ES-108Débutant

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.

0.0(0)
ESP32 Bluetooth LED et relais
Touche un interrupteur sur ton téléphone et le relais sur ton bureau claque : ni internet, ni box, ni serveur. L'ESP32 a le Bluetooth intégré, ton téléphone se connecte directement à la carte et deux interrupteurs du panneau pilotent la LED et le relais. À l'ouverture du panneau, la carte envoie son état réel, donc l'écran montre ce que fait la carte. Dans l'appli, ajoute un appareil, choisis Bluetooth et le modèle LED et relais, téléverse le code avec Obtenir le code puis trouve ta carte dans la liste. Le bouton de cette page y mène aussi. Tu apprends : dialoguer en Bluetooth Low Energy avec de courtes lignes de texte, un relais qui s'enclenche sur LOW et une carte qui renvoie son état au panneau. Note sur le relais : cette carte fonctionne en 3,3 V. Utilise un module relais avec optocoupleur, qui se déclenche avec un signal de 3,3 V ; les modules 5 V sans optocoupleur risquent de ne pas se couper avec un signal de 3,3 V.

Vidéo

Schéma du circuit

ESP32 Bluetooth LED et relais - Schéma du circuit

Code source

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

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.

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.