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.

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 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ámbrica confiable, seguro y con eficiencia energética para dispositivos con recursos limitados que se suelen encontrar en casas inteligentes y edificios comerciales. OpenThread incluye todo el alcance de la capa de red dentro de Thread, como IPv6, 6LoWPAN, IEEE 802.15.4 con seguridad MAC, establecimiento del vínculo de malla y enrutamiento de malla.

Telink integró la implementación de OpenThread en las RTOS de Zephyr, lo que permite una compatibilidad sin inconvenientes con el hardware de Telink. El código fuente para esta integración es de fácil acceso en GitHub y 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 e intercambiarás mensajes entre nodos. En la siguiente imagen, se muestra la configuración del hardware. En el codelab, se muestra un router de borde OT (OTBR) y un dispositivo Thread.

Qué aprenderás

Configura la implementación de OpenThread con el entorno de desarrollo de Telink Zephyr.
Compilar los ejemplos de la CLI de OpenThread (ot-cli-ftd y ot-rcp) y escribirlos en la memoria flash de las placas de desarrollo Telink B91
Configura un router de borde de OpenThread (OTBR) con Docker en una Raspberry Pi 3B+ o posterior.
Para crear una red Thread en la OTBR.
Agregar dispositivos a la red Thread usando la depuración fuera de banda
Validar la conectividad entre los nodos en la red Thread usando CLI.

Requisitos

Hardware:

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

Software:

Herramienta de quema y depuración de Telink: LinuxBDT.
Herramienta de terminal de puerto en serie, como PuTTY.
Otras herramientas, como Git y West.

2. Requisitos previos

Conceptos de subprocesos y CLI de OpenThread

Tal vez te resulte útil consultar 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 de Linux

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

Conexión y terminales de puertos en serie

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

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

Kit de desarrollo Telink B91

Este codelab necesita dos conjuntos de kits de desarrollo B91. La siguiente foto muestra los componentes mínimos obligatorios 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. Algunos componentes que se usarán son los siguientes:

Índice	Nombre
1	Placa de desarrollo Telink B91
2	Tablero ardiente Telink
3	Antena de 2.4 GHz
4	Cable USB (USB A a mini-USB)

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

En este codelab, se necesita una versión Raspberry Pi 3B o superior con una imagen de SO Raspbian Bullseye Lite o una Raspbian Bullseye con computadoras de escritorio. Se conecta a Internet a través de Ethernet y se configurará como host para el router de borde de OpenThread (OTBR).

Conexión de red

Un switch (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 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 Telink, te permite borrar y escribir en la memoria flash del firmware OpenThread en las placas de desarrollo Telink B91. Instala la versión linuxBDT basada en X86 en tu máquina Linux.

Otras opciones

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

3. Configurar firmware

Configura el entorno de desarrollo de Telink Zephyr

En la máquina de Linux, abre una terminal de la CLI y comienza por ejecutar los siguientes comandos para asegurarte de que la aplicación APT esté actualizada.

$ sudo apt update
$ sudo apt upgrade

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

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 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 la duplicación APT a una duplicación estable y actualizada, o actualiza estas dependencias de forma manual.

Instala la versión oeste.

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

Obtén el código fuente del proyecto Zephyr.

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

Instala dependencias adicionales de Python para Zephyr.

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

Configura la cadena de herramientas Zephyr. Descarga la cadena de herramientas de Zephyr (alrededor de 1~2 GB) a un directorio local para que puedas escribir en la memoria flash 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 de acceso 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]

En el que [-x.y.z] es texto opcional que puede ser cualquier texto, como -0.16.1. No se puede mover el directorio 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

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 de hello_world a partir del directorio raíz del repositorio de Zephyr. Puedes encontrar el firmware llamado zephyr.bin en build/zephyr directory.
Agrega la secuencia de comandos del entorno Zephyr a ~/.bashrc. Ejecuta los siguientes comandos.
```
$ echo "source ~/zephyrproject/zephyr/zephyr-env.sh" >> ~/.bashrc
$ source ~/.bashrc
```

Agrega el repositorio remoto 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, puedes consultar el documento de Zephyr: Guía de introducción.

Cómo configurar Telink LinuxBDT

Descarga la herramienta Telink LinuxBDT y extráela en un directorio local en tu máquina Linux, como el directorio principal ~, para habilitar la escritura en la memoria flash de 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 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 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:

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

Dispositivo de subprocesos completamente destacado 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 quema con un cable USB como se ilustra en la siguiente figura.

En la línea de comandos, ejecuta los siguientes comandos para ejecutar la grabación de firmware (con la escritura en la memoria flash del firmware ot-cli-ftd como ejemplo).

$ 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 escritura en la memoria flash para ot-rcp es básicamente el mismo que para ot-cli-ftd. Sin embargo, existen diferencias en los nombres y las rutas de acceso del firmware.

Después de escribir en la memoria flash, marca las dos placas de desarrollo B91 según corresponda. Etiqueta la placa con ot-cli-ftd como "FTD Joiner" y ot-rcp como "RCP".

4. Cómo configurar una consola en serie para el dispositivo de unión de FTD

Como se muestra en la imagen, conecta 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 abre el puerto en serie.

Aquí encontrarás 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. Cómo configurar 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 el firmware necesarios para funcionar como router de borde (BR).
RCP es responsable de la comunicación de Thread.

Coprocesador de radio (RCP)

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

Raspberry Pi

Asegúrate de que la imagen de SO Raspbian Bullseye Lite o Raspbian Bullseye with Desktop estén escritas correctamente en la tarjeta SD.
Tienes la opción de establecer una conexión SSH a Raspberry Pi o de trabajar directamente con el escritorio de Raspbian. En este codelab, se usará SSH.
Antes de continuar con la instalación de OTBR Docker 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.

Instala Docker:

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

Coloca la cuenta actual en un grupo de Docker para otorgar el permiso, de modo que no sea necesario agregar sudo frente a cada comando.
```
$ sudo usermod -aG docker $USER
```
Reinicia Raspberry Pi para que funcione.
Si no se inició Docker, inícialo:
```
$ sudo dockerd
```
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
```

Configurar y ejecutar Docker

En este codelab, se extrae directamente la imagen de Docker de OTBR desde OpenThread Docker Hub. El equipo de OpenThread probó y verificó esta imagen.

Extrae la imagen más reciente:
```
$ docker pull openthread/otbr:latest
```

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

Determina el nombre del puerto en serie del dispositivo RCP. Para ello, verifica /dev (ttyACM0 indica que el RCP está conectado correctamente).
```
$ ls /dev/tty*
...
/dev/ttyACM0
... 
```

Ejecuta el Docker de OTBR por primera vez y haz referencia al puerto en serie de RCP (ttyACM0). Si deseas continuar 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

Abre una nueva ventana de la terminal SSH para probar la conectividad entre Raspberry Pi y el RCP.
```
$ docker exec -ti otbr sh -c "sudo ot-ctl"
> state 
disabled
Done
```

Comandos opcionales de Docker:

Obtén información sobre el contenedor de Docker en ejecución:
```
$ docker ps -aq
```
Detén Docker OTBR:
```
$ docker stop otbr
```
Quita el Docker de OTBR:
```
$ docker rm otbr
```
Volver a cargar Docker de OTBR:
```
$ docker restart otbr
```

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

6. Cómo crear una red Thread

Cómo crear una red Thread en RCP

Usamos la shell ot-ctl en OTBR para establecer una red Thread. Si saliste de la shell en la última sección, 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.

Índice	Comando	Introducción	Respuesta esperada
1	`dataset init new`	Crea un nuevo conjunto de datos de red aleatorio.	Lista
2	`dataset commit active`	Confirma un conjunto de datos nuevo al conjunto de datos operativos activo en el almacenamiento no volátil.	Lista
3	`ifconfig up`	Abre la interfaz IPv6.	Lista
4	`thread start`	Habilita la operación del protocolo Thread y conéctalo a una red Thread.	Lista
			Espera 10 segundos para que se active la interfaz del subproceso.
5	`state`	Verifica el estado del dispositivo.Se puede llamar a este comando varias veces hasta que se convierta en el líder y pase al siguiente paso.	líder Listo
6	`dataset active`	Verifica el conjunto de datos operativos activo completo y registra la clave de red.	Marca de tiempo activa: 1 Canal: 13 Máscara de canal: 0x07fff800 ID de PAN ext.: b07476e168eda4fc Prefijo local de malla: fd8c:60bc:a98:c7ba::/64 Clave de red: c312485187484ceb5c16c2B19c9C2B2B12B1

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

Agrega el conector de FTD a Thread a través de la comisión 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 mediante métodos no inalámbricos (por ejemplo, ingresar manualmente en la CLI de OpenThread). Ingresa los siguientes comandos en orden en la consola en serie para el FTD Joiner.

Índice	Comando	Introducción	Respuestas esperadas
1	`ot dataset networkkey c312485187484ceb5992d2343baaf93d`	Solo se necesita la clave de red para que un dispositivo se conecte a una red Thread.	Lista
2	`ot dataset commit active`	Confirma un conjunto de datos nuevo al conjunto de datos operativos activo en el almacenamiento no volátil.	Lista
3	`ot ifconfig up`	Abre la interfaz IPv6.	Lista
4	`ot thread start`	Habilita la operación del protocolo Thread y conéctalo a una red Thread.	Lista
			Espera 20 segundos mientras el dispositivo se une y se configura.
5	`ot state`	Comprueba el estado del dispositivo.	elemento secundario/router Listo

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 combinador de FTD es, inicialmente, 0xb001. Luego, el RLOC16 del conector de FTD se convierte en 0x8400 después de obtener el ID de router. Puede observar 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 Thread en 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 en serie 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 en serie indica que el lado OTBR recibió la solicitud de ping y que el conector de FTD recibió la respuesta de ping que mostró 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 a través del router de borde. La introducción detallada de la API de UDP de OpenThread se encuentra en CLI de OpenThread: ejemplo de UDP. En este codelab, se usarán algunas de las APIs para transmitir información entre OTBR y FTD Joiner.

Primero, obtén el EID de 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 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

Ingresa los siguientes comandos en la consola en serie y habilita el UDP del Joiner de FTD. Vincula el puerto 1022 del dispositivo y, luego, envía un mensaje hello de 5 bytes a 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 Joiner de FTD, lo que significa que la comunicación UDP se realiza correctamente.

> 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 sabes lo siguiente:

Cómo compilar y usar el entorno de desarrollo de Telink Zephyr
Cómo compilar los objetos binarios ot-cli-ftd y ot-rcp, y escribirlos en la memoria flash de las placas de desarrollo Telink B91
Cómo configurar Raspberry Pi 3B+ o una versión posterior como un 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 comisión fuera de banda
Cómo verificar la conectividad entre los nodos en la red Thread

Material de lectura adicional

Consulta openthread.io y GitHub para obtener información sobre varios 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 se destacan en este codelab.

Documentos de referencia: