Créer un réseau Thread avec la carte de développement B91 et OpenThread

1. Introduction

OpenThread est une implémentation Open Source du protocole réseau Thread®, qui est un protocole réseau maillé sans fil robuste et sécurisé conçu pour les appareils IoT (Internet des objets). OpenThread a été développé par l'équipe Nest de Google et est disponible sans frais pour la communauté des développeurs en tant que projet Open Source.

La spécification Thread établit un protocole de communication sans fil fiable, sécurisé et écoénergétique pour les appareils aux ressources limitées que l'on trouve couramment dans les maisons connectées et les bâtiments commerciaux. OpenThread inclut l'ensemble du champ d'application de la couche réseau dans Thread, comme IPv6, 6LoWPAN, IEEE 802.15.4 avec sécurité MAC, établissement de liens maillés et routage maillé.

Telink a intégré l'implémentation OpenThread dans Zephyr RTOS, ce qui permet une compatibilité parfaite avec le matériel Telink. Le code source de cette intégration est facilement accessible sur GitHub. Il est également fourni sous forme de kit de développement logiciel (SDK).

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 échanger des messages entre les nœuds. L'image ci-dessous illustre la configuration matérielle, avec un routeur de bordure OT (OTBR) et un appareil Thread dans l'atelier de programmation.

Points abordés

Pour configurer l'implémentation OpenThread à l'aide de l'environnement de développement Telink Zephyr.
Pour créer les exemples OpenThread CLI (ot-cli-ftd et ot-rcp) et les flasher sur les cartes de développement Telink B91.
Configurer un routeur de bordure OpenThread (OTBR) à l'aide de Docker sur un Raspberry Pi 3B+ ou version ultérieure.
Pour créer un réseau Thread sur l'OTBR.
Ajouter des appareils au réseau Thread à l'aide du débogage hors bande.
Valider la connectivité entre les nœuds du réseau Thread à l'aide de l'interface de ligne de commande

Prérequis

Matériel :

Deux cartes de développement B91.
Un Raspberry Pi 3B+ ou version ultérieure avec une image Raspbian OS.
Une machine Linux avec au moins deux ports USB.
Un commutateur (ou routeur) connecté à Internet et plusieurs câbles Ethernet.

Logiciels :

Outil de programmation et de débogage Telink : LinuxBDT.
Un outil de terminal de port série, tel que PuTTY.
D'autres outils tels que Git et West.

2. Prérequis

Concepts Thread et CLI OpenThread

Il peut être utile de suivre l'atelier de programmation sur la simulation OpenThread pour vous familiariser avec les concepts fondamentaux de Thread et l'interface de ligne de commande OpenThread avant cet atelier.

Machine Linux

La machine Linux (Ubuntu 20.04 LTS ou version ultérieure) sert de machine de compilation pour configurer l'environnement de développement Telink Zephyr et flasher toutes les cartes de développement Thread. Pour effectuer ces tâches, la machine Linux doit disposer de deux ports USB disponibles et d'une connexion Internet.

Connexion et terminaux du port série

Vous pouvez brancher directement l'appareil sur le port USB de la machine Linux. De plus, vous aurez besoin d'un outil de terminal de port série pour accéder aux appareils.

Dans cet atelier de programmation, l'outil de terminal PuTTY est utilisé pour contrôler le FTD Joiner et le Raspberry Pi. Il offre un aperçu de son utilisation, mais vous pouvez également utiliser d'autres logiciels de terminal.

Kit de développement Telink B91

Cet atelier de programmation nécessite deux ensembles de kits de développement B91. La photo ci-dessous montre les composants minimaux requis dans un ensemble.

L'un de ces kits sera utilisé comme RCP (processeur radio), tandis que l'autre fonctionnera comme FTD (Full Thread Device). Si vous n'avez pas encore reçu le kit, vous pouvez obtenir plus d'informations sur le site Web officiel de Telink. Voici quelques composants à utiliser :

Index	Nom
1	Carte de développement Telink B91
2	Telink Burning Board
3	Antenne 2,4 GHz
4	Câble USB (USB-A vers mini-USB)

Raspberry Pi 3B+ ou version ultérieure avec l'image Raspbian OS

Dans cet atelier de programmation, vous aurez besoin d'un Raspberry Pi 3B+ ou version ultérieure avec l'image OS Raspbian Bullseye Lite ou Raspbian Bullseye avec Desktop. Il est connecté à Internet via Ethernet et sera configuré comme hôte pour le routeur de bordure OpenThread (OTBR).

Connexion réseau

Un commutateur (ou routeur) connecté à Internet et plusieurs câbles Ethernet. Ils permettent de connecter le Raspberry Pi à la machine Linux, ce qui facilite la configuration du Raspberry Pi par l'utilisateur via l'hôte.

LinuxBDT

L'outil de programmation et de débogage (BDT) de Telink, qui s'applique à toutes les séries de puces Telink, vous permet d'effacer et de flasher le micrologiciel OpenThread sur les cartes de développement Telink B91. Installez la version Linux basée sur X86 linuxBDT sur votre machine Linux.

Autres

Git, pour configurer l'environnement de développement Telink Zephyr.
West pour gérer le projet Zephyr et compiler les binaires OpenThread.

3. Configurer le micrologiciel

Configurer l'environnement de développement Telink Zephyr

Sur la machine Linux, ouvrez un terminal CLI et commencez par exécuter les commandes suivantes pour vous assurer que votre APT est à jour.

$ sudo apt update
$ sudo apt upgrade

Une fois cette opération effectuée, passez aux étapes suivantes.

Installez les dépendances.
```
$ wget https://apt.kitware.com/kitware-archive.sh
$ sudo bash kitware-archive.sh
$ sudo apt install --no-install-recommends git cmake ninja-build \
gperf ccache dfu-util device-tree-compiler python3-dev python3-pip \
python3-setuptools python3-tk python3-wheel xz-utils file make gcc \
gcc-multilib g++-multilib libsdl2-dev
```
Zephyr nécessite actuellement des versions minimales des principales dépendances, telles que CMake (3.20.0), Python3 (3.6) et Devicetree Compiler (1.4.6).
```
$ cmake --version
$ python3 --version
$ dtc --version
```
Vérifiez les versions installées sur votre système avant de passer aux étapes suivantes. Si les versions ne sont pas correctes, remplacez le miroir APT par un miroir stable et à jour, ou mettez à jour manuellement ces dépendances.

Installez west.

$ pip3 install --user -U west
$ echo 'export PATH=~/.local/bin:"$PATH"' >> ~/.bashrc
$ source ~/.bashrc

Assurez-vous que ~/.local/bin se trouve dans votre variable d'environnement $PATH.

Obtenez le code source du projet Zephyr.

$ west init ~/zephyrproject
$ cd ~/zephyrproject
$ west update
$ west blobs fetch hal_telink
$ west zephyr-export

Installez des dépendances Python supplémentaires pour Zephyr.

$ pip3 install --user -r ~/zephyrproject/zephyr/scripts/requirements.txt

Configurez la chaîne d'outils Zephyr. Téléchargez la chaîne d'outils Zephyr (environ 1 à 2 Go) dans un répertoire local pour pouvoir flasher la plupart des cartes.

$ wget https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.16.1/zephyr-sdk-0.16.1_linux-x86_64.tar.xz
$ wget -O - https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.16.1/sha256.sum | shasum --check --ignore-missing

Téléchargez le SDK Zephyr et placez-le dans le chemin d'accès recommandé, comme indiqué ci-dessous.

$HOME/zephyr-sdk[-x.y.z]
$HOME/.local/zephyr-sdk[-x.y.z]
$HOME/.local/opt/zephyr-sdk[-x.y.z]
$HOME/bin/zephyr-sdk[-x.y.z]
/opt/zephyr-sdk[-x.y.z]
/usr/zephyr-sdk[-x.y.z]
/usr/local/zephyr-sdk[-x.y.z]

[-x.y.z] est un texte facultatif qui peut être n'importe quel texte, tel que -0.16.1. Le répertoire ne peut pas être déplacé une fois le SDK installé. Installez ensuite la chaîne d'outils Zephyr.

$ tar xvf zephyr-sdk-0.16.1_linux-x86_64.tar.xz
$ cd zephyr-sdk-0.16.1
$ ./setup.sh -t riscv64-zephyr-elf -h -c

Créez l'exemple Hello World. Commencez par vérifier que la configuration officielle du projet Zephyr est correcte à l'aide de l'exemple Hello World, puis configurez votre projet personnalisé.
```
$ cd ~/zephyrproject/zephyr
$ west build -p auto -b tlsr9518adk80d samples/hello_world
```
Utilisez la commande de compilation West pour compiler l'exemple hello_world à partir du répertoire racine du dépôt Zephyr. Vous trouverez le micrologiciel nommé zephyr.bin sous build/zephyr directory.
Ajoutez le script d'environnement Zephyr à ~/.bashrc. Exécutez les commandes suivantes.
```
$ echo "source ~/zephyrproject/zephyr/zephyr-env.sh" >> ~/.bashrc
$ source ~/.bashrc
```

Ajoutez le dépôt distant Telink Zephyr. Téléchargez le dépôt Telink en local en tant que branche de développement et mettez-le à jour.

$ cd ~/zephyrproject/zephyr
$ git remote add telink-semi https://github.com/telink-semi/zephyr
$ git fetch telink develop
$ git checkout develop
$ west update
$ west blobs fetch hal_telink

Pour en savoir plus, consultez le Guide de démarrage de Zephyr.

Configurer Telink LinuxBDT

Téléchargez l'outil Telink LinuxBDT et extrayez-le dans un répertoire local de votre machine Linux, tel que le répertoire de base ~, pour pouvoir flasher le micrologiciel sur la carte de développement B91.

$ cd ~
$ wget http://wiki.telink-semi.cn/tools_and_sdk/Tools/BDT/LinuxBDT.tar.bz2
$ tar -vxf LinuxBDT.tar.bz2

Connectez la carte de programmation à la machine Linux via l'interface USB, puis saisissez les commandes suivantes.

$ cd LinuxBDT
$ sudo ./bdt lsusb -v
Bus 002 Device 001: ID 1d6b:0003 xHCI Host Controller
Bus 001 Device 003: ID 0bda:565a Integrated_Webcam_HD
Bus 001 Device 023: ID 413c:301a Dell MS116 USB Optical Mouse
Bus 001 Device 037: ID 248a:826a Telink Web Debugger v3.6
Bus 001 Device 001: ID 1d6b:0002 xHCI Host Controller

Si le message "Telink Web Debugger v3.6" s'affiche, cela signifie que le programmateur BDT s'est bien connecté à la machine Linux.

Compilation du micrologiciel

Cet atelier de programmation vous permettra de créer deux types de micrologiciels OpenThread :

ot-cli-ftd,
et ot-rcp.

Voici les méthodes de compilation :

Coprocesseur radio (ot-rcp)

$ cd ~/zephyrproject
$ rm -rf build_ot_coprocessor
$ west build -b tlsr9518adk80d -d build_ot_coprocessor zephyr/samples/net/openthread/coprocessor -- -DDTC_OVERLAY_FILE="usb.overlay" -DOVERLAY_CONFIG=overlay-rcp-usb-telink.conf

Appareil Thread complet avec ligne de commande interactive (ot-cli-ftd)

$ cd ~/zephyrproject
$ rm -rf build_ot_cli_ftd
$ west build -b tlsr9518adk80d -d build_ot_cli_ftd zephyr/samples/net/openthread/cli -- -DOVERLAY_CONFIG=overlay-telink-fixed-mac.conf -DCONFIG_OPENTHREAD_FTD=y

Flasher le micrologiciel

Connectez une carte de développement B91 à la carte de programmation à l'aide d'un câble USB, comme illustré dans la figure ci-dessous.

Dans la ligne de commande, exécutez les commandes suivantes pour graver le micrologiciel (en utilisant le flashage du micrologiciel ot-cli-ftd comme exemple).

$ cd ~/zephyrproject/build_ot_cli_ftd/zephyr
$ cp zephyr.bin ~/LinuxBDT/bin/ot-cli-ftd.bin
$ cd ~/LinuxBDT
$ sudo ./bdt 9518 ac
 Activate OK!
$ sudo ./bdt 9518 wf 0 -i bin/ot-cli-ftd.bin
 EraseSectorsize...
 Total Time: 2181 ms
 Flash writing...
 [100%][-] [##################################################]
 File Download to Flash at address 0x000000: 491700 bytes
 Total Time: 30087 ms

La méthode flash pour ot-rcp est fondamentalement la même que celle pour ot-cli-ftd. Toutefois, les chemins et les noms des micrologiciels sont différents.

Après le flashage, distinguez les deux cartes de développement B91 en les marquant en conséquence. Attribuez le libellé "FTD Joiner" à la carte flashée avec ot-cli-ftd et le libellé "RCP" à la carte flashée avec ot-rcp.

4. Configurer une console série pour le périphérique FTD Joiner

Comme indiqué sur l'image, branchez directement le connecteur FTD sur le port USB de la machine Linux.

Après avoir connecté l'appareil FTD Joiner à la machine Linux, ouvrez PuTTY. Créez ensuite un terminal, définissez les informations du port série et ouvrez le port série.

La documentation de référence de la ligne de commande OpenThread est disponible ici : Documentation de référence de la CLI OpenThread. Veillez à ajouter le préfixe ot à toutes les commandes.

Exemples :

> ot state
disabled
Done
> ot channel
11
Done
>

5. Configurer le Raspberry Pi en tant que routeur de bordure OpenThread

Un routeur de bordure OpenThread est un appareil composé de deux parties principales :

Raspberry Pi contient tous les services et micrologiciels nécessaires pour servir de routeur de bordure.
Le RCP est responsable de la communication Thread.

Coprocesseur radio (RCP)

Pour flasher le micrologiciel ot-rcp, suivez la même procédure que pour le micrologiciel ot-cli-ftd. Connectez la carte de développement B91 à un port USB du Raspberry Pi, comme illustré dans la figure ci-dessous.

Raspberry Pi

Assurez-vous que l'image de l'OS Raspbian Bullseye Lite ou Raspbian Bullseye avec Desktop est correctement écrite sur la carte SD.
Vous pouvez vous connecter à la Raspberry Pi via SSH ou travailler directement avec le bureau Raspbian. Cet atelier de programmation utilisera SSH.
Avant de passer à l'installation d'OTBR Docker à l'étape suivante, veillez d'abord à mettre à jour le dépôt local et le gestionnaire de packages.
```
$ sudo apt-get update
$ sudp apt-get upgrade
```

Installer Docker

Si vous venez de mettre à jour le dépôt local et le gestionnaire de packages APT à l'étape précédente, redémarrez le Raspberry Pi, puis ouvrez une fenêtre de terminal SSH.

Installez Docker :

$ curl -sSL https://get.docker.com | sh

Placez le compte actuel dans un groupe Docker pour accorder l'autorisation afin que sudo n'ait pas besoin d'être ajouté devant chaque commande.
```
$ sudo usermod -aG docker $USER
```
Vous devez redémarrer le Raspberry Pi pour que les modifications prennent effet.
Si Docker n'a pas démarré, démarrez-le :
```
$ sudo dockerd
```
Les scripts de pare-feu OTBR génèrent des règles dans le conteneur Docker. Avant cela, exécutez modprobe pour charger le module du noyau d'iptables.
```
$ sudo modprobe ip6table_filter
```

Configurer et exécuter Docker

Cet atelier de programmation extrait directement l'image Docker OTBR depuis OpenThread Docker Hub. Cette image a été testée et validée par l'équipe OpenThread.

Récupérez la dernière image :
```
$ docker pull openthread/otbr:latest
```

Consultez la liste des images dans le conteneur Docker :

$ docker images
REPOSITORY        TAG       IMAGE ID       CREATED      SIZE
openthread/otbr   latest    db081f4de15f   6 days ago   766MB

Déterminez le nom du port série de l'appareil RCP en vérifiant /dev. ttyACM0 indique que le RCP est correctement connecté.
```
$ ls /dev/tty*
...
/dev/ttyACM0
... 
```

Exécutez OTBR Docker pour la première fois et référencez le port série du RCP (ttyACM0). Si vous souhaitez continuer à utiliser cet OTBR Docker, utilisez la commande docker start otbr.

$ docker run --name "otbr" --sysctl "net.ipv6.conf.all.disable_ipv6=0 net.ipv4.conf.all.forwarding=1 net.ipv6.conf.all.forwarding=1" -p 8080:80 --dns=127.0.0.1 -it --volume /dev/ttyACM0:/dev/ttyACM0 --privileged openthread/otbr --radio-url spinel+hdlc+uart:///dev/ttyACM0

Ouvrez une nouvelle fenêtre de terminal SSH pour tester la connectivité entre le Raspberry Pi et le RCP.
```
$ docker exec -ti otbr sh -c "sudo ot-ctl"
> state 
disabled
Done
```

Commandes Docker facultatives :

Obtenez des informations sur le conteneur Docker en cours d'exécution :
```
$ docker ps -aq
```
Arrêtez OTBR Docker :
```
$ docker stop otbr
```
Supprimez OTBR Docker :
```
$ docker rm otbr
```
Rechargez OTBR Docker :
```
$ docker restart otbr
```

À ce stade, un appareil FTD Joiner et un OTBR sont prêts. Vous pouvez passer à l'étape suivante pour créer le réseau Thread.

6. Créer un réseau Thread

Créer un réseau Thread sur RCP

Nous utilisons le shell ot-ctl sur l'OTBR pour établir un réseau Thread. Si vous avez quitté le shell dans la section précédente, saisissez la commande suivante pour le redémarrer dans le terminal SSH :

$ docker exec -ti otbr sh -c "sudo ot-ctl"

Ensuite, saisissez les commandes dans l'ordre indiqué dans le tableau et assurez-vous que chaque étape produit le résultat attendu avant de passer à la suivante.

Index	Commande	Introduction	Réponse attendue
1	`dataset init new`	Créez un ensemble de données réseau aléatoire.	OK
2	`dataset commit active`	Validez le nouvel ensemble de données dans l'ensemble de données opérationnelles actif dans le stockage non volatile.	OK
3	`ifconfig up`	Activez l'interface IPv6.	OK
4	`thread start`	Activez le protocole Thread et connectez-vous à un réseau Thread.	OK
			Patientez 10 secondes pour que l'interface Thread soit opérationnelle.
5	`state`	Vérifiez l'état de l'appareil.Cette commande peut être appelée plusieurs fois jusqu'à ce qu'il devienne le leader et passe à l'étape suivante.	leader OK
6	`dataset active`	Vérifiez l'ensemble de données opérationnelles actives et enregistrez la clé réseau.	Active Timestamp: 1 Channel: 13 Channel Mask: 0x07fff800 Ext PAN ID: b07476e168eda4fc Mesh Local Prefix: fd8c:60bc:a98:c7ba::/64 Network Key: c312485187484ceb5992d2343baaf93d Network Name: OpenThread-599c PAN ID: 0x599c PSKc: 04f79ad752e8401a1933486c95299f60 Security Policy: 672 onrc 0 Done

La clé réseau générée de manière aléatoire par OTBR lors de la création du réseau sera utilisée lorsque les appareils ot-cli-ftd rejoindront ce réseau Thread.

Ajouter le FTD Joiner à Thread par mise en service hors bande

La mise en service hors bande fait référence à la transmission des identifiants réseau aux appareils en attente de rejoindre le réseau par des méthodes non sans fil (par exemple, en les saisissant manuellement dans l'interface de ligne de commande OpenThread). Saisissez les commandes suivantes dans l'ordre dans la console série du FTD Joiner.

Index	Commande	Introduction	Réponses attendues
1	`ot dataset networkkey c312485187484ceb5992d2343baaf93d`	Seule la clé réseau est nécessaire pour qu'un appareil se connecte à un réseau Thread.	OK
2	`ot dataset commit active`	Validez le nouvel ensemble de données dans l'ensemble de données opérationnelles actif dans le stockage non volatile.	OK
3	`ot ifconfig up`	Activez l'interface IPv6.	OK
4	`ot thread start`	Activez le protocole Thread et connectez-vous à un réseau Thread.	OK
			Patientez 20 secondes pendant que l'appareil rejoint le réseau et se configure.
5	`ot state`	Vérifiez l'état de l'appareil.	child/router OK

Topologie

Saisissez des commandes telles que ipaddr, child table ou router table dans le terminal SSH pour obtenir des réponses comme celles des extraits de code suivants.

> ipaddr rloc
fd8c:60bc:a98:c7ba:0:ff:fe00:b000
Done
> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|D|N|Ver|CSL|QMsgCnt|Suprvsn| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+---+---+-------+-------+------------------+
|   1 | 0xb001 |        240 |         23 |     3 |   51 |1|1|1|  3| 0 |     0 |   129 | 82bc12fbe783468e |

Done
> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     | Link |
+----+--------+----------+-----------+-------+--------+-----+------------------+------+
| 44 | 0xb000 |       63 |         0 |     0 |      0 |   0 | 7ae354109d611f7e |    0 |

Done
...
> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|D|N|Ver|CSL|QMsgCnt|Suprvsn| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+---+---+-------+-------+------------------+

Done
> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     | Link |
+----+--------+----------+-----------+-------+--------+-----+------------------+------+
| 33 | 0x8400 |       63 |         0 |     3 |      3 |  13 | e61487c1cda940a6 |    1 |
| 44 | 0xb000 |       63 |         0 |     0 |      0 |   0 | 7ae354109d611f7e |    0 |

Done

Le RLOC16 de l'OTBR est 0xb000 et le RLOC16 du FTD Joiner est initialement 0xb001. L'état du FTD Joiner RLOC16 devient 0x8400 après l'obtention de l'ID du routeur. On peut voir que le FTD Joiner est passé d'un enfant à un routeur.

Le réseau Thread actuel contient deux nœuds et la topologie est celle illustrée dans la figure ci-dessous.

7. Communication entre les appareils Thread

Communication ICMPv6

Nous utilisons la commande ping pour vérifier si les appareils Thread du même réseau peuvent communiquer entre eux. Commencez par utiliser la commande ipaddr pour obtenir le RLOC de l'appareil.

> ipaddr
fd8c:60bc:a98:c7ba:0:ff:fe00:fc11
fdbd:7274:649c:1:1d19:9613:f705:a5af
fd8c:60bc:a98:c7ba:0:ff:fe00:fc10
fd8c:60bc:a98:c7ba:0:ff:fe00:fc38
fd8c:60bc:a98:c7ba:0:ff:fe00:fc00
fd8c:60bc:a98:c7ba:0:ff:fe00:b000       # Routing Locator (RLOC)
fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6
fe80:0:0:0:78e3:5410:9d61:1f7e
Done

Saisissez la commande suivante dans la console série du FTD Joiner pour exécuter l'opération ping.

> ot ping fd8c:60bc:a98:c7ba:0:ff:fe00:b000
16 bytes from fd8c:60bc:a98:c7ba:0:ff:fe00:b000: icmp_seq=1 hlim=64 time=19ms
1 packets transmitted, 1 packets received. Packet loss = 0.0%. Round-trip min/avg/max = 19/19.0/19 ms.
Done

La réponse de sortie du port série indique que le côté OTBR a reçu la requête ping et que le FTD Joiner a reçu la réponse ping renvoyée par OTBR. La communication entre les deux appareils est établie.

Communication UDP

Les services d'application fournis par OpenThread incluent également UDP. Vous pouvez utiliser l'API UDP pour transmettre des informations entre les nœuds du réseau Thread ou à des réseaux externes via le routeur de bordure. Pour une présentation détaillée de l'API UDP d'OpenThread, consultez Exemple d'interface de ligne de commande OpenThread – UDP. Cet atelier de programmation utilisera certaines de ces API pour transmettre des informations entre OTBR et FTD Joiner.

Commencez par obtenir l'EID local du réseau maillé de l'OTBR. Cette adresse est également l'une des adresses IPv6 de l'appareil Thread. Elle peut être utilisée pour accéder aux appareils Thread dans la même partition du réseau Thread.

> ipaddr mleid
fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6
Done

Saisissez les commandes suivantes dans le terminal SSH pour activer OTBR UDP et associer le port 1022 de l'appareil.

> udp open
Done
> udp bind :: 1022
Done

Saisissez les commandes suivantes dans la console série et activez l'UDP du FTD Joiner. Associez le port 1022 de l'appareil, puis envoyez un message hello de 5 octets à OTBR.

> ot udp open 
Done
> ot udp bind :: 1022
Done
> ot udp send fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6 1022 hello
Done

Le terminal SSH affiche les informations suivantes. L'OTBR reçoit le message hello de l'appareil FTD Joiner, ce qui signifie que la communication UDP a réussi.

> 5 bytes from fd8c:60bc:a98:c7ba:9386:63cf:19d7:5a61 1022 hello

8. Félicitations

Vous avez créé un réseau Thread simple et vérifié la communication au sein de ce réseau.

Vous savez maintenant :

Comment créer et utiliser l'environnement de développement Telink Zephyr.
Comment créer les binaires ot-cli-ftd et ot-rcp, et les flasher sur les cartes de développement Telink B91.
Configurer une Raspberry Pi 3B+ ou version ultérieure en tant que routeur de bordure OpenThread (OTBR) à l'aide de Docker.
Découvrez comment créer un réseau Thread sur OTBR.
Ajouter des appareils au réseau Thread par le biais de la mise en service hors bande.
Comment vérifier la connectivité entre les nœuds du réseau Thread

Documentation complémentaire

Consultez openthread.io et GitHub pour en savoir plus sur les différentes 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.

Documents de référence :