Questa pagina è stata tradotta dall'API Cloud Translation.

Crea OpenThread

Come creare OpenThread

I passaggi per creare OpenThread variano in base alla catena degli strumenti, alla macchina utente e alla piattaforma di destinazione.

Il flusso di lavoro più comune è:

Configura l'ambiente di compilazione e installa la toolchain desiderata:
1. Per creare direttamente su una macchina,consulta il codelab sulla simulazione per istruzioni dettagliate
2. Per utilizzare un container Docker con un ambiente preconfigurato, scarica ed esegui l'immagine environmentOpenThread:
```
docker pull openthread/environment:latest
docker run -it --rm openthread/environment bash
```
All'interno dell'ambiente che hai scelto, clona il repository Git OpenThread specifico della piattaforma. Prendiamo ad esempio CC2538:
```
git clone https://github.com/openthread/ot-cc2538.git --recursive
```
Dalla directory principale del repository clonato:
1. Installa la toolchain:
```
./script/bootstrap
```
2. Crea la configurazione:
```
./script/build platform-specific-args cmake-options
```
Esegui il flashing del programma binario desiderato sulla piattaforma di destinazione. Tutti i programmi binari generati si trovano in ./build/bin.

Configurazione

Puoi configurare OpenThread per diverse funzionalità e comportamenti durante il processo di compilazione. Le opzioni di configurazione disponibili sono dettagliate nelle seguenti posizioni:

Tipo	Località
Costanti del tempo di compilazione	Elencato in tutti i file di intestazione in `/src/core/config`
opzioni build cmake	Elencato in `openthread/examples/README.md`

Esempi di build

Utilizza le opzioni di build cmake per abilitare la funzionalità per la piattaforma. Ad esempio, per creare il programma binario per la piattaforma CC2538 con il supporto Commissioner e Joiner abilitato:

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

In alternativa, per creare la piattaforma nRF52840 con la funzionalità di rilevamento Jam attivata nel repository:

./script/build nrf52840 UART_trans -DOT_JAM_DETECTION=ON

Programmi binari

I seguenti programmi binari vengono generati in ./build/bin dal processo di compilazione. Per determinare quali programmi binari vengono generati, utilizza i flag con il comando ./script/build. Ad esempio, per creare OpenThread e generare solo il programma binario dell'interfaccia a riga di comando FTD:

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

Programma binario	Descrizione	Opzioni
`ot-cli-ftd`	Dispositivo full Thread per SoC	`-DOT_APP_CLI=ON` `-DOT_FTD=ON`
`ot-cli-mtd`	Dispositivo Thread minimo per progettazione SoC	`-DOT_APP_CLI=ON` `-DOT_MTD=ON`
`ot-ncp-ftd`	Dispositivo full Thread per i progetti NCP (Network Co-Processor)	`-DOT_APP_NCP=ON` `-DOT_FTD=ON`
`ot-ncp-mtd`	Dispositivo Thread minimo per progettazione NCP	`-DOT_APP_NCP=ON` `-DOT_MTD=ON`
`ot-rcp`	Progettazione di radio coprocessori (RCP)	`-DOT_APP_RCP=ON` `-DOT_RCP=ON`

Per impostazione predefinita, sono abilitati tutti i flag sopra indicati. Se disabiliti esplicitamente tutti i flag, le applicazioni non vengono create, ma i file della libreria OpenThread vengono comunque generati in ./build/lib per essere utilizzati in un progetto.

Controlla la directory examples/platforms per vedere quali flag sono supportati da ciascuna piattaforma. Per ulteriori informazioni su FTD e MTD, consulta il primer per thread. Per ulteriori informazioni sui progetti SoC e NCP, consulta le Piattaforme.

Il processo per il flashing di questi programmi binari varia a seconda delle piattaforme di esempio. Per istruzioni dettagliate, consulta la cartella di esempio di README in ogni piattaforma.

Daemon OpenThread

OpenThread Daemon (OT Daemon) è una modalità di compilazione OpenThread POSIX che esegue OpenThread come servizio e viene utilizzata con la progettazione RCP. Per ulteriori informazioni su come crearlo e utilizzarlo, consulta OpenThread Daemon.

Creazione di pacchetti di assistenza

I pacchetti di assistenza alle build (BSP) si trovano in /third_party. I BSP sono codici di terze parti aggiuntivi utilizzati da OpenThread su ogni piattaforma, generalmente inclusi nel trasferimento di OpenThread a una nuova piattaforma hardware.