Raspberry Pi Arduino serielle Kommunikation – Alles, was Sie wissen müssen

BY admin
|

In diesem Tutorial zeige ich Ihnen, wie Sie zwischen einem Raspberry Pi und einem Arduino-Board über serielle Kommunikation kommunizieren.

Zuerst werde ich schnell erklären, was serielle Kommunikation ist. Dann werden Sie sehen, wie Sie Ihre Hardware und Software einrichten, und wir werden in den Python-Code (Cpp für Arduino) eintauchen. Zunächst ein grundlegendes Beispiel, das zu einer vollständigeren Anwendung mit einem Raspberry Pi, einem Arduino und anderen elektronischen Geräten führt.

Dieses Tutorial funktioniert mit einem Raspberry Pi 4 (und früher: 3B, 3B+) Board und jedem Arduino Board. Ich werde hauptsächlich Arduino Uno verwenden, aber mehr Details über die Unterschiede zwischen Arduino-Boards geben, wenn es um serielle Kommunikation geht.

Bei der Arbeit mit elektronischen Geräten ist Kommunikation der Schlüssel. Jedes Gerät muss – zusätzlich zu dem, was es tun soll – in der Lage sein, klar mit anderen Geräten zu kommunizieren. Das ist eines der wichtigsten Dinge, an denen man arbeiten muss, um von einer sehr einfachen Anwendung zu komplexeren zu wechseln.

Inhaltsverzeichnis

Was ist Serielle kommunikation (mit UART)

Serielle kommunikation ist einfach eine Möglichkeit, Daten zu übertragen. Die Daten werden nacheinander Bit für Bit gesendet (1 Byte = 8 Bit), im Gegensatz zur parallelen Kommunikation, bei der viele Bits gleichzeitig gesendet werden.

UART-Protokoll

Genauer gesagt, wenn Sie seriell mit Arduino und Raspberry Pi verwenden, verwenden Sie das UART-Protokoll. UART steht für „Universal Asynchronous Reception and Transmission“.

Sie lernen, wie man Raspberry Pi verwenden, um Ihre eigenen Projekte zu bauen?

Schauen Sie sich Raspberry Pi für Anfänger an und lernen Sie Schritt für Schritt.

Grundsätzlich handelt es sich um ein asynchrones Multi-Master-Protokoll, das auf der seriellen Kommunikation basiert und es Ihnen ermöglicht, zwischen den 2 Boards zu kommunizieren. Seien Sie versichert, es gibt Bibliotheken, die alle niedrigen Ebenen für Sie verarbeiten.

Multi-Master bedeutet, dass alle angeschlossenen Geräte Daten senden können, wann immer sie möchten. Dies ist einer der Hauptunterschiede zu Master-Slaves-Protokollen, bei denen nur das Master-Gerät eine Kommunikation initiieren kann. Normalerweise verwenden Sie andere Protokolle wie I2C und SPI, wenn Sie Master-Slaves-Konfigurationen benötigen: Zum Beispiel, wenn Sie ein Arduino-Board und mehrere Sensoren oder Aktoren haben.

Die Arduino Uno board hat eine UART, dass sie verwenden können entweder mit einem USB kabel oder von der RX/TX pins (nicht verwenden es mit sowohl zur gleichen zeit). Einige Boards haben mehr verfügbare UARTs. Zum Beispiel hat der Arduino Mega verschiedene Serien (seriell, Serial1, Serial2, Serial3) und der Arduino Zero hat nur einen nativen USB-Anschluss (verwenden Sie SerialUSB anstelle von Seriell).

Auf die Raspberry Pi, sie können verbinden viele Serielle geräte auf die USB ports. Jeder hat einen anderen Gerätenamen (wir werden sehen, wie sie später in diesem Tutorial zu finden). Sie können die GPIOs (RX0/TX0) auch für einen zusätzlichen UART verwenden.

Sie kennen die serielle Kommunikation wahrscheinlich schon

Sie haben die serielle Kommunikation sicherlich schon oft verwendet. Ich bin sicher, Sie kennen bereits die serielle Arduino-Bibliothek, mit der Sie protokollieren können, was in Ihrem Code passiert, und Benutzereingaben abrufen können. Wenn Sie den seriellen Monitor verwenden, initiiert Ihre Arduino IDE im Grunde eine serielle Kommunikation mit Ihrem Arduino. Sie können Daten direkt vom seriellen Monitor empfangen und senden.

Was wir hier tun, ist fast dasselbe, außer dass anstelle Ihrer Arduino IDE die andere Seite der seriellen Kommunikation eine Raspberry Pi-Karte ist. Wir müssen einige Einstellungen vornehmen und Code schreiben, damit es funktioniert. Dann können sowohl Raspberry Pi als auch Arduino Nachrichten aneinander senden.

Sehen wir uns nun an, wie die 2 Platinen physisch miteinander verbunden werden.

Hardware Setup für serielle Kommunikation

Es gibt 2 Möglichkeiten, Raspberry Pi und Arduino für die serielle Kommunikation zu verbinden.

Seriell über USB

Am einfachsten ist es, ein USB-Kabel zwischen beiden Boards zu verwenden.

Auf der Raspberry Pi-Seite genügt ein einfacher USB-Anschluss. Sie können einen der 4 auf der Platine verfügbaren USB-Anschlüsse auswählen.

Für Arduino verwenden Sie den USB-Anschluss, mit dem Sie Code von Ihrem Computer (mit der Arduino IDE) auf Ihr Board hochladen. Hier hängt der USB-Anschluss davon ab, welche Version Sie haben. Bei Boards wie Arduino Uno und Mega unterscheidet sich der Anschluss von Arduino Nano und von Arduino Zero.

Für dieses Beispiel habe ich ein Arduino Uno Board verwendet.

Wie Sie sehen, ist dies die einfachste Hardwareverbindung, die Sie zwischen Raspberry Pi und Arduino herstellen können.

Hinweis: sie müssen zuerst Ihren Arduino an Ihren Computer anschließen, damit Sie den Code in das Board hochladen können. Schließen Sie danach das USB-Kabel an den Raspberry Pi an. Der Raspberry Pi versorgt den Arduino über dieses Kabel mit Strom.

Seriell über GPIOs

Um eine serielle Verbindung herzustellen, können Sie auch einfache Drähte zwischen dem Raspberry Pi GPIOs und den Arduino-Pins verwenden.

Abhängig von Ihrem Arduino-Board müssen Sie möglicherweise einen Spannungspegelschieber verwenden. Der Raspberry Pi arbeitet mit 3,3 V. Für Arduino-Boards wie Due, 101 ist dies in Ordnung, da sie auch 3,3 V verwenden.

Aber, für viele Arduino, wie Uno, Mega, Leonardo, Nano, und viele mehr, die bord ist betriebs bei 5 V. so, sie benötigen eine 3,3 V/5 V level-shifter zu schützen die Raspberry Pi, wenn anschluss RX und TX (mehr info auf Raspberry Pi pins und Arduino Uno pins).

Für den Rest dieses Tutorials verwenden wir das Setup mit dem USB-Kabel. Dies ist einfacher zu verwalten, und wenn Sie keinen guten Grund haben, sollten Sie das USB-Kabel anstelle von einfachen gpios für die serielle Kommunikation bevorzugen.

Raspberry Pi Software Setup

Sie benötigen kein spezielles Setup für Arduino. Stellen Sie einfach sicher, dass Sie die Arduino IDE heruntergeladen und installiert haben.

Auf Ihrem Raspberry Pi sind nun einige Dinge erforderlich, damit die Kommunikation funktioniert.

Verbinde dich mit deinem Raspberry Pi, entweder über ssh, oder durch Drücken von screen+mouse+keyboard, und öffne ein Terminal. Wenn Sie noch kein Betriebssystem auf Ihrem Pi installiert haben, können Sie Raspbian oder Ubuntu ganz einfach auf einer SD-Karte installieren.

Arduino-Board erkennen

Wenn Sie das Arduino mit einem USB-Kabel verbinden, sollte es als /dev/ttyACM0 oder /dev/ttyUSB0 angezeigt werden (manchmal kann die Nummer unterschiedlich sein, z. B. / dev/ttyACM1).

Führen Sie einfach ls /dev/tty* und Sie sollten es sehen. An diesem Punkt, wenn Sie nicht sicher sind, welches Gerät das Arduino-Board ist, trennen Sie einfach das Board (entfernen Sie das USB-Kabel) und führen Sie ls /dev/tty* erneut aus. Auf diese Weise können Sie leicht den seriellen Gerätenamen Ihres Arduino erkennen.

Hardwareberechtigungen für seriell

Möglicherweise möchten Sie Ihren Benutzer auch zur Dialout-Gruppe hinzufügen, um Fehler zu vermeiden, z. B.: seriell.serialutil.SerialException: Port / dev / ttyACM0 konnte nicht geöffnet werden: Berechtigung verweigert: ‚/ dev / ttyACM0‘

$ sudo adduser your_username dialout

Dadurch wird sichergestellt, dass Sie Zugriff auf serielle Geräte haben (/ dev / ttyACMx, / dev / ttyUSBx, …).

Nachdem Sie sich der Dialout–Gruppe hinzugefügt haben, müssen Sie Ihren Pi neu starten (oder sich zumindest abmelden /anmelden), um die Änderung zu übernehmen.

Install Python Serial library on Raspberry Pi

Sie müssen eine Bibliothek installieren, um die serielle Schnittstelle mit Python verwenden zu können.

Für dieses Tutorial verwenden wir die pySerial-Bibliothek (Dokumentation für Python 3). Um es zu installieren:

python3 -m pip install pyserial

Diese Python-Bibliothek ist bekannt und wird in vielen Anwendungen verwendet.

Wenn Sie bei der Installation einen Fehler wie „/usr/bin/python3: No module named pip“ erhalten, müssen Sie pip zuerst mit sudo apt install python3-pip installieren.

Einfache serielle Kommunikation von Arduino zu Raspberry Pi

Beginnen wir mit einem sehr einfachen Programm.

Arduino-Code

Laden Sie diesen Code mit der Arduino IDE von Ihrem Computer auf Ihr Arduino hoch.

void setup() { Serial.begin(9600);}void loop() { Serial.println("Hello from Arduino!"); delay(1000);}

Zuerst initialisieren wir die serielle Kommunikation und wählen eine Baudrate, hier 9600. 9600 ist eine häufig verwendete Baudrate und auch eine ziemlich niedrige. In Ihren zukünftigen Anwendungen können Sie problemlos eine Baudrate von 57600 oder sogar 115200 verwenden. Für dieses Tutorial werden wir mit 9600 fortfahren.

Jede Sekunde senden wir dem Arduino einen String mit Serial .println(). die Funktion println() fügt am Ende der Zeichenfolge ein Zeilenumbruchzeichen ‚\n‘ hinzu.

Sie können den seriellen Monitor öffnen, um die Zeichenfolge auf Ihrem Computer anzuzeigen.

Raspberry Pi Python Code 

#!/usr/bin/env python3import serialif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: if ser.in_waiting > 0: line = ser.readline().decode('utf-8').rstrip() print(line)

Also, was macht dieser Code?

#!/usr/bin/env python3import serial

Zuerst importieren wir die serielle Bibliothek, die wir zuvor installiert haben.

if __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1)

Die serielle Kommunikation wird durch Aufruf von serial initialisiert.Serial() zusammen mit einigen Parametern:

  • Serieller Gerätename für das Arduino: normalerweise ‚/ dev / ttyACM0‘, ‚/ dev / ttyUSB0‘ oder ähnliches.
  • Baudrate: Dieser Parameter ist sehr wichtig. Sie müssen die gleiche Baudrate verwenden wie die, die Sie auf Arduino verwendet haben, sonst ist alles, was Sie lesen und schreiben, Müll. Also wählen wir 9600 wie in der Arduino-Skizze.
  • timeout: Dies ist ein Timeout für Lesevorgänge. Hier setzen wir es auf 1 Sekunde. Dies bedeutet, dass das Programm beim Lesen von Serial nicht für immer hängen bleibt, wenn die Daten nicht kommen. Wenn nach 1 Sekunde oder Lesen nicht alle Bytes empfangen werden, gibt die Funktion die bereits empfangenen Bytes zurück.

Also, seriell.Serial() gibt ein Objekt zurück, das Sie für alle Ihre seriellen Operationen verwenden können. Wir speichern es in der Variablen ’ser‘.

 ser.flush()

Dann verwenden wir die flush() -Funktion. Dadurch werden alle Eingabe- und Ausgabepuffer geleert, sodass zu Beginn der Kommunikation keine seltsamen / nicht nützlichen / nicht vollständigen Daten empfangen oder gesendet werden.

 while True: if ser.in_waiting > 0: line = ser.readline().decode('utf-8').rstrip() print(line)

In einer Endlosschleife (denken Sie an die loop() -Funktion in der Arduino-Skizze) prüfen wir, ob einige Daten mit dem Attribut in_waiting verfügbar sind (keine Klammern setzen, dies ist keine Funktion). Wenn ja, können wir die Daten lesen.

Die Funktion readline() liest alle Bytes, bis ein Zeilenumbruch erkannt wird.

Wenn wir nur das drucken würden, was wir erhalten haben, würden wir b’Hallo von Arduino sehen!\r\n‘. Sie erhalten Bytes, wenn Sie von Serial lesen, und Sie müssen diese Bytes in den entsprechenden Datentyp konvertieren (dekodieren). Wir verwenden also decode(‚utf-8‘) – Sie können auch decode(‚ascii‘) verwenden –, um die empfangenen Daten in eine Zeichenfolge zu dekodieren.

Schließlich ist die Funktion rstrip() spezifisch für Zeichenfolgen und ermöglicht es Ihnen, alle nachfolgenden Zeichen (Zeilenumbruch, Wagenrücklauf) zu entfernen. Auf diese Weise können wir ‚\ r‘ und ‚\ n‘ entfernen und eine richtige Zeichenfolge erhalten.

Hinweis: Hier lesen wir jedes Mal eine komplette Zeile. Wenn Sie eine bestimmte Anzahl von Bytes – eines oder mehrere – lesen möchten, verwenden Sie die Funktion read(size=1).

Testen der seriellen Kommunikation

Trennen Sie nun Ihr Arduino-Board von Ihrem Computer und verbinden Sie es mit Ihrem Raspberry Pi-Board.

Der Arduino-Code läuft bereits, sobald er eingeschaltet ist.

Machen Sie auf dem Raspberry Pi die Python-Datei ausführbar und starten Sie sie.

$ chmod +x receive_serial_data_from_arduino.py$ ./receive_serial_data_from_arduino.py Hello from Arduino!Hello from Arduino!Hello from Arduino!

Es funktioniert! Die von Arduino jede Sekunde gesendete Zeichenfolge wird auf dem Raspberry Pi-Terminal angezeigt.

Bidirektionale serielle Kommunikation zwischen Raspberry Pi und Arduino

Machen wir die Dinge ein bisschen interessanter. Sie haben gesehen, wie Sie Daten von Arduino an Raspberry Pi senden. In diesem Teil erfahren Sie, wie Sie von Raspberry Pi zu Arduino sprechen. So haben Sie beide Seiten der Kommunikation und können Programme erstellen, die auf die Eingabe des anderen warten.

Arduino-Code 

void setup() { Serial.begin(9600);}void loop() { if (Serial.available() > 0) { String data = Serial.readStringUntil('\n'); Serial.print("You sent me: "); Serial.println(data); }}

Hier prüfen wir, ob der Arduino Daten mit Seriell empfangen hat.verfügbar(). Dadurch erhalten Sie die Anzahl der bereits eingetroffenen und im Empfangspuffer gespeicherten Bytes.

Wenn einige Daten eingetroffen sind, verwenden wir Seriell.readStringUntil() mit einem Zeilenumbruchzeichen ‚\n‘, um die nächste Zeile zu erhalten. Dies ähnelt der Funktion readline(). Alle bis ‚\n‘ empfangenen Bytes werden automatisch konvertiert und in einem Arduino String-Objekt hinzugefügt.

Dann drucken wir einfach die Daten, die wir erhalten haben, mit einem zusätzlichen Text zurück.

Hinweis: Wenn Sie Bytes einzeln lesen möchten, können Sie dies mit der Seriennummer tun.lesen () Funktion. Dann müssen Sie diese (diese) Bytes bei Bedarf konvertieren: int, String usw.

Raspberry Pi Python Code 

#!/usr/bin/env python3import serialimport timeif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: ser.write(b"Hello from Raspberry Pi!\n") line = ser.readline().decode('utf-8').rstrip() print(line) time.sleep(1)

Verwenden Sie die pySerial-Funktion write(), um Daten an den Arduino zu senden. Hier können Sie sehen, dass ich vor der zu sendenden Zeichenfolge ein ‚b‘ hinzugefügt habe. Dadurch wird die Zeichenfolge in Bytes codiert, da Sie Bytes nur über Seriell senden können. Alle Daten, die kein Byte oder Byte-Array sind, müssen vor dem Senden konvertiert werden. Wenn Sie nur versuchen, die Zeichenfolge so zu senden, erhalten Sie die Fehlermeldung “ TypeError: Unicode-Zeichenfolgen werden nicht unterstützt, bitte codieren Sie in Bytes: ‚Hallo von Raspberry Pi!‘ „

Hinweis: Anstelle von ser.write(b"Hello from Raspberry Pi!\n") hätten Sie ser.write("Hello from Raspberry Pi!\n".encode('utf-8')) oder ser.write("Hello from Raspberry Pi!\n".encode('ascii')) schreiben können. Dies wird das Gleiche tun. Die Funktion encode () nimmt die Zeichenfolge und codiert sie für seriell.

Außerdem fügen wir ein Zeilenumbruchzeichen ‚\n‘ hinzu, da vom Arduino erwartet wird, dass es das Lesen mit Seriell beendet.readStringUntil(‚\n‘).

Dann machen wir dasselbe wie zuvor: Wir lesen eine Zeile, dekodieren sie in einen String und entfernen jedes nachfolgende Zeichen. Wir benutzen den ser nicht.in_waiting hier, weil wir für diese spezielle Anwendung wissen, dass der Arduino einige Daten zurücksendet, kurz nachdem er die Zeichenfolge erhalten hat. Außerdem haben wir ein Timeout von 1 Sekunde, um zu vermeiden, dass wir in dieser Zeile stecken bleiben.

Schließlich drucken wir die empfangene Zeichenfolge und warten 1 Sekunde mit der Zeit.sleep(), bevor der nächste String über Seriell gesendet wird.

Testen der bidirektionalen seriellen Kommunikation

Machen Sie auf Ihrem Raspberry Pi Ihre Python-Datei ausführbar und starten Sie sie.

$ chmod +x bidirectional_serial_communication.py $ ./bidirectional_serial_communication.py You sent me: Hello from Raspberry Pi!You sent me: Hello from Raspberry Pi!You sent me: Hello from Raspberry Pi!

Erfolg! Der Arduino empfing die Zeichenfolge und schickte sie mit ein paar weiteren Worten zurück. Dann empfing und druckte der Raspberry Pi die endgültige Zeichenfolge.

Raspberry Pi Arduino Serielle kommunikation: Anwendung beispiel

Jetzt, dass sie wissen, wie zu setup ihre Arduino und Raspberry Pi für Serielle kommunikation, und schreiben programme zu sprechen zwischen jeder bord, lassen sie uns eine mehr komplexe anwendung.

In dieser Anwendung werden 4 LEDs und ein Druckknopf mit dem Arduino-Board verbunden.

Raspberry Pi und Arduino werden über ein USB-Kabel verbunden und kommunizieren über serielle Kommunikation miteinander.

Hier ist das Ergebnis, das wir erhalten möchten:

  • Wenn der Druckknopf gedrückt wird, sendet der Arduino eine Benachrichtigung an den Raspberry Pi (ein einfaches Byte).
  • Der Raspberry Pi berechnet dann eine zufällige Ganzzahl zwischen 1 und 4 und sendet sie an den Arduino.
  • Der Arduino schaltet die LED für diese Nummer ein und die anderen LEDs aus.

Damit üben Sie die Kommunikation und Synchronisation von Aufgaben zwischen Arduino und Raspberry Pi.

Wenn Sie an dieser Stelle des Tutorials angekommen sind (herzlichen Glückwunsch!) Ich ermutige Sie, den Code selbst zu schreiben, bevor Sie den unten angegebenen Code lesen. Außerdem gibt es nicht nur einen möglichen Code, um diese Anforderungen zu erfüllen, sodass sich Ihr Code möglicherweise von meinem unterscheidet. Sie können Hilfe von der Arduino Serial Reference und der pySerial API Reference erhalten.

Schaltplan

Um diese Schaltung zu machen:

  • Verbinden Sie 4 LEDs mit den Pins 9-12. Fügen Sie für jede LED zwischen dem längeren Bein und dem digitalen Pin einen 220-Ohm-Widerstand hinzu. Das kürzere Bein ist mit dem Boden verbunden.
  • Fügen Sie einen Taster mit einem 10-Ohm-Widerstand hinzu, der an Masse angeschlossen ist (Pull-Down-Widerstand). Eine seite der taste ist verbunden zu 5 V, die andere zu digitale pin 5 für lesen.
  • Vergessen Sie nicht, alle Komponenten zu verbinden: Das Arduino-Board, die 4 LEDs und den Druckknopf. Fügen Sie keine Stromversorgung hinzu, wenn Sie die Masse nicht mindestens korrekt angeschlossen haben.
  • Verbinden Sie Arduino und Raspberry Pi über ein USB-Kabel für die serielle Kommunikation (das USB-Kabel verwaltet bereits die Masseverbindung zwischen Ihren 2 Boards).

Arduino Code 

#define LED_1_PIN 9#define LED_2_PIN 10#define LED_3_PIN 11#define LED_4_PIN 12#define BUTTON_PIN 5byte lastButtonState = LOW;byte currentButtonState = LOW;unsigned long lastButtonDebounceTime = 0;unsigned long buttonDebounceDelay = 20;void powerOffAllLEDs(){ digitalWrite(LED_1_PIN, LOW); digitalWrite(LED_2_PIN, LOW); digitalWrite(LED_3_PIN, LOW); digitalWrite(LED_4_PIN, LOW);}void setup(){ Serial.begin(9600); pinMode(LED_1_PIN, OUTPUT); pinMode(LED_2_PIN, OUTPUT); pinMode(LED_3_PIN, OUTPUT); pinMode(LED_4_PIN, OUTPUT); pinMode(BUTTON_PIN, INPUT); powerOffAllLEDs();}void loop(){ byte readValue = digitalRead(BUTTON_PIN); if (readValue != lastButtonState) { lastButtonDebounceTime = millis(); } if (millis() - lastButtonDebounceTime > buttonDebounceDelay) { if (readValue != currentButtonState) { currentButtonState = readValue; if (currentButtonState == HIGH) { Serial.write(18); } } } lastButtonState = readValue; if (Serial.available() > 0) { int ledNumber = Serial.read() - '0'; powerOffAllLEDs(); switch (ledNumber) { case 1: digitalWrite(LED_1_PIN, HIGH); break; case 2: digitalWrite(LED_2_PIN, HIGH); break; case 3: digitalWrite(LED_3_PIN, HIGH); break; case 4: digitalWrite(LED_4_PIN, HIGH); break; default: // wrong pin number, do nothing // all LEDs will be powered off break; } }}

In der Funktion setup() initialisieren wir die Pin-Modi für alle 4 LEDs und den Taster. Wir stellen auch sicher, dass alle LEDs ausgeschaltet sind.

Dann machen wir in der Schleife () 2 Dinge: Handhabung des Druckknopfes und Verwaltung der 4 LEDs. Beide Aktionen werden nacheinander ausgeführt, aber sie werden sehr schnell ausgeführt, sodass es so ist, als würden sie gleichzeitig ausgeführt. Das ist ein Fall von Multitasking ein Arduino-Programm.

Erste Aktion: Handhabung des Druckknopfes.

byte readValue = digitalRead(BUTTON_PIN);if (readValue != lastButtonState) { lastButtonDebounceTime = millis();}if (millis() - lastButtonDebounceTime > buttonDebounceDelay) { if (readValue != currentButtonState) { currentButtonState = readValue; if (currentButtonState == HIGH) { Serial.write(18); } }}lastButtonState = readValue;

Wir müssen die Schaltfläche entprellen, um unerwünschte Werte zu vermeiden. Wenn wir feststellen, dass die Taste gedrückt ist, können wir einige Daten über seriell an den Raspberry Pi senden.

Hier habe ich die Seriennummer verwendet.write() Funktion: Es sendet ein Byte oder eine Reihe von Bytes. Dies unterscheidet sich von seriell.print(), wodurch die Ausgabe auf dem seriellen Monitor gut sichtbar wird. Da wir mit einer anderen Maschine und nicht mit einem Menschen sprechen, kein Problem damit.

Die Nummer, die wir hier senden, ist 18. Dies ist nur eine Zufallszahl, die wir mit dem Zustand „Button wurde gedrückt“ verknüpfen, also wenn der Raspberry Pi eine Nummer erhält, wird überprüft, ob er gleich 18 ist. Sie können sich vorstellen, verschiedene Aktionen oder Nachrichten über seriell mit unterschiedlichen Nummern zu senden.

Hinweis: Normalerweise können Sie auch Arduino-Interrupts verwenden, um zu erfahren, wann eine Taste gedrückt wurde. Wenn Sie dies tun, verwenden Sie die serielle Bibliothek nicht im Interrupt. Wenn Sie unbedingt Interrupts verwenden müssen, setzen Sie ein Flag innerhalb des Interrupts (eine einfache boolesche Variable) und verwenden Sie Serial in Ihrer loop() -Funktion.

Und die zweite Aktion: Verwaltung der 4 LEDs.

 if (Serial.available() > 0) { int ledNumber = Serial.read() - '0'; powerOffAllLEDs(); switch (ledNumber) { case 1: digitalWrite(LED_1_PIN, HIGH); break; case 2: digitalWrite(LED_2_PIN, HIGH); break; case 3: digitalWrite(LED_3_PIN, HIGH); break; case 4: digitalWrite(LED_4_PIN, HIGH); break; default: // wrong pin number, do nothing // all LEDs will be powered off break; } }

Zunächst prüfen wir, ob der Arduino über die serielle Kommunikation Daten vom Raspberry Pi erhalten hat.

Wenn ja, lesen wir das nächste Byte mit Serial .lesen(). Hier können Sie einen kleinen Trick bemerken, der darin besteht, mit ‚0‘ zu subtrahieren, wodurch das Zeichen in die Zahl konvertiert wird, die es darstellt – in diesem Fall eine ganze Zahl.

Danach ist es ganz einfach. Wir schalten alle LEDs aus und dann nur die LED ein, die der Nummer zugeordnet ist: 1, 2, 3 oder 4. Falls ein falscher Wert gesendet wird, wird keine LED eingeschaltet.

Raspberry Pi Python Code 

#!/usr/bin/env python3import serialimport randomif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: number = ser.read() if number != b'': if int.from_bytes(number, byteorder='big') == 18: led_number = random.randint(1,4) print("Button has been pressed.") print("Sending number " + str(led_number) + " to Arduino.") ser.write(str(led_number).encode('utf-8'))

Zuerst fügen wir eine Importzeile hinzu: die Python random Library.

In der Endlosschleife („while True“) lesen wir zuerst ein Byte von Seriell. Das Timeout ist auf 1 Sekunde eingestellt. Wenn nach einer Sekunde nichts empfangen wird, gibt die Funktion read () b“ zurück.

Wir prüfen also, ob das, was wir erhalten haben, einfach leer ist (b“) oder ob es wirklich etwas gab. In diesem letzteren Fall konvertieren wir die empfangenen Daten in eine Ganzzahl, damit wir sie im Code verwenden können. Dazu verwenden wir die Funktion int.from_bytes() , das b’0x12′ (die hexadezimale Darstellung von 18 ist 0x12) in 18 dekodiert.

Wie Sie sehen, überprüfen wir, ob die Nummer 18 ist, um die Aktion fortzusetzen. Wenn Sie unterschiedliche Befehle verarbeiten müssen, empfiehlt es sich, für jeden Befehl eine andere Nummer zu verwenden.

Wir wählen eine Zufallszahl zwischen 1 und 4, um zu bestimmen, welche LED eingeschaltet werden soll. Dann senden wir es mit der Funktion pySerial write(). Um ein int über Seriell zu senden, konvertieren wir es zuerst als String mit str() und codieren es dann mit encode(‚utf-8‘) .

Testen der Anwendung

Jetzt können Sie den Arduino mit dem USB-Kabel an den Raspberry Pi anschließen. Der Raspberry Pi liefert dann die Stromversorgung für den Arduino und die 4 LEDs.

Wenn Sie viele Dinge an Ihren Arduino angeschlossen haben, möchten Sie möglicherweise eine externe Stromversorgung am Arduino-Netzteilanschluss hinzufügen. Wenn Sie beispielsweise einen Schrittmotor verwenden möchten, hat der Raspberry Pi nie genug Strom für sich selbst + den Arduino + den Motor. In diesem Fall ist das mit 4 LEDs in Ordnung.

Führen Sie Ihr Python-Skript aus und drücken Sie den Druckknopf. Sie sehen ein Protokoll und eine der LEDs am Arduino wird eingeschaltet.

$ chmod +x arduino_raspberry_pi_leds_button.py$ ./arduino_raspberry_pi_leds_button.py Button has been pressed.Sending number 3 to Arduino.Button has been pressed.Sending number 2 to Arduino.Button has been pressed.Sending number 4 to Arduino.Button has been pressed.Sending number 1 to Arduino.Button has been pressed.Sending number 3 to Arduino.Button has been pressed.Sending number 3 to Arduino.

Jedes Mal, wenn Sie die Taste drücken:

  • Der Arduino erkennt es und sendet 18 an den Raspberry Pi.
  • Die Raspberry Pi erhalten einige daten von Serielle. Es wird geprüft, ob die Zahl gleich 18. Wenn ja, wird eine Zufallszahl (zwischen 1-4) gewählt. Der Raspberry Pi sendet diese Nummer an den Arduino.
  • Der Arduino erhält diese Nummer und schaltet die zugehörige LED ein.

Hinweis: Um diese Anwendung schneller und mit weniger Code auszuführen, können Sie auch das Firmata-Protokoll verwenden, z. B. die pyFirmata-Bibliothek auf Raspberry und die StandarfFirmata-Bibliothek auf Arduino. Schauen Sie sich diese Tutorials an, um mehr zu erfahren.

Fazit

In diesem Tutorial haben Sie gelernt, wie Sie zwischen Ihrem Raspberry Pi und Arduino Board über seriell kommunizieren.

Wird Ihnen das im wirklichen Leben nützlich sein? Die Antwort ist ja und ziemlich oft.

Die Raspberry Pi ist ideal für mit eine menge von berechnung power eingebettet in ihre anwendung. Sie können komplette Software in vielen Sprachen, Webservern, Robotikanwendungen usw. ausführen. Der Raspberry Pi hat sicherlich einige GPIOs, die Sie verwenden können, aber sie sind nicht so gut wie die Arduino. Außerdem haben Sie mehr Chancen, Ihren Pi zu brennen, wenn Sie etwas mit der Hardware falsch machen.

Der Arduino eignet sich besser für den direkten Umgang mit Hardwaresensoren und -aktuatoren: IMU, Servomotoren, Schrittmotoren, alles, was mehr Leistung erfordert usw. – weitere Informationen zur Verwendung von Arduino vs Raspberry Pi.

Alles in allem können die 2 Boards perfekt zusammenarbeiten: Der Raspberry Pi als „Gehirn“ der Anwendung und der Arduino als „Muskeln“ mit einer seriellen Kommunikation, damit sie miteinander sprechen können.