Componenten · 10 min leestijd

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.

ESP32-ontwikkelboard om de INMP441-microfoon uit te lezen
Om de INMP441 uit te lezen heb je een board met I2S-hardware nodig; de ESP32 heeft twee I2S-eenheden en de signalen kunnen naar elke gewenste GPIO worden gerouteerd.

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.

EigenschapWaarde
TypeMEMS, omnidirectionele microfoon met digitale uitgang
InterfaceI2S, 24-bit, MSB eerst, two's complement
Voeding1,8–3,3 V
StroomOngeveer 1,4 mA
Gevoeligheid−26 dBFS (1 kHz, 94 dB SPL)
Signaal-ruisverhouding (SNR)61 dBA
Frequentierespons60 Hz – 15 kHz
Akoestisch overbelastingspunt (AOP)120 dB SPL
SCK-frequentieOngeveer 0,5–3,2 MHz (bemonstering ongeveer 7,8–50 kHz)
ModulepinnenVDD, 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-pinFunctie
VDDVoeding, 1,8–3,3 V
GNDMassa
SCKIngang voor de bitklok (komt van het board)
WSIngang voor de kanaalkeuzeklok (komt van het board)
SDSeriële audiodata-uitgang (van de microfoon naar het board)
L/RKanaalkeuze: GND = linkerkanaal, VDD = rechterkanaal

INMP441-bedrading: ESP32 en Raspberry Pi Pico

INMP441-pinESP32Raspberry Pi Pico
VDD3V33V3(OUT) (pin 36)
GNDGNDGND
SCKGPIO 32GP16
WSGPIO 25GP17
SDGPIO 33GP18
L/RGNDGND
Sluit de INMP441 nooit aan op 5 V; de absolute maximale voedingsspanning is ongeveer 3,6 V en 5 V kan de microfoon blijvend beschadigen. Om dezelfde reden zijn de Arduino Uno en Nano niet geschikt voor deze module: ze hebben geen I2S-hardware, werken met 5V-logica en 2 KB RAM is niet genoeg voor een audiobuffer. De tweede veelgemaakte fout is de L/R-pin zwevend laten; een zwevende pin maakt het kanaal onbepaald en de metingen zijn dan nul of willekeurig.

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

  1. 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?.
  2. Steek de module in het breadboard; verbind VDD met 3V3, GND met GND en L/R met GND.
  3. Verbind SCK met GPIO 32, WS met GPIO 25 en SD met GPIO 33 en houd de draden kort.
  4. 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.
  5. 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.
  6. 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.

C++ (Arduino IDE)
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}
CodedeelWat het doet
SAMPLE_RATE = 16000Neemt 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 bitDe 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_LEFTAlleen het linkerkanaal wordt gelezen; omdat de L/R-pin met GND is verbonden, gebruikt de microfoon het linkerslot.
samples[i] >>= 8Haalt de 24-bit meting uit het 32-bit slot; de waarde ligt tussen −8.388.608 en +8.388.607.
Het gemiddelde aftrekkenVerwijdert de kleine DC-offset in het signaal; anders valt de RMS groter uit dan hij zou moeten zijn.
rmsDe wortel uit het gemiddelde van de gekwadrateerde samples; dit vertegenwoordigt het gemiddelde vermogen van het geluid.
dbfs + DB_OFFSETZet 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.

GeluidsbronCa. dB SPLdBFS op de INMP441
Eigen ruisvloer van de microfoon33−87
Stille kamer40−80
Normaal gesprek (1 m)60−60
Druk verkeer, stofzuiger70–80−50 tot −40
Risico op gehoorschade bij langdurige blootstelling85−35
Meetreferentie (kalibrator)94−26
Boormachine, voor een concertpodium100–110−20 tot −10
Bovengrens van de microfoon (AOP)1200
Deze formule berust alleen op de waarde uit de datasheet; de gevoeligheid kan van microfoon tot microfoon ±1 dB afwijken en de berekening is niet A-gewogen. Voor een nauwkeuriger resultaat meet je een constant geluid (bijvoorbeeld een toon van 1 kHz) tegelijk met de INMP441 en met een geluidsniveaumeter of een dB-app op je telefoon, en tel je het verschil op bij of trek je het af van de 120 in de code. Om de waarden rustiger te maken, middel je de laatste metingen; het voortschrijdend gemiddelde uit sensordata filteren werkt hier ook.

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.

C++ (Arduino IDE)
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?.

MicroPython
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

Analoge geluidssensormodule KY-038
KY-038: een analoge geluidssensor met een elektretcapsule, een trimmer om de drempel in te stellen en een LM393-comparator.

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.

EigenschapINMP441KY-038
Type microfoonMEMS, digitale uitgangElektretcapsule, analoog
UitgangI2S, 24-bit samplesAO analoge spanning + DO-drempeluitgang
Voeding1,8–3,3 V3,3–5 V
Compatibele boardsESP32, Pico en boards met I2S-ondersteuningElk board, ook de Uno
GeluidskwaliteitGoed genoeg voor opname en analyse (60 Hz – 15 kHz)Alleen een ruw niveau
dB-metingMogelijk met de formuleNiet betrouwbaar
Typisch gebruikGeluidsmeter, audio-opname, FFT, spraakcommando'sKlapschakelaar, 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

SymptoomWaarschijnlijke oorzaakOplossing
De dB SPL-waarde blijft vast op ongeveer −15,5Er komt geen data van de SD-lijn, alle samples zijn 0Controleer 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 willekeurigSCK en WS zijn verwisseld of de draden zijn te langCorrigeer 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 opstartenDe oude driver/i2s.h is samen met het nieuwe stuurprogramma gebruikt op de 3.x-coreGebruik één stuurprogramma; de #if-structuur hier kiest automatisch het juiste
De dB-waarden wijken 10–20 dB af van de geluidsniveaumeterVerkeerde bitverschuiving, DC niet verwijderd of geen kalibratie gedaanStel de verschuiving in op 8 bits, trek het gemiddelde af en kalibreer met een constante toon
ValueError bij het aanmaken van I2S op de PicoDe WS-pin is niet één hoger dan de SCK-pinGebruik opeenvolgende pins zoals SCK = GP16, WS = GP17
De microfoon wordt heet of reageert helemaal nietVDD is op 5 V aangeslotenZet hem meteen op 3V3; de microfoon kan beschadigd zijn, probeer dus een nieuwe
De golfvorm ziet er hakkelig uit in de Serial PlotterDe seriële lijn kan geen 16.000 samples per seconde aanDit is normaal; voor een vloeiender beeld verhoog je de baudrate naar 921600
De snelste manier om de verbinding te testen is de dB-code te uploaden en zachtjes op de microfoon te blazen. Als de waarde rond de 40 blijft en boven de 90 uitkomt wanneer je blaast, is alles goed. Als de waarde niet verandert van rond −15,5, komt er geen data binnen; controleer de L/R- en SD-draden voordat je aan de code gaat sleutelen.

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.

Alle projecten bekijken
Led laten knipperen met ESP32
ES-1Beginner

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.

4.7(37)
107
Een buzzer gebruiken
AR-13Beginner

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.

4.7(92)
170
ESP32-led dimmen met PWM
ES-8Beginner

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.

4.8(36)
55
Melodie afspelen met een buzzer op de ESP32
ES-12Beginner
Premium

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

4.8(30)
55
ESP32 WS2812B NeoPixel-strip aansturen
ES-24Gemiddeld
Premium

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.

4.9(19)
30
ESP32 asynchrone webserver (met IP-weergave op lcd)
ES-27Gevorderd

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.

4.8(16)
26
ESP32 WebSocket-teller (2 knoppen + lcd + realtime web)
ES-28Gevorderd
Premium

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.

4.5(14)
23
ESP32 HTTPClient + weer-API (met SSD1306 OLED-display)
ES-32Gevorderd
Premium

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.

4.3(10)
22