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. # CMake mit FreeRTOS verwenden **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 bestehendes FreeRTOS-Projekt haben, das auf dem inzwischen veralteten Amazon-FreeRTOS Repository basiert, finden Sie weitere Informationen unter. [Amazon-FreeRTOS Leitfaden zur Migration zum Github-Repository](github-repo-migration.md) 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 Geräten zu bearbeiten, zu debuggen, zu kompilieren, zu flashen und auszuführen. FreeRTOS-qualified 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: + Espressif ESP32-DevKitC + Espressif ESP-WROVER-KIT + Infineon XMC4800 IoT Connectivity Kit + Marvell MW320 Starterpaket AWS IoT + Marvell MW322 Starterkit AWS IoT + 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. **Topics** + [Voraussetzungen](#building-cmake-prereqs) + [Entwicklung von FreeRTOS-Anwendungen mit Code-Editoren und Debugging-Tools von Drittanbietern](#developing-third-party) + [FreeRTOS mit CMake erstellen](#building-cmake) ## 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 herunterladen. [CMake.org](https://cmake.org/download/) **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](https://brew.sh/) auf MacOS und [Scoop](https://scoop.sh/) oder [Chocolatey](https://chocolatey.org/) auf Windows. **Anmerkung** Die CMake-Paketversionen in den Paketmanagern für viele Linux-Distributionen sind veraltet. 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](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 als Code-Editor](https://code.visualstudio.com/) verwenden, können Sie die [Cortex-Debug](https://marketplace.visualstudio.com/items?itemName=marus25.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](#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 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)](#cmake-gen-cli)-Anweisungen, um weitere Informationen zu erhalten. Weitere Informationen zum Cross-Compiling in CMake finden [CrossCompiling](https://gitlab.kitware.com/cmake/community/wikis/doc/cmake/CrossCompiling)Sie im offiziellen CMake-Wiki. **Um ein Projekt zu erstellen CMake-based** 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](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. [Generieren von Build-Dateien (CMake GUI)](#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 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. 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.** ![CMakeSetup Dialog 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 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`. 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\_BOARD**, wählen Sie Ihr Board und dann erneut **Configure (Konfigurieren)**. 1. Klicken Sie auf **Generieren**. 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ä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 ``` #### 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. 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](https://cmake.org/cmake/help/latest/manual/cmake.1.html#build-tool-mode).