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?
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?
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
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.
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
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
Como começar?
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 o 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 o 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:
- MQTT For Small Things (SN) escrito em Java, disponível para download no github
- MQTT Client Toolbox, disponível para download na página oficial do MQTTX
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
O 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".
Você deverá ver um log semelhante a este e um status de que a conexão foi bem-sucedida.
Em seguida, clique no botão "Open file" e selecione o arquivo de firmware que deseja carregar.
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.
Uma mensagem “File download complete” deve confirmar que o download do firmware foi realizado corretamente.
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".
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".
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
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...
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 .
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...
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:
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
Cada nó da rede, incluindo o root, possui um endereço IPv6 que consiste em duas partes:
prefix:uid
onde o prefixo é definido para a rede no arquivo config.json e o uid é o identificador IEEE EUI-64 de 64 bits, também conhecido como endereço MAC. No caso das placas Nucleo-WL55JC está impresso no chip ST-Link na parte inferior esquerda da placa, próximo ao soquete micro-USB.
Regras de adesão
Cada nó que deseja ingressar na rede embeNET precisa ser autorizado pela Autoridade de Autenticação integrada. O processo de autenticação utiliza uma chave pré-compartilhada ( psk ), que precisa ser configurada nos nós durante o comissionamento. No firmware do aplicativo de demonstração fornecido , a chave está codificada no arquivo main.c. Durante o processo de autenticação, tanto o uid quanto o psk devem corresponder ao que está definido em join_rules para permitir que o nó se junte à rede. No entanto, quando uid é definido como 0, CADA nó com psk (chave pré-compartilhada) correspondente poderá ingressar na rede. Chamamos isso de “regra zero”. É útil para testes e experiências, porém provavelmente deveria ser desabilitado na implantação real.
Executando o aplicativo Border Route (roteador de borda)
Este é um aplicativo de console que também registrará muitas informações sobre o que está acontecendo na rede e quais pacotes são recebidos dos nós. A análise deste log pode ajudar a lidar com problemas, caso eles surjam durante o processo de desenvolvimento posterior.
Conectando os nós
Assim que o aplicativo do roteador de fronteira estiver em execução, todos os nós dentro do alcance de comunicação deverão começar a ingressar na rede. Esteja ciente de que este processo pode levar alguns minutos dependendo da topologia da rede e do estado dos nós. Por exemplo: nós que ingressaram anteriormente na rede podem levar algum tempo para perceber que o roteador de borda foi reiniciado antes de tentarem ingressar novamente.
Interface de rede virtual
Durante a execução, o aplicativo roteador de borda registra uma interface de rede virtual no Windows. O nome da interface será definido de acordo com o arquivo config.json . Você pode verificar a presença desta interface executando o comando padrão do Windows:
ipconfig
Além disso, cada nó conectado pode ser acessado pelo 'ping' do ICMPv6.
Visualizando a rede
O pacote de demonstração inclui um aplicativo que visualiza a rede. É denominado enms_visualizer e é baseado no serviço ENMS executado em segundo plano na rede. Para utilizá-lo basta executar o aplicativo enquanto a rede estiver funcionando. Após cerca de um minuto, as mensagens ENMS alimentarão o aplicativo com o estado atual da rede, que será visualizado como um gráfico, abrangendo desde o nó raiz.
Uma topologia exemplar com dois nós pode ser assim:
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:
- ENMS: serviço de gerenciamento de rede embeNET que permite coletar informações sobre o funcionamento da rede a partir dos nós
- Serviço de cliente MQTT-SN que permite usar a popular arquitetura de publicação/assinatura MQTT em redes UDP e conectar-se a corretores MQTT padrão
- BOTA: Serviço Bulk-Over-The-Air que permite enviar grandes porções de dados (por exemplo - novo firmware ) entre os nós. Observe que o serviço BOTA não está disponível nesta demonstraçã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.
Serviço UDP personalizado no aplicativo de demonstração
O serviço personalizado implementado na demonstração funciona na porta UDP número 1234. Observe que este serviço funciona apenas em nós remotos - não está disponível no nó raiz . O serviço faz duas coisas:
- envia periodicamente uma mensagem de texto simples com contador para o nó roteador de fronteira
- reage a alguns comandos de texto simples que controlam os LEDs integrados - esses comandos são: led1on , led1off , led2on , led2off , led3on e led3off
Há muitas maneiras de interagir com portas UDP para testar este serviço. Uma das mais fáceis é usar um aplicativo chamado UDP - Sender/Reciever app da Microsoft Store . Depois de executar, defina o modo como Sender/Receiver . A seguir, na caixa IP remoto insira o endereço IPv6 do nó remoto com o qual deseja se comunicar. Ao usar o prefixo de rede padrão, este endereço IP terá o seguinte formato:
onde o UID será o endereço MAC do nó.
Nas caixas Porta Remota e Porta Local coloque o número da porta: 1234
Depois de clicar em Conectar, você deverá ver as mensagens de texto recebidas. Você também pode enviar alguns comandos para acender e apagar os LEDs.
Próximas etapas
Para conhecer os detalhes internos da demonstração e modificá-la ou ampliá-la consulte Internos da demonstração embeNET para placa NUCLEO-WL55JC . (STM32 NUCLEO)
Para testar a parte MQTT-SN da demonstração, vá para Usando o serviço de demonstração MQTT-SN .
Testes OK com Border Router e Node
Nenhum comentário:
Postar um comentário