ESP32 Bluetooth LED et relais
Allume et éteins une LED et un relais depuis ton téléphone en Bluetooth, sans internet ni Wi-Fi. Ce projet est le guide pas à pas du modèle Bluetooth LED et relais de l'appli, monté avec un ESP32 et un module relais 5 V. Va dans Mon Atelier › Appareils › Ajouter un appareil › Bluetooth, choisis LED et relais et téléverse le code avec Obtenir le code. Le bouton Configurer en panneau Bluetooth de cette page ouvre aussi l'assistant avec ce modèle.

Vidéo
Schéma du circuit

Code source
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32 │
4// │ BG-Lamba │
5// └───────────────────────────┘
6// LED et relais
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
14const char BLE_NAME[] = "BG-Lamba"; // la carte s’annonce sous ce nom, l’appli la retrouve ainsi dans la liste
15
16// Broches : modifie-les ici si tu as câblé autrement
17const int LED_PIN = 2;
18const int RELAY_PIN = 26;
19const bool RELAY_ACTIVE_LOW = true; // la plupart des modules relais s’activent sur LOW
20
21void btWrite(const char *text);
22void onValue(const char *key, const char *value);
23void sendAll();
24void onLinkLost();
25
26// ── L’appli envoie des lignes "clé=valeur" ; sur "?", la carte renvoie toutes ses valeurs ──
27char line[65];
28uint8_t lineLen = 0;
29unsigned long lastRxMs = 0;
30
31bool is(const char *a, const char *b) { return strcmp(a, b) == 0; }
32bool isOn(const char *v) { return v[0] == '1'; }
33
34void sendText(const char *key, const char *value) {
35 char out[72];
36 snprintf(out, sizeof(out), "%s=%s\n", key, value);
37 btWrite(out);
38}
39
40void sendInt(const char *key, long value) {
41 char text[12];
42 snprintf(text, sizeof(text), "%ld", value);
43 sendText(key, text);
44}
45
46void sendFloat(const char *key, float value) {
47 char text[16];
48 dtostrf(value, 1, 1, text);
49 sendText(key, text);
50}
51
52void handleLine(char *text) {
53 char *eq = strchr(text, '=');
54 if (eq == nullptr) {
55 if (text[strlen(text) - 1] == '?') {
56 btWrite("@v=1.0\n"); // la ligne "@v" indique à l’appli la version du code
57 sendAll();
58 }
59 return;
60 }
61 *eq = '\0';
62 onValue(text, eq + 1);
63}
64
65void feed(char c) {
66 lastRxMs = millis();
67 if (c == '\n' || c == '\r') {
68 if (lineLen == 0) return;
69 line[lineLen] = '\0';
70 lineLen = 0;
71 handleLine(line);
72 } else if (lineLen < sizeof(line) - 1) {
73 line[lineLen++] = c;
74 }
75}
76
77// ── Bluetooth (Nordic UART) ──
78#define UART_SERVICE "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
79#define UART_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
80#define UART_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"
81
82BLECharacteristic *txChar = nullptr;
83volatile bool linked = false;
84volatile bool linkLost = false;
85// les octets reçus passent de la tâche Bluetooth à loop() par un petit tampon circulaire
86const int RX_SIZE = 256;
87volatile uint8_t rxBuf[RX_SIZE];
88volatile int rxHead = 0, rxTail = 0;
89
90class ServerEvents : public BLEServerCallbacks {
91 void onConnect(BLEServer *server) override { linked = true; }
92 void onDisconnect(BLEServer *server) override { linked = false; linkLost = true; }
93};
94
95class RxEvents : public BLECharacteristicCallbacks {
96 void onWrite(BLECharacteristic *c) override {
97 auto v = c->getValue();
98 for (size_t i = 0; i < v.length(); i++) {
99 int next = (rxHead + 1) % RX_SIZE;
100 if (next == rxTail) break;
101 rxBuf[rxHead] = (uint8_t)v[i];
102 rxHead = next;
103 }
104 }
105};
106
107// les lignes partent en paquets de 20 octets (compatible avec tous les téléphones)
108void btWrite(const char *text) {
109 if (!linked || txChar == nullptr) return;
110 size_t n = strlen(text);
111 for (size_t i = 0; i < n; i += 20) {
112 size_t len = n - i < 20 ? n - i : 20;
113 txChar->setValue((uint8_t *)text + i, len);
114 txChar->notify();
115 delay(4);
116 }
117}
118
119void btBegin() {
120 BLEDevice::init(BLE_NAME);
121 BLEServer *server = BLEDevice::createServer();
122 server->setCallbacks(new ServerEvents());
123 BLEService *uart = server->createService(UART_SERVICE);
124 txChar = uart->createCharacteristic(UART_TX, BLECharacteristic::PROPERTY_NOTIFY);
125 txChar->addDescriptor(new BLE2902());
126 BLECharacteristic *rx = uart->createCharacteristic(UART_RX, BLECharacteristic::PROPERTY_WRITE | BLECharacteristic::PROPERTY_WRITE_NR);
127 rx->setCallbacks(new RxEvents());
128 uart->start();
129 BLEAdvertisementData adv;
130 adv.setFlags(0x06);
131 adv.setCompleteServices(BLEUUID(UART_SERVICE));
132 BLEAdvertisementData scan;
133 scan.setName(BLE_NAME);
134 BLEAdvertising *advertising = BLEDevice::getAdvertising();
135 advertising->setAdvertisementData(adv);
136 advertising->setScanResponseData(scan);
137 BLEDevice::startAdvertising();
138}
139
140void btPoll() {
141 while (rxTail != rxHead) {
142 char c = (char)rxBuf[rxTail];
143 rxTail = (rxTail + 1) % RX_SIZE;
144 feed(c);
145 }
146 if (linkLost) {
147 linkLost = false;
148 onLinkLost();
149 delay(100);
150 BLEDevice::startAdvertising();
151 }
152}
153
154// ── ESP32 ──
155bool ledOn = false, relayOn = false;
156
157void setRelay(bool on) {
158 if (RELAY_ACTIVE_LOW) {
159 if (on) { pinMode(RELAY_PIN, OUTPUT); digitalWrite(RELAY_PIN, LOW); }
160 else { pinMode(RELAY_PIN, INPUT); } // éteindre libère la broche : un HIGH à 3,3 V ne suffit pas à couper un module 5 V
161 } else {
162 pinMode(RELAY_PIN, OUTPUT); digitalWrite(RELAY_PIN, on ? HIGH : LOW);
163 }
164}
165
166void apply() {
167 digitalWrite(LED_PIN, ledOn ? HIGH : LOW);
168 setRelay(relayOn);
169}
170
171void onValue(const char *key, const char *value) {
172 if (is(key, "led")) ledOn = isOn(value);
173 else if (is(key, "role")) relayOn = isOn(value);
174 apply();
175}
176
177void sendAll() {
178 sendInt("led", ledOn);
179 sendInt("role", relayOn);
180}
181
182void onLinkLost() {
183}
184
185void setup() {
186 Serial.begin(115200);
187 pinMode(LED_PIN, OUTPUT);
188 apply();
189 btBegin();
190 Serial.print(F("BlueGrays Bluetooth: "));
191 Serial.println(BLE_NAME);
192}
193
194void loop() {
195 btPoll();
196}
197FAQ
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.
Je peux brancher une vraie lampe sur le relais ?
Le module relais peut commuter le 230 V, mais le secteur peut tuer. Dans ce projet, rien n'est branché sur les bornes COM et NO ; le relais montre qu'il fonctionne par son clic et la LED du module. Pour tester une charge, commence par un circuit basse tension, comme une pile ou un adaptateur 12 V. Si tu passes au 230 V, fais-le avec quelqu'un d'expérimenté, ne laisse aucun fil ni vis à nu et reste sous le courant indiqué sur le module.
Pourquoi la LED bleue de la carte s'allume en même temps que ma LED ?
Sur beaucoup de cartes ESP32 DevKit, la LED bleue intégrée est elle aussi reliée à GPIO2. Ta LED est sur la même broche, donc les deux clignotent ensemble ; ce n'est pas une panne. C'est même pratique : si un fil est mal branché, la LED bleue montre quand même que l'ordre est arrivé. Si tu n'en veux pas, déplace ta LED sur une autre broche (par exemple GPIO4) et change LED_PIN dans le code.
Faut-il internet ou le Wi-Fi, et quelle est la portée ?
Non. Ton téléphone se connecte directement à la carte en Bluetooth, sans box ni serveur. À l'intérieur, la portée tourne en général autour de 10 mètres, et les murs la réduisent. La carte ne se connecte qu'à un téléphone à la fois ; quand il se déconnecte, la carte se remet à émettre et un autre téléphone peut se connecter. Pour la piloter depuis l'extérieur, choisis un projet qui utilise le panneau IoT Wi-Fi de l'appli.
