Simulazione di una rete Thread con OpenThread

1. Introduzione

26b7f4f6b3ea0700.png

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.

Questo codelab ti spiega nei dettagli come simulare una rete Thread sui dispositivi simulati.

Obiettivi didattici

  • Come configurare la catena di strumenti di compilazione OpenThread
  • Come simulare una rete Thread
  • Come autenticare i nodi Thread
  • Come gestire una rete Thread con OpenThread Daemon

Che cosa ti serve

  • git
  • Conoscenza di base di Linux, routing di rete

2. Configura il sistema di compilazione

Git

Git necessario per completare questo codelab. Scaricalo e installalo prima di continuare.

Una volta installata, segui le istruzioni relative al tuo sistema operativo specifico per scaricare e creare OpenThread.

XCode per Mac OS X

Per installare e creare OpenThread su Mac OS X è necessario XCode.

Dopo aver installato XCode, installa gli strumenti a riga di comando XCode:

$ xcode-select --install

Build su Linux / Mac OS X

Queste istruzioni di installazione sono state testate su Ubuntu Server 14.04 LTS e Mac OS X Sierra 10.12.6.

Installa OpenThread. I comandi 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

Su Windows

Se preferisci Windows, ti consigliamo di provare la versione Docker di questo codelab.

3. Crea le applicazioni OpenThread

Al termine dell'installazione, crea l'applicazione OpenThread di esempio. Per questo codelab utilizziamo l'esempio di simulazione.

$ cd ~/src/openthread
$ ./script/cmake-build simulation

Ora crea il daemon OpenThread:

$ ./script/cmake-build posix -DOT_DAEMON=ON

4. Simulare una rete Thread

L'applicazione di esempio che utilizzerai per questo codelab mostra un'applicazione OpenThread minima che espone le interfacce di configurazione e gestione di OpenThread tramite un'interfaccia a riga di comando (CLI) di base.

Questo esercizio ti guida nei passaggi minimi necessari per inviare un ping a un dispositivo Thread simulato da un altro dispositivo Thread simulato.

La figura seguente descrive una topologia di rete di Thread di base. Per questo esercizio, simuleremo i due nodi all'interno del cerchio verde: un leader del thread e un router Thread con una singola connessione tra loro.

6e3aa07675f902dc.png

Invia un ping a un nodo

1. Avvia nodo 1

Vai alla directory openthread e genera il processo dell'interfaccia a riga di comando per un dispositivo Thread simulato utilizzando il programma binario ot-cli-ftd.

$ cd ~/src/openthread
$ ./build/simulation/examples/apps/cli/ot-cli-ftd 1

Nota: se non vedi il messaggio > dopo aver eseguito questo comando, premi enter.

Questo programma binario implementa un dispositivo OpenThread simulato sopra POSIX. Il driver radio IEEE 802.15.4 è implementato su UDP (i frame IEEE 802.15.4 vengono passati all'interno dei payload UDP).

L'argomento 1 è un descrittore di file che rappresenta i bit meno significativi dello standard IEEE EUI-64 "assegnato in fabbrica" per il dispositivo simulato. Questo valore viene utilizzato anche quando si esegue il collegamento a una porta UDP per l'emulazione della radio IEEE 802.15.4 (porta = 9000 + descrittore del file). Ogni istanza di un dispositivo Thread simulato in questo codelab utilizzerà un descrittore di file diverso.

Nota: utilizza i descrittori dei file pari o superiori a 1 come indicato in questo codelab quando generi la procedura per un dispositivo simulato. Un descrittore di file 0 è riservato a un altro utilizzo.

Creare un nuovo set di dati operativo e eseguirne il commit come attivo. Il set di dati operativi è la configurazione per la rete Thread che stai creando.

> dataset init new
Done
> dataset
Active Timestamp: 1
Channel: 20
Channel Mask: 07fff800
Ext PAN ID: d6263b6d857647da
Mesh Local Prefix: fd61:2344:9a52:ede0/64
Network Key: e4344ca17d1dca2a33f064992f31f786
Network Name: OpenThread-c169
PAN ID: 0xc169
PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4
Security Policy: 0, onrcb
Done

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

Attendi qualche secondo e verifica che il dispositivo sia diventato Thread Leader. Il Leader è il dispositivo responsabile della gestione dell'assegnazione degli ID router.

> state
leader
Done

Visualizza gli indirizzi IPv6 assegnati all'interfaccia Thread del nodo 1 (l'output sarà diverso):

> ipaddr
fd61:2344:9a52:ede0:0:ff:fe00:fc00
fd61:2344:9a52:ede0:0:ff:fe00:5000
fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
fe80:0:0:0:94da:92ea:1353:4f3b
Done

Osserva i tipi di indirizzo IPv6 specifici:

  • Inizia con fd = mesh-local
  • Inizia con fe80 = link-local

I tipi di indirizzo mesh locale sono classificati ulteriormente:

  • Contiene ff:fe00 = Localizzatore router (RLOC)
  • Non contiene ff:fe00 = identificatore endpoint (EID)

Identifica l'EID nell'output della console e prendine nota per un uso futuro. Nell'output di esempio riportato sopra, l'EID è:

fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6

2. Avvia nodo 2

Apri un nuovo terminale, vai alla directory openthread e genera il processo dell'interfaccia a riga di comando. Questo è il secondo dispositivo Thread simulato:

$ cd ~/src/openthread
$ ./build/simulation/examples/apps/cli/ot-cli-ftd 2

Nota: se non vedi il messaggio > dopo aver eseguito questo comando, premi enter.

Configura la chiave di rete Thread e l'ID PAN utilizzando gli stessi valori del set di dati operativi del nodo 1:

> dataset networkkey e4344ca17d1dca2a33f064992f31f786
Done
> dataset panid 0xc169
Done

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

Il dispositivo si inizializza come bambino. Un asset secondario Thread è equivalente a un dispositivo finale, ovvero un dispositivo Thread che trasmette e riceve traffico comunicativo solo con un dispositivo principale.

> state
child
Done

Entro 2 minuti dovresti vedere il passaggio dello stato da child a router. Un router Thread è in grado di instradare il traffico tra dispositivi Thread. È anche indicato come Genitore.

> state
router
Done

Verifica la rete

Un modo semplice per verificare la rete mesh è controllare la tabella dei router.

1. Controlla connettività

Sul nodo 2, recupera RLOC16. RLOC16 è gli ultimi 16 bit dell'indirizzo RLOC IPv6 del dispositivo.

> rloc16
5800
Done

Sul nodo 1, controlla la tabella del router per il RLOC16 del nodo 2. Assicurati che il nodo 2 sia passato prima allo stato del router.

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQI In | LQI Out | Age | Extended MAC  |
+----+--------+----------+----------+-------+---------+-----+------------------+
| 20 | 0x5000 |       63 |         0 |     0 |      0 |   0 | 96da92ea13534f3b |
| 22 | 0x5800 |       63 |         0 |     3 |      3 |  23 | 5a4eb647eb6bc66c |

La tabella RLOC di 0xa800 del nodo 1 si trova nella tabella a conferma della sua connessione al mesh.

2. Ping del nodo 1 del nodo 2

Verifica la connettività tra i due dispositivi Thread simulati. Nel nodo 2, ping l'EID assegnato al nodo 1:

> ping fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
> 16 bytes from fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6: icmp_seq=1
hlim=64 time=12ms

Premi enter per tornare alla richiesta dell'interfaccia a riga di comando di >.

Testa la rete

Ora che puoi eseguire il ping tra due dispositivi Thread simulati, testa la rete mesh mettendo offline un nodo.

Torna al nodo 1 e interrompi il thread:

> thread stop
Done

Passa al nodo 2 e controlla lo stato. Entro due minuti, il nodo 2 rileva che il leader (nodo 1) è offline e dovresti vedere che la transizione del nodo 2 è il leader della rete:

> state
router
Done
...
> state
leader
Done

Una volta confermato, arresta Thread e ripristina i dati di fabbrica del nodo 2 prima di uscire. Viene eseguito un ripristino dei dati di fabbrica per garantire che le credenziali di rete di Thread utilizzate in questo esercizio non vengano trasferite all'esercizio successivo.

> thread stop
Done
> factoryreset
>
> exit

Ripristina anche i dati di fabbrica e esci dal nodo 1:

> factoryreset
>
> exit

Consulta la pagina Riferimento interfaccia a riga di comando OpenThread per esplorare tutti i comandi dell'interfaccia a riga di comando disponibili.

5. Autenticare i nodi con la messa in servizio

Nell'esercizio precedente hai configurato una rete Thread con due dispositivi simulati e connettività verificata. Tuttavia, questo consente solo il passaggio tra traffico locale e link IPv6 non autenticato tra dispositivi. Per instradare il traffico IPv6 globale tra loro (e Internet tramite un router di confine Thread), i nodi devono essere autenticati.

Per eseguire l'autenticazione, un dispositivo deve agire da commissario. Il commissario è il server di autenticazione attualmente eletto per i nuovi dispositivi Thread e l'autorizzatore a fornire le credenziali di rete necessarie ai dispositivi per collegarsi alla rete.

In questo esercizio utilizzeremo la stessa topologia a due nodi di prima. Per l'autenticazione, il leader di Thread agisce in qualità di commissario, come router Thread come Joiner.

d6a67e8a0d0b5dcb.png

1. Crea una rete

Se continui l'esercizio precedente, dovresti già avere due finestre del terminale aperte. In caso contrario, assicurati che due siano aperti e pronti all'uso. Uno fungerà da nodo 1, l'altro come nodo 2.

Nel nodo 1, genera il processo dell'interfaccia a riga di comando:

$ cd ~/src/openthread
$ ./build/simulation/examples/apps/cli/ot-cli-ftd 1

Nota: se non vedi il messaggio > dopo aver eseguito questo comando, premi enter.

Crea un nuovo set di dati operativo, eseguilo come attivo e avvia Thread:

> dataset init new
Done
> dataset
Active Timestamp: 1
Channel: 12
Channel Mask: 07fff800
Ext PAN ID: e68d05794bf13052
Mesh Local Prefix: fd7d:ddf7:877b:8756/64
Network Key: a77fe1d03b0e8028a4e13213de38080e
Network Name: OpenThread-8f37
PAN ID: 0x8f37
PSKc: f9debbc1532487984b17f92cd55b21fc
Security Policy: 0, onrcb
Done

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

Attendi qualche secondo e verifica che il dispositivo sia diventato Thread Leader:

> state
leader
Done

2. Avviare il ruolo Commissario

Mentre sei ancora sul nodo 1, avvia il ruolo Commissioner:

> commissioner start
Done

Consenti a qualsiasi Joiner (utilizzando il carattere jolly *) con la credenziale Joiner J01NME di effettuare commissioni sulla rete. Un joiner è un dispositivo che viene aggiunto da un amministratore a una rete Thread commissionata.

> commissioner joiner add * J01NME
Done

3. Avvia il ruolo Collaboratore

In una seconda finestra del terminale, genera un nuovo processo dell'interfaccia a riga di comando. Questo è il nodo 2.

$ cd ~/src/openthread
$ ./build/simulation/examples/apps/cli/ot-cli-ftd 2

Sul nodo 2, abilita il ruolo Joiner utilizzando la credenziale di join J01NME.

> ifconfig up
Done
> joiner start J01NME
Done

... attendi qualche secondo per la conferma ...

Join success

In qualità di falegname, il dispositivo (nodo 2) si è autenticato correttamente con il commissario (nodo 1) e ha ricevuto le credenziali di rete Thread.

Ora che il nodo 2 è autenticato, avvia Thread:

> thread start
Done

4. Convalida l'autenticazione della rete

Controlla il state sul nodo 2, per verificare che sia stato aggiunto alla rete. Entro due minuti, le transizioni del nodo 2 da child a router:

> state
child
Done
...
> state
router
Done

5. Reimposta configurazione

Per prepararti al prossimo esercizio, reimposta la configurazione. Su ciascun nodo, interrompi Thread, esegui un ripristino dei dati di fabbrica ed esci dal dispositivo Thread simulato:

> thread stop
Done
> factoryreset
>
> exit

Potresti dover premere enter volte alcune volte per ripristinare il messaggio > dopo un comando factoryreset.

6. Gestire la rete con OpenThread Daemon

Per questo esercizio, simuleremo un'istanza dell'interfaccia a riga di comando (un unico dispositivo Thread SoC incorporato) e un'istanza di radio coprocessore (RCP).

ot-daemon è una modalità dell'app OpenThread Posix che utilizza un socket UNIX come input e output, in modo che il core OpenThread possa essere eseguito come servizio. Un client può comunicare con questo servizio connettendosi al socket utilizzando l'interfaccia a riga di comando OpenThread come protocollo.

ot-ctl è un'interfaccia a riga di comando fornita da ot-daemon per gestire e configurare l'RCP. In questo modo, collegheremo l'RCP alla rete creata dal dispositivo Thread.

Utilizza ot-daemon

Questo esercizio utilizzerà tre finestre del terminale, corrispondenti alle seguenti:

  1. Istanza CLI di dispositivo Thread simulato (Nodo 1)
  2. Processo ot-daemon
  3. ot-ctl istanza dell'interfaccia a riga di comando

Se continui l'esercizio precedente, dovresti già avere due finestre del terminale aperte. Aprine una terza per assicurarti di avere tre finestre terminali disponibili per questo esercizio.

1. Avvia nodo 1

Nella prima finestra del terminale, genera il processo dell'interfaccia a riga di comando per il dispositivo Thread simulato:

$ cd ~/src/openthread
$ ./build/simulation/examples/apps/cli/ot-cli-ftd 1

Nota: se non vedi il messaggio > dopo aver eseguito questo comando, premi enter.

Crea un nuovo set di dati operativo, eseguilo come attivo e avvia Thread:

> dataset init new
Done
> dataset
Active Timestamp: 1
Channel: 13
Channel Mask: 07fff800
Ext PAN ID: 97d584bcd493b824
Mesh Local Prefix: fd55:cf34:dea5:7994/64
Network Key: ba6e886c7af50598df1115fa07658a83
Network Name: OpenThread-34e4
PAN ID: 0x34e4
PSKc: 38d6fd32c866927a4dfcc06d79ae1192
Security Policy: 0, onrcb
Done

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

Visualizza gli indirizzi IPv6 assegnati all'interfaccia Thread del nodo 1:

> ipaddr
fd55:cf34:dea5:7994:0:ff:fe00:fc00
fd55:cf34:dea5:7994:0:ff:fe00:d000
fd55:cf34:dea5:7994:460:872c:e807:c4ab
fe80:0:0:0:9cd8:aab6:482f:4cdc
Done
>

Come spiegato nel passaggio Simulare una rete Thread, un indirizzo deve essere locale rispetto al collegamento (fe80) e tre sono locale rispetto al mesh (fd). L'EID è l'indirizzo locale mesh che non contiene ff:fe00 nell'indirizzo. In questo output di esempio, l'EID è fd55:cf34:dea5:7994:460:872c:e807:c4ab.

Identifica l'EID specifico del tuo output ipaddr, che verrà utilizzato per comunicare con il nodo.

2. Avvia ot-daemon

Nella seconda finestra del terminale, vai alla directory openthread e avvia ot-daemon per un nodo RCP, che chiameremo Nodo 2. Utilizza il flag con dettaglio -v per poter vedere l'output del log e verificare che sia in esecuzione e assicurati di utilizzare sudo:

$ cd ~/src/openthread
$ sudo ./build/posix/src/posix/ot-daemon -v \
    'spinel+hdlc+forkpty://build/simulation/examples/apps/ncp/ot-rcp?forkpty-arg=2'

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 questo terminale aperto e in esecuzione in background. Non inserirai altri comandi al suo interno.

3. Utilizza OTT per accedere alla rete

Il nodo 2 (RCP ot-daemon) non è stato ancora commissionato a nessuna rete Thread. È qui che entra in gioco ot-ctl. 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 terza finestra del terminale, avvia ot-ctl:

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

Nota: se non vedi il messaggio > dopo aver eseguito questo comando, premi enter.

Utilizzerai ot-ctl in questa terza finestra del terminale per gestire il nodo 2 (il nodo RCP) avviato nella seconda finestra del terminale con ot-daemon. Controlla il state del nodo 2:

> state
disabled
Done

Recupera il eui64 di nodo 2, per limitare l'unione al sottoscrittore specifico:

> eui64
18b4300000000001
Done

Sul Nodo 1 (prima finestra del terminale), avvia il Commissioner e limita l'unione solo a quella eui64:

> commissioner start
Done
> commissioner joiner add 18b4300000000001 J01NME
Done

Sul nodo 2 (terza finestra del terminale), apri l'interfaccia di rete ed entra nella rete:

> ifconfig up
Done
> joiner start J01NME
Done

... attendi qualche secondo per la conferma ...

Join success

In qualità di Joiner, l'RCP (Nodo 2) si è autenticato correttamente con il Commissario (Nodo 1) e ha ricevuto le credenziali di Thread Network.

Ora unisci il nodo 2 alla rete Thread:

> thread start
Done

4. Convalida l'autenticazione della rete

Controlla il state sul nodo 2, per verificare che sia stato aggiunto alla rete. Entro due minuti, le transizioni del nodo 2 da child a router:

> state
child
Done
...
> state
router
Done

5. Convalida connettività

Esci da ot-ctl utilizzando il comando Ctrl+D o exit. Quindi, invia un ping al nodo 1 della riga di comando della macchina host, utilizzando il relativo EID con il comando ping6. Se l'istanza ot-daemon RCP è collegata e comunica con la rete Thread, il ping riesce:

$ ping6 -c 4 fd55:cf34:dea5:7994:460:872c:e807:c4ab
PING fd55:cf34:dea5:7994:460:872c:e807:c4ab (fd55:cf34:dea5:7994:460:872c:e807:c4ab): 56 data bytes
64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=0 ttl=64 time=4.568 ms
64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=1 ttl=64 time=6.396 ms
64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=2 ttl=64 time=7.594 ms
64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=3 ttl=64 time=5.461 ms
--- fd55:cf34:dea5:7994:460:872c:e807:c4ab ping statistics ---
4 packets transmitted, 4 packets received, 0% packet loss
round-trip min/avg/max/stddev = 4.568/6.005/7.594/1.122 ms

7. Complimenti.

Hai simulato correttamente la tua prima rete Thread utilizzando OpenThread. Ottimo!

In questo codelab hai imparato a:

  • Configura la catena di strumenti di compilazione OpenThread
  • Simulare una rete Thread
  • Autentica i nodi Thread
  • Gestire una rete Thread con OpenThread Daemon

Per saperne di più, consulta questi riferimenti: