Kontrollstrukturen - Schleifen

Die for-Schleife

Die for-Schleife gehört zu den wichtigsten Kontrollstrukturen eines Programms und erlaubt das wiederholende Ausführen eines Programmabschnitts. Die Schleife beginnt mit dem Schlüsselwort for, gefolgt von drei Anweisungen im Schleifenkopf. Im Schleifenrumpf, welcher in geschweiften Klammern {...} steht, befindet sich der wiederholend auszuführende Anweisungsblock.

Ausführung einer for-Schleife:

Initialisierung mit einer Zählvariable. Die Deklaration der Zählvariable int i kann innerhalb oder außerhalb des Schleifenkopfs erfolgen. Wird sie im Schleifenkopf initialisiert, wird die Zählvariable nur während der Abarbeitung der Schleife existieren.
Überprüfen der Testbedingung mittels logischer Ausdrücke. Im obigen Beispiel liefert die Testbedingung so lange true, wie der Wert von i kleiner als 10 ist. Für i = 10 oder Werte größer 10 liefert die Testbedingung false.
Wenn die Testbedingung false liefert, wird die Schleife direkt beendet (ohne die Anweisungen im Schleifenrumpf auszuführen).
Wenn die Testbedingung true liefert, werden die Anweisungen im Schleifenrumpf ausgeführt.
Aktualisieren der Zählvariable. Der Ausdruck i++ bedeutet i=i+1 und erhöht den Wert der Variable i bei jedem Durchlauf.

caution

Die einzelnen Ausdrücke im Schleifenkopf werden mit einem Semikolon voneinander getrennt.

Vergleichsoperatoren

Arduino stellt eine Reihe verschiedener Vergleichsoperatoren zur Verfügung. Alle Operatoren haben gemeinsam, dass zwei Werte miteinander verglichen werden und als Ergebnis nur true (1) oder false (0) zurückgegeben wird.

Operator	Erläuterungen
`x == y`	Ist x gleich y?
`x != y`	Ist x ungleich y?
`x < y`	Ist x kleiner y?
`x > y`	Ist x größer y?
`x <= y`	Ist x kleiner gleich y?
`x >= y`	Ist x größer gleich y?

tip

Die Operatoren = und == sind sehr verschieden. Während = ein Zuweisungsoperator ist, also einer Variablen einen Wert zuweist (z.B. int wert = 312) handelt es sich bei == um einen Vergleichsoperator, der true zurückgibt, wenn zwei Werte gleich sind. Das Verwechseln beider Operatoren ist ein häufiger Fehler bei Programmieranfänger*innen.

Beispiel

// Einfaches Beispiel für eine for-Schleife

void setup() {
  Serial.begin(115200);
  Serial.println("Warten (1 sec) ....");
  delay(1000);
  for (int i = 0 ; i<5; i++)
  {
    Serial.print("Zaehler: "); Serial.println(i);
    delay(500);
  }
}

void loop() {
  // bleibt leer
}

Ausgabe auf dem seriellen Monitor:

Warten (1 sec) ....
Zaehler: 0
Zaehler: 1
Zaehler: 2
Zaehler: 3
Zaehler: 4

Eine geschachtelte `for` Schleife

Schleifen können auch geschachtelt werden. Bei einer geschachtelten Schleife befindet sich im Rumpf der äußeren Schleife eine weitere innere Schleife. Dadurch wird die innere Schleife sooft neu gestartet, wie es in der äußeren Schleife angegeben ist.

 https://wokwi.com/arduino/projects/318944954351092307 
/* Eine geschachtelte for-Schleife
 * Wokwi-Link: https://wokwi.com/arduino/projects/318944954351092307 */

void setup() {
  Serial.begin(115200);
  Serial.println("Warten (1 sec) ....");
  delay(1000);
  int i,j; // Deklaration der Zählvariablen auch außerhalb der Schleife möglich
  for (i = 0 ; i<5; i++) // Zeilen (äußere Schleife)
  {     
    Serial.println();  
    Serial.print("Zeile: "); Serial.print(i);
    for(j=0; j<10; j++)  // Spalten (innere Schleife)
    {
      Serial.print("*");
      delay(100);
    }
  }
}

void loop() {
  // bleibt leer
}

Im obigen Beispiel wird die innere Schleife

for(j=0; j<10; j++)  // Spalten (innere Schleife)

welche 10 mal durchlaufen wird, von der äußeren Schleife 5 mal neu gestartet. Insgesamt wird also die Zeile

Serial.print("*");

in der inneren Schleife 50 mal aufgerufen.

Auf dem seriellen Monitor erscheint folgende Ausgabe:

Warten (1 sec) ....

Zeile: 0**********
Zeile: 1**********
Zeile: 2**********
Zeile: 3**********
Zeile: 4**********

Aufgaben

Schreiben Sie ein Programm, welches abwechselnd zwei verschiedene LEDs blinken lässt:
- Zuerst blinkt die 1. LED 3x auf.
- Anschließend blinkt die 2. LED 5x auf.
- Dann beginnt die Blinksequenz wieder von vorne.
- Nutzen Sie die for-Schleife und vermeiden Sie sich wiederholenden Code.
Schreiben Sie ein Programm, welches die Blinkgeschwindigkeit einer (oder mehrerer) LEDs schrittweise von ganz langsam zu ganz schnell und wieder zu ganz langsam, etc. ändert.
Ändern Sie das Programm mit der geschachtelten Schleife so, dass auf dem seriellen Monitor folgender Text ausgegeben wird:
```
Zeile: 0*
Zeile: 1**
Zeile: 2***
Zeile: 3****
Zeile: 4*****
Zeile: 5******
Zeile: 6*******
Zeile: 7********
Zeile: 8*********
Zeile: 9**********
```
Hinweis: Bei der Testbedingung im Schleifenkopf können auch zwei Variablen miteinander verglichen werden:
for(int i = 0; i > k; i++){ ... }

Ändern Sie das Programm mit der geschachtelten Schleife noch einmal. Diesmal soll folgender Text ausgegeben werden:

Zeile: 0**********
Zeile: 1*********
Zeile: 2********
Zeile: 3*******
Zeile: 4******
Zeile: 5*****
Zeile: 6****
Zeile: 7***
Zeile: 8**
Zeile: 9*

Lassen Sie zwei LEDs im angegebenen Rhythmus blinken.
Nutzen Sie geschachtelte `for`-Schleifen. Verwenden Sie maximal zweimal den Befehl `delay()`.
Erweitern Sie folgendes Programmgerüst so, dass 5 angeschlossene LEDs wie unten abgebildet blinken. Zum Vervollständigen des Programms dürfen Sie maximal zweimal den Befehl digitalWrite() verwenden.
Achten Sie beim Aufbauen der Schaltung auf die Verwendung der richtigen Pins.
```
// 5 LEDs mit for-Schleife blinken lassen
int dTime = 200;

void setup(){
    for (int i = 2; i <= 6; i++){
        pinMode(i, OUTPUT);
    }
}
void loop(){
    // maximal zweimal 'digitalWrite()' verwenden
  
}
```

Die while-Schleife

Die while-Schleife wird so lange ausgeführt (also der dazugehörige Code-Block), wie die Testbedingung wahr (true) ist. Damit ist sie von der Struktur wesentlich einfacher als die for-Schleife.

int i = 1;
while(i < 5){
  Serial.println(i);
  i++;
}

Serieller Monitor:

Mit der while-Schleife auf eine Tastereingabe warten

Die while-Schleife eignet sich besonders gut, um ein Programm so lange pausieren zu lassen, bis ein Taster gedrückt wurde. Auch wenn die Tastereingabe erst im nächsten Abschnitt behandelt wird, soll hier schon einmal der Code für die Programmverzögerung vorgestellt werden.

/* Die while-Schleife wird solange ausgeführt, wie der Taster nicht gedrückt ist.
 * Das Programm pausiert also, bis der Taster gedrückt wurde. */

int zustandTaster = digitalRead(TASTER)
while (zustandTaster) { // zustandTaster: gedrückt = LOW (0) / offen = HIGH (1)
    zustandTaster = digitalRead(TASTER)
}

Die for-Schleife​

Vergleichsoperatoren​

Beispiel​

Eine geschachtelte for Schleife​

Die while-Schleife​

Mit der while-Schleife auf eine Tastereingabe warten​