Jarvis – Porta monitorada com NodeMCU WiFi ESP82666 e Sensor Magnético MC-38

Nesta postagem você vai aprender a utilizar o NodeMCU ESP8266 junto ao Jarvis para fazer o monitoramento de uma porta. Com o uso do Sensor Magnético MC-38 junto ao NodeMCU, o Jarvis vai conseguir identificar se a porta foi / está aberta ou fechada.

Na primeira postagem sobre o Jarvis que saiu aqui no blog, foi falado um pouco sobre a ferramenta, suas capacidades, compatibilidade e foi implementado uma prática com o intuito de demonstrar a integração entre o Jarvis e o Arduino. Acesse a postagem Jarvis – Controlando o seu Arduino por Comandos de Voz e veja todos os detalhes.

Já na segunda postagem, foi explicado passo a passo a solução que implementei para permitir a integração entre o Jarvis e o Arduino com feedback e confirmação das ações executadas. Acesse a publicação Jarvis – Feedback / Confirmação das ações executadas no Arduino para entender como foi implementado todo o processo e para ver os projetos práticos que foram executados como demonstração.

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

O uso do Arduino junto ao Jarvis sem integração com um módulo ou shield ethernet ou WiFi, nos limita a fazer o envio de informações do Jarvis para o Arduino através de cabo usando comunicação serial. Para vários projetos a comunicação via serial é suficiente, contudo, há situações em que é necessário o uso de comunicação sem fio para enviar comandos do Jarvis para a plataforma a ser controlada. Neste tipo de situação, caso esteja sendo usado um Arduino, por exemplo, as opções de envio de dados por conexão sem fio mais comuns são: radiofrequência e WiFi. No caso da radiofrequência, dependendo do projeto será necessário utilizar mais de um Arduino. Caso seja utilizado WiFi, será necessário o uso de um módulo ou shield WiFi.

Olhando todas estas questões, o mais viável e mais barato é usar uma plataforma que já possua conexão WiFi nativa e que possa ser programada da mesma forma que o Arduino. Portanto, a plataforma mais indicada neste caso é o ESP8266 ou as placas baseadas nele. No mercado há diversas placas baseadas no ESP8266, como, por exemplo, o NodeMCU e a Wemos D1.

Nesta prática será utilizado o NodeMCU V3 com a sua respectiva Base, contudo, caso você tenha o NodeMCU V2 ou a Wemos D1 poderá utilizá-los também, pois o esquema de ligação é compatível. O NodeMCU e a Wemos D1 são baseadas na mesma versão do ESP8266, que no caso é o ESP-12E.

A comunicação entre o Jarvis e o Arduino utilizando cabo é feita através da serial, onde o comando de voz é falado no microfone conectado ao computador, o Jarvis processa este comando e envia ao Arduino um determinado dado através da serial. Com o NodeMCU ESP8266 podemos usar o recurso de Tarefas Remotas que o Jarvis possui, onde é possível fazer o envio de requisições HTTP para um endereço IP e uma determinada ação poderá ser executada de acordo com o parâmetro recebido. Logo, podemos conectar ao NodeMCU módulos, sensores e componentes eletrônicos, por exemplo, e fazer o acionamento deles através de comunicação sem fio com o envio de requisições HTTP.

Para demonstrar a utilização do NodeMCU ESP866 com o Jarvis, optei por implementar um projeto de monitoramento de uma porta. Utilizei o Sensor Magnético MC-38 para verificar se a porta foi / está fechada ou aberta. O monitoramento da porta poderá ser ativado ou desativado através de comando de voz enviado ao Jarvis. Quando estiver ativado, sempre que o estado da porta mudar, o Jarvis irá avisar. Além disso, o estado da porta poderá ser consultado a partir de uma pergunta feita ao Jarvis e caso seja feito a consulta e o monitoramento esteja desativado, o Jarvis vai informar e perguntar se deseja ativar o monitoramento.

Assim como na publicação Jarvis – Feedback / Confirmação das ações executadas no Arduino, utilizei o Módulo YX6300 para possibilitar que o Jarvis possa dar feedback em relação as ações executadas. Este módulo é que permite o Jarvis informar se a porta foi / está fechada ou aberta. Optei também por usar um transmissor VHF e um receptor VHF. A saída de áudio do Módulo YX6300 é conectada ao transmissor e o receptor é conectado a entrada de microfone do computador. Logo, quando o arquivo de áudio for executado no Módulo YX6300, o receptor VHF vai captar o sinal de áudio, direcionar ao conector de microfone do computador, o Jarvis vai escutar e dar a resposta correspondente, que no caso é o feedback do estado atual da porta.

Os comandos de voz poderão ser enviados ao Jarvis através do microfone convencional que vai estar conectado ao computador ou via WiFi através do microfone do smartphone. Desta forma, o projeto fica 100% sem fio.

Para implementar esta prática você vai precisar dos seguintes itens:

01 – NodeMCU v3 Lolin WiFi ESP8266 ESP-12E (v2 Amica / Wemos D1 R2)
01 – Base Adaptador para NodeMCU V3
01 – Sensor Magnético com fio para Alarme MC-38
01 – Módulo YX6300 Leitor de Cartão com Saída de Áudio P2
01 – Micro Cartão de Memória
01 – Microfone Lapela Sem Fio MT-2205
06 – Cabos Jumper macho-fêmea
01 – Clip Conector de Bateria 9V com Plug P4
01 – Chave Gangorra KCD1-101 Preta 2T (Liga / Desliga)
01 – LED Difuso 5mm Verde
01 – Bateria 9V
01 – Cabo P2 Macho (em ambas as pontas)

Para poder prosseguir é altamente recomendado que você leia a postagem Jarvis – Feedback / Confirmação das ações executadas no Arduino para entender os passos que serão executados a seguir. Após a leitura, retorne para continuar.

No cartão de memória do Módulo YX6300 gravei três comandos de voz. No primeiro arquivo de áudio MP3 falo o comando “Aberta”, no segundo falo o comando “Fechada” e no terceiro e último comando falo “Desativado”. Considerando que o monitoramento esteja ativado, quando a porta for aberta, o arquivo de áudio 001 (Aberta) será executado, o áudio será direcionado do Módulo YX6300 para o transmissor VHF através do cabo P2 que conecta ambos, o sinal de áudio será direcionado ao receptor VHF que está conectado a entrada de microfone do computador, o Jarvis vai escutar o comando de voz “Aberta” e vai dar a resposta correspondente, que no caso é “A porta está aberta”. Para os comandos 002 (Fechada) e 003 (Desativado) o funcionamento é idêntico. Portanto, grave os seus comandos de voz no cartão de memória e insira o cartão no Módulo YX6300.

Conforme eu já havia mencionado anteriormente, os comandos de voz poderão ser enviados ao Jarvis através do microfone convencional que vai estar conectado ao computador ou pelo microfone do smartphone. Para utilizar o microfone do seu smartphone e enviar comandos ao Jarvis remotamente via WiFi, leia a postagem Jarvis – Utilizando o Smartphone como Microfone via WiFi e em seguida retorne para continuar.

Caso seu PC possua apenas uma entrada de microfone, você pode usar o Cabo 2X1 para conectar o microfone e o receptor VHF ao computador:

Monte o esquema de ligação a seguir para ser instalado na porta:

Nas imagens a seguir você pode ver como eu fiz a montagem e instalação na porta do meu escritório:

Em seguida, faça o download da biblioteca abaixo e instale na IDE do Arduino:

Download MD_YX6300

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 IDE

Considerando que você já tenha o pacote de bibliotecas do ESP8266 instalados no ambiente de programação do Arduino, copie o código abaixo e cole na IDE:

#include <ESP8266WiFi.h> //INCLUSÃO DE BIBLIOTECA
#include <WiFiClient.h> //INCLUSÃO DE BIBLIOTECA
#include <ESP8266WebServer.h> //INCLUSÃO DE BIBLIOTECA
#include <MD_YX5300.h> //INCLUSÃO DE BIBLIOTECA

#define Mp3_RX 5 //PINO RX (CONECTAR AO TX DO MÓDULO YX6300)
#define Mp3_TX 4 //PINO TX (CONECTAR AO RX DO MÓDULO YX6300)
#define pinoSensor 14 //PINO UTILIZADO PELO SENSOR MAGNÉTICO

MD_YX5300 mp3(Mp3_RX, Mp3_TX); //PASSA OS PARÂMETROS PARA A FUNÇÃO

const char* ssid = "NOME_DA_SUA_REDE_WIFI"; //VARIÁVEL QUE ARMAZENA O NOME DA REDE SEM FIO EM QUE VAI CONECTAR
const char* password = "SENHA_DA_SUA_REDE_WIFI"; //VARIÁVEL QUE ARMAZENA A SENHA DA REDE SEM FIO EM QUE VAI CONECTAR

IPAddress ip(192,168,0,175); //COLOQUE UMA FAIXA DE IP DISPONÍVEL DO SEU ROTEADOR
IPAddress gateway(192,168,0,1); //GATEWAY DE CONEXÃO (ALTERE PARA O GATEWAY DO SEU ROTEADOR)
IPAddress subnet(255,255,255,0); //MASCARA DE REDE (ALTERE PARA A SUA MÁSCARA DE REDE)

ESP8266WebServer server(80); //CRIA UM OBJETO PARA LIDAR COM AS REQUISIÇÕES HTTP NA PORTA 80

int statusPorta = 0; //VARIÁVEL DE CONTROLE (PORTA)
int statusMonitor = 0; //VARIÁVEL DE CONTROLE (MONITORAMENTO)
int leituraSensor = 0; //VARIÁVEL PARA ARMAZENAR LEITURA DO SENSOR
int mudancaStatus = 0; //VARIÁVEL DE CONTROLE (ESTADO INICIAL DA PORTA)

void handleRoot(){
  
  if(server.hasArg("ARG")){ //SE O PARÂMETRO RECEBIDO FOR IGUAL A "ARG", FAZ
      String valorARG; //DECLARAÇÃO DE VARIÁVEL DO TIPO STRING
      
    if(!server.hasArg("ARG")) return returnFail("BAD ARGS"); //SE PARÂMETRO RECEBIDO FOR DIFERENTE DE "ARG", RETORNA A MENSAGEM
        valorARG = server.arg("ARG"); //VARIÁVEL RECEBE O VALOR DO PARÂMETRO ARG
        
    if((valorARG == "1") && (statusMonitor == 0)){ //SE O VALOR DO PARÂMETRO FOR IGUAL A 1 E O MONITORAMENTO ESTIVER DESATIVADO, FAZ
         delay(700); //INTERVALO DE 700 MILISSEGUNDOS (TEMPO PARA O JARVIS CONCLUIR A RESPOSTA AO COMANDO RECEBIDO PELO MICROFONE)
         mp3.playSpecific(01, 003); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE O MONITORAMENTO ESTÁ DESATIVADO (PASTA 01 / ARQUIVO 003 = 003 OCTAL)
         server.send(200, "text/html", ""); //RETORNO DE INFORMAÇÃO HTML (NAVEGADOR)
    }
    if((valorARG == "1") && (statusMonitor == 1) && (statusPorta == 0)){ //SE O VALOR DO PARÂMETRO FOR IGUAL A 1 E O MONITORAMENTO
      //ESTIVER ATIVADO E A PORTA ESTIVER FECHADA, FAZ
         delay(700); //INTERVALO DE 700 MILISSEGUNDOS (TEMPO PARA O JARVIS CONCLUIR A RESPOSTA AO COMANDO RECEBIDO PELO MICROFONE)
         mp3.playSpecific(01, 002); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A PORTA ESTÁ FECHADA (PASTA 01 / ARQUIVO 002 = 002 OCTAL)
         server.send(200, "text/html", ""); //RETORNO DE INFORMAÇÃO HTML (NAVEGADOR)
    }
    if((valorARG == "1") && (statusMonitor == 1) && (statusPorta == 1)){ //SE O VALOR DO PARÂMETRO FOR IGUAL A 1 E O MONITORAMENTO
      //ESTIVER ATIVADO E A PORTA ESTIVER ABERTA, FAZ
         delay(700); //INTERVALO DE 700 MILISSEGUNDOS (TEMPO PARA O JARVIS CONCLUIR A RESPOSTA AO COMANDO RECEBIDO PELO MICROFONE)
         mp3.playSpecific(01, 001); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A PORTA ESTÁ ABERTA (PASTA 01 / ARQUIVO 001 = 001 OCTAL)
         server.send(200, "text/html", ""); //RETORNO DE INFORMAÇÃO HTML (NAVEGADOR)
    }
    if(valorARG == "2"){ //SE O VALOR DO PARÂMETRO FOR IGUAL A 2, FAZ
         statusMonitor = 1; //MONITORAMENTO ATIVADO
         server.send(200, "text/html", ""); //RETORNO DE INFORMAÇÃO HTML (NAVEGADOR)
    }
    if(valorARG == "3"){ //SE O VALOR DO PARÂMETRO FOR IGUAL A 3, FAZ
         statusMonitor = 0; //MONITORAMENTO DESATIVADO
         server.send(200, "text/html", ""); //RETORNO DE INFORMAÇÃO HTML (NAVEGADOR)
    }else{ //SENÃO, FAZ
          returnFail("Argumento inválido"); //IMPRIME O TEXTO NO NAVEGADOR
    }
  }else{ //SENÃO, FAZ
        server.send(200, "text/html", ""); //RETORNO DE INFORMAÇÃO HTML (NAVEGADOR)
  }
}

//FUNÇÃO DE RETORNO DE INFORMAÇÃO (FALHA)
void returnFail(String msg){
  
  server.sendHeader("Connection", "close");
  server.sendHeader("Access-Control-Allow-Origin", "*");
  server.send(500, "text/plain", msg + "\r\n");
}

//FUNÇÃO DE RETORNO DE INFORMAÇÃO (ERRO 404)
void handleNotFound(){
  
  String message = "File Not Found\n\n";
  message += "URI: ";
  message += server.uri();
  message += "\nMethod: ";
  message += (server.method() == HTTP_GET)?"GET":"POST";
  message += "\nArguments: ";
  message += server.args();
  message += "\n";
  for (uint8_t i=0; i<server.args(); i++){
    message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
  }
  server.send(404, "text/plain", message);
}

void setup(void){
  
  WiFi.begin(ssid, password); //PASSA OS PARÂMETROS PARA A FUNÇÃO QUE VAI FAZER A CONEXÃO COM A REDE SEM FIO
  WiFi.config(ip, gateway, subnet); //PASSA OS PARÂMETROS PARA A FUNÇÃO QUE VAI SETAR O IP FIXO NO NODEMCU
  
  //AGUARDA PELA CONEXÃO
  while (WiFi.status() != WL_CONNECTED) {
    delay(500); //INTERVALO DE 500 MILISSEGUNDOS
  }
  
  server.on("/", handleRoot); //CHAMA A FUNÇÃO handleRoot QUANDO O CLIENTE SOLICITAR UM URI "/"
  server.onNotFound(handleNotFound); //CHAMA A FUNÇÃO handleNotFound QUANDO O CLIENTE SOLICITAR UM URI DIFERENTE DE "/"
  server.begin(); //INICIALIZA O SERVIDOR WEB
  mp3.begin(); //INICIALIZA O MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO
  mp3.volume(30); //MÓDULO INICIA COM VOLUME MÁXIMO (30) NA SAÍDA DE ÁUDIO
  pinMode(pinoSensor, INPUT_PULLUP); //DEFINE O PINO COMO ENTRADA / "_PULLUP" É PARA ATIVAR O RESISTOR INTERNO
  //DO ARDUINO PARA GARANTIR QUE NÃO EXISTA FLUTUAÇÃO ENTRE 0 (LOW) E 1 (HIGH)
  leituraSensor = digitalRead(pinoSensor); //VARIÁVEL ARMAZENA A LEITURA DO PINO
  
  if(leituraSensor == LOW){ //SE A LEITURA DO PINO FOR IGUAL A LOW, FAZ
      mudancaStatus = 0; //PORTA INICIOU FECHADA
  }else{ //SENÃO, FAZ
        mudancaStatus = 1; //PORTA INICIOU ABERTA
  }
}

void loop(void){
  server.handleClient(); //CHAMA A FUNÇÃO RESPONSÁVEL POR ATENDER AS REQUISIÇÕES
  leituraSensor = digitalRead(pinoSensor); //VARIÁVEL ARMAZENA A LEITURA DO PINO
  
  if(leituraSensor == LOW){ //SE A LEITURA DO PINO FOR IGUAL A LOW, FAZ
        statusPorta = 0; //PORTA FECHADA
  }
  else{ //SENÃO, FAZ
      statusPorta = 1; //PORTA ABERTA
  }

  if((statusPorta == 0) && (mudancaStatus == 0) && (statusMonitor == 1)){ //SE A PORTA FOI FECHADA E O mudancaStatus FOR IGUAL A 0 E O MONITORAMENTO
      //ESTIVER ATIVADO, FAZ
        mp3.playSpecific(01, 002); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A PORTA FOI FECHADA (PASTA 01 / ARQUIVO 002 = 002 OCTAL)
        mudancaStatus = 1; //PORTA ABERTA
  }else{
    if((statusPorta == 1) && (mudancaStatus == 1) && (statusMonitor == 1)){
        mp3.playSpecific(01, 001); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A PORTA FOI ABERTA (PASTA 01 / ARQUIVO 001 = 001 OCTAL)
        mudancaStatus = 0; //PORTA FECHADA
    }
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

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

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

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

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

#define Mp3_RX 5 //PINO RX (CONECTAR AO TX DO MÓDULO YX6300)

#define Mp3_TX 4 //PINO TX (CONECTAR AO RX DO MÓDULO YX6300)

#define pinoSensor 14 //PINO UTILIZADO PELO SENSOR MAGNÉTICO

MD_YX5300 mp3(Mp3_RX, Mp3_TX); //PASSA OS PARÂMETROS PARA A FUNÇÃO

const char* ssid = "NOME_DA_SUA_REDE_WIFI"; //VARIÁVEL QUE ARMAZENA O NOME DA REDE SEM FIO EM QUE VAI CONECTAR

const char* password = "SENHA_DA_SUA_REDE_WIFI"; //VARIÁVEL QUE ARMAZENA A SENHA DA REDE SEM FIO EM QUE VAI CONECTAR

IPAddress ip(192,168,0,175); //COLOQUE UMA FAIXA DE IP DISPONÍVEL DO SEU ROTEADOR

IPAddress gateway(192,168,0,1); //GATEWAY DE CONEXÃO (ALTERE PARA O GATEWAY DO SEU ROTEADOR)

IPAddress subnet(255,255,255,0); //MASCARA DE REDE (ALTERE PARA A SUA MÁSCARA DE REDE)

ESP8266WebServer server(80); //CRIA UM OBJETO PARA LIDAR COM AS REQUISIÇÕES HTTP NA PORTA 80

int statusPorta = 0; //VARIÁVEL DE CONTROLE (PORTA)

int statusMonitor = 0; //VARIÁVEL DE CONTROLE (MONITORAMENTO)

int leituraSensor = 0; //VARIÁVEL PARA ARMAZENAR LEITURA DO SENSOR

int mudancaStatus = 0; //VARIÁVEL DE CONTROLE (ESTADO INICIAL DA PORTA)

void handleRoot(){

if(server.hasArg("ARG")){ //SE O PARÂMETRO RECEBIDO FOR IGUAL A "ARG", FAZ

String valorARG; //DECLARAÇÃO DE VARIÁVEL DO TIPO STRING

if(!server.hasArg("ARG")) return returnFail("BAD ARGS"); //SE PARÂMETRO RECEBIDO FOR DIFERENTE DE "ARG", RETORNA A MENSAGEM

valorARG = server.arg("ARG"); //VARIÁVEL RECEBE O VALOR DO PARÂMETRO ARG

if((valorARG == "1") && (statusMonitor == 0)){ //SE O VALOR DO PARÂMETRO FOR IGUAL A 1 E O MONITORAMENTO ESTIVER DESATIVADO, FAZ

delay(700); //INTERVALO DE 700 MILISSEGUNDOS (TEMPO PARA O JARVIS CONCLUIR A RESPOSTA AO COMANDO RECEBIDO PELO MICROFONE)

mp3.playSpecific(01, 003); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE O MONITORAMENTO ESTÁ DESATIVADO (PASTA 01 / ARQUIVO 003 = 003 OCTAL)