ESP32 Bluetooth-servoslot
Bedien een SG90-servo als klein grendeltje met je telefoon via Bluetooth: vergrendel, open of stel de hoek in, zonder internet of Wi-Fi. Dit project is de stap-voor-stapgids bij het Bluetooth-sjabloon Servoslot in de app, gebouwd met een ESP32, één servo en 3 draden. Ga naar Werkplaats › Apparaten › Apparaat toevoegen › Bluetooth, kies Servoslot en upload de code met Code ophalen. De knop Instellen als Bluetooth-paneel op deze pagina opent de wizard ook met dit sjabloon.

Video
Schakelschema

Broncode
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32 │
4// │ BG-Kilit │
5// └───────────────────────────┘
6// Servoslot
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#include <ESP32Servo.h> // Library Manager: 'ESP32Servo'
14
15const char BLE_NAME[] = "BG-Kilit"; // het board zendt deze naam uit, de app herkent het in de lijst aan deze naam
16
17// Pinnen: pas ze hier aan als je anders hebt aangesloten
18const int SERVO_PIN = 13;
19const int LOCKED_ANGLE = 90, OPEN_ANGLE = 0; // servohoeken voor vergrendeld en open
20const bool LOCK_ON_DISCONNECT = true; // Valt de verbinding weg, dan gaat het slot dicht (zet op false om het te laten zoals het is)
21
22void btWrite(const char *text);
23void onValue(const char *key, const char *value);
24void sendAll();
25void onLinkLost();
26
27// ── De app stuurt regels "sleutel=waarde"; bij "?" stuurt het board al zijn waarden ──
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"); // de regel "@v" geeft de app de codeversie door
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// binnenkomende bytes gaan via een kleine ringbuffer van de Bluetooth-taak naar 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// regels worden in pakketten van 20 bytes verstuurd (werkt met elke telefoon)
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}
204Veelgestelde 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 niet verbinden met klassieke Bluetooth-modules zoals de HC-05 en HC-06, en dit project heeft ze 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 vergrendelt het zichzelf als de verbinding wegvalt?
Dat is met opzet. Omdat de instelling LOCK_ON_DISCONNECT in de code true is, draait het board de grendel terug naar de vergrendelde hoek (90 graden) wanneer de telefoon buiten bereik raakt of de app wordt gesloten, zodat het slot niet per ongeluk open blijft. Het board start bij het opstarten ook vergrendeld. Wil je dat het open blijft, zet die waarde dan op false en upload de code opnieuw. Dezelfde beveiliging werkt als je de grendel hebt geopend met de schuifregelaar Servohoek in plaats van de schakelaar Slot: het board beschouwt elke andere hoek dan 90 als open.
Kan ik er een echte deur of een kluis mee afsluiten?
Nee, dit is een leerproject. De SG90 is een kleine hobbyservo met plastic tandwielen; de hoorn draait mee als je kracht zet en zonder stroom heeft hij geen houdkracht meer. Bovendien heeft de Bluetooth-verbinding in deze code geen wachtwoord: een andere telefoon in de buurt kan ook verbinding maken met het board en commando's sturen. Probeer het op de grendel van een doos, een lade of een modeldeur; vertrouw er geen echte deur of kostbaarheden aan toe.
Wat is het verschil tussen de slotschakelaar en de hoekschuifregelaar?
De schakelaar Slot zet de grendel in twee standen die in de code staan: vergrendeld op 90 graden, open op 0. Bij elke wijziging meldt het board de nieuwe hoek aan het paneel, zodat de schuifregelaar naar die waarde springt. De schuifregelaar Servohoek draait de hoorn juist naar elke hoek tussen 0 en 180 graden; handig om te vinden waar je grendel echt sluit. Schrijf de waarden die je vindt in de regels LOCKED_ANGLE en OPEN_ANGLE van de code. Als je de schuifregelaar op een andere hoek dan 90 zet, beschouwt het board het slot als open en toont de schakelaar Slot in het paneel dat ook; precies terug op 90 staat hij weer op vergrendeld.
