Microfone I2S INMP441 com ESP32: ler áudio, medir dB e plotar a forma de onda

O INMP441 é um pequeno módulo de microfone MEMS que converte o som para digital dentro do próprio chip e envia amostras de 24 bits diretamente pelo barramento I2S. A dupla INMP441 ESP32 é o jeito mais fácil de obter áudio limpo sem microfone analógico, amplificador ou ADC. Você liga o módulo ao ESP32 com seis fios, captura 16.000 amostras por segundo com poucas linhas de código I2S, calcula o nível sonoro do ambiente em decibéis (dB) a partir dessas amostras e acompanha a forma de onda do som ao vivo no Plotter Serial.

Neste guia você vai ver passo a passo como o INMP441 funciona, o que fazem as três linhas do I2S, um código pronto que compila tanto no core 2.x quanto no 3.x do ESP32 para Arduino, a diferença entre dBFS e dB SPL e a fórmula de um decibelímetro de verdade. No final você também encontra o uso com MicroPython no Raspberry Pi Pico, a diferença em relação ao barato sensor de som analógico KY-038 e os erros de ligação mais comuns.

O que é o INMP441 e como ele funciona?

O INMP441 é um microfone MEMS omnidirecional fabricado pela TDK InvenSense. MEMS, aqui, significa um minúsculo capacitor formado por uma membrana microscópica e uma placa fixa gravadas no silício: conforme as ondas sonoras fazem a membrana vibrar, a capacitância muda. Um microfone de eletreto clássico entrega essa variação como uma tensão analógica fraca, e você precisa amplificá-la, filtrá-la e medi-la com um ADC. Dentro do INMP441, porém, estão juntos um pré-amplificador, um filtro anti-aliasing, um ADC sigma-delta de 24 bits e a interface I2S. Ou seja, o que sai do microfone já não é uma tensão, e sim números que seguem um sinal de clock. Assim, nenhum ruído analógico é captado nos fios, a qualidade do ADC da sua placa deixa de importar e qualquer microcontrolador de 3,3 V adequado obtém a mesma qualidade de som. O pequeno furo no módulo é a entrada de som do microfone; tome cuidado para não tampá-lo ao montar a placa em uma caixa.

O que é I2S? Áudio digital em três linhas

I2S (Inter-IC Sound) é um barramento serial criado para transportar amostras de áudio entre chips e, apesar do nome parecido, não tem nada a ver com o I2C. Ele tem três linhas: SCK (clock de bit) indica quando cada bit de dado deve ser lido, WS (word select, também chamado de LRCLK) indica se naquele momento está sendo enviado o canal esquerdo ou o direito, e SD é o próprio dado. Nesta montagem o ESP32 é o mestre (master): ele gera os dois clocks, e o microfone segue o clock e coloca os dados na linha SD. No INMP441 cada quadro tem 64 pulsos de SCK: 32 bits para o canal esquerdo e 32 bits para o direito. Por isso a taxa de amostragem é SCK / 64; para amostrar a 16 kHz, o ESP32 gera um clock de bit de cerca de 1,024 MHz. O microfone escreve sua medição de 24 bits, com o MSB primeiro, no espaço de 32 bits do seu canal, e os 8 bits restantes ficam em zero. É por isso que o código desloca o valor 8 bits para a direita.

Ligação do INMP441: ESP32 e Raspberry Pi Pico

No ESP32, os sinais I2S podem ser roteados para qualquer pino pela matriz de GPIO; os números 32, 25 e 33 da tabela não são obrigatórios, apenas escolhas seguras. Só fique longe dos pinos de strapping, que definem o comportamento na inicialização (GPIO 0, 2, 5, 12, 15), e dos GPIO 6–11, reservados para a memória flash. Os GPIO 34–39 são somente entrada, então servem para a linha SD, mas não podem ser usados para SCK e WS. No Pico a regra é diferente: o driver I2S do MicroPython usa PIO e o pino WS precisa ser o número seguinte ao pino SCK (como GP16 e GP17). Mantenha os fios com menos de 10–15 cm; um sinal de clock na faixa de megahertz se deforma em jumpers longos. Você pode conferir a disposição dos pinos da sua placa na ferramenta Pinagem.

Passo a passo: sua primeira leitura de áudio com o ESP32

1. Verifique se o pacote de placas ESP32 está instalado no Arduino IDE e escolha ESP32 Dev Module em Ferramentas > Placa. Se você não sabe como instalar, veja O que é ESP32?.
2. Encaixe o módulo na protoboard; ligue VDD ao 3V3, GND ao GND e L/R também ao GND.
3. Ligue SCK ao GPIO 32, WS ao GPIO 25 e SD ao GPIO 33, e mantenha os fios curtos.
4. Carregue o código abaixo. Nenhuma biblioteca extra é necessária: a ESP_I2S no core 3.x e a driver/i2s.h no core 2.x já vêm incluídas no pacote da placa.
5. Abra o Monitor Serial a 115200 baud; em um cômodo silencioso você deve ver valores de cerca de 35–50 dB e, ao falar, algo em torno de 55–70 dB.
6. Abra Ferramentas > Plotter Serial para acompanhar ao vivo as curvas de dBFS e dB SPL; bata palmas perto do microfone e veja a curva saltar.

Código para ESP32: medindo o nível sonoro (dB) com o INMP441

O código verifica a versão do core ESP32 para Arduino com ESP_ARDUINO_VERSION_MAJOR. Na versão 3.x ele usa a nova biblioteca ESP_I2S e, na 2.x, o driver I2S clássico do ESP-IDF. Os dois caminhos oferecem as mesmas funções micBegin() e micRead(), então o cálculo dentro de loop() não muda. A cada ciclo são lidas 512 amostras, ou seja, 32 ms de áudio a 16 kHz; o offset DC é removido, o valor RMS é calculado e convertido para decibéis.

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}

Como o nível sonoro é calculado? dBFS e dB SPL

Como a pressão sonora varia numa faixa muito ampla, usa-se a escala logarítmica de decibéis: dobrar a amplitude significa cerca de +6 dB, e multiplicá-la por dez significa +20 dB. Os números do microfone são primeiro convertidos para dBFS (decibéis em relação ao fundo de escala): dBFS = 20 × log10(RMS / RMS de fundo de escala). O fundo de escala é o RMS de uma senoide cujo pico atinge o maior valor de 24 bits, 8.388.608, ou seja, 8.388.608 / √2 ≈ 5.931.642. Nessa escala, 0 dBFS é o limite de saturação do microfone, e qualquer som mais baixo recebe um valor negativo. Para chegar à pressão sonora física, o dB SPL, usa-se a sensibilidade do datasheet: o INMP441 entrega um som de 1 kHz a 94 dB SPL como −26 dBFS. Daí vem a fórmula dB SPL = dBFS + 94 − (−26) = dBFS + 120. Por exemplo, se o valor RMS for 5.932, então dBFS = 20 × log10(0,001) = −60 e o nível sonoro fica em cerca de 60 dB SPL, que é o nível de uma conversa normal.

Plotando a forma de onda no Plotter Serial

O valor em decibéis diz o quanto o som está alto; para ver o formato do som, você precisa plotar as amostras brutas. No mesmo sketch, substitua apenas a função loop() pela de baixo. Há um limite importante aqui: uma linha serial de 115200 baud transporta cerca de 11.500 caracteres por segundo, o que não basta para imprimir 16.000 amostras por segundo. Por isso o código imprime um bloco de 512 amostras em sequência; o som que chega enquanto o bloco está sendo impresso é perdido, mas cada trecho que você vê no plotter é uma fatia real e contínua 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}

Ao assobiar perto do microfone, você verá no plotter uma senoide quase perfeita. Num assobio de 1 kHz, um período dura 1 ms e corresponde a 16 pontos com amostragem de 16 kHz; contando os pontos de um período, dá para estimar a frequência por alto. Como a fala é uma mistura de muitas frequências, ela desenha uma onda irregular, com envoltória; já uma palma produz um pico curto e muito alto. Como o plotter ajusta a escala do eixo automaticamente, pequenas oscilações de ruído podem parecer grandes no silêncio, o que é normal. Para detalhes de uso do Monitor Serial e do Plotter Serial, veja o post Monitor Serial do Arduino.

INMP441 com o Raspberry Pi Pico (MicroPython)

O Raspberry Pi Pico não tem uma unidade I2S dedicada, mas seus blocos programáveis PIO emulam o I2S na velocidade do hardware, e a classe machine.I2S do MicroPython faz esse trabalho por você. Não é preciso instalar nenhum arquivo extra; basta ter uma versão recente do MicroPython instalada. No código você escolhe bits=32 e format=I2S.MONO, e as amostras lidas são de novo deslocadas 8 bits para a direita e convertidas para decibéis com a mesma fórmula. Como os laços em Python são mais lentos que em C, manter o bloco em 512 amostras é um bom equilíbrio; perder alguns milissegundos de som enquanto o cálculo roda quase não afeta o resultado. Se você programa o Pico com o Arduino IDE, a biblioteca I2S do core arduino-pico faz o mesmo trabalho; lá também o pino WS (LRCLK) precisa ser o número seguinte ao pino BCLK. Se você é novo no MicroPython, dê uma olhada primeiro em O que é 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 x sensor de som analógico KY-038

O KY-038 é um módulo barato formado por uma cápsula de microfone de eletreto, um trimpot para ajustar o limiar e um comparador LM393. Sua saída digital (DO) muda de estado quando o som ultrapassa o limiar que você definiu; a saída analógica (AO) entrega a tensão bruta da cápsula e é lida com o ADC da placa. Esse arranjo basta para detectar palmas ou saber se há som no ambiente. Mas, como o módulo não tem amplificador, o sinal é muito fraco: o ADC de 10 bits do Arduino Uno enxerga apenas alguns degraus de variação durante a fala, e o ADC do ESP32 é ruidoso. Já o INMP441 faz a medição dentro do próprio microfone com 24 bits; como não há cabo analógico, amplificador ou ADC no meio, ele registra com limpeza uma faixa de cerca de 87 dB, do piso de ruído até o limite de saturação. Resumindo, o KY-038 é um interruptor de som, enquanto o INMP441 é um microfone de verdade. Você encontra os limites da leitura analógica em detalhes no guia de ADC.

Ideias de projetos com o INMP441

• LEDs que reagem ao som: transforme o nível sonoro na quantidade de LEDs acesos numa fita WS2812B; para detalhes, veja os posts LEDs que reagem à música e WS2812B NeoPixel.
• Semáforo de ruído para a sala de aula: monte uma luz de aviso que fica verde abaixo de 55 dB, amarela entre 55–70 dB e vermelha acima disso.
• Painel de ruído ao vivo na web: envie o valor em dB para o navegador via WebSocket e acompanhe em gráfico pelo celular; a estrutura básica está em Servidor web e WebSocket com ESP32.
• Sensor de ruído para casa inteligente: envie as medições para o Home Assistant via MQTT; o guia ESP32 com MQTT e Home Assistant facilita o trabalho.
• Alerta de choro de bebê ou latido de cachorro: se o som passar do limiar por um certo tempo, envie uma mensagem para o seu celular com um bot do Telegram.
• Gravador de áudio: grave as amostras como arquivo WAV de 16 bits num módulo de cartão SD e ouça no computador.
• Controle por assobio: encontre a frequência dominante com uma FFT e acione um LED ou relé com um tom de assobio específico.

Erros comuns e como resolvê-los

Com alguns fios e um sketch curto, o INMP441 dá ao seu ESP32 um microfone digital de verdade; ele é a base de muitos projetos, da medição do nível sonoro a luzes que reagem à música. Sempre que você quiser processar o som como números em vez de se contentar com um sensor analógico, ele é a primeira escolha. No app BlueGrays você pode seguir esquemas do circuito e códigos passo a passo de projetos com ESP32 usando LEDs, buzzers, fitas WS2812B e servidores web, e adicionar este microfone a eles com facilidade.