MÓDULOS E KITS LoRa/LoRaWAN, LoRa MESH

LSM110A ACESSANDO SEGUNDA UART COM ARDUINO

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

Será mostrado como Habilitar a UART1 e mandar um "Hello" a cada 1 segundo.

PA9 - TXD (Uart1)

PA10 - RXD (Uart1)

Mas, não é apenas definir a classe Serial1 ? Teoricamente sim!

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

ARDUINO

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

https://www.arduino.cc/

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

Altere Placa para STM32WL series

Modelo Generic WL55JCLx

Exemplo

HardwareSerial Serial1(USART1); //<=====================

void setup() {
  // put your setup code here, to run once:
  Serial1.begin(9600);  
}

void loop() {
  // put your main code here, to run repeatedly:
  Serial1.println("Hello");
  delay(1000);
}

Transferindo (utilizado o STM32CubeProgrammer)

Executando

Montagem

PA9 - TXD (Uart1)

(PA10 - RXD (Uart1)

Fontes:

STM32 Cube Programmer - Aticleworld

stm32duino/Arduino_Core_STM32: STM32 core support for Arduino (github.com)

PeripheralPins.c

#ifdef HAL_UART_MODULE_ENABLED
WEAK const PinMap PinMap_UART_TX[] = {
  {PA_0,       USART4,  STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_USART4)},
  {PA_2,       LPUART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_LPUART1)},
  {PA_2_ALT1,  USART2,  STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF4_USART2)},
  {PA_9,       USART1,  STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF4_USART1)},
  {PA_14,      LPUART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_LPUART1)},
  {PA_14_ALT1, USART2,  STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF4_USART2)},
  {PB_3,       USART5,  STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_USART5)},
  {PB_6,       USART1,  STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_USART1)},
  {PB_10,      LPUART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF4_LPUART1)},
  {PB_11,      LPUART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF7_LPUART1)},
  {PC_1,       LPUART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_LPUART1)},
  {NC,         NP,      0}
};
#endif

#ifdef HAL_UART_MODULE_ENABLED
WEAK const PinMap PinMap_UART_RX[] = {
  {PA_1,      USART4,  STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_USART4)},
  {PA_3,      LPUART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_LPUART1)},
  {PA_3_ALT1, USART2,  STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF4_USART2)},
  {PA_10,     USART1,  STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF4_USART1)},
  {PA_13,     LPUART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_LPUART1)},
  {PA_15,     USART2,  STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF4_USART2)},
  {PB_4,      USART5,  STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_USART5)},
  {PB_7,      USART1,  STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF0_USART1)},
  {PB_10,     LPUART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF7_LPUART1)},
  {PB_11,     LPUART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF4_LPUART1)},
  {PC_0,      LPUART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_LPUART1)},
  {NC,        NP,      0}
};
#endif

Dúvidas

suporte@smartcore.com.br

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

PROGRAMANDO LSM110A EM MICROPYTHON - LoRa P2P

O objetivo deste BLOG é demonstrar como é possível utilizar programar o módulo LoRa LSM110A com a linguagem de Scripts MicroPython para envio e recebimento de Pacotes LoRa, utilizando P2P.

BETA BETA BETA BETA

LSM110A Starter KIT

Módulo

MICROPYTHON

O MicroPython é uma implementação enxuta e eficiente da linguagem de programação Python 3 que inclui um pequeno subconjunto da biblioteca padrão do Python e é otimizada para ser executada em microcontroladores e em ambientes restritos.

O MicroPython é repleto de recursos avançados, como um prompt interativo, números inteiros de precisão arbitrária, fechamentos, compreensão de listas, geradores, tratamento de exceções e muito mais. No entanto, é compacto o suficiente para caber e executar com apenas 256k de espaço de código e 16k de RAM.

O MicroPython pretende ser o mais compatível possível com o Python normal, para permitir a transferência de código com facilidade da área de trabalho para um microcontrolador ou sistema incorporado.

COMPILAÇÃO MicroPython para LSM110A (UBUNTU VM)

Baixe o MicroPython em WSL2 (seja paciente)

->git clone --recursive https://github.com/micropython/micropython.git

Agora, dentro da pasta micropython faça o checkout

->gh pr checkout 9130

Agora, dentro da pasta lib/micropython-lib faça o checkout

->gh pr checkout 572

Em C:\Users\Usuario\Desktop\micropython\ports\stm32\boards\NUCLEO_WL55, edit

mpconfigboard.mk para definir o Manifest

MCU_SERIES = wl
CMSIS_MCU = STM32WL55xx
AF_FILE = boards/stm32wl55_af.csv
STARTUP_FILE = $(STM32LIB_CMSIS_BASE)/Source/Templates/gcc/startup_stm32wl55xx_cm4.o
LD_FILES = boards/stm32wl55xc.ld boards/common_basic.ld
TEXT0_ADDR = 0x08000000

# MicroPython settings
MICROPY_VFS_FAT = 0
MICROPY_VFS_LFS2 = 1

# Don't include default frozen modules because MCU is tight on flash space
FROZEN_MANIFEST ?= $(BOARD_DIR)/manifest.py

Agora crie o Manifest para criar adicionar os módulos LoRa e adicione

include("$(MPY_DIR)/extmod/uasyncio")

require("lora-async")

require("lora-stm32wl5")

https://github.com/projectgus/micropython-lib/blob/feature/lora_stm32wl5/micropython/lora/lora-stm32wl5/lora/stm32wl5.py

Baseado no SDK LSM110A

 case RBI_SWITCH_OFF:
    {
        **HAL_GPIO_WritePin(RF_SW_CTRL1_GPIO_PORT, RF_SW_CTRL1_PIN, GPIO_PIN_RESET);
        HAL_GPIO_WritePin(RF_SW_CTRL2_GPIO_PORT, RF_SW_CTRL2_PIN, GPIO_PIN_RESET);**
        break;
    }
    case RBI_SWITCH_RX:
    {
        **HAL_GPIO_WritePin(RF_SW_CTRL1_GPIO_PORT, RF_SW_CTRL1_PIN, GPIO_PIN_SET);
        HAL_GPIO_WritePin(RF_SW_CTRL2_GPIO_PORT, RF_SW_CTRL2_PIN, GPIO_PIN_RESET);**
        break;
    }
    case RBI_SWITCH_RFO_LP:
    {
        **HAL_GPIO_WritePin(RF_SW_CTRL1_GPIO_PORT, RF_SW_CTRL1_PIN, GPIO_PIN_SET);
        HAL_GPIO_WritePin(RF_SW_CTRL2_GPIO_PORT, RF_SW_CTRL2_PIN, GPIO_PIN_SET);**
        break;
    }
    case RBI_SWITCH_RFO_HP:
    {
        **HAL_GPIO_WritePin(RF_SW_CTRL1_GPIO_PORT, RF_SW_CTRL1_PIN, GPIO_PIN_SET);
        HAL_GPIO_WritePin(RF_SW_CTRL2_GPIO_PORT, RF_SW_CTRL2_PIN, GPIO_PIN_SET);**
        break;
    }

Altere stm32wl5.py para

class NucleoWL55RFConfig:
    def __init__(self):
        self._FE_CTRL = (machine.Pin(x, mode=machine.Pin.OUT) for x in ("B12", "C13", "C3"))

    def _set_fe_ctrl(self, values):
        for pin, val in zip(self._FE_CTRL, values):
            pin(val)

    def rx(self):
        self._set_fe_ctrl((1, 0, 1))

    def tx(self, hp):
        self._set_fe_ctrl((1 if hp else 1, 1, 1))

    def idle(self):
        pass

Compilando

Em C:\Users\Usuario\Desktop\micropython\ports\stm32

execute o comando

make BOARD=NUCLEO_WL55

Gravação com STM32 PROGRAMMER

Foi pego o código executável (FIRMWARE.HEX) gerado pelo MAKE e então copiado para o WINDOWS e utilizado o STM32 CUBE para gravação.

STM32 CUBE

Apontar para aquela basta e abrir firmware.hex. Grave em 2 módulos para testar o P2P.

Execução do Micropython

Para interagir com o MicroPython, recomendo MU Editor, o mesmo permite gravar a Script Python, mas atenção ***

CÓDIGO (async.py)

# MicroPython lora simple_rxtx example - asynchronous API version
# MIT license; Copyright (c) 2023 Angus Gratton
import uasyncio
from umachine import Pin, SPI

import micropython

micropython.alloc_emergency_exception_buf(256)

def get_async_modem():
    from lora import AsyncWL55SubGhzModem
    # The LoRa configuration will depend on your board and location, see
    # README under "Modem Configuration" for some possible examples.
    lora_cfg = {
        "freq_khz": 916000,
        "bw": "125",
        "coding_rate": 5,
        "preamble_len": 8,
        "sf": 12,
    }
    return AsyncWL55SubGhzModem(lora_cfg)

async def main_task():
    modem = get_async_modem()
    await uasyncio.gather(
        uasyncio.create_task(send_coro(modem)),
        uasyncio.create_task(recv_coro(modem)),
    )

async def recv_coro(modem):
    while True:
        print("Receiving...")
        rx = await modem.recv(6000)
        if rx:
            print(f"Received: {repr(rx)}")
        else:
            print("Receive timeout!")


async def send_coro(modem):
    counter = 0
    while True:
        print("Sending...")
        await modem.send(f"Hello world from async MicroPython #{counter}".encode())
        print("Sent!")
        await uasyncio.sleep(5)
        counter += 1

if __name__ == "__main__":
    uasyncio.run(main_task())
# Escreva o seu código aqui :-)

Salve o Script Python e execute!

Foi então detectado o seguinte "problema" durante o boot** (caso use MU)

MPY: sync filesystems

MPY: soft reboot

MPY: can't mount flash

MicroPython v1.19.1-997-g55d2b01ae-dirty on 2023-06-05; NUCLEO-WL55 with STM32WL55JCI7

Type "help()" for more information.

O STM32WL55 é um dispositivo de poucos recursos, portanto não possui um sistema de arquivos flash automaticamente. Você nem sempre precisa de um sistema de arquivos no flash interno, por exemplo, se congelar todo o código Python no binário do firmware e atualizá-lo dessa maneira.

Há suporte na configuração WL55 padrão para Littlefs2, então você pode formatar uma imagem Littlefs no espaço flash disponível como este:

import os, pyb

os.VfsLfs2.mkfs(pyb.Flash(start=0))

... então, quando você reiniciar (por exemplo, com Ctrl-D), este sistema de arquivos será montado em /flash e não haverá mais erros. A documentação para este recurso está aqui.

Observe que o flash disponível será pequeno, no meu sistema era de 24 KB. Execute pyb.Flash(start=0) para imprimir o valor do objeto Flash, que inclui o comprimento.

>>> import os, pyb

>>> os.VfsLfs2.mkfs(pyb.Flash(start=0))

>>>

MPY: sync filesystems

MPY: soft reboot

MicroPython v1.19.1-997-g55d2b01ae-dirty on 2023-06-05; NUCLEO-WL55 with STM32WL55JCI7

Type "help()" for more information.

>>>