Schleifen und Variablen: Blockprogrammierung mit Arduino

Schleifen und Variablen in der Blockprogrammierung sind die zwei Bausteine, die aus einem Programm, das etwas einmal tut, eines machen, das es ständig und klug tut. Eine Schleife führt dieselben Blöcke immer wieder aus, eine Variable merkt sich dabei eine Zahl. In den BlueGrays-Blöcken heißen sie "immer wiederholen", "zähle i", "globale Variablen (ganz oben)" und "setze … auf"; im Arduino-Code, der auf das Board kommt, entsprechen ihnen loop(), die for-Schleife, eine int-Variable und eine Zuweisung.

In diesem Teil lesen wir die Blöcke von vier kostenlosen Projekten neben ihrem echten C++-Code: LED-Lauflicht, das sechs LEDs nacheinander leuchten lässt, LED-Lauflicht mit einstellbarer Geschwindigkeit, das sein Tempo von einem Potentiometer bekommt, Knight-Rider-Lauflicht, das das Licht von einem Ende zum anderen und zurück schickt, und dessen Potentiometer-Version Knight-Rider-Lauflicht mit einstellbarer Geschwindigkeit. Alle vier nutzen dieselbe Schaltung: sechs LEDs an den Pins D2–D7 und ein Potentiometer an A0. Zum Schluss schreibst du ein eigenes Zählerbeispiel und lernst die drei häufigsten Anfängerfehler kennen: eins zu viel oder zu wenig zählen, über das Ende eines Arrays hinauslaufen und lange Wartezeiten, die Taster blind machen.

Der Block "immer wiederholen" und loop(): Warum hört das Board nie auf?

Ein Programm auf dem Computer beendet sich, wenn seine Arbeit getan ist; ein Arduino-Programm nicht. Das Board hat kein Betriebssystem, und der Prozessor hat sonst nichts zu tun. Deshalb hat jedes Blockprojekt dasselbe Gerüst: Was im Block "Setup (läuft einmal)" steht, läuft nur einmal, wenn das Board Strom bekommt oder der Reset-Taster gedrückt wird; was im Block "immer wiederholen" steht, wiederholt sich von oben nach unten ohne Pause. In C++ sind das die Funktionen setup() und loop(). Ist die letzte Zeile von loop() erledigt, springt das Board sofort zur ersten zurück; eine kurze loop() ohne Wartezeit kann zehntausende Male pro Sekunde laufen. Anhalten lässt sich das Board nur, indem du den Strom trennst oder ein neues Programm hochlädst. Diese endlose Wiederholung ist kein Fehler, sondern Absicht: Taster lesen, Sensoren beobachten, LEDs schalten, all das passiert bei jedem Durchlauf neu, und so reagiert das Board ständig auf Änderungen in seiner Umgebung.

Variablen in der Blockprogrammierung: globale Variablen und der Deklarieren-Block

Eine Variable ist eine kleine Kiste, in die du eine Zahl legst und die du über ihren Namen ansprichst. In den Blöcken entstehen Variablen im lila Block "globale Variablen (ganz oben)". Der Block "deklariere Ganzzahl (int) potValue = 0" darin wird im Code zur Zeile int potValue: int ist der Typ, potValue der Name und 0 der Startwert. "Ganz oben" ist wichtig: Diese Zeilen stehen außerhalb von setup() und loop() ganz oben in der Datei. Eine so angelegte globale Variable ist im ganzen Programm sichtbar und verliert ihren Wert nicht, wenn loop() von vorn beginnt. Auf dem Arduino Uno belegt ein int 2 Byte und speichert ganze Zahlen von -32768 bis 32767, mehr als genug für die 0–1023 von analogRead() und für Pinnummern. Vielleicht fällt dir auf, dass in den Blöcken von LED-Lauflicht mit einstellbarer Geschwindigkeit potValue = 0 steht, im Code aber nur int potValue;. Beides wirkt gleich: Globale Variablen ohne Startwert beginnen in C++ bei null.

Der Block, der den Wert später ändert, ist "setze … auf". Aus "setze potValue auf analog lesen A0" wird im Code potValue = analogRead(A0);. Das Gleichheitszeichen bedeutet hier nicht Gleichheit wie in Mathe, sondern "berechne den Wert rechts und lege ihn in die Kiste links". Ein Vergleich, ob zwei Werte gleich sind, schreibt sich in C++ mit ==; das haben wir im vorigen Teil der Reihe beim Wenn-Block gesehen. Sobald der Setze-Block läuft, wird der alte Inhalt gelöscht und der neue eingetragen. Alle Blöcke, die die Variable lesen, nutzen ab dann den neuen Wert: "potValue ms warten" wartet genau so viele Millisekunden, wie potValue in diesem Moment enthält.

Die Zählschleife: der Block "zähle i" und die Arduino for-Schleife

Um etwas eine feste Anzahl von Malen zu wiederholen, nimmst du den grünen Block "zähle i von 0 bis 5 in Schritten von 1". Er legt einen Zähler i an, setzt ihn auf 0, führt die Blöcke darin aus, erhöht i um 1, führt sie erneut aus und macht so weiter, bis i größer als 5 ist. Die Arduino-Entsprechung ist die Zeile for (int i = 0; i < 6; i++). In der Klammer stehen drei durch Semikolons getrennte Teile: der Start (int i = 0), die Bedingung zum Weitermachen (i < 6) und der Schritt nach jedem Durchlauf (i++, also i um eins erhöhen). Das Wichtigste dabei: Der Endwert im Block wird mitgezählt. "Von 0 bis 5" heißt 0, 1, 2, 3, 4 und 5; die Schleife läuft also nicht 5-mal, sondern 6-mal, und jede der sechs LEDs kommt einmal dran. Deshalb steht im Code i < 6, was dasselbe bedeutet wie i <= 5. Das Muster "bei null anfangen, weitermachen, solange kleiner als die Anzahl" ist in Arduino-Code sehr verbreitet, weil die 6 direkt die Zahl der LEDs nennt.

Der Array-Block: "Array 2 3 4 5 6 7" und ledPins[i]

Statt für sechs LEDs sechs einzelne Variablen anzulegen, kannst du alle in einer Liste halten. Steckt der lila Block "Array 2 3 4 5 6 7" in "deklariere Ganzzahl (int) ledPins = …", wird daraus im Code die Zeile int ledPins[] = {2, 3, 4, 5, 6, 7};. Die eckigen Klammern zeigen, dass es ein Array ist, die geschweiften enthalten die Werte. Ein Element erreichst du über seine Position, den Index, und in C++ beginnt der Index bei 0: Das erste Element ist ledPins[0], das letzte ledPins[5]. In den Blöcken erledigt das "Element i von ledPins", im Code wird daraus ledPins[i]. Weil auch die Zählschleife bei 0 beginnt, passen beide perfekt zusammen: i liefert bei jedem Durchlauf den nächsten Index, ledPins[i] die dort gespeicherte Pinnummer. Noch ein Vorteil: Willst du die Reihenfolge der LEDs ändern, tauschst du nur die Zahlen in der Liste, ohne die Schleife anzufassen. Mehr dazu findest du in Arrays beim Arduino.

LED-Lauflicht: Blöcke und C++ Zeile für Zeile

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri, yanma sırasıyla / LED pins in lighting order
2
3void setup() {
4  // Tüm LED pinlerini çıkış yap / Set all LED pins as outputs
5  for(int i = 0; i < 6; i++) {
6    pinMode(ledPins[i], OUTPUT);
7  }
8}
9
10void loop() {
11  // Her LED'i sırayla 150 ms yak / Light each LED in turn for 150 ms
12  for(int i = 0; i < 6; i++) {
13    digitalWrite(ledPins[i], HIGH);
14    delay(150);
15    digitalWrite(ledPins[i], LOW);
16  }
17}

Stell dir den Ablauf wie eine Zeitleiste vor. Beim Start macht die Schleife im Setup die sechs Pins von 0 bis 5 nacheinander zu Ausgängen, und das passiert nie wieder. Dann beginnt immer wiederholen: Die Zählschleife darin schaltet die LED an D2 ein, wartet 150 ms, schaltet sie aus und macht dasselbe mit D3, D4, D5, D6 und D7. Eine Runde dauert 6 × 150 = 900 ms. Geht die letzte LED aus, endet loop(), das Board springt sofort zurück an den Anfang und das Licht startet wieder bei D2; da zwischen den Runden keine Pause liegt, scheint das Licht ohne Unterbrechung zu fließen. Für ein anderes Tempo änderst du nur eine Zahl, die 150: Mit 50 läuft das Licht dreimal so schnell, mit 500 schlendert es gemütlich. Dieses feste Tempo per Drehknopf einstellbar zu machen, führt uns zum nächsten Projekt.

LED-Lauflicht mit einstellbarer Geschwindigkeit: der Potiwert wird zur Wartezeit

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri, yanma sırasıyla / LED pins in lighting order
2int potValue;                         // Pot değeri = bekleme (ms) / Pot value = delay (ms)
3
4void setup() {
5  // Tüm LED pinlerini çıkış yap / Set all LED pins as outputs
6  for(int i = 0; i < 6; i++) {
7    pinMode(ledPins[i], OUTPUT);
8  }
9}
10
11void loop() {
12  for(int i = 0; i < 6; i++) {
13    potValue = analogRead(A0);        // Hızı oku (0-1023) / Read the speed (0-1023)
14    digitalWrite(ledPins[i], HIGH);
15    delay(potValue);                  // Pot değeri kadar ms bekle / Wait as many ms as the pot value
16    digitalWrite(ledPins[i], LOW);
17  }
18}

Der einzige Unterschied zum LED-Lauflicht sind zwei neue Blöcke. Zu den globalen Variablen kommt "deklariere Ganzzahl (int) potValue = 0", und am Anfang der Zählschleife steht "setze potValue auf analog lesen A0". analogRead(A0) wandelt die Spannung am mittleren Pin des Potentiometers in eine Zahl von 0 bis 1023 um; diese Zahl geht direkt an "potValue ms warten", also an die Zeile delay(potValue). Drehst du den Knopf an ein Ende, leuchtet jede LED etwa eine Sekunde (1023 ms) und eine Runde dauert rund 6 Sekunden; am anderen Ende sinkt die Wartezeit auf 0, und die LEDs schalten so schnell, dass alle gleichzeitig schwach zu leuchten scheinen. Dass der Wert in der Schleife vor jeder LED gelesen wird, ist Absicht: Sobald du drehst, leuchtet schon die nächste LED im neuen Tempo, du musst nicht auf das Ende der Runde warten. Wie ein Potentiometer funktioniert, erklärt Was ist ein Potentiometer.

Knight Rider: zwei Schleifen, die vor- und zurückzählen

Beim Knight-Rider-Effekt wandert das Licht von einem Ende zum anderen und wieder zurück. In den Blöcken von Knight-Rider-Lauflicht stehen in immer wiederholen zwei Zählschleifen untereinander. Die erste ist das bekannte "zähle i von 0 bis 5 in Schritten von 1" und bringt das Licht von D2 nach D7. Die zweite ist "zähle i von 4 bis 1 in Schritten von 1": Weil der Start größer als das Ende ist, zählt der Block rückwärts, und i wird nacheinander 4, 3, 2, 1. Im Code ist das die Zeile for(int i = 4; i > 0; i--); i-- verringert i um eins. Warum von 4 bis 1 und nicht von 5 bis 0? Weil ledPins[5] (D7) schon am Ende des Hinwegs leuchtet und ledPins[0] (D2) am Anfang des nächsten. Werden die Enden auf dem Rückweg übersprungen, leuchten die äußeren LEDs nicht zweimal hintereinander, und das Zurückprallen wirkt flüssig. Hin und zurück sind 6 + 4 = 10 Schritte zu je 100 ms, zusammen 1 Sekunde. Knight-Rider-Lauflicht mit einstellbarer Geschwindigkeit nutzt dieselben zwei Schleifen; es setzt nur an den Anfang beider Schleifen "setze potValue auf analog lesen A0" und verwendet "potValue ms warten" statt 100 ms. Weitere Muster findest du in Arduino Knight Rider und Lauflicht.

Dein eigenes Zählerbeispiel: Rundenzähler und serielle Schnittstelle

Jetzt schreiben wir ein kleines Beispiel, das alles verbindet: Jedes Mal, wenn das Lauflicht eine Runde beendet, steigt ein Zähler, und das Board schickt sowohl die Werte von i als auch die Rundenzahl an den Computer. Mit den Blöcken aus den Bildern baust du das so: Unter das Array ledPins in den globalen Variablen kommt "deklariere Ganzzahl (int) rounds = 0". Ins Setup gehört der Block "Seriell starten mit 9600 Baud". In der Zählschleife geben, bevor die LED angeht, "seriell ausgeben"-Blöcke den Text "i = ", dann i und dann den Text " pin = " mit der Option "ohne Umbruch" aus, zum Schluss "Element i von ledPins" mit der Option "neue Zeile". Nach der Zählschleife, noch in immer wiederholen, bekommt ein Block "setze rounds auf …" die Summe rounds + 1, und die Rundenzahl wird mit "seriell ausgeben … neue Zeile" angezeigt.

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri / LED pins
2int rounds = 0;                       // tamamlanan tur sayısı / number of finished rounds
3
4void setup() {
5  Serial.begin(9600);                 // seri port 9600 baud / serial port at 9600 baud
6  for (int i = 0; i < 6; i++) {
7    pinMode(ledPins[i], OUTPUT);
8  }
9}
10
11void loop() {
12  for (int i = 0; i < 6; i++) {
13    Serial.print("i = ");             // aynı satırda kal / stay on the same line
14    Serial.print(i);
15    Serial.print("  pin = ");
16    Serial.println(ledPins[i]);       // alt satıra geç / new line
17    digitalWrite(ledPins[i], HIGH);
18    delay(300);
19    digitalWrite(ledPins[i], LOW);
20  }
21  rounds = rounds + 1;                // sayacı bir artır / add one to the counter
22  Serial.print("Tur / Round: ");
23  Serial.println(rounds);
24}

Öffne nach dem Hochladen den seriellen Monitor der Arduino IDE und stelle 9600 Baud ein. Pro Runde siehst du sechs Zeilen, von "i = 0 pin = 2" bis "i = 5 pin = 7", danach eine Zeile "Tur / Round", die 1, 2, 3 hochzählt. Diese Ausgabe ist der deutlichste Beweis, dass der Endwert des Zählblocks mitzählt: "von 0 bis 5" ergibt genau sechs Werte. Achte auch darauf, dass rounds unter den globalen Variablen steht; der Zähler wird nicht bei jedem Start von loop() zurückgesetzt, sondern nimmt seinen Wert von Runde zu Runde mit. Eine Runde dauert 6 × 300 = 1,8 Sekunden, die int-Grenze von 32767 ist also nach etwa 16 Stunden erreicht; willst du länger zählen, mach die Variable zu unsigned long. Mehr zum seriellen Monitor steht in Arduino Serial Monitor.

Schaltung: 6 LEDs, 220-Ω-Widerstände und ein Potentiometer

Ein 220-Ω-Widerstand lässt durch eine rote LED an 5 V etwa (5 − 2) / 220 ≈ 14 mA fließen, ein sicherer Wert für LED und Arduino-Pin. Für LEDs in anderen Farben prüfst du den Widerstand mit dem LED-Vorwiderstandsrechner. Sammle alle Kathoden auf der GND-Schiene des Steckbretts und verbinde sie mit dem GND-Pin des Arduino. Vertauschst du die äußeren Beine des Potentiometers, geht nichts kaputt, nur die Drehrichtung kehrt sich um. LED-Lauflicht und Knight-Rider-Lauflicht nutzen das Potentiometer nicht; es darf trotzdem angeschlossen bleiben, so kannst du alle vier Projekte nacheinander auf derselben Schaltung testen.

Typische Fehler bei Schleifen und Variablen

Schleifen- und Variablenblöcke in der BlueGrays-App ansehen

Die vier Projekte aus diesem Artikel und die folgenden sind in der BlueGrays-App komplett kostenlos, mit Blöcken und Code. Schalte im Code-Bereich eines Projekts Als Blöcke zeigen ein, dann erscheinen statt des Codes die Blöcke desselben Programms; tippst du auf das Bild, öffnet es sich im Vollbild, und du kannst lange Zählschleifen bequem vergrößern. Der Tab Blöcke verstehen geht das Programm Schritt für Schritt durch und zeigt bei jedem Schritt nur dessen Blöcke und was sie tun. Weitere kostenlose Projekte, die sich als Blöcke lohnen: LED-Polizeilicht, das mit einer Variablen delayTime und zwei Zählschleifen arbeitet, Ampel, das in immer wiederholen vier Zustände nacheinander durchläuft, Lichtstärke messen mit LDR, das seinen Messwert in einer Variablen hält und seriell ausgibt, und LED mit Taster ein- und ausschalten, das sich den LED-Zustand in einer Variablen merkt. Jedes Arduino-Beispiel im Code-Guide gibt es ebenfalls als Blöcke, und die Fragen des Tages helfen dir mit 5 Fragen täglich von A1 bis C2, das Gelernte zu festigen. Alle Blockprojekte findest du auf der Seite Blockprogrammierung. Blöcke werden nicht direkt auf das Board geladen; dorthin kommt immer der echte Code des Projekts, du kopierst das Programm, das du über die Blöcke verstanden hast, also in die Arduino IDE und lädst es hoch.

Jetzt, wo du Schleifen und Variablen kennst, holen wir die Zahlen als Nächstes aus der echten Welt: In Teil 5 der Reihe geht es um Sensoren mit Blöcken auslesen, die serielle Schnittstelle und den Umstieg auf MicroPython mit dem Pico. Bis dahin kannst du dir in der BlueGrays-App das LED-Lauflicht, Knight Rider und die Versionen mit einstellbarer Geschwindigkeit mit Schaltplan und Code ansehen, mit Als Blöcke zeigen zur Blockansicht und mit Blöcke verstehen zur Schritt-für-Schritt-Erklärung wechseln und selbst verfolgen, welcher Codezeile jede Zählschleife entspricht.