Marcio Cunha

Como configurar o protocolo MQTT em ESP32 na automação

Aprenda a implementar mensageria leve com ESP32 e MQTT via Wi-Fi para integrar atuadores IoT locais com brokers seguros.

Marcio Cunha•4 min
Também disponível em:EnglishEspañol
Resumo
  • O protocolo MQTT opera em arquitetura publish-subscribe otimizada para microcontroladores com restrição de banda e energia
  • A biblioteca PubSubClient simplifica a conexão TCP e a troca de pacotes JSON entre o ESP32 e o broker central
  • Garantir a segurança das credenciais Wi-Fi e o uso de criptografia TLS no broker evita interceptações na rede local
  • Separar redes físicas de IoT utilizando ferramentas como VLANs em switches gerenciáveis protege a infraestrutura crítica
  • Tratar falhas de conexão com reconexão automática assegura o funcionamento contínuo dos atuadores residenciais

O que é o MQTT e por que usá-lo no ESP32

Na automação residencial moderna, conectar dispositivos físicos à rede sem fio exige protocolos que consumam poucos recursos de processamento e banda. O MQTT, sigla para Message Queuing Telemetry Transport, funciona exatamente como um sistema de correio ultraleve projetado para computadores minúsculos como o ESP32. Diferente do protocolo HTTP que abre e fecha uma nova conexão a cada requisição, o MQTT mantém um canal TCP persistente e aberto com um servidor central chamado de broker. Na prática, isso significa que o microcontrolador pode enviar um comando ou receber um aviso instantaneamente, gastando pouca energia e operando perfeitamente mesmo quando a conexão oscila. Para entender o impacto da estabilidade na infraestrutura, vale conferir também como verificar perdas de pacotes com ping na sua rede Wi-Fi.

Arquitetura Publish-Subscribe na prática

O funcionamento do MQTT baseia-se no conceito de tópicos e na divisão de papéis entre publicadores e assinantes. Um tópico funciona como um canal de mensagens estruturado por caminhos em formato de texto, por exemplo, 'casa/sala/luz'. Quando o ESP32 quer acender uma lâmpada conectada a um relé, ele publica uma mensagem nesse canal. O broker recebe essa informação e a repassa imediatamente para todos os dispositivos que demonstraram interesse naquele assunto, assinando o mesmo tópico. Essa abordagem descentralizada elimina a necessidade de o microcontrolador saber o endereço IP de cada interruptor ou sensor da casa, simplificando imensamente a expansão do sistema à medida que você adiciona novos aparelhos.

Preparando o ambiente de desenvolvimento e bibliotecas

Para colocar a mão na massa com o ESP32 usando a IDE do Arduino, precisamos preparar o terreno instalando as ferramentas de comunicação essenciais. A biblioteca mais popular e testada para essa finalidade é a PubSubClient, criada por Nick O'Leary, que gerencia toda a lógica de conexão com o broker e o envio de pacotes binários. Antes de escrever o código de automação, é altamente recomendável isolar seus dispositivos inteligentes em uma rede segregada, tal como explicamos ao detalhar como configurar VLANs em switches gerenciáveis, garantindo que falhas em um ESP32 comprometido não afetem seus computadores principais. Com o ecossistema pronto, definimos as credenciais de rede e os parâmetros básicos de conexão no topo do código.

Escrevendo o código de conexão Wi-Fi e MQTT

Abaixo apresentamos um exemplo funcional de código para o ESP32 conectar-se ao Wi-Fi e estabelecer uma sessão persistente com um broker MQTT local, como o Mosquitto rodando em um servidor de homelab. O código gerencia a reconexão automática caso o sinal caia.

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

const char* ssid = "SuaRedeWiFi";
const char* password = "SuaSenhaWiFi";
const char* mqtt_server = "192.168.1.100";

WiFiClient espClient;
PubSubClient client(espClient);
const int relayPin = 23;

void callback(char* topic, byte* payload, unsigned int length) {
  String message;
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }
  if (String(topic) == "casa/sala/luz") {
    if (message == "ON") {
      digitalWrite(relayPin, HIGH);
    } else {
      digitalWrite(relayPin, LOW);
    }
  }
}

void reconnect() {
  while (!client.connected()) {
    if (client.connect("ESP32Client")) {
      client.subscribe("casa/sala/luz");
    } else {
      delay(5000);
    }
  }
}

void setup() {
  pinMode(relayPin, OUTPUT);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
}

Tratando falhas de conexão e reconexão automática

Dispositivos IoT instalados dentro de caixas de passagem ou paredes estão sujeitos a quedas esporádicas de sinal e reinicializações de roteadores. Se a rotina de software não prever essas falhas, o ESP32 pode travar em um estado desconectado após alguns dias de operação contínua. No script apresentado, a função loop executa ciclicamente a verificação client.connected(), acionando o método de reconexão automática quando necessário. Na prática, isso garante que o atuador recupere o controle em poucos segundos após o restablecimento da rede sem fio, mantendo a residência totalmente responsiva sem intervenção humana manual. Para aprofundar esses conceitos na prática em produção, confira também nossa análise técnica sobre Como testar o chip de áudio Realtek com multímetro na placa.

Considerações finais sobre segurança e estabilidade

Implementar automação residencial com ESP32 e MQTT traz uma liberdade incrível, mas exige atenção rigorosa com a segurança da rede local. Embora o protocolo padrão utilize a porta 1883 sem criptografia, o ideal em ambientes de produção é habilitar o suporte a TLS na porta 8883 e utilizar autenticação por usuário e senha no broker. Além disso, manter seus firmwares atualizados e monitorar o comportamento físico dos relés garante uma operação duradoura, segura e totalmente integrada aos seus assistentes locais preferidos.