Arduino Schallsensor KY-038: Klatschschalter und Lautstärke

Wer einen Arduino Schallsensor sucht, landet fast immer beim KY-038: einem günstigen Modul, das ein kleines Elektret-Mikrofon, einen LM393-Komparator und ein blaues Potentiometer zur Empfindlichkeitseinstellung auf einer Platine vereint. Sein Bruder mit dem großen Mikrofon, der KY-037, funktioniert genauso. Eine Bibliothek brauchst du nicht: Der DO-Pin wechselt seinen Zustand, sobald das Geräusch eine Schwelle überschreitet, und wird mit digitalRead() gelesen; der AO-Pin liefert das Rohsignal des Mikrofons und wird mit analogRead() gelesen. Klatschschalter, Lärmwarner und Lichter, die auf Musik reagieren, werden mit diesem Modul gebaut.

Dieser Sensor hat aber eine wichtige Grenze, die viele Anleitungen verschweigen: Der KY-038 ist ein Detektor für Geräusch ja oder nein. Er nimmt keinen Ton auf, erkennt keine Sprache und kann keine Dezibel messen. In diesem Artikel lernst du, wie die Schaltung auf dem Modul arbeitet, wie du das Poti richtig einstellst, warum der Analogwert oft scheinbar gar nicht reagiert und wie du die Lautstärke mit der Spitze-Spitze-Methode korrekt misst. Danach baust du eine Lampe, die per Doppelklatschen schaltet, und eine Pegelanzeige mit 8 LEDs, setzt dasselbe mit dem ESP32 und dem Raspberry Pi Pico um und erfährst, auf welche Module du für echte Schallmessung umsteigen solltest.

Was ist ein Schallsensor und wie funktioniert er?

Der silberne Zylinder am Ende der Platine ist ein Elektret-Kondensatormikrofon. Darin liegt eine dünne Membran einer Platte mit dauerhafter elektrischer Ladung gegenüber, sodass ein winziger Kondensator entsteht. Schall ist eine Druckschwankung in der Luft; wenn sie die Membran hin und her bewegt, ändert sich die Kapazität und es entsteht eine sehr kleine Spannungsänderung. Ein winziger JFET in der Kapsel puffert dieses Signal; deshalb wird ein Elektret-Mikrofon über einen Widerstand versorgt und ist gepolt. Am Mikrofon erhältst du also eine Schallwelle von nur wenigen Millivolt, die auf einer festen Gleichspannung sitzt.

Der 8-beinige LM393 in der Mitte der Platine enthält zwei Komparatoren, von denen das Modul einen nutzt. Ein Komparator vergleicht zwei Spannungen: das Signal vom Mikrofon und die Schwelle, die das Potentiometer vorgibt. Sobald das Signal die Schwelle überschreitet, kippt der Ausgang, und der DO-Pin sowie die zweite LED auf der Platine reagieren. Ein sehr wichtiges Detail: Ein Komparator ist kein Verstärker. Er macht das Signal nicht größer, sondern beantwortet nur die Frage „über oder unter der Schwelle?“. Am AO-Pin liegt das unverstärkte Rohsignal des Mikrofons, und genau deshalb ist der Analogwert so schwach.

Unterschied zwischen KY-038 und KY-037

KY-038 und KY-037 nutzen dieselbe Schaltung, denselben LM393 und dieselbe Pinreihenfolge; alle Sketche in diesem Artikel laufen auf beiden ohne Änderung. Der Unterschied liegt in der Mikrofonkapsel: Der KY-037 hat eine größere Kapsel und wird als „hochempfindlicher Schallsensor“ verkauft, der KY-038 hat eine kleinere Kapsel und ist das Modell, das du in Sensor-Kits am häufigsten findest. In der Praxis erkennen beide laute Geräusche in der Nähe gut, ein Gespräch am anderen Ende des Zimmers aber nicht. Außerdem gibt es 3-polige LM393-Geräuschsensoren mit nur einem Digitalausgang; bei den meisten geht der Ausgang bei Geräusch auf LOW.

Schallsensor anschließen: Arduino Uno, ESP32 und Pico

Digitalausgang (DO) und Poti einstellen

Der DO-Pin ist eine Ja/Nein-Antwort. Bei vielen KY-038-Platinen geht DO auf HIGH und die zweite LED leuchtet, sobald das Geräusch die Schwelle überschreitet; bei manchen Nachbauten und bei 3-poligen Modulen ist es genau umgekehrt. Deshalb speichern die Sketche den Pegel, der „Geräusch“ bedeutet, in einer Konstante namens SOUND_ACTIVE. Der zweite wichtige Punkt: DO liefert bei einem Klatschen keinen einzelnen langen Impuls. Weil die Schallwelle hunderte Male pro Sekunde über die Schwelle steigt und darunter fällt, schaltet auch der Ausgang genauso schnell ein und aus; ein einziges Klatschen erzeugt eine Impulssalve aus kurzen Pulsen, die einige zehn Millisekunden dauert. Die meisten Platinen haben keine Hysterese am Komparator, deshalb flattert der Ausgang bei Geräuschen nahe der Schwelle zusätzlich. Lies DO also mit einer schnellen Schleife ohne delay() oder per Interrupt und werte dicht aufeinanderfolgende Pulse als ein einziges Ereignis.

1. Schließe das Modul an und platziere den Sensor dort, wo er später arbeitet, und zwar bei normalem Umgebungsgeräusch; stelle ihn immer in der echten Umgebung ein.
2. Beobachte die DO-LED auf der Platine. Leuchtet sie in der Stille dauerhaft, ist die Schwelle zu empfindlich; drehe das Poti mit einem kleinen Schraubendreher, bis die LED erlischt.
3. Leuchtet die LED nie, drehe in die andere Richtung, bis du den Punkt findest, an dem sie anfängt zu leuchten.
4. Drehe von diesem Punkt aus eine halbe bis eine ganze Umdrehung zurück in die Richtung, in der die LED aus bleibt. So lösen Dauergeräusche wie Kühlschrank oder Lüfter nichts aus.
5. Klatsche aus etwa einem Meter Entfernung: Die LED sollte kurz aufblitzen. Leuchtet sie auch bei normalem Sprechen, drehe etwas in Richtung unempfindlicher; reagiert sie nicht auf Klatschen, etwas in Richtung empfindlicher.

1// KY-038 DO testi: sesi algıla ve dahili LED'i yak / KY-038 DO test: detect sound and light the built-in LED
2const int SOUND_DO = 2;               // modülün DO pini / module DO pin
3const int SOUND_ACTIVE = HIGH;        // ses gelince HIGH; kartın tersse LOW / HIGH on sound; LOW if your board is inverted
4const unsigned long HOLD_MS = 200;    // yeni olay için gereken sessizlik / silence needed for a new event
5
6unsigned long lastSound = 0;
7unsigned long events = 0;
8
9void setup() {
10  Serial.begin(9600);
11  pinMode(SOUND_DO, INPUT);
12  pinMode(LED_BUILTIN, OUTPUT);
13}
14
15void loop() {
16  unsigned long now = millis();
17  if (digitalRead(SOUND_DO) == SOUND_ACTIVE) {
18    if (now - lastSound > HOLD_MS) {  // sessizlikten sonra ilk darbe / first pulse after silence
19      events++;
20      Serial.print(F("Ses algilandi / Sound detected #"));
21      Serial.println(events);
22    }
23    lastSound = now;                  // darbe yağmuru süreyi uzatır / the pulse burst extends the time
24  }
25  digitalWrite(LED_BUILTIN, now - lastSound < HOLD_MS ? HIGH : LOW);  // LED en az 200 ms yanar / LED stays on at least 200 ms
26}

Der Sketch liest den DO-Pin in jedem Schleifendurchlauf ohne delay(). Jedes Mal, wenn DO aktiv ist, wird die Zeit lastSound erneuert; ein neues Ereignis zählt erst nach 200 ms Stille, sodass die Impulssalve eines Klatschens im seriellen Monitor als eine einzige Zeile erscheint. Auch die eingebaute LED bleibt mindestens 200 ms an, sonst könntest du die Millisekunden-Pulse mit bloßem Auge nicht sehen. Steigt der Zähler in der Stille ständig an, ist entweder die Schwelle zu empfindlich oder der DO-Ausgang deiner Platine arbeitet invertiert; im zweiten Fall setze SOUND_ACTIVE auf LOW.

Warum ist der Analogwert (AO) so schwach?

Die meisten Einsteiger verbinden AO mit A0, geben den analogRead()-Wert aus und sehen eine Zahl um 500, die sich bei Geräuschen kaum bewegt. Der Sensor ist nicht kaputt, das Problem ist der Maßstab. Der 10-Bit-ADC des Arduino Uno teilt 0–5 V in 1024 Stufen, eine Stufe entspricht also etwa 4,9 mV. Das Signal des Mikrofons ist bei normalen Geräuschen viel kleiner als diese Stufe:

Die Tabelle wurde mit −44 dBV/Pa, der Empfindlichkeit einer typischen Elektretkapsel, und unter Annahme eines sinusförmigen Tons berechnet. Je nach Vorwiderstand des Mikrofons auf deiner Platine können die echten Werte einige Male größer sein, am Ergebnis ändert das nichts: AO sieht nur nahe, laute Geräusche deutlich, normales Sprechen und Flüstern liegen unter der Auflösung des Uno. Wie ein ADC funktioniert, erfährst du ausführlich in Was ist ein ADC?.

Der zweite Grund ist die Natur des Schalls. Schall ist eine Welle, die um einen Gleichspannungspegel auf und ab schwingt. Ein einzelnes analogRead() erwischt einen zufälligen Moment dieser Welle: einen Wellenberg, ein Wellental oder genau die Mitte. Die Größe eines einzelnen Messwerts sagt deshalb nichts über die Lautstärke aus. Der dritte Grund ist die Geschwindigkeit: Der Uno braucht für eine Analogmessung etwa 100 Mikrosekunden und schafft damit höchstens rund 10.000 Messungen pro Sekunde. Das reicht, um den Pegel zu verfolgen, aber nicht für Tonaufnahmen oder Frequenzanalysen. Und schließlich koppelt das Rauschen der 5-V-Versorgung vom USB direkt in AO ein. Die ersten beiden Probleme löst du mit der richtigen Messmethode.

Spitze-Spitze-Amplitude messen: die Lautstärke richtig erfassen

Die richtige Methode: Nimm in einem kurzen Zeitfenster so viele Messwerte wie möglich und suche den größten und den kleinsten Wert. Ihre Differenz ist die Spitze-Spitze-Amplitude (peak-to-peak) und zeigt unabhängig vom Gleichspannungspegel, wie stark das Geräusch ist. 50 ms sind ein gutes Fenster: Eine Periode von 20 Hz, der tiefsten Frequenz, die das menschliche Ohr hört, dauert genau 50 ms, sodass selbst der tiefste Ton mit einer ganzen Welle hineinpasst. Der Uno nimmt in dieser Zeit etwa 450–500 Messwerte auf.

1// Tepe-tepe genlik ölçümü (Seri Çizici için) / Peak-to-peak amplitude (for the Serial Plotter)
2const int SOUND_AO = A0;                 // modülün AO pini / module AO pin
3const unsigned long WINDOW_MS = 50;      // 50 ms = 20 Hz'in bir periyodu / one period of 20 Hz
4
5void setup() {
6  Serial.begin(115200);
7}
8
9void loop() {
10  int minV = 1023, maxV = 0;
11  long sum = 0;
12  int count = 0;
13  unsigned long start = millis();
14  while (millis() - start < WINDOW_MS) { // yaklaşık 450-500 örnek / about 450-500 samples
15    int v = analogRead(SOUND_AO);
16    if (v < minV) minV = v;
17    if (v > maxV) maxV = v;
18    sum += v;
19    count++;
20  }
21  int p2p = maxV - minV;                 // tepe-tepe genlik / peak-to-peak amplitude
22  float mv = p2p * 5000.0 / 1024.0;      // milivolt karşılığı / in millivolts
23
24  Serial.print(F("p2p:"));
25  Serial.print(p2p);
26  Serial.print(F(" ortalama_avg:"));     // AO'nun DC seviyesi; istemezsen bu iki satırı sil / DC level of AO; delete these two lines if not needed
27  Serial.print(sum / count);
28  Serial.print(F(" mV:"));
29  Serial.println(mv, 1);
30}

Öffne nach dem Hochladen über das Menü Werkzeuge den seriellen Plotter und stelle 115200 Baud ein. In einem ruhigen Raum bleibt p2p meist zwischen 0 und 3; sprichst du neben dem Mikrofon, steigt der Wert um einige Einheiten, klatschst du aus der Nähe, um einige zehn. Der Wert ortalama_avg ist der Gleichspannungspegel von AO; da er die Skala des Diagramms streckt, kannst du die beiden ortalama_avg-Zeilen löschen, wenn du p2p bequem verfolgen willst. Bei manchen Platinen verschiebt das Poti auch diesen Pegel; klebt der Mittelwert an 0 oder 1023, wird das Signal abgeschnitten, also drehe das Poti, bis der Wert in der Mitte liegt. Wenn du den seriellen Plotter zum ersten Mal nutzt, wirf einen Blick in Arduino Serieller Monitor.

Schritt für Schritt: Lampe per Doppelklatschen schalten

Der Klatschschalter ist das bekannteste Projekt mit einem Schallsensor. Eine Schaltung, die schon auf einmaliges Klatschen reagiert, löst aber auch bei einer zuschlagenden Tür, einem heruntergefallenen Buch oder einem Husten aus, und die Lampe geht ständig an und aus. Die Lösung ist, nach einem Rhythmus zu suchen: Der folgende Sketch reagiert nur auf genau zweimal Klatschen im Abstand von 0,12 bis 0,7 Sekunden. Ein einzelnes Geräusch oder drei und mehr Geräusche (Musik, Applaus, ein bellender Hund) werden ignoriert.

1. Verbinde den +-Pin des KY-038 mit 5V, G mit GND und DO mit D2.
2. Verbinde VCC des Relaismoduls mit 5V, GND mit GND und IN mit D7. Wie ein Relais funktioniert und wie die Lastseite verdrahtet wird, steht in Was ist ein Relaismodul?; mach die ersten Tests mit der LED des Relais statt mit einer Lampe.
3. Lade den Sketch hoch und öffne den seriellen Monitor mit 9600 Baud.
4. Klatsche aus ein bis zwei Metern Entfernung zweimal. Pro Klatschen solltest du nur eine Zeile „Alkis / Clap“ sehen; wird ein Klatschen mehrfach gezählt, drehe das Poti etwas in Richtung unempfindlicher.
5. Beobachte, wie die Lampe etwa 0,7 Sekunden nach dem zweiten Klatschen umschaltet.

1// Çift alkışla lamba (röle) / Double-clap lamp (relay)
2const int SOUND_DO = 2;                     // KY-038 DO pini / KY-038 DO pin
3const int RELAY = 7;                        // röle modülü IN / relay module IN
4const int SOUND_ACTIVE = HIGH;              // kartın tersse LOW / LOW if your board is inverted
5const int RELAY_ON = LOW;                   // aktif LOW röle modülü / active-LOW relay module
6const int RELAY_OFF = HIGH;
7const unsigned long QUIET_GAP_MS = 120;     // yeni alkış için gereken sessizlik / silence needed before a new clap
8const unsigned long CLAP_WINDOW_MS = 700;   // dizinin bittiğine karar verme süresi / time to decide the series is over
9const unsigned long LOCKOUT_MS = 1000;      // röle tıkırtısını yok say / ignore the relay click
10
11int clapCount = 0;
12unsigned long lastPulse = 0;                // DO'nun son aktif olduğu an / last time DO was active
13unsigned long lastToggle = 0;               // lambanın son değiştiği an / last time the lamp changed
14bool lampOn = false;
15
16void setup() {
17  Serial.begin(9600);
18  pinMode(SOUND_DO, INPUT);
19  pinMode(RELAY, OUTPUT);
20  digitalWrite(RELAY, RELAY_OFF);           // lamba kapalı başlar / lamp starts off
21}
22
23void loop() {
24  unsigned long now = millis();
25
26  if (digitalRead(SOUND_DO) == SOUND_ACTIVE) {
27    bool locked = now - lastToggle < LOCKOUT_MS;
28    if (!locked && now - lastPulse >= QUIET_GAP_MS) {  // sessizlikten sonra ilk darbe = yeni alkış / first pulse after silence = new clap
29      clapCount++;
30      Serial.print(F("Alkis / Clap: "));
31      Serial.println(clapCount);
32    }
33    lastPulse = now;                        // aynı alkışın darbeleri süreyi uzatır / pulses of the same clap extend the time
34  }
35
36  if (clapCount > 0 && now - lastPulse > CLAP_WINDOW_MS) {  // dizi bitti / the series is over
37    if (clapCount == 2) {                   // yalnız tam iki alkış / exactly two claps only
38      lampOn = !lampOn;
39      digitalWrite(RELAY, lampOn ? RELAY_ON : RELAY_OFF);
40      lastToggle = now;
41      if (lampOn) Serial.println(F("Lamba ACIK / Lamp ON"));
42      else Serial.println(F("Lamba KAPALI / Lamp OFF"));
43    }
44    clapCount = 0;                          // 1, 3 ve fazlası yok sayılır / 1, 3 or more are ignored
45  }
46}

Der Sketch verwendet kein delay(), sondern misst alles mit millis(); so geht kein Klatschen verloren. Das Prinzip erklären wir ausführlich in millis statt delay. Dass die Lampe nicht sofort, sondern 0,7 Sekunden nach dem zweiten Klatschen schaltet, ist Absicht: Der Sketch wartet ab, ob noch ein drittes Klatschen kommt. Willst du eine schnellere Reaktion, kannst du CLAP_WINDOW_MS auf 400–500 ms senken, musst dann aber auch schneller klatschen. Hallt dein Raum stark und wird ein Klatschen doppelt gezählt, erhöhe QUIET_GAP_MS auf 150–200 ms.

Pegelanzeige: VU-Meter mit 8 LEDs

Den Spitze-Spitze-Wert direkt auf die LEDs zu geben funktioniert, wirkt aber unnatürlich, denn unser Ohr nimmt Schall logarithmisch wahr: Ein Geräusch mit doppelter Amplitude klingt nicht doppelt so laut. Deshalb misst man Schall in Dezibel (dB). Für die Amplitude lautet die Formel dB = 20 × log10(p2p / Referenz); doppelte Amplitude sind +6 dB, zehnfache +20 dB. Der folgende Sketch misst beim Start eine Sekunde lang das Grundrauschen des Raums und nimmt es als Referenz; jede LED steht für 3 dB über diesem Grundrauschen. Schließe die LEDs an D3–D10 an, jede mit einem 220-Ω-Widerstand; für andere LED-Farben findest du den passenden Widerstand mit dem LED-Vorwiderstandsrechner.

1// 8 LED'li ses seviyesi göstergesi (VU metre) / 8-LED sound level bar (VU meter)
2const int SOUND_AO = A0;                    // modülün AO pini / module AO pin
3const int LED_PINS[8] = {3, 4, 5, 6, 7, 8, 9, 10};  // her LED 220 Ω ile / each LED with 220 Ω
4const float DB_PER_LED = 3.0;               // her LED 3 dB / each LED is 3 dB
5const unsigned long FALL_MS = 80;           // LED'ler bu aralıkla birer birer söner / LEDs drop one by one at this rate
6
7float noiseFloor = 1.0;                     // sessiz ortamın p2p değeri / quiet-room p2p
8int shown = 0;                              // yanan LED sayısı / number of lit LEDs
9unsigned long lastFall = 0;
10
11int readPeakToPeak() {
12  int minV = 1023, maxV = 0;
13  unsigned long start = millis();
14  while (millis() - start < 50) {           // 50 ms pencere / 50 ms window
15    int v = analogRead(SOUND_AO);
16    if (v < minV) minV = v;
17    if (v > maxV) maxV = v;
18  }
19  return maxV - minV;
20}
21
22void setup() {
23  Serial.begin(115200);
24  for (int i = 0; i < 8; i++) pinMode(LED_PINS[i], OUTPUT);
25  long sum = 0;
26  for (int i = 0; i < 20; i++) sum += readPeakToPeak();  // 1 sn sessizlik ölç / measure 1 s of silence
27  noiseFloor = sum / 20.0;
28  if (noiseFloor < 1.0) noiseFloor = 1.0;
29}
30
31void loop() {
32  int p2p = readPeakToPeak();
33  if (p2p < 1) p2p = 1;
34  float db = 20.0 * log10(p2p / noiseFloor);  // tabana göre göreceli dB / relative dB above the floor
35  int level = constrain((int)(db / DB_PER_LED), 0, 8);
36
37  unsigned long now = millis();
38  if (level >= shown) {                     // yükselişte anında / rise instantly
39    shown = level;
40    lastFall = now;
41  } else if (now - lastFall >= FALL_MS) {   // inişte yavaşça / fall slowly
42    shown--;
43    lastFall = now;
44  }
45  for (int i = 0; i < 8; i++) digitalWrite(LED_PINS[i], i < shown ? HIGH : LOW);
46
47  Serial.print(F("dB:"));
48  Serial.println(db, 1);
49}

Sei beim Start eine Sekunde lang still; sprichst du in dieser Zeit, wird das Grundrauschen zu hoch gemessen und die Anzeige reagiert schwächer. Die Anzeige steigt sofort, fällt aber langsam, eine LED alle 80 ms; auch echte VU-Meter wirken deshalb ruhig statt zappelig. Weil das Analogsignal des KY-038 schwach ist, passen 2–3 dB pro LED; nutzt du denselben Sketch mit einem verstärkten Mikrofon wie dem MAX4466, kannst du DB_PER_LED auf 4–6 dB erhöhen. Für eine farbige Anzeige kannst du statt der LEDs auch einen NeoPixel-Ring verwenden; Details findest du in WS2812B NeoPixel LED.

Schallsensor mit dem ESP32: Klatschen per Interrupt erkennen

Der ADC des ESP32 hat 12 Bit und liefert Werte von 0 bis 4095; im 3,3-V-Bereich entspricht eine Stufe etwa 0,8 mV, also rund sechsmal feiner als beim Uno. Dafür rauscht der ADC des ESP32 stärker, sodass auch der p2p-Wert im ruhigen Raum höher ausfällt; die relative dB-Berechnung gleicht das von selbst aus. Im folgenden Sketch hängt der DO-Pin an einem Interrupt: Selbst während loop() 50 ms lang den Pegel an AO misst, geht kein Klatschimpuls verloren. Die Interrupt-Funktion wird mit IRAM_ATTR in den RAM gelegt und kurz gehalten; Variablen, die sowohl der Interrupt als auch loop() nutzen, sind volatile und werden durch einen kritischen Abschnitt geschützt.

1// ESP32: kesmeyle çift alkış + ses seviyesi / ESP32: double clap via interrupt + sound level
2const int SOUND_AO = 34;                    // ADC1 pini, Wi-Fi açıkken de çalışır / ADC1 pin, works with Wi-Fi on
3const int SOUND_DO = 27;                    // modülün DO pini / module DO pin
4const int RELAY = 26;                       // röle modülü IN / relay module IN
5const int SOUND_ACTIVE = HIGH;              // kartın tersse LOW / LOW if your board is inverted
6const int RELAY_ON = LOW;                   // aktif LOW röle / active-LOW relay
7const int RELAY_OFF = HIGH;
8const unsigned long QUIET_GAP_MS = 120;     // yeni alkış için sessizlik / silence before a new clap
9const unsigned long CLAP_WINDOW_MS = 700;   // dizinin bitmesi / end of the series
10const unsigned long LOCKOUT_MS = 1000;      // röle tıkırtısını yok say / ignore the relay click
11
12portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;  // kesme ile loop arasında kilit / lock between ISR and loop
13volatile int clapCount = 0;
14volatile unsigned long lastPulse = 0;
15volatile unsigned long lastToggle = 0;
16bool lampOn = false;
17float noiseFloor = 1.0;
18
19void IRAM_ATTR onSound() {                  // kısa tutulur, RAM'den çalışır / kept short, runs from RAM
20  unsigned long now = millis();
21  portENTER_CRITICAL_ISR(&mux);
22  if (now - lastToggle >= LOCKOUT_MS && now - lastPulse >= QUIET_GAP_MS) clapCount++;
23  lastPulse = now;
24  portEXIT_CRITICAL_ISR(&mux);
25}
26
27int readPeakToPeak() {
28  int minV = 4095, maxV = 0;
29  unsigned long start = millis();
30  while (millis() - start < 50) {           // 50 ms pencere / 50 ms window
31    int v = analogRead(SOUND_AO);           // 0-4095 (12 bit)
32    if (v < minV) minV = v;
33    if (v > maxV) maxV = v;
34  }
35  return maxV - minV;
36}
37
38void setup() {
39  Serial.begin(115200);
40  pinMode(SOUND_DO, INPUT);
41  pinMode(RELAY, OUTPUT);
42  digitalWrite(RELAY, RELAY_OFF);
43  long sum = 0;
44  for (int i = 0; i < 20; i++) sum += readPeakToPeak();  // 1 sn sessiz ortam / 1 s of quiet room
45  noiseFloor = sum / 20.0;
46  if (noiseFloor < 1.0) noiseFloor = 1.0;
47  attachInterrupt(digitalPinToInterrupt(SOUND_DO), onSound, SOUND_ACTIVE == HIGH ? RISING : FALLING);
48}
49
50void loop() {
51  int p2p = readPeakToPeak();               // bu sırada alkışları kesme yakalar / the interrupt catches claps meanwhile
52  float db = 20.0 * log10((p2p < 1 ? 1 : p2p) / noiseFloor);
53  Serial.printf("p2p:%d dB:%.1f\n", p2p, db);
54
55  portENTER_CRITICAL(&mux);
56  unsigned long now = millis();
57  int claps = clapCount;
58  bool finished = claps > 0 && now - lastPulse > CLAP_WINDOW_MS;
59  if (finished) clapCount = 0;              // dizi bitti, sayacı sıfırla / series over, reset the counter
60  portEXIT_CRITICAL(&mux);
61
62  if (finished && claps == 2) {             // yalnız tam iki alkış / exactly two claps only
63    lampOn = !lampOn;
64    digitalWrite(RELAY, lampOn ? RELAY_ON : RELAY_OFF);
65    portENTER_CRITICAL(&mux);
66    lastToggle = millis();
67    portEXIT_CRITICAL(&mux);
68    Serial.println(lampOn ? "Lamba ACIK / Lamp ON" : "Lamba KAPALI / Lamp OFF");
69  }
70}

Der Sketch führt dieselbe Doppelklatsch-Logik wie beim Uno aus, nur im Interrupt, und gibt etwa alle 50 ms den Pegel in dB aus. Verbinde IN des Relaismoduls mit GPIO 26; manche Low-aktiven Relaismodule, die mit 5 V versorgt werden, fallen beim 3,3-V-HIGH-Pegel des ESP32 nicht sicher ab – nimm dann ein Modul, das sich mit 3,3 V ansteuern lässt. Die eigentliche Stärke des ESP32 ist das WLAN: Bleibt der Pegel einige Sekunden über einer Schwelle (etwa wenn ein Baby weint oder ein Hund bellt), kannst du eine Benachrichtigung aufs Handy schicken. Nutze dafür die Methode aus ESP32 Telegram-Bot und für die Anbindung an ein Hausautomationssystem ESP32 mit MQTT und Home Assistant.

Schallsensor mit Raspberry Pi Pico und MicroPython

Versorge das Modul am Raspberry Pi Pico über den Pin 3V3(OUT), verbinde AO mit GP26 und DO mit GP15 und setze statt einer Lampe eine LED mit 220-Ω-Widerstand an GP14. Der ADC des Pico hat 12 Bit, aber in MicroPython skaliert read_u16() den Wert auf 0–65535; deshalb wirken die p2p-Zahlen viel größer als beim Uno, die relative dB-Berechnung bleibt aber gleich. Für den DO-Pin wird mit Pin.irq() ein Interrupt eingerichtet.

1# Raspberry Pi Pico: çift alkış + ses seviyesi / double clap + sound level
2from machine import Pin, ADC
3import time, math
4
5sound_ao = ADC(26)                  # GP26 = ADC0, modülün AO pini / module AO pin
6sound_do = Pin(15, Pin.IN)          # modülün DO pini / module DO pin
7lamp = Pin(14, Pin.OUT, value=0)    # LED (220 Ω ile) / LED (with 220 Ω)
8
9QUIET_GAP_MS = 120                  # yeni alkış için sessizlik / silence before a new clap
10CLAP_WINDOW_MS = 700                # dizinin bitmesi / end of the series
11LOCKOUT_MS = 1000                   # değişimden sonra sesleri yok say / ignore sounds after a toggle
12
13claps = 0
14last_pulse = time.ticks_ms()
15last_toggle = time.ticks_ms()
16
17def on_sound(pin):                  # kesme fonksiyonu / interrupt handler
18    global claps, last_pulse
19    now = time.ticks_ms()
20    if (time.ticks_diff(now, last_toggle) >= LOCKOUT_MS
21            and time.ticks_diff(now, last_pulse) >= QUIET_GAP_MS):
22        claps += 1
23    last_pulse = now
24
25# DO sesle LOW oluyorsa IRQ_FALLING yaz / use IRQ_FALLING if DO goes LOW on sound
26sound_do.irq(trigger=Pin.IRQ_RISING, handler=on_sound)
27
28def peak_to_peak(window_ms=50):     # 50 ms boyunca en büyük - en küçük / max - min over 50 ms
29    lo, hi = 65535, 0
30    start = time.ticks_ms()
31    while time.ticks_diff(time.ticks_ms(), start) < window_ms:
32        v = sound_ao.read_u16()     # 0-65535
33        if v < lo:
34            lo = v
35        if v > hi:
36            hi = v
37    return hi - lo
38
39noise_floor = max(1, sum(peak_to_peak() for _ in range(20)) / 20)  # 1 sn sessizlik / 1 s of silence
40
41while True:
42    p2p = peak_to_peak()
43    db = 20 * math.log10(max(p2p, 1) / noise_floor)   # göreceli dB / relative dB
44    print("p2p:", p2p, "dB:", round(db, 1))
45
46    now = time.ticks_ms()
47    if claps and time.ticks_diff(now, last_pulse) > CLAP_WINDOW_MS:
48        if claps == 2:              # yalnız tam iki alkış / exactly two claps only
49            lamp.toggle()
50            last_toggle = now
51            print("Lamba / Lamp:", "ON" if lamp.value() else "OFF")
52        claps = 0

Wenn du den Code in Thonny ausführst, siehst du die p2p- und dB-Werte in der Shell; öffnest du im Menü Ansicht den Plotter, verfolgst du sie als Diagramm. Geht der DO-Ausgang deiner Platine bei Geräusch auf LOW, schreibe IRQ_FALLING statt IRQ_RISING. Damit das Programm beim Einschalten des Pico von selbst startet, speichere die Datei auf dem Pico als main.py. Wenn MicroPython neu für dich ist, sind die MicroPython-Grundlagen ein guter Einstieg.

Kann ein Schallsensor Dezibel messen?

Kurze Antwort: nein. Im Netz findest du viele Sketche, die den Spitze-Spitze-Wert des KY-038 mit map() in einen Bereich wie 49–90 dB umrechnen; das sind Schätzungen, keine Messungen. Für einen echten Schalldruckpegel (dB SPL) brauchst du ein Mikrofon mit bekannter Empfindlichkeit und ein mit einem 94-dB-Kalibrator abgeglichenes System, eine lineare Verstärkung des Signals, einen über eine feste Zeit (125 ms bei „Fast“, 1 s bei „Slow“) berechneten Effektivwert und einen A-Bewertungsfilter, der die Empfindlichkeit des Ohrs nachbildet. Schallpegelmesser werden deshalb nach der Norm IEC 61672 gebaut.

Der KY-038 erfüllt keine dieser Bedingungen: Die Verstärkung der Platine ist unbekannt, die Empfindlichkeit der Mikrofonkapseln schwankt von Exemplar zu Exemplar um einige dB, Poti und Versorgungsspannung verändern den Signalpegel, und am Uno werden alle normalen Geräusche in wenige ADC-Stufen gequetscht. Das Ehrlichste, was du tun kannst, ist eine relative Messung: „Gerade ist es 12 dB lauter als im ruhigen Raum.“ Selbst das reicht völlig für einen Lärmwarner, eine Lärmampel im Klassenzimmer oder ein VU-Meter. Du kannst an einem Punkt mit einer Handy-App vergleichen und grob kalibrieren, aber diese Kalibrierung verliert bei anderen Pegeln und auf einer anderen Platine ihre Gültigkeit.

Alternativen: MAX4466, MAX9814 und INMP441

Der MAX4466 kombiniert die gleiche Art von Elektret-Mikrofon mit einem Operationsverstärker mit einstellbarer Verstärkung. Sein Ausgang liegt in der Stille bei der halben Versorgungsspannung und liefert bei normalem Sprechen in der Nähe ein Signal von einigen hundert Millivolt; aus den wenigen ADC-Stufen des KY-038 werden so Dutzende oder sogar Hunderte Stufen. Die Spitze-Spitze- und VU-Meter-Sketche aus diesem Artikel laufen mit dem MAX4466 ohne jede Änderung. Wie die Verstärkung berechnet wird, zeigen dir der OPV-Verstärkungsrechner und Was ist ein Operationsverstärker?. Wenn du das Modul aus dem saubereren 3.3V-Pin des Uno versorgst, sinkt das Rauschen. Der MAX9814 holt dagegen mit seiner automatischen Verstärkungsregelung selbst entfernte Sprache auf einen brauchbaren Pegel; für Aufnahmen und Spracherkennung ist er super, für Pegelmessungen aber ungeeignet, weil er leise und laute Umgebungen einander angleicht.

Der INMP441 ist gar nicht analog, sondern ein digitales MEMS-Mikrofon: Er wandelt den Schall intern in 24-Bit-Zahlen um und sendet sie über einen I2S-Bus, sodass Störungen auf den Leitungen nicht in die Messung gelangen. Sein größter Vorteil ist, dass der Hersteller die Empfindlichkeit mit enger Toleranz angibt: Ein Schall von 94 dB SPL wird als −26 dBFS gelesen. Wandelst du den gemessenen Effektivwert in dBFS um und addierst 120, erhältst du also einen ungefähren dB-SPL-Wert. Für I2S brauchst du einen ESP32 oder Pico; der Arduino Uno hat keine I2S-Hardware. INMP441-Module für Bastler sind günstig und leicht erhältlich, und ICS-43434 und SPH0645 sind ähnliche I2S-Mikrofone. Brauchst du wirklich eine genaue Lärmmessung, ist ein fertiges Schallpegelmodul mit A-bewertetem, kalibriertem Ausgang der einfachste Weg; beim DFRobot SEN0232 etwa ergibt die Ausgangsspannung mal 50 direkt den dBA-Wert.

Projektideen mit dem Schallsensor

• Klatschschalter: Ergänze den Doppelklatsch-Sketch oben um ein Relaismodul, steuere damit deine Schreibtischlampe oder einen LED-Streifen und lege dreimal Klatschen auf ein zweites Gerät.
• Lärmampel fürs Klassenzimmer: Eine Lärmanzeige, die je nach relativem dB-Wert grüne, gelbe und rote LEDs leuchten lässt; Lehrkräfte lieben sie.
• Baby- und Haustierwächter: Bleibt es länger als 5 Sekunden laut, schickt der ESP32 eine Telegram-Nachricht aufs Handy.
• Musikgesteuerte Lichter: Ein NeoPixel-Ring oder -Streifen, der im Takt der Musik pulsiert.
• Klopfmelder für die Tür: Eine Schaltung, die per Summer oder LED meldet, wenn jemand anklopft; um das Klopfen als Vibration statt als Geräusch zu erfassen, ist auch der Vibrationssensor SW-420 eine gute Wahl.
• Smart-Home-Szenarien: Kombiniere Geräusch mit Bewegungs- und Lichtsensoren, um das Licht auszuschalten, wenn niemand im Raum ist; Ideen findest du im Arduino Smart-Home-Projekt.

Häufige Fehler und Lösungen

Mit ein paar Kabeln und gut geschriebenem Code lehrt der KY-038 viele Grundlagen der Elektronik auf einmal: Komparatoren, Analog-Digital-Wandlung, Interrupts, Timing und Dezibelrechnung. Fang mit der Klatscherkennung über DO an, miss den Pegel mit der Spitze-Spitze-Methode und steig auf einen MAX4466 oder INMP441 um, wenn du echte Schallmessung brauchst. In der BlueGrays-App findest du Projekte wie Lampe mit Relais, Lauflicht, ESP32-Smart-Beleuchtung und NeoPixel-Streifen mit Schaltplänen und Schritt-für-Schritt-Code; einen Schallsensor hinzuzufügen ist der einfachste Weg, daraus Systeme zu machen, die auf Klatschen oder Geräusche reagieren.