OpenThread publié par Google est une implémentation open-source du protocole de mise en réseau Thread . Google Nest a lancé OpenThread pour 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 appareil à appareil sans fil fiable, sécurisé et de faible puissance basé sur IPv6 pour les applications domestiques. OpenThread implémente toutes les couches de réseau Thread, y compris IPv6, 6LoWPAN, IEEE 802.15.4 avec sécurité MAC, établissement de liens maillés et routage maillé.
Ce Codelab vous guidera tout au long de la simulation d'un réseau Thread sur des appareils émulés à l'aide de Docker.
Ce que tu apprendras
- Comment configurer la chaîne d'outils de construction OpenThread
- Comment simuler un réseau Thread
- Comment authentifier les nœuds de thread
- Comment gérer un réseau Thread avec OpenThread Daemon
Ce dont vous aurez besoin
- Docker
- Connaissance de base de Linux, routage réseau
Ce Codelab est conçu pour utiliser Docker sur une machine Linux, Mac OS X ou Windows. Linux est l'environnement recommandé.
Installer Docker
Installez Docker sur le système d'exploitation de votre choix.
Tirez l'image Docker
Une fois Docker installé, ouvrez une fenêtre de terminal et tirez l'image Docker openthread/codelab_otsim . Cette image présente OpenThread et OpenThread Daemon pré-construits et prêts à être utilisés pour ce Codelab.
$ docker pull openthread/codelab_otsim:latest
Notez que le téléchargement complet peut prendre quelques minutes.
Dans une fenêtre de terminal, démarrez un conteneur Docker à partir de l'image et connectez-vous à son shell bash :
$ docker run --name codelab_otsim_ctnr -it --rm \ --sysctl net.ipv6.conf.all.disable_ipv6=0 \ --cap-add=net_admin openthread/codelab_otsim bash
Notez les indicateurs, qui sont requis pour ce Codelab:
-
--sysctl net.ipv6.conf.all.disable_ipv6=0- cela active IPv6 dans le conteneur -
--cap-add=net_admin- active la capacité NET_ADMIN, qui vous permet d'exécuter des opérations liées au réseau, telles que l'ajout de routes IP
Une fois dans le conteneur, vous devriez avoir une invite similaire à celle-ci:
root@c0f3912a74ff:/#
Dans l'exemple ci-dessus, le c0f3912a74ff est l'ID du conteneur. L'ID de conteneur de votre instance du conteneur Docker sera différent de celui affiché dans les invites de ce Codelab.
Utilisation de Docker
Ce Codelab suppose que vous connaissez les bases de l'utilisation de Docker. Vous devez rester dans le conteneur Docker pour l'intégralité du Codelab.
L'exemple d'application que vous utiliserez pour ce Codelab illustre une application OpenThread minimale qui expose la configuration d'OpenThread et les interfaces de gestion via une interface de ligne de commande (CLI) de base.
Cet exercice vous guide à travers les étapes minimales requises pour envoyer une requête ping à un périphérique Thread émulé à partir d'un autre périphérique Thread émulé.
La figure ci-dessous décrit une topologie de réseau Thread de base. Pour cet exercice, nous émulerons les deux nœuds dans le cercle vert: un Thread Leader et un Thread Router avec une seule connexion entre eux.
Créer le réseau
1. Démarrez le nœud 1
Si vous ne l'avez pas déjà fait, dans une fenêtre de terminal, démarrez le conteneur Docker et connectez-vous à son shell bash :
$ docker run --name codelab_otsim_ctnr -it --rm \ --sysctl net.ipv6.conf.all.disable_ipv6=0 \ --cap-add=net_admin openthread/codelab_otsim bash
Dans le conteneur Docker, accédez au répertoire openthread et openthread le processus CLI pour un périphérique Thread émulé à l'aide du binaire ot-cli-ftd .
root@c0f3912a74ff:/# cd ~/src/openthread root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 1
Ce binaire implémente un périphérique OpenThread émulé au-dessus de POSIX. Le pilote radio IEEE 802.15.4 est implémenté au-dessus d'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 de l'IEEE EUI-64 «assignée en usine» pour le périphérique émulé. 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). Chaque instance d'un périphérique Thread émulé dans ce Codelab utilisera un descripteur de fichier différent.
Remarque: utilisez uniquement des descripteurs de fichier de 1 ou plus, comme indiqué dans ce laboratoire de codes, lors de la création du processus pour un périphérique émulé. Un descripteur de fichier de 0 est réservé pour une autre utilisation.
Si vous ne voyez pas l' invite > après avoir exécuté cette commande, appuyez sur enter .
Créez un nouvel ensemble de données opérationnelles et validez-le comme étant actif. Le jeu de données opérationnel est la configuration du réseau Thread que vous créez.
> 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
Validez cet ensemble de données en tant qu'actif:
> dataset commit active Done
Affichez l'interface IPv6:
> ifconfig up Done
Démarrez le fonctionnement du protocole Thread:
> thread start Done
Attendez quelques secondes et vérifiez que l'appareil est devenu le Thread Leader. Le leader 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 sortie sera différente):
> 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= link-local
Les types d'adresses locales de maillage sont classés plus en détail:
- Contient
ff:fe00= Router Locator (RLOC) - Ne contient pas
ff:fe00= Endpoint Identifier (EID)
Identifiez l'EID dans la sortie de votre console, notez-le pour une utilisation ultérieure. Dans l'exemple de sortie ci-dessus, l'EID est:
fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
2. Démarrez le nœud 2
Ouvrez un nouveau terminal et exécutez un shell bash dans le conteneur Docker en cours d'exécution à utiliser pour Node 2.
$ docker exec -it codelab_otsim_ctnr bash
À cette nouvelle invite bash , accédez au répertoire openthread et openthread le processus CLI. Ceci est votre deuxième appareil Thread émulé:
root@c0f3912a74ff:/# cd ~/src/openthread root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 2
Si vous ne voyez pas l' invite > après avoir exécuté cette commande, appuyez sur enter .
Configurez la clé principale de thread et l'ID PAN, en utilisant les mêmes valeurs que le jeu de données opérationnel du nœud 1:
> dataset masterkey e4344ca17d1dca2a33f064992f31f786 Done > dataset panid 0xc169 Done
Validez cet ensemble de données en tant qu'actif:
> dataset commit active Done
Affichez l'interface IPv6:
> ifconfig up Done
Démarrez le fonctionnement du protocole Thread:
> thread start Done
L'appareil s'initialise en tant qu'enfant. Un Thread Child équivaut à un End Device, qui est un Thread qui transmet et reçoit le trafic de monodiffusion uniquement avec un appareil Parent.
> state child Done
Dans les 2 minutes, vous devriez voir l'état passer de l' child au router . Un Thread Router est capable de router le trafic entre les périphériques Thread. Il est également appelé parent.
> state router Done
Vérifiez le réseau
Un moyen simple de vérifier le réseau maillé est de consulter le tableau des routeurs.
1. Vérifiez la connectivité
Sur le nœud 2, récupérez 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, vérifiez la table des routeurs pour le RLOC16 du nœud 2. Assurez-vous que le nœud 2 est d'abord passé à l'état du routeur.
> router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+--------+-------+---+--------------------+ | 20 | 0x5000 | 63 | 0 | 0 | 0 | 0 | 96da92ea13534f3b | | 22 | 0x5800 | 63 | 0 | 3 | 3 | 23 | 5a4eb647eb6bc66c |
Le RLOC du nœud 2 de 0x5800 se trouve dans le tableau, confirmant qu'il est connecté au maillage.
2. Ping Node 1 depuis Node 2
Vérifiez la connectivité entre les deux périphériques Thread émulés. Dans le nœud 2, ping une requête 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 > CLI.
Tester le réseau
Maintenant que vous pouvez exécuter un ping entre deux périphériques Thread émulés, testez le réseau maillé en mettant un nœud hors ligne.
Revenez au nœud 1 et arrêtez Thread:
> thread stop Done
Basculez vers le nœud 2 et vérifiez l'état. En moins de deux minutes, le nœud 2 détecte que le leader (nœud 1) est hors ligne et vous devriez voir la transition du nœud 2 pour être le leader du réseau:
> state router Done ... > state leader Done
Une fois confirmé, arrêtez Thread et réinitialisez le nœud 2 avant de revenir à l'invite Docker bash . Une réinitialisation d'usine est effectuée pour garantir que les informations d'identification du réseau Thread que nous avons utilisées dans cet exercice ne sont pas reportées à l'exercice suivant.
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
Vous devrez peut-être appuyer plusieurs fois sur enter pour ramener l'invite > après une commande de factoryreset . Ne quittez pas le conteneur Docker.
Également réinitialisé aux paramètres d'usine et quitter le nœud 1:
> factoryreset > > exit root@c0f3912a74ff:/#
Consultez la référence de la CLI OpenThread pour explorer toutes les commandes CLI disponibles.
Dans l'exercice précédent, vous avez configuré un réseau Thread avec deux appareils simulés et une connectivité vérifiée. Cependant, cela permet uniquement au trafic lien-local IPv6 non authentifié de passer entre les appareils. Pour acheminer le trafic IPv6 global entre eux (et Internet via un routeur frontière Thread), les nœuds doivent être authentifiés.
Afin de s'authentifier, un appareil doit agir en tant que commissaire. Le commissaire est le serveur d'authentification actuellement élu pour les nouveaux appareils Thread et l'autorisateur pour fournir les informations d'identification réseau requises pour que les appareils rejoignent le réseau.
Dans cet exercice, nous utiliserons la même topologie à deux nœuds qu'auparavant. Pour l'authentification, le Thread Leader agira en tant que Commissaire, le Thread Router en tant que Joiner.
Docker
Pour chaque nœud (fenêtre de terminal) dans les exercices restants, assurez-vous que vous exécutez le conteneur Docker avec la version OpenThread. Si vous continuez à partir de l'exercice précédent, vous devriez toujours avoir deux invites bash dans le même conteneur Docker déjà ouvertes. Sinon, reportez-vous à l'étape de dépannage de Docker ou recommencez simplement l'exercice Simulate a Thread network .
1. Créez un réseau
Dans le nœud 1, lancez le processus CLI:
root@c0f3912a74ff:/# cd ~/src/openthread root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 1
Si vous ne voyez pas l' invite > après avoir exécuté cette commande, appuyez sur enter .
Créez un nouvel ensemble de données opérationnelles, validez-le comme étant actif et démarrez 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
Validez cet ensemble de données en tant qu'actif:
> dataset commit active Done
Affichez l'interface IPv6:
> ifconfig up Done
Démarrez le fonctionnement du protocole Thread:
> thread start Done
Attendez quelques secondes et vérifiez que l'appareil est devenu un Thread Leader:
> state leader Done
2. Commencer le rôle de commissaire
Tout en restant sur le nœud 1, démarrez le rôle de commissaire:
> commissioner start Done
Autorisez n'importe quel Joiner (en utilisant le caractère générique * ) avec le J01NME Joiner Credential à mettre en service sur le réseau. Un Joiner est un appareil ajouté par un administrateur humain à un Thread Network commandé.
> commissioner joiner add * J01NME Done
3. Démarrez le rôle Joiner
Dans une deuxième fenêtre de terminal, dans le conteneur Docker, créez un nouveau processus CLI. Il s'agit du nœud 2.
root@c0f3912a74ff:/# cd ~/src/openthread root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 2
Sur le nœud 2, activez le rôle Joiner à l'aide des J01NME identification J01NME Joiner.
> ifconfig up Done > joiner start J01NME Done
... attendez quelques secondes pour confirmation ...
Join success
En tant que Joiner, l'appareil (Nœud 2) s'est authentifié avec succès auprès du Commissaire (Nœud 1) et a reçu les informations d'identification de Thread Network.
Maintenant que le nœud 2 est authentifié, démarrez Thread:
> thread start Done
4. Validez l'authentification réseau
Vérifiez l' state sur le nœud 2, pour valider qu'il a maintenant rejoint le réseau. En deux minutes, le nœud 2 passe de l' child au router :
> state child Done ... > state router Done
5. Réinitialiser la configuration
Pour vous préparer à l'exercice suivant, réinitialisez la configuration. Sur chaque nœud, arrêtez Thread, effectuez une réinitialisation d'usine et quittez le périphérique Thread émulé:
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
Vous devrez peut-être appuyer sur enter plusieurs fois pour ramener l'invite > après une commande de factoryreset .
Pour cet exercice, nous allons simuler une instance CLI (un seul périphérique SoC Thread intégré) et une instance de Radio Co-Processor (RCP).
ot-daemon est un mode de l'application OpenThread Posix qui utilise un socket UNIX comme entrée et sortie, afin que OpenThread core puisse s'exécuter en tant que service. Un client peut communiquer avec ce service en se connectant au socket en utilisant l'interface de ligne de commande OpenThread comme protocole.
ot-ctl est une CLI fournie par ot-daemon pour gérer et configurer le RCP. En utilisant cela, nous connecterons le RCP au réseau créé par le périphérique Thread.
Docker
Pour chaque nœud (fenêtre de terminal) de cet exercice, assurez-vous que vous exécutez le conteneur Docker avec la version OpenThread. Si vous continuez à partir de l'exercice précédent, vous devriez avoir deux invites bash dans le même conteneur Docker déjà ouvertes. Sinon, reportez-vous à l'étape de dépannage de Docker .
Utilisez ot-daemon
Cet exercice utilisera trois fenêtres de terminal, correspondant à ce qui suit:
- Instance CLI du périphérique Thread simulé (Nœud 1)
- processus
ot-daemon - Instance CLI
ot-ctl
1. Démarrez le nœud 1
Dans la première fenêtre de terminal, lancez le processus CLI pour votre périphérique Thread émulé:
root@c0f3912a74ff:/# cd ~/src/openthread root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 1
Si vous ne voyez pas l' invite > après avoir exécuté cette commande, appuyez sur enter .
Créez un nouvel ensemble de données opérationnelles, validez-le comme étant actif et démarrez 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
Validez cet ensemble de données en tant qu'actif:
> dataset commit active Done
Affichez l'interface IPv6:
> ifconfig up Done
Démarrez le fonctionnement du protocole Thread:
> thread start Done
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 link-local ( fe80 ) et trois sont mesh-local ( fd ). L'EID est l'adresse locale du maillage qui ne contient pas ff:fe00 dans l'adresse. Dans cet exemple de sortie, l'EID est fd55:cf34:dea5:7994:460:872c:e807:c4ab .
Identifiez l'EID spécifique de votre sortie ipaddr , qui sera utilisé pour communiquer avec le nœud.
2. Démarrez ot-daemon
Dans la deuxième fenêtre de terminal, créez un nœud de périphérique tun et définissez les autorisations de lecture / écriture:
root@c0f3912a74ff:/# mkdir -p /dev/net && mknod /dev/net/tun c 10 200 root@c0f3912a74ff:/# chmod 600 /dev/net/tun
Cet appareil est utilisé pour la transmission et la réception de paquets dans des appareils virtuels. Vous pouvez obtenir une erreur si le périphérique a déjà été créé. Ceci est normal et peut être ignoré.
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 voir la sortie du journal et confirmer son exécution:
root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/posix/bin/ot-daemon -v \
'spinel+hdlc+forkpty://output/simulation/bin/ot-rcp?forkpty-arg=2'
En cas de succès, ot-daemon en mode détaillé génère une sortie similaire à ce qui suit:
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. Utilisez ot-ctl pour rejoindre le réseau
Nous n'avons pas encore mis en service Node 2 (le RCP ot-daemon ) sur un réseau Thread. C'est là ot-ctl vient. ot-ctl utilise la même CLI que l'application OpenThread CLI. Par conséquent, vous pouvez contrôler les nœuds ot-daemon de la même manière que les autres périphériques Thread simulés.
Ouvrez une troisième fenêtre de terminal et exécutez le conteneur existant:
$ docker exec -it codelab_otsim_ctnr bash
Une fois dans le conteneur, lancez ot-ctl :
root@c0f3912a74ff:/# cd ~/src/openthread root@c0f3912a74ff:/# ./output/posix/bin/ot-ctl >
Vérifiez l' state du nœud 2 (le nœud RCP) que vous avez démarré avec ot-daemon :
> state disabled Done
Obtenez l' eui64 Node 2 pour restreindre l'adhésion au Joiner spécifique:
> eui64 18b4300000000001 Done
Sur le nœud 1, démarrez le commissaire et limitez l'adhésion à seulement cet eui64:
> commissioner start Done > commissioner joiner add 18b4300000000001 J01NME Done
Sur le nœud 2, affichez l'interface réseau et rejoignez le réseau:
> ifconfig up Done > joiner start J01NME Done
... attendez quelques secondes pour confirmation ...
Join success
En tant que Joiner, le RCP (Node 2) s'est authentifié avec succès auprès du Commissaire (Node 1) et a reçu les informations d'identification du Thread Network.
Rejoignez maintenant Node 2 sur le réseau Thread:
> thread start Done
4. Validez l'authentification réseau
Vérifiez l' state sur le nœud 2, pour valider qu'il a maintenant rejoint le réseau. En deux minutes, le nœud 2 passe de l' child au router :
> state child Done ... > state router Done
5. Validez la connectivité
Quittez ot-ctl en utilisant Ctrl + D et sur la ligne de commande de votre machine hôte, ping6 ping au nœud 1, en utilisant son EID avec la commande ping6 . Si l'instance RCP ot-daemon est correctement jointe et communique avec le réseau Thread, le ping réussit:
root@c0f3912a74ff:/# 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
Si vous avez quitté les invites de bash conteneur Docker , vous devrez peut-être vérifier s'il est en cours d'exécution et redémarrer / ressaisir si nécessaire.
Pour afficher les conteneurs Docker en cours d'exécution:
$ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 505fc57ffc72 codelab_otsim "bash" 10 minutes ago Up 10 minutes codelab_otsim_ctnr
Pour afficher tous les conteneurs Docker (en cours d'exécution et arrêtés):
$ docker ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 505fc57ffc72 codelab_otsim "bash" 10 minutes ago Up 10 minutes codelab_otsim_ctnr
Si vous ne voyez pas le conteneur codelab_otsim_ctnr dans la sortie de l'une ou l'autre des commandes docker ps , exécutez-le à nouveau:
$ docker run --name codelab_otsim_ctnr -it --rm \ --sysctl net.ipv6.conf.all.disable_ipv6=0 \ --cap-add=net_admin openthread/codelab_otsim bash
Si le conteneur est arrêté (répertorié dans docker ps -a mais pas docker ps ), redémarrez-le:
$ docker start -i codelab_otsim_ctnr
Si le conteneur Docker est déjà en cours d'exécution (répertorié dans docker ps ), reconnectez-vous au conteneur dans chaque terminal:
$ docker exec -it codelab_otsim_ctnr bash
Vous avez simulé avec succès votre premier réseau Thread à l'aide d'OpenThread. Impressionnant!
Dans ce Codelab, vous avez appris à:
- Démarrez et gérez le conteneur Docker OpenThread Simulation
- Simuler un réseau Thread
- Authentifier les nœuds de thread
- Gérer un réseau Thread avec OpenThread Daemon
Pour en savoir plus sur Thread et OpenThread, explorez ces références:
- Thread Primer sur openthread.io
- Spécification de fil
- Dépôt OpenThread GitHub
- Référence de l'interface de ligne de commande OpenThread
- Prise en charge supplémentaire d'OpenThread Docker
Ou essayez d'utiliser OpenThread Border Router dans un conteneur Docker !