1. Introduction
OpenThread, publié par l'équipe Google Nest, est une implémentation Open Source du protocole réseau Thread® conçu pour 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 fiable, sécurisé et à faible consommation d'énergie basé sur IPv6 pour les applications domestiques et commerciales.
Espressif a porté la pile OpenThread basée sur FreeRTOS et LwIP, ce qui permet aux développeurs de créer rapidement des réseaux Thread. Le code source associé est disponible sur GitHub. Parallèlement, Espressif a également implémenté un routeur de bordure Thread basé sur RTOS.
Dans cet atelier de programmation, vous allez programmer OpenThread sur du matériel réel, créer et gérer un réseau Thread, et transmettre des messages entre les nœuds.
Points abordés
- Compiler et flasher les binaires de la CLI OpenThread sur les cartes ESP.
- Compilation et flashage du routeur de bordure sur la carte ESP Thread Border Router.
- Gérer manuellement les nœuds Thread avec ESP Monitor et l'interface de ligne de commande OpenThread.
- Créer un réseau Thread sur le routeur de bordure Thread.
- Sécuriser la mise en service des appareils sur un réseau Thread.
- Pinguer une adresse IPv6 entre les nœuds Thread.
- Transmettre des messages entre les nœuds Thread avec UDP.
Prérequis
Matériel :
- Deux cartes ESP avec des modules IEEE 802.15.4.
- 1 carte de routeur de bordure Thread ESP.
Logiciels :
2. Premiers pas
- Installation d'ESP-IDF.
Veuillez suivre le guide de programmation ESP-IDF pour installer l'environnement de développement logiciel.
- Clonez le SDK ESP Thread Border Router.
ESP-THREAD-BR est le SDK officiel ESP Thread Border Router. Il est compatible avec toutes les fonctionnalités réseau de base permettant de créer un routeur de bordure Thread et intègre de nombreuses fonctionnalités au niveau du produit pour une commercialisation rapide.
$ cd <your-local-workspace> $ git clone --recursive https://github.com/espressif/esp-thread-br.git
3. Compiler et flasher
Pour créer et flasher le fichier binaire ot-cli-ftd sur les cartes ESP avec des modules IEEE 802.15.4, vous pouvez consulter l'exemple ESP-IDF ot_cli pour en savoir plus :
$ cd <your-idf-path>/examples/openthread/ot_cli $ idf.py set-target <your-board-type>
Activez la fonctionnalité de jonction via menuconfig :
$ idf.py menuconfig
Configuration des composants > OpenThread > Activer le participant, puis compiler et flasher.
$ idf.py -p <your-local-port> build flash monitor
Pour compiler et flasher le fichier binaire ot-br sur la carte ESP Thread Border Router, vous devez d'abord compiler le fichier binaire RCP. Il n'est pas nécessaire de flasher explicitement ce fichier binaire RCP sur l'appareil de la carte ESP Thread Border Router. Il sera inclus dans le fichier binaire du routeur de bordure et transféré sur la puce ESP32-H2 au premier démarrage (ou si le micrologiciel RCP a été modifié). Pour en savoir plus, consultez la documentation ESP Thread BR :
$ cd <your-idf-path>/examples/openthread/ot_rcp $ idf.py set-target esp32h2 $ idf.py build $ cd <your-esp-thread-br-path>/examples/basic_thread_border_router $ idf.py set-target esp32s3
Activez la fonctionnalité de commissaire via menuconfig :
$ idf.py menuconfig
Configuration des composants > OpenThread > Activer le commissaire, puis compiler et flasher.
$ idf.py -p <your-local-port> build flash monitor
4. Créer un réseau Thread sur le routeur de bordure Thread
Vous pouvez maintenant former un réseau Thread à l'aide de la ligne de commande OpenThread sur la carte de routeur de bordure Thread ESP (BR Commissioner) :
## BR Commissioner ## ---------------------- > dataset init new Done > dataset Active Timestamp: 1 Channel: 21 Channel Mask: 0x07fff800 Ext PAN ID: 151975d11bea97b5 Mesh Local Prefix: fd6a:b54b:d6a3:b05a::/64 Network Key: 731ab6a60a64a0a0b14b259b86b2be01 Network Name: OpenThread-1444 PAN ID: 0x1444 PSKc: 54e7f18d2575014da94db09df29c5df0 Security Policy: 672 onrc 0 Done
Validez cet ensemble de données comme actif :
> dataset commit active Done
Activez l'interface IPv6 :
> ifconfig up I (59329) OPENTHREAD: Platform UDP bound to port 49153 Done I (59329) OT_STATE: netif up
Démarrer l'opération du protocole Thread :
> thread start I(61709) OPENTHREAD:[N] Mle-----------: Role disabled -> detached Done > I(62469) OPENTHREAD:[N] Mle-----------: Attach attempt 1, AnyPartition reattaching with Active Dataset I(69079) OPENTHREAD:[N] RouterTable---: Allocate router id 11 I(69079) OPENTHREAD:[N] Mle-----------: RLOC16 fffe -> 2c00 I(69089) OPENTHREAD:[N] Mle-----------: Role detached -> leader I(69089) OPENTHREAD:[N] Mle-----------: Partition ID 0x28b518c6 I (69099) OPENTHREAD: Platform UDP bound to port 49154
Après quelques instants, vérifiez l'état de l'appareil. Il doit s'agir du responsable.
> state leader Done >
5. Rejoindre le réseau Thread via une clé réseau
Dans cet atelier de programmation, deux cartes ESP avec des modules IEEE 802.15.4 sont préparées pour rejoindre le réseau formé par le routeur de bordure. Dans cette session, nous allons ajouter la carte 1 au réseau.
Obtenez la clé réseau auprès de BR :
## BR Commissioner ## ---------------------- > networkkey 731ab6a60a64a0a0b14b259b86b2be01 Done >
Définissez cette clé réseau sur une carte ESP (carte 1 Joiner) avec des modules IEEE 802.15.4 :
## Board1 Joiner ## ---------------------- > dataset networkkey 731ab6a60a64a0a0b14b259b86b2be01 Done
Validez cet ensemble de données comme actif :
> dataset commit active Done
Activez l'interface IPv6 :
> ifconfig up Done I (20308) OT_STATE: netif up
Démarrer l'opération du protocole Thread :
> thread start I(23058) OPENTHREAD:[N] Mle-----------: Role disabled -> detached Done > I(23408) OPENTHREAD:[N] Mle-----------: Attach attempt 1, AnyPartition reattaching with Active Dataset I(30028) OPENTHREAD:[N] Mle-----------: Attach attempt 1 unsuccessful, will try again in 0.288 seconds I(30328) OPENTHREAD:[N] Mle-----------: Attach attempt 2, AnyPartition I(33498) OPENTHREAD:[N] Mle-----------: Delay processing Announce - channel 21, panid 0x1444 I(33758) OPENTHREAD:[N] Mle-----------: Processing Announce - channel 21, panid 0x1444 I(33758) OPENTHREAD:[N] Mle-----------: Role detached -> disabled I(33758) OPENTHREAD:[N] Mle-----------: Role disabled -> detached I(34178) OPENTHREAD:[N] Mle-----------: Attach attempt 1, AnyPartition I(35068) OPENTHREAD:[N] Mle-----------: RLOC16 fffe -> 2c01 I(35068) OPENTHREAD:[N] Mle-----------: Role detached -> child
Après quelques instants, vérifiez l'état de l'appareil. Il doit s'agir de l'enfant.
> state child Done
Définissez le rôle sur "Routeur".
> state router Done I(51028) OPENTHREAD:[N] Mle-----------: RLOC16 2c01 -> 2800 I(51028) OPENTHREAD:[N] Mle-----------: Role child -> router I(51028) OPENTHREAD:[N] Mle-----------: Partition ID 0x28b518c6 >
6. Rejoindre le réseau Thread via une mise en service sécurisée
Dans cette session, nous allons ajouter Board2 au réseau via la mise en service de sécurité :
Obtenez le PSKc et le panid du commissaire BR :
## BR Commissioner ## ---------------------- > pskc 54e7f18d2575014da94db09df29c5df0 Done > panid 0x1444 Done
Configurez les informations réseau pour Board2 :
## Board2 Joiner ## ---------------------- > dataset pskc 54e7f18d2575014da94db09df29c5df0 Done > dataset panid 0x1444 Done
Validez cet ensemble de données comme actif :
## Board2 Joiner ## ---------------------- > dataset commit active Done
Activez l'interface IPv6 :
## Board2 Joiner ## ---------------------- > ifconfig up Done I (29146) OT_STATE: netif up
Obtenez l'eui64 de la carte 2 :
## Board2 Joiner ## ---------------------- > eui64 4831b7fffec02be1 Done
Sur le commissaire BR, démarrez le commissaire et spécifiez le eui64 de l'appareil pouvant rejoindre le réseau, ainsi que les identifiants de l'intégrateur, par exemple J01NME. L'identifiant de l'appareil est une chaîne de caractères alphanumériques (0-9 et A-Y, à l'exclusion de I, O, Q et Z pour une meilleure lisibilité) en majuscules, d'une longueur comprise entre 6 et 32 caractères.
## BR Commissioner ## ---------------------- > commissioner start Commissioner: petitioning Done Commissioner: active > commissioner joiner add 4831b7fffec02be1 J01NME Done
Passez à Board2 Joiner. Démarrez le rôle de participant avec les identifiants de participant que vous venez de configurer sur le commissaire BR :
## Board2 Joiner ## ---------------------- > ifconfig up Done > joiner start J01NME Done
Au bout d'une minute environ, vous recevez une confirmation de l'authentification :
## Board2 Joiner ## ---------------------- > Join success
Vous pourrez ensuite démarrer et rejoindre le réseau Thread formé par le commissaire BR.
Démarrer l'opération du protocole Thread :
> thread start I(35727) OPENTHREAD:[N] Mle-----------: Role disabled -> detached Done > I(36197) OPENTHREAD:[N] Mle-----------: Attach attempt 1, AnyPartition reattaching with Active Dataset I(37007) OPENTHREAD:[N] Mle-----------: RLOC16 fffe -> 2801 I(37007) OPENTHREAD:[N] Mle-----------: Role detached -> child
Définissez le rôle sur "Routeur".
> state router Done I(46057) OPENTHREAD:[N] Mle-----------: RLOC16 2801 -> 4400 I(46057) OPENTHREAD:[N] Mle-----------: Role child -> router I(46057) OPENTHREAD:[N] Mle-----------: Partition ID 0x28b518c6 >
Vous obtenez alors un réseau Thread avec la topologie illustrée ci-dessous :
7. Envoyer une requête ping à une adresse IPv6 entre des nœuds Thread
Vous pouvez utiliser la commande ping pour communiquer entre deux cartes. Utilisez la commande ipaddr pour afficher l'adresse IPv6 de chaque carte :
## BR Commissioner ## ---------------------- > ipaddr fd6a:b54b:d6a3:b05a:0:ff:fe00:fc00 # Leader Anycast Locator (ALOC) fd6a:b54b:d6a3:b05a:0:ff:fe00:2c00 # Routing Locator (RLOC) fd6a:b54b:d6a3:b05a:a8df:eb43:63d8:bda0 # Mesh-Local EID (ML-EID) fe80:0:0:0:687c:7248:cc14:9c4d # Link-Local Address (LLA) Done >
## Board1 Joiner ## ---------------------- > ipaddr fd6a:b54b:d6a3:b05a:0:ff:fe00:2800 # Routing Locator (RLOC) fd6a:b54b:d6a3:b05a:e461:db08:c833:1248 # Mesh-Local EID (ML-EID) fe80:0:0:0:18ac:df04:4671:6a45 # Link-Local Address (LLA) Done
## Board2 Joiner ## ---------------------- > ipaddr fd6a:b54b:d6a3:b05a:0:ff:fe00:4400 # Routing Locator (RLOC) fd6a:b54b:d6a3:b05a:d7dc:8e90:9bc9:ecbc # Mesh-Local EID (ML-EID) fe80:0:0:0:a8cc:1483:f696:91a2 # Link-Local Address (LLA) Done
Par exemple, pour envoyer un ping à l'ID MLE de Board2 depuis BR Commissioner, vous pouvez exécuter cette commande sur BR Commissioner :
## BR Commissioner ## ---------------------- > ping fd6a:b54b:d6a3:b05a:d7dc:8e90:9bc9:ecbc 16 bytes from fd6a:b54b:d6a3:b05a:d7dc:8e90:9bc9:ecbc: icmp_seq=1 hlim=255 time=123ms 1 packets transmitted, 1 packets received. Packet loss = 0.0%. Round-trip min/avg/max = 123/123.0/123 ms. Done
8. Transmettre des messages entre des nœuds Thread avec UDP
Dans cette session, vous allez apprendre à envoyer un message entre deux appareils Thread. Par exemple, ouvrez udp, liez-le au port 20617 et écoutez toutes les adresses sur BR :
## BR Commissioner ## ---------------------- > udp open Done > udp bind :: 20617 I (1298739) OPENTHREAD: Platform UDP bound to port 20617 Done
Envoyez ensuite un message depuis Board1 à l'adresse et au port BR MLE-ID 20617 :
## Board1 Joiner ## ---------------------- > udp open Done > udp send fd6a:b54b:d6a3:b05a:a8df:eb43:63d8:bda0 20617 ESP
Vous pouvez voir le message reçu sur BR :
## BR Commissioner ## ---------------------- 3 bytes from fd6a:b54b:d6a3:b05a:e461:db08:c833:1248 49154 ESP
9. Félicitations !
Vous avez créé un réseau Thread physique à l'aide de cartes ESP.
Vous savez maintenant :
- Compiler et flasher les binaires de la CLI OpenThread sur les cartes ESP.
- Créer et flasher un routeur de bordure sur la carte ESP Thread Border Router.
- Gérer manuellement les nœuds Thread avec ESP Monitor et l'interface de ligne de commande OpenThread.
- Créer un réseau Thread sur le routeur de bordure Thread.
- Sécuriser la mise en service des appareils sur un réseau Thread.
- Pinguer une adresse IPv6 entre les nœuds Thread.
- Transmettre des messages entre les nœuds Thread avec UDP.
Documentation complémentaire
Consultez openthread.io et GitHub pour accéder à diverses ressources OpenThread, y compris :
- Plates-formes compatibles : découvrez toutes les plates-formes compatibles avec OpenThread.
- Compiler OpenThread : plus d'informations sur la compilation et la configuration d'OpenThread
- Principes de base de Thread : couvre tous les concepts Thread présentés dans cet atelier de programmation.
Références :