Bemästra seriell kommunikation med Arduino

När man arbetar med stora Arduino-projekt är det ganska vanligt att man får slut på tillgängliga stift för att koppla ihop komponenter. Säg att du vill koppla upp flera sensorer/ställdon med det akuta behovet av att fortfarande bevara extra stift för att mata en stifthungrig displaymodul.

Om du inte arbetar med lite magi, är det ibland svårt att hantera alla dessa anslutningar på ett enda Arduino-bräde - speciellt när du bestämmer dig för att använda mindre brädor eftersom du är pressad för utrymme. Det är då seriell kommunikation kommer in i bilden.

Låt oss utforska vad seriell kommunikation är och hur du kan ställa in den med Arduino för uppgifter som distribuerad bearbetning och allmän integration.

Vad är seriell kommunikation?

Seriell kommunikation är en metod för att skicka och ta emot data mellan två eller flera elektroniska enheter, en bit i taget över en enda kommunikationslinje. Som namnet antyder skickas data i "serier".

Även bara att kunna ladda upp skisser till ditt favorit Arduino-kort använder seriell kommunikation via USB.

Seriella kommunikationsprotokoll på Arduino

Arduino-kort är otroligt mångsidiga och kan kommunicera med ett brett utbud av enheter. De stöder fyra seriella kommunikationsprotokoll: Soft Serial, SPI (Serial Peripheral Interface), standard UART (Universal Asynchronous Receiver-Transmitter) och I2C (Inter-Integrated Circuit). För mer information, kolla in vår omfattande guide om hur UART, SPI och I2C seriell kommunikation fungerar.

Den här handledningen använder grundläggande skisser för att visa hur du kan ställa in en seriell anslutning mellan två Arduino Uno-kort med olika protokoll. Anpassa koden för att möta dina specifika krav.

SPI (Serial Peripheral Interface)

SPI är ett synkront seriellt kommunikationsprotokoll som möjliggör höghastighetskommunikation mellan mikrokontroller och kringutrustning. Detta protokoll kräver fyra ledningar för kommunikation: SCK (Serial klocka), MOSI (Master Out Slave In), MISO (Master In Slave Out), och SS (Slavval).

De SPI.h biblioteket är väldigt praktiskt för den här typen av kommunikation och måste inkluderas överst i din skiss.

#omfatta

Här är SPI-stiften på Arduino Uno-kortet:

Efter initialisering av seriell kommunikation måste du konfigurera kommunikationsstiften.

tomhetuppstart(){
SPI.Börja(115200);
// Ställ in stiftlägen för SS, MOSI, MISO och SCK
pinMode(SS, PRODUKTION);
pinMode(MOSI, PRODUKTION);
pinMode(MISO, INMATNING);
pinMode(SCK, PRODUKTION);
// Ställ in slavvalsstiftet (SS) högt för att inaktivera slavenheten
digitalWrite(SS, HÖG);
}

SS-signalen används för att tala om för slavenheten när data överförs.

// Välj slav
digitalWrite(SS, LÅG);
// Skicka data till slavenheten
SPI.överföra(data);
// Avmarkera slavenheten
digitalWrite(SS, HÖG);

Så här ansluter du två Arduino-kort med SPI.

Kod för masterkortet:

#omfatta
konstint slaveSelectPin = 10;
tomhetuppstart(){
SPI.Börja(115200);
pinMode(slaveSelectPin, PRODUKTION);
}
tomhetslinga(){
digitalWrite(slaveSelectPin, LÅG);
SPI.överföra('H');
digitalWrite(slaveSelectPin, HÖG);
dröjsmål(1000);
}

Kod för slavkortet:

#omfatta
konstint slaveSelectPin = 10;
tomhetuppstart(){
SPI.Börja(115200);
pinMode(slaveSelectPin, PRODUKTION);
}
tomhetslinga(){
om (digitalRead(slaveSelectPin) == LÅG) {
röding mottagna Data = SPI.överföra('L');
Serie.println(mottagen Data);
 }
}

Se till att dina enheter har en gemensam grund för korrekt konfiguration.

UART (Universal Asynchronous Receiver-Transmitter)

UART är ett asynkront seriellt kommunikationsprotokoll som tillåter kommunikation mellan enheter med endast två ledningar: TX (sändning) och RX (mottagning). UART används ofta för kommunikation med enheter som GPS-moduler, Bluetooth-moduler och andra mikrokontroller. Varje Arduino-bräda är utrustad med minst en port för UART.

UART-stiften på populära Arduino-brädor inkluderar:

Du kan få hela bordet från Arduinos onlinedokumentation om seriell kommunikation.

Anslut först dina kort så här:

Använd sedan denna kod för avsändarkortet:

tomhetuppstart(){
Serie.Börja(9600);
}
tomhetslinga(){
// Skicka ett meddelande över seriell varje sekund
Serie.println("Hej från avsändarstyrelsen!");
dröjsmål(1000);
}

Kod för mottagarkortet:

tomhetuppstart(){
Serie.Börja(9600);
}
tomhetslinga(){
// Kontrollera om det finns någon inkommande data
om (Serie.tillgängliga() > 0) {
// Läs inkommande data och skriv ut den till den seriella monitorn
Sträng inkommandeData = Serie.readString();
Serie.println(inkommande Data);
 }
}

Arduino Uno arbetar på en 5V logisk nivå medan en dators RS232-port använder en +/-12V logiknivå.

Att direkt ansluta en Arduino Uno till en RS232-port kan och kommer att skada ditt kort.

I2C (Inter-Integrated Circuit)

I2C är ett synkront seriellt kommunikationsprotokoll som tillåter kommunikation mellan flera enheter med endast två ledningar: SDA (Serial Data) och SCL (Serial Clock). I2C används ofta för kommunikation med sensorer, EEPROM och andra enheter som behöver överföra data över korta avstånd.

I2C-stift på Arduino Uno är SDA (A4) och SCL (A5).

Vi kommer att skapa ett enkelt program för att upprätta en anslutning mellan två Arduino-kort med hjälp av I2C-kommunikation. Men först, anslut dina kort så här:

Kod för masterkortet:

#omfatta
tomhetuppstart(){
Tråd.Börja(); // gå med I2C buss som master
Serie.Börja(9600);
}
tomhetslinga(){
Tråd.börja sändning(9); // överför till slavenhet med adress 9
Tråd.skriva('a'); // skickar 'en' byte till slavenhet
Tråd.endTransmission(); // sluta sända
dröjsmål(500);
}

Kod för slavkortet:

#omfatta
tomhetuppstart(){
Tråd.Börja(9); // gå med i I2C-bussen som en slav med adress 9
Tråd.vid ta emot(ta emotEvent);
Serie.Börja(9600); 
}
tomhetslinga(){
dröjsmål(100);
}
tomhetta emotEvent(int byte){
medan(Tråd.tillgängliga()) { // går igenom alla mottagna byte
röding mottagenByte = Tråd.läsa(); // läs varje mottagen byte
Serie.println(receivedByte); // skriv ut mottagen byte på seriell monitor
 }
}

Vad är SoftwareSerial?

Arduino SoftwareSerial-biblioteket utvecklades för att emulera UART-kommunikation, vilket möjliggör seriell kommunikation genom två valfria digitala stift på Arduino-kort. Det är användbart när hårdvaran UART redan används av andra enheter.

För att ställa in SoftwareSerial, inkludera först SoftwareSerial-biblioteket i skissen.

#omfatta

Skapa sedan en instans av SoftwareSerial-objektet genom att ange RX och TX stift som ska användas för kommunikation.

SoftwareSerialmySerial(2, 3); // RX, TX stift

Här är en exempelkod för Arduino som visar användningen av SoftwareSerial:

#omfatta
SoftwareSerialmySerial(2, 3); // RX, TX stift
tomhetuppstart(){
Serie.Börja(9600); // starta hårdvaruserien
 mySerial.Börja(9600); // starta mjuk serie
}
tomhetslinga(){
om (mySerial.tillgängliga()) {
Serie.skriva(mySerial.läsa()); // skicka mottagen data till hårdvaruserien
 }
om (Serie.tillgängliga()) {
 mySerial.skriva(Serie.läsa()); // skicka data från hårdvaruserie till mjuk serie
 }
}

Seriebiblioteket

Seriebiblioteket är ett kraftfullt verktyg i Arduino som möjliggör kommunikation mellan mikrokontrollern och en dator eller andra enheter via en seriell anslutning. Några vanliga funktioner inkluderar:

Baudhastighet och seriellt dataformat

Baudhastigheten hänvisar till den hastighet med vilken data överförs över den seriella anslutningen. Det representerar antalet bitar som sänds per sekund. Baudraten måste ställas in på samma sätt på både sändar- och mottagarenheterna, annars kan kommunikationen vara förvrängd eller inte fungera alls. Vanliga baudpriser för Arduino inkluderar 9600, 19200, 38400 och 115200.

Seriellt dataformat hänvisar till strukturen för de data som skickas över den seriella anslutningen. Det finns tre huvudkomponenter för seriellt dataformat: startbitar, databitar och stoppbitar.

• Databitar: Antalet bitar som används för att representera en enda databyte.
• Paritet: En valfri bit som används för felkontroll. Den kan ställas in på ingen, jämn eller udda paritet, beroende på kommunikationskanalens krav.
• Stop Bits: Antalet bitar som används för att signalera slutet på en databyte.

Dataformatet måste vara detsamma på både sändande och mottagande enheter för att säkerställa korrekt kommunikation. Här är ett exempel på hur du kan ställa in specifika dataformat:

tomhetuppstart(){
// Ställ in seriell kommunikation med 9600 baudhastighet, 8 databitar, ingen paritet och 1 stoppbit
Serie.Börja(9600, SERIAL_8N1); 
}

Här, SERIAL_8N1 representerar dataformatet med 8 databitar, ingen paritet och 1 stopp bit. Andra alternativ som t.ex SERIAL_7E1, SERIAL_8O2, etc., kan användas beroende på projektets specifika krav.

Serial Talk

Arduino-kort tillhandahåller olika seriella kommunikationsalternativ som möjliggör effektivt och tillförlitligt datautbyte mellan enheter. Genom att förstå hur man ställer in seriella kommunikationsprotokoll på Arduino IDE kan du dra nytta av kraften i distribuerad bearbetning eller avsevärt minska antalet ledningar som används i dina projekt.