Mikrocontroller/ Programmierung

Programmierung des Arduino Mikrocontrollers

In diesem Kapitel soll eine kurze Einführung in die Programmierung des Arduino Boards gegeben werden. Weiterführende Informationen finden sich in der Arduino Referenz und dem Arduino Programming Notebook von Brian W. Evans.

Imperative ProgrammierungBearbeiten

Ein Programm in einer imperativen Programmiersprache besteht im Wesentlichen aus Anweisungen, die der Reihe nach ausgeführt werden. Einige Beispiel für Anweisungen:

1 int counter; // die Variable counter wird als ganze Zahl definiert
2 int x = 5;   // die Variable x ist eine ganze Zahl und hat den Wert 5
3 
4 counter = 10 * x; // der Variablen counter wird der Wert 50 zugewiesen
5 int inputVariable = analogRead(2); // der ganzzahligen Variablen
6                                    // inputVariable wird der Wert von
7                                    // analogRead(2) zugewiesen
8 x = x - 3;   // x wird der neue Wert x-3 zugewiesen

Jede Anweisung muss in unserer Programmiersprache (C/C++) mit einem Semikolon „;“ abgeschlossen werden.

Programmplanung und DokumentationBearbeiten

Man kann Programme mit Hilfe von Flussdiagrammen planen und darstellen, z.B. als Programmablaufplan. Besser angepasst an (imperative) Programmiersprachen sind Nassi-Shneiderman-Diagramme, die für Kontrollstrukturen spezielle Symbole bereit halten.

Programmablaufplan PAPBearbeiten

Elemente (Auswahl)Bearbeiten

 
Beispiel eines Programmablaufplans.

Hauptsächlich werden in einem Programmablaufplan die folgenden Elemente verwendet:

  • Kreis; Oval / Rechteck mit gerundeten Ecken: Terminator  
  • Pfeil, Linie: Verbindung zum nächstfolgenden Element  
  • Rechteck: Operation (Tätigkeit)  
  • Rechteck mit doppelten, vertikalen Linien: Unterprogramm  
  • Raute: Verzweigung / Entscheidungen  
  • Parallelogramm: Ein- und Ausgabe  

Nassi-Shneiderman-StruktogrammeBearbeiten

Elemente (Auswahl)Bearbeiten

 
Der euklidische Algorithmus zur Berechnung des größten gemeinsamen Teilers zweier Zahlen als Nassi-Shneiderman Diagramm.
VerzweigungBearbeiten

Wenn die Bedingung zutreffend (wahr) ist, wird der Anweisungsblock 1 durchlaufen; trifft die Bedingung nicht zu (falsch), wird der Anweisungsblock 2 durchlaufen (if then else). Ein Anweisungsblock kann aus einer oder mehreren Anweisungen bestehen. Austritt unten nach Abarbeitung des jeweiligen Anweisungsblocks.

SchleifeBearbeiten

Wiederholungsstruktur, bei der die Anzahl der Durchläufe festgelegt ist (for). Als Bedingung muss eine Zählvariable angegeben und mit einem Startwert initialisiert werden. Ebenso muss ein Endwert und die (Zähl-)Schrittweite angegeben werden. Nach jedem Durchlauf des Schleifenkörpers (Anweisungsblock 1) wird die Zählvariable um die Schrittweite inkrementiert (bzw. bei negativer Schrittweite dekrementiert) und mit dem Endwert verglichen. Ist der Endwert überschritten bzw. unterschritten, wird die Schleife verlassen.


Heute findend vor allem sog. Aktivitätsdiagramme, die (auch) für objektorientierte Sprachen geeignet sind, zusammen mit der Unified Modeling Language (UML) Verwendung.

KontrollstrukturenBearbeiten

Bevor wir uns anhand von einigen Programmbeispielen mit der Programmierung unseres Mikrocontrollers vertraut machen, sollen in diesem Abschnitt grundlegende und in fast allen Programmiersprachen vorhandene Kontrollstrukturen vorgestellt werden.

BedingungenBearbeiten

Das Durchlaufen von Kontrollstrukturen erfolgt abhängig von Bedingungen (Tests). Bedingungen werden bei uns wie folgt ausgedrückt und sind entweder wahr oder falsch:

1 (x>5)                   // wahr, wenn x>5 ist, sonst falsch
2 (x<3)                   // wahr, wenn x<3 ist, sonst falsch
3 (x==7)                  // wahr, wenn x=7 ist, sonst falsch
4 (x!=7)                  // wahr, wenn x ungleich 7 ist, sonst falsch
5 (a>0 && b>0)            // wahr, wenn a>0 und b>0 ist, sonst falsch
6 (a>0 || b>0)            // wahr, wenn a>0 oder b>0 ist, sonst falsch
7 ((a>0 || b>0) && c==0)  // wahr, wenn a>0 oder b>0 ist und dazu c=0

Verzweigung: if-AbfrageBearbeiten

 1 if ( <test1> )
 2 {
 3     <statements1>;
 4 }
 5 else if ( <test2> )     // optional
 6 {
 7     <statements2>;
 8 }
 9 else                    // optional
10 {
11     <statements3>;
12 }

Die if-Abfrage erlaubt abhängig von Tests verschiedene Programmteile (Anweisungen) entweder zu durchlaufen d.h. auszuführen oder andernfalls zu überspringen. Diese bedingte Ausführung hat die Abgebildete allgemeine Struktur.

Dabei werden die Anweisungen <statements1> nur ausgeführt, wenn <test1> wahr ist. Ist <test1> falsch, <test2> jedoch wahr, so wird <statements2> ausgeführt. Ist weder <test1> noch <test2> wahr, so werden die Anweisungen in <statements3> ausgeführt.

Schleifen: while, do…while und forBearbeiten

while-SchleifeBearbeiten

1 while ( <test> )
2 {
3     <statements>;
4 }
 
Vorprüfende (kopfgesteuerte) Schleife.

Die Anweisungen <statements> werden so lange (und nur dann) ausgeführt, wie die Bedingung <test> wahr ist.

Die Schleife läuft endlos, wenn <test> nicht innerhalb der Anweisungen <statements> oder aufgrund äusserer Einflüsse (z.B. eines Sensorwerts) verändert und dadurch falsch wird.

do…while-SchleifeBearbeiten

1 do
2 {
3     <statements>;
4 }
5 while ( <test> )
 
Nachprüfende (fußgesteuerte) Schleife.

Die Anweisungen <statements> werden ausgeführt und so lange wiederholt, wie die Bedingung <test> wahr ist.

for-SchleifeBearbeiten

1 for (<start value>; <test>; <expression>)
2 {
3     <statements>;
4 }
 
Zählergesteuerte Schleife.

Eine for-Schleife dient dazu, Anweisungen mehrfach zu durchlaufen. Dabei muss <test> wahr sein und die Anweisung <expression> wird nach jedem Schleifendurchlauf ausgeführt.

In den folgenden Abschnitten sind zahlreiche Beispiele für die Verwendung von if-Abfragen und Schleifen zu finden.


Aufgaben:


Das Blink-Programm im DetailBearbeiten

Betrachten wir ein einfaches Beispielprogramm. Wenn man das folgende Programm auf das Arduino-Board lädt, so blinkt die eingebaute LED an Pin 13. Den grundsätzlichen Aufbau von Arduino-Programmen können wir schon an diesem Beispiel erkennen:

 1 /* Blink
 2    Turns on a LED for one second, then off for one second,
 3    repeatedly.  This example code is in the public domain.
 4 */
 5 
 6 void setup() {
 7   // initialize the digital pin as an output.
 8   // Pin 13 has an LED connected on most Arduino boards:
 9   pinMode(13, OUTPUT);
10 }
11 
12 void loop() {
13   digitalWrite(13, HIGH);   // set the LED on
14   delay(1000);              // wait for a second
15   digitalWrite(13, LOW);    // set the LED off
16   delay(1000);              // wait for a second
17 }

Programmkopf und KommentareBearbeiten

Die Zeilen 1 bis 5 stellen den sogenannten „header“ (engl. „Kopfteil“) dar. Sie beschreiben das Programm und enthalten weitere wichtige Informationen wie z.B. die Lizenz, unter der das Programm steht. Alle diese Angaben sind in die Kommentarzeichen /* und */ eingefasst. Aller Text zwischen diesen Zeichen spielt für den Ablauf des Programms keine Rolle, ist aber für den Programmierer umso wichtiger. Einzelne Zeilen(-teile) werden mit // wie z.B. Zeile 8, 9 bzw. in 14 ff. „auskommentiert“.

Funktionen: setup() und loop()Bearbeiten

Nach dem „header“ beginnt das auf dem Mikroprozessor ausgeführte Programm mit einer Funktion. Beim Programmieren stellen Funktionen, die manchmal auch Unterprogramme genannt werden, ein wesentliches Element dar. Wir kennen Funktionen aus der Mathematik:  . Die Funktion heißt  ,   ist der Name der Funktion. Die Funktion bekommt als Argument die Variable   übergeben und gibt   zurück. D.h. wenn wir z.B.   an die Funktion   übergeben, bekommen wir   zurück. Im Gegensatz dazu müssen Funktionen in Programmen keine Argumente übergeben bekommen. Auch müssen sie nichts zurückgeben. Beides ist bei Programm-Funktionen völlig unabhängig voneinander.

Unser einfaches Programm besteht aus zwei Funktionen, die in jedem Arduino-Programm vorhanden sein müssen. Betrachten wir die erste Funktion, definiert in den Zeilen 7 bis 11. Funktionsdefinitionen sind immer gleich aufgebaut: Vor dem Funktionsnamen setup wird der Rückgabetyp der Funktion angegeben, in unserem Fall „void“ (engl. leer, nichts). Nach dem Funktionsnamen werden in runden Klammern die übergebenen Argumente angegeben. Bei uns wird nichts übergeben, die Klammern sind leer. Anschließend folgt in geschweiften Klammern der Funktionsblock: Alle hier gemachten Anweisungen werden zum Programmstart ausgeführt.

In unserem Fall wird, wie aus dem Kommentar ersichtlich, Pin 13 als OUTPUT (Ausgang) definiert. Alle digitalen Ports des Arduinos können entweder als Eingang (INPUT) oder Ausgang (OUTPUT) verwendet werden. OUTPUT bedeutet wir wollen ein Signal ausgeben, verwenden wir INPUT, so lesen wir ein Signal ein.

Hat der Mikrocontroller die Funktion setup() abgearbeitet, setzt er seine Arbeit mit der Funktion loop() (engl. Schleife), definiert in den Zeilen 13 bis 18, fort. Auch diese Funktion gibt nichts zurück (Rückgabetyp „void“) und bekommt auch keine Argumente übergeben: Die runden Klammern sind leer: (). Was passiert, wenn loop() ausgeführt wird? Wie aus den Kommentaren ersichtlich wird die LED eingeschaltet (HIGH), dann 1000 ms gewartet, anschließend wieder abgeschaltet (LOW) und wieder 1 s gewartet.

Sobald die Funktion loop() beendet wurde, wird sie sofort wieder aufgerufen und erneut ausgeführt: Die LED blinkt.

Das Digital/AnalogReadSerial-Programm im DetailBearbeiten

Nachdem wir sowohl digitale als auch analoge Signale erzeugen können, schauen wir uns nun zwei Programme an, mit denen wir die eingelesenen Signale am Bildschirm ausgeben können. Dies ist insbesondere zum Testen von Schaltungen bzw. Sensoren hilfreich.

Betrachten wir das DigitalReadSerial-Programm, das ein digitales Signal einliest und über die serielle Schnittstelle ausgibt. Die Anweisungen sind in Kommentaren erläutert:

 1 /* DigitalReadSerial
 2    Reads a digital input on pin 2, prints the result to the serial
 3    monitor.  This example code is in the public domain.
 4  */
 5 
 6 void setup() {
 7   Serial.begin(9600);  // Serielle Schnittstelle wird bereitgestellt
 8   pinMode(2, INPUT);   // Pin 2 wird als Eingang definiert
 9 }
10 
11 void loop() {
12   int sensorValue = digitalRead(2);  // Pin 2 wird ausgelesen und der
13                                      // (ganzzahligen) Variablen
14                                      // sensorValue zugewiesen.
15   Serial.println(sensorValue, DEC);  // Der Wert von sensorValue wird
16                                      // ausgegeben.
17 }

Das AnalogReadSerial-Programm funktioniert genau gleich wie das DigitalReadSerial-Programm, nur dass nun ein analoges Signal eingelesen wird:

 1 /* AnalogReadSerial
 2    Reads an analog input on pin 0, prints the result to the serial
 3    monitor.  This example code is in the public domain.
 4  */
 5 
 6 void setup() {
 7   Serial.begin(9600);
 8 }
 9 
10 void loop() {
11   int sensorValue = analogRead(A0);  // Analoger Eingang 0 wird
12                                      // ausgelesen.
13   Serial.println(sensorValue, DEC);
14 }

Vom Blinklicht zum LauflichtBearbeiten

Wir wollen nun das Blink-Programm durch Ansteuerung mehrerer LEDs zu einem Lauflicht erweitern. Im ersten Schritt erweitern wir unser Blink-Programm und fügen weitere LEDs hinzu. Dazu müssen wir die entsprechenden Pins als Ausgänge definieren. Unsere Funktion setup() sieht dann folgendermaßen aus:

1 void setup() {
2   // initialize the digital pins as output:
3   pinMode(9, OUTPUT);
4   pinMode(10, OUTPUT);
5   pinMode(11, OUTPUT);
6   pinMode(12, OUTPUT);
7   pinMode(13, OUTPUT);
8 }

Da sich Zeilen 3 bis 7 nur durch die Pin-Nummer unterscheiden, bietet sich die Verwendung einer for-Schleife an:

1 void setup() {
2   // initialize the digital pins as output:
3   for ( int i = 9; i != 14; i++ ){
4      pinMode(i, OUTPUT);
5   }
6 }

Die Schleife startet mit der ganzen Zahl   und wird solange durchlaufen, wie   ist. Bei jedem Durchlauf wird   um eins erhöht. Statt   kann man auch   schreiben.

Betrachten wir nun die Funktion loop(). In einem ersten Schritt schalten wir mit einer Schleife alle LEDs der Reihe nach an:

1 void loop() {
2   for ( int i = 9; i != 14; i++ ){
3     digitalWrite(i, HIGH);    // set the LED i on
4     delay(1000);              // wait for a second
5   }
6 }

Nun soll aber, wenn z.B. die LED an Pin 10 angeschaltet wird die LED an Pin 9 ausgehen, also immer die im Schleifendurchlauf zuvor angeschaltete LED soll wieder ausgeschaltet werden. Probieren wir folgendes:

1 void loop() {
2   for ( int i = 9; i != 14; i++ ){
3     digitalWrite(i, HIGH);    // set the LED i on
4     digitalWrite(i-1, LOW);   // set the LED i-1 off
5     delay(1000);              // wait for a second
6   }
7 }

Unser Programm funktioniert nun schon halbwegs, allerdings leuchtet die letzte LED permanent. Da   in unserer Schleife maximal bis   läuft, wird die LED   ausgeschaltet, jedoch nie LED 13. Wir lösen dieses Problem, indem wir die Schleife bis 14 laufen lassen. (Man beachte, dass dadurch ein fiktiver Pin 14 HIGH geschaltet wird, genauso wie Pin 8 schon im ersten Schleifendurchlauf LOW geschaltet wurde. Will man diese Pins verwenden, so muss das Programm an dieser Stelle verbessert werden!):

1 void loop() {
2   for ( int i = 9; i != 15; i++ ){
3     digitalWrite(i, HIGH);    // set the LED i on
4     digitalWrite(i-1, LOW);   // set the LED i-1 off
5     delay(1000);              // wait for a second
6   }
7 }

Schalten, Verzögerung und Glück oder PechBearbeiten

Auf Knopfdruck soll das Lauflicht, vergleichbar mit einem Glücksrad das sich dreht, langsamer wird und schließlich in einem Feld stehen bleibt, langsamer werden und schließlich bei einer LED anhalten. Abhängig von der LED soll dann eine Melodie ertönen.

Beginnen wir mit dem Einlesen eines digitalen Signals, das wir mit einem einfachen Taster erzeugen (siehe Abschnitt {digiSig}). Dazu benötigen wir einen Input-Pin:

1 void setup() {
2   // initialize the digital pins as output:
3   for ( int i = 9; i != 14; i++ ){
4     pinMode(i, OUTPUT);
5   }
6   pinMode(3, INPUT);  // initialize the digital pin 3 as input
7 }

In der loop-Funktion fragen wir Pin 3 ab. Wird der Taster gedrückt (Eingang Pin 3 ist HIGH d.h. es liegen   am Pin an) wird das Lauflicht bis zum Anhalten verzögert, andernfalls läuft es einfach wie zuvor weiter:

 1 void loop() {
 2   // Lese den digitalen Eingang 3 aus und speichere den
 3   // Wert (0 oder 1) in der Variable 'sensorValue':
 4   int sensorValue = digitalRead(3);
 5   if (sensorValue == 1){
 6     for (int p = 10; p < 300; p = p + 30){
 7       // Schleife Wartezeit
 8       for ( int i = 9; i != 15; i++ ){
 9         // Schleife Lauflicht
10         digitalWrite(i, HIGH);    // set the LED i on
11         digitalWrite(i-1, LOW);   // set the LED i-1 off
12         delay(p);                 // wait for p milliseconds
13       }
14     }
15   }else{
16     for ( int i = 9; i != 15; i++ ){
17       digitalWrite(i, HIGH);    // set the LED i on
18       digitalWrite(i-1, LOW);   // set the LED i-1 off
19       delay(1000);              // wait for a second
20     }
21   }
22 }

Nun soll das Lauflicht beim letzten Durchlauf bei einer zufällig gewürfelten LED anhalten. Dazu verwenden wir die Funktion random(min,max), die eine Zufallszahl zwischen min und max-1 zurückgibt. Im letzten Durchlauf halten wir bei der gewürfelten LED an und machen eine längere Pause. Je nachdem ob die „Glücks-LED“ gewürfelt wurde, wir entweder die Funktion happy() oder aber sad() aufgerufen:

 1 void loop() {
 2   // Lese den digitalen Eingang 3 aus und speichere den
 3   // Wert (0 oder 1) in der Variable 'sensorValue':
 4   int sensorValue = digitalRead(3);
 5   if (sensorValue == 1){
 6     int num = random(9,15);  // Zufallszahl 'num' zwischen 9 und 14
 7     for (int p = 10; p < 300; p = p + 30){
 8       // Schleife Wartezeit
 9       for ( int i = 9; i != 15; i++ ){
10         // Schleife Lauflicht
11         if ( p > 269 & num == i ){  // Wenn 'letzte Runde' und
12           digitalWrite(i-1, LOW);   // LED 'i' = Zufallszahl 'num'
13           digitalWrite(i, HIGH);
14           if (num == 11){
15             happy();
16             delay(1000);
17           }else{
18             sad();
19             delay(1000);
20           }
21         }
22         digitalWrite(i, HIGH);    // set the LED i on
23         digitalWrite(i-1, LOW);   // set the LED i-1 off
24         delay(p);                 // wait for p milliseconds
25       }
26     }
27   }else{
28     for ( int i = 9; i != 15; i++ ){
29       digitalWrite(i, HIGH);    // set the LED i on
30       digitalWrite(i-1, LOW);   // set the LED i-1 off
31       delay(1000);              // wait for a second
32     }
33   }
34 }

Die Funktionen happy() und sad()Bearbeiten

Die Funktionen happy() und sad() sollen eine Melodie spielen. Wie funktioniert das? Betrachten wir das Beispielprogramm toneMelodie:

 1 /*
 2  Melody
 3 
 4  Plays a melody,  circuit: 8-ohm speaker on digital pin 8
 5  by Tom Igoe
 6  This example code is in the public domain.
 7 
 8 */
 9 
10 #include "pitches.h";
11 
12 // notes in the melody:
13 int melody[] = {NOTE_C4, NOTE_G3,NOTE_G3, NOTE_A3,
14                               NOTE_G3,0, NOTE_B3, NOTE_C4};
15 
16 // note durations: 4 = quarter note, 8 = eighth note, etc.:
17 int noteDurations[] = {4, 8, 8, 4,4,4,4,4 };
18 
19 void setup() {
20   // iterate over the notes of the melody:
21   for (int thisNote = 0; thisNote < 8; thisNote++) {
22 
23     // to calculate the note duration, take one second
24     // divided by the note type.
25     //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
26     int noteDuration = 1000/noteDurations[thisNote];
27     tone(4, melody[thisNote],noteDuration);
28 
29     // to distinguish the notes, set a minimum time between them.
30     // the note's duration + 30% seems to work well:
31     int pauseBetweenNotes = noteDuration * 1.30;
32     delay(pauseBetweenNotes);
33     // stop the tone playing:
34     noTone(4);
35   }
36 }
37 
38 void loop() {
39   // no need to repeat the melody.
40 }

Anhand dieses Beispiels können wir happy() und sad() implementieren:

 1 void happy() {
 2   // notes in the melody:
 3   int melody[] = {NOTE_C4, NOTE_G3,NOTE_G3, NOTE_A3,
 4                               NOTE_G3,0, NOTE_B3, NOTE_C4};
 5 
 6   // note durations: 4 = quarter note, 8 = eighth note, etc.:
 7   int noteDurations[] = {4, 8, 8, 4,4,4,4,4 };
 8 
 9   // iterate over the notes of the melody:
10   for (int thisNote = 0; thisNote < 8; thisNote++) {
11 
12     // to calculate the note duration, take one second
13     // divided by the note type.
14     //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
15     int noteDuration = 1000/noteDurations[thisNote];
16     tone(4, melody[thisNote],noteDuration);
17 
18     // to distinguish the notes, set a minimum time between them.
19     // the note's duration + 30% seems to work well:
20     int pauseBetweenNotes = noteDuration * 1.30;
21     delay(pauseBetweenNotes);
22     // stop the tone playing:
23     noTone(4);
24   }
25 }
26 
27 void sad() {
28   for (int f = 1000; f > 100; f = f - 5) {
29     tone(4, f, 10);
30     delay(8);
31   }
32 }

Nicht zu vergessen ist die Einbindung der Datei pitches.h am Anfang des Programms. Die Datei pitches.h ordnet den Noten Frequenzen zu.

Ansteuerung einer LCD-AnzeigeBearbeiten

 1 /*
 2   LiquidCrystal Library - Hello World
 3 
 4  Demonstrates the use a 16x2 LCD display.  The LiquidCrystal library
 5  works with all LCD displays that are compatible with the Hitachi
 6  HD44780 driver. There are many of them out there, and you can usually
 7  tell them by the 16-pin interface.
 8 
 9  This sketch prints &quot;Hello World!&quot; to the LCD and shows the time.
10 
11   The circuit:
12  * LCD RS pin to digital pin 12   * LCD Enable pin to digital pin 11
13  * LCD D4 pin to digital pin 5    * LCD D5 pin to digital pin 4
14  * LCD D6 pin to digital pin 3    * LCD D7 pin to digital pin 2
15  * LCD R/W pin to ground
16  * 10K resistor: ends to +5V and ground, wiper to LCD VO pin (pin 3)
17 
18  This example code is in the public domain.
19  http://www.arduino.cc/en/Tutorial/LiquidCrystal
20  */
21 // include the library code:
22 #include <LiquidCrystal.h>;
23 // initialize the library with the numbers of the interface pins
24 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
25 
26 void setup() {
27   // set up the LCD's number of columns and rows:
28   lcd.begin(16, 2);
29   // Print a message to the LCD.
30   lcd.print("hello, world!");
31 }
32 void loop() {
33   // set the cursor to column 0, line 1
34   // (note: line 1 is the second row, since counting begins with 0):
35   lcd.setCursor(0, 1);
36   // print the number of seconds since reset:
37   lcd.print(millis()/1000);
38 }