MÓDULOS E KITS LoRa/LoRaWAN, LoRa MESH - PRIMEIROS PASSOS: PROGRAMANDO LSM110A EM MICROPYTHON

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

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.

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.

>>>