Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation CMake avec FreeRTOS
**Important**
Cette page fait référence au référentiel Amazon-FreeRTOS qui est obsolète. Nous vous recommandons de [commencer ici](freertos-getting-started-modular.md) lorsque vous créez un nouveau projet. Si vous possédez déjà un projet FreeRTOS basé sur le référentiel Amazon-FreeRTOS, désormais obsolète, consultez le. [Guide de migration du référentiel Github d'Amazon-FreeRTOS](github-repo-migration.md)
Vous pouvez les utiliser CMake pour générer des fichiers de construction de projet à partir du code source de l'application FreeRTOS, ainsi que pour créer et exécuter le code source.
Vous pouvez également utiliser un IDE pour modifier, déboguer, compiler, flasher et exécuter du code sur des appareils compatibles FreeRTOS. Chaque manuel de démarrage propre à une carte inclut des instructions de définition de l'IDE pour une plateforme spécifique. Si vous préférez travailler sans IDE, vous pouvez utiliser d'autres outils tiers d'édition de code et de débogage pour développer et déboguer votre code, puis les utiliser CMake pour créer et exécuter les applications.
Les cartes suivantes sont compatibles CMake :
+ Espressif - C ESP32 DevKit
+ Espressif ESP-WROVER-KIT
+ Kit de connectivité Infineon XMC4800 IoT
+ Kit de MW320 AWS IoT démarrage Marvell
+ Kit de MW322 AWS IoT démarrage Marvell
+ Ensemble Microchip Curiosity PIC32 MZEF
+ Kit de développement Nordic n RF52840 DK
+ STMicroelectronicsSTM32Nœud IoT du kit L4 Discovery
+ Texas Instruments CC3220 SF-LAUNCHXL
+ Simulateur Microsoft Windows
Consultez les rubriques ci-dessous pour plus d'informations sur l'utilisation CMake de FreeRTOS.
**Topics**
+ [Conditions préalables](#building-cmake-prereqs)
+ [Développement d'applications FreeRTOS avec des éditeurs de code et des outils de débogage tiers](#developing-third-party)
+ [Construire FreeRTOS avec CMake](#building-cmake)
## Conditions préalables
Vérifiez que votre machine hôte satisfait les prérequis suivants avant de continuer :
+ La chaîne d'outils de compilation de votre appareil doit prendre en charge le système d'exploitation de la machine. CMake prend en charge toutes les versions de Windows, macOS et Linux
Le sous-système Windows pour Linux (WSL) n'est pas pris en charge. Utilisez CMake le mode natif sur les machines Windows.
+ CMake La version 3.13 ou supérieure doit être installée.
Vous pouvez télécharger la distribution binaire de CMake depuis [CMake.org](https://cmake.org/download/).
**Note**
Si vous téléchargez la distribution binaire de CMake, assurez-vous d'ajouter l' CMake exécutable à la variable d'environnement PATH avant de l'utiliser CMake depuis la ligne de commande.
Vous pouvez également le télécharger et CMake l'installer à l'aide d'un gestionnaire de paquets, comme [homebrew](https://brew.sh/) sur macOS et [scoop](https://scoop.sh/) ou [chocolatey](https://chocolatey.org/) sur Windows.
**Note**
Les versions de CMake package fournies dans les gestionnaires de packages pour de nombreuses distributions Linux sont out-of-date. Si le gestionnaire de packages de votre distribution ne fournit pas la dernière version de CMake, vous pouvez essayer d'autres gestionnaires de packages, tels que `linuxbrew` ou`nix`.
+ Votre système de build natif doit être compatible.
CMake peut cibler de nombreux systèmes de construction natifs, notamment [GNU Make](https://www.gnu.org/software/make/) ou [Ninja](https://github.com/ninja-build/ninja/releases). Make et Ninja peuvent être installés à l’aide de gestionnaires de package sous Linux, macOS et Windows. Si vous utilisez Make sous Windows, vous pouvez installer une version autonome de [Equation](http://www.equation.com/servlet/equation.cmd?fa=make), ou vous pouvez installer [MinGW](https://sourceforge.net/projects/mingw-w64/files/), qui comprend Make.
**Note**
Dans MinGW, le fichier exécutable de Make se nomme `mingw32-make.exe`, et non pas `make.exe`.
Nous vous recommandons d'utiliser Ninja, car il est plus rapide que Make et fournit également une prise en charge native pour tous les systèmes d'exploitation de bureau.
## Développement d'applications FreeRTOS avec des éditeurs de code et des outils de débogage tiers
Vous pouvez utiliser un éditeur de code et une extension de débogage ou un outil de débogage tiers pour développer des applications pour FreeRTOS.
Si, par exemple, vous utilisez [Visual Studio Code](https://code.visualstudio.com/) en tant qu'éditeur de code, vous pouvez installer l'extension de code VS [Cortex-Debug](https://marketplace.visualstudio.com/items?itemName=marus25.cortex-debug) en tant que débogueur. Lorsque vous avez terminé de développer votre application, vous pouvez invoquer l'outil de CMake ligne de commande pour créer votre projet à partir de VS Code. Pour plus d'informations sur l'utilisation CMake pour créer des applications FreeRTOS, consultez. [Construire FreeRTOS avec CMake](#building-cmake)
Pour le débogage, vous pouvez fournir un code VS avec la configuration de débogage similaire à ce qui suit :
```
"configurations": [
{
"name": "Cortex Debug",
"cwd": "${workspaceRoot}",
"executable": "./build/st/stm32l475_discovery/aws_demos.elf",
"request": "launch",
"type": "cortex-debug",
"servertype": "stutil"
}
]
```
## Construire FreeRTOS avec CMake
CMake cible votre système d'exploitation hôte en tant que système cible par défaut. Pour l'utiliser pour la compilation croisée, il CMake faut un fichier de chaîne d'outils, qui spécifie le compilateur que vous souhaitez utiliser. Dans FreeRTOS, nous fournissons des fichiers de chaîne d'outils par défaut dans. `freertos/tools/cmake/toolchains` La manière de fournir ce fichier CMake varie selon que vous utilisez l'interface de ligne de CMake commande ou l'interface graphique. Pour plus d'informations, suivez les instructions [Génération de fichiers de compilation (outil CMake en ligne de commande)](#cmake-gen-cli) ci-dessous. Pour plus d'informations sur la compilation croisée dans CMake, consultez le [CrossCompiling](https://gitlab.kitware.com/cmake/community/wikis/doc/cmake/CrossCompiling)wiki officiel CMake .
**Pour créer un projet CMake basé**
1. Exécutez CMake pour générer les fichiers de construction pour un système de construction natif, tel que Make ou Ninja.
Vous pouvez utiliser l'[outil de CMake ligne de commande](https://cmake.org/cmake/help/latest/manual/cmake.1.html) ou l'[CMake interface graphique](https://cmake.org/cmake/help/latest/manual/cmake-gui.1.html) pour générer les fichiers de génération pour votre système de génération natif.
Pour plus d'informations sur la génération de fichiers de compilation FreeRTOS, reportez-vous aux sections et. [Génération de fichiers de compilation (outil CMake en ligne de commande)](#cmake-gen-cli) [Génération de fichiers de compilation (CMake GUI)](#cmake-gen-gui)
1. Appelez le système de build natif pour transformer le projet en fichier exécutable.
Pour plus d'informations sur la création de fichiers de compilation FreeRTOS, consultez. [Création de FreeRTOS à partir des fichiers de construction générés](#cmake-build)
### Génération de fichiers de compilation (outil CMake en ligne de commande)
Vous pouvez utiliser l'outil de CMake ligne de commande (cmake) pour générer des fichiers de compilation pour FreeRTOS. Pour générer les fichiers de build, vous devez spécifier une carte cible, un compilateur et l'emplacement du code source et du répertoire de build.
Vous pouvez utiliser les options suivantes pour cmake :
+ `-DVENDOR`— Spécifie le tableau cible.
+ `-DCOMPILER`— Spécifie le compilateur.
+ `-S`— Spécifie l'emplacement du code source.
+ `-B`— Spécifie l'emplacement des fichiers de compilation générés.
**Note**
Le compilateur doit se trouver dans la variable `PATH` du système, ou bien vous devez spécifier l'emplacement du compilateur.
Par exemple, si le fournisseur est Texas Instruments, que la carte est le CC3220 Launchpad et que le compilateur est GCC pour ARM, vous pouvez exécuter la commande suivante pour créer les fichiers source du répertoire actuel vers un répertoire nommé : `build-directory`
```
cmake -DVENDOR=ti -DBOARD=cc3220_launchpad -DCOMPILER=arm-ti -S . -B build-directory
```
**Note**
Si vous utilisez Windows, vous devez spécifier le système de génération natif car il CMake utilise Visual Studio par défaut. Par exemple :
```
cmake -DVENDOR=ti -DBOARD=cc3220_launchpad -DCOMPILER=arm-ti -S . -B build-directory -G Ninja
```
Ou:
```
cmake -DVENDOR=ti -DBOARD=cc3220_launchpad -DCOMPILER=arm-ti -S . -B build-directory -G "MinGW Makefiles"
```
Les expressions régulières `${VENDOR}.*` et `${BOARD}.*` sont utilisées pour rechercher une carte correspondante, afin que vous n’ayez pas à utiliser les noms complets du fournisseur et de la carte pour les options `VENDOR` et `BOARD`. Vous pouvez utiliser les noms partiels, à condition qu'il n’existe qu’une seule correspondance. Par exemple, les commandes suivantes génèrent les mêmes fichiers de build à partir de la même source :
```
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
```
Vous pouvez utiliser l' option `CMAKE_TOOLCHAIN_FILE` si vous souhaitez utiliser un fichier de chaîne d’outils qui ne figure pas dans le répertoire `cmake/toolchains` par défaut. Par exemple :
```
cmake -DBOARD=cc3220 -DCMAKE_TOOLCHAIN_FILE='/path/to/toolchain_file.cmake' -S . -B build-directory
```
Si le fichier de chaîne d'outils n'utilise pas de chemins absolus pour votre compilateur et que vous n'avez pas ajouté votre compilateur à la variable d'`PATH`environnement, vous ne pourrez CMake peut-être pas le trouver. Pour vous assurer qu'il CMake trouve votre fichier de chaîne d'outils, vous pouvez utiliser l'`AFR_TOOLCHAIN_PATH`option. Cette option recherche le chemin du répertoire de la chaîne d’outils spécifiée et le sous-dossier dans `bin`. Par exemple :
```
cmake -DBOARD=cc3220 -DCMAKE_TOOLCHAIN_FILE='/path/to/toolchain_file.cmake' -DAFR_TOOLCHAIN_PATH='/path/to/toolchain/' -S . -B build-directory
```
Pour activer le débogage, définissez le paramètre `CMAKE_BUILD_TYPE` sur `debug`. Lorsque cette option est activée, CMake ajoute des indicateurs de débogage aux options de compilation et construit FreeRTOS avec des symboles de débogage.
```
# Build with debug symbols
cmake -DBOARD=cc3220 -DCOMPILER=arm-ti -DCMAKE_BUILD_TYPE=debug -S . -B build-directory
```
Vous pouvez également définir `CMAKE_BUILD_TYPE` sur `release` pour ajouter des indicateurs d'optimisation aux options de compilation.
### Génération de fichiers de compilation (CMake GUI)
Vous pouvez utiliser l' CMake interface graphique pour générer des fichiers de compilation FreeRTOS.
**Pour générer des fichiers de build à l'aide de l' CMake interface graphique**
1. À partir de la ligne de commande, exécutez `cmake-gui` pour lancer la GUI.
1. Sélectionnez **Browse Source (Sélectionner la source)** et spécifiez l’entrée source, puis sélectionnez **Browse Build (Sélectionner la build)** et spécifiez la sortie de la build.
![\[CMake fenêtre avec des champs de saisie pour l'emplacement du code source et l'emplacement des fichiers binaires de construction, ainsi que des options pour parcourir les sources, parcourir le répertoire de construction, rechercher, ajouter ou supprimer une entrée et afficher les options groupées ou avancées.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/cmake-gui1.png)
1. Choisissez **Configure (Configurer)**, et sous **Specify the build generator for this project (Spécifier le générateur de build pour ce projet)**, recherchez et choisissez le système de build que vous souhaitez utiliser pour générer les fichiers de build générés. Si vous ne voyez pas la fenêtre contextuelle, il se peut que vous réutilisiez un répertoire de build existant. Dans ce cas, supprimez le CMake cache en choisissant **Supprimer le cache** dans le menu **Fichier**.
![\[CMakeBoîte de dialogue de configuration avec des options permettant de spécifier le générateur du projet sous forme de Makefiles Unix et de spécifier le fichier de chaîne d'outils pour la compilation croisée.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/cmake-gui2.png)
1. Sélectionnez **Specify toolchain file for cross-compiling (Spécifier le fichier de chaîne d’outils pour compilation croisée**, puis sélectionnez **Next (Suivant)**.
1. Choisissez le fichier de chaîne d'outils (par exemple, `freertos/tools/cmake/toolchains/arm-ti.cmake`), puis sélectionnez **Terminer**.
La configuration par défaut de FreeRTOS est le tableau de modèles, qui ne fournit aucune cible de couche portable. Une fenêtre s'affiche alors avec le message Error in configuration process.
**Note**
Si vous voyez l'erreur suivante :
```
CMake Error at tools/cmake/toolchains/find_compiler.cmake:23 (message):
Compiler not found, you can specify search path with AFR_TOOLCHAIN_PATH.
```
Cela signifie que le compilateur ne se trouve pas dans votre variable d'environnement `PATH`. Vous pouvez définir la `AFR_TOOLCHAIN_PATH` variable dans l'interface graphique pour indiquer CMake où vous avez installé votre compilateur. Si vous ne voyez pas la variable `AFR_TOOLCHAIN_PATH`, choisissez **Add Entry (Ajouter une entrée)**. Dans la fenêtre contextuelle, sous **Name (Nom)**, tapez **AFR\$1TOOLCHAIN\$1PATH**. Sous **Compiler Path (Chemin d’accès du compilateur)**, tapez le chemin d'accès à votre compilateur. Par exemple, `C:/toolchains/arm-none-eabi-gcc`.
1. La GUI devrait maintenant ressembler à ceci :
![\[CMake fenêtre de configuration pour créer des FreeRTOS avec le tableau des fournisseurs sélectionné, les modules activés et les chemins de construction spécifiés.\]](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/cmake-gui3.png)
Sélectionnez **AFR\$1BOARD**, choisissez votre carte, puis sélectionnez à nouveau **Configure (Configurer)** .
1. Choisissez **Générer**. CMake génère les fichiers système de construction (par exemple, les fichiers makefiles ou ninja), et ces fichiers apparaissent dans le répertoire de construction que vous avez spécifié lors de la première étape. Suivez les instructions de la section suivante pour générer l'image binaire.
### Création de FreeRTOS à partir des fichiers de construction générés
#### Génération avec un système de génération natif
Vous pouvez créer FreeRTOS avec un système de construction natif en appelant la commande build system depuis le répertoire des binaires de sortie.
Par exemple, si votre répertoire de sortie de fichier de build est ``, et que vous utilisez CMake en tant que système de build natif, exécutez les commandes suivantes :
```
cd
make -j4
```
#### Construire avec CMake
Vous pouvez également utiliser l'outil de CMake ligne de commande pour créer FreeRTOS. CMake fournit une couche d'abstraction pour appeler des systèmes de construction natifs. Par exemple :
```
cmake --build build_dir
```
Voici d'autres utilisations courantes du mode de génération de l'outil de CMake ligne de commande :
```
# 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
```
Pour plus d'informations sur le mode de CMake construction, consultez la [CMake documentation](https://cmake.org/cmake/help/latest/manual/cmake.1.html#build-tool-mode).