Micro I2S INMP441 ESP32 : lire le son, mesurer les dB et la forme d'onde

Le INMP441 est un petit module de micro MEMS qui convertit le son en numérique directement à l'intérieur et envoie des échantillons de 24 bits via le bus I2S. Le duo INMP441 ESP32 est le moyen le plus simple d'obtenir un son propre sans micro analogique, sans amplificateur ni CAN. Tu relies le module à l'ESP32 avec six fils, tu récupères 16 000 échantillons par seconde avec quelques lignes de code I2S, tu calcules le niveau sonore ambiant en décibels (dB) et tu observes la forme d'onde en direct dans le traceur série.

Dans ce guide, tu vois pas à pas comment fonctionne l'INMP441, le rôle des trois lignes I2S, un code prêt à compiler avec les versions 2.x et 3.x du noyau Arduino ESP32, la différence entre dBFS et dB SPL et la formule d'un vrai sonomètre. À la fin, tu trouves l'utilisation avec le Raspberry Pi Pico en MicroPython, la différence avec le capteur de son KY-038 bon marché et les erreurs de câblage les plus courantes.

Qu'est-ce que l'INMP441 et comment fonctionne-t-il ?

L'INMP441, fabriqué par TDK InvenSense, est un micro MEMS omnidirectionnel (il entend de façon égale dans toutes les directions). Un MEMS est un minuscule condensateur formé d'une membrane microscopique gravée sur silicium et d'une plaque fixe : quand l'onde sonore fait vibrer la membrane, la capacité change. Dans un micro électret classique, cette variation sort sous forme d'une faible tension analogique que tu dois amplifier, filtrer et mesurer avec un CAN. Dans l'INMP441, le préamplificateur, le filtre anti-repliement, le CAN sigma-delta 24 bits et l'interface I2S sont réunis. Ce qui sort du micro n'est donc plus une tension, mais des nombres cadencés par une horloge. Le câble ne capte plus de bruit analogique, la qualité du CAN de la carte n'a plus d'importance et tout microcontrôleur 3,3 V adapté obtient la même qualité sonore. Le petit trou sur le module est l'entrée sonore du micro ; ne le bouche pas quand tu montes la carte dans un boîtier.

Qu'est-ce que l'I2S ? Du son numérique avec trois lignes

L'I2S (Inter-IC Sound) est un bus série conçu pour transporter des échantillons audio entre circuits ; malgré la ressemblance des noms, il n'a rien à voir avec l'I2C. Il comporte trois lignes : SCK (horloge de bit) indique quand lire chaque bit, WS (word select, aussi appelé LRCLK) indique si c'est le canal gauche ou droit qui est envoyé, et SD porte les données. Ici, l'ESP32 est le maître : il génère les deux horloges, et le micro place les données sur SD en suivant l'horloge. Sur l'INMP441, chaque trame compte 64 impulsions SCK : 32 bits pour le canal gauche, 32 bits pour le droit. La fréquence d'échantillonnage vaut donc SCK / 64 ; pour 16 kHz, l'ESP32 génère une horloge de bit d'environ 1,024 MHz. Le micro écrit sa mesure de 24 bits, bit de poids fort en premier, dans l'emplacement de 32 bits de son canal ; les 8 bits restants sont à zéro. C'est pourquoi, dans le code, on décale la valeur de 8 bits vers la droite.

Branchement de l'INMP441 : ESP32 et Raspberry Pi Pico

Sur l'ESP32, les signaux I2S peuvent être routés vers n'importe quelle broche via la matrice GPIO ; les numéros 32, 25 et 33 du tableau ne sont pas obligatoires, ce sont juste des choix sûrs. Évite seulement les broches de strapping qui déterminent le comportement au démarrage (GPIO 0, 2, 5, 12, 15) et les GPIO 6–11 réservés à la mémoire flash. Les GPIO 34–39 sont des entrées seules : ils conviennent pour SD, mais pas pour SCK et WS. Sur le Pico, la règle est différente : le pilote I2S de MicroPython utilise le PIO et la broche WS doit être celle qui suit la broche SCK (comme GP16 et GP17). Garde des fils de moins de 10–15 cm ; une horloge de l'ordre du mégahertz se dégrade sur de longs jumpers. Tu peux vérifier le brochage de ta carte avec l'outil de brochage.

Pas à pas : première lecture audio avec l'ESP32

1. Vérifie que le paquet de cartes ESP32 est installé dans l'IDE Arduino et choisis ESP32 Dev Module dans le menu Outils > Type de carte. Si tu ne sais pas l'installer, lis Qu'est-ce que l'ESP32 ?.
2. Place le module sur la breadboard ; relie VDD à 3V3, GND à GND et L/R à GND.
3. Relie SCK au GPIO 32, WS au GPIO 25 et SD au GPIO 33, en gardant les fils courts.
4. Téléverse le code ci-dessous. Aucune bibliothèque supplémentaire n'est nécessaire : ESP_I2S avec le noyau 3.x et driver/i2s.h avec le noyau 2.x sont déjà inclus dans le paquet de cartes.
5. Ouvre le moniteur série à 115200 bauds ; tu dois voir environ 35–50 dB dans une pièce silencieuse et 55–70 dB quand tu parles.
6. Ouvre Outils > Traceur série pour suivre en direct les courbes dBFS et dB SPL ; tape dans les mains près du micro et regarde la courbe bondir.

Code ESP32 : mesurer le niveau sonore (dB) avec l'INMP441

Le code vérifie la version du noyau Arduino ESP32 avec ESP_ARDUINO_VERSION_MAJOR. Avec la version 3.x, il utilise la nouvelle bibliothèque ESP_I2S ; avec la 2.x, le pilote I2S classique d'ESP-IDF. Les deux voies fournissent les mêmes fonctions micBegin() et micRead(), donc le calcul dans loop() ne change pas. À chaque boucle, 512 échantillons (soit 32 ms de son à 16 kHz) sont lus, le décalage continu est retiré, la valeur RMS est calculée puis convertie en décibels.

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}

Comment calculer le niveau sonore ? dBFS et dB SPL

La pression acoustique varie sur une très large plage, on utilise donc l'échelle logarithmique des décibels : doubler l'amplitude ajoute environ 6 dB, la multiplier par dix ajoute 20 dB. Les nombres fournis par le micro sont d'abord convertis en dBFS (décibels par rapport à la pleine échelle) : dBFS = 20 × log10(RMS / RMS pleine échelle). La pleine échelle est la valeur RMS d'une sinusoïde dont le pic atteint la plus grande valeur 24 bits, 8 388 608, soit 8 388 608 / √2 ≈ 5 931 642. Sur cette échelle, 0 dBFS est la limite de saturation du micro et tout son plus faible a une valeur négative. Pour passer à la pression acoustique physique, c'est-à-dire aux dB SPL, on utilise la sensibilité de la fiche technique : l'INMP441 donne un son de 1 kHz à 94 dB SPL comme −26 dBFS. On en tire dB SPL = dBFS + 94 − (−26) = dBFS + 120. Par exemple, si le RMS vaut 5 932, dBFS = 20 × log10(0,001) = −60 et le niveau est d'environ 60 dB SPL, soit une conversation normale.

Tracer la forme d'onde dans le traceur série

La valeur en décibels dit à quel point le son est fort ; pour voir sa forme, il faut tracer les échantillons bruts. Dans le même sketch, remplace seulement la fonction loop() par celle ci-dessous. Il y a une limite importante : une liaison série à 115200 bauds transporte environ 11 500 caractères par seconde, ce qui ne suffit pas pour afficher 16 000 échantillons par seconde. Le code affiche donc un bloc de 512 échantillons à la suite ; le son arrivant pendant l'écriture est perdu, mais chaque morceau que tu vois dans le traceur est un vrai extrait continu 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}

Quand tu siffles dans le micro, tu vois dans le traceur une sinusoïde presque régulière. Pour un sifflement à 1 kHz, une période dure 1 ms et correspond à 16 points à 16 kHz d'échantillonnage ; en comptant les points d'une période, tu peux estimer grossièrement la fréquence. La voix étant un mélange de nombreuses fréquences, elle dessine une onde irrégulière avec une enveloppe ; un claquement de mains produit un pic bref et très élevé. Comme le traceur ajuste l'échelle automatiquement, de petites fluctuations de bruit peuvent sembler grandes dans le silence, c'est normal. Pour les détails sur le moniteur série et le traceur série, consulte l'article Moniteur série Arduino.

INMP441 avec le Raspberry Pi Pico (MicroPython)

Le Raspberry Pi Pico n'a pas d'unité I2S dédiée, mais ses blocs PIO programmables émulent l'I2S à vitesse matérielle et la classe machine.I2S de MicroPython fait le travail à ta place. Aucun fichier supplémentaire à installer ; il suffit d'avoir une version récente de MicroPython. Dans le code, on choisit bits=32 et format=I2S.MONO, les échantillons lus sont de nouveau décalés de 8 bits vers la droite et convertis en décibels avec la même formule. Les boucles Python étant plus lentes que le C, garder la taille de bloc à 512 échantillons est un bon compromis ; perdre quelques millisecondes de son pendant le calcul n'affecte guère le résultat. Si tu programmes le Pico avec l'IDE Arduino, la bibliothèque I2S du noyau arduino-pico fait le même travail ; là aussi, la broche WS (LRCLK) doit suivre la broche BCLK. Si tu débutes en MicroPython, lis d'abord Qu'est-ce que le 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))

Différence entre l'INMP441 et le capteur de son analogique KY-038

Le KY-038 est un module bon marché composé d'une capsule de micro électret, d'un potentiomètre de réglage du seuil et d'un comparateur LM393. Sa sortie numérique (DO) change d'état quand le son dépasse le seuil que tu as réglé ; sa sortie analogique (AO) donne la tension brute de la capsule, que tu lis avec le CAN de la carte. Cette structure suffit pour détecter un claquement de mains ou savoir s'il y a du son dans la pièce. Mais comme le module n'a pas d'amplificateur, le signal est très faible : le CAN 10 bits de l'Arduino Uno ne voit que quelques pas de variation en parlant, et le CAN de l'ESP32 est bruité. L'INMP441, lui, fait la mesure en 24 bits à l'intérieur du micro ; comme il n'y a ni câble analogique, ni amplificateur, ni CAN entre les deux, il enregistre proprement une plage d'environ 87 dB, du bruit de fond jusqu'à la saturation. En résumé, le KY-038 est un interrupteur sonore, l'INMP441 est un vrai micro. Tu trouveras les limites de la lecture analogique dans le guide du CAN.

Idées de projets avec l'INMP441

• LED réactives à la musique : convertis le niveau sonore en nombre de LED allumées sur une bande WS2812B ; pour les détails, vois les articles LED réactives à la musique et WS2812B NeoPixel.
• Feu tricolore du bruit en classe : fabrique une lampe d'alerte verte sous 55 dB, jaune entre 55 et 70 dB et rouge au-dessus.
• Tableau de bruit en direct sur le web : envoie la valeur en dB au navigateur par WebSocket et suis un graphique depuis ton téléphone ; la structure de base est dans l'article ESP32 Web Server et WebSocket.
• Capteur de bruit pour maison connectée : envoie les mesures à Home Assistant via MQTT ; le guide ESP32 MQTT et Home Assistant te facilite la tâche.
• Alerte de pleurs de bébé ou d'aboiements : si le son dépasse le seuil pendant un certain temps, envoie un message sur ton téléphone avec un bot Telegram.
• Enregistreur audio : écris les échantillons en fichier WAV 16 bits sur un module carte SD et écoute-les sur l'ordinateur.
• Commande par sifflement : trouve la fréquence dominante avec une FFT et déclenche une LED ou un relais à une certaine note sifflée.

Erreurs fréquentes et solutions

Avec quelques fils et un code court, l'INMP441 offre à l'ESP32 un vrai micro numérique ; c'est la base de nombreux projets, de la mesure du niveau sonore aux lumières réactives à la musique. Chaque fois que tu veux traiter le son en nombres plutôt que de te contenter d'un capteur analogique, c'est le premier choix. Dans l'application BlueGrays, tu peux consulter pas à pas, avec schémas et code, des projets ESP32 avec LED, buzzer, bande WS2812B et serveur web, et y ajouter facilement ce micro.