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 entre appareils basé sur IPv6 pour les applications résidentielles 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. En même temps, 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
- Créer et flasher des binaires OpenThread CLI sur des cartes ESP.
- Créer et flasher un routeur de bordure sur une carte de routeur de bordure ESP Thread.
- Gérer manuellement les nœuds Thread avec ESP Monitor et l'interface de ligne de commande OpenThread.
- Former un réseau Thread sur le routeur de bordure Thread.
- Sécuriser la mise en service des appareils sur un réseau Thread.
- Envoyer une commande ping à une adresse IPv6 entre des nœuds Thread.
- Transmettre des messages entre des nœuds Thread avec UDP.
Ce dont vous avez besoin
Matériel :
- 2 cartes ESP avec des modules IEEE 802.15.4.
- 1 carte de routeur de bordure ESP Thread.
Logiciels :
2. Premiers pas
- Installation d'ESP-IDF.
Veuillez suivre le guide de programmation ESP-IDF pour installer l'environnement de développement logiciel.
- Cloner le SDK du routeur de bordure Thread ESP.
ESP-THREAD-BR est le SDK officiel du routeur de bordure Thread ESP. Il est compatible avec toutes les fonctionnalités réseau fondamentales pour créer un routeur de bordure Thread et intègre des fonctionnalités de niveau produit enrichies pour une commercialisation rapide.
$ cd <your-local-workspace> $ git clone --recursive https://github.com/espressif/esp-thread-br.git
3. Compiler et flasher
Pour compiler et flasher le fichier binaire ot-cli-ftd sur des 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
Component config > OpenThread > Enable Joiner, puis compilez et flashez.
$ idf.py -p <your-local-port> build flash monitor
Pour compiler et flasher le fichier binaire ot-br sur la carte de routeur de bordure ESP Thread, 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 de routeur de bordure ESP Thread. Il sera inclus dans le fichier binaire du routeur de bordure et flashé sur la puce ESP32-H2 au premier démarrage (ou lorsque le micrologiciel RCP est 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 commissionnement via menuconfig :
$ idf.py menuconfig
Component config > OpenThread > Enable Commissioner, puis compilez et flashez.
$ idf.py -p <your-local-port> build flash monitor
4. Former 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 ESP Thread (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
Affichez l'interface IPv6 :
> ifconfig up I (59329) OPENTHREAD: Platform UDP bound to port 49153 Done I (59329) OT_STATE: netif up
Démarrez 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 un moment, vérifiez l'état de l'appareil. Il doit s'agir du leader.
> state leader Done >
5. Rejoindre le réseau Thread via networkkey
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. Au cours de cette session, nous allons ajouter la carte 1 au réseau.
Obtenez la clé réseau à partir du routeur de bordure :
## 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
Affichez l'interface IPv6 :
> ifconfig up Done I (20308) OT_STATE: netif up
Démarrez 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 un moment, vérifiez l'état de l'appareil. Il doit s'agir de l'enfant.
> state child Done
Définissez le rôle sur Mesh Extender (appelé router dans l'interface de ligne de commande et les journaux).
> 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
Au cours de cette session, nous allons ajouter la carte 2 au réseau via la mise en service de sécurité :
Obtenez le PSKc et le panid du routeur de bordure :
## BR Commissioner ## ---------------------- > pskc 54e7f18d2575014da94db09df29c5df0 Done > panid 0x1444 Done
Configurez les informations réseau sur la carte 2 :
## Board2 Joiner ## ---------------------- > dataset pskc 54e7f18d2575014da94db09df29c5df0 Done > dataset panid 0x1444 Done
Validez cet ensemble de données comme actif :
## Board2 Joiner ## ---------------------- > dataset commit active Done
Affichez l'interface IPv6 :
## Board2 Joiner ## ---------------------- > ifconfig up Done I (29146) OT_STATE: netif up
Obtenez l'eui64 à partir de la carte 2 :
## Board2 Joiner ## ---------------------- > eui64 4831b7fffec02be1 Done
Sur le BR Commissioner, démarrez le commissionnement et spécifiez l'eui64 du type d'appareil qui peut rejoindre le réseau, ainsi que les identifiants de jonction, par exemple J01NME. Les identifiants de jonction sont une chaîne spécifique à l'appareil composée de caractères alphanumériques en majuscules (0-9 et A-Y, à l'exclusion de I, O, Q et Z pour une meilleure lisibilité), 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 à la carte 2 Joiner. Démarrez le rôle de jonction avec les identifiants de jonction que vous venez de configurer sur le routeur de bordure :
## Board2 Joiner ## ---------------------- > ifconfig up Done > joiner start J01NME Done
Au bout d'une minute environ, vous recevez une confirmation de l'authentification réussie :
## Board2 Joiner ## ---------------------- > Join success
Vous pouvez ensuite démarrer et rejoindre le réseau Thread formé par le routeur de bordure.
Démarrez 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 Mesh Extender (appelé router dans l'interface de ligne de commande et les journaux).
> 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 maintenant un réseau Thread avec la topologie illustrée ci-dessous :
7. Envoyer une commande 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 imprimer 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 une commande ping à l'ID MLE de la carte 2 à partir du routeur de bordure, vous pouvez exécuter cette commande sur le routeur de bordure :
## 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
Au cours de 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 le routeur de bordure :
## BR Commissioner ## ---------------------- > udp open Done > udp bind :: 20617 I (1298739) OPENTHREAD: Platform UDP bound to port 20617 Done
Envoyez ensuite un message de la carte 1 à l'adresse et au port 20617 de l'ID MLE du routeur de bordure :
## 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 le routeur de bordure :
## 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 :
- Créer et flasher des binaires OpenThread CLI sur des cartes ESP.
- Créer et flasher un routeur de bordure sur une carte de routeur de bordure ESP Thread.
- Gérer manuellement les nœuds Thread avec ESP Monitor et l'interface de ligne de commande OpenThread.
- Former un réseau Thread sur le routeur de bordure Thread.
- Sécuriser la mise en service des appareils sur un réseau Thread.
- Envoyer une commande ping à une adresse IPv6 entre des nœuds Thread.
- Transmettre des messages entre des nœuds Thread avec UDP.
Documentation complémentaire
Consultez openthread.io et GitHub pour découvrir diverses ressources OpenThread, y compris :
- Plates-formes compatibles : découvrez toutes les plates-formes compatibles avec OpenThread.
- Créer OpenThread : plus d'informations sur la création et la configuration d'OpenThread.
- Thread Primer : couvre tous les concepts Thread présentés dans cet atelier de programmation.
Références :