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
eot-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:
Índice | Nome |
1 | Placa de desenvolvimento Telink B91 |
2 | Tampa de ardósia Telink |
3 | Antena de 2,4 Ghz |
4 | Cabo USB (USB A para miniUSB) |
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.
- 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. - 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
. - 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) 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
- 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 chamadozephyr.bin
está disponível embuild/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 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:
- 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 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
- Confira se a imagem Raspbian Bullseye Lite Lite ou Raspbian Bullseye com computador está gravada corretamente no cartão SD.
- Você tem a opção de usar o SSH no Raspberry Pi ou trabalhar diretamente com o Raspbian Desktop. Este codelab usará SSH.
- 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.
- 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, 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. - 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 do Docker OTBR 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
- Determine o nome da porta serial do dispositivo RCP marcando
/dev
.ttyACM0
indica que o RCP está conectado corretamente.$ ls /dev/tty* ... /dev/ttyACM0 ...
- 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
- 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.
Índice | Comando | Introdução | Resposta esperada | ||
1 |
| Crie um novo conjunto de dados de rede aleatório. | Concluído | ||
2 |
| Confirmar o novo conjunto de dados operacional ativo em um armazenamento não volátil. | Concluído | ||
3 |
| Abra a interface IPv6. | Concluído | ||
4 |
| Ativar a operação do protocolo Thread e anexar a uma rede Thread. | Concluído | ||
Aguarde 10 segundos para que a interface da linha de execução apareça. | |||||
5 |
| Verifique o estado do dispositivo.Esse comando pode ser chamado várias vezes até se tornar líder e passar para a próxima etapa. | líder | ||
6 |
| Verifique o conjunto de dados operacional ativo completo e registre a chave de rede. | Carimbo de data/hora ativo: 1 |
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.
Índice | Comando | Introdução | Respostas esperadas | ||
1 |
| Apenas a chave de rede é necessária para que um dispositivo se conecte a uma rede Thread. | Concluído | ||
2 |
| Confirmar o novo conjunto de dados operacional ativo em um armazenamento não volátil. | Concluído | ||
3 |
| Abra a interface IPv6. | Concluído | ||
4 |
| Ativar a operação do protocolo Thread e anexar a uma rede Thread. | Concluído | ||
Aguarde 20 segundos enquanto o dispositivo é conectado e configurado automaticamente. | |||||
5 |
| Verifique o estado do dispositivo. | filho/roteador |
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
eot-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: