Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.
Se usó la API de Cloud Translation para traducir esta página.
Switch to English

Simular una red Thread con OpenThread

26b7f4f6b3ea0700.png

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

La especificación Thread define un protocolo de comunicación de dispositivo a dispositivo inalámbrico confiable, seguro y de bajo consumo basado en IPv6 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.

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

Se requiere XCode para instalar y compilar OpenThread en Mac OS X.

Descarga XCode

Después de instalar 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 comandos de bootstrap garantizan que la cadena de herramientas esté instalada y que 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 OpenThread en Docker

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

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 siguiente figura 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 Thread Router con una sola conexión entre ellos.

6e3aa07675f902dc.png

Hacer ping a un nodo

1. Inicie el nodo 1

Navegue hasta el directorio openthread y openthread el proceso CLI para un dispositivo Thread simulado usando el binario ot-cli-ftd .

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

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 archivo que representa los bits menos significativos del IEEE EUI-64 "asignado de fábrica" ​​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: Utilice únicamente descriptores de archivo de 1 o más como se indica en este Codelab al generar el proceso para un dispositivo simulado. Un descriptor de archivo de 0 está reservado para otro uso.

Si no ves el

>

después de ejecutar este comando, presione

enter

.

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
Master 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 = mesh-local
  • Empieza por fe80 = link-local

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

  • Contiene ff:fe00 = Localizador de enrutadores (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

Abra una nueva terminal y navegue hasta el directorio de openthread y openthread el proceso CLI. Este es su segundo dispositivo Thread simulado:

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

Si no ves el

>

después de ejecutar este comando, presione

enter

.

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

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

En 2 minutos, debería ver el cambio de estado de child a router . Un Thread Router es capaz de enrutar el tráfico entre dispositivos Thread. 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, verifique 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 |

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

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

Prueba la red

Ahora que puede hacer ping correctamente entre dos dispositivos Thread simulados, pruebe la red en malla desconectando un nodo.

Regrese al nodo 1 y detenga el subproceso:

> thread stop
Done

Cambie al nodo 2 y verifique el estado. En dos minutos, el nodo 2 detecta que el líder (nodo 1) está fuera de línea y debería ver la transición del nodo 2 para convertirse en 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

Consulte la Referencia de la CLI de OpenThread para explorar todos los comandos CLI disponibles.

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 subprocesos), los nodos deben estar autenticados.

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

Si no ves el

>

después de ejecutar este comando, presione

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

Permita que cualquier Joiner (utilizando el comodín * ) con la Credencial de Joiner J01NME en marcha 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, habilite la función de J01NME mediante la credencial de J01NME .

> 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

Verifique el state del Nodo 2 para validar que ahora 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 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 presionar enter varias veces para que vuelva a factoryreset el indicador > después de un comando de factoryreset .

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 usa un socket UNIX como entrada y salida, de modo que el núcleo OpenThread puede ejecutarse como un servicio. Un cliente puede comunicarse con este servicio conectándose al socket utilizando la CLI OpenThread como protocolo.

ot-ctl es una CLI proporcionada por ot-daemon para administrar y configurar el RCP. 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. proceso ot-daemon
  3. instancia de CLI ot-ctl

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

Si no ves el

>

después de ejecutar este comando, presione

enter

.

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

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 el paso de red Simular un subproceso , una dirección es local de enlace ( fe80 ) y tres son local de malla ( fd ). El EID es la dirección local de malla que no contiene ff:fe00 en la dirección. En esta salida de muestra, el EID es fd55:cf34:dea5:7994:460:872c:e807:c4ab .

Identifique el EID específico de la salida de su ipaddr , que se utilizará para comunicarse con el nodo.

2. Inicie ot-daemon

En la segunda ventana de terminal, navegue hasta el directorio openthread e inicie ot-daemon para un nodo RCP, al que llamaremos Nodo 2. Use la -v verbose 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 modo detallado 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

3. Use ot-ctl para unirse a la red

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

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

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

Verifique el state del Nodo 2 (el nodo RCP) que comenzó con ot-daemon :

> state
disabled
Done

Obtenga eui64 del Nodo 2, para restringir la unión al Joiner específico:

> eui64
18b4300000000001
Done

En el nodo 1, 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, 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

Verifique el state del Nodo 2 para validar que ahora se haya unido a la red. En dos minutos, el nodo 2 pasa de child a router :

> state
child
Done
...
> state
router
Done

5. Validar la conectividad

Salga de ot-ctl usando Ctrl + D y en la línea de comando de su máquina host, ping6 ping al Nodo 1, usando su EID con el comando ping6 . Si la instancia de ot-daemon RCP se une correctamente a la red Thread y se comunica con ella, el ping se realiza correctamente:

$ 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

Ha simulado con éxito su primera red Thread usando OpenThread. ¡Increíble!

En este Codelab aprendiste cómo:

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

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