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 em produtos Nest para acelerar o desenvolvimento de produtos para a casa conectada.
A especificação do Thread define um protocolo de comunicação dispositivo a dispositivo sem fio confiável, seguro e de baixo consumo de energia para aplicativos domésticos. O OpenThread implementa todas as camadas de rede do Thread, incluindo IPv6, 6LoWPAN, IEEE 802.15.4 com segurança MAC, estabelecimento de vinculação 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 binários da CLI do OpenThread em placas de desenvolvimento
- Como criar um RCP que consiste em uma máquina Linux e uma placa de desenvolvimento
- Comunicação com um RCP usando o Daemon do OpenThread e
ot-ctl - Como gerenciar manualmente os nós do Thread com o GNU Screen e a CLI do OpenThread
- Comissionamento seguro de dispositivos em uma rede Thread
- Como funciona o multicast IPv6
- Como transmitir mensagens entre nós do Thread com UDP
Pré-requisitos
Hardware:
- 3 placas de desenvolvedor Nordic Semiconductor 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 Selink J-Segger
- OpenThread
- Git
2. Como começar
Simulação do OpenThread
Antes de começar, veja o Codelab de simulação do OpenThread para se familiarizar com os conceitos básicos do 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 qualquer outro software de terminal pode ser usado.
Máquina Linux
Este codelab foi projetado para usar uma máquina Linux baseada em i386 ou x86 para servir como host em um dispositivo Thread de processador de rádio (RCP) e atualizar todas as placas de desenvolvimento do Thread. Todas as etapas foram testadas no Ubuntu 14.04.5 LTS (Trusty Tahr).
Placas Nordic Semiconductor nRF52840
Este codelab usa três placas PDK nRF52840 (link em inglês).
Instalar o SEGGER J-Link
Usamos o SEGGER J-Link para programar as placas nRF52840, que têm módulos JTAG integrados. Instale o aplicativo na sua máquina Linux.
Faça o download do pacote apropriado para sua máquina e instale-o no local apropriado. No Linux, o valor é /opt/SEGGER/JLink.
Instalar ferramentas de linha de comando nRF5x
As ferramentas de linha de comando nRF5x permitem que você atualize os binários do OpenThread nas placas nRF52840. Instale a versão nRF5x-Command-Line-Tools-<OS> apropriada em sua máquina Linux.
Coloque o pacote extraído na pasta raiz ~/
Instalar o ARM GNU Toolchain
O ARM GNU Toolchain é usado para criar.
Recomendamos que você coloque o arquivo extraído em /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ na sua máquina Linux. Siga as instruções no arquivo readme.txt do arquivo para ver as instruções de instalação.
Instalar tela (opcional)
O Screen é uma ferramenta simples para acessar dispositivos conectados por uma porta serial. Este codelab usa o Screen, 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
Crie o Daemon do OpenThread:
$ script/cmake-build posix -DOT_DAEMON=ON
Agora você está pronto para criar e atualizar o OpenThread para as placas nRF52840.
4. Configurar o Combinador de RCP
Criar e atualizar
Crie o exemplo do OpenThread nRF52840 com a junta e a funcionalidade USB nativa. Um dispositivo usa a função "Combinador" para ser autenticado e comissionado com segurança em uma rede Thread. O USB nativo permite o uso do USB CDC ACM como um transporte serial entre o nRF52840 e o host.
Sempre execute 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 conecte-o à máquina Linux. Configure a chave fonte de alimentação nRF da placa nRF52840 para VDD. Quando conectado corretamente, o LED5 é ativado.
Se esta for a primeira placa conectada à máquina Linux, ela aparecerá como a 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 OpenThread RCP na placa nRF52840, usando o número de série da placa. Se você deixar de fora a sinalização --verify, verá uma mensagem de aviso informando que o processo do Flash pode falhar sem erros.
$ 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 a conclusão:
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 board "RCP" para não confundir os papéis do board.
Conectar ao USB nativo
Como a versão 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, em seguida, conecte-a novamente à porta nRF USB micro ao lado do botão REDEFINIR. Configure a chave fonte de alimentação nRF para USB.
Iniciar o Daemon do OpenThread
No design do RCP, use o OpenThread Daemon para se comunicar e gerenciar o dispositivo Thread. Inicie ot-daemon com a sinalização detalhada -v para poder 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 de terminal aberta para que os registros de ot-daemon possam ser visualizados.
Use ot-ctl para se comunicar com o nó RCP. ot-ctl usa a mesma CLI que o app CLI do OpenThread. Portanto, você pode controlar ot-daemon nós da mesma forma que os outros dispositivos Thread simulados.
Em uma segunda janela de 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 completa (FTD, na sigla em inglês) 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 do NCP do OpenThread, mas neste codelab, usaremos ot-ctl, a CLI do OpenThread.
Um dispositivo funciona como comissário para autenticar e comissionar dispositivos com segurança nessa rede. O outro dispositivo funciona como um Joiner que o Commissioner pode autenticar na rede Thread.
Criar e atualizar
Crie o exemplo FTD do OpenThread para a plataforma nRF52840, com os papéis "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 conecte-o à máquina Linux. Se o RCP ainda estiver conectado à máquina Linux, a 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
Marque o quadro "Comissário".
Conectar ao USB nativo
Como a versão FTD do OpenThread permite usar o ACM USB CDC nativo como um 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, em seguida, conecte-a novamente à porta nRF USB micro ao lado do botão REDEFINIR. Configure a chave fonte de alimentação nRF para USB.
Verificar build
Verificar uma versão bem-sucedida acessando a CLI do OpenThread usando a tela do GNU a partir de uma janela de terminal. As placas nRF52840 usam uma taxa baud de 115200.
$ screen /dev/ttyACM1 115200
Na nova janela, pressione Enter no teclado algumas vezes para abrir a solicitação > do OpenThread CLI. Abra a interface IPv6 e verifique os endereços:
> ifconfig up Done > ipaddr fe80:0:0:0:1cd6:87a9:cb9d:4b1d Done
Usar Ctrl+a →
d para se desconectar da tela da CLI do FTD Commissioner e voltar ao terminal do Linux para que a próxima placa possa ser atualizada. 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 a versão ot-cli-ftd.hex existente. Quando terminar, reconecte a placa ao PC usando a porta USB do nRF e defina a chave da fonte de alimentação nRF para VDD.
Se os outros dois nós estiverem conectados à máquina Linux quando a terceira placa estiver conectada, ela aparecerá como a porta serial /dev/ttyACM2:
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1 /dev/ttyACM2
Marque a placa como "Joiner".
Ao verificar usando a tela, em vez de criar uma nova instância da tela a partir da linha de comando, reconecte-a à existente e crie uma nova janela dentro dela (que você usou para o FTD Commissioner):
$ screen -r
Crie a nova janela na tela com Ctrl+a → c.
Um novo prompt de linha de comando é exibido. Acesse a CLI do OpenThread para o Joiner do FTD:
$ screen /dev/ttyACM2 115200
Nesta nova janela, pressione Enter no teclado algumas vezes para abrir a solicitação > da OpenThread CLI. Abra a interface IPv6 e verifique os 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.
Usar 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 certifique-se de que todos eles estejam ativos e facilmente acessíveis. Até agora, usamos o Screen para acessar os dois 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 a comandos emitidos em outro.
O ideal é ter quatro janelas disponíveis:
- Serviço / registros do
ot-daemon - Combinador RCP via
ot-ctl - FTD Commissioner: CLI do OpenThread
- FTD Joiner (link em inglês): usando a CLI do OpenThread.
Se quiser usar sua própria ferramenta ou configuração de terminal / porta serial, pule para a próxima etapa. Configure as janelas de terminal para todos os dispositivos da maneira que funcionar melhor para você.
Como usar a tela
Para facilitar o uso, inicie apenas uma sessão de tela. Você já deve ter um de quando configurou os dois FTDs.
Todos os comandos na tela começam com Ctrl+a.
Comandos básicos da tela:
Reanexar à sessão de tela (pela linha de comando) |
|
Sair da sessão de tela | Ctrl+a → |
Criar nova janela na sessão de tela | Ctrl+a → |
Alternar entre janelas na mesma sessão de tela | Ctrl+a → |
Eliminar a janela atual na sessão de Tela | Ctrl+a → |
Tela dividida
Com o Screen, é possível dividir o terminal em várias janelas:
Os comandos em screen são acessados usando Ctrl + a. Todos os comandos devem começar com esta combinação de teclas de acesso.
Se você estiver seguindo o codelab exatamente, será necessário ter duas janelas (FTD Commissioner, FTD Joiner) na mesma instância de Screen. Para dividir a tela entre os dois, primeiro insira sua sessão de tela existente:
$ screen -r
Você deve estar em um dos dispositivos de 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 ela for igual à janela superior, pressione Ctrl+a →
nnovamente para ver o outro dispositivo FTD.
Ambos estão visíveis. Alterne entre eles usando Ctrl+a → Tab. Recomendamos que você renomeie 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 de ot-daemon e o combinador RCP ot-ctl, esses serviços precisam ser iniciados na mesma instância da tela. Para fazer isso, pare o ot-daemon, saia do ot-ctl e reinicie-o em novas janelas de 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 com a linha de comando.
Para mais informações sobre a tela, 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 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 mais tarde.
Confirme este conjunto de dados como o ativo:
> dataset commit active Done
Abra a interface IPv6:
> ifconfig up Done
Inicie a operação do protocolo Thread:
> thread start Done
Depois de um momento, verifique o estado do dispositivo. Ele deve ser o líder. Receba 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 está visível quando verificada de outros dispositivos Thread.
De ot-ctl no Combinador RCP:
## RCP Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |
Na CLI do OpenThread no FTD Joiner (link em inglês):
## 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
A ativação de Thread não está ativa 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, anotamos a chave de rede, por exemplo, 1234c0de7ab51234c0de7ab51234c0de. Se você precisar pesquisar a chave de rede novamente, execute o seguinte comando 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 configurado corretamente.
## RCP Joiner ## ---------------- > dataset Network Key: 1234c0de7ab51234c0de7ab51234c0de
Abra o Thread para que o RCP Joiner entre na rede "codelab". Aguarde alguns segundos, verifique o estado, o 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 da rede local (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 de 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 RCP (o endereço local da malha obtido da saída do ipaddr) 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 composta de dois nós, ilustrados por este diagrama de topologia:
Diagramas de topologia
À medida que você trabalhar 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ã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 secundário mostrado na saída da CLI, dependendo do papel atual e do estado de cada nó no momento.
9. Comissão do Joiner FTD
Agora, vamos adicionar o terceiro dispositivo Thread à rede "codelab". Desta vez, usaremos o processo de comissionamento mais seguro na banda e permitiremos que somente o FTD Joiner participe.
No FTD Joiner, acesse o eui64 para que o FTD Commissioner possa identificá-lo:
## FTD Joiner ## ---------------- > eui64 2f57d222545271f1 Done
Em FTD Commissioner, inicie o Commissioner e especifique o eui64 do dispositivo que pode participar, junto com o Joiner Credential, por exemplo, J01NME. A credencial do combinador é uma string específica do dispositivo de todos os caracteres alfanuméricos em maiúsculas (0-9 e A-Y, exceto I, O, Q e Z para legibilidade), com tamanho entre 6 e 32 caracteres.
## FTD Commissioner ## ---------------------- > commissioner start Done > commissioner joiner add 2f57d222545271f1 J01NME Done
Alterne para o FTD Joiner. Inicie o papel de Combinador com a credencial de combinador que você acabou de configurar no FTD Commissioner:
## FTD Joiner ## ---------------- > ifconfig up Done > joiner start J01NME Done
Em aproximadamente um minuto, você receberá uma confirmação de autenticação:
## FTD Joiner ## ---------------- > Join success
Abra o 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 esse dispositivo não é o líder nem tem um papel específico do Anycast que requer um 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)
Mude imediatamente para o FTD Commissioner e verifique as tabelas do roteador e do filho para confirmar se existem 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 FTD Joiner se conectou à rede como um dispositivo final (filho). Veja nossa topologia atualizada:
10. Conversa em ação
Os dispositivos de encadeamento neste Codelab são um tipo específico de Dispositivo de encadeamento completo (FTD) chamado Dispositivo qualificado final do roteador (REED). Isso significa que eles podem funcionar como roteadores ou dispositivos finais e se promover de dispositivos finais a roteadores.
O Thread é compatível com até 32 roteadores, mas tenta manter o número de roteadores entre 16 e 23. Se um REED for conectado como um dispositivo final (filho) e o número de roteadores for inferior a 16, após um período aleatório de dois minutos, ele será promovido automaticamente a um roteador.
Se você tiver dois filhos na rede Thread após adicionar o FTD Joiner, aguarde pelo menos dois minutos e 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 estendido = e6cdd2d93249a243) se promoveu para um roteador. Observe que o RLOC16 é diferente (b800 em vez de 0c02). Isso porque o RLOC16 é baseado no ID do roteador e no ID secundário de um dispositivo. Quando ocorre a transição do dispositivo final para o roteador, os valores de ID do roteador e 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 Joiner do FTD
É possível testar esse comportamento com o downgrade manual do Combinador de 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
De volta ao FTD Commissioner, o FTD Joiner aparecerá na tabela filho (ID = 3). Ela pode até mesmo estar em ambas durante 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
Após algum tempo, ele retornará para um roteador com um RLOC de b800.
Remover o líder
O líder é escolhido 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 se tornará o novo líder.
No FTD Commissioner, encerre 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 da Thread. Verifique o estado e os endereços IPv6 do Combinador de 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. Esta é a ferramenta RCP Joiner, conforme indicado por seu código e Extended MAC. Para manter a rede Thread conjunta, ela alternou os roteadores pais, do FTD Commissioner para o FTD Joiner. Isso resulta em um novo RLOC16 para o Joiner RCP (porque o ID do roteador foi alterado 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 RCP Joiner seja conectado ao FTD como um filho. Verifique o estado e o RLOC16 para confirmar se:
## RCP Joiner ## -------------- > state child > rloc16 b801
Reanexar o FTD Commissioner
Uma rede Thread com dois nós não é muito divertida. Deixaremos o FTD Commissioner de volta on-line.
No FTD Commissioner, reinicie o Thread:
## FTD Commissioner ## ---------------------- > ifconfig up Done > thread start Done
Em dois minutos, ele se reconecta automaticamente à rede "codelab" como um dispositivo final e se promove como roteador.
## FTD Commissioner ## ---------------------- > state router Done
Verifique 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ê se perder na configuração (excesso de janelas ou telas na tela), continue encerrando janelas com Ctrl + A → k até que nenhuma exista, e screen -ls na linha de comando gera No Sockets found. Em seguida, recrie as janelas de tela para cada dispositivo. Os estados do dispositivo são mantidos, mesmo quando a tela é encerrada.
Nós da linha de execução
Se a topologia de rede Thread não for a descrita neste codelab ou os nós forem desconectados por algum motivo (talvez porque a máquina Linux que os colocou em suspensão), é melhor desativar o 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 para um grupo de dispositivos de uma só vez. Em uma rede Thread, os endereços específicos são reservados para uso multicast com diferentes grupos de dispositivos, dependendo do escopo.
Endereço IPv6 | Scope | Entregue em |
| Link local | Todos os FTDs e MEDs |
| Link local | Todos os FTDs e roteadores de borda |
| Rede local | Todos os FTDs e MEDs |
| Rede local | Todos os 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 um único "hop". A topologia de rede determina quais dispositivos respondem a um ping para o endereço multicast ff02::1.
Dê um ping em 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 só recebeu uma resposta do endereço link-local (LLA, na sigla em inglês) do combinador de FTD. Isso significa que o FTD Joiner é o único dispositivo que o FTD Commissioner pode alcançar 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, podemos ver que o primeiro (que termina em 4b1d) é o LLA do FTD Commissioner e o segundo (que termina em 943b) é o LLA do Combinador RCP.
Isso significa que o FTD Joiner é conectado diretamente ao FTD Commissioner e RCP Joiner, o que confirma nossa topologia.
Rede local
O escopo mesh-local abrange todas as interfaces Thread acessíveis na mesma rede Thread. Vamos ver as respostas para um ping no endereço multicast ff03::1.
Dê um ping em 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 Localizador de roteamento do Combinador de FTD (RLOC, terminando em b800) e outra do EID do Mesh-Local do Combinador de RCP (ML-EID, terminando em d55f). Isso ocorre porque o escopo local da malha abrange toda a rede Thread. Independentemente de onde o dispositivo esteja na rede, ele será inscrito no endereço ff03::1.
Dê um ping em ff03::1 do 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 demorou muito mais para chegar ao Comissário de FTD (68 ms) do que para alcançar o Combinador de FTD (23 ms). Isso ocorre porque é preciso fazer dois saltos para alcançar o Comissário de FTD, em comparação com um salto para o Combinador de FTD.
Talvez você também tenha notado que o ping multicast local da rede respondeu com o RLOC apenas para os dois FTDs, não para o RCP Joiner. Isso ocorre porque os FTDs são roteadores dentro da rede, enquanto o RCP é um dispositivo final.
Verifique o estado do combinador RCP para confirmar:
## RCP Joiner ## ---------------- > state child
13. Enviar mensagens com UDP
Um dos serviços de aplicativo que o OpenThread oferece é o User Datagram Protocol (UDP), um protocolo de camada de transporte. Um aplicativo criado no OpenThread pode usar a API UDP para passar mensagens entre nós em uma rede Thread ou para outros dispositivos em uma rede externa (como a Internet, se a rede Thread tiver 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 FTD Joiner. 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-o ao soquete configurado no FTD Joiner usando o ML-EID dele:
## FTD Commissioner ## ---------------------- > udp open Done > udp connect fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd 1212 Done
A conexão UDP precisa estar ativa 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, papéis e escopos de dispositivos Thread
- como os dispositivos Thread gerenciam os estados na rede.
- como transmitir mensagens simples entre nós usando UDP
Próximas etapas
Com base neste codelab, faça os seguintes exercícios:
- Atualize a placa do FTD Joiner como um MTD usando o binário
ot-cli-mtde observe que ele nunca se atualiza para um roteador ou tenta se tornar o líder. - Adicionar mais dispositivos (tente uma plataforma diferente) à rede e esboçar a topologia usando tabelas de roteador e filhas, além de pings para os endereços multicast
- Use pyspinel para controlar o NCP
- Converta o NCP em um roteador de borda usando o OpenThread Border Router e conecte sua rede Thread à Internet
Leia mais
Acesse openthread.io e GitHub para conferir uma variedade de recursos do OpenThread, incluindo:
- Plataformas compatíveis: descubra todas as plataformas compatíveis com o OpenThread
- Criar OpenThread: mais detalhes sobre como criar e configurar o OpenThread
- Thread Primer: abrange todos os conceitos da linha de execução apresentados neste codelab.
Referência: