1. Introdução
O que são Thread e OTNS
O Thread é um protocolo de rede mesh sem fio de baixo consumo energético baseado em IP que permite comunicações seguras entre dispositivos e entre dispositivos e a nuvem. As redes Thread podem se adaptar a mudanças na topologia para evitar um único ponto de falha.
O OpenThread lançado pelo Google é uma implementação de código aberto do Thread. Apesar do tamanho pequeno do código e da ocupação de memória, o OpenThread é compatível com todos os recursos definidos na especificação do Thread (em inglês).
O Simulador de rede OpenThread (OTNS) pode ser usado para simular redes Thread executando nós OpenThread simulados em plataformas posix. O OTNS oferece uma interface da Web fácil de usar (OTNS-Web) para visualizar e operar redes Thread simuladas. Também é possível fazer simulações programadas (com Python).
O que você vai aprender
- Instalar o OTNS e as dependências
- Conheça os conceitos básicos da OTNS-CLI
- Como adicionar/mover/excluir nós do OpenThread no OTNS-Web
- Use outros recursos úteis do OTNS-Web para controlar a simulação de rede.
- Verificar a ausência de ponto único de falha do OpenThread
- Conferir o tráfego de dados entre nós do OpenThread no Wireshark
Este codelab se concentra no OTNS-CLI e no OTNS-Web para uso interativo. Outros recursos do OTNS, como a programação de scripts em Python, não são abordados.
O que é necessário
- Primer de linhas de execução. Você precisa conhecer os conceitos básicos de Thread para entender o que é ensinado neste codelab.
- De preferência, Linux x86_64 ou macOS com Homebrew. O Ubuntu versão 24 ou mais recente no WSL2 do Windows também deve funcionar, mas pode exigir alguns ajustes manuais nas configurações.
- Git.
- Navegador da Web. O OTNS-Web usa um navegador da Web para mostrar simulações.
- Analisador de protocolo de rede Wireshark (opcional).
- Go versão 1.23 ou mais recente.
- O script de instalação vai verificar a versão instalada do Go.
- Se o Go não estiver instalado, ele vai instalar uma versão >= 1.23, se disponível no gerenciador de pacotes.
- Se não estiver disponível no gerenciador de pacotes, será necessária uma instalação manual.
- O Ubuntu 24.04 ou versões anteriores não são compatíveis com o Go 1.23 automaticamente. Consulte a página Versões disponíveis do Go na documentação do Ubuntu para mais detalhes. É possível fazer a instalação manual, usando
snapou outros procedimentos.
- Versão 3.9 ou mais recente do Python.
- O script de instalação vai verificar a versão do Python instalada.
- Se o Python 3 ainda não estiver instalado, ele vai instalar uma versão >= 3.9, se disponível no gerenciador de pacotes.
- Se não estiver disponível no gerenciador de pacotes, será necessária uma instalação manual.
Terminologia
O termo "roteador" é usado como o termo técnico para o extensor de malha Thread, que inicialmente era chamado de roteador Thread. "Nó" se refere a qualquer dispositivo OpenThread simulado em uma simulação do OTNS.
2. Instalação
Receber código OTNS
$ git clone https://github.com/openthread/ot-ns.git ./otns $ cd otns
Todos os comandos de console subsequentes neste codelab são executados no diretório otns.
Inicializar e instalar
O script bootstrap vai instalar dependências (incluindo Python 3 e Go/Golang, se necessário) e o OTNS. O script pode ser interrompido se não for possível instalar automaticamente algumas dependências, como Python versão >= 3.9 ou Go versão >= 1.23. A instalação automática exige que os pacotes sejam encontrados no repositório de pacotes configurado do sistema operacional.
O script também cria os vários tipos de nós de OT que podem ser usados diretamente em uma simulação e realiza alguns testes básicos. Devido a esses builds de nós, isso pode levar vários minutos.
$ ./script/bootstrap .... .... OTNS installed - use 'otns' to start it. $
Talvez seja necessário inserir uma senha para sudo durante a execução do script.
Se otns não estiver instalado corretamente
O script pode informar um erro como:
.... OTNS installed - please add ~/go/bin to your PATH variable first, to use it. $
Nesse caso, adicione $(go env GOPATH)/bin à variável $PATH.
Em caso de outros erros, crie um problema no GitHub.
3. Executar o OTNS pela primeira vez
Execute otns:
$ otns >_ ← OTNS-CLI prompt
Quando iniciado com sucesso, o OTNS entra em um console da CLI (OTNS-CLI) e inicia um navegador da Web para visualização e gerenciamento de rede (OTNS-Web):
Se você só vê uma página em branco para o OTNS-Web, é provável que o WebGL não esteja ativado no seu navegador. Consulte https://superuser.com/a/836833 para saber como ativar o WebGL.
Nas seções a seguir, você vai aprender a gerenciar simulações de OTNS usando OTNS-CLI e OTNS-Web.
4. Conheça o OTNS-CLI e o OTNS-Web
OTNS-CLI
OTNS-CLI é a interface de linha de comando (CLI) para gerenciar simulações do OTNS.
$ otns >_ ← OTNS-CLI prompt
Você pode digitar comandos usando OTNS-CLI. Consulte a referência da CLI do OTNS para conferir uma lista completa de comandos. Não se preocupe, você só vai usar alguns desses comandos neste codelab.
Digite o comando help para uma visão geral dos comandos da CLI. Essa lista é idêntica à referência da CLI.
> help add Add a node to the simulation and get the node ID. .... .... Done >
Para receber mais ajuda sobre um comando específico, use o nome dele. Por exemplo:
> help add add Add a node to the simulation and get the node ID. Definition: .... .... >
OTNS-Web
OTNS-Web é a ferramenta de visualização e gerenciamento de rede do OTNS. Ele oferece uma representação visual dos nós, mensagens e links da rede Thread simulada. Observe os vários elementos de OTNS-Web:
5. Adicionar nós
Adicionar nós usando a CLI do OTNS
Adicione um roteador Thread à simulação:
> add router 1 Done
Um nó será criado em OTNS-Web. O nó começa como um roteador e se torna um líder em alguns segundos:
Para facilitar o início de simulações interativas, cada novo nó do OpenThread é provisionado por padrão com um conjunto padrão de parâmetros de rede.
Adicionar mais nós usando OTNS-CLI
Agora vamos adicionar alguns nós de tipos diferentes.
> add fed 2 Done > add med 3 Done > add sed 4 Done
Aguarde alguns segundos para que os nós sejam mesclados em uma partição. Você vai ver os nós em OTNS-Web:
Também em OTNS-Web, é possível selecionar qualquer um dos nós para abrir um painel com mais informações sobre ele. Por exemplo, na figura abaixo, o nó 1 está selecionado. A entrada "Função" no painel confirma que é um líder.
Adicionar nós por OTNS-Web
Também é possível adicionar nós usando OTNS-Web. Clique no botão New Router do Action Bar. Um nó será criado à direita do nó selecionado. O novo roteador precisa entrar na partição Thread atual:
Clique também nos botões FED, MED, SSED e BR na barra de ações para criar esses outros tipos de nós. Agora deve haver nove nós no total. Se quiser, arraste alguns nós para outras posições e crie uma topologia de rede física diferente.
Agora você criou uma rede Thread de uma partição que contém muitos nós. Na próxima seção, vamos ajustar a velocidade de simulação para que ela seja executada mais rapidamente.
6. Ajustar velocidade
No momento, a simulação está sendo executada na velocidade 1X, o que significa que o tempo simulado decorrido até agora é o mesmo que o tempo real desde que criamos o primeiro nó.
Ajustar a velocidade usando OTNS-CLI
É possível ajustar a velocidade de simulação usando OTNS-CLI.
Definir a velocidade de simulação como 100X
> speed 100 Done
Os nós vão enviar mensagens com muito mais frequência do que antes.
Definir a velocidade de simulação como MAX
> speed max Done
Agora, o OTNS está tentando simular o mais rápido possível. Portanto, você vai ver os nós enviando um grande número de mensagens.
Pausar simulação
> speed 0 Done
Definir a velocidade de simulação como 0 pausa a simulação.
Restaurar a simulação na velocidade normal
> speed 1 Done
Definir a velocidade de simulação como um valor maior que 0 retoma a simulação.
Ajustar a velocidade usando OTNS-Web
Botões de controle de velocidade
Encontre os botões de controle de velocidade 
na Action Bar. Os botões mostram a velocidade de simulação atual e podem ser usados para ajustar a velocidade e pausar/retomar a simulação.
Acelerar a simulação
Clique no botão 
até que a velocidade chegue a MAX: 
.
Diminuir a velocidade da simulação
Clique no botão 
para desacelerar a simulação.
Pausar simulação
Clique no botão 
para pausar a simulação enquanto ela estiver em execução. O botão vai mudar para 
.
Retomar a simulação
Clique no botão para retomar a simulação quando ela estiver pausada. O botão vai voltar para .
Definir a velocidade de simulação como 10X
Para economizar tempo, use
OTNS-CLI para ajustar a velocidade de simulação para
10X para que possamos observar as mudanças na topologia da rede muito mais rápido.
> speed 10 Done
7. Ligar/desligar o rádio
Agora, a simulação precisa conter pelo menos dois roteadores (formato hexagonal), possivelmente um roteador de borda (formato quadrado) e muitos filhos, e ser executada na velocidade 10X.
Encontre o líder atual (borda vermelha) dos dois roteadores e clique uma vez para selecionar:
Desativar o rádio
Clique no botão 
na barra de ações para desativar o rádio do nó principal. O líder não poderá enviar nem receber mensagens com o rádio desligado.
Aguarde cerca de 12 segundos (120 segundos no tempo de simulação) para que o outro roteador ou roteador de borda se torne o novo líder:
A rede Thread se recupera automaticamente de uma falha do líder formando uma nova partição com um novo líder. A nova partição também tem uma nova cor.
Ativar o rádio
Selecione o líder cujo rádio foi desligado. Clique no botão 
em Action Bar para restaurar a conectividade de rádio:
O líder precisa se reconectar à rede depois que a conectividade de rádio for restaurada.
8. Mover nós
Com o OTNS, os usuários podem mover nós facilmente usando OTNS-CLI ou OTNS-Web.
Mover o nó por OTNS-CLI
Mova o nó do roteador de borda 9 para um novo local:
> move 9 50 50 Done
Mover o nó pelo OTNS-Web
Arraste o nó 5 até a parte de baixo à direita. Como o nó 5 está fora da cobertura de rádio dos outros roteadores, ele forma uma partição própria com um novo ID de partição. Para verificar os IDs de partição, clique nos nós no painel de informações do nó.
Uma única linha verde ainda é desenhada entre os nós 5 e 9. Isso geralmente acontece devido a informações desatualizadas sobre uma criança, que ainda são mantidas na tabela de crianças de um ex-responsável. Ou podem ser informações desatualizadas sobre o antigo link de roteador para roteador entre o nó 9 e o nó 5. Ou talvez, neste caso, até mesmo um bug de renderização. Com o tempo, as informações desatualizadas são limpas dos nós após o tempo limite adequado.
9. Excluir nós
Excluir nós usando OTNS-CLI
Excluir nó 5:
> del 5 Done
O nó 5 vai desaparecer da simulação:
Excluir nós usando OTNS-Web
Selecione o nó do roteador de borda 9 e clique no botão 
em Action Bar para excluir o nó 9:
Node 1 vai se tornar o líder de uma nova partição, e todos os nós restantes serão anexados como filhos ao nó 1.
10. Contexto do nó OTNS-CLI
O OTNS-CLI oferece o modo de contexto de nó para facilitar a interação com os nós e ajudar os desenvolvedores a diagnosticar o status de um nó. Além disso, as ações de nó podem ser iniciadas nesse modo.
Entrar no modo de contexto do nó
Insira o contexto do nó 1:
> node 1 Done node 1>
O prompt da CLI mudou para node 1> , indicando o contexto do nó atual. É possível digitar comandos da CLI do OpenThread para serem executados no nó como se você estivesse interagindo diretamente com ele.
Executar comandos no contexto do nó
node 1> state leader Done node 1> channel 11 Done node 1> panid 0xface Done node 1> networkname otns Done node 1> ipaddr fdde:ad00:beef:0:0:ff:fe00:fc00 fdde:ad00:beef:0:0:ff:fe00:b400 fd00:f00d:cafe:0:2505:8719:3685:ebfb fdde:ad00:beef:0:4fd9:b9ba:44e0:96cb fe80:0:0:0:e86a:e07:ec97:777 Done
Mudar para outro contexto de nó
node 1> node 2 Done node 2>
Contexto do nó de saída
node 1> exit Done >
Uma maneira alternativa de sair do contexto do nó é o comando node 0.
11. Como visualizar registros de nós e capturas de pacotes
Registros de nós OpenThread
Por padrão, o OTNS gera arquivos de registro detalhados para todos os nós OpenThread simulados. Eles podem ser visualizados no diretório ./tmp. O nome do arquivo é 0_. Por exemplo, um trecho de arquivo de registro é mostrado abaixo:
7616488 00:00:06.326 [I] MeshForwarder-: Received IPv6 UDP msg, len:90, chksum:5915, ecn:no, from:ca72650db7b856af, sec:no, prio:net, rss:-58.0
7616488 00:00:06.326 [I] MeshForwarder-: src:[fe80:0:0:0:c872:650d:b7b8:56af]:19788
7616488 00:00:06.326 [I] MeshForwarder-: dst:[ff02:0:0:0:0:0:0:1]:19788
7616488 00:00:06.326 [D] Mle-----------: Receive MLE message
7616488 00:00:06.326 [D] Mac-----------: Idle mode: Radio receiving on channel 11
7657544 00:00:06.367 [D] Mac-----------: ==============================[RX len=063]==============================
7657544 00:00:06.367 [D] Mac-----------: | 41 D8 7F CE FA FF FF 46 | 74 5A 33 9E 76 51 4E 7F | A......FtZ3.vQN. |
7657544 00:00:06.367 [D] Mac-----------: | 3B 02 F0 4D 4C 4D 4C 81 | E6 00 15 03 00 00 00 00 | ;..MLML......... |
7657544 00:00:06.367 [D] Mac-----------: | 00 00 00 01 46 86 7D FE | 06 CC DB 94 86 9C 88 0B | ....F.}......... |
7657544 00:00:06.367 [D] Mac-----------: | 1C 1E 26 9B 8D 21 2E 65 | 53 5A 43 4E A2 59 D6 | ..&..!.eSZCN.Y. |
7657544 00:00:06.367 [D] Mac-----------: ------------------------------------------------------------------------
7657544 00:00:06.367 [I] MeshForwarder-: Received IPv6 UDP msg, len:84, chksum:81e6, ecn:no, from:4e51769e335a7446, sec:no, prio:net, rss:-48.0
7657544 00:00:06.367 [I] MeshForwarder-: src:[fe80:0:0:0:4c51:769e:335a:7446]:19788
7657544 00:00:06.367 [I] MeshForwarder-: dst:[ff02:0:0:0:0:0:0:2]:19788
7657544 00:00:06.367 [D] Mac-----------: Idle mode: Radio receiving on channel 11
7833912 00:00:06.543 [I] Mle-----------: AttachState ParentReq -> Idle
7833912 00:00:06.543 [N] RouterTable---: Allocate router id 12
7833912 00:00:06.543 [N] Mle-----------: RLOC16 fffe -> 3000
7833912 set node RLOC16: fffe -> 3000
7833912 00:00:06.543 [D] SubMac--------: RadioShortAddress: 0x3000
7833912 00:00:06.543 [N] Mle-----------: Role detached -> leader
7833912 00:00:06.543 [N] Mle-----------: Partition ID 0x24c35f10
7833912 00:00:06.543 [I] RouterTable---: Route table
7833912 00:00:06.543 [I] RouterTable---: 12 0x3000 - me - leader
O tempo absoluto de simulação em microssegundos é mostrado à esquerda. O carimbo de data/hora hh:mm:ss mostra o carimbo de data/hora do próprio registro do nó OpenThread, que pode ser diferente do tempo absoluto de simulação.
Capturas de pacotes do Wireshark
Por padrão, todos os frames IEEE 802.15.4 transmitidos são capturados no arquivo PCAP current.pcap. Esse arquivo pode ser lido pelo Wireshark durante ou após a simulação. Devido à criptografia da camada de link do Thread, é necessário fazer uma configuração única no Wireshark para definir corretamente a chave de descriptografia do OTNS. Por padrão, uma chave de rede conhecida é usada para facilitar a descriptografia de frames pelo Wireshark.
Confira na captura de tela abaixo um exemplo de inspeção de pacotes do OpenThread no Wireshark.
Para configurar a chave de descriptografia, selecione no menu Editar -> Preferências. Na janela de preferências, selecione Protocolos -> IEEE 802.15.4. Clique no botão Editar... ao lado de "Chaves de descriptografia". Clique em + para criar uma nova entrada, insira a chave 00112233445566778899aabbccddeeff (32 caracteres) e selecione "Hash da linha de execução" no campo "Hash da chave". O "Índice da chave de descriptografia" pode ser deixado como 0. Em seguida, clique em OK e em OK novamente. Agora, o arquivo PCAP do OTNS será descriptografado corretamente quando carregado.
Os carimbos de data/hora mostrados na coluna "Tempo" (em segundos) correspondem aos valores absolutos de tempo de simulação mostrados nos registros do nó OpenThread. Isso facilita a correlação de mensagens de registro com frames de rádio transmitidos ou recebidos. No entanto, os valores normalmente não são idênticos até a precisão de um único microssegundo: o hardware de rádio IEEE 802.15.4 simulado pode adicionar um atraso extra depois que um frame de rádio é solicitado para ser enviado pela pilha OpenThread.
12. Parabéns
Parabéns, você executou sua primeira simulação do OTNS.
Você aprendeu a instalar o OTNS e as dependências dele. Você iniciou uma simulação do OTNS com nós simulados do OpenThread. Você aprendeu a manipular a simulação de várias maneiras usando OTNS-CLI e OTNS-Web.
Agora você sabe o que é o OTNS e como usá-lo para simular redes OpenThread.
A seguir
Confira alguns destes codelabs:
- Simulação de uma rede Thread com o OpenThread
- Simular uma rede Thread usando o OpenThread no Docker
- Criar uma rede Thread com placas nRF52840 e OpenThread