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.

Video
Schaltplan

Quellcode
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}
204FAQ
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.
