das installieren der software ist relati v einfach. zuerst ... · pdf file21 1 blinke, blinke,...

21

1Blinke, blinke, kleine LED

In diesem Kapitel wirst du lernen, wie du den Arduino programmierst, wieman LEDs (das sind kleine Lampen) zum Leuchten bekommt. Zusätzlichlernst du das Benutzen von Buttons (Tasten) und wie du sie mit demArduino verwenden kannst.

Genau lernst du Folgendes:

$ Installieren der Software, Anschließen des Arduinos

$ Wie du LEDs an- und ausschaltest

$ Wie du den Arduino pausierst

$ Auslesen eines Buttons

$ Wie du ein eigenes Projekt planst

Am Ende des Kapitels werden wir ein kleines Projekt planen und pro-grammieren: eine blinkende Lichterkette mit verschiedenen Funktionen.Im 2. Kapitel werden wir dann die Lichterkette so erweitern, dass wir sieüber den PC steuern können und die Funktionen austauschen können.

© des Titels »Arduino für Kids« (ISBN 978-3-8266-9470-7) 2015 by mitp-Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/9470

Blinke, blinke, kleine LED

22

1Kapitel

Die Software installierenDas Installieren der Software ist relativ einfach. Zuerst musst du die Soft-ware hier herunterladen: http://arduino.cc/en/Main/Software.

Nun zu dem wirklich schwierigen Teil der Installation, das Installieren derTreiber. Wenn du Windows benutzt, bist du leider darauf angewiesen,Treiber zu installieren, damit du den Arduino programmieren kannst. Ste-cke den Arduino (Uno) an und warte. Es sollte sich nach kurzer Zeit einFenster öffnen, in dem nach Treibern/Updates gesucht wird. Ignorieredies und öffne die Systemsteuerung. Gehe dann auf SYSTEM & SICHERHEIT.Dort wählst du den Menüpunkt SYSTEM|GERÄTE-MANAGER.

Aktuell ist die Version 1.0.5. Lade aber bitte nicht die Version 1.5 her-unter, da sie für die Beispiele aus dem Buch nicht geeignet ist. DasArchiv, das du herunterlädst, entpackst du bitte mit deinerArchivsoftware (beispielsweise Winrar oder 7Zip). Den Ordner kannstdu dann zum Beispiel auf dem Desktop speichern. Darin enthalten istdie sogenannte IDE, ein Programm, um einen Quellcode zu entwi-ckeln und diesen dann in »Maschinensprache« zu übersetzen. ImGrunde genommen ist eine IDE eine Textbearbeitung, die Program-mierbefehle farbig markiert.


Die Software installieren

23

In dem sich neu öffnenden Fenster musst du den ersten Punkt(Anschlüsse) entfalten. Nun sollte dort ein Eintrag mit Arduino sein. Gehemit einem Rechtsklick darauf, wähle TREIBERSOFTWARE AKTUALISIEREN und imsich öffnenden Fenster AUF DEM COMPUTER NACH TREIBERSOFTWARE SUCHEN.Nun musst du den Ordner auf dem Desktop suchen, in den du vorhin dieIDE entpackt hast. Im Subordner Drivers (DESKTOP|ARDUINO|DRIVERS) fin-dest du eine Datei mit dem Namen ArduinoUno.inf. Wähle diese aus unddie Treiberinstallation ist abgeschlossen. Solltest du ein anderes Boardverwenden, musst du dann natürlich einen anderen Treiber (aus demgleichen Ordner) auswählen.

Hiermit ist die Installation schon fertig. Nun kannst du deinen Arduinoüber USB-Kabel mit dem Computer verbinden und gleich programmieren.Zuerst musst du in deiner IDE den richtigen Arduino einstellen. Wenn duden empfohlenen Arduino Uno benutzt, musst du unter TOOLS|BOARD denArduino auswählen, siehe dazu folgende Abbildung.

Danach musst du noch den richtigen Port einstellen: Ziehe den ArduinoUno ab (falls du ihn bereits angeschlossen hattest) und schau dir unterTOOLS|SERIAL PORT die Ports an und notiere sie dir. Danach steckst du denArduino Uno ein. Den Port, der neu hinzugekommen ist, musst du aus-wählen. Jetzt kannst du endlich programmieren.



24

1Kapitel

Unser erstes ProgrammUnser erstes Programm soll lediglich zeigen, dass der Arduino korrektverbunden ist.

Diesen Code (den Quellcode) musst du in der IDE eingeben und dann aufden Pfeil oben links klicken. Wenn dann in der schwarzen Textbox stehtDone (schwarzes Feld im unteren Bereich der IDE), ist der Arduino korrekteingestellt, ansonsten muss du die Anleitung oben wiederholen oder imAnhang A nachsehen.

Ein Programm für den Arduino, der sogenannte Sketch, besteht immeraus zwei Teilen, dem »Setup« und der »Loop«. Der Code, der im Setupsteht, wird einmal beim Starten beziehungsweise beim Resetten des Con-trollers ausgeführt. Der Code in der Loop wird dagegen in einer Endlos-schleife ausgeführt. Der Quellcode, den du selber schreibst, kommt dabeiin die geschweiften Klammern. Warum das so ist, kannst du später in die-sem Kapitel im Bereich »Wie Funktionen funktionieren« nachlesen.

Unser erstes Programm mit einer richtigen Funktion soll eine LED ansteu-ern und sie anschalten, später soll sie blinken.

void setup() {}

void loop() {}

Ein wichtiger Hinweis: Wir verwenden die LED-Schaltung aus derEinführung!

void setup() {

pinMode(13,OUTPUT); //Pin 13 auf Ausgang

digitalWrite(13,HIGH);//Pin 13 Anschalten

}

void loop() {}

Ein wichtiger Hinweis: Alles, was hinter zwei Schrägstrichen steht,wird in einem Programm immer als Kommentar gewertet, das heißt,dass dahinter geschriebener Text keine Funktion hat, sondern nur zurbesseren Lesbarkeit dient.


Unser erstes Programm

25

Bei einem Arduino sind alle Ausgänge als sogenannte Pins konfiguriert.Das heißt, dass du jeden Pin einzeln ansteuern kannst. Die Pins sind diekleinen Metallkontakte in den schwarzen Buchsen des Arduino (Uno).Häufig genutzte Pins sind gelb markiert.

Erstellt mit FritzingNeben jedem Pin ist eine Nummer, über die du den Pin ansteuern kannst.In dem Beispiel verwende ich Pin 13, da an diesem bereits eine LED ver-baut ist. Diesen Code musst du wie beim Beispiel auf den Arduino ladenund schon leuchtet die LED grün. Oben im Code kannst du erkennen, dassder Befehl pinMode eine Funktion ist. In den Klammern werden der Funk-tion Parameter übergeben. Parameter kann man als Informationen anse-hen, die die Funktion zum Arbeiten benötigt. Hier ist der erste Parameterder Pin, der zweite der Zustand. Dies kann Output (Ausgang) sein oderInput (Eingang), den wir aber erst im Abschnitt »Das Lesen von Eingän-gen« benötigen.

void setup() {

pinMode(13,OUTPUT); //Pin 13 auf Ausgang

digitalWrite(13,HIGH);//Pin 13 Anschalten

}

void loop() {}



26

1Kapitel

Ausgänge schalten immer etwas, beispielsweise LEDs, Eingänge lesenimmer etwas, z.B. Tasten. Eine Funktion wird immer mit einem Semikolon(;) abgeschlossen, damit der Übersetzer weiß, dass der Befehl zu Ende ist.Der Übersetzer, der sogenannte Compiler, übersetzt den Quellcode inMaschinensprache, also in das Dualsystem, damit es der Mikrocontrollerverstehen kann. Der Befehl pinMode() ist notwendig, damit der Arduinoweiß, wie der Pin zu benutzen ist. Der zweite Befehl, digitalWrite(),schaltet dann den Pin an. Bei dem Arduino Uno liegen 5 Volt an. BeidigitalWrite() kannst du bei dem zweiten Parameter entweder HIGHangeben, der PIN führt also Strom, oder LOW, der PIN ist ausgeschaltet.

Wie bekommt man die LED zum Blinken?Du kannst zwar versuchen, abwechselnd in der Loop digitalWrite() mitHIGH und LOW zu versehen, aber das wird nicht funktionieren. Mit die-sem Code kannst du es selber versuchen:

An sich sollte der Code funktionieren, tut er auch! Aber da der Controllermit 16 Millionen Hertz (Hertz bedeutet Schwingungen, Takte; wenn einBefehl also einen Takt dauert, wird der Pin 16 Millionen Mal pro Sekundeumgeschaltet beziehungsweise der Zustand des Pins alle 0,0000000625Sekunden geändert) arbeitet, kann das menschliche Auge die Reaktionder LED nicht sehen. Man muss den Abstand etwas vergrößern. Dazu

Vielleicht merkst du schon, dass viele Begriffe in der Informatik eng-lisch sind! Beim Programmieren ist Englisch eine wichtige Sprache:Sowohl die Fachbegriffe, beispielsweise HIGH für Hoch (im Sinne vonangeschaltet), als auch die meisten Programmiersprachen sind aufEnglisch »verfasst«. Deswegen schadet es nicht, wenn du einen klei-nen Englischkurs machst.

void setup() {

pinMode(13,OUTPUT); //Nur einmal, da wir Pin 13 nur als

// Ausgang benutzen wollen

}

void loop() {

digitalWrite(13,HIGH);

digitalWrite(13,LOW);

}


Unser erstes Programm

27

dient der Befehl delay(). Dieser Befehl pausiert den Controller für eineübergebene Anzahl an Millisekunden (1000 ms = 1 Sekunde). Um die LEDnun im Sekunden-Takt blinken zu lassen, brauchen wir folgenden Code:

Und damit hast du dein erstes Projekt, die blinkende LED. Dieses kannstdu nun über FILE|SAVE unter einem Namen deiner Wahl speichern. DieArduino-IDE speichert dabei alle Dateien mit Quellcode (die Quellda-teien) an einem Ort, sodass du sie auch später benutzen kannst.

Variablen und was es damit auf sich hat Damit hast du deinen ersten »funktionierenden« Code fertig, der auchzugleich mehrfach Pins ansteuert. Vielleicht fragst du dich gerade, wieorganisiert man die Pins, wenn man 50 Stück benutzt (beispielsweise hatder Arduino Mega über 50 Pins)? Bei dem Arduino besteht die Möglich-keit, einem Pin einen eigenen Namen zu geben. Dies wird über soge-nannte Variablen gemacht. Eigentlich enthält eine Variable einen Inhalt,der veränderbar, also variabel ist; daher der Name. Das Gegenteil ist eineKonstante, die nicht veränderbar ist. In Variablen können wir aber auchdie Zahl des Pins festlegen, den wir ansteuern wollen. Dafür brauchen wireine Zahlenvariable, eine sogenannte Integer-Variable. Integer ist eng-lisch für Ganzzahl, so kannst du auch raten, was in ihr gespeichert wird.Das obige Beispiel mit Variablen sieht dann so aus:

void setup() {

pinMode(13,OUTPUT);

}

void loop() {

digitalWrite(13,HIGH);//LED anschalten

delay(1000); //1 Sekunde warten

digitalWrite(13,LOW);/LED ausschalten

delay(1000);//Und erst nach 1 Sek. wieder anschalten

//Und die Schleife beginnt von vorne

}

int led = 13; //Variablen definieren

int pause = 1000;

void setup() {



28

1Kapitel

Mit variablentyp variablenname = Wert; wird eine Variable initialisiert.Dabei gibt es folgende Variablentypen, die wir verwenden werden:

Dabei ist es wichtig, dass Variablen weder mit einer Zahl beginnen nochein Leerzeichen enthalten (du kannst stattdessen Unterstriche verwen-den, z.B. langer_variablenname). Dazu musst du beachten, dass du eineVariable immer gleich schreibst, denn zwischen Groß- und Kleinschrei-bung wird unterschieden.

Bei einzelnen Variablen musst du noch Folgendes beachten: Variablenhaben immer nur einen bestimmten Wertebereich, der nicht überschrit-ten werden darf (wie beispielsweise -128 bis +127 bei byte). Kommas inKommazahlen werden zudem mit einem Punkt (.) geschrieben, da dies soin Amerika gemacht wird (also wird aus 3,14 3.14). Bei char muss derBuchstabe immer in Hochkommas stehen und bei bool kannst du nur dieoben angegebenen Werte benutzen. Wofür bool benutzt wird, lernst duspäter in diesem Kapitel.

pinMode(led,OUTPUT);

}

void loop() {

digitalWrite(led,HIGH); //Pin, der in led festgelegt ist, //wird geschaltet

delay(pause); //Warte Anzahl MS, die in pause festgelegt //sind

digitalWrite(led,LOW);

delay(pause);

}

Variablentyp Inhalt Beispiel

int Ganzzahl 9

float Gleitkommazahl 9.4

byte Ganzzahl von -128 bis 127 50

char Einzelner Buchstabe 'e'

bool Boolescher Wert (mit ande-ren Worten: 1 oder 0)

true/false oder 1/0


Unser zweites Programm: Lichtspiel mit LEDs

29

Unser zweites Programm: Lichtspiel mit LEDsNun wollen wir aber auch etwas Praktisches mit den Variablen machen,nämlich ein kleines Lichtspiel mit LEDs. Dazu solltest du mindestens fünfLEDs haben, damit man auch etwas erkennen kann. Ich schlage vor, dasswir die PINs 12 bis 8 benutzen. Nun ist noch die Verkabelung entschei-dend. Wenn du wie empfohlen ein Breadboard besitzt, kannst du es somachen (eine Anleitung zum Breadboard gibt es in der Einführung):

Erstellt mit Fritzing

Wie werden Variablen eigentlich organisiert?

Jeder Mikrocontroller enthält eine gewisse Anzahl an RAM, also demArbeitsspeicher eines Mikrochips. Dieser ist in kleinen Einheitenorganisiert. Je nach Größe der Variablen wird eine bestimmte Anzahlreserviert und mit dem Wert beschrieben. Daher ist es auch nötig,immer genügend Arbeitsspeicher frei zu haben, da ansonsten dasProgramm fehlerhaft ausgeführt werden kann. Ein kleiner Trost: Alleim Buch vorgestellten Programme funktionieren auf dem ArduinoUno einwandfrei, bei manchen Sketchen kann durch eigene Erweite-rungen der Speicher vollkommen belegt werden, aber darauf werdeich gesondert hinweisen.



30

1Kapitel

Das Ganze ist relativ einfach: Du verbindest Pin 12 mit der LED, die amweitesten links ist, und nimmst dann immer die nächste LED und dennächsten Pin. Damit haben wir die Beschaltung schon geschafft und wer-den jetzt die nächsten Experimente machen.

Zuerst wollen wir einfach eine Schleife entwickeln, die eine LED aufblin-ken lässt und danach die nächste benutzt usw. Der Quellcode dazu ent-hält nichts Neues und ist relativ einfach:

int pin1 = 8;

int pin2 = 9;

int pin3 = 10;

int pin4 = 11;

int pin5 = 12;

void setup() {

pinMode(pin1,OUTPUT);





}

void loop() {

//Lasse Pin 1 blinken

digitalWrite(pin1,HIGH);

delay(100);

digitalWrite(pin1,LOW);

delay(100);

//Pin 2


delay(100);


delay(100);

//Pin 3



31

Wie Funktionen funktionierenDu siehst, nichts Neues, aber etwas zu lang geraten für diesen kleinenEffekt. Nun müsste man diesen Code doch kürzen können, oder? Dieskann man mit Funktionen. Den Begriff hast du schon vorhin gelesen, jetztwerden wir selber eine Funktion schreiben. In unserem Fall ist die Funk-tion einfach ein Abarbeiten mehrere Befehle (eigentlich auch Funktionen,beispielsweise digitalWrite()), »gekapselt« über einen einzigen Aufruf.Durch Funktionen kann man den Code besser organisieren. Diese Technikist eine Methode zum sogenannten strukturierten Programmieren. Dazugehören u.a. auch Schleifen und Sprünge, wobei ich Sprünge in diesemBuch nicht behandle, da sie heutzutage veraltet sind und den Code ver-schlechtern, das nennt man dann Spaghetti-Code (kein Scherz, echterName!).

Nun geht’s aber weiter mit Funktionen. Schauen wir uns doch eine Funk-tion an, die du schon kennst: void digitalWrite(int,int). So kann manFunktionen kurz zusammenfassen, den Namen der Funktion sowie dieArten der zu übergebenden Parameter (in unserem Fall zwei Ganzzahlen).Vor der Funktion kommt die Rückgabeart, in unserem Fall void (die Funk-tion gibt nichts zurück; was das heißt, kommt gleich).


delay(100);


delay(100);

//Pin 4


delay(100);


delay(100);

//Pin 5


delay(100);


delay(100);

}



32

1Kapitel

Also kannst du eine Funktion so umschreiben:

Rückgabeart Funktionsname(Parameter) {funktionscode;}

Nach dem obigen langen Code zeige ich dir hier einmal eine dazugehö-rige Funktion:

So sieht unsere erste Funktion aus. In den (runden) Klammern geben wirParameter an, also welcher Pin geschaltet werden soll und wie lange. Inden geschweiften Klammern kommt dann der Code, der zur Funktiongehört.

Interessant wird es jetzt, wenn wir den gesamten Code auf den Arduinoladen, hier noch einmal die Übersicht unseres aktuellen Sketchs:

void blink(int pin,int msek) {

digitalWrite(pin,HIGH);

delay(msek);

digitalWrite(pin,LOW);

delay(msek);

}

Hinweis: Nach geschweiften Klammern kommt kein Semikolon.

void blink(int pin,int msek) {

digitalWrite(pin,HIGH);

delay(msek);

digitalWrite(pin,LOW);

delay(msek);

}

void setup() {

pinMode(8,OUTPUT);

pinMode(9,OUTPUT);

pinMode(10,OUTPUT);



33

Die Quelldatei ist jetzt wesentlich kürzer, macht aber genau dasselbe;praktisch, oder? Funktionsdefinitionen müssen immer außerhalb einerweiteren Funktion stehen, damit es keine Fehler gibt, damit kommen wirzu den sogenannten Gültigkeitsbereichen. Diese sind zwar etwas schwerzu verstehen, aber sehr wichtig. Nehmen wir an, du definierst eine Varia-ble in blink(). Kannst du sie auch in anderen Funktionen benutzen? Lei-der nicht. Das hängt mit den Gültigkeitsebenen zusammen. Damit du diesverstehst, hier ein kleiner Quellcode:

Dies ist zwar praktisch zu wissen, wird aber selten wichtig sein, wenn duprogrammierst. Viel wichtiger ist das Thema Auslesen der Pins, das auchweniger Theorie enthält und mehr Praxis.

pinMode(11,OUTPUT);

pinMode(12,OUTPUT);

}

void loop() {

blink(8,1000); //Dauer in Millisekunden

blink(9,1000);

blink(10,1000);

blink(11,1000);

blink(12,1000);

}

int dateiebene;

void setup() {

int funktionsebene;

}

Variablen, die in der Dateiebene definiert wurden, können überallaufgerufen werden. Variablen, die in der Funktionsebene definiertsind, können nur in der zugehörigen Funktion aufgerufen/benutztwerden.



34

1Kapitel

Das Lesen von EingängenDas Auslesen von Pins, die auf Eingang (Input) geschaltet sind, ist einwichtiges Thema, das du auch im Rest dieses Buches benötigen wirst.Nehmen wir mal folgenden Fall: Du willst eine LED nur dann blinkenlassen, wenn ein Button (Taster) gedrückt wird. Dazu brauchen wirdas Gegenteil von digitalWrite(), nämlich digitalRead(). Damit wirjetzt am Quellcode »basteln« können, brauchen wir erst mal folgendeSchaltung:




35

Baue diese am besten so wie abgebildet nach. Wichtig ist, dass du denButton wie abgebildet verkabelst, da es sonst zu Kurzschlüssen kommenkann. Nun musst du aber auch einen Widerstand anschließen, dessenWert man schlecht erkennen kann. Dieser beträgt 10 Kiloohm.

Sollte alles funktionieren, fangen wir mit dem Quellcode an. Wiegewohnt, zuerst der Sketch und dann die Erklärung:

If und Else: Wenn das nicht klappt, mache dasDu siehst gleich mehrere neue Programmiertechniken und Funktionen:die If-Else-Abfrage sowie das Lesen und Setzen eines »Inputstatus«.

Zuerst die Erweiterung der pinMode()-Funktion: Durch »INPUT« signali-sieren wir, dass der PIN intern (im Mikrochip) gelesen werden soll, undnicht »beschrieben« wie beim Schalten einer LED. Danach die Zahlenvari-able buttonstate; wir weisen ihr in der loop()-Schleife keinen direktenWert zu, sondern den, der von der Funktion digitalRead() zurückgege-ben wird. (In diesem Fall 0 = kein Strom, 1 = Strom.) Wie du dies selberprogrammierst, kommt noch in diesem Kapitel. Schwieriger wird es eineZeile darunter, denn dann kommen wir zur if-Abfrage. Damit du es bes-

int ledpin = 12;

int buttonpin = 11;

int buttonstate;

void setup() {

pinMode(ledpin,OUTPUT); //Output, da LED geschaltet wird

pinMode(buttonpin,INPUT); //Input, damit wir das lesen

// können

}

void loop() {

buttonstate = digitalRead(buttonpin);

if (buttonstate == HIGH) {

digitalWrite(ledpin,HIGH);

} else { digitalWrite(ledpin,LOW); }

}



36

1Kapitel

ser verstehst, schreibe ich diesen Codeteil einmal in Pseudocode auf(Pseudocode bedeutet: Inhalt einer Funktion wörtlich notieren, nicht dieProgrammierung)

Die geschweiften Klammern dienen dabei wie bei der Definition einer Funk-tion dazu, den Inhalt der Abfrage zuzuordnen. Dadurch weiß der Computer(Arduino), dass der Code in den geschweiften Klammern hinter if die Befehlenotiert, die ausgeführt werden sollen, wenn der Button gedrückt ist.

Nun kommen wir zu der if-Abfrage; sie ist in etwa so aufgebaut:

Eine Bedingung kann dabei ein Vergleich zwischen einer Variablen undeiner Konstanten sein, wie in unserem Beispiel zwischen der Variablenbuttonstate und der Konstanten HIGH. Zu beachten ist, dass man zweiGleichheitszeichen nimmt (!), denn dadurch macht man dem Arduinodeutlich, dass dies ein Vergleich ist (buttonstate == HIGH) und keineZuweisung (int xy = 9). Natürlich kannst du nicht nur auf Gleichheit prü-fen, sondern auch auf Folgendes (wenn wir annehmen, dass x = 5 ist):

wenn button gedrückt

-> dann LED anschalten

ansonsten

-> LED ausschalten

if (bedingung) {

//Dann führe den Code aus, der hier steht

}

Operator Beispiel Ergebnis

== (ist gleich) x == 5 Wahr

!= (ungleich) x != 5 Falsch, da x = 5 ist

> (größer) x > 3 Wahr, da x = 5 ist und somit größer als 3

< (kleiner als) x < 10 Wahr, da x = 5 ist und somit kleiner als 10

>= (größer oder gleich) 10 >= x Wahr, da x = 5 ist und somit 10 größer ist

<= (kleiner oder gleich) x <= 3 Falsch, da x = 5 ist und somit größer als 3



37

Das mag jetzt vielleicht etwas kompliziert aussehen, wenn du aber imKapitel weiterliest, wirst du die Tabelle besser verstehen.

Nun kommen wir noch zu dem else: else ist Englisch und heißt übersetztansonsten. Wenn du unseren Quellcode aussprichst, lautet er: Wenn but-tonstate gleich HIGH, dann schalte die LED an, ansonsten schalte sie aus.Noch deutlicher wird es durch diese Zeichnung, ein sogenanntes Fluss-Diagramm.

Der else-Teil wird übrigens auch in geschweiften Klammern zusammen-fasst und kann nur hinter einer if-Abfrage stehen (irgendwo anderswürde dies auch keinen Sinn ergeben). Nun können wir auch den gesam-ten Quellcode/Sketch in Pseudocode notieren und darstellen:

Inhalt der Loop-Schleife:

- Lese, ob an Pin 11 (buttonpin) Strom anliegt, der Button

also betätigt wird; wenn ja, schreibe HIGH* in die

Variable, ansonsten schreibe LOW* in die Variable (es

liegt also kein Strom an).

- Prüfe nun, ob HIGH in der Variablen steht.

->Steht HIGH dort, dann schalte die LED an.

->Steht etwas anderes darin (else),schalte die LED



38

1Kapitel

* HIGH und LOW werden intern in Ganzzahlen umgewandelt, deswegen auch Integer-Variablen

So solltest du die Funktion des Sketchs verstehen. Damit die Funktionenaber besser sitzen, hier noch eine kleine Aufgabe:

Bedingungen in der PraxisSchreibe ein Programm, das eine Variable x von y subtrahiert und in derVariablen z speichert. Sollte z größer als 10 sein, so soll eine LED ange-schaltet werden, ansonsten nicht. Der Code kann auch im setup-Teil ste-hen. Versuche, erst selber eine Lösung zu erarbeiten, und schaue dir dannmeinen Vorschlag an.

Und, war doch nicht so schwer, oder? Der englische Fachbegriff für eineIf-Abfrage ist übrigens if-clause.

aus (in unserem Fall steht entweder HIGH oder LOW

darin).

- Fange wieder von vorne an (Loop-Schleife!).

int x = 312; //Hier immer einen Wert für

int y = 9; //x und y angeben

int z;

void setup() {

z = x – y; //Ziehe(subtrahiere) x von y ab und speichere

//in z

if (z > 10) { //Ist z größer als 10, also min. 11

digitalWrite(13,HIGH); //Schalte die Led an Pin 13

} else {

digitalWrite(13,LOW);//In jedem anderen Fall:

//Schalte die LED aus (eigentlich kann die else-

//Klausel in diesem Fall leer bleiben, da die LED

//am Anfang sowieso ausgeschaltet ist)

}

}

void loop() {}


Unser drittes Programm: Morsen

39

Unser drittes Programm: MorsenNun wollen wir aber auch etwas entwickeln, was mindestens einengeringen praktischen Nutzen hat. Ich dachte da an ein kleines Gerät, dasuns beim Morsen helfen kann. Der Morsecode wurde 1833 von SamuelMorse entwickelt, um Zeichen mit einem von ihm entwickelten Schreib-telegrafen zu übermitteln. Nach mehreren Verbesserungen entstanddann schließlich der heute gebräuchliche Code (u.a. unter Mitarbeit vonA. Vail und F. Gerke). Wenn du mehr zur Geschichte dieses Codes erfahrenmöchtest, kannst du dies unter de.wikipedia.org/wiki/Morsezeichennachlesen.

Ich schlage nun vor, einen Morsetaster zu entwickeln, der bei einem But-tondruck akustisch ein Signal ausgibt, damit man Morsen besser übenkann. Dabei kannst du auch das Vorgehen zum Entwickeln eigener Pro-jekte üben.

Die Hardware anschließenZuerst müssen wir überlegen, was wir an Hardware brauchen. Neben demArduino und dem Breadboard inklusive der Kabel (unserer Grundausstat-tung) brauchen wir für dieses Projekt einen Button und ein Mittel zurAusgabe der Morsesignale. Dafür bieten sich LEDs, Lautsprecher, die seri-elle Schnittstelle (siehe nächstes Kapitel) oder auch Protokolle auf einerMikro-SD-Karte (kommt in einem späteren Kapitel) an. Ich werde dasGanze mit einem Lautsprecher implementieren, dir aber auch zeigen,dass man es leicht auf eine LED portieren kann. Also brauchen wir auchnoch einen kleinen Lautsprecher.

Sollte es dir zu aufwendig sein, einen passenden Lautsprecher zu finden,kannst du auch einfach die zweite Version mit LEDs benutzen. Nun wol-len wir zuerst die Schaltung entwickeln, damit wir »etwas« Hardware

Hier noch ein Tipp, falls du den Inhalt einer offiziellen Funktion ver-gessen hast (beispielsweise digitalWrite()): Markiere den Namender Funktion und gehe im Kontextmenü (Rechtsklick) auf »Find inReference«. Du erhältst daraufhin eine Seite in deinem Browser miteiner kurzen Erklärung und einen Beispielcode mit der korrektenAnwendung/Benutzung (markiere dabei aber nur das orange hinter-legte Wort in der IDE).



40

1Kapitel

zum Basteln haben. Dabei wird das Schalten des Lautsprechers über denArduino vorgenommen, wir brauchen also zwei Schaltkreise (Arduino &Button sowie Arduino & Lautsprecher). Hier nun der versprocheneSchaltplan:


Die Kabel sind zwar etwas eckig geraten, aber das Prinzip sollte verständ-lich sein. Zuerst werden die Powerrails (die durchgezogenen Kontakte


Unser drittes Programm: Morsen

41

ganz außen) mit Plus und Minus verbunden (aber auf zwei Leisten) unddann mit dem Button verbunden. Das gelbe Kabel geht dabei zum Inputam Mikrocontroller. Eventuell musst du noch einen Übergang in derMitte der Powerrails machen, da dort bei manchen Breadboards eineUnterbrechung vorliegt.


Die SoftwareDamit kommen wir auch schon zum Quellcode, unserem Sketch. Dukannst versuchen, im Internet eine Funktion zu finden, um Töne über denLautsprecher auszugeben (Stichwort tone()), so wäre das Vorgehen, wenndu selber ein Projekt erstellst. Du kannst aber auch jetzt einfach den klei-nen Quellcode ansehen:

int buttonstate;

int note = 720; //Tonhöhe der Note

void setup() {

pinMode(7,INPUT);

}

void loop() {

buttonstate = digitalRead(7);


tone(8,note); // Gib Ton aus

} else {



42

1Kapitel

In dem Beispiel gehe ich davon aus, dass der Lautsprecher an Pin 8 ange-schlossen ist, der Button an Pin 7. In der Variablen int note steht die Ton-höhe, mit der auf dem Lautsprecher geschrieben werden soll (um genauzu sein, ist es die Frequenz). Unten kommt wieder eine If-Abfrage und dieeinzige neue Funktion: tone(). Diese ist aber auch relativ einfach aufge-baut. Der erste Parameter ist der Pin (bei uns Pin 8) und der zweite Para-meter ist die Frequenz (gespeichert in der Variablen note). Nun könnenwir das Ganze auch auf eine LED portieren, was du erst einmal alleineversuchen solltest. Auch wenn dies sehr einfach ist, kommt die Lösunghier.

Dies war auch nicht wirklich schwer. Schwerer wird es, wenn man denCode sehr kompakt gestalten will. Der folgende Code zeigt dies, ist aberfür Anfänger schwer zu verstehen und ich rate von der Verwendung ab,da er schlecht zu lesen und fehleranfällig ist.

noTone(8); //Ansonsten sei still :)

}

}

int buttonstate;

void setup() {

pinMode(7,INPUT);

pinMode(8,OUTPUT); //LED an Pin 8,

//die Button-Schaltung bleibt

//gleich

}

void loop() {

buttonstate = digitalRead(7);


digitalWrite(8,HIGH);

} else {

digitalWrite(8,LOW);

}

}


Unser viertes Programm: Der heiße Draht

43

Unser viertes Programm: Der heiße DrahtNun hast du einen Morsetaster mit verschiedenen Ideen zur Implemen-tierung. Nun wollen wir noch etwas Theoretisches machen, um dann einSpiel nachzubauen.

Beim Theoretischen geht’s wieder um das Programmieren von Funktionen,aber diesmal mit Rückgabewerten. Zudem lernst du auch noch die switch()-Funktion kennen (eine sogenannte Fallunterscheidung). Anschließendwollen wir ein größeres Projekt angehen, nämlich eine Neuentwicklungdes bekannten Spiels »Der heiße Draht«. Falls du es nicht kennst, es gehtdarum, einen Ring über einen Parcours aus einem gebogenen Draht zuschieben, ohne den Draht zu berühren. Berührt man den Draht, wird einAlarm ausgelöst. Wir wollen das Spiel aber noch um einen Schritt erwei-tern: Wir wollen über LEDs auch eine Aussage über die Zeit des Spielersgeben. Damit du eine Vorstellung hast, was du kaufen musst, hier eineEinkaufsliste:

0 ein Draht

0 ein Holzbrett (zum Befestigen des Spiels)

0 eine Heißklebepistole

0 3 LEDs (in Rot, Gelb und Grün)

0 Lötzinn und einen Lötkolben

0 einen Piezolautsprecher (voriges Projekt, dort nur als Lautsprecherbezeichnet)

0 und natürlich unseren Arduino

Am besten, du arbeitest erst einmal Anhang C durch, denn dort wirderklärt, wie man mit einem Lötkolben umgeht und wie man lötet.

Es braucht zwar seine Zeit, bis du das Ganze gebastelt hast, wenn du esaber schön machst, hast du nachher umso mehr. Zur Verkabelung: DieLEDs werden an die Pins 12 und 10 angeschlossen (Rot = 12, Grün = 10).Der Lautsprecher kommt an Pin 9, die beiden Buttons zum Starten und

void setup() {pinMode(7,INPUT);}

void loop()

{digitalRead(7) == 1 ? tone(8,720) : noTone(8);}



44

1Kapitel

Beenden an Pin 8 und 7, der »Ring« an Pin 6 und der eigentliche Draht anden Pluspol. (Für die Farben siehe den Download auf www.mitp.de/9470)


Zuerst die Variablen und FunktionenHier zuerst eine Liste der Variablen, die wir verwenden:

int red = 12;

int green = 10;

int yellow = 11;



45

Du merkst, hier werden die Funktionen angekündigt. Das dient dazu, dassdu eine Funktion aus der Funktion heraus aufrufen kannst, ohne auf dieReihenfolge zu achten. Deutlich wird das an diesem Beispiel (lässt sichnicht kompilieren, dient nur der Veranschaulichung):

Dies wird nicht funktionieren, da ende aufgerufen wird, bevor es definiertwurde. Der Übersetzer weiß also nicht, wo er die Funktion ende herneh-men soll. Wird zuerst ende() definiert, passiert das Gleiche mit start().Um dies zu umgehen, definiert man die Funktionen im Voraus:

int alert = 9;

int button_start = 8;

int button_end = 7;

int touch = 6;

//Hier die Funktionen, die wir schreiben werden

int play_game();

void show_result();

bool game_stop();

bool check_touch();

void clear_game();

int start() {

ende();

}

int ende() {

start();

}

int start();

int ende();

int start() {

ende();

}



46

1Kapitel

So funktioniert das Programm, da es bereits eine Referenz auf die Funk-tion ende() gibt. Frage mich allerdings nicht, warum man das so entwi-ckelt hat.

Nun zurück zu unserem Programm. Nachdem wir wissen, welche Funkti-onen wir in etwa brauchen werden, müssen wir nun eine Stelle finden,wo wir mit dem Schreiben anfangen. Schau dir einmal das nachfolgendeSchaubild an: Hier liste ich in einer Art Baumstruktur auf, von welcherFunktion welche aufgerufen wird.

Wir sollten einen der äußeren Punkte nehmen, damit wir wissen, wie eineFunktion aussieht, und dann die nächsthöhere implementieren (nur beiplay_game() ist dieser Fall gegeben). Ich würde sagen, wir fangen beiclear_game() an, da dies die einfachste Funktion ist. Sie soll lediglich diedrei LEDs ausschalten, wenn wir ein neues Spiel anfangen:

int ende() {

start();

}

void clear_game() {

digitalWrite(red,LOW);

digitalWrite(yellow,LOW);

digitalWrite(green,LOW);

}



47

Dies ist auch die leichteste Funktion. Ich wette, die hättest du auch ausdem Kopf schreiben können. Denn Code kannst du einfach irgendwo hin-ter das bereits Geschriebene setzen. Nun machen wir weiter mitgame_stop(). Dies ist ebenfalls sehr einfach, da wir nur prüfen wollen, obder Button zum Beenden des Spiels gedrückt wird:

Wenn du die erste Zeile liest, siehst du, dass diesmal ein bool vor demFunktionsnamen steht und kein void! Dies kommt daher, dass die Funk-tion einen Wert zurückgeben soll. Wenn du in der Liste mit den Variab-lentypen nachsiehst, erkennst du, dass bool ein Variablentyp ist, derentweder true oder false beinhaltet. Zurückgegeben werden diese Wertemit return. Um etwas besser zu verdeutlichen, wie dieser Mechanismusfunktioniert, hier noch einmal ein weiterer Code zu Demonstrationszwe-cken:

Jetzt ist der Sinn vielleicht etwas deutlicher geworden. Wozu das Ganzedient und wozu wir den Datentyp bool nehmen, erkläre ich bei der Imple-mentierung der Funktion play_game(). Doch nun kommen wir zu derFunktion check_touch(). Diese funktioniert ähnlich wie game_stop(), dabeide das Spiel beenden.

bool game_stop() {

int state = digitalRead(button_end);

if (state == 1) {return true;

} else {

return false;

}

}

int addiere(int a,int b) {

int c = a + b;

return c;

}

int foo = addiere(5,4); //foo enthält jetzt den Wert

//9, da 5+4 = 9, und der

//berechnete Wert wird zurückgegeben, um ihn in einer

//Variablen zu speichern



48

1Kapitel

Zeit messenDiese Funktion verhält sich analog (= ähnlich) wie game_stop(). Dies istdarauf zurückzuführen, dass beide zu einem Spielabbruch führen undeiner Bewertung des Ergebnisses. Um es zu vereinfachen, werden wirnicht zwischen »Draht berührt« und »Spiel erfolgreich beendet« unter-scheiden, diese Anpassung kannst du allerdings selber relativ einfachanfertigen. Nun wird es einen Tick schwerer, wir messen nämlich die Zeitseit dem Starten des Arduinos, um einen Wert über die Zeitdauer desSpiels zu erhalten. Hier wieder die kleine Funktion, die dies erfüllt:

Wenn du gut aufgepasst hast, weißt du, dass long-Variablen einen grö-ßeren Zahlenbereich als int erfassen. Neu ist auch die Funktion millis(),die die Anzahl der Millisekunden seit dem Start des Arduinos ausgibt.Den Inhalt bei dem while()-Teil erkläre ich später. Nun wirst du aber pro-testieren, dass du auch mehrere Spiele hintereinander spielen willst, ohnejedes Mal den Arduino neu starten zu müssen. Auch dafür gibt es eineLösung, die bauen wir aber erst in der finalen (= fertigen) Fassung unse-res Sketchs ein.

bool check_touch() {

if (digitalRead(touch) == 1) {

return true;

} else {

return false;

}

}

int play_game() {

long time = 0;

while(!game_stop() && !check_touch()) {

time = millis();

}

return time;

}



49

Das Ergebnis ausgebenWenn du nun wieder auf unser Schaubild siehst, merkst du, dass uns nurnoch eine Funktion fehlt, show_result(). Sie wird den Wert der Dauermessen und ihn analysieren. Liegt man unter 3 Sekunden, lassen wir diegrüne LED leuchten. Unter 10, aber über 3 Sekunden wird die gelbeleuchten. Dauert es mehr als 10 Sekunden, leuchtet die rote LED. DieWerte musst du gegebenenfalls an deinen »Parcours« anpassen, da mei-ner relativ einfach zu bewältigen ist. Zuerst kommt die Funktion mit If-Abfragen:

Switch: Die passende Reaktion auslösenDies kannst du aber auch wesentlich eleganter lösen, indem du denswitch-Befehl benutzt. Dabei kannst du eine Variable nach bestimmtenInhalten abfragen und gegebenenfalls eine passende Reaktion auslösen:

void show_result(long time) {

if (time < 3000) { //Zeit unter 3 Sek.

digitalWrite(green,HIGH);

}

if (time > 3000 && time < 10000) { //Zeit über 3

//Sek., aber unter 10 Sekunden

digitalWrite(yellow,HIGH);

}

if (time > 10000) { //Zeit über 10 Sekunden

digitalWrite(red,HIGH);

}

}

void show_result(long time){

switch(time) {

case 0-3000 : digitalWrite(green,HIGH); break;

case 4000-10000 : digitalWrite(yellow,HIGH);

break;



50

1Kapitel

Du siehst, der Code reduziert sich um einiges. Die Funktion einer switch-Struktur lässt sich auch erahnen. Mit switch(variable) wird sie eingelei-tet. Danach kommt mit case immer ein Absatz, in dem geprüft wird, obeine Variable den angegebenen Inhalt besitzt, beispielsweise beim ersten,ob die Variable einen Inhalt zwischen 0 und 3 besitzt. Hinter dem Dop-pelpunkt kommt der Code, der ausgeführt werden soll, wenn der Wertzwischen 0 und 3 liegt, jedenfalls ist das so bei unserem Beispiel. Mitbreak wird der aktuelle case-Teil beendet. Dann kann entweder dienächste case-Verzweigung kommen oder ein default-Zweig, der sich wieeine else-Verzweigung verhält.

Der Code oben ist zwar etwas zusammengerückt, lässt sich aber auchausführlich aufschreiben:

Die beiden Varianten bewirken aber das Gleiche. Noch eine Anmerkungzu eventuellen Fehlern bei eigenen Programmen: In einer switch-clausekönnen keine neuen Variablen definiert werden. Zur Vollständigkeit nocheinmal der gesamte Sketch nach aktuellem Stand:

default: digitalWrite(red,HIGH); break;

}

}


switch(time) {

case 0-3000 : //if(time < 3.1) ...

.....digitalWrite(green,HIGH);

break;

case 4000-10000 :

....digitalWrite(yellow,HIGH);

break;

default: //Ansonsten

digitalWrite(red,HIGH);

break;

}

}



51

int red = 12;

int green = 10;

int yellow = 11;

int alert = 9;

int button_start = 8;

int button_end = 7;

int touch = 6;

int play_game();

void show_result(long time);

bool game_stop();

bool check_touch();

void clear_game();

void setup() {}

void loop() {

int start = digitalRead(button_start);

if(start == 1) {

clear_game();

long time = play_game();

show_result(time);

}

}

int play_game() {

long time = 0;

while(!game_stop() && !check_touch()) {

time = millis();

}

return time;

}



52

1Kapitel

bool game_stop() {

int state = digitalRead(button_end);

if (state == 1) {return true;

} else {

return false;

}

}

void clear_game() {

digitalWrite(red,LOW);

digitalWrite(yellow,LOW);

digitalWrite(green,LOW);

}

bool check_touch() {

if (digitalRead(touch) == 1) {

return true;

} else {

return false;

}

}


switch(time) {

case 0-3000 : digitalWrite(green,HIGH); break;

case 4000-10000 : digitalWrite(yellow,HIGH); break;

default: digitalWrite(red,HIGH); break;

}

}



53

While: Eine Schleife ausführenJetzt siehst du die while-Schleife erneut. Eine while-Schleife verhält sichwie die loop()-Schleife, nur dass eine while-Schleife so lange ausgeführtwird, wie die Bedingungen im Schleifenkopf (der Teil in den runden Klam-mern) stimmen. Diesmal arbeiten wir mit bool-Variablen, wodurch wiruns das ständige »!=« ersparen können. Das, was jetzt folgt, gilt übrigensauch für if-Abfragen. Du kannst auch einfach if(variable) schreiben,wenn es sich bei variable um eine boolesche Variable handelt. Ist ihrInhalt »true«, wird die If-Klausel ausgeführt, sonst nicht. Durch ein »!«verneinen wir den Inhalt. if(!variable) wird also nur ausgeführt, wennder Inhalt ungleich true ist, also false. Wir können auch zwei Bedingun-gen verknüpfen, indem wir && einsetzen. Im obigen Fall heißt das: Nurwenn game_stop() und check_touch() ein false zurückliefern, wird dieSchleife ausgeführt. Du kannst aber auch wollen, dass nur einer der Para-meter stimmen muss: Wenn wir oben

notieren, wird die Schleife ausgeführt, auch wenn nur einer der Parame-ter ein false zurückliefert. Die genaue Funktion dieser »Konnektoren«werden wir uns aber noch in einem späteren Kapitel ausführlicher anse-hen.

Da haben wir schon einiges geschafft. Nun haben wir aber noch das Pro-blem, dass die Zeit immer vom Start des Arduinos aus gemessen wird undnicht vom Start des Spiels an. Dazu muss lediglich die loop() angepasstwerden.

if (!game_stop() || !check_touch())

void loop() {

int start = digitalRead(button_start);

if(start == 1) {

clear_game();

long cur = millis();

long time = play_game();

time = time - cur;

show_result(time);

}

}



54

1Kapitel

In der Variablen cur (von engl. current, was aktuell bedeutet) wird dieaktuelle Zeit seit dem Start des Arduinos gemessen. Danach ziehen wirdie vorangegangene Zeit von der Gesamtzeit ab. Einfacher wird es, wennwir mit Zahlen rechnen:

0 Bis zum Drücken des Startbuttons sind 3000 Millisekunden vergangen.

0 Nach dem Beenden des Spiels sind 10000 Millisekunden vergangen,also 3000 ms vom Start sowie 7000 ms reine Spielzeit.

0 Die reine Spielzeit berechnet sich aus der Gesamtzeit (long time,10000 ms) minus der Zeit, bevor das Spiel begonnen wurde (long cur,3000 ms). Es wurden also 7000 ms (= 7 Sekunden) zum Lösen desParcours gebraucht.

ZusammenfassungDies war eines der ausführlichsten Kapitel, deswegen ist die Zusammen-fassung auch verhältnismäßig etwas knapp geraten:

0 Du hast die IDE installiert und deinen ersten Sketch geschrieben.

0 Du kannst PINs mit digitalWrite() und digitalRead() benutzen.

0 Du weißt, wie du Variablen benutzt und Funktionen schreibst.

0 Du kennst die if()- und switch()-Kontrollstrukturen.

0 Und du hast einen Morsetaster sowie das Spiel »Der heiße Draht«nachgebaut.

Ein paar Fragen ...1. Wo stellt man das verwendete Arduino-Board ein?

2. Wozu dienen bool-Variablen?

3. Welche Schleifenart hast du kennengelernt?

4. Was bewirkt die Funktion millis()?


... und ein paar Aufgaben

55

... und ein paar Aufgaben1. Schreibe das Programm für den Morsetaster so um, dass es sowohl

einen Ton ausgibt als auch blinkt.

2. Suche in der Referenz der Arduino-Befehle nach der Seite für denBefehl setup().

3. Schreibe ein Programm, das eine Reihe von 10 LEDs blinken lässt.

4. Schreibe eine Funktion, die eine Quadratzahl berechnen kann (x² = x * x).

5. Entspann dich etwas nach diesem langen Kapitel.


das installieren der software ist relati v einfach. zuerst ... · pdf file21 1 blinke, blinke,...

Documents