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.

Video
Diagrama del circuito

Código fuente
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}
212Preguntas 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.
