Simulando uma rede Thread com OpenThread

1. Introdução

26b7f4f6b3ea0700.png

OpenThread lançado pela Google é uma implementação open-source do Tópico 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.

Este Codelab o orienta na simulação de uma rede Thread em dispositivos simulados.

O que você aprenderá

  • Como configurar o conjunto de ferramentas de construção OpenThread
  • Como simular uma rede Thread
  • Como autenticar nós de thread
  • Como gerenciar uma rede Thread com OpenThread Daemon

O que você precisará

  • idiota
  • Conhecimento básico de Linux, roteamento de rede

2. Configure o sistema de compilação

Git

O Git é necessário para concluir este Codelab. Baixe e instale-o antes de continuar.

Baixar Git

Uma vez instalado, siga as instruções para seu sistema operacional específico para baixar e construir OpenThread.

XCode para Mac OS X

XCode é necessário para instalar e construir OpenThread no Mac OS X.

Baixar XCode

Após a instalação do XCode, instale as ferramentas de linha de comando do XCode:

$ xcode-select --install

Construir em Linux / Mac OS X

Estas instruções de instalação foram testadas no Ubuntu Server 14.04 LTS e no Mac OS X Sierra 10.12.6.

Instale o OpenThread. As 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
$ ./bootstrap

Usando Windows

Se você preferir Windows, recomendamos tentar a versão Docker deste Codelab.

Simulação OpenThread no Docker

3. Crie os aplicativos OpenThread

Assim que a instalação for concluída, crie o aplicativo OpenThread de exemplo. Para este Codelab, estamos usando o exemplo de simulação.

$ cd ~/src/openthread
$ make -f examples/Makefile-simulation

Agora crie o OpenThread Daemon:

$ cd ~/src/openthread
$ make -f src/posix/Makefile-posix DAEMON=1

4. Simule uma rede Thread

O aplicativo de exemplo que você usará para este Codelab demonstra um aplicativo OpenThread mínimo que expõe a configuração do OpenThread e as interfaces de gerenciamento por meio de uma interface de linha de comando básica (CLI).

Este exercício o conduz pelas etapas mínimas necessárias para executar ping em um dispositivo Thread simulado de outro dispositivo Thread simulado.

A figura abaixo descreve uma topologia básica de rede Thread. Para este exercício, simularemos os dois nós dentro do círculo verde: um Thread Leader e Thread Router com uma única conexão entre eles.

6e3aa07675f902dc.png

Ping um nó

1. Iniciar o Nó 1

Navegue até a openthread diretório e gerar o processo CLI para um dispositivo Tópico simuladas, utilizando o ot-cli-ftd binário.

$ cd ~/src/openthread
$ ./output/simulation/bin/ot-cli-ftd 1

Nota: Se você não vê a > alerta depois de executar este comando, prima enter .

Este binário implementa um dispositivo OpenThread simulado em cima do POSIX. O driver de rádio IEEE 802.15.4 é implementado na parte superior do UDP (os quadros IEEE 802.15.4 são passados ​​dentro de cargas UDP).

O argumento de 1 é um descritor de arquivo que representa os bits menos significativos da "fábrica-designado" IEEE EUI-64 para o dispositivo simulado. Este valor também é usado ao vincular a uma porta UDP para emulação de rádio IEEE 802.15.4 (porta = 9000 + descritor de arquivo). Cada instância de um dispositivo Thread simulado neste Codelab usará um descritor de arquivo diferente.

Nota: Apenas descritores de arquivos utilização de 1 ou maior conforme observado neste Codelab quando desova o processo para um dispositivo simulado. Um descritor de arquivo 0 é reservada para outro uso.

Crie um novo Dataset Operacional e confirme-o como ativo. O conjunto de dados operacionais é a configuração da rede Thread que você está criando.

> dataset init new
Done
> dataset
Active Timestamp: 1
Channel: 20
Channel Mask: 07fff800
Ext PAN ID: d6263b6d857647da
Mesh Local Prefix: fd61:2344:9a52:ede0/64
Network Key: e4344ca17d1dca2a33f064992f31f786
Network Name: OpenThread-c169
PAN ID: 0xc169
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

Aguarde alguns segundos e verifique se o dispositivo se tornou o Thread Leader. O Líder é o dispositivo responsável por gerenciar a atribuição da ID do roteador.

> state
leader
Done

Visualize os endereços IPv6 atribuídos à interface Thread do Nó 1 (sua saída será diferente):

> ipaddr
fd61:2344:9a52:ede0:0:ff:fe00:fc00
fd61:2344:9a52:ede0:0:ff:fe00:5000
fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
fe80:0:0:0:94da:92ea:1353:4f3b
Done

Observe os tipos de endereço IPv6 específicos:

  • Começa com fd = malha-locais
  • Começa com fe80 = link-local

Os tipos de endereço local de malha são classificados ainda:

  • Contém ff:fe00 = Router Locator (RLOC)
  • Não contém ff:fe00 = Endpoint Identifier (EID)

Identifique o EID na saída do console, anote-o para uso posterior. No exemplo de saída acima, o EID é:

fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6

2. Iniciar o Nó 2

Abra um novo terminal e navegue até o openthread diretório e gerar o processo CLI. Este é o seu segundo dispositivo Thread simulado:

$ cd ~/src/openthread
$ ./output/simulation/bin/ot-cli-ftd 2

Nota: Se você não vê a > alerta depois de executar este comando, prima enter .

Configure a Thread Network Key e o PAN ID, usando os mesmos valores do Node 1's Operational Dataset:

> dataset networkkey e4344ca17d1dca2a33f064992f31f786
Done
> dataset panid 0xc169
Done

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

O dispositivo se inicializará como Criança. Um Thread Child é equivalente a um End Device, que é um dispositivo Thread que transmite e recebe tráfego unicast apenas com um dispositivo Pai.

> state
child
Done

Dentro de 2 minutos, você deve ver o detector de estado da child ao router . Um Thread Router é capaz de rotear o tráfego entre dispositivos Thread. Também é conhecido como Pai.

> state
router
Done

Verifique a rede

Uma maneira fácil de verificar a rede em malha é examinar a tabela do roteador.

1. Verifique a conectividade

No Nó 2, obtenha o RLOC16. O RLOC16 são os últimos 16 bits do endereço RLOC IPv6 do dispositivo.

> rloc16
5800
Done

No Nó 1, verifique a tabela do roteador para RLOC16 do Nó 2. Certifique-se de que o Nó 2 tenha mudado para o estado do roteador primeiro.

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQI In | LQI Out | Age | Extended MAC  |
+----+--------+----------+----------+-------+---------+-----+------------------+
| 20 | 0x5000 |       63 |         0 |     0 |      0 |   0 | 96da92ea13534f3b |
| 22 | 0x5800 |       63 |         0 |     3 |      3 |  23 | 5a4eb647eb6bc66c |

RLOC de nó de um 0xa800 for encontrada na tabela, o que confirma que ele é ligado para a malha.

2. Faça ping no Nó 1 a partir do Nó 2

Verifique a conectividade entre os dois dispositivos Thread simulados. No nó 2, ping a EID atribuído ao nó 1:

> ping fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
> 16 bytes from fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6: icmp_seq=1
hlim=64 time=12ms

Imprensa enter para voltar ao > alerta CLI.

Teste a rede

Agora que você pode executar ping com êxito entre dois dispositivos de Thread simulados, teste a rede mesh colocando um nó offline.

Retorne ao Nó 1 e pare o Tópico:

> thread stop
Done

Mude para o Nó 2 e verifique o estado. Dentro de dois minutos, Node 2 detecta que o líder (nó 1) é desligada, e você deve ver Nó 2 transição para ser o leader da rede:

> state
router
Done
...
> state
leader
Done

Uma vez confirmado, pare o Thread e redefina o Nó 2 de fábrica antes de sair. Uma redefinição de fábrica é feita para garantir que as credenciais de rede Thread que usamos neste exercício não sejam transportadas para o próximo exercício.

> thread stop
Done
> factoryreset
>
> exit

Também redefinir as configurações de fábrica e sair do Nó 1:

> factoryreset
>
> exit

Veja a OpenThread CLI Referência para explorar todos os comandos da CLI disponíveis.

5. Autenticar nós com comissionamento

No exercício anterior, você configurou uma rede Thread com dois dispositivos simulados e conectividade verificada. No entanto, isso só permite que o tráfego de link local IPv6 não autenticado passe entre os dispositivos. Para rotear o tráfego IPv6 global entre eles (e a Internet por meio de um roteador de borda de thread), os nós devem ser autenticados.

Para autenticar, um dispositivo deve atuar como um Comissário. O Comissário é o servidor de autenticação atualmente eleito para novos dispositivos Thread, e o autorizador para fornecer as credenciais de rede necessárias para os dispositivos ingressarem na rede.

Neste exercício, usaremos a mesma topologia de dois nós de antes. Para autenticação, o Thread Leader atuará como o Comissário, o Thread Router como um Joiner.

d6a67e8a0d0b5dcb.png

1. Crie uma rede

Se continuar do exercício anterior, você já deve ter duas janelas de terminal abertas. Caso contrário, certifique-se de que dois estejam abertos e prontos para uso. Um servirá como Nó 1, o outro como Nó 2.

No Nó 1, crie o processo CLI:

$ cd ~/src/openthread
$ ./output/simulation/bin/ot-cli-ftd 1

Nota: Se você não vê a > alerta depois de executar este comando, prima enter .

Crie um novo conjunto de dados operacionais, confirme-o como ativo e inicie o thread:

> dataset init new
Done
> dataset
Active Timestamp: 1
Channel: 12
Channel Mask: 07fff800
Ext PAN ID: e68d05794bf13052
Mesh Local Prefix: fd7d:ddf7:877b:8756/64
Network Key: a77fe1d03b0e8028a4e13213de38080e
Network Name: OpenThread-8f37
PAN ID: 0x8f37
PSKc: f9debbc1532487984b17f92cd55b21fc
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

Aguarde alguns segundos e verifique se o dispositivo se tornou um Thread Leader:

> state
leader
Done

2. Comece a função de Comissário

Ainda no Nó 1, comece a função de Comissário:

> commissioner start
Done

Permitir que qualquer Joiner (usando o * universal) com o J01NME Joiner Credencial a Comissão sobre a rede. Um Joiner é um dispositivo adicionado por um administrador humano a uma Thread Network comissionada.

> commissioner joiner add * J01NME
Done

3. Inicie a função de Joiner

Em uma segunda janela de terminal, gere um novo processo CLI. Este é o Nó 2.

$ cd ~/src/openthread
$ ./output/simulation/bin/ot-cli-ftd 2

No nó 2, habilite a função Joiner usando o J01NME Joiner Credencial.

> ifconfig up
Done
> joiner start J01NME
Done

... aguarde alguns segundos pela confirmação ...

Join success

Como um Joiner, o dispositivo (Nó 2) autenticou-se com sucesso com o Comissário (Nó 1) e recebeu as credenciais da Thread Network.

Agora que o Nó 2 está autenticado, inicie o Thread:

> thread start
Done

4. Valide a autenticação da rede

Verifique o state no nó 2, para validar que já aderiram à rede. Dentro de dois minutos, o nó 2 a transição de child para router :

> state
child
Done
...
> state
router
Done

5. Redefinir a configuração

Para se preparar para o próximo exercício, redefina a configuração. Em cada nó, pare o Thread, faça uma redefinição de fábrica e saia do dispositivo de Thread simulado:

> thread stop
Done
> factoryreset
>
> exit

Você pode ter que pressionar enter algumas vezes para trazer a > volta rápida após um factoryreset comando.

6. Gerencie a rede com OpenThread Daemon

Para este exercício, vamos simular uma instância CLI (um único dispositivo SoC Thread integrado) e uma instância Radio Co-Processor (RCP).

ot-daemon é um modo do aplicativo OpenThread Posix que usa um soquete de UNIX como entrada e saída, de modo que OpenThread núcleo pode funcionar como um serviço. Um cliente pode se comunicar com este serviço conectando-se ao soquete usando o OpenThread CLI como protocolo.

ot-ctl é um CLI fornecida pelo ot-daemon para gerenciar e configurar o RCP. Usando isso, conectaremos o RCP à rede criada pelo dispositivo Thread.

Use ot-daemon

Este exercício usará três janelas de terminal, correspondendo ao seguinte:

  1. Instância CLI do dispositivo Thread simulado (Nó 1)
  2. ot-daemon processo
  3. ot-ctl exemplo CLI

Se continuar do exercício anterior, você já deve ter duas janelas de terminal abertas. Abra uma terceira para garantir que você tenha três janelas de terminal disponíveis para este exercício.

1. Iniciar o Nó 1

Na primeira janela do terminal, gere o processo CLI para o dispositivo Thread simulado:

$ cd ~/src/openthread
$ ./output/simulation/bin/ot-cli-ftd 1

Nota: Se você não vê a > alerta depois de executar este comando, prima enter .

Crie um novo conjunto de dados operacionais, confirme-o como ativo e inicie o thread:

> dataset init new
Done
> dataset
Active Timestamp: 1
Channel: 13
Channel Mask: 07fff800
Ext PAN ID: 97d584bcd493b824
Mesh Local Prefix: fd55:cf34:dea5:7994/64
Network Key: ba6e886c7af50598df1115fa07658a83
Network Name: OpenThread-34e4
PAN ID: 0x34e4
PSKc: 38d6fd32c866927a4dfcc06d79ae1192
Security Policy: 0, onrcb
Done

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

Visualize os endereços IPv6 atribuídos à interface Thread do Nó 1:

> ipaddr
fd55:cf34:dea5:7994:0:ff:fe00:fc00
fd55:cf34:dea5:7994:0:ff:fe00:d000
fd55:cf34:dea5:7994:460:872c:e807:c4ab
fe80:0:0:0:9cd8:aab6:482f:4cdc
Done
>

Como explicado na Simular um passo rede Thread, um endereço é link-local ( fe80 ) e três são de malha-local ( fd ). A EID é o endereço malha-local que não contenha ff:fe00 no endereço. Nessa saída de exemplo, a EID é fd55:cf34:dea5:7994:460:872c:e807:c4ab .

Identificar o EID específico de sua ipaddr saída, que será usado para se comunicar com o nó.

2. Inicie o ot-daemon

Na segunda janela de terminal, navegue até o openthread diretório, e começar a ot-daemon para um nó de RCP, que chamaremos Nó 2. Use o -v detalhado bandeira para que você possa ver a saída log e confirme que ele está sendo executado:

$ cd ~/src/openthread
$ ./output/posix/bin/ot-daemon -v \
    'spinel+hdlc+forkpty://output/simulation/bin/ot-rcp?forkpty-arg=2'

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 este terminal aberto e em execução em segundo plano. Você não digitará mais nenhum comando nele.

3. Use ot-ctl para entrar na rede

Nós não ter encomendado Nó 2 (o ot-daemon RCP) a qualquer rede Tópico ainda. Este é o lugar onde ot-ctl entra. 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.

Numa terceira janela do terminal, iniciar ot-ctl :

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

Você vai usar ot-ctl nesta terceira janela de terminal para gerenciar o nó 2 (o nó RCP) que começou na segunda janela do terminal com ot-daemon . Verifique o state do nó 2:

> state
disabled
Done

Obter do Nó 2 eui64 , para restringir juntando para o específico Joiner:

> eui64
18b4300000000001
Done

No Nó 1 (primeira janela do terminal), inicie o Comissário e restrinja a junção apenas a esse eui64:

> commissioner start
Done
> commissioner joiner add 18b4300000000001 J01NME
Done

No Nó 2 (terceira janela do terminal), abra a interface de rede e conecte-se à rede:

> ifconfig up
Done
> joiner start J01NME
Done

... aguarde alguns segundos pela confirmação ...

Join success

Como um Joiner, o RCP (Nó 2) autenticou-se com sucesso com o Comissário (Nó 1) e recebeu as credenciais da Thread Network.

Agora junte o Nó 2 à rede Thread:

> thread start
Done

4. Valide a autenticação da rede

Verifique o state no nó 2, para validar que já aderiram à rede. Dentro de dois minutos, o nó 2 a transição de child para router :

> state
child
Done
...
> state
router
Done

5. Valide a conectividade

Sair ot-ctl usando Ctrl + D e na linha de comando da sua máquina host, pingue Nó 1, usando seu EID com a ping6 comando. Se o ot-daemon exemplo RCP se une com sucesso para e se comunicar com a rede Thread, o ping tiver êxito:

$ ping6 -c 4 fd55:cf34:dea5:7994:460:872c:e807:c4ab
PING fd55:cf34:dea5:7994:460:872c:e807:c4ab (fd55:cf34:dea5:7994:460:872c:e807:c4ab): 56 data bytes
64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=0 ttl=64 time=4.568 ms
64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=1 ttl=64 time=6.396 ms
64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=2 ttl=64 time=7.594 ms
64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=3 ttl=64 time=5.461 ms
--- fd55:cf34:dea5:7994:460:872c:e807:c4ab ping statistics ---
4 packets transmitted, 4 packets received, 0% packet loss
round-trip min/avg/max/stddev = 4.568/6.005/7.594/1.122 ms

7. Parabéns!

Você simulou com sucesso sua primeira rede Thread usando OpenThread. Incrível!

Neste Codelab você aprendeu como:

  • Configure o conjunto de ferramentas de compilação OpenThread
  • Simular uma rede Thread
  • Autenticar nós de thread
  • Gerenciar uma rede Thread com OpenThread Daemon

Se você quiser saber mais, explore estas referências: