Beherrschen der seriellen Kommunikation mit Arduino

Bei der Arbeit an großen Arduino-Projekten ist es üblich, dass die verfügbaren Pins zum Anschließen von Komponenten ausgehen. Angenommen, Sie möchten mehrere Sensoren/Aktoren anschließen, müssen aber dringend zusätzliche Pins erhalten, um ein Pin-hungriges Anzeigemodul zu versorgen.

Wenn Sie nicht ein bisschen zaubern, ist es manchmal schwierig, all diese Verbindungen auf einem einzigen Arduino-Board zu handhaben – besonders wenn Sie sich entscheiden, kleinere Boards zu verwenden, weil Sie wenig Platz haben. Hier kommt die serielle Kommunikation ins Spiel.

Lassen Sie uns untersuchen, was serielle Kommunikation ist und wie Sie sie mit Arduino für Aufgaben wie verteilte Verarbeitung und allgemeine Integration einrichten können.

Was ist serielle Kommunikation?

Serielle Kommunikation ist eine Methode zum Senden und Empfangen von Daten zwischen zwei oder mehr elektronischen Geräten, Bit für Bit über eine einzige Kommunikationsleitung. Wie der Name schon sagt, werden Daten in "Serien" gesendet

".

Selbst wenn Sie nur Skizzen auf Ihr bevorzugtes Arduino-Board hochladen können, wird die serielle Kommunikation über USB verwendet.

Serielle Kommunikationsprotokolle auf Arduino

Arduino-Boards sind unglaublich vielseitig und können mit einer Vielzahl von Geräten kommunizieren. Sie unterstützen vier serielle Kommunikationsprotokolle: Soft Serial, SPI (Serial Peripheral Interface), Standard-UART (Universal Asynchronous Receiver-Transmitter) und I2C (Inter-Integrated Circuit). Weitere Informationen finden Sie in unserem umfassenden Leitfaden zu wie die serielle UART-, SPI- und I2C-Kommunikation funktioniert.

Dieses Tutorial zeigt anhand grundlegender Skizzen, wie Sie eine serielle Verbindung zwischen zwei Arduino Uno-Boards mit verschiedenen Protokollen einrichten können. Passen Sie den Code an Ihre spezifischen Anforderungen an.

SPI (Serial Peripheral Interface)

SPI ist ein synchrones serielles Kommunikationsprotokoll, das eine Hochgeschwindigkeitskommunikation zwischen Mikrocontrollern und Peripheriegeräten ermöglicht. Dieses Protokoll erfordert vier Drähte für die Kommunikation: SCK (Serienuhr), MOSI (Master Out Slave In), MISO (Master In Slave Out) und SS (Slave-Auswahl).

Der SPI.h Die Bibliothek ist für diese Art der Kommunikation sehr praktisch und muss oben in Ihrer Skizze enthalten sein.

#enthalten

Hier sind die SPI-Pins auf dem Arduino Uno-Board:

Nach der Initialisierung der seriellen Kommunikation müssen Sie die Kommunikationspins konfigurieren.

Leereaufstellen(){
SPI.Start(115200);
// Pin-Modi für SS, MOSI, MISO und SCK einstellen
pinMode(SS, AUSGANG);
pinMode(MOSI, AUSGANG);
pinMode(MISO, EINGANG);
pinMode(SCK, AUSGANG);
// Setzen Sie den Slave-Select-Pin (SS) auf High, um das Slave-Gerät zu deaktivieren
digitalWrite(SS, HOCH);
}

Das SS-Signal wird verwendet, um dem Slave-Gerät mitzuteilen, wann Daten übertragen werden.

// Wählen Sie den Sklaven aus
digitalWrite(SS, NIEDRIG);
// Daten an das Slave-Gerät senden
SPI.überweisen(Daten);
// Das Slave-Gerät abwählen
digitalWrite(SS, HOCH);

So verbinden Sie zwei Arduino-Boards mit SPI.

Code für das Masterboard:

#enthalten
konstint slaveSelectPin = 10;
Leereaufstellen(){
SPI.Start(115200);
pinMode(slaveSelectPin, AUSGANG);
}
LeereSchleife(){
digitalWrite(slaveSelectPin, NIEDRIG);
SPI.überweisen('H');
digitalWrite(slaveSelectPin, HOCH);
Verzögerung(1000);
}

Code für das Slave-Board:

#enthalten
konstint slaveSelectPin = 10;
Leereaufstellen(){
SPI.Start(115200);
pinMode(slaveSelectPin, AUSGANG);
}
LeereSchleife(){
Wenn (digitalLesen(slaveSelectPin) == NIEDRIG) {
verkohlen empfangeneDaten = SPI.überweisen('L');
Seriell.println(empfangene Daten);
 }
}

Stellen Sie sicher, dass Ihre Geräte für eine ordnungsgemäße Konfiguration eine gemeinsame Erdung haben.

UART (Universeller asynchroner Empfänger-Sender)

UART ist ein asynchrones serielles Kommunikationsprotokoll, das die Kommunikation zwischen Geräten mit nur zwei Drähten ermöglicht: TX (Senden) und RX (Empfangen). UART wird häufig für die Kommunikation mit Geräten wie GPS-Modulen, Bluetooth-Modulen und anderen Mikrocontrollern verwendet. Jedes Arduino-Board ist mit mindestens einem Port für UART ausgestattet.

Zu den UART-Pins auf gängigen Arduino-Boards gehören:

Die vollständige Tabelle erhalten Sie unter Arduinos Online-Dokumentation über serielle Kommunikation.

Verbinden Sie zuerst Ihre Platinen wie folgt:

Dann verwenden Sie diesen Code für das Absenderboard:

Leereaufstellen(){
Seriell.Start(9600);
}
LeereSchleife(){
// Senden Sie jede Sekunde eine Nachricht über seriell
Seriell.println("Hallo vom Absender-Board!");
Verzögerung(1000);
}

Code für die Empfängerplatine:

Leereaufstellen(){
Seriell.Start(9600);
}
LeereSchleife(){
// Prüfen, ob Daten eingehen
Wenn (Seriell.verfügbar() > 0) {
// Lesen Sie die eingehenden Daten und geben Sie sie auf dem seriellen Monitor aus
Schnur eingehende Daten = Seriell.readString();
Seriell.println(eingehende Daten);
 }
}

Der Arduino Uno arbeitet mit einem 5-V-Logikpegel, während der RS232-Anschluss eines Computers einen +/-12-V-Logikpegel verwendet.

Das direkte Anschließen eines Arduino Uno an einen RS232-Port kann und wird Ihr Board beschädigen.

I2C (Interintegrierter Schaltkreis)

I2C ist ein synchrones serielles Kommunikationsprotokoll, das die Kommunikation zwischen mehreren Geräten mit nur zwei Drähten ermöglicht: SDA (Serial Data) und SCL (Serial Clock). I2C wird häufig für die Kommunikation mit Sensoren, EEPROMs und anderen Geräten verwendet, die Daten über kurze Entfernungen übertragen müssen.

I2C-Pins auf dem Arduino Uno sind SDA (A4) Und SCL (A5).

Wir werden ein einfaches Programm erstellen, um eine Verbindung zwischen zwei Arduino-Boards mithilfe der I2C-Kommunikation herzustellen. Aber zuerst verbinden Sie Ihre Platinen wie folgt:

Code für das Masterboard:

#enthalten
Leereaufstellen(){
Kabel.Start(); // dem I2C-Bus als Master beitreten
Seriell.Start(9600);
}
LeereSchleife(){
Kabel.beginÜbertragung(9); // an Slave-Gerät mit Adresse 9 senden
Kabel.schreiben('A'); // sendet 'a' Byte an das Slave-Gerät
Kabel.EndeÜbertragung(); // Übertragung beenden
Verzögerung(500);
}

Code für das Slave-Board:

#enthalten
Leereaufstellen(){
Kabel.Start(9); // dem I2C-Bus als Slave mit Adresse 9 beitreten
Kabel.onReceive(Empfangsereignis);
Seriell.Start(9600); 
}
LeereSchleife(){
Verzögerung(100);
}
LeereEmpfangsereignis(int Bytes){
während(Kabel.verfügbar()) { // Alle empfangenen Bytes durchlaufen
verkohlen empfangenByte = Kabel.lesen(); // jedes empfangene Byte lesen
Seriell.println(empfangenes Byte); // Empfangenes Byte auf seriellem Monitor drucken
 }
}

Was ist SoftwareSerial?

Die Arduino SoftwareSerial-Bibliothek wurde entwickelt, um die UART-Kommunikation zu emulieren und eine serielle Kommunikation über zwei beliebige digitale Pins auf Arduino-Boards zu ermöglichen. Dies ist nützlich, wenn der Hardware-UART bereits von anderen Geräten verwendet wird.

Um SoftwareSerial einzurichten, schließen Sie zunächst die SoftwareSerial-Bibliothek in die Skizze ein.

#enthalten

Erstellen Sie dann eine Instanz des SoftwareSerial-Objekts, indem Sie die angeben Empfang Und Senden Pins, die für die Kommunikation verwendet werden.

SoftwareSerialmeineSerial(2, 3); // RX-, TX-Pins

Hier ist ein Beispielcode für Arduino, der die Verwendung von SoftwareSerial demonstriert:

#enthalten
SoftwareSerialmeineSerial(2, 3); // RX-, TX-Pins
Leereaufstellen(){
Seriell.Start(9600); // Hardware seriell starten
 meineSerial.Start(9600); // Softserie starten
}
LeereSchleife(){
Wenn (meineSerial.verfügbar()) {
Seriell.schreiben(meineSerial.lesen()); // Empfangene Daten an Hardware Serial senden
 }
Wenn (Seriell.verfügbar()) {
 meineSerial.schreiben(Seriell.lesen()); // Daten von Hardware-Seriell zu Soft-Seriell senden
 }
}

Die serielle Bibliothek

Die serielle Bibliothek ist ein leistungsstarkes Werkzeug in Arduino, das die Kommunikation zwischen dem Mikrocontroller und einem Computer oder anderen Geräten über eine serielle Verbindung ermöglicht. Einige allgemeine Funktionen umfassen:

Baudrate und serielles Datenformat

Die Baudrate bezieht sich auf die Geschwindigkeit, mit der Daten über die serielle Verbindung übertragen werden. Es stellt die Anzahl der Bits dar, die pro Sekunde übertragen werden. Die Baudrate muss bei Sender- und Empfängergerät gleich eingestellt sein, sonst kann die Kommunikation verstümmelt werden oder gar nicht funktionieren. Gängige Baudraten für Arduino sind 9600, 19200, 38400 und 115200.

Das serielle Datenformat bezieht sich auf die Struktur der Daten, die über die serielle Verbindung gesendet werden. Das serielle Datenformat besteht aus drei Hauptkomponenten: Startbits, Datenbits und Stoppbits.

• Daten Bits: Die Anzahl der Bits, die verwendet werden, um ein einzelnes Datenbyte darzustellen.
• Parität: Ein optionales Bit, das zur Fehlerprüfung verwendet wird. Sie kann je nach den Anforderungen des Kommunikationskanals auf keine, gerade oder ungerade Parität eingestellt werden.
• Stopp-Bits: Die Anzahl der Bits, die verwendet werden, um das Ende eines Datenbytes zu signalisieren.

Das Datenformat muss sowohl auf dem sendenden als auch auf dem empfangenden Gerät gleich sein, um eine ordnungsgemäße Kommunikation zu gewährleisten. Hier ein Beispiel, wie Sie bestimmte Datenformate einstellen können:

Leereaufstellen(){
// Serielle Kommunikation mit 9600 Baudrate, 8 Datenbits, keine Parität und 1 Stoppbit einrichten
Seriell.Start(9600, SERIAL_8N1); 
}

Hier, SERIAL_8N1 repräsentiert das Datenformat mit 8 Datenbits, keine Parität und 1 Stoppbit. Andere Optionen wie z SERIE_7E1, SERIE_8O2, usw. können je nach den spezifischen Anforderungen des Projekts verwendet werden.

Serielles Gespräch

Arduino-Boards bieten verschiedene serielle Kommunikationsoptionen, die einen effizienten und zuverlässigen Datenaustausch zwischen Geräten ermöglichen. Wenn Sie verstehen, wie Sie serielle Kommunikationsprotokolle in der Arduino IDE einrichten, können Sie die Leistungsfähigkeit der verteilten Verarbeitung nutzen oder die Anzahl der in Ihren Projekten verwendeten Drähte erheblich reduzieren.