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.
# Erste Schritte mit dem Espressif ESP32 - DevKit C und dem ESP-WROVER-KIT
**Wichtig**
Diese Referenzintegration wird im Amazon-FreeRTOS-Repository gehostet, 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)
**Anmerkung**
Um zu erfahren, wie Sie modulare FreeRTOS-Bibliotheken und -Demos in Ihr eigenes Espressif-IDF-Projekt integrieren können, schauen Sie sich unsere [vorgestellte](https://www.freertos.org/featured-freertos-iot-integration-targeting-an-espressif-esp32-c3-risc-v-mcu/) Referenzintegration für die -C3-Plattform an. ESP32
Folgen Sie diesem Tutorial, um mit dem DevKit Espressif-C zu beginnen, das mit den Modulen ESP32 -WROOM-32, -SOLO-1 ESP32 oder ESP-WROVER ausgestattet ist, und den. ESP32 ESP-WROVER-KIT-VB Verwenden Sie die folgenden Links, um eines von unserem Partner im Partnergerätekatalog zu erwerben: AWS
+ [ESP32-WROOM-32 C DevKit](https://devices.amazonaws.com/detail/a3G0L00000AANtjUAH/ESP32-DevKitC)
+ [ESP32-SOLO-1](https://devices.amazonaws.com/detail/a3G0h0000076lSMEAY)
+ [ ESP32-WROVER-KIT](https://devices.amazonaws.com/detail/a3G0L00000AANtlUAH/ESP-WROVER-KIT)
Diese Versionen von Entwicklungsboards werden auf FreeRTOS unterstützt.
Weitere Informationen zu den neuesten Versionen dieser Boards finden Sie unter [ ESP32- DevKit C V4](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/hw-reference/modules-and-boards.html#esp32-devkitc-v4) oder [ ESP-WROVER-KITv4.1](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/hw-reference/modules-and-boards.html#esp-wrover-kit-v4-1) auf der Espressif-Website.
**Anmerkung**
Derzeit unterstützt der FreeRTOS-Port für ESP32 -WROVER-KIT und ESP DevKit C die Funktion Symmetric Multiprocessing (SMP) nicht.
## -Übersicht
In diesem Tutorial führen Sie die folgenden Schritte aus:
1. Verbinden Ihres Boards mit einem Host-Computer.
1. Installieren von Software auf dem Host-Computer zum Entwickeln und Debuggen eingebetteter Anwendungen für Ihr Mikrocontroller-Board.
1. Cross-Compilierung einer FreeRTOS-Demo-Anwendung zu einem Binär-Image.
1. Laden des binären Anwendungs-Image auf Ihr Board und Ausführen der Anwendung.
1. Interaktion mit der Anwendung, die auf Ihrem Board über eine serielle Verbindung ausgeführt wird, zu Überwachungs- und Debuggingzwecken.
## Voraussetzungen
Bevor Sie mit FreeRTOS auf Ihrem Espressif-Board beginnen, müssen Sie Ihr Konto und Ihre AWS Berechtigungen einrichten.
### Melde dich an für ein AWS-Konto
Wenn Sie noch keine haben AWS-Konto, führen Sie die folgenden Schritte aus, um eine zu erstellen.
**Um sich für eine anzumelden AWS-Konto**
1. Öffnen Sie [https://portal.aws.amazon.com/billing/die Anmeldung.](https://portal.aws.amazon.com/billing/signup)
1. Folgen Sie den Online-Anweisungen.
Während der Anmeldung erhalten Sie einen Telefonanruf oder eine Textnachricht und müssen einen Verifizierungscode über die Telefontasten eingeben.
Wenn Sie sich für eine anmelden AWS-Konto, *Root-Benutzer des AWS-Kontos*wird eine erstellt. Der Root-Benutzer hat Zugriff auf alle AWS-Services und Ressourcen des Kontos. Als bewährte Sicherheitsmethode weisen Sie einem Benutzer Administratorzugriff zu und verwenden Sie nur den Root-Benutzer, um [Aufgaben auszuführen, die Root-Benutzerzugriff erfordern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS sendet Ihnen nach Abschluss des Anmeldevorgangs eine Bestätigungs-E-Mail. Du kannst jederzeit deine aktuellen Kontoaktivitäten einsehen und dein Konto verwalten, indem du zu [https://aws.amazon.com/](https://aws.amazon.com/)gehst und **Mein Konto** auswählst.
### Erstellen eines Benutzers mit Administratorzugriff
Nachdem Sie sich für einen angemeldet haben AWS-Konto, sichern Sie Ihren Root-Benutzer des AWS-Kontos AWS IAM Identity Center, aktivieren und erstellen Sie einen Administratorbenutzer, sodass Sie den Root-Benutzer nicht für alltägliche Aufgaben verwenden.
**Sichern Sie Ihre Root-Benutzer des AWS-Kontos**
1. Melden Sie sich [AWS-Managementkonsole](https://console.aws.amazon.com/)als Kontoinhaber an, indem Sie **Root-Benutzer** auswählen und Ihre AWS-Konto E-Mail-Adresse eingeben. Geben Sie auf der nächsten Seite Ihr Passwort ein.
Hilfe bei der Anmeldung mit dem Root-Benutzer finden Sie unter [Anmelden als Root-Benutzer](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) im *AWS-Anmeldung -Benutzerhandbuch* zu.
1. Aktivieren Sie die Multi-Faktor-Authentifizierung (MFA) für den Root-Benutzer.
Anweisungen finden Sie unter [Aktivieren eines virtuellen MFA-Geräts für Ihren AWS-Konto Root-Benutzer (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) im *IAM-Benutzerhandbuch*.
**Erstellen eines Benutzers mit Administratorzugriff**
1. Aktivieren Sie das IAM Identity Center.
Anweisungen finden Sie unter [Aktivieren AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
1. Gewähren Sie einem Administratorbenutzer im IAM Identity Center Benutzerzugriff.
*Ein Tutorial zur Verwendung von IAM-Identity-Center-Verzeichnis als Identitätsquelle finden Sie IAM-Identity-Center-Verzeichnis im Benutzerhandbuch unter [Benutzerzugriff mit der Standardeinstellung konfigurieren](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html).AWS IAM Identity Center *
**Anmelden als Administratorbenutzer**
+ Um sich mit Ihrem IAM-Identity-Center-Benutzer anzumelden, verwenden Sie die Anmelde-URL, die an Ihre E-Mail-Adresse gesendet wurde, als Sie den IAM-Identity-Center-Benutzer erstellt haben.
Hilfe bei der Anmeldung mit einem IAM Identity Center-Benutzer finden Sie [im *AWS-Anmeldung Benutzerhandbuch* unter Anmeldung beim AWS Access-Portal](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html).
**Weiteren Benutzern Zugriff zuweisen**
1. Erstellen Sie im IAM-Identity-Center einen Berechtigungssatz, der den bewährten Vorgehensweisen für die Anwendung von geringsten Berechtigungen folgt.
Anweisungen hierzu finden Sie unter [ Berechtigungssatz erstellen](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
1. Weisen Sie Benutzer einer Gruppe zu und weisen Sie der Gruppe dann Single Sign-On-Zugriff zu.
Eine genaue Anleitung finden Sie unter [ Gruppen hinzufügen](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
Um Zugriff zu gewähren, fügen Sie Ihren Benutzern, Gruppen oder Rollen Berechtigungen hinzu:
+ Benutzer und Gruppen in AWS IAM Identity Center:
Erstellen Sie einen Berechtigungssatz. Befolgen Sie die Anweisungen unter [Erstellen eines Berechtigungssatzes](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
+ Benutzer, die in IAM über einen Identitätsanbieter verwaltet werden:
Erstellen Sie eine Rolle für den Identitätsverbund. Befolgen Sie die Anleitung unter [Eine Rolle für einen externen Identitätsanbieter (Verbund) erstellen](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) im *IAM-Benutzerhandbuch*.
+ IAM-Benutzer:
+ Erstellen Sie eine Rolle, die Ihr Benutzer annehmen kann. Befolgen Sie die Anleitung unter [Eine Rolle für einen IAM-Benutzer erstellen](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) im *IAM-Benutzerhandbuch*.
+ (Nicht empfohlen) Weisen Sie einem Benutzer eine Richtlinie direkt zu oder fügen Sie einen Benutzer zu einer Benutzergruppe hinzu. Befolgen Sie die Anweisungen unter [Hinzufügen von Berechtigungen zu einem Benutzer (Konsole)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) im *IAM-Benutzerhandbuch*.
## Erste Schritte
**Anmerkung**
Für die Linux-Befehle in diesem Tutorial müssen Sie die Bash-Shell verwenden.
1. **Richten Sie die Espressif-Hardware ein.**
+ Informationen zur Einrichtung der Hardware für das ESP32 DevKit C-Entwicklungsboard finden Sie im [ ESP32DevKitC V4 Getting Started Guide](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/hw-reference/esp32/get-started-devkitc.html).
+ Informationen zur Einrichtung der Hardware für das ESP-WROVER-KIT Entwicklungsboard finden Sie im [ ESP-WROVER-KITV4.1 Getting Started Guide](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/hw-reference/esp32/get-started-wrover-kit.html).
**Wichtig**
Wenn Sie den Abschnitt „**Erste Schritte**“ der Espressif-Anleitungen erreicht haben, halten Sie an und kehren Sie dann zu den Anweisungen auf dieser Seite zurück.
1. Laden Sie Amazon FreeRTOS von herunter. [GitHub](https://github.com/aws/amazon-freertos) (Anweisungen finden Sie in der Datei [README.md](https://github.com/aws/amazon-freertos/blob/main/README.md).)
1. **Richten Sie Ihre Entwicklungsumgebung ein**.
Um mit Ihrem Board zu kommunizieren, müssen Sie eine Toolchain installieren. Espressif stellt die ESP-IDF zur Verfügung, um Software für ihre Boards zu entwickeln. Da die ESP-IDF eine eigene Version des FreeRTOS-Kernels als Komponente integriert hat, enthält Amazon FreeRTOS eine benutzerdefinierte Version von ESP-IDF v4.2, bei der der FreeRTOS-Kernel entfernt wurde. Dies behebt Probleme mit doppelten Dateien beim Kompilieren. Um die in Amazon FreeRTOS enthaltene benutzerdefinierte Version von ESP-IDF v4.2 zu verwenden, folgen Sie den nachstehenden Anweisungen für das Betriebssystem Ihres Host-Computers.
**Windows**
1. [Laden Sie den Universal Online Installer von ESP-IDF für Windows herunter.](https://dl.espressif.com/dl/esp-idf/?idf=4.2)
1. Führen Sie den **Universal** Online Installer aus.
1. **Wenn Sie zum Schritt ESP-IDF **herunterladen oder verwenden gelangen, wählen Sie Bestehendes ESP-IDF-Verzeichnis** **verwenden und setzen Sie Vorhandenes ESP-IDF-Verzeichnis** auswählen auf.** `freertos/vendors/espressif/esp-idf`
1. Schließen Sie die Installation ab.
**macOS**
1. Folgen Sie den Anweisungen in den [Voraussetzungen für die Standardkonfiguration der Toolchain (ESP-IDF v4.2](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/get-started/macos-setup.html)) für macOS.
**Wichtig**
Wenn Sie unter **Nächste Schritte** zu den Anweisungen „Get ESP-IDF“ gelangen, beenden Sie den Vorgang und kehren Sie dann zu den Anweisungen auf dieser Seite zurück.
1. Öffnen Sie ein Befehlszeilenfenster.
1. Navigieren Sie zum FreeRTOS-Download-Verzeichnis und führen Sie dann das folgende Skript aus, um die espressif-Toolchain für Ihre Plattform herunterzuladen und zu installieren.
```
vendors/espressif/esp-idf/install.sh
```
1. Fügen Sie die ESP-IDF-Toolketten-Tools mit dem folgenden Befehl zum Pfad Ihres Terminals hinzu.
```
source vendors/espressif/esp-idf/export.sh
```
**Linux**
1. Folgen Sie den Anweisungen in den [Voraussetzungen für die Standardkonfiguration der Toolchain (ESP-IDF](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/get-started/linux-setup.html) v4.2) für Linux.
**Wichtig**
Wenn Sie unter „**Nächste Schritte**“ zu den Anweisungen „Get ESP-IDF“ gelangen, beenden Sie den Vorgang und kehren Sie dann zu den Anweisungen auf dieser Seite zurück.
1. Öffnen Sie ein Befehlszeilenfenster.
1. Navigieren Sie zum FreeRTOS-Download-Verzeichnis und führen Sie dann das folgende Skript aus, um die Espressif-Toolchain für Ihre Plattform herunterzuladen und zu installieren.
```
vendors/espressif/esp-idf/install.sh
```
1. Fügen Sie die ESP-IDF-Toolketten-Tools mit dem folgenden Befehl zum Pfad Ihres Terminals hinzu.
```
source vendors/espressif/esp-idf/export.sh
```
1. **Stellen Sie eine serielle Verbindung her.**
1. Um eine serielle Verbindung zwischen Ihrem Host-Computer und dem ESP32 - DevKit C herzustellen, müssen Sie die CP210x USB-zu-UART-Bridge-VCP-Treiber installieren. Sie können diese Treiber von [Silicon Labs](https://www.silabs.com/products/development-tools/software/usb-to-uart-bridge-vcp-drivers) herunterladen.
Um eine serielle Verbindung zwischen Ihrem Host-Computer und dem ESP32 -WROVER-KIT herzustellen, müssen Sie den virtuellen FTDI-COM-Port-Treiber installieren. [Sie können diesen Treiber von FTDI herunterladen.](https://www.ftdichip.com/Drivers/VCP.htm)
1. Folgen Sie den Schritten zum [Herstellen einer seriellen Verbindung mit ESP32](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/get-started/establish-serial-connection.html).
1. Nachdem Sie eine serielle Verbindung hergestellt haben, notieren Sie sich den seriellen Port für Ihre Board-Verbindung. Sie benötigen es, um die Demo zu flashen.
### Konfigurieren Sie die FreeRTOS-Demoanwendungen
Für dieses Tutorial befindet sich die FreeRTOS-Konfigurationsdatei unter. `freertos/vendors/espressif/boards/board-name/aws_demos/config_files/FreeRTOSConfig.h` (Wenn zum Beispiel ausgewählt `AFR_BOARD espressif.esp32_devkitc` ist, befindet sich die Konfigurationsdatei unter`freertos/vendors/espressif/boards/esp32/aws_demos/config_files/FreeRTOSConfig.h`.)
1. Wenn Sie macOS oder Linux verwenden, öffnen Sie eine Terminal-Eingabeaufforderung. Wenn Sie Windows verwenden, öffnen Sie die App „ESP-IDF 4.x CMD“ (falls Sie diese Option bei der Installation der ESP-IDF-Toolchain angegeben haben) oder andernfalls die App „Command Prompt“.
1. Um zu überprüfen, ob Sie Python3 installiert haben, führen Sie Folgendes aus
```
python --version
```
Die installierte Version wird angezeigt. Wenn Sie Python 3.0.1 oder höher nicht installiert haben, können Sie es von der [Python-Website](https://www.python.org/downloads/) installieren.
1. Sie benötigen die AWS Befehlszeilenschnittstelle (CLI), um AWS IoT Befehle auszuführen. Wenn Sie Windows verwenden, verwenden Sie den `easy_install awscli` Befehl, um die AWS CLI in der App „Command“ oder „ESP-IDF 4.x CMD“ zu installieren.
Wenn Sie macOS oder Linux verwenden, finden Sie weitere Informationen unter [Installation der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/installing.html).
1. Ausführen
```
aws configure
```
und konfigurieren Sie die AWS CLI mit Ihrer AWS Zugriffsschlüssel-ID, Ihrem geheimen Zugriffsschlüssel und Ihrer AWS Standardregion. Weitere Informationen finden Sie unter [Konfigurieren der AWS -CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).
1. Verwenden Sie den folgenden Befehl, um das AWS SDK für Python (boto3) zu installieren:
+ Führen Sie unter Windows in der App „Command“ oder „ESP-IDF 4.x CMD“ den folgenden Befehl aus
```
pip install boto3 --user
```
**Anmerkung**
[Einzelheiten finden Sie in der Boto3-Dokumentation.](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html)
+ Führen Sie unter macOS oder Linux Folgendes aus
```
pip install tornado nose --user
```
und dann ausführen
```
pip install boto3 --user
```
FreeRTOS enthält das `SetupAWS.py` Skript, mit dem Sie Ihr Espressif-Board für die Verbindung einfacher einrichten können. AWS IoT Wenn Sie das Skript konfigurieren möchten, öffnen Sie `freertos/tools/aws_config_quick_start/configure.json` und legen die folgenden Attribute fest:
**`afr_source_dir`**
Der vollständige Pfad zum `freertos`-Verzeichnis auf Ihrem Computer. Stellen Sie sicher, dass Sie diesen Pfad mit Schrägstrichen angeben.
**`thing_name`**
Der Name, den Sie dem AWS IoT Ding zuweisen möchten, das Ihr Board repräsentiert.
**`wifi_ssid`**
Die SSID Ihres WLANs.
**`wifi_password`**
Das Passwort für Ihr WLAN-Netzwerk
**`wifi_security`**
Der Sicherheitstyp für Ihr WLAN-Netzwerk
Die folgenden Sicherheitstypen sind gültig:
+ `eWiFiSecurityOpen` (Open, no security (Offen, keine Sicherheit)
+ `eWiFiSecurityWEP` (WEP-Sicherheit)
+ `eWiFiSecurityWPA` (WPA-Sicherheit)
+ `eWiFiSecurityWPA2`(WPA2 Sicherheit)
1. Führen Sie das Konfigurationsskript aus.
1. Wenn Sie macOS oder Linux verwenden, öffnen Sie eine Terminal-Eingabeaufforderung. Wenn Sie Windows verwenden, öffnen Sie die App „ESP-IDF 4.x CMD“ oder „Command“.
1. Navigiere zum Verzeichnis und führe es aus `freertos/tools/aws_config_quick_start`
```
python SetupAWS.py setup
```
Das -Skript führt folgende Aktionen aus:
+ Erstellt ein IoT-Ding, ein Zertifikat und eine Richtlinie.
+ Hängt die IoT-Richtlinie an das Zertifikat und das Zertifikat an das AWS IoT Ding an.
+ Füllt die `aws_clientcredential.h` Datei mit Ihrem AWS IoT Endpunkt, Ihrer Wi-Fi-SSID und Ihren Anmeldeinformationen auf.
+ Formatiert Ihr Zertifikat und Ihren privaten Schlüssel und schreibt sie in die `aws_clientcredential_keys.h` Header-Datei.
**Anmerkung**
Das Zertifikat ist nur zu Demonstrationszwecken hartcodiert. Anwendungen auf Produktionsebene sollten diese Dateien an einem sicheren Ort speichern.
Weitere Informationen dazu `SetupAWS.py` finden Sie `README.md` im `freertos/tools/aws_config_quick_start` Verzeichnis.
### Überwachung von MQTT-Nachrichten in der Cloud
Bevor Sie das FreeRTOS-Demoprojekt ausführen, können Sie den MQTT-Client in der AWS IoT Konsole so einrichten, dass er die Nachrichten überwacht, die Ihr Gerät an die Cloud sendet. AWS
**Um das MQTT-Thema mit dem MQTT-Client zu abonnieren AWS IoT**
1. Navigieren Sie zur [AWS IoT -Konsole](https://console.aws.amazon.com/iotv2/).
1. Wählen Sie im Navigationsbereich **Test** und dann **MQTT** Test Client aus.
1. Geben Sie im Feld **Subscription topic (Abonnementthema)** die Option `your-thing-name/example/topic` ein und wählen Sie dann **Subscribe to topic (Thema abonnieren)**.
Wenn das Demo-Projekt erfolgreich auf Ihrem Gerät ausgeführt wird, sehen Sie „Hello World\$1“ mehrfach zu dem Thema gesendet, das Sie abonniert haben.
### Erstellen, flashen und starten Sie das FreeRTOS-Demoprojekt mit dem Skript idf.py
Sie können das IDF-Hilfsprogramm (`idf.py`) von Espressif verwenden, um das Projekt zu erstellen und die Binärdateien auf Ihr Gerät zu flashen.
**Anmerkung**
Bei einigen Setups müssen Sie möglicherweise die Port-Option `"-p port-name"` mit verwenden, `idf.py` um den richtigen Port anzugeben, wie im folgenden Beispiel.
```
idf.py -p /dev/cu.usbserial-00101301B flash
```
**FreeRTOS unter Windows, Linux und macOS erstellen und flashen (ESP-IDF v4.2)**
1. Navigieren Sie zum Stammverzeichnis Ihres FreeRTOS-Download-Verzeichnisses.
1. Geben Sie in einem Befehlszeilenfenster den folgenden Befehl ein, um die ESP-IDF-Tools zum PATH Ihres Terminals hinzuzufügen.
**Windows (App „Command“)**
```
vendors\espressif\esp-idf\export.bat
```
**Windows (App „ESP-IDF 4.x CMD“)**
(Dies wurde bereits getan, als Sie die App geöffnet haben.)
**Linux//macOS**
```
source vendors/espressif/esp-idf/export.sh
```
1. Konfigurieren Sie cmake im `build` Verzeichnis und erstellen Sie das Firmware-Image mit dem folgenden Befehl.
```
idf.py -DVENDOR=espressif -DBOARD=esp32_wrover_kit -DCOMPILER=xtensa-esp32 build
```
Die Ausgabe sollte ungefähr wie die folgende aussehen.
```
Running cmake in directory /path/to/hello_world/build
Executing "cmake -G Ninja --warn-uninitialized /path/to/hello_world"...
Warn about uninitialized values.
-- Found Git: /usr/bin/git (found version "2.17.0")
-- Building empty aws_iot component due to configuration
-- Component names: ...
-- Component paths: ...
... (more lines of build system output)
[527/527] Generating hello-world.bin
esptool.py v2.3.1
Project build complete. To flash, run this command:
../../../components/esptool_py/esptool/esptool.py -p (PORT) -b 921600 write_flash --flash_mode dio --flash_size detect --flash_freq 40m 0x10000 build/hello-world.bin build 0x1000 build/bootloader/bootloader.bin 0x8000 build/partition_table/partition-table.bin
or run 'idf.py -p PORT flash'
```
Wenn keine Fehler vorliegen, generiert der Build die binären Firmware-Dateien.
1. Löschen Sie den Flash-Speicher Ihres Entwicklungsboards mit dem folgenden Befehl.
```
idf.py erase_flash
```
1. Verwenden Sie das `idf.py` Skript, um die Binärdatei der Anwendung auf Ihr Board zu flashen.
```
idf.py flash
```
1. Überwachen Sie die Ausgabe von der seriellen Schnittstelle Ihrer Platine mit dem folgenden Befehl.
```
idf.py monitor
```
**Anmerkung**
Sie können diese Befehle wie im folgenden Beispiel kombinieren.
```
idf.py erase_flash flash monitor
```
Bei bestimmten Host-Rechner-Setups müssen Sie den Port angeben, wenn Sie die Karte flashen, wie im folgenden Beispiel.
```
idf.py erase_flash flash monitor -p /dev/ttyUSB1
```
### FreeRTOS erstellen und flashen mit CMake
Zusätzlich zu dem vom IDF SDK bereitgestellten `idf.py` Skript zum Erstellen und Ausführen Ihres Codes können Sie das Projekt auch verwenden. CMake Derzeit unterstützt es entweder Unix-Makefiles oder das Ninja-Build-System.
**Um das Projekt zu erstellen und zu flashen**
1. Navigieren Sie in einem Befehlszeilenfenster zum Stammverzeichnis Ihres FreeRTOS-Download-Verzeichnisses.
1. Führen Sie das folgende Skript aus, um die ESP-IDF-Tools zum PATH Ihrer Shell hinzuzufügen.
**Windows**
```
vendors\espressif\esp-idf\export.bat
```
**Linux//macOS**
```
source vendors/espressif/esp-idf/export.sh
```
1. Geben Sie den folgenden Befehl ein, um die Build-Dateien zu generieren.
**Mit Unix-Makefiles**
```
cmake -DVENDOR=espressif -DBOARD=esp32_wrover_kit -DCOMPILER=xtensa-esp32 -S . -B ./YOUR_BUILD_DIRECTORY -DAFR_ENABLE_ALL_MODULES=1 -DAFR_ENABLE_TESTS=0
```
**Mit Ninja**
```
cmake -DVENDOR=espressif -DBOARD=esp32_wrover_kit -DCOMPILER=xtensa-esp32 -S . -B ./YOUR_BUILD_DIRECTORY -DAFR_ENABLE_ALL_MODULES=1 -DAFR_ENABLE_TESTS=0 -GNinja
```
1. Erstellen Sie das Projekt.
**Mit Unix-Makefiles**
```
make -C ./YOUR_BUILD_DIRECTORY -j8
```
**Mit Ninja**
```
ninja -C ./YOUR_BUILD_DIRECTORY -j8
```
1. Lösche den Blitz und flashe dann die Platine.
**Mit Unix-Makefiles**
```
make -C ./YOUR_BUILD_DIRECTORY erase_flash
```
```
make -C ./YOUR_BUILD_DIRECTORY flash
```
**Mit Ninja**
```
ninja -C ./YOUR_BUILD_DIRECTORY erase_flash
```
```
ninja -C ./YOUR_BUILD_DIRECTORY flash
```
## Ausführen der Bluetooth Low Energy-Demos
FreeRTOS unterstützt [Bluetooth Low Energy-Bibliothek](freertos-ble-library.md) Konnektivität.
Um das FreeRTOS-Demoprojekt über Bluetooth Low Energy auszuführen, müssen Sie die FreeRTOS Bluetooth Low Energy Mobile SDK-Demoanwendung auf einem iOS- oder Android-Mobilgerät ausführen.
**So richten Sie die mobile FreeRTOS Bluetooth Low Energy SDK-Demoanwendung ein**
1. Folgen Sie den Anweisungen im Abschnitt [Mobil SDKs für FreeRTOS-Bluetooth-Geräte](freertos-ble-mobile.md), um das SDK für Ihre mobile Plattform auf Ihren Host-Computer herunterzuladen und dort zu installieren.
1. Folgen Sie den Anweisungen im Abschnitt [FreeRTOS Bluetooth Low Energy Mobile SDK-Demoanwendung](ble-demo.md#ble-sdk-app), um die Demoanwendung für Mobilgeräte auf Ihrem Mobilgerät einzurichten.
Anweisungen zum Ausführen der MQTT over Bluetooth Low Energy-Demo auf Ihrem Board finden Sie unter. [MQTT über Bluetooth Low Energy](ble-demo.md#ble-demo-mqtt)
Anweisungen zur Ausführung der Wi-Fi-Bereitstellungsdemo auf Ihrem Board finden Sie unter. [WLAN-Bereitstellung](ble-demo.md#ble-demo-wifi)
## Verwenden Sie FreeRTOS in Ihrem eigenen CMake Projekt für ESP32
Wenn Sie FreeRTOS in Ihrem eigenen CMake Projekt verwenden möchten, können Sie es als Unterverzeichnis einrichten und zusammen mit Ihrer Anwendung erstellen. Besorgen Sie sich zunächst eine Kopie von FreeRTOS von. [GitHub](https://github.com/aws/amazon-freertos) Sie können es auch mit dem folgenden Befehl als Git-Submodul einrichten, damit es in future einfacher aktualisiert werden kann.
```
git submodule add -b release https://github.com/aws/amazon-freertos.git freertos
```
Wenn eine neuere Version veröffentlicht wird, können Sie Ihre lokale Kopie mit diesen Befehlen aktualisieren.
```
# Pull the latest changes from the remote tracking branch.
git submodule update --remote -- freertos
```
```
# Commit the submodule change because it is pointing to a different revision now.
git add freertos
```
```
git commit -m "Update FreeRTOS to a new release"
```
Wenn Ihr Projekt die folgende Verzeichnisstruktur hat:
```
- freertos (the copy that you obtained from GitHub or the AWS IoT console)
- src
- main.c (your application code)
- CMakeLists.txt
```
Dann ist das Folgende ein Beispiel für die `CMakeLists.txt` Top-Level-Datei, die verwendet werden kann, um Ihre Anwendung zusammen mit FreeRTOS zu erstellen.
```
cmake_minimum_required(VERSION 3.13)
project(freertos_examples)
# Tell IDF build to link against this target.
set(IDF_EXECUTABLE_SRCS "/src/main.c")
set(IDF_PROJECT_EXECUTABLE my_app)
# Add FreeRTOS as a subdirectory. AFR_BOARD tells which board to target.
set(AFR_BOARD espressif.esp32_devkitc CACHE INTERNAL "")
add_subdirectory(freertos)
# Link against the mqtt library so that we can use it. Dependencies are transitively
# linked.
target_link_libraries(my_app PRIVATE AFR::core_mqtt)
```
Führen Sie die folgenden Befehle aus, um das Projekt zu erstellen. CMake Stellen Sie sicher, dass sich der ESP32 Compiler in der Umgebungsvariablen PATH befindet.
```
cmake -S . -B build-directory -DCMAKE_TOOLCHAIN_FILE=freertos/tools/cmake/toolchains/xtensa-esp32.cmake -GNinja
```
```
cmake --build build-directory
```
Führen Sie den folgenden Befehl aus, um die Anwendung auf Ihr Board zu flashen.
```
cmake --build build-directory --target flash
```
### Komponenten von FreeRTOS verwenden
Nach der Ausführung CMake finden Sie alle verfügbaren Komponenten in der Übersichtsausgabe. Es sollte ungefähr wie das folgende Beispiel aussehen.
```
====================Configuration for FreeRTOS====================
Version: 202107.00
Git version: 202107.00-g79ad6defb
Target microcontroller:
vendor: Espressif
board: ESP32-DevKitC
description: Development board produced by Espressif that comes in two
variants either with ESP-WROOM-32 or ESP32-WROVER module
family: ESP32
data ram size: 520KB
program memory size: 4MB
Host platform:
OS: Linux-4.15.0-66-generic
Toolchain: xtensa-esp32
Toolchain path: /opt/xtensa-esp32-elf
CMake generator: Ninja
FreeRTOS modules:
Modules to build: backoff_algorithm, common, common_io, core_http,
core_http_demo_dependencies, core_json, core_mqtt,
core_mqtt_agent, core_mqtt_agent_demo_dependencies,
core_mqtt_demo_dependencies, crypto, defender, dev_mode_key_
provisioning, device_defender, device_defender_demo_
dependencies, device_shadow, device_shadow_demo_dependencies,
freertos_cli_plus_uart, freertos_plus_cli, greengrass,
http_demo_helpers, https, jobs, jobs_demo_dependencies,
kernel, logging, mqtt, mqtt_agent_interface, mqtt_demo_
helpers, mqtt_subscription_manager, ota, ota_demo_
dependencies, ota_demo_version, pkcs11, pkcs11_helpers,
pkcs11_implementation, pkcs11_utils, platform, secure_sockets,
serializer, shadow, tls, transport_interface_secure_sockets,
wifi
Enabled by user: common_io, core_http_demo_dependencies, core_json,
core_mqtt_agent_demo_dependencies, core_mqtt_demo_
dependencies, defender, device_defender, device_defender_demo_
dependencies, device_shadow, device_shadow_demo_dependencies,
freertos_cli_plus_uart, freertos_plus_cli, greengrass, https,
jobs, jobs_demo_dependencies, logging, ota_demo_dependencies,
pkcs11, pkcs11_helpers, pkcs11_implementation, pkcs11_utils,
platform, secure_sockets, shadow, wifi
Enabled by dependency: backoff_algorithm, common, core_http, core_mqtt,
core_mqtt_agent, crypto, demo_base, dev_mode_key_provisioning,
freertos, http_demo_helpers, kernel, mqtt, mqtt_agent_
interface, mqtt_demo_helpers, mqtt_subscription_manager, ota,
ota_demo_version, pkcs11_mbedtls, serializer, tls,
transport_interface_secure_sockets, utils
3rdparty dependencies: jsmn, mbedtls, pkcs11, tinycbor
Available demos: demo_cli_uart, demo_core_http, demo_core_mqtt, demo_core_mqtt_
agent, demo_device_defender, demo_device_shadow,
demo_greengrass_connectivity, demo_jobs, demo_ota_core_http,
demo_ota_core_mqtt, demo_tcp
Available tests:
=========================================================================
```
Sie können auf alle Komponenten aus der `Modules to build` Liste verweisen. Um sie mit Ihrer Anwendung zu verknüpfen, stellen Sie den `AFR::` Namespace vor den Namen `AFR::core_mqtt``AFR::ota`, z. B., usw.
### Fügen Sie mithilfe von ESP-IDF benutzerdefinierte Komponenten hinzu
Sie können weitere Komponenten hinzufügen, während Sie ESP-IDF verwenden. Angenommen, Sie möchten eine Komponente mit dem Namen `example_component` hinzufügen und Ihr Projekt sieht folgendermaßen aus:
```
- freertos
- components
- example_component
- include
- example_component.h
- src
- example_component.c
- CMakeLists.txt
- src
- main.c
- CMakeLists.txt
```
Im Folgenden finden Sie ein Beispiel für die `CMakeLists.txt` Datei für Ihre Komponente.
```
add_library(example_component src/example_component.c)
target_include_directories(example_component PUBLIC include)
```
Fügen Sie dann in der `CMakeLists.txt` Datei der obersten Ebene die Komponente hinzu, indem Sie direkt danach `add_subdirectory(freertos)` die folgende Zeile einfügen.
```
add_subdirectory(component/example_component)
```
Ändern Sie dann, `target_link_libraries` um Ihre Komponente einzubeziehen.
```
target_link_libraries(my_app PRIVATE AFR::core_mqtt PRIVATE example_component)
```
Diese Komponente ist jetzt standardmäßig automatisch mit Ihrem Anwendungscode verknüpft. Sie können jetzt die zugehörigen Header-Dateien einbeziehen und die darin definierten Funktionen aufrufen.
### Überschreiben Sie die Konfigurationen für FreeRTOS
Derzeit gibt es keinen klar definierten Ansatz zur Neudefinition der Konfigurationen außerhalb des FreeRTOS-Quellbaums. Standardmäßig wird nach den Verzeichnissen und CMake gesucht. `freertos/vendors/espressif/boards/esp32/aws_demos/config_files/` `freertos/demos/include/` Sie können jedoch eine Problemumgehung verwenden, um den Compiler anzuweisen, zuerst andere Verzeichnisse zu durchsuchen. Sie können beispielsweise einen weiteren Ordner für FreeRTOS-Konfigurationen hinzufügen.
```
- freertos
- freertos-configs
- aws_clientcredential.h
- aws_clientcredential_keys.h
- iot_mqtt_agent_config.h
- iot_config.h
- components
- src
- CMakeLists.txt
```
Die Dateien unter `freertos-configs` werden aus den Verzeichnissen `freertos/vendors/espressif/boards/esp32/aws_demos/config_files/` und `freertos/demos/include/` kopiert. Fügen Sie dann in Ihrer `CMakeLists.txt` Datei auf oberster Ebene zuvor diese Zeile hinzu, `add_subdirectory(freertos)` damit der Compiler zuerst dieses Verzeichnis durchsucht.
```
include_directories(BEFORE freertos-configs)
```
### Bereitstellen Ihrer eigenen sdkconfig für ESP-IDF
Falls Sie Ihre eigene Variable angeben möchten`sdkconfig.default`, können Sie die CMake Variable `IDF_SDKCONFIG_DEFAULTS` über die Befehlszeile festlegen:
```
cmake -S . -B build-directory -DIDF_SDKCONFIG_DEFAULTS=path_to_your_sdkconfig_defaults -DCMAKE_TOOLCHAIN_FILE=freertos/tools/cmake/toolchains/xtensa-esp32.cmake -GNinja
```
Wenn Sie keinen Speicherort für Ihre eigene `sdkconfig.default` Datei angeben, verwendet FreeRTOS die Standarddatei unter. `freertos/vendors/espressif/boards/esp32/aws_demos/sdkconfig.defaults`
Weitere Informationen finden Sie unter [Projektkonfiguration](https://docs.espressif.com/projects/esp-idf/en/v4.2-beta1/esp32s2/api-reference/kconfig.html) in der Espressif *API-Referenz*. Falls Sie nach der erfolgreichen Kompilierung auf Probleme stoßen, lesen Sie den Abschnitt über [veraltete Optionen und](https://docs.espressif.com/projects/esp-idf/en/v4.2-beta1/esp32s2/api-reference/kconfig.html#deprecated-options-and-their-replacements) deren Ersatz auf dieser Seite.
### Zusammenfassung
Wenn Sie in einem Projekt mit einer Komponente mit dem Namen `example_component` einige Konfigurationen außer Kraft setzen möchten, finden Sie hier ein vollständiges Beispiel für die Datei `CMakeLists.txt` der obersten Ebene.
```
cmake_minimum_required(VERSION 3.13)
project(freertos_examples)
set(IDF_PROJECT_EXECUTABLE my_app)
set(IDF_EXECUTABLE_SRCS "src/main.c")
# Tell IDF build to link against this target.
set(IDF_PROJECT_EXECUTABLE my_app)
# Add some extra components. IDF_EXTRA_COMPONENT_DIRS is a variable used by ESP-IDF
# to collect extra components.
get_filename_component(
EXTRA_COMPONENT_DIRS
"components/example_component" ABSOLUTE
)
list(APPEND IDF_EXTRA_COMPONENT_DIRS ${EXTRA_COMPONENT_DIRS})
# Override the configurations for FreeRTOS.
include_directories(BEFORE freertos-configs)
# Add FreeRTOS as a subdirectory. AFR_BOARD tells which board to target.
set(AFR_BOARD espressif.esp32_devkitc CACHE INTERNAL "")
add_subdirectory(freertos)
# Link against the mqtt library so that we can use it. Dependencies are transitively
# linked.
target_link_libraries(my_app PRIVATE AFR::core_mqtt)
```
## Fehlerbehebung
+ Wenn Sie macOS verwenden und das Betriebssystem Ihren nicht erkennt, stellen Sie sicher ESP-WROVER-KIT, dass Sie die D2XX-Treiber nicht installiert haben. Befolgen Sie zum Deinstallieren die Anweisungen im [FTDI-Treiber-Installationsleitfaden für macOS X](http://www.ftdichip.com/Support/Documents/AppNotes/AN_134_FTDI_Drivers_Installation_Guide_for_MAC_OSX.pdf).
+ Das von ESP-IDF bereitgestellte (und mit make monitor aufgerufene) Monitor-Hilfsprogramm hilft Ihnen beim Dekodieren von Adressen. Aus diesem Grund kann es Ihnen helfen, aussagekräftige Rückverfolgungen für den Fall zu erhalten, dass die Anwendung nicht mehr funktioniert. Weitere Informationen finden Sie unter [Automatische Adressdekodierung](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/api-guides/tools/idf-monitor.html#automatic-address-decoding) auf der Espressif-Website.
+ Es ist auch möglich, die Kommunikation mit gdb GDBstub zu aktivieren, ohne dass spezielle JTAG-Hardware erforderlich ist. Weitere Informationen finden Sie unter [Launching GDB with GDBStub](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/api-guides/tools/idf-monitor.html#launching-gdb-with-gdbstub) auf der Espressif-Website.
+ [Informationen zum Einrichten einer OpenOCD-basierten Umgebung, falls hardwarebasiertes JTAG-Debugging erforderlich ist, finden Sie unter JTAG-Debugging auf der Espressif-Website.](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/jtag-debugging/index.html)
+ Wenn es nicht unter macOS `pip` installiert werden `pyserial` kann, laden Sie es von der [Pyserial-Website](https://pypi.org/simple/pyserial) herunter.
+ Wenn das Board kontinuierlich zurückgesetzt wird, versuchen Sie, den Flash zu löschen, indem Sie den folgenden Befehl am Terminal eingeben.
```
make erase_flash
```
+ Wenn Fehler bei der Ausführung von `idf_monitor.py` auftreten, verwenden Sie Python 2.7.
+ Erforderliche Bibliotheken von ESP-IDF sind in FreeRTOS enthalten, sodass sie nicht extern heruntergeladen werden müssen. Wenn die `IDF_PATH` Umgebungsvariable gesetzt ist, empfehlen wir, dass Sie sie löschen, bevor Sie FreeRTOS erstellen.
+ Unter Windows kann es drei bis vier Minuten dauern, bis das Projekt erstellt wird. Um die Build-Zeit zu reduzieren, können Sie den `-j4` Schalter im Befehl make verwenden.
```
make flash monitor -j4
```
+ Wenn Ihr Gerät Probleme hat, eine Verbindung herzustellen AWS IoT, öffnen Sie die `aws_clientcredential.h` Datei und überprüfen Sie, ob die Konfigurationsvariablen in der Datei richtig definiert sind. `clientcredentialMQTT_BROKER_ENDPOINT[]`sollte so aussehen`1234567890123-ats.iot.us-east-1.amazonaws.com`.
+ Wenn Sie die Schritte in [Verwenden Sie FreeRTOS in Ihrem eigenen CMake Projekt für ESP32](#getting_started_espressif_cmake_project) ausführen und undefinierte Referenzfehler vom Linker sehen, liegt dies normalerweise an fehlenden abhängigen Bibliotheken oder Demos. Um sie hinzuzufügen, aktualisieren Sie die `CMakeLists.txt` Datei (im Stammverzeichnis) mit der CMake Standardfunktion`target_link_libraries`.
+ ESP-IDF v4.2 unterstützt die Verwendung von *xtensa\$1 -esp32\$1 -elf\$1 -gcc 8\$1 .2\$1 .0\$1*. Werkzeugkette. Wenn Sie eine frühere Version der Xtensa-Toolchain verwenden, laden Sie die erforderliche Version herunter.
+ Wenn Sie ein Fehlerprotokoll wie das Folgende über Python-Abhängigkeiten sehen, die für ESP-IDF v4.2 nicht erfüllt sind:
```
The following Python requirements are not satisfied:
click>=5.0
pyserial>=3.0
future>=0.15.2
pyparsing>=2.0.3,<2.4.0
pyelftools>=0.22
gdbgui==0.13.2.0
pygdbmi<=0.9.0.2
reedsolo>=1.5.3,<=1.5.4
bitstring>=3.1.6
ecdsa>=0.16.0
Please follow the instructions found in the "Set up the tools" section of ESP-IDF Getting Started Guide
```
Installieren Sie die Python-Abhängigkeiten auf Ihrer Plattform mit dem folgenden Python-Befehl:
```
root/vendors/espressif/esp-idf/requirements.txt
```
Weitere Informationen zur Fehlerbehebung finden Sie unter[Fehlerbehebung – Erste Schritte](gsg-troubleshooting.md).
## Debuggen
### Debuggen von Code auf Espressif ESP32 — DevKit C und ESP-WROVER-KIT (ESP-IDF v4.2)
In diesem Abschnitt erfahren Sie, wie Sie Espressif-Hardware mit ESP-IDF v4.2 debuggen. Sie benötigen ein JTAG zu USB-Kabel. [Wir verwenden ein USB-MPSSE-Kabel (z. B. das FTDI C232HM-DDHSL-0).](http://www.ftdichip.com/Products/Cables/USBMPSSE.htm)
**DevKitESP-C JTAG-Setup**
Für das FTDI C232HM-DDHSL-0-Kabel sind dies die Verbindungen zum DevkitC. ESP32
```
| C232HM-DDHSL-0 Wire Color | ESP32 GPIO Pin | JTAG Signal Name |
| ------------------------- | -------------- | ---------------- |
| Brown (pin 5) | IO14 | TMS |
| Yellow (pin 3) | IO12 | TDI |
| Black (pin 10) | GND | GND |
| Orange (pin 2) | IO13 | TCK |
| Green (pin 4) | IO15 | TDO |
```
**ESP-WROVER-KIT JTAG-Setup**
Für das FTDI C232HM-DDHSL-0-Kabel sind dies die Verbindungen zum -WROVER-KIT. ESP32
```
| C232HM-DDHSL-0 Wire Color | ESP32 GPIO Pin | JTAG Signal Name |
| ------------------------- | -------------- | ---------------- |
| Brown (pin 5) | IO14 | TMS |
| Yellow (pin 3) | IO12 | TDI |
| Orange (pin 2) | IO13 | TCK |
| Green (pin 4) | IO15 | TDO |
```
Diese Tabellen wurden aus dem [ FTDI-C232HM-DDHSL-0-Datenblatt](https://www.ftdichip.com/Support/Documents/DataSheets/Cables/DS_C232HM_MPSSE_CABLE.pdf) entwickelt. Weitere Informationen finden Sie im Abschnitt „C232HM MPSSE-Kabelanschluss und mechanische Details“ im Datenblatt.
Um JTAG auf dem zu aktivieren ESP-WROVER-KIT, platzieren Sie Jumper an den TMS-, TDO-, TDI-, TCK- und S\$1TDI-Pins, wie hier gezeigt.
![\[Platzierung der Jumper\]](http://docs.aws.amazon.com/de_de/freertos/latest/userguide/images/JP8-jumpers.png)
**Debuggen unter Windows (ESP-IDF v4.2)**
**So richten Sie das Debugging in Windows ein:**
1. Verbinden Sie die USB-Seite von FTDI-C232HM-DDHSL-0 mit Ihrem Computer und der anderen Seite, siehe [Debuggen von Code auf Espressif ESP32 — DevKit C und ESP-WROVER-KIT (ESP-IDF v4.2)](#debugging-espressif-idf42). Das FTDI-C232HM-DDHSL-0-Gerät sollte im **Device Manager (Geräte-Manager)** unter **Universal Serial Bus Controllers (Universal-Serial-Bus-Controller)** erscheinen.
1. **Klicken Sie in der Liste der Geräte mit dem universellen seriellen Bus mit der rechten Maustaste auf das **C232HM-DDHSL-0-Gerät** und wählen Sie dann Eigenschaften.**
**Anmerkung**
Das Gerät ist möglicherweise als **USB-Serial Port (Serieller USB-Anschluss)** aufgeführt.
**Um die Eigenschaften des Geräts anzuzeigen, wählen Sie im Eigenschaftenfenster die Registerkarte Details.** Wenn das Gerät nicht aufgeführt ist, installieren Sie den [Windows-Treiber für FTDI C232HM-DDHSL-0](http://www.ftdichip.com/Drivers/D2XX.htm).
1. ****Wählen Sie auf der Registerkarte **Details die Option Eigenschaft und dann Hardware** aus. IDs**** Im Feld **Wert** sollte etwas Ähnliches angezeigt werden.
```
FTDIBUS\COMPORT&VID_0403&PID_6014
```
In diesem Beispiel lautet die Anbieter-ID 0403 und die Produkt-ID 6014.
Stellen Sie sicher, dass diese IDs mit IDs der Eingabe übereinstimmen`projects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg`. Sie IDs werden in einer Zeile angegeben, die mit beginnt, `ftdi_vid_pid` gefolgt von einer Lieferanten-ID und einer Produkt-ID.
```
ftdi_vid_pid 0x0403 0x6014
```
1. Laden Sie [OpenOCD für Windows](https://github.com/espressif/openocd-esp32/releases) herunter.
1. Entpacken Sie die Datei in das Verzeichnis `C:\` und fügen Sie `C:\openocd-esp32\bin` Ihrem Systempfad hinzu.
1. OpenOCD erfordert libusb. Dies wird unter Windows nicht standardmäßig installiert. Um libusb zu installieren:
1. Laden Sie [zadig.exe](https://zadig.akeo.ie) herunter.
1. Führen Sie `zadig.exe`. Wählen Sie im Menü **Optionen** die Option **List All Devices (Alle Geräte auflisten)** aus.
1. **Wählen Sie im Dropdownmenü C232HM-DDHSL-0.**
1. Wählen Sie im Feld für den Zieltreiber rechts neben dem grünen Pfeil **WinUSB** aus.
1. **Wählen Sie für die Liste unter dem Zieltreiberfeld den Pfeil und dann Treiber installieren aus.** Klicken Sie auf **Replace Driver (Treiber ersetzen)**.
1. Öffnen Sie eine Befehlszeile, navigieren Sie zum Stammverzeichnis Ihres FreeRTOS-Download-Verzeichnisses und führen Sie den folgenden Befehl aus.
```
idf.py openocd
```
Lassen Sie dieses Befehlszeilenfenster geöffnet.
1. Öffnen Sie eine neue Eingabeaufforderung, navigieren Sie zum Stammverzeichnis Ihres FreeRTOS-Download-Verzeichnisses und führen Sie Folgendes aus:
```
idf.py flash monitor
```
1. Öffne eine weitere Eingabeaufforderung, navigiere zum Stammverzeichnis deines FreeRTOS-Download-Verzeichnisses und warte, bis die Demo auf deinem Board läuft. Wenn das der Fall ist, starte
```
idf.py gdb
```
Das Programm sollte in der `main`-Funktion stoppen.
**Anmerkung**
Der ESP32 unterstützt maximal zwei Breakpoints.
**Debuggen auf macOS (ESP-IDF v4.2)**
1. Laden Sie den [FTDI-Treiber für macOS](http://www.ftdichip.com/Drivers/VCP.htm) herunter.
1. Laden Sie [OpenOCD](https://github.com/espressif/openocd-esp32/releases) herunter.
1. Extrahieren Sie die heruntergeladen TAR-Datei und legen Sie den Pfad in `.bash_profile` auf `OCD_INSTALL_DIR/openocd-esp32/bin` fest.
1. Verwenden Sie den folgenden Befehl, um die Installation `libusb` auf macOS durchzuführen.
```
brew install libusb
```
1. Verwenden Sie den folgenden Befehl, um den Treiber für die serielle Schnittstelle zu entladen.
```
sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver
```
1. Verwenden Sie den folgenden Befehl, um den Treiber für die serielle Schnittstelle zu entladen.
```
sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver
```
1. Wenn Sie eine neuere macOS-Version als 10.9 verwenden, verwenden Sie den folgenden Befehl, um den Apple FTDI-Treiber zu entladen.
```
sudo kextunload -b com.apple.driver.AppleUSBFTDI
```
1. Verwenden Sie den folgenden Befehl, um die Produkt-ID und Anbieter-ID des FTDI-Kabels zu bekommen. Er listet die angeschlossenen USB-Geräte auf.
```
system_profiler SPUSBDataType
```
Die Ausgabe von `system_profiler` sollte wie folgt aussehen.
```
DEVICE:
Product ID: product-ID
Vendor ID: vendor-ID (Future Technology Devices International Limited)
```
1. Öffnen Sie die `projects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg` Datei. Die Anbieter-ID und Produkt-ID für Ihr Gerät sind in einer Zeile angegeben, die mit `ftdi_vid_pid` beginnt. Ändern Sie IDs das so, dass es mit der `system_profiler` Ausgabe im vorherigen Schritt übereinstimmt. IDs
1. Öffnen Sie ein Terminalfenster, navigieren Sie zum Stammverzeichnis Ihres FreeRTOS-Download-Verzeichnisses und verwenden Sie den folgenden Befehl, um OpenOCD auszuführen.
```
idf.py openocd
```
Lassen Sie dieses Terminalfenster geöffnet.
1. Öffnen Sie ein neues Terminal und laden Sie mit dem folgenden Befehl den FTDI-Treiber für die serielle Schnittstelle.
```
sudo kextload -b com.FTDI.driver.FTDIUSBSerialDriver
```
1. Gehen Sie zum Stammverzeichnis Ihres FreeRTOS-Download-Verzeichnisses und starten Sie
```
idf.py flash monitor
```
1. Öffnen Sie ein anderes neues Terminal, navigieren Sie zum Stammverzeichnis Ihres FreeRTOS-Download-Verzeichnisses und starten Sie
```
idf.py gdb
```
Das Programm sollte bei `main` stoppen.
**Debuggen unter Linux (ESP-IDF v4.2)**
1. Laden Sie [OpenOCD](https://github.com/espressif/openocd-esp32/releases) herunter. Extrahieren Sie den Tarball und befolgen Sie die Installationsanweisungen in der Readme-Datei.
1. Verwenden Sie den folgenden Befehl, um libusb unter Linux zu installieren.
```
sudo apt-get install libusb-1.0
```
1. Öffnen Sie ein Terminal und geben Sie **ls -l /dev/ttyUSB\$1** ein, um alle mit Ihrem Computer verbundenen USB-Geräte aufzulisten. Auf diese Weise können Sie überprüfen, ob die USB-Anschlüsse der Platine vom Betriebssystem erkannt werden. Die Ausgabe sollte ungefähr wie die folgende aussehen.
```
$ls -l /dev/ttyUSB*
crw-rw---- 1 root dialout 188, 0 Jul 10 19:04 /dev/ttyUSB0
crw-rw---- 1 root dialout 188, 1 Jul 10 19:04 /dev/ttyUSB1
```
1. Melden Sie sich ab und anschließend wieder an und schalten Sie die Stromversorgung zum Board ab und wieder an, damit die Änderungen wirksam werden. Listen Sie in einer Terminal-Eingabeaufforderung die USB-Geräte auf. Stellen Sie sicher, dass der Gruppenbesitzer von `dialout` zu gewechselt hat`plugdev`.
```
$ls -l /dev/ttyUSB*
crw-rw---- 1 root plugdev 188, 0 Jul 10 19:04 /dev/ttyUSB0
crw-rw---- 1 root plugdev 188, 1 Jul 10 19:04 /dev/ttyUSB1
```
Die `/dev/ttyUSBn`-Schnittstelle mit der niedrigeren Zahl wird für die JTAG-Kommunikation verwendet. Die andere Schnittstelle wird an die serielle Schnittstelle (UART) ESP32 von weitergeleitet und dient zum Hochladen von Code in den Flash-Speicher ESP32 von.
1. Navigieren Sie in einem Terminalfenster zum Stammverzeichnis Ihres FreeRTOS-Download-Verzeichnisses und verwenden Sie den folgenden Befehl, um OpenOCD auszuführen.
```
idf.py openocd
```
1. Öffnen Sie ein anderes Terminal, navigieren Sie zum Stammverzeichnis Ihres FreeRTOS-Download-Verzeichnisses und führen Sie den folgenden Befehl aus.
```
idf.py flash monitor
```
1. Öffnen Sie ein anderes Terminal, navigieren Sie zum Stammverzeichnis Ihres FreeRTOS-Download-Verzeichnisses und führen Sie den folgenden Befehl aus:
```
idf.py gdb
```
Das Programm sollte bei `main()` stoppen.