MicroPython mit Claude Code in VS Code zu entwickeln, hat meinen bisherigen Workflow deutlich vereinfacht. Mit Claude Code und MicroPico kann ich Code erstellen und prüfen, auf den ESP32-C6 übertragen, über die REPL testen und Messwerte direkt in VS Code visualisieren.
In diesem Beitrag zeige ich meinen kompletten Workflow am XIAO ESP32-C6 – von der Einrichtung bis zu einem kleinen DHT11-Praxisprojekt mit MicroPico Plotter.
Hinweis: Den XIAO ESP32-C6 sowie das Expansion Board habe ich kostenfrei von OpenELAB zur Verfügung gestellt bekommen. Auf den Inhalt und meine Bewertung dieses Projekts hat das keinen Einfluss.
Mein Setup
Für dieses Projekt verwende ich Visual Studio Code zusammen mit zwei Erweiterungen:
- Claude Code für die Unterstützung beim Programmieren,
- MicroPico zum Übertragen und Ausführen des MicroPython-Codes auf dem XIAO ESP32-C6.
Damit lässt sich das komplette Projekt direkt in VS Code bearbeiten. Claude unterstützt mich beim Erstellen und Anpassen des Codes, während MicroPico die Verbindung zum Mikrocontroller übernimmt.
MicroPico funktioniert nicht nur mit dem Raspberry Pi Pico
Der Name der Erweiterung ist dabei etwas irreführend. MicroPico wird in der Beschreibung hauptsächlich für Raspberry-Pi-Pico-Boards mit MicroPython beworben und bietet unter anderem Autovervollständigung, einen Remote Workspace und eine integrierte REPL-Konsole.
In der Praxis funktioniert die Erweiterung jedoch auch mit anderen Mikrocontrollern, auf denen MicroPython läuft. Mit dem XIAO ESP32-C6 klappt die Verbindung bei mir problemlos.
Damit kann ich den Code direkt aus VS Code auf den ESP32-C6 übertragen, ausführen und über die REPL-Konsole testen – ohne dafür zusätzlich Thonny öffnen zu müssen.
Claude Code und MicroPico installieren
Für mein Setup benötige ich in Visual Studio Code nur zwei zusätzliche Erweiterungen: Claude Code und MicroPico. Beide lassen sich direkt über den Extension Marketplace von VS Code installieren.
Claude Code installieren
Über die Erweiterungsverwaltung von VS Code suche ich nach Claude Code und installiere die offizielle Erweiterung von Anthropic.
Nach der Installation erscheint Claude direkt in der Seitenleiste von VS Code. Von dort aus kann ich Fragen zum Projekt stellen, vorhandene Dateien analysieren lassen oder Claude Änderungen am Quellcode vornehmen lassen.
Der große Vorteil dabei: Claude Code ist direkt in VS Code integriert und ich muss nicht mehr zwischen Entwicklungsumgebung und separatem Terminal wechseln.
MicroPico installieren
Als zweite Erweiterung installiere ich MicroPico.
Der Name ist zunächst etwas irreführend, denn MicroPico ist eigentlich für den Raspberry Pi Pico mit MicroPython gedacht. Die Erweiterung funktioniert jedoch auch mit anderen Mikrocontrollern, auf denen MicroPython läuft. Mit meinem XIAO ESP32-C6 klappt das problemlos.
MicroPico übernimmt dabei gleich mehrere Aufgaben:
- Verbindung zum XIAO ESP32-C6,
- Dateien auf den Mikrocontroller übertragen,
- Python-Dateien direkt auf dem Board ausführen,
- Zugriff auf die MicroPython-REPL,
- Dateien vom Mikrocontroller zurück nach VS Code übertragen.
Praktisch: ein Plotter direkt in VS Code
Ein weiteres Feature von MicroPico finde ich besonders praktisch: Die Erweiterung bringt einen Plotter für Zahlenwerte mit.
Wer bereits mit der Arduino IDE gearbeitet hat, kennt wahrscheinlich den dort integrierten Serial Plotter. Messwerte, die der Mikrocontroller über die serielle Schnittstelle ausgibt, lassen sich damit direkt als Liniendiagramm darstellen.
Eine ähnliche Möglichkeit bietet MicroPico direkt in VS Code. Das ist beispielsweise praktisch, wenn später ein Sensor über die Grove-Schnittstelle angeschlossen wird und Temperatur, Luftfeuchtigkeit oder andere Messwerte nicht nur als Zahlen in der Konsole erscheinen sollen.
Damit habe ich für dieses Projekt alles an einem Ort: Claude unterstützt beim Programmieren, MicroPico verbindet VS Code mit dem XIAO ESP32-C6 und Messwerte lassen sich direkt visualisieren.
MicroPico mit dem XIAO ESP32-C6 verbinden
MicroPico funktioniert nach der Installation nicht sofort automatisch. Zuerst verbinde ich den XIAO ESP32-C6 per USB mit dem Computer.
Anschließend öffne ich mit Strg + Shift + P die Befehlspalette von VS Code und wähle dort MicroPico: Connect aus.
Sobald die Verbindung hergestellt ist, erscheinen am unteren Rand von VS Code zusätzliche Schaltflächen und Informationen zu MicroPico. Darüber lassen sich die wichtigsten Funktionen direkt erreichen.
So kann ich zum Beispiel den aktuell geöffneten Python-Code auf dem Mikrocontroller starten oder ein laufendes Programm stoppen.
Beim Zugriff auf das Dateisystem gab es bei meinem XIAO ESP32-C6 allerdings zunächst eine Fehlermeldung. Nach einem erneuten Verbindungsversuch funktionierte der Zugriff dann und ich konnte mir die Dateien auf dem Mikrocontroller anzeigen lassen.
Mit einem Raspberry Pi Pico 2 funktionierte der Dateizugriff in meinem Test direkt. Beim XIAO ESP32-C6 klappt die Funktion also grundsätzlich, scheint aber nicht ganz so zuverlässig zu sein.
Dateien auf den XIAO ESP32-C6 übertragen
Der Upload von Dateien auf den Mikrocontroller ist mit MicroPico recht einfach.
Im Explorer von VS Code wähle ich eine oder mehrere Dateien beziehungsweise komplette Verzeichnisse aus und öffne mit der rechten Maustaste das Kontextmenü. Unter MicroPico stehen anschließend die passenden Upload-Funktionen zur Verfügung.
So lassen sich einzelne Dateien, mehrere Dateien, ganze Verzeichnisse oder auch direkt das komplette Projekt auf den XIAO ESP32-C6 übertragen.
Genauso einfach funktioniert auch der umgekehrte Weg: Dateien lassen sich vom Mikrocontroller wieder zurück nach VS Code herunterladen.
Damit eignet sich MicroPico nicht nur zum schnellen Testen einzelner Skripte, sondern auch für Projekte mit mehreren Modulen und einer etwas größeren Verzeichnisstruktur.
Claude Code direkt in VS Code nutzen
Bisher habe ich für meine MicroPython-Projekte Thonny und Claude Code parallel verwendet. Beide Tools haben dabei mit demselben Projektordner gearbeitet, was grundsätzlich gut funktioniert hat.
Der Nachteil: Ich musste ständig zwischen zwei Fenstern wechseln – hier den Code bearbeiten und testen, dort Claude meine Änderungen oder Fragen mitgeben.
Mit VS Code fällt dieser Wechsel weg. Claude Code läuft direkt in derselben Entwicklungsumgebung, in der ich auch den MicroPython-Code bearbeite und mit MicroPico auf den Mikrocontroller übertrage.
Bevor Claude Code in VS Code genutzt werden kann, muss es bereits eingerichtet und mit einem passenden Zugang verbunden sein. Wie das unter Windows funktioniert, habe ich ausführlich im Beitrag „Claude Code unter Windows 11 mit WSL installieren – Schritt für Schritt“ beschrieben.
Wer Claude Code bereits eingerichtet hat, kann direkt weitermachen.
Der eigentliche Vorteil ist für mich deshalb nicht, dass Claude plötzlich Zugriff auf das Projekt hat, sondern dass Code, Claude, Upload und Test in einer Oberfläche zusammenkommen.
Vor- und Nachteile meines Workflows
Nach der Einrichtung lässt sich der Workflow mit VS Code, Claude Code und MicroPico sehr angenehm nutzen. Gerade weil die Entwicklungsumgebung nicht für jedes neue Projekt wieder von Grund auf eingerichtet werden muss, eignet sich das Setup für kleine wie auch größere MicroPython-Projekte.
| Pro | Contra |
|---|---|
| Alles in einer Oberfläche | Etwas mehr Einrichtung am Anfang |
| Claude Code direkt im Projekt | Claude-Zugang erforderlich |
| Upload, REPL und Plotter mit MicroPico | MicroPico nicht auf jedem Board gleich zuverlässig |
| Auch für kleine Projekte praktisch | Generierter Code muss immer geprüft werden |
| Gut für größere und wachsende Projekte | Hardwaretests bleiben notwendig |
| Änderungen direkt nachvollziehbar |
Für mich überwiegen damit klar die Vorteile. Besonders angenehm ist, dass Code, Claude, Upload und Test direkt in VS Code zusammenkommen und ich nicht mehr ständig zwischen mehreren Fenstern wechseln muss.
Praxisbeispiel: DHT11 mit Claude Code und MicroPico Plotter
Für ein erstes kleines Praxisprojekt verwende ich einen DHT11-Sensor zusammen mit einer LED am XIAO ESP32-C6.
Der DHT11 liefert Temperatur und relative Luftfeuchtigkeit. Beide Werte sollen regelmäßig ausgelesen und über die serielle Schnittstelle ausgegeben werden. Die LED dient dabei lediglich als optischer Indikator und leuchtet bei jeder neuen Messung kurz auf.
Als zusätzliche Ausgabe möchte ich den bereits erwähnten MicroPico Plotter verwenden. Damit lassen sich die beiden Messwerte direkt in VS Code als Liniendiagramm darstellen.
Das Programm mit Claude Code erstellen
Claude bekommt zunächst nur die Anforderungen für das kleine Projekt:
Erstelle ein MicroPython-Programm für einen XIAO ESP32-C6.
Angeschlossen sind:
- eine LED an GPIO0
- ein DHT11-Sensor an GPIO1
Lies alle 2 Sekunden Temperatur und relative Luftfeuchtigkeit aus.
Gib beide Werte über die serielle Schnittstelle aus, sodass sie mit dem MicroPico Plotter dargestellt werden können.
Bei jeder Messung soll die LED kurz aufleuchten.
Halte den Code übersichtlich und verwende aussagekräftige Variablennamen.Claude erstellt daraus die benötigte main.py, die ich anschließend mit MicroPico direkt auf den ESP32-C6 übertragen und testen kann.
generierter MicroPython Code von Claude Code
from machine import Pin
from time import sleep
import dht
# ---------- Konfiguration ----------
LED_PIN_NUMBER = 0 # LED an GPIO0
DHT11_PIN_NUMBER = 1 # DHT11-Datenleitung an GPIO1
MEASUREMENT_INTERVAL_S = 2 # Messintervall in Sekunden
LED_FLASH_DURATION_S = 0.1 # Dauer des LED-Blinkens pro Messung
# ---------- Hardware initialisieren ----------
status_led = Pin(LED_PIN_NUMBER, Pin.OUT)
status_led.off()
dht11_sensor = dht.DHT11(Pin(DHT11_PIN_NUMBER))
def flash_status_led():
"""Leuchtet die LED kurz auf."""
status_led.on()
sleep(LED_FLASH_DURATION_S)
status_led.off()
while True:
try:
dht11_sensor.measure()
temperature_celsius = dht11_sensor.temperature()
relative_humidity_percent = dht11_sensor.humidity()
# Format für den MicroPico Plotter: "Name:Wert" durch Komma getrennt
print("Temperatur:{},Luftfeuchtigkeit:{}".format(
temperature_celsius, relative_humidity_percent))
flash_status_led()
except OSError:
# DHT11 liefert gelegentlich keine gültigen Daten – Messung überspringen
print("Fehler: DHT11 konnte nicht gelesen werden")
sleep(MEASUREMENT_INTERVAL_S)
Das Programm selbst funktionierte auf Anhieb: Der Sensor wurde ausgelesen und die LED blinkte bei jeder Messung kurz auf.
Messwerte für den MicroPico Plotter formatieren
Im Plotter wurden die Werte zunächst allerdings nicht angezeigt. MicroPico gab mir stattdessen den Hinweis:
Waiting for data. Print comma-separated numbers
Der Plotter erwartet also keine frei formatierte Textausgabe, sondern kommaseparierte Zahlenwerte.
Statt den Code nun von Hand anzupassen, gebe ich Claude einfach die Information zurück:
Das Programm funktioniert, der MicroPico Plotter erkennt die Ausgabe jedoch nicht.
MicroPico erwartet kommaseparierte Zahlen, zum Beispiel:
print("%.1f, %.1f" % (temp, humidity))
Die erste Zeile kann optional die Namen der Datenreihen enthalten:
print("Temperatur,Luftfeuchtigkeit")
Passe ausschließlich die serielle Ausgabe entsprechend an. Die restliche Programmlogik soll unverändert bleiben.angepasster Quellcode von Claude Code damit die Daten im MicroPico Plotter visualisiert werden können
from machine import Pin
from time import sleep
import dht
# ---------- Konfiguration ----------
LED_PIN_NUMBER = 0 # LED an GPIO0
DHT11_PIN_NUMBER = 1 # DHT11-Datenleitung an GPIO1
MEASUREMENT_INTERVAL_S = 2 # Messintervall in Sekunden
LED_FLASH_DURATION_S = 0.1 # Dauer des LED-Blinkens pro Messung
# ---------- Hardware initialisieren ----------
status_led = Pin(LED_PIN_NUMBER, Pin.OUT)
status_led.off()
dht11_sensor = dht.DHT11(Pin(DHT11_PIN_NUMBER))
# Kopfzeile mit den Namen der Datenreihen für den MicroPico Plotter
print("Temperatur,Luftfeuchtigkeit")
def flash_status_led():
"""Leuchtet die LED kurz auf."""
status_led.on()
sleep(LED_FLASH_DURATION_S)
status_led.off()
while True:
try:
dht11_sensor.measure()
temperature_celsius = dht11_sensor.temperature()
relative_humidity_percent = dht11_sensor.humidity()
# Format für den MicroPico Plotter: kommaseparierte Zahlen
print("%.1f, %.1f" % (temperature_celsius, relative_humidity_percent))
flash_status_led()
except OSError:
# DHT11 liefert gelegentlich keine gültigen Daten – Messung überspringen
print("Fehler: DHT11 konnte nicht gelesen werden")
sleep(MEASUREMENT_INTERVAL_S)
Danach sieht die Ausgabe beispielsweise so aus:
Temperatur,Luftfeuchtigkeit 23.0, 74.0 23.0, 72.0 23.0, 74.0 23.0, 74.0 23.0, 74.0
Damit erkennt MicroPico beide Datenreihen und zeigt Temperatur und Luftfeuchtigkeit direkt als zwei Linien im Plotter an.
Doppelpunkt in der Legende
In der Legende des Plotters erscheint hinter dem Namen der Datenreihe zusätzlich ein Doppelpunkt. Zunächst hatte ich vermutet, dass dieser ebenfalls aus meinem Programm stammt.
In der seriellen Ausgabe ist dieser jedoch nicht vorhanden. Der Doppelpunkt wird vom MicroPico Plotter selbst ergänzt und gehört damit zur Darstellung der Legende.
Eine weitere Änderung am MicroPython-Code ist an dieser Stelle also nicht notwendig.
Gerade dieses kleine Beispiel zeigt für mich sehr gut, wie der Workflow gedacht ist: Claude erstellt den Code, ich teste ihn auf der echten Hardware und gebe anschließend konkrete Rückmeldungen, wenn etwas noch nicht zum verwendeten Tool passt.
Der Ablauf bleibt damit immer gleich:
FAQ: MicroPython mit Claude Code in VS Code
Kann ich MicroPython mit VS Code statt Thonny programmieren?
Ja. Mit Erweiterungen wie MicroPico lässt sich MicroPython direkt in VS Code entwickeln. Code kann auf den Mikrocontroller übertragen, ausgeführt und über die REPL getestet werden. In meinem Fall funktioniert das auch mit dem XIAO ESP32-C6.
Funktioniert MicroPico auch mit dem ESP32?
MicroPico ist ursprünglich vor allem für Raspberry-Pi-Pico-Boards gedacht, funktioniert bei mir aber auch mit dem XIAO ESP32-C6. Einzelne Funktionen, beispielsweise der Zugriff auf das Dateisystem, waren bei meinem Test allerdings nicht immer beim ersten Versuch zuverlässig.
Brauche ich Claude Code für MicroPython in VS Code?
Nein. MicroPython lässt sich auch ohne Claude Code in VS Code entwickeln. Claude Code ist für mich eine zusätzliche Unterstützung beim Erstellen, Analysieren und Anpassen des Programmcodes.
Was bringt Claude Code direkt in VS Code?
Der größte Vorteil ist für mich der gemeinsame Workflow. Code, Claude, Upload, REPL und Test befinden sich in derselben Entwicklungsumgebung. Dadurch muss ich nicht ständig zwischen VS Code, einem separaten Terminal und weiteren Programmen wechseln.
Überträgt Claude Code den MicroPython-Code direkt auf den ESP32?
Nein. Claude Code erstellt oder verändert den Quellcode im Projekt. Die Verbindung zum Mikrocontroller und den Upload der Dateien übernimmt in meinem Setup MicroPico.
Muss ich von Claude erzeugten Code noch prüfen?
Ja. Generierter Code sollte immer geprüft und anschließend auf der echten Hardware getestet werden. Claude kann beispielsweise nicht automatisch erkennen, ob ein Sensor tatsächlich am angegebenen GPIO angeschlossen ist oder eine Schaltung anders aufgebaut wurde.
Kann ich Messwerte direkt in VS Code darstellen?
Ja. MicroPico bringt einen Plotter mit, über den sich beispielsweise Temperatur und Luftfeuchtigkeit als Liniendiagramm darstellen lassen. Die Messwerte müssen dafür passend formatiert über die serielle Schnittstelle ausgegeben werden.
Ist VS Code für kleine MicroPython-Projekte nicht zu aufwendig?
Die Einrichtung ist zunächst etwas umfangreicher als bei Thonny. Wenn VS Code, Claude Code und MicroPico aber einmal eingerichtet sind, funktioniert der Workflow auch bei kleinen Projekten sehr angenehm.
Fazit
Für mich ist die Kombination aus VS Code, Claude Code und MicroPico inzwischen ein sehr angenehmer Workflow für MicroPython-Projekte.
Der größte Vorteil ist weniger ein einzelnes Feature, sondern dass alles an einem Ort zusammenkommt: Code bearbeiten, Claude nutzen, Dateien auf den Mikrocontroller übertragen, die REPL öffnen und Messwerte direkt im Plotter anzeigen.
Am Beispiel mit dem DHT11 hat sich außerdem gezeigt, wie sinnvoll der iterative Ablauf ist: Claude erstellt den ersten Code, ich teste ihn auf der echten Hardware und gebe gezielt Rückmeldung, wenn etwas noch nicht passt. Gerade solche kleinen Korrekturen lassen sich anschließend sehr schnell umsetzen.
Wichtig bleibt trotzdem: Generierter Code sollte immer geprüft und auf der realen Hardware getestet werden. Claude kann viel Arbeit abnehmen, kennt aber nicht automatisch jede Besonderheit der Schaltung oder des verwendeten Boards.
Thonny bleibt für mich weiterhin ein gutes Werkzeug. Wenn Claude Code jedoch intensiv genutzt wird oder ein Projekt wächst, bietet mir VS Code mit MicroPico den deutlich runderen Workflow.
Letzte Aktualisierung am: 03. Oktober 2026
