Arduino: MQTT

MQTT e Arduino

O suporte para MQTT para Arduíno é provido por uma biblioteca que pode ser obtida em: https://github.com/knolleary/pubsubclient .

Uma boa descrição do uso da biblioteca PubSubClient.h pode ser encontrada em:

Para interagir com a rede é necessário um shild Ethernet colocado sobre a placa Arduíno.

Limitações do MQTT para Arduíno

• Suporta somente publicações com QoS=0 e subscrições com QoS=0 ou QoS=1.
• Suporta somente CleanSessions devido a limitação de memória.
• Tamanho máximo de mensagem com 128 bytes por default.
• Intervalo de keep alive de 15 s por default.

  Os dois últimos parâmetros podem ser alterados na biblioteca PubSubClient.h:

  MQTT_MAX_PACKET_SIZE

  MQTT_KEEPALIVE

Hardware compatível

• Shield Ethernet
• Arduíno Ethernet
• Arduíno Yun
• Arduíno Wifi
• ESP8266
• ESP32

Experimento: MQTT e Arduino

Neste experimento foi utilizado um Arduino UNO com um Shield Ethernet, rodando a biblioteca PubSubClient.h para interagir um com brocker Mosquitto e clientes publicadores e subscritores através do protocolo MQTT.

A comunicação foi realizada através de uma rede local residencial e foram utilizados os seguintes endereços IP:

• brocker Mosquito: 192.168.1.16/24
• Arduino: 192.168.1.50/24
• Clientes (mosquitto_pub e mosquitto_sub): 192.168.1.16/24

Código fonte Arduino

O código Arduino abaixo descreve o cenário da aplicação e ilustra o uso das funções da biblioteca PubSubClient.h para implementar a comunicação MQTT.

/*            
 Baseado no exemplo da bilbioteca PubSubClient.h: Basic MQTT example

 Exemplo: MQTT com Arduíno/Shield Ethernet e Mosquitto: 
 Anunciar status do Arduino, receber comando para led e publicar status do led.

 Este sketch demonstra a comunicação de um Arduino com um brocker Mosquitto usando MQTT:
  - conecta ao brocker e informa lastWill para o tópico "arduino/status" com mensagem "off-line"
    (será publicada caso o Arduino seja desconectado involuntariamente);
  - publica para o tópico "arduino/status" a mensagem  "on-line" anunciando que está ativo;
  - subscreve o tópico "arduino/led" para receber comandos para um led;
  - caso receba mensagem para o tópico "arduino/led", aciona o led conforme comando recebido.
*/

#include <SPI.h>
#include <Ethernet.h>
#include <PubSubClient.h>

// Endereçamento IP utilizado para o cliente e servidor
byte mac[]    = { 0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED };
IPAddress ip(192, 168, 1, 50);
IPAddress server(192, 168, 1, 16);

EthernetClient ethClient;
PubSubClient client(ethClient);

//Função callback chamada quando uma mensagem for recebida para subscrições:
void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("message arrived [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i=0;i<length;i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();
  //comanda o LED
  if ((char)payload[0] == '1') {
    digitalWrite(4, HIGH);
  } else if  ((char)payload[0] == '0') {
    digitalWrite(4, LOW);
  } 
}

void setup()
{
  Serial.begin(57600);

  pinMode(4, OUTPUT);

  client.setServer(server, 1883);
  client.setCallback(callback);

  Ethernet.begin(mac, ip);
  delay(5000); // Allow the hardware to sort itself out
  
  delay(10000);
}

void loop(){
  // Aguarda conexão    
  while (!client.connected()) {

    Serial.print("Attempting MQTT connection...");

    //Mensagem lastWill
    byte willQoS = 0;
    const char* willTopic = "arduino/status";
    const char* willMessage = "OFF_LINE";
    boolean willRetain = true;
    //Conexão
    if (client.connect("arduinoClient", willTopic, willQoS, willRetain, willMessage)) {
      Serial.println("connected");
      //Uma vez conectado publica status
      char* message = "ON_LINE";
      int length = strlen(message);
      boolean retained = true; //Retain message
      client.publish("arduino/status", (byte*)message, length, retained);
      // ... and resubscribe
      client.subscribe("arduino/led");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      delay(5000);
    }
  }
  //Uma vez conectado client.loop() deve ser chamada periodicamente para manter conexão
  //e aguardar recebimento de mensagens
  client.loop();
}

Análise da troca de mensagens com Wireshark

A comunicação foi realizada através de uma rede local residencial e foram utilizados os seguintes endereços IP:

• Brocker Mosquito: 192.168.0.13/24
• Arduino: 192.168.0.30/24
• Clientes (mosquitto_pub e mosquitto_sub): 192.168.0.18/24

Análise das mensagens trocadas

• Na marca de tempo 5.6... um cliente se conectou ao brocker e subscreveu o tópico "status".
• Na marca de tempo 36.3... o Arduíno se conectou ao brocker e informou tópico/mensagem lastWill ("status = OFF_LINE"), publicou o tópico "status = ON_LINE" e subscreveu o tópico "led". O brocker também publicou o tópico "status" para o cliente.
• Na marca de tempo 42.6... outro cliente se conectou ao brocker e publicou o tópico "led = ON". O brocker também publicou o tópico "led = ON" ao Arduino (que acionou um led) e publicou ao cliente o tópico "status = ON_LINE: led ON"
• Em seguida o Arduíno foi desligado.
• Na marca de tempo 65.6..., como o brocker não recebeu do Arduíno um PINGREC, ele supos que o Arduino foi desconectado involuntariamente e publicou ao cliente o tópico "status = OFF_LINE".

Observação

As mensagens em preto, com indicação de TCP ACKED unseen segment, como indicado em , "se referem a pacotes que foram transferidos e reconhecidos, mas que não foram capturados pelo Wireshark. Usualmente isto acontece quando o dispositivo não é rápido o suficiente". O que pede ser o caso do Arduino.

MQTT e ESP8266

O suporte para MQTT para o ESP8266 é provido por uma biblioteca que pode ser obtida em: https://github.com/knolleary/pubsubclient .

Neste experimento foi utilizado um NodeMCU 8266 utilizando a biblioteca PubSubClient.h para interagir um com brocker Mosquitto e clientes publicadores e subscritores através do protocolo MQTT.

A comunicação foi realizada através de uma rede local residencial e foram utilizados os seguintes endereços IP:

• brocker Mosquito: 192.168.1.16/24
• ESP: 192.168.1.19/24 (Obtido por DHCP da rede Wifi)
• Clientes (mosquitto_pub e mosquitto_sub): 192.168.1.16/24

Código fonte ESP8266

O código abaixo é baseado no exemplo mqtt_esp8266 da biblioteca PubSubClient.h:

/*
 Basic ESP8266 MQTT example
 Baseado no exemplo da bilbioteca PubSubClient.h: mqtt_esp8266

 Este sketch demonstra a comunicação de um ESP8266 com um brocker Mosquitto usando MQTT:
  - conecta ao brocker e informa lastWill para o tópico "esp/status" com mensagem "off-line"
    (será publicada caso o ESP seja desconectado involuntariamente);
  - publica para o tópico "esp/status" a mensagem  "on-line" anunciando que está ativo;
  - subscreve o tópico "esp/led" para receber comandos para um led;
  - caso receba mensagem para o tópico "esp/led", aciona o led conforme comando recebido.
  - publica periodicamente para o tópico "esp/temperatura" a temperatura medida por um sensor LM35.
 O ESP se reconecta so servidor caso perca a conexão.
*/

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

//Varíaveis sensor temperatura
char msgTemperatura[10];
float temperatura;

// Identificação da rede Wifi
const char* ssid = "Zhone_EB1C";
const char* password = "aaaaabbbbb";

// Identificação do Brocker
const char* mqtt_server = "192.168.1.16"; 

unsigned long lastMsg = 0;

WiFiClient espClient;
PubSubClient client(espClient);

void setup_wifi() {
  delay(10);
  // Conecta a rede WiFi
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  randomSeed(micros());
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Message arrived [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();
  // Aciona LED se 1 for recebido como primeiro caractere
  if ((char)payload[0] == '1') {
    digitalWrite(BUILTIN_LED, HIGH);   
  } else {
    digitalWrite(BUILTIN_LED, LOW);  
  }
}

void reconnect() {
  //Mensagem lastWill
  byte willQoS = 0;
  const char* willTopic = "esp/status";
  const char* willMessage = "OFF_LINE";
  boolean willRetain = true;
  // Loop até reconectar
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Cria identificação randômica do cliente
    String clientId = "ESP8266Client-";
    clientId += String(random(0xffff), HEX);
    if (client.connect(clientId.c_str(), willTopic, willQoS, willRetain, willMessage)) {
      Serial.println("connected");
      // Uma vez conectado publica anúncio:
      char* message = "ON_LINE";
      int length = strlen(message);
      boolean retained = true; 
      client.publish("esp/status", (byte*)message, length, retained);
      // Subscreve tópico
      client.subscribe("esp/led");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      delay(5000);
    }
  }
}

void setup() {
  pinMode(BUILTIN_LED, OUTPUT);     
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
  unsigned long now = millis();
  if (now - lastMsg > 5000) {
    lastMsg = now;
    //Sensor temperatura LM35
    int   analogValue = analogRead(A0);
    float millivolts = (analogValue/1024.0) * 3.3;
    float temperatura = millivolts*100;
    //Publicação da temperatura
    Serial.print("Publish message: ");
    Serial.print("temperature oC = ");
    Serial.println(temperatura);
    //converte temperatura em string
    sprintf(msgTemperatura,"%.1f",temperatura);
    Serial.println(msgTemperatura);
    boolean retained = true; 
    client.publish("esp/temp", (byte*)msgTemperatura, strlen(msgTemperatura), retained);
    }
}

Sensor de temperatura LM35

O LM35 é um circuito integrado exclusivo para medir temperatura com uma tensão de saída variando linearmente com a temperatura em graus Célsius.

Na configuração básica este sensor mede temperaturas entre 2^oC e 150^oC, variando a saída em função da temperatura de 0 mV + 10mV por 1^oC.

Com a configuração mostrada em é possível medir temperatura de -55^oC e 150^oC.

Esquema de ligação com Esp

            _______
           |       |
           | LM 35 | 
           |_______|
             | | |
 (+3,3v) ----+ | +---- (Ground)
               |
          Analog Pin A0
       0mV + 10mV / oC

Leitura pela entrada analógica do Esp

O valor de tensão (entre 0V e 3,3V) lido pelo Esp na entrada analógica é convertido um número digital com 10 bits de magnitude, ou seja, 2¹⁰ (1024) valores (entre 0 e 1023).

Para obter o valor de tensão, para uso no cálculo da temperatura, multiplica-se o valor digital obtido na leitura por 3.3/1023.

Como a tensão medida pelo sensor varia de 0 mV + 10mV/1^oC, se multiplicarmos por 100, teremos o valor em graus Celsius:

Referências

---

Evandro.cantu (discussão) 11h19min de 8 de outubro de 2020 (-03)