Crie uma rede Thread com placas nRF52840 e OpenThread

1. Introdução

26b7f4f6b3ea0700.png

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.

4806d16a8c137c6d.jpeg

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

a6693da3ce213856.png

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.

20a3b4b480356447.png

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:

c00d519ebec7e5f0.jpeg

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.

46e7b670d2464842.png

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:

c00d519ebec7e5f0.jpeg

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.

46e7b670d2464842.png

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:

  1. Serviço / registros do ot-daemon
  2. Combinador RCP via ot-ctl
  3. FTD Commissioner: CLI do OpenThread
  4. 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)

screen -r

Sair da sessão de tela

Ctrl+a → d

Criar nova janela na sessão de tela

Ctrl+a → c

Alternar entre janelas na mesma sessão de tela

Ctrl+a → n (para frente)Ctrl+a → p (voltar)

Eliminar a janela atual na sessão de Tela

Ctrl+a → k

Tela dividida

Com o Screen, é possível dividir o terminal em várias janelas:

f1cbf1258cf0a5a.png

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:

  1. Ctrl+a → S para dividir a janela horizontalmente
  2. Ctrl+a → Tab para mover o cursor para a nova janela em branco
  3. Ctrl+a → n para alternar a nova janela para a próxima
  4. Se ela for igual à janela superior, pressione Ctrl+a → n novamente 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 → c

Dividir janela verticalmente

Ctrl+a →

Dividir janela horizontalmente

Ctrl+a → S

Ir para a próxima janela exibida

Ctrl+a → Tab

Alternar a janela exibida para frente ou para trás

Ctrl+a → n ou p

Renomear a janela atual

Ctrl+a → 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:

otcodelab_top01C_2nós.png

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:

b75a527be4563215.png

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:

otcodelab_top01C_ed01.png

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.

otcodelab_top01C.png

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

otcodelab_top01C_ed02.png

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.

otcodelab_top01C.png

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

otcodelab_top02C_01.png

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

otcodelab_top02C_02.png

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

ff02::1

Link local

Todos os FTDs e MEDs

ff02::2

Link local

Todos os FTDs e roteadores de borda

ff03::1

Rede local

Todos os FTDs e MEDs

ff03::2

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.

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.

otcodelab_top02C_02_LL.png

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.

otcodelab_top02C_02_LL02.png

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.

otcodelab_top02C_02_ML.png

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

otcodelab_top02C_02_LL02.png

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.

b915c433e7027cc7.png

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-mtd e 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:

Referência: