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ámbrica sólido y seguro diseñado para dispositivos de Internet de las cosas (IoT). OpenThread fue desarrollado por el equipo de Nest de Google y está disponible de forma gratuita para la comunidad de desarrolladores como un proyecto de código abierto.

La Especificación de Thread establece un protocolo de comunicación inalámbrica confiable, seguro y con eficiencia energética para los dispositivos con recursos limitados que se encuentran comúnmente en las casas inteligentes y los 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 en el RTOS de Zephyr, lo que permite una compatibilidad perfecta con el hardware de Telink. El código fuente de esta integración está disponible 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 de Thread, y te intercambiarás mensajes entre nodos. En la siguiente imagen, se muestra la configuración del hardware, que incluye un router de borde de 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
• Compilar las muestras de la CLI de OpenThread (ot-cli-ftd y ot-rcp) y grabarlas en las placas de desarrollo B91 de Telink
• Configurar un router de borde de OpenThread (OTBR) con Docker en una Raspberry Pi 3B+ o posterior
• Crear una red de Thread en el OTBR
• Agregar dispositivos a la red Thread con depuración fuera de banda
• Validar la conectividad entre los nodos de la red Thread con la CLI

Requisitos

Hardware:

• Dos placas de desarrollo B91
• Una Raspberry Pi 3B+ o superior con la imagen del SO Raspbian
• Una máquina Linux con al menos dos puertos USB
• Un conmutador (o router) conectado a Internet y varios cables Ethernet

Software:

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

2. Requisitos previos

Conceptos de Thread y CLI de OpenThread

Antes de realizar este codelab, puede ser útil que completes el codelab de simulación de OpenThread para familiarizarte con los conceptos fundamentales de Thread y la CLI de OpenThread.

Máquina Linux

La máquina Linux (Ubuntu v20.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 disponibles y conectividad a Internet.

Conexión y terminales de puerto en serie

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

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

Kit de desarrollo de Telink B91

Este codelab necesita dos conjuntos de kits de desarrollo B91. En la siguiente foto, se muestran los componentes mínimos requeridos en un conjunto.

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

Raspberry Pi 3B+ o superior con imagen de SO Raspbian

En este codelab, se necesita una Raspberry Pi 3B+ o superior con la imagen del SO Raspbian Bullseye Lite o Raspbian Bullseye con escritorio. Está conectada a Internet a través de Ethernet y se configurará como el host del router de borde de OpenThread (OTBR).

Conexión de red

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

LinuxBDT

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

Otros

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

3. Cómo configurar el firmware

Configura el entorno de desarrollo de Telink Zephyr

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

$ sudo apt update
$ sudo apt upgrade

Cuando termines, 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 las dependencias principales, como CMake (3.20.0), Python3 (3.6) y Devicetree Compiler (1.4.6).

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

   Verifica las versiones instaladas en tu sistema antes de continuar con los siguientes pasos. Si las versiones no son correctas, cambia el espejo de APT a uno estable y actualizado, o bien actualiza estas dependencias de forma manual.
2. Instala west.

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

   Asegúrate de que ~/.local/bin esté en tu 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. Configura la cadena de herramientas de Zephyr. Descarga la cadena de herramientas de Zephyr (alrededor de 1 a 2 GB) en un directorio local para que puedas escribir la mayoría de las placas en la memoria flash.

   $ 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. El directorio no se puede mover después de instalar el SDK. Luego, instala la cadena de herramientas de 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 Zephyr sea correcta con el ejemplo de Hello World y, luego, continúa con la configuración de tu proyecto personalizado.

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

   Usa el comando de compilación de West para compilar el ejemplo hello_world desde el directorio raíz del repositorio de Zephyr. Puedes encontrar 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 repo 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, consulta la Guía de introducción a Zephyr.

Cómo configurar Telink LinuxBDT

Descarga la herramienta Telink LinuxBDT y extráela a un directorio local en tu máquina Linux, como el directorio principal ~, para poder escribir 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 la placa de grabación 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 ves 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. Procesador secundario 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 Thread con todas las funciones y 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 grabación con un cable USB, como se ilustra en la siguiente imagen.

En la línea de comandos, ejecuta los siguientes comandos para realizar la grabación del firmware (usando como ejemplo la escritura del firmware de 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 para ot-cli-ftd. Sin embargo, existen diferencias en las rutas de acceso y los nombres del firmware.

Después de la escritura, distingue las dos placas de desarrollo B91 marcándolas según corresponda. Etiqueta la placa que se grabó con ot-cli-ftd como "FTD Joiner" y la placa que se grabó con ot-rcp como "RCP".

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

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

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

Puedes consultar la referencia de la línea de comandos de OpenThread aquí: 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 la Raspberry Pi como un router de borde de OpenThread

Un Border Router de OpenThread es un dispositivo que consta de dos partes principales:

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

Procesador secundario de radio (RCP)

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

Raspberry Pi

1. Asegúrate de que la imagen del SO Raspbian Bullseye Lite o Raspbian Bullseye con escritorio se haya escrito correctamente en la tarjeta SD.
2. Tienes la opción de establecer una conexión SSH con la Raspberry Pi o trabajar directamente con el escritorio de Raspbian. En este codelab, se usará SSH.
3. Antes de continuar con la instalación de OTBR Docker en el siguiente paso, asegúrate de actualizar primero el repositorio local y el administrador de paquetes.

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

Instala Docker

Si solo actualizaste el repositorio local y el administrador de paquetes APT en el paso anterior, reinicia la Raspberry Pi y, luego, abre una ventana de 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 la Raspberry Pi para que se apliquen los cambios.
3. Si Docker no se inició, hazlo:

   $ sudo dockerd
   

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

   $ sudo modprobe ip6table_filter
   

Configura y ejecuta Docker

En este codelab, se extrae directamente la imagen de Docker del OTBR desde el Docker Hub de OpenThread. 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. Para determinar el nombre del puerto serie del dispositivo RCP, verifica /dev. ttyACM0 indica que el RCP está conectado correctamente.

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

4. Ejecuta OTBR Docker por primera vez y haz referencia al puerto serie del RCP (ttyACM0). Si deseas seguir usando este OTBR Docker, 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 terminal SSH para probar la conectividad entre la Raspberry Pi y el 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 el Docker de OTBR:

  $ docker stop otbr
  

• Quita el OTBR Docker:

  $ docker rm otbr
  

• Vuelve a cargar el Docker de OTBR:

  $ docker restart otbr
  

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

6. Cómo crear una red de Thread

Cómo crear una red de subprocesos en RCP

Usamos el shell ot-ctl en el OTBR para establecer una red de Thread. Si saliste de la shell en la sección anterior, ingresa el siguiente comando para volver a iniciarla en la terminal SSH:

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

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

La clave de red que genera el OTBR de forma aleatoria durante la creación de la red se usará cuando los dispositivos ot-cli-ftd se unan a esta red de Thread.

Cómo agregar el FTD Joiner al subproceso a través de la puesta en marcha fuera de banda

El aprovisionamiento fuera de banda se refiere 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, ingresándolas manualmente en la CLI de OpenThread). Ingresa los siguientes comandos en orden en la consola serial del FTD Joiner.

Topología

Ingresa comandos como ipaddr, child table y 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 inicialmente es 0xb001. Luego, el RLOC16 del FTD Joiner se convierte en 0x8400 después de obtener el ID del router. Se puede observar que el conector FTD se actualizó de secundario a router.

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

7. Comunicación entre dispositivos Thread

Comunicación ICMPv6

Usamos el comando ping para verificar si los dispositivos 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

Ingresa el siguiente comando en la consola serial del FTD Joiner 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 serie indica que el lado del OTBR recibió la solicitud de ping y que el dispositivo de unión FTD recibió la respuesta de ping que devolvió el OTBR. La comunicación entre los dos dispositivos se realizó correctamente.

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 a través del Border Router. La introducción detallada a la API de UDP de OpenThread se encuentra en el ejemplo de CLI de OpenThread: UDP. En este codelab, se usarán algunas de las APIs incluidas en él para transmitir información entre el OTBR y el FTD Joiner.

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

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

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

> udp open
Done
> udp bind :: 1022
Done

Ingresa los siguientes comandos en la consola serial y habilita el UDP del FTD Joiner. 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. El OTBR recibe el mensaje hello del FTD Joiner, lo que significa que la comunicación UDP se realizó correctamente.

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

8. Felicitaciones

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

Ahora ya sabes lo siguiente:

• Cómo compilar y usar el entorno de desarrollo de Telink Zephyr
• Cómo compilar los archivos binarios ot-cli-ftd y ot-rcp, y cómo grabarlos en las placas de desarrollo Telink B91
• Cómo configurar un Raspberry Pi 3B+ o una versión superior como un router de borde de OpenThread (OTBR) con Docker
• Cómo crear una red de Thread en un OTBR
• Cómo agregar dispositivos a la red de Thread a través de la puesta en servicio fuera de banda
• Cómo verificar la conectividad entre los nodos de la red Thread

Lecturas adicionales

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

• Plataformas compatibles: Descubre todas las plataformas que admiten OpenThread.
• Cómo compilar OpenThread: Más detalles para compilar y configurar OpenThread
• Thread Primer: Abarca todos los conceptos de Thread que se incluyen en este codelab.

Documentos de referencia:

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