Numerische Daten von einem Arduino zu einem anderen senden - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:16

Einführung

von David Palmer, CDIO Tech. an der Aston-Universität.

Mussten Sie jemals Zahlen von einem Arduino zu einem anderen senden? Dieses Instructable zeigt, wie.

Sie können leicht testen, ob es funktioniert, indem Sie einfach eine Zahlenfolge eingeben, die am Serial Monitor-Terminal gesendet werden soll, und sehen, wie die Zahlen an einem zweiten seriellen Monitor ausgegeben werden, der mit dem zweiten Arduino verbunden ist. Sie können sogar eine Bluetooth-Verbindung verwenden.

Was es macht

Zwei Arduino-Programme (Skizzen in Arduino-Sprache) müssen entwickelt werden, eines als Master-Programm zum Verbinden mit dem Host-Computer, auf dem der Arduino Serial Monitor ausgeführt wird, eines als Slave, um die serielle Nachricht vom Master zu empfangen, zu decodieren und zurückzusenden. Der Slave ist optional in der Lage, die Nummern, mit denen er es zu tun hat, auf dem Serial Monitor einer zweiten IDE anzuzeigen - nur für den Fall, dass Sie diesen verwenden möchten. Es kann hilfreich sein, die Dinge überhaupt zum Laufen zu bringen, und Ihnen helfen, wenn Sie sich entscheiden, Änderungen an den Programmen vorzunehmen, die Ihren eigenen Anforderungen entsprechen.

Ausrüstung

• 2 Arduinos
• 2 USB-Kabel
• Patchkabel (nach Bedarf)
• 1 PC/Laptop geladen mit Arduino IDE (als kostenloser Download von der Arduino.cc-Website erhältlich)

Schritt 1: Einrichten - Richten Sie zuerst Ihre Hardware ein

Stecken Sie die 2 Arduinos in 2 USB-Anschlüsse Ihres Computers.

Tipp, es ist eine gute Idee, sie als M und S (Master und Slave) zu kennzeichnen, damit Sie später nicht ins Durcheinander geraten (wie auf den 2 Fotos hier gezeigt).

Schritt 2: Einrichten - Stellen Sie Ihren Bildschirm ein

Am besten richten Sie Ihren Bildschirm so ein, dass Sie

• die IDE mit dem Master-Programm auf der linken Seite geladen und
• das mit dem Slave rechts.

Halten Sie die seriellen Monitore für Maser und Slave ebenfalls links und rechts, wie im Screenshot hier gezeigt.

Schritt 3: Richten Sie das Master-Ende ein und verbinden Sie es dann - Teil 1

Wenn Sie Ihren Master End Serial Monitor so einrichten, dass er zwei Nummern sendet, müssen Sie immer die Start- und End-Trennzeichen und das Komma-Trennzeichen verwenden, wie hier gezeigt.

Sie müssen nun die 2 Arduinos über seriell miteinander verbinden. Dies geschieht mit zwei Patchdrähten.

Ich habe Grün und Gelb verwendet

• Nehmen Sie zuerst das Gelbe, das muss in einem Arduino an D6 und im zweiten an D7 angeschlossen werden
• Dann das Gegenteil für den grünen Draht, D7 am ersten und D6 am zweiten Arduino.

Alternativ, wenn Sie etwas wie ein Paar Bluetooth-Module - wie das HC-05 - haben, werden diese auch funktionieren, um genau den gleichen Effekt wie die obigen Drähte zu erzielen.

Schritt 4: Richten Sie das Master-Ende ein und verbinden Sie es dann - Teil 2

Wir verwenden die Software Serial Library. Weitere Informationen finden Sie unter diesem Link

Sie können es in Zeile 7 eines der Programme sehen. Es konfiguriert die Pins 7 und 6 als TX und RX (Senden und Empfangen). Auf diese Weise werden die Daten vom Master-Arduino durch das grüne Kabel in den Slave übertragen und, wenn das Slave-Programm im zweiten Arduino seine Arbeit beendet hat, durch das gelbe Kabel zurück. Unten in der gleichen Abbildung (im Serial Monitor-Fenster) sehen Sie, dass die von uns übertragenen Daten nun erfolgreich die hier beschriebene Schleife durchlaufen haben und als das Paar von Ganzzahlen schön getrennt in den PC zurückkehren.

Schritt 5: Übersicht der Skizzen / Programme - Aufbau des Programms

Layout Wie in allen Arduino-Skizzen gibt es 3 grundlegende Teile:

• Die Erklärungen
• Die Einrichtung
• Die Hauptschleife

Wie so oft haben wir hier von einem vierten Abschnitt Gebrauch gemacht, der das Hinzufügen von 'Funktionen' ist. Wenn Sie mit der Verwendung von Funktionen nicht vertraut sind, können Sie nach "Arduino-Funktionen" googeln und Sie finden Erklärungsseiten wie das Beispiel in diesem Link: www.tutorialspoint.com/arduino/arduino_functions…..

Wir haben auch Tabs verwendet, um das Programm in übersichtlichere Blöcke zu unterteilen.

Die drei von uns verwendeten Blöcke sind oben in jeder Abbildung der IDE-Fenster oben zu sehen:

• simpleRxTx0330Master
• gemeinsames
• Anmerkungen

Dies sind eigentlich separate Dateien innerhalb des Programmordners, wie Sie in dieser Windows Explorer-Ansicht der Dateien des Slave-Programms sehen können.

Es gibt einen sehr guten Grund, warum wir dies getan haben.

• Als wir das Programm aufbauten, stellten wir fest, dass der größte Teil des Programms für den Master das gleiche war wie für den Slave.
• Am Ende haben wir alle gemeinsamen Teile in eine Registerkarte gezogen, die wir daher "gemeinsam" nannten, und jedes Mal, wenn wir ein Teil debuggt hatten (es getestet und zufrieden waren, dass es in Ordnung war), haben wir einfach das ganze Register kopiert und eingefügt gegenüber von Master zu Slave oder umgekehrt.
• Die Notizen-Registerkarten sind auch identisch, da das Design generisch ist.

Keine der Funktionen wird von setup aufgerufen, sie werden alle von loop aufgerufen, also haben wir sie nach setup aber vor loop erstellt.

Schritt 6: Top-Down-Design

Es ist eine gute Idee, Ihre Skizze zu entwerfen, beginnend mit einer Definition dessen, was Sie tun möchten.

Sobald Sie dies haben, können Sie mit der Skizze beginnen, um diese Dinge zu tun. Im Allgemeinen, wenn Sie ein Detail noch nicht kennen, machen Sie es einfach zu einer Funktion und überlassen Sie das Erstellen der Funktion bis später.

Dies folgt der guten Designphilosophie, die an vielen Universitäten gelehrt wird und CDIO genannt wird (Wenn Sie diese noch nicht kennen, können Sie sie googeln und finden Sie Websites, die es erklären: https://www.cdio.org/s.) Das sagt im Grunde: Beginnen Sie nicht mit dem Design, bevor Sie das Konzept klar haben. Beginnen Sie nicht mit der Implementierung, bis Sie das Design klar haben. Erwarten Sie nicht, dass es funktioniert, bevor Sie die Implementierung klar haben. Zuerst C, dann D, I und O. In jeder nachfolgenden Phase iterieren Sie (gehen Sie die Schleife(n) zurück, wenn Sie also mit Ihrer ursprünglichen Designschleife zufrieden sind, überprüfen Sie, ob sie immer noch dem Konzept entspricht, und aktualisieren Sie es das C, wenn es sein muss usw. Und so weiter, also selbst wenn Sie bei Operating angekommen sind, gehen Sie ganz nach oben und sehen Sie noch einmal, wie das C jetzt aussieht, dann das D und I, und machen und überprüfen Sie alle Bei Programmierskizzen funktioniert dies genauso, wenn Sie von oben nach unten entwerfen.

Schritt 7: Konzept und Design - Teil 1

Das Konzept hier sieht aus wie die Gliederungsanforderungen, die auf der Registerkarte "Notizen" angegeben sind.

Das Design könnte wie eine frühe Version der Schleife aussehen, die der Registerkarte "Notizen" entspricht und in etwa so aussehen könnte, wie Sie es in dieser Abbildung sehen

Sehen Sie, wie ich anfange, indem ich die Kommentare zuerst mit STRG-C in den Kopf der Schleife kopiere und dann die Lücken mit Befehlen ausfülle, die diese Dinge tun.

Dies kompiliert tatsächlich OK, wie Sie am unteren Bildschirmrand in der Abbildung sehen können. Das reicht von CDIO-Stufe D bis I, und während wir den Code entwickeln, ist es eine gute Idee, diese D-I-Schleife weiter zu durchlaufen.

Jetzt ist es an der Zeit, zur nächsten Stufe zu gehen, dort gibt es einen Kommentar, der besagt, dass wir: // etwas vom Hardware-USB empfangen, dann werden wir das auf den seriellen Softwarekanal übertragen. Wir schreiben diesen Code, um dies zu ermöglichen - die Zeilen 133 bis 138 werden hier in gelber Markierung angezeigt

Schritt 8: Konzept und Design - Teil 2

Die beiden ersten Funktionen, die wir hier einführen, sind (recv() und tran(), um das Empfangen vom Hardware-Port und das Senden an den Software-Port durchzuführen - daher rufen sie sie mit den gezeigten 'hw'- oder 'sw'-Parametern auf.

Darüber hinaus haben wir einen Test für eine globale Variable namens newData hinzugefügt. Dies ist ein Flag, das wir in der Funktion " void recv(); " setzen. Wenn eine Nachricht empfangen wurde, wird diese Variable von false auf true gekennzeichnet. Wir tun dies, damit wir nur dann eine Nachricht senden, wenn in Zeile 134 eine empfangen wurde (Flag ==true). Und wenn wir unsere Nachricht gesendet haben, ist das 'Job erledigt', also löschen wir das Flag in Zeile 137 wieder auf false.

Wieder können wir kompilieren (D bis I) überprüfen, und diesmal haben wir eine 'nicht deklarierte' Fehlermeldung (dargestellt). Dies sagt uns, dass wir recv() nicht deklariert haben; Funktion. Wir planen, dies später zu tun, also müssen wir nur für den Moment eine Dummy- oder Platzhalterfunktion erstellen, wie als nächstes gezeigt, um eine saubere Kompilierung zu erhalten.

Wieder können wir kompilieren (D bis I) überprüfen, und diesmal haben wir eine weitere 'nicht deklarierte' Fehlermeldung für tran(); Funktion. Dies erfordert eine ähnliche Stub-Erstellung. Wieder können wir kompilieren (D bis I) überprüfen, und dieses Mal werden wir feststellen, dass dies perfekt funktioniert; So weit, ist es gut.

Schritt 9: Beenden Sie die Hauptschleife: A) Empfangen von USB, B) Empfangen von Slave-Arduino

Es gibt noch ein letztes Stück, das wir hinzugefügt haben, um diesen Teil abzuschließen, nämlich etwas Debugging-Code hinzuzufügen.

Es gibt ein weiteres Instructable zum Debuggen von Skizzen, auf das verwiesen werden kann, um zu verstehen, was wir hier getan haben und warum. Siehe die Anleitung "Wie man Arduino-Skizzen baut und testet, bis sie funktionieren"

Diese Debug-Zeilen [136-139 gezeigt] werden also als nächstes in der Hauptschleife hinzugefügt, und siehe da, Sie können sie am Master-Ende testen, indem Sie die Debug-Variable auf true setzen und Kompilieren (I), dann wenn Wenn Sie ein Arduino anschließen, können Sie hochladen, den Serial Monitor öffnen und sehen, ob das, was in den Serial Monitor zurückkommt, wie hier gezeigt ist (sehen Sie die Meldung "DEBUG MODE" hinzugefügt?)

Schritt 10: Empfangen und Verarbeiten der Daten im Slave-Arduino

Empfangen von Slave Arduino

Fügen Sie den erforderlichen Code für den zweiten Kanal in die Hauptschleife ein, den seriellen Software-Empfänger wie gezeigt - Zeilen 149 bis 155.

Können Sie sehen, dass die Struktur lose auf dem basiert, was wir oben für den Master-Fall geschrieben haben?

Sie werden auch sehen, dass wir einen Compilerfehler erhalten, eine weitere nicht deklarierte Funktion - diesmal parseData(); - deshalb müssen wir auch hierfür einen Stub erstellen, bevor wir eine fehlerfreie Testkompilierung durchführen können.

Umgang mit den Daten im Slave Arduino

Fügen Sie den Hauptschleifencode hinzu, der für das Arduino erforderlich ist, wenn es wie gezeigt als Slave-Gerät konfiguriert ist - Zeilen 163 bis 174. Können Sie sehen, dass die Struktur der des ersten Kanals sehr ähnlich ist?

Und Sie sollten dieses Mal feststellen, dass es absolut in Ordnung ist.

Schritt 11: Schreiben Sie die Empfangsfunktion

Die Empfangsfunktion - void recv(char from){} - hat zwei Hauptaufgaben.

1, um eine Zeichenfolge vom USB-Kanal zu empfangen, und

2, um einen vom Arduino-zu-Arduino-Kanal zu empfangen.

Für das erste müssen wir verwenden, da es den eingebauten Hardware-UART des Arduino verwendet, und für das zweite die Standard-Arduino-Bibliothek: Software-UART.

Wenn wir anfangen, Code zu einer Funktion hinzuzufügen - um eine Funktion zu erstellen, die etwas tut, anstatt nur einen Stub -, müssen wir daran denken, den Stub, den sie ersetzt, zu entfernen oder auszukommentieren. Andernfalls erhalten wir einen Kompilierungsfehler: reffintion of 'void lrec(char)'.

Versuchen Sie, den Fehler zu beheben, und versuchen Sie dann eine der oben vorgeschlagenen Methoden, um ihn zu beheben.

Beginnen Sie mit einer Funktion, die wie die hier gezeigte der Zeilen 75 bis 88 in Gelb aussieht.

Inzwischen wissen Sie, dass Sie, wenn Sie Code haben, den Compile-Vorgang ausprobieren müssen. Sie erhalten einen Fehler, wie den, den wir zuvor hatten, vom Typ: Funktionsname nicht in diesem Bereich deklariert. Wir werden zunächst einen weiteren Stub benötigen, damit wir über diesen Fehler hinweg kompilieren können. Fügen Sie also einen wie zuvor hinzu und stellen Sie sicher, dass Sie jetzt eine fehlerfreie Kompilierung erhalten.

Sehen wir uns nun den Code an, den wir für die recv()-Funktion geschrieben haben.

Es ist ziemlich sauber, Sie können die Verwendung der 'if'-Bedingung sehen, um die beiden Teile der oben genannten Funktion zu erzeugen.

Der Code innerhalb des 'sw'-Teils und des 'hw'-Teils hat die gleiche Form, und ich werde ihn hier beschreiben.

Die erste des Zeilenpaares ist jeweils der Beginn einer while-Schleife. Wenn Sie mit while nicht vertraut sind, können Sie die Erklärung und Beispiele auf der Arduino.cc/Reference-Site nachschlagen. Hier warten wir 'während' die eingebaute 'Serial'-Funktion keine Zeichen erhalten hat und weil die newData-Variable ausgeschaltet wurde (d.h. die newData == false-Bedingung ist wahr). Sobald ein Zeichen - oder mehr als ein Zeichen - empfangen wird, wird das while in die zweite Zeile dieses Paares "durchgeschaltet". Das ruft dann recAstringChar(char) auf; Funktion, um das aktuelle Zeichen zu behandeln. Dieses Zeilenpaar wechselt dann ab, solange (oder solange) noch Zeichen zu empfangen sind. Sobald sie alle fertig sind, endet der while-Zustand, wodurch die nächste Ebene von if oder else beendet wird und wiederum rec(char); Funktion zu beenden. Somit ist nun eine vollständige Nachricht eingegangen.

Schritt 12: Schreiben Sie die Empfangs-Unterfunktion - Teil 1

Wir müssen jetzt die Funktion recAstringChar(char) schreiben;. Sie sehen aus dem Kommentar zu Zeile 50 hier oben, dass seine Aufgabe darin besteht, zwei Puffer mit Kopien der eingehenden seriellen Nachricht zu aktualisieren. [Als ich versuchte, das alles zum Laufen zu bringen, habe ich gelernt, dass ich zwei verschiedene Puffer brauche - oder zumindest war dies der einfachste Weg, um einige Probleme zu umgehen, daher hat es sich so entwickelt, dass ich 2 Puffer brauche, also Ich habe sie gerade erstellt.] Ich habe einen Puffer aufgerufen: ReceivedData und den anderen: ReceivedChars.

Die Puffer sind globale Variablen, sie werden also auf Modulebene deklariert, siehe Zeilen 9 und 10 der gemeinsamen Registerkarte. Es gibt andere Variablen, die in dieser Funktion deklariert sind und daher einen lokalen Gültigkeitsbereich haben – hier in den Zeilen 51-54 gezeigt. Dies ist nicht der Ort, um die Unterschiede zwischen Globals und Locals zu erklären, aber es gibt mehr Informationen dazu unter https://www.arduino.cc/glossary/en/ unter Local und Global.

Alles über die Datentypen und Typ-Modifikatoren: static, boolean, byte, const, char erfahren Sie auch in https://www.arduino.cc/reference/en/#variables, hier gezeigt.

Der Hauptprogrammablauf in dieser Funktion wird hier durch das if in Zeile 56 und sein entsprechendes else in Zeile 74 gesteuert. Dies behandelt zwei Szenarien

a) [ab Zeile 74] wenn die empfangene Nachricht beginnt. Dies geschieht, wenn der startMarker erkannt wird - dies wurde als das Zeichen ' < ' definiert, weshalb wir unsere Zeichenfolge immer mit diesem Zeichen beginnen, wenn wir den Sketch testen. Wenn wir dies nicht tun, wird nichts als empfangen verarbeitet, es wird alles ignoriert, als ob wir Unsinn an der Tastatureingabeaufforderung 'Serial Monitor' eingeben.

b) [Zeilen 56 bis 73], die alle anderen Zeichen empfängt, was auch immer sie sind, aber sie behandeln Zeichen nur, nachdem ein gültiger Start stattgefunden hat (ein '>' wurde wie in a) oben empfangen.)

In diesen Zeilen (von 74 bis 78) legen wir das empfangene < in einen der Puffer (receivedData[0]), aber nicht in den anderen. Wir passen den Pufferzeiger (Variable: char ndx) so an, dass er auf die nächste freie Pufferposition (receivedData[1]) zeigt, indem wir den Post-Increment-Befehl (++) in der Zeile ndx++ verwenden;, und wir setzen das Flag in progress auf true.

Der Programmablauf in diesem Teil der Funktion wird hier durch das if in Zeile 57 und sein entsprechendes else in Zeile 65 gesteuert. Dies behandelt zwei Szenarien

a) [ab Zeile 65] wenn die empfangene Nachricht beendet ist. Dies geschieht, wenn der endMarker entdeckt wird - definiert als >, weshalb wir unseren String immer mit diesem Zeichen beenden, wenn wir unseren Sketch testen. Eines der Dinge, die beim Empfang des Endzeichens passieren, ist, dass das globale Flag (technisch variabel) newData auf true gesetzt wird, sobald die Funktion endet, sodass die Funktion, die unsere Unterfunktion aufgerufen hat (die aufrufende Funktion: recv(char);) kann 'wissen', dass gültige neue Daten vollständig empfangen wurden.

b) [Zeilen 57 bis 64], die alle anderen Zeichen empfängt, was auch immer sie sind. Es parkt sie nur geschäftig in Reihen in beiden Puffern.

Schritt 13: Schreiben Sie die Empfangsunterfunktion - Teil 2

Es könnte hilfreich sein, ein Beispiel dafür zu geben, wie die beiden Puffer aussehen, wenn sie gefüllt sind. Wenn wir die Eingabetaste eingeben, werden in den Puffern die Zeichen angezeigt:

Jetzt können Sie sehen, dass wir einen Puffer haben, der genau die gleichen Zeichen enthält, die wir zuerst eingegeben haben, und einen Puffer, der nur die beiden Werte und ein Trennkomma enthält. Jetzt haben wir einen Code, der die Zeichen empfangen kann, die wir auf der Serial Monitor-Tastatur eingeben, wir können von CDIO-Phase I zu O wechseln, einige Zeichenfolgen eingeben und sehen, was passiert. Laden Sie den Code auf den Master Arduino hoch, öffnen Sie den Serial Monitor und versuchen Sie, etwas Gültiges einzugeben, z. Erhalten Sie auf dem Serial Monitor-Bildschirm ein Echo wie das hier gezeigte?

Schritt 14: Schreiben Sie die Sende- und Analysefunktionen

Zuerst für die Übertragung

Nachdem wir nun einen String erhalten haben, können wir die Sendefunktion schreiben: tran(char); um seinen Stummel zu ersetzen. Auf diese Weise können wir eine Zeichenfolge vom Master zum Slave-Arduino senden.

Stellen Sie also sicher, dass beide Geräte angeschlossen und miteinander verbunden sind, um diese neue Funktionalität zu testen.

Geben Sie diese Funktion wie hier in den Zeilen 117 bis 133 gezeigt ein. Wie Sie erkennen werden, besteht sie aus zwei Teilen, einer zur Übertragung auf den USB-Kanal (Hardware-UART) und einer zur Übertragung an den anderen Arduino (Software-UART). Dies sollte einen Kompilierungsfehler verursachen -kostenlos, und Sie können die Skizze sofort hochladen und sehen, was passiert. Diesmal schicke ich. Bekommst du das Ergebnis angezeigt?

Der Screenshot ist interessant, weil die empfangene Zeichenfolge … wie zuvor korrekt aussehen sollte und die übertragene Zeichenfolge … jetzt korrekt aussehen sollte. Beachten Sie jedoch, dass die Integer-Konvertierung nicht funktioniert hat. Es muss noch ein bisschen mehr Code hinzugefügt werden, damit das funktioniert.

Schritt 15: Schreiben Sie die Sende- und Analysefunktionen

Dann für die Parse

Dies ist ein Codestück, das die empfangene Zeichenfolge analysiert, um die numerischen Teilzeichenfolgen abzurufen und sie in ganzzahlige Werte umzuwandeln. Es ist das void parseData(); Funktion der Hauptschleife

Ersetzen Sie den Parse-Stub durch den in den Zeilen 98 - 113 gezeigten Code. Laden Sie ihn hoch und sehen wir, ob das Problem, das wir mit den 2 Integer-Werten hatten, jetzt behoben ist. Lass es uns versuchen.

Ja, es funktioniert, wie gezeigt, die gefundenen ganzen Zahlen sind 49 und 98.

Schritt 16: Finale

Diese Daten haben die Schleife vom PC über den Master über den Slave und wieder zurück über den Master zum PC durchlaufen. Wenn die fertige Version von Common sowohl auf Master- als auch auf Slave-Enden hochgeladen wurde und der Debug-Modus jetzt deaktiviert ist, sehen wir die Daten an beiden Enden korrekt empfangen, wie hier gezeigt.