Cette page a été traduite par l'API Cloud Translation.

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®, un protocole de 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 mis sans frais à la disposition de la communauté des développeurs sous forme de projet open source.

La spécification Thread établit un protocole de communication sans fil fiable, sécurisé et économe en énergie pour les appareils à ressources limitées que l'on trouve couramment dans les maisons connectées et les bâtiments commerciaux. OpenThread inclut l'intégralité du champ d'application de la couche réseau dans Thread, par exemple 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 aux RTOS de Zephyr, ce qui permet une compatibilité totale 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, Software Development Kit).

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 OTBR et un appareil Thread dans l'atelier de programmation.

Points abordés

Configurer l'implémentation d'OpenThread à l'aide de l'environnement de développement Telink Zephyr.
Pour compiler les exemples de CLI OpenThread (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
Créer un réseau Thread sur l'OTBR
Ajouter des appareils au réseau Thread à l'aide du débogage hors bande
Pour valider la connectivité entre les nœuds du réseau Thread à l'aide de la CLI.

Prérequis

Matériel :

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

Logiciels :

Outil de gravure et de débogage de 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 la CLI OpenThread avant cet atelier de programmation.

Machine Linux

La machine Linux (Ubuntu v20.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 accomplir ces tâches, la machine Linux nécessite deux ports USB disponibles et 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 Terminal PuTTY est utilisé pour contrôler le FTD Joiner et le Raspberry Pi. Il offre un aperçu de son utilisation, mais d'autres logiciels de terminal peuvent également être utilisés.

Kit de développement Telink B91

Cet atelier de programmation nécessite deux ensembles de kits de développement B91. La photo ci-dessous présente le nombre minimal de composants requis dans un ensemble.

L'un de ces kits fonctionnera en tant que RCP (Radio Co-Processor), tandis que l'autre fonctionnera en tant que FTD (Full Thread Device). Si vous n'êtes pas encore en possession du kit, vous pouvez obtenir plus d'informations sur le site Web officiel de Telink. Voici quelques-uns des composants à utiliser:

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

Raspberry Pi version 3B ou supérieure avec image de l'OS Raspbian

Dans cet atelier de programmation, vous aurez besoin d'un Raspberry Pi 3B ou plus et d'une image d'OS Raspbian Bullseye Lite ou de Raspbian Bullseye sur ordinateur. 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 sont utilisés pour connecter le Raspberry Pi à la machine Linux, ce qui facilite la configuration de l'utilisateur du Raspberry Pi via l'hôte.

LinuxBDT

L'outil de brûlure 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 linuxBDT, basée sur X86, sur votre ordinateur Linux.

Autres

Git, pour configurer l'environnement de développement Telink Zephyr.
West, pour gérer le projet Zephyr et créer des 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, procédez comme suit.

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 dépendances principales, 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, basculez le miroir APT vers 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.

Obtenir le code source du projet Zephyr

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

Installer 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 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]

Où [-x.y.z] est un texte facultatif qui peut être n'importe quel texte, par exemple -0.16.1. Impossible de déplacer le répertoire 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. Tout d'abord, vérifiez que la configuration officielle du projet Zephyr est correcte à l'aide de l'exemple Hello World, puis continuez à configurer votre projet personnalisé.
```
$ cd ~/zephyrproject/zephyr
$ west build -p auto -b tlsr9518adk80d samples/hello_world
```
Utilisez la commande de compilation West pour créer l'exemple hello_world à partir du répertoire racine du dépôt Zephyr. Le micrologiciel zephyr.bin est disponible 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 localement 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, vous pouvez consulter Zephyr Doc – Guide de démarrage.

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 d'accueil ~. Vous pourrez ainsi 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 gravée à 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" (Débogueur Web Telink v3.6) s'affiche, cela signifie que le programmeur BDT s'est connecté avec succès à la machine Linux.

Compilation du micrologiciel

Cet atelier de programmation créera deux types de micrologiciels OpenThread:

ot-cli-ftd,
et ot-rcp.

Les méthodes de compilation sont les suivantes :

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

Flash du micrologiciel

Branchez une carte de développement B91 à la carte brûlante à 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 brûler le micrologiciel (en flashant le micrologiciel ot-cli-ftd, par 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 essentiellement la même que celle pour ot-cli-ftd. Cependant, il existe des différences au niveau des chemins d'accès et des noms du micrologiciel.

Après avoir clignoter, identifiez les deux cartes de développement B91 en les marquant comme suit : Étiqueter le tableau clignotant avec ot-cli-ftd comme "FTD Joiner" et le tableau clignote avec ot-rcp en tant que "RCP".

4. Configurer une console série pour l'appareil FTD Joiner

Comme illustré sur l'image, branchez directement FTD Joiner au 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 sur le port série, puis ouvrez-le.

La référence de la ligne de commande OpenThread est disponible ici: 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 constitué de deux parties principales :

Raspberry Pi contient l'ensemble des services et micrologiciels nécessaires pour agir en tant que routeur de bordure (BR).
RCP est responsable de la communication Thread.

Co-processeur 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 with Desktop sont correctement écrites sur la carte SD.
Vous pouvez vous connecter en SSH au Raspberry Pi ou travailler directement avec Raspbian Desktop. Cet atelier de programmation utilisera SSH.
Avant de procéder à l'installation d'OTBR Docker à l'étape suivante, veillez à mettre à jour le dépôt local et le gestionnaire de packages.
```
$ sudo apt-get update
$ sudp apt-get upgrade
```

Installer Docker

Si vous mettez simplement à jour le dépôt local et le gestionnaire de packages APT à l'étape précédente, redémarrez 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 cela prenne 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 kernel d'iptables.
```
$ sudo modprobe ip6table_filter
```

Configurer et exécuter Docker

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

Extrayez 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 de RCP (ttyACM0). Si vous souhaitez continuer à utiliser ce Docker OTBR, 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
```
Actualisez Docker OTBR:
```
$ docker restart otbr
```

À ce stade, un appareil FTD Joiner et un OTBR sont prêts, et 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 un RCP

Nous utilisons le shell ot-ctl sur l'OTBR pour établir un réseau Thread. Si vous avez quitté le shell à 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 aboutit au résultat attendu avant de passer à la suivante.

Index	Commande	Introduction	Réponse attendue
1	`dataset init new`	Créer un ensemble de données réseau aléatoire	OK
2	`dataset commit active`	Valider le nouvel ensemble de données dans l'ensemble de données opérationnel actif dans un espace de stockage non volatile.	OK
3	`ifconfig up`	Affichez l'interface IPv6.	OK
4	`thread start`	Activer le protocole Thread et l'associer à un réseau Thread	OK
			Patientez 10 secondes, le temps que l'interface de thread soit active.
5	`state`	Vérifiez l'état de l'appareil.Cette commande peut être appelée plusieurs fois jusqu'à ce qu'il devienne l'instance principale et qu'il passe à l'étape suivante.	leader Done
6	`dataset active`	Vérifiez l'ensemble de données opérationnel actif complet et enregistrez la clé réseau.

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 ot-cli-ftd appareils rejoindront ce réseau Thread.

Ajouter le joint FTD à Thread via la mise en service hors bande

La mise en service hors bande fait référence à la transmission d’identifiants réseau aux appareils en attente de connexion au réseau par des méthodes non sans fil (par exemple, la saisie manuelle dans la CLI OpenThread). Saisissez les commandes suivantes dans l'ordre dans la console série pour 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 puisse se connecter à un réseau Thread.	OK
2	`ot dataset commit active`	Valider le nouvel ensemble de données dans l'ensemble de données opérationnel actif dans un espace de stockage non volatile.	OK
3	`ot ifconfig up`	Affichez l'interface IPv6.	OK
4	`ot thread start`	Activer le protocole Thread et l'associer à un réseau Thread	OK
			Patientez 20 secondes, le temps que l'appareil se connecte et se configure.
5	`ot state`	Vérifiez l'état de l'appareil.	enfant/routeur OK

Topologie

Saisissez des commandes telles que ipaddr, child table ou router table dans le terminal SSH pour obtenir des réponses semblables aux 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 de 0xb000 et le RLOC16 du FTD Joiner initialement est 0xb001. Ensuite, le RLOC16 de FTD Joiner devient 0x8400 après avoir obtenu l'ID de routeur. On peut constater que FTD Joiner est passé d'un enfant à un routeur.

Le réseau Thread actuel contient deux nœuds et la topologie se présente comme illustré 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 d'un 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 de 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 FTD Joiner a reçu la réponse ping renvoyée par l'OTBR. La communication entre les deux appareils est établie.

Communication UDP

Les services applicatifs 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 transmettre des informations à des réseaux externes via le routeur de bordure. L'introduction détaillée de l'API UDP d'OpenThread se trouve dans la CLI OpenThread - Exemple UDP. Cet atelier de programmation utilisera certaines des API qu'il contient 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 de la même partition réseau Thread.

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

Saisissez les commandes suivantes dans le terminal SSH pour activer le protocole UDP OTBR 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 de la jointure FTD. Liez 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 renvoie les informations suivantes. L'OTBR reçoit le message hello de FTD Joiner, ce qui signifie que la communication UDP aboutit.

> 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 désormais:

Créer et utiliser l'environnement de développement Telink Zephyr
Créer les binaires ot-cli-ftd et ot-rcp, et les flasher sur les cartes de développement Telink B91
Comment configurer un Raspberry Pi 3B ou version ultérieure en tant que routeur de bordure OpenThread (OTBR) à l'aide de Docker
Créer un réseau Thread sur OTBR
Ajouter des appareils au réseau Thread via la mise en service hors bande
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 différentes 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

Documents de référence: