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 guide dans la simulation d'un réseau Thread sur des appareils simulés.
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
- git
- Connaissance de base de Linux, routage réseau
Git
Git est requis pour compléter ce Codelab. Téléchargez et installez-le avant de continuer.
Une fois installé, suivez les instructions de votre système d'exploitation spécifique pour télécharger et créer OpenThread.
XCode pour Mac OS X
XCode est requis pour installer et créer OpenThread sur Mac OS X.
Une fois XCode installé, installez les outils de ligne de commande XCode:
$ xcode-select --install
Construire sur Linux / Mac OS X
Ces instructions d'installation ont été testées sur Ubuntu Server 14.04 LTS et Mac OS X Sierra 10.12.6.
Installez OpenThread. Les commandes d' 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 $ ./bootstrap
Utilisation de Windows
Si vous préférez Windows, nous vous recommandons d'essayer la version Docker de ce Codelab.
Une fois votre installation terminée, créez l'exemple d'application OpenThread. Pour ce Codelab, nous utilisons l'exemple de simulation.
$ cd ~/src/openthread $ make -f examples/Makefile-simulation
Construisez maintenant le démon OpenThread:
$ cd ~/src/openthread $ make -f src/posix/Makefile-posix DAEMON=1
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 simulé à partir d'un autre périphérique Thread simulé.
La figure ci-dessous décrit une topologie de réseau Thread de base. Pour cet exercice, nous simulerons les deux nœuds dans le cercle vert: un Thread Leader et un Thread Router avec une seule connexion entre eux.
Ping un nœud
1. Démarrez le nœud 1
Accédez au répertoire openthread et openthread le processus CLI pour un périphérique Thread simulé à l'aide du binaire ot-cli-ftd .
$ cd ~/src/openthread $ ./output/simulation/bin/ot-cli-ftd 1
Ce binaire implémente un périphérique OpenThread simulé au-dessus de POSIX. Le pilote radio IEEE 802.15.4 est implémenté par-dessus 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 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). Chaque instance d'un périphérique Thread simulé 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 appareil simulé. 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= lien-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 accédez au répertoire openthread et openthread le processus CLI. Ceci est votre deuxième appareil Thread simulé:
$ cd ~/src/openthread $ ./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 l'ensemble de données opérationnelles 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 est équivalent à 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 | 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 du nœud 1 de 0xa800 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 simulé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.
Testez le réseau
Maintenant que vous pouvez exécuter un ping entre deux périphériques Thread simulé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 quitter. 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
Également réinitialisé aux paramètres d'usine et quitter le nœud 1:
> factoryreset > > exit
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.
1. Créez un réseau
Si vous continuez à partir de l'exercice précédent, vous devriez déjà avoir deux fenêtres de terminal ouvertes. Sinon, assurez-vous que deux 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, lancez le processus CLI:
$ cd ~/src/openthread $ ./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 tout Joiner (en utilisant le caractère générique * ) avec les J01NME identification de Joiner J01NME à 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, créez un nouveau processus CLI. Il s'agit du nœud 2.
$ cd ~/src/openthread $ ./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 simulé:
> thread stop Done > factoryreset > > exit
Vous devrez peut-être appuyer plusieurs fois sur enter 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.
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
Si vous continuez à partir de l'exercice précédent, vous devriez déjà avoir deux fenêtres de terminal ouvertes. Ouvrez une troisième pour vous assurer que trois fenêtres de terminal sont disponibles pour cet exercice.
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 simulé:
$ cd ~/src/openthread $ ./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 de threads , 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, 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 qu'il est en cours d'exécution:
$ cd ~/src/openthread
$ ./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.
Dans une troisième fenêtre de terminal, démarrez ot-ctl :
$ ./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:
$ 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
Vous avez simulé avec succès votre premier réseau Thread à l'aide d'OpenThread. Impressionnant!
Dans ce Codelab, vous avez appris à:
- Configurer la chaîne d'outils de construction OpenThread
- Simuler un réseau Thread
- Authentifier les nœuds de thread
- Gérer un réseau Thread avec OpenThread Daemon
Si vous souhaitez en savoir plus, explorez ces références: