L’interaction vocale prend une place de plus en plus centrale dans les systèmes embarqués modernes, la robotique et les objets connectés. Le Gravity Voice Recognition Module de DFRobot fournit un module compact, capable de fonctionner hors ligne, conçu pour les makers et développeurs travaillant avec des plateformes telles que Arduino, micro:bit et ESP32. Ce module prend en charge à la fois la communication I²C et UART, intègre 121 commandes vocales préprogrammées et permet d’entraîner localement jusqu’à 17 phrases personnalisées — le tout sans nécessiter de connexion Internet.
Dans ce guide, nous passerons en revue les fonctionnalités clés du module, préparerons le matériel et le logiciel nécessaires, puis montrerons comment intégrer le module dans un projet simple commandé par la voix. Que votre objectif soit un système d’éclairage activé par la voix, un assistant robotique ou une routine d’automatisation déclenchée vocalement, cet article servira de point de départ pratique pour mettre en service le Gravity Voice Recognition Module sous votre propre contrôle.
Où acheter
Vous pouvez vous procurer le Gravity Voice Recognition Module chez DFRobot ou sur Amazon. Le lien ci‑dessous pointe vers le produit sur Amazon. De plus, il vous faudra un microcontrôleur. J’utilise un Arduino UNO mais la plupart des microcontrôleurs courants (par ex. ESP32, ESP8266, …) fonctionneront également. Et si vous voulez essayer quelques projets, une breadboard et des câbles seront utiles.
Gravity Voice Recognition Module
Arduino Uno
USB Cable for Arduino UNO
Dupont Wire Set
Breadboard
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.
Matériel du Gravity Voice Recognition Module
Le Gravity Voice Recognition Module de DFRobot est une unité de traitement vocal compacte et autonome qui permet le contrôle vocal hors ligne pour les systèmes embarqués. Au cœur du module se trouve une puce de reconnaissance vocale puissante capable d’analyser localement les commandes sans dépendre de services cloud. Cela permet des réponses rapides, une faible latence et une indépendance complète vis‑à‑vis de la connectivité réseau.
Composants
Le module contient un petit haut‑parleur intégré et un connecteur pour un haut‑parleur externe (8 Ω 3W). Un petit interrupteur permet de basculer entre les deux haut‑parleurs. Un second interrupteur permet de sélectionner la communication I2C ou UART avec le module.
De plus, la carte comporte deux microphones et deux LED d’indication. Une LED (rouge) indique l’alimentation et l’autre LED (bleue) signale que le mot d’activation a été reconnu et que le module est prêt à recevoir des commandes vocales. La photo ci‑dessous montre les composants du module :
Versions
Notez qu’il existe deux versions du module : Version 1.0 et Version 1.1. La version plus ancienne 1.0 ne possède pas de connecteur pour le haut‑parleur embarqué ni deux trous de fixation. Sinon, le matériel et la programmation sont identiques. La photo ci‑dessous montre les deux versions du module :
Alimentation
Le module fonctionne dans une plage de tension typique de3.3V à 5V, garantissant la compatibilité avec les systèmes logiques 3.3V (tels que ESP32 et Raspberry Pi Pico) et les systèmes 5V (tels que Arduino Uno). Le format compact (49 mm × 32 mm) le rend adapté à l’intégration dans des boîtiers à espace restreint.
Commandes
Le module comporte 121 commandes préprogrammées, comme « Turn the light on », qui ne peuvent pas être modifiées. Il y a aussi un mot d’activation fixe (« Hello Robot »). Il existe 17 emplacements pour des commandes apprenables et un emplacement pour un mot d’activation pouvant être appris. Pour la liste complète des commandes préprogrammées, voir le DFRobot Wiki for the Gravity Voice Recognition Module.
Le module se réveille lorsque le mot d’activation est reconnu, reste ensuite actif pendant une durée programmable et, pendant ce laps de temps, est prêt à détecter des commandes vocales.
Caractéristiques techniques
| Paramètre | Spécification |
|---|---|
| Nom du produit | Gravity Voice Recognition Module |
| Tension d’alimentation | 3.3 V – 5 V |
| Interface de communication | I²C and UART (selectable) |
| Adresse I2C | 0x64 |
| Mode de reconnaissance | Reconnaissance vocale hors ligne |
| Commandes intégrées | 121 préprogrammées |
| Commandes personnalisées | Jusqu’à 17 personnalisées |
| Commande d’activation d’apprentissage | 1 |
| Microphone | 2 x intégrés |
| Sensibilité du microphone | -28dB |
| Haut‑parleur | Intégré, avec haut‑parleur externe optionnel |
| Courant de fonctionnement | ≤ 370 mA @ 5V |
| Température de fonctionnement | 0 °C à +70 °C |
| Dimensions | 49 mm × 32 mm |
| Port | Gravity 4-pin interface (VCC, GND, SDA/RX, SCL/TX) |
Raccordement du Gravity Voice Recognition Module à un Arduino UNO
Brancher le Gravity Voice Recognition Module à un Arduino UNO est simple. Reliez le GND du Gravity Module au GND de l’Arduino et le VCC au 5V.
Ensuite, connectez l’interface I2C. La ligne SCL sur la broche A5 de l’Arduino doit être reliée à la broche C/R du Gravity Module (fil vert). Enfin, connectez SDA (A4) de l’Arduino au D/T du Gravity Module. L’image ci‑dessous montre le câblage complet :
Dans la section suivante, nous écrirons du code pour essayer le Voice Recognition Module.
Installer la bibliothèque pour le Gravity Voice Recognition Module
Avant de pouvoir utiliser le Gravity Voice Recognition Module avec un Arduino ou un ESP32, nous devons d’abord installer le DFRobot_DF2301Q Library dans l’Arduino IDE. Ouvrez simplement le LIBRARY MANAGER, saisissez DFRobot_DF2301Q dans la barre de recherche et appuyez sur INSTALL :
Exemple de code : Allumer/éteindre la LED embarquée
Dans ce premier exemple de code, nous allons commander la LED embarquée de l’Arduino UNO pour l’allumer ou l’éteindre en utilisant lepre-programmed voice commands« Turn on the light » et « Turn off the light ». Puisque nous utilisons les commandes préprogrammées, aucun apprentissage ni préparation supplémentaire du Voice Recognition Module n’est nécessaire ici. Jetez d’abord un coup d’œil au code, puis nous en discuterons en détail.
#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);
}
Imports
Tout d’abord, nous incluons le fichier d’en‑tête de la bibliothèque DF2301Q :
#include "DFRobot_DF2301Q.h"
Cette bibliothèque fournit toutes les fonctions nécessaires pour initialiser, configurer et communiquer avec le module de reconnaissance vocale DF2301Q. Elle gère la communication I²C et simplifie la reconnaissance de commandes ainsi que la gestion de la configuration.
Constantes
Dans la ligne suivante, nous définissons une constante pour la broche de la LED :
const byte led = LED_BUILTIN;
Le LED_BUILTIN macro fait référence à la LED embarquée de la carte de développement, généralement connectée à la broche 13 sur la plupart des cartes Arduino. En affectant cette valeur à la led constante, le code devient plus lisible et plus facile à adapter si vous souhaitez utiliser une broche LED différente.
Objets
Ensuite, une instance de la DFRobot_DF2301Q_I2C est créée, ce qui permet à l’Arduino de communiquer avec le Gravity Voice Recognition Module via I2C :
DFRobot_DF2301Q_I2C asr;
Setup
La setup() fonction s’exécute une fois au début du programme et prépare à la fois le microcontrôleur et le module DF2301Q.
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);
}
Tout d’abord, nous initialisons la communication série à 115200 bauds. Cela permet à l’Arduino d’envoyer des informations de diagnostic au Moniteur Série. Ensuite, la broche de la LED est configurée en sortie et son état est défini sur LOW, garantissant que la LED est initialement éteinte.
Le programme tente ensuite d’initialiser le module DF2301Q en utilisant asr.begin(). La fonction retourne true si le module est détecté avec succès via I2C. Sinon, le message « Can’t initialize ASR« est affiché toutes les 3 secondes jusqu’à ce que l’initialisation réussisse.
Après l’initialisation, plusieurs commandes de configuration sont envoyées. Le asr.setVolume(6) règle le volume du haut‑parleur ou de la reconnaissance au niveau 6 (sur une échelle de 1 à 10).
Avec la commande asr.setMuteMode(0) vous pouvez activer ou désactiver le retour audio. Une valeur de 0 signifie que le mode muet est désactivé et que le module confirmera les commandes reconnues par « OK », « Yes, I am here », ou « I’m off now » en quittant le mode d’activation.
Enfin, asr.setWakeTime(20) définit le temps de réveil du module, c’est‑à‑dire la durée pendant laquelle il reste actif après avoir détecté le mot d’activation. Le nombre semble être le temps en secondes (allant de 0 à 255) mais je n’ai pas trouvé d’information précise dans la documentation.
Loop
La loop() fonction s’exécute en continu après le setup et gère la logique principale du programme.
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);
}
Au début de chaque itération de loop, la fonction asr.getCMDID() récupère l’ID de commande le plus récent reconnu par le module DF2301Q. Chaque commande vocale reconnue est associée à un ID numérique unique. Voir le DFRobot Wiki for the Gravity Voice Recognition Module pour la liste des commandes et leurs IDs.
Si l’ID de commande retourné est égal à 103, la LED est allumée en réglant la broche de sortie HIGH, et le message « Turn on the light« est affiché dans le Moniteur Série.
Si l’ID de commande est égal à 104, la LED est éteinte en réglant la broche de sortie LOW. Et le message « Turn off the light« est affiché.
Le bloc conditionnel suivant affiche la valeur cmd_id détectée chaque fois qu’elle est non nulle, ce qui aide à surveiller les commandes reçues.
Enfin, un delay(300) met le loop en pause pendant 300 millisecondes avant de vérifier à nouveau, laissant le temps à la prochaine commande d’être reconnue.
Exécution du code
Après avoir téléversé le code sur votre Arduino, vous pouvez désormais contrôler la LED embarquée de l’Arduino à la voix. Commencez par dire « Hello Robot » pour activer le mode d’activation. La LED bleue du module de reconnaissance vocale devrait s’allumer, et le module dira « How, can I help » ou « Yes, I am here ».
Une fois en mode d’activation, vous pouvez dire « Turn on the light » ou « Turn off the light » pour allumer ou éteindre la LED embarquée. Si aucune commande n’est reçue pendant un certain temps (wake time), le module quitte le mode d’activation et dit « I’m off now ». Vous devrez dire « Hello Robot » à nouveau pour réveiller le module.
Dans le Moniteur Série, vous devriez voir les IDs de commande (2 = wake‑up) et le texte« Turn on the light« ou « Turn off the light« affichés.
cmd_id = 2 Turn on the light cmd_id = 103 Turn off the light cmd_id = 104
Exemple de code : Contrôler le retour audio
Dans cet exemple suivant, nous allumons toujours la LED embarquée ou l’éteignons, mais nous contrôlerons nous‑mêmes le retour audio.
Si vous appelez asr.setMuteMode(1), le module est mis en sourdine et ne fournit pas de retour audio automatiquement. Cependant, vous pouvez appeler asr.playByCMDID(id) pour jouer certaines phrases telles que « How can I help / yes, I am here » ou « Done ».
Malheureusement, je n’ai pas trouvé de documentation sur les phrases supportées et leurs IDs. Mais j’ai identifié les trois IDs utiles suivants :
| id | phrase(s) |
|---|---|
| 1 | How can I help / Yes, I am here |
| 5 | Ok, got it / Ok / doing it / done |
| 23 | Done |
Notez que pour les IDs 1 et 5, le module choisit aléatoirement une des phrases listées dans le tableau.
Dans l’exemple de code suivant, nous désactivons le retour audio automatique, disons « Done » lorsqu’une commande a été exécutée, et « How can I help / Yes, I am here » lorsque le mot d’activation est détecté :
#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);
}
Le code est très similaire au précédent, à l’exception de la fonction speak(). Elle prend l’ID d’une phrase (par ex. 23 = « Done »), désactive temporairement la sourdine, appelle playByCMDID(id) pour prononcer la phrase, puis remet le module en sourdine.
void speak(uint8_t id) {
asr.setMuteMode(0);
asr.playByCMDID(id);
delay(100);
asr.setMuteMode(1);
}
Ainsi, si le Voice Recognition Module est un peu trop bavard pour vous, cela vous permet de contrôler vous‑même le retour audio.
Exemple de code : Contrôler des périphériques externes avec des commandes apprises
Dans ce dernier exemple, nous contrôlerons deux périphériques externes (LED rouge et verte) en utilisant des commandes apprises. À la place des LED, vous pourriez connecter des relais pour commuter des appareils de forte puissance, mais pour cet exemple nous utilisons des LED.
Commençons par câbler les LED. Les deux LED sont reliées à la masse (GND). La LED verte sera connectée au GPIO11 et la LED rouge au GPIO12 via une résistance de 220 ohms. Voir le schéma de câblage ci‑dessous :
Ensuite, nous enseignons les phrases de commande à utiliser pour l’allumage des LED.
Apprentissage des mots de commande
Je souhaite utiliser les quatre phrases suivantes pour contrôler la LED rouge et la LED verte :
- « Turn on red light«
- « Turn off red light«
- « Turn on green light«
- « Turn off green light«
Pour commencer l’apprentissage, dites d’abord le mot d’activation « Hello Robot« . Ensuite, entrez en mode apprentissage en disant « Learning command word« . Le module vous guidera alors à travers le processus d’apprentissage avec les étapes suivantes :
- Indication : Learning now, be quiet, please learn the command word according to the prompt! Please say the first command to be learned!
- Phrase à apprendre : « Turn on red light«
- Indication : Learning successful, please say it again!
- Phrase à apprendre : « Turn on red light«
- Indication : Learning successful, please say it again!
- Phrase à apprendre : « Turn on red light«
- Indication : OK, learned the first command successfully! Please say the second command to be learned!
- …
Vous pouvez quitter le mode apprentissage en disant « Exit learning« .
Code
Si l’apprentissage des quatre nouvelles phrases de commande a réussi, vous pouvez alors contrôler les LED rouge et verte à l’aide du code suivant :
#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);
}
Encore une fois, le code est similaire aux exemples précédents. La seule différence se situe dans la fonction principale, où nous vérifions maintenant les IDs de commande 5, 6, 7 et 8 qui correspondent aux commandes apprises :
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);
}
Si vous avez déjà appris d’autres phrases de commande ou si vous les avez entraînées dans un ordre différent, vos IDs seront différents. Cependant, le code affiche l’ID de la phrase reconnue et vous pouvez adapter votre code en conséquence.
Évidemment, vous pouvez aussi supprimer des phrases apprises ou apprendre un nouveau mot d’activation. Pour les détails, voir le Wiki Gravity Voice Recognition Module. Le tableau suivant vous donne un aperçu des phrases de contrôle importantes pour l’apprentissage, la modification et la suppression :
| Commande | Fonction |
| Hello Robot | Mot d’activation système par défaut. |
| Learning wake word | Permet de changer le mot d’activation. |
| Learning command word | Enseigne une nouvelle commande. |
| Re-learn | Remplace une commande par une autre. |
| Exit learning | Dites ceci pour quitter le mode apprentissage. |
| I want to delete | Permet d’entrer dans la fonction de suppression. |
| Delete wake word | Efface le mot d’activation appris. |
| Delete command word | Supprime une phrase de commande précédemment acquise. |
| Delete all | Supprime toutes les commandes et phrases de la mémoire. |
| Exit deleting | Quitte la fonction de suppression |
Et voilà ! Vous disposez maintenant de trois exemples qui devraient vous aider avec le Gravity Voice Recognition Module.
Conclusions
Ce tutoriel vous a fourni des exemples de code pour démarrer avec le Gravity Voice Recognition Module. Pour la liste complète des commandes vocales préprogrammées et la procédure d’entraînement du module, voir leWiki.
Le Gravity Voice Recognition Module facilite grandement la prise en main de la reconnaissance vocale. Il suffit de connecter le module à un microcontrôleur, d’écrire un peu de code minimal et vous êtes prêt à l’emploi.
L’apprentissage de nouvelles commandes et de mots d’activation se fait également entièrement par commande vocale. Cela rend l’ajout de nouvelles commandes simple, mais la suppression ou la modification des commandes peut s’avérer fastidieuse.
Par ailleurs, si la précision de reconnaissance des commandes préprogrammées est élevée, la précision pour les commandes apprises semble nettement inférieure. J’ai eu des difficultés à obtenir une reconnaissance fiable pour des commandes comme « Turn on the red light », qui étaient souvent confondues avec « Turn on the light ».
Une alternative au Gravity Voice Recognition Module pourrait être le Voice Recognition Module V3. Il n’a pas de phrases préprogrammées mais peut apprendre 80 mots et permet un contrôle programmatique des mots appris. Cependant, il est plus difficile à configurer et j’ai l’impression que la précision de reconnaissance est moindre.
Si vous recherchez vraiment une grande précision de reconnaissance, vous pourriez essayer Voice control with XIAO-ESP32-S3-Sense and Edge Impulse. Dans ce cas, vous pouvez entraîner entièrement la reconnaissance vocale vous‑même, ce qui peut améliorer la précision mais c’est aussi beaucoup plus complexe et travailleur !
Si vous avez des questions, n’hésitez pas à les laisser dans la section des commentaires.
Bon bricolage 😉
