02 Die Arduino-Sprache C/C++

Genau genommen gibt es keine Arduino-Sprache. Das Arduino-Projekt verwendet eine vereinfachte Version der Sprachen C und C++, um Hardware anzusteuern. Dies sind sehr mächtige Programmiersprachen, mit denen viele professionelle Anwendungen erstellt werden.

Das Arduino ist eine Untermenge von C/C++ mit zusätzlichen und abgespeckten Funktionen, die mit den Hardware-Funktionen des Boards zusammenhängen. Es besitzt somit ähnliche Datentypen wie C/C++, aber auch geänderte und neue exklusive Typen. In diesem Kapitel wollen wir uns nur einen Überblick über die “Arduino-Sprache” verschaffen. Zu diesem Zweck schauen wir uns den sogenannten Blink-Code an. Der Blink-Code ist der Klassiker, wenn es um die ersten Programmierschritte geht. Wie der Name schon darauf hindeutet, lässt er die eingebaute LED (Pin 13) auf dem Arduino-Board blinken.

Das Wort Programm oder Code wird in der Arduino-Welt meistens als Sketch bezeichnet. Der Begriff Sketch betont das skizzenhafte schnelle Entwerfen von Arduino-Projekten, in dem man schnell Ideen realisieren kann. Die Begriffe Programm, Sketch oder Code werden in diesem Buch als Synonyme verwendet und sind austauschbar.

Sketche werden in deinem Computer geschrieben und dann auf das Arduino übertragen (hochgeladen). Es wird eine Kopie in den Speicher des Arduino-Mikrocontrollers abgelegt. Dabei wird ein laufendes Programm auf dem Board sofort gestoppt und überschrieben. Solange das Arduino mit Strom versorgt wird, läuft der neue übermittelte Sketch. Wird das Board von der Stromzufuhr getrennt, läuft verständlicherweise nichts mehr. Liegt wieder Strom an, nimmt das Arduino-Board sofort den Betrieb auf und startet den Sketch neu.

Der Blink-Sketch

Eine detaillierte Funktionsweise des Blink-Sketches werden wir uns im nächsten Kapitel ansehen. Zuvor wollen wir uns die generelle Programmstruktur näher betrachten. Siehe dir folgenden Code an und versuche zu erraten, was jede einzelne Zeile macht.

void setup()
{
pinMode(13,OUTPUT);
}

void loop()
{
digitalWrite(13,HIGH);
delay(1000);
digitalWrite(13,LOW);
delay(1000);
}

Die Syntax

Wenn wir Menschen miteinander kommunizieren, konstruieren wir Sätze, in dem wir gewisse Satzregeln einhalten, in der Hoffnung, dass uns die andere Seite versteht. Jede gesprochene Sprache enthält eine Grammatik, die bestimmte Regeln aufstellt, um eine gemeinsame Kommunikationsgrundlage sicherzustellen. Dementsprechend werden im Satzbau Objekte, Verben, Adjektive oder Zeiten positioniert.

Da im weitesten Sinne Programmiersprachen sich an die gesprochenen Sprachen anlehnen, besitzen sie eine gewisse Grammatik, die Syntax genannt wird. Dies sind bestimmte Regeln, wie Code geschrieben wird. Die Arduino IDE ist besonders streng bei der Einhaltung von Syntaxregeln und verweigert bei Regelbruch jeden Dienst.

Funktionen

Funktionen führen Aktionen aus. Du erkennst sie meistens an den beiden Klammern am Ende des Funktionsnamens. Die Funktion delay() (Englisch für Verzögerung) pausiert zum Beispiel den Code und macht an dieser Stelle gar nichts.

delay(1000);

Einige Funktionen können durch Parameter etwas genauer eingestellt werden. Die Zahl 1000 im oberen Beispiel innerhalb der Klammern des delays ist in diesem Fall eine Zeitangabe in Millisekunden und gibt an, wie lange pausiert werden soll. So können wir Funktionen unseren Bedürfnissen anpassen.

Was sollen die Slashs, Semikolons und anderen merkwürdigen Zeichen?

Es fällt dir wahrscheinlich schwer, den oberen Code zu verstehen – mit all den ungewöhnlichen Zeichen. Es wird dich etwas Zeit kosten, dich daran zu gewöhnen. Schließlich lernst du genau genommen so etwas wie eine neue Sprache mit der dazugehörigen Grammatik. Jedes Zeichen hat seine Bedeutung. Falls auch nur einer fehlt oder am falschen Platz steht, funktioniert der Code nicht. Betrachten wir folgende vier Zeichen etwas genauer:

Kommentare // /**/
Semikolons ;
Klammern ()
Geschweifte Klammern {}

Kommentare // oder //**

Kommentare sind äußerst hilfreich und beschreiben den Sketch. Es ist so eine Art von Notizen. Zum einen helfen sie anderen, sich in deinem Code zurechtzufinden. Das macht besonders Sinn, wenn ihr Hilfe braucht und euren Code z.B. in einem Forum teilt. So verstehen andere leichter was die Zusammenhänge sind.

Und zum anderen ist es für dich eine Gedächtnisstütze. Falls du nach längerer Zeit die Arbeit an einem komplexeren Code wieder aufnimmst, kann es leicht passieren, dass dir die Funktionsweise deines Programms entfallen ist. Dann wird das "Reinkommen" durch Kommentare viel leichter.

Kommentare werden vom Computer völlig ignoriert und nicht ausgeführt. Einen Kommentar erkennst du in der Arduino-IDE an der hellgrauen Schrift. Beim Uploaden des Sketches vom PC auf das Arduino-Board werden Kommentare nicht übertragen – macht auch gar keinen Sinn. Das würde nur kostbaren Speicherplatz belegen.

Es gibt zwei Möglichkeiten, den eigenen Code zu kommentieren:
/**/ Slash-Stern kommentiert über mehrere Zeilen. Also alles was zwischen /* und */ steht, ist ein Kommentar. Diese Form wird meistens am Programmkopf (die ersten Zeilen im Sketch) angewendet, um viele Informationen aufzulisten: Name des Programms, Funktionsbeschreibung, Autor, Quelle usw…

/* Alles was

zwischen diesen Zeichen

steht, wird ignoriert.

*/

Im Gegensatz dazu kommentiert ein Doppel–Slash // nur eine Zeile aus. Diese Form wird oft innerhalb des Codes genutzt.

// Alles was hinter diesem Doppel–Slash steht wird ignoriert.

Semikolons ; sind überall

Wir Menschen benutzen in unserer Schrift Pausen (Punkte) in einem Satz, um dessen Ende anzuzeigen. Ohne die Pausen zwischen den Sätzen würde uns das Verstehen schwerfallen. Genauso verhält es sich in der Arduino-Sprache: Ein Semikolon (auch Statement Terminator genannt) zeigt das Ende einer Befehlskette an. Sie sind fast überall. Hier ein Beispiel:

 pinMode(tonePin, OUTPUT);    //Semikolon
  for(int x=0; x<=3; x +=1)   //in diesem Fall kein Semikolon nötig
  {
   tone(tonePin, 100, 500);   //Semikolon
   delay(250);		      //Semikolon
   tone(tonePin, 44, 222);   //Semikolon
   delay(500);    	     //Semikolon 
  }

Klammern ()

Klammern werden auf zwei Arten benutzt. Zum einen werden Fragen (Konditionen) innerhalb Klammern platziert. Eine if-Abfrage (wenn-Abfrage) ist solch ein typischer Fall. In einer if()-Funktion wird eine Kondition innerhalb der Klammern formuliert. Wenn die Kondition zutrifft, werden Befehle innerhalb der geschweiften Klammern ausgeführt, die zuvor ignoriert wurden. Zum Beispiel: Wenn die Taste gedrückt wird, dann mache irgendetwas.

if (taste == gedrückt)  //die Klammer beinhaltet die Frage/Kondition
{
  //dann mache irgend etwas
}

Zum anderen werden Klammern benutzt, um Informationen zu übergeben. In die Klammern werden Daten platziert, mit denen die Funktion arbeiten kann.

delay(1000); 	//Dies ist eine Pausefunktion. 
	        //Die Zahl innerhalb der Klammern ist die Zeit, 
                //in der die Funktion pausiert.

Geschweifte Klammern {}

Diese speziellen Klammern erfüllen verschiedene Aufgaben. Sehen wir uns das Beispiel von oben noch einmal an. Solange die Kondition einer if-Abfrage unerfüllt bleibt, werden alle Befehle innerhalb der geschweiften Klammer ignoriert. Die geschweiften Klammern verpacken somit die Befehle der if-Funktion und verwehren den Zugang. Mit anderen Worten die If-Abfrage ist so etwas wie eine Tür mit einem Schloss und die geschweiften Klammern die Mauern, die den Inhalt umgeben.

if (taste == gedrückt) // die Klammer beinhaltet die Frage/Kondition
			//Wenn die Taste gedrückt wird, dann...
{
 //dann mache irgend etwas
}

Neben dem Gruppieren von Befehlen werden diese Klammern als Indikatoren benutzt. Wenn das Programm bei der void loop()-Funktion die letzte geschweifte Klammer erreicht, weiß das Programm, dass es nun Zeit ist wieder an den Anfang der Schleife zu springen.

void loop()
{
 //Hier werden Befehle ausgeführt.
 ...
 
} //Wird diese Klammer erreicht, 
  //springt das Programm wieder an den Anfang.

Tipp den Code ein!! Oder lass es sein.

Bitte kein copy und past! Anfangs solltest du den Code nach tippen. Dadurch bekommst du ein Gefühl für das Programmieren. Zu Beginn wirst du öfters Fehler im Code haben. Das wird sich schnell legen, je öfter du programmierst. Wenn du den Code mit den Augen nur überfliegst, wirst du später mit steigender Programmkomplexität überfordert sein. Das Lernen von Programmierung muss haptisch angeeignet werden und ist niemals durch reine Theorie zu ersetzen.

Lass uns gleich eine praktische Übung machen. Folge den unteren Übungsanweisungen, in dem du den Blink-Code nach tippst. Mache dir keine Gedanken über die Bedeutung des Codes. Wir gehen im nächsten Kapitel detaillierter darauf ein. Der untere Code lässt eine LED im Sekundentakt blinken. Die LED (Light Emitting Diode) ist ein sehr verbreiteter und nützlicher Halbleiter, das Licht produziert. Du brauchst an dieser Stelle keine Elektronik anschließen. Die meisten Arduinos besitzen eine eingebaute LED, die sofort angesteuert werden kann.

1. Stecke das Arduino-Board an
Schließe mit dem USB-Kabel das Arduino Uno an deinen Computer an.

2. Starte die Arduino-IDE und wähle das richtige Arduino-Board aus
Gehe hierzu im oberen Menü auf den Eintrag Werkzeuge > Board und wähle im Fenster Arduino Uno.

2. Den seriellen Port einstellen.
Jedes Arduino-Board hat sein eigenes Kommunikations-Protokoll, ein sogenannter serieller Port und muss explizit eingestellt werden: Gehe wieder zu Werkzeuge und wähle Port aus. Es erscheint ein Dropdown-Menü in der alle verfügbaren USB-Ports aufgelistet werden. Jeder Computer hat andere Kombinationen serieller Ports, je nachdem welche anderen Komponenten auf dem Rechner verwendet werden. Wähle den Eintrag in dem usbmodem auftaucht.

Windows-Rechner zeigen eine Liste an COM-Einträgen. Wahrscheinlich ist es der letzte Eintrag und sollte mit dem Wort Arduino erscheinen. Falls das Arduino-Port gar nicht erscheint, trenne das USB-Kabel mit dem Arduino. Beim erneuten Verbinden sollte es erscheinen. Schließe zur Not die Arduino IDE und öffne es wieder. Manchmal hilft auch ein Neustart des PCs. Wird das Port immer noch nicht angezeigt, kann es an fehlenden Treibern liegen. Gehe hierzu zur Arduino Troubleshooting-Seite.

3. Tippe den folgenden Blink-Sketch in die Arduino IDE ein.
Achte auf Gross- und Kleinschreibung! Geschweifte Klammern erzeugst du mit der Tastenkombination alt + 8 und alt + 9.

void setup()
{      
  pinMode(13, OUTPUT);  
}

void loop()
{
  digitalWrite(13, HIGH);  
  delay(1000);            
  digitalWrite(13, LOW);    
  delay(1000);              
}

4. Das Programm zum Arduino-Board transferieren

Momentan befindet sich der eingetippte Code noch auf deinem PC und muss noch auf das Arduino-Board übertragen werden. Doch bevor du das machen kannst musst du zuerst den Code speichern. Gehe im oberen Menü auf Datei > Speichern unter oder alternativ die Tastenkombi Shift + cmd + S. Gib der Datei den Namen blink_LED

Zum hochladen des Codes tippe auf das zweite Symbol (nach rechts zeigender Pfeil) in der linken oberen Ecke oder du benutzt die Tastenkombination ⌘U.

###Bild mit icon

Sobald du etwas auf das Arduino-Board hochlädst wird das aktuell laufende Programm gestoppt und überschrieben. Ist das Uploaden abgeschlossen, wird sofort das neu geladene Programm ausgeführt. Die LED sollte jetzt im Sekundentakt blinken.

Ist der Upload nicht erfolgreich wird in der unteren Leiste der Arduino-IDE eine Fehlermeldung angezeigt. Meistens liegt der Grund an falsch ausgewählten Boards oder seriellen Ports. Oder der Code ist fehlerhaft. In diesem Fall korrigiere den Fehler und versuche es noch einmal.

####bild fehlermeldung

5. Kommentare
Sieh dir den Code an und versuche heraus zu finden was die einzelnen Zeilen zu bedeuten haben. Kommentiere in eigenen Worten innerhalb des Codes was nach deiner Meinung passiert. Benutze die Kommentator-Funktion wie oben beschrieben.

back