Ratgeber · 8 Min. Lesezeit

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.

WS2812B NeoPixel RGB-LED-Ring mit 24 LEDs
WS2812B-Ring mit 24 LEDs: Über eine einzige Datenleitung wird jede LED einzeln gesteuert, ideal für ein VU-Meter.

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.

MerkmalUno + KY-038ESP32 + INMP441
MikrofontypAnaloges Elektret, ohne VerstärkerDigitales MEMS, I2S-Ausgang
Auflösung10-Bit-ADC (4,9 mV pro Schritt)24 Bit Daten
AbtastungCa. 8,9 kHz (analogRead ~112 µs)16 kHz, lückenlos per DMA
PegelberechnungSpitze-SpitzeRMS + Dezibel
EmpfindlichkeitGering, reagiert auf laute, nahe GeräuscheHoch, erfasst Zimmermusik problemlos
RauschenAnfällig für VersorgungsrauschenSehr gering, digitale Leitung
SchwierigkeitEinsteigerMittel

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.
KY-038-Soundsensormodul
KY-038-Soundsensor: Der AO-Pin liefert das rohe Mikrofonsignal, der DO-Pin gibt ein Digitalsignal aus, sobald der per Trimmer eingestellte Schwellenwert überschritten wird.

Verkabelung Uno + KY-038

Bauteil / PinArduino UnoHinweis
KY-038 +5VVersorgung des Moduls
KY-038 GGNDGemeinsame Masse
KY-038 AOA0Analoges Audiosignal
KY-038 DOFreiWird im VU-Meter nicht benutzt
Mittelanschluss PotentiometerA1Außenanschlüsse an 5V und GND
WS2812B DIND6 (über 330 Ω)Eingangsseite (DI) des Rings
WS2812B 5V5V oder externe 5 V1000-µF-Kondensator zwischen 5V und GND
WS2812B GNDGNDMuss mit der externen Quelle verbunden sein
24 LEDs ziehen bei voller weißer Helligkeit etwa 24 × 60 mA = 1,44 A; das liegt weit über dem, was der Uno über USB liefern kann. Im Code halten wir die Helligkeit bei 60/255. Trotzdem solltest du bei längeren Streifen die LEDs aus einem externen 5-V-Netzteil speisen und dessen GND unbedingt mit dem Arduino-GND verbinden. Ohne gemeinsame Masse zeigen die LEDs zufällige Farben. Details findest du im Beitrag WS2812B NeoPixel LED.

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

  1. Öffne in der Arduino IDE den Bibliotheksverwalter, suche die Bibliothek Adafruit NeoPixel und installiere sie.
  2. Baue die Schaltung nach der Tabelle oben auf; verbinde das lange Bein (+) des Kondensators mit 5V.
  3. Lade den folgenden Code hoch und halte die Umgebung in der ersten halben Sekunde still: In dieser Zeit misst der Code den Rauschpegel.
  4. Öffne den Serial Monitor mit 115200 Baud und sieh dir den ausgegebenen Rauschpegel an; liegt er über 10, gibt es Versorgungsrauschen.
  5. Spiele Musik ab und drehe am Potentiometer, bis der Ring bei höchster Lautstärke fast ganz gefüllt ist.
  6. Platziere das Mikrofon 20–50 cm vom Lautsprecher entfernt, weg vom LED-Licht und von Tischvibrationen.
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}
CodeabschnittAufgabe
readPeakToPeak()Nimmt 25 ms lang Samples auf und gibt die Differenz zwischen größtem und kleinstem Wert zurück
noiseFloorMittelwert der 20 Messungen beim Start + 2; alles darunter gilt als Stille
maxPPPer Potentiometer zwischen 10 und 300 einstellbarer Vollausschlag; kleiner Wert = hohe Empfindlichkeit
levelSchnell steigender, langsam fallender geglätteter Pegel (verhindert Flackern)
peakLedWeiß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.

Der blaue Trimmer auf dem KY-038 stellt nur den Schwellenwert des DO-Ausgangs ein; er verstärkt das Signal am AO nicht. Reagiert die Uno-Version nur auf laute Geräusche in der Nähe, erhöhe die Empfindlichkeit per Potentiometer oder steige auf ein Mikrofonmodul mit Verstärker um. Alle Details zum KY-038 findest du im Beitrag KY-038 Soundsensor.

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 / PinESP32Hinweis
INMP441 VDD3V3Keine 5 V anlegen, das Mikrofon arbeitet mit 3,3 V
INMP441 GNDGNDGemeinsame Masse
INMP441 L/RGNDLinker Kanal wird gewählt
INMP441 WSGPIO 25Wortauswahl (LRCLK)
INMP441 SCKGPIO 32Bit-Takt (BCLK)
INMP441 SDGPIO 33Audiodaten
WS2812B DINGPIO 18 (über 330 Ω)3,3-V-Signal funktioniert bei kurzem Kabel
WS2812B 5VVIN (USB 5 V) oder externe 5 V1000-µF-Kondensator ergänzen
WS2812B GNDGNDGemeinsam mit der externen Quelle
Lass den L/R-Pin des INMP441 nicht offen; sonst kann das Mikrofon keinen Kanal wählen, und du liest dauerhaft Nullen oder unsinnige Daten. Außerdem kann das 3,3-V-Datensignal des ESP32 bei manchen Streifen knapp werden, wenn die WS2812B mit 5 V versorgt wird. Flackert die erste LED oder zeigt sie eine falsche Farbe, kürze das Datenkabel oder nutze einen Logikpegel-Wandler.
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}

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

SymptomMögliche UrsacheLösung
LEDs flackern bei StilleRauschpegel zu niedrig gemessenBeim Start Ruhe halten, Schwellenreserve von 2 auf 4–5 erhöhen
Keine Reaktion auf Musik (Uno)KY-038-Signal zu schwachmaxPP per Poti senken, Mikrofon näher an den Lautsprecher bringen
Ring ist dauerhaft vollVollausschlag zu kleinPer Poti maxPP bzw. RANGE_DB erhöhen
INMP441 liest immer nullL/R offen oder Kanal vertauschtL/R an GND legen; hilft das nicht, an 3V3 legen und im Code den rechten Kanal wählen
Erste LED zeigt falsche FarbeDatensignal schwach oder Widerstand fehlt330-Ω-Vorwiderstand ergänzen, Datenkabel kürzen
Board startet bei Bassschlägen neuLED-Strom lässt die Versorgung einbrechenHelligkeit senken, externes 5-V-Netzteil und 1000-µF-Kondensator verwenden
LEDs triggern das MikrofonVersorgungsschwankungen gelangen in die analoge LeitungMikrofon mit separatem Kabel an 5V anschließen, GNDs an einem Punkt verbinden
Beim Einstellen hilft der Serial Plotter enorm: Füge in die Schleife Serial.println(pp) bzw. beim ESP32 Serial.println(db) ein und sieh dir die Grafik bei laufender Musik an. Die Linie in der Stille zeigt den Rauschpegel, die Spitze im lautesten Moment des Songs zeigt direkt, welchen Wert du für den Vollausschlag eintragen musst.

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.

Alle Projekte ansehen
Steuerung des ESP32 WS2812B NeoPixel-Streifens
ES-24Mittel
Premium

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.

4.9(19)
30
WS2812B-LED-Streifen verwenden
AR-69Mittel
Premium

WS2812B-LED-Streifen verwenden

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

4.8(54)
70
Polizeilicht mit WS2812B
AR-70Mittel
Premium

Polizeilicht mit WS2812B

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

4.8(67)
86
WS2812B-Lauflicht
AR-71Mittel
Premium

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.

4.8(58)
75
WS2812B-Lauflicht (auffüllend)
AR-72Mittel
Premium

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…

4.7(50)
65
WS2812B Knight-Rider-Lauflicht
AR-73Mittel
Premium

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.

4.9(73)
94
WS2812B Animation 1
AR-75Mittel
Premium

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.

4.9(69)
89
WS2812B Animation 2
AR-76Mittel
Premium

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…

4.8(65)
84