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

1. Introdução

26b7f4f6b3ea0700.png

A OpenThread lançada pelo Google é uma implementação de código aberto do protocolo de rede Thread®. O Google Nest lançou o OpenThread para disponibilizar amplamente a tecnologia usada nos produtos Nest para desenvolvedores e acelerar o desenvolvimento de produtos para a casa conectada.

A especificação 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 Thread, incluindo IPv6, 6LoWPAN, IEEE 802.15.4 com segurança MAC, estabelecimento de link de malha e roteamento de malha.

Neste codelab, você criará 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 em placas de desenvolvimento
  • Como criar um RCP que consiste em uma máquina Linux e uma placa de desenvolvedor
  • Comunicação com um RCP usando o Thread Openemem e ot-ctl
  • Como gerenciar manualmente os nós da linha de execução 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

Pré-requisitos

Hardware:

  • 3 placas de desenvolvimento semicondutores nRF52840
  • Três cabos USB para micro USB para conectar as placas
  • Um computador Linux com pelo menos três portas USB

Software:

  • Conjunto de ferramentas GNU
  • Ferramentas de linha de comando nRF5x nórdica
  • Software Segger J-Link
  • OpenThread
  • Git

2. Primeiros passos

Simulação de OpenThread

Antes de começar, consulte o Codelab de simulação do OpenThread para se familiarizar com os conceitos básicos 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 criado para usar uma máquina Linux baseada em i386 ou x86 para servir como host de um dispositivo Thread de processador coprocessador (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 np52840 PDK (link em inglês).

a6693da3ce213856.png

Nós usamos o SEGGER J-Link para programar as placas nRF52840, que têm módulos JTAG integrados. Instale este arquivo no seu computador Linux.

Faça o download do pacote adequado para sua máquina e instale-o no local apropriado. No Linux, /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 para as placas nRF52840. Instale o build nRF5x-Command-Line-Tools-<OS> adequado na sua máquina Linux.

Coloque o pacote extraído na pasta raiz ~/

Instalar o ARM GNU Toolchain

O conjunto de ferramentas GNU GNU é usado para criar.

Recomendamos colocar 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 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 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 que 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 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 OpenThread nRF52840 com combinador e 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 transporte serial entre nRF52840 e o host.

Sempre limpe o repositório de builds anteriores executando rm -rf build.

$ 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. Defina a chave fonte de energia nRF na placa nRF52840 como VDD. Quando conectado corretamente, o LED5 está ativado.

20a3b4b480356447

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 que está sendo usada para a RCP:

c00d519ebec7e5f0.jpeg

Navegue até o local das ferramentas de linha de comando nRFx e atualize o arquivo hexadecimal OpenThread RCP na placa nRF52840 usando o número de série da placa. Ao omitir a sinalização --verify, 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 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 que mais tarde você não confunda os papéis do board.

Conectar ao USB nativo

Como o build do RCP do OpenThread permite o uso do USB CDC ACM nativo como transporte serial, é preciso usar a porta nRF USB na placa nRF52840 para se comunicar com o host do RCP (máquina Linux).

Remova 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. Mude a chave da fonte de energia nRF para USB.

46e7b670d2464842.png

Iniciar daemon da OpenThread

No design do RCP, use o Thread Openemon para se comunicar e gerenciar o dispositivo Thread. Inicie o ot-daemon com a sinalização detalhada -v para ver a saída do registro e confirmar que ele está em execução:

$ cd ~/src/openthread
$ ./build/posix/src/posix/ot-daemon -v \
    'spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=115200'

Quando bem-sucedido, o ot-daemon no modo detalhado gera uma saída semelhante a esta:

ot-daemon[228024]: Running OPENTHREAD/20191113-00831-gfb399104; POSIX; Jun  7 2020 18:05:15
ot-daemon[228024]: Thread version: 2
ot-daemon[228024]: RCP version: OPENTHREAD/20191113-00831-gfb399104; SIMULATION; Jun  7 2020 18:06:08

Deixe esta janela do terminal aberta para que os registros de ot-daemon possam ser visualizados.

Use ot-ctl para se comunicar com o nó RCP. O ot-ctl usa a mesma CLI que o app de CLI OpenThread. Portanto, você pode controlar os nós ot-daemon da mesma forma que os outros dispositivos Thread simulados.

Em uma segunda janela de terminal, inicie ot-ctl:

$ ./build/posix/bin/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) no design padrão do system on chip (SoC). Em uma configuração de produção, é possível usar o wpantund, um driver de interface de rede de nível de produção, para controlar as instâncias de NCP do OpenThread. No entanto, neste codelab, usaremos o ot-ctl, a CLI do OpenThread.

Um dispositivo funciona como o encomendado, para autenticar e comissionar dispositivos com segurança nessa rede. O outro dispositivo funciona como um Combinador 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 da CLI 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 na placa nRF52840 e 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, anote o número de série da placa nRF52840 em uso no FTD:

c00d519ebec7e5f0.jpeg

Navegue até o local das ferramentas de linha de comando nRFx e atualize o arquivo hexadecimal FTD do OpenThread CLI 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ão".

Conectar ao USB nativo

Como o build FTD do OpenThread permite o uso do USB CDC ACM nativo como transporte serial, é preciso usar a porta nRF USB na placa nRF52840 para se comunicar com o host do RCP (máquina Linux).

Remova 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. Mude a chave da fonte de energia nRF para USB.

46e7b670d2464842.png

Verificar build

Verifique 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 de velocidade de 115.200.

$ screen /dev/ttyACM1 115200

Na nova janela, pressione Enter no teclado algumas vezes para abrir a solicitação CLI > do OpenThread. Ative a interface IPv6 e verifique os 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 que a próxima placa possa ser atualizada. Para digitar 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 existente. Quando terminar, reconecte a placa ao PC usando a porta USB nRF e defina a chave da fonte de energia nRF como VDD.

Se os outros dois nós estiverem anexados à máquina Linux quando a terceira placa estiver anexada, ela aparecerá como a porta serial /dev/ttyACM2:

$ ls /dev/ttyACM*
/dev/ttyACM0  /dev/ttyACM1  /dev/ttyACM2

Marque o tabuleiro "Combinador"

Ao verificar usando a tela, em vez de criar uma nova instância de tela na linha de comando, anexe-a novamente à atual e crie uma nova janela dentro da tela (que você usou para o FTD Commissioner):

$ screen -r

Crie a nova janela na tela pressionando Ctrl+A → c.

Um novo prompt de linha de comando será exibido. Acesse a CLI do OpenThread para o Combinador FTD:

$ screen /dev/ttyACM2 115200

Nessa nova janela, pressione Enter no teclado algumas vezes para abrir a solicitação CLI > do OpenThread. Ative 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.

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, portanto, verifique se todos estão ativos e acessíveis. Até o momento, usamos a tela para acessar os dois FTDs, e essa ferramenta também permite dividir a tela na mesma janela do terminal. Use-o para ver como um nó reage a comandos emitidos em outro.

O ideal é que quatro janelas estejam disponíveis:

  1. Serviço / registros do ot-daemon
  2. Combinador de RCP pelo ot-ctl
  3. FTD Commissioner pela CLI do OpenThread
  4. FTD Joiner (link em inglês) 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 preferir.

Como usar a tela

Para facilitar o uso, inicie apenas uma sessão de tela. Você já deve ter um cartão ao configurar os dois FTDs.

Todos os comandos no Screen começam com Ctrl+a.

Comandos básicos de tela:

Reanexar à sessão de tela (da 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 de tela

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

Fechar a janela atual na sessão "Tela"

Ctrl + A → k

Tela dividida

Com o Screen, você pode 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 essa combinação de teclas de acesso.

Se você estiver seguindo o codelab exatamente, precisará 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 usar 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 entre uma nova janela e a próxima
  4. Se for igual à janela superior, pressione Ctrl+a → n novamente para ver o outro dispositivo FTD.

Agora ambos estão visíveis. Alterne entre eles usando Ctrl+a → Tab. Para evitar confusão, recomendamos que você renomeie cada janela com Ctrl+a → A.

Uso avançado

Para dividir ainda mais a tela em quadrantes e visualizar os registros ot-daemon e o Combinador de RCP ot-ctl, esses serviços precisam ser iniciados na mesma instância de tela. Para fazer isso, pare ot-daemon e saia de ot-ctl. Em seguida, reinicie-os em novas janelas de tela (Ctrl+a → c).

Essa configuração não é obrigatória e é um exercício para o usuário.

Divida e navegue entre janelas usando estes 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

Deixe a tela a qualquer momento com Ctrl + A → d e anexe novamente à tela usando a linha de comando screen -r.

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-o como o ativo. O conjunto de dados operacional é a configuração da 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

Chame a interface IPv6:

> ifconfig up
Done

Inicie a operação do protocolo da linha de execução:

> thread start
Done

Aguarde um momento e verifique o estado do dispositivo. 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)

Agora, a rede "codelab" está visível quando é verificada em outros dispositivos Thread.

De ot-ctl no Combinador de RCP:

## RCP Joiner ##
----------------

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |

Na CLI do OpenThread no FTD Joiner (link em inglês):

## FTD Joiner ##
----------------

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |

Se a rede "codelab" não aparecer na lista, tente verificar novamente.

Em ambas as verificações, a rede não pode ser junta (coluna J no Combinador de RCP e no Combinador FTD). Isso significa apenas que o Thread Commissioning não está ativo na rede. Ele ainda pode ser mesclado fora de banda, inserindo a chave de rede no dispositivo de junção manualmente.

8. Adicionar o combinador RCP

Vamos adicionar o RCP Joiner à rede Thread que acabamos de criar, usando um processo fora de banda. Verifique as redes no Combinador de RCP:

## RCP Joiner ##
----------------

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |

Para participar, defina a chave de rede (que acabamos de obter do comissionador FTD) no disjuntor RCP no conjunto de dados ativo.

## 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 o Thread para participar da rede "codelab" Aguarde alguns segundos e verifique o estado, o RLOC16 e os endereços IPv6:

## RCP Joiner ##
----------------

> 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 malha local (fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f aqui). Você o usará mais tarde.

De volta ao comissionador FTD, verifique as tabelas do roteador e do filho para confirmar se ambos os 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 mesh local obtido da saída de 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 composta por 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 linhas de execução 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 ID filho mostrado na saída da CLI, dependendo do papel atual e do estado de cada nó naquele momento.

9. Comissionador do FTD

Agora, vamos adicionar o terceiro dispositivo Thread à rede "codelab" Desta vez, vamos usar o processo de comissionamento mais seguro. No FTD Joiner, verifique a rede:

## FTD Joiner ##
----------------

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | f65ae2853ff0c4e4 | 11 | -36 |  57 |

Um 0 na coluna J indica que o uso de Thread Commissioning não está ativo no dispositivo.

Seja específico no momento do comissionamento no próximo dispositivo e só permita que o FTD combine. Ainda no Combinador FTD, 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 ser mesclado, além da credencial do Combinador, como J01NME. A credencial do combinador é uma string específica de dispositivo de todos os 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

Alterne para o FTD Joiner e faça uma nova verificação:

## FTD Joiner ##
----------------

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 1 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -45 | 196 |

Como indicado pelo 1 na coluna J, o Thread Commissioning agora está ativo na rede. Inicie o papel de Combinador com a credencial do 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 uma autenticação bem-sucedida:

## FTD Joiner ##
----------------

>
Join success

Chame 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. Não há ALOC. Isso ocorre porque este dispositivo não é o líder nem possui uma função específica 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 confira 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 Combinador FTD se conectou à rede como um Dispositivo Final (filho). Veja nossa topologia atualizada:

otcodelab_top01C_ed01.png

10. Conversa em ação

Os dispositivos Thread neste codelab são um tipo específico de dispositivo de linha de execução completa (FTD) chamado Dispositivo qualificado para o roteador final (REED). Isso significa que podem funcionar como um roteador ou dispositivo final e se promover de um dispositivo final para 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 for anexado como um dispositivo final (filho) e o número de roteadores for menor que 16, após um período aleatório dentro de dois minutos, ele será promovido automaticamente a um roteador.

Se 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 longo estendido = e6cdd2d93249a243) se promoveu para um roteador. Observe que o RLOC16 é diferente (b800 em vez de 0c02). Isso acontece porque o RLOC16 é baseado no ID do roteador e no ID filho de um dispositivo. Quando ocorre a transição do dispositivo final para o roteador, os valores de código do roteador e 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 combinador FTD

É possível testar esse comportamento fazendo o downgrade manual do Combinador de FTD de um roteador de volta para um dispositivo final. Mude 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 Commissioner vai aparecer na tabela filha (ID = 3). Ele pode até mesmo estar na fase de 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 um 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 Thread. 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, desligue a Thread para removê-la da rede Thread:

## FTD Commissioner ##
----------------------

> thread stop
Done
> ifconfig down
Done

Em dois minutos, o FTD Joiner se torna o novo líder de linhas de execução. 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. Veja que há um novo RLOC16. Esse é o combinador de RCP, conforme indicado pelo ID e pelo MAC estendido. Para manter a rede Thread juntos, ela trocou de roteador pai do comissário de FTD para o combinador 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 até que o Combinador de RCP seja anexado ao Combinador de 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. Vamos voltar a exibir o FTD Commissioner.

No FTD Commissioner, reinicie a linha de execução:

## FTD Commissioner ##
----------------------

> ifconfig up
Done
> thread start
Done

Em dois minutos, ele se reconecta automaticamente à rede "codelab" como um dispositivo final, e depois se autopromove a um 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. Solucionar 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 espaço de trabalho se você encontrar problemas.

Screen

Se alguma vez você se perder na configuração (por exemplo, muitas janelas de tela ou telas dentro da tela), continue a desativar as janelas de tela com as teclas Ctrl+a → k até não haver nenhuma e o screen -ls na linha de comando gerar 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 da linha de execução não for a descrita neste codelab ou os nós se desconectarem por algum motivo (talvez porque a máquina Linux que os iniciou parou de funcionar), é melhor desativar a linha de execução, limpar as credenciais de rede e começar novamente da etapa Criar a rede de linha de execução.

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 o multicast

O multicast é usado para comunicar informações para um grupo de dispositivos de uma só vez. Em uma rede Thread, endereços específicos são reservados para uso multicast com diferentes grupos de dispositivos, dependendo do escopo.

Endereço IPv6

Escopo

Entregue a

ff02::1

Link local

Todos os FTDs e MEDs

ff02::2

Link local

Todos os FTDs e roteadores de borda

ff03::1

Rede mesh local

Todos os FTDs e MEDs

ff03::2

Rede mesh 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 compreende todas as interfaces Thread acessíveis por uma única transmissão de rádio ou por um único "hop." A topologia da rede determina quais dispositivos respondem a um ping para o endereço multicast ff02::1.

Dê um ping na ff02::1 no 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

Há dois outros dispositivos na rede (FTD Joiner e RCP Joiner), mas o FTD Commissioner só recebeu uma resposta do FTD Joiner&l39;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 no ff02::1 usando o 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 (terminado em 4b1d) é o LLA do FTD Commissioner, e o segundo (que termina em 943b) é o RCP Joiner's LLA.

otcodelab_top02C_02_LL02.png

Isso significa que o combinador FTD está diretamente conectado ao FTD Commissioner e ao RCP Joiner, o que confirma nossa topologia.

Rede mesh local

O escopo mesh-local compreende todas as interfaces Thread acessíveis na mesma rede Thread. Vamos ver as respostas de um ping para o endereço multicast ff03::1.

Dê um ping na ff03::1 no 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's Routing Finder (RLOC, que termina em b800) e outra do RCP Joiner's Mesh-Local EID (ML-EID, terminando em d55f). Isso ocorre porque o escopo mesh-local compreende toda a rede Thread. Independentemente da rede em que o dispositivo está, ele será inscrito no endereço ff03::1.

otcodelab_top02C_02_ML.png

Dê um ping no ff03::1 usando o 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 combinador de RCP nas duas saídas de ping. O Combinador de RCP levou muito mais tempo para alcançar o Comissão de FTD (68 ms) do que para chegar ao Comissário de FTD (23 ms). Isso ocorre porque é preciso fazer dois saltos para chegar ao FTD Commissioner, em comparação a um salto para o FTD Joiner.

Talvez você também tenha percebido que o ping multicast mesh local respondeu com o RLOC somente para os dois FTDs, e não para o Combinador de RCP. Isso acontece porque os FTDs são roteadores dentro da rede, enquanto o RCP é um dispositivo final.

Verifique o estado do Combinador de RCP para confirmar:

## RCP Joiner ##
----------------

> state
child

13. Enviar mensagens com UDP

Um dos serviços de aplicativo oferecidos pelo OpenThread é o protocolo de datagramas do usuário (UDP), um protocolo de camada de transporte. Um app 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 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

Mude para o FTD Commissioner, inicie o UDP e conecte-se ao soquete que você configurou no FTD Joiner usando o 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 ativa entre os dois nós. Envie uma mensagem do FTD Commissioner:

## FTD Commissioner ##
----------------------

> udp send hellothere
Done

A mensagem UDP foi recebida no FTD Joiner.

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

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

  • Faça uma nova atualização da placa do FTD 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 outra plataforma) à rede e esboçar a topologia usando roteador e tabelas filhas, junto com pings para os endereços de multicast
  • Usar pyspinel para controlar o NCP
  • Converta o NCP em um roteador de borda usando o OpenBorder Border Router e conecte sua rede Thread à Internet.

Leitura adicional

Acesse openthread.io e GitHub para ver uma variedade de recursos do OpenThread, incluindo:

Referência: