Usare CMake con FreerTOS

Importante

Questa pagina fa riferimento al repository Amazon-FreeRTOS che è obsoleto. Ti consigliamo di iniziare da qui quando crei un nuovo progetto. Se disponi già di un progetto FreeRTOS esistente basato sull'ormai obsoleto repository Amazon-FreerTOS, consulta il. Guida alla migrazione del repository Github di Amazon-FreeRTOS

Puoi usare CMake per generare file di build del progetto dal codice sorgente dell'applicazione FreerTOS e per creare ed eseguire il codice sorgente.

Puoi anche utilizzare un IDE per modificare, eseguire il debug, compilare, eseguire il flashing ed eseguire il codice su dispositivi certificati FreeRTOS. Ogni guida alle operazioni di base specifiche della scheda include istruzioni per configurare l'IDE per una determinata piattaforma. Se preferisci non utilizzare un'IDE, puoi usare altri strumenti di modifica e debug del codice di terze parti per lo sviluppo e il debug del codice e quindi utilizzare CMake per compilare ed eseguire le applicazioni.

CMake è supportato dalle seguenti schede:

• DevKitEspressif ESP32-C

• Espressif ESP-WROVER-KIT

• Kit di connessione IoT Infineon XMC4800

• Kit di avviamento Marvell MW320 AWS IoT

• Kit di avviamento Marvell MW322 AWS IoT

• Pacchetto Microchip Curiosity PIC32MZEF

• Kit di sviluppo Nordic NRF52840 DK

• STMicroelectronicsSTM32L4 Discovery Kit IoT Node

• Texas Instruments CC3220SF-LAUNCHXL

• Simulatore Microsoft Windows

Consulta gli argomenti seguenti per ulteriori informazioni sull'uso di CMake con FreerTOS.

Prerequisiti

Assicurati che il computer host soddisfi i seguenti prerequisiti prima di continuare:

• La toolchain di compilazione del dispositivo deve supportare il sistema operativo del computer. CMake supporta tutte le versioni di Windows, macOS e Linux.

  Il sottosistema Windows per Linux (WSL) non è supportato. Utilizza CMake nativo su computer Windows.

• Deve essere stato installato CMake versione 3.13 o successive.

  Puoi scaricare la distribuzione binaria di CMake da CMake.org.

  Nota

  Se scarichi la distribuzione binaria di CMake, assicurati di aggiungere l'eseguibile CMake alla variabile di ambiente PATH prima di utilizzare CMake dalla riga di comando.

  Puoi anche scaricare e installare CMake utilizzando un programma di gestione dei pacchetti, ad esempio homebrew su macOS e scoop o chocolatey su Windows.

  Nota

  Le versioni del pacchetto CMake fornite nei gestori di pacchetti per molte distribuzioni Linux sono. out-of-date Se il programma di gestione dei pacchetti della distribuzione non include la versione più recente di CMake, puoi provare a usare programmi di gestione dei pacchetti alternativi, ad esempio linuxbrew o nix.

• Devi disporre di un sistema di compilazione nativo compatibile.

  CMake può riguardare molti sistemi di compilazione nativi, incluso GNU Make o Ninja. Make e Ninja possono essere entrambi installati con il programma di gestione dei pacchetti su Linux, macOS e Windows. Se utilizzi Make su Windows, puoi installare una versione autonoma da Equation o installare MinGW, che include Make.

  Nota

  L'eseguibile Make in MinGW è chiamato mingw32-make.exe, anziché make.exe.

  Ti consigliamo di utilizzare Ninja, perché è più veloce di Make e fornisce anche supporto nativo per tutti i sistemi operativi desktop.

Sviluppo di applicazioni FreerTOS con editor di codice e strumenti di debug di terze parti

Puoi utilizzare un editor di codice e un'estensione di debug o uno strumento di debug di terze parti per sviluppare applicazioni per FreerTOS.

Se, ad esempio, utilizzi Visual Studio Code come editor di codice, puoi installare l'estensione Cortex-Debug di VS Code come strumento di debug. Al termine dello sviluppo dell'applicazione, è possibile richiamare lo strumento a riga di comando CMake per compilare il progetto all'interno di VS Code. Per ulteriori informazioni sull'utilizzo di CMake per creare applicazioni FreerTOS, vedere. Costruire FreerTOS con CMake

Per le operazioni di debug, puoi specificare una configurazione di debug simile alla seguente:

"configurations": [
    {
        "name": "Cortex Debug",
        "cwd": "${workspaceRoot}",
        "executable": "./build/st/stm32l475_discovery/aws_demos.elf",
        "request": "launch",
        "type": "cortex-debug",
        "servertype": "stutil"
    }
]

Costruire FreerTOS con CMake

Per impostazione predefinita, CMake definisce il sistema operativo host come sistema di destinazione. Per utilizzarlo per la compilazione incrociata, CMake richiede un file toolchain che specifica il compilatore da utilizzare. In FreerTOS, forniamo file di toolchain predefiniti in. freertos/tools/cmake/toolchains Il modo in cui fornire questo file a CMake varia a seconda se utilizzi l'interfaccia della riga di comando o la GUI di CMake. Per ulteriori dettagli, segui le istruzioni Generazione dei file di compilazione (strumento a riga di comando di CMake) di seguito. Per ulteriori informazioni sulla compilazione incrociata in CMake, consulta CrossCompilingil wiki ufficiale di CMake.

Per compilare un progetto basato su CMake

1. Eseguire CMake per generare i file di compilazione per un sistema di compilazione nativo, come Make o Ninja.

   È possibile utilizzare lo strumento a riga di comando di CMake o la GUI CMake per generare i file di compilazione per il sistema di compilazione nativo.

   Per informazioni sulla generazione di file build FreerTOS, consulta e. Generazione dei file di compilazione (strumento a riga di comando di CMake) Generazione dei file di compilazione (GUI CMake)

2. Richiamare il sistema di compilazione nativo per rendere eseguibile il progetto.

   Per informazioni sulla creazione di file build per FreerTOS, consulta. Creazione di FreerTOS da file di build generati

Generazione dei file di compilazione (strumento a riga di comando di CMake)

Puoi usare lo strumento da riga di comando CMake (cmake) per generare file di build per FreerTOS. Per generare i file di compilazione, devi specificare una scheda di destinazione, un compilatore e la posizione del codice sorgente e della directory di compilazione.

Puoi usare le seguenti opzioni per cmake:

• -DVENDOR— Specifica la scheda di destinazione.

• -DCOMPILER— specifica il compilatore.

• -S— specifica la posizione del codice sorgente.

• -B— specifica la posizione dei file di build generati.

Nota

Il compilatore deve trovarsi nella variabile PATH. In alternativa, è necessario specificare la posizione del compilatore.

Ad esempio, se il fornitore è Texas Instruments, la scheda è CC3220 Launchpad e il compilatore è GCC per ARM, puoi avviare il comando seguente per compilare i file di origine dalla directory corrente in una directory denominata build-directory:

cmake -DVENDOR=ti -DBOARD=cc3220_launchpad -DCOMPILER=arm-ti -S . -B build-directory

Nota

Se utilizzi il sistema operativo Windows, devi specificare il sistema di compilazione nativo perché CMake utilizza Visual Studio per impostazione predefinita. Per esempio:

cmake -DVENDOR=ti -DBOARD=cc3220_launchpad -DCOMPILER=arm-ti -S . -B build-directory -G Ninja

O:

cmake -DVENDOR=ti -DBOARD=cc3220_launchpad -DCOMPILER=arm-ti -S . -B build-directory -G "MinGW Makefiles"

Le espressioni regolari ${VENDOR}.* e ${BOARD}.* vengono utilizzate per cercare una scheda corrispondente, pertanto non è necessario utilizzare i nomi completi del fornitore e della scheda per le opzioni VENDOR e BOARD. È possibile utilizzare nomi parziali, purché esista una sola corrispondenza. Ad esempio, i seguenti comandi generano gli stessi file di compilazione dalla stessa origine:

cmake -DVENDOR=ti -DCOMPILER=arm-ti -S . -B build-directory

cmake -DBOARD=cc3220 -DCOMPILER=arm-ti -S . -B build-directory

cmake -DVENDOR=t -DBOARD=cc -DCOMPILER=arm-ti -S . -B build-directory

Puoi utilizzare l'opzione CMAKE_TOOLCHAIN_FILE se desideri utilizzare un file di toolchain che non si trova nella directory predefinita cmake/toolchains. Per esempio:

cmake -DBOARD=cc3220 -DCMAKE_TOOLCHAIN_FILE='/path/to/toolchain_file.cmake' -S . -B build-directory

Se il file di toolchain non utilizza percorsi assoluti per il compilatore, e non hai aggiunto il compilatore alla variabile di ambiente PATH, CMake potrebbe non essere in grado di individuarlo. Per essere certo che CMake individui il file di toolchain, puoi utilizzare l'opzione AFR_TOOLCHAIN_PATH. Questa opzione esegue una ricerca nel percorso di directory della toolchain specificato e nella sottocartella della toolchain in bin. Per esempio:

cmake -DBOARD=cc3220 -DCMAKE_TOOLCHAIN_FILE='/path/to/toolchain_file.cmake' -DAFR_TOOLCHAIN_PATH='/path/to/toolchain/' -S . -B build-directory

Per abilitare il debug, imposta CMAKE_BUILD_TYPE su debug. Con questa opzione abilitata, CMake aggiunge flag di debug alle opzioni di compilazione e crea FreerTOS con simboli di debug.

# Build with debug symbols
cmake -DBOARD=cc3220 -DCOMPILER=arm-ti -DCMAKE_BUILD_TYPE=debug -S . -B build-directory

Puoi anche impostare CMAKE_BUILD_TYPE su release per aggiungere flag di ottimizzazione alle opzioni di compilazione.

Generazione dei file di compilazione (GUI CMake)

Puoi usare la GUI di CMake per generare file di build FreerTOS.

Per generare i file di compilazione con la GUI CMake

1. Dalla riga di comando, eseguire cmake-gui per avviare la GUI.

2. Scegliere Browse Source (Sfoglia origine) e specificare l'input di origine, quindi scegliere Browse Build (Sfoglia compilazione) e specificare l'output di compilazione.

   

3. Scegliere Configure (Configura) e in Specify the build generator for this project (Specifica il generatore di compilazione per questo progetto), individuare e scegliere il sistema di compilazione che si desidera utilizzare per i file di compilazione generati. Se la finestra popup non viene visualizzata, è possibile che si stia riutilizzando una directory di compilazione esistente. In questo caso, eliminare la cache CMake scegliendo Delete Cache (Elimina cache) dal menu File.

   

4. Scegliere Specify toolchain file for cross-compiling (Specifica file di toolchain per la compilazione incrociata), quindi selezionare Next (Successivo).

5. Scegliere il file di toolchain (ad esempio, freertos/tools/cmake/toolchains/arm-ti.cmake), quindi selezionare Fine.

   La configurazione predefinita per FreerTOS è la scheda modello, che non fornisce obiettivi di livello portatili. Di conseguenza, viene visualizzata una finestra con il messaggio .

   Nota

   Se viene visualizzato il seguente errore:

   CMake Error at tools/cmake/toolchains/find_compiler.cmake:23 (message):
   Compiler not found, you can specify search path with AFR_TOOLCHAIN_PATH.

   Ciò significa che il compilatore non è nella variabile di ambiente PATH. È possibile impostare la variabile AFR_TOOLCHAIN_PATH nella GUI per indicare a CMake dove è installato il compilatore. Se la variabile AFR_TOOLCHAIN_PATH non è visualizzata, scegliere Add Entry (Aggiungi voce). Nella finestra popup, in Nome, digitare AFR_TOOLCHAIN_PATH. In Compiler Path (Percorso compilatore) digitare il percorso del compilatore, ad esempio C:/toolchains/arm-none-eabi-gcc.

6. L'aspetto della GUI dovrebbe essere simile al seguente:

   

   Scegliere AFR_BOARD, selezionare la scheda, quindi scegliere nuovamente Configure (Configura) .

7. Scegliere Generate (Genera). CMake genera i file di sistema di compilazione (ad esempio, makefile o file ninja) e questi file vengono visualizzati nella directory di compilazione specificata nella prima fase. Segui le istruzioni nella sezione successiva per generare l'immagine binaria.

Creazione di FreerTOS da file di build generati

Compilazione con un sistema di compilazione nativo

Puoi creare FreerTOS con un sistema di build nativo chiamando il comando build system dalla directory dei binari di output.

Ad esempio, se la directory di output del file di compilazione è <build_dir> e utilizzi Make come sistema di compilazione nativo, esegui i comandi seguenti:

cd <build_dir>
make -j4

Compilazione di con CMake

Puoi anche usare lo strumento da riga di comando CMake per creare FreerTOS. CMake fornisce un livello di astrazione per chiamare sistemi di compilazione nativi. Per esempio:

cmake --build build_dir

Di seguito sono riportati alcuni utilizzi comuni della modalità di compilazione dello strumento a riga di comando di CMake:

# Take advantage of CPU cores.
cmake --build build_dir --parallel 8

# Build specific targets.
cmake --build build_dir --target afr_kernel

# Clean first, then build.
cmake --build build_dir --clean-first

Per ulteriori informazioni sulle modalità di compilazione CMake, consulta la documentazione CMake.