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.
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
Git
O Git é necessário para concluir este Codelab. Baixe e instale-o antes de continuar.
Uma vez instalado, siga as instruções para seu sistema operacional específico para baixar e construir OpenThread.
XCode para Mac OS X
O XCode é necessário para instalar e construir o OpenThread no Mac OS X.
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. 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
Usando Windows
Se você preferir Windows, recomendamos experimentar a versão Docker deste Codelab.
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 construa o OpenThread Daemon:
$ cd ~/src/openthread $ make -f src/posix/Makefile-posix DAEMON=1
O aplicativo de exemplo que você usará para este Codelab demonstra um aplicativo OpenThread mínimo que expõe a configuração 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.
Ping um nó
1. Iniciar o Nó 1
Navegue até o diretório openthread e openthread o processo CLI para um dispositivo Thread simulado usando o binário ot-cli-ftd .
$ cd ~/src/openthread $ ./output/simulation/bin/ot-cli-ftd 1
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 úteis UDP).
O argumento de 1 é um descritor de arquivo que representa os bits menos significativos do IEEE EUI-64 "atribuído de fábrica" 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: Use apenas descritores de arquivo de 1 ou maior conforme observado neste Codelab ao iniciar o processo para um dispositivo simulado. Um descritor de arquivo de 0 é reservado para outro uso.
Se você não vê o
>
prompt após executar este comando, pressione
enter
.
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.
> 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 Master 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
Inicie a 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= mesh-local - 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 diretório openthread e openthread o processo CLI. Este é o seu segundo dispositivo Thread simulado:
$ cd ~/src/openthread $ ./output/simulation/bin/ot-cli-ftd 2
Se você não vê o
>
prompt após executar este comando, pressione
enter
.
Configure a Thread Master Key e o PAN ID, usando os mesmos valores do Conjunto de Dados Operacionais do Nó 1:
> dataset masterkey 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 Parent.
> state child Done
Em 2 minutos, você deverá ver a mudança de estado de child para 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 mesh é 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 de 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 |
O RLOC do nó 1 de 0xa800 é encontrado na tabela, confirmando que ele está conectado à malha.
2. Faça ping no nó 1 do nó 2
Verifique a conectividade entre os dois dispositivos Thread simulados. No Nó 2, ping no 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
Pressione enter para retornar ao > prompt 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. Em dois minutos, o Nó 2 detecta que o líder (Nó 1) está offline e você deve ver a transição do Nó 2 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
Consulte OpenThread CLI Reference para explorar todos os comandos CLI disponíveis.
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 agirá como o Comissário, o Thread Router como um Joiner.
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, gere o processo CLI:
$ cd ~/src/openthread $ ./output/simulation/bin/ot-cli-ftd 1
Se você não vê o
>
prompt após executar este comando, pressione
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 Master 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
Inicie a 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
Permita que qualquer Joiner (usando o caractere curinga * ) com a Credencial de Joiner J01NME comissão na 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, ative a função de Joiner usando a Credencial de Joiner J01NME .
> 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 se ele agora está conectado à rede. Em dois minutos, o Nó 2 faz a transição do child para o router :
> state child Done ... > state router Done
5. Redefinir 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 Thread simulado:
> thread stop Done > factoryreset > > exit
Pode ser necessário pressionar enter algumas vezes para trazer o prompt > volta após um comando de factoryreset .
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 UNIX como entrada e saída, para que o núcleo do OpenThread possa ser executado como um serviço. Um cliente pode se comunicar com este serviço conectando-se ao soquete usando a CLI OpenThread como protocolo.
ot-ctl é uma 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:
- Instância CLI do dispositivo Thread simulado (Nó 1)
- processo
ot-daemon - instância CLI
ot-ctl
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
Se você não vê o
>
prompt após executar este comando, pressione
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 Master 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 >
Conforme explicado na etapa Simular uma rede Thread , um endereço é local de link ( fe80 ) e três são locais de malha ( fd ). O EID é o endereço local da malha que não contém ff:fe00 no endereço. Neste exemplo de saída, o EID é fd55:cf34:dea5:7994:460:872c:e807:c4ab .
Identifique o EID específico de sua saída ipaddr , que será usado para se comunicar com o nó.
2. Inicie o ot-daemon
Na segunda janela do terminal, navegue até o diretório openthread e inicie ot-daemon para um nó RCP, que chamaremos de Nó 2. Use o sinalizador -v verbose para que você possa ver a saída do log e confirmar se está em execução:
$ cd ~/src/openthread
$ ./output/posix/bin/ot-daemon -v \
'spinel+hdlc+forkpty://output/simulation/bin/ot-rcp?forkpty-arg=2'
Quando bem ot-daemon sucedido, ot-daemon no modo verbose 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
3. Use ot-ctl para entrar na rede
Ainda não comissionamos o Nó 2 (o RCP ot-daemon ) para nenhuma rede Thread. É aqui que entra ot-ctl . 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 de Thread simulados.
Em uma terceira janela de terminal, inicie ot-ctl :
$ ./output/posix/bin/ot-ctl >
Verifique o state do Nó 2 (o nó RCP) que você iniciou com ot-daemon :
> state disabled Done
Obtenha eui64 do Nó 2, para restringir a junção ao Joiner específico:
> eui64 18b4300000000001 Done
No Nó 1, 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, 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 se ele agora está conectado à rede. Em dois minutos, o Nó 2 faz a transição do child para o router :
> state child Done ... > state router Done
5. Valide a conectividade
Saia de ot-ctl usando Ctrl + D e na linha de comando de sua máquina host, execute ping no Nó 1, usando seu EID com o comando ping6 . Se a instância ot-daemon RCP for conectada e se comunicar com a rede Thread, o ping será bem-sucedido:
$ 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
Você simulou com sucesso sua primeira rede Thread usando OpenThread. Impressionante!
Neste Codelab, você aprendeu como:
- Configure o conjunto de ferramentas de compilação OpenThread
- Simular uma rede Thread
- Nós de thread de autenticação
- Gerenciar uma rede Thread com OpenThread Daemon
Se você quiser saber mais, explore estas referências: