Arduino-geluidssensor (KY-038): klapschakelaar en geluidsniveau
Hoe werkt de KY-038/KY-037 Arduino-geluidssensor? Potmeter instellen, geluidsniveau via piek-tot-piek, dubbele-klaplamp, ledbalk, ESP32- en Pico-code en de waarheid over dB.
Als mensen het over een Arduino-geluidssensor hebben, bedoelen ze meestal de KY-038: een goedkope module met een kleine elektreetmicrofoon, een LM393-comparator en een blauwe gevoeligheidspotmeter op één print. Zijn broertje met de grotere microfoon, de KY-037, werkt op dezelfde manier. Je hebt geen bibliotheek nodig: de DO-pin verandert van toestand als het geluid een drempel overschrijdt en lees je met digitalRead(). De AO-pin geeft het ruwe microfoonsignaal en lees je met analogRead(). Klaplampen, geluidsalarmen en geluidsgevoelige verlichting bouw je allemaal met deze module.
Maar deze sensor heeft een belangrijke beperking die veel tutorials overslaan: de KY-038 is een detector voor geluid / geen geluid. Hij neemt geen audio op, herkent geen spraak en kan geen decibels meten. In dit artikel leer je hoe de schakeling op de module werkt, hoe je de potmeter goed instelt, waarom de analoge meting vaak helemaal niet lijkt te veranderen en hoe je het volume correct meet met de piek-tot-piekmethode. Daarna bouw je een lamp die met een dubbele klap schakelt en een ledbalk met 8 leds voor het geluidsniveau, doe je hetzelfde met een ESP32 en een Raspberry Pi Pico en zie je naar welke modules je overstapt als je echt geluid wilt meten.

Wat is een geluidssensor en hoe werkt hij?
Het zilverkleurige cilindertje aan het uiteinde van de print is een elektreetcondensatormicrofoon. Binnenin staat een dun membraan tegenover een plaatje met een permanente elektrische lading, samen een piepkleine condensator. Geluid is een drukgolf in de lucht; als die het membraan heen en weer duwt, verandert de capaciteit en ontstaat een zeer kleine spanningsverandering. Een klein JFET'je in de capsule buffert dit signaal; daarom wordt een elektreetmicrofoon via een weerstand gevoed en heeft hij een polariteit. Het resultaat aan de microfoon is een geluidsgolf van slechts enkele millivolts bovenop een vaste gelijkspanning.
De LM393-chip met 8 pinnen in het midden van de print bevat twee comparators, waarvan de module er één gebruikt. Een comparator vergelijkt twee spanningen: het signaal van de microfoon en de drempel die de potmeter instelt. Zodra het signaal de drempel kruist, verandert de uitgang van toestand en reageren de DO-pin en de tweede led op de print. Een heel belangrijk detail: een comparator is geen versterker. Hij maakt het signaal niet groter, hij beantwoordt alleen de vraag "zit het boven of onder de drempel?". De AO-pin voert het ruwe, onversterkte signaal van de microfoon en daarom is de analoge meting zo zwak.
| Eigenschap | Waarde |
|---|---|
| Microfoon | Elektreetcondensatorcapsule, omnidirectioneel |
| Comparator | LM393 (dubbele comparator, er wordt er één gebruikt) |
| Voeding | 3,3–5 V |
| Stroom | Een paar mA (ongeveer 5–10 mA inclusief de leds) |
| Uitgangen | AO: ruw microfoonsignaal, DO: drempeluitgang |
| Gevoeligheidsinstelling | Blauwe meerslagen-trimmer (meestal type 3296) |
| Leds | Eén voor de voeding, één voor de DO-status |
| Pinvolgorde | AO, G, +, DO |
KY-038 versus KY-037
De KY-038 en KY-037 hebben dezelfde schakeling, dezelfde LM393 en dezelfde pinvolgorde, dus elke sketch in dit artikel draait zonder aanpassingen op beide. Het verschil zit in de microfooncapsule: de KY-037 heeft een grotere capsule en wordt verkocht als "geluidssensor met hoge gevoeligheid", terwijl de KY-038 een kleinere capsule heeft en het model is dat je het vaakst in sensorkits vindt. In de praktijk pikken beide harde geluiden dichtbij goed op, maar geen van beide hoort iemand praten aan de andere kant van de kamer. Je vindt ook LM393-geluidsmodules met 3 pinnen die alleen een digitale uitgang hebben; bij de meeste gaat de uitgang LOW als er geluid is.
| Model | Pins | Microfoon | Opmerking |
|---|---|---|---|
| KY-038 | AO, G, +, DO | Kleine capsule | Het meest voorkomende model in sensorkits |
| KY-037 | AO, G, +, DO | Grote capsule | Dezelfde schakeling en dezelfde code; meestal iets gevoeliger |
| LM393-geluidsmodule met 3 pinnen | VCC, GND, OUT | Kleine capsule | Alleen digitale uitgang; OUT gaat meestal LOW bij geluid |
Bedrading van de geluidssensor: Arduino Uno, ESP32 en Pico
| Modulepin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| + | 5V | 3V3 | 3V3(OUT), pin 36 |
| G | GND | GND | GND, pin 38 |
| AO | A0 | GPIO 34 (ADC1) | GP26 (ADC0), pin 31 |
| DO | D2 | GPIO 27 | GP15, pin 20 |
Digitale uitgang (DO) en potmeter instellen
De DO-pin geeft een ja/nee-antwoord. Op veel KY-038-boards gaat DO HIGH en gaat de tweede led branden als het geluid de drempel overschrijdt; op sommige kloonboards en op modules met 3 pinnen is het andersom. Daarom bewaren de sketches het niveau dat "geluid" betekent in een constante SOUND_ACTIVE. Het tweede belangrijke punt: DO geeft niet één lange puls per klap. Omdat de geluidsgolf honderden keren per seconde boven en onder de drempel komt, schakelt de uitgang even snel aan en uit; één klap levert een reeks korte pulsen op die enkele tientallen milliseconden duurt. De meeste boards hebben geen hysterese op de comparator, dus de uitgang klappert ook bij geluiden vlak bij de drempel. Lees DO dus met een snelle lus zonder delay() of met een interrupt, en behandel pulsen die dicht bij elkaar liggen als één gebeurtenis.
- Sluit de module aan en plaats de sensor op de plek waar hij gebruikt wordt, op een moment met normaal achtergrondgeluid; stel hem altijd af in de echte omgeving.
- Kijk naar de DO-led op de print. Als die in stilte blijft branden, is de drempel te gevoelig; draai met een klein schroevendraaiertje aan de potmeter tot de led uitgaat.
- Als de led nooit brandt, draai dan de andere kant op om het punt te vinden waar hij begint te branden.
- Draai vanaf dat punt een halve tot een hele slag terug naar de kant waar de led uit blijft. Zo veroorzaken constante geluiden zoals een koelkast of ventilator geen trigger.
- Klap van ongeveer een meter afstand: de led moet kort flitsen. Als hij ook bij normaal praten brandt, draai dan iets naar minder gevoelig; als hij bij een klap niet brandt, draai iets naar gevoeliger.
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}De sketch leest de DO-pin in elke lus zonder delay(). Elke keer dat DO actief is, wordt de tijd lastSound ververst; een nieuwe gebeurtenis wordt pas geteld na 200 ms stilte, zodat de pulsenreeks van een klap als één regel in de Serial Monitor verschijnt. De ingebouwde led blijft ook minstens 200 ms aan; anders zou je pulsen van milliseconden niet met je ogen kunnen zien. Als de teller in stilte blijft oplopen, is de drempel te gevoelig of is de DO-uitgang van je board geïnverteerd; stel in het tweede geval SOUND_ACTIVE in op LOW.
Waarom is de analoge meting (AO) zo zwak?
De meeste beginners sluiten AO aan op A0, printen de analogRead()-waarde en zien een getal rond 500 dat nauwelijks verandert met geluid. De sensor is niet kapot; het probleem is de schaal. De 10-bits ADC van de Arduino Uno verdeelt 0–5 V in 1024 stappen, dus één stap is ongeveer 4,9 mV. Bij normale geluiden is het signaal dat de microfoon levert veel kleiner dan die stap:
| Geluid | Geschat niveau | Microfoonuitgang (piek-tot-piek) | ADC-stappen op de Uno |
|---|---|---|---|
| Gefluister | 30 dB SPL | ~0.01 mV | 0 |
| Normale spraak (1 m) | 60 dB SPL | ~0.4 mV | 0 (onzichtbaar) |
| Harde tv, verkeer | 80 dB SPL | ~3.6 mV | 0–1 |
| Zeer hard geluid (1 Pa) | 94 dB SPL | ~18 mV | 3–4 |
| Scherpe klap of autotoeter van dichtbij | 110 dB SPL | ~110 mV | ~23 |
De tabel is berekend met −44 dBV/Pa, de gevoeligheid van een typische elektreetcapsule, uitgaand van een sinusvormig geluid. Afhankelijk van de voorspanningsweerstand van de microfoon op jouw board kunnen de echte waarden een paar keer groter zijn, maar de conclusie blijft hetzelfde: AO ziet alleen dichtbije, harde geluiden duidelijk, terwijl normale spraak en gefluister onder de resolutie van de Uno vallen. Meer over de werking van de ADC vind je in Wat is een ADC?.
De tweede reden is de aard van geluid. Geluid is een golf die op en neer beweegt rond een gelijkspanningsniveau. Eén analogRead() vangt een willekeurig moment van die golf: het kan een piek zijn, een dal of precies het midden. De grootte van één meting zegt dus niets over hoe hard het geluid is. De derde reden is snelheid: de Uno heeft ongeveer 100 microseconden per analoge meting nodig, dus hij kan hoogstens zo'n 10.000 samples per seconde nemen. Dat is genoeg om het geluidsniveau te volgen, maar niet om audio op te nemen of frequenties te analyseren. Ten slotte komt ruis op de 5V-voeding via USB rechtstreeks in AO terecht. De eerste twee problemen los je op met de juiste meetmethode.
De piek-tot-piekamplitude meten: volume correct uitlezen
De juiste methode is om in een kort tijdvenster zoveel mogelijk samples te nemen en de grootste en kleinste waarde te zoeken. Het verschil daartussen is de piek-tot-piekamplitude en die laat zien hoe sterk het geluid is, los van het gelijkspanningsniveau. 50 ms is een goed venster: één periode van 20 Hz, de laagste frequentie die het menselijk oor kan horen, is precies 50 ms, dus zelfs het diepste geluid past met één volledige golf in het venster. De Uno neemt in die tijd zo'n 450–500 samples.
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}Open na het uploaden van de sketch de Serial Plotter via het menu Tools en stel de snelheid in op 115200. In een stille kamer blijft p2p meestal tussen 0 en 3; het stijgt met een paar eenheden als je naast de microfoon praat en met tientallen eenheden als je dichtbij klapt. De waarde ortalama_avg is het gelijkspanningsniveau van AO; omdat die de schaal van de grafiek oprekt, kun je de twee regels met ortalama_avg verwijderen als je p2p comfortabel wilt volgen. Op sommige boards verschuift de potmeter ook dit gelijkspanningsniveau; als het gemiddelde vastzit op 0 of 1023, clipt het signaal, dus draai de potmeter tot de waarde bijna in het midden zit. Ben je nieuw met de Serial Plotter, bekijk dan Arduino Serial Monitor.
Stap voor stap: een lamp schakelen met een dubbele klap
De klaplamp is het bekendste geluidssensorproject, maar een schakeling die op één klap werkt, reageert ook op een dichtslaande deur, een gevallen boek of een kuchje, waardoor de lamp steeds aan en uit flikkert. De oplossing is zoeken naar een ritme: de onderstaande sketch reageert alleen op precies twee klappen die 0,12 tot 0,7 seconden uit elkaar liggen. Eén enkel geluid, of drie of meer geluiden (muziek, applaus, een blaffende hond), wordt genegeerd.
- Sluit de +-pin van de KY-038 aan op 5V, G op GND en DO op D2.
- Sluit de VCC-pin van de relaismodule aan op 5V, GND op GND en IN op D7. Hoe een relais werkt en hoe je de belastingkant bedraadt, vind je in Wat is een relaismodule?; doe je eerste tests met de eigen led van het relais in plaats van een lamp.
- Upload de sketch en open de Serial Monitor op 9600 baud.
- Klap twee keer van een of twee meter afstand. Je zou per klap maar één regel "Alkis / Clap" moeten zien; als één klap meer dan eens wordt geteld, draai de potmeter dan iets naar minder gevoelig.
- Zie hoe de lamp ongeveer 0,7 seconden na de tweede klap van toestand verandert.
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}| Constante | Waarde | Doel |
|---|---|---|
| SOUND_ACTIVE | HIGH | Het niveau dat DO heeft bij geluid; zet op LOW als je board geïnverteerd is |
| QUIET_GAP_MS | 120 ms | De stilte die nodig is voordat een nieuwe klap wordt geteld; de pulsenreeks en echo van een klap tellen als één klap |
| CLAP_WINDOW_MS | 700 ms | Na zoveel stilte sinds het laatste geluid wordt de reeks als afgelopen beschouwd en worden de klappen beoordeeld |
| LOCKOUT_MS | 1000 ms | Nadat de lamp is omgeschakeld worden geluiden genegeerd, zodat de klik van het relais niet voor een nieuwe klap wordt aangezien |
| RELAY_ON / RELAY_OFF | LOW / HIGH | Voor een relaismodule die actief-LOW is; verwissel ze op een board dat actief-HIGH is |
De sketch gebruikt geen delay(); alles wordt gemeten met millis(), zodat de timing van de klappen nooit gemist wordt. Deze aanpak leggen we uitgebreid uit in millis versus delay. Dat de lamp 0,7 seconden na de tweede klap schakelt in plaats van meteen, is een bewuste keuze: de sketch wacht of er een derde klap komt. Wil je een snellere reactie, dan kun je CLAP_WINDOW_MS verlagen naar 400–500 ms, maar dan moet je sneller klappen. Als je kamer erg galmt en één klap twee keer wordt geteld, verhoog dan QUIET_GAP_MS naar 150–200 ms.
Geluidsniveaubalk: een VU-meter met 8 leds
De piek-tot-piekwaarde rechtstreeks naar de leds sturen werkt, maar ziet er niet natuurlijk uit, omdat ons oor geluid logaritmisch waarneemt: een geluid met dubbele amplitude lijkt niet twee keer zo hard. Daarom wordt geluid gemeten in decibel (dB). Voor amplitude is de formule dB = 20 × log10(p2p / referentie); dubbele amplitude is +6 dB en tien keer zoveel is +20 dB. De onderstaande sketch meet bij het opstarten een seconde lang de ruisvloer van de kamer en gebruikt die als referentie; elke led staat voor 3 dB boven die vloer. Sluit de leds aan op pin D3–D10, elk met een weerstand van 220 Ω; voor leds van andere kleuren vind je de juiste weerstand met de ledweerstandcalculator.
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}Blijf bij het opstarten een seconde stil; als je in die tijd praat, wordt de vloer te hoog gemeten en reageert de balk minder. De balk stijgt direct maar daalt langzaam, één led per 80 ms; daarom zien echte VU-meters er vloeiend uit in plaats van schokkerig. Omdat het analoge signaal van de KY-038 zwak is, past 2–3 dB per led goed; als je dezelfde sketch gebruikt met een versterkte microfoon zoals de MAX4466, kun je DB_PER_LED verhogen naar 4–6 dB. Voor een kleurrijke weergave kun je een NeoPixel-ring gebruiken in plaats van leds; de details staan in WS2812B NeoPixel-led.
Geluidssensor met de ESP32: klappen detecteren met een interrupt
De ADC van de ESP32 is 12-bits en geeft waarden van 0 tot 4095; over een bereik van 3,3 V is één stap ongeveer 0,8 mV, zo'n 6 keer fijner dan bij de Uno. Aan de andere kant is de ADC van de ESP32 ruisgevoeliger, dus de p2p-waarde in een stille kamer komt ook hoger uit; de relatieve dB-berekening vangt dit zelf op. In de onderstaande sketch is de DO-pin gekoppeld aan een interrupt: klappulsen worden niet gemist, zelfs niet terwijl loop() 50 ms bezig is met het meten van het geluidsniveau via AO. De interruptfunctie staat met IRAM_ATTR in RAM en is kort gehouden; de variabelen die zowel de interrupt als loop() gebruiken zijn volatile verklaard en beschermd met een kritieke sectie.
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}De sketch draait dezelfde dubbele-klaplogica als op de Uno, alleen binnen de interrupt, en print het geluidsniveau in dB ongeveer elke 50 ms. Sluit de IN-pin van de relaismodule aan op GPIO 26; sommige actief-LOW relaismodules op 5 V laten niet volledig los bij het HIGH-niveau van 3,3 V van de ESP32, kies in dat geval een module die met 3,3 V aan te sturen is. De echte kracht van de ESP32 is Wi-Fi: als het geluidsniveau een paar seconden boven een drempel blijft (bijvoorbeeld een huilende baby of een blaffende hond), kun je een melding naar je telefoon sturen. Gebruik daarvoor de methode uit ESP32 Telegram-bot en koppel hem met ESP32 MQTT en Home Assistant aan een domoticasysteem.
Geluidssensor met de Raspberry Pi Pico en MicroPython
Voed de module op de Raspberry Pi Pico vanaf de 3V3(OUT)-pin en sluit AO aan op GP26 en DO op GP15; zet in plaats van een lamp een led met een weerstand van 220 Ω op GP14. De ADC van de Pico is 12-bits, maar in MicroPython schaalt read_u16() de waarde naar 0–65535; daarom lijken de p2p-getallen veel groter dan op de Uno, terwijl de relatieve dB-berekening hetzelfde blijft. Met Pin.irq() stel je een interrupt in op de DO-pin.
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 = 0Als je de code in Thonny uitvoert, zie je de p2p- en dB-waarden in de Shell; open de Plotter via het menu View om ze als grafiek te volgen. Als de DO-uitgang van je board bij geluid LOW gaat, schrijf dan IRQ_FALLING in plaats van IRQ_RISING. Om het programma zelf te laten starten zodra de Pico stroom krijgt, sla je het bestand op de Pico op als main.py. Ben je nieuw met MicroPython, dan is MicroPython-basis een goed begin.
Kan een geluidssensor decibels meten?
Kort antwoord: nee. Online vind je genoeg sketches die met map() de piek-tot-piekwaarde van de KY-038 omzetten naar een bereik als 49–90 dB; dat zijn gokken, geen metingen. Om een echt geluidsdrukniveau (dB SPL) te meten heb je een microfoon met bekende gevoeligheid nodig en een systeem dat gekalibreerd is met een 94 dB-kalibrator, lineaire versterking van het signaal, een RMS-waarde berekend over een vaste tijd (125 ms bij fast, 1 s bij slow) en een A-weging-filter dat de gevoeligheid van het oor nabootst. Daarom worden geluidsmeters gebouwd volgens de norm IEC 61672.
De KY-038 voldoet aan geen van deze voorwaarden: de versterking van de print is onbekend, de gevoeligheid van microfooncapsules verschilt een paar dB van exemplaar tot exemplaar, de potmeter en de voedingsspanning veranderen het signaalniveau, en op de Uno worden alle normale geluiden samengeperst in een paar ADC-stappen. Het eerlijkste wat je kunt doen is een relatieve meting: zeggen dat het "nu 12 dB harder is dan in de stille kamer". Zelfs dat is ruim voldoende voor een geluidsalarm, een geluidsstoplicht voor in de klas of een VU-meter. Je kunt grof kalibreren door op één punt te vergelijken met een app op je telefoon, maar die kalibratie verliest zijn betekenis bij andere geluidsniveaus en op een ander board.
Alternatieven: MAX4466, MAX9814 en INMP441
| Module | Uitgang | Versterking | Decibelmeting | Geschikte boards |
|---|---|---|---|---|
| KY-038 / KY-037 | AO (ruw) + DO (drempel) | Geen | Nee | Alle |
| MAX4466 | Analoog, gecentreerd op VCC/2 | 25–125×, instelbaar | Alleen relatief | Alle |
| MAX9814 | Analoog, gecentreerd op 1,25 V, max 2 Vpp | 40 / 50 / 60 dB + automatische versterkingsregeling (AGC) | Nee, AGC comprimeert het niveau | Alle |
| INMP441 | Digitaal I2S, 24-bit | Niet nodig | Bij benadering dB SPL | ESP32, Pico (niet de Uno) |
| Kant-en-klare geluidsniveaumodule (bijv. DFRobot SEN0232) | Analoog, direct in dBA | In de fabriek gekalibreerd | Ja, 30–130 dBA, ±1,5 dB | Alle |
De MAX4466 combineert hetzelfde soort elektreetmicrofoon met een opamp met instelbare versterking. De uitgang zit in stilte op de helft van de voedingsspanning en geeft bij normale spraak dichtbij een signaal van honderden millivolts; het signaal van de KY-038 van een paar ADC-stappen wordt dus tientallen of zelfs honderden stappen. De sketches voor piek-tot-piek en de VU-meter in dit artikel werken zonder aanpassingen met de MAX4466. Wil je weten hoe de versterking wordt berekend, bekijk dan de opamp-versterkingscalculator en Wat is een opamp?. De module voeden vanaf de schonere 3.3V-pin van de Uno vermindert ruis. De MAX9814 gebruikt daarentegen automatische versterkingsregeling om zelfs verre spraak op een bruikbaar niveau te brengen; hij is geweldig voor opnemen en stemdetectie, maar omdat hij stille en luide omgevingen dichter bij elkaar brengt, is hij niet geschikt voor niveaumeting.
De INMP441 is helemaal niet analoog maar een digitale MEMS-microfoon: hij zet geluid intern om in 24-bits getallen en stuurt die over een I2S-bus, zodat ruis op de draden niet in de meting komt. Het grote voordeel is dat de fabrikant de gevoeligheid met een krappe tolerantie specificeert: een geluid van 94 dB SPL wordt gelezen als −26 dBFS. Als je de gemeten RMS-waarde omrekent naar dBFS en er 120 bij optelt, krijg je dus een benaderende dB SPL-waarde. I2S vereist een ESP32 of een Pico; de Arduino Uno heeft geen I2S-hardware. INMP441-hobbymodules zijn goedkoop en makkelijk te vinden, en de ICS-43434 en SPH0645 zijn vergelijkbare I2S-microfoons. Als je echt een nauwkeurige geluidsmeting nodig hebt, is de eenvoudigste weg een kant-en-klare geluidsniveaumodule met een A-gewogen, gekalibreerde uitgang; als je bijvoorbeeld de uitgangsspanning van de DFRobot SEN0232 met 50 vermenigvuldigt, krijg je direct de dBA-waarde.
Projectideeën met een geluidssensor
- Klaplamp: voeg een relaismodule toe aan de sketch voor de dubbele klap hierboven om je bureaulamp of een ledstrip te bedienen, en laat drie klappen een tweede apparaat schakelen.
- Geluidsstoplicht voor in de klas: een geluidsdisplay dat groene, gele en rode leds laat branden op basis van de relatieve dB-waarde; docenten vinden het geweldig.
- Baby- en huisdiermonitor: als het geluid langer dan 5 seconden hard blijft, laat je de ESP32 een Telegram-bericht naar je telefoon sturen.
- Geluidsgevoelige verlichting: een NeoPixel-ring of -strip die meepulseert op het ritme van de muziek.
- Detector voor kloppen op de deur: een opstelling die met een buzzer of led laat weten wanneer er wordt geklopt; om het kloppen als trilling in plaats van geluid op te pikken is de SW-420-trillingssensor ook een goede optie.
- Slimme-huisscenario's: combineer geluid met bewegings- en lichtsensoren om de lichten uit te doen als er niemand in de kamer is; voor ideeën zie Arduino-project voor een slim huis.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| De DO-led blijft de hele tijd aan | De drempel is te gevoelig of er is constant geluid (een ventilator, een koelkast) | Draai de potmeter in stilte tot de led uitgaat en verplaats de sensor weg van de geluidsbron |
| Er gebeurt niets als je klapt | De drempel is te hoog of DO zit op de verkeerde pin | Controleer eerst of de led op de print bij een klap flitst, controleer dan de draad en het pinnummer in de code |
| De teller loopt op in stilte en stopt bij geluid | De DO-uitgang van het board is actief-LOW | Stel SOUND_ACTIVE in op LOW; gebruik op de Pico IRQ_FALLING |
| analogRead blijft rond 500 en verandert 1–2 bij geluid | AO is onversterkt en er worden alleen losse metingen gedaan | Gebruik de piek-tot-piekmethode, breng het geluid dichterbij of stap over op een MAX4466 |
| AO is altijd 0 of 1023 | AO en DO zijn verwisseld of het gelijkspanningsniveau is naar de rand gedreven | Controleer de bedrading en breng het gemiddelde met de potmeter naar het midden |
| Eén klap wordt twee keer geteld | De kamer galmt of QUIET_GAP_MS is te kort | Stel QUIET_GAP_MS in op 150–200 ms en maak de drempel iets minder gevoelig |
| De lamp gaat uit zichzelf aan en uit | Relaisklik, dichtslaande deuren of muziek | Verhoog LOCKOUT_MS, verplaats de sensor weg van het relais en houd je aan de regel van de dubbele klap |
| Op de ESP32 stopt AO met lezen als Wi-Fi aan staat | AO zit op een ADC2-pin | Verplaats AO naar een ADC1-pin tussen GPIO 32 en 39 |
Met een paar draden en goed geschreven code leert de KY-038 je veel basisprincipes van elektronica tegelijk: comparators, analoog-naar-digitaalomzetting, interrupts, timing en decibelrekenen. Begin met het detecteren van klappen met DO, meet het geluidsniveau met de piek-tot-piekmethode en stap over op een MAX4466 of INMP441 als je echt geluid wilt meten. In de BlueGrays-app vind je projecten met relaislamp, lopende led, slimme ESP32-verlichting en NeoPixel-strip met schakelschema's en stap-voor-stapcode; een geluidssensor toevoegen is de makkelijkste manier om ze om te vormen tot systemen die op klappen of geluid reageren.
Veelgestelde vragen
Hoe werkt een Arduino-geluidssensor?
De geluidssensor gebruikt een LM393-comparator om de kleine spanning van zijn elektreetmicrofoon te vergelijken met een drempel die door de potmeter wordt ingesteld. Als het geluid de drempel overschrijdt, verandert de DO-pin van toestand en gaat de led op de print branden. De AO-pin geeft het ruwe, onversterkte signaal van de microfoon, dat je leest met analogRead().
Wat is het verschil tussen de KY-038 en de KY-037?
Beide gebruiken dezelfde LM393-schakeling en dezelfde pinvolgorde AO, G, +, DO, en de code is identiek. De KY-037 heeft een grotere microfooncapsule en is meestal iets gevoeliger; de KY-038 is kleiner en vaker te vinden in sensorkits.
Hoe stel je de gevoeligheid van een geluidssensor in?
Draai in stilte de blauwe potmeter naar het punt waar de DO-led flikkert en draai hem dan een halve tot een hele slag terug naar de kant waar de led uit blijft. Omdat het een meerslagenpotmeter is, kan het zijn dat je meerdere slagen moet draaien voordat je enige verandering ziet. Stel hem altijd af op de plek waar de sensor gebruikt wordt.
Kan een geluidssensor decibels meten?
De KY-038 en KY-037 kunnen geen echte decibels (dB SPL) meten: de versterking van de print en de gevoeligheid van de microfoon zijn onbekend en er is geen kalibratie of A-weging. Je kunt alleen relatieve dB berekenen ten opzichte van een stille kamer. Gebruik voor echte metingen een I2S-microfoon met bekende gevoeligheid zoals de INMP441, of een gekalibreerde geluidsniveaumodule.
Waarom verandert de analoge waarde van mijn geluidssensor niet?
De AO-uitgang is het onversterkte microfoonsignaal en bij normale geluiden is dat kleiner dan één ADC-stap van 4,9 mV op de Uno. Bovendien leest één analogRead() een willekeurig moment van de geluidsgolf. Neem 50 ms lang samples en bereken het verschil tussen de grootste en kleinste waarde (piek-tot-piek), dan zie je de verandering duidelijk.
Werkt de geluidssensor met de ESP32 en de Raspberry Pi Pico?
Ja, de module werkt ook op 3,3 V; voed hem op de ESP32 en Pico vanaf de 3V3-pin zodat de DO-uitgang nooit boven 3,3 V komt. Sluit op de ESP32 AO aan op een ADC1-pin (GPIO 32–39), die niet botst met Wi-Fi, en op de Pico op GP26, GP27 of GP28.
Projecten om hierna te bouwen
Alle projecten bekijken
LED schakelen met een knop (aan/uit)
Druk één keer op de knop en het licht gaat aan, druk nog een keer en het gaat uit, net als de lichtschakelaar in je kamer. De Arduino merkt elke druk op en zet de led in de tegenovergestelde toestand.

ESP32-ledbesturing met drukknop (Toggle)
Elke keer dat je op de knop drukt, verandert de led van stand: is hij aan, dan gaat hij uit; is hij uit, dan gaat hij aan. Het klassieke togglepatroon. Met debounce filteren we de mechanische ruis van de drukknop weg, zodat één druk precies één wisseling geeft.

LED-looplicht
Lichten die na elkaar aangaan, alsof ze rennen. De Arduino laat zes LED's een voor een branden; elke LED licht even op en gaat uit, zodat het licht van begin tot eind loopt en dan opnieuw begint.

230V-lamp laten branden met een knop (aan/uit)
Wil je een echte lamp uit huis met een klein knopje aan- en uitzetten? Elke keer dat je op de knop drukt, schakelt de Arduino een relais om en gaat de lamp aan; druk je nog een keer, dan gaat hij uit.

Raspberry Pi Pico: led aan/uit met een knop (toggle)
Knop + led, een niveau hoger! Je hoeft de knop niet ingedrukt te houden. Indrukken en loslaten → led aan. Nog een keer → led uit (toggle). Dezelfde schakeling (led GP14, knop GP2), maar andere code. Je leert edge detection (het moment van 1→0 vastleggen), toestand bijhouden en debounce (filter tegen contactdender). led.toggle() van MicroPython wisselt de toestand in één regel. De basis van interactieve knopprojecten.

ESP32 slimme verlichting (PIR + LDR + relais + OLED)
Met een ESP32, een PIR-bewegingssensor, een LDR-lichtsensor en een relaismodule maak je van je gang, toilet of bijkeuken slimme verlichting. Is het al licht in de ruimte, dan blijft het licht uit, ook bij beweging, zodat overdag geen energie wordt verspild. Het licht blijft 30 seconden aan en de tijd verlengt automatisch zolang er beweging is.

ESP32 parkeersensor (HC-SR04 + 5-ledbalk + buzzer + OLED)
De ESP32-versie van een parkeersensor voor auto's! De HC-SR04-ultrasoonsensor meet de afstand tot het voorwerp ervoor. Naarmate je dichterbij komt, vult een balk van 5 leds zich (groen → geel → rood) en piept de buzzer sneller. Heel dichtbij (onder 10 cm) klinkt een continu alarm en branden alle leds. Het SSD1306 OLED-display toont de live afstand in cm in grote tekst, plus een statusbericht.

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.
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

