CMake pour STM32F407 : compilation avec GCC sur Windows

Configuration de CMake pour la compilation de firmware STM32F407 sur Windows avec GCC

CMake permet la compilation multiplateforme de firmware pour les microcontrôleurs STM32. Avec un seul ensemble de scripts, vous pouvez compiler des projets sur Windows et Linux. Cela résout le problème des chemins et utilitaires spécifiques au système d'exploitation dans GNU Make. Pour un développement sur une seule plateforme, le changement n'est pas nécessaire, mais lors de la prise en charge de plusieurs OS, CMake devient la norme parmi les systèmes de méta-compilation.

Le système génère des fichiers de compilation natifs : GNU Make pour Linux/Windows, Ninja ou des projets d'IDE. L'accent est mis sur ARM GCC pour STM32F407VE avec la HAL de ST et CMSIS.

Avantages de la compilation par script

La compilation en ligne de commande s'adapte à des centaines de projets de firmware. Les IDE graphiques limitent l'automatisation à mesure que les projets grandissent. Les scripts permettent de :

• Automatiser les pipelines CI/CD
• Compiler toutes les variantes pendant la nuit
• Intégrer dans les dépôts avec une seule commande

Pour 150+ projets de firmware, un fichier batch suffit : exécutez-le, et en quelques minutes, les fichiers .hex sont prêts.

Définition de la tâche : Un projet C pour STM32F407VE. Compilateur croisé ARM GCC. CMake génère GNU Make. STM32 HAL + CMSIS. Cible : Windows 10.

Passez des drapeaux stricts au compilateur :

-MMD -MP -O0 -std=c11 -Wall -Werror -mcpu=cortex-m4 -march=armv7e-m -Werror=address -Werror=address-of-packed-member -Werror=array-bounds=1 -Werror=bool-compare -Werror=bool-operation -Werror=char-subscripts -Werror=clobbered -Werror=div-by-zero -Werror=duplicate-decl-specifier -Werror=empty-body -Werror=enum-compare -Werror=float-equal -Werror=ignored-qualifiers -Werror=implicit -Werror=implicit-int -Werror=incompatible-pointer-types -Werror=init-self -Werror=int-in-bool-context -Werror=int-to-pointer-cast -Werror=logical-not-parentheses -Werror=logical-op -Werror=maybe-uninitialized -Werror=memset-elt-size -Werror=misleading-indentation -Werror=missing-braces -Werror=multistatement-macros -Werror=old-style-declaration -Werror=overflow -Werror=pointer-arith -Werror=pointer-sign -Werror=return-local-addr -Werror=return-type -Werror=shadow -Werror=shift-count-overflow -Werror=sign-compare -Werror=sizeof-pointer-div -Werror=strict-aliasing -Werror=switch -Werror=tautological-compare -Werror=type-limits -Werror=uninitialized -Werror=unused-variable -g3 -Wextra -Wno-conversion -Wno-cpp -Wno-discarded-qualifiers -Wno-implicit -Wno-int-conversion -Wno-nonnull-compare -Wno-redundant-decls -Wno-restrict -Wno-sign-compare -Wno-stringop-truncation -Wno-switch-bool -Wno-unused-parameter -fallthrough -fdata-sections -ffreestanding -ffunction-sections -finline-small -fmax-errors=70 -fno-common -fno-move-loop-invariants -fno-printf-return-value -fomit-frame-pointer -fshort-enums -fsigned-char -fstack-usage -fzero-initialized-in-bss -mfloat-abi=hard -mfpu=fpv4-sp-d16 -mthumb

Au linker :

-specs=nosys.specs -Xlinker --gc-sections -Xlinker --nmagic -Wl,--gc-sections -Xlinker --print-memory-usage -t -Wl,--cref -Wl,--gc-sections --verbose -mcpu=cortex-m4 -march=armv7e-m -mthumb -mfloat-abi=hard -mfpu=fpv4-sp-d16 -lm

STM32CubeMX ne génère pas directement CMake—seulement GNU Make. La solution : migration manuelle.

Théorie : De Make à CMake

Variables d'environnement stockent les chemins, drapeaux du compilateur et paramètres. Visibles par tous les utilitaires.

Système de compilation automatise la compilation, le linking et les dépendances. Exemples : GNU Make, Ninja, IAR.

Générateur de système de compilation (CMake, Meson) crée des fichiers pour les systèmes de compilation natifs.

Schéma CMake + GNU Make :

• CMake lit CMakeLists.txt
• Génère Makefile
• GNU Make compile les artefacts

Vérifiez CMake : where cmake sous Windows.

Migration Make → CMake

Remplacement syntaxique mécanique. CMake est plus verbeux mais plus puissant.

| GNU Make | CMake | Explication |

|----------|--------|-----------|

| VAR += value | string(APPEND VAR " value") | Ajout à une variable |

| CRC=Y | set(CRC Y) | Définition |

| $(VAR) | ${VAR} | Insertion |

| ifeq($(IAR),Y) | if(IAR STREQUAL Y) | Condition |

| SOURCES_C += src/main.c | target_sources(app PRIVATE src/main.c) | Fichiers sources |

| OPT += -Ipath | target_include_directories(app PUBLIC path) | Chemins |

Exemples de transformation :

• LINKER_FLAGS += -u _printf_float → target_link_options(app PRIVATE -u _printf_float)
• include file.mk → include(${file}.cmake)
• SOURCES += file.c → string(APPEND SOURCES " ${file}.c")
• ifneq($(FLAG),Y) → if(NOT (FLAG STREQUAL Y))

CMakeLists.txt (racine) :

cmake_minimum_required(VERSION 3.16)
project(jz_f407vet6_mbr_gcc_cmake)
set(PROJECT_NAME jz_f407vet6_mbr_gcc_cmake)
enable_language(C ASM)

set(CURRENT_CMAKELISTS_DIR ${CMAKE_CURRENT_SOURCE_DIR})
set(PROJECT_LOC ${CMAKE_CURRENT_SOURCE_DIR})
include_directories(${PROJECT_LOC})

set(BUILD_DIR ${PROJECT_LOC}/build)
set(TARGET ${PROJECT_NAME})
set(EXECUTABLE ${TARGET})

get_filename_component(WORKSPACE_LOC "${PROJECT_LOC}/../.." ABSOLUTE)
include_directories(${WORKSPACE_LOC})

include(${PROJECT_LOC}/config.cmake)
include(${WORKSPACE_LOC}/cmake_scripts/code_base.cmake)
include(${WORKSPACE_LOC}/cmake_scripts/rules.cmake)

Configuration des composants

Dans config.cmake, activez les modules :

set(CONTROL Y)
set(DWT Y)
set(ARM_GCC Y)
set(CORTEX_M4 Y)
set(FLASH Y)
set(FPU Y)
set(GPIO Y)
set(INTERRUPT Y)
set(JZ_F407VET6 Y)
set(LED_MONO Y)
set(MBR Y)
set(MCAL_STM32 Y)
set(MICROCONTROLLER Y)
set(NVIC Y)
set(RCC Y)
set(SCHEDULER Y)
set(STM32F407VE Y)
set(STM32F4X_HAL_DRIVER Y)
set(SUPER_CYCLE Y)
set(SYSTEM Y)
set(SYSTICK Y)
set(SYS_INIT Y)
set(TIME Y)

Dans code_base.cmake, ajoutez les composants conditionnellement :

if(GPIO STREQUAL Y)
  target_sources(app PRIVATE gpio/src/gpio.c)
  target_include_directories(app PUBLIC gpio/inc)
  add_compile_definitions(GPIO_ENABLED)
endif()

Points clés

• CMake offre une compatibilité multiplateforme sans réécriture de scripts
• La migration Make→CMake est un remplacement basé sur des modèles, automatisable avec l'IA
• Les drapeaux stricts -Werror détectent les erreurs à la compilation
• config.cmake gère la sélection des modules HAL
• La compilation par script s'adapte à 100+ projets de firmware

— Editorial Team