LEDs reactivos a la música con Arduino: vúmetro WS2812B
LEDs reactivos a la música: vúmetro con anillo WS2812B usando Arduino Uno + KY-038 y ESP32 + INMP441. Conexión, código, umbral y filtro de ruido.
Un proyecto de LEDs reactivos a la música con Arduino es un circuito que escucha el sonido del ambiente con un micrófono y enciende más LEDs cuanto más fuerte suena, imitando el vúmetro de los antiguos equipos de música. En esta guía usarás un anillo WS2812B de 24 LEDs (el mismo código funciona con una tira) para montar dos versiones: una con Arduino Uno y un sensor de sonido KY-038, barata y rápida, y otra con ESP32 y un micrófono digital I2S INMP441, que mide mucho más limpio.
El verdadero truco del proyecto no es encender LEDs, sino medir bien el sonido. La señal del micrófono es una onda que cambia de sentido miles de veces por segundo; una sola lectura de analogRead no te dice nada. Por eso aprenderás paso a paso a medir la amplitud dentro de una ventana de tiempo, a encontrar automáticamente el ruido de fondo en silencio, a ajustar la sensibilidad con un potenciómetro y a usar un filtro de suavizado que elimina el parpadeo.

¿Cómo funcionan los LEDs reactivos a la música?
La cadena tiene cuatro eslabones: el micrófono convierte el sonido en una señal eléctrica, el microcontrolador toma muestras de esa señal, con las muestras se calcula un único número de nivel de sonido y ese número se convierte en la cantidad de LEDs que se encienden. Hay dos formas habituales de calcular el nivel. En el método de pico a pico (peak-to-peak) se resta el valor mínimo al máximo recibido en un periodo corto; es sencillo y suficiente para el Uno. En el método RMS se calcula la raíz cuadrada de la media de los cuadrados de las muestras, que da la energía real del sonido. Como el oído humano percibe el sonido de forma logarítmica y no lineal, convertir el RMS a decibelios (dB = 20 × log10(RMS)) da un movimiento de vúmetro mucho más natural. Lo usaremos en la versión ESP32.
| Característica | Uno + KY-038 | ESP32 + INMP441 |
|---|---|---|
| Tipo de micrófono | Electret analógico, sin amplificador | MEMS digital, salida I2S |
| Resolución | ADC de 10 bits (pasos de 4,9 mV) | Datos de 24 bits |
| Muestreo | Unos 8,9 kHz (analogRead ~112 µs) | 16 kHz, continuo con DMA |
| Cálculo del nivel | Pico a pico | RMS + decibelios |
| Sensibilidad | Baja, responde a sonidos fuertes y cercanos | Alta, capta bien la música ambiente |
| Ruido | Le afecta el ruido de la alimentación | Muy bajo, línea digital |
| Dificultad | Principiante | Media |
Materiales necesarios
- Microcontrolador: Arduino Uno (o Nano) o una placa de desarrollo ESP32.
- Micrófono: módulo sensor de sonido KY-038 para el Uno, módulo de micrófono I2S INMP441 para el ESP32.
- LED: anillo WS2812B de 24 LEDs o tira WS2812B de 30–60 LEDs.
- Resistencia de 330 Ω: en serie con la línea de datos de los LEDs; evita reflexiones de señal y que se dañe el primer LED.
- Condensador de 1000 µF / 10 V: entre 5V y GND de la alimentación de los LEDs; suaviza los picos de corriente.
- Potenciómetro de 10 kΩ: para ajustar la sensibilidad (fondo de escala) en la versión Uno.
- Fuente de 5 V 2 A: imprescindible si usas más de 24 LEDs o subes el brillo.
- Protoboard y cables jumper.

Conexión Uno + KY-038
| Pieza / pin | Arduino Uno | Nota |
|---|---|---|
| KY-038 + | 5V | Alimentación del módulo |
| KY-038 G | GND | Masa común |
| KY-038 AO | A0 | Señal analógica de sonido |
| KY-038 DO | Sin conectar | No se usa en el vúmetro |
| Potenciómetro, pin central | A1 | Los extremos van a 5V y GND |
| WS2812B DIN | D6 (a través de 330 Ω) | Lado de entrada (DI) del anillo |
| WS2812B 5V | 5V o 5 V externos | Condensador de 1000 µF entre 5V y GND |
| WS2812B GND | GND | Debe ser común con la fuente externa |
Medir la amplitud del sonido: el método pico a pico
La salida AO del KY-038 es una señal que en silencio se queda fija en torno a 2,5 V y oscila por encima y por debajo de ese valor cuando llega sonido. En el Uno, analogRead lee ese punto medio como un número cercano a 500. Una sola lectura da un valor aleatorio según el instante de la onda en que caiga. Por eso leemos durante una ventana de 25 milisegundos y guardamos el valor máximo y el mínimo. Como un analogRead en el Uno tarda unos 112 microsegundos, en 25 ms se toman unas 220 muestras, suficientes para captar al menos unas cuantas ondas completas de graves y medios. Al final de la ventana, máximo menos mínimo es el nivel de sonido de ese momento. Como el KY-038 no tiene amplificador, en una habitación silenciosa esa diferencia es de 2–5, y con música alta cerca llega a 50–200.
Versión Uno paso a paso
- En el Arduino IDE abre el Gestor de bibliotecas, busca la biblioteca Adafruit NeoPixel e instálala.
- Monta el circuito según la tabla anterior; conecta la pata larga (+) del condensador a 5V.
- Sube el código de abajo y mantén el ambiente en silencio durante el primer medio segundo: en ese tiempo el código mide el ruido de fondo.
- Abre el Monitor Serie a 115200 baudios y mira el valor de ruido de fondo; si pasa de 10, hay ruido en la alimentación.
- Pon música y gira el potenciómetro hasta encontrar el punto en que, al volumen más alto, el anillo casi se llena por completo.
- Coloca el micrófono a 20–50 cm del altavoz, lejos de la luz de los LEDs y de las vibraciones de la mesa.
1#include <Adafruit_NeoPixel.h>
2
3#define LED_PIN 6 // WS2812B DIN / WS2812B DIN
4#define NUM_LEDS 24 // halkadaki LED sayısı / number of LEDs in the ring
5#define MIC_PIN A0 // KY-038 AO / KY-038 AO
6#define POT_PIN A1 // hassasiyet potu / sensitivity pot
7#define WINDOW_MS 25 // ölçüm penceresi (ms) / measurement window (ms)
8
9Adafruit_NeoPixel strip(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
10
11int noiseFloor = 0; // sessizlikteki genlik / amplitude in silence
12float level = 0; // yumuşatılmış seviye / smoothed level
13int peakLed = 0; // tepe noktası / peak dot
14unsigned long peakTime = 0;
15
16int readPeakToPeak() {
17 int minV = 1023;
18 int maxV = 0;
19 unsigned long start = millis();
20 while (millis() - start < WINDOW_MS) {
21 int v = analogRead(MIC_PIN);
22 if (v < minV) minV = v;
23 if (v > maxV) maxV = v;
24 }
25 return maxV - minV; // tepeden tepeye genlik / peak-to-peak amplitude
26}
27
28uint32_t vuColor(int i) {
29 uint16_t hue = 21845 - (uint32_t)i * 21845 / (NUM_LEDS - 1); // yeşil -> kırmızı / green -> red
30 return strip.gamma32(strip.ColorHSV(hue, 255, 255));
31}
32
33void setup() {
34 Serial.begin(115200);
35 strip.begin();
36 strip.setBrightness(60); // akımı sınırla / limit current
37 strip.show();
38 delay(500);
39 long sum = 0;
40 for (int i = 0; i < 20; i++) sum += readPeakToPeak(); // sessiz ortamda kalibrasyon / calibrate in silence
41 noiseFloor = sum / 20 + 2; // küçük güvenlik payı / small safety margin
42 Serial.print(F("Gurultu tabani / Noise floor: "));
43 Serial.println(noiseFloor);
44}
45
46void loop() {
47 int maxPP = map(analogRead(POT_PIN), 0, 1023, 10, 300); // tam ölçek / full scale
48 int pp = readPeakToPeak() - noiseFloor;
49 if (pp < 0) pp = 0;
50 if (pp > maxPP) pp = maxPP;
51 float target = (float)pp * NUM_LEDS / maxPP;
52
53 if (target > level) level = 0.6 * target + 0.4 * level; // hızlı yüksel / fast attack
54 else level = 0.15 * target + 0.85 * level; // yavaş düş / slow release
55 int lit = (int)(level + 0.5);
56
57 if (lit >= peakLed) {
58 peakLed = lit;
59 peakTime = millis();
60 } else if (millis() - peakTime > 400 && peakLed > 0) { // 400 ms bekle, sonra düş / hold 400 ms, then fall
61 peakLed--;
62 peakTime = millis() - 340; // sonraki adım 60 ms sonra / next step in 60 ms
63 }
64
65 strip.clear();
66 for (int i = 0; i < lit; i++) strip.setPixelColor(i, vuColor(i));
67 if (peakLed > 0) strip.setPixelColor(peakLed - 1, strip.Color(255, 255, 255));
68 strip.show();
69}| Parte del código | Función |
|---|---|
| readPeakToPeak() | Toma muestras durante 25 ms y devuelve la diferencia entre el valor máximo y el mínimo |
| noiseFloor | Media de las 20 mediciones iniciales + 2; por debajo de este valor se considera silencio |
| maxPP | Fondo de escala ajustable de 10 a 300 con el potenciómetro; valor pequeño = alta sensibilidad |
| level | Nivel suavizado que sube rápido y baja despacio (evita el parpadeo) |
| peakLed | Punto blanco de pico; espera 400 ms y luego baja un LED cada 60 ms |
| vuColor() | Genera la transición de color de verde a amarillo y de amarillo a rojo según la posición del LED |
Ajuste del umbral y filtrado de ruido
Si trasladas el nivel de sonido bruto directamente a los LEDs, te encontrarás con dos problemas. El primero es que, incluso en un ambiente silencioso, los primeros LEDs parpadean sin parar, porque el micrófono, los cables y la alimentación USB siempre generan algo de ruido. La solución es medir ese ruido y restarlo de cada lectura. Nuestro código hace una medición de medio segundo en silencio al arrancar y añade a la media un margen de 2 unidades. Ese valor funciona como un umbral: todo lo que queda por debajo se considera cero. Si vas a trabajar en un entorno ruidoso, puedes subir ese margen a 4–5. El segundo ajuste es el fondo de escala: determina qué amplitud llena el anillo por completo. Como el volumen de la música cambia de un sitio a otro, en lugar de fijarlo en el código lo conectamos a un potenciómetro.
El segundo problema es el parpadeo: como las ventanas de 25 ms son muy cortas, el nivel salta bruscamente de una medición a otra. Lo resolvemos con una media móvil exponencial (EMA): nuevo nivel = a × objetivo + (1 − a) × nivel anterior. Cuando el sonido sube usamos a = 0,6, así que los LEDs captan los golpes de bombo al instante; cuando baja usamos a = 0,15, así que los LEDs descienden despacio, como una aguja real. En ingeniería de audio esta diferencia se llama attack y release. Como el bucle dura unos 26 ms, con un coeficiente de release de 0,15 el nivel cae un 90 % en unos 15 ciclos, es decir, en 0,4 segundos. Puedes comparar otros tipos de filtro en el artículo filtrado de datos de sensores.
Versión ESP32 + INMP441: medición limpia con micrófono digital
El INMP441 es un micrófono MEMS que convierte el sonido a digital internamente con resolución de 24 bits y envía los datos mediante el protocolo I2S. Al no haber cable analógico, el ruido de la alimentación no se cuela en la medición y la relación señal/ruido es de unos 61 dB. El ESP32 recoge los datos I2S en segundo plano con DMA sin cargar el procesador; nosotros tomamos bloques de 512 muestras y calculamos el valor RMS. A 16 kHz un bloque dura 32 ms, así que el vúmetro se actualiza unas 30 veces por segundo. Puedes ver cómo funciona el micrófono en detalle en el artículo micrófono I2S INMP441.
| Pieza / pin | ESP32 | Nota |
|---|---|---|
| INMP441 VDD | 3V3 | No le des 5 V, el micrófono es de 3,3 V |
| INMP441 GND | GND | Masa común |
| INMP441 L/R | GND | Se selecciona el canal izquierdo |
| INMP441 WS | GPIO 25 | Selección de palabra (LRCLK) |
| INMP441 SCK | GPIO 32 | Reloj de bit (BCLK) |
| INMP441 SD | GPIO 33 | Datos de audio |
| WS2812B DIN | GPIO 18 (a través de 330 Ω) | La señal de 3,3 V funciona con cable corto |
| WS2812B 5V | VIN (5 V del USB) o 5 V externos | Añade un condensador de 1000 µF |
| WS2812B GND | GND | Común con la fuente externa |
1#include <Arduino.h>
2#include <Adafruit_NeoPixel.h>
3#include <math.h>
4
5#if ESP_ARDUINO_VERSION_MAJOR >= 3
6 #include <ESP_I2S.h> // core 3.x yeni I2S sürücüsü / core 3.x new I2S driver
7 I2SClass i2s;
8#else
9 #include <driver/i2s.h> // core 2.x eski I2S sürücüsü / core 2.x legacy I2S driver
10 #include <esp_idf_version.h>
11#endif
12
13#define I2S_SCK 32
14#define I2S_WS 25
15#define I2S_SD 33
16#define LED_PIN 18
17#define NUM_LEDS 24
18#define SAMPLE_RATE 16000
19#define BLOCK 512 // 512 örnek = 32 ms / 512 samples = 32 ms
20
21const float RANGE_DB = 35.0; // halkanın kapsadığı dB aralığı / dB range of the ring
22
23Adafruit_NeoPixel strip(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
24int32_t samples[BLOCK];
25float noiseDb = 0;
26float level = 0;
27int peakLed = 0;
28unsigned long peakTime = 0;
29
30void micBegin() {
31#if ESP_ARDUINO_VERSION_MAJOR >= 3
32 i2s.setPins(I2S_SCK, I2S_WS, -1, I2S_SD);
33 if (!i2s.begin(I2S_MODE_STD, SAMPLE_RATE, I2S_DATA_BIT_WIDTH_32BIT, I2S_SLOT_MODE_MONO, I2S_STD_SLOT_LEFT)) {
34 Serial.println("I2S baslatilamadi / I2S init failed");
35 while (true) delay(1000);
36 }
37#else
38 i2s_config_t cfg = {};
39 cfg.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX);
40 cfg.sample_rate = SAMPLE_RATE;
41 cfg.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT;
42 cfg.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT;
43 cfg.communication_format = I2S_COMM_FORMAT_STAND_I2S;
44 cfg.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1;
45 cfg.dma_buf_count = 4;
46 cfg.dma_buf_len = 256;
47 cfg.use_apll = false;
48
49 i2s_pin_config_t pins = {};
50#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 4, 0)
51 pins.mck_io_num = I2S_PIN_NO_CHANGE;
52#endif
53 pins.bck_io_num = I2S_SCK;
54 pins.ws_io_num = I2S_WS;
55 pins.data_out_num = I2S_PIN_NO_CHANGE;
56 pins.data_in_num = I2S_SD;
57
58 i2s_driver_install(I2S_NUM_0, &cfg, 0, NULL);
59 i2s_set_pin(I2S_NUM_0, &pins);
60#endif
61}
62
63size_t micRead() {
64#if ESP_ARDUINO_VERSION_MAJOR >= 3
65 return i2s.readBytes((char *)samples, sizeof(samples)) / sizeof(int32_t);
66#else
67 size_t bytesRead = 0;
68 i2s_read(I2S_NUM_0, samples, sizeof(samples), &bytesRead, portMAX_DELAY);
69 return bytesRead / sizeof(int32_t);
70#endif
71}
72
73float readDb() {
74 size_t n = micRead();
75 if (n == 0) return 0;
76 double mean = 0;
77 for (size_t i = 0; i < n; i++) {
78 samples[i] >>= 8; // 24 bit veriyi hizala / align 24-bit data
79 mean += samples[i];
80 }
81 mean /= n; // DC kaymasını bul / find DC offset
82 double sum = 0;
83 for (size_t i = 0; i < n; i++) {
84 double d = samples[i] - mean;
85 sum += d * d;
86 }
87 double rms = sqrt(sum / n);
88 return 20.0 * log10(rms + 1.0); // desibel / decibels
89}
90
91uint32_t vuColor(int i) {
92 uint16_t hue = 21845 - (uint32_t)i * 21845 / (NUM_LEDS - 1); // yeşil -> kırmızı / green -> red
93 return strip.gamma32(strip.ColorHSV(hue, 255, 255));
94}
95
96void setup() {
97 Serial.begin(115200);
98 strip.begin();
99 strip.setBrightness(60);
100 strip.show();
101 micBegin();
102 for (int i = 0; i < 10; i++) readDb(); // açılış verisini at / discard startup data
103 float sum = 0;
104 for (int i = 0; i < 20; i++) sum += readDb(); // sessizlik kalibrasyonu / silence calibration
105 noiseDb = sum / 20 + 3.0; // 3 dB eşik payı / 3 dB threshold margin
106 Serial.printf("Gurultu tabani / Noise floor: %.1f dB\n", noiseDb);
107}
108
109void loop() {
110 float db = readDb();
111 float target = (db - noiseDb) / RANGE_DB * NUM_LEDS;
112 if (target < 0) target = 0;
113 if (target > NUM_LEDS) target = NUM_LEDS;
114
115 if (target > level) level = 0.6 * target + 0.4 * level; // hızlı yüksel / fast attack
116 else level = 0.15 * target + 0.85 * level; // yavaş düş / slow release
117 int lit = (int)(level + 0.5);
118
119 if (lit >= peakLed) {
120 peakLed = lit;
121 peakTime = millis();
122 } else if (millis() - peakTime > 400 && peakLed > 0) {
123 peakLed--;
124 peakTime = millis() - 340;
125 }
126
127 strip.clear();
128 for (int i = 0; i < lit; i++) strip.setPixelColor(i, vuColor(i));
129 if (peakLed > 0) strip.setPixelColor(peakLed - 1, strip.Color(255, 255, 255));
130 strip.show();
131}El código elige automáticamente la nueva biblioteca ESP_I2S si usas el core 3.x de Arduino para ESP32, o el antiguo controlador driver/i2s.h si usas el 2.x. El INMP441 coloca cada muestra en los 24 bits superiores de una trama de 32 bits; desplazar 8 bits a la derecha da el valor real. Después se resta la media para eliminar el pequeño desvío DC del micrófono y se calcula el RMS. En la escala de decibelios, cada 6 dB equivalen a duplicar la amplitud. Con RANGE_DB = 35 el anillo se llena por completo 35 dB por encima del ruido de fondo. Si escuchas música baja en una habitación silenciosa, reduce este valor a 25; en una fiesta ruidosa, súbelo a 45.
Si quieres usar una Raspberry Pi Pico, la clase machine.I2S de MicroPython también es compatible con la RP2040; puedes conectar el mismo INMP441 con los pines SCK, WS y SD y trasladar la lógica RMS a Python. Para la WS2812B, MicroPython también incluye el módulo neopixel. Para dar tus primeros pasos con la Pico, el artículo qué es la Raspberry Pi Pico es un buen comienzo.
Mejorar el efecto: ideas para proyectos
- Vúmetro desde el centro: crea un efecto simétrico que empieza en los LEDs 0 y 12 del anillo y se llena hacia los dos lados.
- Vúmetro estéreo: conecta el pin L/R de uno de los dos INMP441 a GND y el del otro a 3V3, y muestra el canal izquierdo y el derecho en dos tiras distintas.
- Espectro en matriz de LEDs: con FFT en el ESP32, separa el sonido en bandas de frecuencia y dibuja barras de ecualizador en una matriz de LEDs WS2812B.
- Luz musical para tu cuarto: si quieres una interfaz ya hecha, convierte el ESP32 en un controlador de tiras reactivo al sonido con la instalación de WLED.
- Aviso de nivel de ruido: haz un medidor de ruido para clase o biblioteca que ponga el anillo en rojo y haga sonar un zumbador cuando el sonido supere cierto dB.
- Adorno navideño: combínalo con el proyecto de árbol de Navidad con LEDs para un árbol que cambia de color según la música.
Errores comunes y cómo solucionarlos
| Síntoma | Causa probable | Solución |
|---|---|---|
| Los LEDs parpadean en silencio | El ruido de fondo se midió demasiado bajo | Mantén el ambiente en silencio al arrancar y sube el margen del umbral de 2 a 4–5 |
| Ninguna reacción a la música (Uno) | La señal del KY-038 es muy débil | Baja maxPP con el potenciómetro y acerca el micrófono al altavoz |
| El anillo siempre está lleno | El fondo de escala es demasiado pequeño | Gira el potenciómetro para aumentar maxPP, o aumenta RANGE_DB |
| El INMP441 siempre lee cero | L/R sin conectar o canal invertido | Conecta L/R a GND; si sigue igual, ponlo a 3V3 y elige el canal derecho en el código |
| El primer LED muestra un color equivocado | Señal de datos débil o falta la resistencia | Añade una resistencia serie de 330 Ω y acorta el cable de datos |
| La placa se reinicia con el golpe de bombo | La corriente de los LEDs hunde la alimentación | Baja el brillo, usa una fuente externa de 5 V y un condensador de 1000 µF |
| Los LEDs disparan el micrófono | El rizado de la alimentación se cuela en la línea analógica | Conecta el micrófono a 5V con un cable aparte y une las masas en un solo punto |
Un proyecto de LEDs reactivos a la música reúne en un solo circuito divertido la medición de señales analógicas, el filtrado y el control de LEDs direccionables. Puedes empezar en pocos minutos con el Uno y el KY-038 y pasar a un indicador de sonido profesional con el ESP32 y el INMP441. En la app de BlueGrays puedes explorar paso a paso, con esquema de conexión y código listo, los proyectos de LEDs WS2812B en movimiento, coche fantástico, luces de policía y animaciones, además del control de tiras NeoPixel con ESP32.
Preguntas frecuentes
¿Qué sensor de sonido es mejor para LEDs reactivos a la música?
Para empezar y con poco presupuesto, el KY-038 sirve, pero al no tener amplificador solo responde bien a sonidos fuertes y cercanos. Si quieres un resultado más sensible y limpio, usa un micrófono digital I2S como el INMP441 con un ESP32, o un módulo de micrófono analógico con amplificador.
¿Por qué el sensor de sonido KY-038 no reacciona a la música?
La señal en la salida AO del KY-038 normalmente solo oscila unas pocas unidades del ADC, y el trimpot no la amplifica, solo cambia el umbral de DO. Acerca el micrófono al altavoz, baja el fondo de escala en el código y asegúrate de medir pico a pico en lugar de usar una sola lectura.
¿Cómo enciendo LEDs WS2812B al ritmo de la música con Arduino?
Tomas muestras del micrófono en una ventana de tiempo corta, calculas el nivel de sonido y lo conviertes en un número de LEDs con una proporción tipo map. Después enciendes esa cantidad de LEDs con la biblioteca Adafruit NeoPixel y actualizas con strip.show(); un filtro de suavizado hace que el efecto fluya sin parpadear.
¿Funciona el micrófono INMP441 con Arduino Uno?
No, el Arduino Uno no tiene hardware I2S, por lo que no puede leer datos del INMP441. Necesitas placas con soporte I2S como ESP32, ESP32-S3 o Raspberry Pi Pico; para el Uno son adecuados los módulos de micrófono con salida analógica.
¿Cuánta corriente consume un anillo WS2812B de 24 LEDs?
Como cada LED consume unos 60 mA en blanco total, 24 LEDs consumen 1,44 A en el peor caso. En un efecto de vúmetro rara vez están todos a brillo máximo, así que el consumo real es mucho menor; aun así, lo más seguro es limitar el brillo y usar una fuente externa de 5 V.
¿Se puede cambiar el color según la frecuencia en LEDs reactivos a la música?
Sí, para ello tienes que separar el sonido con FFT en bandas de frecuencia como graves, medios y agudos. La potencia y la memoria del ESP32 bastan para una FFT en tiempo real; en el Uno solo se puede hacer un análisis limitado y de baja resolución.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Control de la tira NeoPixel WS2812B con ESP32
Los LED direccionables WS2812B (NeoPixel) son LED RGB inteligentes que se encadenan y se controlan desde un solo pin de datos. Controlamos una tira WS2812B de 8 LED con la biblioteca Adafruit_NeoPixel y creamos un arcoíris fluido. La lógica de 3,3 V del ESP32 va bien con casi todos los WS2812B; si hay inestabilidad, mostramos la solución con una resistencia en serie de 470Ω y un condensador de 1000µF. La animación desplaza el tono en el espacio HSV.

Uso de la tira LED WS2812B
Conoces una tira LED inteligente en la que puedes dar color a cada luz por separado.

Luces de policía con WS2812B
Traes a tu escritorio las luces roja y azul del techo de un coche de policía. Una mitad de una tira WS2812B de diez LED destella en rojo tres veces muy rápido, la otra mitad destella en azul tres…

Luz secuencial con WS2812B
En una tira de diez LED, un punto de luz verde avanza de principio a fin, LED a LED, y al llegar al final vuelve al comienzo; se queda un tercio de segundo en cada LED.

Luz secuencial con WS2812B (efecto llenado)
Una tira de luz que se llena y se vacía como un vaso de agua. El Arduino enciende diez LED de color uno a uno en naranja y los deja encendidos; cuando la tira está llena, los apaga uno a uno en el…

Efecto coche fantástico con WS2812B
Un punto de luz roja recorre una tira LED inteligente de un extremo al otro y vuelve, en un vaivén que nunca se detiene.

WS2812B Animación 1
En una tira de 56 LED, todos los colores del arcoíris se colocan uno junto a otro y fluyen sin detenerse nunca, como si un río de luz se deslizara por la tira.

WS2812B Animación 2
Monta en tu habitación un espectáculo de luz que cambia de color solo. El Arduino hace fluir los colores sin parar por una tira de 30 LED y cada pocos segundos pasa a una nueva gama: arcoíris, rayas…
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

