Erste Schritte mit dem Gravity Spracherkennungsmodul

Sprachgesteuerte Interaktion wird zunehmend zentral für moderne Embedded-Systeme, Robotik und smarte Geräte. Das Gravity Voice Recognition Module von DFRobot bietet ein kompaktes, offline-fähiges Modul, das für Maker und Entwickler gedacht ist, die mit Plattformen wie Arduino, micro:bit und ESP32 arbeiten. Dieses Modul unterstützt sowohl I²C- als auch UART-Kommunikation, verfügt über 121 vorprogrammierte Sprachbefehle und erlaubt es, bis zu 17 benutzerdefinierte Phrasen lokal zu trainieren – alles ohne Internetverbindung.

In diesem Leitfaden führen wir dich durch die wichtigsten Funktionen des Moduls, bereiten die notwendige Hardware- und Softwareeinrichtung vor und zeigen dann, wie du das Modul in ein einfaches sprachgesteuertes Projekt integrierst. Egal, ob dein Ziel ein sprachaktiviertes Lichtsystem, ein Roboterassistent oder eine sprachgesteuerte Automatisierungsroutine ist, dieser Beitrag dient als praktischer Einstieg, um das Gravity Voice Recognition Module unter deiner eigenen Kontrolle zum Laufen zu bringen.

Wo kaufen

Das Gravity Voice Recognition Module kannst du bei DFRobot oder Amazon erwerben. Der untenstehende Link führt zum Produkt auf Amazon. Außerdem benötigst du einen Mikrocontroller. Ich verwende ein Arduino UNO, aber die meisten gängigen Mikrocontroller (z.B. ESP32, ESP8266, …) funktionieren ebenfalls. Und wenn du ein paar Projekte ausprobieren möchtest, sind ein Breadboard und einige Kabel sehr hilfreich.

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.

Hardware des Gravity Voice Recognition Modules

Das Gravity Voice Recognition Module von DFRobot ist eine kompakte, eigenständige Spracheinheit, die Offline-Sprachsteuerung für Embedded-Systeme ermöglicht. Im Kern integriert das Modul einen leistungsstarken Spracherkennungs-Chip, der lokale Befehlsanalysen ohne Cloud-Dienste durchführt. Das sorgt für schnelle Reaktionen, geringe Latenz und vollständige Unabhängigkeit von Netzwerkverbindungen.

Komponenten

Das Modul enthält einen kleinen eingebauten Lautsprecher und einen Anschluss für einen externen Lautsprecher (8 Ω 3W). Ein kleiner Schalter ermöglicht den Wechsel zwischen den beiden Lautsprechern. Ein zweiter Schalter erlaubt die Auswahl zwischen I2C- und UART-Kommunikation mit dem Modul.

Außerdem sind zwei Mikrofone und zwei Status-LEDs auf der Platine verbaut. Eine LED (rot) zeigt die Stromversorgung an, die andere (blau) signalisiert, dass das Weckwort erkannt wurde und das Modul bereit ist, Sprachbefehle zu empfangen. Das Bild unten zeigt die Komponenten des Moduls:

Components of the Gravity Voice Recognition Module — Komponenten des Gravity Voice Recognition Modules

Versionen

Beachte, dass es zwei Versionen des Moduls gibt: Version 1.0 und Version 1.1. Die ältere Version 1.0 hat keinen Anschluss für den eingebauten Lautsprecher und zwei Befestigungslöcher weniger. Ansonsten sind Hardware und Programmierung identisch. Das Foto unten zeigt die beiden Modulversionen:

Versions of the Gravity Voice Recognition Module — Versionen des Gravity Voice Recognition Modules

Stromversorgung

Das Modul arbeitet im typischen Spannungsbereich von 3,3 V bis 5 V, was die Kompatibilität mit 3,3V-Logiksystemen (wie ESP32 und Raspberry Pi Pico) sowie 5V-Systemen (wie Arduino Uno) sicherstellt. Die kompakte Bauform (49 mm × 32 mm) macht es geeignet für den Einbau in platzbeschränkte Gehäuse.

Befehle

Das Modul verfügt über 121 vorprogrammierte Befehle, wie „Turn the light on“, die nicht verändert werden können. Es gibt außerdem ein festes Weckwort („Hello Robot“). Es stehen 17 Slots für lernbare Befehlswörter und ein Slot für ein lernbares Weckwort zur Verfügung. Eine vollständige Liste der vorprogrammierten Befehle findest du im DFRobot Wiki for the Gravity Voice Recognition Module.

Das Modul wacht auf, wenn das Weckwort erkannt wird, bleibt dann für eine programmierbare Zeit aktiv und ist währenddessen bereit, Sprachbefehle zu erkennen.

Technische Daten

Parameter	Spezifikation
Produktname	Gravity Voice Recognition Module
Versorgungsspannung	3,3 V – 5 V
Kommunikationsschnittstelle	I²C und UART (umschaltbar)
I2C-Adresse	0x64
Erkennungsmodus	Offline-Spracherkennung
Eingebaute Befehle	121 vorprogrammiert
Benutzerdefinierte Befehle	Bis zu 17 benutzerdefinierte
Aktivierungsbefehl für Lernen	1
Mikrofon	2 x eingebaut
Mikrofonempfindlichkeit	-28 dB
Lautsprecher	Eingebaut, mit optionalem externem Lautsprecher
Betriebsstrom	≤ 370 mA @ 5V
Betriebstemperatur	0 °C bis +70 °C
Abmessungen	49 mm × 32 mm
Anschluss	Gravity 4-Pin-Schnittstelle (VCC, GND, SDA/RX, SCL/TX)

Anschluss des Voice Recognition Modules an ein Arduino UNO

Der Anschluss des Gravity Voice Recognition Modules an ein Arduino UNO ist einfach. Verbinde GND des Gravity Moduls mit GND des Arduino und VCC mit 5V.

Als nächstes verbinden wir die I2C-Schnittstelle. Die SCL-Leitung am Pin A5 des Arduino muss mit dem C/R-Pin des Gravity Moduls (grünes Kabel) verbunden werden. Schließlich verbinden wir SDA (A4) vom Arduino mit D/T des Gravity Moduls. Das Bild unten zeigt die komplette Verkabelung:

Wiring of the Voice Recognition Module with an Arduino UNO — Verkabelung des Voice Recognition Modules mit einem Arduino UNO

Im nächsten Abschnitt schreiben wir etwas Code, um das Voice Recognition Module auszuprobieren.

Bibliothek für Gravity Voice Recognition Module installieren

Bevor wir das Gravity Voice Recognition Module mit einem Arduino oder ESP32 verwenden können, müssen wir zuerst die DFRobot_DF2301Q Library in der Arduino IDE installieren. Öffne einfach den LIBRARY MANAGER, gib DFRobot_DF2301Q in die Suchleiste ein und drücke INSTALL:

Installing DFRobot_DF2301Q Library — Installation der DFRobot_DF2301Q Bibliothek

Code-Beispiel: Eingebaute LED ein- oder ausschalten

Im ersten Code-Beispiel schalten wir die eingebaute LED des Arduino UNO mit den Befehlen pre-programmed voice commands „Turn on the light“ und „Turn off the light“ ein- oder aus. Da wir die vorprogrammierten Befehle verwenden, ist kein Lernen oder andere Vorbereitung des Voice Recognition Modules erforderlich. Schau dir den Code kurz an, dann besprechen wir die Details.

#include "DFRobot_DF2301Q.h"

const byte led = LED_BUILTIN;

DFRobot_DF2301Q_I2C asr;

void setup() {
  Serial.begin(115200);

  pinMode(led, OUTPUT);    
  digitalWrite(led, LOW);  

  while (!(asr.begin())) {
    Serial.println("Can't initialize ASR");
    delay(3000);
  }

  asr.setVolume(6);
  asr.setMuteMode(0);  // 1=Mute
  asr.setWakeTime(20);
}

void loop() {
  uint8_t cmd_id = asr.getCMDID();
  if (cmd_id==103) {
      digitalWrite(led, HIGH);      
      Serial.println("Turn on the light");  
  }
  if (cmd_id==104) {
      digitalWrite(led, LOW);      
      Serial.println("Turn off the light");  
  }  
  if (cmd_id != 0) {
      Serial.print("cmd_id = ");  
      Serial.println(cmd_id);
  }
  delay(300);
}

Includes

Zuerst binden wir die Header-Datei für die DF2301Q-Bibliothek ein:

#include "DFRobot_DF2301Q.h"

Diese Bibliothek stellt alle notwendigen Funktionen bereit, um das DF2301Q Voice Recognition Module zu initialisieren, zu konfigurieren und zu kommunizieren. Sie übernimmt die I²C-Kommunikation und vereinfacht die Befehls- und Konfigurationsverwaltung.

Konstanten

In der folgenden Zeile definieren wir eine Konstante für den LED-Pin:

const byte led = LED_BUILTIN;

Das LED_BUILTIN Makro bezieht sich auf die eingebaute LED des Entwicklungsboards, die bei den meisten Arduino-Boards typischerweise an Pin 13 angeschlossen ist. Durch die Zuweisung dieses Werts zur led Konstante wird der Code lesbarer und leichter anpassbar, falls du einen anderen LED-Pin verwenden möchtest.

Objekte

Als nächstes wird eine Instanz der DFRobot_DF2301Q_I2C Klasse erstellt, die es dem Arduino ermöglicht, über I2C mit dem Gravity Voice Recognition Module zu kommunizieren:

DFRobot_DF2301Q_I2C asr;

Setup

Die setup() Funktion läuft einmal zu Beginn des Programms und bereitet sowohl den Mikrocontroller als auch das DF2301Q-Modul vor.

void setup() {
  Serial.begin(115200);

  pinMode(led, OUTPUT);    
  digitalWrite(led, HIGH);  

  while (!(asr.begin())) {
    Serial.println("Can't initialize ASR");
    delay(3000);
  }

  asr.setVolume(6);
  asr.setMuteMode(0);  // 1=Mute
  asr.setWakeTime(20);
}

Zuerst initialisieren wir die serielle Kommunikation mit 115200 Baud. So kann der Arduino Diagnosedaten an den Serial Monitor senden. Dann wird der LED-Pin als Ausgang konfiguriert und sein Zustand auf LOW gesetzt, sodass die LED zunächst ausgeschaltet ist.

Das Programm versucht dann, das DF2301Q-Modul mit asr.begin() zu initialisieren. Die Funktion gibt true zurück, wenn das Modul erfolgreich über I2C erkannt wurde. Falls nicht, wird alle 3 Sekunden die Meldung „Kann ASR nicht initialisieren„ ausgegeben, bis die Initialisierung gelingt.

Nach der Initialisierung werden mehrere Konfigurationsbefehle gesendet. Der asr.setVolume(6) setzt die Lautstärke des Lautsprechers bzw. der Erkennung auf Stufe 6 (auf einer Skala von 1 bis 10).

Mit dem asr.setMuteMode(0) Befehl kannst du die Audio-Rückmeldung ein- oder ausschalten. Ein Wert von 0 bedeutet, dass Stummschaltung deaktiviert ist und das Modul erkannte Befehle mit „OK“, „Yes, I am here“ oder „I’m off now“ (beim Verlassen des Weckmodus) bestätigt.

Schließlich definiert asr.setWakeTime(20) die Weckzeit des Moduls, also die Dauer, wie lange es nach Erkennung des Weckworts aktiv bleibt. Die Zahl scheint die Zeit in Sekunden (0 bis 255) anzugeben, aber in der Dokumentation konnte ich keine genauen Angaben finden.

Loop

Die loop() Funktion läuft kontinuierlich nach setup und steuert die Hauptlogik des Programms.

void loop() {
  uint8_t cmd_id = asr.getCMDID();
  if (cmd_id==103) {
      digitalWrite(led, HIGH);      
      Serial.println("Turn on the light");  
  }
  if (cmd_id==104) {
      digitalWrite(led, LOW);      
      Serial.println("Turn off the light");  
  }  
  if (cmd_id != 0) {
      Serial.print("cmd_id = ");  
      Serial.println(cmd_id);
  }
  delay(300);
}

Zu Beginn jeder Schleifeniteration ruft die Funktion asr.getCMDID() die zuletzt erkannte Befehls-ID vom DF2301Q-Modul ab. Jeder erkannte Sprachbefehl ist mit einer eindeutigen numerischen ID verknüpft. Siehe DFRobot Wiki for the Gravity Voice Recognition Module für eine Liste der Befehle und deren IDs.

Wenn die zurückgegebene Befehls-ID 103 entspricht, wird die LED eingeschaltet, indem der Ausgangspin HIGH gesetzt wird, und die Meldung „Turn on the light„ im Serial Monitor ausgegeben.

Wenn die Befehls-ID 104 entspricht, wird die LED ausgeschaltet, indem der Ausgangspin LOW gesetzt wird. Und die Meldung „Turn off the light„ wird ausgegeben.

Der folgende bedingte Block gibt den erkannten cmd_id Wert aus, wann immer er ungleich null ist, was hilft, die empfangenen Befehle zu überwachen.

Abschließend pausiert ein delay(300) die Schleife für 300 Millisekunden, bevor erneut geprüft wird, um Zeit für den nächsten Befehl zu geben.

Code ausführen

Nachdem du den Code auf dein Arduino hochgeladen hast, kannst du die eingebaute LED des Arduino jetzt per Sprache steuern. Starte, indem du „Hello Robot“ sagst, um den Weckmodus zu aktivieren. Die blaue LED am Voice Recognition Modul sollte angehen und das Modul sagt „How, can I help“ oder „Yes, I am here“.

Im Weckmodus kannst du nun „Turn on the light“ oder „Turn off the light“ sagen, um die eingebaute LED ein- oder auszuschalten. Wenn für eine Weile kein Befehl empfangen wird (Weckzeit), verlässt das Modul den Weckmodus und sagt „I’m off now“. Du musst dann wieder „Hello Robot“ sagen, um das Modul zu wecken.

Im Serial Monitor solltest du die Befehls-IDs (2 = Weckwort) und den Text „Turn on the light„ oder „Turn off the light„ sehen:

cmd_id = 2
Turn on the light
cmd_id = 103
Turn off the light
cmd_id = 104

Code-Beispiel: Audio-Rückmeldung steuern

Im nächsten Beispiel schalten wir weiterhin die eingebaute LED ein- oder aus, steuern aber die Audio-Rückmeldung selbst.

Wenn du asr.setMuteMode(1) aufrufst, wird das Modul stummgeschaltet und gibt keine automatische Audio-Rückmeldung mehr. Du kannst jedoch asr.playByCMDID(id) aufrufen, um bestimmte Phrasen wie „How can I help / yes, I am here“ oder „Done“ abzuspielen.

Leider konnte ich keine Dokumentation zu den unterstützten Phrasen und deren IDs finden. Ich habe aber folgende drei nützliche IDs identifiziert:

ID	Phrase(n)
1	How can I help / Yes, I am here
5	Ok, got it / Ok / doing it / done
23	Done

Beachte, dass das Modul bei den IDs 1 und 5 zufällig eine der in der Tabelle gelisteten Phrasen auswählt.

Im folgenden Code-Beispiel schalten wir die automatische Audio-Rückmeldung aus und sagen „Done“, wenn ein Befehl ausgeführt wurde, und „How can I help / Yes, I am here“, wenn das Weckwort erkannt wurde:

#include "DFRobot_DF2301Q.h"

const byte led = LED_BUILTIN;

DFRobot_DF2301Q_I2C asr;

void speak(uint8_t id) {
  asr.setMuteMode(0);
  asr.playByCMDID(id);
  delay(100);
  asr.setMuteMode(1);
}

void setup() {
  Serial.begin(115200);

  pinMode(led, OUTPUT);    
  digitalWrite(led, LOW);  

  while (!(asr.begin())) {
    Serial.println("Can't initialize ASR");
    delay(3000);
  }

  asr.setVolume(6);
  asr.setMuteMode(1);  // 1=Mute
  asr.setWakeTime(20);
}

void loop() {
  uint8_t cmd_id = asr.getCMDID();
  switch (cmd_id) {
    case 2:
      speak(1); // How can I help / yes, I am here
      Serial.println("Waking up");
      break;    
    case 103:
      digitalWrite(led, HIGH);      
      Serial.println("Turn on the light");
      speak(23);  // Done
      break;
    case 104:
      digitalWrite(led, LOW);      
      Serial.println("Turn off the light");
      speak(23); // Done
      break;          
    default:
      if (cmd_id != 0) {
        Serial.print("CMDID = ");  
        Serial.println(cmd_id);
      }
  }
  delay(300);
}

Der Code ist dem vorherigen sehr ähnlich, mit Ausnahme der speak() Funktion. Sie nimmt die ID einer Phrase (z.B. 23 = „Done“), deaktiviert vorübergehend die Stummschaltung, ruft playByCMDID(id) auf, um die Phrase auszusprechen, und schaltet dann die Stummschaltung wieder ein.

void speak(uint8_t id) {
  asr.setMuteMode(0);
  asr.playByCMDID(id);
  delay(100);
  asr.setMuteMode(1);
}

Wenn dir das Voice Recognition Module zu gesprächig ist, kannst du so die Audio-Rückmeldung selbst steuern.

Code-Beispiel: Externe Geräte mit gelernten Befehlen steuern

Im letzten Beispiel steuern wir zwei externe Geräte (rote und grüne LEDs) mit gelernten Befehlen. Statt LEDs könntest du auch Relais anschließen, um leistungsstarke Geräte zu schalten, aber hier verwenden wir LEDs.

Zuerst verkabeln wir die LEDs. Beide LEDs sind mit Masse (GND) verbunden. Die grüne LED wird über GPIO11 und die rote LED über GPIO12 mit einem 220-Ohm-Widerstand angeschlossen. Siehe das Schaltbild unten:

Connecting two LEDs and Gravity module to Arduino UNO — Anschluss von zwei LEDs und Gravity Modul an Arduino UNO

Als nächstes bringen wir die Befehlsphrasen bei, die zum Schalten der LEDs verwendet werden.

Befehlswörter lernen

Ich möchte die folgenden vier Phrasen verwenden, um die rote und grüne LED zu steuern:

„Turn on red light„
„Turn off red light„
„Turn on green light„
„Turn off green light„

Um mit dem Lernen zu beginnen, sage zuerst das Weckwort „Hello Robot“. Dann trittst du in den Lernmodus ein, indem du „Learning command word“ sagst. Das Modul führt dich dann durch den Lernprozess mit folgenden Schritten:

Anzeige: Jetzt lernen, bitte ruhig sein, lerne das Befehlswort gemäß der Aufforderung! Bitte sage den ersten zu lernenden Befehl!
Zu lernende Befehlsphrase: „Turn on red light„
Anzeige: Lernen erfolgreich, bitte wiederhole es!
Zu lernende Befehlsphrase : „Turn on red light„
Anzeige: Lernen erfolgreich, bitte wiederhole es!
Zu lernende Befehlsphrase : „Turn on red light„
Anzeige: OK, erster Befehl erfolgreich gelernt! Bitte sage den zweiten zu lernenden Befehl!
…

Du kannst den Lernmodus verlassen, indem du „Exit learning“ sagst.

Code

Wenn das Lernen der vier neuen Befehlsphrasen erfolgreich war, kannst du die rote und grüne LED mit folgendem Code steuern:

#include "DFRobot_DF2301Q.h"

const byte redLed = 12;
const byte greenLed = 11;

DFRobot_DF2301Q_I2C asr;

void setup() {
  Serial.begin(115200);

  pinMode(redLed, OUTPUT);
  digitalWrite(redLed, LOW);
  pinMode(greenLed, OUTPUT);
  digitalWrite(greenLed, LOW);

  while (!(asr.begin())) {
    Serial.println("Can't initialize ASR");
    delay(3000);
  }

  asr.setVolume(6);
  asr.setMuteMode(0);  // 1=Mute
  asr.setWakeTime(20);
}

void loop() {
  uint8_t cmd_id = asr.getCMDID();
  switch (cmd_id) {
    case 5:  // Turn on red light
      digitalWrite(redLed, HIGH);
      break;
    case 6:  // Turn off red light
      digitalWrite(redLed, LOW);
      break;
    case 7:  // Turn on green light
      digitalWrite(greenLed, HIGH);
      break;
    case 8:  // Turn off green light
      digitalWrite(greenLed, LOW);
      break;
  }
  if (cmd_id != 0) {
    Serial.print("CMDID = ");
    Serial.println(cmd_id);
  }
  delay(300);
}

Der Code ähnelt wieder den vorherigen Beispielen. Der einzige Unterschied liegt in der Hauptfunktion, wo wir jetzt auf die Befehls-IDs 5, 6, 7 und 8 prüfen, die den gelernten Befehlen entsprechen:

void loop() {
  uint8_t cmd_id = asr.getCMDID();
  switch (cmd_id) {
    case 5:  // Turn on red light
      digitalWrite(redLed, HIGH);
      break;
    case 6:  // Turn off red light
      digitalWrite(redLed, LOW);
      break;
    case 7:  // Turn on green light
      digitalWrite(greenLed, HIGH);
      break;
    case 8:  // Turn off green light
      digitalWrite(greenLed, LOW);
      break;
  }
  if (cmd_id != 0) {
    Serial.print("CMDID = ");
    Serial.println(cmd_id);
  }
  delay(300);
}

Wenn du bereits andere Befehlsphrasen gelernt hast oder in anderer Reihenfolge trainiert hast, werden deine IDs anders sein. Der Code gibt die erkannte Phrase-ID aus, sodass du deinen Code entsprechend anpassen kannst.

Natürlich kannst du auch gelernte Phrasen löschen oder ein neues Weckwort lernen. Details findest du im Wiki Gravity Voice Recognition Module. Die folgende Tabelle gibt dir einen Überblick über wichtige Steuerphrasen zum Lernen, Bearbeiten und Löschen:

Befehl	Funktion
Hello Robot	Standard-Weckwort des Systems.
Learning wake word	Ändert das Weckwort.
Learning command word	Bringt dem Modul einen neuen Befehl bei.
Re-learn	Ersetzt einen Befehl durch einen anderen.
Exit learning	Sagt man, um den Lernmodus zu verlassen.
I want to delete	Wechselt in den Löschmodus.
Delete wake word	Löscht das gelernte Weckwort.
Delete command word	Entfernt eine zuvor gelernte Befehlsphrase.
Delete all	Löscht alle Befehle und Phrasen aus dem Speicher.
Exit deleting	Verlässt den Löschmodus

Und das war’s! Nun hast du drei Beispiele, die dir beim Gravity Voice Recognition Module helfen sollten.

Fazit

Dieses Tutorial hat dir Code-Beispiele gegeben, um mit dem Gravity Voice Recognition Module zu starten. Für eine vollständige Liste der vorprogrammierten Sprachbefehle und wie man das Modul trainiert, siehe Wiki.

Das Gravity Voice Recognition Module macht den Einstieg in die Spracherkennung sehr einfach. Einfach das Modul an einen Mikrocontroller anschließen, etwas minimalen Code schreiben und loslegen.

Das Lernen neuer Befehle und Weckwörter erfolgt ebenfalls komplett per Sprachsteuerung. Das macht es einfach, neue Befehle hinzuzufügen, aber das Löschen oder Bearbeiten von Befehlen kann umständlich sein.

Außerdem ist die Erkennungsgenauigkeit der vorprogrammierten Sprachbefehle hoch, die der gelernten Befehle scheint jedoch deutlich niedriger zu sein. Ich hatte Schwierigkeiten, das System zuverlässig Befehle wie „Turn on the red light“ erkennen zu lassen, die oft als „Turn on the light“ fehlinterpretiert wurden.

Eine Alternative zum Gravity Voice Recognition Module könnte das Voice Recognition Module V3 sein. Es hat keine vorprogrammierten Phrasen, kann aber 80 Wörter lernen und erlaubt programmatische Steuerung der gelernten Wörter. Allerdings ist es schwieriger einzurichten und ich empfinde die Erkennungsgenauigkeit als geringer.

Wenn du wirklich hohe Erkennungsgenauigkeit willst, könntest du Voice control with XIAO-ESP32-S3-Sense and Edge Impulse ausprobieren. Hier kannst du die Spracherkennung komplett selbst trainieren, was bessere Erkennungsraten bringen kann, aber auch deutlich komplexer und aufwändiger ist!

Wenn du Fragen hast, hinterlasse sie gerne im Kommentarbereich.

Viel Spaß beim Tüfteln 😉

Stefan Maetschke