Was wir ja noch brauchen ist irgendwas, wie wir auf Ereignisse reageiren können und das Programm entsprechend verzweigen kann.
Das nennt man Kontrollstrukturen. Dazu gehören Verzweigungen und Schleifen.
Verzweigungen werden üblicherweise an eine Bedingung geknüpft. (Jaja, auch hier geht nix ohne Bedingungen…) Auf deutsch heist das Wenn…dann…sonst, auf Arduinesisch
if…{} else {} ist da der richtige Befehl. Ein wenig Syntax:
byte schalter = digitalRead(SCHALTER_PIN);
if (schalter == 0) {
// Taste gedrückt
} else {
// Taste nicht gedrückt
}
Eine 0 wird auch als Falsch (false) angesehen d.h. man könnte auch folgendes schreiben:
byte schalter = digitalRead(SCHALTER_PIN);
if (!schalter) {
// Taste gedrückt
}
Man kann auch vor dem Else Zweig eine weitere Bedingung einfügen:
if (schalter1 == 0) {
// Schalter 1 gedrückt
} else if (schalter2 == 0) {
// Schalter 2 gedrückt
} else {
// keine Taste gedrückt
}
Will man noch mehr verzweigen gibts auch dafür einen eigenen Befehl. Das ganze nennt sich Switch.
switch (Ausdruck) {
case 1. Möglichkeit:
1. Befehl
...
break;
case 2. Möglichkeit:
2. Befehl
...
break;
case 3. Möglichkeit:
3. Befehl
...
break;
...
default:
;
}
Ausdruck muss irgendeinen Wert ergeben. Danach wird der entsprechende Zweig (case) wählt und von dort weiter gemacht. Von dort weitergemacht, ist ein ganz wichtiger Satz würde das break; fehlen (das break springt aus der Case-anweisung raus, also zu dem 1. Befehl nach der }) würden alle weiteren case Zweige mit durchlaufen. Beispiel:
switch (Kommando) {
case CMD_1:
digitalWrite(LED_1,HIGH);
case CMD_2:
digitalWrite(LED_2,HIGH);
case CMD_3:
digitalWrite(LED_3,HIGH);
default:
;
}
Ist Kommando = CMD_1 dann würden alle 3 LED's eingeschaltet, bei CMD_2 nur 2 und 3… Das kann man sich natürlich auch zu nutze machen…
Und natürlich brauchen wir Schleifen. Eine haben wir bereits kennen gelernt. Die Hauptprogrammschleife. Diese wird vom Arduino automatisch gebildet. Aber man braucht natürlich manchmal auch was eigenes. Dabei gibt es 2 verschiedene Typen von Schleifen, einmal Zählschleifen und dann bedingte Schleifen. (An die Programmierer: Natürlich ist der Übergang bei C fliessend…)
Das ist die Mutter aller Schleifen. Die sog. for-Schleife
for (int i = 1; i <= 100; i++) {
...
}
Der Aufbau ist einach. Zunächst kommt das Schlüsselwort for. Dann folgt ein Teil in runden Klammern. Darin sind immer 3 Teile, die durch ein ; getrennt werden.
Der 1. Teil ist die sog. Initialisierung. Also was soll das Programm am Anfang tun. Hier wird eine Variable i erzeugt und mit 1 initialisiert.
Der 2. Teil ist die Bedingung. Solange diese Bedingung wahr ist, wird die Schleife ausgeführt.
der 3. Teil ist das Increment, hier wird der Befehl eingetragen, der nach der Schleife ausgeführt werden soll. (Normalerweise eben ein erhöhen oder erniedrigen der Zählvariable) Man kann das increment auch weglassen, wenn man innerhalb der Schleife die Schleifenvariable irgendwie selber berechnet.
Der Block zwisschen den {} Klammern ist der Ausfürhrungsteil.
Wenn man das genauer betrachtet merkt man schnell, daß eine for-Schleife nicht nur zählen kann.
Aber es gibt noch 2 weitere Schleifen
while(Bedingung){
// Kommandos
}
Die Kommandos werden so lange ausgeführt, wie die Bedingung wahr ist. Also 0..n mal.
Sehr ähnlich aber doch nicht ganz gleich
do {
// Kommandos
} while (Bedingung);
Da die Bedingung erst am Ende geprüft wird, wird die Schleife min. 1 mal durchlaufen.
Beispiel: Alle 8 LED's einschalten (Pins 0..7) in allen drei Schleifenvarianten
for (int pin = 0; pin <= 7; pin++) {
digitalWrite(pin,HIGH);
}
int pin =0
while (pin <=7) {
digitalWrite(pin,HIGH);
pin = pin + 1;
}
int pin =0
do {
digitalWrite(pin,HIGH);
pin = pin + 1;
} while (pin <=8)
Hier sieht man gut den Unterschied zwischen der 1 und 2 While-Schleife.
Jede Schleife kann vor Ihrer Abbruchbedingung auch mit dem Kommand
break
beendet werden.
int pin =0
do {
digitalWrite(pin,HIGH);
pin = pin + 1;
if (pin == 4) break;
} while (pin <=8)
Hier würde die Schleife niemals bis zum 8 Pin durchlaufen werden, denn bei Pin 4 wird die Schleife expliziet abgebrochen.