Das XIAO MG24 Senseist eines der Boards aus der XIAO-Serie von Seeed Studio, das einen leistungsstarken Silicon Labs EFR32MG24 Mikrocontroller mit integrierten Sensoren wie einem Mikrofon und einer 6-Achsen-IMU kombiniert. Dank seines kleinen Formfaktors, des energiesparenden Designs und der integrierten drahtlosen Funktionen ist es eine großartige Wahl für Projekte in den Bereichen IoT, Sensorfusion und Edge AI.
In diesem Leitfaden führen wir dich durch die Grundlagen, um mit dem XIAO MG24 Sense zu starten. Wir beginnen mit der Installation des notwendigen Board-Cores und führen dann das klassische blink Beispiel aus, um zu bestätigen, dass alles funktioniert. Danach erkunden wir seine wichtigsten Merkmale: das eingebaute Mikrofon und die IMU (Inertial Measurement Unit).
Benötigte Teile
Du benötigst ein XIAO MG24 Sense Board von Seeed Studio und ein USB-C-Kabel, um das Board zu programmieren und die Codebeispiele auszuprobieren.
Seeed Studio XIAO MG24 Sense
USB-C-Kabel
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.
Das XIAO MG24 Sense
Das XIAO MG24 Sense wird von dem Silicon Labs EFR32MG24 System-on-Chip angetrieben, der einen ARM Cortex-M33 Mikrocontroller mit bis zu 78 MHz nutzt. Das bietet ausreichend Rechenleistung für allgemeine Embedded-Projekte bei gleichzeitig hoher Energieeffizienz. Ein herausragendes Merkmal dieses Chips ist der Matrix-Vector Processor (MVP), ein kleiner Hardware-Beschleuniger, der die mathematischen Operationen für maschinelles Lernen beschleunigt. Dadurch eignet sich der MG24 Sense besonders gut für TinyML-Anwendungen wie Keyword Spotting oder Bewegungsklassifikation, ohne die Batterie zu schnell zu entladen.
In Bezug auf den Speicher verfügt das Board über 1,5 MB Flash und 256 kB RAM, die im Mikrocontroller integriert sind. Darüber hinaus hat Seeed Studio einen externen 4 MB SPI-Flash-Chip hinzugefügt, der nützlich ist, um größere Programme, Modelldaten oder sogar Logs zu speichern. Die Kombination aus internem und externem Speicher bietet dir Platz, um mit komplexeren Anwendungen zu experimentieren und dabei ein kleines Board zu nutzen.
Drahtlose Konnektivität ist eine weitere Stärke dieses Geräts. Der MG24 unterstützt Matter über Thread sowie Bluetooth Low Energy 5.3, was die Kompatibilität mit modernen IoT-Ökosystemen und Smartphone-Verbindungen sicherstellt. Das Board verfügt außerdem über Secure Vault Hardware-Sicherheitsfunktionen, die sensible Daten wie Verschlüsselungsschlüssel schützen und einen sicheren Bootvorgang ermöglichen.
Sensoren
Das „Sense“ im Namen des Boards stammt von den eingebauten Sensoren. Zuerst gibt es die LSM6DS3TR-C IMU, einen Sechs-Achsen-Sensor, der einen Dreiachs-Beschleunigungssensor mit einem Dreiachs-Kreisel kombiniert. Dieser Sensor kann Bewegung, Orientierung, Schritte und Gesten messen und verfügt sogar über Energiesparmodi für kontinuierliche Aktivitätserkennung ohne hohen Energieverbrauch. Weitere Details findest du im unten verlinkten Datenblatt:
Zusätzlich zur IMU gibt es das MSM381ACT001 MEMS-Mikrofon, mit dem du Ton aufnehmen kannst. Obwohl es sich um ein analoges Mikrofon handelt, macht der ADC des Mikrocontrollers das Abtasten und Verarbeiten von Audio einfach, sei es für Tonerkennung oder sprachgesteuerte Interaktionen. Siehe das unten verlinkte Datenblatt:
GPIO
Für die Hardware-Anbindung stellt das XIAO MG24 Sense 19 General-Purpose Input/Output (GPIO) Pins bereit, die im vertrauten XIAO-Layout angeordnet sind. Diese Pins können für I²C, SPI, UART und andere Standard-Schnittstellen verwendet werden.
Eine Benutzer-LED und eine Power-/Lade-LED sind ebenfalls vorhanden, um bei der Fehlersuche und schnellen Rückmeldung zu helfen. Das Hochladen des Codes erfolgt über den USB-C-Anschluss, der auch als Strom- und Ladeanschluss dient.
Stromversorgung
Energieeffizienz ist eine der größten Stärken des XIAO MG24 Sense. In Tiefschlafmodi kann der Mikrocontroller seinen Stromverbrauch auf nur wenige Mikroampere reduzieren, was ihn ideal für batteriebetriebene Projekte macht. Das Board enthält eine Ladeelektronik für Li-Po-Akkus und kann auch die Batteriespannung messen, sodass deine Projekte ihren eigenen Ladezustand überwachen können. Mit diesen Funktionen ist der MG24 Sense eine ausgezeichnete Wahl für langfristige, batteriebetriebene IoT-Knoten.
Größe
Trotz all dieser Funktionen behält das Board den klassischen XIAO-Formfaktor von nur 21 × 17,8 mm bei, was es einfach macht, es in kompakte Projekte oder Wearables einzubauen. Es verfügt über eine eingebaute Antenne für die drahtlose Kommunikation, sodass keine zusätzlichen Module zum Starten benötigt werden.
Zusammenfassend kombiniert der XIAO MG24 Sense einen leistungsstarken und effizienten Mikrocontroller, moderne drahtlose Konnektivität, sichere Hardware, integrierte Bewegungs- und Audiosensoren, großzügigen Speicher und ein batteriefreundliches Design in einem sehr kleinen Paket.
Technische Spezifikationen
| Merkmal | Spezifikation |
|---|---|
| Prozessor | Silicon Labs EFR32MG24, ARM Cortex-M33, bis zu 78 MHz |
| Hardware-Beschleuniger | Matrix-Vector Processor (MVP) für ML-Workloads |
| Interner Speicher | 1536 kB Flash, 256 kB RAM |
| Externer Speicher | 4 MB SPI-Flash |
| Drahtlos | Matter (Thread), Bluetooth Low Energy 5.3 |
| Sicherheit | Secure Vault Hardware-Sicherheits-Engine |
| IMU | LSM6DS3TR-C, 6-Achsen-Beschleunigungssensor + Gyroskop |
| Mikrofon | MSM381ACT001 analoges MEMS-Mikrofon |
| GPIO | 19 Pins (I²C, SPI, UART, GPIO, etc.) |
| USB | USB-C für Programmierung, Stromversorgung und Laden |
| Batteriefunktionen | Integrierte Ladeelektronik, Batteriespannungsüberwachung |
| Energieeffizienz | Ultra-niedriger Stromverbrauch, Schlafstrom bis ca. 1,95 µA |
| Formfaktor | 21 × 17,8 mm, integrierte Antenne |
XIAO MG24 Sense versus XIAO MG24
Seeed Studio bietet zwei eng verwandte Versionen dieses Boards an: das XIAO MG24 und das XIAO MG24 Sense. Beide basieren auf dem gleichen Fundament, dem EFR32MG24 Mikrocontroller mit ARM Cortex-M33 Kern, Matrix-Vector Processor für maschinelles Lernen und Unterstützung moderner drahtloser Standards wie Matter (Thread) und Bluetooth Low Energy 5.3. Sie teilen auch den gleichen kompakten XIAO-Formfaktor, den gleichen externen 4 MB Flash und das gleiche energiesparende Design mit integrierter Ladeelektronik für Li-Po-Akkus.
Der Hauptunterschied liegt in den Sensorfähigkeiten. Das XIAO MG24 Sense integriert zwei zusätzliche eingebaute Sensoren: die LSM6DS3TR-C 6-Achsen-IMU und das MSM381ACT001 analoges MEMS-Mikrofon. Diese Ergänzungen ermöglichen es der Sense-Version, Bewegung, Orientierung und Ton direkt zu erkennen, was sie zu einer viel besseren Option für Projekte mit Gestenerkennung, Audioeingabe oder Sensorfusion macht. Im Gegensatz dazu enthält das Standard-XIAO MG24 diese Sensoren nicht, was es etwas günstiger macht und besser geeignet, wenn du nur den Mikrocontroller, die drahtlosen Funktionen und I/O-Pins benötigst.
Ein weiterer kleiner Unterschied liegt in den vorgesehenen Anwendungsfällen. Das XIAO MG24 ist als universelles, ultra-niedrigstrom IoT-Board konzipiert, während das XIAO MG24 Sense eher für Edge AI- und Smart-Sensing-Projekte gedacht ist, bei denen Bewegung und Audio eine Rolle spielen. Wenn dein Projekt Dinge wie TinyML Keyword Spotting, Fitness-Tracking, Gestensteuerung oder soundgesteuerte Ereignisse umfasst, erspart dir die Sense-Version das Anschließen externer Sensoren. Wenn du jedoch ein einfaches, kostengünstiges Basisboard für drahtlose IoT-Knoten oder Sensornetzwerke suchst, könnte das nicht-Sense MG24 ausreichen.
XIAO MG24 versus ESP32
Der ESP32 ist in der Maker-Community bekannt für die Kombination eines Dual-Core- (oder je nach Variante Single-Core-) Xtensa LX6/LX7 Prozessors mit bis zu 240 MHz und Wi-Fi- und BluetoothKonnektivität. Das macht ihn besonders attraktiv für Projekte, die höhere Rohverarbeitungsleistung oder Internetverbindung via Wi-Fi benötigen. Der ESP32 verfügt auch über großzügigen RAM (oft 520 kB SRAM, mit externem PSRAM bei einigen Modulen) und Flash-Speicher, was ihn geeignet macht für Anwendungen wie Webserver, Echtzeit-Audiostreaming oder komplexe Benutzeroberflächen. Sein Ökosystem ist umfangreich, mit exzellentem Community-Support, zahlreichen Tutorials und Kompatibilität mit Plattformen wie Arduino, ESP-IDF und MicroPython.
Im Gegensatz dazu konzentriert sich der EFR32MG24 im XIAO MG24 auf niedrigen Stromverbrauch, moderne drahtlose Standards und Sicherheit. Er läuft mit einer niedrigeren Taktfrequenz (bis zu 78 MHz) und hat weniger RAM, beinhaltet aber den Matrix-Vector Processor (MVP) zur Beschleunigung von Machine-Learning-Aufgaben. Statt Wi-Fi unterstützt er Matter (Thread) und Bluetooth Low Energy 5.3, die beide für Smart-Home- und IoT-Anwendungen mit niedrigem Stromverbrauch und Mesh-Netzwerken sehr relevant sind. Der MG24 integriert außerdem Silicon Labs’ Secure Vault Funktionen, die Hardware-Verschlüsselung und sicheren Boot bieten.
Kurz gesagt, der ESP32 eignet sich besser für Anwendungen, bei denen Wi-Fi-Konnektivität, höhere Rechenleistung oder großer Speicherbedarf notwendig sind, während der MG24 für batteriebetriebene IoT-Knoten, Sensordevices und Anwendungen mit hohen Sicherheitsanforderungen und modernen drahtlosen Standards ausgelegt ist. Beide werden von Arduino unterstützt, aber der ESP32 profitiert von einer größeren Community und einem größeren Ökosystem, während der MG24 eine starke Wahl für Entwickler ist, die an Matter, BLE 5.3 und ultra-niedrigem Stromverbrauch interessiert sind.
Vergleichstabelle
| Merkmal | XIAO MG24 (EFR32MG24) | ESP32 (typische Varianten) |
|---|---|---|
| Prozessor | ARM Cortex-M33, bis zu 78 MHz | Xtensa LX6/LX7, Single- oder Dual-Core, bis zu 240 MHz |
| Hardware-Beschleuniger | MVP (Matrix-Vector Processor für ML) | Keiner (einige ESP32-Varianten enthalten KI/ML Co-Prozessoren, z.B. ESP32-S3 mit Vektor-Instruktionen) |
| Interner Speicher | 1536 kB Flash, 256 kB RAM | ~448–520 kB SRAM, externer PSRAM bei einigen Modulen |
| Externer Speicher | 4 MB SPI-Flash (auf XIAO-Board) | Typischerweise 4–16 MB Flash, optional PSRAM |
| Drahtlos | Matter (Thread), Bluetooth 5.3 | Wi-Fi 2,4 GHz, Bluetooth 4.2/5.0 (je nach Variante) |
| Sicherheit | Secure Vault Hardware (Secure Boot, Schlüsselverwaltung) | Secure Boot, Flash-Verschlüsselung (variiert je nach Variante) |
| Ökosystem | Unterstützt in Arduino, offizielle Silicon Labs SDKs | Arduino, ESP-IDF, MicroPython, CircuitPython, große Community |
| Energieeffizienz | Ultra-niedriger Stromverbrauch, Schlafstrom im µA-Bereich | Niedrigstrommodi verfügbar, aber typischerweise höherer Stromverbrauch |
| Am besten geeignet für | Niedrigstrom-IoT-Knoten, Matter/Thread-Geräte, BLE-Anwendungen | Wi-Fi-verbundene Projekte, Webserver, Echtzeit-Streaming, allgemeine Maker-Projekte |
Core installieren
Bevor du mit dem Programmieren des XIAO MG24 oder XIAO MG24 Sense mit der Arduino IDE beginnen kannst, musst du den Board-Core installieren. Aber was genau ist ein Board-Core?
Ein Core im Arduino-Ökosystem ist im Wesentlichen eine Sammlung von Softwaredateien, die es der Arduino IDE ermöglicht, einen bestimmten Mikrocontroller zu verstehen und mit ihm zu kommunizieren. Er enthält den Compiler, Linker, Startdateien, Bibliotheken und Board-Definitionen, die benötigt werden, um Code für diesen Mikrocontroller zu erstellen und hochzuladen. Ohne einen Core wüsste die Arduino IDE nicht, wie sie deine Sketche in Maschinencode übersetzen soll, den der Mikrocontroller ausführen kann.
URL zu den Einstellungen hinzufügen
Der XIAO MG24 verwendet den Silicon Labs EFR32MG24 Mikrocontroller, der nicht in der Standard-Arduino-Installation enthalten ist. Um Unterstützung für dieses Board hinzuzufügen, folge diesen Schritten.
Zuerst, öffne die Arduino IDE und gehe zu Datei → Einstellungen:
Als nächstes füge im Feld Zusätzliche Board-Manager-URLs die URL für das Seeed Studio Paket hinzu. Die aktuelle URL lautet:
https://files.seeedstudio.com/arduino/package_seeeduino_boards_index.json
Du kannst die URL als Text im Eingabefeld hinzufügen. Wenn du bereits andere URLs eingetragen hast, trenne sie mit einem Komma.
Oder du klickst auf das Symbol rechts, das einen separaten Editor öffnet, in dem du die URL hinzufügen kannst. Im Screenshot unten siehst du, dass ich bereits den ESP8266-Core und den ESP32-Core installiert habe:
Boards installieren
Dann öffne den Boards Manager über Werkzeuge → Board → Boards Manager… und tippe „MG24“ in die Suchleiste. Du wirst Silicon Labs und einen Text sehen, der das unterstützte Board auflistet. Drücke den INSTALL Button. Der Screenshot unten zeigt, wie das nach der Installation des Cores aussieht (der INSTALL Button wird zu einem ENTFERNEN Button):
Nach der Installation wähle ein Board aus dem Dropdown-Menü unter der Menüleiste aus: Im Beispiel unten ist ein Arduino Uno als ausgewähltes Board zu sehen.
Ein Klick auf den Namen des aktuell ausgewählten Boards (Arduino Uno) öffnet den Board-Auswahldialog. Tippe im Suchfeld „mg24“ ein und wähle „Seeed Studio XIAO MG24 (Sense)“ wie unten gezeigt aus:
Wenn das Board per USB mit deinem PC verbunden ist, solltest du auch den COM-Port auswählen können. Im Screenshot oben ist es COM8, bei dir könnte es ein anderer COM-Port sein.
Nach der Installation behandelt die Arduino IDE den MG24 wie jedes andere unterstützte Board. Du kannst Bibliotheken nutzen, GPIO, I²C, SPI, ADC verwenden und sogar eingebaute Beispiele für das Board nutzen, wie das klassische Blink sketch, das wir im nächsten Abschnitt implementieren werden.
Blink-Code
Sobald der Core für den MG24 installiert ist, testen wir ihn, um zu sehen, ob er tatsächlich funktioniert. Wir verwenden das bekannte Blink-Programm für unseren Test. Unten ist der 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);
Es lässt die eingebaute LED jede Sekunde blinken und gibt den Status der LED auch im Serial Monitor aus. Beachte, dass die Logik invertiert ist. Ein HIGH-Signal am LED-Pin schaltet die LED aus und umgekehrt.
Lade den Code auf dein Board hoch, indem du in der Arduino IDE auf das Upload-Symbol klickst. Stelle sicher, dass du das richtige Board ausgewählt hast (Seeed Studio XIAO MG24):
Du solltest den folgenden Kompilierungs- und Programmierstatus im Ausgabeterminal sehen. Lass dich nicht von der roten Farbe täuschen. Wenn du „** Programming Finished **“ lesen kannst, ist alles gut.
Wechsle als Nächstes zur Terminalausgabe des Serial Monitors. Du solltest eine Folge von „ON“ und „OFF“ Meldungen sehen. Gleichzeitig sollte die orange LED des XIAO MG24 Boards blinken.
Wenn das alles funktioniert, Glückwunsch, du kannst jetzt dein XIAO MG24 Sense programmieren ; )
In den nächsten Abschnitten probieren wir die Inertial Measurement Unit (IMU) und das Mikrofon des XIAO MG24 Sense aus.
IMU-Code
Der folgende Sketch zeigt, wie man Bewegungsdaten vom LSM6DS3, einer 6-Achsen-IMU, die einen 3-Achsen-Beschleunigungssensor und ein 3-Achsen-Gyroskop kombiniert, ausliest.
Bevor du ihn ausführen kannst, musst du die Seeed_Arduino_LSM6DS3 Bibliothek installieren. Lade die Bibliothek als .ZIP-Datei vom Github-Repo herunter und installiere sie über Sketch → Include Library → Add .ZIP Library …
Das Beispielprogramm initialisiert den Sensor, prüft auf Fehler und gibt kontinuierlich Beschleunigungs- und Gyroskopwerte im Serial Monitor aus. Lass uns den Code Schritt für Schritt durchgehen.
#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
Der Sketch beginnt mit dem Einbinden von zwei wichtigen Bibliotheken. Die erste ist <LSM6DS3.h>, die eine einfache Schnittstelle zur LSM6DS3 IMU bereitstellt. Die zweite ist <Wire.h>, die die I2C-Kommunikation zwischen Arduino und Sensor ermöglicht. Ohne diese kann der Arduino nicht mit der IMU kommunizieren.
#include <LSM6DS3.h> #include <Wire.h>
Objekte
Nach den Imports erstellt der Sketch ein Objekt namens myIMU aus der LSM6DS3 Klasse. Der Konstruktor weist das Programm an, die I2C-Kommunikation zu verwenden und setzt die I2C-Adresse des Sensors auf 0x6A. Diese Adresse hängt davon ab, wie die Pins des Sensors verdrahtet sind und muss zur Hardwarekonfiguration passen.
LSM6DS3 myIMU(I2C_MODE, 0x6A);
Setup
Die setup() Funktion läuft einmal am Anfang. Sie öffnet die serielle Schnittstelle mit 115200 Baud, damit wir die Sensordaten im Serial Monitor der Arduino IDE sehen können.
Serial.begin(115200);
Als Nächstes konfiguriert der Code Pin PD5 als Ausgang und setzt ihn auf HIGH. Dieser wird verwendet, um die IMU zu aktivieren.
pinMode(PD5, OUTPUT); digitalWrite(PD5, HIGH);
Schließlich initialisiert der Sketch die IMU durch Aufruf von myIMU.begin(). Wenn die Funktion einen Wert ungleich Null zurückgibt, gibt das Programm "Device error" im Serial Monitor aus, was signalisiert, dass der Sensor nicht erkannt oder korrekt initialisiert werden konnte.
if (myIMU.begin() != 0) {
Serial.println("Device error");
}
Loop
Die loop() Funktion läuft kontinuierlich nach dem Setup. In jedem Zyklus liest der Sketch Beschleunigungs- und Gyroskopdaten von der IMU aus und gibt sie im Serial Monitor im CSV-Format aus.
Die Beschleunigungswerte werden in den X-, Y- und Z-Richtungen gemessen. Jeder Aufruf von readFloatAccelX(), readFloatAccelY() und readFloatAccelZ() liefert einen Fließkommawert in g, der die Beschleunigung relativ zur Erdanziehung misst. Das zweite Argument 3 gibt an, dass der Serial Monitor drei Nachkommastellen ausgeben soll.
Serial.print(myIMU.readFloatAccelX(), 3);
Serial.print(',');
Serial.print(myIMU.readFloatAccelY(), 3);
Serial.print(',');
Serial.print(myIMU.readFloatAccelZ(), 3);
Anschließend werden die Gyroskopwerte in den X-, Y- und Z-Richtungen ausgelesen. Die Funktionen readFloatGyroX(), readFloatGyroY() und readFloatGyroZ() liefern die Winkelgeschwindigkeit in Grad pro Sekunde. Auch hier gibt der Sketch jeden Wert mit drei Dezimalstellen aus, getrennt durch Kommas.
Serial.print(',');
Serial.print(myIMU.readFloatGyroX(), 3);
Serial.print(',');
Serial.print(myIMU.readFloatGyroY(), 3);
Serial.print(',');
Serial.print(myIMU.readFloatGyroZ(), 3);
Am Ende jeder Schleife gibt der Sketch eine neue Zeile aus, sodass jeder vollständige Datensatz in einer eigenen Zeile erscheint. Danach pausiert er 500 Millisekunden, bevor er wiederholt. Diese Verzögerung hält die Ausgabe lesbar und verhindert eine Überflutung des Serial Monitors.
Serial.println(); delay(500);
Wenn du diesen Code hochlädst und ausführst, solltest du einen Zahlenstrom im Serial Monitor sehen, der sich ändert, wenn du das XIAO MG24 Sense bewegst:
In den nächsten zwei Abschnitten probieren wir das Mikrofon des XIAO MG24 Sense mit zwei verschiedenen Bibliotheken aus.
Mikrofon-Code mit SiliconLabs-Bibliothek
Der folgende Code zeigt, wie man Audiosamples vom Mikrofon erfasst, den durchschnittlichen Signalpegel berechnet und diesen Pegel auf die LED-Helligkeit abbildet. Er verwendet ein Callback-System, um Mikrofon-Daten effizient zu verarbeiten. Lass uns den Code Stück für Stück ansehen.
#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
Der Sketch beginnt mit dem Einbinden der SilabsMicrophoneAnalog.h Bibliothek. Diese Bibliothek stellt Funktionen bereit, um das Mikrofon zu initialisieren, das Sampling zu starten und zu stoppen sowie die gesammelten Daten zu verarbeiten.
#include <SilabsMicrophoneAnalog.h>
Konstanten
Als Nächstes definiert das Programm mehrere Konstanten. MIC_DATA_PIN und MIC_PWR_PIN geben die Pins an, die mit den Daten- und Stromleitungen des Mikrofons verbunden sind. NUM_SAMPLES bestimmt, wie viele Audiosamples auf einmal gesammelt werden. MIC_VAL_MIN und MIC_VAL_MAX definieren den erwarteten Wertebereich des Mikrofons zur Normalisierung. Diese Grenzen helfen, unerwünschtes Rauschen herauszufiltern und eine gute LED-Helligkeitszuordnung sicherzustellen.
#define MIC_DATA_PIN PC9 #define MIC_PWR_PIN PC8 #define NUM_SAMPLES 128 #define MIC_VAL_MIN 735 #define MIC_VAL_MAX 900
Puffer
Zwei Puffer speichern die Mikrofonsamples. mic_buffer hält die rohen Samples vom Mikrofon, während mic_buffer_local eine sichere Kopie dieser Samples für die Verarbeitung speichert. Diese Trennung verhindert Fehler, falls neue Daten eintreffen, während noch Berechnungen laufen.
uint32_t mic_buffer[NUM_SAMPLES]; uint32_t mic_buffer_local[NUM_SAMPLES];
Flags und Objekte
Die Variable data_ready_flag signalisiert dem Programm, wann ein neuer Satz von Samples verfügbar ist. Sie ist als volatile markiert, da sie innerhalb eines Interrupts oder Callbacks aktualisiert wird. Das Objekt micAnalog wird aus der MicrophoneAnalog Klasse erstellt. Es erhält die Daten- und Strompins des Mikrofons als Parameter.
volatile bool data_ready_flag = false; MicrophoneAnalog micAnalog(MIC_DATA_PIN, MIC_PWR_PIN);
Mikrofon-Callback
Die Funktion mic_samples_ready_cb() läuft automatisch, sobald das Mikrofon eine Charge von Samples gesammelt hat. Sie kopiert den Inhalt von mic_buffer in mic_buffer_local und setzt data_ready_flag auf true, was signalisiert, dass die Daten bereit zur Verarbeitung sind.
void mic_samples_ready_cb() {
memcpy(mic_buffer_local, mic_buffer, NUM_SAMPLES * sizeof(uint32_t));
data_ready_flag = true;
}
Verarbeitung der Sprachpegel
Die Funktion calculate_and_display_voice_level() verarbeitet die Audiodaten und aktualisiert die LED-Helligkeit. Zuerst stoppt sie das Mikrofon-Sampling, um Störungen während der Berechnung zu vermeiden. Dann berechnet sie den Durchschnittswert mit micAnalog.getAverage(). Dieser Wert wird zwischen MIC_VAL_MIN und MIC_VAL_MAX begrenzt, um extreme Ausreißer zu glätten.
Um die LED-Reaktion weicher zu machen, wird der Durchschnittswert mit dem vorherigen Durchschnitt durch einen einfachen Filter kombiniert. Das Ergebnis wird vom Mikrofonbereich auf den LED-Helligkeitsbereich von 0 bis 255 abgebildet. Schließlich wird die LED-Helligkeit mit analogWrite() gesetzt. Ein höherer Pegel macht die LED heller.
Die Funktion gibt den Durchschnittswert auch im Serial Monitor aus und startet dann das Mikrofon-Sampling neu.
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
Die setup() Funktion bereitet den Serial Monitor und die LED vor. Sie initialisiert auch das Mikrofon mit dem Puffer und der Anzahl der Samples. Nach der Initialisierung startet der Sketch das Sampling und gibt Bestätigungsmeldungen im Serial Monitor aus.
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
Die loop() Funktion prüft, ob neue Daten bereitstehen. Wenn data_ready_flag wahr ist, wird das Flag gelöscht und calculate_and_display_voice_level() aufgerufen. So wird sichergestellt, dass die Mikrofon-Daten nur verarbeitet werden, wenn frische Samples vorliegen.
void loop() {
if (data_ready_flag) {
data_ready_flag = false;
calculate_and_display_voice_level();
}
}
Nach dem Hochladen des Codes solltest du sehen, wie sich die Helligkeit der eingebauten LED je nach Umgebungslautstärke ändert. Je lauter, desto heller.
Mikrofon-Code mit Seeed_Arduino_Mic Bibliothek
Dieser Sketch initialisiert ein Mikrofon mit der Seeed_Arduino_Mic Bibliothek, sammelt eine feste Anzahl von Audiosamples und gibt sie als Rohdaten aus. Er zeigt, wie man Mikrofonparameter einstellt, Callbacks handhabt und eingehende Audiodaten verarbeitet.
Du musst die Seeed_Arduino_Mic Bibliothek installieren, bevor du diesen Code ausführen kannst. Lade die Bibliothek als .ZIP-Datei vom Github-Repo herunter und installiere sie über Sketch → Include Library → Add .ZIP Library …
Schau dir zuerst den kompletten Sketch an, dann gehen wir auf die Details ein:
#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
Das Programm beginnt mit dem Einbinden der mic.h Header-Datei. Diese Bibliothek bietet Werkzeuge zur Konfiguration und Steuerung der Mikrofon-Hardware auf Seeeds Plattformen.
#include <mic.h>
Konstanten
Zwei Konstanten werden definiert. Die erste, DEBUG, erlaubt es, das Pin-Pulsieren während Interrupts zum Debuggen zu aktivieren. Wenn DEBUG auf 1 gesetzt ist, toggelt der LED-Pin bei jedem Interrupt und gibt so eine visuelle Rückmeldung über die Sampling-Aktivität. Die zweite Konstante, SAMPLES, gibt die Anzahl der Audiosamples an, die vor der Verarbeitung aufgenommen werden.
#define DEBUG 1 // Enable pin pulse during ISR #define SAMPLES 800
Mikrofon-Konfiguration
Das Mikrofon wird mit einer mic_config_t Struktur konfiguriert. Hier ist das Mikrofon auf einen Kanal, eine Abtastrate von 16 kHz und eine Puffergröße von 1600 Samples eingestellt. Die debug_pin ist mit LED_BUILTIN verbunden, sodass die eingebaute LED bei jedem Interrupt toggelt, wenn Debugging aktiviert ist.
mic_config_t mic_config{
.channel_cnt = 1,
.sampling_rate = 16000,
.buf_size = 1600,
.debug_pin = LED_BUILTIN
};
Das Programm erstellt dann ein Mikrofon-Objekt namens Mic mit der MG24_ADC_Class. Dieses Objekt erhält die Mikrofon-Konfiguration als Eingabe und verwaltet die Datenerfassung.
MG24_ADC_Class Mic(&mic_config);
Puffer und Flags
Das Array recording_buf speichert die aufgenommenen Samples, mit einer Größe entsprechend der Konstanten SAMPLES. Zwei Variablen steuern den Aufnahmeprozess: recording verfolgt den Aufnahmezustand, und record_ready signalisiert, wenn der Puffer voll ist und zur Verarbeitung bereitsteht. Beide sind als volatile deklariert, da sie in einem Interrupt-Callback geändert werden.
int16_t recording_buf[SAMPLES]; volatile uint8_t recording = 0; volatile static bool record_ready = false;
Callback
Der Kern des Aufnahmeprozesses findet in der audio_rec_callback() Funktion statt. Dieser Callback läuft automatisch, wenn der Mikrofon-Puffer voll ist. Die Funktion kopiert Audiodaten aus dem Eingabepuffer in den Hauptpuffer recording_buf.
Jeder rohe 12-Bit-ADC-Wert vom Mikrofon wird in ein vorzeichenbehaftetes 16-Bit PCM-Sample umgewandelt. Die Funktion verfolgt den aktuellen Index im Puffer mit einer statischen Variable idx. Wenn der Puffer seine maximale Größe (SAMPLES) erreicht, setzt die Funktion den Index zurück, löscht das Aufnahme-Flag und setzt record_ready auf true, damit die Loop weiß, dass Daten zur Verarbeitung bereitstehen.
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
Im setup() wird der Serial Monitor mit 115200 Baud initialisiert. Das Programm weist audio_rec_callback als Funktion zu, die eingehende Audiodaten verarbeitet, sobald das Mikrofon Samples sammelt.
Das Mikrofon wird dann mit Mic.begin() gestartet. Wenn die Initialisierung fehlschlägt, gibt das Programm eine Fehlermeldung aus und bleibt in einer Endlosschleife. Andernfalls bestätigt es die erfolgreiche Initialisierung.
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
Die loop() Funktion prüft, ob die Aufnahme abgeschlossen ist, indem sie record_ready abfragt. Wenn wahr, gibt das Programm "Finished sampling" aus und durchläuft dann den Puffer, um jedes aufgenommene Audiosample auszugeben. Nach dem Drucken setzt es record_ready auf false zurück, damit das System erneut aufnehmen kann.
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;
}
}
Wenn du diesen Sketch hochlädst und den Serial Plotter öffnest, siehst du ein Audiosignal, das je nach vom Mikrofon erfasstem Ton variiert:
Und das war’s! Diese Anleitungen und Codebeispiele sollten dir helfen, schnell mit dem XIAO MG24 Sense zu starten.
Fazit
In diesem Tutorial hast du gelernt, wie du mit dem XIAO MG24 Sense von Seeed Studio startest. Für weitere Informationen wirf einen Blick auf Seeed Studios Getting Started Wiki. Die Codebeispiele in diesem Tutorial stammen aus den Beispielen der Seeed_Arduino_Mic und der Seeed_Arduino_LSM6DS3 Bibliotheken. Dort findest du noch mehr Codebeispiele.
Mit dem eingebauten Mikrofon und dem Matrix-Vector Processor (MVP) eignet sich der XIAO MG24 Sense besonders für TinyML-Anwendungen wie Keyword Spotting, Sprachsteuerung oder Klangklassifikation.
Eine alternative Mikrocontroller-Plattform ist der ESP32-basierte XIAO-ESP32-S3-Sense – ebenfalls von Seeed Studio. Er verfügt ebenfalls über ein Mikrofon und hat statt der IMU eine Kamera. Er kann für Sprach-Anwendungen genutzt werden, siehe auch unser Voice control with XIAO-ESP32-S3-Sense and Edge Impulse, verbraucht aber mehr Strom.
Wenn du jedoch an Objekterkennung interessiert bist, ist der XIAO ESP32 Sense aufgrund der eingebauten Kamera die bessere Wahl. Schau dir dazu unsere Face Detection with XIAO ESP32-S3-Sense and SenseCraft AI und die Edge AI Room Occupancy Sensor with ESP32 and Person Detection Tutorials an.
Wenn du Fragen hast, hinterlasse sie gerne im Kommentarbereich.
Viel Spaß beim Tüfteln 😉
