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 de CMake avec FreeRTOS **Important** Cette page fait référence au Amazon-FreeRTOS référentiel 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 désormais Amazon-FreeRTOS obsolète, consultez le. [Amazon-FreeRTOS Guide de migration du référentiel Github](github-repo-migration.md) Vous pouvez 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 FreeRTOS-qualified des appareils. 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 d'édition et de débogage tiers pour développer et déboguer votre code, puis utiliser CMake pour générer et exécuter les applications. Les cartes suivantes prennent en charge CMake : + Espressif ESP32-DevKitC + Espressif ESP-WROVER-KIT + Infineon XMC4800 IoT Connectivity Kit + Kit de démarrage Marvell MW320 AWS IoT + Kit de démarrage Marvell MW322 AWS IoT + Microchip Curiosity PIC32MZEF Bundle + Kit de développement Nordic nRF52840 DK + STMicroelectronicsSTM32L4 Discovery Kit IoT Node + Instruments texans CC3220SF-LAUNCHXL + Simulateur Microsoft Windows Consultez les rubriques ci-dessous pour plus d'informations sur l'utilisation de CMake avec 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) + [Création de 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 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 natif sur les machines Windows. + Vous devez disposer de la version 3.13 (ou ultérieure) de CMake. 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 le fichier exécutable CMake l'exécutable à la variable d’environnement PATH avant d'utiliser CMake à partir de la ligne de commande. Vous pouvez également télécharger et installer CMake à l'aide d'un gestionnaire de package, tel que[homebrew](https://brew.sh/) sur macOS et [scoop](https://scoop.sh/) ou [chocolatey](https://chocolatey.org/) sur Windows. **Note** Les versions de package CMake dans les gestionnaires de package pour de nombreuses distributions Linux sont obsolètes. Si le gestionnaire de package de votre distribution ne fournit pas la version la plus récente de CMake, vous pouvez essayer d'autres gestionnaires de packages, comme `linuxbrew` ou `nix`. + Votre système de build natif doit être compatible. CMake peut cibler de nombreux systèmes de build natifs, y compris [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/) comme éditeur de code, vous pouvez installer l'extension [Cortex-Debug](https://marketplace.visualstudio.com/items?itemName=marus25.cortex-debug)VS Code en tant que débogueur. Lorsque vous avez fini de développer votre application, vous pouvez appeler l'outil de ligne de commande CMake pour générer votre projet à partir de VS Code. Pour plus d'informations sur l'utilisation de CMake pour créer des applications FreeRTOS, consultez. [Création de 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" } ] ``` ## Création de 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, CMake a besoin d’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 utilisateur graphique ou l'interface de ligne de commande CMake. Pour plus d'informations, suivez les instructions [Génération de fichiers de build (outil de ligne de commande CMake)](#cmake-gen-cli) ci-dessous. Pour plus d'informations sur la compilation croisée dans CMake, consultez le wiki officiel [CrossCompiling](https://gitlab.kitware.com/cmake/community/wikis/doc/cmake/CrossCompiling)de CMake. **Pour créer un CMake-based projet** 1. Exécutez CMake pour générer les fichiers de build pour un système de build natif, tel que Make ou Ninja. Vous pouvez utiliser l'[outil de ligne de commande CMake](https://cmake.org/cmake/help/latest/manual/cmake.1.html) ou l'[interface graphique utilisateur CMake](https://cmake.org/cmake/help/latest/manual/cmake-gui.1.html) pour générer les fichiers de build pour votre système de build 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 build (outil de ligne de commande CMake)](#cmake-gen-cli) [Génération de fichiers de build (GUI CMake)](#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 build (outil de ligne de commande CMake) Vous pouvez utiliser l'outil de ligne de commande CMake (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 une CC3220 Launchpad et que le compilateur est GCC pour ARM, vous pouvez exécuter la commande suivante pour générer les fichiers source depuis le 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 build natif, car 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' environnement `PATH`, il est possible que CMake ne trouve pas son emplacement. Pour vous assurer que CMake trouve votre fichier de chaîne d’outils, vous pouvez utiliser l'option `AFR_TOOLCHAIN_PATH`. 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 build (GUI CMake) Vous pouvez utiliser l'interface graphique de CMake pour générer des fichiers de compilation FreeRTOS. **Pour générer des fichiers de build avec la GUI CMake** 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. ![Fenêtre CMake avec des champs de saisie pour l'emplacement du code source et l'emplacement des binaires de compilation, ainsi que des options pour parcourir les sources, parcourir le répertoire de construction, rechercher, ajouter ou supprimer des entrées 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 cache CMake en choisissant **Delete Cache (Supprimer le cache)** dans le menu **File (Fichier)**. ![CMakeSetup boîte de dialogue 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 variable `AFR_TOOLCHAIN_PATH` dans l'interface utilisateur 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\_TOOLCHAIN\_PATH**. 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 : ![Fenêtre de configuration CMake 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\_BOARD**, choisissez votre carte, puis sélectionnez à nouveau **Configure (Configurer)** . 1. Choisissez **Générer**. CMake génère les fichiers du système de génération (par exemple, makefiles ou ninja), et ces fichiers apparaissent dans le répertoire de génération 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 ``` #### Création d’ avec CMake Vous pouvez également utiliser l'outil de ligne de commande CMake pour créer FreeRTOS. CMake fournit une couche d'abstraction pour appeler les systèmes de build natifs. Par exemple : ``` cmake --build {{build_dir}} ``` Voici quelques autres utilisations courantes du mode de build de l'outil de ligne de commande 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 ``` Pour plus d'informations sur le mode de build CMake, consultez la [documentation CMake](https://cmake.org/cmake/help/latest/manual/cmake.1.html#build-tool-mode).