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.

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.
| Eigenschap | Uno + KY-038 | ESP32 + INMP441 |
|---|---|---|
| Type microfoon | Analoge elektreet, zonder versterker | Digitale MEMS, I2S-uitgang |
| Resolutie | 10-bits ADC (stap van 4,9 mV) | 24-bits data |
| Bemonstering | Ca. 8,9 kHz (analogRead ~112 µs) | 16 kHz, continu met DMA |
| Niveauberekening | Peak-to-peak | RMS + decibel |
| Gevoeligheid | Laag, reageert op harde geluiden dichtbij | Hoog, vangt makkelijk muziek in de kamer op |
| Ruis | Gevoelig voor ruis op de voeding | Zeer laag, digitale lijn |
| Moeilijkheid | Beginner | Gemiddeld |
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.

Bedrading Uno + KY-038
| Onderdeel / pin | Arduino Uno | Opmerking |
|---|---|---|
| KY-038 + | 5V | Voeding van de module |
| KY-038 G | GND | Gemeenschappelijke massa |
| KY-038 AO | A0 | Analoog geluidssignaal |
| KY-038 DO | Niet aangesloten | Niet gebruikt in de VU-meter |
| Middelste pin van de potmeter | A1 | Buitenste pinnen naar 5V en GND |
| WS2812B DIN | D6 (via 330 Ω) | Ingang (DI) van de ring |
| WS2812B 5V | 5V of externe 5 V | Condensator van 1000 µF tussen 5V en GND |
| WS2812B GND | GND | Moet gemeenschappelijk zijn met de externe voeding |
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
- Open de Library Manager in de Arduino IDE, zoek de bibliotheek Adafruit NeoPixel en installeer die.
- Bouw de schakeling volgens de tabel hierboven; verbind het lange pootje (+) van de condensator met 5V.
- Upload de onderstaande code en houd de kamer het eerste halve seconde stil: de code meet in die tijd de ruisvloer.
- 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.
- Speel muziek af en draai aan de potmeter tot je het punt vindt waarop de ring bij het hardste volume bijna helemaal vol is.
- Plaats de microfoon 20–50 cm van de luidspreker, uit de buurt van het ledlicht en trillingen van de tafel.
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}| Codeonderdeel | Doel |
|---|---|
| readPeakToPeak() | Neemt 25 ms lang samples en geeft het verschil tussen de grootste en kleinste waarde terug |
| noiseFloor | Gemiddelde van de 20 metingen bij het opstarten + 2; alles eronder telt als stilte |
| maxPP | Volle schaal, met de potmeter in te stellen van 10–300; kleine waarde = hoge gevoeligheid |
| level | Afgevlakt niveau dat snel stijgt en langzaam daalt (voorkomt flikkeren) |
| peakLed | Witte 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.
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 / pin | ESP32 | Opmerking |
|---|---|---|
| INMP441 VDD | 3V3 | Geef hem geen 5 V, de microfoon is een onderdeel van 3,3 V |
| INMP441 GND | GND | Gemeenschappelijke massa |
| INMP441 L/R | GND | Kiest het linkerkanaal |
| INMP441 WS | GPIO 25 | Word select (LRCLK) |
| INMP441 SCK | GPIO 32 | Bitklok (BCLK) |
| INMP441 SD | GPIO 33 | Audiodata |
| WS2812B DIN | GPIO 18 (via 330 Ω) | Signaal van 3,3 V werkt op een korte draad |
| WS2812B 5V | VIN (USB 5 V) of externe 5 V | Voeg een condensator van 1000 µF toe |
| WS2812B GND | GND | Gemeenschappelijk met de externe voeding |
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
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Leds flikkeren in stilte | Ruisvloer te laag gemeten | Houd 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 zwak | Verlaag maxPP met de potmeter, zet de microfoon dichter bij de luidspreker |
| Ring is altijd vol | Volle schaal te klein | Draai de potmeter om maxPP te verhogen, of verhoog RANGE_DB |
| INMP441 leest altijd nul | L/R zweeft of kanaal omgedraaid | Verbind L/R met GND; helpt dat niet, verbind hem dan met 3V3 en kies het juiste kanaal in de code |
| Eerste led toont verkeerde kleur | Zwak datasignaal of geen weerstand | Voeg een serieweerstand van 330 Ω toe, kort de datadraad in |
| Board reset bij een basslag | Ledstroom laat de voeding instorten | Verlaag de helderheid, gebruik een externe 5V-adapter en een condensator van 1000 µF |
| Leds sturen de microfoon aan | Rimpel van de voeding lekt naar de analoge lijn | Verbind de microfoon met een aparte draad met 5V, voeg de GND's op één punt samen |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

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…

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

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.

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…

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.

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.

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…
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

