Construir uma rede Thread com placas nRF52840 e OpenThread

26b7f4f6b3ea0700.png

OpenThread lançado pela Google é uma implementação open-source do Thread® protocolo de rede. O Google Nest lançou o OpenThread para tornar a tecnologia usada nos produtos Nest amplamente disponível para desenvolvedores a fim de acelerar o desenvolvimento de produtos para casas conectadas.

A especificação da linha define um protocolo de comunicação sem fios baseados em IPv6 fiável, segura e de baixo consumo de dispositivo para dispositivo para aplicações domésticas. OpenThread implementa todas as camadas de rede Thread, incluindo IPv6, 6LoWPAN, IEEE 802.15.4 com segurança MAC, Mesh Link Establishment e Mesh Routing.

Neste Codelab, você programará OpenThread em hardware real, criará e gerenciará uma rede Thread e passará mensagens entre nós.

4806d16a8c137c6d.jpeg

O que você aprenderá

  • Construindo e atualizando binários OpenThread CLI para placas de desenvolvimento
  • Construir um RCP que consiste em uma máquina Linux e uma placa de desenvolvimento
  • Comunicando com uma RCP utilizando OpenThread daemon e ot-ctl
  • Gerenciando manualmente Thread nodes com Screen e OpenThread CLI
  • Comissionamento seguro de dispositivos em uma rede Thread
  • Como funciona o multicast IPv6
  • Passando mensagens entre nós de thread com UDP

O que você precisará

Hardware:

  • 3 placas dev Nordic Semiconductor nRF52840
  • 3 cabos USB para micro-USB para conectar as placas
  • Uma máquina Linux com pelo menos 3 portas USB

Programas:

  • GNU Toolchain
  • Ferramentas de linha de comando Nordic nRF5x
  • Software Segger J-Link
  • OpenThread
  • Git

Simulação OpenThread

Antes de começar, você pode querer executar através do OpenThread Simulação Codelab , para se familiarizar com os conceitos de Tópicos básicos ea OpenThread CLI.

Terminais de porta serial

Você deve estar familiarizado com a conexão a uma porta serial por meio de um terminal. Este Codelab usa Screen 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 para um dispositivo Thread de Co-Processador de Rádio (RCP) e para atualizar todas as placas de desenvolvimento de Thread. Todas as etapas foram testadas no Ubuntu 14.04.5 LTS (Trusty Tahr).

Placas Nordic Semiconductor nRF52840

Este Codelab usa três placas nRF52840 PDK .

a6693da3ce213856.png

Usamos SEGGER J-Link para programar as placas nRF52840, que possuem módulos JTAG integrados. Instale isso em sua máquina Linux.

Baixe o pacote de software e documentação da J-Link

Baixe o pacote apropriado para sua máquina e instale-o no local apropriado. No Linux isso é /opt/SEGGER/JLink .

Instale as ferramentas de linha de comando nRF5x

As ferramentas de linha de comando nRF5x permitem que você atualize os binários OpenThread para as placas nRF52840. Instale a compilação nRF5x-Command-Line-Tools- <OS> apropriada em sua máquina Linux.

Baixe ferramentas de linha de comando nRF5x

Coloque o pacote extraído na pasta raiz ~/

Instalar ARM GNU Toolchain

O ARM GNU Toolchain é usado para construção.

Baixe o arquivo portátil ARM GNU Toolchain

Recomendamos colocar o extraído do arquivo em /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ em sua máquina Linux. Siga as instruções no arquivo de readme.txt arquivo para instruções de instalação.

Tela de instalação (opcional)

Screen é uma ferramenta simples para acessar dispositivos conectados por uma porta serial. Este Codelab usa Screen, mas você pode usar qualquer aplicativo de terminal de porta serial que desejar.

$ sudo apt-get install screen

OpenThread

Clone e instale o OpenThread. As script/bootstrap comandos certifique-se o conjunto de ferramentas é instalado e o ambiente está configurado corretamente:

$ mkdir -p ~/src
$ cd ~/src
$ git clone --recursive https://github.com/openthread/openthread.git
$ cd openthread
$ ./script/bootstrap

Build OpenThread Daemon:

$ script/cmake-build posix -DOT_DAEMON=ON

Agora você está pronto para construir e atualizar OpenThread para as placas nRF52840.

Construir e atualizar

Construa o exemplo OpenThread nRF52840 com Joiner e funcionalidade USB nativa. Um dispositivo usa a função Joiner para ser autenticado e comissionado com segurança em uma rede Thread. O USB nativo permite o uso de USB CDC ACM como um transporte serial entre o nRF52840 e o host.

Limpe sempre o repo de construções anteriores primeiro, 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 OpenThread RCP 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 de alimentação externa na placa nRF52840 e, em seguida, conecte-o à máquina Linux. Coloque o interruptor de fonte de energia NRF na placa nRF52840 a VDD. Quando conectado corretamente, LED5 está ligado.

20a3b4b480356447.png

Se esta for a primeira placa ligada à máquina Linux, ela aparece como porta serial /dev/ttyACM0 (todas as placas nRF52840 usar ttyACM para o identificador de porta série).

$ ls /dev/ttyACM*
/dev/ttyACM0

Observe o número de série da placa nRF52840 sendo usada para o RCP:

c00d519ebec7e5f0.jpeg

Navegue até a localização 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:

$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --chiperase --program \
       ~/src/ot-nrf528xx/build/bin/ot-rcp.hex --reset

A seguinte saída é gerada em caso de 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 a placa como "RCP" para que mais tarde você não confunda as funções da placa.

Conecte ao USB nativo

Porque a construção OpenThread RCP permite o uso de USB nativa CDC ACM como um transporte de série, você deve usar a porta USB NRF na placa nRF52840 para se comunicar com o anfitrião RCP (máquina Linux).

Retire o final Micro-USB do cabo USB da porta de depuração do brilhou bordo nRF52840, em seguida, recoloque-o para a NRF porta USB Micro-USB ao lado do botão RESET. Coloque o interruptor de fonte de energia NRF para USB.

46e7b670d2464842.png

Iniciar OpenThread Daemon

No design RCP, use o OpenThread Daemon para se comunicar e gerenciar o dispositivo Thread. Comece ot-daemon com o -v detalhado bandeira para que você possa ver a saída log e confirme que ele está sendo executado:

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

Quando for bem sucedida, ot-daemon no modo detalhado gera uma saída semelhante à que se segue:

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 tão aberto terminal que toras de ot-daemon pode ser visualizado.

Use ot-ctl para se comunicar com o nó RCP. ot-ctl usa o mesmo CLI como o aplicativo OpenThread CLI. Portanto, você pode controlar ot-daemon nós da mesma forma como os outros dispositivos de Tópicos simulados.

Em uma segunda janela do terminal, iniciar ot-ctl :

$ ./output/posix/bin/ot-ctl
>

Verifique o state do nó 2 (o nó RCP) você começou com ot-daemon :

> state
disabled
Done

Os outros dois nós Thread usados ​​neste Codelab são Full Thread Devices (FTDs) no design System-on-Chip (SoC) padrão. Eles não usam wpantund , eo usuário consegue-los manualmente com o OpenThread CLI.

Um dispositivo funciona como o Comissário, para autenticar e comissionar dispositivos nessa rede com segurança. O outro dispositivo funciona como um Joiner que o Comissário pode autenticar na rede Thread.

Construir e flash

Construa o exemplo OpenThread FTD para a plataforma nRF52840, com as funções de Comissário e Joiner habilitadas:

$ 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 Full 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 de alimentação externa na placa nRF52840 e, em seguida, conecte-o à máquina Linux. Se a RCP ainda está ligado à máquina Linux, esta nova placa deve aparecer como porta serial /dev/ttyACM1 (todas as placas nRF52840 usar ttyACM para o identificador de porta serial).

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

Como antes, observe o número de série da placa nRF52840 que está sendo usada para o FTD:

c00d519ebec7e5f0.jpeg

Navegue até a localização das ferramentas de linha de comando nRFx e atualize o arquivo hex OpenThread CLI FTD na placa nRF52840, usando o número de série da placa:

$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --chiperase --program \
       ~/src/ot-nrf528xx/build/bin/ot-cli-ftd.hex --reset

Rotule o quadro como "Comissário".

Conecte ao USB nativo

Porque a construção OpenThread FTD permite o uso de USB nativa CDC ACM como um transporte de série, você deve usar a porta USB NRF na placa nRF52840 para se comunicar com o anfitrião RCP (máquina Linux).

Retire o final Micro-USB do cabo USB da porta de depuração do brilhou bordo nRF52840, em seguida, recoloque-o para a NRF porta USB Micro-USB ao lado do botão RESET. Coloque o interruptor de fonte de energia NRF para USB.

46e7b670d2464842.png

Verificar construção

Verifique se a construção foi bem-sucedida acessando a CLI OpenThread usando GNU Screen a partir de uma janela de terminal. As placas nRF52840 usam uma taxa de transmissão de 115200.

$ screen /dev/ttyACM1 115200

Na nova janela, pressione Enter no teclado algumas vezes para abrir o OpenThread CLI > alerta. Abra 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 separar a partir do ecrã FTD Comissário CLI e retorno ao modo terminal do Linux que a próxima placa pode ser brilhou. Para voltar a entrar no CLI, a qualquer momento, o uso screen -r na linha de comando. Para ver uma lista de telas disponíveis, o uso screen -ls :

$ screen -ls
There is a screen on:
        74182.ttys000.mylinuxmachine        (Detached)
1 Socket in /tmp/uscreens/S-username.

Configurar o FTD Joiner

Repetir o processo acima a piscar a terceira placa nRF52840, usando a existente ot-cli-ftd.hex compilação.

Se os outros dois nós estão ligados à máquina Linux quando este terceiro conselho é ligado, ele deve aparecer como porta serial /dev/ttyACM2 :

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

Identifique o quadro como "Joiner".

Ao verificar usando a Tela, em vez de criar uma nova instância da Tela a partir da linha de comando, reconecte à existente e faça uma nova janela dentro dela (que você usou para o Comissário FTD):

$ screen -r

Crie a nova janela na Tela com Ctrl + a →

c

****. Um novo prompt de linha de comando é exibido. Acesse a CLI OpenThread para o FTD Joiner:

$ screen /dev/ttyACM2 115200

Nesta nova janela, pressione Enter no teclado algumas vezes para abrir o OpenThread CLI > alerta. Abra a interface IPv6 e verifique os endereços:

> ifconfig up
Done
> ipaddr
fe80:0:0:0:6c1e:87a2:df05:c240
Done

Agora que o FTD Joiner CLI está na mesma instância de tela como o FTD Comissário, você pode alternar entre eles usando Ctrl + a → n .

Use Ctrl + a →

d a qualquer momento para tela de saída.

Daqui para frente, você alternará entre os dispositivos Thread com frequência, portanto, certifique-se de que todos eles estejam ativos e facilmente acessíveis. Até agora, utilizamos o Screen para acessar os dois FTDs, e esta ferramenta também permite dividir a tela na mesma janela do terminal. Use isso para ver como um nó reage aos comandos emitidos em outro.

Idealmente, você deve ter quatro janelas disponíveis:

  1. ot-daemon de serviços / logs
  2. RCP Joiner via ot-ctl
  3. FTD Comissário via OpenThread CLI
  4. FTD Joiner via OpenThread CLI

Se desejar usar sua própria configuração ou ferramenta de terminal / porta serial, pule para a próxima etapa. Configure as janelas do terminal para todos os dispositivos da maneira que for melhor para você.

Usando a tela

Para facilidade de 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 de tela básicos:

Reconecte-se à sessão de tela (a partir da linha de comando)

screen -r

Sair da sessão de tela

Ctrl + um → d

Criar nova janela dentro da sessão de tela

Ctrl + um → c

Alternar entre janelas na mesma sessão de tela

Ctrl + um → n (para a frente) Ctrl + → um p (parte de trás)

Mata a janela atual na sessão de tela

Ctrl + um → k

Tela dividida

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

f1cbf1258cf0a5a.png

Comandos no screen são acessados usando Ctrl + a. Cada comando deve começar com esta combinação de teclas de acesso.

Se você está seguindo o Codelab exatamente, deve ter duas janelas (FTD Commissioner, FTD Joiner) na mesma instância de Tela. Para dividir a tela entre as duas, primeiro entre em sua sessão de tela existente:

$ screen -r

Você deve estar em um dos dispositivos FTD. Siga estas etapas na tela:

  1. Ctrl + um → S para dividir a janela horizontal
  2. Ctrl + a → Tab para mover o cursor para a nova janela em branco
  3. Ctrl + a → n ao interruptor que nova janela para a próxima
  4. Se for a mesma que a janela de topo, um Ctrl + → n novamente para ler o outro dispositivo FTD

Eles agora estão ambos visíveis. Alternar entre eles usando Ctrl + a → Tab . É recomendável que você modifique o título de cada janela com Ctrl + a → A para evitar confusão.

Uso avançado

Para mais dividir a tela em quadrantes e ver os ot-daemon logs eo RCP Joiner ot-ctl , esses serviços devem ser iniciados dentro desta mesma instância da tela. Para fazer isso, parar ot-daemon e saída ot-ctl , e reiniciá-los dentro de novas janelas de tela (Ctrl + A → c ).

Esta configuração não é necessária e é deixada como um exercício para o usuário.

Divida e navegue entre as janelas com os seguintes comandos:

Criar nova janela

Ctrl + um → c

Dividir janela verticalmente

Ctrl + a →

Dividir janela horizontalmente

Ctrl + um → S

Pule para a próxima janela exibida

Ctrl + a → Tab

Mude a janela exibida para frente ou para trás

Ctrl + um → n ou p

Renomear a janela atual

Ctrl + um → A

Deixar tela a qualquer momento com Ctrl + a → d e reconecte com screen -r a partir da linha de comando.

Para mais informações sobre a tela, consulte a tela de referência rápida GNU .

Agora que você tem todas as janelas e telas do seu terminal configuradas, vamos criar nossa rede Thread. Na FTD Comissário, criar um novo conjunto de dados operacional e cometê-lo como um ativo. O conjunto de dados operacionais é 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á utilizado mais tarde.

Confirme este conjunto de dados como 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. Deve ser o líder. Obtenha 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 é visível quando varrida de outros dispositivos Thread.

De ot-ctl na RCP Joiner:

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

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

A partir do CLI OpenThread na FTD Joiner:

## 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 digitalizar novamente.

Você pode notar que em ambos os exames, a rede parece não ser acopláveis (coluna J na RCP Joiner e FTD Joiner). Isso significa apenas que o Thread Commissioning não está ativo na rede. Ele ainda pode ser unido fora da banda, inserindo a chave de rede no dispositivo joiner manualmente.

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

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

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

Para ingressar, defina a chave de rede (que acabamos de obter do comissário FTD) no RCP Joiner em seu conjunto de dados ativo.

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

> dataset networkkey 1234c0de7ab51234c0de7ab51234c0de
Done
> dataset commit active
Done

Verifique o conjunto de dados para garantir que está definido corretamente.

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

> dataset
Network Key: 1234c0de7ab51234c0de7ab51234c0de

Abra o Thread para que o RCP Joiner se junte à rede "codelab". Aguarde alguns segundos, verifique o estado, RLOC16 e seus 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

Tome nota da malha-Local Endereço IPv6 ( fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f aqui), você vai usá-lo mais tarde.

De volta à FTD Comissário, verifique as tabelas de roteamento e da criança para confirmar ambos os dispositivos são parte da mesma rede. Use o RLOC16 para identificar o RCP Joiner.

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

Ping do endereço malha-local do RCP Joiner (o endereço malha-Local obtido a partir de RCP Joiner ipaddr saída) 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_2nodes.png

Diagramas de topologia

Conforme você trabalha no restante do Codelab, mostraremos um novo diagrama de topologia de Thread sempre que o estado da rede mudar. As funções do nó são denotadas da seguinte forma:

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 a ID do roteador ou a ID da criança mostrada na saída CLI, dependendo da função atual de cada nó e do estado naquele momento.

Agora vamos adicionar o terceiro dispositivo Thread à rede "codelab". Desta vez, usaremos o processo de comissionamento in-band mais seguro. Na FTD Joiner, digitalização para 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 a rosca comissionamento não é activo no dispositivo.

Vamos ser específicos ao fazer o comissionamento neste próximo dispositivo e permitir que apenas o FTD Joiner entre. Ainda sobre o FTD Joiner, obter o eui64 , de modo que o FTD Comissário pode identificá-lo:

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

> eui64
2f57d222545271f1
Done

Na FTD Comissário, iniciar o comissário e especifique o eui64 do dispositivo que pode participar, juntamente com o Joiner Credencial. A credencial do Joiner é uma frase secreta específica do dispositivo.

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

> commissioner start
Done
> commissioner joiner add 2f57d222545271f1 J01NME
Done

Mudar para o FTD Joiner, e nova pesquisa:

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

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

Tal como indicado pelo 1 na coluna J, linha comissionamento está agora activo na rede. Comece a função de marceneiro com a credencial de marceneiro que você acabou de configurar no Comissário FTD:

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

> ifconfig up
Done
> joiner start J01NME
Done

Em mais ou menos um minuto, você recebe uma confirmação de autenticação bem-sucedida:

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

>
Join success

Abra o Thread para que o FTD Joiner se junte à 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 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)

Mudar imediatamente para o FTD Comissário e verificar as tabelas de roteamento e da criança para confirmar que 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). Aqui está nossa topologia atualizada:

otcodelab_top01C_ed01.png

Os dispositivos Thread neste Codelab são um tipo específico de Full Thread Device (FTD) denominado Router Eligible End Device (REED). Isso significa que eles podem funcionar como um roteador ou dispositivo final e podem se promover de um dispositivo final a um roteador.

Thread pode suportar até 32 roteadores, mas tenta manter o número de roteadores entre 16 e 23. Se um REED anexar como um dispositivo final (filho) e o número de roteadores for inferior a 16, após um período de tempo aleatório dentro de dois minutos, automaticamente se autopromove a um Roteador.

Se você tivesse dois filhos em sua rede Tópico depois de adicionar o FTD Joiner, aguarde pelo menos dois minutos e, em seguida, verifique novamente as tabelas de roteamento e criança no FTD Comissário:

## 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 FTD Joiner (Extended MAC = e6cdd2d93249a243 ) promoveu-se a um Router. Note que o RLOC16 é diferente ( b800 em vez de 0c02 ). Isso ocorre porque o RLOC16 é baseado no ID do roteador e no ID do filho de um dispositivo. Quando ele faz a transição do dispositivo final para o roteador, seus valores de ID de roteador e ID de filho mudam, e o mesmo acontece com o RLOC16.

otcodelab_top01C.png

Confirme o novo estado e RLOC16 na FTD Joiner:

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

> state
router
Done
> rloc16
b800
Done

Downgrade do FTD Joiner

Você pode testar esse comportamento desclassificação manualmente o FTD Joiner de uma parte traseira do roteador 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 à FTD Comissário, a FTD Joiner agora deve aparecer na tabela filho (ID = 3). Pode até ser em ambos 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

Depois de algum tempo, ele vai voltar para um roteador com um RLOC de b800 .

otcodelab_top01C.png

Remova o líder

O líder é auto-eleito entre todos os Thread Routers. Isso significa que se o Líder atual for removido da rede Thread, um dos outros Roteadores se tornará o novo Líder.

Na FTD Comissário, encerre Tópico para removê-lo a partir da rede Tópico:

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

> thread stop
Done
> ifconfig down
Done

Dentro de dois minutos, a FTD Joiner torna-se o novo líder Thread. Verifique o estado e os endereços IPv6 do FTD Joiner 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 infantil. Observe que há um novo RLOC16. Este é o RCP Joiner, conforme indicado por seu ID e MAC estendido. Para manter a rede Thread unida, ela trocou os roteadores pai, do FTD Commissioner para o FTD Joiner. Isso resulta em um novo RLOC16 para o RCP Joiner (porque seu ID de 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

Você pode ter que esperar alguns minutos para que o RCP Joiner para anexar ao FTD Joiner como uma criança. Verifique o estado e o RLOC16 para confirmar que:

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

> state
child
> rloc16
b801

Reconecte o Comissário FTD

Uma rede Thread com dois nós não é muito divertida. Vamos colocar o Comissário do FTD novamente online.

Na FTD Comissário, reinicie Tópico:

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

> ifconfig up
Done
> thread start
Done

Em dois minutos, ele se reconecta automaticamente à rede "codelab" como um dispositivo final e, em seguida, se promove a um roteador.

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

> state
router
Done

Verifique as tabelas de roteamento e criança 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.

Gerenciar uma rede Thread com vários dispositivos em diferentes terminais ou janelas de tela pode ser complicado. Use essas dicas para "redefinir" o estado da rede ou do seu espaço de trabalho se encontrar problemas.

Tela

Se você nunca se perder em sua configuração (muitas janelas tela ou telas dentro da tela), manter a matar janelas tela com Ctrl + a → k até que não existem e screen -ls na linha de comando saídas No Sockets found . Em seguida, recrie as janelas de tela para cada dispositivo. Os estados do dispositivo são retidos mesmo quando a tela é eliminada.

Nós da linha

Se a topologia da rede da linha não está conforme descrito neste Codelab, ou nós desligar por algum motivo (talvez porque a máquina Linux alimentação deles foi dormir), é melhor para derrubar Thread, limpar as credenciais de rede, e começar de novo a partir do Criar o passo rede thread.

Para redefinir os FTDs:

## FTD Commissioner or FTD Joiner ##
------------------------------------

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

A RCP pode ser reposto da mesma forma através de ot-ctl :

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

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

Multicast é usado para comunicar informações a um grupo de dispositivos de uma 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

Alcance

Entregue a

ff02::1

Link-Local

Todos os FTDs e MEDs

ff02::2

Link-Local

Todos os FTDs e roteadores de fronteira

ff03::1

Mesh-Local

Todos os FTDs e MEDs

ff03::2

Mesh-Local

Todos os FTDs e roteadores de fronteira

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 um único "salto". Os ditames topologia de rede que dispositivos respondem a um ping para o ff02::1 endereço de multicast.

Ping ff02::1 do FTD Comissário:

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

> ping ff02::1
> 8 bytes from fe80:0:0:0:e4cd:d2d9:3249:a243: icmp_seq=2 hlim=64 time=9ms

Existem dois outros dispositivos na rede (FTD Joiner e RCP Joiner), mas o FTD Commissioner recebeu apenas uma resposta, do Link-Local Address (LLA) do FTD Joiner. 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 Ping ff02::1 do 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! Verificar os endereços IPv6 para os outros dispositivos, podemos ver o primeiro (que termina em 4b1d ) é LLA do FTD Comissário, eo segundo (que termina em 943b ) é LLA de RCP Joiner.

otcodelab_top02C_02_LL02.png

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

Mesh-Local

O escopo Mesh-Local compreende todas as interfaces Thread acessíveis na mesma rede Thread. Vamos ver as respostas a um ping ao ff03::1 multicast endereço.

Ping ff03::1 do FTD Comissário:

## 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, a FTD Comissário recebeu duas respostas, uma do FTD Joiner Routing Locator (RLOC, terminando em b800 ) e um da EID Mesh-local de RCP Joiner (ML-EID, terminando em d55f ). Isso porque o escopo local da malha abrange toda a rede Thread. Não importa onde na rede um dispositivo é, ele vai ser inscrito para o ff03::1 endereço.

otcodelab_top02C_02_ML.png

Ping 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 em ambas as saídas de ping. O RCP Joiner demorou muito mais para chegar ao FTD Commissioner (68 ms) do que para chegar ao FTD Joiner (23 ms). Isso porque ele tem que fazer dois saltos para alcançar o Comissário do FTD, em comparação com um salto para o Marceneiro do FTD.

Você também deve ter notado que o ping de multicast local da malha respondeu com o RLOC apenas para os dois FTDs - não o RCP Joiner. Isso ocorre porque os FTDs são roteadores dentro da rede, enquanto o RCP é um dispositivo final.

Verifique o estado da RCP Joiner para confirmar:

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

> state
child

Um dos serviços de aplicativo que o OpenThread fornece é o User Datagram Protocol (UDP), um protocolo de camada de transporte. Um aplicativo construído em 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 possuir um Roteador de Borda).

Os soquetes UDP são expostos por meio da CLI OpenThread. Vamos usá-lo para passar mensagens entre os dois FTDs.

Obter o endereço EID Mesh-local para o FTD Joiner. Estamos usando este endereço porque ele pode ser acessado de qualquer lugar da 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

Mudar para o FTD Comissário, começar a UDP, e ligar à tomada de configurar 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 deve estar ativa entre os dois nós. Envie uma mensagem do Comissário FTD:

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

> udp send hellothere
Done

Na FTD Joiner, a mensagem UDP foi recebido!

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

> 10 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00 49153 hellothere

Você criou uma rede Thread física!

b915c433e7027cc7.png

Agora você sabe:

  • a diferença entre os tipos de dispositivos, funções e escopos de Thread
  • como os dispositivos Thread gerenciam seus estados dentro da rede
  • como passar mensagens simples entre nós usando UDP

Próximos passos

Partindo deste Codelab, tente os seguintes exercícios:

  • Reflash o conselho FTD Joiner como uma MTD usando o ot-cli-mtd binário, e observar que ele nunca atualiza-se a um roteador ou tenta se tornar o líder
  • Adicione mais dispositivos (experimente uma plataforma diferente!) À rede e esboce a topologia usando tabelas de roteador e filho, junto com pings para os endereços multicast
  • Use pyspinel para controlar o NCP
  • Converter o NCP em um roteador de borda usando OpenThread Border Router e conectar a sua rede Tópico à internet

Leitura adicional

Confira openthread.io e GitHub para uma variedade de recursos OpenThread, incluindo:

Referência: