Von Blockprogrammierung zu Arduino C++: Tabelle mit MicroPython

Der schnellste Weg von Blockprogrammierung zu Arduino C++ ist eine einseitige Tabelle neben dir, die zeigt, zu welcher echten Codezeile jeder Block wird. Die kurze Antwort: Blöcke sind keine neue Sprache, sondern die grafische Form von Arduino-C++-Zeilen. Der Block „Pin 13 als AUSGANG setzen“ ist die Zeile pinMode(13, OUTPUT);, der Block „1000 ms warten“ ist delay(1000); und der Block „falls … mache“ ist eine if-Anweisung. Die Tabelle unten stellt die echten Beschriftungen der Blöcke in der BlueGrays-App neben ihren Arduino-C++-Code und ihren MicroPython-Code für den Raspberry Pi Pico.

Diese Seite ist keine Unterrichtsstunde, sondern ein Nachschlageblatt. Du kannst die Tabelle ausdrucken, neben den Arbeitsplatz legen und beim Blick auf ein Projekt prüfen, welche Zeile zu welchem Block gehört. Nach der Tabelle findest du die häufigsten Fehler beim Umstieg, eine Methode in vier Schritten, mit der du die Blöcke hinter dir lässt, und dasselbe Programm als Blöcke, C++ und MicroPython. Das Beispiel lässt sich in der Arduino IDE kompilieren und läuft mit Thonny auf dem Pico.

Bevor du die Tabelle liest: vier Unterschiede zwischen den drei

Blöcke, C++ und MicroPython drücken dieselbe Idee aus, aber die Schreibregeln unterscheiden sich. An diesen vier Unterschieden stolperst du am häufigsten. Der erste ist der Aufbau: Ein Arduino-C++-Programm besteht aus zwei Teilen namens setup() und loop(), die in den Blöcken als „Setup (läuft einmal)“ und „immer wiederholen“ erscheinen. MicroPython hat kein eigenes Setup; die Datei läuft einmal von oben nach unten, und der sich wiederholende Teil steht in einer while True:-Schleife. Der zweite sind Datentypen: In C++ hat jede Variable einen geschriebenen Typ (int, float, bool), in den Blöcken ist das die Option „deklariere Ganzzahl (int)“, in Python wird gar kein Typ geschrieben.

Der dritte Unterschied sind Zahlenbereiche. Am Arduino Uno liefert ein Analogwert 0–1023 und PWM 0–255; beim ESP32 reicht der Analogwert bis 0–4095; auf dem Pico liefert MicroPython Messwerte und PWM-Tastgrad im Bereich 0–65535. Deshalb kannst du einen Schwellwert nicht einfach von einem Board aufs andere übernehmen. Der vierte Unterschied ist die Zeiteinheit: delay() erwartet Millisekunden, time.sleep() Sekunden. Eine halbe Sekunde ist in C++ delay(500) und in MicroPython time.sleep(0.5). Wenn du diese vier Regeln im Kopf behältst, ordnen sich die meisten Tabellenzeilen von selbst.

• Die Zahlen in der Tabelle sind Beispiele: Wo im Block 13 steht, kann in deinem Projekt 7 stehen, und die Zahl in der Codezeile ändert sich mit.
• Die Pins in der MicroPython-Spalte sind GP-Nummern des Pico (GP14, GP15, GP26). Sie müssen nicht mit den Pin-Nummern des Uno übereinstimmen; schau in den Schaltplan.
• Zeilen mit „Kein Pico-Block“ bedeuten, dass dieser Block in Pico-Projekten nicht vorkommt; MicroPython-Code für dieselbe Aufgabe steht trotzdem da.
• Auch der ESP32 wird in Arduino C++ programmiert; die C++-Spalte gilt auch für ihn, nur der Analogbereich und manche Pin-Nummern sind anders.

Tabelle: Block, Arduino C++ und MicroPython

Die Tabelle ist in 12 Gruppen geteilt: Programmaufbau, Pins, Zeit, Bedingung, Schleife, Variablen, Mathematik, serielle Schnittstelle, Analog und PWM, Ton, Servo und Sensor. Der Text in der Block-Spalte ist die Beschriftung, die in der App auf den Blöcken steht; „…“ und „?“ markieren den Steckplatz, in den ein anderer Block kommt. Stehen mehrere Blöcke in einer Zeile, trennt sie ein Punkt.

Manche Zeilen wirken auf den ersten Blick eins zu eins, brauchen aber Aufmerksamkeit. Bei „zähle i von 0 bis 5“ ist die 5 eingeschlossen, die Schleife läuft 6-mal; deshalb steht in C++ <= statt <, und Python braucht range(0, 6), weil range die Endzahl auslässt. Auch der Divisionsblock ist eine Falle: Teilst du zwei Ganzzahlen, wirft C++ den Rest weg und 7 / 2 ergibt 3, Python liefert 3.5. Für eine Ganzzahldivision wie in C++ nutzt du in Python //. Die Funktion map() hinter dem Block „x umrechnen“ ist in MicroPython nicht eingebaut; im Beispiel unten erledigt eine zweizeilige Funktion arduino_map() dieselbe Rechnung.

Wie werden verschachtelte Blöcke zu Code?

Einzelne Blöcke zu kennen reicht nicht; die eigentliche Fähigkeit ist, verschachtelte Blöcke in eine Zeile zu übersetzen. Dafür unterscheidest du zwei Formen. Untereinander gestapelte Blöcke mit einer Nase am Rand sind Befehle, und jeder wird zu einer Codezeile. Ovale oder spitze Blöcke, die in den Steckplatz eines anderen Blocks gesteckt werden, sind Werte; im Code stehen sie in Klammern, rechts von einem Gleichheitszeichen oder in einer Bedingung. Die Zeilen unten stammen aus dem kostenlosen Projekt Frequenzeinstellung mit Buzzer: Vier Taster schalten den Ton ein und aus und erhöhen oder senken die Frequenz, die zwischen 50 und 5000 Hz bleibt.

Gewöhne dir beim Lesen dieser Tabelle eines an: Übersetze zuerst den innersten Block und arbeite dich dann nach außen. In „setze frequency auf (begrenze frequency zwischen 50 und 5000)“ ist der innerste Teil constrain(frequency, 50, 5000), und der äußere Setzen-Block macht daraus frequency = …. Ein Wertblock kann nicht allein eine Zeile sein; lässt du ihn mit einem Semikolon stehen, meckert der Compiler vielleicht nicht, aber das Ergebnis wird nirgends gespeichert.

Typische Fehler beim Umstieg von Blöcken auf Code

Der Block-Editor lässt die meisten dieser Fehler gar nicht zu; die Form der Teile verhindert, dass sie an der falschen Stelle einrasten. Im Code fällt dieser Schutz weg, darum begegnen fast allen in den ersten Wochen die folgenden Fehler. Die Fehlermeldungen kommen auf Englisch, aber es gibt nur wenige Muster, und nach ein paar Mal erkennst du sie wieder.

Die Blöcke hinter dir lassen: Methode in 4 Schritten

Den Umstieg in einem Zug zu schaffen, ist anstrengend. Die vier Schritte unten führen in kleinen Etappen vom Lesen zum Schreiben. Ein oder zwei Projekte pro Schritt reichen; bereit für den nächsten Schritt bist du, wenn du den aktuellen ohne Blick auf die Tabelle schaffst.

1. Nebeneinander lesen. Öffne Blöcke und Code eines Projekts gleichzeitig und ordne mit dem Finger jedem Block seine Codezeile zu. Die Tabelle liegt in diesem Schritt immer neben dir. Ziel: jede Codezeile einem Block zuordnen können.
2. Blöcke ausblenden, raten. Sieh dir zuerst die Blöcke an, schalte dann die Blockansicht aus und schreib den C++-Code dieser Blöcke auf Papier, ohne in den Code zu schauen. Vergleiche danach mit dem echten Code. Probier es auch andersherum: Code lesen, Blöcke erraten.
3. Einen Wert im Code ändern. Hol dir den Code auf den Computer und ändere nur eine Zahl: die Wartezeit von 100 auf 500 oder den Schwellwert von 400 auf 600. Hochladen und den Unterschied mit eigenen Augen sehen. Kommt ein Kompilierfehler, geh zurück zur Fehlertabelle oben.
4. Eine neue Zeile schreiben. Füge eine Zeile hinzu, die es in den Blöcken nicht gibt: ein Serial.println(), das den Wert im seriellen Monitor ausgibt, eine zweite LED oder ein if mit einem Taster. Jetzt übersetzt du keine Blöcke mehr, du schreibst Code direkt.

Zu jedem Schritt gibt es eine passende Lektion in der Reihe. Für den ersten Schritt ist die Block-Zeilen-Tabelle im Beitrag eine LED mit Blöcken blinken lassen ein guter Start. Für Bedingungen und Schleifen in Schritt zwei und drei lies der Falls-Block und Schleifen und Variablen. Wenn du mit dem Pico zu MicroPython wechselst, erklärt von Blöcken zu MicroPython auch die Einrichtung von Thonny. Willst du den Umstieg im Unterricht über mehrere Wochen verteilen, bietet der 8-Wochen-Plan für Robotik eine fertige Reihenfolge.

Blöcke und Code in der BlueGrays-App nebeneinander öffnen

Am meisten nutzt du diese Tabelle, wenn du zwischen den Blöcken und dem Code eines echten Projekts hin und her wechselst. Die BlueGrays-App hat für über 100 Projekte eine Blockansicht; in mehr als 30 kostenlosen Projekten sind die Blöcke ebenfalls frei, in Premium-Projekten öffnen sich die Blöcke mit Premium. Blöcke sind zum Lesen da: In der App werden Blöcke nicht bearbeitet und nicht auf das Board hochgeladen. Auf das Board kommt immer der echte Code; du holst ihn mit Kopieren oder mit Link kopieren, um ihn am Computer zu öffnen, und fügst ihn in die Arduino IDE oder für den Pico in Thonny ein.

• Als Blöcke zeigen: Schalte diesen Schalter neben dem Quellcode auf einer Projektseite ein, und dasselbe Programm erscheint als Blockbild in der Sprache der App. Tippst du auf das Bild, öffnet es sich im Vollbild; durch Aus- und Einschalten übst du genau die Schritte eins und zwei.
• Blöcke verstehen: Bei eingeschalteter Blockansicht heißt der Tab „Code verstehen“ so. Das Programm wird in Schritte zerlegt, jeder mit dem passenden Teil und einer Erklärung. Die Aufgabe „Probier es selbst“ am Ende ist eine fertige Übung für Schritt vier.
• Code-Guide: Jede der 36 Karten im Bereich Lernen (18 Arduino C++, 18 MicroPython) zeigt ihr Beispiel dreifach mit den Tabs Blöcke, Arduino und MicroPython. Willst du eine Tabellenzeile genauer sehen, öffne die passende Karte.
• Projekte mit Blöcken: Diese Option unter Filtern in Entdecken > Projekte listet nur Projekte mit Blockansicht auf und erleichtert dir die Wahl eines Projekts für den Umstieg.

Wie der Code-Guide funktioniert, erklären wir im Beitrag zum Code-Guide, die Bereiche „Code verstehen“ und „Probier es selbst“ im Leitfaden zu Code verstehen. Für die einzelnen Befehle mit Erklärung passt die Arduino-Befehlsliste gut zu dieser Tabelle.

Ein Programm in drei Formen: Nachtlicht, das mit dem Licht dimmt

Um die Tabelle in Aktion zu sehen, bauen wir ein kleines Programm. Ein LDR misst das Licht; ist der Raum hell, bleibt die LED aus, wird es dunkler, leuchtet die LED langsam heller. Das Programm nutzt Variablen-, Analog-, Bedingungs-, Umrechnen-, PWM-, Seriell- und Warten-Blöcke, also mehr als die Hälfte der Tabelle in einem Beispiel. Die Idee basiert auf dem kostenlosen Projekt Nachtlicht mit LDR; dort ist die LED nur an oder aus, hier wird sie per PWM gedimmt. Für die Verdrahtung des LDR kannst du dir auch den Schaltplan des Projekts Lichtstärke messen mit LDR ansehen.

Zuerst die Blockfassung. Mit den Beschriftungen aus der App besteht das Programm aus diesen Blöcken; jeder Punkt entspricht einer oder mehreren Zeilen des folgenden C++-Codes:

1. globale Variablen (ganz oben): deklariere Ganzzahl (int) lightValue = 0 und deklariere Ganzzahl (int) brightness = 0
2. Setup (läuft einmal): Seriell starten mit 9600 Baud, danach Pin 9 als AUSGANG setzen
3. immer wiederholen: setze lightValue auf (analog lesen A0)
4. falls (lightValue < 400) mache: setze brightness auf (lightValue umrechnen: 0 – 400 → 255 – 0); sonst: setze brightness auf 0
5. PWM brightness an Pin 9 schreiben
6. seriell ausgeben „Light: “ ohne Umbruch, seriell ausgeben lightValue ohne Umbruch, seriell ausgeben „ PWM: “ ohne Umbruch, seriell ausgeben brightness neue Zeile
7. 200 ms warten

1// ─────────────────────────────────────────
2//   BlueGrays · bluegrays.com
3//   Işığa göre kısılan gece lambası / Dimming night light
4// ─────────────────────────────────────────
5
6int lightValue = 0;   // LDR okuması / LDR reading (0-1023)
7int brightness = 0;   // LED parlaklığı / LED brightness (0-255)
8
9void setup() {
10  Serial.begin(9600);   // Seri port 9600 baud / Serial at 9600 baud
11  pinMode(9, OUTPUT);   // LED, PWM pini D9 / LED on PWM pin D9
12}
13
14void loop() {
15  lightValue = analogRead(A0);   // Az ışık = küçük değer / Little light = small value
16
17  if (lightValue < 400) {
18    // Karanlık arttıkça LED parlar / The darker it gets, the brighter the LED
19    brightness = map(lightValue, 0, 400, 255, 0);
20  } else {
21    brightness = 0;   // Oda aydınlık, LED kapalı / Room is bright, LED off
22  }
23
24  analogWrite(9, brightness);   // PWM 0-255 / PWM 0-255
25
26  Serial.print("Light: ");
27  Serial.print(lightValue);
28  Serial.print("  PWM: ");
29  Serial.println(brightness);
30
31  delay(200);   // 0,2 sn bekle / Wait 0.2 s
32}
33

1# ─────────────────────────────────────────
2#   BlueGrays · bluegrays.com
3#   Işığa göre kısılan gece lambası / Dimming night light
4# ─────────────────────────────────────────
5from machine import Pin, ADC, PWM
6import time
7
8ldr = ADC(26)                # GP26 = ADC0 / GP26 = ADC0
9led = PWM(Pin(15))           # LED, GP15 / LED on GP15
10led.freq(1000)               # PWM frekansı 1000 Hz / PWM frequency 1000 Hz
11
12THRESHOLD = 25600            # Uno'daki 400'ün karşılığı / Same as 400 on the Uno
13
14
15def arduino_map(x, in_min, in_max, out_min, out_max):
16    # Arduino map() ile aynı hesap / Same math as Arduino map()
17    return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
18
19
20while True:
21    light_value = ldr.read_u16()          # 0-65535 / 0-65535
22
23    if light_value < THRESHOLD:
24        # Karanlık arttıkça LED parlar / The darker it gets, the brighter the LED
25        brightness = arduino_map(light_value, 0, THRESHOLD, 65535, 0)
26    else:
27        brightness = 0                    # Oda aydınlık, LED kapalı / Room is bright, LED off
28
29    led.duty_u16(brightness)              # PWM 0-65535 / PWM 0-65535
30
31    print("Light:", light_value, " PWM:", brightness)
32
33    time.sleep(0.2)                       # 0,2 sn bekle / Wait 0.2 s
34

Vergleichst du beide Programme Zeile für Zeile, zeigen sich alle Unterschiede aus der Tabelle. setup() aus C++ wird in Python zu den Zeilen vor while True, und Serial.begin() fällt weg. Aus analogRead(A0) wird ADC(26).read_u16(), der Bereich wächst von 0–1023 auf 0–65535, deshalb liegt der Schwellwert bei 25600 statt 400. Statt analogWrite(9, …) wird zuerst ein PWM-Objekt angelegt und die Helligkeit mit duty_u16() zwischen 0 und 65535 gesetzt. Weil map() fehlt, wird eine Funktion arduino_map() geschrieben; die Ganzzahldivision // darin entspricht der Ganzzahldivision in C++. Ein print() ersetzt vier einzelne Serial.print(), und delay(200) wird zu time.sleep(0.2).

Der Umstieg von Blockprogrammierung auf Arduino C++ heißt weniger, etwas Neues auswendig zu lernen, als die geschriebene Form der Blöcke wiederzuerkennen, die du schon kennst. Behalte diese Tabelle neben dir, lies bei jedem Projekt zuerst nebeneinander, dann blende die Blöcke aus und schreib selbst. Wenn du die Zeilen in echten Projekten sehen willst, öffne in der BlueGrays-App ein Projekt mit Blockansicht und wechsle mit Als Blöcke zeigen zwischen den beiden Formen desselben Programms.