O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.
Esta página foi traduzida pela API Cloud Translation.
Switch to English

Construir uma rede Thread com placas nRF52840 e OpenThread

26b7f4f6b3ea0700.png

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 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 Thread define um protocolo de comunicação de dispositivo a dispositivo sem fio confiável, seguro e de baixo consumo de energia baseado em IPv6 para aplicativos domésticos. 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
  • Comunicação com um RCP usando 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

Exceto quando indicado de outra forma, o conteúdo deste Codelab é licenciado pela Creative Commons Attribution 3.0 License e os exemplos de código são licenciados pela Apache 2.0 License .

Simulação OpenThread

Antes de começar, você pode querer percorrer o OpenThread Simulation Codelab para se familiarizar com os conceitos básicos de Thread e a CLI OpenThread.

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

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, é /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 o nRF5x-Command-Line-Tools- <OS> apropriado compilado 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 arquivo extraído em /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ em sua máquina Linux. Siga as instruções no arquivo readme.txt arquivo para obter 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. Os comandos de bootstrap garantem que o conjunto de ferramentas esteja instalado e o ambiente configurado corretamente:

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

Construir OpenThread Daemon:

$ make -f src/posix/Makefile-posix DAEMON=1

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 de Joiner para ser autenticado com segurança e comissionado em uma rede Thread. O USB nativo permite o uso de USB CDC ACM como um transporte serial entre o nRF52840 e o host.

Sempre limpe o repo de compilações anteriores primeiro executando make clean .

$ cd ~/src/openthread
$ make -f examples/Makefile-nrf52840 clean
$ make -f examples/Makefile-nrf52840 JOINER=1 USB=1

Navegue até o diretório com o binário OpenThread RCP e converta-o para o formato hexadecimal:

$ cd ~/src/openthread/output/nrf52840/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. Defina a chave da fonte de alimentação nRF na placa nRF52840 para VDD . Quando conectado corretamente, o LED5 está aceso.

20a3b4b480356447.png

Se esta for a primeira placa conectada à máquina Linux, ela aparecerá como porta serial /dev/ttyACM0 (todas as placas ttyACM 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 o NCP:

c00d519ebec7e5f0.jpeg

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

$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --chiperase --program \
       ~/openthread/output/nrf52840/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

Como a construção OpenThread RCP permite o uso de USB CDC ACM nativo como um transporte serial, você deve usar a porta USB nRF 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 com flash e reconecte-a à porta Micro-USB nRF USB ao lado do botão RESET . Defina a chave da fonte de alimentação nRF para USB .

46e7b670d2464842.png

Iniciar OpenThread Daemon

No design RCP, use o OpenThread Daemon para se comunicar e gerenciar o dispositivo Thread. Inicie o ot-daemon com a sinalização -v verbose para que você possa ver a saída do log e confirmar se ele está em execução:

$ cd ~/src/openthread
$ ./output/posix/x86_64-unknown-linux-gnu/bin/ot-daemon -v \
    'spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=115200'

Quando bem ot-daemon sucedido, 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 logs do ot-daemon possam ser visualizados.

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

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

$ ./output/posix/x86_64-unknown-linux-gnu/bin/ot-ctl
>

Verifique o state do Nó 2 (o nó RCP) que você iniciou 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 e o usuário os gerencia manualmente com a CLI do OpenThread.

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

Construir e flash

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

$ cd ~/src/openthread
$ make -f examples/Makefile-nrf52840 clean
$ make -f examples/Makefile-nrf52840 COMMISSIONER=1 JOINER=1

Navegue até o diretório com o binário CLI OpenThread Full Thread Device (FTD) e converta-o para o formato hexadecimal:

$ cd ~/src/openthread/output/nrf52840/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 o RCP ainda estiver conectado à máquina Linux, esta nova placa deve aparecer como porta serial /dev/ttyACM1 (todas as placas ttyACM 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 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 \
       ~/openthread/output/nrf52840/bin/ot-cli-ftd.hex --reset

Rotule o quadro como "Comissário".

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 Return no teclado algumas vezes para abrir o prompt OpenThread CLI > . Abra a interface IPv6 e verifique os endereços:

> ifconfig up
Done
> ipaddr
fdde:ad00:beef:0:6394:5a75:a1ad:e5a
fe80:0:0:0:1cd6:87a9:cb9d:4b1d
Done

Use Ctrl + a → d para desconectar da tela FTD Commissioner CLI e retornar ao terminal Linux para que a próxima placa possa ser flasheada. Para entrar novamente na CLI a qualquer momento, use screen -r na linha de comando. Para ver uma lista de telas disponíveis, use screen -ls :

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

Configurar o FTD Joiner

Repita o processo acima para atualizar a terceira placa nRF52840, usando a versão existente ot-cli-ftd.hex .

Se os outros dois nós estiverem conectados à máquina Linux quando esta terceira placa for conectada, 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 (a 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 aparece. Acesse a CLI OpenThread para o FTD Joiner:

$ screen /dev/ttyACM2 115200

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

> ifconfig up
Done
> ipaddr
fdde:ad00:beef:0:3e2e:66e:9d41:ebcd
fe80:0:0:0:6c1e:87a2:df05:c240
Done

Agora que o FTD Joiner CLI está na mesma instância da Tela que o FTD Commissioner, você pode alternar entre eles usando Ctrl + a → n .

Use Ctrl + a → d a qualquer momento para sair da tela.

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. serviço / logs ot-daemon
  2. RCP Joiner via ot-ctl
  3. Comissário FTD via OpenThread CLI
  4. FTD Joiner via OpenThread CLI

Se você deseja 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 básicos da tela:

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

screen -r

Sair da sessão de tela

Ctrl + a → d

Criar nova janela na sessão de tela

Ctrl + a → c

Alternar entre janelas na mesma sessão de tela

Ctrl + a → n (avançar) Ctrl + a → p (voltar)

Mate 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

Os comandos na 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 + 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 mudar essa nova janela para a próxima
  4. Se for igual à janela superior, pressione Ctrl + a → n novamente para ver o outro dispositivo FTD

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

Uso avançado

Para dividir ainda mais a tela em quadrantes e visualizar os logs ot-daemon e o RCP Joiner ot-ctl , esses serviços devem ser iniciados dentro da mesma instância da Tela. Para fazer isso, pare o ot-daemon e saia do ot-ctl , e reinicie-os em 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 + a → c

Dividir janela verticalmente

Ctrl + a →

Dividir janela horizontalmente

Ctrl + a → S

Pule para a próxima janela exibida

Ctrl + a → Tab

Mude 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 reconecte com screen -r na linha de comando.

Para obter mais informações sobre a Tela, consulte a referência rápida da Tela GNU .

Agora que você tem todas as janelas e telas do terminal configuradas, vamos criar nossa rede Thread. No Comissário FTD , crie um novo Conjunto de Dados Operacionais e confirme-o como 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: 20
Channel Mask: 07fff800
Ext PAN ID: c0de7ab5c0de7ab5
Mesh Local Prefix: fdc0:de7a:b5c0/64
Master Key: 1234c0de7ab51234c0de7ab51234c0de
Network Name: OpenThread-c0de
PAN ID: 0xc0de
PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4
Security Policy: 0, onrcb
Done

Confirme este conjunto de dados como ativo:

> dataset commit active
Done

Abra a interface IPv6:

> ifconfig up
Done

Iniciar 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)
fe80:0:0:0:1cd6:87a9:cb9d:4b1d         # Link-Local Address (LLA)
fdc0:de7a:b5c0:0:6394:5a75:a1ad:e5a    # Mesh-Local EID (ML-EID)

A rede "codelab" agora é visível quando escaneada de outros dispositivos Thread.

De ot-ctl no RCP Joiner :

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

wpanctl:utun7> scan
   | Joinable | NetworkName        | PAN ID | Ch | XPanID           | HWAddr           | RSSI
---+----------+--------------------+--------+----+------------------+------------------+------
 1 |       NO | "OpenThread-c0de"  | 0xC0DE | 11 | C0DE7AB5C0DE7AB5 | 1ED687A9CB9D4B1D |  -20

Do OpenThread CLI no FTD Joiner :

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

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

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

Você pode notar que em ambas as varreduras, a rede parece não ser juntável (coluna Joinable no Joiner NCP, coluna J no Joiner FTD). Isso significa apenas que o Thread Commissioning não está ativo na rede. Ele ainda pode ser unido fora da banda, inserindo manualmente a chave mestra da rede no dispositivo joiner.

Vamos adicionar o NCP Joiner à rede Thread que acabamos de criar, usando um processo out-of-band. Procure redes no NCP Joiner :

## NCP Joiner ##
----------------

wpanctl:utun7> scan
   | Joinable | NetworkName        | PAN ID | Ch | XPanID           | HWAddr           | RSSI
---+----------+--------------------+--------+----+------------------+------------------+------
 1 |       NO | "OpenThread-c0de"  | 0xC0DE | 11 | C0DE7AB5C0DE7AB5 | F65AE2853FF0C4E4 |  -32

Para ingressar, defina a chave mestra da rede no NCP Joiner e ingresse na rede 1 (o ID na primeira coluna da saída da scan ):

## NCP Joiner ##
----------------

wpanctl:utun7> setprop Network:Key 1234C0DE7AB51234C0DE7AB51234C0DE
wpanctl:utun7> join 1
Joining "OpenThread-c0de" C0DE7AB5C0DE7AB5 as node type "end-device"
Successfully Joined!

Verifique o status do Joiner NCP para verificar. Pode levar alguns segundos para que todos os endereços IPv6 apareçam na saída.

## NCP Joiner ##
----------------

wpanctl:utun7> status
utun7 => [
        "NCP:State" => "associated"
        "Daemon:Enabled" => true
        "NCP:Version" => "OPENTHREAD/g4ccc23a5-dirty; NRF52840; Sep 22 2017 10:44:07"
        "Daemon:Version" => "0.08.00d (0.07.01-124-g038e8b0/0.07.01-153-g6752c40; Oct  3 2017 17:55:05)"
        "Config:NCP:DriverName" => "spinel"
        "NCP:HardwareAddress" => [F872DF9CD5AE4DCE]
        "NCP:Channel" => 11
        "Network:NodeType" => "end-device"
        "Network:Name" => "OpenThread-c0de"
        "Network:XPANID" => 0xC0DE7AB5C0DE7AB5
        "Network:PANID" => 0xC0DE
        "IPv6:LinkLocalAddress" => "fe80::18e5:29b3:a638:943b"
        "IPv6:MeshLocalAddress" => "fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f"
        "IPv6:MeshLocalPrefix" => "fdc0:de7a:b5c0::/64"
        "com.nestlabs.internal:Network:AllowingJoin" => false
]

Anote o IPv6:MeshLocalAddress , você o usará mais tarde.

Obtenha o RLOC16 do marceneiro NCP:

## NCP Joiner ##
----------------

wpanctl:utun7> getprop Thread:RLOC16
Thread:RLOC16 = 0x0C01

De volta ao FTD Commissioner , verifique o roteador e as tabelas filho para confirmar se os dois dispositivos fazem parte da mesma rede. Use o RLOC16 para identificar o Joiner NCP.

## 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|N| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+-+------------------+
|   1 | 0x0c01 |        240 |         25 |     3 |   89 |1|1|1|1| 1ae529b3a638943b |
Done

Faça ping no endereço de malha local do NCP Joiner (o atributo IPv6:MeshLocalAddress da saída de status do NCP Joiner) 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:

a1149fa813cff2cf.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 e do estado atual de cada nó naquele momento.

Agora vamos adicionar o terceiro dispositivo Thread à rede "codelab". Desta vez, usaremos o processo de comissionamento in-band mais seguro. No FTD Joiner , procure 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 Thread Commissioning não está ativo no dispositivo.

Vamos ser específicos ao fazer o comissionamento neste próximo dispositivo e permitir que apenas o FTD Joiner entre. Ainda no FTD Joiner, obtenha o eui64 , para que o Comissário do FTD possa identificá-lo:

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

> eui64
2f57d222545271f1
Done

No FTD Commissioner , inicie o comissário e especifique o eui64 do dispositivo que pode ingressar, junto com a credencial do marceneiro. A credencial do Joiner é uma frase secreta específica do dispositivo.

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

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

Mude para o FTD Joiner e verifique novamente:

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

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

Conforme indicado pelo 1 na coluna J, o Thread Commissioning agora está ativo 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 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)
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)

Mude imediatamente para o Comissário FTD e verifique o roteador e as tabelas filho para confirmar se existem três dispositivos na rede "codelab":

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

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     |
+----+--------+----------+-----------+-------+--------+-----+------------------+
|  3 | 0x0c00 |        3 |         0 |     0 |      0 |  50 | 1ed687a9cb9d4b1d |

> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|N| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+-+------------------+
|   1 | 0x0c01 |        240 |         25 |     3 |   89 |1|1|1|1| 1ae529b3a638943b |
|   2 | 0x0c02 |        240 |         15 |     3 |   44 |1|1|1|1| e6cdd2d93249a243 |
Done

Com base no RLOC16, o FTD Joiner se conectou à rede como um dispositivo final (filho). Aqui está nossa topologia atualizada:

4f0ef147bb68947b.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 roteadores ou como dispositivos finais e podem se promover de dispositivos finais a roteadores.

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, ele automaticamente se promove a um roteador.

Se você teve dois filhos em sua rede Thread após adicionar o FTD Joiner, espere pelo menos dois minutos e verifique novamente o roteador e as tabelas 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 FTD Joiner (Extended MAC = e6cdd2d93249a243 ) foi promovido a roteador. Observe que o RLOC16 é diferente ( b800 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, assim como o RLOC16.

279f8559cbe6308d.png

Confirme o novo estado e RLOC16 no FTD Joiner :

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

> state
router
Done
> rloc16
b800
Done

Downgrade do FTD Joiner

Você pode testar esse comportamento fazendo o downgrade manualmente do FTD Joiner de um roteador para um dispositivo final. Mude o estado para filho e verifique o RLOC16:

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

> state child
Done
> rloc16
0c03
Done

27fdf2bddd3a2938.png

De volta ao FTD Commissioner , o 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 mudará de volta para um Roteador com um RLOC de b800 .

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

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 Thread leader. 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
fe80:0:0:0:e4cd:d2d9:3249:a243
fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd
Done

1a99ffadf49e108c.png

Verifique a tabela infantil. Observe que há um novo RLOC16. Este é o NCP 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 NCP Joiner (porque sua 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

Pode ser necessário esperar alguns minutos para que o Joiner NCP se conecte ao Joiner FTD quando criança. Se você tiver a janela wpantund visível, deve haver uma nova saída, pois ela está associada a um novo pai:

## wpantund ##
--------------

wpantund[2128]: Node type change: "end-device" -> "unknown"
wpantund[2128]: State change: "associated" -> "associated:no-parent"
wpantund[2128]: Taking interface(s) down. . .
wpantund[2128]: State change: "associated:no-parent" -> "associated"
wpantund[2128]: Adding address "fe80::dad4:de8a:a0f9:dc0a/64" to NCP
wpantund[2128]: Node type change: "unknown" -> "end-device"

Mude para o NCP Joiner e verifique o RLOC16 para confirmar se ele mudou:

## NCP Joiner ##
----------------

wpanctl:utun7> getprop Thread:RLOC16
Thread:RLOC16 = 0xB801

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.

No Comissário FTD , reinicie o 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 o roteador e as tabelas 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

5effd8bdac8ab182.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 da sua área de trabalho se encontrar problemas.

Tela

Se você alguma vez se perder em sua configuração (muitas janelas de Tela ou Telas dentro da Tela), continue matando as janelas de Tela com Ctrl + a → k até que nenhuma exista e screen -ls nas saídas da linha de comando 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 de rede do Thread não for conforme descrito neste Codelab, ou os nós se desconectarem por algum motivo (talvez porque a máquina Linux que os alimenta tenha entrado em suspensão), é melhor desativar o Thread, limpar as credenciais de rede e começar novamente a partir do Criar a etapa de rede Thread .

Para redefinir os FTDs:

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

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

Para redefinir o NCP:

## NCP Joiner ##
----------------

wpanctl:utun7> leave
Leaving current WPAN. . .
wpanctl:utun7> reset
Resetting NCP. . .

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

Escopo

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

Ping ff02::1 do Comissário FTD :

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

5a60a47570100e5f.png

Agora execute ping 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! Verificando os endereços IPv6 para os outros dispositivos, podemos ver que o primeiro (terminando em 4b1d ) é o LLA do Comissário FTD, e o segundo (terminando em 943b ) é o LLA do Joiner NCP.

6e4bfe1ab638474d.png

Isso significa que o FTD Joiner está diretamente conectado ao FTD Commissioner e ao NCP 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 para o endereço multicast ff03::1 .

Ping ff03::1 do Comissário FTD :

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

9498cacb5f2fe153.png

Execute 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

6e4bfe1ab638474d.png

Observe o tempo de resposta do NCP Joiner em ambas as saídas de ping. O NCP Joiner demorou muito mais para chegar ao FTD Commissioner (68 ms) do que para chegar ao FTD Joiner (23 ms). Isso porque é necessário fazer dois saltos para chegar ao 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 de malha respondeu com o RLOC apenas para os dois FTDs - não o Joiner NCP. Isso ocorre porque os FTDs são roteadores na rede, enquanto o NCP é um dispositivo final.

Verifique o NodeType do NCP Joiner para confirmar:

## NCP Joiner ##
----------------

wpanctl:utun7> getprop Network:NodeType
Network:NodeType = "end-device"

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

Obtenha 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

Mude para o FTD Commissioner , inicie o UDP e conecte ao soquete que você configurou 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

No FTD Joiner , a mensagem UDP foi recebida!

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

  • ot-cli-mtd placa FTD Joiner como um MTD usando o binário ot-cli-mtd e observe que ele nunca se atualiza para um roteador ou tenta se tornar o líder
  • Adicione mais dispositivos (tente uma plataforma diferente!) À rede e esboce a topologia usando tabelas de roteador e filho, juntamente com pings para os endereços multicast
  • Use pyspinel para controlar o NCP
  • Converta o NCP em um Border Router usando OpenThread Border Router e conecte sua rede Thread à Internet

Leitura adicional

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

Referência: