Primeiros Passos com o Shield LoRaWAN em OTAA

This tutorial is not available in English

Introdução

Com o Shield LoRaWAN da RoboCore, você pode conectar o seu projeto baseado em Arduino à internet, com um alcance que só o protocolo LoRaWAN é capaz de fornecer.

Neste tutorial você verá como enviar mensagens à rede LoRaWAN usando o novo Shield, para poder implementar esta funcionalidade em seus projetos.

Lista de Materiais

Shield para Arduino - LoRaWAN Helix Antenna

R$ 208,90 no PIX

Cabo USB AB 1.50m

R$ 10,35 no PIX

Atenção: na lista acima foi listado o Shield LoRaWAN Helix Antenna, porém este tutorial também é possível com o Shield LoRaWAN Chip Antenna.

Instalação da Biblioteca

A biblioteca do Shield LoRaWAN está disponível para ser instalada diretamente pelo "Gerenciador de Bibliotecas" da Arduino IDE. Para acessá-lo siga o caminho da imagem abaixo, ou então pressione "Ctrl+Shift+I".

caminho-gerenciador-bibliotecas — Caminho para o "Gerenciador de Bibliotecas"

Com o gerenciador aberto, digite "robocore smw sx1262", conforme mostrado na imagem abaixo.

biblioteca-encontrada — Biblioteca Encontrada

Com a biblioteca listada como na imagem acima, pressione o botão "Instalar" e aguarde alguns instantes. Assim que a instalação estiver finalizada, será exibido "Instalada" ao lado do nome da biblioteca, como na imagem a seguir.

biblioteca-instalada — Biblioteca Instalada

Aproveite que o "Gerenciador de Bibliotecas" está aberto e pesquise por "arduinojson" para instalar a biblioteca "ArduinoJSON", conforme mostrado na imagem abaixo. Esta biblioteca será utilizada posteriormente para auxiliar no envio de mensagens pela rede LoRaWAN.

biblioteca-arduinojson-instalada — Biblioteca "ArduinoJSON" Instalada

Teste da Comunicação Serial

Com a biblioteca instalada, abra o exemplo "Bridge", conforme mostrado na próxima imagem, e então carregue-o para a placa base conectada ao Shield LoRaWAN.

caminho-exemplo-bridge — Caminho para o Exemplo "Bridge"

Com o código carregado, abra o monitor serial da porta serial corresponde à placa base no seu computador e configure-o para a velocidade de 9600 bps, assim como com a função "retorno de carro". Com o monitor aberto e configurado, envie o comando "AT" e veja se o Shield retorna "OK" como na imagem abaixo.

envio-comando-at — Envio do Comando "AT"

Com o comando corretamente respondido, envie o comando "AT+DEUI=?" para coletar o Device EUI do seu Shield, para a configuração posterior da ProIoT. Esse comando irá retornar um código de 16 caracteres hexadecimais separados por dois pontos, como na imagem a seguir. Este código é a identificação do seu dispositivo, portanto anote-o e guarde-o, pois ele é importante.

envio-comando-atdeui — Envio do Comando "AT+DEUI=?"

Com isso conseguimos confirmar o funcionamento e coletar a informação necessária para a conexão do Shield com a rede LoRaWAN, e já estamos prontos para prosseguir com o envio de mensagens pela rede. Entretanto, o Shield possui diversos comandos AT que podem ser enviados para configurá-lo, e é possível ver todos os comandos disponíveis neste documento.

Envio de Mensagens pela Rede LoRaWAN

Agora que coletamos o Device EUI necessário para a conexão do Shield à rede LoRaWAN, já podemos prosseguir com a configuração da ProIoT para enviar mensagens à ela. Vale lembrar que é necessário adquirir uma plano ATC para poder conectar o Shield à ela. Portanto, se ainda não possui uma, aproveite para adquirir seguindo os passos deste tutorial. Além disso, certifique-se que está em uma área de boa cobertura da rede ATC pelo mapa abaixo (zonas avermelhadas).

Mapa de Cobertura da Rede ATC LoRaWAN
Fonte: IoT OpenLabs

Configurações da Plataforma

Além de adquirir o plano da ATC, para criar um dispositivo na ProIoT, também será necessário criar uma aplicação em uma organização. Então, se ainda não tiver uma, acesse a seção "Organizações" da plataforma e crie uma.

Já para criar um dispositivo, acesse a seção "Dispositivos" e pressione o botão "+ Dispositivo" para criar um novo. Após pressionar este botão, será exibida uma janela para as configurações do novo dispositivo que será criado. Neste momento, selecione a opção "ATC LoRaWAN" na aba de "Conectores", como demarcado na imagem abaixo.

Logo em seguida, serão listadas algumas opções de "Modelo" de dispositivos. Para o Shield LoRaWAN, selecione a opção "Custom Device", como demarcado na imagem a seguir.

selecao-modelo-dispositivo — Seleção do Modelo de Dispositivo

Feito isso, serão habilitados os campos de edição na aba "Selecione o protocolo e modelo". Então selecione uma de suas "Aplicações", dê um nome para o seu dispositivo e insira o Device EUI coletado anteriormente, como feito na próxima imagem, por exemplo.

configuracoes-dispositivo — Configurações do Dispositivo

Feito isso, role um pouco a aba de configurações para baixo e, para finalizar, gere um Application EUI aleatório (clicando sobre o botão de uma seta em formato de círculo), selecione o seu plano ATC no campo "Conectividade LoRaWAN", e certifique-se que a "Ativação de Segurança", a "Criptografia de Segurança", a "Classe do Dispositivo" e o "Tamanho do Contador" estão selecionados como "OTAA", "NS", "A" e "2", como na imagem abaixo. Após selecionar a "Criptografia de Segurança" como "NS", será criado um novo campo para criação de um Application Key, então basta criá-lo aleatoriamente como feito para o Application EUI.

configuracoes-finais-dispositivo — Configurações Finais do Dispositivo

Com as configurações finalizadas, pressione o botão de confirmação verde para criar o dispositivo. Ele então será listado na seção de "Dispositivos" da plataforma.

Em seguida, temos que criar uma variável para receber as informações que serão enviadas do Shield. Para isso, clique sobre o dispositivo recém criado e acesse a seção lateral "Variáveis". Assim que a seção estiver aberta, clique sobre o botão "+ Variável" e então dê um nome para ela, com o "ALIAS" "Data". O restante dos campos pode ficar em branco ou com a configuração padrão. De modo geral, a configuração da sua variável deve ser semelhante à da imagem abaixo.

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

Após a criação da variável, acesse a seção "Dashboard" da plataforma para que possamos editar um "Widget" para receber as informações que serão enviadas do Shield. Após acessar a seção "Dashboard", clique sobre o botão "+ Widget" e então selecione a opção "Métrico". Isso abrirá a janela de edição novo "Widget".

Com a janela de edição do "Widget" aberta, selecione a variável criada anteriormente na lista do dispositivo criado, como na próxima imagem.

selecao-variavel-widget — Seleção da Variável para o "Widget"

Feito isso, dê um nome para o "Widget" e configure-o como preferir, com o tamanho da fonte, ícone de exibição, cor de exibição e opção de exibir a última atualização do "Widget", como na imagem abaixo, por exemplo.

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

Para finalizar, pressione o botão de confirmação verde para que ele seja criado no "Dashboard" da plataforma. Vale lembrar que você pode alterar o tamanho do "Widget" no "Dashboard", se quiser.

Código

Com as configurações da plataforma finalizadas, já podemos gravar o código abaixo para enviar mensagens pela rede LoRaWAN. Lembre-se de, antes de carregar o código para a placa base, alterar o valor das variáveis APPEUI e APPKEY com os códigos gerados aleatoriamente pela plataforma. Ambos podem ser copiados da seção "Informações do Dispositivo", como na nesta imagem.

/*******************************************************************************
* Shield LoRaWAN - Envio de Mensagens LoRaWAN por OTAA (v1.0)
* 
* Codigo para enviar um contador incremental a plataforma ProIoT cada vez que o
* botao do Shield for pressionado. O LED L do Shield e da placa base irao piscar
* a cada envio/retorno de mensagem do Shield. Se algum problema for encontrado
* na configuracao do Shield, o LED L ficara permanentemente aceso.
* 
* Copyright 2022 RoboCore.
* Escrito por Giovanni de Castro (02/06/2022).
* 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/>).
*******************************************************************************/

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

//Adicao das biblitoecas
#include <RoboCore_SMW_SX1262M0.h>
#include <SoftwareSerial.h>
#include <ArduinoJson.h>

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

//Criacao do objeto para biblitoeca "SoftwareSerial"
SoftwareSerial LoRaSerial(10, 11); //RX, TX
//Criacao do objeto para a biblioteca "SMW_SX1262M0" utilizando o objeto da biblioteca "SoftwareSerial"
SMW_SX1262M0 LoRaWAN(LoRaSerial);

//Declaracao da variavel que armazena as respostas do Shield
CommandResponse response;

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

//Declaracao da variavel que armazena o estado de conexao do Shield
bool conectado = false;
//Declaracao do contador incrementavel que sera usado para o envio de mensagens
int contador = 0;

//Declaracao da variavel que armazena o ALIAS da variavel criada na ProIoT
const char ALIAS[] = "Data";

//Declaracao da variavel que armazena o pino conectado ao botao do Shield
const int PINO_BOTAO = A0;

//Declaracao da variavel que armazena o pino conectadi ao LED L do Shield
const int PINO_LED = 13;

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

//Configuracao do codigo
void setup() {
  
  //Inicializacao do monitor serial para acompanhar a execucao do codigo
  Serial.begin(9600);
  Serial.println(F("--- Primeiros Passos com o Shield LoRaWAN ---"));
  Serial.println(F("--- Envio de Mensagens por OTAA ---"));

  //Configuracao dos pinos usados da placa base
  pinMode(PINO_BOTAO, INPUT_PULLUP); //Botao do Shield
  pinMode(PINO_LED, OUTPUT); //LED L do Shield e da placa base
  digitalWrite(PINO_LED, LOW); //LED L iniciado apagado

  //Inicializacao da comunicacao com o Shield
  LoRaSerial.begin(9600);

  //Reinicializacao do Shield
  LoRaWAN.reset();

  //Configura o Shield para operar no metodo de conexao OTAA
  response = LoRaWAN.set_JoinMode(SMW_SX1262M0_JOIN_MODE_OTAA);
  if (response == CommandResponse::OK) {
    Serial.println(F("Metodo de conexao configurado como OTAA"));
    //Pisca o LED L
    digitalWrite(PINO_LED, HIGH);
    delay(100);
    digitalWrite(PINO_LED, LOW);
  } else {
    Serial.println(F("Erro ao configurar modo de conexao"));
    //Mantem LED L aceso
    digitalWrite(PINO_LED, HIGH);
  }

  //Coleta o DevEUI do Shield
  char deveui[16];
  response = LoRaWAN.get_DevEUI(deveui);
  if (response == CommandResponse::OK) {
    Serial.print(F("DevEUI: "));
    Serial.write(deveui, 16);
    Serial.println();
    //Pisca o LED L
    digitalWrite(PINO_LED, HIGH);
    delay(100);
    digitalWrite(PINO_LED, LOW);
  } else {
    Serial.println(F("Erro ao coletar o DevEUI"));
    //Mantem LED L aceso
    digitalWrite(PINO_LED, HIGH);
  }

  //Configura o AppEUI do dispositivo criado na ProIoT
  response = LoRaWAN.set_AppEUI(APPEUI);
  if (response == CommandResponse::OK) {
    Serial.print(F("Application EUI configurado ("));
    Serial.write(APPEUI, 16);
    Serial.println(')');
    //Pisca o LED L
    digitalWrite(PINO_LED, HIGH);
    delay(100);
    digitalWrite(PINO_LED, LOW);
  } else {
    Serial.println(F("Erro ao configurar o AppEUI"));
    //Mantem LED L aceso
    digitalWrite(PINO_LED, HIGH);
  }

  // Configura o AppKEY do dispositivo criado na ProIoT
  response = LoRaWAN.set_AppKey(APPKEY);
  if (response == CommandResponse::OK) {
    Serial.print(F("Application Key configurado ("));
    Serial.write(APPKEY, 32);
    Serial.println(')');
    //Pisca o LED L
    digitalWrite(PINO_LED, HIGH);
    delay(100);
    digitalWrite(PINO_LED, LOW);
  } else {
    Serial.println(F("Erro ao configurar AppKEY"));
    //Mantem LED L aceso
    digitalWrite(PINO_LED, HIGH);
  }

  //Salva as informacoes configuradas na memoria do Shield
  //Este trecho e opcional
  response = LoRaWAN.save();
  if (response == CommandResponse::OK) {
    Serial.println(F("Configuracoes salvas"));
    //Pisca o LED L
    digitalWrite(PINO_LED, HIGH);
    delay(100);
    digitalWrite(PINO_LED, LOW);
  } else {
    Serial.println(F("Erro ao salvar configuracoes"));
    //Mantem LED L aceso
    digitalWrite(PINO_LED, HIGH);
  }

  //Envia uma requisicao de conexao a rede ATC
  Serial.println(F("Conectando a rede..."));
  //Pisca o LED L
  digitalWrite(PINO_LED, HIGH);
  delay(100);
  digitalWrite(PINO_LED, LOW);
  LoRaWAN.join();
  
}

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

//Repeticao do Codigo
void loop() {

  //Verifica se o modulo esta conectado na rede
  if (LoRaWAN.isConnected()) {
    //Atualiza a variavel que armazena o estado de conexao do Shield
    if (!conectado) {
      Serial.println(F("Conectado!"));
      conectado = true; // set
    }

    //Verifica se o botao do Shield foi pressionado
    if (digitalRead(PINO_BOTAO) == LOW) {
      delay(30); //Debounce
      if (digitalRead(PINO_BOTAO) == LOW) {

        //Pisca o LED L
        digitalWrite(PINO_LED, HIGH);
        delay(100);
        digitalWrite(PINO_LED, LOW);

        //Incrementa em uma unidade o contador
        contador++;
        if (contador > 255) {
          contador = 0; // reset
        }

        //Cria o objeto dinamico "json" com tamanho "1" para a biblioteca
        DynamicJsonDocument json(JSON_OBJECT_SIZE(1));

        //Atrela ao objeto "json" ao contador com o valor ja atualizado com o nome do ALIAS definido
        json[ALIAS] = contador;

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

        //Envia a mensagem
        Serial.print(F("Mensagem: "));
        Serial.println(mensagem);
        response = LoRaWAN.sendT(1, mensagem);

      }
    }

  //Se ainda nao estiver conectado
  } else if (!conectado) {
    //Demonstra tentativa de conexao
    Serial.println('.');
    //Pisca o LED L
    digitalWrite(PINO_LED, HIGH);
    delay(100);
    digitalWrite(PINO_LED, LOW);
    //A cada 5 segundos
    delay(5000);
  }

}

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

Entendendo o Código

O código se inicia com a inclusão das bibliotecas "RoboCore_SMW_SX1262M0", "SoftwareSerial" e "ArduinoJson" ao código. Em seguida, é criado o objeto LoRaSerial a partir da biblioteca "SoftwareSerial" e para a comunicação com o Shield. Este objeto é então utilizado para criar o objeto LoRaWAN a partir da biblioteca "SMW_SX1262M0". Após a criação destes objetos, são declaradas as constantes APPEUI e APPKEY, que armazenam os parâmetros Application EUI e Application Key gerados anteriormente na ProIoT.

//Adicao das biblitoecas
#include <RoboCore_SMW_SX1262M0.h>
#include <SoftwareSerial.h>
#include <ArduinoJson.h>

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

//Criacao do objeto para biblitoeca "SoftwareSerial"
SoftwareSerial LoRaSerial(10, 11); //RX, TX
//Criacao do objeto para a biblioteca "SMW_SX1262M0" utilizando o objeto da biblioteca "SoftwareSerial"
SMW_SX1262M0 LoRaWAN(LoRaSerial);

//Declaracao da variavel que armazena as respostas do Shield
CommandResponse response;

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

Para finalizar as declarações globais do código, temos a declaração da variável booleana conectado, responsável por armazenar o estado de conexão do Shield; a declaração da variável contador, que será incrementada em uma unidade a cada vez que o botão for pressionado, para o envio de uma mensagem diferente; a variável ALIAS, que, como o próprio nome diz, armazena o alias da variável criada na plataforma; e, finalmente, a variável PINO_BOTAO, que armazena o pino conectado ao botão do Shield (pino A0).

//Declaracao da variavel que armazena o estado de conexao do Shield
bool conectado = false;
//Declaracao do contador incrementavel que sera usado para o envio de mensagens
int contador = 0;

//Declaracao da variavel que armazena o ALIAS da variavel criada na ProIoT
const char ALIAS[] = "Data";

//Declaracao da variavel que armazena o pino conectado ao botao do Shield
const int PINO_BOTAO = A0;

//Declaracao da variavel que armazena o pino conectadi ao LED L do Shield
const int PINO_LED = 13;

Já nas configurações do código, o monitor serial é iniciado na velocidade de 9600 bps e os pinos conectados ao botão do Shield e ao LED L são configurados como entrada com pull-up interno ("INPUT_PULLUP") e como saída com nível lógico inicial baixo ("LOW"), respectivamente.

//Inicializacao do monitor serial para acompanhar a execucao do codigo
Serial.begin(9600);
Serial.println(F("--- Primeiros Passos com o Shield LoRaWAN ---"));
Serial.println(F("--- Envio de Mensagens por OTAA ---"));

//Configuracao dos pinos usados da placa base
pinMode(PINO_BOTAO, INPUT_PULLUP); //Botao do Shield
pinMode(PINO_LED, OUTPUT); //LED L do Shield e da placa base
digitalWrite(PINO_LED, LOW); //LED L iniciado apagado

Em seguida, a comunicação do Shield é iniciada com a velocidade de 9600 pelo comando LoRaSerial.begin(9600) e o Shield é reiniciado pelo comando LoRaWAN.reset(). Feito isso, o método de conexão é alterado para OTAA, é coletado o Device EUI do Shield para exibição no monitor serial e são configurados os parâmetros Application EUI e Application Key da rede LoRaWAN no Shield. Para finalizar as configurações do código, as configurações são salvas na memória do Shield, e o Shield inicia a requisição de conexão à rede ("join") pelo comando LoRaWAN.join().

//Inicializacao da comunicacao com o Shield
LoRaSerial.begin(9600);

//Reinicializacao do Shield
LoRaWAN.reset();

//Configura o Shield para operar no metodo de conexao OTAA
response = LoRaWAN.set_JoinMode(SMW_SX1262M0_JOIN_MODE_OTAA);
if (response == CommandResponse::OK) {
  Serial.println(F("Metodo de conexao configurado como OTAA"));
  //Pisca o LED L
  digitalWrite(PINO_LED, HIGH);
  delay(100);
  digitalWrite(PINO_LED, LOW);
} else {
  Serial.println(F("Erro ao configurar modo de conexao"));
  //Mantem LED L aceso
  digitalWrite(PINO_LED, HIGH);
}

//Coleta o DevEUI do Shield
char deveui[16];
response = LoRaWAN.get_DevEUI(deveui);
if (response == CommandResponse::OK) {
  Serial.print(F("DevEUI: "));
  Serial.write(deveui, 16);
  Serial.println();
  //Pisca o LED L
  digitalWrite(PINO_LED, HIGH);
  delay(100);
  digitalWrite(PINO_LED, LOW);
} else {
  Serial.println(F("Erro ao coletar o DevEUI"));
  //Mantem LED L aceso
  digitalWrite(PINO_LED, HIGH);
}

//Configura o AppEUI do dispositivo criado na ProIoT
response = LoRaWAN.set_AppEUI(APPEUI);
if (response == CommandResponse::OK) {
  Serial.print(F("Application EUI configurado ("));
  Serial.write(APPEUI, 16);
  Serial.println(')');
  //Pisca o LED L
  digitalWrite(PINO_LED, HIGH);
  delay(100);
  digitalWrite(PINO_LED, LOW);
} else {
  Serial.println(F("Erro ao configurar o AppEUI"));
  //Mantem LED L aceso
  digitalWrite(PINO_LED, HIGH);
}

// Configura o AppKEY do dispositivo criado na ProIoT
response = LoRaWAN.set_AppKey(APPKEY);
if (response == CommandResponse::OK) {
  Serial.print(F("Application Key configurado ("));
  Serial.write(APPKEY, 32);
  Serial.println(')');
  //Pisca o LED L
  digitalWrite(PINO_LED, HIGH);
  delay(100);
  digitalWrite(PINO_LED, LOW);
} else {
  Serial.println(F("Erro ao configurar AppKEY"));
  //Mantem LED L aceso
  digitalWrite(PINO_LED, HIGH);
}

//Salva as informacoes configuradas na memoria do Shield
//Este trecho e opcional
response = LoRaWAN.save();
if (response == CommandResponse::OK) {
  Serial.println(F("Configuracoes salvas"));
  //Pisca o LED L
  digitalWrite(PINO_LED, HIGH);
  delay(100);
  digitalWrite(PINO_LED, LOW);
} else {
  Serial.println(F("Erro ao salvar configuracoes"));
  //Mantem LED L aceso
  digitalWrite(PINO_LED, HIGH);
}

//Envia uma requisicao de conexao a rede ATC
Serial.println(F("Conectando a rede..."));
//Pisca o LED L
digitalWrite(PINO_LED, HIGH);
delay(100);
digitalWrite(PINO_LED, LOW);
LoRaWAN.join();

Já na repetição do código, verificamos através da condição if (LoRaWAN.isConnected()) se a requisição de conexão do Shield foi aceita pela rede, ou seja, se ele está conectado. Se esta condição for verdadeira, a variável conectado é atualizada para verdadeiro ("true"), e em seguida é verificado se o botão do Shield foi pressionado com debounce. Caso o botão tenha sido pressionado, a variável contador é incrementada em uma unidade, e caso ela supere o valor de 255 durante a execução do código (condição if (contador > 255)), o seu valor é zerado novamente.

Com o valor da variável atualizado, é então criado o objeto json como instância DynamicJsonDocument da biblioteca "ArduinoJson", com o tamanho unitário, já que estamos enviando apenas um dado pela mensagem. Em seguida é atrelado ao objeto json o contador com o nome definido na variável ALIAS. A variável tamanho_mensagem é então criada com o valor do tamanho do objeto JSON que foi criado, somando-se uma unidade para considerar o caractere de fim de texto. Em seguida, a variável mensagem é declarada com o tamanho contido na variável tamanho_mensagem. Por fim, o comando serializeJson(json, mensagem, tamanho_mensagem) salva a mensagem JSON criada na variável mensagem, levando em conta o tamanho de mensagem salvo, e então a mensagem é enviada pelo Shield através do comando LoRaWAN.sendT(1, mensagem).

Caso o Shield ainda não esteja conectado (condição else if (!conectado)), o código apenas mostra atividade imprimindo pontos no monitor serial e aguarda 5 segundos para repetição do código.

//Verifica se o modulo esta conectado na rede
if (LoRaWAN.isConnected()) {
  //Atualiza a variavel que armazena o estado de conexao do Shield
  if (!conectado) {
    Serial.println(F("Conectado!"));
    conectado = true; // set
  }

  //Verifica se o botao do Shield foi pressionado
  if (digitalRead(PINO_BOTAO) == LOW) {
    delay(30); //Debounce
    if (digitalRead(PINO_BOTAO) == LOW) {

  	  //Pisca o LED L
      digitalWrite(PINO_LED, HIGH);
      delay(100);
      digitalWrite(PINO_LED, LOW);

      //Incrementa em uma unidade o contador
      contador++;
      if (contador > 255) {
        contador = 0; // reset
      }

      //Cria o objeto dinamico "json" com tamanho "1" para a biblioteca
      DynamicJsonDocument json(JSON_OBJECT_SIZE(1));

      //Atrela ao objeto "json" ao contador com o valor ja atualizado com o nome do ALIAS definido
      json[ALIAS] = contador;

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

      //Envia a mensagem
      Serial.print(F("Mensagem: "));
      Serial.println(mensagem);
      response = LoRaWAN.sendT(1, mensagem);

    }
  }

//Se ainda nao estiver conectado
} else if (!conectado) {
  //Demonstra tentativa de conexao
  Serial.println('.');
  //Pisca o LED L
  digitalWrite(PINO_LED, HIGH);
  delay(100);
  digitalWrite(PINO_LED, LOW);
  //A cada 5 segundos
  delay(5000);
}

O Que Deve Acontecer

Após carregar o código para a placa, abra o monitor serial para monitorar a execução do código. Inicialmente será exibido o Device EUI do Shield, e que as configurações dos parâmetros de conexão do Shield foram alterados e salvos na memória do Shield. Em seguida, será iniciada a tentativa de conexão do Shield à rede e, assim que ele estiver conectado, também será exibido "Conectado!" no monitor serial.

Para enviar uma mensagem pela rede, pressione o botão no Shield. Será exibida a mensagem em formato JSON enviada para a plataforma, como na imagem abaixo.

resultado-monitor-serial — Resultado no Monitor Serial

Juntamente com a exibição da mensagem, será possível observar que após alguns instantes o "Widget" criado no "Dashboard" também será atualizado com o valor enviado pelo Shield, como na imagem a seguir.

Indo Além

Neste tutorial utilizamos o método de conexão OTAA, que é o mais recomendado para dispositivos LoRaWAN, para enviar mensagens para a ProIoT, porém este método consome um "Downlink" do plano para cada tentativa de conexão, o que pode ser um ponto negativo em algumas aplicações. Entretanto, é possível utilizar o método de conexão ABP, que não depende de um "Join" e, portanto, não consome um "Downlink" a cada conexão.

Para entender melhor como usar este outro tipo, você pode alterar o método de conexão do dispositivo criado para ABP, gerar os parâmetros de conexão aleatoriamente e inseri-los no exemplo "SimpleSend_ABP" da biblioteca do Shield.

Além disso, o Shield LoRaWAN também possui a possibilidade de comunicação ponto a ponto (chamada popularmente de "P2P") entre dois ou mais Shields, como abordamos no tutorial Primeiros Passos com o Shield LoRaWAN com P2P.

Conclusão

Neste tutorial vimos como utilizar o método de conexão OTAA com o Shield LoRaWAN e como configurar a ProIoT para receber mensagens.