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 di prodotti per la casa connessa.
La specifica Thread definisce un protocollo di comunicazione da dispositivo a dispositivo wireless affidabile, sicuro ea basso consumo basato su IPv6 per applicazioni domestiche. OpenThread implementa tutti i livelli di rete Thread inclusi IPv6, 6LoWPAN, IEEE 802.15.4 con sicurezza MAC, Mesh Link Establishment e Mesh Routing.
Questo Codelab ti guida attraverso la simulazione di una rete Thread su dispositivi simulati.
Cosa imparerai
- Come configurare la toolchain di build OpenThread
- Come simulare una rete di thread
- Come autenticare i nodi di thread
- Come gestire una rete di thread con OpenThread Daemon
Di cosa avrai bisogno
- idiota
- Conoscenza di base di Linux, routing di rete
Idiota
Git è necessario per completare questo Codelab. Scaricalo e installalo prima di continuare.
Una volta installato, segui le istruzioni per il tuo sistema operativo specifico per scaricare e creare OpenThread.
XCode per Mac OS X
XCode è necessario per installare e creare OpenThread su Mac OS X.
Dopo aver installato XCode, installa gli strumenti della riga di comando XCode:
$ xcode-select --install
Crea 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 l'ambiente sia configurato correttamente:
$ mkdir -p ~/src $ cd ~/src $ git clone --recursive https://github.com/openthread/openthread.git $ cd openthread $ ./script/bootstrap $ ./bootstrap
Utilizzando Windows
Se preferisci Windows, ti consigliamo di provare la versione Docker di questo Codelab.
Una volta completata l'installazione, crea l'applicazione OpenThread di esempio. Per questo Codelab stiamo usando l'esempio di simulazione.
$ cd ~/src/openthread $ make -f examples/Makefile-simulation
Ora crea il demone OpenThread:
$ cd ~/src/openthread $ make -f src/posix/Makefile-posix DAEMON=1
L'applicazione di esempio che utilizzerai per questo Codelab mostra un'applicazione OpenThread minima che espone le interfacce di gestione e configurazione OpenThread tramite un'interfaccia della riga di comando (CLI) di base.
Questo esercizio illustra i passaggi minimi richiesti per eseguire il ping di un dispositivo Thread simulato da un altro dispositivo Thread simulato.
La figura seguente descrive una topologia di rete Thread di base. Per questo esercizio, simuleremo i due nodi all'interno del cerchio verde: un Thread Leader e un Thread Router con una singola connessione tra di loro.
Eseguire il ping di un nodo
1. Avviare il nodo 1
Passare alla directory openthread e generare il processo CLI per un dispositivo Thread simulato utilizzando il binario ot-cli-ftd .
$ cd ~/src/openthread $ ./output/simulation/bin/ot-cli-ftd 1
Questo binario implementa un dispositivo OpenThread simulato su 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 dell'IEEE EUI-64 "assegnato in fabbrica" per il dispositivo simulato. Questo valore viene utilizzato anche durante il collegamento a una porta UDP per l'emulazione radio IEEE 802.15.4 (porta = 9000 + descrittore di file). Ogni istanza di un dispositivo Thread simulato in questo Codelab utilizzerà un descrittore di file diverso.
Nota: utilizzare solo descrittori di file pari o superiori a 1 come indicato in questo Codelab quando si genera il processo per un dispositivo simulato. Un descrittore di file di 0 è riservato per altri usi.
Se non vedi il file
>
prompt dopo aver eseguito questo comando, premere
enter
.
Crea un nuovo set di dati operativo e inseriscilo come attivo. Il set di dati operativo è la configurazione per la rete di 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 Master Key: e4344ca17d1dca2a33f064992f31f786 Network Name: OpenThread-c169 PAN ID: 0xc169 PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4 Security Policy: 0, onrcb Done
Salva questo set di dati come quello attivo:
> dataset commit active Done
Visualizza l'interfaccia IPv6:
> ifconfig up Done
Avvia l'operazione 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 dell'ID del router.
> state leader Done
Visualizza gli indirizzi IPv6 assegnati all'interfaccia Thread del nodo 1 (il tuo 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
Prendi nota dei tipi di indirizzo IPv6 specifici:
- Inizia con
fd= mesh-local - Inizia con
fe80= link-local
I tipi di indirizzi mesh locali sono classificati ulteriormente:
- Contiene
ff:fe00= Router Locator (RLOC) - Non contiene
ff:fe00= Endpoint Identifier (EID)
Identifica l'EID nell'output della tua console e annotalo per un uso successivo. Nell'output di esempio sopra, l'EID è:
fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
2. Avviare il nodo 2
Apri un nuovo terminale e vai alla directory openthread e openthread il processo CLI. Questo è il tuo secondo dispositivo Thread simulato:
$ cd ~/src/openthread $ ./output/simulation/bin/ot-cli-ftd 2
Se non vedi il file
>
prompt dopo aver eseguito questo comando, premere
enter
.
Configurare la chiave principale del thread e l'ID PAN, utilizzando gli stessi valori del set di dati operativi del nodo 1:
> dataset masterkey e4344ca17d1dca2a33f064992f31f786 Done > dataset panid 0xc169 Done
Salva questo set di dati come quello attivo:
> dataset commit active Done
Visualizza l'interfaccia IPv6:
> ifconfig up Done
Avvia l'operazione del protocollo Thread:
> thread start Done
Il dispositivo si inizializzerà come figlio. Un Thread Child è equivalente a un End Device, ovvero un dispositivo Thread che trasmette e riceve traffico unicast solo con un dispositivo Parent.
> state child Done
Entro 2 minuti dovresti vedere lo stato passare da child a router . Un router thread è in grado di instradare il traffico tra i dispositivi thread. Viene anche definito genitore.
> state router Done
Verifica la rete
Un modo semplice per verificare la rete mesh è guardare la tabella del router.
1. Verificare la connettività
Sul nodo 2, ottieni RLOC16. RLOC16 sono gli ultimi 16 bit dell'indirizzo RLOC IPv6 del dispositivo.
> rloc16 5800 Done
Sul nodo 1, controlla la tabella del router per 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 |
L'RLOC del nodo 1 di 0xa800 si trova nella tabella, a conferma che è connesso alla mesh.
2. Eseguire il ping del nodo 1 dal nodo 2
Verificare la connettività tra i due dispositivi Thread simulati. Nel nodo 2, eseguire il ping dell'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
Premere enter per tornare al prompt > CLI.
Testa la rete
Ora che puoi eseguire correttamente il ping tra due dispositivi Thread simulati, prova la rete mesh portando un nodo offline.
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 la transizione del nodo 2 per essere il leader della rete:
> state router Done ... > state leader Done
Una volta confermato, interrompere Thread e ripristinare le impostazioni di fabbrica del nodo 2 prima di uscire. Viene eseguito un ripristino delle impostazioni di fabbrica per garantire che le credenziali di rete Thread che abbiamo utilizzato in questo esercizio non vengano trasferite all'esercizio successivo.
> thread stop Done > factoryreset > > exit
Ripristina anche le impostazioni di fabbrica ed esci dal nodo 1:
> factoryreset > > exit
Vedere OpenThread CLI Reference per esplorare tutti i comandi CLI disponibili.
Nell'esercizio precedente, hai configurato una rete Thread con due dispositivi simulati e connettività verificata. Tuttavia, ciò consente solo il passaggio del traffico locale IPv6 non autenticato tra i dispositivi. Per instradare il traffico IPv6 globale tra di loro (e Internet tramite un router di confine thread), i nodi devono essere autenticati.
Per autenticarsi, un dispositivo deve fungere da Commissario. Il Commissario è il server di autenticazione attualmente eletto per i nuovi dispositivi Thread e l'autorizzazione per fornire le credenziali di rete necessarie affinché i dispositivi si colleghino alla rete.
In questo esercizio useremo la stessa topologia a due nodi di prima. Per l'autenticazione, il Thread Leader agirà come Commissioner, il Thread Router come Joiner.
1. Crea una rete
Se continui dall'esercizio precedente, dovresti già avere due finestre di terminale aperte. In caso contrario, assicurati che due siano aperti e pronti per l'uso. Uno servirà come Nodo 1, l'altro come Nodo 2.
Nel nodo 1, genera il processo CLI:
$ cd ~/src/openthread $ ./output/simulation/bin/ot-cli-ftd 1
Se non vedi il file
>
prompt dopo aver eseguito questo comando, premere
enter
.
Creare un nuovo set di dati operativi, eseguirne il commit come quello attivo e avviare il 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 Master Key: a77fe1d03b0e8028a4e13213de38080e Network Name: OpenThread-8f37 PAN ID: 0x8f37 PSKc: f9debbc1532487984b17f92cd55b21fc Security Policy: 0, onrcb Done
Salva questo set di dati come quello attivo:
> dataset commit active Done
Visualizza l'interfaccia IPv6:
> ifconfig up Done
Avvia l'operazione del protocollo Thread:
> thread start Done
Attendi qualche secondo e verifica che il dispositivo sia diventato un Thread Leader:
> state leader Done
2. Inizia il ruolo di Commissario
Mentre sei ancora nel Nodo 1, inizia il ruolo di Commissario:
> commissioner start Done
Consenti a qualsiasi Joiner (utilizzando il carattere jolly * ) con le credenziali Joiner J01NME eseguire la commissione sulla rete. Un Joiner è un dispositivo che viene aggiunto da un amministratore umano a una rete di thread commissionata.
> commissioner joiner add * J01NME Done
3. Avviare il ruolo di falegname
In una seconda finestra di terminale, genera un nuovo processo CLI. Questo è il nodo 2.
$ cd ~/src/openthread $ ./output/simulation/bin/ot-cli-ftd 2
Sul nodo 2, abilita il ruolo Joiner utilizzando la credenziale Joiner J01NME .
> ifconfig up Done > joiner start J01NME Done
... attendi qualche secondo per la conferma ...
Join success
In qualità di Joiner, il dispositivo (Nodo 2) si è autenticato con successo con il Commissioner (Nodo 1) e ha ricevuto le credenziali di Thread Network.
Ora che il nodo 2 è autenticato, avvia il thread:
> thread start Done
4. Convalidare l'autenticazione di rete
Controllare lo state sul nodo 2, per verificare che ora sia entrato nella rete. Entro due minuti, il nodo 2 passa da child a router :
> state child Done ... > state router Done
5. Ripristina la configurazione
Per prepararsi all'esercizio successivo, reimpostare la configurazione. Su ogni nodo, interrompi il thread, ripristina le impostazioni di fabbrica e esci dal dispositivo Thread simulato:
> thread stop Done > factoryreset > > exit
Potrebbe essere necessario premere enter alcune volte per ripristinare il prompt > dopo un comando factoryreset .
Per questo esercizio, simuleremo un'istanza CLI (un singolo dispositivo SoC Thread incorporato) e un'istanza Radio Co-Processor (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 OpenThread CLI come protocollo.
ot-ctl è una CLI fornita da ot-daemon per gestire e configurare RCP. Usando questo, collegheremo l'RCP alla rete creata dal dispositivo Thread.
Usa ot-daemon
Questo esercizio utilizzerà tre finestre di terminale, corrispondenti alle seguenti:
- Istanza CLI del dispositivo Thread simulato (Nodo 1)
- processo
ot-daemon - istanza CLI
ot-ctl
Se continui dall'esercizio precedente dovresti già avere due finestre di terminale aperte. Aprine una terza per assicurarti di avere tre finestre di terminale disponibili per questo esercizio.
1. Avviare il nodo 1
Nella prima finestra del terminale, genera il processo CLI per il tuo dispositivo Thread simulato:
$ cd ~/src/openthread $ ./output/simulation/bin/ot-cli-ftd 1
Se non vedi il file
>
prompt dopo aver eseguito questo comando, premere
enter
.
Creare un nuovo set di dati operativi, eseguirne il commit come quello attivo e avviare il 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 Master Key: ba6e886c7af50598df1115fa07658a83 Network Name: OpenThread-34e4 PAN ID: 0x34e4 PSKc: 38d6fd32c866927a4dfcc06d79ae1192 Security Policy: 0, onrcb Done
Salva questo set di dati come quello attivo:
> dataset commit active Done
Visualizza l'interfaccia IPv6:
> ifconfig up Done
Avvia l'operazione 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 Simulate a Thread network , un indirizzo è link-local ( fe80 ) e tre sono mesh-local ( fd ). L'EID è l'indirizzo mesh locale 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 dall'output del tuo 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. Usa il flag -v verbose in modo da poter vedere l'output del log e confermare che è in esecuzione:
$ cd ~/src/openthread
$ ./output/posix/bin/ot-daemon -v \
'spinel+hdlc+forkpty://output/simulation/bin/ot-rcp?forkpty-arg=2'
In caso di successo, ot-daemon in modalità dettagliata genera un output simile al seguente:
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
3. Usa ot-ctl per unirti alla rete
Non abbiamo ancora commissionato il Nodo 2 (l'RCP ot-daemon ) a nessuna rete Thread. Questo è dove ot-ctl entra. ot-ctl utilizza lo stesso CLI come l'applicazione OpenThread CLI. Pertanto, è possibile controllare i nodi ot-daemon allo stesso modo degli altri dispositivi Thread simulati.
In una terza finestra di terminale, avvia ot-ctl :
$ ./output/posix/bin/ot-ctl >
Controlla lo state del nodo 2 (il nodo RCP) che hai iniziato con ot-daemon :
> state disabled Done
Ottieni l' eui64 del Nodo 2, per limitare l'accesso allo specifico Joiner:
> eui64 18b4300000000001 Done
Sul nodo 1, avvia il Commissioner e limita l'adesione solo a quell'eui64:
> commissioner start Done > commissioner joiner add 18b4300000000001 J01NME Done
Sul nodo 2, apri l'interfaccia di rete e unisciti alla 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 con successo con il Commissioner (Nodo 1) e ha ricevuto le credenziali di Thread Network.
Ora unisci il nodo 2 alla rete Thread:
> thread start Done
4. Convalidare l'autenticazione di rete
Controllare lo state sul nodo 2, per verificare che ora sia entrato nella rete. Entro due minuti, il nodo 2 passa da child a router :
> state child Done ... > state router Done
5. Convalidare la connettività
Esci da ot-ctl usando Ctrl + D e sulla riga di comando del tuo computer host, ping Node 1, usando il suo EID con il comando ping6 . Se l'istanza RCP del ot-daemon viene unita e comunica con successo con la rete Thread, il ping ha esito positivo:
$ 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
Hai simulato con successo la tua prima rete Thread utilizzando OpenThread. Eccezionale!
In questo Codelab hai imparato come:
- Configura la toolchain di compilazione OpenThread
- Simula una rete di thread
- Autentica i nodi del thread
- Gestisci una rete di thread con OpenThread Daemon
Se vuoi saperne di più, esplora questi riferimenti: