Beheersing van seriële communicatie met Arduino

Bij het werken aan grote Arduino-projecten is het vrij normaal dat er geen beschikbare pinnen meer zijn om componenten aan te sluiten. Stel dat u meerdere sensoren/actuators wilt aansluiten met de dringende noodzaak om nog steeds extra pinnen te behouden om een ​​pin-hongerige displaymodule te voeden.

Tenzij je wat magie gebruikt, is het soms moeilijk om al deze verbindingen op een enkel Arduino-bord te verwerken, vooral als je besluit om kleinere borden te gebruiken omdat je weinig ruimte hebt. Dat is wanneer seriële communicatie in het spel komt.

Laten we eens kijken wat seriële communicatie is en de manieren waarop je het met Arduino kunt instellen voor taken als gedistribueerde verwerking en algemene integratie.

Wat is seriële communicatie?

Seriële communicatie is een methode voor het verzenden en ontvangen van gegevens tussen twee of meer elektronische apparaten, bit voor bit via een enkele communicatielijn. Zoals de naam al doet vermoeden, worden gegevens in "series" verzonden

".

Zelfs het uploaden van schetsen naar je favoriete Arduino-bord maakt gebruik van seriële communicatie via USB.

Seriële communicatieprotocollen op Arduino

Arduino-borden zijn ongelooflijk veelzijdig en kunnen communiceren met een breed scala aan apparaten. Ze ondersteunen vier seriële communicatieprotocollen: Soft Serial, SPI (Serial Peripheral Interface), standaard UART (Universal Asynchronous Receiver-Transmitter) en I2C (Inter-Integrated Circuit). Raadpleeg voor meer informatie onze uitgebreide gids over hoe UART, SPI en I2C seriële communicatie werken.

Deze tutorial gebruikt basisschetsen om te laten zien hoe je een seriële verbinding tussen twee Arduino Uno-kaarten kunt opzetten met behulp van verschillende protocollen. Pas de code aan uw specifieke wensen aan.

SPI (seriële perifere interface)

SPI is een synchroon serieel communicatieprotocol dat snelle communicatie tussen microcontrollers en randapparatuur mogelijk maakt. Dit protocol vereist vier draden voor communicatie: SCK (seriële klok), MOSI (Master Uit Slave In), MISO (Master In Slave Out), en SS (Slave selecteren).

De SPI.h bibliotheek is erg handig voor dit soort communicatie en moet bovenaan je schets worden opgenomen.

#erbij betrekken

Dit zijn de SPI-pinnen op het Arduino Uno-bord:

Nadat u de seriële communicatie hebt geïnitialiseerd, moet u de communicatiepennen configureren.

leegteopgericht(){
SPI.beginnen(115200);
// Stel pin-modi in voor SS, MOSI, MISO en SCK
pinMode(SS, UITVOER);
pinMode(MOSI, UITVOER);
pinMode(MISO, INVOER);
pinMode(SCK, UITVOER);
// Stel de slave select (SS) pin hoog in om het slave-apparaat uit te schakelen
digitaalSchrijven(SS, HOOG);
}

Het SS-signaal wordt gebruikt om het slave-apparaat te vertellen wanneer gegevens worden overgedragen.

// Selecteer de slaaf
digitaalSchrijven(SS, LAAG);
// Stuur gegevens naar het slave-apparaat
SPI.overdracht(gegevens);
// Deselecteer het slave-apparaat
digitaalSchrijven(SS, HOOG);

Hier leest u hoe u twee Arduino-kaarten kunt verbinden met behulp van SPI.

Code voor het hoofdbord:

#erbij betrekken
constint slaveSelectPin = 10;
leegteopgericht(){
SPI.beginnen(115200);
pinMode(slaveSelectPin, UITVOER);
}
leegtelus(){
digitaalSchrijven(slaveSelectPin, LAAG);
SPI.overdracht('H');
digitaalSchrijven(slaveSelectPin, HOOG);
vertraging(1000);
}

Code voor het slave-bord:

#erbij betrekken
constint slaveSelectPin = 10;
leegteopgericht(){
SPI.beginnen(115200);
pinMode(slaveSelectPin, UITVOER);
}
leegtelus(){
als (digitaal lezen(slaveSelectPin) == LAAG) {
char ontvangenData = SPI.overdracht('L');
Serieel.println(ontvangen data);
 }
}

Zorg ervoor dat uw apparaten een gemeenschappelijke basis delen voor een juiste configuratie.

UART (Universele Asynchrone Ontvanger-Zender)

UART is een asynchroon serieel communicatieprotocol dat communicatie tussen apparaten mogelijk maakt met slechts twee kabels: TX (verzenden) en RX (ontvangen). UART wordt vaak gebruikt voor communicatie met apparaten zoals GPS-modules, Bluetooth-modules en andere microcontrollers. Elk Arduino-bord is uitgerust met ten minste één poort voor UART.

De UART-pinnen op populaire Arduino-borden zijn onder andere:

U kunt de volledige tafel krijgen van Arduino's online documentatie over seriële communicatie.

Verbind eerst je boards als volgt:

Gebruik dan deze code voor het zenderbord:

leegteopgericht(){
Serieel.beginnen(9600);
}
leegtelus(){
// Stuur elke seconde een bericht via serieel
Serieel.println("Hallo van het afzenderbord!");
vertraging(1000);
}

Code voor het ontvangerbord:

leegteopgericht(){
Serieel.beginnen(9600);
}
leegtelus(){
// Controleer of er binnenkomende gegevens zijn
als (Serieel.beschikbaar() > 0) {
// Lees de binnenkomende gegevens en print deze naar de seriële monitor
Snaar inkomende gegevens = Serieel.readString();
Serieel.println(inkomende gegevens);
 }
}

De Arduino Uno werkt op een logisch niveau van 5V, terwijl de RS232-poort van een computer een logisch niveau van +/-12V gebruikt.

Het rechtstreeks aansluiten van een Arduino Uno op een RS232-poort kan en zal uw bord beschadigen.

I2C (Inter-geïntegreerd circuit)

I2C is een synchroon serieel communicatieprotocol dat communicatie tussen meerdere apparaten mogelijk maakt met slechts twee kabels: SDA (Serial Data) en SCL (Serial Clock). I2C wordt vaak gebruikt voor communicatie met sensoren, EEPROM's en andere apparaten die gegevens over korte afstanden moeten overbrengen.

I2C-pinnen op de Arduino Uno zijn SDA (A4) En SCL (A5).

We zullen een eenvoudig programma maken om een ​​verbinding tot stand te brengen tussen twee Arduino-kaarten met behulp van I2C-communicatie. Maar verbind eerst je boards als volgt:

Code voor het hoofdbord:

#erbij betrekken
leegteopgericht(){
Draad.beginnen(); // word lid van de I2C-bus als master
Serieel.beginnen(9600);
}
leegtelus(){
Draad.beginVerzending(9); // verzenden naar slave-apparaat met adres 9
Draad.schrijven('A'); // stuurt 'a' byte naar slave-apparaat
Draad.eindtransmissie(); // stop met verzenden
vertraging(500);
}

Code voor het slave-bord:

#erbij betrekken
leegteopgericht(){
Draad.beginnen(9); // word lid van de I2C-bus als een slaaf met adres 9
Draad.opOntvangen(gebeurtenis ontvangen);
Serieel.beginnen(9600); 
}
leegtelus(){
vertraging(100);
}
leegteontvangstgebeurtenis(int bytes){
terwijl(Draad.beschikbaar()) { // doorloop alle ontvangen bytes
char ontvangenByte = Draad.lezen(); // lees elke ontvangen byte
Serieel.println(ontvangenByte); // print ontvangen byte op seriële monitor
 }
}

Wat is SoftwareSerial?

De Arduino SoftwareSerial-bibliotheek is ontwikkeld om UART-communicatie na te bootsen, waardoor seriële communicatie mogelijk is via twee willekeurige digitale pinnen op Arduino-borden. Het is handig wanneer de hardware-UART al door andere apparaten wordt gebruikt.

Om SoftwareSerial in te stellen, neemt u eerst de SoftwareSerial-bibliotheek op in de schets.

#erbij betrekken

Maak vervolgens een instantie van het SoftwareSerial-object door de RX En TX pinnen om te gebruiken voor communicatie.

SoftwareserieelmijnSerial(2, 3); // RX, TX-pinnen

Hier is een voorbeeldcode voor Arduino die het gebruik van SoftwareSerial demonstreert:

#erbij betrekken
SoftwareserieelmijnSerial(2, 3); // RX, TX-pinnen
leegteopgericht(){
Serieel.beginnen(9600); // start hardware serieel
 mijnSerial.beginnen(9600); // start zachte seriële
}
leegtelus(){
als (mijnSerial.beschikbaar()) {
Serieel.schrijven(mijnSerial.lezen()); // stuur ontvangen gegevens naar hardwareserieel
 }
als (Serieel.beschikbaar()) {
 mijnSerial.schrijven(Serieel.lezen()); // stuur gegevens van hardwareserieel naar zacht serieel
 }
}

De seriële bibliotheek

De seriële bibliotheek is een krachtige tool in Arduino die communicatie mogelijk maakt tussen de microcontroller en een computer of andere apparaten via een seriële verbinding. Enkele veel voorkomende functies zijn:

Baudsnelheid en serieel gegevensformaat

Baud rate verwijst naar de snelheid waarmee gegevens worden overgedragen via de seriële verbinding. Het vertegenwoordigt het aantal bits dat per seconde wordt verzonden. De baudrate moet hetzelfde worden ingesteld op zowel de zender als de ontvanger, anders kan de communicatie onleesbaar zijn of helemaal niet werken. Gangbare baudrates voor Arduino zijn 9600, 19200, 38400 en 115200.

Het seriële gegevensformaat verwijst naar de structuur van de gegevens die via de seriële verbinding worden verzonden. Er zijn drie hoofdcomponenten voor het seriële gegevensformaat: startbits, databits en stopbits.

• Gegevensbits: Het aantal bits dat wordt gebruikt om een ​​enkele gegevensbyte weer te geven.
• Pariteit: Een optionele bit die wordt gebruikt voor foutcontrole. Het kan worden ingesteld op geen, even of oneven pariteit, afhankelijk van de vereisten van het communicatiekanaal.
• Bits stoppen: Het aantal bits dat wordt gebruikt om het einde van een databyte aan te geven.

Het gegevensformaat moet hetzelfde zijn op zowel de verzendende als de ontvangende apparaten om een ​​goede communicatie te garanderen. Hier is een voorbeeld van hoe u specifieke gegevensindelingen kunt instellen:

leegteopgericht(){
// Stel seriële communicatie in met een baudrate van 9600, 8 databits, geen pariteit en 1 stopbit
Serieel.beginnen(9600, SERIAL_8N1); 
}

Hier, SERIAL_8N1 vertegenwoordigt het gegevensformaat met 8 databits, geen pariteit, en 1 stop beetje. Andere mogelijkheden zoals SERIAL_7E1, SERIAL_8O2, enz. kunnen worden gebruikt afhankelijk van de specifieke vereisten van het project.

Serieel praten

Arduino-kaarten bieden verschillende seriële communicatie-opties die een efficiënte en betrouwbare gegevensuitwisseling tussen apparaten mogelijk maken. Door te begrijpen hoe u seriële communicatieprotocollen op de Arduino IDE instelt, kunt u de kracht van gedistribueerde verwerking benutten of het aantal draden dat in uw projecten wordt gebruikt aanzienlijk verminderen.