Kapitel 4: Das Arduino-Board ausf hrlich vorgestellt

Kapitel 4: Das Arduino-Board ausf hrlich vorgestellt

Inhalt

Einleitung

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

VII

1 Was ist ein Mikrocontroller

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Wozu kann man ihn verwenden?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Allgemeiner Aufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1

2

3

2 Die

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

11

Was für Arduino-Boards gibt es? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

11

3 Das jüngste Arduino-Kind: Der Yún

. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

29

Einführung Arduino Yún . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Erste Schritte mit dem Yún . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

30

77

4 Das Arduino-Board ausführlich vorgestellt

. . . . . . . . . . . . . . . . . . . . . .

101

Die Stromversorgung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

105

Die Kommunikationswege. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

106

Die Programmiersprachen C/C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

109

Wie und womit kann ich Arduino programmieren? . . . . . . . . . . . . . . . . . . . . . . .

111

Die Arduino-Entwicklungsumgebung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

124

Die Portkommunikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

136

Befehl und Gehorsam. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

140

5 Die

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

145

Was ist Elektronik eigentlich? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

145

Bauteile. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

157

Weitere interessante Bauteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

185

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

III

6 Elektronische

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

199

Widerstandsschaltungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199

Kondensatorschaltungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207

Transistorschaltungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209

7 Fritzing

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

215

Die Oberfläche der Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216

Das Fritzing Creator Kit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233

Wo finde ich was? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237

8 Das Zusammenfügen der Bauteile und weitere Tipps

. . . . . . . . . .

239

Was ist eine Platine? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239

Das Steckbrett (Breadboard) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241

Verschiedene Kabel und ihre Tücken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244

Die flexiblen Steckbrücken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247

Die Durchgangsprüfung mit einem Multimeter . . . . . . . . . . . . . . . . . . . . . . . . . . 250

9 Nützliches

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

253

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

10 Grundlegendes zur Programmierung

. . . . . . . . . . . . . . . . . . . . . . . . . . .

273

Was ist ein Programm bzw. ein Sketch? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273

Was bedeutet Datenverarbeitung? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275

Die Struktur eines Arduino-Sketches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292

Wie lange läuft ein Sketch auf dem Board? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295

11 Die Programmierung des Arduino-Boards

. . . . . . . . . . . . . . . . . . . . . .

297

Die digitalen Ports . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297

Die analogen Ports. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299

Die serielle Schnittstelle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306

12 Elektronikprojekte mit dem Arduino-Board

. . . . . . . . . . . . . . . . . . . . .

307

12-1: Der erste Sketch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309

12-2: Einen Sensor abfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321

12-3: Blinken mit Intervallsteuerung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339

12-4: Der störrische Taster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351

12-5: Ein Lauflicht. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363

12-6: Porterweiterung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377

12-7: Porterweiterung mal 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397

12-8: Die State Machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413

IV

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Inhalt

12-9: Der elektronische Würfel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

435

12-10: Der elektronische Würfel (und wie erstelle ich eine Bibliothek?) . . . . . . . .

459

12-11: Das Mini-Roulette. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

483

12-12: Lichtsensoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

497

12-13: Der Richtungsdetektor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

511

12-14: Die Ansteuerung eines Servos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

521

12-15: Das Lichtradar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

533

12-16: Das Tisch-Sonar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

543

12-17: Die Siebensegmentanzeige . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

567

12-18: Die Siebensegmentanzeige (mir gehen die Pins aus). . . . . . . . . . . . . . . . . .

583

12-19: Der Reaktionstester. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

595

12-20: Das KeyPad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

611

12-21: Das KeyPad (diesmal ganz anders) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

627

12-22: Eine Alphanumerische Anzeige . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

641

12-23: Kommunikation über I 2 C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

661

12-24: Der Schrittmotor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

695

12-25: Der ArduBot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

709

12-26: Die Temperatur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

723

12-27: Der Sound und mehr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

741

12-28: Data Monitoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

757

12-29: Der Arduino-Talker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

769

12-30: Die drahtlose Kommunikation über Bluetooth . . . . . . . . . . . . . . . . . . . . .

781

12-31: Bluetooth und das Android-Smartphone . . . . . . . . . . . . . . . . . . . . . . . . . .

797

12-32: Der ArduBot wird funkgesteuert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

803

12-33: Netzwerk-Kommunikation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

811

12-34: Ein TFT ansteuern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

829

12-35: Digital ruft analog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

867

12-36: Interrupt-Steuerung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

881

12-37: Arduino-Interaktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

905

12-38: Yún Prozesse starten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

925

12-39: Der Webserver des Yún . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

931

12-40: Temboo für den Yún nutzen – Twitter-API . . . . . . . . . . . . . . . . . . . . . . . .

953

12-41: Temboo für den Yún nutzen – Google Spreadsheet . . . . . . . . . . . . . . . . . .

979

12-42: Der Yún und die Datenbank. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

991

12-43: Das Arduino-SimpleBoard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1027

12-44: Der Shieldbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1033

A Wo bekomme ich was?

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1043

Index

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1045

Inhalt

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

V

First

Kapitel 4

ausführlich vorgestellt

Erstellen auf den

Arbeitsseiten

(siehe Muster)

Abstand untere Tabellenlinie zu Textanfang 1,8 cm

-> also: manuell auf den Arbeitsseiten ziehen!!!

In diesem Kapitel möchte ich mit dem Hauptakteur beginnen, um den sich alles dreht. Das Arduino-Mikrokontroller-Board. Ich verwende dazu das Modell Arduino Uno, weil es das momentan populärste Arduino-Board ist. Werfen wir zunächst einen Blick auf das

Objekt der Begierde.

Abbildung 4-1

Das Arduino-Board

4

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

• Breite: ca. 7 cm

• Länge: ca. 5 cm

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

101

Abbildung 4-2

Was ist wo auf der Arduino-

Experimentierplatine?

Der Arduino passt locker in eine Hand und ist sehr kompakt. Wir erkennen auf der Platine die unterschiedlichsten Bauteile, auf die ich noch im Detail eingehen werde. Der größte Mitspieler, der uns direkt ins Auge fällt, ist der Mikrocontroller selbst. Er ist vom Typ ATmega

328. Über die Jahre wurden die unterschiedlichsten Arduino-Boards entwickelt, die mit abweichender Hardware bestückt sind. Ich habe mich für das Board mit der Bezeichnung Arduino Uno R3 entschieden, das sich trotz weiterer Nachfolgeboards wie z.B. Arduino Due oder Arduino Yún zum Quasi-Standard herauskristallisiert hat. Für den Einstieg in die Mikrocontroller-Thematik ist das Board hervorragend geeignet. Jetzt ist es an der Zeit, einen genaueren Blick in Richtung Arduino zu riskieren. Aus welchen einzelnen Komponenten besteht unsere kleine Platine, die so unscheinbar vor uns liegt?

Manch einer mag behaupten, dass auf so kleinem Raum kaum etwas

Platz hat, mit dem sich etwas anfangen lässt. Doch in den letzten Jahren sind die Bauteile immer kleiner geworden, und was früher z.B. in fünf separaten Chips untergebracht war, leistet heute ein einziger.

Das sind für den Anfang die wichtigsten Komponenten auf dem

Arduino-Board, was natürlich nicht bedeutet, dass die restlichen für uns uninteressant sind. Auf einige andere kommen wir zu gegebener Zeit zu sprechen. Jetzt endlich die Frage, die sicherlich alle brennend interessiert. Was kann das Arduino-Board? Zunächst einmal die Eckdaten:

• Mikrocontroller ATmega 328

• 5V Betriebsspannung

102

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

• 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,5KByte belegt)

• 2KByte SRAM

• 1KByte EEPROM

• 16MHz Taktfrequenz

• USB-Schnittstelle

Ein bescheidene Frage: Was soll daran so besonders sein? Kann ich in irgendeiner Weise mit dem Mikrocontroller kommunizieren? Und wenn ja, wie?

Wie du aus der eben gezeigten Liste entnehmen kannst, steht uns zur Kommunikation mit dem Arduino-Board eine bestimmte

Anzahl Ein- bzw. Ausgänge zur Verfügung. Sie stellen die Schnittstelle zur Außenwelt dar und ermöglichen uns, Daten an den Mikrocontroller zu senden bzw. von ihm zu empfangen. Wirf einen

Blick auf das folgende Diagramm:

Abbildung 4-3

Ein- und Ausgänge des

Arduino-Boards

Der blaue Kasten auf der linken Seite symbolisiert den Arduino-

Mikrocontroller, der über bestimmte Schnittstellen mit uns kommunizieren kann. Manche Ports sind als Eingänge, andere als Einbzw. Ausgänge vorhanden. Ein Port ist dabei ein definierter

Zugangsweg zum Mikrocontroller, quasi eine Tür ins Innere, derer wir uns bedienen können. Wirf noch einmal einen Blick auf das

Board, und du wirst an der Ober- bzw. Unterkante jeweils schwarze Buchsenleisten erkennen.

Das Arduino-Board ausführlich vorgestellt

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

103

Moment! Irgendetwas stimmt hier nicht. Unser Mikrocontroller sollte 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!

Das hast du gut beobachtet, Ardus! Ich muss dir aber sagen, dass das Diagramm vollkommen korrekt ist. Der Grund ist folgender (er wird später noch näher beleuchtet): Unser Arduino-Board ist nicht mit separaten analogen Ausgängen bestückt. Das hört sich erst einmal recht merkwürdig an, doch bestimmte digitale Pins werden als analoge Ausgänge missbraucht. Du fragst dich bestimmt, wie das funktionieren soll. Ich mache einen kleinen Vorgriff auf das, was noch im Kapitel über die Puls-Weiten-Modulation, auch PWM genannt, kommt. Das ist ein Verfahren, bei dem ein Signal mehr oder weniger lange An- bzw. Ausphasen vorweist. Ist die Anphase, also wenn der Strom fließt, länger als die Ausphase, leuchtet zum

Beispiel eine angeschlossene Lampe augenscheinlich heller, als wenn die Ausphase länger ist. Ihr wird also mehr Energie in einer bestimmten Zeit in Form von elektrischem Strom zugeführt. Aufgrund seiner Trägheit kann unseres Auge sehr schnell wechselnde

Ereignisse nicht unterscheiden und auch die Lampe weist beim

Hin- und Herschalten zwischen den beiden Zuständen Ein bzw.

Aus eine gewisse Trägheit auf. Dadurch hat es für uns den

Anschein einer sich verändernden Ausgangsspannung. Klingt etwas merkwürdig, nicht wahr? Du wirst es ganz sicher besser verstehen, wenn wir das entsprechende Kapitel erreichen. Einen offensichtlich entscheidenden Nachteil hat diese Art der Portverwaltung schon.

Verwendest du einen oder mehrere analoge Ausgänge, geht das zu

Lasten der digitalen Portverfügbarkeit. Du hast dafür eben weniger zur Verfügung. Doch das soll uns nicht weiter stören, denn wir kommen nicht an die Grenzen, die eine Einschränkung unserer

Versuchsaufbauten bedeuten würde.

Bevor du weiter in dem Tempo erzählst, muss ich dich wieder einmal stoppen. Du hast in der Aufzählung der Eckdaten des Arduino-

Boards einen Bootloader erwähnt. Was ist genau ein Bootloader?

Ok, Ardus, das hätte ich beinahe vergessen! Ein Bootloader ist ein kleines Programm, das in einem bestimmten Bereich des Flash-

Speichers auf dem Mikrocontrollerboard seinen Platz findet und für das Laden des eigentlichen Programms verantwortlich ist. Normalerweise wird ein Mikrocontroller über eine zusätzliche Hardware, z.B. einen ISP-Programmer, mit dem Arbeitsprogramm versehen.

104

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

Durch den Bootloader entfällt diese Notwendigkeit, und so gestaltet sich das Uploaden der Software wirklich komfortabel. Nach dem erfolgreichen Übertragen des Arbeitsprogramms in den

Arbeitsspeicher des Controllers wird es unmittelbar zur Ausführung gebracht. Angenommen, du müsstest deinen Mikrocontroller

ATmega 328 auf der Platine aus irgendeinem Grund austauschen, dann würde der Neue nicht wissen, was zu tun wäre, da der Bootloader standardmäßig noch nicht geladen ist. Für diese Prozedur gibt es verschiedene Verfahren, die ich aus Platzgründen nicht erklären kann. Im Internet finden sich aber genügend Informationen, wie du den passenden Bootloader für den Mikrocontroller installieren kannst. Besuch doch einfach einmal meine Internetseite.

Die Stromversorgung

Damit unser Arduino-Board auch arbeiten kann, muss es in irgendeiner Weise mit Energie versorgt werden. Diese Versorgung erfolgt in erster Linie über die USB-Schnittstelle, die das Board mit dem Rechner verbindet. Über diesen Weg werden übrigens auch Daten zwischen

Board und Rechner ausgetauscht. Wenn du dich also in der Entwicklungsphase mit deinem Arduino befindest, ist das die primäre Versorgung für das Board. Die zweite Möglichkeit besteht im Anschluss einer Batterie oder eines Netzgerätes an den Poweranschluss, der auch

Power Jack genannt wird. Diese Variante kannst du z.B. verwenden, wenn du ein fahrbares Vehikel gebaut hast, das durch den Arduino gesteuert wird. Das Gefährt soll sich unabhängig von einem Kabelanschluss frei im Raum bewegen können, ohne am meist zu kurzen USB-

Kabel hängen zu bleiben – ein autarkes Gefährt halt.

Abbildung 4-4

Spannungsversorgung des

Arduino-Boards

Die Stromversorgung

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

105

Hier zeige ich dir einmal die unterschiedlichen Steckervarianten.

Du kannst sie nicht vertauschen, da sie vollkommen unterschiedliche Formen aufweisen und auch ganz abweichende Funktionen innehaben.

USB-Stecker Power Jack

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

Tabelle 4-1

Strom- bzw. Spannungswerte

Kategorie

Betriebsspannung

Spannungsversorgung über Extern (empfohlen)

Spannungsversorgung über Extern (Grenzwerte)

Gleichstrom pro Pin (maximal)

Wert

5V (DC)

7–12V (DC)

6–20V (DC)

40mA

Eine Bezeichnung DC hinter den Voltangaben bedeutet Direct Cur-

rent, was übersetzt Gleichstrom bedeutet. Die USB-Schnittstelle kann maximal einen Strom von 500mA liefern. Das reicht aus, um die meisten Versuchsschaltungen aus diesem Buch zu realisieren.

Sie ist sogar gegen Kurzschlüsse und zu hohe Ströme derart geschützt, dass eine sogenannte Poly-Sicherung ausgelöst wird. Das sollte aber nicht bedeuten, dass du weniger Sorgfalt beim Aufbau einer Schaltung walten lässt. Erinnere dich daran, was ich dir in der

Einleitung über einen USB-Hub gesagt habe, und beherzige es.

Die Kommunikationswege

So ein Mikrocontroller-Board hat eine Menge Anschlüsse, die es auseinanderzuhalten gilt. Du musst sehen, dass du den Überblick bewahrst und die Dinge nicht durcheinanderbringst. Doch diese

Verwirrung – wenn sie überhaupt aufgekommt – zeigt sich nur am

Anfang. Nach ein paar Tagen gehen dir diese Feinheiten in Fleisch und Blut über. Wollen wir einmal die Unterschiede aufzählen.

106

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

Der USB-Port

Da haben wir zum einen den USB-Port. Ohne ihn wärst du nicht in der Lage, anfänglich mit dem Board in irgendeiner Weise zu kommunizieren. Wir können das Arbeiten mit dem Arduino-Board in zwei Phasen unterteilen. Die Zeit, in der du bestrebt bist, dein Projekt umzusetzen, also Programmierarbeit verrichtest und dir

Gedanken über die Peripherie machst, nennt sich Entwicklungszeit

(engl. Designtime). Die Programmierung erfolgt mit Hilfe einer Entwicklungsumgebung, die du gleich kennenlernen wirst. In ihr wird das von dir erstellte Programm eingegeben und zum Mikrocontroller übertragen. Ist das erfolgreich verlaufen, beginnt sofort die Laufzeit (engl. Runtime). Du musst dem Mikrocontroller also nicht explizit sagen: »So, mein Freund, jetzt fang an zu arbeiten!« Er legt sofort los, wenn er alle Instruktionen von dir erhalten hat. Zusätzlich kannst du aber auch Daten über den USB-Port von deinem

Computer empfangen oder an ihn versenden. Wie das funktioniert, werden wir später noch sehen.

Die Ein- bzw. Ausgabeports

Kommen wir zu den eigentlichen Ports, die die Schnittstelle des

Mikrocontrollers darstellen. Es sind quasi Augen, Ohren und

Mund des Controllers, so wie diese Organe bei uns Menschen auch

Daten empfangen bzw. aussenden. Es findet eine Interaktion durch und über diese Kommunikationskanäle mit der Umgebung statt.

Dein Arduino nutzt einerseits Sensordaten (z.B. Temperatur, Licht,

Feuchtigkeit) zur internen Bewertung, die durch seine Programmierung vorgegeben wurde. Er wird darauf reagieren und dir seine Entscheidung in Form von bestimmten Aktionen mitteilen. Das können Lichtsignale, Töne oder auch Bewegungen über angeschlossene Aktoren (Motoren + Sensoren) sein.

Du hast sicherlich erkannt, dass wir es mit zwei steuerungstechnischen Signal-Kategorien zu tun haben. Sensoren liefern Daten und Aktoren wandeln Eingangsgrößen in Ausgangsgrößen um.

Dieser Prozess verläuft nach dem EVA-Prinzip (Eingabe, Verarbei-

tung, Ausgabe).

Abbildung 4-5

EVA-Prinzip

Die Kommunikationswege

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

107

Abbildung 4-6

Digitale Ein- bzw. Ausgänge

Wo befinden sich diese Ein- bzw. Ausgabeports auf unserem

Arduino-Board? Hältst du es so herum, dass du den Schriftzug

UNO lesen kannst, dann befinden sich die digitalen Ein- bzw. Ausgabeports am oberen Rand. (1 x Zehner- / 1 x Achterblock)

Abbildung 4-7

Versorgung + analoge Eingänge

Natürlich ist es wichtig zu wissen, welcher Port welche Bezeichnung hat, um ihn später in der Programmierung eindeutig ansprechen zu können. Deshalb ist jeder einzelne Pin mit einer Nummer versehen. Beachte, dass die Nummerierung des ersten Pins mit 0 beginnt. Auf dieses Phänomen wirst du während deiner Programmierung noch des Öfteren stoßen. Fast jegliche Aufzählung beginnt mit der Ziffer 0. Unterhalb vereinzelter Ziffern befindet sich ein

Tilde-Zeichen (~), das auf den Umstand hindeutet, dass dieser Pin auch als analoger Ausgang geschaltet werden kann. Es handelt sich um einen PWM-Pin (Du erinnerst dich: Pulse-Weiten-Modulation, auf die ich noch ausführlich eingehen werde). Am unteren Ende der

Platine findest du sowohl die Versorgungs-Ports (links), als auch die analogen Eingangsports. (1 x Achter- / 1 x Sechserblock)

Auch hier siehst du wieder, dass die Nummerierung der anlogen

Ports mit 0 beginnt, diesmal allerdings von links gesehen.

Das könnte wichtig für dich sein

Bevor du die einzelnen Pins verkabelst, orientiere dich immer an den entsprechenden Bezeichnungen, die entweder darüber oder darunter stehen. Man kann sich aufgrund der dicht beieinanderstehenden Pins schnell verlesen oder beim Verkabeln einen Pin links oder rechts daneben erwischen. Ganz schlimm kann es werden, wenn du zwei oder mehr benachbarte Pins durch Unachtsamkeit miteinander verbindest und einen Kurzschluss erzeugst. Das könnte dazu führen, dass der eine oder andere Kamerad auf der Schaltung Rauchzeichen von sich

108

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

gibt. Am besten schaut man senkrecht von oben auf die Leisten. Ein Blick schräg von der Seite birgt die genannten Gefahren in sich. Die spätere Fehlersuche gestaltet sich dann etwas mühsam. Liegt ein Fehler in der Programmierung vor oder einer in der Verkabelung? Zu allem Übel kann eine falsch verdrahtete Leitung einen Schaden am Board verursachen. Verkable nicht das Board, wenn es noch oder schon unter

Spannung über den USB-Port steht. Also nicht hektisch werden und beim Verkabeln der Schaltung schon an den späteren

Versuchslauf 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 verläuft, mussten sich die Entwickler auf eine Sprachbasis einigen.

Nur wenn alle Beteiligten die gleiche Sprache sprechen, kann es zur

Verständigung untereinander kommen und ein Informationsfluss einsetzen. Wenn du ins Ausland fährst und die Landessprache nicht beherrschst, musst du dich in irgendeiner Form anpassen, um dich zu verständigen. Die Art und Weise ist dabei egal. Das kann entweder durch Laute oder auch mit Händen und Füßen geschehen. Hast du mit deinem Gegenüber eine Basis gefunden, kann’s losgehen. Bei unserem Mikrocontroller ist das nicht anders. Wir müssen jedoch zwischen zwei Ebenen unterscheiden. Der Mikrocontroller versteht auf seiner Interpretationsebene nur Maschinensprache – auch Nativer Code genannt –, die für den Menschen sehr schwer zu verstehen ist, da es sich lediglich um Zahlenwerte handelt. Wir sind es gewohnt, mit Worten und Sätzen sprachlich zu interagieren. Das ist also reine Gewohnheitssache. Würden wir von

Geburt an über Zahlenwerte miteinander »reden«, wäre das auch ok. Jedenfalls gibt es trotz dieses Sprachdilemmas eine Möglichkeit, verständlich mit mit dem Mikrocontroller zu kommunizieren. Es gibt eine Entwicklungsumgebung, die Befehle über eine sogenannte

Hochsprache – das ist eine Sprache in einer abstrakten Form, ähnlich der unseren – entgegennimmt. Doch wir stecken dann wieder in einer Sackgasse, denn der Mikrocontroller versteht diese Sprache leider nicht. Es fehlt so etwas wie ein Übersetzer, der als Verbindungsglied zwischen Entwicklungsumgebung und Mikrocontroller

Die Programmiersprachen C/C++

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

109

Abbildung 4-8

Der Compiler als Dolmetscher arbeitet und dolmetscht. Aus diesem Grund existiert ein sogenannter Compiler. Das ist ein Programm, das ein in einer Hochsprache geschriebenes Programm in die Zielsprache des Empfängers (hier unsere CPU des Mikrocontrollers) umwandelt.

Da fast alle Programmiersprachen sich des englischen Wortschatzes bedienen, kommen wir nicht umhin, auch diese Hürde zu nehmen. Ich denke, dass unser Schulenglisch hierbei gut weiterhilft.

Die Instruktionen, also die Befehle, die die Entwicklungsumgebung versteht, sind recht kurz gehalten und gleichen einer Militärsprache, die in knappen Anweisungen ausdrücken, was zu tun ist.

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

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 Programme werden heutzutage in C/C++ oder verwandten Sprachen wie C# oder Java geschrieben, die allesamt ähnliche Syntaxformen aufweisen. Hoffentlich bricht nun kein Donnerwetter von den Programmierern aus, die ihre favorisierte Sprache hier nicht aufgelistet sehen. Das soll in keinster Weise bedeuten, dass alle restlichen

Sprachen – und es gibt eine Menge davon – nicht in die Kategorie professionell fallen. Wir wollen uns hier auf C/C++ konzentrieren, da Arduino bzw. der Compiler eine Teilmenge der Funktionalität der Sprachen C/C++ innehat. Wer schon mit C bzw. C++ programmiert hat, wird sich hier wie zu Hause fühlen. Alle anderen werden wir dahin führen, dass sie sich ebenfalls recht schnell in vertrauter

Umgebung bewegen. Viele andere Mikrocontroller-Entwicklungspakete verwenden auch C/C++-ähnliche Compiler, so dass das Studium dieser Sprachen bald Früchte tragen wird. Doch hier Arduino angesagt, und wir wollen uns ganz diesem Thema widmen. Wie wir was in welcher Form programmieren, wird integraler Bestandteil dieses Buches sein. Hab noch ein wenig Geduld, im Kapitel über

Befehl und Gehorsam wirst du den ersten Kontakt mit der Programmiersprache bekommen. Du kannst gespannt sein, was wir alles anstellen werden.

110

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

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

Na, du bist auch einer von denen, die‘s nicht erwarten können.

Also gut. Aber nur ein einfaches Beispiel, das wir nachher sowieso als 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 angeschlossene

Leuchtdiode blinken, die am digitalen Ausgang Pin 13 angeschlossen wird. Willst du das etwa jetzt ausprobieren? Ich habe die

Grundlagen zur Treiberinstallation doch noch gar nicht besprochen. Die solltest du abwarten und anschließend die Entwicklungsumgebung richtig konfigurieren. Können wir so verbleiben?

Wie und womit kann ich

Arduino programmieren?

Wie ich schon erwähnt habe, steht uns zur Programmierung des

Arduino-Mikrocontrollers eine Entwicklungsumgebung – auch

IDE (Integrated Development Environment) – zur Verfügung. Über sie nehmen wir direkten Kontakt mit dem Board auf und übertragen das Programm in den Mikrocontroller. Ein Programm wird

übrigens im Arduino-Umfeld Sketch genannt, was grob übersetzt so viel wie Skizze bedeutet. Wir reden also ab jetzt nur noch von Sket-

chen, wenn es sich um Arduino-Programme dreht. Um ein möglichst breites Publikum mit Arduino anzusprechen, wurden für die unterschiedlichsten Plattformen Entwicklungsumgebungen geschaffen, die sich gleichen. Das bekannteste und weitesten verbreitete Betriebssystem ist Windows. Alle meine Sketche, die ich in diesem Buch anführe, habe ich unter Windows entwickelt, was

Wie und womit kann ich Arduino programmieren?

-------------------------------------------------------------------------------------------------------------------------------------------------

111

Abbildung 4-9

Der Treiber für Arduino fehlt 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 folgende Betriebssysteme:

• Windows

• Mac OS X

• Linux (32 Bit)

Dort befinden sich auch die sogenannten Release Notes (übersetzt:

Freigabevermerk), die wichtige Informationen über die betreffende

Version der IDE enthalten. Da geht es z.B. um neue Features oder behobene Fehler, die in der Vorgängerversion aufgetreten sind. Es lohnt sich, einen Blick dort hinein zu riskieren.

Die Installation der

Entwicklungsumgebung inklusive

Treiber

Ich habe jetzt so lange von der Entwicklungsumgebung geredet, dass es langsam an der Zeit ist, einen Blick darauf zu werfen. Ich werde mit Windows beginnen, mit Mac OS X fortfahern und bei

Linux enden. Die Reihenfolge stellt dabei keine Wertung der genannten Betriebssysteme dar. Verbindest du ohne die korrekte

Installation der Entwicklungsumgebung dein Arduino-Uno-Board z.B. bei Windows mit der USB-Schnittstelle, wird zuerst versucht, automatisch einen passenden Treiber zu finden. Das schlägt jedoch fehl, so dass du mit der folgenden Fehlermeldung beglückt wirst.

112

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

Die Entwicklungssystem-Versionen ändern sich mit der Zeit, du solltest immer die aktuellste verwenden. Bei Erscheinen des Buches kann es durchaus sein, dass die hier vorgestellte Version schon etwas veraltet ist, was jedoch nicht bedeutet, dass die im Buch vorgestellten Sketche nicht mehr lauffähig sind. Eine Abwärtskompatibilität sollte gewährleistet sein.

Abbildung 4-10

Die Arduino-Entwicklungsumgebung 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 die benötigten Treiber in das System eingebunden.

Abbildung 4-11

Download des Windows-

Installer-Setups

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

Wie und womit kann ich Arduino programmieren?

-------------------------------------------------------------------------------------------------------------------------------------------------

113

Abbildung 4-12

Das Setup wird ausgeführt (Teil 1)

Schritt 2

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

Abbildung 4-13

Das Setup wird ausgeführt (Teil 2)

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, indem du auf die Install-Schaltfläche klickst.

114

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

Abbildung 4-14

Das Setup wird ausgeführt (Teil 3)

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

Abbildung 4-15

Das Setup wird ausgeführt (Teil 4)

Während der Installation erscheint eine Windows-Sicherheitswarnung, die dich nicht zu beunruhigen hat. Bestätige den Dialog über die Schaltfläche Diese Treibersoftware trotzdem installieren. Diese

Abfrage erscheint, wenn der Herausgeber der Treibersoftware nicht ermittelt werden konnte. Das stellt in diesem Fall kein Problem dar.

Wie und womit kann ich Arduino programmieren?

-------------------------------------------------------------------------------------------------------------------------------------------------

115

Abbildung 4-16

Das Setup wird ausgeführt (Teil 5) –

Treiberinstallation

Abbildung 4-17

Das Setup wird beendet (Teil 6)

Nach kurzer Zeit wird die Installation abgeschlossen.

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

Schritt 3

Wenn du jetzt deinen Arduino Uno über das USB-Kabel mit deinem Rechner verbindest, sollte ein entsprechender Eintrag im

Gerätemanager erscheinen. Beachte, dass dem Arduino Uno standardmäßig kein USB-Kabel beiliegt. Sorge also rechtzeitig für ein derartiges Kabel, sonst wirst du wenig Spaß an deinem Arduino

Uno haben.

116

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

Abbildung 4-18

USB-Kabel zum Anschluss des

Arduino-Boards an den PC

Die Seite mit dem Stecker Typ-B wird mit dem Board und der Stecker mit Typ-A mit dem PC verbunden. Bedenke, wie schon in der

Einleitung erwähnt, dass die Verwendung eines USB-HUB die sicherere Variante ist. Geh jetzt über die Computerverwaltung (rechte

Maustaste auf das Computer-Desktop-Icon und Verwaltung wählen) und öffne den Gerätemanager. Du findest in der angezeigten

Hierarchie einen Eintrag unter Anschlüsse (COM & LPT).

Abbildung 4-19

Der 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 X installieren möchtest, öffnetst du am besten den Webbrowser

Safari und gehst auf die gleiche Internetseite, wie ich das unter

Windows erklärt hatte.

Abbildung 4-20

Die Arduino-Software-Downloadseite im Safari-Browser

Wie und womit kann ich Arduino programmieren?

-------------------------------------------------------------------------------------------------------------------------------------------------

117

Abbildung 4-21

Der Download-Ordner im Finder

Klicke auf den Link Mac OS X und speichere darüber die Datei.

Nach erfolgreichem Herunterladen befindet sich die Datei im Ordner Downloads.

Abbildung 4-22

Sicherheitshinweis nach dem

Ausführen des Pakets

Schritt 1

Um die Arduino-Entwicklungsumgebung zu starten, führe einen

Doppelklick auf die Datei Arduino aus. Danach erscheint ein

Sicherheitshinweis, dass diese Datei aus dem Internet heruntergeladen wurde. Das ist eine obligatorische Frage, die nach der ersten

Bestätigung kein weiteres Mal für diese App gestellt wird.

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

gramme verschieben.

Schritt 2

Verbinde deinen Arduino Uno mit dem USB-Anschluss deines

Macs. Bevor es losgehen kann, sind zwei wichtige Dinge zu konfigurieren, auf die ich später in diesem Kapitel noch einmal unter

Windows eingehen werde.

• Über welchen Anschluss ist der Arduino mit dem Mac verbunden?

• Um welchen Arduino handelt es sich?

118

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

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

dem14441.

Abbildung 4-23

Auswahl des USB-Ports

Falls dieser Eintrag bei dir nicht vorhanden sein sollte, trenne die

USB-Verbindung vom Arduino zum Mac und schau dir die Liste der zur Verfügung stehenden Ports an. Dann stell die Verbindung wieder her und schau erneut nach. Der Eintrag, der hinzugekommen ist, ist der richtige für deinen Arduino.

Abbildung 4-24

Auswahl des Arduino Uno

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

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

Installation für Ubuntu

Für die KUbuntu-Linux 13.04-Version liegt ein Installationspaket der Arduino-Version 1.0.5 vor, was also aktuell ist. Ich zeige dir die unkomplizierte Variante der Installation über die Muon-Programm-

verwaltung. Ich habe übrigens KUbuntu bei mir installiert. Es handelt sich dabei um Ubuntu mit der Arbeitsumgebung KDE statt

Gnome. Gehen wir die einzelnen Schritte einfach einmal durch. Ich habe Linux innerhalb VirtualBox installiert.

Wie und womit kann ich Arduino programmieren?

-------------------------------------------------------------------------------------------------------------------------------------------------

119

Schritt 1

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

Abbildung 4-25

Muon-Programmverwaltung bei KUbuntu

Du bekommst sofort die Arduino-Entwicklungsumgebung zur Installation 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-26

Muon-Programmverwaltung bei KUbuntu (zusätzliche

Software-Pakete)

Klicke auf die OK-Schaltfläche.

Schritt 3

Jetzt bekommst du alle notwendigen Pakete, die zur Installation anstehen, angezeigt.

120

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

Abbildung 4-27

Muon-Programmverwaltung bei

KUbuntu (Pakete sind vorgewählt)

Schritt 4

Bis zu diesem Zeitpunkt ist hinsichtlich der Paket-Installation noch nichts passiert. Du musst abschließend die Schaltfläche Änderun-

gen anwenden am oberen Fensterrand anklicken.

Schritt 5

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

Abbildung 4-28

Muon-Programmverwaltung bei

KUbuntu (Installation starten)

Abbildung 4-29

Muon-Programmverwaltung bei

KUbuntu (Root-Passwort eingeben)

Anschließend wird mit der Installation der Pakete begonnen.

Abbildung 4-30

Muon-Programmverwaltung bei

KUbuntu (die Installation beginnt)

Wie und womit kann ich Arduino programmieren?

-------------------------------------------------------------------------------------------------------------------------------------------------

121

Abbildung 4-31

Muon-Programmverwaltung bei

KUbuntu (Dialout-Gruppen-Dialog)

Schritt 6

Die Arduino-Entwicklungsumgebung benötigt zur Kommunikation mit deinem Board die Mitgliedschaft in der Dialout-Gruppe. Über das Dialog-Fenster wirst du aufgefordert, dies zu erlauben. Klicke dazu auf die Add-Schaltfläche.

Schritt 7

Da mein Linux auf der VirtualBox unter Windows läuft, ist mein

Arduino Uno primär am USB-Port des Wirtssystems – also

Windows – angeschlossen. Dieser USB-Port soll jetzt jedoch am

Linux-Gastsystem genutzt werden. Über den Menüpunkt

Gast|USB-Geräte kannst du den USB-Port quasi in Linux übernehmen. Wähl den entsprechenden Eintrag für Arduino aus der Liste aus.

Abbildung 4-32

Muon-Programmverwaltung bei

KUbuntu (USB-Port-Übernahme)

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

122

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

Abbildung 4-33

Der VirtualBox-USB-Treiber wird unter Windows installiert

Das könnte wichtig für dich sein

Wenn du den USB-Anschluss, an dem sich der Arduino befindet, von VirtualBox in Beschlag nimmst, steht er auf der

Windows-Seite nicht mehr zur Verfügung. Windows quittiert das mit einem typischen Zweiklang (bing-bong). Möchtest du wieder unter Windows mit dem Arduino arbeiten, entferne das

Häkchen bei den USB-Geräten unter VirtualBox.

Schritt 8

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

Abbildung 4-34

Die Arduino-Entwicklungsumgebung

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

Wie und womit kann ich Arduino programmieren?

-------------------------------------------------------------------------------------------------------------------------------------------------

123

Abbildung 4-35

Die Arduino-Entwicklungsumgebung mit dem richtigen seriellen

Port versehen

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

Schritt 9

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

Achtung

Es kann sein, dass der Menüpunkt Serieller Port ausgegraut ist, so dass du keine Möglichkeit hast, einen neuen Port zuzuweisen. Ich habe – was für Linux eigentlich sehr ungewöhnlich ist

– einen Reboot durchgeführt und konnte anschließend den erforderlichen seriellen Port auswählen.

Die Arduino-Entwicklungsumgebung

Was ist überhaupt eine Entwicklungsumgebung und was können wir damit machen? Nun, sie bietet dem interessierten Programmierer bzw. angehenden Arduino-Experten, der du ja in Kürze sein wirst, ein Werkzeug zur Umsetzung deiner programmiertechnischen Ideen. Wir haben es einerseits mit der Hardware zu tun, deren Hauptbestandteil das Arduino-Board ist. An ihm werden die unterschiedlichen elektronischen bzw. elektrischen Bauteile angeschlossen, auf die wir noch im Detail zu sprechen kommen. Das sind 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 Sache rund zu machen. Genau, da ist andererseits die Software. Das ist die Welt der Programme – oh, Entschuldigung, der Sketche und

Daten. Das ist etwas, was du nicht unmittelbar mit deinen Händen greifen kannst, es sei denn, du druckst alles auf Papier aus. Die

124

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

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

Das Starten der Entwicklungsumgebung

Kommen wir endlich zu etwas Konkretem. Der Start der Entwicklungsumgebung – ich werde sie ab jetzt nur noch IDE nennen – steht unmittelbar bevor. Über die Windows-Start-Schaltfläche kannst du die IDE starten. Du erkennst sie am typischen Arduino-

Icon.

Abbildung 4-36

Starten der

Entwicklungsumgebung

Nach dem Start bekommst du die folgende Ansicht zu sehen:

Abbildung 4-37

Die leere IDE (Windows)

Wenn du genau hinschaust, kannst du sicherlich bestimmte voneinander abgetrennte Bereiche erkennen, in denen sich vielleicht

Die Arduino-Entwicklungsumgebung

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

125

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 Informationen stehen:

• Sketch-Name (hier: sketch_dec27a) Dieser Name wird automatisch vergeben und beginnt immer mit sketch_. Danach folgen der Monat, der Tag und ein laufender Buchstabe a bis z, falls an diesem Tag noch weitere Sketche erstellt werden. Dieser Sketch wurde demnach am 27. Dezember in der ersten Version dieses

Tages erstellt.

• Arduino-IDE-Versionsnummer (hier Version 1.0.5, die sich im

Laufe der Zeit aber noch erhöhen wird, wenn Fehler behoben wurden oder neue Funktionen hinzugekommen sind)

Die Menüleiste

In der Menüleiste werden die unterschiedlichsten Menüeinträge zur

Auswahl angeboten, über die du bestimmte Funktionen der IDE aufrufen kannst.

Die Symbolleiste

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

Der Tabulatorbereich

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

Im Moment erkennen wir lediglich einen Tabulator-Reiter mit dem

Namen sketch_dec27a. Dort können, je nach Programmieraufwand, weitere hinzugefügt werden. Dazu dient das am rechten

Rand befindliche Icon.

126

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

Der Editor

Kommen wir zu Herzstück der IDE. Der Editorbereich, der im

Moment noch vollkommen jungfräulich daherkommt, ist der zentrale Ort, an dem du dich mit deinen Ideen austoben kannst. Hier gibst du den Quellcode ein, also die Instruktionen, die den Mikrocontroller veranlassen sollen, das zu tun, was du ihm aufträgst. Das ist die Welt der Sketche.

Die Infozeile

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

Hast du z.B. einen Sketch erfolgreich auf deiner Festplatte gespeichert, bekommst du den hier gezeigten Wortlaut angezeigt. Hat der

Compiler bei der Übersetzung einen Fehler in deinem Sketch entdeckt, weil du dich vielleicht vertippt hast, so tut er das hier mit einer entsprechenden Aussage kund. Weitere Details zu erkannten

Fehlern werden im Nachrichtenfenster, das jetzt folgt, angezeigt.

Das Nachrichtenfenster

Das Nachrichtenfenster versorgt dich mit all den notwendigen

Informationen, die die IDE verschickt, um dich auf dem Laufenden zu halten. Was könnten das für Informationen sein?

Die Arduino-Entwicklungsumgebung

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

127

• 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 oder

COM-Port nicht gefunden)

Die Statuszeile

In der Statuszeile wird entweder ein einzelner Wert angezeigt, der die 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 deines

Arduino-Boards und den verwendeten COM-Port der seriellen

Schnittstelle.

Tabelle 4-1

Iconfunktionen der Symbolleiste

Die Symbolleiste im Detail

Im täglichen Umgang mit der IDE wirst du bemerken, dass die

Symbolleiste dein wichtigster Begleiter ist. Es handelt sich zwar nicht um sehr viele Icons in der Leiste, doch ihre Funktionalitäten solltest du beherrschen.

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 Überprü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.

128

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

Icon Funktion

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:\Benutzer\<Benutzername>\Eigene Dokumente\Arduino

befindet. Für den Benutzernamen 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. Standardmäß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 passieren folgende Dinge, die du visuell beobachten kannst. Auf dem Board befinden sich einige kleine Leuchtdioden, die Aufschluss über bestimmte Aktivitäten geben.

Tabelle 4-1

Iconfunktionen der Symbolleiste

(Fortsetzung)

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 Empfangsleitung (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 Kommunikation kommen.

Die Arduino-Entwicklungsumgebung

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

129

Abbildung 4-38

Quellcode eines Arduino-Sketches

Das könnte wichtig für dich sein

Falls du einmal die Funktion hinter einem der sechs Icons vergessen haben solltest, fahr mit der Maus einfach über ein Symbol und schau rechts neben die Symbolleiste. Dort wird die

Bedeutung des Icons angezeigt.

Der Editor im Detail

Der Editor, in den du deinen Quellcode eingibst, unterstützt dich in vieler Hinsicht beim Programmieren. Das folgende Editorfenster mit seinem Inhalt zeigt dir einen Quellcode, den du noch nicht verstehen musst. Es soll lediglich verdeutlichen, wie bzw. in welcher

Form der Inhalt dargestellt wird.

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

1. Die IDE beherrscht die farbliche Hervorhebung von bestimmten Wörtern innerhalb des Editors. Aber welche Wörter sind das?

2. Die Schriftstärke variiert in Abhängigkeit von bestimmten

Wörtern.

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

4. Es liegt eine gewisse Struktur vor, wie der Quellcode dargestellt wird. Manche Bereiche sind weiter nach rechts eingerückt als andere.

Das ist natürlich keine reine Willkür oder weil es einfach schick aussieht. Alles hat seinen Grund. Gehen wir auf die einzelnen

Punkte genauer ein:

Zu Punkt 1

Bestimmte Wörter, auch Schlüsselwörter genannt, werden farblich hervorgehoben. Es handelt sich dabei um reservierte Namen, die z.

B. Befehlen zugewiesen wurden. Unsere Entwicklungsumgebung bzw. der Compiler verfügt ja über einen bestimmten Wortschatz,

130

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

dessen wir uns bedienen können, um unseren Sketch zu programmieren. Wird ein der IDE bekanntes (Schlüssel-)Wort von dir eingegeben, reagiert sie, indem sie es sofort farblich darstellt. In diesem Fall sind Schlüsselwörter immer in Orange gehalten. Einerseits behältst du auf diese Weise einen besseren Überblick und andererseits bemerkst du sofort, wenn ein Befehl falsch geschrieben wurde. Er wird dann eben nicht farblich hervorgehoben. Das ist eine fantastische optische Rückmeldung, die dir unmittelbar ein

Feedback auf das gibt, was du gerade in den Editor eingibst.

Zu Punkt 2

Einige Wörter, die als Schlüsselwörter erkannt wurden, werden von der IDE fetter dargestellt. Das sind hier die Wörter setup und loop, die eine elementare Rolle in einem Sketch spielen. Diese beiden

Wörter stellen Funktionsnamen dar. Was das genau ist und was sie bedeuten, soll an dieser Stelle zweitrangig sein. Durch dieses optische Merkmal der fetteren Darstellung fallen sie leichter ins Auge und dienen ebenfalls zur Bewahrung eines besseren Überblicks.

Zu Punkt 3

Instruktionen bzw. Befehle werden in der Programmierung mit der

Arduino-IDE immer blockorientiert eingegeben. Das bedeutet, dass bestimmte Befehle, die untereinander aufgelistet sind, zu einem bestimmten Ausführungsblock gehören. So ein Block wird durch ein geschweiftes Klammernpaar gekennzeichnet. Die öffnende Klammer signalisiert den Beginn und die schließende Klammer das Ende des Blocks. Auch darauf gehen wir zu gegebener Zeit genauer ein.

Jedenfalls gehören beide Klammern immer zusammen und können nur paarweise auftreten. Wird eine von beiden vergessen, kommt es unweigerlich zu einem Fehler, da die zu erwartende und zwingend notwendige Blockstruktur nicht gegeben ist. Setzt du den

Cursor hinter eine Klammer, wird automatisch die korrespondierende Klammer mit einer rechteckigen Umrandung versehen. Du erkennst das in diesem Beispiel in der setup-Funktion. Ich habe den

Cursor hinter die öffnende geschweifte Klammer positioniert, und die schließende hat entsprechend reagiert. Das funktioniert übrigens auch mit den runden Klammern. Was der Unterschied zwischen beiden Klammern ist, werden wir noch sehen.

Zu Punkt 4

Der Quellcode innerhalb eines Ausführungsblocks wird in der

Regel weiter nach rechts eingerückt als der Block bzw. die Blockbe-

Die Arduino-Entwicklungsumgebung

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

131

zeichnung selbst. Das dient ebenfalls zur besseren Übersicht und ist auch bei der Fehlersuche sehr hilfreich. Auf diese Weise können mehrere Blöcke besser voneinander unterschieden werden. Es ist sogar möglich, den ganzen Quellcode in eine einzige Zeile zu schreiben. Der Compiler würde keinen syntaktischen Fehler feststellen, doch die Übersicht wäre katastrophal. Ebenso könntest du alle Codezeilen linksbündig eingeben, was ebenfalls ein grauenhafter Programmierstil wäre. Es gibt einen interessanten Menüpunkt, der eine automatische Einrückung durchführt. Er wird über

Tools|Automatisch formatieren aufgerufen.

Eine Bemerkung am Rande

Falls du schon einmal mit einer Entwicklungsumgebung in einer anderen Sprache wie z.B. C# programmiert hast, fällt dir im Unterschied zur Arduino-Entwicklungsumgebung garantiert etwas auf. Diese hier ist recht spartanisch gehalten und besitzt nicht den gewaltigen Funktionsumfang wie andere IDEs. Das hat wiederum seine Bewandtnis. Die Entwickler von Arduino wollten die Philosophie der Einfachheit und Unkompliziertheit auch bei der Handhabung bzw. Programmierung der Software weiterführen. Viele Menschen schrecken davor zurück, sich mit so komplizierten Dingen der technisierten Welt wie Mikrocontroller oder der Programmierung zu befassen, weil sie befürchten, dass alles viel zu kompliziert ist und sie versagen könnten.

Du musst dir aber keine Gedanken machen, dass dich dieses

Schicksal ereilen wird. Lass dich einfach überraschen und vom

Charme des Arduino einfangen.

Die Übertragung des Sketches zum

Arduino-Board

Hast du deinen Sketch zur Zufriedenheit programmiert und auch der Ü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, aber dennoch durch eine einzige IDE mit Daten versorgt werden, musst du eine grundlegende Einstellung vornehmen. Das ist nicht weiter kompliziert. Verbinde dein Arduino-Board mit deinem Rechner und schau her:

Arduino-Board auswählen

Du gehst über den Menüpunkt Tools|Board und bekommst eine

Liste aller Boards angezeigt, die die IDE unterstützt. Da wir mit

132

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

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

Abbildung 4-39

Auswahl 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önnen durchaus mehrere Einträge auftauchen, du musst dann den richtigen auswählen. Wirf notfalls einen Blick in den Gerätemanager, um

Gewissheit zu erlangen.

Abbildung 4-40

Auswahl der seriellen Schnittstelle in der IDE

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

Nein, ganz im Gegenteil! Du hast bestimmt etwas durcheinandergebracht. Einerseits redest du von einer seriellen Schnittstelle und einem COM-Port, aber dann schließt du das Board über den USB-

Anschluss an den Rechner an. Das sind doch zwei völlig verschiedene

Paar Schuhe!?

Natürlich hast du recht, fast hätte ich es vergessen zu erwähnen.

Ältere Arduino-Boards haben tatsächlich noch eine serielle Schnittstelle (RS232) in Form eines D-Sub-Anschlusses, der 9-polig ist und

über ein serielles Kabel mit dem Rechner verbunden wird. Die neu-

Die Arduino-Entwicklungsumgebung

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

133

Abbildung 4-41

Was passiert im Hintergrund bei der

Übertragung des Sketches zum

Arduino-Board?

eren Generationen besitzen allesamt einen USB-Anschluss, der nach und nach die serielle Schnittstelle verdrängt. Die heutigen

Rechner besitzen standardmäßig schon keine serielle Anschlussmöglichkeit mehr. Die interne Verarbeitung erwartet aber eine serielle Komponente. Was also tun? Auf deinem Arduino-Board befindet sich u.a. ein eigener kleiner Mikrocontroller vom Typ

ATMEGA8U2-MU, der von Haus aus so programmiert wurde, dass er als USB-zu-seriell-Konverter arbeitet. Das ältere Board mit der

Bezeichnung Duemilanove hatte noch einen FTDI-Chip, der in ähnlicher Weise arbeitete. Der neue Chip weist folgende Vorteile gegenüber dem älteren auf:

• Er hat kürzere Latenzzeiten (die Zeit zwischen einer Aktion und einer 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, sondern du findest einen Eintrag, der wie folgt aussehen kann:

/dev/ttyACM0

Dev ist die Abkürzung für Device, was Gerät bedeutet. Nähere

Informationen dazu findest du im Internet.

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

Nein, Ardus, die Frage ist nicht verfrüht und hat durchaus ihre

Berechtigung. Ich hatte dir ja schon ein wenig über die Entwicklungsumgebung, den Compiler und die Programmiersprachen C/

C++ erzählt. Manche nehmen einfach alles hin, doch du stellst Fragen. Das ist gut!

134

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

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

Schritt 1

Es findet die Überprüfung des Sketch-Codes durch die Entwicklungsumgebung statt, um sicherzustellen, dass die C/C++ Syntax korrekt ist.

Schritt 2

Danach wird der Code zum Compiler (avr-gcc) geschickt, der daraus eine für den Mikrocontroller lesbare Sprache, die Maschinen-

sprache, erstellt.

Schritt 3

Im Anschluss wird der Code mit einigen Arduino-Bibliotheken, die grundlegende Funktionalitäten bereitstellen, zusammengeführt und als Ergebnis eine Intel-HEX Datei erstellt. Es handelt sich dabei um eine Textdatei, die binäre Informationen für Mikrocontroller speichert. Hier zeige ich dir einen kurzen Ausschnitt aus dem ersten

Sketch, den ich dir eben als Appetizer gezeigt habe.

Abbildung 4-42

Ausschnitt aus einer Intel-HEX Datei

Dieses Format versteht der Mikrocontroller, denn es ist seine

Native Language (übersetzt Muttersprache).

Schritt 4

Der Bootloader überträgt die Intel-HEX-Datei über USB in den

Flash-Speicher des Mikrocontroller-Boards. Der sogenannte

Upload-Prozess, also die Übertragung zum Board, erfolgt mit dem

Programm avrdude. Es ist Bestandteil der Arduino-Installation und befindet sich unter Arduino\hardware\tools\avr\bin. Nähere Informationen über die Parameter, die beim Aufruf mit übergeben werden, findest du im Internet bzw. auf meiner Internetseite.

Die Arduino-Entwicklungsumgebung

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

135

Abbildung 4-43

Schnittstellen sind die Verbindungskanäle zwischen zwei benachbarten Welten

Die Portkommunikation

Du hast bisher lediglich die Kommunikation mit deinem Arduino-

Board auf der Ebene der Programmierung kennengelernt. Ein

Sketch wird von dir programmiert und über den USB-Port auf das

Board übertragen. Dort fängt der Sketch unmittelbar nach dem erfolgreichen Load mit der Ausführung und der Verarbeitung von

Daten an. Diese Daten müssen aber irgendwie in Form von Sensorenwerten über Schnittstellen in den Mikrocontroller gelangen und später ggf. wieder nach draußen geschickt werden, um z.B. einen

Motor anzusteuern. Das hast du anfangs schon kurz gesehen, als wir die analogen bzw. digitalen Ports ansprachen.

Was sind Schnittstellen?

Der Ausdruck Schnittstelle ist inzwischen so oft gefallen, dass es

Zeit wird, eine gültige und plausible Definition dafür zu geben.

Eine Schnittstelle – auch Interface genannt – dient zur Kommunikation eines in sich geschlossenen Systems mit der Außenwelt.

Schauen wir uns dazu die folgende Grafik an.

Eine Schnittstelle hat sowohl einen Fuß in der Innen- als auch in der

Außenwelt und hält somit den Kontakt zwischen beide Sphären aufrecht. Durch sie strömen Informationen in Form von Daten hin und her. Eigentlich könnte dein Arduino in einer kleinen schwarzen Kiste verpackt sein, denn dich braucht nicht zu interessieren, wie es auf dem Board aussieht und welche einzelnen Bauteile dort welche Funktion haben. Ein derartiges Gebilde nennt man auch

Black Box.

136

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

Was ist eine Black Box?

Eine Black Box ist ein mehr oder weniger komplexes System mit einem Innenleben, das durch seine Kapselung der Außenwelt verborgen bleibt bzw. bleiben soll. Die innere Struktur ist dabei nicht weiter von Bedeutung. Als Nutzer hat uns einzig und alleine zu interessieren, was die Black Box zu leisten vermag und wie wir uns ihrer bedienen können. Aus diesem Grund liegt jeder Black Box eine detaillierte Beschreibung ihrer Schnittstellen bei, die Aufschluss über die Funktionalitäten liefert. Dein Arduino-Board kann als eine solche Box angesehen werden, und wir werden im Laufe dieses Buches einiges über die Schnittstellen und ihre Besonderheiten bzw. ihr Verhalten erfahren.

Na, dann wollen wir mal sehen, was passiert!

Wenn man sich nicht über die Funktion einer Block-Box im Klaren ist, kann der Schuss vielleicht nach hinten losgehen. Vielleicht schlummert etwas Explosives im Verborgenen. Soweit lassen wir es aber nicht kommen.

Was ist der Unterschied zwischen digital und analog?

Jetzt greife ich schon ein wenig auf das vor, was ich später noch im

Kapitel über die Grundlagen der Elektronik ausführen werde. Doch wenn wir schon bei der Black Box und der Portkommunikation sind, ist das kein schlechter Zeitpunkt, um auf die Unterschiede einzugehen. Unser Arduino ist ja mit digitalen und analogen Ports ausgestattet.

In der Digitaltechnik (lat. digitus bedeutet übersetzt Finger) wird mit 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-44

Digitaler Signalverlauf

(Rechtecksignal)

Die Portkommunikation

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

137

Abbildung 4-45

Toleranzbereiche

Diesen beiden logischen Zuständen können Spannungswerte zugewiesen werden. Bei digitalen Signalen haben wir es in unserem Fall mit der +5V-Logik zu tun. Was bedeutet das? In der Digitaltechnik werden Spannungspegel binären Zuständen zugeordnet. Der Spannungswert 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 kleineren

Abweichungen hinsichtlich der Widerstände kommen kann, ist es notwendig, einen Toleranzbereich für die logischen Zustände zu definieren. Würden wir statt +5V nur +4,5V messen, wäre das streng gesehen ein LOW-Pegel. Aus diesem Grund wurden Toleranzbereiche mit den folgenden Werten geschaffen:

Abbildung 4-46

Analoger Signalverlauf

(Sinus-Signal)

Im Gegensatz dazu haben analoge Signale eine ganz andere Qualität. Sie können nicht nur im zeitlichen Verlauf zwischen den zwei

Pegeln HIGH bzw. LOW unterscheiden, sondern sie haben die

Eigenart, stufenlos zwischen einem minimalen und maximalen

Wert zu pendeln.

In unseren Beispielen werden wir uns beiden Signalformen widmen.

138

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

Der Eingang (INPUT)

Da ein Informationsfluss in beide Richtungen verlaufen kann und somit zu einem Informationsaustausch wird, existieren auf dem

Arduino-Board Ports mit unterschiedlichem Verhalten. Natürlich müssen wir hier wieder zwischen digital und analog unterscheiden.

Fangen wir mit den Eingängen an.

Digitale Eingänge

Die digitalen Eingänge des Bords werden von Sensoren gespeist, die digitalen Charakter vorweisen. Der einfachste digitale Sensor ist der

Schalter. Er ist entweder offen und liefert kein Signal (LOW-Pegel), oder er ist geschlossen und liefert ein Signal (HIGH-Pegel). Ebenso kannst du dir auch einen Transistor vorstellen, der einen elektronischen Schalter darstellt. Er liefert vergleichbare Signalpegel an einen digitalen Eingang. Wie unterschiedliche Sensorschaltungen funktionieren, wirst du in Kürze sehen.

Analoge Eingänge

Die analogen Eingänge des Boards können ebenfalls von Sensoren gespeist werden, die sowohl analogen als auch digitalen Charakter besitzen. Stell dir einen Temperatursensor vor, der in Abhängigkeit der Umgebungstemperatur seinen Widerstand ändert und einen mehr oder weniger hohen Spannungspegel an den Eingang liefert.

Dieser empfangene Wert kann zu weiteren Berechnungen herangezogen werden, um auf die wahre Temperatur schließen zu können.

Ein Spannungswert wird in einen entsprechenden Temperaturwert umgesetzt und zur Anzeige gebracht oder er steuert vielleicht einen

Ventilator, der für eine bessere Kühlung sorgt.

Der Ausgang (OUTPUT)

Was hereinkommt, muss auch irgendwie wieder hinaus. Das liegt in der Natur der Dinge. Das Arduino-Board ist mit einer Reihe Ausgänge versehen, die es dir ermöglichen, etwas zu steuern oder anzuzeigen. Der Gegenpart zu einem Sensor ist ein Aktor, wie z.B. ein

Motor oder ein Relais.

Digitale Ausgänge

Die digitalen Ausgänge kannst du z.B. dazu verwenden, optische

Signalgeber, die interne Zustände widerspiegeln, anzuschließen.

Die Portkommunikation

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

139

Das sind in der Regel Leuchtdioden, auch LEDs (Light Emitting

Diode) genannt, die mit einem entsprechenden Vorwiderstand versehen, dort angeklemmt werden. Natürlich kann ein digitaler Ausgang auch einen Transistor regeln, der seinerseits eine größere Last steuert, als der Arduino-Port es könnte. Das werden wir ebenfalls alles noch kennenlernen.

Analoge Ausgänge

Mit den analogen Ausgängen ist es bei deinem Arduino so eine

Sache. Auf diesen Umstand bist du ja selbst schon sehr schnell gestoßen. Derartige dedizierte, also nur für diesen Zweck ausgelegte Ports, gibt es nicht. Einige digitale Ports übernehmen quasi die Funktion und simulieren ein analoges Signal, das über die Puls-

Weiten-Modulation generiert wird. Auch dazu wirst du noch einiges erfahren, wenn wir einen analogen Ausgang programmieren.

Befehl und Gehorsam

Wenn es für einen Computer keine Software geben würde, hättest du zwar ein ganz schönes Stück Hardware herumstehen, aber sie wäre zu nichts fähig. Intelligente Software haucht der Hardware erst Leben ein und lässt sie das tun, was du ihr sagst. Wir müssen uns unserem Arduino-Mikrocontroller in irgendeiner Form verständlich machen.

Du tust, was ich dir sage

Das geschieht über sogenannte Befehle. Ein Befehl stellt eine

Anweisung an den Mikrocontroller dar, den er aufgrund seiner Spezifikation versteht und in entsprechende Aktionen wandelt. Wir wollen 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 und erkannte Schlüsselwörter farblich hervorhebt, zu denen auch die

Befehle gehören. Dadurch wird die Übersichtlichkeit erhöht und zeigt dir u.a. sofort, wenn du z.B. einen Befehl falsch geschrieben hast.

Schreibe folgende Zeile:

140

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

pinModes(13,

OUTPUT

); und du wirst sehen, dass der vermeintliche Befehl nicht als solcher erkannt wird. Er erscheint in der Farbe Schwarz, was darauf hindeutet, dass etwas nicht stimmt. Der Befehl pinMode hat strukturmäßig weiteren Erklärungsbedarf. Du siehst hinter ihm etwas in runden Klammern stehen. Es sind die Argumente, die dem Befehl beim Aufruf mit übergeben wurden. Es ist wie bei einer Tasche, in die du Dinge packst, die am Zielort benötigt werden.

Abbildung 4-47

Der Befehl pinMode

Argumente sind Zusatzinformationen, die dieser Befehl zur Abarbeitung benötigt. Was sie in diesem Fall genau bewirken, wirst du in Kürze sehen. Die Argumente bei diesem Befehl geben an, dass der Port 13 als Output, also Ausgang, arbeiten soll. Etwas Entscheidendes haben wir noch vergessen. Am Ende jedes Befehls steht ein

Semikolon. Das ist für den Compiler der Hinweis, dass der Befehl jetzt endet und ggf. ein neuer Befehl zu erwarten ist. Nicht jeder

Befehl benötigt übrigens Argumente, das runde Klammernpaar ist trotzdem erforderlich. Es bleibt dann leer. Bitte beachte auf jeden

Fall die Klein- bzw. Großschreibung. Genau wie in den Programmiersprachen C/C++ erfolgt eine Unterscheidung hinsichtlich der

Schreibweise. Sie ist case sensitive, wie man so schön sagt. pinMode ist nicht gleich pinmode!

Was passiert, wenn ein Befehl unklar formuliert wurde?

Ein Befehl, den du an den Mikrocontroller schickst, wird auf jeden

Fall ausgeführt, es sei denn, er wurde falsch geschrieben. Du musst dich mit dem Wortschatz des Mikrocontrollers bzw. der Entwicklungsumgebung, die ja C++ verwandt ist, vertraut machen und versuchen, sie wie deine Muttersprache zu beherrschen. Das geht natürlich nicht von heute auf morgen. Es ist wie bei einer Fremdsprache. Je öfter du dich in dieser Sprache mitteilst und sie anwendest, desto schneller beherrschst du sie. Wenn du z.B. deiner ausländischen Bekanntschaft eine Mail schreibst und dich vielleicht bei dem einen oder anderen Wort verschreibst, ist er möglicherweise doch imstande, das Wort und den Sinn zu verstehen. Bei

Befehl und Gehorsam

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

141

einem Computer ist das anders. Er kennt in dieser Hinsicht kein

Pardon. Entweder du drückst dich klar und deutlich aus und verwendest die exakte Schreibweise oder er lehnt die Anweisung einfach ab und streikt. Woher soll er auch wissen, was du meinst?

Diese Intelligenz können wir ihm nicht zusprechen. Wird ein Befehl falsch geschrieben oder nicht auf die Klein- bzw. Großschreibung geachtet, dann gibt es einen Compilerfehler. Zum Glück teilt uns der Compiler in den meisten Fällen mit, worum es sich beim erkannten Fehler handelt, und nennt den Ort und den Grund.

Er wird zwischen drei Fehlertypen unterschieden.

• syntaktische Fehler

• logische Fehler

• Laufzeitfehler

Der syntaktische Fehler

Du kannst froh sein, wenn es sich um einen syntaktischen Fehler handelt. Er wird vom Compiler erkannt und ist einfach zu lokalisieren. Schau dir folgende Fehlermeldung genauer an.

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

Der logische Fehler

Logische Fehler sind äußerst unangenehm, denn dabei handelt es sich um Fehler, die im Verborgenen ihr Unwesen treiben. Sie führen zu keiner Fehlermeldung, denn mit den Anweisungen ist alles ok. Und dennoch stimmt etwas nicht. Der programmierte Sketch will nicht so funktionieren, wie du dir das vorgestellt hast. Es muss an etwas anderem liegen. Der Compiler ist nicht schuld an der

Misere. Eine falsche Formel kann z.B. Ursache dafür sein oder ein falscher Wert, den du an einer Stelle definiert hast. Ein benötigter

Ausgangsport wurde als Eingang definiert. Die Fehlerquellen sind breit gefächert. Du bekommst das, was du bestellt hast, und das ist nicht immer das, was du wirklich willst.

142

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

Wie man solchen Fehlern dennoch auf die Schliche kommt, werden wir sehen, wenn es um das Debugging geht. Es ist eine

Methode, mit der du Fehler im Programm ausfindig machen kannst.

Laufzeitfehler

Bei einem Laufzeitfehler handelt es sich um ein Problem, das erst zur Laufzeit des Sketches auftreten kann. Syntaktisch ist wieder alles in Ordnung und der Compiler hat alles für gut befunden, doch irgendwo tickt eine Zeitbombe, die nur darauf wartet, hochzugehen. Das kann eine Zeitlang gutgehen und du denkst, dass alles zur

Zufriedenheit läuft. Doch eines Tages erwischt es dich und du fluchst: »Das hat doch bisher immer funktioniert. Warum jetzt nicht mehr? So ein Sch…«

Befehl und Gehorsam

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

143

Ich bringe dir ein Beispiel aus der Windows-Welt. Angenommen, du hast deine MP3-Sammulng auf einer externen Platte mit der

Bezeichnung D: abgelegt. Ein Musikprogramm greift regelmäßig darauf zu und spielt die dort gespeicherten Lieder ab. Alles läuft wunderbar. Aus irgendeinem Grund ist die Platte nicht mehr verfügbar, sei es, weil sie kaputtgegangen ist oder das USB-Kabel aus der Buchse gerutscht ist. Jedenfalls versucht das Programm weiterhin, darauf zuzugreifen, doch der Programmierer hat es nicht so intelligent programmiert, den Aufruf auf das Laufwerk mit einer

Fehlerbehandlung zu versehen. Der gestartete Zugriff ist nicht mehr möglich und das Programm bricht sang- und klanglos ab. Das scheint vielleicht an den Haaren herbeigezogen, doch manch ein

Programm reagiert einfach mit Abbruch statt mit einer Fehlermeldung. Das bedeutet einen unkontrollierten Abbruch und kann einen schon nerven.

Das könnte wichtig für dich sein

Hier ein paar Begriffe für die Suchmaschine, die dir weitere interessante Informationen liefern:

• Arduino

• Freeduino

• Arduino Projects

144

----------------------------------------------------------------------------------------------------------------------------------------------

Kapitel 4: Das Arduino-Board ausführlich vorgestellt

Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertisement