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 rete Thread®. Google Nest ha rilasciato OpenThread per rendere la tecnologia utilizzata nei prodotti Nest ampiamente disponibile agli sviluppatori per accelerare lo sviluppo dei prodotti per la casa connessa.

La specifica Thread definisce un protocollo di comunicazione da dispositivo a dispositivo affidabile, sicuro e a basso consumo basato su IPv6 per le applicazioni per la casa. 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, devi programmare OpenThread su hardware reale, creare e gestire una rete Thread e trasmettere messaggi tra nodi.

Cosa scoprirai

Creazione di file binari dell'interfaccia a riga di comando OpenThread e lampeggianti nelle dev board
Creazione di un RCP composto da una macchina Linux e una scheda di sviluppo
Comunicazione con un RCP tramite OpenThread Daemon e ot-ctl
Gestione manuale dei nodi Thread con la schermata GNU e l'interfaccia a riga di comando OpenThread
Messa in servizio sicura dei dispositivi su una rete Thread
Come funziona il multicast IPv6
Passaggio di messaggi tra nodi Thread con UDP

Che cosa ti serve

Hardware:

3 schede per sviluppatori nRF52840 Nordic Semiconductor
3 cavi da USB a micro USB per il collegamento di schede
Una macchina Linux con almeno 3 porte USB

Software:

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

2. Guida introduttiva

Simulazione OpenThread

Prima di iniziare, ti consigliamo di eseguire il Codelab sulla simulazione di OpenThread per acquisire familiarità con i concetti di base dei thread e con l'interfaccia a riga di comando di OpenThread.

Terminali per porte seriali

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 del terminale.

macchina Linux

Questo codelab è stato progettato per utilizzare una macchina Linux basata su i386 o x86 come host per un dispositivo Thread di 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 nRF52840 PDK.

Installare SEGGER J-Link

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

Scarica il pacchetto appropriato per la tua macchina e installalo nella posizione corretta. Su Linux, il nome è /opt/SEGGER/JLink.

Installa gli strumenti a riga di comando nRF5x

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

Inserisci il pacchetto estratto nella cartella principale ~/

Installa Acha GNU Toolchain

La toolchain GNU ARM viene utilizzata per la costruzione.

Ti consigliamo di collocare l'archivio estratto in /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ sulla tua macchina Linux. Per istruzioni di installazione, segui le istruzioni riportate nel file readme.txt dell'archivio.

Schermata di installazione (facoltativa)

Lo schermo consente di accedere facilmente ai dispositivi connessi tramite una porta seriale. Questo Codelab utilizza Screen, ma puoi utilizzare qualsiasi applicazione terminale seriale della porta.

$ sudo apt-get install screen

3. Clona repository

OpenThread

Clonare e installare 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 puoi creare e implementare Flash Thread sulle schede nRF52840.

4. Configura il joiner RCP

Creazione e flash

Crea l'esempio OpenThread, nRF52840, con Joiner e la funzionalità USB nativa. Un dispositivo usa il ruolo Joiner per essere autenticato e messo in servizio in modo sicuro su una rete Thread. La tecnologia USB nativa consente l'utilizzo di CDC USB ACM come trasporto seriale tra nRF52840 e l'host.

Esegui sempre prima il 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

Passa alla directory con il programma binario OpenCP RCP 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 della scheda nRF52840, quindi collegalo alla macchina Linux. Imposta l'opzione Fonte di alimentazione nRF sulla scheda nRF52840 su VDD. Quando è collegato correttamente, LED5 è attivo.

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

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

Vai alla posizione degli strumenti a riga di comando nRFx e invia il file esadecimale OpenThread RCP sulla scheda nRF52840, utilizzando il numero di serie della scheda. Tieni presente che, se lasci il flag --verify, viene visualizzato un messaggio di avviso per informarti che il processo Flash potrebbe non riuscire senza errori.

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

Il seguente output viene generato correttamente.

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.

Contrassegna la scheda "RCP" in modo da non confondere i ruoli del consiglio.

Connettiti a USB nativa

Poiché la build OpenThread RCP consente l'utilizzo di ACM CDC USB nativo come trasporto seriale, devi utilizzare la porta nRF USB sulla scheda nRF52840 per comunicare con l'host RCP (Linux 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 Fonte di alimentazione nRF su USB.

Avvia il daemon OpenThread

Nella progettazione RCP, utilizza il daemon OpenThread per comunicare con il dispositivo Thread e gestirlo. Avvia 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
$ ./build/posix/src/posix/ot-daemon -v \
    'spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=115200'

In caso di esito positivo, ot-daemon in modalità dettagliata genera output simili ai seguenti:

ot-daemon[228024]: Running OPENTHREAD/20191113-00831-gfb399104; POSIX; Jun  7 2020 18:05:15
ot-daemon[228024]: Thread version: 2
ot-daemon[228024]: RCP version: OPENTHREAD/20191113-00831-gfb399104; SIMULATION; Jun  7 2020 18:06:08

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 la stessa interfaccia a riga di comando dell'app interfaccia a riga di comando OpenThread. Pertanto, puoi controllare ot-daemon nodi allo stesso modo degli altri dispositivi Thread simulati.

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

$ ./build/posix/bin/ot-ctl
>

Controlla il state del nodo 2 (nodo RCP) che hai iniziato con ot-daemon:

> state
disabled
Done

5. Configurare i piani FTD

Gli altri due nodi Thread usati in questo codelab sono Full Thread Devices (FTD) con il design standard System-on-Chip (SoC). In un'impostazione di produzione, potresti utilizzare wpantund, un driver dell'interfaccia di rete di produzione, per controllare le istanze NCP OpenThread, ma in questo codelab utilizzeremo ot-ctl, OpenThread. Interfaccia a riga di comando.

Un dispositivo funge da commissario per autenticare e mettere in sicurezza i dispositivi su quella rete. L'altro dispositivo funge da joiner che il Commissioner può autenticare sulla rete Thread.

Creazione e flash

Creare l'esempio FTD OpenThread 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 file binario dell'interfaccia a riga di comando Full Thread (FTD) di OpenThread 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 della scheda nRF52840, quindi collegalo alla macchina Linux. Se l'RCP è ancora collegato alla macchina Linux, questa nuova scheda dovrebbe apparire come porta seriale /dev/ttyACM1 (tutte le schede nRF52840 usano ttyACM per l'identificatore della porta seriale).

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

Come in precedenza, prendi nota del numero di serie della scheda nRF52840 utilizzata per l'FTD:

Passa alla posizione degli strumenti a riga di comando nRFx e invia il file esadecimale OpenThread CLI FTD 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

Contrassegna il consiglio "Commissario".

Connettiti a USB nativa

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

Verifica build

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

$ screen /dev/ttyACM1 115200

Nella nuova finestra, premi Invio un paio di volte sulla tastiera per far apparire il prompt dell'interfaccia a riga di comando di OpenThread >. Visualizza l'interfaccia IPv6 e controlla gli indirizzi:

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

Ctrl+a→ →

d per disconnetterti dall'interfaccia a riga di comando del FTD Commissioner e torna al terminale Linux in modo che la scheda successiva possa lampeggiare. Per inserire di nuovo 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.

Configurare FTD Joiner

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

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

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

Contrassegna la lavagna come "Joiner".

Durante la verifica utilizzando Screen, invece di creare una nuova istanza di Screen dalla riga di comando, ricollegala a quella esistente ed esegui una nuova finestra al suo interno (utilizzata per FTD Commissioner):

$ screen -r

Crea la nuova finestra in Schermo con Ctrl+a → c.

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

$ screen /dev/ttyACM2 115200

In questa nuova finestra, premi alcune volte il tasto Invio sulla tastiera per visualizzare il prompt dell'interfaccia a riga di comando di OpenThread >. Visualizza 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 FTD è nella stessa istanza di Screener, puoi passare da un'interfaccia all'altra utilizzando Ctrl+a → n.

Ctrl+a→ →

d in qualsiasi momento per uscire dalla schermata.

6. Configurazione della finestra del terminale

In futuro, dovrai passare spesso da un dispositivo Thread a un altro, quindi assicurati che tutti i dispositivi siano attivi e facilmente accessibili. Finora abbiamo utilizzato Screen per accedere ai due funzioni FTD e questo strumento consente anche lo schermo diviso nella stessa finestra del terminale. Usa questa funzionalità per vedere la reazione di un nodo ai comandi emessi su un altro.

L'ideale è avere a disposizione quattro finestre:

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

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

Utilizzo dello schermo

Per facilitare l'utilizzo, avvia una sola sessione di schermo. Dovresti già averne già uno quando configuri entrambi i FTD.

Tutti i comandi all'interno della schermata iniziano con Ctrl+a.

Comandi di base dello schermo:

Ricollega alla sessione Screen (dalla riga di comando)	`screen -r`
Uscire dalla sessione dello schermo	Ctrl + A → `d`
Crea nuova finestra nella sessione Schermo	Ctrl + A → `c`
Passare da una finestra all'altra nella stessa sessione dello schermo	Ctrl + A → `n` (avanti) Ctrl + A → `p` (Indietro)
Termina la finestra corrente nella sessione Schermata	Ctrl + A → `k`

Schermo diviso

Con Schermo puoi suddividere il terminale in più finestre:

Puoi accedere ai comandi in screen utilizzando Ctrl + A. Ogni comando deve iniziare con questa combinazione di chiavi di accesso.

Se hai seguito esattamente il codelab, dovresti avere due finestre (FTD Commissioner, FTD Joiner) sulla stessa istanza di Screen. Per suddividere lo schermo tra i due, inserisci innanzitutto la sessione schermo esistente:

$ screen -r

Dovresti usare uno dei dispositivi registrati da FTD. Segui questi passaggi nella schermata:

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

Ora sono entrambe visibili. Passa da un tasto all'altro usando Ctrl + un tasto → Tab. Ti consigliamo di rinominare ciascuna finestra con Ctrl+a → A per evitare confusione.

Utilizzo avanzato

Per suddividere ulteriormente lo schermo in quadranti e visualizzare i log ot-daemon e RCP Joiner ot-ctl, tali servizi devono essere avviati nella stessa istanza Screen. Per farlo, interrompi ot-daemon e esci da ot-ctl e riavvialo nelle nuove finestre dello schermo (CTRL+A → c).

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

Dividi e naviga tra le finestre con i seguenti comandi:

Crea nuova finestra	Ctrl + A → `c`
Suddividi finestra in verticale	Ctrl + A →
Suddividi la finestra in orizzontale	Ctrl + A → `S`
Andare alla finestra successiva visualizzata	Ctrl + A → `Tab`
Spostare la finestra visualizzata in avanti o indietro	Ctrl + A → `n` o `p`
Rinominare la finestra corrente	Ctrl + A → `A`

Puoi uscire dalla schermata in qualsiasi momento premendo Ctrl+a → d e ricollegarla con screen -r dalla riga di comando.

Per ulteriori informazioni sullo schermo, consulta la guida rapida per lo schermo GNU.

7. Creare la rete Thread

Ora che tutte le finestre e le schermate del terminale sono configurate, passiamo alla creazione della rete Thread. In FTD Commissioner, crea un nuovo set di dati operativo e impostalo come attivo. Il set di dati operativo è la configurazione della 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 operazione di protocollo Thread:

> thread start
Done

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

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

> state
leader
Done
> rloc16
0c00
Done

Verifica 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)

La rete "codelab" è ora visibile quando viene scansionata da altri dispositivi Thread.

Da ot-ctl nel Joiner BGP:

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

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |

Nell'interfaccia a riga di comando di OpenThread su FTD Joiner:

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

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |

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

Potresti notare che in entrambe le scansioni la rete sembra non essere join (colonna J sul joiner RCP e sul joiner FTD). Questo significa che la messa in servizio di Thread non è attiva sulla rete. Può comunque essere unito fuori banda inserendo la chiave di rete nel dispositivo di unione manualmente.

8. Aggiungi il joiner RCP

Aggiungiamo il joiner RCP alla rete Thread che abbiamo appena creato, utilizzando un processo fuori banda. Cerca reti sul Joiner RCP:

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

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |

Per partecipare, imposta la chiave di rete (che abbiamo appena ricevuto dal commissario FTD) sul joiner RCP nel suo set di dati attivo.

## 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

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

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

> 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-local (qui fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f), che utilizzerai in seguito.

Torna a FTD Commissioner (Controlla FTD), controlla le tabelle del router e dei provider secondari per assicurarti che entrambi i dispositivi facciano parte della stessa rete. Utilizza 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-local del join RCP (l'indirizzo Mesh-Local 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 lavori nel resto del codelab, ti mostreremo un nuovo diagramma della topologia dei thread ogni volta che lo stato della rete cambia. I ruoli dei nodi sono indicati come segue:

I router sono sempre pentagoni 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. Commissione del programma FTD

Ora aggiungiamo il terzo dispositivo Thread alla rete "codelab". Questa volta useremo la procedura di messa in servizio in banda più sicura. Nell'FTD Joiner, cerca la rete:

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

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | f65ae2853ff0c4e4 | 11 | -36 |  57 |

Una colonna 0 nella colonna J indica che la messa in servizio di Thread non è attiva sul dispositivo.

Per essere più precisi, quando esegui la messa in servizio su questo dispositivo, consenti solo a FTD Joiner di partecipare. Sempre in collaborazione con l'FTD, prendi il comando eui64 per consentire all'FTD Commissioner di identificarlo:

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

> eui64
2f57d222545271f1
Done

In FTD Commissioner (Commissario FTD), avvia il Commissioner e specifica il valore eui64 del dispositivo che può partecipare, oltre all'estensione Joiner Credential, ad esempio J01NME. Joiner Credential è una stringa specifica per dispositivo di tutti i caratteri alfanumerici maiuscoli (0-9 e AY, 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 e ripeti la scansione:

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

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 1 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -45 | 196 |

Come indicato da 1 nella colonna J, la messa in servizio di Thread è ora attiva sulla rete. Avvia il ruolo di membro della riunione con le credenziali del membro che hai appena configurato nel FTD Commissioner:

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

> ifconfig up
Done
> joiner start J01NME
Done

Entro circa un minuto, riceverai una conferma di autenticazione riuscita:

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

>
Join success

Attiva Thread in modo che il joiner FTD si unisca alla rete "codelab", quindi controlli immediatamente lo stato e RLOC16:

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

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

Verifica gli indirizzi IPv6 del dispositivo. Nota che non esiste alcun ALOC. Questo perché il dispositivo non è leader e non ha alcun ruolo specifico di Anycast che richiede 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 al FTD Commissioner e controlla le tabelle di router e figlio per verificare 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, FTD Joiner è collegato alla rete come dispositivo finale (secondario). Ecco la nostra topologia aggiornata:

10 Thread in azione

I dispositivi Thread in questo codelab sono un tipo specifico di dispositivo FTD (Full Thread Device), chiamato dispositivo finale idoneo del router (REED). Ciò significa che possono funzionare come router o 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 dopo laaggiunta di FTD Joiner erano presenti due bambini in rete Thread, attendi almeno due minuti e quindi controlla di nuovo il router e le tabelle figlio in 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

FTD Joiner (Extended MAC = e6cdd2d93249a243) si è promosso a router. Tieni presente che RLOC16 è diverso da b800 (anziché 0c02). Questo perché RLOC16 si basa sull'ID router e sull'ID secondario di un dispositivo. Quando passa dal dispositivo finale al router, i relativi valori ID router e ID secondario cambiano, così come lo cambia RLOC16.

Conferma il nuovo stato e il codice RLOC16 in FTD Joiner:

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

> state
router
Done
> rloc16
b800
Done

Eseguire il downgrade del Joiner FTD

Puoi testare questo comportamento eseguendo il downgrade manuale del FTD Joiner da un router a un dispositivo finale. Modifica lo stato in figlio e controlla il codice RLOC16:

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

> state child
Done
> rloc16
0c03
Done

Di nuovo nel FTD Commissioner, il Joiner FTD dovrebbe apparire nella tabella secondaria (ID = 3). Potrebbe anche trovarsi in entrambe 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

Dopo qualche tempo, passerà a un router con un RLOC di b800.

Rimuovi il leader

Il Leader è autoeletto tra tutti i router dei thread. Ciò significa che se l'attuale leader viene rimosso dalla rete Thread, uno degli altri router diventerà il nuovo leader.

In FTD Commissioner, chiudi Thread per rimuoverlo dalla rete Thread:

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

> thread stop
Done
> ifconfig down
Done

Entro due minuti, FTD Joiner diventa il nuovo leader di Thread. Controlla lo stato e gli indirizzi IPv6 dell'FTD Joiner 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 secondaria. Nota che è disponibile un nuovo RLOC16. Questo è il joiner RCP, come indicato dal relativo ID e dal MAC esteso. Per mantenere unita la rete Thread, ha cambiato i router principali, dal FTD Commissioner all'FTD Joiner. Ciò genera 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

Potresti dover attendere qualche minuto perché l'Joiner Joint si connetta al FTD Joiner come bambino. Controlla lo stato e la RLOC16 per confermare che:

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

> state
child
> rloc16
b801

Ricollega il FTD Commissioner

Una rete Thread con due nodi non è molto divertente. Torniamo online al FTD Commissioner.

In 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 su un router.

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

> state
router
Done

Controlla il router e le tabelle figlio nel 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 è di nuovo composta da tre nodi.

11 Risolvere i problemi

Gestire una rete Thread con più dispositivi su diversi terminali o finestre di schermate può essere complicato. Utilizza 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 di schermo o schermate sullo schermo), continua a terminare le finestre di schermo con la combinazione di tasti Ctrl+a → k finché non ne esiste nessuna e screen -ls negli output della riga di comando No Sockets found. Dopodiché ricrea le finestre dello schermo per ogni dispositivo. Gli stati dei dispositivi vengono mantenuti anche quando lo schermo viene interrotto.

Nodi thread

Se la topologia della rete Thread non è come descritto in questo codelab o se i nodi si disconnettono per qualche motivo (forse perché la macchina Linux che li alimenta attiva la sospensione), è meglio spegnere Thread, cancellare le credenziali di rete e ricominciare da Crea il passaggio Rete Thread.

Per reimpostare i FTD, procedi nel seguente modo:

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

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

L'RCP può essere reimpostato nello stesso modo tramite ot-ctl:

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

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

12 Utilizzo del multicast

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

Indirizzo IPv6	Ambito	Recapitato a
`ff02::1`	Link locale	Tutti i FTD e i MED
`ff02::2`	Link locale	Tutti i router e i router di confine
`ff03::1`	Rete locale	Tutti i FTD e i MED
`ff03::2`	Rete locale	Tutti i router 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 include tutte le interfacce Thread raggiungibili tramite una singola trasmissione radio o un singolo "hop". La topologia di rete determina quali dispositivi rispondono a un ping all'indirizzo multicast di ff02::1.

Invia un ping a ff02::1 dal 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 il FTD Commissioner ha ricevuto una sola risposta dall'FTD Joiner's Link-Local Address (LLA). Ciò significa che il programma FTD Joiner è l'unico dispositivo che il FTD Commissioner può raggiungere con un singolo hop.

Ora invia un ping a ff02::1 dall'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 notare che il primo (che termina con 4b1d) è l'LLA del Commissioner FTD, mentre il secondo (che termina con 943b) è l'LLA del Joiner RCP.

Ciò significa che il programma FTD Joiner è direttamente collegato sia al FTD Commissioner sia al RCP Joiner, a conferma della nostra topologia.

Rete locale

L'ambito mesh-local include tutte le interfacce Thread accessibili all'interno della stessa rete Thread. Vediamo le risposte a un ping all'indirizzo multicast di ff03::1.

Invia un ping a ff03::1 dal 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 l'FTD Commissioner ha ricevuto due risposte, una dal FTD Joiner's Routing Locator (RLOC, che termina con b800) e una dall'RCP Joiner's Mesh-Local EID (ML-EID, che termina con d55f). Questo perché l'ambito mesh locale comprende l'intera rete Thread. A prescindere dalla rete in cui si trova il dispositivo, l'abbonamento verrà applicato alla reteff03::1 indirizzo email.

Invia un ping a ff03::1 dal 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

Prendi nota del tempo di risposta per il Joiner RCP in entrambi gli output del ping. L'Joiner Joint per FTD ha impiegato molto più tempo per raggiungere il FTD Commissioner (68 ms) rispetto a quello per raggiungere il FTD Joiner (23 ms). Questo perché deve effettuare due hop per raggiungere il FTD Commissioner rispetto a un hop per l'FTD Joiner.

Potresti anche aver notato che il ping multicast mesh locale ha risposto con il RLOC solo per i due FTD, non per il Joiner RCP. Questo perché i FTD sono router all'interno della rete, mentre gli RCP sono un dispositivo finale.

Controlla lo stato del Joiner RCP per confermare:

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

> state
child

13. Inviare messaggi con UDP

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

I socket UDP vengono esposti tramite l'interfaccia a riga di comando OpenThread. Usalo per trasmettere messaggi tra i due FTD.

Recupera l'indirizzo EID mesh-local per il FTD Joiner. 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, avvia UDP e connettiti al socket configurato su FTD Joiner, 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 FTD Commissioner:

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

> udp send hellothere
Done

Nel FTD Joiner, il messaggio UDP è stato ricevuto.

## 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 tipi di dispositivi, ruoli e ambiti di Thread
in che modo i dispositivi Thread gestiscono i propri stati all'interno della rete
come trasmettere messaggi semplici tra nodi utilizzando UDP

Passaggi successivi

Partendo da questo codelab, prova i seguenti esercizi:

Esegui nuovamente il flashing della scheda Joiner FTD come MTD utilizzando il programma binario ot-cli-mtd e osserva che non esegue mai l'upgrade a un router o tenta di diventare il leader.
Aggiungi altri dispositivi (prova una piattaforma diversa) alla rete e disegna la topologia utilizzando il router e le tabelle figlio, oltre ai ping agli indirizzi multicast
Utilizza pyspinel per controllare il NCP
Converti il router NCP in un router di confine utilizzando il router di confine OpenThread e connetti la rete di Thread a Internet

Per approfondire

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

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

Riferimento: