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.

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ística | Uno + KY-038 | ESP32 + INMP441 |
|---|---|---|
| Tipo de microfone | Eletreto analógico, sem amplificador | MEMS digital, saída I2S |
| Resolução | ADC de 10 bits (passo de 4,9 mV) | Dados de 24 bits |
| Amostragem | Cerca de 8,9 kHz (analogRead ~112 µs) | 16 kHz, contínua com DMA |
| Cálculo do nível | Pico a pico | RMS + decibéis |
| Sensibilidade | Baixa, reage a sons altos e próximos | Alta, capta bem a música do ambiente |
| Ruído | Afetado pelo ruído da alimentação | Muito baixo, linha digital |
| Dificuldade | Iniciante | Intermediá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.

Ligações do Uno + KY-038
| Componente / pino | Arduino Uno | Observação |
|---|---|---|
| KY-038 + | 5V | Alimentação do módulo |
| KY-038 G | GND | GND comum |
| KY-038 AO | A0 | Sinal de som analógico |
| KY-038 DO | Desconectado | Não usado no VU meter |
| Pino central do potenciômetro | A1 | Pinos externos no 5V e no GND |
| WS2812B DIN | D6 (através de 330 Ω) | Lado de entrada (DI) do anel |
| WS2812B 5V | 5V ou 5 V externo | Capacitor de 1000 µF entre 5V e GND |
| WS2812B GND | GND | Deve ser comum com a fonte externa |
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
- Abra o Gerenciador de Bibliotecas no Arduino IDE, busque a biblioteca Adafruit NeoPixel e instale.
- Monte o circuito seguindo a tabela acima; ligue a perna longa do capacitor (+) ao 5V.
- 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.
- 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.
- Toque uma música e gire o potenciômetro até encontrar o ponto em que o anel quase se completa no volume mais alto.
- Posicione o microfone a 20–50 cm do alto-falante, longe da luz dos LEDs e da vibração da 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}| Trecho do código | Funçã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.
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 / pino | ESP32 | Observação |
|---|---|---|
| INMP441 VDD | 3V3 | Não aplique 5 V, o microfone é de 3,3 V |
| INMP441 GND | GND | GND comum |
| INMP441 L/R | GND | Seleciona o canal esquerdo |
| INMP441 WS | GPIO 25 | Seleção de palavra (LRCLK) |
| INMP441 SCK | GPIO 32 | Clock de bit (BCLK) |
| INMP441 SD | GPIO 33 | Dados de áudio |
| WS2812B DIN | GPIO 18 (através de 330 Ω) | O sinal de 3,3 V funciona com fio curto |
| WS2812B 5V | VIN (USB 5 V) ou 5 V externo | Adicione um capacitor de 1000 µF |
| WS2812B GND | GND | Comum com a fonte 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}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
| Sintoma | Causa provável | Solução |
|---|---|---|
| Os LEDs cintilam no silêncio | Piso de ruído medido baixo demais | Mantenha 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 demais | Reduza maxPP com o potenciômetro, aproxime o microfone do alto-falante |
| O anel fica sempre cheio | Fundo de escala pequeno demais | Gire o potenciômetro para aumentar maxPP, ou aumente RANGE_DB |
| O INMP441 sempre lê zero | L/R solto ou canal invertido | Ligue 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 errada | Sinal de dados fraco ou falta de resistor | Adicione um resistor de 330 Ω em série, encurte o fio de dados |
| A placa reinicia em uma batida de grave | A corrente dos LEDs derruba a alimentação | Reduza o brilho, use uma fonte externa de 5 V e um capacitor de 1000 µF |
| Os LEDs disparam o microfone | A ondulação da alimentação vaza para a linha analógica | Ligue o microfone ao 5V com um fio separado, una os GNDs em um único ponto |
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.
Projetos para montar depois desta leitura
Ver todos os projetos
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.

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

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…

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.

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…

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.

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.

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…
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

