Utilizando Qualidade de Serviço (QoS) no MQTT com ESP32

O que é Qualidade de Serviço (QoS) no MQTT?🔗

A Qualidade de Serviço, ou QoS, é um mecanismo do MQTT que define o nível de garantia na entrega de mensagens entre o cliente (no nosso caso, o ESP32) e o broker MQTT. O protocolo MQTT foi projetado para ser simples e eficiente, especialmente em redes com largura de banda limitada ou conexões instáveis. O QoS permite controlar como as mensagens são enviadas e recebidas, oferecendo diferentes níveis de confiabilidade.

Níveis de QoS

O MQTT define três níveis de QoS:

1. QoS 0 – No máximo uma vez (At most once): A mensagem é enviada pelo cliente apenas uma vez, sem confirmação de recebimento. Não há garantias de que a mensagem chegará ao destino. É o nível mais rápido e com menor overhead, ideal para aplicações onde a perda ocasional de mensagens não é crítica.

2. QoS 1 – Pelo menos uma vez (At least once): Garante que a mensagem será entregue pelo menos uma vez. O cliente mantém a mensagem até receber uma confirmação do broker. Pode resultar em mensagens duplicadas no destinatário, caso haja retransmissões.

3. QoS 2 – Exatamente uma vez (Exactly once): Garante que a mensagem será entregue exatamente uma vez. É o nível mais confiável, porém o mais lento, devido ao maior número de interações necessárias para garantir a entrega única.

Por que o QoS é importante em projetos com ESP32?🔗

Em aplicações IoT, especialmente aquelas que envolvem monitoramento e controle remoto, a confiabilidade na comunicação é crucial. Imagine um sensor de temperatura que envia leituras críticas para um servidor central. A perda de uma mensagem pode significar a falta de um alerta importante. Por outro lado, em aplicações onde a atualização constante é necessária, mas a perda de um dado não é tão impactante (como em leituras frequentes de um sensor de ambiente), um nível de QoS menor pode ser mais eficiente.

O ESP32, sendo um dispositivo projetado para comunicações sem fio, pode enfrentar situações de conexão instável. Utilizar o QoS adequado garante que seu dispositivo se comunique de forma confiável, atendendo às necessidades específicas do projeto.

Implementando QoS com ESP32 e MQTT🔗

Vamos agora colocar a teoria em prática e ver como implementar os diferentes níveis de QoS em um projeto com o ESP32. Utilizaremos a IDE Arduino, que é uma plataforma acessível e fácil de usar, ideal para engenheiros, estudantes e hobbistas.

Configurando o ambiente

Antes de começarmos, certifique-se de que o ambiente de desenvolvimento está configurado para programar o ESP32 usando a IDE Arduino. Você precisa ter instalado a placa ESP32 na IDE e as bibliotecas necessárias para trabalhar com MQTT.

Bibliotecas necessárias

Para a comunicação MQTT, usaremos a biblioteca PubSubClient, que é amplamente utilizada em projetos com ESP32.

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

Configurando a conexão Wi-Fi e MQTT

Primeiramente, precisamos conectar o ESP32 à rede Wi-Fi e configurar o cliente MQTT.

const char* ssid = "SEU_SSID";
const char* password = "SUA_SENHA";
const char* mqtt_server = "ENDERECO_DO_BROKER";
WiFiClient espClient;
PubSubClient client(espClient);

Função de conexão Wi-Fi

void setup_wifi()
{
  delay(10);
  Serial.println();
  Serial.print("Conectando-se a ");
  Serial.println(ssid);
  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());
}

Conectando-se ao broker MQTT

void reconnect()
{
  // Enquanto não estiver conectado
  while (!client.connected())
  {
    Serial.print("Tentando conexão MQTT...");
    // Tenta se conectar
    if (client.connect("ESP32Client"))
    {
      Serial.println("conectado");
      // Se inscreve em um tópico, se necessário
      client.subscribe("topico/teste", 0); // Aqui podemos definir o nível de QoS na assinatura
    }
    else
    {
      Serial.print("falhou, rc=");
      Serial.print(client.state());
      Serial.println(" tentaremos novamente em 5 segundos");
      delay(5000);
    }
  }
}

Publicando e Subscribing com diferentes níveis de QoS🔗

Agora que temos a conexão estabelecida, vamos ver como publicar e subscrever mensagens utilizando os diferentes níveis de QoS.

Publicando mensagens

Para publicar uma mensagem com um determinado nível de QoS, utilizamos a função publish e especificamos o nível desejado.

void loop()
{
  if (!client.connected())
  {
    reconnect();
  }
  client.loop();
  String mensagem = "Olá, mundo!";
  // Convertendo a mensagem para formato compatível
  char msg[50];
  mensagem.toCharArray(msg, 50);
  // Publicando com QoS 0
  client.publish("topico/teste", msg, false);
  // Publicando com QoS 1
  client.publish("topico/teste", msg, false, 1);
  // Publicando com QoS 2
  client.publish("topico/teste", msg, false, 2);
  delay(2000);
}

Recebendo mensagens

Para receber mensagens com um determinado nível de QoS, configuramos na função subscribe.

client.subscribe("topico/teste", 0); // QoS 0
client.subscribe("topico/teste", 1); // QoS 1
client.subscribe("topico/teste", 2); // QoS 2

Callback de mensagens

Para processar as mensagens recebidas, implementamos a função callback.

void callback(char* topic, byte* payload, unsigned int length)
{
  Serial.print("Mensagem recebida em [");
  Serial.print(topic);
  Serial.print("] com QoS ");
  Serial.println(client.getQoS());
  String mensagem;
  for (int i = 0; i < length; i++)
  {
    mensagem += (char)payload[i];
  }
  Serial.println("Mensagem: " + mensagem);
}

Testando os níveis de QoS🔗

Para testar os diferentes níveis de QoS, podemos simular situações de falha na rede e observar como o ESP32 e o broker MQTT se comportam.

Teste com QoS 0

• Cenário: Enviamos mensagens com QoS 0 e interrompemos a conexão Wi-Fi momentaneamente.
• Expectativa: Algumas mensagens podem não chegar ao destino, pois não há garantia de entrega.

Teste com QoS 1

• Cenário: Enviamos mensagens com QoS 1 e simulamos instabilidades na rede.
• Expectativa: As mensagens serão entregues pelo menos uma vez, podendo ocorrer duplicações.

Teste com QoS 2

• Cenário: Enviamos mensagens com QoS 2 em uma rede instável.
• Expectativa: As mensagens serão entregues exatamente uma vez, apesar das instabilidades, devido ao protocolo garantir a entrega única.

Considerações sobre o uso do QoS🔗

• Desempenho vs. Confiabilidade: Níveis mais altos de QoS aumentam a confiabilidade, mas também o overhead na comunicação. É importante balancear conforme a necessidade do projeto.
• Limitações do dispositivo: O ESP32 tem recursos limitados. O uso excessivo de memória ou processamento pode afetar o desempenho. Utilize o QoS adequado para otimizar recursos.
• Aplicações críticas: Em sistemas onde a perda de dados é inaceitável (por exemplo, monitoramento de equipamentos médicos), o QoS 2 é recomendado.

Boas práticas ao utilizar QoS com ESP32🔗

1. Conheça as necessidades do seu projeto: Nem sempre o nível mais alto de QoS é necessário. Avalie se a perda ocasional de mensagens é aceitável.

2. Monitore o desempenho: Teste como o seu sistema se comporta com diferentes níveis de QoS e cargas de trabalho.

3. Gerencie a reconexão: Implemente rotinas que garantam a reconexão ao broker MQTT em caso de falhas, minimizando a perda de mensagens.

4. Adapte-se ao ambiente de rede: Em redes com alta latência ou instabilidade, níveis mais altos de QoS podem ser necessários.

5. Cuide com mensagens duplicadas: Ao utilizar QoS 1, esteja preparado para lidar com possíveis duplicações de mensagens no destinatário.

Exemplo prático: Monitoramento de Temperatura com QoS🔗

Vamos aplicar o que aprendemos em um exemplo prático. Suponha que temos um sensor de temperatura conectado ao ESP32, e queremos enviar leituras para um servidor. A confiabilidade na entrega é importante, mas podemos tolerar a perda ocasional de dados.

Código do ESP32

#include <WiFi.h>
#include <PubSubClient.h>
const char* ssid = "SEU_SSID";
const char* password = "SUA_SENHA";
const char* mqtt_server = "ENDERECO_DO_BROKER";
WiFiClient espClient;
PubSubClient client(espClient);
void setup_wifi()
{
  // (Função conforme anteriormente)
}
void callback(char* topic, byte* payload, unsigned int length)
{
  // (Função conforme anteriormente)
}
void reconnect()
{
  // (Função conforme anteriormente)
}
void setup()
{
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
}
void loop()
{
  if (!client.connected())
  {
    reconnect();
  }
  client.loop();
  float temperatura = lerTemperatura(); // Suponha que esta função lê o sensor
  char msg[50];
  dtostrf(temperatura, 1, 2, msg);
  // Publicando com QoS 1
  client.publish("sensor/temperatura", msg, false, 1);
  delay(5000);
}
float lerTemperatura()
{
  // Simulando leitura do sensor
  return random(20, 30) + (random(0, 100) / 100.0);
}

Explicação

• Conexão Wi-Fi e MQTT: Configuramos conforme os passos anteriores.
• Leitura do sensor: Simulamos uma leitura de temperatura com valores aleatórios.
• Publicação da mensagem: Enviamos a leitura para o tópico sensor/temperatura com QoS 1, garantindo que a leitura será entregue pelo menos uma vez.

Conclusão🔗

A Qualidade de Serviço no MQTT é uma ferramenta poderosa para controlar a confiabilidade na comunicação entre dispositivos IoT. Utilizando o QoS adequado, podemos adaptar nossos projetos com ESP32 para atender às necessidades específicas de desempenho e confiabilidade.

A compreensão dos diferentes níveis de QoS e sua implementação prática permite que engenheiros, estudantes e hobbistas desenvolvam soluções mais robustas e eficientes. Lembre-se sempre de equilibrar as demandas do projeto com os recursos disponíveis, garantindo a melhor performance possível.

Agora que você está familiarizado com o QoS no MQTT, experimente em seus próprios projetos e observe como essa funcionalidade pode melhorar a comunicação e a confiabilidade dos seus dispositivos IoT com ESP32.

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