Im letzten Beitrag „ESP32 programmieren – DC-Motor mit PWM und Drehpotentiometer steuern“ habe ich gezeigt, wie sich ein DC-Motor am ESP32 mithilfe der Arduino IDE und C/C++ ansteuern lässt. Dabei kamen PWM, ein Drehpotentiometer und ein MOSFET-Modul zum Einsatz, um die Motordrehzahl sicher und zuverlässig zu regeln.

Ein großer Vorteil des ESP32 ist jedoch, dass er sich nicht nur mit C/C++, sondern auch mit MicroPython programmieren lässt. Gerade für schnelle Prototypen, übersichtlichen Code und einen direkten Einstieg empfinde ich persönlich MicroPython oft als angenehmer und deutlich zugänglicher.

ESP32 DC-Motor mit MicroPython: PWM-Drehzahlregelung Schritt für Schritt

Dieses Video auf YouTube ansehen.

In diesem Beitrag zeige ich dir deshalb Schritt für Schritt, wie du die exakt gleiche Schaltung in MicroPython programmierst. Das Hardware-Setup bleibt unverändert – lediglich die Software wird auf MicroPython umgestellt. So kannst du beide Ansätze direkt miteinander vergleichen und selbst entscheiden, welche Programmiersprache besser zu deinem Projekt und deinem Workflow passt.

Schaltung – ESP32 mit DC-Motor, IRF520 Modul sowie Drehpotentiometer

Die verwendete Schaltung ist identisch zur Arduino-Version aus dem vorherigen Beitrag.
Der ESP32 erzeugt das PWM-Steuersignal für das IRF520-MOSFET-Modul, die Drehzahl wird über ein Drehpotentiometer vorgegeben.

Schaltung - ESP32 mit IRF520, DC-Motor & LEDs — Schaltung – ESP32 mit IRF520, DC-Motor & LEDs

Da sich an der Hardware nichts geändert hat, gehe ich hier nicht erneut im Detail auf den Aufbau ein.
Eine ausführliche Erklärung der Schaltung inklusive Sicherheits- und Praxis-Hinweisen findest du im vorherigen Beitrag: https://draeger-it.blog/esp32-programmieren-dc-motor-mit-pwm-und-drehpotentiometer-steuern/

Wichtiger Sicherheits- & Praxis-Hinweis zur Motoransteuerung

Auch in der MicroPython-Version gilt: Ein DC-Motor darf niemals direkt an einen GPIO-Pin des ESP32 angeschlossen werden.

Der ESP32 arbeitet intern mit 3,3 V und die GPIO-Pins sind nur für sehr geringe Ströme ausgelegt. Ein DC-Motor hingegen benötigt – insbesondere beim Start – einen deutlich höheren Strom. Dieser sogenannte Anlaufstrom liegt weit über dem, was ein ESP32-Pin sicher liefern kann.

Würde man den Motor direkt anschließen, könnte das:

den GPIO-Pin dauerhaft beschädigen,
zu instabilem Verhalten des ESP32 führen,
oder im schlimmsten Fall den Mikrocontroller vollständig zerstören.

Aus diesem Grund übernimmt der ESP32 in diesem Projekt ausschließlich die Steuerlogik.
Das eigentliche PWM-Signal wird an das IRF520-MOSFET-Modul weitergegeben, welches den Motor über eine externe Stromversorgung schaltet.

Wichtig ist dabei außerdem:

Gemeinsame Masse (GND) zwischen ESP32, IRF520-Modul und externer Stromversorgung
Der ESP32 liefert nur das Steuersignal, nicht die Motorleistung

Diese Trennung von Logik (ESP32) und Leistung (MOSFET + externe Versorgung) sorgt für einen sicheren, stabilen und reproduzierbaren Betrieb – unabhängig davon, ob die Steuerung in C/C++ oder in MicroPython umgesetzt wird.

Flashen des ESP32 für die Programmierung in MicroPython

Damit wir den ESP32 in MicroPython programmieren können, muss zunächst die entsprechende MicroPython-Firmware auf den Mikrocontroller geflasht werden.
Dafür trenne ich den ESP32 zunächst von allen angeschlossenen Komponenten und verbinde ihn ohne zusätzliche Beschaltung direkt mit dem Computer. So vermeiden wir mögliche Störungen während des Flash-Vorgangs.

Zum Flashen verwende ich das Tool Thonny. Thonny bietet eine sehr einfache Möglichkeit, den ESP32 D1 R32 mit MicroPython zu bespielen – ganz ohne komplizierte Befehle über die Kommandozeile eingeben zu müssen.
Im Hintergrund nutzt Thonny ebenfalls die bekannten Flash-Tools, nimmt einem dabei aber die komplette Konfiguration und Bedienung ab.

Kurz gesagt:
Thonny ist der komfortable Weg, um MicroPython auf den ESP32 zu bringen – besonders für Einsteiger. Technisch passiert dabei nichts anderes, als wenn man den Flash-Vorgang manuell über die Kommandozeile durchführen würde.

Was tun, wenn das Flashen nicht klappt?

Problem: Verbindungsabbruch während des Flashens

Der Flash-Vorgang startet, bricht aber plötzlich ab oder Thonny verliert die Verbindung zum ESP32.

Mögliche Ursache:
Ein instabiles oder ungeeignetes USB-Kabel bzw. ein problematischer USB-Port.

Lösung:

Verwende ein hochwertiges USB-Datenkabel (kein reines Ladekabel).
Schließe den ESP32 möglichst direkt am Computer an – nicht über einen USB-Hub.
Nutze bevorzugt einen USB-2.0-Port (häufig blau oder schwarz gekennzeichnet).
Trenne während des Flashens alle weiteren Komponenten vom ESP32.

In vielen Fällen lässt sich das Problem allein durch ein anderes USB-Kabel oder einen anderen Port sofort beheben.

Problem: Falsches Board oder falscher Port ausgewählt

Der Flash-Vorgang startet nicht oder bricht sofort ab, obwohl der ESP32 korrekt angeschlossen ist.

Mögliche Ursache:
In Thonny ist entweder das falsche Board oder der falsche serielle Port ausgewählt.

Lösung – Board überprüfen:
Auf dem ESP32-Board ist der verwendete Microcontroller-Chip direkt aufgedruckt.
Mit einer Handy-Kamera lässt sich der Chip sehr gut heranzoomen und eindeutig identifizieren.
Bei den meisten ESP32-Boards ist die Beschriftung (z. B. ESP32, ESP32-WROOM, ESP32-S3) deutlich lesbar.

ESP32-C3 Chip auf dem runden Elecrow Crowpanel

ESP32-S3 Chip — ESP32-C3 Chip auf dem runden Elecrow Crowpanel

Gerade bei größeren ESP32-Modulen ist der verbaute Chip gut sichtbar und eindeutig zu erkennen – das hilft enorm bei der korrekten Auswahl in Thonny.

Lösung – richtigen Port finden:

Windows 11:
Der verwendete serielle Port lässt sich im Geräte-Manager unter
Anschlüsse (COM & LPT) ablesen, sobald der ESP32 angeschlossen ist.
Linux:
Hier kann der Port über die Kommandozeile ermittelt werden, zum Beispiel mit: lsusb Alternativ erscheinen serielle Geräte häufig unter /dev/ttyUSB* oder /dev/ttyACM*.

Windows - Gerätemanager - Arduino Nesso N1 als serielles USB-Gerät erkannt

Sobald der richtige Chip und der korrekte Port ausgewählt sind, lässt sich der ESP32 in den meisten Fällen problemlos flashen.

Programmierung in MicroPython

Nachdem der ESP32 erfolgreich mit MicroPython geflasht wurde, können wir direkt mit der Programmierung beginnen.
Auch in MicroPython benötigen wir keine zusätzlichen Module oder Bibliotheken, da der ESP32 alle benötigten Funktionen bereits von Haus aus mitbringt.

Sowohl das Einlesen des Drehpotentiometers als auch die Erzeugung des PWM-Signals für den DC-Motor lassen sich mit den integrierten MicroPython-Modulen umsetzen. Das macht den Code übersichtlich, leicht nachvollziehbar und ideal für den Einstieg.

Der grundlegende Aufbau bleibt dabei identisch zur Arduino-Version:
Wir lesen einen analogen Wert ein, wandeln ihn in ein PWM-Signal um und steuern damit über das MOSFET-Modul die Drehzahl des Motors.

Programm: steuern eines DC-Motors am ESP32 mit Drehpotentiometer & PWM Signal Herunterladen

Schritt 1: Importe & Grundstruktur

from machine import Pin, ADC, PWM
import time

Was passiert hier?

Pin → steuert Ein- und Ausgänge (LEDs, Motor-Pin)
ADC → liest analoge Werte (Drehpotentiometer)
PWM → erzeugt ein PWM-Signal für den Motor
time → wird für kleine Pausen (sleep) benötigt

Schritt 2: Pinbelegung

led1Pin1 = 18
led1Pin2 = 23
led1Pin3 = 12
led1Pin4 = 17
led1Pin5 = 26

drehPotiPin = 2
motorPin = 4

Zweck

Hier legen wir zentral fest:

welche GPIOs für die LEDs verwendet werden
welcher Pin das Drehpotentiometer liest
welcher Pin das PWM-Signal für den Motor ausgibt

👉 Vorteil: Ändert sich später ein Pin, muss nur hier angepasst werden.

Schritt 3: LEDs initialisieren & in einer Liste ablegen

led_pins = [
    Pin(led1Pin1, Pin.OUT),
    Pin(led1Pin2, Pin.OUT),
    Pin(led1Pin3, Pin.OUT),
    Pin(led1Pin4, Pin.OUT),
    Pin(led1Pin5, Pin.OUT),
]

MAX_LEDS = len(led_pins)

Was passiert hier?

Jede LED wird als Ausgang definiert
Alle LEDs werden in einer Liste gesammelt

👉 Dadurch können wir später:

alle LEDs per Schleife an- oder ausschalten
die Anzeige sehr einfach erweitern

Schritt 4: Drehpotentiometer (ADC) konfigurieren

poti = ADC(Pin(drehPotiPin))
poti.atten(ADC.ATTN_11DB)
poti.width(ADC.WIDTH_12BIT)

Erklärung

ADC(Pin(...)) → verbindet den ADC mit dem Poti-Pin
ATTN_11DB → erlaubt Messungen bis ca. 3,3 V
WIDTH_12BIT → Wertebereich 0–4095

👉 Genau der gleiche Wertebereich wie beim Arduino-ESP32.

Schritt 5: PWM für den Motor initialisieren

motor_pwm = PWM(Pin(motorPin))
motor_pwm.freq(1000)

Erklärung

PWM(Pin(...)) → PWM-Signal auf dem Motor-Pin
freq(1000) → 1 kHz PWM-Frequenz

👉 Das PWM-Signal geht nicht direkt zum Motor, sondern:

an das IRF520-MOSFET-Modul
dieses schaltet dann die Motorleistung

Schritt 7: Geschwindigkeit über LEDs anzeigen

def display_speed(value):
    led_index = int(value / 4095 * (MAX_LEDS - 1))
    reset_leds()
    led_pins[led_index].on()

Erklärung

ADC-Wert (0–4095) wird auf LED-Index (0–4) umgerechnet
alle LEDs werden ausgeschaltet
genau eine LED wird eingeschaltet

👉 Ergebnis: Eine einfache Geschwindigkeitsanzeige in 5 Stufen

Schritt 8: Motorgeschwindigkeit setzen (PWM)

def set_motor_speed(value):
    duty = int(value / 4095 * 1023)
    motor_pwm.duty(duty)

Erklärung

ADC-Wert → PWM-Duty
MicroPython nutzt hier 0–1023 als PWM-Bereich

👉 Je höher der Duty-Wert:

desto länger ist das Signal „AN“
desto schneller dreht der Motor

Schritt 9: LED-Test beim Start

for led in led_pins:
    led.on()
    time.sleep(0.2)
reset_leds()

Zweck

jede LED leuchtet einmal kurz
sofortige Kontrolle:
- LEDs richtig angeschlossen?
- Programm läuft?

Schritt 10: Hauptschleife (loop-Ersatz)

last_value = -1

while True:
    poti_value = poti.read()

    if abs(poti_value - last_value) > 10:
        display_speed(poti_value)
        set_motor_speed(poti_value)
        last_value = poti_value

    time.sleep(0.05)

Erklärung

while True: → Endlosschleife (wie loop() bei Arduino)
Poti-Wert wird kontinuierlich gelesen
Deadband (±10) verhindert Flackern & unnötige Updates
LEDs & Motor werden nur bei Änderung aktualisiert

👉 Ergebnis:

ruhiger Lauf
stabile Anzeige
sauberes PWM-Verhalten

Fazit & Ausblick

Wie du in diesem Beitrag gesehen hast, lässt sich die kleine Schaltung auch in MicroPython sehr einfach und übersichtlich programmieren. Mit wenigen Zeilen Code, klaren Funktionen und den Bordmitteln des ESP32 können sowohl das PWM-Signal für den DC-Motor als auch die Auswertung des Drehpotentiometers zuverlässig umgesetzt werden.

Gerade für Prototypen und schnelle Experimente spielt MicroPython hier seine Stärken aus: Änderungen am Code sind sofort testbar, die Struktur bleibt gut lesbar und der Einstieg ist auch für Einsteiger problemlos möglich.

Im nächsten Beitrag greifen wir dieses Projekt erneut auf und erweitern es um eine kleine Weboberfläche, über die sich die Motordrehzahl bequem steuern lässt – ganz ohne Drehpotentiometer.
Bleib also gespannt, denn damit wird aus der einfachen Schaltung ein kleines, praxisnahes IoT-Projekt.

Letzte Aktualisierung am: 31. Dezember 2025