Exemplo de Automação Residencial com IoT e utilizando protocolo MQTT
- #IoT
Neste artigo eu trago um exemplo prático de como você pode implementar uma conexão básica utilizando protocolo MQTT e 2 arduinos.
O protocolo MQTT e a lógica publisher-subscriber.
Se você deseja conectar sua casa ao futuro, controlando luzes, temperatura e muito mais com apenas um toque, você pode fazer uso da tecnologia IoT e do protocolo de comunicação MQTT. Ontem, eu um artigo publicado aqui na DIO (link para leitura) eu falei sobre do que se trata esse protocolo e seus aspectos técnicos.
Para aprofundar mais sobre este protocolo, é importante entender a lógica publisher-subscriber. Imagine um sistema de comunicação onde temos dois papéis principais: o publisher (emissor) e o subscriber (receptor). O publisher é responsável por enviar mensagens, enquanto o subscriber as recebe. O MQTT utiliza essa lógica para permitir a comunicação eficiente entre dispositivos.
No MQTT, a comunicação entre dispositivos é organizada em tópicos. Um tópico é uma espécie de canal de comunicação ao qual os dispositivos podem se inscrever (subscribe) para receber mensagens ou publicar (publish) mensagens nele. Os tópicos funcionam como etiquetas que ajudam a direcionar as mensagens para os destinatários corretos.
Por exemplo, em uma automação residencial, podemos ter um tópico chamado "casa/luzes" para controlar as luzes da casa. Os dispositivos interessados em receber informações sobre o estado das luzes podem se inscrever nesse tópico. Assim, quando uma mensagem é publicada nesse tópico com informações sobre ligar ou desligar as luzes, os dispositivos inscritos recebem essa mensagem e podem executar a ação apropriada.
Os tópicos no MQTT seguem uma hierarquia de níveis separados por barras (/), permitindo uma organização eficiente das mensagens. Por exemplo, podemos ter tópicos como "casa/sala/luzes" e "casa/cozinha/luzes" para controlar as luzes em diferentes ambientes da casa.
Ao utilizar o MQTT para a automação residencial com Arduino, você pode criar tópicos relevantes para cada funcionalidade que deseja controlar, como luzes, temperatura, segurança, entre outros. Dessa forma, você pode criar um sistema flexível e modular, onde diferentes dispositivos podem se comunicar de maneira eficiente por meio desses tópicos.
Exemplo de Automação Residencial com Arduino:
Agora que entendemos a lógica publisher-subscriber, vamos dar um exemplo prático de como utilizar o MQTT para criar uma automação residencial com o Arduino. Imagine que você queira controlar as luzes de sua casa remotamente através de um aplicativo no seu smartphone.
Primeiro, você precisa configurar o Arduino para se conectar ao broker MQTT e aguardar as mensagens. Utilize a biblioteca PubSubClient para facilitar essa tarefa. Aqui está um exemplo de código:
#include <WiFi.h>
#include <PubSubClient.h>
const char* ssid = "SUA_REDE_WIFI";
const char* password = "SUA_SENHA_WIFI";
const char* mqttServer = "SEU_BROKER_MQTT";
const int mqttPort = 1883;
WiFiClient espClient;
PubSubClient client(espClient);
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("WiFi conectado!");
Serial.println("IP: " + WiFi.localIP().toString());
client.setServer(mqttServer, mqttPort);
client.setCallback(callback);
while (!client.connected()) {
if (client.connect("arduino-client")) {
Serial.println("Conectado ao Broker MQTT!");
client.subscribe("casa/luzes");
} else {
Serial.print("Falha na conexão ao Broker MQTT. Tentando novamente em 5 segundos...");
delay(5000);
}
}
}
void loop() {
client.loop();
}
void callback(char* topic, byte* payload, unsigned int length) {
Serial.print("Mensagem recebida no tópico: ");
Serial.println(topic);
if (payload[0] == '1') {
Serial.println("Luzes ligadas!");
// Código para ligar as luzes
} else if (payload[0] == '0') {
Serial.println("Luzes desligadas!");
// Código para desligar as luzes
}
}
No exemplo acima, o Arduino se conecta ao broker MQTT, aguarda as mensagens no tópico "casa/luzes" e realiza as ações de ligar ou desligar as luzes de acordo com o payload da mensagem recebida.
Porém, ainda falta o elemento que escreve nos tópicos, ou seja, o publisher!
Com outro arduino, você pode utilizar o seguinte código:
#include <WiFi.h>
#include <PubSubClient.h>
const char* ssid = "SUA_REDE_WIFI";
const char* password = "SUA_SENHA_WIFI";
const char* mqttServer = "SEU_BROKER_MQTT";
const int mqttPort = 1883;
const int buttonPin = 2; // Pino do botão
int buttonState = 0; // Estado do botão
bool lightOn = false; // Estado atual das luzes
WiFiClient espClient;
PubSubClient client(espClient);
void setup() {
Serial.begin(115200);
pinMode(buttonPin, INPUT_PULLUP); // Configura o pino do botão como entrada com pull-up interno
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("WiFi conectado!");
Serial.println("IP: " + WiFi.localIP().toString());
client.setServer(mqttServer, mqttPort);
while (!client.connected()) {
if (client.connect("arduino-client")) {
Serial.println("Conectado ao Broker MQTT!");
} else {
Serial.print("Falha na conexão ao Broker MQTT. Tentando novamente em 5 segundos...");
delay(5000);
}
}
}
void loop() {
buttonState = digitalRead(buttonPin); // Lê o estado atual do botão
if (buttonState == LOW) { // Botão pressionado
if (!lightOn) { // Se as luzes estiverem desligadas, envia comando para ligá-las
client.publish("casa/luzes", "ligar");
lightOn = true; // Atualiza o estado das luzes
Serial.println("Luzes ligadas!");
} else { // Se as luzes estiverem ligadas, envia comando para desligá-las
client.publish("casa/luzes", "desligar");
lightOn = false; // Atualiza o estado das luzes
Serial.println("Luzes desligadas!");
}
delay(1000); // Debounce do botão
}
client.loop();
}
Neste exemplo, adicionamos um botão ao pino 2 do Arduino e utilizamos a função digitalRead() para ler o estado do botão. Se o botão for pressionado (estado LOW), o código verifica o estado atual das luzes. Se as luzes estiverem desligadas, envia um comando para ligá-las e atualiza o estado. Se as luzes estiverem ligadas, envia um comando para desligá-las e atualiza o estado.
OBS: Para funcionar corretamente o botão é necessário configurar o pino como entrada com pull-up interno. Você pode adaptar esse exemplo para controlar outras funcionalidades da automação residencial.
Com este exemplo completo de um publisher MQTT, que envia comandos para ligar ou desligar as luzes com base no estado de um botão, você pode fazer outras modificações e explorar mais possibilidades na parte de automação residencial.
Entenda mais sobre arduino e a biblioteca PubSubclient nos links abaixo:
#iot #internetdascoisas #internetofthings #domótica #automaçãoresidencial #mqtt
