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 los dispositivos de la Internet de las cosas (IoT). OpenThread fue desarrollado por el equipo de Google Nest 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 los dispositivos con recursos limitados que suelen encontrarse 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, el establecimiento de vínculos de malla y el enrutamiento de la malla.

Telink integró la implementación de OpenThread a los RTOS de Zephyr, lo que permite una compatibilidad sin inconvenientes con su 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, además, intercambiarás mensajes entre nodos. En la siguiente imagen, se muestra la configuración de hardware, con 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 Telink Zephyr.
Para compilar las muestras de la CLI de OpenThread (ot-cli-ftd y ot-rcp) y escribirlas en la memoria flash de las placas de desarrollo Telink B91, sigue estos pasos:
Configura un router de borde de OpenThread (OTBR) con Docker en una placa Raspberry Pi 3B+ o posterior.
Crear una red Thread en la OTBR.
Para agregar dispositivos a la red Thread usando depuración fuera de banda.
Validar la conectividad entre nodos en la red de Thread con la CLI.

Requisitos

Hardware:

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

Software:

Herramienta de grabación y depuración 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

Puede ser ú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 v20.04 LTS o versiones posteriores) actúa como la 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 disponibles y conectividad a Internet.

Conexión y terminales de puertos en serie

Puedes conectar directamente el dispositivo al 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 de terminal PuTTY se usa para controlar FTD Joiner y Raspberry Pi. Ofrece una descripción general de su uso, pero también se puede usar 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 requeridos en un conjunto.

Uno de estos kits se usará como RCP (Coprocesador de radio), mientras que el otro funcionará como FTD (dispositivo de 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:

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

Raspberry Pi 3B+ o superior con Raspbian OS Image

En este codelab, se necesita una Raspberry Pi 3B o una versión posterior con una imagen de SO Raspbian Bullseye Lite o una Raspbian Bullseye con computadora. Está conectado 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 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 Burning and Debugging Tool (BDT) de Telink, que se aplica a todas las series de chips Telink, te permite borrar e instalar el firmware OpenThread en las placas de desarrollo Telink B91. Instala la versión linuxBDT de Linux basada en X86 en tu máquina Linux.

Otros

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 Linux, abre una terminal de la CLI y ejecuta los siguientes comandos para asegurarte de que tu APT esté actualizada.

$ sudo apt update
$ sudo apt upgrade

Una vez hecho esto, 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 próximos pasos. Si las versiones no son correctas, cambia la duplicación de APT a una duplicación estable y actualizada, o actualiza estas dependencias de forma manual.

Instalar al 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 de Zephyr. Descarga la cadena de herramientas de Zephyr (alrededor de 1-2 GB) a un directorio local para poder 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 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 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 del proyecto oficial de 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
```
Utiliza el comando de compilación West para compilar el ejemplo de hello_world a partir del directorio raíz del repositorio de Zephyr. Puedes encontrar el firmware con el nombre zephyr.bin en build/zephyr directory.
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
```

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, 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 de tu máquina Linux, como el directorio principal ~, que permite escribir el firmware 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 placa de fuego 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:

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 Thread con funciones completas 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 combustión con un cable USB, como se ilustra en la siguiente imagen.

En la línea de comandos, ejecuta los siguientes comandos para llevar a cabo la grabación del firmware (utilizando la instalación 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 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 escribir en la memoria flash, marca las dos placas de desarrollo B91 según corresponda. Etiqueta la placa con la leyenda ot-cli-ftd como “FTD Joiner”. y en la placa aparece 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 directamente el FTD Joiner al puerto USB de la máquina de Linux.

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

La referencia de la línea de comandos de OpenThread está 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. Cómo configurar Raspberry Pi como router de borde de OpenThread

Un router de borde 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 los subprocesos.

Coprocesador de radio (RCP)

Para escribir en la memoria flash del firmware ot-rcp, sigue los mismos pasos que para el firmware 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

Asegúrate de que la imagen de SO Raspbian Bullseye Lite o Raspbian Bullseye con Desktop esté bien escrita en la tarjeta SD.
Puedes conectarte con SSH a Raspberry Pi o trabajar directamente con Raspbian Desktop. En este codelab, se usará SSH.
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 actualizas el repositorio local y la APT del administrador de paquetes 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 delante de cada comando.
```
$ sudo usermod -aG docker $USER
```
Debes reiniciar la Raspberry Pi para que se aplique el cambio.
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
```

Configura y ejecuta 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 seguir usando este Docker de OTBR, utiliza 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 la placa 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 el Docker de OTBR:
```
$ docker stop otbr
```
Quita el Docker de OTBR:
```
$ docker rm otbr
```
Vuelve a cargar el 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 Thread.

6. Cómo crear una red Thread

Crea una red Thread en RCP

Usamos el 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`	Crear un nuevo conjunto de datos de red aleatorio	Listo
2	`dataset commit active`	Confirmar el nuevo conjunto de datos en el conjunto de datos operativos activos en el almacenamiento no volátil	Listo
3	`ifconfig up`	Abre la interfaz IPv6.	Listo
4	`thread start`	Habilita la operación del protocolo Thread y conéctate a una red de Thread.	Listo
			Espera 10 segundos para que la interfaz del subproceso esté activa.
5	`state`	Verifica el estado del dispositivo.Se puede llamar a este comando varias veces hasta que se convierta en líder y avance al siguiente paso.	leader Done
6	`dataset active`	Verifica el conjunto de datos operativos activos completo y registra la clave de red.

Se usará la clave de red generada de forma aleatoria por OTBR durante la creación de la red cuando ot-cli-ftd dispositivos se unan a esta red de Thread.

Agrega la unión de FTD a Thread a través de una puesta en servicio fuera de banda

La puesta fuera de banda hace referencia a la transmisión de credenciales de red a dispositivos que esperan para unirse a la red a través de 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.	Listo
2	`ot dataset commit active`	Confirmar el nuevo conjunto de datos en el conjunto de datos operativos activos en el almacenamiento no volátil	Listo
3	`ot ifconfig up`	Abre la interfaz IPv6.	Listo
4	`ot thread start`	Habilita la operación del protocolo Thread y conéctate a una red de Thread.	Listo
			Espera 20 segundos mientras el dispositivo se une y se configura.
5	`ot state`	Verifica el estado del dispositivo.	hijo/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 FTD Joiner inicialmente es 0xb001. Luego, el RLOC16 del Unión de FTD se convierte en 0x8400 después de obtener el ID de router. Puede ver que el FTD Joiner se actualizó de un elemento secundario a un router.

La red de 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 comprobar si los dispositivos Thread que se encuentran 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 de 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 ping y que el FTD Joiner recibió la respuesta ping devuelta por OTBR. La comunicación entre los dos dispositivos es exitosa.

Comunicación UDP

Los servicios de aplicaciones que proporciona OpenThread también incluyen UDP. Puedes usar la API de UDP para pasar información entre nodos de la red Thread o para 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 Ejemplo de UDP de la CLI de OpenThread. 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 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

Ingresa los siguientes comandos en la consola en serie y habilita el UDP del Unión 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 Unión de FTD, lo que significa que la comunicación UDP es correcta.

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

Ahora sabes lo siguiente:

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

Lecturas adicionales

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

Plataformas compatibles: Descubre todas las plataformas compatibles con OpenThread
Compila OpenThread: Obtén más detalles sobre cómo compilar y configurar OpenThread.
Primer Thread: Abarca todos los conceptos de Thread que se presentan en este codelab

Documentos de referencia: