Primeiros Passos com o Shield LoRaWAN em OTAA

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

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

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.

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.

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.

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.

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.

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

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.

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

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.

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.

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.

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.
xxxxxxxxxx
//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).
xxxxxxxxxx
//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.
xxxxxxxxxx
//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()
.
xxxxxxxxxx
//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.
xxxxxxxxxx
//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.

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.