ESP32 programmieren – DC-Motor mit PWM und Drehpotentiometer steuern

In einem früheren Video mit dem Titel ESP32 programmieren – steuern von LEDs mit einem Drehpotentiometer habe ich bereits gezeigt, wie sich ein ESP32 ganz einfach nutzen lässt, um LEDs stufenlos per Drehregler zu steuern.
Das Video stammt zwar bereits aus dem Jahr 2023, die grundlegenden Konzepte – ADC, PWM und das Zusammenspiel von Hardware und Software – sind aber nach wie vor aktuell.

ESP32 programmieren - DC-Motor mit PWM und Drehpotentiometer steuern

Dieses Video auf YouTube ansehen.

In den Kommentaren zu diesem Video kam eine spannende Frage auf:
Kann man mit dem ESP32 auf ähnliche Weise auch einen DC-Motor steuern?

Genau das schauen wir uns in diesem Beitrag an.

Ich zeige dir Schritt für Schritt, wie du einen DC-Motor am ESP32 D1 R32 anschließt und programmierst. Statt einer LED regeln wir diesmal die Drehzahl eines Motors per PWM, ebenfalls über ein Drehpotentiometer. Das Grundprinzip bleibt also vertraut, der praktische Nutzen steigt jedoch deutlich.

Für die Ansteuerung des Motors setze ich auf das IRF520-Modul, das ich bereits in einem früheren Projekt verwendet habe – unter anderem in meinem Beitrag zur Lüftersteuerung:
https://draeger-it.blog/lueftersteuerung-mit-irf520-ir-abstandssensor/

Der große Vorteil dieses Moduls liegt in der einfachen Handhabung:
Der ESP32 übernimmt ausschließlich die Steuerlogik, während das IRF520-Modul die nötige Leistung für den Motor schaltet. Dadurch bleibt die Schaltung übersichtlich, sicher und auch für Einsteiger gut geeignet.

Am Ende dieses Beitrags weißt du:

• warum ein DC-Motor nicht direkt an den ESP32 angeschlossen werden sollte,
• wie der Anschluss mit dem IRF520-Modul erfolgt,
• und wie sich die Drehzahl per PWM sauber und reproduzierbar regeln lässt.

PWM – so steuert der ESP32 einen DC-Motor

Um einen DC-Motor mit dem ESP32 zu steuern, benötigen wir kein spezielles Motor-Protokoll. Die Grundlage ist ein PWM-Signal (Pulsweitenmodulation), das der ESP32 direkt erzeugen kann.

Der ESP32 selbst kann an seinen Ausgängen nur zwei Zustände ausgeben: Ein oder Aus.
Für einen Motor ist das jedoch völlig ausreichend – denn er reagiert nicht auf einzelne Schaltimpulse, sondern auf die zugeführte Energie über die Zeit.

Genau hier kommt PWM ins Spiel:
Der ESP32 schaltet den Ausgang sehr schnell ein und aus. Entscheidend ist dabei nicht, wie hoch die Spannung ist, sondern wie lange der Ausgang innerhalb eines festen Zeitfensters eingeschaltet ist.

• Kurze Einschaltzeit → wenig Energie → Motor dreht langsam
• Lange Einschaltzeit → mehr Energie → Motor dreht schneller

Der Motor wirkt dabei wie ein mechanischer „Filter“:
Durch seine Massenträgheit werden die einzelnen Impulse nicht als Stop-and-Go wahrgenommen, sondern als gleichmäßige Drehbewegung mit unterschiedlicher Geschwindigkeit.

Wichtig ist: 👉 Der ESP32 steuert den Motor nicht direkt.

Das PWM-Signal wird an das IRF520-MOSFET-Modul weitergegeben. Der ESP32 liefert dabei ausschließlich das Steuersignal, während das IRF520-Modul den eigentlichen Motorstrom aus der externen Stromversorgung schaltet.

Benötigte Materialien

Für den Aufbau brauchst du nur wenige, gut erhältliche Komponenten:

Mehr ist für dieses Projekt nicht nötig. Im nächsten Schritt verbinden wir die Komponenten und bauen die Schaltung Schritt für Schritt auf.

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

In der Schaltung verwende ich einen großen Drehpotentiometer mit 50 kOhm, diesen gibt es noch in weiteren ausführungen welche kleiner sind und wie ich finde dadurch weniger gut zu bedienen, aber die Schaltung funktioniert mit diesen genauso gut.

Werkzeuge

Schaltung: ESP32 mit Drehpotentiometer, IRF520-MOSFET-Modul und DC-Motor

Die Schaltung ist bewusst einfach gehalten.
Der ESP32 erzeugt das PWM-Steuersignal, das IRF520-MOSFET-Modul schaltet damit den Motorstrom aus einer externen Stromversorgung. Der Motor selbst ist zu keinem Zeitpunkt direkt mit dem ESP32 verbunden.

ESP32 Pin	Bauteil	Anschluss / Funktion
GPIO 4	IRF520-MOSFET-Modul	SIG (PWM-Steuersignal für den Motor)
GND	IRF520-MOSFET-Modul	GND (gemeinsame Masse)
GND	Externe Stromversorgung	Minus (-)
V+	IRF520-MOSFET-Modul	Motor +
V-	IRF520-MOSFET-Modul	Motor –
3,3 V	Drehpotentiometer	Außenpin
GND	Drehpotentiometer	Außenpin
GPIO 2	Drehpotentiometer	Schleifer (mittlerer Pin, ADC)
GPIO 18	LED 1	Anode
GPIO 23	LED 2	Anode
GPIO 12	LED 3	Anode
GPIO 17	LED 4	Anode
GPIO 26	LED 5	Anode
GND	LEDs	Kathode (über Vorwiderstand)

Wichtiger Sicherheits- und Praxis-Hinweis zur Versorgung

Der ESP32 stellt an seinen Pins 3,3 V (teilweise auch 5 V) zur Verfügung. Rein theoretisch könnte man auf die Idee kommen, einen kleinen DC-Motor direkt an einen GPIO-Pin anzuschließen – das sollte man jedoch niemals tun.

Der Grund dafür ist der sogenannte Anlaufstrom eines Motors. Beim Start zieht ein DC-Motor für einen sehr kurzen Moment deutlich mehr Strom als im normalen Betrieb. Dieser Strom liegt weit über dem, was ein GPIO-Pin des ESP32 liefern kann. Im schlimmsten Fall wird dadurch der Pin oder sogar der gesamte Mikrocontroller dauerhaft beschädigt.

Selbst wenn der ESP32 diesen Moment überstehen sollte, entsteht das nächste Problem, sobald der Motor mechanisch belastet wird – zum Beispiel durch Reibung, eine Achse oder einen Linearantrieb. Auch hier steigt der Strombedarf sprunghaft an und kann erneut zu Schäden oder instabilem Verhalten führen.

Aus diesem Grund wird der Motor in diesem Projekt niemals direkt vom ESP32 versorgt.
Der ESP32 erzeugt ausschließlich das PWM-Steuersignal, während die eigentliche Motorleistung über eine externe Stromversorgung und das IRF520-MOSFET-Modul geschaltet wird. So bleibt der ESP32 geschützt und die Schaltung arbeitet zuverlässig und sicher.

Programmieren in der Schaltung in der Arduino IDE

Das Gute an diesem Projekt ist, dass der Code ohne zusätzliche Bibliotheken auskommt. Das IRF520-Modul wird lediglich mit einem PWM-Signal angesteuert, welches sich mit den Bordmitteln des ESP32 sehr einfach erzeugen lässt.

Schritt 1 – definieren der Pins

Im ersten Schritt legen wir die Konstanten für unsere Pins fest. Dabei verwende ich das Schlüsselwort #define.
Dieses sorgt dafür, dass der Compiler vor dem eigentlichen Kompilieren jedes Vorkommen des definierten Namens durch den zugewiesenen Wert ersetzt.

Das hat zwei Vorteile:

• Der Code wird übersichtlicher und besser lesbar, da wir mit sprechenden Namen arbeiten.
• Ändert sich später ein Pin, muss dieser nur an einer Stelle angepasst werden.

Statt im Code mit festen Zahlen zu arbeiten, greifen wir so überall auf klar benannte Bezeichner wie motor oder led1 zurück – das macht den Sketch gerade für Einsteiger deutlich nachvollziehbarer.

// ==============================
// LED-Pins (Geschwindigkeitsanzeige)
// ==============================
#define led1 18
#define led2 23
#define led3 12
#define led4 17
#define led5 26

// ==============================
// Drehpotentiometer (ADC-Eingang)
// ==============================
#define drehPoti 2

// ==============================
// Motor-Pin (PWM-Ausgang → IRF520 SIG)
// ==============================
#define motor 4

Alternativ kannst du die Pins auch so definieren, wie es in vielen anderen Tutorials im Internet üblich ist – zum Beispiel über ganz normale Variablen anstelle von #define.

const int LED1 = 18;

Schritt 2 – anlegen der Konstanten und Liste mit Pindefinitionen

Wenn wir mehrere LEDs gemeinsam behandeln wollen – zum Beispiel um sie alle auf einmal ein- oder auszuschalten – bietet sich eine for-Schleife an.
Damit das funktioniert, müssen die verwendeten Pins jedoch in einer Liste (Array) abgelegt werden.

Statt jede LED einzeln anzusprechen, können wir so alle LEDs nacheinander durchlaufen und mit derselben Anweisung steuern. Das spart Code, vermeidet Wiederholungen und macht den Sketch deutlich übersichtlicher.

Gerade bei mehreren LEDs ist diese Vorgehensweise sehr praktisch und lässt sich später leicht erweitern, falls weitere LEDs hinzukommen.

// Anzahl der verwendeten LEDs
const int MAX_LEDS = 5;

// Array für die LEDs, damit sie bequem per Schleife angesteuert werden können
int leds[MAX_LEDS] = { led1, led2, led3, led4, led5 };

// Speichert den letzten Poti-Wert, um unnötige Updates zu vermeiden
int lastValue = -1;

Schritt 3 – Funktion setup

In der Funktion setup(), die einmalig beim Start des Mikrocontrollers oder nach dem Drücken des RESET-Tasters ausgeführt wird, legen wir fest, wie die einzelnen Pins verwendet werden. In unserem Fall definieren wir die LED-Pins als Ausgänge.

Hier kommt auch die zuvor erwähnte for-Schleife zum Einsatz. Mit ihr durchlaufen wir alle LED-Pins aus unserem Array und setzen sie als Ausgang. Anschließend werden die LEDs einmal nacheinander eingeschaltet. Dieser kurze Test zeigt sofort, ob alle LEDs korrekt angeschlossen sind und funktioniert gleichzeitig als einfache Funktionsprüfung beim Start des Programms.

void setup() {
  // Alle LEDs als Ausgang konfigurieren
  for (int index = 0; index < MAX_LEDS; index++) {
    pinMode(leds[index], OUTPUT);
  }

  // LED-Test beim Start:
  // Die LEDs werden nacheinander eingeschaltet,
  // um zu prüfen, ob alle korrekt angeschlossen sind.
  for (int index = 0; index < MAX_LEDS; index++) {
    digitalWrite(leds[index], HIGH);
    delay(250);
  }

  // Kurze Pause, damit der Test sichtbar bleibt
  delay(2000);
}

Schritt 4 – Hilfsfunktionen

Für das Ausschalten aller LEDs sowie für das Visualisieren und Setzen der Geschwindigkeit habe ich jeweils separate Funktionen angelegt. Dadurch bleibt der Code übersichtlich und man sieht immer nur den Teil, der gerade relevant ist.

Diese Aufteilung erleichtert nicht nur das Verständnis, sondern macht den Sketch auch leicht erweiterbar. Möchte man später zum Beispiel die LED-Anzeige ändern oder die Motorsteuerung anpassen, kann das gezielt an einer Stelle erfolgen, ohne den restlichen Code anfassen zu müssen.

Schritt 4.1 – deaktivieren der LEDs

Die LEDs werden in einer Schleife deaktiviert.

// ==============================
// Alle LEDs ausschalten
// ==============================
void resetLEDs() {
  for (int ledIndex = 0; ledIndex < MAX_LEDS; ledIndex++) {
    digitalWrite(leds[ledIndex], LOW);
  }
}

Schritt 4.2 – aktivieren der LEDs

Wie die LEDs deaktiviert werden kann man diese eben auch aktivieren, hier muss lediglich der Pin auf HIGH statt auf LOW gesetzt werden.

// ==============================
// Geschwindigkeit über LEDs anzeigen
// ==============================
// Der ADC-Wert (0–4095) wird auf einen LED-Index (0–4) umgerechnet.
// Es leuchtet genau eine LED als aktuelle Geschwindigkeitsstufe.
void displaySpeed(int value) {
  int ledIndex = map(value, 0, 4095, 0, MAX_LEDS - 1);
  digitalWrite(leds[ledIndex], HIGH);
}

Schritt 4.3 – setzen der Motor Geschwindigkeit

Die Funktion zum setzen der Motor Geschwindigkeit erhält den ausgelesenen Wert des Drehpotentiometers und mappt diesen (0..4095) auf ein PWM Wert (0..255).

// ==============================
// Motorgeschwindigkeit setzen
// ==============================
// Der ADC-Wert wird auf einen PWM-Wert (0–255) gemappt.
// Dieser PWM-Wert steuert das IRF520-MOSFET-Modul.
void setMotorSpeed(int value) {
  int speed = map(value, 0, 4095, 0, 255);
  analogWrite(motor, speed);
}

Schritt 5 – Funktion loop

In der Funktion loop wird zunächst der Wert vom Drehpotentiometer ausgelesen und wenn dieser sich vom letzten Wert unterscheidet dann werden alle LEDs deaktiviert eine passende LED aktiviert sowie die Motorgeschwindigkeit gesetzt.

void loop() {
  // Aktuellen Wert des Drehpotentiometers einlesen
  int resistorValue = analogRead(drehPoti);

  // Nur reagieren, wenn sich der Wert geändert hat
  if (lastValue != resistorValue) {
    resetLEDs();                 // LEDs zurücksetzen
    displaySpeed(resistorValue); // neue LED-Stufe anzeigen
    setMotorSpeed(resistorValue); // Motor-PWM setzen
    lastValue = resistorValue;   // Wert merken
  }

  // Kleine Pause zur Beruhigung der Ausgabe
  delay(50);
}

Am Ende wird noch eine kleine Pause eingelegt diese wird benötigt um den Mikrocontroller etwas zu entlasten.

Kompletter Quellcode

/*
Titel:
ESP32 DC-Motor steuern: PWM + Drehpotentiometer (mit LED-Speedanzeige)

Beschreibung:
In diesem Sketch wird gezeigt, wie sich ein DC-Motor mit einem ESP32
per PWM-Signal steuern lässt. Die Drehzahl wird über ein
Drehpotentiometer vorgegeben und zusätzlich über 5 LEDs visualisiert.

Der Motor wird nicht direkt vom ESP32 angesteuert, sondern über ein
externes MOSFET-Modul (z. B. IRF520). Der ESP32 erzeugt lediglich das
PWM-Steuersignal.

Ausführliche Anleitung inkl. Schaltung:
https://draeger-it.blog/esp32-programmieren-dc-motor-mit-pwm-und-drehpotentiometer-steuern/

Autor:
Stefan Draeger
*/

// ==============================
// LED-Pins (Geschwindigkeitsanzeige)
// ==============================
#define led1 18
#define led2 23
#define led3 12
#define led4 17
#define led5 26

// ==============================
// Drehpotentiometer (ADC-Eingang)
// ==============================
#define drehPoti 2

// ==============================
// Motor-Pin (PWM-Ausgang → IRF520 SIG)
// ==============================
#define motor 4

// Anzahl der verwendeten LEDs
const int MAX_LEDS = 5;

// Array für die LEDs, damit sie bequem per Schleife angesteuert werden können
int leds[MAX_LEDS] = { led1, led2, led3, led4, led5 };

// Speichert den letzten Poti-Wert, um unnötige Updates zu vermeiden
int lastValue = -1;

void setup() {
  // Alle LEDs als Ausgang konfigurieren
  for (int index = 0; index < MAX_LEDS; index++) {
    pinMode(leds[index], OUTPUT);
  }

  // LED-Test beim Start:
  // Die LEDs werden nacheinander eingeschaltet,
  // um zu prüfen, ob alle korrekt angeschlossen sind.
  for (int index = 0; index < MAX_LEDS; index++) {
    digitalWrite(leds[index], HIGH);
    delay(250);
  }

  // Kurze Pause, damit der Test sichtbar bleibt
  delay(2000);
}

// ==============================
// Alle LEDs ausschalten
// ==============================
void resetLEDs() {
  for (int ledIndex = 0; ledIndex < MAX_LEDS; ledIndex++) {
    digitalWrite(leds[ledIndex], LOW);
  }
}

// ==============================
// Geschwindigkeit über LEDs anzeigen
// ==============================
// Der ADC-Wert (0–4095) wird auf einen LED-Index (0–4) umgerechnet.
// Es leuchtet genau eine LED als aktuelle Geschwindigkeitsstufe.
void displaySpeed(int value) {
  int ledIndex = map(value, 0, 4095, 0, MAX_LEDS - 1);
  digitalWrite(leds[ledIndex], HIGH);
}

// ==============================
// Motorgeschwindigkeit setzen
// ==============================
// Der ADC-Wert wird auf einen PWM-Wert (0–255) gemappt.
// Dieser PWM-Wert steuert das IRF520-MOSFET-Modul.
void setMotorSpeed(int value) {
  int speed = map(value, 0, 4095, 0, 255);
  analogWrite(motor, speed);
}

void loop() {
  // Aktuellen Wert des Drehpotentiometers einlesen
  int resistorValue = analogRead(drehPoti);

  // Nur reagieren, wenn sich der Wert geändert hat
  if (lastValue != resistorValue) {
    resetLEDs();                 // LEDs zurücksetzen
    displaySpeed(resistorValue); // neue LED-Stufe anzeigen
    setMotorSpeed(resistorValue); // Motor-PWM setzen
    lastValue = resistorValue;   // Wert merken
  }

  // Kleine Pause zur Beruhigung der Ausgabe
  delay(50);
}

Fazit & Ausblick

Wie du in diesem Beitrag gesehen hast, ist das Steuern eines DC-Motors mit dem ESP32 deutlich einfacher, als es auf den ersten Blick wirkt. Mit wenigen Zeilen Code, einem PWM-Signal und einem passenden MOSFET-Modul lässt sich die Motordrehzahl zuverlässig und sicher regeln.

Im nächsten Beitrag greife ich dieses Projekt erneut auf und setze es in MicroPython um. Dadurch hast du beide Varianten – die Programmierung in der Arduino IDE und in MicroPython – direkt zum Vergleich an der Hand und kannst selbst entscheiden, welcher Ansatz für deine Projekte besser geeignet ist.

FAQ – Häufige Fragen zum DC-Motor am ESP32

Kann ich auch einen anderen ESP32 statt des ESP32 D1 R32 verwenden?

Ja, absolut. In diesem Beitrag habe ich den ESP32 D1 R32 verwendet, das Projekt funktioniert jedoch mit jedem gängigen ESP32-Mikrocontroller. Wichtig ist lediglich, dass:

• ein PWM-fähiger GPIO-Pin vorhanden ist,
• ein ADC-Pin für das Drehpotentiometer genutzt wird,
• und der Mikrocontroller mit 3,3 V Logikpegeln arbeitet.

Die Pinbelegung kann sich je nach Board unterscheiden, das Grundprinzip und der Code bleiben jedoch identisch.

Welchen Motor verwendest du in diesem Projekt?

Ich nutze einen TT-DC-Motor, wie er häufig in 2WD-Arduino-Roboterbausätzen enthalten ist. Diese Motoren sind günstig, robust und ideal für erste Motorprojekte mit Mikrocontrollern.

Ein großer Vorteil:
Für diese Motoren gibt es zahlreiche 3D-Druck-Modelle, zum Beispiel für:

• Linearantriebe
• kleine Roboterfahrwerke
• Testaufbauten für den Schreibtisch

Damit lassen sich schnell stabile und optisch ansprechende Aufbauten realisieren.

Wo bekomme ich die verwendeten Bauteile?

Die im Beitrag verwendeten Komponenten sind weit verbreitet und leicht erhältlich. Du findest sie nicht nur bei eBay (siehe verlinkte Artikel), sondern auch bei Plattformen wie AliExpress oder anderen Elektronik-Shops.

Gerade bei einfachen Bauteilen wie:

• DC-Motoren
• MOSFET-Modulen
• Drehpotentiometern

lohnt sich ein Vergleich, da die Preise teils stark variieren.

Kann ich auch einen anderen MOSFET oder ein anderes Modul verwenden?

Ja. Das IRF520-Modul eignet sich gut für einfache Einsteigerprojekte. Alternativ kannst du auch:

• andere MOSFET-Module
• oder spezielle Motortreiber

verwenden, solange diese ein PWM-Steuersignal akzeptieren und für die benötigte Motorleistung ausgelegt sind. Das grundlegende Prinzip bleibt dabei gleich.

Warum wird der Motor nicht direkt am ESP32 angeschlossen?

Ein DC-Motor benötigt deutlich mehr Strom als ein GPIO-Pin des ESP32 liefern kann – insbesondere beim Anlauf oder unter mechanischer Last.
Ein direkter Anschluss kann den Mikrocontroller beschädigen. Deshalb übernimmt das MOSFET-Modul die Leistungsseite, während der ESP32 nur das Steuersignal liefert.

Lässt sich das Projekt erweitern?

Ja, sehr einfach sogar. Typische Erweiterungen sind zum Beispiel:

• eine Richtungssteuerung (Vorwärts / Rückwärts)
• eine Anzeige per OLED oder Display
• eine Web-Oberfläche zur Steuerung
• oder – wie im nächsten Beitrag gezeigt – die Umsetzung in MicroPython

Letzte Aktualisierung am: 30. Dezember 2025