ES-110Intermedio

ESP32 Bluetooth Tira LED RGB (WS2812B)

Cambia el color, el brillo y el efecto de tu tira desde el móvil: el ESP32 se conecta directo al móvil por Bluetooth y la tira WS2812B solo necesita 3 cables. Este proyecto es la guía paso a paso de la plantilla Bluetooth Tira LED RGB de la app. Ve a Mi Taller › Dispositivos › Añadir dispositivo › Bluetooth, elige Tira LED RGB y sube el código con Obtener el código. El botón Configurar como panel Bluetooth de esta página abre el asistente con esta plantilla.

0.0(0)
1 completado
ESP32 Bluetooth Tira LED RGB (WS2812B)
¿Quieres pintar la luz de tu cuarto desde el móvil? Aquí el ESP32 se conecta directo a tu teléfono por Bluetooth; no hacen falta internet, router ni servidor. En el panel enciendes y apagas la tira, eliges cualquier color, deslizas el brillo y escoges un efecto como arcoíris o respiración. En la app ve a Mi Taller › Dispositivos › Añadir dispositivo › Bluetooth, elige la plantilla Tira LED RGB, sube el código con Obtener el código y conéctate en el paso Busca tu placa. El botón Configurar como panel Bluetooth de esta página abre el asistente con la misma plantilla. Aprendes: comandos línea a línea por Bluetooth Low Energy, manejar una tira WS2812B con Adafruit NeoPixel, corrección gamma y animaciones fluidas.

Video

Diagrama del circuito

ESP32 Bluetooth Tira LED RGB (WS2812B) - Diagrama del circuito

Código fuente

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Isik                   │
5// └───────────────────────────┘
6// Tira LED RGB
7// Placa en Arduino IDE: ESP32 Dev Module
8// la biblioteca BLE viene con el paquete de placas ESP32, no hay que instalar nada más
9
10#include <BLEDevice.h>
11#include <BLEServer.h>
12#include <BLE2902.h>
13#include <Adafruit_NeoPixel.h>  // Gestor de bibliotecas: 'Adafruit NeoPixel'
14
15const char BLE_NAME[] = "BG-Isik";  // la placa se anuncia con este nombre y la app la encuentra así en la lista
16
17// Pines: cámbialos aquí si conectaste de otra forma
18const int STRIP_PIN = 5;
19const int LED_COUNT = 30;  // número de LED de tu tira
20
21void btWrite(const char *text);
22void onValue(const char *key, const char *value);
23void sendAll();
24void onLinkLost();
25
26// ── La app envía líneas "clave=valor"; con "?" la placa manda todos sus valores ──
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 línea "@v" indica a la app la versión del código
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// los bytes que llegan pasan de la tarea Bluetooth a loop() por un pequeño búfer circular
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// las líneas salen en paquetes de 20 bytes (funciona con cualquier móvil)
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// corrección gamma: los colores se ven en los LED como en la pantalla
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    // el efecto se detiene un instante mientras llega un comando (al escribir en la tira se desactivan las interrupciones)
216    if (millis() - lastRxMs > 150 && millis() - lastFrameMs >= 30) {
217      lastFrameMs = millis();
218      if (is(effect, "gokkusagi")) {  // un arcoíris recorre la tira
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")) {  // se apaga y se enciende despacio
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")) {  // parpadea cada medio segundo
227        fillColor(strip.Color(cr, cg, cb), (millis() / 500) % 2 ? level() : 0);
228      } else if (is(effect, "renk_dongusu")) {  // toda la tira del mismo color, cambio suave de tono
229        hue += 128;
230        fillColor(strip.ColorHSV(hue), level());
231      }
232    }
233  }
234}
235

Preguntas frecuentes

¿Funciona con iPhone?

Sí. El proyecto usa el Bluetooth Low Energy (BLE) integrado del ESP32, que funciona en iPhone y en Android. Un iPhone no puede conectarse a módulos Bluetooth clásicos como el HC-05 o el HC-06, por eso aquí no hay ningún módulo extra. No intentes emparejar la placa desde los ajustes Bluetooth del teléfono; la conexión la hace solo la app BlueGrays.

¿Cuántos LED puedo conectar y qué fuente necesito?

Cada LED consume hasta 60 mA en blanco total, así que 30 LED suman unos 1,8 A. El USB de un ordenador no da tanto, por eso en una prueba corta por USB deja el brillo en torno a 20. Para el uso diario, alimenta la tira con un adaptador aparte de 5 V 2 A y une su GND con el GND del ESP32. Para una tira más larga, cambia LED_COUNT en el código y elige el adaptador calculando 60 mA por LED. Un condensador de 1000 µF en la entrada de la tira y una resistencia de 330 Ω en serie con la línea de datos protegen la tira.

¿Por qué los colores se ven distintos a la pantalla?

El brillo de un LED sube en línea recta con el valor, pero tu ojo no percibe la luz así; sin corrección, los colores se ven pálidos y blanquecinos. Por eso el código corrige cada color con gamma32. Los tonos oscuros y pastel se acercan a la pantalla, aunque nunca son idénticos. Con un brillo muy bajo los colores se desplazan y los tonos mezclados como el amarillo y el naranja se apagan; por encima de 40 la diferencia baja.

¿Qué hace la tira tras un corte de luz?

La placa siempre arranca con la tira apagada: el color vuelve a blanco, el brillo a 70 y el efecto a Fijo, porque los valores no se guardan en la placa. Cuando la app se vuelve a conectar, el panel muestra los valores actuales que envía la placa; solo tienes que encender Luz. Si solo se corta la conexión con el teléfono, la tira sigue encendida como estaba.