Carro WiFi con ESP32: contrólalo desde el celular (L298N)
Haz un carro WiFi con ESP32 y manéjalo desde el navegador del celular: red propia (softAP), joystick web, L298N con PWM, materiales con costo y paro seguro.
Un carro WiFi con ESP32 es un carrito robot que manejas con un joystick que se abre en el navegador de tu celular, sin instalar ninguna app. El ESP32 crea su propia red WiFi (softAP), tu celular se conecta a ella y, al escribir 192.168.4.1 en el navegador, aparece un joystick en la pantalla. Mientras deslizas el dedo, el ESP32 acelera, frena y hace girar dos motorreductores con PWM a través de un módulo puente H L298N. No necesitas módem, internet ni emparejar Bluetooth, y funciona igual en Android y en iPhone.
En esta guía armamos el carro de principio a fin: lista de materiales y costo aproximado, tabla de conexiones ESP32–L298N, un primer código que prueba los motores sin WiFi, el código principal que lleva el joystick guardado dentro del ESP32 y cómo la posición del joystick se convierte en la velocidad de las dos ruedas. Además añadimos una medida de seguridad que casi todos los ejemplos olvidan: si se corta la conexión, el carro se detiene solo en medio segundo. El código compila tanto con la versión 2.x como con la 3.x del core de ESP32 para Arduino.




¿Cómo funciona un carro WiFi con ESP32?
El sistema tiene cuatro partes. El ESP32 es el cerebro y además un pequeño servidor web: le envía al celular la página del joystick y luego aplica las órdenes de "motor izquierdo a tal velocidad, motor derecho a tal otra" que llegan diez veces por segundo. El L298N es un puente H doble; convierte las débiles señales de 3,3 V del ESP32 en la corriente que piden los motores. Dos motorreductores amarillos TT mueven las ruedas (las llantas); no hay dirección, el carro gira por la diferencia de velocidad entre las dos ruedas (tracción diferencial). Dos pilas 18650 alimentan los motores y, a través del regulador de 5 V del propio L298N, también al ESP32. En modo softAP el ESP32 se comporta como un módem y siempre se asigna la dirección 192.168.4.1, así que puedes manejar el carro en el patio, en la escuela o en cualquier lugar sin módem.
| WiFi softAP (esta guía) | WiFi de la casa (STA) | Bluetooth (HC-05 o BT clásico) | |
|---|---|---|---|
| ¿Necesita módem? | No | Sí | No |
| App en el celular | No hace falta, basta el navegador | No hace falta, basta el navegador | Hace falta una app de terminal Bluetooth |
| Funciona con iPhone | Sí | Sí | No (iOS no admite el puerto serie por Bluetooth clásico) |
| Alcance al aire libre | Unos 30–50 m | Lo que cubra el módem | Unos 10–20 m |
| Retardo de las órdenes | Unos 20–50 ms | 20–100 ms según el tráfico de la red | Unos 20–40 ms |
Lista de materiales y costo
| Pieza | Cant. | Precio aprox. (USD) | Nota |
|---|---|---|---|
| ESP32 DevKit V1 (30 o 38 pines) | 1 | 4–7 | Los GPIO que usamos están en las dos versiones |
| Módulo puente H L298N | 1 | 2–4 | 2 A por canal; maneja dos motores por separado |
| Kit de chasis 2WD para carro robot | 1 | 8–15 | Suele traer 2 motores TT, 2 ruedas, rueda loca e interruptor |
| Pila de litio 18650 | 2 | 6–12 | Celdas de marca que entreguen al menos 5 A |
| Portapilas doble 18650 (en serie) | 1 | 1–2 | El modelo con interruptor simplifica el cableado |
| Cargador de 18650 | 1 | 3–10 | Que cargue cada celda por separado |
| Cables dupont (hembra-hembra, macho-hembra) | 10+ | 1–3 | Entre el ESP32 y el L298N |
| Capacitores de 470 µF / 16 V y 100 nF | 1 + 2 | Menos de 1 | Contra caídas de voltaje y ruido de los motores |
| Total | 25–50 | 15–25 si ya tienes pilas y cargador |
Los precios son valores típicos de tiendas de electrónica en línea y cambian según el país, el envío y el tipo de cambio; en México, Colombia, Argentina o Chile el total suele quedar en ese rango convertido a moneda local. Lo que más pesa en el presupuesto son el chasis y las pilas. No ahorres en las pilas: las muy baratas que dicen "9900 mAh" casi siempre son falsas, su voltaje se desploma al arrancar los motores y el ESP32 se reinicia. Si ya tienes un kit de carro robot para Arduino, solo necesitas comprar el ESP32; el chasis, los motores y el L298N se quedan igual. Explicamos cómo elegir pilas en Pila de litio 18650.
Conexión: ESP32, L298N y motores
| L298N | ESP32 | Descripción |
|---|---|---|
| ENA | GPIO 25 | Velocidad del motor izquierdo (PWM); quita el jumper de ENA |
| IN1 | GPIO 26 | Sentido del motor izquierdo |
| IN2 | GPIO 27 | Sentido del motor izquierdo |
| ENB | GPIO 33 | Velocidad del motor derecho (PWM); quita el jumper de ENB |
| IN3 | GPIO 18 | Sentido del motor derecho |
| IN4 | GPIO 19 | Sentido del motor derecho |
| +12V (VS) | – | Positivo del paquete 2×18650 (después del interruptor) |
| GND | GND | Negativo de las pilas y GND del ESP32; la tierra común es obligatoria |
| +5V | VIN (5V) | Alimenta al ESP32 desde el regulador del L298N con el jumper 5V-EN puesto |
| OUT1 / OUT2 | – | Motor izquierdo |
| OUT3 / OUT4 | – | Motor derecho |
Las entradas lógicas del L298N toman como HIGH cualquier voltaje por encima de 2,3 V, así que las salidas de 3,3 V del ESP32 se conectan directo, sin convertidor de nivel. Con las pilas llenas el paquete da 8,4 V; el L298N se come entre 1,5 y 3 V y a los motores les llegan 5–6 V, justo el rango ideal de los motores TT. El regulador 78M05 del módulo saca 5 V del mismo paquete y alimenta al ESP32 por su pin VIN. Los pines tampoco son al azar: GPIO 0, 2, 12 y 15 son pines de arranque (strapping) que definen el modo de inicio, del 6 al 11 están reservados para la memoria flash y del 34 al 39 son solo entradas. 25, 26, 27, 33, 18 y 19 son salidas seguras que existen en las placas de 30 y de 38 pines. Explicamos por qué la tierra debe ser común en GND y tierra común.
Armado paso a paso
- En el Gestor de tarjetas del Arduino IDE instala esp32 by Espressif Systems y elige la placa ESP32 Dev Module.
- Atornilla los motores al chasis y conecta sus cables a las borneras OUT1-OUT2 (izquierdo) y OUT3-OUT4 (derecho) del L298N.
- Quita los jumpers de ENA y ENB del L298N; deja puesto el jumper 5V-EN.
- Conecta los seis cables de señal de la tabla y la GND común con cables dupont hembra-hembra.
- Pon el carro sobre una caja con las ruedas en el aire; sube el código de prueba de motores y revisa el sentido de giro.
- Sube el código principal, abre el Monitor Serie a 115200 baudios y fíjate en la dirección que aparece.
- En los ajustes WiFi del celular conéctate a la red BlueGrays-Car con la contraseña 12345678 y escribe 192.168.4.1 en el navegador.
- Empuja el joystick con suavidad; si las ruedas giran hacia donde deben, baja el carro al piso y a manejar.
Primero prueba los motores
Antes de pasar al código WiFi, comprueba el cableado con este programa corto. Como deja ENA y ENB siempre en HIGH, los motores giran a toda velocidad: un segundo hacia adelante, luego hacia atrás y después girando en su lugar a la izquierda y a la derecha. Si con la orden de avanzar una rueda gira hacia atrás, no toques el código; intercambia los dos cables de ese motor en el L298N. Si ningún motor se mueve, revisa el interruptor de las pilas, la GND común y los cables de ENA y ENB.
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}Código principal: el carro que crea su propia red WiFi (softAP)
En el programa principal la página del joystick va guardada dentro del ESP32 como un solo texto con HTML, CSS y JavaScript. No tienes que subir archivos aparte ni instalar librerías; solo se usan WiFi y WebServer, que vienen con el paquete del ESP32. Con la página abierta, el navegador manda cada 100 ms una petición pequeñita como /d?l=60&r=-60; el ESP32 lee los dos números, los aplica a los motores y anota la hora de la orden.
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}| Línea | Qué hace |
|---|---|
| WiFi.softAP(AP_SSID, AP_PASS) | Convierte al ESP32 en punto de acceso; la contraseña debe tener al menos 8 caracteres o la red no se crea |
| PAGE[] = R"rawliteral(…)rawliteral" | Toda la página del joystick; al ser texto crudo no hay que escapar las comillas |
| server.on("/d", handleDrive) | Lee los valores l y r (-100 … 100) que manda el navegador y se los da a los motores |
| map(abs(speed), 1, 100, MIN_DUTY, 255) | Hace que hasta la velocidad más baja arranque en el PWM mínimo que mueve el motor |
| ledcAttach / ledcSetup + ledcAttachPin | Configura el PWM según la versión del core (3.x / 2.x) |
| millis() - lastCmd > FAILSAFE_MS | Detiene los dos motores si no llega ninguna orden en 500 ms |
¿Cómo se convierte el joystick en velocidad de los motores?
El joystick de la página mide la posición de tu dedo respecto al centro como x (izquierda-derecha) e y (adelante-atrás), de -100 a 100. Con una mezcla sencilla llamada tracción tipo tanque se obtiene la velocidad de cada rueda: izquierda = y + x, derecha = y − x. Si el resultado pasa de ±100 se recorta y luego se multiplica por el porcentaje de velocidad máxima del deslizador. Del lado del ESP32 ese porcentaje se convierte en un valor PWM. Aquí hay un truco pequeño pero importante: los motores TT zumban pero no giran por debajo de un PWM de 80–90. Por eso el código no reparte 1–100 entre 0 y 255, sino entre MIN_DUTY y 255; por ejemplo, 50 % de velocidad es map(50, 1, 100, 90, 255) = 171. Si tu carro no se mueve nada a baja velocidad, sube MIN_DUTY de 10 en 10; si sale disparado apenas tocas el joystick, bájalo.
| Joystick (x, y) | Izquierda | Derecha | Qué hace el carro |
|---|---|---|---|
| (0, 100) | 100 | 100 | Adelante a toda velocidad |
| (0, -100) | -100 | -100 | Reversa a toda velocidad |
| (100, 0) | 100 | -100 | Gira a la derecha en su lugar |
| (-100, 0) | -100 | 100 | Gira a la izquierda en su lugar |
| (50, 100) | 100 | 50 | Avanza y dobla suavemente a la derecha |
| (0, 0) | 0 | 0 | Se detiene |
Velocidad con PWM: diferencias entre el core 2.x y 3.x del ESP32
En el ESP32 el PWM lo genera un bloque de hardware llamado LEDC. El código usa 1 kHz de frecuencia y 8 bits de resolución, o sea que el ciclo de trabajo va de 0 a 255. Los transistores bipolares del L298N conmutan lento, así que subir a varios kHz no hace más rápido al motor, solo calienta más el driver; el zumbido leve a 1 kHz es normal. En la versión 3.0 del core de ESP32 para Arduino cambiaron las funciones de PWM: la pareja ledcSetup(canal, frecuencia, resolución) y ledcAttachPin(pin, canal) se reemplazó por una sola ledcAttach(pin, frecuencia, resolución), y ledcWrite ahora recibe el número de pin en lugar del canal. Las líneas #if ESP_ARDUINO_VERSION_MAJOR >= 3 del código eligen la función correcta tengas la versión que tengas. Lo básico del PWM está en Qué es el PWM.
Detener el carro si se pierde la conexión (failsafe)
En un vehículo manejado por WiFi, el momento más peligroso es cuando se cae la señal. Se bloquea la pantalla del celular, la pestaña del navegador pasa a segundo plano o el carro sale del alcance; si el ESP32 sigue aplicando la última orden, el carro se va a toda velocidad contra la pared o escaleras abajo. En este código la página manda una orden cada 100 ms aunque el joystick esté quieto, y manda 0 / 0 cuando levantas el dedo. El ESP32 guarda la hora de cada orden en lastCmd y en cada vuelta de loop() revisa qué tan vieja es la última. Si en 500 ms no llega ninguna petición nueva, es decir, si se pierden cinco órdenes seguidas, los motores se detienen. La bandera busy del navegador evita además que las peticiones se amontonen cuando la red se pone lenta; no se manda una nueva hasta recibir la respuesta, así una orden vieja nunca se aplica tarde.
Versión conectada al WiFi de tu casa (modo STA)
Si usas el carro en casa, también puedes conectar el ESP32 a tu módem. Así el celular se queda en su WiFi de siempre y no pierde internet, pero el alcance se limita a la cobertura del módem y la dirección del ESP32 será la IP que le asigne el módem. Basta con cambiar la línea WiFi.softAP de setup() por el fragmento de abajo. WiFi.setSleep(false) desactiva el modo de ahorro del módem del ESP32; sin esta línea las órdenes pueden retrasarse 100–200 ms de vez en cuando. Si no logra conectarse, revisa El ESP32 no se conecta al WiFi.
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 browserAlcance, retardo y ajustes del celular
- Aviso de "sin internet": El celular avisa que la red BlueGrays-Car no tiene internet; elige "Mantener conexión". En Android, si está activado el cambio automático a datos móviles, el teléfono puede salirse de la red; apagar los datos mientras manejas es la solución más fácil.
- Alcance: Con la antena de la propia placa (antena PCB) espera 30–50 m al aire libre y 10–20 m dentro de la casa con una o dos paredes de por medio. Deja la antena en la orilla de la placa, al descubierto y lejos de piezas metálicas y de las pilas.
- Canal: Si hay muchas redes alrededor, elige el canal más libre entre 1, 6 y 11 con un tercer parámetro, por ejemplo WiFi.softAP(AP_SSID, AP_PASS, 6).
- Retardo: En softAP las peticiones HTTP suelen tardar 20–50 ms, más que suficiente para manejar un carro. Si quieres un control más fluido o enviar datos del carro al celular (voltaje de las pilas, distancia), pásate a WebSocket; Servidor web y WebSocket con ESP32 lo explica paso a paso.
- Un solo piloto: Si dos celulares se conectan y usan el joystick al mismo tiempo, las órdenes se mezclan. Cambia la contraseña para que el carro sea solo tuyo.
Errores comunes y soluciones
| Síntoma | Causa probable | Solución |
|---|---|---|
| El ESP32 se reinicia cuando arrancan los motores | El voltaje de las pilas se cae por un instante (brownout) | Usa pilas 18650 de calidad; pon 470 µF en la entrada del L298N y 100 nF en los bornes de cada motor |
| Error de compilación "'ledcSetup' was not declared" | Tienes el core 3.x y el código usa las funciones de PWM viejas | Usa el código de esta guía, con la condición #if ESP_ARDUINO_VERSION_MAJOR |
| El carro no se mueve a baja velocidad | El PWM está por debajo del umbral de arranque del motor | Sube MIN_DUTY a 100–120 |
| Una rueda gira al revés | Los cables del motor están invertidos | Intercambia los dos cables de ese motor en el L298N |
| El carro siempre va a toda velocidad | Los jumpers de ENA / ENB siguen puestos | Quita los jumpers y conecta esos pines a GPIO 25 y 33 |
| No abre 192.168.4.1 | El celular se salió de la red o está usando datos móviles | Apaga los datos, vuelve a conectarte y escribe la dirección con http:// |
| El carro avanza a tirones | Canal WiFi saturado o señal débil | Cambia de canal, deja la antena al descubierto y sube un poco FAILSAFE_MS |
| El L298N se calienta mucho | Los motores van forzados todo el tiempo o una rueda está trabada | Revisa que las ruedas giren libres; considera un driver más eficiente (TB6612FNG) |
Ideas para mejorar tu carro
- Freno anticolisión: Pon un HC-SR04 al frente e ignora las órdenes de avanzar cuando haya un obstáculo a menos de 20 cm. Cómo usar el sensor: Sensor ultrasónico HC-SR04.
- Modo autónomo: Agrega un botón a la página; al presionarlo el carro anda solo como un robot evasor de obstáculos.
- Indicador de batería: Mide el voltaje del paquete en un pin analógico con un divisor de voltaje de dos resistencias y muéstralo en la página del joystick.
- Actualización inalámbrica: Con OTA en el ESP32 subes código nuevo sin conectar el cable USB cada vez.
- Control físico: Maneja sin celular con un segundo ESP32 y un módulo joystick usando ESP-NOW.
- Luces: Agrega LEDs WS2812B adelante y atrás; que las traseras se pongan rojas al ir en reversa.
Un carro WiFi con ESP32 es un gran primer proyecto: en uno solo aprendes servidor web, PWM, puente H y lógica de control segura. Más adelante puedes reutilizar la misma página del joystick en un brazo robótico o en un carro con cámara. Si te interesa cómo funciona el driver por dentro, lee Control de motor DC con el L298N, y para la versión con Arduino y Bluetooth mira Cómo hacer un carro robot con Arduino. En la app BlueGrays también encontrarás el carro Bluetooth con L298N, el robot evasor de obstáculos y los proyectos de servidor web con ESP32, con diagramas de conexión y código paso a paso.
Preguntas frecuentes
¿Se necesita internet para un carro WiFi con ESP32?
No. En modo softAP el ESP32 crea su propia red inalámbrica y el celular se conecta directo a ella; no hace falta módem ni internet. La página del joystick está guardada en la memoria del ESP32, así que abre sin ninguna conexión externa.
¿Qué alcance tiene un carro WiFi con ESP32?
Con la antena de la placa suele llegar a 30–50 m al aire libre y a 10–20 m dentro de la casa, según las paredes. Los módulos con conector para antena externa, como el ESP32-WROOM-32U, aumentan bastante el alcance.
¿El L298N funciona con los 3,3 V del ESP32?
Sí. Las entradas del L298N toman como HIGH cualquier voltaje arriba de 2,3 V, así que los pines del ESP32 se conectan directo a IN1–IN4 y ENA–ENB. Lo importante es unir la GND de las dos placas.
¿Tengo que instalar una app en el celular para manejar el carro?
No. El joystick es una página web que sirve el propio ESP32 y funciona en cualquier navegador, como Chrome, Safari o Firefox. Por eso se usa igual en celulares Android, iPhone, tablets y computadoras.
¿Por qué se reinicia el ESP32 cuando arrancan los motores?
Al arrancar, los motores piden varios amperes por un instante y el voltaje de las pilas débiles se desploma; el ESP32 lo detecta como brownout y se reinicia. Pilas 18650 de calidad, un capacitor de 470 µF en la entrada del L298N y uno de 100 nF en cada motor resuelven casi siempre el problema.
¿Qué es mejor para un carro robot: Bluetooth o WiFi?
El WiFi no necesita app, funciona también con iPhone y tiene más alcance. El Bluetooth clásico (HC-05 o el BluetoothSerial del ESP32) da una conexión ligera, pero depende de Android y de una app de terminal. Para un carro con ESP32 manejado desde el celular, el WiFi suele ser lo más práctico.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Coche controlado por Bluetooth con L298N
Convierte tu móvil en un mando y conduce tu propio coche robot. El Arduino recibe por un módulo Bluetooth las órdenes de una app de control remoto en el móvil y mueve las ruedas con un controlador de…

Robot para evitar obstáculos
¿Qué le parece construir un vehículo inteligente que encuentre su propio camino? El Robot Evitador de Obstáculos explora constantemente su entorno gracias al sensor ultrasónico que lleva delante.

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

Contador ESP32 WebSocket (2 botones + pantalla LCD + web en tiempo real)
En este proyecto, dos botones conectados al ESP32 (GPIO 5 suma, GPIO 4 resta) cambian un contador. El valor se actualiza al instante en una pantalla LCD I2C de 16x2 y, gracias al soporte WebSocket de ESPAsyncWebServer, en todos los navegadores conectados sin recargar la página. En lugar del sondeo HTTP se usa una única conexión persistente y el ESP32 envía el nuevo valor a todos con ws.textAll().

Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.

ESP32 LED Fade con PWM
Cambiar el brillo del LED suavemente de 0 a max, de max a 0. Controlamos PWM con analogWrite() como en Arduino - la misma sintaxis con ESP32 Arduino Core 3.0+ funciona sin problemas. Pin definición + pinMode + analogWrite es suficiente.

ESP32 mDNS: Acceso al dispositivo mediante bluegrays-esp.local (con pantalla LCD)
Añadimos un servicio mDNS (Multicast DNS) al ESP32 para que accedas a él con un nombre de host legible como bluegrays-esp.local en lugar de una dirección IP. Aunque cambie la IP que asigna el DHCP, el dispositivo siempre responde al mismo nombre. Un pequeño servidor web en la placa te permite controlar el LED desde el navegador en http://bluegrays-esp.local/.

Actualización OTA del ESP32 — Instalación inalámbrica del firmware (con pantalla LCD)
Aprenderás a cargar un firmware nuevo en el ESP32 por Wi-Fi, sin cable USB. Con la biblioteca ArduinoOTA, el ESP32 se hace visible en la red y aparece automáticamente como bluegrays-ota en la pestaña "Network port" del Arduino IDE. La primera carga se hace por USB; después, todas las actualizaciones son inalámbricas, algo clave para los dispositivos instalados sobre el terreno.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

