Programando o ESP32 para Publicar Dados via MQTT

O Que é MQTT e Por Que Usá-lo com o ESP32?🔗

MQTT é um protocolo de comunicação leve e eficiente, projetado especificamente para dispositivos que possuem recursos limitados, como é o caso do ESP32. Ele funciona no modelo publish/subscribe, onde dispositivos podem publicar mensagens em tópicos específicos, enquanto outros assinam esses tópicos para receber as mensagens.

Vantagens do MQTT

• Baixa Latência: Ideal para aplicações que requerem respostas rápidas.
• Baixo Consumo de Rede: Utiliza pacotes pequenos, economizando banda.
• Escalabilidade: Suporta um grande número de dispositivos conectados simultaneamente.
• Confiabilidade: Possui mecanismos de qualidade de serviço (QoS) que garantem a entrega das mensagens.

Preparando o Ambiente de Desenvolvimento🔗

Antes de começar a programar, precisamos preparar nosso ambiente:

1. Instalar o Arduino IDE: Se ainda não o fez, baixe e instale a versão mais recente do Arduino IDE.

2. Configurar Suporte ao ESP32: No Arduino IDE, vá em Arquivo > Preferências, e adicione o seguinte URL aos URLs Adicionais para Gerenciadores de Placas:

https://dl.espressif.com/dl/package_esp32_index.json

3. Instalar as Bibliotecas Necessárias: Vá em Ferramentas > Placa > Gerenciador de Placas, procure por "ESP32" e instale o pacote.

4. Biblioteca PubSubClient: Precisamos desta biblioteca para utilizar o MQTT. Vá em Sketch > Incluir Biblioteca > Gerenciar Bibliotecas, procure por "PubSubClient" e instale-a.

Circuito Básico🔗

Para este projeto, não precisaremos de um circuito complexo. Apenas conecte o ESP32 ao computador via cabo USB. No entanto, para fins ilustrativos, vamos simular a leitura de um sensor de temperatura e umidade (como o DHT11 ou DHT22). Se tiver um desses sensores, você pode conectá-lo seguindo este esquema:

• VCC do Sensor: Conectar ao 3.3V do ESP32.
• GND do Sensor: Conectar ao GND do ESP32.
• Data do Sensor: Conectar ao pino GPIO 4 do ESP32.

Programando o ESP32🔗

Importando as Bibliotecas Necessárias

Vamos começar importando as bibliotecas que usaremos em nosso código.

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

Definindo as Constantes e Variáveis

Defina as credenciais da sua rede Wi-Fi, o endereço do broker MQTT e outras configurações.

// Configurações da rede Wi-Fi
const char* ssid = "SEU_SSID";
const char* password = "SUA_SENHA";
// Configurações do MQTT
const char* mqtt_server = "test.mosquitto.org";
const int mqtt_port = 1883;
const char* mqtt_user = "";
const char* mqtt_password = "";
// Configurações do sensor DHT
#define DHTPIN 4      // Pino onde o sensor está conectado
#define DHTTYPE DHT22 // Tipo do sensor DHT11 ou DHT22
DHT dht(DHTPIN, DHTTYPE);

Configurando o Cliente Wi-Fi e MQTT

Crie instâncias dos clientes Wi-Fi e MQTT.

WiFiClient espClient;
PubSubClient client(espClient);

Função de Conexão ao Wi-Fi

Implemente uma função para conectar o ESP32 à rede Wi-Fi.

void setup_wifi()
{
  delay(10);
  Serial.println();
  Serial.print("Conectando-se à rede ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("Wi-Fi conectado");
  Serial.print("Endereço IP: ");
  Serial.println(WiFi.localIP());
}

Função de Reconexão ao Broker MQTT

Se a conexão com o broker MQTT for perdida, precisamos reconectá-la.

void reconnect()
{
  while (!client.connected())
  {
    Serial.print("Conectando ao broker MQTT...");
    String clientId = "ESP32Client-";
    clientId += String(random(0xffff), HEX);
    if (client.connect(clientId.c_str(), mqtt_user, mqtt_password))
    {
      Serial.println("Conectado");
    }
    else
    {
      Serial.print("Falha, rc=");
      Serial.print(client.state());
      Serial.println(" Tentando novamente em 5 segundos");
      delay(5000);
    }
  }
}

Configurando o Setup

Na função setup(), inicializamos a comunicação serial, conectamos ao Wi-Fi, configuramos o cliente MQTT e inicializamos o sensor DHT.

void setup()
{
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, mqtt_port);
  dht.begin();
}

Loop Principal

No loop(), certificamos que estamos conectados ao broker MQTT, lemos os dados do sensor e publicamos os valores.

void loop()
{
  if (!client.connected())
  {
    reconnect();
  }
  client.loop();
  // Leitura dos dados do sensor
  float temperatura = dht.readTemperature();
  float umidade = dht.readHumidity();
  // Verifica se a leitura falhou
  if (isnan(temperatura) || isnan(umidade))
  {
    Serial.println("Falha ao ler do sensor DHT");
    return;
  }
  // Exibe os valores no Serial Monitor
  Serial.print("Temperatura: ");
  Serial.print(temperatura);
  Serial.print(" °C | Umidade: ");
  Serial.print(umidade);
  Serial.println(" %");
  // Converte os valores para string
  char tempString[8];
  dtostrf(temperatura, 1, 2, tempString);
  char umidString[8];
  dtostrf(umidade, 1, 2, umidString);
  // Publica os valores nos tópicos MQTT
  client.publish("casa/sala/temperatura", tempString);
  client.publish("casa/sala/umidade", umidString);
  // Aguarda 10 segundos antes de ler novamente
  delay(10000);
}

Explicação Detalhada do Código🔗

Conexão Wi-Fi

A função setup_wifi() é responsável por conectar o ESP32 à rede Wi-Fi. Utilizamos WiFi.begin(ssid, password) para iniciar a conexão e, em seguida, aguardamos até que o status seja WL_CONNECTED.

Cliente MQTT

Criamos um cliente MQTT com PubSubClient client(espClient);, onde espClient é o cliente Wi-Fi. Configuramos o servidor MQTT com client.setServer(mqtt_server, mqtt_port);.

Reconexão ao Broker MQTT

A função reconnect() tenta reconectar ao broker MQTT em caso de perda de conexão. Ela gera um ID de cliente único para cada tentativa e utiliza client.connect(clientId.c_str(), mqtt_user, mqtt_password) para estabelecer a conexão.

Leitura do Sensor e Publicação dos Dados

No loop principal, lemos os valores de temperatura e umidade usando dht.readTemperature() e dht.readHumidity(). Em seguida, verificamos se a leitura foi bem-sucedida. Convertimos os valores para strings e usamos client.publish(tópico, mensagem) para publicar nos tópicos MQTT desejados.

Testando a Publicação dos Dados🔗

Para verificar se os dados estão sendo publicados corretamente, podemos utilizar um cliente MQTT, como o MQTT Explorer ou o MQTT.fx. Siga os passos abaixo:

1. Instale um Cliente MQTT: Baixe e instale um cliente de sua preferência.

2. Conecte ao Broker MQTT: Use o mesmo broker especificado no código (por exemplo, test.mosquitto.org).

3. Assine os Tópicos: Inscreva-se nos tópicos casa/sala/temperatura e casa/sala/umidade.

4. Monitore as Mensagens: Você deverá ver os valores de temperatura e umidade sendo atualizados a cada 10 segundos.

Personalizando os Tópicos e Mensagens🔗

Os tópicos que escolhemos (casa/sala/temperatura e casa/sala/umidade) são exemplos. Você pode personalizá-los de acordo com a estrutura do seu projeto.

Estrutura de Tópicos

Uma boa prática é utilizar uma estrutura hierárquica nos tópicos, facilitando a organização e o gerenciamento dos dados. Por exemplo:

• projeto/local/dispositivo/medida

Exemplo:

• meuProjeto/laboratorio/ESP32_01/temperatura
• meuProjeto/laboratorio/ESP32_01/umidade

Lidando com Erros e Exceções🔗

É importante implementar mecanismos para lidar com possíveis erros, como falhas na leitura do sensor ou perda de conexão com o broker.

Verificação de Leitura

No código, verificamos se os valores retornados pelo sensor são números válidos:

if (isnan(temperatura) || isnan(umidade))
{
  Serial.println("Falha ao ler do sensor DHT");
  return;
}

Se a leitura falhar, podemos tentar ler novamente ou enviar uma mensagem de erro através do MQTT.

Reconexão Automática

Utilizamos a função reconnect() para garantir que o ESP32 tente se reconectar ao broker MQTT caso a conexão seja perdida.

Segurança na Comunicação MQTT🔗

Embora, neste exemplo, não tenhamos utilizado autenticação ou criptografia, é fundamental considerar aspectos de segurança em projetos reais.

Autenticação

Configure um usuário e senha para o broker MQTT e passe essas credenciais na função client.connect().

if (client.connect(clientId.c_str(), mqtt_user, mqtt_password))
{
  // Conectado com autenticação
}

Criptografia TLS

Para adicionar uma camada extra de segurança, utilize um broker que suporte TLS/SSL e configure o ESP32 para se conectar usando criptografia. Isso envolve certificados e configurações adicionais.

Expandindo o Projeto🔗

Uma vez que você tenha aprendido a publicar dados via MQTT, pode expandir o projeto de várias maneiras:

• Assinar Tópicos: Permitir que o ESP32 receba comandos ou configurações através do MQTT.
• Controlar Dispositivos: Acionar relés, LEDs ou outros atuadores baseados em mensagens recebidas.
• Integrar com Serviços em Nuvem: Enviar dados para plataformas como AWS IoT, Google Cloud IoT ou Azure IoT Hub.
• Criar Dashboards: Visualizar os dados em tempo real utilizando ferramentas como Node-RED ou Grafana.

Dicas e Boas Práticas🔗

• Intervalos de Publicação: Evite publicar dados com intervalos muito curtos para não sobrecarregar a rede ou o broker.
• QoS (Qualidade de Serviço): Ajuste o nível de QoS de acordo com a confiabilidade necessária (0, 1 ou 2).
• Limpeza de Tópicos: Utilize a opção "Retain" com cuidado para não manter mensagens desatualizadas nos tópicos.
• Debugging: Utilize o Serial Monitor para depurar e verificar o funcionamento do código.

Conclusão🔗

Programar o ESP32 para publicar dados via MQTT é uma habilidade poderosa que permite a criação de soluções avançadas em IoT e automação. Compreendendo os conceitos básicos e aplicando as práticas demonstradas neste artigo, você estará apto a desenvolver projetos robustos e eficientes.

Lembre-se de sempre considerar os aspectos de segurança, especialmente em aplicações que envolvem dados sensíveis ou controles críticos. Explore as diversas possibilidades que o MQTT oferece e continue expandindo seus conhecimentos para criar sistemas cada vez mais complexos e integrados.

Desejamos sucesso em seus projetos e que este guia tenha sido útil em sua jornada com o ESP32 e o MQTT!

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