ES-110Intermédiaire

ESP32 Bluetooth Ruban LED RGB (WS2812B)

Change la couleur, la luminosité et l'effet de ton ruban depuis ton téléphone : l'ESP32 s'y connecte directement en Bluetooth, et le ruban WS2812B ne demande que 3 fils. Ce projet est le guide pas à pas du modèle Bluetooth Ruban LED RGB de l'app. Va dans Mon Atelier › Appareils › Ajouter un appareil › Bluetooth, choisis Ruban LED RGB et téléverse le code avec Obtenir le code. Le bouton Configurer en panneau Bluetooth de cette page ouvre l'assistant avec ce modèle.

0.0(0)
1 terminé
ESP32 Bluetooth Ruban LED RGB (WS2812B)
Envie de colorer ta chambre depuis ton téléphone ? Ici, l'ESP32 se connecte directement à ton téléphone en Bluetooth, sans internet, box ni serveur. Dans le panneau, tu allumes le ruban, choisis une couleur, règles la luminosité et lances un effet arc-en-ciel ou respiration. Dans l'app, ouvre Mon Atelier › Appareils › Ajouter un appareil › Bluetooth, choisis le modèle Ruban LED RGB, téléverse le code avec Obtenir le code, puis connecte-toi à l'étape Trouvez votre carte. Le bouton Configurer en panneau Bluetooth de cette page ouvre l'assistant avec ce modèle. Tu apprends : des commandes ligne par ligne en Bluetooth Low Energy, piloter un WS2812B avec Adafruit NeoPixel, la correction gamma et des effets fluides.

Vidéo

Schéma du circuit

ESP32 Bluetooth Ruban LED RGB (WS2812B) - Schéma du circuit

Code source

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Isik                   │
5// └───────────────────────────┘
6// Ruban LED RGB
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 <Adafruit_NeoPixel.h>  // Gestionnaire de bibliothèques : 'Adafruit NeoPixel'
14
15const char BLE_NAME[] = "BG-Isik";  // 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 STRIP_PIN = 5;
19const int LED_COUNT = 30;  // nombre de LED sur ta bande
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 ──
155Adafruit_NeoPixel strip(LED_COUNT, STRIP_PIN, NEO_GRB + NEO_KHZ800);
156bool stripOn = false;
157uint8_t cr = 255, cg = 255, cb = 255;
158int brightness = 70;
159char effect[16] = "sabit";
160uint16_t hue = 0;
161unsigned long lastFrameMs = 0;
162
163uint8_t level() { return map(brightness, 0, 100, 0, 255); }
164
165// correction gamma : les couleurs rendent sur les LED comme à l’écran
166void fillColor(uint32_t color, uint8_t bright) {
167  strip.setBrightness(bright);
168  strip.fill(strip.gamma32(color));
169  strip.show();
170}
171
172void paint() {
173  if (!stripOn) { strip.clear(); strip.show(); return; }
174  fillColor(strip.Color(cr, cg, cb), level());
175}
176
177void onValue(const char *key, const char *value) {
178  if (is(key, "acik")) {
179    stripOn = isOn(value);
180  } else if (is(key, "renk") && value[0] == '#' && strlen(value) == 7) {
181    long c = strtol(value + 1, nullptr, 16);
182    cr = c >> 16; cg = (c >> 8) & 0xFF; cb = c & 0xFF;
183  } else if (is(key, "parlaklik")) {
184    brightness = constrain(atoi(value), 0, 100);
185  } else if (is(key, "efekt")) {
186    strncpy(effect, value, sizeof(effect) - 1);
187  }
188  paint();
189}
190
191void sendAll() {
192  char hex[8];
193  snprintf(hex, sizeof(hex), "#%02X%02X%02X", cr, cg, cb);
194  sendInt("acik", stripOn);
195  sendText("renk", hex);
196  sendInt("parlaklik", brightness);
197  sendText("efekt", effect);
198}
199
200void onLinkLost() {
201}
202
203void setup() {
204  Serial.begin(115200);
205  strip.begin();
206  paint();
207  btBegin();
208  Serial.print(F("BlueGrays Bluetooth: "));
209  Serial.println(BLE_NAME);
210}
211
212void loop() {
213  btPoll();
214  if (stripOn && !is(effect, "sabit")) {
215    // l’effet marque une courte pause quand une commande arrive (les interruptions sont coupées pendant l’écriture de la bande)
216    if (millis() - lastRxMs > 150 && millis() - lastFrameMs >= 30) {
217      lastFrameMs = millis();
218      if (is(effect, "gokkusagi")) {  // un arc-en-ciel défile le long de la bande
219        hue += 512;
220        strip.setBrightness(level());
221        for (int i = 0; i < LED_COUNT; i++) strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(hue + i * 65536L / LED_COUNT)));
222        strip.show();
223      } else if (is(effect, "nefes")) {  // s’éteint et se rallume doucement
224        float wave = (sin(millis() / 600.0) + 1.0) / 2.0;
225        fillColor(strip.Color(cr, cg, cb), level() * (0.15 + 0.85 * wave));
226      } else if (is(effect, "yanip_sonme")) {  // clignote toutes les demi-secondes
227        fillColor(strip.Color(cr, cg, cb), (millis() / 500) % 2 ? level() : 0);
228      } else if (is(effect, "renk_dongusu")) {  // toute la bande d’une seule couleur, transition douce des teintes
229        hue += 128;
230        fillColor(strip.ColorHSV(hue), level());
231      }
232    }
233  }
234}
235

FAQ

Est-ce que ça marche avec un iPhone ?

Oui. Le projet utilise le Bluetooth Low Energy (BLE) intégré de l'ESP32, qui fonctionne sur iPhone comme sur Android. Un iPhone ne peut pas se connecter aux modules Bluetooth classiques comme le HC-05 ou le HC-06, c'est pour ça qu'il n'y a pas de module en plus ici. N'essaie pas d'appairer la carte dans les réglages Bluetooth du téléphone ; seule l'app BlueGrays établit la connexion.

Combien de LED puis-je brancher, et quelle alimentation faut-il ?

Chaque LED tire jusqu'à 60 mA en blanc maximal, donc 30 LED font environ 1,8 A. Le port USB d'un ordinateur ne fournit pas autant : pour un court essai en USB, garde la luminosité autour de 20. Pour un usage durable, alimente le ruban avec un adaptateur séparé de 5 V 2 A et relie son GND au GND de l'ESP32. Pour un ruban plus long, change LED_COUNT dans le code et choisis l'adaptateur en comptant 60 mA par LED. Un condensateur de 1000 µF à l'entrée du ruban et une résistance de 330 Ω en série sur la ligne de données protègent le ruban.

Pourquoi les couleurs sont-elles différentes de l'écran ?

La luminosité d'une LED monte en ligne droite avec la valeur, mais ton œil ne perçoit pas la lumière ainsi ; sans correction, les couleurs paraissent pâles et blanchâtres. C'est pour ça que le code corrige chaque couleur avec gamma32. Les teintes sombres et pastel se rapprochent de l'écran, sans jamais être identiques. À très faible luminosité, les couleurs dérivent et les teintes mélangées comme le jaune et l'orange pâlissent ; au-dessus de 40 environ, l'écart diminue.

Que fait le ruban après une coupure de courant ?

La carte démarre toujours ruban éteint : la couleur revient au blanc, la luminosité à 70 et l'effet à Fixe, car les valeurs ne sont pas enregistrées sur la carte. Quand l'app se reconnecte, le panneau affiche les valeurs actuelles envoyées par la carte ; il suffit d'allumer Lumière. Si seule la connexion avec le téléphone coupe, le ruban reste allumé comme avant.