Le XIAO MG24 Sense fait partie de la série XIAO de Seeed Studio, combinant un microcontrôleur puissant Silicon Labs EFR32MG24 avec des capteurs intégrés comme un microphone et une IMU 6 axes. Grâce à son format compact, sa faible consommation d’énergie et ses capacités sans fil intégrées, c’est un excellent choix pour des projets IoT, de fusion de capteurs et d’IA embarquée.
Dans ce guide, nous allons parcourir les bases pour débuter avec le XIAO MG24 Sense. Nous commencerons par installer le core nécessaire, puis exécuterons l’exemple classique Blink pour vérifier que tout fonctionne. Ensuite, nous explorerons ses caractéristiques principales : le microphone embarqué et l’IMU (Unité de Mesure Inertielle).
Pièces requises
Vous aurez besoin d’une carte XIAO MG24 Sense de Seeed Studio et d’un câble USB-C pour programmer la carte et tester les exemples de code.
Seeed Studio XIAO MG24 Sense
Câble USB-C
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Le XIAO MG24 Sense
Le XIAO MG24 Sense est équipé du système sur puce Silicon Labs EFR32MG24, qui utilise un microcontrôleur ARM Cortex-M33 cadencé jusqu’à 78 MHz. Cela lui confère une grande capacité de traitement pour des projets embarqués tout en restant très économe en énergie. Une caractéristique remarquable de cette puce est le Matrix-Vector Processor (MVP), un petit accélérateur matériel qui accélère les opérations mathématiques nécessaires au machine learning. Cela rend le MG24 Sense particulièrement adapté aux applications TinyML, comme la détection de mots-clés ou la classification de mouvements, sans épuiser rapidement la batterie.
En termes de mémoire, la carte intègre 1,5 Mo de flash et 256 Ko de RAM dans le microcontrôleur. De plus, Seeed Studio a ajouté une puce flash SPI externe de 4 Mo, utile pour stocker des programmes plus volumineux, des données de modèles ou même des journaux. La combinaison de mémoire interne et externe vous offre de la marge pour expérimenter des applications plus complexes tout en conservant un format compact.
La connectivité sans fil est un autre point fort de cet appareil. Le MG24 supporte Matter via Thread ainsi que Bluetooth Low Energy 5.3, garantissant la compatibilité avec les écosystèmes IoT modernes et la connectivité smartphone. La carte intègre aussi des fonctions de sécurité matérielle Secure Vault, qui protègent les données sensibles comme les clés de chiffrement et permettent un démarrage sécurisé.
Capteurs
Le « Sense » dans le nom de la carte vient de ses capteurs embarqués. D’abord, il y a l’IMU LSM6DS3TR-C, un capteur six axes combinant un accéléromètre 3 axes et un gyroscope 3 axes. Ce capteur peut mesurer le mouvement, l’orientation, les pas et les gestes, et inclut même des modes basse consommation pour une détection d’activité continue sans forte consommation d’énergie. Vous trouverez plus de détails dans la fiche technique ci-dessous :
En plus de l’IMU, il y a le microphone MEMS MSM381ACT001, qui permet de capturer le son. Bien qu’il soit analogique, l’ADC du microcontrôleur facilite l’échantillonnage et le traitement audio, que ce soit pour la détection sonore ou les interactions déclenchées par la voix. Voir la fiche technique ci-dessous :
GPIO
Pour l’interface matérielle, le XIAO MG24 Sense expose 19 broches GPIO (entrée/sortie généraliste), disposées selon le format XIAO habituel. Ces broches peuvent être utilisées pour I²C, SPI, UART et d’autres interfaces standards.
Une LED utilisateur et une LED d’alimentation/charge sont également présentes pour faciliter le débogage et fournir un retour rapide. Le chargement du code se fait via le connecteur USB-C, qui sert aussi d’interface d’alimentation et de charge.
Alimentation
L’efficacité énergétique est l’un des points forts du XIAO MG24 Sense. En mode sommeil profond, le microcontrôleur peut réduire sa consommation à seulement quelques microampères, ce qui le rend idéal pour des projets alimentés par batterie. La carte intègre un circuit de charge pour batteries Li-Po, et peut aussi mesurer la tension de la batterie pour que vos projets surveillent leur propre niveau d’énergie. Avec ces fonctionnalités, le MG24 Sense est un excellent choix pour des nœuds IoT autonomes à long terme.
Taille
Malgré toutes ces fonctionnalités, la carte conserve le format classique XIAO de seulement 21 × 17,8 mm, ce qui la rend facile à intégrer dans des projets compacts ou des objets portables. Elle inclut une antenne embarquée pour la communication sans fil, vous évitant d’ajouter des modules supplémentaires pour démarrer.
Pour résumer, le XIAO MG24 Sense combine un microcontrôleur puissant et efficace, une connectivité sans fil moderne, une sécurité matérielle, des capteurs de mouvement et audio intégrés, une mémoire généreuse et un design adapté aux batteries dans un format très compact.
Spécifications techniques
| Caractéristique | Spécification |
|---|---|
| Processeur | Silicon Labs EFR32MG24, ARM Cortex-M33, jusqu’à 78 MHz |
| Accélérateur matériel | Matrix-Vector Processor (MVP) pour charges ML |
| Mémoire interne | 1536 Ko flash, 256 Ko RAM |
| Mémoire externe | 4 Mo flash SPI |
| Sans fil | Matter (Thread), Bluetooth Low Energy 5.3 |
| Sécurité | Moteur de sécurité matériel Secure Vault |
| IMU | LSM6DS3TR-C, accéléromètre + gyroscope 6 axes |
| Microphone | Microphone MEMS analogique MSM381ACT001 |
| GPIO | 19 broches (I²C, SPI, UART, GPIO, etc.) |
| USB | USB-C pour programmation, alimentation et charge |
| Fonctionnalités batterie | Circuit de charge embarqué, surveillance de la tension batterie |
| Efficacité énergétique | Ultra-basse consommation, courant de sommeil ~1,95 µA |
| Format | 21 × 17,8 mm, antenne embarquée |
XIAO MG24 Sense versus XIAO MG24
Seeed Studio propose deux versions proches de cette carte : le XIAO MG24 et le XIAO MG24 Sense. Les deux partagent la même base, construite autour du microcontrôleur EFR32MG24 avec son cœur ARM Cortex-M33, le Matrix-Vector Processor pour le machine learning, et le support des standards sans fil modernes comme Matter (Thread) et Bluetooth Low Energy 5.3. Ils ont aussi le même format compact XIAO, la même mémoire flash externe de 4 Mo, et le même design basse consommation avec un circuit de charge embarqué pour batteries Li-Po.
La principale différence réside dans les capacités de détection. Le XIAO MG24 Sense intègre deux capteurs supplémentaires embarqués : l’IMU 6 axes LSM6DS3TR-C et le microphone MEMS analogique MSM381ACT001. Ces ajouts permettent à la version Sense de détecter le mouvement, l’orientation et le son dès la sortie de la boîte, ce qui en fait une option bien plus adaptée aux projets impliquant la reconnaissance de gestes, l’entrée audio ou la fusion de capteurs. En revanche, le XIAO MG24 standard ne comprend pas ces capteurs, ce qui le rend un peu moins cher et plus adapté si vous avez seulement besoin du microcontrôleur, des fonctions sans fil et des broches d’E/S.
Une autre petite distinction concerne les cas d’usage visés. Le XIAO MG24 est conçu comme une carte IoT ultra-basse consommation polyvalente, tandis que le XIAO MG24 Sense cible davantage les projets d’IA embarquée et de détection intelligente où le mouvement et l’audio jouent un rôle. Si votre projet implique des applications TinyML comme la détection de mots-clés, le suivi d’activité, le contrôle gestuel ou les événements déclenchés par le son, la version Sense vous évitera de câbler des capteurs externes. En revanche, si vous cherchez une carte de base simple et économique pour des nœuds IoT sans fil ou des réseaux de capteurs, le MG24 non Sense peut suffire.
XIAO MG24 versus ESP32
L’ESP32 est bien connu dans la communauté maker pour combiner un processeur Xtensa LX6/LX7 double cœur (ou parfois simple cœur selon la variante) cadencé jusqu’à 240 MHz avec une connectivité Wi-Fi et Bluetooth. Cela le rend particulièrement attractif pour des projets nécessitant une puissance brute plus élevée ou une connexion internet via Wi-Fi. L’ESP32 dispose aussi de quantités généreuses de RAM (souvent 520 Ko SRAM, avec PSRAM externe disponible sur certains modules) et de mémoire flash, ce qui le rend adapté à des applications comme les serveurs web, le streaming audio en temps réel ou les interfaces utilisateur complexes. Son écosystème est vaste, avec un excellent support communautaire, de nombreux tutoriels et une compatibilité avec des plateformes comme Arduino, ESP-IDF et MicroPython.
En revanche, l’EFR32MG24 utilisé dans le XIAO MG24 se concentre sur la faible consommation, les standards sans fil modernes et la sécurité. Il fonctionne à une fréquence plus basse (jusqu’à 78 MHz) et dispose de moins de RAM, mais inclut le Matrix-Vector Processor (MVP) pour accélérer les tâches de machine learning. Au lieu du Wi-Fi, il supporte Matter (Thread) et Bluetooth Low Energy 5.3, tous deux très pertinents pour la maison connectée et les applications IoT où la faible consommation et le maillage sont importants. Le MG24 intègre aussi les fonctionnalités Secure Vault de Silicon Labs, offrant chiffrement matériel et démarrage sécurisé.
En résumé, l’ESP32 est mieux adapté aux applications nécessitant la connectivité Wi-Fi, une puissance de calcul plus élevée ou de grandes quantités de mémoire, tandis que le MG24 est conçu pour des nœuds IoT alimentés par batterie, des dispositifs capteurs et des applications demandant une forte sécurité et des standards sans fil modernes. Les deux sont supportés par Arduino, mais l’ESP32 bénéficie d’une communauté et d’un écosystème plus larges, tandis que le MG24 est un excellent choix pour les développeurs intéressés par Matter, BLE 5.3 et l’ultra-basse consommation.
Tableau comparatif
| Caractéristique | XIAO MG24 (EFR32MG24) | ESP32 (variantes typiques) |
|---|---|---|
| Processeur | ARM Cortex-M33, jusqu’à 78 MHz | Xtensa LX6/LX7, simple ou double cœur, jusqu’à 240 MHz |
| Accélérateur matériel | MVP (Matrix-Vector Processor pour ML) | Aucun (certaines variantes ESP32 incluent des coprocesseurs AI/ML, ex. ESP32-S3 avec instructions vectorielles) |
| Mémoire interne | 1536 Ko flash, 256 Ko RAM | ~448–520 Ko SRAM, PSRAM externe sur certains modules |
| Mémoire externe | 4 Mo flash SPI (sur carte XIAO) | Typiquement 4–16 Mo flash, PSRAM optionnelle |
| Sans fil | Matter (Thread), Bluetooth 5.3 | Wi-Fi 2,4 GHz, Bluetooth 4.2/5.0 (selon variante) |
| Sécurité | Secure Vault matériel (démarrage sécurisé, stockage de clés) | Démarrage sécurisé, chiffrement flash (varie selon variante) |
| Écosystème | Supporté dans Arduino, SDK officiels Silicon Labs | Arduino, ESP-IDF, MicroPython, CircuitPython, grande communauté |
| Efficacité énergétique | Ultra-basse consommation, courant de sommeil en µA | Modes basse consommation disponibles, mais consommation généralement plus élevée |
| Mieux adapté pour | Nœuds IoT basse consommation, appareils Matter/Thread, applications BLE | Projets connectés Wi-Fi, serveurs web, streaming temps réel, projets maker polyvalents |
Installation du Core
Avant de pouvoir programmer le XIAO MG24 ou XIAO MG24 Sense avec l’IDE Arduino, vous devez installer le core de la carte. Mais qu’est-ce qu’un core exactement ?
Un core dans l’écosystème Arduino est essentiellement un ensemble de fichiers logiciels qui permet à l’IDE Arduino de comprendre et communiquer avec un type spécifique de microcontrôleur. Il inclut le compilateur, l’éditeur de liens, les fichiers de démarrage, les bibliothèques et les définitions de carte nécessaires pour construire et téléverser du code sur ce microcontrôleur. Sans core, l’IDE Arduino ne saurait pas comment transformer vos sketches en code machine exécutable par le microcontrôleur.
Ajouter l’URL aux Préférences
Le XIAO MG24 utilise le microcontrôleur Silicon Labs EFR32MG24, qui n’est pas inclus dans l’installation Arduino par défaut. Pour ajouter le support de cette carte, suivez ces étapes.
D’abord, Ouvrez l’IDE Arduinoet allez dans File → Preferences:
Ensuite, dans le champ Additional Board Manager URLs, ajoutez l’URL du package Seeed Studio. L’URL actuelle est :
https://files.seeedstudio.com/arduino/package_seeeduino_boards_index.json
Vous pouvez ajouter l’URL en texte dans le champ d’édition. Si vous avez déjà d’autres URL listées, séparez-les par une virgule.
Ou cliquez sur l’icône à droite, qui ouvre un éditeur séparé où vous pouvez ajouter l’URL. Dans la capture d’écran ci-dessous, vous pouvez voir que j’ai déjà installé les cores ESP8266 et ESP32 :
Installer les cartes
Puis, ouvrez le Boards Manageren allant dans Tools → Board → Boards Manager…et tapez « MG24 » dans la barre de recherche. Vous verrez Silicon Labset un texte listant la carte supportée. Appuyez sur le bouton INSTALL. La capture d’écran ci-dessous montre l’apparence après installation du core (le bouton INSTALLdevient un bouton REMOVE ):
Une fois installé, sélectionnez une carte dans le sélecteur déroulant sous la barre de menu : dans l’exemple ci-dessous, c’est une Arduino Uno qui est sélectionnée :
Cliquer sur le nom de la carte sélectionnée (Arduino Uno) ouvre la boîte de sélection de carte. Dans la zone de recherche, tapez « mg24 » et sélectionnez « Seeed Studio XIAO MG24 (Sense) » comme montré ci-dessous :
Si la carte est connectée à votre PC via USB, vous devriez aussi pouvoir sélectionner le port COM. Dans la capture d’écran ci-dessus, c’est COM8, mais dans votre cas cela peut être un autre port COM.
Après installation, l’IDE Arduino traite le MG24 comme n’importe quelle autre carte supportée. Vous pouvez accéder aux bibliothèques, utiliser GPIO, I²C, SPI, ADC, et même exploiter les exemples intégrés pour la carte, comme le sketch classique Blink que nous allons implémenter dans la section suivante.
Code Blink
Une fois le core MG24 installé, testons-le pour voir s’il fonctionne réellement. Nous utilisons le programme Blink classique pour notre test. Voici le code :
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
Serial.println("OFF");
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
Serial.println("ON");
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
Il fait clignoter la LED embarquée toutes les secondes et affiche aussi l’état de la LED dans le moniteur série. Notez que la logique est inversée. Écrire un signal HIGH sur la broche de la LED éteint la LED, et inversement.
Téléversez le code sur votre carte en appuyant sur l’icône de téléversement dans l’IDE Arduino. Assurez-vous d’avoir la bonne carte sélectionnée (Seeed Studio XIAO MG24) :
Vous devriez voir le statut de compilation et de programmation s’afficher dans le terminal de sortie. Ne vous laissez pas tromper par la couleur rouge. Si vous lisez « ** Programming Finished ** », tout est bon.
Passez ensuite à la sortie du moniteur série. Vous devriez voir une séquence de messages « ON » et « OFF » apparaître. En même temps, la LED orange de la carte XIAO MG24 devrait clignoter.
Si tout cela fonctionne, félicitations, vous pouvez maintenant programmer votre XIAO MG24 Sense ; )
Dans les sections suivantes, nous allons tester l’Unité de Mesure Inertielle (IMU) et le microphone du XIAO MG24 Sense.
Code IMU
Le sketch suivant montre comment lire les données de mouvement du LSM6DS3, une IMU 6 axes combinant un accéléromètre 3 axes et un gyroscope 3 axes.
Avant de pouvoir l’exécuter, vous devrez installer la bibliothèque Seeed_Arduino_LSM6DS3. Téléchargez la bibliothèque au format .ZIP depuis le dépôt Github et installez-la via Sketch → Include Library → Add .ZIP Library …
Le programme exemple initialise le capteur, vérifie les erreurs, et affiche en continu les mesures d’accélération et de gyroscope dans le moniteur série. Parcourons le code étape par étape.
#include <LSM6DS3.h>
#include <Wire.h>
LSM6DS3 myIMU(I2C_MODE, 0x6A);
void setup() {
Serial.begin(115200);
pinMode(PD5, OUTPUT);
digitalWrite(PD5, HIGH);
if (myIMU.begin() != 0) {
Serial.println("Device error");
}
}
void loop() {
Serial.print(myIMU.readFloatAccelX(), 3);
Serial.print(',');
Serial.print(myIMU.readFloatAccelY(), 3);
Serial.print(',');
Serial.print(myIMU.readFloatAccelZ(), 3);
Serial.print(',');
Serial.print(myIMU.readFloatGyroX(), 3);
Serial.print(',');
Serial.print(myIMU.readFloatGyroY(), 3);
Serial.print(',');
Serial.print(myIMU.readFloatGyroZ(), 3);
Serial.println();
delay(500);
}
Imports
Le sketch commence par inclure deux bibliothèques essentielles. La première est <LSM6DS3.h>, qui fournit une interface simple pour l’IMU LSM6DS3. La seconde est <Wire.h>, qui permet la communication I2C entre l’Arduino et le capteur. Sans elles, l’Arduino ne peut pas communiquer avec l’IMU.
#include <LSM6DS3.h> #include <Wire.h>
Objets
Après les imports, le sketch crée un objet nommé myIMU de la classe LSM6DS3. Le constructeur indique au programme d’utiliser la communication I2C et définit l’adresse I2C du capteur à 0x6A. Cette adresse dépend du câblage des broches du capteur et doit correspondre à la configuration matérielle.
LSM6DS3 myIMU(I2C_MODE, 0x6A);
Setup
La fonction setup() s’exécute une fois au démarrage. Elle commence par ouvrir le port série à 115200 bauds pour que nous puissions voir les données du capteur dans le moniteur série de l’IDE Arduino.
Serial.begin(115200);
Ensuite, le code configure la broche PD5 en sortie et la met à HIGH. Cela sert à activer l’IMU.
pinMode(PD5, OUTPUT); digitalWrite(PD5, HIGH);
Enfin, le sketch initialise l’IMU en appelant myIMU.begin(). Si la fonction retourne une valeur non nulle, le programme affiche "Device error" dans le moniteur série, indiquant que le capteur n’a pas pu être détecté ou initialisé correctement.
if (myIMU.begin() != 0) {
Serial.println("Device error");
}
Loop
La fonction loop() s’exécute en continu après le setup. À chaque cycle, le sketch lit les données d’accélération et de gyroscope de l’IMU et les affiche dans le moniteur série au format CSV.
Les mesures de l’accéléromètre sont prises selon les axes X, Y et Z. Chaque appel à readFloatAccelX(), readFloatAccelY() et readFloatAccelZ() renvoie une valeur flottante en g, qui mesure l’accélération relative à la gravité. Le second argument 3 indique au moniteur série d’afficher trois chiffres après la virgule.
Serial.print(myIMU.readFloatAccelX(), 3);
Serial.print(',');
Serial.print(myIMU.readFloatAccelY(), 3);
Serial.print(',');
Serial.print(myIMU.readFloatAccelZ(), 3);
Ensuite, les valeurs du gyroscope sont lues selon les axes X, Y et Z. Les fonctions readFloatGyroX(), readFloatGyroY() et readFloatGyroZ() renvoient la vitesse angulaire en degrés par seconde. Là encore, le sketch affiche chaque valeur avec trois décimales, séparées par des virgules.
Serial.print(',');
Serial.print(myIMU.readFloatGyroX(), 3);
Serial.print(',');
Serial.print(myIMU.readFloatGyroY(), 3);
Serial.print(',');
Serial.print(myIMU.readFloatGyroZ(), 3);
À la fin de chaque boucle, le sketch imprime un saut de ligne pour que chaque ensemble complet de mesures apparaisse sur une ligne distincte. Il fait ensuite une pause de 500 millisecondes avant de recommencer. Ce délai rend la sortie lisible et évite de saturer le moniteur série.
Serial.println(); delay(500);
Si vous téléversez et exécutez ce code, vous devriez voir un flux de nombres apparaître dans votre moniteur série qui change lorsque vous déplacez le XIAO MG24 Sense :
Dans les deux sections suivantes, nous allons tester le microphone du XIAO MG24 Sense, en utilisant deux bibliothèques différentes.
Code Microphone avec la bibliothèque SiliconLabs
Le code suivant montre comment capturer des échantillons audio du microphone, calculer le niveau moyen du signal et mapper ce niveau à la luminosité d’une LED. Il utilise un système de callback pour gérer efficacement les données du microphone. Explorons le code morceau par morceau.
#include <SilabsMicrophoneAnalog.h>
#define MIC_DATA_PIN PC9
#define MIC_PWR_PIN PC8
#define NUM_SAMPLES 128
#define MIC_VAL_MIN 735
#define MIC_VAL_MAX 900
uint32_t mic_buffer[NUM_SAMPLES];
uint32_t mic_buffer_local[NUM_SAMPLES];
volatile bool data_ready_flag = false;
MicrophoneAnalog micAnalog(MIC_DATA_PIN, MIC_PWR_PIN);
void mic_samples_ready_cb() {
memcpy(mic_buffer_local, mic_buffer, NUM_SAMPLES * sizeof(uint32_t));
data_ready_flag = true;
}
void calculate_and_display_voice_level() {
static uint32_t avg = 0;
micAnalog.stopSampling();
uint32_t level = (uint32_t)micAnalog.getAverage(mic_buffer_local, NUM_SAMPLES);
level = constrain(level, MIC_VAL_MIN, MIC_VAL_MAX);
avg = (level + avg) / 2;
int brightness = map(avg, MIC_VAL_MIN, MIC_VAL_MAX, 0, 255);
analogWrite(LED_BUILTIN, 255 - brightness);
Serial.println(avg);
micAnalog.startSampling(mic_samples_ready_cb);
}
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
micAnalog.begin(mic_buffer, NUM_SAMPLES);
Serial.println("Microphone initialized...");
micAnalog.startSampling(mic_samples_ready_cb);
Serial.println("Sampling started...");
}
void loop() {
if (data_ready_flag) {
data_ready_flag = false;
calculate_and_display_voice_level();
}
}
Imports
Le sketch commence par inclure la bibliothèque SilabsMicrophoneAnalog.h. Cette bibliothèque fournit des fonctions pour initialiser le microphone, démarrer et arrêter l’échantillonnage, et traiter les données collectées.
#include <SilabsMicrophoneAnalog.h>
Constantes
Ensuite, le programme définit plusieurs constantes. MIC_DATA_PIN et MIC_PWR_PIN spécifient les broches connectées aux lignes de données et d’alimentation du microphone. NUM_SAMPLES détermine combien d’échantillons audio seront collectés à la fois. MIC_VAL_MIN et MIC_VAL_MAX définissent la plage attendue des valeurs du microphone pour la normalisation. Ces limites aident à filtrer le bruit indésirable et assurent un bon mapping de la luminosité de la LED.
#define MIC_DATA_PIN PC9 #define MIC_PWR_PIN PC8 #define NUM_SAMPLES 128 #define MIC_VAL_MIN 735 #define MIC_VAL_MAX 900
Buffers
Deux buffers stockent les échantillons du microphone. mic_buffer contient les échantillons bruts du microphone, tandis que mic_buffer_local stocke une copie sécurisée de ces échantillons pour le traitement. Cette séparation évite les erreurs si de nouvelles données arrivent pendant les calculs.
uint32_t mic_buffer[NUM_SAMPLES]; uint32_t mic_buffer_local[NUM_SAMPLES];
Flags et Objets
La variable data_ready_flag indique au programme quand un nouvel ensemble d’échantillons est disponible. Elle est marquée comme volatile car elle est mise à jour dans une interruption ou un callback. L’objet micAnalog est créé à partir de la classe MicrophoneAnalog. Il prend en paramètres les broches de données et d’alimentation du microphone.
volatile bool data_ready_flag = false; MicrophoneAnalog micAnalog(MIC_DATA_PIN, MIC_PWR_PIN);
Callback Microphone
La fonction mic_samples_ready_cb() s’exécute automatiquement chaque fois que le microphone termine la collecte d’un lot d’échantillons. Elle copie le contenu de mic_buffer dans mic_buffer_local et met data_ready_flag à true, signalant que les données sont prêtes à être traitées.
void mic_samples_ready_cb() {
memcpy(mic_buffer_local, mic_buffer, NUM_SAMPLES * sizeof(uint32_t));
data_ready_flag = true;
}
Traitement des niveaux sonores
La fonction calculate_and_display_voice_level() traite les données audio et met à jour la luminosité de la LED. D’abord, elle arrête l’échantillonnage du microphone pour éviter les interférences pendant les calculs. Puis elle calcule la valeur moyenne du signal avec micAnalog.getAverage(). Cette valeur est contrainte entre MIC_VAL_MIN et MIC_VAL_MAX pour lisser les pics extrêmes.
Pour rendre la réponse de la LED plus fluide, la valeur moyenne est combinée avec la moyenne précédente via un filtre simple. Le résultat est mappé de la plage du microphone à la plage de luminosité LED de 0 à 255. Enfin, la luminosité de la LED est réglée avec analogWrite(). Un niveau sonore plus élevé rend la LED plus brillante.
La fonction affiche aussi la valeur moyenne dans le moniteur série puis redémarre l’échantillonnage du microphone.
void calculate_and_display_voice_level() {
static uint32_t avg = 0;
micAnalog.stopSampling();
uint32_t level = (uint32_t)micAnalog.getAverage(mic_buffer_local, NUM_SAMPLES);
level = constrain(level, MIC_VAL_MIN, MIC_VAL_MAX);
avg = (level + avg) / 2;
int brightness = map(avg, MIC_VAL_MIN, MIC_VAL_MAX, 0, 255);
analogWrite(LED_BUILTIN, 255 - brightness);
Serial.println(avg);
micAnalog.startSampling(mic_samples_ready_cb);
}
Setup
La fonction setup() prépare le moniteur série et la LED. Elle initialise aussi le microphone avec le buffer et le nombre d’échantillons. Une fois initialisé, le sketch démarre l’échantillonnage et affiche des messages de confirmation dans le moniteur série.
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
micAnalog.begin(mic_buffer, NUM_SAMPLES);
Serial.println("Microphone initialized...");
micAnalog.startSampling(mic_samples_ready_cb);
Serial.println("Sampling started...");
}
Loop
La fonction loop() vérifie si de nouvelles données sont prêtes. Si data_ready_flag est vrai, elle efface le flag et appelle calculate_and_display_voice_level(). Cela garantit que les données du microphone sont traitées uniquement lorsque des échantillons frais sont disponibles.
void loop() {
if (data_ready_flag) {
data_ready_flag = false;
calculate_and_display_voice_level();
}
}
Après avoir téléversé le code, vous devriez voir la luminosité de la LED embarquée changer en fonction du niveau sonore ambiant. Plus c’est fort, plus c’est lumineux.
Code Microphone avec la bibliothèque Seeed_Arduino_Mic
Ce sketch initialise un microphone avec la bibliothèque Seeed_Arduino_Mic, collecte un nombre fixe d’échantillons audio et les affiche en données brutes. Il montre comment configurer les paramètres du microphone, gérer les callbacks et traiter les données audio entrantes.
Vous devrez installer la bibliothèque Seeed_Arduino_Mic avant de pouvoir exécuter ce code. Téléchargez la bibliothèque au format .ZIP depuis le dépôt Github et installez-la via Sketch → Include Library → Add .ZIP Library …
Jetez un œil rapide au sketch complet d’abord, puis nous détaillerons son fonctionnement :
#include <mic.h>
#define DEBUG 1 // Enable pin pulse during ISR
#define SAMPLES 800
mic_config_t mic_config{
.channel_cnt = 1,
.sampling_rate = 16000,
.buf_size = 1600,
.debug_pin = LED_BUILTIN // Toggles each DAC ISR (if DEBUG is set to 1)
};
MG24_ADC_Class Mic(&mic_config);
int16_t recording_buf[SAMPLES];
volatile uint8_t recording = 0;
volatile static bool record_ready = false;
static void audio_rec_callback(uint16_t *buf, uint32_t buf_len) {
static uint32_t idx = 0;
for (uint32_t i = 0; i < buf_len; i++) {
// Convert 12-bit unsigned ADC value to 16-bit PCM (signed) audio value
recording_buf[idx++] = buf[i];
if (idx >= SAMPLES) {
idx = 0;
recording = 0;
record_ready = true;
break;
}
}
}
void setup() {
Serial.begin(115200);
Mic.set_callback(audio_rec_callback);
if (!Mic.begin()) {
Serial.println("Mic initialization failed");
while (1)
;
}
Serial.println("Mic initialization done.");
}
void loop() {
if (record_ready) {
Serial.println("Finished sampling");
for (int i = 0; i < SAMPLES; i++) {
int16_t sample = recording_buf[i];
Serial.println(sample);
}
record_ready = false;
}
}
Imports
Le programme commence par inclure le fichier d’en-tête mic.h. Cette bibliothèque fournit des outils pour configurer et contrôler le matériel microphone sur les plateformes Seeed.
#include <mic.h>
Constantes
Deux constantes sont définies. La première, DEBUG, permet d’activer le clignotement de la broche pendant les interruptions pour le débogage. Si DEBUG est à 1, la broche LED bascule à chaque interruption, donnant une indication visuelle de l’activité d’échantillonnage. La seconde constante, SAMPLES, spécifie le nombre d’échantillons audio à enregistrer avant traitement.
#define DEBUG 1 // Enable pin pulse during ISR #define SAMPLES 800
Configuration du microphone
Le microphone est configuré via une structure mic_config_t. Ici, le microphone est réglé sur un canal, un taux d’échantillonnage de 16 kHz et une taille de buffer de 1600 échantillons. Le debug_pin est lié à LED_BUILTIN, donc la LED embarquée bascule à chaque interruption si le débogage est activé.
mic_config_t mic_config{
.channel_cnt = 1,
.sampling_rate = 16000,
.buf_size = 1600,
.debug_pin = LED_BUILTIN
};
Le programme crée ensuite un objet microphone nommé Mic avec la classe MG24_ADC_Class. Cet objet prend la configuration du microphone en entrée et gère la collecte des données.
MG24_ADC_Class Mic(&mic_config);
Buffers et Flags
Le tableau recording_buf stocke les échantillons enregistrés, avec une taille égale à la constante SAMPLES. Deux variables gèrent le processus d’enregistrement : recording suit l’état d’enregistrement, et record_ready signale quand le buffer est plein et prêt à être traité. Les deux sont déclarées volatile car modifiées dans un callback d’interruption.
int16_t recording_buf[SAMPLES]; volatile uint8_t recording = 0; volatile static bool record_ready = false;
Callback
Le cœur du processus d’enregistrement se trouve dans la fonction audio_rec_callback(). Ce callback s’exécute automatiquement chaque fois que le buffer du microphone est rempli. La fonction copie les données audio du buffer d’entrée dans le buffer principal recording_buf.
Chaque valeur ADC brute 12 bits du microphone est convertie en un échantillon PCM signé 16 bits. La fonction garde la trace de l’index courant dans le buffer avec une variable statique idx. Quand le buffer atteint sa taille maximale (SAMPLES), la fonction réinitialise l’index, efface le flag d’enregistrement et met record_ready à vrai pour que la boucle sache que les données sont prêtes à être traitées.
static void audio_rec_callback(uint16_t *buf, uint32_t buf_len) {
static uint32_t idx = 0;
for (uint32_t i = 0; i < buf_len; i++) {
// Convert 12-bit unsigned ADC value to 16-bit PCM (signed) audio value
recording_buf[idx++] = buf[i];
if (idx >= SAMPLES) {
idx = 0;
recording = 0;
record_ready = true;
break;
}
}
}
Setup
Dans setup(), le moniteur série est initialisé à 115200 bauds. Le programme assigne audio_rec_callback comme fonction de gestion des données audio entrantes chaque fois que le microphone collecte des échantillons.
Le microphone est ensuite démarré avec Mic.begin(). Si l’initialisation échoue, le programme affiche un message d’erreur et entre dans une boucle infinie. Sinon, il confirme l’initialisation réussie.
void setup() {
Serial.begin(115200);
Mic.set_callback(audio_rec_callback);
if (!Mic.begin()) {
Serial.println("Mic initialization failed");
while (1);
}
Serial.println("Mic initialization done.");
}
Loop
La fonction loop() vérifie si l’enregistrement est terminé en regardant record_ready. Si vrai, le programme affiche "Finished sampling" puis parcourt le buffer en affichant chaque échantillon audio enregistré. Après l’affichage, il réinitialise record_ready à false pour permettre un nouvel enregistrement.
void loop() {
if (record_ready) {
Serial.println("Finished sampling");
for (int i = 0; i < SAMPLES; i++) {
int16_t sample = recording_buf[i];
Serial.println(sample);
}
record_ready = false;
}
}
Si vous téléversez ce sketch et ouvrez le traceur série, vous verrez un signal audio qui varie selon le son détecté par le microphone :
Et voilà ! Ces instructions et exemples de code devraient vous aider à démarrer rapidement avec le XIAO MG24 Sense.
Conclusions
Dans ce tutoriel, vous avez appris à démarrer avec le XIAO MG24 Sense de Seeed Studio. Pour plus d’informations, consultez la Getting Started Wiki de Seeed Studio. Les exemples de code de ce tutoriel sont dérivés des exemples des bibliothèques Seeed_Arduino_Mic et Seeed_Arduino_LSM6DS3. Vous y trouverez davantage d’exemples de code.
Avec le microphone intégré et le Matrix-Vector Processor (MVP), le XIAO MG24 Sense est particulièrement adapté aux applications TinyML telles que la détection de mots-clés, le contrôle vocal ou la classification sonore.
Une alternative est le microcontrôleur ESP32 basé sur XIAO-ESP32-S3-Sense – également de Seeed Studio. Il est aussi équipé d’un microphone et, bien qu’il ne possède pas d’IMU, il dispose d’une caméra. Il peut être utilisé pour des applications vocales, voir notre Voice control with XIAO-ESP32-S3-Sense and Edge Impulse, mais consomme plus d’énergie.
Cependant, si vous vous intéressez à la détection d’objets, le XIAO ESP32 Sense est un meilleur choix grâce à sa caméra intégrée. Consultez nos tutoriels Face Detection with XIAO ESP32-S3-Sense and SenseCraft AI et Edge AI Room Occupancy Sensor with ESP32 and Person Detection pour plus de détails.
Si vous avez des questions, n’hésitez pas à les poser dans la section commentaires.
Bon bricolage 😉
