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 RTOS Amazon-Free-Repository gehostet, das veraltet ist. Wir empfehlen, dass Sie hier beginnen, wenn Sie ein neues Projekt erstellen. Wenn Sie bereits über ein bestehendes kostenloses RTOS Projekt verfügen, das auf dem inzwischen veralteten RTOS Amazon-Free-Repository basiert, finden Sie weitere Informationen unter. Leitfaden zur Migration des kostenlosen RTOS Github-Repositorys von Amazon
Folgen Sie diesem Tutorial, um mit dem DevKit Espressif-C zu beginnen, das mit den ESP32 Modulen - WROOM -32, ESP32 - SOLO -1 oder ESP32 - ausgestattet ist, und den. ESP WROVER ESP-WROVER-KIT-VB Verwenden Sie die folgenden Links, um eines von unserem AWS Partner im Partnergerätekatalog zu erwerben:
Diese Versionen von Entwicklungsboards werden von Free unterstütztRTOS.
Weitere Informationen zu den neuesten Versionen dieser Boards finden Sie unter ESP32- DevKit C V4
Anmerkung
Derzeit unterstützt der freie RTOS Port für ESP32 - WROVER - KIT und ESP DevKit C die Funktion Symmetric Multiprocessing () nicht. SMP
Übersicht
In diesem Tutorial führen Sie die folgenden Schritte aus:
-
Verbinden Ihres Boards mit einem Host-Computer.
-
Installieren von Software auf dem Host-Computer zum Entwickeln und Debuggen eingebetteter Anwendungen für Ihr Mikrocontroller-Board.
-
Cross-Compilierung einer kostenlosen RTOS Demo-Anwendung zu einem Binär-Image.
-
Laden des binären Anwendungs-Image auf Ihr Board und Ausführen der Anwendung.
-
Interaktion mit der Anwendung, die auf Ihrem Board über eine serielle Verbindung ausgeführt wird, zu Überwachungs- und Debuggingzwecken.
Voraussetzungen
Bevor Sie mit Free RTOS auf Ihrem Espressif-Board beginnen können, müssen Sie Ihr AWS Konto und Ihre 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
Öffnen Sie https://portal.aws.amazon.com/billing/die Anmeldung.
Folgen Sie den Online-Anweisungen.
Bei der Anmeldung müssen Sie auch einen Telefonanruf entgegennehmen und einen Verifizierungscode über die Telefontasten eingeben.
Wenn Sie sich für eine anmelden AWS-Konto, Root-Benutzer des AWS-Kontoswird eine erstellt. Der Root-Benutzer hat Zugriff auf alle AWS-Services und Ressourcen des Kontos. Als bewährte Sicherheitsmethode weisen Sie einem Administratorbenutzer Administratorzugriff zu und verwenden Sie nur den Root-Benutzer, um Aufgaben auszuführen, die Root-Benutzerzugriff erfordern.
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/
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
-
Melden Sie sich AWS Management Console
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 im AWS-Anmeldung Benutzerhandbuch zu.
-
Aktivieren Sie die Multi-Faktor-Authentifizierung (MFA) für Ihren Root-Benutzer.
Anweisungen finden Sie im Benutzerhandbuch unter Aktivieren eines virtuellen MFA Geräts für Ihren AWS-Konto IAM Root-Benutzer (Konsole).
Erstellen eines Benutzers mit Administratorzugriff
-
Aktivieren Sie IAM Identity Center.
Anweisungen finden Sie unter Aktivieren AWS IAM Identity Center im AWS IAM Identity Center Benutzerhandbuch.
-
Gewähren Sie einem Benutzer in IAM Identity Center Administratorzugriff.
Ein Tutorial zur Verwendung von IAM-Identity-Center-Verzeichnis als Identitätsquelle finden Sie unter Benutzerzugriff mit der Standardeinstellung konfigurieren IAM-Identity-Center-Verzeichnis im AWS IAM Identity Center Benutzerhandbuch.
Anmelden als Administratorbenutzer
-
Um sich mit Ihrem IAM Identity Center-Benutzer anzumelden, verwenden Sie die Anmeldung, 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 Zugriffsportal.
Weiteren Benutzern Zugriff zuweisen
-
Erstellen Sie in IAM Identity Center einen Berechtigungssatz, der der bewährten Methode zur Anwendung von Berechtigungen mit den geringsten Rechten folgt.
Anweisungen hierzu finden Sie unter Berechtigungssatz erstellen im AWS IAM Identity Center Benutzerhandbuch.
-
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 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 im AWS IAM Identity Center -Benutzerhandbuch.
-
Benutzer, IAM die über einen Identitätsanbieter verwaltet werden:
Erstellen Sie eine Rolle für den Identitätsverbund. Folgen Sie den Anweisungen unter Erstellen einer Rolle für einen externen Identitätsanbieter (Verband) im IAMBenutzerhandbuch.
-
IAMBenutzer:
-
Erstellen Sie eine Rolle, die Ihr Benutzer annehmen kann. Folgen Sie den Anweisungen unter Eine Rolle für einen IAM Benutzer erstellen im IAMBenutzerhandbuch.
-
(Nicht empfohlen) Weisen Sie einem Benutzer eine Richtlinie direkt zu oder fügen Sie einen Benutzer zu einer Benutzergruppe hinzu. Folgen Sie den Anweisungen unter Hinzufügen von Berechtigungen für einen Benutzer (Konsole) im IAMBenutzerhandbuch.
-
Erste Schritte
Anmerkung
Für die Linux-Befehle in diesem Tutorial müssen Sie die Bash-Shell verwenden.
-
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
. -
Informationen zur Einrichtung der Hardware für das ESP-WROVER-KIT Entwicklungsboard finden Sie im ESP-WROVER-KITV4.1 Getting Started Guide
.
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.
-
-
Laden Sie Amazon Free RTOS von herunter GitHub
. (Anweisungen finden Sie in der README.md-Datei .) -
Richten Sie Ihre Entwicklungsumgebung ein.
Um mit Ihrem Board zu kommunizieren, müssen Sie eine Toolchain installieren. Espressif bietet die Möglichkeit, Software ESP für IDF ihre Boards zu entwickeln. Da der ESP - eine eigene Version des Free RTOS Kernel als Komponente integriert IDF hat, RTOS enthält Amazon Free eine benutzerdefinierte Version von ESP - IDF v4.2, bei der der Free RTOS Kernel entfernt wurde. Dies behebt Probleme mit doppelten Dateien beim Kompilieren. Um die benutzerdefinierte Version von ESP - IDF v4.2 zu verwenden, die in Amazon Free enthalten istRTOS, folgen Sie den nachstehenden Anweisungen für das Betriebssystem Ihres Host-Computers.
Windows
-
Laden Sie ESP IDF den Universal Online Installer
für Windows herunter. -
Führen Sie den Universal Online Installer aus.
-
Wenn Sie zum Schritt Herunterladen oder Verwenden von ESP - gelangenIDF, wählen Sie Ein ESP vorhandenes IDF Verzeichnis verwenden und setzen Sie Vorhandenes ESP IDF Verzeichnis auswählen auf
.freertos
/vendors/espressif/esp-idf -
Schließen Sie die Installation ab.
macOS
-
Folgen Sie den Anweisungen in den Voraussetzungen für die Standardkonfiguration der Toolchain (ESP— IDF v4.2) für macOS
. Wichtig
Wenn Sie unter „Nächste Schritte“ zu den Anweisungen IDF „Get ESP —“ gelangen, beenden Sie den Vorgang und kehren Sie dann zu den Anweisungen auf dieser Seite zurück.
-
Öffnen Sie ein Befehlszeilenfenster.
-
Navigieren Sie zum Verzeichnis für kostenlose RTOS Downloads 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
-
Fügen Sie die Tools ESP - IDF toolchain mit dem folgenden Befehl zum Pfad Ihres Terminals hinzu.
source vendors/espressif/esp-idf/export.sh
Linux
-
Folgen Sie den Anweisungen in der Standardkonfiguration der Toolchainvoraussetzungen (ESP- IDF v4.2)
für Linux. Wichtig
Wenn Sie unter Nächste Schritte zu den Anweisungen IDF „Get ESP —“ gelangen, beenden Sie den Vorgang und kehren Sie dann zu den Anweisungen auf dieser Seite zurück.
-
Öffnen Sie ein Befehlszeilenfenster.
-
Navigieren Sie zum Verzeichnis für kostenlose RTOS Downloads 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
-
Fügen Sie die Tools ESP - IDF toolchain mit dem folgenden Befehl zum Pfad Ihres Terminals hinzu.
source vendors/espressif/esp-idf/export.sh
-
-
Stellen Sie eine serielle Verbindung her.
-
Um eine serielle Verbindung zwischen Ihrem Host-Computer und dem ESP32 DevKit -C herzustellen, müssen Sie die CP21 0x USB to UART VCP Bridge-Treiber installieren. Sie können diese Treiber von Silicon Labs
herunterladen. Um eine serielle Verbindung zwischen Ihrem Host-Computer und dem ESP32 - WROVER - herzustellenKIT, müssen Sie den FTDI virtuellen COM Port-Treiber installieren. Sie können diesen Treiber von herunterladen FTDI
. -
Folgen Sie den Schritten zum Herstellen einer seriellen Verbindung mit ESP32
. -
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 kostenlosen RTOS Demo-Anwendungen
Für dieses Tutorial befindet sich die kostenlose RTOS Konfigurationsdatei unter
. (Wenn diese Option beispielsweise ausgewählt freertos
/vendors/espressif/boards/board-name
/aws_demos/config_files/FreeRTOSConfig.hAFR_BOARD espressif.esp32_devkitc
ist, befindet sich die Konfigurationsdatei unter
.) freertos
/vendors/espressif/boards/esp32/aws_demos/config_files/FreeRTOSConfig.h
-
Wenn Sie macOS oder Linux verwenden, öffnen Sie eine Terminal-Eingabeaufforderung. Wenn Sie Windows verwenden, öffnen Sie die App "ESP- IDF 4.xCMD" (falls Sie diese Option bei der Installation der ESP IDF -Toolchain angegeben haben) oder andernfalls die App „Command Prompt“.
-
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
installieren. -
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 das AWS CLI in der App „Command“ oder "ESP- IDF 4.xCMD“ zu installieren.Wenn Sie macOS oder Linux verwenden, finden Sie weitere Informationen unter Installation von AWS CLI.
-
Ausführen
aws configure
und konfigurieren Sie das AWS CLI mit Ihrer AWS Zugriffsschlüssel-ID, Ihrem geheimen Zugriffsschlüssel und Ihrer AWS Standardregion. Weitere Informationen finden Sie unter Konfiguration von AWS CLI.
-
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.xCMD" den folgenden Befehl aus
pip install boto3 --user
Anmerkung
Einzelheiten finden Sie in der Boto3-Dokumentation
. -
Führen Sie unter macOS oder Linux Folgendes aus
pip install tornado nose --user
und dann ausführen
pip install boto3 --user
Free RTOS 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
und legen die folgenden Attribute fest:freertos
/tools/aws_config_quick_start/configure.jsonafr_source_dir
-
Der vollständige Pfad zum
-Verzeichnis auf Ihrem Computer. Stellen Sie sicher, dass Sie diesen Pfad mit Schrägstrichen angeben.freertos
thing_name
-
Der Name, den Sie dem AWS IoT Ding zuweisen möchten, das Ihr Board repräsentiert.
wifi_ssid
-
Der SSID Ihres Wi-Fi-Netzwerks.
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
(WEPSicherheit) -
eWiFiSecurityWPA
(WPASicherheit) -
eWiFiSecurityWPA2
(WPA2Sicherheit)
-
-
-
Führen Sie das Konfigurationsskript aus.
-
Wenn Sie macOS oder Linux verwenden, öffnen Sie eine Terminal-Eingabeaufforderung. Wenn Sie Windows verwenden, öffnen Sie die App "ESP- IDF 4.xCMD" oder „Command“.
-
Navigieren Sie zum
Verzeichnis und führen Sie es ausfreertos
/tools/aws_config_quick_startpython 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 EndpunktSSID, WLAN 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 SieREADME.md
im
Verzeichnis.freertos
/tools/aws_config_quick_start -
-
MQTTNachrichten in der Cloud überwachen
Bevor Sie das kostenlose RTOS Demo-Projekt 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 AWS Cloud sendet.
Um das MQTT Thema mit dem AWS IoT MQTT Client zu abonnieren
-
Navigieren Sie zur AWS IoT -Konsole
. -
Wählen Sie im Navigationsbereich Test und dann MQTTTest Client aus.
-
Geben Sie im Feld Subscription topic (Abonnementthema) die Option
ein und wählen Sie dann Subscribe to topic (Thema abonnieren).your-thing-name
/example/topic
Wenn das Demo-Projekt erfolgreich auf Ihrem Gerät ausgeführt wird, sehen Sie „Hello World!“ mehrfach zu dem Thema gesendet, das Sie abonniert haben.
Erstellen, flashen und starten Sie das kostenlose RTOS Demo-Projekt mit dem Skript idf.py
Sie können das IDF Programm (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 verwendenidf.py
, um den richtigen Port anzugeben, wie im folgenden Beispiel.
idf.py -p /dev/cu.usbserial-00101301B flash
Kostenlos bauen und flashen RTOS unter Windows, Linux und macOS (ESP- IDF v4.2)
-
Navigiere zum Stammverzeichnis deines kostenlosen RTOS Download-Verzeichnisses.
-
Geben Sie in einem Befehlszeilenfenster den folgenden Befehl ein, um die IDF Tools ESP - zu den Tools Ihres Terminals hinzuzufügenPATH.
- Windows (App „Command“)
-
vendors\espressif\esp-idf\export.bat
- Windows (App „ESP- IDF 4.xCMD“)
-
(Dies wurde bereits getan, als Sie die App geöffnet haben.)
- Linux//macOS
-
source vendors/espressif/esp-idf/export.sh
-
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.
-
Löschen Sie den Flash-Speicher Ihres Entwicklungsboards mit dem folgenden Befehl.
idf.py erase_flash
-
Verwenden Sie das
idf.py
Skript, um die Binärdatei der Anwendung auf Ihr Board zu flashen.idf.py flash
-
Ü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
Kostenlos erstellen und flashen mit RTOS CMake
Zusätzlich zu dem von der bereitgestellten idf.py
Skript IDF SDK zum Erstellen und Ausführen Ihres Codes können Sie das Projekt auch verwendenCMake. Derzeit unterstützt es entweder Unix-Makefiles oder das Ninja-Build-System.
Um das Projekt zu erstellen und zu flashen
-
Navigieren Sie in einem Befehlszeilenfenster zum Stammverzeichnis Ihres kostenlosen RTOS Download-Verzeichnisses.
-
Führen Sie das folgende Skript aus, um die ESP IDF -Tools zu Ihren Shells hinzuzufügenPATH.
- Windows
-
vendors\espressif\esp-idf\export.bat
- Linux//macOS
-
source vendors/espressif/esp-idf/export.sh
-
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
-
Erstellen Sie das Projekt.
- Mit Unix-Makefiles
-
make -C ./YOUR_BUILD_DIRECTORY -j8
- Mit Ninja
-
ninja -C ./YOUR_BUILD_DIRECTORY -j8
-
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
Free RTOS unterstützt Bluetooth Low Energy-Bibliothek Konnektivität.
Um das kostenlose RTOS Demo-Projekt über Bluetooth Low Energy ausführen zu können, müssen Sie die kostenlose RTOS Bluetooth Low Energy SDK Mobile-Demo-Anwendung auf einem iOS- oder Android-Mobilgerät ausführen.
Um die kostenlose mobile SDK Demoanwendung für RTOS Bluetooth Low Energy einzurichten
-
Folgen Sie den Anweisungen unterMobile SDKs für FreeRTOS-Bluetooth-Geräte, um das SDK für Ihre mobile Plattform herunterzuladen und auf Ihrem Host-Computer zu installieren.
-
Folgen Sie den Anweisungen im Abschnitt FreeRTOS Bluetooth Low Energy Mobile SDK-Demoanwendung, um die Demoanwendung für Mobilgeräte auf Ihrem Mobilgerät einzurichten.
Anweisungen dazu, wie Sie die Demo MQTT über Bluetooth Low Energy auf Ihrem Motherboard ausführen können, finden Sie unterMQTT über Bluetooth Low Energy.
Anweisungen dazu, wie Sie die Demo zur Wi-Fi-Bereitstellung auf Ihrem Motherboard ausführen, finden Sie unterWLAN-Bereitstellung.
Verwenden Sie Free RTOS in Ihrem eigenen CMake Projekt für ESP32
Wenn Sie Free RTOS 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 Free RTOS von GitHub
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
Datei der obersten Ebene, die verwendet werden kann, um Ihre Anwendung zusammen mit Free RTOS zu erstellen.
cmake_minimum_required(VERSION 3.13) project(freertos_examples) # Tell IDF build to link against this target. set(IDF_EXECUTABLE_SRCS "<complete_path>/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 CMake Befehle aus, um das Projekt zu erstellen. Stellen Sie sicher, dass sich der ESP32 Compiler in der PATH Umgebungsvariablen 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
Verwenden Sie Komponenten von Free RTOS
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 benutzerdefinierte Komponenten hinzu mit ESP - IDF
Sie können weitere Komponenten hinzufügen, während Sie ESP - verwendenIDF. 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 kostenlos RTOS
Derzeit gibt es keinen klar definierten Ansatz zur Neudefinition der Konfigurationen außerhalb des kostenlosen RTOS Quellbaums. Sucht standardmäßig nach CMake den Verzeichnissen und. freertos
/vendors/espressif/boards/esp32/aws_demos/config_files/
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 kostenlose RTOS Konfigurationen hinzufügen.freertos
/demos/include/
- 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
und freertos
/vendors/espressif/boards/esp32/aws_demos/config_files/
kopiert. Fügen Sie dann in Ihrer freertos
/demos/include/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)
Bereitstellung Ihrer eigenen sdkconfig für - ESP IDF
Falls Sie Ihre eigene angeben möchtensdkconfig.default
, können Sie die CMake Variable IDF_SDKCONFIG_DEFAULTS
über die Befehlszeile setzen:
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, RTOS verwendet Free die Standarddatei unter
.freertos
/vendors/espressif/boards/esp32/aws_demos/sdkconfig.defaults
Weitere Informationen finden Sie unter Projektkonfiguration
Übersicht
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. Um sie zu deinstallieren, folgen Sie den Anweisungen im FTDITreiberinstallationshandbuch für macOS X.
-
Das von ESP - bereitgestellte IDF (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
auf der Espressif-Website. -
Es ist auch möglich, die Kommunikation mit gdb GDBstub zu aktivieren, ohne dass spezielle Hardware erforderlich ist. JTAG Weitere Informationen finden Sie unter Launching GDB with GDBStub
auf der Espressif-Website. -
Wenn es nicht unter macOS
pip
installiert werdenpyserial
kann, laden Sie es von der Pyserial-Websiteherunter. -
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 Free enthaltenRTOS, sodass sie nicht extern heruntergeladen werden müssen. Wenn die
IDF_PATH
Umgebungsvariable gesetzt ist, empfehlen wir, dass Sie sie löschen, bevor Sie Free erstellenRTOS. -
Unter Windows kann es drei bis vier Minuten dauern, bis das Projekt erstellt wird. Um die Build-Zeit zu verkürzen, 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 aussehen1234567890123-ats.iot.us-east-1.amazonaws.com
. -
Wenn Sie die Schritte in Verwenden Sie Free RTOS in Ihrem eigenen CMake Projekt für ESP32 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 Standardfunktiontarget_link_libraries
. -
ESP- IDF v4.2 unterstützt die Verwendung von xtensa\ -esp32\ -elf\ -gcc 8\ .2\ .0\. 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 - v4.2 nicht erfüllt sind: IDF
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 unterFehlerbehebung – Erste Schritte.
Debugging
Debuggen von Code auf Espressif ESP32 — DevKit C und ESP-WROVER-KIT (ESP— v4.2) IDF
In diesem Abschnitt erfahren Sie, wie Sie Espressif-Hardware mit - v4.2 debuggen. ESP IDF Sie benötigen ein Kabel. JTAG USB Wir verwenden ein USB MPSSE Zu-Kabel (zum Beispiel das FTDIC232HM- DDHSL
- ESP- C-Setup DevKit JTAG
-
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 JTAGeinrichten
-
Für das FTDI C232HM- DDHSL -0-Kabel sind dies die Verbindungen zum - -. ESP32 WROVER KIT
| 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 auf der Grundlage des FTDIC232HM-0-Datenblatts
entwickelt. DDHSL Weitere Informationen finden Sie im Abschnitt „MPSSEC232HM-Kabelanschluss und mechanische Details“ im Datenblatt. Um den JTAG zu aktivieren ESP-WROVER-KIT, platzieren Sie die Jumper an den PinsTMS,TDO, und S_ TDI TCKTDI, wie hier gezeigt.
- Debuggen unter Windows (ESP- IDF v4.2)
-
So richten Sie das Debugging in Windows ein:
-
Connect die USB Seite des FTDI C232HM- DDHSL -0 mit Ihrem Computer und die andere Seite, wie unter beschrieben. Debuggen von Code auf Espressif ESP32 — DevKit C und ESP-WROVER-KIT (ESP— v4.2) IDF Das Gerät FTDI C232HM- DDHSL -0 sollte im Geräte-Manager unter Universal Serial Bus Controllers angezeigt werden.
-
Klicken Sie in der Liste der Geräte mit dem universellen seriellen Bus mit der rechten Maustaste auf das Gerät C232HM- DDHSL -0 und wählen Sie dann Eigenschaften.
Anmerkung
Das Gerät ist möglicherweise als serielle Schnittstelle aufgeführt. USB
Um die Eigenschaften des Geräts zu sehen, 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
- -0. DDHSL -
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
-
Laden Sie Open OCD für Windows
herunter. -
Entpacken Sie die Datei in das Verzeichnis
C:\
und fügen SieC:\openocd-esp32\bin
Ihrem Systempfad hinzu. -
Open OCD benötigt libusb, das unter Windows standardmäßig nicht installiert ist. Um libusb zu installieren:
-
Laden Sie zadig.exe
herunter. -
Führen Sie
zadig.exe
. Wählen Sie im Menü Optionen die Option List All Devices (Alle Geräte auflisten) aus. -
Wählen Sie im Dropdownmenü C232HM - -0. DDHSL
-
Wählen Sie im Feld Zieltreiber rechts neben dem grünen Pfeil die Option Win. USB
-
Wählen Sie für die Liste unter dem Zieltreiberfeld den Pfeil und dann Treiber installieren aus. Klicken Sie auf Replace Driver (Treiber ersetzen).
-
-
Öffnen Sie eine Befehlszeile, navigieren Sie zum Stammverzeichnis Ihres kostenlosen RTOS Download-Verzeichnisses und führen Sie den folgenden Befehl aus.
idf.py openocd
Lassen Sie dieses Befehlszeilenfenster geöffnet.
-
Öffnen Sie eine neue Eingabeaufforderung, navigieren Sie zum Stammverzeichnis Ihres kostenlosen RTOS Download-Verzeichnisses und führen Sie Folgendes aus
idf.py flash monitor
-
Öffnen Sie eine weitere Eingabeaufforderung, navigieren Sie zum Stammverzeichnis Ihres kostenlosen RTOS Download-Verzeichnisses und warten Sie, bis die Demo auf Ihrem Board ausgeführt wird. 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)
-
-
Laden Sie den FTDITreiber für macOS herunter
. -
Herunterladen Öffnen OCD
. -
Extrahieren Sie die heruntergeladen TAR-Datei und legen Sie den Pfad in
.bash_profile
aufOCD_INSTALL_DIR/openocd-esp32/bin
fest. -
Verwenden Sie den folgenden Befehl, um die Installation
libusb
auf macOS durchzuführen.brew install libusb
-
Verwenden Sie den folgenden Befehl, um den Treiber für die serielle Schnittstelle zu entladen.
sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver
-
Verwenden Sie den folgenden Befehl, um den Treiber für die serielle Schnittstelle zu entladen.
sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver
-
Wenn Sie eine neuere macOS-Version als 10.9 verwenden, verwenden Sie den folgenden Befehl, um den FTDI Apple-Treiber zu entladen.
sudo kextunload -b com.apple.driver.AppleUSBFTDI
-
Verwenden Sie den folgenden Befehl, um die Produkt- und Lieferanten-ID des FTDI Kabels abzurufen. 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)
-
Ö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 mitftdi_vid_pid
beginnt. Ändern Sie IDs das so, dass es mit dersystem_profiler
Ausgabe im vorherigen Schritt übereinstimmt. IDs -
Öffnen Sie ein Terminalfenster, navigieren Sie zum Stammverzeichnis Ihres kostenlosen RTOS Download-Verzeichnisses und führen Sie Open mit dem folgenden Befehl ausOCD.
idf.py openocd
Lassen Sie dieses Terminalfenster geöffnet.
-
Öffnen Sie ein neues Terminal und laden Sie mit dem folgenden Befehl den Treiber für die FTDI serielle Schnittstelle.
sudo kextload -b com.FTDI.driver.FTDIUSBSerialDriver
-
Navigieren Sie zum Stammverzeichnis Ihres kostenlosen RTOS Download-Verzeichnisses und führen Sie Folgendes aus
idf.py flash monitor
-
Öffnen Sie ein anderes neues Terminal, navigieren Sie zum Stammverzeichnis Ihres kostenlosen RTOS Download-Verzeichnisses und führen Sie Folgendes aus
idf.py gdb
Das Programm sollte bei
main
stoppen.
-
- Debuggen unter Linux (ESP- IDF v4.2)
-
-
Laden Sie Open herunter. OCD
Extrahieren Sie den Tarball und befolgen Sie die Installationsanweisungen in der Readme-Datei. -
Verwenden Sie den folgenden Befehl, um libusb unter Linux zu installieren.
sudo apt-get install libusb-1.0
-
Öffnen Sie ein Terminal und geben Sie einls -l /dev/ttyUSB*, um alle an Ihren USB Computer angeschlossenen 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
-
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. In einer Terminalaufforderung listen Sie die USB Geräte auf. Stellen Sie sicher, dass der Gruppenbesitzer von
dialout
zu gewechselt istplugdev
.$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 Nummer wird für die JTAG Kommunikation verwendet. Die andere Schnittstelle wird an die ESP32 serielle Schnittstelle (UART) weitergeleitet und dient zum Hochladen von Code in den Flash-Speicher ESP32 von. -
Navigieren Sie in einem Terminalfenster zum Stammverzeichnis Ihres kostenlosen RTOS Download-Verzeichnisses und führen Sie Open mit dem folgenden Befehl aus. OCD
idf.py openocd
-
Öffnen Sie ein anderes Terminal, navigieren Sie zum Stammverzeichnis Ihres kostenlosen RTOS Download-Verzeichnisses und führen Sie den folgenden Befehl aus.
idf.py flash monitor
-
Öffnen Sie ein anderes Terminal, navigieren Sie zum Stammverzeichnis Ihres kostenlosen RTOS Download-Verzeichnisses und führen Sie den folgenden Befehl aus:
idf.py gdb
Das Programm sollte bei
main()
stoppen.
-