1. Introdução
O OpenThread lançado pelo Google é uma implementação de código aberto do protocolo de rede Thread®. O Google Nest lançou o OpenThread para disponibilizar aos desenvolvedores a tecnologia usada nos produtos Nest para acelerar o desenvolvimento de produtos para a casa conectada.
A especificação da linha de execução define um protocolo de comunicação dispositivo a dispositivo sem fio confiável, seguro e de baixo consumo energético IPv6 para aplicativos domésticos. O OpenThread implementa todas as camadas de rede Thread, incluindo IPv6, 6LoWPAN, IEEE 802.15.4 com segurança MAC, estabelecimento de link de malha e roteamento de malha.
Neste codelab, você vai programar o OpenThread em hardware real, criar e gerenciar uma rede Thread e transmitir mensagens entre nós.
O que você vai aprender
- Como criar e atualizar os binários da CLI do OpenThread para placas de desenvolvedor
- Como criar um RCP que consiste em uma máquina Linux e uma placa de desenvolvedor
- Comunicação com um RCP usando o Daemon do OpenThread e
ot-ctl - Gerenciamento manual de nós Thread com a Tela do GNU e a CLI do OpenThread
- comissionamento seguro de dispositivos em uma rede Thread
- Como funciona o multicast IPv6
- Como transmitir mensagens entre nós da linha de execução com UDP
O que é necessário
Hardware:
- Três placas de desenvolvimento nórdica nRF52840
- Três cabos USB para micro USB para conectar as placas
- Uma máquina Linux com pelo menos três portas USB
Software:
- Conjunto de ferramentas GNU
- Ferramentas de linha de comando nórdica nRF5x
- Software Segger J-Link
- OpenThread
- Git
2. Primeiros passos
Simulação do OpenThread
Antes de começar, consulte o Codelab de simulação de OpenThread para conhecer os conceitos básicos de Thread e a CLI do OpenThread.
Terminais de porta serial
Você precisa saber se conectar a uma porta serial usando um terminal. Este codelab usa a Tela GNU e fornece uma visão geral do uso, mas é possível usar qualquer outro software de terminal.
Máquina Linux
Este codelab foi projetado para usar uma máquina Linux baseada em i386 ou x86 para servir como host para um dispositivo Thread de processador de rádio (RCP) e atualizar todas as placas de desenvolvimento Thread. Todas as etapas foram testadas no Ubuntu 14.04.5 LTS (Trusty Tahr).
Placas nórdicas semicondutores nRF52840
Este codelab usa três placas PDRF n252840.
Instalar o SE-GER J-Link
Usamos o SEGGER J-Link para programar as placas nRF52840, que têm módulos JTAG integrados. Instale este aplicativo no seu computador Linux.
Faça o download do pacote apropriado para sua máquina e instale-o no local adequado. No Linux, ele é /opt/SEGGER/JLink.
Instalar ferramentas de linha de comando nRF5x
As ferramentas de linha de comando nRF5x permitem atualizar os binários do OpenThread para as placas nRF52840. Instale a versão nRF5x-Command-Line-Tools-<OS> adequada na sua máquina Linux.
Colocar o pacote extraído na pasta raiz ~/
Instalar conjunto de ferramentas ARM GNU
O conjunto de ferramentas ARM GNU é usado para criar
Recomendamos que você coloque o arquivo extraído em /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ na máquina Linux. Siga as instruções no arquivo readme.txt do arquivo para ver as instruções de instalação.
Instalar tela (opcional)
A tela é uma ferramenta simples para acessar dispositivos conectados por uma porta serial. Este codelab usa a tela, mas você pode usar qualquer aplicativo de terminal de porta serial que quiser.
$ sudo apt-get install screen
3. Clonar repositórios
OpenThread
Clone e instale o OpenThread. Os comandos script/bootstrap garantem que o conjunto de ferramentas esteja instalado e o ambiente esteja configurado corretamente:
$ mkdir -p ~/src $ cd ~/src $ git clone --recursive https://github.com/openthread/openthread.git $ cd openthread $ ./script/bootstrap
Criar daemon do Thread:
$ script/cmake-build posix -DOT_DAEMON=ON
Agora está tudo pronto para criar e atualizar o OpenThread para as placas nRF52840.
4. Configurar o Combinador de RCP
Criar e atualizar
Crie o exemplo OpenThread nRF52840 com funcionalidade de Combinador e USB nativo. Um dispositivo usa o papel de Combinador para ser autenticado com segurança e comissionado em uma rede Thread. O USB nativo permite o uso do USB CDC ACM como transporte serial entre o nRF52840 e o host.
Primeiro, execute o comando rm -rf build para limpar o repositório de builds anteriores.
$ cd ~/src $ git clone --recursive https://github.com/openthread/ot-nrf528xx.git $ cd ot-nrf528xx $ script/build nrf52840 USB_trans
Navegue até o diretório com o binário RCP do OpenThread e converta-o para o formato hexadecimal:
$ cd ~/src/ot-nrf528xx/build/bin $ arm-none-eabi-objcopy -O ihex ot-rcp ot-rcp.hex
Conecte o cabo USB à porta de depuração micro USB ao lado do pino externo da placa nRF52840 e depois conecte-o à máquina Linux. Defina o interruptor da fonte de energia nRF na placa nRF52840 como VDD. Quando conectado corretamente, o LED5 está ativado.
Se esta for a primeira placa anexada à máquina Linux, ela aparecerá como porta serial /dev/ttyACM0 (todas as placas nRF52840 usam ttyACM para o identificador da porta serial).
$ ls /dev/ttyACM* /dev/ttyACM0
Observe o número de série da placa nRF52840 usada para o RCP:
Navegue até o local das ferramentas de linha de comando nRFx e atualize o arquivo hexadecimal do RCP do OpenThread na placa nRF52840, usando o número de série da placa. Se a sinalização --verify for deixada de fora, você verá uma mensagem de aviso informando que o processo de atualização pode falhar sem erro.
$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
~/src/ot-nrf528xx/build/bin/ot-rcp.hex --reset
A saída a seguir é gerada após o sucesso:
Parsing hex file. Erasing user available code and UICR flash areas. Applying system reset. Checking that the area to write is not protected. Programing device. Applying system reset. Run.
Rotule o tabuleiro "RCP" para que mais tarde você não confunda os papéis do tabuleiro.
Conectar ao USB nativo
Como o build do RCP do OpenThread permite o uso do ACM USB CDC nativo como transporte serial, é necessário usar a porta nRF USB na placa nRF52840 para se comunicar com o host do RCP (máquina Linux).
Desconecte a extremidade micro USB do cabo USB da porta de depuração da placa nRF52840 atualizada e depois conecte-a novamente à porta nRF USB micro ao lado do botão REDEFINIR. Defina o interruptor da fonte de energia nRF como USB.
Iniciar daemon do OpenThread
No design RCP, use o Daemon do OpenThread para se comunicar e gerenciar o dispositivo Thread. Inicie ot-daemon com a sinalização de resposta detalhada -v para ver a saída do registro e confirmar que ele está em execução:
$ cd ~/src/openthread
$ sudo ./build/posix/src/posix/ot-daemon -v \
'spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=115200'
Quando bem-sucedido, ot-daemon no modo detalhado gera uma saída semelhante a esta:
ot-daemon[12463]: Running OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; POSIX; Aug 30 2022 10:55:05 ot-daemon[12463]: Thread version: 4 ot-daemon[12463]: Thread interface: wpan0 ot-daemon[12463]: RCP version: OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; SIMULATION; Aug 30 2022 10:54:10
Deixe essa janela do terminal aberta para ver os registros de ot-daemon.
Use ot-ctl para se comunicar com o nó do RCP. O ot-ctl usa a mesma CLI que o app de CLI do OpenThread. Portanto, você pode controlar os nós ot-daemon da mesma forma que os outros dispositivos simulados do Thread.
Em uma segunda janela do terminal, inicie ot-ctl:
$ sudo ./build/posix/src/posix/ot-ctl >
Verifique o state do nó 2 (o nó RCP) que você começou com ot-daemon:
> state disabled Done
5. Configurar os FTDs
Os outros dois nós de linha de execução usados neste codelab são dispositivos de linha de execução completos (FTDs) no design padrão de system on chip (SoC). Em uma configuração de produção, é possível usar wpantund, um driver de interface de rede no nível de produção, para controlar as instâncias de NCP do OpenThread. No entanto, neste codelab, usaremos ot-ctl, a CLI do OpenThread.
Um dispositivo funciona como o comissário para autenticar e comissionar os dispositivos nessa rede com segurança. O outro dispositivo funciona como um Combinador que o comissário pode autenticar na rede Thread.
Criar e atualizar
Crie o exemplo FTD do OpenThread para a plataforma nRF52840, com os papéis de Comissário e Combinador ativados:
$ cd ~/src/ot-nrf528xx $ rm -rf build $ script/build nrf52840 USB_trans -DOT_JOINER=ON -DOT_COMMISSIONER=ON
Navegue até o diretório com o binário CLI do OpenThread Thread Device (FTD) e converta-o para o formato hexadecimal:
$ cd ~/src/ot-nrf528xx/build/bin $ arm-none-eabi-objcopy -O ihex ot-cli-ftd ot-cli-ftd.hex
Conecte o cabo USB à porta micro USB ao lado do pino externo da placa nRF52840 e depois conecte-o à máquina Linux. Se o RCP ainda estiver conectado à máquina Linux, essa nova placa aparecerá como porta serial /dev/ttyACM1 (todas as placas nRF52840 usam ttyACM para o identificador da porta serial).
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1
Como antes, observe o número de série da placa nRF52840 usada para o FTD:
Navegue até o local das ferramentas de linha de comando nRFx e atualize o arquivo hexadecimal FTD da CLI do OpenThread na placa nRF52840, usando o número de série da placa:
$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
~/src/ot-nrf528xx/build/bin/ot-cli-ftd.hex --reset
Rotule o tabuleiro "Comissionador."
Conectar ao USB nativo
Como o build FTD do OpenThread permite o uso do ACM USB CDC nativo como transporte serial, você precisa usar a porta nRF USB na placa nRF52840 para se comunicar com o host RCP (máquina Linux).
Desconecte a extremidade micro USB do cabo USB da porta de depuração da placa nRF52840 atualizada e depois conecte-a novamente à porta nRF USB micro ao lado do botão REDEFINIR. Defina o interruptor da fonte de energia nRF como USB.
Verificar build
Verifique se uma versão foi bem-sucedida acessando a CLI do OpenThread usando a tela do GNU a partir de uma janela do terminal. As placas nRF52840 usam uma taxa de baud de 115.200.
$ screen /dev/ttyACM1 115200
Na nova janela, pressione"Return"no teclado algumas vezes para abrir o prompt > da CLI do OpenThread. Abra a interface do IPv6 e verifique se há endereços:
> ifconfig up Done > ipaddr fe80:0:0:0:1cd6:87a9:cb9d:4b1d Done
Use Ctrl + A →
d para se desconectar da tela FTD Commissioner CLI e voltar ao terminal Linux para atualizar a próxima placa. Para inserir a CLI novamente a qualquer momento, use screen -r na linha de comando. Para ver uma lista de telas disponíveis, use screen -ls:
$ screen -ls
There is a screen on:
74182.ttys000.mylinuxmachine (Detached)
1 Socket in /tmp/uscreens/S-username.
Configurar o FTD Joiner
Repita o processo acima para atualizar a terceira placa nRF52840 usando o build ot-cli-ftd.hex. Quando terminar, reconecte a placa ao computador usando a porta USB nRF e mude a chave da fonte de energia nRF para VDD.
Se os outros dois nós estiverem conectados à máquina Linux quando a terceira placa estiver conectada, ela vai aparecer como a porta serial /dev/ttyACM2:
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1 /dev/ttyACM2
Rotule o tabuleiro "Joiner."
Ao verificar usando Screen, em vez de criar uma nova instância de Screen na linha de comando, reconecte-se à existente e crie uma nova janela dentro dela (que foi usada para o FTD Commissioner):
$ screen -r
Crie a nova janela na tela usando Ctrl+A → c.
Um novo prompt de linha de comando é exibido. Acesse a CLI do OpenThread para o FTD Joiner:
$ screen /dev/ttyACM2 115200
Nessa nova janela, pressione "Return" no teclado algumas vezes para abrir o prompt > da CLI do OpenThread. Abra a interface do IPv6 e verifique se há endereços:
> ifconfig up Done > ipaddr fe80:0:0:0:6c1e:87a2:df05:c240 Done
Agora que a CLI do FTD Joiner está na mesma instância da tela que o FTD Commissioner, é possível alternar entre eles usando Ctrl + A → n.
Use Ctrl + A →
d a qualquer momento para sair da Tela.
6. Configuração da janela do terminal
A partir de agora, você alternará entre dispositivos Thread com frequência, então verifique se todos estão ativos e acessíveis. Até agora, usamos o Screen para acessar os FTDs, e essa ferramenta também permite dividir a tela na mesma janela do terminal. Use esse método para ver como um nó reage aos comandos emitidos em outro.
O ideal é ter quatro janelas disponíveis:
- Serviço / registros do
ot-daemon - RCP Joiner via
ot-ctl - FTD Commissioner pela CLI do OpenThread
- FTD Joiner pela CLI do OpenThread
Se você quiser usar sua própria ferramenta ou configuração de terminal / porta serial, pule para a próxima etapa. Configure as janelas do terminal para todos os dispositivos da maneira que funcionar melhor para você.
Como usar a tela
Para facilitar, use apenas uma sessão de tela. Você já deve ter um de quando configurar os FTDs.
Todos os comandos na tela começam com Ctrl+a.
Comandos básicos de tela:
Reanexar à sessão de tela (na linha de comando) |
|
Sair da sessão de tela | Ctrl + A → |
Criar uma nova janela na sessão de tela | Ctrl + A → |
Alternar entre janelas na mesma sessão do Screen | Ctrl+a → |
encerrar a janela atual na sessão de tela; | Ctrl + A → |
Tela dividida
Com o Screen, você pode dividir o terminal em várias janelas:
Para acessar os comandos do screen, use Ctrl+a. Cada comando precisa começar com essa combinação de chave de acesso.
Se você está seguindo o codelab exatamente, é preciso ter duas janelas (FTD Commissioner, FTD Joiner) na mesma instância de Screen. Para dividir a tela entre os dois, primeiro insira a sessão de tela existente:
$ screen -r
Você deve estar em um dos dispositivos FTD. Siga estas etapas na tela:
- Ctrl+a →
Spara dividir a janela horizontalmente - Ctrl+a →
Tabpara mover o cursor para a nova janela em branco - Ctrl+a →
npara alternar a nova janela para a próxima - Se for igual à janela superior, Ctrl+a →
nnovamente para visualizar o outro dispositivo FTD
Agora elas podem ser vistas. Alterne entre eles usando Ctrl + A → Tab. Recomenda-se renomear cada janela com Ctrl + A → A para evitar confusão.
Uso avançado
Para dividir ainda mais a tela em quadrantes e ver os registros do ot-daemon e o Combinador do RCP ot-ctl, esses serviços precisam ser iniciados nessa mesma instância do Screen. Para fazer isso, interrompa o ot-daemon e saia do ot-ctl e o reinicie nas novas janelas da Tela (Ctrl+a → c).
Essa configuração não é obrigatória e é deixada como um exercício para o usuário.
Divida e navegue entre janelas com os seguintes comandos:
Criar nova janela | Ctrl + A → |
Dividir janela verticalmente | Ctrl+A → |
Dividir janela horizontalmente | Ctrl + A → |
Ir para a próxima janela exibida | Ctrl + A → |
Alternar a janela exibida para frente ou para trás | Ctrl+a → |
Renomear a janela atual | Ctrl + A → |
Saia da tela a qualquer momento com Ctrl+a → d e anexe novamente ao screen -r na linha de comando.
Para mais informações sobre Screen, consulte a referência rápida da tela GNU.
7. Criar a rede Thread
Agora que todas as janelas e telas do terminal estão configuradas, vamos criar nossa rede Thread. No FTD Commissioner, crie um novo conjunto de dados operacional e confirme-o como o ativo. O conjunto de dados operacional é a configuração para a rede Thread que você está criando.
## FTD Commissioner ## ---------------------- > dataset init new Done > dataset Active Timestamp: 1 Channel: 11 Channel Mask: 07fff800 Ext PAN ID: c0de7ab5c0de7ab5 Mesh Local Prefix: fdc0:de7a:b5c0/64 Network Key: 1234c0de7ab51234c0de7ab51234c0de Network Name: OpenThread-c0de PAN ID: 0xc0de PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4 Security Policy: 0, onrcb Done
Anote a chave de rede 1234c0de7ab51234c0de7ab51234c0de, que será usada posteriormente.
Confirme que este conjunto de dados é o ativo:
> dataset commit active Done
Mostrar a interface IPv6:
> ifconfig up Done
Inicie a operação do protocolo Thread:
> thread start Done
Após um momento, verifique o estado do dispositivo. Deve ser o líder. Veja também o RLOC16 para referência futura.
## FTD Commissioner ## ---------------------- > state leader Done > rloc16 0c00 Done
Verifique os endereços IPv6 do dispositivo:
## FTD Commissioner ## ---------------------- > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Leader Anycast Locator (ALOC) fdc0:de7a:b5c0:0:0:ff:fe00:c00 # Routing Locator (RLOC) fdc0:de7a:b5c0:0:6394:5a75:a1ad:e5a # Mesh-Local EID (ML-EID) fe80:0:0:0:1cd6:87a9:cb9d:4b1d # Link-Local Address (LLA)
A rede "codelab" agora fica visível quando verificada em outros dispositivos Thread.
De ot-ctl no Combinador RCP:
## RCP Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |
A partir da CLI do OpenThread no FTD Joiner:
## FTD Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |
Se a rede "codelab" não aparecer na lista, tente verificar novamente.
8. Adicionar o Combinador de RCP
O comissionamento do Thread não está ativo na rede, o que significa que precisaremos adicionar o Combinador RCP à rede Thread que acabamos de criar usando um processo de comissionamento fora de banda.
No FTD Commissioner, fizemos uma observação sobre a chave de rede, por exemplo, 1234c0de7ab51234c0de7ab51234c0de. Se você precisar procurar a chave de rede novamente, execute o comando a seguir no FTD Commissioner:
## FTD Commissioner ## > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done
Em seguida, no RCP Joiner, defina a chave de rede do conjunto de dados ativo como a chave de rede do FTD Commissioner:
## RCP Joiner ## ---------------- > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done > dataset commit active Done
Verifique o conjunto de dados para garantir que ele esteja definido corretamente.
## RCP Joiner ## ---------------- > dataset Network Key: 1234c0de7ab51234c0de7ab51234c0de
Chame Thread para o Combinador RCP participar da rede "codelab" Aguarde alguns segundos, verifique o estado, RLOC16 e os endereços IPv6:
## RCP Joiner ## ---------------- > ifconfig up Done > thread start Done > state child Done > rloc16 0c01 Done > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:0c01 # Routing Locator (RLOC) fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f # Mesh-Local EID (ML-EID) fe80:0:0:0:18e5:29b3:a638:943b # Link-Local Address (LLA) Done
Anote o endereço IPv6 local da malha (fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f aqui). Ele será usado mais tarde.
De volta ao FTD Commissioner, verifique as tabelas do roteador e do filho para confirmar se os dois dispositivos fazem parte da mesma rede. Use o RLOC16 para identificar o Combinador RCP.
## FTD Commissioner ## ---------------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 3 | 0 | 0 | 0 | 35 | 1ed687a9cb9d4b1d | Done > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|VER| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+---+------------------+ | 1 | 0x0c01 | 240 | 25 | 3 | 89 |1|1|1| 2| 1ae529b3a638943b | Done
Dê um ping no endereço local da malha do Combinador de RCP (o endereço local de malha recebido da saída ipaddr do Combinador de RCP) para verificar a conectividade:
## FTD Commissioner ## ---------------------- > ping fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f > 8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=1 hlim=64 time=40ms
Agora temos uma rede Thread que consiste em dois nós, ilustrados por este diagrama de topologia:
Diagramas de topologia
À medida que você trabalha no restante do codelab, mostraremos um novo diagrama de topologia de Thread sempre que o estado da rede mudar. Os papéis de nós são indicados da seguinte maneira:
Os roteadores são sempre pentágonos, e os dispositivos finais são sempre círculos. Os números em cada nó representam o ID do roteador ou o ID filho mostrado na saída da CLI, dependendo do papel atual e do estado de cada nó naquele momento.
9. Comissões do FTD Combinador
Agora, vamos adicionar o terceiro dispositivo Thread à rede "codelab" Desta vez, usaremos o processo de comissionamento em banda mais seguro e permitiremos apenas a participação do FTD.
No FTD Joiner, receba o eui64, para que o FTD Commissioner possa identificá-lo:
## FTD Joiner ## ---------------- > eui64 2f57d222545271f1 Done
No FTD Commissioner, inicie o Commissioner e especifique o eui64 do dispositivo que pode participar, além da credencial do Combinador, por exemplo, J01NME. A credencial do combinador é uma string específica do dispositivo, com caracteres alfanuméricos maiúsculos (0-9 e A-Y, exceto I, O, Q e Z para legibilidade), com comprimento entre 6 e 32 caracteres.
## FTD Commissioner ## ---------------------- > commissioner start Done > commissioner joiner add 2f57d222545271f1 J01NME Done
Mude para o FTD Joiner. Inicie o papel de integrador com a credencial de Joiner que você acabou de configurar no FTD Commissioner:
## FTD Joiner ## ---------------- > ifconfig up Done > joiner start J01NME Done
Em cerca de um minuto, você receberá uma confirmação de autenticação:
## FTD Joiner ## ---------------- > Join success
Chame Thread para que o FTD Joiner entre na rede "codelab" e verifique imediatamente o estado e o RLOC16:
## FTD Joiner ## ---------------- > thread start Done > state child Done > rloc16 0c02 Done
Verifique os endereços IPv6 do dispositivo. Observe que não há ALOC. Isso ocorre porque o dispositivo não é o líder nem tem um papel específico do Anycast que requer uma ALOC.
## FTD Joiner ## ---------------- > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:c02 # Routing Locator (RLOC) fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd # Mesh-Local EID (ML-EID) fe80:0:0:0:e4cd:d2d9:3249:a243 # Link-Local Address (LLA)
Imediatamente mude para o FTD Commissioner e verifique as tabelas do roteador e do filho para confirmar se há três dispositivos na rede "codelab":
## FTD Commissioner ## ---------------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 3 | 0 | 0 | 0 | 50 | 1ed687a9cb9d4b1d | > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0x0c01 | 240 | 25 | 3 | 89 |1|1|1|1| 1ae529b3a638943b | | 2 | 0x0c02 | 240 | 15 | 3 | 44 |1|1|1|1| e6cdd2d93249a243 | Done
Com base no RLOC16, o Combinador FTD se conectou à rede como um dispositivo final (filha). Esta é nossa topologia atualizada:
10. Conversa em ação
Os dispositivos de linha de execução neste codelab são um tipo específico de dispositivo de linha de execução completo (FTD), chamado de dispositivo final qualificado de roteador (REED, na sigla em inglês). Isso significa que eles podem funcionar como um roteador ou dispositivo final e se promover de um dispositivo final a um roteador.
A Thread é compatível com até 32 roteadores, mas tenta manter o número de roteadores entre 16 e 23. Se um REED se anexar como um dispositivo final (filha) e o número de roteadores estiver abaixo de 16, após um período aleatório de dois minutos, ele será promovido automaticamente a um roteador.
Se você teve dois filhos na sua rede Thread após adicionar o FTD Combinador, aguarde pelo menos dois minutos e, em seguida, verifique novamente as tabelas do roteador e do filho no FTD Commissioner:
## FTD Commissioner ## ---------------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 3 | 0 | 0 | 0 | 50 | 1ed687a9cb9d4b1d | | 46 | 0xb800 | 63 | 0 | 3 | 3 | 1 | e6cdd2d93249a243 | > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0x0c01 | 240 | 61 | 3 | 89 |1|1|1|1| 1ae529b3a638943b | Done
O Combinador FTD (Mac MAC estendido = e6cdd2d93249a243) se promoveu para um roteador. O RLOC16 é diferente (b800 em vez de 0c02). Isso acontece porque o RLOC16 é baseado no ID do roteador e no ID do filho de um dispositivo. Quando há uma transição do dispositivo final para o roteador, os valores de ID do roteador e do ID filho são alterados, assim como o RLOC16.
Confirme o novo estado e o RLOC16 no FTD Joiner:
## FTD Joiner ## ---------------- > state router Done > rloc16 b800 Done
Fazer downgrade do FTD Combinador
Para testar esse comportamento, faça o downgrade manual do Combinador FTD de um roteador para um dispositivo final. Altere o estado para filho e verifique o RLOC16:
## FTD Joiner ## ---------------- > state child Done > rloc16 0c03 Done
No FTD Commissioner, o FTD Joiner será exibido na tabela filha (ID = 3). Ele pode até mesmo estar em ambos ao fazer a transição:
## FTD Commissioner ## ---------------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 3 | 0 | 0 | 0 | 50 | 1ed687a9cb9d4b1d | | 46 | 0xb800 | 63 | 0 | 3 | 3 | 1 | e6cdd2d93249a243 | > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0x0c01 | 240 | 61 | 3 | 89 |1|1|1|1| 1ae529b3a638943b | | 3 | 0x0c03 | 240 | 16 | 3 | 94 |1|1|1|1| e6cdd2d93249a243 | Done
Depois de algum tempo, ele voltará para um roteador com um RLOC de b800.
Remover o líder
O líder é eleito entre todos os roteadores de linha de execução. Isso significa que se o líder atual for removido da rede Thread, um dos outros roteadores vai se tornar o novo líder.
No FTD Commissioner, desligue o Thread para removê-lo da rede Thread:
## FTD Commissioner ## ---------------------- > thread stop Done > ifconfig down Done
Em dois minutos, o FTD Joiner se torna o novo líder do Thread. Verifique os estados e os endereços IPv6 do Combinador FTD para verificar:
## FTD Joiner ## ---------------- > state leader Done > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Now it has the Leader ALOC! fdc0:de7a:b5c0:0:0:ff:fe00:b800 fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd fe80:0:0:0:e4cd:d2d9:3249:a243 Done
Verifique a tabela filha. Observe que há um novo RLOC16. Esse é o Combinador de RCP, conforme indicado pelo ID e pelo MAC estendido. Para manter a rede Thread juntas, ela trocou os roteadores pais do Comissário de FTD para o Combinador de FTD. Isso resulta em um novo RLOC16 para o Combinador de RCP (porque o ID do roteador mudou, de 3 para 46).
## FTD Joiner ## ---------------- > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0xb801 | 240 | 27 | 3 | 145 |1|1|1|1| 1ae529b3a638943b | Done
Talvez seja necessário aguardar alguns minutos para que o Combinador RCP seja anexado ao FTD combinador como filho. Verifique o estado e o RLOC16 para confirmar se:
## RCP Joiner ## -------------- > state child > rloc16 b801
Anexe novamente o FTD do comissário
Uma rede Thread com dois nós não é muito divertida. Vamos voltar ao FTD Commissioner.
No FTD Commissioner, reinicie a linha de execução:
## FTD Commissioner ## ---------------------- > ifconfig up Done > thread start Done
Em dois minutos, ele é reconectado automaticamente à rede "codelab" como um dispositivo final e se promove como um roteador.
## FTD Commissioner ## ---------------------- > state router Done
Confira as tabelas do roteador e do filho no FTD Joiner para verificar:
## FTD Joiner ## ---------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 63 | 0 | 3 | 3 | 0 | 1ed687a9cb9d4b1d | | 46 | 0xb800 | 46 | 0 | 0 | 0 | 15 | e6cdd2d93249a243 | > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0xb801 | 240 | 184 | 3 | 145 |1|1|1|1| 1ae529b3a638943b | Done
Nossa rede Thread consiste em três nós novamente.
11. Solução de problemas
Gerenciar uma rede Thread com vários dispositivos em diferentes terminais ou janelas de tela pode ser complicado. Use estas dicas para "redefinir" o estado da rede ou do seu espaço de trabalho em caso de problemas.
Screen
Se você perder sua configuração (muitas janelas ou telas na tela), continue encerrando as janelas de tela com Ctrl+a → k até que nenhuma exista e screen -ls na linha de comando gere No Sockets found. Em seguida, recrie janelas de tela para cada dispositivo. Os estados do dispositivo são mantidos mesmo quando a tela é encerrada.
Nós de linha de execução
Se a topologia de rede Thread não for conforme a descrição neste codelab ou os nós forem desconectados por algum motivo (talvez porque a máquina Linux que os alimentava tenha entrado no modo de suspensão), é melhor desativar a Thread, limpar as credenciais da rede e começar novamente da etapa Create the Thread network.
Para redefinir os FTDs:
## FTD Commissioner or FTD Joiner ## ------------------------------------ > thread stop Done > ifconfig down Done > factoryreset Done
O RCP pode ser redefinido da mesma maneira usando ot-ctl:
## RCP Joiner ## ---------------- > thread stop Done > ifconfig down Done > factoryreset Done
12. Como usar multicast
O multicast é usado para comunicar informações a um grupo de dispositivos de uma só vez. Em uma rede Thread, os endereços específicos são reservados para uso em multicast com diferentes grupos de dispositivos, dependendo do escopo.
Endereço IPv6 | Escopo | Entregue a |
| Link local | FTDs e MEDs |
| Link local | FTDs e roteadores de borda |
| Rede mesh local | FTDs e MEDs |
| Rede mesh local | FTDs e roteadores de borda |
Como não estamos usando um roteador de borda neste codelab, vamos nos concentrar nos dois endereços multicast FTD e MED.
Link local
O escopo link-local abrange todas as interfaces Thread acessíveis por uma única transmissão de rádio ou uma única "hop." A topologia de rede determina quais dispositivos respondem a um ping para o endereço multicast ff02::1.
Dê um ping no ff02::1 do FTD Commissioner:
## FTD Commissioner ## ---------------------- > ping ff02::1 > 8 bytes from fe80:0:0:0:e4cd:d2d9:3249:a243: icmp_seq=2 hlim=64 time=9ms
Existem outros dois dispositivos na rede (FTD Joiner e RCP Joiner), mas o FTD Commissioner recebeu apenas uma resposta do FTD Joiner's Link-Local Address (LLA). Isso significa que o FTD Joiner é o único dispositivo que o FTD Commissioner pode acessar com um único salto.
Agora dê um ping em ff02::1 no FTD Joiner:
## FTD Joiner ## ---------------- > ping ff02::1 > 8 bytes from fe80:0:0:0:1cd6:87a9:cb9d:4b1d: icmp_seq=1 hlim=64 time=11ms 8 bytes from fe80:0:0:0:18e5:29b3:a638:943b: icmp_seq=1 hlim=64 time=24ms
Duas respostas. Ao verificar os endereços IPv6 dos outros dispositivos, vemos que o primeiro (que termina em 4b1d) é o LLA do FTD Commissioner e o que termina em 943b é o RCP Joiner's LLA.
Isso significa que o FTD Joiner é conectado diretamente ao FTD Commissioner e ao RCP Joiner, o que confirma nossa topologia.
Rede mesh local
O escopo mesh-local inclui todas as interfaces Thread acessíveis na mesma rede Thread. Vamos ver as respostas a um ping no endereço multicast ff03::1.
Dê um ping no ff03::1 do FTD Commissioner:
## FTD Commissioner ## ---------------------- > ping ff03::1 > 8 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:b800: icmp_seq=3 hlim=64 time=9ms 8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=3 hlim=64 time=68ms
Desta vez, o FTD Commissioner recebeu duas respostas: uma do FTD Joiner& 39;s Locator Finder (RLOC, terminando em b800) e uma do RCP Joiner's Mesh-Local EID (ML-EID, terminando em d55f). Isso ocorre porque o escopo mesh-local abrange toda a rede Thread. Não importa onde o dispositivo está na rede, ele será inscrito no endereço ff03::1.
Dê um ping em ff03::1 no FTD Joiner para confirmar o mesmo comportamento:
## FTD Joiner ## ---------------- > ping ff03::1 > 8 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00: icmp_seq=2 hlim=64 time=11ms 8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=2 hlim=64 time=23ms
Observe o tempo de resposta do RCP Joiner nas duas saídas de ping. O Combinador de RCP levou muito mais tempo para alcançar o Comissário de FTD (68ms) do que para chegar ao Combinador de FTD (23ms). Isso ocorre porque é preciso dois saltos para alcançar o FTD Commissioner, em comparação com um hop para o FTD Joiner.
Talvez você também tenha notado que o ping multicast local de malha respondeu com o RLOC apenas para os dois FTDs, não para o Combinador de RCP. Isso ocorre porque os FTDs são roteadores na rede, enquanto o RCP é um dispositivo final.
Verifique o estado do RCP Joiner para confirmar:
## RCP Joiner ## ---------------- > state child
13. Enviar mensagens com UDP
Um dos serviços de aplicativo que o OpenThread fornece é o protocolo de datagramas do usuário (UDP), um protocolo da camada de transporte. Um aplicativo criado no OpenThread pode usar a API UDP para transmitir mensagens entre nós em uma rede Thread ou para outros dispositivos em uma rede externa (como a Internet, se a rede Thread conta com um roteador de borda).
Os soquetes UDP são expostos pela CLI do OpenThread. Vamos usá-lo para transmitir mensagens entre os dois FTDs.
Encontre o endereço EID da malha local do Combinador FTD. Estamos usando este endereço porque ele pode ser acessado de qualquer lugar na rede Thread.
## FTD Joiner ## ---------------- > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Leader Anycast Locator (ALOC) fdc0:de7a:b5c0:0:0:ff:fe00:b800 # Routing Locator (RLOC) fe80:0:0:0:e4cd:d2d9:3249:a243 # Link-Local Address (LLA) fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd # Mesh-Local EID (ML-EID) Done
Inicie o UDP e vincule-o a um soquete para qualquer endereço IPv6:
## FTD Joiner ## ---------------- > udp open Done > udp bind :: 1212
Alterne para o FTD Commissioner, inicie o UDP e conecte ao soquete configurado no FTD Joiner usando seu ML-EID:
## FTD Commissioner ## ---------------------- > udp open Done > udp connect fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd 1212 Done
A conexão UDP precisa estar entre os dois nós. Envie uma mensagem do FTD Commissioner:
## FTD Commissioner ## ---------------------- > udp send hellothere Done
No FTD Joiner, a mensagem UDP foi recebida.
## FTD Joiner ## ---------------- > 10 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00 49153 hellothere
14. Parabéns!
Você criou uma rede Thread física!
Agora você sabe:
- A diferença entre tipos de dispositivos, papéis e escopos de linha de execução
- como os dispositivos Thread gerenciam os próprios estados na rede;
- como transmitir mensagens simples entre nós usando UDP
Próximas etapas
Com base neste codelab, tente os seguintes exercícios:
- Recarregue a placa de junção do FTD como um MTD usando o binário
ot-cli-mtde observe que ela nunca faz upgrade para um roteador ou tenta se tornar o líder - Adicionar mais dispositivos (testar uma plataforma diferente) na rede e esboçar a topologia usando roteador e tabelas filhas, além de pings para os endereços de multicast
- Usar pyspinel para controlar o NCP
- Converta o NCP em um roteador de borda usando o roteador de borda do OpenThread e conecte sua rede Thread à Internet
Leia mais
Acesse openthread.io e GitHub para conhecer vários recursos do OpenThread, incluindo:
- Plataformas compatíveis: descubra todas as plataformas compatíveis com o OpenThread
- Build OpenThread: mais detalhes sobre como criar e configurar o OpenThread
- Thread Primer: abrange todos os conceitos de Thread apresentados neste codelab.
Referência: