Was ist MicroPython? Grundbefehle, REPL und erste Programme

MicroPython ist eine kleine, schnelle Neuimplementierung der Sprache Python 3 für Mikrocontroller. Hast du MicroPython auf ein Board wie den Raspberry Pi Pico oder den ESP32 gespielt, führt das Board Python-Code selbst aus: Du tippst einen Befehl ohne Kompilieren ein und siehst die LED sofort leuchten. Wenn du Python in der Schule oder am Computer gelernt hast, kannst du mit derselben Syntax Pins lesen, Motoren ansteuern, Sensordaten erfassen und dich mit dem WLAN verbinden.

In dieser Anleitung lernst du, wie sich MicroPython vom normalen Python unterscheidet, die REPL, mit der du sofort mit dem Board sprichst, und die Module, die du am häufigsten brauchst, also machine.Pin, PWM, ADC und I2C, mit Beispielcode. Danach siehst du den Unterschied zwischen time.sleep und ticks_ms, die Dateien main.py und boot.py, die beim Start laufen, das Hochladen von Dateien mit Thonny und mpremote, das Hinzufügen von Bibliotheken mit mip und das Flashen der Firmware auf Pico und ESP32. Im letzten Abschnitt vergleichen wir MicroPython und Arduino C++ direkt miteinander.

Was ist MicroPython und was unterscheidet es von Python?

MicroPython ist ein Open-Source-Projekt, das Damien George 2013 für ein kleines Board gestartet hat, und unterstützt heute Dutzende Mikrocontroller. Die Firmware, die du auf das Board spielst, enthält den Python-Interpreter, die Grundmodule und ein kleines Dateisystem. Dein Code wird auf dem Board zuerst in Bytecode übersetzt, dann führt der Interpreter diesen Bytecode Schritt für Schritt aus. Da sich das komplette Python deines Computers unmöglich in einige Hundert KB RAM quetschen lässt, bleibt die Sprache gleich, doch die meisten Bibliotheken sind entweder abgespeckt oder fehlen ganz. Dafür ist etwas hinzugekommen, das das Desktop-Python nicht hat: das Modul machine mit direktem Zugriff auf die Hardware.

Boards, auf denen MicroPython läuft

MicroPython-Firmware auf Pico und ESP32 flashen

1. Pico: Halte die Taste BOOTSEL auf dem Board gedrückt, während du das USB-Kabel einsteckst, und lass sie dann los. Am Computer erscheint ein Laufwerk namens RPI-RP2 (beim Pico 2 RP2350).
2. Lade auf der offiziellen Download-Seite von MicroPython die passende .uf2-Datei für dein Board herunter (RPI_PICO für den Pico, RPI_PICO_W für den Pico W) und zieh sie auf dieses Laufwerk.
3. Nach dem Kopieren startet das Board von selbst neu und das Laufwerk verschwindet; MicroPython ist installiert. Wähle in Thonny unter Werkzeuge > Optionen > Interpreter den Eintrag MicroPython (Raspberry Pi Pico).
4. ESP32: Ist Python auf deinem Computer installiert, tippe auf der Kommandozeile pip install esptool. Schließ das Board an und finde seinen Port heraus (z. B. COM3 unter Windows, /dev/ttyUSB0 unter Linux).
5. Lösche zuerst den Flash: esptool.py --chip esp32 --port COM3 erase_flash. Verbindet sich das Board nicht, halte während des Befehls die Taste BOOT gedrückt.
6. Schreib die Firmware: esptool.py --chip esp32 --port COM3 --baud 460800 write_flash -z 0x1000 ESP32_GENERIC-....bin. Beim ESP32-S3 und ESP32-C3 lautet die Adresse 0x0. Die Option Install or update MicroPython (esptool) in Thonny erledigt dasselbe per Fenster.

Die REPL: sofort mit dem Board sprechen

Die REPL (Read-Eval-Print Loop) ist die Kommandozeile, die das Board dir über die serielle Schnittstelle öffnet. Das Zeichen >>> im Shell-Fenster unten in Thonny zeigt, dass die REPL auf dich wartet. Tippst du 1 + 1, rechnet das Board und gibt 2 zurück; tippst du from machine import Pin und danach Pin("LED", Pin.OUT).value(1), leuchtet die LED des Pico im selben Moment. Es gibt keinen schnelleren Weg als die REPL, um einen Sensorwert zu lesen, zu prüfen, ob ein Pin richtig verdrahtet ist, oder herauszufinden, wie eine Bibliothek funktioniert, ganz ohne auf Kompilieren und Hochladen zu warten.

Erstes Programm und sein Gegenstück in Arduino C++

1# İlk program: dahili LED'i yakıp söndür / First program: blink the onboard LED
2from machine import Pin
3import time
4
5led = Pin("LED", Pin.OUT)        # Pico ve Pico W; ESP32'de Pin(2, Pin.OUT) / Pico and Pico W; Pin(2, Pin.OUT) on ESP32
6
7while True:
8    led.value(1)                 # yak / on
9    time.sleep(0.5)              # saniye cinsinden / in seconds
10    led.value(0)                 # söndür / off
11    time.sleep(0.5)

1// Aynı program Arduino C++ ile / The same program in Arduino C++
2void setup() {
3  pinMode(LED_BUILTIN, OUTPUT);
4}
5
6void loop() {
7  digitalWrite(LED_BUILTIN, HIGH);
8  delay(500);                    // milisaniye cinsinden / in milliseconds
9  digitalWrite(LED_BUILTIN, LOW);
10  delay(500);
11}

Beide Programme tun dasselbe, sind aber unterschiedlich aufgebaut. MicroPython kennt kein setup() und kein loop(): Die Datei läuft einmal von oben nach unten, und die Endlosschleife baust du selbst mit while True:. Statt geschweifter Klammern und Semikolons wird eingerückt; alle Zeilen innerhalb der Schleife müssen gleich weit eingerückt sein (meist 4 Leerzeichen). Auch die Wartezeit hat eine andere Einheit: time.sleep(0.5) erwartet Sekunden, delay(500) beim Arduino Millisekunden. In MicroPython nimmst du time.sleep_ms() für Millisekunden und time.sleep_us() für Mikrosekunden. Die Grundlagen der Arduino-Seite stehen in Arduino-Programmierung: Grundlagen.

machine.Pin: digitale Ein- und Ausgänge

time.sleep und ticks_ms: Zeit messen ohne Blockieren

time.sleep() lässt das Board komplett warten; währenddessen wird kein Taster gelesen und kein Sensor abgefragt. Um mehrere Aufgaben gleichzeitig zu erledigen, nutzt du das MicroPython-Gegenstück zum millis()-Prinzip des Arduino: time.ticks_ms() liefert die Millisekunden seit dem Start, time.ticks_diff(neu, alt) berechnet den Abstand zwischen zwei Zeitpunkten. Wichtig ist, die Differenz mit ticks_diff statt mit einfacher Subtraktion zu bilden; der Zähler läuft nach einem bestimmten Wert über, und eine einfache Subtraktion liefert in diesem Moment ein falsches Ergebnis. Der folgende Code lässt die LED ohne Blockieren blinken und überwacht dabei einen Taster per Interrupt (IRQ); jeder Druck ändert die Blinkgeschwindigkeit.

1# delay kullanmadan iki iş: LED yanıp söner, buton kesmeyle modu değiştirir
2# Two jobs without blocking: the LED blinks, a button interrupt switches the mode
3from machine import Pin
4import time
5
6led = Pin(15, Pin.OUT)                       # LED + 220 Ω, GP15
7buton = Pin(14, Pin.IN, Pin.PULL_UP)         # buton GP14 ile GND arasında / button between GP14 and GND
8
9hizli = False
10son_basma = 0
11son_degisim = time.ticks_ms()
12
13def buton_kesme(pin):                        # kesme fonksiyonu kısa olmalı / keep the handler short
14    global hizli, son_basma
15    simdi = time.ticks_ms()
16    if time.ticks_diff(simdi, son_basma) > 200:   # 200 ms debounce / 200 ms debounce
17        son_basma = simdi
18        hizli = not hizli
19
20buton.irq(trigger=Pin.IRQ_FALLING, handler=buton_kesme)   # basınca HIGH'dan LOW'a iner / goes HIGH to LOW when pressed
21
22while True:
23    aralik = 100 if hizli else 500
24    if time.ticks_diff(time.ticks_ms(), son_degisim) >= aralik:   # taşmaya karşı güvenli / safe against wrap-around
25        son_degisim = time.ticks_ms()
26        led.value(not led.value())
27    # burada başka işler yapılabilir / other work can run here

PWM: Helligkeit, Servos und Töne

1# PWM: LED parlaklığı ve servo açısı / PWM: LED brightness and servo angle
2from machine import Pin, PWM
3import time
4
5led = PWM(Pin(15))
6led.freq(1000)                               # 1 kHz: titreme görünmez / no visible flicker
7
8for d in range(0, 65536, 2048):              # duty_u16: 0 (kapalı) ... 65535 (tam) / 0 (off) ... 65535 (full)
9    led.duty_u16(d)
10    time.sleep_ms(20)
11led.duty_u16(0)
12
13servo = PWM(Pin(16))
14servo.freq(50)                               # servolar 50 Hz (20 ms) ister / servos expect 50 Hz (20 ms)
15
16def servo_aci(derece):
17    us = 500 + derece * 2000 // 180          # 0° = 0,5 ms, 180° = 2,5 ms; servona göre ayarla / tune for your servo
18    servo.duty_ns(us * 1000)
19
20for a in (0, 90, 180, 90):
21    servo_aci(a)
22    time.sleep(1)

Das PWM-Objekt schaltet einen Pin sehr schnell ein und aus und stellt so eine mittlere Leistung ein. freq() legt fest, wie oft sich das pro Sekunde wiederholt, und duty_u16(), wie lange der Pin eingeschaltet bleibt, mit einer Zahl zwischen 0 und 65535; 32768 entspricht etwa 50 Prozent. Diese Skala ist viel feiner als der Bereich 0–255 von analogWrite beim Arduino. Servos erwarten ein 50-Hz-Signal und eine Pulsbreite zwischen 0,5 und 2,5 ms; duty_ns() gibt die Pulslänge direkt in Nanosekunden an und macht Servo-Code dadurch viel einfacher. Mit verschiedenen freq()-Werten kann ein passiver Summer auch Noten spielen. Tastgrad und Frequenz erklärt Was ist PWM im Detail.

ADC: analoge Werte lesen

1# ADC: potansiyometre ve Pico'nun dahili sıcaklık sensörü
2# ADC: a potentiometer and the Pico's internal temperature sensor
3from machine import ADC, Pin
4import time
5
6pot = ADC(Pin(26))                           # GP26 = ADC0; ESP32'de ADC(Pin(34)) / ADC(Pin(34)) on ESP32
7yonga = ADC(4)                               # 4. kanal: dahili sıcaklık / channel 4: internal temperature
8
9def ortalama(adc, n=16):                     # gürültüyü azalt / reduce noise
10    toplam = 0
11    for _ in range(n):
12        toplam += adc.read_u16()
13    return toplam // n
14
15while True:
16    ham = ortalama(pot)                      # 0-65535 (12 bit ölçüm 16 bite ölçeklenir) / 12-bit reading scaled to 16 bits
17    volt = ham * 3.3 / 65535
18    v_t = ortalama(yonga) * 3.3 / 65535
19    derece = 27 - (v_t - 0.706) / 0.001721   # RP2040 veri sayfasındaki formül / formula from the RP2040 datasheet
20    print("Pot: {} ({:.2f} V)  Yonga / chip: {:.1f} C".format(ham, volt, derece))
21    time.sleep(1)

read_u16() liefert auf jedem Board einen Wert zwischen 0 und 65535, daher läuft derselbe Code auf Pico und ESP32. Der ADC des Pico arbeitet eigentlich mit 12 Bit, der Messwert wird auf 16 Bit skaliert. Der Pico hat drei frei nutzbare Analogpins: GP26 (ADC0), GP27 (ADC1) und GP28 (ADC2); der vierte Kanal ist der Temperatursensor im Chip und misst die Chiptemperatur, nicht die Raumtemperatur. Beim ESP32 brauchst du adc.atten(ADC.ATTN_11DB), um den vollen Bereich 0–3,3 V zu messen, und die ADC2-Pins sind bei aktivem WLAN nicht nutzbar; nimm daher die ADC1-Pins zwischen GPIO 32 und 39. Der Mittelwert aus 16 Messungen im Code verringert das ADC-Rauschen deutlich. Begriffe wie Auflösung und Referenzspannung behandelt Was ist ein ADC.

I2C: Sensoren und Displays anschließen

1# I2C: hattı tara ve SSD1306 OLED'e yaz / I2C: scan the bus and write to an SSD1306 OLED
2from machine import Pin, I2C
3import ssd1306                               # önce: mpremote mip install ssd1306 / first: mpremote mip install ssd1306
4
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)   # Pico; ESP32'de I2C(0, sda=Pin(21), scl=Pin(22))
6adresler = i2c.scan()
7print("Bulunan / found:", [hex(a) for a in adresler])   # OLED genelde 0x3c / OLED is usually 0x3c
8
9if 0x3C in adresler:
10    oled = ssd1306.SSD1306_I2C(128, 64, i2c)
11    oled.fill(0)
12    oled.text("MicroPython", 0, 0)
13    oled.text("I2C: " + hex(adresler[0]), 0, 16)
14    oled.show()

I2C(0, sda=..., scl=...) startet die Hardware-I2C-Einheit an den gewählten Pins, und scan() gibt eine Liste der Adressen aller Geräte zurück, die am Bus antworten. Funktioniert ein Sensor nicht, ist dieser Scan der erste Schritt: Eine leere Liste bedeutet ein Verdrahtungsproblem, eine unerwartete Adresse korrigierst du im Code. Beim Pico sind die Pins jeder I2C-Einheit festgelegt; für I2C0 funktionieren etwa die Paare GP0-GP1, GP4-GP5 oder GP8-GP9, ein falsches Paar führt zu einem ValueError. Beim ESP32 lässt sich I2C fast jedem Pin zuweisen. Details zum Display stehen in OLED-Display, das Protokoll selbst in Was ist I2C.

main.py und boot.py: Code, der beim Start läuft

Wenn du in Thonny auf Ausführen klickst, läuft der Code nur in diesem Moment, ohne auf dem Board gespeichert zu werden; ziehst du das USB-Kabel, ist er weg. Damit dein Code bei jedem Start von selbst läuft, musst du die Datei als main.py auf dem Board speichern. Beim Start läuft zuerst boot.py, danach main.py. boot.py ist für einmalige Vorbereitungen wie die WLAN-Verbindung oder das Stellen der Uhr gedacht; die ESP32-Firmware legt diese Datei selbst an, auf dem Pico gibt es sie meist nicht. Dein eigentliches Programm steht immer in main.py. Funktionen aus anderen Dateien holst du mit import in main.py, Messwerte speicherst du mit open() im Dateisystem des Boards.

1# main.py: kart her açıldığında otomatik çalışır / runs automatically every time the board starts
2import time
3from machine import Pin
4
5time.sleep(3)                                # Ctrl+C ile durdurmak için güvenlik payı / a safety window for Ctrl+C
6led = Pin("LED", Pin.OUT)
7sayac = 0
8
9try:
10    while True:
11        sayac += 1
12        led.value(sayac % 2)
13        print("Calisiyor / running", sayac)
14        time.sleep(1)
15except KeyboardInterrupt:                    # Thonny'de Stop ya da Ctrl+C / Stop in Thonny or Ctrl+C
16    led.value(0)
17    print("Durduruldu / stopped")

Dateien hochladen: Thonny und mpremote

Für den Einstieg ist Thonny der einfachste Weg: Schreib deinen Code, wähle Datei > Speichern unter, im folgenden Fenster Raspberry Pi Pico bzw. MicroPython device und nenne die Datei main.py. Öffnest du Ansicht > Dateien, siehst du die Dateien auf dem Computer und auf dem Board nebeneinander und kopierst per Rechtsklick hin und her. Wer die Kommandozeile mag und einen Editor wie VS Code nutzt, greift zum offiziellen Werkzeug mpremote; es wird mit pip install mpremote installiert und verbindet sich automatisch mit dem ersten gefundenen MicroPython-Board.

Bibliotheken hinzufügen: mip

In MicroPython gibt es kein pip; stattdessen nutzt du den kleinen Paketmanager mip. Auf einem Board mit Internetzugang wie Pico W oder ESP32 verbindest du dich zuerst mit dem WLAN und tippst dann in der REPL import mip und mip.install("ssd1306"); das Paket wird aus dem offiziellen micropython-lib-Repository geladen und im Ordner /lib des Boards abgelegt. Einen Treiber von GitHub installierst du mit mip.install("github:benutzer/repo"). Beim Pico ohne WLAN erledigst du dasselbe vom Computer aus mit dem Befehl mpremote mip install oder über das Menü Werkzeuge > Pakete verwalten in Thonny. Es reicht auch, einen Treiber aus einer einzigen Datei (z. B. eine .py-Datei für einen Sensor) aufs Board zu kopieren; solange die Datei im Hauptverzeichnis oder in /lib liegt, lädst du sie mit import. Die Schritte zur WLAN-Verbindung stehen in Pico W und WLAN.

MicroPython oder Arduino C++?

In der Praxis entscheidet dein Projekt. Einen Sensor lesen und per WLAN schicken, eine Webseite ausliefern oder ein Display ansteuern geht in MicroPython mit weniger Zeilen und schneller. Signale mit Mikrosekundengenauigkeit erzeugen, Hunderte LEDs sehr schnell aktualisieren oder nur ein kleines Board wie den Uno zur Hand haben, spricht für C++. Eine langsame Funktion beschleunigst du mit dem Dekorator @micropython.native, und Pausen des Garbage Collectors verringerst du, indem du in Schleifen keine neuen Listen und Zeichenketten erzeugst. Zur Wahl des Boards siehe auch Arduino oder ESP32.

Häufige Fehler und Lösungen

MicroPython ist für alle, die Python schon kennen, der kürzeste Weg in die Welt der Mikrocontroller: Du siehst das Ergebnis, sobald du einen Pin in der REPL ausprobierst, und mit wenigen Zeilen liest du einen Sensor und verbindest dich mit dem WLAN. Kennst du die Grundmodule, das Prinzip von main.py und die blockierungsfreie Zeitmessung mit ticks_ms, wachsen deine Projekte schnell. In der BlueGrays-App findest du Raspberry-Pi-Pico-Projekte mit LEDs, Ampel, Tastern und PWM, jeweils mit Schaltplänen und MicroPython-Code Schritt für Schritt.