Simular una red Thread con OpenThread

1. Introducción

26b7f4f6b3ea0700.png

OpenThread lanzado por Google es una implementación de código abierto de la rosca protocolo de red. Google Nest ha lanzado OpenThread para hacer que la tecnología utilizada en los productos Nest esté ampliamente disponible para los desarrolladores a fin de acelerar el desarrollo de productos para el hogar conectado.

La especificación de rosca define un protocolo de comunicación basada en IPv6 fiable, seguro y de bajo consumo inalámbrico de dispositivo a dispositivo para aplicaciones domésticas. OpenThread implementa todas las capas de red de Thread, incluidas IPv6, 6LoWPAN, IEEE 802.15.4 con seguridad MAC, establecimiento de enlace de malla y enrutamiento de malla.

Este Codelab lo guía a través de la simulación de una red Thread en dispositivos simulados.

Lo que aprenderás

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

Lo que necesitarás

  • git
  • Conocimientos básicos de Linux, enrutamiento de red.

2. Configure el sistema de compilación

Git

Se requiere Git para completar este Codelab. Descárguelo e instálelo antes de continuar.

Descarga Git

Una vez instalado, siga las instrucciones de su sistema operativo específico para descargar y compilar OpenThread.

XCode para Mac OS X

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

Descarga XCode

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

$ xcode-select --install

Construir en Linux / Mac OS X

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

Instale OpenThread. Los bootstrap comandos asegurarse de que está instalado el conjunto de herramientas y el entorno está configurado correctamente:

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

Usando Windows

Si prefiere Windows, le recomendamos que pruebe la versión Docker de este Codelab.

Simulación de OpenThread en Docker

3. Cree las aplicaciones OpenThread

Una vez que se complete la instalación, cree la aplicación OpenThread de ejemplo. Para este Codelab estamos usando el ejemplo de simulación.

$ cd ~/src/openthread
$ make -f examples/Makefile-simulation

Ahora compile OpenThread Daemon:

$ cd ~/src/openthread
$ make -f src/posix/Makefile-posix DAEMON=1

4. Simular una red de subprocesos

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

Este ejercicio lo lleva a través de los pasos mínimos necesarios para hacer ping a un dispositivo Thread simulado desde otro dispositivo Thread simulado.

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

6e3aa07675f902dc.png

Hacer ping a un nodo

1. Inicie el nodo 1

Vaya a la openthread directorio y generar el proceso de CLI para un dispositivo de rosca simulado utilizando el ot-cli-ftd binario.

$ cd ~/src/openthread
$ ./output/simulation/bin/ot-cli-ftd 1

Nota: Si no ve la > pronta después de ejecutar este comando, pulse enter .

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

El argumento de 1 es un descriptor de fichero que representa los bits menos significativos de la "fábrica-asignado" IEEE EUI-64 para el dispositivo simulado. Este valor también se utiliza cuando se vincula 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 utilizará un descriptor de archivo diferente.

Nota: Sólo los descriptores de fichero uso de 1 o mayor como se indica en este experimento de código cuando el proceso de desove para un dispositivo simulado. Un descriptor de archivo de 0 está reservado para otro uso.

Cree un nuevo conjunto de datos operativos y consúltelo como activo. El conjunto de datos operativo es la configuración de la red de subprocesos que está 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

Confirme este conjunto de datos como activo:

> dataset commit active
Done

Abra la interfaz IPv6:

> ifconfig up
Done

Iniciar la operación del protocolo Thread:

> thread start
Done

Espere unos segundos y verifique que el dispositivo se haya convertido en el líder del hilo. El líder es el dispositivo responsable de administrar la asignación de ID de enrutador.

> state
leader
Done

Vea las direcciones IPv6 asignadas a la interfaz Thread del Nodo 1 (su salida 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

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

  • Comienza con fd = malla local
  • Comienza con fe80 = de enlace local

Los tipos de direcciones locales de malla se clasifican además:

  • Contiene ff:fe00 = Router Locator (RLOC)
  • No contiene ff:fe00 = Identificador de punto final (EID)

Identifique el EID en la salida de su consola y anótelo para su uso posterior. En el resultado de muestra anterior, el EID es:

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

2. Inicie el nodo 2

Abrir una nueva terminal y vaya a la openthread directorio y generar el proceso de CLI. Este es su segundo dispositivo Thread simulado:

$ cd ~/src/openthread
$ ./output/simulation/bin/ot-cli-ftd 2

Nota: Si no ve la > pronta después de ejecutar este comando, pulse enter .

Configure la clave de red de subprocesos y el ID de PAN, utilizando los mismos valores que el conjunto de datos operativos del nodo 1:

> dataset networkkey e4344ca17d1dca2a33f064992f31f786
Done
> dataset panid 0xc169
Done

Confirme este conjunto de datos como activo:

> dataset commit active
Done

Abra la interfaz IPv6:

> ifconfig up
Done

Iniciar la operación del protocolo Thread:

> thread start
Done

El dispositivo se inicializará como un niño. Un subproceso secundario es equivalente a un dispositivo final, que es un dispositivo subproceso que transmite y recibe tráfico de unidifusión solo con un dispositivo principal.

> state
child
Done

Dentro de 2 minutos se debe ver el interruptor de estado del child al router . Un enrutador de subprocesos es capaz de enrutar el tráfico entre dispositivos de subprocesos. También se le conoce como padre.

> state
router
Done

Verifica la red

Una forma fácil de verificar la red de malla es mirar la tabla del enrutador.

1. Verifique la conectividad

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

> rloc16
5800
Done

En el nodo 1, consulte la tabla del enrutador para el RLOC16 del nodo 2. Asegúrese de que el nodo 2 haya cambiado al estado del enrutador primero.

> 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 |

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

Verifique la conectividad entre los dos dispositivos Thread simulados. En el nodo 2, ping la 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

Presione enter para volver a la > CLI del sistema.

Prueba la red

Ahora que puede hacer ping con éxito entre dos dispositivos Thread simulados, pruebe la red de malla desconectando un nodo.

Regrese al nodo 1 y detenga el subproceso:

> thread stop
Done

Cambie al Nodo 2 y verifique el estado. Al cabo de dos minutos, el nodo 2 detecta que el líder (Nodo 1) no está en línea, y usted debe ver el nodo 2 transición a ser el leader de la red:

> state
router
Done
...
> state
leader
Done

Una vez confirmado, detenga Thread y restablezca los valores 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 restablecimiento de fábrica y salida del nodo 1:

> factoryreset
>
> exit

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

5. Autenticar nodos con puesta en servicio

En el ejercicio anterior, configuró una red Thread con dos dispositivos simulados y conectividad verificada. Sin embargo, esto solo permite que el tráfico local de enlace IPv6 no autenticado pase entre dispositivos. Para enrutar el tráfico IPv6 global entre ellos (e Internet a través de un enrutador de borde de subproceso), los nodos deben estar autenticados.

Para autenticarse, un dispositivo debe actuar como comisionado. El Comisionado es el servidor de autenticación actualmente elegido 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 Thread Leader actuará como Comisionado, el Thread Router como Joiner.

d6a67e8a0d0b5dcb.png

1. Crea una red

Si continúa desde el ejercicio anterior, ya debería tener dos ventanas de terminal abiertas. Si no es así, asegúrese de que dos estén abiertos y listos para usar. Uno servirá como Nodo 1, el otro como Nodo 2.

En el nodo 1, genere el proceso CLI:

$ cd ~/src/openthread
$ ./output/simulation/bin/ot-cli-ftd 1

Nota: Si no ve la > pronta después de ejecutar este comando, pulse enter .

Cree un nuevo conjunto de datos operativos, consúltelo como activo e inicie 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

Confirme este conjunto de datos como activo:

> dataset commit active
Done

Abra la interfaz IPv6:

> ifconfig up
Done

Iniciar la operación del protocolo Thread:

> thread start
Done

Espere unos segundos y verifique que el dispositivo se haya convertido en un líder de hilo:

> state
leader
Done

2. Iniciar el rol de Comisionado

Mientras todavía está en el Nodo 1, comience el rol de Comisionado:

> commissioner start
Done

Permitir que cualquier Joiner (utilizando el * comodín) con el J01NME Joiner Credencial de comisión en la red. Un Joiner es un dispositivo que agrega un administrador humano a una red de subprocesos encargada.

> commissioner joiner add * J01NME
Done

3. Inicie el rol Joiner

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

$ cd ~/src/openthread
$ ./output/simulation/bin/ot-cli-ftd 2

En el nodo 2, habilitar la función de Joiner utilizando el J01NME Joiner credencial.

> ifconfig up
Done
> joiner start J01NME
Done

... espera unos segundos la confirmación ...

Join success

Como Joiner, el dispositivo (Nodo 2) se ha autenticado exitosamente con el Comisionado (Nodo 1) y ha recibido las credenciales de Thread Network.

Ahora que el Nodo 2 está autenticado, inicie Thread:

> thread start
Done

4. Validar la autenticación de red

Comprobar el state en el nodo 2, para validar que ahora se ha unido a la red. Al cabo de dos minutos, el nodo 2 transiciones del child a router :

> state
child
Done
...
> state
router
Done

5. Restablecer la configuración

Para prepararse para el próximo ejercicio, restablezca la configuración. En cada nodo, detenga Thread, realice un restablecimiento de fábrica y salga del dispositivo Thread simulado:

> thread stop
Done
> factoryreset
>
> exit

Puede que tenga que presione enter un par de veces para que la > vuelta rápida después de un factoryreset comando.

6. Administre la red con OpenThread Daemon

Para este ejercicio, vamos a simular una instancia de CLI (un único dispositivo de subproceso SoC integrado) y una instancia de coprocesador de radio (RCP).

ot-daemon es un modo de la aplicación OpenThread Posix que utiliza un socket UNIX como entrada y salida, de modo que OpenThread núcleo puede funcionar como un servicio. Un cliente puede comunicarse con este servicio conectándose al socket utilizando OpenThread CLI como protocolo.

ot-ctl es una CLI proporcionada por ot-daemon para administrar y configurar el PCR. Usando esto, conectaremos el RCP a la red creada por el dispositivo Thread.

Utilice ot-daemon

Este ejercicio utilizará tres ventanas de terminal, correspondientes a lo siguiente:

  1. Instancia CLI del dispositivo Thread simulado (nodo 1)
  2. ot-daemon proceso
  3. ot-ctl ejemplo CLI

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

1. Inicie el nodo 1

En la primera ventana de terminal, genere el proceso CLI para su dispositivo Thread simulado:

$ cd ~/src/openthread
$ ./output/simulation/bin/ot-cli-ftd 1

Nota: Si no ve la > pronta después de ejecutar este comando, pulse enter .

Cree un nuevo conjunto de datos operativos, consúltelo como activo e 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

Confirme este conjunto de datos como activo:

> dataset commit active
Done

Abra la interfaz IPv6:

> ifconfig up
Done

Iniciar la operación del protocolo Thread:

> thread start
Done

Vea las direcciones IPv6 asignadas a la interfaz 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 explica en la Simular un paso red de rosca, una dirección es de enlace local ( fe80 ) y tres son de malla-local ( fd ). La EID es la dirección de malla local que no contiene ff:fe00 en la dirección. En este ejemplo de salida, la DIA es fd55:cf34:dea5:7994:460:872c:e807:c4ab .

Identificar la identificación electrónica específica de su ipaddr de salida, que será utilizado para comunicarse con el nodo.

2. Inicie ot-daemon

En la segunda ventana de terminal, vaya a la openthread directorio y empezar a ot-daemon para un nodo RCP, que llamaremos Nodo 2. Uso del -v verboso bandera para que pueda ver la salida del registro y confirmar que se está ejecutando:

$ cd ~/src/openthread
$ ./output/posix/bin/ot-daemon -v \
    'spinel+hdlc+forkpty://output/simulation/bin/ot-rcp?forkpty-arg=2'

Cuando tiene éxito, ot-daemon en verbosa modo genera una salida similar a la siguiente:

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

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

3. Utilice ot-ctl para unirse a la red

No hemos encargado Nodo 2 (el ot-daemon RCP) a cualquier red de rosca todavía. Aquí es donde ot-ctl entra en acción. ot-ctl utiliza la misma CLI como la aplicación OpenThread CLI. Por lo tanto, se puede controlar ot-daemon nodos de la misma manera que los otros dispositivos de rosca simulados.

En una tercera ventana de terminal, iniciar ot-ctl :

$ ./output/posix/bin/ot-ctl
>

Vamos a usar ot-ctl en esta tercera ventana de terminal para gestionar el nodo 2 (el nodo RCP) que inició en la segunda ventana de terminal con ot-daemon . Compruebe el state del nodo 2:

> state
disabled
Done

Obtener del Nodo 2 eui64 , para restringir unirse a la específica Joiner:

> eui64
18b4300000000001
Done

En el Nodo 1 (primera ventana de terminal), inicie el Comisionado y restrinja la unión solo a ese eui64:

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

En el Nodo 2 (tercera ventana de terminal), abra la interfaz de red y únase a la red:

> ifconfig up
Done
> joiner start J01NME
Done

... espera unos segundos la confirmación ...

Join success

Como Joiner, el RCP (Nodo 2) se ha autenticado exitosamente con el Comisionado (Nodo 1) y ha recibido las credenciales de Thread Network.

Ahora únase al Nodo 2 a la red Thread:

> thread start
Done

4. Validar la autenticación de red

Comprobar el state en el nodo 2, para validar que ahora se ha unido a la red. Al cabo de dos minutos, el nodo 2 transiciones del child a router :

> state
child
Done
...
> state
router
Done

5. Validar la conectividad

Dejar de ot-ctl usando Ctrl + D y en la línea de comandos del ordenador central, mesa de ping Nodo 1, utilizando su identificación electrónica con el ping6 comando. Si el ot-daemon ejemplo PCR se unió con éxito y comunicación con la red de rosca, 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!

Ha simulado con éxito su primera red Thread utilizando OpenThread. ¡Impresionante!

En este Codelab aprendiste cómo:

  • Configurar la cadena de herramientas de compilación de OpenThread
  • Simular una red de subprocesos
  • Autenticar nodos de subprocesos
  • Administrar una red de subprocesos con OpenThread Daemon

Si desea obtener más información, explore estas referencias: