ES-111Débutant

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.

0.0(0)
ESP32 Bluetooth Serrure à servo
Touche l'interrupteur sur ton téléphone : le servo ferme le loquet à 90 degrés ; touche encore, il le rouvre à 0. Sans internet ni box : le téléphone parle directement à l'ESP32 en Bluetooth. Le curseur règle l'angle de 0 à 180 degrés. La carte démarre verrouillée et, si la serrure est ouverte quand la connexion tombe, se reverrouille. Le SG90 est un petit servo de modélisme : ce projet sert à apprendre avec le loquet d'une boîte, d'un tiroir ou d'une maquette, pas à remplacer une vraie serrure de porte ou d'objets de valeur. Dans l'appli, choisis Bluetooth et Serrure à servo, téléverse avec Obtenir le code et trouve ta carte dans la liste. Tu apprends : angles de servo, texte en Bluetooth Low Energy et retour d'état de la carte.

Vidéo

Schéma du circuit

ESP32 Bluetooth Serrure à servo - Schéma du circuit

Code source

C++ (Arduino IDE)
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}
204

FAQ

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é.