domingo, 30 de outubro de 2022

LOM204A - Programando com RTOS RIOT

O objetivo deste BLOG é demonstrar como é possível utilizar o RIOT para programação do WISOL LOM204. Foi utilizado o Starter Kit LOM204 para o teste. O exemplo permitirá via linha de comandos o acesso à rede LoRaWAN e então será enviado um texto "HELLO" via OTA, AU915, ao servidor LoRaWAN CHIRPSTACK.

BETA - EM TESTES - APENAS PARA PROGRAMADORES COM RIOT IOT

Baseado no i-nucleo-lrwan1

Testado no WSL2 (Ubuntu on Windows), mas pode ser também no MinGW ou Ubuntu.

Módulo


O que é ChirpStack
ChirpStack é um Servidor de Rede LoRaWAN de código aberto que pode ser usado para configurar redes LoRaWAN. O ChirpStack fornece uma interface web para o gerenciamento de gateways, dispositivos e inquilinos, bem como para configurar integrações de dados com os principais provedores de nuvem, bancos de dados e serviços comumente usados para lidar com dados de dispositivos. O ChirpStack fornece uma API baseada em gRPC que pode ser usada para integrar ou estender o ChirpStack.
RIOT: O sistema operacional amigável para a Internet das Coisas.

O RIOT alimenta a Internet das Coisas, como o Linux alimenta a Internet. O RIOT é um sistema operacional gratuito e de código aberto desenvolvido por uma comunidade de base que reúne empresas, universidades e entusiastas, distribuídos em todo o mundo.

O RIOT é um sistema operacional de IoT com recursos em tempo real. Foi desenvolvido por um consórcio de universidades na Alemanha e na França, que incluía a Universidade Livre de Berlim, o Instituto Francês de Pesquisa em Ciência da Computação e Automação e a Universidade de Ciências Aplicadas de Hamburgo. É lançado sob a Licença Pública Geral Menor GNU (LGPL).

É baseado na arquitetura de microkernel e é executado em microcontroladores de 8 a 32 bits. O RIOT suporta multithreading e toda a pilha de rede IoT.

O RIOT suporta a maioria dos dispositivos IoT de baixa potência e arquiteturas de microcontroladores (32 bits, 16 bits, 8 bits). O RIOT tem como objetivo implementar todos os padrões abertos relevantes que suportam uma Internet das Coisas conectada, segura, durável e amiga da privacidade.

O RIOT é um desenvolvimento amigável

Programe como você está acostumado. Não perca tempo com ambientes novos ou complexos.

Programação padrão em C ou C ++
Ferramentas padrão como gcc, gdb, valgrind
Código dependente de hardware minimizado
Zero curva de aprendizado para programação incorporada
Codifique uma vez, execute em plataformas de 8 bits (por exemplo, Arduino Mega 2560), plataformas de 16 bits (por exemplo, MSP430) e em plataformas de 32 bits (por exemplo, ARM)
Conformidade parcial com POSIX. Rumo à conformidade total com POSIX.
Desenvolva no Linux ou Mac OS usando a porta nativa, implemente no dispositivo incorporado

O RIOT é favorável aos recursos

Beneficie-se de uma arquitetura de microkernel e de um agendador sem marcação em dispositivos muito leves.

Robustez e flexibilidade da footprint de código
Permitindo a máxima eficiência energética
Capacidade em tempo real devido à latência de interrupção ultra baixa (~ 50 ciclos de clock) e agendamento com base em prioridades
Multiencadeamento com sobrecarga de encadeamento ultra baixo (<25 bytes por encadeamento)

O RIOT é amigável à Internet das coisas

Prepare seus aplicativos para as coisas menores da Internet com suporte comum ao sistema.

6LoWPAN, IPv6, RPL e UDP
CoAP e CBOR
Alocação de memória estática e dinâmica
Temporizadores de alta resolução e longo prazo
Ferramentas e utilitários (shell do sistema, SHA-256, filtros Bloom, ...)

Estrutura do RIOT


LOM204A E RIOT

Como o módulo LOM204A é baseado no chip STM32L0 (CPU), será possível rodar o RIOT sem problemas. O usuário deve dar atenção ao mapeamento de GPIOS de acesso ao SX1276 (Semtech LoRa).


O link abaixo, é roteiro Básico para que você possa preparar o ambiente para programar o LOM204


Durante o processo você "deverá" instalar

git, Arm Toolchain, gcc, make, python3, pip3

Clone RIOT OS
git clone github.com/RIOT-OS/RIOT.git
cd RIOT
Entre no CHIRPSTACK

Configuração do aplicativo do LOM204A
Antes de criar o aplicativo e ingressar em uma rede LoRaWAN, você precisa de uma conta em um provedor de back-end LoRaWAN. Em seguida, crie um aplicativo LoRaWAN e registre seu dispositivo. Como este aplicativo foi fortemente testado com o backend fornecido pelo CHIRPSTACK. Assim que seu aplicativo e dispositivo forem criados e registrados, você terá várias informações (fornecidas pelo provedor LoRaWAN).
Assim que seu aplicativo e dispositivo forem criados e registrados, você terá várias informações fornecidas pelo provedor LoRaWAN:
  • O tipo de procedimento de JOIN: ABP (Ativação por personalização) ou OTAA (Ativação Over The Air) 
  • O dispositivo EUI: uma matriz de 8 bytes 
  • A aplicação EUI: uma matriz de 8 bytes 
  • A chave do aplicativo: uma matriz de 16 bytes 
  • O endereço do dispositivo: uma matriz de 4 bytes, necessária apenas com o procedimento de junção ABP 
  • A chave de sessão do aplicativo: uma matriz de 16 bytes, necessária apenas com o procedimento de junção ABP 
  • A chave de sessão de rede: uma matriz de 16 bytes, necessária apenas com o procedimento de junção ABP 
  • Depois de obter essas informações, edite o Makefile adequadamente ou use os comandos set/get no shell do aplicativo de teste.

Editando arquivos em

\RIOT\tests\pkg_semtech-loramac

Makefile

BOARD ?= b-l072z-lrwan1 include ../Makefile.tests_common BOARD_WITHOUT_LORAMAC_RX := \ arduino-mega2560 \ i-nucleo-lrwan1 \ stm32f0discovery \ waspmote-pro \ LORA_DRIVER ?= sx1276 LORA_REGION ?= AU915 USEPKG += semtech-loramac USEMODULE += $(LORA_DRIVER) # load loramac RX if board supports it ifeq (,$(filter $(BOARD),$(BOARD_WITHOUT_LORAMAC_RX))) USEMODULE += semtech_loramac_rx endif USEMODULE += auto_init_loramac USEMODULE += shell USEMODULE += shell_cmds_default USEMODULE += fmt FEATURES_OPTIONAL += periph_eeprom # Default IotLab Config to run the test ifneq (,$(filter iotlab%,$(MAKECMDGOALS))) IOTLAB_NODES ?= 1 IOTLAB_TYPE ?= st-lrwan1:sx1276 IOTLAB_SITE ?= saclay include $(RIOTBASE)/dist/testbed-support/Makefile.iotlab endif include $(RIOTBASE)/Makefile.include

\RIOT\boards\b-l072z-lrwan1\include
board.h

/* * Copyright (C) 2017 Inria * * This file is subject to the terms and conditions of the GNU Lesser * General Public License v2.1. See the file LICENSE in the top level * directory for more details. */ /** * @ingroup boards_b-l072z-lrwan1 * @{ * * @file * @brief Board specific definitions for the ST B-L072Z-LRWAN1 board * * @author Alexandre Abadie <alexandre.abadie@inria.fr> */ #ifndef BOARD_H #define BOARD_H #include <stdint.h> #include "cpu.h" #ifdef __cplusplus extern "C" { #endif /** * @name xtimer configuration * @{ */ #define XTIMER_WIDTH (16) /** @} */ /** * @name sx1276 configuration * @{ */ #define SX127X_PARAM_SPI (SPI_DEV(1)) #define SX127X_PARAM_SPI_NSS GPIO_PIN(PORT_A, 4) #define SX127X_PARAM_RESET GPIO_PIN(PORT_A, 8) #define SX127X_PARAM_DIO0 GPIO_PIN(PORT_A, 12) #define SX127X_PARAM_DIO1 GPIO_PIN(PORT_B, 2) #define SX127X_PARAM_DIO2 GPIO_PIN(PORT_B, 5) #define SX127X_PARAM_DIO3 GPIO_PIN(PORT_B, 0) #define RADIO_TCXO_VCC_PIN GPIO_PIN(PORT_B, 1) /** @} */ /** * @name LED pin definitions and handlers * @{ */ ///////////#define LED0_PIN_NUM 5 ///////////#define LED0_PORT_NUM PORT_A

///////////#define LED1_PIN_NUM 5 ///////////#define LED1_PORT_NUM PORT_B

///////////#define LED2_PIN_NUM 6 ///////////#define LED2_PORT_NUM PORT_B

///////////#define LED3_PIN_NUM 7
///////////#define LED3_PORT_NUM PORT_B
/** @} */ /** * @name User button pin configuration * @{ */
///////////#define BTN0_PIN GPIO_PIN(PORT_B, 2) /**< User button pin */
///////////#define BTN0_MODE GPIO_IN_PU /**< User button pin mode */
/** @} */ #ifdef __cplusplus } #endif #include "stm32_leds.h" #endif /* BOARD_H */ /** @} */

































\RIOT\boards\b-l072z-lrwan1\include\periph_conf.h
periph_conf.h
,
{
.dev = SPI1, /* connected to SX1276 */
.mosi_pin = GPIO_PIN(PORT_A, 7),
.miso_pin = GPIO_PIN(PORT_A, 6),
.sclk_pin = GPIO_PIN(PORT_A, 5),
.cs_pin = SPI_CS_UNDEF,
.mosi_af = GPIO_AF0,
.miso_af = GPIO_AF0,
.sclk_af = GPIO_AF0,
.cs_af = GPIO_AF0,
.rccmask = RCC_APB2ENR_SPI1EN,
.apbbus = APB2,
#ifdef MODULE_PERIPH_DMA
.tx_dma = 1,
.tx_dma_chan = 1,
.rx_dma = 0,
.rx_dma_chan = 1,
#endif
},
RIOT\build\pkg\semtech-loramac\src\mac\region
REGION_AU915.C (SUB-Bands)
void RegionAU915InitDefaults( InitType_t type ) { switch( type ) { case INIT_TYPE_INIT: { // Channels // 125 kHz channels for( uint8_t i = 0; i < AU915_MAX_NB_CHANNELS - 8; i++ ) { Channels[i].Frequency = 915200000 + i * 200000; Channels[i].DrRange.Value = ( DR_5 << 4 ) | DR_0; Channels[i].Band = 0; } // 500 kHz channels for( uint8_t i = AU915_MAX_NB_CHANNELS - 8; i < AU915_MAX_NB_CHANNELS; i++ ) { Channels[i].Frequency = 915900000 + ( i - ( AU915_MAX_NB_CHANNELS - 8 ) ) * 1600000; Channels[i].DrRange.Value = ( DR_6 << 4 ) | DR_6; Channels[i].Band = 0; } // Initialize channels default mask ChannelsDefaultMask[0] = 0xFF00; ChannelsDefaultMask[1] = 0x0000; ChannelsDefaultMask[2] = 0x0000; ChannelsDefaultMask[3] = 0x0000; ChannelsDefaultMask[4] = 0x0000; ChannelsDefaultMask[5] = 0x0000;














Compilando
LORA_DRIVER=sx1276 make BOARD=b-l072z-lrwan1 -C tests/pkg_semtech-loramac
TESTANDO NO WISOL LOM204A

text data bss dec hex filename 62604 184 7584 70372 112e4 /home/ubuntu/RIOT/tests/pkg_semtech-loramac/bin/b-l072z-lrwan1/tests_pkg_semtech-loramac.elf make: Leaving directory '/home/ubuntu/RIOT/tests/pkg_semtech-loramac' ubuntu@DESKTOP-GRCNLV8:~/RIOT$


Na pasta

/home/ubuntu/RIOT/tests/pkg_semtech-loramac/bin/b-l072z-lrwan1
será gerado o tests_pkg_semtech-loramac.bin

Utilize STM32 PROGRAMMER para gravar


Abra o Emulador de Terminal

PA2 e PA3 do LOM204

Usando o SHELL

Este aplicativo fornece o comando loramac para configurar o MAC, juntar-se a uma rede e enviar/receber dados para/a partir de uma rede LoRaWAN. Subcomandos tx e join estão bloqueados até que o MAC esteja pronto. Classe A é ativado por padrão.

OTA

Juntando-se com over the air activation (OTA)

Defina seu dispositivo EUI, aplicativo EUI, chave de aplicativo:

> loramac set deveui AAAAAAAAAAAAAAAA
> loramac set appeui BBBBBBBBBBBBBBBB
> loramac set appkey CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
Junte-se a uma rede usando o procedimento OTAA:

> loramac join otaa
Join procedure succeeded!
Unindo-se à ativação por personalização (ABP)

OTAA é sempre preferido em cenários do mundo real. No entanto, a ABP pode ser prática para testes ou workshops.

Defina o endereço do dispositivo, a chave da sessão da rede, a chave da sessão do aplicativo:

> loramac set devaddr AAAAAAAA
> loramac set nwkskey BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
> loramac set appskey CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
Junte-se a uma rede usando o procedimento ABP:

> loramac join abp
Join procedure succeeded!
Salvar contadores de quadros na memória flash não é (ainda) suportado. Antes de enviar dados, é necessário limpar contadores de quadros no Servidor de Rede! Caso contrário, as mensagens de uplink não funcionarão.

NOTA: Se usar TTN com ABP, certifique-se de definir a taxa de dados correta para RX2. Caso contrário, mensagens confirmadas e de downlink não funcionarão. O datarate para RX2 deve ser DR3 (SF9BW125) como visto na visão geral das frequências LoRaWAN:

> loramac set rx2_dr 3
Envio e recebimento de dados

Enviar dados confirmáveis na porta 2 (cnf e porta são opcionais):

> loramac tx This\ is\ RIOT! cnf 2
Envie dados não cconfirmáveis sobre a porta 10:

> loramac tx This\ is\ RIOT! uncnf 10
Ao usar mensagens de downlink classe A (modo padrão) serão recebidas no próximo uplink:

> loramac tx hello
    Data received: RIOT, port: 1
Outros comandos shell

Salve a configuração LoRaWAN do dispositivo (EUIs e chaves) em EEPROM (se fornecido pelo microcontrolador):

> loramac save
Na próxima reinicialização do dispositivo, esses parâmetros serão lidos automaticamente a partir do armazenamento não volátil EEPROM e, portanto, você pode se juntar diretamente à rede sem inseri-los novamente da linha de comando.

Remova a configuração LoRaWAN armazenada anteriormente:
> loramac erase
Alterne o índice de taxa de dados padrão (de 0 a 16). 5 é para SF7, BW125:

> loramac set dr 5
Mude para taxa de dados adaptativo (DataRate)

loramac set adr on
Execute um comando Link Check (será acionado na próxima transmissão):

> loramac link_check
A lista de comandos disponíveis:

> help
  help
  Command              Description
  ---------------------------------------
  loramac              control the loramac stack
  reboot               Reboot the node
Sequência de testes

  • Acesse CHIRPSTACK e pegue credenciais

loramac set deveui xxxxxxfxxex3xx9e
loramac set appeui 0000000000000000
loramac set appkey 8311413bf104565f9cc39f9c05663f1
loramac join otaa



Enviando um HELLO



Downlink



Saindo da linha de Comando para VISUAL CODE

DÚVIDAS

FORUMS RIOT

REFERÊNCIAS


Sobre a SMARTCORE

A SmartCore fornece módulos para comunicação wireless, biometria, conectividade, rastreamento e automação.
Nosso portifó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