The XIAO MG24 Sense è una delle schede della serie XIAO di Seeed Studio, che combina un potente microcontrollore Silicon Labs EFR32MG24 con sensori integrati come un microfono e un IMU a 6 assi. Grazie al suo formato compatto, al design a basso consumo e alle capacità wireless integrate, è una scelta eccellente per progetti IoT, sensor fusion e edge AI.
In questa guida vedremo le basi per iniziare con la XIAO MG24 Sense. Inizieremo installando il core della scheda necessario, quindi eseguiremo l’esempio classico Blink per confermare che tutto funzioni. Successivamente esploreremo le sue caratteristiche principali: il microfono integrato e l’IMU (Inertial Measurement Unit).
Parti necessarie
Ti serviranno una scheda XIAO MG24 Sense di Seeed Studio e un cavo USB-C per programmare la scheda e provare gli esempi di codice.
Seeed Studio XIAO MG24 Sense
Cavo 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.
La XIAO MG24 Sense
La XIAO MG24 Sense è alimentata dal system-on-chip Silicon Labs EFR32MG24, che utilizza un microcontrollore ARM Cortex-M33 con frequenza fino a 78 MHz. Questo le conferisce ampie capacità di elaborazione per progetti embedded generici mantenendo un’elevata efficienza energetica. Una caratteristica distintiva di questo chip è il Matrix-Vector Processor (MVP), un piccolo acceleratore hardware che velocizza le operazioni matematiche richieste nel machine learning. Questo rende la MG24 Sense particolarmente adatta per applicazioni TinyML, come il riconoscimento di parole chiave o la classificazione del movimento, senza consumare rapidamente la batteria.
Per quanto riguarda la memoria, la scheda include 1,5 MB di flash e 256 kB di RAM integrati nel microcontrollore. Inoltre, Seeed Studio ha aggiunto un chip flash SPI esterno da 4 MB, utile per memorizzare programmi più grandi, dati di modelli o anche log. La combinazione di memoria interna ed esterna offre spazio per sperimentare applicazioni più complesse mantenendo un formato compatto.
La connettività wireless è un altro punto di forza di questo dispositivo. La MG24 supporta Matter su Thread e Bluetooth Low Energy 5.3, garantendo compatibilità con ecosistemi IoT moderni e connettività smartphone. La scheda include anche funzionalità di sicurezza hardware Secure Vault, che proteggono dati sensibili come chiavi di crittografia e abilitano il boot sicuro.
Sensori
Il “Sense” nel nome della scheda deriva dai sensori integrati. Innanzitutto, c’è l’IMU LSM6DS3TR-C, un sensore a sei assi che combina un accelerometro a tre assi con un giroscopio a tre assi. Questo sensore è in grado di misurare movimento, orientamento, passi e gesti, e include anche modalità a basso consumo per il rilevamento continuo dell’attività senza un elevato consumo energetico. Puoi trovare maggiori dettagli nel datasheet linkato qui sotto:
Oltre all’IMU, c’è il microfono MEMS analogico MSM381ACT001, che permette di catturare il suono. Pur essendo un microfono analogico, l’ADC del microcontrollore rende semplice campionare e processare l’audio, sia per il rilevamento del suono che per interazioni attivate dalla voce. Consulta il datasheet qui sotto:
GPIO
Per l’interfacciamento hardware, la XIAO MG24 Sense espone 19 pin GPIO (general-purpose input/output), disposti nel classico footprint XIAO. Questi pin possono essere usati per I²C, SPI, UART e altre interfacce standard.
Sono presenti anche un LED utente e un LED di alimentazione/ricarica per facilitare il debug e fornire un feedback rapido. Il caricamento del codice avviene tramite il connettore USB-C, che funge anche da interfaccia di alimentazione e ricarica.
Alimentazione
L’efficienza energetica è uno degli aspetti più forti della XIAO MG24 Sense. In modalità deep sleep, il microcontrollore può ridurre il consumo a pochi microampere, rendendola ideale per progetti alimentati a batteria. La scheda include un circuito di ricarica per batterie Li-Po e può anche misurare la tensione della batteria, così i tuoi progetti possono monitorare i propri livelli di energia. Con queste caratteristiche, la MG24 Sense è un’ottima scelta per nodi IoT a batteria a lungo termine.
Dimensioni
Nonostante tutte queste funzionalità, la scheda mantiene il classico formato XIAO di soli 21 × 17,8 mm, rendendola facile da integrare in progetti compatti o indossabili. Include un’antenna integrata per la comunicazione wireless, quindi non servono moduli aggiuntivi per iniziare.
In sintesi, la XIAO MG24 Sense combina un microcontrollore potente ed efficiente, connettività wireless moderna, sicurezza hardware, sensori di movimento e audio integrati, memoria generosa e un design a basso consumo in un pacchetto molto piccolo.
Specifiche tecniche
| Caratteristica | Specifiche |
|---|---|
| Processore | Silicon Labs EFR32MG24, ARM Cortex-M33, fino a 78 MHz |
| Acceleratore hardware | Matrix-Vector Processor (MVP) per carichi ML |
| Memoria interna | 1536 kB flash, 256 kB RAM |
| Memoria esterna | 4 MB SPI flash |
| Wireless | Matter (Thread), Bluetooth Low Energy 5.3 |
| Sicurezza | Motore di sicurezza hardware Secure Vault |
| IMU | LSM6DS3TR-C, accelerometro + giroscopio a 6 assi |
| Microfono | Microfono MEMS analogico MSM381ACT001 |
| GPIO | 19 pin (I²C, SPI, UART, GPIO, ecc.) |
| USB | USB-C per programmazione, alimentazione e ricarica |
| Caratteristiche batteria | Circuito di ricarica integrato, monitoraggio tensione batteria |
| Efficienza energetica | Ultra-basso consumo, corrente di sleep fino a ~1,95 µA |
| Formato | 21 × 17,8 mm, antenna integrata |
XIAO MG24 Sense vs XIAO MG24
Seeed Studio offre due versioni strettamente correlate di questa scheda: la XIAO MG24 e la XIAO MG24 Sense. Entrambe condividono la stessa base, costruita attorno al microcontrollore EFR32MG24 con core ARM Cortex-M33, Matrix-Vector Processor per machine learning e supporto per standard wireless moderni come Matter (Thread) e Bluetooth Low Energy 5.3. Condividono anche lo stesso formato compatto XIAO, la stessa flash esterna da 4 MB e lo stesso design a basso consumo con circuito di ricarica integrato per batterie Li-Po.
La differenza principale riguarda le capacità di sensing. La XIAO MG24 Sense integra due sensori aggiuntivi a bordo: l’IMU a 6 assi LSM6DS3TR-C e il microfono MEMS analogico MSM381ACT001. Queste aggiunte permettono alla versione Sense di rilevare movimento, orientamento e suono fin da subito, rendendola un’opzione molto più forte per progetti che coinvolgono riconoscimento gestuale, input audio o sensor fusion. Al contrario, la XIAO MG24 standard non include questi sensori, ma questo la rende anche leggermente meno costosa e più adatta se ti servono solo il microcontrollore, le funzionalità wireless e i pin I/O.
Un’altra piccola differenza riguarda i casi d’uso previsti. La XIAO MG24 è progettata come scheda IoT ultra-low-power a uso generale, mentre la XIAO MG24 Sense è più orientata a progetti di edge AI e sensing intelligente dove movimento e audio giocano un ruolo. Se il tuo progetto coinvolge cose come il riconoscimento di parole chiave TinyML, il monitoraggio fitness, il controllo gestuale o eventi attivati dal suono, la versione Sense ti farà risparmiare il lavoro di collegare sensori esterni. Se invece vuoi una scheda base semplice ed economica per nodi IoT wireless o reti di sensori, la MG24 non Sense potrebbe essere tutto ciò di cui hai bisogno.
XIAO MG24 vs ESP32
L’ESP32 è ben noto nella community maker per combinare un processore dual-core (o a volte single-core, a seconda della variante) Xtensa LX6/LX7 che arriva fino a 240 MHz con connettività Wi-Fi e Bluetooth. Questo lo rende particolarmente attraente per progetti che richiedono maggiore potenza di calcolo o connettività internet via Wi-Fi. L’ESP32 ha anche quantità generose di RAM (spesso 520 kB SRAM, con PSRAM esterna disponibile su alcuni moduli) e memoria flash, rendendolo adatto ad applicazioni come server web, streaming audio in tempo reale o interfacce utente complesse. Il suo ecosistema è vasto, con ottimo supporto comunitario, numerosi tutorial e compatibilità con piattaforme come Arduino, ESP-IDF e MicroPython.
Al contrario, l’EFR32MG24 usato nella XIAO MG24 si concentra su basso consumo, standard wireless moderni e sicurezza. Funziona a frequenze più basse (fino a 78 MHz) e ha meno RAM, ma include il Matrix-Vector Processor (MVP) per accelerare i compiti di machine learning. Invece del Wi-Fi, supporta Matter (Thread) e Bluetooth Low Energy 5.3, entrambi molto rilevanti per smart home e applicazioni IoT dove il basso consumo e il mesh networking sono importanti. La MG24 integra anche le funzionalità Secure Vault di Silicon Labs, offrendo crittografia hardware e boot sicuro.
In breve, l’ESP32 è più adatto per applicazioni che richiedono connettività Wi-Fi, maggiore potenza di calcolo o grandi quantità di memoria, mentre la MG24 è progettata per nodi IoT a batteria, dispositivi sensoriali e applicazioni che richiedono sicurezza elevata e standard wireless moderni. Entrambi sono supportati da Arduino, ma l’ESP32 beneficia di una comunità ed ecosistema più ampi, mentre la MG24 è una scelta solida per sviluppatori interessati a Matter, BLE 5.3 e operazioni ultra-low-power.
Tabella di confronto
| Caratteristica | XIAO MG24 (EFR32MG24) | ESP32 (varianti tipiche) |
|---|---|---|
| Processore | ARM Cortex-M33, fino a 78 MHz | Xtensa LX6/LX7, single o dual-core, fino a 240 MHz |
| Acceleratore hardware | MVP (Matrix-Vector Processor per ML) | Nessuno (alcune varianti ESP32 includono co-processori AI/ML, es. ESP32-S3 con istruzioni vettoriali) |
| Memoria interna | 1536 kB flash, 256 kB RAM | ~448–520 kB SRAM, PSRAM esterna su alcuni moduli |
| Memoria esterna | 4 MB SPI flash (sulla scheda XIAO) | Tipicamente 4–16 MB flash, PSRAM opzionale |
| Wireless | Matter (Thread), Bluetooth 5.3 | Wi-Fi 2.4 GHz, Bluetooth 4.2/5.0 (a seconda della variante) |
| Sicurezza | Hardware Secure Vault (boot sicuro, storage chiavi) | Boot sicuro, crittografia flash (varia per variante) |
| Ecosistema | Supportato in Arduino, SDK ufficiali Silicon Labs | Arduino, ESP-IDF, MicroPython, CircuitPython, grande comunità |
| Efficienza energetica | Ultra-basso consumo, corrente di sleep in µA | Modalità a basso consumo disponibili, ma tipicamente con consumi più alti |
| Ideale per | Nodi IoT a basso consumo, dispositivi Matter/Thread, applicazioni BLE | Progetti connessi Wi-Fi, server web, streaming in tempo reale, progetti maker generici |
Installazione del Core
Prima di poter programmare la XIAO MG24 o la XIAO MG24 Sense con Arduino IDE, devi installare il core della scheda. Ma cos’è esattamente un core della scheda?
Un core nell’ecosistema Arduino è essenzialmente un insieme di file software che permette all’IDE Arduino di comprendere e comunicare con un tipo specifico di microcontrollore. Include il compilatore, linker, file di avvio, librerie e definizioni della scheda necessari per costruire e caricare il codice su quel microcontrollore. Senza un core, l’IDE Arduino non saprebbe come trasformare i tuoi sketch in codice macchina eseguibile dal microcontrollore.
Aggiungi URL alle Preferenze
La XIAO MG24 usa il microcontrollore Silicon Labs EFR32MG24, che non è incluso nell’installazione Arduino di default. Per aggiungere il supporto a questa scheda, segui questi passaggi.
Per prima cosa, apri l’IDE Arduinoe vai su File → Preferences:
Poi, nel campo Additional Board Manager URLs, aggiungi l’URL per il pacchetto Seeed Studio. L’URL attuale è:
https://files.seeedstudio.com/arduino/package_seeeduino_boards_index.json
Puoi aggiungere l’URL come testo nel campo di modifica. Se hai già altri URL elencati, separali con una virgola.
Oppure clicca sull’icona a destra, che apre un editor separato dove puoi aggiungere l’URL. Nello screenshot qui sotto puoi vedere che ho già installato i core ESP8266 e ESP32:
Installa le schede
Poi, apri il Boards Manager andando su Tools → Board → Boards Manager…e digita “MG24” nella barra di ricerca. Vedrai Silicon Labse un testo che elenca la scheda supportata. Premi il pulsante INSTALL. Lo screenshot qui sotto mostra come appare dopo l’installazione del core (il pulsante INSTALLdiventa un pulsante REMOVE ):
Una volta installato, seleziona una scheda dal menu a tendina sotto la barra del menu: nell’esempio sotto è selezionata una Arduino Uno, per esempio:
Cliccando sul nome della scheda attualmente selezionata (Arduino Uno), si apre la finestra di selezione della scheda. Nella casella di ricerca digita “mg24” e seleziona “Seeed Studio XIAO MG24 (Sense)” come mostrato sotto:
Se la scheda è collegata al PC via USB, dovresti anche poter selezionare la porta COM. Nello screenshot sopra è COM8, ma nel tuo caso potrebbe essere una porta COM diversa.
Dopo l’installazione, l’IDE Arduino tratta la MG24 come qualsiasi altra scheda supportata. Puoi accedere alle librerie, usare GPIO, I²C, SPI, ADC e persino sfruttare esempi integrati per la scheda, come il classico sketch Blink, che implementeremo nella sezione successiva.
Codice Blink
Una volta installato il core per la MG24, testiamolo per vedere se funziona davvero. Usiamo il programma comune Blink per il test. Ecco il codice:
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);
Fa lampeggiare il LED a bordo ogni secondo e stampa anche lo stato del LED sul monitor seriale. Nota che la logica è invertita. Scrivere un segnale HIGH sul pin del LED spegne il LED e viceversa.
Carica il codice sulla tua scheda premendo l’icona di upload nell’IDE Arduino. Assicurati di aver selezionato la scheda corretta (Seeed Studio XIAO MG24):
Dovresti vedere lo stato di compilazione e programmazione mostrato nel terminale Output. Non farti ingannare dal colore rosso. Se leggi “** Programming Finished **” tutto è a posto.
Passa quindi all’output del monitor seriale. Dovresti vedere una sequenza di messaggi “ON” e “OFF” apparire. Allo stesso tempo il LED arancione della scheda XIAO MG24 dovrebbe lampeggiare.
Se tutto funziona, congratulazioni, ora puoi programmare la tua XIAO MG24 Sense ; )
Nelle sezioni successive proveremo l’Inertial Measurement Unit (IMU) e il microfono della XIAO MG24 Sense.
Codice IMU
Lo sketch seguente mostra come leggere i dati di movimento dall’LSM6DS3, un IMU a 6 assi che combina un accelerometro a 3 assi e un giroscopio a 3 assi.
Prima di poterlo eseguire, dovrai installare la Seeed_Arduino_LSM6DS3libreria. Scarica la libreria come file .ZIP dal repository Github e installala tramite Sketch → Include Library → Add .ZIP Library …
Il programma di esempio inizializza il sensore, verifica errori e stampa continuamente le letture di accelerazione e giroscopio sul monitor seriale. Vediamo il codice passo passo.
#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);
}
Importazioni
Lo sketch inizia includendo due librerie essenziali. La prima è <LSM6DS3.h>, che fornisce un’interfaccia semplice per l’IMU LSM6DS3. La seconda è <Wire.h>, che abilita la comunicazione I2C tra Arduino e il sensore. Senza queste, Arduino non può comunicare con l’IMU.
#include <LSM6DS3.h> #include <Wire.h>
Oggetti
Dopo le importazioni, lo sketch crea un oggetto chiamato myIMU dalla classe LSM6DS3. Il costruttore indica al programma di usare la comunicazione I2C e imposta l’indirizzo I2C del sensore a 0x6A. Questo indirizzo dipende da come sono cablati i pin del sensore e deve corrispondere alla configurazione hardware.
LSM6DS3 myIMU(I2C_MODE, 0x6A);
Setup
La funzione setup()viene eseguita una volta all’inizio. Inizia aprendo la porta seriale a 115200 baud per poter visualizzare i dati del sensore nel monitor seriale dell’IDE Arduino.
Serial.begin(115200);
Successivamente, il codice configura il pin PD5come output e lo imposta a HIGH. Questo serve per abilitare l’IMU.
pinMode(PD5, OUTPUT); digitalWrite(PD5, HIGH);
Infine, lo sketch inizializza l’IMU chiamando myIMU.begin(). Se la funzione restituisce un valore diverso da zero, il programma stampa "Device error" sul monitor seriale, segnalando che il sensore non è stato rilevato o inizializzato correttamente.
if (myIMU.begin() != 0) {
Serial.println("Device error");
}
Loop
La funzione loop()viene eseguita continuamente dopo il setup. Ad ogni ciclo, lo sketch legge i dati di accelerazione e giroscopio dall’IMU e li stampa sul monitor seriale in formato separato da virgole.
Le letture dell’accelerometro sono prese nelle direzioni X, Y e Z. Ogni chiamata a readFloatAccelX(), readFloatAccelY() e readFloatAccelZ() restituisce un valore in virgola mobile in g, che misura l’accelerazione relativa alla gravità. Il secondo argomento 3 dice al monitor seriale di stampare tre cifre decimali.
Serial.print(myIMU.readFloatAccelX(), 3);
Serial.print(',');
Serial.print(myIMU.readFloatAccelY(), 3);
Serial.print(',');
Serial.print(myIMU.readFloatAccelZ(), 3);
Successivamente, i valori del giroscopio sono letti nelle direzioni X, Y e Z. Le funzioni readFloatGyroX(), readFloatGyroY() e readFloatGyroZ() restituiscono la velocità angolare in gradi al secondo. Anche in questo caso, lo sketch stampa ogni valore con tre decimali, separati da virgole.
Serial.print(',');
Serial.print(myIMU.readFloatGyroX(), 3);
Serial.print(',');
Serial.print(myIMU.readFloatGyroY(), 3);
Serial.print(',');
Serial.print(myIMU.readFloatGyroZ(), 3);
Alla fine di ogni ciclo, lo sketch stampa una nuova riga in modo che ogni set completo di letture appaia su una linea separata. Poi si ferma per 500 millisecondi prima di ripetere. Questo ritardo mantiene l’output leggibile e impedisce di sovraccaricare il monitor seriale.
Serial.println(); delay(500);
Se carichi ed esegui questo codice, dovresti vedere un flusso di numeri apparire sul monitor seriale che cambia se muovi la XIAO MG24 Sense:
Nelle prossime due sezioni proveremo il microfono della XIAO MG24 Sense, usando due librerie diverse.
Codice microfono con libreria SiliconLabs
Il codice seguente mostra come catturare campioni audio dal microfono, calcolare il livello medio del segnale e mappare quel livello sulla luminosità del LED. Usa un sistema di callback per gestire i dati del microfono in modo efficiente. Esploriamo il codice pezzo per pezzo.
#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();
}
}
Importazioni
Lo sketch inizia includendo la libreria SilabsMicrophoneAnalog.h. Questa libreria fornisce funzioni per inizializzare il microfono, avviare e fermare il campionamento e processare i dati raccolti.
#include <SilabsMicrophoneAnalog.h>
Costanti
Successivamente, il programma definisce diverse costanti. MIC_DATA_PIN e MIC_PWR_PIN specificano i pin collegati alle linee dati e alimentazione del microfono. NUM_SAMPLES determina quanti campioni audio verranno raccolti in una volta. MIC_VAL_MIN e MIC_VAL_MAX definiscono l’intervallo previsto dei valori del microfono per la normalizzazione. Questi limiti aiutano a filtrare il rumore indesiderato e garantiscono una buona mappatura della luminosità del 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
Buffer
Due buffer memorizzano i campioni del microfono. mic_buffer contiene i campioni grezzi dal microfono, mentre mic_buffer_local conserva una copia sicura di quei campioni per l’elaborazione. Questa separazione previene errori se arrivano nuovi dati mentre i calcoli sono in corso.
uint32_t mic_buffer[NUM_SAMPLES]; uint32_t mic_buffer_local[NUM_SAMPLES];
Flag e oggetti
La variabile data_ready_flag indica al programma quando un nuovo set di campioni è disponibile. È marcata come volatile perché viene aggiornata all’interno di un interrupt o callback. L’oggetto micAnalog è creato dalla classe MicrophoneAnalog. Prende come parametri i pin dati e alimentazione del microfono.
volatile bool data_ready_flag = false; MicrophoneAnalog micAnalog(MIC_DATA_PIN, MIC_PWR_PIN);
Callback del microfono
La funzione mic_samples_ready_cb() viene eseguita automaticamente ogni volta che il microfono termina di raccogliere un batch di campioni. Copia il contenuto di mic_buffer in mic_buffer_local e imposta data_ready_flag a true, segnalando che i dati sono pronti per essere processati.
void mic_samples_ready_cb() {
memcpy(mic_buffer_local, mic_buffer, NUM_SAMPLES * sizeof(uint32_t));
data_ready_flag = true;
}
Elaborazione dei livelli vocali
La funzione calculate_and_display_voice_level() elabora i dati audio e aggiorna la luminosità del LED. Prima ferma il campionamento del microfono per evitare interferenze durante i calcoli. Poi calcola il valore medio del segnale usando micAnalog.getAverage(). Questo valore è limitato tra MIC_VAL_MIN e MIC_VAL_MAX per smussare picchi estremi.
Per rendere la risposta del LED più fluida, il valore medio è combinato con la media precedente usando un filtro semplice. Il risultato è mappato dall’intervallo del microfono a quello della luminosità del LED da 0 a 255. Infine, la luminosità del LED è impostata usando analogWrite(). Un livello sonoro più alto rende il LED più luminoso.
La funzione stampa anche il valore medio sul monitor seriale e poi riavvia il campionamento del microfono.
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 funzione setup() prepara il monitor seriale e il LED. Inizializza anche il microfono con il buffer e il numero di campioni. Una volta inizializzato, lo sketch avvia il campionamento e stampa messaggi di conferma sul monitor seriale.
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 funzione loop() controlla se nuovi dati sono pronti. Se data_ready_flag è vero, azzera il flag e chiama calculate_and_display_voice_level(). Questo assicura che i dati del microfono vengano processati solo quando sono disponibili campioni freschi.
void loop() {
if (data_ready_flag) {
data_ready_flag = false;
calculate_and_display_voice_level();
}
}
Dopo aver caricato il codice, dovresti vedere la luminosità del LED a bordo cambiare in base ai livelli di volume ambientale. Più è alto il suono, più il LED è luminoso.
Codice microfono con libreria Seeed_Arduino_Mic
Questo sketch inizializza un microfono usando la libreria Seeed_Arduino_Mic, raccoglie un numero fisso di campioni audio e li stampa come dati grezzi. Dimostra come configurare i parametri del microfono, gestire callback e processare i dati audio in ingresso.
Dovrai installare la libreria Seeed_Arduino_Mic prima di poter eseguire questo codice. Scarica la libreria come file .ZIP dal repository Github e installala tramite Sketch → Include Library → Add .ZIP Library …
Dai un’occhiata veloce allo sketch completo e poi ne analizzeremo i dettagli:
#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;
}
}
Importazioni
Il programma inizia includendo il file header mic.h. Questa libreria fornisce strumenti per configurare e controllare l’hardware del microfono sulle piattaforme Seeed.
#include <mic.h>
Costanti
Sono definite due costanti. La prima, DEBUG, permette di abilitare il pulsare del pin durante gli interrupt per il debug. Se DEBUG è impostato a 1, il pin del LED si attiva ogni volta che si verifica un interrupt, fornendo un’indicazione visiva dell’attività di campionamento. La seconda costante, SAMPLES, specifica il numero di campioni audio da registrare prima della elaborazione.
#define DEBUG 1 // Enable pin pulse during ISR #define SAMPLES 800
Configurazione microfono
Il microfono è configurato usando una struttura mic_config_t. Qui, il microfono è impostato per usare un canale, una frequenza di campionamento di 16 kHz e una dimensione del buffer di 1600 campioni. Il debug_pin è collegato a LED_BUILTIN, così il LED a bordo lampeggia durante ogni interrupt se il debug è abilitato.
mic_config_t mic_config{
.channel_cnt = 1,
.sampling_rate = 16000,
.buf_size = 1600,
.debug_pin = LED_BUILTIN
};
Il programma crea quindi un oggetto microfono chiamato Mic usando la classe MG24_ADC_Class. Questo oggetto prende la configurazione del microfono come input e gestisce la raccolta dati.
MG24_ADC_Class Mic(&mic_config);
Buffer e flag
L’array recording_buf memorizza i campioni registrati, con una dimensione pari alla costante SAMPLES. Due variabili gestiscono il processo di registrazione: recording traccia lo stato di registrazione, e record_ready segnala quando il buffer è pieno e pronto per l’elaborazione. Entrambi sono dichiarati volatile perché modificati all’interno di una callback di interrupt.
int16_t recording_buf[SAMPLES]; volatile uint8_t recording = 0; volatile static bool record_ready = false;
Callback
Il cuore del processo di registrazione avviene nella funzione audio_rec_callback(). Questa callback viene eseguita automaticamente ogni volta che il buffer del microfono si riempie. La funzione copia i dati audio dal buffer di input nel buffer principale recording_buf.
Ogni valore ADC a 12 bit grezzo dal microfono viene convertito in un campione PCM a 16 bit con segno. La funzione tiene traccia dell’indice corrente nel buffer con una variabile statica idx. Quando il buffer raggiunge la dimensione massima (SAMPLES), la funzione resetta l’indice, azzera il flag di registrazione e imposta record_ready a true così che il loop sappia che i dati sono pronti per essere processati.
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
All’interno di setup(), il monitor seriale viene inizializzato a 115200 baud. Il programma assegna audio_rec_callback come funzione che gestirà i dati audio in arrivo ogni volta che il microfono raccoglie campioni.
Il microfono viene quindi avviato usando Mic.begin(). Se l’inizializzazione fallisce, il programma stampa un messaggio di errore ed entra in un loop infinito. Altrimenti conferma l’inizializzazione avvenuta con successo.
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 funzione loop() controlla se la registrazione è completata guardando record_ready. Se vero, il programma stampa "Finished sampling" e poi scorre il buffer, stampando ogni campione audio registrato. Dopo la stampa, resetta record_ready a false così il sistema può registrare di nuovo.
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;
}
}
Se carichi questo sketch e apri il Serial Plotter vedrai un segnale audio che varia in base all’audio rilevato dal microfono:
E questo è tutto! Queste istruzioni ed esempi di codice dovrebbero aiutarti a iniziare rapidamente con la XIAO MG24 Sense.
Conclusioni
In questo tutorial hai imparato come iniziare con la XIAO MG24 Sense di Seeed Studio. Per ulteriori informazioni dai un’occhiata al sito di Seeed Studio Getting Started Wiki. Gli esempi di codice in questo tutorial derivano dagli esempi nelle librerie Seeed_Arduino_Mic e Seeed_Arduino_LSM6DS3. Troverai altri esempi di codice lì.
Con il microfono integrato e il Matrix-Vector Processor (MVP), la XIAO MG24 Sense è particolarmente adatta per applicazioni TinyML come il riconoscimento di parole chiave, il controllo vocale o la classificazione sonora.
Un microcontrollore alternativo è l’ESP32 basato su XIAO-ESP32-S3-Sense – sempre di Seeed Studio. Anch’esso ha un microfono e, pur non avendo l’IMU, dispone di una fotocamera. Può essere usato per applicazioni vocali, vedi anche il nostro Voice control with XIAO-ESP32-S3-Sense and Edge Impulse, ma consuma più energia.
Tuttavia, se sei interessato al rilevamento oggetti, la XIAO ESP32 Sense è la scelta migliore grazie alla fotocamera integrata. Dai un’occhiata ai nostri tutorial Face Detection with XIAO ESP32-S3-Sense and SenseCraft AI e Edge AI Room Occupancy Sensor with ESP32 and Person Detection per maggiori dettagli.
Se hai domande, sentiti libero di lasciarle nella sezione commenti.
Buon divertimento con il tinkering 😉
