IoT DevKit - 13. Recebimento de Dados por MQTT

Introdução

No tutorial anterior aprendemos como enviar dados para a PROIoT utilizando a conectividade Wi-Fi e o protocolo MQTT. Porém, assim como o protocolo LoRaWAN, também é possível receber informações da plataforma com a conectividade Wi-Fi.

Neste tutorial iremos aprender como enviar mensagens da plataforma para o ESP32 utilizando o protocolo MQTT, e então alterar o estado do LED quando uma determinada mensagem for recebida.

Lista de Materiais

Lista completa de produtos

comprar

IoT DevKit - LoRaWAN

R$299.90

Configuração da Plataforma

Para esse tutorial aproveitaremos toda a configuração que fizemos na plataforma para o tutorial anterior. A única coisa que adicionaremos é um "Widget". Para isso, acesse o painel que criamos para o ESP32 anteriormente, pressione o botão "+ Widget" e selecione a opção "Requisição", como na imagem a seguir.

widget-requisicao-selecionado — "Widget" "Requisição" Selecionado

Feito isso, será aberta uma janela para a configuração do "Widget", como na imagem abaixo.

janela-configuracao-widget — Janela de Configuração do "Widget"

Com essa janela aberta, selecione corretamente a sua "Organização" e a sua "Aplicação" na seção lateral, então dê um nome e uma descrição para o "Widget". Em seguida altere o campo "Tipo de Requisição" de "HTTP", pré selecionada pela plataforma, para "MQTT". Isso fará com que os campos de configuração se alterem um pouco na janela. Neste momento, digite no campo "Porta" o valor "1883" e no campo "Host" o link "http://mqtt.proiot.network". Feito isso, agora temos que configurar alguns parâmetros que foram gerados na plataforma. No campo "Usuário", digite o Token API gerado anteriormente, e no campo "Tópico", digite "device/ID_DISPOSITIVO", lembrando de alterar a parte "ID_DISPOSITIVO" pelo código gerado pela plataforma anteriormente. Por fim, digite no campo "Payload" a mensagem "L", que será utilizada para alterar o estado do LED. Deste modo o seu "Widget" deve ficar configurado como o da próxima imagem.

widget-configurado — "Widget" Configurado

Com isso, altere a cor do botão se desejar, e então pressione o botão de confirmação verde. Assim o "Widget" será adicionado ao painel do ESP32, como na imagem a seguir.

Vale lembrar que você pode alterar o tamanho e a posição do "Widget" no painel, se desejar.

Código

Com a plataforma configurada, carregue o código a seguir para a sua placa, lembrando de alterar as variáveis que armazenam o nome e a senha da sua rede Wi-Fi (REDE e SENHA respectivamente), juntamente com as variáveis que armazenam o ID único do seu dispositivo (ID_DISPOSITIVO) e o Token API (TOKEN_API), que foram gerados pela plataforma.

/*******************************************************************************
* IoT DevKit - Recebimento de Mensagens pelo ESP32 (Wi-Fi / MQTT) (v1.0)
* 
* Codigo usado para receber as mensagens enviadas pela PROIoT, e entao alterar o
* estado do LED do Kit quando uma determinada mensagem for recebida.
* 
* Copyright 2020 RoboCore.
* Escrito por Giovanni de Castro (02/09/2020).
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

//Verifica se o modelo de placa selecionado esta correto
#if !defined(ARDUINO_ESP32_DEV) // ESP32
#error Use this example with the ESP32
#endif

//Inclusao das Bibliotecas
#include <WiFi.h>
#include <PubSubClient.h>

//Declaracao das variaveis da rede Wi-Fi
const char* REDE = "SUA-REDE-WIFI-AQUI";
const char* SENHA = "SENHA-SUA-REDE-AQUI";

//Criacao dos objetos que serao resposaveis pela conexao ao servidor
WiFiClient cliente; //Objeto "cliente" para a biblioteca WiFi
PubSubClient MQTT(cliente); //Objeto "MQTT" para a biblioteca PubSubClient através do objeto "cliente"

//Declaracao do servidor e da sua porta
const char* SERVIDOR = "mqtt.proiot.network";
const uint16_t PORTA = 1883;

//Declaracao das variaveis geradas na plataforma
const char* ID_DISPOSITIVO = "ID-DISPOSITIVO-AQUI"; //ID Unico do Dispositivo
const char* TOKEN_API = "SEU-TOKEN-API-AQUI"; //Token da Organizacao
//Altere as variaveis acima de acordo com os valores gerados na plataforma

//Declaracao da variavel que armazena a senha de conexao ao servidor
const char* SENHA_ID = ""; //Nao e necessario altera-la

//Declaracao da variavel auxiliar para a criacao do topico para publish
char TOPICO[50] = "device/";

//Declaracao da variavel que armazena o intervalo de tempo entre mensagens
unsigned long reconecta; //Variavel para a conexao com o servidor

//Declaracao das variaveis para o LED
const int PINO_LED = 13;
int estado = LOW;

//---------------------------------------------------------------------------------------
void setup (){

  //Inicializacao do monitor serial
  Serial.begin(115200);
  Serial.println("Recebimento de dados da PROIoT usando MQTT");

  //Define o "PINO_LED" como uma saida
  pinMode(PINO_LED, OUTPUT);

  //Requisita a conexao do dispositivo a rede
  Serial.print("Conectando a rede: ");
  Serial.println(REDE);
  WiFi.mode(WIFI_STA);
  WiFi.begin(REDE,SENHA);

  //Aguarda ate que o dispositivo se conecte a rede
  while(WiFi.status() != WL_CONNECTED){
    delay(100);
    Serial.print(".");
  }

  //Quando conectado, exibe o endereco IP
  Serial.println("Conectado!");
  Serial.print("Endereco IP: ");
  Serial.println(WiFi.localIP());

  //Indica para o objeto "MQTT" em que servidor e em que porta iremos nos conectar
  Serial.print("Servidor configurado: ");
  Serial.print(SERVIDOR);
  Serial.print(" : ");
  Serial.println(PORTA);
  MQTT.setServer(SERVIDOR,PORTA);

  //Atribui a funcao "mqtt_callback" (do final do codigo) ao objeto "MQTT"
  MQTT.setCallback(mqtt_callback);

  //Concatena a variavel "TOPICO" com a variavel "ID_DISPOSITIVO"
  strcat(TOPICO,ID_DISPOSITIVO);
  
}

//---------------------------------------------------------------------------------------
void loop (){

  //Mantem a conexao ativa com o servidor
  MQTT.loop();

  //Verifica a conexao com o servidor
  if(!MQTT.connected()){ //Se nao estiver conectado
    if(reconecta < millis()){ //Executa a solicitacao de conexao a cada 5 segundos
      Serial.println("");
      Serial.println("Conectando ao servidor...");
      //Solicita a conexao com o servidor utilizando os parametros "ID_DISPOSITIVO", "TOKEN_API" e "SENHA_ID" 
      if(!MQTT.connect(ID_DISPOSITIVO, TOKEN_API, SENHA_ID)){ 
        Serial.println("Falha na conexao com o servidor.");
      } else {
        Serial.println("Conectado!");
        Serial.print("Estabelecendo inscricao com ");
        Serial.println(TOPICO);
        //Solicita a inscricao no "TOPICO"
        if(!MQTT.subscribe(TOPICO)){
          Serial.println("Erro ao se inscrever no topico");
          Serial.println("Desconectando do servidor...");
          MQTT.disconnect(); //Desconecta a placa do servidor
          Serial.println("Desconectado.");
        } else {
          Serial.println("Inscricao concluida!");
        }
      }
      reconecta = millis() + 5000; //Atualiza a contagem de tempo
    }
  }
  
}

//---------------------------------------------------------------------------------------
void mqtt_callback (char* topico, byte* payload, unsigned int comprimento){

  //Declaracao da variavel que armazena a mensagem recebida
  String mensagem;

  //Salva os caracteres da mensagem a variavel "mensagem"
  for(int i = 0; i < comprimento; i++){
    char c = (char)payload[i];
    mensagem += c;
  }

  //Verifica a mensagem recebida
  if(mensagem == "L"){
    estado = !estado; //Inverte a variavel "estado"
    digitalWrite(PINO_LED, estado); //Aciona o "PINO_LED" de acordo com o "estado"
  }
  Serial.println("");
  Serial.print("Mensagem recebida: ");
  Serial.println(mensagem);
  
}

Entendendo o Código

O código deste projeto é parecido com o utilizado no tutorial anterior, porém não utilizamos as bibliotecas "ArduinoJson" e "DHT", pois não enviaremos as leituras do sensor para a plataforma. Além disso, ao invés de declararmos variáveis e objetos para o sensor DHT11, apenas declaramos a variável PINO_LED, que armazena o pino do ESP32 que está conectado ao LED do DevKit, e a variável estado, que armazena o estado de acionamento do LED (alto - HIGH - ou baixo- LOW). Inicialmente a variável de estado é mantida com nível baixo, pois ainda não recebemos a mensagem da plataforma. Por fim, nas declarações globais do código, nós não declaramos as variáveis responsáveis por realizar o intervalo de tempo entre envio de mensagens, já que neste código apenas receberemos as mensagens da plataforma.

//Declaracao das variaveis para o LED
const int PINO_LED = 13;
int estado = LOW;

Já nas configurações do código, como não vamos utilizar o sensor DHT, não precisamos iniciá-lo com o comando dht.begin(). Ao invés disso, definimos o pino conectado ao LED como uma saída do sistema (pinMode(PINO_LED, OUTPUT)). Além disso, nós atribuímos ao objeto MQTT a função mqtt_callback, do final do código, através do comando MQTT.setCallback(mqtt_callback). Isso faz com que essa função seja executada quando o ESP32 receber uma mensagem no tópico inscrito.

//Define o "PINO_LED" como uma saida
pinMode(PINO_LED, OUTPUT);
      
//Atribui a funcao "mqtt_callback" (do final do codigo) ao objeto "MQTT"
MQTT.setCallback(mqtt_callback);

A repetição do código é bem parecida com a do tutorial anterior, porém não temos a lógica de conversão e envio das leituras do sensor. Neste código, caso o ESP32 não esteja conectado ao servidor, repetimos todas as verificações e a reconexão do tutorial anterior. Porém, além disso, nos inscrevemos no tópico do nosso dispositivo, que está armazenado na variável TOPICO, através da condição if(!MQTT.subscribe(TOPICO)), que também verifica se a inscrição foi feita com sucesso. Caso a inscrição não foi feita com sucesso, informamos isso no monitor serial e desconectamos o ESP32 do servidor para tentarmos a reconexão após 5 segundos. Entretanto, caso a inscrição tenha sido feita com sucesso, apenas mantemos a conexão com o servidor ativa.

//Mantem a conexao ativa com o servidor
MQTT.loop();

//Verifica a conexao com o servidor
if(!MQTT.connected()){ //Se nao estiver conectado
  if(reconecta &ly; millis()){ //Executa a solicitacao de conexao a cada 5 segundos
    Serial.println("");
    Serial.println("Conectando ao servidor...");
    //Solicita a conexao com o servidor utilizando os parametros "ID_DISPOSITIVO", "TOKEN_API" e "SENHA_ID" 
    if(!MQTT.connect(ID_DISPOSITIVO, TOKEN_API, SENHA_ID)){ 
      Serial.println("Falha na conexao com o servidor.");
    } else {
      Serial.println("Conectado!");
      Serial.print("Estabelecendo inscricao com ");
      Serial.println(TOPICO);
      //Solicita a inscricao no "TOPICO"
      if(!MQTT.subscribe(TOPICO)){
        Serial.println("Erro ao se inscrever no topico");
        Serial.println("Desconectando do servidor...");
        MQTT.disconnect(); //Desconecta a placa do servidor
        Serial.println("Desconectado.");
      } else {
        Serial.println("Inscricao concluida!");
      }
    }
    reconecta = millis() + 5000; //Atualiza a contagem de tempo
  }
}

A maior diferença deste código para o do tutorial anterior é justamente a função mqtt_callback, que é declarada juntamente com as variáveis topico, payload e comprimento, que são responsáveis por armazenar o tópico, o conteúdo e o comprimento da mensagem recebida, respectivamente. Dentro da função, declaramos a variável mensagem, que armazenará a mensagem completa recebida pela placa.

Com isso, utilizamos o laço for(int i = 0; i < comprimento; i++) para repetir o processo de cópia dos caracteres da mensagem na variável mensagem enquanto a variável auxiliar i for menor que a variável comprimento. Esse processo de salvamento da mensagem é realizado graças à variável auxiliar c, que armazena um a um os caracteres da variável payload por meio do comando char c = (char)payload[i]. Deste modo, todos os caracteres são adicionados em sequência na variável mensagem pelo comando mensagem += c. Quando toda a mensagem estiver salva, utilizamos a condição if(mensagem == "L") para verificar se a mensagem recebida é igual a "L". Caso essa condição seja verdadeira, invertemos o estado da variável estado por meio do comando estado = !estado, que então é utilizada para acionar o LED através do comando digitalWrite(PINO_LED, estado).

void mqtt_callback (char* topico, byte* payload, unsigned int comprimento){

  //Declaracao da variavel que armazena a mensagem recebida
  String mensagem;

  //Salva os caracteres da mensagem a variavel "mensagem"
  for(int i = 0; i < comprimento; i++){
    char c = (char)payload[i];
    mensagem += c;
  }

  //Verifica a mensagem recebida
  if(mensagem == "L"){
    estado = !estado; //Inverte a variavel "estado"
    digitalWrite(PINO_LED, estado); //Aciona o "PINO_LED" de acordo com o "estado"
  }
  Serial.println("");
  Serial.print("Mensagem recebida: ");
  Serial.println(mensagem);
  
}

O Que Deve Acontecer

Assim que o código for carregado para a placa, abra o monitor serial e, assim que a placa se inscrever ao tópico do protocolo, pressione o botão do "Widget" criado na plataforma. Isso fará com que a mensagem que configuramos seja enviada para o ESP32, apresentando um símbolo de confirmação verde, como na imagem a seguir.

Feito isso, será possível observar a mensagem sendo exibida no monitor serial, como na imagem abaixo.

resposta-moniotr-serial — Resposta Monitor Serial

E com isso, o LED do IoT DevKit irá se acender, como na próxima imagem.

Se você quiser apagar o LED depois de aceso, basta pressionar novamente o botão da plataforma, pois ele atua basicamente como um botão virtual.

É interessante observar a diferença entre o protocolo LoRaWAN e o MQTT. Como vimos no tutorial de recebimento de mensagens com LoRaWAN, o LoRaWAN Bee só recebe as mensagens da plataforma após enviar uma mensagem para a mesma, enquanto com o protocolo MQTT não precisamos enviar uma mensagem para a plataforma para autorizar o recebimento de outra. Essa pode ser uma característica fundamental para algumas aplicações que exigem uma resposta rápida para o dispositivo.

Conclusão

Neste tutorial vimos a diferença no funcionamento entre as conectividades Wi-Fi por MQTT e LoRaWAN do IoT DevKit para o recebimento de mensagens, aprendendo como receber dados da PROIoT e como tratá-los para tomar uma decisão.

Solução de Problemas

Se mesmo seguindo as soluções propostas abaixo você não conseguir solucionar o seu problema, encaminhe um e-mail para suporte@robocore.net para que possamos te ajudar da melhor maneira possível.

Arduino IDE Retornou a Mensagem "#error Use this example with the ESP32"

Como vimos anteriormente, esta é uma mensagem personalizada que criamos no início do código para quando o modelo de placa selecionado não está corretamente selecionado, portanto certifique-se que o modelo da placa nas "Ferramentas" da IDE está como "ESP32 Dev Module".

Monitor Serial Apresenta Pontos Infinitamente e Não se Conecta

Se isso acontecer, verifique as variáveis REDE e SENHA do código carregado, pois é possível que elas não estejam exatamente iguais aos parâmetros configurados no roteador. Além disso, certifique-se que tanto a rede quanto a senha não possuem caracteres especiais, como acentos, pois o ESP32 não deve estar os interpretando corretamente.

Monitor Serial Apresentou a Mensagem "Falha na conexao com o servidor."

Se esta mensagem for exibida no monitor serial, verifique as variáveis ID_DISPOSITIVO e TOKEN_API, pois é possível que elas não sejam exatamente iguais aos parâmetros gerados na plataforma. Além disso, verifique se o seu dispositivo está com a opção "Conectado" selecionada na plataforma, como na imagem abaixo. Se não estiver selecionado, selecione esta opção e observe o resultado ao tentar novamente.

dispositivo-conectado — Dispositivo Conectado