INMP441 ESP32 I2S Mikrofon: Audio lesen, dB messen, Wellenform

Das INMP441 ist ein kleines MEMS-Mikrofonmodul, das den Schall intern digitalisiert und über den I2S-Bus direkt 24-Bit-Samples sendet. Die Kombination INMP441 ESP32 ist der einfachste Weg zu sauberem Audio, ohne analoges Mikrofon, Verstärker und ADC. Du schließt das Modul mit sechs Kabeln an den ESP32 an, holst mit ein paar Zeilen I2S-Code 16 000 Samples pro Sekunde ab, berechnest daraus den Lautstärkepegel der Umgebung in Dezibel (dB) und verfolgst die Wellenform live im Serial Plotter.

In dieser Anleitung siehst du Schritt für Schritt, wie das INMP441 funktioniert, wofür die drei I2S-Leitungen da sind, einen fertigen Code, der sowohl mit dem ESP32-Arduino-Core 2.x als auch 3.x kompiliert, den Unterschied zwischen dBFS und dB SPL und die Formel eines echten Schallpegelmessers. Am Ende findest du die Nutzung mit dem Raspberry Pi Pico in MicroPython, den Unterschied zum günstigen analogen KY-038 Schallsensor und die häufigsten Verdrahtungsfehler.

Was ist das INMP441 und wie funktioniert es?

Das INMP441 ist ein von TDK InvenSense gefertigtes, omnidirektionales MEMS-Mikrofon. MEMS bedeutet hier einen winzigen Kondensator aus einer mikroskopisch kleinen Membran und einer festen Platte auf Silizium: Schwingt die Membran durch den Schall, ändert sich die Kapazität. Bei einem klassischen Elektretmikrofon kommt diese Änderung als schwache analoge Spannung heraus, die du selbst verstärken, filtern und mit einem ADC messen musst. Im INMP441 sitzen dagegen Vorverstärker, Anti-Aliasing-Filter, 24-Bit-Sigma-Delta-ADC und I2S-Schnittstelle in einem Gehäuse. Aus dem Mikrofon kommen also keine Spannungen mehr, sondern Zahlen im Takt eines Taktsignals. So sammelt das Kabel kein analoges Rauschen auf, die ADC-Qualität deines Boards spielt keine Rolle, und jeder passende 3,3-V-Mikrocontroller erreicht die gleiche Audioqualität. Das kleine Loch auf dem Modul ist der Schalleinlass; achte beim Einbau in ein Gehäuse darauf, es nicht zu verdecken.

Was ist I2S? Digitales Audio mit drei Leitungen

I2S (Inter-IC Sound) ist ein serieller Bus, der entwickelt wurde, um Audio-Samples zwischen Chips zu übertragen; trotz des ähnlichen Namens hat er nichts mit I2C zu tun. Er hat drei Leitungen: SCK (Bittakt) sagt, wann jedes Datenbit gelesen wird, WS (Word Select, auch LRCLK genannt) gibt an, ob gerade der linke oder der rechte Kanal gesendet wird, und SD ist die Datenleitung selbst. Dabei ist der ESP32 der Master: Er erzeugt beide Takte, und das Mikrofon legt die Daten im Takt auf die SD-Leitung. Beim INMP441 besteht jeder Frame aus 64 SCK-Impulsen: 32 Bit linker Kanal, 32 Bit rechter Kanal. Die Abtastrate ist deshalb SCK / 64; für 16 kHz erzeugt der ESP32 einen Bittakt von etwa 1,024 MHz. Das Mikrofon schreibt die 24-Bit-Messung MSB zuerst in den 32-Bit-Slot seines Kanals, die restlichen 8 Bit sind null. Deshalb schieben wir den Wert im Code um 8 Bit nach rechts.

INMP441 anschließen: ESP32 und Raspberry Pi Pico

Beim ESP32 lassen sich die I2S-Signale über die GPIO-Matrix auf beliebige Pins legen; die Nummern 32, 25 und 33 in der Tabelle sind nicht zwingend, sondern nur sichere Wahlen. Halte dich nur von den Strapping-Pins fern, die das Verhalten beim Start bestimmen (GPIO 0, 2, 5, 12, 15), und von GPIO 6–11, die für den Flash-Speicher reserviert sind. GPIO 34–39 sind reine Eingänge und eignen sich deshalb für die SD-Leitung, aber nicht für SCK und WS. Beim Pico gilt eine andere Regel: Der MicroPython-I2S-Treiber nutzt PIO, und der WS-Pin muss um eins größer sein als der SCK-Pin (z. B. GP16 und GP17). Halte die Kabel kürzer als 10–15 cm; das Taktsignal im Megahertz-Bereich wird auf langen Jumperkabeln verzerrt. Die Pinbelegung deines Boards kannst du im Pinout-Tool prüfen.

Schritt für Schritt: erstes Audio mit dem ESP32 lesen

1. Stelle sicher, dass das ESP32-Board-Paket in der Arduino IDE installiert ist, und wähle unter Werkzeuge > Board ESP32 Dev Module. Wenn du die Installation nicht kennst, lies Was ist der ESP32?.
2. Stecke das Modul aufs Breadboard; verbinde VDD mit 3V3, GND mit GND und L/R ebenfalls mit GND.
3. Verbinde SCK mit GPIO 32, WS mit GPIO 25 und SD mit GPIO 33 und halte die Kabel kurz.
4. Lade den Code unten hoch. Du brauchst keine zusätzliche Bibliothek: ESP_I2S im 3.x-Core und driver/i2s.h im 2.x-Core sind bereits im Board-Paket enthalten.
5. Öffne den Serial Monitor mit 115200 Baud; in einem ruhigen Raum solltest du etwa 35–50 dB sehen, beim Sprechen etwa 55–70 dB.
6. Öffne Werkzeuge > Serieller Plotter und verfolge die dBFS- und dB-SPL-Kurven live; klatsche neben dem Mikrofon und sieh, wie die Kurve springt.

ESP32-Code: Lautstärke (dB) mit dem INMP441 messen

Der Code prüft die Version des ESP32-Arduino-Cores mit ESP_ARDUINO_VERSION_MAJOR. Bei 3.x nutzt er die neue ESP_I2S-Bibliothek, bei 2.x den klassischen I2S-Treiber von ESP-IDF. Da beide Wege dieselben Funktionen micBegin() und micRead() bieten, bleibt die Berechnung in loop() gleich. In jedem Durchlauf werden 512 Samples gelesen (bei 16 kHz also 32 ms Audio), der DC-Offset wird abgezogen, der Effektivwert (RMS) berechnet und in Dezibel umgerechnet.

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}

Wie wird der Pegel berechnet? dBFS und dB SPL

Weil sich der Schalldruck über einen sehr großen Bereich ändert, nutzt man die logarithmische Dezibel-Skala: Eine Verdopplung der Amplitude entspricht etwa 6 dB mehr, eine Verzehnfachung 20 dB. Die Zahlen des Mikrofons werden zuerst in dBFS (Dezibel relativ zur Vollaussteuerung) umgerechnet: dBFS = 20 × log10(RMS / Vollausschlag-RMS). Die Vollaussteuerung ist der RMS-Wert einer Sinuswelle, deren Spitze den größten 24-Bit-Wert 8 388 608 erreicht, also 8 388 608 / √2 ≈ 5 931 642. Auf dieser Skala ist 0 dBFS die Übersteuerungsgrenze des Mikrofons, jeder leisere Schall bekommt einen negativen Wert. Für den physikalischen Schalldruck, also dB SPL, nutzt man die Empfindlichkeit aus dem Datenblatt: Das INMP441 liefert einen 1-kHz-Ton mit 94 dB SPL als −26 dBFS. Daraus ergibt sich dB SPL = dBFS + 94 − (−26) = dBFS + 120. Kommt zum Beispiel ein RMS-Wert von 5 932 heraus, ist dBFS = 20 × log10(0,001) = −60, und der Pegel liegt bei etwa 60 dB SPL, also normaler Gesprächslautstärke.

Wellenform im Serial Plotter zeichnen

Der Dezibelwert sagt dir, wie laut es ist; um die Form des Schalls zu sehen, musst du die rohen Samples zeichnen lassen. Ersetze im selben Sketch nur die Funktion loop() durch die folgende. Hier gibt es eine wichtige Grenze: Eine serielle Verbindung mit 115200 Baud überträgt etwa 11 500 Zeichen pro Sekunde, und das reicht nicht, um 16 000 Samples pro Sekunde auszugeben. Deshalb gibt der Code einen Block von 512 Samples hintereinander aus; während der Block geschrieben wird, geht der eintreffende Schall verloren, aber jedes Stück, das du im Plotter siehst, ist ein lückenloser, echter 32-ms-Ausschnitt.

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}

Wenn du ins Mikrofon pfeifst, siehst du im Plotter eine fast saubere Sinuswelle. Bei einem 1-kHz-Pfiff dauert eine Periode 1 ms und entspricht bei 16 kHz Abtastrate 16 Punkten; durch Zählen der Punkte pro Periode kannst du die Frequenz grob abschätzen. Sprache ist eine Mischung vieler Frequenzen und zeichnet deshalb eine unregelmäßige Welle mit Hüllkurve; ein Klatschen erzeugt eine kurze, sehr hohe Spitze. Da der Plotter die Achse automatisch skaliert, können kleine Rauschschwankungen in der Stille groß aussehen; das ist normal. Details zum Serial Monitor und Serial Plotter findest du im Artikel Arduino Serial Monitor.

INMP441 am Raspberry Pi Pico (MicroPython)

Der Raspberry Pi Pico hat keine eigene I2S-Einheit, aber die programmierbaren PIO-Blöcke emulieren I2S in Hardware-Geschwindigkeit, und die Klasse machine.I2S von MicroPython übernimmt das für dich. Du musst keine zusätzliche Datei installieren; eine aktuelle MicroPython-Version genügt. Im Code werden bits=32 und format=I2S.MONO gewählt, die gelesenen Samples werden wieder um 8 Bit nach rechts geschoben und mit derselben Formel in Dezibel umgerechnet. Da Python-Schleifen langsamer sind als C, ist eine Blockgröße von 512 Samples ein guter Kompromiss; dass während der Berechnung ein paar Millisekunden Schall verloren gehen, beeinflusst das Messergebnis kaum. Programmierst du den Pico mit der Arduino IDE, erfüllt die I2S-Bibliothek im arduino-pico-Core denselben Zweck; auch dort muss der WS-Pin (LRCLK) um eins größer sein als der BCLK-Pin. Bist du neu bei MicroPython, wirf zuerst einen Blick auf Was ist der 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 und KY-038: der Unterschied zum analogen Schallsensor

Der KY-038 ist ein günstiges Modul aus einer Elektretmikrofonkapsel, einem Trimmer zur Schwelleneinstellung und einem LM393-Komparator. Sein digitaler Ausgang (DO) wechselt den Zustand, wenn der Schall deine eingestellte Schwelle überschreitet; der analoge Ausgang (AO) gibt die rohe Spannung der Kapsel aus und wird mit dem ADC des Boards gelesen. Das reicht, um Klatschen zu erkennen oder festzustellen, ob überhaupt Geräusche da sind. Weil das Modul aber keinen Verstärker hat, ist das Signal sehr schwach: Der 10-Bit-ADC des Arduino Uno sieht bei Sprache nur eine Änderung von wenigen Stufen, und auch der ADC des ESP32 rauscht. Das INMP441 misst dagegen schon im Mikrofon mit 24 Bit; da zwischen Mikrofon und Board weder analoges Kabel noch Verstärker noch ADC liegen, nimmt es einen Bereich von etwa 87 dB vom Rauschboden bis zur Übersteuerungsgrenze sauber auf. Kurz gesagt: Der KY-038 ist ein Geräuschschalter, das INMP441 ein echtes Mikrofon. Die Grenzen analoger Messung findest du ausführlich im ADC-Leitfaden.

Projektideen mit dem INMP441

• Musikreaktive LEDs: Wandle den Pegel in die Anzahl der leuchtenden LEDs eines WS2812B-Streifens um; Details in den Artikeln Musikreaktive LEDs und WS2812B NeoPixel.
• Lärmampel für die Klasse: Baue eine Warnlampe, die unter 55 dB grün, zwischen 55 und 70 dB gelb und darüber rot leuchtet.
• Live-Lärmpanel im Web: Sende den dB-Wert per WebSocket an den Browser und verfolge ihn als Diagramm auf dem Handy; die Grundlagen stehen im Artikel ESP32 Webserver und WebSocket.
• Lärmsensor fürs Smart Home: Übertrage die Messwerte per MQTT an Home Assistant; die Anleitung ESP32 MQTT und Home Assistant erleichtert dir die Arbeit.
• Warnung bei Babyweinen oder Hundebellen: Überschreitet der Schall eine bestimmte Zeit lang die Schwelle, sende dir mit einem Telegram-Bot eine Nachricht aufs Handy.
• Tonrekorder: Schreibe die Samples als 16-Bit-WAV-Datei auf ein SD-Kartenmodul und höre sie am Computer an.
• Pfeifsteuerung: Finde per FFT die dominante Frequenz und löse bei einem bestimmten Pfeifton eine LED oder ein Relais aus.

Häufige Fehler und ihre Lösungen

Mit ein paar Kabeln und einem kurzen Code verschafft das INMP441 dem ESP32 ein echtes digitales Mikrofon; es ist die Grundlage vieler Projekte, vom Schallpegelmesser bis zu musikreaktivem Licht. Wenn du Schall lieber als Zahlen verarbeiten willst, statt dich mit einem analogen Sensor zu begnügen, ist es die erste Wahl. In der BlueGrays-App findest du ESP32-Projekte mit LEDs, Buzzer, WS2812B-Streifen und Webserver mit Schaltplan und Code Schritt für Schritt und kannst dieses Mikrofon leicht dazu ergänzen.