ES-113Anfänger

ESP32 Bluetooth Parksensor (HC-SR04)

Miss mit einem HC-SR04 den Abstand zu einem Hindernis und sieh ihn auf dem Handy; der Summer piept schneller, je näher es kommt. Ohne Internet. Dies ist die Schritt-für-Schritt-Anleitung zur Bluetooth-Vorlage Parksensor der App, gebaut mit einem ESP32. Geh zu Werkstatt › Geräte › Gerät hinzufügen › Bluetooth, wähl Parksensor und lade den Code mit Code holen hoch. Die Taste Als Bluetooth-Panel einrichten auf dieser Seite öffnet denselben Assistenten.

0.0(0)
ESP32 Bluetooth Parksensor (HC-SR04)
Beweg die Hand zum Sensor: Die Anzeige im Handy fällt, das Piepen wird schneller, bei 10 cm wird es ein Dauerton. Etwa 10-mal pro Sekunde misst der ESP32 die Laufzeit eines Ultraschall-Echos, macht daraus einen Abstand und schickt ihn per Bluetooth ans Panel; ohne Internet. Das Piepen beginnt bei 100 cm; der Schalter Warnton stellt den Summer stumm, die Messung läuft weiter. Füg in der App ein Gerät hinzu, wähl Bluetooth und Parksensor, lade den Code mit Code holen hoch und such dein Board in der Liste. Ein Lern- und Modellprojekt für Schreibtisch oder Spielzeugauto, nichts für die Fahrsicherheit in einem echten Fahrzeug. Du lernst: Ultraschallmessung, Spannungsteiler für das 5-V-Echosignal, Messwerte ans Panel melden.

Video

Schaltplan

ESP32 Bluetooth Parksensor (HC-SR04) - Schaltplan

Quellcode

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Park                   │
5// └───────────────────────────┘
6// Parksensor
7// Board in der Arduino IDE: ESP32 Dev Module
8// die BLE-Bibliothek kommt mit dem ESP32-Boardpaket, nichts extra zu installieren
9
10#include <BLEDevice.h>
11#include <BLEServer.h>
12#include <BLE2902.h>
13
14const char BLE_NAME[] = "BG-Park";  // das Board sendet unter diesem Namen, die App findet es damit in der Liste
15
16// Pins: hier ändern, wenn du anders verkabelt hast
17const int TRIG_PIN = 5, ECHO_PIN = 18;  // ECHO liefert 5 V: über einen 1k/2k-Teiler anschließen
18const int BUZZER_PIN = 19;
19const int ALARM_FROM_CM = 100;  // Alarm: unter 100 cm piept es schneller, je näher das Hindernis kommt, unter 10 cm dauerhaft
20
21void btWrite(const char *text);
22void onValue(const char *key, const char *value);
23void sendAll();
24void onLinkLost();
25
26// ── Die App sendet Zeilen im Format "Schlüssel=Wert"; bei "?" schickt das Board alle Werte ──
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");  // die Zeile "@v" meldet der App die Codeversion
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// eingehende Bytes gelangen über einen kleinen Ringpuffer vom Bluetooth-Task in 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// Zeilen gehen in 20-Byte-Paketen raus (klappt mit jedem Handy)
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;  // kein Echo: nichts innerhalb von 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

Klappt das mit dem iPhone?

Ja. Das eingebaute Bluetooth Low Energy (BLE) des ESP32 spricht mit iPhone und Android. Ein iPhone kann sich nicht mit klassischen Bluetooth-Modulen wie HC-05 und HC-06 verbinden, die brauchst du hier aber auch nicht. Versuch nicht, das Board in den Bluetooth-Einstellungen des Handys zu koppeln; BLE-Boards tauchen dort oft gar nicht auf, das ist normal. Die Verbindung stellt die BlueGrays-App her.

Wozu der Spannungsteiler? Kann ich ECHO direkt anschließen?

Der HC-SR04 läuft mit 5 V und gibt an ECHO ein 5-V-Signal aus. Die Pins des ESP32 arbeiten mit 3,3 V und sind nicht 5-V-fest. Die Widerstände mit 1 kΩ und 2 kΩ teilen das Signal, an GPIO 18 kommen etwa 3,3 V an. Direkt verbunden scheint die Schaltung vielleicht zu funktionieren, du kannst den Pin aber beschädigen; lass den Teiler nicht weg. TRIG braucht keinen Teiler, denn dort sendet das Board das Signal. Hast du keinen 2-kΩ-Widerstand, schalte zwei mit 1 kΩ hintereinander (in Reihe).

Kann ich das in mein echtes Auto einbauen?

Nein, das ist ein Lern- und Modellprojekt. Auf dem Schreibtisch, am Spielzeugauto oder beim Herantasten an die Garagenwand tut es seinen Dienst. HC-SR04 und Breadboard sind nicht für Regen, Schmutz und Vibration gebaut; an weichen oder schrägen Flächen misst der Sensor falsch, und die Bluetooth-Verbindung kann abreißen. Es ist kein Parksystem für die Fahrsicherheit in einem echten Fahrzeug, verlass dich dort nicht darauf.

Piept es auch, wenn kein Handy verbunden ist?

Ja. Messen und Piepen laufen auf dem Board; das Handy zeigt nur den Abstand und schaltet den Ton aus und ein. Das Board startet bei jedem Einschalten mit Warnton an, an einer Powerbank piept es also auch ohne Handy ab 100 cm. Reißt die Verbindung ab, laufen Messung und Piepen weiter. Hast du den Ton mit dem Schalter im Panel ausgeschaltet, bleibt es still, bis du ihn wieder einschaltest oder das Board neu startet. Internet und WLAN brauchst du nie.