Criar uma rede Thread com placas Silicon Labs EFR32 e OpenThread usando o Simplicity Studio v5

1. Introdução

26b7f4f6b3ea0700.png

O OpenThread (OT) do Google é uma implementação de código aberto do Thread. O Google lançou o OpenThread para disponibilizar de maneira mais ampla aos desenvolvedores a tecnologia de rede usada nos produtos Google Nest para acelerar o desenvolvimento de produtos para as casas e edifícios comerciais conectados. Com uma camada de abstração de plataforma estreita e um pequeno consumo de memória, o OpenThread é altamente portátil. Ele é compatível com designs de system-on-chip (SoC) e de coprocessador de rede (NCP).

A Especificação de thread define um protocolo de comunicação dispositivo a dispositivo sem fio confiável, seguro e de baixo consumo de energia para aplicativos residenciais e comerciais.

A Silicon Labs aprimorou o OpenThread para funcionar com o hardware Silicon Labs. Esse código-fonte está disponível no GitHub e também como um kit de desenvolvimento de software (SDK, na sigla em inglês) instalado com o Simplicity Studio 5 (SSv5). O SDK inclui um instantâneo totalmente testado do código-fonte do GitHub. Ele é compatível com uma variedade maior de hardware do que a versão do GitHub e inclui documentação e aplicativos de exemplo não disponíveis no GitHub.

Este guia descreve como começar a desenvolver aplicativos do OpenThread usando o SDK do Silicon Labs OpenThread e o Simplicity Studio 5. A imagem abaixo mostra as placas (BRDs) e o hardware configurado com um roteador de borda OT (OTBR, na sigla em inglês) e dois dispositivos Thread usados no codelab.

Configuração do hardware EFR32MG

O que você vai aprender

  • Como criar um projeto do OpenThread usando o ambiente de desenvolvimento integrado do Silicon Labs Simplicity Studio.
  • Como criar e atualizar binários da CLI do OpenThread em placas de rádio da Silicon Labs.
  • Como configurar um Raspberry Pi 3B+ ou superior como um roteador de borda do OpenThread (OTBR) usando o Docker.
  • Como criar uma rede Thread no OTBR.
  • Comissionamento fora de banda de dispositivos em uma rede Thread.
  • Como verificar a comunicação de linhas de execução entre os nós usando o comando ping.

2. Pré-requisitos

Hardware:

  1. Três placas de rádio EFR32MGxx: qualquer combinação desses dispositivos pode ser usada. Este codelab usa um BRD4166A como o RCP e dois BRD4168As como dispositivos de linha de execução completa.
    • EFR32MG12 (BRD4161A, BRD4166A, BRD4170A, BRD4304A)
    • EFR32MG13 (BRD4168A)
    • EFR32MG21 (BRD4180A, BRD4180B)
    Se você estiver começando do zero, poderá comprar um dos kits de linha de execução EFR32 com as placas listadas acima.
  2. BRD4001A: placas principais sem fio (WSTK, na sigla em inglês) para hospedar as placas de rádio. Com exceção da BRD4166A, todas as placas de rádio precisam de uma placa principal inicial. Cabos mini USB para conectar e fornecer energia às placas principais ou ao cabo micro USB para BRD4166A.

WSTK AEM (em inglês)

  1. Um Raspberry Pi 3B+ ou superior com a imagem do Raspbian Stretch Lite OS ou o Raspbian Stretch with Desktop conectado à Internet por Ethernet. Configuramos isso como um roteador de borda OT.
  2. Um sistema host do Windows/Linux/Mac com pelo menos duas portas USB e uma conexão com a Internet. Verifique os requisitos de hardware e SO em SSv5.
  3. Pelo menos um cabo Ethernet para conectar o Raspberry Pi à Internet. Os WSTKs também são compatíveis com a depuração e a atualização flash por IP. Como opção, cabos Ethernet adicionais podem ser usados para conectar o WSTK ao seu sistema host por meio de um switch Ethernet.

Software:

  • O Simplicity Studio v5 instalado e atualizado no sistema host do Windows/Linux/Mac com
    • Conjunto de ferramentas do ARM ARM
    • Gecko SDK Suite 3.2.0 ou posterior e Silicon Labs OpenThread SDK.

3. Configuração de hardware

Este codelab foi criado usando

  1. EBR32MG12 BRD4166A Thunderboard Sense 2, conforme mostrado à esquerda.
  2. Dois EFR32MG13 BRD4168A, conforme mostrado à direita.
  3. Simplicity Studio v5 instalado no macOS Catalina 10.15.7 com
    1. SDK do Gecko 3.2.0
    2. GNU ARM v7.2.1

BRD 4.168

Conecte cada placa principal sem fio do Kit do iniciante no computador host via USB, como mostra a imagem abaixo. Essas conexões permitirão a programação e a análise de rede do RCP e dos dispositivos finais. Primeiro, usaremos o computador host para programar o BRD4166A com o firmware ot-rcp e, por fim, conectá-lo ao Raspberry Pi. Opcionalmente, dispositivos finais podem ser conectados ao computador host por meio de um comutador Ethernet comum. Os kits de primeiros passos também são compatíveis com programação e análise de rede por IPv4.

Conexões

4. Configuração do firmware

Há duas maneiras de começar. Ambas as opções permitem que você atualize manualmente os firmwares necessários para este codelab.

  1. Projetos: (recomendado) criar, criar e atualizar um aplicativo de amostra. Esta opção permite personalizar o aplicativo no projeto.
  2. Demonstrações: (opcional) atualize as demonstrações pré-criadas diretamente na placa de rádio para qualquer aplicativo de exemplo. Os usuários são incentivados a testar o firmware de demonstrações configurado como um exercício opcional. Consulte a seção "Configuração opcional do firmware: demonstrações" no final deste codelab para mais detalhes.

Usaremos o método com base em projeto para este codelab.

Criar projetos usando exemplos

Criaremos dois projetos. O projeto ot-rcp para o BRD4166A e o projeto ot-cli-ftd para os dois BRD4168A. Siga estas etapas e selecione o aplicativo de amostra apropriado para sua placa.

  1. Abra o menu Arquivo do Studio e selecione New > Silicon Labs Project Wizard. A caixa de diálogo "Target, SDK, and Toolchain Selection" será aberta. Não altere o conjunto de ferramentas padrão do ambiente de desenvolvimento integrado / Simplicity compatível com o OpenThread. Clique em "Avançar".
    • Placas de destino: mostra a placa de rádio selecionada (BRD4168A) junto com a placa principal (BRD4001A)
    • Dispositivo de destino: esse campo mostra o chip do microcontrolador (MCU) a bordo. O BRD4168A tem uma placa MCU EFR32MG13.
    • SDK: aqui você pode selecionar a versão do SDK do OT com a qual está trabalhando. As informações do Suite incluem a tag do SDK e a versão do Silicon Labs do OpenThread, por exemplo, Platform 4.0.1.0 e OpenThread 2.0.1.0 (GitHub-55af6ce2c).
    • IDE/ Toolchain: a cadeia de ferramentas que será usada para compilar o projeto OT. Usamos o GNU ARM.

Novo assistente de projeto

  1. A caixa de diálogo Exemplo de seleção de projeto é aberta. Você verá uma lista de projetos de exemplo. Use os filtros de palavra-chave e tipo de tecnologia Thread para procurar um exemplo específico. Anote o número da versão do Gecko SDK Suite. Você precisará dessa tag de versão ao configurar o Raspberry Pi como um roteador de borda. Selecione ot-cli-ftd e clique em PRÓXIMA.

Nova etapa 2 do assistente de projeto

  1. A caixa de diálogo "Configuração do projeto" é aberta. Aqui você pode renomear seu projeto, alterar o local padrão do arquivo do projeto e determinar se os links serão ou serão copiados. Os arquivos do projeto vinculados apontam para o SDK, e todas as modificações feitas são feitas nele e usadas em projetos futuros. A cópia de fontes do projeto permite editar uma cópia local do projeto para que os arquivos do SDK permaneçam intactos. "Vincular o SDK e copiar as fontes do projeto" é a opção padrão e a recomendada. Clique em CONCLUIR.

Etapa 3 do assistente de novo projeto

  1. A Perspective IDE do Simplicity é aberta com o Project Configurator aberto na guia VISÃO GERAL.

Visão geral do projeto

Para configurar o projeto, acesse a guia Componentes do software e instale e desinstale os componentes instalados. Os componentes instalados são verificados. Clique em Componentes instalados para ver uma lista filtrada dos componentes instalados pelo aplicativo de exemplo. Todas as alterações feitas são salvas automaticamente, e os arquivos de projeto são gerados automaticamente. O progresso é mostrado no canto inferior direito da perspectiva do Simplicity IDE.

Componentes de software

Para esta demonstração, usaremos a configuração padrão dos aplicativos de amostra. Repita as etapas acima para criar o projeto ot-rcp para a outra placa.

Criar e atualizar projetos

Crie e atualize projetos ot-rcp e ot-cli-ftd.

  1. Depois de configurar o projeto, clique em Build control (ícone de martelo) na barra de ferramentas superior. Outra opção é clicar com o botão direito do mouse no projeto e em "Criar projeto".

Botão "Build project"

  1. O progresso é exibido no Console e uma barra de progresso no canto inferior direito. Todos os erros ou avisos relacionados ao projeto também aparecerão nessa janela de saída.

Janela de saída de build do projeto

  1. As imagens binárias são geradas após a criação de um projeto. É possível atualizar a imagem binária na visualização Project Explorer. Localize o arquivo .bin, .hex ou .s37 no subdiretório do compilador. Clique com o botão direito do mouse no arquivo e selecione Flash para dispositivo. Se você tiver mais de um dispositivo conectado, selecione um dispositivo para programar, clique em OK. O Programador Flash é aberto com o caminho do arquivo preenchido. Clique em PROGRAMAR.

Flash

5. Resumo da configuração do firmware

Neste ponto, você deve ter criado, compilado e atualizado com flash o firmware apropriado nas placas de rádio. Depois que a ot-rcp for atualizada para BRD4166A, desconecte-a do sistema host e conecte esta placa ao Raspberry Pi.

Depois de concluir esta seção, a configuração do hardware de rede Thread vai ficar assim.

Configuração do EFR32MG

6. Configurar o console serial para dispositivos ot-cli-ftd

Para iniciar a interface do Console, na perspectiva do Simplicity IDE, clique com o botão direito do mouse no dispositivo J-Link na janela de visualização / adaptadores de dispositivos. Escolha Launch Console. Para receber uma solicitação no Console, escolha a guia Serial 1 e pressione Enter. Verifique o estado do nó FTD.

Visualização do console do FTD Studio

Observe que ainda não temos um console para ot-rcp. Na próxima etapa, configuraremos o Raspberry Pi como um roteador de borda OT e configuraremos o console para ot-rcp.

7. Configurar o Raspberry Pi como um roteador de borda

O Silicon Labs recomenda a implantação do contêiner do Docker da empresa com o OTBR. A execução do OTBR em um contêiner permite a criação de artefatos facilmente implantáveis e a rápida prototipagem e teste de desenvolvimento.

As imagens OTBR do Silicon Labs são hospedadas no siliconlabsinc DockerHub com tags. Cada tag corresponde a uma versão do GSDK:

https://hub.docker.com/r/siliconlabsinc/openthread-border-router/tags (link em inglês)

Os contêineres do Docker precisam ser usados com RCPs criados com o Simplicity Studio 5 em uma determinada versão. Certifique-se de fazer a correspondência entre uma versão de tag de contêiner e a versão do GSDK com que você está testando. Por exemplo, se a versão do GDSK era Gecko SDK Suite v4.0.1 (140) quando você selecionou ot-rcp na janela Exemplo de seleção de projeto, use a imagem siliconlabsinc/openthread-border-router:gsdk-4.0.1.

Versão do GSDK

Configuração do Raspberry Pi

  1. No cartão SD, atualize a imagem do Raspbian Stretch Lite OS ou Raspbian Stretch with Desktop.
  2. Você pode usar o SSH no Raspberry Pi ou optar por trabalhar diretamente com o Raspbian Desktop. Abra um terminal.
  3. Atualize seus repositórios locais e o gerenciador de pacotes (apt-get update e apt-get upgrade antes de instalar o Docker).

Instalar imagem do Docker

  1. Instale o Docker com o comando a seguir no seu RPi.
    curl -sSL https://get.docker.com | sh
  2. Quando terminar, modifique as configurações de usuário do Docker para não exigir sudo antes de cada comando. É necessário reinicializar.
    sudo usermod -aG docker $USER
  3. Execute os comandos a seguir para instalar os contêineres. É possível ter apenas um contêiner do roteador de borda em execução por vez com seu RCP. Além disso, verifique se sua versão do GSDK do Simplicity Studio corresponde à sua imagem do Docker correta. Por exemplo, gsdk-4.0.1:
    docker pull siliconlabsinc/openthread-border-router:gsdk-4.0.1

Configurar e executar o docker

  1. Você precisa configurar a porta TTY que quer usar para o OTBR para conectar seu RCP na inicialização. Procure a porta TTY do dispositivo RCP. A maneira mais fácil de fazer isso é procurar uma entrada /tty/dev... depois que o RCP estiver conectado. Geralmente, precisa ser /dev/ttyUSB0 ou /dev/ttyACM0.
  2. Execute a instalação do Docker com o comando a seguir. Substitua o nome da imagem do Docker pela versão do GSDK correspondente. Por exemplo, gsdk-4.0.1:
    docker run -d --name "otbr" \
 --sysctl "net.ipv6.conf.all.disable_ipv6=0 net.ipv4.conf.all.forwarding=1 net.ipv6.conf.all.forwarding=1" \
 -p 8080:80 --dns=127.0.0.1 -it \
 --volume /dev/ttyACM0:/dev/ttyACM0 \
 --privileged siliconlabsinc/openthread-border-router:gsdk-4.0.1 \
 --radio-url spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=460800 \
 --backbone-interface eth0
    • -d garante que o contêiner seja executado no modo independente.
    • É possível ver os registros em execução do contêiner a qualquer momento usando o comando docker logs.
    • --name permanece até que o contêiner do Docker seja fechado (ou removido) corretamente.
    • A porta 8080 indica a porta do servidor da Web que hospeda a página de gerenciamento do roteador de borda.
    • O ?uart-baudrate=460800 é necessário nas opções do URL de rádio para contornar problemas de fragmentação / remontagem no UART, com operações caras, como DTLS com pacotes IPv6 longos.

Interagir com o nó RCP

Quando o docker estiver em execução, você pode se comunicar com o nó do RCP por meio de um shell interativo usando este comando. Verifique o estado do nó RCP.

$ docker exec -ti otbr sh -c "sudo ot-ctl"
> state 
disabled
Done

É possível conseguir uma lista de códigos de contêiner em execução

$ docker ps -aq

É possível verificar a janela que executa o contêiner do Docker OTBR para executar a saída do registro do roteador de borda ou seguir o registro do contêiner da seguinte maneira:

$ docker logs [container-id] -f

Opcionalmente, você pode parar, remover ou eliminar sua imagem se o contêiner do docker for carregado corretamente.

$ docker stop otbr

$ docker rm otbr

$ docker kill otbr

Opcional: para sair do shell, use CNTL + C.

Neste momento, você terá três consoles.

  1. Dois consoles ot-cli-ftd no Simplicity Studio configurados como dispositivos de linha de execução completa.
  2. Um shell interativo ot-ctl no Raspberry Pi, configurado como um roteador de borda OT.

Agora estamos prontos para formar uma rede Thread.

8. Criar uma rede Thread

Configurar RCP

Para criar a rede, começamos com o shell ot-ctl no OTBR, que é usado para se comunicar com o nó RCP. Digite os seguintes comandos na ordem mostrada abaixo:

Índice

Comando

Descrição do comando

Resposta esperada

1

dataset init new

Crie uma nova configuração de rede.

Concluído

2

dataset commit active

Confirmar novo conjunto de dados no conjunto de dados operacional ativo.

Concluído

3

ifconfig up

Ativar interface do Thread.

Concluído

4

thread start

Ativar e anexar operação do protocolo Thread.

Concluído

Aguarde 10 segundos para que a interface da linha de execução fique ativa.

5

state

Verifique o estado do dispositivo. Precisa ser o líder.
Outros estados possíveis: off-line, desativado, desanexado,
filho, roteador ou líder

Líder
Concluído

6

dataset

Veja a configuração de rede.
Seus valores serão diferentes deste codelab.
Anote o canal, a chave da rede, o
nome da rede e o ID do PAN.

Carimbo de data/hora ativo: 1
Canal: 20
Máscara de canal: 0x07fff800
Código PAN externo: 39ba71f7fc367160
Prefixo local da rede mesh: fd5c:c6b:3a17:40b9::/64
Chave de rede: 81ae2c2c1c17380555000000000000000000000000 # #35000000""




Usaremos o número do canal e a chave da rede no ot-cli-ftd para unir os dois FTDs a essa rede.

Configurar e adicionar o FTD à nossa rede Thread (método fora de banda)

Com o método fora de banda, conhecemos todas as informações de segurança e adicionamos o nó manualmente. Nos consoles do Simplicity, adicione os dois FTDs à nossa rede usando os seguintes comandos na ordem mostrada abaixo.

Índice

Comando

Descrição do comando

Resposta esperada

1

dataset channel 20

Define o canal usado pelo OTBR.

Concluído

2

dataset networkkey 81ae2c2c17368d585dee71eaa8cf1e90

Somente a chave de rede é necessária para que um dispositivo seja conectado a uma rede Thread.

Concluído

3

dataset commit active

Confirmar novo conjunto de dados no conjunto de dados operacional ativo.

Concluído

4

ifconfig up

Ativar interface do Thread.

Concluído

5

thread start

Ativar e anexar operação do protocolo Thread.

Concluído

Aguarde 20 segundos enquanto o dispositivo é conectado e se configura.

6

state

Ver configuração da rede.

criança
Concluído

Comunicação entre dispositivos Thread

Usaremos o comando ping para verificar se os dispositivos podem se comunicar entre si. Para usar o comando ping, precisamos dos endereços IPv6 dos dispositivos. É possível encontrá-las usando o comando ipaddr.

> ipaddr
fd5c:c6b:3a17:40b9:0:ff:fe00:fc00		# Leader Anycast Locator (ALOC)
fd5c:c6b:3a17:40b9:0:ff:fe00:1800		# Routing Locator (RLOC)
fd5c:c6b:3a17:40b9:84e2:bae8:bd5b:fa03		# Mesh-Local EID (ML-EID)
fe80:0:0:0:c449:ca4a:101f:5d16			# Link-Local Address (LLA)

Nos dois FTDs, dê um ping no OTBR usando o endereço RLOC do OTBR.

> ping fd5c:c6b:3a17:40b9:0:ff:fe00:1800
Done
> 
> 16 bytes from fd5c:c6b:3a17:40b9:0:ff:fe00:1800: icmp_seq=3 hlim=64 time=30ms
16 bytes from fd5c:c6b:3a17:40b9:0:ff:fe00:1800: icmp_seq=3 hlim=64 time=52ms

A resposta indica a carga útil recebida e que a comunicação é bem-sucedida. Repita o processo para dar um ping nos FTDs a partir do OTBR.

9. Parabéns

Você criou uma rede Thread.

Agora você sabe:

  • Como criar um projeto do OpenThread usando o ambiente de desenvolvimento integrado do Silicon Labs Simplicity Studio.
  • Como criar e atualizar binários da CLI do OpenThread em placas de rádio da Silicon Labs.
  • Como configurar um Raspberry Pi 3B+ ou superior como um roteador de borda do OpenThread (OTBR) usando o Docker.
  • Como criar uma rede Thread no OTBR.
  • Comissionamento fora de banda de dispositivos em uma rede Thread.
  • Como verificar a comunicação de linhas de execução entre os nós usando o comando ping.

Leia mais

Acesse openthread.io e GitHub para conferir uma variedade de recursos do OpenThread, incluindo:

10. Configuração de firmware opcional: demonstrações

As demonstrações são imagens de firmware pré-criadas prontas para download em um dispositivo compatível. A maneira mais rápida de descobrir se uma demonstração está disponível para sua parte no Simplicity Studio é clicar na parte que aparece na visualização "Adaptadores de depuração" e navegar até a guia "EXEMPLOS DE PROJETOS E DEMONSTRAÇÕES" na perspectiva do iniciador. Desative o filtro "Projetos de exemplo" e marque a caixa de seleção Thread em "Tipo de tecnologia".

Demonstrações do Studio

As imagens pré-compiladas do aplicativo de demonstração fornecidas com o SDK do OpenThread são compatíveis com as seguintes placas:

  1. BRD 4.161
  2. BRD 4.166
  3. BRD 4.168
  4. BRD 4.180
  5. BRD 4.304

Esta lista pode ser atualizada nas próximas versões do SDK para incluir mais placas de rádio. Consulte as notas de versão do SDK do Silicon Labs OpenThread em Documentação para obter uma lista completa de partes compatíveis.

Atualize as seguintes demonstrações nas respectivas placas. Para atualizar, selecione a placa em "Adaptadores de depuração" à esquerda e clique em "EXECUTAR" nos aplicativos de amostra correspondentes. Uma janela pop-up mostrará o progresso do flash.

  1. BRD4166A: ot-rcp — este dispositivo funcionará como um processador de rádio colaborativa para o roteador de borda de OT. Usaremos este dispositivo para criar uma rede Thread e integrar os outros dois dispositivos na rede Thread. Por ser um roteador de borda, este dispositivo também funciona como um gateway para os dispositivos na rede Thread se comunicarem pela Internet.
  2. Dois BRD4168A: ot-cli-ftd - esses dois dispositivos funcionarão como dispositivos de linha de execução completa. Eles participarão da rede Thread criada pelo OTBR.