CMake mit FreeRTOS verwenden

Sie können CMake verwenden, um Projekt-Build-Dateien aus dem Quellcode der FreeRTOS-Anwendung zu generieren und den Quellcode zu erstellen und auszuführen.

Sie können eine IDE auch verwenden, um Code auf FreeRTOS-qualifizierten Geräten zu bearbeiten, zu debuggen, zu kompilieren, zu flashen und auszuführen. Jeder boardspezifische Erste-Schritte-Leitfaden enthält Anweisungen zur Einrichtung der IDE für eine bestimmte Plattform. Wenn Sie es vorziehen, ohne IDE zu arbeiten, können Sie andere Werkzeuge zur Code-Editierung und -Debugging von Drittanbietern verwenden, um Ihren Code zu entwickeln und zu debuggen, und dann CMake verwenden, um die Anwendungen zu erstellen und auszuführen.

Die folgenden Boards unterstützen CMake:

In den folgenden Themen finden Sie weitere Informationen zur Verwendung von CMake mit FreeRTOS.

Voraussetzungen

Stellen Sie sicher, dass Ihr Host-Computer die folgenden Voraussetzungen erfüllt, bevor Sie fortfahren:

Entwicklung von FreeRTOS-Anwendungen mit Code-Editoren und Debugging-Tools von Drittanbietern

Sie können einen Code-Editor und eine Debugging-Erweiterung oder ein Debugging-Tool eines Drittanbieters verwenden, um Anwendungen für FreeRTOS zu entwickeln.

Wenn Sie beispielsweise Visual Studio Code als Code-Editor verwenden, können Sie die Cortex-Debug VS Code-Erweiterung als Debugger installieren. Wenn Sie die Entwicklung Ihrer Anwendung abgeschlossen haben, können Sie das Befehlszeilentool CMake aufrufen, um Ihr Projekt aus dem VS-Code heraus zu erstellen. Weitere Hinweise zur Verwendung von CMake zum Erstellen von FreeRTOS-Anwendungen finden Sie unter. FreeRTOS mit CMake erstellen

Für das Debugging können Sie einen VS-Code mit einer Debug-Konfiguration ähnlich der folgenden bereitstellen:

"configurations": [
    {
        "name": "Cortex Debug",
        "cwd": "${workspaceRoot}",
        "executable": "./build/st/stm32l475_discovery/aws_demos.elf",
        "request": "launch",
        "type": "cortex-debug",
        "servertype": "stutil"
    }
]

FreeRTOS mit CMake erstellen

CMake zielt standardmäßig auf Ihr Host-Betriebssystem als Zielsystem ab. Um CMake für die Cross-Kompilierung zu verwenden, erfordert der Service eine Toolchain-Datei, die den Compiler angibt, den Sie verwenden möchten. In FreeRTOS stellen wir Standard-Toolchain-Dateien bereit. freertos/tools/cmake/toolchains Die Bereitstellungsmethode für diese Datei in CMake hängt davon ab, ob Sie die CMake- Befehlszeilenschnittstelle oder die GUI verwenden. Befolgen Sie die folgenden Generieren von Build-Dateien (CMake-Befehlszeilentool)-Anweisungen, um weitere Informationen zu erhalten. Weitere Informationen zum Cross-Compiling in CMake finden CrossCompilingSie im offiziellen CMake-Wiki.

Generieren von Build-Dateien (CMake-Befehlszeilentool)

Sie können das CMake-Befehlszeilentool (cmake) verwenden, um Build-Dateien für FreeRTOS zu generieren. Um die Build-Dateien zu generieren, müssen Sie ein Ziel-Board, einen Compiler und den Speicherort des Quellcodes und des Build-Verzeichnisses angeben.

Sie können die folgenden Optionen für CMake verwenden:

Wenn der Anbieter beispielsweise Texas Instruments und die Karte das CC3220 Launchpad und der Compiler GCC für ARM ist, können Sie den folgenden Befehl ausführen, um die Quelldateien aus dem aktuellen Verzeichnis in ein Verzeichnis namens build-directory zu erstellen:

cmake -DVENDOR=ti -DBOARD=cc3220_launchpad -DCOMPILER=arm-ti -S . -B build-directory

cmake -DVENDOR=ti -DBOARD=cc3220_launchpad -DCOMPILER=arm-ti -S . -B build-directory -G Ninja

cmake -DVENDOR=ti -DBOARD=cc3220_launchpad -DCOMPILER=arm-ti -S . -B build-directory -G "MinGW Makefiles"

Die regulären Ausdrücke ${VENDOR}.* und ${BOARD}.* werden verwendet, um nach einem passenden Board zu suchen, so dass Sie für die Optionen VENDOR und BOARD nicht den vollständigen Namen des Anbieters und des Boards verwenden müssen. Teilnamen funktionieren, vorausgesetzt, es gibt eine einzige Übereinstimmung. Die folgenden Befehle erzeugen beispielsweise die gleichen Build-Dateien aus derselben Quelle:

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

Sie können die Option CMAKE_TOOLCHAIN_FILE verwenden, wenn Sie eine Toolchain-Datei verwenden möchten, die sich nicht im Standardverzeichnis cmake/toolchains befindet. Beispielsweise:

cmake -DBOARD=cc3220 -DCMAKE_TOOLCHAIN_FILE='/path/to/toolchain_file.cmake' -S . -B build-directory

Wenn die Toolchain-Datei keine absoluten Pfade für Ihren Compiler verwendet und Sie Ihren Compiler nicht zur PATH-Umgebungsvariablen hinzugefügt haben, kann CMake ihn möglicherweise nicht finden. Um sicherzustellen, dass CMake Ihre Toolchain-Datei findet, können Sie die Option AFR_TOOLCHAIN_PATH verwenden. Diese Option durchsucht den angegebenen Toolchain-Verzeichnispfad und den Unterordner der Toolchain unter bin. Beispielsweise:

cmake -DBOARD=cc3220 -DCMAKE_TOOLCHAIN_FILE='/path/to/toolchain_file.cmake' -DAFR_TOOLCHAIN_PATH='/path/to/toolchain/' -S . -B build-directory

Um das Debugging zu aktivieren, setzen Sie CMAKE_BUILD_TYPE auf debug. Wenn diese Option aktiviert ist, fügt CMake den Kompilierungsoptionen Debug-Flags hinzu und erstellt FreeRTOS mit Debug-Symbolen.

# Build with debug symbols
cmake -DBOARD=cc3220 -DCOMPILER=arm-ti -DCMAKE_BUILD_TYPE=debug -S . -B build-directory

Sie können auch das CMAKE_BUILD_TYPE auf release setzen, um den Kompilierungsoptionen Optimierungsflags hinzuzufügen.

Generieren von Build-Dateien (CMake GUI)

Sie können die CMake-GUI verwenden, um FreeRTOS-Build-Dateien zu generieren.

FreeRTOS aus generierten Build-Dateien erstellen

Build mit dem nativen Build System

Sie können FreeRTOS mit einem nativen Build-System erstellen, indem Sie den Befehl build system aus dem Ausgabe-Binärdateiverzeichnis aufrufen.

Wenn Ihr Ausgabeverzeichnis für die Build-Datei beispielsweise <build_dir> ist und Sie Make als natives Build-System verwenden, führen Sie die folgenden Befehle aus:

cd <build_dir>
make -j4

Erstellen mit CMake

Sie können auch das Befehlszeilentool CMake verwenden, um FreeRTOS zu erstellen. CMake bietet eine Abstraktionsschicht für den Aufruf nativer Build-Systeme. Beispielsweise:

cmake --build build_dir

Hier sind einige weitere häufige Anwendungen des Build-Modus des CMake-Befehlszeilenwerkzeugs:

# 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

Weitere Informationen zum CMake Build-Modus finden Sie in der CMake-Dokumentation.