INTRODUÇÃO
Nesse tutorial, será apresentado o passo a passo de como integrar o Devkit ESP32-C3 LoRaWAN da JVTech à plataforma IOTA, utilizando a conectividade LoRaWAN da ATC para a transmissão de dados para a nuvem. Você irá aprender desde a codificação do Devkit ESP32-C3 para estabelecer conexão com a rede LoRaWAN da ATC, até o envio e apresentação dos dados na plataforma IOTA.
Devkit ESP32-C3 LoRaWAN
O Devkit ESP32-C3 LoRaWAN é uma placa de desenvolvimento criada pela JVTECH. Ela é uma ótima opção para quem deseja aprender e desenvolver seus primeiros projetos de internet das coisas utilizando a conectividade LoRaWAN. Ela é baseada no microcontrolador ESP32-C3 e conta com o módulo SMW SX1262M0 da Smart Modular para comunicação LoRaWAN. Você pode adiquir essa e outras placas pelo site da JVTech.
Plataforma IOTA
A IOTA é uma plataforma SaaS que facilita e acelera o desenvolvimento de aplicações de Internet das Coisas. Através dela, é possível integrar dispositivos IoT com a nuvem usando diferentes protocolos, criar dashboards customizáveis para visualização dos dados e gerar alertas e notificações para monitorar eventos e condições específicas em tempo real. Cadastre-se e comece a utilizar gratuitamente.
Rede ATC LoRaWAN
A Rede ATC LoRaWAN® é uma iniciativa da American Tower Corporation (ATC), líder global em infraestrutura para telecomunicações, com uma extensa rede de torres e infraestrutura, com ampla presença nacional e internacional. A rede LoRaWAN da ATC oferece uma infraestrutura de rede neutra em todo o território nacional, viabilizando projetos de Internet das Coisas (IoT) com conectividade de baixo custo. Complementando tecnologias de rede existentes, ela potencializa o desenvolvimento do IoT no Brasil, permitindo a interconexão de dispositivos em diversas áreas, como agricultura inteligente, cidades inteligentes e saúde, etc.
CONTRATANDO A CONECTIVIDADE
A conectividade LoRaWAN da ATC pode ser contratada diretamente pela plataforma IOTA. O plano pode ser adquirido tanto pela pessoa física como pela pessoa júridica, sem contrato de fidelidade e quantidade mínima de linhas. Na verdade, você pode contratar apenas uma linha, se assim desejar, tornando o processo simples e sem burocracia. A seguir, é apresentado o passo a passo para realizar a contratação.
Passo 1 - Contrate um plano de conectividade
No menu lateral "LoRaWAN ATC", vá até a opção "checkout". Caso ainda não tenha cadastro na plataforma, cadastre-se pelo link.
Escolha o plano e a quantidade que deseja contratar:
Observação:
Certifique-se de que exista cobertura da rede LoRaWAN ATC na sua localidade.
Fonte: IoT Labs
Passo 2- Faça o pagamento
Utilizando um cartão de crédito, faça o pagamento do plano escolhido. Quando o gateway de pagamentos aprovar a transação, você receberá uma notificação por e-mail confirmando o pagamento.
Observações:
A contratação do plano pode ser feita tanto pela pessoa física como pela pessoa jurídica.
Os planos de conectividade possuem duração de 1 ano.
Os limites de uplink e downlink são renovados mensalmente, sempre no primeiro dia úitl de cada mês.
Passo 3 - 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 via OTA (Over The Air) do módulo LoRa SMW SX1262M0 embarcado no DevKit.
Para ativação via ABP, siga a parte 2 desse tutorial.
Passo 1 - Configurando o ambiente de desenvolvimento
Como o DevKit é baseado no ESP32-C3, antes de começarmos a escrever o código, serão necessárias algumas configurações iniciais para deixar o Arduino IDE compatível com o DevKit.
O primeiro passo é adicionar as placas da família ESP32 ao Arduino IDE. Começe selecionando o menu File>Preferences ou apertando as teclas Ctrl+Vírgula no seu teclado.
Quando aparecer o menu Preferences, adicione o seguinte link ao parâmetro "Adicional boards manager URLs" o seguinte link: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
Em seguida, no menu Tools>Board>esp32, escolha a placa "ESP32C3 Dev Module".
Por fim, no menu Tools>USB CDC on Boot, escolha a opção "Enable".
Passo 2) Instalando bibliotecas
A comunição com o DevKit ESP32-C3 LoRaWAN e por sua vez com o módulo LoRaWAN, é realizada através da comunicação serial. Porém, a biblioteca padrão do Arduino IDE "<SoftwareSerial.h>", se mostrou problemática na comunicação do ESP32-C3 durante a realização desse tutorial. Por isso, antes de começarmos a escrever o código, vamos instalar a seguinte biblioteca:
Instale a biblioteca "EspSoftwareSerial by Dirk Kaar". Para utiliza-lá, você irá importá-la do mesmo jeito que a biblioteca Software Serial padrão: "#include <SoftwareSerial.h>".
Aproveite também para já instalar a biblioteca "RoboCore_SMW_SX1262M0", que irá facilitar a manipulação do módulo LoRaWAN mais a frente nesse tutorial.
Passo 3 - Descobrindo os parâmetros do módulo LoRaWAN para conexão via OTA
Para descobrir e/ou alterar os parâmetros de ativação via OTA 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 via OTA do módulo LoRaWAN SMW_SX1262M0, envie o comando "ATZ". Esse comando faz a reinicialização do módulo, e em seguida apresenta as seguintes informações. O modo de ativação do módulo na rede LoRaWAN "OTAA Mode enabled", e os respectivos parâmetros para ativação, "DevEui", "JoinEui (AppEui)" e "AppKey". Guarde esses parâmetros, pois eles serão utilizados na plataforma IOTA para ativação do módulo na rede ATC LoRaWAN .
Passo 4 - Alterar os parâmetros de ativação via OTA
Você também pode customizar os parâmetros de ativação "APPEUI (JoinEui)" e "APPKEY" 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+APPKEY=d0:88:7c:cb:20:f9:00:87:2f:ae:c0:af:4f:83:e5:00
AT+SAVE
ATZ
Observaçõ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 "APPKEY".
Passo 5 - 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 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" e "Application Key" com as informações coletadas na seção anterior, escolha também um "Name" e um Description" para o dispositivo.
Em "LoRaWAN ATC Plan", escolha um dos planos contratados no começo 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 realizer o "Join" do DevKit a rede ATC e 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 Uplink ---"));
// 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 da AppKey do módulo
char appKey[32];
response = lorawan.get_AppKey(appKey);
if (response == CommandResponse::OK) {
Serial.print(F("AppKey: "));
Serial.write(appKey, 32);
Serial.println();
} else {
Serial.println(F("Error getting the AppKey"));
}
// Define o modo de autenticação na rede LoRaWAN como OTAA
response = lorawan.set_JoinMode(SMW_SX1262M0_JOIN_MODE_OTAA);
if (response == CommandResponse::OK) {
Serial.println(F("Mode set to OTAA"));
} 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"));
lorawan.join();
// 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 feedback
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 2
// lorawan.sendX(2, "AF84EC");
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 faz algumas tentativas de "Join" na rede ATC, e após alguns segundos ele é autenticado na rede "Joined". Logo 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 tanto as tentativas de "Join", como 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.
PRÓXIMOS PASSOS
Na parte dois e três(link em breve) desse tutorial , será apresentado como ativar o DevKit utilizando a ativação ABP, integrar o DevKit ao sensor BMP180 utilizando I2C, formatar os dados em JSON utilizando a biblioteca "<ArduinoJson.h>" para enviar a plataforma IOTA e por fim, com construir dashboards para visualização online dos dados.
Comments