1. Introducción
OpenThread, lanzado por el equipo de Google Nest, es una implementación de código abierto del protocolo de red Thread® diseñado para acelerar el desarrollo de productos para el hogar conectado. La especificación de Thread define un protocolo de comunicación inalámbrico confiable, seguro y de baja potencia de dispositivo a dispositivo basado en IPv6 para aplicaciones de edificios comerciales y domésticos.
Espressif transfirió la pila de OpenThread basada en FreeRTOS y LwIP, lo que permite a los desarrolladores compilar rápidamente redes Thread. El código fuente relacionado se puede obtener de GitHub. Al mismo tiempo, Espressif también implementó un router de borde Thread basado en RTOS.
En este codelab, programarás OpenThread en hardware real, crearás y administrarás una red Thread y pasarás mensajes entre nodos.
Qué aprenderás
- Compilar y escribir en la memoria flash archivos binarios de la CLI de OpenThread en placas ESP
- Compilar y escribir en la memoria flash el router de borde en la placa del router de borde Thread de ESP
- Administrar manualmente los nodos Thread con ESP Monitor y la CLI de OpenThread
- Formar una red Thread en el router de borde Thread
- Proteger la asignación de dispositivos a una red Thread
- Hacer ping a la dirección IPv6 entre nodos Thread
- Pasar mensajes entre nodos Thread con UDP
Requisitos
Hardware:
Software:
2. Cómo comenzar
- Instalación de ESP-IDF
Sigue la Guía de programación de ESP-IDF para instalar el entorno de desarrollo de software.
- Clona el SDK del router de borde Thread de ESP.
ESP-THREAD-BR es el SDK oficial del router de borde Thread de ESP. Es compatible con todas las funciones de red fundamentales para compilar un router de borde Thread y, además, integra funciones enriquecidas a nivel de producto para una rápida comercialización.
$ cd <your-local-workspace> $ git clone --recursive https://github.com/espressif/esp-thread-br.git
3. Compilación y escritura en la memoria flash
Para compilar y escribir en la memoria flash el archivo binario ot-cli-ftd en placas ESP con módulos IEEE 802.15.4, puedes consultar el ejemplo ot_cli de ESP-IDF para obtener más detalles:
$ cd <your-idf-path>/examples/openthread/ot_cli $ idf.py set-target <your-board-type>
Habilita la función de unión a través de menuconfig:
$ idf.py menuconfig
Component config > OpenThread > Enable Joiner, luego compila y escribe en la memoria flash.
$ idf.py -p <your-local-port> build flash monitor
Para compilar y escribir en la memoria flash el archivo binario ot-br en la placa del router de borde Thread de ESP, primero debes compilar el archivo binario RCP. No es necesario escribir explícitamente este archivo binario RCP en el dispositivo de la placa del router de borde Thread de ESP. Se incluirá en el archivo binario del router de borde y se escribirá en la memoria flash del chip ESP32-H2 en el primer arranque (o se cambiará el firmware RCP). Puedes consultar los documentos de ESP Thread BR para obtener más detalles:
$ 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
Habilita la función de comisionado a través de menuconfig:
$ idf.py menuconfig
Component config > OpenThread > Enable Commissioner, luego compila y escribe en la memoria flash.
$ idf.py -p <your-local-port> build flash monitor
4. Forma una red Thread en el router de borde Thread
Ahora puedes formar una red Thread con la línea de comandos de OpenThread en la placa del router de borde Thread de ESP (comisionado de BR):
## 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
Confirma este conjunto de datos como el activo:
> dataset commit active Done
Activa la interfaz IPv6:
> ifconfig up I (59329) OPENTHREAD: Platform UDP bound to port 49153 Done I (59329) OT_STATE: netif up
Inicia la operación del protocolo 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
Después de un momento, verifica el estado del dispositivo. Debería ser el líder.
> state leader Done >
5. Únete a la red Thread a través de networkkey
En este codelab, se preparan dos placas ESP con módulos IEEE 802.15.4 para unirse a la red formada por BR. En esta sesión, agregaremos Board1 a la red.
Obtén la networkkey de BR:
## BR Commissioner ## ---------------------- > networkkey 731ab6a60a64a0a0b14b259b86b2be01 Done >
Configura esta networkkey en una placa ESP (unión de Board1) con módulos IEEE 802.15.4:
## Board1 Joiner ## ---------------------- > dataset networkkey 731ab6a60a64a0a0b14b259b86b2be01 Done
Confirma este conjunto de datos como el activo:
> dataset commit active Done
Activa la interfaz IPv6:
> ifconfig up Done I (20308) OT_STATE: netif up
Inicia la operación del protocolo 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
Después de un momento, verifica el estado del dispositivo. Debería ser el hijo.
> state child Done
Establece el rol en Mesh Extender (denominado router en la CLI y los registros).
> 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. Únete a la red Thread a través de la asignación segura
En esta sesión, agregaremos Board2 a la red a través de la asignación de seguridad:
Obtén el PSKc y el panid del comisionado de BR:
## BR Commissioner ## ---------------------- > pskc 54e7f18d2575014da94db09df29c5df0 Done > panid 0x1444 Done
Configura la información de la red en Board2:
## Board2 Joiner ## ---------------------- > dataset pskc 54e7f18d2575014da94db09df29c5df0 Done > dataset panid 0x1444 Done
Confirma este conjunto de datos como el activo:
## Board2 Joiner ## ---------------------- > dataset commit active Done
Activa la interfaz IPv6:
## Board2 Joiner ## ---------------------- > ifconfig up Done I (29146) OT_STATE: netif up
Obtén el eui64 de Board2:
## Board2 Joiner ## ---------------------- > eui64 4831b7fffec02be1 Done
En el comisionado de BR, inicia el comisionado y especifica el eui64 del dispositivo que puede unirse, junto con la credencial de unión, por ejemplo, J01NME. La credencial de unión es una cadena específica del dispositivo de todos los caracteres alfanuméricos en mayúscula (0-9 y A-Y, excepto I, O, Q y Z para facilitar la lectura), con una longitud de entre 6 y 32 caracteres.
## BR Commissioner ## ---------------------- > commissioner start Commissioner: petitioning Done Commissioner: active > commissioner joiner add 4831b7fffec02be1 J01NME Done
Cambia a la unión de Board2. Inicia el rol de unión con la credencial de unión que acabas de configurar en el comisionado de BR:
## Board2 Joiner ## ---------------------- > ifconfig up Done > joiner start J01NME Done
En un minuto, recibirás una confirmación de una autenticación exitosa:
## Board2 Joiner ## ---------------------- > Join success
Después de eso, puedes iniciar y unirte a la red Thread formada por el comisionado de BR.
Inicia la operación del protocolo 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
Establece el rol en Mesh Extender (denominado router en la CLI y los registros).
> 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 >
Ahora tienes una red Thread con la topología que se muestra a continuación:
7. Haz ping a la dirección IPv6 entre nodos Thread
Puedes usar el comando ping para comunicarte entre dos placas. Usa el comando ipaddr para imprimir la dirección IPv6 de cada placa:
## 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
Por ejemplo, para hacer ping al MLE-ID de Board2 desde el comisionado de BR, puedes ejecutar este comando en el comisionado de BR:
## 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. Pasa mensajes entre nodos Thread con UDP
En esta sesión, aprenderás a enviar un mensaje entre dos dispositivos Thread. Por ejemplo, abre udp, vincúlalo en el puerto 20617 y escucha todas las direcciones en BR:
## BR Commissioner ## ---------------------- > udp open Done > udp bind :: 20617 I (1298739) OPENTHREAD: Platform UDP bound to port 20617 Done
Luego, envía un mensaje de Board1 a la dirección MLE-ID de BR y al puerto 20617:
## Board1 Joiner ## ---------------------- > udp open Done > udp send fd6a:b54b:d6a3:b05a:a8df:eb43:63d8:bda0 20617 ESP
Puedes ver el mensaje recibido en BR:
## BR Commissioner ## ---------------------- 3 bytes from fd6a:b54b:d6a3:b05a:e461:db08:c833:1248 49154 ESP
9. ¡Felicitaciones!
¡Creaste una red Thread física con placas ESP!
Ahora sabes lo siguiente:
- Compilar y escribir en la memoria flash archivos binarios de la CLI de OpenThread en placas ESP
- Compilar y escribir en la memoria flash el router de borde en la placa del router de borde Thread de ESP
- Administrar manualmente los nodos Thread con ESP Monitor y la CLI de OpenThread
- Formar una red Thread en el router de borde Thread
- Proteger la asignación de dispositivos a una red Thread
- Hacer ping a la dirección IPv6 entre nodos Thread
- Pasar mensajes entre nodos Thread con UDP
Lecturas adicionales
Consulta openthread.io y GitHub para obtener una variedad de recursos de OpenThread, incluidos los siguientes:
- Plataformas compatibles: Descubre todas las plataformas que admiten OpenThread.
- Compila OpenThread: Obtén más detalles para compilar y configurar OpenThread.
- Thread Primer: Abarca todos los conceptos de Thread que se incluyen en este codelab.
Referencia: