stm32 cube cmake vscode herunterladen - stm32 cube cmake vscode Quellcode herunterladen

stm32 cube cmake vscode

Anderer Quellcode

Herunterladen

STM32-Entwicklungsumgebung mit Visual Studio Code und CMake

In diesem Tutorial werden Schritte zum effektiven Entwickeln und Debuggen von STM32-Anwendungen in Visual Studio Code mithilfe des CMake- Build-Generators, des Ninja- Build-Tools und des GCC- Compilers erläutert.

Dinge, die Sie lernen werden

So installieren und richten Sie alle Tools ein
So erstellen Sie ein neues STM32-Projekt mit den Tools STM32CubeMX oder STM32CubeIDE
So installieren und richten Sie empfohlene Erweiterungen für Visual Studio Code ein, um die Entwicklung zu vereinfachen
So richten Sie CMake-Listen und CMake-Voreinstellungen ein
So generieren Sie ein Build-System für den Compiler
So kompilieren Sie das Projekt mit GCC
So flashen und debuggen Sie eine Anwendung auf dem STM32-Ziel

Dieses Tutorial verwendet das Windows -Betriebssystem. Ein ähnliches Verfahren gilt für Linux- und MAC-Betriebssysteme.

Werkzeuginstallation

Update vom August 2024

Das Tutorial zur Installation der Tools hilft Ihnen, die notwendigen Tools zu verstehen, die für die Arbeit mit STM32 erforderlich sind, und eignet sich im Allgemeinen gut für Anfänger, um sich mit der Geschwindigkeit vertraut zu machen und die erforderlichen Anforderungen richtig zu verstehen.

Seit einiger Zeit verfügt ST über ein neues STM32CubeCLT-Softwaretool, das die für vscode erforderlichen Build-Tools, das Ninja -Build-System und den CMake- Build-Generator enthält. STM32CubeCLT (Befehlszeilentools) ist eine einfache und unkomplizierte Möglichkeit, sich schnell mit der vscode-Entwicklung vertraut zu machen. Außerdem werden Ihre Build-Umgebungsvariablen ( Pfad im Fall von Windows) automatisch eingerichtet, sodass Sie Ninja , cmake oder andere Befehle direkt über das Befehlszeilentool aufrufen können.

Durch die Installation von STM32CubeCLT erhalten Sie weder das grafische STM32CubeIDE- Tool noch die Möglichkeit eines MCU-Konfigurationstools, sondern lediglich Befehlszeilentools zum Aufrufen von Build und Debug, normalerweise aus vscode heraus. Sie müssen vscode und die erforderlichen Erweiterungen weiterhin separat installieren.

STM32CubeIDE

Der erste Schritt besteht darin, STM32CubeIDE zu installieren, das zum einfachen Starten eines neuen STM32- Projekts verwendet wird und über ein integriertes STM32CubeMX- Tool verfügt, das uns eine grafische Konfiguration ermöglicht.

STM32CubeIDE bietet auch die notwendigen Tools, die später für die VSCode- Entwicklung benötigt werden

ARM kein eabi GCC-Compiler
ST-LINK GDBServer zum Debuggen
STM32CubeProgrammer-Tool zum Herunterladen von Code und entsprechenden ST-Link-Treibern
Ordner mit STM32 SVD-Dateien
Treiber für ST-Link

Einrichtung des Umgebungspfads

Den Umgebungseinstellungen aus der STM32CubeIDE-Installation sollten 3 Pfade hinzugefügt werden, ein Pfad für jedes der oben genannten Tools. Im Fall meines Computers, der STM32CubeIDE 1.8 verwendet (aktualisiert durch Eclipse, daher zeigt mein tatsächlicher Installationspfad immer noch Version 1.0.2 an), sind die Pfade wie folgt definiert:

GCC-Compiler: c:STSTM32CubeIDE_1.0.2STM32CubeIDEpluginscom.st.stm32cube.ide.mcu.externaltools.gnu-tools-for-stm32.9-2020-q2-update.win32_2.0.0.202105311346toolsbin
ST-Link GDB-Server: c:STSTM32CubeIDE_1.0.2STM32CubeIDEpluginscom.st.stm32cube.ide.mcu.externaltools.stlink-gdb-server.win32_2.0.100.202109301221toolsbin
STM32Cube-Programmierer-CLI: c:STSTM32CubeIDE_1.0.2STM32CubeIDEpluginscom.st.stm32cube.ide.mcu.externaltools.cubeprogrammer.win32_2.0.100.202110141430toolsbin

Ihre Pfade können sich bei den Versionsnummern unterscheiden

Überprüfen Sie die korrekte Pfadeinrichtung und führen Sie Folgendes aus:

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

Das sollte eine Ausgabe ähnlich der Abbildung unten erzeugen

CMake

Dieser Schritt ist nicht erforderlich, wenn Sie die Build-Tools mit STM32CubeCLT installiert haben

Laden Sie CMake herunter und installieren Sie es.

Der Installationsassistent fordert Sie auf, CMake zu Umgebungspfaden hinzuzufügen. Wählen Sie die Option aus oder fügen Sie bin Ordner des CMake-Installationsordners zum Umgebungspfad hinzu.

Ninja

Dieser Schritt ist nicht erforderlich, wenn Sie die Build-Tools mit STM32CubeCLT installiert haben

Laden Sie das Ninja-Build-System von der Github-Release-Seite herunter. Es wird als portable ausführbare Datei geliefert, ohne dass etwas installiert werden muss. Es muss jedoch wie alle vorherigen Tools auf Umgebungsebene sichtbar sein.

Überprüfen Sie die CMake- und Ninja- Installation und führen Sie Folgendes aus:

cmake --version
ninja --version

Die Ausgabe sollte in etwa so aussehen wie

Visual Studio-Code

Laden Sie VSCode herunter und installieren Sie es. Nach der Installation und dem Öffnen sieht das Fenster ähnlich wie das folgende aus.

Visual Studio Code-Erweiterungen

Visual Studio Code ist ein leichter Texteditor mit der Möglichkeit, ihn mithilfe von Erweiterungen zu vergrößern.

Liste nützlicher Erweiterungen für die STM32-Entwicklung mit CMake:

ms-vscode.cpptools : Syntaxhervorhebung und andere Kernfunktionen für die C/C++-Entwicklung
ms-vscode.cmake-tools : CMake-Kerntools, Build-System-Generator-Tool
twxs.cmake : CMake-Farbhervorhebung
marus25.cortex-debug : Cortex-M-Debugging-Erweiterung, obligatorisch für STM32-Debug von VSCode
dan-c-underwood.arm : Hervorhebung der ARM-Assembly-Syntax
zixuanwang.linkerscript : Syntaxhervorhebung für GCC-Linker-Skripte

Sie können sie installieren, indem Sie die folgenden Befehle in das interne Terminalfenster von VSCode kopieren.

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

Gehen Sie zu Terminal -> Neues Terminal, um ein neues Terminalfenster zu öffnen

Eine alternative Möglichkeit besteht darin, die Benutzeroberfläche für die Erweiterungssuche zu verwenden und von dort aus manuell zu installieren.

Installierte Werkzeuge – Prüfpunkt

An diesem Punkt sind alle Werkzeuge richtig installiert – Sie sind auf dem richtigen Weg zum Erfolg.

Neue Projekterstellung

Grundvoraussetzung für die Weiterentwicklung ist ein funktionierendes Projekt, das in CMake konvertiert und in VSCode entwickelt wird. Zu diesem Zweck werde ich Sie durch die einfache Erstellung neuer Projekte mit den Softwaretools STM32CubeMX oder STM32CubeIDE führen.

Sie können diesen Teil überspringen, wenn Sie bereits an Ihrem Projekt arbeiten.

Für diese Demo habe ich das STM32CubeIDE- Tool und das STM32H735G-DK-Board verwendet.

Öffnen Sie STM32CubeIDE und starten Sie ein neues Projekt

Wählen Sie STM32 MCU – ich habe STM32H735IG ausgewählt, das auf der STM32H735G-DK -Karte verwendet wird

Wählen Sie Projektnamen und -pfad aus, erstellen Sie dann ein Projekt und warten Sie, bis die Pinout-Ansicht geöffnet wird

Unsere Aufgabe ist es, ein einfaches Projekt zu haben, das LEDs umschaltet. LEDs sind jeweils an PC2 und PC3 angeschlossen, aktiv LOW. Pins können im Ausgangs-Push-Pull- oder Open-Drain-Modus konfiguriert werden

Stellen Sie die Pins als Ausgänge mit optionalen Beschriftungen als LED1 bzw. LED2 ein

Wenn Sie STM32CubeMX verwenden, gehen Sie zum Projektmanager , legen Sie den Projektnamen fest und stellen Sie sicher, dass STM32CubeIDE als Toolchain ausgewählt ist.

Gehen Sie zu den erweiterten Einstellungen und wählen Sie LL als Treiber für den generierten Code aus

Der Einfachheit halber verwenden wir in diesem Tutorial LL-Treiber

Generieren Sie das Projekt neu, indem Sie die rote Taste drücken oder das Projekt mit der Tastenkombination CTRL + S speichern

Das Projekt wird jetzt (neu) generiert. Gelb hervorgehobene Dateien sind Quellen zum Erstellen. Blau ist ein Linker-Skript.

Das war’s für den ersten Durchlauf, wir sind bereit zum Kompilieren. Drücken Sie CTRL + B oder klicken Sie auf das Hammersymbol , um zu starten. STM32CubeIDE kompiliert das Projekt. Sie sollten ein ähnliches Bild wie auf dem Bild unten sehen. Es ist nun bereit, den Flash der MCU zu flashen und mit dem Debuggen zu beginnen.

Dies ist das Ende des ersten Teils, in dem wir unser Projekt erfolgreich erstellt haben. An diesem Punkt gehen wir davon aus, dass das Projekt für die Übertragung auf ein CMake-basiertes Build-System bereit ist.

Sie können Ihre Entwicklung mit STM32CubeIDE in Zukunft fortsetzen, neue Quellen hinzufügen, Code ändern, kompilieren, die Binärdatei flashen und direkt den Mikrocontroller debuggen. Dies ist das bevorzugte STM32-Entwicklungsstudio, entwickelt und verwaltet von STMicroelectronics.

CMake-Konfiguration

Es wird erwartet, dass ein Projekt zur Entwicklung in VSCode erstellt wurde. Wir werden den GCC-Compiler vorantreiben, aber es könnten auch andere verwendet werden.

Mit der Veröffentlichung von Visual Studio Code nutzen viele Entwickler das Tool für viele Programmiersprachen und können glücklicherweise auch STM32-Anwendungen mit einem einzigen Tool entwickeln. Wenn Sie zu den Entwicklern gehören, die VSCode mögen, besteht die eleganteste Möglichkeit, voranzukommen, darin, ein STM32CubeIDE-basiertes Projekt an CMake zu übertragen, Code in VSCode zu entwickeln und mit dem Ninja-Build-System mithilfe des GCC-Compilers zu kompilieren. Es ist schnell und leicht.

Die Entwicklung in VSCode richtet sich an fortgeschrittene oder erfahrene Benutzer. Ich empfehle allen STM32-Anfängern, bei der STM32CubeIDE- Entwicklungstoolchain zu bleiben. Es wird sehr einfach sein, später weiterzumachen und zum VSCode-Thema zu kommen.

Bereiten Sie die Datei CMakeLists.txt vor

Jede CMake-basierte Anwendung erfordert die Datei CMakeLists.txt im Stammverzeichnis , die das Projekt beschreibt und Eingabeinformationen für die Build-System-Generierung bereitstellt.

Die Stammdatei CMakeLists.txt wird manchmal als CMake-Datei der obersten Ebene bezeichnet

Wesentliche Dinge, die in der Datei CMakeLists.txt beschrieben sind:

Toolchain-Informationen, z. B. GCC-Konfiguration mit Build-Flags
Projektname
Quelldateien zum Erstellen mit Compiler-, C-, C++- oder Assembly-Dateien
Liste der Include-Pfade für den Compiler zum Suchen von Funktionen, Definitionen usw. ( -I )
Linker-Skriptpfad
Kompilierungsdefinitionen, manchmal auch Präprozessordefinitionen genannt ( -D )
Cortex-Mxx- und Gleitkomma-Einstellungen für die Befehlssatzgenerierung

Öffnen Sie VSCode im Projektstammordner

Visual Studio Code wurde installiert und wird als weiterer Dateieditor verwendet.

Suchen Sie Ihren generierten Projektpfad und öffnen Sie den Ordner mit VSCode:

Option 1: Gehen Sie mit dem Explorer zum Ordner, klicken Sie dann mit der rechten Maustaste und wählen Sie Open in Code .
Option 2: Alternativ können Sie VScode als neue leere Lösung öffnen und den Ordner manuell hinzufügen. Verwenden Sie File -> Open Folder... um den Ordner zu öffnen
Option 3: Gehen Sie mit cmd oder dem Powershell-Tool zum Ordner und führen Sie code .

Das Endergebnis sollte dem folgenden ähneln

Informationen zur Toolchain

CMake muss sich der Toolchain bewusst sein, mit der wir das Projekt endgültig kompilieren möchten. Da dieselbe Toolchain normalerweise in verschiedenen Projekten wiederverwendet wird, wird empfohlen, diesen Teil zur einfacheren Wiederverwendung in einer separaten Datei zu erstellen. Hierbei handelt es sich um allgemeine Compilereinstellungen, die nicht direkt mit den Projekten selbst verknüpft sind.

Eine einfache .cmake Datei kann verwendet und später in Ihren verschiedenen Projekten wiederverwendet werden. Ich verwende für dieses Tutorial den Namen cmake/gcc-arm-none-eabi.cmake und unten ist ein Beispiel:

 set(CMAKE_SYSTEM_NAME Generic)set(CMAKE_SYSTEM_PROCESSOR arm)# Einige Standard-GCC-Einstellungen# arm-none-eabi- muss Teil des Pfads sein ambientset(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")# Compilereinstellungen definierenset(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}gcc ${FLAGS})set(CMAKE_ASM_COMPILER ${CMAKE_C_COMPILER})set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}g++ $ {FLAGGEN} ${CPP_FLAGS})set(CMAKE_OBJCOPY ${TOOLCHAIN_PREFIX}objcopy)set(CMAKE_SIZE ${TOOLCHAIN_PREFIX}size)set(CMAKE_EXECUTABLE_SUFFIX_ASM ".elf")set(CMAKE_EXECUTABLE_SUFFIX_C ".elf")set(CMAKE_EXECUTABLE_SUFFIX_CXX ".elf")set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)

Erstellen Sie eine Datei im Ordner cmake/ des Stammprojektverzeichnisses.

Wenn das CMake-Highlighter-Plugin installiert ist, hebt VSCode CMake-Befehle gut für Sie hervor

Die Einrichtung der Toolchain ist abgeschlossen. Sie können die Datei jederzeit schließen und mit dem nächsten Schritt fortfahren.

Erstellen Sie die Hauptdatei CMakeLists.txt

Wir müssen die Hauptdatei CMakeLists.txt erstellen, auch Stammdatei von CMake genannt.

Stellen Sie sicher, dass Sie es wirklich CMakeLists.txt mit korrekten Groß- und Kleinbuchstaben benennen.

Ich habe für Sie eine einfache Vorlagendatei vorbereitet, die Sie in Zukunft für alle Ihre Projekte wiederverwenden können. Sie müssen lediglich Dinge wie Projektnamen, Quelldateien, Include-Pfade usw. ändern.

 cmake_minimum_required(VERSION 3.22)# Compiler-Einstellungen einrichtenset(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("Build-Typ: " ${CMAKE_BUILD_TYPE})## Kernprojekteinstellungen#project(your-project-name)enable_sprache(C CXX ASM)## Kern-MCU-Flags, CPU, Befehlssatz und FPU-Setup# Muss für Ihre MCU richtig eingestellt werden#set(CPU_PARAMETERS
    -mthumb# Dies erfordert Aufmerksamkeit, damit es für den verwendeten MCU-mcpu=cortex-m7 richtig eingestellt wird
    -mfpu=fpv5-d16
    -mfloat-abi=hart
)# Set linker scriptset(linker_script_SRC ${PROJ_PATH}/path-to-linker-script.ld)set(EXECUTABLE ${CMAKE_PROJECT_NAME})## Liste der zu kompilierenden Quelldateien#set(sources_SRCS# Fügen Sie hier Ihre Quelldateien ein, eine in jeder Zeile, relativ zum Speicherort der CMakeLists.txt-Datei)## Verzeichnisse einschließen#set(include_path_DIRS# Fügen Sie hier Ihr Include ein dirs, eines in jeder Zeile, relativ zum Speicherort der CMakeLists.txt-Datei)## Symboldefinition#set(symbols_SYMB# Geben Sie hier Ihre Symbole (Präprozessordefinitionen) ein, eines in jeder Zeile# Kapseln Sie sie aus Sicherheitsgründen in doppelte Anführungszeichen)# Ausführbare Dateienadd_executable (${EXECUTABLE} ${sources_SRCS})# Include pathstarget_include_directories(${EXECUTABLE} PRIVATE ${include_path_DIRS})# Projekt symbolstarget_compile_definitions(${EXECUTABLE} PRIVATE ${symbols_SYMB})# Compiler optionstarget_compile_options(${EXECUTABLE} PRIVATE${CPU_PARAMETERS}-Wall
    -Wextra
    -Wpedantisch
    -Wno-unused-parameter# Vollständige Debug-Konfiguration-Og -g3 -ggdb
)# Linker optionstarget_link_options(${EXECUTABLE} PRIVATE-T${linker_script_SRC}${CPU_PARAMETERS}-Wl,-Map=${CMAKE_PROJECT_NAME}.map
    --specs=nosys.specs
    -u _printf_float # STDIO Float-Formatierung support-Wl,--start-group
    -lc
    -lm
    -lstdc++
    -lsupc++
    -Wl,--end-group
    -Wl,--print-memory-usage
)# Führen Sie den Post-Build aus, um sizeadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_SIZE} $<TARGET_FILE:${EXECUTABLE}> zu drucken
)# Konvertieren Sie die Ausgabe in Hex und Binaryadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O ihex $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.hex
)# In Bin-Datei konvertieren -> Bedingungsprüfung hinzufügen?add_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O Binary $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.bin
)

Die Quelldateien sind die gleichen wie im STM32CubeIDE -Projekt. Sie können das vorherige Bild mit gelb hervorgehobenen Quellen überprüfen.

Symbole und Include-Pfade finden Sie in STM32CubeIDE unter Projekteinstellungen. 2 Bilder unten zeigen, wie es im Fall eines Demoprojekts ist.

Das Cortex-Mxx-Setup erfordert besondere Aufmerksamkeit, insbesondere beim Gleitkomma-Setup. Für STM32H735xx sollten die Einstellungen wie folgt festgelegt werden.

 set(CPU_PARAMETERS
    -mDaumen
    -mcpu=cortex-m7 # Setzt Cortex-M CPU-mfpu=fpv5-d16 # Setzt Floating point type-mfloat-abi=hard # Hardware-ABI-Modus)

Die allgemeine Regel für die Einstellungen ist die folgende Tabelle

STM32-Familie	-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`
STM32WL CM4	`cortex-m4`	`Not used`	`soft`
STM32WL CM0	`cortex-m0plus`	`Not used`	`soft`

Diese Tabelle unterliegt potenziellen Fehlern und wurde nicht für alle Zeilen mit dem GCC-Compiler getestet. Gehen Sie für STM32F7 zur offiziellen Website von STM32F7xx und prüfen Sie, ob Ihr Gerät über eine FPU mit einfacher oder doppelter Genauigkeit verfügt, und nehmen Sie dann die entsprechenden Einstellungen vor. Die Produktliste ist nicht vollständig.

Endgültige CMakeLists.txt Datei, nachdem Quelldateien, Include-Pfade, MCU-Kerneinstellungen und Definitionen festgelegt wurden:

 cmake_minimum_required(VERSION 3.22)# Compiler-Einstellungen einrichtenset(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("Build-Typ: " ${CMAKE_BUILD_TYPE})## Kernprojekteinstellungen#project(STM32H735G-DK-LED) # Modifiedenable_sprache(C CXX ASM)## Kern-MCU-Flags, CPU , Befehlssatz und FPU-Setup# Muss für Sie richtig eingestellt werden MCU#set(CPU_PARAMETERS
    -mthumb# Dies muss beachtet werden, damit es für die verwendete MCU richtig eingestellt wird.-mcpu=cortex-m7 # Modified-mfpu=fpv5-d16 # Modified-mfloat-abi=hard # Geändert)# Set linker scriptset(linker_script_SRC ${PROJ_PATH}/STM32H735IGKX_FLASH. ld) # Modifiedset(EXECUTABLE ${CMAKE_PROJECT_NAME})## Liste von Zu kompilierende Quelldateien#set(sources_SRCS # Geändert${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
)## Verzeichnisse einschließen#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}/ Treiber/CMSIS/Include
)## Symboldefinition#set(symbols_SYMB # Modified"DEBUG""STM32H735xx""USE_FULL_LL_DRIVER""HSE_VALUE=25000000")# Ausführbare Dateienadd_executable(${EXECUTABLE} ${sources_SRCS})# Include pathstarget_include_directories(${EXECUTABLE} PRIVATE ${include_path_DIRS})# Projekt symbolstarget_compile_definitions(${EXECUTABLE} PRIVATE ${symbols_SYMB})# Compiler optionstarget_compile_options(${EXECUTABLE} PRIVATE${CPU_PARAMETERS}-Wall
    -Wextra
    -Wpedantisch
    -Wno-unused-parameter# Vollständige Debug-Konfiguration-Og -g3 -ggdb
)# Linker optionstarget_link_options(${EXECUTABLE} PRIVATE-T${linker_script_SRC}${CPU_PARAMETERS}-Wl,-Map=${CMAKE_PROJECT_NAME}.map
    --specs=nosys.specs
    -u _printf_float # STDIO Float-Formatierung support-Wl,--start-group
    -lc
    -lm
    -lstdc++
    -lsupc++
    -Wl,--end-group
    -Wl,--print-memory-usage
)# Führen Sie den Post-Build aus, um sizeadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_SIZE} $<TARGET_FILE:${EXECUTABLE}> zu drucken
)# Konvertieren Sie die Ausgabe in Hex und Binaryadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O ihex $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.hex
)# In Bin-Datei konvertieren -> Bedingungsprüfung hinzufügen?add_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O Binary $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.bin
)

In VSCode sieht es, gut hervorgehoben, so aus

Erstellen Sie die voreingestellte CMakePresets.json-Datei

CMakePresets.json ist eine spezielle Datei, die seit CMake 3.18 verfügbar ist und Definitionen für die Benutzerkonfiguration bereitstellt, ähnlich der in Eclipse bekannten Debug- und Release -Konfiguration. Mit dieser Datei können Entwickler schnell zwischen Debug- und Release -Modus oder sogar zwischen Bootloader und Hauptanwendung wechseln, was in eingebetteten Anwendungen ein häufiger Anwendungsfall ist.

In diesem Tutorial geht es nicht um Details zur Datei, sondern um die bereitgestellte Vorlagendatei

Datei beschreibt:

Pfad zum Build-Verzeichnis für jede Build-Konfiguration
Standard-Build-Typ für jede Konfiguration ( Debug , Release , ...)
Pfad zum .cmake- Toolchain-Deskriptor

Für jede der standardmäßigen CMake -Konfigurationen sind in der Vorlage 4 Voreinstellungen konfiguriert

 {"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"}
        }
    ]
}

Die stets aktuelle Datei ist in templates/CMakePresets.json verfügbar

Führen Sie CMake-Befehle aus

Wir haben CMake mit Projektinformationen konfiguriert und sind nun bereit, die CMake-Befehle auszuführen.

VSCode wird mit dem CMake Tools- Plugin geliefert – einem großartigen Helfer für CMake-Befehle. Nach der Installation stehen unten im aktiven VSCode-Fenster mehrere Optionen zur Verfügung

Wie Sie sehen, ist keine Konfigurationsvoreinstellung ausgewählt.

Wenn Sie solche Informationen nicht sehen, drücken Sie CTRl + ALT + P und führen Sie den Befehl CMake: Quick Start aus.

Der nächste Schritt besteht darin, die aktuelle Voreinstellung auszuwählen. Klicken Sie auf „Keine Voreinstellung konfigurieren“ ausgewählt, um oben ein Fenster zu öffnen und Ihre Voreinstellung auszuwählen. Für dieses Tutorial habe ich Debug ausgewählt.

Bei Auswahl ändert sich der Text in die ausgewählte voreingestellte Beschriftung .

Da die Voreinstellung jetzt aktiv ist, ruft VSCode dank der CMake-Tools- Erweiterung jedes Mal, wenn der Benutzer die Datei CMakeLists.txt ändert, automatisch den Build-Generierungsbefehl auf, um neue Änderungen anzuwenden.

Projekt erstellen

Unser Projekt ist bereit zum Erstellen und Verknüpfen. Sofern der CMake-Build-Generierungsschritt nicht fehlschlägt, sollte das Build-Verzeichnis bereit sein, um das Ninja-Build-System aufzurufen.

Der nächste Schritt besteht darin, auf die Schaltfläche „Erstellen“ zu klicken – wie durch das grüne Rechteck angezeigt. CMake führt folgende Befehle aus:

Führen Sie den Build-Generator für die ausgewählte Voreinstellung aus
Eigentlich Code mit Ninja erstellen

Wenn es gut aufgebaut ist, besteht der letzte Schritt der Ausgabe darin, die Speichernutzung mit verschiedenen Abschnitten auszudrucken.

Als Ergebnis haben wir einige Ausgaben im Verzeichnis build/<presetname>/ erhalten:

project-name.elf Datei mit vollständigen ausführbaren Informationen
project-name.hex Datei
project-name.bin Datei
project-name.map Map-Datei

In der Standardkonfiguration werden weder .hex und .bin Dateien generiert noch die Speichernutzung angezeigt. Unsere vorbereitete CMakeLists.txt Datei enthält POST_BUILD Optionen, um nach erfolgreichem Build zusätzliche Befehle auszuführen. Der Code befindet sich bereits in Ihrer CMakeLists.txt Datei, Sie müssen also nichts tun, sondern nur beobachten.

Es führt den folgenden Befehl aus:

Verwendete Druckgröße jeder Region + endgültiger Speicherverbrauch der ausführbaren Datei
Generieren Sie .hex Datei aus der ausführbaren Datei
Generieren Sie .bin Datei aus einer ausführbaren Datei

 # Nach dem Build ausführen, um sizeadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_SIZE} $<TARGET_FILE:${EXECUTABLE}> zu drucken
)# Konvertieren Sie die Ausgabe in Hex und Binaryadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O ihex $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.hex
)# In Bin-Datei konvertieren -> Bedingungsprüfung hinzufügen?add_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O Binary $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.bin
)

Um .bin Dateigenerierung zu deaktivieren, löschen Sie einfach POST_BUILD Zeile für .bin und generieren Sie die CMake-Build-Systembefehle neu. Das Generieren .bin -Dateien kann sich negativ auswirken, wenn der Speicher zwischen internen und externen Flash-Speichern aufgeteilt wird. Es können sehr große Dateien ( >= 2GB ) mit vielen nicht verwendeten Nullen generiert werden.

Es gibt eine Liste nützlicher Befehle, die Sie bei der Projektentwicklung beachten sollten:

Build-Änderungen
Sauberes Projekt
Projekt neu erstellen, zuerst reinigen
Flash-Projekt

Es ist leicht, die vollständige Syntax zu vergessen. Erstellen wir lieber die Datei .vscode/tasks.json mit der Befehlsliste, um sie schnell auszuführen:

 { "version": "2.0.0", "tasks": [
        {"type": "cppbuild", "label": "Build project", "command": "cmake", "args": ["--build", "${command:cmake.buildDirectory}", "- j", "8"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": ["$gcc"],"group": {"kind": "build"," isDefault": true}
        },
        {"type": "shell", "label": "Projekt neu erstellen", "command": "cmake", "args": ["--build", "${command:cmake.buildDirectory}", „--clean-first“, „-v“, „-j“, „8“], „options“: {“cwd“: „${workspaceFolder}“}, „problemMatcher“: [“$gcc“] ,
        },
        {"type": "shell", "label": "Clean project", "command": "cmake", "args": ["--build", "${command:cmake.buildDirectory}", "- -target", "clean"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": []
        },
        {"type": "shell", "label": "CubeProg: Flash project (SWD)", "command": "STM32_Programmer_CLI", "args": ["--connect", "port=swd", "- -download", "${command:cmake.launchTargetPath}","-hardRst"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": []
        },
        {"type": "shell","label": "CubeProg: Flash-Projekt mit definierter Seriennummer (SWD) – Sie müssen zuerst die Seriennummer festlegen",

Expandieren

Zusätzliche Informationen