Mestring av seriekommunikasjon med Arduino

Når du jobber med store Arduino-prosjekter, er det ganske vanlig å gå tom for tilgjengelige pinner for å koble sammen komponenter. La oss si at du vil koble til flere sensorer/aktuatorer med det presserende behovet for fortsatt å beholde ekstra pinner for å mate en pin-hungrig skjermmodul.

Med mindre du jobber med litt magi, er det noen ganger vanskelig å håndtere alle disse forbindelsene på et enkelt Arduino-brett – spesielt når du bestemmer deg for å bruke mindre brett fordi du er presset for plass. Det er da seriekommunikasjon kommer inn.

La oss utforske hva seriekommunikasjon er og måtene du kan sette den opp med Arduino for oppgaver som distribuert prosessering og generell integrasjon.

Hva er seriell kommunikasjon?

Seriell kommunikasjon er en metode for å sende og motta data mellom to eller flere elektroniske enheter, en bit om gangen over en enkelt kommunikasjonslinje. Som navnet antyder, blir data sendt i "serier".

Selv bare det å kunne laste opp skisser til ditt favoritt Arduino-kort bruker seriell kommunikasjon over USB.

Serielle kommunikasjonsprotokoller på Arduino

Arduino-kort er utrolig allsidige og kan kommunisere med et bredt spekter av enheter. De støtter fire serielle kommunikasjonsprotokoller: Soft Serial, SPI (Serial Peripheral Interface), standard UART (Universal Asynchronous Receiver-Transmitter) og I2C (Inter-Integrated Circuit). For mer informasjon, sjekk ut vår omfattende veiledning om hvordan UART, SPI og I2C seriell kommunikasjon fungerer.

Denne opplæringen bruker grunnleggende skisser for å vise hvordan du kan sette opp en seriell forbindelse mellom to Arduino Uno-kort ved hjelp av forskjellige protokoller. Tilpass koden for å møte dine spesifikke krav.

SPI (Serial Peripheral Interface)

SPI er en synkron seriell kommunikasjonsprotokoll som tillater høyhastighetskommunikasjon mellom mikrokontrollere og perifere enheter. Denne protokollen krever fire ledninger for kommunikasjon: SCK (Serieklokke), MOSI (Master Out Slave In), MISO (Master In Slave Out), og SS (Slave Select).

De SPI.h biblioteket er veldig nyttig for denne typen kommunikasjon og må inkluderes øverst på skissen din.

#inkludere

Her er SPI-pinnene på Arduino Uno-kortet:

Etter initialisering av seriell kommunikasjon, må du konfigurere kommunikasjonspinnene.

tomromoppsett(){
SPI.begynne(115200);
// Angi pin-modi for SS, MOSI, MISO og SCK
pin-modus(SS, PRODUKSJON);
pin-modus(MOSI, PRODUKSJON);
pin-modus(MISO, INNGANG);
pin-modus(SCK, PRODUKSJON);
// Sett slave select (SS) pin høy for å deaktivere slaveenheten
digitalWrite(SS, HØY);
}

SS-signalet brukes til å fortelle slaveenheten når data overføres.

// Velg slaven
digitalWrite(SS, LAV);
// Send data til slaveenheten
SPI.overføre(data);
// Fjern markeringen av slaveenheten
digitalWrite(SS, HØY);

Slik kobler du sammen to Arduino-kort ved hjelp av SPI.

Kode for hovedkortet:

#inkludere
konstint slaveSelectPin = 10;
tomromoppsett(){
SPI.begynne(115200);
pin-modus(slaveSelectPin, PRODUKSJON);
}
tomromLøkke(){
digitalWrite(slaveSelectPin, LAV);
SPI.overføre('H');
digitalWrite(slaveSelectPin, HØY);
forsinkelse(1000);
}

Kode for slavekortet:

#inkludere
konstint slaveSelectPin = 10;
tomromoppsett(){
SPI.begynne(115200);
pin-modus(slaveSelectPin, PRODUKSJON);
}
tomromLøkke(){
hvis (digitallest(slaveSelectPin) == LAV) {
røye mottatt Data = SPI.overføre('L');
Seriell.println(mottatt Data);
 }
}

Sørg for at enhetene dine deler en felles grunn for riktig konfigurasjon.

UART (Universal Asynchronous Receiver-Transmitter)

UART er en asynkron seriell kommunikasjonsprotokoll som tillater kommunikasjon mellom enheter ved bruk av kun to ledninger: TX (overføring) og RX (mottak). UART brukes ofte for kommunikasjon med enheter som GPS-moduler, Bluetooth-moduler og andre mikrokontrollere. Hvert Arduino-brett er utstyrt med minst én port for UART.

UART-pinnene på populære Arduino-brett inkluderer:

Du kan få hele bordet fra Arduinos nettdokumentasjon om seriell kommunikasjon.

Først kobler du brettene dine slik:

Bruk deretter denne koden for avsenderkortet:

tomromoppsett(){
Seriell.begynne(9600);
}
tomromLøkke(){
// Send en melding over serien hvert sekund
Seriell.println("Hei fra avsendertavlen!");
forsinkelse(1000);
}

Kode for mottakerkortet:

tomromoppsett(){
Seriell.begynne(9600);
}
tomromLøkke(){
// Sjekk om det er noen innkommende data
hvis (Seriell.tilgjengelig() > 0) {
// Les de innkommende dataene og skriv dem ut til seriemonitoren
String innkommende Data = Seriell.readString();
Seriell.println(innkommende Data);
 }
}

Arduino Uno opererer på et 5V logisk nivå mens en datamaskins RS232-port bruker et +/-12V logikknivå.

Å koble en Arduino Uno direkte til en RS232-port kan og vil skade brettet ditt.

I2C (inter-integrert krets)

I2C er en synkron seriell kommunikasjonsprotokoll som tillater kommunikasjon mellom flere enheter ved bruk av kun to ledninger: SDA (Serial Data) og SCL (Serial Clock). I2C brukes ofte til kommunikasjon med sensorer, EEPROM-er og andre enheter som trenger å overføre data over korte avstander.

I2C-pinner på Arduino Uno er SDA (A4) og SCL (A5).

Vi vil lage et enkelt program for å etablere en forbindelse mellom to Arduino-kort ved hjelp av I2C-kommunikasjon. Men først kobler du brettene dine slik:

Kode for hovedkortet:

#inkludere
tomromoppsett(){
Metalltråd.begynne(); // bli med I2C buss som master
Seriell.begynne(9600);
}
tomromLøkke(){
Metalltråd.begynne overføring(9); // send til slaveenhet med adresse 9
Metalltråd.skrive('en'); // sender 'en' byte til slaveenheten
Metalltråd.endTransmission(); // slutte å sende
forsinkelse(500);
}

Kode for slavekortet:

#inkludere
tomromoppsett(){
Metalltråd.begynne(9); // bli med I2C-buss som en slave med adresse 9
Metalltråd.på Motta(mottaEvent);
Seriell.begynne(9600); 
}
tomromLøkke(){
forsinkelse(100);
}
tomrommottaEvent(int bytes){
samtidig som(Metalltråd.tilgjengelig()) { // går gjennom alle mottatte bytes
røye receiveByte = Metalltråd.lese(); // les hver mottatt byte
Seriell.println(mottattByte); // skriv ut mottatt byte på seriell monitor
 }
}

Hva er SoftwareSerial?

Arduino SoftwareSerial-biblioteket ble utviklet for å etterligne UART-kommunikasjon, og tillater seriell kommunikasjon gjennom alle to digitale pinner på Arduino-kort. Det er nyttig når maskinvaren UART allerede er i bruk av andre enheter.

For å sette opp SoftwareSerial må du først inkludere SoftwareSerial-biblioteket i skissen.

#inkludere

Deretter oppretter du en forekomst av SoftwareSerial-objektet ved å spesifisere RX og TX pinner som skal brukes til kommunikasjon.

ProgramvareseriemySerial(2, 3); // RX, TX pinner

Her er en eksempelkode for Arduino som demonstrerer bruken av SoftwareSerial:

#inkludere
ProgramvareseriemySerial(2, 3); // RX, TX pinner
tomromoppsett(){
Seriell.begynne(9600); // start maskinvareserien
 mySerial.begynne(9600); // start myk serie
}
tomromLøkke(){
hvis (mySerial.tilgjengelig()) {
Seriell.skrive(mySerial.lese()); // send mottatte data til maskinvareserie
 }
hvis (Seriell.tilgjengelig()) {
 mySerial.skrive(Seriell.lese()); // send data fra maskinvareserie til myk serie
 }
}

Seriebiblioteket

Seriebiblioteket er et kraftig verktøy i Arduino som tillater kommunikasjon mellom mikrokontrolleren og en datamaskin eller andre enheter via en seriell tilkobling. Noen vanlige funksjoner inkluderer:

Baudhastighet og seriedataformat

Baudhastighet refererer til hastigheten som data overføres med over den serielle forbindelsen. Den representerer antall biter som sendes per sekund. Baudraten må settes likt på både sender- og mottakerenheten, ellers kan kommunikasjonen bli forvansket eller ikke fungere i det hele tatt. Vanlige baudrater for Arduino inkluderer 9600, 19200, 38400 og 115200.

Serielt dataformat refererer til strukturen til dataene som sendes over den serielle forbindelsen. Det er tre hovedkomponenter til seriell dataformat: startbiter, databiter og stoppbiter.

• Databiter: Antall biter som brukes til å representere en enkelt databyte.
• Paritet: En valgfri bit som brukes til feilkontroll. Den kan settes til ingen, partall eller oddetall, avhengig av kravene til kommunikasjonskanalen.
• Stoppbiter: Antall biter som brukes til å signalisere slutten av en databyte.

Dataformatet må være det samme på både sender- og mottaksenheten for å sikre riktig kommunikasjon. Her er et eksempel på hvordan du kan angi spesifikke dataformater:

tomromoppsett(){
// Sett opp seriell kommunikasjon med 9600 baudhastighet, 8 databiter, ingen paritet og 1 stoppbit
Seriell.begynne(9600, SERIAL_8N1); 
}

Her, SERIAL_8N1 representerer dataformatet med 8 databiter, ingen paritet, og 1 stopp litt. Andre alternativer som f.eks SERIAL_7E1, SERIAL_8O2, etc., kan brukes avhengig av de spesifikke kravene til prosjektet.

Serial Talk

Arduino-kort gir ulike serielle kommunikasjonsalternativer som muliggjør effektiv og pålitelig datautveksling mellom enheter. Ved å forstå hvordan du setter opp serielle kommunikasjonsprotokoller på Arduino IDE, kan du utnytte kraften til distribuert prosessering eller redusere antallet ledninger som brukes i prosjektene dine.