ARDUINO, AUTOMAÇÃO, DESTAQUE, DICAS, OUTROS

Jarvis – Controlando o seu Arduino por Comandos de Voz

O uso de assistente de voz se tornou algo bem comum nos últimos anos. O assistente virtual mais conhecido e mais antigo é a Siri, que está disponível em vários dispositivos comercializados pela Apple. Com o passar dos anos surgiram outros assistentes virtuais, tais como o Google Now (para Android), Alexa (Amazon), Google Assistente (evolução do Google Now) e vários outros. Dentre estas várias opções de assistentes virtuais, temos o DJ JARVIS, uma ferramenta computacional que além de ser capaz de interagir com as pessoas e executar tarefas do nosso cotidiano, pode ser integrado ao Arduino, permitindo infinitas possibilidades, principalmente na automação residencial e robótica.

O DJ.JARVIS.AM ou simplesmente Jarvis, é um programa de computador que tem como papel ser um assistente de voz. O Jarvis pode ser instalado e executado em dispositivos com Windows, e além disso, reconhece os comandos de voz em português do Brasil. Um dos diferenciais do Jarvis em relação aos demais assistentes virtuais, é o fato de não precisar estar conectado à internet para que os comandos sejam reconhecidos. Desta forma, as respostas e ações do Jarvis são executadas em menor tempo.

Após o programa ser instalado no computador, é necessário o uso de um microfone para que os comandos possam ser enviados ao Jarvis. Ao receber o comando de voz, ele irá interpretar e executar a ação correspondida de acordo com as configurações predefinidas ou que você definiu manualmente após a instalação. Além disso, você pode criar comandos e respostas para deixar o Jarvis muito mais interativo.

Para conhecer todos os detalhes do Jarvis, recomendo que acesse o site oficial e faça o download da versão free para que você possa fazer testes com a ferramenta. Lembrando que o Jarvis está disponível também na versão PRO:

Site Oficial do Jarvis

Download Jarvis

Tutoriais de Instalação e Configuração

Conforme dito antes, até a data desta publicação (12/2018) o Jarvis pode ser instalado e executado apenas em dispositivos com Windows. A equipe de desenvolvedores do Jarvis permanece trabalhando no desenvolvimento da ferramenta para dispositivos móveis.

Além de ser capaz de interagir com as pessoas e executar tarefas do nosso cotidiano, o Jarvis pode ser integrado com qualquer plataforma embarcada / microcontrolada que possua comunicação serial. Desta forma, podemos interagir o Jarvis com o Arduino, Raspberry Pi, ESP8266 e ESP32, por exemplo. Com isto, temos infinitas possibilidades de projetos, principalmente na área de automação residencial e robótica.

Para esta postagem o foco será o uso do Jarvis com o Arduino.

No diagrama abaixo você pode ver um esquema básico de funcionamento do Jarvis junto ao computador e ao Arduino:

Para demonstrar a integração entre o Jarvis e o Arduino, optei por utilizar um módulo relé com uma lâmpada e uma TV com controle remoto.

Com o módulo relé conectado ao Arduino e a uma lâmpada, vai ser possível enviar os comandos aos Jarvis para que a lâmpada acenda ou apague. Para controlar a TV, vai ser necessário clonar as teclas do controle remoto através do Arduino para em seguida inserir os códigos das teclas no código final que será carregado na placa, e fazer o controle da TV através dos comandos de voz que serão enviados ao Jarvis.

Para fazer o acionamento do módulo relé, vou utilizar dois comandos no Jarvis:

Acender lâmpada
Apagar lâmpada

A resposta do Jarvis para estes comandos serão respectivamente:

Lâmpada está acesa
Lâmpada está apagada

Os caracteres enviados ao Arduino pela serial serão respectivamente:

A / B

Para controle da TV, vou utilizar os seguintes comandos:

Acender lâmpada
Apagar lâmpada
Ligar a Televisão e Desligar a Televisão
Acessar entradas
Pra esquerda e Voltar
Pra direita e Avançar
Pra cima
Pra baixo
Quero assistir este, Abrir e OK
Pausar
Continuar reprodução
Aumentar o som
Abaixar o som
Sair

Não especifiquei nenhuma resposta para estes comandos, contudo, se você quiser poderá adicionar as respostas.

Os caracteres enviados ao Arduino pela serial serão respectivamente:

C / D / E / F / G / H / I / J / K / L / M / N

Agora conecte o seu Arduino ao computador através do cabo USB para que a porta serial COM do mesmo possa ser configurada e registrada no Jarvis.

Considerando que você já tenha o Jarvis instalado e configurado em seu computador, execute o programa e aguarde o carregamento da interface.

OBS: o Jarvis que está instalado em meu computador é a versão PRO e está com o tema Dark Edition.

Com o Jarvis aberto, acesse a opção de “Comandos” para que o menu de opções seja aberto.

Clique na opção “Controles de automação”:

Na janela que for aberta, clique em “Comandos Arduino”:

Nesta janela, em “Portas seriais” selecione a porta COM em que seu Arduino está conectado e clique em “Salvar porta”. Em “Baud rate” selecione 9600 e clique em “Setar Baud Rate”:

OBS: a porta COM1 é nativa do Windows e não corresponde ao Arduino.

Na parte de “COMANDOS” deve ser inserido em cada linha o comando (frase), em “RESPOSTAS” deve ser inserido em cada linha a resposta correspondente ao comando e em “ENVIAR” deve ser inserido o caractere que será enviado via serial para o Arduino. Anteriormente eu já havia mencionado os comandos, respostas e caracteres que seriam configurados no Jarvis para que fossem direcionados ao Arduino.

Para criar o comando, basta colocar o cursor na linha 1, digitar a frase e pressionar enter para que o cursor vá para a segunda linha. Use este mesmo procedimento para inserir as respostas e os caracteres a serem enviados ao Arduino.

Após preenchimento das informações, minhas configurações ficaram conforme a imagem abaixo:

Clique em “Salvar” para efetivar as modificações.

OBS: veja que nas linhas 3, 5, 6 e 9 coloquei mais de um comando e os separei por uma barra vertical. Desta forma, qualquer um destes comandos que eu falar, ele vai dar a mesma resposta (se existir resposta configurada) e vai enviar ao Arduino o caractere definido. Na resposta de um comando você também pode inserir mais de uma resposta, respeitando o uso da barra vertical para separá-los. Além disso, como também deixei em branco a resposta para o último comando (Sair), tive que pressionar enter para que fosse criado a linha 15 e fiz o mesmo procedimento para a resposta e para o enviar. Isto evita que o Jarvis fique acusando que há problemas com a porta COM em que o Arduino está conectado.

Agora será necessário informar ao Jarvis que há novos comandos disponíveis. Para isto, aproxime-se do microfone e diga “Atualizar comandos”. Aguarde o Jarvis responder “Todos os comandos foram atualizados”.

Terminado esta configuração, basta fechar a janela de comandos e deixar o Jarvis aberto.

Para prosseguir você vai precisar dos seguintes itens:

01 – Arduino com Cabo USB
01 – Módulo Relé 5V 1 Canal
01 – Fotorreceptor / Receptor IR VS1838B
01 – Led Emissor Infravermelho (IR)
01 – Resistor de 220Ω
01 – Protoboard
03 – Cabos Jumper macho-macho
03 – Cabos Jumper macho-fêmea
01 – TV com controle remoto
01 – Lâmpada
01 – Receptáculo (boquilha)
01 – Cabo paralelo de 1,5mm ou 2,5mm
01 – Tomada (Rede alternada de 127V)

Inicialmente vai ser necessário fazer a captura dos códigos infravermelho das teclas do controle remoto da TV.

Para captura de códigos IR e envio deles para o dispositivo a ser controlado através do Arduino, é necessário baixar e instalar a biblioteca IRremote:

Download IRremote

Se você não sabe como instalar bibliotecas na IDE do Arduino, basta clicar no link abaixo, seguir os passos, importar a biblioteca e retornar para continuar:

Arduino – Importando bibliotecas para a ID

Monte o seguinte esquema de ligação para clonar as teclas do controle remoto:

Conecte o Arduino ao computador através do cabo USB e em seguida abra a IDE e acesse o menu Arquivos > Exemplos > IRremote > IRrecvDump:

Este código disponível na biblioteca IRremote é que será utilizado para capturar as teclas do controle remoto. Carregue o código no Arduino.

Abra o monitor serial da IDE do Arduino, aponte o controle remoto para o fotorreceptor IR e aperte cada uma das teclas que deseja capturar o código IR:

1) No monitor serial é mostrado o protocolo para o sinal clonado e no meu caso o protocolo é o NEC. Em seguida é mostrado o código hexadecimal (HEX). O ideal é que pressione o mesmo botão mais de uma vez para confirmar que o código capturado está correto. Anote os códigos (HEX) que você clonar, pois você irá precisar deles a seguir.

2) Utilizei uma TV LG e o controle dela é bem simples de ser clonado e utiliza o protocolo NEC que é bem comum. Dependendo da marca da TV (ou outro dispositivo que queira clonar as teclas do controle remoto) pode ser um pouco mais complicado devido ao protocolo utilizado, comprimento do sinal e vários outros fatores.

Anote os códigos que você capturou e registre em uma planilha. Ao fim das capturas de tecla que fiz, minha tabela de códigos hexadecimais ficou desta forma:

Monte o seguinte esquema de ligação:

ATENÇÃO: MUITO CUIDADO AO EXECUTAR PRÁTICAS QUE ENVOLVAM TENSÃO / CORRENTE ALTERNADA! FAÇA TODAS AS LIGAÇÕES COM O CIRCUITO COMPLETAMENTE DESLIGADO E ANTES DE FAZER OS TESTES VERIFIQUE CADA UMA DAS LIGAÇÕES PARA ELIMINAR A POSSIBILIDADE DE CURTO ENTRE FASE / NEUTRO OU FASE / FASE.

Veja na imagem abaixo que deixei o LED Emissor IR apontado para o Receptor IR da TV:

Conecte o Arduino ao computador novamente, leia os comentários em cada linha do código para que você possa compreender o funcionamento e em seguida faça o carregamento no Arduino:

OBS: antes de carregar o código abaixo no Arduino, substitua os códigos hexadecimais (após o 0x) pelos códigos que você capturou.

#include <IRremote.h> //INCLUSÃO DE BIBLIOTECA

IRsend irsend; //PINO DIGITAL 3 (PINO PADRÃO UTILIZADO PELA IRREMOTE COM ARDUINO UNO)

const int pinoRele = 2; //PINO DIGITAL UTILIZADO PELO MÓDULO RELÉ

void setup(){
  Serial.begin(9600); //INICIALIZA A SERIAL
  pinMode(pinoRele, OUTPUT); //DEFINE O PINO COMO SAÍDA
  digitalWrite(pinoRele, HIGH); //MÓDULO RELÉ INICIA DESLIGADO
}

void loop() {
  
  switch (Serial.read()) { //RECEBE OS CARACTERES VINDOS PELA SERIAL E FAZ O TRATAMENTO
      case 'A':{ //CASO RECEBA A LETRA "A"
      digitalWrite(pinoRele, LOW); //LIGA O MÓDULO RELÉ (LÂMPADA ACENDE)
      break; //FINALIZA A EXECUÇÃO DO SWITCH
      }
      case 'B':{ //CASO RECEBA A LETRA "B", FAZ
      digitalWrite(pinoRele, HIGH); //DESLIGA O MÓDULO RELÉ (LÂMPADA APAGA)
      break; //FINALIZA A EXECUÇÃO DO SWITCH
      } 
      case 'C':{ //CASO RECEBA A LETRA "C", FAZ
      irsend.sendNEC(0x20DF10EF, 32); //LIGAR A TV / DESLIGAR A TV
      break; //FINALIZA A EXECUÇÃO DO SWITCH
      } 
      case 'D':{ //CASO RECEBA A LETRA "D", FAZ
      irsend.sendNEC(0x20DFD02F, 32); //ACESSA AS ENTRADAS DA TV
      break; //FINALIZA A EXECUÇÃO DO SWITCH
      } 
      case 'E':{ //CASO RECEBA A LETRA "E", FAZ
      irsend.sendNEC(0x20DFE01F, 32); //MOVE O CURSOR PARA A ESQUERDA / VOLTAR
      break; //FINALIZA A EXECUÇÃO DO SWITCH  
      }  
      case 'F':{ //CASO RECEBA A LETRA "F", FAZ
      irsend.sendNEC(0x20DF609F, 32); //MOVE O CURSOR PARA A DIREITA / AVANÇAR
      break; //FINALIZA A EXECUÇÃO DO SWITCH
      }
      case 'G':{ //CASO RECEBA A LETRA "G", FAZ
      irsend.sendNEC(0x20DF02FD, 32); //MOVE O CURSOR PARA CIMA
      break; //FINALIZA A EXECUÇÃO DO SWITCH
      }
      case 'H':{ //CASO RECEBA A LETRA "H", FAZ
      irsend.sendNEC(0x20DF827D, 32); //MOVE O CURSOR PARA BAIXO
      break; //FINALIZA A EXECUÇÃO DO SWITCH
      }
      case 'I':{ //CASO RECEBA A LETRA "I", FAZ
      irsend.sendNEC(0x20DF22DD, 32); //CONFIRMA A SELEÇÃO (OK / QUERO ASSISTIR ESTE / ABRIR)
      break; //FINALIZA A EXECUÇÃO DO SWITCH
      }
      case 'J':{ //CASO RECEBA A LETRA "J", FAZ
      irsend.sendNEC(0x20DF5DA2, 32); //PAUSA A REPRODUÇÃO
      break; //FINALIZA A EXECUÇÃO DO SWITCH
      }
      case 'K':{ //CASO RECEBA A LETRA "K", FAZ
      irsend.sendNEC(0x20DF0DF2, 32); //CONTINUA A REPRODUÇÃO
      break; //FINALIZA A EXECUÇÃO DO SWITCH
      }
      case 'L':{ //CASO RECEBA A LETRA "L", FAZ
      irsend.sendNEC(0x20DF40BF, 32); //AUMENTA O VOLUME
      break; //FINALIZA A EXECUÇÃO DO SWITCH
      }
      case 'M':{ //CASO RECEBA A LETRA "M", FAZ
      irsend.sendNEC(0x20DFC03F, 32); //DIMINUI O VOLUME
      break; //FINALIZA A EXECUÇÃO DO SWITCH
      }
      case 'N':{ //CASO RECEBA A LETRA "N", FAZ
      irsend.sendNEC(0x20DFDA25, 32); //SAIR
      break; //FINALIZA A EXECUÇÃO DO SWITCH
      }
   }
}

#include <IRremote.h> //INCLUSÃO DE BIBLIOTECA

IRsend irsend; //PINO DIGITAL 3 (PINO PADRÃO UTILIZADO PELA IRREMOTE COM ARDUINO UNO)

const int pinoRele = 2; //PINO DIGITAL UTILIZADO PELO MÓDULO RELÉ

void setup(){

Serial.begin(9600); //INICIALIZA A SERIAL

pinMode(pinoRele, OUTPUT); //DEFINE O PINO COMO SAÍDA

digitalWrite(pinoRele, HIGH); //MÓDULO RELÉ INICIA DESLIGADO

}

void loop() {

switch (Serial.read()) { //RECEBE OS CARACTERES VINDOS PELA SERIAL E FAZ O TRATAMENTO

case 'A':{ //CASO RECEBA A LETRA "A"

digitalWrite(pinoRele, LOW); //LIGA O MÓDULO RELÉ (LÂMPADA ACENDE)