Simuler un réseau Thread avec OpenThread

1. Introduction

OpenThread publié par Google est une implémentation Open Source du protocole réseau Thread. Google Nest a lancé OpenThread afin de rendre la technologie utilisée dans les produits Nest largement accessible aux développeurs afin d’accélérer le développement de produits pour la maison connectée.

La spécification Thread définit un protocole de communication sans fil d'appareil à appareil fiable, sécurisé et à faible consommation d'énergie basé sur IPv6 pour les applications domestiques. OpenThread implémente toutes les couches réseau Thread, y compris IPv6, 6LoWPAN, IEEE 802.15.4 avec sécurité MAC, établissement de liens maillés et routage maillé.

Cet atelier de programmation vous explique comment simuler un réseau Thread sur des appareils de simulation.

Points abordés

• Configurer la chaîne d'outils de compilation OpenThread
• Simuler un réseau Thread
• Authentifier les nœuds Thread
• Gérer un réseau Thread avec le daemon OpenThread

Prérequis

• git
• Connaissances de base de Linux, le routage réseau

2. Configurer le système de compilation

Git

Git est requis pour cet atelier de programmation. Téléchargez-la et installez-la avant de continuer.

Télécharger Git

Une fois installé, suivez les instructions de votre système d’exploitation spécifique pour télécharger et compiler OpenThread.

XCode pour Mac OS X

XCode est requis pour installer et compiler OpenThread sous Mac OS X.

Télécharger XCode

Une fois XCode installé, installez les outils de ligne de commande XCode:

$ xcode-select --install

Compiler sur Linux / Mac OS X

Ces instructions d'installation ont été testées sur Ubuntu Server 14.04 LTS et sur Mac OS X Sierra 10.12.6.

Installez OpenThread. Les commandes bootstrap garantissent que la chaîne d'outils est installée et que l'environnement est correctement configuré:

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

Sous Windows

Si vous préférez Windows, nous vous recommandons d'essayer la version Docker de cet atelier de programmation.

Simulation OpenThread sur Docker

3. Créer les applications OpenThread

Une fois l'installation terminée, créez l'exemple d'application OpenThread. Pour cet atelier de programmation, nous utilisons l'exemple de simulation.

$ cd ~/src/openthread
$ ./script/cmake-build simulation

Créez maintenant le daemon OpenThread:

$ ./script/cmake-build posix -DOT_DAEMON=ON

4. Simuler un réseau Thread

L'exemple d'application que vous utiliserez pour cet atelier de programmation illustre une application OpenThread minimale qui expose les interfaces de configuration et de gestion OpenThread via une interface de ligne de commande (CLI) de base.

Cet exercice vous explique les étapes minimales requises pour pinguer un appareil Thread simulé à partir d'un autre appareil Thread simulé.

Remarque:Ce premier exercice n'inclut pas de configuration des paramètres réseau, comme l'ID PAN IEEE 802.15.4 ou la clé réseau des threads. OpenThread implémente actuellement des valeurs par défaut pour les paramètres réseau (qui peuvent être modifiées ultérieurement via la CLI).

La figure ci-dessous décrit une topologie de base d'un réseau Thread. Pour cet exercice, nous allons simuler les deux nœuds situés dans le cercle vert: un leader de thread et un routeur de thread avec une seule connexion entre eux.

Pinguer un nœud

1. Démarrer le nœud 1

Accédez au répertoire openthread et générez le processus CLI pour un appareil Thread simulé à l'aide du binaire ot-cli-ftd.

$ cd ~/src/openthread
$ ./build/simulation/examples/apps/cli/ot-cli-ftd 1

Remarque:Si vous ne voyez pas l'invite > après avoir exécuté cette commande, appuyez sur enter.

Ce binaire implémente un périphérique OpenThread simulé sur POSIX. Le pilote radio IEEE 802.15.4 est implémenté au-dessus de l'UDP (les trames IEEE 802.15.4 sont transmises dans les charges utiles UDP).

L'argument de 1 est un descripteur de fichier qui représente les bits les moins significatifs des "attribués par l'usine". IEEE EUI-64 pour l'appareil simulé. Cette valeur est également utilisée lors de la liaison à un port UDP pour l'émulation radio IEEE 802.15.4 (port = 9000 + descripteur de fichier). Dans cet atelier de programmation, chaque instance d'un appareil Thread simulé utilisera un descripteur de fichier différent.

Remarque:N'utilisez que des descripteurs de fichier de 1 ou d'une version ultérieure, comme indiqué dans cet atelier de programmation, lorsque vous générez le processus pour un appareil simulé. Un descripteur de fichier 0 est réservé à d'autres utilisations.

Créez un ensemble de données opérationnel et validez-le en tant qu'ensemble de données actif. L'ensemble de données opérationnel correspond à la configuration du réseau Thread que vous créez.

dataset init new crée un ensemble de données opérationnel avec des valeurs aléatoires. Vos valeurs seront différentes de celles présentées dans cet atelier de programmation. Remplacez les valeurs des exemples de commandes de l'atelier de programmation par les valeurs de votre ensemble de données opérationnel.

> 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

Validez cet ensemble de données en tant qu'ensemble de données actif:

> dataset commit active
Done

Affichez l'interface IPv6:

> ifconfig up
Done

Démarrer l'opération du protocole Thread:

> thread start
Done

Attendez quelques secondes, puis vérifiez que l'appareil est devenu Thread Leader. Le responsable est l'appareil responsable de la gestion de l'attribution des ID de routeur.

> state
leader
Done

Affichez les adresses IPv6 attribuées à l'interface Thread du nœud 1 (votre résultat sera différent):

> 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

Notez les types d'adresses IPv6 spécifiques:

• Commence par fd = mesh-local
• Commence par fe80 = lien-local

Les types d'adresses de réseau maillé local sont classés plus précisément:

• Contient ff:fe00 = outil de localisation de routeurs (RLOC)
• Ne contient pas ff:fe00 = identifiant du point de terminaison (EID)

Identifiez l'EID dans la sortie de votre console et notez-le pour une utilisation ultérieure. Dans l'exemple de résultat ci-dessus, l'EID est le suivant:

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

Le RLOC change à mesure que la topologie du réseau change et qu'un appareil Thread passe d'un état à un autre. L'EID est indépendant des changements de topologie et reste statique.

2. Démarrer le nœud 2

Ouvrez un nouveau terminal, accédez au répertoire openthread et générez le processus CLI. Voici votre deuxième appareil Thread de simulation:

$ cd ~/src/openthread
$ ./build/simulation/examples/apps/cli/ot-cli-ftd 2

Remarque:Si vous ne voyez pas l'invite > après avoir exécuté cette commande, appuyez sur enter.

Configurez la clé du réseau Thread et l'ID du PAN en utilisant les mêmes valeurs que l'ensemble de données opérationnel du nœud 1:

> dataset networkkey e4344ca17d1dca2a33f064992f31f786
Done
> dataset panid 0xc169
Done

Validez cet ensemble de données en tant qu'ensemble de données actif:

> dataset commit active
Done

Affichez l'interface IPv6:

> ifconfig up
Done

Démarrer l'opération du protocole Thread:

> thread start
Done

L'appareil s'initialise en tant qu'enfant. Un enfant Thread est équivalent à un appareil final, c'est-à-dire un périphérique Thread qui transmet et reçoit le trafic unicast uniquement avec un appareil parent.

> state
child
Done

Au bout de deux minutes, vous devriez voir l'état passer de child à router. Un routeur Thread est capable d'acheminer le trafic entre des appareils Thread. Elle est également appelée parent.

> state
router
Done

Vérifier le réseau

Pour vérifier facilement le réseau maillé, consultez la table du routeur.

1. Vérifier la connectivité

Sur le nœud 2, obtenez le RLOC16. Le RLOC16 correspond aux 16 derniers bits de l'adresse IPv6 RLOC de l'appareil.

> rloc16
5800
Done

Sur le nœud 1, consultez la table du routeur pour trouver le RLOC16 du nœud 2. Assurez-vous d'abord que le nœud 2 est passé à l'état du routeur.

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

Le RLOC 0xa800 du nœud 1 figure dans la table, ce qui confirme qu'il est connecté au maillage.

2. Pinguer le nœud 1 du nœud 2

Vérifier la connectivité entre les deux appareils Thread de simulation Dans le nœud 2, ping l'EID attribué au nœud 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

Appuyez sur enter pour revenir à l'invite de CLI >.

Tester le réseau

Maintenant que vous pouvez pinguer deux appareils Thread de simulation, testez le réseau maillé en mettant un nœud hors connexion.

Revenez au nœud 1 et arrêtez le thread:

> thread stop
Done

Passez au nœud 2 et vérifiez l'état. Au bout de deux minutes, le nœud 2 détecte que le nœud principal (nœud 1) est hors connexion. La transition du nœud 2 devrait donc apparaître en tant que leader du réseau:

> state
router
Done
...
> state
leader
Done

Une fois que vous avez confirmé, arrêtez le thread et rétablissez la configuration d'usine du nœud 2 avant de quitter. Une restauration de la configuration d'usine est effectuée pour s'assurer que les identifiants du réseau Thread que nous avons utilisés dans cet exercice ne seront pas transférés vers l'exercice suivant.

> thread stop
Done
> factoryreset
>
> exit

Rétablissez également la configuration d'usine et quittez le nœud 1:

> factoryreset
>
> exit

Consultez la documentation de référence de la CLI OpenThread pour explorer toutes les commandes CLI disponibles.

5. Authentifier les nœuds avec la mise en service

Dans l'exercice précédent, vous avez configuré un réseau Thread avec deux appareils de simulation et vérifié la connectivité. Toutefois, cela n'autorise que le trafic de liaison locale IPv6 non authentifié à passer entre les appareils. Pour acheminer le trafic IPv6 global entre eux (et Internet via un routeur de bordure Thread), les nœuds doivent être authentifiés.

Pour s'authentifier, un appareil doit agir en tant que "Commissaire". Le Commissioner est le serveur d'authentification actuellement élu pour les nouveaux appareils Thread et l'agent d'autorisation qui fournit les identifiants réseau requis pour que les appareils puissent le rejoindre.

Dans cet exercice, nous allons utiliser la même topologie à deux nœuds qu'auparavant. Pour l'authentification, le leader de thread agira en tant que commissaire, le routeur de threads en tant que jointer.

Les appareils sans interface Thread peuvent également jouer le rôle de commissaire. Par exemple, un téléphone portable ou un serveur dans le cloud peut fournir l'interface par laquelle un administrateur humain joint un nouvel appareil au réseau Thread. Ces appareils sont appelés commissaires externes.

1. Créer un réseau

Si vous poursuivez l'exercice précédent, vous devriez déjà avoir deux fenêtres de terminal ouvertes. Si ce n'est pas le cas, assurez-vous que deux d'entre eux sont ouverts et prêts à être utilisés. L'un servira de nœud 1, l'autre de nœud 2.

Dans le nœud 1, générez le processus CLI:

$ cd ~/src/openthread
$ ./build/simulation/examples/apps/cli/ot-cli-ftd 1

Remarque:Si vous ne voyez pas l'invite > après avoir exécuté cette commande, appuyez sur enter.

Créez un ensemble de données opérationnel, validez-le en tant qu'ensemble de données actif, puis démarrez le 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

Validez cet ensemble de données en tant qu'ensemble de données actif:

> dataset commit active
Done

Affichez l'interface IPv6:

> ifconfig up
Done

Démarrer l'opération du protocole Thread:

> thread start
Done

Attendez quelques secondes et vérifiez que l'appareil est devenu Thread Leader:

> state
leader
Done

2. Démarrer le rôle de commissaire

Toujours sur le nœud 1, démarrez le rôle "Commissaire" :

> commissioner start
Done

Autorisez toutes les jointures (en utilisant le caractère générique *) disposant de l'identifiant Joiner J01NME à être mise en service sur le réseau. Un Joiner est un appareil ajouté par un administrateur humain à un réseau Thread mis en service.

> commissioner joiner add * J01NME
Done

J01NME est l'identifiant Joiner défini par l'utilisateur et utilisé pour cet atelier de programmation. Vous pouvez choisir n'importe quel identifiant Joiner dans une autre implémentation d'un réseau Thread. L'identifiant Joiner est une chaîne spécifique à l'appareil composée de tous les caractères alphanumériques en majuscules (0-9 et A-Y, à l'exclusion des I, O, Q et Z pour la lisibilité), d'une longueur comprise entre 6 et 32 caractères. Pour en savoir plus, consultez Mise en service de threads.

3. Démarrer le rôle Joiner

Dans une deuxième fenêtre de terminal, générez un nouveau processus CLI. Il s'agit du nœud 2.

$ cd ~/src/openthread
$ ./build/simulation/examples/apps/cli/ot-cli-ftd 2

Sur le nœud 2, activez le rôle Joiner à l'aide des identifiants Joiner J01NME.

> ifconfig up
Done
> joiner start J01NME
Done

... patientez quelques secondes pour confirmation ...

Join success

En tant que Joiner, l'appareil (Node 2) s'est authentifié auprès du Commissioner (Node 1) et a reçu les identifiants du réseau Thread.

Si vous recevez un message Join failed, il se peut que le Commissioner ait dépassé le délai d'attente de la demande d'adhésion. Dans ce cas, redémarrez à partir de la commande commissioner joiner. N'attendez pas trop longtemps après avoir démarré le rôle "Commissaire" pour activer le rôle "Joiner".

Il se peut également que vous receviez des messages d'erreur et/ou de journal sur les nœuds 1 et 2 après une jointure réussie. Ces erreurs sont normales et peuvent être ignorées.

Maintenant que le nœud 2 est authentifié, démarrez Thread:

> thread start
Done

4. Valider l'authentification réseau

Vérifiez le state sur le nœud 2 pour confirmer qu'il a maintenant rejoint le réseau. En deux minutes, le nœud 2 passe de child à router:

> state
child
Done
...
> state
router
Done

5. Réinitialiser la configuration

Pour préparer l'exercice suivant, réinitialisez la configuration. Sur chaque nœud, arrêtez le thread, rétablissez la configuration d'usine et quittez l'appareil Thread simulé:

> thread stop
Done
> factoryreset
>
> exit

Vous devrez peut-être appuyer sur enter plusieurs fois pour que l'invite > réapparaisse après une commande factoryreset.

6. Gérer le réseau avec le daemon OpenThread

Pour cet exercice, nous allons simuler une instance CLI (un seul appareil de thread SoC intégré) et une instance de co-processeur radio (RCP).

ot-daemon est un mode de l'application OpenThread Posix qui utilise un socket UNIX en entrée et en sortie, afin que le cœur OpenThread puisse s'exécuter en tant que service. Un client peut communiquer avec ce service en se connectant au socket en utilisant la CLI OpenThread comme protocole.

ot-ctl est une CLI fournie par ot-daemon pour gérer et configurer le RCP. À l'aide de cela, nous connecterons le RCP au réseau créé par l'appareil Thread.

Utiliser ot-daemon

Cet exercice utilise trois fenêtres de terminal, correspondant aux éléments suivants:

1. Instance CLI de l'appareil Thread simulé (nœud 1)
2. Nœud de traitement ot-daemon
3. Instance CLI ot-ctl

Si vous continuez à partir de l'exercice précédent, deux fenêtres de terminal doivent déjà être ouvertes. Ouvrez-en une troisième pour vous assurer que vous disposez de trois fenêtres de terminal pour cet exercice.

1. Démarrer le nœud 1

Dans la première fenêtre de terminal, générez le processus CLI pour votre appareil Thread simulé:

$ cd ~/src/openthread
$ ./build/simulation/examples/apps/cli/ot-cli-ftd 1

Remarque:Si vous ne voyez pas l'invite > après avoir exécuté cette commande, appuyez sur enter.

Créez un ensemble de données opérationnel, validez-le en tant qu'ensemble de données actif, puis démarrez le 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

Validez cet ensemble de données en tant qu'ensemble de données actif:

> dataset commit active
Done

Affichez l'interface IPv6:

> ifconfig up
Done

Démarrer l'opération du protocole Thread:

> thread start
Done

channel correspond au canal 2,4 GHz, tel que défini dans la norme IEEE 802.15.4. Les valeurs non réservées sont comprises entre 11 et 26.

Le champ networkkey peut être n'importe quelle chaîne de 32 caractères hexadécimaux définie par l'utilisateur. Si aucune clé n'est spécifiée, networkkey est défini par défaut sur 00112233445566778899AABBCCDDEEFF, et les appareils peuvent rejoindre le réseau sans avoir à spécifier de clé.

Affichez les adresses IPv6 attribuées à l'interface Thread du nœud 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
>

Comme expliqué dans l'étape Simuler un réseau Thread, une adresse est de type liaison locale (fe80) et trois sont de type réseau maillé (fd). L'EID est l'adresse du réseau maillé local dont l'adresse ne contient pas ff:fe00. Dans cet exemple de résultat, l'EID est fd55:cf34:dea5:7994:460:872c:e807:c4ab.

Identifiez l'EID spécifique dans la sortie ipaddr, qui sera utilisé pour communiquer avec le nœud.

2. Démarrer ot-daemon

Dans la deuxième fenêtre de terminal, accédez au répertoire openthread et démarrez ot-daemon pour un nœud RCP, que nous appellerons "Node 2". Utilisez l'indicateur détaillé -v pour afficher la sortie du journal et vérifier qu'elle est en cours d'exécution. Veillez à utiliser sudo:

$ cd ~/src/openthread
$ sudo ./build/posix/src/posix/ot-daemon -v \
    'spinel+hdlc+forkpty://build/simulation/examples/apps/ncp/ot-rcp?forkpty-arg=2'

Si l'opération réussit, ot-daemon en mode détaillé génère un résultat semblable à celui-ci:

ot-daemon[12463]: Running OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; POSIX; Aug 30 2022 10:55:05
ot-daemon[12463]: Thread version: 4
ot-daemon[12463]: Thread interface: wpan0
ot-daemon[12463]: RCP version: OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; SIMULATION; Aug 30 2022 10:54:10

Laissez ce terminal ouvert et exécuté en arrière-plan. Vous n'y saisirez aucune autre commande.

3. Utiliser ot-ctl pour rejoindre le réseau

Nous n'avons encore mis en service le nœud 2 (le RCP ot-daemon) d'aucun réseau Thread. C'est là que ot-ctl entre en jeu. ot-ctl utilise la même CLI que l'application CLI OpenThread. Par conséquent, vous pouvez contrôler les nœuds ot-daemon de la même manière que les autres appareils Thread simulés.

Dans une troisième fenêtre de terminal, démarrez ot-ctl:

$ sudo ./build/posix/src/posix/ot-ctl
>

Remarque:Si vous ne voyez pas l'invite > après avoir exécuté cette commande, appuyez sur enter.

Vous allez utiliser ot-ctl dans cette troisième fenêtre de terminal pour gérer le nœud 2 (le nœud RCP) que vous avez démarré dans la deuxième fenêtre de terminal avec ot-daemon. Vérifiez le state du nœud 2:

> state
disabled
Done

Obtenez le eui64 du nœud 2 pour limiter la jointure à la jointure spécifique:

> eui64
18b4300000000001
Done

Sur le nœud 1 (première fenêtre de terminal), démarrez le "Commissioner" et limitez la jointure à cette interface utilisateur:

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

Sur le nœud 2 (troisième fenêtre de terminal), affichez l'interface réseau et rejoignez le réseau:

> ifconfig up
Done
> joiner start J01NME
Done

... patientez quelques secondes pour confirmation ...

Join success

En tant que Joiner, le RCP (Node 2) s'est authentifié avec le Commissaire (Node 1) et a reçu les identifiants du réseau Thread.

Si vous recevez un message Join failed, il se peut que le Commissioner ait dépassé le délai d'attente de la demande d'adhésion. Dans ce cas, redémarrez à partir de la commande commissioner joiner. N'attendez pas trop longtemps après avoir démarré le rôle "Commissaire" pour activer le rôle "Joiner".

Joignez maintenant le nœud 2 au réseau Thread:

> thread start
Done

4. Valider l'authentification réseau

Vérifiez le state sur le nœud 2 pour confirmer qu'il a maintenant rejoint le réseau. En deux minutes, le nœud 2 passe de child à router:

> state
child
Done
...
> state
router
Done

5. Valider la connectivité

Quittez ot-ctl à l'aide de la commande Ctrl+D ou exit, puis sur la ligne de commande de votre machine hôte, pinguez le nœud 1 en utilisant son EID avec la commande ping6. Si l'instance RCP ot-daemon est correctement jointe au réseau Thread et qu'elle communique avec lui, le ping aboutit:

$ 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. Félicitations !

Vous avez réussi à simuler votre premier réseau Thread à l'aide d'OpenThread. Parfait !

Dans cet atelier de programmation, vous avez appris à :

• Configurer la chaîne d'outils de compilation OpenThread
• Simuler un réseau Thread
• Authentifier les nœuds Thread
• Gérer un réseau Thread avec un daemon OpenThread

Pour en savoir plus, consultez les références suivantes:

• Thread Primer sur openthread.io
• Spécification du thread
• Dépôt GitHub OpenThread
• Référence de la CLI OpenThread