ES-113Principiante

ESP32 Bluetooth Sensor de aparcamiento

Mide la distancia a un obstáculo con un HC-SR04 y mírala en tu móvil; el zumbador pita más rápido cuanto más cerca está. Sin internet. Es la guía paso a paso de la plantilla Bluetooth Sensor de aparcamiento de la app, montada con un ESP32. Ve a Mi Taller › Dispositivos › Añadir dispositivo › Bluetooth, elige Sensor de aparcamiento y sube el código con Obtener el código. El botón Configurar como panel Bluetooth de esta página abre el mismo asistente.

0.0(0)
ESP32 Bluetooth Sensor de aparcamiento
Acerca la mano al sensor: el indicador del móvil baja, los pitidos se aceleran y a 10 cm el tono es continuo. Unas 10 veces por segundo el ESP32 mide el tiempo de un eco ultrasónico, lo pasa a distancia y la envía al panel por Bluetooth; sin internet. Los pitidos empiezan a 100 cm; el interruptor Sonido de aviso silencia el zumbador y la medida sigue. En la app añade un dispositivo, elige Bluetooth y Sensor de aparcamiento, sube el código con Obtener el código y busca tu placa en la lista. Es un proyecto de aprendizaje y maqueta, para una mesa o un coche de juguete, no para la seguridad vial en un vehículo real. Aprendes: medida por ultrasonidos, divisor de tensión para el eco de 5 V y envío de medidas al panel.

Video

Diagrama del circuito

ESP32 Bluetooth Sensor de aparcamiento - Diagrama del circuito

Código fuente

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Park                   │
5// └───────────────────────────┘
6// Sensor de aparcamiento
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-Park";  // 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 TRIG_PIN = 5, ECHO_PIN = 18;  // ECHO da 5 V: conéctalo con un divisor 1k/2k
18const int BUZZER_PIN = 19;
19const int ALARM_FROM_CM = 100;  // Alarma: por debajo de 100 cm pita más rápido cuanto más cerca está el obstáculo, y continuo por debajo de 10 cm
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 ──
155bool alarmOn = true;
156bool buzzing = false;
157int distanceCm = -1, sentCm = -100;
158unsigned long lastMeasureMs = 0, lastSentMs = 0, lastBeepMs = 0;
159
160int measureCm() {
161  digitalWrite(TRIG_PIN, LOW);
162  delayMicroseconds(2);
163  digitalWrite(TRIG_PIN, HIGH);
164  delayMicroseconds(10);
165  digitalWrite(TRIG_PIN, LOW);
166  unsigned long us = pulseIn(ECHO_PIN, HIGH, 25000UL);
167  if (us == 0) return 400;  // sin eco: nada en 4 m
168  return min(400UL, us / 58);
169}
170
171void buzz(bool on) {
172  if (on == buzzing) return;
173  buzzing = on;
174  if (on) tone(BUZZER_PIN, 2000);
175  else noTone(BUZZER_PIN);
176}
177
178void onValue(const char *key, const char *value) {
179  if (is(key, "alarm")) alarmOn = isOn(value);
180}
181
182void sendAll() {
183  if (distanceCm >= 0) sendInt("mesafe", distanceCm);
184  sendInt("alarm", alarmOn);
185}
186
187void onLinkLost() {
188}
189
190void setup() {
191  Serial.begin(115200);
192  pinMode(TRIG_PIN, OUTPUT);
193  pinMode(ECHO_PIN, INPUT);
194  pinMode(BUZZER_PIN, OUTPUT);
195  btBegin();
196  Serial.print(F("BlueGrays Bluetooth: "));
197  Serial.println(BLE_NAME);
198}
199
200void loop() {
201  btPoll();
202  if (millis() - lastMeasureMs >= 100) {
203    lastMeasureMs = millis();
204    distanceCm = measureCm();
205    if ((distanceCm != sentCm && millis() - lastSentMs >= 250) || millis() - lastSentMs >= 2000) {
206      sendInt("mesafe", distanceCm);
207      sentCm = distanceCm;
208      lastSentMs = millis();
209    }
210  }
211  if (!alarmOn || distanceCm < 0 || distanceCm > ALARM_FROM_CM) {
212    buzz(false);
213  } else if (distanceCm <= 10) {
214    buzz(true);
215  } else if (millis() - lastBeepMs >= (unsigned long)map(distanceCm, 10, ALARM_FROM_CM, 60, 600)) {
216    lastBeepMs = millis();
217    buzz(!buzzing);
218  }
219}
220

Preguntas frecuentes

¿Funciona con iPhone?

Sí. El Bluetooth Low Energy (BLE) integrado del ESP32 habla con iPhone y con Android. Un iPhone no puede conectarse a módulos de Bluetooth clásico como el HC-05 y el HC-06, y este proyecto no los necesita. No intentes emparejar la placa desde los ajustes Bluetooth del móvil; las placas BLE pueden no aparecer ahí, es normal. La conexión la hace la app BlueGrays.

¿Para qué sirve el divisor de tensión? ¿Puedo conectar ECHO directo?

El HC-SR04 funciona a 5 V y su pin ECHO entrega una señal de 5 V. Los pines del ESP32 trabajan a 3,3 V y no toleran 5 V. Las resistencias de 1 kΩ y 2 kΩ dividen esa señal y a GPIO 18 llegan unos 3,3 V. Conectado directo, el circuito puede parecer que funciona, pero puedes dañar el pin; no te saltes el divisor. TRIG no necesita divisor, porque ahí la señal la envía la placa. Si no tienes una resistencia de 2 kΩ, pon dos de 1 kΩ una detrás de otra (en serie).

¿Puedo montarlo en mi coche de verdad?

No, es un proyecto para aprender y para maquetas. Cumple sobre una mesa, en un coche de juguete o cuando pruebas a acercarte a la pared del garaje. El HC-SR04 y la protoboard no están hechos para la lluvia, el barro ni las vibraciones; en superficies blandas o inclinadas la medida falla y la conexión Bluetooth puede cortarse. No es un sistema de aparcamiento para la seguridad al conducir un vehículo real, así que no te fíes de él ahí.

¿Pita aunque no haya un móvil conectado?

Sí. La medida y los pitidos ocurren en la placa; el móvil solo muestra la distancia y apaga o enciende el sonido. La placa arranca siempre con Sonido de aviso activado, así que con una batería externa pita desde los 100 cm sin ningún móvil. Si la conexión se corta, la medida y los pitidos siguen. Si lo silenciaste con el interruptor del panel, sigue callado hasta que lo vuelvas a activar o la placa se reinicie. Nunca hace falta internet ni wifi.