Ratgeber · 9 Min. Lesezeit

ESP32 WLAN Auto bauen: Steuerung per Handy-Joystick (L298N)

ESP32 WLAN Auto mit eigenem Access Point: Web-Joystick im Handy-Browser, L298N-Motortreiber mit PWM, Teileliste mit Kosten und Not-Stopp bei Verbindungsabbruch.

Ein ESP32 WLAN Auto ist ein Roboterauto, das du mit einer Joystick-Seite im Browser deines Handys steuerst, ganz ohne App. Der ESP32 spannt sein eigenes WLAN auf (softAP), dein Handy verbindet sich damit, und sobald du 192.168.4.1 in den Browser tippst, erscheint ein Joystick. Während du den Finger bewegst, beschleunigt, bremst und lenkt der ESP32 zwei Getriebemotoren per PWM über einen L298N-Motortreiber. Du brauchst weder Router noch Internet noch Bluetooth-Kopplung, und es funktioniert auf Android und iPhone gleich.

In dieser Anleitung bauen wir das Auto von Anfang bis Ende: Teileliste und ungefähre Kosten, Verdrahtungstabelle ESP32–L298N, ein erster Sketch, der die Motoren ohne WLAN testet, der Hauptsketch, der die Joystick-Seite im ESP32 speichert, und wie aus der Joystick-Position die Geschwindigkeit der beiden Räder wird. Außerdem bauen wir eine Sicherheitsfunktion ein, die fast alle Beispiele vergessen: Reißt die Verbindung ab, bleibt das Auto innerhalb einer halben Sekunde von selbst stehen. Der Code kompiliert mit Version 2.x und 3.x des ESP32-Arduino-Cores.

ESP32
ESP32
L298N
L298N
TT motor
TT motor
18650 Li-ion
18650 Li-ion

Wie funktioniert ein ESP32 WLAN Auto?

Das System besteht aus vier Teilen. Der ESP32 ist Gehirn und kleiner Webserver zugleich: Er schickt die Joystick-Seite ans Handy und setzt danach die Befehle "linker Motor so schnell, rechter Motor so schnell" um, die zehnmal pro Sekunde eintreffen. Der L298N ist eine doppelte H-Brücke; er macht aus den schwachen 3,3-V-Signalen des ESP32 den Strom, den die Motoren brauchen. Zwei gelbe TT-Getriebemotoren treiben die Räder an; eine Lenkung gibt es nicht, das Auto dreht über den Geschwindigkeitsunterschied der beiden Räder (Differentialantrieb). Zwei 18650-Akkus versorgen die Motoren und über den 5-V-Regler auf dem L298N-Board auch den ESP32. Im softAP-Modus verhält sich der ESP32 wie ein Router und gibt sich immer die Adresse 192.168.4.1, deshalb kannst du das Auto im Garten, in der Schule oder überall ohne Router fahren.

WLAN softAP (diese Anleitung)Heim-WLAN (STA)Bluetooth (HC-05 oder klassisches BT)
Router nötig?NeinJaNein
App auf dem HandyNicht nötig, der Browser reichtNicht nötig, der Browser reichtEine Bluetooth-Terminal-App ist nötig
iPhone-UnterstützungJaJaNein (iOS unterstützt kein serielles klassisches Bluetooth)
Reichweite im FreienEtwa 30–50 mSo weit das Router-WLAN reichtEtwa 10–20 m
BefehlsverzögerungEtwa 20–50 ms20–100 ms je nach NetzlastEtwa 20–40 ms

Teileliste und Kosten

TeilAnzahlPreis ca. (USD)Hinweis
ESP32 DevKit V1 (30 oder 38 Pins)14–7Die verwendeten GPIOs gibt es auf beiden Boards
L298N-Motortreiber-Modul12–42 A pro Kanal; steuert zwei Motoren getrennt
2WD-Roboterauto-Chassis-Bausatz18–15Meist mit 2 TT-Motoren, 2 Rädern, Stützrad und Schalter
18650-Li-Ion-Akku26–12Markenzellen mit mindestens 5 A Entladestrom
Halter für 2 × 18650 (in Reihe)11–2Ein Modell mit Schalter vereinfacht die Verdrahtung
18650-Ladegerät13–10Lädt jede Zelle einzeln
Jumper-Kabel (Buchse-Buchse, Stecker-Buchse)10+1–3Zwischen ESP32 und L298N
Kondensatoren 470 µF / 16 V und 100 nF1 + 2Unter 1Gegen Spannungseinbrüche und Motorstörungen
Summe25–5015–25, wenn du Akkus und Ladegerät schon hast

Die Preise sind typische Werte aus Online-Elektronikshops und schwanken je nach Land, Versand und Wechselkurs; in Euro landest du ungefähr im gleichen Zahlenbereich. Die größten Posten sind Chassis und Akkus. Spare nicht an den Akkus: Sehr billige Zellen mit der Aufschrift "9900 mAh" sind fast immer Fälschungen, ihre Spannung bricht beim Anfahren ein und der ESP32 startet neu. Hast du schon einen Arduino-Roboterauto-Bausatz, musst du nur einen ESP32 kaufen; Chassis, Motoren und L298N bleiben gleich. Wie du die richtigen Zellen wählst, erklären wir in 18650-Li-Ion-Akku.

Verdrahtung: ESP32, L298N und Motoren

L298NESP32Beschreibung
ENAGPIO 25Geschwindigkeit linker Motor (PWM); ENA-Jumper abziehen
IN1GPIO 26Drehrichtung linker Motor
IN2GPIO 27Drehrichtung linker Motor
ENBGPIO 33Geschwindigkeit rechter Motor (PWM); ENB-Jumper abziehen
IN3GPIO 18Drehrichtung rechter Motor
IN4GPIO 19Drehrichtung rechter Motor
+12V (VS)–Plus des 2×18650-Packs (hinter dem Schalter)
GNDGNDAkku-Minus und ESP32-GND; gemeinsame Masse ist Pflicht
+5VVIN (5V)Versorgt den ESP32 aus dem L298N-Regler, solange der 5V-EN-Jumper steckt
OUT1 / OUT2–Linker Motor
OUT3 / OUT4–Rechter Motor

Die Logikeingänge des L298N werten alles über 2,3 V als HIGH, deshalb lassen sich die 3,3-V-Ausgänge des ESP32 ohne Pegelwandler direkt anschließen. Voll geladen liefert der Pack 8,4 V; der L298N verliert davon intern 1,5–3 V, an den Motoren kommen 5–6 V an, genau der ideale Bereich für TT-Motoren. Der 78M05-Regler auf dem Modul macht aus demselben Pack 5 V und versorgt den ESP32 über VIN. Auch die Pinwahl ist kein Zufall: GPIO 0, 2, 12 und 15 sind Strapping-Pins, die den Boot-Modus festlegen, 6–11 sind für den Flash-Speicher reserviert und 34–39 sind reine Eingänge. 25, 26, 27, 33, 18 und 19 sind sichere Ausgänge, die es auf 30- und 38-Pin-Boards gibt. Warum die Masse gemeinsam sein muss, erklären wir in GND und gemeinsame Masse.

Solange der ESP32 am USB hängt, zieh das +5V-Kabel des L298N von VIN ab oder schalte den Akku aus; zwei 5-V-Quellen gleichzeitig können bei manchen Boards Strom zurück in den USB-Port des Computers drücken. Schließ das Akku-Plus auch nie direkt an den ESP32 an: 8,4 V am 3V3-Pin zerstören das Board sofort, und 8,4 V an VIN überhitzen den AMS1117-Regler auf dem Board.

Aufbau Schritt für Schritt

  1. Installiere im Boardverwalter der Arduino IDE esp32 by Espressif Systems und wähle als Board ESP32 Dev Module.
  2. Schraube die Motoren ans Chassis; schließe ihre Kabel an die Schraubklemmen OUT1-OUT2 (links) und OUT3-OUT4 (rechts) des L298N an.
  3. Zieh die ENA- und ENB-Jumper am L298N ab; der 5V-EN-Jumper bleibt stecken.
  4. Verbinde die sechs Signalleitungen aus der Tabelle und die gemeinsame Masse mit Buchse-Buchse-Jumperkabeln.
  5. Stell das Auto auf eine Schachtel, damit die Räder frei drehen; lade den Motortest hoch und prüfe die Drehrichtungen.
  6. Lade den Hauptsketch hoch, öffne den seriellen Monitor mit 115200 Baud und notiere die angezeigte Adresse.
  7. Verbinde das Handy in den WLAN-Einstellungen mit dem Netz BlueGrays-Car (Passwort 12345678) und tippe 192.168.4.1 in den Browser.
  8. Schieb den Joystick vorsichtig an; drehen die Räder richtig herum, stell das Auto auf den Boden und fahr los.

Zuerst die Motoren testen

Bevor du zum WLAN-Code wechselst, prüfst du die Verdrahtung mit diesem kurzen Sketch. Er setzt ENA und ENB dauerhaft auf HIGH, die Motoren laufen also mit voller Geschwindigkeit: eine Sekunde vorwärts, dann rückwärts, dann auf der Stelle nach links und rechts. Dreht sich beim Vorwärtsbefehl ein Rad rückwärts, lass den Code in Ruhe und tausche die beiden Kabel dieses Motors am L298N. Dreht sich gar nichts, prüfe den Akkuschalter, die gemeinsame Masse und die ENA- und ENB-Leitungen.

C++ (Arduino IDE)
1// L298N bağlantı testi (Wi-Fi yok) / L298N wiring test (no Wi-Fi)
2// Sol motor / left motor: ENA=25, IN1=26, IN2=27 — Sağ motor / right motor: ENB=33, IN3=18, IN4=19
3const int ENA = 25, IN1 = 26, IN2 = 27;
4const int ENB = 33, IN3 = 18, IN4 = 19;
5
6void wheels(int l1, int l2, int r1, int r2) {
7  digitalWrite(IN1, l1); digitalWrite(IN2, l2);
8  digitalWrite(IN3, r1); digitalWrite(IN4, r2);
9}
10
11void setup() {
12  int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4};
13  for (int p : pins) pinMode(p, OUTPUT);
14  digitalWrite(ENA, HIGH);                 // tam hız, PWM yok / full speed, no PWM
15  digitalWrite(ENB, HIGH);
16  wheels(LOW, LOW, LOW, LOW);
17  delay(3000);                             // tekerlekleri havaya kaldır / lift the wheels
18}
19
20void loop() {
21  wheels(HIGH, LOW, HIGH, LOW); delay(1000);   // ileri / forward
22  wheels(LOW, LOW, LOW, LOW);   delay(500);    // dur / stop
23  wheels(LOW, HIGH, LOW, HIGH); delay(1000);   // geri / backward
24  wheels(LOW, LOW, LOW, LOW);   delay(500);
25  wheels(LOW, HIGH, HIGH, LOW); delay(700);    // yerinde sola / spin left
26  wheels(HIGH, LOW, LOW, HIGH); delay(700);    // yerinde sağa / spin right
27  wheels(LOW, LOW, LOW, LOW);   delay(2000);
28}

Hauptsketch: ein Auto mit eigenem WLAN (softAP)

Im Hauptprogramm steckt die Joystick-Seite als ein einziger Text aus HTML, CSS und JavaScript direkt im ESP32. Du musst keine Dateien hochladen und keine Bibliotheken installieren; es werden nur WiFi und WebServer verwendet, die mit dem ESP32-Paket kommen. Ist die Seite offen, schickt der Browser alle 100 ms eine winzige Anfrage wie /d?l=60&r=-60; der ESP32 liest die beiden Zahlen, gibt sie an die Motoren weiter und merkt sich den Zeitpunkt des Befehls.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* AP_SSID = "BlueGrays-Car";      // telefonda görünecek ağ adı / network name on the phone
5const char* AP_PASS = "12345678";           // en az 8 karakter / at least 8 characters
6
7// Sol motor / left motor: ENA=25, IN1=26, IN2=27 — Sağ motor / right motor: ENB=33, IN3=18, IN4=19
8const int ENA = 25, IN1 = 26, IN2 = 27;
9const int ENB = 33, IN3 = 18, IN4 = 19;
10
11const int PWM_FREQ = 1000;                  // Hz
12const int PWM_RES = 8;                      // 8 bit: 0-255
13const int MIN_DUTY = 90;                    // motorun kıpırdadığı en düşük değer / lowest duty that moves the motor
14const unsigned long FAILSAFE_MS = 500;      // bu süre komut gelmezse dur / stop if no command for this long
15
16WebServer server(80);
17unsigned long lastCmd = 0;
18
19const char PAGE[] PROGMEM = R"rawliteral(
20<!DOCTYPE html><html><head><meta charset="utf-8">
21<meta name="viewport" content="width=device-width,initial-scale=1,user-scalable=no">
22<title>BlueGrays Car</title>
23<style>
24body{margin:0;background:#0f172a;color:#e2e8f0;font-family:sans-serif;text-align:center;touch-action:none;user-select:none}
25#pad{width:260px;height:260px;margin:24px auto;border-radius:50%;background:#1e293b;position:relative}
26#knob{width:90px;height:90px;border-radius:50%;background:#38bdf8;position:absolute;left:85px;top:85px}
27input{width:220px}
28</style></head><body>
29<h3>BlueGrays Wi-Fi Car</h3>
30<div id="pad"><div id="knob"></div></div>
31<p>Max <input id="sp" type="range" min="30" max="100" value="80"></p>
32<p id="st">0 / 0</p>
33<script>
34const pad=document.getElementById('pad'),knob=document.getElementById('knob'),R=85;
35let x=0,y=0,busy=false,drag=false;
36function put(dx,dy){knob.style.left=(85+dx)+'px';knob.style.top=(85+dy)+'px';}
37function move(e){const b=pad.getBoundingClientRect(),t=e.touches?e.touches[0]:e;
38 let dx=t.clientX-b.left-130,dy=t.clientY-b.top-130,d=Math.hypot(dx,dy);
39 if(d>R){dx*=R/d;dy*=R/d;}
40 put(dx,dy);x=Math.round(dx/R*100);y=Math.round(-dy/R*100);e.preventDefault();}
41function end(){drag=false;x=0;y=0;put(0,0);}
42pad.addEventListener('touchstart',move,{passive:false});
43pad.addEventListener('touchmove',move,{passive:false});
44pad.addEventListener('touchend',end);
45pad.addEventListener('mousedown',e=>{drag=true;move(e);});
46document.addEventListener('mousemove',e=>{if(drag)move(e);});
47document.addEventListener('mouseup',end);
48setInterval(()=>{if(busy)return;busy=true;
49 const s=document.getElementById('sp').value/100;
50 const l=Math.round(Math.max(-100,Math.min(100,y+x))*s);
51 const r=Math.round(Math.max(-100,Math.min(100,y-x))*s);
52 document.getElementById('st').textContent=l+' / '+r;
53 fetch('/d?l='+l+'&r='+r).catch(()=>{}).finally(()=>{busy=false;});},100);
54</script></body></html>
55)rawliteral";
56
57void setMotor(int pwmPin, int channel, int inA, int inB, int speed) {   // speed: -100 … 100
58  speed = constrain(speed, -100, 100);
59  digitalWrite(inA, speed > 0);
60  digitalWrite(inB, speed < 0);
61  int duty = (speed == 0) ? 0 : map(abs(speed), 1, 100, MIN_DUTY, 255);
62#if ESP_ARDUINO_VERSION_MAJOR >= 3
63  ledcWrite(pwmPin, duty);                  // 3.x: pin numarasıyla / by pin number
64#else
65  ledcWrite(channel, duty);                 // 2.x: kanal numarasıyla / by channel number
66#endif
67}
68
69void drive(int left, int right) {
70  setMotor(ENA, 0, IN1, IN2, left);
71  setMotor(ENB, 1, IN3, IN4, right);
72}
73
74void handleDrive() {
75  drive(server.arg("l").toInt(), server.arg("r").toInt());
76  lastCmd = millis();
77  server.send(200, "text/plain", "ok");
78}
79
80void setup() {
81  Serial.begin(115200);
82  int pins[] = {IN1, IN2, IN3, IN4};
83  for (int p : pins) pinMode(p, OUTPUT);
84#if ESP_ARDUINO_VERSION_MAJOR >= 3
85  ledcAttach(ENA, PWM_FREQ, PWM_RES);
86  ledcAttach(ENB, PWM_FREQ, PWM_RES);
87#else
88  ledcSetup(0, PWM_FREQ, PWM_RES); ledcAttachPin(ENA, 0);
89  ledcSetup(1, PWM_FREQ, PWM_RES); ledcAttachPin(ENB, 1);
90#endif
91  drive(0, 0);
92
93  WiFi.softAP(AP_SSID, AP_PASS);            // kendi Wi-Fi ağını kurar / creates its own Wi-Fi network
94  Serial.print("Adres / address: http://");
95  Serial.println(WiFi.softAPIP());          // 192.168.4.1
96
97  server.on("/", []() { server.send(200, "text/html", PAGE); });
98  server.on("/d", handleDrive);
99  server.begin();
100}
101
102void loop() {
103  server.handleClient();
104  if (millis() - lastCmd > FAILSAFE_MS) drive(0, 0);   // bağlantı koptu: dur / link lost: stop
105}
ZeileWas sie macht
WiFi.softAP(AP_SSID, AP_PASS)Macht den ESP32 zum Access Point; das Passwort braucht mindestens 8 Zeichen, sonst entsteht kein Netz
PAGE[] = R"rawliteral(…)rawliteral"Die komplette Joystick-Seite; als Raw-String musst du keine Anführungszeichen maskieren
server.on("/d", handleDrive)Liest die Werte l und r (-100 … 100) aus dem Browser und gibt sie an die Motoren
map(abs(speed), 1, 100, MIN_DUTY, 255)Lässt selbst die kleinste Geschwindigkeit beim niedrigsten PWM-Wert beginnen, der den Motor bewegt
ledcAttach / ledcSetup + ledcAttachPinRichtet PWM passend zur Core-Version ein (3.x / 2.x)
millis() - lastCmd > FAILSAFE_MSStoppt beide Motoren, wenn 500 ms lang kein Befehl kommt

Wie wird aus dem Joystick Motorgeschwindigkeit?

Der Joystick auf der Seite misst die Position deines Fingers relativ zur Mitte als x (links-rechts) und y (vor-zurück) zwischen -100 und 100. Eine einfache Mischung namens Panzersteuerung ergibt die Geschwindigkeit der Räder: links = y + x, rechts = y − x. Überschreitet das Ergebnis ±100, wird es begrenzt und dann mit dem Höchsttempo-Prozentwert des Schiebereglers multipliziert. Auf dem ESP32 wird dieser Prozentwert zu einem PWM-Wert. Dabei gibt es einen kleinen, aber wichtigen Trick: TT-Motoren brummen unter einem PWM-Wert von etwa 80–90, drehen aber nicht. Deshalb verteilt der Code 1–100 nicht auf 0–255, sondern auf MIN_DUTY–255; 50 % Geschwindigkeit sind zum Beispiel map(50, 1, 100, 90, 255) = 171. Bewegt sich dein Auto bei niedriger Geschwindigkeit gar nicht, erhöhe MIN_DUTY in Zehnerschritten; schießt es schon bei leichtem Antippen los, senke den Wert.

Joystick (x, y)LinksRechtsWas das Auto macht
(0, 100)100100Volle Fahrt vorwärts
(0, -100)-100-100Volle Fahrt rückwärts
(100, 0)100-100Dreht auf der Stelle nach rechts
(-100, 0)-100100Dreht auf der Stelle nach links
(50, 100)10050Fährt vorwärts in einer sanften Rechtskurve
(0, 0)00Bleibt stehen

PWM-Geschwindigkeit: ESP32-Core 2.x und 3.x im Vergleich

Beim ESP32 erzeugt eine Hardware-Einheit namens LEDC das PWM-Signal. Der Code nutzt 1 kHz und 8 Bit Auflösung, das Tastverhältnis reicht also von 0 bis 255. Die bipolaren Transistoren im L298N schalten langsam; mehr als ein paar kHz machen den Motor nicht schneller, sondern heizen nur den Treiber stärker auf. Das leise Pfeifen bei 1 kHz ist normal. Mit Version 3.0 des ESP32-Arduino-Cores haben sich die PWM-Funktionen geändert: Das alte Paar ledcSetup(Kanal, Frequenz, Auflösung) und ledcAttachPin(Pin, Kanal) wurde durch ein einziges ledcAttach(Pin, Frequenz, Auflösung) ersetzt, und ledcWrite erwartet jetzt die Pinnummer statt des Kanals. Die Zeilen #if ESP_ARDUINO_VERSION_MAJOR >= 3 im Code wählen die passende Funktion, egal welche Version du nutzt. Die PWM-Grundlagen findest du in Was ist PWM.

Auto bei Verbindungsabbruch stoppen (Failsafe)

Bei einem per WLAN gesteuerten Fahrzeug ist der gefährlichste Moment der Funkabriss. Der Handy-Bildschirm sperrt sich, der Browser-Tab rutscht in den Hintergrund oder das Auto fährt aus der Reichweite; führt der ESP32 den letzten Befehl weiter aus, rast das Auto mit voller Geschwindigkeit gegen die Wand oder die Treppe hinunter. In diesem Code schickt die Seite auch bei ruhendem Joystick alle 100 ms einen Befehl und sendet 0 / 0, sobald du den Finger hebst. Der ESP32 speichert bei jedem Befehl die Zeit in lastCmd, und loop() prüft bei jedem Durchlauf, wie alt der letzte Befehl ist. Kommt 500 ms lang keine neue Anfrage, gehen also fünf Befehle hintereinander verloren, stoppen die Motoren. Das busy-Flag im Browser verhindert außerdem, dass sich Anfragen bei langsamem Netz stapeln; eine neue wird erst nach der Antwort gesendet, so wird kein alter Befehl verspätet ausgeführt.

Zum Testen des Failsafe schiebst du den Joystick bei frei drehenden Rädern nach vorn und schaltest dabei das WLAN des Handys aus; die Räder müssen innerhalb einer halben Sekunde stehen. Ruckelt das Auto in einem vollen Funknetz, kannst du FAILSAFE_MS auf 800 ms erhöhen.

Variante im Heim-WLAN (STA-Modus)

Fährst du das Auto zu Hause, kannst du den ESP32 auch mit deinem Router verbinden. Dann bleibt das Handy in seinem gewohnten WLAN und behält das Internet; die Reichweite ist aber auf die Router-Abdeckung begrenzt, und der ESP32 bekommt die IP, die der Router vergibt. Ersetze dazu in setup() die Zeile WiFi.softAP durch den folgenden Ausschnitt. WiFi.setSleep(false) schaltet den Modem-Schlaf des ESP32 ab; ohne diese Zeile können Befehle gelegentlich 100–200 ms verspätet ankommen. Bei Verbindungsproblemen hilft ESP32 verbindet sich nicht mit dem WLAN.

C++ (Arduino IDE)
1// setup() içinde WiFi.softAP(...) satırının yerine / in setup(), instead of the WiFi.softAP(...) line
2WiFi.mode(WIFI_STA);
3WiFi.begin("EvAgim", "sifre123");          // ev ağının adı ve şifresi / your home network name and password
4while (WiFi.status() != WL_CONNECTED) delay(300);
5WiFi.setSleep(false);                      // modem uykusunu kapat, gecikme düşer / disable modem sleep, lower latency
6Serial.println(WiFi.localIP());            // tarayıcıya bu adresi yaz / type this address in the browser

Reichweite, Verzögerung und Handy-Einstellungen

  • Hinweis "Kein Internet": Das Handy meldet, dass das Netz BlueGrays-Car kein Internet hat; wähle "Verbindung beibehalten". Ist bei Android der automatische Wechsel zu mobilen Daten aktiv, kann das Handy das Netz verlassen; mobile Daten während der Fahrt auszuschalten ist die einfachste Lösung.
  • Reichweite: Mit der PCB-Antenne auf dem Board sind im Freien 30–50 m und im Haus durch ein, zwei Wände 10–20 m zu erwarten. Lass die Antenne am Rand des Boards frei liegen, weg von Metallteilen und den Akkus.
  • Kanal: Sind viele Netze in der Nähe, wähle mit einem dritten Parameter wie WiFi.softAP(AP_SSID, AP_PASS, 6) den freiesten der Kanäle 1, 6 oder 11.
  • Verzögerung: HTTP-Anfragen dauern im softAP meist 20–50 ms, mehr als genug zum Fahren. Für flüssigere Steuerung oder um Daten vom Auto ans Handy zu schicken (Akkuspannung, Abstand), wechsle zu WebSocket; ESP32-Webserver und WebSocket erklärt das Schritt für Schritt.
  • Nur ein Fahrer: Verbinden sich zwei Handys und nutzen gleichzeitig den Joystick, vermischen sich die Befehle. Ändere das Passwort, damit das Auto nur dir gehorcht.

Häufige Fehler und Lösungen

SymptomWahrscheinliche UrsacheLösung
Der ESP32 startet neu, wenn die Motoren anlaufenDie Akkuspannung bricht kurz ein (Brownout)Gute 18650-Zellen verwenden; 470 µF am L298N-Eingang und 100 nF an den Motorklemmen ergänzen
Kompilierfehler "'ledcSetup' was not declared"ESP32-Core 3.x, der Code nutzt die alten PWM-FunktionenDen Code aus dieser Anleitung mit der Weiche #if ESP_ARDUINO_VERSION_MAJOR verwenden
Das Auto bewegt sich bei niedriger Geschwindigkeit nichtDer PWM-Wert liegt unter der Anlaufschwelle des MotorsMIN_DUTY auf 100–120 erhöhen
Ein Rad dreht falsch herumDie Motorkabel sind vertauschtDie beiden Kabel dieses Motors am L298N tauschen
Das Auto fährt immer VollgasDie ENA-/ENB-Jumper stecken nochJumper abziehen und die Pins mit GPIO 25 und 33 verbinden
192.168.4.1 lässt sich nicht öffnenDas Handy hat das Netz verlassen oder nutzt mobile DatenMobile Daten aus, neu verbinden und die Adresse mit http:// eingeben
Das Auto ruckeltÜberfüllter WLAN-Kanal oder schwaches SignalKanal wechseln, Antenne frei lassen, FAILSAFE_MS etwas erhöhen
Der L298N wird sehr heißDie Motoren arbeiten ständig unter Last oder ein Rad klemmtPrüfen, ob die Räder frei laufen; einen effizienteren Treiber (TB6612FNG) erwägen

Ideen zum Ausbau deines Autos

  • Kollisionsbremse: Setz einen HC-SR04 nach vorn und ignoriere Vorwärtsbefehle, wenn ein Hindernis näher als 20 cm ist. Wie der Sensor funktioniert, steht in HC-SR04 Ultraschallsensor.
  • Autonomer Modus: Füge der Seite einen Knopf hinzu; auf Druck fährt das Auto selbstständig wie ein Hindernis ausweichender Roboter.
  • Akkuanzeige: Miss die Pack-Spannung mit einem Spannungsteiler aus zwei Widerständen an einem Analogpin und zeig sie auf der Joystick-Seite an.
  • Kabellose Updates: Mit ESP32 OTA lädst du neuen Code hoch, ohne jedes Mal ein USB-Kabel einzustecken.
  • Echte Fernbedienung: Fahr ohne Handy mit einem zweiten ESP32 und einem Joystick-Modul über ESP-NOW.
  • Beleuchtung: Bau vorn und hinten WS2812B-LEDs ein; beim Rückwärtsfahren leuchten die Rücklichter rot.

Ein ESP32 WLAN Auto ist ein tolles Einstiegsprojekt, das Webserver, PWM, Motortreiber und sichere Steuerlogik auf einmal vermittelt. Die gleiche Joystick-Seite kannst du später für einen Roboterarm oder ein Kamera-Auto weiterverwenden. Wenn du wissen willst, wie der Motortreiber innen arbeitet, lies Gleichstrommotor mit L298N steuern; die Arduino-Variante mit Bluetooth findest du in Arduino-Roboterauto bauen. In der BlueGrays-App gibt es außerdem das Bluetooth-Auto mit L298N, den Hindernis ausweichenden Roboter und die ESP32-Webserver-Projekte mit Schaltplänen und Code Schritt für Schritt.

Häufige Fragen

Braucht ein ESP32 WLAN Auto Internet?

Nein. Im softAP-Modus spannt der ESP32 sein eigenes Funknetz auf, und das Handy verbindet sich direkt damit; weder Router noch Internet sind nötig. Die Joystick-Seite liegt im Speicher des ESP32 und öffnet sich deshalb komplett offline.

Welche Reichweite hat ein ESP32 WLAN Auto?

Mit der PCB-Antenne auf dem Board meist 30–50 m im Freien und je nach Wänden 10–20 m im Haus. Module mit Anschluss für eine externe Antenne, etwa der ESP32-WROOM-32U, vergrößern die Reichweite deutlich.

Funktioniert der L298N mit den 3,3 V des ESP32?

Ja. Die Eingänge des L298N werten alles über 2,3 V als HIGH, daher lassen sich die ESP32-Pins direkt an IN1–IN4 und ENA–ENB anschließen. Wichtig ist nur, dass die Masse beider Boards verbunden ist.

Brauche ich eine App auf dem Handy, um das Auto zu steuern?

Nein. Der Joystick ist eine Webseite, die der ESP32 ausliefert, und läuft in jedem Browser wie Chrome, Safari oder Firefox. Deshalb funktioniert er auf Android-Handys, iPhones, Tablets und Computern gleich.

Warum startet mein ESP32 neu, wenn die Motoren anlaufen?

Beim Anlaufen ziehen die Motoren kurz mehrere Ampere, und die Spannung schwacher Akkus bricht für einen Moment ein; der ESP32 erkennt einen Brownout und startet neu. Gute 18650-Zellen, 470 µF am L298N-Eingang und 100 nF an den Motorklemmen beheben das meist.

Ist Bluetooth oder WLAN besser für ein Roboterauto?

WLAN braucht keine App, funktioniert auch mit dem iPhone und hat mehr Reichweite. Klassisches Bluetooth (HC-05 oder BluetoothSerial des ESP32) bietet eine schlanke Verbindung, ist aber an Android und eine Terminal-App gebunden. Für ein per Handy gesteuertes ESP32-Auto ist WLAN meist die praktischere Wahl.

Alle Projekte ansehen
Bluetooth-gesteuertes Auto mit L298N
AR-80Fortgeschritten
Premium

Bluetooth-gesteuertes Auto mit L298N

Mach dein Handy zur Fernbedienung und steuere dein eigenes Roboterauto. Der Arduino empfängt über ein Bluetooth-Modul die Befehle einer Fernsteuer-App auf dem Handy und treibt die Räder über einen…

5.0(39)
66
Roboter zur Hindernisvermeidung
AR-81Fortgeschritten
Premium

Roboter zur Hindernisvermeidung

Wie wäre es, ein intelligentes Fahrzeug zu bauen, das seinen Weg selbst findet? Der Obstacle Avoiding Robot scannt dank des Ultraschallsensors vor ihm ständig seine Umgebung.

5.0(38)
49
ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
ES-27Fortgeschritten

ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)

Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

4.8(16)
26
ESP32-WebSocket-Zähler (2 Tasten + LCD + Web-Echtzeit)
ES-28Fortgeschritten
Premium

ESP32-WebSocket-Zähler (2 Tasten + LCD + Web-Echtzeit)

In diesem Projekt ändern zwei am ESP32 angeschlossene Taster (GPIO 5 zählt hoch, GPIO 4 zählt herunter) einen Zähler. Der Wert wird sofort auf einem 16x2-I2C-LCD und über die WebSocket-Unterstützung von ESPAsyncWebServer in allen verbundenen Browsern aktualisiert, ohne die Seite neu zu laden. Statt HTTP-Polling wird eine einzige dauerhafte Verbindung genutzt; der ESP32 sendet den neuen Wert mit ws.textAll() an alle.

4.5(14)
23
ESP32-WLAN-STA-Verbindung (mit LCD-Display)
ES-25Fortgeschritten

ESP32-WLAN-STA-Verbindung (mit LCD-Display)

In diesem Projekt verbinden wir den ESP32 im Station-Modus (STA) sicher und fehlertolerant mit dem heimischen WLAN. Wir lagern SSID und Passwort in eine separate secrets.h-Datei aus, um Leaks zu Git zu verhindern, richten einen Auto-Reconnect-Mechanismus ein und zeigen RSSI-Signalpegel und IP-Adresse auf einem I2C-LCD-Display an. Die interne LED dient als Statusanzeige. Ein Verbindungsmanager auf Produktionsniveau.

4.4(21)
38
ESP32 LED-Überblendung mit PWM
ES-8Anfänger

ESP32 LED-Überblendung mit PWM

Ändern Sie die Helligkeit der LED stufenlos von 0 bis max, von max bis 0. Wir steuern PWM mit analogWrite() wie in Arduino - die gleiche Syntax mit ESP32 Arduino Core 3.0+ funktioniert reibungslos. Pin-Definition + pinMode + analogWrite ist genug.

4.8(36)
55
ESP32 mDNS: Zugriff auf das Gerät über „bluegrays-esp.local“ (mit LCD-Display)
ES-29Fortgeschritten
Premium

ESP32 mDNS: Zugriff auf das Gerät über „bluegrays-esp.local“ (mit LCD-Display)

Wir ergänzen den ESP32 um einen mDNS-Dienst (Multicast DNS), damit du ihn statt über eine IP-Adresse unter einem lesbaren Hostnamen wie bluegrays-esp.local erreichst. Auch wenn sich die per DHCP vergebene IP ändert, bleibt der Name gleich. Ein kleiner Webserver auf dem Board lässt dich die LED im Browser unter http://bluegrays-esp.local/ steuern.

4.8(14)
23
ESP32-OTA-Update – Drahtlose Firmware-Installation (mit LCD-Display)
ES-30Fortgeschritten
Premium

ESP32-OTA-Update – Drahtlose Firmware-Installation (mit LCD-Display)

Du lernst, neue Firmware ohne USB-Kabel per WLAN auf den ESP32 zu laden. Mit der Bibliothek ArduinoOTA wird der ESP32 im Netzwerk sichtbar und erscheint in der Arduino IDE unter "Network port" automatisch als bluegrays-ota. Das erste Hochladen läuft über USB, danach kommen alle Updates kabellos, eine wichtige Funktion für Geräte im Außeneinsatz.

4.6(14)
22