ES-113Beginner

ESP32 Bluetooth-parkeersensor (HC-SR04)

Meet met een HC-SR04 de afstand tot een obstakel en volg die op je telefoon; de buzzer piept sneller naarmate je dichterbij komt. Internet is niet nodig. Dit is de stap-voor-stapgids voor het Bluetooth-sjabloon Parkeersensor in de app, gebouwd met een ESP32. Ga naar Werkplaats › Apparaten › Apparaat toevoegen › Bluetooth, kies Parkeersensor en upload de code met Code ophalen. De knop Instellen als Bluetooth-paneel op deze pagina opent de wizard ook met dit sjabloon.

0.0(0)
ESP32 Bluetooth-parkeersensor (HC-SR04)
Beweeg je hand naar de sensor: de meter op je telefoon zakt, de piepjes volgen elkaar sneller op en bij 10 cm klinkt een continue toon. Ongeveer 10 keer per seconde meet de ESP32 de tijd van een ultrasone echo, rekent die om naar een afstand en stuurt die via Bluetooth naar het paneel; internet is niet nodig. Het piepen begint bij 100 cm; met de schakelaar Alarmgeluid zet je de buzzer uit terwijl de metingen blijven binnenkomen. Voeg in de app een apparaat toe, kies Bluetooth en Parkeersensor, upload de code met Code ophalen en zoek je board in de lijst. Dit is een leer- en maquetteproject voor op je bureau of een speelgoedauto, niet voor rijveiligheid in een echt voertuig. Je leert: ultrasone afstandsmeting, een spanningsdeler voor het 5 V-echosignaal en metingen doorgeven aan het paneel.

Video

Schakelschema

ESP32 Bluetooth-parkeersensor (HC-SR04) - Schakelschema

Broncode

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Park                   │
5// └───────────────────────────┘
6// Parkeersensor
7// Board in de Arduino IDE: ESP32 Dev Module
8// de BLE-bibliotheek zit in het ESP32-boardpakket, je hoeft niets extra te installeren
9
10#include <BLEDevice.h>
11#include <BLEServer.h>
12#include <BLE2902.h>
13
14const char BLE_NAME[] = "BG-Park";  // het board zendt deze naam uit, de app herkent het in de lijst aan deze naam
15
16// Pinnen: pas ze hier aan als je anders hebt aangesloten
17const int TRIG_PIN = 5, ECHO_PIN = 18;  // ECHO geeft 5 V af: sluit hem aan via een 1k/2k-spanningsdeler
18const int BUZZER_PIN = 19;
19const int ALARM_FROM_CM = 100;  // Alarm: onder 100 cm piept hij sneller naarmate het obstakel dichterbij komt, onder 10 cm continu
20
21void btWrite(const char *text);
22void onValue(const char *key, const char *value);
23void sendAll();
24void onLinkLost();
25
26// ── De app stuurt regels "sleutel=waarde"; bij "?" stuurt het board al zijn waarden ──
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");  // de regel "@v" geeft de app de codeversie door
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// binnenkomende bytes gaan via een kleine ringbuffer van de Bluetooth-taak naar loop()
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// regels worden in pakketten van 20 bytes verstuurd (werkt met elke telefoon)
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;  // geen echo: niets binnen 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

Veelgestelde vragen

Werkt het met een iPhone?

Ja. De ingebouwde Bluetooth Low Energy (BLE) van de ESP32 werkt met zowel iPhone als Android. Een iPhone kan geen verbinding maken met klassieke Bluetooth-modules zoals de HC-05 en HC-06, en die heb je in dit project ook niet nodig. Probeer het board niet te koppelen in de Bluetooth-instellingen van je telefoon; BLE-boards verschijnen daar mogelijk niet, dat is normaal. De BlueGrays-app maakt de verbinding.

Waarom heb ik de spanningsdeler nodig? Kan ik ECHO rechtstreeks op het board aansluiten?

De HC-SR04 werkt op 5 V en de ECHO-pin geeft een 5 V-signaal. De pins van de ESP32 werken op 3,3 V en zijn niet 5 V-tolerant. De weerstanden van 1 kΩ en 2 kΩ delen dat signaal, zodat ongeveer 3,3 V bij GPIO 18 aankomt. Direct aangesloten lijkt de schakeling misschien te werken, maar je kunt de pin beschadigen; sla de spanningsdeler dus niet over. TRIG heeft geen deler nodig, want daar stuurt het board het signaal. Heb je geen weerstand van 2 kΩ, zet dan twee weerstanden van 1 kΩ achter elkaar (in serie).

Kan ik dit in mijn echte auto monteren?

Nee, dit is een leer- en maquetteproject. Het doet zijn werk op een bureau, op een speelgoedauto of als je een garagemuur nadert. De HC-SR04 en een breadboard zijn niet gemaakt voor regen, modder en trillingen; op zachte of schuine oppervlakken klopt de meting niet en de Bluetooth-verbinding kan wegvallen. Het is geen parkeersysteem voor rijveiligheid in een echt voertuig, vertrouw er daar dus niet op.

Piept het ook als er geen telefoon verbonden is?

Ja. Meten en piepen gebeuren op het board; de telefoon is er alleen om de afstand te tonen en het geluid uit en aan te zetten. Het board start bij elke inschakeling met Alarmgeluid aan, dus op een powerbank piept het vanaf 100 cm zonder telefoon. Valt de verbinding weg, dan gaan meten en piepen door. Heb je het geluid met de schakelaar in het paneel uitgezet, dan blijft het stil tot je de schakelaar weer aanzet of het board opnieuw start. Internet en Wi-Fi zijn nooit nodig.