stm32 cube cmake vscode

Environnement de développement STM32 avec Visual Studio Code et CMake

Ce didacticiel explique les étapes pour développer et déboguer efficacement une application STM32 dans Visual Studio Code à l'aide du générateur de build CMake , de l'outil de build Ninja et du compilateur GCC .

Choses que vous apprendrez

• Comment installer et configurer tous les outils

• Comment créer un nouveau projet STM32 avec les outils STM32CubeMX ou STM32CubeIDE

• Comment installer et configurer les extensions recommandées pour Visual Studio Code pour un développement plus facile

• Comment configurer les listes CMake et les préréglages CMake

• Comment générer un système de build pour le compilateur

• Comment compiler le projet avec GCC

• Comment flasher et déboguer une application sur la cible STM32

Ce didacticiel utilise le système d'exploitation Windows . Une procédure similaire s’appliquera aux systèmes d’exploitation Linux et MAC.

Installation d'outils

Mise à jour d'août 2024

Le didacticiel d'installation des outils vous aidera à comprendre les outils nécessaires pour travailler avec STM32 et est généralement utile aux débutants pour se mettre à jour et comprendre correctement les exigences nécessaires.

Depuis un certain temps, ST dispose d'un nouvel outil logiciel STM32CubeCLT, qui inclut les outils de build nécessaires pour vscode, notamment le système de build Ninja et le générateur de build CMake . STM32CubeCLT (Command Line Tools) est un moyen simple et facile de se mettre rapidement au courant du développement vscode. Il configurera également automatiquement vos variables d'environnement de construction ( Chemin dans le cas de Windows), vous permettant d'invoquer ninja , cmake ou d'autres commandes directement à partir de l'outil de ligne de commande.

En installant le STM32CubeCLT , vous n'obtiendrez pas l'outil graphique STM32CubeIDE , ni aucune fonctionnalité d'outil de configuration MCU, mais simplement des outils de ligne de commande pour appeler la construction et le débogage, normalement à partir de vscode . Vous devrez toujours installer séparément vscode et les extensions nécessaires.

STM32CubeIDE

La première étape consiste à installer STM32CubeIDE, qui sera utilisé pour démarrer facilement un nouveau projet STM32 et il est livré avec l'outil STM32CubeMX intégré - nous permettant une configuration graphique.

STM32CubeIDE fournit également les outils nécessaires nécessaires ultérieurement au développement de VSCode

• ARM aucun compilateur eabi GCC

• ST-LINK GDBServer pour le débogage

• Outil STM32CubeProgrammer pour le téléchargement de code et les pilotes ST-Link respectifs

• Dossier avec les fichiers SVD STM32

• Pilotes pour ST-Link

Configuration du chemin environnemental

3 chemins doivent être ajoutés aux paramètres environnementaux à partir de l'installation de STM32CubeIDE, un chemin pour chacun des outils mentionnés ci-dessus. Dans le cas de mon ordinateur, en utilisant STM32CubeIDE 1.8 (mis à jour via Eclipse, donc mon chemin d'installation actuel affiche toujours la version 1.0.2 ), les chemins sont définis comme :

• Compilateur GCC : c:STSTM32CubeIDE_1.0.2STM32CubeIDEpluginscom.st.stm32cube.ide.mcu.externaltools.gnu-tools-for-stm32.9-2020-q2-update.win32_2.0.0.202105311346toolsbin

• Serveur ST-Link GDB : c:STSTM32CubeIDE_1.0.2STM32CubeIDEpluginscom.st.stm32cube.ide.mcu.externaltools.stlink-gdb-server.win32_2.0.100.202109301221toolsbin

• CLI du programmeur STM32Cube : c:STSTM32CubeIDE_1.0.2STM32CubeIDEpluginscom.st.stm32cube.ide.mcu.externaltools.cubeprogrammer.win32_2.0.100.202110141430toolsbin

Vos chemins peuvent différer selon les numéros de version

Vérifiez la configuration correcte du chemin, exécutez :

arm-none-eabi-gcc --version
STM32_Programmer_CLI --version
ST-LINK_gdbserver --version

Cela devrait produire un résultat similaire à l'image ci-dessous

CMake

Cette étape n'est pas nécessaire si vous avez installé les outils de build avec STM32CubeCLT

Téléchargez et installez CMake.

L'assistant d'installation vous demandera d'ajouter CMake aux chemins environnementaux. Sélectionnez l’option ou ajoutez le dossier bin du dossier d’installation de CMake au chemin environnemental.

Ninja

Cette étape n'est pas nécessaire si vous avez installé les outils de build avec STM32CubeCLT

Téléchargez le système de construction Ninja à partir de la page des versions de Github. Il se présente sous forme d’exécutable portable, sans rien installer. Cependant il doit être visible au niveau de l'environnement, comme tous les outils précédents.

Vérifiez l'installation de CMake et Ninja , exécutez :

cmake --version
ninja --version

Le résultat doit être quelque chose de similaire à

Code de Visual Studio

Téléchargez et installez VSCode. Une fois installée et ouverte, la fenêtre ressemblera à celle ci-dessous.

Extensions de code Visual Studio

Visual Studio Code est un éditeur de texte léger avec la possibilité de l'agrandir à l'aide d'extensions.

Liste des extensions utiles pour le développement STM32 à l'aide de CMake :

• ms-vscode.cpptools : mise en évidence de la syntaxe et autres fonctionnalités principales pour le développement C/C++

• ms-vscode.cmake-tools : outils de base CMake, outil générateur de système de construction

• twxs.cmake : mise en évidence des couleurs CMake

• marus25.cortex-debug : Extension de débogage Cortex-M, obligatoire pour le débogage STM32 depuis VSCode

• dan-c-underwood.arm : surligneur de syntaxe d'assemblage ARM

• zixuanwang.linkerscript : surligneur de syntaxe du script GCC Linker

Vous pouvez les installer en copiant les commandes ci-dessous dans la fenêtre du terminal interne de VSCode.

code --install-extension ms-vscode.cpptools
code --install-extension ms-vscode.cmake-tools
code --install-extension twxs.cmake
code --install-extension marus25.cortex-debug
code --install-extension dan-c-underwood.arm
code --install-extension zixuanwang.linkerscript

Allez dans Terminal -> Nouveau terminal pour ouvrir une nouvelle fenêtre de terminal

Une autre méthode consiste à utiliser l'interface graphique de recherche d'extensions et à l'installer manuellement à partir de là.

Outils installés - point de contrôle

À ce stade, tous les outils sont correctement installés : vous êtes sur la bonne voie vers le succès.

Création d'un nouveau projet

L'exigence fondamentale pour avancer est d'avoir un projet fonctionnel qui sera converti en CMake et développé en VSCode . À cette fin, je vous guiderai à travers la création simple d'un nouveau projet à l'aide des outils logiciels STM32CubeMX ou STM32CubeIDE .

Vous pouvez ignorer cette partie si vous avez déjà votre projet sur lequel travailler.

J'ai utilisé l'outil STM32CubeIDE et la carte STM32H735G-DK pour cette démo.

Ouvrez STM32CubeIDE et démarrez un nouveau projet

Sélectionnez STM32 MCU - J'ai sélectionné STM32H735IG qui est utilisé sur la carte STM32H735G-DK

Sélectionnez le nom et le chemin du projet, puis créez le projet et attendez que la vue Pinout s'ouvre.

Notre tâche est d'avoir un projet simple qui fera basculer les LED. Les LED sont connectées respectivement à PC2 et PC3 , actives LOW. Les broches peuvent être configurées en mode push-pull de sortie ou en mode drain ouvert

Définir les broches comme sorties avec des étiquettes facultatives comme LED1 et LED2 respectivement

Si vous utilisez STM32CubeMX , accédez au Gestionnaire de projets , définissez le nom du projet et assurez-vous que STM32CubeIDE est sélectionné comme Toolchain .

Accédez aux paramètres avancés et sélectionnez LL comme pilotes pour le code généré

Nous utilisons les pilotes LL par souci de simplicité dans ce tutoriel

Régénérez le projet en appuyant sur le bouton rouge ou en enregistrant le projet avec le raccourci CTRL + S

Le projet est maintenant (re)généré. Les fichiers surlignés en jaune sont des sources à construire. Le bleu est le script de l'éditeur de liens.

C'est tout pour la première exécution, nous sommes prêts à compiler. Appuyez sur CTRL + B ou cliquez sur l'icône du marteau pour commencer. STM32CubeIDE compilera le projet, vous devriez voir similaire à l'image ci-dessous. Il est maintenant prêt à flasher le flash du MCU et à commencer le débogage.

C'est la fin de la première partie, où nous avons créé avec succès notre projet. À ce stade, nous considérons que le projet est prêt à être transféré vers un système de construction basé sur CMake.

Vous pouvez continuer votre développement avec STM32CubeIDE à l'avenir, ajouter de nouvelles sources, modifier le code, compiler, flasher le binaire et déboguer directement le microcontrôleur. Il s'agit du studio de développement STM32 préféré, développé et maintenu par STMicroelectronics.

Configuration de CMake

Il est prévu qu'un projet à développer dans VSCode ait été créé. Nous allons avancer sur le compilateur GCC, mais d'autres pourraient également être utilisés.

Avec la sortie de Visual Studio Code, de nombreux développeurs utilisent l'outil pour de nombreux langages de programmation et peuvent heureusement également développer des applications STM32 avec un seul outil. Si vous faites partie des développeurs aimant VSCode, la manière la plus élégante d'avancer est de transférer le projet basé sur STM32CubeIDE vers CMake , de développer du code dans VSCode et de le compiler avec le système de construction Ninja à l'aide du compilateur GCC. C'est rapide et léger.

Le développement dans VSCode est destiné aux utilisateurs intermédiaires ou expérimentés. Je suggère à tous les débutants STM32 de rester avec la chaîne d'outils de développement STM32CubeIDE . Il sera très facile d'avancer et de revenir sur le sujet VSCode plus tard.

Préparer le fichier CMakeLists.txt

Chaque application basée sur CMake nécessite le fichier CMakeLists.txt dans le répertoire racine , qui décrit le projet et fournit des informations d'entrée pour la génération du système de construction.

Le fichier racine CMakeLists.txt est parfois appelé fichier CMake de niveau supérieur.

Éléments essentiels décrits dans le fichier CMakeLists.txt :

• Informations sur la chaîne d'outils, telles que la configuration GCC avec les indicateurs de build

• Nom du projet

• Fichiers sources à construire avec le compilateur, fichiers C, C++ ou Assembly

• Liste des chemins d'inclusion permettant au compilateur de trouver des fonctions, des définitions, ... ( -I )

• Chemin du script de l'éditeur de liens

• Définitions de compilation, ou parfois appelées définitions de préprocesseur ( -D )

• Paramètres Cortex-Mxx et virgule flottante pour la génération de jeux d'instructions

Ouvrez VSCode dans le dossier racine du projet

Visual Studio Code a été installé et sera utilisé comme éditeur de fichiers supplémentaire.

Recherchez le chemin de votre projet généré et ouvrez le dossier avec VSCode :

• Option 1 : Accédez au dossier avec l'explorateur, puis faites un clic droit et sélectionnez Open in Code .

• Option 2 : vous pouvez également ouvrir VScode en tant que nouvelle solution vide et y ajouter un dossier manuellement. Utilisez File -> Open Folder... pour ouvrir le dossier

• Option 3 : accédez au dossier avec l'outil cmd ou PowerShell et exécutez code .

Le résultat final devrait ressembler à celui ci-dessous

Informations sur la chaîne d'outils

CMake doit connaître la Toolchain que nous aimerions utiliser pour enfin compiler le projet. Comme la même chaîne d'outils est généralement réutilisée entre différents projets, il est conseillé de créer cette pièce dans un fichier séparé pour une réutilisation plus facile. Il s'agit de paramètres génériques du compilateur et non directement liés aux projets eux-mêmes.

Un simple fichier .cmake peut être utilisé et réutilisé ultérieurement entre vos différents projets. J'utilise le nom cmake/gcc-arm-none-eabi.cmake pour ce tutoriel et voici son exemple :

 set(CMAKE_SYSTEM_NAME Generic)set(CMAKE_SYSTEM_PROCESSOR arm)# Certains paramètres GCC par défaut# arm-none-eabi- doivent faire partie du chemin d'environnementset(TOOLCHAIN_PREFIX arm-none-eabi-)set(FLAGS "-fdata-sections -ffunction-sections - -specs=nano.specs -Wl,--gc-sections")set(CPP_FLAGS "-fno-rtti -fno-exceptions -fno-threadsafe-statics")# Définir les paramètres du compilateurset(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}gcc ${FLAGS})set(CMAKE_ASM_COMPILER ${CMAKE_C_COMPILER})set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}g++ $ {DRAPEAU} ${CPP_FLAGS})set(CMAKE_OBJCOPY ${TOOLCHAIN_PREFIX}objcopy)set(CMAKE_SIZE ${TOOLCHAIN_PREFIX}taille)set(CMAKE_EXECUTABLE_SUFFIX_ASM ".elf")set(CMAKE_EXECUTABLE_SUFFIX_C ".elf")set(CMAKE_EXECUTABLE_SUFFIX_CXX ".elf")ensemble(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)

Créez un fichier dans le dossier cmake/ du répertoire racine du projet.

Si le plugin de surligneur CMake est installé, VSCode mettra joliment en évidence les commandes CMake pour vous

La configuration de la chaîne d'outils est terminée. Vous pouvez librement fermer le fichier et passer à l'étape suivante.

Créer le fichier principal CMakeLists.txt

Nous devons créer le fichier CMakeLists.txt principal, également appelé fichier CMake racine .

Assurez-vous de bien le nommer CMakeLists.txt avec les caractères majuscules et minuscules corrects.

J'ai préparé pour vous un fichier modèle simple, qui peut être réutilisé pour tous vos projets à l'avenir. Vous aurez juste besoin de modifier des éléments tels que le nom du projet, les fichiers sources, les chemins d'accès, etc.

 cmake_minimum_required(VERSION 3.22)# Configurer les paramètres du compilateurset(CMAKE_C_STANDARD 11)set(CMAKE_C_STANDARD_REQUIRED ON)set(CMAKE_C_EXTENSIONS ON)set(CMAKE_CXX_STANDARD 20)set(CMAKE_CXX_STANDARD_REQUIRED ON)set(CMAKE_CXX_EXTENSIONS ON)set(PROJ_PATH ${CMAKE_CURRENT_SOURCE_DIR})message("Type de build : " ${CMAKE_BUILD_TYPE})## Paramètres du projet principal#project(votre-nom-de-projet)enable_langue(C CXX ASM)## Indicateurs MCU de base, CPU, jeu d'instructions et configuration FPU# Doit être défini correctement pour votre MCU#set(CPU_PARAMETERS
    -mthumb# Cela nécessite une attention particulière pour être correctement défini pour le MCU-mcpu=cortex-m7 utilisé
    -mfpu=fpv5-d16
    -mfloat-abi=dur
)# Set linker scriptset(linker_script_SRC ${PROJ_PATH}/path-to-linker-script.ld)set(EXECUTABLE ${CMAKE_PROJECT_NAME})## Liste des fichiers sources à compiler#set(sources_SRCS# Mettez ici vos fichiers sources, un dans chaque ligne, par rapport à l'emplacement du fichier CMakeLists.txt)## Inclure les répertoires#set(include_path_DIRS# Mettez ici vos répertoires d'inclusion, un dans chaque ligne, par rapport à l'emplacement du fichier CMakeLists.txt)## Définition des symboles#set(symbols_SYMB# Mettez ici vos symboles (définis par le préprocesseur), un dans chaque ligne# Encapsulez-les avec des guillemets doubles pour des raisons de sécurité)# Fichiers exécutablesadd_executable(${ EXECUTABLE} ${sources_SRCS})# Inclure pathstarget_include_directories(${EXECUTABLE} PRIVATE ${include_path_DIRS})# Symbole du projetstarget_compile_definitions(${EXECUTABLE} PRIVATE ${symbols_SYMB})# Options du compilateurstarget_compile_options(${EXECUTABLE} PRIVATE${CPU_PARAMETERS}-Wall
    -Wextra
    -Wpédantique
    -Wno-unused-parameter# Configuration de débogage complète-Og -g3 -ggdb
)# Options de l'éditeur de liensstarget_link_options(${EXECUTABLE} PRIVATE-T${linker_script_SRC}${CPU_PARAMETERS}-Wl,-Map=${CMAKE_PROJECT_NAME}.map
    --specs=nosys.specs
    -u _printf_float # Prise en charge du formatage flottant STDIO-Wl,--start-group
    -lc
    -lm
    -lstdc++
    -lsupc++
    -Wl,--groupe-fin
    -Wl,--impression-utilisation-de-la-mémoire
)# Exécuter la post-construction pour imprimer sizeadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_SIZE} $<TARGET_FILE:${EXECUTABLE}>
)# Convertir la sortie en hexadécimal et en binaireadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O ihex $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.hex
)# Convertir en fichier bin -> ajouter une vérification conditionnelle ?add_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O binaire $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.bin
)

Les fichiers sources sont les mêmes que dans le projet STM32CubeIDE . Vous pouvez vérifier l'image précédente avec les sources surlignées en jaune.

Les symboles et les chemins d'inclusion peuvent être trouvés dans STM32CubeIDE sous les paramètres du projet. 2 images ci-dessous montrent comment cela se passe dans le cas d'un projet de démonstration.

La configuration de Cortex-Mxx nécessite une attention particulière, en particulier avec la configuration en virgule flottante. Pour STM32H735xx , les paramètres doivent être définis comme ci-dessous.

 ensemble(CPU_PARAMETERS
    -mpouce
    -mcpu=cortex-m7 # Définir Cortex-M CPU-mfpu=fpv5-d16 # Définir le type à virgule flottante-mfloat-abi=hard # Mode ABI matériel)

La règle générale pour les paramètres serait conforme au tableau ci-dessous

Famille STM32	-mcpu	-mfpu	-mfloat-abi
STM32F0	cortex-m0	Not used	soft
STM32F1	cortex-m3	Not used	soft
STM32F2	cortex-m3	Not used	soft
STM32F3	cortex-m4	fpv4-sp-d16	hard
STM32F4	cortex-m4	fpv4-sp-d16	hard
STM32F7 SP	cortex-m7	fpv5-sp-d16	hard
STM32F7-DP	cortex-m7	fpv5-d16	hard
STM32G0	cortex-m0plus	Not used	soft
STM32C0	cortex-m0plus	Not used	soft
STM32G4	cortex-m4	fpv4-sp-d16	hard
STM32H5	cortex-m33	fpv5-sp-d16	hard
STM32H7	cortex-m7	fpv5-d16	hard
STM32L0	cortex-m0plus	Not used	soft
STM32L1	cortex-m3	Not used	soft
STM32L4	cortex-m4	fpv4-sp-d16	hard
STM32L5	cortex-m33	fpv5-sp-d16	hard
STM32U0	cortex-m0plus	Not used	soft
STM32U5	cortex-m33	fpv5-sp-d16	hard
STM32WB	cortex-m4	fpv4-sp-d16	hard
STM32WBA	cortex-m33	fpv5-sp-d16	hard
STM32WLCM4	cortex-m4	Not used	soft
STM32WLCM0	cortex-m0plus	Not used	soft

Ce tableau est sujet à des erreurs potentielles, non testé avec le compilateur GCC pour toutes les lignes. Pour STM32F7 , accédez au site officiel de STM32F7xx et vérifiez si votre appareil dispose d'un FPU simple ou double précision, puis appliquez les paramètres en conséquence. La liste des produits n'est pas exhaustive.

Le fichier CMakeLists.txt final après les fichiers source, les chemins d'inclusion, les paramètres de base du MCU et les définitions sont définis :

 cmake_minimum_required(VERSION 3.22)# Configurer les paramètres du compilateurset(CMAKE_C_STANDARD 11)set(CMAKE_C_STANDARD_REQUIRED ON)set(CMAKE_C_EXTENSIONS ON)set(CMAKE_CXX_STANDARD 20)set(CMAKE_CXX_STANDARD_REQUIRED ON)set(CMAKE_CXX_EXTENSIONS ON)set(PROJ_PATH ${CMAKE_CURRENT_SOURCE_DIR})message("Type de build : " ${CMAKE_BUILD_TYPE})## Paramètres du projet de base#project(STM32H735G-DK-LED) # Modifiedenable_langage (C CXX ASM)## Indicateurs MCU de base, CPU , jeu d'instructions et configuration FPU# Doit être défini correctement pour votre MCU#ensemble(CPU_PARAMETERS
    -mthumb# Cela nécessite une attention particulière pour être correctement défini pour le MCU-mcpu=cortex-m7 # Modified-mfpu=fpv5-d16 # Modified-mfloat-abi=hard # Modified)# Définir le jeu de scripts de l'éditeur de liens (linker_script_SRC ${PROJ_PATH}/STM32H735IGKX_FLASH. ld) # Ensemble modifié (EXECUTABLE ${CMAKE_PROJECT_NAME})## Liste des fichiers sources à compiler#set(sources_SRCS # Modifié${PROJ_PATH}/Core/Src/main.c${PROJ_PATH}/Core/Src/stm32h7xx_it.c${PROJ_PATH}/Core/Src/syscalls.c${PROJ_PATH}/Core/Src/sysmem.c$ { PROJ_PATH}/Core/Src/system_stm32h7xx.c${PROJ_PATH}/Core/Startup/startup_stm32h735igkx.s${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm3 2h7xx_ll_exti.c${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_gpio.c${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_l l_pwr.c${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_rcc.c${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_utils.c
)## Inclure les répertoires#set(include_path_DIRS # Modified${PROJ_PATH}/Core/Inc${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Inc${PROJ_PATH}/Drivers/CMSIS/Device/ST/STM32H7xx/Include${PROJ_PATH}/ Pilotes/CMSIS/Inclure
)## Définition des symboles#set(symbols_SYMB # Modifié"DEBUG""STM32H735xx""USE_FULL_LL_DRIVER""HSE_VALUE=25000000")# Fichiers exécutablesadd_executable(${EXECUTABLE} ${sources_SRCS})# Inclure pathstarget_include_directories(${EXECUTABLE} PRIVATE ${include_path_DIRS})# Symbole du projetstarget_compile_definitions(${EXECUTABLE} PRIVATE ${symbols_SYMB})# Options du compilateurstarget_compile_options(${EXECUTABLE} PRIVATE${CPU_PARAMETERS}-Wall
    -Wextra
    -Wpédantique
    -Wno-unused-parameter# Configuration de débogage complète-Og -g3 -ggdb
)# Options de l'éditeur de liensstarget_link_options(${EXECUTABLE} PRIVATE-T${linker_script_SRC}${CPU_PARAMETERS}-Wl,-Map=${CMAKE_PROJECT_NAME}.map
    --specs=nosys.specs
    -u _printf_float # Prise en charge du formatage flottant STDIO-Wl,--start-group
    -lc
    -lm
    -lstdc++
    -lsupc++
    -Wl,--groupe-fin
    -Wl,--impression-utilisation-de-la-mémoire
)# Exécuter la post-construction pour imprimer sizeadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_SIZE} $<TARGET_FILE:${EXECUTABLE}>
)# Convertir la sortie en hexadécimal et en binaireadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O ihex $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.hex
)# Convertir en fichier bin -> ajouter une vérification conditionnelle ?add_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O binaire $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.bin
)

Dans VSCode, bien mis en évidence, ça ressemble à ça

Créer un fichier CMakePresets.json prédéfini

CMakePresets.json est un fichier spécial, disponible depuis CMake 3.18 et fournit une définition de la configuration utilisateur, similaire à la configuration de débogage et de publication connue dans Eclipse. Ce fichier permet au développeur de basculer rapidement entre le mode débogage et le mode release , ou même entre le chargeur de démarrage et l'application principale , ce qui est un cas d'utilisation courant dans les applications embarquées.

Ce didacticiel ne se concentrera pas sur les détails du fichier, voici plutôt le fichier modèle fourni

Le fichier décrit :

• Chemin d'accès au répertoire de build pour chaque configuration de build

• Type de build par défaut pour chaque configuration ( Debug , Release , ...)

• Chemin d'accès au descripteur de chaîne d'outils .cmake

4 préréglages sont configurés dans le modèle pour chacune des configurations CMake par défaut

 {"version": 3,"configurePresets": [
        {"name": "default","hidden": true,"generator": "Ninja","binaryDir": "${sourceDir}/build/${presetName}","toolchainFile": "${sourceDir} /cmake/gcc-arm-none-eabi.cmake","cacheVariables": {"CMAKE_EXPORT_COMPILE_COMMANDS": "ON"}
        },
        {"name": "Debug","inherits": "default","cacheVariables": {"CMAKE_BUILD_TYPE": "Debug"}
        },
        {"name": "RelWithDebInfo","inherits": "default","cacheVariables": {"CMAKE_BUILD_TYPE": "RelWithDebInfo"}
        },
        {"name": "Release","inherits": "default","cacheVariables": {"CMAKE_BUILD_TYPE": "Release"}
        },
        {"name": "MinSizeRel","inherits": "default","cacheVariables": {"CMAKE_BUILD_TYPE": "MinSizeRel"}
        }
    ]
}

Le fichier toujours à jour est disponible dans templates/CMakePresets.json

Exécuter les commandes CMake

Nous avons configuré CMake avec les informations du projet et sommes maintenant prêts à exécuter les commandes CMake.

VSCode est livré avec le plugin CMake Tools - une aide précieuse pour les commandes CMake. Une fois installé, plusieurs options sont disponibles en bas de la fenêtre active VSCode

Comme vous pouvez le constater, aucun préréglage de configuration n'est sélectionné.

Si vous ne voyez pas ces informations, appuyez sur CTRl + ALT + P et exécutez la commande CMake: Quick Start .

L'étape suivante consiste à sélectionner le préréglage actuel. Cliquez sur No Configure Preset Selected pour ouvrir une fenêtre en haut et sélectionnez votre préréglage . J'ai sélectionné le débogage pour le bien de ce tutoriel.

Une fois sélectionné, le texte deviendra l' étiquette prédéfinie sélectionnée.

Maintenant que ce préréglage est actif, chaque fois que l'utilisateur modifiera le fichier CMakeLists.txt , grâce à l'extension CMake-Tools , VSCode invoquera automatiquement la commande de génération de build pour appliquer de nouvelles modifications.

Construire un projet

Notre projet est prêt à être construit et relié. À moins que l’étape de génération de build CMake n’échoue, nous devrions avoir le répertoire de build prêt à invoquer le système de build ninja .

L'étape suivante consiste à appuyer sur le bouton Construire - comme indiqué par le rectangle vert. CMake exécutera les commandes :

• Exécuter le générateur de build pour le préréglage sélectionné

• Construisez réellement du code avec Ninja

S'il se construit bien, la dernière étape de la sortie est l'impression de l'utilisation de la mémoire avec différentes sections.

En conséquence, nous avons obtenu une sortie dans le répertoire build/<presetname>/ :

• fichier project-name.elf avec des informations exécutables complètes

• project-name.hex fichier HEX

• project-name.bin fichier BIN

• fichier de carte project-name.map

Dans la configuration par défaut, les fichiers .hex et .bin ne sont pas générés et l'utilisation de la mémoire n'est pas affichée. Notre fichier CMakeLists.txt préparé inclut les options POST_BUILD , pour exécuter des commandes supplémentaires après une construction réussie. Le code est déjà dans votre fichier CMakeLists.txt , donc pas besoin de faire quoi que ce soit, observez simplement.

Il exécute la commande pour :

• Imprimer la taille utilisée de chaque région + la consommation finale de mémoire exécutable

• Générer un fichier .hex à partir de l'exécutable

• Générer un fichier .bin à partir de l'exécutable

 # Exécuter la post-construction pour imprimer sizeadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_SIZE} $<TARGET_FILE:${EXECUTABLE}>
)# Convertir la sortie en hexadécimal et en binaireadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O ihex $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.hex
)# Convertir en fichier bin -> ajouter une vérification conditionnelle ?add_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O binaire $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.bin
)

Pour désactiver la génération de fichiers .bin , supprimez simplement la ligne POST_BUILD pour .bin et régénérez les commandes du système de build CMake. La génération de fichiers .bin peut avoir un effet négatif lorsque la mémoire est partagée entre les mémoires flash internes et externes. Il peut générer des fichiers très volumineux ( >= 2GB ) avec de nombreux zéros non utilisés.

Il existe une liste de commandes utiles à garder à l’esprit lors du développement d’un projet :

• Construire des changements

• Projet propre

• Projet de reconstruction, avec le nettoyage d'abord

• Projet Flash

Il est facile d'oublier la syntaxe complète, créons plutôt le fichier .vscode/tasks.json avec la liste des commandes, pour une exécution rapide :

 { "version": "2.0.0", "tâches": [
        {"type": "cppbuild","label": "Build project","command": "cmake","args": ["--build", "${command:cmake.buildDirectory}", "- j", "8"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": ["$gcc"],"group": {"kind": "build"," isDefault": vrai}
        },
        {"type": "shell","label": "Reconstruire le projet","command": "cmake","args": ["--build", "${command:cmake.buildDirectory}", "--clean-first", "-v", "-j", "8"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": ["$gcc"] ,
        },
        {"type": "shell", "label": "Projet propre", "command": "cmake", "args": ["--build", "${command:cmake.buildDirectory}", "- -target", "clean"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": []
        },
        {"type": "shell","label": "CubeProg : projet Flash (SWD)","command": "STM32_Programmer_CLI","args": ["--connect","port=swd","- -download", "${command:cmake.launchTargetPath}","-hardRst"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": []
        },
        {"type": "shell","label": "CubeProg : projet Flash avec numéro de série défini (SWD) - vous devez d'abord définir le numéro de série",