Crea una red Thread con la placa de desarrollo B91 y OpenThread

1. Introducción

OpenThread es una implementación de código abierto del protocolo de red Thread®, que es un protocolo de red en malla inalámbrico sólido y seguro diseñado para los dispositivos de la Internet de las cosas (IoT). OpenThread fue desarrollado por el equipo de Nest de Google y está disponible sin costo para la comunidad de desarrolladores como un proyecto de código abierto.

La Especificación de Thread establece un protocolo de comunicación inalámbrico confiable, seguro y de bajo consumo para dispositivos con recursos limitados que se encuentran comúnmente en casas inteligentes y edificios comerciales. OpenThread incluye el alcance completo de la capa de red dentro de Thread, como IPv6, 6LoWPAN, IEEE 802.15.4 con seguridad MAC, establecimiento de vínculos de malla y enrutamiento de malla.

Telink integró la implementación de OpenThread a las RTOS de Zephyr, lo que permite una compatibilidad perfecta con el hardware de Telink. El código fuente de esta integración es de fácil acceso en GitHub y también se proporciona como un kit de desarrollo de software (SDK).

En este codelab, programarás OpenThread en hardware real, crearás y administrarás una red Thread, y también intercambiarás mensajes entre nodos. En la siguiente imagen, se muestra la configuración de hardware, con un router de borde OT (OTBR) y un dispositivo Thread en el codelab.

Qué aprenderás

• Configurar la implementación de OpenThread con el entorno de desarrollo de Telink Zephyr
• Para compilar las muestras de la CLI de OpenThread (ot-cli-ftd y ot-rcp) y escribirlas en la placa de desarrollo de Telink B91
• Para configurar un router de borde de OpenThread (OTBR) con Docker en una Raspberry Pi 3B o una versión posterior.
• Para crear una red Thread en OTBR
• Para agregar dispositivos a la red Thread con depuración fuera de banda
• Para validar la conectividad entre nodos en la red de Thread con la CLI.

Qué necesitarás

Hardware:

• Dos placas de desarrollo B91.
• One Raspberry Pi 3B o una versión posterior con Raspbian OS Image.
• Una máquina Linux con al menos dos puertos USB
• Un conmutador conectado a Internet (o router) y varios cables Ethernet

Software:

• Herramienta Telink Burning and Debugging — LinuxBDT.
• Herramienta de terminal del puerto en serie, como PuTTY.
• Otras herramientas, como Git y West

2. Requisitos previos

Conceptos de Thread y CLI de OpenThread

Puede resultarte útil revisar el codelab de simulación de OpenThread para familiarizarte con los conceptos fundamentales de Thread y la CLI de OpenThread antes de este codelab.

Máquina Linux

La máquina Linux (Ubuntu 20.04 LTS o posterior) actúa como la máquina de compilación para configurar el entorno de desarrollo de Telink Zephyr y escribir en la memoria flash todas las placas de desarrollo de Thread. Para realizar estas tareas, la máquina Linux requiere dos puertos USB y conectividad a Internet disponibles.

Terminales y conexión a puertos en serie

Puedes conectar el dispositivo directamente al puerto USB de la máquina Linux. Además, necesitarás una herramienta de terminal para puertos en serie a fin de acceder a los dispositivos.

En este codelab, la herramienta de terminal PuTTY se usa para controlar la unión del FTD y Raspberry Pi. Ofrece una descripción general de su uso, pero también se puede utilizar otro software de terminal.

Kit de desarrollo Telink B91

En este codelab, se necesitan dos conjuntos de kits de desarrollo B91. La siguiente foto muestra los componentes mínimos necesarios en un conjunto.

Uno de estos kits se usará como RCP (coprocesador de radio), mientras que el otro funcionará como FTD (dispositivo de subproceso completo). Si aún no tienes el kit, puedes obtener más detalles en el sitio web oficial de Telink. Estos son algunos componentes que se usarán:

Raspberry Pi 3B+ o una versión posterior con Raspbian OS Image

En este codelab, se necesita una Raspberry Pi 3B o una versión posterior con la imagen de Raspbian Bullseye Lite OS o Raspbian Bullseye con computadora de escritorio. Está conectado a Internet mediante Ethernet y se configurará como host del router de borde abierto (OTBR) de OpenThread.

Conexión de red

Un conmutador (o router) conectado a Internet y varios cables Ethernet Se usan para conectar Raspberry Pi a la máquina Linux, lo que facilita la configuración de Raspberry Pi a través del host.

BDT de Linux

La herramienta de grabación y depuración (BDT) de Telink, que se aplica a todas las series de chips Telink, te permite borrar y actualizar el firmware de OpenThread en las placas de desarrollo Telink B91. Instala la versión de linuxBDT de Linux basada en X86 en tu máquina de Linux.

Otras preguntas

• Git, para configurar el entorno de desarrollo de Telink Zephyr.
• West, para administrar el proyecto Zephyr y compilar objetos binarios de OpenThread.

3. Configura el firmware

Configura el entorno de desarrollo de Telink Zephyr

En la máquina de Linux, abre una terminal de CLI y comienza a ejecutar los siguientes comandos para asegurarte de que tu APT esté actualizado.

$ sudo apt update
$ sudo apt upgrade

Una vez que lo hayas hecho, continúa con los siguientes pasos.

1. Instala las dependencias.

   $ wget https://apt.kitware.com/kitware-archive.sh
   $ sudo bash kitware-archive.sh
   $ sudo apt install --no-install-recommends git cmake ninja-build \
   gperf ccache dfu-util device-tree-compiler python3-dev python3-pip \
   python3-setuptools python3-tk python3-wheel xz-utils file make gcc \
   gcc-multilib g++-multilib libsdl2-dev
   

   Actualmente, Zephyr requiere versiones mínimas de dependencias principales, como CMake (3.20.0), Python3 (3.6) y el compilador Devicetree (1.4.6).

   $ cmake --version
   $ python3 --version
   $ dtc --version
   

   Verifica las versiones instaladas en el sistema antes de continuar con los siguientes pasos. Si las versiones no son correctas, cambia la duplicación de APT a una duplicación estable y actualizada, o actualiza manualmente estas dependencias.
2. Instala al oeste.

   $ pip3 install --user -U west
   $ echo 'export PATH=~/.local/bin:"$PATH"' >> ~/.bashrc
   $ source ~/.bashrc
   

   Asegúrate de que ~/.local/bin esté en la variable de entorno $PATH.
3. Obtén el código fuente del proyecto Zephyr.

   $ west init ~/zephyrproject
   $ cd ~/zephyrproject
   $ west update
   $ west blobs fetch hal_telink
   $ west zephyr-export
   

4. Instala dependencias adicionales de Python para Zephyr.

   $ pip3 install --user -r ~/zephyrproject/zephyr/scripts/requirements.txt
   

5. Configurar la cadena de herramientas Zephyr Descarga la cadena de herramientas Zephyr (aproximadamente 1~2 GB) a un directorio local para que puedas escribir en la mayoría de las placas.

   $ wget https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.16.1/zephyr-sdk-0.16.1_linux-x86_64.tar.xz
   $ wget -O - https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.16.1/sha256.sum | shasum --check --ignore-missing
   

   Descarga el SDK de Zephyr y colócalo en la ruta recomendada, como se muestra a continuación.

   $HOME/zephyr-sdk[-x.y.z]
   $HOME/.local/zephyr-sdk[-x.y.z]
   $HOME/.local/opt/zephyr-sdk[-x.y.z]
   $HOME/bin/zephyr-sdk[-x.y.z]
   /opt/zephyr-sdk[-x.y.z]
   /usr/zephyr-sdk[-x.y.z]
   /usr/local/zephyr-sdk[-x.y.z]
   

   Donde [-x.y.z] es texto opcional que puede ser cualquier texto, como -0.16.1. No se puede mover el directorio después de que se instale el SDK. Luego, instala la cadena de herramientas Zephyr.

   $ tar xvf zephyr-sdk-0.16.1_linux-x86_64.tar.xz
   $ cd zephyr-sdk-0.16.1
   $ ./setup.sh -t riscv64-zephyr-elf -h -c
   

6. Compila el ejemplo de Hello World. Primero, verifica que la configuración oficial del proyecto de Zephyr sea la correcta con el ejemplo de Hello World y, luego, configura tu proyecto personalizado.

   $ cd ~/zephyrproject/zephyr
   $ west build -p auto -b tlsr9518adk80d samples/hello_world
   

   Use el comando de compilación West para crear el ejemplo hello_world desde el directorio raíz del repositorio de Zephyr. Encontrarás el firmware llamado zephyr.bin en build/zephyr directory.
7. Agrega la secuencia de comandos del entorno de Zephyr a ~/.bashrc. Ejecuta los siguientes comandos.

   $ echo "source ~/zephyrproject/zephyr/zephyr-env.sh" >> ~/.bashrc
   $ source ~/.bashrc
   

8. Agrega el repositorio remoto de Telink Zephyr. Descarga el repositorio de Telink de forma local como una rama de desarrollo y actualízalo.

   $ cd ~/zephyrproject/zephyr
   $ git remote add telink-semi https://github.com/telink-semi/zephyr
   $ git fetch telink develop
   $ git checkout develop
   $ west update
   $ west blobs fetch hal_telink
   

Para obtener más información, pueden consultar Zephyr Doc – Getting Started Guide.

Cómo configurar Telink LinuxBDT

Descarga la herramienta Telink LinuxBDT y extráela en un directorio local de tu máquina Linux, como el directorio principal ~, a fin de instalar el firmware en la placa de desarrollo B91.

$ cd ~
$ wget http://wiki.telink-semi.cn/tools_and_sdk/Tools/BDT/LinuxBDT.tar.bz2
$ tar -vxf LinuxBDT.tar.bz2 

Conecta el Burning Board a la máquina Linux a través de la interfaz USB y, luego, ingresa los siguientes comandos.

$ cd LinuxBDT
$ sudo ./bdt lsusb -v
Bus 002 Device 001: ID 1d6b:0003 xHCI Host Controller
Bus 001 Device 003: ID 0bda:565a Integrated_Webcam_HD
Bus 001 Device 023: ID 413c:301a Dell MS116 USB Optical Mouse
Bus 001 Device 037: ID 248a:826a Telink Web Debugger v3.6
Bus 001 Device 001: ID 1d6b:0002 xHCI Host Controller

Si aparece el mensaje "Telink Web Debugger v3.6", significa que el programador de BDT se conectó correctamente a la máquina Linux.

Compilación de firmware

En este codelab, se compilarán dos tipos de firmware de OpenThread:

• ot-cli-ftd,
• y ot-rcp.

Los métodos de compilación son los siguientes:

1. Coprocesador de radio（ot-rcp)

   $ cd ~/zephyrproject
   $ rm -rf build_ot_coprocessor
   $ west build -b tlsr9518adk80d -d build_ot_coprocessor zephyr/samples/net/openthread/coprocessor -- -DDTC_OVERLAY_FILE="usb.overlay" -DOVERLAY_CONFIG=overlay-rcp-usb-telink.conf
   

2. Dispositivo de Thread con todas las funciones con línea de comandos interactiva (ot-cli-ftd)

   $ cd ~/zephyrproject
   $ rm -rf build_ot_cli_ftd
   $ west build -b tlsr9518adk80d -d build_ot_cli_ftd zephyr/samples/net/openthread/cli -- -DOVERLAY_CONFIG=overlay-telink-fixed-mac.conf -DCONFIG_OPENTHREAD_FTD=y
   

Flash de firmware

Conecta una placa de desarrollo B91 a la placa de quemadura con un cable USB, como se muestra en la siguiente figura.

En la línea de comandos, ejecuta los siguientes comandos para grabar el firmware (por ejemplo, con la escritura en la memoria flash del firmware ot-cli-ftd).

$ cd ~/zephyrproject/build_ot_cli_ftd/zephyr
$ cp zephyr.bin ~/LinuxBDT/bin/ot-cli-ftd.bin
$ cd ~/LinuxBDT
$ sudo ./bdt 9518 ac
 Activate OK!
$ sudo ./bdt 9518 wf 0 -i bin/ot-cli-ftd.bin
 EraseSectorsize...
 Total Time: 2181 ms
 Flash writing...
 [100%][-] [##################################################]
 File Download to Flash at address 0x000000: 491700 bytes
 Total Time: 30087 ms

El método de flash para ot-rcp es básicamente el mismo que el de ot-cli-ftd. Sin embargo, existen diferencias en las rutas de acceso y los nombres de los firmwares.

Después de la escritura en la memoria flash, marque las dos placas de desarrollo B91 para identificarlas. Etiqueta la placa con la memoria flash de ot-cli-ftd como "FTD Joiner" y la placa parpadeó con ot-rcp como "RCP".

4. Configure una consola en serie para el dispositivo de unión del FTD

Como se muestra en la imagen, conecte directamente el FTD Joiner al puerto USB de la máquina Linux.

Después de conectar el dispositivo de unión de FTD a la máquina Linux, abre PuTTY. Luego, crea una terminal nueva, configura la información del puerto en serie y ábrelo.

Aquí está la referencia de la línea de comandos de OpenThread: Referencia de la CLI de OpenThread. Asegúrate de agregar el prefijo ot a todos los comandos.

Ejemplos:

> ot state
disabled
Done
> ot channel
11
Done
>

5. Configura Raspberry Pi como router de borde de OpenThread

Un router de borde de OpenThread es un dispositivo que consta de dos partes principales:

• Raspberry Pi contiene todos los servicios y firmware necesarios para funcionar como router de borde (BR).
• RCP es el responsable de la comunicación de Thread.

Coprocesador de radio（RCP）

Para escribir en la memoria flash del firmware ot-rcp, sigue los mismos pasos que el proceso de instalación del firmware de ot-cli-ftd. Conecta la placa de desarrollo B91 a un puerto USB en la placa Raspberry Pi, como se muestra en la siguiente figura.

Raspberry Pi

1. Asegúrate de que la imagen de Raspbian Bullseye Lite OS o Raspbian Bullseye con computadora de escritorio esté escrita correctamente en la tarjeta SD.
2. Tienes la opción de establecer una conexión SSH a Raspberry Pi o trabajar directamente con Raspbian Desktop. Este codelab usará SSH.
3. Antes de instalar Docker OTBR en el siguiente paso, asegúrate de actualizar el repositorio local y el administrador de paquetes.

   $ sudo apt-get update
   $ sudp apt-get upgrade
   

Instala Docker

Si acabas de actualizar el repositorio local y el administrador de paquetes APT en el paso anterior, reinicia Raspberry Pi y, luego, abre una ventana de la terminal SSH.

1. Instala Docker:

   $ curl -sSL https://get.docker.com | sh
   

2. Coloca la cuenta actual en un grupo de Docker para otorgar el permiso, de modo que no sea necesario agregar sudo delante de cada comando.

   $ sudo usermod -aG docker $USER
   

   Debes reiniciar Raspberry Pi para que se aplique.
3. Si aún no se inició Docker, inícialo:

   $ sudo dockerd
   

4. Las secuencias de comandos de firewall de OTBR generan reglas dentro del contenedor de Docker. Antes de eso, ejecuta modprobe para cargar el módulo de kernel de iptables.

   $ sudo modprobe ip6table_filter
   

Configura y ejecuta Docker

Este codelab extrae directamente la imagen de Docker de OTBR desde OpenThread Docker Hub. El equipo de OpenThread probó y verificó esta imagen.

1. Extrae la imagen más reciente:

   $ docker pull openthread/otbr:latest
   

2. Verifica la lista de imágenes en el contenedor de Docker:

   $ docker images
   REPOSITORY        TAG       IMAGE ID       CREATED      SIZE
   openthread/otbr   latest    db081f4de15f   6 days ago   766MB
   

3. Determina el nombre del puerto en serie del dispositivo RCP marcando /dev. ttyACM0 indica que el RCP está conectado correctamente.

   $ ls /dev/tty*
   ...
   /dev/ttyACM0
   ... 
   

4. Ejecuta Docker de OTBR por primera vez y haz referencia al puerto en serie de RCP (ttyACM0). Si quieres seguir usando este Docker de OTBR, usa el comando docker start otbr.

   $ docker run --name "otbr" --sysctl "net.ipv6.conf.all.disable_ipv6=0 net.ipv4.conf.all.forwarding=1 net.ipv6.conf.all.forwarding=1" -p 8080:80 --dns=127.0.0.1 -it --volume /dev/ttyACM0:/dev/ttyACM0 --privileged openthread/otbr --radio-url spinel+hdlc+uart:///dev/ttyACM0
   

5. Abre una nueva ventana de la terminal SSH para probar la conectividad entre Raspberry Pi y RCP.

   $ docker exec -ti otbr sh -c "sudo ot-ctl"
   > state 
   disabled
   Done
   

Comandos de Docker opcionales:

• Obtén información sobre el contenedor de Docker en ejecución:

  $ docker ps -aq
  

• Detén Docker OTBR:

  $ docker stop otbr
  

• Quita Docker de OTBR:

  $ docker rm otbr
  

• Vuelve a cargar Docker de OTBR:

  $ docker restart otbr
  

En este punto, un dispositivo de unión de FTD y un OTBR están listos, y puedes continuar con el siguiente paso para crear la red de Thread.

6. Cómo crear una red Thread

Cómo crear una red Thread en RCP

Usamos el shell ot-ctl en la OTBR para establecer una red de Thread. Si salió de la shell en la última sección, ingrese el siguiente comando para volver a iniciarlo en la terminal SSH:

$ docker exec -ti otbr sh -c "sudo ot-ctl"

A continuación, ingrese los comandos en el orden especificado en la tabla y asegúrese de que cada paso logre el resultado esperado antes de continuar con el siguiente.

La clave de red generada de forma aleatoria por OTBR se usará cuando los dispositivos ot-cli-ftd se unan a esta red de Thread.

Agregue el unión del FTD a Thread a través de un encargo fuera de banda

La puesta en marcha fuera de banda hace referencia a la transmisión de credenciales de red a dispositivos que esperan unirse a la red a través de métodos no inalámbricos (por ejemplo, ingresar manualmente en la CLI de OpenThread). Ingrese los siguientes comandos en orden en la consola en serie para el FTD Joiner.

Topología

Ingresa comandos como ipaddr, child table, router table en la terminal SSH para obtener respuestas como los siguientes fragmentos de código.

> ipaddr rloc
fd8c:60bc:a98:c7ba:0:ff:fe00:b000
Done
> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|D|N|Ver|CSL|QMsgCnt|Suprvsn| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+---+---+-------+-------+------------------+
|   1 | 0xb001 |        240 |         23 |     3 |   51 |1|1|1|  3| 0 |     0 |   129 | 82bc12fbe783468e |

Done
> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     | Link |
+----+--------+----------+-----------+-------+--------+-----+------------------+------+
| 44 | 0xb000 |       63 |         0 |     0 |      0 |   0 | 7ae354109d611f7e |    0 |

Done
...
> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|D|N|Ver|CSL|QMsgCnt|Suprvsn| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+---+---+-------+-------+------------------+

Done
> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     | Link |
+----+--------+----------+-----------+-------+--------+-----+------------------+------+
| 33 | 0x8400 |       63 |         0 |     3 |      3 |  13 | e61487c1cda940a6 |    1 |
| 44 | 0xb000 |       63 |         0 |     0 |      0 |   0 | 7ae354109d611f7e |    0 |

Done

El RLOC16 de OTBR es 0xb000, y el RLOC16 del FTD Joiner es inicialmente 0xb001. Luego, el RLOC16 del unión del FTD se convierte en 0x8400 después de obtener el ID del router. Puede observarse que el FTD Joiner se actualizó de un elemento secundario a un router.

La red Thread actual contiene dos nodos, y la topología es como se muestra en la siguiente figura.

7. Comunicación entre dispositivos Thread

Comunicación ICMPv6

Usamos el comando ping para verificar si los dispositivos de Thread de la misma red pueden comunicarse entre sí. Primero, usa el comando ipaddr para obtener el RLOC del dispositivo.

> ipaddr
fd8c:60bc:a98:c7ba:0:ff:fe00:fc11
fdbd:7274:649c:1:1d19:9613:f705:a5af
fd8c:60bc:a98:c7ba:0:ff:fe00:fc10
fd8c:60bc:a98:c7ba:0:ff:fe00:fc38
fd8c:60bc:a98:c7ba:0:ff:fe00:fc00
fd8c:60bc:a98:c7ba:0:ff:fe00:b000       # Routing Locator (RLOC)
fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6
fe80:0:0:0:78e3:5410:9d61:1f7e
Done

Ingrese el siguiente comando en la consola en serie del Unión de FTD para ejecutar la operación de ping.

> ot ping fd8c:60bc:a98:c7ba:0:ff:fe00:b000
16 bytes from fd8c:60bc:a98:c7ba:0:ff:fe00:b000: icmp_seq=1 hlim=64 time=19ms
1 packets transmitted, 1 packets received. Packet loss = 0.0%. Round-trip min/avg/max = 19/19.0/19 ms.
Done

La respuesta de salida del puerto en serie indica que el lado de la OTBR recibió la solicitud de ping y que el unión del FTD recibió la respuesta de ping que muestra OTBR. La comunicación entre los dos dispositivos es correcta.

Comunicación UDP

Los servicios de aplicación que proporciona OpenThread también incluyen UDP. Puedes usar la API de UDP para pasar información entre nodos en la red de Thread, o pasar información a redes externas mediante el router de borde. La introducción detallada de la API de UDP de OpenThread se encuentra en el ejemplo de la CLI de OpenThread: UDP. En este codelab, se usarán algunas de las API para transmitir información entre el OTBR y el unión del FTD.

Primero, obtén el EID de la malla local de OTBR. Esta dirección también es una de las direcciones IPv6 del dispositivo Thread y se puede usar para acceder a dispositivos Thread en la misma partición de red de Thread.

> ipaddr mleid
fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6
Done

Ingresa los siguientes comandos en la terminal SSH para habilitar OTBR UDP y vincular el puerto 1022 del dispositivo.

> udp open
Done
> udp bind :: 1022
Done

Ingrese los siguientes comandos en la consola en serie y habilite el UDP del Unión FTD. Vincula el puerto 1022 del dispositivo y, luego, envía un mensaje hello de 5 bytes al OTBR.

> ot udp open 
Done
> ot udp bind :: 1022
Done
> ot udp send fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6 1022 hello
Done

La terminal SSH genera la siguiente información. OTBR recibe el mensaje hello del Unión de FTD, lo que significa que la comunicación UDP tiene éxito.

> 5 bytes from fd8c:60bc:a98:c7ba:9386:63cf:19d7:5a61 1022 hello

8. Felicitaciones

Creaste una red Thread simple y verificaste la comunicación dentro de esta red.

Ahora sabe lo siguiente:

• Cómo crear y usar el entorno de desarrollo de Telink Zephyr.
• Cómo compilar los objetos binarios ot-cli-ftd y ot-rcp, además de actualizarlos en placas de desarrollo Telink B91
• Cómo configurar una versión Raspberry Pi 3B o versiones posteriores como router de borde de OpenThread (OTBR) con Docker.
• Cómo crear una red Thread en OTBR
• Cómo agregar dispositivos a la red Thread mediante la asignación de fuera de banda
• Cómo verificar la conectividad entre nodos en la red Thread

Material de lectura adicional

Consulta openthread.io y GitHub para obtener información sobre diversos recursos de OpenThread, incluidos los siguientes:

• Plataformas compatibles: Descubre todas las plataformas compatibles con OpenThread
• Compilación de OpenThread: Más detalles sobre la compilación y configuración de OpenThread
• Thread Primer: Abarca todos los conceptos de Thread que aparecen en este codelab

Documentos de referencia:

• Referencia de la CLI de OpenThread
• Referencia de la CLI de OpenThread UDP
• Referencia de la API de OpenThread UDP