Controlando o ESP32 por comandos de voz via Google Assistant 20

Atualmente os assistentes de voz estão cada vez mais presentes no cotidiano das pessoas, muitas já utilizam os dispositivos em suas residências permitindo a interação e controle de diversos aparelhos como TV, ar condicionado, iluminação entre outros. Neste post mostraremos como é possível fazer a integração do ESP32 com um dos assistentes de voz mais conhecidos, o Google Assistant.

Esse projeto pode ser modificado para diversas aplicações como acionamento de eletroeletrônicos ou abertura/fechamento de portas.

Material necessário

Para controlar o ESP32 por comandos de voz via Google Assistant você precisará dos seguintes componentes:

• 1 x Módulo WiFi ESP32 Bluetooth
• 1 x Cabo Micro USB
• 1 x Módulo Buzzer Piezoelétrico 3.3V
• 1 x LED Amarelo
• 1 x LED Branco
• 1 x LED Vermelho
• 1 x LED Verde
• 1 x LED Azul
• 1 x LDR
• 5 x Resistores de 220 Ω 1/4W
• 1 x Resistor de 10k Ω 1/4W
• 1 x Protoboard
• Kit de Jumpers

Serviços Web Utilizados

Para controlar o ESP32 por comandos de voz utilizaremos, além do Google Assistant, alguns serviços para fazer conexão com o hardware. São eles:

• Adafruit IO 
• IFTT 
• Google Assistant

Para saber mais sobre o Adafruit IO, acesse o seguinte post: Adafruit IO – Uma nova plataforma de IoT

Circuito

Com todos os componentes em mãos vamos à montagem do circuito. Abaixo temos o esquemático eletrônico montado em protoboard:

Configuração Adafruit IO

Após realizada a montagem em protoboard, nós utilizaremos o servidor Adafruit IO para comandar a placa através da comunicação IFTTT. Precisamos criar botões para realizar a leitura do LDR e para acionar cada um dos LEDs.

Para começar a configuração acesse o site Adafruit IO. Clique em “Get Started for Free” e crie uma conta.

Após criada a conta clique em “Sign In” para conectar sua conta. Clique em “Dashboards” e depois “view all”.

Clique em “Actions” para criar um novo dashboard.

Insira o nome do dashboard e clique em “Create”. Após isso aparecerá a dashboard com o nome criado.

Dê um duplo clique no nome para abrir a interface com o usuário. Aparecerá uma tela como a imagem abaixo.

Clique no ícone azul com o sinal “+” para inserir os objetos e depois selecione “Toggle”.

Insira o nome da variável e clique em “Create” seguindo as imagens que apareceram em sequência abaixo. Obs: os nomes definidos abaixo não devem ser alterados, se caso feita alguma alteração, deverá também ser feita a alteração no código de programação.

Repita o mesmo procedimento para os demais. Ao final dessas etapas a sua tela ficará assim:

Agora vamos configurar cada variável, para isso siga os passos abaixo. Na lista “Group/Feed” selecione “LED Branco” e clique em “Next Step”.

Como mostra a imagem abaixo, coloque o nome em “Block Tittle” e mude os campos ON e OFF para 1 e 0, respectivamente.

Após isso clique em “Create Block”.

Repita o mesmo procedimento para os demais LEDs. Ao final do procedimento teremos uma tela com os botões mostrados na imagem abaixo:

Agora vamos as variáveis de “Alarme” e “Status Alarme”. Assim como o LED criaremos um botão para a variável “Alarme”. Então selecione o “Toggle”, selecione a variável “Alarme” na lista de “Group/Feed” e clique em “Next Step”.

Defina o nome como Alarme e mude o ON e OFF para 1 e 0, depois clique em “Create Block”.

Para última etapa teremos a variável de “Status Alarme” que ao invés de adicionarmos um botão, usaremos o “Indicator”. Ao adicionar um novo item no dashboard procure e selecione “Indicator” como mostra a imagem abaixo.

Na lista selecione a variável “Status Alarme” e defina os parâmetros como demonstrados abaixo.

Em “Conditions” defina como “=” e atribua o valor para 1 e depois clique em “Create Block”.

O resultado final será algo semelhante a imagem abaixo:

Para concluirmos a configuração do servidor, precisamos obter o Usuário e a Chave de comunicação para utilizarmos posteriormente na programação do ESP32.

Para esse procedimento clique no ícone em amarelo com o desenho de uma chave como mostra a imagem abaixo.

Copie o “Username” e a “Active Key” no bloco de notas para utilizarmos posteriormente. Após isso concluímos as configurações na Adafruit.

Programação

Na Arduino IDE vá em Arquivos > Preferências e adicione o link abaixo em “URLs Adicionais para Gerenciadores de Placas” e clique em OK.

https://dl.espressif.com/dl/package_esp32_index.json

Depois vá em Ferramentas > Placas > Gerenciador de Placas… e pesquise ESP32 e clique em instalar.

Após instalado a placa vá em Ferramentas > Placa e selecione a placa ESP32 Dev Module.

Após isso vá em Sketch > Incluir Biblioteca > Gerenciar Bibliotecas… e pesquise Adafruit MQTT e instale.

Agora podemos ir ao código para descarregar na ESP32. No início do código precisaremos colocar os parâmetros da rede WiFi e do servidor da Adafruit que anotamos anteriormente.

Adicione o nome da sua Rede Wifi e Senha, adicione também o Username e o Active Key obtidos anteriormente no Dashboard já criado.

Abaixo está o código para controlar o ESP32 por comandos de voz via Google Assistant:

//Bibliotecas utilizadas
#include <WiFi.h>
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"

//Definição dos pinos
#define LED_conexao  23
#define LED_azul     27
#define LED_verde    26
#define LED_vermelho 33
#define LED_branco   32
#define buzzer       14
#define LDR          36

#define WLAN_SSID       "nomedarede"      // Nome da Rede Wifi
#define WLAN_PASS       "senhadarede"     // Senha da Rede Wifi

/************************* Adafruit.io Configuração *********************************/

#define AIO_SERVER      "io.adafruit.com" //Adafruit Servidor
#define AIO_SERVERPORT  1883                  
#define AIO_USERNAME    "YYYYYYYYY"      //Insira o usuario criado na adafruit io
#define AIO_KEY         "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" //Insira a chave de comunicação obtida na adafruit io

//Váriáveis utilizadas

int conectado = 1;
int conexao = 0;
int alarme = 0;
int trava = 0;

unsigned long anterior = 0;
unsigned long intervalo = 15000;
unsigned long atual;

//Definição do Wifi Client
WiFiClient client;
Adafruit_MQTT_Client mqtt(&client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);

//Váriáveis criadas para comunicação com o MQTT
Adafruit_MQTT_Publish   sensor = Adafruit_MQTT_Publish  (&mqtt, AIO_USERNAME "/feeds/Status Alarme");   // Crie aqui sua variavel
Adafruit_MQTT_Subscribe Light1 = Adafruit_MQTT_Subscribe(&mqtt, AIO_USERNAME "/feeds/LED Azul");        // a palavra feeds deve estar em todos
Adafruit_MQTT_Subscribe Light2 = Adafruit_MQTT_Subscribe(&mqtt, AIO_USERNAME "/feeds/LED Verde");    
Adafruit_MQTT_Subscribe Light3 = Adafruit_MQTT_Subscribe(&mqtt, AIO_USERNAME "/feeds/LED Vermelho");
Adafruit_MQTT_Subscribe Light4 = Adafruit_MQTT_Subscribe(&mqtt, AIO_USERNAME "/feeds/LED Branco");
Adafruit_MQTT_Subscribe Light5 = Adafruit_MQTT_Subscribe(&mqtt, AIO_USERNAME "/feeds/Alarme");

//Funções
void MQTT_connect(); //Determina a conexão MQTT
void Conectar();     //Verifica a conexão o Wifi

void setup() {

  Serial.begin(115200);

  //Definição de saida e entrada de cada pino
  pinMode(LED_conexao,OUTPUT);
  pinMode(LED_azul,OUTPUT);
  pinMode(LED_verde,OUTPUT);
  pinMode(LED_vermelho,OUTPUT);
  pinMode(LED_branco, OUTPUT);
  pinMode(buzzer,OUTPUT);
  pinMode(LDR,INPUT);

  //Desliga o LED de status de conexão do Wifi
  digitalWrite(LED_conexao,LOW);
  
  //Declaração de Tópicos de Leitura
  mqtt.subscribe(&Light1);
  mqtt.subscribe(&Light3);
  mqtt.subscribe(&Light2);
  mqtt.subscribe(&Light4);
  mqtt.subscribe(&Light5);

}

void loop() {

  Conectar();
  MQTT_connect();

  //Leitura do valor recebido através da Adafruit IO
  Adafruit_MQTT_Subscribe *subscription;
  if((subscription = mqtt.readSubscription(100))) {
    if (subscription == &Light1) {
      Serial.print(F("Got: "));
      Serial.println((char *)Light1.lastread);
      int Light1_State = atoi((char *)Light1.lastread);
      digitalWrite(LED_azul, Light1_State);
    }
    if (subscription == &Light2) {
      Serial.print(F("Got: "));
      Serial.println((char *)Light2.lastread);
      int Light2_State = atoi((char *)Light2.lastread);
      digitalWrite(LED_verde, Light2_State);
    }
    if (subscription == &Light3) {
      Serial.print(F("Got: "));
      Serial.println((char *)Light3.lastread);
      int Light3_State = atoi((char *)Light3.lastread);
      digitalWrite(LED_vermelho, Light3_State);
    }
    if (subscription == &Light4) {
      Serial.print(F("Got: "));
      Serial.println((char *)Light4.lastread);
      int Light4_State = atoi((char *)Light4.lastread);
      digitalWrite(LED_branco, Light4_State);
    }
    if (subscription == &Light5) {
      Serial.print(F("Got: "));
      Serial.println((char *)Light5.lastread);
      int Light5_State = atoi((char *)Light5.lastread);
      alarme = Light5_State;
    }
  }
  if(alarme){
    //Leitura do LDR
    int leitura = analogRead(LDR);
    Serial.println(leitura);
    if(leitura < 2900){
      trava = 1;
      //Buzzer tocando intermitente
      digitalWrite(buzzer,HIGH);
      delay(500);
      digitalWrite(buzzer,LOW);
      delay(500);
    }
    atual = millis();
    if (atual - anterior > intervalo)
    {    
        if(trava == 1){
          //Tópico de publicação de acionamento do sensor
          sensor.publish(1);
          trava = 0;
        }
        else{
          //Tópico de publicação de desacionamento do sensor
          sensor.publish(0);
        }
        anterior = atual;
     }
  }
  else{
     //Desliga Buzzer
     digitalWrite(buzzer,LOW);
     trava = 0;
     atual = millis();
     if (atual - anterior > intervalo)
     {   
          sensor.publish(0);
          anterior = atual;
     }
  }
}

void MQTT_connect() {
  int8_t ret;
  //Conectando MQTT
  if (mqtt.connected()) {
    if(conectado){
      conectado = 0;
      Serial.println("MQTT Conectado!");
    }
    return;
  }
  Serial.print("Conectando MQTT...");
  uint8_t retries = 3;
  if((ret = mqtt.connect()) != 0) {
    Serial.println(mqtt.connectErrorString(ret));
    Serial.println("Reconexao ao MQTT em 5 segundos...");
    mqtt.disconnect();
    delay(5000);
    conectado = 1;
    //retries--;
    if (retries == 0) {
      //retries = 3;
    }
  }
}

void Conectar(){
  //Verifica a conexão wifi
  if(WiFi.status() != WL_CONNECTED){
      conexao = 0; 
      //Conectando ao Wifi
      Serial.println();
      Serial.println();
      Serial.print("Conectando a rede: ");
      Serial.println(WLAN_SSID);
      //Inicializa Conexão Wifi
      WiFi.begin(WLAN_SSID, WLAN_PASS);
      while(WiFi.status() != WL_CONNECTED) {
            digitalWrite(LED_conexao,LOW);
            delay(100);
            digitalWrite(LED_conexao,HIGH);
            delay(100);
            Serial.print(".");
            conexao++;
            if(conexao == 30){
              ESP.restart();
            }
      }
      Serial.println("WiFi conectado!");
      Serial.println("Endereco de IP: ");
      Serial.println(WiFi.localIP());
      digitalWrite(LED_conexao,HIGH);
      conectado = 1;
      Serial.println();
  }
}

Após descarregado o código vá no dashboard e tente acionar os LEDs através dos botões note que já é possível controlá-los.

Para finalizar o projeto concluiremos com a configuração do IFTTT e do aplicativo Google Assistant no smartphone.

Configuração IFTTT

Para configuramos o IFTTT é necessário também criar uma conta onde poderemos vincular a conta criada no Adafruit IO para interagirmos com o Google Assistant. Acesse o site a seguir e faça login com uma conta do Google.

Após logar com uma conta do Google vá no perfil e clique em “Create”.

Vai aparecer esta tela e então clique em “If This”.

Pesquise por ”Google Assistant” no campo de busca e clique no mesmo. Obs: Na primeira vez vai pedir autorização.

Clique em “Say a simple phrase”.

Na tela “Complete triggers fields” vamos definir os comandos de voz que serão utilizados através do app “Google Assistant”. Para cada LED será necessário aplicar dois comandos um para desligar e outro para ligar como o exemplo abaixo.

Depois de preencher os campos clique em Create e depois clique em “That”.

Pesquise por “Adafruit” clique no mesmo e vincule sua conta.

Clique em “Send data to Adafruit IO”.

Em “Complete action fields” selecione a variável que nós escolhemos para dar o comando, no caso utilizamos o comando “Turn on the LED White” que será utilizado para ligar o LED Branco, então selecionaremos a “variável LED Branco” e definiremos o “Data to save” para 1.

Após clicar em “Create” clique em “Finish”, para configurar o desligamento do LED faça o mesmo procedimento criando outro comando “Turn off the LED White” e definindo o “Data to save” para 0.

Bom agora como desafio crie os comandos para os outros LEDs o vermelho, verde e azul, o Alarme fica a seu critério de escolha qual comando irá ativá-lo.

Configuração Google Assistant

Para controlando o ESP32 por comandos de voz  nós vamos finalizar o projeto adicionando os comandos ao Google Assistant. Em seu smartphone se caso não estiver instalado baixe o app na Play Store em seguida faça login com a conta do Google utilizada para vincular o IFTTT.

Ao abrir o app vá na página do seu perfil e procure pela aba “Assistente” e navegue até “Rotinas”, clique em “+ Acionar uma rotina” e siga os passos nas imagens abaixo.

Crie a rotina também para desligar o LED.

Resultado

Bom agora só testar o comando e usar sua criatividade para melhorar o projeto, e como desafio explorar os acionamentos dos outros LEDs e do Buzzer apenas aplicando a implantação dos comandos necessários como você já observou anteriormente.

Gostou de aprender a controlar o ESP32 por comandos de voz via Google Assistant? Deixe seu comentário logo abaixo.