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 robusto e sicuro progettato per i dispositivi dell'Internet delle cose (IoT). 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'ambito completo del livello di rete all'interno di Thread, ad esempio IPv6, 6LoWPAN, IEEE 802.15.4 con sicurezza MAC, creazione di link mesh e routing mesh.

Telink ha integrato l'implementazione di 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 su hardware reale, creerai e gestirai una rete Thread e scambierai messaggi tra i 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 della CLI OpenThread (ot-cli-ftd e ot-rcp) e caricarli sulle schede di sviluppo Telink B91.
Per configurare un router di confine OpenThread (OTBR) utilizzando Docker su Raspberry Pi 3B+ o versioni successive.
Per creare una rete Thread sull'OTBR.
Per aggiungere dispositivi alla rete Thread utilizzando il debug out-of-band.
Per convalidare la connettività tra i nodi nella rete Thread utilizzando la CLI.

Che cosa ti serve

Hardware:

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 programmazione e debug Telink - LinuxBDT.
Strumento terminale della porta seriale, ad esempio PuTTY.
Altri strumenti come Git e West.

2. Prerequisiti

Concetti di Thread e CLI OpenThread

Prima di questo codelab, potrebbe essere utile seguire il codelab sulla simulazione OpenThread per acquisire familiarità con i concetti fondamentali di Thread e con la CLI OpenThread.

Linux Machine

La macchina Linux (Ubuntu v20.04 LTS o versioni successive) funge da macchina di compilazione per configurare l'ambiente di sviluppo Telink Zephyr e programmare tutte le schede di sviluppo Thread. Per eseguire queste attività, la macchina Linux richiede due porte USB disponibili e la connettività a internet.

Connessione e terminali della porta seriale

Puoi collegare direttamente il dispositivo alla porta USB della macchina Linux. Inoltre, avrai bisogno di uno strumento terminale della porta seriale per accedere ai dispositivi.

In questo codelab, lo strumento terminale PuTTY viene utilizzato 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 seguente mostra i componenti minimi richiesti in un unico set.

Uno di questi kit verrà utilizzato come RCP (Radio Co-Processor), mentre l'altro funzionerà come FTD (Full Thread Device). Se non hai ancora ricevuto il kit, puoi trovare maggiori dettagli sul sito web ufficiale di Telink. Di seguito sono riportati alcuni componenti da utilizzare:

Indice	Nome
1	Scheda di sviluppo Telink B91
2	Telink Burning Board
3	Antenna 2,4 GHz
4	Cavo USB (da USB-A a mini USB)

Raspberry Pi 3B+ o versioni successive con immagine del 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 OpenThread Border Router (OTBR).

Connessione di rete

Uno switch (o router) connesso a internet e diversi cavi Ethernet. Vengono utilizzati per connettere Raspberry Pi alla macchina Linux, facilitando la configurazione di Raspberry Pi da parte dell'utente tramite l'host.

LinuxBDT

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

Altro

Git, per configurare l'ambiente di sviluppo Telink Zephyr.
West, per gestire il progetto Zephyr e creare i binari OpenThread.

3. Configurare il firmware

Configura l'ambiente di sviluppo Telink Zephyr

Sulla macchina Linux, apri un terminale CLI e inizia eseguendo i seguenti comandi per assicurarti che APT sia aggiornato.

$ sudo apt update
$ sudo apt upgrade

Una volta completata questa operazione, procedi con i passaggi successivi.

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 le 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 tuo sistema prima di procedere con i passaggi successivi. Se le versioni non sono corrette, passa a un mirror APT stabile e aggiornato o aggiorna manualmente queste dipendenze.

Installa ovest.

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

Assicurati che ~/.local/bin sia nella variabile di ambiente $PATH.

Recupera il codice sorgente del progetto Zephyr.

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

Installa dipendenze Python aggiuntive per Zephyr.

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

Configura la toolchain 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 inseriscilo 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 qualsiasi testo, ad esempio -0.16.1. La directory non può essere spostata dopo l'installazione dell'SDK. Poi 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

Crea l'esempio Hello World. Per prima cosa, verifica che la configurazione ufficiale del progetto Zephyr sia corretta utilizzando l'esempio Hello World, poi procedi con la configurazione del tuo progetto personalizzato.
```
$ cd ~/zephyrproject/zephyr
$ west build -p auto -b tlsr9518adk80d samples/hello_world
```
Utilizza il comando di compilazione West per compilare l'esempio hello_world dalla directory principale del repository Zephyr. Puoi trovare il firmware denominato zephyr.bin nella sezione build/zephyr directory.

Aggiungi lo script dell'ambiente Zephyr a ~/.bashrc. Esegui i seguenti comandi.

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

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 saperne di più, consulta la Guida introduttiva di Zephyr Doc.

Configurare Telink LinuxBDT

Scarica lo strumento Telink LinuxBDT ed estrailo in una directory locale della tua macchina Linux, ad esempio la home directory ~, per poter caricare il 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 la scheda di masterizzazione alla macchina Linux tramite l'interfaccia USB, quindi inserisci i seguenti comandi.

$ 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 visualizzi il messaggio "Telink Web Debugger v3.6", significa che il programmatore BDT si è connesso correttamente alla macchina Linux.

Compilazione del firmware

Questo codelab creerà due tipi di firmware OpenThread:

ot-cli-ftd,
e ot-rcp.

I metodi di compilazione sono i seguenti:

Radio Co-Processor（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

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 del firmware

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

Nella riga di comando, esegui i seguenti comandi per eseguire il burning del firmware (utilizzando come esempio 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 è fondamentalmente lo stesso di quello per ot-cli-ftd. Tuttavia, esistono differenze nei percorsi e nei nomi del firmware.

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

4. Configura una console seriale per il dispositivo di unione FTD

Come mostrato nell'immagine, collega direttamente l'FTD Joiner alla porta USB della macchina Linux.

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

Il riferimento alla riga di comando di OpenThread è disponibile qui: Riferimento alla CLI di OpenThread. Assicurati di aggiungere il prefisso ot 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 della comunicazione Thread.

Radio Co-Processor (RCP)

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

Raspberry Pi

Assicurati che l'immagine del sistema operativo Raspbian Bullseye Lite o Raspbian Bullseye con desktop sia scritta correttamente sulla scheda SD.
Puoi connetterti a Raspberry Pi tramite SSH o lavorare direttamente con Raspbian Desktop. Questo codelab utilizzerà SSH.
Prima di procedere all'installazione di OTBR Docker nel passaggio successivo, assicurati di aggiornare prima il repository locale e il gestore dei pacchetti.
```
$ sudo apt-get update
$ sudp apt-get upgrade
```

Installa Docker

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

Installa Docker:

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

Inserisci l'account corrente in un gruppo Docker per concedere l'autorizzazione in modo che sudo non debba essere aggiunto davanti a ogni comando.
```
$ sudo usermod -aG docker $USER
```
Per applicare le modifiche, devi riavviare Raspberry Pi.
Se Docker non è stato avviato, avvialo:
```
$ sudo dockerd
```
Gli script firewall OTBR generano regole all'interno del container Docker. Prima di ciò, esegui modprobe per caricare il modulo kernel di iptables.
```
$ sudo modprobe ip6table_filter
```

Configura ed esegui Docker

Questo codelab esegue il pull diretto dell'immagine Docker OTBR da OpenThread Docker Hub. Questa immagine è stata testata e verificata dal team di OpenThread.

Esegui il pull dell'ultima immagine:
```
$ docker pull openthread/otbr:latest
```

Controlla l'elenco delle immagini nel container Docker:

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

Determina il nome della porta seriale del dispositivo RCP controllando /dev. ttyACM0 indica che l'RCP è collegato correttamente.
```
$ ls /dev/tty*
...
/dev/ttyACM0
... 
```

Esegui OTBR Docker per la prima volta e fai riferimento alla porta seriale di RCP (ttyACM0). Se vuoi continuare a utilizzare questo OTBR Docker, 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

Apri una nuova finestra del terminale SSH per testare la connettività tra Raspberry Pi e l'RCP.
```
$ docker exec -ti otbr sh -c "sudo ot-ctl"
> state 
disabled
Done
```

Comandi Docker facoltativi:

Visualizza informazioni sul container Docker in esecuzione:
```
$ docker ps -aq
```
Arresta OTBR Docker:
```
$ docker stop otbr
```
Rimuovi OTBR Docker:
```
$ docker rm otbr
```
Ricarica Docker OTBR:
```
$ docker restart otbr
```

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

6. Creare una rete Thread

Creare una rete Thread su RCP

Utilizziamo la shell ot-ctl su OTBR per stabilire una rete Thread. Se hai chiuso la shell nella sezione precedente, inserisci il seguente comando per riavviarla nel terminale SSH:

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

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

Indice	Comando	Introduzione	Risposta prevista
1	`dataset init new`	Crea un nuovo set di dati di rete casuale.	Fine
2	`dataset commit active`	Esegui il commit del nuovo set di dati nel set di dati operativi attivo in una memoria non volatile.	Fine
3	`ifconfig up`	Visualizza l'interfaccia IPv6.	Fine
4	`thread start`	Attiva il funzionamento del protocollo Thread e connettiti a una rete Thread.	Fine
			Attendi 10 secondi affinché venga visualizzata l'interfaccia del thread.
5	`state`	Controlla lo stato del dispositivo.Questo comando può essere chiamato più volte finché non diventa il leader e non passa al passaggio successivo.	leader Fine
6	`dataset active`	Controlla l'intero set di dati operativi attivi e registra la chiave di rete.	Active Timestamp: 1 Channel: 13 Channel Mask: 0x07fff800 Ext PAN ID: b07476e168eda4fc Mesh Local Prefix: fd8c:60bc:a98:c7ba::/64 Network Key: c312485187484ceb5992d2343baaf93d Network Name: OpenThread-599c PAN ID: 0x599c PSKc: 04f79ad752e8401a1933486c95299f60 Security Policy: 672 onrc 0 Done

La chiave di rete generata in modo casuale da OTBR durante la creazione della rete verrà utilizzata quando i dispositivi ot-cli-ftd si connettono a questa rete Thread.

Aggiungere FTD Joiner a Thread tramite il provisioning out-of-band

Il provisioning out-of-band si riferisce alla trasmissione delle credenziali di rete ai dispositivi in attesa di connettersi alla rete tramite metodi non wireless (ad esempio, l'inserimento manuale nella CLI OpenThread). Inserisci i seguenti comandi in ordine nella console seriale per FTD Joiner.

Indice	Comando	Introduzione	Risposte previste
1	`ot dataset networkkey c312485187484ceb5992d2343baaf93d`	Per connettersi a una rete Thread è necessaria solo la chiave di rete.	Fine
2	`ot dataset commit active`	Esegui il commit del nuovo set di dati nel set di dati operativi attivo in una memoria non volatile.	Fine
3	`ot ifconfig up`	Visualizza l'interfaccia IPv6.	Fine
4	`ot thread start`	Attiva il funzionamento del protocollo Thread e connettiti a una rete Thread.	Fine
			Attendi 20 secondi mentre il dispositivo si connette e si configura.
5	`ot state`	Controlla lo stato del dispositivo.	child/router Fine

Topologia

Inserisci comandi come ipaddr, child table, router table nel terminale SSH per ottenere 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 e il RLOC16 di FTD Joiner inizialmente è 0xb001. A questo punto, l'FTD Joiner's RLOC16 diventa 0x8400 dopo aver ottenuto l'ID router. Si può notare che il dispositivo di unione FTD è stato aggiornato da dispositivo secondario a router.

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

7. Comunicazione tra i 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 di FTD Joiner per eseguire l'operazione 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 ping e che FTD Joiner ha ricevuto la risposta ping restituita da OTBR. La comunicazione tra i due dispositivi è riuscita.

Comunicazione UDP

I servizi applicativi forniti da OpenThread includono anche UDP. Puoi utilizzare l'API UDP per trasferire informazioni tra i nodi della rete Thread o per trasferire informazioni a reti esterne tramite il router di confine. L'introduzione dettagliata dell'API UDP di OpenThread è disponibile in OpenThread CLI - UDP Example. Questo codelab utilizzerà alcune delle API per trasmettere informazioni tra OTBR e FTD Joiner.

Per prima cosa, recupera l'EID locale della 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 seguenti comandi nel terminale SSH per attivare OTBR UDP e associare la porta 1022 del dispositivo.

> udp open
Done
> udp bind :: 1022
Done

Inserisci i seguenti comandi nella console seriale e abilita l'UDP di FTD Joiner. Collega la porta 1022 del dispositivo, quindi invia un messaggio hello di 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, il che significa che la comunicazione UDP è riuscita.

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

8. Complimenti

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

Ora sai che:

Come creare e utilizzare l'ambiente di sviluppo Telink Zephyr.
Come creare i file binari ot-cli-ftd e ot-rcp, nonché come eseguirne il flashing sulle schede di sviluppo Telink B91.
Come configurare 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 il provisioning out-of-band.
Come verificare la connettività tra i nodi della rete Thread.

Per approfondire

Visita openthread.io e GitHub per scoprire varie risorse OpenThread, tra cui:

Piattaforme supportate: scopri tutte le piattaforme che supportano OpenThread
Build OpenThread: ulteriori dettagli sulla creazione e la configurazione di OpenThread
Thread Primer: tratta tutti i concetti di Thread presentati in questo codelab

Documenti di riferimento: