Implementando Assinaturas MQTT no ESP32 para Receber Dados

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

O MQTT (Message Queuing Telemetry Transport) é um protocolo de mensagem publicado/assinado (publish/subscribe) que permite a comunicação entre dispositivos em redes com largura de banda limitada ou conectividade intermitente. O ESP32, sendo um microcontrolador poderoso com conectividade Wi-Fi e Bluetooth integrados, é uma escolha excelente para projetos IoT que requerem comunicação eficiente.

Implementar assinaturas MQTT no ESP32 permite que o dispositivo receba mensagens de um broker MQTT, possibilitando a criação de aplicações como monitoramento remoto, automação residencial e controle de dispositivos em tempo real.

Preparando o Ambiente🔗

Antes de começarmos, é importante garantir que temos todas as ferramentas necessárias.

Ferramentas Necessárias

• ESP32: O microcontrolador que usaremos.
• Cabo USB: Para conectar o ESP32 ao computador.
• Computador: Para programar o ESP32.
• Arduino IDE: Ambiente de desenvolvimento integrado para escrever e enviar códigos ao ESP32.
• Broker MQTT: Podemos usar um broker público como o Mosquitto ou configurar um localmente.

Instalando o Arduino IDE e Bibliotecas Necessárias

1. Instalar o Arduino IDE: Baixe e instale a versão mais recente do Arduino IDE a partir do site oficial.

2. Configurar o ESP32 no Arduino IDE:

• Abra o Arduino IDE.
• Vá em Arquivo > Preferências.
• No campo URLs Adicionais para Gerenciadores de Placas, adicione: https://dl.espressif.com/dl/package_esp32_index.json.
• Vá em Ferramentas > Placa > Gerenciador de Placas e instale esp32 by Espressif Systems.

3. Instalar a Biblioteca PubSubClient:

• Vá em Sketch > Incluir Biblioteca > Gerenciar Bibliotecas.
• Procure por PubSubClient e clique em instalar.

Conectando o ESP32 à Rede Wi-Fi🔗

Para que o ESP32 se comunique com o broker MQTT, é necessário conectá-lo à internet via Wi-Fi.

Código para Conexão Wi-Fi

#include <WiFi.h>
// Defina o nome e a senha da rede Wi-Fi
const char* ssid = "SEU_SSID";
const char* password = "SUA_SENHA";
void setup()
{
  Serial.begin(115200);
  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("Conexão estabelecida!");
  Serial.print("Endereço IP: ");
  Serial.println(WiFi.localIP());
}
void loop()
{
  // O loop ficará vazio por enquanto
}

• WiFi.h: Biblioteca que permite ao ESP32 conectar-se a redes Wi-Fi.
• ssid e password: Substitua por seu nome de rede e senha.
• WiFi.begin(): Inicia a conexão com a rede especificada.
• WiFi.status(): Verifica o status da conexão.

Implementando a Assinatura MQTT🔗

Agora que o ESP32 está conectado à internet, vamos configurar a assinatura MQTT para receber dados.

Passo 1: Importar Bibliotecas Necessárias

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

Passo 2: Configurar Parâmetros MQTT

// Endereço do broker MQTT
const char* mqtt_server = "SEU_BROKER_MQTT";
// Cria um cliente Wi-Fi e um cliente MQTT
WiFiClient espClient;
PubSubClient client(espClient);

Substitua SEU_BROKER_MQTT pelo endereço IP do seu broker MQTT ou pelo endereço de um broker público.

Passo 3: Função de CallBack

A função de callback é chamada sempre que uma mensagem é recebida em um tópico ao qual o ESP32 está inscrito.

void callback(char* topic, byte* message, unsigned int length)
{
  Serial.print("Mensagem recebida no tópico: ");
  Serial.println(topic);
  Serial.print("Mensagem: ");
  String messageTemp;
  for (int i = 0; i < length; i++)
  {
    Serial.print((char)message[i]);
    messageTemp += (char)message[i];
  }
  Serial.println();
  // Aqui você pode adicionar lógica para processar a mensagem recebida
}

Passo 4: Reconectando ao Broker MQTT

O ESP32 precisa manter a conexão com o broker. Se a conexão cair, ele tenta reconectar.

void reconnect()
{
  // Loop até conseguir se reconectar
  while (!client.connected())
  {
    Serial.print("Tentando se conectar ao broker MQTT...");
    // Cria um ID de cliente aleatório
    String clientId = "ESP32Client-";
    clientId += String(random(0xffff), HEX);
    // Tenta se conectar
    if (client.connect(clientId.c_str()))
    {
      Serial.println("Conectado!");
      // Inscreve-se no tópico desejado
      client.subscribe("seu/topico");
    }
    else
    {
      Serial.print("Falha na conexão, rc=");
      Serial.print(client.state());
      Serial.println(" Tentando novamente em 5 segundos...");
      delay(5000);
    }
  }
}

Substitua "seu/topico" pelo tópico ao qual deseja se inscrever.

Passo 5: Completando o Setup e Loop

Atualize as funções setup() e loop() para integrar tudo.

void setup()
{
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  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);
  client.setCallback(callback);
}
void loop()
{
  if (!client.connected())
  {
    reconnect();
  }
  client.loop();
}

• client.setServer(): Configura o endereço do broker MQTT e a porta (1883 por padrão).
• client.setCallback(): Define a função que será chamada ao receber uma mensagem.
• client.loop(): Mantém a comunicação com o broker MQTT ativa.

Testando a Assinatura MQTT🔗

Agora que o código está completo, é hora de testar se o ESP32 está recebendo mensagens via MQTT.

Passo 1: Enviar o Código para o ESP32

• Conecte o ESP32 ao computador via USB.
• Selecione a placa correta em Ferramentas > Placa > ESP32 Dev Module.
• Selecione a porta correta em Ferramentas > Porta.
• Clique em Enviar para compilar e enviar o código ao ESP32.

Passo 2: Usar um Cliente MQTT para Enviar Mensagens

Podemos usar ferramentas como o MQTT.fx ou o MQTT Explorer para publicar mensagens no tópico ao qual o ESP32 está inscrito.

1. Conecte-se ao mesmo broker MQTT utilizado pelo ESP32.

2. Publique uma mensagem no tópico especificado, por exemplo, "seu/topico".

3. Observe o Serial Monitor no Arduino IDE para ver se o ESP32 recebe a mensagem.

Passo 3: Verificando o Recebimento

No Serial Monitor, você deve ver uma saída semelhante a:

Mensagem recebida no tópico: seu/topico
Mensagem: Olá, ESP32!

Isso confirma que o ESP32 está assinando corretamente o tópico e recebendo as mensagens publicadas.

Aplicação Prática: Controlando um LED via MQTT🔗

Para demonstrar uma aplicação prática, vamos controlar um LED conectado ao ESP32 usando mensagens MQTT.

Esquema de Conexão

• Conecte um LED ao pino GPIO 2 (D2), com um resistor de 220Ω em série.
• O outro terminal do LED deve ser conectado ao GND.

Atualizando a Função Callback

Modifique a função callback() para controlar o LED com base na mensagem recebida.

#define LED_PIN 2
void setup()
{
  // ... código anterior ...
  pinMode(LED_PIN, OUTPUT);
}
void callback(char* topic, byte* message, unsigned int length)
{
  String messageTemp;
  for (int i = 0; i < length; i++)
  {
    messageTemp += (char)message[i];
  }
  if (String(topic) == "seu/topico")
  {
    Serial.print("Comando recebido: ");
    Serial.println(messageTemp);
    if (messageTemp == "ligar")
    {
      digitalWrite(LED_PIN, HIGH);
      Serial.println("LED ligado");
    }
    else if (messageTemp == "desligar")
    {
      digitalWrite(LED_PIN, LOW);
      Serial.println("LED desligado");
    }
  }
}

• pinMode(LED_PIN, OUTPUT): Define o pino do LED como saída.
• digitalWrite(LED_PIN, HIGH/LOW): Liga ou desliga o LED.
• messageTemp == "ligar"/"desligar": Verifica o comando recebido.

Testando o Controle do LED

1. Envie mensagens "ligar" ou "desligar" no tópico "seu/topico" usando um cliente MQTT.

2. Observe o LED: Ele deve ligar ou desligar conforme o comando.

3. Verifique o Serial Monitor: As mensagens de estado devem ser exibidas.

Entendendo a Lógica Implementada🔗

A lógica deste projeto permite que o ESP32 reaja a comandos enviados via MQTT. Isso é fundamental em sistemas IoT, onde dispositivos precisam ser controlados remotamente.

Como Funciona a Assinatura MQTT no ESP32

• Conexão ao Broker: O ESP32 mantém uma conexão com o broker MQTT.
• Inscrição em Tópicos: Utilizando client.subscribe("seu/topico"), o ESP32 ouve mensagens enviadas para esse tópico.
• Recebimento de Mensagens: A função callback() é acionada sempre que uma nova mensagem é recebida.
• Processamento de Mensagens: Com base no conteúdo da mensagem, o ESP32 executa ações, como ligar ou desligar um LED.

Expandindo o Projeto🔗

A partir desta base, é possível expandir o projeto para controlar múltiplos dispositivos, receber dados de sensores ou até mesmo integrar com serviços em nuvem.

Exemplos de Expansão

• Controle de Múltiplos LEDs: Inscrever-se em diferentes tópicos para controlar vários LEDs.
• Recebimento de Dados de Configuração: Alterar parâmetros do dispositivo em tempo real.
• Integração com Assistentes Virtuais: Controlar dispositivos via comandos de voz integrados a serviços como Alexa ou Google Assistant.

Boas Práticas e Considerações🔗

Ao desenvolver projetos com MQTT e ESP32, é importante seguir algumas boas práticas:

• Segurança: Utilize autenticação e criptografia (TLS/SSL) para proteger as comunicações.
• Gestão de Conexões: Implemente lógica para reconexão automática e tratamento de erros.
• QoS (Qualidade de Serviço): Configure níveis adequados de QoS para garantir a entrega das mensagens.

Conclusão🔗

Implementar assinaturas MQTT no ESP32 é uma tarefa essencial para criar dispositivos IoT que precisam receber dados de maneira eficiente. Com os conhecimentos adquiridos neste artigo, você está pronto para desenvolver aplicações que se comunicam de forma confiável e responsiva, abrindo um leque de possibilidades para projetos inovadores.

Lembre-se de que a chave para o sucesso em projetos IoT é entender profundamente tanto o hardware quanto os protocolos de comunicação. Continue explorando, testando e expandindo seus conhecimentos para criar soluções cada vez mais completas e robustas.

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