L’interazione abilitata alla voce è sempre più centrale nei moderni sistemi embedded, nella robotica e nei dispositivi smart. Gravity Voice Recognition Module Il modulo Gravity Voice Recognition di DFRobot offre un modulo compatto, capace di funzionare offline, progettato per maker e sviluppatori che lavorano con piattaforme come Arduino, micro:bit ed ESP32. Questo modulo supporta sia la comunicazione I²C che UART, dispone di 121 comandi vocali pre-programmati e consente di addestrare fino a 17 frasi personalizzate localmente — tutto senza necessità di una connessione internet.
In questa guida esploreremo le caratteristiche principali del modulo, prepareremo l’hardware e il software necessari, e poi mostreremo come integrare il modulo in un semplice progetto controllato a voce. Che il tuo obiettivo sia un sistema di illuminazione attivato vocalmente, un assistente robotico o una routine di automazione attivata dalla voce, questo articolo sarà un punto di partenza pratico per far funzionare il Gravity Voice Recognition Module sotto il tuo controllo.
Dove Acquistare
Puoi acquistare il Gravity Voice Recognition Module su DFRobot o Amazon. Il link qui sotto è per il prodotto su Amazon. Inoltre, ti servirà un microcontrollore. Io uso un Arduino UNO ma la maggior parte dei microcontrollori comuni (es. ESP32, ESP8266, …) funzionerà altrettanto bene. E se vuoi provare qualche progetto, una breadboard e qualche cavo ti saranno utili.
Gravity Voice Recognition Module
Arduino Uno
Cavo USB per Arduino UNO
Set di fili Dupont
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.
Hardware del Gravity Voice Recognition Module
Il Gravity Voice Recognition Module di DFRobot è un’unità compatta e autonoma per l’elaborazione vocale che abilita il controllo vocale offline per sistemi embedded. Al suo interno integra un potente chip di riconoscimento vocale capace di analizzare comandi localmente senza dipendere da servizi cloud. Questo garantisce risposte rapide, bassa latenza e completa indipendenza dalla connettività di rete.
Componenti
Il modulo contiene un piccolo altoparlante integrato e un connettore per un altoparlante esterno (8 Ω 3W). Un piccolo interruttore permette di selezionare tra i due altoparlanti. Un secondo interruttore consente di scegliere tra comunicazione I2C e UART con il modulo.
Inoltre, sulla scheda ci sono due microfoni e due LED indicatori. Un LED (rosso) indica l’alimentazione, mentre l’altro (blu) segnala che la parola di attivazione è stata riconosciuta e che il modulo è pronto a ricevere comandi vocali. L’immagine sottostante mostra i componenti del modulo:
Versioni
Nota che esistono due versioni del modulo: Versione 1.0 e Versione 1.1. La versione più vecchia 1.0 non ha il connettore per l’altoparlante integrato né i due fori di montaggio. Per il resto, hardware e programmazione sono identici. La foto sottostante mostra le due versioni del modulo:
Alimentazione
Il modulo opera in un tipico intervallo di tensione di3.3V a 5V, garantendo compatibilità sia con sistemi a logica 3.3V (come ESP32 e Raspberry Pi Pico) sia con sistemi a 5V (come Arduino Uno). Il formato compatto (49 mm × 32 mm) lo rende adatto all’integrazione in contenitori con spazio limitato.
Comandi
Il modulo dispone di 121 comandi pre-programmati, come “Accendi la luce”, che non possono essere modificati. C’è anche una parola di attivazione (“Hello Robot”) fissa. Sono disponibili 17 slot per comandi personalizzati da apprendere e uno slot per una parola di attivazione personalizzabile. Per la lista completa dei comandi pre-programmati vedi il DFRobot Wiki for the Gravity Voice Recognition Module.
Il modulo si attiva quando viene riconosciuta la parola di attivazione, rimane attivo per un tempo programmabile e durante questo periodo è pronto a rilevare comandi vocali.
Specifiche Tecniche
| Parametro | Specifiche |
|---|---|
| Nome Prodotto | Gravity Voice Recognition Module |
| Tensione di Alimentazione | 3.3 V – 5 V |
| Interfaccia di Comunicazione | I²C e UART (selezionabile) |
| Indirizzo I2C | 0x64 |
| Modalità di Riconoscimento | Riconoscimento vocale offline |
| Comandi Integrati | 121 pre-programmati |
| Comandi Personalizzati | Fino a 17 definiti dall’utente |
| Comando di Attivazione per Apprendimento | 1 |
| Microfono | 2 x integrati |
| Sensibilità Microfono | -28dB |
| Altoparlante | Integrato, con altoparlante esterno opzionale |
| Corrente di Funzionamento | ≤ 370 mA @ 5V |
| Temperatura di Funzionamento | 0 °C a +70 °C |
| Dimensioni | 49 mm × 32 mm |
| Porta | Interfaccia Gravity a 4 pin (VCC, GND, SDA/RX, SCL/TX) |
Collegare il Voice Recognition Module a un Arduino UNO
Collegare il Gravity Voice Recognition Module a un Arduino UNO è semplice. Collega GND del modulo Gravity a GND dell’Arduino e VCC a 5V.
Successivamente colleghiamo l’interfaccia I2C. La linea SCL al pin A5 dell’Arduino deve essere collegata al pin C/R del modulo Gravity (filo verde). Infine, colleghiamo SDA (A4) dall’Arduino a D/T del modulo Gravity. L’immagine sottostante mostra il cablaggio completo:
Nella sezione successiva scriveremo del codice per provare il Voice Recognition Module.
Installare la Libreria per Gravity Voice Recognition Module
Prima di poter usare il Gravity Voice Recognition Module con Arduino o ESP32 dobbiamo prima installare la DFRobot_DF2301Q Library nell’IDE Arduino. Basta aprire il LIBRARY MANAGER, inserire DFRobot_DF2301Q nella barra di ricerca e premere INSTALL:
Esempio di Codice: Accendere o Spegnere il LED integrato
In questo primo esempio di codice accenderemo o spegneremo il LED integrato dell’Arduino UNO usando i comandi pre-programmed voice commands “Accendi la luce” e “Spegni la luce”. Poiché usiamo i comandi pre-programmati, non è necessario alcun apprendimento o altra preparazione del Voice Recognition Module. Dai un’occhiata veloce al codice e poi ne discuteremo i dettagli.
#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);
}
Importazioni
Per prima cosa includiamo il file header della libreria DF2301Q:
#include "DFRobot_DF2301Q.h"
Questa libreria fornisce tutte le funzioni necessarie per inizializzare, configurare e comunicare con il modulo di riconoscimento vocale DF2301Q. Gestisce la comunicazione I²C e semplifica il riconoscimento dei comandi e la gestione della configurazione.
Costanti
Nella riga seguente definiamo una costante per il pin del LED:
const byte led = LED_BUILTIN;
La macro LED_BUILTIN si riferisce al LED integrato della scheda di sviluppo, tipicamente collegato al pin 13 sulla maggior parte delle schede Arduino. Assegnando questo valore alla costante led, il codice diventa più leggibile e più facile da adattare se vuoi usare un pin LED diverso.
Oggetti
Successivamente viene creata un’istanza della classe DFRobot_DF2301Q_I2C, che permette all’Arduino di comunicare con il Gravity Voice Recognition Module tramite I2C:
DFRobot_DF2301Q_I2C asr;
Setup
La funzione setup() viene eseguita una volta all’inizio del programma e prepara sia il microcontrollore che il modulo 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);
}
Per prima cosa inizializziamo la comunicazione seriale a 115200 baud. Questo permette all’Arduino di inviare informazioni diagnostiche al Monitor Seriale. Poi configuriamo il pin del LED come output e impostiamo il suo stato a LOW, assicurandoci che il LED sia spento all’inizio.
Il programma tenta quindi di inizializzare il modulo DF2301Q usando asr.begin(). La funzione restituisce true se il modulo viene rilevato correttamente via I2C. In caso contrario, il messaggio “Impossibile inizializzare ASR“ viene stampato ogni 3 secondi finché l’inizializzazione non ha successo.
Dopo l’inizializzazione, vengono inviati diversi comandi di configurazione. Il asr.setVolume(6) imposta il volume dell’altoparlante o del riconoscimento al livello 6 (su una scala da 1 a 10).
Con il comando asr.setMuteMode(0) puoi abilitare o disabilitare il feedback audio. Un valore di 0 significa che il silenziamento è disabilitato e il modulo confermerà i comandi riconosciuti con “OK”, “Sì, sono qui” o “Ora sono spento”, quando esce dalla modalità di attivazione.
Infine, asr.setWakeTime(20) definisce il tempo di attivazione del modulo, ovvero la durata in cui rimane attivo dopo aver rilevato la parola di attivazione. Il valore sembra indicare il tempo in secondi (da 0 a 255) ma non ho trovato informazioni specifiche nella documentazione.
Loop
La funzione loop() viene eseguita continuamente dopo il setup e gestisce la logica principale del programma.
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);
}
All’inizio di ogni iterazione del loop, la funzione asr.getCMDID() recupera l’ultimo ID comando riconosciuto dal modulo DF2301Q. Ogni comando vocale riconosciuto è associato a un ID numerico univoco. Vedi il DFRobot Wiki for the Gravity Voice Recognition Module per una lista dei comandi e dei loro ID.
Se l’ID comando restituito è uguale a 103, il LED viene acceso impostando il pin di output HIGH, e il messaggio “Accendi la luce“ viene stampato sul Monitor Seriale.
Se l’ID comando è uguale a 104, il LED viene spento impostando il pin di output LOW. E viene stampato il messaggio “Spegni la luce“.
Il blocco condizionale seguente stampa il valore cmd_id rilevato ogni volta che è diverso da zero, aiutando a monitorare i comandi ricevuti.
Infine, un delay(300) mette in pausa il loop per 300 millisecondi prima di ricontrollare, dando tempo al modulo di riconoscere il prossimo comando.
Esecuzione del Codice
Dopo aver caricato il codice sul tuo Arduino puoi ora controllare il LED integrato con la voce. Inizia dicendo “Hello Robot” per attivare la modalità di attivazione. Il LED blu sul modulo Voice Recognition dovrebbe accendersi e il modulo dirà “Come posso aiutarti” o “Sì, sono qui”.
Mentre sei in modalità attivazione puoi dire “Accendi la luce” o “Spegni la luce” per accendere o spegnere il LED integrato. Se non viene ricevuto alcun comando per un po’ (tempo di attivazione), il modulo esce dalla modalità attivazione e dice “Ora sono spento”. Dovrai dire di nuovo “Hello Robot” per riattivare il modulo.
Sul Monitor Seriale dovresti vedere gli ID dei comandi (2 = attivazione) e il testo “Accendi la luce“ o “Spegni la luce“ stampati:
cmd_id = 2 Turn on the light cmd_id = 103 Turn off the light cmd_id = 104
Esempio di Codice: Controllare il Feedback Audio
In questo esempio successivo, continueremo a accendere o spegnere il LED integrato ma controlleremo noi stessi il feedback audio.
Se chiami asr.setMuteMode(1), il modulo viene silenziato e non fornisce feedback audio automaticamente. Tuttavia, puoi chiamare asr.playByCMDID(id) per riprodurre certe frasi come “Come posso aiutarti / sì, sono qui” o “Fatto”.
Purtroppo non ho trovato documentazione sulle frasi supportate e i loro ID. Ma ho identificato i seguenti tre ID utili:
| id | frase(e) |
|---|---|
| 1 | Come posso aiutarti / Sì, sono qui |
| 5 | Ok, capito / Ok / sto facendo / fatto |
| 23 | Fatto |
Nota che per gli ID 1 e 5 il modulo sceglie casualmente una delle frasi elencate nella tabella.
Nel codice seguente disattiviamo il feedback audio automatico, diciamo “Fatto” quando un comando è eseguito, e “Come posso aiutarti / Sì, sono qui” quando viene rilevata la parola di attivazione:
#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);
}
Il codice è molto simile a quello precedente, con l’eccezione della funzione speak(). Essa prende l’ID di una frase (es. 23 = “Fatto”), disabilita temporaneamente il silenziamento, chiama playByCMDID(id) per pronunciare la frase e poi riattiva il silenziamento.
void speak(uint8_t id) {
asr.setMuteMode(0);
asr.playByCMDID(id);
delay(100);
asr.setMuteMode(1);
}
Quindi, se il Voice Recognition Module ti sembra un po’ troppo loquace, questo ti permette di controllare tu stesso il feedback audio.
Esempio di Codice: Controllare Dispositivi Esterni con Comandi Apprendibili
In questo ultimo esempio controlleremo due dispositivi esterni (LED rossi e verdi) usando comandi appresi. Al posto dei LED potresti collegare relè per commutare dispositivi ad alta potenza, ma per questo esempio usiamo LED.
Per prima cosa colleghiamo i LED. Entrambi i LED sono collegati a massa (GND). Il LED verde sarà collegato a GPIO11 e il LED rosso a GPIO12 tramite una resistenza da 220 Ohm. Vedi lo schema di cablaggio sotto:
Ora insegniamo le frasi di comando da usare per accendere e spegnere i LED.
Apprendimento delle parole di comando
Voglio usare le seguenti quattro frasi per controllare il LED rosso e quello verde:
- “Accendi la luce rossa“
- “Spegni la luce rossa“
- “Accendi la luce verde“
- “Spegni la luce verde“
Per iniziare l’apprendimento, prima pronuncia la parola di attivazione “Hello Robot“. Poi entra in modalità apprendimento dicendo “Apprendimento parola di comando“. Il modulo ti guiderà nel processo di apprendimento con i seguenti passaggi:
- Indicazione: Sto imparando, stai zitto, per favore impara la parola di comando secondo il prompt! Per favore pronuncia il primo comando da imparare!
- Frase di comando da imparare: “Accendi la luce rossa“
- Indicazione: Apprendimento riuscito, per favore ripeti!
- Frase di comando da imparare : “Accendi la luce rossa“
- Indicazione: Apprendimento riuscito, per favore ripeti!
- Frase di comando da imparare : “Accendi la luce rossa“
- Indicazione: OK, primo comando imparato con successo! Per favore pronuncia il secondo comando da imparare!
- …
Puoi uscire dalla modalità apprendimento dicendo “Esci dall’apprendimento“.
Codice
Se l’apprendimento delle quattro nuove frasi di comando è andato a buon fine, puoi controllare i LED rosso e verde usando il seguente codice:
#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);
}
Anche in questo caso il codice è simile agli esempi precedenti. L’unica differenza è nella funzione principale, dove ora controlliamo gli ID comando 5, 6, 7 e 8 che corrispondono ai comandi appresi:
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);
}
Se hai già imparato altre frasi di comando o le hai addestrate in ordine diverso, i tuoi ID saranno differenti. Tuttavia, il codice stampa l’ID della frase riconosciuta e puoi modificare il codice di conseguenza.
Ovviamente puoi anche cancellare frasi apprese o imparare una nuova parola di attivazione. Per i dettagli vedi il Wiki Gravity Voice Recognition Module. La tabella seguente ti offre una panoramica delle frasi di controllo importanti per apprendere, modificare e cancellare:
| Comando | Funzione |
| Hello Robot | Parola di attivazione di sistema predefinita. |
| Apprendimento parola di attivazione | Cambia la parola di attivazione. |
| Apprendimento parola di comando | Insegna un nuovo comando. |
| Ri-apprendimento | Sostituisce un comando con un altro. |
| Esci dall’apprendimento | Pronuncia questo per uscire dalla modalità apprendimento. |
| Voglio cancellare | Entra nella funzione di cancellazione. |
| Cancella parola di attivazione | Cancella la parola di attivazione appresa. |
| Cancella parola di comando | Rimuove una frase di comando precedentemente acquisita. |
| Cancella tutto | Cancella tutti i comandi e le frasi dalla memoria. |
| Esci dalla cancellazione | Esce dalla funzione di cancellazione |
E questo è tutto! Ora hai tre esempi che dovrebbero aiutarti con il Gravity Voice Recognition Module.
Conclusioni
Questo tutorial ti ha fornito esempi di codice per iniziare con il Gravity Voice Recognition Module. Per la lista completa dei comandi vocali pre-programmati e su come addestrare il modulo vedi il Wiki.
Il Gravity Voice Recognition Module rende molto facile iniziare con il riconoscimento vocale. Basta collegare il modulo a un microcontrollore, scrivere un codice minimale e sei pronto a partire.
L’apprendimento di nuovi comandi e parole di attivazione avviene completamente tramite controllo vocale. Questo rende facile aggiungere nuovi comandi ma può essere scomodo cancellare o modificare comandi.
Inoltre, mentre l’accuratezza del riconoscimento dei comandi vocali pre-programmati è alta, quella dei comandi appresi sembra essere decisamente inferiore. Ho avuto difficoltà a far riconoscere affidabilmente comandi come “Accendi la luce rossa”, spesso confusi con “Accendi la luce”.
Un’alternativa al Gravity Voice Recognition Module potrebbe essere il Voice Recognition Module V3. Non ha frasi pre-programmate ma può imparare 80 parole e permette il controllo programmatico delle parole apprese. Tuttavia è più difficile da configurare e, a mio avviso, l’accuratezza del riconoscimento è inferiore.
Se vuoi davvero un’alta accuratezza di riconoscimento potresti provare Voice control with XIAO-ESP32-S3-Sense and Edge Impulse. In questo caso puoi addestrare completamente il riconoscimento vocale da solo, il che potrebbe darti migliori risultati ma è anche molto più complesso e impegnativo!
Se hai domande sentiti libero di lasciarle nella sezione commenti.
Buon divertimento con il tinkering 😉
