Inhalt. Vorwort... III

Transkript

1

2 Inhalt Vorwort.... XI 1 Erste Schritte Einführung Installation der integrierten Entwicklungsumgebung (IDE) Das Arduino-Board einrichten Einen Arduino-Sketch mit der integrierten Entwicklungsumgebung (IDE) bearbeiten Den Blink-Sketch hochladen und ausführen Einen Sketch erstellen und speichern Arduino verwenden Den Sketch machen lassen, was Sie wollen Einführung Strukturierung eines Arduino-Programms Einfache primitive Typen (Variablen) nutzen Fließkommazahlen verwenden Mit Gruppen von Werten arbeiten Arduino-Stringfunktionen nutzen C-Zeichenketten nutzen Durch Komma getrennten Text in Gruppen aufteilen Eine Zahl in einen String umwandeln Einen String in eine Zahl umwandeln Ihren Code in Funktionsblöcken strukturieren Mehr als einen Wert in einer Funktion zurückliefern Aktionen basierend auf Bedingungen ausführen Eine Folge von Anweisungen wiederholt ausführen III

3 2.14 Anweisungen über einen Zähler wiederholen Aus Schleifen ausbrechen Basierend auf einem Variablenwert verschiedene Aktionen durchführen Zeichen und Zahlen vergleichen Strings vergleichen Logische Vergleiche durchführen Bitweise Operationen durchführen Operationen und Zuweisungen kombinieren Mathematische Operatoren nutzen Einführung Addieren, subtrahieren, multiplizieren und dividieren Werte inkrementieren und dekrementieren Den Rest einer Division bestimmen Den Absolutwert ermitteln Zahlen auf einen Wertebereich beschränken Das Minimum oder Maximum bestimmen Eine Zahl potenzieren Die Quadratwurzel berechnen Fließkommazahlen auf- und abrunden Trigonometrische Funktionen nutzen Zufallszahlen erzeugen Bits setzen und lesen Bits verschieben (Shifting) Höher- und niederwertige Bytes aus int oder long extrahieren int- oder long-werte aus höher- und niederwertigen Bytes bilden Serielle Kommunikation Einführung Debugging-Informationen vom Arduino an Ihren Computer senden Formatierten Text und numerische Daten vom Arduino senden Serielle Daten mit Arduino empfangen Mehrere Textfelder vom Arduino in einer einzelnen Nachricht senden Mit dem Arduino mehrere Textfelder in einer Nachricht empfangen Binäre Daten vom Arduino senden Binärdaten vom Arduino auf einem Computer empfangen Binäre Werte aus Processing an den Arduino senden Den Wert mehrerer Arduino-Pins senden Den Mauszeiger eines PCs oder Macs bewegen IV Inhalt

4 4.11 Google Earth per Arduino steuern Arduino-Daten in einer Datei auf dem Computer festhalten Daten an zwei serielle Geräte gleichzeitig senden Serielle Daten von zwei Geräten gleichzeitig empfangen Serielle Daten mit Processing Senden und Empfangen Einfacher digitaler und analoger Input Einführung Einen Schalter verwenden Taster ohne externen Widerstand verwenden Das Schließen eines Schalters zuverlässig erkennen Ermitteln, wie lange eine Taste gedrückt wird Von einer Tastatur lesen Analogwerte einlesen Wertebereiche ändern Mehr als sechs analoge Eingänge einlesen Spannungen von bis zu 5V messen Auf Spannungsänderungen reagieren Spannungen über 5V messen (Spannungsteiler) Werte von Sensoren einlesen Einführung Movement erkennen Licht messen Motion erkennen (Passive Infrarot-Detektoren integrieren) Abstände messen Abstände genauer messen Vibration messen Geräusche erkennen Temperatur messen RFID-Tags lesen Drehbewegungen messen Mehrere Drehbewegungen messen Drehbewegungen in einem viel beschäftigten Sketch messen Eine Maus nutzen Die Position per GPS bestimmen Bewegungen mit einem Gyroskop erkennen Richtung bestimmen Inhalt V

5 6.17 Daten von einem Spiele-Controller (PlayStation) einlesen Beschleunigung messen Visuelle Ausgabe Einführung LEDs anschließen und nutzen Helligkeit einer LED regeln Hochleistungs-LEDs ansteuern Die Farbe einer LED steuern Mehrere LEDs aneinanderreihen: LED-Balkenanzeige Mehrere LEDs aneinanderreihen: Knight Rider-Lauflicht Eine LED-Matrix per Multiplexing steuern Bilder (Images) auf einer LED-Matrix darstellen Eine LED-Matrix ansteuern: Charlieplexing Eine 7-Segment-LED-Anzeige ansteuern Mehrstellige 7-Segment-LED-Anzeigen ansteuern: Multiplexing Mehrstellige 7-Segment-LED-Anzeigen mit MAX7221-Schieberegistern ansteuern Eine LED-Matrix mit MAX72xx-Schieberegistern ansteuern Die Anzahl analoger Ausgänge mit PWM-Extender-Chips (TLC5940) erhöhen Ein analoges Anzeigeinstrument nutzen Physische Ausgabe Einführung Die Position eines Servos kontrollieren Ein oder zwei Servos mit einem Potentiometer oder Sensor steuern Die Geschwindigkeit dauerrotierender Servos steuern Servos über Computerbefehle steuern Einen bürstenlosen Motor (per Fahrtregler) steuern Hubmagnete und Relais steuern Ein Objekt vibrieren lassen Einen Bürstenmotor über einen Transistor ansteuern Die Drehrichtung eines Bürstenmotors über eine H-Brücke steuern Drehrichtung und Geschwindigkeit eines Bürstenmotors mit einer H-Brücke steuern Richtung und Geschwindigkeit von Bürstenmotoren über Sensoren steuern (L293 H-Brücke) Einen bipolaren Schrittmotor ansteuern VI Inhalt

6 8.13 Einen bipolaren Schrittmotor ansteuern (mit EasyDriver-Board) Einen unipolaren Schrittmotor ansteuern (ULN2003A) Audio-Ausgabe Einführung Töne ausgeben Eine einfache Melodie spielen Mehr als einen Ton gleichzeitig erzeugen Einen Ton erzeugen und eine LED ansteuern Eine WAV-Datei abspielen MIDI steuern Audio-Synthesizer Externe Geräte fernsteuern Einführung Auf eine Infrarot-Fernbedienung reagieren IR-Signale einer Fernbedienung dekodieren IR-Signale imitieren Eine Digitalkamera steuern Wechselstromgeräte über eine gehackte Fernbedienung steuern Displays nutzen Einführung Ein Text-LCD anschließen und nutzen Text formatieren Cursor und Display ein- und ausschalten Text scrollen Sonderzeichen darstellen Eigene Zeichen definieren Große Symbole darstellen Kleine Pixel darstellen Ein graphisches LC-Display anschließen und nutzen Bitmaps für graphische Displays Text auf dem Fernseher ausgeben Datum und Uhrzeit Einführung Zeitverzögerungen Laufzeiten messen mit millis Inhalt VII

7 12.3 Die Dauer eines Impulses präziser messen Arduino als Uhr verwenden Einen Alarm einrichten, um regelmäßig eine Funktion aufzurufen Eine Echtzeituhr nutzen Kommunikation per I2C und SPI Einführung Steuerung einer RGB-LED mit dem BlinkM-Modul Den Wii Nunchuck-Beschleunigungsmesser nutzen Anbindung einer externen Echtzeituhr Externen EEPROM-Speicher anbinden Temperatur per Digital-Thermometer messen Vier 7-Segment-LEDs mit nur zwei Leitungen steuern Einen I2C-Port-Expander integrieren Mehrstellige 7-Segment-Anzeigen über SPI ansteuern Kommunikation zwischen zwei oder mehr Arduino-Boards Drahtlose Kommunikation Einführung Nachrichten über Low-Cost-Drahtlos-Module senden Den Arduino mit einem ZigBee- oder Netzwerk verbinden Eine Nachricht an einen bestimmten XBee senden Sensordaten zwischen XBees senden Einen mit dem XBee verbundenen Aktuator aktivieren Nachrichten über Low-Cost-Transceiver senden Mit Bluetooth-Geräten kommunizieren Ethernet und Netzwerke Einführung Ein Ethernet-Shield einrichten Die IP-Adresse automatisch beziehen Hostnamen in IP-Adressen umwandeln (DNS) Daten von einem Webserver abrufen XML-Daten von einem Webserver abrufen Den Arduino als Webserver einrichten Eingehende Web-Requests verarbeiten Das Anfordern bestimmter Seiten verarbeiten Antworten des Webservers mit HTML aufbereiten Formulare (POST) verarbeiten VIII Inhalt

8 15.11 Webseiten mit großen Datenmengen zurückgeben Twitter-Nachrichten senden Einfache Nachrichten (UDP) senden und empfangen Die Zeit von einem Internet-Zeitserver abrufen Pachube-Feeds überwachen Informationen an Pachube senden Bibliotheken nutzen, ändern und aufbauen Einführung Mitgelieferte Bibliotheken nutzen Bibliotheken von Drittanbietern installieren Eine Bibliothek anpassen Eine eigene Bibliothek entwickeln Eine Bibliothek entwickeln, die andere Bibliotheken nutzt Bibliotheken von Drittanbietern an Arduino 1.0 anpassen Index Inhalt IX

9

10 KAPITEL 4 Serielle Kommunikation 4.0 Einführung Die serielle Kommunikation bietet eine einfache und flexible Möglichkeit, Ihr Arduino- Board mit Ihrem Computer und anderen Geräten interagieren zu lassen. Dieses Kapitel erläutert, wie man auf diese Weise Informationen senden und empfangen kann. In Kapitel 1 wurde beschrieben, wie man den seriellen Port des Arduino mit dem Computer verbindet, um Sketches hochzuladen. Der Upload-Prozess sendet Daten von Ihrem Computer an den Arduino, und der Arduino sendet Statusmeldungen zurück an den Computer, um zu bestätigen, dass der Transfer funktioniert. Die hier vorgestellten Rezepte zeigen, wie Sie diesen Kommunikationslink nutzen können, um beliebige Informationen zwischen dem Arduino und Ihrem Computer (oder einem anderen seriellen Gerät) zu senden und zu empfangen. Die serielle Kommunikation ist auch ein praktisches Tool zur Fehlersuche (Debugging). Sie senden Debugging-Nachrichten vom Arduino an den Computer und geben sie auf dem Bildschirm oder einem externen LC- Display aus. Die Arduino-IDE (beschrieben in Rezept 1.3) stellt einen seriellen Monitor zur Verfügung (siehe Abbildung 4-1), der vom Arduino gesendete serielle Daten ausgibt. Sie können Daten über den seriellen Monitor an den Arduino senden, indem Sie Text in das Textfeld links neben dem Send-Button eingeben. Die Baudrate (die Geschwindigkeit, mit der die Daten übertragen werden, gemessen in Bits pro Sekunde) wird über eine Dropdown-Box am unteren rechten Rand ausgewählt. Sie können die Dropdown-Box namens»no line ending«nutzen, um automatisch ein Carriage Return (Wagenrücklauf) oder eine Kombination aus Carriage Return und Linefeed (Zeilenvorschub) an das Ende jeder Nachricht anzuhängen, sobald der Send-Button angeklickt wird. Ändern Sie dazu einfach»no line ending«in die gewünschte Option. 89

11 Abbildung 4-1: Serieller Monitor des Arduino Ihr Arduino-Sketch kann den seriellen Port nutzen, um indirekt (üblicherweise über ein Proxy-Programm in einer Sprache wie Processing) auf alle Ressourcen (Speicher, Bildschirm, Tastatur, Maus, Netzwerk etc.) Ihres Computers zugreifen zu können. Ihr Computer kann wiederum die serielle Schnittstelle nutzen, um mit Sensoren oder anderen, mit dem Arduino verbundenen Geräten zu interagieren. Die Implementierung einer seriellen Kommunikation verlangt Hard- und Software. Die Hardware sorgt für die elektrischen Signale zwischen dem Arduino und dem Gerät, mit dem er sich unterhält. Die Software nutzt die Hardware, um Bytes oder Bits zu senden, die von der angeschlossenen Hardware verstanden werden. Arduinos serielle Bibliotheken verstecken einen Großteil der Hardware-Komplexität vor Ihnen, es ist aber hilfreich, die Grundlagen zu verstehen, besonders wenn Sie bei Ihren Projekten Probleme mit der seriellen Kommunikation untersuchen müssen. Serielle Hardware Die serielle Hardware sendet und empfängt Daten in Form elektrischer Impulse, die eine sequentielle Folge von Bits darstellen. Die Nullen und Einsen, die die Informationen enthalten, aus denen ein Byte besteht, können auf verschiedene Art repräsentiert werden. Das von Arduino verwendete Schema ist 0 Volt für den Bitwert 0 und 5 (oder 3,3) Volt für den Bitwert 1. Die Verwendung von 0 Volt (für 0) und 5 Volt (für 1) ist weit verbreitet. Man spricht hier vom TTL-Level (Pegel), weil Signale in einer der ersten Implementierungen digitaler Logik, der sog. Transistor-Transistor Logik (TTL), in dieser Form repräsentiert wurden. se A TT g Tr ( TT 90 Kapitel 4: Serielle Kommunikation

12 Boards wie das Uno, Duemilanove, Diecimila, Nano und Mega besitzen einen Chip, der den seriellen Hardware-Port des Arduino-Chips in Universal Serial Bus (USB) umwandelt, um die Verbindung mit dem seriellen Port herzustellen. Andere Boards wie das Mini, Pro, Pro Mini, Boarduino, Sanguino und Modern Device Bare Bones Board unterstützen USB nicht und benötigen für die Verbindung zum Computer einen Adapter, der TTL in USB umwandelt. Weitere Details zu diesen Boards finden Sie unter Main/Hardware. Einige beliebte USB-Adapter sind: Mini USB Adapter ( USB Serial Light Adapter ( FTDI USB TTL Adapter ( Modern Device USB BUB-Board ( Seeedstudio UartSBee ( Einige serielle Geräte verwenden den RS-232-Standard für die serielle Verbindung. Sie haben üblicherweise einen Neun-Pin-Stecker, und ein Adapter wird benötigt, um sie mit dem Arduino verwenden zu können. RS-232 ist ein altehrwürdiges Kommunikationsprotokoll, dessen Spannungspegel mit den Digitalpins des Arduino nicht kompatibel sind. Sie können Arduino-Boards kaufen, die für die RS-232-Signalpegel gebaut sind, etwa das Freeduino Serial v2.0 ( Hier einige RS-232-Adapter, die RS-232-Signale mit den 5 (oder 3,3) Volt der Arduino- Pins verbinden: RS-232 nach TTL 3V5.5V Adapter ( P4 RS232 nach TTL Serial Adapter Kits ( RS232 Shifter SMD ( id=449) Ein Standard-Arduino verfügt über einen einzigen seriellen Hardware-Port, doch die serielle Kommunikation ist auch über Software-Bibliotheken möglich, die zusätzliche Ports (Kommunikationskanäle) emulieren, um mehr als ein Gerät anschließen zu können. Serielle Software-Ports benötigen sehr viel Hilfe vom Arduino-Controller, um Daten senden und empfangen zu können, weshalb sie nicht so schnell und effizient sind wie serielle Hardware-Ports. Das Arduino Mega besitzt vier serielle Hardware-Ports, die mit bis zu vier verschiedenen seriellen Geräten kommunizieren können. Nur bei einem ist ein USB-Adapter integriert (alle anderen seriellen Ports können mit einem USB/TTL-Adapter verbunden werden). Tabelle 4-1 zeigt die Portnamen und -Pins aller seriellen Ports des Mega. 4.0 Einführung 91

13 Tabelle 4-1: Serielle Ports des Arduino Mega Portname Sendepin Empfangspin Serial 1 (auch USB) 0 (auch USB) Serial Serial Serial Serielle Software Sie werden üblicherweise die in Arduino integrierte Serial-Bibliothek verwenden, um mit den seriellen Hardware-Ports zu kommunizieren. Serielle Bibliotheken vereinfachen die Verwendung serieller Ports, indem sie die Komplexität der Hardware vor Ihnen verbergen. Manchmal benötigen Sie mehr serielle Ports, als Hardware-Ports zur Verfügung stehen. In diesem Fall können Sie eine zusätzliche Bibliothek nutzen, die serielle Hardware in Software emuliert. Die Rezepte 4.13 und 4.14 zeigen, wie man eine serielle Bibliothek nutzt, um mit mehreren Geräten zu kommunizieren. Serielles Protokoll Die Hardware- und Software-Bibliotheken übernehmen das Senden und Empfangen von Informationen. Diese Informationen bestehen häufig aus Gruppen von Variablen, die zusammen gesendet werden müssen. Damit diese Informationen korrekt interpretiert werden können, muss die Empfangsseite erkennen, wo eine Nachricht beginnt und endet. Eine sinnvolle serielle Kommunikation bzw. jede Art der Maschine/Maschine-Kommunikation kann nur erreicht werden, wenn die sendende und die empfangende Seite genau darin übereinstimmen, wie die Informationen in den Nachrichten organisiert sind. Die formale Organisation einer Nachricht und die Menge korrekter Antworten auf Anfragen wird Kommunikationsprotokoll genannt. Nachrichten können ein oder mehr spezielle Zeichen enthalten, die den Anfang einer Nachricht markieren das bezeichnet man als Header (Kopf). Ein oder mehr Zeichen können auch genutzt werden, um das Ende der Nachricht zu kennzeichnen das bezeichnet man als Footer (Fuß). Die Rezepte dieses Kapitels zeigen beispielhafte Nachrichten, bei denen die Werte des Rumpfs (Body, also die eigentlichen Nutzdaten) im Textoder Binärformat gesendet werden. Das Senden und Empfangen von Nachrichten im Textformat verlangt das Senden von Befehlen und numerischen Werten in Form von für Menschen lesbaren Buchstaben und Wörtern. Zahlen werden als Strings von Ziffern gesendet, die den Wert repräsentieren. Ist der Wert beispielsweise 1234, dann werden die Zeichen 1, 2, 3 und 4 als einzelne Zeichen gesendet. Binäre Nachrichten bestehen aus den Bytes, die der Computer zur Repräsentation der Werte verwendet. Binärdaten sind effizienter (weil weniger Bytes gesendet werden müsse se N Ko Ko ( k o 92 Kapitel 4: Serielle Kommunikation

14 sen), doch die Daten sind für uns Menschen nicht so einfach zu lesen, was die Fehlersuche erschwert. Arduino stellt die Zahl 1234 beispielsweise mit den Bytes 4 und 210 (4 * = 1234) dar. Wenn das verbundene Gerät nur Binärdaten sendet oder empfängt, bleibt Ihnen keine andere Wahl, als mit diesem Format zu arbeiten, doch wenn Sie die Wahl haben, sind Textnachrichten einfacher zu implementieren und zu debuggen. Es gibt viele Möglichkeiten, Softwareprobleme anzugehen, und einige Rezepte dieses Kapitels bieten zwei oder drei unterschiedliche Lösungen für das gleiche Ergebnis an. Die Unterschiede (z.b. das Senden von Text anstelle reiner Binärdaten) liegen im Verhältnis von Einfachheit und Effizienz. Wo eine Auswahl angeboten wird, sollten Sie die Lösung wählen, die Sie am besten verstehen und adaptieren können (üblicherweise die erste Lösung). Die Alternativen sind möglicherweise etwas effizienter, oder für ein bestimmtes Protokoll besser geeignet, aber die»richtige Lösung«ist diejenige, die in Ihrem Projekt am einfachsten eingesetzt werden kann. Die Processing-Entwicklungsumgebung Einige Beispiele in diesem Kapitel verwenden die Sprache Processing, um serielle Meldungen auf einem Computer zu senden und zu empfangen. Processing ist ein freies Open-Source-Tool, das eine ähnliche Entwicklungsumgebung nutzt wie Arduino. Statt aber Sketches auf dem Mikrocontroller auszuführen, laufen Processing-Sketches auf Ihrem Computer. Alle Informationen zu Processing und zum Download finden Sie auf der Processing-Website ( Processing basiert auf Java, doch die Processing-Codebeispiele in diesem Buch sollten sich recht einfach in anderen Umgebungen nutzen lassen, die die serielle Kommunikation unterstützen. Processing wird mit einigen Beispiel-Sketches ausgeliefert, die die Kommunikation zwischen Arduino und Processing illustrieren. SimpleRead ist ein Arduino- Code enthaltendes Processing-Beispiel. In Processing wählen Sie File Examples Libraries Serial SimpleRead. Das Beispiel liest Daten über den seriellen Port ein und ändert die Farbe eines Rechtecks, wenn ein am Arduino angeschlossener Taster gedrückt oder losgelassen wird. Neues in Arduino 1.0 Arduino 1.0 führt eine Reihe von Verbesserungen und Änderungen bei der Serial-Bibliothek ein: Serial.flush wartet nun, bis alle ausgehenden Daten gesendet wurden, statt empfangene Daten einfach auszusortieren. Mit der folgenden Anweisung können Sie alle Daten aus dem Empfangspuffer löschen: while(serial.read() >= 0) ; // Empfangspuffer leeren Serial.write und Serial.print»blockieren«nicht. Der alte Code hat gewartet, bis alle Zeichen gesendet waren, bevor er zurückkehrte. Seit 1.0 werden von Serial.write gesendete Daten im Hintergrund übertragen (über einen Interrupthandler), d.h., der 4.0 Einführung 93

15 Sketch kann seine Arbeit direkt wieder aufnehmen. Üblicherweise ist das eine gute Sache (der Sketch reagiert schneller), doch manchmal muss man warten, bis alle Zeichen gesendet wurden. Sie erreichen das, indem Sie Serial.flush() gleich nach Serial.write() aufrufen. Die print-funktionen von Serial geben die Anzahl der ausgegebenen Zeichen zurück. Das ist nützlich, wenn die Textausgaben ausgerichtet werden müssen, oder wenn die übertragenen Daten die Gesamtzahl der gesendeten Zeichen enthalten. Ein Parsing ist für Streams wie Serial fest integriert, um Zahlen extrahieren und Text aufspüren zu können. Mehr zu diesen Möglichkeiten bei Serial zeigt Rezept 4.5. Die bei Arduino mitgelieferte SoftwareSerial-Bibliothek wurde stark verbessert. Siehe 4.13 und Die Funktion Serial.peek wurde hinzugefügt, mit der Sie sich das nächste Zeichen im Empfangspuffer ansehen können. Im Gegensatz zu Serial.read wird das Zeichen mit Serial.peek nicht aus dem Puffer entfernt. Siehe auch Eine Arduino-Einführung zu RS-232 finden Sie unter ArduinoSoftwareRS232. Sehr viele Informationen und Links sind auch auf der Serial Port Central-Website zu finden. Darüber hinaus gibt eine Reihe von Büchern zu Processing: Processing (ISBN ) von Erik Bartmann, erschienen bei O Reilly. Getting Started with Processing: A Quick, Hands-on Tutorial von Casey Reas und Ben Fry (Make). Processing: A Programming Handbook for Visual Designers and Artists von Casey Reas und Ben Fry (MIT Press). Visualizing Data von Ben Fry (O Reilly; suchen Sie bei oreilly.de) danach. Processing: Creative Coding and Computational Art von Ira Greenberg (Apress). Making Things Talk (ISBN ) von Tom Igoe (Make). Dieses Buch behandelt Processing und Arduino und enthält viele Beispiele für Kommunkationscode. Bei O Reilly erschienen. Se Pr 4.1 Debugging-Informationen vom Arduino an Ihren Computer senden Problem Sie wollen Texte und Daten senden, die auf Ihrem PC oder Mac in der Arduino-IDE oder einem Terminalprogramm Ihrer Wahl ausgegeben werden sollen. se D 94 Kapitel 4: Serielle Kommunikation

16 Lösung Dieser Sketch gibt eine Folge von Zahlen über den seriellen Monitor aus: /* * SerialOutput Sketch * Gibt Zahlen am seriellen Port aus */ void setup() Serial.begin(9600); // Senden und Empfangen mit 9600 Baud int number = 0; void loop() Serial.print("Die Zahl ist "); Serial.println(number); // Zahl ausgeben delay(500); // Halbe Sekunde warten number++; // Nächste Zahl Verbinden Sie den Arduino wie in Kapitel 1 beschrieben mit dem Computer und laden Sie den Sketch hoch. Klicken Sie das Icon für den seriellen Monitor in der IDE an, und die folgende Ausgabe sollte erscheinen: Die Zahl ist 0 Die Zahl ist 1 Die Zahl ist 2 Diskussion Um Texte oder Zahlen von Ihrem Sketch auf einem PC oder Mac über den seriellen Link auszugeben, fügen Sie die Anweisung Serial.begin(9600) in setup() ein und verwenden dann Serial.print()-Anweisungen, um die gewünschten Texte oder Werte auszugeben. Der serielle Monitor kann vom Arduino gesendete serielle Daten ausgeben. Um den seriellen Monitor zu starten, klicken Sie das Icon in der Werkzeugleiste an (siehe Abbildung 4-2). Ein neues Fenster wird geöffnet, das die Ausgaben des Arduino enthält. 4.1 Debugging-Informationen vom Arduino an Ihren Computer senden 95

17 Abbildung 4-2: Serieller Monitor des Arduino Ihr Sketch muss Serial.begin() aufrufen, bevor er die serielle Ein- und Ausgabe nutzen kann. Die Funktion verlangt einen einzelnen Parameter: die gewünschte Kommunikationsgeschwindigkeit. Sie müssen auf Sende- und Empfangsseite die gleiche Geschwindigkeit einstellen, sonst erscheint auf dem Bildschirm nur Zeichensalat (oder gar nichts). Diese Beispiele (und die meisten anderen in diesem Buch) verwenden eine Geschwindigkeit von 9600 Baud (Baud ist das Maß für die Zahl der pro Sekunde übertragenen Bits). Eine Baudrate von 9600 entspricht ungefähr 1000 Zeichen pro Sekunde. Sie können kleinere und höhere Geschwindigkeiten (von 300 bis ) einstellen, müssen aber sicherstellen, das auf beiden Seiten die gleiche Geschwindigkeit verwendet wird. Der serielle Monitor legt die Geschwindigkeit über die Baudraten-Dropdown-Box (am unteren rechten Rand des Seriellen-Monitor-Fensters in Abbildung 4-2) fest. Wenn Ihre Ausgabe eher so aussieht: `3??f<ÌxÌ///ü`3??f< sollten Sie überprüfen, ob die im seriellen Monitor gewählte Baudrate der Baudrate entspricht, die Sie im Sketch bei Serial.begin() angegeben haben. Ba Wenn Sende- und Empfangsgeschwindigkeit übereinstimmen und trotzdem unleserlicher Text erscheint, überprüfen Sie, ob das korrekte Board im Menü Tools Board ausgewählt wurde. Bei einigen Boards gibt es Unterschiede bei den Chip-Geschwindigkeiten, und wenn Sie den falschen gewählt haben, müssen Sie das korrigieren und das Programm noch einmal hochladen. 96 Kapitel 4: Serielle Kommunikation

18 Sie können Text mit der Funktion Serial.print()ausgeben. Strings (zwischen Anführungszeichen stehender Text) wird unverändert (aber ohne die Anführungszeichen) ausgegeben. Der folgende Code: Serial.print("Die Zahl ist "); gibt also Folgendes aus: Die Zahl ist Die ausgegebenen Werte (Zahlen) hängen vom Variablentyp ab. Mehr zu diesem Thema finden Sie in Rezept 4.2. Für ein Integer wird zum Beispiel der numerische Wert ausgegeben. Ist die Variable number auf 1 gesetzt, dann gibt der Code: Serial.println(number); Folgendes aus: 1 Im Beispiel-Sketch wird beim Start der Schleife zuerst der Wert 0 ausgegeben und dann bei jedem Schleifendurchlauf erhöht. Das ln am Ende von println sorgt dafür, dass die nächste Ausgabe in der nächsten Zeile beginnt. Sie sind nun soweit, Texte und Integerwerte ausgeben zu können. Details zu Formatoptionen finden Sie in Rezept 4.2. Sie könnten auch mit einem Terminalprogramm von einem Drittanbieter liebäugeln, das über mehr Features verfügt als der serielle Monitor. Die Darstellung von Daten im Textoder Binärformat (oder beides), Darstellung von Steuerzeichen und das Logging in eine Datei sind nur einige zusätzliche Fähigkeiten vieler Terminalprogramme. Hier einige Programme, die von Arduino-Benutzern empfohlen wurden: CoolTerm ( Ein einfach zu nutzendes Freeware-Terminal-Programm für Windows, Mac und Linux CuteCom ( Ein Open-Source-Terminal-Programm für Linux Bray Terminal ( Ein freies Programm für den PC GNU screen ( Ein Open-Source-Programm zur Verwaltung virtueller Bildschirme, das die serielle Kommunikation unterstützt. Bei Linux und Mac OS X enthalten moserial ( Ein weiteres Open-Source-Terminal-Programm für Linux PuTTY ( Ein Open-Source- SSH-Programm für Windows und Linux, das die serielle Kommunikation unterstützt 4.1 Debugging-Informationen vom Arduino an Ihren Computer senden 97

19 RealTerm ( Ein Open- Source-Terminal-Programm für den PC ZTerm ( Ein Shareware- Programm für den Mac Ein Artikel im Arduino-Wiki erläutert außerdem, wie man Linux konfiguriert, um mit dem Arduino per TTY zu kommunizieren (siehe LinuxTTY). Sie können ein LC-Display für die serielle Ausgabe verwenden, auch wenn die Funktionalität stark eingeschränkt ist. Schauen Sie in der Dokumentation nach, wie das Display Carriage-Returns handhabt, da einige Displays bei println-anweisungen nicht automatisch zur nächsten Zeile springen. Siehe auch Die Arduino-Bibliothek LiquidCrystal für Text-LCDs besitzt eine print-funktionalität, die derjenigen der Serial-Bibliothek ähnelt. Viele der in diesem Kapitel gegebenen Vorschläge können auch mit dieser Bibliothek umgesetzt werden (siehe Kapitel 11). 4.2 Formatierten Text und numerische Daten vom Arduino senden Problem Sie wollen vom Arduino serielle Daten senden, die als Text, als Dezimalwert, als Hexadezimalwert oder als Binärwert ausgegeben werden sollen. Lösung Sie können Daten in vielen verschiedenen Formaten über den seriellen Port ausgeben. Hier ein Sketch, der alle Formatoptionen vorstellt: /* * SerialFormatting * Gibt Werte in verschiedenen Formaten über den seriellen Port aus */ char chrvalue = 65; // Startwert für die Ausgabe byte bytevalue = 65; int intvalue = 65; float floatvalue = 65.0; Re ZT Li se se fo Za v D H Bi Te Se void setup() Serial.begin(9600); void loop() 98 Kapitel 4: Serielle Kommunikation

20 Serial.println("chrValue: "); Serial.println(chrValue); Serial.write(chrValue); Serial.println(); Serial.println(chrValue,DEC); Serial.println("byteValue: "); Serial.println(byteValue); Serial.write(byteValue); Serial.println(); Serial.println(byteValue,DEC); Serial.println("intValue: "); Serial.println(intValue); Serial.println(intValue,DEC); Serial.println(intValue,HEX); Serial.println(intValue,OCT); Serial.println(intValue,BIN); Serial.println("floatValue: "); Serial.println(floatValue); delay(1000); // Eine Sekunde Warten chrvalue++; // Nächster Wert bytevalue++; intvalue++; floatvalue +=1; Die Ausgabe (hier auf wenige Zeilen gekürzt) sieht wie folgt aus: chrvalue: A A 65 bytevalue: 65 A 65 intvalue: floatvalue: chrvalue: B B 66 bytevalue: 66 B 66 intvalue: floatvalue: Diskussion Die Ausgabe eines Textstrings ist einfach: Serial.print("Hallo, Welt"); sendet den Textstring»Hallo, Welt«an das Gerät am Ende des seriellen Ports. Soll nach jeder Zeile ein Zeilenvorschub (Newline) ausgegeben werden, verwenden Sie Serial.println()statt Serial.print(). Die Ausgabe numerischer Werte kann etwas schwieriger sein. Wie Byte- und Integerwerte ausgegeben werden, hängt vom Variablentyp und einem optionalen Formatparameter ab. Die Arduino-Sprache ist recht locker, wenn es um die Übergabe von Werten an unterschiedliche Datentypen geht (mehr zu Datentypen finden Sie in Rezept 2.2). Doch diese Flexibilität kann verwirrend sein, weil die numerischen Werte, selbst wenn sie gleich sind, vom Compiler als verschiedene Typen mit unterschiedlichen Charakteristika betrachtet 4.2 Formatierten Text und numerische Daten vom Arduino senden 99