La interacción habilitada por voz es cada vez más central en los sistemas embebidos modernos, la robótica y los dispositivos inteligentes. El Gravity Voice Recognition Module de DFRobot ofrece un módulo compacto, capaz de funcionar sin conexión, diseñado para makers y desarrolladores que trabajan con plataformas como Arduino, micro:bit y ESP32. Este módulo soporta comunicación tanto I²C como UART, cuenta con 121 comandos de voz preprogramados y permite entrenar hasta 17 frases personalizadas localmente, todo sin necesidad de conexión a internet.
En esta guía, repasaremos las características clave del módulo, prepararemos el hardware y software necesarios, y luego mostraremos cómo integrar el módulo en un proyecto simple controlado por voz. Ya sea que tu objetivo sea un sistema de luces activado por voz, un asistente robótico o una rutina de automatización activada por voz, este post será un punto de partida práctico para poner en marcha el Gravity Voice Recognition Module bajo tu propio control.
Dónde comprar
Puedes adquirir el Gravity Voice Recognition Module en DFRobot o Amazon. El enlace a continuación es para el producto en Amazon. Además, necesitarás un microcontrolador. Yo uso un Arduino UNO, pero la mayoría de microcontroladores comunes (por ejemplo, ESP32, ESP8266, …) también funcionarán. Y si quieres probar algunos proyectos, una protoboard y algunos cables te serán útiles.
Gravity Voice Recognition Module
Arduino Uno
Cable USB para Arduino UNO
Juego de cables Dupont
Protoboard
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
El Gravity Voice Recognition Module de DFRobot es una unidad compacta y autónoma de procesamiento de voz que permite el control por voz sin conexión para sistemas embebidos. En su núcleo, el módulo integra un potente chip de reconocimiento de voz capaz de realizar análisis de comandos localmente sin depender de servicios en la nube. Esto permite una respuesta rápida, baja latencia y completa independencia de la conectividad de red.
Componentes
El módulo contiene un pequeño altavoz integrado y un conector para un altavoz externo (8 Ω 3W). Un pequeño interruptor permite cambiar entre los dos altavoces. Un segundo interruptor permite seleccionar entre comunicación I2C y UART con el módulo.
Además, hay dos micrófonos y dos LEDs indicadores en la placa. Un LED (rojo) indica alimentación y el otro (azul) señala que se ha reconocido la palabra de activación y que el módulo está listo para recibir comandos de voz. La imagen a continuación muestra los componentes del módulo:
Versiones
Ten en cuenta que existen dos versiones del módulo; la versión 1.0 y la versión 1.1. La versión más antigua 1.0 carece de conector para el altavoz integrado y de dos orificios para montaje. Por lo demás, el hardware y la programación son idénticos. La foto a continuación muestra las dos versiones del módulo:
Alimentación
El módulo opera dentro de un rango típico de voltaje de3.3V a 5V, asegurando compatibilidad tanto con sistemas lógicos de 3.3V (como ESP32 y Raspberry Pi Pico) como con sistemas de 5V (como Arduino Uno). El factor de forma compacto (49 mm × 32 mm) lo hace adecuado para integrarse en cajas con espacio limitado.
Comandos
El módulo tiene 121 comandos preprogramados, como «Turn the light on», que no pueden ser modificados. También hay una palabra de activación («Hello Robot») que es fija. Hay 17 espacios para comandos que pueden ser aprendidos, y un espacio para una palabra de activación aprendible. Para una lista completa de comandos preprogramados, consulta elDFRobot Wiki for the Gravity Voice Recognition Module.
El módulo se activa cuando se reconoce la palabra de activación, luego permanece activo durante un tiempo programable y durante ese tiempo está listo para detectar comandos de voz.
Especificaciones técnicas
| Parámetro | Especificación |
|---|---|
| Nombre del producto | Gravity Voice Recognition Module |
| Voltaje de alimentación | 3.3 V – 5 V |
| Interfaz de comunicación | I²C y UART (seleccionable) |
| Dirección I2C | 0x64 |
| Modo de reconocimiento | Reconocimiento de voz offline |
| Comandos incorporados | 121 preprogramados |
| Comandos personalizados | Hasta 17 definidos por el usuario |
| Comando de activación para aprendizaje | 1 |
| Micrófono | 2 x integrados |
| Sensibilidad del micrófono | -28dB |
| Altavoz | Integrado, con altavoz externo opcional |
| Corriente de operación | ≤ 370 mA @ 5V |
| Temperatura de operación | 0 °C a +70 °C |
| Dimensiones | 49 mm × 32 mm |
| Puerto | Interfaz Gravity de 4 pines (VCC, GND, SDA/RX, SCL/TX) |
Conectar el Voice Recognition Module a un Arduino UNO
Conectar el Gravity Voice Recognition Module a un Arduino UNO es sencillo. Conecta GND del módulo Gravity a GND del Arduino y VCC a 5V.
Luego conectamos la interfaz I2C. La línea SCL en el pin A5 del Arduino debe conectarse al pin C/R del módulo Gravity (cable verde). Finalmente, conectamos SDA (A4) del Arduino al pin D/T del módulo Gravity. La imagen a continuación muestra el cableado completo:
En la siguiente sección escribiremos algo de código para probar el Voice Recognition Module.
Instalar la librería para Gravity Voice Recognition Module
Antes de poder usar el Gravity Voice Recognition Module con un Arduino o ESP32, primero debemos instalar laDFRobot_DF2301Q Libraryen el IDE de Arduino. Simplemente abre el LIBRARY MANAGER, escribe DFRobot_DF2301Q en la barra de búsqueda y presiona INSTALL:
Ejemplo de código: Encender o apagar el LED integrado
En este primer ejemplo de código encenderemos o apagaremos el LED integrado del Arduino UNO usando el pre-programmed voice commands «Turn on the light» y «Turn off the light». Como usamos comandos preprogramados, no se requiere aprendizaje ni otra preparación del Voice Recognition Module aquí. Echa un vistazo rápido al código primero y luego discutiremos sus detalles.
#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);
}
Importaciones
Primero, incluimos el archivo de cabecera para la librería DF2301Q:
#include "DFRobot_DF2301Q.h"
Esta librería proporciona todas las funciones necesarias para inicializar, configurar y comunicarse con el módulo de reconocimiento de voz DF2301Q. Maneja la comunicación I²C y simplifica el reconocimiento de comandos y la gestión de configuración.
Constantes
En la siguiente línea definimos una constante para el pin del LED:
const byte led = LED_BUILTIN;
La macroLED_BUILTINse refiere al LED integrado de la placa de desarrollo, que típicamente está conectado al pin 13 en la mayoría de placas Arduino. Al asignar este valor a la constanteled, el código se vuelve más legible y fácil de adaptar si quieres usar otro pin para el LED.
Objetos
A continuación se crea una instancia de la claseDFRobot_DF2301Q_I2C, que permite al Arduino comunicarse con el Gravity Voice Recognition Module vía I2C:
DFRobot_DF2301Q_I2C asr;
Setup
La funciónsetup()se ejecuta una vez al inicio del programa y prepara tanto el microcontrolador como el módulo 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);
}
Primero inicializamos la comunicación serial a 115200 baudios. Esto permite que el Arduino envíe información diagnóstica al Monitor Serial. Luego, el pin del LED se configura como salida y su estado se establece enLOW, asegurando que el LED esté inicialmente apagado.
El programa intenta entonces inicializar el módulo DF2301Q usandoasr.begin(). La función devuelvetruesi el módulo es detectado correctamente vía I2C. Si no, se imprime el mensaje«Can’t initialize ASR«cada 3 segundos hasta que la inicialización tenga éxito.
Después de la inicialización, se envían varios comandos de configuración. Elasr.setVolume(6)establece el volumen del altavoz o reconocimiento al nivel 6 (en una escala de 1 a 10).
Con el comandoasr.setMuteMode(0)puedes activar o desactivar la retroalimentación de audio. Un valor de 0 significa que el silencio está desactivado y el módulo confirmará los comandos reconocidos con «OK», «Yes, I am here» o «I’m off now» al salir del modo de activación.
Finalmente,asr.setWakeTime(20)define el tiempo de activación del módulo, o la duración que permanece activo tras detectar la palabra de activación. El número parece ser el tiempo en segundos (de 0 a 255), pero no encontré información específica en la documentación.
Loop
La funciónloop()se ejecuta continuamente después del setup y maneja la lógica principal del programa.
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);
}
Al inicio de cada iteración del loop, la funciónasr.getCMDID()recupera el último ID de comando reconocido por el módulo DF2301Q. Cada comando de voz reconocido está asociado a un ID numérico único. Consulta el DFRobot Wiki for the Gravity Voice Recognition Module para ver la lista de comandos y sus IDs.
Si el ID de comando devuelto es103, el LED se enciende configurando el pin de salidaHIGHy se imprime el mensaje«Turn on the light«en el Monitor Serial.
Si el ID de comando es104, el LED se apaga configurando el pin de salidaLOW. Y se imprime el mensaje«Turn off the light«.
El siguiente bloque condicional imprime el valor detectado decmd_idsi es distinto de cero, lo que ayuda a monitorear los comandos recibidos.
Finalmente, undelay(300)pausa el loop durante 300 milisegundos antes de volver a comprobar, dando tiempo para que se reconozca el siguiente comando.
Ejecutar el código
Después de subir el código a tu Arduino, ahora puedes controlar el LED integrado con tu voz. Comienza diciendo «Hello Robot» para activar el modo de activación. El LED azul del módulo de reconocimiento de voz debería encenderse y el módulo dirá «How, can I help» o «Yes, I am here».
Mientras estés en modo de activación, puedes decir «Turn on the light» o «Turn off the light» para encender o apagar el LED integrado. Si no se recibe ningún comando durante un tiempo (tiempo de activación), el módulo sale del modo de activación y dice «I’m off now». Tendrás que decir «Hello Robot» de nuevo para activar el módulo.
En el Monitor Serial deberías ver los IDs de comando (2 = activación) y el texto«Turn on the light«o«Turn off the light«impresos:
cmd_id = 2 Turn on the light cmd_id = 103 Turn off the light cmd_id = 104
Ejemplo de código: Controlar la retroalimentación de audio
En este siguiente ejemplo, seguimos encendiendo o apagando el LED integrado, pero controlaremos la retroalimentación de audio nosotros mismos.
Si llamas aasr.setMuteMode(1), el módulo se silencia y no proporciona retroalimentación de audio automáticamente. Sin embargo, puedes llamar aasr.playByCMDID(id)para reproducir ciertas frases como «How can I help / yes, I am here» o «Done».
Desafortunadamente, no encontré documentación sobre las frases soportadas y sus IDs. Pero identifiqué los siguientes tres IDs útiles:
| id | frase(s) |
|---|---|
| 1 | How can I help / Yes, I am here |
| 5 | Ok, got it / Ok / doing it / done |
| 23 | Done |
Ten en cuenta que para los IDs 1 y 5 el módulo elige aleatoriamente una de las frases listadas en la tabla.
En el siguiente ejemplo de código desactivamos la retroalimentación automática de audio, y decimos «Done» cuando un comando se ejecuta, y «How can I help / Yes, I am here» cuando se detecta la palabra de activación:
#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);
}
El código es muy similar al anterior, excepto por la funciónspeak(). Esta toma el ID de una frase (por ejemplo, 23 = «Done»), desactiva temporalmente el silencio, llama aplayByCMDID(id)para pronunciar la frase y luego vuelve a silenciar el módulo.
void speak(uint8_t id) {
asr.setMuteMode(0);
asr.playByCMDID(id);
delay(100);
asr.setMuteMode(1);
}
Así que, si el Voice Recognition Module te parece un poco parlanchín, esto te permite controlar tú mismo la retroalimentación de audio.
Ejemplo de código: Controlar dispositivos externos con comandos aprendidos
En este último ejemplo controlaremos dos dispositivos externos (LEDs rojo y verde) usando comandos aprendidos. En lugar de LEDs podrías conectar relés para controlar dispositivos de mayor potencia, pero para este ejemplo usamos LEDs.
Primero conectemos los LEDs. Ambos LEDs están conectados a tierra (GND). El LED verde se conectará a GPIO11 y el LED rojo a GPIO12 a través de una resistencia de 220 Ohmios. Consulta el diagrama de cableado a continuación:
Luego enseñamos las frases de comando para controlar los LEDs.
Aprendiendo palabras de comando
Quiero usar las siguientes cuatro frases para controlar el LED rojo y el verde:
- «Turn on red light«
- «Turn off red light«
- «Turn on green light«
- «Turn off green light«
Para comenzar a aprender, primero di la palabra de activación «Hello Robot«. Luego entra en modo aprendizaje diciendo «Learning command word«. El módulo te guiará a través del proceso de aprendizaje con los siguientes pasos:
- Indicación: Aprendiendo ahora, por favor guarda silencio, aprende la palabra de comando según la indicación. ¡Por favor di el primer comando a aprender!
- Frase de comando a aprender: «Turn on red light«
- Indicación: Aprendizaje exitoso, por favor repítelo.
- Frase de comando a aprender: «Turn on red light«
- Indicación: Aprendizaje exitoso, por favor repítelo.
- Frase de comando a aprender: «Turn on red light«
- Indicación: OK, primer comando aprendido con éxito. Por favor di el segundo comando a aprender.
- …
Puedes salir del modo aprendizaje diciendo «Exit learning«.
Código
Si el aprendizaje de las cuatro nuevas frases de comando fue exitoso, entonces puedes controlar los LEDs rojo y verde usando el siguiente código:
#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);
}
De nuevo, el código es similar a los ejemplos anteriores. La única diferencia está en la función principal, donde ahora comprobamos los IDs de comando 5, 6, 7 y 8 que corresponden a los comandos aprendidos:
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 ya has aprendido otras frases de comando o las entrenaste en diferente orden, tus IDs serán distintos. Sin embargo, el código imprime el ID de la frase reconocida y puedes modificar tu código en consecuencia.
Obviamente, también puedes borrar frases aprendidas o aprender una nueva palabra de activación. Para detalles, consulta el Wiki Gravity Voice Recognition Module. La siguiente tabla te ofrece un resumen de las frases de control importantes para aprender, editar y borrar:
| Comando | Función |
| Hello Robot | Palabra de activación por defecto del sistema. |
| Learning wake word | Cambiar la palabra de activación. |
| Learning command word | Enseña un nuevo comando. |
| Re-learn | Reemplaza un comando por otro. |
| Exit learning | Di esto para salir del modo aprendizaje. |
| I want to delete | Entra en la función de borrado. |
| Delete wake word | Borra la palabra de activación aprendida. |
| Delete command word | Elimina una frase de comando previamente aprendida. |
| Delete all | Borra todos los comandos y frases de la memoria. |
| Exit deleting | Sale de la función de borrado. |
¡Y eso es todo! Ahora tienes tres ejemplos que deberían ayudarte con el Gravity Voice Recognition Module.
Conclusiones
Este tutorial te proporcionó ejemplos de código para comenzar con el Gravity Voice Recognition Module. Para una lista completa de los comandos de voz preprogramados y cómo entrenar el módulo, consulta elWiki.
El Gravity Voice Recognition Module facilita mucho empezar con el reconocimiento de voz. Solo conecta el módulo a un microcontrolador, escribe un código mínimo y estarás listo para usarlo.
El aprendizaje de nuevos comandos y palabras de activación también se realiza completamente por control de voz. Esto facilita añadir nuevos comandos, pero puede ser engorroso borrar o editar comandos.
Además, aunque la precisión de reconocimiento de los comandos preprogramados es alta, la precisión de los comandos aprendidos parece ser bastante menor. Tuve dificultades para que el sistema reconociera de forma fiable comandos como «Turn on the red light», que a menudo se confundían con «Turn on the light».
Una alternativa al Gravity Voice Recognition Module podría ser el Voice Recognition Module V3. No tiene frases preprogramadas pero puede aprender 80 palabras y permite control programático sobre las palabras aprendidas. Sin embargo, es más difícil de configurar y siento que la precisión de reconocimiento es menor.
Si realmente quieres alta precisión de reconocimiento, podrías probar Voice control with XIAO-ESP32-S3-Sense and Edge Impulse. En este caso puedes entrenar el reconocimiento de voz completamente tú mismo, lo que podría darte mejores precisiones, pero también es mucho más complejo y laborioso.
Si tienes alguna pregunta, no dudes en dejarla en la sección de comentarios.
¡Feliz bricolaje! 😉
