06 Die Serielle Schnitstelle   

Die serielle Schnittstelle ist eine Arduino-Bibliothek. Eine Bibliothek in der Arduino-Welt ist ein Hilfsprogramm, dass schon irgendjemand für uns netterweise geschrieben hat. Sie enthalten Basisfunktionalitäten, wie z.B. das Abfragen von Sensoren oder Kommunikationsprotokolle. Ohne Bibliotheken müssten wir sehr vieles von Grund auf neu schreiben. Sie erleichtern uns die Arbeit in höchstem Maße und halten unseren Sketch schlank.

Die serielle Schnittstelle, eines der vielen Bibliotheken, wird durch ein Unterprogramm des Arduino IDE visualisiert - dem seriellen Monitor. Es ist ein Fenster mit einer Textausgabe.

##Bild

Nehmen wir zum Beispiel das Empfangen und Senden von Daten zwischen dem Arduino und Computer. Damit beide Geräte wissen, was und wann in welcher Richtung geschickt wird, gibt es ein Protokoll. Dieses regelt und taktet den Datenverkehr, wie ein Verkehrspolizist an einer Kreuzung. Zum Glück müssen wir uns nicht darum kümmern, wie Daten portioniert, getaktet, verschickt und entschlüsselt werden müssen.

Wir können zwischen zwei Bibliotheken unterscheiden: Die, die bereits in der Arduino IDE integriert sind (z. B. WIFI, Servo, Keyboard …). Diese brauchen wir nicht zu installieren. Und die, die wir selber installieren müssen.

Mit Bibliotheken müssen wir nicht immer wieder das Rad neu erfinden und können uns auf unser wirkliches Ziel konzentrieren. Es wäre eine Wahnsinnsarbeit jedes Mal selber ein Protokoll zur Datenübertragung zu schreiben. Eine Bibliothek ist ein wahrer Segen. Sie sind unsichtbar und arbeiten für uns im Hintergrund. Wir müssen nur bestimmte Befehle aufrufen und haben dann den vollen Funktionszugriff.

Die serielle Schnittstelle

Wir haben bereits gelernt wie man einen Sketch zum Arduino uploadet. Die Arduino IDE kann mehr als nur einen Sketch zum Board zu versenden. Wir können in beide Richtungen (Computer <> Arduino) interaktive Anwendungen programmieren. Wir können z.B. die Tastatur des Computers benutzen, um einen Motor schneller drehen zu lassen oder seine Drehrichtung zu ändern. Oder die Werte eines Thermometers vom Arduino zum Computer schicken und als Gradzahl anzeigen lassen. Die Möglichkeiten sind sehr vielfältig.

Wenn ein Sketch zum Arduino hochgeladen wird, geschieht dies mit einer speziellen Technik. Daten kommen nicht irgendwie zum Mikrocontroller an, sondern werden über bestimmte Protokolle verschickt.

Der Datentransfer erfolgt beim Arduino wie bereits erwähnt über die serielle Schnittstelle. Dies ist ein sehr altes Übertragungsprotokoll aus den 60er, entwickelt zur Datenübertragung zwischen zwei Geräten.

Die Bezeichnung serielle Schnittstelle umfasst ein großes Spektrum an Varianten. Die Unterschiede variieren z. B. in der Übertragungssteuerung, Datenflusskontrolle oder Datenraten.

Im Zusammenhang mit dem Arduino ist die RS-232 Schnittstelle gemeint. Auch, wenn das Arduino-Board einen USB-Anschluss hat, steckt keine USB-Technik drinnen. Die USB-Technik ist eine modernere serielle Schnittstelle. RS-232 wurde früher in Tastaturen, Mäusen und Druckern verwendet und ist durch die USB-Schnittstelle verdrängt worden.

Wie der Name schon andeutet, werden die Daten in Serie versendet – eine Informationseinheit nach der anderen - also hintereinander in Serie. Der Datentransfer kann, je nach Technologie, unterschiedlich erfolgen:

  • in nur eine Richtung (simplex)

  • oder in beide Richtungen entweder abwechselnd (halb-duplex)

  • oder gleichzeitig in beide Richtungen(voll-duplex)


Die Daten werden byteweise versendet. Ein Byte besteht aus 8 bits. Die kleinste Speichereinheit in der Computertechnik ist das Bit. Ein Bit kann den Zustand  0 oder 1 haben (Binärsystem). Da man mit einem Bit nicht sehr viel anfangen kann, werden 8 Bits zu einem Byte zusammengefasst:

Bit, Byte, Megabyte usw. sind Maßeinheiten, um Informationsmengen zu messen. Wie z. B. Millimeter, Zentimeter und Meter für Längeneinheiten. In Bytes werden alle Zeichen wie Zahlen und Wörter ausgedrückt.

8 Bits = 1 Byte

Die Zahl 7 sieht als Byte folgendermaßen aus: 00000111

Bytes werden gesendet, in dem die Datenleitung auf HIGH oder LOW gesetzt wird. Genauso wie wir es beim LED-Tutorial gelernt haben – einschalten/ausschalten. Die eine Kommunikationsseite setzt das Byte, die andere liest es. Eigentlich funktioniert es ähnlich wie in der alten Zeit des Telegrafierens, in dem die Morsetechnik einsetzt, wurde, um Informationen auszutauschen.

Bei der Datenübertragung wird der zu sendende Byte mit einem Start und Stopbit eingerahmt, damit die Empfängerseite weiß, wo die Information anfängt und aufhört. Wir werden uns mit dem Thema Byte und serielle Datenübertragung später noch im Detail auseinandersetzen.

Den Datentransfer auf dem Arduino-Board kannst du wie bereits erwähnt in Realtime beobachten: Es sind zwei LEDs mit der Bezeichnung Tx (transmit) für das Senden und Rx (receive) für das Empfangen auf dem Arduino-Board aufgebracht. Diese flackern, wenn die Daten durchrauschen. Diesen Vorgang kannst du jedes Mal beobachten, wenn du einen Sketch auf das Arduino uploadest. Dann leuchtet die Rx Receive-LED. Werden Daten vom Arduino zum Computer geschickt, leuchtet die Tx Transmit-LED auf.

Eine serielle Verbindung zum Arduino aufbauen

Der folgende Sketch zeigt, wie man in eine serielle Verbindung vom Arduino zum Computer aufbaut. Es wird eine Textnachricht geschickt und in der IDE angezeigt. Wichtig dabei ist natürlich, dass das Board mit deinem Computer über ein USB-Kabel verbunden ist. Eine batteriebetriebene mobile kabellose Anwendung braucht zusätzlich ein Sende-Empfänger-Modul.

Der ganze Sketch

void setup() 
{
  // Inizialisiere die Serielle Kommunikation mit 9600 bauds.
  Serial.begin(9600);
}

void loop() 
{
  // Sende folgende Nachricht an den Computer
  Serial.println("Hello world!");
  delay(1);        // delay wird hier aus Stabilitätsgründen eingesetzt
}

Der Code im Detail

Über die serielle Schnittstelle wird Text in Form von Hello world! verschickt. Zunächst müssen wir dem Arduino klarmachen, dass wir die serielle Ein- und Ausgabe benutzen, so zu sagen eine Kommunikation-Brücke aufbauen wollen. Wir rufen mit der Zeile

  Serial.begin(9600);

die Bibliothek für die serielle Schnittstelle auf. Diese Bibliothek besteht auch aus Code, den wir aber nicht sehen. Das ist das Schöne daran. Sie ist unsichtbar im Hintergrund. Sie enthält Funktionsmodule die wir bei Bedarf aufrufen können.

Mit Serial.beginn() startet die Verbindung zum Computer. Der Parameter innerhalb der Klammer (9600) gibt an, mit welcher Kommunikationsgeschwindigkeit die Geräte Daten austauschen sollen. Stimmt die Übertragungsgeschwindigkeit nicht überein, werden die Informationen nicht erkannt und es erscheint nur Zeichensalat oder gar nichts auf dem seriellen Monitor.

Im oberen Sketch sind es 9600 Baud. Baud gibt an, wie viele Bits pro Sekunde übertragen werden sollen. Es werden also 9600 Bits pro Sekunde versendet. In Bytes sind das 1200 (9600:8 = 1200). Standardmäßig wird Baud 9600 benutzt, es sind aber auch höhere oder niedrigere Werte (von 300 bis 115200) möglich. Je nachdem, wie groß die Datenmenge ist, die übertragen werden soll.

Lade den oberen Sketch auf dein Arduino. Öffne in der IDE den Serial Monitor. Dies ist die serielle Applikation innerhalb der Arduino-Software. Entweder klickst du auf das Lupen-Icon in der oberen rechten Ecke oder du benutzt das Menü: Werkzeuge > Serieller Monitor. Oder die Tastenkombination Shift+CMD+M.

Wenn die Kommunikation hergestellt ist, öffnet sich ein Fenster in dem pausenlos die Zeichen Hello World! ausgegeben wird. In der unteren rechten Ecke findest du eine Baudraten-Dropdown-Box. In diesem steht die Baudrate, die dein Computer nutzt, um sich mit dem Arduino zu synchronisieren. Stimmt dieser nicht mit der Baud 9600 aus dem Arduino-Sketch überein, werden unverständliche Zeichen ausgegeben. Die Kommunikation wäre in diesem Fall fehlgeschlagen.

Wenn Sende- und Empfangsgeschwindigkeit übereinstimmen und trotzdem unleserlicher Text erscheint, überprüfe, ob das korrekte Board im Menü Tools > Board ausgewählt wurde. Bei einigen Boards gibt es Unterschiede bei den Chip-Geschwindigkeiten. Hast du ein falsches Board ausgewählt, musst du dies korrigieren und den Sketch noch einmal hochladen.

Um Daten oder Zeichen zu verschicken, wird der Befehl Serial.println benutzt. Immer, wenn wir das Schnittstellen-Programm benutzen, schreiben wir Serial. und dann die Unterfunktion: println. Es existieren andere Serial Befehle, die wir später behandeln.

Serial.println("Hello world!");

Warum schreiben wir eigentlich Serial? Ist der println-Befehl nicht ausreichend? Antwort: Nein, er ist nicht ausreichend. Zum einen können wir unterscheiden, welche Befehle zu der Bibliothek gehören und zum anderen, kann es passieren, dass wir mehrere Bibliotheken gleichzeitig benutzen, die die gleichen Funktionsnamen haben können.

Zum Beispiel: Serial.write() oder EEPROM.write(). Ein Befehl namens write() kann dann nicht mehr zugeordnet werden.

Zurück zu "Hello world!". Alles was innerhalb der " " steht wird als Text interpretiert. Genannt auch String (eine weitere Variablenart). Selbst wenn wir hier Zahlen verwenden, werden sie vom Programm als Text angesehen.

Serial.println("Hello world!");

Aus Stabilitätsgründen wird in Sketches oft ein sehr kurzes delay() von nur wenigen Millisekunden eingefügt. Ohne diese Zeitverzögerung kann es manchmal zu Fehlern führen.

delay(1);

Wir verschicken soeben Informationen vom Arduino zum Computer. In einem späteren Kapitel werden wir den umgekehrten Weg gehen.

Wozu brauchen wir die Serielle Schnittstelle noch?

Die serielle Schnittstelle wird uns noch super Dienste leisten. Vor allem werden wir sie zur Fehlerfindung einsetzen. ### debug mehr text

 

###Aufgaben