Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verwendung CMake mit FreeRTOS
**Wichtig**
Diese Seite bezieht sich auf das Amazon-FreeRTOS-Repository, das veraltet ist. Wir empfehlen, dass Sie [hier beginnen](freertos-getting-started-modular.md), wenn Sie ein neues Projekt erstellen. Wenn Sie bereits ein vorhandenes FreeRTOS-Projekt haben, das auf dem inzwischen veralteten Amazon-FreeRTOS-Repository basiert, finden Sie weitere Informationen unter. [Leitfaden zur Migration des Amazon-FreerTOS Github-Repositorys](github-repo-migration.md)
Sie können CMake es 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 lieber ohne IDE arbeiten möchten, können Sie andere Codebearbeitungs- und Debugging-Tools von Drittanbietern für die Entwicklung und das Debuggen Ihres Codes verwenden und diese dann zum Erstellen und Ausführen der Anwendungen verwenden CMake .
Die folgenden Boards unterstützen: CMake
+ Espressif - C ESP32 DevKit
+ Espressif ESP-WROVER-KIT
+ Infineon XMC4800 IoT-Konnektivitätskit
+ Marvell Einsteigerpaket MW320 AWS IoT
+ Marvell Starterpaket MW322 AWS IoT
+ Microchip Curiosity MZEF-Paket PIC32
+ Nordic n DK Entwicklungskit RF52840
+ STMicroelectronicsSTM32L4 Discovery Kit IoT-Knoten
+ Texas Instruments CC3220 SF-LAUNCHXL
+ Microsoft Windows Simulator
In den folgenden Themen finden Sie weitere Informationen zur Verwendung CMake mit FreeRTOS.
**Topics**
+ [Voraussetzungen](#building-cmake-prereqs)
+ [Entwicklung von FreeRTOS-Anwendungen mit Code-Editoren und Debugging-Tools von Drittanbietern](#developing-third-party)
+ [FreeRTOS erstellen mit CMake](#building-cmake)
## Voraussetzungen
Stellen Sie sicher, dass Ihr Host-Computer die folgenden Voraussetzungen erfüllt, bevor Sie fortfahren:
+ Die Kompilierungstoolchain Ihres Geräts muss das Betriebssystem des Geräts 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 Native 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 [CMakevon.org](https://cmake.org/download/) herunterladen.
**Anmerkung**
Wenn Sie die Binärdistribution von herunterladen CMake, stellen Sie sicher, dass Sie die CMake ausführbare Datei der Umgebungsvariablen PATH hinzufügen, bevor Sie sie von der Befehlszeile CMake aus verwenden.
Du kannst auch CMake mit einem Paketmanager wie [Homebrew](https://brew.sh/) auf macOS und [Scoop](https://scoop.sh/) oder [Chocolatey](https://chocolatey.org/) auf Windows herunterladen und installieren.
**Anmerkung**
Die in den CMake Paketmanagern für viele Linux-Distributionen bereitgestellten Paketversionen sind. out-of-date Falls der Paketmanager Ihrer Distribution nicht die neueste Version von bereitstellt CMake, können Sie alternative Paketmanager wie `linuxbrew` oder `nix` ausprobieren.
+ Sie müssen über ein kompatibles natives Build-System verfügen.
CMake kann auf viele native Bausysteme abzielen, einschließlich [GNU Make](https://www.gnu.org/software/make/) oder [Ninja](https://github.com/ninja-build/ninja/releases). 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](http://www.equation.com/servlet/equation.cmd?fa=make) installieren, oder Sie können [MinGW](https://sourceforge.net/projects/mingw-w64/files/) 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](https://code.visualstudio.com/) als Code-Editor verwenden, können Sie die [Cortex-Debug](https://marketplace.visualstudio.com/items?itemName=marus25.cortex-debug) VS Code-Erweiterung als Debugger installieren. Wenn Sie mit der Entwicklung Ihrer Anwendung fertig sind, können Sie das CMake Befehlszeilentool aufrufen, um Ihr Projekt in VS Code zu erstellen. Weitere Hinweise zur Verwendung CMake zum Erstellen von FreeRTOS-Anwendungen finden Sie unter. [FreeRTOS erstellen mit CMake](#building-cmake)
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 erstellen mit CMake
CMake zielt standardmäßig auf Ihr Host-Betriebssystem als Zielsystem ab. Um es für Cross-Compiling zu verwenden, CMake ist eine Toolchain-Datei erforderlich, die den Compiler angibt, den Sie verwenden möchten. In FreeRTOS stellen wir Standard-Toolchain-Dateien bereit. `freertos/tools/cmake/toolchains` Die Art und Weise, wie Sie diese Datei bereitstellen, CMake hängt davon ab, ob Sie die CMake Befehlszeilenschnittstelle oder die GUI verwenden. Befolgen Sie die folgenden [Generieren von Build-Dateien (CMake Befehlszeilentool)](#cmake-gen-cli)-Anweisungen, um weitere Informationen zu erhalten. Weitere Informationen zum Cross-Compilieren finden Sie [CrossCompiling](https://gitlab.kitware.com/cmake/community/wikis/doc/cmake/CrossCompiling)im offiziellen CMake Wiki. CMake
**Um ein basiertes Projekt zu erstellen CMake**
1. Führen Sie aus CMake , um die Build-Dateien für ein natives Build-System wie Make oder Ninja zu generieren.
Sie können entweder das [CMake Befehlszeilentool](https://cmake.org/cmake/help/latest/manual/cmake.1.html) oder die [CMake GUI](https://cmake.org/cmake/help/latest/manual/cmake-gui.1.html) verwenden, um die Build-Dateien für Ihr natives Build-System zu generieren.
Hinweise zum Generieren von FreeRTOS-Build-Dateien finden Sie unter [Generieren von Build-Dateien (CMake Befehlszeilentool)](#cmake-gen-cli) und. [Generierung von Build-Dateien (GUI) CMake](#cmake-gen-gui)
1. Rufen Sie das native Build-System auf, um das Projekt in eine ausführbare Datei zu verwandeln.
Hinweise zur Erstellung von FreeRTOS-Build-Dateien finden Sie unter. [FreeRTOS aus generierten Build-Dateien erstellen](#cmake-build)
### 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 Hersteller beispielsweise Texas Instruments ist und das Board das CC3220 Launchpad ist und der Compiler GCC for ARM ist, können Sie den folgenden Befehl ausführen, um die Quelldateien aus dem aktuellen Verzeichnis in ein Verzeichnis mit dem Namen zu kompilieren: `build-directory`
```
cmake -DVENDOR=ti -DBOARD=cc3220_launchpad -DCOMPILER=arm-ti -S . -B build-directory
```
**Anmerkung**
Wenn Sie Windows verwenden, müssen Sie das native Buildsystem angeben, da standardmäßig Visual Studio CMake verwendet wird. 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, können Sie CMake ihn möglicherweise nicht finden. Um sicherzustellen, dass Ihre CMake Toolchain-Datei gefunden wird, können Sie die Option verwenden. `AFR_TOOLCHAIN_PATH` 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, CMake fügt sie Debug-Flags zu den Kompilierungsoptionen 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.
### Generierung von Build-Dateien (GUI) CMake
Sie können die CMake GUI verwenden, um FreeRTOS-Build-Dateien zu generieren.
**Um Build-Dateien mit der GUI zu generieren CMake**
1. Geben Sie in der Befehlszeile `cmake-gui` ein, um die GUI zu starten.
1. 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.
![\[CMake Fenster mit Eingabefeldern für den Speicherort des Quellcodes und den Speicherort der Build-Binärdateien sowie Optionen zum Durchsuchen von Quellen, zum Durchsuchen des Build-Verzeichnisses, zum Suchen, Hinzufügen oder Entfernen von Einträgen und zum Anzeigen gruppierter oder erweiterter Optionen.\]](http://docs.aws.amazon.com/de_de/freertos/latest/userguide/images/cmake-gui1.png)
1. 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.
![\[CMakeEinrichtungsdialog mit Optionen zur Angabe des Generators für das Projekt als Unix-Makefiles und zur Angabe der Toolchain-Datei für Cross-Compilierung.\]](http://docs.aws.amazon.com/de_de/freertos/latest/userguide/images/cmake-gui2.png)
1. 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)**.
1. 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 bietet. Dies hat zur Folge, dass ein Fenster mit der Meldung Error in configuration process 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 `AFR_TOOLCHAIN_PATH` Variable in der GUI so einstellen, dass sie angibt, CMake 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\$1TOOLCHAIN\$1PATH** ein. Geben Sie unter **Compiler Path (Compiler-Pfad)** den Pfad zu Ihrem Compiler ein, z. B.: `C:/toolchains/arm-none-eabi-gcc`.
1. Die GUI sollte jetzt wie folgt aussehen:
![\[CMake Konfigurationsfenster zum Erstellen von FreeRTOS mit ausgewähltem Vendor-Board, aktivierten Modulen und angegebenen Build-Pfaden.\]](http://docs.aws.amazon.com/de_de/freertos/latest/userguide/images/cmake-gui3.png)
Wählen Sie **AFR\$1BOARD**, wählen Sie Ihr Board und dann erneut **Configure (Konfigurieren)**.
1. **Wählen Sie Generieren.** CMake generiert die Build-Systemdateien (z. B. Makefiles oder Ninja-Dateien), und diese Dateien werden in dem 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ärdateiverzeichnis aufrufen.
Wenn Ihr Ausgabeverzeichnis für die Build-Datei beispielsweise `` ist und Sie Make als natives Build-System verwenden, führen Sie die folgenden Befehle aus:
```
cd
make -j4
```
#### Bauen mit CMake
Sie können auch das CMake Befehlszeilentool verwenden, um FreeRTOS zu erstellen. CMake bietet eine Abstraktionsebene zum Aufrufen nativer Build-Systeme. Beispiel:
```
cmake --build build_dir
```
Im Folgenden sind einige andere gebräuchliche Verwendungszwecke des Build-Modus des CMake Befehlszeilentools aufgeführt:
```
# 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.](https://cmake.org/cmake/help/latest/manual/cmake.1.html#build-tool-mode)