Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

Cómo simular una red Thread con OpenThread

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

1. Introducción

26b7f4f6b3ea0700.png

OpenThread, lanzado por Google, es una implementación de código abierto del protocolo de red Thread. Google Nest lanzó OpenThread para poner a disposición de los desarrolladores la tecnología que se usa en los productos Nest a fin de acelerar el desarrollo de productos para el hogar conectado.

La especificación de Thread define un protocolo de comunicación de dispositivos inalámbricos, confiable, seguro y de bajo consumo basado en IPv6 para las aplicaciones del hogar. OpenThread implementa todas las capas de herramientas de redes de Thread, incluidas IPv6, 6LoWPAN, IEEE 802.15.4 con seguridad MAC, establecimiento de vínculos de malla y enrutamiento de malla.

En este codelab, se explica cómo simular una red Thread en dispositivos simulados.

Qué aprenderás

  • Cómo configurar la cadena de herramientas de compilación de OpenThread
  • Cómo simular una red Thread
  • Cómo autenticar nodos de Thread
  • Cómo administrar una red Thread con Daemon de OpenThread

Requisitos

  • git
  • Conocimiento básico de Linux, enrutamiento de red

2. Cómo configurar el sistema de compilación

Git

Se requiere Git para completar este Codelab. Descárgala e instálala antes de continuar.

Una vez instalado, sigue las instrucciones de tu SO específico para descargar y compilar OpenThread.

XCode para Mac OS X

XCode es necesario para instalar y compilar OpenThread en Mac OS X.

Una vez instalado XCode, instala las herramientas de línea de comandos XCode:

$ xcode-select --install

Compila en Linux / Mac OS X

Estas instrucciones de instalación se probaron en Ubuntu Server 14.04 LTS y Mac OS X Sierra 10.12.6.

Instala OpenThread. Los comandos bootstrap garantizan que la cadena de herramientas esté instalada y que el entorno esté configurado de forma correcta:

$ mkdir -p ~/src
$ cd ~/src
$ git clone --recursive https://github.com/openthread/openthread.git
$ cd openthread
$ ./script/bootstrap
$ ./bootstrap

Uso de Windows

Si prefieres Windows, te recomendamos que pruebes la versión de Docker de este Codelab.

3. Cómo compilar las aplicaciones de OpenThread

Cuando se complete la instalación, compila la aplicación de ejemplo de OpenThread. Para este Codelab, usamos el ejemplo de simulación.

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

Ahora compila el daemon de OpenThread:

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

4. Simula una red Thread

La aplicación de ejemplo que usarás en este Codelab demuestra una aplicación mínima de OpenThread que expone la configuración y las interfaces de administración de OpenThread a través de una interfaz de línea de comandos (CLI).

Este ejercicio te guiará por los pasos mínimos necesarios para hacer ping a un dispositivo Thread simulado desde otro dispositivo Thread simulado.

En la siguiente figura, se describe una topología básica de red de Thread. Para este ejercicio, simularemos los dos nodos dentro del círculo verde: un líder de subprocesos y un router de subprocesos con una sola conexión entre ellos.

6e3aa07675f902dc.png

Haz ping en un nodo

1. Iniciar Node 1

Navega al directorio openthread y genera el proceso de la CLI para un dispositivo Thread simulado con el objeto binario ot-cli-ftd.

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

Nota: Si no ves el mensaje > después de ejecutar este comando, presiona enter.

Este objeto binario implementa un dispositivo OpenThread simulado sobre POSIX. El controlador de radio IEEE 802.15.4 se implementa sobre UDP (los marcos IEEE 802.15.4 se pasan dentro de cargas útiles de UDP).

El argumento de 1 es un descriptor de archivo que representa los bits menos significativos del IEEE EUI-64 para el dispositivo simulado. Este valor también se usa cuando se realiza una vinculación a un puerto UDP para la emulación de radio IEEE 802.15.4 (puerto = 9000 + descriptor de archivo). Cada instancia de un dispositivo Thread simulado en este Codelab usará un descriptor de archivos diferente.

Nota: Solo usa descriptores de archivos de 1 o superior como se indica en este Codelab cuando generes el proceso para un dispositivo simulado. Un descriptor de archivos de 0 está reservado para otro uso.

Crear un nuevo conjunto de datos operativo y confirmarlo como el activo El conjunto de datos operativo es la configuración de la red Thread que estás 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

Confirma este conjunto de datos como el activo:

> dataset commit active
Done

Abre la interfaz de IPv6:

> ifconfig up
Done

Inicia la operación del protocolo Thread:

> thread start
Done

Espera unos segundos y verifica que el dispositivo se haya convertido en el líder de subprocesos. El líder es el dispositivo responsable de administrar la asignación de ID de router.

> state
leader
Done

Visualiza las direcciones IPv6 asignadas a la interfaz de Thread del nodo 1 (tu resultado será diferente):

> 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

Ten en cuenta los tipos de direcciones IPv6 específicos:

  • Comienza con fd = malla local
  • Comienza con fe80 = local-vínculo

Los tipos de dirección locales en malla se clasifican aún más:

  • Contiene ff:fe00 = Localizador de router (RLOC)
  • No contiene ff:fe00 = Identificador de extremo (EID)

Identifica el EID en el resultado de tu consola y anótalo para usarlo más adelante. En el resultado de muestra anterior, el EID es el siguiente:

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

2. Iniciar Node 2

Abre una terminal nueva, navega al directorio openthread y genera el proceso de la CLI. Este es tu segundo dispositivo Thread simulado:

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

Nota: Si no ves el mensaje > después de ejecutar este comando, presiona enter.

Configura la clave de red de Thread y el PAN con los mismos valores que el conjunto de datos operativo del nodo 1:

> dataset networkkey e4344ca17d1dca2a33f064992f31f786
Done
> dataset panid 0xc169
Done

Confirma este conjunto de datos como el activo:

> dataset commit active
Done

Abre la interfaz de IPv6:

> ifconfig up
Done

Inicia la operación del protocolo Thread:

> thread start
Done

El dispositivo se inicializará como secundario. Un subproceso secundario es un dispositivo final, que es un dispositivo Thread que transmite y recibe tráfico de unidifusión solo con un dispositivo superior.

> state
child
Done

En dos minutos, deberías ver el cambio de estado de child a router. Un router de subprocesos es capaz de enrutar el tráfico entre dispositivos de subprocesos. También se la conoce como superior.

> state
router
Done

Verifica la red

Una manera sencilla de verificar la red en malla es mirar la tabla del router.

1. Verifica la conectividad

En el nodo 2, obtén el RLOC16. El RLOC16 son los últimos 16 bits de la dirección IPv6 de RLOC del dispositivo.

> rloc16
5800
Done

En el nodo 1, verifica la tabla de router para el RLOC16 del nodo 2. Primero, asegúrate de que el nodo 2 haya cambiado al estado 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 |

El RLOC del nodo 1 de 0xa800 se encuentra en la tabla, lo que confirma que está conectado a la malla.

2. Hacer ping al nodo 1 desde el nodo 2

Verifica la conectividad entre los dos dispositivos Thread simulados. En el Nodo 2, ping, el EID asignado 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

Presiona enter para volver al mensaje de la CLI de >.

Prueba la red

Ahora que puedes hacer ping correctamente entre dos dispositivos Thread simulados, prueba la red en malla dejando un nodo sin conexión.

Regresa al nodo 1 y detén el subproceso:

> thread stop
Done

Cambia a Node 2 y verifica el estado. En dos minutos, el Nodo 2 detecta que el líder (Nodo 1) está sin conexión, y deberías ver que la transición del Nodo 2 es el leader de la red:

> state
router
Done
...
> state
leader
Done

Una vez confirmado, detén el subproceso y restablece la configuración de fábrica del nodo 2 antes de salir. Se realiza un restablecimiento de fábrica para garantizar que las credenciales de red de Thread que usamos en este ejercicio no se transfieran al siguiente ejercicio.

> thread stop
Done
> factoryreset
>
> exit

También restablece la configuración de fábrica y sal del nodo 1:

> factoryreset
>
> exit

Consulta la referencia de la CLI de OpenThread para explorar todos los comandos de la CLI disponibles.

5. Autenticar nodos con puesta en marcha

En el ejercicio anterior, configuraste una red Thread con dos dispositivos simulados y conectividad verificada. Sin embargo, esto solo permite que el tráfico local IPv6 no autenticado pase entre dispositivos. Para enrutar el tráfico IPv6 global entre estos (y la Internet a través de un router de borde de Thread), se deben autenticar los nodos.

Para autenticarse, un dispositivo debe actuar como comisionado. El comisionado es el servidor de autenticación electo para los nuevos dispositivos Thread y el autorizador para proporcionar las credenciales de red necesarias para que los dispositivos se unan a la red.

En este ejercicio, usaremos la misma topología de dos nodos que antes. Para la autenticación, el líder de subproceso actúa como Comisionado, el router de subprocesos como tal.

d6a67e8a0d0b5dcb.png

1. Crea una red

Si continúa con el ejercicio anterior, ya debería tener abiertas dos ventanas de la terminal. De lo contrario, asegúrate de que dos estén abiertas y listas para usar. Uno servirá como Nodo 1 y el otro como Nodo 2.

En el nodo 1, genera el proceso de la CLI:

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

Nota: Si no ves el mensaje > después de ejecutar este comando, presiona enter.

Cree un nuevo conjunto de datos operativo, confírmelo como el activo y, luego, inicie el subproceso:

> 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

Confirma este conjunto de datos como el activo:

> dataset commit active
Done

Abre la interfaz de IPv6:

> ifconfig up
Done

Inicia la operación del protocolo Thread:

> thread start
Done

Espera unos segundos y verifica que el dispositivo se haya convertido en líder de Thread:

> state
leader
Done

2. Inicie el rol de comisionado

En el nodo 1, inicia la función de comisionado:

> commissioner start
Done

Permitir que cualquier Unión (con el comodín *) con la Credencial J01NME se encargue en la red. Un Joiner es un dispositivo que agrega un administrador humano a una red Thread encargada.

> commissioner joiner add * J01NME
Done

3. Inicie el rol de Unión

En una segunda ventana de la terminal, genera un nuevo proceso de CLI. Este es el nodo 2.

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

En el nodo 2, habilite la función de unión con la credencial de unión J01NME.

> ifconfig up
Done
> joiner start J01NME
Done

Espera unos segundos para recibir la confirmación...

Join success

Como Unión, el dispositivo (Nodo 2) se autenticó correctamente con el Comisionado (Nodo 1) y recibió las credenciales de la Red de subprocesos.

Ahora que el nodo 2 está autenticado, inicia el subproceso:

> thread start
Done

4. Valida la autenticación de la red

Verifica el state en el nodo 2 para validar que se haya unido a la red. En dos minutos, el nodo 2 pasa de child a router:

> state
child
Done
...
> state
router
Done

5. Restablecer configuración

A fin de prepararte para el próximo ejercicio, restablece la configuración. En cada nodo, detén Thread, restablece la configuración de fábrica y sal del dispositivo Thread simulado:

> thread stop
Done
> factoryreset
>
> exit

Es posible que debas presionar enter varias veces para que devuelva el mensaje > después de un comando factoryreset.

6. Cómo administrar la red con OpenThread Daemon

Para este ejercicio, simularemos una instancia de CLI (un solo dispositivo SoC Thread incorporado) y una instancia de radioprocesador (RCP).

ot-daemon es un modo de la app de OpenThread Posix que usa un socket UNIX como entrada y salida para que se pueda ejecutar el núcleo de OpenThread como servicio. Un cliente puede comunicarse con este servicio si se conecta al socket con la CLI de OpenThread como protocolo.

ot-ctl es una CLI que proporciona ot-daemon para administrar y configurar el RCP. Con esto, conectaremos el RCP a la red que crea el dispositivo Thread.

Usar ot-daemon

En este ejercicio, se usarán tres ventanas de terminal, que corresponden a lo siguiente:

  1. Instancia de CLI del dispositivo Thread simulado (nodo 1)
  2. Proceso ot-daemon
  3. ot-ctl instancia de CLI

Si continúa desde el ejercicio anterior, debería tener dos ventanas de terminales abiertas. Abra un tercero para asegurarse de tener tres ventanas de terminal disponibles para este ejercicio.

1. Iniciar Node 1

En la primera ventana de la terminal, genera el proceso de la CLI para tu dispositivo Thread simulado:

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

Nota: Si no ves el mensaje > después de ejecutar este comando, presiona enter.

Cree un nuevo conjunto de datos operativo, confírmelo como el activo y, luego, inicie el subproceso:

> 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

Confirma este conjunto de datos como el activo:

> dataset commit active
Done

Abre la interfaz de IPv6:

> ifconfig up
Done

Inicia la operación del protocolo Thread:

> thread start
Done

Visualiza las direcciones IPv6 asignadas a la interfaz de 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
>

Como se explicó en el paso Simula una red Thread, una dirección es local de vínculo (fe80) y tres son locales de malla (fd). El EID es la dirección de malla local que no contiene ff:fe00 en la dirección. En este resultado de muestra, el EID es fd55:cf34:dea5:7994:460:872c:e807:c4ab.

Identifica el EID específico del resultado de ipaddr, que se usará para comunicarse con el nodo.

2. Iniciar ot-daemon

En la segunda ventana de la terminal, navega al directorio openthread e inicia ot-daemon para un nodo RCP, al que llamaremos Node 2. Usa la marca detallada -v para ver el resultado del registro, confirmar que se está ejecutando y asegurarte de usar 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'

Cuando se ejecuta de forma correcta, ot-daemon en el modo detallado genera un resultado similar al siguiente:

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

Deje esta terminal abierta y ejecutándose en segundo plano. No ingresarás más comandos.

3. Use ot-ctl para unirse a la red

Aún no encargamos el Nodo 2 (el RCP de ot-daemon) a ninguna red Thread. Aquí es donde ot-ctl entra en juego. ot-ctl usa la misma CLI que la app de CLI de OpenThread. Por lo tanto, puedes controlar los nodos ot-daemon de la misma manera que los otros dispositivos de Thread simulados.

En una tercera ventana de la terminal, inicia ot-ctl:

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

Nota: Si no ves el mensaje > después de ejecutar este comando, presiona enter.

Usarás ot-ctl en esta tercera ventana de la terminal para administrar el Nodo 2 (el nodo RCP) que iniciaste en la segunda ventana de la terminal con ot-daemon. Verifica el state del nodo 2:

> state
disabled
Done

Obtén el eui64 del nodo 2 para restringir la unión a la unión específica:

> eui64
18b4300000000001
Done

En el Nodo 1 (primera ventana de la terminal), inicia el Comisionado y restringe la unión a ese eui64 únicamente:

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

En Node 2 (tercera ventana de la terminal), abre la interfaz de red y únete a la red:

> ifconfig up
Done
> joiner start J01NME
Done

Espera unos segundos para recibir la confirmación...

Join success

Como Unión, el RCP (Nodo 2) se autenticó correctamente con el Comisionado (Nodo 1) y recibió las credenciales de la Red de subprocesos.

Ahora, une el nodo 2 a la red Thread:

> thread start
Done

4. Valida la autenticación de la red

Verifica el state en el nodo 2 para validar que se haya unido a la red. En dos minutos, el nodo 2 pasa de child a router:

> state
child
Done
...
> state
router
Done

5. Valida la conectividad

Sal de ot-ctl mediante el comando Ctrl+D o exit, y en la línea de comandos de tu máquina anfitrión, haz ping al nodo 1 usando el EID con el comando ping6. Si la instancia de RCP ot-daemon se unió correctamente a la red Thread y se está comunicando con ella, el ping tiene éxito:

$ 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. ¡Felicitaciones!

Simulaste correctamente tu primera red Thread con OpenThread. ¡Genial!

En este Codelab aprendiste a hacer lo siguiente:

  • Configura la cadena de herramientas de compilación de OpenThread
  • Simula una red Thread
  • Autentica los nodos de subprocesos
  • Cómo administrar una red Thread con Daemon de OpenThread

Si quieres obtener más información, explora estas referencias: