IoT DevKit - 9. Recebimento de Dados por LoRaWAN

Introdução

No tutorial anterior aprendemos como nos conectar na rede e como enviar dados para a plataforma PROIoT. Entretanto, assim como diversos dispositivos de IoT, o LoRaWAN Bee é capaz de receber dados vindos da plataforma.

Neste tutorial iremos aprender como receber uma mensagem da plataforma e como utilizá-la para controlar o estado do LED do DevKit.

Lista de Materiais

Lista completa de produtos

comprar

IoT DevKit - LoRaWAN

R$299.90

Configuração da Plataforma

Para este tutorial vamos aproveitar toda a configuração que já fizemos anteriormente na plataforma. A única coisa que vamos ter que adicionar ao nosso projeto é um "Widget" ao painel. Para isso, acesse o seu painel, clique sobre o botão "+ Widget", e então selecione a opção "Requisição", como na imagem a seguir.

Após selecionar esta opção, será exibida uma janela de configuração do Widget, como na imagem abaixo.

configuracao-widget — Configuração do "Widget"

Com esta janela aberta, selecione corretamente a sua "Organização" e a sua "Aplicação" no campo lateral "Variáveis de Dispositivos". Em seguida dê um nome para o "Widget" no campo "Nome do Widget" e crie uma descrição para ele. Feito isso, altere a seleção do campo "Tipo de Requisição" de "HTTP", pré configurada pela plataforma, para "Downlink". Assim será exibido ao lado o "Device EUI" do seu dispositivo e a porta que será usada para enviar a mensagem. Mantenha a porta com a configuração "100", que é pré selecionada pela plataforma. Por fim, digite no campo "Payload" a mensagem "MA==" para que o seu dispositivo fique configurado como na próxima imagem.

widget-configurado — "Widget" Configurado

Feito isso, altere a cor do botão, se desejar, e pressione o botão de confirmação verde.

Você deve estar se perguntando por que a mensagem que será enviada é "MA==". O que isso significa? A plataforma requer que as mensagens sejam enviadas com codificação Base64, portanto precisamos converter os dados que queremos enviar antes de inseri-los no campo. Existem algumas ferramentas online, como esta, que nos ajudam a obter o código em Base64 da mensagem que enviaremos. Neste caso usaremos o caractere "0", que é equivalente a "MA==" em Base64.

Após a confirmação, o "Widget" é adicionado ao painel, logo abaixo do "Widget" criado no tutorial anterior, como na imagem a seguir.

Vale lembrar que, além de alterar o tamanho do "Widget", também é possível movê-lo no painel, se desejar. Para isso, basta clicar na parte superior do "Widget", logo ao lado do seu nome, e então movê-lo enquanto o botão está pressionado.

Atenção: cada requisição enviada pela plataforma consome um "Downlink" do seu plano.

Código

Com a plataforma corretamente configurada, carregue o código a seguir para a sua placa. Lembre-se de alterar os valores "Application EUI" (APPEUI), "Application Key" (APPKEY) e "Alias" (ALIAS) de acordo com os valores configurados na plataforma.

/*******************************************************************************
* IoT DevKit - Envio e Recebimento de Mensagens pelo LoRaWAN Bee (v1.0)
* 
* Codigo usado para enviar as leituras do LDR do IoT DevKit atraves de mensagens
* LoRaWAN. As leituras do sensor sao convertidas para mensagens JSON e entao 
* enviadas por texto para a plataforma PROIoT.
* Este codigo tambem eh capaz de receber e exibir as mensagens recebidas do 
* sevidor, que sao agendadas e entao enviadas no recebimento de uma mensagem. 
* Quando o modulo recebe uma determinada mensagem, o LED do IoT DevKit inverte 
* o seu estado.
* 
* Copyright 2020 RoboCore.
* Escrito por Giovanni de Castro (12/08/2020).
* Creditos: @francois - RoboCore
* 
* 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 "RoboCore_SMW_SX1276M0.h"
#include <HardwareSerial.h>
#include <ArduinoJson.h>

//Declaracao dos pinos de comunicacao serial do Kit
HardwareSerial LoRaSerial(2);
#define RXD2 16
#define TXD2 17

//Criacao do objeto lorawan para a biblioteca SMW_SX1276M0
SMW_SX1276M0 lorawan(LoRaSerial);

//Declaracao da variavel que armazena as respostas do modulo
CommandResponse resposta;

//Declaracao das variaveis que armazenam as informacoes da rede
const char APPEUI[] = "0000000000000000"; //Application EUI
const char APPKEY[] = "00000000000000000000000000000000"; //Application Key
//As variaveis acima devem ser alteradas de acordo com os codigos gerados na plataforma PROIoT

//Declaracao da variavel que armazena o "ALIAS" da variavel da PROIoT
const char ALIAS[] = "Luminosidade"; //Altere essa variavel de acordo com o ALIAS configurado na plataforma

//Declaracao das variaveis de intervalo de tempo
const unsigned long TEMPO_ESPERA = 300000; //5 minutos
unsigned long intervalo;

//Declaracao das variaveis para o LDR
const int PINO_LDR = 15;
int leitura_LDR = 0;

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

//Declaracao da funcao que verifica a conexao do modulo e o recebimento de mensagens
void event_handler(Event);

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

  //Inicia o monitor serial e imprime o cabecalho
  Serial.begin(115200);
  Serial.println(F("Envio e Recebimento de Mensagens da Plataforma PROIoT"));

  //Definicao do pino de reset do modulo
  lorawan.setPinReset(5);
  lorawan.reset(); //Realiza um reset no modulo

  //Inicia a comunicacao serial com o modulo
  LoRaSerial.begin(115200, SERIAL_8N1, RXD2, TXD2);

  //Define o pino conectado ao sensor como uma entrada
  pinMode(PINO_LDR,INPUT);

  //Define o pino conectado ao LED como uma saida
  pinMode(PINO_LED,OUTPUT);

  //Associa a funcao que verifica a conexao do modulo ao objeto "lorawan"
  lorawan.event_listener = &event_handler;
  Serial.println(F("Evento configurado."));

  //Requisita e imprime o Device EUI do modulo
  char deveui[16];
  resposta = lorawan.get_DevEUI(deveui);
  if(resposta == CommandResponse::OK){
    Serial.print(F("DevEUI: "));
    Serial.write((uint8_t *)deveui, 16);
    Serial.println();
  } else {
    Serial.println(F("Erro ao obter o Device EUI"));
  }

  //Configura o Application EUI no modulo
  resposta = lorawan.set_AppEUI(APPEUI);
  if(resposta == CommandResponse::OK){
    Serial.print(F("Application EUI configurado ("));
    Serial.write((uint8_t *)APPEUI, 16);
    Serial.println(')');
  } else {
    Serial.println(F("Erro ao configurar o Application EUI"));
  }

  //Configura o Application Key no modulo
  resposta = lorawan.set_AppKey(APPKEY);
  if(resposta == CommandResponse::OK){
    Serial.print(F("Application Key configurado ("));
    Serial.write((uint8_t *)APPKEY, 32);
    Serial.println(')');
  } else {
    Serial.println(F("Erro ao configurar o Application Key"));
  }

  //Condfigura o metodo de conexao como OTAA
  resposta = lorawan.set_JoinMode(SMW_SX1276M0_JOIN_MODE_OTAA);
  if(resposta == CommandResponse::OK){
    Serial.println(F("Metodo de Conexao Configurado como OTAA"));
  } else {
    Serial.println(F("Erro ao configurar o metodo OTAA"));
  }

  //Requisita conexao com a rede
  Serial.println(F("Conectando a Rede"));
  lorawan.join();
  
}

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

  //Recebe informacoes do modulo
  lorawan.listen();

  if(lorawan.isConnected()){  //Verifica se o modulo esta conectado
    //Executa o envio da mensagem uma vez a cada 5 minutos
    if(intervalo < millis()){
      
      //Realiza a leitura do LDR e mapeia a leitura entre 0 e 100
      leitura_LDR = analogRead(PINO_LDR);
      leitura_LDR = map(leitura_LDR, 0, 4095, 100, 0);
      
      //Cria o objeto dinamico "json" com tamanho "1" para a biblioteca
      DynamicJsonDocument json(JSON_OBJECT_SIZE(1));

      //Atrela ao objeto "json" a leitura do LDR com o nome do Alias definido
      json[ALIAS] = leitura_LDR;

      //Mede o tamanho da mensagem "json" e atrela o valor somado em uma unidade ao objeto "tamanho_mensagem"
      size_t tamanho_mensagem = measureJson(json) + 1;

      //Cria a string "mensagem" de acordo com o tamanho do objeto "tamanho_mensagem"
      char mensagem[tamanho_mensagem];

      //Copia o objeto "json" para a variavel "mensagem" e com o "tamanho_mensagem"
      serializeJson(json, mensagem, tamanho_mensagem);

      //Imprime a mensagem e envia a mensagem como texto pelo modulo
      Serial.print(F("Mensagem: "));
      Serial.println(mensagem);
      resposta = lorawan.sendT(1, mensagem); //Envio como texto

      intervalo = millis() + TEMPO_ESPERA; //Atualiza a contagem de tempo
      
    }
  } else {    //Se o modulo nao estiver conectado
    //Imprime um "." a cada 5 segundos
    if(intervalo < millis()){
      Serial.println('.');
      intervalo = millis() + 5000; //Atualiza a contagem de tempo
      
    }
  }

}

//------------------------------------------------------------------------

void event_handler(Event type){

  //Verifica se o modulo esta conectado e atualiza essa informacao
  if(type == Event::JOINED){
    Serial.println(F("Conectado!"));
  }

  //Verifica se o modulo recebeu alguma mensagem
  else if(type == Event::RECEIVED_X){
    Serial.println(F("Mensagem Hexadecimal Recebida!"));

    //Declaracao da variavel "porta"
    uint8_t porta;

    //Declaracao da variavel "leitura_buffer"
    uint8_t leitura_buffer;

    //Declaracao do objeto "buffer"
    Buffer buffer;

    //Atrela a variavel "resposta" o que foi retornado pelo módulo
    resposta = lorawan.readX(porta, buffer);
    if(resposta == CommandResponse::OK){ //Se retornar "<OK>"
      Serial.print(F("Mensagem: "));
      for(uint8_t i=0 ; i < buffer.available() ; i++){
        leitura_buffer = buffer[i];
        Serial.write(leitura_buffer);
      }
      if(leitura_buffer == '0'){
        Serial.print(F(" (zero)"));
        estado =! estado; //Inverte a variavel "estado"
        digitalWrite(PINO_LED,estado); //Aciona o LED de acordo com a variavel "estado
      }
      Serial.print(F(" na porta "));
      Serial.println(porta);
    }
  }
  
}

Entendendo o Código

O código acima é basicamente igual ao que utilizamos para enviar mensagens no tutorial anterior, porém, nas declarações globais do código, nós declaramos as variáveis PINO_LED e estado, que são responsáveis por armazenar o pino em que o LED do IoT DevKit está conectado e o estado de acionamento do LED (alto - HIGH - ou baixo - LOW). Inicialmente a variável de estado é mantida como nível baixo, pois ela ainda não recebeu a mensagem configurada pela plataforma.

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

Na configuração do código, apenas declaramos o pino do LED como uma saída da placa através do comando pinMode(PINO_LED, OUTPUT).

//Define o pino conectado ao LED como uma saida
pinMode(PINO_LED,OUTPUT);

A grande mudança deste código para o anterior é justamente na função event_handler, que além de verificar se o módulo se conectou à rede, também é responsável por verificar as mensagens recebidas. Nela, utilizamos a condição else if(type == Event::RECEIVED_X) para verificar se o módulo recebeu uma mensagem hexadecimal. Então, se uma mensagem foi recebida, nós criamos as variáveis porta, que irá armazenar a porta da rede em que a mensagem foi enviada, e leitura_buffer, que será usada para armazenar cada caractere da mensagem recebida, juntamente com a criação do objeto buffer, que possibilita o gerenciamento da mensagem recebida. Em seguida, nós armazenamos a mensagem no objeto buffer, juntamente com a porta da mensagem na variável porta, através do comando resposta = lorawan.readX(porta, buffer). Depois verificamos se a resposta do módulo (salva na variável resposta) é igual a "<OK>", por meio da condição if(resposta == CommandResponse::OK).

Caso esta condição seja verdadeira, ou seja, caso o módulo retorne um "<OK>", nós atribuímos cada caractere da mensagem recebida à variável leitura_buffer utilizando o comando leitura_buffer = buffer[i], que é repetido enquanto a variável i for menor que o tamanho total da mensagem recebida (for(uint8_t i=0 ; i < buffer.available() ; i++)). Ainda nesse laço, aproveitamos para imprimir cada caractere no monitor serial. Após a última iteração, temos o último caractere armazenado na variável leitura_buffer. Com isso, nós verificamos se ele é igual a "0" com a condição if(leitura_buffer == '0'). Se essa condição for verdadeira, invertemos a lógica da variável estado utilizando o comando estado = !estado e atualizamos o estado físico do LED. Ou seja, se ele estava apagado antes, agora ele estará aceso, e vice-versa.

//Verifica se o modulo recebeu alguma mensagem
else if(type == Event::RECEIVED_X){
  Serial.println(F("Mensagem Hexadecimal Recebida!"));

  //Declaracao da variavel "porta"
  uint8_t porta;

  //Declaracao da variavel "leitura_buffer"
  uint8_t leitura_buffer;

  //Declaracao do objeto "buffer"
  Buffer buffer;

  //Atrela a variavel "resposta" o que foi retornado pelo módulo
  resposta = lorawan.readX(porta, buffer);
  if(resposta == CommandResponse::OK){ //Se retornar "<OK>"
    Serial.print(F("Mensagem: "));
    for(uint8_t i=0 ; i &ly; buffer.available() ; i++){
      leitura_buffer = buffer[i];
      Serial.write(leitura_buffer);
    }
    if(leitura_buffer == '0'){
      Serial.print(F(" (zero)"));
      estado =! estado; //Inverte a variavel "estado"
      digitalWrite(PINO_LED,estado); //Aciona o LED de acordo com a variavel "estado
    }
    Serial.print(F(" na porta "));
    Serial.println(porta);
  }
}

Como a última passagem do código é complexa e pode gerar dúvidas, vamos ver um exemplo com uma mensagem mais simples, sendo ela "OLA". Quando esta mensagem é recebida pelo módulo, os seus caracteres são contabilizados ("OLA" possui 3 caracteres) e então são salvos um de cada vez na variável leitura_buffer. Em outras palavras, a variável leitura_buffer recebe 3 caracteres em sequência, sendo eles "O", "L" e "A", que são respectivamente impressos no monitor serial, formando a mensagem completa "OLA". Entretanto, somente o último caractere da mensagem ("A" no nosso exemplo) é verificado (condição if apresentada acima), pois ele fica salvo na variável após o laço de impressão de caracteres (função for no código).

O Que Deve Acontecer

Após carregar o código para a placa, aguarde até que o módulo se conecte à rede, e então pressione o botão do "Widget" criado anteriormente. Isso fará com que a mensagem seja agendada para envio, exibindo a mensagem da imagem a seguir.

Feito isso, o módulo irá enviar para a plataforma novamente os valores de luminosidade ambiente, como no tutorial anterior, porém, após o envio da mensagem, ele irá receber a mensagem agendada na plataforma, como na próxima imagem.

resposta-obtida-monitor-serial — Resposta Obtida no Monitor Serial

O projeto funcionou corretamente, mas imaginamos que você está com algumas dúvidas. A primeira delas deve ser por que a mensagem só é recebida após o envio de uma mensagem. O módulo LoRaWAN Bee que estamos usando no DevKit está configurado com a classe de dispositivos "A", e você deve se lembrar dos conceitos apresentados no tutorial introdutório deste protocolo que, na classe "A", o dispositivo possui duas janelas de recepção de informações do servidor e elas só são abertas após o envio de uma mensagem.

Outra pergunta que você deve estar se fazendo é em relação à mensagem recebida: "se "MA==" em Base64 é equivalente a "0", por que recebemos a mensagem "30"?" A mensagem é recebida pelo módulo no formato hexadecimal, após a conversão através da tabela ASCII de sinais gráficos imprimíveis. Levando isso em conta, e procurando na tabela ASCII pelo caractere "0", temos que o seu valor hexadecimal é equivalente a "30", o valor que recebemos pelo módulo. Inclusive os caracteres de "0" a "9" são sequenciados na tabela ASCII de "30" a "39", como na imagem a seguir, portanto é simples replicar este projeto para ter mais botões e condições (por exemplo if(leitura_buffer == '1') se a plataforma for configurada para enviar a mensagem equivalente a "1").

tabela-ascii — Tabela ASCII
Fonte: ASC Ohio State

Juntamente com a resposta do monitor serial, é possível observar que o LED do DevKit acendeu, como na próxima imagem.

Se após acender o LED você desejar apagá-lo, basta agendar novamente o envio da mensagem. Esta requisição da plataforma funciona basicamente como um botão virtual.

Conclusão

Neste tutorial vimos mais uma das funcionalidades do IoT DevKit, aprendendo a receber mensagens da PROIoT pelo módulo LoRaWAN Bee. Agora vamos avançar em nossos estudos e criar uma estação de monitoramento com todos os sensores do kit.

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 configurado, portanto certifique-se que o modelo da placa nas "Ferramentas" da IDE está como "ESP32 Dev Module".

Mensagem foi Agendada pela Plataforma, mas Não foi Recebida pelo Módulo

Se a sua mensagem foi agendada pela plataforma, mas não foi recebida pelo módulo, verifique se as mensagens enviadas pelo módulo foram recebidas pela plataforma, pois lembre-se que a mensagem da plataforma só é enviada quando uma mensagem do módulo é recebida na plataforma. Além disso, certifique-se que os "Uplinks" e "Downlinks" estão ativados nas configurações do seu dispositivo, como na imagem a seguir.

uplink-downlink-ativados — "Uplinks" e "Downlinks" Ativados