ES-111Anfänger

ESP32 Bluetooth Servo-Schloss

Steuere einen SG90-Servo als Riegel per Bluetooth vom Handy: verriegeln, öffnen, Winkel einstellen, ohne Internet oder WLAN. Dieses Projekt ist die Schritt-für-Schritt-Anleitung zur Bluetooth-Vorlage Servo-Schloss der App: ESP32, ein Servo und 3 Kabel. Geh zu Werkstatt › Geräte › Gerät hinzufügen › Bluetooth, wähle Servo-Schloss und lade den Code mit Code holen hoch. Auch der Button Als Bluetooth-Panel einrichten auf dieser Seite startet diesen Assistenten.

0.0(0)
ESP32 Bluetooth Servo-Schloss
Tipp am Handy auf den Schalter: Der Servo schließt den Riegel bei 90 Grad; noch ein Tipp, und er öffnet bei 0. Ohne Internet und Router: Das Handy spricht per Bluetooth direkt mit dem ESP32. Der Regler stellt 0 bis 180 Grad ein. Das Board startet verriegelt; ist das Schloss offen, wenn die Verbindung abbricht, verriegelt es wieder. Der SG90 ist ein kleiner Hobby-Servo: also ein Lernprojekt für den Riegel einer Schachtel, Schublade oder Modelltür, kein Ersatz für ein echtes Schloss an Tür oder Wertsachen. Wähle in der App Bluetooth und Servo-Schloss, lade den Code mit Code holen hoch und such dein Board in der Liste. Du lernst: Servowinkel, Textzeilen über Bluetooth Low Energy und ein Board, das seinen Zustand meldet.

Video

Schaltplan

ESP32 Bluetooth Servo-Schloss - Schaltplan

Quellcode

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Kilit                  │
5// └───────────────────────────┘
6// Servo-Schloss
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#include <ESP32Servo.h>  // Bibliotheksverwalter: 'ESP32Servo'
14
15const char BLE_NAME[] = "BG-Kilit";  // das Board sendet unter diesem Namen, die App findet es damit in der Liste
16
17// Pins: hier ändern, wenn du anders verkabelt hast
18const int SERVO_PIN = 13;
19const int LOCKED_ANGLE = 90, OPEN_ANGLE = 0;  // Servowinkel für verriegelt und offen
20const bool LOCK_ON_DISCONNECT = true;  // Reißt die Verbindung ab, schließt das Schloss (false lässt es, wie es ist)
21
22void btWrite(const char *text);
23void onValue(const char *key, const char *value);
24void sendAll();
25void onLinkLost();
26
27// ── Die App sendet Zeilen im Format "Schlüssel=Wert"; bei "?" schickt das Board alle Werte ──
28char line[65];
29uint8_t lineLen = 0;
30unsigned long lastRxMs = 0;
31
32bool is(const char *a, const char *b) { return strcmp(a, b) == 0; }
33bool isOn(const char *v) { return v[0] == '1'; }
34
35void sendText(const char *key, const char *value) {
36  char out[72];
37  snprintf(out, sizeof(out), "%s=%s\n", key, value);
38  btWrite(out);
39}
40
41void sendInt(const char *key, long value) {
42  char text[12];
43  snprintf(text, sizeof(text), "%ld", value);
44  sendText(key, text);
45}
46
47void sendFloat(const char *key, float value) {
48  char text[16];
49  dtostrf(value, 1, 1, text);
50  sendText(key, text);
51}
52
53void handleLine(char *text) {
54  char *eq = strchr(text, '=');
55  if (eq == nullptr) {
56    if (text[strlen(text) - 1] == '?') {
57      btWrite("@v=1.0\n");  // die Zeile "@v" meldet der App die Codeversion
58      sendAll();
59    }
60    return;
61  }
62  *eq = '\0';
63  onValue(text, eq + 1);
64}
65
66void feed(char c) {
67  lastRxMs = millis();
68  if (c == '\n' || c == '\r') {
69    if (lineLen == 0) return;
70    line[lineLen] = '\0';
71    lineLen = 0;
72    handleLine(line);
73  } else if (lineLen < sizeof(line) - 1) {
74    line[lineLen++] = c;
75  }
76}
77
78// ── Bluetooth (Nordic UART) ──
79#define UART_SERVICE "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
80#define UART_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
81#define UART_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"
82
83BLECharacteristic *txChar = nullptr;
84volatile bool linked = false;
85volatile bool linkLost = false;
86// eingehende Bytes gelangen über einen kleinen Ringpuffer vom Bluetooth-Task in loop()
87const int RX_SIZE = 256;
88volatile uint8_t rxBuf[RX_SIZE];
89volatile int rxHead = 0, rxTail = 0;
90
91class ServerEvents : public BLEServerCallbacks {
92  void onConnect(BLEServer *server) override { linked = true; }
93  void onDisconnect(BLEServer *server) override { linked = false; linkLost = true; }
94};
95
96class RxEvents : public BLECharacteristicCallbacks {
97  void onWrite(BLECharacteristic *c) override {
98    auto v = c->getValue();
99    for (size_t i = 0; i < v.length(); i++) {
100      int next = (rxHead + 1) % RX_SIZE;
101      if (next == rxTail) break;
102      rxBuf[rxHead] = (uint8_t)v[i];
103      rxHead = next;
104    }
105  }
106};
107
108// Zeilen gehen in 20-Byte-Paketen raus (klappt mit jedem Handy)
109void btWrite(const char *text) {
110  if (!linked || txChar == nullptr) return;
111  size_t n = strlen(text);
112  for (size_t i = 0; i < n; i += 20) {
113    size_t len = n - i < 20 ? n - i : 20;
114    txChar->setValue((uint8_t *)text + i, len);
115    txChar->notify();
116    delay(4);
117  }
118}
119
120void btBegin() {
121  BLEDevice::init(BLE_NAME);
122  BLEServer *server = BLEDevice::createServer();
123  server->setCallbacks(new ServerEvents());
124  BLEService *uart = server->createService(UART_SERVICE);
125  txChar = uart->createCharacteristic(UART_TX, BLECharacteristic::PROPERTY_NOTIFY);
126  txChar->addDescriptor(new BLE2902());
127  BLECharacteristic *rx = uart->createCharacteristic(UART_RX, BLECharacteristic::PROPERTY_WRITE | BLECharacteristic::PROPERTY_WRITE_NR);
128  rx->setCallbacks(new RxEvents());
129  uart->start();
130  BLEAdvertisementData adv;
131  adv.setFlags(0x06);
132  adv.setCompleteServices(BLEUUID(UART_SERVICE));
133  BLEAdvertisementData scan;
134  scan.setName(BLE_NAME);
135  BLEAdvertising *advertising = BLEDevice::getAdvertising();
136  advertising->setAdvertisementData(adv);
137  advertising->setScanResponseData(scan);
138  BLEDevice::startAdvertising();
139}
140
141void btPoll() {
142  while (rxTail != rxHead) {
143    char c = (char)rxBuf[rxTail];
144    rxTail = (rxTail + 1) % RX_SIZE;
145    feed(c);
146  }
147  if (linkLost) {
148    linkLost = false;
149    onLinkLost();
150    delay(100);
151    BLEDevice::startAdvertising();
152  }
153}
154
155// ── ESP32 ──
156Servo servo;
157bool locked = true;
158int angle = LOCKED_ANGLE;
159
160void moveTo(int a) {
161  angle = constrain(a, 0, 180);
162  servo.write(angle);
163}
164
165void onValue(const char *key, const char *value) {
166  if (is(key, "kilit")) {
167    locked = isOn(value);
168    moveTo(locked ? LOCKED_ANGLE : OPEN_ANGLE);
169    sendInt("aci", angle);
170  } else if (is(key, "aci")) {
171    moveTo(atoi(value));
172    if (locked != (angle == LOCKED_ANGLE)) {
173      locked = !locked;
174      sendInt("kilit", locked);
175    }
176  }
177}
178
179void sendAll() {
180  sendInt("kilit", locked);
181  sendInt("aci", angle);
182}
183
184void onLinkLost() {
185  if (LOCK_ON_DISCONNECT && !locked) {
186    locked = true;
187    moveTo(LOCKED_ANGLE);
188  }
189}
190
191void setup() {
192  Serial.begin(115200);
193  servo.setPeriodHertz(50);
194  servo.attach(SERVO_PIN, 500, 2500);
195  moveTo(LOCKED_ANGLE);
196  btBegin();
197  Serial.print(F("BlueGrays Bluetooth: "));
198  Serial.println(BLE_NAME);
199}
200
201void loop() {
202  btPoll();
203}
204

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.

Warum verriegelt das Board von selbst, wenn die Verbindung abreißt?

Das ist Absicht. Weil die Einstellung LOCK_ON_DISCONNECT im Code auf true steht, dreht das Board den Riegel auf den verriegelten Winkel (90 Grad) zurück, sobald das Handy außer Reichweite ist oder die App geschlossen wird; so bleibt das Schloss nicht versehentlich offen. Auch beim Einschalten startet das Board verriegelt. Soll der Riegel offen bleiben, setz den Wert auf false und lade den Code neu hoch. Derselbe Schutz greift auch, wenn du den Riegel statt mit dem Schalter Schloss mit dem Regler Servowinkel geöffnet hast: Für das Board ist jeder andere Winkel als 90 offen.

Kann ich damit eine echte Tür oder einen Tresor sichern?

Nein, das ist ein Lernprojekt. Der SG90 ist ein kleiner Hobby-Servo mit Kunststoffgetriebe; mit etwas Kraft lässt sich der Arm verdrehen, und ohne Strom hält er nicht mehr dagegen. Außerdem hat die Bluetooth-Verbindung in diesem Code kein Passwort: Auch ein anderes Handy in der Nähe kann sich mit dem Board verbinden und Befehle senden. Probier es am Riegel einer Schachtel, einer Schublade oder einer Modelltür aus; eine echte Tür oder Wertsachen vertraust du dem besser nicht an.

Was ist der Unterschied zwischen Schalter und Winkelregler?

Der Schalter Schloss fährt den Riegel auf zwei feste Positionen aus dem Code: verriegelt 90 Grad, offen 0 Grad. Bei jedem Wechsel meldet das Board den neuen Winkel an das Panel, und der Regler springt auf diesen Wert. Mit dem Regler Servowinkel drehst du den Arm dagegen auf jede Stelle zwischen 0 und 180 Grad; praktisch, um herauszufinden, wo dein Riegel wirklich schließt. Trag die gefundenen Werte im Code bei LOCKED_ANGLE und OPEN_ANGLE ein. Stellst du den Regler auf einen anderen Winkel als 90, gilt das Schloss für das Board als offen, und der Schalter Schloss im Panel zeigt das ebenfalls an; genau bei 90 zeigt er wieder verriegelt.