CMake dla STM32F407: budowanie z GCC na Windows

Konfiguracja CMake do budowania firmware'ów STM32F407 w Windows z GCC

CMake zapewnia wieloplatformowość budowania firmware'ów dla mikrokontrolerów STM32. Tymi samymi skryptami zbudujesz projekty zarówno w Windows, jak i w Linux. To rozwiązuje problem ścieżek i narzędzi specyficznych dla systemu operacyjnego w GNU Make. Dla rozwoju na jednej platformie przejście nie jest konieczne, ale przy potrzebie wsparcia wielu systemów CMake staje się standardem wśród meta systemów budowania.

System generuje natywne pliki budowania: GNU Make dla Linux/Windows, Ninja lub projekty IDE. Skupiamy się na ARM GCC dla STM32F407VE z HAL od ST i CMSIS.

Zalety skryptowej budowy

Budowanie z konsoli skaluje się na setki firmware'ów. GUI-IDE ograniczają automatyzację przy wzroście projektów. Skrypty pozwalają:

• Automatyzować potoki CI/CD
• Zbudować wszystkie warianty w nocy
• Zintegrować w repozytoriach jedną komendą

Dla 150+ firmware'ów wystarczy plik wsadowy: uruchomienie — i po kilku minutach gotowe pliki .hex.

Postawienie zadania: Projekt w C dla STM32F407VE. Kompilator krzyżowy ARM GCC. CMake generuje GNU Make. HAL STM32 + CMSIS. Cel — Windows 10.

Kompilatorowi przekazujemy ścisłe flagi:

-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

Linkerowi:

-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 nie generuje CMake bezpośrednio — tylko GNU Make. Rozwiązanie: ręczna migracja.

Teoria: od Make do CMake

Zmienne środowiskowe przechowują ścieżki, flagi kompilatora, ustawienia. Widoczne dla wszystkich narzędzi.

System budowania automatyzuje kompilację, linkowanie, zależności. Przykłady: GNU Make, Ninja, IAR.

Generator systemu budowania (CMake, Meson) tworzy pliki dla natywnych systemów budowania.

Schemat CMake + GNU Make:

• CMake czyta CMakeLists.txt
• Generuje Makefile
• GNU Make buduje artefakty

Sprawdź CMake: where cmake w Windows.

Migracja Make → CMake

Mechaniczne zastąpienie składni. CMake jest bardziej rozwlekłe, ale potężniejsze.

| GNU Make | CMake | Wyjaśnienie |

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

| VAR += value | string(APPEND VAR " value") | Uzupełnianie zmiennej |

| CRC=Y | set(CRC Y) | Definicja |

| $(VAR) | ${VAR} | Wstawienie |

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

| SOURCES_C += src/main.c | target_sources(app PRIVATE src/main.c) | Pliki źródłowe |

| OPT += -Ipath | target_include_directories(app PUBLIC path) | Ścieżki |

Przykłady transformacji:

• 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 (główny):

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)

Konfiguracja komponentów

W config.cmake aktywuj moduły:

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)

W code_base.cmake dodawaj komponenty warunkowo:

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()

Co jest ważne

• CMake zapewnia wieloplatformowość bez przepisywania skryptów
• Migracja Make→CMake — szablonowe zastąpienie, automatyzowalne przez AI
• Ścisłe flagi -Werror wykrywają błędy na etapie kompilacji
• config.cmake zarządza zestawem modułów HAL
• Budowanie ze skryptów skaluje się na 100+ firmware'ów

— Editorial Team