ES-111Principiante

ESP32 Bluetooth Serratura con servo

Comanda un servo SG90 come chiavistello dal telefono via Bluetooth: chiudi, apri o regola l'angolo, senza internet né Wi-Fi. Questo progetto è la guida passo passo del modello Bluetooth Serratura con servo dell'app: un ESP32, un servo e 3 cavetti. Vai in La Mia Officina › Dispositivi › Aggiungi dispositivo › Bluetooth, scegli questo modello e carica il codice con Ottieni il codice. Anche il pulsante Configura come pannello Bluetooth di questa pagina porta lì.

0.0(0)
ESP32 Bluetooth Serratura con servo
Tocca l'interruttore sul telefono e il servo chiude il chiavistello a 90 gradi; tocca di nuovo e lo riapre a 0. Niente internet né router: il telefono parla direttamente con l'ESP32 via Bluetooth. Il cursore regola l'angolo da 0 a 180 gradi. La scheda parte chiusa e, se la serratura è aperta quando cade il collegamento, si richiude da sola. L'SG90 è un piccolo servo da modellismo: serve a imparare con il chiavistello di una scatola, un cassetto o un modellino, non sostituisce una vera serratura per porte o oggetti di valore. Nell'app scegli Bluetooth e Serratura con servo, carica con Ottieni il codice e trova la scheda nell'elenco. Impari: angoli del servo, testo via Bluetooth Low Energy e una scheda che comunica il suo stato.

Video

Schema circuito

ESP32 Bluetooth Serratura con servo - Schema circuito

Codice sorgente

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Kilit                  │
5// └───────────────────────────┘
6// Serratura con servo
7// Scheda in Arduino IDE: ESP32 Dev Module
8// la libreria BLE arriva con il pacchetto schede ESP32, niente da installare in più
9
10#include <BLEDevice.h>
11#include <BLEServer.h>
12#include <BLE2902.h>
13#include <ESP32Servo.h>  // Gestore librerie: 'ESP32Servo'
14
15const char BLE_NAME[] = "BG-Kilit";  // la scheda si annuncia con questo nome e l’app la trova così nell’elenco
16
17// Pin: cambiali qui se hai collegato in modo diverso
18const int SERVO_PIN = 13;
19const int LOCKED_ANGLE = 90, OPEN_ANGLE = 0;  // angoli del servo per chiuso e aperto
20const bool LOCK_ON_DISCONNECT = true;  // Se la connessione cade la serratura si chiude (metti false per lasciarla com’è)
21
22void btWrite(const char *text);
23void onValue(const char *key, const char *value);
24void sendAll();
25void onLinkLost();
26
27// ── L’app invia righe "chiave=valore"; con "?" la scheda manda tutti i suoi valori ──
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");  // la riga "@v" comunica all’app la versione del codice
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// i byte in arrivo passano dal task Bluetooth a loop() tramite un piccolo buffer circolare
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// le righe partono in pacchetti da 20 byte (funziona con ogni telefono)
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

Funziona con l'iPhone?

Sì. Il Bluetooth Low Energy (BLE) integrato nell'ESP32 parla sia con iPhone sia con Android. Un iPhone non può collegarsi ai moduli Bluetooth classici come HC-05 e HC-06, e questo progetto non ne ha bisogno. Non provare ad associare la scheda dalle impostazioni Bluetooth del telefono; le schede BLE possono non comparire lì, è normale. La connessione la crea l'app BlueGrays.

Perché si chiude da sola quando cade il collegamento?

È voluto. Dato che l'impostazione LOCK_ON_DISCONNECT nel codice è true, la scheda riporta il chiavistello all'angolo di chiusura (90 gradi) quando il telefono si allontana o l'app viene chiusa; così la serratura non resta aperta per distrazione. Anche all'accensione la scheda parte chiusa. Se preferisci che resti aperta, metti quel valore a false e carica di nuovo il codice. La stessa protezione vale se hai aperto il chiavistello con il cursore Angolo del servo invece che con l'interruttore Serratura: per la scheda qualsiasi angolo diverso da 90 è aperto.

Posso chiudere una porta vera o una cassaforte con questo?

No, è un progetto per imparare. L'SG90 è un piccolo servo da modellismo con ingranaggi di plastica; la squadretta gira se la forzi e, senza alimentazione, non oppone più resistenza. Inoltre il collegamento Bluetooth di questo codice non ha password: anche un altro telefono nelle vicinanze può collegarsi alla scheda e inviare comandi. Provalo sul chiavistello di una scatola, di un cassetto o di una porta in miniatura; non affidargli una porta vera né oggetti di valore.

Che differenza c'è tra l'interruttore e il cursore dell'angolo?

L'interruttore Serratura porta il chiavistello in due posizioni scritte nel codice: chiuso a 90 gradi, aperto a 0. A ogni cambio la scheda comunica il nuovo angolo al pannello e il cursore si sposta su quel valore. Il cursore Angolo del servo invece ruota la squadretta dove vuoi tra 0 e 180 gradi; è comodo per scoprire dove il tuo chiavistello chiude davvero. Scrivi i valori trovati nelle righe LOCKED_ANGLE e OPEN_ANGLE del codice. Se porti il cursore su un angolo diverso da 90, la scheda considera aperta la serratura e anche l'interruttore Serratura del pannello lo mostra; tornando esattamente a 90 risulta di nuovo chiusa.