A interação por voz está a tornar-se cada vez mais central em sistemas embebidos modernos, robótica e dispositivos inteligentes. Gravity Voice Recognition Module da DFRobot oferece um módulo compacto, capaz de funcionar offline, desenhado para makers e desenvolvedores que trabalham com plataformas como Arduino, micro:bit e ESP32. Este módulo suporta comunicação I²C e UART, possui 121 comandos de voz pré-programados e permite treinar localmente até 17 frases personalizadas — tudo sem necessidade de ligação à internet.
Neste guia, vamos explorar as principais funcionalidades do módulo, preparar o hardware e software necessários, e depois demonstrar como integrar o módulo num projeto simples controlado por voz. Quer o seu objetivo seja um sistema de luz ativado por voz, um assistente robótico ou uma rotina de automação acionada por voz, este artigo será um ponto de partida prático para pôr o Gravity Voice Recognition Module a funcionar sob o seu controlo.
Onde Comprar
Pode adquirir o Gravity Voice Recognition Module na DFRobot ou na Amazon. O link abaixo é para o produto na Amazon. Além disso, vai precisar de um microcontrolador. Eu estou a usar um Arduino UNO, mas a maioria dos microcontroladores comuns (ex. ESP32, ESP8266, …) também funcionam. E se quiser experimentar alguns projetos, uma breadboard e alguns cabos serão úteis.
Gravity Voice Recognition Module
Arduino Uno
Cabo USB para Arduino UNO
Conjunto de Cabos 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 do Gravity Voice Recognition Module
O Gravity Voice Recognition Module da DFRobot é uma unidade compacta e autónoma de processamento de voz que permite controlo por voz offline para sistemas embebidos. No seu núcleo, o módulo integra um chip poderoso de reconhecimento de voz capaz de realizar análise local de comandos sem depender de serviços na cloud. Isto permite respostas rápidas, baixa latência e total independência da conectividade de rede.
Componentes
O módulo contém um pequeno altifalante integrado e um conector para um altifalante externo (8 Ω 3W). Um pequeno interruptor permite alternar entre os dois altifalantes. Um segundo interruptor permite escolher entre comunicação I2C e UART com o módulo.
Além disso, há dois microfones e dois LEDs indicadores na placa. Um LED (vermelho) indica energia e o outro (azul) sinaliza que a palavra de ativação foi reconhecida e que o módulo está pronto para receber comandos de voz. A imagem abaixo mostra os componentes do módulo:
Versões
Note que existem duas versões do módulo; Versão 1.0 e Versão 1.1. A versão mais antiga 1.0 não tem conector para o altifalante integrado nem dois orifícios de montagem. Fora isso, o hardware e a programação são idênticos. A foto abaixo mostra as duas versões do módulo:
Alimentação
O módulo opera numa faixa típica de voltagem de3.3V a 5V, garantindo compatibilidade com sistemas lógicos de 3.3V (como ESP32 e Raspberry Pi Pico) e sistemas de 5V (como Arduino Uno). O formato compacto (49 mm × 32 mm) torna-o adequado para integração em caixas com espaço limitado.
Comandos
O módulo tem 121 comandos pré-programados, como “Ligar a luz”, que não podem ser alterados. Existe também uma palavra de ativação fixa (“Hello Robot”). Há 17 espaços para palavras de comando que podem ser aprendidas, e um espaço para uma palavra de ativação aprendível. Para uma lista completa dos comandos pré-programados veja o DFRobot Wiki for the Gravity Voice Recognition Module.
O módulo desperta quando a palavra de ativação é reconhecida, mantém-se ativo por um tempo programável e durante esse período está pronto para detectar comandos de voz.
Especificações Técnicas
| Parâmetro | Especificação |
|---|---|
| Nome do Produto | Gravity Voice Recognition Module |
| Tensão de Alimentação | 3.3 V – 5 V |
| Interface de Comunicação | I²C e UART (selecionável) |
| Endereço I2C | 0x64 |
| Modo de Reconhecimento | Reconhecimento de voz offline |
| Comandos Integrados | 121 pré-programados |
| Comandos Personalizados | Até 17 definidos pelo utilizador |
| Comando de Ativação para Aprendizagem | 1 |
| Microfone | 2 x integrados |
| Sensibilidade do Microfone | -28dB |
| Altifalante | Integrado, com altifalante externo opcional |
| Corrente de Operação | ≤ 370 mA @ 5V |
| Temperatura de Operação | 0 °C a +70 °C |
| Dimensões | 49 mm × 32 mm |
| Porta | Interface Gravity de 4 pinos (VCC, GND, SDA/RX, SCL/TX) |
Ligação do Voice Recognition Module a um Arduino UNO
Ligar o Gravity Voice Recognition Module a um Arduino UNO é simples. Ligue o GND do módulo Gravity ao GND do Arduino e o VCC aos 5V.
De seguida, ligamos a interface I2C. A linha SCL no pino A5 do Arduino deve ser ligada ao pino C/R do módulo Gravity (fio verde). Finalmente, ligue o SDA (A4) do Arduino ao D/T do módulo Gravity. A imagem abaixo mostra a ligação completa:
Na próxima secção vamos escrever algum código para experimentar o Voice Recognition Module.
Instalar Biblioteca para Gravity Voice Recognition Module
Antes de podermos usar o Gravity Voice Recognition Module com um Arduino ou ESP32, precisamos primeiro de instalar a DFRobot_DF2301Q Library na IDE Arduino. Basta abrir o LIBRARY MANAGER, digitar DFRobot_DF2301Q na barra de pesquisa e pressionar INSTALL:
Exemplo de Código: Ligar ou desligar o LED integrado
Neste primeiro exemplo de código vamos ligar ou desligar o LED integrado do Arduino UNO usando os comandos pre-programmed voice commands “Turn on the light” e “Turn off the light”. Como estamos a usar os comandos pré-programados, não é necessário aprender ou preparar o Voice Recognition Module. Dê uma vista rápida ao código primeiro e depois discutiremos os detalhes.
#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);
}
Importações
Primeiro, incluímos o ficheiro de cabeçalho da biblioteca DF2301Q:
#include "DFRobot_DF2301Q.h"
Esta biblioteca fornece todas as funções necessárias para inicializar, configurar e comunicar com o módulo de reconhecimento de voz DF2301Q. Trata a comunicação I²C e simplifica o reconhecimento de comandos e a gestão da configuração.
Constantes
Na linha seguinte, definimos uma constante para o pino do LED:
const byte led = LED_BUILTIN;
A macro LED_BUILTIN refere-se ao LED integrado da placa de desenvolvimento, que normalmente está ligado ao pino 13 na maioria das placas Arduino. Ao atribuir este valor à constante led, o código torna-se mais legível e fácil de adaptar caso queira usar um pino diferente para o LED.
Objetos
De seguida, é criada uma instância da classe DFRobot_DF2301Q_I2C, que permite ao Arduino comunicar com o Gravity Voice Recognition Module via I2C:
DFRobot_DF2301Q_I2C asr;
Setup
A função setup() corre uma vez no início do programa e prepara tanto o microcontrolador como o 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);
}
Primeiro inicializamos a comunicação serial a 115200 baud. Isto permite ao Arduino enviar informações de diagnóstico para o Monitor Serial. Depois, o pino do LED é configurado como saída, e o seu estado é definido para LOW, garantindo que o LED está inicialmente desligado.
O programa tenta então inicializar o módulo DF2301Q usando asr.begin(). A função retorna true se o módulo for detetado com sucesso via I2C. Caso contrário, a mensagem “Não é possível inicializar o ASR“ é impressa a cada 3 segundos até a inicialização ser bem-sucedida.
Após a inicialização, são emitidos vários comandos de configuração. O asr.setVolume(6) define o volume do altifalante ou do reconhecimento para o nível 6 (numa escala de 1 a 10).
Com o comando asr.setMuteMode(0) pode ativar ou desativar o feedback áudio. Um valor 0 significa que o mudo está desativado e o módulo confirma os comandos reconhecidos com “OK”, “Yes, I am here”, ou “I’m off now”, ao sair do modo de ativação.
Finalmente, asr.setWakeTime(20) define o tempo de ativação do módulo, ou a duração em que permanece ativo após detetar a palavra de ativação. O número parece ser o tempo em segundos (de 0 a 255), mas não encontrei informação específica na documentação.
Loop
A função loop() corre continuamente após o setup e gere a lógica principal do 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);
}
No início de cada iteração do loop, a função asr.getCMDID() obtém o último ID de comando reconhecido pelo módulo DF2301Q. Cada comando de voz reconhecido está associado a um ID numérico único. Veja o DFRobot Wiki for the Gravity Voice Recognition Module para uma lista de comandos e seus IDs.
Se o ID do comando retornado for 103, o LED é ligado definindo o pino de saída HIGH, e a mensagem “Ligar a luz“ é impressa no Monitor Serial.
Se o ID do comando for 104, o LED é desligado definindo o pino de saída LOW. E a mensagem “Desligar a luz“ é impressa.
O bloco condicional seguinte imprime o valor do cmd_id sempre que for diferente de zero, o que ajuda a monitorizar os comandos recebidos.
Finalmente, um delay(300) pausa o loop por 300 milissegundos antes de verificar novamente, dando tempo para o próximo comando ser reconhecido.
Executar o Código
Depois de carregar o código no seu Arduino, pode controlar o LED integrado do Arduino com a sua voz. Comece por dizer “Hello Robot” para ativar o modo de ativação. O LED azul no módulo de reconhecimento de voz deve acender, e o módulo dirá “How, can I help” ou “Yes, I am here”.
Enquanto estiver no modo de ativação, pode dizer “Turn on the light” ou “Turn off the light” para ligar ou desligar o LED integrado. Se nenhum comando for recebido durante algum tempo (tempo de ativação), o módulo sai do modo de ativação e diz “I’m off now”. Terá de dizer “Hello Robot” novamente para ativar o módulo.
No Monitor Serial deverá ver os IDs dos comandos (2 = ativação) e o texto “Ligar a luz“ ou “Desligar a luz“ impresso:
cmd_id = 2 Turn on the light cmd_id = 103 Turn off the light cmd_id = 104
Exemplo de Código: Controlar Feedback de Áudio
Neste próximo exemplo, continuamos a ligar ou desligar o LED integrado, mas vamos controlar o feedback de áudio manualmente.
Se chamar asr.setMuteMode(1), o módulo fica mudo e não fornece feedback de áudio automaticamente. No entanto, pode chamar asr.playByCMDID(id) para reproduzir certas frases como “How can I help / yes, I am here” ou “Done”.
Infelizmente, não encontrei documentação sobre as frases suportadas e seus IDs. Mas identifiquei os seguintes três IDs úteis:
| id | frase(s) |
|---|---|
| 1 | How can I help / Yes, I am here |
| 5 | Ok, got it / Ok / doing it / done |
| 23 | Done |
Note que para os IDs 1 e 5 o módulo escolhe aleatoriamente uma das frases listadas na tabela.
No código seguinte desligamos o feedback automático de áudio, dizemos “Done” quando um comando é executado, e “How can I help / Yes, I am here” quando a palavra de ativação é detetada:
#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);
}
O código é muito semelhante ao anterior, exceto pela função speak(). Esta recebe o ID de uma frase (ex. 23 = “Done”), desativa temporariamente o mudo, chama playByCMDID(id) para pronunciar a frase e depois volta a ativar o mudo.
void speak(uint8_t id) {
asr.setMuteMode(0);
asr.playByCMDID(id);
delay(100);
asr.setMuteMode(1);
}
Portanto, se o Voice Recognition Module for um pouco demasiado falador para si, isto permite controlar o feedback de áudio manualmente.
Exemplo de Código: Controlar Dispositivos Externos com Comandos Aprendidos
Neste último exemplo vamos controlar dois dispositivos externos (LEDs vermelho e verde) usando comandos aprendidos. Em vez de LEDs, poderia ligar relés para controlar dispositivos de maior potência, mas para este exemplo usamos LEDs.
Primeiro vamos ligar os LEDs. Ambos os LEDs estão ligados ao terra (GND). O LED verde será ligado ao GPIO11 e o LED vermelho ao GPIO12 através de um resistor de 220 Ohm. Veja o diagrama de ligação abaixo:
De seguida, ensinamos as frases de comando a usar para controlar os LEDs.
Aprender palavras de comando
Quero usar as seguintes quatro frases para controlar o LED vermelho e o verde:
- “Ligar luz vermelha“
- “Desligar luz vermelha“
- “Ligar luz verde“
- “Desligar luz verde“
Para começar a aprender, primeiro diga a palavra de ativação “Hello Robot“. De seguida, entre no modo de aprendizagem dizendo “Aprender palavra de comando“. O módulo irá guiá-lo pelo processo de aprendizagem com os seguintes passos:
- Indicação: A aprender agora, por favor esteja quieto, aprenda a palavra de comando conforme o pedido! Por favor diga o primeiro comando a aprender!
- Frase de comando a aprender: “Ligar luz vermelha“
- Indicação: Aprendizagem bem-sucedida, por favor diga novamente!
- Frase de comando a aprender : “Ligar luz vermelha“
- Indicação: Aprendizagem bem-sucedida, por favor diga novamente!
- Frase de comando a aprender : “Ligar luz vermelha“
- Indicação: OK, aprendeu o primeiro comando com sucesso! Por favor diga o segundo comando a aprender!
- …
Pode sair do modo de aprendizagem dizendo “Sair da aprendizagem“.
Código
Se a aprendizagem das quatro novas frases de comando foi bem-sucedida, pode então controlar os LEDs vermelho e verde usando o seguinte 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);
}
Novamente, o código é semelhante aos exemplos anteriores. A única diferença está na função principal, onde agora verificamos os IDs dos comandos 5, 6, 7 e 8 que correspondem aos 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);
}
Se já aprendeu outras frases de comando ou treinou numa ordem diferente, os seus IDs serão diferentes. No entanto, o código imprime o ID da frase reconhecida e pode alterar o seu código em conformidade.
Obviamente, também pode apagar frases aprendidas ou aprender uma nova palavra de ativação. Para detalhes veja o Wiki Gravity Voice Recognition Module. A tabela seguinte fornece uma visão geral das frases de controlo importantes para aprender, editar e apagar:
| Comando | Função |
| Hello Robot | Palavra de ativação padrão do sistema. |
| Aprender palavra de ativação | Muda a palavra de ativação. |
| Aprender palavra de comando | Ensina um novo comando. |
| Reaprender | Substitui um comando por outro. |
| Sair da aprendizagem | Diz isto para sair do modo de aprendizagem. |
| Quero apagar | Entra na função de apagar. |
| Apagar palavra de ativação | Apaga a palavra de ativação aprendida. |
| Apagar palavra de comando | Remove uma frase de comando previamente adquirida. |
| Apagar tudo | Apaga todos os comandos e frases da memória. |
| Sair de apagar | Sai da função de apagar |
E é tudo! Agora tem três exemplos que devem ajudar com o Gravity Voice Recognition Module.
Conclusões
Este tutorial forneceu exemplos de código para começar a usar o Gravity Voice Recognition Module. Para uma lista completa dos comandos de voz pré-programados e como treinar o módulo veja o Wiki.
O Gravity Voice Recognition Module torna muito fácil começar com reconhecimento de voz. Basta ligar o módulo a um microcontrolador, escrever algum código mínimo e está pronto a usar.
Aprender novos comandos e palavras de ativação é também totalmente feito por controlo de voz. Isso facilita adicionar novos comandos, mas pode ser complicado apagar ou editar comandos.
Além disso, enquanto a precisão do reconhecimento dos comandos pré-programados é alta, a precisão dos comandos aprendidos parece ser bastante inferior. Tive dificuldades em fazer o sistema reconhecer de forma fiável comandos como “Turn on the red light”, que eram frequentemente confundidos com “Turn on the light”.
Uma alternativa ao Gravity Voice Recognition Module pode ser o Voice Recognition Module V3. Não tem frases pré-programadas, mas pode aprender 80 palavras e permite controlo programático sobre as palavras aprendidas. Mas é mais difícil de configurar e sinto que a precisão do reconhecimento é menor.
Se realmente quiser alta precisão de reconhecimento, pode experimentar Voice control with XIAO-ESP32-S3-Sense and Edge Impulse. Neste caso pode treinar o reconhecimento de voz completamente sozinho, o que pode dar melhor precisão, mas é também muito mais complexo e trabalhoso!
Se tiver alguma dúvida, sinta-se à vontade para deixar nos comentários.
Boas criações 😉
