ES-111Începător

Încuietoare cu servomotor și ESP32 prin Bluetooth

Controlează un servomotor SG90 ca zăvor de pe telefon prin Bluetooth: încuie, deschide sau reglează unghiul, fără internet ori Wi-Fi. Ghid pentru șablonul Bluetooth Încuietoare cu servomotor, cu ESP32, un servomotor și 3 fire. Mergi la Atelier › Dispozitive › Adaugă un dispozitiv › Bluetooth, alege șablonul și încarcă prin Obține codul. Butonul Configurează ca panou Bluetooth deschide asistentul cu acest șablon.

0.0(0)
Încuietoare cu servomotor și ESP32 prin Bluetooth
Atinge comutatorul de încuietoare de pe telefon, iar servomotorul se rotește la 90 de grade și închide zăvorul; atinge din nou, iar acesta revine la 0 și îl deschide. Fără internet sau router: telefonul se conectează direct la ESP32 prin Bluetooth. Un glisor reglează unghiul între 0 și 180 de grade. La pornirea plăcii, încuietoarea este închisă; dacă este deschisă când se pierde conexiunea, se închide automat. SG90 este un servomotor mic pentru hobby: acesta este un proiect educativ pentru zăvorul unei cutii, al unui sertar sau al unei uși de machetă și nu înlocuiește o încuietoare adevărată pentru uși sau obiecte de valoare. În aplicație, alege Bluetooth și șablonul Încuietoare cu servomotor, încarcă prin Obține codul și găsește placa în listă. Înveți despre unghiurile servomotorului, trimiterea unor linii scurte de text prin Bluetooth Low Energy și raportarea stării plăcii către panou.

Video

Schemă electrică

Încuietoare cu servomotor și ESP32 prin Bluetooth - Schemă electrică

Cod sursă

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Kilit                  │
5// └───────────────────────────┘
6// Servo lock
7// Arduino IDE board: ESP32 Dev Module
8// the BLE library comes with the ESP32 board package, nothing extra to install
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";  // the board advertises with this name, the app finds it in the list by it
16
17// Pins: change them here if you wired differently
18const int SERVO_PIN = 13;
19const int LOCKED_ANGLE = 90, OPEN_ANGLE = 0;  // servo angles for locked and open
20const bool LOCK_ON_DISCONNECT = true;  // If the connection drops the lock closes (set false to leave it as it is)
21
22void btWrite(const char *text);
23void onValue(const char *key, const char *value);
24void sendAll();
25void onLinkLost();
26
27// ── The app sends "key=value" lines; on "?" the board sends all its values ──
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");  // the "@v" line tells the app the code version
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// incoming bytes move from the Bluetooth task to loop() through a small ring buffer
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// lines go out in 20-byte packets (works with every phone)
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

Întrebări frecvente

Funcționează și cu iPhone?

Da. Funcția Bluetooth Low Energy (BLE) integrată în ESP32 permite comunicarea atât cu iPhone, cât și cu Android. Un iPhone nu se poate conecta la module Bluetooth clasic precum HC-05 și HC-06, iar acest proiect nu are nevoie de ele. Nu încerca să asociezi placa din setările Bluetooth ale telefonului; plăcile BLE pot să nu apară acolo, ceea ce este normal. Conexiunea se face din aplicația BlueGrays.

De ce se închide automat încuietoarea când se pierde conexiunea?

Așa este prevăzut să funcționeze. Setarea LOCK_ON_DISCONNECT din cod are valoarea true, așa că placa readuce zăvorul la unghiul de închidere (90 de grade) când telefonul iese din raza de acțiune sau aplicația se închide. Astfel, încuietoarea nu rămâne deschisă din greșeală. La pornirea plăcii, încuietoarea este tot închisă. Dacă vrei să rămână deschisă, schimbă valoarea în false și încarcă din nou codul. Aceeași protecție funcționează și dacă ai deschis zăvorul cu glisorul Unghi servomotor în locul comutatorului Încuietoare: placa consideră încuietoarea deschisă la orice unghi diferit de 90.

Pot încuia cu el o ușă adevărată sau un seif?

Nu, acesta este un proiect educativ. SG90 este un servomotor mic pentru hobby, cu roți dințate din plastic; brațul se rotește dacă îl forțezi, iar la întreruperea alimentării nu mai poate menține poziția. În plus, conexiunea Bluetooth din acest cod nu are parolă: și alt telefon din apropiere se poate conecta la placă și poate trimite comenzi. Încearcă-l pe zăvorul unei cutii, al unui sertar sau al unei uși de machetă; nu îl folosi pentru a proteja o ușă adevărată sau obiecte de valoare.

Care este diferența dintre comutatorul de încuietoare și glisorul pentru unghi?

Comutatorul Încuietoare mută zăvorul în două poziții definite în cod: închis la 90 de grade, deschis la 0. La fiecare schimbare, placa trimite noul unghi către panou, iar glisorul trece la acea valoare. Glisorul Unghi servomotor rotește brațul în orice poziție între 0 și 180 de grade; este util pentru a găsi unghiul exact la care se închide zăvorul. Scrie valorile găsite în liniile LOCKED_ANGLE și OPEN_ANGLE din cod. Când muți glisorul la orice unghi diferit de 90, placa consideră încuietoarea deschisă, iar comutatorul Încuietoare din panou indică și el acest lucru; la revenirea exact la 90, apare din nou ca închisă.