LED Reattivi alla Musica con Arduino: VU Meter WS2812B
LED reattivi alla musica con Arduino Uno + KY-038 ed ESP32 + INMP441: VU meter su anello WS2812B con collegamenti, codice pronto, soglia e filtro del rumore.
Un progetto di LED reattivi alla musica con Arduino ascolta il suono con un microfono e accende più LED quanto più il volume è alto, imitando il VU meter dei vecchi impianti stereo. In questa guida userai un anello WS2812B da 24 LED (lo stesso codice funziona anche con una striscia) e costruirai due versioni: una economica e veloce con Arduino Uno e il sensore sonoro KY-038, e una molto più pulita con ESP32 e il microfono digitale I2S INMP441.
Il vero segreto del progetto non è accendere i LED, ma misurare bene il suono. Il segnale del microfono è un'onda che cambia direzione migliaia di volte al secondo: un singolo valore di analogRead non ti dice nulla. Per questo imparerai passo dopo passo a misurare l'ampiezza in una finestra di tempo, a trovare in automatico il rumore di fondo in ambiente silenzioso, a regolare la sensibilità con un potenziometro e a usare un filtro di smussamento che elimina lo sfarfallio.

Come funzionano i LED reattivi alla musica?
La catena ha quattro anelli: il microfono trasforma il suono in segnale elettrico, il microcontrollore lo campiona, dai campioni si calcola un unico numero di livello sonoro e questo numero viene convertito nel numero di LED da accendere. Ci sono due modi comuni per calcolare il livello. Con il metodo picco-picco (peak-to-peak) si prende la differenza tra il valore massimo e minimo in un breve intervallo: è semplice e basta per l'Uno. Con il metodo RMS si calcola la radice della media dei quadrati dei campioni, che dà la vera energia del suono. Poiché l'orecchio umano percepisce il suono in modo logaritmico e non lineare, convertire l'RMS in decibel (dB = 20 × log10(RMS)) dà un movimento del VU meter molto più naturale. Lo useremo nella versione ESP32.
| Caratteristica | Uno + KY-038 | ESP32 + INMP441 |
|---|---|---|
| Tipo di microfono | Electret analogico, senza amplificatore | MEMS digitale, uscita I2S |
| Risoluzione | ADC a 10 bit (passo di 4,9 mV) | Dati a 24 bit |
| Campionamento | Circa 8,9 kHz (analogRead ~112 µs) | 16 kHz, continuo con DMA |
| Calcolo del livello | Picco-picco | RMS + decibel |
| Sensibilità | Bassa, reagisce a suoni forti e vicini | Alta, rileva bene la musica in una stanza |
| Rumore | Risente del rumore di alimentazione | Molto basso, linea digitale |
| Difficoltà | Principiante | Media |
Materiale necessario
- Microcontrollore: Arduino Uno (o Nano) oppure scheda di sviluppo ESP32.
- Microfono: modulo sensore sonoro KY-038 per l'Uno, modulo microfono I2S INMP441 per l'ESP32.
- LED: anello WS2812B da 24 LED oppure striscia WS2812B da 30–60 LED.
- Resistenza da 330 Ω: in serie alla linea dati dei LED, evita riflessioni del segnale e danni al primo LED.
- Condensatore da 1000 µF / 10 V: tra i poli 5V e GND dell'alimentazione dei LED, attenua i picchi di corrente.
- Potenziometro da 10 kΩ: per regolare la sensibilità (fondoscala) nella versione Uno.
- Alimentatore 5 V 2 A: indispensabile se usi più di 24 LED o alzi la luminosità.
- Breadboard e cavi jumper.

Collegamento Uno + KY-038
| Componente / pin | Arduino Uno | Nota |
|---|---|---|
| KY-038 + | 5V | Alimentazione del modulo |
| KY-038 G | GND | Massa comune |
| KY-038 AO | A0 | Segnale audio analogico |
| KY-038 DO | Non collegato | Non serve per il VU meter |
| Cursore del potenziometro | A1 | Gli estremi vanno a 5V e GND |
| WS2812B DIN | D6 (tramite 330 Ω) | Lato ingresso (DI) dell'anello |
| WS2812B 5V | 5V o 5 V esterno | Condensatore da 1000 µF tra 5V e GND |
| WS2812B GND | GND | Deve essere in comune con l'alimentatore esterno |
Misurare l'ampiezza del suono: il metodo picco-picco
L'uscita AO del KY-038 è un segnale che in silenzio resta fermo intorno a 2,5 V e oscilla sopra e sotto questo valore quando arriva il suono. Sull'Uno analogRead legge questo punto centrale come un numero intorno a 500. Una singola lettura dà un valore casuale, a seconda del punto dell'onda in cui cade. Per questo leggiamo per una finestra di 25 millisecondi e memorizziamo il valore massimo e minimo. Poiché un analogRead sull'Uno dura circa 112 microsecondi, in 25 ms si prendono circa 220 campioni: abbastanza per catturare almeno qualche onda completa di bassi e medi. A fine finestra, massimo meno minimo è il livello sonoro di quell'istante. Il KY-038 non ha amplificatore, quindi in una stanza silenziosa questa differenza è 2–5, mentre con musica alta vicina arriva a 50–200.
Versione Uno passo dopo passo
- Nell'IDE di Arduino apri il Gestore Librerie, cerca la libreria Adafruit NeoPixel e installala.
- Monta il circuito seguendo la tabella qui sopra; collega la gamba lunga (+) del condensatore a 5V.
- Carica il codice qui sotto e per il primo mezzo secondo mantieni l'ambiente silenzioso: in questo tempo il codice misura il rumore di fondo.
- Apri il Monitor Seriale a 115200 baud e guarda il valore del rumore di fondo: se supera 10 c'è rumore di alimentazione.
- Metti della musica e ruota il potenziometro fino a trovare il punto in cui, al volume massimo, l'anello si riempie quasi del tutto.
- Posiziona il microfono a 20–50 cm dall'altoparlante, lontano dalla luce dei LED e dalle vibrazioni del tavolo.
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 di codice | Funzione |
|---|---|
| readPeakToPeak() | Campiona per 25 ms e restituisce la differenza tra valore massimo e minimo |
| noiseFloor | Media delle 20 misure all'avvio + 2; sotto questo valore è considerato silenzio |
| maxPP | Fondoscala regolato tra 10 e 300 col potenziometro; valore piccolo = alta sensibilità |
| level | Livello smussato che sale veloce e scende lento (evita lo sfarfallio) |
| peakLed | Punto di picco bianco; aspetta 400 ms, poi scende di un LED ogni 60 ms |
| vuColor() | Genera la transizione di colore da verde a giallo e da giallo a rosso in base alla posizione del LED |
Regolazione della soglia e filtro del rumore
Se mostri il livello sonoro grezzo direttamente sui LED incontri due problemi. Il primo: anche in ambiente silenzioso i primi LED lampeggiano di continuo, perché microfono, cavi e alimentazione USB producono sempre un po' di rumore. La soluzione è misurare questo rumore e sottrarlo a ogni lettura. Il nostro codice all'avvio misura mezzo secondo di silenzio e aggiunge alla media un margine di 2 unità. Questo valore funziona come soglia: tutto ciò che sta sotto è considerato zero. Se lavori in un ambiente rumoroso puoi portare il margine a 4–5. La seconda regolazione è il fondoscala: stabilisce quale ampiezza riempie completamente l'anello. Poiché il volume della musica cambia da ambiente a ambiente, invece di scriverlo fisso nel codice lo abbiamo collegato al potenziometro.
Il secondo problema è lo sfarfallio: le finestre da 25 ms sono molto brevi, quindi il livello salta bruscamente da una misura all'altra. Lo risolviamo con la media mobile esponenziale (EMA): nuovo livello = a × obiettivo + (1 − a) × vecchio livello. Quando il suono sale usiamo a = 0,6, così i LED catturano subito i colpi di batteria; quando scende a = 0,15, quindi i LED calano lentamente come una vera lancetta. Nell'ingegneria del suono questa distinzione si chiama attack e release. Dato che il ciclo dura circa 26 ms, con un coefficiente di release di 0,15 il livello cala del 90% in circa 15 cicli, cioè 0,4 secondi. Puoi confrontare altri tipi di filtro nell'articolo filtraggio dei dati dei sensori.
Versione ESP32 + INMP441: misura pulita con microfono digitale
L'INMP441 è un microfono MEMS che converte il suono in digitale al suo interno con risoluzione a 24 bit e invia i dati con il protocollo I2S. Non essendoci un cavo analogico, il rumore di alimentazione non entra nella misura e il rapporto segnale/rumore è di circa 61 dB. L'ESP32 raccoglie i dati I2S in background tramite DMA senza impegnare il processore; noi prendiamo blocchi da 512 campioni e calcoliamo l'RMS. A 16 kHz un blocco dura 32 ms, quindi il VU meter si aggiorna circa 30 volte al secondo. Trovi il funzionamento del microfono nell'articolo microfono I2S INMP441.
| Componente / pin | ESP32 | Nota |
|---|---|---|
| INMP441 VDD | 3V3 | Non dare 5 V, il microfono è da 3,3 V |
| INMP441 GND | GND | Massa comune |
| INMP441 L/R | GND | Seleziona il canale sinistro |
| INMP441 WS | GPIO 25 | Selezione parola (LRCLK) |
| INMP441 SCK | GPIO 32 | Clock di bit (BCLK) |
| INMP441 SD | GPIO 33 | Dati audio |
| WS2812B DIN | GPIO 18 (tramite 330 Ω) | Il segnale a 3,3 V funziona con cavo corto |
| WS2812B 5V | VIN (5 V USB) o 5 V esterno | Aggiungi un condensatore da 1000 µF |
| WS2812B GND | GND | In comune con l'alimentatore esterno |
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}Il codice sceglie automaticamente la nuova libreria ESP_I2S se usi l'ESP32 Arduino core 3.x, oppure il vecchio driver driver/i2s.h con il core 2.x. L'INMP441 colloca ogni campione nei 24 bit alti di un frame a 32 bit; uno spostamento di 8 bit a destra restituisce il valore reale. Poi si sottrae la media per eliminare il piccolo offset DC del microfono e si calcola l'RMS. Sulla scala dei decibel ogni 6 dB corrispondono al raddoppio dell'ampiezza. Con RANGE_DB = 35 l'anello si riempie completamente a 35 dB sopra il rumore di fondo. Se ascolti musica a basso volume in una stanza silenziosa portalo a 25, a una festa rumorosa a 45.
Se vuoi usare un Raspberry Pi Pico, la classe machine.I2S di MicroPython è supportata anche su RP2040: collega lo stesso INMP441 con i pin SCK, WS e SD e porta la logica RMS in Python. Per i WS2812B MicroPython ha anche il modulo integrato neopixel. Per muovere i primi passi con il Pico è un buon inizio l'articolo Cos'è Raspberry Pi Pico.
Migliorare l'effetto: idee per i progetti
- VU meter che si apre dal centro: crea un effetto simmetrico che parte dal LED 0 e dal LED 12 dell'anello e si riempie nelle due direzioni.
- VU meter stereo: collega il pin L/R di un INMP441 a GND e quello dell'altro a 3V3, e mostra canale sinistro e destro su due strisce separate.
- Spettro su matrice LED: con la FFT sull'ESP32 dividi il suono in bande di frequenza e disegna barre da equalizzatore su una matrice LED WS2812B.
- Luce musicale per la stanza: se vuoi un'interfaccia già pronta, con l'installazione di WLED trasformi l'ESP32 in un controller di strisce reattivo al suono.
- Avviso di volume: crea un misuratore di rumore per aula o biblioteca che accende l'anello di rosso e fa suonare un buzzer quando il suono supera un certo livello in dB.
- Decorazione natalizia: uniscilo al progetto dell'albero di Natale a LED per un albero che cambia colore con la musica.
Errori comuni e come risolverli
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| I LED sfarfallano in silenzio | Rumore di fondo misurato troppo basso | Mantieni silenzio all'avvio, porta il margine della soglia da 2 a 4–5 |
| Nessuna reazione alla musica (Uno) | Segnale del KY-038 troppo debole | Abbassa maxPP col potenziometro, avvicina il microfono all'altoparlante |
| L'anello è sempre pieno | Fondoscala troppo piccolo | Ruota il potenziometro per aumentare maxPP o aumenta RANGE_DB |
| L'INMP441 legge sempre zero | L/R scollegato o canale invertito | Collega L/R a GND; se non basta collegalo a 3V3 e scegli il canale destro nel codice |
| Il primo LED ha il colore sbagliato | Segnale dati debole o manca la resistenza | Aggiungi la resistenza in serie da 330 Ω, accorcia il cavo dati |
| La scheda si resetta sui colpi di basso | La corrente dei LED fa crollare l'alimentazione | Abbassa la luminosità, usa un alimentatore esterno da 5 V e un condensatore da 1000 µF |
| I LED disturbano il microfono | Le oscillazioni dell'alimentazione entrano nella linea analogica | Collega il microfono a 5V con un cavo separato, unisci i GND in un solo punto |
Il progetto di LED reattivi alla musica unisce in un solo circuito divertente misura di segnali analogici, filtraggio e controllo di LED indirizzabili. Puoi iniziare in pochi minuti con Uno e KY-038 e passare a un indicatore audio professionale con ESP32 e INMP441. Nell'app BlueGrays trovi, passo dopo passo con schema elettrico e codice pronto, progetti come LED in movimento WS2812B, Knight Rider, lampeggiante della polizia e animazioni, oltre al controllo di strisce NeoPixel con ESP32.
Domande frequenti
Quale sensore sonoro è meglio per i LED reattivi alla musica?
Per iniziare e con poco budget il KY-038 va bene, ma senza amplificatore reagisce bene solo ai suoni forti e vicini. Se vuoi un risultato più sensibile e senza rumore usa un microfono digitale I2S come l'INMP441 con ESP32, oppure un modulo microfono analogico con amplificatore.
Perché il sensore sonoro KY-038 non reagisce alla musica?
Il segnale sull'uscita AO del KY-038 di solito oscilla solo di poche unità dell'ADC e il trimmer non lo amplifica, cambia solo la soglia di DO. Avvicina il microfono all'altoparlante, abbassa il fondoscala nel codice e assicurati di misurare il picco-picco invece di fare una singola lettura.
Come accendo i LED WS2812B a tempo di musica con Arduino?
Prendi campioni dal microfono in una breve finestra di tempo, calcola il livello sonoro e convertilo nel numero di LED con una proporzione tipo map. Poi accendi quel numero di LED con la libreria Adafruit NeoPixel e aggiorna con strip.show(); un filtro di smussamento fa scorrere l'effetto senza sfarfallio.
Il microfono INMP441 funziona con Arduino Uno?
No, l'Arduino Uno non ha hardware I2S e non può leggere i dati dell'INMP441. Servono schede con supporto I2S come ESP32, ESP32-S3 o Raspberry Pi Pico; per l'Uno vanno bene i moduli microfono con uscita analogica.
Quanta corrente assorbe un anello WS2812B da 24 LED?
Ogni LED assorbe circa 60 mA in bianco pieno, quindi 24 LED nel caso peggiore assorbono 1,44 A. Nell'effetto VU meter tutti i LED raramente sono accesi alla massima luminosità, quindi il consumo reale è molto più basso; limitare la luminosità e usare un'alimentazione esterna da 5 V resta comunque la strada più sicura.
È possibile cambiare il colore dei LED in base alla frequenza?
Sì, per farlo devi dividere il suono con la FFT in bande di frequenza come bassi, medi e acuti. La potenza di calcolo e la memoria dell'ESP32 bastano per una FFT in tempo reale; sull'Uno si può fare solo un'analisi limitata e a bassa risoluzione.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Controllo della striscia LED NeoPixel WS2812B con ESP32
I LED indirizzabili WS2812B (NeoPixel) sono LED RGB intelligenti collegabili in catena e controllati da un solo pin dati. Pilotiamo una striscia WS2812B da 8 LED con la libreria Adafruit_NeoPixel e creiamo un arcobaleno fluido. La logica a 3,3 V dell'ESP32 va bene con quasi tutti i WS2812B; in caso di instabilità mostriamo la soluzione con una resistenza in serie da 470Ω e un condensatore da 1000µF. L'animazione sposta la tonalità nello spazio HSV.

Utilizzo della striscia LED WS2812B
Conosci una striscia LED intelligente in cui puoi colorare ogni singola luce per conto suo.

Lampeggiante della polizia con WS2812B
Porti sulla scrivania il lampeggiante rosso e blu del tetto di un'auto della polizia.

LED in sequenza con WS2812B
Su una striscia di dieci LED, un puntino di luce verde avanza dall'inizio alla fine un LED alla volta, poi torna all'inizio; resta su ogni LED per un terzo di secondo.

LED in sequenza con WS2812B (riempimento)
Una striscia di luce che si riempie e si svuota come un bicchiere d'acqua. L'Arduino accende uno alla volta dieci LED colorati in arancione e li lascia accesi; quando la striscia è piena, li spegne…

Effetto Supercar con WS2812B
Un punto di luce rossa scorre da un capo all'altro di una striscia LED intelligente e poi torna indietro, in un avanti e indietro che non si ferma mai.

WS2812B Animazione 1
Su una striscia di 56 LED tutti i colori dell'arcobaleno si mettono in fila uno accanto all'altro e scorrono senza fermarsi mai, come se un fiume di luce scivolasse lungo la striscia.

WS2812B Animazione 2
Allestisci nella tua stanza uno spettacolo di luci che cambia colore da solo. L'Arduino fa scorrere i colori senza sosta su una striscia da 30 LED e ogni pochi secondi passa a una nuova serie…
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

