Microfono I2S INMP441 ESP32: leggere audio, misurare dB e onda

L'INMP441 è un piccolo modulo con microfono MEMS che converte il suono in digitale al suo interno e invia campioni a 24 bit direttamente tramite il bus I2S. La coppia INMP441 ESP32 è il modo più semplice per ottenere un audio pulito senza microfono analogico, amplificatore e ADC. Collega il modulo all'ESP32 con sei fili, acquisisci 16 000 campioni al secondo con poche righe di codice I2S, calcola dai campioni il livello sonoro dell'ambiente in decibel (dB) e guarda l'onda sonora dal vivo sul Serial Plotter.

In questa guida vedrai passo dopo passo come funziona l'INMP441, a cosa servono le tre linee dell'I2S, un codice pronto che compila sia con il core Arduino per ESP32 2.x sia con il 3.x, la differenza tra dBFS e dB SPL e la formula di un vero fonometro. Alla fine troverai l'uso con Raspberry Pi Pico e MicroPython, la differenza rispetto al economico sensore sonoro KY-038 e gli errori di collegamento più comuni.

Cos'è l'INMP441 e come funziona?

L'INMP441 è un microfono MEMS omnidirezionale prodotto da TDK InvenSense. MEMS significa un piccolo condensatore formato da una membrana microscopica e una piastra fissa ricavate dal silicio: quando l'onda sonora fa vibrare la membrana, la capacità cambia. In un microfono a elettrete classico questa variazione esce come una debole tensione analogica che devi amplificare, filtrare e misurare con un ADC. Dentro l'INMP441 invece ci sono preamplificatore, filtro anti-aliasing, ADC sigma-delta a 24 bit e interfaccia I2S. Quindi dal microfono non esce più una tensione, ma numeri che arrivano seguendo un segnale di clock. In questo modo sul cavo non si accumula rumore analogico, la qualità dell'ADC della scheda perde importanza e qualsiasi microcontrollore a 3,3 V ottiene la stessa qualità audio. Il piccolo foro sul modulo è l'ingresso del suono: se monti la scheda in una scatola, fai attenzione a non coprirlo.

Cos'è l'I2S? Audio digitale con tre linee

L'I2S (Inter-IC Sound) è un bus seriale sviluppato per trasportare campioni audio tra i chip e, nonostante il nome simile, non ha nulla a che fare con l'I2C. Ha tre linee: SCK (bit clock) indica quando leggere ogni bit di dati, WS (word select, detta anche LRCLK) indica se in quel momento viene inviato il canale sinistro o destro, SD è il dato vero e proprio. In questa configurazione l'ESP32 è il master: genera entrambi i clock e il microfono, seguendo il clock, mette i dati sulla linea SD. Nell'INMP441 ogni frame è composto da 64 impulsi SCK: 32 bit per il canale sinistro e 32 bit per il destro. Per questo la frequenza di campionamento è SCK / 64; per 16 kHz l'ESP32 genera un bit clock di circa 1,024 MHz. Il microfono scrive la misura a 24 bit nello slot a 32 bit del proprio canale, partendo dal bit più significativo; gli 8 bit restanti sono zero. Ecco perché nel codice spostiamo il valore di 8 bit a destra.

Collegamento dei pin INMP441: ESP32 e Raspberry Pi Pico

Sull'ESP32 i segnali I2S possono essere instradati su qualsiasi pin tramite la matrice GPIO; i numeri 32, 25 e 33 della tabella non sono obbligatori, sono solo scelte sicure. Evita però i pin di strapping che determinano il comportamento della scheda all'avvio (GPIO 0, 2, 5, 12, 15) e i GPIO 6–11 riservati alla memoria flash. I GPIO 34–39 sono solo ingressi, quindi vanno bene per la linea SD ma non si possono usare per SCK e WS. Sul Pico la regola è diversa: il driver I2S di MicroPython usa il PIO e il pin WS deve essere il pin SCK più uno (come GP16 e GP17). Tieni i cavi sotto i 10–15 cm; un clock nell'ordine dei megahertz si deteriora sui jumper lunghi. Puoi controllare la piedinatura della tua scheda con lo strumento mappa dei pin.

Passo dopo passo: la prima lettura audio con ESP32

1. Assicurati che il pacchetto schede ESP32 sia installato nell'IDE Arduino e scegli ESP32 Dev Module da Strumenti > Scheda. Se non sai come installarlo, leggi l'articolo Cos'è l'ESP32?.
2. Inserisci il modulo nella breadboard; collega VDD a 3V3, GND a GND e anche L/R a GND.
3. Collega SCK al GPIO 32, WS al GPIO 25 e SD al GPIO 33, tenendo i cavi corti.
4. Carica il codice qui sotto. Non serve nessuna libreria aggiuntiva: ESP_I2S nel core 3.x e driver/i2s.h nel core 2.x sono già inclusi nel pacchetto schede.
5. Apri il Monitor Seriale a 115200 baud; in una stanza silenziosa dovresti vedere valori intorno a 35–50 dB, mentre parli circa 55–70 dB.
6. Apri Strumenti > Serial Plotter per seguire dal vivo le curve dBFS e dB SPL; batti le mani vicino al microfono e guarda la curva schizzare.

Codice ESP32: misurare il livello sonoro (dB) con l'INMP441

Il codice controlla la versione del core Arduino per ESP32 con ESP_ARDUINO_VERSION_MAJOR. Nella versione 3.x usa la nuova libreria ESP_I2S, nella 2.x il driver I2S classico di ESP-IDF. Poiché entrambi i percorsi offrono le stesse funzioni micBegin() e micRead(), il calcolo dentro loop() non cambia. A ogni ciclo vengono letti 512 campioni, cioè 32 ms di audio a 16 kHz, si rimuove l'offset DC, si calcola il valore RMS e lo si converte in 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}

Come si calcola il livello sonoro? dBFS e dB SPL

Poiché la pressione sonora varia in un intervallo molto ampio, si usa la scala logaritmica dei decibel: raddoppiare l'ampiezza equivale a circa +6 dB, moltiplicarla per dieci a +20 dB. I numeri forniti dal microfono vengono prima convertiti in dBFS (decibel rispetto al fondo scala): dBFS = 20 × log10(RMS / RMS di fondo scala). Il fondo scala è l'RMS di una sinusoide il cui picco raggiunge il massimo valore a 24 bit, 8 388 608, cioè 8 388 608 / √2 ≈ 5 931 642. In questa scala 0 dBFS è il limite di saturazione del microfono e ogni suono più debole ha un valore negativo. Per passare alla pressione sonora fisica, cioè ai dB SPL, si usa la sensibilità del datasheet: l'INMP441 restituisce un suono a 1 kHz di 94 dB SPL come −26 dBFS. Da qui si ricava la formula dB SPL = dBFS + 94 − (−26) = dBFS + 120. Per esempio, se l'RMS risulta 5 932, dBFS = 20 × log10(0,001) = −60 e il livello sonoro è circa 60 dB SPL, cioè una normale conversazione.

Disegnare la forma d'onda sul Serial Plotter

Il valore in decibel ti dice quanto è forte il suono; per vederne la forma devi tracciare i campioni grezzi. Nello stesso sketch sostituisci solo la funzione loop() con quella qui sotto. C'è un limite importante: una linea seriale a 115200 baud trasporta circa 11 500 caratteri al secondo e non basta per stampare 16 000 campioni al secondo. Per questo il codice stampa di seguito un blocco di 512 campioni; l'audio che arriva mentre il blocco viene scritto va perso, ma ogni tratto che vedi nel plotter è un vero segmento continuo di 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}

Se fischi nel microfono vedrai nel plotter una sinusoide quasi regolare. In un fischio a 1 kHz un periodo dura 1 ms e corrisponde a 16 punti con campionamento a 16 kHz; contando i punti di un periodo puoi stimare la frequenza. La voce è un miscuglio di molte frequenze e disegna un'onda irregolare con un inviluppo; un applauso produce un picco breve e molto alto. Poiché il plotter scala l'asse automaticamente, in silenzio le piccole oscillazioni di rumore possono sembrare grandi: è normale. Per i dettagli sull'uso di Monitor Seriale e Serial Plotter consulta l'articolo Arduino Serial Monitor.

Raspberry Pi Pico con INMP441 (MicroPython)

Il Raspberry Pi Pico non ha un'unità I2S dedicata, ma i blocchi PIO programmabili emulano l'I2S a velocità hardware e la classe machine.I2S di MicroPython fa il lavoro al posto tuo. Non serve installare file aggiuntivi: basta una versione recente di MicroPython. Nel codice si scelgono bits=32 e format=I2S.MONO, i campioni letti vengono di nuovo spostati di 8 bit a destra e convertiti in decibel con la stessa formula. Poiché i cicli Python sono più lenti del C, mantenere il blocco a 512 campioni è un buon compromesso; perdere qualche millisecondo di audio durante il calcolo non influisce molto sul risultato. Se programmi il Pico con l'IDE Arduino, anche la libreria I2S del core arduino-pico fa lo stesso lavoro; anche lì il pin WS (LRCLK) deve essere il pin BCLK più uno. Se sei nuovo di MicroPython, dai prima un'occhiata a Cos'è il 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))

Differenza tra INMP441 e sensore sonoro analogico KY-038

Il KY-038 è un modulo economico composto da una capsula microfonica a elettrete, un trimmer per regolare la soglia e un comparatore LM393. L'uscita digitale (DO) cambia stato quando il suono supera la soglia impostata; l'uscita analogica (AO) fornisce la tensione grezza della capsula e si legge con l'ADC della scheda. Questa struttura basta per rilevare un applauso o capire se nell'ambiente c'è rumore. Ma poiché il modulo non ha amplificatore, il segnale è molto debole: l'ADC a 10 bit dell'Arduino Uno vede appena qualche gradino di variazione con la voce e anche l'ADC dell'ESP32 è rumoroso. L'INMP441 invece esegue la misura a 24 bit dentro il microfono; senza cavo analogico, amplificatore o ADC in mezzo, registra in modo pulito un intervallo di circa 87 dB dal rumore di fondo al limite di saturazione. In breve, il KY-038 è un interruttore sonoro, l'INMP441 è un vero microfono. I limiti della lettura analogica li trovi in dettaglio nella guida all'ADC.

Idee di progetto con l'INMP441

• LED reattivo alla musica: trasforma il livello sonoro nel numero di LED accesi su una striscia WS2812B; per i dettagli guarda gli articoli LED reattivo alla musica e WS2812B NeoPixel.
• Semaforo del rumore in classe: realizza una lampada che si accende verde sotto i 55 dB, gialla tra 55 e 70 dB e rossa oltre.
• Pannello del rumore dal vivo sul web: invia il valore in dB al browser con WebSocket e seguilo come grafico dal telefono; la struttura di base è nell'articolo ESP32 Web Server e WebSocket.
• Sensore di rumore per la casa intelligente: invia le misure a Home Assistant tramite MQTT; la guida ESP32 MQTT e Home Assistant ti semplifica il lavoro.
• Avviso di pianto del bambino o abbaio del cane: se il suono supera la soglia per un certo tempo, manda un messaggio al telefono con un bot Telegram.
• Registratore audio: scrivi i campioni come file WAV a 16 bit su un modulo scheda SD e ascoltali sul computer.
• Controllo con il fischio: trova la frequenza dominante con la FFT e attiva un LED o un relè con un certo tono di fischio.

Errori comuni e come risolverli

Con pochi cavi e un breve codice, l'INMP441 dà all'ESP32 un vero microfono digitale ed è la base di molti progetti, dalla misura del livello sonoro alle luci reattive alla musica. Ogni volta che vuoi elaborare il suono come numeri invece di accontentarti di un sensore analogico, è la prima scelta. Nell'app BlueGrays trovi passo dopo passo, con schema elettrico e codice, progetti ESP32 con LED, buzzer, strisce WS2812B e web server, a cui puoi aggiungere facilmente questo microfono.