Gidsen · 9 min leestijd

Muziekgestuurde led met Arduino: WS2812B VU-meterproject

Muziekgestuurde led: bouw een VU-meter op een WS2812B-ring met Arduino Uno + KY-038 of ESP32 + INMP441. Bedrading, kant-en-klare code, drempel afstellen en ruis filteren.

Een muziekgestuurd led-project met Arduino luistert met een microfoon naar het geluid om je heen en laat meer leds oplichten naarmate het harder wordt, zoals de VU-meter op oude hifi-installaties. In deze gids gebruik je een WS2812B-ring met 24 leds (dezelfde code werkt op een strip) om twee versies te bouwen: een goedkope, snelle versie met een Arduino Uno en een KY-038-geluidssensor, en een versie die veel schoner meet, met een ESP32 en een INMP441 digitale I2S-microfoon.

Het echte kunstje van dit project is niet het laten branden van leds, maar het goed meten van geluid. Het microfoonsignaal is een golf die duizenden keren per seconde van richting verandert, dus één analogRead-waarde zegt niets. Daarom leer je stap voor stap hoe je de amplitude over een tijdvenster meet, automatisch de ruisvloer van een stille kamer bepaalt, de gevoeligheid instelt met een potmeter en een afvlakfilter gebruikt dat flikkeren tegengaat.

WS2812B NeoPixel RGB-ring met 24 leds
WS2812B-ring met 24 leds: de kleur van elke led wordt los aangestuurd via één datadraad, ideaal voor een VU-meter.

Hoe werkt een muziekgestuurde led?

De keten heeft vier schakels: de microfoon zet geluid om in een elektrisch signaal, de microcontroller bemonstert dat signaal, uit de samples wordt één getal voor het geluidsniveau berekend en dat getal wordt omgezet in het aantal leds dat oplicht. Er zijn twee gangbare manieren om het niveau te berekenen. De peak-to-peak-methode neemt het verschil tussen de grootste en kleinste waarde in een korte tijd; die is simpel en genoeg voor de Uno. De RMS-methode neemt de wortel uit het gemiddelde van de gekwadrateerde samples en geeft de echte energie van het geluid. Omdat het menselijk oor luidheid logaritmisch en niet lineair waarneemt, geeft het omrekenen van de RMS-waarde naar decibel (dB = 20 × log10(RMS)) een veel natuurlijkere beweging van de VU-meter. Dat gebruiken we in de ESP32-versie.

EigenschapUno + KY-038ESP32 + INMP441
Type microfoonAnaloge elektreet, zonder versterkerDigitale MEMS, I2S-uitgang
Resolutie10-bits ADC (stap van 4,9 mV)24-bits data
BemonsteringCa. 8,9 kHz (analogRead ~112 µs)16 kHz, continu met DMA
NiveauberekeningPeak-to-peakRMS + decibel
GevoeligheidLaag, reageert op harde geluiden dichtbijHoog, vangt makkelijk muziek in de kamer op
RuisGevoelig voor ruis op de voedingZeer laag, digitale lijn
MoeilijkheidBeginnerGemiddeld

Benodigde componenten

  • Microcontroller: een Arduino Uno (of Nano) of een ESP32-ontwikkelboard.
  • Microfoon: een KY-038-geluidssensormodule voor de Uno, een INMP441 I2S-microfoonmodule voor de ESP32.
  • Leds: een WS2812B-ring met 24 leds of een WS2812B-strip met 30–60 leds.
  • Weerstand van 330 Ω: in serie met de datalijn van de leds; voorkomt signaalreflecties en schade aan de eerste led.
  • Condensator van 1000 µF / 10 V: over de 5V en GND van de ledvoeding; vlakt plotselinge stroompieken af.
  • Potmeter van 10 kΩ: om de gevoeligheid (volle schaal) in te stellen in de Uno-versie.
  • Voedingsadapter van 5 V 2 A: noodzakelijk als je meer dan 24 leds gebruikt of de helderheid verhoogt.
  • Een breadboard en jumperdraden.
KY-038-geluidssensormodule
KY-038-geluidssensor: de AO-pin geeft het ruwe microfoonsignaal, terwijl de DO-pin een digitaal signaal geeft zodra het niveau de met de trimmer ingestelde drempel overschrijdt.

Bedrading Uno + KY-038

Onderdeel / pinArduino UnoOpmerking
KY-038 +5VVoeding van de module
KY-038 GGNDGemeenschappelijke massa
KY-038 AOA0Analoog geluidssignaal
KY-038 DONiet aangeslotenNiet gebruikt in de VU-meter
Middelste pin van de potmeterA1Buitenste pinnen naar 5V en GND
WS2812B DIND6 (via 330 Ω)Ingang (DI) van de ring
WS2812B 5V5V of externe 5 VCondensator van 1000 µF tussen 5V en GND
WS2812B GNDGNDMoet gemeenschappelijk zijn met de externe voeding
Bij volledig witte helderheid trekken 24 leds ongeveer 24 × 60 mA = 1,44 A, veel meer dan de Uno via USB kan leveren. De code houdt de helderheid op 60/255, maar gebruik je een langere strip, voed de leds dan met een externe 5V-adapter en verbind altijd de GND van de adapter met de GND van de Arduino. Zonder gemeenschappelijke GND tonen de leds willekeurige kleuren. Meer details vind je in het bericht over de WS2812B NeoPixel-led.

Geluidsamplitude meten: de peak-to-peak-methode

De AO-uitgang van de KY-038 is een signaal dat in stilte rond 2,5 V blijft en boven en onder die waarde uitslaat zodra er geluid komt. Op de Uno leest analogRead dit middelpunt als een getal rond 500. Eén meting geeft een willekeurige waarde, afhankelijk van het moment van de golf waarop je meet. Daarom lezen we over een venster van 25 milliseconden en bewaren we de grootste en kleinste waarde. Omdat één analogRead op de Uno ongeveer 112 microseconden duurt, worden in 25 ms zo'n 220 samples genomen; dat is genoeg om minstens een paar volledige golven van bas- en middenfrequenties te vangen. Aan het eind van het venster is maximum min minimum het huidige geluidsniveau. Omdat de KY-038 geen versterker heeft, is dit verschil 2–5 in een stille kamer en 50–200 bij harde muziek in de buurt.

Uno-versie stap voor stap

  1. Open de Library Manager in de Arduino IDE, zoek de bibliotheek Adafruit NeoPixel en installeer die.
  2. Bouw de schakeling volgens de tabel hierboven; verbind het lange pootje (+) van de condensator met 5V.
  3. Upload de onderstaande code en houd de kamer het eerste halve seconde stil: de code meet in die tijd de ruisvloer.
  4. Open de Serial Monitor op 115200 baud en bekijk de waarde van de ruisvloer die wordt geprint; is die hoger dan 10, dan zit er ruis op de voeding.
  5. Speel muziek af en draai aan de potmeter tot je het punt vindt waarop de ring bij het hardste volume bijna helemaal vol is.
  6. Plaats de microfoon 20–50 cm van de luidspreker, uit de buurt van het ledlicht en trillingen van de tafel.
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}
CodeonderdeelDoel
readPeakToPeak()Neemt 25 ms lang samples en geeft het verschil tussen de grootste en kleinste waarde terug
noiseFloorGemiddelde van de 20 metingen bij het opstarten + 2; alles eronder telt als stilte
maxPPVolle schaal, met de potmeter in te stellen van 10–300; kleine waarde = hoge gevoeligheid
levelAfgevlakt niveau dat snel stijgt en langzaam daalt (voorkomt flikkeren)
peakLedWitte piekpunt; blijft 400 ms staan en zakt daarna elke 60 ms één led
vuColor()Maakt een kleurovergang van groen naar geel en van geel naar rood op basis van de positie van de led

Drempel afstellen en ruis filteren

Als je het ruwe geluidsniveau direct op de leds toont, loop je tegen twee problemen aan. Ten eerste knipperen de eerste paar leds zelfs in een stille kamer voortdurend, want de microfoon, draden en USB-voeding geven altijd wat ruis. De oplossing is die ruis te meten en van elke meting af te trekken. Onze code doet bij het opstarten een stiltemeting van een halve seconde en telt een marge van 2 eenheden bij het gemiddelde op. Deze waarde werkt als een drempel: alles eronder telt als nul. Werk je in een rumoerige omgeving, dan kun je deze marge verhogen naar 4–5. De tweede instelling is de volle schaal: die bepaalt welke amplitude de ring helemaal vult. Omdat het muziekvolume per plek verschilt, hebben we die aan de potmeter gekoppeld in plaats van vast in de code te zetten.

Het tweede probleem is flikkeren: vensters van 25 ms zijn zo kort dat het niveau van meting tot meting sterk springt. Dat lossen we op met een exponentieel voortschrijdend gemiddelde (EMA): nieuw niveau = a × doel + (1 − a) × oud niveau. We gebruiken a = 0.6 terwijl het geluid stijgt, zodat de leds drumslagen direct oppikken; met a = 0.15 terwijl het daalt zakken de leds langzaam, als een echte naald. In de audiotechniek heten deze twee attack en release. Omdat de lus ongeveer 26 ms duurt, daalt het niveau met een releasecoëfficiënt van 0.15 in ongeveer 15 lussen, oftewel 0,4 seconde, met 90%. Andere soorten filters vergelijk je in het bericht over sensordata filteren.

De blauwe trimmer op de KY-038 stelt alleen de drempel van de DO-uitgang in; hij maakt het signaal op AO niet groter. Reageert de Uno-versie alleen op harde geluiden dichtbij, verhoog dan de gevoeligheid met de potmeter of stap over op een microfoonmodule met versterker. Alle details over de KY-038 vind je in het bericht over de KY-038-geluidssensor.

ESP32 + INMP441-versie: schone meting met een digitale microfoon

De INMP441 is een MEMS-microfoon die geluid intern met 24-bits resolutie omzet naar digitaal en de data via het I2S-protocol verstuurt. Omdat er geen analoge draad is, komt ruis van de voeding niet in de meting terecht, en de signaal-ruisverhouding is ongeveer 61 dB. De ESP32 verzamelt I2S-data op de achtergrond met DMA zonder de processor te belasten; wij nemen blokken van 512 samples en berekenen de RMS-waarde. Bij 16 kHz bemonstering duurt een blok 32 ms, dus de VU-meter wordt ongeveer 30 keer per seconde bijgewerkt. Hoe de microfoon precies werkt, lees je in het bericht over de INMP441 I2S-microfoon.

Onderdeel / pinESP32Opmerking
INMP441 VDD3V3Geef hem geen 5 V, de microfoon is een onderdeel van 3,3 V
INMP441 GNDGNDGemeenschappelijke massa
INMP441 L/RGNDKiest het linkerkanaal
INMP441 WSGPIO 25Word select (LRCLK)
INMP441 SCKGPIO 32Bitklok (BCLK)
INMP441 SDGPIO 33Audiodata
WS2812B DINGPIO 18 (via 330 Ω)Signaal van 3,3 V werkt op een korte draad
WS2812B 5VVIN (USB 5 V) of externe 5 VVoeg een condensator van 1000 µF toe
WS2812B GNDGNDGemeenschappelijk met de externe voeding
Laat de L/R-pin van de INMP441 niet zweven; zweeft hij, dan kan de microfoon geen kanaal kiezen en lees je steeds nul of betekenisloze data. Bovendien kan het 3,3V-datasignaal van de ESP32 bij sommige strips grensgeval zijn als de WS2812B op 5 V draait. Flikkert de eerste led of toont hij de verkeerde kleur, kort dan de datadraad in of gebruik een niveauconverter.
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}

De code kiest automatisch de nieuwe ESP_I2S-bibliotheek als je ESP32 Arduino core 3.x gebruikt, of de oude driver/i2s.h-driver bij 2.x. De INMP441 plaatst elke sample in de bovenste 24 bits van een frame van 32 bits; 8 bits naar rechts schuiven geeft de echte waarde. Daarna wordt het gemiddelde afgetrokken om de kleine DC-offset van de microfoon te verwijderen en wordt de RMS berekend. Op de decibelschaal betekent elke 6 dB een verdubbeling van de amplitude. Met RANGE_DB = 35 is de ring helemaal vol bij 35 dB boven de ruisvloer. Luister je naar zachte muziek in een stille kamer, verlaag deze waarde dan naar 25; op een rumoerig feest verhoog je hem naar 45.

Wil je een Raspberry Pi Pico gebruiken: de klasse machine.I2S in MicroPython wordt ook op de RP2040 ondersteund; je kunt dezelfde INMP441 aansluiten via de pinnen SCK, WS en SD en de RMS-logica naar Python overzetten. MicroPython heeft ook een ingebouwde neopixel-module voor de WS2812B. Voor een eerste stap met de Pico is het bericht Wat is de Raspberry Pi Pico een goed begin.

Het effect uitbreiden: projectideeën

  • VU-meter vanuit het midden: maak een symmetrisch effect dat start bij led 0 en led 12 van de ring en in beide richtingen vult.
  • Stereo-VU-meter: verbind de L/R-pin van de ene INMP441 met GND en die van de andere met 3V3, en toon het linker- en rechterkanaal op twee aparte strips.
  • Ledmatrix-spectrum: splits het geluid met een FFT op de ESP32 in frequentiebanden en teken equalizerbalken op een WS2812B-ledmatrix.
  • Muzieklamp voor in de kamer: wil je een kant-en-klare interface, maak van de ESP32 dan een geluidsgestuurde stripcontroller met de WLED-installatie.
  • Waarschuwing bij geluidsniveau: maak een geluidsmeter voor een klaslokaal of bibliotheek die de ring rood laat worden en een buzzer laat klinken als het geluid een bepaald aantal dB overschrijdt.
  • Kerstversiering: combineer het met het project kerstboom met leds voor een boom die met de muziek van kleur verandert.

Veelgemaakte fouten en oplossingen

SymptoomWaarschijnlijke oorzaakOplossing
Leds flikkeren in stilteRuisvloer te laag gemetenHoud de kamer bij het opstarten stil, verhoog de drempelmarge van 2 naar 4–5
Helemaal geen reactie op muziek (Uno)Signaal van de KY-038 te zwakVerlaag maxPP met de potmeter, zet de microfoon dichter bij de luidspreker
Ring is altijd volVolle schaal te kleinDraai de potmeter om maxPP te verhogen, of verhoog RANGE_DB
INMP441 leest altijd nulL/R zweeft of kanaal omgedraaidVerbind L/R met GND; helpt dat niet, verbind hem dan met 3V3 en kies het juiste kanaal in de code
Eerste led toont verkeerde kleurZwak datasignaal of geen weerstandVoeg een serieweerstand van 330 Ω toe, kort de datadraad in
Board reset bij een basslagLedstroom laat de voeding instortenVerlaag de helderheid, gebruik een externe 5V-adapter en een condensator van 1000 µF
Leds sturen de microfoon aanRimpel van de voeding lekt naar de analoge lijnVerbind de microfoon met een aparte draad met 5V, voeg de GND's op één punt samen
De Serial Plotter is erg handig bij het afstellen: voeg Serial.println(pp) toe aan de lus (of Serial.println(db) op de ESP32) en bekijk de grafiek terwijl er muziek speelt. De lijn in stilte toont de ruisvloer en de piek op het luidste moment van het nummer laat precies zien wat je als volle schaal moet instellen.

Een muziekgestuurd led-project combineert het meten van een analoog signaal, filteren en het aansturen van adresseerbare leds in één leuke schakeling. Je kunt in een paar minuten beginnen met de Uno en KY-038 en daarna doorgroeien naar een professioneel ogend geluidsdisplay met de ESP32 en INMP441. In de BlueGrays-app kun je naast WS2812B-looplicht-, Knight Rider-, politiestroboscoop- en animatieprojecten ook de aansturing van een ESP32 NeoPixel-strip stap voor stap volgen, met schakelschema's en kant-en-klare code.

Veelgestelde vragen

Welke geluidssensor is beter voor muziekgestuurde leds?

De KY-038 werkt voor beginners en een klein budget, maar zonder versterker reageert hij alleen goed op harde geluiden dichtbij. Voor een gevoeliger resultaat met weinig ruis gebruik je een digitale I2S-microfoon zoals de INMP441 met een ESP32, of een analoge microfoonmodule met versterker.

Waarom reageert mijn KY-038-geluidssensor niet op muziek?

Het signaal op de AO-uitgang van de KY-038 slaat meestal maar een paar ADC-eenheden uit en de trimmer versterkt het niet, hij verandert alleen de DO-drempel. Zet de microfoon dichter bij de luidspreker, verlaag de volle schaal in de code en zorg dat je peak-to-peak meet in plaats van één enkele meting.

Hoe laat ik WS2812B-leds met Arduino op muziek branden?

Je neemt samples van de microfoon over een kort tijdvenster, berekent het geluidsniveau en zet dat met een map-achtige verhouding om in een aantal leds. Daarna laat je zoveel leds branden met de Adafruit NeoPixel-bibliotheek en werk je bij met strip.show(); een afvlakfilter houdt het effect vloeiend en zonder flikkeren.

Werkt de INMP441-microfoon met een Arduino Uno?

Nee, de Arduino Uno heeft geen I2S-hardware en kan dus geen data van de INMP441 lezen. Je hebt een board met I2S-ondersteuning nodig, zoals de ESP32, ESP32-S3 of Raspberry Pi Pico; voor de Uno zijn microfoonmodules met een analoge uitgang geschikt.

Hoeveel stroom trekt een WS2812B-ring met 24 leds?

Elke led trekt bij volledig wit ongeveer 60 mA, dus 24 leds trekken in het slechtste geval 1,44 A. In een VU-meter-effect branden zelden alle leds op volle helderheid, dus het echte verbruik is veel lager; toch is de helderheid beperken en een externe 5V-voeding gebruiken de veiligste manier.

Kunnen muziekgestuurde leds per frequentie van kleur veranderen?

Ja, daarvoor moet je het geluid met een FFT splitsen in frequentiebanden zoals bas, midden en hoog. De ESP32 heeft genoeg rekenkracht en geheugen voor een realtime FFT; op de Uno kun je alleen een beperkte analyse met lage resolutie doen.

Alle projecten bekijken
ESP32 WS2812B NeoPixel-strip aansturen
ES-24Gemiddeld
Premium

ESP32 WS2812B NeoPixel-strip aansturen

WS2812B-leds (NeoPixel) zijn adresseerbare slimme RGB-leds die je kunt doorlussen en via één datapin kunt aansturen. In dit project sturen we een WS2812B-strip met 8 leds aan met de Adafruit_NeoPixel-bibliotheek en maken we een vloeiende regenbooganimatie. De 3,3V-logica van de ESP32 werkt met de meeste WS2812B-batches; wordt het instabiel, dan laten we de oplossing zien met een serieweerstand van 470Ω en een condensator van 1000µF. De animatie schuift de tint op in de HSV-kleurruimte.

4.9(19)
30
Een WS2812B-ledstrip gebruiken
AR-69Gemiddeld
Premium

Een WS2812B-ledstrip gebruiken

Maak kennis met een slimme ledstrip waarvan je elk lampje apart kunt kleuren. De Arduino laat eerst de eerste vijf leds rood branden, zet een seconde later de andere vijf blauw, schakelt dan alles…

4.8(54)
70
Politieknipperlicht met WS2812B
AR-70Gemiddeld
Premium

Politieknipperlicht met WS2812B

Je haalt de rode en blauwe lichten van het dak van een politieauto naar je bureau.

4.8(67)
86
WS2812B-looplicht
AR-71Gemiddeld
Premium

WS2812B-looplicht

Op een strip van tien leds loopt een groen lichtpuntje led voor led van begin naar eind en springt dan terug naar het begin; het blijft een derde seconde op elke led.

4.8(58)
75
WS2812B-looplicht (opbouweffect)
AR-72Gemiddeld
Premium

WS2812B-looplicht (opbouweffect)

Een lichtstrip die zich vult en leegt als een glas water. De Arduino laat tien kleurenleds een voor een oranje branden en houdt ze aan; als de strip vol is, schakelt hij ze in dezelfde volgorde een…

4.7(50)
65
WS2812B Knight Rider-effect
AR-73Gemiddeld
Premium

WS2812B Knight Rider-effect

Een rood lichtpuntje glijdt van het ene uiteinde van een slimme ledstrip naar het andere en komt dan terug, heen en weer zonder ooit te stoppen.

4.9(73)
94
WS2812B-animatie 1
AR-75Gemiddeld
Premium

WS2812B-animatie 1

Op een strip van 56 leds staan alle kleuren van de regenboog naast elkaar en stromen ze zonder ophouden door, alsof er een rivier van licht over de strip glijdt.

4.9(69)
89
WS2812B-animatie 2
AR-76Gemiddeld
Premium

WS2812B-animatie 2

Zet in je kamer een lichtshow op die helemaal zelf van kleur verandert. De Arduino laat kleuren over een strip van 30 leds stromen en schakelt om de paar seconden over op een nieuwe kleurenset…

4.8(65)
84