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
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
2.4.0
LIB STM32LoRaWAN - EXCELENTE!
No github
Baixe em formato ZIP
Adicione ao Arduino IDE:
Pronto
Altere Placa para STM32WL series
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
DOWNLINK message
Fontes:
SmartCore - --- SmartCore - tecnico publico - All Documents (sharepoint.com) (Nodes) / LMIC - The Things Network
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