Guías · 11 min de lectura

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.

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

¿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?NoSíNo
App en el celularNo hace falta, basta el navegadorNo hace falta, basta el navegadorHace falta una app de terminal Bluetooth
Funciona con iPhoneSíSíNo (iOS no admite el puerto serie por Bluetooth clásico)
Alcance al aire libreUnos 30–50 mLo que cubra el módemUnos 10–20 m
Retardo de las órdenesUnos 20–50 ms20–100 ms según el tráfico de la redUnos 20–40 ms

Lista de materiales y costo

PiezaCant.Precio aprox. (USD)Nota
ESP32 DevKit V1 (30 o 38 pines)14–7Los GPIO que usamos están en las dos versiones
Módulo puente H L298N12–42 A por canal; maneja dos motores por separado
Kit de chasis 2WD para carro robot18–15Suele traer 2 motores TT, 2 ruedas, rueda loca e interruptor
Pila de litio 1865026–12Celdas de marca que entreguen al menos 5 A
Portapilas doble 18650 (en serie)11–2El modelo con interruptor simplifica el cableado
Cargador de 1865013–10Que cargue cada celda por separado
Cables dupont (hembra-hembra, macho-hembra)10+1–3Entre el ESP32 y el L298N
Capacitores de 470 µF / 16 V y 100 nF1 + 2Menos de 1Contra caídas de voltaje y ruido de los motores
Total25–5015–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

L298NESP32Descripción
ENAGPIO 25Velocidad del motor izquierdo (PWM); quita el jumper de ENA
IN1GPIO 26Sentido del motor izquierdo
IN2GPIO 27Sentido del motor izquierdo
ENBGPIO 33Velocidad del motor derecho (PWM); quita el jumper de ENB
IN3GPIO 18Sentido del motor derecho
IN4GPIO 19Sentido del motor derecho
+12V (VS)–Positivo del paquete 2×18650 (después del interruptor)
GNDGNDNegativo de las pilas y GND del ESP32; la tierra común es obligatoria
+5VVIN (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.

Mientras el ESP32 esté conectado por USB, desconecta el cable +5V del L298N del pin VIN o apaga el interruptor de las pilas; tener dos fuentes de 5 V a la vez puede regresar corriente al puerto USB de la computadora en algunas placas. Tampoco conectes nunca el positivo de las pilas directo al ESP32: 8,4 V en el pin 3V3 dañan la placa al instante y 8,4 V en VIN sobrecalientan el regulador AMS1117 de la placa.

Armado paso a paso

  1. En el Gestor de tarjetas del Arduino IDE instala esp32 by Espressif Systems y elige la placa ESP32 Dev Module.
  2. Atornilla los motores al chasis y conecta sus cables a las borneras OUT1-OUT2 (izquierdo) y OUT3-OUT4 (derecho) del L298N.
  3. Quita los jumpers de ENA y ENB del L298N; deja puesto el jumper 5V-EN.
  4. Conecta los seis cables de señal de la tabla y la GND común con cables dupont hembra-hembra.
  5. 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.
  6. Sube el código principal, abre el Monitor Serie a 115200 baudios y fíjate en la dirección que aparece.
  7. 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.
  8. 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.

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}

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.

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}
LíneaQué 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 + ledcAttachPinConfigura el PWM según la versión del core (3.x / 2.x)
millis() - lastCmd > FAILSAFE_MSDetiene 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)IzquierdaDerechaQué hace el carro
(0, 100)100100Adelante a toda velocidad
(0, -100)-100-100Reversa a toda velocidad
(100, 0)100-100Gira a la derecha en su lugar
(-100, 0)-100100Gira a la izquierda en su lugar
(50, 100)10050Avanza y dobla suavemente a la derecha
(0, 0)00Se 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.

Para probar el failsafe, con las ruedas en el aire empuja el joystick hacia adelante y, sin soltarlo, apaga el WiFi del celular; las ruedas deben detenerse en medio segundo. Si en una red saturada el carro avanza a tirones, puedes subir FAILSAFE_MS a 800 ms.

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.

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

Alcance, 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íntomaCausa probableSolución
El ESP32 se reinicia cuando arrancan los motoresEl 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 viejasUsa el código de esta guía, con la condición #if ESP_ARDUINO_VERSION_MAJOR
El carro no se mueve a baja velocidadEl PWM está por debajo del umbral de arranque del motorSube MIN_DUTY a 100–120
Una rueda gira al revésLos cables del motor están invertidosIntercambia los dos cables de ese motor en el L298N
El carro siempre va a toda velocidadLos jumpers de ENA / ENB siguen puestosQuita los jumpers y conecta esos pines a GPIO 25 y 33
No abre 192.168.4.1El celular se salió de la red o está usando datos móvilesApaga los datos, vuelve a conectarte y escribe la dirección con http://
El carro avanza a tironesCanal WiFi saturado o señal débilCambia de canal, deja la antena al descubierto y sube un poco FAILSAFE_MS
El L298N se calienta muchoLos motores van forzados todo el tiempo o una rueda está trabadaRevisa 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.

Ver todos los proyectos
Coche controlado por Bluetooth con L298N
AR-80Avanzado
Premium

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…

5.0(39)
66
Robot para evitar obstáculos
AR-81Avanzado
Premium

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.

5.0(38)
49
Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
ES-27Avanzado

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).

4.8(16)
26
Contador ESP32 WebSocket (2 botones + pantalla LCD + web en tiempo real)
ES-28Avanzado
Premium

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().

4.5(14)
23
Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
ES-25Avanzado

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.

4.4(21)
38
ESP32 LED Fade con PWM
ES-8Principiante

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.

4.8(36)
55
ESP32 mDNS: Acceso al dispositivo mediante bluegrays-esp.local (con pantalla LCD)
ES-29Avanzado
Premium

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/.

4.8(14)
23
Actualización OTA del ESP32 — Instalación inalámbrica del firmware (con pantalla LCD)
ES-30Avanzado
Premium

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.

4.6(14)
22