Micrófono I2S INMP441 con ESP32: leer audio, medir dB y onda

El INMP441 es un pequeño módulo de micrófono MEMS que convierte el sonido a digital en su interior y envía directamente muestras de 24 bits por el bus I2S. La pareja INMP441 ESP32 es la forma más fácil de leer audio limpio sin lidiar con un micrófono analógico, un amplificador y un ADC. Conectas el módulo al ESP32 con seis cables, con unas pocas líneas de código I2S obtienes 16 000 muestras por segundo, con ellas puedes calcular el nivel de sonido del ambiente en decibelios (dB) y ver la forma de onda en directo en el Serial Plotter.

En esta guía verás paso a paso cómo funciona el INMP441, para qué sirven las tres líneas del I2S, un código listo que compila tanto en la versión 2.x como en la 3.x del núcleo Arduino para ESP32, la diferencia entre dBFS y dB SPL y la fórmula de un sonómetro real. Al final encontrarás el uso con Raspberry Pi Pico y MicroPython, la diferencia con el económico sensor de sonido KY-038 y los errores de conexión más habituales.

¿Qué es el INMP441 y cómo funciona?

El INMP441 es un micrófono MEMS omnidireccional (capta por igual desde todas las direcciones) fabricado por TDK InvenSense. MEMS significa, en esencia, un pequeño condensador formado por una membrana microscópica y una placa fija grabadas sobre silicio: cuando la onda sonora hace vibrar la membrana, cambia la capacidad. En un micrófono electret clásico ese cambio sale como una tensión analógica muy débil que tú tienes que amplificar, filtrar y medir con un ADC. Dentro del INMP441, en cambio, hay un preamplificador, un filtro anti-aliasing, un ADC sigma-delta de 24 bits y la interfaz I2S. Es decir, lo que sale del micrófono ya no es tensión, sino números que llegan siguiendo una señal de reloj. Así el cable no recoge ruido analógico, la calidad del ADC de la placa deja de importar y cualquier microcontrolador de 3,3 V adecuado obtiene la misma calidad de sonido. El pequeño orificio de la placa del módulo es la entrada de sonido del micrófono; al montar la placa en una caja, cuida de no taparlo.

¿Qué es I2S? Audio digital con tres líneas

I2S (Inter-IC Sound) es un bus serie diseñado para transportar muestras de audio entre chips y, aunque el nombre se parezca, no tiene relación con el I2C. Tiene tres líneas: SCK (reloj de bit) indica cuándo hay que leer cada bit de datos, WS (word select, también llamada LRCLK) indica si en ese momento se envía el canal izquierdo o el derecho, y SD son los datos en sí. En este esquema el ESP32 es el maestro (master): genera los dos relojes y el micrófono, siguiendo el reloj, coloca los datos en la línea SD. En el INMP441 cada trama consta de 64 pulsos de SCK: 32 bits del canal izquierdo y 32 bits del derecho. Por eso la frecuencia de muestreo es SCK / 64; para muestrear a 16 kHz, el ESP32 genera un reloj de bit de unos 1,024 MHz. El micrófono escribe su medición de 24 bits, primero el bit más significativo, en la ranura de 32 bits de su canal, y los 8 bits restantes son cero. Por eso en el código desplazamos el valor 8 bits a la derecha.

Conexión del INMP441: ESP32 y Raspberry Pi Pico

En el ESP32 las señales I2S se pueden enrutar a cualquier pin mediante la matriz de GPIO; los números 32, 25 y 33 de la tabla no son obligatorios, solo una elección segura. Eso sí, mantente alejado de los pines de strapping que determinan el comportamiento de la placa al arrancar (GPIO 0, 2, 5, 12, 15) y de los GPIO 6–11, reservados para la memoria flash. Los GPIO 34–39 son solo de entrada, así que sirven para la línea SD pero no para SCK y WS. En la Pico la regla es distinta: el controlador I2S de MicroPython usa PIO y el pin WS debe ser el siguiente al pin SCK (por ejemplo GP16 y GP17). Mantén los cables por debajo de 10–15 cm; la señal de reloj, de varios megahercios, se degrada en cables jumper largos. Puedes comprobar la distribución de pines de tu placa en la herramienta de pinout.

Paso a paso: primera lectura de audio con el ESP32

1. Asegúrate de que el paquete de placas ESP32 está instalado en el Arduino IDE y elige ESP32 Dev Module en el menú Herramientas > Placa. Si no sabes cómo instalarlo, consulta el artículo ¿Qué es el ESP32?.
2. Coloca el módulo en la protoboard; conecta VDD a 3V3, GND a GND y L/R también a GND.
3. Conecta SCK a GPIO 32, WS a GPIO 25 y SD a GPIO 33, y mantén los cables cortos.
4. Sube el código de abajo. No hace falta ninguna biblioteca adicional: ESP_I2S en el núcleo 3.x y driver/i2s.h en el 2.x ya vienen incluidos en el paquete de placas.
5. Abre el Monitor Serie a 115200 baudios; en una habitación silenciosa deberías ver valores de unos 35–50 dB y de 55–70 dB mientras hablas.
6. Abre Herramientas > Serial Plotter para ver en directo las curvas de dBFS y dB SPL; da una palmada junto al micrófono y verás cómo salta la curva.

Código para ESP32: medir el nivel de sonido (dB) con el INMP441

El código comprueba la versión del núcleo Arduino para ESP32 con ESP_ARDUINO_VERSION_MAJOR. En la versión 3.x usa la nueva biblioteca ESP_I2S y en la 2.x el controlador I2S clásico de ESP-IDF. Como ambas rutas ofrecen las mismas funciones micBegin() y micRead(), el cálculo dentro de loop() no cambia. En cada vuelta se leen 512 muestras, es decir, 32 ms de audio a 16 kHz, se elimina el desplazamiento de continua, se obtiene el valor RMS y se convierte a decibelios.

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}

¿Cómo se calcula el nivel de sonido? dBFS y dB SPL

Como la presión sonora varía en un rango enorme, se usa la escala logarítmica de decibelios: duplicar la amplitud supone unos 6 dB más y multiplicarla por diez, 20 dB más. Los números que da el micrófono se convierten primero a dBFS (decibelios respecto a fondo de escala): dBFS = 20 × log10(RMS / RMS a fondo de escala). El fondo de escala es el valor RMS de una senoidal cuyo pico alcanza el mayor valor de 24 bits, 8 388 608; es decir, 8 388 608 / √2 ≈ 5 931 642. En esta escala 0 dBFS es el límite de saturación del micrófono y cualquier sonido menor da un valor negativo. Para pasar a la presión sonora física, es decir, a dB SPL, se usa la sensibilidad de la hoja de datos: el INMP441 entrega un sonido de 1 kHz a 94 dB SPL como −26 dBFS. De ahí sale la fórmula dB SPL = dBFS + 94 − (−26) = dBFS + 120. Por ejemplo, si el RMS resulta 5 932, dBFS = 20 × log10(0,001) = −60 y el nivel de sonido es de unos 60 dB SPL, es decir, una conversación normal.

Dibujar la forma de onda en el Serial Plotter

El valor en decibelios te dice lo fuerte que es el sonido; para ver su forma tienes que representar las muestras en bruto. En el mismo sketch, sustituye solo la función loop() por la siguiente. Hay un límite importante: una línea serie de 115200 baudios transporta unos 11 500 caracteres por segundo, y eso no basta para imprimir 16 000 muestras por segundo. Por eso el código imprime seguido un bloque de 512 muestras; el sonido que llega mientras se escribe el bloque se pierde, pero cada fragmento que ves en el plotter es un trozo real y continuo de 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}

Si silbas al micrófono, verás en el plotter una senoidal casi limpia. En un silbido de 1 kHz un periodo dura 1 ms y equivale a 16 puntos con un muestreo de 16 kHz; contando los puntos de un periodo puedes estimar la frecuencia a grandes rasgos. Como la voz es una mezcla de muchas frecuencias, dibuja una onda irregular y con envolvente; una palmada produce un pico corto y muy alto. Como el plotter escala el eje automáticamente, en el silencio las pequeñas fluctuaciones de ruido pueden parecer grandes; es normal. Para más detalles sobre el Monitor Serie y el Serial Plotter, consulta el artículo Monitor Serie de Arduino.

INMP441 con Raspberry Pi Pico (MicroPython)

La Raspberry Pi Pico no tiene una unidad I2S independiente, pero sus bloques PIO programables emulan el I2S a velocidad de hardware y la clase machine.I2S de MicroPython hace ese trabajo por ti. No hace falta instalar ningún archivo adicional; basta con tener una versión reciente de MicroPython. En el código se elige bits=32 y format=I2S.MONO, y las muestras leídas se desplazan de nuevo 8 bits a la derecha y se convierten a decibelios con la misma fórmula. Como los bucles de Python son más lentos que en C, mantener el tamaño de bloque en 512 muestras es un buen equilibrio; que se pierdan unos milisegundos de sonido durante el cálculo apenas afecta al resultado. Si programas la Pico con el Arduino IDE, la biblioteca I2S del núcleo arduino-pico hace lo mismo; allí también el pin WS (LRCLK) debe ser el siguiente al pin BCLK. Si eres nuevo en MicroPython, echa primero un vistazo a ¿Qué es la 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))

Diferencia entre el INMP441 y el sensor de sonido analógico KY-038

El KY-038 es un módulo económico formado por una cápsula de micrófono electret, un trimmer para ajustar el umbral y un comparador LM393. Su salida digital (DO) cambia de estado cuando el sonido supera el umbral que hayas fijado; la salida analógica (AO) entrega la tensión en bruto de la cápsula y se lee con el ADC de la placa. Esta estructura basta para detectar palmadas o saber si hay sonido en el ambiente. Pero como el módulo no lleva amplificador, la señal es muy débil: el ADC de 10 bits del Arduino Uno apenas ve unos pocos escalones de variación al hablar, y el ADC del ESP32 también es ruidoso. El INMP441, en cambio, hace la medición dentro del micrófono con 24 bits; como no hay cable analógico, amplificador ni ADC por el medio, registra limpiamente un rango de unos 87 dB desde el suelo de ruido hasta el límite de saturación. En resumen, el KY-038 es un interruptor de sonido y el INMP441 es un micrófono de verdad. Puedes encontrar los límites de la lectura analógica con detalle en la guía del ADC.

Ideas de proyectos con el INMP441

• LED que reacciona a la música: convierte el nivel de sonido en el número de LED encendidos de una tira WS2812B; para los detalles, mira los artículos LED que reacciona a la música y WS2812B NeoPixel.
• Semáforo de ruido para el aula: haz una lámpara de aviso verde por debajo de 55 dB, amarilla entre 55 y 70 dB y roja por encima.
• Panel de ruido en directo en la web: envía el valor en dB al navegador por WebSocket y míralo como gráfico desde el móvil; la estructura básica está en el artículo ESP32 Web Server y WebSocket.
• Sensor de ruido para casa inteligente: envía las mediciones a Home Assistant por MQTT; la guía ESP32 MQTT y Home Assistant te lo pone fácil.
• Aviso de llanto de bebé o ladrido de perro: si el sonido supera el umbral durante un tiempo determinado, envía un mensaje a tu móvil con un bot de Telegram.
• Grabadora de sonido: escribe las muestras como archivo WAV de 16 bits en un módulo de tarjeta SD y escúchalo en el ordenador.
• Control por silbido: encuentra la frecuencia dominante con una FFT y activa un LED o un relé con un tono de silbido concreto.

Errores comunes y cómo solucionarlos

Con unos pocos cables y un código corto, el INMP441 le da al ESP32 un micrófono digital de verdad; es la base de muchos proyectos, desde medir el nivel de sonido hasta luces que reaccionan a la música. Siempre que quieras procesar el sonido como números en lugar de conformarte con un sensor analógico, es la primera opción. En la app de BlueGrays puedes ver paso a paso, con esquema de conexiones y código, proyectos con ESP32 como LED, zumbador, tira WS2812B y servidor web, y añadirles este micrófono con facilidad.