Questa pagina è stata tradotta dall'API Cloud Translation.

Crea OpenThread

Come creare OpenThread

I passaggi per creare OpenThread variano a seconda della toolchain, della macchina dell'utente e della piattaforma di destinazione.

Il flusso di lavoro più comune è:

Configura l'ambiente di build e installa la toolchain che ti interessa:
1. Per creare direttamente su un computer,consulta il codelab della simulazione per istruzioni dettagliate.
2. Per utilizzare un container Docker con un ambiente preconfigurato, scarica ed esegui l'immagine OpenThread environment:
```
docker pull openthread/environment:latest
docker run -it --rm openthread/environment bash
```
All'interno dell'ambiente scelto, clona il repository Git di OpenThread specifico della piattaforma. Prendiamo come 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 funzionalità e comportamenti diversi durante il processo di compilazione. Le opzioni di configurazione disponibili sono dettagliate nelle seguenti località:

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

Esempi di build

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

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

Oppure, per creare la piattaforma nRF52840 con la funzionalità di rilevamento Jam abilitata nel repository:

./script/build nrf52840 UART_trans -DOT_JAM_DETECTION=ON

Binari

I seguenti file binari vengono generati in ./build/bin dal processo di compilazione. Per stabilire quali programmi binari vengono generati, utilizza i flag con il comando ./script/build. Ad esempio, per creare OpenThread e generare solo il codice 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

Binario	Description	Opzioni
`ot-cli-ftd`	Dispositivo Thread completo per progetti SoC	`-DOT_APP_CLI=ON` `-DOT_FTD=ON`
`ot-cli-mtd`	Thread Thread minimo per progetti SoC	`-DOT_APP_CLI=ON` `-DOT_MTD=ON`
`ot-ncp-ftd`	Dispositivo Thread completo per i progetti di co-processore di rete (NCP)	`-DOT_APP_NCP=ON` `-DOT_FTD=ON`
`ot-ncp-mtd`	Dispositivo Thread minimo per progetti NCP	`-DOT_APP_NCP=ON` `-DOT_MTD=ON`
`ot-rcp`	Progettazione di co-processori radio (RCP)	`-DOT_APP_RCP=ON` `-DOT_RCP=ON`

Per impostazione predefinita, tutti i flag precedenti sono attivati. 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 i Makefile di esempio per ogni piattaforma per vedere quali flag sono supportati da ciascuna di esse. Per ulteriori informazioni su FTD e MTD, consulta la pagina Thread Primer. Per ulteriori informazioni sui progetti SoC e NCP, consulta la sezione Piattaforme.

Il processo di flashing di questi programmi binari varia a seconda delle piattaforme di esempio. Per istruzioni dettagliate, vedi i README nella cartella di esempio di ogni piattaforma.

Daemon OpenThread

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

Creazione di pacchetti di assistenza

I BSP (Build Support Package) si trovano in /third_party. I BSP sono codice di terze parti aggiuntivi utilizzati da OpenThread su ogni rispettiva piattaforma, generalmente incluso quando si trasferisce OpenThread a una nuova piattaforma hardware.