Cliente MQTT ESP8266: publicação e assinatura (Raspberry Pi, Node-red)

Tempo de leitura: 6 minutes

Este tutorial explica como desenvolver e usar um cliente ESP8266 MQTT para publicar e assinar canais MQTT. Mais detalhadamente, este tutorial do ESP8266 desenvolverá um cliente MQTT do ESP8266 que se conecta ao broker do Mosquitto MQTT em execução no Raspberry Pi. Em seguida, usaremos Node-red (executando no Raspberry Pi) para criar um painel que visualiza os dados. Além disso, neste projeto, exploraremos:

  • Como publicar dados usando o MQTT do ESP8266
  • Como se inscrever em um canal MQTT usando ESP8266

Primeiro, no primeiro cenário, o ESP8266 se conecta ao DHT11 para adquirir temperatura e umidade. Essas leituras do sensor são enviadas ao intermediário MQTT (Mosquitto) usando dois canais MQTT. Portanto, o ESP8266 publica dados através dos canais MQTT.

Em segundo lugar, nesse cenário, o ESP8266 assina o canal MQTT e recebe dados. Nesse contexto, para simplificar, o ESP8266 controlará um LED usando os comandos recebidos.

Dados de publicação do cliente ESP8266 MQTT:

Nesta primeira etapa, analisaremos como publicar leituras de sensores do ESP8266 no Mosquitto (o intermediário MQTT). A imagem abaixo mostra este cenário:

Esp8266 MTQQ

Nesse caso, o ESP8266 atua como um cliente MQTT que publica as leituras do sensor no broker MQTT. Portanto, o ESP8266 usa dois canais diferentes para publicar dados. Em seguida, usando Node-red, criaremos um painel de interface do usuário Node-red que visualiza os dados adquiridos pelo sensor. Vermelho-nó e Mosquitto rodam no Raspberry Pi. Você pode acessar o painel usando um navegador, como veremos mais adiante.

Implementando o Cliente MQTT Usando a Biblioteca PubsubClient

Depois de ter uma visão geral do cenário em que queremos usar nosso ESP8266, podemos começar a codificar o cliente MQTT do ESP8266. Para simplificar o desenvolvimento do cliente, usaremos a biblioteca PubsubClient. Portanto, você precisa importá-lo para o seu projeto. O código é mostrado abaixo:

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
 
IPAddress mqttServer(192,168,1,142);
const char *SSID = "seu_ssid";
const char *PWD = "sua_senha_wifi";
long lastime = 0;
  
void callback(char* topic, byte* payload, unsigned int length) {
 Serial.println("Callback");
 Serial.println((char) payload[0]);
}
 
WiFiClient wifiClient = WiFiClient();
PubSubClient mqttClient(mqttServer, 1883, callback, wifiCliient);
  
void connectToWiFi() {
 Serial.print("Conectando à ");
 Serial.println(SSID);
  WiFi.begin(SSID, PWD);
  while (WiFi.status() != WL_CONNECTED) {
   Serial.print(".");
   delay(500);
   // podemos até fazer o ESP32 dormir
 }
  
 Serial.print("Conectado - ");
 //Serial.println(WiFi.localIP);
}
  
void reconnect() {
 Serial.println("Conectando ao MQTT Broker...");
 while (!mqttClient.connected()) {
     Serial.println("Reconnecting to MQTT Broker..");
     String clientId = "ESP8266Client-";
     clientId += String(random(0xffff), HEX);
     
     if (mqttClient.connect(clientId.c_str())) {
       Serial.println("Conectado.");
       // assina o tópico
     }
 }
}
  
void setup() {
 Serial.begin(9600);
 connectToWiFi();
}
  
void loop() {
  
 if (!mqttClient.connected())
   reconnect();
   mqttClient.loop();
    
  // Publicando dados no MQTT
  long now = millis();
  if(now - lastime > 10000) {
   Serial.println("Publicando dados..");
   // lê a temperatura do sensor
   mqttClient.publish("/esp8266/temperature", data);
   // lê a umidade do sensor
   mqttClient.publish("/esp8266/humidity", data);
   lastime = now;
 }
  
}

Vamos analisar o código. Na linha 3, importamos as definições para usar o Pubsubclient. Em seguida na linha 5, é necessário definir o endereço IP do broker MQTT. Veremos mais adiante como instalar o broker MQTT no Raspberry Pi. Em seguida, na linha 16, definimos o cliente MQTT:

PubSubClient mqttClient(mqttServer, 1883, callback, wifiClient);

em que 1883 é a porta MQTT e o retorno de chamada é a função a ser chamada quando o ESP8266 recebe uma mensagem através do MQTT. Até agora, podemos ignorá-lo, usaremos essa opção mais tarde quando o ESP8266 assinar o canal MQTT. No método reconnect(), manipulamos a conexão com o MQTT e o evento de desconexão. Por fim, nas linhas 63 e 65, publicamos dados adquiridos pelo sensor DHT11, usando dois canais MQTT diferentes:

  • /esp8266/temperature
  • /esp8266/humidity

Conexão do ESP8266 ao DHT11 e publicação de dados

Depois que o cliente ESP8266 MQTT para publicar dados estiver pronto, podemos concentrar nossa atenção na conexão do ESP8266 ao sensor DHT11 para adquirir temperatura e umidade.

#include <Adafruit_Sensor.h> 
#include <DHT.h> 
 
#define DHT_TYPE DHT11
#define DHT_PIN D5
 
DHT dht(DHT_PIN, DHT_TYPE);
char data[100];
 
void reconnect() {
 Serial.println("Conectando ao MQTT Broker ...");
 while (!mqttClient.connected()) {
     Serial.println("Reconnecting to MQTT Broker..");
     String clientId = "ESP8266Client-";
     clientId += String(random(0xffff), HEX);
     
     if (mqttClient.connect(clientId.c_str())) {
       Serial.println("Conectado.");
       // assine o tópico  
       mqttClient.subscribe("/esp8266/commands");      
     }
 }
}
 
void setup() {
 Serial.begin(9600);
 connectToWiFi();
 dht.begin();
 Serial.println("Sensor DHT11....");
}
 
void loop() {
  
  if (!mqttClient.connected()) reconnect();
  mqttClient.loop();
   
  // Publicando dados no MQTT
  long now = millis();
  if(now - lastime > 10000) {
    Serial.println("Publicando dados..");
    float temp = dht.readTemperature();
    float hum = dht.readHumidity();
    sprintf(data, "%f", temp);
    Serial.println(data);
    mqttClient.publish("/esp8266/temperature", data);
    sprintf(data, "%f", hum);
    Serial.println(hum);
    mqttClient.publish("/esp8266/humidity", data);
    lastime = now;
  }
}

O código acima conclui o desenvolvimento do cliente ESP8266 MQTT. Este cliente publica as leituras do sensor DHT11 usando dois canais MQTT diferentes. Além disso, ele envia dados a cada 10 segundos.

Como desenvolver o cliente ESP8266 MQTT para assinar o canal MQTT

Nesta segunda parte deste tutorial do ESP8266, analisaremos como desenvolver um cliente MQTT do ESP8266 que assina um canal MQTT para que o ESP8266 possa receber comandos. Nesse cenário, usaremos esses comandos para controlar um LED, ligando ou desligando. Posteriormente, desenvolveremos o painel usando o Node-red em execução no Raspberry Pi para comandar o LED. Portanto, a figura abaixo mostra o cenário que queremos desenvolver:

WebResposta

Conforme descrito na figura acima, através do painel construído usando Node-red e Mosquitto, enviaremos comandos para o ESP8266 que assina o canal de comando. Nesse caso, o cliente ESP8266 MQTT recebe dados através do canal MQTT, enquanto no primeiro cenário o cliente ESP8266 MQTT envia dados.

O código é quase o mesmo que o mostrado no cenário anterior. De qualquer forma, neste contexto, é necessário implementar a função de retorno de chamada que é chamada quando o ESP8266 recebe dados através do canal MQTT. Portanto, é necessário implementar a função callback. Neste método, implementaremos a lógica para ligar ou desligar o LED conectado ao ESP8266. O código é trivial. É necessário implementar o método de retorno de chamada:

void callback(char* topic, byte* payload, unsigned int length) {
 Serial.println("Callback");
 Serial.println((char) payload[0]);
  // usando carga útil [0] == 't' ou 'f', apaga ou apaga o LED
}

Como desenvolver um painel de interface do usuário vermelho-nó para publicar e receber dados por meio do MQTT

Por fim, nesta última parte deste projeto, implementaremos um painel de interface do usuário em vermelho. Este painel receberá dados publicados pelo cliente ESP8266 MQTT nos canais /esp8266/temperature e /esp8266/humidity. Por outro lado, o painel da interface do usuário Node-red publica dados no canal /esp8266/command onde o cliente ESP8266 MQTT está inscrito. Como afirmado anteriormente, o Node-red e o Mosquitto rodam no Raspberry Pi. Vamos ver como podemos instalá-los e configurá-los.

Instalando o Mosquitto no Raspberry Pi

A instalação do Mosquitto é muito simples. Usaremos o Docker para instalá-lo:

sudo docker run -it -p 1883:1883 -p 9001:9001 eclipse-mosquitto 

Ele executará o intermediário Mosquitto MQTT que escuta na porta 1883.

Instalando o Node-red no Raspberry Pi

Ele executará o intermediário Mosquitto MQTT que escuta na porta 1883.

sudo docker run -p 1880:1880 nodered/node-red -v /home/pi/.node-red:/data

O Node-Red será executado na porta 1880. Em seguida, abra o navegador e conecte-se à interface Node-Red. Antes de conectar o Node-red ao broker do MQTT, precisamos importar os nós da interface do usuário do painel. Você pode fazer isso usando o menu Paleta.

Criando Node-red UI

Depois que o Node-red estiver instalado, podemos criar o fluxo que deve se parecer com o mostrado na figura abaixo:

WebResposta

Abaixo do arquivo json to import que cria o fluxo mostrado acima:

{"id":"62754c3f.ea8df4","type":"ui_chart","z":"43827484.221c5c","name":"Temperature","group":"6ce5a9c7.9482d8","order":0,"width":0,"height":0,"label":"Temperature","chartType":"line","legend":"false","xformat":"HH:mm:ss","interpolate":"linear","nodata":"","dot":false,"ymin":"0","ymax":"40","removeOlder":1,"removeOlderPoints":"","removeOlderUnit":"3600","cutout":0,"useOneColor":false,"colors":["#1f77b4","#aec7e8","#ff7f0e","#2ca02c","#98df8a","#d62728","#ff9896","#9467bd","#c5b0d5"],"useOldStyle":false,"outputs":1,"x":630,"y":380,"wires":[[]]},{"id":"6ce5a9c7.9482d8","type":"ui_group","z":"","name":"Control","tab":"3f223f3f.02ae8","disp":true,"width":"6","collapse":false},{"id":"3f223f3f.02ae8","type":"ui_tab","name":"Tab 1","icon":"dashboard","order":1}]

Como você pode ver na figura acima, existem três nós da interface do usuário:

  • Switch que usará para comandar o LED
  • Um medidor que mostra a umidade
  • Gráfico que mostra a temperatura

Além disso, existem três nós diferentes:

  • um nó que publica dados (do comutador) para /esp8266/commando em que o cliente MQTT está inscrito
  • dois canais MQTT nos quais o cliente ESP8266 MQTT publica dados provenientes do sensor DHT11.

Em seguida, vamos implantar o fluxo no servidor Node-red e mostrar o painel da interface do usuário. O resultado é:

WebResposta

Empacotando

Concluindo, no final deste tutorial, esperamos que você tenha adquirido conhecimento sobre como desenvolver o cliente ESP8266 MQTT. Vimos como conectar o ESP8266 ao broker MQTT e como usar o ESP8266 para assinar canais MQTT. Além disso, descobrimos que podemos usar o cliente ESP8266 MQTT para publicar dados provenientes de sensores. No final, este tutorial abordou como construir um painel de interface do usuário vermelho de nó que se conecta ao broker MQTT para visualizar dados.

Espero que você tenha gostado da explicação deste projeto, e teste o funcionando e que tenha gostado de fazê-lo. Se você tiver alguma dúvida, pode escrevê-las na seção de comentários abaixo ou publicá-las em nossos blog.

Visits: 2 Visits: 1191078