Objetivo

           Com o conhecimento adquirido em: Introdução ao MQTT, Segurança no MQTT e Certificados de Segurança no MQTT. Apresentaremos nesse tutorial um protótipo de monitoramento e controle de residência através do aplicativo mobile chamado: MQTTDash e o broker MQTTBox, esse último já explanado anteriormente. O propósito desse tutorial é exemplificar o funcionamento prático da comunicação MQTT, de forma a fixar o conteúdo aprendido e te auxiliar em seus projetos pessoais. Dividiremos essa postagem nos seguintes tópicos: -Clique se quiser ser encaminhado(a) para algum trecho específico do texto.

 

Introdução

Lista de Materiais

MQTT

NodeMCU V3 - ESP8266 LoLin

DHT22

Como baixar a placa ESP8266 na IDE do Arduino

Baixando a Biblioteca PubSubClient

Configurando o MQTTBox para o ESP8266

Protótipo de Casa Monitorada - Montagem na Protoboard 

Protótipo de Casa Monitorada - Biblioteca DHT

Protótipo de Casa Monitorada - Programação

Protótipo de Casa Monitorada - MQTTBox

Protótipo de Casa Monitorada - Aplicativo

Protótipo de Casa Monitorada - Funcionando

 

Para acompanhar esse tutorial é necessário que você tenha visto os tutoriais anteriores, pois trabalharemos com conhecimentos adquiridos previamente, além de utilizarmos a ferramenta MQTTBox, apresentada em: Introdução ao MQTT

 

Introdução

 

           Em meio ao avanço da tecnologia e as infinitas possibilidades que surgiram com esse crescimento, surgiu a domótica. Originada da palavra francesa Domotique, sendo que domus significa casa e imotique automático, a palavra é constantemente utilizada quando nos referimos a Casas Inteligentes, essas casas são otimizadas para que seu controle e monitoramento seja realizado por um software, de forma a oferecer maior comodidade e segurança aos moradores. Outrossim, um projeto de automação residencial pode ser voltado para acessibilidade, pois com um aplicativo mobile, um cadeirante consegue ter controle da iluminação de sua residência sem precisar acionar os interruptores correspondentes. Um outro uso é em projetos sustentáveis, com o monitoramento é possível controlar gastos desnecessários com energia elétrica.

           No nosso projeto, vamos controlar 4 Leds de forma a simular a iluminação de quatro cômodos diferentes de uma casa, sendo esses: Sala, Quarto, Cozinha e Banheiro, além disso, vamos monitorar a temperatura e a umidade.


Domótica


Lista de Materiais:
           Para concluir a atividade disposta nesse tutorial, tenha os seguintes componentes:

 

01- Placa NodeMCU V3 - ESP8266 - CH340

01- Cabo micro USB

04- Jumper Macho-macho

04- Led Alto Brilho Branco – 5mm

04- Resistor 220Ω

01- Módulo Sensor DHT22

02- Protoboard 400 pontos

 

           Caso não tenha, você pode adquiri-los clicando em cada componente ou acessando o nosso site: https://www.curtocircuito.com.br/

MQTT

 

            Para realização do nosso protótipo faremos uso da comunicação MQTT, explanada nos tutoriais anteriores. O MQTT é um protocolo de comunicação voltado para o uso em IoT- Internet of Things, em português, Internet das Coisas. É leve e seu funcionamento se baseia na troca de informações entre Subscriber(Subscrito) e Publisher(Publicador), sendo que o mensageiro responsável por encaminhar e receber os dados é chamado de broker, podendo esse ser hospedado na nuvem ou local.

 

           O exemplo abaixo é semelhante ao nosso protótipo, o sensor de temperatura atua como Publisher e publica o dado medido no tópico “temp”, esse dado é transmitido ao Broker que encaminha para todos os clientes que estão subscritos nesse mesmo tópico “temp”, no caso, o Computador e o Celular. Para maior compreensão do MQTT, consulte os tutoriais anteriores.

 

MQTT Funcionamento

NodeMCU V3 - ESP8266 LoLin

 

            Para realizar essa comunicação, é necessário o uso da internet, em razão disso, utilizaremos o NodeMCU V3 - ESP8266 (LoLin), que é uma placa microcontroladora que realiza comunicação WiFi sem a necessidade do uso de um módulo externo para isso.

ESP8266

          O ESP8266 apresenta algumas vantagens em relação Arduino Uno R3, essas diferenças são expressas na tabela a seguir:

Comparação Arduino e ESP8266

          Para mais informações da placa, acesse:

 

Datasheet: NodeMCU V3 - ESP8266 - CH340

 

          Sendo a pinagem da placa expressa pela seguinte ilustração:


Pinos ESP8266 LoLin
Tabela ESP8266 Pinos


DHT22

 

           O DHT22 é um sensor que realiza medições de umidade e temperatura, permitindo leituras na faixa dos -40°C a 80°C, com umidade de 0 a 100%. Seu funcionamento é baseado no uso de um sensor capacitivo de umidade e um termistor, com função de medir a temperatura do ar circundante. Utilizaremos o módulo DHT22, que é esse mesmo sensor em sua forma embarcada.

 

           A pinagem do DHT22 e do módulo DHT22 é:

Pinos DHT22

 

            Note que o módulo não conta com o pino ENB, pois o mesmo não é necessário para uso do sensor.

 

            Abra a sua IDE do Arduino e prossiga com o tutorial, caso não tenha, baixe e instale gratuitamente através do site oficial:

 

https://www.arduino.cc/en/main/software#

 

            Se tiver, prossiga com o tutorial.

 

            Como baixar a placa ESP8266 na IDE do Arduino

 

            Se você nunca utilizou a placa ESP8266 com a IDE do Arduino, será necessário instalar a extensão de placa Generic ESP8266 Module na IDE.

 

            Realize uma busca caso queira confirmar. Na Interface da IDE, clique no canto superior em Ferramentas > Placa:_______ , em seguida realize uma busca pelos modelos de placa, procure a Generic ESP8266 Module, caso não tenha, ensinaremos o processo para inserção da mesma, do contrário, pule essa etapa do tutorial.

Busca pela placa Generic ESP8266 na IDE
           Na IDE, clique em Arquivo> Preferências

 

Preferências IDE

           Em seguida, clique nesse pequeno ícone ao lado da caixa de texto, uma janela será aberta.

Inclusão de placas na IDE

           
             Insira o link abaixo na caixa de texto, caso já tenha algum link nesse espaço, não apague, pressione ENTER para ir para a linha seguinte e cole o novo link:

 

http://arduino.esp8266.com/stable/package_esp8266com_index.json

código placa ESP8266 na IDE

           Clique em   e em seguida clique  em  novamente.

           De volta à tela inicial do Arduino, entre novamente em Ferramentas>Placa:_____ e vá para Gerenciador de Placas...


Gerenciador de placas da IDE

 

 

             
           Uma janela será aberta, procure: esp8266e ao encontrar o esp8266 by ESP8266 Communityclique em Instalar.

Instalar placa na IDE

 

 

           Depois de instalar, clique em fechar
           Confira se sua placa está disponível em Ferramentas> Placa:______

Generic ESP8266 Module


Baixando a Biblioteca PubSubClient

 

           Para realizar a nossa comunicação MQTT com o ESP8266 é necessário que seja instalada a Biblioteca PubSubClient.

 

           Clique em Ferramentas>Gerenciar Bibliotecas...

Gerenciar Bibliotecas

           Realize uma busca por “PubSubClient”, instale a biblioteca feita por Nick O’Leary clicando em Instalar.

PubSubClient

            Depois de instalar, vamos voltar para a tela inicial do Arduino e abrir o exemplo dedicado ao ESP8266.

 

            Clique em Arquivo>Exemplos>PubSubClient>mqtt_esp8266

Exemplo PubSubClient

           Tendo aberto o programa, vamos realizar as configurações iniciais para teste de comunicação MQTT entre o ESP8266 e a plataforma MQTTBox.

 

           Para esse teste inicial, eu vou inserir o nome da minha rede Wi-Fi e a senha da mesma nos seguintes espaços:

Conexão Wi-Fi ESP8266

           Dessa forma:

ESP8266 Wi-Fi

           Por enquanto usarei o broker do próprio programa.

 

           Prosseguindo com as configurações, agora vou configurar os tópicos de publicação e assinatura do ESP8266.

Tópicos MQTT

             Vou modificar o nome dos meus tópicos, é importante realizar essa mudança porque esses tópicos são do exemplo, em razão disso, muitas pessoas publicam e subscrevem neles, o que dificulta a análise.

Publicação e Subscrição no ESP8266

 

           No final do programa existe mais uma função de client.publish, insira o mesmo nome de tópico que você colocou no client.publish anterior.

Função de publicação do ESP8266

            Abaixo está disponível esse exemplo, eu me permiti fazer mais algumas alterações que não interferem no funcionamento, traduzi as frases que serão printadas e modifiquei o tempo da mensagem que será encaminhada periodicamente, além disso, comentei cada função para facilitar a compreensão do código.

 

/************************************************************************ 
* Programa: Tutorial Comunicação MQTT 
* Autor: Curto Circuito 
* Descrição: Programa baseado no exemplo mqtt_esp8266 do autor Nick O'Leary 
**************************************************************************/

#include <ESP8266WiFi.h>
#include <PubSubClient.h>



const char* ssid = "Nome da Rede";                                
const char* password = "senhadarede";                                    
const char* mqtt_server = "broker.mqtt-dashboard.com";                  

WiFiClient espClient;                                                   
PubSubClient client(espClient);                                         
unsigned long lastMsg = 0;
#define MSG_BUFFER_SIZE (50)
char msg[MSG_BUFFER_SIZE];
int value = 0;

void setup() {                                                          
  pinMode(BUILTIN_LED, OUTPUT);                                         
  Serial.begin(115200);                                                 
  setup_wifi();                                                         
  client.setServer(mqtt_server, 1883);                                  
  client.setCallback(callback);                                         
}

void setup_wifi() {                                                     

  delay(10);                                                            
  Serial.println();                                                     
  Serial.print("Conectando com ");                                       
  Serial.println(ssid);                                                 
             
  WiFi.begin(ssid, password);                                           
 
  while (WiFi.status() != WL_CONNECTED) {                               
    delay(500);                                                         
    Serial.print(".");                                                  
  }
  randomSeed(micros());
  Serial.println();                                                     
  Serial.println("WiFi conectado");                                     
  Serial.println("Endereço de IP: ");                                   
  Serial.println(WiFi.localIP());                                       
}

void callback(char* topic, byte* payload, unsigned int length) {        
  Serial.print("Mensagem recebida [");                                  
  Serial.print(topic);                                                  
  Serial.print("] ");                                                   
  for (int i = 0; i < length; i++) {                                    
    Serial.print((char)payload[i]);                                     
  }
  Serial.println();                                                     

  if ((char)payload[0] == '1') {                                        
    digitalWrite(BUILTIN_LED, LOW);                                     
  } else {                                                              
    digitalWrite(BUILTIN_LED, HIGH);                                    
  }

}

void reconnect() {                                                       
  while (!client.connected()) {                                          
    Serial.print("Aguardando conexão MQTT...");                          
    if (client.connect("ESP8266Client")) {                               
      Serial.println("conectado");                                       
      client.publish("publicacao_do_esp8266", "hello world");    
      client.subscribe("subscricao_do_esp8266");                         
    } else {                                                             
      Serial.print("falhou, rc=");                                       
      Serial.print(client.state());                                      
      Serial.println(" tente novamente em 5s");                          
      delay(5000);                                                       
    }
  }
}
void loop() {                                                            

  if (!client.connected()) {                                             
    reconnect();
  }
  client.loop();                                                         

  long now = millis();                                                   
  if (now - lastMsg > 5000) {                                            
    lastMsg = now;                                                       
    ++value;                                                             
    snprintf (msg, 75, "hello world #%ld", value);               
    Serial.print("Publica mensagem: ");                                  
    Serial.println(msg);                                                 
    client.publish("publicacao_do_esp8266", msg);                        
  }
}

/************************ FIM DO PROGRAMA***************************/

 

 

           Depois de inserir o código na sua IDE, conecte o ESP8266 ao computador através de um cabo USB, selecione a placa como “Generic ESP8266 Module”.

Generic ESP8266 Module Arduino

             Em seguida, selecione a porta disponível, lembrando que o número da COM pode variar, não se preocupe caso a sua não seja COM18.

Porta COM


Configurando o MQTTBox para o ESP8266

           Abra o MQTTBox, caso não saiba mexer nessa ferramenta, veja os tutoriais anteriores sobre o MQTT.

 

           Ao abrir, clique em Create MQTT Client
           Crie um nome para esse cliente MQTT em “MQTT Client Name”, modifique o protocolo “Protocol” para mqtt/tcp e insira o broker utilizado em nosso programa em “Host”.


MQTTBox pré configuração

 

           Finalizando essa configuração inicial, clique em “Save”.

 

           Vamos agora criar o nosso Subscrito, devemos realizar a inscrição no tópico que vai receber a publicação do ESP8266, nomeamos de “publicacao_do_esp8266”.

Publicação no esp8266

           Depois criaremos o nosso Publicador, responsável por publicar a mensagem no ESP8266, assinaremos o tópico “subscricao_do_esp8266”.

Publisher MQTTBox

           Realizando todas as configurações, voltaremos para a IDE e compilaremos nosso programa clicando em  Compilar

           Aguarde até o seu programa ser compilado, quando surgir a mensagem informando que ele está carregado, pressione o reset (RST) do seu microcontrolador.

Carregado

 

           Para monitoramento do nosso programa rodando no ESP8266, vamos abrir o Monitor Serial. Para isso devemos clicar em COM , localizado no canto superior direito da IDE.

Monitor Serial

           O nosso microcontrolador foi conectado e iniciou as publicações periódicas, vamos conferir no MQTTBox.

Publicação do ESP8266 no MQTTBox

           O ESP8266 está funcionando perfeitamente como Publicador, publicando mensagens para o Subscrito do MQTTBox, agora vamos testar o ESP8266 como Subscrito, digitaremos uma mensagem no tópico “Topic to publish” e clicaremos em “Publish”.

Publicação do MQTTBox no ESP8266

           Abrimos o monitor serial para conferir se a mensagem chegou ao ESP8266.

MQTTBox publicando mensagem no monitor serial

           Agora publicaremos o 1 para nos certificarmos que o ESP8266 está respondendo às mensagens publicadas, na programação definimos que se fosse publicado o número 1, o LED interno do ESP8266 acenderia, caso contrário, apagaria ou permaneceria apagado.
Acendendo um LED MQTT
           No nosso monitor conseguimos visualizar a mensagem encaminhada

Mensagem publicada no ESP8266 pelo MQTTBox

 

           E o ESP8266 se comporta como o esperado

 


Protótipo de Casa Monitorada –Montagem na Protoboard

 

            De posse dos componentes necessários e de ciência do funcionamento de cada parte, monte o protótipo abaixo. Como o software utilizado (Fritzing) para montagem não conta com o Módulo Sensor DHT22, eu utilizei o Sensor DHT22, note que eu não fiz a ligação do terceiro pino, você também pode utilizar o sensor caso não tenha o módulo, ligando exatamente dessa forma.


Protótipo ligação ESP8266 com DHT22 e LEDsProtótipo MQTT casa monitorada e controlada ESP8266

Protótipo de Casa Monitorada –Biblioteca DHT

           Para a nossa programação, utilizaremos a biblioteca do Sensor DHT, caso você não tenha, siga esse passo a passo para inserir na sua IDE.

 

           Clique em Ferramentas > Gerenciar Bibliotecas...

Gerenciar bibliotecas

 

            Ao abrir a janela, faça uma busca por DHTe instale a versão mais recente da biblioteca da Adafruit clicando em “Instalar”.

DHT biblioteca


Protótipo de Casa Monitorada –Programação

 

           Depois de realizada a montagem do protótipo e as bibliotecas pertinentes ao proposto tiverem sido baixadas (PubSubClient.h e DHT.h), vamos iniciar a nossa programação.

 

Primeiro incluímos as bibliotecas, definimos os pinos, constantes e variáveis.

Programação 1

 

           Em seguida vamos estabelecer a conexão com o broker, para isso precisamos fazer as configurações de Internet, inserimos nosso SSID (nome da rede) e password (senha da rede), logo em seguida definimos um broker para troca de dados, utilizamos o mesmo broker do exemplo para ESP8266 da biblioteca PubSubClient.

PubSubClient rede

 

           Terminamos de declarar nossas variáveis

Programação 3

 

           No laço de configurações, faremos as configurações necessárias para o DHT realizar as leituras.

Programação 4

 

           Seguidamente, definiremos os pinos correspondentes aos LEDs e o modo de operação (INPUT/OUTPUT), tendo em mente a tabela dos pinos ESP8266  - IDE.

Programação 5

 

           No laço de configuração do WiFi, definiremos como o ESP8266 vai se comportar durante uma tentativa de conexão WiFi, e depois.

Programação 6

 

           Em callback, ou retorno, faremos as configurações da mensagem para ser publicada de forma correta no tópico.

Programação 6

 

           Em seguida realizaremos um processo que repetiremos para cada LED (Lâmpada de um cômodo da casa), definiremos que se o ESP8266 receber uma mensagem referente à inicial maiúscula desse cômodo, o LED vai acender, se receber a letra minúscula, o LED vai apagar, ou seja:

 

Inicial em caixa alta: Nível lógico alto

Inicial em caixa baixa: Nível lógico baixo

 

           Essa mensagem será publicada no tópico casa/publisher, enquanto uma mensagem do estado da lâmpada será publicada no tópico referente ao cômodo, no exemplo da sala: casa/sala.

Programação 8

 

           No laço de reconexão, criaremos um ID de cliente randômico, e faremos as configurações necessárias para a reconexão, caso a conexão seja perdida.

Programação 9

 

           Em loop faremos as configurações do sensor para que realizemos as publicações de medições na serial e nos tópicos correspondentes.

Programação 10
Programação 10

 

           O programa na íntegra está disponível abaixo, assim como o anterior, todas as funções estão comentadas para facilitar o entendimento.

 

/**************** Programa: Tutorial Casa Monitorada * 
Autor: Curto Circuito *
Descrição: Programa de monitoramento e controle residencial através de aplicativo *
em comunicação MQTT com o ESP8266
******************************************************************************/
#include <ESP8266WiFi.h> #include <PubSubClient.h> #define MSG_BUFFER_SIZE (50) char msg[MSG_BUFFER_SIZE]; #include <Adafruit_Sensor.h> #include <DHT.h> #include <DHT_U.h> #define DHTPIN 5 #define DHTTYPE DHT22 DHT_Unified dht(DHTPIN, DHTTYPE); uint32_t delayMS; const char* ssid = "Minha rede"; const char* password = "senhadarede"; const char* mqtt_server = "broker.mqtt-dashboard.com"; WiFiClient espClient; PubSubClient client(espClient); unsigned long lastMsg = 0; int value = 0; char Sala; char Quarto; char Cozinha; char Banheiro; void setup() { dht.begin(); Serial.println(F("Sensor DHT22")); sensor_t sensor; dht.temperature().getSensor(&sensor); Serial.println(F("------------------------------------")); Serial.println(F("Temperatura")); Serial.print (F("Sensor: ")); Serial.println(sensor.name); Serial.print (F("Valor máximo: ")); Serial.print(sensor.max_value); Serial.println(F("°C")); Serial.print (F("Valor mínimo: ")); Serial.print(sensor.min_value); Serial.println(F("°C")); Serial.print (F("Resolução: ")); Serial.print(sensor.resolution); Serial.println(F("°C")); Serial.println(F("------------------------------------")); dht.humidity().getSensor(&sensor); Serial.println(F("------------------------------------")); Serial.println(F("Umidade")); Serial.print (F("Sensor: ")); Serial.println(sensor.name); Serial.print (F("Valor máximo: ")); Serial.print(sensor.max_value); Serial.println(F("%")); Serial.print (F("Valor mínimo: ")); Serial.print(sensor.min_value); Serial.println(F("%")); Serial.print (F("Resolução: ")); Serial.print(sensor.resolution); Serial.println(F("%")); Serial.println(F("------------------------------------")); delayMS = sensor.min_delay / 1000; Sala = 4; Quarto = 2; Cozinha = 14; Banheiro = 13; pinMode(Sala, OUTPUT); pinMode(Quarto, OUTPUT); pinMode(Cozinha, OUTPUT); pinMode(Banheiro, OUTPUT); Serial.begin(115200); setup_wifi(); client.setServer(mqtt_server, 1883); client.setCallback(callback); } void setup_wifi() { delay(10); Serial.println(""); Serial.print("Conectando com "); Serial.println(ssid); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(""); Serial.println("WiFi conectado"); Serial.println("IP: "); Serial.println(WiFi.localIP()); } void callback(char* topic, byte* payload, unsigned int length) { Serial.print("Mensagem recebida ["); Serial.print(topic); Serial.print("] "); for (int i = 0; i < length; i++) { Serial.print((char)payload[i]); } Serial.println(""); if ((char)payload[0] == 'S') { digitalWrite(Sala, HIGH); snprintf (msg, MSG_BUFFER_SIZE, "A luz da sala está ligada"); Serial.print("Publica mensagem: "); Serial.println(msg); client.publish("casa/sala", msg); } Serial.println(""); if ((char)payload[0] == 's') { digitalWrite(Sala, LOW); snprintf (msg, MSG_BUFFER_SIZE, "A luz da sala está desligada"); Serial.print("Publica mensagem: "); Serial.println(msg); client.publish("casa/sala", msg); } Serial.println(""); if ((char)payload[0] == 'Q') { digitalWrite(Quarto, HIGH); snprintf (msg, MSG_BUFFER_SIZE, "A luz do quarto está ligada"); Serial.print("Publica mensagem: "); Serial.println(msg); client.publish("casa/quarto", msg); } Serial.println(""); if ((char)payload[0] == 'q') { digitalWrite(Quarto, LOW); snprintf (msg, MSG_BUFFER_SIZE, "A luz do quarto está desligada"); Serial.print("Publica mensagem: "); Serial.println(msg); client.publish("casa/quarto", msg); } Serial.println(""); if ((char)payload[0] == 'C') { digitalWrite(Cozinha, HIGH); snprintf (msg, MSG_BUFFER_SIZE, "A luz da cozinha está ligada"); Serial.print("Publica mensagem: "); Serial.println(msg); client.publish("casa/cozinha", msg); } Serial.println(""); if ((char)payload[0] == 'c') { digitalWrite(Cozinha, LOW); snprintf (msg, MSG_BUFFER_SIZE, "A luz da cozinha está desligada"); Serial.print("Publica mensagem: "); Serial.println(msg); client.publish("casa/cozinha", msg); } Serial.println(""); if ((char)payload[0] == 'B') { digitalWrite(Banheiro, HIGH); snprintf (msg, MSG_BUFFER_SIZE, "A luz do banheiro está ligada"); Serial.print("Publica mensagem: "); Serial.println(msg); client.publish("casa/banheiro", msg); } Serial.println(""); if ((char)payload[0] == 'b') { digitalWrite(Banheiro, LOW); snprintf (msg, MSG_BUFFER_SIZE, "A luz do banheiro está desligada"); Serial.print("Publica mensagem: "); Serial.println(msg); client.publish("casa/banheiro", msg); } } void reconnect() { while (!client.connected()) { Serial.print("Aguardando conexão MQTT..."); String clientId = "ESP8266Client"; clientId += String(random(0xffff), HEX); if (client.connect(clientId.c_str())) { Serial.println("conectado"); client.subscribe("casa/publisher"); } else { Serial.print("falhou, rc="); Serial.print(client.state()); Serial.println("tente novamente em 5s"); delay(5000); } } } void loop() { delay(delayMS); sensors_event_t event; dht.temperature().getEvent(&event); if (isnan(event.temperature)) { Serial.println(F("Erro na leitura da temperatura!")); } else { Serial.print(F("Temperatura: ")); Serial.print(event.temperature); Serial.println(F("°C")); sprintf(msg,"%f",event.temperature); client.publish("casa/temperatura", msg); } dht.humidity().getEvent(&event); if (isnan(event.relative_humidity)) { Serial.println(F("Erro na leitura da umidade!")); } else { Serial.print(F("Umidade: ")); Serial.print(event.relative_humidity); Serial.println(F("%")); sprintf(msg,"%f",event.relative_humidity); client.publish("casa/umidade", msg); } if (!client.connected()) { reconnect(); } client.loop(); }

 

 

Protótipo de Casa Monitorada –MQTTBox

            Vamos criar um novo cliente da mesma forma que fizemos anteriormente, adicionaremos um Publisher e seis Subscribers, sendo quatro destinados aos cômodos, um à temperatura e um à umidade, dessa forma:

MQTTBox layout

MQTTBox layout 2

MQTTBox 3 Laayout

Protótipo de Casa Monitorada –Aplicativo

             Para monitoramento e controle via aplicativo, utilizaremos um aplicativo mobile chamado “MQTTDash”, o mesmo encontra-se disponível na Play Store para download gratuito

MQTTDash na Playstore

 

            Depois de finalizado o processo de baixar e instalar, abra o seu aplicativo e crie um novo arquivo clicando no + no canto superior direito da tela.

 

            Adicionar novo projeto

 

 

 

            Agora faremos as pré-configurações do nosso projeto mobile, selecionaremos a opção de conexão automática,  criaremos o nome do projeto “Name”, o endereço do broker “Adress”, o "Port" e deixaremos as outras configurações da mesma forma. Clique no disquete no canto superior para salvar.
MQTTDash pré-configurações

 

           Clique no projeto que você criou para iniciarmos a montagem da Dashboard.

MQTT Dash

 

           Ao abrir a nossa Dashboard, clicaremos no + para inserção dos widgets que usaremos.

Adicionar widgets MQTTDash

 

           Primeiramente colocaremos o texto indicando o Status da lâmpada do cômodo em questão, para isso selecionaremos a opção “Text”.

Widget text mqttdash

 

            Primeiro, criaremos um nome para a nossa caixa de texto, depois configuraremos para que essa caixa de texto se inscreva para receber a informação publicada no tópico do cômodo que ela representa, por exemplo: Para caixa de texto do status da sala, usaremos: Topic(sub): casa/sala

Inserção de texto 1
Inserção de texto 2

 

            Como a nossa mensagem é um pouco longa, definimos o Main text size (tamanho do texto) para Small(pequeno).

           Você também pode definir a cor do texto em Main text color (cor do texto) se assim desejar.

            Depois de configurar, clique no disquete para Salvar.

 

            Concluindo esse processo de monitoramento, vamos incluir nosso botão para controle da lâmpada desse mesmo cômodo. Novamente na parte de Widgets, vamos selecionar Switch/button.
 

Widget button

 

            Assim como fizemos com a caixa de texto, vamos criar um nome, em Topic (sub) nos inscreveremos no publisher, sendo: casa/publisher. Em Topic (pub), colocaremos igualmente o tópico: casa/publisher.Ou seja, esse botão receberá toda informação que for publicada (incluindo as do MQTTBox), e terá o direito de publicar no ESP8266. Além disso, mudarei o 1 do modo ON e o 0 do modo OFF para as letras correspondentes ao cômodo, igualmente, mudarei as cores e os ícones do botão, sendo isso apenas um floreio opcional.


Configurações do botão MQTTDash     
           Minha configuração de interruptor ficou da seguinte forma:
Interruptor MQTTDash

 

           Depois disso, faremos o mesmo para todos os cômodos da casa: modificando os tópicos da caixa de texto para o cômodo de monitoramento, em botão mudaremos as inicias que farão o LED acender ou apagar, e adicionaremos ícones e cores para deixar o aplicativo mais lúdico, sendo essas as configurações primordiais:

Tabela de cômodos para widget text
Tabela cômodos com o modo Switch

           Atentando-se para o seguinte fator: Se você quiser que sua Dashboard fique com o layout semelhante ao que fizemos, insira um text e em seguida o switch daquele mesmo cômodo, de forma revezada, assim: text da sala > switch/button da sala> text do quarto > switch/button do quarto> text da cozinha > switch/button da cozinha > tex do banheiro > switch/button do banheiro

MQTTDash casa inteligente controle iluminação

 

            Agora vamos inserir as medições de temperatura e umidade, para isso, vamos em +> Range/progress

MQTTDash barra de progresso

 

           Vamos nos inscrever em Topic(sub): casa/temperaturae fazer configurações básicas de cor e precisão 2 para aparecerem dois números após a vírgula. Também vamos inserir a unidade C° em postfix.

Temperatura


Faremos o mesmo para umidade, sendo Topic(sub) : casa/umidade e unidade em porcentagem.

Umidade MQTTDash

Sensor de Umidade MQTTDash
         O seu dashboard deve ficar dessa forma:

MQTTDash Projeto

Dashboard completo MQTTDash

 

 

 

Projeto de Casa Monitorada -Funcionamento

           Depois de realizar a compilação do programa, vamos testar o aplicativo

  
            E o funcionamento através do MQTTBox ficou da seguinte forma:



Conclusão

           A Comunicação via protocolo MQTT se mostrou eficaz na transmissão e recepção de dados. O Funcionamento dos tópicos, publicador e subscrito também atuaram de acordo com o exposto nos tutoriais anteriores, com isso, sabemos que podemos contar com esse tipo de comunicação para os nossos projetos de IoT, abrindo a possibilidade de colocar o nosso microcontrolador como emissor (publicador) e receptor (subscrito). Nos próximos tutoriais vamos criar uma comunicação segura para esse mesmo projeto, além de criarmos um Dashboard para PC via IO Adafruit.
Nao esqueça de deixar o seu feedback e qualquer dúvida nos comentários abaixo.

Abraços, Equipe Curto Circuito :)