IoT DevKit - 8. Envio de Dados por LoRaWAN

This tutorial is not available in English

Introdução

No tutorial anterior tivemos o nosso primeiro contato com o módulo LoRaWAN Bee, porém não chegamos a fazer o que realmente se espera de um dispositivo IoT, ou seja, ainda não nos conectamos à rede. Consequentemente ainda não chegamos a enviar a nossa primeira mensagem.

Neste tutorial iremos aprender como configurar corretamente a plataforma online, como utilizar os comandos da biblioteca para estabelecermos a primeira conexão e enviar a primeira mensagem.

Lista de Materiais

Lista completa de produtos

comprar

IoT DevKit - LoRaWAN

R$ 322,90 no PIX

Configuração da Plataforma

Neste kit usaremos a PROIoT como plataforma de exibição de dados, portanto primeiramente crie a sua conta na plataforma para que possamos prosseguir. Além disso, iremos utilizar uma linha ATC paga para nos conectar e enviar as mensagens, portanto realize a compra do plano antes de tentar qualquer conexão com a plataforma. Lembre-se de verificar a disponibilidade da linha ATC na sua região antes de efetuar a compra.

Criação do Dispositivo

Agora que a conta está criada e o plano está comprado, temos que criar uma "Aplicação" dentro da sua "Organização" antes de configurar um dispositivo LoRaWAN. Para isso, acesse a seção "Organização" da plataforma, onde será exibido um resumo de sua "Organização" com o número de "Aplicações", "Tokens API", "Gateways", "Perfis - LoRa Privado" e "Perfis - ATC LoRaWAN". Então clique sobre esta janela de resumo, como na primeira imagem abaixo. Caso você ainda não tenha uma "Organização", apenas clique no botão "+ Organização" digite um nome para ela e pressione o botão de confirmação verde. Ao clicar sobre a janela de resumo, você é redirecionado para uma página de configuração da "Organização", mais especificamente para a seção de "Aplicações". Com esta seção aberta, pressione o botão "+ Aplicação" digite um nome para ela e pressione o botão de confirmação verde, como na segunda imagem abaixo.

resumo-organizacao — Resumo da "Organização"

criacao-aplicacao — Criação da "Aplicação"

Assim que a "Organização" e a "Aplicação" estiverem corretamente criadas e configuradas, acesse a seção "Dispositivos" da plataforma para iniciarmos a configuração. Ao acessar essa seção, clique sobre o botão "+ Dispositivo" da página, como na imagem abaixo.

secao-dispositivo — Seção "Dispositivos"

Ao pressionar o botão, é exibida uma janela de criação de um novo dispositivo, como na imagem a seguir.

criacao-novo-dispositivo — Criação de Novo Dispositivo

Neste momento temos de escolher a tecnologia que utilizaremos para conectar o nosso dispositivo à plataforma. Para este tutorial, selecione a opção "LoRaWAN". Após a seleção da tecnologia, temos que selecionar o "Modelo" de dispositivo, e, como o LoRaWAN Bee não está listado nas opções, temos que selecionar a opção "Dispositivo genérico", como na próxima imagem.

Agora que a tecnologia e o modelo de dispositivo estão devidamente configurados, temos que selecionar o tipo de conectividade que usaremos com este dispositivo. No caso deste tutorial, usaremos a opção "Rede ATC LoRaWAN", como na imagem a seguir.

selecao-conectivdade — Seleção de Conectividade

Com a conectividade selecionada, a plataforma irá apresentar uma janela de configuração dos dados do dispositivo, como na imagem abaixo. Com esta janela aberta, digite o nome de seu dispositivo no campo "Nome do Dispositivo". Além do nome do dispositivo, aproveite para selecionar a sua rede ATC adquirida no campo "Conectividade LoRaWAN", antes de conectarmos o LoRaWAN Bee ao computador. Se não houver nenhuma opção nesse campo de conectividade, significa que não há um plano ATC disponível e você deve adquirir um (veja nosso tutorial sobre esse passo a passo).

configuracao-dispositivo — Configuração do Dispositivo

Agora que estas coisas mais simples estão configuradas na plataforma, podemos atrelar e salvar as informações que serão usadas de fato pelo dispositivo. Primeiramente digite o "Device EUI" (que aprendemos como obter no tutorial anterior), no campo "Device EUI" na plataforma. Feito isso, vamos gerar aleatoriamente os códigos "Application EUI" e "Application Key", que possuem 16 e 32 caracteres hexadecimais (8 e 16 bytes), respectivamente. Para gerar estes valores aleatoriamente, basta clicar sobre a seta em formato circular nos respectivos campos, como na imagem a seguir.

geracao-aleatoria-application-eui — Geração Aleatória de "*Application EUI*"

Com esses valores gerados, garanta que o dispositivo da plataforma está configurado com o método de conexão "OTAA" no campo "Ativação de Segurança", como na imagem abaixo.

ativacao-seguranca-otaa — Ativação de Segurança como OTAA

Por fim, basta verificar se os campos "Criptografia de Segurança", "Classe de Dispositivo" e "Tamanho do Contador" estão selecionados como "NS", "A" e "4", respectivamente. Além disso, altere o campo "Formato de Payload", que está com a opção "Hexadecimal" pré-selecionada pela plataforma, para a opção "JSON". Quando tudo estiver certo, o seu dispositivo deve estar parecido com o da próxima imagem.

configuracao-final-dispositivo-plataforma — Configuração Final do Dispositivo na Plataforma

Com o dispositivo finalmente configurado, clique sobre o símbolo de confirmação verde na parte de baixo da página para que a criação do dispositivo seja finalizada. Após pressionar o botão, é exibido na lista de "Dispositivos" o dispositivo que acabamos de criar, como na imagem a seguir.

Configuração da Variável

Agora que o nosso dispositivo está criado e devidamente configurado, podemos criar uma variável para armazenar os valores que enviaremos posteriormente. Para isso, clique sobre o dispositivo criado e então pressione o botão "+ Variável" para entrar no campo de criação, como na imagem a seguir.

Com esta janela de configuração aberta, digite um nome para a sua variável, e então digite sua unidade como "%", já que vamos receber a porcentagem de luminosidade ambiente na plataforma. Além disso, certifique-se que os "Pontos Decimais" estão configurados como "0", e digite o nome "Luminosidade" no campo "Alias" (o código de exemplo deste tutorial possui este nome de Alias pré configurado, porém você você pode utilizar outro nome se preferir, lembrando de alterar a variável no código também). Após estas configurações, sua variável deve estar como a da imagem abaixo.

configuracao-variavel — Configuração da Variável

Com a variável devidamente configurada, pressione o botão de confirmação verde para que a variável seja criada. Após pressionar o botão, é possível observar a variável na lista do dispositivo.

Edição do Painel

Agora temos que acessar o nosso "Painel", para adicionarmos um "Widget" para exibir as mensagens que enviaremos para a plataforma. Com o painel aberto, selecione o botão "+ Widget" e selecione a opção "Métrico", como na imagem a seguir.

selecao-widget-metrico — Seleção do "Widget" Métrico

Ao pressionar esta opção, você é direcionado para uma página de edição do "Widget". Nesta janela, configure primeiramente a sua "Organização" e a sua "Aplicação", e então selecione a variável criada neste tutorial, dentro do dispositivo previamente configurado (ela deve aparecer embaixo do nome do dispositivo - "test-device" na imagem). Com estas primeiras configurações feitas, altere o "Nome do Widget", a cor de exibição da variável e adicione um ícone de exibição, se desejar. Por fim, a sua tela de configuração deve estar parecida com a da próxima imagem.

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

Com a configuração concluída, pressione o botão de confirmação verde, e observe o "Widget" ser adicionado ao seu painel, como na imagem abaixo.

widget-adicionado-painel — "Widget" Adicionado ao Painel

Vale lembrar que você pode editar o tamanho de exibição do "Widget", se desejar. Basta pressionar o botão direito do mouse sobre a seta no canto inferior direito do "Widget" e arrastá-lo para "dentro" ou para "fora" enquanto o botão está pressionado.

Software

Biblioteca

No tutorial anterior já instalamos a biblioteca "SMW_SX1276M0", porém para fazermos o envio de dados neste tutorial, iremos usar a biblioteca "ArduinoJson". Para instalá-la vamos acessar o "Gerenciador de Bibliotecas" da IDE, através do caminho da imagem abaixo.

Com o gerenciador aberto, digite na barra de pesquisa "arduinojson" e então pressione "Enter" no seu teclado, assim a lista exibirá como primeira opção a biblioteca que usaremos neste tutorial, como na próxima imagem.

biblioteca-arduinojson-encontrada — Biblioteca "ArduinoJson" Encontrada

Agora basta pressionar o botão "Instalar" e aguardar alguns instantes. Quando a biblioteca estiver instalada, será exibida a etiqueta "Instalada" ao lado do nome dela, como na imagem a seguir.

biblioteca-instalada — Biblioteca Instalada

Código

Agora que todas as bibliotecas necessárias já estão instaladas, copie e carregue o código a seguir para a sua placa. Antes de carregar, apenas lembre-se de alterar as variáveis que armazenam o "Application EUI" (APPEUI), o "Application Key" (APPKEY) e o Alias (ALIAS) com os valores configurados na plataforma.

/*******************************************************************************
* IoT DevKit - Envio 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.
* 
* Copyright 2020 RoboCore.
* Escrito por Giovanni de Castro (25/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 da funcao que verifica a conexao do modulo
void event_handler(Event);

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

  //Inicia o monitor serial e imprime o cabecalho
  Serial.begin(115200);
  Serial.println(F("Envio de Luminosidade para a 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);

  //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!"));
  }
  
}

Entendendo o Código

Primeiramente verificamos se o modelo de placa selecionado na Arduino está correto e retornamos uma mensagem de erro personalizada caso não esteja. Em seguida incluímos no código as bibliotecas que usaremos para nos comunicar com o módulo, conectar com a rede, enviar mensagens e converter os valores lidos pelo sensor de luminosidade.

//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>

Com as bibliotecas adicionadas, criamos o objeto LoRaSerial a partir da biblioteca "HardwareSerial" e definimos os pinos digitais do ESP32 que usaremos para nos comunicar com o LoRaWAN Bee. Com o objeto LoRaSerial criado, nós o utilizamos para criar o objeto lorawan a partir da biblioteca "SMW_SX1276M0", configurando assim que o programa utilizará a comunicação serial dos pinos RXD2 e TXD2 para enviar e receber informações do módulo.

//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);

Então nós declaramos as variáveis APPEUI e APPKEY, que armazenam justamente os códigos do "Application EUI" e do "Application Key", respectivamente, que foram gerados aleatoriamente pela plataforma. Logo em seguida, a variável ALIAS é declarada para armazenar o nome do Alias que você configurou na sua variável da plataforma. Antes destas variáveis, nós criamos o objeto resposta do tipo CommandResponse da biblioteca "SMW_SX1276M0", pois ele será responsável por armazenar as respostas dos comandos executados.

//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

Como não queremos que o código envie mensagens muito rapidamente, para não acabar com o número máximo de "Uplinks" antes do final do mês, nós declaramos a variável TEMPO_ESPERA que armazena o tempo que o módulo irá levar entre uma mensagem e outra, juntamente com a variável intervalo, que ajudará a realizar este intervalo entre envios. Por fim declaramos a variável PINO_LDR, que armazena o pino em que o sensor está conectado; a variável leitura_LDR, que armazena a leitura do sensor; e a função event_handler, que verifica se o módulo se conectou à rede.

//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 da funcao que verifica a conexao do modulo
void event_handler(Event);

Já na configuração do código, começamos iniciando o monitor serial com a velocidade de 115200 bps ("bits per second"), a mesma velocidade de comunicação usada para configurar a comunicação com LoRaWAN Bee através do comando LoRaSerial.begin(115200, SERIAL_8N1, RXD2, TXD2). Entretanto, antes da inicialização da comunicação na ESP32, nós configuramos o pino de reset do módulo (conectado ao pino 5 da ESP32) e efetuamos a reinicialização para iniciar corretamente a comunicação. Juntamente com estas inicializações, nós declaramos o pino conectado ao sensor como uma entrada do sistema e atribuímos a função event_handler ao objeto lorawan.

//Inicia o monitor serial e imprime o cabecalho
Serial.begin(115200);
Serial.println(F("Envio de Luminosidade para a 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);

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

Agora finalmente começamos a obter e a configurar informações no módulo, e a primeira delas é o "Device EUI", que é impresso no monitor serial se o módulo retornar uma mensagem "<OK>", como vimos no tutorial anterior. Com esta mesma condição, nós configuramos no módulo os códigos para o "Application EUI" e para o "Application Key", juntamente com a configuração do método de conexão para OTAA. Para finalizar a configuração do código, nós enviamos a requisição de conexão para a rede através da função lorawan.join().

//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();

Atenção: cada procedimento de conexão na rede (join) em modo OTAA consome uma mensagem de "Downlink" para notificar o dispositivo que o acesso foi bem-sucedido.

Finalmente na repetição do código, nós iniciamos cada repetição aguardando por informações do módulo através do comando lorawan.listen(). Na sequência, verificamos se o módulo está conectado na rede através da condição if(lorawan.isConnected()). Então, caso ele não tenha se conectado ainda, nós mantemos ele tentando, enquanto imprimimos pontos (".") no monitor serial a cada 5 segundos.

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

if(lorawan.isConnected()){ //Verifica se o modulo esta conectado

.
. 
.
        
} 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   
  }
}

Entretanto, quando o módulo consegue se conectar, passamos a executar o envio de mensagens com intervalos de 5 minutos. Para isso, atribuímos à variável leitura_LDR a leitura analógica do pino que está conectado ao sensor, e então mapeamos essa leitura de uma valor entre 0 e 4095 para um valor entre 0 e 100, para trabalharmos com porcentagem. Como queremos converter essas leituras para uma mensagem em JSON, temos que criar primeiramente o objeto json com o tamanho unitário (JSON_OBJECT_SIZE(1)) e a classe DynamicJsonDocument da biblioteca "ArduinoJson". Em seguida criamos um elemento com o nome ALIAS e com o valor igual à leitura mapeada do sensor.

Com essa configuração do objeto json, nós criamos a variável tamanho_mensagem, que é então atribuída à soma unitária do comprimento da mensagem JSON do objeto json. Essa adição é necessária para inserir o caractere de final de texto ('\0') na conversão a seguir. Depois criamos a string mensagem de acordo com o tamanho tamanho_mensagem, que será responsável por armazenar a mensagem JSON para o envio. Após esta criação, nós realizamos uma cópia do objeto json para a variável mensagem de acordo com o comprimento tamanho_mensagem, através da função serializeJson() da biblioteca "ArduinoJson". Por fim, nós finalmente enviamos uma mensagem em formato de texto para a porta "1" da rede através do comando resposta = lorawan.sendT(1, mensagem), e atualizamos a contagem de tempo do código para iniciar novamente o envio de mensagem após 5 minutos.

//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
      
}

Ao final do código temos a função event_handler, que foi declarada anteriormente. Nela apenas verificamos se o módulo se conectou à rede utilizando a condição if(type == Event::JOINED), para retornar essa informação no monitor serial, pois quando o módulo se conecta à rede, ele retorna a mensagem "EVENT [JOINED]".

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

O Que Deve Acontecer

Quando o código terminar de ser carregado para a placa com as variáveis mencionadas devidamente configuradas, abra o monitor serial em 115200 bps e observe os resultados. O módulo deve se conectar à rede após alguns instantes, e então enviar a primeira mensagem, como na imagem a seguir.

resultado-monitor-serial — Resultado no Monitor Serial

Após o envio da mensagem, acesse o seu painel na PROIoT para observar que a variável da plataforma foi atualizada com o mesmo valor da mensagem enviada, como na próxima imagem.

variavel-atualizada-plataforma — Variável atualizada na Plataforma

Conclusão

Neste tutorial demos um passo importante para o nosso aprendizado sobre a conectividade LoRaWAN e finalmente nos conectamos à rede para enviar nossa primeira mensagem pelo LoRaWAN Bee. Agora podemos avançar nos estudos e expandir as possibilidades deste protocolo tão recente e popular.

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 o seu módulo não estiver se conectando após alguns pontos, você pode reiniciar o conjunto e para tentar novamente. Mas antes, deixe ele tentar se conectar sozinho, portanto aguarde alguns minutos. Entretanto, lembre-se de verificar se a sua posição atual está dentro da área coberta pela rede ATC.

Caso mesmo reiniciando, o módulo não se conecta, verifique a inserção dos códigos para "Application EUI" e "Application Key", assim como a configuração do dispositivo na plataforma PROIoT, e tente novamente. Além disso, nas informações sobre o dispositivo, verifique se ele está conectado, com as opções de "Uplink" e "Downlink" selecionadas, caso contrário, selecione estas opções, como na imagem abaixo.

dispositivo-conectado — Dispositivo Conectado

Mensagem Enviada Não é Igual à Mensagem Recebida

Se o valor atualizado na plataforma não for igual ao valor exibido no monitor serial, verifique nas "Opções de Payload" da plataforma se a opção "JSON" está realmente selecionada, como na próxima imagem.

payload-configurado-json — "Payload" Configurado como "JSON"

Comments

To make comments you must be logged in. Login.

You are not registered yet? Register Now!

allanjuniorj
date

Sent 2024-03-22 10:44:05

Bom dia, 
Estou com dúvidas sobre a pinagem do módulo lora. Meu projeto precisa do (Pino Chip Select, Pino Reset e Pino DIO) e não está funcionando porque não declarei os pinos corretos. Olhei o esquema elétrico, mas não tenho muito conhecimento. Podem me ajudar com isso?

luan.ferreira
date

Sent 2024-03-22 12:34:52
allanjuniorj

Olá, tudo bem? No DevKit, o ESP32 precisa usar os pinos 16, 17 e 5 para se comunicar com o LoRaWAN Bee. Se um desses pinos for usado para outra coisa, a comunicação provavelmente não funcionará.

rafaelmbs
date

Sent 2023-04-25 14:48:19

Giovanii, tenho falado com alguns provedores (Algar, Kore e TCTEC) e o que mais me surpreendeu até o momento foi a TCTec pela facilidade em contratação.

Estou em contato com eles e caso aconteça um bom negócio, eu comento aqui. Abs e obrigado por responder.

Giovanni5

Sent 2023-04-25 16:51:50
rafaelmbs

rafaelmbs disponha. Também estamos buscando alternativas para planos LoRaWAN, e agradecemos pelas sugestões.

rafaelmbs
date

Sent 2023-04-22 23:44:40

A plataforma ProIoT continua indisponivel?

Giovanni5

Sent 2023-04-24 08:39:18
rafaelmbs

Sim, infelizmente a ProIoT não comercializa mais os planos ATC para comunicação LoRaWAN, e embora ela ainda esteja acessível para uso de ferramentas como o MQTT, a plataforma ainda deve estar em processo de descontinuação, portanto suas ferramentas devem não estar completamente funcionais.

sergioscarpin
date

Sent 2022-11-02 10:00:09

Bom dia. 
Agora que a ProIoT não tem mais os planos da ATC, e a ATC (agora Everynet) só comercializa para empresas, qual a recomendação da Robocore para usar este kit ?

luan.ferreira
date

Sent 2022-11-03 16:55:30
sergioscarpin

Infelizmente no momento ainda não temos nenhuma para recomendar. Entretanto, estamos procurando uma rede que possa ser usada com o Kit, e assim que encontrarmos atualizaremos os tutoriais.

kleber3
date

Sent 2021-10-01 21:26:25

Boa noite, comprei um kit de Robocore DevKit esta semana, mas, estou com dificuldade de configurar com o ProIot, a plataforma esta diferente na questão de configuração de dispositivos novos, e não estou conseguindo comunicação, existe alguma atualização do passo a passo de vc´s que contemple esta atualização da PlataForma ProIot.

Francois

Sent 2021-10-04 13:30:02
kleber3

Você conseguiu criar um dispositivo ATC LoRaWAN na ProIoT? Qual foi o problema encontrado na comunicação com a plataforma? Antes de validar as variáveis da aplicação, é interessante confirmar que o módulo conseguiu ingressar na rede (join bem-sucedido por OTAA, por exemplo) e se alguma mensagem chega na ProIoT (no menu "dados em tempo real").

Rei70

Sent 2021-07-07 16:29:48

Ola Giovanni !!! Enfim funcionou quase 100 % .... o problema final agora é que o Widget só atualiza o valor uma vez e fica parado. O software continua rodando e apresentando novos valores só que não atualiza mais ... !! Obrigado / Abraço

Giovanni5

Sent 2021-07-07 17:17:23
Rei70

Você pode acompanhar o recebimento da atualização de leituras do sensor pela seção "Dados em tempo real" do dispositivo, mas é relativamente comum que nem todas as mensagens enviadas sejam recebidas pela plataforma, pois isso depende diretamente da cobertura da rede no local de testes, e a conexão pode acabar sofrendo interferências de obstáculos externos também.

Rei70

Sent 2021-07-02 18:30:51

Boa noite Giovanni !!! Na criação do meu Custon Device percebi que o campo Application Key não aparece .. que fazer ? Abraço

Giovanni5

Sent 2021-07-05 08:12:20
Rei70

Verifique se o seu dispositivo está com a "Criptografia de Segurança" configurada como "NS", juntamente com o restante das configurações do dispositivo ("Ativação de Segurança", "Número de Contadores" e "Classe do Dispositivo"), para que a plataforma libere a criação do "Application Key".

Rei70

Sent 2021-06-23 15:13:53

Ola Giovanni .. Em dispositivos estou selecionando ATC LoRaWAN , Custom Device ... Tenho a opção de conectores ( Everynet, LORIOT, HTTP, MQTT ) ... qualquer uma que escolher ele volta ao inicio e se clicar no continuar .. aparece Device label e name obrigatorio, Device e aplication EUI tamanho invalido e LoRaWAN Connectivity obrigatorio ... o que fazer ??

Giovanni5

Sent 2021-06-23 16:01:00
Rei70

Parece que a plataforma teve uma pequena instabilidade, mas testamos a criação de dispositivos agora, e ela está funcionando corretamente. Tente novamente criar o dispositivo, e se esse problema persistir, entre em contato com os desenvolvedores da PROIoT para tentar solucioná-lo.

Rei70

Sent 2021-06-23 14:44:52

Vi que respondeu ... desculpe !!

Rei70

Sent 2021-06-23 14:44:02

Boa tarde Giovanni !! Conseguiu ver qual dispositivo devo usar LoRa Privado ou ATC LoRaWAN ? Não encontro dispositivo genérico em nenhum dos casos !! Grato