Erik Bartmann, Die elektronische Welt mit Arduino ... · Erik Bartmann, Die elektronische Welt mit...

Erik Bartmann, Die elektronische Welt mit Arduino entdecken, O´Reilly, ISBN 97839556111569783955611156

D3kjd3Di38lk323nnm

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- III

Inhalt

Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . VII

1 Was ist ein Mikrocontroller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1Wozu kann man ihn verwenden?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2Allgemeiner Aufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 Die Arduino-Familie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11Was für Arduino-Boards gibt es? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

3 Das jüngste Arduino-Kind: Der Yún . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29Einführung Arduino Yún . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30Erste Schritte mit dem Yún . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

4 Das Arduino-Board ausführlich vorgestellt . . . . . . . . . . . . . . . . . . . . . . 101Die Stromversorgung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105Die Kommunikationswege. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106Die Programmiersprachen C/C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109Wie und womit kann ich Arduino programmieren? . . . . . . . . . . . . . . . . . . . . . . . 111Die Arduino-Entwicklungsumgebung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124Die Portkommunikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136Befehl und Gehorsam. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

5 Die Elektronik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145Was ist Elektronik eigentlich? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145Bauteile. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157Weitere interessante Bauteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- InhaltIV

6 Elektronische Grundschaltungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199Widerstandsschaltungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199Kondensatorschaltungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207Transistorschaltungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209

7 Fritzing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215Die Oberfläche der Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216Das Fritzing Creator Kit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233Wo finde ich was? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237

8 Das Zusammenfügen der Bauteile und weitere Tipps . . . . . . . . . . 239Was ist eine Platine? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239Das Steckbrett (Breadboard) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241Verschiedene Kabel und ihre Tücken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244Die flexiblen Steckbrücken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247Die Durchgangsprüfung mit einem Multimeter . . . . . . . . . . . . . . . . . . . . . . . . . . 250

9 Nützliches Equipment. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253Nützliches Equipment. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253

10 Grundlegendes zur Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . 273Was ist ein Programm bzw. ein Sketch? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273Was bedeutet Datenverarbeitung? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275Die Struktur eines Arduino-Sketches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292Wie lange läuft ein Sketch auf dem Board? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295

11 Die Programmierung des Arduino-Boards . . . . . . . . . . . . . . . . . . . . . . 297Die digitalen Ports . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297Die analogen Ports. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299Die serielle Schnittstelle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306

12 Elektronikprojekte mit dem Arduino-Board . . . . . . . . . . . . . . . . . . . . . 30712-1: Der erste Sketch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30912-2: Einen Sensor abfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32112-3: Blinken mit Intervallsteuerung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33912-4: Der störrische Taster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35112-5: Ein Lauflicht. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36312-6: Porterweiterung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37712-7: Porterweiterung mal 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39712-8: Die State Machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413


Inhalt ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- V

12-9: Der elektronische Würfel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43512-10: Der elektronische Würfel (und wie erstelle ich eine Bibliothek?) . . . . . . . . 45912-11: Das Mini-Roulette. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48312-12: Lichtsensoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49712-13: Der Richtungsdetektor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51112-14: Die Ansteuerung eines Servos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52112-15: Das Lichtradar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53312-16: Das Tisch-Sonar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54312-17: Die Siebensegmentanzeige . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56712-18: Die Siebensegmentanzeige (mir gehen die Pins aus). . . . . . . . . . . . . . . . . . 58312-19: Der Reaktionstester. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59512-20: Das KeyPad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61112-21: Das KeyPad (diesmal ganz anders) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62712-22: Eine Alphanumerische Anzeige . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64112-23: Kommunikation über I2C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66112-24: Der Schrittmotor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69512-25: Der ArduBot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70912-26: Die Temperatur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72312-27: Der Sound und mehr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74112-28: Data Monitoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75712-29: Der Arduino-Talker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76912-30: Die drahtlose Kommunikation über Bluetooth . . . . . . . . . . . . . . . . . . . . . 78112-31: Bluetooth und das Android-Smartphone . . . . . . . . . . . . . . . . . . . . . . . . . . 79712-32: Der ArduBot wird funkgesteuert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80312-33: Netzwerk-Kommunikation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81112-34: Ein TFT ansteuern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82912-35: Digital ruft analog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86712-36: Interrupt-Steuerung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88112-37: Arduino-Interaktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90512-38: Yún Prozesse starten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92512-39: Der Webserver des Yún . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93112-40: Temboo für den Yún nutzen – Twitter-API . . . . . . . . . . . . . . . . . . . . . . . . 95312-41: Temboo für den Yún nutzen – Google Spreadsheet . . . . . . . . . . . . . . . . . . 97912-42: Der Yún und die Datenbank. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99112-43: Das Arduino-SimpleBoard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102712-44: Der Shieldbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1033

A Wo bekomme ich was? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1043

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1045

FirstHier Mini IVZ eingeben!

Abstand untere Tabellenlinie zu Textanfang 1,8 cm-> also: manuell auf den Arbeitsseiten ziehen!!!

Erstellen auf denArbeitsseiten(siehe Muster)

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 101

Kapitel 4 4Das Arduino-Board ausführlich vorgestellt

In diesem Kapitel möchte ich mit dem Hauptakteur beginnen, umden sich alles dreht. Das Arduino-Mikrokontroller-Board. Ich ver-wende dazu das Modell Arduino Uno, weil es das momentan popu-lärste Arduino-Board ist. Werfen wir zunächst einen Blick auf dasObjekt der Begierde.

Abbildung 4-1Das Arduino-Board

Auf diesem Bild kannst du natürlich nicht erkennen, welche gerin-gen Ausmaße das Arduino-Mikrocontroller-Board hat. Mit den fol-genden Maßen ist es wirklich sehr handlich:

• Breite: ca. 7 cm

• Länge: ca. 5 cm

---------------------------------------------------------------------------------------------------------------------------------------------- Kapitel 4: Das Arduino-Board ausführlich vorgestellt102

Der Arduino passt locker in eine Hand und ist sehr kompakt. Wirerkennen auf der Platine die unterschiedlichsten Bauteile, auf die ichnoch im Detail eingehen werde. Der größte Mitspieler, der uns direktins Auge fällt, ist der Mikrocontroller selbst. Er ist vom Typ ATmega328. Über die Jahre wurden die unterschiedlichsten Arduino-Boardsentwickelt, die mit abweichender Hardware bestückt sind. Ich habemich für das Board mit der Bezeichnung Arduino Uno R3 entschie-den, das sich trotz weiterer Nachfolgeboards wie z.B. Arduino Dueoder Arduino Yún zum Quasi-Standard herauskristallisiert hat. Fürden Einstieg in die Mikrocontroller-Thematik ist das Board hervorra-gend geeignet. Jetzt ist es an der Zeit, einen genaueren Blick in Rich-tung Arduino zu riskieren. Aus welchen einzelnen Komponentenbesteht unsere kleine Platine, die so unscheinbar vor uns liegt?Manch einer mag behaupten, dass auf so kleinem Raum kaum etwasPlatz hat, mit dem sich etwas anfangen lässt. Doch in den letzten Jah-ren sind die Bauteile immer kleiner geworden, und was früher z.B. infünf separaten Chips untergebracht war, leistet heute ein einziger.

Abbildung 4-2Was ist wo auf der Arduino-

Experimentierplatine?

Das sind für den Anfang die wichtigsten Komponenten auf demArduino-Board, was natürlich nicht bedeutet, dass die restlichenfür uns uninteressant sind. Auf einige andere kommen wir zu gege-bener Zeit zu sprechen. Jetzt endlich die Frage, die sicherlich allebrennend interessiert. Was kann das Arduino-Board? Zunächst ein-mal die Eckdaten:

• Mikrocontroller ATmega 328

• 5V Betriebsspannung


Das Arduino-Board ausführlich vorgestellt ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 103

• 14 digitale Ein- bzw. Ausgänge (6 als PWM-Ausgänge schaltbar)

• 6 analoge Eingänge (Auflösung 10Bit)

• 32Kbyte Flash-Speicher (vom Bootloader werden 0,5KBytebelegt)

• 2KByte SRAM

• 1KByte EEPROM

• 16MHz Taktfrequenz

• USB-Schnittstelle

Wie du aus der eben gezeigten Liste entnehmen kannst, steht unszur Kommunikation mit dem Arduino-Board eine bestimmteAnzahl Ein- bzw. Ausgänge zur Verfügung. Sie stellen die Schnitt-stelle zur Außenwelt dar und ermöglichen uns, Daten an den Mi-krocontroller zu senden bzw. von ihm zu empfangen. Wirf einenBlick auf das folgende Diagramm:

Abbildung 4-3Ein- und Ausgänge des Arduino-Boards

Der blaue Kasten auf der linken Seite symbolisiert den Arduino-Mikrocontroller, der über bestimmte Schnittstellen mit uns kom-munizieren kann. Manche Ports sind als Eingänge, andere als Ein-bzw. Ausgänge vorhanden. Ein Port ist dabei ein definierterZugangsweg zum Mikrocontroller, quasi eine Tür ins Innere, dererwir uns bedienen können. Wirf noch einmal einen Blick auf dasBoard, und du wirst an der Ober- bzw. Unterkante jeweilsschwarze Buchsenleisten erkennen.

Ein bescheidene Frage: Was soll daran so besonders sein? Kann ich inirgendeiner Weise mit dem Mikrocontroller kommunizieren? Undwenn ja, wie?


Das hast du gut beobachtet, Ardus! Ich muss dir aber sagen, dassdas Diagramm vollkommen korrekt ist. Der Grund ist folgender (erwird später noch näher beleuchtet): Unser Arduino-Board ist nichtmit separaten analogen Ausgängen bestückt. Das hört sich erst ein-mal recht merkwürdig an, doch bestimmte digitale Pins werden alsanaloge Ausgänge missbraucht. Du fragst dich bestimmt, wie dasfunktionieren soll. Ich mache einen kleinen Vorgriff auf das, wasnoch im Kapitel über die Puls-Weiten-Modulation, auch PWMgenannt, kommt. Das ist ein Verfahren, bei dem ein Signal mehroder weniger lange An- bzw. Ausphasen vorweist. Ist die Anphase,also wenn der Strom fließt, länger als die Ausphase, leuchtet zumBeispiel eine angeschlossene Lampe augenscheinlich heller, alswenn die Ausphase länger ist. Ihr wird also mehr Energie in einerbestimmten Zeit in Form von elektrischem Strom zugeführt. Auf-grund seiner Trägheit kann unseres Auge sehr schnell wechselndeEreignisse nicht unterscheiden und auch die Lampe weist beimHin- und Herschalten zwischen den beiden Zuständen Ein bzw.Aus eine gewisse Trägheit auf. Dadurch hat es für uns denAnschein einer sich verändernden Ausgangsspannung. Klingt etwasmerkwürdig, nicht wahr? Du wirst es ganz sicher besser verstehen,wenn wir das entsprechende Kapitel erreichen. Einen offensichtlichentscheidenden Nachteil hat diese Art der Portverwaltung schon.Verwendest du einen oder mehrere analoge Ausgänge, geht das zuLasten der digitalen Portverfügbarkeit. Du hast dafür eben wenigerzur Verfügung. Doch das soll uns nicht weiter stören, denn wirkommen nicht an die Grenzen, die eine Einschränkung unsererVersuchsaufbauten bedeuten würde.

Ok, Ardus, das hätte ich beinahe vergessen! Ein Bootloader ist einkleines Programm, das in einem bestimmten Bereich des Flash-Speichers auf dem Mikrocontrollerboard seinen Platz findet und fürdas Laden des eigentlichen Programms verantwortlich ist. Norma-lerweise wird ein Mikrocontroller über eine zusätzliche Hardware,z.B. einen ISP-Programmer, mit dem Arbeitsprogramm versehen.

Moment! Irgendetwas stimmt hier nicht. Unser Mikrocontrollersollte doch analoge wie digitale Ein- bzw. Ausgangsports vorweisen.Im Diagramm sehe ich jedoch von den analogen Ports nur Eingänge.Wo sind die Ausgänge? Da hast du sicherlich etwas vergessen!

Bevor du weiter in dem Tempo erzählst, muss ich dich wieder einmalstoppen. Du hast in der Aufzählung der Eckdaten des Arduino-Boards einen Bootloader erwähnt. Was ist genau ein Bootloader?


Die Stromversorgung ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 105

Durch den Bootloader entfällt diese Notwendigkeit, und so gestal-tet sich das Uploaden der Software wirklich komfortabel. Nachdem erfolgreichen Übertragen des Arbeitsprogramms in denArbeitsspeicher des Controllers wird es unmittelbar zur Ausfüh-rung gebracht. Angenommen, du müsstest deinen MikrocontrollerATmega 328 auf der Platine aus irgendeinem Grund austauschen,dann würde der Neue nicht wissen, was zu tun wäre, da der Boot-loader standardmäßig noch nicht geladen ist. Für diese Prozedurgibt es verschiedene Verfahren, die ich aus Platzgründen nichterklären kann. Im Internet finden sich aber genügend Informatio-nen, wie du den passenden Bootloader für den Mikrocontroller in-stallieren kannst. Besuch doch einfach einmal meine Internetseite.

Die StromversorgungDamit unser Arduino-Board auch arbeiten kann, muss es in irgendei-ner Weise mit Energie versorgt werden. Diese Versorgung erfolgt inerster Linie über die USB-Schnittstelle, die das Board mit dem Rechnerverbindet. Über diesen Weg werden übrigens auch Daten zwischenBoard und Rechner ausgetauscht. Wenn du dich also in der Entwick-lungsphase mit deinem Arduino befindest, ist das die primäre Versor-gung für das Board. Die zweite Möglichkeit besteht im Anschlusseiner Batterie oder eines Netzgerätes an den Poweranschluss, der auchPower Jack genannt wird. Diese Variante kannst du z.B. verwenden,wenn du ein fahrbares Vehikel gebaut hast, das durch den Arduinogesteuert wird. Das Gefährt soll sich unabhängig von einem Kabelan-schluss frei im Raum bewegen können, ohne am meist zu kurzen USB-Kabel hängen zu bleiben – ein autarkes Gefährt halt.

Abbildung 4-4Spannungsversorgung des Arduino-Boards


Hier zeige ich dir einmal die unterschiedlichen Steckervarianten.Du kannst sie nicht vertauschen, da sie vollkommen unterschiedli-che Formen aufweisen und auch ganz abweichende Funktioneninnehaben.

Wenn es um Strom bzw. Spannung geht, sollten wir einen Blick aufdie folgende Tabelle werfen:

Tabelle 4-1Strom- bzw. Spannungswerte

Eine Bezeichnung DC hinter den Voltangaben bedeutet Direct Cur-rent, was übersetzt Gleichstrom bedeutet. Die USB-Schnittstellekann maximal einen Strom von 500mA liefern. Das reicht aus, umdie meisten Versuchsschaltungen aus diesem Buch zu realisieren.Sie ist sogar gegen Kurzschlüsse und zu hohe Ströme derartgeschützt, dass eine sogenannte Poly-Sicherung ausgelöst wird. Dassollte aber nicht bedeuten, dass du weniger Sorgfalt beim Aufbaueiner Schaltung walten lässt. Erinnere dich daran, was ich dir in derEinleitung über einen USB-Hub gesagt habe, und beherzige es.

Die KommunikationswegeSo ein Mikrocontroller-Board hat eine Menge Anschlüsse, die esauseinanderzuhalten gilt. Du musst sehen, dass du den Überblickbewahrst und die Dinge nicht durcheinanderbringst. Doch dieseVerwirrung – wenn sie überhaupt aufgekommt – zeigt sich nur amAnfang. Nach ein paar Tagen gehen dir diese Feinheiten in Fleischund Blut über. Wollen wir einmal die Unterschiede aufzählen.

USB-Stecker Power Jack

Kategorie Wert

Betriebsspannung 5V (DC)

Spannungsversorgung über Extern (empfohlen) 7 – 12V (DC)

Spannungsversorgung über Extern (Grenzwerte) 6 – 20V (DC)

Gleichstrom pro Pin (maximal) 40mA


Die Kommunikationswege ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 107

Der USB-PortDa haben wir zum einen den USB-Port. Ohne ihn wärst du nicht inder Lage, anfänglich mit dem Board in irgendeiner Weise zu kom-munizieren. Wir können das Arbeiten mit dem Arduino-Board inzwei Phasen unterteilen. Die Zeit, in der du bestrebt bist, dein Pro-jekt umzusetzen, also Programmierarbeit verrichtest und dirGedanken über die Peripherie machst, nennt sich Entwicklungszeit(engl. Designtime). Die Programmierung erfolgt mit Hilfe einer Ent-wicklungsumgebung, die du gleich kennenlernen wirst. In ihr wirddas von dir erstellte Programm eingegeben und zum Mikrocontrol-ler übertragen. Ist das erfolgreich verlaufen, beginnt sofort die Lauf-zeit (engl. Runtime). Du musst dem Mikrocontroller also nichtexplizit sagen: »So, mein Freund, jetzt fang an zu arbeiten!« Er legtsofort los, wenn er alle Instruktionen von dir erhalten hat. Zusätz-lich kannst du aber auch Daten über den USB-Port von deinemComputer empfangen oder an ihn versenden. Wie das funktioniert,werden wir später noch sehen.

Die Ein- bzw. AusgabeportsKommen wir zu den eigentlichen Ports, die die Schnittstelle desMikrocontrollers darstellen. Es sind quasi Augen, Ohren undMund des Controllers, so wie diese Organe bei uns Menschen auchDaten empfangen bzw. aussenden. Es findet eine Interaktion durchund über diese Kommunikationskanäle mit der Umgebung statt.Dein Arduino nutzt einerseits Sensordaten (z.B. Temperatur, Licht,Feuchtigkeit) zur internen Bewertung, die durch seine Programmie-rung vorgegeben wurde. Er wird darauf reagieren und dir seine Ent-scheidung in Form von bestimmten Aktionen mitteilen. Daskönnen Lichtsignale, Töne oder auch Bewegungen über ange-schlossene Aktoren (Motoren + Sensoren) sein.

Du hast sicherlich erkannt, dass wir es mit zwei steuerungstechni-schen Signal-Kategorien zu tun haben. Sensoren liefern Datenund Aktoren wandeln Eingangsgrößen in Ausgangsgrößen um.Dieser Prozess verläuft nach dem EVA-Prinzip (Eingabe, Verarbei-tung, Ausgabe).

Abbildung 4-5EVA-Prinzip


Wo befinden sich diese Ein- bzw. Ausgabeports auf unseremArduino-Board? Hältst du es so herum, dass du den SchriftzugUNO lesen kannst, dann befinden sich die digitalen Ein- bzw. Aus-gabeports am oberen Rand. (1 x Zehner- / 1 x Achterblock)

Abbildung 4-6Digitale Ein- bzw. Ausgänge

Natürlich ist es wichtig zu wissen, welcher Port welche Bezeich-nung hat, um ihn später in der Programmierung eindeutig anspre-chen zu können. Deshalb ist jeder einzelne Pin mit einer Nummerversehen. Beachte, dass die Nummerierung des ersten Pins mit 0beginnt. Auf dieses Phänomen wirst du während deiner Program-mierung noch des Öfteren stoßen. Fast jegliche Aufzählung beginntmit der Ziffer 0. Unterhalb vereinzelter Ziffern befindet sich einTilde-Zeichen (~), das auf den Umstand hindeutet, dass dieser Pinauch als analoger Ausgang geschaltet werden kann. Es handelt sichum einen PWM-Pin (Du erinnerst dich: Pulse-Weiten-Modulation,auf die ich noch ausführlich eingehen werde). Am unteren Ende derPlatine findest du sowohl die Versorgungs-Ports (links), als auchdie analogen Eingangsports. (1 x Achter- / 1 x Sechserblock)

Abbildung 4-7Versorgung + analoge Eingänge

Auch hier siehst du wieder, dass die Nummerierung der anlogenPorts mit 0 beginnt, diesmal allerdings von links gesehen.

Das könnte wichtig für dich seinBevor du die einzelnen Pins verkabelst, orientiere dich immeran den entsprechenden Bezeichnungen, die entweder darüberoder darunter stehen. Man kann sich aufgrund der dicht bei-einanderstehenden Pins schnell verlesen oder beim Verkabelneinen Pin links oder rechts daneben erwischen. Ganz schlimmkann es werden, wenn du zwei oder mehr benachbarte Pinsdurch Unachtsamkeit miteinander verbindest und einen Kurz-schluss erzeugst. Das könnte dazu führen, dass der eine oderandere Kamerad auf der Schaltung Rauchzeichen von sich


Die Programmiersprachen C/C++ ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 109

gibt. Am besten schaut man senkrecht von oben auf die Leis-ten. Ein Blick schräg von der Seite birgt die genannten Gefah-ren in sich. Die spätere Fehlersuche gestaltet sich dann etwasmühsam. Liegt ein Fehler in der Programmierung vor odereiner in der Verkabelung? Zu allem Übel kann eine falsch ver-drahtete Leitung einen Schaden am Board verursachen. Verka-ble nicht das Board, wenn es noch oder schon unterSpannung über den USB-Port steht. Also nicht hektisch wer-den und beim Verkabeln der Schaltung schon an den späterenVersuchslauf denken. Sei immer ganz präsent bei den Dingen,die du gerade tust, und im jetzigen Augenblick verhaftet.Dann wird nichts schiefgehen.

Die Programmiersprachen C/C++Damit die Kommunikation mit dem Arduino-Board erfolgreich ver-läuft, mussten sich die Entwickler auf eine Sprachbasis einigen.Nur wenn alle Beteiligten die gleiche Sprache sprechen, kann es zurVerständigung untereinander kommen und ein Informationsflusseinsetzen. Wenn du ins Ausland fährst und die Landessprachenicht beherrschst, musst du dich in irgendeiner Form anpassen, umdich zu verständigen. Die Art und Weise ist dabei egal. Das kannentweder durch Laute oder auch mit Händen und Füßen gesche-hen. Hast du mit deinem Gegenüber eine Basis gefunden, kann’slosgehen. Bei unserem Mikrocontroller ist das nicht anders. Wirmüssen jedoch zwischen zwei Ebenen unterscheiden. Der Mikro-controller versteht auf seiner Interpretationsebene nur Maschinen-sprache – auch Nativer Code genannt –, die für den Menschen sehrschwer zu verstehen ist, da es sich lediglich um Zahlenwerte han-delt. Wir sind es gewohnt, mit Worten und Sätzen sprachlich zuinteragieren. Das ist also reine Gewohnheitssache. Würden wir vonGeburt an über Zahlenwerte miteinander »reden«, wäre das auchok. Jedenfalls gibt es trotz dieses Sprachdilemmas eine Möglichkeit,verständlich mit mit dem Mikrocontroller zu kommunizieren. Esgibt eine Entwicklungsumgebung, die Befehle über eine sogenannteHochsprache – das ist eine Sprache in einer abstrakten Form, ähn-lich der unseren – entgegennimmt. Doch wir stecken dann wiederin einer Sackgasse, denn der Mikrocontroller versteht diese Spracheleider nicht. Es fehlt so etwas wie ein Übersetzer, der als Verbin-dungsglied zwischen Entwicklungsumgebung und Mikrocontroller


arbeitet und dolmetscht. Aus diesem Grund existiert ein sogenann-ter Compiler. Das ist ein Programm, das ein in einer Hochsprachegeschriebenes Programm in die Zielsprache des Empfängers (hierunsere CPU des Mikrocontrollers) umwandelt.

Abbildung 4-8Der Compiler als Dolmetscher

Da fast alle Programmiersprachen sich des englischen Wortschat-zes bedienen, kommen wir nicht umhin, auch diese Hürde zu neh-men. Ich denke, dass unser Schulenglisch hierbei gut weiterhilft.Die Instruktionen, also die Befehle, die die Entwicklungsumgebungversteht, sind recht kurz gehalten und gleichen einer Militärspra-che, die in knappen Anweisungen ausdrücken, was zu tun ist.

Kein Grund zur Sorge, wir werden sie Schritt für Schritt erlernen.Die Überschrift deutet darauf hin, dass es sich bei C bzw. C++ebenfalls um Hochsprachen handelt. Alle professionellen Pro-gramme werden heutzutage in C/C++ oder verwandten Sprachenwie C# oder Java geschrieben, die allesamt ähnliche Syntaxformenaufweisen. Hoffentlich bricht nun kein Donnerwetter von den Pro-grammierern aus, die ihre favorisierte Sprache hier nicht aufgelistetsehen. Das soll in keinster Weise bedeuten, dass alle restlichenSprachen – und es gibt eine Menge davon – nicht in die Kategorieprofessionell fallen. Wir wollen uns hier auf C/C++ konzentrieren,da Arduino bzw. der Compiler eine Teilmenge der Funktionalitätder Sprachen C/C++ innehat. Wer schon mit C bzw. C++ program-miert hat, wird sich hier wie zu Hause fühlen. Alle anderen werdenwir dahin führen, dass sie sich ebenfalls recht schnell in vertrauterUmgebung bewegen. Viele andere Mikrocontroller-Entwicklungs-pakete verwenden auch C/C++-ähnliche Compiler, so dass das Stu-dium dieser Sprachen bald Früchte tragen wird. Doch hier Arduinoangesagt, und wir wollen uns ganz diesem Thema widmen. Wie wirwas in welcher Form programmieren, wird integraler Bestandteildieses Buches sein. Hab noch ein wenig Geduld, im Kapitel überBefehl und Gehorsam wirst du den ersten Kontakt mit der Program-miersprache bekommen. Du kannst gespannt sein, was wir allesanstellen werden.

Mikro hergehört: Lampe an Port 13 anschalten. Ausführung!


Wie und womit kann ich Arduino programmieren? ------------------------------------------------------------------------------------------------------------------------------------------------- 111

Na, du bist auch einer von denen, die‘s nicht erwarten können.Also gut. Aber nur ein einfaches Beispiel, das wir nachher sowiesoals Erstes kennenlernen werden.

int ledPin = 13; // Variable mit Pin 13 deklarieren + initialisieren

void setup(){

pinMode(ledPin, OUTPUT); // Digitaler Pin 13 als Ausgang

}

void loop(){

digitalWrite(ledPin, HIGH); // LED auf HIGH-Pegel (5V)

delay(1000); // Eine Sekunde warten

digitalWrite(ledPin, LOW); // LED auf LOW-Pegel (0V)

delay(1000); // Eine Sekunde warten

}

Zufrieden? Mit diesem Beispiel lässt du eine angeschlosseneLeuchtdiode blinken, die am digitalen Ausgang Pin 13 angeschlos-sen wird. Willst du das etwa jetzt ausprobieren? Ich habe dieGrundlagen zur Treiberinstallation doch noch gar nicht bespro-chen. Die solltest du abwarten und anschließend die Entwicklungs-umgebung richtig konfigurieren. Können wir so verbleiben?

Wie und womit kann ich Arduino programmieren?Wie ich schon erwähnt habe, steht uns zur Programmierung desArduino-Mikrocontrollers eine Entwicklungsumgebung – auchIDE (Integrated Development Environment) – zur Verfügung. Übersie nehmen wir direkten Kontakt mit dem Board auf und übertra-gen das Programm in den Mikrocontroller. Ein Programm wirdübrigens im Arduino-Umfeld Sketch genannt, was grob übersetzt soviel wie Skizze bedeutet. Wir reden also ab jetzt nur noch von Sket-chen, wenn es sich um Arduino-Programme dreht. Um ein mög-lichst breites Publikum mit Arduino anzusprechen, wurden für dieunterschiedlichsten Plattformen Entwicklungsumgebungengeschaffen, die sich gleichen. Das bekannteste und weitesten ver-breitete Betriebssystem ist Windows. Alle meine Sketche, die ich indiesem Buch anführe, habe ich unter Windows entwickelt, was

Ich will jetzt schon Code sehen. Komm, zeig mir einfach jetzt schonetwas. Nur damit ich einen kleinen Einblick bekomme – ok!?


jedoch nicht bedeutet, dass andere Plattformen schlechter wären.Auf der Internetseite von Arduino, die http://arduino.cc/en/Main/Software lautet, findest du die unterschiedlichen Versionen für fol-gende Betriebssysteme:

• Windows

• Mac OS X

• Linux (32 Bit)

Dort befinden sich auch die sogenannten Release Notes (übersetzt:Freigabevermerk), die wichtige Informationen über die betreffendeVersion der IDE enthalten. Da geht es z.B. um neue Features oderbehobene Fehler, die in der Vorgängerversion aufgetreten sind. Eslohnt sich, einen Blick dort hinein zu riskieren.

Die Installation der Entwicklungsumgebung inklusive TreiberIch habe jetzt so lange von der Entwicklungsumgebung geredet,dass es langsam an der Zeit ist, einen Blick darauf zu werfen. Ichwerde mit Windows beginnen, mit Mac OS X fortfahern und beiLinux enden. Die Reihenfolge stellt dabei keine Wertung dergenannten Betriebssysteme dar. Verbindest du ohne die korrekteInstallation der Entwicklungsumgebung dein Arduino-Uno-Boardz.B. bei Windows mit der USB-Schnittstelle, wird zuerst versucht,automatisch einen passenden Treiber zu finden. Das schlägt jedochfehl, so dass du mit der folgenden Fehlermeldung beglückt wirst.

Abbildung 4-9Der Treiber für Arduino fehlt



Die Entwicklungssystem-Versionen ändern sich mit der Zeit, dusolltest immer die aktuellste verwenden. Bei Erscheinen des Bucheskann es durchaus sein, dass die hier vorgestellte Version schonetwas veraltet ist, was jedoch nicht bedeutet, dass die im Buch vor-gestellten Sketche nicht mehr lauffähig sind. Eine Abwärtskompati-bilität sollte gewährleistet sein.

Abbildung 4-10Die Arduino-Entwicklungsumge-bung für die unterschiedlichen Betriebssysteme

Installation unter Windows 7

Schritt 1

Für die Installation unter Windows habe ich mich für die Windows-Installer-Variante entschieden. Darüber werden automatisch diebenötigten Treiber in das System eingebunden.

Abbildung 4-11Download des Windows-Installer-Setups

Klicke auf die Datei Speichern-Schaltfläche, um die Setup-Datei indeinem Filesystem zu speichern.


Schritt 2

Öffne die Setup-Datei und folge den Anweisungen der Dialoge. Kli-cke zu Beginn auf die I Agree-Schaltfläche.

Abbildung 4-12Das Setup wird ausgeführt (Teil 1)

Danach wirst du sehen, dass die aufgelisteten Installationen bzw.Änderungen durchgeführt werden. Klicke auf die Next-Schaltflä-che.


Im folgenden Dialog kannst du den Installationspfad anpassen.Bestätige nach Möglichkeit ohne Änderungen diesen Dialog, indemdu auf die Install-Schaltfläche klickst.




Die Installation wird gestartet, über den Verlauf wirst du anhanddes Fortschrittsbalkens informiert.


Während der Installation erscheint eine Windows-Sicherheitswar-nung, die dich nicht zu beunruhigen hat. Bestätige den Dialog überdie Schaltfläche Diese Treibersoftware trotzdem installieren. DieseAbfrage erscheint, wenn der Herausgeber der Treibersoftware nichtermittelt werden konnte. Das stellt in diesem Fall kein Problem dar.


Abbildung 4-16Das Setup wird ausgeführt (Teil 5) –

Treiberinstallation

Nach kurzer Zeit wird die Installation abgeschlossen.

Abbildung 4-17Das Setup wird beendet (Teil 6)

Über die Close-Schaltfläche wird das Setup beendet.

Schritt 3

Wenn du jetzt deinen Arduino Uno über das USB-Kabel mit dei-nem Rechner verbindest, sollte ein entsprechender Eintrag imGerätemanager erscheinen. Beachte, dass dem Arduino Uno stan-dardmäßig kein USB-Kabel beiliegt. Sorge also rechtzeitig für einderartiges Kabel, sonst wirst du wenig Spaß an deinem ArduinoUno haben.



Abbildung 4-18USB-Kabel zum Anschluss des Arduino-Boards an den PC

Die Seite mit dem Stecker Typ-B wird mit dem Board und der Ste-cker mit Typ-A mit dem PC verbunden. Bedenke, wie schon in derEinleitung erwähnt, dass die Verwendung eines USB-HUB die siche-rere Variante ist. Geh jetzt über die Computerverwaltung (rechteMaustaste auf das Computer-Desktop-Icon und Verwaltung wäh-len) und öffne den Gerätemanager. Du findest in der angezeigtenHierarchie einen Eintrag unter Anschlüsse (COM & LPT).

Abbildung 4-19Der Arduino Uno wurde erkannt

Nun ist alles soweit fertig, dass du die Entwicklungsumgebungüber die Windows-Start-Schaltfläche starten kannst.

Installation für Mac OS X (Mavericks)Wenn du die Arduino-Entwicklungsumgebung unter Mac OS Xinstallieren möchtest, öffnetst du am besten den WebbrowserSafari und gehst auf die gleiche Internetseite, wie ich das unterWindows erklärt hatte.

Abbildung 4-20Die Arduino-Software-Download-seite im Safari-Browser


Klicke auf den Link Mac OS X und speichere darüber die Datei.Nach erfolgreichem Herunterladen befindet sich die Datei im Ord-ner Downloads.

Abbildung 4-21Der Download-Ordner im Finder

Schritt 1

Um die Arduino-Entwicklungsumgebung zu starten, führe einenDoppelklick auf die Datei Arduino aus. Danach erscheint einSicherheitshinweis, dass diese Datei aus dem Internet heruntergela-den wurde. Das ist eine obligatorische Frage, die nach der erstenBestätigung kein weiteres Mal für diese App gestellt wird.

Abbildung 4-22Sicherheitshinweis nach dem

Ausführen des Pakets

Klicke auf die Öffnen-Schaltfläche. Für eine dauerhafte Verfügbar-keit solltest du die heruntergeladene Datei in den Ordner Pro-gramme verschieben.

Schritt 2

Verbinde deinen Arduino Uno mit dem USB-Anschluss deinesMacs. Bevor es losgehen kann, sind zwei wichtige Dinge zu konfi-gurieren, auf die ich später in diesem Kapitel noch einmal unterWindows eingehen werde.

• Über welchen Anschluss ist der Arduino mit dem Mac verbun-den?

• Um welchen Arduino handelt es sich?



Über Tools|Serieller Port wählst du den Eintrag /dev/tty.usbmo-dem14441.

Abbildung 4-23Auswahl des USB-Ports

Falls dieser Eintrag bei dir nicht vorhanden sein sollte, trenne dieUSB-Verbindung vom Arduino zum Mac und schau dir die Listeder zur Verfügung stehenden Ports an. Dann stell die Verbindungwieder her und schau erneut nach. Der Eintrag, der hinzugekom-men ist, ist der richtige für deinen Arduino.

Abbildung 4-24Auswahl des Arduino Uno

Nun musst du noch das korrekte Arduino-Board auswählen. Öffnedazu über Tools|Board die Liste der unterstützten Arduino-Boardsund wähle Arduino Uno aus.

Nun ist die Entwicklungsumgebung bereit für dich und du kannstbeginnen.

Installation für UbuntuFür die KUbuntu-Linux 13.04-Version liegt ein Installationspaketder Arduino-Version 1.0.5 vor, was also aktuell ist. Ich zeige dir dieunkomplizierte Variante der Installation über die Muon-Programm-verwaltung. Ich habe übrigens KUbuntu bei mir installiert. Es han-delt sich dabei um Ubuntu mit der Arbeitsumgebung KDE stattGnome. Gehen wir die einzelnen Schritte einfach einmal durch. Ichhabe Linux innerhalb VirtualBox installiert.


Schritt 1

Über Anwendungen|System die Muon-Paketverwaltung auswählenund auf der linken Seite die Kategorie Elektronik anklicken.

Abbildung 4-25Muon-Programmverwaltung

bei KUbuntu

Du bekommst sofort die Arduino-Entwicklungsumgebung zur Instal-lation angezeigt. Klicke rechts unten auf die Installieren-Schaltflä-che.

Schritt 2

Da für dieses Software-Paket zusätzliche Abhängigkeiten bestehen,müssen weitere Pakete installiert werden.

Abbildung 4-26Muon-Programmverwaltung

bei KUbuntu (zusätzlicheSoftware-Pakete)

Klicke auf die OK-Schaltfläche.

Schritt 3

Jetzt bekommst du alle notwendigen Pakete, die zur Installationanstehen, angezeigt.



Abbildung 4-27Muon-Programmverwaltung bei KUbuntu (Pakete sind vorgewählt)

Schritt 4

Bis zu diesem Zeitpunkt ist hinsichtlich der Paket-Installation nochnichts passiert. Du musst abschließend die Schaltfläche Änderun-gen anwenden am oberen Fensterrand anklicken.

Abbildung 4-28Muon-Programmverwaltung bei KUbuntu (Installation starten)Schritt 5

Da die Softwareverwaltung einem Administrator obliegt, wirst du imnächsten Schritt zur Eingabe deines Root-Passwortes aufgefordert.

Abbildung 4-29Muon-Programmverwaltung bei KUbuntu (Root-Passwort eingeben)

Abbildung 4-30Muon-Programmverwaltung bei KUbuntu (die Installation beginnt)Anschließend wird mit der Installation der Pakete begonnen.


Schritt 6

Die Arduino-Entwicklungsumgebung benötigt zur Kommunikationmit deinem Board die Mitgliedschaft in der Dialout-Gruppe. Überdas Dialog-Fenster wirst du aufgefordert, dies zu erlauben. Klickedazu auf die Add-Schaltfläche.

Abbildung 4-31Muon-Programmverwaltung bei

KUbuntu (Dialout-Gruppen-Dialog)

Schritt 7

Da mein Linux auf der VirtualBox unter Windows läuft, ist meinArduino Uno primär am USB-Port des Wirtssystems – alsoWindows – angeschlossen. Dieser USB-Port soll jetzt jedoch amLinux-Gastsystem genutzt werden. Über den MenüpunktGast|USB-Geräte kannst du den USB-Port quasi in Linux überneh-men. Wähl den entsprechenden Eintrag für Arduino aus der Listeaus.

Abbildung 4-32Muon-Programmverwaltung beiKUbuntu (USB-Port-Übernahme)

Auf der Windows-Seite erfolgt nach der Auswahl die Installationdes VirtualBox-USB-Treibers.



Abbildung 4-33Der VirtualBox-USB-Treiber wird unter Windows installiert

Das könnte wichtig für dich seinWenn du den USB-Anschluss, an dem sich der Arduino befin-det, von VirtualBox in Beschlag nimmst, steht er auf derWindows-Seite nicht mehr zur Verfügung. Windows quittiertdas mit einem typischen Zweiklang (bing-bong). Möchtest duwieder unter Windows mit dem Arduino arbeiten, entferne dasHäkchen bei den USB-Geräten unter VirtualBox.

Schritt 8

Alles ist nun zum Start der Arduino-Entwicklungsumgebung vorbe-reitet, so dass du sie unter Anwendungen|Elektronik starten kannst.

Abbildung 4-34Die Arduino-Entwicklungs-umgebung

Schau einmal an den rechten unteren Rand der Entwicklungsumge-bung. Dort steht Arduino Uno on COM1. Da stimmt etwas nicht,denn die COM-Bezeichnung ist unter Linux keine gebräuchliche


Angabe für eine serielle Verbindung. Du musst im nächsten Schrittden korrekten Port auswählen.

Schritt 9

Geh über den Menüpunkt Tools|Serieller Port und selektiere dortden angezeigten Eintrag /dev/ttyACM0.

Abbildung 4-35Die Arduino-Entwicklungsumge-bung mit dem richtigen seriellen

Port versehen

AchtungEs kann sein, dass der Menüpunkt Serieller Port ausgegraut ist,so dass du keine Möglichkeit hast, einen neuen Port zuzuwei-sen. Ich habe – was für Linux eigentlich sehr ungewöhnlich ist– einen Reboot durchgeführt und konnte anschließend denerforderlichen seriellen Port auswählen.

Die Arduino-Entwicklungs-umgebungWas ist überhaupt eine Entwicklungsumgebung und was könnenwir damit machen? Nun, sie bietet dem interessierten Programmie-rer bzw. angehenden Arduino-Experten, der du ja in Kürze seinwirst, ein Werkzeug zur Umsetzung deiner programmiertechni-schen Ideen. Wir haben es einerseits mit der Hardware zu tun,deren Hauptbestandteil das Arduino-Board ist. An ihm werden dieunterschiedlichen elektronischen bzw. elektrischen Bauteile ange-schlossen, auf die wir noch im Detail zu sprechen kommen. Dassind alles greifbare Dinge, die eben in ihrer Struktur hart sind.Daher der Ausdruck Hardware. Was nützt uns aber eine Hardware,die nicht weiß, was sie tun soll? Etwas fehlt noch, um die Sacherund zu machen. Genau, da ist andererseits die Software. Das istdie Welt der Programme – oh, Entschuldigung, der Sketche undDaten. Das ist etwas, was du nicht unmittelbar mit deinen Händengreifen kannst, es sei denn, du druckst alles auf Papier aus. Die


Die Arduino-Entwicklungsumgebung ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 125

Software macht Hardware erst zu dem, wozu sie eigentlich geschaf-fen wurde: Befehle interpretieren und ausführen. Beide zusammenbilden eine Einheit, keiner kommt ohne den anderen aus.

Das Starten der Entwicklungs-umgebungKommen wir endlich zu etwas Konkretem. Der Start der Entwick-lungsumgebung – ich werde sie ab jetzt nur noch IDE nennen –steht unmittelbar bevor. Über die Windows-Start-Schaltflächekannst du die IDE starten. Du erkennst sie am typischen Arduino-Icon.

Abbildung 4-36Starten der Entwicklungsumgebung

Nach dem Start bekommst du die folgende Ansicht zu sehen:

Abbildung 4-37Die leere IDE (Windows)

Wenn du genau hinschaust, kannst du sicherlich bestimmte von-einander abgetrennte Bereiche erkennen, in denen sich vielleicht


später etwas abspielt. Werfen wir einen genaueren Blick darauf.Wir gehen systematisch von oben nach unten durch.

Die Titelzeile

Die Titelzeile ist die Zeile am oberen Fensterrand, in der zwei Infor-mationen stehen:

• Sketch-Name (hier: sketch_dec27a) Dieser Name wird automa-tisch vergeben und beginnt immer mit sketch_. Danach folgender Monat, der Tag und ein laufender Buchstabe a bis z, falls andiesem Tag noch weitere Sketche erstellt werden. Dieser Sketchwurde demnach am 27. Dezember in der ersten Version diesesTages erstellt.

• Arduino-IDE-Versionsnummer (hier Version 1.0.5, die sich imLaufe der Zeit aber noch erhöhen wird, wenn Fehler behobenwurden oder neue Funktionen hinzugekommen sind)

Die Menüleiste

In der Menüleiste werden die unterschiedlichsten Menüeinträge zurAuswahl angeboten, über die du bestimmte Funktionen der IDEaufrufen kannst.

Die Symbolleiste

Unterhalb der Menüleiste befindet sich die Symbolleiste, die miteinigen Piktogrammen – auch Icons genannt – versehen ist. Aufderen einzelne Funktionen komme ich gleich zu sprechen.

Der Tabulatorbereich

Der Tabulatorbereich signalisiert uns, wie viele Quellcodedateienzum jeweiligen geöffneten Arduino-Projekt gehören.

Im Moment erkennen wir lediglich einen Tabulator-Reiter mit demNamen sketch_dec27a. Dort können, je nach Programmierauf-wand, weitere hinzugefügt werden. Dazu dient das am rechtenRand befindliche Icon.



Der Editor

Kommen wir zu Herzstück der IDE. Der Editorbereich, der imMoment noch vollkommen jungfräulich daherkommt, ist der zen-trale Ort, an dem du dich mit deinen Ideen austoben kannst. Hiergibst du den Quellcode ein, also die Instruktionen, die den Mikro-controller veranlassen sollen, das zu tun, was du ihm aufträgst. Dasist die Welt der Sketche.

Die Infozeile

In der Infozeile wirst du über bestimmte durchgeführte Aktionender IDE informiert.

Hast du z.B. einen Sketch erfolgreich auf deiner Festplatte gespei-chert, bekommst du den hier gezeigten Wortlaut angezeigt. Hat derCompiler bei der Übersetzung einen Fehler in deinem Sketch ent-deckt, weil du dich vielleicht vertippt hast, so tut er das hier miteiner entsprechenden Aussage kund. Weitere Details zu erkanntenFehlern werden im Nachrichtenfenster, das jetzt folgt, angezeigt.

Das Nachrichtenfenster

Das Nachrichtenfenster versorgt dich mit all den notwendigenInformationen, die die IDE verschickt, um dich auf dem Laufendenzu halten. Was könnten das für Informationen sein?


• Informationen über Sketch-Transfer zum Arduino-Board(erfolgreich oder fehlerhaft)

• Informationen über Übersetzungsaktivitäten des Compilers(erfolgreich oder fehlerhaft)

• Informationen über den seriellen Monitor (erfolgreich oderCOM-Port nicht gefunden)

Die Statuszeile

In der Statuszeile wird entweder ein einzelner Wert angezeigt, derdie Zeilennummer des Cursors wiedergibt (hier Zeile 3)

oder einen markierten Bereich, der sich über einen Bereich erstreckt(hier Zeile 1 bis 4)

Zusätzlich erkennst du am rechten Rand den Namen deinesArduino-Boards und den verwendeten COM-Port der seriellenSchnittstelle.

Die Symbolleiste im DetailIm täglichen Umgang mit der IDE wirst du bemerken, dass dieSymbolleiste dein wichtigster Begleiter ist. Es handelt sich zwarnicht um sehr viele Icons in der Leiste, doch ihre Funktionalitätensolltest du beherrschen.

Tabelle 4-1Iconfunktionen der Symbolleiste

Icon Funktion

Das Icon hat die Aufgabe, den im Editor befindlichen Sketch auf seine Syntax hin zu überprüfen (verify bedeutet übersetzt prüfen) und zu übersetzen. Beim Start der Über-prüfung (Kompilierung) wird ein horizontaler Balken angezeigt, der Aufschluss über den Fortschritt gibt.

Ist kein Fehler festgestellt worden, wird der Vorgang mit der Meldung Kompilierung abgeschlossen abgeschlossen. Im Ausgabefenster findest du einen Hinweis über den Speicherbedarf des Sketches.



Um einen neuen Sketch anzulegen, benutzt du dieses Symbol. Denk aber daran, dass die IDE immer nur einen Sketch zur selben Zeit verwalten kann. Startest du einen neuen, denk daran, den alten Sketch unbedingt zu speichern. Andernfalls verlierst du sämtliche Informationen.

Alle Sketche werden in einem Sketchbook abgelegt, das sich im Verzeichnis C:\Benut-zer\<Benutzername>\Eigene Dokumente\Arduino befindet. Für den Benut-zernamen musst du deinen eigenen Benutzernamen eintragen. Über dieses Symbol kannst du einen gespeicherten Sketch von der Festplatte in die IDE laden. Hierüber erreichst du auch die zahlreich vorhandenen Beispiel-Sketche, die die IDE von Haus aus mitbringt. Schau sie dir an, du kann einiges von ihnen lernen.

Über das Speichern-Symbol sicherst du deinen Sketch auf einen Datenträger. Standard-mäßig erfolgt die Speicherung im eben genannten Sketchbook-Verzeichnis.

Dieses Symbol sorgt für eine Übertragung des erfolgreich kompilierten Sketches auf das Arduino-Board in den Mikrocontroller. Beim sogenannten Upload des Sketches passie-ren folgende Dinge, die du visuell beobachten kannst. Auf dem Board befinden sich einige kleine Leuchtdioden, die Aufschluss über bestimmte Aktivitäten geben.

LED L: Ist mit Pin 13 verbunden und leuchtet kurz, wenn die Übertragung beginnt

LED TX: Sendeleitung der seriellen Schnittstelle des Boards (blinkt bei Übertragung)

LED RX: Empfangsleitung der seriellen Schnittstelle des Boards (blinkt bei Übertragung)

Die Sendeleitung (TX) ist hardwaremäßig mit dem digitalen Pin 1 und die Empfangs-leitung (RX) mit dem digitalen Pin 0 verbunden.

Der serielle Monitor kann über dieses Icon geöffnet werden. Es öffnet sich ein Dialog, der einem Terminal ähnelt.

In der oberen Zeile kannst du Befehle eingeben, die an das Board verschickt werden, wenn du die Senden-Schaltfläche drückst. Im mittleren Bereich bekommst du die Daten angezeigt, die das Board über die serielle Schnittstelle versendet. So können bestimmte Werte angezeigt werden, für die du dich interessierst. Im unteren Abschnitt kannst du auf der rechten Seite über eine Auswahlliste die Übertragungsgeschwindigkeit (Baud) einstellen, die mit dem Wert korrespondieren muss, den du beim Programmieren des Sketches verwendet hast. Stimmen diese Werte nicht überein, kann es nicht zur Kom-munikation kommen.

Icon Funktion Tabelle 4-1Iconfunktionen der Symbolleiste (Fortsetzung)


Das könnte wichtig für dich seinFalls du einmal die Funktion hinter einem der sechs Icons ver-gessen haben solltest, fahr mit der Maus einfach über ein Sym-bol und schau rechts neben die Symbolleiste. Dort wird dieBedeutung des Icons angezeigt.

Der Editor im DetailDer Editor, in den du deinen Quellcode eingibst, unterstützt dichin vieler Hinsicht beim Programmieren. Das folgende Editorfenstermit seinem Inhalt zeigt dir einen Quellcode, den du noch nicht ver-stehen musst. Es soll lediglich verdeutlichen, wie bzw. in welcherForm der Inhalt dargestellt wird.

Abbildung 4-38Quellcode eines Arduino-Sketches

Welche optischen Merkmale fallen uns sofort auf? Ich fasse kurzzusammen, was wir sehen:

1. Die IDE beherrscht die farbliche Hervorhebung von bestimm-ten Wörtern innerhalb des Editors. Aber welche Wörter sinddas?

2. Die Schriftstärke variiert in Abhängigkeit von bestimmtenWörtern.

3. Bestimmte Elemente werden besonders hervorgehoben. Hierist es die schließende geschweifte Klammer.

4. Es liegt eine gewisse Struktur vor, wie der Quellcode darge-stellt wird. Manche Bereiche sind weiter nach rechts einge-rückt als andere.

Das ist natürlich keine reine Willkür oder weil es einfach schickaussieht. Alles hat seinen Grund. Gehen wir auf die einzelnenPunkte genauer ein:

Zu Punkt 1

Bestimmte Wörter, auch Schlüsselwörter genannt, werden farblichhervorgehoben. Es handelt sich dabei um reservierte Namen, die z.B. Befehlen zugewiesen wurden. Unsere Entwicklungsumgebungbzw. der Compiler verfügt ja über einen bestimmten Wortschatz,



dessen wir uns bedienen können, um unseren Sketch zu program-mieren. Wird ein der IDE bekanntes (Schlüssel-)Wort von dir ein-gegeben, reagiert sie, indem sie es sofort farblich darstellt. Indiesem Fall sind Schlüsselwörter immer in Orange gehalten. Einer-seits behältst du auf diese Weise einen besseren Überblick undandererseits bemerkst du sofort, wenn ein Befehl falsch geschriebenwurde. Er wird dann eben nicht farblich hervorgehoben. Das isteine fantastische optische Rückmeldung, die dir unmittelbar einFeedback auf das gibt, was du gerade in den Editor eingibst.

Zu Punkt 2

Einige Wörter, die als Schlüsselwörter erkannt wurden, werden vonder IDE fetter dargestellt. Das sind hier die Wörter setup und loop,die eine elementare Rolle in einem Sketch spielen. Diese beidenWörter stellen Funktionsnamen dar. Was das genau ist und was siebedeuten, soll an dieser Stelle zweitrangig sein. Durch dieses opti-sche Merkmal der fetteren Darstellung fallen sie leichter ins Augeund dienen ebenfalls zur Bewahrung eines besseren Überblicks.

Zu Punkt 3

Instruktionen bzw. Befehle werden in der Programmierung mit derArduino-IDE immer blockorientiert eingegeben. Das bedeutet, dassbestimmte Befehle, die untereinander aufgelistet sind, zu einembestimmten Ausführungsblock gehören. So ein Block wird durch eingeschweiftes Klammernpaar gekennzeichnet. Die öffnende Klam-mer signalisiert den Beginn und die schließende Klammer das Endedes Blocks. Auch darauf gehen wir zu gegebener Zeit genauer ein.Jedenfalls gehören beide Klammern immer zusammen und könnennur paarweise auftreten. Wird eine von beiden vergessen, kommtes unweigerlich zu einem Fehler, da die zu erwartende und zwin-gend notwendige Blockstruktur nicht gegeben ist. Setzt du denCursor hinter eine Klammer, wird automatisch die korrespondie-rende Klammer mit einer rechteckigen Umrandung versehen. Duerkennst das in diesem Beispiel in der setup-Funktion. Ich habe denCursor hinter die öffnende geschweifte Klammer positioniert, unddie schließende hat entsprechend reagiert. Das funktioniert übri-gens auch mit den runden Klammern. Was der Unterschied zwi-schen beiden Klammern ist, werden wir noch sehen.

Zu Punkt 4

Der Quellcode innerhalb eines Ausführungsblocks wird in derRegel weiter nach rechts eingerückt als der Block bzw. die Blockbe-


zeichnung selbst. Das dient ebenfalls zur besseren Übersicht und istauch bei der Fehlersuche sehr hilfreich. Auf diese Weise könnenmehrere Blöcke besser voneinander unterschieden werden. Es istsogar möglich, den ganzen Quellcode in eine einzige Zeile zuschreiben. Der Compiler würde keinen syntaktischen Fehler fest-stellen, doch die Übersicht wäre katastrophal. Ebenso könntest dualle Codezeilen linksbündig eingeben, was ebenfalls ein grauenhaf-ter Programmierstil wäre. Es gibt einen interessanten Menüpunkt,der eine automatische Einrückung durchführt. Er wird überTools|Automatisch formatieren aufgerufen.

Eine Bemerkung am RandeFalls du schon einmal mit einer Entwicklungsumgebung ineiner anderen Sprache wie z.B. C# programmiert hast, fällt dirim Unterschied zur Arduino-Entwicklungsumgebung garantiertetwas auf. Diese hier ist recht spartanisch gehalten und besitztnicht den gewaltigen Funktionsumfang wie andere IDEs. Dashat wiederum seine Bewandtnis. Die Entwickler von Arduinowollten die Philosophie der Einfachheit und Unkompliziertheitauch bei der Handhabung bzw. Programmierung der Softwareweiterführen. Viele Menschen schrecken davor zurück, sich mitso komplizierten Dingen der technisierten Welt wie Mikrocon-troller oder der Programmierung zu befassen, weil sie befürch-ten, dass alles viel zu kompliziert ist und sie versagen könnten.Du musst dir aber keine Gedanken machen, dass dich diesesSchicksal ereilen wird. Lass dich einfach überraschen und vomCharme des Arduino einfangen.

Die Übertragung des Sketches zum Arduino-BoardHast du deinen Sketch zur Zufriedenheit programmiert und auchder Überprüfung bzw. Kompilierung hat er genügt, wird es ernst.Die Übertragung in Richtung Mikrocontroller steht auf dem Plan.Doch stopp! Eine wichtige Kleinigkeit habe ich noch nicht erwähnt.Da es sehr unterschiedliche Arduino-Boards auf dem Markt gibt,die sich alle mehr oder weniger hardwaremäßig unterscheiden, aberdennoch durch eine einzige IDE mit Daten versorgt werden, musstdu eine grundlegende Einstellung vornehmen. Das ist nicht weiterkompliziert. Verbinde dein Arduino-Board mit deinem Rechnerund schau her:

Arduino-Board auswählen

Du gehst über den Menüpunkt Tools|Board und bekommst eineListe aller Boards angezeigt, die die IDE unterstützt. Da wir mit



dem Uno-Board arbeiten, selektierst du den ersten Listeneintrag,der hier markiert ist, weil ich das vorher schon eingestellt habe.

Abbildung 4-39Auswahl deines Arduino-Boards in der IDE

Serielle Schnittstelle auswählen

Nun wählst du den COM-Port für der serielle Schnittstelle aus. Gehüber den Menüpunkt Tools|Serieller Port. In der Liste könnendurchaus mehrere Einträge auftauchen, du musst dann den richti-gen auswählen. Wirf notfalls einen Blick in den Gerätemanager, umGewissheit zu erlangen.

Abbildung 4-40Auswahl der seriellen Schnittstelle in der IDE

Aha! Der COM-Port 12 wurde erkannt, an dem mein Board jetztangeschlossen ist. Alles klar?

Natürlich hast du recht, fast hätte ich es vergessen zu erwähnen.Ältere Arduino-Boards haben tatsächlich noch eine serielle Schnitt-stelle (RS232) in Form eines D-Sub-Anschlusses, der 9-polig ist undüber ein serielles Kabel mit dem Rechner verbunden wird. Die neu-

Nein, ganz im Gegenteil! Du hast bestimmt etwas durcheinanderge-bracht. Einerseits redest du von einer seriellen Schnittstelle undeinem COM-Port, aber dann schließt du das Board über den USB-Anschluss an den Rechner an. Das sind doch zwei völlig verschiedenePaar Schuhe!?


eren Generationen besitzen allesamt einen USB-Anschluss, dernach und nach die serielle Schnittstelle verdrängt. Die heutigenRechner besitzen standardmäßig schon keine serielle Anschluss-möglichkeit mehr. Die interne Verarbeitung erwartet aber eine seri-elle Komponente. Was also tun? Auf deinem Arduino-Boardbefindet sich u.a. ein eigener kleiner Mikrocontroller vom TypATMEGA8U2-MU, der von Haus aus so programmiert wurde, dasser als USB-zu-seriell-Konverter arbeitet. Das ältere Board mit derBezeichnung Duemilanove hatte noch einen FTDI-Chip, der in ähn-licher Weise arbeitete. Der neue Chip weist folgende Vorteilegegenüber dem älteren auf:

• Er hat kürzere Latenzzeiten (die Zeit zwischen einer Aktion undeiner verzögerten Reaktion).

• Er ist programmierbar.

• Er kann sich am System als USB-Tastatur anmelden.

Bei der Linux-Variante hast du übrigens keine COM-Ports, sonderndu findest einen Eintrag, der wie folgt aussehen kann:

/dev/ttyACM0

Dev ist die Abkürzung für Device, was Gerät bedeutet. NähereInformationen dazu findest du im Internet.

Nein, Ardus, die Frage ist nicht verfrüht und hat durchaus ihreBerechtigung. Ich hatte dir ja schon ein wenig über die Entwick-lungsumgebung, den Compiler und die Programmiersprachen C/C++ erzählt. Manche nehmen einfach alles hin, doch du stellst Fra-gen. Das ist gut!

Abbildung 4-41Was passiert im Hintergrund bei der

Übertragung des Sketches zumArduino-Board?

Kannst du mir ein bisschen darüber erzählen, was bei der Übertra-gung des Sketch-Codes in Richtung Arduino-Board passiert? Oder istdiese Frage verfrüht?



Wir können den Ablauf in einzelne logische Schritte unterteilen.

Schritt 1

Es findet die Überprüfung des Sketch-Codes durch die Entwick-lungsumgebung statt, um sicherzustellen, dass die C/C++ Syntaxkorrekt ist.

Schritt 2

Danach wird der Code zum Compiler (avr-gcc) geschickt, der da-raus eine für den Mikrocontroller lesbare Sprache, die Maschinen-sprache, erstellt.

Schritt 3

Im Anschluss wird der Code mit einigen Arduino-Bibliotheken, diegrundlegende Funktionalitäten bereitstellen, zusammengeführtund als Ergebnis eine Intel-HEX Datei erstellt. Es handelt sich dabeium eine Textdatei, die binäre Informationen für Mikrocontrollerspeichert. Hier zeige ich dir einen kurzen Ausschnitt aus dem erstenSketch, den ich dir eben als Appetizer gezeigt habe.

Abbildung 4-42Ausschnitt aus einer Intel-HEX Datei

Dieses Format versteht der Mikrocontroller, denn es ist seineNative Language (übersetzt Muttersprache).

Schritt 4

Der Bootloader überträgt die Intel-HEX-Datei über USB in denFlash-Speicher des Mikrocontroller-Boards. Der sogenannteUpload-Prozess, also die Übertragung zum Board, erfolgt mit demProgramm avrdude. Es ist Bestandteil der Arduino-Installation undbefindet sich unter Arduino\hardware\tools\avr\bin. Nähere Infor-mationen über die Parameter, die beim Aufruf mit übergeben wer-den, findest du im Internet bzw. auf meiner Internetseite.


Die PortkommunikationDu hast bisher lediglich die Kommunikation mit deinem Arduino-Board auf der Ebene der Programmierung kennengelernt. EinSketch wird von dir programmiert und über den USB-Port auf dasBoard übertragen. Dort fängt der Sketch unmittelbar nach demerfolgreichen Load mit der Ausführung und der Verarbeitung vonDaten an. Diese Daten müssen aber irgendwie in Form von Senso-renwerten über Schnittstellen in den Mikrocontroller gelangen undspäter ggf. wieder nach draußen geschickt werden, um z.B. einenMotor anzusteuern. Das hast du anfangs schon kurz gesehen, alswir die analogen bzw. digitalen Ports ansprachen.

Was sind Schnittstellen?Der Ausdruck Schnittstelle ist inzwischen so oft gefallen, dass esZeit wird, eine gültige und plausible Definition dafür zu geben.Eine Schnittstelle – auch Interface genannt – dient zur Kommunika-tion eines in sich geschlossenen Systems mit der Außenwelt.Schauen wir uns dazu die folgende Grafik an.

Abbildung 4-43Schnittstellen sind die Verbin-

dungskanäle zwischen zweibenachbarten Welten

Eine Schnittstelle hat sowohl einen Fuß in der Innen- als auch in derAußenwelt und hält somit den Kontakt zwischen beide Sphärenaufrecht. Durch sie strömen Informationen in Form von Daten hinund her. Eigentlich könnte dein Arduino in einer kleinen schwar-zen Kiste verpackt sein, denn dich braucht nicht zu interessieren,wie es auf dem Board aussieht und welche einzelnen Bauteile dortwelche Funktion haben. Ein derartiges Gebilde nennt man auchBlack Box.


Die Portkommunikation ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 137

Was ist eine Black Box?Eine Black Box ist ein mehr oder weniger komplexes System miteinem Innenleben, das durch seine Kapselung der Außenwelt ver-borgen bleibt bzw. bleiben soll. Die innere Struktur ist dabei nichtweiter von Bedeutung. Als Nutzer hat uns einzig und alleine zuinteressieren, was die Black Box zu leisten vermag und wie wir unsihrer bedienen können. Aus diesem Grund liegt jeder Black Boxeine detaillierte Beschreibung ihrer Schnittstellen bei, die Auf-schluss über die Funktionalitäten liefert. Dein Arduino-Board kannals eine solche Box angesehen werden, und wir werden im Laufedieses Buches einiges über die Schnittstellen und ihre Besonderhei-ten bzw. ihr Verhalten erfahren.

Wenn man sich nicht über die Funktion einer Block-Box im Klarenist, kann der Schuss vielleicht nach hinten losgehen. Vielleichtschlummert etwas Explosives im Verborgenen. Soweit lassen wir esaber nicht kommen.

Was ist der Unterschied zwischen digital und analog?Jetzt greife ich schon ein wenig auf das vor, was ich später noch imKapitel über die Grundlagen der Elektronik ausführen werde. Dochwenn wir schon bei der Black Box und der Portkommunikationsind, ist das kein schlechter Zeitpunkt, um auf die Unterschiedeeinzugehen. Unser Arduino ist ja mit digitalen und analogen Portsausgestattet.

In der Digitaltechnik (lat. digitus bedeutet übersetzt Finger) wirdmit zwei definierten Zuständen gearbeitet.

• LOW-Pegel (wird mit L oder 0 abgekürzt)

• HIGH-Pegel (wird mit H oder 1 abgekürzt)

Hier siehst du ein Signal, das digitalen Charakter besitzt:

Abbildung 4-44Digitaler Signalverlauf (Rechtecksignal)

Na, dann wollen wir mal sehen, was passiert!


Diesen beiden logischen Zuständen können Spannungswerte zuge-wiesen werden. Bei digitalen Signalen haben wir es in unserem Fallmit der +5V-Logik zu tun. Was bedeutet das? In der Digitaltechnikwerden Spannungspegel binären Zuständen zugeordnet. Der Span-nungswert 0V entspricht in der Regel dem binären LOW-Wert(niedriger Pegel) und +5V dem binären HIGH-Wert (hoher Pegel).Da es aufgrund unterschiedlicher Bauteiltoleranzen zu kleinerenAbweichungen hinsichtlich der Widerstände kommen kann, ist esnotwendig, einen Toleranzbereich für die logischen Zustände zudefinieren. Würden wir statt +5V nur +4,5V messen, wäre dasstreng gesehen ein LOW-Pegel. Aus diesem Grund wurden Tole-ranzbereiche mit den folgenden Werten geschaffen:

Abbildung 4-45Toleranzbereiche

Im Gegensatz dazu haben analoge Signale eine ganz andere Quali-tät. Sie können nicht nur im zeitlichen Verlauf zwischen den zweiPegeln HIGH bzw. LOW unterscheiden, sondern sie haben dieEigenart, stufenlos zwischen einem minimalen und maximalenWert zu pendeln.

Abbildung 4-46Analoger Signalverlauf

(Sinus-Signal)

In unseren Beispielen werden wir uns beiden Signalformen widmen.


Die Portkommunikation ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 139

Der Eingang (INPUT)Da ein Informationsfluss in beide Richtungen verlaufen kann undsomit zu einem Informationsaustausch wird, existieren auf demArduino-Board Ports mit unterschiedlichem Verhalten. Natürlichmüssen wir hier wieder zwischen digital und analog unterscheiden.Fangen wir mit den Eingängen an.

Digitale EingängeDie digitalen Eingänge des Bords werden von Sensoren gespeist, diedigitalen Charakter vorweisen. Der einfachste digitale Sensor ist derSchalter. Er ist entweder offen und liefert kein Signal (LOW-Pegel),oder er ist geschlossen und liefert ein Signal (HIGH-Pegel). Ebensokannst du dir auch einen Transistor vorstellen, der einen elektroni-schen Schalter darstellt. Er liefert vergleichbare Signalpegel aneinen digitalen Eingang. Wie unterschiedliche Sensorschaltungenfunktionieren, wirst du in Kürze sehen.

Analoge EingängeDie analogen Eingänge des Boards können ebenfalls von Sensorengespeist werden, die sowohl analogen als auch digitalen Charakterbesitzen. Stell dir einen Temperatursensor vor, der in Abhängigkeitder Umgebungstemperatur seinen Widerstand ändert und einenmehr oder weniger hohen Spannungspegel an den Eingang liefert.Dieser empfangene Wert kann zu weiteren Berechnungen herange-zogen werden, um auf die wahre Temperatur schließen zu können.Ein Spannungswert wird in einen entsprechenden Temperaturwertumgesetzt und zur Anzeige gebracht oder er steuert vielleicht einenVentilator, der für eine bessere Kühlung sorgt.

Der Ausgang (OUTPUT)Was hereinkommt, muss auch irgendwie wieder hinaus. Das liegtin der Natur der Dinge. Das Arduino-Board ist mit einer Reihe Aus-gänge versehen, die es dir ermöglichen, etwas zu steuern oder anzu-zeigen. Der Gegenpart zu einem Sensor ist ein Aktor, wie z.B. einMotor oder ein Relais.

Digitale AusgängeDie digitalen Ausgänge kannst du z.B. dazu verwenden, optischeSignalgeber, die interne Zustände widerspiegeln, anzuschließen.


Das sind in der Regel Leuchtdioden, auch LEDs (Light EmittingDiode) genannt, die mit einem entsprechenden Vorwiderstand ver-sehen, dort angeklemmt werden. Natürlich kann ein digitaler Aus-gang auch einen Transistor regeln, der seinerseits eine größere Laststeuert, als der Arduino-Port es könnte. Das werden wir ebenfallsalles noch kennenlernen.

Analoge AusgängeMit den analogen Ausgängen ist es bei deinem Arduino so eineSache. Auf diesen Umstand bist du ja selbst schon sehr schnellgestoßen. Derartige dedizierte, also nur für diesen Zweck ausge-legte Ports, gibt es nicht. Einige digitale Ports übernehmen quasidie Funktion und simulieren ein analoges Signal, das über die Puls-Weiten-Modulation generiert wird. Auch dazu wirst du noch einigeserfahren, wenn wir einen analogen Ausgang programmieren.

Befehl und GehorsamWenn es für einen Computer keine Software geben würde, hättestdu zwar ein ganz schönes Stück Hardware herumstehen, aber siewäre zu nichts fähig. Intelligente Software haucht der Hardwareerst Leben ein und lässt sie das tun, was du ihr sagst. Wir müssenuns unserem Arduino-Mikrocontroller in irgendeiner Form ver-ständlich machen.

Du tust, was ich dir sageDas geschieht über sogenannte Befehle. Ein Befehl stellt eineAnweisung an den Mikrocontroller dar, den er aufgrund seiner Spe-zifikation versteht und in entsprechende Aktionen wandelt. Wirwollen uns einfach mal einen Befehl anschauen, damit du siehst,was ich meine. Der Sinn ist nicht von Bedeutung:

pinMode(13, OUTPUT);

Wenn du diesen Befehl in die Entwicklungsumgebung eintippst,erkennst du, dass das Syntaxhighlighting in Aktion tritt underkannte Schlüsselwörter farblich hervorhebt, zu denen auch dieBefehle gehören. Dadurch wird die Übersichtlichkeit erhöht undzeigt dir u.a. sofort, wenn du z.B. einen Befehl falsch geschriebenhast.

Schreibe folgende Zeile:


Befehl und Gehorsam -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 141

pinModes(13, OUTPUT);

und du wirst sehen, dass der vermeintliche Befehl nicht als solchererkannt wird. Er erscheint in der Farbe Schwarz, was darauf hin-deutet, dass etwas nicht stimmt. Der Befehl pinMode hat struktur-mäßig weiteren Erklärungsbedarf. Du siehst hinter ihm etwas inrunden Klammern stehen. Es sind die Argumente, die dem Befehlbeim Aufruf mit übergeben wurden. Es ist wie bei einer Tasche, indie du Dinge packst, die am Zielort benötigt werden.

Abbildung 4-47Der Befehl pinMode

Argumente sind Zusatzinformationen, die dieser Befehl zur Abar-beitung benötigt. Was sie in diesem Fall genau bewirken, wirst duin Kürze sehen. Die Argumente bei diesem Befehl geben an, dassder Port 13 als Output, also Ausgang, arbeiten soll. Etwas Entschei-dendes haben wir noch vergessen. Am Ende jedes Befehls steht einSemikolon. Das ist für den Compiler der Hinweis, dass der Befehljetzt endet und ggf. ein neuer Befehl zu erwarten ist. Nicht jederBefehl benötigt übrigens Argumente, das runde Klammernpaar isttrotzdem erforderlich. Es bleibt dann leer. Bitte beachte auf jedenFall die Klein- bzw. Großschreibung. Genau wie in den Program-miersprachen C/C++ erfolgt eine Unterscheidung hinsichtlich derSchreibweise. Sie ist case sensitive, wie man so schön sagt. pinModeist nicht gleich pinmode!

Was passiert, wenn ein Befehl unklar formuliert wurde?Ein Befehl, den du an den Mikrocontroller schickst, wird auf jedenFall ausgeführt, es sei denn, er wurde falsch geschrieben. Du musstdich mit dem Wortschatz des Mikrocontrollers bzw. der Entwick-lungsumgebung, die ja C++ verwandt ist, vertraut machen und ver-suchen, sie wie deine Muttersprache zu beherrschen. Das gehtnatürlich nicht von heute auf morgen. Es ist wie bei einer Fremd-sprache. Je öfter du dich in dieser Sprache mitteilst und sie anwen-dest, desto schneller beherrschst du sie. Wenn du z.B. deinerausländischen Bekanntschaft eine Mail schreibst und dich vielleichtbei dem einen oder anderen Wort verschreibst, ist er möglicher-weise doch imstande, das Wort und den Sinn zu verstehen. Bei


einem Computer ist das anders. Er kennt in dieser Hinsicht keinPardon. Entweder du drückst dich klar und deutlich aus und ver-wendest die exakte Schreibweise oder er lehnt die Anweisung ein-fach ab und streikt. Woher soll er auch wissen, was du meinst?Diese Intelligenz können wir ihm nicht zusprechen. Wird ein Befehlfalsch geschrieben oder nicht auf die Klein- bzw. Großschreibunggeachtet, dann gibt es einen Compilerfehler. Zum Glück teilt unsder Compiler in den meisten Fällen mit, worum es sich beimerkannten Fehler handelt, und nennt den Ort und den Grund.

Er wird zwischen drei Fehlertypen unterschieden.

• syntaktische Fehler

• logische Fehler

• Laufzeitfehler

Der syntaktische FehlerDu kannst froh sein, wenn es sich um einen syntaktischen Fehlerhandelt. Er wird vom Compiler erkannt und ist einfach zu lokalisie-ren. Schau dir folgende Fehlermeldung genauer an.

Ich habe den Befehl pinMode komplett in Kleinbuchstabengeschrieben. Das ist natürlich falsch. Der Compiler bemerkt diesund teilt uns mit, dass er pinmode in diesem Bereich nicht kennt.

Der logische FehlerLogische Fehler sind äußerst unangenehm, denn dabei handelt essich um Fehler, die im Verborgenen ihr Unwesen treiben. Sie füh-ren zu keiner Fehlermeldung, denn mit den Anweisungen ist allesok. Und dennoch stimmt etwas nicht. Der programmierte Sketchwill nicht so funktionieren, wie du dir das vorgestellt hast. Es mussan etwas anderem liegen. Der Compiler ist nicht schuld an derMisere. Eine falsche Formel kann z.B. Ursache dafür sein oder einfalscher Wert, den du an einer Stelle definiert hast. Ein benötigterAusgangsport wurde als Eingang definiert. Die Fehlerquellen sindbreit gefächert. Du bekommst das, was du bestellt hast, und das istnicht immer das, was du wirklich willst.


Befehl und Gehorsam -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 143

Wie man solchen Fehlern dennoch auf die Schliche kommt, wer-den wir sehen, wenn es um das Debugging geht. Es ist eineMethode, mit der du Fehler im Programm ausfindig machenkannst.

LaufzeitfehlerBei einem Laufzeitfehler handelt es sich um ein Problem, das erstzur Laufzeit des Sketches auftreten kann. Syntaktisch ist wiederalles in Ordnung und der Compiler hat alles für gut befunden, dochirgendwo tickt eine Zeitbombe, die nur darauf wartet, hochzuge-hen. Das kann eine Zeitlang gutgehen und du denkst, dass alles zurZufriedenheit läuft. Doch eines Tages erwischt es dich und dufluchst: »Das hat doch bisher immer funktioniert. Warum jetztnicht mehr? So ein Sch…«


Ich bringe dir ein Beispiel aus der Windows-Welt. Angenommen,du hast deine MP3-Sammulng auf einer externen Platte mit derBezeichnung D: abgelegt. Ein Musikprogramm greift regelmäßigdarauf zu und spielt die dort gespeicherten Lieder ab. Alles läuftwunderbar. Aus irgendeinem Grund ist die Platte nicht mehr ver-fügbar, sei es, weil sie kaputtgegangen ist oder das USB-Kabel ausder Buchse gerutscht ist. Jedenfalls versucht das Programm weiter-hin, darauf zuzugreifen, doch der Programmierer hat es nicht sointelligent programmiert, den Aufruf auf das Laufwerk mit einerFehlerbehandlung zu versehen. Der gestartete Zugriff ist nichtmehr möglich und das Programm bricht sang- und klanglos ab. Dasscheint vielleicht an den Haaren herbeigezogen, doch manch einProgramm reagiert einfach mit Abbruch statt mit einer Fehlermel-dung. Das bedeutet einen unkontrollierten Abbruch und kanneinen schon nerven.

Das könnte wichtig für dich seinHier ein paar Begriffe für die Suchmaschine, die dir weitere inte-ressante Informationen liefern:

• Arduino

• Freeduino

• Arduino Projects


Erik Bartmann, Die elektronische Welt mit Arduino ... · Erik Bartmann, Die elektronische Welt mit...

Documents

Transcript of Erik Bartmann, Die elektronische Welt mit Arduino ... · Erik Bartmann, Die elektronische Welt mit...