Guias · 9 min de leitura

LED que reage à música com Arduino: projeto de VU meter com WS2812B

Projeto de LED que reage à música: monte um VU meter em um anel WS2812B com Arduino Uno + KY-038 ou ESP32 + INMP441. Ligações, código pronto, ajuste de limiar e filtragem de ruído.

Um projeto de LED que reage à música com Arduino escuta o som ao redor com um microfone e acende mais LEDs quanto mais alto ele fica, imitando o VU meter dos aparelhos de som antigos. Neste guia você vai usar um anel WS2812B de 24 LEDs (o mesmo código funciona em uma fita) para montar duas versões: uma barata e rápida, com Arduino Uno e um sensor de som KY-038, e outra com medição muito mais limpa, com ESP32 e um microfone digital I2S INMP441.

O verdadeiro segredo do projeto não é acender LEDs, e sim medir o som corretamente. O sinal do microfone é uma onda que muda de direção milhares de vezes por segundo, então um único valor de analogRead não diz nada. Por isso você vai aprender, passo a passo, a medir a amplitude dentro de uma janela de tempo, encontrar automaticamente o piso de ruído de um ambiente silencioso, ajustar a sensibilidade com um potenciômetro e usar um filtro de suavização que elimina a cintilação.

Anel RGB WS2812B NeoPixel de 24 LEDs
Anel WS2812B de 24 LEDs: a cor de cada LED é controlada individualmente por um único fio de dados, o que o torna ideal para um VU meter.

Como funciona um LED que reage à música?

A cadeia tem quatro elos: o microfone transforma o som em sinal elétrico, o microcontrolador amostra esse sinal, um único número de nível sonoro é calculado a partir das amostras, e esse número é convertido na quantidade de LEDs a acender. Há duas formas comuns de calcular o nível. O método pico a pico pega a diferença entre o maior e o menor valor em um curto intervalo; é simples e suficiente para o Uno. O método RMS tira a raiz quadrada da média dos quadrados das amostras e dá a energia real do som. Como o ouvido humano percebe a intensidade de forma logarítmica, e não linear, converter o valor RMS em decibéis (dB = 20 × log10(RMS)) produz um movimento de VU meter muito mais natural. Vamos usar isso na versão com ESP32.

CaracterísticaUno + KY-038ESP32 + INMP441
Tipo de microfoneEletreto analógico, sem amplificadorMEMS digital, saída I2S
ResoluçãoADC de 10 bits (passo de 4,9 mV)Dados de 24 bits
AmostragemCerca de 8,9 kHz (analogRead ~112 µs)16 kHz, contínua com DMA
Cálculo do nívelPico a picoRMS + decibéis
SensibilidadeBaixa, reage a sons altos e próximosAlta, capta bem a música do ambiente
RuídoAfetado pelo ruído da alimentaçãoMuito baixo, linha digital
DificuldadeInicianteIntermediário

Componentes necessários

  • Microcontrolador: um Arduino Uno (ou Nano) ou uma placa de desenvolvimento ESP32.
  • Microfone: um módulo sensor de som KY-038 para o Uno, um módulo de microfone I2S INMP441 para o ESP32.
  • LEDs: um anel WS2812B de 24 LEDs ou uma fita WS2812B de 30–60 LEDs.
  • Resistor de 330 Ω: em série com a linha de dados dos LEDs; evita reflexões do sinal e danos ao primeiro LED.
  • Capacitor de 1000 µF / 10 V: entre o 5V e o GND da alimentação dos LEDs; suaviza picos repentinos de corrente.
  • Potenciômetro de 10 kΩ: para ajustar a sensibilidade (fundo de escala) na versão com Uno.
  • Fonte de 5 V 2 A: indispensável se você usar mais de 24 LEDs ou aumentar o brilho.
  • Uma protoboard e jumpers.
Módulo sensor de som KY-038
Sensor de som KY-038: o pino AO fornece o sinal bruto do microfone, enquanto o pino DO gera um sinal digital quando o nível ultrapassa o limiar ajustado no trimpot.

Ligações do Uno + KY-038

Componente / pinoArduino UnoObservação
KY-038 +5VAlimentação do módulo
KY-038 GGNDGND comum
KY-038 AOA0Sinal de som analógico
KY-038 DODesconectadoNão usado no VU meter
Pino central do potenciômetroA1Pinos externos no 5V e no GND
WS2812B DIND6 (através de 330 Ω)Lado de entrada (DI) do anel
WS2812B 5V5V ou 5 V externoCapacitor de 1000 µF entre 5V e GND
WS2812B GNDGNDDeve ser comum com a fonte externa
Em branco com brilho máximo, 24 LEDs consomem cerca de 24 × 60 mA = 1,44 A, muito mais do que o Uno consegue fornecer pela USB. O código mantém o brilho em 60/255, mas, se você usar uma fita mais longa, alimente os LEDs com uma fonte externa de 5 V e sempre ligue o GND da fonte ao GND do Arduino. Sem GND comum, os LEDs mostram cores aleatórias. Para mais detalhes, veja o post WS2812B NeoPixel LED.

Medindo a amplitude do som: o método pico a pico

A saída AO do KY-038 é um sinal que fica estável em cerca de 2,5 V no silêncio e oscila acima e abaixo desse valor quando chega som. No Uno, o analogRead lê esse ponto médio como um número em torno de 500. Uma única leitura dá um valor aleatório, dependendo do momento da onda em que ela cai. Por isso lemos durante uma janela de 25 milissegundos e guardamos o maior e o menor valor. Como um analogRead no Uno leva cerca de 112 microssegundos, são feitas aproximadamente 220 amostras em 25 ms; isso basta para captar pelo menos algumas ondas completas de graves e médios. No fim da janela, o máximo menos o mínimo é o nível sonoro do momento. Como o KY-038 não tem amplificador, essa diferença fica entre 2–5 em um ambiente silencioso e entre 50–200 com música alta tocando por perto.

Versão com Uno passo a passo

  1. Abra o Gerenciador de Bibliotecas no Arduino IDE, busque a biblioteca Adafruit NeoPixel e instale.
  2. Monte o circuito seguindo a tabela acima; ligue a perna longa do capacitor (+) ao 5V.
  3. Carregue o código abaixo e mantenha o ambiente em silêncio durante o primeiro meio segundo: nesse tempo o código mede o piso de ruído.
  4. Abra o Monitor Serial em 115200 baud e veja o valor do piso de ruído exibido; se passar de 10, há ruído na alimentação.
  5. Toque uma música e gire o potenciômetro até encontrar o ponto em que o anel quase se completa no volume mais alto.
  6. Posicione o microfone a 20–50 cm do alto-falante, longe da luz dos LEDs e da vibração da 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}
Trecho do códigoFunção
readPeakToPeak() (leitura pico a pico)Faz amostras durante 25 ms e retorna a diferença entre o maior e o menor valor
noiseFloor (piso de ruído)Média das 20 medições da inicialização + 2; tudo abaixo disso conta como silêncio
maxPP (fundo de escala)Fundo de escala ajustado de 10–300 com o potenciômetro; valor pequeno = sensibilidade alta
level (nível)Nível suavizado que sobe rápido e desce devagar (evita cintilação)
peakLed (LED de pico)Ponto de pico branco; fica parado por 400 ms e depois desce um LED a cada 60 ms
vuColor() (cor do VU)Gera uma transição de cor de verde para amarelo e de amarelo para vermelho conforme a posição do LED

Ajuste de limiar e filtragem de ruído

Se você mostrar o nível sonoro bruto diretamente nos LEDs, vai enfrentar dois problemas. Primeiro, mesmo em um ambiente silencioso os primeiros LEDs ficam piscando sem parar, porque o microfone, os fios e a alimentação USB sempre produzem algum ruído. A solução é medir esse ruído e subtraí-lo de cada leitura. Nosso código faz uma medição de silêncio de meio segundo na inicialização e soma uma margem de 2 unidades à média. Esse valor funciona como um limiar: tudo o que fica abaixo dele é considerado zero. Se você for usar o projeto em um ambiente barulhento, pode aumentar essa margem para 4–5. O segundo ajuste é o fundo de escala: ele decide qual amplitude enche o anel por completo. Como o volume da música muda de um lugar para outro, ligamos esse valor ao potenciômetro em vez de deixá-lo fixo no código.

O segundo problema é a cintilação: janelas de 25 ms são tão curtas que o nível salta bruscamente de uma medição para a outra. Resolvemos isso com uma média móvel exponencial (EMA): novo nível = a × alvo + (1 − a) × nível anterior. Usamos a = 0,6 enquanto o som sobe, para que os LEDs captem as batidas da bateria na hora; com a = 0,15 enquanto ele desce, os LEDs caem devagar, como um ponteiro de verdade. Em engenharia de áudio essa distinção se chama attack e release. Como o loop leva cerca de 26 ms, com um coeficiente de release de 0,15 o nível cai 90% em cerca de 15 ciclos, ou seja, 0,4 segundo. Você pode comparar outros tipos de filtro no post filtragem de dados de sensores.

O trimpot azul do KY-038 ajusta apenas o limiar da saída DO; ele não aumenta a amplitude do sinal em AO. Se a versão com Uno só reage a sons altos e próximos, aumente a sensibilidade com o potenciômetro ou troque por um módulo de microfone com amplificador. Para todos os detalhes do KY-038, confira o post sensor de som KY-038.

Versão ESP32 + INMP441: medição limpa com microfone digital

O INMP441 é um microfone MEMS que converte o som para digital internamente com resolução de 24 bits e envia os dados pelo protocolo I2S. Como não há fio analógico, o ruído da alimentação não entra na medição, e a relação sinal-ruído é de cerca de 61 dB. O ESP32 coleta os dados I2S em segundo plano com DMA, sem sobrecarregar o processador; pegamos blocos de 512 amostras e calculamos o valor RMS. Com amostragem de 16 kHz, um bloco dura 32 ms, então o VU meter é atualizado cerca de 30 vezes por segundo. Você encontra os detalhes de funcionamento do microfone no post microfone I2S INMP441.

Componente / pinoESP32Observação
INMP441 VDD3V3Não aplique 5 V, o microfone é de 3,3 V
INMP441 GNDGNDGND comum
INMP441 L/RGNDSeleciona o canal esquerdo
INMP441 WSGPIO 25Seleção de palavra (LRCLK)
INMP441 SCKGPIO 32Clock de bit (BCLK)
INMP441 SDGPIO 33Dados de áudio
WS2812B DINGPIO 18 (através de 330 Ω)O sinal de 3,3 V funciona com fio curto
WS2812B 5VVIN (USB 5 V) ou 5 V externoAdicione um capacitor de 1000 µF
WS2812B GNDGNDComum com a fonte externa
Não deixe o pino L/R do INMP441 solto; se ele ficar flutuando, o microfone não consegue selecionar um canal e você vai ler zero ou dados sem sentido o tempo todo. Além disso, quando o WS2812B é alimentado com 5 V, o sinal de dados de 3,3 V do ESP32 pode ficar no limite em algumas fitas. Se o primeiro LED cintilar ou mostrar a cor errada, encurte o fio de dados ou use um conversor de nível 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}

O código escolhe automaticamente a nova biblioteca ESP_I2S se você usa o core ESP32 Arduino 3.x, ou o driver antigo driver/i2s.h se usa o 2.x. O INMP441 coloca cada amostra nos 24 bits superiores de um quadro de 32 bits; deslocar 8 bits para a direita dá o valor real. Em seguida a média é subtraída para remover o pequeno offset DC do microfone, e o RMS é calculado. Na escala de decibéis, cada 6 dB significa que a amplitude dobra. Com RANGE_DB = 35, o anel se completa a 35 dB acima do piso de ruído. Se você ouve música baixa em um ambiente silencioso, reduza esse valor para 25; em uma festa barulhenta, aumente para 45.

Se quiser usar um Raspberry Pi Pico, a classe machine.I2S do MicroPython também é suportada no RP2040; você pode ligar o mesmo INMP441 pelos pinos SCK, WS e SD e portar a lógica do RMS para Python. O MicroPython também tem um módulo neopixel integrado para o WS2812B. Para dar o primeiro passo com o Pico, o post O que é o Raspberry Pi Pico é um bom começo.

Indo além com o efeito: ideias de projetos

  • VU meter que abre do centro: faça um efeito simétrico que começa no LED 0 e no LED 12 do anel e se preenche nas duas direções.
  • VU meter estéreo: ligue o pino L/R de um INMP441 ao GND e o do outro ao 3V3, e mostre os canais esquerdo e direito em duas fitas separadas.
  • Espectro em matriz de LEDs: divida o som em bandas de frequência com uma FFT no ESP32 e desenhe barras de equalizador em uma matriz de LEDs WS2812B.
  • Luz de música para o quarto: se quiser uma interface pronta, transforme o ESP32 em um controlador de fita que reage ao som com a instalação do WLED.
  • Alerta de nível de ruído: faça um medidor de ruído para sala de aula ou biblioteca que deixa o anel vermelho e toca um buzzer quando o som passa de certo valor em dB.
  • Decoração de Natal: combine com o projeto de árvore de Natal com LEDs para ter uma árvore que muda de cor com a música.

Erros comuns e como corrigir

SintomaCausa provávelSolução
Os LEDs cintilam no silêncioPiso de ruído medido baixo demaisMantenha o ambiente em silêncio na inicialização, aumente a margem do limiar de 2 para 4–5
Nenhuma reação à música (Uno)Sinal do KY-038 fraco demaisReduza maxPP com o potenciômetro, aproxime o microfone do alto-falante
O anel fica sempre cheioFundo de escala pequeno demaisGire o potenciômetro para aumentar maxPP, ou aumente RANGE_DB
O INMP441 sempre lê zeroL/R solto ou canal invertidoLigue o L/R ao GND; se ainda não funcionar, ligue ao 3V3 e selecione o canal direito no código
O primeiro LED mostra a cor erradaSinal de dados fraco ou falta de resistorAdicione um resistor de 330 Ω em série, encurte o fio de dados
A placa reinicia em uma batida de graveA corrente dos LEDs derruba a alimentaçãoReduza o brilho, use uma fonte externa de 5 V e um capacitor de 1000 µF
Os LEDs disparam o microfoneA ondulação da alimentação vaza para a linha analógicaLigue o microfone ao 5V com um fio separado, una os GNDs em um único ponto
O Plotter Serial é muito útil durante o ajuste: adicione Serial.println(pp) ao loop (ou Serial.println(db) no ESP32) e observe o gráfico enquanto a música toca. A linha no silêncio mostra o piso de ruído, e o pico no momento mais alto da música mostra exatamente o valor que você deve usar como fundo de escala.

Um projeto de LED que reage à música reúne medição de sinal analógico, filtragem e controle de LEDs endereçáveis em um único circuito divertido. Você pode começar em poucos minutos com o Uno e o KY-038 e depois evoluir para um indicador de som com cara profissional usando o ESP32 e o INMP441. No app BlueGrays você também pode acompanhar passo a passo o controle de fita NeoPixel com ESP32, com esquema do circuito e código pronto, além de projetos de LED corrida com WS2812B, efeito Knight Rider, luzes de polícia e animações.

Perguntas frequentes

Qual sensor de som é melhor para LEDs que reagem à música?

O KY-038 serve para iniciantes e orçamentos baixos, mas, como não tem amplificador, só reage bem a sons altos e próximos. Para resultados mais sensíveis e com menos ruído, use um microfone digital I2S como o INMP441 com um ESP32, ou um módulo de microfone analógico com amplificador.

Por que meu sensor de som KY-038 não reage à música?

O sinal na saída AO do KY-038 geralmente oscila só algumas unidades do ADC, e o trimpot não o amplifica, apenas muda o limiar do DO. Aproxime o microfone do alto-falante, reduza o fundo de escala no código e confira se você está usando medição pico a pico em vez de uma única leitura.

Como acender LEDs WS2812B de acordo com a música usando Arduino?

Você faz amostras do microfone durante uma curta janela de tempo, calcula o nível sonoro e o converte em quantidade de LEDs com uma proporção no estilo de map. Depois acende essa quantidade de LEDs com a biblioteca Adafruit NeoPixel e atualiza com strip.show(); um filtro de suavização mantém o efeito fluido, sem cintilação.

O microfone INMP441 funciona com Arduino Uno?

Não, o Arduino Uno não tem hardware I2S, então não consegue ler dados do INMP441. Você precisa de uma placa com suporte a I2S, como ESP32, ESP32-S3 ou Raspberry Pi Pico; para o Uno, os módulos de microfone com saída analógica são os adequados.

Quanta corrente um anel WS2812B de 24 LEDs consome?

Cada LED consome cerca de 60 mA em branco total, então 24 LEDs consomem 1,44 A no pior caso. Em um efeito de VU meter, raramente todos os LEDs acendem com brilho máximo, então o consumo real é bem menor; ainda assim, limitar o brilho e usar uma fonte externa de 5 V é o caminho mais seguro.

LEDs que reagem à música podem mudar de cor conforme a frequência?

Sim, para isso você precisa dividir o som em bandas de frequência, como graves, médios e agudos, com uma FFT. O ESP32 tem poder de processamento e memória suficientes para uma FFT em tempo real; no Uno só é possível fazer uma análise limitada e de baixa resolução.

Ver todos os projetos
Controle de fita WS2812B NeoPixel com ESP32
ES-24Intermediário
Premium

Controle de fita WS2812B NeoPixel com ESP32

Os LEDs endereçáveis WS2812B (NeoPixel) são LEDs RGB inteligentes que podem ser controlados em cadeia por um único pino de dados. Neste projeto, vamos controlar uma fita WS2812B de 8 LEDs com a biblioteca Adafruit_NeoPixel para criar uma animação suave de arco-íris. Embora o nível lógico de 3,3V do ESP32 funcione sem problemas na maioria dos lotes de WS2812B, vamos mostrar uma solução com um resistor de 470Ω em série e um capacitor de 1.000µF para casos de instabilidade.

4.9(19)
30
Uso da fita LED WS2812B
AR-69Intermediário
Premium

Uso da fita LED WS2812B

Conheça uma fita LED inteligente em que você pode definir a cor de cada luz individualmente.

4.8(54)
70
Luzes de polícia com WS2812B
AR-70Intermediário
Premium

Luzes de polícia com WS2812B

Traga as luzes vermelhas e azuis do teto de uma viatura para a sua mesa. Metade de uma fita WS2812B de dez LEDs pisca em vermelho três vezes seguidas rapidamente, depois a outra metade pisca em azul…

4.8(67)
86
LED sequencial com WS2812B
AR-71Intermediário
Premium

LED sequencial com WS2812B

Em uma fita de dez LEDs, um ponto de luz verde avança do início ao fim, um LED por vez, e depois volta ao começo; ele permanece em cada LED por um terço de segundo.

4.8(58)
75
LED sequencial com WS2812B (efeito de preenchimento)
AR-72Intermediário
Premium

LED sequencial com WS2812B (efeito de preenchimento)

Uma fita de luz que enche e esvazia como um copo de água. O Arduino acende dez LEDs coloridos em laranja, um por vez, e os mantém acesos; quando a fita está cheia, apaga um por vez na mesma ordem, e…

4.7(50)
65
Efeito Super Máquina com WS2812B
AR-73Intermediário
Premium

Efeito Super Máquina com WS2812B

Um ponto de luz vermelho desliza de uma ponta à outra de uma fita LED inteligente e volta, indo e vindo sem parar.

4.9(73)
94
Animação 1 com WS2812B
AR-75Intermediário
Premium

Animação 1 com WS2812B

Em uma fita de 56 LEDs, todas as cores do arco-íris ficam lado a lado e fluem sem parar, como se um rio de luz deslizasse pela fita.

4.9(69)
89
Animação 2 com WS2812B
AR-76Intermediário
Premium

Animação 2 com WS2812B

Monte no seu quarto um espetáculo de luzes que muda de cor sozinho. O Arduino mantém as cores em movimento em uma fita de 30 LEDs e troca o conjunto de cores a cada poucos segundos: arco-íris, faixas…

4.8(65)
84