In diesem Teil des Kurses werden wir uns mit dem UART beschäftigen. Dies ist eine einfache und sehr beliebte serielle Schnittstelle. Vor allem bei der Kommunikation mit einem Computer.
Wie funktioniert der UART? - Ein wenig Theorie
Sein Funktionsprinzip beruht auf der seriellen Übertragung einer Folge von Bits, die dann zu einer Information zusammengesetzt werden. Ein einzelner Frame (einfach ausgedrückt: Ein Byte) wird in der folgenden Form übertragen:
Die Übertragung beginnt mit dem Startbit, das in der Abbildung mit BS gekennzeichnet ist. Dieser Bit ist immer eine logische Null. Danach folgen je nach Konfiguration 7, 8 oder 9 Datenbits (hier als B0-B7 gekennzeichnet), die die zu übertragenden Informationen darstellen. Der Stopbit (hier als BK-Bit gekennzeichnet) ist ein Bit, der eine logische Eins ist – er zeigt das Ende der Übertragung an.
Glücklicherweise müssen wir uns nicht selbst um die Aufteilung der Daten in Bits/Bytes/Frames kümmern. Alle Operationen werden für uns vom Arduino durchgeführt.
Bei der Verwendung des UART auf dem Arduino sind wir an zwei Pins interessiert:
- Tx zum Senden von Daten (Pin 1 auf dem Arduino),
- Rx für den Empfang von Daten (Pin 0 auf dem Arduino).
Damit die Übertragung korrekt abläuft, muss auf beiden Chips die gleiche Datenrate – die so genannte Baudrate – eingestellt sein. Sie bestimmt die Anzahl der pro Sekunde übertragenen Bits. Übliche Werte sind: 9600 und 115200.
Was bleibt, ist die Kommunikation über USB. Leider ist diese Aufgabe ziemlich schwierig. Aus diesem Grund verwenden die meisten Bastler UART <-> USB-Konverter, die die Sache wesentlich einfacher machen. Mit dem Arduino musst du dir darüber keine Gedanken machen. Ein solcher Konverter ist bereits in unserem Board eingebaut.
Kommen wir nun zu den Beispielen aus der Praxis. Die ersten beiden Programme erfordern NUR den Anschluss des Arduino über USB an den Computer. Erst später werden wir Peripheriegeräte zu unserer Schaltung hinzufügen.
Fertige Sets für Forbot-Kurse
Sie können jetzt ein Set von mehr als 70 Elementen, die für die Kursübungen notwendig sind, bei unseren Händlern kaufen!
Beliebtes Paket: Arduino Meister – Robotik Meister
Erstes Arduino-Programm
Die Aufgabe des folgenden Programms ist einfach, einen Text regelmäßig an den Computer zu senden:
void setup(){
Serial.begin(9600); //Einstellung der Baudrate
Serial.println("Wilkommen bei Forbot!"); //Einmalige Textübertragung
}
void loop() {
delay(5000);
Serial.println("5 Sekunden abgelaufen!"); //Senden in einer Schleife
}
Update, Januar 2016 – seit dem Update der Arduino-IDE-Umgebung befindet sich die hier als Serial Port Monitor bezeichnete Funktion unter der Option Serial Monitor. Wenn Sie beide Optionen in Ihrem Programm sehen, wählen Sie jetzt Serial Monitor, die zweite Option wird in Teil 10 besprochen.
Es ist wichtig, dass das Terminal mit der richtigen Geschwindigkeit an dem COM-Port arbeitet, an dem der Arduino angeschlossen ist! Die Geschwindigkeitseinstellungen findet man in der unteren rechten Ecke des Terminals.
Programmablauf in der Praxis:
Der Text „Willkommen bei Forbot!“ wird nur einmal angezeigt, weil wir ihn in die Setup-Funktion eingefügt haben, und wie ihr euch aus dem vorherigen Teil des Kurses erinnern solltet – die Anweisungen dort werden erst nach dem Start des Programms ausgeführt.
Eine funktionierende Übertragung kann auch an den im Arduino eingebauten LEDs beobachtet werden (mit Tx und Rx bezeichnet)! Sie leuchten auf, wenn die Datenübertragung zu/von unserem Board läuft.
Hausaufgabe 2.1
Finde heraus, was passiert, wenn du im Terminal-Fenster andere Geschwindigkeiten auswählst als die, die im Arduino eingestellt sind. Wann treten Fehler auf? Wie machen sie sich bemerkbar? Wie du selbst sehen wirst, sind die Fehler recht unterschiedlich und sollten beachtet werden.
Interaktion mit dem Programm
Stellen wir uns eine Situation vor, in der der Arduino in der Rolle einer Fensterkontrolleuchte montiert ist, an deren Rahmen ein spezieller Knopf/Sensor angebracht ist. Der ganze Mechanismus funktioniert so, dass bei geschlossenem Fenster der Knopf mit der Masse kurzgeschlossen ist, ansonsten ist der Stromkreis unterbrochen.
Mit den zuvor erworbenen Kenntnissen könnte man ein Programm schreiben, das eine farbige LED einschaltet, wenn das Fenster offen ist. Versuchen wir jedoch, unser Programm zu erweitern. Wir statten den Arduino mit einem Taster (der einen Sensor im Fensterrahmen nachahmt) und zwei LEDs (grün und rot) aus.
Wenn das Fenster geschlossen ist (Taster gedrückt), leuchtet die grüne LED. Wenn man den Stromkreis unterbricht (aufhört, die Taste zu drücken), muss die rote LED aufleuchten und das Terminal zeigt „Achtung Alarm! Fenster nicht geschlossen!“.
void setup(){
Serial.begin(9600); //Starten der Übertragung
pinMode(8, OUTPUT); //Rote Diode Ausgang
pinMode(9, OUTPUT); //Grüne Diode Ausgang
pinMode(10, INPUT_PULLUP); //Taste
digitalWrite(8, LOW); //Beide Dioden ausschalten
digitalWrite(9, LOW);
}
void loop() {
if (digitalRead(10) == LOW) { //Wenn taste gedrückt ist
digitalWrite(9, HIGH); //Grüne Diode einschalten
digitalWrite(8, LOW); //Rote Diode ausschalten
} else { //Wenn Taste nicht gedrückt ist
digitalWrite(9, LOW); //Grüne Diode ausschalten
digitalWrite(8, HIGH); //Rote Diode einschalten
Serial.println("Achtung Alarm! Fenster nicht geschlossen!");
}
}
Schauen wir mal, wie das Programm funktioniert! Leider ist es nicht ideal, wenn das Fenster nicht geschlossen ist, denn die Alarminformation wird permanent gesendet. Wir würden es jedoch vorziehen, wenn sie nur einmal gesendet wird. Hast du eine Idee, wie man das ändern kann? Natürlich mit der while-Schleife, die wir vorher benutzt haben.
void setup(){
Serial.begin(9600); //Start der Übertragung
pinMode(8, OUTPUT); //Rote Diode Ausgang
pinMode(9, OUTPUT); //Grüne Diode Ausgang
pinMode(10, INPUT_PULLUP); //Taste
digitalWrite(8, LOW); //Beide Dioden ausschalten
digitalWrite(9, LOW);
}
void loop() {
if (digitalRead(10) == LOW) { //Wenn die Taste gedrückt ist
digitalWrite(9, HIGH); //Grüne Diode einschalten
digitalWrite(8, LOW); //Rote Diode ausschalten
} else { //Wenn die Taste nicht gedrückt ist
digitalWrite(9, LOW); //Grüne Diode ausschalten
digitalWrite(8, HIGH); //Rote Diode ausschalten
Serial.println("Achtung Alarm! Das Fenster ist nicht geschlossen!");
while (digitalRead(10) == HIGH) {
//Wir bleiben in einer leeren Schleife, bis sich das Fenster wieder schließt
delay(25); //Wir fügen eine kleine Verzögerung von 25 ms in die Schleife ein, um Störungen zu reduzieren
}
}
}
Können wir den obigen Code noch irgendwie verbessern? Verbessern nein, aber natürlich können wir ihn eleganter gestalten.
Anweisung #define
Die #define-Direktive kommt uns zu Hilfe. Sie erlaubt es uns, ein Symbol zu definieren, das vor der Kompilierung überall im Programm ersetzt wird. Zum Beispiel:
#define ledPin 8
void setup() {
pinMode(ledPin, OUTPUT); //Konfiguration von Pin 8 als Ausgang
}
void loop() {
digitalWrite(ledPin, HIGH); //Diode einschalten
delay(1000); //1 Sekunde warten
digitalWrite(ledPin, LOW); //Diode ausschalten
delay(1000); //1 Sekunde warten
}
Durch das Einfügen einer Zeile am Anfang des Programms: #define ledPin 8 sorgen wir dafür, dass jedes Vorkommen des Textes ledPin vor der Kompilierung in 8 umgewandelt wird. Natürlich kann der umgewandelte Name anders lauten, wichtig ist nur, dass er eindeutig ist und dir beim Schreiben langer Programme hilft.
Merke!
Setze kein Strichpunkt nach Zeilen, die mit #define beginnen!
Nachstehend findet sich die endgültige, überarbeitete Fassung unseres Fensteralarms:
#define DiodeRot 8
#define DiodeGrün 9
#define FensterSensor 10
void setup(){
Serial.begin(9600); //Start der Übertragung
pinMode(DiodeRot, OUTPUT); //Rote Diode Ausgang czerwonej
pinMode(DiodeGrün, OUTPUT); //Grüne Diode Ausgang
pinMode(FensterSensor, INPUT_PULLUP); //Taste
digitalWrite(DiodeRot, LOW); //Beide Dioden ausschalten
digitalWrite(DiodeGrün, LOW);
}
void loop() {
if (digitalRead(FensterSensor) == LOW) { //Wenn Taste gedrückt ist
digitalWrite(DiodeGrün, HIGH); //Grüne Diode einschalten
digitalWrite(DiodeRot, LOW); //Rote Diode ausschalten
} else { //Wenn Taste nicht gedrückt ist
digitalWrite(DiodeGrün, LOW); //Grüne Diode ausschalten
digitalWrite(DiodeRot, HIGH); //Rote Diode einschalten
Serial.println("Achtung Alarm! Das Fenster ist nicht geschlossen!");
while (digitalRead(FensterSensor) == HIGH) {
//Wir bleiben in einer leeren Schleife, bis sich das Fenster wieder schließt
delay(25); //Wir fügen eine kleine Verzögerung von 25 ms in die Schleife ein, um Störungen zu reduzieren.
}
}
}
Von nun an erfordert die Änderung des Pins, an den wir eine Diode oder einen Sensor anschließen, nur noch eine Änderung an einer Stelle im Programm.
Variablen oder "Universal-Schubladen"
Genauer gesagt, können es Zeichen, Wörter oder Zahlen sein. Am häufigsten werden wir mit numerischen Variablen zu tun haben. Wann werden Variablen benötigt? Wenn wir einen Wert speichern und verschiedene Operationen mit ihm durchführen wollen. Eine Variable kann – genau wie eine Funktion – einen bestimmten Typ haben, der angibt, welche Daten sie speichern kann.
Hier ist eine Liste der wichtigsten Datentypen:
boolean logik = false; //Boolean - Wert wahr (true) oder falsch (false)
int Zahl = 30000; //Int - Ganzzahlen im Bereich von -32,768 bis 32,767 (im Arduino Uno)
long GroßeZahl = 2000000; //Long - Ganzzahlen im Bereich von -2.147.483.648 bis 2.147.483.647
float GleitkommaZahl = 6.28; //Float - Reale Zahlen, die 4 Bytes im Speicher belegen.
char Zeichen = 'a'; //Char - speichert ein Zeichen
String Satz = "Willkommen bei Forbot!"; //String - Zeichenfolge
Die maximalen Werte, die wir in eine Variable schreiben können, hängen von der Schaltung ab, die wir programmieren. Die oben genannten Werte sind für den Arduino UNO angegeben.
Beachte besonders die Variablen vom Typ long und float.
- boolean
- int
- string
Int ist die am häufigsten verwendete Variable zur Speicherung ganzer Zahlen. Sie kann verwendet werden, um Informationen zu speichern, z. B. wie oft eine Taste gedrückt wurde, wie oft ein Ereignis ausgelöst wurde oder den Messwert des Entfernungssensors (wir werden uns damit gegen Ende des Kurses befassen). Man kann natürlich auch mathematische Operationen mit Variablen durchführen – mehr dazu in den praktischen Beispielen.
String, ist eine Zeichenfolge, also können wir, ganz einfach ausgedrückt, in Variablen dieses Typs Texte speichern. Wörter, Sätze, Meldungen.
Variablen in der Praxis
Der Name jeder Variablen beginnt mit einem Buchstaben. Die Ziffern dürfen nicht am Anfang stehen. Jede Deklaration muss wie folgt vorgenommen werden:
Typname = 0;
//oder
Typname;
Beachten Sie, dass der Operator = verwendet wird, um einer Variablen einen Wert zuzuweisen, und dass der Operator == verwendet wird, um zu prüfen, ob der Begriff (Variable) gleich dem Wert ist.
Variablen haben eine Eigenschaft, die Scope genannt wird. Wenn eine Variable in einer Funktion, Prozedur oder einem Unterprogramm platziert ist, ist sie in einem anderen Unterprogramm nicht sichtbar (wir können sie nicht verwenden). Einige Beispiele:
int Variable = 0; //Globale Variable - überall im Programm sichtbar
void setup() {
int Variable2 = 0; //nur in der Funktion setup() sichtbar
}
void loop() {
int Variable3 = 0; //Lokale Variable - nur in der Funktion loop() sichtbar
}
Es gibt noch eine sehr wichtige Sache – die Benennung von Variablen. Denk daran, den Variablen Namen zu geben, die ihren Zweck angeben. Also, zum Beispiel, anstatt von:
string xx = "Damian"; //Variable zum Speichern des Namens
sollte eine Variable erstellt werden:
string Name = "Damian"; //Variable zum Speichern des Namens
Ein Problem kann entstehen, wenn der Einsatzzweck der Variablen komplizierter ist. Scheut euch jedoch nicht, vor Namen wie z. B.:
int GeschwindigkeitDesLinkenMotors = 100; //Geschwindigkeit des linken Motors
Das Wichtigste ist, dass das Programm lesbar ist.
Natürlich dürfen die Namen der Variablen keine Leerzeichen enthalten!
Verwendung von Variablen - Zähler
Die Theorie liegt hinter uns – jetzt ist es Zeit für die Praxis. Beginnen wir mit etwas sehr Einfachem. Zuerst lassen wir unser Programm den Wert der Variablen in jeder Schleife ausschreiben, den wir erhöhen wollen.
int Zähler = 0; //Deklaration der Variablen
void setup() {
Serial.begin(9600); //Initialisierung der Verbindung zum PC
}
void loop() {
Serial.println(Zähler); //Senden des Wertes der Variablen Zähler
Zähler = Zähler + 1; //Erhöhung des Zählers um 1
delay(100); //Verzögerung, um den Effekt besser sichtbar zu machen
}
Natürlich steht die Deklaration einer globalen Variablen ganz am Anfang. So können wir von überall im Programm auf sie zugreifen. Als nächstes wird die Übertragung wie üblich gestartet. Unsere Hauptschleife, loop(), führt 3 Aktionen aus.
- Wir greifen auf die Speicherstelle zu, die wir als Variable Zähler deklariert haben, und senden dann den dort gefundenen Wert über den UART.
- Wir erhöhen den aktuellen Wert der Variablen Zähler um 1.
- Wir warten 100ms (für einen besseren Effekt) und kehren zum Anfang der Schleife zurück.
Punkt 2, d.h. die Erhöhung der Variablen, bedarf eventuell einer Erklärung. Die angewandte Notation ist:
Zähler + Zähler + 1; //Zähler um 1 erhöhen
Aus mathematischer Sicht, wo das „=“ Zeichen Gleichheit bedeutet, sollte die obige Zeile nicht funktionieren. In der Programmierung bedeutet das „=“ Zeichen jedoch eine Zuweisung. In der Praxis sollte der obige Code als folgende Operation verstanden werden:
- Nimm den Wert der Variablen Zähler,
- addiere 1 dazu,
- speichere den so erhaltenen Wert in der Variablen Zähler.
Lade das Programm in den Arduino, um zu sehen, ob es korrekt funktioniert. Natürlich muss man den Monitor an der seriellen Schnittstelle (Terminal) laufen lassen, um die Auswirkungen zu sehen.
Hausaufgabe 2.2
Was passiert, wenn die Deklaration der Variablen Zähler in die Schleife loop() verschoben wird?
Hausaufgabe 2.3
Wie bereits erwähnt, haben Variablen ihre Einschränkungen. Ändere die Deklaration der Variable Zähler von int in byte, die Zahlen im Bereich von 0-255 aufnehmen kann. Was passiert, wenn dieser Wert überschritten wird? Beobachte die angezeigten Ergebnisse genau!
Zwei-Wege-Übertragung mit Arduino
Die Aufgabe des ersten Programms wird sein, nach unserem Namen zu „lauschen“. Wenn wir ihn senden, sollte uns der Arduino mit der Nachricht „Hallo Name!“ begrüßen, wobei natürlich der zuvor gesendete Name eingefügt wird.
String empfangeneDaten = ""; //Leere Zeichenfolge der empfangenen Daten
void setup() {
Serial.begin(9600); //Start der Kommunikation
}
void loop() {
if(Serial.available() > 0) { //Hat der Arduino die Daten empfangen
empfangeneDaten = Serial.readStringUntil('\n'); //Wenn ja, lese sie bis zum Zeilenende und speichere sie in der Variablen empfangeneDaten
Serial.println("Willkommen " + empfangeneDaten + "!"); //Anzeigen der Nachricht
}
}
Wenn die Daten verfügbar sind (mehr als 0), beginnt das Schreiben der Daten in die Variable empfangeneDaten. Dies geschieht mit der Funktion Serial.readStringUntil(Abschlusszeichen), die die Daten aus dem Puffer kopiert, bis ein Abschlusszeichen auftritt (in diesem Fall „\n“ – d.h. ein Zeilenumbruch).
Interaktion mit der Schaltung - Steuerung der Dioden über UART
Wir werden die Möglichkeit nutzen, einen Text an den Arduino zu senden, um die Leuchtdioden zu steuern. Schließe dazu die beiden Dioden wie unten gezeigt an (Dioden an Pin 8 und 9).
Die Aufgabe unseres Programms ist es, die grüne oder rote LED für 1 Sekunde einzuschalten, wenn der entsprechende Befehl an den Arduino gesendet wird. Das fertige Programm sieht wie folgt aus:
#define grün 8
#define rot 9
String empfangeneDaten = ""; //Leere Zeichenfolge der empfangenen Daten
void setup() {
Serial.begin(9600); //Start der Kommunikation
pinMode(grün, OUTPUT); //Konfiguration des Ausgangs
pinMode(rot, OUTPUT);
digitalWrite(grün, LOW); //Dioden ausschalten
digitalWrite(rot, LOW);
}
void loop() {
if(Serial.available() > 0) { //Hat der Arduino Daten empfangen
//Wenn ja, lesen wir sie bis zum Zeilenende und speichern sie in der Variablen empfangeneDaten
empfangeneDaten = Serial.readStringUntil('\n');
if (empfangeneDaten == "grün") { //Wenn das Wort "grün" empfangen wurde
digitalWrite(grün, HIGH); //Dann schalten wir die grüne Diode ein
delay(1000);
digitalWrite(grün, LOW);
}
if (empfangeneDaten == "rot") { //Wenn das Wort "rot" empfangen wurde
digitalWrite(rot, HIGH); //Dann schalten wir die rote Diode ein
delay(1000);
digitalWrite(rot, LOW);
}
}
}
Analysieren wir nun, wie das Programm funktioniert. Zu Beginn werden die Pin-Nummern der Leuchtdioden definiert und die Variable, in die die empfangenen Daten kopiert werden, deklariert. Dann prüfen wir in einer Schleife, ob der Arduino die Daten empfangen hat. Wenn ja, prüfen wir, ob diese Daten mit einer der Farben übereinstimmen. Daraufhin werden die entsprechenden Dioden eingeschaltet.
Damit das obige Programm funktioniert, müssen Zeilenendezeichen gesendet werden, die automatisch an die eingegebene Zeichenfolge angehängt werden können. Wähle dazu die entsprechende Option aus dem Dropdown-Menü im Monitor der seriellen Schnittstelle.
Hausaufgabe 2.4
Überarbeite das obige Programm so, dass es bei falscher Farbe eine entsprechende Meldung über das Terminal sendet.
Hausaufgabe 2.5*
Schwierigere Aufgabe mit einem Sternchen. Schreibe ein Programm, das, sobald einer Diode eine Farbe gesendet wird, ihren Zustand in den entgegengesetzten ändert. Wenn die Diode an ist, wird sie ausgeschaltet und umgekehrt. Tipp: Verwende unbedingt zusätzliche Variablen vom Typ bool, um den aktuellen Zustand der LEDs zu speichern.
Zusammenfassung
Denkt daran, dass das komplette Set, das für alle Übungen benötigt wird, bei Botland erhältlich ist. Mit dem Kauf der Kits unterstützt ihr zukünftige Veröffentlichungen auf Forbot!
Die Variablen sind ein Programmierungselement, das immer wieder auftauchen wird! Außerdem werden wir den UART häufig benutzen, um die von uns gesammelten Informationen anzuzeigen und die Einstellungen unseres Programms zu ändern. Er wird auch sehr nützlich sein, um Fehler in unseren Codes zu finden!
