sexta-feira, 26 de maio de 2023

PROGRAMANDO WISOL LSM110A ( LoRaWAN CLASS A - OTAA) COM ARDUINO E ACESSANDO LoRaWAN TTN - MODO ASSÍNCRONO

  

O objetivo deste BLOG é demonstrar como é possível programar o módulo WISOL LSM110A via Arduino Framework e assim utilizá-lo como OPENCPU.

BETA BETA BETA BETA

Será publicada uma sequência de bytes 
{0xde, 0xad, 0xbe, 0xef,0xde, 0xad, 0xbe, 0xef,0xde, 0xad, 0xbe} a cada 60 segundos na rede LoRaWAN TTN (CLASS A, OTAA), no modo ASSÍNCRONO, ou seja, é testado o exemplo SIMPLEASYNC.

Esta biblioteca fornece suporte para comunicação LoRaWAN usando o microcontrolador STM32WL55 (com rádio LoRa embutido) dentro do ambiente de desenvolvimento Arduino (juntamente com o núcleo stm32duino com versão 2.4.0 ou posterior).

A mesma foi modificada para funcionar no LSM110A.

BETA BETA BETA BETA

LSM110A Starter KIT
Módulo

O LSM110A é um módulo de última geração que integra o STMicroelectronics STM32WL. É muito menos consumo atual para o dispositivo IoT para estender a vida útil da bateria. E, também suporta ambas as tecnologias – Sigfox e LoRa – com o próprio módulo LSM110A.

Você pode trocar Sigfox ou LoRa com ele para que você também possa reduzir o custo. É altamente otimizado para solução de IoT (Alto Consumo de Energia, Baixo Custo)

BREAKOUT para testes


Esquema Elétrico - últimas correções





PLACA MONTADA



CONEXÃO COM ST-LINK V2 E UART


TTN
The Thing Network

A Rede de Coisas (TTN) é uma iniciativa iniciada pela sociedade civil holandesa. O objetivo é ter redes LoRaWAN instaladas em todas as cidades do mundo. Ao interconectar essas redes locais, a TTN quer construir uma infra-estrutura mundial para facilitar uma Internet das Coisas (IoT) pública.

A The Things Network (TTN) é o servidor IoT na nuvem utilizado nesse projeto. É um dos servidores gratuitos para LoRaWAN mais utilizados, com mais de 90 mil desenvolvedores, mais de 9 mil gateways de usuários conectados à rede ao redor do mundo e mais de 50 mil aplicações em funcionamento.

A TTN comercializa nós e gateways LoRa e provê treinamento individual e coletivo para empresas e desenvolvedores que desejam utilizar o LoRa. Possui uma comunidade bem ativa nos fóruns, sempre colaborando e ajudando a resolver problemas, além de prover diversos meios de integrar a TTN com a aplicação que se deseja usar. Possui integração nativa com diversas aplicações como: Cayenne, Hypertext Transfer Protocol (HTTP), permitindo ao usuário realizar uplink para um gateway e receber downlink por HTTP, OpenSensors e EVRYTHNG . Caso o usuário queira criar sua própria aplicação, a TTN disponibiliza Application Programming Interface (API) para uso com Message Queuing Telemetry Transport (MQTT) e diversos Software Developer Kits (SDK) para uso com as linguagens Python, Java , Node.Js , NODE-RED e Go

A rede TTN utiliza o protocolo LoRaWAN objetivando uma cobertura em longo alcance para os dispositivos da rede, caracterizando-a assim com uma Wide Area Network (WAN). Devido ao baixo consumo de energia e ao uso da tecnologia LoRa, é chamada de LPWAN (Low Power Wide Area Network). O grande diferencial da TTN é seu estabelecimento como uma rede aberta (open-source) e colaborativa (crowd-sourced), onde qualquer usuário pode contribuir instalando um gateway em sua residência.

Os elementos da TTN são classificados como: 

• Endpoints (nós): Os dispositivos responsáveis pela camada de sensoriamento da rede, o endpoint LoRaWAN. Podem coletar informações através de sensores e também acionar dispositivos/máquinas via atuadores. São configurados através de uma das três classes distintas do protocolo LaRaWAN; 

• Gateways: Elementos responsáveis por concentrar e processar as informações enviadas pelos endpoints. Os gateways em geral estão conectados a internet, seja por WiFi/Ethernet ou 3G/4G em locais remotos. Mesmo que uma mesma rede LoRaWAN tenha diferentes objetivos, baseados em aplicações distintas, os gateways possuem o objetivo comum de fornecer a maior área de cobertura possível; 

• Aplicações: Conectar e interligar os diferentes dispositivos da rede TTN para o fornecimento de informações gerais sobre a coleta de dados dos dispositivos.

ARDUINO

O que é Arduino? Se você sabe pouco sobre Arduino, por favor dê uma olhada abaixo:

Você conhece Arduino. Instale o IDE primeiro:
https://www.arduino.cc/en/Main/Software

LSM110A e Arduino (STM32DUINO)

LSM110A é baseado em STM32WL55.  No Arduino STM32 existe este core.

Como instalar Arduino STM32? adicionar em Arquivo-->Preferências-->URLs adicionais

https://github.com/stm32duino/BoardManagerFiles/raw/main/package_stmicroelectronics_index.json


BSP

2.4.0

LIB STM32LoRaWAN - EXCELENTE!

No github


Baixe em formato ZIP


Adicione ao Arduino IDE:


Pronto


Altere Placa para STM32WL series


Modelo Generic WLE5CCUX


Ok, o ambiente de desenvolvimento está pronto. Abra o  Basic.ino  e configure 3 parâmetros para LoRaWAN_OTAA os quais deve ser obtidos no servidor TTN.

bool connected = modem.joinOTAA(/* AppEui */ "0000000000000099", /* AppKey */ "FF9F138B40180AA45D6846E0A0146954", /* DevEui */ "0080E115051FD80A");



Neste exemplo, será transmitido para LoRaWAN (TTN) os dados

Altere em radio_board_if.c 
em
C:\Users\Usuario\Documents\Arduino\libraries\STM32LoRaWAN-main\src\BSP

// Supported TX modes (LP/HP or both) #if !defined(LORAWAN_TX_CONFIG) #define LORAWAN_TX_CONFIG RBI_CONF_RFO_HP //MIGUEL#define LORAWAN_TX_CONFIG RBI_CONF_RFO_LP_HP #endif #if !defined(LORAWAN_RFSWITCH_PINS) #define LORAWAN_RFSWITCH_PINS PB12,PC13 #define LORAWAN_RFSWITCH_PIN_COUNT 2 #define LORAWAN_RFSWITCH_OFF_VALUES LOW,LOW #define LORAWAN_RFSWITCH_RX_VALUES HIGH,LOW #define LORAWAN_RFSWITCH_RFO_LP_VALUES HIGH,HIGH #define LORAWAN_RFSWITCH_RFO_HP_VALUES HIGH,HIGH #endif











Baseado no...


...altere máscara de canais (Join, Uplink, Downlink)

Ver RegionAU915.c
C:\Users\Usuario\Documents\Arduino\libraries\STM32LoRaWAN-main\src\STM32CubeWL\LoRaWAN\Mac\Region

// Initialize channels default mask #if ( HYBRID_ENABLED == 1 ) RegionNvmGroup2->ChannelsDefaultMask[0] = HYBRID_DEFAULT_MASK0; RegionNvmGroup2->ChannelsDefaultMask[1] = HYBRID_DEFAULT_MASK1; RegionNvmGroup2->ChannelsDefaultMask[2] = HYBRID_DEFAULT_MASK2; RegionNvmGroup2->ChannelsDefaultMask[3] = HYBRID_DEFAULT_MASK3; RegionNvmGroup2->ChannelsDefaultMask[4] = HYBRID_DEFAULT_MASK4; RegionNvmGroup2->ChannelsDefaultMask[5] = 0x0000; #else RegionNvmGroup2->ChannelsDefaultMask[0] = 0xFF00; RegionNvmGroup2->ChannelsDefaultMask[1] = 0x0000; RegionNvmGroup2->ChannelsDefaultMask[2] = 0x0000; RegionNvmGroup2->ChannelsDefaultMask[3] = 0x0000; RegionNvmGroup2->ChannelsDefaultMask[4] = 0x00FF; RegionNvmGroup2->ChannelsDefaultMask[5] = 0x0000; #endif /* HYBRID_ENABLED == 1 */

Segue código final (alterado)

/** * This is a an example of the asynchronous API. This sketch is not * completely asynchronous (see ScheduledAsync.ino for that) and its * flow still follows the LoRa flow, but this sketch shows how some * background work can be done while waiting for the LoRa library to * complete its work. * * Revised BSD License - https://spdx.org/licenses/BSD-3-Clause.html */ #include <STM32LoRaWAN.h> STM32LoRaWAN modem; static const unsigned long TX_INTERVAL = 60000; /* ms */ unsigned long last_tx = 0; static const unsigned long BLINK_INTERVAL = 250; /* ms */ unsigned long last_blink = 0; void background_work() { if (millis() - last_blink > BLINK_INTERVAL) { last_blink = millis(); digitalWrite(PA8, !digitalRead(PA8)); } } void wait_for_idle() { while (modem.busy()) { // Call maintain() so the lora library can do any // pending background work too. modem.maintain(); background_work(); } } void setup() { pinMode(PA8, OUTPUT); Serial.begin(115200); Serial.println("Start"); modem.begin(AU915);
modem.setAppEui("0000000000000099"); modem.setAppKey("FF9F138B40180AA45D6846E0A0146954"); modem.setDevEui("0XX0EXX50XXFXX0A"); while(1) { // Configure join method by (un)commenting the right method // calls, and fill in credentials in those method calls. modem.joinOTAAAsync(); //modem.setDevAddr("00000000"); //modem.setNwkSKey("00000000000000000000000000000000"); //modem.setAppSKey("00000000000000000000000000000000"); //modem.joinABPAsync(); wait_for_idle(); if (modem.connected()) { Serial.println("Joined"); return; } else { Serial.println("Join failed"); //while (true) /* infinite loop */; delay(2000); } } } void send_packet() { uint8_t payload[] = {0xde, 0xad, 0xbe, 0xef,0xde, 0xad, 0xbe, 0xef,0xde, 0xad, 0xbe}; modem.setPort(10); modem.beginPacket(); modem.write(payload, sizeof(payload));
//confirmed package = true if (modem.endPacketAsync(true) == sizeof(payload)) { Serial.println("Queued packet"); } else { Serial.println("Failed to send packet"); return; } wait_for_idle(); Serial.println("Sent packet"); if (modem.available()) { Serial.print("Received packet on port "); Serial.print(modem.getDownlinkPort()); Serial.print(":"); while (modem.available()) { uint8_t b = modem.read(); Serial.print(" "); Serial.print(b >> 4, HEX); Serial.print(b & 0xF, HEX); } Serial.println(); } } void loop() { background_work(); if (!last_tx || millis() - last_tx > TX_INTERVAL) { send_packet(); last_tx = millis(); } }














Montagem


Compilando - Modo Debug



Gravador

"Instale" o STM32 Cube Programmer, o Arduino (STM32 PACKAGE) irá reconhecê-lo e então utilizá-lo para programar o LSM110A. O Kit LSM110A possui um "gravador" ST-LINK embarcado.

Neste blog foi utilizado o BREAKOUT e um ST-LINK-V2.



Uma vez gravado o Software, o LSM110A fará o JOIN na LoRaWAN enviará o pacote a cada 60 segundos de forma assíncrona.



UPLINK message
PA2 - TXD / PA3- RXD

DOWNLINK message



Fontes:


Dúvidas

Sobre a SMARTCORE

A SmartCore fornece módulos para comunicação wireless, biometria, conectividade, rastreamento e automação.
Nosso portfólio inclui modem 2G/3G/4G/NB-IoT/Cat.M, satelital, módulos WiFi, Bluetooth, GNSS / GPS, Sigfox, LoRa, leitor de cartão, leitor QR code, mecanismo de impressão, mini-board PC, antena, pigtail, LCD, bateria, repetidor GPS e sensores.

Mais detalhes em www.smartcore.com.br

Nenhum comentário:

Postar um comentário