Wenn du einen ESP8266 oder ESP32 in die Hand nimmst, landest du fast automatisch bei der Arduino IDE und C++. Es geht aber auch anders: Mit MicroPython programmierst du deinen Microcontroller in Python – und musst dafür nicht mehr bei jeder kleinen Änderung einen kompletten Sketch kompilieren und hochladen. Du tippst einen Befehl in die Shell, drückst Enter, und die LED leuchtet.
In diesem Tutorial erfährst du, was MicroPython ist, welche Vor- und Nachteile es hat und wie du es auf deinem ESP8266 oder ESP32 installierst. Außerdem klären wir die beiden Fragen, an denen die meisten hängenbleiben: Welche Firmware brauche ich eigentlich für mein Board? Und: Wie bringe ich meinen Code dazu, auch ohne angeschlossenen Computer zu laufen?
Was ist MicroPython?
MicroPython ist angelehnt an und kompatibel zu Python 3 und speziell für die Programmierung von Microcontrollern ausgelegt. Die Sprache ist dem regulären Python sehr ähnlich – das heißt, wenn du bereits mit Python programmieren kannst, kannst du das auch mit MicroPython.
Da diese Sprache darauf ausgelegt ist, unter eingeschränkten Bedingungen – nämlich auf Microcontrollern mit wenig Speicherplatz – zu arbeiten, besitzt MicroPython nicht alle Bibliotheken von Python. Die für die Programmierung von ESP8266 und ESP32 sind natürlich an Bord – insbesondere jene, die du brauchst, um mit den Pins zu arbeiten und dich mit dem Internet zu verbinden.
Wichtig zu verstehen: MicroPython ist kein Programm, das du auf deinen Microcontroller lädst. Es ist eine Firmware, die den kompletten Speicher deines Boards überschreibt. Danach ist dort kein Arduino-Bootloader mehr, sondern ein kleiner Python-Interpreter, der auf deine Befehle wartet. Rückgängig machen lässt sich das jederzeit – dazu am Ende dieses Tutorials mehr.
Welche Vorteile bietet MicroPython?
Python ist eine Programmiersprache, die sowohl leicht zu lernen als auch leicht zu lesen ist. Das gilt auch für MicroPython – wenn du etwas Python beherrschst und schon auf „richtigen“ Computern programmiert hast, fällt dir der Einstieg leicht. Hier findest du einen Überblick über wichtige Funktionen von MicroPython (Englisch).
Weitere Vorteile sind:
- Du kannst deinen Microcontroller „live“ programmieren. Über die Shell (bzw. REPL) testest du deinen Code direkt, ohne erst einen ganzen Sketch hochladen zu müssen.
- Exception- und Error-Handling: Du kannst den Umgang mit Ausnahmen und Fehlern bereits in deinem Code definieren.
- Dein Programm liegt als Datei auf dem Board. Du kannst es dir jederzeit wieder herunterladen – auch von einem anderen Computer aus.
Aber MicroPython hat auch Nachteile im Vergleich zur Arduino IDE und C++, denn dort gibt es für nahezu jedes Bauteil bereits eine Bibliothek, die du einfach installieren, einbinden und verwenden kannst. Mit MicroPython wirst du ab und an etwas länger nach einer geeigneten Lösung suchen müssen. Dazu kommt: MicroPython ist deutlich langsamer als kompilierter C++-Code. Für eine Wetterstation oder einen Datenlogger spielt das keine Rolle – wenn du aber Signale im Mikrosekunden-Bereich verarbeiten willst, bist du mit der Arduino IDE besser bedient.
Welche Firmware brauchst du?
Diesen Schritt vorweg, denn hier scheitern die meisten Installationen: „ESP32“ ist längst keine eindeutige Angabe mehr. Unter diesem Namen verkaufen sich heute mehrere unterschiedliche Chips – und jeder von ihnen braucht seine eigene Firmware-Datei. Lädst du die falsche auf dein Board, meldet es sich nach der Installation schlicht nicht mehr.
Die gute Nachricht: Du musst nicht raten. Auf dem silbernen Metalldeckel deines Boards steht der Chipname aufgedruckt – zum Beispiel ESP32-WROOM-32, ESP32-S3-WROOM-1 oder ESP8266EX. Nimm eine Lupe oder mach ein Foto mit dem Handy und zoome hinein.
Diesen Namen brauchst du gleich im Installationsdialog. Dort wählst du zuerst die family – das ist die Chipfamilie – und darunter die variant, also die konkrete Ausführung:
| Aufdruck auf dem Modul | Typische Boards | family in Thonny |
|---|---|---|
ESP8266EX | NodeMCU, Wemos D1 mini | ESP8266 |
ESP32-WROOM-32 | ESP32 DevKit V1, NodeMCU-32S | ESP32 |
ESP32-S2 | Lolin S2 Mini | ESP32-S2 |
ESP32-S3 | ESP32-S3 DevKitC, viele neue Boards | ESP32-S3 |
ESP32-C3 | ESP32-C3 SuperMini, XIAO ESP32C3 | ESP32-C3 |
ESP32-C6 | ESP32-C6 DevKit | ESP32-C6 |
___STEADY_PAYWALL___
Bei der variant bietet dir Thonny anschließend die passenden Einträge an – teils auch Versionen für bestimmte Hersteller-Boards. Nimm im Zweifel immer den generischen Eintrag von Espressif, also zum Beispiel „Espressif • ESP32 / WROOM“. Der läuft auf so gut wie jedem Board. Findest du dort Zusätze wie SPIRAM oder OCT, lass sie weg – du verzichtest höchstens auf zusätzlichen Arbeitsspeicher.
MicroPython installieren mit der Thonny IDE
Um die Firmware auf deinen Microcontroller zu bekommen, gibt es mehrere Wege. Der einfachste führt über den Editor Thonny IDE. Das Tolle: Thonny ist für Anfänger bestens geeignet, bringt das Flash-Werkzeug bereits mit und du kannst deinen Microcontroller anschließend auch gleich damit programmieren.
Lade dir zunächst die neueste Version von Thonny hier herunter und starte die Installation. Schließe dann deinen Microcontroller wie gewohnt über USB an deinen Computer an und öffne Thonny.
Den Interpreter konfigurieren
Klicke im Menü Ausführen auf Konfiguriere den Interpreter. Dort findest du im oberen Dropdown-Menü mehrere Optionen – wähle MicroPython (ESP8266) bzw. MicroPython (ESP32). Diese Auswahl gilt auch für die neueren Varianten S2, S3, C3 und C6: Sie laufen alle unter „ESP32“.
Darunter wählst du bei Port or WebREPL den USB-Port, an dem dein Microcontroller hängt. Unter Windows heißt er COM3, COM4 oder ähnlich, auf dem Mac beginnt er mit /dev/cu.usbserial oder /dev/cu.wchusbserial.
Taucht dort kein Port auf? Dann überspring den nächsten Abschnitt kurz und lies weiter unten bei „Wenn es nicht funktioniert“ nach – das hat fast immer dieselbe Ursache.
Die Firmware installieren
Klicke nun unten rechts auf den Link MicroPython installieren oder aktualisieren (esptool). Es öffnet sich ein weiteres Fenster – und hier kommt die gute Nachricht: Du musst die Firmware nicht selbst herunterladen. Thonny holt sie sich direkt von micropython.org, du wählst nur aus, was du brauchst:
- Target port: der USB-Port deines Microcontrollers. Praktisch: Thonny nennt hier auch gleich den Übersetzerchip, also etwa „CP2102 USB to UART Bridge Controller“.
- Erase all flash before installing: Setz dieses Häkchen. Damit wird der Speicher vorher komplett geleert – das erspart dir eine ganze Klasse von Problemen, wenn auf dem Board vorher ein Arduino-Sketch oder eine ältere MicroPython-Version lag.
- MicroPython family und variant: die beiden Angaben aus der Tabelle oben.
- version: Hier steht bereits die aktuellste Version – die kannst du so stehen lassen.
Unter info führt dich ein Link zur passenden Seite auf micropython.org – dort kannst du nachlesen, was die gewählte Variante mitbringt. Und hinter der Schaltfläche ≡ unten verbergen sich weitere Optionen, die du nur in Ausnahmefällen brauchst (etwa wenn du flash-mode auf dio stellen musst, weil dein Board mit der Standardeinstellung zickt).
Zwei Dinge noch zu diesem Dialog: Er braucht eine Internetverbindung, weil die Firmware ja erst geladen werden muss. Und im Feld version findest du nicht nur die aktuellste Ausgabe – falls ein Projekt eine ältere Version voraussetzt, kannst du sie dort direkt auswählen. Ältere Thonny-Versionen konnten das übrigens noch nicht; dort musstest du die .bin-Datei selbst von micropython.org herunterladen. Falls dein Dialog noch so aussieht, lohnt sich ein Update von Thonny.
Mit einem Klick auf Installieren geht es los. Nach 15 bis 60 Sekunden ist alles erledigt und du kannst die Fenster wieder schließen, bis du auf der Oberfläche von Thonny landest. In der Shell unten sollte dich nun eine Zeile wie diese begrüßen:
Wrote 1760192 bytes (1152806 compressed) at 0x00001000 in 102.9 seconds (136.8 kbit/s).
Verifying written data...
Hash of data verified.
Hard resetting via RTS pin...
Done!Wenn du die Dialogfenster nun schließt, landest du wieder in der ursprünglichen Thonny Oberfläche. Hier sollte nun unten in der Shell (Kommandozeile) etwas in dieser Art zu lesen sein:
MicroPython v1.28.0 on 2026-04-06; Generic ESP32 module with ESP32
Type "help()" for more information.
>>> Wenn es nicht funktioniert
Drei Probleme erwischen praktisch jeden – und alle drei sind schnell gelöst.
Es wird kein Port angezeigt
Dein Board kommuniziert nicht direkt über USB, sondern über einen kleinen Übersetzerchip auf der Platine. Für den braucht dein Computer einen Treiber. Welchen, verrät wieder ein Blick auf die Platine – der Chip sitzt meist direkt neben der USB-Buchse. (Sobald der Treiber einmal läuft, nennt dir übrigens auch Thonny den Chip im Port-Menü.)
- CH340 oder CH9102 (die günstigen Boards): Treiber gibt es beim Hersteller WCH.
- CP2102 (häufig auf ESP32-DevKits): Treiber gibt es bei Silicon Labs.
Zwei weitere Klassiker, bevor du dich in Treiber stürzt: Prüfe dein USB-Kabel. Viele Kabel, die bei Powerbanks und Kopfhörern beiliegen, übertragen nur Strom und keine Daten – damit leuchtet dein Board zwar, meldet sich aber nie. Und: Bei Boards mit ESP32-S3, C3 oder C6 gibt es oft zwei USB-Buchsen. Nur eine davon ist mit dem Übersetzerchip verbunden, probier also beide aus.
„Failed to connect to ESP32“
Der Port ist da, aber die Installation bricht mit dieser Meldung ab. Dein Board muss zum Flashen in einen speziellen Modus wechseln, und das klappt nicht bei jedem Board automatisch. So hilfst du nach:
- Halte den Taster BOOT (manchmal auch FLASH oder IO0 beschriftet) gedrückt.
- Klicke bei gedrücktem Taster in Thonny auf Installieren.
- Sobald „Connecting…“ verschwindet und der Fortschrittsbalken losläuft, lass den Taster wieder los.
Bei besonders sturen Boards hilft die härtere Variante: Zieh das USB-Kabel ab, halte BOOT gedrückt, steck das Kabel wieder ein und lass den Taster erst dann los. Thonny selbst weist im Installationsfenster auf diesen Trick hin.
„Could not open port“ oder „Access is denied“
Der Port ist bereits belegt. Fast immer ist die Arduino IDE schuld – genauer gesagt ihr Serieller Monitor, der noch im Hintergrund lauscht. Schließe ihn (oder gleich die ganze IDE) und versuch es noch einmal. Auch ein zweites offenes Thonny-Fenster kann der Grund sein.
Der erste Test in der Shell
Die Oberfläche von Thonny besteht (neben dem Menü) aus zwei Fenstern. Im oberen schreibst du dein Python-Programm, das du über den grünen „Play“-Button auf deinem ESP8266 oder ESP32 ausführst. Im unteren findest du die Shell, mit der du quasi in Echtzeit mit deinem Microcontroller interagierst. Genau das macht MicroPython so angenehm – probieren wir es aus.
Trage hinter die drei >>> in der Shell Zeile für Zeile folgenden Code ein und drücke nach jeder Zeile Enter:
from machine import Pin
led = Pin(2, Pin.OUT)
led.value(1)Auf einem ESP32 sollte nun die interne LED leuchten. Tippe led.value(0) und sie geht wieder aus. Genau hier zeigt sich der Reiz von MicroPython: Du schaltest deinen Microcontroller im Dialog, ohne irgendetwas hochzuladen.
Beim ESP8266 ist es andersherum – dort schaltet led.value(0) die LED an und led.value(1) aus. Das wirkt verkehrt, hat aber einen simplen Grund: Auf dem NodeMCU und dem Wemos D1 mini hängt die LED zwischen der Versorgungsspannung und GPIO 2. Sie leuchtet also erst, wenn der Pin auf LOW geht. Der Pin verhält sich völlig normal – nur die LED ist andersherum verdrahtet.
Übrigens: Vielleicht hast du beim Anlegen des Pins ein kurzes Aufblitzen der LED bemerkt. Das ist normal – in dem Moment, in dem Pin(2, Pin.OUT) den Pin zum Ausgang macht, liegt kurz HIGH an. Willst du das vermeiden, gib den Startwert gleich mit: led = Pin(2, Pin.OUT, value=0).
Und wenn gar nichts passiert? Dann hast du vermutlich ein Board mit ESP32-S3 oder ESP32-C3 vor dir. Dort sitzt keine einfache LED, sondern eine adressierbare RGB-LED – die braucht andere Befehle. Probier stattdessen das hier (beim S3 sitzt sie meist an GPIO 48, beim C3 an GPIO 8):
from machine import Pin
from neopixel import NeoPixel
np = NeoPixel(Pin(48), 1)
np[0] = (0, 30, 0)
np.write()Die LED sollte nun grün leuchten. Mit np[0] = (0, 0, 0) und einem erneuten np.write() schaltest du sie wieder aus.
Dein Programm dauerhaft speichern: main.py
Die Shell ist gut zum Ausprobieren – aber dein Projekt soll am Ende ja laufen, ohne dass ein Computer daneben steht. Dafür legst du dein Programm als Datei auf dem Microcontroller ab. Und das ist der eigentliche Kniff, den viele Anleitungen unterschlagen:
MicroPython sucht beim Start nach zwei Dateien und führt sie automatisch aus:
boot.pyläuft als Erstes, bei jedem Start. Hier landet, was einmalig eingerichtet werden muss – zum Beispiel die WLAN-Verbindung.main.pyläuft direkt danach. Das ist dein eigentliches Programm.
Für den Anfang reicht dir main.py völlig. Blende zunächst die Dateiansicht ein: Klicke im Menü auf Ansicht und dann auf Dateien. Links erscheint nun ein geteiltes Fenster – oben Dieser Computer unten MicroPython device. Der untere Bereich ist der Speicher deines Microcontrollers.
Schreibe nun im oberen Editorfenster ein kleines Blinkprogramm:
from machine import Pin
from time import sleep
led = Pin(2, Pin.OUT)
while True:
led.value(1)
sleep(0.5)
led.value(0)
sleep(0.5)Klicke jetzt auf Datei → Speichern unter. Thonny fragt dich, wohin gespeichert werden soll: auf Dieser Computer oder auf das MicroPython device. Wähle das Gerät (also device) und gib als Dateinamen exakt main.py ein – Kleinschreibung, ohne Leerzeichen.
Und jetzt der Moment der Wahrheit: Zieh das USB-Kabel ab und steck es wieder ein – oder schließe dein Board an ein Netzteil oder eine Powerbank an. Die LED blinkt weiter, ganz ohne Computer. Dein Microcontroller führt jetzt bei jedem Start main.py aus.
Ein laufendes Programm stoppen
Ein Programm mit while True: läuft endlos – und blockiert damit die Shell. Willst du wieder Befehle eintippen oder eine neue Datei speichern, klickst du in Thonny auf den roten Stop-Button oder drückst Strg + C in der Shell. Danach meldet sich der Prompt >>> zurück.
Sollte sich dein Board gar nicht mehr melden, weil main.py es sofort nach dem Start beschäftigt: Halte Strg + C gedrückt, während du den Reset-Taster drückst. In hartnäckigen Fällen hilft eine Neuinstallation der Firmware mit „Erase flash“ – dabei verlierst du allerdings alle Dateien auf dem Board.
Zurück zur Arduino IDE
Vielleicht die wichtigste Nachricht für alle, die zögern: Die Installation von MicroPython ist keine Einbahnstraße. Du kannst jederzeit zu C++ zurückkehren.
Dazu musst du nichts Besonderes tun – öffne einfach die Arduino IDE und lade wie gewohnt einen Sketch hoch. Er überschreibt MicroPython vollständig. Nur falls der Upload fehlschlägt, greifst du zum selben Trick wie oben: BOOT-Taster gedrückt halten, während der Upload startet.
Denk nur daran, deine Python-Dateien vorher zu sichern – zieh sie in der Dateiansicht einfach von „MicroPython device“ nach „This computer“.
Wie geht es weiter?
Jetzt hast du alles beisammen: MicroPython läuft, du kannst in der Shell experimentieren, und dein Programm startet selbstständig. Damit steht dir eine Menge offen – ein Sensor, der seine Werte ins Netz schickt, eine Wetterstation oder eine kleine Steuerung, die morgens die Pflanzen gießt.
