ESP32 Bluetooth Serrure à servo
Pilote un servo SG90 comme un petit loquet depuis ton téléphone en Bluetooth : verrouille, ouvre ou règle l'angle, sans internet ni Wi-Fi. Ce projet est le guide pas à pas du modèle Bluetooth Serrure à servo de l'appli : un ESP32, un servo et 3 fils. Va dans Mon Atelier › Appareils › Ajouter un appareil › Bluetooth, choisis ce modèle et téléverse le code avec Obtenir le code. Le bouton Configurer en panneau Bluetooth de cette page ouvre le même assistant.

Vidéo
Schéma du circuit

Code source
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32 │
4// │ BG-Kilit │
5// └───────────────────────────┘
6// Serrure à servo
7// Carte dans l’IDE Arduino : ESP32 Dev Module
8// la bibliothèque BLE est fournie avec le paquet de cartes ESP32, rien à installer en plus
9
10#include <BLEDevice.h>
11#include <BLEServer.h>
12#include <BLE2902.h>
13#include <ESP32Servo.h> // Gestionnaire de bibliothèques : 'ESP32Servo'
14
15const char BLE_NAME[] = "BG-Kilit"; // la carte s’annonce sous ce nom, l’appli la retrouve ainsi dans la liste
16
17// Broches : modifie-les ici si tu as câblé autrement
18const int SERVO_PIN = 13;
19const int LOCKED_ANGLE = 90, OPEN_ANGLE = 0; // angles du servo pour verrouillé et ouvert
20const bool LOCK_ON_DISCONNECT = true; // Si la connexion coupe, la serrure se ferme (mets false pour la laisser telle quelle)
21
22void btWrite(const char *text);
23void onValue(const char *key, const char *value);
24void sendAll();
25void onLinkLost();
26
27// ── L’appli envoie des lignes "clé=valeur" ; sur "?", la carte renvoie toutes ses valeurs ──
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 ligne "@v" indique à l’appli la version du code
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// les octets reçus passent de la tâche Bluetooth à loop() par un petit tampon circulaire
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// les lignes partent en paquets de 20 octets (compatible avec tous les téléphones)
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
Est-ce que ça marche avec un iPhone ?
Oui. Le Bluetooth Low Energy (BLE) intégré à l'ESP32 parle aussi bien à l'iPhone qu'à Android. Un iPhone ne peut pas se connecter aux modules Bluetooth classiques comme le HC-05 et le HC-06, et ce projet n'en a pas besoin. N'essaie pas d'appairer la carte dans les réglages Bluetooth du téléphone ; les cartes BLE peuvent ne pas y apparaître, c'est normal. C'est l'appli BlueGrays qui établit la connexion.
Pourquoi se verrouille-t-elle toute seule quand la connexion est coupée ?
C'est voulu. Comme le réglage LOCK_ON_DISCONNECT du code vaut true, la carte ramène le loquet à l'angle verrouillé (90 degrés) dès que le téléphone s'éloigne ou que l'appli se ferme ; la serrure ne reste donc pas ouverte par oubli. La carte démarre aussi verrouillée à la mise sous tension. Si tu préfères qu'elle reste ouverte, passe cette valeur à false et téléverse de nouveau le code. La même protection joue si tu as ouvert le loquet avec le curseur Angle du servo plutôt qu'avec l'interrupteur Serrure : la carte considère comme ouvert tout angle autre que 90.
Est-ce que je peux verrouiller une vraie porte ou un coffre avec ?
Non, c'est un projet pour apprendre. Le SG90 est un petit servo de modélisme à engrenages en plastique ; son bras tourne si on le force et, sans alimentation, il ne retient plus rien. En plus, la liaison Bluetooth de ce code n'a pas de mot de passe : un autre téléphone à proximité peut lui aussi se connecter à la carte et envoyer des commandes. Essaie-le sur le loquet d'une boîte, d'un tiroir ou d'une porte de maquette ; ne lui confie ni une vraie porte ni des objets de valeur.
Quelle est la différence entre l'interrupteur et le curseur d'angle ?
L'interrupteur Serrure amène le loquet à deux positions écrites dans le code : verrouillé à 90 degrés, ouvert à 0. À chaque changement, la carte renvoie le nouvel angle au panneau et le curseur se cale sur cette valeur. Le curseur Angle du servo, lui, tourne le bras où tu veux entre 0 et 180 degrés ; pratique pour trouver où ton loquet ferme vraiment. Reporte les valeurs trouvées dans les lignes LOCKED_ANGLE et OPEN_ANGLE du code. Si tu places le curseur sur un autre angle que 90, la carte considère la serrure comme ouverte et l'interrupteur Serrure du panneau l'indique aussi ; de retour sur 90 exactement, il affiche de nouveau verrouillé.
