CMake mit FreeRTOS verwenden

Wichtig

Diese Seite bezieht sich auf das Amazon-FreeRTOS-Repository, das veraltet ist. Wir empfehlen, dass Sie hier beginnen, wenn Sie ein neues Projekt erstellen. Wenn Sie bereits über ein bestehendes FreeRTOS-Projekt verfügen, das auf dem inzwischen veralteten Amazon-FreeRTOS-Repository basiert, lesen Sie dieLeitfaden zur Migration des Amazon-FreerTOS Github-Repositorys.

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

Sie können auch eine IDE verwenden, um Code auf Geräten zu bearbeiten, zu debuggen, zu kompilieren, zu flashen und auszuführen, die für FreerTOS qualifiziert sind. 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:

• EspressoDevKit ESP32-C

• Espressif ESP-WROVER-KIT

• Infineon XMC4800 IoT Connectivity Kit

• Marvell MW320 AWS IoT-Starter Kit

• Marvell MW322 AWS IoT-Starter Kit

• Microchip Curiosity PIC32MZEF Bundle

• Nordic nRF52840 DK Development Kit

• STMicroelectronicsSTM32L4 Discovery Kit IoT Node

• Texas Instruments CC3220SF-LAUNCHXL

• Microsoft Windows Simulator

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:

• Die Kompilierungs-Toolchain Ihres Geräts muss das Betriebssystem der Maschine unterstützen. CMake unterstützt alle Versionen von Windows, MacOS und Linux.

  Das Windows Subsystem für Linux (WSL) wird nicht unterstützt. Verwenden Sie natives CMake auf Windows-Computern.

• Sie müssen CMake Version 3.13 oder höher installiert haben.

  Sie können die Binärdistribution von CMake von CMake.org herunterladen.

  Anmerkung

  Wenn Sie die Binärdistribution von CMake herunterladen, stellen Sie sicher, dass Sie die ausführbare CMake-Datei zur PATH Umgebungsvariablen hinzufügen, bevor Sie CMake von der Befehlszeile aus verwenden.

  Sie können CMake auch mit einem Paketmanager herunterladen und installieren, z.B. Homebrew auf MacOS und Scoop oder Chocolatey auf Windows.

  Anmerkung

  Die CMake-Paketversionen, die in den Paketmanagern für viele Linux-Distributionen bereitgestellt werden, sind out-of-date. Wenn der Paketmanager Ihrer Distribution nicht die neueste Version von CMake enthält, können Sie alternative Paketmanager wie linuxbrew oder nix ausprobieren.

• Sie müssen über ein kompatibles natives Build-System verfügen.

  CMake kann viele native Build-Systeme ansprechen, einschließlich, einschließlich GNU Make oder Ninja. Sowohl Make als auch Ninja können mit Paketmanagern unter Linux, MacOS und Windows installiert werden. Wenn Sie Make unter Windows verwenden, können Sie eine eigenständige Version von Equation installieren, oder Sie können MinGW installieren, das Make bündelt.

  Anmerkung

  Das ausführbare Make in MinGW heißt mingw32-make.exe statt make.exe.

  Wir empfehlen Ihnen, Ninja zu verwenden, da es schneller ist als Make und auch nativen Support für alle Desktop-Betriebssysteme bietet.

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 Informationen zur Verwendung von CMake zur Erstellung von FreeRTOS-Anwendungen finden Sie unterFreeRTOS 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 in bereitfreertos/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 Sie CrossCompilingim offiziellen CMake-Wiki.

So erstellen Sie ein CMake-basiertes Projekt

1. Führen Sie CMake aus, um die Build-Dateien für ein natives Build-System wie Make oder Ninja zu generieren.

   Sie können entweder das CMake-Befehlszeilenwerkzeug oder die CMake-GUI verwenden, um die Build-Dateien für Ihr natives Build-System zu generieren.

   Hinweise zum Generieren von FreeRTOS-Build-Dateien finden Sie unterGenerieren von Build-Dateien (CMake-Befehlszeilentool) undGenerieren von Build-Dateien (CMake GUI).

2. Rufen Sie das native Build-System auf, um das Projekt in eine ausführbare Datei zu verwandeln.

   Hinweise zum Erstellen von FreeRTOS-Build-Dateien finden Sie unterFreeRTOS aus generierten Build-Dateien erstellen.

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:

• -DVENDOR— Spezifiziert das Zielboard.

• -DCOMPILER— Spezifiziert den Compiler.

• -S— Gibt den Speicherort des Quellcodes an.

• -B— Gibt den Speicherort der generierten Build-Dateien an.

Anmerkung

Der Compiler muss sich in der PATH-Variablen des Systems befinden, oder Sie müssen den Speicherort des Compilers angeben.

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

Anmerkung

Wenn Sie Windows verwenden, müssen Sie das native Build-System angeben, da CMake standardmäßig Visual Studio verwendet. Beispiel:

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

Oder:

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. Beispiel:

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. Beispiel:

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.

So generieren Sie Build-Dateien mit der CMake GUI

1. Geben Sie in der Befehlszeile cmake-gui ein, um die GUI zu starten.

2. Wählen Sie Browse Source (Quelle durchsuchen) und geben Sie die Quelleingabe an und wählen Sie dann Browse Build (Abbild durchsuchen) und geben Sie die Build-Ausgabe an.

   

3. Wählen Sie Configure (Konfigurieren) und suchen und wählen Sie unter Specify the build generator for this project (Geben Sie die Build-Generator für dieses Projekt an) das Build-System, das Sie verwenden möchten, um die Build-Dateien zu erzeugen. Wenn das Pop-up-Fenster nicht angezeigt wird, verwenden Sie möglicherweise ein vorhandenes Build-Verzeichnis. Löschen Sie in diesem Fall den CMake-Cache, indem Sie im Menü Datei die Option Cache löschen wählen.

   

4. Wählen Sie Specify toolchain file for cross-compiling (Geben Sie die Toolchain-Datei für das Cross-Compiling an) aus und klicken Sie dann auf Next (Weiter).

5. Wählen Sie die Toolchain-Datei (z. B. „freertos/tools/cmake/toolchains/arm-ti.cmake“) und klicken Sie dann auf Finish (Fertigstellen).

   Die Standardkonfiguration für FreeRTOS ist das Template-Board, das keine portablen Layer-Ziele bereitstellt. Dies hat zur Folge, dass ein Fenster mit der Meldung angezeigt wird.

   Anmerkung

   Wenn die folgende Fehlermeldung angezeigt wird:

   CMake Error at tools/cmake/toolchains/find_compiler.cmake:23 (message):
   Compiler not found, you can specify search path with AFR_TOOLCHAIN_PATH.

   Dies bedeutet, dass der Compiler sich nicht in Ihrer Umgebungsvariablen PATH befindet. Sie können die Variable AFR_TOOLCHAIN_PATH in der GUI angeben, um CMake mitzuteilen, wo Sie Ihren Compiler installiert haben. Wenn die Variable AFR_TOOLCHAIN_PATH nicht angezeigt wird, wählen Sie Add Entry (Eintrag hinzufügen). Geben Sie im Pop-up-Fenster unter Name AFR_TOOLCHAIN_PATH ein. Geben Sie unter Compiler Path (Compiler-Pfad) den Pfad zu Ihrem Compiler ein, z. B.: C:/toolchains/arm-none-eabi-gcc.

6. Die GUI sollte jetzt wie folgt aussehen:

   

   Wählen Sie AFR_BOARD, wählen Sie Ihr Board und dann erneut Configure (Konfigurieren).

7. Wählen Sie Generate (Erstellen). CMake generiert die Build-Systemdateien (z. B. makefiles oder ninja-Dateien) und diese Dateien werden im Build-Verzeichnis angezeigt, das Sie im ersten Schritt angegeben haben. Befolgen Sie die Anweisungen im nächsten Abschnitt, um das Binärabbild 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ärverzeichnis 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 CMake-Befehlszeilentool verwenden, um FreeRTOS zu erstellen. CMake bietet eine Abstraktionsschicht für den Aufruf nativer Build-Systeme. Beispiel:

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.