ES-107Principiante

Coche Bluetooth con ESP32 (L298N)

Conduce un coche de dos ruedas por Bluetooth con el joystick del móvil; sin internet, en iPhone y Android. Este proyecto es la guía paso a paso de la plantilla Bluetooth Mando de coche de la app, montada con un ESP32, un L298N y dos motores. Ve a Mi Taller › Dispositivos › Añadir dispositivo › Bluetooth, elige Mando de coche y sube el código de Obtener el código. El botón Configurar como panel Bluetooth de esta página abre el asistente con esta plantilla.

0.0(0)
1 completado
Coche Bluetooth con ESP32 (L298N)
¿Y si conviertes tu móvil en un mando y paseas por casa un coche hecho por ti? El Bluetooth integrado del ESP32 se conecta directo al móvil, sin internet, router ni módulos extra. En la app añade un dispositivo Bluetooth, elige la plantilla Mando de coche, sube el código de Obtener el código y conéctate a tu placa. Arrastras el joystick y el coche avanza, lo sueltas y se para; también hay flechas, un control de velocidad y una vista a pantalla completa. El botón Configurar como panel Bluetooth de esta página te lleva directo al asistente. Aprendes: recibir órdenes por Bluetooth Low Energy, el sentido de los motores y la velocidad PWM con el L298N, la mezcla del joystick y una parada de seguridad.

Video

Diagrama del circuito

Coche Bluetooth con ESP32 (L298N) - Diagrama del circuito

Código fuente

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Araba                  │
5// └───────────────────────────┘
6// Mando de coche
7// Placa en Arduino IDE: ESP32 Dev Module
8// la biblioteca BLE viene con el paquete de placas ESP32, no hay que instalar nada más
9
10#include <BLEDevice.h>
11#include <BLEServer.h>
12#include <BLE2902.h>
13
14const char BLE_NAME[] = "BG-Araba";  // la placa se anuncia con este nombre y la app la encuentra así en la lista
15
16// Pines: cámbialos aquí si conectaste de otra forma
17const int ENA = 14, IN1 = 27, IN2 = 26;  // El motor A (ENA, IN1, IN2) es la rueda izquierda y el motor B (ENB, IN3, IN4) la derecha
18const int ENB = 32, IN3 = 25, IN4 = 33;
19const unsigned long COMMAND_TIMEOUT_MS = 500;  // Seguridad: si no llega ningún comando en 500 ms, los motores se paran (la app lo repite mientras conduces)
20
21void btWrite(const char *text);
22void onValue(const char *key, const char *value);
23void sendAll();
24void onLinkLost();
25
26// ── La app envía líneas "clave=valor"; con "?" la placa manda todos sus valores ──
27char line[65];
28uint8_t lineLen = 0;
29unsigned long lastRxMs = 0;
30
31bool is(const char *a, const char *b) { return strcmp(a, b) == 0; }
32bool isOn(const char *v) { return v[0] == '1'; }
33
34void sendText(const char *key, const char *value) {
35  char out[72];
36  snprintf(out, sizeof(out), "%s=%s\n", key, value);
37  btWrite(out);
38}
39
40void sendInt(const char *key, long value) {
41  char text[12];
42  snprintf(text, sizeof(text), "%ld", value);
43  sendText(key, text);
44}
45
46void sendFloat(const char *key, float value) {
47  char text[16];
48  dtostrf(value, 1, 1, text);
49  sendText(key, text);
50}
51
52void handleLine(char *text) {
53  char *eq = strchr(text, '=');
54  if (eq == nullptr) {
55    if (text[strlen(text) - 1] == '?') {
56      btWrite("@v=1.0\n");  // la línea "@v" indica a la app la versión del código
57      sendAll();
58    }
59    return;
60  }
61  *eq = '\0';
62  onValue(text, eq + 1);
63}
64
65void feed(char c) {
66  lastRxMs = millis();
67  if (c == '\n' || c == '\r') {
68    if (lineLen == 0) return;
69    line[lineLen] = '\0';
70    lineLen = 0;
71    handleLine(line);
72  } else if (lineLen < sizeof(line) - 1) {
73    line[lineLen++] = c;
74  }
75}
76
77// ── Bluetooth (Nordic UART) ──
78#define UART_SERVICE "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
79#define UART_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
80#define UART_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"
81
82BLECharacteristic *txChar = nullptr;
83volatile bool linked = false;
84volatile bool linkLost = false;
85// los bytes que llegan pasan de la tarea Bluetooth a loop() por un pequeño búfer circular
86const int RX_SIZE = 256;
87volatile uint8_t rxBuf[RX_SIZE];
88volatile int rxHead = 0, rxTail = 0;
89
90class ServerEvents : public BLEServerCallbacks {
91  void onConnect(BLEServer *server) override { linked = true; }
92  void onDisconnect(BLEServer *server) override { linked = false; linkLost = true; }
93};
94
95class RxEvents : public BLECharacteristicCallbacks {
96  void onWrite(BLECharacteristic *c) override {
97    auto v = c->getValue();
98    for (size_t i = 0; i < v.length(); i++) {
99      int next = (rxHead + 1) % RX_SIZE;
100      if (next == rxTail) break;
101      rxBuf[rxHead] = (uint8_t)v[i];
102      rxHead = next;
103    }
104  }
105};
106
107// las líneas salen en paquetes de 20 bytes (funciona con cualquier móvil)
108void btWrite(const char *text) {
109  if (!linked || txChar == nullptr) return;
110  size_t n = strlen(text);
111  for (size_t i = 0; i < n; i += 20) {
112    size_t len = n - i < 20 ? n - i : 20;
113    txChar->setValue((uint8_t *)text + i, len);
114    txChar->notify();
115    delay(4);
116  }
117}
118
119void btBegin() {
120  BLEDevice::init(BLE_NAME);
121  BLEServer *server = BLEDevice::createServer();
122  server->setCallbacks(new ServerEvents());
123  BLEService *uart = server->createService(UART_SERVICE);
124  txChar = uart->createCharacteristic(UART_TX, BLECharacteristic::PROPERTY_NOTIFY);
125  txChar->addDescriptor(new BLE2902());
126  BLECharacteristic *rx = uart->createCharacteristic(UART_RX, BLECharacteristic::PROPERTY_WRITE | BLECharacteristic::PROPERTY_WRITE_NR);
127  rx->setCallbacks(new RxEvents());
128  uart->start();
129  BLEAdvertisementData adv;
130  adv.setFlags(0x06);
131  adv.setCompleteServices(BLEUUID(UART_SERVICE));
132  BLEAdvertisementData scan;
133  scan.setName(BLE_NAME);
134  BLEAdvertising *advertising = BLEDevice::getAdvertising();
135  advertising->setAdvertisementData(adv);
136  advertising->setScanResponseData(scan);
137  BLEDevice::startAdvertising();
138}
139
140void btPoll() {
141  while (rxTail != rxHead) {
142    char c = (char)rxBuf[rxTail];
143    rxTail = (rxTail + 1) % RX_SIZE;
144    feed(c);
145  }
146  if (linkLost) {
147    linkLost = false;
148    onLinkLost();
149    delay(100);
150    BLEDevice::startAdvertising();
151  }
152}
153
154// ── ESP32 ──
155int speedLimit = 80;  // límite de velocidad desde la app (0–100 %)
156unsigned long lastCommandMs = 0;
157bool moving = false;
158
159// si el coche va hacia atrás, intercambia los dos cables de ese motor
160void motor(int en, int a, int b, int power) {
161  power = constrain(power, -100, 100);
162  digitalWrite(a, power > 0 ? HIGH : LOW);
163  digitalWrite(b, power < 0 ? HIGH : LOW);
164  analogWrite(en, abs(power) * speedLimit * 255L / 10000);
165}
166
167void drive(int left, int right) {
168  motor(ENA, IN1, IN2, left);
169  motor(ENB, IN3, IN4, right);
170  moving = left != 0 || right != 0;
171  lastCommandMs = millis();
172}
173
174void onValue(const char *key, const char *value) {
175  if (is(key, "joy")) {  // Joystick: y adelante/atrás, x gira; se convierte en velocidad de rueda izquierda y derecha
176    const char *comma = strchr(value, ',');
177    int x = atoi(value), y = comma ? atoi(comma + 1) : 0;
178    drive(constrain(y + x, -100, 100), constrain(y - x, -100, 100));
179  } else if (is(key, "yon")) {
180    if (is(value, "ileri")) drive(100, 100);
181    else if (is(value, "geri")) drive(-100, -100);
182    else if (is(value, "sol")) drive(-70, 70);
183    else if (is(value, "sag")) drive(70, -70);
184    else drive(0, 0);
185  } else if (is(key, "hiz")) {
186    speedLimit = constrain(atoi(value), 0, 100);
187  }
188}
189
190void sendAll() {
191  sendInt("hiz", speedLimit);
192}
193
194void onLinkLost() {
195  drive(0, 0);  // Conexión perdida: los motores se paran
196}
197
198void setup() {
199  Serial.begin(115200);
200  int pins[] = { ENA, IN1, IN2, ENB, IN3, IN4 };
201  for (int pin : pins) pinMode(pin, OUTPUT);
202  drive(0, 0);
203  btBegin();
204  Serial.print(F("BlueGrays Bluetooth: "));
205  Serial.println(BLE_NAME);
206}
207
208void loop() {
209  btPoll();
210  if (moving && millis() - lastCommandMs > COMMAND_TIMEOUT_MS) drive(0, 0);
211}
212

Preguntas frecuentes

¿Funciona con iPhone? ¿En qué se diferencia del HC-05?

Sí, funciona en iPhone y Android. Los módulos Bluetooth clásicos como el HC-05 y el HC-06 no pueden conectarse a un iPhone, por eso este proyecto usa el Bluetooth Low Energy integrado del ESP32 y no necesita módulos extra. No intentes emparejar la placa en los ajustes Bluetooth del móvil; la conexión la hace solo la app BlueGrays.

El coche va hacia atrás o una rueda gira al revés.

Intercambia los dos cables del motor que gira al revés en la bornera del L298N (motor izquierdo OUT1/OUT2, motor derecho OUT3/OUT4); el comentario del código dice lo mismo. Si al pulsar adelante el coche gira sobre sí mismo, solo un motor está invertido. Si los dos giran bien pero izquierda lo lleva a la derecha, intercambia el motor izquierdo y el derecho.

¿Cómo alimento el ESP32? ¿Pueden estar conectados el USB y la batería a la vez?

Las 2× 18650 (7,4 V) van a la entrada 12V del L298N, y la salida 5V del L298N alimenta el pin VIN del ESP32; para ello el jumper del regulador de 5V del L298N debe seguir puesto. Así el coche funciona sin cable. Si el USB está conectado mientras subes el código, apaga la batería o quita el cable de 5V para que las dos alimentaciones no choquen. El GND del L298N y el del ESP32 deben estar siempre unidos.

¿Qué alcance tiene? ¿Qué hace el coche si se corta la conexión?

Bluetooth Low Energy suele llegar a entre 10 y 30 metros en espacio abierto; las paredes y las personas en medio lo acortan. Si se corta la conexión, la placa para los motores al instante y vuelve a anunciarse, así puedes reconectarte desde la app. El coche también se para si la placa no recibe ningún comando en 500 ms, así que nunca se escapa fuera de alcance.