Cliente ESP32 MQTT: publicar e assinar. Exemplo de HiveMQ e BME280
Este guia aborda como desenvolver um cliente ESP32 MQTT para publicar mensagens MQTT e assinar tópicos do MQTT. Neste tutorial, iremos pubsubclient library para conectar o ESP32 ao MQTT broker. Para entender melhor como usar um cliente ESP32 MQTT, usaremos um exemplo de publicação ESP32 MQTT conectando-se ao HiveMQ MQTT broker. O cliente enviará leituras do sensor BME280, como temperatura, umidade e pressão, usando os tópicos do MQTT. Além disso, vamos descobrir como se inscrever nos tópicos do MQTT para que o ESP32 possa receber dados.
O MQTT é um dos protocolos de IoT mais importantes, amplamente usado em projetos de IoT para conectar placas como o ESP32 ao broker do MQTT na nuvem. Além disso, o ESP32 com MQTT também é usado em automação residencial. Este tutorial supõe que você esteja familiarizado com o MQTT e conheça os aspectos básicos, como intermediário do MQTT, tópicos do MQTT e a arquitetura de publicação e assinatura.
Conteudo
O que vamos aprender ..
Durante este tutorial, você aprenderá: como
- Publique mensagens MQTT do ESP32 usando tópicos do MQTT na biblioteca do Pubsub
- Conecte-se a um broker MQTT usando ESP32
- Inscreva-se em um tópico do MQTT usando ESP32 para receber dados
- Use o HiveMQ para verificar as mensagens publicadas
- Publicar mensagem MQTT do ESP32 no cloud MQTT broker
O que você precisa para seguir este tutorial?
Este guia é baseado no ESP32, portanto, para seguir as instruções deste guia, é necessário um EspressIf ESP32 ou um dispositivo compatível.
Como desenvolver um cliente MQTT do Arduino ESP32
Nosso cliente ESP32 MQTT precisa executar duas tarefas diferentes:
- publique dados no tópico MQTT:
- >>>ler dados de um sensor BME280
- assine o tópico MQTT para receber dados
Para implementar um cliente MQTT usando ESP32, precisamos seguir estas etapas:
1) Conecte o ESP32 ao Wifi
2) Instalar e configurar o cliente MQTT
3) Instalar e configurar o sensor BME280
4) Conecte o cliente MQTT para ESP32 ao broker MQTT
5) Publique as leituras do sensor nos tópicos do MQTT periodicamente
6) Ouvir mensagem recebida assinando um tópico do MQTT
Para testar o cliente, usaremos o broker público MQTT do HiveMQ, mesmo se você puder conectar o cliente a outro broker MQTT.
Etapa 1: conectar o ESP32 ao Wifi
Vamos começar. O primeiro passo é um passo comum. Para desenvolver o cliente, usaremos o PlatforIO, mesmo que você possa usar outro IDE, se preferir.
#include <Arduino.h>
#include <WiFi.h>
const char *SSID = "seu_wifi_ssid";
const char *PWD = "sua_senha_wifi";
void connectToWiFi() {
Serial.print("Ligação a");
WiFi.begin(SSID, PWD);
Serial.println(SSID);
while (WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}
Serial.print("Conectado.");
}
O código é realmente simples.
Etapa 2: Instalar e configurar o cliente ESP32 usando o PubSubClient
Após a conexão Wifi ser implementada, podemos nos concentrar em como configurar o cliente MQTT para ESP32. Para simplificar o desenvolvimento do cliente, usaremos a Biblioteca PubSubClient sugerida pelo HiveMQ.
Você precisa importar a biblioteca PubSubClient usando seu IDE. Depende do IDE que você está usando, mas o processo é quase o mesmo: você precisa procurar a biblioteca e importá-la. O código para configurar o cliente ESP32 é:
#include <PubSubClient.h>
// MQTT client
WiFiClient wifiClient;
PubSubClient mqttClient(wifiClient);
char *mqttServer = "broker.hivemq.com";
int mqttPort = 1883;
void setupMQTT() {
mqttClient.setServer(mqttServer, mqttPort);
// define a função de retorno de chamada
mqttClient.setCallback(callback);
}
Esse código de cliente ESP32 deve ser adicionado ao código mostrado na etapa anterior. As linhas de importação mais são:
- 1: Importar o cabeçalho PubSubClient PubSubClient.h
- 4,5: defina o mqttClient passando o WiFiClient
- 7,8: defina o endereço do broker MQTT na nuvem e a porta.
- 10: configure o mqttClient configurando o broker MQTT
Etapa 3: Instalar e configurar o sensor BME280
Como o ESP32 MQTT publica o exemplo, o cliente MQTT do ESP32 envia temperatura, umidade e pressão usando os tópicos do MQTT. Obviamente, você pode enviar dados diferentes.
O esquema para conectar o ESP32 ao BME280 é mostrado abaixo:
O código é simples. Novamente, você precisa importar a biblioteca de sensores Adafruit BME280 antes de usá-la:
#include <Adafruit_BME280.h>
#include <Adafruit_Sensor.h>
Adafruit_BME280 bme;
void setup() {
Serial.begin(9600);
connectToWiFi();
if (!bme.begin(0x76)) {
Serial.println("Problema ao conectar-se ao BME280");
}
setupMQTT();
}
- 3: definimos o sensor Adafruit BME280
- 4,5: defina o mqttClient passando o WiFiClient
- 7: nos conectamos ao sensor. Observe que o endereço I2C usado é 0x76. Se o seu sensor usar um endereço diferente, substitua-o pelo valor no código
4. Conecte o ESP32 ao intermediário MQTT
Durante esta etapa, conectaremos o cliente ESP32 MQTT ao broker para que o cliente possa enviar dados. Para fazer isso, adicione o seguinte código:
void reconnect() {
Serial.println("Conectando ao MQTT Broker...");
while (!mqttClient.connected()) {
Serial.println("Reconectando ao MQTT Broker..");
String clientId = "ESP32Client-";
clientId += String(random(0xffff), HEX);
if (mqttClient.connect(clientI.c_str())) {
Serial.println("Connected.");
// inscreva-se no tópico
mqttClient.subscribe("/swa/commands");
}
}
}
void loop() {
if (!mqttClient.connected())
reconnect();
mqttClient.loop();
}
O código é simples:
Linha 3: tentamos conectar o cliente ESP32 MQTT ao broker, selecionando um cliente de identificação aleatória (clientId). O clientId muda toda vez que nos conectamos
No método de loop, o código verifica se o cliente ESP32 está conectado. Caso contrário, reconecte o cliente ao broker
11: o cliente assina um tópico chamado /swa/command para receber dados (veremos mais adiante)
Etapa 5: Publicando as leituras do sensor nos tópicos do MQTT usando o PubsubClient for ESP32
Nesta etapa, publicamos dados no MQTT. Para fazer isso, o cliente ESP32 usa três tópicos diferentes:
- /swa/temperature tópico usado para publicar as leituras de temperatura
- /swa/humidity tópico usado para publicar as leituras de umidade
- /swa/pressure tópico de pressão usado para publicar as leituras de pressão
Portanto, o código é:
void loop() {
if (!mqttClient.connected())
reconnect();
mqttClient.loop();
long now = millis();
if (now - last_time > 60000) {
// envia dados
float temp = bme.readTemperature();
float hum = bme.readHumidity();
float pres = bme.readPressure() / 100;
// Publicando dados através do MQTT
sprintf(data, "%f", temp);
Serial.println(data);
mqttClient.publish("/swa/temperature", data);
sprintf(data, "%f", hum);
Serial.println(hum);
mqttClient.publish("/swa/humidity", data);
sprintf(data, "%f", pres);
Serial.println(pres);
mqttClient.publish("/swa/pressure", data);
last_time = now;
}
- Linha 8,9,10: o código lê os valores do sensor BME280
- Linha 14,17,20: o código publica a leitura do sensor BME280 em três tópicos diferentes
Observe que o código publica os dados a cada minuto e usa o método PubsubClient chamado publish, que aceita o tópico MQTT e os dados a serem publicados. Se você deseja alterar o intervalo, é necessário modificar o valor na linha 9.
Etapa 6: Assine o tópico MQTT para ouvir a mensagem recebida
Nesta etapa, assinamos os tópicos do MQTT para ouvir as mensagens recebidas do MQTT publicadas por outro cliente MQTT que assina o mesmo tópico. Portanto, na biblioteca Pubsubclient, é necessário implementar uma função de retorno de chamada. Aqui, lidaremos com a mensagem recebida:
void callback(char* topic, byte* payload, unsigned int length) {
Serial.print("Callback - ");
Serial.print("Message:");
for (int i = 0; i < length; i++) {
Serial.print((char)payload[i]);
}
}
Neste exemplo, simplesmente escrevemos a carga útil da mensagem recebida. De qualquer forma, você pode executar outras tarefas aqui de acordo com a carga útil que o cliente ESP32 recebe. Por exemplo, se estivermos usando ESP32 com MQTT em automação residencial, podemos:
- LED de controle (ligando ou desligando)
- controlando a cor RGB
- Escreva o resultado em uma tela
Exemplo de mensagem de publicação do ESP32 usando o cliente do navegador HiveMQ: Teste
Execute o código no seu ESP32. Se você fez tudo corretamente, o código deve compilar e executar. Agora você pode configurar o cliente do navegador HiveMQ para visualizar as mensagens MQTT publicadas pelo cliente MQTT.
1) Vá para este link e clique no botão conectar
2) Adicione os tópicos de assinatura um para cada tópico que o ESP32 usa
Você deve ter algo parecido com isto:
Assim que o cliente ESP32 publicar dados nesses tópicos, você deverá ver os dados conforme mostrado na figura abaixo:
Teste o cliente ESP32 MQTT usando MQTT.fx
Você pode obter o mesmo resultado usando o MQTT.fx. Execute-o e conecte-se ao broker HiveMQ MQTT incluindo um novo perfil. Assine os três tópicos mostrados anteriormente e você obterá o seguinte resultado:
Testando a assinatura do tópico ESP32 MQTT
Neste último teste, publicaremos, usando o navegador do cliente HiveMQ, uma mensagem para o tópico em que o cliente ESP32 está inscrito:
Observe que o tópico é o mesmo usado no código do cliente ESP32 MQTT. Escreva Hello ESP32 na caixa de mensagem e clique em publicar. Nós conseguiremos:
Empacotando…
No final deste tutorial do cliente ESP32 MQTT, aprendemos como publicar mensagens MQTT nos canais. Usamos um exemplo de publicação de mensagem ESP32 MQTT com base no sensor BME280. O ESP32 publica temperatura, umidade e pressão para publicar em três canais diferentes do MQTT.
Além disso, você aprendeu como assinar o cliente ESP32 MQTT em um tópico para receber mensagens MQTT. No final, testamos o cliente ESP32 usando o broker HiveMQ MQTT. Por fim, abordamos como desenvolver um cliente ESP32 MQTT usando a biblioteca PubsubClient.
TAGS : ESP32 BME280, ESP32 HiveMQ, ESP32 IoT, ESP32 MQTT, Tutorial do ESP32, IoT
![Eletrônica Passo a Passo [Coleção Completa]](https://capsistema.com.br/wp-content/uploads/2020/08/foto1-5-150x150.png "Eletrônica Passo a Passo [Coleção Completa]")
