Arduino Taster LED mit if-else: Bedingungen in Blöcken und C++

Mit Arduino, Taster, LED und if-else lernst du, wie ein Programm abhängig von einer Frage einen von zwei Wegen wählt: „Ist der Taster gedrückt? Dann schalte die LED ein, sonst aus.“ In Arduinos C++ heißt diese Struktur if/else, und der Block „falls … mache … sonst“ in der BlueGrays-Blockprogrammierung ist ihr genaues Gegenstück. In diesem Beitrag lernst du an einem Taster-Projekt, wie du einen Pin als Eingang einstellst und ausliest, danach den falls-Block, Vergleichsoperatoren, verschachtelte Bedingungen und wie du zwei Bedingungen mit „und“ verknüpfst, Block für Block und Zeile für Zeile.

Bisher haben unsere Programme immer dasselbe getan: LED an, warten, LED aus, wieder warten. Auf die Außenwelt haben sie nie gehört. Sobald Bedingungen ins Spiel kommen, entscheidet das Board anhand eines Tasters, eines Lichtsensors oder einer gemessenen Entfernung, und genau da beginnt der eigentliche Spaß beim Programmieren von Robotern. Alle Beispiele hier stammen aus kostenlosen Blockprojekten. Du kannst ihre Blöcke und ihren Code auf der Seite zur Blockprogrammierung oder in der App öffnen und parallel mitlesen.

Eingang und Ausgang: In welche Richtung arbeitet ein Pin?

Die digitalen Pins des Arduino erledigen eine von zwei Aufgaben. Ein Pin als Ausgang gibt 5 V (HIGH) oder 0 V (LOW) aus; so steuerst du eine LED, einen Summer oder ein Relais. Ein Pin als Eingang gibt nichts aus, er lauscht nur auf die Spannung: Beim Arduino Uno liest er alles über etwa 3 V als HIGH und alles unter 1,5 V als LOW. In Blöcken legst du das im Setup fest: Der Block „Pin 13 als EINGANG setzen“ wird in C++ zu pinMode(13, INPUT); und „Pin 7 als AUSGANG setzen“ zu pinMode(7, OUTPUT);. Zum Auslesen dient der Block „Pin 13 lesen“. Er sieht anders aus als die übrigen: Er ist kein Befehl zum Stapeln, sondern ein abgerundeter Wertblock, der in eine Lücke eines anderen Blocks gesteckt wird. Sein C++-Gegenstück ist digitalRead(13), das HIGH oder LOW zurückgibt. Weil HIGH beim Arduino 1 und LOW 0 entspricht, kannst du das Ergebnis auch wie eine Zahl in einer Variablen speichern. Kurz gesagt: Befehlsblöcke tun etwas, Wertblöcke liefern ein Ergebnis, und nur so ein Ergebnis passt in den Bedingungsplatz des falls-Blocks.

Schaltung: Taster an 13, LED an 7, Pull-down-Widerstand ist Pflicht

Im Projekt LED mit Taster schalten (Push) hängt der Taster an D13 und die LED an D7. Ein Beinchen des Tasters geht an 5V, das andere an D13, und zwischen D13 und GND sitzt ein Pull-down-Widerstand mit 10 kΩ. Ist der Taster losgelassen, zieht der Widerstand den Pin auf GND, und er liest LOW. Drückst du, liegen die 5V direkt am Pin, und er liest HIGH. Weil der Widerstand groß ist, fließt beim Drücken nur etwa ein halbes Milliampere von 5V nach GND. Das lange Bein der LED geht über einen 220-Ω-Widerstand an D7, das kurze an GND.

Der falls-Block und if/else: LED leuchtet, solange der Taster gedrückt ist

Die Blockversion des Projekts hat zwei Bereiche. In „Setup (läuft einmal)“ wird Pin 13 als EINGANG und Pin 7 als AUSGANG gesetzt. In „immer wiederholen“ steht ein einziger großer Block: falls … mache … sonst. In seinem sechseckigen Bedingungsplatz steckt der Vergleich „Pin 13 lesen = HOCH“. Ist die Bedingung wahr, läuft der Block „HOCH an Pin 7 schreiben“ im mache-Zweig, sonst der Block „NIEDRIG an Pin 7 schreiben“ im sonst-Zweig.

1void setup() {
2  pinMode(13, INPUT);    // Buton girişi (harici pull-down) / Button input (external pull-down)
3  pinMode(7, OUTPUT);    // LED çıkışı / LED output
4}
5
6void loop() {
7  if (digitalRead(13) == HIGH) {   // Buton basılı mı? / Is the button pressed?
8    digitalWrite(7, HIGH);         // Basılı: LED yanar / Pressed: LED on
9  } else {
10    digitalWrite(7, LOW);          // Bırakıldı: LED söner / Released: LED off
11  }
12}
13

Legst du Code und Blöcke nebeneinander, ist die Zuordnung eindeutig. Das Wort if entspricht „falls“, die Bedingung digitalRead(13) == HIGH in Klammern dem Bedingungsplatz, das erste Paar geschweifter Klammern dem mache-Zweig und else mit seinen Klammern dem sonst-Zweig. Jeder Block, den du in einen Zweig legst, wird im Code zu einer Zeile innerhalb der passenden Klammern. Da loop() zigtausendmal pro Sekunde läuft, liest das Board den Taster ständig neu; sobald du den Finger hebst, ist die Bedingung im nächsten Durchlauf falsch und die LED geht aus. Darum heißt das Projekt „Push“: Die LED leuchtet nur, solange du drückst. Der sonst-Zweig ist optional; ein falls-Block nur mit mache-Zweig wird zu einem if ohne else. Entfernst du hier aber den sonst-Zweig, geht die LED nach dem ersten Einschalten nie wieder aus, weil keine Zeile mehr übrig ist, die sie ausschaltet. Bei jeder Bedingung an beide Zweige zu denken, ist eine gute Gewohnheit.

Vergleichsblöcke: =, ≠, < und >

Ein/Aus mit einem Taster: verschachteltes falls und eine Zustandsvariable

Im Push-Projekt leuchtete die LED nur, solange du den Taster gedrückt hieltest. Soll sie sich wie ein echter Lichtschalter verhalten, „einmal drücken an, nochmal drücken aus“, muss sich das Programm zwei Dinge merken: ob die LED gerade an ist und was der Taster im letzten Durchlauf gelesen hat. Das Projekt LED mit Taster ein- und ausschalten deklariert dafür im Bereich „globale Variablen (ganz oben)“ zwei Ganzzahlen: ledState (0 = aus, 1 = an) und lastButton (der vorherige Wert). Die Schaltung bleibt gleich: Taster an D13 mit externem Pull-down, LED an D7.

1int ledState = 0;     // LED durumu: 0 = sönük, 1 = yanık / LED state: 0 = off, 1 = on
2int lastButton = 0;   // Butonun önceki okuması / Previous button reading
3
4void setup() {
5  pinMode(13, INPUT);   // Buton girişi (harici pull-down) / Button input (external pull-down)
6  pinMode(7, OUTPUT);   // LED çıkışı / LED output
7}
8
9void loop() {
10  int button = digitalRead(13);   // Butonu oku / Read the button
11  if (button != lastButton) {     // Buton durumu değişti / Button state changed
12    if (button == 1) {            // Yalnız basış anında (LOW -> HIGH) / Only at the press (LOW -> HIGH)
13      ledState = !ledState;       // Durumu ters çevir / Flip the state
14      digitalWrite(7, ledState);
15    }
16    delay(50);                    // Sıçramayı atlamak için kısa bekleme / Short wait to skip the bounce
17    lastButton = button;          // Bu okumayı sakla / Store this reading
18  }
19}
20

Das Herz des Programms sind die zwei verschachtelten falls-Blöcke. Die äußere Bedingung button ≠ lastButton ist nur in dem Durchlauf wahr, in dem sich der Tasterzustand ändert; in den tausenden Durchläufen, in denen du den Taster hältst oder gar nicht berührst, passiert nichts. Eine Änderung kann in zwei Richtungen gehen: Drücken (0 auf 1) oder Loslassen (1 auf 0). Die innere Bedingung button = 1 wählt davon nur das Drücken aus. So ändert sich die LED einmal pro Tastendruck und beim Loslassen gar nicht. Im Code erkennst du verschachtelte ifs an Klammern in Klammern. In Blöcken sitzt das innere falls im mache-Zweig des äußeren, sodass du auf einen Blick siehst, welche Zeile von welcher Bedingung abhängt.

Der Block nicht ledState wird in C++ als !ledState geschrieben. Das Ausrufezeichen bildet das logische Gegenteil: Das Gegenteil von 0 ist 1, das Gegenteil jeder Zahl ungleich null ist 0. Weist du ledState sein eigenes Gegenteil zu, kippt der Zustand bei jedem Drücken. Der folgende Block „ledState an Pin 7 schreiben“ ist die Zeile digitalWrite(7, ledState); weil HIGH 1 und LOW 0 entspricht, lässt sich der Wert der Variablen direkt an den Pin schreiben. Zum Schluss bekommt lastButton den Wert dieses Durchlaufs, damit der Vergleich im nächsten Durchlauf stimmt. Vergisst du diese Zuweisung, bleibt lastButton immer 0; solange du drückst, ist die äußere Bedingung in jedem Durchlauf wahr, und die LED blinkt schnell.

Analoge Bedingung: Nachtlicht mit LDR

Bedingungen gibt es nicht nur für HIGH und LOW. Im Projekt Nachtlicht mit LDR wandelt der Block „setze value auf analog lesen A0“ die Spannung an A0, wo der LDR angeschlossen ist, in eine Zahl zwischen 0 und 1023 um; in C++ ist das die Zeile value = analogRead(A0);. Danach prüft der falls-Block value < 50. Liegt der Wert unter 50, gilt es als dunkel und die LED an D13 geht an, sonst aus. Der Aufbau ist derselbe wie beim Push-Projekt; nur der Vergleich im Bedingungsplatz ist ein anderer.

1int value;   // Işık okuması (0-1023) / Light reading (0-1023)
2
3void setup() {
4  pinMode(13, OUTPUT);   // LED çıkışı / LED output
5}
6
7void loop() {
8  value = analogRead(A0);   // Işık seviyesini oku / Read the light level
9
10  // Eşik 50: altı karanlık sayılır, hassasiyeti bu sayıyla ayarla
11  // Threshold 50: anything below counts as dark. Tune the sensitivity with this number
12  if (value < 50) {
13    digitalWrite(13, HIGH);   // Karanlık: LED yanar / Dark: LED on
14  } else {
15    digitalWrite(13, LOW);    // Aydınlık: LED söner / Bright: LED off
16  }
17}
18

Je nach LDR und Widerstand in der Schaltung kann der Schwellwert 50 für dein Zimmer zu niedrig oder zu hoch sein. Um die richtige Zahl zu finden, beobachte zuerst mit dem Projekt Lichtstärke messen mit LDR die Hell- und Dunkelwerte im seriellen Monitor und lege den Schwellwert dazwischen. Pendelt der Wert genau um die Schwelle, kann die LED flackern; zwei getrennte Schwellen für Ein und Aus sind eine schöne Lösung. Wie ein LDR funktioniert, erfährst du im Beitrag LDR-Lichtsensor.

Bedingungen verknüpfen: der und-Block und &&

Manchmal reicht eine Bedingung nicht. Im Projekt HC-SR04 Abstandsmessung (serielle Anzeige) wird die gemessene Entfernung nur dann im seriellen Monitor ausgegeben, wenn sie zwischen 3 cm und 100 cm liegt. In Blöcken werden zwei Vergleiche mit einem und-Block nebeneinander verbunden: „distance > minDistance und distance < maxDistance“. In C++ wird daraus if (distance > minDistance && distance < maxDistance). Der Operator && macht das Ergebnis nur wahr, wenn beide Seiten wahr sind; ist auch nur eine falsch, ist die Bedingung falsch. So landen unsinnige Werte außerhalb des Messbereichs gar nicht erst auf dem Bildschirm. „Oder“ schreibt man in C++ als ||, dann genügt eine wahre Bedingung. Die Wahrheitstabellen von UND, ODER und NICHT kannst du im Werkzeug Logikgatter ausprobieren.

Dieselben Bedingungen auf dem ESP32: interner Pull-up und umgekehrte Logik

Das Projekt ESP32 LED-Steuerung mit Drucktaste (Push) nutzt denselben falls-Block auf einem ESP32, mit zwei Unterschieden. Die LED hängt an GPIO 5, der Taster an GPIO 4, und der Tasterpin bekommt im Pin-Block die Eingangsoption mit Pull-up. In C++ ist das pinMode(BUTTON_PIN, INPUT_PULLUP);: Ein Widerstand im Chip zieht den Pin auf HIGH, ein externer Widerstand ist nicht nötig. Diesmal geht der Taster an GND, also liest der Pin beim Drücken LOW, und die Bedingung lautet „Pin BUTTON_PIN lesen = NIEDRIG“. Das Projekt ESP32 LED Steuerung mit Taster (Toggle) erledigt das Ein- und Ausschalten statt mit 50 ms Warten mit dem Zeitblock für millis() und verknüpft wieder zwei Bedingungen mit einem und-Block. ESP32-Pins arbeiten mit 3,3 V; schließe den Taster nicht an 5 V an.

Häufige Fehler und Lösungen

Blöcke und Code in der App nebeneinander öffnen

Alle Projekte aus diesem Beitrag gehören zu den kostenlosen Blockprojekten in der BlueGrays-App. Schaltest du im Codebereich eines Projekts den Schalter Als Blöcke zeigen ein, erscheint statt des Codes dasselbe Programm als Blöcke; tippst du auf das Bild, öffnet es sich im Vollbild. Der Tab Blöcke verstehen erklärt das Programm Schritt für Schritt: Jeder Schritt zeigt nur seine eigenen Blöcke und was sie tun, so kannst du verschachtelte falls-Blöcke einzeln verfolgen. Auch die if/else- und digitalRead-Beispiele im Code-Guide gibt es als Blöcke. Blöcke werden nicht direkt aufs Board geladen, und eigene Programme aus Blöcken zusammenstellen kannst du vorerst nicht; aufs Board kommt immer der echte C++-Code des Projekts, den du in die Arduino IDE kopierst und hochlädst. Zum Wiederholen stellen dir die Fragen des Tages jeden Tag 5 Fragen auf den Stufen A1 bis C2.

Jetzt, wo du Bedingungen kennst, geht es als Nächstes um Wiederholungen und Zähler: Im Teil Schleifen und Variablen siehst du, wie „immer wiederholen“ mit loop() und der Zählblock mit einer for-Schleife zusammenhängt. Bis dahin kannst du dir in der BlueGrays-App Schaltplan und Code der Projekte LED mit Taster, Nachtlicht mit LDR und der ESP32-Taster ansehen, mit Als Blöcke zeigen zur Blockansicht und mit Blöcke verstehen zur Schritt-für-Schritt-Erklärung wechseln.