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 degli 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'ambito completo 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 OpenThread in Zephyr RTOS, consentendo una compatibilità perfetta con l'hardware Telink. Il codice sorgente per questa integrazione è facilmente accessibile su GitHub ed è fornito anche come software development kit (SDK).

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

Obiettivi didattici

• Configurare l'implementazione OpenThread utilizzando l'ambiente di sviluppo Telink Zephyr.
• 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.
• Per configurare un router di confine OpenThread (OTBR) utilizzando Docker su un Raspberry Pi 3B e versioni successive o versioni successive.
• Per creare una rete Thread sulla OTBR.
• Per aggiungere dispositivi alla rete Thread utilizzando il debug fuori banda.
• a convalidare la connettività tra i nodi nella rete Thread mediante l'interfaccia a riga di comando.

Che cosa ti serve

Articoli di ferramenta:

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

Software:

• Strumento di burning e debug Telink - LinuxBDT.
• Strumento di terminale per la 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 esaminare il codelab sulla simulazione OpenThread per acquisire familiarità con i concetti fondamentali di Thread e l'interfaccia a riga di comando OpenThread prima di questo codelab.

Macchina Linux

La macchina Linux (Ubuntu v20.04 LTS o versioni successive) 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à, la macchina Linux richiede due porte USB disponibili e una connessione a internet.

Connessione porta seriale e terminali

Puoi collegare il dispositivo direttamente alla porta USB del computer Linux. Inoltre, per accedere ai dispositivi ti servirà uno strumento di terminale con porta seriale.

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

Kit di sviluppo Telink B91

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

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

Immagine Raspberry Pi 3B o versioni successive con sistema operativo Raspbian

In questo codelab, è necessario un Raspberry Pi 3B o versioni successive con immagine del sistema operativo Raspbian Bullseye Lite o 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 router) connesso a Internet e diversi cavi Ethernet. Vengono utilizzati per collegare Raspberry Pi alla macchina Linux, agevolando la configurazione di Raspberry Pi tramite l'host.

LinuxBDT

Lo strumento Telink Burning and Debugging Tool (BDT), che si applica a tutte le serie di chip Telink, consente di cancellare e flashare il firmware OpenThread sulle schede di sviluppo Telink B91. Installa la versione di Linux basata su X86 linuxBDT sul tuo computer Linux.

Altri

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

3. Configura firmware

Configura l'ambiente di sviluppo Telink Zephyr

Sulla macchina Linux, apri un terminale a riga di comando e inizia eseguendo questi comandi per assicurarti che il tuo APT sia aggiornato.

$ sudo apt update
$ sudo apt upgrade

Al termine, procedi con i seguenti passaggi.

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

   Zephyr attualmente 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 al Mirror APT su un mirror stabile e aggiornato oppure aggiorna manualmente queste dipendenze.
2. Installa west.

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

   Assicurati che ~/.local/bin sia nella 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 Toolchain di Zephyr. Scarica la Toolchain di Zephyr (circa 1 ~ 2 GB) in una directory locale per consentire 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] è un testo facoltativo che può essere di qualsiasi tipo, ad esempio -0.16.1. Non è possibile spostare la directory dopo l'installazione dell'SDK. Quindi, installa la Toolchain di 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 hello_world dalla directory root del repository Zephyr. Puoi trovare il firmware denominato zephyr.bin nella sezione build/zephyr directory.
7. Aggiungi lo script di ambiente Zephyr a ~/.bashrc. Esegui questi comandi.

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

8. Aggiungi il repository remoto 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, ad esempio la home directory ~, che consente di eseguire il flashing del firmware 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 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

Se viene visualizzato il messaggio "Telink Web Debugger v3.6", significa che il programmatore BDT si è connesso correttamente alla macchina Linux.

Compilation del 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 in primo piano 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
   

Firmware Flash

Collegare una scheda di sviluppo B91 alla scheda di masterizzazione utilizzando un cavo USB, come illustrato nella figura seguente.

Nella riga di comando, esegui questi comandi per eseguire la masterizzazione del firmware (utilizzando il lampeggiamento del firmware ot-cli-ftd come esempio).

$ 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 è fondamentalmente uguale a quello utilizzato per ot-cli-ftd. Tuttavia, esistono differenze nei percorsi e nei nomi del firmware.

Dopo il lampeggiamento, distingui le due schede di sviluppo B91 contrassegnandole di conseguenza. Etichetta la bacheca con ot-cli-ftd come "FTD Joiner" e etichetta con ot-rcp come "RCP".

4. Configura una console seriale per il dispositivo Joiner FTD

Come mostrato nell'immagine, collega direttamente FTD Joiner alla porta USB del computer Linux.

Dopo aver connesso il dispositivo Joiner FTD alla macchina Linux, apri PuTTY. Quindi, crea un nuovo terminale, imposta le informazioni relative alla porta seriale e apri la porta seriale.

Il riferimento per la riga di comando OpenThread è qui: Riferimento per l'interfaccia a riga di comando OpenThread. Assicurati di anteporre a tutti i comandi il prefisso ot.

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 costituito da due parti principali:

• Raspberry Pi contiene tutti i servizi e il firmware necessari per funzionare come router di confine (BR).
• La RCP è responsabile della comunicazione Thread.

Co-processore radio(RCP)

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

Raspberry Pi

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

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

Installa Docker

Se al passaggio precedente aggiorni l'APT del repository locale e del gestore di pacchetti, riavvia Raspberry Pi e apri una finestra del terminale SSH.

1. Installa Docker:

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

2. Inserisci l'account corrente 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
   

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

   $ sudo dockerd
   

4. Gli script firewall OTBR generano regole all'interno del container Docker. Prima di farlo, 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 dall'hub Docker OpenThread. Questa immagine è stata testata e verificata dal team 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 RCP è connesso 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, usa 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 testare la connettività tra Raspberry Pi e RCP.

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

Comandi docker facoltativi:

• Ottieni informazioni sul container Docker in esecuzione:

  $ docker ps -aq
  

• Interrompi 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 seguente comando per avviarla nuovamente 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 ottenga 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à utilizzata quando ot-cli-ftd dispositivi si uniranno a questa rete Thread.

Aggiungere il joiner FTD a Thread tramite la messa in servizio fuori banda

La messa in servizio fuori banda si riferisce alla trasmissione di 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 nell'ordine nella console seriale per arrivare a FTD Joiner.

Topologia

Inserisci comandi come ipaddr, child table e router table nel terminale SSH per ricevere risposte come gli snippet di codice indicati di seguito.

> 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 e il RLOC16 del joiner FTD inizialmente è 0xb001. Quindi, il RLOC16 del joiner FTD diventa 0x8400 dopo aver ottenuto l'ID router. Si può notare che FTD Joiner è stato trasformato in un router secondario.

L'attuale rete Thread contiene due nodi e la topologia è come mostrato 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. Innanzitutto, 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 seguente comando nella console seriale del joiner FTD 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 di output della porta seriale indica che il lato OTBR ha ricevuto la richiesta di ping e che il joiner FTD ha ricevuto la risposta ping restituita da OTBR. La comunicazione tra i due dispositivi ha esito positivo.

Comunicazione UDP

I servizi per le applicazioni forniti da OpenThread includono anche UDP. Puoi utilizzare l'API UDP per passare informazioni tra i nodi nella rete Thread o per passare informazioni a reti esterne tramite il router di confine. L'introduzione dettagliata dell'API UDP di OpenThread è nell'Esempio di interfaccia a riga di comando di OpenThread - 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 del joiner FTD. Associa la porta 1022 del dispositivo, quindi invia un messaggio hello a 5 byte all'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 dal joiner FTD, il che significa che la comunicazione UDP ha esito positivo.

> 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 programmi binari ot-cli-ftd e ot-rcp e come eseguirne il flashing sulle schede di sviluppo Telink B91.
• Come configurare un Raspberry Pi 3B+ o una versione successiva come router di confine OpenThread (OTBR) utilizzando 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

Consulta openthread.io e GitHub per scoprire di più sulle varie risorse OpenThread, tra cui:

• Piattaforme supportate: scopri tutte le piattaforme che supportano OpenThread
• Crea OpenThread: ulteriori dettagli su come creare e configurare OpenThread
• Thread Primer: illustra tutti i concetti di 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 di OpenThread
• Riferimento API OpenThread UDP