Google is committed to advancing racial equity for Black communities. See how.
Cette page a été traduite par l'API Cloud Translation.
Switch to English

Simulating a Thread network with OpenThread

26b7f4f6b3ea0700.png

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.

Télécharger Git

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.

Télécharger XCode

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.

Simulation OpenThread sur Docker

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.

6e3aa07675f902dc.png

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.

d6a67e8a0d0b5dcb.png

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:

  1. Instance CLI du périphérique Thread simulé (Nœud 1)
  2. processus ot-daemon
  3. 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: