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

1. Introduction

26b7f4f6b3ea0700.png

OpenThread est une implémentation Open Source du protocole réseau Thread®, 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 économe en énergie pour les appareils disposant de ressources limitées, couramment utilisés 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, comme IPv6, 6LoWPAN, IEEE 802.15.4 avec la sécurité MAC, l'établissement d'un lien maillé et le routage de maillage.

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, 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.

codelab_overview.png

Points abordés

  • Configurer l'implémentation d'OpenThread à l'aide de l'environnement de développement Telink Zephyr.
  • Créer 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.
  • 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 la CLI ;

Ce dont vous avez besoin

Matériel :

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

Logiciel :

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

2. Prérequis

Concepts de 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 avec 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 du port série et terminaux

Vous pouvez brancher directement le périphérique au 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 permet de contrôler FTD Joiner et Raspberry Pi. Il offre un aperçu de son utilisation, mais vous pouvez également utiliser d'autres logiciels de terminal.

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

overview.png

L'un de ces kits servira de coprocesseur radio (RCP), tandis que l'autre fera office de dispositif 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 Telelink. Voici quelques composants à utiliser:

Index

Nom

1

Carte de développement Telink B91

2

Planche de combustion Telink

3

Antenne 2,4 GHz

4

Câble USB (USB A vers mini USB)

Image de l'OS Raspbian pour Raspberry Pi 3B ou version ultérieure

Dans cet atelier de programmation, vous aurez besoin d'un appareil Raspberry Pi 3B ou version ultérieure avec une image de l'OS Raspbian Bullseye Lite ou une image Raspbian Bullseye avec ordinateur de bureau. Il est connecté à Internet via Ethernet et sera configuré comme hôte du 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 par l'utilisateur du Raspberry Pi via l'hôte.

LinuxBDT

L'outil de brûlure et de débogage 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 de Telink Zephyr
  • West, pour gérer le projet Zephyr et créer des binaires OpenThread.

3. Configurer le micrologiciel

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

$ sudo apt update
$ sudo apt upgrade

Ensuite, procédez comme suit.

  1. 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, faites basculer le miroir APT sur un miroir stable et à jour ou mettez à jour manuellement ces dépendances.
  2. 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.
  3. Obtenez le code source du projet Zephyr.
    $ west init ~/zephyrproject
$ cd ~/zephyrproject
$ west update
$ west blobs fetch hal_telink
$ west zephyr-export
  4. Installez des dépendances Python supplémentaires pour Zephyr.
    $ pip3 install --user -r ~/zephyrproject/zephyr/scripts/requirements.txt
  5. Configurez la chaîne d'outils Zephyr. Téléchargez la chaîne d'outils Zephyr (d'environ 1 à 2 Go) dans un répertoire local pour pouvoir flasher la plupart des tableaux.
    $ 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] correspond à un texte facultatif pouvant correspondre à 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
  6. 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 créer l'exemple hello_world à partir du répertoire racine du dépôt Zephyr. Le micrologiciel nommé zephyr.bin se trouve sous build/zephyr directory.
  7. Ajoutez le script de l'environnement Zephyr à ~/.bashrc. Exécutez les commandes suivantes.
    $ echo "source ~/zephyrproject/zephyr/zephyr-env.sh" >> ~/.bashrc
$ source ~/.bashrc
  8. 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, consultez le document Zephyr – Guide de démarrage.

Téléchargez l'outil Telink LinuxBDT et extrayez-le dans un répertoire local de votre ordinateur Linux, par exemple le répertoire d'accueil ~, afin de 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 gravure à 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 programmeur BDT s'est bien connecté à la machine Linux.

Compilation du micrologiciel

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

  • ot-cli-ftd,
  • et ot-rcp.

Voici les méthodes de compilation :

  1. 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
  2. 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

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

connection_overview.png

Dans la ligne de commande, exécutez les commandes suivantes pour graver le micrologiciel (en prenant l'exemple du flash du micrologiciel ot-cli-ftd).

$ 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 pour ot-cli-ftd. Toutefois, il existe des différences au niveau des chemins d'accès et des noms des micrologiciels.

Après le flash, faites une distinction entre les deux cartes de développement B91 en les marquant en conséquence. Le tableau indiquait "FTD Joiner" comme ot-cli-ftd, et ot-rcp comme "RCP".

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

Comme illustré sur l'image, branchez directement la FTD Joiner au port USB de la machine Linux.

usb_connection.png

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

uart_console.png

La documentation de référence de la ligne de commande OpenThread se trouve ici: Documentation de référence sur 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 éléments principaux :

  • Raspberry Pi contient tous les services et micrologiciels requis pour faire office de routeur de bordure (BR).
  • RCP est responsable de la communication Thread.

Coprocesseur radio (RCP)

Pour flasher le micrologiciel ot-rcp, suivez la même procédure que pour flasher 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.

OTBR_overview.png

Raspberry Pi

  1. Assurez-vous que l'image de l'OS Raspbian Bullseye Lite ou Raspbian Bullseye with Desktop est correctement écrite sur la carte SD.
  2. Vous avez la possibilité de vous connecter en SSH au Raspberry Pi ou de travailler directement avec le Bureau Raspbian. Cet atelier de programmation utilisera SSH.
  3. Avant d'installer 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 venez de mettre à 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.

  1. Installez Docker:
    $ curl -sSL https://get.docker.com | sh
  2. 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 la modification prenne effet.
  3. Si Docker n'a pas démarré, démarrez-le:
    $ sudo dockerd
  4. 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 de noyau d'iptables.
    $ sudo modprobe ip6table_filter

Configurer et exécuter Docker

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

  1. Extrayez la dernière image:
    $ docker pull openthread/otbr:latest
  2. Vérifiez la liste des images dans le conteneur Docker:
    $ docker images
REPOSITORY        TAG       IMAGE ID       CREATED      SIZE
openthread/otbr   latest    db081f4de15f   6 days ago   766MB
  3. 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
...
  4. 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, exécutez 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
  5. 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 OTBR Docker:
    $ 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 RCP

Nous utilisons l'interface système ot-ctl sur l'OTBR pour établir un réseau Thread. Si vous avez quitté l'interface système 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 spécifié dans le tableau et assurez-vous que chaque étape atteint le 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

Terminée

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.

Terminée

3

ifconfig up

Affichez l'interface IPv6.

Terminée

4

thread start

Activer le fonctionnement du protocole Thread et effectuer une association à un réseau Thread.

Terminée

Attendez 10 secondes que l'interface du 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 l'instance principale et passe à l'étape suivante.

leader
OK

6

dataset active

Vérifiez l'ensemble de données opérationnel actif complet et enregistrez la clé réseau.

Code temporel actif : 1
Canal : 13
Masque de chaîne : 0x07fff800
ID PAN ext : b07476e168eda4fc
Préfixe local de maillage : fd8c:60bc:a98:c7ba::/64
Clé réseau : c312485187484d9Thread2543




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 FTD Joiner à 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 qui attendent de rejoindre le 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 indiqué dans la console série dans 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.

Terminée

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.

Terminée

3

ot ifconfig up

Affichez l'interface IPv6.

Terminée

4

ot thread start

Activer le fonctionnement du protocole Thread et effectuer une association à un réseau Thread.

Terminée

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

Topology

Saisissez des commandes telles que ipaddr, child table et 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 0xb000, et le RLOC16 de la FTD Joiner est initialement 0xb001. Ensuite, le RLOC16 de FTD Joiner devient 0x8400 après l'obtention de l'ID de routeur. On peut voir que FTD Joiner est passé d'un enfant à un routeur.

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

topology.png

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 le jointure FTD a reçu la réponse ping renvoyée par OTBR. La communication entre les deux appareils est réussie.

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 pour 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 du réseau maillé de l'OTBR. Cette adresse est également l'une des adresses IPv6 de l'appareil Thread. Elle permet d'accéder aux appareils Thread d'une 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 OTBR UDP et lier le port 1022 de l'appareil.

> udp open
Done
> udp bind :: 1022
Done

Saisissez les commandes suivantes dans la console série pour activer l'UDP de FTD Joiner. Liez le port 1022 de l'appareil, puis envoyez un message hello de cinq 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 génère les informations suivantes. 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 connaissez maintenant:

  • Créer et utiliser l'environnement de développement de Telink Zephyr
  • Compiler les binaires ot-cli-ftd et ot-rcp, et les flasher sur les cartes de développement Telink B91
  • Comment configurer un routeur 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 une 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 les différentes ressources OpenThread, dont:

Documents de référence: