Guide · 9 min di lettura

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.

Anello LED RGB WS2812B NeoPixel da 24
Anello WS2812B da 24 LED: un solo filo dati controlla il colore di ogni LED, ideale per un VU meter.

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.

CaratteristicaUno + KY-038ESP32 + INMP441
Tipo di microfonoElectret analogico, senza amplificatoreMEMS digitale, uscita I2S
RisoluzioneADC a 10 bit (passo di 4,9 mV)Dati a 24 bit
CampionamentoCirca 8,9 kHz (analogRead ~112 µs)16 kHz, continuo con DMA
Calcolo del livelloPicco-piccoRMS + decibel
SensibilitàBassa, reagisce a suoni forti e viciniAlta, rileva bene la musica in una stanza
RumoreRisente del rumore di alimentazioneMolto basso, linea digitale
DifficoltàPrincipianteMedia

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.
Modulo sensore sonoro KY-038
Sensore sonoro KY-038: il pin AO fornisce il segnale grezzo del microfono, il pin DO dà un segnale digitale quando si supera la soglia regolata dal trimmer.

Collegamento Uno + KY-038

Componente / pinArduino UnoNota
KY-038 +5VAlimentazione del modulo
KY-038 GGNDMassa comune
KY-038 AOA0Segnale audio analogico
KY-038 DONon collegatoNon serve per il VU meter
Cursore del potenziometroA1Gli estremi vanno a 5V e GND
WS2812B DIND6 (tramite 330 Ω)Lato ingresso (DI) dell'anello
WS2812B 5V5V o 5 V esternoCondensatore da 1000 µF tra 5V e GND
WS2812B GNDGNDDeve essere in comune con l'alimentatore esterno
24 LED a piena luminosità bianca assorbono circa 24 × 60 mA = 1,44 A, molto più di quanto l'Uno può fornire via USB. Nel codice teniamo la luminosità a 60/255, ma se usi una striscia lunga alimenta i LED da un alimentatore esterno da 5 V e collega sempre il GND dell'alimentatore al GND di Arduino. Senza massa comune i LED mostrano colori casuali. Per approfondire guarda l'articolo LED WS2812B NeoPixel.

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

  1. Nell'IDE di Arduino apri il Gestore Librerie, cerca la libreria Adafruit NeoPixel e installala.
  2. Monta il circuito seguendo la tabella qui sopra; collega la gamba lunga (+) del condensatore a 5V.
  3. 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.
  4. Apri il Monitor Seriale a 115200 baud e guarda il valore del rumore di fondo: se supera 10 c'è rumore di alimentazione.
  5. Metti della musica e ruota il potenziometro fino a trovare il punto in cui, al volume massimo, l'anello si riempie quasi del tutto.
  6. Posiziona il microfono a 20–50 cm dall'altoparlante, lontano dalla luce dei LED e dalle vibrazioni del tavolo.
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 di codiceFunzione
readPeakToPeak()Campiona per 25 ms e restituisce la differenza tra valore massimo e minimo
noiseFloorMedia delle 20 misure all'avvio + 2; sotto questo valore è considerato silenzio
maxPPFondoscala regolato tra 10 e 300 col potenziometro; valore piccolo = alta sensibilità
levelLivello smussato che sale veloce e scende lento (evita lo sfarfallio)
peakLedPunto 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.

Il trimmer blu sul KY-038 regola solo la soglia dell'uscita DO; non aumenta l'ampiezza del segnale su AO. Se la versione Uno reagisce solo ai suoni forti e vicini, aumenta la sensibilità col potenziometro oppure passa a un modulo microfono con amplificatore. Per tutti i dettagli del KY-038 leggi l'articolo sensore sonoro KY-038.

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 / pinESP32Nota
INMP441 VDD3V3Non dare 5 V, il microfono è da 3,3 V
INMP441 GNDGNDMassa comune
INMP441 L/RGNDSeleziona il canale sinistro
INMP441 WSGPIO 25Selezione parola (LRCLK)
INMP441 SCKGPIO 32Clock di bit (BCLK)
INMP441 SDGPIO 33Dati audio
WS2812B DINGPIO 18 (tramite 330 Ω)Il segnale a 3,3 V funziona con cavo corto
WS2812B 5VVIN (5 V USB) o 5 V esternoAggiungi un condensatore da 1000 µF
WS2812B GNDGNDIn comune con l'alimentatore esterno
Non lasciare il pin L/R dell'INMP441 scollegato: se è flottante il microfono non riesce a scegliere il canale e leggi sempre zero o dati senza senso. Inoltre, con i WS2812B alimentati a 5 V il segnale dati a 3,3 V dell'ESP32 su alcune strisce è al limite. Se il primo LED sfarfalla o mostra il colore sbagliato, accorcia il cavo dati o usa un convertitore di livello logico.
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}

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

SintomoCausa probabileSoluzione
I LED sfarfallano in silenzioRumore di fondo misurato troppo bassoMantieni silenzio all'avvio, porta il margine della soglia da 2 a 4–5
Nessuna reazione alla musica (Uno)Segnale del KY-038 troppo deboleAbbassa maxPP col potenziometro, avvicina il microfono all'altoparlante
L'anello è sempre pienoFondoscala troppo piccoloRuota il potenziometro per aumentare maxPP o aumenta RANGE_DB
L'INMP441 legge sempre zeroL/R scollegato o canale invertitoCollega L/R a GND; se non basta collegalo a 3V3 e scegli il canale destro nel codice
Il primo LED ha il colore sbagliatoSegnale dati debole o manca la resistenzaAggiungi la resistenza in serie da 330 Ω, accorcia il cavo dati
La scheda si resetta sui colpi di bassoLa corrente dei LED fa crollare l'alimentazioneAbbassa la luminosità, usa un alimentatore esterno da 5 V e un condensatore da 1000 µF
I LED disturbano il microfonoLe oscillazioni dell'alimentazione entrano nella linea analogicaCollega il microfono a 5V con un cavo separato, unisci i GND in un solo punto
Per regolare il progetto è molto utile il Plotter Seriale: aggiungi nel ciclo Serial.println(pp), o Serial.println(db) sull'ESP32, e guarda il grafico mentre suona la musica. La linea in silenzio mostra il rumore di fondo, mentre il picco nel momento più forte del brano indica direttamente quale valore scrivere come fondoscala.

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.

Vedi tutti i progetti
Controllo della striscia LED NeoPixel WS2812B con ESP32
ES-24Intermedio
Premium

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.

4.9(19)
30
Utilizzo della striscia LED WS2812B
AR-69Intermedio
Premium

Utilizzo della striscia LED WS2812B

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

4.8(54)
70
Lampeggiante della polizia con WS2812B
AR-70Intermedio
Premium

Lampeggiante della polizia con WS2812B

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

4.8(67)
86
LED in sequenza con WS2812B
AR-71Intermedio
Premium

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.

4.8(58)
75
LED in sequenza con WS2812B (riempimento)
AR-72Intermedio
Premium

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…

4.7(50)
65
Effetto Supercar con WS2812B
AR-73Intermedio
Premium

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.

4.9(73)
94
WS2812B Animazione 1
AR-75Intermedio
Premium

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.

4.9(69)
89
WS2812B Animazione 2
AR-76Intermedio
Premium

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…

4.8(65)
84