Guías · 9 min de lectura

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.

Anillo de 24 LEDs RGB WS2812B NeoPixel
Anillo WS2812B de 24 LEDs: con un solo cable de datos se controla el color de cada LED por separado, ideal para un vúmetro.

¿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ísticaUno + KY-038ESP32 + INMP441
Tipo de micrófonoElectret analógico, sin amplificadorMEMS digital, salida I2S
ResoluciónADC de 10 bits (pasos de 4,9 mV)Datos de 24 bits
MuestreoUnos 8,9 kHz (analogRead ~112 µs)16 kHz, continuo con DMA
Cálculo del nivelPico a picoRMS + decibelios
SensibilidadBaja, responde a sonidos fuertes y cercanosAlta, capta bien la música ambiente
RuidoLe afecta el ruido de la alimentaciónMuy bajo, línea digital
DificultadPrincipianteMedia

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.
Módulo sensor de sonido KY-038
Sensor de sonido KY-038: el pin AO entrega la señal bruta del micrófono y el pin DO genera una señal digital cuando se supera el umbral ajustado con el trimpot.

Conexión Uno + KY-038

Pieza / pinArduino UnoNota
KY-038 +5VAlimentación del módulo
KY-038 GGNDMasa común
KY-038 AOA0Señal analógica de sonido
KY-038 DOSin conectarNo se usa en el vúmetro
Potenciómetro, pin centralA1Los extremos van a 5V y GND
WS2812B DIND6 (a través de 330 Ω)Lado de entrada (DI) del anillo
WS2812B 5V5V o 5 V externosCondensador de 1000 µF entre 5V y GND
WS2812B GNDGNDDebe ser común con la fuente externa
24 LEDs a brillo blanco máximo consumen unos 24 × 60 mA = 1,44 A, muy por encima de lo que el Uno puede dar por USB. En el código mantenemos el brillo en 60/255, pero si usas una tira larga alimenta los LEDs con un adaptador externo de 5 V y conecta siempre el GND del adaptador al GND del Arduino. Sin GND común los LEDs muestran colores aleatorios. Para más detalles consulta el artículo LED WS2812B NeoPixel.

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

  1. En el Arduino IDE abre el Gestor de bibliotecas, busca la biblioteca Adafruit NeoPixel e instálala.
  2. Monta el circuito según la tabla anterior; conecta la pata larga (+) del condensador a 5V.
  3. 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.
  4. 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.
  5. 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.
  6. Coloca el micrófono a 20–50 cm del altavoz, lejos de la luz de los LEDs y de las vibraciones de la mesa.
C++ (Arduino IDE)
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ódigoFunción
readPeakToPeak()Toma muestras durante 25 ms y devuelve la diferencia entre el valor máximo y el mínimo
noiseFloorMedia de las 20 mediciones iniciales + 2; por debajo de este valor se considera silencio
maxPPFondo de escala ajustable de 10 a 300 con el potenciómetro; valor pequeño = alta sensibilidad
levelNivel suavizado que sube rápido y baja despacio (evita el parpadeo)
peakLedPunto 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.

El trimpot azul del KY-038 solo ajusta el umbral de la salida DO; no aumenta la amplitud de la señal de AO. Si la versión Uno solo reacciona a sonidos fuertes y cercanos, aumenta la sensibilidad con el potenciómetro o pasa a un módulo de micrófono con amplificador. Para todos los detalles del KY-038 echa un vistazo al artículo sensor de sonido KY-038.

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 / pinESP32Nota
INMP441 VDD3V3No le des 5 V, el micrófono es de 3,3 V
INMP441 GNDGNDMasa común
INMP441 L/RGNDSe selecciona el canal izquierdo
INMP441 WSGPIO 25Selección de palabra (LRCLK)
INMP441 SCKGPIO 32Reloj de bit (BCLK)
INMP441 SDGPIO 33Datos de audio
WS2812B DINGPIO 18 (a través de 330 Ω)La señal de 3,3 V funciona con cable corto
WS2812B 5VVIN (5 V del USB) o 5 V externosAñade un condensador de 1000 µF
WS2812B GNDGNDComún con la fuente externa
No dejes el pin L/R del INMP441 sin conectar; si queda flotante, el micrófono no puede elegir canal y leerás siempre cero o datos sin sentido. Además, con la WS2812B alimentada a 5 V, la señal de datos de 3,3 V del ESP32 puede quedar al límite en algunas tiras. Si el primer LED parpadea o muestra un color equivocado, acorta el cable de datos o usa un conversor de nivel lógico.
C++ (Arduino IDE)
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íntomaCausa probableSolución
Los LEDs parpadean en silencioEl ruido de fondo se midió demasiado bajoManté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ébilBaja maxPP con el potenciómetro y acerca el micrófono al altavoz
El anillo siempre está llenoEl fondo de escala es demasiado pequeñoGira el potenciómetro para aumentar maxPP, o aumenta RANGE_DB
El INMP441 siempre lee ceroL/R sin conectar o canal invertidoConecta 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 equivocadoSeñal de datos débil o falta la resistenciaAñade una resistencia serie de 330 Ω y acorta el cable de datos
La placa se reinicia con el golpe de bomboLa corriente de los LEDs hunde la alimentaciónBaja el brillo, usa una fuente externa de 5 V y un condensador de 1000 µF
Los LEDs disparan el micrófonoEl rizado de la alimentación se cuela en la línea analógicaConecta el micrófono a 5V con un cable aparte y une las masas en un solo punto
Para ajustar, el Serial Plotter (Trazador Serie) es muy útil: añade Serial.println(pp) al bucle, o Serial.println(db) en el ESP32, y mira la gráfica mientras suena música. La línea en silencio muestra el ruido de fondo y el pico del momento más fuerte de la canción te indica directamente qué valor poner en el fondo de escala.

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.

Ver todos los proyectos
Control de la tira NeoPixel WS2812B con ESP32
ES-24Intermedio
Premium

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.

4.9(19)
30
Uso de la tira LED WS2812B
AR-69Intermedio
Premium

Uso de la tira LED WS2812B

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

4.8(54)
70
Luces de policía con WS2812B
AR-70Intermedio
Premium

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…

4.8(67)
86
Luz secuencial con WS2812B
AR-71Intermedio
Premium

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.

4.8(58)
75
Luz secuencial con WS2812B (efecto llenado)
AR-72Intermedio
Premium

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…

4.7(50)
65
Efecto coche fantástico con WS2812B
AR-73Intermedio
Premium

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.

4.9(73)
94
WS2812B Animación 1
AR-75Intermedio
Premium

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.

4.9(69)
89
WS2812B Animación 2
AR-76Intermedio
Premium

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…

4.8(65)
84