1. Introduzione
OpenThread, rilasciato dal team Google Nest, è un'implementazione open source del protocollo di rete Thread® progettata per accelerare lo sviluppo di prodotti per la casa connessa. La specifica Thread definisce un protocollo di comunicazione wireless da dispositivo a dispositivo affidabile, sicuro e a basso consumo basato su IPv6 per applicazioni domestiche ed edifici commerciali.
Espressif ha eseguito il porting dello stack OpenThread basato su FreeRTOS e LwIP, consentendo agli sviluppatori di creare rapidamente reti Thread. Il codice sorgente correlato può essere ottenuto da GitHub. Allo stesso tempo, Espressif ha implementato anche un Thread border router basato su RTOS.
In questo codelab, programmerai OpenThread su hardware reale, creerai e gestirai una rete Thread e trasmetterai messaggi tra i nodi.
Obiettivi didattici
- Creare e caricare i file binari dell'interfaccia a riga di comando di OpenThread sulle schede ESP.
- Creare e caricare il router di confine sulla scheda del router di confine Thread ESP.
- Gestire manualmente i nodi Thread con ESP Monitor e l'interfaccia a riga di comando di OpenThread.
- Formare una rete Thread sul router di confine Thread.
- Proteggere la messa in servizio dei dispositivi su una rete Thread.
- Eseguire il ping dell'indirizzo IPv6 tra i nodi Thread.
- Trasmettere messaggi tra i nodi Thread con UDP.
Che cosa ti serve
Hardware:
Software:
2. Per iniziare
- Installazione di ESP-IDF.
Segui la guida alla programmazione ESP-IDF per installare l'ambiente di sviluppo software.
- Clona l'SDK del Thread border router ESP.
ESP-THREAD-BR è l'SDK ufficiale del Thread border router ESP. Supporta tutte le funzionalità di rete fondamentali per creare un Thread border router e integra funzionalità avanzate a livello di prodotto per una rapida commercializzazione.
$ cd <your-local-workspace> $ git clone --recursive https://github.com/espressif/esp-thread-br.git
3. Crea e carica
Per creare e caricare il file binario ot-cli-ftd sulle schede ESP con moduli IEEE 802.15.4, puoi consultare l'esempio ot_cli di ESP-IDF per ulteriori dettagli:
$ cd <your-idf-path>/examples/openthread/ot_cli $ idf.py set-target <your-board-type>
Attiva la funzionalità di joiner tramite menuconfig:
$ idf.py menuconfig
Configurazione componente > OpenThread > Abilita joiner, quindi crea e carica.
$ idf.py -p <your-local-port> build flash monitor
Per creare e caricare il file binario ot-br sulla scheda Thread border router ESP, devi prima creare il file binario RCP. Questo file binario RCP non deve essere caricato esplicitamente sul dispositivo sulla scheda del router di confine Thread ESP. Verrà incluso nel file binario del router di confine e caricato sul chip ESP32-H2 al primo avvio (o se il firmware RCP è stato modificato). Per ulteriori dettagli, consulta la documentazione del router di confine Thread ESP:
$ cd <your-idf-path>/examples/openthread/ot_rcp $ idf.py set-target esp32h2 $ idf.py build $ cd <your-esp-thread-br-path>/examples/basic_thread_border_router $ idf.py set-target esp32s3
Attiva la funzionalità di commissione tramite menuconfig:
$ idf.py menuconfig
Configurazione componente > OpenThread > Abilita commissione, quindi crea e carica.
$ idf.py -p <your-local-port> build flash monitor
4. Formare una rete Thread sul router di confine Thread
Ora puoi formare una rete Thread utilizzando la riga di comando OpenThread sulla scheda del router di confine Thread ESP (commissione del router di confine):
## BR Commissioner ## ---------------------- > dataset init new Done > dataset Active Timestamp: 1 Channel: 21 Channel Mask: 0x07fff800 Ext PAN ID: 151975d11bea97b5 Mesh Local Prefix: fd6a:b54b:d6a3:b05a::/64 Network Key: 731ab6a60a64a0a0b14b259b86b2be01 Network Name: OpenThread-1444 PAN ID: 0x1444 PSKc: 54e7f18d2575014da94db09df29c5df0 Security Policy: 672 onrc 0 Done
Esegui il commit di questo set di dati come quello attivo:
> dataset commit active Done
Attiva l'interfaccia IPv6:
> ifconfig up I (59329) OPENTHREAD: Platform UDP bound to port 49153 Done I (59329) OT_STATE: netif up
Avvia l'operazione del protocollo Thread:
> thread start I(61709) OPENTHREAD:[N] Mle-----------: Role disabled -> detached Done > I(62469) OPENTHREAD:[N] Mle-----------: Attach attempt 1, AnyPartition reattaching with Active Dataset I(69079) OPENTHREAD:[N] RouterTable---: Allocate router id 11 I(69079) OPENTHREAD:[N] Mle-----------: RLOC16 fffe -> 2c00 I(69089) OPENTHREAD:[N] Mle-----------: Role detached -> leader I(69089) OPENTHREAD:[N] Mle-----------: Partition ID 0x28b518c6 I (69099) OPENTHREAD: Platform UDP bound to port 49154
Dopo un po' di tempo, controlla lo stato del dispositivo. Dovrebbe essere il leader.
> state leader Done >
5. Connettersi alla rete Thread tramite networkkey
In questo codelab, due schede ESP con moduli IEEE 802.15.4 sono preparate per connettersi alla rete formata dal router di confine. In questa sessione aggiungeremo la scheda 1 alla rete.
Recupera la networkkey dal router di confine:
## BR Commissioner ## ---------------------- > networkkey 731ab6a60a64a0a0b14b259b86b2be01 Done >
Imposta questa networkkey su una scheda ESP (joiner della scheda 1) con moduli IEEE 802.15.4:
## Board1 Joiner ## ---------------------- > dataset networkkey 731ab6a60a64a0a0b14b259b86b2be01 Done
Esegui il commit di questo set di dati come quello attivo:
> dataset commit active Done
Attiva l'interfaccia IPv6:
> ifconfig up Done I (20308) OT_STATE: netif up
Avvia l'operazione del protocollo Thread:
> thread start I(23058) OPENTHREAD:[N] Mle-----------: Role disabled -> detached Done > I(23408) OPENTHREAD:[N] Mle-----------: Attach attempt 1, AnyPartition reattaching with Active Dataset I(30028) OPENTHREAD:[N] Mle-----------: Attach attempt 1 unsuccessful, will try again in 0.288 seconds I(30328) OPENTHREAD:[N] Mle-----------: Attach attempt 2, AnyPartition I(33498) OPENTHREAD:[N] Mle-----------: Delay processing Announce - channel 21, panid 0x1444 I(33758) OPENTHREAD:[N] Mle-----------: Processing Announce - channel 21, panid 0x1444 I(33758) OPENTHREAD:[N] Mle-----------: Role detached -> disabled I(33758) OPENTHREAD:[N] Mle-----------: Role disabled -> detached I(34178) OPENTHREAD:[N] Mle-----------: Attach attempt 1, AnyPartition I(35068) OPENTHREAD:[N] Mle-----------: RLOC16 fffe -> 2c01 I(35068) OPENTHREAD:[N] Mle-----------: Role detached -> child
Dopo un po' di tempo, controlla lo stato del dispositivo. Dovrebbe essere il figlio.
> state child Done
Imposta il ruolo su Mesh Extender (denominato router nell'interfaccia a riga di comando e nei log).
> state router Done I(51028) OPENTHREAD:[N] Mle-----------: RLOC16 2c01 -> 2800 I(51028) OPENTHREAD:[N] Mle-----------: Role child -> router I(51028) OPENTHREAD:[N] Mle-----------: Partition ID 0x28b518c6 >
6. Connettersi alla rete Thread tramite la messa in servizio sicura
In questa sessione aggiungeremo la scheda 2 alla rete tramite la messa in servizio di sicurezza:
Recupera PSKc e panid dal commissione del router di confine:
## BR Commissioner ## ---------------------- > pskc 54e7f18d2575014da94db09df29c5df0 Done > panid 0x1444 Done
Configura le informazioni di rete per la scheda 2:
## Board2 Joiner ## ---------------------- > dataset pskc 54e7f18d2575014da94db09df29c5df0 Done > dataset panid 0x1444 Done
Esegui il commit di questo set di dati come quello attivo:
## Board2 Joiner ## ---------------------- > dataset commit active Done
Attiva l'interfaccia IPv6:
## Board2 Joiner ## ---------------------- > ifconfig up Done I (29146) OT_STATE: netif up
Recupera eui64 dalla scheda 2:
## Board2 Joiner ## ---------------------- > eui64 4831b7fffec02be1 Done
Sul commissione del router di confine, avvia il commissione e specifica il eui64 del dispositivo che può connettersi, insieme alle credenziali del joiner, ad esempio J01NME. Le credenziali del joiner sono una stringa specifica del dispositivo composta da caratteri alfanumerici in maiuscolo (0-9 e A-Y, esclusi I, O, Q e Z per la leggibilità), con una lunghezza compresa tra 6 e 32 caratteri.
## BR Commissioner ## ---------------------- > commissioner start Commissioner: petitioning Done Commissioner: active > commissioner joiner add 4831b7fffec02be1 J01NME Done
Passa al joiner della scheda 2. Avvia il ruolo di joiner con le credenziali del joiner che hai appena configurato sul commissione del router di confine:
## Board2 Joiner ## ---------------------- > ifconfig up Done > joiner start J01NME Done
Entro un minuto circa, riceverai una conferma dell'autenticazione riuscita:
## Board2 Joiner ## ---------------------- > Join success
Dopodiché, puoi avviare e connetterti alla rete Thread formata dal commissione del router di confine.
Avvia l'operazione del protocollo Thread:
> thread start I(35727) OPENTHREAD:[N] Mle-----------: Role disabled -> detached Done > I(36197) OPENTHREAD:[N] Mle-----------: Attach attempt 1, AnyPartition reattaching with Active Dataset I(37007) OPENTHREAD:[N] Mle-----------: RLOC16 fffe -> 2801 I(37007) OPENTHREAD:[N] Mle-----------: Role detached -> child
Imposta il ruolo su Mesh Extender (denominato router nell'interfaccia a riga di comando e nei log).
> state router Done I(46057) OPENTHREAD:[N] Mle-----------: RLOC16 2801 -> 4400 I(46057) OPENTHREAD:[N] Mle-----------: Role child -> router I(46057) OPENTHREAD:[N] Mle-----------: Partition ID 0x28b518c6 >
Ora hai una rete Thread con la topologia mostrata di seguito:
7. Eseguire il ping dell'indirizzo IPv6 tra i nodi Thread
Puoi utilizzare il comando ping per comunicare tra due schede qualsiasi. Utilizza il comando ipaddr per stampare l'indirizzo IPv6 di ogni scheda:
## BR Commissioner ## ---------------------- > ipaddr fd6a:b54b:d6a3:b05a:0:ff:fe00:fc00 # Leader Anycast Locator (ALOC) fd6a:b54b:d6a3:b05a:0:ff:fe00:2c00 # Routing Locator (RLOC) fd6a:b54b:d6a3:b05a:a8df:eb43:63d8:bda0 # Mesh-Local EID (ML-EID) fe80:0:0:0:687c:7248:cc14:9c4d # Link-Local Address (LLA) Done >
## Board1 Joiner ## ---------------------- > ipaddr fd6a:b54b:d6a3:b05a:0:ff:fe00:2800 # Routing Locator (RLOC) fd6a:b54b:d6a3:b05a:e461:db08:c833:1248 # Mesh-Local EID (ML-EID) fe80:0:0:0:18ac:df04:4671:6a45 # Link-Local Address (LLA) Done
## Board2 Joiner ## ---------------------- > ipaddr fd6a:b54b:d6a3:b05a:0:ff:fe00:4400 # Routing Locator (RLOC) fd6a:b54b:d6a3:b05a:d7dc:8e90:9bc9:ecbc # Mesh-Local EID (ML-EID) fe80:0:0:0:a8cc:1483:f696:91a2 # Link-Local Address (LLA) Done
Ad esempio, per eseguire il ping dell'ID MLE della scheda 2 dal commissione del router di confine, puoi eseguire questo comando sul commissione del router di confine:
## BR Commissioner ## ---------------------- > ping fd6a:b54b:d6a3:b05a:d7dc:8e90:9bc9:ecbc 16 bytes from fd6a:b54b:d6a3:b05a:d7dc:8e90:9bc9:ecbc: icmp_seq=1 hlim=255 time=123ms 1 packets transmitted, 1 packets received. Packet loss = 0.0%. Round-trip min/avg/max = 123/123.0/123 ms. Done
8. Trasmettere messaggi tra i nodi Thread con UDP
In questa sessione imparerai a inviare un messaggio tra due dispositivi Thread. Ad esempio, apri UDP, eseguine il binding sulla porta 20617 e ascolta tutti gli indirizzi sul router di confine:
## BR Commissioner ## ---------------------- > udp open Done > udp bind :: 20617 I (1298739) OPENTHREAD: Platform UDP bound to port 20617 Done
Poi invia un messaggio dalla scheda 1 all'indirizzo e alla porta 20617 dell'ID MLE del router di confine:
## Board1 Joiner ## ---------------------- > udp open Done > udp send fd6a:b54b:d6a3:b05a:a8df:eb43:63d8:bda0 20617 ESP
Puoi visualizzare il messaggio ricevuto sul router di confine:
## BR Commissioner ## ---------------------- 3 bytes from fd6a:b54b:d6a3:b05a:e461:db08:c833:1248 49154 ESP
9. Complimenti!
Hai creato una rete Thread fisica utilizzando le schede ESP.
Ora sai:
- Creare e caricare i file binari dell'interfaccia a riga di comando di OpenThread sulle schede ESP.
- Creare e caricare il router di confine sulla scheda del router di confine Thread ESP.
- Gestire manualmente i nodi Thread con ESP Monitor e l'interfaccia a riga di comando di OpenThread.
- Formare una rete Thread sul router di confine Thread.
- Proteggere la messa in servizio dei dispositivi su una rete Thread.
- Eseguire il ping dell'indirizzo IPv6 tra i nodi Thread.
- Trasmettere messaggi tra i nodi Thread con UDP.
Per approfondire
Consulta openthread.io e GitHub per una serie di risorse 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: copre tutti i concetti di Thread trattati in questo codelab
Riferimento: