Guide de l'utilisateur de l'aventure sans fil Espressif Systems ESP32-C3

Avant d'utiliser l'ESP32-C3 Wireless Adventure, assurez-vous d'être
familier avec les concepts et l'architecture de l'IoT. CA aidera
vous comprenez comment l'appareil s'intègre dans l'écosystème IoT plus large
et ses applications potentielles dans les maisons intelligentes.

Introduction et pratique des projets IoT

Dans cette section, vous découvrirez les projets IoT typiques,
y compris les modules de base pour les appareils IoT courants, les modules de base
des applications client et des plates-formes cloud IoT communes. Cette volonté
vous fournir une base pour comprendre et créer votre
propres projets IoT.

Pratique : Projet Smart Light

Dans ce projet pratique, vous apprendrez à créer un
lumière à l’aide de l’ESP32-C3 Wireless Adventure. La structure du projet,
les fonctions, la préparation du matériel et le processus de développement seront
expliqué en détail.

Structure du projet

Le projet comprend plusieurs volets, dont le
ESP32-C3 Wireless Adventure, LED, capteurs et cloud
arrière-plan.

Fonctions du projet

Le projet d'éclairage intelligent vous permet de contrôler la luminosité et
couleur des LED à distance via une application mobile ou web
interface.

Préparation du matériel

Pour préparer le projet, vous devrez rassembler les
composants matériels nécessaires, tels que l'ESP32-C3 Wireless
Carte aventure, LED, résistances et alimentation.

Processus de développement

Le processus de développement implique la mise en place du développement
Environnement, écriture de code pour contrôler les LED, connexion au
backend cloud et tester la fonctionnalité du smart
lumière.

Introduction à ESP RainMaker

ESP RainMaker est un framework puissant pour développer l'IoT
dispositifs. Dans cette section, vous apprendrez ce qu'est ESP RainMaker et
comment il peut être mis en œuvre dans vos projets.

Qu'est-ce qu'ESP RainMaker ?

ESP RainMaker est une plateforme basée sur le cloud qui fournit un ensemble de
outils et services pour créer et gérer des appareils IoT.

La mise en œuvre d'ESP RainMaker

Cette section explique les différents composants impliqués dans
implémenter ESP RainMaker, y compris le service de réclamation,
Agent RainMaker, backend cloud et client RainMaker.

Pratique : points clés pour le développement avec ESP RainMaker

Dans cette section pratique, vous découvrirez les points clés à
à prendre en compte lors du développement avec ESP RainMaker. Cela inclut l'appareil
la revendication, la synchronisation des données et la gestion des utilisateurs.

Caractéristiques d'ESP RainMaker

ESP RainMaker propose diverses fonctionnalités pour la gestion des utilisateurs, fin
utilisateurs et administrateurs. Ces fonctionnalités permettent un appareil facile
configuration, contrôle à distance et surveillance.

Configuration de l'environnement de développement

Cette section fournit un aperçuview de l'ESP-IDF (Espressif IoT
Development Framework), qui est le cadre de développement officiel
pour les appareils basés sur ESP32. Il explique les différentes versions de
ESP-IDF et comment configurer l'environnement de développement.

Développement de matériel et de pilotes

Conception matérielle de produits Smart Light basés sur ESP32-C3

Cette section se concentre sur la conception matérielle de l'éclairage intelligent
produits basés sur l'ESP32-C3 Wireless Adventure. Il couvre le
caractéristiques et composition des produits d'éclairage intelligents, ainsi que les
conception matérielle du système central ESP32-C3.

Caractéristiques et composition des produits Smart Light

Cette sous-section explique les fonctionnalités et les composants qui
produits d'éclairage intelligents. Il aborde les différentes fonctionnalités
et considérations de conception pour créer des lumières intelligentes.

Conception matérielle du système de base ESP32-C3

La conception matérielle du système central ESP32-C3 inclut l'alimentation
Alimentation, séquence de mise sous tension, réinitialisation du système, flash SPI, source d'horloge,
et considérations relatives aux RF et aux antennes. Cette sous-section fournit
des informations détaillées sur ces aspects.

FAQ

Q : Qu'est-ce qu'ESP RainMaker ?

R : ESP RainMaker est une plate-forme basée sur le cloud qui fournit des outils
et des services pour créer et gérer des appareils IoT. Cela simplifie
le processus de développement et permet une configuration facile de l'appareil, à distance
contrôle et surveillance.

Q : Comment puis-je configurer l'environnement de développement pour
ESP32-C3 ?

R : Pour configurer l'environnement de développement pour ESP32-C3, vous avez besoin
d'installer ESP-IDF (Espressif IoT Development Framework) et
configurez-le selon les instructions fournies. L'ESP-IDF est le
cadre de développement officiel pour les appareils basés sur ESP32.

Q : Quelles sont les fonctionnalités d'ESP RainMaker ?

R : ESP RainMaker offre diverses fonctionnalités, notamment
gestion, fonctionnalités de l'utilisateur final et fonctionnalités d'administration. Gestion des utilisateurs
permet une réclamation facile des appareils et une synchronisation des données. Utilisateur final
les fonctionnalités permettent le contrôle à distance des appareils via une application mobile ou
web interface. Les fonctionnalités d'administration fournissent des outils pour la surveillance des appareils
et la gestion.

View Fullscreen

Aventure sans fil ESP32-C3
Un guide complet sur l'IoT
Systèmes Espressif 12 juin 2023

Contenu

Je Préparation

1 Introduction à l'IoT

1.1 Architecture de l'IoT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.2 Application IoT dans les maisons intelligentes . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2 Introduction et pratique des projets IoT

2.1 Introduction aux projets IoT typiques . . . . . . . . . . . . . . . . . . . . . . . . 9

2.1.1 Modules de base pour les appareils IoT courants . . . . . . . . . . . . . . . . . 9

2.1.2 Modules de base des applications clientes . . . . . . . . . . . . . . . . . . . dix

2.1.3 Introduction aux plateformes cloud IoT communes. . . . . . . . . . . . . . 11

2.2 Pratique : Projet Smart Light . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2.2.1 Structure du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.2.2 Fonctions du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.2.3 Préparation du matériel . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.2.4 Processus de développement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.3 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3 Introduction à ESP RainMaker

3.1 Qu'est-ce qu'ESP RainMaker ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

3.2 La mise en œuvre d'ESP RainMaker . . . . . . . . . . . . . . . . . . . . . . 21

3.2.1 Réclamation du service . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

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

3.2.3 Back-end cloud . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

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

3.3 Pratique : points clés pour le développement avec ESP RainMaker . . . . . . . . . . . . 25

3.4 Fonctionnalités d'ESP RainMaker . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.4.1 Gestion des utilisateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.4.2 Fonctionnalités utilisateur final . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

3.4.3 Fonctionnalités d'administration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

3.5 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4 Configuration de l'environnement de développement

4.1 ESP-IDF terminéview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

4.1.1 Versions ESP-IDF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

4.1.2 Flux de travail Git ESP-IDF . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 4.1.3 Choix d'une version appropriée . . . . . . . . . . . . . . . . . . . . . . . . 34 4.1.4 Finiview du répertoire SDK ESP-IDF. . . . . . . . . . . . . . . . . . . . 34 4.2 Configuration de l'environnement de développement ESP-IDF . . . . . . . . . . . . . . . . . 38 4.2.1 Configuration de l'environnement de développement ESP-IDF sous Linux . . . . . . . . 38 4.2.2 Configuration de l'environnement de développement ESP-IDF sous Windows . . . . . . 40 4.2.3 Configuration de l'environnement de développement ESP-IDF sur Mac . . . . . . . . . 45 4.2.4 Installation de VS Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 4.2.5 Introduction aux environnements de développement tiers . . . . . . . . 46 4.3 Système de compilation ESP-IDF . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 4.3.1 Concepts de base du système de compilation . . . . . . . . . . . . . . . . . . 47 4.3.2 Projet File Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 4.3.3 Règles de construction par défaut du système de compilation . . . . . . . . . . . . . 50 4.3.4 Introduction au script de compilation . . . . . . . . . . . . . . . . . . 51 4.3.5 Introduction aux commandes courantes . . . . . . . . . . . . . . . . . . . 52 4.4 Pratique : Compiler Example programme « Blink » . . . . . . . . . . . . . . . . . . 53 4.4.1 Exampl'Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 4.4.2 Compilation du programme Blink . . . . . . . . . . . . . . . . . . . . . . . 56 4.4.3 Flasher le programme Blink . . . . . . . . . . . . . . . . . . . . . . . . 59 4.4.4 Analyse du journal du port série du programme Blink . . . . . . . . . . . . . . 60 4.5 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

II Développement de matériel et de pilotes

5 Conception matérielle des produits Smart Light basés sur ESP32-C3

5.1 Caractéristiques et composition des produits Smart Light . . . . . . . . . . . . . . . 67

5.2 Conception matérielle du système central ESP32-C3 . . . . . . . . . . . . . . . . . . . 70

5.2.1 Alimentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

5.2.2 Séquence de mise sous tension et réinitialisation du système . . . . . . . . . . . . . . . . . . 74

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

5.2.4 Source d'horloge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

5.2.5 RF et antenne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

5.2.6 Goupilles de cerclage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

5.2.7 Contrôleur GPIO et PWM . . . . . . . . . . . . . . . . . . . . . . . . . 79

5.3 Pratique : Construire un système d'éclairage intelligent avec ESP32-C3. . . . . . . . . . . . . 80

5.3.1 Sélection des modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

5.3.2 Configuration des GPIO des signaux PWM . . . . . . . . . . . . . . . . . . . . 82

5.3.3 Téléchargement du micrologiciel et de l'interface de débogage . . . . . . . . . . . . 82

5.3.4 Lignes directrices pour la conception RF . . . . . . . . . . . . . . . . . . . . . . . . . . 84 5.3.5 Directives pour la conception de l'alimentation électrique . . . . . . . . . . . . . . . . . . . 86 5.4 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

6 Développement de pilotes

6.1 Processus de développement des pilotes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

6.2 Applications périphériques ESP32-C3 . . . . . . . . . . . . . . . . . . . . . . . . . 88

6.3 Bases du pilote LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

6.3.1 Espaces colorimétriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

6.3.2 Pilote LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

6.3.3 Gradation des LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

6.3.4 Introduction à la MLI . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

6.4 Développement de pilotes de gradation LED . . . . . . . . . . . . . . . . . . . . . . . . 96

6.4.1 Stockage non volatile (NVS) . . . . . . . . . . . . . . . . . . . . . . . . 97

6.4.2 Contrôleur PWM LED (LEDC) . . . . . . . . . . . . . . . . . . . . . . . 98

6.4.3 Programmation PWM des LED . . . . . . . . . . . . . . . . . . . . . . . . . . 100

6.5 Pratique : ajout de pilotes au projet Smart Light . . . . . . . . . . . . . . . . . 103

6.5.1 Pilote de bouton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

6.5.2 Pilote de gradation LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

6.6 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

III Communication et contrôle sans fil

109

7 Configuration et connexion Wi-Fi

111

7.1 Bases du Wi-Fi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

7.1.1 Introduction au Wi-Fi . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

7.1.2 Évolution de la norme IEEE 802.11 . . . . . . . . . . . . . . . . . . . . . . . . . 111

7.1.3 Concepts Wi-Fi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

7.1.4 Connexion Wi-Fi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

7.2 Notions de base du Bluetooth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

7.2.1 Introduction au Bluetooth . . . . . . . . . . . . . . . . . . . . . . . . . 123

7.2.2 Notions Bluetooth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

7.2.3 Connexion Bluetooth . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

7.3 Configuration du réseau Wi-Fi . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

7.3.1 Guide de configuration du réseau Wi-Fi . . . . . . . . . . . . . . . . . . . . 131

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

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

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

7.3.5 Autres méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

7.4 Programmation Wi-Fi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 7.4.1 Composants Wi-Fi dans ESP-IDF . . . . . . . . . . . . . . . . . . . . . . . 139 7.4.2 Exercice : Connexion Wi-Fi . . . . . . . . . . . . . . . . . . . . . . . . 141 7.4.3 Exercice : Connexion Wi-Fi intelligente . . . . . . . . . . . . . . . . . . . . . 145
7.5 Pratique : configuration Wi-Fi dans le projet Smart Light . . . . . . . . . . . . . . . 156 7.5.1 Connexion Wi-Fi dans le projet Smart Light . . . . . . . . . . . . . . . . . 156 7.5.2 Configuration du Wi-Fi intelligent . . . . . . . . . . . . . . . . . . . . . . . . . 157
7.6 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

8 Contrôle local

159

8.1 Introduction au contrôle local . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

8.1.1 Application du contrôle local . . . . . . . . . . . . . . . . . . . . . . . . 161

Advan 8.1.2tages de Contrôle Local . . . . . . . . . . . . . . . . . . . . . . . . 161

8.1.3 Découverte des appareils contrôlés via les smartphones . . . . . . . . . . 161

8.1.4 Communication de données entre smartphones et appareils . . . . . . . . 162

8.2 Méthodes courantes de découverte locale . . . . . . . . . . . . . . . . . . . . . . . . 162

8.2.1 Diffusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

8.2.2 Multidiffusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169

8.2.3 Comparaison entre diffusion et multidiffusion . . . . . . . . . . . . . . 176

8.2.4 Protocole d'application multicast mDNS pour la découverte locale . . . . . . . . 176

8.3 Protocoles de communication communs pour les données locales . . . . . . . . . . . . . . . 179

8.3.1 Protocole de contrôle de transmission (TCP) . . . . . . . . . . . . . . . . . . . 179

8.3.2 Protocole de transfert hypertexte (HTTP) . . . . . . . . . . . . . . . . . . . 185

8.3.3 Données utilisateurtagProtocole RAM (UDP) . . . . . . . . . . . . . . . . . . . . . . 189

8.3.4 Protocole d'application contraint (CoAP) . . . . . . . . . . . . . . . . 192

8.3.5 Protocole Bluetooth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

8.3.6 Résumé des protocoles de communication de données . . . . . . . . . . . . . . . 203

8.4 Garantie de sécurité des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205

8.4.1 Introduction à la sécurité de la couche transport (TLS) . . . . . . . . . . . . . 207

8.4.2 Introduction à DatagRAM Transport Layer Security (DTLS) . . . . . . . 213

8.5 Pratique : Contrôle local dans le projet Smart Light . . . . . . . . . . . . . . . . . . 217

8.5.1 Création d'un serveur de contrôle local basé sur Wi-Fi . . . . . . . . . . . . . . . 217

8.5.2 Vérification de la fonctionnalité de contrôle local à l'aide de scripts . . . . . . . . . . . 221

8.5.3 Création d'un serveur de contrôle local basé sur Bluetooth . . . . . . . . . . . . 222

8.6 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224

9 contrôle du nuage

225

9.1 Introduction à la télécommande . . . . . . . . . . . . . . . . . . . . . . . . . . 225

9.2 Protocoles de communication de données cloud . . . . . . . . . . . . . . . . . . . . . . 226

9.2.1 Introduction à MQTT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226 9.2.2 Principes MQTT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227 9.2.3 Format des messages MQTT . . . . . . . . . . . . . . . . . . . . . . . . . . 228 9.2.4 Comparaison des protocoles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 9.2.5 Configuration de MQTT Broker sous Linux et Windows . . . . . . . . . . . . 233 9.2.6 Configuration du client MQTT basé sur ESP-IDF . . . . . . . . . . . . . . . . 235 9.3 Assurer la sécurité des données MQTT . . . . . . . . . . . . . . . . . . . . . . . . . . . 237 9.3.1 Signification et fonction des certificats . . . . . . . . . . . . . . . . . . . 237 9.3.2 Génération locale de certificats . . . . . . . . . . . . . . . . . . . . . . 239 9.3.3 Configuration du courtier MQTT . . . . . . . . . . . . . . . . . . . . . . . . . 241 9.3.4 Configuration du client MQTT . . . . . . . . . . . . . . . . . . . . . . . . . 241 9.4 Pratique : Contrôle à distance via ESP RainMaker . . . . . . . . . . . . . . . . 243 9.4.1 Notions de base d'ESP RainMaker . . . . . . . . . . . . . . . . . . . . . . . . . . . 243 9.4.2 Protocole de communication back-end de nœud et de cloud . . . . . . . . . . . 244 9.4.3 Communication entre le client et le backend cloud . . . . . . . . . . . 249 9.4.4 Rôles utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252 9.4.5 Services de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253 9.4.6 Éclairage intelligent Example. . . . . . . . . . . . . . . . . . . . . . . . . . . . 255 9.4.7 Application RainMaker et intégrations tierces . . . . . . . . . . . . . . . 262 9.5 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267

10 Développement d'applications pour smartphones

269

10.1 Introduction au développement d'applications pour smartphone . . . . . . . . . . . . . . . . . . 269

10.1.1 Plus deview du développement d'applications pour smartphones. . . . . . . . . . . . . . . 270

10.1.2 Structure du projet Android . . . . . . . . . . . . . . . . . . . . . . 270

10.1.3 Structure du projet iOS . . . . . . . . . . . . . . . . . . . . . . . . 271

10.1.4 Cycle de vie d'une activité Android . . . . . . . . . . . . . . . . . . . . . . 272

10.1.5 Cycle de vie d'iOS ViewManette . . . . . . . . . . . . . . . . . . . . . . 273

10.2 Création d'un nouveau projet d'application pour smartphone . . . . . . . . . . . . . . . . . . . . . 275

10.2.1 Préparation au développement Android . . . . . . . . . . . . . . . . . . . 275

10.2.2 Création d'un nouveau projet Android . . . . . . . . . . . . . . . . . . . . . . 275

10.2.3 Ajout de dépendances pour MyRainmaker . . . . . . . . . . . . . . . . . 276

10.2.4 Demande d'autorisation sous Android . . . . . . . . . . . . . . . . . . . . . . 277

10.2.5 Préparation au développement iOS . . . . . . . . . . . . . . . . . . . . . . 277

10.2.6 Création d'un nouveau projet iOS . . . . . . . . . . . . . . . . . . . . . . . . 278

10.2.7 Ajout de dépendances pour MyRainmaker . . . . . . . . . . . . . . . . . 279

10.2.8 Demande d'autorisation dans iOS . . . . . . . . . . . . . . . . . . . . . . . . . 280

10.3 Analyse des exigences fonctionnelles de l'application. . . . . . . . . . . . . . . . . . 281

10.3.1 Analyse des exigences fonctionnelles du projet . . . . . . . . . . . . 282

10.3.2 Analyse des exigences de gestion des utilisateurs . . . . . . . . . . . . . . . 282 10.3.3 Analyse de l'approvisionnement des appareils et des exigences de liaison . . . . . . . 283 10.3.4 Analyse des besoins en matière de télécommande . . . . . . . . . . . . . . . . 283 10.3.5 Analyse des exigences de planification . . . . . . . . . . . . . . . . . . . 284 10.3.6 Analyse des exigences du centre utilisateur . . . . . . . . . . . . . . . . . . 285 10.4 Développement de la gestion des utilisateurs . . . . . . . . . . . . . . . . . . . . . . . . 285 10.4.1 Introduction aux API RainMaker . . . . . . . . . . . . . . . . . . . . . . 285 10.4.2 Initier la communication via un smartphone . . . . . . . . . . . . . . . . 286 10.4.3 Enregistrement du compte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286 10.4.4 Connexion au compte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 10.5 Développement du provisionnement des appareils . . . . . . . . . . . . . . . . . . . . . . . 292 10.5.1 Périphériques de numérisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293 10.5.2 Connexion d'appareils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295 10.5.3 Génération de clés secrètes . . . . . . . . . . . . . . . . . . . . . . . . . . . 298 10.5.4 Obtention de l'ID du nœud . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298 10.5.5 Approvisionnement des périphériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300 10.6 Développement du contrôle des appareils . . . . . . . . . . . . . . . . . . . . . . . . . . 302 10.6.1 Liaison d'appareils à des comptes cloud . . . . . . . . . . . . . . . . . . . . 303 10.6.2 Obtenir une liste de périphériques . . . . . . . . . . . . . . . . . . . . . . . . . . 305 10.6.3 Obtenir l'état du périphérique . . . . . . . . . . . . . . . . . . . . . . . . . . . 308 10.6.4 Modification de l'état de l'appareil . . . . . . . . . . . . . . . . . . . . . . . . . . 310 10.7 Développement de la planification et du centre utilisateur . . . . . . . . . . . . . . . . . . . 313 10.7.1 Implémentation de la fonction de planification . . . . . . . . . . . . . . . . . . . . 313 10.7.2 Implémentation du Centre utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . 315 10.7.3 Plus d'API Cloud . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318 10.8 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319

11 Mise à niveau du micrologiciel et gestion des versions

321

11.1 Mise à niveau du micrologiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321

11.1.1 Plus deview des tables de partition . . . . . . . . . . . . . . . . . . . . . . . . 322

11.1.2 Processus de démarrage du micrologiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . 324

11.1.3 Plus deview du mécanisme OTA. . . . . . . . . . . . . . . . . . . . . 326

11.2 Gestion des versions du micrologiciel . . . . . . . . . . . . . . . . . . . . . . . . . . 329

11.2.1 Marquage du micrologiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329

11.2.2 Rollback et Anti-Rollback . . . . . . . . . . . . . . . . . . . . . . . . 331

11.3 Pratique : Ex en direct (OTA)ample. . . . . . . . . . . . . . . . . . . . . . . 332

11.3.1 Mise à niveau du micrologiciel via un hôte local. . . . . . . . . . . . . . . . . 332

11.3.2 Mise à niveau du micrologiciel via ESP RainMaker. . . . . . . . . . . . . . . 335

11.4 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342

IV Optimisation et production de masse

343

12 Gestion de l'alimentation et optimisation basse consommation

345

12.1 Gestion de l'alimentation ESP32-C3 . . . . . . . . . . . . . . . . . . . . . . . . . . . 345

12.1.1 Mise à l'échelle dynamique de la fréquence . . . . . . . . . . . . . . . . . . . . . . . . 346

12.1.2 Configuration de la gestion de l'alimentation . . . . . . . . . . . . . . . . . . . . 348

12.2 Mode faible consommation ESP32-C3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348

12.2.1 Mode veille du modem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349

12.2.2 Mode veille légère . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351

12.2.3 Mode veille profonde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356

12.2.4 Consommation de courant dans différents modes d'alimentation . . . . . . . . . . . . . 358

12.3 Gestion de l'alimentation et débogage basse consommation . . . . . . . . . . . . . . . . . 359

12.3.1 Débogage des journaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360

12.3.2 Débogage GPIO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362

12.4 Pratique : Gestion de l'énergie dans le projet Smart Light . . . . . . . . . . . . . . . 363

12.4.1 Configuration de la fonctionnalité de gestion de l'alimentation . . . . . . . . . . . . . . . . . 364

12.4.2 Utiliser les verrous de gestion de l'alimentation . . . . . . . . . . . . . . . . . . . . . . 365

12.4.3 Vérification de la consommation électrique . . . . . . . . . . . . . . . . . . . . . . . 366

12.5 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367

13 Fonctionnalités améliorées de sécurité des appareils

369

13.1 Plus deview de la sécurité des données des appareils IoT. . . . . . . . . . . . . . . . . . . . . . . 369

13.1.1 Pourquoi sécuriser les données des appareils IoT ? . . . . . . . . . . . . . . . . . . . . . . 370

13.1.2 Exigences de base pour la sécurité des données des appareils IoT. . . . . . . . . . . . 371

13.2 Protection de l'intégrité des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372

13.2.1 Introduction à la méthode de vérification de l'intégrité . . . . . . . . . . . . . . 372

13.2.2 Vérification de l'intégrité des données du micrologiciel . . . . . . . . . . . . . . . . . . 373

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

13.3 Protection de la confidentialité des données . . . . . . . . . . . . . . . . . . . . . . . . . . 374

13.3.1 Introduction au cryptage des données . . . . . . . . . . . . . . . . . . . . . . 374

13.3.2 Introduction au schéma de chiffrement Flash . . . . . . . . . . . . . . . . . 376

13.3.3 Stockage de la clé de chiffrement Flash . . . . . . . . . . . . . . . . . . . . . . . 379

13.3.4 Mode de fonctionnement du cryptage Flash . . . . . . . . . . . . . . . . . . . . 380

13.3.5 Processus de cryptage Flash . . . . . . . . . . . . . . . . . . . . . . . . . . 381

13.3.6 Introduction au chiffrement NVS . . . . . . . . . . . . . . . . . . . . . . 383

13.3.7 Exampfichiers de chiffrement Flash et de chiffrement NVS. . . . . . . . . . . 384

13.4 Protection de la légitimité des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386

13.4.1 Introduction à la signature numérique . . . . . . . . . . . . . . . . . . . . . 386

13.4.2 Plus deview du schéma de démarrage sécurisé. . . . . . . . . . . . . . . . . . . . . 388

13.4.3 Introduction au démarrage sécurisé du logiciel . . . . . . . . . . . . . . . . . . . 388 13.4.4 Introduction au démarrage sécurisé matériel . . . . . . . . . . . . . . . . . . 390 13.4.5 Examples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394 13.5 Pratique : fonctionnalités de sécurité dans la production de masse . . . . . . . . . . . . . . . . . . 396 13.5.1 Chiffrement Flash et démarrage sécurisé . . . . . . . . . . . . . . . . . . . . . 396 13.5.2 Activation du cryptage Flash et du démarrage sécurisé avec Batch Flash Tools . . 397 13.5.3 Activation du cryptage Flash et du démarrage sécurisé dans le projet Smart Light . . . 398 13.6 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398

14 Gravure et tests de micrologiciels pour la production de masse

399

14.1 Gravure de micrologiciels en production de masse . . . . . . . . . . . . . . . . . . . . . . 399

14.1.1 Définition des partitions de données . . . . . . . . . . . . . . . . . . . . . . . . . . 399

14.1.2 Gravure du micrologiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402

14.2 Tests de production de masse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403

14.3 Pratique : Données de production de masse dans le projet Smart Light . . . . . . . . . . . . . 404

14.4 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404

15 ESP Insights : plateforme de surveillance à distance

405

15.1 Introduction à ESP Insights. . . . . . . . . . . . . . . . . . . . . . . . . . . . 405

15.2 Premiers pas avec ESP Insights . . . . . . . . . . . . . . . . . . . . . . . . . 409

15.2.1 Premiers pas avec ESP Insights dans le projet esp-insights . . . . . . 409

15.2.2 Exécution d'Exampfichier dans le projet esp-insights . . . . . . . . . . . . . . . 411

15.2.3 Rapport des informations de vidage de mémoire . . . . . . . . . . . . . . . . . . . . . 411

15.2.4 Personnalisation des journaux d'intérêt . . . . . . . . . . . . . . . . . . . . . . . . 412

15.2.5 Signalement du motif du redémarrage . . . . . . . . . . . . . . . . . . . . . . . . . 413

15.2.6 Rapports de métriques personnalisées . . . . . . . . . . . . . . . . . . . . . . . . . 413

15.3 Pratique : Utilisation d'ESP Insights dans le projet Smart Light . . . . . . . . . . . . . . . 416

15.4 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417

Introduction
ESP32-C3 est un SoC à microcontrôleur Wi-Fi et Bluetooth 5 (LE) monocœur, basé sur l'architecture open source RISC-V. Il offre le juste équilibre entre puissance, capacités d'E/S et sécurité, offrant ainsi la solution optimale et rentable pour les appareils connectés. Pour montrer diverses applications de la famille ESP32-C3, ce livre d'Espressif vous emmènera dans un voyage intéressant à travers l'AIoT, depuis les bases du développement de projets IoT et de la configuration de l'environnement jusqu'aux exemples pratiques.amples. Les quatre premiers chapitres parlent de l'IoT, d'ESP RainMaker et d'ESP-IDF. Les chapitres 5 et 6 présentent la conception matérielle et le développement de pilotes. Au fur et à mesure de votre progression, vous découvrirez comment configurer votre projet via les réseaux Wi-Fi et les applications mobiles. Enfin, vous apprendrez à optimiser votre projet et à le mettre en production en série.
Si vous êtes un ingénieur dans des domaines connexes, un architecte logiciel, un enseignant, un étudiant ou toute personne intéressée par l'IoT, ce livre est fait pour vous.
Vous pouvez télécharger le code example utilisé dans ce livre depuis le site d’Espressif sur GitHub. Pour les dernières informations sur le développement de l’IoT, veuillez suivre notre compte officiel.

Préface
Un monde qui s'informatise
Surfant sur la vague d'Internet, l'Internet des objets (IoT) a fait ses grands débuts pour devenir un nouveau type d'infrastructure dans l'économie numérique. Pour rapprocher la technologie du public, Espressif Systems œuvre pour la vision selon laquelle les développeurs de tous horizons peuvent utiliser l'IoT pour résoudre certains des problèmes les plus urgents de notre époque. Un monde de « réseau intelligent de toutes choses », c’est ce que nous attendons de l’avenir.
La conception de nos propres puces constitue un élément essentiel de cette vision. Il s’agit d’un marathon exigeant des avancées constantes contre les frontières technologiques. Du « Game Changer » ESP8266 à la série ESP32 intégrant la connectivité Wi-Fi et Bluetoothr (LE), suivi de l'ESP32-S3 équipé de l'accélération IA, Espressif ne cesse de rechercher et de développer des produits pour les solutions AIoT. Avec nos logiciels open source, tels que IoT Development Framework ESP-IDF, Mesh Development Framework ESP-MDF et Device Connectivity Platform ESP RainMaker, nous avons créé un cadre indépendant pour créer des applications AIoT.
En juillet 2022, les expéditions cumulées de chipsets IoT d’Espressif dépassaient les 800 millions, leader sur le marché des MCU Wi-Fi et alimentant un grand nombre d’appareils connectés dans le monde. La recherche de l'excellence fait de chaque produit Espressif un grand succès pour son haut niveau d'intégration et sa rentabilité. La sortie de l’ESP32-C3 marque une étape importante dans la technologie développée par Espressif. Il s'agit d'un MCU monocœur 32 bits basé sur RISC-V avec 400 Ko de SRAM, qui peut fonctionner à 160 MHz. Il intègre le Wi-Fi 2.4 GHz et le Bluetooth 5 (LE) avec un support longue portée. Il offre un équilibre subtil entre puissance, capacités d'E/S et sécurité, offrant ainsi la solution optimale et rentable pour les appareils connectés. Basé sur un ESP32-C3 aussi puissant, ce livre est destiné à aider les lecteurs à comprendre les connaissances liées à l'IoT avec des illustrations détaillées et des exemples pratiques.amples.
Pourquoi avons-nous écrit ce livre ?
Espressif Systems est plus qu'une entreprise de semi-conducteurs. C'est également une société de plateforme IoT, qui s'efforce toujours de réaliser des percées et des innovations dans le domaine de la technologie. Dans le même temps, Espressif a open source et partagé son système d'exploitation et son cadre logiciel auto-développés avec la communauté, formant ainsi un écosystème unique. Les ingénieurs, les créateurs et les passionnés de technologie développent activement de nouvelles applications logicielles basées sur les produits Espressif, communiquent librement et partagent leur expérience. Vous pouvez voir à tout moment les idées fascinantes des développeurs sur diverses plateformes, telles que YouTube et GitHub. La popularité des produits Espressif a stimulé un nombre croissant d’auteurs qui ont produit plus de 100 livres basés sur les chipsets Espressif, dans plus de dix langues, dont l’anglais, le chinois, l’allemand, le français et le japonais.

C’est le soutien et la confiance des partenaires communautaires qui encouragent l’innovation continue d’Espressif. « Nous nous efforçons de rendre nos puces, nos systèmes d’exploitation, nos frameworks, nos solutions, notre Cloud, nos pratiques commerciales, nos outils, notre documentation, nos écrits, nos idées, etc. toujours plus pertinents par rapport aux réponses dont les gens ont besoin face aux problèmes les plus urgents de la vie contemporaine. C’est la plus haute ambition et la boussole morale d’Espressif. a déclaré M. Teo Swee Ann, fondateur et PDG d'Espressif.
Espressif valorise la lecture et les idées. Alors que la mise à niveau continue de la technologie IoT impose des exigences plus élevées aux ingénieurs, comment pouvons-nous aider davantage de personnes à maîtriser rapidement les puces IoT, les systèmes d'exploitation, les cadres logiciels, les schémas d'application et les produits de services cloud ? Comme le dit le proverbe, il vaut mieux apprendre à pêcher à un homme que de lui donner du poisson. Lors d'une séance de brainstorming, nous avons pensé que nous pourrions écrire un livre pour trier systématiquement les connaissances clés du développement de l'IoT. Nous nous sommes bien entendus, avons rapidement rassemblé un groupe d'ingénieurs senior et avons combiné l'expérience de l'équipe technique en programmation embarquée, en développement de matériel et de logiciels IoT, contribuant ainsi à la publication de ce livre. Au cours du processus d'écriture, nous avons fait de notre mieux pour être objectifs et justes, débarrassés du cocon, et utiliser des expressions concises pour raconter la complexité et le charme de l'Internet des objets. Nous avons soigneusement résumé les questions courantes, fait référence aux commentaires et suggestions de la communauté, afin de répondre clairement aux questions rencontrées dans le processus de développement et de fournir des directives pratiques de développement de l'IoT aux techniciens et décideurs concernés.
Structure du livre
Ce livre adopte une perspective centrée sur l'ingénieur et expose étape par étape les connaissances nécessaires au développement de projets IoT. Il est composé de quatre parties, comme suit :
· Préparation (Chapitre 1) : Cette partie présente l'architecture de l'IoT, le cadre typique du projet IoT, la plate-forme cloud ESP RainMakerr et l'environnement de développement ESP-IDF, afin de jeter une base solide pour le développement de projets IoT.
· Développement du matériel et des pilotes (Chapitre 5) : Basée sur le chipset ESP6-C32, cette partie développe le système matériel minimum et le développement des pilotes, et implémente le contrôle de la gradation, de l'étalonnage des couleurs et de la communication sans fil.
· Communication et contrôle sans fil (Chapitre 7) : Cette partie explique le schéma de configuration Wi-Fi intelligent basé sur la puce ESP11-C32, les protocoles de contrôle local et cloud et le contrôle local et à distance des appareils. Il fournit également des schémas pour le développement d'applications pour smartphone, la mise à niveau du micrologiciel et la gestion des versions.
· Optimisation et production de masse (chapitres 12-15) : cette partie est destinée aux applications IoT avancées, en se concentrant sur l'optimisation des produits en matière de gestion de l'énergie, d'optimisation de faible consommation et de sécurité renforcée. Il présente également la gravure et les tests du micrologiciel en production de masse, ainsi que la façon de diagnostiquer l'état de fonctionnement et les journaux du micrologiciel de l'appareil via la plateforme de surveillance à distance ESP Insights.

À propos du code source
Les lecteurs peuvent exécuter l'examples programmes de ce livre, soit en saisissant le code manuellement, soit en utilisant le code source qui accompagne le livre. Nous mettons l'accent sur la combinaison de la théorie et de la pratique et proposons ainsi une section pratique basée sur le projet Smart Light dans presque chaque chapitre. Tous les codes sont open source. Les lecteurs sont invités à télécharger le code source et à en discuter dans les sections liées à ce livre sur GitHub et sur notre forum officiel esp32.com. Le code open source de ce livre est soumis aux termes de la licence Apache 2.0.
Note de l'auteur
Ce livre est officiellement produit par Espressif Systems et est rédigé par les ingénieurs principaux de l'entreprise. Il convient aux gestionnaires et au personnel de R&D des industries liées à l'IoT, aux enseignants et aux étudiants des disciplines connexes, ainsi qu'aux passionnés du domaine de l'Internet des objets. Nous espérons que ce livre pourra servir de manuel de travail, de référence et de livre de chevet, pour être comme un bon tuteur et ami.
Lors de la rédaction de ce livre, nous avons fait référence à certains résultats de recherche pertinents d'experts, d'universitaires et de techniciens nationaux et étrangers, et nous avons fait de notre mieux pour les citer conformément aux normes académiques. Cependant, il est inévitable qu'il y ait quelques omissions, c'est pourquoi nous souhaitons ici exprimer notre profond respect et notre gratitude à tous les auteurs concernés. De plus, nous avons cité des informations provenant d'Internet, nous souhaitons donc remercier les auteurs et éditeurs originaux et nous excuser de ne pas pouvoir indiquer la source de chaque élément d'information.
Afin de produire un livre de haute qualité, nous avons organisé des séries de discussions internes et tiré les leçons des suggestions et des commentaires des lecteurs d'essai et des éditeurs. Ici, nous tenons à vous remercier encore une fois pour votre aide qui a toutes contribué à la réussite de ce travail.
Dernier point, mais le plus important, merci à tout le monde chez Espressif qui a travaillé si dur pour la naissance et la popularisation de nos produits.
Le développement de projets IoT implique un large éventail de connaissances. Limitées à la longueur du livre, ainsi qu'au niveau et à l'expérience de l'auteur, les omissions sont inévitables. C’est pourquoi nous demandons aux experts et aux lecteurs de critiquer et de corriger nos erreurs. Si vous avez des suggestions pour ce livre, veuillez nous contacter à book@espressif.com. Nous attendons avec impatience vos commentaires.

Comment utiliser ce livre?
Le code des projets de ce livre est open source. Vous pouvez le télécharger depuis notre référentiel GitHub et partager vos réflexions et questions sur notre forum officiel. GitHub : https://github.com/espressif/book-esp32c3-iot-projects Forum : https://www.esp32.com/bookc3 Tout au long du livre, certaines parties seront mises en évidence comme indiqué ci-dessous.
Code source Dans ce livre, nous mettons l'accent sur la combinaison de la théorie et de la pratique, et avons ainsi créé une section pratique sur le projet Smart Light dans presque chaque chapitre. Les étapes correspondantes et la page source seront marquées entre deux lignes commençant par le tag Code source.
REMARQUE/CONSEILS C'est ici que vous pouvez trouver des informations critiques et des rappels pour déboguer avec succès votre programme. Ils seront marqués entre deux traits épais commençant par le tag REMARQUE ou CONSEILS.
La plupart des commandes de ce livre sont exécutées sous Linux, signalées par le caractère « $ ». Si la commande nécessite des privilèges de superutilisateur pour s'exécuter, l'invite sera remplacée par « # ». L'invite de commande sur les systèmes Mac est « % », tel qu'utilisé dans la section 4.2.3 Installation d'ESP-IDF sur Mac.
Le corps du texte de ce livre sera imprimé en Charte, tandis que le code exampfichiers, composants, fonctions, variables, code file les noms, les répertoires de codes et les chaînes seront dans Courier New.
Les commandes ou les textes qui doivent être saisis par l'utilisateur et les commandes qui peuvent être saisies en appuyant sur la touche « Entrée » seront imprimés en Courier New gras. Les journaux et les blocs de code seront présentés dans des cases bleu clair.
Example:
Deuxièmement, utilisez esp-idf/components/nvs flash/nvs partition Generator/nvs partition gen.py pour générer le binaire de partition NVS. file sur l'hôte de développement avec la commande suivante :
$ python $IDF PATH/components/nvs flash/générateur de partition nvs/nvs partition gen.py –input mass prod.csv –output mass prod.bin –size TAILLE DE LA PARTITION NVS

Chapitre 1

Introduction

IoT

À la fin du XXe siècle, avec l’essor des réseaux informatiques et des technologies de communication, Internet s’est rapidement intégré dans la vie des gens. Alors que la technologie Internet continue de mûrir, l’idée de l’Internet des objets (IoT) est née. Littéralement, l’IoT désigne un Internet où les objets sont connectés. Alors que l’Internet original brise les limites de l’espace et du temps et réduit la distance entre « personne à personne », l’IoT fait des « choses » un acteur important, rapprochant les « personnes » et les « choses ». Dans un avenir proche, l’IoT est appelé à devenir le moteur de l’industrie de l’information.
Alors, qu'est-ce que l'Internet des objets ?
Il est difficile de définir avec précision l’Internet des objets, car sa signification et sa portée évoluent constamment. En 1995, Bill Gates a évoqué pour la première fois l’idée de l’IoT dans son livre The Road Ahead. En termes simples, l'IoT permet aux objets d'échanger des informations entre eux via Internet. Son objectif ultime est d’établir un « Internet de tout ». Il s’agit d’une première interprétation de l’IoT, ainsi que d’un fantasme de la technologie future. Trente ans plus tard, avec le développement rapide de l’économie et de la technologie, ce fantasme devient réalité. Des appareils intelligents, des maisons intelligentes, des villes intelligentes, de l'Internet des véhicules et des appareils portables, au « métaverse » soutenu par les technologies IoT, de nouveaux concepts émergent constamment. Dans ce chapitre, nous commencerons par une explication de l'architecture de l'Internet des objets, puis présenterons l'application IoT la plus courante, la maison intelligente, afin de vous aider à bien comprendre l'IoT.
1.1 Architecture de l'IoT
L'Internet des objets implique plusieurs technologies qui ont des besoins et des formes d'application différents dans différents secteurs. Afin de comprendre la structure, les technologies clés et les caractéristiques des applications de l’IoT, il est nécessaire d’établir une architecture unifiée et un système technique standard. Dans ce livre, l'architecture de l'IoT est simplement divisée en quatre couches : couche de perception et de contrôle, couche réseau, couche plate-forme et couche application.
Couche de perception et de contrôle En tant qu'élément le plus fondamental de l'architecture IoT, la couche de perception et de contrôle est au cœur de la réalisation de la détection complète de l'IoT. Sa fonction principale est de collecter, d'identifier et de contrôler les informations. Il se compose d'une variété d'appareils dotés de capacités de perception,
3

l'identification, le contrôle et l'exécution, et est responsable de la récupération et de l'analyse des données telles que les propriétés des matériaux, les tendances comportementales et l'état de l'appareil. De cette façon, l’IoT parvient à reconnaître le monde physique réel. En outre, la couche est également capable de contrôler l’état de l’appareil.
Les dispositifs les plus courants de cette couche sont divers capteurs, qui jouent un rôle important dans la collecte et l'identification des informations. Les capteurs sont comme les organes sensoriels humains, tels que les capteurs photosensibles équivalents à la vision, les capteurs acoustiques à l'audition, les capteurs de gaz à l'odorat et les capteurs sensibles à la pression et à la température au toucher. Avec tous ces « organes sensoriels », les objets deviennent « vivants » et capables de perception, de reconnaissance et de manipulation intelligentes du monde physique.
Couche réseau La fonction principale de la couche réseau est de transmettre des informations, y compris les données obtenues de la couche de perception et de contrôle à une cible spécifiée, ainsi que les commandes émises par la couche application vers la couche de perception et de contrôle. Il constitue un pont de communication important reliant les différentes couches d'un système IoT. Pour mettre en place un modèle de base de l'Internet des objets, l'intégration d'objets dans un réseau implique deux étapes : l'accès à Internet et la transmission via Internet.
L'accès à Internet Internet permet l'interconnexion entre les individus, mais ne parvient pas à intégrer les choses dans la grande famille. Avant l’avènement de l’IoT, la plupart des choses n’étaient pas « connectables en réseau ». Grâce au développement continu de la technologie, l'IoT parvient à connecter les objets à Internet, réalisant ainsi l'interconnexion entre « les personnes et les choses » et « les choses et les choses ». Il existe deux manières courantes de mettre en œuvre une connexion Internet : l'accès au réseau filaire et l'accès au réseau sans fil.
Les méthodes d'accès au réseau filaire incluent Ethernet, la communication série (par exemple, RS-232, RS-485) et USB, tandis que l'accès au réseau sans fil dépend de la communication sans fil, qui peut être divisée en communication sans fil à courte portée et communication sans fil à longue portée.
La communication sans fil à courte portée comprend ZigBee, Bluetoothr, Wi-Fi, Near-Field Communication (NFC) et l'identification par radiofréquence (RFID). La communication sans fil à longue portée comprend la communication améliorée de type machine (eMTC), LoRa, l'Internet des objets à bande étroite (NB-IoT), la 2G, la 3G, la 4G, la 5G, etc.
Transmission via Internet Différentes méthodes d'accès à Internet conduisent à un lien physique de transmission de données correspondant. La prochaine étape consiste à décider quel protocole de communication utiliser pour transmettre les données. Par rapport aux terminaux Internet, la plupart des terminaux IoT ont actuellement moins
4 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

ressources disponibles, telles que les performances de traitement, la capacité de stockage, le débit du réseau, etc., il est donc nécessaire de choisir un protocole de communication qui occupe moins de ressources dans les applications IoT. Il existe deux protocoles de communication largement utilisés aujourd'hui : Message Queuing Telemetry Transport (MQTT) et Constrained Application Protocol (CoAP).
Couche plate-forme La couche plate-forme fait principalement référence aux plates-formes cloud IoT. Lorsque tous les terminaux IoT sont mis en réseau, leurs données doivent être regroupées sur une plateforme cloud IoT pour être calculées et stockées. La couche plate-forme prend principalement en charge les applications IoT pour faciliter l'accès et la gestion d'appareils massifs. Il connecte les terminaux IoT à la plateforme cloud, collecte les données des terminaux et émet des commandes aux terminaux, afin de mettre en œuvre le contrôle à distance. En tant que service intermédiaire pour attribuer des équipements aux applications industrielles, la couche plate-forme joue un rôle de connexion dans l'ensemble de l'architecture IoT, transportant une logique métier abstraite et un modèle de données de base standardisé, qui peuvent non seulement permettre un accès rapide aux appareils, mais également fournir de puissantes capacités modulaires. pour répondre à divers besoins dans les scénarios d'application industrielle. La couche plate-forme comprend principalement des modules fonctionnels tels que l'accès aux appareils, la gestion des appareils, la gestion de la sécurité, la communication des messages, la surveillance de l'exploitation et de la maintenance, ainsi que les applications de données.
· Accès aux appareils, réalisant la connexion et la communication entre les terminaux et les plateformes cloud IoT.
· Gestion des appareils, y compris des fonctions telles que la création d'appareils, la maintenance des appareils, la conversion de données, la synchronisation des données et la distribution des appareils.
· Gestion de la sécurité, garantissant la sécurité de la transmission des données IoT du point de vue de l'authentification de sécurité et de la sécurité des communications.
· Communication de messages, comprenant trois directions de transmission, c'est-à-dire que le terminal envoie des données à la plate-forme cloud IoT, la plate-forme cloud IoT envoie des données au côté serveur ou à d'autres plates-formes cloud IoT, et le côté serveur contrôle à distance les appareils IoT.
· Surveillance de l'exploitation et de la maintenance, impliquant la surveillance et le diagnostic, la mise à niveau du micrologiciel, le débogage en ligne, les services de journalisation, etc.
· Applications de données, impliquant le stockage, l'analyse et l'application de données.
Couche application La couche application utilise les données de la couche plate-forme pour gérer l'application, en les filtrant et en les traitant avec des outils tels que des bases de données et des logiciels d'analyse. Les données obtenues peuvent être utilisées pour des applications IoT du monde réel telles que les soins de santé intelligents, l'agriculture intelligente, les maisons intelligentes et les villes intelligentes.
Bien entendu, l’architecture de l’IoT peut être subdivisée en plusieurs couches, mais quel que soit le nombre de couches qui la composent, le principe sous-jacent reste essentiellement le même. Apprentissage
Chapitre 1. Introduction à IoT 5

sur l'architecture de l'IoT nous aide à approfondir notre compréhension des technologies IoT et à construire des projets IoT entièrement fonctionnels.
1.2 Application IoT dans les maisons intelligentes
L'IoT a pénétré tous les domaines de la vie, et l'application IoT la plus étroitement liée à nous est la maison intelligente. De nombreux appareils traditionnels sont désormais équipés d’un ou plusieurs appareils IoT, et de nombreuses maisons nouvellement construites sont conçues dès le départ avec les technologies IoT. La figure 1.1 montre quelques appareils domestiques intelligents courants.
Graphique 1.1. Appareils domestiques intelligents courants Le développement de la maison intelligente peut être simplement divisé en produits intelligentstage, interconnexion de scène stage et intelligent stage, comme le montre la figure 1.2.
Graphique 1.2. Développementstage de la maison intelligente 6 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

Le premier stagNous parlons de produits intelligents. Contrairement aux maisons traditionnelles, dans les maisons intelligentes, les appareils IoT reçoivent des signaux avec des capteurs et sont mis en réseau via des technologies de communication sans fil telles que Wi-Fi, Bluetooth LE et ZigBee. Les utilisateurs peuvent contrôler les produits intelligents de différentes manières, telles que les applications pour smartphone, les assistants vocaux, le contrôle intelligent des haut-parleurs, etc.tage se concentre sur l’interconnexion des scènes. Dans ce stage, les développeurs n'envisagent plus de contrôler un seul produit intelligent, mais d'interconnecter deux ou plusieurs produits intelligents, d'automatiser dans une certaine mesure et enfin de former un mode scène personnalisé. Par exempleample, lorsque l'utilisateur appuie sur un bouton de mode scène, les lumières, les rideaux et les climatiseurs seront automatiquement adaptés aux préréglages. Bien entendu, la condition préalable est que la logique de liaison soit facilement mise en place, y compris les conditions de déclenchement et les actions d'exécution. Imaginez que le mode chauffage de la climatisation se déclenche lorsque la température intérieure descend en dessous de 10°C ; qu'à 7 heures du matin, de la musique est diffusée pour réveiller l'utilisateur, des rideaux intelligents sont ouverts et le cuiseur à riz ou le grille-pain démarre via une prise intelligente ; au moment où l'utilisateur se lève et finit de se laver, le petit-déjeuner est déjà servi, de sorte qu'il n'y aura pas de retard pour se rendre au travail. Comme notre vie est devenue pratique ! Le troisième stage va au renseignement stage. À mesure que l’on accède à davantage d’appareils domestiques intelligents, les types de données générées évoluent également. Avec l’aide du cloud computing, du big data et de l’intelligence artificielle, c’est comme si un « cerveau plus intelligent » avait été implanté dans les maisons intelligentes, qui ne nécessitent plus de commandes fréquentes de la part de l’utilisateur. Ils collectent des données sur les interactions précédentes et apprennent les modèles de comportement et les préférences de l’utilisateur, afin d’automatiser les activités, notamment en fournissant des recommandations pour la prise de décision. Actuellement, la plupart des maisons intelligentes sont sur la scène des interconnexions.tage. À mesure que le taux de pénétration et l’intelligence des produits intelligents augmentent, les barrières entre les protocoles de communication disparaissent. À l'avenir, les maisons intelligentes deviendront certainement vraiment « intelligentes », tout comme le système d'IA Jarvis dans Iron Man, qui peut non seulement aider l'utilisateur à contrôler divers appareils et à gérer les affaires quotidiennes, mais également à disposer d'une super puissance de calcul et d'une capacité de réflexion. Dans le monde intelligenttage, les êtres humains recevront de meilleurs services tant en quantité qu’en qualité.
Chapitre 1. Introduction à IoT 7

8 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

Chapitre Introduction et pratique de 2 projets IoT
Dans le chapitre 1, nous avons présenté l'architecture de l'IoT, ainsi que les rôles et les interrelations de la couche de perception et de contrôle, de la couche réseau, de la couche plateforme et de la couche application, ainsi que le développement de la maison intelligente. Cependant, tout comme lorsque l’on apprend à peindre, connaître les connaissances théoriques est loin d’être suffisant. Nous devons « mettre la main à la pâte » pour mettre en pratique les projets IoT afin de véritablement maîtriser la technologie. De plus, lorsqu'un projet passe à la production de masse,tagPar exemple, il est nécessaire de prendre en compte davantage de facteurs tels que la connexion réseau, la configuration, l'interaction avec la plateforme cloud IoT, la gestion et les mises à jour du micrologiciel, la gestion de la production de masse et la configuration de la sécurité. Alors, à quoi devons-nous prêter attention lors du développement d’un projet IoT complet ? Au chapitre 1, nous avons mentionné que la maison intelligente est l'un des scénarios d'application IoT les plus courants et que les lumières intelligentes sont l'un des appareils les plus basiques et pratiques, qui peuvent être utilisés dans les maisons, les hôtels, les gymnases, les hôpitaux, etc. Dans ce livre, nous prendrons la construction d'un projet d'éclairage intelligent comme point de départ, expliquerons ses composants et ses fonctionnalités et fournirons des conseils sur le développement du projet. Nous espérons que vous pourrez tirer des conclusions de ce cas pour créer davantage d’applications IoT.
2.1 Introduction aux projets IoT typiques
En termes de développement, les modules fonctionnels de base des projets IoT peuvent être classés en développement logiciel et matériel d'appareils IoT, développement d'applications client et développement de plate-forme cloud IoT. Il est important de clarifier les modules fonctionnels de base, qui seront décrits plus en détail dans cette section.
2.1.1 Modules de base pour les appareils IoT courants
Le développement logiciel et matériel des appareils IoT comprend les modules de base suivants : Collecte de données
En tant que couche inférieure de l'architecture IoT, les appareils IoT de la couche de perception et de contrôle connectent les capteurs et les appareils via leurs puces et périphériques pour réaliser la collecte de données et le contrôle des opérations.
9

Liaison de compte et configuration initiale Pour la plupart des appareils IoT, la liaison de compte et la configuration initiale sont effectuées en un seul processus opérationnel, par ex.ample, connectant les appareils aux utilisateurs en configurant le réseau Wi-Fi.
Interaction avec les plateformes cloud IoT Pour surveiller et contrôler les appareils IoT, il est également nécessaire de les connecter aux plateformes cloud IoT, afin de donner des commandes et de signaler l'état grâce à l'interaction entre eux.
Contrôle des appareils Lorsqu'ils sont connectés aux plateformes cloud IoT, les appareils peuvent communiquer avec le cloud et être enregistrés, liés ou contrôlés. Les utilisateurs peuvent interroger l'état du produit et effectuer d'autres opérations sur l'application pour smartphone via des plateformes cloud IoT ou des protocoles de communication locaux.
Mise à niveau du micrologiciel Les appareils IoT peuvent également réaliser une mise à niveau du micrologiciel en fonction des besoins des fabricants. En recevant les commandes envoyées par le cloud, la mise à niveau du micrologiciel et la gestion des versions seront réalisées. Avec cette fonctionnalité de mise à niveau du micrologiciel, vous pouvez améliorer continuellement les fonctions des appareils IoT, corriger les défauts et améliorer l'expérience utilisateur.
2.1.2 Modules de base des applications clientes
Les applications clientes (par exemple les applications pour smartphone) comprennent principalement les modules de base suivants :
Système de compte et autorisation Il prend en charge l'autorisation de compte et d'appareil.
Contrôle des appareils Les applications pour smartphone sont généralement équipées de fonctions de contrôle. Les utilisateurs peuvent facilement se connecter aux appareils IoT et les gérer à tout moment et en tout lieu via des applications pour smartphone. Dans une maison intelligente du monde réel, les appareils sont principalement contrôlés via des applications pour smartphone, ce qui permet non seulement une gestion intelligente des appareils, mais permet également d'économiser les coûts de main d'œuvre. Par conséquent, le contrôle des appareils est indispensable pour les applications client, telles que le contrôle des attributs de fonction des appareils, le contrôle des scènes, la planification, la télécommande, la liaison des appareils, etc. Les utilisateurs de maison intelligente peuvent également personnaliser les scènes en fonction de leurs besoins personnels, en contrôlant l'éclairage, les appareils électroménagers, l'entrée. , etc., pour rendre la vie à la maison plus confortable et plus pratique. Ils peuvent programmer la climatisation, l'éteindre à distance, allumer automatiquement la lumière du couloir une fois la porte déverrouillée ou passer en mode « cinéma » avec un seul bouton.
Les applications Notification Client mettent à jour l'état en temps réel des appareils IoT et envoient des alertes lorsque les appareils présentent des anomalies.
10 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

Service client après-vente Les applications pour smartphone peuvent fournir des services après-vente de produits, afin de résoudre en temps opportun les problèmes liés aux pannes des appareils IoT et aux opérations techniques.
Fonctions proposées Pour répondre aux besoins des différents utilisateurs, d'autres fonctions peuvent être ajoutées, telles que Shake, NFC, GPS, etc. Le GPS peut aider à définir la précision des opérations de scène en fonction de l'emplacement et de la distance, tandis que la fonction Shake permet aux utilisateurs de définir la commandes à exécuter pour un appareil ou une scène spécifique en secouant.
2.1.3 Introduction aux plateformes cloud IoT courantes
La plateforme cloud IoT est une plateforme tout-en-un qui intègre des fonctions telles que la gestion des appareils, la communication de sécurité des données et la gestion des notifications. En fonction de leur groupe cible et de leur accessibilité, les plateformes cloud IoT peuvent être divisées en plateformes cloud IoT publiques (ci-après dénommées « cloud public ») et en plateformes cloud IoT privées (ci-après dénommées « cloud privé »).
Le cloud public désigne généralement des plates-formes cloud IoT partagées pour les entreprises ou les particuliers, exploitées et entretenues par des fournisseurs de plates-formes et partagées via Internet. Il peut être gratuit ou peu coûteux et fournit des services sur l'ensemble du réseau public ouvert, tels qu'Alibaba Cloud, Tencent Cloud, Baidu Cloud, AWS IoT, Google IoT, etc. En tant que plate-forme de support, le cloud public peut intégrer des fournisseurs de services en amont et utilisateurs finaux en aval pour créer une nouvelle chaîne de valeur et un nouvel écosystème.
Le cloud privé est conçu uniquement pour une utilisation en entreprise, garantissant ainsi le meilleur contrôle sur les données, la sécurité et la qualité du service. Ses services et son infrastructure sont gérés séparément par les entreprises, et le matériel et les logiciels de support sont également dédiés à des utilisateurs spécifiques. Les entreprises peuvent personnaliser les services cloud pour répondre aux besoins de leur entreprise. À l’heure actuelle, certains fabricants de maisons intelligentes disposent déjà de plates-formes cloud IoT privées et ont développé des applications pour maisons intelligentes basées sur celles-ci.
Le cloud public et le cloud privé ont leurs propres avancéestages, qui sera expliqué plus tard.
Pour parvenir à une connectivité de communication, il est nécessaire de réaliser au moins un développement intégré côté appareil, ainsi que des serveurs d'entreprise, des plates-formes cloud IoT et des applications pour smartphone. Face à un projet d’une telle envergure, le cloud public fournit normalement des kits de développement logiciel pour les applications côté appareil et smartphone afin d’accélérer le processus. Les cloud publics et privés fournissent des services comprenant l'accès aux appareils, la gestion des appareils, l'ombre des appareils, ainsi que l'exploitation et la maintenance.
Accès aux appareils Les plates-formes cloud IoT doivent fournir non seulement des interfaces pour l'accès aux appareils à l'aide de protocoles
Chapitre 2. Introduction et pratique des projets IoT 11

tels que MQTT, CoAP, HTTPS et WebSocket, mais aussi la fonction d'authentification de sécurité des appareils pour bloquer les appareils falsifiés et illégaux, réduisant ainsi efficacement le risque d'être compromis. Une telle authentification prend généralement en charge différents mécanismes. Ainsi, lorsque les appareils sont produits en série, il est nécessaire de pré-attribuer le certificat de l'appareil en fonction du mécanisme d'authentification sélectionné et de le graver dans les appareils.
Gestion des appareils La fonction de gestion des appareils fournie par les plateformes cloud IoT peut non seulement aider les fabricants à surveiller l'état d'activation et l'état en ligne de leurs appareils en temps réel, mais permet également des options telles que l'ajout/suppression d'appareils, la récupération, l'ajout/suppression de groupes, la mise à niveau du micrologiciel. et la gestion des versions.
Les plates-formes cloud IoT d'ombre d'appareil peuvent créer une version virtuelle persistante (ombre d'appareil) pour chaque appareil, et l'état de l'ombre d'appareil peut être synchronisé et obtenu par une application pour smartphone ou d'autres appareils via des protocoles de transmission Internet. L'ombre de l'appareil stocke le dernier état signalé et l'état attendu de chaque appareil, et même si l'appareil est hors ligne, il peut toujours obtenir l'état en appelant des API. Device Shadow fournit des API toujours actives, ce qui facilite la création d'applications pour smartphone qui interagissent avec les appareils.
Exploitation et maintenance La fonction O&M comprend trois aspects : · Démonstration d'informations statistiques sur les appareils IoT et les notifications. · La gestion des journaux permet la récupération d'informations sur le comportement de l'appareil, le flux de messages haut/bas et le contenu des messages. · Le débogage des appareils prend en charge l'envoi de commandes, la mise à jour de la configuration et la vérification de l'interaction entre les plates-formes cloud IoT et les messages de l'appareil.
2.2 Pratique : Projet Smart Light
Après l'introduction théorique de chaque chapitre, vous trouverez une section pratique liée au projet Smart Light pour vous aider à acquérir une expérience pratique. Le projet est basé sur la puce ESP32-C3 d'Espressif et la plateforme cloud IoT ESP RainMaker, et couvre le matériel de module sans fil dans les produits d'éclairage intelligents, les logiciels intégrés pour les appareils intelligents basés sur ESP32C3, les applications pour smartphone et l'interaction ESP RainMaker.
Code source Pour une meilleure expérience d'apprentissage et de développement, le projet présenté dans ce livre a été open source. Vous pouvez télécharger le code source depuis notre référentiel GitHub à l'adresse https://github. com/espressif/book-esp32c3-iot-projects.
12 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

2.2.1 Structure du projet
Le projet Smart Light se compose de trois parties : i. Dispositifs d'éclairage intelligents basés sur ESP32-C3, chargés d'interagir avec les plates-formes cloud IoT et de contrôler l'interrupteur, la luminosité et la température de couleur de la LED lamp perles. ii. Applications pour smartphone (y compris les applications pour tablettes fonctionnant sous Android et iOS), responsables de la configuration réseau des produits d'éclairage intelligents, ainsi que de l'interrogation et du contrôle de leur état.
iii. Une plateforme cloud IoT basée sur ESP RainMaker. Par souci de simplification, nous considérons la plateforme cloud IoT et le serveur d'entreprise dans leur ensemble dans ce livre. Des détails sur ESP RainMaker seront fournis au chapitre 3.
La correspondance entre la structure du projet Smart Light et l'architecture de l'IoT est illustrée dans la figure 2.1.
Graphique 2.1. Structure du projet d'éclairage intelligent
2.2.2 Fonctions du projet
Réparties selon la structure, les fonctions de chaque partie sont les suivantes. Appareils d'éclairage intelligents
· Configuration et connexion réseau. · Contrôle LED PWM, tel que commutateur, luminosité, température de couleur, etc. · Automatisation ou contrôle de scène, par exemple minuterie. · Cryptage et démarrage sécurisé du Flash. · Mise à niveau du firmware et gestion des versions.
Chapitre 2. Introduction et pratique des projets IoT 13

Applications pour smartphone · Configuration du réseau et liaison des appareils. · Contrôle intelligent des produits d'éclairage, tels que l'interrupteur, la luminosité, la température de couleur, etc. · Paramètres d'automatisation ou de scène, par exemple, minuterie. · Contrôle local/à distance. · Enregistrement des utilisateurs, connexion, etc.
Plateforme cloud ESP RainMaker IoT · Activation de l'accès aux appareils IoT. · Fournir des API de fonctionnement des appareils accessibles aux applications pour smartphones. · Mise à niveau du firmware et gestion des versions.
2.2.3 Préparation du matériel
Si vous souhaitez mettre le projet en pratique, vous aurez également besoin du matériel suivant : des lumières intelligentes, des smartphones, des routeurs Wi-Fi et un ordinateur répondant aux exigences d'installation de l'environnement de développement. Lumières intelligentes
Les lumières intelligentes sont un nouveau type d’ampoules dont la forme est la même que celle des ampoules à incandescence générales. Une lampe intelligente est composée d'une alimentation régulée par condensateur, d'un module sans fil (avec ESP32-C3 intégré), d'un contrôleur LED et d'une matrice LED RVB. Lorsqu'il est connecté à l'alimentation, le vol 15 V DCtagLa sortie après réduction du condensateur, redressement de la diode et régulation fournit de l'énergie au contrôleur LED et à la matrice LED. Le contrôleur LED peut envoyer automatiquement des niveaux hauts et bas à certains intervalles, commutant la matrice LED RVB entre fermée (lumières allumées) et ouverte (lumières éteintes), de sorte qu'elle puisse émettre du cyan, du jaune, du vert, du violet, du bleu, du rouge et lumière blanche. Le module sans fil est chargé de se connecter au routeur Wi-Fi, de recevoir et de signaler l'état des lumières intelligentes et d'envoyer des commandes pour contrôler la LED.
Graphique 2.2. Une lumière intelligente simulée
Au début du développementtage, vous pouvez simuler une lumière intelligente à l'aide de la carte ESP32-C3DevKitM-1 connectée avec des LED RVB lamp perles (voir Figure 2.2). Mais tu devrais
14 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

notez que ce n’est pas la seule façon d’assembler une lampe intelligente. La conception matérielle du projet dans ce livre contient uniquement un module sans fil (avec ESP32-C3 intégré), mais pas une conception matérielle complète d'éclairage intelligent. De plus, Espressif produit également une carte de développement audio ESP32-C3 basée sur ESP32-C3 pour contrôler les lumières avec audio. La carte dispose d'interfaces pour microphones et haut-parleurs et peut contrôler des bandes LED. Il peut être utilisé pour développer des diffuseurs audio et des bandes lumineuses rythmiques à très faible coût et hautes performances. La figure 2.3 montre une carte ESP32-C3Lyra reliée à une bande de 40 lumières LED.
Graphique 2.3. ESP32-C3-Lyra relié à une bande de 40 lumières LED
Smartphones (Android/iOS) Le projet Smart Light implique le développement d'une application pour smartphone permettant de configurer et de contrôler des produits d'éclairage intelligents.
Routeurs Wi-Fi Les routeurs Wi-Fi convertissent les signaux du réseau filaire et des signaux du réseau mobile en signaux du réseau sans fil, permettant aux ordinateurs, smartphones, tablettes et autres appareils sans fil de se connecter au réseau. Par exempleampLe haut débit à la maison n'a besoin que d'être connecté à un routeur Wi-Fi pour réaliser une mise en réseau sans fil des appareils Wi-Fi. La norme de protocole dominante prise en charge par les routeurs Wi-Fi est IEEE 802.11n, avec un TxRate moyen de 300 Mbps, ou 600 Mbps au maximum. Ils sont rétrocompatibles avec IEEE 802.11b et IEEE 802.11g. La puce ESP32-C3 d'Espressif prend en charge IEEE 802.11b/g/n, vous pouvez donc choisir un routeur Wi-Fi mono-bande (2.4 GHz) ou bi-bande (2.4 GHz et 5 GHz).
Un environnement de développement informatique (Linux/macOS/Windows) sera présenté au chapitre 4. Chapitre 2. Introduction et pratique des projets IoT 15

2.2.4 Processus de développement
Graphique 2.4. Étapes de développement du projet Smart Light
Conception matérielle La conception matérielle des appareils IoT est essentielle à un projet IoT. Un projet complet d'éclairage intelligent est destiné à produire un lamp fonctionnant sous alimentation secteur. Différents fabricants produisent du lamps de styles et de types de pilotes différents, mais leurs modules sans fil ont généralement la même fonction. Pour simplifier le processus de développement du projet Smart Ligh, ce livre couvre uniquement la conception matérielle et le développement logiciel des modules sans fil.
Configuration de la plateforme cloud IoT Pour utiliser les plateformes cloud IoT, vous devez configurer des projets sur le backend, tels que la création de produits, la création d'appareils, la définition des propriétés des appareils, etc.
Développement de logiciels embarqués pour les appareils IoT Implémentez les fonctions attendues avec ESP-IDF, le SDK côté appareil d'Espressif, notamment la connexion aux plates-formes cloud IoT, le développement de pilotes LED et la mise à niveau du micrologiciel.
Développement d'applications pour smartphone Développez des applications pour smartphone pour les systèmes Android et iOS afin de réaliser l'enregistrement et la connexion des utilisateurs, le contrôle des appareils et d'autres fonctions.
Optimisation des appareils IoT Une fois le développement de base des fonctions des appareils IoT terminé, vous pouvez vous tourner vers des tâches d'optimisation, telles que l'optimisation de la puissance.
Tests de production de masse Effectuer des tests de production de masse conformément aux normes associées, telles que le test de fonctionnement de l'équipement, le test de vieillissement, le test RF, etc.
Malgré les étapes listées ci-dessus, un projet Smart Light n'est pas nécessairement soumis à une telle procédure puisque différentes tâches peuvent également être réalisées en même temps. Par exempleample, les logiciels embarqués et les applications pour smartphone peuvent être développés en parallèle. Certaines étapes devront peut-être également être répétées, comme l'optimisation des appareils IoT et les tests de production de masse.
16 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

2.3 Résumé
Dans ce chapitre, nous avons d'abord exposé les composants de base et les modules fonctionnels d'un projet IoT, puis avons présenté le cas Smart Light pour la pratique, en faisant référence à sa structure, ses fonctions, sa préparation matérielle et son processus de développement. Les lecteurs peuvent tirer des conclusions de la pratique et acquérir la confiance nécessaire pour mener à bien des projets IoT avec un minimum d'erreurs à l'avenir.
Chapitre 2. Introduction et pratique des projets IoT 17

18 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

Chapitre 3

Introduction

ESP

Faiseur de pluie

L'Internet des objets (IoT) offre des possibilités infinies pour changer la façon dont les gens vivent, mais le développement de l'ingénierie IoT est semé d'embûches. Avec les cloud publics, les fabricants de terminaux peuvent mettre en œuvre les fonctionnalités des produits via les solutions suivantes :
Basé sur les plates-formes cloud des fournisseurs de solutions. De cette manière, les fabricants de terminaux n'ont qu'à concevoir le matériel du produit, puis à connecter le matériel au cloud à l'aide du module de communication fourni et à configurer les fonctions du produit en suivant les directives. Il s’agit d’une approche efficace car elle élimine le besoin de développement, d’exploitation et de maintenance (O&M) côté serveur et côté application. Cela permet aux fabricants de terminaux de se concentrer sur la conception matérielle sans avoir à envisager la mise en œuvre du cloud. Cependant, ces solutions (par exemple, le micrologiciel de l'appareil et l'application) ne sont généralement pas open source, de sorte que les fonctions du produit seront limitées par la plate-forme cloud du fournisseur qui ne peut pas être personnalisée. Parallèlement, les données des utilisateurs et des appareils appartiennent également à la plateforme cloud.
Basé sur des produits cloud Dans cette solution, après avoir terminé la conception matérielle, les fabricants de terminaux doivent non seulement implémenter des fonctions cloud en utilisant un ou plusieurs produits cloud fournis par le cloud public, mais doivent également relier le matériel au cloud. Par exempleample, pour se connecter à Amazon Web Services (AWS), les fabricants de terminaux doivent utiliser des produits AWS tels qu'Amazon API Gateway, AWS IoT Core et AWS Lambda pour permettre l'accès aux appareils, le contrôle à distance, le stockage de données, la gestion des utilisateurs et d'autres fonctions de base. Il demande non seulement aux fabricants de terminaux d'utiliser et de configurer de manière flexible les produits cloud avec une compréhension approfondie et une expérience riche, mais également de prendre en compte les coûts de construction et de maintenance pour les projets initiaux et ultérieurs.tages Cela pose de grands défis en termes d’énergie et de ressources de l’entreprise.
Comparés aux cloud publics, les cloud privés sont généralement conçus pour des projets et des produits spécifiques. Les développeurs de cloud privé bénéficient du plus haut niveau de liberté en matière de conception de protocoles et de mise en œuvre de la logique métier. Les fabricants de terminaux peuvent créer des produits et concevoir des schémas à volonté, et intégrer et responsabiliser facilement les données des utilisateurs. Combinant la haute sécurité, l'évolutivité et la fiabilité du cloud public avec l'advantages du cloud privé, Espressif lance ESP
19

RainMaker, une solution de cloud privé profondément intégrée basée sur le cloud Amazon. Les utilisateurs peuvent déployer ESP RainMaker et créer un cloud privé simplement avec un compte AWS.
3.1 Qu'est-ce qu'ESP RainMaker ?
ESP RainMaker est une plateforme AIoT complète construite avec plusieurs produits AWS matures. Il fournit divers services requis pour la production de masse, tels que l'accès au cloud des appareils, la mise à niveau des appareils, la gestion du backend, la connexion tierce, l'intégration vocale et la gestion des utilisateurs. En utilisant le Serverless Application Repository (SAR) fourni par AWS, les fabricants de terminaux peuvent déployer rapidement ESP RainMaker sur leurs comptes AWS, ce qui est rapide et facile à utiliser. Géré et maintenu par Espressif, le SAR utilisé par ESP RainMaker aide les développeurs à réduire les coûts de maintenance du cloud et à accélérer le développement de produits AIoT, créant ainsi des solutions AIoT sécurisées, stables et personnalisables. La figure 3.1 montre l'architecture d'ESP RainMaker.
Graphique 3.1. Architecture d'ESP RainMaker
Le serveur public ESP RainMaker d'Espressif est gratuit pour tous les passionnés, créateurs et éducateurs ESP pour l'évaluation de solutions. Les développeurs peuvent se connecter avec des comptes Apple, Google ou GitHub et créer rapidement leurs propres prototypes d'applications IoT. Le serveur public intègre Alexa et Google Home et fournit des services de commande vocale, pris en charge par Alexa Skill et Google Actions. Sa fonction de reconnaissance sémantique est également alimentée par des tiers. Les appareils RainMaker IoT ne répondent qu'à des actions spécifiques. Pour une liste exhaustive des commandes vocales prises en charge, veuillez consulter les plateformes tierces. De plus, Espressif propose une application publique RainMaker permettant aux utilisateurs de contrôler les produits via leurs smartphones. 20 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

3.2 La mise en œuvre d'ESP RainMaker
Comme le montre la figure 3.2, ESP RainMaker se compose de quatre parties : · Service de réclamation, permettant aux appareils RainMaker d'obtenir dynamiquement des certificats. · RainMaker Cloud (également connu sous le nom de backend cloud), fournissant des services tels que le filtrage des messages, la gestion des utilisateurs, le stockage de données et les intégrations tierces. · RainMaker Agent, permettant aux appareils RainMaker de se connecter à RainMaker Cloud. · Client RainMaker (RainMaker App ou scripts CLI), pour le provisionnement, la création d'utilisateurs, l'association et le contrôle de périphériques, etc.
Graphique 3.2. Structure d'ESP RainMaker
ESP RainMaker fournit un ensemble complet d'outils pour le développement de produits et la production de masse, notamment : RainMaker SDK
RainMaker SDK est basé sur ESP-IDF et fournit le code source de l'agent côté appareil et les API C associées pour le développement du micrologiciel. Les développeurs n'ont qu'à écrire la logique de l'application et laisser le reste au framework RainMaker. Pour plus d'informations sur les API C, veuillez visiter https://bookc3.espressif.com/rm/c-api-reference. Application RainMaker La version publique de l'application RainMaker permet aux développeurs de finaliser le provisionnement des appareils, ainsi que de contrôler et d'interroger l'état des appareils (par exemple, les produits d'éclairage intelligents). Il est disponible sur les magasins d'applications iOS et Android. Pour plus de détails, veuillez vous référer au chapitre 10. API REST Les API REST aident les utilisateurs à créer leurs propres applications similaires à l'application RainMaker. Pour plus d'informations, veuillez visiter https://swaggerapis.rainmaker.espressif.com/.
Chapitre 3. Introduction à ESP RainMaker 21

API Python Une CLI basée sur Python, fournie avec le SDK RainMaker, est fournie pour implémenter toutes les fonctions similaires aux fonctionnalités des smartphones. Pour plus d'informations sur les API Python, veuillez visiter https://bookc3.espressif.com/rm/python-api-reference.
Admin CLI Admin CLI, avec un niveau d'accès plus élevé, est fourni pour le déploiement privé d'ESP RainMaker afin de générer des certificats de périphérique en masse.
3.2.1 Réclamation du service
Toutes les communications entre les appareils RainMaker et le backend cloud sont effectuées via MQTT+TLS. Dans le contexte d'ESP RainMaker, « Claming » est le processus par lequel les appareils obtiennent des certificats du service de réclamation pour se connecter au backend cloud. Notez que Claiming Service s'applique uniquement au service public RainMaker, tandis que pour un déploiement privé, les certificats de périphérique doivent être générés en masse via Admin CLI. ESP RainMaker prend en charge trois types de services de réclamation : Auto-réclamation
L'appareil lui-même récupère les certificats via une clé secrète préprogrammée dans eFuse après la connexion à Internet. Réclamation basée sur l'hôte Les certificats sont obtenus auprès de l'hôte de développement avec le compte RainMaker. Réclamation assistée Les certificats sont obtenus via des applications smartphone lors de la mise à disposition.
3.2.2 Agent RainMaker
Graphique 3.3. Structure du SDK RainMaker La fonction principale de l'agent RainMaker est de fournir la connectivité et d'aider la couche d'application à traiter les données cloud de liaison montante/descendante. Il est construit via le RainMaker SDK 22 ESP32-C3 Wireless Adventure : un guide complet de l'IoT.

et développé sur la base du framework ESP-IDF éprouvé, en utilisant des composants ESP-IDF tels que RTOS, NVS et MQTT. La figure 3.3 montre la structure du SDK RainMaker.
Le SDK RainMaker comprend deux fonctionnalités principales.
Connexion
je. Coopérer avec le service de réclamation pour obtenir des certificats d'appareil.
ii. Connexion au backend cloud à l'aide du protocole sécurisé MQTT pour fournir une connectivité à distance et mettre en œuvre le contrôle à distance, la création de rapports de messages, la gestion des utilisateurs, la gestion des appareils, etc. Il utilise le composant MQTT dans ESP-IDF par défaut et fournit une couche d'abstraction pour s'interfacer avec d'autres piles de protocoles.
iii. Fourniture d'un composant d'approvisionnement Wi-Fi pour la connexion et l'approvisionnement Wi-Fi, d'un composant esp https ota pour les mises à niveau OTA et d'un composant esp local ctrl pour la découverte et la connexion des appareils locaux. Tous ces objectifs peuvent être atteints grâce à une configuration simple.
Informatique
je. Stockage des certificats de périphérique émis par Claiming Service et des données nécessaires à l'exécution de RainMaker, par défaut en utilisant l'interface fournie par le composant nvs flash, et en fournissant des API aux développeurs pour une utilisation directe.
ii. Utiliser le mécanisme de rappel pour traiter les données cloud de liaison montante/descendante et débloquer automatiquement les données vers la couche d'application pour un traitement facile par les développeurs. Par exempleample, le SDK RainMaker fournit des interfaces riches pour établir des données TSL (Thing Spécification Language), qui sont nécessaires pour définir des modèles TSL pour décrire les appareils IoT et implémenter des fonctions telles que la synchronisation, le compte à rebours et la commande vocale. Pour les fonctionnalités interactives de base telles que la synchronisation, RainMaker SDK fournit une solution sans développement qui peut être simplement activée en cas de besoin. Ensuite, l'agent RainMaker traitera directement les données, les enverra vers le cloud via la rubrique MQTT associée et transmettra les modifications des données dans le backend du cloud via un mécanisme de rappel.
3.2.3 Back-end cloud
Le backend cloud est construit sur AWS Serverless Computing et réalisé via AWS Cognito (système de gestion des identités), Amazon API Gateway, AWS Lambda (service informatique sans serveur), Amazon DynamoDB (base de données NoSQL), AWS IoT Core (noyau d'accès IoT qui fournit un accès MQTT et filtrage de règles), Amazon Simple Email Service (service de messagerie simple SES), Amazon CloudFront (réseau de livraison rapide), Amazon Simple Queue Service (file d'attente des messages SQS) et Amazon S3 (service de stockage de compartiments). Il vise à optimiser l’évolutivité et la sécurité. Avec ESP RainMaker, les développeurs peuvent gérer les appareils sans avoir à écrire de code dans le cloud. Les messages signalés par les appareils sont transmis de manière transparente à
Chapitre 3. Introduction à ESP RainMaker 23

clients d’application ou autres services tiers. Le tableau 3.1 présente les produits et fonctions cloud AWS utilisés dans le backend cloud, avec d'autres produits et fonctionnalités en cours de développement.
Tableau 3.1. Produits et fonctions cloud AWS utilisés par le backend cloud

Produit Cloud AWS utilisé par RainMaker

Fonction

AWS Cognito

Gestion des informations d'identification des utilisateurs et prise en charge des connexions tierces

AWS Lambda

Implémentation de la logique métier de base du backend cloud

Amazon Timestream Stockage de données de séries chronologiques

Amazon DynamoDB Stockage des informations privées des clients

Noyau AWS IoT

Prise en charge des communications MQTT

Amazon SES

Fournir des services d'envoi d'e-mails

Amazon CloudFront Accélérer la gestion du backend webAccès au site

Amazon SQS

Transfert de messages depuis AWS IoT Core

3.2.4 Client RainMaker
Les clients RainMaker, tels que App et CLI, communiquent avec le backend cloud via les API REST. Des informations et des instructions détaillées sur les API REST peuvent être trouvées dans la documentation Swagger fournie par Espressif. Le client d'application mobile de RainMaker est disponible pour les systèmes iOS et Android. Il permet l'approvisionnement, le contrôle et le partage des appareils, ainsi que la création et l'activation de tâches de compte à rebours et la connexion à des plates-formes tierces. Il peut charger automatiquement l'interface utilisateur et les icônes en fonction de la configuration signalée par les appareils et afficher entièrement le TSL de l'appareil.
Par exempleample, si une lumière intelligente est construite sur l'ex fourni par RainMaker SDKampchiers, l'icône et l'interface utilisateur de l'ampoule seront chargées automatiquement une fois l'approvisionnement terminé. Les utilisateurs peuvent modifier la couleur et la luminosité de la lumière via l'interface et obtenir un contrôle tiers en reliant Alexa Smart Home Skill ou Google Smart Home Actions à leurs comptes ESP RainMaker. La figure 3.4 montre l'icône et l'interface utilisateurampLes ampoules s'allument respectivement sur Alexa, Google Home et l'application ESP RainMaker.

24 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

(a) Example – Alexa

(b) Example – Google Accueil

(c) Ex.ample – ESP RainMaker
Figure 3.4.Exampfichiers d'icône et d'interface utilisateur de l'ampoule sur Alexa, Google Home et l'application ESP RainMaker
3.3 Pratique : points clés pour le développement avec ESP RainMaker
Une fois la couche de pilote de périphérique terminée, les développeurs peuvent commencer à créer des modèles TSL et traiter les données de liaison descendante à l'aide des API fournies par RainMaker SDK, et activer les services de base ESP RainMaker en fonction de la définition et des exigences du produit.
Chapitre 3. Introduction à ESP RainMaker 25

La section 9.4 de ce livre expliquera la mise en œuvre de la lumière intelligente LED dans RainMaker. Pendant le débogage, les développeurs peuvent utiliser les outils CLI du SDK RainMaker pour communiquer avec la lumière intelligente (ou appeler les API REST depuis Swagger).
Le chapitre 10 détaillera l'utilisation des API REST dans le développement d'applications pour smartphone. Les mises à niveau OTA des lumières intelligentes LED seront couvertes au chapitre 11. Si les développeurs ont activé la surveillance à distance ESP Insights, le backend de gestion ESP RainMaker affichera les données ESP Insights. Les détails seront présentés au chapitre 15.
ESP RainMaker prend en charge le déploiement privé, qui diffère du serveur public RainMaker des manières suivantes :
Service de réclamation Pour générer des certificats dans des déploiements privés, il est nécessaire d'utiliser la CLI RainMaker Admin au lieu de réclamer. Avec un serveur public, les développeurs doivent disposer de droits d'administrateur pour mettre en œuvre la mise à niveau du micrologiciel, mais cela n'est pas souhaitable dans les déploiements commerciaux. Par conséquent, ni un service d'authentification distinct ne peut être fourni pour l'auto-revendication, ni des droits d'administrateur pour une revendication pilotée ou assistée par l'hôte.
Applications téléphoniques Dans les déploiements privés, les applications doivent être configurées et compilées séparément pour garantir que les systèmes de compte ne sont pas interopérables.
Connexions tierces et intégration vocale Les développeurs doivent configurer séparément via les comptes de développeur Google et Apple pour activer les connexions tierces, ainsi que l'intégration des compétences Alexa et de Google Voice Assistant.
CONSEILS Pour plus de détails sur le déploiement cloud, veuillez visiter https://customer.rainmaker.espressif. com. En termes de micrologiciel, la migration d'un serveur public vers un serveur privé nécessite uniquement le remplacement des certificats de périphérique, ce qui améliore considérablement l'efficacité de la migration et réduit le coût de la migration et du débogage secondaire.
3.4 Caractéristiques d'ESP RainMaker
Les fonctionnalités d'ESP RainMaker ciblent principalement trois aspects : la gestion des utilisateurs, les utilisateurs finaux et les administrateurs. Toutes les fonctionnalités sont prises en charge sur les serveurs publics et privés, sauf indication contraire.
3.4.1 Gestion des utilisateurs
Les fonctionnalités de gestion des utilisateurs permettent aux utilisateurs finaux de s'inscrire, de se connecter, de modifier leurs mots de passe, de récupérer des mots de passe, etc.
26 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

S'inscrire et se connecter Les méthodes d'enregistrement et de connexion prises en charge par RainMaker incluent : · Identifiant de courrier électronique + Mot de passe · Numéro de téléphone + Mot de passe · Compte Google · Compte Apple · Compte GitHub (serveur public uniquement) · Compte Amazon (serveur privé uniquement)
REMARQUE L'inscription à l'aide de Google/Amazon partage l'adresse e-mail de l'utilisateur avec RainMaker. Inscrivez-vous en utilisant Apple partage une adresse factice qu'Apple attribue à l'utilisateur spécifiquement pour le service RainMaker. Un compte RainMaker sera automatiquement créé pour les utilisateurs qui se connectent pour la première fois avec un compte Google, Apple ou Amazon.
Modifier le mot de passe Valable uniquement pour les connexions basées sur un identifiant de courrier électronique/un numéro de téléphone. Toutes les autres sessions actives seront déconnectées une fois le mot de passe modifié. Conformément au comportement d'AWS Cognito, les sessions déconnectées peuvent rester actives jusqu'à 1 heure.
Récupérer le mot de passe Valable uniquement pour les connexions basées sur un identifiant de courrier électronique/un numéro de téléphone.
3.4.2 Fonctionnalités de l'utilisateur final
Les fonctionnalités ouvertes aux utilisateurs finaux incluent le contrôle et la surveillance locaux et à distance, la planification, le regroupement d'appareils, le partage d'appareils, les notifications push et les intégrations tierces.
Contrôle et surveillance à distance · Configuration des requêtes, valeurs des paramètres et état de connexion pour un ou tous les appareils. · Définir les paramètres pour un ou plusieurs appareils.
Contrôle et surveillance locaux Le téléphone mobile et l'appareil doivent être connectés au même réseau pour le contrôle local.
Planification · Les utilisateurs prédéfinissent certaines actions à un moment précis. · Aucune connexion Internet requise pour l'appareil lors de l'exécution du programme. · Une fois ou répéter (en spécifiant les jours) pour un ou plusieurs appareils.
Regroupement d'appareils Prend en charge le regroupement abstrait à plusieurs niveaux Les métadonnées de groupe peuvent être utilisées pour créer une structure de salle d'accueil.
Chapitre 3. Introduction à ESP RainMaker 27

Partage d'appareils Un ou plusieurs appareils peuvent être partagés avec un ou plusieurs utilisateurs.
Notifications push Les utilisateurs finaux recevront des notifications push pour des événements tels que · Nouveaux appareils ajoutés/supprimés · Appareil connecté au cloud · Appareil déconnecté du cloud · Demandes de partage d'appareil créées/acceptées/refusées · Messages d'alerte signalés par les appareils
Les intégrations tierces Alexa et Google Voice Assistant sont prises en charge pour contrôler les appareils RainMaker, notamment les lumières, les interrupteurs, les prises, les ventilateurs et les capteurs de température.
3.4.3 Fonctionnalités d'administration
Les fonctionnalités d'administration permettent aux administrateurs de mettre en œuvre l'enregistrement des appareils, le regroupement d'appareils et les mises à niveau OTA, ainsi que de view statistiques et données ESP Insights.
Enregistrement de l'appareil Générez des certificats d'appareil et enregistrez-vous auprès d'Admin CLI (serveur privé uniquement).
Regroupement de périphériques Créez des groupes abstraits ou structurés basés sur les informations sur les périphériques (serveur privé uniquement).
Mises à niveau OTA (Over-the-Air) Téléchargez le micrologiciel en fonction de la version et du modèle sur un ou plusieurs appareils ou un groupe. Surveillez, annulez ou archivez les tâches OTA.
View statistiques ViewLes statistiques disponibles incluent : · Enregistrements d'appareils (certificats enregistrés par l'administrateur) · Activations d'appareils (appareil connecté pour la première fois) · Comptes d'utilisateurs · Association utilisateur-appareil
View Données ESP Insights ViewLes données ESP Insights exploitables incluent : · Erreurs, avertissements et journaux personnalisés · Rapports et analyses de crash · Raisons du redémarrage · Mesures telles que l'utilisation de la mémoire, RSSI, etc. · Mesures et variables personnalisées
28 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

3.5 Résumé
Dans ce chapitre, nous avons présenté quelques différences clés entre le déploiement public de RainMaker et le déploiement privé. La solution privée ESP RainMaker lancée par Espressif est hautement fiable et extensible. Toutes les puces de la série ESP32 ont été connectées et adaptées à AWS, ce qui réduit considérablement les coûts. Les développeurs peuvent se concentrer sur la vérification des prototypes sans avoir à se renseigner sur les produits cloud AWS. Nous avons également expliqué l'implémentation et les fonctionnalités d'ESP RainMaker, ainsi que quelques points clés pour le développement à l'aide de la plateforme.
Scannez pour télécharger ESP RainMaker pour Android Scannez pour télécharger ESP RainMaker pour iOS
Chapitre 3. Introduction à ESP RainMaker 29

30 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

Chapitre Configuration 4 Environnement de développement
Ce chapitre se concentre sur ESP-IDF, le cadre de développement logiciel officiel pour ESP32-C3. Nous expliquerons comment configurer l'environnement sur différents systèmes d'exploitation, et présenterons la structure du projet et le système de construction d'ESP-IDF, ainsi que l'utilisation des outils de développement associés. Ensuite, nous présenterons le processus de compilation et d'exécution d'un example projet, tout en proposant une explication détaillée du journal de sortie à chaque stage.
4.1 ESP-IDF terminéview
ESP-IDF (Espressif IoT Development Framework) est un cadre de développement IoT unique fourni par Espressif Technology. Il utilise C/C++ comme principal langage de développement et prend en charge la compilation croisée sous les systèmes d'exploitation courants tels que Linux, Mac et Windows. Le EXampLes programmes inclus dans ce livre sont développés à l'aide d'ESP-IDF, qui offre les fonctionnalités suivantes : · Pilotes au niveau du système SoC. ESP-IDF comprend des pilotes pour ESP32, ESP32-S2, ESP32-C3,
et autres chips. Ces pilotes englobent la bibliothèque périphérique de bas niveau (LL), la bibliothèque de couche d'abstraction matérielle (HAL), la prise en charge RTOS et le logiciel pilote de couche supérieure, etc. · Composants essentiels. ESP-IDF intègre les composants fondamentaux requis pour le développement de l'IoT. Cela inclut plusieurs piles de protocoles réseau telles que HTTP et MQTT, un cadre de gestion de l'énergie avec modulation de fréquence dynamique et des fonctionnalités telles que Flash Encryption et Secure Boot, etc. · Outils de développement et de production. ESP-IDF fournit des outils couramment utilisés pour la construction, le flash et le débogage pendant le développement et la production de masse (voir Figure 4.1), tels que le système de construction basé sur CMake, la chaîne d'outils de compilation croisée basée sur GCC et le JTAG outil de débogage basé sur OpenOCD, etc. Il est à noter que le code ESP-IDF adhère principalement à la licence open source Apache 2.0. Les utilisateurs peuvent développer des logiciels personnels ou commerciaux sans restrictions tout en respectant les termes de la licence open source. De plus, les utilisateurs bénéficient gratuitement de licences de brevet permanentes, sans obligation d'ouvrir le code source des modifications apportées au code source.
31

Figure 4.1.

Construction, flashage et débogage

outils de développement pour le développement et la production de masse

4.1.1 Versions ESP-IDF
Le code ESP-IDF est hébergé sur GitHub en tant que projet open source. Actuellement, trois versions principales sont disponibles : v3, v4 et v5. Chaque version majeure contient généralement diverses sous-versions, telles que la v4.2, la v4.3, etc. Espressif Systems garantit une assistance de 30 mois pour les corrections de bugs et les correctifs de sécurité pour chaque sous-version publiée. Par conséquent, des révisions de subversions sont également publiées régulièrement, telles que v4.3.1, v4.2.2, etc. Le tableau 4.1 montre l'état de prise en charge des différentes versions d'ESP-IDF pour les puces Espressif, indiquant si elles sont en pré-version.view stage (offrant un support pour les préview versions, qui peuvent manquer de certaines fonctionnalités ou documentation) ou qui sont officiellement prises en charge.

Tableau 4.1. Statut de prise en charge des différentes versions ESP-IDF pour les puces Espressif

Série ESP32 ESP32-S2 ESP32-C3 ESP32-S3 ESP32-C2 ESP32-H2

v4.1 pris en charge

v4.2 pris en charge pris en charge

v4.3 pris en charge pris en charge pris en charge

v4.4 pris en charge pris en charge pris en charge pris en charge
préview

v5.0 pris en charge pris en charge pris en charge pris en charge pris en charge préview

32 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

L'itération des versions majeures implique souvent des ajustements de la structure du framework et des mises à jour du système de compilation. Par exempleample, le changement majeur de la v3.* à la v4.* a été la migration progressive du système de build de Make vers CMake. D’un autre côté, l’itération de versions mineures implique généralement l’ajout de nouvelles fonctionnalités ou la prise en charge de nouvelles puces.
Il est important de distinguer et de comprendre la relation entre les versions stables et les branches GitHub. Les versions étiquetées v*.* ou v*.*.* représentent des versions stables qui ont passé avec succès les tests internes complets par Espressif. Une fois corrigés, le code, la chaîne d'outils et les documents de version de la même version restent inchangés. Cependant, les branches GitHub (par exemple, la branche release/v4.3) subissent des validations de code fréquentes, souvent quotidiennement. Par conséquent, deux extraits de code sous la même branche peuvent différer, obligeant les développeurs à mettre rapidement à jour leur code en conséquence.
4.1.2 Flux de travail Git ESP-IDF
Espressif suit un workflow Git spécifique pour ESP-IDF, décrit comme suit :
· De nouvelles modifications sont apportées à la branche master, qui sert de branche principale de développement. La version ESP-IDF sur la branche master porte toujours un -dev tag pour indiquer qu'il est actuellement en cours de développement, comme v4.3-dev. Les modifications sur la branche master seront d'abord réévaluéesviewédité et testé dans le référentiel interne d'Espressif, puis transféré vers GitHub une fois les tests automatisés terminés.
· Une fois qu'une nouvelle version a terminé le développement des fonctionnalités sur la branche principale et répond aux critères d'entrée en test bêta, elle passe à une nouvelle branche, telle que release/v4.3. De plus, cette nouvelle succursale est tagprésenté comme une version préliminaire, comme la v4.3-beta1. Les développeurs peuvent se référer à la plateforme GitHub pour accéder à la liste complète des branches et tags pour ESP-IDF. Il est important de noter que la version bêta (version préliminaire) peut encore présenter un nombre important de problèmes connus. Comme la version bêta est soumise à des tests continus, des corrections de bogues sont ajoutées simultanément à cette version et à la branche principale. Pendant ce temps, la branche principale a peut-être déjà commencé à développer de nouvelles fonctionnalités pour la prochaine version. Lorsque les tests sont presque terminés, une étiquette de version candidate (rc) est ajoutée à la branche, indiquant qu'il s'agit d'une candidate potentielle pour la version officielle, telle que v4.3-rc1. À ce moment-làtage, la branche reste une version préliminaire.
· Si aucun bogue majeur n'est découvert ou signalé, la version préliminaire reçoit finalement une étiquette de version majeure (par exemple, v5.0) ou une étiquette de version mineure (par exemple, v4.3) et devient une version officielle, qui est documentée. dans la page des notes de version. Par la suite, tous les bugs identifiés dans cette version sont corrigés sur la branche release. Une fois les tests manuels terminés, la branche se voit attribuer une étiquette de version de correction de bug (par exemple, v4.3.2), qui est également reflétée sur la page des notes de version.
Chapitre 4. Configuration de l'environnement de développement 33

4.1.3 Choix d'une version appropriée
Depuis que ESP-IDF a officiellement commencé à prendre en charge ESP32-C3 à partir de la version v4.3 et que la v4.4 n'a pas encore été officiellement publiée au moment de la rédaction de ce livre, la version utilisée dans ce livre est la v4.3.2, qui est une version révisée. de la v4.3. Cependant, il est important de noter qu'au moment où vous lirez ce livre, la version 4.4 ou des versions plus récentes seront peut-être déjà disponibles. Lors de la sélection d'une version, nous recommandons ce qui suit :
· Pour les développeurs débutants, il est conseillé de choisir la version stable v4.3 ou sa version révisée, qui s'aligne sur l'exampla version utilisée dans ce livre.
· Dans le cadre d'une production de masse, il est recommandé d'utiliser la dernière version stable pour bénéficier du support technique le plus à jour.
· Si vous avez l'intention d'expérimenter de nouvelles puces ou d'explorer de nouvelles fonctionnalités de produit, veuillez utiliser la branche master. La dernière version contient toutes les dernières fonctionnalités, mais gardez à l’esprit qu’il peut y avoir des bogues connus ou inconnus.
· Si la version stable utilisée n'inclut pas les nouvelles fonctionnalités souhaitées et que vous souhaitez minimiser les risques liés à la branche master, pensez à utiliser la branche release correspondante, comme la branche release/v4.4. Le référentiel GitHub d'Espressif créera d'abord la branche release/v4.4, puis publiera la version stable v4.4 sur la base d'un instantané historique spécifique de cette branche, après avoir terminé tous les développements et tests de fonctionnalités.
4.1.4 Plus deview du répertoire SDK ESP-IDF
Le SDK ESP-IDF se compose de deux répertoires principaux : esp-idf et .espressif. Le premier contient le code source du référentiel ESP-IDF files et scripts de compilation, tandis que ce dernier stocke principalement des chaînes d'outils de compilation et d'autres logiciels. La familiarité avec ces deux répertoires aidera les développeurs à mieux utiliser les ressources disponibles et à accélérer le processus de développement. La structure des répertoires d'ESP-IDF est décrite ci-dessous :
(1) Répertoire de codes du référentiel ESP-IDF (/esp/esp-idf), comme le montre la figure 4.2.
un. Composants du répertoire de composants
Ce répertoire principal intègre de nombreux composants logiciels essentiels d'ESP-IDF. Aucun code de projet ne peut être compilé sans s'appuyer sur les composants de ce répertoire. Il inclut la prise en charge des pilotes pour diverses puces Espressif. De la bibliothèque LL et des interfaces de bibliothèque HAL pour les périphériques au pilote et virtuel de niveau supérieur. File Prise en charge de la couche système (VFS), les développeurs peuvent choisir les composants appropriés à différents niveaux pour leurs besoins de développement. ESP-IDF prend également en charge plusieurs piles de protocoles réseau standard telles que TCP/IP, HTTP, MQTT, WebSocket, etc. Les développeurs peuvent utiliser des interfaces familières telles que Socket pour créer des applications réseau. Les composants fournissent une
34 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

Graphique 4.2. Répertoire de codes du référentiel ESP-IDF
fonctionnalité sive et peut être facilement intégré dans les applications, permettant aux développeurs de se concentrer uniquement sur la logique métier. Certains composants courants incluent : · pilote : ce composant contient des programmes de pilotes de périphériques pour divers Espressif
séries de puces, telles que GPIO, I2C, SPI, UART, LEDC (PWM), etc. Les programmes de pilotes de périphériques de ce composant offrent des interfaces abstraites indépendantes de la puce. Chaque périphérique a un en-tête commun file (comme gpio.h), éliminant ainsi le besoin de répondre à différentes questions d'assistance spécifiques à la puce. · esp_wifi : le Wi-Fi, en tant que périphérique spécial, est traité comme un composant distinct. Il comprend plusieurs API telles que l'initialisation de divers modes de pilote Wi-Fi, la configuration des paramètres et le traitement des événements. Certaines fonctions de ce composant sont fournies sous forme de bibliothèques de liens statiques. ESP-IDF fournit également une documentation complète sur les pilotes pour une utilisation facile.
Chapitre 4. Configuration de l'environnement de développement 35

· freertos : ce composant contient le code FreeRTOS complet. En plus de fournir un support complet pour ce système d'exploitation, Espressif a également étendu son support aux puces dual-core. Pour les puces double cœur comme ESP32 et ESP32-S3, les utilisateurs peuvent créer des tâches sur des cœurs spécifiques.
b. Documents du répertoire de documents
Ce répertoire contient des documents de développement liés à ESP-IDF, notamment le guide de démarrage, le manuel de référence de l'API, le guide de développement, etc.
REMARQUE Après avoir été compilé par des outils automatisés, le contenu de ce répertoire est déployé sur https://docs.espressif.com/projects/esp-idf. Veuillez vous assurer de basculer la cible du document sur ESP32-C3 et de sélectionner la version ESP-IDF spécifiée.
c. Outils de l'outil de script
Ce répertoire contient des outils frontaux de compilation couramment utilisés tels que idf.py et l'outil de terminal de surveillance idf_monitor.py, etc. Le sous-répertoire cmake contient également le script principal files du système de compilation, servant de base à la mise en œuvre des règles de compilation ESP-IDF. Lors de l'ajout des variables d'environnement, le contenu du répertoire tools est ajouté à la variable d'environnement système, permettant à idf.py d'être exécuté directement sous le chemin du projet.
d. Example répertoire des programmes examples
Ce répertoire comprend une vaste collection d'ex ESP-IDFamples programmes qui démontrent l’utilisation des API des composants. Le EXamples fichiers sont organisés en différents sous-répertoires en fonction de leurs catégories :
· commencer : ce sous-répertoire comprend les ex débutantsampdes fichiers comme « hello world » et « blink » pour aider les utilisateurs à comprendre les bases.
· Bluetooth : vous pouvez trouver des ex liés au Bluetoothamples ici, y compris Bluetooth LE Mesh, Bluetooth LE HID, BluFi, et plus encore.
· wifi : ce sous-répertoire se concentre sur le Wi-Fi exampfichiers, y compris des programmes de base comme Wi-Fi SoftAP, Wi-Fi Station, espnow, ainsi que le protocole de communication propriétaire examples de chez Espressif. Il comprend également plusieurs couches d'application exampfichiers basés sur le Wi-Fi, tels que Iperf, Sniffer et Smart Config.
· Périphériques : ce sous-répertoire étendu est divisé en de nombreux sous-dossiers basés sur les noms de périphériques. Il contient principalement un pilote de périphérique examples pour chips Espressif, avec chaque example mettant en vedette plusieurs sous-examples. Par exemple, le sous-répertoire gpio comprend deux examples : clavier GPIO et matrice GPIO. Il est important de noter que tous les examples fichiers de ce répertoire sont applicables à ESP32-C3.
36 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

Par exempleample, l'exampLes fichiers USB/Host ne sont applicables qu'aux périphériques dotés d'un matériel hôte USB (tels que l'ESP32-S3), et l'ESP32-C3 n'a pas ce périphérique. Le système de compilation fournit généralement des invites lors de la définition de la cible. Le fichier README file de chaque example répertorie les puces prises en charge. · protocols : Ce sous-répertoire contient exampfichiers pour divers protocoles de communication, notamment MQTT, HTTP, HTTP Server, PPPoS, Modbus, mDNS, SNTP, couvrant une large gamme de protocoles de communication exampfichiers requis pour le développement de l'IoT. · provisionnement : vous trouverez ici le provisionnement exampfichiers pour différentes méthodes, telles que l'approvisionnement Wi-Fi et l'approvisionnement Bluetooth LE. · système : ce sous-répertoire inclut le débogage du système exampfichiers (par exemple, suivi de pile, suivi d'exécution, surveillance des tâches), gestion de l'alimentation, etc.ampfichiers (par exemple, divers modes de veille, coprocesseurs), et exampchiers liés aux composants courants du système tels que le terminal de console, la boucle d'événements et la minuterie système. · stockage : Au sein de ce sous-répertoire, vous découvrirez examples de tous file systèmes et mécanismes de stockage pris en charge par ESP-IDF (tels que la lecture et l'écriture de Flash, de carte SD et d'autres supports de stockage), ainsi que exampfichiers de stockage non volatile (NVS), FatFS, SPIFFS et autres file opérations du système. · security : Ce sous-répertoire contient exampchiers liés au chiffrement flash. (2) Répertoire de la chaîne d'outils de compilation ESP-IDF (/.espressif), comme le montre la figure 4.3.
Graphique 4.3. Répertoire de la chaîne d'outils de compilation ESP-IDF
Chapitre 4. Configuration de l'environnement de développement 37

un. Répertoire de distribution de logiciels
La chaîne d'outils ESP-IDF et les autres logiciels sont distribués sous forme de packages compressés. Pendant le processus d'installation, l'outil d'installation télécharge d'abord le package compressé dans le répertoire dist, puis l'extrait dans le répertoire spécifié. Une fois l'installation terminée, le contenu de ce répertoire peut être supprimé en toute sécurité.
b. Répertoire d'environnement virtuel Python python env
Différentes versions d'ESP-IDF reposent sur des versions spécifiques des packages Python. L'installation de ces packages directement sur le même hôte peut entraîner des conflits entre les versions des packages. Pour résoudre ce problème, ESP-IDF utilise des environnements virtuels Python pour isoler différentes versions de packages. Grâce à ce mécanisme, les développeurs peuvent installer plusieurs versions d'ESP-IDF sur le même hôte et basculer facilement entre elles en important différentes variables d'environnement.
c. Outils de répertoire de la chaîne d'outils de compilation ESP-IDF
Ce répertoire contient principalement les outils de compilation croisée nécessaires à la compilation des projets ESP-IDF, tels que les outils CMake, les outils de build Ninja et la chaîne d'outils gcc qui génère le programme exécutable final. De plus, ce répertoire héberge la bibliothèque standard du langage C/C++ ainsi que l'en-tête correspondant. files. Si un programme fait référence à un en-tête système file comme #include , la chaîne d'outils de compilation localisera le stdio.h file dans ce répertoire.
4.2 Configuration de l'environnement de développement ESP-IDF
L'environnement de développement ESP-IDF prend en charge les systèmes d'exploitation courants tels que Windows, Linux et macOS. Cette section présentera comment configurer l'environnement de développement sur chaque système. Il est recommandé de développer ESP32-C3 sur le système Linux, qui sera présenté en détail ici. De nombreuses instructions sont applicables sur toutes les plateformes en raison de la similitude des outils de développement. Il est donc conseillé de lire attentivement le contenu de cette section.
REMARQUE Vous pouvez vous référer aux documents en ligne disponibles sur https://bookc3.espressif.com/esp32c3, qui fournissent les commandes mentionnées dans cette section.
4.2.1 Configuration de l'environnement de développement ESP-IDF sous Linux
Les outils de développement et de débogage GNU requis pour l'environnement de développement ESP-IDF sont natifs du système Linux. De plus, le terminal de ligne de commande sous Linux est puissant et convivial, ce qui en fait un choix idéal pour le développement ESP32-C3. Tu peux
38 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

sélectionnez votre distribution Linux préférée, mais nous vous recommandons d'utiliser Ubuntu ou d'autres systèmes basés sur Debian. Cette section fournit des conseils sur la configuration de l'environnement de développement ESP-IDF sur Ubuntu 20.04.
1. Installez les packages requis
Ouvrez un nouveau terminal et exécutez la commande suivante pour installer tous les packages nécessaires. La commande ignorera automatiquement les packages déjà installés.
$ 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
CONSEILS Vous devez utiliser le compte administrateur et le mot de passe pour la commande ci-dessus. Par défaut, aucune information ne sera affichée lors de la saisie du mot de passe. Appuyez simplement sur la touche « Entrée » pour poursuivre la procédure.
Git est un outil de gestion de code clé dans ESP-IDF. Après avoir configuré avec succès l'environnement de développement, vous pouvez utiliser la commande git log pour view toutes les modifications de code apportées depuis la création d'ESP-IDF. De plus, Git est également utilisé dans ESP-IDF pour confirmer les informations de version, nécessaires à l'installation de la chaîne d'outils appropriée correspondant à des versions spécifiques. Outre Git, d'autres outils système importants incluent Python. ESP-IDF intègre de nombreux scripts d'automatisation écrits en Python. Des outils tels que CMake, Ninja-build et Ccache sont largement utilisés dans les projets C/C++ et servent d'outils de compilation et de construction de code par défaut dans ESP-IDF. libusb-1.0-0 et dfu-util sont les principaux pilotes utilisés pour la communication série USB et la gravure de micrologiciels. Une fois les packages logiciels installés, vous pouvez utiliser la commande apt show pour obtenir des descriptions détaillées de chaque package. Par exempleample, utilisez apt show git pour imprimer les informations de description de l'outil Git.
Q : Que faire si la version Python n'est pas prise en charge ? R : ESP-IDF v4.3 nécessite une version Python qui n'est pas inférieure à la v3.6. Pour les anciennes versions d'Ubuntu, veuillez télécharger et installer manuellement une version supérieure de Python et définir Python3 comme environnement Python par défaut. Vous pouvez trouver des instructions détaillées en recherchant le mot-clé update-alternatives python.
2. Téléchargez le code du référentiel ESP-IDF
Ouvrez un terminal et créez un dossier nommé esp dans votre répertoire personnel à l'aide de la commande mkdir. Vous pouvez choisir un nom différent pour le dossier si vous préférez. Utilisez la commande cd pour accéder au dossier.
Chapitre 4. Configuration de l'environnement de développement 39

$ mkdir -p /esp $ cd /esp
Utilisez la commande git clone pour télécharger le code du référentiel ESP-IDF, comme indiqué ci-dessous :
$ git clone -b v4.3.2 – récursif https://github.com/espressif/esp-idf.git
Dans la commande ci-dessus, le paramètre -b v4.3.2 précise la version à télécharger (dans ce cas, la version 4.3.2). Le paramètre –recursive garantit que tous les sous-dépôts d'ESP-IDF sont téléchargés de manière récursive. Des informations sur les sous-dépôts peuvent être trouvées dans les .gitmodules file.
3. Installez la chaîne d'outils de développement ESP-IDF
Espressif fournit un script automatisé install.sh pour télécharger et installer la chaîne d'outils. Ce script vérifie la version actuelle d'ESP-IDF et l'environnement du système d'exploitation, puis télécharge et installe la version appropriée des packages d'outils Python et des chaînes d'outils de compilation. Le chemin d'installation par défaut de la chaîne d'outils est /.espressif. Tout ce que vous avez à faire est d’accéder au répertoire esp-idf et d’exécuter install.sh.
$ cd /esp/esp-idf $ ./install.sh
Si vous installez la chaîne d'outils avec succès, le terminal affichera :
Tout est fait !
À ce stade, vous avez configuré avec succès l’environnement de développement ESP-IDF.
4.2.2 Configuration de l'environnement de développement ESP-IDF sous Windows
1. Téléchargez le programme d'installation des outils ESP-IDF
CONSEILS Il est recommandé de configurer l'environnement de développement ESP-IDF sur Windows 10 ou supérieur. Vous pouvez télécharger le programme d'installation depuis https://dl.espressif.com/dl/esp-idf/. Le programme d'installation est également un logiciel open source et son code source peut être viewédité sur https://github.com/espressif/idf-installer.
· Installateur d'outils ESP-IDF en ligne
Ce programme d'installation est relativement petit, environ 4 Mo, et d'autres packages et codes seront téléchargés pendant le processus d'installation. L'avancéetagL'avantage du programme d'installation en ligne est que non seulement les packages logiciels et le code peuvent être téléchargés à la demande pendant le processus d'installation, mais il permet également l'installation de toutes les versions disponibles d'ESP-IDF et de la dernière branche du code GitHub (comme la branche principale). . L'inconvénienttagLa raison en est qu'il nécessite une connexion réseau pendant le processus d'installation, ce qui peut entraîner un échec de l'installation en raison de problèmes de réseau.
40 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

· Installateur d'outils ESP-IDF hors ligne Ce programme d'installation est plus grand, d'environ 1 Go, et contient tous les packages logiciels et le code requis pour la configuration de l'environnement. Le principal avantagetagL'avantage du programme d'installation hors ligne est qu'il peut être utilisé sur des ordinateurs sans accès à Internet et a généralement un taux de réussite d'installation plus élevé. Il convient de noter que le programme d'installation hors ligne ne peut installer que les versions stables d'ESP-IDF identifiées par v*.* ou v*.*.*.
2. Exécutez le programme d'installation des outils ESP-IDF Après avoir téléchargé une version appropriée du programme d'installation (prenez ESP-IDF Tools Offline 4.3.2 par exempleample ici), double-cliquez sur l'exe file pour lancer l'interface d'installation ESP-IDF. Ce qui suit montre comment installer la version stable d'ESP-IDF v4.3.2 à l'aide du programme d'installation hors ligne.
(1) Dans l'interface « Sélectionner la langue d'installation » illustrée à la figure 4.4, sélectionnez la langue à utiliser dans la liste déroulante.
Graphique 4.4. Interface « Sélectionner la langue d'installation » (2) Après avoir sélectionné la langue, cliquez sur « OK » pour faire apparaître l'interface « Contrat de licence »
(voir Figure 4.5). Après avoir lu attentivement le contrat de licence d'installation, sélectionnez « J'accepte le contrat » et cliquez sur « Suivant ».
Graphique 4.5. Interface « Contrat de licence » Chapitre 4. Configuration de l'environnement de développement 41

(3) Réview la configuration du système dans l’interface « Vérification du système avant l’installation » (voir Figure 4.6). Vérifiez la version de Windows et les informations sur le logiciel antivirus installé. Cliquez sur « Suivant » si tous les éléments de configuration sont normaux. Sinon, vous pouvez cliquer sur « Journal complet » pour des solutions basées sur des éléments clés.
Graphique 4.6. Interface « Vérification du système avant installation » CONSEILS
Vous pouvez soumettre des journaux à https://github.com/espressif/idf-installer/issues pour obtenir de l'aide. (4) Sélectionnez le répertoire d'installation ESP-IDF. Ici, sélectionnez D:/.espressif, comme indiqué dans
Figure 4.7, puis cliquez sur « Suivant ». Veuillez noter que .espressif est ici un répertoire caché. Une fois l'installation terminée, vous pouvez view le contenu spécifique de ce répertoire en ouvrant le file gestionnaire et affichage des éléments cachés.
Graphique 4.7. Sélectionnez le répertoire d'installation ESP-IDF 42 ESP32-C3 Wireless Adventure : Un guide complet de l'IoT

(5) Vérifiez les composants qui doivent être installés, comme indiqué sur la figure 4.8. Il est recommandé d'utiliser l'option par défaut, c'est-à-dire terminer l'installation, puis de cliquer sur « Suivant ».
Graphique 4.8. Sélectionnez les composants à installer (6) Confirmez les composants à installer et cliquez sur « Installer » pour démarrer l'installation automatique.
processus de décrochage, comme le montre la figure 4.9. Le processus d'installation peut durer des dizaines de minutes et la barre de progression du processus d'installation est illustrée à la figure 4.10. S'il vous plaît, attendez patiemment.
Graphique 4.9. Préparation de l'installation (7) Une fois l'installation terminée, il est recommandé de cocher « Enregistrer l'ESP-IDF
Outils exécutables comme exclusions de Windows Defender… » pour empêcher la suppression du logiciel antivirus files. L'ajout d'éléments d'exclusion peut également éviter les analyses fréquentes par antivirus
Chapitre 4. Configuration de l'environnement de développement 43

Graphique 4.10. Logiciel de barre de progression d'installation, améliorant considérablement l'efficacité de compilation de code du système Windows. Cliquez sur « Terminer » pour terminer l'installation de l'environnement de développement, comme le montre la figure 4.11. Vous pouvez choisir de cocher « Exécuter l'environnement PowerShell ESP-IDF » ou « Exécuter l'invite de commande ESP-IDF ». Exécutez la fenêtre de compilation directement après l'installation pour vous assurer que l'environnement de développement fonctionne normalement.
Graphique 4.11. Installation terminée (8) Ouvrez l'environnement de développement installé dans la liste des programmes (soit ESP-IDF 4.3
CMD ou ESP-IDF 4.3 PowerShell, comme illustré dans la figure 4.12), et la variable d'environnement ESP-IDF seront automatiquement ajoutées lors de l'exécution dans le terminal. Après cela, vous pouvez utiliser la commande idf.py pour les opérations. Le CMD ESP-IDF 4.3 ouvert est illustré à la figure 4.13. 44 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

Graphique 4.12. Environnement de développement installé
Graphique 4.13. ESP-IDF 4.3 CMD
4.2.3 Configuration de l'environnement de développement ESP-IDF sur Mac
Le processus d'installation de l'environnement de développement ESP-IDF sur un système Mac est le même que celui sur un système Linux. Les commandes pour télécharger le code du référentiel et installer la chaîne d'outils sont exactement les mêmes. Seules les commandes d'installation des packages de dépendances sont légèrement différentes. 1. Installer les packages de dépendances Ouvrez un terminal et installez pip, l'outil de gestion des packages Python, en exécutant la commande suivante :
% sudo installation facile pip
Installez Homebrew, un outil de gestion de packages pour macOS, en exécutant la commande suivante :
% /bin/bash -c « $(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/ HEAD/install.sh) »
Installez les packages de dépendances requis en exécutant la commande suivante :
% Brew Python3 installe cmake ninja ccache dfu-util
2. Téléchargez le code du référentiel ESP-IDF Suivez les instructions fournies dans la section 4.2.1 pour télécharger le code du référentiel ESP-IDF. Les étapes sont les mêmes que pour le téléchargement sur un système Linux.
Chapitre 4. Configuration de l'environnement de développement 45

3. Installez la chaîne d'outils de développement ESP-IDF
Suivez les instructions fournies dans la section 4.2.1 pour installer la chaîne d'outils de développement ESP-IDF. Les étapes sont les mêmes que pour une installation sur un système Linux.
4.2.4 Installation de VSCode
Par défaut, le SDK ESP-IDF n'inclut pas d'outil d'édition de code (bien que le dernier programme d'installation d'ESP-IDF pour Windows offre la possibilité d'installer ESP-IDF Eclipse). Vous pouvez utiliser n'importe quel outil d'édition de texte de votre choix pour modifier le code, puis le compiler à l'aide des commandes du terminal.
Un outil d'édition de code populaire est VS Code (Visual Studio Code), qui est un éditeur de code gratuit et riche en fonctionnalités avec une interface conviviale. Il propose divers plugins qui fournissent des fonctionnalités telles que la navigation dans le code, la coloration syntaxique, le contrôle de version Git et l'intégration de terminaux. De plus, Espressif a développé un plugin dédié appelé Espressif IDF pour VS Code, qui simplifie la configuration et le débogage du projet.
Vous pouvez utiliser la commande code dans le terminal pour ouvrir rapidement le dossier actuel dans VS Code. Vous pouvez également utiliser le raccourci Ctrl+ pour ouvrir la console de terminal par défaut du système dans VS Code.
CONSEILS Il est recommandé d'utiliser VS Code pour le développement de code ESP32-C3. Téléchargez et installez la dernière version de VS Code sur https://code.visualstudio.com/.
4.2.5 Introduction aux environnements de développement tiers
En plus de l'environnement de développement officiel ESP-IDF, qui utilise principalement le langage C, ESP32-C3 prend également en charge d'autres langages de programmation courants et un large éventail d'environnements de développement tiers. Certaines options notables incluent :
Arduino : une plate-forme open source pour le matériel et les logiciels, prenant en charge divers microcontrôleurs, dont ESP32-C3.
Il utilise le langage C++ et propose une API simplifiée et standardisée, communément appelée langage Arduino. Arduino est largement utilisé dans le développement de prototypes et dans des contextes éducatifs. Il fournit un progiciel extensible et un IDE qui permet une compilation et un flashage faciles.
MicroPython : un interpréteur du langage Python 3 conçu pour fonctionner sur des plateformes de microcontrôleurs embarqués.
Avec un langage de script simple, il peut accéder directement aux ressources périphériques de l'ESP32-C3 (telles que UART, SPI et I2C) et aux fonctions de communication (telles que Wi-Fi et Bluetooth LE).
46 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

Cela simplifie l'interaction matérielle. MicroPython, combiné à la vaste bibliothèque d'opérations mathématiques de Python, permet la mise en œuvre d'algorithmes complexes sur ESP32-C3, facilitant ainsi le développement d'applications liées à l'IA. En tant que langage de script, il n’est pas nécessaire de procéder à une compilation répétée ; des modifications peuvent être apportées et des scripts peuvent être exécutés directement.
NodeMCU : un interpréteur de langage LUA développé pour les puces de la série ESP.
Il prend en charge presque toutes les fonctions périphériques des puces ESP et est plus léger que MicroPython. Semblable à MicroPython, NodeMCU utilise un langage de script, éliminant le besoin de compilation répétée.
De plus, ESP32-C3 prend également en charge les systèmes d'exploitation NuttX et Zephyr. NuttX est un système d'exploitation en temps réel qui fournit des interfaces compatibles POSIX, améliorant ainsi la portabilité des applications. Zephyr est un petit système d'exploitation en temps réel spécialement conçu pour les applications IoT. Il comprend de nombreuses bibliothèques de logiciels nécessaires au développement de l'IoT, évoluant progressivement vers un écosystème logiciel complet.
Ce livre ne fournit pas d'instructions d'installation détaillées pour les environnements de développement susmentionnés. Vous pouvez installer un environnement de développement en fonction de vos besoins en suivant la documentation et les instructions respectives.
4.3 Système de compilation ESP-IDF
4.3.1 Concepts de base du système de compilation
Un projet ESP-IDF est un ensemble d'un programme principal avec une fonction d'entrée et plusieurs composants fonctionnels indépendants. Par exempleample, un projet qui contrôle les commutateurs LED se compose principalement d'un programme d'entrée principal et d'un composant pilote qui contrôle GPIO. Si vous souhaitez réaliser la télécommande LED, vous devez également ajouter le Wi-Fi, la pile de protocole TCP/IP, etc.
Le système de compilation peut compiler, lier et générer un exécutable files (.bin) pour le code via un ensemble de règles de construction. Le système de compilation des versions ESP-IDF v4.0 et supérieures est basé sur CMake par défaut, et le script de compilation CMakeLists.txt peut être utilisé pour contrôler le comportement de compilation du code. En plus de prendre en charge la syntaxe de base de CMake, le système de compilation ESP-IDF définit également un ensemble de règles de compilation par défaut et de fonctions CMake, et vous pouvez écrire le script de compilation avec des instructions simples.
4.3.2 Projet File Structure
Un projet est un dossier qui contient un programme d'entrée principal, des composants définis par l'utilisateur et fileest requis pour créer des applications exécutables, telles que des scripts de compilation, des
Chapitre 4. Configuration de l'environnement de développement 47

files, tables de partition, etc. Les projets peuvent être copiés et transmis, et le même exécutable file peut être compilé et généré sur des machines avec la même version de l'environnement de développement ESP-IDF. Un projet typique ESP-IDF file La structure est illustrée à la figure 4.14.
Graphique 4.14. Projet type ESP-IDF file structure Étant donné que ESP-IDF prend en charge plusieurs puces IoT d'Espressif, notamment ESP32, la série ESP32-S, la série ESP32-C, la série ESP32-H, etc., une cible doit être déterminée avant de compiler le code. La cible est à la fois le périphérique matériel qui exécute le programme d'application et la cible de construction du système de compilation. En fonction de vos besoins, vous pouvez spécifier une ou plusieurs cibles pour votre projet. Par exempleample, via la commande idf.py set-target esp32c3, vous pouvez définir la cible de compilation sur ESP32-C3, au cours de laquelle les paramètres par défaut et le chemin de la chaîne d'outils de compilation pour ESP32C3 seront chargés. Après compilation, un programme exécutable peut être généré pour ESP32C3. Vous pouvez également exécuter à nouveau la commande set-target pour définir une cible différente, et le système de compilation sera automatiquement nettoyé et reconfiguré. Composants
Les composants d'ESP-IDF sont des unités de code modulaires et indépendantes gérées au sein du système de compilation. Ils sont organisés sous forme de dossiers, le nom du dossier représentant le nom du composant par défaut. Chaque composant possède son propre script de compilation qui 48 ESP32-C3 Wireless Adventure : Un guide complet de l'IoT

spécifie ses paramètres de compilation et ses dépendances. Pendant le processus de compilation, les composants sont compilés dans des bibliothèques statiques distinctes (.a files) et éventuellement combiné avec d'autres composants pour former le programme d'application.
ESP-IDF fournit des fonctions essentielles, telles que le système d'exploitation, les pilotes de périphériques et la pile de protocoles réseau, sous forme de composants. Ces composants sont stockés dans le répertoire des composants situé dans le répertoire racine ESP-IDF. Les développeurs n'ont pas besoin de copier ces composants dans le répertoire des composants de myProject. Au lieu de cela, il leur suffit de spécifier les relations de dépendance de ces composants dans le fichier CMakeLists.txt du projet. file en utilisant les directives REQUIRES ou PRIV_REQUIRES. Le système de compilation localisera et compilera automatiquement les composants requis.
Par conséquent, le répertoire des composants sous myProject n’est pas nécessaire. Il est uniquement utilisé pour inclure certains composants personnalisés du projet, qui peuvent être des bibliothèques tierces ou du code défini par l'utilisateur. De plus, les composants peuvent provenir de n'importe quel répertoire autre que ESP-IDF ou le projet en cours, par exemple à partir d'un projet open source enregistré dans un autre répertoire. Dans ce cas, il vous suffit d'ajouter le chemin du composant en définissant la variable EXTRA_COMPONENT_DIRS dans le CMakeLists.txt sous le répertoire racine. Ce répertoire remplacera tout composant ESP-IDF portant le même nom, garantissant ainsi que le composant correct est utilisé.
Programme d'entrée principal Le répertoire principal du projet suit le même file structure comme les autres composants (par exemple, composant1). Cependant, il revêt une importance particulière car il s’agit d’un élément obligatoire qui doit exister dans tout projet. Le répertoire principal contient le code source du projet et le point d'entrée du programme utilisateur, généralement nommé app_main. Par défaut, l'exécution du programme utilisateur démarre à partir de ce point d'entrée. Le composant principal diffère également dans le sens où il dépend automatiquement de tous les composants du chemin de recherche. Par conséquent, il n'est pas nécessaire d'indiquer explicitement les dépendances à l'aide des directives REQUIRES ou PRIV_REQUIRES dans le fichier CMakeLists.txt. file.
Configuration file Le répertoire racine du projet contient une configuration file appelé sdkconfig, qui contient les paramètres de configuration de tous les composants du projet. Le SDKconfig file est automatiquement généré par le système de compilation et peut être modifié et régénéré par la commande idf.py menuconfig. Les options menuconfig proviennent principalement du Kconfig.projbuild du projet et du Kconfig des composants. Les développeurs de composants ajoutent généralement des éléments de configuration dans Kconfig pour rendre le composant flexible et configurable.
Répertoire de construction Par défaut, le répertoire de construction au sein du projet stocke les files et le fi-
Chapitre 4. Configuration de l'environnement de développement 49

Programmes exécutables finaux générés par la commande idf.py build. En général, il n’est pas nécessaire d’accéder directement au contenu du répertoire build. ESP-IDF fournit des commandes prédéfinies pour interagir avec le répertoire, comme l'utilisation de la commande flash idf.py pour localiser automatiquement le binaire compilé. file et flashez-le à l'adresse flash spécifiée, ou en utilisant la commande idf.py fullclean pour nettoyer l'intégralité du répertoire de construction.
Table de partition (partitions.csv) Chaque projet nécessite une table de partition pour diviser l'espace flash et spécifier la taille et l'adresse de départ du programme exécutable et de l'espace de données utilisateur. La commande idf.py flash ou le programme de mise à niveau OTA fera clignoter le firmware à l'adresse correspondante selon ce tableau. ESP-IDF fournit plusieurs tables de partition par défaut dans composants/partition_table, telles que partitions_singleapp.csv et partitions_two_ota.csv, qui peuvent être sélectionnées dans menuconfig.
Si la table de partition par défaut du système ne peut pas répondre aux exigences du projet, un fichier partitions.csv personnalisé peut être ajouté au répertoire du projet et sélectionné dans menuconfig.
4.3.3 Règles de construction par défaut du système de compilation
Règles de remplacement des composants portant le même nom Lors du processus de recherche de composants, le système de compilation suit un ordre spécifique. Il recherche d'abord les composants internes d'ESP-IDF, puis recherche les composants du projet utilisateur et enfin recherche les composants dans EXTRA_COMPONENT_DIRS. Dans les cas où plusieurs répertoires contiennent des composants portant le même nom, le composant trouvé dans le dernier répertoire remplacera tous les composants précédents portant le même nom. Cette règle permet la personnalisation des composants ESP-IDF au sein du projet utilisateur, tout en gardant intact le code ESP-IDF d'origine.
Règles d'inclusion des composants communs par défaut Comme mentionné dans la section 4.3.2, les composants doivent spécifier explicitement leurs dépendances sur d'autres composants dans le fichier CMakeLists.txt. Cependant, les composants courants tels que les freertos sont automatiquement inclus par défaut dans le système de construction, même si leurs relations de dépendance ne sont pas explicitement définies dans le script de compilation. Les composants communs ESP-IDF incluent freertos, Newlib, heap, log, soc, esp_rom, esp_common, xtensa/riscv et cxx. L'utilisation de ces composants communs évite le travail répétitif lors de l'écriture de CMakeLists.txt et le rend plus concis.
Règles de remplacement des éléments de configuration Les développeurs peuvent ajouter des paramètres de configuration par défaut en ajoutant une configuration par défaut file nommé sdkconfig.defaults au projet. Par exempleample, en ajoutant CONFIG_LOG_
50 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

DEFAULT_LEVEL_NONE = y peut configurer l'interface UART pour ne pas imprimer les données du journal par défaut. De plus, si des paramètres spécifiques doivent être définis pour une cible particulière, une configuration file nommé sdkconfig.defaults.TARGET_NAME peut être ajouté, où TARGET_NAME peut être esp32s2, esp32c3, etc. Ces configurations fileLes s sont importés dans le sdkconfig lors de la compilation, avec la configuration générale par défaut file sdkconfig.defaults étant importé en premier, suivi de la configuration spécifique à la cible file, tel que sdkconfig.defaults.esp32c3. Dans les cas où il existe des éléments de configuration portant le même nom, cette dernière configuration file remplacera le premier.
4.3.4 Introduction au script de compilation
Lors du développement d'un projet à l'aide d'ESP-IDF, les développeurs doivent non seulement écrire le code source, mais également écrire CMakeLists.txt pour le projet et les composants. CMakeLists.txt est un texte file, également appelé script de compilation, qui définit une série d'objets de compilation, d'éléments de configuration de compilation et de commandes pour guider le processus de compilation du code source. Le système de compilation d'ESP-IDF v4.3.2 est basé sur CMake. En plus de prendre en charge les fonctions et commandes natives de CMake, il définit également une série de fonctions personnalisées, facilitant grandement l'écriture de scripts de compilation.
Les scripts de compilation dans ESP-IDF incluent principalement le script de compilation du projet et les scripts de compilation des composants. Le CMakeLists.txt dans le répertoire racine du projet est appelé script de compilation du projet, qui guide le processus de compilation de l'ensemble du projet. Un script de compilation de projet de base comprend généralement les trois lignes suivantes :
1. cmake_minimum_required(VERSION 3.5) 2. include($ENV{IDF_PATH}/tools/cmake/project.cmake) 3. projet(monProjet)
Parmi eux, le cmake_minimum_required (VERSION 3.5) doit être placé sur la première ligne, qui sert à indiquer le numéro de version minimum de CMake requis par le projet. Les versions plus récentes de CMake sont généralement rétrocompatibles avec les anciennes versions, ajustez donc le numéro de version en conséquence lorsque vous utilisez des commandes CMake plus récentes pour garantir la compatibilité.
include($ENV {IDF_PATH}/tools/cmake/project.cmake) importe des éléments de configuration et des commandes prédéfinis du système de compilation ESP-IDF, y compris les règles de construction par défaut du système de compilation décrites dans la section 4.3.3. project(myProject) crée le projet lui-même et spécifie son nom. Ce nom sera utilisé comme binaire de sortie final file nom, c'est-à-dire myProject.elf et myProject.bin.
Un projet peut avoir plusieurs composants, y compris le composant principal. Le répertoire de niveau supérieur de chaque composant contient un fichier CMakeLists.txt file, appelé script de compilation de composants. Les scripts de compilation de composants sont principalement utilisés pour spécifier les dépendances des composants, les paramètres de configuration, le code source files, et en-tête inclus files pour
Chapitre 4. Configuration de l'environnement de développement 51

compilation. Avec la fonction personnalisée idf_component_register d'ESP-IDF, le code minimum requis pour un script de compilation de composants est le suivant :

1. idf_component_register (SRCS « src1.c »

INCLUDE_DIRS "inclure"

NÉCESSITE le composant1)

Le paramètre SRCS fournit une liste de sources files dans le composant, séparés par des espaces s'il y en a plusieurs files. Le paramètre INCLUDE_DIRS fournit une liste d'en-têtes publics file répertoires du composant, qui seront ajoutés au chemin de recherche d'inclusion pour les autres composants qui dépendent du composant actuel. Le paramètre REQUIRES identifie les dépendances du composant public pour le composant actuel. Il est nécessaire que les composants indiquent explicitement de quels composants ils dépendent, comme par exemple le composant2 dépendant du composant1. Cependant, pour le composant principal, qui dépend par défaut de tous les composants, le paramètre REQUIRES peut être omis.

De plus, les commandes CMake natives peuvent également être utilisées dans le script de compilation. Par exempleample, utilisez la commande set pour définir des variables, telles que set(VARIABLE « VALUE »).

4.3.5 Introduction aux commandes courantes
ESP-IDF utilise CMake (outil de configuration de projet), Ninja (outil de création de projet) et esptool (outil flash) dans le processus de compilation de code. Chaque outil joue un rôle différent dans le processus de compilation, de création et de flash, et prend également en charge différentes commandes d'exploitation. Pour faciliter l'utilisation de l'utilisateur, ESP-IDF ajoute un frontal unifié idf.py qui permet d'appeler rapidement les commandes ci-dessus.
Avant d'utiliser idf.py, assurez-vous que :
· La variable d'environnement IDF_PATH d'ESP-IDF a été ajoutée au terminal actuel. · Le répertoire d'exécution des commandes est le répertoire racine du projet, qui comprend le
script de compilation de projet CMakeLists.txt.
Les commandes courantes de idf.py sont les suivantes :
· idf.py –help : affichage d'une liste de commandes et de leurs instructions d'utilisation. · idf.py set-target : définition de la compilation taidf.py fullcleanrget, telle que
en remplaçant par esp32c3. · idf.py menuconfig : lancement de menuconfig, une configuration graphique de terminal
outil, qui peut sélectionner ou modifier les options de configuration, et les résultats de la configuration sont enregistrés dans le sdkconfig file. · build idf.py : lancement de la compilation du code. L'intermédiaire files et le programme exécutable final généré par la compilation seront enregistrés par défaut dans le répertoire build du projet. Le processus de compilation est incrémental, ce qui signifie que si une seule source file est modifié, seul le modifié file sera compilé la prochaine fois.

52 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

· idf.py clean : nettoyage de l'intermédiaire files générés par la compilation du projet. L'ensemble du projet sera obligé d'être compilé lors de la prochaine compilation. Notez que la configuration CMake et les modifications de configuration apportées par menuconfig ne seront pas supprimées lors du nettoyage.
· idf.py fullclean : suppression de l'intégralité du répertoire de construction, y compris toutes les sorties de configuration CMake files. Lors de la nouvelle construction du projet, CMake configurera le projet à partir de zéro. Veuillez noter que cette commande supprimera récursivement tous files dans le répertoire build, utilisez-le donc avec prudence, et la configuration du projet file ne sera pas supprimé.
· idf.py flash : flasher le binaire du programme exécutable file généré par la construction sur la cible ESP32-C3. Les options -p et -b sont utilisées pour définir respectivement le nom de périphérique du port série et le débit en bauds pour le clignotement. Si ces deux options ne sont pas spécifiées, le port série sera automatiquement détecté et le débit en bauds par défaut sera utilisé.
· Moniteur idf.py : affichant la sortie du port série de l'ESP32-C3 cible. L'option -p peut être utilisée pour spécifier le nom de périphérique du port série côté hôte. Pendant l'impression sur le port série, appuyez sur la combinaison de touches Ctrl+] pour quitter le moniteur.
Les commandes ci-dessus peuvent également être combinées selon les besoins. Par exempleample, la commande idf.py build flash monitor effectuera la compilation du code, flashera et ouvrira le moniteur du port série en séquence.
Vous pouvez visiter https://bookc3.espressif.com/build-system pour en savoir plus sur le système de compilation ESP-IDF.
4.4 Pratique : Compiler Example programme « Blink »
4.4.1 Exampl'analyse
Cette section prendra le programme Blink comme example pour analyser le file la structure et les règles de codage d'un projet réel en détail. Le programme Blink implémente l'effet clignotant des LED et le projet se trouve dans le répertoire examples/get-started/blink, qui contient une source file, configuration files et plusieurs scripts de compilation.
Le projet d'éclairage intelligent présenté dans ce livre est basé sur cet example programme. Des fonctions seront progressivement ajoutées dans les chapitres ultérieurs pour enfin le compléter.
Code source Afin de démontrer l'ensemble du processus de développement, le programme Blink a été copié dans esp32c3-iot-projects/device firmware/1 clin.
La structure des répertoires du projet Blink files est illustré à la figure 4.15.
Le projet Blink ne contient qu'un seul répertoire principal, qui est un composant spécial qui
Chapitre 4. Configuration de l'environnement de développement 53

Figure 4.15. File structure des répertoires du projet Blink

doivent être inclus comme décrit à la section 4.3.2. Le répertoire principal est principalement utilisé pour stocker l'implémentation de la fonction app_main(), qui est le point d'entrée du programme utilisateur. Le projet Blink n'inclut pas le répertoire des composants, car cet example doit uniquement utiliser les composants fournis avec ESP-IDF et ne nécessite pas de composants supplémentaires. Le CMakeLists.txt inclus dans le projet Blink est utilisé pour guider le processus de compilation, tandis que Kconfig.projbuild est utilisé pour ajouter des éléments de configuration pour cet ex.ample programme dans menuconfig. Autre inutile fileLes s n'affecteront pas la compilation du code, ils ne seront donc pas abordés ici. Une introduction détaillée au projet Blink files est le suivant.

1. /*blink.c inclut l'en-tête suivant files*/

2. #include

//En-tête de bibliothèque standard C file

3. #include « freertos/freeRTOS.h » //En-tête principal FreeRTOS file

4. #include « freertos/task.h »

//En-tête de tâche FreeRTOS file

5. #include « sdkconfig.h »

//En-tête de configuration file généré par kconfig

6. #include « driver/gpio.h »

//En-tête du pilote GPIO file

La source file Blink.c contient une série d'en-têtes files correspondant à la déclaration de fonction

tion. ESP-IDF suit généralement l'ordre d'inclusion de l'en-tête de bibliothèque standard files, LibreR-

En-tête des conditions d'utilisation files, en-tête du pilote files, autre en-tête de composant files et en-tête du projet files.

L'ordre dans lequel l'en-tête files sont inclus peuvent affecter le résultat final de la compilation, alors essayez de

suivez les règles par défaut. A noter que sdkconfig.h est généré automatiquement

par kconfig et ne peut être configuré que via la commande idf.py menuconfig.

Modification directe de cet en-tête file sera écrasé.

1. /*Vous pouvez sélectionner le GPIO correspondant à la LED dans idf.py menuconfig, et le résultat de la modification de menuconfig est que la valeur de CONFIG_BLINK

_GPIO sera modifié. Vous pouvez également modifier directement la définition de la macro

ici, et remplacez CONFIG_BLINK_GPIO par une valeur fixe.*/ 2. #define BLINK_GPIO CONFIG_BLINK_GPIO

3. void app_main(void)

4. {

/*Configurer IO comme fonction GPIO par défaut, activer le mode pull-up et

désactiver les modes d'entrée et de sortie*/

gpio_reset_pin(BLINK_GPIO);

54 ESP32-C3 Wireless Adventure : un guide complet de l'IoT

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

/*Mettez GPIO en mode sortie*/ gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT); tandis que(1) {
/*Imprimer le journal*/ printf(« Éteindre la LEDn »); /*Éteignez la LED (niveau de sortie faible)*/ gpio_set_level(BLINK_GPIO, 0); /*Délai (1000 ms)*/ vTaskDelay(1000 / portTICK_PERIOD_MS); printf("Allumer la LEDn"); /*Allumez la LED (niveau de sortie élevé)*/ gpio_set_level(BLINK_GPIO, 1); vTaskDelay(1000 / portTICK_PERIOD_MS); }

La fonction app_main() dans l'ex BlinkampLe programme sert de point d'entrée aux programmes utilisateur. C'est une fonction simple sans paramètres ni valeur de retour. Cette fonction est appelée une fois l'initialisation du système terminée, qui comprend des tâches telles que l'initialisation du port série de journal, la configuration d'un cœur simple/double et la configuration du chien de garde.

La fonction app_main() s'exécute dans le contexte d'une tâche nommée main. La taille de la pile et la priorité de cette tâche peuvent être ajustées dans menuconfig Componentconfig Common ESP-liated.

Pour des tâches simples comme faire clignoter une LED, tout le code nécessaire peut être implémenté directement dans la fonction app_main(). Cela implique généralement d'initialiser le GPIO correspondant à la LED et d'utiliser une boucle while(1) pour allumer et éteindre la LED. Vous pouvez également utiliser l'API FreeRTOS pour créer une nouvelle tâche qui gère le clignotement du voyant. Une fois la nouvelle tâche créée avec succès, vous pouvez quitter la fonction app_main().

Le contenu de main/CMakeLists.txt file, qui guide le processus de compilation du composant principal, est le suivant :

1. idf_component_register(SRCS "blink.c" INCLUDE_DIRS "." )

Parmi eux, main/CMakeLists.txt n'appelle qu'une seule fonction du système de compilation, à savoir idf_component_register. Semblable au CMakeLists.txt pour la plupart des autres composants, clignotant.c est ajouté au SRCS et la source fileLes fichiers ajoutés au SRCS seront compilés. Dans le même temps, ".", qui représente le chemin où se trouve CMakeLists.txt, doit être ajouté à INCLUDE_DIRS comme répertoires de recherche pour l'en-tête. files. Le contenu de CMakeLists.txt est le suivant :
1. #Spécifiez v3.5 comme la version la plus ancienne de CMake prise en charge par le projet actuel 2. #Les versions inférieures à v3.5 doivent être mises à niveau avant que la compilation ne continue 3. cmake_minimum_required(VERSION 3.5) 4. #Inclure la configuration CMake par défaut de l'ESP -Système de compilation IDF

Chapitre 4. Configuration de l'environnement de développement 55

5. include($ENV{IDF_PATH}/tools/cmake/project.cmake) 6. #Créer un projet nommé « blink » 7. project(myProject)
Parmi eux, le fichier CMakeLists.txt dans le répertoire racine comprend principalement $ENV{IDF_ PATH}/tools/cmake/project.cmake, qui est la configuration principale de CMake. file fourni par ESP-IDF. Il est utilisé pour con

Documents / Ressources

Espressif Systems ESP32-C3 Aventure sans fil [pdf] Guide de l'utilisateur
ESP32-C3 Aventure sans fil, ESP32-C3, Aventure sans fil, Aventure

Références

Manuel d'utilisation

Aventure sans fil ESP32-C3