Crea una rete Thread con la scheda di sviluppo B91 e OpenThread

1. Introduzione

OpenThread è un'implementazione open source del protocollo di rete Thread®, un protocollo di rete mesh wireless solido e sicuro progettato per i dispositivi IoT (Internet of Things). OpenThread è stato sviluppato dal team Nest di Google ed è disponibile senza costi per la community di sviluppatori come progetto open source.

La specifica Thread stabilisce un protocollo di comunicazione wireless affidabile, sicuro ed efficiente dal punto di vista energetico per i dispositivi con risorse limitate che si trovano comunemente nelle smart home e negli edifici commerciali. OpenThread include l'intero ambito del livello di rete all'interno di Thread, come IPv6, 6LoWPAN, IEEE 802.15.4 con sicurezza MAC, creazione di link mesh e routing mesh.

Telink ha integrato l'implementazione di OpenThread negli RTOS di Zephyr, consentendo una compatibilità perfetta con l'hardware Telink. Il codice sorgente per questa integrazione è facilmente accessibile su GitHub e viene fornito anche come software development kit (SDK).

In questo codelab, programmi OpenThread su hardware reale, creerai e gestirai una rete Thread e scambierai messaggi tra nodi. L'immagine seguente mostra la configurazione hardware, con un router di confine OT (OTBR) e un dispositivo Thread nel codelab.

Obiettivi didattici

• Per configurare l'implementazione di OpenThread utilizzando l'ambiente di sviluppo Telink Zephyr.
• Per creare gli esempi dell'interfaccia a riga di comando OpenThread (ot-cli-ftd e ot-rcp) e eseguirne il flashing sulle schede di sviluppo Telink B91.
• Configurare un router di confine OpenThread (OTBR) utilizzando Docker su un Raspberry Pi 3B+ o versioni successive.
• Per creare una rete Thread sull'OTBR.
• Aggiungere dispositivi alla rete Thread utilizzando il debug fuori banda.
• Convalidare la connettività tra nodi nella rete Thread utilizzando l'interfaccia a riga di comando.

Che cosa ti serve

Hardware:

• Due schede di sviluppo B91.
• Un Raspberry Pi 3B o versioni successive con immagine Raspbian OS.
• Un computer Linux con almeno due porte USB.
• Uno switch (o router) connesso a internet e diversi cavi Ethernet.

Software:

• Strumento di masterizzazione e debug Telink: LinuxBDT.
• Strumento per il terminale della porta seriale, ad esempio PuTTY.
• Altri strumenti come Git e West.

2. Prerequisiti

Concetti di Thread e interfaccia a riga di comando OpenThread

Potrebbe essere utile svolgere il codelab sulla simulazione di OpenThread per acquisire familiarità con i concetti fondamentali di Thread e con l'interfaccia a riga di comando OpenThread prima di questo codelab.

Computer Linux

La macchina Linux (Ubuntu v20.04 LTS o successiva) funge da macchina di compilazione per configurare l'ambiente di sviluppo Telink Zephyr e eseguire il flashing di tutte le schede di sviluppo Thread. Per svolgere queste attività, il computer Linux richiede due porte USB e una connessione a internet.

Connessione alla porta seriale e terminali

Puoi collegare direttamente il dispositivo alla porta USB del computer Linux. Inoltre, per accedere ai dispositivi sarà necessario uno strumento per il terminale della porta seriale.

In questo codelab, viene utilizzato lo strumento terminale PuTTY per controllare FTD Joiner e Raspberry Pi. Offre una panoramica del suo utilizzo, ma è possibile impiegare anche altro software terminale.

Kit di sviluppo Telink B91

Questo codelab richiede due set di kit di sviluppo B91. La foto seguente mostra il numero minimo di componenti richiesti in un set.

Uno di questi kit verrà utilizzato come co-processore radiofonico (RCP), mentre l'altro come dispositivo FTD (Full Thread Device). Se non sei ancora in possesso del kit, puoi acquisire maggiori dettagli dal sito web ufficiale di Telink. Ecco alcuni componenti da utilizzare:

Immagine Raspberry Pi 3B o versioni successive con Raspbian OS

In questo codelab, è necessario Raspbian Pi 3B o versioni successive con un'immagine del sistema operativo Raspbian Bullseye Lite o un Raspbian Bullseye con Desktop. È connesso a internet tramite Ethernet e verrà configurato come host per il router di confine OpenThread (OTBR).

Connessione di rete

Uno switch (o un router) connesso a internet e diversi cavi Ethernet. Vengono utilizzati per connettere Raspberry Pi al computer Linux, facilitando la configurazione utente di Raspberry Pi tramite l'host.

LinuxBDT

Telink Burning and Debugging Tool (BDT), valido per tutte le serie di chip Telink, consente di resettare e eseguire il flashing del firmware OpenThread sulle schede di sviluppo Telink B91. Installa la versione di Linux basata su X86 linuxBDT sul tuo computer Linux.

Altro

• Git, per la configurazione dell'ambiente di sviluppo Telink Zephyr.
• West, per gestire il progetto Zephyr e creare file binari OpenThread.

3. Configura il firmware

Configurare l'ambiente di sviluppo Telink Zephyr

Sul computer Linux, apri un terminale dell'interfaccia a riga di comando e inizia eseguendo i seguenti comandi per assicurarti che APT sia aggiornato.

$ sudo apt update
$ sudo apt upgrade

Al termine, procedi con i seguenti passaggi.

1. Installare le dipendenze.

   $ 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
   

   Attualmente Zephyr richiede versioni minime delle dipendenze principali, come CMake (3.20.0), Python3 (3.6) e Devicetree Compiler (1.4.6).

   $ cmake --version
   $ python3 --version
   $ dtc --version
   

   Verifica le versioni installate sul sistema prima di procedere con i passaggi successivi. Se le versioni non sono corrette, passa dal mirror APT a uno stabile e aggiornato oppure aggiorna manualmente queste dipendenze.
2. Installa l'app verso ovest.

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

   Assicurati che ~/.local/bin sia nella tua variabile di ambiente $PATH.
3. Ottieni il codice sorgente del progetto Zephyr.

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

4. Installa dipendenze Python aggiuntive per Zephyr.

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

5. Configura la catena di strumenti Zephyr. Scarica la toolchain Zephyr (circa 1~2 GB) in una directory locale per poter eseguire il flashing della maggior parte delle schede.

   $ 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
   

   Scarica l'SDK Zephyr e posizionalo nel percorso consigliato, come mostrato di seguito.

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

   Dove [-x.y.z] è testo facoltativo che può essere qualsiasi testo, ad esempio -0.16.1. Non è possibile spostare la directory dopo l'installazione dell'SDK. Quindi, installa la toolchain 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. Crea l'esempio Hello World. Innanzitutto, verifica che la configurazione ufficiale del progetto Zephyr sia corretta utilizzando l'esempio Hello World, quindi procedi con la configurazione del progetto personalizzato.

   $ cd ~/zephyrproject/zephyr
   $ west build -p auto -b tlsr9518adk80d samples/hello_world
   

   Utilizza il comando West build per creare l'esempio di hello_world dalla directory radice del repository Zephyr. Puoi trovare il firmware denominato zephyr.bin sotto build/zephyr directory.
7. Aggiungi lo script dell'ambiente Zephyr a ~/.bashrc. Esegui questi comandi.

   $ echo "source ~/zephyrproject/zephyr/zephyr-env.sh" >> ~/.bashrc
   $ source ~/.bashrc
   

8. Aggiungi il repository remoto di Telink Zephyr. Scarica il repository Telink localmente come ramo di sviluppo e aggiornalo.

   $ 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
   

Per ulteriori informazioni, consulta la Guida introduttiva al documento Zephyr.

Configura Telink LinuxBDT

Scarica lo strumento Telink LinuxBDT ed estrailo in una directory locale sul tuo computer Linux, come la home directory ~, per abilitare il firmware Flash sulla scheda di sviluppo B91.

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

Collega la Burning Board al computer Linux tramite l'interfaccia USB, quindi inserisci i comandi seguenti.

$ 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

Il messaggio "Telink Web Debugger v3.6" indica che il programmatore BDT si è connesso correttamente al computer Linux.

Compilazione firmware

Questo codelab creerà due tipi di firmware OpenThread:

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

I metodi di compilazione sono i seguenti:

1. Co-processore 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. Dispositivo Thread completo con riga di comando interattiva (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 firmware

Collega una scheda di sviluppo B91 alla Burning Board utilizzando un cavo USB, come illustrato nella figura sotto.

Nella riga di comando, esegui questi comandi per la masterizzazione del firmware (ad esempio, utilizzando il flashing del firmware 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

Il metodo Flash per ot-rcp è sostanzialmente lo stesso di ot-cli-ftd. Tuttavia, esistono differenze nei percorsi e nei nomi del firmware.

Dopo aver lampeggiato, distinguere le due schede di sviluppo B91 contrassegnandole di conseguenza. Etichetta la lavagna lampeggiata con ot-cli-ftd come "FTD Joiner" e la lavagna lampeggiava con ot-rcp come "RCP".

4. Configurazione di una console seriale per il dispositivo FTD Joiner

Come mostrato in figura, collegare direttamente l'FTD Joiner alla porta USB del sistema Linux.

Dopo aver collegato l'FTD Joiner Device al computer Linux, apri PuTTY. Quindi crea un nuovo terminale, imposta le informazioni sulla porta seriale e apri la porta seriale.

Puoi trovare il riferimento della riga di comando OpenThread qui: Riferimento all'interfaccia a riga di comando OpenThread. Assicurati di aggiungere ot prima a tutti i comandi.

Esempi:

> ot state
disabled
Done
> ot channel
11
Done
>

5. Configurare Raspberry Pi come router di confine OpenThread

Un router di confine OpenThread è un dispositivo composto da due parti principali:

• Raspberry Pi contiene tutti i servizi e il firmware necessari per fungere da router di confine (BR).
• RCP è responsabile delle comunicazioni Thread.

Co-processore radio (RCP)

Per eseguire il flashing del firmware ot-rcp, segui gli stessi passaggi della procedura di flashing del firmware ot-cli-ftd. Collega la scheda di sviluppo B91 a una porta USB sul Raspberry Pi, come mostrato nella figura seguente.

Raspberry Pi

1. Assicurati che l'immagine del sistema operativo Raspbian Bullseye Lite o il Raspbian Bullseye con desktop siano scritte correttamente sulla scheda SD.
2. Puoi scegliere di connetterti tramite SSH a Raspberry Pi o di lavorare direttamente con Raspbian Desktop. Questo codelab utilizzerà SSH.
3. Prima di procedere con l'installazione di OTBR Docker nel passaggio successivo, assicurati di aggiornare prima il repository locale e il gestore di pacchetti.

   $ sudo apt-get update
   $ sudp apt-get upgrade
   

Installa Docker

Se nel passaggio precedente hai semplicemente aggiornato il repository locale e il gestore di pacchetti APT, riavvia Raspberry Pi e apri una finestra del terminale SSH.

1. Installa Docker:

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

2. Inserisci l'account attuale in un gruppo Docker per concedere l'autorizzazione, in modo che non sia necessario aggiungere sudo prima di ogni comando.

   $ sudo usermod -aG docker $USER
   

   Devi riavviare Raspberry Pi per applicare le modifiche.
3. Se Docker non è stato avviato, avvialo:

   $ sudo dockerd
   

4. Gli script firewall OTBR generano regole all'interno del container Docker. Prima, esegui modprobe per caricare il modulo kernel di iptables.

   $ sudo modprobe ip6table_filter
   

Configura ed esegui Docker

Questo codelab estrae direttamente l'immagine Docker OTBR da OpenThread Docker Hub. Questa immagine è stata testata e verificata dal team di OpenThread.

1. Esegui il pull dell'immagine più recente:

   $ docker pull openthread/otbr:latest
   

2. Controlla l'elenco delle immagini nel container Docker:

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

3. Determina il nome della porta seriale del dispositivo RCP controllando /dev; ttyACM0 indica che il dispositivo RCP è collegato correttamente.

   $ ls /dev/tty*
   ...
   /dev/ttyACM0
   ... 
   

4. Esegui OTBR Docker per la prima volta e fai riferimento alla porta seriale di RCP (ttyACM0). Se vuoi continuare a utilizzare questo Docker OTBR, utilizza il comando 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. Apri una nuova finestra del terminale SSH per verificare la connettività tra Raspberry Pi e RCP.

   $ docker exec -ti otbr sh -c "sudo ot-ctl"
   > state 
   disabled
   Done
   

Comandi facoltativi Docker:

• Ottieni informazioni sul container Docker in esecuzione:

  $ docker ps -aq
  

• Arresta Docker OTBR:

  $ docker stop otbr
  

• Rimuovi Docker OTBR:

  $ docker rm otbr
  

• Ricarica Docker OTBR:

  $ docker restart otbr
  

A questo punto, un dispositivo FTD Joiner e un OTBR sono pronti e puoi procedere con il passaggio successivo per creare la rete Thread.

6. Crea una rete Thread

Crea una rete Thread su RCP

Utilizziamo la shell ot-ctl sull'OTBR per stabilire una rete Thread. Se sei uscito dalla shell nell'ultima sezione, inserisci il comando seguente per avviarla di nuovo nel terminale SSH:

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

Quindi, inserisci i comandi nell'ordine specificato nella tabella e assicurati che ogni passaggio raggiunga il risultato previsto prima di procedere con quello successivo.

La chiave di rete generata in modo casuale da OTBR durante la creazione della rete verrà usata quando ot-cli-ftd dispositivi entrano a far parte di questa rete Thread.

Aggiungere l'FTD Joiner a Thread attraverso la messa in servizio fuori banda

La messa in servizio fuori banda si riferisce alla trasmissione delle credenziali di rete ai dispositivi in attesa di collegarsi alla rete tramite metodi non wireless (ad esempio, l'inserimento manuale nell'interfaccia a riga di comando OpenThread). Inserisci i seguenti comandi in ordine nella console seriale in FTD Joiner.

Topologia

Inserisci comandi come ipaddr, child table, router table nel terminale SSH per ricevere risposte come i seguenti snippet di codice.

> 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

Il RLOC16 di OTBR è 0xb000, mentre il RLOC16 del Joiner FTD è inizialmente 0xb001. Il valore RLOC16 del joiner FTD diventa 0x8400 dopo l'ottenimento dell'ID router. Si può notare che l'FTD Joiner è stato trasformato da figlio a router.

L'attuale rete Thread contiene due nodi e la topologia è quella mostrata nella figura seguente.

7. Comunicazione tra dispositivi Thread

Comunicazione ICMPv6

Utilizziamo il comando ping per verificare se i dispositivi Thread nella stessa rete possono comunicare tra loro. In primo luogo, utilizza il comando ipaddr per ottenere l'RLOC del dispositivo.

> 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

Inserisci il comando seguente nella console seriale dell'FTD Joiner per eseguire l'operazione di 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 risposta dell'output della porta seriale indica che il lato OTBR ha ricevuto la richiesta di ping e che FTD Joiner ha ricevuto la risposta ping restituita da OTBR. La comunicazione tra i due dispositivi è riuscita.

Comunicazione UDP

I servizi per le applicazioni forniti da OpenThread includono anche UDP. Puoi utilizzare l'API UDP per passare le informazioni tra i nodi nella rete Thread o passare le informazioni a reti esterne attraverso il router di confine. L'introduzione dettagliata dell'API UDP di OpenThread è disponibile nell'interfaccia a riga di comando OpenThread - Esempio UDP. Questo codelab utilizzerà alcune delle API al suo interno per trasmettere informazioni tra OTBR e FTD Joiner.

Innanzitutto, ottieni l'EID locale mesh di OTBR. Questo indirizzo è anche uno degli indirizzi IPv6 del dispositivo Thread e può essere utilizzato per accedere ai dispositivi Thread nella stessa partizione di rete Thread.

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

Inserisci i comandi seguenti nel terminale SSH per abilitare OTBR UDP e associare la porta 1022 del dispositivo.

> udp open
Done
> udp bind :: 1022
Done

Inserisci i comandi seguenti nella console seriale e abilita l'UDP dell'FTD Joiner. Associa la porta 1022 del dispositivo e poi invia un messaggio hello da 5 byte a OTBR.

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

Il terminale SSH restituisce le seguenti informazioni. OTBR riceve il messaggio hello da FTD Joiner, a indicare che la comunicazione UDP è riuscita.

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

8. Complimenti

Hai creato una rete Thread semplice e hai verificato la comunicazione all'interno di questa rete.

Ora sai:

• Come creare e utilizzare l'ambiente di sviluppo Telink Zephyr
• Come creare i file binari ot-cli-ftd e ot-rcp e come eseguire il flashing su schede di sviluppo Telink B91.
• Come configurare un Raspberry Pi 3B+ o una versione successiva come router di confine OpenThread (OTBR) usando Docker.
• Come creare una rete Thread su OTBR.
• Come aggiungere dispositivi alla rete Thread tramite la messa in servizio fuori banda.
• Come verificare la connettività tra nodi nella rete Thread.

Per approfondire

Dai un'occhiata a openthread.io e GitHub per scoprire di più sulle varie risorse OpenThread, tra cui:

• Piattaforme supportate: scopri tutte le piattaforme che supportano OpenThread
• Creare OpenThread: ulteriori dettagli su come creare e configurare OpenThread.
• Thread Primer: tratta tutti i concetti relativi ai thread presentati in questo codelab

Documenti di riferimento:

• Riferimento per l'interfaccia a riga di comando OpenThread
• Riferimento per l'interfaccia a riga di comando UDP OpenThread
• Riferimento API UDP OpenThread