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 de mise en 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 disponible sans frais pour la communauté de 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 limités en ressources fréquemment utilisés dans les maisons connectées et les bâtiments commerciaux. OpenThread inclut le champ d'application complet 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 de maillage.

Telink a intégré l'implémentation d'OpenThread dans les conditions d'utilisation 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 comme 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 des nœuds. L'image ci-dessous présente la configuration matérielle, avec un routeur de bordure OTB 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), puis 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 une 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
• Valider la connectivité entre les nœuds du réseau Thread à l'aide de la CLI

Ce dont vous avez besoin

Matériel :

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

Logiciel :

• Outil Teburn burning and Debugging — LinuxBDT.
• Outil de terminal pour port série, tel que PuTTY.
• Autres outils, tels que Git et West.

2. Conditions préalables

Concepts de Thread et CLI OpenThread

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

Machine Linux

La machine Linux (Ubuntu 20.04 LTS ou version ultérieure) joue le rôle de machine de configuration pour l'environnement de développement Telink Zephyr et pour flasher toutes les cartes de développement Thread. Pour effectuer ces tâches, la machine Linux nécessite deux ports USB et une connexion Internet.

Connexion et terminaux du port série

Vous pouvez brancher directement l'appareil dans le port USB de l'ordinateur Linux. Vous aurez également besoin d'un outil de terminal de port série pour accéder aux appareils.

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

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 au minimum les composants obligatoires d'un ensemble.

L'un de ces kits sera utilisé 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 vous reporter au site Web officiel de Linklink. Voici certains composants à utiliser:

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

Dans cet atelier de programmation, vous devez disposer d'un Raspberry Pi 3B ou version ultérieure avec une image Raspbian Bullseye Lite OS ou Raspbian Bullseye avec ordinateur. Elle est connectée à Internet via Ethernet et sera configurée en tant qu'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 à l'ordinateur Linux et ainsi de configurer facilement le Raspberry Pi via l'hôte.

BDBD Linux

L'outil de brouillage et de débogage, qui s'applique à toutes les séries de puces Telink, vous permet d'effacer et de flasher un micrologiciel OpenThread sur les cartes de développement Telink B91. Installez la version Linux 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 créer des binaires OpenThread

3. Configurer le micrologiciel

Configurer l'environnement de développement Telink Zephyr

Sur la machine Linux, ouvrez un terminal de CLI et exécutez d'abord 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.

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 exige actuellement les 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.
2. Installer l'ouest.

   $ 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 (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 correspondre à n'importe quel texte, par exemple -0.16.1. Le répertoire ne peut pas être déplacé après l'installation du SDK. 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. Vous trouverez le micrologiciel nommé zephyr.bin sous build/zephyr directory.
7. Ajoutez le script d'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, puis 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 Doc.

Configurer Telink LinuxBDT

Téléchargez l'outil Telink LinuxBDT et extrayez-le dans un répertoire local sur votre ordinateur Linux, par exemple dans le répertoire d'accueil ~, pour pouvoir flasher un 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 le Burning Board à l'ordinateur 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 a réussi à se connecter à la machine Linux.

Compilation de micrologiciel

Cet atelier de programmation va créer deux types de micrologiciel OpenThread:

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

Voici les méthodes de compilation :

1. Coprocesseur de 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 au tableau de gravure à l'aide d'un câble USB, comme illustré ci-dessous.

Dans la ligne de commande, exécutez les commandes suivantes pour effectuer la gravure du micrologiciel (en utilisant le flash 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 essentiellement la même que pour ot-cli-ftd. Cependant, il existe des différences au niveau des chemins d'accès et des noms du micrologiciel.

Une fois le flash clignote, faites la distinction entre les deux cartes de développement B91. Ajoutez le libellé ot-cli-ftd "FTD Joiner" au tableau et le tableau ot-rcp à "RCP".

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

Comme illustré sur l'image, branchez directement le connecteur FTD au port USB de l'ordinateur Linux.

Après avoir connecté l'appareil Joint FTD à l'ordinateur Linux, ouvrez PuTTY. Créez ensuite un nouveau terminal, définissez les informations du port série, puis ouvrez le port série.

La documentation de référence sur 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 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 le micrologiciel nécessaires pour faire office de routeur de bordure.
• Le RCP est responsable de la communication Thread.

Coprocesseur de radio（RCP）

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

Raspberry Pi

1. Assurez-vous que l'image ROSBian Bullseye Lite Bulls ou Raspbian Bullseye avec ordinateur est correctement enregistrée sur la carte SD.
2. Vous avez la possibilité de vous connecter en SSH à Raspberry Pi ou de travailler directement avec le bureau Raspbian. Cet atelier de programmation utilisera SSH.
3. Avant d'installer Docker OTBR à 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 avez simplement mis à 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 ne doive pas être ajouté devant chaque commande.

   $ sudo usermod -aG docker $USER
   

   Vous devez redémarrer Raspberry Pi pour qu'elle soit prise en compte.
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 iptables du noyau.

   $ 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 validé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 pour la première fois le service Docker OTBR et référencez le port série du protocole RCP (ttyACM0). Si vous souhaitez continuer à utiliser ce conteneur 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
   

5. Ouvrez une nouvelle fenêtre de terminal SSH pour tester la connectivité entre 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 le service OTBR de Docker:

  $ docker stop otbr
  

  .
• Suppression du Docker OTBR:

  $ docker rm otbr
  

• Actualisez OTBR pour Docker:

  $ docker restart otbr
  

À ce stade, un appareil de jointure FTD 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é 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"

Saisissez ensuite les commandes dans l'ordre indiqué dans le tableau et assurez-vous que chaque étape atteint le résultat attendu avant de passer à la suivante.

La clé réseau générée aléatoirement par OTBR lors de la création du réseau sera utilisée lorsque ot-cli-ftd appareils rejoignent ce réseau Thread.

Ajouter le Joint FTD à Thread via la mise hors 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 via des méthodes non sans fil (par exemple, en les saisissant manuellement dans la CLI OpenThread). Saisissez les commandes suivantes dans la console série dans l'outil de jointure FTD.

Topology

Saisissez des commandes telles que ipaddr, child table et router table dans le terminal SSH pour obtenir des réponses comme les 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 Joint FTD est initialement de 0xb001. Ensuite, le RLOC16 du Joint FTD devient 0x8400 après avoir obtenu l'ID du routeur. Comme vous pouvez le constater, l'outil de jointure FTD a été mis à niveau d'un enfant à un routeur.

Le réseau Thread actuel contient deux nœuds, et la topologie est illustrée à 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. Utilisez d'abord 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 connecteur FTD a reçu la réponse ping renvoyée par OTBR. La communication entre les deux appareils aboutit.

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 des réseaux externes via le routeur de bordure. L'introduction détaillée de l'API UDP d'OpenThread se trouve dans la section OpenThread CLI - UDP Example. 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 maillage. 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 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 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 et activez l'UDP de FTD Joiner. 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 génère les informations suivantes. OTBR reçoit le message hello du joint FTD, 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 désormais:

• 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 un Raspberry Pi 3B+ ou une version ultérieure en tant que routeur de bordure OpenThread (OTBR) à l'aide de Docker
• Créer un réseau Thread sur un service de distribution par contournement.
• 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 les différentes ressources OpenThread, y compris:

• Plates-formes compatibles : découvrez toutes les plates-formes compatibles avec OpenThread.
• Build OpenThread : informations supplémentaires sur la création et la configuration d'OpenThread
• Thread Prime : couvre tous les concepts de Thread présentés dans cet atelier de programmation.

Documents de référence:

• Documentation de référence de la CLI OpenThread
• Documentation de référence de la CLI UDP OpenThread
• Documentation de référence de l'API OpenThread UDP