domingo, 24 de maio de 2026

LSM110 MESHTASTIC

🚀 Meshtastic no LSM110A (STM32WL55JCIx) — Guia Completo de Port

📅 Data: Maio 2026
👤 Autor: Miguel Alexandre Wisintainer
🔧 Hardware: WISOL LSM110A (STM32WL55JCIx)
📦 Firmware base: Meshtastic 2.8.0 — variant wio-e5
📖 Blog: lom204-cli-wisol.blogspot.com

Este guia documenta como portar o firmware Meshtastic para o módulo LSM110A da WISOL, baseado no chip STM32WL55JCIx da STMicroelectronics. O LSM110A é um módulo LoRaWAN industrial de alta qualidade, com TCXO integrado e excelente estabilidade de frequência — características que o tornam ideal para nós Meshtastic de longa autonomia.

📋 Índice

  1. O módulo LSM110A
  2. Pré-requisitos
  3. Clonar o repositório Meshtastic
  4. Modificações necessárias no firmware
  5. Compilar o firmware
  6. Gravar o firmware no LSM110A
  7. Configurar o nó via CLI
  8. Testar a comunicação mesh
  9. Resumo das mudanças
  10. Conclusão

1. O módulo LSM110A

O LSM110A é um módulo LoRaWAN da WISOL baseado no STM32WL55JCIx da STMicroelectronics. As suas principais características são:

CaracterísticaValor
ChipSTM32WL55JCIx
NúcleosCortex-M4 (aplicação) + Cortex-M0+ (rádio)
Flash256 KB
RAM64 KB
RádioSub-GHz LoRa integrado (SX1262 interno)
TCXOSim — 1.7V
Frequência868 MHz / 915 MHz
Potência TXaté 22 dBm
RF Switch CTRL1PB12
RF Switch CTRL2PC13
Serial (UART)PA2 (TX), PA3 (RX)
ℹ️ Porquê o LSM110A para Meshtastic? O STM32WL55 tem consumo ultra-baixo em sleep e o TCXO garante estabilidade de frequência mesmo com variações de temperatura — ideal para nós relay alimentados por bateria + painel solar.

2. Pré-requisitos

  • VSCode com extensão PlatformIO IDE
  • Git instalado no sistema
  • Python 3.x instalado (com pip)
  • STM32CubeProgrammer — para gravar o firmware via UART ou ST-Link
  • Adaptador USB-UART (CP2102 ou CH340) — para comunicação serial com o LSM110A
  • Meshtastic CLI — instalar com: pip install meshtastic

Verifica a instalação do CLI:

python -m meshtastic --version

3. Clonar o repositório Meshtastic

git clone https://github.com/meshtastic/firmware.git
cd firmware
git submodule update --init

Abre a pasta firmware no VSCode. O PlatformIO irá instalar as dependências automaticamente na primeira compilação.

4. Modificações necessárias no firmware

São necessárias modificações em 3 ficheiros. Todas as alterações são cirúrgicas e bem documentadas.

4.1 — RF Switch: variants/stm32/wio-e5/rfswitch.h

Define os pinos do RF switch do LSM110A. O módulo usa apenas dois pinos de controlo:

// LSM110A (STM32WL55JCIx)
// RF Switch: PB12 = CTRL1, PC13 = CTRL2
// O LSM110A transmite APENAS via RFO_HP (High Power)
static const RADIOLIB_PIN_TYPE rfswitch_pins[5] = {
    PB12, PC13, RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC
};
static const Module::RfSwitchMode_t rfswitch_table[4] = {
    {STM32WLx::MODE_IDLE,  {LOW,  LOW}},
    {STM32WLx::MODE_RX,    {HIGH, LOW}},
    {STM32WLx::MODE_TX_HP, {HIGH, HIGH}},
    END_OF_MODE_TABLE
};

4.2 — MAC address único: src/platform/stm32wl/main-stm32wl.cpp

O STM32WL55 gera o Node ID a partir do UID do chip. Em alguns lotes de produção, dois chips podem ter o mesmo UID. Para garantir IDs únicos em cada módulo, usa-se o BUILD_EPOCH (timestamp Unix da compilação) como factor adicional de aleatoriedade:

void getMacAddr(uint8_t *dmac)
{
    const uint32_t uid0 = HAL_GetUIDw0();
    const uint32_t uid1 = HAL_GetUIDw1();
    const uint32_t uid2 = HAL_GetUIDw2();

    // XOR com BUILD_EPOCH garante ID único por compilação
    // Cada compilação tem um timestamp diferente
    dmac[5] = (uint8_t)(uid0 ^ (BUILD_EPOCH & 0xFF));
    dmac[4] = (uint8_t)(uid0 >> 16) ^ ((BUILD_EPOCH >> 8) & 0xFF);
    dmac[3] = (uint8_t)uid1;
    dmac[2] = (uint8_t)(uid1 >> 8);
    dmac[1] = (uint8_t)uid2;
    dmac[0] = (uint8_t)(uid2 >> 8);
}
ℹ️ Como funciona o BUILD_EPOCH: O PlatformIO define automaticamente BUILD_EPOCH como o timestamp Unix do momento da compilação. Como cada compilação acontece em momentos diferentes, o MAC gerado será sempre único — sem necessidade de configuração manual.

5. Compilar o firmware

Usa o ambiente wio-e5 — é o variant mais compatível com o STM32WL55 do LSM110A:

pio run -e wio-e5

O binário gerado fica em:

.pio/build/wio-e5/firmware.bin
⚠️ Para cada módulo LSM110A: Compila o firmware separadamente para cada módulo (em momentos diferentes). O BUILD_EPOCH muda a cada compilação, garantindo Node IDs únicos.

6. Gravar o firmware no LSM110A

1 Entra em modo bootloader: Liga o pino BOOT0 a VCC e faz reset. O LSM110A entra em modo de programação UART.
2 Liga o CP2102/CH340: Conecta PA2 (TX) ao RX do adaptador e PA3 (RX) ao TX do adaptador.
3 Abre o STM32CubeProgrammer → selecciona UART → conecta à porta COM do adaptador.
4 Full Chip Erase — obrigatório! Limpa o Node ID anterior e força o Meshtastic a gerar um novo ID único.
5 Grava o firmware: Selecciona o ficheiro firmware.bin e grava no endereço 0x08000000.
6 Verifica: O STM32CubeProgrammer deve mostrar "Verify OK".
7 Sai do modo bootloader: Coloca BOOT0 em LOW e faz reset. O Meshtastic inicia automaticamente.

7. Configurar o nó via CLI

Liga o LSM110A ao PC via CP2102 e verifica se o Meshtastic está a responder:

python -m meshtastic --port COM6 --info

Resposta esperada:

Connected to radio
Owner: Meshtastic XXXX
firmwareVersion: "2.8.0.ef734b7"
hwModel: WIO_E5
pioEnv: "wio-e5"

Configura a região (Brasil usa ANZ — banda 915-928 MHz):

python -m meshtastic --port COM6 --set lora.region ANZ

Configura o nome do nó:

python -m meshtastic --port COM6 --set device.longName "LSM110 Node1"
python -m meshtastic --port COM6 --set device.shortName "LS-1"

Activa a telemetria:

python -m meshtastic --port COM6 --set telemetry.deviceTelemetryEnabled true

Reinicia o nó para aplicar as configurações:

python -m meshtastic --port COM6 --reboot

8. Testar a comunicação mesh

Com dois módulos LSM110A gravados e configurados com região ANZ, abre dois terminais:

Terminal 1 — Node1 a escutar:

python -m meshtastic --port COM6 --listen

Terminal 2 — Node2 a enviar:

python -m meshtastic --port COM3 --sendtext "Hello from Node2!"

Resultado esperado no Terminal 1:

decoded {
  portnum: TEXT_MESSAGE_APP
  payload: "Hello from Node2!"
}
rx_snr: 6.25
rx_rssi: -69
hop_limit: 3
fromId: '!5008332a'
transport_mechanism: TRANSPORT_LORA
✅ Mesh a funcionar! RSSI de -69 dBm e SNR de 6.25 indicam excelente qualidade de sinal. O campo TRANSPORT_LORA confirma que a mensagem viajou via rádio LoRa.

8.1 — Web Client (interface gráfica)

Para uma interface mais amigável, usa o Web Client oficial:

  1. Abre o Chrome ou Edge em client.meshtastic.org
  2. Clica em Add Connection → Serial
  3. Selecciona a porta COM do LSM110A
  4. Vês os nós detectados, mensagens e configurações em tempo real
ℹ️ Dois nós em simultâneo: Usa o Chrome para um nó e o Edge para o outro — cada browser tem o seu contexto Serial independente.

9. Resumo das mudanças

FicheiroMudançaMotivo
variants/stm32/wio-e5/rfswitch.hPB12 e PC13 apenas; tabela com MODE_TX_HPPinos correctos do RF switch do LSM110A
src/mesh/STM32WLE5JCInterface.cppsetTCXO(1.7) antes do begin(); return trueTCXO obrigatório; begin() pode retornar erro mas rádio funciona
src/platform/stm32wl/main-stm32wl.cppgetMacAddr() com XOR do BUILD_EPOCHGarante Node IDs únicos por compilação
Ambiente PlatformIOUsar wio-e5Variant mais compatível com o STM32WL55

📡 Configurações LoRa em uso

ParâmetroValor
Região (Brasil)ANZ (915-928 MHz)
Modem PresetLONG_FAST
Spreading FactorSF11
Bandwidth250 kHz
Coding Rate4/5
Potência TX22 dBm
Hop Limit3 saltos
TCXO1.7V
Canal padrãoLongFast (compatível com toda a rede Meshtastic)

🔄 Procedimento para cada novo LSM110A

  1. Aplica as 3 modificações nos ficheiros acima
  2. Compila: pio run -e wio-e5
  3. Full Chip Erase no STM32CubeProgrammer
  4. Grava o firmware.bin em 0x08000000
  5. Configura via CLI: região ANZ + nome
  6. Repete o processo para cada módulo adicional (nova compilação = novo BUILD_EPOCH = novo ID)

10. Conclusão

O LSM110A (STM32WL55JCIx) é um excelente módulo para integrar na rede Meshtastic, especialmente como nó relay/repetidor de longa autonomia. Com as modificações documentadas neste guia, é possível ter o Meshtastic completamente funcional, incluindo:

  • ✅ Comunicação LoRa bidirecional (TX e RX)
  • ✅ Telemetria automática (bateria, uptime, utilização do canal)
  • ✅ Detecção automática de nós vizinhos
  • ✅ Envio e recepção de mensagens de texto
  • ✅ Compatibilidade total com qualquer nó Meshtastic na região ANZ
  • ✅ Interface Web Client via Serial
  • ✅ Node IDs únicos automáticos via BUILD_EPOCH

O LSM110A, sem GPS, ecrã ou Bluetooth, é ideal como nó repetidor autónomo — pode funcionar anos com bateria + painel solar, retransmitindo automaticamente as mensagens de toda a rede mesh, expandindo o alcance para dezenas de quilómetros em linha de vista.

📬 Comunidade Meshtastic Brasil: t.me/meshtastic_br
📖 Outros projectos com LSM110A: lom204-cli-wisol.blogspot.com
🔗 Firmware Meshtastic: github.com/meshtastic/firmware
Meshtastic no LSM110A (STM32WL55JCIx) — Guia Completo

🚀 Meshtastic no LSM110A (STM32WL55JCIx) — Guia Completo de Port

📅 Data: Maio 2026
👤 Autor: Miguel Alexandre Wisnieski
🔧 Hardware: WISOL LSM110A (STM32WL55JCIx)
📦 Firmware base: Meshtastic 2.8.0 — variant wio-e5
📖 Blog: lom204-cli-wisol.blogspot.com

Este guia documenta como portar o firmware Meshtastic para o módulo LSM110A da WISOL, baseado no chip STM32WL55JCIx da STMicroelectronics. O LSM110A é um módulo LoRaWAN industrial de alta qualidade, com TCXO integrado e excelente estabilidade de frequência — características que o tornam ideal para nós Meshtastic de longa autonomia.

📋 Índice

  1. O módulo LSM110A
  2. Pré-requisitos
  3. Clonar o repositório Meshtastic
  4. Modificações necessárias no firmware
  5. Compilar o firmware
  6. Gravar o firmware no LSM110A
  7. Configurar o nó via CLI
  8. Testar a comunicação mesh
  9. Resumo das mudanças
  10. Conclusão

1. O módulo LSM110A

O LSM110A é um módulo LoRaWAN da WISOL baseado no STM32WL55JCIx da STMicroelectronics. As suas principais características são:

CaracterísticaValor
ChipSTM32WL55JCIx
NúcleosCortex-M4 (aplicação) + Cortex-M0+ (rádio)
Flash256 KB
RAM64 KB
RádioSub-GHz LoRa integrado (SX1262 interno)
TCXOSim — 1.7V
Frequência868 MHz / 915 MHz
Potência TXaté 22 dBm
RF Switch CTRL1PB12
RF Switch CTRL2PC13
Serial (UART)PA2 (TX), PA3 (RX)
ℹ️ Porquê o LSM110A para Meshtastic? O STM32WL55 tem consumo ultra-baixo em sleep e o TCXO garante estabilidade de frequência mesmo com variações de temperatura — ideal para nós relay alimentados por bateria + painel solar.

2. Pré-requisitos

  • VSCode com extensão PlatformIO IDE
  • Git instalado no sistema
  • Python 3.x instalado (com pip)
  • STM32CubeProgrammer — para gravar o firmware via UART ou ST-Link
  • Adaptador USB-UART (CP2102 ou CH340) — para comunicação serial com o LSM110A
  • Meshtastic CLI — instalar com: pip install meshtastic

Verifica a instalação do CLI:

python -m meshtastic --version

3. Clonar o repositório Meshtastic

git clone https://github.com/meshtastic/firmware.git
cd firmware
git submodule update --init

Abre a pasta firmware no VSCode. O PlatformIO irá instalar as dependências automaticamente na primeira compilação.

4. Modificações necessárias no firmware

São necessárias modificações em 3 ficheiros. Todas as alterações são cirúrgicas e bem documentadas.

4.1 — RF Switch: variants/stm32/wio-e5/rfswitch.h

Define os pinos do RF switch do LSM110A. O módulo usa apenas dois pinos de controlo:

// LSM110A (STM32WL55JCIx)
// RF Switch: PB12 = CTRL1, PC13 = CTRL2
// O LSM110A transmite APENAS via RFO_HP (High Power)
static const RADIOLIB_PIN_TYPE rfswitch_pins[5] = {
    PB12, PC13, RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC
};
static const Module::RfSwitchMode_t rfswitch_table[4] = {
    {STM32WLx::MODE_IDLE,  {LOW,  LOW}},
    {STM32WLx::MODE_RX,    {HIGH, LOW}},
    {STM32WLx::MODE_TX_HP, {HIGH, HIGH}},
    END_OF_MODE_TABLE
};
⚠️ Importante: Não usar PC5 como terceiro pino de controlo — este pino não é usado pelo RF switch do LSM110A e pode interferir com a transmissão RF.

4.2 — Interface do rádio: src/mesh/STM32WLE5JCInterface.cpp

Este é o ficheiro mais crítico. O lora.begin() pode retornar erro no STM32WL55 mesmo quando o rádio está operacional. A solução é forçar a inicialização completa independentemente do resultado:

#include "configuration.h"
#ifdef ARCH_STM32WL
#include "STM32WLE5JCInterface.h"
#include "error.h"

#ifndef STM32WLx_MAX_POWER
#define STM32WLx_MAX_POWER 22
#endif

STM32WLE5JCInterface::STM32WLE5JCInterface(LockingArduinoHal *hal,
    RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq,
    RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE busy)
    : SX126xInterface(hal, cs, irq, rst, busy)
{
}

bool STM32WLE5JCInterface::init()
{
    RadioLibInterface::init();

    // Configura o RF switch para o LSM110A
    lora.setRfSwitchTable(rfswitch_pins, rfswitch_table);

    limitPower(STM32WLx_MAX_POWER);

    // TCXO a 1.7V — obrigatório para o LSM110A
    // Deve ser chamado ANTES do lora.begin()
    lora.setTCXO(1.7);

    // Inicializa o rádio (tcxoVoltage=0 porque já foi configurado acima)
    int res = lora.begin(getFreq(), bw, sf, cr, syncWord, power, preambleLength, 0);
    LOG_INFO("STM32WLx init result %d", res);
    LOG_INFO("Frequency set to %f", getFreq());
    LOG_INFO("Bandwidth set to %f", bw);
    LOG_INFO("Power output set to %d", power);

    // Forçar startReceive() independentemente do resultado do begin()
    // O rádio funciona no LSM110A mesmo que begin() reporte erro
    startReceive();
    return true;
}

#endif // ARCH_STM32WL

4.3 — MAC address único: src/platform/stm32wl/main-stm32wl.cpp

O STM32WL55 gera o Node ID a partir do UID do chip. Em alguns lotes de produção, dois chips podem ter o mesmo UID. Para garantir IDs únicos em cada módulo, usa-se o BUILD_EPOCH (timestamp Unix da compilação) como factor adicional de aleatoriedade:

void getMacAddr(uint8_t *dmac)
{
    const uint32_t uid0 = HAL_GetUIDw0();
    const uint32_t uid1 = HAL_GetUIDw1();
    const uint32_t uid2 = HAL_GetUIDw2();

    // XOR com BUILD_EPOCH garante ID único por compilação
    // Cada compilação tem um timestamp diferente
    dmac[5] = (uint8_t)(uid0 ^ (BUILD_EPOCH & 0xFF));
    dmac[4] = (uint8_t)(uid0 >> 16) ^ ((BUILD_EPOCH >> 8) & 0xFF);
    dmac[3] = (uint8_t)uid1;
    dmac[2] = (uint8_t)(uid1 >> 8);
    dmac[1] = (uint8_t)uid2;
    dmac[0] = (uint8_t)(uid2 >> 8);
}
ℹ️ Como funciona o BUILD_EPOCH: O PlatformIO define automaticamente BUILD_EPOCH como o timestamp Unix do momento da compilação. Como cada compilação acontece em momentos diferentes, o MAC gerado será sempre único — sem necessidade de configuração manual.

5. Compilar o firmware

Usa o ambiente wio-e5 — é o variant mais compatível com o STM32WL55 do LSM110A:

pio run -e wio-e5

O binário gerado fica em:

.pio/build/wio-e5/firmware.bin
⚠️ Para cada módulo LSM110A: Compila o firmware separadamente para cada módulo (em momentos diferentes). O BUILD_EPOCH muda a cada compilação, garantindo Node IDs únicos.

6. Gravar o firmware no LSM110A

1 Entra em modo bootloader: Liga o pino BOOT0 a VCC e faz reset. O LSM110A entra em modo de programação UART.
2 Liga o CP2102/CH340: Conecta PA2 (TX) ao RX do adaptador e PA3 (RX) ao TX do adaptador.
3 Abre o STM32CubeProgrammer → selecciona UART → conecta à porta COM do adaptador.
4 Full Chip Erase — obrigatório! Limpa o Node ID anterior e força o Meshtastic a gerar um novo ID único.
5 Grava o firmware: Selecciona o ficheiro firmware.bin e grava no endereço 0x08000000.
6 Verifica: O STM32CubeProgrammer deve mostrar "Verify OK".
7 Sai do modo bootloader: Coloca BOOT0 em LOW e faz reset. O Meshtastic inicia automaticamente.

7. Configurar o nó via CLI

Liga o LSM110A ao PC via CP2102 e verifica se o Meshtastic está a responder:

python -m meshtastic --port COM6 --info

Resposta esperada:

Connected to radio
Owner: Meshtastic XXXX
firmwareVersion: "2.8.0.ef734b7"
hwModel: WIO_E5
pioEnv: "wio-e5"

Configura a região (Brasil usa ANZ — banda 915-928 MHz):

python -m meshtastic --port COM6 --set lora.region ANZ

Configura o nome do nó:

python -m meshtastic --port COM6 --set device.longName "LSM110 Node1"
python -m meshtastic --port COM6 --set device.shortName "LS-1"

Activa a telemetria:

python -m meshtastic --port COM6 --set telemetry.deviceTelemetryEnabled true

Reinicia o nó para aplicar as configurações:

python -m meshtastic --port COM6 --reboot

8. Testar a comunicação mesh

Com dois módulos LSM110A gravados e configurados com região ANZ, abre dois terminais:

Terminal 1 — Node1 a escutar:

python -m meshtastic --port COM6 --listen

Terminal 2 — Node2 a enviar:

python -m meshtastic --port COM3 --sendtext "Hello from Node2!"

Resultado esperado no Terminal 1:

decoded {
  portnum: TEXT_MESSAGE_APP
  payload: "Hello from Node2!"
}
rx_snr: 6.25
rx_rssi: -69
hop_limit: 3
fromId: '!5008332a'
transport_mechanism: TRANSPORT_LORA
✅ Mesh a funcionar! RSSI de -69 dBm e SNR de 6.25 indicam excelente qualidade de sinal. O campo TRANSPORT_LORA confirma que a mensagem viajou via rádio LoRa.

8.1 — Web Client (interface gráfica)

Para uma interface mais amigável, usa o Web Client oficial:

  1. Abre o Chrome ou Edge em client.meshtastic.org
  2. Clica em Add Connection → Serial
  3. Selecciona a porta COM do LSM110A
  4. Vês os nós detectados, mensagens e configurações em tempo real
ℹ️ Dois nós em simultâneo: Usa o Chrome para um nó e o Edge para o outro — cada browser tem o seu contexto Serial independente.

9. Resumo das mudanças

FicheiroMudançaMotivo
variants/stm32/wio-e5/rfswitch.h PB12 e PC13 apenas; tabela com MODE_TX_HP Pinos correctos do RF switch do LSM110A
src/mesh/STM32WLE5JCInterface.cpp setTCXO(1.7) antes do begin(); return true TCXO obrigatório; begin() pode retornar erro mas rádio funciona
src/platform/stm32wl/main-stm32wl.cpp getMacAddr() com XOR do BUILD_EPOCH Garante Node IDs únicos por compilação
Ambiente PlatformIO Usar wio-e5 Variant mais compatível com o STM32WL55

📡 Configurações LoRa em uso

ParâmetroValor
Região (Brasil)ANZ (915-928 MHz)
Modem PresetLONG_FAST
Spreading FactorSF11
Bandwidth250 kHz
Coding Rate4/5
Potência TX22 dBm
Hop Limit3 saltos
TCXO1.7V
Canal padrãoLongFast (compatível com toda a rede Meshtastic)

🔄 Procedimento para cada novo LSM110A

  1. Aplica as 3 modificações nos ficheiros acima
  2. Compila: pio run -e wio-e5
  3. Full Chip Erase no STM32CubeProgrammer
  4. Grava o firmware.bin em 0x08000000
  5. Configura via CLI: região ANZ + nome
  6. Repete o processo para cada módulo adicional (nova compilação = novo BUILD_EPOCH = novo ID)

10. Conclusão

O LSM110A (STM32WL55JCIx) é um excelente módulo para integrar na rede Meshtastic, especialmente como nó relay/repetidor de longa autonomia. Com as modificações documentadas neste guia, é possível ter o Meshtastic completamente funcional, incluindo:

  • ✅ Comunicação LoRa bidirecional (TX e RX)
  • ✅ Telemetria automática (bateria, uptime, utilização do canal)
  • ✅ Detecção automática de nós vizinhos
  • ✅ Envio e recepção de mensagens de texto
  • ✅ Compatibilidade total com qualquer nó Meshtastic na região ANZ
  • ✅ Interface Web Client via Serial
  • ✅ Node IDs únicos automáticos via BUILD_EPOCH

O LSM110A, sem GPS, ecrã ou Bluetooth, é ideal como nó repetidor autónomo — pode funcionar anos com bateria + painel solar, retransmitindo automaticamente as mensagens de toda a rede mesh, expandindo o alcance para dezenas de quilómetros em linha de vista.

📬 Comunidade Meshtastic Brasil: t.me/meshtastic_br
📖 Outros projectos com LSM110A: lom204-cli-wisol.blogspot.com
🔗 Firmware Meshtastic: github.com/meshtastic/firmware

Documento gerado em Maio 2026 — Miguel Alexandre Wisnieski

quinta-feira, 22 de agosto de 2024

LSM110A - MESH embeNET - MQTT

 STM32 NUCLEO - MESH embeNET

      

embeNET e STM32WL: rede mesh baseada em 6TiSCH supera grandes desafios que assolam a Internet das Coisas

A ausência de um padrão popular capaz de conectar uma infinidade de dispositivos IoT em uma rede mesh é problemática. É por isso que a EMBETECH, uma empresa europeia e membro do ST Partner Program, criou o embeNET, uma pilha de rede baseada em 6TiSCH. Destinado a sistemas embarcados, o embeNET usa bibliotecas C para otimizar as operações entre dispositivos usando microcontroladores Cortex. Atualmente, a tecnologia é executada no MCU sem fio de 32 bits de longo alcance STM32WL (STM32 NUCLEO). Os desenvolvedores simplesmente usam APIs desenvolvidas pela EMBETECH para aproveitar os vários recursos do protocolo de rede. Assim, as equipes ignoram problemas de implementação altamente complexos para se concentrar na criação de uma infraestrutura original e eficiente.

Serviços de rede

Um serviço de rede no embeNET é uma funcionalidade separada construída em torno da comunicação em uma única porta UDP (raramente - múltiplas portas UDP). Três exemplos de serviços distribuídos com a pilha embeNET são:

Os usuários, entretanto, podem desenvolver facilmente seus próprios serviços usando UDP. Um exemplo desse serviço UDP personalizado é implementado nos nós de demonstração.

Serviço de demonstração MQTT-SN

O serviço de demonstração MQTT-SN usa o cliente MQTT-SN e faz três coisas:

  • publica periodicamente informações de tempo de atividade
  • ao pressionar o botão publica o contador de cliques do botão
  • reage a alguns comandos de texto simples que controlam os LEDs integrados - esses comandos são: led1on , led1off , led2on , led2off , led3on e led3off

Consulte Usando o serviço de demonstração MQTT-SN para obter mais informações sobre como esse serviço funciona e como usá-lo.

A arquitetura MQTT-SN requer um Gateway adicional, que basicamente traduz o protocolo MQTT-SN (que é baseado em UDP) para MQTT (que é baseado em TCP) (veja a parte superior da imagem abaixo).

Esse gateway geralmente é executado no roteador de borda, mas pode estar em qualquer lugar da rede.

Alguns imagens de testes com LSM110A (desligar FIREWALL)

SN-MQTT

MQTT 

NODE

Border Router

config.json
{ "serial_port": "COM14", "wan_interface": "embeNET", "log_level": "trace", "network": { "k1": "0xc08b766277099e7d7e9c0222f168cc9e", "panid": "0xe3be", "prefix": "0xaaaabbbbccccdddd" }, "join_rules": [ { "uid": 0, "psk": "0x46d7dc94e8ee7496ceaf54a3ab64cbeb" } ] }


Execução

Testes OK com Border Router e Node




Referências

Tradução, Adaptação e testes dos links

Discussões

Sem documentação entre Border Router com SN-MQTT

Ok, so it looks like the MQTT packets are received at the border router:


00:00:59.366 BR_RNC (V): Packet was decoded and handled successfuly; len: 85, rx: 0, received count: 85
00:00:59.369 EMBENET_PORT_WAN (D): Data request: {{v: 6, tc 0, fl 0, len: 34, nh: 17, hl: 64, src: aaaa:bbbb:cccc:dddd:0080:e115:051f:c14c, dst: aaaa:bbbb:cccc:dddd:0080:e115:0055:3ac8}, udp: {src: 1885, dst: 1885, len: 34, checksum: 0x8ea},  udp payload: {0x1a, 0x4, 0x4, 0x1, 0x0, 0x1e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x38, 0x30, 0x65, 0x31, 0x31, 0x35, 0x30, 0x35, 0x31, 0x66, 0x63, 0x31, 0x34, 0x63, }}


so the packets go to the network interface in Windows but somehow they do not pop up in the MQTT-SN Gateway socket (nor ENMS Visualizer).


If the MQTT-SN Gateway is on and operational on port 1885 then we have two hypothesis:

1. The firewall is blocking them - you can try to temporarily disable it and see if it helps
2. The IP forwarding is not working correctly in the system. To check this please refer to:
https://serverfault.com/questions/929081/how-can-i-enable-packet-forwarding-on-windows


Let me know if it helps or not.



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

sábado, 17 de agosto de 2024

LSM110A - MESH embeNET

STM32 NUCLEO - MESH embeNET

      

embeNET e STM32WL: rede mesh baseada em 6TiSCH supera grandes desafios que assolam a Internet das Coisas

A ausência de um padrão popular capaz de conectar uma infinidade de dispositivos IoT em uma rede mesh é problemática. É por isso que a EMBETECH, uma empresa europeia e membro do ST Partner Program, criou o embeNET, uma pilha de rede baseada em 6TiSCH. Destinado a sistemas embarcados, o embeNET usa bibliotecas C para otimizar as operações entre dispositivos usando microcontroladores Cortex. Atualmente, a tecnologia é executada no MCU sem fio de 32 bits de longo alcance STM32WL (STM32 NUCLEO). Os desenvolvedores simplesmente usam APIs desenvolvidas pela EMBETECH para aproveitar os vários recursos do protocolo de rede. Assim, as equipes ignoram problemas de implementação altamente complexos para se concentrar na criação de uma infraestrutura original e eficiente.

Os desafios por trás das redes mesh na Internet das Coisas (IoT)

Por que a eficiência energética e as interferências são problemáticas?

No livro Internet das Coisas: Desafios e Oportunidades , Maria Palattella et al. (2014) explicam como as redes industriais estão cada vez mais migrando para tecnologias baseadas em IP. A tendência é popular porque se baseia em conceitos familiares e ao mesmo tempo habilita muitos dispositivos na mesma rede. O desafio é que ele deve ser compatível com dispositivos de baixo consumo de energia, o que significa que os rádios nem sempre podem estar ligados. O padrão também deve lidar com interferências e desvanecimentos devido a vários dispositivos que usam a mesma frequência para comunicação sem fio. A resposta é o protocolo IEEE802.15.4-2011 Medium Access Control (MAC) chamado Timeslotted Channel Hopping (TSCH, pronunciado Tish).

O que é o TSC?

Como o nome indica, o TSCH depende da sincronização de horário. O padrão define um “intervalo de tempo” como uma unidade de tempo. Sua duração não é definida pela norma e pode, portanto, variar. Em um horário específico do intervalo de tempo, a rede enviará um pacote com componentes de temporização e cada nó registrará o horário em que recebeu aquele quadro. Com essas informações, todos os dispositivos podem sincronizar o relógio da rede, compensando assim qualquer desvio potencial. Graças a um contador, cada dispositivo também pode saber por quantos intervalos de tempo a rede passou. Chamado de Absolute Slot Number (ASN), ele aumenta após cada intervalo de tempo, usa um número inteiro de cinco bytes e pode, portanto, durar centenas de anos.

O outro componente principal do TSCH refere-se ao salto de canal, um mecanismo que permite a um dispositivo alternar frequências sem fio. Para garantir que nós próximos usem a mesma frequência e possam se comunicar, o padrão usa o ASN para calcular um deslocamento que determina qual frequência usar. Como todos os nós se beneficiam da sincronização de tempo rigorosa e todos conhecem o ASN, o salto de canal torna-se altamente confiável. Porém, no caso de falha na transmissão, a retransmissão ocorrerá em uma frequência diferente. Na verdade, a estratégia tem mais chances de sucesso do que reenviar o mesmo pacote na mesma frequência.

Por que o TSCH é importante?

Usar a sincronização de tempo significa que o TSCH é um padrão sem fio determinístico. As transmissões acontecem com precisão, o que significa que os microcontroladores sabem quando ligar o rádio e por quanto tempo, economizando muita energia. A coordenação do tempo também evita que um nó perca pacotes. Além disso, o salto de canal permite o uso de todos os canais disponíveis para rádios sub-GHz e 2,4 GHz. Os engenheiros podem, portanto, usar muitos dispositivos sem atrapalhar um canal, o que alivia o risco de interferências. Como resultado, o TSCH abre a porta para operações de escala massiva.

O que é 6TiSCH?

Em essência, 6TiSCH é uma rede TSCH que usa uma sub-rede IPv6. Como o protocolo utiliza endereços de 128 bits, as empresas podem aplicar um único identificador IPv6 para cada dispositivo sem medo de esgotamento, mesmo em grandes ambientes industriais. Nos bastidores, o 6TiSCH é bastante abrangente. Ele define como rotear e rastrear pacotes e implementa qualidade de serviço para priorizar determinados pacotes, bem como recursos de segurança, entre outras coisas. Simplificando, a IETF (Internet Engineering Task Force) concebeu o 6TiSCH para responder a uma ampla gama de aplicações. Seja para cidades inteligentes, transportes, edifícios ou fábricas, o 6TiSCH visa resolver os desafios inerentes às redes mesh.

embeNET, a solução para a democratização da rede Mesh na Internet das Coisas

Por que 6TiSCH ainda não é uma palavra da moda?

embeNET e as outras tecnologias EMBETECH
embeNET e as outras tecnologias EMBETECH

Embora o 6TiSCH resolva muitos problemas que afetam as redes mesh de dispositivos IoT, podemos perguntar por que a tecnologia ainda não é onipresente. Afinal, a primeira mailing list da IETF sobre o tema data de janeiro de 2013, e o livro de 2014 mencionado acima já descreve as vantagens e a importância da tecnologia. No entanto, muitos engenheiros ainda desconhecem a sua existência ou não têm muita experiência. A razão é que, embora academicamente fascinante, o 6TiSCH é comercialmente difícil de implementar. E é isso que a embeNET tenta resolver, oferecendo uma pilha de rede completa com APIs para maior facilidade de uso.

Como a embeNET está resolvendo o desafio de implementação?

O STM32WL
O STM32WL

As empresas muitas vezes têm dificuldade em implementar uma pilha de rede 6TiSCH em um microcontrolador. Embora a IETF tenha definido mecanismos voltados para dispositivos de baixo consumo de energia, ela não oferece soluções prontas para uso. Conseqüentemente, a EMBETECH pegou a tecnologia e melhorou as funções de agendamento, garantiu a estabilidade em um ambiente industrial e otimizou a pilha de rede para dispositivos com recursos limitados. Com todos os serviços habilitados, a biblioteca precisa apenas de 100 KB de flash. Portanto, como exemplo, tomemos o STM32WL (NUCLEO), o primeiro MCU com um transceptor LoRa multimodulação integrado. Neste caso, seus 256 KB de armazenamento são suficientes para o firmware, mecanismos de atualização e aplicativo.

A pilha de rede também usa o recurso de hardware do ST. Por exemplo, ele usa os recursos de modulação FSK/(G)FSK do STM32WL, o que simplifica o design geral. Da mesma forma, a biblioteca usa o núcleo criptográfico do ST e seu gerador de números verdadeiros para acelerar as operações criptográficas. Conseqüentemente, o embeNET pode ser executado em apenas um dos KIT STM32 NUCLEO. A pilha de rede pode ser executada no mesmo Arm® Cortex®-M4 que o aplicativo sem afetar negativamente o desempenho. Simplificando, os desenvolvedores desfrutam de um alto nível de otimização e podem reutilizar facilmente seu sistema em vários MCUs STM32 (STM32 NUCLEO). Por exemplo, uma rede mesh básica para uma aplicação de medidor inteligente que envia um pacote por dia poderia usar um STM32WL com baterias AA que durariam cerca de dez anos.

Começando

KIT LSM110A USADO PARA TESTE NO LUGAR DO KIT STM32 NUCLEO 

Os desenvolvedores podem começar a experimentar o embeNET pegando uma placa de desenvolvimento STM32WL como no KIT STM32 NUCLEO e baixando o pacote de software de demonstração EMBETECH . Uma versão de avaliação da pilha suporta até 10 nós e três saltos de rede. A empresa também oferece documentação para ajudar os desenvolvedores a começar. Além disso, um software de gateway é executado em PCs após conectar o KIT STM32 NUCLEO à máquina para criar uma rede virtual. Por fim, a empresa fornece uma solução em nuvem para ajudar a processar os dados dos nós da rede mesh.

Apresentando o Portal embeNET

Sua ferramenta para configurar, provisionar, monitorar e visualizar redes embeNET

O Portal embeNET  é uma aplicação web que coleta dados de todos os nós de campo conectados, permitindo visualizar as conexões e o status da rede. Ele fornece informações detalhadas sobre a operação da rede, permitindo detectar e depurar problemas de conexão desde o momento da instalação. Esta ferramenta também pode ser usada para provisionar e autorizar os dispositivos e executar ações de atualização de firmware em larga escala.  

A versão demo fornecida cobre todas as funcionalidades principais da plataforma e já vem preenchida com alguns dados de demonstração, para que você possa obter a experiência certa.

DEMO



O KIT STM32 NUCLEO oferece uma maneira acessível e flexível para os usuários experimentarem novos conceitos e construir protótipos com o microcontrolador da série STM32WL. Você pode usar essa plataforma para testar e conhecer facilmente a plataforma embeNET.


Informação importante: esta demonstração utiliza a banda de rádio europeia: 863-870MHz

Esta banda está disponível na maioria dos países europeus, mas não em todo o mundo. Contate-nos em caso de dúvidas!

O que você precisa?

Você vai precisar de pelo menos duas placas KIT STM32 NUCLEO (mais recomendadas) e um PC com Linux ou Windows. Uma placa será conectada ao PC e atuará como raiz da rede. A outra placa (ou placas) atuará como nós. 

Você também precisará do STM32CUBE  para usar os exemplos de software fornecidos e programar as placas.

Transferências

Código fonte e pacote binário para o KIT STM32 NUCLEO e Windows.

Como começar?

Introdução à demonstração embeNET para o KIT STM32 NUCLEO.

Está com problemas?

Está tendo problemas para executar a demonstração? Em caso de dúvidas entre em contato com nosso suporte.

O que você precisa

  • Computador com Windows
  • Um KIT STM32 NUCLEO conectada ao PC (via cabo USB TTL 3.3V) que atuará como raiz da rede
  • Pelo menos mais uma (até 10) KIT STM32 NUCLEO que atuarão como nós da rede
  • pacote de demonstração embeNET para KIT STM32 NUCLEO
  • STM32CubeIDE, disponível para download no site oficial da ST
  • (STM32CubeProgrammer disponível para download no site oficial da ST
  • (opcional)Qualquer terminal de porta serial, por exemplo Teraterm,  ExtraPutty , para visualizar os logs

Opcionalmente, para brincar com o serviço de demonstração MQTT-SN, você precisará de:

Opcionalmente, para interagir facilmente com o serviço UDP personalizado, você precisará

Arquitetura de demonstração

A imagem abaixo apresenta a arquitetura da rede embeNET apresentada nesta demonstração.


Arquitetura desta demonstração embeNET

O PC atua como um Border Router (Roteador de Fronteira) e se torna a porta de entrada para a rede. Um KIT STM32 NUCLEO executando o firmware Root é conectada ao PC via cabo USB TTL 3.3V e atua como uma interface de rede. Os demais KIT STM32 NUCLEO estão rodando o firmware Node . Ao executar a aplicação Border Router, ele se conecta à raiz através de conexão serial (COM no Windows) e uma nova interface de rede é registrada no sistema. Todas os outros KIT STM32 NUCLEO ingressam na rede como nós. Como o embeNET é uma rede mesh verdadeira , cada nó da rede é um roteador e pode estender a rede por meio de saltos sucessivos.

O pacote de demonstração embeNET

pacote de demonstração embeNET é distribuído como um único arquivo ZIP. Descompacte-o em um local conveniente no disco. Dentro você encontrará algumas pastas:

  • doc - contém esta documentação
  • embenet_br - contém o aplicativo Border Router para rodar no PC
  • embenet_demo_src - contém o projeto de firmware para os KIT STM32 NUCLEO
  • embenet_demo_hex - contém os arquivos de firmware já construídos para os KIT STM32 NUCLEO (formato Intel HEX), que você pode usar sem construí-los você mesmo
  • enms_visualizer - contém um aplicativo de demonstração para PC que visualiza a rede

Programando as placas sem construir (build) o firmware

Arquivos hexadecimais de firmware pré-construídos (build) estão disponíveis na pasta embenet_demo_hex . Você pode carregá-los nos fóruns usando uma ferramenta de sua escolha. Recomendamos o STM32CubeProgrammer. Aqui estão as etapas necessárias para começar.

Baixe e instale o STM32CubeProgrammer

Execute a ferramenta STM32CubeProgrammer e conecte o KIT STM32 NUCLEO ao seu PC. Em seguida, clique no botão "Conectar".

STM32CubeProgrammer: conectando à placa

Você deverá ver um log semelhante a este e um status de que a conexão foi bem-sucedida.

Registro de conexão do STM32CubeProgrammer

Em seguida, clique no botão "Open file" e selecione o arquivo de firmware que deseja carregar.

STM32CubeProgrammer: carregando o arquivo de firmware

Vá para a pasta embenet_demo_hex e selecione:

  • embenet_root_demo.hex para a placa que atua como nó raiz ( firmware raiz )
  • embenet_node_demo.hex para todas as outras placas ( firmware do nó )

Por fim, clique no botão "Download" para programar a placa.

STM32CubeProgrammer: baixando o firmware para a placa

Uma mensagem “File download complete” deve confirmar que o download do firmware foi realizado corretamente.

STM32CubeProgrammer: mensagem completa de download

Observe que, por padrão, o código não será executado até que você reinicie a placa.

Agora você deve ter o KIT STM32 NUCLEO executando o firmware Root e pelo menos uma ou mais KIT STM32 NUCLEO executando o firmware Node .

Programando a placa a partir do projeto de código-fonte CubeIDE

Baixe e instale o STM32CubeIDE .

Depois de instalado, abra-o e importe o projeto localizado na pasta embenet_demo_src .

Você deverá ver e navegar em um projeto chamado "embenet_node_demo".

STM32CubeIDE: explorador de projetos

Dentro do projeto haverá as seguintes pastas:

  • Core contém os arquivos no nível do aplicativo, incluindo main.c
  • Drivers contém arquivos de driver CMSIS e STM32 HAL
  • embenet_node_bsp contém pacote de suporte de placa para embeNET com algum código relacionado à placa
  • embenet_node_port contém a porta embeNET para o chip STM32WL
  • embenet_node_port_interface contém os arquivos de cabeçalho para a porta embeNET (interface da porta)
  • embenet_node contém a biblioteca portátil embeNET Node com cabeçalhos

O projeto possui duas configurações de build: Root e Node. Você pode alternar entre eles usando a opção de projeto "Build Configurations".

STM32CubeIDE: configurações de construção

Construindo e implantando aplicativo de demonstração embeNET no nó

Clique com o botão direito no nome do projeto e selecione "Build Configurations" -> "Set Active" -> "Node". Crie o aplicativo de demonstração usando a opção Build Project

STM32CubeIDE: Project Building

O aplicativo deve ser compilado sem erros. Conecte o KIT STM32 NUCLEO que deve funcionar como um nó. No menu Execute selecione a configuração embenet_node_demo para programar a placa. Se a configuração não estiver visível, marque-a como favorita no menu Organize Favorites...

STM32CubeIDE: atualizando a placa com firmware Node

Construindo e implantando o aplicativo de demonstração embeNET na raiz

Clique com o botão direito no nome do projeto e selecione "Build Configurations" -> "Set Active" -> "Root". Crie o aplicativo de demonstração usando a opção Build Project .

STM32CubeIDE: Project Building

O aplicativo deve ser compilado sem erros. Conecte o KIT STM32 NUCLEO que deve funcionar como raiz. No menu Execute selecione a configuração embenet_root_demo para programar a placa. Se a configuração não estiver visível, marque-a como favorita no menu Organize Favorites...

STM32CubeIDE: atualizando a placa com firmware Root

Iniciando a rede

Depois de programar as placas, você poderá ver a demonstração em ação.

Para iniciar a rede você precisa conectar a placa raiz do KIT STM32 NUCLEO ao PC. Deve ser registrado como uma porta COM. Em seguida vá até a pasta embenet_br e edite o arquivo config.json que contém a configuração do roteador de borda. O arquivo ficará semelhante a este:

{
"serial_port": "COMxx",
"interface_name": "embeNET",
"network": {
"k1": "0xc08b766277099e7d7e9c0222f168cc9e",
"panid": "0xe3be",
"prefix": "0xaaaabbbbccccdddd"
},
"join_rules": [
{
"uid": 0,
"psk": "0x46d7dc94e8ee7496ceaf54a3ab64cbeb"
}
]
}

O arquivo possui as seguintes entradas:

  • serial_port - define a interface COM para o nó raiz, no formato COMxx .
  • interface_name - define o nome da interface de rede que será criada dentro do SO para se comunicar com os nós da rede
  • panid - é o identificador de rede de 16 bits - deve ser exclusivo para cada raiz
  • k1 é uma chave de rede de 128 bits usada para autenticar a troca de informações na rede. Essa chave pode ser específica para a rede ou até mesmo para toda a organização.
  • prefixo - prefixo IPv6 de 64 bits da rede sem fio
  • join_rules - conjunto de regras de junção que definem quais nós podem ingressar na rede (veja abaixo)

‍Edite o arquivo para garantir que a entrada serial_port corresponda à porta COM registrada para a placa raiz.

Endereço IPv6 dos nós