Espressif Systems ESP32-C3 Wireless Adventure-Benutzerhandbuch

Stellen Sie vor der Verwendung des ESP32-C3 Wireless Adventure sicher, dass Sie dies tun
mit den Konzepten und der Architektur des IoT vertraut sind. Das wird helfen
Sie verstehen, wie das Gerät in das größere IoT-Ökosystem passt
und seine möglichen Anwendungen in Smart Homes.

Einführung und Praxis von IoT-Projekten

In diesem Abschnitt erfahren Sie mehr über typische IoT-Projekte,
inklusive der Basismodule für gängige IoT-Geräte, Basismodule
von Client-Anwendungen und gängigen IoT-Cloud-Plattformen. Dieser Wille
Bieten Sie eine Grundlage zum Verstehen und Erstellen Ihrer
eigene IoT-Projekte.

Übung: Smart Light-Projekt

In diesem Übungsprojekt erfahren Sie, wie Sie einen smart erstellen
Licht mit dem ESP32-C3 Wireless Adventure. Die Projektstruktur,
Funktionen, Hardware-Vorbereitung und Entwicklungsprozess
ausführlich erklärt.

Projektstruktur

Das Projekt besteht aus mehreren Komponenten, darunter dem
ESP32-C3 Wireless Adventure, LEDs, Sensoren und eine Cloud
Backend.

Projektfunktionen

Mit dem Smart Light-Projekt können Sie die Helligkeit steuern und
Farbe der LEDs aus der Ferne über eine mobile App oder web
Schnittstelle.

Hardware-Vorbereitung

Um sich auf das Projekt vorzubereiten, müssen Sie Folgendes sammeln
notwendige Hardwarekomponenten, wie zum Beispiel den ESP32-C3 Wireless
Abenteuerplatine, LEDs, Widerstände und ein Netzteil.

Entwicklungsprozess

Der Entwicklungsprozess umfasst die Einrichtung der Entwicklung
Umgebung, Schreiben von Code zur Steuerung der LEDs, Herstellen einer Verbindung zur
Cloud-Backend und Testen der Funktionalität des smart
Licht.

Einführung in ESP RainMaker

ESP RainMaker ist ein leistungsstarkes Framework für die Entwicklung des IoT
Geräte. In diesem Abschnitt erfahren Sie, was ESP RainMaker ist und
wie es in Ihren Projekten umgesetzt werden kann.

Was ist ESP RainMaker?

ESP RainMaker ist eine cloudbasierte Plattform, die eine Reihe von Funktionen bereitstellt
Tools und Dienste zum Erstellen und Verwalten von IoT-Geräten.

Die Implementierung von ESP RainMaker

In diesem Abschnitt werden die verschiedenen beteiligten Komponenten erläutert
Implementierung von ESP RainMaker, einschließlich des Claiming-Services,
RainMaker-Agent, Cloud-Backend und RainMaker-Client.

Praxis: Wichtige Punkte für die Entwicklung mit ESP RainMaker

In diesem Übungsteil lernen Sie die wichtigsten Punkte kennen
Beachten Sie dies bei der Entwicklung mit ESP RainMaker. Dazu gehört auch das Gerät
Anspruch, Datensynchronisierung und Benutzerverwaltung.

Funktionen von ESP RainMaker

ESP RainMaker bietet verschiedene Funktionen zur Benutzerverwaltung
Benutzer und Administratoren. Diese Funktionen ermöglichen ein einfaches Gerät
Einrichtung, Fernbedienung und Überwachung.

Entwicklungsumgebung einrichten

Dieser Abschnitt bietet einen Überblickview von ESP-IDF (Espressif IoT
Development Framework), das offizielle Entwicklungsframework
für ESP32-basierte Geräte. Es erklärt die verschiedenen Versionen von
ESP-IDF und wie man die Entwicklungsumgebung einrichtet.

Hardware- und Treiberentwicklung

Hardware-Design von Smart Light-Produkten basierend auf ESP32-C3

Dieser Abschnitt konzentriert sich auf das Hardware-Design von Smart Light
Produkte basierend auf dem ESP32-C3 Wireless Adventure. Es umfasst die
Eigenschaften und Zusammensetzung von Smart-Light-Produkten sowie die
Hardware-Design des ESP32-C3-Kernsystems.

Merkmale und Zusammensetzung von Smart Light-Produkten

In diesem Unterabschnitt werden die Funktionen und Komponenten erläutert, die es ausmachen
bis hin zu smarten Lichtprodukten. Es werden die verschiedenen Funktionalitäten besprochen
und Designüberlegungen für die Erstellung intelligenter Lichter.

Hardware-Design des ESP32-C3-Kernsystems

Das Hardwaredesign des ESP32-C3-Kernsystems umfasst die Stromversorgung
Versorgung, Einschaltsequenz, System-Reset, SPI-Flash, Taktquelle,
und Überlegungen zu HF und Antenne. Dieser Unterabschnitt bietet
detaillierte Informationen zu diesen Aspekten.

Häufig gestellte Fragen

F: Was ist ESP RainMaker?

A: ESP RainMaker ist eine cloudbasierte Plattform, die Tools bereitstellt
und Dienstleistungen für den Aufbau und die Verwaltung von IoT-Geräten. Es vereinfacht
den Entwicklungsprozess und ermöglicht eine einfache Geräteeinrichtung aus der Ferne
Steuerung und Überwachung.

F: Wie kann ich die Entwicklungsumgebung einrichten?
ESP32-C3?

A: Um die Entwicklungsumgebung für ESP32-C3 einzurichten, benötigen Sie
ESP-IDF (Espressif IoT Development Framework) zu installieren und
Konfigurieren Sie es gemäß den bereitgestellten Anweisungen. ESP-IDF ist das
offizielles Entwicklungsframework für ESP32-basierte Geräte.

F: Welche Funktionen bietet ESP RainMaker?

A: ESP RainMaker bietet verschiedene Funktionen, einschließlich Benutzerfunktionen
Verwaltung, Endbenutzerfunktionen und Administratorfunktionen. Benutzerverwaltung
ermöglicht eine einfache Gerätebeanspruchung und Datensynchronisierung. Endbenutzer
Funktionen ermöglichen die Fernsteuerung von Geräten über eine mobile App oder
web Schnittstelle. Admin-Funktionen bieten Tools zur Geräteüberwachung
und Management.

View Fullscreen

ESP32-C3 Drahtloses Abenteuer
Ein umfassender Leitfaden zum IoT
Espressif Systems 12. Juni 2023

Inhalt

Ich Vorbereitung

1 Einführung in IoT

1.1 Architektur des IoT. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.2 IoT-Anwendung in Smart Homes . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2 Einführung und Praxis von IoT-Projekten

2.1 Einführung in typische IoT-Projekte. . . . . . . . . . . . . . . . . . . . . . . . 9

2.1.1 Basismodule für gängige IoT-Geräte . . . . . . . . . . . . . . . . . 9

2.1.2 Grundmodule von Client-Anwendungen . . . . . . . . . . . . . . . . . . . 10

2.1.3 Einführung in gängige IoT-Cloud-Plattformen. . . . . . . . . . . . . . 11

2.2 Praxis: Smart Light Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2.2.1 Projektstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.2.2 Projektfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.2.3 Hardware-Vorbereitung . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.2.4 Entwicklungsprozess . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.3 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3 Einführung in ESP RainMaker

3.1 Was ist ESP RainMaker? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

3.2 Die Implementierung von ESP RainMaker. . . . . . . . . . . . . . . . . . . . . . 21

3.2.1 Anspruchsservice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3.2.2 RainMaker-Agent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3.2.3 Cloud-Backend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.2.4 RainMaker-Client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

3.3 Praxis: Wichtige Punkte für die Entwicklung mit ESP RainMaker. . . . . . . . . . . . 25

3.4 Funktionen von ESP RainMaker . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.4.1 Benutzerverwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.4.2 Endbenutzerfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

3.4.3 Admin-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

3.5 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4 Einrichten der Entwicklungsumgebung

4.1 ESP-IDF vorbeiview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

4.1.1 ESP-IDF-Versionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

4.1.2 ESP-IDF Git-Workflow . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 4.1.3 Auswahl einer geeigneten Version . . . . . . . . . . . . . . . . . . . . . . . . 34 4.1.4 Überview des ESP-IDF SDK-Verzeichnisses. . . . . . . . . . . . . . . . . . . . 34 4.2 Einrichten der ESP-IDF-Entwicklungsumgebung . . . . . . . . . . . . . . . . . 38 4.2.1 Einrichten der ESP-IDF-Entwicklungsumgebung unter Linux . . . . . . . . 38 4.2.2 Einrichten der ESP-IDF-Entwicklungsumgebung unter Windows . . . . . . 40 4.2.3 Einrichten der ESP-IDF-Entwicklungsumgebung auf dem Mac . . . . . . . . . 45 4.2.4 VS-Code installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 4.2.5 Einführung in Entwicklungsumgebungen von Drittanbietern . . . . . . . . 46 4.3 ESP-IDF-Kompilierungssystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 4.3.1 Grundkonzepte des Kompilierungssystems . . . . . . . . . . . . . . . . . . 47 4.3.2 Projekt File Struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 4.3.3 Standard-Build-Regeln des Kompilierungssystems . . . . . . . . . . . . . 50 4.3.4 Einführung in das Kompilierungsskript . . . . . . . . . . . . . . . . . . 51 4.3.5 Einführung in allgemeine Befehle . . . . . . . . . . . . . . . . . . . 52 4.4 Übung: Kompilieren Bspample Programm „Blink“ . . . . . . . . . . . . . . . . . . 53 4.4.1 Bspample Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 4.4.2 Kompilieren des Blinkprogramms . . . . . . . . . . . . . . . . . . . . . . . 56 4.4.3 Blinkprogramm flashen . . . . . . . . . . . . . . . . . . . . . . . . 59 4.4.4 Protokollanalyse des seriellen Ports des Blink-Programms . . . . . . . . . . . . . . 60 4.5 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

II Hardware- und Treiberentwicklung

5 Hardware-Design von Smart Light-Produkten basierend auf ESP32-C3

5.1 Merkmale und Zusammensetzung von Smart Light-Produkten . . . . . . . . . . . . . . . 67

5.2 Hardware-Design des ESP32-C3-Kernsystems. . . . . . . . . . . . . . . . . . . 70

5.2.1 Stromversorgung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

5.2.2 Einschaltsequenz und System-Reset . . . . . . . . . . . . . . . . . . 74

5.2.3 SPI-Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

5.2.4 Taktquelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

5.2.5 HF und Antenne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

5.2.6 Umreifungsstifte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

5.2.7 GPIO- und PWM-Controller . . . . . . . . . . . . . . . . . . . . . . . . . 79

5.3 Übung: Aufbau eines intelligenten Lichtsystems mit ESP32-C3 . . . . . . . . . . . . . 80

5.3.1 Module auswählen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

5.3.2 GPIOs von PWM-Signalen konfigurieren . . . . . . . . . . . . . . . . . . . . 82

5.3.3 Firmware herunterladen und Debugging-Schnittstelle . . . . . . . . . . . . 82

5.3.4 Richtlinien für das HF-Design . . . . . . . . . . . . . . . . . . . . . . . . . . 84 5.3.5 Richtlinien für die Stromversorgungsauslegung . . . . . . . . . . . . . . . . . . . 86 5.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

6 Treiberentwicklung

6.1 Treiberentwicklungsprozess . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

6.2 ESP32-C3-Peripherieanwendungen. . . . . . . . . . . . . . . . . . . . . . . . . 88

6.3 Grundlagen zum LED-Treiber . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

6.3.1 Farbräume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

6.3.2 LED-Treiber . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

6.3.3 LED-Dimmung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

6.3.4 Einführung in PWM . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

6.4 Entwicklung von LED-Dimmtreibern . . . . . . . . . . . . . . . . . . . . . . . . 96

6.4.1 Nichtflüchtiger Speicher (NVS) . . . . . . . . . . . . . . . . . . . . . . . . 97

6.4.2 LED-PWM-Controller (LEDC) . . . . . . . . . . . . . . . . . . . . . . . 98

6.4.3 LED-PWM-Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . 100

6.5 Übung: Treiber zum Smart Light-Projekt hinzufügen . . . . . . . . . . . . . . . . . 103

6.5.1 Tastentreiber . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

6.5.2 LED-Dimmtreiber . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

6.6 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

III Drahtlose Kommunikation und Steuerung

109

7 WLAN-Konfiguration und -Verbindung

111

7.1 Grundlagen von WLAN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

7.1.1 Einführung in WLAN . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

7.1.2 Entwicklung von IEEE 802.11 . . . . . . . . . . . . . . . . . . . . . . . . . 111

7.1.3 WLAN-Konzepte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

7.1.4 WLAN-Verbindung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

7.2 Grundlagen von Bluetooth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

7.2.1 Einführung in Bluetooth . . . . . . . . . . . . . . . . . . . . . . . . . 123

7.2.2 Bluetooth-Konzepte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

7.2.3 Bluetooth-Verbindung . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

7.3 WLAN-Netzwerkkonfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

7.3.1 Wi-Fi-Netzwerk-Konfigurationsanleitung . . . . . . . . . . . . . . . . . . . . 131

7.3.2 SoftAP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

7.3.3 SmartConfig . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

7.3.4 Bluetooth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

7.3.5 Andere Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

7.4 WLAN-Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 7.4.1 WLAN-Komponenten in ESP-IDF . . . . . . . . . . . . . . . . . . . . . . . 139 7.4.2 Übung: WLAN-Verbindung . . . . . . . . . . . . . . . . . . . . . . . . 141 7.4.3 Übung: Intelligente WLAN-Verbindung . . . . . . . . . . . . . . . . . . . . . 145
7.5 Übung: WLAN-Konfiguration im Smart Light-Projekt . . . . . . . . . . . . . . . 156 7.5.1 WLAN-Verbindung im Smart Light Project . . . . . . . . . . . . . . . . . 156 7.5.2 Smart Wi-Fi-Konfiguration . . . . . . . . . . . . . . . . . . . . . . . . . 157
7.6 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

8 Lokale Steuerung

159

8.1 Einführung in die lokale Steuerung . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

8.1.1 Anwendung der lokalen Steuerung . . . . . . . . . . . . . . . . . . . . . . . . 161

8.1.2 Fortschritttages der lokalen Kontrolle. . . . . . . . . . . . . . . . . . . . . . . . 161

8.1.3 Erkennen gesteuerter Geräte über Smartphones . . . . . . . . . . 161

8.1.4 Datenkommunikation zwischen Smartphones und Geräten . . . . . . . . 162

8.2 Gängige lokale Erkennungsmethoden. . . . . . . . . . . . . . . . . . . . . . . . 162

8.2.1 Übertragung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

8.2.2 Multicast . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169

8.2.3 Vergleich zwischen Broadcast und Multicast . . . . . . . . . . . . . . 176

8.2.4 Multicast Application Protocol mDNS für lokale Erkennung . . . . . . . . 176

8.3 Gemeinsame Kommunikationsprotokolle für lokale Daten . . . . . . . . . . . . . . . 179

8.3.1 Transmission Control Protocol (TCP) . . . . . . . . . . . . . . . . . . . 179

8.3.2 HyperText Transfer Protocol (HTTP) . . . . . . . . . . . . . . . . . . . 185

8.3.3 BenutzerdatentagRAM-Protokoll (UDP) . . . . . . . . . . . . . . . . . . . . . . 189

8.3.4 Constrained Application Protocol (CoAP) . . . . . . . . . . . . . . . . 192

8.3.5 Bluetooth-Protokoll . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

8.3.6 Zusammenfassung der Datenkommunikationsprotokolle . . . . . . . . . . . . . . . 203

8.4 Gewährleistung der Datensicherheit. . . . . . . . . . . . . . . . . . . . . . . . . . . . 205

8.4.1 Einführung in Transport Layer Security (TLS) . . . . . . . . . . . . . 207

8.4.2 Einführung in DatagRAM Transport Layer Security (DTLS) . . . . . . . 213

8.5 Praxis: Lokale Steuerung im Smart Light-Projekt . . . . . . . . . . . . . . . . . . 217

8.5.1 Erstellen eines Wi-Fi-basierten lokalen Steuerungsservers . . . . . . . . . . . . . . . 217

8.5.2 Überprüfen der lokalen Steuerungsfunktionalität mithilfe von Skripten. . . . . . . . . . . 221

8.5.3 Erstellen eines Bluetooth-basierten lokalen Steuerungsservers . . . . . . . . . . . . 222

8.6 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224

9 Cloud-Steuerung

225

9.1 Einführung in die Fernbedienung . . . . . . . . . . . . . . . . . . . . . . . . . . 225

9.2 Cloud-Datenkommunikationsprotokolle . . . . . . . . . . . . . . . . . . . . . . 226

9.2.1 MQTT-Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226 9.2.2 MQTT-Prinzipien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227 9.2.3 MQTT-Nachrichtenformat . . . . . . . . . . . . . . . . . . . . . . . . . . 228 9.2.4 Protokollvergleich . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 9.2.5 MQTT-Broker unter Linux und Windows einrichten . . . . . . . . . . . . 233 9.2.6 MQTT-Client basierend auf ESP-IDF einrichten . . . . . . . . . . . . . . . . 235 9.3 Gewährleistung der MQTT-Datensicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . 237 9.3.1 Bedeutung und Funktion von Zertifikaten . . . . . . . . . . . . . . . . . . . 237 9.3.2 Zertifikate lokal generieren . . . . . . . . . . . . . . . . . . . . . . 239 9.3.3 MQTT-Broker konfigurieren . . . . . . . . . . . . . . . . . . . . . . . . . 241 9.3.4 MQTT-Client konfigurieren . . . . . . . . . . . . . . . . . . . . . . . . . 241 9.4 Praxis: Fernsteuerung durch ESP RainMaker . . . . . . . . . . . . . . . . 243 9.4.1 ESP RainMaker-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . 243 9.4.2 Knoten- und Cloud-Backend-Kommunikationsprotokoll . . . . . . . . . . . 244 9.4.3 Kommunikation zwischen Client und Cloud-Backend . . . . . . . . . . . 249 9.4.4 Benutzerrollen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252 9.4.5 Basisdienste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253 9.4.6 Smart Light Example. . . . . . . . . . . . . . . . . . . . . . . . . . . . 255 9.4.7 RainMaker-App und Drittanbieter-Integrationen . . . . . . . . . . . . . . . 262 9.5 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267

10 Smartphone-App-Entwicklung

269

10.1 Einführung in die Smartphone-App-Entwicklung. . . . . . . . . . . . . . . . . . 269

10.1.1 Überview der Smartphone-App-Entwicklung. . . . . . . . . . . . . . . 270

10.1.2 Struktur des Android-Projekts . . . . . . . . . . . . . . . . . . . . . . 270

10.1.3 Struktur des iOS-Projekts . . . . . . . . . . . . . . . . . . . . . . . . 271

10.1.4 Lebenszyklus einer Android-Aktivität . . . . . . . . . . . . . . . . . . . . . . 272

10.1.5 Lebenszyklus von iOS ViewController. . . . . . . . . . . . . . . . . . . . . . 273

10.2 Erstellen eines neuen Smartphone-App-Projekts . . . . . . . . . . . . . . . . . . . . . 275

10.2.1 Vorbereitung auf die Android-Entwicklung. . . . . . . . . . . . . . . . . . . 275

10.2.2 Erstellen eines neuen Android-Projekts . . . . . . . . . . . . . . . . . . . . . . 275

10.2.3 Abhängigkeiten für MyRainmaker hinzufügen. . . . . . . . . . . . . . . . . 276

10.2.4 Berechtigungsanfrage in Android. . . . . . . . . . . . . . . . . . . . . . 277

10.2.5 Vorbereitung auf die iOS-Entwicklung. . . . . . . . . . . . . . . . . . . . . . 277

10.2.6 Erstellen eines neuen iOS-Projekts . . . . . . . . . . . . . . . . . . . . . . . . 278

10.2.7 Abhängigkeiten für MyRainmaker hinzufügen. . . . . . . . . . . . . . . . . 279

10.2.8 Berechtigungsanfrage in iOS. . . . . . . . . . . . . . . . . . . . . . . . . 280

10.3 Analyse der funktionalen Anforderungen der App . . . . . . . . . . . . . . . . . . 281

10.3.1 Analyse der funktionalen Anforderungen des Projekts . . . . . . . . . . . . 282

10.3.2 Analyse der Benutzerverwaltungsanforderungen . . . . . . . . . . . . . . . 282 10.3.3 Analyse der Gerätebereitstellungs- und Bindungsanforderungen . . . . . . . 283 10.3.4 Analyse der Fernsteuerungsanforderungen . . . . . . . . . . . . . . . . 283 10.3.5 Analyse der Terminierungsanforderungen . . . . . . . . . . . . . . . . . . . 284 10.3.6 Analyse der User Center-Anforderungen . . . . . . . . . . . . . . . . . . 285 10.4 Entwicklung des Benutzermanagements . . . . . . . . . . . . . . . . . . . . . . . . 285 10.4.1 Einführung in RainMaker-APIs . . . . . . . . . . . . . . . . . . . . . . 285 10.4.2 Kommunikation per Smartphone einleiten . . . . . . . . . . . . . . . . 286 10.4.3 Kontoregistrierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286 10.4.4 Kontoanmeldung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 10.5 Entwicklung der Gerätebereitstellung . . . . . . . . . . . . . . . . . . . . . . . 292 10.5.1 Scangeräte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293 10.5.2 Geräte anschließen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295 10.5.3 Geheime Schlüssel generieren . . . . . . . . . . . . . . . . . . . . . . . . . . . 298 10.5.4 Knoten-ID abrufen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298 10.5.5 Geräte bereitstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300 10.6 Entwicklung der Gerätesteuerung . . . . . . . . . . . . . . . . . . . . . . . . . . 302 10.6.1 Geräte an Cloud-Konten binden . . . . . . . . . . . . . . . . . . . . 303 10.6.2 Eine Geräteliste abrufen . . . . . . . . . . . . . . . . . . . . . . . . . . 305 10.6.3 Gerätestatus abrufen . . . . . . . . . . . . . . . . . . . . . . . . . . . 308 10.6.4 Gerätestatus ändern . . . . . . . . . . . . . . . . . . . . . . . . . . 310 10.7 Entwicklung von Scheduling und User Center . . . . . . . . . . . . . . . . . . . 313 10.7.1 Implementierung der Scheduling-Funktion . . . . . . . . . . . . . . . . . . . . 313 10.7.2 User Center implementieren . . . . . . . . . . . . . . . . . . . . . . . . . 315 10.7.3 Weitere Cloud-APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318 10.8 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319

11 Firmware-Upgrade und Versionsverwaltung

321

11.1 Firmware-Upgrade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321

11.1.1 Überview von Partitionstabellen. . . . . . . . . . . . . . . . . . . . . . . . 322

11.1.2 Firmware-Bootvorgang . . . . . . . . . . . . . . . . . . . . . . . . . . . 324

11.1.3 Überview des OTA-Mechanismus. . . . . . . . . . . . . . . . . . . . . 326

11.2 Firmware-Versionsverwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . 329

11.2.1 Firmware-Markierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329

11.2.2 Rollback und Anti-Rollback . . . . . . . . . . . . . . . . . . . . . . . . 331

11.3 Praxis: Over-the-Air (OTA) Bspample. . . . . . . . . . . . . . . . . . . . . . . 332

11.3.1 Firmware über einen lokalen Host aktualisieren. . . . . . . . . . . . . . . . . 332

11.3.2 Firmware über ESP RainMaker aktualisieren. . . . . . . . . . . . . . . 335

11.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342

IV-Optimierung und Massenproduktion

343

12 Energieverwaltung und Low-Power-Optimierung

345

12.1 ESP32-C3 Energieverwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . 345

12.1.1 Dynamische Frequenzskalierung . . . . . . . . . . . . . . . . . . . . . . . . 346

12.1.2 Energieverwaltungskonfiguration . . . . . . . . . . . . . . . . . . . . 348

12.2 ESP32-C3 Energiesparmodus . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348

12.2.1 Modem-Ruhemodus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349

12.2.2 Leichtschlafmodus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351

12.2.3 Tiefschlafmodus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356

12.2.4 Stromverbrauch in verschiedenen Leistungsmodi . . . . . . . . . . . . . 358

12.3 Energieverwaltung und Low-Power-Debugging . . . . . . . . . . . . . . . . . 359

12.3.1 Protokoll-Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360

12.3.2 GPIO-Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362

12.4 Praxis: Energiemanagement im Smart Light-Projekt . . . . . . . . . . . . . . . 363

12.4.1 Konfigurieren der Energieverwaltungsfunktion. . . . . . . . . . . . . . . . . 364

12.4.2 Power-Management-Sperren verwenden. . . . . . . . . . . . . . . . . . . . . . 365

12.4.3 Überprüfen des Stromverbrauchs . . . . . . . . . . . . . . . . . . . . . . . 366

12.5 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367

13 erweiterte Gerätesicherheitsfunktionen

369

13.1 Überview der Datensicherheit von IoT-Geräten. . . . . . . . . . . . . . . . . . . . . . . 369

13.1.1 Warum IoT-Gerätedaten sichern? . . . . . . . . . . . . . . . . . . . . . . 370

13.1.2 Grundvoraussetzungen für die Datensicherheit von IoT-Geräten . . . . . . . . . . . . 371

13.2 Schutz der Datenintegrität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372

13.2.1 Einführung in die Methode zur Integritätsüberprüfung . . . . . . . . . . . . . . 372

13.2.2 Integritätsprüfung von Firmware-Daten . . . . . . . . . . . . . . . . . . 373

13.2.3 Example. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374

13.3 Datenschutz. . . . . . . . . . . . . . . . . . . . . . . . . . 374

13.3.1 Einführung in die Datenverschlüsselung . . . . . . . . . . . . . . . . . . . . . . 374

13.3.2 Einführung in das Flash-Verschlüsselungsschema. . . . . . . . . . . . . . . . . 376

13.3.3 Flash-Verschlüsselungsschlüsselspeicherung . . . . . . . . . . . . . . . . . . . . . . . 379

13.3.4 Arbeitsmodus der Flash-Verschlüsselung. . . . . . . . . . . . . . . . . . . . 380

13.3.5 Flash-Verschlüsselungsprozess . . . . . . . . . . . . . . . . . . . . . . . . . . 381

13.3.6 Einführung in die NVS-Verschlüsselung. . . . . . . . . . . . . . . . . . . . . . 383

13.3.7 ExampDateien der Flash-Verschlüsselung und der NVS-Verschlüsselung. . . . . . . . . . . 384

13.4 Schutz der Datenlegitimität . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386

13.4.1 Einführung in die digitale Signatur . . . . . . . . . . . . . . . . . . . . . 386

13.4.2 Überview des Secure Boot Scheme. . . . . . . . . . . . . . . . . . . . . 388

13.4.3 Einführung in Software Secure Boot . . . . . . . . . . . . . . . . . . . 388 13.4.4 Einführung in Hardware Secure Boot . . . . . . . . . . . . . . . . . . 390 13.4.5 Bspamples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394 13.5 Praxis: Sicherheitsmerkmale in der Massenproduktion . . . . . . . . . . . . . . . . . . 396 13.5.1 Flash-Verschlüsselung und Secure Boot . . . . . . . . . . . . . . . . . . . . . 396 13.5.2 Aktivieren der Flash-Verschlüsselung und des sicheren Starts mit Batch-Flash-Tools . . 397 13.5.3 Aktivieren der Flash-Verschlüsselung und des sicheren Starts im Smart Light Project . . . 398 13.6 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398

14 Brennen und Testen der Firmware für die Massenproduktion

399

14.1 Firmware-Brennen in der Massenproduktion . . . . . . . . . . . . . . . . . . . . . . 399

14.1.1 Datenpartitionen definieren . . . . . . . . . . . . . . . . . . . . . . . . . . 399

14.1.2 Firmware-Brennen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402

14.2 Massenproduktionstests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403

14.3 Praxis: Massenproduktionsdaten im Smart Light-Projekt . . . . . . . . . . . . . 404

14.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404

15 ESP Insights: Fernüberwachungsplattform

405

15.1 Einführung in ESP Insights . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405

15.2 Erste Schritte mit ESP Insights . . . . . . . . . . . . . . . . . . . . . . . . . 409

15.2.1 Erste Schritte mit ESP Insights im esp-insights-Projekt. . . . . . 409

15.2.2 Ausführen von Example im esp-insights-Projekt. . . . . . . . . . . . . . . 411

15.2.3 Coredump-Informationen melden . . . . . . . . . . . . . . . . . . . . . 411

15.2.4 Anpassen relevanter Protokolle . . . . . . . . . . . . . . . . . . . . . . . . 412

15.2.5 Neustartgrund melden . . . . . . . . . . . . . . . . . . . . . . . . . 413

15.2.6 Benutzerdefinierte Metriken melden . . . . . . . . . . . . . . . . . . . . . . . . . 413

15.3 Praxis: Verwendung von ESP Insights im Smart Light-Projekt. . . . . . . . . . . . . . . 416

15.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417

Einführung
ESP32-C3 ist ein Single-Core-Wi-Fi- und Bluetooth 5 (LE)-Mikrocontroller-SoC, der auf der Open-Source-RISC-V-Architektur basiert. Es sorgt für die richtige Balance zwischen Leistung, E/A-Fähigkeiten und Sicherheit und bietet so die optimale kostengünstige Lösung für angeschlossene Geräte. Um verschiedene Anwendungen der ESP32-C3-Familie zu zeigen, nimmt Sie dieses Buch von Espressif mit auf eine interessante Reise durch AIoT, angefangen von den Grundlagen der IoT-Projektentwicklung und Umgebungseinrichtung bis hin zu praktischen Beispielenamples. In den ersten vier Kapiteln geht es um IoT, ESP RainMaker und ESP-IDF. Kapitel 5 und 6 kurz zum Hardwaredesign und zur Treiberentwicklung. Im weiteren Verlauf erfahren Sie, wie Sie Ihr Projekt über Wi-Fi-Netzwerke und mobile Apps konfigurieren. Schließlich lernen Sie, Ihr Projekt zu optimieren und in die Massenproduktion zu bringen.
Wenn Sie Ingenieur in verwandten Bereichen, Software-Architekt, Lehrer, Student oder jemand sind, der sich für IoT interessiert, ist dieses Buch genau das Richtige für Sie.
Sie können den Code z. B. herunterladenampDie in diesem Buch verwendete Datei stammt von Espressifs Website auf GitHub. Für aktuelle Informationen zur IoT-Entwicklung folgen Sie bitte unserem offiziellen Account.

Vorwort
Eine Welt der Information
Auf der Welle des Internets feierte das Internet der Dinge (IoT) sein großes Debüt und entwickelte sich zu einer neuen Art von Infrastruktur in der digitalen Wirtschaft. Um die Technologie der Öffentlichkeit näher zu bringen, arbeitet Espressif Systems an der Vision, dass Entwickler aus allen Gesellschaftsschichten IoT nutzen können, um einige der drängendsten Probleme unserer Zeit zu lösen. Eine Welt des „Intelligenten Netzwerks aller Dinge“ ist das, was wir von der Zukunft erwarten.
Die Entwicklung unserer eigenen Chips ist ein entscheidender Bestandteil dieser Vision. Es soll ein Marathon werden, der ständige Durchbrüche über technologische Grenzen erfordert. Vom „Game Changer“ ESP8266 bis zur ESP32-Serie, die Wi-Fi- und Bluetoothr (LE)-Konnektivität integriert, gefolgt vom ESP32-S3 mit KI-Beschleunigung: Espressif hört nie auf, Produkte für AIoT-Lösungen zu erforschen und zu entwickeln. Mit unserer Open-Source-Software, wie dem IoT Development Framework ESP-IDF, dem Mesh Development Framework ESP-MDF und der Device Connectivity Platform ESP RainMaker, haben wir ein unabhängiges Framework für die Erstellung von AIoT-Anwendungen geschaffen.
Bis Juli 2022 beliefen sich die kumulierten Auslieferungen der IoT-Chipsätze von Espressif auf über 800 Millionen. Damit ist das Unternehmen führend auf dem Wi-Fi-MCU-Markt und versorgt eine große Anzahl vernetzter Geräte weltweit mit Strom. Das Streben nach Exzellenz macht jedes Espressif-Produkt aufgrund seines hohen Integrationsgrads und seiner Kosteneffizienz zu einem großen Erfolg. Die Veröffentlichung von ESP32-C3 markiert einen bedeutenden Meilenstein der selbst entwickelten Technologie von Espressif. Es handelt sich um einen Single-Core-32-Bit-RISC-V-basierten MCU mit 400 KB SRAM, der mit 160 MHz betrieben werden kann. Es verfügt über integriertes 2.4-GHz-WLAN und Bluetooth 5 (LE) mit Langstreckenunterstützung. Es sorgt für ein ausgewogenes Verhältnis von Leistung, I/O-Fähigkeiten und Sicherheit und bietet somit die optimale kostengünstige Lösung für angeschlossene Geräte. Basierend auf solch einem leistungsstarken ESP32-C3 soll dieses Buch den Lesern helfen, IoT-bezogenes Wissen mit detaillierten Illustrationen und praktischen Beispielen zu verstehenamples.
Warum haben wir dieses Buch geschrieben?
Espressif Systems ist mehr als ein Halbleiterunternehmen. Darüber hinaus handelt es sich um ein IoT-Plattformunternehmen, das stets nach Durchbrüchen und Innovationen im Technologiebereich strebt. Gleichzeitig hat Espressif sein selbst entwickeltes Betriebssystem und Software-Framework als Open-Source-Lösung bereitgestellt und mit der Community geteilt und so ein einzigartiges Ökosystem geschaffen. Ingenieure, Hersteller und Technologiebegeisterte entwickeln aktiv neue Softwareanwendungen auf Basis der Produkte von Espressif, kommunizieren frei und tauschen ihre Erfahrungen aus. Die faszinierenden Ideen der Entwickler können Sie jederzeit auf verschiedenen Plattformen wie YouTube und GitHub sehen. Die Beliebtheit der Espressif-Produkte hat eine wachsende Zahl von Autoren angeregt, die über 100 Bücher auf Basis von Espressif-Chipsätzen in mehr als zehn Sprachen, darunter Englisch, Chinesisch, Deutsch, Französisch und Japanisch, produziert haben.

Es sind die Unterstützung und das Vertrauen der Community-Partner, die die kontinuierliche Innovation von Espressif fördern. „Wir streben danach, unsere Chips, Betriebssysteme, Frameworks, Lösungen, Clouds, Geschäftspraktiken, Tools, Dokumentationen, Schriften, Ideen usw. immer relevanter für die Antworten zu machen, die Menschen auf die dringendsten Probleme des modernen Lebens benötigen. Das ist Espressifs höchstes Ziel und sein moralischer Kompass.“ sagte Herr Teo Swee Ann, Gründer und CEO von Espressif.
Espressif legt Wert auf Lektüre und Ideen. Da die kontinuierliche Weiterentwicklung der IoT-Technologie höhere Anforderungen an Ingenieure stellt, wie können wir mehr Menschen helfen, IoT-Chips, Betriebssysteme, Software-Frameworks, Anwendungsschemata und Cloud-Service-Produkte schnell zu beherrschen? Wie das Sprichwort sagt: Es ist besser, einem Mann das Fischen beizubringen, als ihm Fisch zu geben. In einer Brainstorming-Sitzung kam uns die Idee, dass wir ein Buch schreiben könnten, um das Schlüsselwissen der IoT-Entwicklung systematisch zu ordnen. Wir verstanden uns gut, stellten schnell eine Gruppe leitender Ingenieure zusammen und bündelten die Erfahrung des technischen Teams in den Bereichen Embedded-Programmierung, IoT-Hardware und Softwareentwicklung, die alle zur Veröffentlichung dieses Buches beitrugen. Beim Schreiben haben wir unser Bestes gegeben, um objektiv und fair zu sein, uns aus dem Kokon zu befreien und prägnante Ausdrücke zu verwenden, um die Komplexität und den Charme des Internets der Dinge darzustellen. Wir haben die häufigsten Fragen sorgfältig zusammengefasst und auf das Feedback und die Vorschläge der Community verwiesen, um die im Entwicklungsprozess aufgetretenen Fragen klar zu beantworten und praktische IoT-Entwicklungsrichtlinien für relevante Techniker und Entscheidungsträger bereitzustellen.
Buchstruktur
Dieses Buch nimmt eine ingenieurzentrierte Perspektive ein und erläutert Schritt für Schritt das notwendige Wissen für die IoT-Projektentwicklung. Es besteht aus vier Teilen:
· Vorbereitung (Kapitel 1): In diesem Teil werden die Architektur des IoT, das typische IoT-Projekt-Framework, die ESP RainMakerr-Cloud-Plattform und die Entwicklungsumgebung ESP-IDF vorgestellt, um eine solide Grundlage für die IoT-Projektentwicklung zu schaffen.
· Hardware- und Treiberentwicklung (Kapitel 5): Basierend auf dem ESP6-C32-Chipsatz geht dieser Teil auf die minimale Hardwaresystem- und Treiberentwicklung ein und implementiert die Steuerung von Dimmung, Farbkorrektur und drahtloser Kommunikation.
· Drahtlose Kommunikation und Steuerung (Kapitel 7): In diesem Teil wird das intelligente Wi-Fi-Konfigurationsschema basierend auf dem ESP11-C32-Chip, lokalen und Cloud-Steuerungsprotokollen sowie der lokalen und Fernsteuerung von Geräten erläutert. Es bietet außerdem Schemata für die Entwicklung von Smartphone-Apps, Firmware-Upgrades und Versionsverwaltung.
· Optimierung und Massenproduktion (Kapitel 12–15): Dieser Teil ist für fortgeschrittene IoT-Anwendungen gedacht und konzentriert sich auf die Optimierung von Produkten im Bereich Energiemanagement, Optimierung bei geringem Stromverbrauch und erhöhte Sicherheit. Außerdem werden das Brennen und Testen von Firmware in der Massenproduktion sowie die Diagnose des Betriebsstatus und der Protokolle der Geräte-Firmware über die Fernüberwachungsplattform ESP Insights vorgestellt.

Über den Quellcode
Leser können den Ex ausführenample Programme in diesem Buch, entweder durch manuelle Eingabe des Codes oder durch Verwendung des Quellcodes, der dem Buch beiliegt. Wir legen Wert auf die Verbindung von Theorie und Praxis und haben daher in fast jedem Kapitel einen Praxisteil basierend auf dem Smart Light-Projekt eingerichtet. Alle Codes sind Open-Source. Leser sind herzlich eingeladen, den Quellcode herunterzuladen und ihn in den Abschnitten zu diesem Buch auf GitHub und unserem offiziellen Forum esp32.com zu diskutieren. Der Open-Source-Code dieses Buches unterliegt den Bedingungen der Apache-Lizenz 2.0.
Anmerkung des Autors
Dieses Buch wurde offiziell von Espressif Systems produziert und von den leitenden Ingenieuren des Unternehmens geschrieben. Es eignet sich für Manager und F&E-Personal in IoT-bezogenen Branchen, Lehrer und Studenten verwandter Studiengänge sowie Enthusiasten im Bereich Internet der Dinge. Wir hoffen, dass dieses Buch als Arbeitshandbuch, Nachschlagewerk und Nachtbuch dienen kann, um wie ein guter Lehrer und Freund zu sein.
Bei der Zusammenstellung dieses Buches haben wir auf einige relevante Forschungsergebnisse von Experten, Wissenschaftlern und Technikern im In- und Ausland zurückgegriffen und unser Bestes getan, sie gemäß akademischen Standards zu zitieren. Es lässt sich jedoch nicht vermeiden, dass es zu Auslassungen kommt, weshalb wir an dieser Stelle allen relevanten Autoren unseren tiefen Respekt und Dank aussprechen möchten. Darüber hinaus haben wir Informationen aus dem Internet zitiert, daher möchten wir uns bei den ursprünglichen Autoren und Herausgebern bedanken und entschuldigen uns dafür, dass wir nicht für jede Information die Quelle angeben können.
Um ein qualitativ hochwertiges Buch zu produzieren, haben wir interne Diskussionsrunden organisiert und aus den Vorschlägen und dem Feedback von Probelesern und Verlagsredakteuren gelernt. An dieser Stelle möchten wir uns noch einmal bei Ihnen für Ihre Hilfe bedanken, die alle zu dieser erfolgreichen Arbeit beigetragen haben.
Zu guter Letzt möchte ich allen bei Espressif danken, die so hart an der Entstehung und Verbreitung unserer Produkte gearbeitet haben.
Die Entwicklung von IoT-Projekten erfordert ein breites Spektrum an Wissen. Aufgrund der Länge des Buches sowie des Niveaus und der Erfahrung des Autors sind Auslassungen unvermeidlich. Daher bitten wir Experten und Leser, unsere Fehler zu kritisieren und zu korrigieren. Wenn Sie Vorschläge für dieses Buch haben, kontaktieren Sie uns bitte unter book@espressif.com. Wir freuen uns auf Ihr Feedback.

Wie verwende ich dieses Buch?
Der Code der Projekte in diesem Buch ist Open Source. Sie können es aus unserem GitHub-Repository herunterladen und Ihre Gedanken und Fragen in unserem offiziellen Forum teilen. GitHub: https://github.com/espressif/book-esp32c3-iot-projects Forum: https://www.esp32.com/bookc3 Im gesamten Buch werden Teile hervorgehoben, wie unten gezeigt.
Quellcode In diesem Buch legen wir Wert auf die Kombination von Theorie und Praxis und haben daher in fast jedem Kapitel einen Praxisabschnitt über das Smart Light-Projekt eingerichtet. Die entsprechenden Schritte und die Quellseite werden zwischen zwei Zeilen markiert, die mit beginnen tag Quellcode.
HINWEIS/TIPPS Hier finden Sie möglicherweise einige wichtige Informationen und Hinweise zum erfolgreichen Debuggen Ihres Programms. Sie werden zwischen zwei dicken Linien markiert, beginnend mit dem tag HINWEIS oder TIPPS.
Die meisten Befehle in diesem Buch werden unter Linux ausgeführt und durch das Zeichen „$“ ausgelöst. Wenn für die Ausführung des Befehls Superuser-Rechte erforderlich sind, wird die Eingabeaufforderung durch „#“ ersetzt. Die Eingabeaufforderung auf Mac-Systemen lautet „%“, wie in Abschnitt 4.2.3 „Installieren von ESP-IDF auf Mac“ verwendet.
Der Haupttext in diesem Buch wird in Charter gedruckt, während der Code exampDateien, Komponenten, Funktionen, Variablen, Code file Namen, Codeverzeichnisse und Zeichenfolgen befinden sich in Courier New.
Befehle oder Texte, die vom Benutzer eingegeben werden müssen, und Befehle, die durch Drücken der „Enter“-Taste eingegeben werden können, werden in Courier New fett gedruckt. Protokolle und Codeblöcke werden in hellblauen Kästchen angezeigt.
Exampauf:
Zweitens verwenden Sie esp-idf/components/nvs flash/nvs partition generator/nvs partition gen.py, um die Binärdatei der NVS-Partition zu generieren file auf dem Entwicklungshost mit dem folgenden Befehl:
$ python $IDF PATH/components/nvs flash/nvs partition generator/nvs partition gen.py –input mass prod.csv –output mass prod.bin –size NVS-PARTITIONSGRÖSSE

Kapitel 1

Einführung

IoT

Am Ende des 20. Jahrhunderts, mit dem Aufkommen von Computernetzwerken und Kommunikationstechnologien, integrierte sich das Internet rasch in das Leben der Menschen. Während die Internet-Technologie immer weiter reift, wurde die Idee des Internets der Dinge (IoT) geboren. Wörtlich bedeutet IoT ein Internet, in dem Dinge miteinander verbunden sind. Während das ursprüngliche Internet die Grenzen von Raum und Zeit sprengt und die Distanz zwischen „Person und Person“ verringert, macht das IoT „Dinge“ zu einem wichtigen Teilnehmer und bringt „Menschen“ und „Dinge“ näher zusammen. In absehbarer Zeit wird das IoT zur treibenden Kraft der Informationsindustrie werden.
Was ist also das Internet der Dinge?
Es ist schwierig, das Internet der Dinge genau zu definieren, da sich seine Bedeutung und sein Umfang ständig weiterentwickeln. 1995 brachte Bill Gates in seinem Buch „The Road Ahead“ erstmals die Idee des IoT zur Sprache. Vereinfacht ausgedrückt ermöglicht IoT den Objekten den Austausch von Informationen untereinander über das Internet. Sein oberstes Ziel ist die Schaffung eines „Internet of Everything“. Dies ist eine frühe Interpretation des IoT sowie eine Fantasie über zukünftige Technologie. Dreißig Jahre später, mit der rasanten Entwicklung von Wirtschaft und Technologie, wird die Fantasie Wirklichkeit. Von intelligenten Geräten, intelligenten Häusern, intelligenten Städten, dem Internet der Fahrzeuge und tragbaren Geräten bis hin zum „Metaversum“, das durch IoT-Technologien unterstützt wird, entstehen ständig neue Konzepte. In diesem Kapitel beginnen wir mit einer Erläuterung der Architektur des Internets der Dinge und stellen dann die häufigste IoT-Anwendung, das Smart Home, vor, um Ihnen ein klares Verständnis des IoT zu vermitteln.
1.1 Architektur des IoT
Das Internet der Dinge umfasst mehrere Technologien, die in verschiedenen Branchen unterschiedliche Anwendungsanforderungen und -formen haben. Um die Struktur, die Schlüsseltechnologien und Anwendungsmerkmale des IoT zu klären, ist es notwendig, eine einheitliche Architektur und ein einheitliches technisches System zu etablieren. In diesem Buch wird die Architektur des IoT einfach in vier Schichten unterteilt: Wahrnehmungs- und Kontrollschicht, Netzwerkschicht, Plattformschicht und Anwendungsschicht.
Wahrnehmungs- und Kontrollschicht Als grundlegendstes Element der IoT-Architektur ist die Wahrnehmungs- und Kontrollschicht der Kern für die umfassende Wahrnehmung des IoT. Seine Hauptfunktion besteht darin, Informationen zu sammeln, zu identifizieren und zu kontrollieren. Es besteht aus einer Vielzahl von Geräten mit der Fähigkeit zur Wahrnehmung,
3

Identifizierung, Steuerung und Ausführung und ist für das Abrufen und Analysieren von Daten wie Materialeigenschaften, Verhaltenstrends und Gerätestatus verantwortlich. Auf diese Weise erkennt das IoT die reale physische Welt. Darüber hinaus ist die Ebene auch in der Lage, den Status des Geräts zu steuern.
Die häufigsten Geräte dieser Schicht sind verschiedene Sensoren, die eine wichtige Rolle bei der Informationserfassung und -identifizierung spielen. Sensoren sind wie menschliche Sinnesorgane, z. B. lichtempfindliche Sensoren für das Sehen, akustische Sensoren für das Hören, Gassensoren für den Geruch und druck- und temperaturempfindliche Sensoren für die Berührung. Mit all diesen „Sinnesorganen“ werden Objekte „lebendig“ und in der Lage, die physische Welt intelligent wahrzunehmen, zu erkennen und zu manipulieren.
Netzwerkschicht Die Hauptfunktion der Netzwerkschicht besteht darin, Informationen, einschließlich der von der Wahrnehmungs- und Kontrollschicht erhaltenen Daten, an ein bestimmtes Ziel sowie von der Anwendungsschicht ausgegebene Befehle zurück an die Wahrnehmungs- und Kontrollschicht zu übertragen. Es dient als wichtige Kommunikationsbrücke, die verschiedene Schichten eines IoT-Systems verbindet. Um ein Grundmodell des Internets der Dinge zu erstellen, sind zwei Schritte erforderlich, um Objekte in ein Netzwerk zu integrieren: Zugang zum Internet und Übertragung über das Internet.
Der Zugang zum Internet ermöglicht die Verbindung zwischen Mensch und Mensch, schließt die Dinge jedoch nicht in die große Familie ein. Vor dem Aufkommen des IoT waren die meisten Dinge nicht „netzwerkfähig“. Dank der kontinuierlichen Weiterentwicklung der Technologie gelingt es dem IoT, Dinge mit dem Internet zu verbinden und so eine Verbindung zwischen „Menschen und Dingen“ und „Dingen und Dingen“ herzustellen. Es gibt zwei gängige Möglichkeiten, eine Internetverbindung zu implementieren: kabelgebundener Netzwerkzugriff und drahtloser Netzwerkzugriff.
Zu den kabelgebundenen Netzwerkzugriffsmethoden gehören Ethernet, serielle Kommunikation (z. B. RS-232, RS-485) und USB, während der drahtlose Netzwerkzugriff von der drahtlosen Kommunikation abhängt, die weiter in drahtlose Kommunikation über kurze Entfernungen und drahtlose Kommunikation über große Entfernungen unterteilt werden kann.
Die drahtlose Kommunikation über kurze Entfernungen umfasst ZigBee, Bluetoothr, Wi-Fi, Near-Field Communication (NFC) und Radio Frequency Identification (RFID). Die drahtlose Kommunikation über große Entfernungen umfasst Enhanced Machine Type Communication (eMTC), LoRa, Narrow Band Internet of Things (NB-IoT), 2G, 3G, 4G, 5G usw.
Übertragung über das Internet Verschiedene Zugangswege zum Internet führen zu entsprechenden physikalischen Übertragungsstrecken der Daten. Als nächstes muss entschieden werden, welches Kommunikationsprotokoll zur Übertragung der Daten verwendet werden soll. Im Vergleich zu Internet-Terminals verfügen die meisten IoT-Terminals derzeit über weniger
4 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

Aufgrund der verfügbaren Ressourcen wie Verarbeitungsleistung, Speicherkapazität, Netzwerkrate usw. ist es notwendig, ein Kommunikationsprotokoll zu wählen, das in IoT-Anwendungen weniger Ressourcen beansprucht. Es gibt zwei Kommunikationsprotokolle, die heute weit verbreitet sind: Message Queuing Telemetry Transport (MQTT) und Constrained Application Protocol (CoAP).
Plattformschicht Die Plattformschicht bezieht sich hauptsächlich auf IoT-Cloud-Plattformen. Wenn alle IoT-Terminals vernetzt sind, müssen ihre Daten auf einer IoT-Cloud-Plattform aggregiert, berechnet und gespeichert werden. Die Plattformschicht unterstützt hauptsächlich IoT-Anwendungen bei der Erleichterung des Zugriffs und der Verwaltung großer Geräte. Es verbindet IoT-Terminals mit der Cloud-Plattform, sammelt Terminaldaten und gibt Befehle an Terminals aus, um eine Fernsteuerung zu implementieren. Als Zwischendienst zur Zuweisung von Geräten zu Industrieanwendungen spielt die Plattformschicht eine verbindende Rolle in der gesamten IoT-Architektur und trägt eine abstrakte Geschäftslogik und ein standardisiertes Kerndatenmodell, das nicht nur einen schnellen Zugriff auf Geräte realisieren, sondern auch leistungsstarke modulare Funktionen bereitstellen kann um verschiedene Anforderungen in industriellen Anwendungsszenarien zu erfüllen. Die Plattformschicht umfasst hauptsächlich Funktionsmodule wie Gerätezugriff, Geräteverwaltung, Sicherheitsverwaltung, Nachrichtenkommunikation, Überwachung von Betrieb und Wartung sowie Datenanwendungen.
· Gerätezugriff, Realisierung der Verbindung und Kommunikation zwischen Terminals und IoT-Cloud-Plattformen.
· Geräteverwaltung, einschließlich Funktionen wie Geräteerstellung, Gerätewartung, Datenkonvertierung, Datensynchronisierung und Geräteverteilung.
· Sicherheitsmanagement, Gewährleistung der Sicherheit der IoT-Datenübertragung unter den Gesichtspunkten der Sicherheitsauthentifizierung und Kommunikationssicherheit.
· Nachrichtenkommunikation, einschließlich drei Übertragungsrichtungen, d. h. das Terminal sendet Daten an die IoT-Cloud-Plattform, die IoT-Cloud-Plattform sendet Daten an die Serverseite oder andere IoT-Cloud-Plattformen und die Serverseite steuert IoT-Geräte fern.
· Überwachung von Betrieb und Wartung, einschließlich Überwachung und Diagnose, Firmware-Upgrade, Online-Debugging, Protokolldienste usw.
· Datenanwendungen, die die Speicherung, Analyse und Anwendung von Daten umfassen.
Anwendungsschicht Die Anwendungsschicht nutzt die Daten der Plattformschicht zur Verwaltung der Anwendung, filtert und verarbeitet sie mit Tools wie Datenbanken und Analysesoftware. Die resultierenden Daten können für reale IoT-Anwendungen wie intelligentes Gesundheitswesen, intelligente Landwirtschaft, intelligente Häuser und intelligente Städte verwendet werden.
Natürlich kann die Architektur des IoT in mehrere Schichten unterteilt werden, aber egal aus wie vielen Schichten sie besteht, das zugrunde liegende Prinzip bleibt im Wesentlichen dasselbe. Lernen
Kapitel 1. Einführung in IoT 5

über die Architektur des IoT hilft dabei, unser Verständnis der IoT-Technologien zu vertiefen und voll funktionsfähige IoT-Projekte zu erstellen.
1.2 IoT-Anwendung in Smart Homes
IoT ist in alle Lebensbereiche vorgedrungen und die für uns am engsten verwandte IoT-Anwendung ist das Smart Home. Viele traditionelle Geräte sind mittlerweile mit einem oder mehreren IoT-Geräten ausgestattet und viele neu gebaute Häuser sind von Anfang an mit IoT-Technologien ausgestattet. Abbildung 1.1 zeigt einige gängige Smart-Home-Geräte.
Abbildung 1.1. Gängige Smart-Home-Geräte Die Entwicklung von Smart Home lässt sich einfach in Smart-Produkte unterteilentage, Szenenverbindung stage und intelligente stage, wie in Abbildung 1.2 dargestellt.
Abbildung 1.2. Entwicklung stage von Smart Home 6 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

Die erstentagBei uns geht es um smarte Produkte. Anders als in herkömmlichen Häusern empfangen IoT-Geräte in Smart Homes Signale mit Sensoren und sind über drahtlose Kommunikationstechnologien wie Wi-Fi, Bluetooth LE und ZigBee vernetzt. Benutzer können intelligente Produkte auf verschiedene Arten steuern, beispielsweise über Smartphone-Apps, Sprachassistenten, intelligente Lautsprechersteuerung usw. Die zweite stagDer Schwerpunkt liegt auf der Szenenverknüpfung. In diesem stagDaher denken Entwickler nicht länger darüber nach, ein einzelnes intelligentes Produkt zu steuern, sondern zwei oder mehr intelligente Produkte miteinander zu verbinden, bis zu einem gewissen Grad zu automatisieren und schließlich einen benutzerdefinierten Szenenmodus zu bilden. Zum BeispielampWenn der Benutzer beispielsweise eine Szenenmodustaste drückt, werden die Lichter, Vorhänge und Klimaanlagen automatisch an die Voreinstellungen angepasst. Voraussetzung ist natürlich, dass die Verknüpfungslogik inklusive Triggerbedingungen und Ausführungsaktionen fertig eingerichtet ist. Stellen Sie sich vor, dass der Heizmodus der Klimaanlage ausgelöst wird, wenn die Innentemperatur unter 10 °C fällt; dass um 7 Uhr morgens Musik abgespielt wird, um den Benutzer zu wecken, intelligente Vorhänge geöffnet werden und der Reiskocher oder Brottoaster über eine intelligente Steckdose startet; Sobald der Benutzer aufsteht und mit der Wäsche fertig ist, wird ihm bereits das Frühstück serviert, so dass es zu keiner Verzögerung auf dem Weg zur Arbeit kommt. Wie bequem ist unser Leben geworden! Die dritte stage geht an den Geheimdiensttage. Je mehr Smart-Home-Geräte genutzt werden, desto mehr Daten werden generiert. Mit Hilfe von Cloud Computing, Big Data und künstlicher Intelligenz ist es so, als ob ein „intelligenteres Gehirn“ in Smart Homes eingebaut wurde, das keine häufigen Befehle des Benutzers mehr erfordert. Sie sammeln Daten aus früheren Interaktionen und lernen die Verhaltensmuster und Vorlieben des Benutzers kennen, um Aktivitäten zu automatisieren, einschließlich der Bereitstellung von Empfehlungen für die Entscheidungsfindung. Derzeit sind die meisten Smart Homes auf dem Stand der Vernetzungtage. Da die Durchdringungsrate und Intelligenz intelligenter Produkte zunimmt, werden Barrieren zwischen Kommunikationsprotokollen beseitigt. Künftig werden Smart Homes bestimmt wirklich „smart“, genau wie das KI-System Jarvis in Iron Man, das dem Benutzer nicht nur dabei helfen kann, verschiedene Geräte zu steuern und alltägliche Angelegenheiten zu erledigen, sondern auch über eine enorme Rechenleistung und Denkfähigkeit verfügt. In den intelligenten stage, die Menschen werden sowohl quantitativ als auch qualitativ bessere Dienstleistungen erhalten.
Kapitel 1. Einführung in IoT 7

8 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

Kapitel Einführung und Praxis von 2 IoT-Projekten
In Kapitel 1 haben wir die Architektur des IoT und die Rollen und Wechselbeziehungen der Wahrnehmungs- und Kontrollschicht, der Netzwerkschicht, der Plattformschicht und der Anwendungsschicht sowie die Entwicklung von Smart Home vorgestellt. Allerdings reicht es, genau wie beim Malenlernen, bei weitem nicht aus, das theoretische Wissen zu kennen. Wir müssen uns bei der Umsetzung von IoT-Projekten „die Hände schmutzig machen“, um die Technologie wirklich zu beherrschen. Darüber hinaus, wenn ein Projekt in die Massenproduktion übergehttagh. es ist notwendig, weitere Faktoren wie Netzwerkverbindung, Konfiguration, Interaktion mit der IoT-Cloud-Plattform, Firmware-Management und -Updates, Massenproduktionsmanagement und Sicherheitskonfiguration zu berücksichtigen. Worauf müssen wir also bei der Entwicklung eines kompletten IoT-Projekts achten? In Kapitel 1 haben wir erwähnt, dass Smart Home eines der häufigsten IoT-Anwendungsszenarien ist und dass Smart Lights eines der grundlegendsten und praktischsten Geräte sind, die in Häusern, Hotels, Fitnessstudios, Krankenhäusern usw. verwendet werden können. Daher in In diesem Buch nehmen wir den Aufbau eines Smart-Light-Projekts als Ausgangspunkt, erläutern seine Komponenten und Funktionen und geben Anleitung zur Projektentwicklung. Wir hoffen, dass Sie aus diesem Fall Schlussfolgerungen ziehen können, um weitere IoT-Anwendungen zu erstellen.
2.1 Einführung in typische IoT-Projekte
Im Hinblick auf die Entwicklung lassen sich grundlegende Funktionsmodule von IoT-Projekten in Software- und Hardwareentwicklung von IoT-Geräten, Client-Anwendungsentwicklung und IoT-Cloud-Plattformentwicklung einteilen. Es ist wichtig, die grundlegenden Funktionsmodule zu klären, die in diesem Abschnitt weiter beschrieben werden.
2.1.1 Basismodule für gängige IoT-Geräte
Die Software- und Hardwareentwicklung von IoT-Geräten umfasst die folgenden Grundmodule: Datenerfassung
Als unterste Schicht der IoT-Architektur verbinden die IoT-Geräte der Wahrnehmungs- und Kontrollschicht Sensoren und Geräte über ihre Chips und Peripheriegeräte, um Datenerfassung und Betriebssteuerung zu erreichen.
9

Kontobindung und Erstkonfiguration Bei den meisten IoT-Geräten werden die Kontobindung und die Erstkonfiguration in einem einzigen Vorgang abgeschlossen, zample, Verbinden von Geräten mit Benutzern durch Konfigurieren des Wi-Fi-Netzwerks.
Interaktion mit IoT-Cloud-Plattformen Um IoT-Geräte zu überwachen und zu steuern, ist es auch notwendig, diese mit IoT-Cloud-Plattformen zu verbinden, um durch Interaktion untereinander Befehle zu erteilen und Status zu melden.
Gerätesteuerung Bei Verbindung mit IoT-Cloud-Plattformen können Geräte mit der Cloud kommunizieren und registriert, gebunden oder gesteuert werden. Benutzer können den Produktstatus abfragen und andere Vorgänge über die Smartphone-App über IoT-Cloud-Plattformen oder lokale Kommunikationsprotokolle ausführen.
Firmware-Upgrade IoT-Geräte können auch ein Firmware-Upgrade basierend auf den Anforderungen des Herstellers durchführen. Durch den Empfang von von der Cloud gesendeten Befehlen werden Firmware-Upgrades und Versionsverwaltung realisiert. Mit dieser Firmware-Upgrade-Funktion können Sie die Funktionen von IoT-Geräten kontinuierlich verbessern, Fehler beheben und das Benutzererlebnis verbessern.
2.1.2 Grundmodule von Client-Anwendungen
Client-Anwendungen (z. B. Smartphone-Apps) umfassen hauptsächlich die folgenden Grundmodule:
Kontosystem und Autorisierung Es unterstützt die Konto- und Geräteautorisierung.
Gerätesteuerung Smartphone-Apps sind in der Regel mit Steuerungsfunktionen ausgestattet. Benutzer können problemlos eine Verbindung zu IoT-Geräten herstellen und diese jederzeit und überall über Smartphone-Apps verwalten. In einem realen Smart Home werden Geräte meist über Smartphone-Apps gesteuert, was nicht nur eine intelligente Geräteverwaltung ermöglicht, sondern auch Personalkosten spart. Daher ist die Gerätesteuerung ein Muss für Client-Anwendungen, wie z. B. die Steuerung von Gerätefunktionsattributen, Szenensteuerung, Zeitplanung, Fernbedienung, Geräteverknüpfung usw. Smart-Home-Benutzer können Szenen auch an ihre persönlichen Bedürfnisse anpassen und Beleuchtung, Haushaltsgeräte und den Eingang steuern usw., um das Leben zu Hause komfortabler und bequemer zu gestalten. Sie können die Klimaanlage steuern, sie aus der Ferne ausschalten, das Flurlicht automatisch einschalten, sobald die Tür entriegelt wird, oder mit einer einzigen Taste in den „Theater“-Modus wechseln.
Benachrichtigungs-Client-Anwendungen aktualisieren den Echtzeitstatus von IoT-Geräten und senden Warnungen, wenn Geräte abnormal sind.
10 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

After-Sales-Kundendienst Smartphone-Apps können After-Sales-Services für Produkte bereitstellen, um Probleme im Zusammenhang mit Ausfällen von IoT-Geräten und technischen Abläufen zeitnah zu lösen.
Empfohlene Funktionen Um den Bedürfnissen verschiedener Benutzer gerecht zu werden, können weitere Funktionen hinzugefügt werden, wie z. B. Shake, NFC, GPS usw. GPS kann dabei helfen, die Genauigkeit von Szenenoperationen je nach Standort und Entfernung festzulegen, während die Shake-Funktion es Benutzern ermöglicht, die Genauigkeit einzustellen Befehle, die für ein bestimmtes Gerät oder eine bestimmte Szene ausgeführt werden sollen, durch Schütteln.
2.1.3 Einführung in gängige IoT-Cloud-Plattformen
Die IoT-Cloud-Plattform ist eine All-in-One-Plattform, die Funktionen wie Geräteverwaltung, Datensicherheitskommunikation und Benachrichtigungsverwaltung integriert. Je nach Zielgruppe und Erreichbarkeit können IoT-Cloud-Plattformen in öffentliche IoT-Cloud-Plattformen (im Folgenden „Public Cloud“ genannt) und private IoT-Cloud-Plattformen (im Folgenden „Private Cloud“ genannt) unterteilt werden.
Bei einer öffentlichen Cloud handelt es sich in der Regel um gemeinsam genutzte IoT-Cloud-Plattformen für Unternehmen oder Einzelpersonen, die von Plattformanbietern betrieben und gewartet und über das Internet gemeinsam genutzt werden. Es kann kostenlos oder kostengünstig sein und bietet Dienste im gesamten offenen öffentlichen Netzwerk, wie Alibaba Cloud, Tencent Cloud, Baidu Cloud, AWS IoT, Google IoT usw. Als unterstützende Plattform kann die öffentliche Cloud vorgelagerte Dienstanbieter integrieren und nachgelagerte Endverbraucher, um eine neue Wertschöpfungskette und ein neues Ökosystem zu schaffen.
Die Private Cloud ist ausschließlich für den Einsatz in Unternehmen konzipiert und garantiert so die beste Kontrolle über Daten, Sicherheit und Servicequalität. Seine Dienste und Infrastruktur werden von Unternehmen separat verwaltet, und die unterstützende Hardware und Software ist ebenfalls bestimmten Benutzern gewidmet. Unternehmen können Cloud-Dienste an die Anforderungen ihres Unternehmens anpassen. Derzeit verfügen einige Smart-Home-Hersteller bereits über private IoT-Cloud-Plattformen und haben darauf basierend Smart-Home-Anwendungen entwickelt.
Public Cloud und Private Cloud haben ihre eigenen Vorteiletages, was später erklärt wird.
Um Kommunikationskonnektivität zu erreichen, ist es notwendig, mindestens die eingebettete Entwicklung auf der Geräteseite abzuschließen, zusammen mit Business-Servern, IoT-Cloud-Plattformen und Smartphone-Apps. Bei solch einem riesigen Projekt stellt die öffentliche Cloud normalerweise Softwareentwicklungskits für geräteseitige und Smartphone-Apps bereit, um den Prozess zu beschleunigen. Sowohl die öffentliche als auch die private Cloud bieten Dienste wie Gerätezugriff, Geräteverwaltung, Geräteschatten sowie Betrieb und Wartung.
Gerätezugriff IoT-Cloud-Plattformen müssen nicht nur Schnittstellen für den Gerätezugriff über Protokolle bereitstellen
Kapitel 2. Einführung und Praxis von IoT-Projekten 11

wie MQTT, CoAP, HTTPS und WebSocket, sondern auch die Funktion der Gerätesicherheitsauthentifizierung, um gefälschte und illegale Geräte zu blockieren und so das Risiko einer Kompromittierung wirksam zu reduzieren. Eine solche Authentifizierung unterstützt in der Regel unterschiedliche Mechanismen. Bei der Massenproduktion von Geräten ist es daher erforderlich, das Gerätezertifikat entsprechend dem gewählten Authentifizierungsmechanismus vorab zuzuweisen und in die Geräte einzubrennen.
Geräteverwaltung Die von IoT-Cloud-Plattformen bereitgestellte Geräteverwaltungsfunktion kann Herstellern nicht nur dabei helfen, den Aktivierungsstatus und Online-Status ihrer Geräte in Echtzeit zu überwachen, sondern ermöglicht auch Optionen wie das Hinzufügen/Entfernen von Geräten, Abrufen, Hinzufügen/Löschen von Gruppen und Firmware-Upgrade und Versionsverwaltung.
Geräteschatten-IoT-Cloud-Plattformen können für jedes Gerät eine dauerhafte virtuelle Version (Geräteschatten) erstellen, und der Status des Geräteschattens kann synchronisiert und von Smartphone-Apps oder anderen Geräten über Internet-Übertragungsprotokolle abgerufen werden. Device Shadow speichert den zuletzt gemeldeten Status und den erwarteten Status jedes Geräts, und selbst wenn das Gerät offline ist, kann es den Status durch Aufrufen von APIs abrufen. Device Shadow bietet ständig verfügbare APIs, was die Erstellung von Smartphone-Apps erleichtert, die mit Geräten interagieren.
Betrieb und Wartung Die O&M-Funktion umfasst drei Aspekte: · Darstellung statistischer Informationen über IoT-Geräte und Benachrichtigungen. · Die Protokollverwaltung ermöglicht den Informationsabruf über das Geräteverhalten, den Nachrichtenfluss nach oben/unten und den Nachrichteninhalt. · Das Geräte-Debugging unterstützt die Befehlsübermittlung, Konfigurationsaktualisierung und die Überprüfung der Interaktion zwischen IoT-Cloud-Plattformen und Gerätenachrichten.
2.2 Praxis: Smart Light-Projekt
Nach der theoretischen Einführung in jedem Kapitel finden Sie einen Übungsabschnitt zum Smart Light-Projekt, der Ihnen dabei hilft, praktische Erfahrungen zu sammeln. Das Projekt basiert auf dem ESP32-C3-Chip von Espressif und der IoT-Cloud-Plattform ESP RainMaker und umfasst drahtlose Modulhardware in Smart-Light-Produkten, eingebettete Software für Smart-Geräte auf Basis von ESP32C3, Smartphone-Apps und ESP RainMaker-Interaktion.
Quellcode Für ein besseres Lern- und Entwicklungserlebnis wurde das Projekt in diesem Buch als Open Source bereitgestellt. Sie können den Quellcode aus unserem GitHub-Repository unter https://github herunterladen. com/espressif/book-esp32c3-iot-projects.
12 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

2.2.1 Projektstruktur
Das Smart Light-Projekt besteht aus drei Teilen: i. Intelligente Lichtgeräte basierend auf ESP32-C3, verantwortlich für die Interaktion mit IoT-Cloud-Plattformen und die Steuerung des Schalters, der Helligkeit und der Farbtemperatur der LED lamp Perlen. ii. Smartphone-Apps (einschließlich Tablet-Apps auf Android und iOS), verantwortlich für die Netzwerkkonfiguration von Smart-Light-Produkten sowie für die Abfrage und Steuerung ihres Status.
iii. Eine IoT-Cloud-Plattform basierend auf ESP RainMaker. Zur Vereinfachung betrachten wir in diesem Buch die IoT-Cloud-Plattform und den Business-Server als Ganzes. Einzelheiten zu ESP RainMaker finden Sie in Kapitel 3.
Die Entsprechung zwischen der Smart Light-Projektstruktur und der IoT-Architektur ist in Abbildung 2.1 dargestellt.
Abbildung 2.1. Struktur des Smart-Light-Projekts
2.2.2 Projektfunktionen
Die einzelnen Teile sind je nach Struktur unterteilt und haben folgende Funktionen. Intelligente Lichtgeräte
· Netzwerkkonfiguration und -verbindung. · LED-PWM-Steuerung, z. B. Schalter, Helligkeit, Farbtemperatur usw. · Automatisierung oder Szenensteuerung, z. B. Zeitschaltuhr. · Verschlüsselung und sicheres Booten des Flash. · Firmware-Upgrade und Versionsverwaltung.
Kapitel 2. Einführung und Praxis von IoT-Projekten 13

Smartphone-Apps · Netzwerkkonfiguration und Gerätebindung. · Intelligente Steuerung von Lichtprodukten, z. B. Schalter, Helligkeit, Farbtemperatur usw. · Automatisierung oder Szeneneinstellungen, z. B. Zeitschaltuhr. · Lokale/Fernsteuerung. · Benutzerregistrierung, Login usw.
ESP RainMaker IoT-Cloud-Plattform · Ermöglicht den Zugriff auf IoT-Geräte. · Bereitstellung von APIs für den Gerätebetrieb, die für Smartphone-Apps zugänglich sind. · Firmware-Upgrade und Versionsverwaltung.
2.2.3 Hardwarevorbereitung
Wenn Sie daran interessiert sind, das Projekt in die Tat umzusetzen, benötigen Sie außerdem folgende Hardware: Smart Lights, Smartphones, WLAN-Router und einen Computer, der die Installationsanforderungen der Entwicklungsumgebung erfüllt. Intelligente Lichter
Smart Lights sind eine neue Art von Glühbirnen, deren Form der einer herkömmlichen Glühlampe entspricht. Eine intelligente Leuchte besteht aus einem kondensatorabwärtsgeregelten Netzteil, einem Funkmodul (mit integriertem ESP32-C3), einem LED-Controller und einer RGB-LED-Matrix. Bei Anschluss an die Stromversorgung beträgt die 15-V-GleichstromspannungtagDer Ausgang nach Kondensatorabsenkung, Diodengleichrichtung und Regelung versorgt den LED-Controller und die LED-Matrix mit Energie. Der LED-Controller kann in bestimmten Intervallen automatisch hohe und niedrige Pegel senden und dabei die RGB-LED-Matrix zwischen geschlossen (Licht an) und offen (Licht aus) umschalten, sodass sie Cyan, Gelb, Grün, Lila, Blau, Rot usw. ausstrahlen kann weißes Licht. Das Funkmodul ist für die Verbindung zum WLAN-Router, den Empfang und die Meldung des Status intelligenter Leuchten sowie das Senden von Befehlen zur Steuerung der LED verantwortlich.
Abbildung 2.2. Ein simuliertes intelligentes Licht
In der frühen Entwicklung stage, Sie können ein intelligentes Licht simulieren, indem Sie die ESP32-C3DevKitM-1-Karte verwenden, die mit RGB-LED l verbunden istamp Perlen (siehe Abbildung 2.2). Aber du solltest
14 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

Beachten Sie, dass dies nicht die einzige Möglichkeit ist, eine intelligente Leuchte zusammenzubauen. Das Hardware-Design des Projekts in diesem Buch enthält nur ein drahtloses Modul (mit integriertem ESP32-C3), aber kein vollständiges Smart-Light-Hardware-Design. Darüber hinaus produziert Espressif auch ein ESP32-C3-basiertes Audio-Entwicklungsboard ESP32C3-Lyra zur Steuerung von Lichtern mit Audio. Das Board verfügt über Schnittstellen für Mikrofone und Lautsprecher und kann LED-Streifen ansteuern. Es kann für die Entwicklung äußerst kostengünstiger, leistungsstarker Audio-Broadcaster und Rhythmus-Lichtleisten verwendet werden. Abbildung 2.3 zeigt ein ESP32-C3Lyra-Board, das mit einem Streifen aus 40 LED-Leuchten verbunden ist.
Abbildung 2.3. ESP32-C3-Lyra verbunden mit einem Streifen aus 40 LED-Leuchten
Smartphones (Android/iOS) Im Projekt Smart Light geht es um die Entwicklung einer Smartphone-App zur Einrichtung und Steuerung smarter Lichtprodukte.
Wi-Fi-Router Wi-Fi-Router wandeln kabelgebundene Netzwerksignale und mobile Netzwerksignale in drahtlose Netzwerksignale um, damit Computer, Smartphones, Tablets und andere drahtlose Geräte eine Verbindung zum Netzwerk herstellen können. Zum Beispielample, Breitband im Haus muss nur mit einem WLAN-Router verbunden werden, um eine drahtlose Vernetzung von WLAN-Geräten zu erreichen. Der von WLAN-Routern unterstützte Mainstream-Protokollstandard ist IEEE 802.11n mit einer durchschnittlichen TxRate von 300 Mbit/s oder maximal 600 Mbit/s. Sie sind abwärtskompatibel mit IEEE 802.11b und IEEE 802.11g. Der ESP32-C3-Chip von Espressif unterstützt IEEE 802.11b/g/n, sodass Sie zwischen einem Single-Band-WLAN-Router (2.4 GHz) oder einem Dual-Band-WLAN-Router (2.4 GHz und 5 GHz) wählen können.
Eine Computer-Entwicklungsumgebung (Linux/macOS/Windows) wird in Kapitel 4 vorgestellt. Kapitel 2. Einführung und Praxis von IoT-Projekten 15

2.2.4 Entwicklungsprozess
Abbildung 2.4. Schritte zur Entwicklung des Smart Light-Projekts
Hardware-Design Das Hardware-Design von IoT-Geräten ist für ein IoT-Projekt von entscheidender Bedeutung. Ein komplettes Smart-Light-Projekt soll alamp Arbeiten unter Netzanschluss. Verschiedene Hersteller produzieren lampEs gibt zwar unterschiedliche Stile und Treibertypen, ihre Funkmodule haben jedoch in der Regel die gleiche Funktion. Um den Entwicklungsprozess des Smart Ligh-Projekts zu vereinfachen, behandelt dieses Buch nur das Hardware-Design und die Software-Entwicklung von drahtlosen Modulen.
Konfiguration der IoT-Cloud-Plattform Um IoT-Cloud-Plattformen nutzen zu können, müssen Sie Projekte im Backend konfigurieren, z. B. das Erstellen von Produkten, das Erstellen von Geräten, das Festlegen von Geräteeigenschaften usw.
Entwicklung eingebetteter Software für IoT-Geräte. Implementieren Sie erwartete Funktionen mit ESP-IDF, dem geräteseitigen SDK von Espressif, einschließlich der Verbindung mit IoT-Cloud-Plattformen, der Entwicklung von LED-Treibern und der Aktualisierung der Firmware.
Entwicklung von Smartphone-Apps Entwickeln Sie Smartphone-Apps für Android- und iOS-Systeme, um Benutzerregistrierung und -anmeldung, Gerätesteuerung und andere Funktionen zu realisieren.
IoT-Geräteoptimierung Sobald die grundlegende Entwicklung der IoT-Gerätefunktionen abgeschlossen ist, können Sie sich Optimierungsaufgaben zuwenden, beispielsweise der Leistungsoptimierung.
Massenproduktionstests Führen Sie Massenproduktionstests gemäß verwandten Standards durch, z. B. Gerätefunktionstests, Alterungstests, HF-Tests usw.
Trotz der oben aufgeführten Schritte unterliegt ein Smart Light-Projekt nicht unbedingt einem solchen Verfahren, da auch verschiedene Aufgaben gleichzeitig ausgeführt werden können. Zum Beispielample, eingebettete Software und Smartphone-Apps können parallel entwickelt werden. Einige Schritte müssen möglicherweise auch wiederholt werden, z. B. die Optimierung von IoT-Geräten und Tests in der Massenproduktion.
16 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

2.3 Zusammenfassung
In diesem Kapitel haben wir zunächst die grundlegenden Komponenten und Funktionsmodule eines IoT-Projekts erläutert und dann den Smart Light-Fall für die Praxis vorgestellt, wobei wir uns auf seine Struktur, Funktionen, Hardware-Vorbereitung und Entwicklungsprozess bezogen haben. Leser können Rückschlüsse aus der Praxis ziehen und sich darauf verlassen, IoT-Projekte in Zukunft mit minimalen Fehlern durchzuführen.
Kapitel 2. Einführung und Praxis von IoT-Projekten 17

18 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

Kapitel 3

Einführung

ESP

Regenmacher

Das Internet der Dinge (IoT) bietet endlose Möglichkeiten, die Lebensweise der Menschen zu verändern, doch die Entwicklung der IoT-Technik ist voller Herausforderungen. Mit öffentlichen Clouds können Terminalhersteller Produktfunktionen durch die folgenden Lösungen implementieren:
Basierend auf den Cloud-Plattformen der Lösungsanbieter. Auf diese Weise müssen Terminalhersteller nur die Produkthardware entwerfen, die Hardware dann mithilfe des bereitgestellten Kommunikationsmoduls mit der Cloud verbinden und die Produktfunktionen gemäß den Richtlinien konfigurieren. Dies ist ein effizienter Ansatz, da er die serverseitige und anwendungsseitige Entwicklung sowie den Betrieb und die Wartung (O&M) überflüssig macht. Dadurch können sich Terminalhersteller auf das Hardware-Design konzentrieren, ohne sich mit der Cloud-Implementierung befassen zu müssen. Allerdings sind solche Lösungen (z. B. Geräte-Firmware und App) im Allgemeinen nicht Open Source, sodass die Produktfunktionen durch die Cloud-Plattform des Anbieters eingeschränkt werden, die nicht angepasst werden kann. Mittlerweile gehören auch die Benutzer- und Gerätedaten zur Cloud-Plattform.
Basierend auf Cloud-Produkten Bei dieser Lösung müssen Terminalhersteller nach Abschluss des Hardware-Designs nicht nur Cloud-Funktionen mithilfe eines oder mehrerer Cloud-Produkte implementieren, die von der öffentlichen Cloud bereitgestellt werden, sondern auch die Hardware mit der Cloud verbinden. Zum Beispielample, um eine Verbindung zu Amazon herzustellen Web Services (AWS) müssen Terminalhersteller AWS-Produkte wie Amazon API Gateway, AWS IoT Core und AWS Lambda verwenden, um Gerätezugriff, Fernsteuerung, Datenspeicherung, Benutzerverwaltung und andere grundlegende Funktionen zu ermöglichen. Es verlangt nicht nur von Terminalherstellern, Cloud-Produkte flexibel zu nutzen und zu konfigurieren, mit fundiertem Verständnis und umfangreicher Erfahrung, sondern verlangt auch von ihnen, die Bau- und Wartungskosten für die ersten und späteren s zu berücksichtigentages Dies stellt große Herausforderungen an Energie und Ressourcen des Unternehmens.
Im Vergleich zu öffentlichen Clouds werden private Clouds in der Regel für bestimmte Projekte und Produkte erstellt. Private Cloud-Entwickler erhalten ein Höchstmaß an Freiheit beim Protokolldesign und der Implementierung der Geschäftslogik. Terminalhersteller können Produkte und Designpläne nach Belieben erstellen und Benutzerdaten einfach integrieren und bereitstellen. Kombiniert die hohe Sicherheit, Skalierbarkeit und Zuverlässigkeit der Public Cloud mit dem VorteiltagAls erste private Cloud startete Espressif ESP
19

RainMaker, eine tief integrierte private Cloud-Lösung basierend auf der Amazon Cloud. Benutzer können ESP RainMaker einfach mit einem AWS-Konto bereitstellen und eine private Cloud erstellen.
3.1 Was ist ESP RainMaker?
ESP RainMaker ist eine vollständige AIoT-Plattform, die auf mehreren ausgereiften AWS-Produkten basiert. Es bietet verschiedene für die Massenproduktion erforderliche Dienste wie Geräte-Cloud-Zugriff, Geräte-Upgrade, Backend-Verwaltung, Anmeldung Dritter, Sprachintegration und Benutzerverwaltung. Durch die Verwendung des von AWS bereitgestellten Serverless Application Repository (SAR) können Terminalhersteller ESP RainMaker schnell und zeiteffizient auf ihren AWS-Konten bereitstellen und einfach zu bedienen sein. Der von Espressif verwaltete und gewartete SAR von ESP RainMaker hilft Entwicklern, die Kosten für die Cloud-Wartung zu senken und die Entwicklung von AIoT-Produkten zu beschleunigen und so sichere, stabile und anpassbare AIoT-Lösungen zu entwickeln. Abbildung 3.1 zeigt die Architektur von ESP RainMaker.
Abbildung 3.1. Architektur von ESP RainMaker
Der öffentliche ESP RainMaker-Server von Espressif ist für alle ESP-Enthusiasten, -Macher und -Lehrer zur Lösungsbewertung kostenlos. Entwickler können sich mit Apple-, Google- oder GitHub-Konten anmelden und schnell ihre eigenen IoT-Anwendungsprototypen erstellen. Der öffentliche Server integriert Alexa und Google Home und bietet Sprachsteuerungsdienste, die von Alexa Skill und Google Actions unterstützt werden. Auch die semantische Erkennungsfunktion wird von Dritten unterstützt. RainMaker IoT-Geräte reagieren nur auf bestimmte Aktionen. Eine vollständige Liste der unterstützten Sprachbefehle finden Sie auf den Plattformen von Drittanbietern. Darüber hinaus bietet Espressif eine öffentliche RainMaker-App an, mit der Benutzer die Produkte über Smartphones steuern können. 20 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

3.2 Die Implementierung von ESP RainMaker
Wie in Abbildung 3.2 dargestellt, besteht ESP RainMaker aus vier Teilen: · Claiming Service, der es RainMaker-Geräten ermöglicht, Zertifikate dynamisch zu erhalten. · RainMaker Cloud (auch als Cloud-Backend bekannt) bietet Dienste wie Nachrichtenfilterung, Benutzerverwaltung, Datenspeicherung und Integrationen von Drittanbietern. · RainMaker-Agent, der RainMaker-Geräten die Verbindung mit der RainMaker Cloud ermöglicht. · RainMaker-Client (RainMaker-App oder CLI-Skripte) für Bereitstellung, Benutzererstellung, Gerätezuordnung und -steuerung usw.
Abbildung 3.2. Struktur von ESP RainMaker
ESP RainMaker bietet einen vollständigen Satz an Tools für die Produktentwicklung und Massenproduktion, darunter: RainMaker SDK
Das RainMaker SDK basiert auf ESP-IDF und stellt den Quellcode des geräteseitigen Agenten und zugehöriger C-APIs für die Firmware-Entwicklung bereit. Entwickler müssen nur die Anwendungslogik schreiben und den Rest dem RainMaker-Framework überlassen. Weitere Informationen zu C-APIs finden Sie unter https://bookc3.espressif.com/rm/c-api-reference. RainMaker-App Mit der öffentlichen Version der RainMaker-App können Entwickler die Gerätebereitstellung abschließen und den Status von Geräten (z. B. intelligenten Beleuchtungsprodukten) steuern und abfragen. Es ist sowohl im iOS- als auch im Android-App-Store verfügbar. Weitere Einzelheiten finden Sie in Kapitel 10. REST-APIs REST-APIs helfen Benutzern beim Erstellen eigener Anwendungen ähnlich der RainMaker-App. Weitere Informationen finden Sie unter https://swaggerapis.rainmaker.espressif.com/.
Kapitel 3. Einführung in ESP RainMaker 21

Python-APIs Zur Implementierung aller Smartphone-ähnlichen Funktionen wird eine Python-basierte CLI bereitgestellt, die im RainMaker SDK enthalten ist. Weitere Informationen zu Python-APIs finden Sie unter https://bookc3.espressif.com/rm/python-api-reference.
Admin-CLI Admin-CLI mit höherer Zugriffsebene wird für die private Bereitstellung von ESP RainMaker bereitgestellt, um Gerätezertifikate in großen Mengen zu generieren.
3.2.1 Anspruchsservice
Die gesamte Kommunikation zwischen RainMaker-Geräten und dem Cloud-Backend erfolgt über MQTT+TLS. Im Kontext von ESP RainMaker ist „Claiming“ der Prozess, bei dem Geräte Zertifikate vom Claiming Service erhalten, um eine Verbindung zum Cloud-Backend herzustellen. Beachten Sie, dass der Anspruchsdienst nur für den öffentlichen RainMaker-Dienst gilt, während für die private Bereitstellung die Gerätezertifikate in großen Mengen über die Admin-CLI generiert werden müssen. ESP RainMaker unterstützt drei Arten von Claiming-Diensten: Self Claiming
Das Gerät selbst ruft die Zertifikate über einen in eFuse vorprogrammierten geheimen Schlüssel ab, nachdem es eine Verbindung zum Internet hergestellt hat. Hostgesteuerte Beanspruchung Die Zertifikate werden vom Entwicklungshost mit dem RainMaker-Konto bezogen. Unterstützte Antragsstellung Die Zertifikate werden während der Bereitstellung über Smartphone-Anwendungen abgerufen.
3.2.2 RainMaker-Agent
Abbildung 3.3. Struktur des RainMaker SDK Die Hauptfunktion des RainMaker-Agenten besteht darin, Konnektivität bereitzustellen und die Anwendungsebene bei der Verarbeitung von Uplink-/Downlink-Cloud-Daten zu unterstützen. Es basiert auf dem RainMaker SDK 22 ESP32-C3 Wireless Adventure: A Comprehensive Guide to IoT

und basierend auf dem bewährten ESP-IDF-Framework unter Verwendung von ESP-IDF-Komponenten wie RTOS, NVS und MQTT entwickelt. Abbildung 3.3 zeigt die Struktur des RainMaker SDK.
Das RainMaker SDK umfasst zwei Hauptfunktionen.
Verbindung
ich. Zusammenarbeit mit dem Claiming Service zum Erhalt von Gerätezertifikaten.
ii. Herstellen einer Verbindung zum Cloud-Backend über das sichere MQTT-Protokoll, um Remote-Konnektivität bereitzustellen und Fernsteuerung, Nachrichtenberichte, Benutzerverwaltung, Geräteverwaltung usw. zu implementieren. Standardmäßig wird die MQTT-Komponente in ESP-IDF verwendet und eine Abstraktionsschicht für die Schnittstelle zu anderen bereitgestellt Protokollstapel.
iii. Bereitstellung der WLAN-Bereitstellungskomponente für die WLAN-Verbindung und -Bereitstellung, der ESP-OTA-Komponente für OTA-Upgrades und der ESP-Local-Control-Komponente für die Erkennung und Verbindung lokaler Geräte. Alle diese Ziele können durch einfache Konfiguration erreicht werden.
Datenverarbeitung
ich. Speichern der vom Claiming Service ausgestellten Gerätezertifikate und der für die Ausführung von RainMaker erforderlichen Daten, standardmäßig unter Verwendung der von der NVS-Flash-Komponente bereitgestellten Schnittstelle, und Bereitstellung von APIs für Entwickler zur direkten Verwendung.
ii. Verwendung des Callback-Mechanismus zur Verarbeitung von Uplink-/Downlink-Cloud-Daten und automatische Freigabe der Daten für die Anwendungsschicht zur einfachen Verarbeitung durch Entwickler. Zum BeispielampDas RainMaker SDK bietet umfangreiche Schnittstellen zum Erstellen von TSL-Daten (Thing Specification Language), die zum Definieren von TSL-Modellen zum Beschreiben von IoT-Geräten und zum Implementieren von Funktionen wie Timing, Countdown und Sprachsteuerung erforderlich sind. Für grundlegende interaktive Funktionen wie Timing bietet RainMaker SDK eine entwicklungsfreie Lösung, die bei Bedarf einfach aktiviert werden kann. Anschließend verarbeitet der RainMaker-Agent die Daten direkt, sendet sie über das zugehörige MQTT-Thema an die Cloud und gibt die Datenänderungen im Cloud-Backend über einen Rückrufmechanismus zurück.
3.2.3 Cloud-Backend
Das Cloud-Backend basiert auf AWS Serverless Computing und wird durch AWS Cognito (Identitätsverwaltungssystem), Amazon API Gateway, AWS Lambda (Serverless Computing Service), Amazon DynamoDB (NoSQL-Datenbank) und AWS IoT Core (IoT-Zugriffskern, der MQTT-Zugriff bereitstellt) erreicht und Regelfilterung), Amazon Simple Email Service (SES einfacher Mail-Dienst), Amazon CloudFront (Schnellzustellungsnetzwerk), Amazon Simple Queue Service (SQS-Nachrichtenwarteschlange) und Amazon S3 (Bucket-Storage-Dienst). Ziel ist es, Skalierbarkeit und Sicherheit zu optimieren. Mit ESP RainMaker können Entwickler Geräte verwalten, ohne Code in der Cloud schreiben zu müssen. Von Geräten gemeldete Meldungen werden transparent an übermittelt
Kapitel 3. Einführung in ESP RainMaker 23

Anwendungsclients oder andere Dienste Dritter. Tabelle 3.1 zeigt die im Cloud-Backend verwendeten AWS-Cloud-Produkte und -Funktionen, wobei weitere Produkte und Funktionen in der Entwicklung sind.
Tabelle 3.1. AWS-Cloud-Produkte und -Funktionen, die vom Cloud-Backend verwendet werden

AWS Cloud-Produkt, das von RainMaker verwendet wird

Funktion

AWS Cognito

Verwalten von Benutzeranmeldeinformationen und Unterstützen von Anmeldungen Dritter

AWS Lambda

Implementierung der Kerngeschäftslogik des Cloud-Backends

Amazon Timestream Speicherung von Zeitreihendaten

Amazon DynamoDB speichert private Daten von Kunden

AWS IoT Core

Unterstützt MQTT-Kommunikation

Amazon SES

Bereitstellung von E-Mail-Versanddiensten

Amazon CloudFront Beschleunigung der Backend-Verwaltung webWebsite-Zugang

Amazon SQS

Weiterleiten von Nachrichten von AWS IoT Core

3.2.4 RainMaker-Client
RainMaker-Clients wie App und CLI kommunizieren über REST-APIs mit dem Cloud-Backend. Detaillierte Informationen und Anleitungen zu REST-APIs finden Sie in der von Espressif bereitgestellten Swagger-Dokumentation. Der mobile Anwendungsclient von RainMaker ist sowohl für iOS- als auch für Android-Systeme verfügbar. Es ermöglicht die Bereitstellung, Steuerung und Freigabe von Geräten sowie das Erstellen und Aktivieren von Countdown-Aufgaben und die Verbindung zu Plattformen von Drittanbietern. Es kann die Benutzeroberfläche und Symbole automatisch entsprechend der von den Geräten gemeldeten Konfiguration laden und die TSL des Geräts vollständig anzeigen.
Zum Beispielample, wenn ein intelligentes Licht auf dem vom RainMaker SDK bereitgestellten Ex erstellt wirdampDateien werden das Symbol und die Benutzeroberfläche der Glühbirne automatisch geladen, wenn die Bereitstellung abgeschlossen ist. Benutzer können die Farbe und Helligkeit des Lichts über die Schnittstelle ändern und die Steuerung durch Dritte erreichen, indem sie Alexa Smart Home Skill oder Google Smart Home Actions mit ihren ESP RainMaker-Konten verknüpfen. Abbildung 3.4 zeigt das Symbol und das UI-BeispielampDateien der Glühbirne jeweils auf Alexa, Google Home und der ESP RainMaker App.

24 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

(a) Bspample – Alexa

(b) Bspample – Google Home

(c) Bspample – ESP RainMaker
Abbildung 3.4. BspampSymbol- und Benutzeroberflächendateien für die Glühbirne auf Alexa, Google Home und der ESP RainMaker-App
3.3 Praxis: Wichtige Punkte für die Entwicklung mit ESP RainMaker
Sobald die Gerätetreiberschicht fertiggestellt ist, können Entwickler mit der Erstellung von TSL-Modellen und der Verarbeitung von Downlink-Daten mithilfe der vom RainMaker SDK bereitgestellten APIs beginnen und die ESP RainMaker-Basisdienste basierend auf der Produktdefinition und den Anforderungen aktivieren.
Kapitel 3. Einführung in ESP RainMaker 25

In Abschnitt 9.4 dieses Buches wird die Implementierung des LED-Smart-Lichts in RainMaker erläutert. Während des Debuggens können Entwickler die CLI-Tools im RainMaker SDK verwenden, um mit dem Smart Light zu kommunizieren (oder REST-APIs von Swagger aufrufen).
In Kapitel 10 wird die Verwendung von REST-APIs bei der Entwicklung von Smartphone-Anwendungen näher erläutert. Die OTA-Upgrades von LED-Smart-Leuchten werden in Kapitel 11 behandelt. Wenn Entwickler die ESP Insights-Fernüberwachung aktiviert haben, zeigt das ESP RainMaker-Management-Backend die ESP Insights-Daten an. Einzelheiten werden in Kapitel 15 vorgestellt.
ESP RainMaker unterstützt die private Bereitstellung, die sich in folgenden Punkten vom öffentlichen RainMaker-Server unterscheidet:
Anspruchsdienst Um Zertifikate in privaten Bereitstellungen zu generieren, ist es erforderlich, die RainMaker Admin-CLI anstelle von Anspruch zu verwenden. Bei öffentlichen Servern müssen Entwickler Administratorrechte erhalten, um Firmware-Upgrades durchführen zu können. Bei kommerziellen Bereitstellungen ist dies jedoch unerwünscht. Daher können weder ein separater Authentifizierungsdienst für die Selbstbeanspruchung noch Administratorrechte für die hostgesteuerte oder unterstützte Beanspruchung bereitgestellt werden.
Telefon-Apps In privaten Bereitstellungen müssen Anwendungen separat konfiguriert und kompiliert werden, um sicherzustellen, dass die Kontosysteme nicht interoperabel sind.
Anmeldungen von Drittanbietern und Sprachintegration Entwickler müssen separat über Google- und Apple-Entwicklerkonten konfigurieren, um Anmeldungen von Drittanbietern sowie die Integration von Alexa Skill und Google Voice Assistant zu ermöglichen.
TIPPS Einzelheiten zur Cloud-Bereitstellung finden Sie unter https://customer.rainmaker.espressif. com. In Bezug auf die Firmware erfordert die Migration vom öffentlichen Server zum privaten Server lediglich den Austausch von Gerätezertifikaten, was die Migrationseffizienz erheblich verbessert und die Kosten für die Migration und das sekundäre Debugging senkt.
3.4 Funktionen von ESP RainMaker
Die Funktionen von ESP RainMaker zielen hauptsächlich auf drei Aspekte ab: Benutzerverwaltung, Endbenutzer und Administratoren. Sofern nicht anders angegeben, werden alle Funktionen sowohl auf öffentlichen als auch auf privaten Servern unterstützt.
3.4.1 Benutzerverwaltung
Die Benutzerverwaltungsfunktionen ermöglichen es Endbenutzern, sich zu registrieren, anzumelden, Passwörter zu ändern, Passwörter abzurufen usw.
26 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

Registrieren und anmelden Zu den von RainMaker unterstützten Registrierungs- und Anmeldemethoden gehören: · E-Mail-ID + Passwort · Telefonnummer + Passwort · Google-Konto · Apple-Konto · GitHub-Konto (nur öffentlicher Server) · Amazon-Konto (nur privater Server)
HINWEIS Wenn Sie sich über Google/Amazon anmelden, wird die E-Mail-Adresse des Benutzers an RainMaker weitergegeben. Melden Sie sich über Apple an und teilen Sie ihm eine Dummy-Adresse mit, die Apple dem Benutzer speziell für den RainMaker-Dienst zuweist. Für Benutzer, die sich zum ersten Mal mit einem Google-, Apple- oder Amazon-Konto anmelden, wird automatisch ein RainMaker-Konto erstellt.
Passwort ändern. Gilt nur für Anmeldungen, die auf E-Mail-ID/Telefonnummer basieren. Alle anderen aktiven Sitzungen werden abgemeldet, nachdem das Passwort geändert wurde. Gemäß dem Verhalten von AWS Cognito können abgemeldete Sitzungen bis zu einer Stunde aktiv bleiben.
Passwort abrufen. Gilt nur für Anmeldungen, die auf E-Mail-ID/Telefonnummer basieren.
3.4.2 Endbenutzerfunktionen
Zu den Funktionen, die Endbenutzern offen stehen, gehören lokale und Fernsteuerung und -überwachung, Planung, Gerätegruppierung, Gerätefreigabe, Push-Benachrichtigungen und Integrationen von Drittanbietern.
Fernsteuerung und -überwachung · Konfiguration, Parameterwerte und Verbindungsstatus für ein oder alle Geräte abfragen. · Legen Sie Parameter für einzelne oder mehrere Geräte fest.
Lokale Steuerung und Überwachung Zur lokalen Steuerung müssen Mobiltelefon und Gerät mit demselben Netzwerk verbunden sein.
Planung · Benutzer legen bestimmte Aktionen zu einem bestimmten Zeitpunkt fest. · Während der Ausführung des Zeitplans ist für das Gerät keine Internetverbindung erforderlich. · Einmalig oder wiederholt (durch Angabe von Tagen) für einzelne oder mehrere Geräte.
Gerätegruppierung Unterstützt abstrakte Gruppierung auf mehreren Ebenen. Gruppenmetadaten können zum Erstellen einer Home-Room-Struktur verwendet werden.
Kapitel 3. Einführung in ESP RainMaker 27

Gerätefreigabe Ein oder mehrere Geräte können mit einem oder mehreren Benutzern geteilt werden.
Push-Benachrichtigungen Endbenutzer erhalten Push-Benachrichtigungen für Ereignisse wie · Neue(s) Gerät(e) hinzugefügt/entfernt · Gerät mit der Cloud verbunden · Gerät von der Cloud getrennt · Gerätefreigabeanfragen erstellt/akzeptiert/abgelehnt · Von Geräten gemeldete Warnmeldungen
Integrationen von Drittanbietern wie Alexa und Google Voice Assistant werden zur Steuerung von RainMaker-Geräten unterstützt, darunter Lichter, Schalter, Steckdosen, Lüfter und Temperatursensoren.
3.4.3 Admin-Funktionen
Admin-Funktionen ermöglichen es Administratoren, Geräteregistrierung, Gerätegruppierung und OTA-Upgrades zu implementieren view Statistiken und ESP Insights-Daten.
Geräteregistrierung Generieren Sie Gerätezertifikate und registrieren Sie sich mit der Admin-CLI (nur privater Server).
Gerätegruppierung Erstellen Sie abstrakte oder strukturierte Gruppen basierend auf Geräteinformationen (nur privater Server).
Over-the-Air (OTA)-Upgrades Laden Sie Firmware basierend auf Version und Modell auf ein oder mehrere Geräte oder eine Gruppe hoch. Überwachen, stornieren oder archivieren Sie OTA-Jobs.
View Statistiken ViewZu den verfügbaren Statistiken gehören: · Geräteregistrierungen (vom Administrator registrierte Zertifikate), · Geräteaktivierungen (Gerät wird zum ersten Mal angeschlossen), · Benutzerkonten · Benutzer-Geräte-Zuordnung
View ESP Insights-Daten ViewZu den Daten von ESP Insights gehören: · Fehler, Warnungen und benutzerdefinierte Protokolle · Absturzberichte und -analysen · Neustartgründe · Metriken wie Speichernutzung, RSSI usw. · Benutzerdefinierte Metriken und Variablen
28 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

3.5 Zusammenfassung
In diesem Kapitel haben wir einige wichtige Unterschiede zwischen der öffentlichen RainMaker-Bereitstellung und der privaten Bereitstellung vorgestellt. Die von Espressif eingeführte private ESP RainMaker-Lösung ist äußerst zuverlässig und erweiterbar. Alle Chips der ESP32-Serie wurden an AWS angeschlossen und angepasst, was die Kosten erheblich senkt. Entwickler können sich auf die Prototypenverifizierung konzentrieren, ohne sich mit AWS-Cloud-Produkten vertraut machen zu müssen. Wir haben auch die Implementierung und Funktionen von ESP RainMaker sowie einige wichtige Punkte für die Entwicklung mithilfe der Plattform erläutert.
Scannen Sie, um ESP RainMaker für Android herunterzuladen. Scannen Sie, um ESP RainMaker für iOS herunterzuladen
Kapitel 3. Einführung in ESP RainMaker 29

30 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

Kapitel Einrichten 4 Entwicklungsumgebung
Dieses Kapitel konzentriert sich auf ESP-IDF, das offizielle Softwareentwicklungsframework für ESP32-C3. Wir erklären, wie die Umgebung auf verschiedenen Betriebssystemen eingerichtet wird, und stellen die Projektstruktur und das Build-System von ESP-IDF sowie die Verwendung zugehöriger Entwicklungstools vor. Anschließend stellen wir den Kompilierungs- und Ausführungsprozess eines Ex vorample-Projekt und bietet gleichzeitig eine detaillierte Erklärung des Ausgabeprotokolls bei jedem stage.
4.1 ESP-IDF vorbeiview
ESP-IDF (Espressif IoT Development Framework) ist ein IoT-Entwicklungsframework aus einer Hand, das von Espressif Technology bereitgestellt wird. Es verwendet C/C++ als Hauptentwicklungssprache und unterstützt die Kreuzkompilierung unter gängigen Betriebssystemen wie Linux, Mac und Windows. Die ExampDie in diesem Buch enthaltenen Programme werden mit ESP-IDF entwickelt, das die folgenden Funktionen bietet: · SoC-Treiber auf Systemebene. ESP-IDF enthält Treiber für ESP32, ESP32-S2, ESP32-C3,
und andere Chips. Diese Treiber umfassen eine Peripherie-Low-Level-Bibliothek (LL), eine Hardware-Abstraktionsschicht-Bibliothek (HAL), RTOS-Unterstützung und Treibersoftware für die obere Schicht usw. · Wesentliche Komponenten. ESP-IDF enthält grundlegende Komponenten, die für die IoT-Entwicklung erforderlich sind. Dazu gehören mehrere Netzwerkprotokoll-Stacks wie HTTP und MQTT, ein Energieverwaltungs-Framework mit dynamischer Frequenzmodulation sowie Funktionen wie Flash-Verschlüsselung und Secure Boot usw. · Entwicklungs- und Produktionstools. ESP-IDF bietet häufig verwendete Tools zum Erstellen, Flashen und Debuggen während der Entwicklung und Massenproduktion (siehe Abbildung 4.1), wie das auf CMake basierende Build-System, die auf GCC basierende Cross-Compilation-Toolkette und die JTAG Debugging-Tool basierend auf OpenOCD usw. Es ist erwähnenswert, dass der ESP-IDF-Code in erster Linie der Open-Source-Lizenz Apache 2.0 entspricht. Benutzer können ohne Einschränkungen persönliche oder kommerzielle Software entwickeln und dabei die Bedingungen der Open-Source-Lizenz einhalten. Darüber hinaus erhalten Nutzer kostenlose und dauerhafte Patentlizenzen, ohne dass sie dazu verpflichtet sind, etwaige am Quellcode vorgenommene Änderungen als Open Source bereitzustellen.
31

Abbildung 4.1.

Erstellen, Flashen und Debuggen

Werkzeuge für Entwicklung und Massenproduktion

4.1.1 ESP-IDF-Versionen
Der ESP-IDF-Code wird auf GitHub als Open-Source-Projekt gehostet. Derzeit sind drei Hauptversionen verfügbar: v3, v4 und v5. Jede Hauptversion enthält normalerweise verschiedene Unterversionen, z. B. v4.2, v4.3 usw. Espressif Systems gewährleistet einen 30-monatigen Support für Bugfixes und Sicherheitspatches für jede veröffentlichte Unterversion. Daher werden auch regelmäßig Revisionen von Subversionen veröffentlicht, wie z. B. v4.3.1, v4.2.2 usw. Tabelle 4.1 zeigt den Unterstützungsstatus verschiedener ESP-IDF-Versionen für Espressif-Chips und gibt an, ob sie sich in einer Vorversion befindenview stage (bietet Unterstützung für preview Versionen, denen möglicherweise bestimmte Funktionen oder Dokumentation fehlen) oder offiziell unterstützt werden.

Tabelle 4.1. Unterstützungsstatus verschiedener ESP-IDF-Versionen für Espressif-Chips

Serie ESP32 ESP32-S2 ESP32-C3 ESP32-S3 ESP32-C2 ESP32-H2

v4.1 unterstützt

v4.2 unterstützt unterstützt

v4.3 unterstützt unterstützt unterstützt

v4.4 unterstützt unterstützt unterstützt unterstützt unterstützt
Vorview

v5.0 unterstützt unterstützt unterstützt unterstützt unterstützt unterstützt vorview

32 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

Die Iteration von Hauptversionen erfordert häufig Anpassungen der Framework-Struktur und Aktualisierungen des Kompilierungssystems. Zum Beispielample, die größte Änderung von v3.* zu v4.* war die schrittweise Migration des Build-Systems von Make zu CMake. Andererseits bringt die Iteration von Nebenversionen typischerweise das Hinzufügen neuer Funktionen oder die Unterstützung neuer Chips mit sich.
Es ist wichtig, die Beziehung zwischen stabilen Versionen und GitHub-Zweigen zu unterscheiden und zu verstehen. Mit v*.* oder v*.*.* gekennzeichnete Versionen stellen stabile Versionen dar, die die vollständigen internen Tests von Espressif bestanden haben. Nach der Korrektur bleiben der Code, die Toolkette und die Release-Dokumente für dieselbe Version unverändert. GitHub-Zweigs (z. B. der Release/v4.3-Zweig) unterliegen jedoch häufigen Code-Commits, oft täglich. Daher können sich zwei Codeausschnitte unter demselben Zweig unterscheiden, sodass Entwickler ihren Code umgehend entsprechend aktualisieren müssen.
4.1.2 ESP-IDF-Git-Workflow
Espressif folgt einem spezifischen Git-Workflow für ESP-IDF, der wie folgt beschrieben wird:
· Neue Änderungen werden am Master-Zweig vorgenommen, der als Hauptentwicklungszweig dient. Die ESP-IDF-Version im Master-Zweig trägt immer ein -dev tag um anzuzeigen, dass es sich derzeit in der Entwicklung befindet, z. B. v4.3-dev. Änderungen am Master-Zweig werden zunächst erneut vorgenommenviewIm internen Repository von Espressif erstellt und getestet und dann nach Abschluss des automatisierten Tests an GitHub übertragen.
· Sobald eine neue Version die Funktionsentwicklung im Hauptzweig abgeschlossen hat und die Kriterien für die Teilnahme am Betatest erfüllt, erfolgt der Übergang zu einem neuen Zweig, z. B. Release/v4.3. Darüber hinaus ist diese neue Niederlassung tagals Vorabversion bereitgestellt, wie v4.3-beta1. Entwickler können auf der GitHub-Plattform auf die vollständige Liste der Branches und zugreifen tags für ESP-IDF. Es ist wichtig zu beachten, dass die Betaversion (Vorabversion) möglicherweise noch eine erhebliche Anzahl bekannter Probleme aufweist. Da die Beta-Version kontinuierlichen Tests unterzogen wird, werden sowohl dieser Version als auch dem Master-Zweig gleichzeitig Fehlerbehebungen hinzugefügt. In der Zwischenzeit hat der Master-Zweig möglicherweise bereits mit der Entwicklung neuer Funktionen für die nächste Version begonnen. Wenn die Tests fast abgeschlossen sind, wird dem Zweig die Bezeichnung „Release Candidate“ (rc) hinzugefügt, die darauf hinweist, dass es sich um einen potenziellen Kandidaten für die offizielle Veröffentlichung handelt, z. B. v4.3-rc1. An diesem stage, der Zweig bleibt eine Vorabversion.
· Wenn keine größeren Fehler entdeckt oder gemeldet werden, erhält die Vorabversion schließlich ein Hauptversionslabel (z. B. v5.0) oder ein Nebenversionslabel (z. B. v4.3) und wird zu einer offiziellen Release-Version, die dokumentiert wird auf der Seite mit den Versionshinweisen. Anschließend werden alle in dieser Version identifizierten Fehler im Release-Zweig behoben. Nach Abschluss der manuellen Tests wird dem Zweig ein Bugfix-Versionslabel (z. B. v4.3.2) zugewiesen, das auch auf der Seite mit den Versionshinweisen angezeigt wird.
Kapitel 4. Einrichten der Entwicklungsumgebung 33

4.1.3 Auswahl einer geeigneten Version
Da ESP-IDF offiziell mit der Unterstützung von ESP32-C3 ab Version v4.3 begonnen hat und v4.4 zum Zeitpunkt der Erstellung dieses Buches noch nicht offiziell veröffentlicht wurde, wird in diesem Buch die Version v4.3.2 verwendet, bei der es sich um eine überarbeitete Version handelt von v4.3. Es ist jedoch wichtig zu beachten, dass zum Zeitpunkt der Lektüre dieses Buchs möglicherweise bereits Version 4.4 oder neuere Versionen verfügbar sind. Bei der Auswahl einer Version empfehlen wir Folgendes:
· Für Einsteiger-Entwickler empfiehlt es sich, die stabile Version v4.3 oder die überarbeitete Version zu wählen, die mit der Ex-Version übereinstimmtampDie in diesem Buch verwendete Version.
· Für Massenproduktionszwecke wird empfohlen, die neueste stabile Version zu verwenden, um vom aktuellsten technischen Support zu profitieren.
· Wenn Sie mit neuen Chips experimentieren oder neue Produktfunktionen erkunden möchten, verwenden Sie bitte den Master-Zweig. Die neueste Version enthält alle aktuellen Funktionen. Beachten Sie jedoch, dass möglicherweise bekannte oder unbekannte Fehler vorhanden sind.
· Wenn die verwendete stabile Version nicht die gewünschten neuen Funktionen enthält und Sie die mit dem Master-Zweig verbundenen Risiken minimieren möchten, erwägen Sie die Verwendung des entsprechenden Release-Zweigs, z. B. des Release/v4.4-Zweigs. Das GitHub-Repository von Espressif erstellt zunächst den Release/v4.4-Zweig und veröffentlicht anschließend die stabile v4.4-Version basierend auf einem bestimmten historischen Snapshot dieses Zweigs, nachdem alle Funktionsentwicklungen und Tests abgeschlossen sind.
4.1.4 Überview des ESP-IDF SDK-Verzeichnisses
Das ESP-IDF SDK besteht aus zwei Hauptverzeichnissen: esp-idf und .espressif. Ersteres enthält den Quellcode des ESP-IDF-Repositorys files und Kompilierungsskripte, während letztere hauptsächlich Kompilierungs-Toolketten und andere Software speichern. Die Kenntnis dieser beiden Verzeichnisse hilft Entwicklern, die verfügbaren Ressourcen besser zu nutzen und den Entwicklungsprozess zu beschleunigen. Die Verzeichnisstruktur von ESP-IDF wird im Folgenden beschrieben:
(1) ESP-IDF-Repository-Codeverzeichnis (/esp/esp-idf), wie in Abbildung 4.2 dargestellt.
A. Komponentenverzeichniskomponenten
Dieses Kernverzeichnis integriert zahlreiche wesentliche Softwarekomponenten von ESP-IDF. Kein Projektcode kann kompiliert werden, ohne sich auf die Komponenten in diesem Verzeichnis zu verlassen. Es beinhaltet Treiberunterstützung für verschiedene Espressif-Chips. Von der LL-Bibliothek und den HAL-Bibliotheksschnittstellen für Peripheriegeräte bis hin zu den übergeordneten Treibern und virtuellen Schnittstellen File Durch die Unterstützung der Systemebene (VFS) können Entwickler die geeigneten Komponenten auf verschiedenen Ebenen für ihre Entwicklungsanforderungen auswählen. ESP-IDF unterstützt auch mehrere Standard-Netzwerkprotokoll-Stacks wie TCP/IP, HTTP, MQTT, WebSocket usw. Entwickler können bekannte Schnittstellen wie Socket verwenden, um Netzwerkanwendungen zu erstellen. Komponenten sorgen für umfassende
34 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

Abbildung 4.2. ESP-IDF-Repository-Codeverzeichnis
Sie verfügen über umfangreiche Funktionalität und können problemlos in Anwendungen integriert werden, sodass sich Entwickler ausschließlich auf die Geschäftslogik konzentrieren können. Zu den gängigen Komponenten gehören: · Treiber: Diese Komponente enthält Peripherietreiberprogramme für verschiedene Espressif
Chipserien wie GPIO, I2C, SPI, UART, LEDC (PWM) usw. Die Peripherietreiberprogramme in dieser Komponente bieten Chip-unabhängige abstrakte Schnittstellen. Jedes Peripheriegerät verfügt über einen gemeinsamen Header file (wie gpio.h), wodurch die Notwendigkeit entfällt, sich mit verschiedenen Chip-spezifischen Support-Fragen zu befassen. · esp_wifi: Wi-Fi wird als spezielles Peripheriegerät als separate Komponente behandelt. Es umfasst mehrere APIs wie die Initialisierung verschiedener Wi-Fi-Treibermodi, Parameterkonfiguration und Ereignisverarbeitung. Bestimmte Funktionen dieser Komponente werden in Form von statischen Linkbibliotheken bereitgestellt. ESP-IDF bietet außerdem eine umfassende Treiberdokumentation zur Benutzerfreundlichkeit.
Kapitel 4. Einrichten der Entwicklungsumgebung 35

· Freertos: Diese Komponente enthält den vollständigen FreeRTOS-Code. Neben der umfassenden Unterstützung dieses Betriebssystems hat Espressif auch die Unterstützung auf Dual-Core-Chips ausgeweitet. Bei Dual-Core-Chips wie ESP32 und ESP32-S3 können Benutzer Aufgaben auf bestimmten Kernen erstellen.
B. Dokumentverzeichnis-Dokumente
Dieses Verzeichnis enthält ESP-IDF-bezogene Entwicklungsdokumente, einschließlich des Leitfadens „Erste Schritte“, des API-Referenzhandbuchs, des Entwicklungshandbuchs usw.
HINWEIS Nach der Kompilierung durch automatisierte Tools wird der Inhalt dieses Verzeichnisses unter https://docs.espressif.com/projects/esp-idf bereitgestellt. Bitte stellen Sie sicher, dass Sie das Dokumentziel auf ESP32-C3 umstellen und die angegebene ESP-IDF-Version auswählen.
C. Skript-Tool-Tools
Dieses Verzeichnis enthält häufig verwendete Kompilierungs-Frontend-Tools wie idf.py und das Monitor-Terminal-Tool idf_monitor.py usw. Das Unterverzeichnis cmake enthält auch Kernskripte files des Kompilierungssystems, die als Grundlage für die Implementierung der ESP-IDF-Kompilierungsregeln dienen. Beim Hinzufügen der Umgebungsvariablen werden die Inhalte im Tools-Verzeichnis zur Systemumgebungsvariablen hinzugefügt, sodass idf.py direkt unter dem Projektpfad ausgeführt werden kann.
D. Example Programmverzeichnis examples
Dieses Verzeichnis enthält eine umfangreiche Sammlung von ESP-IDF-Example-Programme, die die Verwendung von Komponenten-APIs demonstrieren. Die ExampDateien sind basierend auf ihren Kategorien in verschiedenen Unterverzeichnissen organisiert:
· get-started: Dieses Unterverzeichnis enthält Einsteiger-ExampB. „Hallo Welt“ und „Blink“, um Benutzern das Verständnis der Grundlagen zu erleichtern.
· Bluetooth: Sie können Bluetooth-bezogene Informationen findenamples hier, einschließlich Bluetooth LE Mesh, Bluetooth LE HID, BluFi und mehr.
· WLAN: Dieses Unterverzeichnis konzentriert sich auf WLAN exampDateien, einschließlich grundlegender Programme wie Wi-Fi SoftAP, Wi-Fi Station, espnow sowie proprietärem Kommunikationsprotokoll, zamples von Espressif. Es umfasst auch mehrere Anwendungsschichten, zampAuf WLAN basierende Dateien wie Iperf, Sniffer und Smart Config.
· Peripheriegeräte: Dieses umfangreiche Unterverzeichnis ist anhand der Peripherienamen weiter in zahlreiche Unterordner unterteilt. Es enthält hauptsächlich Peripherietreiber, zamples für Espressif-Chips, mit jedem example mit mehreren Sub-Examples. Das GPIO-Unterverzeichnis enthält beispielsweise zwei examples: GPIO und GPIO-Matrixtastatur. Es ist wichtig zu beachten, dass nicht alle ExampDie Dateien in diesem Verzeichnis gelten für ESP32-C3.
36 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

Zum Beispielample, der ExampDateien in „usb/host“ gelten nur für Peripheriegeräte mit USB-Host-Hardware (z. B. ESP32-S3), und ESP32-C3 verfügt nicht über dieses Peripheriegerät. Das Kompilierungssystem stellt beim Festlegen des Ziels normalerweise Eingabeaufforderungen bereit. Die README file von jedem Example listet die unterstützten Chips auf. · Protokolle: Dieses Unterverzeichnis enthält z. BampDateien für verschiedene Kommunikationsprotokolle, einschließlich MQTT, HTTP, HTTP-Server, PPPoS, Modbus, mDNS, SNTP, die ein breites Spektrum an Kommunikationsprotokollen abdecken, zampFür die IoT-Entwicklung erforderliche Dateien. · Bereitstellung: Hier finden Sie BereitstellungsoptionenampDateien für verschiedene Methoden, z. B. Wi-Fi-Bereitstellung und Bluetooth LE-Bereitstellung. · System: Dieses Unterverzeichnis enthält System-Debugging-BeispieleampDateien (z. B. Stack-Tracing, Laufzeit-Tracing, Task-Überwachung), Energieverwaltung, zampDateien (z. B. verschiedene Schlafmodi, Co-Prozessoren) und zampDateien, die sich auf allgemeine Systemkomponenten wie Konsolenterminal, Ereignisschleife und Systemtimer beziehen. · Speicher: In diesem Unterverzeichnis finden Sie z. Bamples von allen file Von ESP-IDF unterstützte Systeme und Speichermechanismen (z. B. Lesen und Schreiben von Flash, SD-Karte und anderen Speichermedien) sowie zampDateien des nichtflüchtigen Speichers (NVS), FatFS, SPIFFS und andere file Systemoperationen. · Sicherheit: Dieses Unterverzeichnis enthält zampDateien im Zusammenhang mit der Flash-Verschlüsselung. (2) Verzeichnis der ESP-IDF-Kompilierungstoolkette (/.espressif), wie in Abbildung 4.3 dargestellt.
Abbildung 4.3. Verzeichnis der ESP-IDF-Kompilierungstoolkette
Kapitel 4. Einrichten der Entwicklungsumgebung 37

A. Softwareverteilungsverzeichnis dist
Die ESP-IDF-Toolkette und andere Software werden in Form komprimierter Pakete verteilt. Während des Installationsvorgangs lädt das Installationstool zunächst das komprimierte Paket in das Verzeichnis dist herunter und extrahiert es dann in das angegebene Verzeichnis. Sobald die Installation abgeschlossen ist, können die Inhalte in diesem Verzeichnis sicher entfernt werden.
B. Verzeichnis der virtuellen Python-Umgebung Python env
Verschiedene Versionen von ESP-IDF basieren auf bestimmten Versionen von Python-Paketen. Die direkte Installation dieser Pakete auf demselben Host kann zu Konflikten zwischen Paketversionen führen. Um dieses Problem zu lösen, nutzt ESP-IDF virtuelle Python-Umgebungen, um verschiedene Paketversionen zu isolieren. Mit diesem Mechanismus können Entwickler mehrere Versionen von ESP-IDF auf demselben Host installieren und einfach zwischen ihnen wechseln, indem sie verschiedene Umgebungsvariablen importieren.
C. Verzeichnistools der ESP-IDF-Kompilierungstoolkette
Dieses Verzeichnis enthält hauptsächlich Cross-Compilation-Tools, die zum Kompilieren von ESP-IDF-Projekten erforderlich sind, z. B. CMake-Tools, Ninja-Build-Tools und die gcc-Toolkette, die das endgültige ausführbare Programm generiert. Darüber hinaus enthält dieses Verzeichnis die Standardbibliothek der C/C++-Sprache zusammen mit dem entsprechenden Header fileS. Wenn ein Programm auf einen Systemheader verweist file wie #include , findet die Kompilierungs-Toolkette die stdio.h file innerhalb dieses Verzeichnisses.
4.2 Einrichten der ESP-IDF-Entwicklungsumgebung
Die ESP-IDF-Entwicklungsumgebung unterstützt gängige Betriebssysteme wie Windows, Linux und macOS. In diesem Abschnitt wird erläutert, wie die Entwicklungsumgebung auf jedem System eingerichtet wird. Es wird empfohlen, ESP32-C3 auf einem Linux-System zu entwickeln, das hier ausführlich vorgestellt wird. Aufgrund der Ähnlichkeit der Entwicklungstools sind viele Anweisungen plattformübergreifend anwendbar. Daher wird empfohlen, den Inhalt dieses Abschnitts sorgfältig zu lesen.
HINWEIS Sie können auf die Online-Dokumente unter https://bookc3.espressif.com/esp32c3 verweisen, die die in diesem Abschnitt genannten Befehle enthalten.
4.2.1 Einrichten der ESP-IDF-Entwicklungsumgebung unter Linux
Die für die ESP-IDF-Entwicklungsumgebung erforderlichen GNU-Entwicklungs- und Debugging-Tools stammen ursprünglich aus dem Linux-System. Darüber hinaus ist das Befehlszeilenterminal in Linux leistungsstark und benutzerfreundlich, was es zur idealen Wahl für die ESP32-C3-Entwicklung macht. Du kannst
38 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

Wählen Sie Ihre bevorzugte Linux-Distribution aus, wir empfehlen jedoch die Verwendung von Ubuntu oder anderen Debian-basierten Systemen. Dieser Abschnitt enthält Anleitungen zum Einrichten der ESP-IDF-Entwicklungsumgebung unter Ubuntu 20.04.
1. Installieren Sie die erforderlichen Pakete
Öffnen Sie ein neues Terminal und führen Sie den folgenden Befehl aus, um alle erforderlichen Pakete zu installieren. Der Befehl überspringt automatisch Pakete, die bereits installiert sind.
$ sudo apt-get install git wget flex bison gperf python3 python3-pip python3setuptools cmake ninja-build ccache libffi-dev libssl-dev dfu-util libusb-1.0-0
TIPPS Sie müssen für den obigen Befehl das Administratorkonto und das Passwort verwenden. Standardmäßig werden bei der Passworteingabe keine Informationen angezeigt. Drücken Sie einfach die „Enter“-Taste, um den Vorgang fortzusetzen.
Git ist ein wichtiges Code-Management-Tool in ESP-IDF. Nachdem Sie die Entwicklungsumgebung erfolgreich eingerichtet haben, können Sie den Befehl git log verwenden view alle Codeänderungen, die seit der Erstellung von ESP-IDF vorgenommen wurden. Darüber hinaus wird Git in ESP-IDF auch zur Bestätigung von Versionsinformationen verwendet, die für die Installation der richtigen Toolkette entsprechend bestimmten Versionen erforderlich sind. Zu den weiteren wichtigen Systemtools gehört neben Git auch Python. ESP-IDF enthält zahlreiche in Python geschriebene Automatisierungsskripte. Tools wie CMake, Ninja-build und Ccache werden häufig in C/C++-Projekten verwendet und dienen als Standardtools für die Codekompilierung und -erstellung in ESP-IDF. libusb-1.0-0 und dfu-util sind die Haupttreiber für die serielle USB-Kommunikation und das Brennen von Firmware. Sobald die Softwarepakete installiert sind, können Sie apt show verwenden Befehl, um detaillierte Beschreibungen der einzelnen Pakete zu erhalten. Zum Beispielample, verwenden Sie apt show git, um die Beschreibungsinformationen für das Git-Tool auszudrucken.
F: Was tun, wenn die Python-Version nicht unterstützt wird? A: ESP-IDF v4.3 erfordert eine Python-Version, die nicht niedriger als v3.6 ist. Für ältere Versionen von Ubuntu laden Sie bitte manuell eine höhere Version von Python herunter, installieren Sie sie und legen Sie Python3 als Standard-Python-Umgebung fest. Detaillierte Anweisungen finden Sie, indem Sie nach dem Schlüsselwort update-alternatives python suchen.
2. Laden Sie den ESP-IDF-Repository-Code herunter
Öffnen Sie ein Terminal und erstellen Sie mit dem Befehl mkdir einen Ordner mit dem Namen esp in Ihrem Home-Verzeichnis. Wenn Sie möchten, können Sie einen anderen Namen für den Ordner wählen. Verwenden Sie den Befehl cd, um den Ordner aufzurufen.
Kapitel 4. Einrichten der Entwicklungsumgebung 39

$ mkdir -p /esp $ cd /esp
Verwenden Sie den Befehl „git clone“, um den ESP-IDF-Repository-Code herunterzuladen, wie unten gezeigt:
$ git clone -b v4.3.2 –rekursiv https://github.com/espressif/esp-idf.git
Im obigen Befehl gibt der Parameter -b v4.3.2 die herunterzuladende Version an (in diesem Fall Version 4.3.2). Der Parameter –recursive sorgt dafür, dass alle Unterrepositorys von ESP-IDF rekursiv heruntergeladen werden. Informationen zu Unterrepositorys finden Sie in den .gitmodules file.
3. Installieren Sie die ESP-IDF-Entwicklungstoolkette
Espressif bietet ein automatisiertes Skript install.sh zum Herunterladen und Installieren der Toolkette. Dieses Skript überprüft die aktuelle ESP-IDF-Version und die Betriebssystemumgebung und lädt dann die entsprechende Version der Python-Toolpakete und Kompilierungstoolketten herunter und installiert sie. Der Standardinstallationspfad für die Toolkette ist /.espressif. Sie müssen lediglich zum esp-idf-Verzeichnis navigieren und install.sh ausführen.
$ cd /esp/esp-idf $ ./install.sh
Wenn Sie die Toolkette erfolgreich installiert haben, zeigt das Terminal Folgendes an:
Fertig!
Zu diesem Zeitpunkt haben Sie die ESP-IDF-Entwicklungsumgebung erfolgreich eingerichtet.
4.2.2 Einrichten der ESP-IDF-Entwicklungsumgebung unter Windows
1. Laden Sie das ESP-IDF-Tools-Installationsprogramm herunter
TIPPS Es wird empfohlen, die ESP-IDF-Entwicklungsumgebung unter Windows 10 oder höher einzurichten. Sie können das Installationsprogramm unter https://dl.espressif.com/dl/esp-idf/ herunterladen. Das Installationsprogramm ist ebenfalls eine Open-Source-Software und sein Quellcode kann sein viewveröffentlicht unter https://github.com/espressif/idf-installer.
· Online-Installationsprogramm für ESP-IDF-Tools
Dieses Installationsprogramm ist relativ klein, etwa 4 MB groß, und andere Pakete und Code werden während des Installationsvorgangs heruntergeladen. Der VorteiltagDer Vorteil des Online-Installationsprogramms besteht darin, dass nicht nur Softwarepakete und Code bei Bedarf während des Installationsprozesses heruntergeladen werden können, sondern auch die Installation aller verfügbaren Versionen von ESP-IDF und des neuesten Zweigs des GitHub-Codes (z. B. des Master-Zweigs) ermöglicht. . Der NachteiltagDer Grund dafür ist, dass während des Installationsvorgangs eine Netzwerkverbindung erforderlich ist, was aufgrund von Netzwerkproblemen zu Installationsfehlern führen kann.
40 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

· Offline-Installationsprogramm für ESP-IDF-Tools. Dieses Installationsprogramm ist größer, etwa 1 GB groß und enthält alle Softwarepakete und Codes, die für die Einrichtung der Umgebung erforderlich sind. Der HauptvorteiltagDer Vorteil des Offline-Installationsprogramms besteht darin, dass es auf Computern ohne Internetzugang verwendet werden kann und im Allgemeinen eine höhere Erfolgsquote bei der Installation aufweist. Es ist zu beachten, dass das Offline-Installationsprogramm nur stabile Versionen von ESP-IDF installieren kann, die durch v*.* oder v*.*.* gekennzeichnet sind.
2. Führen Sie das ESP-IDF Tools-Installationsprogramm aus. Nachdem Sie eine geeignete Version des Installationsprogramms heruntergeladen haben (z. B. ESP-IDF Tools offline 4.3.2 schalten).ample hier), doppelklicken Sie auf die Exe-Datei file , um die ESP-IDF-Installationsschnittstelle zu starten. Im Folgenden wird gezeigt, wie Sie die stabile ESP-IDF-Version v4.3.2 mit dem Offline-Installationsprogramm installieren.
(1) Wählen Sie in der in Abbildung 4.4 gezeigten Benutzeroberfläche „Installationssprache auswählen“ die zu verwendende Sprache aus der Dropdown-Liste aus.
Abbildung 4.4. Schnittstelle „Installationssprache auswählen“ (2) Nachdem Sie die Sprache ausgewählt haben, klicken Sie auf „OK“, um die Schnittstelle „Lizenzvereinbarung“ aufzurufen
(siehe Abbildung 4.5). Nachdem Sie die Installationslizenzvereinbarung sorgfältig gelesen haben, wählen Sie „Ich akzeptiere die Vereinbarung“ und klicken Sie auf „Weiter“.
Abbildung 4.5. Schnittstelle „Lizenzvereinbarung“ Kapitel 4. Einrichten der Entwicklungsumgebung 41

(3) Zuview die Systemkonfiguration in der Schnittstelle „Systemprüfung vor der Installation“ (siehe Abbildung 4.6). Überprüfen Sie die Windows-Version und die Informationen zur installierten Antivirensoftware. Klicken Sie auf „Weiter“, wenn alle Konfigurationselemente normal sind. Andernfalls können Sie auf „Vollständiges Protokoll“ klicken, um Lösungen zu erhalten, die auf Schlüsselelementen basieren.
Abbildung 4.6. TIPPS zur Benutzeroberfläche „Systemprüfung vor der Installation“.
Sie können Protokolle an https://github.com/espressif/idf-installer/issues senden, um Hilfe zu erhalten. (4) Wählen Sie das ESP-IDF-Installationsverzeichnis aus. Wählen Sie hier D:/.espressif aus, wie in gezeigt
Abbildung 4.7 und klicken Sie auf „Weiter“. Bitte beachten Sie, dass es sich bei .espressif hier um ein verstecktes Verzeichnis handelt. Nachdem die Installation abgeschlossen ist, können Sie view den spezifischen Inhalt dieses Verzeichnisses durch Öffnen des file Manager und Anzeige versteckter Elemente.
Abbildung 4.7. Wählen Sie das ESP-IDF-Installationsverzeichnis aus. 42 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

(5) Überprüfen Sie die Komponenten, die installiert werden müssen, wie in Abbildung 4.8 dargestellt. Es wird empfohlen, die Standardoption zu verwenden, d. h. die Installation abzuschließen, und dann auf „Weiter“ zu klicken.
Abbildung 4.8. Wählen Sie die zu installierenden Komponenten aus (6). Bestätigen Sie die zu installierenden Komponenten und klicken Sie auf „Installieren“, um die automatische Installation zu starten.
Installationsprozess, wie in Abbildung 4.9 dargestellt. Der Installationsvorgang kann mehrere zehn Minuten dauern und der Fortschrittsbalken des Installationsvorgangs ist in Abbildung 4.10 dargestellt. Bitte warte geduldig.
Abbildung 4.9. Vorbereiten der Installation (7) Nach Abschluss der Installation wird empfohlen, die Option „ESP-IDF registrieren“ zu aktivieren
Tools ausführbare Dateien als Windows Defender-Ausschlüsse…“, um zu verhindern, dass Antivirensoftware gelöscht wird fileS. Durch das Hinzufügen von Ausschlusselementen können auch häufige Scans durch Antivirenprogramme übersprungen werden
Kapitel 4. Einrichten der Entwicklungsumgebung 43

Abbildung 4.10. Installationsfortschrittsbalken-Software, die die Effizienz der Codekompilierung des Windows-Systems erheblich verbessert. Klicken Sie auf „Fertig stellen“, um die Installation der Entwicklungsumgebung abzuschließen, wie in Abbildung 4.11 dargestellt. Sie können wählen, ob Sie „ESP-IDF-PowerShell-Umgebung ausführen“ oder „ESP-IDF-Eingabeaufforderung ausführen“ aktivieren möchten. Führen Sie das Kompilierungsfenster direkt nach der Installation aus, um sicherzustellen, dass die Entwicklungsumgebung normal funktioniert.
Abbildung 4.11. Installation abgeschlossen (8) Öffnen Sie die installierte Entwicklungsumgebung in der Programmliste (entweder ESP-IDF 4.3
CMD oder ESP-IDF 4.3 PowerShell-Terminal, wie in Abbildung 4.12 dargestellt), und die ESP-IDF-Umgebungsvariable wird automatisch hinzugefügt, wenn sie im Terminal ausgeführt wird. Danach können Sie den Befehl idf.py für Vorgänge verwenden. Das geöffnete ESP-IDF 4.3 CMD ist in Abbildung 4.13 dargestellt. 44 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

Abbildung 4.12. Entwicklungsumgebung installiert
Abbildung 4.13. ESP-IDF 4.3 CMD
4.2.3 Einrichten der ESP-IDF-Entwicklungsumgebung auf dem Mac
Der Installationsprozess der ESP-IDF-Entwicklungsumgebung auf einem Mac-System ist derselbe wie auf einem Linux-System. Die Befehle zum Herunterladen des Repository-Codes und zum Installieren der Toolkette sind genau die gleichen. Lediglich die Befehle zum Installieren von Abhängigkeitspaketen unterscheiden sich geringfügig. 1. Abhängigkeitspakete installieren Öffnen Sie ein Terminal und installieren Sie pip, das Python-Paketverwaltungstool, indem Sie den folgenden Befehl ausführen:
% sudo easy install pip
Installieren Sie Homebrew, ein Paketverwaltungstool für macOS, indem Sie den folgenden Befehl ausführen:
% /bin/bash -c „$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)“
Installieren Sie die erforderlichen Abhängigkeitspakete, indem Sie den folgenden Befehl ausführen:
% brew python3 install cmake ninja ccache dfu-util
2. ESP-IDF-Repository-Code herunterladen Befolgen Sie die Anweisungen in Abschnitt 4.2.1, um den ESP-IDF-Repository-Code herunterzuladen. Die Schritte sind die gleichen wie beim Herunterladen auf ein Linux-System.
Kapitel 4. Einrichten der Entwicklungsumgebung 45

3. Installieren Sie die ESP-IDF-Entwicklungstoolkette
Befolgen Sie die Anweisungen in Abschnitt 4.2.1, um die ESP-IDF-Entwicklungstoolkette zu installieren. Die Schritte sind die gleichen wie bei der Installation auf einem Linux-System.
4.2.4 VS-Code installieren
Standardmäßig enthält das ESP-IDF SDK kein Codebearbeitungstool (obwohl das neueste ESP-IDF-Installationsprogramm für Windows die Option zur Installation von ESP-IDF Eclipse bietet). Sie können den Code mit einem beliebigen Textbearbeitungsprogramm bearbeiten und ihn dann mit Terminalbefehlen kompilieren.
Ein beliebtes Codebearbeitungstool ist VS Code (Visual Studio Code), ein kostenloser und funktionsreicher Codeeditor mit einer benutzerfreundlichen Oberfläche. Es bietet verschiedene plugins die Funktionen wie Codenavigation, Syntaxhervorhebung, Git-Versionskontrolle und Terminalintegration bieten. Darüber hinaus hat Espressif ein spezielles Plugin namens Espressif IDF für VS Code entwickelt, das die Projektkonfiguration und das Debuggen vereinfacht.
Sie können den Codebefehl im Terminal verwenden, um schnell den aktuellen Ordner in VS Code zu öffnen. Alternativ können Sie die Tastenkombination Strg+ verwenden, um die Standard-Terminalkonsole des Systems in VS Code zu öffnen.
TIPPS Es wird empfohlen, VS Code für die ESP32-C3-Codeentwicklung zu verwenden. Laden Sie die neueste Version von VS Code unter https://code.visualstudio.com/ herunter und installieren Sie sie.
4.2.5 Einführung in Entwicklungsumgebungen von Drittanbietern
Neben der offiziellen ESP-IDF-Entwicklungsumgebung, die hauptsächlich die Sprache C verwendet, unterstützt ESP32-C3 auch andere gängige Programmiersprachen und eine breite Palette von Entwicklungsumgebungen von Drittanbietern. Einige bemerkenswerte Optionen sind:
Arduino: eine Open-Source-Plattform für Hardware und Software, die verschiedene Mikrocontroller unterstützt, darunter ESP32-C3.
Es verwendet die Sprache C++ und bietet eine vereinfachte und standardisierte API, die allgemein als Arduino-Sprache bezeichnet wird. Arduino wird häufig in der Prototypenentwicklung und im Bildungsbereich eingesetzt. Es bietet ein erweiterbares Softwarepaket und eine IDE, die ein einfaches Kompilieren und Flashen ermöglicht.
MicroPython: ein Python-3-Sprachinterpreter, der für die Ausführung auf eingebetteten Mikrocontroller-Plattformen entwickelt wurde.
Mit einer einfachen Skriptsprache kann es direkt auf die Peripherieressourcen des ESP32-C3 (wie UART, SPI und I2C) und Kommunikationsfunktionen (wie Wi-Fi und Bluetooth LE) zugreifen.
46 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

Dies vereinfacht die Hardware-Interaktion. MicroPython ermöglicht in Kombination mit der umfangreichen mathematischen Operationsbibliothek von Python die Implementierung komplexer Algorithmen auf ESP32-C3 und erleichtert so die Entwicklung von KI-bezogenen Anwendungen. Da es sich um eine Skriptsprache handelt, ist keine wiederholte Kompilierung erforderlich. Es können Änderungen vorgenommen und Skripte direkt ausgeführt werden.
NodeMCU: ein LUA-Sprachinterpreter, der für Chips der ESP-Serie entwickelt wurde.
Es unterstützt nahezu alle Peripheriefunktionen von ESP-Chips und ist leichter als MicroPython. Ähnlich wie MicroPython verwendet NodeMCU eine Skriptsprache, sodass keine wiederholte Kompilierung erforderlich ist.
Darüber hinaus unterstützt ESP32-C3 auch die Betriebssysteme NuttX und Zephyr. NuttX ist ein Echtzeitbetriebssystem, das POSIX-kompatible Schnittstellen bereitstellt und so die Anwendungsportabilität verbessert. Zephyr ist ein kleines Echtzeitbetriebssystem, das speziell für IoT-Anwendungen entwickelt wurde. Es umfasst zahlreiche Softwarebibliotheken, die für die IoT-Entwicklung erforderlich sind, und entwickelt sich nach und nach zu einem umfassenden Software-Ökosystem.
Dieses Buch enthält keine detaillierten Installationsanweisungen für die oben genannten Entwicklungsumgebungen. Sie können eine Entwicklungsumgebung entsprechend Ihren Anforderungen installieren, indem Sie der jeweiligen Dokumentation und Anleitung folgen.
4.3 ESP-IDF-Kompilierungssystem
4.3.1 Grundkonzepte des Kompilierungssystems
Ein ESP-IDF-Projekt ist eine Sammlung eines Hauptprogramms mit einer Einstiegsfunktion und mehreren unabhängigen Funktionskomponenten. Zum Beispielample, ein Projekt, das LED-Schalter steuert, besteht im Wesentlichen aus einem Einstiegsprogramm und einer Treiberkomponente, die GPIO steuert. Wenn Sie die LED-Fernbedienung realisieren möchten, müssen Sie auch WLAN, TCP/IP-Protokollstapel usw. hinzufügen.
Das Kompilierungssystem kann ausführbare Dateien kompilieren, verknüpfen und generieren files (.bin) für den Code durch eine Reihe von Erstellungsregeln. Das Kompilierungssystem von ESP-IDF v4.0 und höheren Versionen basiert standardmäßig auf CMake, und das Kompilierungsskript CMakeLists.txt kann verwendet werden, um das Kompilierungsverhalten des Codes zu steuern. Zusätzlich zur Unterstützung der grundlegenden Syntax von CMake definiert das ESP-IDF-Kompilierungssystem auch eine Reihe von Standardkompilierungsregeln und CMake-Funktionen, und Sie können das Kompilierungsskript mit einfachen Anweisungen schreiben.
4.3.2 Projekt File Struktur
Ein Projekt ist ein Ordner, der ein Hauptprogramm, benutzerdefinierte Komponenten usw. enthält files sind erforderlich, um ausführbare Anwendungen zu erstellen, z. B. Kompilierungsskripts und Konfigurationen
Kapitel 4. Einrichten der Entwicklungsumgebung 47

files, Partitionstabellen usw. Projekte können kopiert und weitergegeben werden, und die gleiche ausführbare Datei file kann auf Maschinen mit derselben Version der ESP-IDF-Entwicklungsumgebung kompiliert und generiert werden. Ein typisches ESP-IDF-Projekt file Die Struktur ist in Abbildung 4.14 dargestellt.
Abbildung 4.14. Typisches ESP-IDF-Projekt file Struktur Da ESP-IDF mehrere IoT-Chips von Espressif unterstützt, einschließlich ESP32, ESP32-S-Serie, ESP32-C-Serie, ESP32-H-Serie usw., muss vor dem Kompilieren des Codes ein Ziel bestimmt werden. Das Ziel ist sowohl das Hardwaregerät, auf dem das Anwendungsprogramm ausgeführt wird, als auch das Build-Ziel des Kompilierungssystems. Je nach Bedarf können Sie ein oder mehrere Ziele für Ihr Projekt angeben. Zum Beispielample, über den Befehl idf.py set-target esp32c3 können Sie das Kompilierungsziel auf ESP32-C3 festlegen, wobei die Standardparameter und der Kompilierungs-Toolkettenpfad für ESP32C3 geladen werden. Nach der Kompilierung kann ein ausführbares Programm für ESP32C3 generiert werden. Sie können den Befehl set-target auch erneut ausführen, um ein anderes Ziel festzulegen. Das Kompilierungssystem wird dann automatisch bereinigt und neu konfiguriert. Komponenten
Komponenten in ESP-IDF sind modulare und unabhängige Codeeinheiten, die im Kompilierungssystem verwaltet werden. Sie sind als Ordner organisiert, wobei der Ordnername standardmäßig den Komponentennamen darstellt. Jede Komponente verfügt über ein eigenes Kompilierungsskript, das 48 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

gibt seine Kompilierungsparameter und Abhängigkeiten an. Während des Kompilierungsprozesses werden Komponenten in separate statische Bibliotheken (.a.) kompiliert files) und schließlich mit anderen Komponenten zum Anwendungsprogramm kombiniert.
ESP-IDF stellt wesentliche Funktionen wie das Betriebssystem, Peripherietreiber und den Netzwerkprotokoll-Stack in Form von Komponenten bereit. Diese Komponenten werden im Komponentenverzeichnis im ESP-IDF-Stammverzeichnis gespeichert. Entwickler müssen diese Komponenten nicht in das Komponentenverzeichnis von myProject kopieren. Stattdessen müssen sie nur die Abhängigkeitsbeziehungen dieser Komponenten in der CMakeLists.txt des Projekts angeben file unter Verwendung der Anweisungen REQUIRES oder PRIV_REQUIRES. Das Kompilierungssystem findet und kompiliert automatisch die erforderlichen Komponenten.
Daher ist das Komponentenverzeichnis unter myProject nicht erforderlich. Es wird nur verwendet, um einige benutzerdefinierte Komponenten des Projekts einzubinden, bei denen es sich um Bibliotheken von Drittanbietern oder benutzerdefinierten Code handeln kann. Darüber hinaus können Komponenten aus jedem anderen Verzeichnis als ESP-IDF oder dem aktuellen Projekt bezogen werden, beispielsweise aus einem Open-Source-Projekt, das in einem anderen Verzeichnis gespeichert ist. In diesem Fall müssen Sie nur den Pfad der Komponente hinzufügen, indem Sie die Variable EXTRA_COMPONENT_DIRS in der CMakeLists.txt im Stammverzeichnis festlegen. Dieses Verzeichnis überschreibt alle ESP-IDF-Komponenten mit demselben Namen und stellt so sicher, dass die richtige Komponente verwendet wird.
Eingabeprogramm main Das Hauptverzeichnis innerhalb des Projekts folgt dem gleichen file Struktur wie andere Komponenten (z. B. Komponente1). Es hat jedoch eine besondere Bedeutung, da es sich um einen obligatorischen Bestandteil handelt, der in jedem Projekt vorhanden sein muss. Das Hauptverzeichnis enthält den Quellcode des Projekts und den Einstiegspunkt des Benutzerprogramms, normalerweise mit dem Namen app_main. Standardmäßig beginnt die Ausführung des Benutzerprogramms an diesem Einstiegspunkt. Die Hauptkomponente unterscheidet sich auch dadurch, dass sie automatisch von allen Komponenten innerhalb des Suchpfads abhängig ist. Daher ist es nicht erforderlich, Abhängigkeiten mithilfe der Direktiven REQUIRES oder PRIV_REQUIRES in CMakeLists.txt explizit anzugeben file.
Konfiguration file Das Stammverzeichnis des Projekts enthält eine Konfiguration file namens sdkconfig, das die Konfigurationsparameter für alle Komponenten innerhalb des Projekts enthält. Die sdkconfig file wird automatisch vom Kompilierungssystem generiert und kann mit dem Befehl idf.py menuconfig geändert und neu generiert werden. Die Menükonfigurationsoptionen stammen hauptsächlich aus der Kconfig.projbuild des Projekts und der Kconfig der Komponenten. Komponentenentwickler fügen im Allgemeinen Konfigurationselemente in Kconfig hinzu, um die Komponente flexibel und konfigurierbar zu machen.
Build-Verzeichnis Standardmäßig speichert das Build-Verzeichnis innerhalb des Projekts Zwischenspeicher files und die fi-
Kapitel 4. Einrichten der Entwicklungsumgebung 49

Letzte ausführbare Programme, die mit dem Build-Befehl idf.py generiert wurden. Im Allgemeinen ist es nicht erforderlich, direkt auf den Inhalt des Build-Verzeichnisses zuzugreifen. ESP-IDF bietet vordefinierte Befehle für die Interaktion mit dem Verzeichnis, z. B. die Verwendung des Flash-Befehls idf.py, um die kompilierte Binärdatei automatisch zu finden file und flashen Sie es an die angegebene Flash-Adresse oder verwenden Sie den Befehl idf.py fullclean, um das gesamte Build-Verzeichnis zu bereinigen.
Partitionstabelle (partitions.csv) Jedes Projekt erfordert eine Partitionstabelle, um den Flash-Speicherplatz zu unterteilen und die Größe und Startadresse des ausführbaren Programms und des Benutzerdatenraums anzugeben. Der Befehl idf.py flash oder das OTA-Upgrade-Programm flasht die Firmware gemäß dieser Tabelle auf die entsprechende Adresse. ESP-IDF stellt mehrere Standardpartitionstabellen in „components/partition_table“ bereit, z. B. „partitions_singleapp.csv“ und „partitions_two_ota.csv“, die in „menuconfig“ ausgewählt werden können.
Wenn die Standardpartitionstabelle des Systems die Anforderungen des Projekts nicht erfüllen kann, kann eine benutzerdefinierte Partitions.csv zum Projektverzeichnis hinzugefügt und in menuconfig ausgewählt werden.
4.3.3 Standard-Build-Regeln des Kompilierungssystems
Regeln zum Überschreiben von Komponenten mit demselben Namen Während der Komponentensuche folgt das Kompilierungssystem einer bestimmten Reihenfolge. Es sucht zunächst nach internen Komponenten von ESP-IDF, dann nach Komponenten des Benutzerprojekts und schließlich nach Komponenten in EXTRA_COMPONENT_DIRS. In Fällen, in denen mehrere Verzeichnisse Komponenten mit demselben Namen enthalten, überschreibt die im letzten Verzeichnis gefundene Komponente alle vorherigen Komponenten mit demselben Namen. Diese Regel ermöglicht die Anpassung von ESP-IDF-Komponenten innerhalb des Benutzerprojekts, während der ursprüngliche ESP-IDF-Code erhalten bleibt.
Regeln für die standardmäßige Einbeziehung gemeinsamer Komponenten Wie in Abschnitt 4.3.2 erwähnt, müssen Komponenten ihre Abhängigkeiten von anderen Komponenten in der CMakeLists.txt explizit angeben. Allerdings werden gängige Komponenten wie Freertos standardmäßig automatisch in das Build-System einbezogen, auch wenn ihre Abhängigkeitsbeziehungen nicht explizit im Kompilierungsskript definiert sind. Zu den allgemeinen ESP-IDF-Komponenten gehören Freertos, Newlib, Heap, Log, Soc, esp_rom, esp_common, xtensa/riscv und cxx. Die Verwendung dieser gemeinsamen Komponenten vermeidet repetitive Arbeit beim Schreiben von CMakeLists.txt und macht es prägnanter.
Regeln zum Überschreiben von Konfigurationselementen Entwickler können Standardkonfigurationsparameter hinzufügen, indem sie eine Standardkonfiguration hinzufügen file mit dem Namen sdkconfig.defaults für das Projekt. Zum Beispielample, CONFIG_LOG_ hinzufügen
50 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

DEFAULT_LEVEL_NONE = Sie können die UART-Schnittstelle so konfigurieren, dass standardmäßig keine Protokolldaten gedruckt werden. Wenn außerdem bestimmte Parameter für ein bestimmtes Ziel festgelegt werden müssen, ist eine Konfiguration erforderlich file mit dem Namen sdkconfig.defaults.TARGET_NAME kann hinzugefügt werden, wobei TARGET_NAME esp32s2, esp32c3 usw. sein kann. Diese Konfiguration files werden während der Kompilierung mit der allgemeinen Standardkonfiguration in die sdkconfig importiert file Zuerst wird sdkconfig.defaults importiert, gefolgt von der zielspezifischen Konfiguration file, wie zum Beispiel sdkconfig.defaults.esp32c3. In Fällen, in denen Konfigurationselemente mit demselben Namen vorhanden sind, die letztere Konfiguration file wird das erstere außer Kraft setzen.
4.3.4 Einführung in das Kompilierungsskript
Bei der Entwicklung eines Projekts mit ESP-IDF müssen Entwickler nicht nur Quellcode, sondern auch CMakeLists.txt für das Projekt und die Komponenten schreiben. CMakeLists.txt ist ein Text file, auch als Kompilierungsskript bekannt, das eine Reihe von Kompilierungsobjekten, Kompilierungskonfigurationselementen und Befehlen definiert, um den Kompilierungsprozess des Quellcodes zu steuern. Das Kompilierungssystem von ESP-IDF v4.3.2 basiert auf CMake. Neben der Unterstützung nativer CMake-Funktionen und -Befehle definiert es auch eine Reihe benutzerdefinierter Funktionen, wodurch das Schreiben von Kompilierungsskripten erheblich vereinfacht wird.
Zu den Kompilierungsskripten in ESP-IDF gehören hauptsächlich das Projektkompilierungsskript und die Komponentenkompilierungsskripte. Die CMakeLists.txt im Stammverzeichnis des Projekts wird als Projektkompilierungsskript bezeichnet, das den Kompilierungsprozess des gesamten Projekts leitet. Ein einfaches Projektkompilierungsskript enthält normalerweise die folgenden drei Zeilen:
1. cmake_minimum_required(VERSION 3.5) 2. include($ENV{IDF_PATH}/tools/cmake/project.cmake) 3. project(myProject)
Darunter muss cmake_minimum_required (VERSION 3.5) in der ersten Zeile platziert werden, die verwendet wird, um die für das Projekt erforderliche Mindestversionsnummer von CMake anzugeben. Neuere Versionen von CMake sind im Allgemeinen abwärtskompatibel mit älteren Versionen. Passen Sie daher die Versionsnummer entsprechend an, wenn Sie neuere CMake-Befehle verwenden, um die Kompatibilität sicherzustellen.
include($ENV {IDF_PATH}/tools/cmake/project.cmake) importiert vordefinierte Konfigurationselemente und Befehle des ESP-IDF-Kompilierungssystems, einschließlich der in Abschnitt 4.3.3 beschriebenen Standard-Build-Regeln des Kompilierungssystems. project(myProject) erstellt das Projekt selbst und gibt seinen Namen an. Dieser Name wird als endgültige Ausgabebinärdatei verwendet file Namen, also myProject.elf und myProject.bin.
Ein Projekt kann aus mehreren Komponenten bestehen, einschließlich der Hauptkomponente. Das oberste Verzeichnis jeder Komponente enthält eine CMakeLists.txt file, das als Komponentenkompilierungsskript bezeichnet wird. Komponentenkompilierungsskripte werden hauptsächlich zur Angabe von Komponentenabhängigkeiten, Konfigurationsparametern und Quellcode verwendet files und enthaltener Header files für
Kapitel 4. Einrichten der Entwicklungsumgebung 51

Zusammenstellung. Mit der benutzerdefinierten Funktion idf_component_register von ESP-IDF lautet der mindestens erforderliche Code für ein Komponentenkompilierungsskript wie folgt:

1. idf_component_register(SRCS „src1.c“

INCLUDE_DIRS „einschließen“

ERFORDERT Komponente1)

Der SRCS-Parameter stellt eine Liste der Quellen bereit files in der Komponente, bei mehreren durch Leerzeichen getrennt fileS. Der Parameter INCLUDE_DIRS stellt eine Liste öffentlicher Header bereit file Verzeichnisse für die Komponente, die dem Include-Suchpfad für andere Komponenten hinzugefügt werden, die von der aktuellen Komponente abhängen. Der Parameter REQUIRES identifiziert die öffentlichen Komponentenabhängigkeiten für die aktuelle Komponente. Komponenten müssen explizit angeben, von welchen Komponenten sie abhängig sind, z. B. Komponente2 abhängig von Komponente1. Für die Hauptkomponente, die standardmäßig von allen Komponenten abhängt, kann der Parameter REQUIRES jedoch weggelassen werden.

Darüber hinaus können im Kompilierungsskript auch native CMake-Befehle verwendet werden. Zum Beispielample, verwenden Sie den Befehl set, um Variablen festzulegen, z. B. set(VARIABLE „VALUE“).

4.3.5 Einführung in allgemeine Befehle
ESP-IDF verwendet im Prozess der Codekompilierung CMake (Projektkonfigurationstool), Ninja (Projekterstellungstool) und esptool (Flash-Tool). Jedes Tool spielt eine andere Rolle beim Kompilierungs-, Erstellungs- und Flash-Prozess und unterstützt auch unterschiedliche Bedienbefehle. Um den Benutzerbetrieb zu erleichtern, fügt ESP-IDF ein einheitliches Front-End idf.py hinzu, mit dem die oben genannten Befehle schnell aufgerufen werden können.
Stellen Sie vor der Verwendung von idf.py sicher, dass:
· Die Umgebungsvariable IDF_PATH von ESP-IDF wurde dem aktuellen Terminal hinzugefügt. · Das Befehlsausführungsverzeichnis ist das Stammverzeichnis des Projekts, das die enthält
Projektkompilierungsskript CMakeLists.txt.
Die allgemeinen Befehle von idf.py lauten wie folgt:
· idf.py –help: Zeigt eine Liste von Befehlen und deren Verwendungsanweisungen an. · idf.py set-target : Festlegen der Kompilierung von taidf.py auf fullcleanrget, z
als Ersatz mit esp32c3. · idf.py menuconfig: Starten von menuconfig, einer grafischen Terminalkonfiguration
Tool, mit dem Konfigurationsoptionen ausgewählt oder geändert werden können. Die Konfigurationsergebnisse werden in sdkconfig gespeichert file. · idf.py-Build: Codekompilierung wird gestartet. Das Zwischenprodukt files und das durch die Kompilierung generierte endgültige ausführbare Programm werden standardmäßig im Build-Verzeichnis des Projekts gespeichert. Der Kompilierungsprozess ist inkrementell, was bedeutet, dass nur eine Quelle vorhanden ist file geändert wird, nur das geänderte file wird beim nächsten Mal zusammengestellt.

52 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

· idf.py clean: Reinigung des Zwischenprodukts files wird durch die Projektkompilierung generiert. Das gesamte Projekt wird bei der nächsten Kompilierung zur Kompilierung gezwungen. Beachten Sie, dass die CMake-Konfiguration und die von menuconfig vorgenommenen Konfigurationsänderungen bei der Bereinigung nicht gelöscht werden.
· idf.py fullclean: Löschen des gesamten Build-Verzeichnisses, einschließlich aller CMake-Konfigurationsausgaben fileS. Beim erneuten Erstellen des Projekts konfiguriert CMake das Projekt von Grund auf. Bitte beachten Sie, dass dieser Befehl alle rekursiv löscht files im Build-Verzeichnis, also verwenden Sie es mit Vorsicht, und die Projektkonfiguration file wird nicht gelöscht.
· idf.py flash: Flashen der ausführbaren Programmbinärdatei file generiert durch Build auf das Ziel ESP32-C3. Die Optionen -p und B werden verwendet, um den Gerätenamen des seriellen Ports bzw. die Baudrate für das Flashen festzulegen. Wenn diese beiden Optionen nicht angegeben sind, wird der serielle Port automatisch erkannt und die Standardbaudrate verwendet.
· idf.py-Monitor: Zeigt die Ausgabe der seriellen Schnittstelle des Ziel-ESP32-C3 an. Mit der Option -p kann der Gerätename des hostseitigen seriellen Ports angegeben werden. Drücken Sie während des Druckens über die serielle Schnittstelle die Tastenkombination [Strg+], um den Monitor zu verlassen.
Die oben genannten Befehle können bei Bedarf auch kombiniert werden. Zum Beispielample, der Befehl idf.py build flash monitor führt nacheinander die Codekompilierung, das Flashen und das Öffnen des Monitors für die serielle Schnittstelle durch.
Sie können https://bookc3.espressif.com/build-system besuchen, um mehr über das ESP-IDF-Kompilierungssystem zu erfahren.
4.4 Übung: Kompilieren Bspample Programm „Blink“
4.4.1 Example Analyse
In diesem Abschnitt wird das Programm Blink als Ex verwendetample, um das zu analysieren file Struktur und Codierungsregeln eines realen Projekts im Detail. Das Blink-Programm implementiert den LED-Blinkeffekt und das Projekt befindet sich im Verzeichnis examples/get-started/blink, das eine Quelle enthält file, Aufbau files und mehrere Kompilierungsskripte.
Das in diesem Buch vorgestellte Smart-Light-Projekt basiert auf diesem Beispielample Programm. In späteren Kapiteln werden nach und nach Funktionen hinzugefügt, um es endgültig zu vervollständigen.
Quellcode Um den gesamten Entwicklungsprozess zu demonstrieren, wurde das Blink-Programm nach esp32c3-iot-projects/devicefirmware/1 blink kopiert.
Die Verzeichnisstruktur des Blink-Projekts files ist in Abbildung 4.15 dargestellt.
Das Blink-Projekt enthält nur ein Hauptverzeichnis, das eine spezielle Komponente darstellt
Kapitel 4. Einrichten der Entwicklungsumgebung 53

Abbildung 4.15. File Verzeichnisstruktur des Blink-Projekts

müssen wie in Abschnitt 4.3.2 beschrieben eingebunden werden. Das Hauptverzeichnis wird hauptsächlich zum Speichern der Implementierung der Funktion app_main() verwendet, die den Einstiegspunkt zum Benutzerprogramm darstellt. Das Blink-Projekt enthält nicht das Komponentenverzeichnis, da dieses Beispielample muss nur die Komponenten verwenden, die mit ESP-IDF geliefert werden, und erfordert keine zusätzlichen Komponenten. Die im Blink-Projekt enthaltene Datei CMakeLists.txt wird zur Steuerung des Kompilierungsprozesses verwendet, während Kconfig.projbuild zum Hinzufügen von Konfigurationselementen für dieses Beispiel verwendet wirdample Programm in menuconfig. Sonstiges unnötig files haben keinen Einfluss auf die Kompilierung des Codes und werden daher hier nicht besprochen. Eine ausführliche Einführung in das Blink-Projekt files ist wie folgt.

1. /*blink.c enthält den folgenden Header fileS*/

2. #include

//Standard-C-Bibliotheksheader file

3. #include „freertos/freeRTOS.h“ //FreeRTOS-Hauptheader file

4. #include „freertos/task.h“

//FreeRTOS-Task-Header file

5. #include „sdkconfig.h“

//Konfigurationsheader file generiert von kconfig

6. #include „driver/gpio.h“

//GPIO-Treiber-Header file

Die Quelle file blink.c enthält eine Reihe von Headern files entspricht der Funktionsdeklaration

tionen. ESP-IDF folgt im Allgemeinen der Reihenfolge, in der der Standardbibliotheksheader eingefügt wird files, FreeR-

TOS-Header files, Treiber-Header files, anderer Komponentenheader files und Projektkopf files.

Die Reihenfolge in welchem Header files enthalten, kann sich auf das endgültige Kompilierungsergebnis auswirken, also versuchen Sie es

Befolgen Sie die Standardregeln. Es ist zu beachten, dass sdkconfig.h automatisch generiert wird

von kconfig und kann nur über den Befehl idf.py menuconfig konfiguriert werden.

Direkte Änderung dieses Headers file wird überschrieben.

1. /*Sie können den GPIO auswählen, der der LED in idf.py menuconfig entspricht. Das Änderungsergebnis von menuconfig ist der Wert von CONFIG_BLINK

_GPIO wird geändert. Sie können die Makrodefinition auch direkt ändern

hier und ändern Sie CONFIG_BLINK_GPIO in einen festen Wert.*/ 2. #define BLINK_GPIO CONFIG_BLINK_GPIO

3. void app_main(void)

4. {

/*Konfigurieren Sie IO als GPIO-Standardfunktion, aktivieren Sie den Pull-up-Modus und

Eingabe- und Ausgabemodi deaktivieren*/

gpio_reset_pin(BLINK_GPIO);

54 ESP32-C3 Wireless Adventure: Ein umfassender Leitfaden zum IoT

8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. }

/*GPIO auf Ausgabemodus setzen*/ gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT); while(1) {
/*Protokoll drucken*/ printf(“Ausschalten der LEDn”); /*LED ausschalten (Ausgangspegel niedrig)*/ gpio_set_level(BLINK_GPIO, 0); /*Verzögerung (1000 ms)*/ vTaskDelay(1000 / portTICK_PERIOD_MS); printf(“Einschalten der LEDn”); /*LED einschalten (hohes Ausgangsniveau)*/ gpio_set_level(BLINK_GPIO, 1); vTaskDelay(1000 / portTICK_PERIOD_MS); }

Die Funktion app_main() im Blink-ExampDas Programm dient als Einstiegspunkt für Benutzerprogramme. Es handelt sich um eine einfache Funktion ohne Parameter und ohne Rückgabewert. Diese Funktion wird aufgerufen, nachdem das System die Initialisierung abgeschlossen hat. Dazu gehören Aufgaben wie die Initialisierung des seriellen Protokollports, die Konfiguration von Single/Dual Core und die Konfiguration des Watchdogs.

Die Funktion app_main() wird im Kontext einer Aufgabe namens main ausgeführt. Die Stapelgröße und Priorität dieser Aufgabe können in „menuconfig Componentconfig Common ESP-related“ angepasst werden.

Für einfache Aufgaben wie das Blinken einer LED kann der gesamte erforderliche Code direkt in der Funktion app_main() implementiert werden. Dies beinhaltet typischerweise die Initialisierung des GPIO, der der LED entspricht, und die Verwendung einer while(1)-Schleife, um die LED ein- und auszuschalten. Alternativ können Sie die FreeRTOS-API verwenden, um eine neue Aufgabe zu erstellen, die das Blinken der LED verarbeitet. Sobald die neue Aufgabe erfolgreich erstellt wurde, können Sie die Funktion app_main() beenden.

Der Inhalt von main/CMakeLists.txt file, das den Kompilierungsprozess für die Hauptkomponente leitet, lautet wie folgt:

1. idf_component_register(SRCS „blink.c“ INCLUDE_DIRS „.“ )

Unter diesen ruft main/CMakeLists.txt nur eine Kompilierungssystemfunktion auf, nämlich idf_component_register. Ähnlich wie CMakeLists.txt für die meisten anderen Komponenten wird blink.c zu SRCS und der Quelle hinzugefügt fileZu SRCS hinzugefügte Dateien werden kompiliert. Gleichzeitig sollte „.“, das den Pfad darstellt, in dem sich CMakeLists.txt befindet, zu INCLUDE_DIRS als Suchverzeichnis für Header hinzugefügt werden fileS. Der Inhalt von CMakeLists.txt ist wie folgt:
1. #Geben Sie v3.5 als älteste vom aktuellen Projekt unterstützte CMake-Version an. 2. #Versionen unter v3.5 müssen aktualisiert werden, bevor die Kompilierung fortgesetzt wird. 3. cmake_minimum_required(VERSION 3.5) 4. #Fügen Sie die standardmäßige CMake-Konfiguration des ESP ein -IDF-Kompilierungssystem

Kapitel 4. Einrichten der Entwicklungsumgebung 55

5. include($ENV{IDF_PATH}/tools/cmake/project.cmake) 6. #Erstellen Sie ein Projekt mit dem Namen „blink“ 7. project(myProject)
Unter diesen enthält CMakeLists.txt im Stammverzeichnis hauptsächlich $ENV{IDF_ PATH}/tools/cmake/project.cmake, die Hauptkonfiguration von CMake file bereitgestellt von ESP-IDF. Es wird verwendet, um zu betrügen

Dokumente / Ressourcen

Espressif Systems ESP32-C3 Wireless Adventure [pdf] Benutzerhandbuch
ESP32-C3 Wireless Adventure, ESP32-C3, Wireless Adventure, Abenteuer

Verweise

Bedienungsanleitung

ESP32-C3 Drahtloses Abenteuer

ESP32-C3 Drahtloses Abenteuer

Ein umfassender Leitfaden zum IoT

Technische Daten

Anweisungen zur Produktverwendung

Vorbereitung

Einführung und Praxis von IoT-Projekten

Übung: Smart Light-Projekt

Projektstruktur

Projektfunktionen

Hardware-Vorbereitung

Entwicklungsprozess

Einführung in ESP RainMaker

Was ist ESP RainMaker?

Die Implementierung von ESP RainMaker

Praxis: Wichtige Punkte für die Entwicklung mit ESP RainMaker

Funktionen von ESP RainMaker

Entwicklungsumgebung einrichten

Hardware- und Treiberentwicklung

Hardware-Design von Smart Light-Produkten basierend auf ESP32-C3

Merkmale und Zusammensetzung von Smart Light-Produkten

Hardware-Design des ESP32-C3-Kernsystems

Häufig gestellte Fragen

F: Was ist ESP RainMaker?

F: Wie kann ich die Entwicklungsumgebung einrichten?
ESP32-C3?

F: Welche Funktionen bietet ESP RainMaker?

Dokumente / Ressourcen

Verweise

Hinterlasse einen Kommentar

Antworten abbrechen

ESP32-C3 Drahtloses Abenteuer

ESP32-C3 Drahtloses Abenteuer

Ein umfassender Leitfaden zum IoT

Technische Daten

Anweisungen zur Produktverwendung

Vorbereitung

Einführung und Praxis von IoT-Projekten

Übung: Smart Light-Projekt

Projektstruktur

Projektfunktionen

Hardware-Vorbereitung

Entwicklungsprozess

Einführung in ESP RainMaker

Was ist ESP RainMaker?

Die Implementierung von ESP RainMaker

Praxis: Wichtige Punkte für die Entwicklung mit ESP RainMaker

Funktionen von ESP RainMaker

Entwicklungsumgebung einrichten

Hardware- und Treiberentwicklung

Hardware-Design von Smart Light-Produkten basierend auf ESP32-C3

Merkmale und Zusammensetzung von Smart Light-Produkten

Hardware-Design des ESP32-C3-Kernsystems

Häufig gestellte Fragen

F: Was ist ESP RainMaker?

F: Wie kann ich die Entwicklungsumgebung einrichten? ESP32-C3?

F: Welche Funktionen bietet ESP RainMaker?

Dokumente / Ressourcen

Verweise

Verwandte Artikel

Hinterlasse einen Kommentar

Antworten abbrechen

F: Wie kann ich die Entwicklungsumgebung einrichten?
ESP32-C3?