Arduino Blockprogrammierung: LED blinken lassen, Blöcke und C++

Bei der Arduino Blockprogrammierung ist das erste Programm fast immer dasselbe: eine LED blinken lassen. Genau das machen wir in diesem Beitrag von Anfang bis Ende. Wir schließen eine LED über einen 220-Ω-Widerstand an Pin 9 an, lesen die Blöcke des Projekts LED Blinken in BlueGrays einzeln durch und sehen nebeneinander, zu welcher Zeile im C++-Code jeder Block wird, der auf das Board geladen wird. Außerdem probierst du aus, wie du mit einer einzigen Zahl, der 100 im Block „100 ms warten“, das Blinktempo steuerst.

Bei einer LED bleibt es nicht. Wir bauen dieselbe Logik Schritt für Schritt aus: zu einem Programm, das zwei LEDs abwechselnd blinken lässt, zu einer Ampel und zu einem Polizeilicht. Danach siehst du dieselbe Idee auf dem ESP32 und mit MicroPython auf dem Raspberry Pi Pico. Am Ende steht eine Tabelle mit den Fehlern, die fast jeder Einsteiger einmal macht. Alle Projekte in diesem Beitrag sind in BlueGrays mit Blöcken und Code kostenlos; alle Projekte mit Blöcken findest du nach Plattform sortiert auf der Seite Blockprogrammierung.

Was brauchst du?

Die Schaltung: LED an Pin 9 anschließen

Eine LED hat zwei Beine und die Richtung ist wichtig. Das lange Bein ist die Anode (+), das kurze die Kathode (-); auf der Kathodenseite ist das Kunststoffgehäuse abgeflacht. Strom fließt nur von der Anode zur Kathode, falsch herum eingesteckt passiert also gar nichts. Verbinde Pin 9 des Arduino mit einem Ende des 220-Ω-Widerstands und das andere Ende mit dem langen Bein der LED. Das kurze Bein führst du zu GND. Der Widerstand begrenzt den Strom: Von 5 V ziehst du die rund 2 V der roten LED ab, am Widerstand bleiben 3 V, und 3 V / 220 Ω ergeben etwa 14 mA. Das ist für die LED angenehm und für den Arduino-Pin sicher. Den Wert für deine LED-Farbe prüfst du mit dem LED-Vorwiderstandsrechner. Wie eine LED funktioniert, steht in Was ist eine LED?, wie die Reihen eines Steckbretts innen verbunden sind, in Was ist ein Breadboard?.

Dein erstes Programm in Blöcken: LED Blinken

Steht die Schaltung, schauen wir uns das Programm an. Öffne in BlueGrays das Projekt LED Blinken und schalte im Code-Bereich Als Blöcke zeigen ein, dann siehst du die Blöcke unten. Es sind insgesamt sieben Blöcke in zwei großen Gruppen: oben Setup (läuft einmal), darunter immer wiederholen. Die Blöcke erscheinen in der Sprache der App; auf Deutsch steht dort „HOCH an Pin schreiben“, auf Englisch „write HIGH to pin“.

Die Blöcke in Setup (läuft einmal) laufen nur einmal, wenn das Board startet oder du Reset drückst. Hier gibt es einen einzigen Block: „Pin 9 als AUSGANG setzen“. Die digitalen Pins des Arduino können Ein- oder Ausgang sein. Da wir eine LED ansteuern, sagen wir dem Board: „Über diesen Pin gebe ich Strom aus.“ Die Gruppe immer wiederholen startet nach dem Setup und läuft, solange das Board eingeschaltet ist, immer wieder von oben nach unten durch. Ihre vier Blöcke schalten die LED ein, warten 100 Millisekunden, schalten sie aus und warten wieder 100 Millisekunden. Nach dem letzten Block springt das Programm nach oben und die LED leuchtet erneut. Blinken heißt also nichts anderes, als dass sich diese vier Schritte fünfmal pro Sekunde wiederholen.

Block → C++-Zeile: Was wird aus jedem Block?

1// Led Yakma (proje 1): D9'daki LED 100 ms yanar, 100 ms söner
2// LED Blink (project 1): the LED on D9 is on for 100 ms, off for 100 ms
3void setup() {
4  pinMode(9,OUTPUT);     // LED pini çıkış / LED pin as output
5}
6
7void loop() {
8  digitalWrite(9,HIGH);  // LED'i yak / turn the LED on
9  delay(100);            // 100 ms bekle (1000 ms = 1 s) / wait 100 ms (1000 ms = 1 s)
10  digitalWrite(9,LOW);   // LED'i söndür / turn the LED off
11  delay(100);            // 100 ms bekle / wait 100 ms
12}
13

Legst du Tabelle und Code nebeneinander, siehst du, was dir die Blöcke abnehmen. Die Form der Gruppen Setup und immer wiederholen entspricht den geschweiften Klammern der Funktionen void setup() und void loop(): In welcher Gruppe ein Block steckt, bestimmt, in welchen Klammern seine Zeile steht. An das Semikolon am Ende jeder Anweisung, an Groß- und Kleinschreibung (pinMode, digitalWrite) und an Klammern musst du bei Blöcken nicht denken. Sobald du den Code in der Arduino IDE selbst änderst, werden sie aber wichtig; schon ein vergessenes Semikolon führt zu einem Kompilierfehler. Genau darin liegt der Nutzen der Blöcke: Erst sitzt die Logik des Programms, dann lernst du, wie dieselbe Logik als Code geschrieben wird.

Was passiert, wenn du „100 ms warten“ änderst?

Die Wartezeit wird in Millisekunden (ms) angegeben, 1000 ms sind eine Sekunde. Beide Warteblöcke im Projekt stehen auf 100 ms, also ist die LED 0,1 Sekunden an und 0,1 Sekunden aus. Ein voller Durchlauf dauert 200 ms, die LED blinkt also fünfmal pro Sekunde. Erhöhst du die Zahl in beiden Blöcken, wird die LED langsamer, verringerst du sie, wird sie schneller. Ab einem gewissen Punkt kann das Auge das Blinken nicht mehr auflösen und die LED scheint dauerhaft zu leuchten. Die Tabelle zeigt, was du bei verschiedenen Werten siehst:

Das Programm erweitern: zwei LEDs, Ampel, Polizeilicht

Wenn du eine LED blinken lassen kannst, brauchst du für mehrere LEDs nichts Neues; du wiederholst einfach dieselben drei Blöcke mit anderen Pins. Im Projekt Zwei LEDs abwechselnd blinken werden im Setup zwei Pins zu Ausgängen: 8 und 9. In immer wiederholen folgen „HOCH an Pin 8 schreiben“ und „NIEDRIG an Pin 9 schreiben“, dann „200 ms warten“. Danach wird es umgekehrt geschrieben und wieder 200 ms gewartet. Der Trick: Die beiden Schreibblöcke laufen direkt hintereinander ohne Wartezeit, deshalb scheinen die LEDs im selben Moment zu wechseln. Der Warteblock bestimmt, wie lange ein Zustand dauert.

Das Projekt Ampel überträgt die Idee auf drei LEDs: Rot an D2, Gelb an D3, Grün an D4. Die Gruppe immer wiederholen besteht aus vier Phasen, und jede folgt demselben Muster: für jede der drei LEDs ein Block HOCH oder NIEDRIG schreiben, danach ein Warteblock. Die Schreibblöcke legen fest, welche LED leuchtet, der Warteblock, wie lange. Mehr Blöcke machen es nicht schwerer, nur länger. Eine Version mit Fußgängertaster, die einer echten Kreuzung näherkommt, findest du im Beitrag Arduino Ampel.

1// Trafik Lambası (proje 3) / Traffic Light (project 3)
2void setup() {
3  pinMode(2,OUTPUT);    // Kırmızı / Red
4  pinMode(3,OUTPUT);    // Sarı / Yellow
5  pinMode(4,OUTPUT);    // Yeşil / Green
6}
7
8void loop() {
9  // Kırmızı yanar, 2 s bekle / Red on, wait 2 s
10  digitalWrite(2,HIGH);
11  digitalWrite(3,LOW);
12  digitalWrite(4,LOW);
13  delay(2000);
14  // Sarı yanar, 0,3 s bekle / Yellow on, wait 0.3 s
15  digitalWrite(2,LOW);
16  digitalWrite(3,HIGH);
17  digitalWrite(4,LOW);
18  delay(300);
19  // Yeşil yanar, 2 s bekle / Green on, wait 2 s
20  digitalWrite(2,LOW);
21  digitalWrite(3,LOW);
22  digitalWrite(4,HIGH);
23  delay(2000);
24  // Sarı yanar, sonra başa (kırmızıya) dön / Yellow on, then back to red
25  digitalWrite(2,LOW);
26  digitalWrite(3,HIGH);
27  digitalWrite(4,LOW);
28  delay(300);
29}
30

Im Projekt LED-Polizeilicht begegnen dir zwei neue Blockarten. Die erste ist die Gruppe globale Variablen (ganz oben) mit dem Block „deklariere Ganzzahl (int) delayTime = 60“. Das ist die Zeile int delayTime = 60; im Code, sie gibt der Blinkzeit einen Namen. Weil in den Warteblöcken delayTime statt einer Zahl steht, änderst du das Tempo, indem du nur die 60 änderst statt vier einzelner Blöcke. Die zweite ist der grüne Block „wiederhole 3 -mal“; er führt die vier Blöcke darin dreimal aus und wird in C++ zur Schleife for(int i=0;i<3;i++).

Rechnen wir: Bei jedem Blitz ist die rote LED 60 ms an und 60 ms aus, ein Blitz dauert also 120 ms. Drei Blitze ergeben 360 ms, bei der blauen LED genauso. Ein ganzer Durchlauf dauert etwa 0,7 Sekunden. Setzt du delayTime auf 30, blitzt es doppelt so schnell, bei 120 langsamer. Variablen und Schleifen sind Thema von Teil 4 der Reihe; im Beitrag „immer wiederholen“, Zähl- und Array-Blöcke gehen wir ausführlich darauf ein. Das Projekt LED-Lauflicht, bei dem das Licht eine LED-Reihe entlangläuft, ist der nächste Schritt auf diesem Weg.

Dieselbe Idee auf ESP32 und Raspberry Pi Pico

Auf dem ESP32 sehen die Blöcke fast genauso aus wie beim Arduino, denn auch der ESP32 wird mit der Arduino IDE in C++ programmiert. Im Projekt LED Blinken mit ESP32 hängt die LED an GPIO 5 und die Warteblöcke stehen auf 500 ms. Auch die Codezeilen sind gleich: pinMode(5, OUTPUT); digitalWrite(5, HIGH); delay(500);. Unterschiede gibt es nur bei der Pinnummer, bei den 3,3 V an den ESP32-Pins und bei der Boardauswahl in der Arduino IDE. Alles, was du am Uno lernst, kannst du direkt auf den ESP32 übertragen.

In Projekten für den Raspberry Pi Pico werden die Blöcke zu MicroPython-Code, und die Blocknamen ändern sich etwas. Im Projekt Pico mit externer LED hängt die LED an GP14. Der Block „Pin led : GP LED_PIN, AUSGANG“ entspricht led = Pin(LED_PIN, Pin.OUT), „Pin led einschalten (on)“ entspricht led.on(), „0.5 Sekunden warten“ entspricht time.sleep(0.5) und immer wiederholen der Schleife while True:. Achtung: In MicroPython wird die Wartezeit in Sekunden angegeben, nicht in Millisekunden; aus delay(500) beim Arduino wird time.sleep(0.5). Willst du ganz ohne Verkabelung starten, bringt das Projekt Pico Onboard-LED die LED an GP25 direkt auf dem Board zum Blinken; beim Pico W sprichst du die Onboard-LED statt mit GP25 mit dem Namen „LED“ an.

1# Pico harici LED (proje 8163), seri port satırları çıkarıldı
2# Pico external LED (project 8163), serial print lines removed
3from machine import Pin
4import time
5
6LED_PIN = 14                    # GP14, herhangi bir boş GPIO / any free GPIO
7led = Pin(LED_PIN, Pin.OUT)     # pini çıkış yap / set the pin as output
8
9while True:                     # sürekli tekrarla / loop forever
10    led.on()                    # LED'i yak / turn the LED on
11    time.sleep(0.5)             # 0,5 saniye bekle / wait 0.5 s
12    led.off()                   # LED'i söndür / turn the LED off
13    time.sleep(0.5)
14

Häufige Fehler und ihre Lösung

Schritt für Schritt in der App: von den Blöcken aufs Board

1. Öffne in BlueGrays das Projekt LED Blinken, das in der Projektliste das Block-Abzeichen trägt. Über den Filter kannst du auch nur Projekte mit Blöcken anzeigen.
2. Stecke nach dem Schaltplan die LED, den 220-Ω-Widerstand und zwei Kabel auf das Steckbrett.
3. Schalte im Code-Bereich Als Blöcke zeigen ein. Statt des Codes erscheinen die Blöcke; tippst du auf das Bild, öffnet es sich im Vollbild.
4. Wechsle zum Tab Blöcke verstehen. Das Programm wird Schritt für Schritt erklärt; in jedem Schritt siehst du nur dessen Blöcke und was sie tun.
5. Schalte den Schalter wieder aus, um zum echten Code zurückzukehren, kopiere ihn und füge ihn in die Arduino IDE ein. Blöcke werden nicht direkt aufs Board geladen; dorthin kommt immer dieser Code.
6. Wähle in der Arduino IDE Arduino Uno als Board und den richtigen Port und klicke auf Hochladen. Falls die IDE noch fehlt, hilft dir der Beitrag Arduino IDE installieren Schritt für Schritt.
7. Sobald die LED blinkt, ändere beide Zeilen delay(100) in delay(1000), lade erneut hoch und sieh dir den Unterschied selbst an.

In diesem Beitrag blinkte die LED immer im gleichen Takt; das Programm hat nichts von außen mitbekommen. Der nächste Schritt ist, das Board Entscheidungen treffen zu lassen: Teil 3 der Reihe, Taster und der „wenn“-Block, zeigt ein Programm, das die LED auf Tastendruck einschaltet, und wie aus dem Wenn-sonst-Block if/else wird.

In der BlueGrays-App findest du LED Blinken, Zwei LEDs abwechselnd blinken, Ampel, LED-Polizeilicht und die LED-Projekte für ESP32 und Pico mit Schaltplan und Code, kannst mit Als Blöcke zeigen zur Blockansicht desselben Programms wechseln und mit Blöcke verstehen nachlesen, was jeder Schritt macht.