INTRODUÇÃO
Na parte 1 deste tutorial, aprendemos como integrar o Devkit ESP32-C3 LoRaWAN da JVTech à plataforma IOTA utilizando o modo de ativação OTAA (Over The Air Activation). Nesta segunda parte, vamos explorar a ativação via ABP (Activation By Personalization), uma alternativa ao OTAA.
ATIVAÇÃO VIA ABP
Com a ativação via ABP, não há a necessidade de trocar mensagens com o servidor antes de enviar dados. Neste método de ativação, a sua sessão é configurada através dos parâmetros "Device Address", "Application Session Key" e "Network Session Key", que são configurados diretamente no dispositivo. Nesta configuração, não existe a etapa de "Join Server" no processo de conexão com rede, tornando o processo mais simples e rápido, porém, menos seguro.
Ativação disponível através do connector "Custom ATC"
Após receber o e-mail de confirmação do pagamento, o plano já estará disponível para ativação. A ativação é feita através do conector "Custom ATC" disponível na página de criação de devices, conforme o print abaixo. Pórem, antes da ativação, ainda precisamos levantar algumas informações do dispositivo. O passo a passo para descobrir essas informações é apresentado em seguida.
PÂRAMETROS DE ATIVAÇÃO DO DISPOSITIVO
Antes de realizarmos a ativação dos dispositivo na rede LoRaWAN da ATC, precisamos recuperar os parâmetros de ativação ABP (Activation By Personalization) do módulo LoRa SMW SX1262M0 embarcado no DevKit.
Passo 1 - Descobrindo os parâmetros do módulo LoRaWAN para ativação ABP
Para descobrir e/ou alterar os parâmetros de ativação via ABP do módulo SMW_SX1262M0, nós iremos utilizar um código para enviar comandos AT diretamente a ele. Copie o código abaixo e grave-o no DevKit.
#include <SoftwareSerial.h>
SoftwareSerial mySerial(7, 6); // RX, TX
void setup()
{
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Native USB only
}
Serial.println("Goodnight moon!");
// set the data rate for the SoftwareSerial port
mySerial.begin(9600);
mySerial.println("AT");
}
void loop() // run over and over
{
if (mySerial.available())
Serial.write(mySerial.read());
if (Serial.available())
mySerial.write(Serial.read());
}
Assim que completar a gravação do código, será printado a mensagem de teste "Goodnight moon!" . Em seguida, você já habilitado a enviar comandos "AT" para o módulo. Faça um primeiro teste, envie o comando "AT", caso o módulo responda "OK", isso indicará que a comunicação está funcionado normalmente.
Lembre-se de configurar o "Serial Monitor" do Arduino IDE para comunicação em 9600baund.
Enfim, para descobrir os parâmetros de ativação ABP do módulo LoRaWAN SMW_SX1262M0, precisamos alterar o módulo para o modo ABP. Envie o comando "AT+NJM=0". Esse comando altera o módulo para o modo ABP "ABP Mode enabled" e em seguida apresenta os seus respectivos parâmetros de ativação, "DevEui", "DevAdd", "NwkSKey" e "AppSKey". Guarde esses parâmetros, pois eles serão utilizados na plataforma IOTA para ativação do módulo na rede ATC LoRaWAN .
Não se esqueça de enviar o comando "AT+SAVE" para salvar as configurações do módulo. Em seguida envie o comando "ATZ" para reiniciar o módulo e perceba que ele estará no modo ABP "ABP Mode enabled"
Passo 2 - Alterar os parâmetros de ativação ABP
Você também pode customizar os parâmetros de ativação "APPEUI (JoinEui)", "NWKSKEY" e "APPSKEY" do seu módulo. Para isso, basta enviar os seguintes comandos "AT" ao módulo com os parâmetros desejados:
AT+APPEUI=ba:69:07:a4:bc:4d:de:cf
AT+NWKSKEY=d0:88:7c:cb:20:f9:00:87:2f:ae:c0:af:4f:83:e5:00
AT+APPSKEY=d0:88:7c:cb:20:f9:00:87:2f:ae:c0:af:4f:83:e5:00
AT+SAVE
ATZObservações:
Vale ressaltar, que o "DevEui" é um parâmetro único para cada módulo LoRaWAN fabricado. Por esse motivo, esse parâmetro não pode ser customizado.
Você pode gerar qualquer valor aleatório para os novos parâmetros, desde que seja um valor Hexadecimal válido e o tamanho da sequência seja de "16" para o "APPEUI" e "32" para o "NWKSKEY" e "APPSKEY".
Passo 3 - Retornar o módulo para configurações de fábrica
Caso deseje retornar os parâmetros do módulo para o padrão de fábrica, basta enviar o comando "AT+DEFLT", conforme apresentado abaixo:
Caso queira realizar outras configurações no módulo, consulte a documentação completa no link: https://d229kd5ey79jzj.cloudfront.net/1443/SMART_LoRa_AT_Command_v1.0_en_v2.14.pdf
ATIVAR E CONECTAR O DEVKIT A REDE ATC LORAWAN
Passo 1 - Ativando o DevKit na rede ATC LoRaWAN
Com os parâmetros de ativação ABP do módulo SMW_SX1262M0 em mãos, chegou a hora de ativá-lo na rede ATC LoRaWAN. Volte até a página de ativação de dispositivos na plataforma IOTA e selecione o connector "Custom ATC".
Será aberto um formulário para preenchimento dos dados do dispositivo. Preencha os parâmetros "Device EUI", "Application EUI", "Device Address", "Network Session Key", "Application Session Key" com as informações coletadas nas seções anterior, escolha também um "Name" e um Description" para o dispositivo.
Defina o Application EUI baseado no mesmo valor da parte 1 do tutorial ou defina um sequência aleatória de 16 bytes hexadecimais.
Em "LoRaWAN ATC Plan", escolha um dos planos contratados na parte 1 desse tutorial. Selecione também os demais parâmetros de ativação da rede LoRaWAN e clique em "Create" para realizar a ativação do dispositivo.
A ativação pode demorar de 20s a 40s. Aguarde na página até que o ícone de carregamente desapareça e seja apresentada uma mensagem de sucesso/erro. Caso tenha problema com a ativação, não hesite em entrar em contato com o nosso suporte por meio do botão que se encontra no canto esquerdo inferior.
Se você sair da página antes do término do loading, poderá ocosionar erro na ativação e a conectividade não funcionará adequadamente.
Passo 2 - Conectando e enviando dados para rede ATC LoRaWAN
Após a ativação, o dispositivo já estará habilitado a se comunicar com a nuvem/IOTA por meio da conectividade LoRaWAN da ATC. O próximo passo será a gravação do código responsável por enviar os dados úteis "Payload" a plataforma IOTA, onde poderão ser explorados em formato de gráfico.
O código utilizado nesse tutorial foi baseado na documentação oficial do Devkit que se encontrada no blog do Douglas Zuqueto: https://devkit-lorawan.douglaszuqueto.com/
Formato do Payload
Antes de realizarmos a gravação do código no Devkit, um ponto importate a ser observado, é que existem dois métodos disponíveis na biblioteca <RoboCore_SMW_SX1262M0.h> para o uplink de dados. O "sendT", usado para o envio de valores "string", e o "sendX", para envio de valores "hexadecimais".
Enviando um valor String
Primeiramente, iremos utilizar "sendT" para envio de uplinks no formato "string". Você irá observar no código completo, apresentado na sequência, o seguinte trecho de código para envio da string "Hello World".
// Envia para a rede LoRaWAN uma payload no formato String na Porta 2
lorawan.sendT(2, "Hello World");Grave o código completo em seu DevKit para testar a conexão e envio de dados a rede LoRaWAN ATC.
#include <SoftwareSerial.h>
#include <RoboCore_SMW_SX1262M0.h>
#define LORA_RX 7
#define LORA_TX 6
#define RGB_BUILTIN 8
#define RGB_BRIGHTNESS 255
SoftwareSerial LoRaSerial(LORA_RX, LORA_TX);
SMW_SX1262M0 lorawan(LoRaSerial);
CommandResponse response;
bool joined = false;
void setup() {
Serial.begin(9600);
LoRaSerial.begin(9600);
Serial.println(F("--- DevKit ESP32-C3 LoRa Simple Join ---"));
// Efetua o reset(reboot) do módulo LoRaWAN
response = lorawan.reset();
if (response == CommandResponse::OK) {
} else {
Serial.println(F("Error on reset the module"));
}
delay(1000);
// Efetua a leitura do Device EUI do módulo
char deveui[16];
response = lorawan.get_DevEUI(deveui);
if (response == CommandResponse::OK) {
Serial.print(F("DevEUI: "));
Serial.write(deveui, 16);
Serial.println();
} else {
Serial.println(F("Error getting the Device EUI"));
}
// Efetua a leitura do Device Addr do módulo
char devaddr[8];
response = lorawan.get_DevAddr(devaddr);
if (response == CommandResponse::OK) {
Serial.print(F("DevAddr: "));
Serial.write(devaddr, 8);
Serial.println();
} else {
Serial.println(F("Error getting the Device Addr"));
}
// Efetua a leitura da AppSKey do módulo
char appSKey[32];
response = lorawan.get_AppSKey(appSKey);
if (response == CommandResponse::OK) {
Serial.print(F("AppSKey: "));
Serial.write(appSKey, 32);
Serial.println();
} else {
Serial.println(F("Error getting the AppSKey"));
}
// Efetua a leitura da NwkSKey do módulo
char nwkSKey[32];
response = lorawan.get_NwkSKey(nwkSKey);
if (response == CommandResponse::OK) {
Serial.print(F("NwkSKey: "));
Serial.write(nwkSKey, 32);
Serial.println();
} else {
Serial.println(F("Error getting the NwkSKey"));
}
// Define o modo de autenticação na rede LoRaWAN como ABP
response = lorawan.set_JoinMode(SMW_SX1262M0_JOIN_MODE_ABP);
if (response == CommandResponse::OK) {
Serial.println(F("Mode set to ABP"));
} else {
Serial.println(F("Error setting the join mode"));
}
// Salva as configurações setadas acima na memória do módulo
response = lorawan.save();
if (response == CommandResponse::OK) {
Serial.println(F("Settings saved"));
} else {
Serial.println(F("Error on saving"));
}
// Efetua uma tentativa de JOIN na rede LoRaWAN
Serial.println(F("Joining the network"));
// Aguarda até o módulo conseguir se conectar na rede
while (true) {
if (lorawan.isConnected()) {
Serial.println(F("Joined"));
neopixelWrite(RGB_BUILTIN, 0, 0, RGB_BRIGHTNESS);
delay(100);
neopixelWrite(RGB_BUILTIN, 0, 0, 0);
break;
} else {
Serial.println(F("Not joined"));
neopixelWrite(RGB_BUILTIN, RGB_BRIGHTNESS, 0, 0);
delay(100);
neopixelWrite(RGB_BUILTIN, 0, 0, 0);
}
delay(1000);
}
}
void loop() {
// Verifica se a conexão está ok
if (lorawan.isConnected()) {
joined = true;
} else {
joined = false;
}
if (joined) {
Serial.println(F("Sending Uplink"));
// Led para feedbak
neopixelWrite(RGB_BUILTIN, 0, RGB_BRIGHTNESS, 0);
// Envia para a rede LoRaWAN uma payload no formato String na Porta 2
lorawan.sendT(2, "Hello World");
// Envia para a rede LoRaWAN uma payload no formato JSON na Porta 2
// lorawan.sendT(2, "{\"TempC\":34}");
// Envia para a rede LoRaWAN uma payload no formato HEX na Porta 1
// lorawan.sendX(1, "01020304");
Serial.println(F("Uplink sended"));
// Led para feedback
neopixelWrite(RGB_BUILTIN, 0, 0, 0);
}
delay(15000);
}Após a gravação do código no DevKit, abra o Serial Monitor. Será possível verificar que o módulo SMW_SX1262M0 estabelece imediatamente a conexão com a rede LoRaWAN da ATC, pois no modo ABP, as credencias já foram inseridas no network server durante a ativação, agilizando o processo de autenticação na rede no início da comunicação. Em seguinda, é enviado um "Uplink" com a string "Hello World" para a rede LoRaWAN da ATC.
Em locais onde o sinal da antena LoRa esteja fraco, pode ser necessário utilizar uma fonte externa mais robusta. No cenário de testes desse tutorial, estávamos distantes da antena e só foi possível conectar a rede ATC após utizarmos uma fonte externa de 2.5A. Porém, quando próximos a antena, a conexão foi possível utilizando até mesmo a alimentação USB do notebook.
Através da aba "Live Data" na página de detalhes do dispositivo da plataforma IOTA, é possível verificar os dados de "Uplink" enviados a rede da ATC LoRaWAN. Verifique o "Uplink" da string "Hello World" através da variável "payload_string".
Enviando um valor Hexadecimal
Também é possível enviar valores hexadecimais através do "sendX". Basta descomentar o trecho de código abaixo e gravar novamente o DevKit.
// Envia para a rede LoRaWAN uma payload no formato HEX na Porta 2
lorawan.sendX(2, "AF84EC");Na aba "Live Data" da página de detalhes do dispositivo da plataforma IOTA, verifique o "Uplink" dos valores hexadecimais "af84ec" através da variável "payload_hex".
Se for enviado um valor hexdecimal inválido, a ATC não repassa nenhuma informação a plataforma IOTA, dando a falsa sensação de que a conectividade não está funcionando.
Enviando um JSON em formato de string
Também é possível enviar uplinks no formato "JSON". Para isso, você poderá utilizar o "sendT", para enviar um valor JSON no formato de string. Atente-se em utilizar a contrabarra \ para escapar qualquer aspas duplas " no conteúdo do JSON, confome o exemplo do código abaixo:
// Envia para a rede LoRaWAN uma payload no formato JSON na Porta 2
lorawan.sendT(2, "{\"TempC\":34}");Na aba "Live Data" da página de detalhes do dispositivo da plataforma IOTA, verifique o "Uplink" do valor JSON no formato string "{\"TempC\":34}" através da variável "payload_string". Observe, que nesse caso também existe uma variável chamada "payload_json" com o conteúdo do payload já formatado em JSON. Essa funcionalidade é muito útil quando existe a necessidade de enviar várias informações em um único payload, bastando para isso acrescentar novas variáveis no conteúdo do JSON.
CONSTRUA UMA DASHBOARD E VISUALIZE OS DADOS
Na parte 3 (link em breve) do tutorial , será apresentado como integrar o DevKit ao sensor I2C BMP180, formatar os dados em JSON utilizando a biblioteca "<ArduinoJson.h>" e enviar a plataforma IOTA para a construção de dashboards e visualização dos dados .
Commentaires