O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Esta página foi traduzida pela API Cloud Translation.

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 de 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 com eficiência energética para dispositivos com recursos limitados normalmente 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 links de malha e roteamento de malha.

O Telink integrou a implementação do OpenThread aos RTOS do Zephyr, o que permite compatibilidade total com o hardware do Telink. O código-fonte dessa integração está disponível no GitHub e é disponibilizado como um kit de desenvolvimento de software (SDK).

Neste codelab, você vai programar o OpenThread em um hardware real, criar e gerenciar uma rede Thread e trocar mensagens entre nós. A imagem abaixo mostra a configuração do hardware, apresentando 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 atualizá-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;
Criar uma rede Thread no OTBR.
Para adicionar dispositivos à rede Thread usando a depuração fora de 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 Telink Burning and Debugging — LinuxBDT.
de porta serial, como PuTTY.
Outras ferramentas, como Git e West.

2. Pré-requisitos

Conceitos de Thread e CLI OpenThread

Pode ser útil fazer o codelab de simulação do OpenThread para se familiarizar com os conceitos fundamentais da linha de execução 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 Telink Zephyr e atualizar todas as placas de desenvolvimento do Thread. Para realizar essas tarefas, a máquina Linux requer duas portas USB disponíveis e conexão com a Internet.

Terminais e conexão de porta serial

É possível conectar o dispositivo diretamente à 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 outro software terminal também pode ser empregado.

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 deles será usado como coprocessador de rádio (RCP, na sigla em inglês), enquanto o outro funcionará como dispositivo FTD (Full Thread Device). Caso ainda não tenha o kit, confira mais detalhes no site oficial da Telink (link em inglês). Estes são alguns componentes que podem ser usados:

Índice	Nome
1	Placa de desenvolvimento Telink B91
2	Tabuleiro de telink
3	Antena de 2,4 Ghz
4	Cabo USB (USB A para mini USB)

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

Neste codelab, é necessário ter um Raspberry Pi 3B ou mais recente com uma imagem do SO Raspbian Bullseye Lite ou um Raspbian Bullseye com 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 pelo 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 Telink, 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 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 OpenThread.

3. Configurar 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 seu APT esteja atualizado.

$ sudo apt update
$ sudo apt upgrade

Depois disso, siga as etapas abaixo.

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

Instalar 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.

Acesse o código-fonte do Projeto Zephyr.

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

Instale outras dependências do Python para o Zephyr.

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

Configure o conjunto de ferramentas do Zephyr. Faça o download do conjunto de ferramentas Zephyr (cerca de 1 a 2 GB) em um diretório local para 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

Baixe o 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]

Onde [-x.y.z] é um texto opcional que pode ser qualquer texto, como -0.16.1. O diretório não pode ser movido 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

Crie o exemplo de Hello World. Primeiro, verifique se a configuração oficial do projeto Zephyr está correta usando o exemplo Hello World e, 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 West build para criar o exemplo hello_world a partir do diretório raiz do repositório Zephyr. Você pode encontrar o firmware chamado zephyr.bin em build/zephyr directory.

Adicione o script de ambiente do Zephyr a ~/.bashrc. Execute os comandos a seguir.

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

Adicione o repositório remoto Telink Zephyr. Faça o download do repositório do 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 Zephyr Doc - Guia de primeiros passos.

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 ~. Isso permite a atualização do 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 a Burning Board à máquina Linux usando a interface USB e 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

A mensagem "Telink Web Debugger v3.6" indica que o programador BDT se conectou à máquina Linux.

Compilação de firmware

Este codelab criará dois tipos de firmware do OpenThread:

ot-cli-ftd,
e ot-rcp.

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

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

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 de firmware

Conecte uma placa de desenvolvimento B91 à queimador usando um cabo USB, conforme ilustrado na figura abaixo.

Na linha de comando, execute os comandos abaixo para realizar a gravação de firmware (usando a atualização do firmware do 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 de flash para ot-rcp é basicamente o mesmo de ot-cli-ftd. No entanto, existem diferenças nos caminhos e nos nomes do firmware.

Depois da atualização, diferencie as duas placas de desenvolvimento B91 marcando-as de acordo com elas. Rotule a placa com ot-cli-ftd como "FTD Joiner". e a placa foi atualizada com ot-rcp como "RCP".

4. Configurar um console serial para o dispositivo do Joiner FTD

Como mostrado na imagem, conecte diretamente o FTD Joiner à 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, configure as informações da porta serial e abra essa porta.

A referência da linha de comando do OpenThread está aqui: Referência da CLI do OpenThread. Certifique-se 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 do OpenThread

O roteador de borda do OpenThread é um dispositivo composto de 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 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

Confira se a imagem do SO Raspbian Bullseye Lite ou Raspbian Bullseye com computador está gravada corretamente no cartão SD.
Você tem a opção de usar SSH no Raspberry Pi ou trabalhar diretamente com a área de trabalho Raspbian. Este codelab vai usar SSH.
Antes de prosseguir com a instalação do Docker OTBR na próxima etapa, certifique-se de atualizar o repositório local e o gerenciador de pacotes primeiro.
```
$ sudo apt-get update
$ sudp apt-get upgrade
```

Instalar o Docker

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

Instale o Docker:

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

Coloque a conta atual em um grupo do Docker para conceder a permissão. Assim, sudo não precisa ser adicionado à frente de cada comando.
```
$ sudo usermod -aG docker $USER
```
É necessário reiniciar o Raspberry Pi para entrar em vigor.
Se o Docker não tiver sido iniciado, inicie-o:
```
$ sudo dockerd
```
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 OTBR do Docker do OpenThread Docker Hub (link em inglês). Esta imagem foi testada e verificada pela equipe do OpenThread.

Extrair a imagem mais recente:
```
$ docker pull openthread/otbr:latest
```

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

Verifique o /dev para determinar o nome da porta serial do dispositivo RCP. ttyACM0 indica que o RCP está conectado corretamente.
```
$ ls /dev/tty*
...
/dev/ttyACM0
... 
```

Execute o Docker do OTBR pela primeira vez e faça referência à porta serial do RCP (ttyACM0). Se você quiser 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

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
```
Interrompa o Docker OTBR:
```
$ docker stop otbr
```
Remova o Docker do OTBR:
```
$ docker rm otbr
```
Atualize o Docker OTBR:
```
$ docker restart otbr
```

Neste ponto, um dispositivo FTD Joiner e um OTBR estão prontos, e você pode prosseguir para a próxima etapa e 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 reiniciá-lo 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 gera o resultado esperado antes de prosseguir para a próxima.

Índice	Comando	Introdução	Resposta esperada
1	`dataset init new`	Crie um novo conjunto de dados de rede aleatório.	Concluído
2	`dataset commit active`	Confirme o novo conjunto de dados com o conjunto de dados operacional ativo em armazenamento não volátil.	Concluído
3	`ifconfig up`	Abra a interface IPv6.	Concluído
4	`thread start`	Ativa a operação do protocolo Thread e anexa a uma rede Thread.	Concluído
			Aguarde 10 segundos para que a interface da linha de execução esteja ativa.
5	`state`	Verifique o estado do dispositivo.Esse comando pode ser chamado várias vezes até se tornar o líder e passar para a próxima etapa.	leader Done
6	`dataset active`	Verifique o conjunto de dados operacional ativo completo e registre a chave de rede.	1 Canal: 1 Canal: 13 Canal: 13 Canal: 0x07fff800

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

Adicionar o Joiner FTD 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 estão esperando para se conectar à rede por métodos não sem fio, como a entrada manual na CLI do OpenThread. Insira os comandos abaixo em ordem no console serial para o Joiner do FTD.

Índice	Comando	Introdução	Respostas esperadas
1	`ot dataset networkkey c312485187484ceb5992d2343baaf93d`	Somente a chave de rede é necessária para que um dispositivo se conecte a uma rede Thread.	Concluído
2	`ot dataset commit active`	Confirme o novo conjunto de dados com o conjunto de dados operacional ativo em armazenamento não volátil.	Concluído
3	`ot ifconfig up`	Abra a interface IPv6.	Concluído
4	`ot thread start`	Ativa a operação do protocolo Thread e anexa a uma rede Thread.	Concluído
			Aguarde 20 segundos enquanto o dispositivo é conectado e se configura.
5	`ot state`	Verifique o estado do dispositivo.	filho/roteador Concluído

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 Combinador do FTD inicialmente é 0xb001. Em seguida, o RLOC16 do Joiner do FTD se torna 0x8400 após receber o ID do roteador. Observe que o Joiner FTD foi atualizado de um filho para um roteador.

A rede Thread atual contém dois nós, e a topologia dela é 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 acessar 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 Joiner do FTD 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 Joiner do FTD recebeu a resposta de ping retornada pelo OTBR. A comunicação entre os dois dispositivos é bem-sucedida.

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 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, receba o EID de malha local do OTBR. Esse 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 comandos abaixo 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 exibe as informações a seguir. O OTBR recebe a mensagem hello do Joiner do FTD, 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 dentro dela.

Agora você sabe:

Como criar e usar o ambiente de desenvolvimento do Telink Zephyr.
Como criar os binários ot-cli-ftd e ot-rcp e fazer a atualização deles em 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 no OTBR.
Como adicionar dispositivos à rede Thread pelo comissionamento fora de banda.
Como verificar a conectividade entre nós na rede Thread.

Leitura adicional

Confira 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 compatíveis com o OpenThread
Build OpenThread: mais detalhes sobre a criação e a configuração do OpenThread
Thread Primer: abrange todos os conceitos do Thread apresentados neste codelab.

Documentos de referência: