1. Introduction
OpenThread est une implémentation Open Source du protocole réseau Thread® conçue 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 énergétique basé sur IPv6, pour les applications de construction à domicile et commercial.
Espressif a transféré la pile OpenThread en fonction de FreeRTOS et LwIP, ce qui permet aux développeurs de créer rapidement des réseaux Thread. Vous pouvez obtenir le code source associé sur GitHub. Parallèlement, Espressif a également implémenté un routeur de bordure Thread basé sur les 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 de la CLI OpenThread sur les cartes ESP.
- Création et flash du routeur de bordure sur la carte de routeur de bordure Thread ESP.
- Gérer manuellement les nœuds Thread avec le moniteur ESP et la CLI OpenThread.
- Créer un réseau Thread sur le routeur de bordure Thread
- Sécurisation de la mise en service des appareils sur un réseau Thread.
- Ping de l'adresse IPv6 entre les nœuds Thread...
- La transmission de messages entre les nœuds Thread avec UDP
Ce dont vous avez besoin
Matériel :
- Deux cartes ESP avec des modules IEEE 802.15.4.
- 1 carte de routeur de bordure Thread ESP.
Logiciel :
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 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 essentielles permettant de créer un routeur de bordure Thread, et intègre des fonctionnalités avancées au niveau du produit pour une productisation 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 les cartes ESP avec des modules IEEE 802.15.4, consultez l'exemple ESP-IDF ot_cli pour plus de détails:
$ cd <your-idf-path>/examples/openthread/ot_cli $ idf.py set-target <your-board-type>
Activez la fonctionnalité de jointure via menuconfig:
$ idf.py menuconfig
Configuration du composant > OpenThread > Activer 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 Thread ESP, vous devez d'abord créer le fichier binaire RCP. Il n'est pas nécessaire de flasher explicitement ce fichier binaire RCP sur l'appareil sur la carte de routeur de bordure Thread ESP. Il sera inclus dans le fichier binaire du routeur de bordure et flashé sur la puce ESP32-H2 lors du premier démarrage (ou lorsque le micrologiciel RCP a été modifié). Pour en savoir plus, consultez la documentation sur l'environnement d'exécution de l'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 mise en service via menuconfig:
$ idf.py menuconfig
Configuration du composant > OpenThread > Activer Commissioner > 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 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 en tant qu'ensemble de données 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é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
Vérifiez l'état de l'appareil après quelques instants. Il devrait 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 BR formé. Dans cette session, nous allons ajouter Board1 au réseau.
Obtenez la clé de réseau à partir de BR:
## BR Commissioner ## ---------------------- > networkkey 731ab6a60a64a0a0b14b259b86b2be01 Done >
Définissez cette clé réseau sur une carte ESP (Board1 Joiner) avec des modules IEEE 802.15.4:
## Board1 Joiner ## ---------------------- > dataset networkkey 731ab6a60a64a0a0b14b259b86b2be01 Done
Validez cet ensemble de données en tant qu'ensemble de données actif:
> dataset commit active Done
Affichez 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
Vérifiez l'état de l'appareil après quelques instants. Il devrait s'agir de l'Enfant.
> state child Done
Définissez le rôle sur "Router".
> 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. Rejoignez le réseau Thread via une mise en service sécurisée
Au cours de cette session, nous allons ajouter le Board2 au réseau via une commission de sécurité:
Obtenez le PSKc et le panid auprès du commissaire du Brésil:
## BR Commissioner ## ---------------------- > pskc 54e7f18d2575014da94db09df29c5df0 Done > panid 0x1444 Done
Configurez les informations réseau sur Board2:
## Board2 Joiner ## ---------------------- > dataset pskc 54e7f18d2575014da94db09df29c5df0 Done > dataset panid 0x1444 Done
Validez cet ensemble de données en tant qu'ensemble de données actif:
## Board2 Joiner ## ---------------------- > dataset commit active Done
Affichez l'interface IPv6:
## Board2 Joiner ## ---------------------- > ifconfig up Done I (29146) OT_STATE: netif up
Obtenez le fichier eui64 à partir de Board2:
## Board2 Joiner ## ---------------------- > eui64 4831b7fffec02be1 Done
Dans le Commissaire BR, démarrez le commissaire et indiquez le eui64 de l'appareil qui peut participer, ainsi que l'identifiant de jointure, par exemple J01NME. L'identifiant Joiner est une chaîne spécifique à l'appareil de tous les caractères alphanumériques en majuscules (0-9 et A-Y, sauf I, O, Q et Z pour la lisibilité), d'une longueur de 6 à 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 jointure avec l'identifiant de jointure 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 que l'authentification a réussi:
## 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 "Router".
> 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 ci-dessous:
7. Ping de l'adresse IPv6 entre les 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 pinguer le MLE-ID Board2 depuis le Commissaire BR, vous pouvez exécuter la commande suivante sur le Commissaire BR:
## 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 les nœuds Thread avec UDP
Dans cette session, vous allez apprendre à envoyer un message entre deux appareils Thread. Par exemple, ouvrez udp et liez-le sur le port 20617, puis é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 à partir de Board1 vers l'adresse MLE-ID BR et le port 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 connaissez maintenant:
- Créer et flasher des binaires de la CLI OpenThread sur les cartes ESP.
- Création d'un routeur de bordure clignotant sur la carte de routeur de bordure Thread ESP.
- Gérer manuellement les nœuds Thread avec le moniteur ESP et la CLI OpenThread.
- Créer un réseau Thread sur le routeur de bordure Thread
- Sécurisation de la mise en service des appareils sur un réseau Thread.
- Ping de l'adresse IPv6 entre les nœuds Thread...
- La transmission de messages entre les nœuds Thread avec UDP
Complément d'informations
Consultez openthread.io et GitHub pour trouver de nombreuses ressources OpenThread, y compris:
- Plates-formes compatibles : découvrez toutes les plates-formes compatibles avec OpenThread.
- Build OpenThread (Construire OpenThread) : plus d'informations sur la compilation et la configuration d'OpenThread.
- Thread Primer : couvre tous les concepts Thread abordés dans cet atelier de programmation
Références :