Musikgesteuerte LED mit Arduino: VU-Meter mit WS2812B bauen
Musikgesteuerte LED mit Arduino: VU-Meter auf WS2812B-Ring mit Uno + KY-038 und ESP32 + INMP441. Verkabelung, fertiger Code, Schwellenwert und Rauschfilter.
Ein musikgesteuertes LED-Projekt mit Arduino hört per Mikrofon den Umgebungsschall ab und lässt umso mehr LEDs leuchten, je lauter es ist. Es ahmt das VU-Meter alter Stereoanlagen nach. In dieser Anleitung baust du mit einem WS2812B-Ring mit 24 LEDs (der gleiche Code läuft auch auf einem Streifen) zwei Versionen: eine günstige, schnelle Variante mit Arduino Uno und KY-038-Soundsensor sowie eine Variante mit ESP32 und dem digitalen I2S-Mikrofon INMP441, die viel sauberer misst.
Der eigentliche Kniff liegt nicht im Leuchtenlassen der LEDs, sondern darin, den Schall richtig zu messen. Das Mikrofonsignal ist eine Welle, die tausendfach pro Sekunde ihre Richtung wechselt; ein einzelner analogRead-Wert sagt dir nichts. Deshalb lernst du Schritt für Schritt, die Amplitude über ein Zeitfenster zu messen, den Rauschpegel in ruhiger Umgebung automatisch zu bestimmen, die Empfindlichkeit per Potentiometer einzustellen und das Flackern mit einem Glättungsfilter zu beseitigen.

Wie funktioniert eine musikgesteuerte LED?
Die Kette besteht aus vier Gliedern: Das Mikrofon wandelt Schall in ein elektrisches Signal, der Mikrocontroller tastet es ab, aus den Samples wird ein einzelner Lautstärkewert berechnet, und dieser wird in die Anzahl der leuchtenden LEDs umgerechnet. Für den Pegel gibt es zwei gängige Wege. Bei der Spitze-Spitze-Methode (Peak-to-Peak) bildest du die Differenz zwischen größtem und kleinstem Wert in einem kurzen Zeitraum; das ist einfach und für den Uno ausreichend. Beim RMS-Verfahren ziehst du die Wurzel aus dem Mittelwert der quadrierten Samples und erhältst die tatsächliche Energie des Schalls. Weil das menschliche Ohr Lautstärke logarithmisch wahrnimmt, wirkt das VU-Meter viel natürlicher, wenn du den RMS-Wert in Dezibel umrechnest (dB = 20 × log10(RMS)). Das nutzen wir in der ESP32-Version.
| Merkmal | Uno + KY-038 | ESP32 + INMP441 |
|---|---|---|
| Mikrofontyp | Analoges Elektret, ohne Verstärker | Digitales MEMS, I2S-Ausgang |
| Auflösung | 10-Bit-ADC (4,9 mV pro Schritt) | 24 Bit Daten |
| Abtastung | Ca. 8,9 kHz (analogRead ~112 µs) | 16 kHz, lückenlos per DMA |
| Pegelberechnung | Spitze-Spitze | RMS + Dezibel |
| Empfindlichkeit | Gering, reagiert auf laute, nahe Geräusche | Hoch, erfasst Zimmermusik problemlos |
| Rauschen | Anfällig für Versorgungsrauschen | Sehr gering, digitale Leitung |
| Schwierigkeit | Einsteiger | Mittel |
Benötigte Bauteile
- Mikrocontroller: Arduino Uno (oder Nano) oder ESP32-Entwicklungsboard.
- Mikrofon: KY-038-Soundsensormodul für den Uno, INMP441-I2S-Mikrofonmodul für den ESP32.
- LEDs: WS2812B-Ring mit 24 LEDs oder WS2812B-Streifen mit 30–60 LEDs.
- 330-Ω-Widerstand: In Reihe zur LED-Datenleitung, verhindert Signalreflexionen und schützt die erste LED.
- 1000 µF / 10 V Kondensator: Zwischen 5V und GND der LED-Versorgung, glättet plötzliche Stromspitzen.
- 10-kΩ-Potentiometer: Für die Empfindlichkeitseinstellung (Vollausschlag) in der Uno-Version.
- 5-V-2-A-Netzteil: Pflicht, wenn du mehr als 24 LEDs nutzt oder die Helligkeit erhöhst.
- Breadboard und Jumperkabel.

Verkabelung Uno + KY-038
| Bauteil / Pin | Arduino Uno | Hinweis |
|---|---|---|
| KY-038 + | 5V | Versorgung des Moduls |
| KY-038 G | GND | Gemeinsame Masse |
| KY-038 AO | A0 | Analoges Audiosignal |
| KY-038 DO | Frei | Wird im VU-Meter nicht benutzt |
| Mittelanschluss Potentiometer | A1 | Außenanschlüsse an 5V und GND |
| WS2812B DIN | D6 (über 330 Ω) | Eingangsseite (DI) des Rings |
| WS2812B 5V | 5V oder externe 5 V | 1000-µF-Kondensator zwischen 5V und GND |
| WS2812B GND | GND | Muss mit der externen Quelle verbunden sein |
Die Amplitude messen: die Spitze-Spitze-Methode
Der AO-Ausgang des KY-038 liegt in Stille bei etwa 2,5 V und schwingt bei Schall über und unter diesen Wert. Am Uno liest analogRead diesen Mittelpunkt als Zahl um 500. Ein einzelner Messwert ist zufällig, je nachdem, an welcher Stelle der Welle er liegt. Deshalb lesen wir 25 Millisekunden lang und merken uns den größten und den kleinsten Wert. Da ein analogRead am Uno etwa 112 Mikrosekunden dauert, entstehen in 25 ms rund 220 Samples; das reicht, um von Bass und Mitten mindestens einige komplette Wellen zu erfassen. Am Ende des Fensters ist Maximum minus Minimum der aktuelle Lautstärkepegel. Weil der KY-038 keinen Verstärker hat, beträgt diese Differenz in einem stillen Raum 2–5, bei laut spielender Musik in der Nähe 50–200.
Schritt für Schritt: die Uno-Version
- Öffne in der Arduino IDE den Bibliotheksverwalter, suche die Bibliothek Adafruit NeoPixel und installiere sie.
- Baue die Schaltung nach der Tabelle oben auf; verbinde das lange Bein (+) des Kondensators mit 5V.
- Lade den folgenden Code hoch und halte die Umgebung in der ersten halben Sekunde still: In dieser Zeit misst der Code den Rauschpegel.
- Öffne den Serial Monitor mit 115200 Baud und sieh dir den ausgegebenen Rauschpegel an; liegt er über 10, gibt es Versorgungsrauschen.
- Spiele Musik ab und drehe am Potentiometer, bis der Ring bei höchster Lautstärke fast ganz gefüllt ist.
- Platziere das Mikrofon 20–50 cm vom Lautsprecher entfernt, weg vom LED-Licht und von Tischvibrationen.
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}| Codeabschnitt | Aufgabe |
|---|---|
| readPeakToPeak() | Nimmt 25 ms lang Samples auf und gibt die Differenz zwischen größtem und kleinstem Wert zurück |
| noiseFloor | Mittelwert der 20 Messungen beim Start + 2; alles darunter gilt als Stille |
| maxPP | Per Potentiometer zwischen 10 und 300 einstellbarer Vollausschlag; kleiner Wert = hohe Empfindlichkeit |
| level | Schnell steigender, langsam fallender geglätteter Pegel (verhindert Flackern) |
| peakLed | Weißer Spitzenpunkt; wartet 400 ms und sinkt dann alle 60 ms um eine LED |
| vuColor() | Erzeugt je nach LED-Position einen Verlauf von Grün über Gelb zu Rot |
Schwellenwert einstellen und Rauschen filtern
Wenn du den rohen Pegel direkt auf die LEDs gibst, bekommst du zwei Probleme. Erstens flackern selbst in einer ruhigen Umgebung ständig die ersten LEDs, weil Mikrofon, Kabel und USB-Versorgung immer etwas Rauschen erzeugen. Die Lösung: dieses Rauschen messen und von jeder Messung abziehen. Unser Code misst beim Start eine halbe Sekunde Stille und addiert zum Mittelwert eine Reserve von 2 Einheiten. Dieser Wert wirkt wie ein Schwellenwert: Alles darunter gilt als null. Arbeitest du in einer lauten Umgebung, kannst du die Reserve auf 4–5 erhöhen. Die zweite Einstellung ist der Vollausschlag: Er legt fest, bei welcher Amplitude der Ring ganz gefüllt ist. Da sich die Musiklautstärke von Raum zu Raum unterscheidet, haben wir ihn nicht fest im Code verankert, sondern an das Potentiometer gelegt.
Das zweite Problem ist das Flackern: Die 25-ms-Fenster sind so kurz, dass der Pegel von Messung zu Messung hart springt. Das lösen wir mit einem exponentiellen gleitenden Mittelwert (EMA): neuer Pegel = a × Ziel + (1 − a) × alter Pegel. Steigt der Schall, nutzen wir a = 0,6, sodass die LEDs Schlagzeugschläge sofort erfassen; fällt er, ist a = 0,15, sodass die LEDs wie bei einem echten Zeiger langsam sinken. In der Audiotechnik heißt das Attack und Release. Da eine Schleife etwa 26 ms dauert, sinkt der Pegel bei einem Release-Koeffizienten von 0,15 in ungefähr 15 Durchläufen, also 0,4 Sekunden, um 90 %. Weitere Filtertypen vergleichst du im Beitrag Sensordaten filtern.
ESP32 + INMP441: sauber messen mit digitalem Mikrofon
Der INMP441 ist ein MEMS-Mikrofon, das den Schall intern mit 24 Bit Auflösung digitalisiert und die Daten über das I2S-Protokoll sendet. Da es keine analoge Leitung gibt, mischt sich kein Versorgungsrauschen in die Messung, und der Signal-Rausch-Abstand beträgt etwa 61 dB. Der ESP32 sammelt die I2S-Daten per DMA im Hintergrund, ohne den Prozessor zu belasten; wir holen Blöcke zu 512 Samples und berechnen den RMS-Wert. Bei 16 kHz Abtastrate dauert ein Block 32 ms, das VU-Meter wird also etwa 30-mal pro Sekunde aktualisiert. Wie das Mikrofon funktioniert, erfährst du ausführlich im Beitrag INMP441 I2S-Mikrofon.
| Bauteil / Pin | ESP32 | Hinweis |
|---|---|---|
| INMP441 VDD | 3V3 | Keine 5 V anlegen, das Mikrofon arbeitet mit 3,3 V |
| INMP441 GND | GND | Gemeinsame Masse |
| INMP441 L/R | GND | Linker Kanal wird gewählt |
| INMP441 WS | GPIO 25 | Wortauswahl (LRCLK) |
| INMP441 SCK | GPIO 32 | Bit-Takt (BCLK) |
| INMP441 SD | GPIO 33 | Audiodaten |
| WS2812B DIN | GPIO 18 (über 330 Ω) | 3,3-V-Signal funktioniert bei kurzem Kabel |
| WS2812B 5V | VIN (USB 5 V) oder externe 5 V | 1000-µF-Kondensator ergänzen |
| WS2812B GND | GND | Gemeinsam mit der externen Quelle |
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}Der Code wählt automatisch die neue ESP_I2S-Bibliothek, wenn du den ESP32-Arduino-Core 3.x nutzt, und den alten Treiber driver/i2s.h beim Core 2.x. Der INMP441 legt jedes Sample in die oberen 24 Bit eines 32-Bit-Frames; eine Verschiebung um 8 Bit nach rechts liefert den echten Wert. Anschließend wird der Mittelwert abgezogen, um den kleinen DC-Versatz des Mikrofons zu entfernen, und der RMS-Wert berechnet. Auf der Dezibel-Skala bedeutet jede Zunahme um 6 dB eine Verdopplung der Amplitude. Mit RANGE_DB = 35 ist der Ring 35 dB über dem Rauschpegel ganz gefüllt. Hörst du in einem ruhigen Raum leise Musik, senke den Wert auf 25; auf einer lauten Party erhöhe ihn auf 45.
Möchtest du einen Raspberry Pi Pico verwenden: Die Klasse machine.I2S in MicroPython wird auch auf dem RP2040 unterstützt; du schließt dasselbe INMP441 an SCK, WS und SD an und überträgst die RMS-Logik nach Python. Für die WS2812B gibt es in MicroPython das eingebaute Modul neopixel. Für den Einstieg mit dem Pico ist der Beitrag Was ist der Raspberry Pi Pico? ein guter Start.
Den Effekt ausbauen: Projektideen
- VU-Meter von der Mitte aus: Starte bei LED 0 und LED 12 des Rings und fülle ihn symmetrisch in beide Richtungen.
- Stereo-VU-Meter: Lege bei einem von zwei INMP441 den L/R-Pin auf GND und beim anderen auf 3V3 und zeige den linken und rechten Kanal auf zwei getrennten Streifen an.
- LED-Matrix-Spektrum: Zerlege den Schall auf dem ESP32 per FFT in Frequenzbänder und zeichne Equalizer-Balken auf einer WS2812B-LED-Matrix.
- Musiklicht fürs Zimmer: Wenn du eine fertige Oberfläche möchtest, mache den ESP32 mit der WLED-Installation zu einem soundreaktiven Streifen-Controller.
- Lautstärkewarnung: Baue für Klassenzimmer oder Bibliothek einen Lärmmesser, der den Ring rot leuchten lässt und einen Buzzer piepen lässt, sobald ein bestimmter dB-Wert überschritten wird.
- Weihnachtsdeko: Kombiniere das Projekt mit dem LED-Weihnachtsbaum für einen Baum, der die Farben zur Musik wechselt.
Häufige Fehler und Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| LEDs flackern bei Stille | Rauschpegel zu niedrig gemessen | Beim Start Ruhe halten, Schwellenreserve von 2 auf 4–5 erhöhen |
| Keine Reaktion auf Musik (Uno) | KY-038-Signal zu schwach | maxPP per Poti senken, Mikrofon näher an den Lautsprecher bringen |
| Ring ist dauerhaft voll | Vollausschlag zu klein | Per Poti maxPP bzw. RANGE_DB erhöhen |
| INMP441 liest immer null | L/R offen oder Kanal vertauscht | L/R an GND legen; hilft das nicht, an 3V3 legen und im Code den rechten Kanal wählen |
| Erste LED zeigt falsche Farbe | Datensignal schwach oder Widerstand fehlt | 330-Ω-Vorwiderstand ergänzen, Datenkabel kürzen |
| Board startet bei Bassschlägen neu | LED-Strom lässt die Versorgung einbrechen | Helligkeit senken, externes 5-V-Netzteil und 1000-µF-Kondensator verwenden |
| LEDs triggern das Mikrofon | Versorgungsschwankungen gelangen in die analoge Leitung | Mikrofon mit separatem Kabel an 5V anschließen, GNDs an einem Punkt verbinden |
Das musikgesteuerte LED-Projekt vereint analoge Signalmessung, Filterung und die Steuerung adressierbarer LEDs in einer unterhaltsamen Schaltung. Mit Uno und KY-038 legst du in wenigen Minuten los, und mit ESP32 und INMP441 steigst du auf eine professionelle Pegelanzeige um. In der BlueGrays-App findest du neben Lauflicht, Knight Rider, Polizeiblinker und Animationsprojekten mit WS2812B auch die NeoPixel-Streifensteuerung mit dem ESP32 Schritt für Schritt mit Schaltplan und fertigem Code.
Häufige Fragen
Welcher Soundsensor ist für musikgesteuerte LEDs besser?
Für Einsteiger und ein kleines Budget reicht der KY-038, er reagiert mangels Verstärker aber nur auf laute Geräusche in der Nähe. Für empfindlichere und rauschärmere Ergebnisse brauchst du ein digitales I2S-Mikrofon wie den INMP441 am ESP32 oder ein analoges Mikrofonmodul mit Verstärker.
Warum reagiert mein KY-038 Soundsensor nicht auf Musik?
Das Signal am AO-Ausgang des KY-038 schwingt meist nur um wenige ADC-Einheiten, und der Trimmer verstärkt es nicht, sondern ändert nur den DO-Schwellenwert. Halte das Mikrofon näher an den Lautsprecher, senke im Code den Vollausschlag und miss per Spitze-Spitze statt mit einem einzelnen Messwert.
Wie lasse ich WS2812B-LEDs mit Arduino zur Musik leuchten?
Du nimmst in einem kurzen Zeitfenster Samples vom Mikrofon, berechnest den Lautstärkepegel und rechnest ihn mit einer map-ähnlichen Skalierung in die LED-Anzahl um. Dann schaltest du mit der Adafruit-NeoPixel-Bibliothek so viele LEDs ein und aktualisierst mit strip.show(); ein Glättungsfilter sorgt dafür, dass der Effekt ohne Flackern fließt.
Funktioniert das INMP441-Mikrofon mit dem Arduino Uno?
Nein, der Arduino Uno hat keine I2S-Hardware und kann keine Daten vom INMP441 lesen. Du brauchst Boards mit I2S-Unterstützung wie ESP32, ESP32-S3 oder Raspberry Pi Pico; für den Uno eignen sich Mikrofonmodule mit analogem Ausgang.
Wie viel Strom zieht ein WS2812B-Ring mit 24 LEDs?
Jede LED zieht bei vollem Weiß etwa 60 mA, 24 LEDs ziehen im ungünstigsten Fall also 1,44 A. Beim VU-Meter leuchten selten alle LEDs mit voller Helligkeit, der echte Verbrauch ist deutlich geringer; am sichersten ist es trotzdem, die Helligkeit zu begrenzen und ein externes 5-V-Netzteil zu nutzen.
Kann ich bei musikgesteuerten LEDs die Farbe nach Frequenz wechseln?
Ja, dafür musst du den Schall per FFT in Frequenzbänder wie Bass, Mitten und Höhen zerlegen. Rechenleistung und Speicher des ESP32 reichen für eine FFT in Echtzeit; am Uno ist nur eine grobe, begrenzte Analyse möglich.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Steuerung des ESP32 WS2812B NeoPixel-Streifens
WS2812B-LEDs (NeoPixel) sind adressierbare RGB-LEDs, die sich in Reihe über einen einzigen Datenpin steuern lassen. Wir steuern einen WS2812B-Streifen mit 8 LEDs über die Bibliothek Adafruit_NeoPixel und erzeugen eine flüssige Regenbogenanimation. Die 3,3-V-Logik des ESP32 klappt bei den meisten WS2812B; bei Instabilität hilft ein 470Ω-Serienwiderstand plus 1000µF-Kondensator. Die Animation verschiebt den Farbton im HSV-Farbraum.

WS2812B-LED-Streifen verwenden
Du lernst einen smarten LED-Streifen kennen, bei dem du jedes einzelne Licht für sich einfärben kannst.

Polizeilicht mit WS2812B
Du holst dir das rot-blaue Blaulicht vom Dach eines Polizeiautos auf den Schreibtisch.

WS2812B-Lauflicht
Auf einem Streifen mit zehn LEDs wandert ein grüner Lichtpunkt Schritt für Schritt vom Anfang bis zum Ende und springt dann wieder an den Start; auf jeder LED bleibt er eine Drittelsekunde.

WS2812B-Lauflicht (auffüllend)
Ein Lichtstreifen, der sich füllt und leert wie ein Glas Wasser. Der Arduino schaltet zehn Farb-LEDs nacheinander in Orange ein und lässt sie an; ist der Streifen voll, schaltet er sie in derselben…

WS2812B Knight-Rider-Lauflicht
Auf einem smarten LED-Streifen gleitet ein roter Lichtpunkt von einem Ende zum anderen und wieder zurück, ein Hin und Her ohne Pause.

WS2812B Animation 1
Auf einem Streifen mit 56 LEDs reihen sich alle Farben des Regenbogens aneinander und fließen ohne Pause weiter, als würde ein Fluss aus Licht über den Streifen gleiten.

WS2812B Animation 2
Bau dir eine Lichtshow fürs Zimmer, die von selbst die Farben wechselt. Der Arduino lässt die Farben ständig über einen Streifen mit 30 LEDs fließen und wechselt alle paar Sekunden zu einem neuen…
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

