Se usó la API de Cloud Translation para traducir esta página.

Construir subproceso abierto

Cómo construir OpenThread

Los pasos para compilar OpenThread varían según la cadena de herramientas, la máquina del usuario y la plataforma de destino.

El flujo de trabajo más común es:

Configure el entorno de compilación e instale la cadena de herramientas deseada:
1. Para construir directamente en una máquina, consulte Simulation Codelab para obtener instrucciones detalladas
2. Para usar un contenedor Docker con un entorno preconfigurado, descargue y ejecute la imagen del environment OpenThread:
```
docker pull openthread/environment:latest
docker run -it --rm openthread/environment bash
```
Dentro de su entorno elegido, clone el repositorio OpenThread Git específico de la plataforma. Tomando CC2538 como ejemplo:
```
git clone https://github.com/openthread/ot-cc2538.git --recursive
```
Desde el directorio raíz del repositorio clonado:
1. Instale la cadena de herramientas:
```
./script/bootstrap
```
2. Cree la configuración:
```
./script/build platform-specific-args cmake-options
```
Muestre el binario deseado a la plataforma de destino. Todos los archivos binarios generados se encuentran en ./build/bin .

Configuración

Puede configurar OpenThread para diferentes funciones y comportamientos durante el proceso de compilación. Las opciones de configuración disponibles se detallan en las siguientes ubicaciones:

Escribe	Ubicación
Constantes de tiempo de compilación	Listado en todos los archivos de encabezado en `/src/core/config`
opciones de compilación cmake	Listado en `openthread/examples/README.md`

Crear ejemplos

Use las opciones de compilación de cmake para habilitar la funcionalidad de la plataforma. Por ejemplo, para compilar el binario para la plataforma CC2538 con la compatibilidad con Commission y Joiner habilitada:

./script/build -DOT_COMMISSIONER=ON -DOT_JOINER=ON

O bien, para construir la plataforma nRF52840 con la función de detección de atascos habilitada en su repositorio:

./script/build nrf52840 UART_trans -DOT_JAM_DETECTION=ON

binarios

Los siguientes archivos binarios se generan en ./build/bin a partir del proceso de compilación. Para determinar qué archivos binarios se generan, use indicadores con el comando ./script/build . Por ejemplo, para compilar OpenThread y generar solo el binario FTD CLI:

./script/build -DOT_APP_CLI=ON -DOT_FTD=ON -DOT_MTD=OFF -DOT_APP_NCP=OFF -DOT_APP_RCP=OFF -DOT_RCP=OFF

Binario	Descripción	Opciones
`ot-cli-ftd`	Dispositivo Full Thread para diseños SoC	`-DOT_APP_CLI=ON` `-DOT_FTD=ON`
`ot-cli-mtd`	Dispositivo Minimal Thread para diseños SoC	`-DOT_APP_CLI=ON` `-DOT_MTD=ON`
`ot-ncp-ftd`	Dispositivo de subproceso completo para diseños de coprocesador de red (NCP)	`-DOT_APP_NCP=ON` `-DOT_FTD=ON`
`ot-ncp-mtd`	Dispositivo Minimal Thread para diseños NCP	`-DOT_APP_NCP=ON` `-DOT_MTD=ON`
`ot-rcp`	Diseño de coprocesador de radio (RCP)	`-DOT_APP_RCP=ON` `-DOT_RCP=ON`

De forma predeterminada, todas las banderas anteriores están habilitadas. Si deshabilita explícitamente todos los indicadores, las aplicaciones no se crean, pero los archivos de la biblioteca OpenThread aún se generan en ./build/lib para usar en un proyecto.

Consulte los Makefiles de ejemplo para cada plataforma para ver qué banderas admite cada plataforma. Para obtener más información sobre FTD y MTD, consulte el Thread Primer . Para obtener más información sobre los diseños de SoC y NCP, consulte Plataformas .

El proceso para actualizar estos binarios varía según las plataformas de ejemplo. Consulte los archivos README en la carpeta de ejemplo de cada plataforma para obtener instrucciones detalladas.

Demonio OpenThread

OpenThread Daemon (OT Daemon) es un modo de compilación OpenThread POSIX que ejecuta OpenThread como un servicio y se usa con el diseño RCP. Para obtener más información sobre cómo compilarlo y usarlo, consulte OpenThread Daemon .

Cree paquetes de soporte

Los paquetes de soporte de compilación (BSP) se encuentran en /third_party . Los BSP son códigos de terceros adicionales utilizados por OpenThread en cada plataforma respectiva, generalmente incluidos al migrar OpenThread a una nueva plataforma de hardware.