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.
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.
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- Led Alto Brilho Branco – 5mm
Caso não tenha, você pode adquiri-los clicando em cada componente ou acessando o nosso site: https://www.curtocircuito.com.br/
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.
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.
O ESP8266 apresenta algumas vantagens em relação Arduino Uno R3, essas diferenças são expressas na tabela a seguir:
Para mais informações da placa, acesse:
Datasheet: NodeMCU V3 - ESP8266 - CH340
Sendo a pinagem da placa expressa pela seguinte ilustração:
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 é:
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.
Na IDE, clique em Arquivo> Preferências
Em seguida, clique nesse pequeno ícone ao lado da caixa de texto, uma janela será aberta.
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
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...
Uma janela será aberta, procure: esp8266 e ao encontrar o esp8266 by ESP8266 Community clique em Instalar.
Depois de instalar, clique em 
Confira se sua placa está disponível em Ferramentas> Placa:______
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...
Realize uma busca por “PubSubClient”, instale a biblioteca feita por Nick O’Leary clicando em Instalar.
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
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:
Dessa forma:
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.
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.
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.
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”.
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.
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 
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”.
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”.
Depois criaremos o nosso Publicador, responsável por publicar a mensagem no ESP8266, assinaremos o tópico “subscricao_do_esp8266”.
Realizando todas as configurações, voltaremos para a IDE e compilaremos nosso programa clicando em 
Aguarde até o seu programa ser compilado, quando surgir a mensagem informando que ele está carregado, pressione o reset (RST) do seu microcontrolador.
Para monitoramento do nosso programa rodando no ESP8266, vamos abrir o Monitor Serial. Para isso devemos clicar em 
, localizado no canto superior direito da IDE.
O nosso microcontrolador foi conectado e iniciou as publicações periódicas, vamos conferir 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”.
Abrimos o monitor serial para conferir se a mensagem chegou ao ESP8266.
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.
No nosso monitor conseguimos visualizar a mensagem encaminhada
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 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...
Ao abrir a janela, faça uma busca por DHT e instale a versão mais recente da biblioteca da Adafruit clicando em “Instalar”.
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.
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.
Terminamos de declarar nossas variáveis
No laço de configurações, faremos as configurações necessárias para o DHT realizar as leituras.
Seguidamente, definiremos os pinos correspondentes aos LEDs e o modo de operação (INPUT/OUTPUT), tendo em mente a tabela dos pinos ESP8266 - IDE.
No laço de configuração do WiFi, definiremos como o ESP8266 vai se comportar durante uma tentativa de conexão WiFi, e depois.
Em callback, ou retorno, faremos as configurações da mensagem para ser publicada de forma correta no tópico.
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.
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.
Em loop faremos as configurações do sensor para que realizemos as publicações de medições na serial e nos tópicos correspondentes.
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:
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
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.
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.
Clique no projeto que você criou para iniciarmos a montagem da Dashboard.
Ao abrir a nossa Dashboard, clicaremos no + para inserção dos widgets que usaremos.
Primeiramente colocaremos o texto indicando o Status da lâmpada do cômodo em questão, para isso selecionaremos a opção “Text”.
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
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.
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.
Minha configuração de interruptor ficou da seguinte forma:
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:
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
Agora vamos inserir as medições de temperatura e umidade, para isso, vamos em + > Range/progress
Vamos nos inscrever em Topic(sub): casa/temperatura e 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.
Faremos o mesmo para umidade, sendo Topic(sub) : casa/umidade e unidade em porcentagem.
O seu dashboard deve ficar dessa forma:
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 :)
Sim, é possível controlar a temperatura e umidade de um ambiente utilizando diversos tipos de sensores e atuadores.
No caso de uma horta, por exemplo, alguns itens necessários são: exaustores de calor como dutos de ventilação ou ventiladores para remover o calor de dentro desta horta, bem como sensores de temperatura e umidade para monitoramento destas variáveis.
Atuadores também são necessários como, por exemplo, válvulas solenoides para abrir e fechar o fluxo de água dentro da estufa. Esse controle de água também pode ser utilizado para borrifar água no ar, melhorando a umidade do local.
Em outros tipos de projetos também é possível realizar este tipo de controle, mas isso é algo que vai variar conforme a necessidade do seu projeto.
char* message = "OFF_LINE";
int length = strlen(message);
boolean retained = true; //Retain message
client.publish("arduinoClient234", (byte*)message, length, retained) ;
Abraços :)
Um grande abraço :)