Google is committed to advancing racial equity for Black communities. See how.

Questa pagina è stata tradotta dall'API Cloud Translation.

Creare una rete Thread con schede nRF52840 e OpenThread

1. Introduzione

OpenThread rilasciato da Google è un'implementazione open source del protocollo di networking Thread®. Google Nest ha rilasciato OpenThread per rendere disponibile agli sviluppatori la tecnologia utilizzata nei prodotti Nest per accelerare lo sviluppo dei prodotti per la casa connessa.

La specifica Thread definisce un protocollo di comunicazione da dispositivo a dispositivo wireless affidabile, sicuro e a basso consumo per le applicazioni domestiche. OpenThread implementa tutti i livelli di networking Thread, tra cui IPv6, 6LoWPAN, IEEE 802.15.4 con sicurezza MAC, mesh Link Establishment e Mesh Routing.

In questo codelab, definirai OpenThread su hardware reale, creerai e gestirai una rete Thread e passerai messaggi tra i nodi.

Obiettivi didattici

Creazione di programmi binari dell'interfaccia a riga di comando OpenThread e flashing boards per dev board
Creazione di un RCP costituito da una macchina Linux e da una scheda sviluppatore
Comunicazioni con un RCP utilizzando OpenThread Daemon e ot-ctl
Gestione manuale dei nodi Thread con la schermata GNU e l'interfaccia a riga di comando OpenThread
Messa in sicurezza dei dispositivi su una rete Thread
Come funziona il multicast IPv6
Trasmettere messaggi tra nodi Thread con UDP

Che cosa ti serve

Hardware:

3 schede di sviluppo Nordic Semiconductor nRF52840
3 cavi da USB a micro USB per collegare le schede
Un computer Linux con almeno 3 porte USB

Software:

Portachiavi GNU
Strumenti a riga di comando Nordic nRF5x
Software Segger J-Link
OpenThread
Git

2. Come iniziare

Simulazione OpenThread

Prima di iniziare, puoi esaminare il codelab della simulazione di OpenThread, per acquisire familiarità con i concetti di base di Thread e l'interfaccia a riga di comando di OpenThread.

Terminali porta seriale

Dovresti sapere come connetterti a una porta seriale tramite un terminale. Questo codelab utilizza la schermata GNU e fornisce una panoramica dell'utilizzo, ma è possibile utilizzare qualsiasi altro software di terminale.

Macchina Linux

Questo codelab è stato progettato per utilizzare una macchina Linux basata su i386 o x86 come host per un dispositivo Thread Radio Co-Processor (RCP) e per eseguire il flashing di tutte le schede di sviluppo Thread. Tutti i passaggi sono stati testati su Ubuntu 14.04.5 LTS (Trusty Tahr).

Schede Nordic Semiconductor nRF52840

Questo codelab utilizza tre schede nPD52840 PDK.

Installa SEGGER J-Link

Utilizziamo SEGGER J-Link per programmare le schede nRF52840, che hanno moduli JTAG integrati. Installalo sulla tua macchina Linux.

Scarica il pacchetto appropriato per il tuo computer e installalo nel percorso corretto. Su Linux è /opt/SEGGER/JLink.

Installa strumenti a riga di comando nRF5x

Gli strumenti a riga di comando nRF5x consentono di eseguire il flashing dei programmi binari OpenThread alle schede nRF52840. Installa la build nRF5x-Command-Line-Tools-<OS> appropriata sulla tua macchina Linux.

Inserisci il pacchetto estratto nella cartella principale ~/

Installa la catena portautensili GNU

La pinza per attrezzi ARM GNU viene utilizzata per l'edilizia.

Ti consigliamo di posizionare l'archivio estratto in /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ sul tuo computer Linux. Segui le istruzioni nel file readme.txt dell'archivio per le istruzioni di installazione.

Schermata di installazione (facoltativa)

Lo schermo è un semplice strumento per accedere ai dispositivi collegati tramite una porta seriale. Questo codelab utilizza Screen, ma puoi usare qualsiasi applicazione di terminale per porte seriali.

$ sudo apt-get install screen

3. Clona repository

OpenThread

Clona e installa OpenThread. I comandi script/bootstrap assicurano che la toolchain sia installata e che l'ambiente sia configurato correttamente:

$ mkdir -p ~/src
$ cd ~/src
$ git clone --recursive https://github.com/openthread/openthread.git
$ cd openthread
$ ./script/bootstrap

Crea il daemon OpenThread:

$ script/cmake-build posix -DOT_DAEMON=ON

Ora è tutto pronto per la creazione e il flashing di OpenThread nelle schede nRF52840.

4. Configura il joiner RCP

Creazione e flash

Crea l'esempio OpenThread nRF52840 con Joiner e funzionalità USB native. Un dispositivo utilizza il ruolo Joiner per l'autenticazione sicura e la commissione su una rete Thread. L'USB nativo consente di utilizzare l'USB CDC ACM come trasporto seriale tra nRF52840 e l'host.

Esegui sempre la pulizia del repository delle build precedenti eseguendo rm -rf build.

$ cd ~/src
$ git clone --recursive https://github.com/openthread/ot-nrf528xx.git
$ cd ot-nrf528xx
$ script/build nrf52840 USB_trans

Vai alla directory con il programma binario RCP di OpenThread e convertilo in formato esadecimale:

$ cd ~/src/ot-nrf528xx/build/bin
$ arm-none-eabi-objcopy -O ihex ot-rcp ot-rcp.hex

Collega il cavo USB alla porta di debug Micro-USB accanto al pin di alimentazione esterno sulla scheda nRF52840, quindi collegalo alla macchina Linux. Imposta l'interruttore della fonte di alimentazione nRF sulla scheda nRF52840 su VDD. Quando è collegato correttamente, il LED5 è acceso.

Se questa è la prima scheda collegata alla macchina Linux, viene visualizzata come porta seriale /dev/ttyACM0 (tutte le schede nRF52840 utilizzano ttyACM per l'identificatore della porta seriale).

$ ls /dev/ttyACM*
/dev/ttyACM0

Osserva il numero di serie della scheda nRF52840 utilizzata per l'RCP:

Vai alla posizione degli strumenti a riga di comando nRFx e inserisci il file esadecimale RCP di OpenThread nella scheda nRF52840, utilizzando il numero di serie della scheda. Tieni presente che, se escludi il flag --verify, verrà visualizzato un messaggio di avviso che ti informa che il processo Flash potrebbe non riuscire senza errore.

$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924  --verify --chiperase --program \
       ~/src/ot-nrf528xx/build/bin/ot-rcp.hex --reset

Al termine dell'operazione viene generato l'output:

Parsing hex file.
Erasing user available code and UICR flash areas.
Applying system reset.
Checking that the area to write is not protected.
Programing device.
Applying system reset.
Run.

Assegna un'etichetta alla lavagna"RCP" in modo da non confondere i ruoli.

Connetti a USB nativo

Poiché la build RCP di OpenThread consente l'utilizzo di ACD USB CDC nativo come trasporto seriale, devi utilizzare la porta nRF USB sulla scheda nRF52840 per comunicare con l'host RCP (macchina Linux).

Scollega l'estremità micro USB del cavo USB dalla porta di debug della scheda nRF52840 flash, quindi ricollegala alla porta nRF USB Micro-USB accanto al pulsante RESET. Imposta l'opzione della fonte di alimentazione nRF su USB.

Avvia daemon OpenThread

Nella progettazione RCP, utilizza OpenThread Daemon per comunicare e gestire il dispositivo Thread. Inizia ot-daemon con il flag dettagliato -v in modo da poter vedere l'output del log e verificare che sia in esecuzione:

$ cd ~/src/openthread
$ sudo ./build/posix/src/posix/ot-daemon -v \
    'spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=115200'

Se l'operazione ha esito positivo, ot-daemon in modalità dettagliata genera un output simile al seguente:

ot-daemon[12463]: Running OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; POSIX; Aug 30 2022 10:55:05
ot-daemon[12463]: Thread version: 4
ot-daemon[12463]: Thread interface: wpan0
ot-daemon[12463]: RCP version: OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; SIMULATION; Aug 30 2022 10:54:10

Lascia aperta questa finestra del terminale in modo da poter visualizzare i log di ot-daemon.

Utilizza ot-ctl per comunicare con il nodo RCP. ot-ctl utilizza lo stesso interfaccia a riga di comando dell'app OpenThread CLI. Pertanto, puoi controllare i nodi ot-daemon nello stesso modo degli altri dispositivi Thread simulati.

In una seconda finestra del terminale, avvia ot-ctl:

$ sudo ./build/posix/src/posix/ot-ctl
>

Controlla il state del nodo 2 (nodo RCP) avviato con ot-daemon:

> state
disabled
Done

5. Configura i FTD

Gli altri due nodi Thread utilizzati in questo codelab sono dispositivi Full Thread (FTD) con la progettazione standard system-on-chip (SoC). In un'impostazione di produzione, si potrebbe usare wpantund, un driver dell'interfaccia di rete di livello enterprise per controllare le istanze NCP di OpenThread, ma in questo codelab utilizzeremo ot-ctl, l'interfaccia a riga di comando di OpenThread.

Un dispositivo ha il ruolo di Commissario, per autenticare e mettere in sicurezza i dispositivi su quella rete in modo sicuro. L'altro dispositivo funziona come un joiner che il commissario può autenticare nella rete Thread.

Creazione e flash

Crea l'esempio OpenThread FTD per la piattaforma nRF52840, con i ruoli Commissioner e Joiner abilitati:

$ cd ~/src/ot-nrf528xx
$ rm -rf build
$ script/build nrf52840 USB_trans -DOT_JOINER=ON -DOT_COMMISSIONER=ON

Vai alla directory con il programma binario dell'interfaccia a riga di comando FTD (OpenThread Thread Device) e convertilo in formato esadecimale:

$ cd ~/src/ot-nrf528xx/build/bin
$ arm-none-eabi-objcopy -O ihex ot-cli-ftd ot-cli-ftd.hex

Collega il cavo USB alla porta micro USB accanto al pin di alimentazione esterno sulla scheda nRF52840, quindi collegalo alla macchina Linux. Se il protocollo RCP è ancora collegato alla macchina Linux, questa nuova scheda dovrebbe essere visualizzata come porta seriale /dev/ttyACM1 (tutte le schede nRF52840 utilizzano ttyACM per l'identificatore della porta seriale).

$ ls /dev/ttyACM*
/dev/ttyACM0  /dev/ttyACM1

Come in precedenza, tieni presente il numero di serie della scheda nRF52840 utilizzata per l'FTD:

Vai alla posizione degli strumenti a riga di comando nRFx e inserisci il file esadecimale FLI di OpenThread CLI sulla scheda nRF52840, utilizzando il numero di serie della scheda:

$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
       ~/src/ot-nrf528xx/build/bin/ot-cli-ftd.hex --reset

Etichetta la lavagna "Commissioner".

Connetti a USB nativo

Poiché la build FTD OpenThread consente l'utilizzo di ACM USB CCD nativo come trasporto seriale, devi utilizzare la porta nRF USB sulla scheda nRF52840 per comunicare con l'host RCP (macchina Linux).

Verifica build

Verifica la riuscita di una build accedendo all'interfaccia a riga di comando di OpenThread utilizzando la schermata GNU da una finestra del terminale. Le schede nRF52840 utilizzano una velocità di trasmissione di 115200.

$ screen /dev/ttyACM1 115200

Nella nuova finestra, premi alcune volte la tastiera per visualizzare la richiesta > dell'interfaccia a riga di comando OpenThread. Apri l'interfaccia IPv6 e controlla gli indirizzi:

> ifconfig up
Done
> ipaddr
fe80:0:0:0:1cd6:87a9:cb9d:4b1d
Done

Utilizza Ctrl+a →

d per eseguire lo scollegamento dalla schermata dell'interfaccia a riga di comando FTD Commissioner e tornare al terminale Linux in modo da poter eseguire il flashing della scheda successiva. Per inserire nuovamente l'interfaccia a riga di comando in qualsiasi momento, utilizza screen -r dalla riga di comando. Per visualizzare un elenco delle schermate disponibili, utilizza screen -ls:

$ screen -ls
There is a screen on:
        74182.ttys000.mylinuxmachine        (Detached)
1 Socket in /tmp/uscreens/S-username.

Configura il giunto FTD

Ripeti la procedura descritta sopra per eseguire il flashing della terza scheda nRF52840 utilizzando la build ot-cli-ftd.hex esistente. Dopodiché, assicurati di ricollegare la scheda al PC utilizzando la porta USB nRF e imposta l'opzione della fonte di alimentazione nRF su VDD.

Se gli altri due nodi sono collegati alla macchina Linux quando è collegata questa terza scheda, dovrebbe apparire come porta seriale /dev/ttyACM2:

$ ls /dev/ttyACM*
/dev/ttyACM0  /dev/ttyACM1  /dev/ttyACM2

Etichetta la lavagna "joiner".

Quando esegui la verifica utilizzando Screen, invece di creare una nuova istanza di Screen dalla riga di comando, ricollegala a quella esistente e crea una nuova finestra al suo interno (utilizzata per il commissario FTD):

$ screen -r

Crea la nuova finestra all'interno di Schermo con Ctrl+a → c.

Viene visualizzato un nuovo prompt della riga di comando. Accedi all'interfaccia a riga di comando OpenThread per l'FTD Joiner:

$ screen /dev/ttyACM2 115200

In questa nuova finestra, premi alcune volte sulla tastiera per visualizzare la richiesta dell'interfaccia a riga di comando OpenThread CLI >. Apri l'interfaccia IPv6 e controlla gli indirizzi:

> ifconfig up
Done
> ipaddr
fe80:0:0:0:6c1e:87a2:df05:c240
Done

Ora che l'interfaccia a riga di comando dell'elemento FTD si trova nella stessa istanza dello schermo del commissario FTD, puoi passare da uno all'altro utilizzando Ctrl+a → n.

Utilizza Ctrl+a →

d puoi uscire in qualsiasi momento dalla schermata.

6. Configurazione della finestra del terminale

In futuro dovrai passare spesso da un dispositivo Thread all'altro, quindi assicurati che tutti siano attivi e facilmente accessibili. Finora abbiamo utilizzato la funzionalità Schermo per accedere ai due FTD e questo strumento consente anche di dividere lo schermo nella stessa finestra del terminale. Utilizzalo per vedere come un nodo reagisce ai comandi emessi su un altro.

Idealmente, dovresti avere quattro finestre immediatamente disponibili:

Servizio / log ot-daemon
RCP Joiner tramite ot-ctl
FTD Commissioner tramite l'interfaccia a riga di comando OpenThread
FTD Joiner tramite l'interfaccia a riga di comando OpenThread

Se vuoi utilizzare il tuo terminale / la tua porta seriale o il tuo strumento, vai direttamente al passaggio successivo. Configura le finestre del terminale per tutti i dispositivi nel modo che preferisci.

Uso dello schermo

Per facilitare l'uso, avvia una sola sessione su schermo. Dovresti averne già uno da quando hai configurato i FTD.

Tutti i comandi all'interno dello schermo iniziano con Ctrl+a.

Comandi di base dello schermo:

Ricollega alla sessione di screen (dalla riga di comando)	`screen -r`
Uscire dalla sessione Screen	Ctrl + A → `d`
Crea una nuova finestra nella sessione della schermata	Ctrl + A → `c`
Passare da una finestra all'altra nella stessa sessione della schermata	Ctrl+a → `n` (Avanti) Ctrl+a → `p` (Indietro)
Consente di chiudere la finestra corrente nella sessione della schermata	Ctrl + A → `k`

Schermo diviso

Con Schermo, puoi dividere il terminale in più finestre:

Per accedere ai comandi in screen, utilizza Ctrl + A. Ogni comando deve iniziare con questa combinazione di chiavi di accesso.

Se stai seguendo esattamente il Codelab, dovresti avere due finestre (FTD Commissioner, FTD Joiner) sulla stessa istanza di Screen. Per dividere lo schermo tra i due, devi prima accedere alla sessione di visualizzazione esistente:

$ screen -r

Devi utilizzare uno dei dispositivi FTD. Segui questi passaggi nella schermata:

Ctrl + A → S per dividere la finestra in orizzontale
Ctrl + A → Tab per spostare il cursore nella nuova finestra vuota
Ctrl + A → n per passare alla nuova finestra con quella successiva
Se è uguale alla finestra superiore, premi nuovamente Ctrl + A → n per visualizzare l'altro dispositivo FTD

Ora sono entrambi visibili. Passa dall'uno all'altro usando Ctrl+a → Tab. Ti consigliamo di assegnare un nuovo titolo a ogni finestra con Ctrl+a → A per evitare confusione.

Utilizzo avanzato

Per suddividere ulteriormente lo schermo in quadranti e visualizzare i log di ot-daemon e il joiner RCP ot-ctl, i servizi devono essere avviati all'interno della stessa istanza di screen. A questo scopo, interrompi ot-daemon ed esci da ot-ctl, quindi riavviale all'interno delle nuove finestre dello schermo (Ctrl+a → c).

Questa configurazione non è obbligatoria e viene lasciata all'utente come esercizio.

Dividi e spostati tra le finestre con i seguenti comandi:

Crea nuova finestra	Ctrl + A → `c`
Suddividi finestra in verticale	Ctrl + A →
Dividi finestra orizzontalmente	Ctrl + A → `S`
Passare alla finestra visualizzata successiva	Ctrl + A → `Tab`
Sposta in avanti o indietro la finestra visualizzata	Ctrl+A → `n` o `p`
Rinominare la finestra corrente	Ctrl + A → `A`

Esci da Screen in qualsiasi momento con Ctrl+a → d e ricollegalo con screen -r dalla riga di comando.

Per ulteriori informazioni sullo schermo, consulta la documentazione di riferimento rapido sullo schermo GNU.

7. Crea la rete Thread

Ora che hai configurato tutte le finestre e le schermate del terminale, creiamo la nostra rete Thread. In FTD Commissioner, crea un nuovo set di dati operativo e sottoponilo a commit attivo. Il set di dati operativi è la configurazione per la rete Thread che stai creando.

## FTD Commissioner ##
----------------------

> dataset init new
Done
> dataset
Active Timestamp: 1
Channel: 11
Channel Mask: 07fff800
Ext PAN ID: c0de7ab5c0de7ab5
Mesh Local Prefix: fdc0:de7a:b5c0/64
Network Key: 1234c0de7ab51234c0de7ab51234c0de
Network Name: OpenThread-c0de
PAN ID: 0xc0de
PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4
Security Policy: 0, onrcb
Done

Prendi nota della chiave di rete 1234c0de7ab51234c0de7ab51234c0de, che verrà utilizzata in seguito.

Esegui il commit di questo set di dati come attivo:

> dataset commit active
Done

Visualizza l'interfaccia IPv6:

> ifconfig up
Done

Avvia il funzionamento del protocollo Thread:

> thread start
Done

Dopo qualche istante, controlla lo stato del dispositivo. Deve essere il leader. Scarica anche il RLOC16 per riferimento futuro.

## FTD Commissioner ##
----------------------

> state
leader
Done
> rloc16
0c00
Done

Controlla gli indirizzi IPv6 del dispositivo:

## FTD Commissioner ##
----------------------

> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:fc00        # Leader Anycast Locator (ALOC)
fdc0:de7a:b5c0:0:0:ff:fe00:c00         # Routing Locator (RLOC)
fdc0:de7a:b5c0:0:6394:5a75:a1ad:e5a    # Mesh-Local EID (ML-EID)
fe80:0:0:0:1cd6:87a9:cb9d:4b1d         # Link-Local Address (LLA)

Ora la rete "codelab" è visibile quando viene eseguita la scansione da altri dispositivi Thread.

Da ot-ctl su RCP Joiner:

## RCP Joiner ##
----------------

> scan
| PAN  | MAC Address      | Ch | dBm | LQI |
+------+------------------+----+-----+-----+
| c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |

Dall'interfaccia a riga di comando OpenThread sull'FTD Joiner:

## FTD Joiner ##
----------------

> scan
| PAN  | MAC Address      | Ch | dBm | LQI |
+------+------------------+----+-----+-----+
| c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |

Se la rete "codelab" non viene visualizzata nell'elenco, prova a ripetere la scansione.

8. Aggiungi falegname RCP

La funzionalità Thread Commissioning non è attiva sulla rete, il che significa che dobbiamo aggiungere il joiner RCP alla rete Thread che abbiamo appena creato utilizzando un processo di messa in servizio fuori banda.

Su FTD Commissioner, abbiamo preso nota della chiave di rete, ad esempio 1234c0de7ab51234c0de7ab51234c0de. Se devi cercare di nuovo la chiave di rete, esegui il comando seguente sull'FTD Commissioner:

## FTD Commissioner ##

> dataset networkkey
1234c0de7ab51234c0de7ab51234c0de
Done

Successivamente, sul giunto RCP, imposta la chiave di rete del suo set di dati attivo sulla chiave di rete del commissario FTD:

## RCP Joiner ##
----------------

> dataset networkkey 1234c0de7ab51234c0de7ab51234c0de
Done
> dataset commit active
Done

Controlla il set di dati per assicurarti che sia impostato correttamente.

## RCP Joiner ##
----------------

> dataset
Network Key: 1234c0de7ab51234c0de7ab51234c0de

Visualizza Thread in modo che il joiner RCP si unisca alla rete "codelab". Attendi qualche secondo, controlla lo stato, l'RLOC16 e i relativi indirizzi IPv6:

## RCP Joiner ##
----------------

> ifconfig up
Done
> thread start
Done
> state
child
Done
> rloc16
0c01
Done
> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:0c01         # Routing Locator (RLOC)
fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f    # Mesh-Local EID (ML-EID)
fe80:0:0:0:18e5:29b3:a638:943b          # Link-Local Address (LLA)
Done

Prendi nota dell'indirizzo IPv6 mesh-locale (fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f qui), che utilizzerai più tardi.

Torna a FTD Commissioner e controlla le tabelle di router e figlio per confermare che entrambi i dispositivi facciano parte della stessa rete. Usa RLOC16 per identificare il joiner RCP.

## FTD Commissioner ##
----------------------

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     |
+----+--------+----------+-----------+-------+--------+-----+------------------+
|  3 | 0x0c00 |        3 |         0 |     0 |      0 |  35 | 1ed687a9cb9d4b1d |

Done
> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|VER| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+---+------------------+
|   1 | 0x0c01 |        240 |         25 |     3 |   89 |1|1|1|  2| 1ae529b3a638943b |
Done

Invia un ping all'indirizzo mesh locale del joiner RCP (l'indirizzo mesh locale ottenuto dall'output ipaddr del join RCP) per verificare la connettività:

## FTD Commissioner ##
----------------------

> ping fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f
> 8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=1 hlim=64 time=40ms

Ora abbiamo una rete Thread composta da due nodi, illustrata da questo diagramma di topologia:

Diagrammi di topologia

Mentre proseguirai il resto del codelab, mostreremo un nuovo diagramma di topologia di Thread ogni volta che lo stato della rete cambia. I ruoli dei nodi sono indicati come segue:

I router sono sempre pentagono e i dispositivi finali sono sempre cerchi. I numeri su ciascun nodo rappresentano l'ID router o l'ID figlio visualizzati nell'output dell'interfaccia a riga di comando, a seconda del ruolo e dello stato correnti di ciascun nodo in quel momento.

9. Ingaggia la candidata FTD

Ora aggiungiamo il terzo dispositivo Thread alla rete "codelab". Questa volta utilizzeremo il più sicuro processo di messa in servizio nella banda e consentiremo solo l'adesione a FTD Joiner.

Su FTD Joiner, prendi il eui64, in modo che il FTD Commissioner possa identificarlo:

## FTD Joiner ##
----------------

> eui64
2f57d222545271f1
Done

Su FTD Commissioner, avvia il commissario e specifica il eui64 del dispositivo che può partecipare, insieme alla credenziale di unione, ad esempio J01NME. La credenziale Joiner è una stringa specifica per dispositivo di tutti i caratteri alfanumerici maiuscoli (0-9 e AA, esclusi I, O, Q e Z per la leggibilità), con una lunghezza compresa tra 6 e 32 caratteri.

## FTD Commissioner ##
----------------------

> commissioner start
Done
> commissioner joiner add 2f57d222545271f1 J01NME
Done

Passa a FTD Joiner. Avvia il ruolo Joiner con la credenziale di join che hai appena configurato in FTD Commissioner:

## FTD Joiner ##
----------------

> ifconfig up
Done
> joiner start J01NME
Done

Entro un minuto circa riceverai la conferma dell'autenticazione:

## FTD Joiner ##
----------------

>
Join success

Visualizza Thread in modo che FTD Joiner si unisca alla rete "codelab" e controlla immediatamente lo stato e RLOC16:

## FTD Joiner ##
----------------

> thread start
Done
> state
child
Done
> rloc16
0c02
Done

Controlla gli indirizzi IPv6 del dispositivo. Nota che non esiste un ALOC. Questo perché questo dispositivo non è il leader, né ha un ruolo specifico per Anycast che richiede un ALOC.

## FTD Joiner ##
----------------

> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:c02         # Routing Locator (RLOC)
fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd    # Mesh-Local EID (ML-EID)
fe80:0:0:0:e4cd:d2d9:3249:a243         # Link-Local Address (LLA)

Passa immediatamente a FTD Commissioner e controlla le tabelle di router e figlio per confermare che esistano tre dispositivi nella rete "codelab":

## FTD Commissioner ##
----------------------

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     |
+----+--------+----------+-----------+-------+--------+-----+------------------+
|  3 | 0x0c00 |        3 |         0 |     0 |      0 |  50 | 1ed687a9cb9d4b1d |

> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|N| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+-+------------------+
|   1 | 0x0c01 |        240 |         25 |     3 |   89 |1|1|1|1| 1ae529b3a638943b |
|   2 | 0x0c02 |        240 |         15 |     3 |   44 |1|1|1|1| e6cdd2d93249a243 |
Done

In base a RLOC16, il joiner FTD è collegato alla rete come dispositivo finale (figlio). Ecco la nostra topologia aggiornata:

10. Thread in azione

I dispositivi Thread in questo codelab sono un tipo specifico di dispositivo Full Thread (FTD) chiamato dispositivo idoneo idoneo per il router (REED). Ciò significa che possono funzionare sia come router sia come dispositivo finale e possono promuoversi da un dispositivo finale a un router.

Thread può supportare fino a 32 router, ma tenta di mantenere il numero di router tra 16 e 23. Se un REED si collega come dispositivo finale (secondario) e il numero di router è inferiore a 16, dopo un periodo di tempo casuale entro due minuti si promuove automaticamente a un router.

Se nella tua rete Thread erano presenti due figli dopo aver aggiunto il joiner FTD, attendi almeno due minuti, quindi ricontrolla il router e le tabelle figlio su FTD Commissioner:

## FTD Commissioner ##
----------------------

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     |
+----+--------+----------+-----------+-------+--------+-----+------------------+
|  3 | 0x0c00 |        3 |         0 |     0 |      0 |  50 | 1ed687a9cb9d4b1d |
| 46 | 0xb800 |       63 |         0 |     3 |      3 |   1 | e6cdd2d93249a243 |

> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|N| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+-+------------------+
|   1 | 0x0c01 |        240 |         61 |     3 |   89 |1|1|1|1| 1ae529b3a638943b |
Done

Il FTD Joiner (MAC esteso = e6cdd2d93249a243) si è promosso a un router. Tieni presente che RLOC16 è diverso (b800 anziché 0c02). Questo perché l'RLOC16 è basato sull'ID router e sull'ID figlio di un dispositivo. Durante la transizione dal dispositivo finale al router, i valori dell'ID router e dell'ID figlio cambiano, così come il valore RLOC16.

Conferma il nuovo stato e RLOC16 su FTD Joiner:

## FTD Joiner ##
----------------

> state
router
Done
> rloc16
b800
Done

Esegui il downgrade di FTD Joiner

Puoi testare questo comportamento eseguendo il downgrade manuale del giunto da FTD da un router a un dispositivo finale. Cambia lo stato in secondario e controlla RLOC16:

## FTD Joiner ##
----------------

> state child
Done
> rloc16
0c03
Done

Quando torni sul FTD Commissioner, il membro FTD Joiner dovrebbe essere visualizzato nella tabella figlio (ID = 3). Potrebbe trattarsi anche di entrambi durante la transizione:

## FTD Commissioner ##
----------------------

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     |
+----+--------+----------+-----------+-------+--------+-----+------------------+
|  3 | 0x0c00 |        3 |         0 |     0 |      0 |  50 | 1ed687a9cb9d4b1d |
| 46 | 0xb800 |       63 |         0 |     3 |      3 |   1 | e6cdd2d93249a243 |

> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|N| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+-+------------------+
|   1 | 0x0c01 |        240 |         61 |     3 |   89 |1|1|1|1| 1ae529b3a638943b |
|   3 | 0x0c03 |        240 |         16 |     3 |   94 |1|1|1|1| e6cdd2d93249a243 |
Done

Trascorso un po' di tempo, tornerà a un router con un RLOC pari a b800.

Rimuovi il leader

Il leader è eletto in autonomia tra tutti i router Thread. Questo significa che se l'attuale leader viene rimosso dalla rete Thread, uno degli altri router diventerà il nuovo leader.

Su FTD Commissioner, disattiva Thread per rimuoverlo dalla rete Thread:

## FTD Commissioner ##
----------------------

> thread stop
Done
> ifconfig down
Done

In due minuti, FTD Joiner diventa il nuovo leader di Thread. Controlla lo stato e gli indirizzi IPv6 del join FTD per verificare:

## FTD Joiner ##
----------------

> state
leader
Done
> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:fc00       # Now it has the Leader ALOC!
fdc0:de7a:b5c0:0:0:ff:fe00:b800
fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd
fe80:0:0:0:e4cd:d2d9:3249:a243
Done

Controlla la tabella figlio. C'è una nuova RLOC16. Questo è il joiner RCP, come indicato dal suo ID e dal MAC esteso. Per mantenere la rete Thread insieme, ha cambiato i router principali, dal FTD Commissioner al FTD Joiner. Ne risulta un nuovo RLOC16 per il joiner RCP (perché il suo ID router è cambiato, da 3 a 46).

## FTD Joiner ##
----------------

> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|N| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+-+------------------+
|   1 | 0xb801 |        240 |         27 |     3 |  145 |1|1|1|1| 1ae529b3a638943b |
Done

Potrebbe essere necessario attendere alcuni minuti prima che il Connettore RCP si colleghi al giunto FTD come bambino. Controlla lo stato e l'RLOC16 per confermare che:

## RCP Joiner ##
--------------

> state
child
> rloc16
b801

Riallega l'FTD Commissioner

Una rete Thread con due nodi non è molto divertente. Riporta online il FTD Commissioner.

Su FTD Commissioner, riavvia Thread:

## FTD Commissioner ##
----------------------

> ifconfig up
Done
> thread start
Done

Entro due minuti, si ricollega automaticamente alla rete "codelab" come dispositivo finale, per poi promuoversi a un router.

## FTD Commissioner ##
----------------------

> state
router
Done

Controlla il router e le tabelle figlio in FTD Joiner per verificare:

## FTD Joiner ##
----------------

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     |
+----+--------+----------+-----------+-------+--------+-----+------------------+
|  3 | 0x0c00 |       63 |         0 |     3 |      3 |   0 | 1ed687a9cb9d4b1d |
| 46 | 0xb800 |       46 |         0 |     0 |      0 |  15 | e6cdd2d93249a243 |

> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|N| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+-+------------------+
|   1 | 0xb801 |        240 |        184 |     3 |  145 |1|1|1|1| 1ae529b3a638943b |
Done

La nostra rete Thread è composta di nuovo di tre nodi.

11. Risoluzione dei problemi

Gestire una rete Thread con più dispositivi su terminali o finestre con schermate diverse può essere complicato. Segui questi suggerimenti per "reimpostare" lo stato della rete o dell'area di lavoro in caso di problemi.

Schermo

Se ti capita di perdere la configurazione (troppe finestre dello schermo o schermate all'interno dello schermo), continua a terminare le finestre con CTRL+A → K finché non ne esiste nessuna e screen -ls nella riga di comando restituisce No Sockets found. Quindi ricrea le finestre di schermata per ogni dispositivo. Gli stati del dispositivo vengono conservati anche in caso di arresto dello schermo.

Nodi thread

Se la topologia di rete Thread non è come descritto in questo codelab o i nodi si disconnettono per qualche motivo (forse perché la macchina Linux che li ha attivati in modalità di sospensione), è meglio rimuovere Thread, cancellare le credenziali di rete e ricominciare dal passaggio Crea la rete Thread.

Per reimpostare le FTD:

## FTD Commissioner or FTD Joiner ##
------------------------------------

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

Il RCP può essere reimpostato allo stesso modo tramite ot-ctl:

## RCP Joiner ##
----------------

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

12. Utilizzare la tecnologia multicast

Il multicast viene utilizzato per comunicare informazioni a un gruppo di dispositivi contemporaneamente. In una rete Thread, indirizzi specifici sono riservati per l'utilizzo multicast con diversi gruppi di dispositivi, a seconda dell'ambito.

Indirizzo IPv6	Ambito	Consegnato a
`ff02::1`	Link locale	Tutti i FTD e gli MED
`ff02::2`	Link locale	Tutti i FTD e i router di confine
`ff03::1`	Mesh locale	Tutti i FTD e gli MED
`ff03::2`	Mesh locale	Tutti i FTD e i router di confine

Poiché in questo codelab non utilizziamo un router di confine, concentriamoci sui due indirizzi multicast FTD e MED.

Link locale

L'ambito Link-Local comprende tutte le interfacce Thread raggiungibili con un'unica trasmissione radio o un singolo "hop". La topologia di rete determina quali dispositivi rispondono a un ping all'indirizzo multicast ff02::1.

Invia un ping a ff02::1 da FTD Commissioner:

## FTD Commissioner ##
----------------------

> ping ff02::1
> 8 bytes from fe80:0:0:0:e4cd:d2d9:3249:a243: icmp_seq=2 hlim=64 time=9ms

Esistono altri due dispositivi nella rete (FTD Joiner e RCP Joiner), ma l'FTD Commissioner ha ricevuto una sola risposta dall'FTD Joiner's Link-Local Address (LLA). Ciò significa che FTD Joiner è l'unico dispositivo che l'FTD Commissioner può raggiungere con un singolo hop.

Ora invia un ping a ff02::1 da FTD Joiner:

## FTD Joiner ##
----------------

> ping ff02::1
> 8 bytes from fe80:0:0:0:1cd6:87a9:cb9d:4b1d: icmp_seq=1 hlim=64 time=11ms
8 bytes from fe80:0:0:0:18e5:29b3:a638:943b: icmp_seq=1 hlim=64 time=24ms

Due risposte. Controllando gli indirizzi IPv6 per gli altri dispositivi, possiamo vedere che il primo (che termina con 4b1d) è l'LLA del commissario FTD, mentre il secondo (che termina con 943b) è l'LLA del fascicolo RCP.

Ciò significa che il joiner FTD è direttamente collegato sia al commissario FTD che al giunto RCP, a conferma della nostra topologia.

Mesh locale

L'ambito mesh locale comprende tutte le interfacce Thread raggiungibili all'interno della stessa rete Thread. Vediamo le risposte a un ping all'indirizzo multicast ff03::1.

Invia un ping a ff03::1 da FTD Commissioner:

## FTD Commissioner ##
----------------------

> ping ff03::1
> 8 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:b800: icmp_seq=3 hlim=64 time=9ms
8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=3 hlim=64 time=68ms

Questa volta il commissario FTD ha ricevuto due risposte, una dal localizzatore di routing del falegname FTD (RLOC, che termina con b800) e uno dall'EID locale del mesh RCP (ML-EID) che termina con d55f. Questo perché l'ambito locale della rete mesh comprende l'intera rete Thread. Indipendentemente da dove si trovi un dispositivo nella rete, il servizio verrà sottoscritto all'indirizzo ff03::1.

Invia un ping a ff03::1 da FTD Joiner per confermare lo stesso comportamento:

## FTD Joiner ##
----------------

> ping ff03::1
> 8 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00: icmp_seq=2 hlim=64 time=11ms
8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=2 hlim=64 time=23ms

Tieni presente il tempo di risposta per il joiner RCP in entrambi gli output ping. L'RCP Joiner ha impiegato molto più tempo per raggiungere il FTD Commissioner (68 ms) rispetto a quello dell'FTD Joiner (23 ms). Questo perché deve fare due hop per raggiungere il commissario FTD, rispetto a un hop per la falegnameria FTD.

Forse avrai notato che il ping multicast mesh-local ha risposto con il RLOC solo per i due FTD, non per l'RCP Joiner. Questo perché gli FTD sono router all'interno della rete, mentre l'RCP è un dispositivo finale.

Controlla lo stato del joiner RCP per confermare:

## RCP Joiner ##
----------------

> state
child

13. Inviare messaggi con UDP

Uno dei servizi per le applicazioni forniti da OpenThread è User Datagram Protocol (UDP), un protocollo Transport Layer. Un'applicazione creata su OpenThread potrebbe utilizzare l'API UDP per passare messaggi tra nodi in una rete Thread o altri dispositivi in una rete esterna (come Internet, se la rete Thread dispone di un router di confine).

I socket UDP sono esposti tramite l'interfaccia a riga di comando OpenThread. Utilizziamolo per passare messaggi tra i due FTD.

Ottieni l'indirizzo EID mesh locale per il joint FTD. Stiamo usando questo indirizzo perché è raggiungibile da qualsiasi punto della rete Thread.

## FTD Joiner ##
----------------

> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:fc00        # Leader Anycast Locator (ALOC)
fdc0:de7a:b5c0:0:0:ff:fe00:b800        # Routing Locator (RLOC)
fe80:0:0:0:e4cd:d2d9:3249:a243         # Link-Local Address (LLA)
fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd    # Mesh-Local EID (ML-EID)
Done

Avvia UDP e associalo a un socket per qualsiasi indirizzo IPv6:

## FTD Joiner ##
----------------

> udp open
Done
> udp bind :: 1212

Passa a FTD Commissioner (Avviatore FTD), avvia UDP e connettiti al socket che hai configurato per il giunto FTD, utilizzando il relativo ML-EID:

## FTD Commissioner ##
----------------------

> udp open
Done
> udp connect fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd 1212
Done

La connessione UDP deve essere attiva tra i due nodi. Invia un messaggio dal commissario FTD:

## FTD Commissioner ##
----------------------

> udp send hellothere
Done

Su FTD Joiner è stato ricevuto il messaggio UDP.

## FTD Joiner ##
----------------

> 10 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00 49153 hellothere

14. Complimenti.

Hai creato una rete Thread fisica.

Ora sai:

la differenza tra i tipi di dispositivi, i ruoli e gli ambiti Thread
in che modo i dispositivi Thread gestiscono i propri stati all'interno della rete
come passare messaggi semplici tra nodi utilizzando UDP

Passaggi successivi

Partendo da questo codelab, prova i seguenti esercizi:

Esegui di nuovo il flashing della scheda Joint FTD come MTD utilizzando il programma binario ot-cli-mtd e osserva che non si aggiorna mai a un router o tenta di diventare il leader
Aggiungi altri dispositivi (prova una piattaforma diversa) alla rete e definisci la topologia utilizzando tabelle di router e secondarie, oltre a ping agli indirizzi multicast
Utilizza pyspinel per controllare l'NCP
Converti l'NCP in un router di confine utilizzando il router di confine Thread e connetti la rete Thread a Internet

Per approfondire

Dai un'occhiata a openthread.io e GitHub per una varietà di risorse di OpenThread, tra cui:

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

Riferimento: