Monitoramento Remoto de Sensores com ESP32 e MQTT

Por Que Usar o ESP32 e MQTT para Monitoramento Remoto?🔗

O monitoramento remoto de sensores é essencial em diversas aplicações, desde a automação residencial até a indústria 4.0. O ESP32, com seu baixo custo e alto desempenho, é ideal para essas tarefas. Já o MQTT é um protocolo de comunicação leve, perfeito para dispositivos com recursos limitados e com necessidade de comunicação eficiente e em tempo real.

Componentes Necessários🔗

Para seguir este projeto, você vai precisar dos seguintes componentes:

• ESP32
• Sensor de Temperatura e Umidade DHT11 ou DHT22
• Protoboard e Jumpers
• Cabo USB para programação do ESP32
• Computador com Arduino IDE instalado

Conectando o Sensor ao ESP32🔗

Esquema de Ligação

O sensor DHT11/DHT22 é fácil de usar e fornece leituras de temperatura e umidade. Vamos conectar o sensor ao ESP32 conforme o esquema abaixo:

• Pino VCC do DHT: Conecte ao pino 3.3V do ESP32.
• Pino GND do DHT: Conecte ao GND do ESP32.
• Pino Data do DHT: Conecte ao pino GPIO 4 do ESP32.

Nota: Alguns sensores DHT possuem quatro pinos. Neste caso, geralmente o quarto pino não é utilizado ou é outro GND.

Configurando o Ambiente de Desenvolvimento🔗

Antes de começarmos a programar, certifique-se de que o Arduino IDE está configurado para o ESP32. Se não estiver, siga os passos abaixo:

1. Abra o Arduino IDE.

2. Vá em Arquivo > Preferências.

3. No campo URLs Adicionais para Gerenciadores de Placas, adicione:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

4. Clique em OK.

5. Vá em Ferramentas > Placa > Gerenciador de Placas.

6. Pesquise por ESP32 e instale o pacote ESP32 by Espressif Systems.

Instalando Bibliotecas Necessárias

Vamos precisar das seguintes bibliotecas:

• DHT sensor library: para comunicação com o sensor DHT.
• PubSubClient: para comunicação MQTT.

Para instalar:

1. Vá em Sketch > Incluir Biblioteca > Gerenciar Bibliotecas.

2. Pesquise por DHT sensor library e instale a biblioteca de Adafruit.

3. Pesquise por Adafruit Unified Sensor e instale.

4. Pesquise por PubSubClient e instale.

Escrevendo o Código para o ESP32🔗

Vamos escrever um código que lê os dados do sensor e publica esses dados em um broker MQTT.

Configurando Credenciais Wi-Fi e MQTT

Primeiro, vamos definir as credenciais da rede Wi-Fi e do broker MQTT:

#include <WiFi.h>
#include <PubSubClient.h>
#include "DHT.h"
#define DHTPIN 4     // Pino onde o DHT está conectado
#define DHTTYPE DHT22   // Defina DHT11 ou DHT22
const char* ssid = "SEU_SSID";
const char* password = "SUA_SENHA";
const char* mqtt_server = "ENDERECO_DO_MQTT_BROKER";
WiFiClient espClient;
PubSubClient client(espClient);
DHT dht(DHTPIN, DHTTYPE);

Configurando a Conexão Wi-Fi

No setup(), vamos conectar o ESP32 à rede Wi-Fi:

void setup()
{
  Serial.begin(115200);
  delay(10);
  dht.begin();
  WiFi.begin(ssid, password);
  Serial.println();
  Serial.print("Conectando-se a ");
  Serial.println(ssid);
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.println("WiFi conectado");
  Serial.println("Endereço IP: ");
  Serial.println(WiFi.localIP());
  client.setServer(mqtt_server, 1883);
}

Função para Reconectar ao MQTT

Caso a conexão com o broker seja perdida, precisamos reconectar:

void reconnect()
{
  while (!client.connected())
  {
    Serial.print("Tentando conexão MQTT...");
    // Cria um ID de cliente aleatório
    String clientId = "ESP32Client-";
    clientId += String(random(0xffff), HEX);
    if (client.connect(clientId.c_str()))
    {
      Serial.println("Conectado");
    }
    else
    {
      Serial.print("Falha, rc=");
      Serial.print(client.state());
      Serial.println(" Tentando novamente em 5 segundos");
      delay(5000);
    }
  }
}

Loop Principal

No loop(), vamos ler os dados do sensor e publicar via MQTT:

void loop()
{
  if (!client.connected())
  {
    reconnect();
  }
  client.loop();
  float temperatura = dht.readTemperature();
  float umidade = dht.readHumidity();
  // Verifica se houve falha na leitura do sensor
  if (isnan(temperatura) || isnan(umidade))
  {
    Serial.println("Falha na leitura do sensor DHT!");
    return;
  }
  // Converte os valores para string
  char tempString[8];
  dtostrf(temperatura, 1, 2, tempString);
  char umidString[8];
  dtostrf(umidade, 1, 2, umidString);
  // Publica os dados no broker MQTT
  client.publish("casa/sala/temperatura", tempString);
  client.publish("casa/sala/umidade", umidString);
  Serial.print("Temperatura: ");
  Serial.print(temperatura);
  Serial.println(" *C");
  Serial.print("Umidade: ");
  Serial.print(umidade);
  Serial.println(" %");
  // Aguarda 10 segundos antes da próxima leitura
  delay(10000);
}

Código Completo

Segue o código completo para copiar e colar no Arduino IDE:

#include <WiFi.h>
#include <PubSubClient.h>
#include "DHT.h"
#define DHTPIN 4     // Pino onde o DHT está conectado
#define DHTTYPE DHT22   // Defina DHT11 ou DHT22
const char* ssid = "SEU_SSID";
const char* password = "SUA_SENHA";
const char* mqtt_server = "ENDERECO_DO_MQTT_BROKER";
WiFiClient espClient;
PubSubClient client(espClient);
DHT dht(DHTPIN, DHTTYPE);
void setup()
{
  Serial.begin(115200);
  delay(10);
  dht.begin();
  WiFi.begin(ssid, password);
  Serial.println();
  Serial.print("Conectando-se a ");
  Serial.println(ssid);
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.println("WiFi conectado");
  Serial.println("Endereço IP: ");
  Serial.println(WiFi.localIP());
  client.setServer(mqtt_server, 1883);
}
void reconnect()
{
  while (!client.connected())
  {
    Serial.print("Tentando conexão MQTT...");
    String clientId = "ESP32Client-";
    clientId += String(random(0xffff), HEX);
    if (client.connect(clientId.c_str()))
    {
      Serial.println("Conectado");
    }
    else
    {
      Serial.print("Falha, rc=");
      Serial.print(client.state());
      Serial.println(" Tentando novamente em 5 segundos");
      delay(5000);
    }
  }
}
void loop()
{
  if (!client.connected())
  {
    reconnect();
  }
  client.loop();
  float temperatura = dht.readTemperature();
  float umidade = dht.readHumidity();
  if (isnan(temperatura) || isnan(umidade))
  {
    Serial.println("Falha na leitura do sensor DHT!");
    return;
  }
  char tempString[8];
  dtostrf(temperatura, 1, 2, tempString);
  char umidString[8];
  dtostrf(umidade, 1, 2, umidString);
  client.publish("casa/sala/temperatura", tempString);
  client.publish("casa/sala/umidade", umidString);
  Serial.print("Temperatura: ");
  Serial.print(temperatura);
  Serial.println(" *C");
  Serial.print("Umidade: ");
  Serial.print(umidade);
  Serial.println(" %");
  delay(10000);
}

Explicação do Código🔗

Vamos analisar as partes-chave do código para entender seu funcionamento.

Incluindo Bibliotecas

Utilizamos as bibliotecas WiFi.h para conexão Wi-Fi, PubSubClient.h para MQTT e DHT.h para o sensor:

#include <WiFi.h>
#include <PubSubClient.h>
#include "DHT.h"

Definindo Constantes e Variáveis

Definimos o pino do sensor, o tipo do DHT, as credenciais Wi-Fi e o endereço do broker MQTT:

#define DHTPIN 4
#define DHTTYPE DHT22
const char* ssid = "SEU_SSID";
const char* password = "SUA_SENHA";
const char* mqtt_server = "ENDERECO_DO_MQTT_BROKER";

Configurando o Setup

No setup(), inicializamos a comunicação serial, o sensor DHT e conectamos ao Wi-Fi:

void setup()
{
  Serial.begin(115200);
  dht.begin();
  WiFi.begin(ssid, password);
  // Código de conexão Wi-Fi...
}

Configuramos também o servidor MQTT:

client.setServer(mqtt_server, 1883);

Loop Principal

No loop(), verificamos se estamos conectados ao broker MQTT e, caso não estejamos, chamamos reconnect(). Em seguida, lemos os dados do sensor e publicamos:

void loop()
{
  if (!client.connected())
  {
    reconnect();
  }
  client.loop();
  float temperatura = dht.readTemperature();
  float umidade = dht.readHumidity();
  // Verificação e publicação dos dados...
}

Função de Reconexão

A função reconnect() tenta conectar ao broker MQTT. Se não conseguir, aguarda 5 segundos e tenta novamente:

void reconnect()
{
  while (!client.connected())
  {
    // Tenta conectar...
  }
}

Configurando o Broker MQTT🔗

Para receber os dados publicados pelo ESP32, precisamos de um broker MQTT. Existem várias opções:

• Broker Local: Usando um computador com o Mosquitto instalado.
• Broker em Nuvem: Serviços como o HiveMQ, CloudMQTT ou Adafruit IO.

Usando o Mosquitto Localmente

Se optar por um broker local, siga os passos:

1. Instale o Mosquitto no seu computador.

2. Inicie o serviço do Mosquitto.

3. Use o endereço IP do computador como mqtt_server no código.

Testando a Publicação de Dados

Para verificar se os dados estão sendo publicados, podemos usar um cliente MQTT:

• MQTT.fx: Aplicativo desktop para assinatura de tópicos MQTT.
• MQTTLens: Extensão para navegadores como o Chrome.

Assine os tópicos:

• casa/sala/temperatura
• casa/sala/umidade

Você deverá ver as leituras do sensor sendo atualizadas a cada 10 segundos.

Aplicações Práticas🔗

Com o monitoramento remoto configurado, as possibilidades são inúmeras:

• Automação Residencial: Monitorar temperatura e umidade em diferentes cômodos.
• Agricultura Inteligente: Coletar dados ambientais para otimizar a irrigação.
• Monitoramento Industrial: Acompanhar condições em equipamentos e ambientes de trabalho.

Expandindo o Projeto🔗

Este projeto pode ser expandido de várias formas:

• Adicionando Mais Sensores: Como sensores de luminosidade, gases ou presença.
• Controlando Dispositivos: Receber comandos via MQTT para acionar relés ou atuadores.
• Integração com Bancos de Dados: Armazenar os dados coletados para análises futuras.
• Visualização em Dashboards: Usar plataformas como o Grafana ou ThingsBoard para criar painéis em tempo real.

Considerações Finais🔗

O uso do ESP32 combinado com o MQTT oferece uma solução robusta para monitoramento remoto de sensores. Com este conhecimento, você pode criar sistemas eficientes de coleta de dados, acessíveis de qualquer lugar. Lembre-se de sempre considerar aspectos de segurança, como autenticação e criptografia, ao implementar soluções em ambientes reais.

Dicas e Resolução de Problemas🔗

• Falha na Leitura do Sensor: Verifique as conexões e certifique-se de que o pino definido no código corresponde ao pino físico usado.
• Não Consegue Conectar ao Wi-Fi: Confirme as credenciais da rede e a proximidade do ESP32 ao roteador.
• Problemas com o Broker MQTT: Certifique-se de que o broker está ativo e acessível a partir da rede onde o ESP32 está conectado.
• Mensagens Não Recebidas: Verifique se os tópicos assinados correspondem exatamente aos publicados. O MQTT diferencia maiúsculas de minúsculas e espaços.

Segurança no Monitoramento Remoto🔗

Embora não tenhamos aprofundado neste artigo, é vital considerar a segurança ao enviar dados pela rede. O MQTT suporta autenticação com usuário e senha, além de criptografia TLS. Em projetos comerciais ou que lidem com informações sensíveis, implemente essas camadas adicionais de segurança para proteger seus dados e dispositivos.

Referências🔗

• Arduino IDE Official Website arduino.cc
• Documentação da Espressif docs.espressif.com
• Documentação de Apresentação do ESP32 espressif.com/en/products/socs/esp32
• Documentação do ESP32 Arduino Core docs.espressif.com/projects/arduino-esp32
• Repositório do ESP32 Arduino Core github.com/espressif/arduino-esp32