INMP441 ESP32 I2S-microfoon: audio uitlezen, dB meten, plotten
Sluit de INMP441 I2S-microfoon aan op een ESP32: bedradingstabel, 24-bit audio via I2S, dB-niveau berekenen, golfvorm in de Serial Plotter en MicroPython-code voor de Pico.
De INMP441 is een kleine MEMS-microfoonmodule die geluid in de chip zelf omzet naar digitaal en 24-bit samples rechtstreeks over de I2S-bus verstuurt. De combinatie INMP441 ESP32 is de eenvoudigste manier om schone audio te krijgen zonder analoge microfoon, versterker of ADC. Je verbindt de module met zes draden met de ESP32, legt met een paar regels I2S-code 16.000 samples per seconde vast, berekent uit die samples het omgevingsgeluidsniveau in decibel (dB) en bekijkt de golfvorm van het geluid live in de Serial Plotter.
In deze gids zie je stap voor stap hoe de INMP441 werkt, wat de drie I2S-lijnen doen, kant-en-klare code die compileert op zowel de 2.x- als de 3.x-ESP32-Arduino-core, het verschil tussen dBFS en dB SPL en de formule van een echte geluidsniveaumeter. Aan het eind vind je ook MicroPython op de Raspberry Pi Pico, het verschil met de goedkope analoge KY-038-geluidssensor en de meest gemaakte bedradingsfouten.

Wat is de INMP441 en hoe werkt hij?
De INMP441 is een omnidirectionele MEMS-microfoon van TDK InvenSense. MEMS betekent hier een piepkleine condensator van een microscopisch klein membraan en een vaste plaat, in silicium geëtst: wanneer geluidsgolven het membraan laten trillen, verandert de capaciteit. Een klassieke elektretmicrofoon geeft deze verandering af als een zwakke analoge spanning, die je moet versterken, filteren en met een ADC moet meten. In de INMP441 zijn echter een voorversterker, een anti-aliasingfilter, een 24-bit sigma-delta-ADC en de I2S-interface samengebracht. Wat uit de microfoon komt is dus geen spanning meer, maar getallen die een kloksignaal volgen. Zo wordt er geen analoge ruis opgepikt op de draden, doet de kwaliteit van de ADC van je board er niet meer toe en krijgt elke geschikte 3,3 V-microcontroller dezelfde geluidskwaliteit. Het kleine gaatje op de module is de geluidsopening van de microfoon; zorg dat je hem niet afdekt als je het board in een behuizing monteert.
| Eigenschap | Waarde |
|---|---|
| Type | MEMS, omnidirectionele microfoon met digitale uitgang |
| Interface | I2S, 24-bit, MSB eerst, two's complement |
| Voeding | 1,8–3,3 V |
| Stroom | Ongeveer 1,4 mA |
| Gevoeligheid | −26 dBFS (1 kHz, 94 dB SPL) |
| Signaal-ruisverhouding (SNR) | 61 dBA |
| Frequentierespons | 60 Hz – 15 kHz |
| Akoestisch overbelastingspunt (AOP) | 120 dB SPL |
| SCK-frequentie | Ongeveer 0,5–3,2 MHz (bemonstering ongeveer 7,8–50 kHz) |
| Modulepinnen | VDD, GND, SD, L/R, WS, SCK |
Wat is I2S? Digitale audio via drie lijnen
I2S (Inter-IC Sound) is een seriële bus die is ontworpen om audiosamples tussen chips te vervoeren en heeft ondanks de gelijkaardige naam niets met I2C te maken. Er zijn drie lijnen: SCK (bitklok) geeft aan wanneer elk databit gelezen moet worden, WS (word select, ook LRCLK genoemd) geeft aan of op dat moment het linker- of rechterkanaal wordt verstuurd en SD is de data zelf. In deze opstelling is de ESP32 de master: hij genereert beide klokken en de microfoon volgt de klok en zet data op de SD-lijn. Bij de INMP441 bestaat elk frame uit 64 SCK-pulsen: 32 bits voor het linkerkanaal en 32 bits voor het rechter. Daarom is de samplefrequentie SCK / 64; voor bemonstering op 16 kHz genereert de ESP32 een bitklok van ongeveer 1,024 MHz. De microfoon schrijft zijn 24-bit meting, MSB eerst, in het 32-bit slot van zijn eigen kanaal; de overige 8 bits zijn nul. Daarom schuift de code de waarde 8 bits naar rechts.
| INMP441-pin | Functie |
|---|---|
| VDD | Voeding, 1,8–3,3 V |
| GND | Massa |
| SCK | Ingang voor de bitklok (komt van het board) |
| WS | Ingang voor de kanaalkeuzeklok (komt van het board) |
| SD | Seriële audiodata-uitgang (van de microfoon naar het board) |
| L/R | Kanaalkeuze: GND = linkerkanaal, VDD = rechterkanaal |
INMP441-bedrading: ESP32 en Raspberry Pi Pico
| INMP441-pin | ESP32 | Raspberry Pi Pico |
|---|---|---|
| VDD | 3V3 | 3V3(OUT) (pin 36) |
| GND | GND | GND |
| SCK | GPIO 32 | GP16 |
| WS | GPIO 25 | GP17 |
| SD | GPIO 33 | GP18 |
| L/R | GND | GND |
Op de ESP32 kunnen I2S-signalen via de GPIO-matrix naar elke pin worden gerouteerd; de nummers 32, 25 en 33 in de tabel zijn niet verplicht, maar veilige keuzes. Blijf alleen uit de buurt van de strapping-pins die het opstartgedrag bepalen (GPIO 0, 2, 5, 12, 15) en van GPIO 6–11, die voor het flashgeheugen zijn gereserveerd. GPIO 34–39 zijn alleen-ingang: ze zijn geschikt voor de SD-lijn, maar niet voor SCK en WS. Bij de Pico geldt een andere regel: het MicroPython-I2S-stuurprogramma gebruikt PIO en de WS-pin moet één hoger zijn dan de SCK-pin (bijvoorbeeld GP16 en GP17). Houd de draden korter dan 10–15 cm; een kloksignaal in het megahertzbereik wordt vervormd op lange jumperdraden. De pinindeling van je board kun je bekijken in de pinout-tool.
Stap voor stap: je eerste audiometing met de ESP32
- Zorg dat het ESP32-boardpakket in de Arduino IDE is geïnstalleerd en kies ESP32 Dev Module onder Tools > Board. Als je niet weet hoe je dat installeert, lees dan Wat is ESP32?.
- Steek de module in het breadboard; verbind VDD met 3V3, GND met GND en L/R met GND.
- Verbind SCK met GPIO 32, WS met GPIO 25 en SD met GPIO 33 en houd de draden kort.
- Upload de onderstaande code. Er is geen extra bibliotheek nodig: ESP_I2S op de 3.x-core en driver/i2s.h op de 2.x-core zitten al in het boardpakket.
- Open de Serial Monitor op 115200 baud; in een stille kamer zie je waarden van ongeveer 35–50 dB en tijdens het praten rond 55–70 dB.
- Open Tools > Serial Plotter om de dBFS- en dB SPL-curves live te bekijken; klap naast de microfoon en zie de curve omhoogspringen.
ESP32-code: geluidsniveau (dB) meten met de INMP441
De code controleert de versie van de ESP32-Arduino-core met ESP_ARDUINO_VERSION_MAJOR. Op versie 3.x gebruikt hij de nieuwe ESP_I2S-bibliotheek en op 2.x het klassieke I2S-stuurprogramma van ESP-IDF. Beide paden leveren dezelfde functies micBegin() en micRead(), dus de berekening in loop() verandert niet. Elke lus leest 512 samples, dat is 32 ms audio op 16 kHz, verwijdert de DC-offset, bepaalt de RMS-waarde en zet die om naar decibel.
1// INMP441 + ESP32: ses seviyesi (dB) olcer / sound level (dB) meter
2// ESP32 Arduino core 2.x ve 3.x / ESP32 Arduino core 2.x and 3.x
3#include <Arduino.h>
4#include <math.h>
5
6#define MIC_SCK 32 // INMP441 SCK
7#define MIC_WS 25 // INMP441 WS
8#define MIC_SD 33 // INMP441 SD
9
10const uint32_t SAMPLE_RATE = 16000; // ornekleme hizi / sample rate
11const size_t BLOCK = 512; // blok basina ornek / samples per block
12const double FS_RMS = 5931642.0; // 8388608 / sqrt(2): tam olcek sinus RMS / full-scale sine RMS
13const double DB_OFFSET = 120.0; // 94 dB SPL - (-26 dBFS)
14
15int32_t samples[BLOCK];
16
17#if ESP_ARDUINO_VERSION_MAJOR >= 3
18#include <ESP_I2S.h>
19I2SClass i2s;
20
21bool micBegin() {
22 i2s.setPins(MIC_SCK, MIC_WS, -1, MIC_SD); // bclk, ws, dout (yok / none), din
23 return i2s.begin(I2S_MODE_STD, SAMPLE_RATE, I2S_DATA_BIT_WIDTH_32BIT,
24 I2S_SLOT_MODE_MONO, I2S_STD_SLOT_LEFT); // L/R = GND -> sol / left
25}
26
27size_t micRead(int32_t *buf, size_t count) {
28 size_t bytes = i2s.readBytes((char *)buf, count * sizeof(int32_t));
29 return bytes / sizeof(int32_t);
30}
31#else
32#include <driver/i2s.h>
33
34bool micBegin() {
35 i2s_config_t cfg = {};
36 cfg.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX); // ana cihaz, alici / master, receiver
37 cfg.sample_rate = SAMPLE_RATE;
38 cfg.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT;
39 cfg.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT; // L/R = GND -> sol / left
40 cfg.communication_format = I2S_COMM_FORMAT_STAND_I2S;
41 cfg.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1;
42 cfg.dma_buf_count = 4;
43 cfg.dma_buf_len = 256;
44 cfg.use_apll = false;
45
46 i2s_pin_config_t pins = {};
47 pins.mck_io_num = I2S_PIN_NO_CHANGE;
48 pins.bck_io_num = MIC_SCK;
49 pins.ws_io_num = MIC_WS;
50 pins.data_out_num = I2S_PIN_NO_CHANGE;
51 pins.data_in_num = MIC_SD;
52
53 if (i2s_driver_install(I2S_NUM_0, &cfg, 0, NULL) != ESP_OK) return false;
54 return i2s_set_pin(I2S_NUM_0, &pins) == ESP_OK;
55}
56
57size_t micRead(int32_t *buf, size_t count) {
58 size_t bytes = 0;
59 i2s_read(I2S_NUM_0, buf, count * sizeof(int32_t), &bytes, portMAX_DELAY);
60 return bytes / sizeof(int32_t);
61}
62#endif
63
64void setup() {
65 Serial.begin(115200);
66 if (!micBegin()) {
67 Serial.println("I2S baslatilamadi / I2S init failed");
68 while (true) delay(1000);
69 }
70}
71
72void loop() {
73 size_t n = micRead(samples, BLOCK);
74 if (n == 0) return;
75
76 double sum = 0;
77 for (size_t i = 0; i < n; i++) {
78 samples[i] >>= 8; // 32 bit yuvadan 24 bit veri / 24-bit data from 32-bit slot
79 sum += samples[i];
80 }
81 double mean = sum / n; // DC kaymasi / DC offset
82
83 double sq = 0;
84 for (size_t i = 0; i < n; i++) {
85 double v = (double)samples[i] - mean;
86 sq += v * v;
87 }
88 double rms = sqrt(sq / n);
89 if (rms < 1.0) rms = 1.0; // log10(0) olmasin / avoid log10(0)
90
91 double dbfs = 20.0 * log10(rms / FS_RMS);
92 double spl = dbfs + DB_OFFSET;
93
94 Serial.print("dBFS:");
95 Serial.print(dbfs, 1);
96 Serial.print(" dB_SPL:");
97 Serial.println(spl, 1);
98}| Codedeel | Wat het doet |
|---|---|
| SAMPLE_RATE = 16000 | Neemt 16.000 samples per seconde; de SCK-frequentie wordt 16.000 × 64 = 1,024 MHz. Dat is genoeg voor spraak; voor muziek kun je 44.100 kiezen (SCK ongeveer 2,82 MHz). |
| Databreedte van 32 bit | De INMP441 verwacht 64 SCK-pulsen per WS-frame; als je 16 bits kiest, wordt het frame korter en wordt de data betekenisloos. |
| MONO + LEFT / ONLY_LEFT | Alleen het linkerkanaal wordt gelezen; omdat de L/R-pin met GND is verbonden, gebruikt de microfoon het linkerslot. |
| samples[i] >>= 8 | Haalt de 24-bit meting uit het 32-bit slot; de waarde ligt tussen −8.388.608 en +8.388.607. |
| Het gemiddelde aftrekken | Verwijdert de kleine DC-offset in het signaal; anders valt de RMS groter uit dan hij zou moeten zijn. |
| rms | De wortel uit het gemiddelde van de gekwadrateerde samples; dit vertegenwoordigt het gemiddelde vermogen van het geluid. |
| dbfs + DB_OFFSET | Zet het resultaat om naar dB SPL met de gevoeligheid uit de datasheet van −26 dBFS @ 94 dB SPL. |
Hoe wordt het geluidsniveau berekend? dBFS en dB SPL
Omdat de geluidsdruk over een heel groot bereik varieert, wordt de logaritmische decibelschaal gebruikt: een verdubbeling van de amplitude betekent ongeveer +6 dB en een tienvoudige amplitude +20 dB. De getallen van de microfoon worden eerst omgezet naar dBFS (decibel ten opzichte van full scale): dBFS = 20 × log10(RMS / full-scale-RMS). Full scale is de RMS van een sinus waarvan de piek de grootste 24-bit waarde bereikt, 8.388.608, dus 8.388.608 / √2 ≈ 5.931.642. Op deze schaal is 0 dBFS de clippinggrens van de microfoon en krijgt elk zachter geluid een negatieve waarde. Om bij de fysieke geluidsdruk, dB SPL, te komen, wordt de gevoeligheid uit de datasheet gebruikt: de INMP441 geeft een geluid van 1 kHz op 94 dB SPL af als −26 dBFS. Daaruit volgt de formule dB SPL = dBFS + 94 − (−26) = dBFS + 120. Als de RMS-waarde bijvoorbeeld 5.932 is, dan is dBFS = 20 × log10(0.001) = −60 en is het geluidsniveau ongeveer 60 dB SPL, het normale spraakniveau.
| Geluidsbron | Ca. dB SPL | dBFS op de INMP441 |
|---|---|---|
| Eigen ruisvloer van de microfoon | 33 | −87 |
| Stille kamer | 40 | −80 |
| Normaal gesprek (1 m) | 60 | −60 |
| Druk verkeer, stofzuiger | 70–80 | −50 tot −40 |
| Risico op gehoorschade bij langdurige blootstelling | 85 | −35 |
| Meetreferentie (kalibrator) | 94 | −26 |
| Boormachine, voor een concertpodium | 100–110 | −20 tot −10 |
| Bovengrens van de microfoon (AOP) | 120 | 0 |
De golfvorm plotten in de Serial Plotter
De decibelwaarde vertelt je hoe hard het geluid is; om de vorm van het geluid te zien, moet je de ruwe samples plotten. Vervang in dezelfde sketch alleen de functie loop() door die hieronder. Er is hier een belangrijke beperking: een seriële lijn van 115200 baud verwerkt ongeveer 11.500 tekens per seconde, wat niet genoeg is om 16.000 samples per seconde te printen. De code print dus een blok van 512 samples achter elkaar; geluid dat binnenkomt terwijl het blok wordt geprint, wordt gemist, maar elk fragment dat je in de plotter ziet is een aaneengesloten, echt stuk van 32 ms.
1// dB taslaginda loop() yerine bunu kullan / Use this instead of loop() in the dB sketch
2void loop() {
3 size_t n = micRead(samples, BLOCK);
4 for (size_t i = 0; i < n; i++) {
5 int32_t v = samples[i] >> 8; // 24 bit ham ornek / 24-bit raw sample
6 Serial.print("ses:");
7 Serial.println(v);
8 }
9}Als je in de microfoon fluit, zie je in de plotter een bijna gladde sinus. Bij een fluittoon van 1 kHz duurt één periode 1 ms en komt die overeen met 16 punten bij bemonstering op 16 kHz; door de punten in één periode te tellen, kun je de frequentie ruwweg schatten. Omdat spraak een mengsel van veel frequenties is, tekent het een onregelmatige golf met een omhullende; een klap geeft een korte, zeer hoge piek. Omdat de plotter zijn as automatisch schaalt, kunnen kleine ruisschommelingen in stilte groot lijken, wat normaal is. Voor details over het gebruik van de Serial Monitor en de Serial Plotter, zie het bericht Arduino Serial Monitor.
INMP441 met de Raspberry Pi Pico (MicroPython)
De Raspberry Pi Pico heeft geen speciale I2S-eenheid, maar zijn programmeerbare PIO-blokken emuleren I2S op hardwaresnelheid en de klasse machine.I2S van MicroPython doet het werk voor je. Je hoeft geen extra bestanden te installeren; een recente MicroPython-versie is genoeg. In de code kies je bits=32 en format=I2S.MONO, de gelezen samples worden opnieuw 8 bits naar rechts geschoven en met dezelfde formule omgezet naar decibel. Omdat Python-lussen trager zijn dan C, is een blokgrootte van 512 samples een goede balans; het missen van een paar milliseconden geluid tijdens de berekening heeft nauwelijks invloed op het resultaat. Als je de Pico programmeert met de Arduino IDE, doet de I2S-bibliotheek in de arduino-pico-core hetzelfde werk; ook daar moet de WS-pin (LRCLK) één hoger zijn dan de BCLK-pin. Ben je nieuw met MicroPython, bekijk dan eerst Wat is Raspberry Pi Pico?.
1from machine import Pin, I2S
2import array
3import math
4
5SCK_PIN = 16 # INMP441 SCK
6WS_PIN = 17 # INMP441 WS (SCK + 1 olmali / must be SCK + 1)
7SD_PIN = 18 # INMP441 SD
8
9FS_RMS = 5931642.0 # 8388608 / sqrt(2): tam olcek sinus RMS / full-scale sine RMS
10DB_OFFSET = 120.0 # 94 dB SPL - (-26 dBFS)
11LN10 = math.log(10)
12
13mic = I2S(0, sck=Pin(SCK_PIN), ws=Pin(WS_PIN), sd=Pin(SD_PIN),
14 mode=I2S.RX, bits=32, format=I2S.MONO,
15 rate=16000, ibuf=8192)
16
17samples = array.array('i', [0] * 512) # 32 bit ornek dizisi / 32-bit sample array
18
19while True:
20 n = mic.readinto(samples) // 4 # okunan ornek sayisi / number of samples read
21 if n == 0:
22 continue
23 total = 0
24 for i in range(n):
25 samples[i] >>= 8 # 24 bit degeri ayikla / extract 24-bit value
26 total += samples[i]
27 mean = total / n # DC kaymasi / DC offset
28 sq = 0.0
29 for i in range(n):
30 d = samples[i] - mean
31 sq += d * d
32 rms = max(math.sqrt(sq / n), 1.0)
33 dbfs = 20 * math.log(rms / FS_RMS) / LN10
34 print("dBFS: {:.1f} dB SPL: {:.1f}".format(dbfs, dbfs + DB_OFFSET))INMP441 versus de analoge geluidssensor KY-038

De KY-038 is een goedkope module met een elektretmicrofoon-capsule, een trimmer om de drempel in te stellen en een LM393-comparator. Zijn digitale uitgang (DO) verandert van toestand wanneer het geluid de ingestelde drempel overschrijdt; zijn analoge uitgang (AO) geeft de ruwe spanning van de capsule en wordt met de ADC van het board gelezen. Dit ontwerp is genoeg om klappen te detecteren of te zien of er geluid in de kamer is. Maar omdat de module geen versterker heeft, is het signaal erg zwak: de 10-bit ADC van de Arduino Uno ziet bij spraak maar een paar stappen verandering en de ADC van de ESP32 is ruisgevoelig. De INMP441 daarentegen meet in de microfoon zelf met 24 bits; omdat er geen analoge kabel, versterker of ADC tussen zit, legt hij een bereik van ongeveer 87 dB, van de ruisvloer tot de clippinggrens, schoon vast. Kortom: de KY-038 is een geluidsschakelaar, terwijl de INMP441 een echte microfoon is. De grenzen van analoog uitlezen vind je uitgebreid in de ADC-gids.
| Eigenschap | INMP441 | KY-038 |
|---|---|---|
| Type microfoon | MEMS, digitale uitgang | Elektretcapsule, analoog |
| Uitgang | I2S, 24-bit samples | AO analoge spanning + DO-drempeluitgang |
| Voeding | 1,8–3,3 V | 3,3–5 V |
| Compatibele boards | ESP32, Pico en boards met I2S-ondersteuning | Elk board, ook de Uno |
| Geluidskwaliteit | Goed genoeg voor opname en analyse (60 Hz – 15 kHz) | Alleen een ruw niveau |
| dB-meting | Mogelijk met de formule | Niet betrouwbaar |
| Typisch gebruik | Geluidsmeter, audio-opname, FFT, spraakcommando's | Klapschakelaar, alarm bij geluid wel/niet aanwezig |
Projectideeën met de INMP441
- Geluidsgevoelige leds: zet het geluidsniveau om in het aantal brandende leds op een WS2812B-strip; voor details zie de berichten geluidsgevoelige led en WS2812B NeoPixel.
- Lawaaistoplicht voor in de klas: bouw een waarschuwingslamp die groen brandt onder 55 dB, geel tussen 55–70 dB en rood daarboven.
- Live lawaaidashboard op het web: stuur de dB-waarde via WebSocket naar de browser en bekijk hem als grafiek op je telefoon; de basisstructuur staat in ESP32-webserver en WebSocket.
- Geluidssensor voor het slimme huis: stuur de metingen via MQTT naar Home Assistant; de gids ESP32 MQTT en Home Assistant maakt het makkelijker.
- Melding bij babygehuil of blaffende hond: als het geluid gedurende een bepaalde tijd de drempel overschrijdt, stuur je met een Telegram-bot een bericht naar je telefoon.
- Audiorecorder: schrijf de samples als 16-bit WAV-bestand naar een SD-kaartmodule en luister het af op je computer.
- Fluitbediening: bepaal met een FFT de dominante frequentie en activeer een led of relais bij een specifieke fluittoon.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| De dB SPL-waarde blijft vast op ongeveer −15,5 | Er komt geen data van de SD-lijn, alle samples zijn 0 | Controleer de SD-draad en of L/R met GND is verbonden; helpt dat niet, schakel het kanaal dan om naar rechts (I2S_STD_SLOT_RIGHT op 3.x, I2S_CHANNEL_FMT_ONLY_RIGHT op 2.x) |
| De waarde stijgt niet bij harder geluid, maar springt willekeurig | SCK en WS zijn verwisseld of de draden zijn te lang | Corrigeer de pins volgens de tabel en kort de draden in tot onder 10–15 cm |
| Foutmelding "CONFLICT! The new i2s driver can't work along with the legacy i2s driver" bij het opstarten | De oude driver/i2s.h is samen met het nieuwe stuurprogramma gebruikt op de 3.x-core | Gebruik één stuurprogramma; de #if-structuur hier kiest automatisch het juiste |
| De dB-waarden wijken 10–20 dB af van de geluidsniveaumeter | Verkeerde bitverschuiving, DC niet verwijderd of geen kalibratie gedaan | Stel de verschuiving in op 8 bits, trek het gemiddelde af en kalibreer met een constante toon |
| ValueError bij het aanmaken van I2S op de Pico | De WS-pin is niet één hoger dan de SCK-pin | Gebruik opeenvolgende pins zoals SCK = GP16, WS = GP17 |
| De microfoon wordt heet of reageert helemaal niet | VDD is op 5 V aangesloten | Zet hem meteen op 3V3; de microfoon kan beschadigd zijn, probeer dus een nieuwe |
| De golfvorm ziet er hakkelig uit in de Serial Plotter | De seriële lijn kan geen 16.000 samples per seconde aan | Dit is normaal; voor een vloeiender beeld verhoog je de baudrate naar 921600 |
Met een paar draden en een korte sketch geeft de INMP441 je ESP32 een echte digitale microfoon; hij is de basis van veel projecten, van het meten van geluidsniveau tot geluidsgevoelige verlichting. Wil je geluid als getallen verwerken in plaats van genoegen te nemen met een analoge sensor, dan is hij de eerste keuze. In de BlueGrays-app kun je stap voor stap schakelschema's en code volgen voor ESP32-projecten met leds, buzzers, WS2812B-strips en webservers en deze microfoon er makkelijk aan toevoegen.
Veelgestelde vragen
Werkt de INMP441 met een Arduino Uno?
Nee, in de praktijk niet. De Arduino Uno en Nano hebben geen I2S-hardware, werken met 5V-logica en 2 KB RAM is niet genoeg voor een audiobuffer. Voor de INMP441 gebruik je een ESP32, ESP32-S3, Raspberry Pi Pico of een ander 3,3 V-board met I2S-ondersteuning.
Wat doet de L/R-pin van de INMP441?
De L/R-pin bepaalt welk kanaal van het stereoframe de microfoon gebruikt: links als hij met GND is verbonden, rechts als hij met 3,3 V is verbonden. Als je de SCK-, WS- en SD-lijnen van twee INMP441's aan elkaar koppelt en de ene op links en de andere op rechts zet, krijg je stereo-audio over één I2S-bus. Laat de pin niet zweven; de metingen zijn dan nul of instabiel.
Kun je audio opnemen met de INMP441?
Ja. Als je de 24-bit samples terugbrengt naar 16 bits en met een WAV-header naar een SD-kaart schrijft, krijg je een opname die je op je computer kunt afspelen. Bemonstering op 16 kHz is genoeg voor spraak; een minuut 16-bit mono-opname neemt ongeveer 1,9 MB in beslag.
Hoe nauwkeurig is dB-meting met de INMP441?
Een berekening met de gevoeligheid uit de datasheet van −26 dBFS geeft ook zonder kalibratie resultaten binnen enkele dB; de tolerantie van de microfoongevoeligheid is ±1 dB. Omdat de berekening niet A-gewogen is, kan hij in omgevingen met veel laagfrequent gebrom hoger aangeven dan een geluidsniveaumeter. Als je hem kalibreert met een bekende geluidsbron, krijg je heel goede resultaten voor kamerlawaai, maar hij vervangt geen officieel meetinstrument.
Moet ik de INMP441 of de KY-038 kopen?
Als je alleen een klap of hard geluid wilt detecteren en iets wilt activeren, is de KY-038 genoeg en werkt hij met elk board. Als je het geluidsniveau in dB wilt meten, audio wilt opnemen, frequentieanalyse wilt doen of geluidsgevoelige verlichting wilt bouwen, geeft de INMP441 veel schonere en nauwkeurigere resultaten.
Waarom leest de INMP441 op de ESP32 altijd 0?
De meest voorkomende oorzaken zijn een zwevende L/R-pin, een kanaal in de code dat niet overeenkomt met de instelling van de microfoon en de SD-draad die op de verkeerde pin zit. Verbind eerst L/R met GND en probeer daarna het kanaal in de code om te schakelen naar rechts. Controleer ook of de bitbreedte 32 bits is en de module via 3V3 wordt gevoed.
Projecten om hierna te bouwen
Alle projecten bekijken
Led laten knipperen met ESP32
Leert je het basisgebruik van een GPIO-uitgang met de ESP32. Door een led via een digitale pin aan en uit te zetten krijgen we een knippereffect. Dit is de ESP32-versie van het klassieke blinkproject op de Arduino UNO; de basiscommando's in de Arduino-omgeving zijn hetzelfde, maar de pinindeling en de 3,3 V-GPIO-niveaus van de ESP32 verschillen van die van de Arduino UNO.

Een buzzer gebruiken
Heb je je ooit afgevraagd hoe een deurbel of alarm geluid maakt? De Arduino laat een kleine buzzer met korte tussenpozen piepen: piep, pauze, piep, pauze.

ESP32-led dimmen met PWM
De helderheid van de led soepel veranderen van 0 naar max en van max naar 0. We sturen PWM aan met analogWrite() zoals bij Arduino; dezelfde syntaxis werkt zonder problemen met ESP32 Arduino Core 3.0+. Een pindefinitie, pinMode en analogWrite zijn genoeg.

Melodie afspelen met een buzzer op de ESP32
Een eenvoudige melodie (Twinkle Twinkle Little Star) afspelen met een passieve buzzer. Net als op Arduino speel je noten met de functies tone() en noTone(); met ESP32 Arduino Core 3.0+ werkt dezelfde syntaxis. Je moet een passieve buzzer gebruiken (een actieve buzzer speelt geen melodie).

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.

ESP32 asynchrone webserver (met IP-weergave op lcd)
In dit project maken we van de ESP32 een asynchrone webserver die je met je telefoon of computer op hetzelfde wifinetwerk kunt bedienen. Dankzij de ESPAsyncWebServer-bibliotheek kan de server meerdere verzoeken tegelijk verwerken (anders dan de klassieke WebServer.h, die bij één verzoek blokkeert). Je opent het IP-adres van de ESP32 in een browser en klikt op de knoppen ON/OFF (de routes /on en /off) om de led op GPIO 5 aan en uit te zetten.

ESP32 WebSocket-teller (2 knoppen + lcd + realtime web)
In dit project verandert een teller met twee knoppen op de ESP32 (GPIO 5 telt op, GPIO 4 telt af). De waarde wordt direct bijgewerkt op een 16x2 I2C-lcd en, via de WebSocket-ondersteuning van ESPAsyncWebServer, in elke verbonden browser zonder de pagina te herladen. In plaats van HTTP-polling wordt één blijvende verbinding gebruikt en de ESP32 stuurt de nieuwe waarde met ws.textAll() naar iedereen.

ESP32 HTTPClient + weer-API (met SSD1306 OLED-display)
In dit project doet de ESP32 via internet een REST API-aanroep naar een weer-API (wttr.in) met HTTPClient.h. Anders dan bij de I2C-LCD-versie gebruiken we hier een SSD1306 OLED-display (128×64), met grote tekst en vectoricoontjes voor een rijkere weergave. Zeven weericonen (zonnig, regenachtig, sneeuw en meer) worden direct getekend, zonder bitmapbestanden.
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

