Dans ce guide de démarrage, vous apprendrez à utiliser le microphone omnidirectionnel INMP441 I2S avec l’ESP32 à l’aide de l’IDE Arduino. Nous expliquerons comment câbler le capteur à la carte et créerons trois exemples pour montrer le fonctionnement du capteur. Nous mesurerons l’intensité sonore (RMS), afficherons l’onde sonore dans le traceur série et créerons un projet clap on/clap off dans lequel vous pourrez contrôler une LED (relais ou toute sortie ESP32) avec des claps.
Table des matières
Dans ce guide, nous aborderons les sujets suivants :
Présentation du module microphone INMP441
L’INMP44 est un microphone MEMS (Micro-Electro-Mechanical System) omnidirectionnel. Il capture le son et produit des données audio numériques 24 bits via l’interface I2S (un protocole de communication spécifique utilisé pour la transmission audio).
Il offre un son clair avec une faible consommation d’énergie et un bon rapport signal/bruit. C’est un bien meilleur choix que les microphones analogiques car il inclut déjà la conversion de l’audio en signal numérique filtré.
Les broches doivent être soudées comme indiqué sur les images ci-dessus et ci-dessous. Lorsqu’il est fixé à une maquette, le petit trou du microphone doit être face à vous.
Principales caractéristiques de l’INMP441 :
- Omnidirectionnel : capture le son de toutes les directions, il n’est donc pas nécessaire de procéder à un positionnement précis ;
- Sortie I2S : produit l’audio numérique directement via l’interface I2S ;
- Bonne qualité de signal et faible bruit ;
- Idéal pour les projets embarqués : sa petite taille, sa faible consommation électrique et son interface numérique en font un bon choix pour les projets IoT, notamment avec l’ESP32, qui supporte l’interface I2S.
Communication I2S
L’INMP441 utilise la communication I2S (Inter-IC Sound). Il s’agit d’un protocole de communication série synchrone utilisé pour transmettre des données audio entre deux appareils audio numériques.
L’ESP32 prend en charge I2S via le périphérique I2S à l’aide du pilote I2S, et il peut être configuré comme entrée pour lire des données audio, ou comme sortie pour envoyer des données audio pour lire ou transférer de l’audio.
Pour des informations techniques plus détaillées sur la communication I2S sur l’ESP32, consultez la documentation officielle de l’ESP-IDF : Inter-IC Sound (I2S).
Brochage INMP441
Le module microphone INMP441 communique avec l’ESP32 via le protocole I2S. Il est livré avec les broches suivantes :
- L/R : sélectionne le canal I2S gauche ou droit (connecté à GND sélectionne la gauche, connecté à 3V3 sélectionne la droite). Vous pouvez sélectionner l’un ou l’autre. Ensuite, il vous suffit de modifier le code en conséquence
- WS : Word Select (également appelé LRCLK) – connectez-vous à un GPIO ESP32
- SCK : Serial Clock (également appelé BCLK) – connectez-vous à un GPIO ESP32
- SD : données série, l’audio réel du microphone – connectez-vous à un GPIO ESP32 (entrée)
- GND : connectez-vous à une broche ESP32 GND
- VDD : alimenter le module – utiliser 3,3 V sur l’ESP32
Où acheter ?
Vous pouvez consulter notre page Maker Advisor Tools pour comparer le prix du module de microphone INMP441 dans différents magasins.
Câblage de l’INMP441 à l’ESP32
Dans ce guide, nous utilisons un ESP32-S3 et nous utiliserons les GPIO suivants. Ajustez si vous utilisez une carte avec une puce ESP32 différente.
| INMP441 | ESP32-S3 |
| G/D | GND |
| WS | GPIO40 |
| SCK | GPIO42 |
| SD | GPIO41 |
| GND | GND |
| VDD | 3V3 |
Il n’y a pas de GPIO I2S prédéfinis. Vous pouvez utiliser n’importe quel GPIO ESP32 sûr à utiliser. Lecture recommandée :
Préparation de l’IDE Arduino
Avant de continuer, assurez-vous que l’IDE Arduino et les cartes ESP32 sont installés. Suivez le tutoriel suivant si ce n’est pas déjà fait :
1) INMP441avec l’ESP32 : Intensité sonore (RMS)
Dans cet exemple, nous utiliserons le microphone INMP441 avec l’ESP32 pour mesurer l’intensité du son et l’afficher dans le traceur série Arduino IDE.
Le microphone capture en permanence le son et envoie des échantillons audio à l’ESP32 (via l’interface I2S). Nous pouvons ensuite utiliser ces échantillons pour calculer la valeur RMS (Root Mean Square), qui nous donne une indication de la force du son pendant une courte période.
Le RMS est calculé comme suit :
- Mettre au carré chaque échantillon
- Calculer la moyenne de toutes les valeurs au carré
- Prendre la root carrée du résultat
Plus le son est fort, plus la valeur RMS est élevée.
Code – INMP441 Intensité sonore (RMS)
Pour obtenir des données audio via I2S, nous utiliserons le pilote ESP-IDF/i2s.h dans l’IDE Arduino. Il est inclus par défaut dans le noyau ESP32 Arduino. Vous n’avez pas besoin d’installer de bibliothèques externes.
Copiez le code suivant dans l’IDE Arduino.
/*
Rui Santos & Sara Santos - Raspberryme.com
Complete project details at https://Raspberryme.com/esp32-inmp441-i2s-microphone-arduino/
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/
#include
// Pin configuration
#define I2S_SCK 42 // BCLK
#define I2S_WS 40 // LRCLK / WS
#define I2S_SD 41 // DOUT from mic
#define I2S_PORT I2S_NUM_0
#define SAMPLE_RATE 16000
#define BUFFER_LEN 512
int32_t sBuffer[BUFFER_LEN];
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("INMP441 Microphone");
// I2S configuration
i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = SAMPLE_RATE,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT, // L/R = GND
.communication_format = I2S_COMM_FORMAT_STAND_I2S,
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = BUFFER_LEN,
.use_apll = false
};
// Pin configuration
i2s_pin_config_t pin_config = {
.bck_io_num = I2S_SCK,
.ws_io_num = I2S_WS,
.data_out_num = I2S_PIN_NO_CHANGE,
.data_in_num = I2S_SD
};
// Start I2S
i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
i2s_set_pin(I2S_PORT, &pin_config);
i2s_zero_dma_buffer(I2S_PORT);
Serial.println("I2S started.");
Serial.println("Reading microphone...");
}
void loop() {
size_t bytes_read = 0;
// Read microphone data
i2s_read(I2S_PORT, sBuffer, sizeof(sBuffer), &bytes_read, portMAX_DELAY);
int samples_read = bytes_read / sizeof(int32_t);
double sum = 0;
// Print the samples
for (int i = 0; i < samples_read; i++) {
// INMP441 sends 24-bit audio left-aligned in a 32-bit I2S word
int32_t sample = sBuffer[i] >> 8;
//Serial.println(sample);
sum += (double)sample * sample;
}
// Calculate RMS
double rms = sqrt(sum / samples_read);
// Print RMS
//Serial.print("RMS: ");
Serial.println(rms);
}
Afficher le code brut
Comment fonctionne le code ?
Continuez à lire pour découvrir comment fonctionne le code ou passez à la section de démonstration.
Pilote I2S
Tout d’abord, nous devons inclure le pilote I2S.
#include Broches I2S
Définissez les broches que vous utilisez pour vous connecter au microphone. Modifiez les lignes suivantes si vous utilisez des broches différentes.
// Pin configuration
#define I2S_SCK 42 // BCLK
#define I2S_WS 40 // LRCLK / WS
#define I2S_SD 41 // DOUT from micPort I2S et fréquence d’échantillonnage
Sélectionnez le périphérique I2S 0 et définissez le taux d’échantillonnage (combien d’échantillons audio sont capturés chaque seconde). Nous définissons le taux d’échantillonnage sur 16 000, ce qui est un taux d’échantillonnage courant pour les applications vocales et sonores.
#define I2S_PORT I2S_NUM_0
#define SAMPLE_RATE 16000Taille du tampon RMS
Ensuite, nous définissons la taille du tampon pour le nombre d’échantillons audio que nous utiliserons pour calculer le RMS et créons le tampon réel (sBuffer).
#define BUFFER_LEN 512
int32_t sBuffer[BUFFER_LEN];Remarque : le tampon est prêt à recevoir un échantillon de 32 bits. I2S transfère les données dans des plages horaires de taille fixe. Avec l’INMP441, l’utilisation d’un emplacement 32 bits est le choix pratique même si la résolution audio du microphone est de 24 bits. En d’autres termes, les 24 bits de données INMP441 sont placés dans un mot I2S de 32 bits. Ensuite, nous devons extraire les bits qui contiennent les données.
installation()
Dans setup(), initialisez le moniteur série à un débit en bauds de 115 200.
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("INMP441 Microphone");Configurer I2S – Structures de configuration
Ensuite, nous pouvons configurer le périphérique I2S. Commencez par créer une structure de type i2s_config_t appelée i2s_config avec les configurations pour I2S. Ici, nous attribuons la fréquence d’échantillonnage, les bits par échantillon, le canal (gauche ou droit) et d’autres paramètres de configuration.
// I2S configuration
i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = SAMPLE_RATE,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT, // L/R = GND
.communication_format = I2S_COMM_FORMAT_STAND_I2S,
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = BUFFER_LEN,
.use_apll = false
};Vous pouvez vérifier d’autres valeurs de configuration possibles dans la documentation ESP-IDF I2S.
Ensuite, créez une autre structure (i2s_pin_config_t) pour définir les broches I2S que nous utilisons.
// Pin configuration
i2s_pin_config_t pin_config = {
.bck_io_num = I2S_SCK,
.ws_io_num = I2S_WS,
.data_out_num = I2S_PIN_NO_CHANGE,
.data_in_num = I2S_SD
};Enfin, vous pouvez démarrer I2S en appelant les fonctions suivantes avec les structures de configuration que nous avons créées précédemment.
i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
i2s_set_pin(I2S_PORT, &pin_config);
i2s_zero_dma_buffer(I2S_PORT);boucle()
Dans la boucle(), nous lirons les données du microphone et calculerons le RMS.
Nous appelons la fonction i2s_read() qui lit les données du microphone INMP441 et les enregistre dans le sBuffer. Après chaque lecture réussie, la variable sBuffer contiendra 512 échantillons audio
i2s_read(I2S_PORT, sBuffer, sizeof(sBuffer), &bytes_read, portMAX_DELAY);Ensuite, nous convertissons bytes_read en samples_read en divisant le nombre d’octets reçus par la taille de chaque échantillon. Cela nous indique exactement combien d’échantillons sont disponibles dans le tampon.
int samples_read = bytes_read / sizeof(int32_t);Les lignes suivantes mettent au carré chaque échantillon et additionnent les valeurs au carré.
// Print the samples
for (int i = 0; i < samples_read; i++) {
// INMP441 sends 24-bit audio left-aligned in a 32-bit I2S word
int32_t sample = sBuffer[i] >> 8;
//Serial.println(sample);
sum += (double)sample * sample;
}Ensuite, calculez le RMS en divisant par les échantillons lus et prenez la root carrée.
// Calculate RMS
double rms = sqrt(sum / samples_read);Notez la ligne de code suivante. Les données du microphone 24 bits sont positionnées dans cette valeur 32 bits. Le >> 8 décale la valeur afin que nous obtenions l’échantillon de 24 bits décalé de 8 bits vers la droite, alignant correctement les données audio avant de calculer RMS.
int32_t sample = sBuffer[i] >> 8;Enfin, nous imprimons la valeur RMS. Nous imprimons uniquement cette valeur sur le moniteur série (sans rien d’autre) afin de pouvoir utiliser le traceur série pour mieux visualiser les résultats.
Serial.println(rms);Démonstration
Téléchargez le code sur votre carte ESP32. N’oubliez pas de sélectionner la bonne carte et le bon port COM. J’utilise une carte ESP32-S3.
Après avoir téléchargé le code, ouvrez le traceur série. Son icône se trouve juste à côté de l’icône Serial Monitor.
Une nouvelle fenêtre s’ouvrira, affichant la valeur RMS au fil du temps. Frappez, parlez ou émettez des sons de plus en plus forts et voyez la valeur RMS changer en conséquence.
Dans cet exemple, les pics correspondent au moment où j’ai applaudi et le second au moment où j’ai claqué des doigts.
Vous pouvez désormais vérifier les valeurs RMS pour différentes intensités sonores et les utiliser pour déterminer un seuil. Ensuite, vous pouvez créer un nouveau projet qui déclenche une action lorsque la valeur RMS dépasse un certain seuil.
2) INMP441 avec l’ESP32 : Visualisez la forme d’onde audio
Dans cet exemple, nous allons lire les données audio et afficher la forme d’onde dans le traceur série Arduino. C’est aussi simple que d’obtenir les données audio I2S et de les imprimer sur le moniteur/traceur série.
Copiez le code suivant dans l’IDE Arduino.
/*
Rui Santos & Sara Santos - Raspberryme.com
Complete project details at https://Raspberryme.com/esp32-inmp441-i2s-microphone-arduino/
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/
#include
// Pin configuration
#define I2S_SCK 42 // BCLK
#define I2S_WS 40 // LRCLK / WS
#define I2S_SD 41 // DOUT from mic
#define I2S_PORT I2S_NUM_0
#define SAMPLE_RATE 16000
#define BUFFER_LEN 512
int32_t sBuffer[BUFFER_LEN];
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("INMP441 Microphone");
// I2S configuration
i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = SAMPLE_RATE,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT, // L/R = GND
.communication_format = I2S_COMM_FORMAT_STAND_I2S,
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = BUFFER_LEN,
.use_apll = false
};
// Pin configuration
i2s_pin_config_t pin_config = {
.bck_io_num = I2S_SCK,
.ws_io_num = I2S_WS,
.data_out_num = I2S_PIN_NO_CHANGE,
.data_in_num = I2S_SD
};
// Start I2S
i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
i2s_set_pin(I2S_PORT, &pin_config);
i2s_zero_dma_buffer(I2S_PORT);
Serial.println("I2S started.");
Serial.println("Reading microphone...");
}
void loop() {
size_t bytes_read = 0;
// Read microphone data
i2s_read(I2S_PORT, sBuffer, sizeof(sBuffer), &bytes_read, portMAX_DELAY);
int samples_read = bytes_read / sizeof(int32_t);
// Print the samples
for (int i = 0; i < samples_read; i++) {
// INMP441 sends 24-bit audio left-aligned in a 32-bit I2S word
int32_t sample = sBuffer[i] >> 8;
Serial.println(sample);
}
}
Afficher le code brut
Comment fonctionne le code ?
Ce code fonctionne exactement de la même manière que le précédent, sauf qu’il ne calcule pas le RMS. Tout le reste reste le même.
Nous parcourons chaque échantillon dans le tampon audio et imprimons les résultats. Chaque échantillon représente l’amplitude du signal audio à un moment précis.
// Print the samples
for (int i = 0; i < samples_read; i++) {
// INMP441 sends 24-bit audio left-aligned in a 32-bit I2S word
int32_t sample = sBuffer[i] >> 8;
Serial.println(sample);
}Démonstration
Téléchargez le code sur votre carte ESP32. N’oubliez pas de sélectionner la bonne carte et le bon port COM. J’utilise une carte ESP32-S3.
Après avoir téléchargé le code, ouvrez le traceur série. Son icône se trouve juste à côté de l’icône Serial Monitor.
Désormais, vous pouvez voir l’amplitude de l’onde sonore à un moment donné. Vous pouvez tester cela en produisant le son de différentes voyelles, comme aaaaaa, eeeeee, iiii, oooooo, uuuuu, et voir comment l’onde sonore change.
Les différentes voyelles produisent différentes combinaisons de fréquences, modifiant la forme de la forme d’onde.
Le traceur série n’est peut-être pas le meilleur outil pour visualiser réellement la forme de la forme d’onde. Vous pouvez créer un code Python avec matplotlib. Vous pouvez ajuster l’échelle pour mieux voir et exporter une capture de la forme d’onde.
Extra : Visualisez la forme d’onde sur Matplotlib (instructions rapides)
1) Installez Python (assurez-vous de cocher Ajouter Python au PATH lors de l’installation)
2) Ouvrez le terminal/invite de commande et exécutez pour installer les bibliothèques requises.
pip install pyserial matplotlib
3) Assurez-vous que le code s’exécute sur l’ESP32. Dans l’IDE Arduino, vérifiez le port série (par exemple COM5). Fermez la fenêtre de l’IDE Arduino.
4) Créez un nouveau programme Python. Vous pouvez utiliser le Bloc-notes si vous ne disposez pas d’un éditeur Python, à condition d’enregistrer le fichier avec l’extension .py.
5) Copiez ce code dans ce fichier (voir le fichier INMP441-microphone.py). Modifiez-le avec votre port COM. Enregistrez le code sur votre bureau, par exemple sous le nom INMP441-microphone.py.
6) Dans la fenêtre Terminal, exécutez :
cd Desktop
Et enfin, exécutez le code Python.
python INMP441-microphone.py
Une fenêtre Matplotlib devrait alors s’ouvrir et afficher la forme d’onde.
3) Contrôlez la sortie ESP32 avec Claps (Clap On/Clap Off)
En tenant compte de ce que vous avez appris jusqu’à présent, il est désormais facile de créer un projet simple dans lequel vous pouvez contrôler les sorties ESP32 avec des applaudissements. Voici un aperçu de ce projet :
- Nous contrôlerons un GPIO de l’ESP32 avec des applaudissements – pour mieux visualiser les résultats, nous contrôlerons une LED. Alternativement, vous pouvez contrôler un relais, par exemple pour contrôler une lampe ou des stores.
- Tapez deux fois pour inverser l’état actuel de la LED.
Lorsque vous applaudissez, l’amplitude de l’onde sonore augmente, créant un pic. On voit bien qu’il se démarque de l’onde sonore ambiante. Si nous détectons deux pics au-dessus d’un certain seuil défini dans un court laps de temps, nous considérons que nous avons un double clap et nous inversons l’état de la LED.
Remarque : ce projet ne détecte pas réellement un applaudissement. Il détecte deux pics consécutifs de l’onde sonore (au-dessus d’un certain seuil et dans une période prédéfinie). Cela fonctionne également avec les doigts saisis, les coups, etc.
Avant de continuer, connectez une LED à votre carte ESP32. Nous contrôlons une LED connectée au GPIO 38 (nous utilisons un DevkitC ESP32-S3). Ajustez pour utiliser un autre GPIO si vous utilisez une autre carte.
Pièces requises :
Après avoir câblé le circuit, copiez le code suivant :
/*
Rui Santos & Sara Santos - Raspberryme.com
Complete project details at https://Raspberryme.com/esp32-inmp441-i2s-microphone-arduino/
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/
#include
// Pin configuration
#define I2S_SCK 42 // BCLK
#define I2S_WS 40 // LRCLK / WS
#define I2S_SD 41 // DOUT from mic
#define I2S_PORT I2S_NUM_0
#define SAMPLE_RATE 16000
#define BUFFER_LEN 512
int32_t sBuffer[BUFFER_LEN];
// LED
#define LED_PIN 38
// Clap detection
#define CLAP_THRESHOLD 1000000
// Maximum time allowed between the first and second clap
const unsigned long CLAP_GAP = 700;
// Prevent the same clap from being detected multiple times
const unsigned long CLAP_COOLDOWN = 250;
// State variables
bool ledState = false;
int clapCount = 0;
unsigned long firstClapTime = 0;
unsigned long lastClapTime = 0;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("INMP441 Microphone");
// LED setup
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, LOW);
// I2S configuration
i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = SAMPLE_RATE,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT, // L/R = GND
.communication_format = I2S_COMM_FORMAT_STAND_I2S,
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = BUFFER_LEN,
.use_apll = false
};
// Pin configuration
i2s_pin_config_t pin_config = {
.bck_io_num = I2S_SCK,
.ws_io_num = I2S_WS,
.data_out_num = I2S_PIN_NO_CHANGE,
.data_in_num = I2S_SD
};
// Start I2S
i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
i2s_set_pin(I2S_PORT, &pin_config);
i2s_zero_dma_buffer(I2S_PORT);
Serial.println("I2S started.");
Serial.println("Double clap to control LED");
}
void loop() {
size_t bytes_read = 0;
// Read microphone data
i2s_read(I2S_PORT, sBuffer, sizeof(sBuffer), &bytes_read, portMAX_DELAY);
int samples_read = bytes_read / sizeof(int32_t);
// Find the loudest sample
int32_t peak = 0;
// Print the samples
for (int i = 0; i < samples_read; i++) {
int32_t sample = sBuffer[i] >> 8;
int32_t magnitude = abs(sample);
if (magnitude > peak) {
peak = magnitude;
}
}
// Print peak
Serial.println(peak);
// Detect a clap
unsigned long now = millis();
if (peak > CLAP_THRESHOLD && now - lastClapTime > CLAP_COOLDOWN) {
lastClapTime = now;
// First clap
if (clapCount == 0) {
clapCount = 1;
firstClapTime = now;
Serial.println("First clap detected");
}
// Second clap
else if (now - firstClapTime <= CLAP_GAP) {
clapCount = 0;
// Double clap - invert LED state
ledState = !ledState;
digitalWrite(LED_PIN, ledState);
if (ledState) {
Serial.println("DOUBLE CLAP - LED ON");
}
else {
Serial.println("DOUBLE CLAP - LED OFF");
}
}
// Too much time passed
else {
// Treat this clap as the beginning of a new pair
clapCount = 1;
firstClapTime = now;
Serial.println("New first clap");
}
}
// Reset if second clap doesn't arrive in time
if (clapCount == 1 && now - firstClapTime > CLAP_GAP) {
clapCount = 0;
}
}
Afficher le code brut
Comment fonctionne le code ?
L’initialisation du protocole I2S et l’obtention de l’onde sonore fonctionnent exactement comme dans les projets précédents.
Nous allons contrôler le GPIO 38. Ajustez en conséquence dans la ligne suivante.
// LED
#define LED_PIN 38Nous devons définir un seuil d’applaudissements. C’est l’amplitude au-dessus de laquelle on considérera qu’il y a un applaudissement. Il doit se démarquer de l’amplitude du son ambiant. Vous devrez peut-être ajuster cette valeur pour votre scénario.
// Clap detection
#define CLAP_THRESHOLD 1000000Nous considérerons que nous avons un double tap si nous avons deux pics au-dessus du seuil qui se produisent avec une différence maximale de 700 millisecondes.
const unsigned long CLAP_GAP = 700;Nous ignorerons les pics qui surviennent après 250 millisecondes. Cela nous permet d’éviter que le même clap soit détecté plusieurs fois.
const unsigned long CLAP_COOLDOWN = 250;Nous enregistrerons l’heure du premier coup et l’heure du dernier coup. Avec cela, nous pouvons déterminer si nous avons un double clap. Nous enregistrerons l’heure à laquelle les applaudissements se sont produits dans les variables suivantes (firstClapTime, lastClapTime). Nous enregistrerons également le numéro de clap (premier clap ou deuxième clap) dans la variable clapCount.
int clapCount = 0;
unsigned long firstClapTime = 0;
unsigned long lastClapTime = 0;Dans la boucle(), nous obtenons continuellement des données audio et les enregistrons dans la variable tampon samples_read.
// Read microphone data
i2s_read(I2S_PORT, sBuffer, sizeof(sBuffer), &bytes_read, portMAX_DELAY);
int samples_read = bytes_read / sizeof(int32_t);Dans chaque tampon que nous obtenons, nous vérifions l’amplitude (amplitude de l’échantillon) et obtenons le pic de l’échantillon.
// Find the loudest sample
int32_t peak = 0;
// Print the samples
for (int i = 0; i < samples_read; i++) {
int32_t sample = sBuffer[i] >> 8;
int32_t magnitude = abs(sample);
if (magnitude > peak) {
peak = magnitude;
}
}Nous économisons le temps de cet échantillon, puis nous vérifions les conditions d’un double clap. Le pic doit être supérieur à la valeur seuil, et le temps entre le pic actuel et le dernier pic doit être supérieur au temps de recharge du clap.
// Detect a clap
unsigned long now = millis();
if (peak > CLAP_THRESHOLD && now - lastClapTime > CLAP_COOLDOWN) {Si ces conditions sont remplies, et si nous n’avons toujours pas de premier clap, nous considérons celui-ci comme le premier clap et enregistrons l’heure à laquelle il s’est produit dans la variable firstClapTime.
// First clap
if (clapCount == 0) {
clapCount = 1;
firstClapTime = now;
Serial.println("First clap detected");
}Ensuite, si nous détectons un deuxième clap (l’intervalle entre le premier et le deuxième tapotement est plus petit que l’intervalle des claps), nous inversons l’état de la LED. Nous réinitialisons également le clapCount à 0 pour commencer à rechercher de nouveaux doubles claps.
// Second clap
else if (now - firstClapTime <= CLAP_GAP) {
clapCount = 0;
// Double clap: invert LED state
ledState = !ledState;
digitalWrite(LED_PIN, ledState);
if (ledState) {
Serial.println("DOUBLE CLAP - turn LED ON");
}
else {
Serial.println("DOUBLE CLAP - turn LED OFF");
}
}Si trop de temps s’est écoulé depuis le premier clap (au-dessus de l’intervalle des clap), nous considérerons désormais ce deuxième coup comme le premier.
// Too much time passed
else {
// Treat this clap as the beginning of a new pair
clapCount = 1;
firstClapTime = now;
Serial.println("New first clap");
}Enfin, si nous n’avons pas de deuxième applaudissements dans le temps imparti, nous réinitialisons le clapCount à 0 pour commencer à rechercher de nouveaux applaudissements.
// Reset if second clap doesn't arrive in time
if (clapCount == 1 && now - firstClapTime > CLAP_GAP) {
clapCount = 0;
}Démonstration
Téléchargez le code sur la carte ESP32. Assurez-vous d’avoir sélectionné la bonne carte et le bon port COM.
Maintenant, applaudissez deux fois. La LED devrait s’allumer. Frappez à nouveau deux fois et la LED devrait s’éteindre. Vous pouvez consulter la démonstration vidéo rapide suivante.
Si la LED clignote continuellement, cela signifie que vous devez augmenter le seuil de prise dans la variable CLAP_THRESHOLD.
#define CLAP_THRESHOLD 1000000Si la LED ne s’allume pas lorsque vous applaudissez, cela signifie que vous devez diminuer la variable CLAP_THRESHOLD.
Pour choisir une valeur plus appropriée pour la variable CLAP_THRESHOLD, décommentez la ligne suivante qui imprimera l’amplitude audio.
//Serial.println(peak);Vérifiez les valeurs du son ambiant (lorsque vous n’applaudissez pas). Vérifiez les valeurs lorsque vous applaudissez. La valeur seuil doit être comprise entre ces deux (un peu inférieure au pic de l’onde sonore lorsque vous applaudissez).
Conclusion
Dans ce guide, vous avez appris à interfacer le module microphone INMP441 avec l’ESP32 à l’aide du protocole de communication I2S. Vous avez appris à configurer le bus I2S et à obtenir des données via I2S.
Avec l’INMP441, nous récupérons en permanence des données audio et les enregistrons dans un tampon. Ensuite, nous pouvons utiliser les données du tampon pour visualiser la forme d’onde audio ou effectuer des calculs comme le RMS.
Dans les projets audio, vous trouverez peut-être également utile d’interfacer un amplificateur comme le MAX98357 pour la sortie audio, également via I2S. Nous créerons bientôt un didacticiel sur ce module, alors restez à l’écoute.
Nous espérons que vous avez trouvé ce guide utile.
Nous avons d’autres guides ESP32 pour les capteurs et les modules qui pourraient vous plaire :
Apprenez-en plus sur l’ESP32 avec nos ressources :
Cette vidéo vous emmène dans l’histoire de Raspberry Pi :
