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 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 do Thread estabelece um protocolo de comunicação sem fio confiável, seguro e econômico para dispositivos com recursos limitados comumente encontrados em casas inteligentes e edifícios comerciais. O OpenThread inclui o escopo completo da camada de rede no Thread, como IPv6, 6LoWPAN, IEEE 802.15.4 com segurança MAC, estabelecimento de link de rede mesh e roteamento de malha.

A Telink integrou a implementação do OpenThread ao Zephyr RTOS, permitindo compatibilidade total com o hardware do Telink. O código-fonte dessa integração está disponível no GitHub (link em inglês) 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 do hardware, com um roteador de borda OT (OTBR, na sigla em inglês) e um dispositivo Thread no codelab.

O que você vai aprender

• Para configurar a implementação do OpenThread usando o ambiente de desenvolvimento do Telink Zephyr.
• Para criar os exemplos da CLI do OpenThread (ot-cli-ftd e ot-rcp) e instalá-los nas placas de desenvolvimento Telink B91.
• Configurar um roteador de borda do 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 depuração fora de banda.
• Para validar a conectividade entre os nós na rede Thread usando a CLI.

Pré-requisitos

Hardware:

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

Software:

• Ferramenta de Gravação e Depuração Telink —— LinuxBDT.
• Ferramenta do terminal de porta serial, como PuTTY.
• Outras ferramentas, como Git e West.

2. Pré-requisitos

Conceitos do Thread e CLI do OpenThread

Antes deste codelab, pode ser útil conferir o codelab de simulação do OpenThread para se familiarizar com os conceitos fundamentais do Thread e com a CLI do OpenThread.

Máquina Linux

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

Terminais e conexão de porta serial

É possível conectar o dispositivo diretamente na porta USB da máquina Linux. Além disso, você 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 também é possível usar outros softwares de terminal.

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 coprocessador de rádio (RCP, na sigla em inglês), enquanto o outro funcionará como um FTD (Dispositivo de Thread completo). Se você ainda não tem o kit, veja mais detalhes no site oficial da Telink. Estes são alguns componentes:

Raspberry Pi 3B ou mais recente com imagem do Raspbian OS

Neste codelab, é necessário ter um Raspberry Pi 3B ou mais recente com a imagem do SO Raspberry Bullseye Lite ou a Raspbian Bullseye com um computador. Ele está conectado à Internet via Ethernet e será configurado como o host do roteador de borda do 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 usuário do Raspberry Pi pelo host.

LinuxBDT

A ferramenta Burning and Debugger (BDT) da Telink, que se aplica a todas as séries Telink Chip, permite apagar e atualizar o firmware do OpenThread nas placas de desenvolvimento Telink B91. Instale a versão do Linux baseada em X86 linuxBDT na 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, prossiga para as próximas etapas.

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 das 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 prosseguir para as próximas etapas. Se as versões não estiverem corretas, troque o espelho APT por um espelho estável e atualizado ou atualize manualmente essas dependências.
2. Instalar o oeste.

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

   Verifique se ~/.local/bin está na sua 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 outras dependências do Python para o Zephyr.

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

5. Configure o conjunto de ferramentas do Zephyr. Faça o download do conjunto de ferramentas Zephyr (cerca de 1 a 2 GB) para um diretório local para que você possa atualizar a 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 após a instalação do SDK. Em seguida, instale o conjunto de ferramentas 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. Em seguida, continue a configuração do seu projeto personalizado.

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

   Use o comando de criação West para criar o exemplo "hello_world" do diretório raiz do repositório Zephyr. O firmware chamado zephyr.bin está disponível em build/zephyr directory.
7. Adicione o script de ambiente do Zephyr a ~/.bashrc. Execute os comandos a seguir.

   $ 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 Guia para iniciantes do Zephyr Doc.

Configurar o Telink LinuxBDT

Faça o download da ferramenta Telink LinuxBDT e extraia-a para um diretório local da máquina Linux, como o diretório principal ~, permitindo atualizar o 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 via interface USB e, em seguida, insira os comandos a seguir.

$ 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 do 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 com todos os recursos e 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 de 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 abaixo para gravar o firmware, usando a atualização do firmware ot-cli-ftd como exemplo.

$ 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 flash para ot-rcp é basicamente o mesmo que para ot-cli-ftd. No entanto, existem diferenças nos caminhos e nomes de firmware.

Depois de piscar, diferencie as duas placas de desenvolvimento B91 marcando-as adequadamente. Rotule a placa com ot-cli-ftd como "FTD Joiner" e a placa com ot-rcp como "RCP".

4. Configurar um console serial para o dispositivo FTD Joiner

Como mostrado na imagem, conecte diretamente o FTD Joiner na 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. Adicione o prefixo ot a todos os comandos.

Exemplos:

> ot state
disabled
Done
> ot channel
11
Done
>

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

Um roteador de borda do OpenThread é um dispositivo com duas partes principais:

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

Coprocessador de rádio (RCP)

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

Raspberry Pi

1. Confira se a imagem Raspbian Bullseye Lite Lite ou Raspbian Bullseye com computador está gravada corretamente no cartão SD.
2. Você tem a opção de usar o SSH no Raspberry Pi ou trabalhar diretamente com o Raspbian Desktop. Este codelab usará SSH.
3. Antes de continuar com a instalação do Docker OTBR 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ê atualizar o repositório local e o gerenciador de pacotes APT na etapa anterior, reinicie o Raspberry Pi e abra uma janela do 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. Assim, não será preciso adicionar sudo na frente 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, inicie-o:

   $ sudo dockerd
   

4. Os scripts de firewall 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
   

Configure e execute o Docker

Este codelab extrai diretamente a imagem do Docker OTBR do OpenThread Docker Hub (link em inglês). Esta imagem foi testada e verificada pela equipe do OpenThread.

1. Extrair a imagem mais recente:

   $ docker pull openthread/otbr:latest
   

2. Verifique 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 marcando /dev. ttyACM0 indica que o RCP está conectado corretamente.

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

4. Execute o Docker OTBR pela primeira vez e faça referência à porta serial do RCP (ttyACM0). Para continuar usando esse Docker 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 do 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
  

• Interromper Docker OTBR:

  $ docker stop otbr
  

• Remover o Docker OTBR:

  $ docker rm otbr
  

• Recarregue o Docker OTBR:

  $ docker restart otbr
  

Neste ponto, um dispositivo FTD Joiner e um OTBR estão prontos, e você pode avançar 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, digite o seguinte comando para iniciá-lo novamente no terminal SSH:

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

Depois, insira os comandos na ordem especificada na tabela e confira 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 dispositivos ot-cli-ftd entrarem nessa rede Thread.

Adicionar o FTD Joiner ao Thread por meio do comissionamento fora de banda

O comissionamento fora de banda se refere à transmissão de credenciais de rede para dispositivos que aguardam conexão com a rede por métodos não sem fio, por exemplo, inserindo manualmente a CLI do OpenThread. Digite os seguintes comandos em ordem no console serial para o FTD Joiner.

topologia

Digite 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. O RLOC16 do combinador de FTD se torna 0x8400 após receber o ID do roteador. Pode-se notar que o FTD Joiner foi atualizado de um filho para um roteador.

A rede Thread atual contém dois nós, e a topologia é a 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 conseguir 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

Digite o seguinte comando 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 o FTD Joiner recebeu a resposta de ping retornada pelo OTBR. A comunicação entre os dois dispositivos foi estabelecida.

Comunicação UDP

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

Primeiro, consiga o EID Mesh-Local 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

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

> udp open
Done
> udp bind :: 1022
Done

Digite os seguintes comandos 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 informações a seguir. 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 do Telink Zephyr.
• Como criar e atualizar os binários ot-cli-ftd e ot-rcp para as placas de desenvolvimento Telink B91.
• Como configurar uma versão do Raspberry Pi 3B+ ou mais recente como um roteador de borda do OpenThread (OTBR) usando o Docker.
• Como criar uma rede Thread em OTBR.
• Como adicionar dispositivos à rede Thread por comissionamento fora de banda.
• Como verificar a conectividade entre os nós na rede Thread.

Leitura complementar

Acesse openthread.io e GitHub para saber mais sobre vários recursos do OpenThread, incluindo:

• Plataformas compatíveis: descubra todas as plataformas compatíveis com OpenThread
• Criar OpenThread: mais detalhes sobre como criar e configurar o OpenThread
• Thread Primer: aborda todos os conceitos do Thread apresentados neste codelab.

Documentos de referência:

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