Raspberry Pi Pico Blockprogrammierung: Sensoren und MicroPython

Raspberry Pi Pico Blockprogrammierung mit MicroPython fällt leichter, wenn du schon weißt, wie man mit Blöcken einen Sensor liest. Sensoren mit Blöcken lesen heißt, einen Messwert ohne getippten Code zu holen: Der Block „analog lesen A0“ liefert die Helligkeit eines LDR, und der Block „seriell ausgeben“ schickt die Zahl an den Seriellen Monitor auf deinem Computer. In diesem Artikel liest du zuerst am Arduino mit Blöcken Sensoren aus, anhand der Projekte mit LDR und HC-SR04, und vergleichst jeden Block mit seiner Zeile analogRead(), Serial.begin(), Serial.println() oder pulseIn(). Danach machst du auf dem Raspberry Pi Pico den Schritt von der blockbasierten Programmierung zu MicroPython und siehst, was sich ändert, wenn dieselben Blöcke zu Python-Code werden.

Bisher haben alle Programme der Serie etwas nach außen bewirkt: Wir haben LEDs geschaltet, einen Taster abgefragt und mit einer Schleife einen Zähler gebaut. Beim Sensorlesen geht es in die andere Richtung: Das Board misst die Umgebung, und du bekommst die Zahl zu sehen. Deshalb kommt hier die serielle Schnittstelle dazu, denn am einfachsten verstehst du einen Sensor, wenn du seinen Wert auf dem Bildschirm verfolgst. In der zweiten Hälfte entsprechen die Blöcke der Pico-Projekte nicht C++, sondern MicroPython. Alle verwendeten Projekte sind in BlueGrays kostenlos, und der zitierte Code ist genau der Projektcode.

Was Sensorlesen bedeutet: digitale und analoge Eingänge

Ein Taster meldet nur zwei Zustände: gedrückt oder nicht. Du liest ihn mit dem Block zum digitalen Pin-Lesen (digitalRead), das Ergebnis ist 0 oder 1. Bauteile wie ein LDR, ein Potentiometer oder ein Bodenfeuchtesensor liefern dagegen alle Werte dazwischen: Die Spannung am Pin ändert sich stufenlos zwischen 0 und 5 V. Die Schaltung, die diese Spannung in eine Zahl umwandelt, heißt ADC (Analog-Digital-Wandler). Der ADC des Arduino Uno arbeitet mit 10 Bit, teilt die Spannung also in 1024 Stufen und liefert eine Zahl von 0 bis 1023; eine Stufe sind etwa 4,9 mV. ESP32 und Pico haben 12-Bit-ADCs, die mit 3,3 V arbeiten. Dieser Unterschied zwischen den Boards sorgt beim Umstieg von Blöcken auf Code besonders oft für Verwirrung; Details findest du im Artikel ADC und Analog-Digital-Wandlung.

LDR am Arduino mit Blöcken auslesen

Unser erstes Beispiel ist das Projekt Lichtstärke messen mit LDR. Ein LDR ist ein Widerstand, dessen Wert sinkt, je heller es wird; eine Spannung erzeugt er allein nicht. Um ihn zu messen, schalten wir ihn mit einem festen 10-kΩ-Widerstand in Reihe zu einem Spannungsteiler und führen den Mittelpunkt an A0. In der Verdrahtung unten liegt der LDR auf der 5-V-Seite, daher steigen bei mehr Licht die Spannung an A0 und der Messwert; tauschst du LDR und Widerstand, kehrt sich die Richtung um. Die Ausgangsspannung für verschiedene LDR-Werte berechnest du mit dem Spannungsteiler-Rechner, und wie viel Ohm ein LDR im Dunkeln und im Hellen hat, steht im Artikel LDR-Lichtsensor. Die Pico-Spalte der Tabelle nutzen wir später im MicroPython-Beispiel.

Lies die Blöcke von oben nach unten. Der Block „deklariere Ganzzahl (int) value = 0“ unter globale Variablen (ganz oben) ist die Zeile int value; ganz oben im Code. Im Abschnitt Setup (läuft einmal) steht nur ein Block, „Seriell starten mit 9600 Baud“, also Serial.begin(9600);. In immer wiederholen kommt zuerst „setze value auf analog lesen A0“; das ist die Zeile value = analogRead(A0);. Danach folgen zwei Blöcke „seriell ausgeben“. Der erste gibt den Text „Value:“ mit der Option ohne Umbruch aus und wird zu Serial.print(); der zweite gibt value mit neue Zeile aus und wird zu Serial.println(). So erscheint jede Messung als eine Zeile wie „Value: 512“. Der letzte Block „500 ms warten“ ist delay(500);, du bekommst also zwei Messungen pro Sekunde. Um den Messwert in eine Spannung umzurechnen, nimm value × 5,0 / 1023: 512 entspricht etwa 2,5 V. In einem dunklen Raum fällt der Wert auf ein paar Hundert, mit einer Taschenlampe auf dem LDR steigt er über 900; die genauen Zahlen hängen von deinem LDR und dem Raum ab.

1int value;   // Işık değeri / Light reading (0-1023)
2
3void setup() {
4  Serial.begin(9600);   // Seri port 9600 baud / Serial at 9600 baud
5}
6
7void loop() {
8  value = analogRead(A0);   // LDR gerilimini oku / Read the LDR voltage
9  Serial.print("Value: ");
10  Serial.println(value);
11  delay(500);               // 0,5 sn bekle / Wait 0.5 s
12}

Seriellen Monitor öffnen und Werte beobachten

1. Füge den Code in die Arduino IDE ein, wähle Board und Port und klicke auf Hochladen.
2. Wenn das Hochladen fertig ist, klicke oben rechts auf das Lupensymbol oder öffne Werkzeuge > Serieller Monitor (Tastenkürzel Strg+Umschalt+M).
3. Stell die Baudrate im Seriellen Monitor auf den Wert aus dem Code: in diesem Projekt 9600 Baud.
4. Jetzt läuft jede halbe Sekunde eine Zeile „Value: …“ durch. Deck den LDR mit der Hand ab und sieh zu, wie die Zahl sinkt.
5. Wenn du die Änderung als Kurve sehen willst, öffne Werkzeuge > Serieller Plotter; dieselben Daten werden als Zeitverlauf gezeichnet.
6. Zeilenende-Einstellungen und das Senden von Daten aus dem Seriellen Monitor an das Board erklärt der Artikel Arduino Serieller Monitor ausführlich.

Abstand mit dem HC-SR04: µs warten und Impulsdauer

Das zweite Sensorprojekt ist HC-SR04 Abstandsmessung (serielle Anzeige). Hier kommen zwei neue Blöcke dazu. Die drei Blöcke, die mit „HOCH an Pin trigPin schreiben“ beginnen, lassen den Sensor einen Ultraschallimpuls senden: Der Block „10 µs warten“ in der Mitte ist delayMicroseconds(10); und wartet tausendmal kürzer als „… ms warten“. Dann folgt „setze duration auf Dauer des Impulses HOCH an Pin echoPin (µs)“; das ist die Zeile unsigned long duration = pulseIn(echoPin, HIGH); und misst, wie viele Mikrosekunden der Echo-Pin HIGH bleibt. Schall legt in Luft etwa 0,034 cm/µs zurück, und diese Zeit umfasst Hin- und Rückweg. Deshalb berechnet „setze totalPath auf duration × 0.034“ den ganzen Weg und „setze distance auf totalPath ÷ 2“ den einfachen Abstand. Ein Impuls von 1000 µs bedeutet zum Beispiel 34 cm Weg, also 17 cm Abstand; weil distance ein int ist, fallen die Nachkommastellen weg. Zum Schluss wird der Block „falls distance > minDistance und distance < maxDistance“ zu if (distance > minDistance && distance < maxDistance) und gibt nur Messungen zwischen 3 und 100 cm aus. Bekommt der Sensor kein Echo, liefert pulseIn() 0, und diese Prüfung hält auch solche falschen Nullen vom Bildschirm fern. Im Code sind die Pins trigPin = 7 und echoPin = 6. Messbereich und Genauigkeit des Sensors findest du im Artikel HC-SR04 Ultraschallsensor.

Dieselbe Idee am ESP32: ein 12-Bit-ADC

Die ESP32-Version derselben LDR-Logik ist das Projekt Messung der Lichtintensität mit dem ESP32-LDR-Modul. Die Blöcke entsprechen wieder C++ und lesen sich wie beim Arduino, mit drei Unterschieden. Erstens legt setup() den ADC mit analogReadResolution(12) auf 12 Bit fest, daher liefert analogRead() 0–4095 statt 0–1023, und eine für den Arduino geschriebene Schwelle wie „unter 500 ist dunkel“ bedeutet am ESP32 etwas anderes. Zweitens läuft die serielle Schnittstelle mit 115200 Baud statt 9600, stell also auch den Seriellen Monitor auf 115200. Drittens sinken am AO-Ausgang des LDR-Moduls Spannung und Rohwert, je heller es wird. Deshalb nutzt der Code die Kalibrierwerte RAW_DARK = 4000 und RAW_LIGHT = 100, hält den Messwert mit constrain() in diesem Bereich und macht daraus mit map() 0 % für dunkel und 100 % für hell. Auf einem klassischen ESP32 DevKit kommt der LDR an GPIO 34, einen reinen Eingangspin an ADC1. Weil ADC2-Pins bei eingeschaltetem WLAN nicht lesbar sind, solltest du analoge Sensoren grundsätzlich an ADC1-Pins anschließen. Die allgemeinen Eigenschaften des Boards beschreibt der Artikel Was ist der ESP32.

Vom Block zu MicroPython auf dem Raspberry Pi Pico

In den Pico-Projekten entsprechen die Blöcke nicht C++, sondern MicroPython. Die Blöcke sehen vertraut aus, aber die Sprache darunter ist anders: keine geschweiften Klammern und keine Semikolons, Codeblöcke werden durch Einrückung gebildet, und es gibt keine Funktionen setup() und loop(). Machen wir den Umstieg mit dem einfachsten Projekt, Raspberry Pi Pico: Externe LED zum Leuchten bringen (GP14 + Steckbrett). Die Schaltung ist winzig: GP14 (physischer Pin 19) geht über einen 220–330-Ω-Widerstand an das lange Beinchen der LED, das kurze Beinchen an GND (zum Beispiel physischer Pin 18). Das Programm schaltet die LED eine halbe Sekunde ein und eine halbe Sekunde aus und schreibt bei jedem Schritt eine Zeile in die Shell von Thonny. Wenn der Pico neu für dich ist, beginne mit dem Artikel Was ist der Raspberry Pi Pico.

1from machine import Pin
2import time
3
4# ============ PIN / PIN ============
5LED_PIN = 14                    # Boştaki herhangi bir GPIO / Any free GPIO
6led = Pin(LED_PIN, Pin.OUT)
7
8print("== BlueGrays: Pico Harici LED Blink ==")
9print("LED pin: GP" + str(LED_PIN))
10print("500ms yakip 500ms sonduruyor / 500ms on 500ms off")
11
12# ============ ANA DÖNGÜ / MAIN LOOP ============
13while True:
14    led.on()                    # LED'i yak / Turn the LED on
15    print("[LED] ACIK / ON")
16    time.sleep(0.5)
17
18    led.off()                   # LED'i söndür / Turn the LED off
19    print("[LED] KAPALI / OFF")
20    time.sleep(0.5)

In der Tabelle fallen vier Dinge auf. Erstens haben die Zeilen from machine import Pin und import time keinen Block; in Python importierst du die benötigten Module ganz oben, und die Blöcke setzen das für dich voraus. Zweitens gibt es für den Arduino-Block „Seriell starten mit 9600 Baud“ hier kein Gegenstück: Beim Pico geht die Ausgabe von print() direkt über USB in die Shell von Thonny, eine Baudrate musst du nicht einstellen. Drittens hat sich die Einheit beim Warten geändert: Am Arduino ist „500 ms warten“ delay(500), am Pico ist „0.5 Sekunden warten“ time.sleep(0.5). Viertens, und am wichtigsten, die Einrückung: Jeder Block, der in „immer wiederholen“ steckt, steht im Code vier Leerzeichen eingerückt unter der Zeile while True:. Löschst du die Einrückung einer Zeile, fällt sie aus der Schleife heraus; in Python übernehmen Leerzeichen die Aufgabe der geschweiften Klammern aus C++. Die weiteren Grundregeln findest du im Artikel MicroPython-Grundlagen.

Dieselben Befehle in drei Sprachen: Blöcke, C++ und MicroPython

Eigenes Beispiel: LDR am Pico mit MicroPython auslesen

Jetzt übertragen wir das LDR-Projekt vom Arduino auf den Pico. Die Verdrahtung folgt der Pico-Spalte der Tabelle oben: ein LDR-Beinchen an 3V3(OUT), das andere an GP26 und zugleich an ein Ende des 10-kΩ-Widerstands, dessen anderes Ende an GND. Der Pico hat drei analogfähige Pins: GP26 (ADC0), GP27 (ADC1) und GP28 (ADC2). In MicroPython erzeugst du ein Objekt ADC(26) und rufst read_u16() auf; obwohl der ADC des Pico in Hardware 12 Bit hat, skaliert diese Funktion das Ergebnis auf 0–65535. Für die Spannung multiplizierst du den Wert mit 3,3 und teilst durch 65535. Das Programm folgt demselben Ablauf wie die Arduino-Version: messen, ausgeben, eine halbe Sekunde warten. Zusätzlich gibt es eine Schwelle: Wird es dunkel, geht die eingebaute LED an. In Blöcken gedacht sind die Zeilen vor while True der Abschnitt „Setup (läuft einmal)“, while True: ist „immer wiederholen“, if/else ist der Falls-Block aus Teil 3 der Serie, led.on() ist „Pin led einschalten (on)“, time.sleep(0.5) ist „0.5 Sekunden warten“, und das + str() in print() ist der Block „erstelle Text aus“. Die Zeile ADC(26).read_u16() übernimmt die Aufgabe des Arduino-Blocks „analog lesen A0“. Passe THRESHOLD an die Zahlen an, die du in deinem Raum in der Shell siehst.

1from machine import Pin, ADC
2import time
3
4# ============ PIN / PIN ============
5ldr = ADC(26)                   # GP26 = ADC0, bölücünün orta noktası / divider midpoint
6led = Pin(25, Pin.OUT)          # Dahili LED; Pico W'de Pin("LED") / Onboard LED; Pico W: Pin("LED")
7THRESHOLD = 20000               # Karanlık eşiği, odana göre ayarla / Darkness threshold, tune for your room
8
9print("== BlueGrays: Pico LDR ==")
10
11# ============ ANA DÖNGÜ / MAIN LOOP ============
12while True:
13    value = ldr.read_u16()                      # 0-65535
14    voltage = value * 3.3 / 65535               # Volt / Volts
15    print("Value: " + str(value) + "  Voltage: " + str(round(voltage, 2)) + " V")
16
17    if value < THRESHOLD:                       # Az ışık = küçük değer / Little light = small value
18        led.on()
19    else:
20        led.off()
21
22    time.sleep(0.5)                             # 0,5 sn = 500 ms / 0.5 s = 500 ms

Mit Thonny auf den Pico hochladen: main.py

1. Installiere Thonny auf deinem Computer. Hat der Pico noch kein MicroPython, halte beim Einstecken des USB-Kabels die Taste BOOTSEL gedrückt; Thonny bietet bei der ersten Verbindung an, MicroPython zu installieren.
2. Wähle unten rechts in Thonny als Interpreter MicroPython (Raspberry Pi Pico). Siehst du unten in der Shell die Eingabeaufforderung >>>, steht die Verbindung.
3. Kopiere den Projektcode aus BlueGrays und füge ihn in den Editor von Thonny ein.
4. Klicke auf den grünen Ausführen-Knopf oder drücke F5. Der Code läuft auf dem Pico, die Ausgaben von print() erscheinen in der Shell. Mit dem Stopp-Knopf (Strg+F2) hältst du ihn an.
5. Soll der Code ohne Computer laufen, wähle Datei > Speichern unter, entscheide dich im Dialog für Raspberry Pi Pico und nenne die Datei main.py. Der Pico startet diese Datei bei jedem Einschalten automatisch, ein USB-Netzteil oder eine Powerbank genügt.
6. Erkennt Thonny das Board nicht, prüfe Kabel und Treiber in der Reihenfolge aus dem Artikel Raspberry Pi Pico wird nicht erkannt.

Weitere kostenlose Pico-Blockprojekte

• Raspberry Pi Pico Onboard-LED blinken (GP25): ganz ohne Verkabelung; die LED auf dem Board blinkt mit LED_PIN = 25. Der Code ist fast identisch mit dem Projekt oben; öffne beide nebeneinander, und du siehst, dass sich nur die Pinnummer ändert. Beim Pico W hängt die Onboard-LED am WLAN-Chip, dort verwendest du Pin("LED").
• Raspberry Pi Pico Zwei LEDs abwechselnd blinken (GP14 + GP13): startet mit led1.value(1) und led2.value(0) in entgegengesetzten Zuständen und ruft in der Schleife für beide LEDs toggle() auf. Weil der Code from time import sleep schreibt, steht das Warten als sleep(0.5) statt time.sleep(0.5) da.
• Raspberry Pi Pico Ampel-Simulator (GP11/GP12/GP13): Eine Funktion all_off() schaltet alle LEDs aus; Grün leuchtet 4, Gelb 1,5 und Rot 3 Sekunden, danach folgt eine Rot-Gelb-Phase von 1 Sekunde.
• Raspberry Pi Pico Polizeilicht-Effekt (GP11 + GP12): Hier wird mit sleep_ms(WAIT_MS) in Millisekunden gewartet, WAIT_MS = 300. Sekunden- und Millisekunden-Funktion in zwei Projekten nebeneinander zu sehen, ist der beste Schutz vor dem häufigsten Fehler unten.

Häufige Fehler und ihre Lösung

Mit Blöcken in der BlueGrays-App weitermachen

Alle Projekte aus diesem Artikel sind in der BlueGrays-App kostenlos. Schaltest du im Code-Bereich eines Projekts 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 führt Schritt für Schritt durch das Programm und zeigt bei jedem Schritt nur dessen Blöcke und was sie tun. Dort siehst du genau, was der Impulsdauer-Block im HC-SR04-Projekt misst oder warum der Setup-Teil eines Pico-Projekts vor while True steht. Auch alle Arduino- und MicroPython-Befehlsbeispiele im Code-Guide gibt es als Blöcke. Zum Üben bieten die Fragen des Tages täglich 5 Fragen von A1 bis C2, eine Wochenrangliste und Abzeichen. Denk daran: Blöcke werden nie direkt auf das Board geladen, das Board bekommt immer den echten Projektcode, den du bei Arduino und ESP32 in die Arduino IDE und beim Pico in Thonny kopierst. In der Projektliste kannst du nach dem Block-Abzeichen filtern, und alle Blockprojekte für Arduino, ESP32 und Pico findest du auf der Seite Blockprogrammierung.

Mit serieller Schnittstelle und Sensorlesen kannst du jetzt alle Grundbausteine eines Projekts als Blöcke und als Code lesen. Im letzten Teil der Serie bringen wir diese Schritte ins Klassenzimmer: ein Unterrichtsplan für Robotik mit Blockprogrammierung für Lehrkräfte. Bis dahin kannst du in der BlueGrays-App die Schaltpläne und den Code der Projekte mit LDR, HC-SR04 und Pico-LED Schritt für Schritt durchgehen, mit Als Blöcke zeigen zur Blockversion desselben Programms wechseln und mit Blöcke verstehen verfolgen, was jeder Schritt macht.