Criar uma rede Thread com a placa de desenvolvimento B91 e o OpenThread

1. Introdução

O OpenThread é uma implementação de código aberto do protocolo de rede Thread®, que é um protocolo de rede mesh sem fio robusto e seguro projetado para dispositivos da Internet das Coisas (IoT). O OpenThread foi desenvolvido pela equipe do Nest do Google e está disponível sem custo financeiro para a comunidade de desenvolvedores como um projeto de código aberto.

A especificação Thread estabelece um protocolo de comunicação sem fio confiável, seguro e com eficiência energética para dispositivos com recursos limitados, comumente encontrados em casas inteligentes e edifícios comerciais. O OpenThread inclui todo o escopo da camada de rede no Thread, como IPv6, 6LoWPAN, IEEE 802.15.4 com segurança MAC, estabelecimento de link de malha e roteamento de malha.

A Telink integrou a implementação do OpenThread ao Zephyr RTOS, permitindo compatibilidade perfeita com o hardware da Telink. O código-fonte dessa integração está disponível no GitHub e também é fornecido como um kit de desenvolvimento de software (SDK).

Neste codelab, você vai programar o OpenThread em hardware real, criar e gerenciar uma rede Thread e trocar mensagens entre nós. A imagem abaixo mostra a configuração de hardware, com um roteador de borda OT (OTBR) e um dispositivo Thread no codelab.

O que você vai aprender

• Para configurar a implementação do OpenThread usando o ambiente de desenvolvimento Telink Zephyr.
• Para criar os exemplos da CLI do OpenThread (ot-cli-ftd e ot-rcp) e gravar em placas de desenvolvimento Telink B91.
• Para configurar um roteador de borda OpenThread (OTBR) usando o Docker em um Raspberry Pi 3B+ ou mais recente.
• Para criar uma rede Thread no OTBR:
• Para adicionar dispositivos à rede Thread usando a depuração fora da banda.
• Para validar a conectividade entre nós na rede Thread usando a CLI.

O que é necessário

Hardware:

• Duas placas de desenvolvimento B91.
• Um Raspberry Pi 3B+ ou mais recente com imagem do SO Raspbian.
• Uma máquina Linux com pelo menos duas portas USB.
• Um switch (ou roteador) conectado à Internet e vários cabos Ethernet.

Software:

• Ferramenta de gravação e depuração da Telink: LinuxBDT.
• Uma ferramenta de terminal de porta serial, como o PuTTY.
• Outras ferramentas, como Git e West.

2. Pré-requisitos

Conceitos do Thread e CLI do OpenThread

É recomendável fazer o codelab de simulação do OpenThread para se familiarizar com os conceitos fundamentais do Thread e a CLI do OpenThread antes deste codelab.

Máquina Linux

A máquina Linux (Ubuntu v20.04 LTS ou mais recente) atua como a máquina de build para configurar o ambiente de desenvolvimento do Telink Zephyr e atualizar todas as placas de desenvolvimento do Thread. Para realizar essas tarefas, a máquina Linux precisa de duas portas USB disponíveis e conectividade com a Internet.

Conexão e terminais de porta serial

Você pode conectar o dispositivo diretamente à porta USB da máquina Linux. Além disso, você vai precisar de uma ferramenta de terminal de porta serial para acessar os dispositivos.

Neste codelab, a ferramenta de terminal PuTTY é usada para controlar o FTD Joiner e o Raspberry Pi. Ele oferece uma visão geral do uso, mas outros softwares de terminal também podem ser usados.

Kit de desenvolvimento Telink B91

Este codelab precisa de dois conjuntos de kits de desenvolvimento B91. A foto abaixo mostra os componentes mínimos necessários em um conjunto.

Um desses kits será usado como RCP (coprocessador de rádio), enquanto o outro vai funcionar como FTD (dispositivo Thread completo). Se você ainda não tem o kit, confira mais detalhes no site oficial da Telink (em inglês). Alguns componentes a serem usados são:

Raspberry Pi 3B+ ou mais recente com imagem do SO Raspbian

Neste codelab, é necessário um Raspberry Pi 3B+ ou mais recente com a imagem do SO Raspbian Bullseye Lite ou Raspbian Bullseye com desktop. Ele está conectado à Internet via Ethernet e será configurado como o host do roteador de borda OpenThread (OTBR).

Conexão de rede

Um switch (ou roteador) conectado à Internet e vários cabos Ethernet. Eles são usados para conectar o Raspberry Pi à máquina Linux, facilitando a configuração do Raspberry Pi pelo usuário via host.

LinuxBDT

A Ferramenta de gravação e depuração (BDT, na sigla em inglês) da Telink, que se aplica a todas as séries de chips da Telink, permite apagar e atualizar o firmware OpenThread nas placas de desenvolvimento B91 da Telink. Instale a versão do Linux baseada em X86 linuxBDT na sua máquina Linux.

Outros

• Git, para configurar o ambiente de desenvolvimento do Telink Zephyr.
• West, para gerenciar o projeto Zephyr e criar binários do OpenThread.

3. Configurar o firmware

Configurar o ambiente de desenvolvimento do Telink Zephyr

Na máquina Linux, abra um terminal da CLI e execute os comandos a seguir para garantir que o APT esteja atualizado.

$ sudo apt update
$ sudo apt upgrade

Depois disso, siga as etapas abaixo.

1. Instale as dependências.

   $ wget https://apt.kitware.com/kitware-archive.sh
   $ sudo bash kitware-archive.sh
   $ sudo apt install --no-install-recommends git cmake ninja-build \
   gperf ccache dfu-util device-tree-compiler python3-dev python3-pip \
   python3-setuptools python3-tk python3-wheel xz-utils file make gcc \
   gcc-multilib g++-multilib libsdl2-dev
   

   No momento, o Zephyr exige versões mínimas de dependências principais, como CMake (3.20.0), Python3 (3.6) e Devicetree Compiler (1.4.6).

   $ cmake --version
   $ python3 --version
   $ dtc --version
   

   Verifique as versões instaladas no seu sistema antes de continuar com as próximas etapas. Se as versões não estiverem corretas, mude o espelho do APT para um espelho estável e atualizado ou atualize essas dependências manualmente.
2. Instale o west.

   $ pip3 install --user -U west
   $ echo 'export PATH=~/.local/bin:"$PATH"' >> ~/.bashrc
   $ source ~/.bashrc
   

   Verifique se ~/.local/bin está na variável de ambiente $PATH.
3. Acesse o código-fonte do projeto Zephyr.

   $ west init ~/zephyrproject
   $ cd ~/zephyrproject
   $ west update
   $ west blobs fetch hal_telink
   $ west zephyr-export
   

4. Instale dependências extras do Python para o Zephyr.

   $ pip3 install --user -r ~/zephyrproject/zephyr/scripts/requirements.txt
   

5. Configure o conjunto de ferramentas Zephyr. Faça o download do conjunto de ferramentas Zephyr (cerca de 1 a 2 GB) em um diretório local para permitir a atualização da maioria das placas.

   $ wget https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.16.1/zephyr-sdk-0.16.1_linux-x86_64.tar.xz
   $ wget -O - https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.16.1/sha256.sum | shasum --check --ignore-missing
   

   Faça o download do SDK do Zephyr e coloque-o no caminho recomendado, conforme mostrado abaixo.

   $HOME/zephyr-sdk[-x.y.z]
   $HOME/.local/zephyr-sdk[-x.y.z]
   $HOME/.local/opt/zephyr-sdk[-x.y.z]
   $HOME/bin/zephyr-sdk[-x.y.z]
   /opt/zephyr-sdk[-x.y.z]
   /usr/zephyr-sdk[-x.y.z]
   /usr/local/zephyr-sdk[-x.y.z]
   

   Em que [-x.y.z] é um texto opcional que pode ser qualquer texto, como -0.16.1. Não é possível mover o diretório depois que o SDK é instalado. Em seguida, instale a cadeia de ferramentas do Zephyr.

   $ tar xvf zephyr-sdk-0.16.1_linux-x86_64.tar.xz
   $ cd zephyr-sdk-0.16.1
   $ ./setup.sh -t riscv64-zephyr-elf -h -c
   

6. Crie o exemplo "Hello World". Primeiro, verifique se a configuração oficial do projeto Zephyr está correta usando o exemplo "Hello World" e, em seguida, configure seu projeto personalizado.

   $ cd ~/zephyrproject/zephyr
   $ west build -p auto -b tlsr9518adk80d samples/hello_world
   

   Use o comando de build do West para criar o exemplo hello_world no diretório raiz do repositório Zephyr. Encontre o firmware chamado zephyr.bin em build/zephyr directory.
7. Adicione o script de ambiente do Zephyr a ~/.bashrc. Execute os seguintes comandos:

   $ echo "source ~/zephyrproject/zephyr/zephyr-env.sh" >> ~/.bashrc
   $ source ~/.bashrc
   

8. Adicione o repositório remoto do Telink Zephyr. Faça o download do repositório Telink localmente como uma ramificação de desenvolvimento e atualize-o.

   $ cd ~/zephyrproject/zephyr
   $ git remote add telink-semi https://github.com/telink-semi/zephyr
   $ git fetch telink develop
   $ git checkout develop
   $ west update
   $ west blobs fetch hal_telink
   

Para mais informações, consulte o Zephyr Doc – Guia de primeiros passos.

Configurar o Telink LinuxBDT

Faça o download da ferramenta Telink LinuxBDT e extraia para um diretório local na sua máquina Linux, como o diretório inicial ~, permitindo gravar firmware na placa de desenvolvimento B91.

$ cd ~
$ wget http://wiki.telink-semi.cn/tools_and_sdk/Tools/BDT/LinuxBDT.tar.bz2
$ tar -vxf LinuxBDT.tar.bz2 

Conecte o Burning Board à máquina Linux pela interface USB e digite os seguintes comandos.

$ cd LinuxBDT
$ sudo ./bdt lsusb -v
Bus 002 Device 001: ID 1d6b:0003 xHCI Host Controller
Bus 001 Device 003: ID 0bda:565a Integrated_Webcam_HD
Bus 001 Device 023: ID 413c:301a Dell MS116 USB Optical Mouse
Bus 001 Device 037: ID 248a:826a Telink Web Debugger v3.6
Bus 001 Device 001: ID 1d6b:0002 xHCI Host Controller

Se a mensagem "Telink Web Debugger v3.6" aparecer, isso indica que o programador BDT se conectou à máquina Linux.

Compilação de firmware

Este codelab vai criar dois tipos de firmware OpenThread:

• ot-cli-ftd,
• e ot-rcp.

Os métodos de compilação são os seguintes:

1. Coprocessador de rádio (ot-rcp)

   $ cd ~/zephyrproject
   $ rm -rf build_ot_coprocessor
   $ west build -b tlsr9518adk80d -d build_ot_coprocessor zephyr/samples/net/openthread/coprocessor -- -DDTC_OVERLAY_FILE="usb.overlay" -DOVERLAY_CONFIG=overlay-rcp-usb-telink.conf
   

2. Dispositivo Thread completo com linha de comando interativa (ot-cli-ftd)

   $ cd ~/zephyrproject
   $ rm -rf build_ot_cli_ftd
   $ west build -b tlsr9518adk80d -d build_ot_cli_ftd zephyr/samples/net/openthread/cli -- -DOVERLAY_CONFIG=overlay-telink-fixed-mac.conf -DCONFIG_OPENTHREAD_FTD=y
   

Flash do firmware

Conecte uma placa de desenvolvimento B91 à placa de gravação usando um cabo USB, conforme ilustrado na figura abaixo.

Na linha de comando, execute os comandos a seguir para fazer a gravação do firmware. Use como exemplo a atualização do firmware ot-cli-ftd.

$ cd ~/zephyrproject/build_ot_cli_ftd/zephyr
$ cp zephyr.bin ~/LinuxBDT/bin/ot-cli-ftd.bin
$ cd ~/LinuxBDT
$ sudo ./bdt 9518 ac
 Activate OK!
$ sudo ./bdt 9518 wf 0 -i bin/ot-cli-ftd.bin
 EraseSectorsize...
 Total Time: 2181 ms
 Flash writing...
 [100%][-] [##################################################]
 File Download to Flash at address 0x000000: 491700 bytes
 Total Time: 30087 ms

O método de flash para ot-rcp é basicamente o mesmo que para ot-cli-ftd. No entanto, há diferenças nos caminhos e nomes do firmware.

Depois de fazer o flash, marque as duas placas de desenvolvimento B91 para diferenciá-las. Rotule a placa gravada com ot-cli-ftd como "FTD Joiner" e a placa gravada com ot-rcp como "RCP".

4. Configurar um console serial para o dispositivo de junção do FTD

Como mostrado na imagem, conecte o FTD Joiner diretamente à porta USB da máquina Linux.

Depois de conectar o dispositivo FTD Joiner à máquina Linux, abra o PuTTY. Em seguida, crie um novo terminal, defina as informações da porta serial e abra a porta serial.

A referência da linha de comando do OpenThread está aqui: Referência da CLI do OpenThread. Não se esqueça de prefixar todos os comandos com ot.

Exemplos:

> ot state
disabled
Done
> ot channel
11
Done
>

5. Configurar o Raspberry Pi como um roteador de borda OpenThread

Um roteador de borda OpenThread é um dispositivo que consiste em duas partes principais:

• O Raspberry Pi contém todos os serviços e firmware necessários para atuar como um roteador de borda (BR, na sigla em inglês).
• O RCP é responsável pela comunicação do Thread.

Coprocessador de rádio (RCP)

Para atualizar o firmware do ot-rcp, siga as mesmas etapas do processo de atualização do firmware do ot-cli-ftd. Conecte a placa de desenvolvimento B91 a uma porta USB no Raspberry Pi, conforme mostrado na figura abaixo.

Raspberry Pi

1. Verifique se a imagem do SO Raspbian Bullseye Lite ou Raspbian Bullseye com área de trabalho foi gravada corretamente no cartão SD.
2. Você pode usar o SSH no Raspberry Pi ou trabalhar diretamente com o Raspbian Desktop. Este codelab usa SSH.
3. Antes de instalar o OTBR Docker na próxima etapa, atualize o repositório local e o gerenciador de pacotes.

   $ sudo apt-get update
   $ sudp apt-get upgrade
   

Instalar o Docker

Se você apenas atualizou o repositório local e o gerenciador de pacotes APT na etapa anterior, reinicie o Raspberry Pi e abra uma janela de terminal SSH.

1. Instale o Docker:

   $ curl -sSL https://get.docker.com | sh
   

2. Coloque a conta atual em um grupo do Docker para conceder a permissão e evitar que sudo precise ser adicionado antes de cada comando.

   $ sudo usermod -aG docker $USER
   

   É necessário reiniciar o Raspberry Pi para que a mudança entre em vigor.
3. Se o Docker não tiver sido iniciado, faça isso:

   $ sudo dockerd
   

4. Os scripts de firewall do OTBR geram regras dentro do contêiner do Docker. Antes disso, execute modprobe para carregar o módulo do kernel do iptables.

   $ sudo modprobe ip6table_filter
   

Configurar e executar o Docker

Este codelab extrai diretamente a imagem Docker do OTBR do Docker Hub do OpenThread. Essa imagem foi testada e verificada pela equipe do OpenThread.

1. Extraia a imagem mais recente:

   $ docker pull openthread/otbr:latest
   

2. Confira a lista de imagens no contêiner do Docker:

   $ docker images
   REPOSITORY        TAG       IMAGE ID       CREATED      SIZE
   openthread/otbr   latest    db081f4de15f   6 days ago   766MB
   

3. Determine o nome da porta serial do dispositivo RCP verificando /dev. ttyACM0 indica que o RCP está conectado corretamente.

   $ ls /dev/tty*
   ...
   /dev/ttyACM0
   ... 
   

4. Execute o Docker do OTBR pela primeira vez e faça referência à porta serial do RCP (ttyACM0). Se quiser continuar usando esse Docker do OTBR, use o comando docker start otbr.

   $ docker run --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 openthread/otbr --radio-url spinel+hdlc+uart:///dev/ttyACM0
   

5. Abra uma nova janela de terminal SSH para testar a conectividade entre o Raspberry Pi e o RCP.

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

Comandos opcionais do Docker:

• Receba informações sobre o contêiner do Docker em execução:

  $ docker ps -aq
  

• Interrompa o Docker do OTBR:

  $ docker stop otbr
  

• Remova o Docker do OTBR:

  $ docker rm otbr
  

• Recarregue o Docker do OTBR:

  $ docker restart otbr
  

Neste ponto, um dispositivo FTD Joiner e um OTBR estão prontos, e você pode seguir para a próxima etapa para criar a rede Thread.

6. Criar uma rede Thread

Criar uma rede Thread no RCP

Usamos o shell ot-ctl no OTBR para estabelecer uma rede Thread. Se você saiu do shell na última seção, insira o seguinte comando para iniciá-lo novamente no terminal SSH:

$ docker exec -ti otbr sh -c "sudo ot-ctl"

Em seguida, insira os comandos na ordem especificada na tabela e verifique se cada etapa alcança o resultado esperado antes de prosseguir para a próxima.

A chave de rede gerada aleatoriamente pelo OTBR durante a criação da rede será usada quando os dispositivos ot-cli-ftd entrarem nessa rede Thread.

Adicionar o FTD Joiner à Thread usando o provisionamento fora da banda

O provisionamento fora da banda se refere à transmissão de credenciais de rede para dispositivos que aguardam entrar na rede por métodos não sem fio (por exemplo, inserindo manualmente na CLI do OpenThread). Insira os comandos a seguir na ordem no console serial do FTD Joiner.

Topologia

Insira comandos como ipaddr, child table e router table no terminal SSH para receber respostas como os snippets de código a seguir.

> ipaddr rloc
fd8c:60bc:a98:c7ba:0:ff:fe00:b000
Done
> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|D|N|Ver|CSL|QMsgCnt|Suprvsn| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+---+---+-------+-------+------------------+
|   1 | 0xb001 |        240 |         23 |     3 |   51 |1|1|1|  3| 0 |     0 |   129 | 82bc12fbe783468e |

Done
> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     | Link |
+----+--------+----------+-----------+-------+--------+-----+------------------+------+
| 44 | 0xb000 |       63 |         0 |     0 |      0 |   0 | 7ae354109d611f7e |    0 |

Done
...
> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|D|N|Ver|CSL|QMsgCnt|Suprvsn| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+---+---+-------+-------+------------------+

Done
> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     | Link |
+----+--------+----------+-----------+-------+--------+-----+------------------+------+
| 33 | 0x8400 |       63 |         0 |     3 |      3 |  13 | e61487c1cda940a6 |    1 |
| 44 | 0xb000 |       63 |         0 |     0 |      0 |   0 | 7ae354109d611f7e |    0 |

Done

O RLOC16 do OTBR é 0xb000 e o RLOC16 do FTD Joiner inicialmente é 0xb001. Em seguida, o RLOC16 do FTD Joiner se torna 0x8400 depois de receber o ID do roteador. É possível ver que o FTD Joiner foi atualizado de um filho para um roteador.

A rede Thread atual contém dois nós, e a topologia é mostrada na figura abaixo.

7. Comunicação entre dispositivos Thread

Comunicação ICMPv6

Usamos o comando ping para verificar se os dispositivos Thread na mesma rede podem se comunicar entre si. Primeiro, use o comando ipaddr para receber o RLOC do dispositivo.

> ipaddr
fd8c:60bc:a98:c7ba:0:ff:fe00:fc11
fdbd:7274:649c:1:1d19:9613:f705:a5af
fd8c:60bc:a98:c7ba:0:ff:fe00:fc10
fd8c:60bc:a98:c7ba:0:ff:fe00:fc38
fd8c:60bc:a98:c7ba:0:ff:fe00:fc00
fd8c:60bc:a98:c7ba:0:ff:fe00:b000       # Routing Locator (RLOC)
fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6
fe80:0:0:0:78e3:5410:9d61:1f7e
Done

Insira o comando a seguir no console serial do FTD Joiner para executar a operação de ping.

> ot ping fd8c:60bc:a98:c7ba:0:ff:fe00:b000
16 bytes from fd8c:60bc:a98:c7ba:0:ff:fe00:b000: icmp_seq=1 hlim=64 time=19ms
1 packets transmitted, 1 packets received. Packet loss = 0.0%. Round-trip min/avg/max = 19/19.0/19 ms.
Done

A resposta de saída da porta serial indica que o lado do OTBR recebeu a solicitação de ping e que o FTD Joiner recebeu a resposta de ping retornada pelo OTBR. A comunicação entre os dois dispositivos foi concluída.

Comunicação UDP

Os serviços de aplicativo fornecidos pelo OpenThread também incluem UDP. É possível usar a API UDP para transmitir informações entre nós na rede Thread ou para redes externas pelo roteador de borda. A introdução detalhada da API UDP do OpenThread está no Exemplo de CLI do OpenThread - UDP. Este codelab vai usar algumas das APIs para transmitir informações entre o OTBR e o FTD Joiner.

Primeiro, receba o EID local da malha do OTBR. Esse endereço também é um dos endereços IPv6 do dispositivo Thread e pode ser usado para acessar dispositivos Thread na mesma partição de rede Thread.

> ipaddr mleid
fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6
Done

Insira os seguintes comandos no terminal SSH para ativar o UDP do OTBR e vincular a porta 1022 do dispositivo.

> udp open
Done
> udp bind :: 1022
Done

Insira os comandos a seguir no console serial e ative o UDP do FTD Joiner. Vincule a porta 1022 do dispositivo e envie uma mensagem hello de 5 bytes para o OTBR.

> ot udp open 
Done
> ot udp bind :: 1022
Done
> ot udp send fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6 1022 hello
Done

O terminal SSH gera as seguintes informações. O OTBR recebe a mensagem hello do FTD Joiner, o que significa que a comunicação UDP foi bem-sucedida.

> 5 bytes from fd8c:60bc:a98:c7ba:9386:63cf:19d7:5a61 1022 hello

8. Parabéns

Você criou uma rede Thread simples e verificou a comunicação nela.

Agora você sabe:

• Como criar e usar o ambiente de desenvolvimento Telink Zephyr.
• Como criar os binários ot-cli-ftd e ot-rcp e gravar em placas de desenvolvimento Telink B91.
• Como configurar um Raspberry Pi 3B+ ou uma versão mais recente como um roteador de borda OpenThread (OTBR) usando o Docker.
• Como criar uma rede Thread no OTBR.
• Como adicionar dispositivos à rede Thread usando o provisionamento fora da banda.
• Como verificar a conectividade entre nós na rede Thread.

Leitura adicional

Acesse openthread.io e GitHub (links em inglês) para saber mais sobre vários recursos do OpenThread, incluindo:

• Plataformas compatíveis: descubra todas as plataformas que oferecem suporte ao OpenThread.
• Criar o OpenThread: mais detalhes sobre como criar e configurar o OpenThread.
• Fundamentos de linhas de execução: aborda todos os conceitos de linhas de execução apresentados neste codelab.

Documentos de referência:

• Referência da CLI do OpenThread
• Referência da CLI UDP do OpenThread
• Referência da API UDP do OpenThread