Mikrofon I2S INMP441 dengan ESP32: Membaca Audio, Mengukur dB, dan Menggambar Gelombang

INMP441 adalah modul mikrofon MEMS kecil yang mengubah suara menjadi digital di dalam chip-nya sendiri dan mengirim sampel 24-bit langsung lewat bus I2S. Pasangan INMP441 ESP32 adalah cara termudah untuk mendapatkan audio yang bersih tanpa repot dengan mikrofon analog, penguat, atau ADC. Kamu cukup menghubungkan modul ke ESP32 dengan enam kabel, mengambil 16.000 sampel per detik dengan beberapa baris kode I2S, menghitung level suara sekitar dalam desibel (dB) dari sampel-sampel itu, lalu melihat bentuk gelombang suara secara langsung di Serial Plotter.

Di panduan ini kamu akan melihat langkah demi langkah cara kerja INMP441, fungsi tiga jalur I2S, kode siap pakai yang bisa dikompilasi di core Arduino ESP32 versi 2.x maupun 3.x, perbedaan dBFS dan dB SPL, serta rumus pengukur level suara yang sesungguhnya. Di bagian akhir ada juga cara memakai MicroPython di Raspberry Pi Pico, perbedaannya dengan sensor suara KY-038 analog yang murah, dan kesalahan pengkabelan yang paling sering terjadi.

Apa itu INMP441 dan bagaimana cara kerjanya?

INMP441 adalah mikrofon MEMS omnidirectional (menangkap suara sama baiknya dari segala arah) buatan TDK InvenSense. MEMS di sini berarti kapasitor kecil yang terdiri dari membran mikroskopis dan pelat tetap yang dibentuk di atas silikon: ketika gelombang suara menggetarkan membran, kapasitansinya berubah. Mikrofon electret klasik mengeluarkan perubahan ini sebagai tegangan analog yang lemah, dan kamu harus menguatkan, menyaring, lalu mengukurnya dengan ADC. Di dalam INMP441, preamplifier, filter anti-aliasing, ADC sigma-delta 24-bit, dan antarmuka I2S sudah tergabung jadi satu. Jadi yang keluar dari mikrofon bukan lagi tegangan, melainkan angka-angka yang mengikuti sinyal clock. Dengan begitu tidak ada derau analog yang tertangkap di kabel, kualitas ADC board-mu tidak lagi berpengaruh, dan mikrokontroler 3,3 V apa pun yang cocok akan mendapat kualitas suara yang sama. Lubang kecil di modul adalah lubang masuk suara mikrofon; hati-hati jangan sampai tertutup ketika kamu memasang board di dalam casing.

Apa itu I2S? Audio digital lewat tiga jalur

I2S (Inter-IC Sound) adalah bus serial yang dirancang untuk membawa sampel audio antar-chip, dan walaupun namanya mirip, tidak ada hubungannya dengan I2C. Bus ini punya tiga jalur: SCK (bit clock) menentukan kapan setiap bit data harus dibaca, WS (word select, disebut juga LRCLK) menunjukkan apakah yang sedang dikirim pada momen itu kanal kiri atau kanal kanan, dan SD adalah datanya sendiri. Dalam susunan ini ESP32 adalah master: ia yang menghasilkan kedua clock, dan mikrofon mengikuti clock tersebut lalu menaruh data di jalur SD. Pada INMP441 setiap frame terdiri dari 64 pulsa SCK: 32 bit untuk kanal kiri dan 32 bit untuk kanal kanan. Karena itu sample rate-nya adalah SCK / 64; untuk sampling 16 kHz, ESP32 menghasilkan bit clock sekitar 1,024 MHz. Mikrofon menulis hasil pengukuran 24-bit-nya dengan MSB lebih dulu ke slot 32-bit milik kanalnya, dan 8 bit sisanya bernilai nol. Itulah sebabnya kode menggeser nilainya 8 bit ke kanan.

Pengkabelan INMP441: ESP32 dan Raspberry Pi Pico

Di ESP32, sinyal I2S bisa diarahkan ke pin mana pun lewat matriks GPIO; angka 32, 25, dan 33 di tabel tidak wajib, hanya pilihan yang aman. Cukup hindari pin strapping yang menentukan perilaku board ketika boot (GPIO 0, 2, 5, 12, 15) dan GPIO 6–11 yang dipakai untuk memori flash. GPIO 34–39 hanya bisa jadi input, jadi cocok untuk jalur SD tetapi tidak bisa dipakai untuk SCK dan WS. Aturan di Pico berbeda: driver I2S MicroPython memakai PIO dan pin WS harus satu nomor lebih tinggi dari pin SCK (misalnya GP16 dan GP17). Buat kabel lebih pendek dari 10–15 cm; sinyal clock di kisaran megahertz akan rusak di kabel jumper yang panjang. Kamu bisa mengecek susunan pin board-mu di alat diagram pin.

Langkah demi langkah: pembacaan audio pertamamu dengan ESP32

1. Pastikan paket board ESP32 sudah terinstal di Arduino IDE dan pilih ESP32 Dev Module di Tools > Board. Kalau belum tahu cara instalnya, lihat Apa Itu ESP32?.
2. Pasang modul di breadboard; hubungkan VDD ke 3V3, GND ke GND, dan L/R ke GND.
3. Hubungkan SCK ke GPIO 32, WS ke GPIO 25, dan SD ke GPIO 33, lalu buat kabelnya tetap pendek.
4. Upload kode di bawah. Tidak perlu library tambahan: ESP_I2S di core 3.x dan driver/i2s.h di core 2.x sudah termasuk dalam paket board.
5. Buka Serial Monitor di 115200 baud; di ruangan yang sepi kamu seharusnya melihat nilai sekitar 35–50 dB, dan sekitar 55–70 dB ketika berbicara.
6. Buka Tools > Serial Plotter untuk melihat kurva dBFS dan dB SPL secara langsung; tepuk tangan di dekat mikrofon dan lihat kurvanya melonjak.

Kode ESP32: mengukur level suara (dB) dengan INMP441

Kode ini mengecek versi core Arduino ESP32 dengan ESP_ARDUINO_VERSION_MAJOR. Di versi 3.x ia memakai library ESP_I2S yang baru, sedangkan di 2.x ia memakai driver I2S klasik dari ESP-IDF. Kedua jalur menyediakan fungsi micBegin() dan micRead() yang sama, jadi perhitungan di loop() tidak berubah. Setiap perulangan membaca 512 sampel, yaitu 32 ms audio pada 16 kHz, membuang offset DC, mencari nilai RMS, lalu mengubahnya ke desibel.

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}

Bagaimana level suara dihitung? dBFS dan dB SPL

Karena tekanan suara berubah dalam rentang yang sangat lebar, dipakailah skala desibel yang logaritmik: amplitudo dua kali lipat berarti sekitar +6 dB, dan amplitudo sepuluh kali lipat berarti +20 dB. Angka dari mikrofon pertama-tama diubah ke dBFS (desibel relatif terhadap skala penuh): dBFS = 20 × log10(RMS / RMS skala penuh). Skala penuh adalah RMS dari gelombang sinus yang puncaknya mencapai nilai 24-bit terbesar, 8.388.608, yaitu 8.388.608 / √2 ≈ 5.931.642. Di skala ini 0 dBFS adalah batas clipping mikrofon, dan setiap suara yang lebih pelan mendapat nilai negatif. Untuk beralih ke tekanan suara fisik, yaitu dB SPL, dipakai sensitivitas dari datasheet: INMP441 mengeluarkan suara 1 kHz sebesar 94 dB SPL sebagai −26 dBFS. Dari sini didapat rumus dB SPL = dBFS + 94 − (−26) = dBFS + 120. Contohnya, kalau nilai RMS-nya 5932, maka dBFS = 20 × log10(0,001) = −60 dan level suaranya sekitar 60 dB SPL, yaitu level orang berbicara normal.

Menggambar bentuk gelombang di Serial Plotter

Nilai desibel memberi tahu seberapa keras suaranya; untuk melihat bentuk suaranya kamu perlu menggambar sampel mentahnya. Di sketch yang sama, ganti hanya fungsi loop() dengan yang di bawah. Ada batasan penting di sini: jalur serial 115200 baud membawa sekitar 11.500 karakter per detik, dan itu tidak cukup untuk mencetak 16.000 sampel per detik. Karena itu kode mencetak satu blok 512 sampel secara berurutan; suara yang datang selama blok dicetak akan terlewat, tetapi setiap potongan yang kamu lihat di plotter adalah irisan 32 ms yang nyata dan tidak terputus.

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}

Ketika kamu bersiul ke mikrofon, kamu akan melihat gelombang sinus yang hampir mulus di plotter. Untuk siulan 1 kHz, satu periode berlangsung 1 ms dan setara dengan 16 titik pada sampling 16 kHz; dengan menghitung jumlah titik dalam satu periode, kamu bisa memperkirakan frekuensinya secara kasar. Karena suara bicara adalah campuran banyak frekuensi, bentuk gelombangnya tidak beraturan dan berselubung; tepuk tangan menghasilkan lonjakan pendek yang sangat tinggi. Karena plotter menskalakan sumbunya secara otomatis, fluktuasi derau kecil bisa terlihat besar ketika suasana sepi, dan itu normal. Untuk detail pemakaian Serial Monitor dan Serial Plotter, lihat artikel Serial Monitor Arduino.

INMP441 dengan Raspberry Pi Pico (MicroPython)

Raspberry Pi Pico tidak punya unit I2S khusus, tetapi blok PIO yang bisa diprogram mampu meniru I2S dengan kecepatan hardware, dan kelas machine.I2S di MicroPython mengerjakannya untukmu. Kamu tidak perlu menginstal file tambahan; cukup pastikan versi MicroPython yang terbaru sudah terpasang. Di kode dipilih bits=32 dan format=I2S.MONO, sampel yang terbaca kembali digeser 8 bit ke kanan dan diubah ke desibel dengan rumus yang sama. Karena perulangan Python lebih lambat dari C, menjaga ukuran blok di 512 sampel adalah keseimbangan yang baik; suara beberapa milidetik yang terlewat selama perhitungan berjalan hampir tidak memengaruhi hasilnya. Kalau kamu memprogram Pico dengan Arduino IDE, library I2S di core arduino-pico juga melakukan hal yang sama; di sana pun pin WS (LRCLK) harus satu nomor lebih tinggi dari pin BCLK. Kalau kamu baru mengenal MicroPython, baca dulu Apa Itu 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 vs sensor suara analog KY-038

KY-038 adalah modul murah yang terdiri dari kapsul mikrofon electret, trimpot untuk mengatur ambang, dan komparator LM393. Output digitalnya (DO) berubah status ketika suara melewati ambang yang kamu atur; output analognya (AO) memberikan tegangan mentah dari kapsul dan dibaca dengan ADC board. Desain ini cukup untuk mendeteksi tepuk tangan atau mengetahui ada tidaknya suara di ruangan. Tetapi karena modul ini tidak punya penguat, sinyalnya sangat lemah: ADC 10-bit Arduino Uno hanya melihat perubahan beberapa langkah ketika ada orang berbicara, dan ADC ESP32 cukup berderau. Sebaliknya, INMP441 melakukan pengukuran di dalam mikrofon dengan 24 bit; karena tidak ada kabel analog, penguat, atau ADC di antaranya, ia merekam rentang sekitar 87 dB, dari derau dasar sampai batas clipping, dengan bersih. Singkatnya, KY-038 adalah sakelar suara, sedangkan INMP441 adalah mikrofon sungguhan. Batasan pembacaan analog bisa kamu temukan secara detail di panduan ADC.

Ide proyek dengan INMP441

• LED yang bereaksi terhadap suara: ubah level suara menjadi jumlah LED yang menyala di strip WS2812B; untuk detailnya lihat artikel LED reaktif musik dan WS2812B NeoPixel.
• Lampu lalu lintas kebisingan kelas: buat lampu peringatan yang menyala hijau di bawah 55 dB, kuning di antara 55–70 dB, dan merah di atasnya.
• Dasbor kebisingan langsung di web: kirim nilai dB ke browser lewat WebSocket dan pantau sebagai grafik dari ponselmu; struktur dasarnya ada di Web Server dan WebSocket ESP32.
• Sensor kebisingan rumah pintar: kirim hasil pengukuran ke Home Assistant lewat MQTT; panduan MQTT dan Home Assistant akan memudahkanmu.
• Peringatan bayi menangis atau anjing menggonggong: kalau suara melewati ambang selama waktu tertentu, kirim pesan ke ponselmu dengan bot Telegram.
• Perekam suara: tulis sampel sebagai file WAV 16-bit ke modul kartu SD lalu dengarkan di komputer.
• Kendali dengan siulan: cari frekuensi dominan dengan FFT dan picu LED atau relay pada nada siulan tertentu.

Kesalahan umum dan cara mengatasinya

Dengan beberapa kabel dan sketch pendek, INMP441 memberi ESP32-mu mikrofon digital sungguhan; modul ini jadi dasar banyak proyek, dari mengukur level suara sampai lampu yang bereaksi terhadap suara. Setiap kali kamu ingin mengolah suara sebagai angka alih-alih puas dengan sensor analog, inilah pilihan pertama. Di aplikasi BlueGrays kamu bisa mengikuti skema rangkaian dan kode langkah demi langkah untuk proyek ESP32 dengan LED, buzzer, strip WS2812B, dan web server, lalu dengan mudah menambahkan mikrofon ini di atasnya.