1. Introduction
Qu'est-ce que Thread et OTNS ?
Thread est un protocole de réseau maillé sans fil basse consommation basé sur IP qui permet de communiquer de manière sécurisée entre les appareils et le cloud. Les réseaux Thread peuvent s'adapter aux modifications de la topologie pour éviter tout point de défaillance unique.
OpenThread, publié par Google, est une implémentation Open Source de Thread. Malgré sa petite taille de code et son encombrement mémoire, OpenThread est compatible avec toutes les fonctionnalités définies dans la spécification Thread.
Le simulateur de réseau OpenThread (OTNS) permet de simuler des réseaux Thread en exécutant des nœuds OpenThread simulés sur des plates-formes POSIX. OTNS fournit une interface Web facile à utiliser (OTNS-Web) pour visualiser et exploiter des réseaux Thread simulés. Il est également possible de créer des simulations avec script (avec Python).
Points abordés
- Installer OTNS et ses dépendances
- Découvrez les principes de base de la CLI OTNS
- Ajouter/déplacer/supprimer des nœuds OpenThread dans OTNS-Web
- Utiliser les autres fonctionnalités utiles d'OTNS-Web pour contrôler la simulation de réseau
- Vérifier l'absence de point de défaillance unique dans OpenThread
- Afficher le trafic de données entre les nœuds OpenThread dans Wireshark
Cet atelier de programmation porte sur OTNS-CLI et OTNS-Web pour une utilisation interactive. Les autres fonctionnalités d'OTNS, telles que le script Python, ne sont pas abordées.
Prérequis
- De préférence Linux x86_64 ou Mac OS avec Homebrew. Ubuntu 22/24 dans WSL2 sous Windows devrait également fonctionner, mais vous devrez peut-être ajuster manuellement certains paramètres.
- Git
- Navigateur Web OTNS-Web utilise un navigateur Web pour afficher les simulations.
- Présentation des threads Vous devez connaître les concepts de base des threads pour comprendre ce qui est enseigné dans cet atelier de programmation.
Terminologie
Le terme "routeur" est utilisé comme terme technique pour le répéteur de réseau maillé Thread, qui était initialement appelé "routeur Thread". "Nœud" désigne tout appareil OpenThread simulé dans une simulation OTNS.
2. Installation
Obtenir un code OTNS
$ git clone https://github.com/openthread/ot-ns.git ./otns $ cd otns
Toutes les commandes de console ultérieures de cet atelier de programmation sont exécutées à partir du répertoire otns.
Amorcer et installer
Le script bootstrap installe les dépendances (y compris Python3 et Go/Golang, si nécessaire) et OTNS. Il compile également les différents types de nœuds OT pouvant être utilisés directement dans une simulation et effectue des tests de base. En raison des compilations de nœuds, cette opération peut prendre plusieurs minutes.
$ ./script/bootstrap .... .... OTNS installed - use 'otns' to start it. $
Vous devrez peut-être saisir un mot de passe pour sudo.
Si otns n'est pas correctement installé
Le script peut signaler une erreur semblable à la suivante:
.... OTNS installed - please add ~/go/bin to your PATH variable first, to use it. $
Dans ce cas, vous devez ajouter $(go env GOPATH)/bin à votre $PATH..
En cas d'autres erreurs, vous pouvez créer un problème GitHub.
3. Exécuter OTNS pour la première fois
Exécutez otns :
$ otns >_ ← OTNS-CLI prompt
Une fois démarré, OTNS ouvre une console CLI (OTNS-CLI) et lance un navigateur Web pour la visualisation et la gestion du réseau (OTNS-Web):
Si vous ne voyez qu'une page vide pour OTNS-Web, il est probable que WebGL ne soit pas activé dans votre navigateur. Pour savoir comment activer WebGL, consultez https://superuser.com/a/836833.
Dans les sections suivantes, vous allez apprendre à gérer les simulations OTNS via OTNS-CLI et OTNS-Web.
4. Découvrir OTNS-CLI et OTNS-Web
OTNS-CLI
OTNS-CLI est l'interface de ligne de commande (CLI) permettant de gérer les simulations OTNS.
$ otns >_ ← OTNS-CLI prompt
Vous pouvez saisir des commandes via OTNS-CLI. Pour obtenir la liste complète des commandes, consultez la documentation de référence de la CLI OTNS. Ne vous inquiétez pas, vous n'utiliserez que quelques-unes de ces commandes dans cet atelier de programmation.
Saisissez la commande help pour obtenir une présentation des commandes CLI. Cette liste est identique à la documentation de référence de la CLI.
> help add Add a node to the simulation and get the node ID. .... .... Done >
Pour obtenir de l'aide sur une commande spécifique, utilisez son nom, par exemple:
> help add add Add a node to the simulation and get the node ID. Definition: .... .... >
OTNS-Web
OTNS-Web est l'outil de visualisation et de gestion du réseau d'OTNS. Il fournit une représentation visuelle des nœuds, des messages et des liens du réseau Thread simulé. Notez les différents éléments de OTNS-Web:
5. Ajouter des nœuds
Ajouter des nœuds via OTNS-CLI
Ajoutez un routeur Thread à la simulation:
> add router 1 Done
Un nœud doit être créé dans OTNS-Web. Le nœud commence en tant que routeur et devient un leader en quelques secondes:
Pour faciliter le démarrage des simulations de manière interactive, chaque nouveau nœud OpenThread est mis en service par défaut avec un ensemble standard de paramètres réseau.
Ajouter des nœuds via OTNS-CLI
Nous allons maintenant ajouter des nœuds de différents types.
> add fed 2 Done > add med 3 Done > add sed 4 Done
Attendez quelques secondes que les nœuds fusionnent en une seule partition. Vous devriez voir les nœuds dans OTNS-Web:
Dans OTNS-Web, vous pouvez également sélectionner l'un des nœuds pour afficher un panneau contenant plus d'informations à son sujet. Par exemple, dans la figure ci-dessous, le nœud 1 est sélectionné. L'entrée "Rôle" du panneau confirme qu'il s'agit d'un leader.
Ajouter des nœuds par OTNS-Web
Vous pouvez également ajouter des nœuds via OTNS-Web. Cliquez sur le bouton New Router de Action Bar. Un nœud doit être créé à droite du nœud sélectionné. Le nouveau routeur doit rejoindre la partition Thread existante:
Cliquez également sur les boutons FED, MED, SSED et BR de la barre d'action pour créer ces autres types de nœuds. Vous devriez maintenant avoir neuf nœuds au total. Si vous le souhaitez, faites glisser certains nœuds vers d'autres positions pour créer une topologie de réseau physique différente.
Vous avez maintenant créé un réseau Thread composé d'une partition contenant de nombreux nœuds. Dans la section suivante, nous allons ajuster la vitesse de simulation pour accélérer la simulation.
6. Ajuster la vitesse
Actuellement, la simulation devrait s'exécuter à la vitesse 1X, ce qui signifie que le temps de simulation écoulé jusqu'à présent est identique au temps réel depuis la création du premier nœud.
Ajuster la vitesse via OTNS-CLI
Vous pouvez ajuster la vitesse de simulation via OTNS-CLI.
Définir la vitesse de simulation sur 100X
> speed 100 Done
Vous devriez voir les nœuds envoyer des messages beaucoup plus fréquemment qu'auparavant.
Définir la vitesse de simulation sur MAX
> speed max Done
OTNS s'efforce de simuler aussi rapidement que possible. Vous devriez donc voir les nœuds envoyer un grand nombre de messages.
Mise en pause de la simulation
> speed 0 Done
Définir la vitesse de simulation sur 0 met la simulation en pause.
Restaurer la simulation à vitesse normale
> speed 1 Done
Définir la vitesse de simulation sur une valeur supérieure à 0 reprend la simulation.
Ajuster la vitesse via OTNS-Web
Boutons de contrôle de la vitesse
Recherchez les boutons de contrôle de la vitesse 
sur le Action Bar. Les boutons indiquent la vitesse de simulation actuelle et permettent d'ajuster la vitesse de simulation, et de suspendre ou de reprendre la simulation.
Accélérer la simulation
Vous pouvez accélérer la simulation en cliquant sur le bouton 
jusqu'à ce que la vitesse atteigne MAX: 
.
ralentir la simulation ;
Vous pouvez ralentir la simulation en cliquant sur le bouton 
.
Mise en pause de la simulation
Cliquez sur le bouton 
pour suspendre la simulation lorsqu'elle est en cours d'exécution. Le bouton est remplacé par 
.
Reprendre la simulation
Cliquez sur le bouton pour reprendre la simulation lorsqu'elle est mise en pause. Le bouton est de nouveau défini sur .
Définir la vitesse de simulation sur 10X
Pour gagner du temps, utilisez
OTNS-CLI pour ajuster la vitesse de simulation sur
10X afin de pouvoir observer les changements de topologie dans le réseau beaucoup plus rapidement.
> speed 10 Done
7. Activer/Désactiver la radio
La simulation doit maintenant contenir au moins deux routeurs (de forme hexagonale), éventuellement un routeur de bordure (de forme carrée) et de nombreux enfants, et s'exécuter à une vitesse 10 fois supérieure.
Recherchez le leader actuel (bordure rouge) des deux routeurs, puis cliquez dessus pour le sélectionner:
Éteindre le signal radio
Cliquez sur le bouton 
dans la barre d'action pour désactiver la radio du nœud Leader. Le chef d'équipe ne pourra pas envoyer ni recevoir de messages lorsque la radio est éteinte.
Attendez environ 12 secondes (120 secondes en temps de simulation) pour que l'autre routeur ou routeur de bordure devienne le nouveau leader:
Le réseau Thread se rétablit automatiquement en cas de défaillance du leader en formant une nouvelle partition avec un nouveau leader. La nouvelle partition a également une nouvelle couleur.
Allumer le signal radio
Sélectionnez le leader dont la radio a été désactivée. Cliquez sur le bouton 
sur Action Bar pour rétablir la connectivité radio:
Le leader doit se reconnecter au réseau une fois la connectivité radio rétablie.
8. Déplacer des nœuds
OTNS permet aux utilisateurs de déplacer facilement des nœuds via OTNS-CLI ou OTNS-Web.
Déplacer un nœud via OTNS-CLI
Déplacez le nœud de routeur de bordure 9 vers un nouvel emplacement:
> move 9 50 50 Done
Déplacer un nœud via OTNS-Web
Déplacez le nœud 5 en bas à droite en le faisant glisser. Étant donné que le nœud 5 est désormais hors de portée radio des autres routeurs, il forme sa propre partition avec un nouvel ID de partition. Vous pouvez consulter les ID de partition dans le panneau d'informations sur les nœuds en cliquant dessus.
Notez qu'une seule ligne verte est toujours tracée entre les nœuds 5 et 9. Cela est souvent dû à des informations obsolètes sur un enfant, qui sont toujours conservées dans la table enfant d'un ancien parent. Il peut également s'agir d'informations obsolètes sur l'ancienne liaison de routeur à routeur entre le nœud 9 et le nœud 5. (ou même un bug de rendu, dans ce cas). Les informations obsolètes sont finalement nettoyées sur les nœuds après l'expiration du délai approprié.
9. Supprimer des nœuds
Supprimer des nœuds via OTNS-CLI
Supprimez le nœud 5:
> del 5 Done
Le nœud 5 doit disparaître de la simulation:
Supprimer des nœuds via OTNS-Web
Sélectionnez le nœud de routeur de bordure 9, puis cliquez sur le bouton 
dans Action Bar pour supprimer le nœud 9:
Node 1 doit devenir le leader d'une nouvelle partition, et tous les autres nœuds s'attachent en tant qu'enfant au nœud 1.
10. Contexte de nœud OTNS-CLI
OTNS-CLI fournit le mode de contexte de nœud pour faciliter les interactions avec les nœuds afin d'aider les développeurs à diagnostiquer l'état d'un nœud. Vous pouvez également lancer des actions de nœud à partir de ce mode.
Activer le mode de contexte du nœud
Saisissez le contexte du nœud 1:
> node 1 Done node 1>
L'invite de la CLI est passée à node 1> , ce qui indique le contexte de nœud actuel. Vous pouvez saisir des commandes OpenThread CLI à exécuter sur le nœud comme si vous interagissiez directement avec lui.
Exécuter des commandes dans le contexte du nœud
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
Passer à un autre contexte de nœud
node 1> node 2 Done node 2>
Quitter le contexte du nœud
node 1> exit Done >
Vous pouvez également quitter le contexte du nœud à l'aide de la commande node 0.
11. Afficher les journaux de nœud et les captures de paquets
Journaux de nœud OpenThread
Par défaut, OTNS génère des fichiers journaux détaillés pour tous les nœuds OpenThread simulés. Vous pouvez les consulter dans le répertoire ./tmp. Le nom du fichier est 0_. Voici un exemple d'extrait de fichier journal:
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
La durée de simulation absolue en microsecondes s'affiche à gauche. Le code temporel hh:mm:ss indique le code temporel de journal du nœud OpenThread, qui peut différer de l'heure de simulation absolue.
Captures de paquets Wireshark
Par défaut, toutes les trames IEEE 802.15.4 transmises sont capturées dans le fichier PCAP current.pcap. Ce fichier peut être lu par Wireshark pendant ou après la simulation. En raison du chiffrement de la couche liaison de données de Thread, une action de configuration unique dans Wireshark est nécessaire pour définir correctement la clé de déchiffrement d'OTNS. Par défaut, une clé réseau connue est utilisée pour faciliter le déchiffrement des trames par Wireshark.
La capture d'écran ci-dessous montre un exemple d'inspection de paquets OpenThread dans Wireshark.
Pour configurer la clé de déchiffrement, sélectionnez Édition -> Préférences dans le menu. Dans la fenêtre des préférences, sélectionnez Protocols -> IEEE 802.15.4 (Protocoles -> IEEE 802.15.4). Cliquez sur le bouton Modifier à côté de "Clés de déchiffrement". Cliquez sur + pour créer une entrée, saisissez la clé 00112233445566778899aabbccddeeff (32 caractères) et sélectionnez "Thread hash" (Hachage de thread) dans le champ "Key hash" (Hachage de clé). Vous pouvez laisser l'index de clé de déchiffrement sur 0. Cliquez ensuite sur OK, puis de nouveau sur OK. Le fichier PCAP OTNS devrait maintenant être correctement déchiffré lors de son chargement.
Les codes temporels affichés dans la colonne "Heure" (en secondes) correspondent aux valeurs de temps de simulation absolues affichées dans les journaux du nœud OpenThread. Il est ainsi plus facile de mettre en corrélation les messages de journal avec les trames radio transmises ou reçues. Toutefois, les valeurs ne sont généralement pas identiques avec une précision de microseconde: le matériel radio IEEE 802.15.4 simulé peut ajouter un délai supplémentaire après qu'un frame radio a été demandé à être envoyé par la pile OpenThread.
12. Félicitations
Félicitations, vous avez exécuté votre première simulation OTNS.
Vous avez appris à installer OTNS et ses dépendances. Vous avez lancé une simulation OTNS avec des nœuds OpenThread simulés. Vous avez appris à manipuler la simulation de différentes manières à l'aide de OTNS-CLI et OTNS-Web.
Vous savez maintenant ce qu'est OTNS et comment l'utiliser pour simuler des réseaux OpenThread.
Étape suivante
Découvrez quelques-uns des ateliers de programmation...
- Simuler un réseau Thread avec OpenThread
- Simuler un réseau Thread à l'aide d'OpenThread dans Docker
- Créer un réseau Thread avec des cartes nRF52840 et OpenThread