ES-113Principiante

ESP32 Bluetooth Sensore di parcheggio

Misura la distanza da un ostacolo con un HC-SR04 e guardala sul telefono; il buzzer suona più in fretta quando si avvicina. Senza internet. È la guida passo passo del modello Bluetooth Sensore di parcheggio dell'app, con un ESP32. Vai in La Mia Officina › Dispositivi › Aggiungi dispositivo › Bluetooth, scegli Sensore di parcheggio e carica il codice con Ottieni il codice. Anche il pulsante Configura come pannello Bluetooth di questa pagina apre la procedura.

0.0(0)
ESP32 Bluetooth Sensore di parcheggio
Avvicina la mano al sensore: l'indicatore sul telefono scende, i bip accelerano e a 10 cm il suono è continuo. Circa 10 volte al secondo l'ESP32 misura il tempo di un'eco a ultrasuoni, lo trasforma in distanza e la invia al pannello via Bluetooth; senza internet. I bip iniziano a 100 cm; l'interruttore Suono di avviso zittisce il buzzer e la misura continua. Nell'app aggiungi un dispositivo, scegli Bluetooth e Sensore di parcheggio, carica il codice con Ottieni il codice e trova la scheda nell'elenco. È un progetto didattico e da modellino, per scrivania o macchinina, non per la sicurezza di guida su un veicolo vero. Impari: misura a ultrasuoni, partitore di tensione per l'eco a 5 V e invio delle misure al pannello.

Video

Schema circuito

ESP32 Bluetooth Sensore di parcheggio - Schema circuito

Codice sorgente

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Park                   │
5// └───────────────────────────┘
6// Sensore di parcheggio
7// Scheda in Arduino IDE: ESP32 Dev Module
8// la libreria BLE arriva con il pacchetto schede ESP32, niente da installare in più
9
10#include <BLEDevice.h>
11#include <BLEServer.h>
12#include <BLE2902.h>
13
14const char BLE_NAME[] = "BG-Park";  // la scheda si annuncia con questo nome e l’app la trova così nell’elenco
15
16// Pin: cambiali qui se hai collegato in modo diverso
17const int TRIG_PIN = 5, ECHO_PIN = 18;  // ECHO dà 5 V: collegalo con un partitore 1k/2k
18const int BUZZER_PIN = 19;
19const int ALARM_FROM_CM = 100;  // Allarme: sotto i 100 cm suona più veloce man mano che l’ostacolo si avvicina, continuo sotto i 10 cm
20
21void btWrite(const char *text);
22void onValue(const char *key, const char *value);
23void sendAll();
24void onLinkLost();
25
26// ── L’app invia righe "chiave=valore"; con "?" la scheda manda tutti i suoi valori ──
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 riga "@v" comunica all’app la versione del codice
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// i byte in arrivo passano dal task Bluetooth a loop() tramite un piccolo buffer circolare
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// le righe partono in pacchetti da 20 byte (funziona con ogni telefono)
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;  // nessuna eco: niente entro 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

FAQ

Funziona con l'iPhone?

Sì. Il Bluetooth Low Energy (BLE) integrato nell'ESP32 parla sia con iPhone sia con Android. Un iPhone non può collegarsi ai moduli Bluetooth classici come HC-05 e HC-06, e questo progetto non ne ha bisogno. Non provare ad associare la scheda dalle impostazioni Bluetooth del telefono; le schede BLE possono non comparire lì, è normale. La connessione la crea l'app BlueGrays.

A cosa serve il partitore di tensione? Posso collegare ECHO direttamente?

L'HC-SR04 funziona a 5 V e dal pin ECHO esce un segnale a 5 V. I pin dell'ESP32 lavorano a 3,3 V e non tollerano i 5 V. Le resistenze da 1 kΩ e 2 kΩ dividono quel segnale e a GPIO 18 arrivano circa 3,3 V. Collegato direttamente, il circuito può sembrare funzionare, ma rischi di danneggiare il pin; non saltare il partitore. TRIG non ha bisogno del partitore, perché lì il segnale lo manda la scheda. Se non hai una resistenza da 2 kΩ, metti due resistenze da 1 kΩ una dopo l'altra (in serie).

Posso montarlo sulla mia auto vera?

No, è un progetto didattico e da modellino. Fa il suo lavoro su una scrivania, su una macchinina o quando provi ad avvicinarti al muro del garage. L'HC-SR04 e la breadboard non sono fatti per pioggia, fango e vibrazioni; su superfici morbide o inclinate la misura sbaglia e la connessione Bluetooth può cadere. Non è un sistema di parcheggio per la sicurezza di guida su un veicolo vero, quindi lì non farci affidamento.

Suona anche senza un telefono collegato?

Sì. Misura e bip avvengono sulla scheda; il telefono serve solo a mostrare la distanza e a spegnere o riaccendere il suono. La scheda parte sempre con Suono di avviso attivo, quindi con un power bank suona da 100 cm anche senza telefono. Se la connessione cade, misura e bip continuano. Se hai spento il suono con l'interruttore del pannello, resta muta finché non lo riattivi o la scheda non si riavvia. Internet e Wi-Fi non servono mai.