1. Introduction
OpenThread, lancé par l'équipe Google Nest, 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 d'appareil à appareil fiable, sécurisé et à faible consommation d'énergie basé sur le protocole IPv6 pour les applications de bâtiment domestiques et professionnelles.
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 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
- Construire et flasher des binaires CLI OpenThread sur les cartes ESP.
- Création du routeur de bordure et clignotement sur la carte de routeur de bordure ESP Thread.
- Gérer manuellement les nœuds de thread avec ESP Monitor et la CLI OpenThread.
- Création d'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 d'une adresse IPv6 entre les nœuds Thread
- Transmettre des messages entre les nœuds Thread avec UDP
Prérequis
Matériel :
- 2 cartes ESP avec 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.
- Clonez le SDK du routeur de bordure de thread ESP.
ESP-THREAD-BR est le SDK officiel du routeur de bordure ESP Thread. 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 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, 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 jointure via menuconfig:
$ idf.py menuconfig
Configuration du composant > OpenThread > Activez Joiner, puis créez et flashez votre application.
$ 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 que ce fichier binaire RCP soit explicitement flashé 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 au premier démarrage (ou lorsque 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é Commissioner via menuconfig:
$ idf.py menuconfig
Configuration du composant > OpenThread > Activez Commissioner, puis créez et flashez.
$ 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
Patientez quelques instants, puis vérifiez l'état de l'appareil. Il doit s'agir du leader.
> 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 BR. Au cours de cette session, nous allons ajouter Board1 au réseau.
Obtenez la clé réseau à partir de BR:
## BR Commissioner ## ---------------------- > networkkey 731ab6a60a64a0a0b14b259b86b2be01 Done >
Définissez cette clé réseau sur une carte ESP (Board1 Joiner) avec les 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
Patientez quelques instants, puis 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
Au cours de cette session, nous allons ajouter Board2 au réseau via la mise en service de la sécurité:
Obtenez la clé PSKc et le panid du BR Commissioner:
## 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 l'eui64 de Board2:
## Board2 Joiner ## ---------------------- > eui64 4831b7fffec02be1 Done
Dans BR Commissioner, démarrez-le et spécifiez l'eui64 de l'appareil qui peut participer, ainsi que l'identifiant Joiner Credential (par exemple, J01NME). L'identifiant Joiner est une chaîne spécifique à un appareil composée de tous les caractères alphanumériques en majuscules (0-9 et A-Y, à l'exception des I, O, Q et Z pour la lisibilité), et doit comporter entre 6 et 32 caractères.
## BR Commissioner ## ---------------------- > commissioner start Commissioner: petitioning Done Commissioner: active > commissioner joiner add 4831b7fffec02be1 J01NME Done
Passez à Board2 Joiner. Commencez le rôle de participant avec l'identifiant Joiner Credential que vous venez de configurer pour le commissaire BR:
## Board2 Joiner ## ---------------------- > ifconfig up Done > joiner start J01NME Done
Au bout d'une minute environ, vous recevez la confirmation de réussite de l'authentification:
## Board2 Joiner ## ---------------------- > Join success
Vous pourrez ensuite démarrer et rejoindre le réseau Thread formé par le commissaire du Brésil.
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 maintenant un réseau Thread avec la topologie ci-dessous:
7. Ping d'une 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 Board2 MLE-ID 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 les nœuds Thread avec UDP
Dans cette session, vous allez apprendre à envoyer un message entre deux appareils Thread. Par exemple, ouvrez udp, liez-le sur le 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 BR MLE-ID et au 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 savez désormais:
- Construire et flasher des binaires CLI OpenThread sur les cartes ESP.
- Création d'un routeur de bordure clignotante sur la carte de routeur de bordure ESP Thread.
- Gérer manuellement les nœuds de thread avec ESP Monitor et la CLI OpenThread.
- Création d'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 d'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 obtenir une variété de ressources OpenThread, notamment:
- Plates-formes compatibles : découvrez toutes les plates-formes prenant en charge OpenThread.
- Build OpenThread : plus de détails sur la création et la configuration d'OpenThread
- Introduction Thread : couvre tous les concepts Thread abordés dans cet atelier de programmation
Références :