Creare una rete Thread con schede nRF52840 e OpenThread

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

1. Introduzione

26b7f4f6b3ea0700.png

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

La specifica Thread definisce un protocollo di comunicazione wireless tra dispositivi affidabile, sicuro e a basso consumo per IPv6. OpenThread implementa tutti i livelli di rete Thread, inclusi IPv6, 6LoWPAN, IEEE 802.15.4 con sicurezza MAC, Mesh Link Establishment e Mesh Routing.

In questo codelab, programmi OpenThread su hardware reale, crei e gestisci una rete Thread e trasmetti messaggi tra nodi.

4806d16a8c137c6d.jpeg

Obiettivi didattici

  • Creazione e deployment di programmi binari dell'interfaccia a riga di comando di OpenThread nelle bacheche
  • Creazione di un RCP costituito da una macchina Linux e da un pannello di sviluppo
  • Comunicazione con un RCP mediante Daemon OpenThread e ot-ctl
  • Gestione manuale dei nodi Thread con GNU Screen e l'interfaccia a riga di comando OpenThread
  • Messa in sicurezza 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 di sviluppo Nordic Semiconductor nRF52840
  • 3 cavi da USB a micro USB per collegare le schede
  • Una macchina Linux con almeno 3 porte USB

Software:

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

2. Per cominciare

Simulazione OpenThread

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

Terminali della porta seriale

Dovresti sapere come connetterti a una porta seriale tramite un terminale. Questo codelab utilizza GNU Screen e fornisce una panoramica dell'utilizzo, ma può essere utilizzato 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).

Lavagne Nordic Semiconductor nRF52840

Questo codelab utilizza tre schede nRF52840 PDK.

a6693da3ce213856.png

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 computer e installalo nella posizione corretta. 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 di OpenThread sulle schede nRF52840. Installa la build nRF5x-Command-Line-Tools-<OS> appropriata sulla tua macchina Linux.

Inserisci il pacchetto estratto nella cartella principale ~/

Installazione di ARM GNU Toolchain

La portautensile ARM GNU viene utilizzata per la costruzione.

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 utilizzare qualsiasi applicazione del terminale di porta seriale.

$ sudo apt-get install screen

3. Clona repository

OpenThread

Clona e installa OpenThread. I comandi script/bootstrap garantiscono 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

Creare un daemon OpenThread:

$ script/cmake-build posix -DOT_DAEMON=ON

Ora sei pronto per costruire e eseguire il flashing di OpenThread sulle schede nRF52840.

4. Configura RCP Joiner

Build e flash

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

Elimina sempre 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 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.

20a3b4b480356447.png

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 la RCP:

c00d519ebec7e5f0.jpeg

Individuare la posizione degli strumenti a riga di comando nRFx e eseguire il flashing del file esadecimale RCP di OpenThread sulla scheda nRF52840, utilizzando il numero di serie della scheda. Tieni presente che, se escludi il flag --verify, verrà 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.

Etichetta la lavagna "RCP" in modo da non confondere i ruoli della lavagna.

Connettiti a una porta USB nativa

Poiché la build OpenThread RCP consente l'utilizzo dell'ACM USBC CD 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 Fonte di alimentazione nRF su USB.

46e7b670d2464842.png

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 confermare che è 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 la stessa interfaccia a riga di comando dell'app CLI di OpenThread. 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 (il nodo RCP) che hai iniziato con ot-daemon:

> state
disabled
Done

5. Configura le aziende FTD

Gli altri due nodi Thread utilizzati in questo codelab sono Full Thread Devices (FTD) sulla progettazione standard system-on-chip (SoC). In un'impostazione Production (Produzione), è possibile usare wpantund, un driver di interfaccia di rete di produzione, per controllare le istanze NCP OpenThread, ma in questo codelab utilizzeremo ot-ctl, l'interfaccia a riga di comando di OpenThread.

Un dispositivo ha le funzioni di Commissioner per autenticare e mettere in servizio i dispositivi su quella rete in modo sicuro. L'altro dispositivo funziona come un joiner che il commissario può autenticare nella rete Thread.

Build 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

Passa alla directory con il file binario dell'interfaccia a riga di comando dell'interfaccia a riga di comando OpenThread Full Thread Device (FTD) 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 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:

c00d519ebec7e5f0.jpeg

Individuare la posizione degli strumenti a riga di comando nRFx e eseguire il flashing del file esadecimale FLI di OpenThread 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".

Connettiti a una porta USB nativa

Poiché la build OpenThread FTD consente l'utilizzo di ACM USBC CD 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 Fonte di alimentazione nRF su USB.

46e7b670d2464842.png

Verifica build

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

$ screen /dev/ttyACM1 115200

Nella nuova finestra, premi diverse volte la tastiera per visualizzare il prompt dell'interfaccia a riga di comando >Thread aperta. 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 scollegare l'interfaccia a riga di comando dell'interfaccia a riga di comando dell'FTD e tornare al terminale Linux, in modo da poter lampeggiare la scheda successiva. Per reinserire l'interfaccia a riga di comando in qualsiasi momento, utilizza screen -r dalla riga di comando. Per visualizzare un elenco di schermate disponibili, utilizza screen -ls:

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

Configura FTD Joiner

Ripeti la procedura riportata 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 di alimentazione nRF su VDD.

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

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

Etichetta la lavagna "Partecipante".

Quando esegui la verifica utilizzando lo schermo, anziché creare una nuova istanza dello schermo dalla riga di comando, ricollegalo a quello esistente ed esegui una nuova finestra al suo interno (utilizzata per il Commissioner FTD):

$ screen -r

Crea la nuova finestra all'interno dello schermo con Ctrl+a → c.

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

$ screen /dev/ttyACM2 115200

In questa nuova finestra, premi alcune volte la tastiera per visualizzare il prompt dell'interfaccia a riga di comando OpenThread >. 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'unione FTD si trova nella stessa istanza dello schermo per l'FTD Commissioner, puoi passare da una all'altra usando Ctrl+a → n.

Utilizza Ctrl + A →

d in qualsiasi momento per uscire dalla schermata.

6. Configurazione della finestra del terminale

In futuro, passerai spesso da un dispositivo Thread all'altro, quindi assicurati che tutti siano attivi e facilmente accessibili. Finora abbiamo utilizzato Schermo per accedere ai due FTD, un'opzione che consente anche di usare lo schermo diviso nella stessa finestra del terminale. Utilizza questo modo per vedere come un nodo reagisce ai comandi emessi su un altro.

Idealmente, dovresti avere quattro finestre immediatamente disponibili:

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

Se vuoi utilizzare il tuo terminale / la tua configurazione della porta seriale, non esitare a passare al passaggio successivo. Configura le finestre del terminale per tutti i dispositivi nel modo più adatto a te.

Utilizzo dello schermo

Per facilitare l'utilizzo, avvia una sola sessione sullo schermo. Dovresti averne già uno da quando hai configurato entrambi gli 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

Abbandonare la sessione schermo

Ctrl + A → d

Crea una nuova finestra nella sessione schermo

Ctrl + A → c

Passare da una finestra all'altra nella stessa sessione schermata

Ctrl+a → n (avanti)Ctrl+a → p (Indietro)

Chiudi la finestra corrente nella sessione di schermata

Ctrl + A → k

Schermo diviso

Con Schermo puoi suddividere il terminale in più finestre:

f1cbf1258cf0a5a.png

Per accedere ai comandi di 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 schermata esistente:

$ screen -r

Dovresti essere in uno dei dispositivi FTD. Segui questi passaggi nello schermo:

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

Ora sono entrambi visibili. Passa da una all'altra usando Ctrl+a → Tab. Ti consigliamo di rinominare 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. Per farlo, interrompi ot-daemon e chiudi ot-ctl, quindi riavviali all'interno di nuove finestre schermata (Ctrl+a → c).

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

Con i seguenti comandi, puoi suddividere le finestre e spostarti da una finestra all'altra:

Crea nuova finestra

Ctrl + A → c

Suddividi finestra in verticale

Ctrl + A →

Dividi la finestra orizzontalmente

Ctrl + A → S

Passare alla finestra visualizzata successiva

Ctrl + A → Tab

Porta avanti o indietro la finestra visualizzata

Ctrl+a → n o p

Rinominare la finestra corrente

Ctrl + A → A

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

Per ulteriori informazioni sullo schermo, consulta la guida rapida di GNU Screen.

7. Creare 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 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

Apri l'interfaccia IPv6:

> ifconfig up
Done

Avvia l'operazione sul protocollo Thread:

> thread start
Done

Dopo qualche istante, controlla lo stato del dispositivo. Dovrebbe essere il leader. Richiedi 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)

La rete "codelab" ora è visibile durante la scansione da altri dispositivi Thread.

A partire 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 su 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 eseguire di nuovo la scansione.

8. Aggiungi Joiner RCP

Thread Commissioning non è attivo sulla rete, il che significa che dobbiamo aggiungere il joiner RCP alla rete Thread che abbiamo appena creato utilizzando una procedura di commissione out-of-band.

In 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 su FTD Commissioner:

## FTD Commissioner ##

> dataset networkkey
1234c0de7ab51234c0de7ab51234c0de
Done

A questo punto, in RCP Joiner, imposta la chiave di rete del set di dati attiva sulla chiave di rete del FTD Commissioner:

## 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 il thread in modo che il join RCP si unisca alla rete "codelab". Attendi qualche secondo, controlla lo stato, 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), lo utilizzerai in un secondo momento.

Torna su FTD Commissioner, controlla il router e le tabelle secondarie per verificare che entrambi i dispositivi facciano parte della stessa rete. Usa RLOC16 per identificare il RCP Joiner.

## 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 locale del mesh 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 costituita da due nodi, illustrati da questo diagramma di topologia:

otcodelab_top01C_2nodes.png

Diagrammi di topologia

Mentre lavori al 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:

b75a527be4563215.png

I router sono sempre pentaloni e i dispositivi finali sono sempre cerchi. I numeri su ciascun nodo rappresentano l'ID router o l'ID secondario 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 l'unione dell'FTD

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

In FTD Joiner, prendi il eui64, in modo che il commissario FTD possa identificarlo:

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

> eui64
2f57d222545271f1
Done

Su Commissioner FTD, avvia il commissario e specifica il eui64 del dispositivo che può partecipare, insieme alla credenziale Joiner, ad esempio J01NME. La credenziale Joiner è una stringa specifica per dispositivo di tutti i caratteri alfanumerici maiuscoli (0-9 e A-Y, 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 Joiner appena configurata in Commissione di FTD:

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

> ifconfig up
Done
> joiner start J01NME
Done

Entro un minuto circa riceverai la conferma dell'autenticazione:

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

>
Join success

Richiama Thread in modo che l'FTD Joiner si unisca alla rete "codelab" e controlli immediatamente lo stato e la funzione RLOC16:

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

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

Controlla gli indirizzi IPv6 del dispositivo. Vedrai che non è presente 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 router e figli per verificare che nella rete siano presenti tre dispositivi:

## 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 dispositivo FTD Joiner è collegato alla rete come dispositivo finale (secondario). Ecco la nostra topologia aggiornata:

otcodelab_top01C_ed01.png

10. Thread in azione

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

Il 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 rete Thread erano presenti due figli dopo l'aggiunta di FTD Joiner, attendi almeno due minuti, quindi controlla il router e le tabelle secondarie 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

L'FTD Joiner (MAC esteso = e6cdd2d93249a243) si è promosso a un router. Tieni presente che RLOC16 è diverso (b800 anziché 0c02). Questo perché RLOC16 si basa sull'ID router e sull'ID secondario di un dispositivo. Quando si esegue la transizione da Dispositivo finale a Router, i valori dell'ID router e dell'ID secondario cambiano, così come il valore RLOC16.

otcodelab_top01C.png

Conferma il nuovo stato e RLOC16 su FTD Joiner:

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

> state
router
Done
> rloc16
b800
Done

Downgrade di FTD Joiner

Puoi verificare questo comportamento eseguendo manualmente il downgrade di FTD Joiner da un router a un dispositivo finale. Modifica lo stato in secondario e controlla la RLOC16:

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

> state child
Done
> rloc16
0c03
Done

otcodelab_top01C_ed02.png

Tornando al FTD Commissioner, l'FTD Joiner dovrebbe ora apparire nella tabella secondaria (ID = 3). Potrebbe essere anche in entrambi i casi 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 un po' di tempo, tornerà a un router con un RLOC pari a b800.

otcodelab_top01C.png

Rimuovi il leader

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

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

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

> thread stop
Done
> ifconfig down
Done

Nel giro di due minuti, FTD Joiner diventa il nuovo leader di Thread. Controlla gli stati e gli indirizzi IPv6 del Joiner 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

otcodelab_top02C_01.png

Controlla la tabella secondaria. Nota che è presente una nuova versione RLOC16. Questo è l'unione RCP, come indicato dal suo ID e dall'estensione MAC, per mantenere unita la rete Thread, ha cambiato router padre, dall'FTD Commissioner all'FTD Joiner. Ne consegue 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 per consentire al rCP Joiner di collegarsi al membro FTD come bambino. Controlla lo stato e l'RLOC16 per confermare che:

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

> state
child
> rloc16
b801

Riallega il commissario FTD

Una rete Thread con due nodi non è molto divertente. Riportiamo online il Commissario per il FTD.

Su FTD Commissioner, riavvia Thread:

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

> ifconfig up
Done
> thread start
Done

Nel giro di due minuti, si ricollega automaticamente alla rete "Codelab" come dispositivo finale, per poi promuoversi automaticamente a un router.

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

> state
router
Done

Controlla il router e le tabelle secondarie su 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

otcodelab_top02C_02.png

La nostra rete Thread è costituita di nuovo da tre nodi.

11. Risoluzione dei problemi

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

Schermo

Se ti perdi nella 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 sulla riga di comando genera No Sockets found. Quindi ricrea le finestre per ogni dispositivo. Gli stati del dispositivo vengono conservati anche in caso di interruzione dello schermo.

Thread thread

Se la topologia della rete Thread non è quella descritta in questo codelab o i nodi si disconnettono per qualche motivo (forse perché la macchina Linux che li alimenta è entrata in modalità di sospensione), è meglio eliminare il thread, cancellare le credenziali di rete e ricominciare dal passaggio Crea la rete Thread.

Per reimpostare gli FTD:

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

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

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

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

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

12 Utilizzare il multicast

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

Indirizzo IPv6

Ambito

Recapitato a

ff02::1

Link-Local

Tutti gli FTD e gli MED

ff02::2

Link-Local

Tutti i router FTD e di confine

ff03::1

Mesh-Local

Tutti gli FTD e gli MED

ff03::2

Mesh-Local

Tutti i router FTD e di confine

Dal momento che non utilizziamo un router di confine in questo codelab, concentriamoci sui due indirizzi multicast FTD e MED.

L'ambito Link-Local comprende tutte le interfacce Thread raggiungibili tramite 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 dal commissario FTD:

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

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

Nella rete sono presenti altri due dispositivi (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 il Commissario per la FTD può raggiungere con un solo hop.

otcodelab_top02C_02_LL.png

Ora puoi inviare 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 degli altri dispositivi, possiamo vedere che il primo (che termina con 4b1d) è l'LLA Commissioner dell'FTD e il secondo (che termina con 943b) è l'LLA Joiner dell'FCP.

otcodelab_top02C_02_LL02.png

Ciò significa che l'unione FTD è direttamente collegata sia all'FTD Commissioner che all'RCP Joiner, il che conferma la nostra topologia.

Mesh-Local

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

Invia un ping a ff03::1 dal commissario FTD:

## 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 per la FTD ha ricevuto due risposte, una dal locatore di routing FTD Joiner (RLOC, che termina con b800) e uno dal EID mesh-local (ML-EID) del Joint RCP, che termina con d55f. Questo perché l'ambito locale del mesh comprende l'intera rete Thread. A prescindere dalla posizione in cui si trova un dispositivo nella rete, l'abbonamento sarà associato all'indirizzo ff03::1.

otcodelab_top02C_02_ML.png

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

otcodelab_top02C_02_LL02.png

Nota il tempo di risposta per il join RCP in entrambi gli output dei ping. Il Joint RCP ha impiegato molto più tempo per raggiungere il Commissario FTD (68 ms) rispetto a quello per raggiungere il FTD Joiner (23 ms). Questo perché deve fare due hop per raggiungere l'FTD Commissioner, rispetto a un hop per l'FTD Joiner.

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

Controlla lo stato dell'unione RCP per confermare:

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

> state
child

13. Inviare messaggi con UDP

Uno dei servizi di applicazioni forniti da OpenThread è User Datagram Protocol (UDP), un protocollo Transport Layer. Un'applicazione basata su OpenThread potrebbe utilizzare l'API UDP per passare messaggi tra nodi in una rete Thread o con 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 i messaggi tra i due FTD.

Ottieni l'indirizzo EID mesh per il joiner FTD. Stiamo utilizzando 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 sul 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 Commissario per la FTD:

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

> udp send hellothere
Done

Il messaggio UDP sul join FTD è stato ricevuto.

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

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

14. Complimenti!

Hai creato una rete fisica di tipo Thread.

b915c433e7027cc7.png

Ora sai:

  • differenza tra i tipi di dispositivi, i ruoli e gli ambiti dei thread
  • Come 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 di nuovo il flashing della scheda FTD Joiner 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 più dispositivi (prova con un'altra piattaforma) alla rete e crea una topologia utilizzando il router e le tabelle secondarie, oltre ai ping agli indirizzi multicast
  • Utilizza pyspinel per controllare l'NCP
  • Converti l'NCP in un router di confine utilizzando il router di confine OpenThread e connetti la tua rete Thread a Internet

Per approfondire

Consulta openthread.io e GitHub per una serie di risorse di OpenThread, tra cui:

Riferimento: