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

Crie uma rede Thread com placas nRF52840 e OpenThread

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

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

4806d16a8c137c6d.jpeg

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.

a6693da3ce213856.png

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.

20a3b4b480356447.png.

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:

c00d519ebec7e5f0.jpeg

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.

46e7b670d2464842.png.

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:

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

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.

46e7b670d2464842.png.

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:

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

screen -r

Sair da sessão de tela

Ctrl + A → d

Criar uma nova janela na sessão de tela

Ctrl + A → c

Alternar entre janelas na mesma sessão do Screen

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

encerrar a janela atual na sessão de tela;

Ctrl + A → k

Tela dividida

Com o Screen, você pode dividir o terminal em várias janelas:

f1cbf1258cf0a5a.png

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:

  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 for igual à janela superior, Ctrl+a → n novamente 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 → 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 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:

otcodelab_top01C_2nós.png

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:

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

Otcodelab_top01C_ed01.png

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.

Otcodelab_top01C.png

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

Otcodelab_top01C_ed02.png

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.

Otcodelab_top01C.png

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

Otcodelab_top02C_01.png

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

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ê 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

ff02::1

Link local

FTDs e MEDs

ff02::2

Link local

FTDs e roteadores de borda

ff03::1

Rede mesh local

FTDs e MEDs

ff03::2

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.

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.

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, vemos que o primeiro (que termina em 4b1d) é o LLA do FTD Commissioner e o que termina em 943b é o RCP Joiner's LLA.

Otcodelab_top02C_02_LL02.png

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.

Otcodelab_top02C_02_ML.png

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

Otcodelab_top02C_02_LL02.png

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!

b915c433e7027cc7.png

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

Referência: