Guida per l'utente di Espressif Systems ESP32-C3 Wireless Adventure

Prima di utilizzare ESP32-C3 Wireless Adventure, assicurati di esserlo
familiarità con i concetti e l'architettura dell'IoT. Questo aiuterà
capisci come il dispositivo si inserisce nel più ampio ecosistema IoT
e le sue potenziali applicazioni nelle case intelligenti.

Introduzione e pratica dei progetti IoT

In questa sezione imparerai i tipici progetti IoT,
compresi i moduli base per i comuni dispositivi IoT, moduli base
di applicazioni client e piattaforme cloud IoT comuni. Questo sarà
fornirti una base per comprendere e creare il tuo
propri progetti IoT.

Esercitazione: Progetto Luce Intelligente

In questo progetto pratico imparerai come creare un file smart
luce utilizzando ESP32-C3 Wireless Adventure. La struttura del progetto,
funzioni, preparazione dell'hardware e processo di sviluppo
spiegato in dettaglio.

Struttura del progetto

Il progetto è composto da diversi componenti, tra cui il
ESP32-C3 Wireless Adventure, LED, sensori e una nuvola
indietro.

Funzioni del progetto

Il progetto luce intelligente ti consente di controllare la luminosità e
colore dei LED da remoto tramite un'app mobile o web
interfaccia.

Preparazione hardware

Per prepararti al progetto, dovrai raccogliere i file
componenti hardware necessari, come ESP32-C3 Wireless
Scheda Adventure, LED, resistori e alimentatore.

Processo di sviluppo

Il processo di sviluppo prevede l'impostazione dello sviluppo
ambiente, scrivendo il codice per controllare i LED, collegandosi al
backend cloud e testare la funzionalità dello smart
leggero.

Introduzione all'ESP RainMaker

ESP RainMaker è un potente framework per lo sviluppo dell'IoT
dispositivi. In questa sezione imparerai cos'è ESP RainMaker e
come può essere implementato nei tuoi progetti.

Cos'è ESP RainMaker?

ESP RainMaker è una piattaforma basata su cloud che fornisce una serie di
strumenti e servizi per la creazione e la gestione di dispositivi IoT.

L'implementazione di ESP RainMaker

Questa sezione spiega i diversi componenti coinvolti
implementazione di ESP RainMaker, incluso il servizio di richiesta di risarcimento,
Agente RainMaker, backend cloud e client RainMaker.

Esercitazione: punti chiave per lo sviluppo con ESP RainMaker

In questa sezione pratica imparerai i punti chiave
considerare quando si sviluppa con ESP RainMaker. Ciò include il dispositivo
rivendicazione, sincronizzazione dei dati e gestione degli utenti.

Caratteristiche di ESP RainMaker

ESP RainMaker offre varie funzionalità per la gestione degli utenti, end
utenti e amministratori. Queste funzionalità consentono un dispositivo semplice
configurazione, controllo remoto e monitoraggio.

Impostazione dell'ambiente di sviluppo

Questa sezione fornisce una panoramicaview di ESP-IDF (Espressif IoT
Development Framework), che è il quadro di sviluppo ufficiale
per dispositivi basati su ESP32. Spiega le diverse versioni di
ESP-IDF e come impostare l'ambiente di sviluppo.

Sviluppo hardware e driver

Progettazione hardware di prodotti Smart Light basati su ESP32-C3

Questa sezione si concentra sulla progettazione hardware della luce intelligente
prodotti basati su ESP32-C3 Wireless Adventure. Copre il
caratteristiche e composizione dei prodotti di illuminazione intelligente, nonché
progettazione hardware del sistema principale ESP32-C3.

Caratteristiche e composizione dei prodotti Smart Light

Questa sottosezione spiega le caratteristiche e i componenti che compongono
creare prodotti di illuminazione intelligenti. Discute le diverse funzionalità
e considerazioni sulla progettazione per la creazione di luci intelligenti.

Progettazione hardware del sistema principale ESP32-C3

La progettazione hardware del sistema principale ESP32-C3 include l'alimentazione
alimentazione, sequenza di accensione, ripristino del sistema, flash SPI, sorgente orologio,
e considerazioni su RF e antenne. Questa sottosezione fornisce
informazioni dettagliate su questi aspetti.

Domande frequenti

D: Cos'è ESP RainMaker?

R: ESP RainMaker è una piattaforma basata su cloud che fornisce strumenti
e servizi per la creazione e la gestione di dispositivi IoT. Semplifica
il processo di sviluppo e consente una facile configurazione del dispositivo, da remoto
controllo e monitoraggio.

D: Come posso configurare l'ambiente di sviluppo per
ESP32-C3?

R: Per configurare l'ambiente di sviluppo per ESP32-C3, è necessario
installare ESP-IDF (Espressif IoT Development Framework) e
configurarlo secondo le istruzioni fornite. ESP-IDF è il
framework di sviluppo ufficiale per dispositivi basati su ESP32.

D: Quali sono le funzionalità di ESP RainMaker?

R: ESP RainMaker offre varie funzionalità, incluso l'utente
gestione, funzionalità per l'utente finale e funzionalità di amministrazione. Gestione utenti
consente una facile richiesta del dispositivo e sincronizzazione dei dati. Utente finale
le funzionalità consentono il controllo remoto dei dispositivi tramite un'app mobile o
web interfaccia. Le funzionalità di amministrazione forniscono strumenti per il monitoraggio del dispositivo
e gestione.

View Fullscreen

ESP32-C3 Avventura senza fili
Una guida completa all'IoT
Sistemi Espressif 12 giugno 2023

Contenuto

Io Preparazione

1 Introduzione all'IoT

1.1 Architettura dell'IoT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.2 Applicazione IoT nelle case intelligenti . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2 Introduzione e pratica dei progetti IoT

2.1 Introduzione ai tipici progetti IoT . . . . . . . . . . . . . . . . . . . . . . . . 9

2.1.1 Moduli di base per dispositivi IoT comuni. . . . . . . . . . . . . . . . . 9

2.1.2 Moduli base delle applicazioni client . . . . . . . . . . . . . . . . . . . 10

2.1.3 Introduzione alle piattaforme cloud IoT comuni. . . . . . . . . . . . . . 11

2.2 Esercitazione: Progetto Smart Light . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2.2.1 Struttura del progetto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.2.2 Funzioni del progetto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.2.3 Preparazione dell'hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.2.4 Processo di sviluppo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.3 Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3 Introduzione all'ESP RainMaker

3.1 Cos'è ESP RainMaker? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

3.2 L'implementazione di ESP RainMaker. . . . . . . . . . . . . . . . . . . . . . 21

3.2.1 Servizio di richiesta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3.2.2 Agente RainMaker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3.2.3 Backend cloud . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.2.4 Cliente RainMaker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

3.3 Pratica: punti chiave per lo sviluppo con ESP RainMaker . . . . . . . . . . . . 25

3.4 Caratteristiche di ESP RainMaker . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.4.1 Gestione utenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.4.2 Funzionalità per l'utente finale. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

3.4.3 Funzionalità di amministrazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

3.5 Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4 Impostazione dell'ambiente di sviluppo

4.1 ESP-IDF Finitaview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

4.1.1 Versioni ESP-IDF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

4.1.2 Flusso di lavoro Git ESP-IDF . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 4.1.3 Scelta della versione adatta . . . . . . . . . . . . . . . . . . . . . . . . 34 4.1.4 Oltreview della directory dell'SDK ESP-IDF . . . . . . . . . . . . . . . . . . . . 34 4.2 Impostazione dell'ambiente di sviluppo ESP-IDF . . . . . . . . . . . . . . . . . 38 4.2.1 Configurazione dell'ambiente di sviluppo ESP-IDF su Linux . . . . . . . . 38 4.2.2 Configurazione dell'ambiente di sviluppo ESP-IDF su Windows . . . . . . 40 4.2.3 Configurazione dell'ambiente di sviluppo ESP-IDF su Mac . . . . . . . . . 45 4.2.4 Installazione di VS Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 4.2.5 Introduzione agli ambienti di sviluppo di terze parti . . . . . . . . 46 4.3 Sistema di compilazione ESP-IDF . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 4.3.1 Concetti base del sistema di compilazione . . . . . . . . . . . . . . . . . . 47 4.3.2 Progetto File Struttura . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 4.3.3 Regole di creazione predefinite del sistema di compilazione . . . . . . . . . . . . . 50 4.3.4 Introduzione allo script di compilazione . . . . . . . . . . . . . . . . . . 51 4.3.5 Introduzione ai comandi comuni . . . . . . . . . . . . . . . . . . . 52 4.4 Esercitazione: Compilazione dell'Esampil Programma “Blink” . . . . . . . . . . . . . . . . . . 53 4.4.1 Esample Analisi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 4.4.2 Compilazione del programma Blink . . . . . . . . . . . . . . . . . . . . . . . 56 4.4.3 Lampeggiamento del programma Blink . . . . . . . . . . . . . . . . . . . . . . . . 59 4.4.4 Analisi del registro della porta seriale del programma Blink . . . . . . . . . . . . . . 60 4.5 Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

II Sviluppo di hardware e driver

5 Progettazione hardware di prodotti Smart Light basati su ESP32-C3

5.1 Caratteristiche e composizione dei prodotti Smart Light. . . . . . . . . . . . . . . 67

5.2 Progettazione hardware del sistema principale ESP32-C3 . . . . . . . . . . . . . . . . . . . 70

5.2.1 Alimentazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

5.2.2 Sequenza di accensione e ripristino del sistema . . . . . . . . . . . . . . . . . . 74

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

5.2.4 Sorgente orologio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

5.2.5 RF e antenna . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

5.2.6 Perni di reggiatura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

5.2.7 GPIO e controller PWM . . . . . . . . . . . . . . . . . . . . . . . . . 79

5.3 Esercitazione: costruire un sistema di illuminazione intelligente con ESP32-C3 . . . . . . . . . . . . . 80

5.3.1 Selezione dei moduli . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

5.3.2 Configurazione GPIO dei segnali PWM . . . . . . . . . . . . . . . . . . . . 82

5.3.3 Download del firmware e interfaccia di debug . . . . . . . . . . . . 82

5.3.4 Linee guida per la progettazione RF. . . . . . . . . . . . . . . . . . . . . . . . . . 84 5.3.5 Linee guida per la progettazione dell'alimentatore . . . . . . . . . . . . . . . . . . . 86 5.4 Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

6 Sviluppo dei conducenti

6.1 Processo di sviluppo del driver. . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

6.2 Applicazioni periferiche ESP32-C3 . . . . . . . . . . . . . . . . . . . . . . . . . 88

6.3 Nozioni di base sui driver LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

6.3.1 Spazi colore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

6.3.2 Driver LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

6.3.3 Dimmerazione LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

6.3.4 Introduzione al PWM . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

6.4 Sviluppo del driver di regolazione LED . . . . . . . . . . . . . . . . . . . . . . . . 96

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

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

6.4.3 Programmazione PWM LED . . . . . . . . . . . . . . . . . . . . . . . . . . 100

6.5 Esercitazione: aggiunta di driver al progetto Smart Light . . . . . . . . . . . . . . . . . 103

6.5.1 Driver dei pulsanti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

6.5.2 Driver di regolazione LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

6.6 Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

III Comunicazione e controllo wireless

109

7 Configurazione e connessione Wi-Fi

111

7.1 Nozioni di base sul Wi-Fi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

7.1.1 Introduzione al Wi-Fi . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

7.1.2 Evoluzione dell'IEEE 802.11 . . . . . . . . . . . . . . . . . . . . . . . . . 111

7.1.3 Concetti Wi-Fi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

7.1.4 Connessione Wi-Fi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

7.2 Nozioni di base sul Bluetooth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

7.2.1 Introduzione al Bluetooth . . . . . . . . . . . . . . . . . . . . . . . . . 123

7.2.2 Concetti Bluetooth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

7.2.3 Connessione Bluetooth . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

7.3 Configurazione della rete Wi-Fi . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

7.3.1 Guida alla configurazione della rete Wi-Fi . . . . . . . . . . . . . . . . . . . . 131

7.3.2 AP Soft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

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

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

7.3.5 Altri metodi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

7.4 Programmazione Wi-Fi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 7.4.1 Componenti Wi-Fi in ESP-IDF . . . . . . . . . . . . . . . . . . . . . . . 139 7.4.2 Esercizio: Connessione Wi-Fi . . . . . . . . . . . . . . . . . . . . . . . . 141 7.4.3 Esercizio: Connessione Wi-Fi intelligente . . . . . . . . . . . . . . . . . . . . . 145
7.5 Esercitazione: configurazione Wi-Fi in Smart Light Project . . . . . . . . . . . . . . . 156 7.5.1 Connessione Wi-Fi in Smart Light Project . . . . . . . . . . . . . . . . . 156 7.5.2 Configurazione Wi-Fi intelligente . . . . . . . . . . . . . . . . . . . . . . . . . 157
7.6 Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

8 Controllo locale

159

8.1 Introduzione al controllo locale . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

8.1.1 Applicazione del controllo locale . . . . . . . . . . . . . . . . . . . . . . . . 161

8.1.2 Avanzatotages di controllo locale. . . . . . . . . . . . . . . . . . . . . . . . 161

8.1.3 Rilevamento dei dispositivi controllati tramite smartphone . . . . . . . . . . 161

8.1.4 Comunicazione di dati tra smartphone e dispositivi . . . . . . . . 162

8.2 Metodi comuni di rilevamento locale. . . . . . . . . . . . . . . . . . . . . . . . 162

8.2.1 Trasmissione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

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

8.2.3 Confronto tra broadcast e multicast . . . . . . . . . . . . . . 176

8.2.4 Protocollo applicativo multicast mDNS per rilevamento locale . . . . . . . . 176

8.3 Protocolli di comunicazione comuni per dati locali. . . . . . . . . . . . . . . 179

8.3.1 Protocollo di controllo della trasmissione (TCP) . . . . . . . . . . . . . . . . . . . 179

8.3.2 Protocollo di trasferimento ipertesto (HTTP) . . . . . . . . . . . . . . . . . . . 185

8.3.3 Dati UtentetagProtocollo RAM (UDP). . . . . . . . . . . . . . . . . . . . . . 189

8.3.4 Protocollo di applicazione vincolata (CoAP) . . . . . . . . . . . . . . . . 192

8.3.5 Protocollo Bluetooth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

8.3.6 Riepilogo dei protocolli di comunicazione dati. . . . . . . . . . . . . . . 203

8.4 Garanzia di Sicurezza dei Dati. . . . . . . . . . . . . . . . . . . . . . . . . . . . 205

8.4.1 Introduzione al Transport Layer Security (TLS) . . . . . . . . . . . . . 207

8.4.2 Introduzione a Datagram Transport Layer Security (DTLS) . . . . . . . 213

8.5 Esercitazione: controllo locale nel progetto Smart Light . . . . . . . . . . . . . . . . . . 217

8.5.1 Creazione di un server di controllo locale basato su Wi-Fi . . . . . . . . . . . . . . . 217

8.5.2 Verifica della funzionalità di controllo locale utilizzando gli script . . . . . . . . . . . 221

8.5.3 Creazione di un server di controllo locale basato su Bluetooth . . . . . . . . . . . . 222

8.6 Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224

9 Controllo nuvola

225

9.1 Introduzione al controllo remoto . . . . . . . . . . . . . . . . . . . . . . . . . . 225

9.2 Protocolli di comunicazione dati cloud . . . . . . . . . . . . . . . . . . . . . . 226

9.2.1 Introduzione MQTT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226 9.2.2 Principi MQTT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227 9.2.3 Formato messaggio MQTT . . . . . . . . . . . . . . . . . . . . . . . . . . 228 9.2.4 Confronto protocolli . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 9.2.5 Configurazione del broker MQTT su Linux e Windows . . . . . . . . . . . . 233 9.2.6 Configurazione del client MQTT basato su ESP-IDF . . . . . . . . . . . . . . . . 235 9.3 Garantire la sicurezza dei dati MQTT . . . . . . . . . . . . . . . . . . . . . . . . . . . 237 9.3.1 Significato e funzione dei certificati . . . . . . . . . . . . . . . . . . . 237 9.3.2 Generazione di certificati localmente . . . . . . . . . . . . . . . . . . . . . . 239 9.3.3 Configurazione del broker MQTT . . . . . . . . . . . . . . . . . . . . . . . . . 241 9.3.4 Configurazione del client MQTT . . . . . . . . . . . . . . . . . . . . . . . . . 241 9.4 Esercitazione: controllo remoto tramite ESP RainMaker . . . . . . . . . . . . . . . . 243 9.4.1 ESP RainMaker Nozioni di base . . . . . . . . . . . . . . . . . . . . . . . . . . . 243 9.4.2 Protocollo di comunicazione nodo e backend cloud . . . . . . . . . . . 244 9.4.3 Comunicazione tra client e backend cloud . . . . . . . . . . . 249 9.4.4 Ruoli utente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252 9.4.5 Servizi di base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253 9.4.6 Smart Light Esample. . . . . . . . . . . . . . . . . . . . . . . . . . . . 255 9.4.7 App RainMaker e integrazioni di terze parti . . . . . . . . . . . . . . . 262 9.5 Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267

10 Sviluppo di app per smartphone

269

10.1 Introduzione allo sviluppo di app per smartphone . . . . . . . . . . . . . . . . . . 269

10.1.1 Oltreview di sviluppo di app per smartphone. . . . . . . . . . . . . . . 270

10.1.2 Struttura del progetto Android . . . . . . . . . . . . . . . . . . . . . . 270

10.1.3 Struttura del progetto iOS . . . . . . . . . . . . . . . . . . . . . . . . 271

10.1.4 Ciclo di vita di un'attività Android . . . . . . . . . . . . . . . . . . . . . . 272

10.1.5 Ciclo di vita di iOS ViewControllore. . . . . . . . . . . . . . . . . . . . . . 273

10.2 Creazione di un nuovo progetto di app per smartphone . . . . . . . . . . . . . . . . . . . . . 275

10.2.1 Preparazione per lo sviluppo Android . . . . . . . . . . . . . . . . . . . 275

10.2.2 Creazione di un nuovo progetto Android . . . . . . . . . . . . . . . . . . . . . . 275

10.2.3 Aggiunta di dipendenze per MyRainmaker . . . . . . . . . . . . . . . . . 276

10.2.4 Richiesta di autorizzazione in Android . . . . . . . . . . . . . . . . . . . . . . 277

10.2.5 Preparazione per lo sviluppo iOS . . . . . . . . . . . . . . . . . . . . . . 277

10.2.6 Creazione di un nuovo progetto iOS . . . . . . . . . . . . . . . . . . . . . . . . 278

10.2.7 Aggiunta di dipendenze per MyRainmaker . . . . . . . . . . . . . . . . . 279

10.2.8 Richiesta di autorizzazione in iOS . . . . . . . . . . . . . . . . . . . . . . . . . 280

10.3 Analisi dei Requisiti Funzionali dell'App. . . . . . . . . . . . . . . . . . 281

10.3.1 Analisi dei Requisiti Funzionali del Progetto . . . . . . . . . . . . 282

10.3.2 Analisi dei requisiti di gestione degli utenti . . . . . . . . . . . . . . . 282 10.3.3 Analisi del provisioning dei dispositivi e dei requisiti vincolanti . . . . . . . 283 10.3.4 Analisi dei requisiti di controllo remoto . . . . . . . . . . . . . . . . 283 10.3.5 Analisi dei fabbisogni di schedulazione . . . . . . . . . . . . . . . . . . . 284 10.3.6 Analisi dei requisiti del Centro utenti . . . . . . . . . . . . . . . . . . 285 10.4 Sviluppo della gestione utenti . . . . . . . . . . . . . . . . . . . . . . . . 285 10.4.1 Introduzione alle API RainMaker . . . . . . . . . . . . . . . . . . . . . . 285 10.4.2 Avvio della comunicazione tramite smartphone . . . . . . . . . . . . . . . . 286 10.4.3 Registrazione account . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286 10.4.4 Accesso all'account . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 10.5 Sviluppo del Device Provisioning . . . . . . . . . . . . . . . . . . . . . . . 292 10.5.1 Dispositivi di scansione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293 10.5.2 Collegamento di dispositivi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295 10.5.3 Generazione di chiavi segrete . . . . . . . . . . . . . . . . . . . . . . . . . . . 298 10.5.4 Ottenere l'ID del nodo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298 10.5.5 Provisioning dei dispositivi . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300 10.6 Sviluppo del controllo dei dispositivi . . . . . . . . . . . . . . . . . . . . . . . . . . 302 10.6.1 Associazione dei dispositivi agli account cloud . . . . . . . . . . . . . . . . . . . . 303 10.6.2 Ottenere un elenco di dispositivi . . . . . . . . . . . . . . . . . . . . . . . . . . 305 10.6.3 Ottenere lo stato del dispositivo . . . . . . . . . . . . . . . . . . . . . . . . . . . 308 10.6.4 Modifica dello stato del dispositivo . . . . . . . . . . . . . . . . . . . . . . . . . . 310 10.7 Sviluppo Schedulazione e Centro Utenti . . . . . . . . . . . . . . . . . . . 313 10.7.1 Implementazione della funzione di pianificazione . . . . . . . . . . . . . . . . . . . . 313 10.7.2 Implementazione del Centro utenti . . . . . . . . . . . . . . . . . . . . . . . . . 315 10.7.3 Altre API cloud . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318 10.8 Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319

11 Aggiornamento firmware e gestione delle versioni

321

11.1 Aggiornamento del firmware. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321

11.1.1 Oltreview delle tabelle delle partizioni. . . . . . . . . . . . . . . . . . . . . . . . 322

11.1.2 Processo di avvio del firmware . . . . . . . . . . . . . . . . . . . . . . . . . . . 324

11.1.3 Oltreview del Meccanismo OTA. . . . . . . . . . . . . . . . . . . . . 326

11.2 Gestione della versione del firmware . . . . . . . . . . . . . . . . . . . . . . . . . . 329

11.2.1 Contrassegno del firmware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329

11.2.2 Rollback e Anti-Rollback . . . . . . . . . . . . . . . . . . . . . . . . 331

11.3 Pratica: Over-the-air (OTA) Esample. . . . . . . . . . . . . . . . . . . . . . . 332

11.3.1 Aggiornamento del firmware tramite un host locale. . . . . . . . . . . . . . . . . 332

11.3.2 Aggiornamento del firmware tramite ESP RainMaker . . . . . . . . . . . . . . . 335

11.4 Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342

IV Ottimizzazione e produzione di massa

343

12 Gestione energetica e ottimizzazione a basso consumo

345

12.1 Gestione energetica ESP32-C3 . . . . . . . . . . . . . . . . . . . . . . . . . . . 345

12.1.1 Scala dinamica della frequenza . . . . . . . . . . . . . . . . . . . . . . . . 346

12.1.2 Configurazione della gestione energetica . . . . . . . . . . . . . . . . . . . . 348

12.2 Modalità a basso consumo ESP32-C3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348

12.2.1 Modalità di sospensione del modem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349

12.2.2 Modalità sonno leggero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351

12.2.3 Modalità sonno profondo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356

12.2.4 Consumo di corrente in diverse modalità di alimentazione. . . . . . . . . . . . . 358

12.3 Gestione energetica e debug a basso consumo . . . . . . . . . . . . . . . . . 359

12.3.1 Debug del registro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360

12.3.2 Debug GPIO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362

12.4 Esercitazione: gestione energetica nel progetto Smart Light . . . . . . . . . . . . . . . 363

12.4.1 Configurazione della funzionalità di risparmio energetico . . . . . . . . . . . . . . . . . 364

12.4.2 Utilizzare i blocchi di gestione energetica . . . . . . . . . . . . . . . . . . . . . . 365

12.4.3 Verifica del consumo energetico . . . . . . . . . . . . . . . . . . . . . . . 366

12.5 Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367

13 Funzionalità avanzate di sicurezza del dispositivo

369

13.1 Oltreview della sicurezza dei dati dei dispositivi IoT. . . . . . . . . . . . . . . . . . . . . . . 369

13.1.1 Perché proteggere i dati dei dispositivi IoT? . . . . . . . . . . . . . . . . . . . . . . 370

13.1.2 Requisiti di base per la sicurezza dei dati dei dispositivi IoT. . . . . . . . . . . . 371

13.2 Protezione dell'integrità dei dati. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372

13.2.1 Introduzione al metodo di verifica dell'integrità . . . . . . . . . . . . . . 372

13.2.2 Verifica dell'integrità dei dati del firmware. . . . . . . . . . . . . . . . . . 373

13.2.3 Esample. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374

13.3 Tutela della riservatezza dei dati. . . . . . . . . . . . . . . . . . . . . . . . . . 374

13.3.1 Introduzione alla crittografia dei dati . . . . . . . . . . . . . . . . . . . . . . 374

13.3.2 Introduzione allo schema di crittografia Flash . . . . . . . . . . . . . . . . . 376

13.3.3 Memorizzazione della chiave di crittografia Flash . . . . . . . . . . . . . . . . . . . . . . . 379

13.3.4 Modalità operativa della crittografia Flash . . . . . . . . . . . . . . . . . . . . 380

13.3.5 Processo di crittografia Flash . . . . . . . . . . . . . . . . . . . . . . . . . . 381

13.3.6 Introduzione alla crittografia NVS . . . . . . . . . . . . . . . . . . . . . . 383

13.3.7 Esampfile di crittografia Flash e crittografia NVS . . . . . . . . . . . 384

13.4 Tutela della legittimità dei dati. . . . . . . . . . . . . . . . . . . . . . . . . . . . 386

13.4.1 Introduzione alla firma digitale. . . . . . . . . . . . . . . . . . . . . 386

13.4.2 Oltreview dello schema di avvio sicuro . . . . . . . . . . . . . . . . . . . . . 388

13.4.3 Introduzione all'avvio sicuro del software . . . . . . . . . . . . . . . . . . . 388 13.4.4 Introduzione all'avvio protetto hardware . . . . . . . . . . . . . . . . . . 390 13.4.5 Esample . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394 13.5 Esercitazione: funzioni di sicurezza nella produzione di massa . . . . . . . . . . . . . . . . . . 396 13.5.1 Crittografia Flash e avvio sicuro . . . . . . . . . . . . . . . . . . . . . 396 13.5.2 Abilitazione della crittografia Flash e dell'avvio protetto con Batch Flash Tools . . 397 13.5.3 Abilitazione della crittografia Flash e dell'avvio protetto in Smart Light Project . . . 398 13.6 Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398

14 Masterizzazione e test del firmware per la produzione di massa

399

14.1 Masterizzazione del firmware nella produzione di massa . . . . . . . . . . . . . . . . . . . . . . 399

14.1.1 Definizione delle partizioni dati . . . . . . . . . . . . . . . . . . . . . . . . . . 399

14.1.2 Masterizzazione del firmware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402

14.2 Test di produzione di massa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403

14.3 Esercitazione: dati sulla produzione di massa nel progetto Smart Light . . . . . . . . . . . . . 404

14.4 Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404

15 Approfondimenti ESP: piattaforma di monitoraggio remoto

405

15.1 Introduzione a ESP Insights . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405

15.2 Introduzione a ESP Insights . . . . . . . . . . . . . . . . . . . . . . . . . 409

15.2.1 Introduzione a ESP Insights nel progetto esp-insights . . . . . . 409

15.2.2 Esecuzione dell'esample nel progetto esp-insights. . . . . . . . . . . . . . . 411

15.2.3 Reporting delle informazioni Coredump. . . . . . . . . . . . . . . . . . . . . 411

15.2.4 Personalizzazione dei registri di interesse. . . . . . . . . . . . . . . . . . . . . . . . 412

15.2.5 Segnalazione del motivo del riavvio . . . . . . . . . . . . . . . . . . . . . . . . . 413

15.2.6 Reporting delle metriche personalizzate . . . . . . . . . . . . . . . . . . . . . . . . . 413

15.3 Esercitazione: utilizzo di ESP Insights in Smart Light Project . . . . . . . . . . . . . . . 416

15.4 Riepilogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417

Introduzione
ESP32-C3 è un SoC microcontrollore Wi-Fi e Bluetooth 5 (LE) single-core, basato sull'architettura RISC-V open source. Raggiunge il giusto equilibrio tra potenza, funzionalità I/O e sicurezza, offrendo così la soluzione ottimale ed economicamente vantaggiosa per i dispositivi connessi. Per mostrare le varie applicazioni della famiglia ESP32-C3, questo libro di Espressif vi condurrà in un interessante viaggio attraverso l'AIoT, partendo dalle basi dello sviluppo di progetti IoT e della configurazione dell'ambiente fino all'esperienza praticaamples. I primi quattro capitoli parlano di IoT, ESP RainMaker ed ESP-IDF. I capitoli 5 e 6 riassumono la progettazione dell'hardware e lo sviluppo dei driver. Man mano che avanzi, scoprirai come configurare il tuo progetto tramite reti Wi-Fi e app mobili. Infine, imparerai a ottimizzare il tuo progetto e a inserirlo nella produzione di massa.
Se sei un ingegnere in campi correlati, un architetto software, un insegnante, uno studente o chiunque abbia interesse per l'IoT, questo libro fa per te.
Puoi scaricare il codice example utilizzato in questo libro dal sito di Espressif su GitHub. Per le informazioni più recenti sullo sviluppo dell'IoT, segui il nostro account ufficiale.

Prefazione
Un mondo informatizzato
Cavalcando l’onda di Internet, l’Internet delle cose (IoT) ha fatto il suo grande debutto diventando un nuovo tipo di infrastruttura nell’economia digitale. Per avvicinare la tecnologia al pubblico, Espressif Systems lavora con l'idea che gli sviluppatori di ogni ceto sociale possano utilizzare l'IoT per risolvere alcuni dei problemi più urgenti dei nostri tempi. Un mondo di “Rete intelligente di tutte le cose” è ciò che ci aspettiamo dal futuro.
Progettare i nostri chip costituisce una componente fondamentale di questa visione. Sarà una maratona che richiederà costanti progressi contro i confini tecnologici. Dal "Game Changer" ESP8266 alla serie ESP32 che integra connettività Wi-Fi e Bluetooth (LE), seguita da ESP32-S3 dotato di accelerazione AI, Espressif non smette mai di ricercare e sviluppare prodotti per soluzioni AIoT. Con il nostro software open source, come IoT Development Framework ESP-IDF, Mesh Development Framework ESP-MDF e Device Connectivity Platform ESP RainMaker, abbiamo creato un framework indipendente per la creazione di applicazioni AIoT.
A luglio 2022, le spedizioni cumulative di chipset IoT di Espressif hanno superato gli 800 milioni, posizionandosi al primo posto nel mercato degli MCU Wi-Fi e alimentando un numero enorme di dispositivi connessi in tutto il mondo. La ricerca dell'eccellenza rende ogni prodotto Espressif un grande successo per il suo elevato livello di integrazione ed efficienza dei costi. Il rilascio di ESP32-C3 segna una pietra miliare significativa nella tecnologia sviluppata internamente da Espressif. Si tratta di un MCU single-core, a 32 bit, basato su RISC-V con 400 KB di SRAM, che può funzionare a 160 MHz. Ha Wi-Fi integrato a 2.4 GHz e Bluetooth 5 (LE) con supporto a lungo raggio. Raggiunge un ottimo equilibrio tra potenza, funzionalità I/O e sicurezza, offrendo così la soluzione ottimale ed economicamente vantaggiosa per i dispositivi connessi. Basato su un ESP32-C3 così potente, questo libro ha lo scopo di aiutare i lettori a comprendere le conoscenze relative all'IoT con illustrazioni dettagliate ed esempi praticiampmeno.
Perché abbiamo scritto questo libro?
Espressif Systems è più di un'azienda di semiconduttori. È anche una società di piattaforme IoT, che punta sempre a scoperte e innovazioni nel campo della tecnologia. Allo stesso tempo, Espressif ha reso open source e condiviso con la comunità il proprio sistema operativo e la struttura software autosviluppati, formando un ecosistema unico. Ingegneri, produttori e appassionati di tecnologia sviluppano attivamente nuove applicazioni software basate sui prodotti Espressif, comunicano liberamente e condividono la loro esperienza. Puoi vedere le idee affascinanti degli sviluppatori in ogni momento su varie piattaforme, come YouTube e GitHub. La popolarità dei prodotti Espressif ha stimolato un numero crescente di autori che hanno prodotto oltre 100 libri basati sui chipset Espressif, in più di dieci lingue, tra cui inglese, cinese, tedesco, francese e giapponese.

Sono il supporto e la fiducia dei partner della comunità che incoraggiano la continua innovazione di Espressif. “Ci sforziamo di rendere i nostri chip, sistemi operativi, framework, soluzioni, Cloud, pratiche commerciali, strumenti, documentazione, scritti, idee, ecc., sempre più rilevanti per le risposte di cui le persone hanno bisogno nei problemi più urgenti della vita contemporanea. Questa è la più alta ambizione e bussola morale di Espressif." ha affermato Teo Swee Ann, fondatore e CEO di Espressif.
Espressif valorizza la lettura e le idee. Poiché il continuo aggiornamento della tecnologia IoT impone requisiti più elevati agli ingegneri, come possiamo aiutare più persone a padroneggiare rapidamente chip IoT, sistemi operativi, framework software, schemi applicativi e prodotti di servizi cloud? Come si suol dire, è meglio insegnare a un uomo a pescare che dargli del pesce. Durante una sessione di brainstorming, ci è venuto in mente che avremmo potuto scrivere un libro per classificare sistematicamente le conoscenze chiave dello sviluppo dell'IoT. Ci siamo trovati d'accordo, abbiamo riunito rapidamente un gruppo di ingegneri senior e abbiamo unito l'esperienza del team tecnico nella programmazione integrata, nello sviluppo di hardware e software IoT, contribuendo tutti alla pubblicazione di questo libro. Nel processo di scrittura, abbiamo fatto del nostro meglio per essere obiettivi ed equi, spogliati del bozzolo, e utilizzare espressioni concise per raccontare la complessità e il fascino dell'Internet delle cose. Abbiamo riepilogato attentamente le domande comuni, facendo riferimento al feedback e ai suggerimenti della comunità, al fine di rispondere chiaramente alle domande incontrate nel processo di sviluppo e fornire linee guida pratiche per lo sviluppo dell'IoT per i tecnici e i decisori interessati.
Struttura del libro
Questo libro adotta una prospettiva incentrata sull'ingegnere ed espone passo dopo passo le conoscenze necessarie per lo sviluppo di progetti IoT. È composto da quattro parti, come segue:
· Preparazione (Capitolo 1): questa parte introduce l'architettura dell'IoT, il tipico framework di progetto IoT, la piattaforma cloud ESP RainMakerr e l'ambiente di sviluppo ESP-IDF, in modo da gettare solide basi per lo sviluppo del progetto IoT.
· Sviluppo di hardware e driver (Capitolo 5): basata sul chipset ESP6-C32, questa parte elabora lo sviluppo minimo del sistema hardware e dei driver e implementa il controllo dell'attenuazione, della gradazione del colore e della comunicazione wireless.
· Comunicazione e controllo wireless (capitolo 7): questa parte spiega lo schema di configurazione Wi-Fi intelligente basato sul chip ESP11-C32, sui protocolli di controllo locale e cloud e sul controllo locale e remoto dei dispositivi. Fornisce inoltre schemi per lo sviluppo di app per smartphone, aggiornamento del firmware e gestione delle versioni.
· Ottimizzazione e produzione di massa (capitoli 12-15): questa parte è destinata alle applicazioni IoT avanzate, incentrate sull'ottimizzazione dei prodotti nella gestione energetica, sull'ottimizzazione a basso consumo e sulla maggiore sicurezza. Introduce inoltre la masterizzazione e il test del firmware nella produzione di massa e come diagnosticare lo stato di funzionamento e i registri del firmware del dispositivo attraverso la piattaforma di monitoraggio remoto ESP Insights.

Informazioni sul codice sorgente
I lettori possono eseguire l'exampi programmi in questo libro, inserendo il codice manualmente o utilizzando il codice sorgente che accompagna il libro. Sottolineiamo la combinazione di teoria e pratica e quindi in quasi ogni capitolo abbiamo inserito una sezione pratica basata sul progetto Smart Light. Tutti i codici sono open source. I lettori sono invitati a scaricare il codice sorgente e discuterne nelle sezioni relative a questo libro su GitHub e sul nostro forum ufficiale esp32.com. Il codice open source di questo libro è soggetto ai termini della licenza Apache 2.0.
Nota dell'autore
Questo libro è prodotto ufficialmente da Espressif Systems ed è scritto dagli ingegneri senior dell'azienda. È adatto a manager e personale di ricerca e sviluppo nei settori legati all'IoT, insegnanti e studenti di specializzazioni correlate e appassionati nel campo dell'Internet delle cose. Ci auguriamo che questo libro possa servire come manuale di lavoro, riferimento e libro da comodino, per essere come un buon tutor e amico.
Durante la compilazione di questo libro, abbiamo fatto riferimento ad alcuni risultati di ricerca rilevanti di esperti, studiosi e tecnici in patria e all’estero, e abbiamo fatto del nostro meglio per citarli secondo le norme accademiche. Tuttavia, è inevitabile che vi siano alcune omissioni, quindi vorremmo esprimere il nostro profondo rispetto e gratitudine a tutti gli autori rilevanti. Inoltre, abbiamo citato informazioni da Internet, quindi vorremmo ringraziare gli autori e gli editori originali e ci scusiamo per non poter indicare la fonte di ogni informazione.
Per produrre un libro di alta qualità, abbiamo organizzato cicli di discussioni interne e imparato dai suggerimenti e dai feedback dei lettori di prova e degli editori. Qui, vorremmo ringraziarvi ancora per il vostro aiuto che ha contribuito a questo lavoro di successo.
Ultimo, ma soprattutto, grazie a tutti coloro che in Espressif hanno lavorato così duramente per la nascita e la divulgazione dei nostri prodotti.
Lo sviluppo di progetti IoT coinvolge un’ampia gamma di conoscenze. Limitate alla lunghezza del libro, nonché al livello e all'esperienza dell'autore, le omissioni sono inevitabili. Pertanto, chiediamo gentilmente agli esperti e ai lettori di criticare e correggere i nostri errori. Se avete suggerimenti per questo libro, contattateci a book@espressif.com. Aspettiamo il tuo feedback.

Come usare questo libro?
Il codice dei progetti contenuti in questo libro è stato open source. Puoi scaricarlo dal nostro repository GitHub e condividere pensieri e domande sul nostro forum ufficiale. GitHub: https://github.com/espressif/book-esp32c3-iot-projects Forum: https://www.esp32.com/bookc3 In tutto il libro, ci saranno parti evidenziate come mostrato di seguito.
Codice sorgente In questo libro, sottolineiamo la combinazione di teoria e pratica, e quindi in quasi ogni capitolo abbiamo inserito una sezione Pratica sul progetto Smart Light. I passaggi corrispondenti e la pagina di origine verranno contrassegnati tra due righe che iniziano con il tag Codice sorgente.
NOTE/SUGGERIMENTI Qui è dove potresti trovare alcune informazioni critiche e promemoria per eseguire correttamente il debug del tuo programma. Saranno contrassegnati tra due linee spesse che iniziano con tag NOTA o SUGGERIMENTI.
La maggior parte dei comandi contenuti in questo libro vengono eseguiti sotto Linux, attivati dal carattere "$". Se il comando richiede i privilegi di superutente per essere eseguito, il prompt verrà sostituito da "#". Il prompt dei comandi sui sistemi Mac è "%", come utilizzato nella Sezione 4.2.3 Installazione di ESP-IDF su Mac.
Il corpo del testo di questo libro sarà stampato in Charter, mentre il codice example, componenti, funzioni, variabili, codice file nomi, directory di codici e stringhe saranno in Courier New.
I comandi o testi che devono essere immessi dall'utente e i comandi che possono essere immessi premendo il tasto "Invio" verranno stampati in Courier New in grassetto. I log e i blocchi di codice verranno presentati in riquadri azzurri.
Exampon:
In secondo luogo, utilizzare esp-idf/components/nvs flash/nvs Partition Generator/nvs Partition Gen.py per generare il binario della partizione NVS file sull'host di sviluppo con il seguente comando:
$ python $IDF PERCORSO/componenti/nvs flash/generatore di partizioni nvs/partizione nvs gen.py –input mass prod.csv –output mass prod.bin –size DIMENSIONE PARTIZIONE NVS

Capitolo 1

Introduzione

IoT

Alla fine del XX secolo, con la nascita delle reti informatiche e delle tecnologie di comunicazione, Internet si è rapidamente integrata nella vita delle persone. Mentre la tecnologia Internet continua a maturare, è nata l’idea di Internet of Things (IoT). Letteralmente IoT significa Internet in cui le cose sono connesse. Mentre l’Internet originale infrange i limiti dello spazio e del tempo e riduce la distanza tra “persona e persona”, l’IoT rende le “cose” un partecipante importante, avvicinando “persone” e “cose”. Nel prossimo futuro, l’IoT è destinato a diventare la forza trainante del settore dell’informazione.
Allora, cos’è l’Internet delle cose?
È difficile definire con precisione l’Internet delle cose, poiché il suo significato e la sua portata sono in continua evoluzione. Nel 1995, Bill Gates propose per la prima volta l’idea dell’IoT nel suo libro The Road Ahead. In poche parole, l’IoT consente agli oggetti di scambiare informazioni tra loro attraverso Internet. Il suo obiettivo finale è creare un “Internet of Everything”. Questa è una prima interpretazione dell’IoT, nonché una fantasia della tecnologia futura. Trent’anni dopo, con il rapido sviluppo dell’economia e della tecnologia, la fantasia sta diventando realtà. Dai dispositivi intelligenti, case intelligenti, città intelligenti, Internet dei veicoli e dispositivi indossabili, al “metaverso” supportato dalle tecnologie IoT, nuovi concetti emergono costantemente. In questo capitolo inizieremo con una spiegazione dell'architettura dell'Internet delle cose, quindi presenteremo l'applicazione IoT più comune, la casa intelligente, per aiutarti a comprendere chiaramente l'IoT.
1.1 Architettura dell'IoT
L'Internet delle cose coinvolge molteplici tecnologie che hanno esigenze e forme di applicazione diverse in diversi settori. Per sistemare la struttura, le tecnologie chiave e le caratteristiche applicative dell’IoT, è necessario stabilire un’architettura unificata e un sistema tecnico standard. In questo libro, l’architettura dell’IoT è semplicemente divisa in quattro livelli: livello di percezione e controllo, livello di rete, livello di piattaforma e livello di applicazione.
Livello di percezione e controllo Essendo l'elemento più basilare dell'architettura IoT, il livello di percezione e controllo è il nucleo per realizzare il rilevamento completo dell'IoT. La sua funzione principale è raccogliere, identificare e controllare le informazioni. Consiste in una varietà di dispositivi con capacità di percezione,
3

identificazione, controllo ed esecuzione ed è responsabile del recupero e dell'analisi di dati quali proprietà dei materiali, tendenze comportamentali e stato del dispositivo. In questo modo l’IoT riesce a riconoscere il mondo fisico reale. Inoltre, il livello è anche in grado di controllare lo stato del dispositivo.
I dispositivi più comuni di questo livello sono vari sensori, che svolgono un ruolo importante nella raccolta e nell'identificazione delle informazioni. I sensori sono come gli organi sensoriali umani, come i sensori fotosensibili che equivalgono alla vista, i sensori acustici all'udito, i sensori del gas all'olfatto e i sensori sensibili alla pressione e alla temperatura al tatto. Con tutti questi “organi di senso”, gli oggetti diventano “vivi” e capaci di percezione, riconoscimento e manipolazione intelligente del mondo fisico.
Livello di rete La funzione principale del livello di rete è quella di trasmettere informazioni, inclusi i dati ottenuti dal livello di percezione e controllo al target specificato, nonché i comandi emessi dal livello di applicazione al livello di percezione e controllo. Serve come un importante ponte di comunicazione che collega diversi livelli di un sistema IoT. Per impostare un modello base di Internet of Things, l'integrazione degli oggetti in una rete prevede due passaggi: accesso a Internet e trasmissione tramite Internet.
Accesso a Internet Internet consente l'interconnessione tra persona e persona, ma non riesce a includere le cose nella grande famiglia. Prima dell’avvento dell’IoT, la maggior parte delle cose non erano “collegabili in rete”. Grazie al continuo sviluppo della tecnologia, l’IoT riesce a connettere le cose a Internet, realizzando così l’interconnessione tra “persone e cose”, e “cose e cose”. Esistono due modi comuni per implementare la connessione Internet: accesso alla rete cablata e accesso alla rete wireless.
I metodi di accesso alla rete cablata includono Ethernet, comunicazione seriale (ad esempio RS-232, RS-485) e USB, mentre l'accesso alla rete wireless dipende dalla comunicazione wireless, che può essere ulteriormente suddivisa in comunicazione wireless a corto raggio e comunicazione wireless a lungo raggio.
La comunicazione wireless a corto raggio include ZigBee, Bluetoothr, Wi-Fi, Near-Field Communication (NFC) e Radio Frequency Identification (RFID). La comunicazione wireless a lungo raggio include Enhanced Machine Type Communication (eMTC), LoRa, Narrow Band Internet of Things (NB-IoT), 2G, 3G, 4G, 5G, ecc.
Trasmissione tramite Internet Diversi metodi di accesso a Internet portano al corrispondente collegamento fisico di trasmissione dei dati. La prossima cosa è decidere quale protocollo di comunicazione utilizzare per trasmettere i dati. Rispetto ai terminali Internet, la maggior parte dei terminali IoT ne possiede attualmente meno
4 Avventura wireless ESP32-C3: una guida completa all'IoT

risorse disponibili, come prestazioni di elaborazione, capacità di archiviazione, velocità di rete, ecc., quindi è necessario scegliere un protocollo di comunicazione che occupi meno risorse nelle applicazioni IoT. Esistono due protocolli di comunicazione ampiamente utilizzati oggi: Message Queuing Telemetry Transport (MQTT) e Constrained Application Protocol (CoAP).
Livello piattaforma Il livello piattaforma si riferisce principalmente alle piattaforme cloud IoT. Quando tutti i terminali IoT sono collegati in rete, i loro dati devono essere aggregati su una piattaforma cloud IoT per essere calcolati e archiviati. Il livello piattaforma supporta principalmente le applicazioni IoT nel facilitare l'accesso e la gestione di dispositivi di grandi dimensioni. Collega i terminali IoT alla piattaforma cloud, raccoglie i dati dei terminali ed invia comandi ai terminali, in modo da implementare il controllo remoto. In quanto servizio intermedio per assegnare apparecchiature alle applicazioni industriali, il livello piattaforma svolge un ruolo di collegamento nell'intera architettura IoT, portando logica aziendale astratta e modello di dati core standardizzato, che può non solo realizzare un rapido accesso ai dispositivi, ma anche fornire potenti funzionalità modulari per soddisfare le diverse esigenze negli scenari applicativi del settore. Il livello della piattaforma comprende principalmente moduli funzionali come accesso ai dispositivi, gestione dei dispositivi, gestione della sicurezza, comunicazione dei messaggi, monitoraggio del funzionamento e della manutenzione e applicazioni dati.
· Accesso ai dispositivi, realizzando la connessione e la comunicazione tra terminali e piattaforme cloud IoT.
· Gestione dei dispositivi, comprese funzioni quali creazione e manutenzione dei dispositivi, conversione dei dati, sincronizzazione dei dati e distribuzione dei dispositivi.
· Gestione della sicurezza, garantendo la sicurezza della trasmissione dei dati IoT dal punto di vista dell'autenticazione e della sicurezza della comunicazione.
· Comunicazione di messaggi, comprese tre direzioni di trasmissione, ovvero il terminale invia dati alla piattaforma cloud IoT, la piattaforma cloud IoT invia dati al lato server o ad altre piattaforme cloud IoT e il lato server controlla in remoto i dispositivi IoT.
· Monitoraggio O&M, che comprende monitoraggio e diagnosi, aggiornamento firmware, debug online, servizi di registro, ecc.
· Applicazioni di dati, che implicano l'archiviazione, l'analisi e l'applicazione dei dati.
Livello dell'applicazione Il livello dell'applicazione utilizza i dati del livello della piattaforma per gestire l'applicazione, filtrandoli ed elaborandoli con strumenti come database e software di analisi. I dati risultanti possono essere utilizzati per applicazioni IoT nel mondo reale come sanità intelligente, agricoltura intelligente, case intelligenti e città intelligenti.
Naturalmente l’architettura dell’IoT può essere suddivisa in più strati, ma non importa da quanti strati sia composta, il principio di fondo rimane sostanzialmente lo stesso. Apprendimento
Capitolo 1. Introduzione all'IoT 5

sull'architettura dell'IoT aiuta ad approfondire la nostra comprensione delle tecnologie IoT e a costruire progetti IoT pienamente funzionali.
1.2 Applicazione IoT nelle case intelligenti
L’IoT è penetrato in tutti gli ambiti della vita e l’applicazione IoT a noi più strettamente correlata è la casa intelligente. Molti elettrodomestici tradizionali sono ora dotati di uno o più dispositivi IoT e molte case di nuova costruzione sono progettate fin dall’inizio con tecnologie IoT. La Figura 1.1 mostra alcuni comuni dispositivi domestici intelligenti.
Figura 1.1. Dispositivi comuni per la casa intelligente Lo sviluppo della casa intelligente può essere semplicemente suddiviso in prodotti intelligentitage, interconnessione di scene stagee intelligente stage, come mostrato nella Figura 1.2.
Figura 1.2. Sviluppo stage della casa intelligente 6 ESP32-C3 Wireless Adventure: una guida completa all'IoT

Il primo stage riguarda i prodotti intelligenti. Diversamente dalle case tradizionali, nelle case intelligenti, i dispositivi IoT ricevono segnali con sensori e sono collegati in rete tramite tecnologie di comunicazione wireless come Wi-Fi, Bluetooth LE e ZigBee. Gli utenti possono controllare i prodotti intelligenti in vari modi, come app per smartphone, assistenti vocali, controllo degli altoparlanti intelligenti, ecc.tage si concentra sull'interconnessione delle scene. In questo stage, gli sviluppatori non stanno più prendendo in considerazione il controllo di un singolo prodotto intelligente, ma l'interconnessione di due o più prodotti intelligenti, l'automazione in una certa misura e, infine, la creazione di una modalità scena personalizzata. Per esample, quando l'utente preme qualsiasi pulsante della modalità scena, le luci, le tende e i condizionatori d'aria verranno automaticamente adattati alle preimpostazioni. Naturalmente, esiste il prerequisito che la logica di collegamento sia prontamente impostata, comprese le condizioni di trigger e le azioni di esecuzione. Immaginiamo che la modalità riscaldamento dell'aria condizionata venga attivata quando la temperatura interna scende sotto i 10°C; che alle 7 del mattino viene riprodotta della musica per svegliare l'utente, vengono aperte le tende intelligenti e il cuociriso o il tostapane si avvia tramite una presa intelligente; non appena l'utente si alza e finisce di lavarsi, la colazione è già servita, in modo che non ci siano ritardi nell'andare al lavoro. Quanto è diventata comoda la nostra vita! La terza stage va all'intelligence stage. Man mano che si accede a un numero maggiore di dispositivi domestici intelligenti, aumenteranno anche i tipi di dati generati. Con l’aiuto del cloud computing, dei big data e dell’intelligenza artificiale, è come se un “cervello più intelligente” fosse stato impiantato nelle case intelligenti, che non richiedono più comandi frequenti da parte dell’utente. Raccolgono dati dalle interazioni precedenti e apprendono i modelli di comportamento e le preferenze dell'utente, in modo da automatizzare le attività, inclusa la fornitura di consigli per il processo decisionale. Attualmente, la maggior parte delle case intelligenti sono sulla scena interconnessionitage. Con l’aumento del tasso di penetrazione e dell’intelligenza dei prodotti intelligenti, le barriere tra i protocolli di comunicazione vengono rimosse. In futuro, le case intelligenti diventeranno davvero “intelligenti”, proprio come il sistema di intelligenza artificiale Jarvis in Iron Man, che non solo può aiutare l’utente a controllare vari dispositivi e gestire le faccende quotidiane, ma ha anche una super potenza di calcolo e capacità di pensiero. Negli intelligentitage, gli esseri umani riceveranno servizi migliori sia in quantità che in qualità.
Capitolo 1. Introduzione all'IoT 7

8 Avventura wireless ESP32-C3: una guida completa all'IoT

Capitolo Introduzione e pratica di 2 progetti IoT
Nel capitolo 1 abbiamo introdotto l’architettura dell’IoT, i ruoli e le interrelazioni del livello di percezione e controllo, del livello di rete, del livello della piattaforma e del livello dell’applicazione, nonché lo sviluppo della casa intelligente. Tuttavia, proprio come quando impariamo a dipingere, conoscere le conoscenze teoriche è lungi dall’essere sufficiente. Dobbiamo “sporcarci le mani” per mettere in pratica i progetti IoT per padroneggiare veramente la tecnologia. Inoltre, quando un progetto passa alla produzione di massa stage, è necessario considerare più fattori quali la connessione di rete, la configurazione, l'interazione della piattaforma cloud IoT, la gestione e gli aggiornamenti del firmware, la gestione della produzione di massa e la configurazione della sicurezza. Quindi, a cosa dobbiamo prestare attenzione quando sviluppiamo un progetto IoT completo? Nel capitolo 1 abbiamo menzionato che la casa intelligente è uno degli scenari di applicazione IoT più comuni e che le luci intelligenti sono uno degli apparecchi più basilari e pratici che possono essere utilizzati in case, hotel, palestre, ospedali, ecc. Pertanto, in In questo libro prenderemo come punto di partenza la costruzione di un progetto di luce intelligente, ne spiegheremo i componenti e le caratteristiche e forniremo indicazioni sullo sviluppo del progetto. Ci auguriamo che tu possa trarre conclusioni da questo caso per creare più applicazioni IoT.
2.1 Introduzione ai tipici progetti IoT
In termini di sviluppo, i moduli funzionali di base dei progetti IoT possono essere classificati in sviluppo software e hardware di dispositivi IoT, sviluppo di applicazioni client e sviluppo di piattaforme cloud IoT. È importante chiarire i moduli funzionali di base, che verranno ulteriormente descritti in questa sezione.
2.1.1 Moduli di base per dispositivi IoT comuni
Lo sviluppo software e hardware dei dispositivi IoT include i seguenti moduli base: Raccolta dati
Essendo lo strato inferiore dell'architettura IoT, i dispositivi IoT dello strato di percezione e controllo collegano sensori e dispositivi attraverso i loro chip e periferiche per ottenere la raccolta dei dati e il controllo delle operazioni.
9

Associazione dell'account e configurazione iniziale Per la maggior parte dei dispositivi IoT, l'associazione dell'account e la configurazione iniziale vengono completate in un unico processo operativo, ad esample, connettendo i dispositivi agli utenti configurando la rete Wi-Fi.
Interazione con le piattaforme IoT cloud Per monitorare e controllare i dispositivi IoT è necessario anche collegarli alle piattaforme IoT cloud, in modo da impartire comandi e segnalare lo stato attraverso l'interazione tra loro.
Controllo dei dispositivi Quando sono connessi alle piattaforme cloud IoT, i dispositivi possono comunicare con il cloud ed essere registrati, associati o controllati. Gli utenti possono interrogare lo stato del prodotto ed eseguire altre operazioni sull'app per smartphone attraverso piattaforme cloud IoT o protocolli di comunicazione locale.
Aggiornamento del firmware I dispositivi IoT possono anche ottenere l'aggiornamento del firmware in base alle esigenze dei produttori. Ricevendo i comandi inviati dal cloud, verrà realizzato l'aggiornamento del firmware e la gestione delle versioni. Con questa funzionalità di aggiornamento del firmware, puoi migliorare continuamente le funzioni dei dispositivi IoT, correggere i difetti e migliorare l'esperienza dell'utente.
2.1.2 Moduli Base delle Applicazioni Client
Le applicazioni client (es. app per smartphone) comprendono principalmente i seguenti moduli base:
Sistema di account e autorizzazione Supporta l'autorizzazione dell'account e del dispositivo.
Controllo del dispositivo Le app per smartphone sono generalmente dotate di funzioni di controllo. Gli utenti possono connettersi facilmente ai dispositivi IoT e gestirli sempre e ovunque tramite le app per smartphone. In una casa intelligente nel mondo reale, i dispositivi sono per lo più controllati tramite app per smartphone, che non solo consentono la gestione intelligente dei dispositivi, ma consentono anche di risparmiare sui costi della manodopera. Pertanto, il controllo del dispositivo è un must per le applicazioni client, come il controllo degli attributi delle funzioni del dispositivo, il controllo delle scene, la programmazione, il controllo remoto, il collegamento dei dispositivi, ecc. Gli utenti della casa intelligente possono anche personalizzare le scene in base alle esigenze personali, controllando l'illuminazione, gli elettrodomestici, l'ingresso , ecc., per rendere la vita domestica più comoda e conveniente. Possono temporizzare l'aria condizionata, spegnerla da remoto, accendere automaticamente la luce del corridoio una volta aperta la porta o passare alla modalità “teatro” con un solo pulsante.
Le applicazioni client di notifica aggiornano lo stato in tempo reale dei dispositivi IoT e inviano avvisi quando i dispositivi presentano anomalie.
10 Avventura wireless ESP32-C3: una guida completa all'IoT

Servizio clienti post-vendita Le app per smartphone possono fornire servizi post-vendita per i prodotti, per risolvere tempestivamente problemi legati a guasti dei dispositivi IoT e operazioni tecniche.
Funzioni in primo piano Per soddisfare le esigenze dei diversi utenti, è possibile aggiungere altre funzioni, come Shake, NFC, GPS, ecc. Il GPS può aiutare a impostare la precisione delle operazioni della scena in base alla posizione e alla distanza, mentre la funzione Shake consente agli utenti di impostare la comandi da eseguire per un dispositivo o una scena specifici tramite scuotimento.
2.1.3 Introduzione alle piattaforme cloud IoT comuni
La piattaforma cloud IoT è una piattaforma all-in-one che integra funzioni come la gestione dei dispositivi, la comunicazione sulla sicurezza dei dati e la gestione delle notifiche. A seconda del gruppo target e dell’accessibilità, le piattaforme cloud IoT possono essere suddivise in piattaforme cloud IoT pubbliche (di seguito “cloud pubblico”) e piattaforme cloud IoT private (di seguito “cloud privato”).
Il cloud pubblico di solito indica piattaforme cloud IoT condivise per aziende o privati, gestite e mantenute da fornitori di piattaforme e condivise tramite Internet. Può essere gratuito o a basso costo e fornisce servizi attraverso la rete pubblica aperta, come Alibaba Cloud, Tencent Cloud, Baidu Cloud, AWS IoT, Google IoT, ecc. Come piattaforma di supporto, il cloud pubblico può integrare fornitori di servizi upstream e utenti finali a valle per creare una nuova catena del valore ed un nuovo ecosistema.
Il cloud privato è realizzato esclusivamente per uso aziendale, garantendo così il miglior controllo su dati, sicurezza e qualità del servizio. I suoi servizi e la sua infrastruttura sono gestiti separatamente dalle imprese e anche l'hardware e il software di supporto sono dedicati a utenti specifici. Le aziende possono personalizzare i servizi cloud per soddisfare le esigenze della propria azienda. Al momento, alcuni produttori di case intelligenti hanno già piattaforme cloud IoT private e hanno sviluppato applicazioni per la casa intelligente basate su di esse.
Il cloud pubblico e il cloud privato hanno i propri vantaggitages, che verrà spiegato più avanti.
Per ottenere la connettività di comunicazione, è necessario completare almeno lo sviluppo integrato sul lato dispositivo, insieme ai server aziendali, alle piattaforme cloud IoT e alle app per smartphone. Di fronte a un progetto così grande, il cloud pubblico normalmente fornisce kit di sviluppo software per app lato dispositivo e smartphone per accelerare il processo. Sia il cloud pubblico che quello privato forniscono servizi tra cui accesso ai dispositivi, gestione dei dispositivi, shadow dei dispositivi, funzionamento e manutenzione.
Accesso ai dispositivi Le piattaforme cloud IoT devono fornire non solo interfacce per l'accesso ai dispositivi tramite protocolli
Capitolo 2. Introduzione e pratica dei progetti IoT 11

come MQTT, CoAP, HTTPS e WebSocket, ma anche la funzione di autenticazione di sicurezza del dispositivo per bloccare dispositivi contraffatti e illegali, riducendo di fatto il rischio di compromissione. Tale autenticazione solitamente supporta diversi meccanismi, quindi quando i dispositivi vengono prodotti in serie, è necessario preassegnare il certificato del dispositivo in base al meccanismo di autenticazione selezionato e masterizzarlo sui dispositivi.
Gestione dei dispositivi La funzione di gestione dei dispositivi fornita dalle piattaforme cloud IoT non solo può aiutare i produttori a monitorare lo stato di attivazione e lo stato online dei loro dispositivi in tempo reale, ma consente anche opzioni come l'aggiunta/rimozione di dispositivi, il recupero, l'aggiunta/eliminazione di gruppi, l'aggiornamento del firmware e gestione delle versioni.
Device shadow Le piattaforme cloud IoT possono creare una versione virtuale persistente (device shadow) per ciascun dispositivo e lo stato del dispositivo shadow può essere sincronizzato e ottenuto dall'app per smartphone o da altri dispositivi tramite protocolli di trasmissione Internet. Il dispositivo shadow memorizza l'ultimo stato segnalato e lo stato previsto di ciascun dispositivo e, anche se il dispositivo è offline, può comunque ottenere lo stato chiamando le API. Device Shadow fornisce API sempre attive, che semplificano la creazione di app per smartphone che interagiscono con i dispositivi.
Funzionamento e manutenzione La funzione O&M comprende tre aspetti: · Dimostrazione di informazioni statistiche sui dispositivi IoT e sulle notifiche. · La gestione dei registri consente il recupero di informazioni sul comportamento del dispositivo, sul flusso dei messaggi su/giù e sul contenuto dei messaggi. · Il debug del dispositivo supporta l'invio di comandi, l'aggiornamento della configurazione e il controllo dell'interazione tra le piattaforme cloud IoT e i messaggi del dispositivo.
2.2 Esercitazione: Progetto Smart Light
Dopo l'introduzione teorica in ogni capitolo, troverai una sezione pratica relativa al progetto Smart Light per aiutarti a fare esperienza pratica. Il progetto si basa sul chip ESP32-C3 di Espressif e sulla piattaforma cloud IoT ESP RainMaker e copre l'hardware dei moduli wireless nei prodotti di illuminazione intelligente, il software integrato per dispositivi intelligenti basati su ESP32C3, le app per smartphone e l'interazione ESP RainMaker.
Codice sorgente Per una migliore esperienza di apprendimento e sviluppo, il progetto in questo libro è stato reso open source. Puoi scaricare il codice sorgente dal nostro repository GitHub all'indirizzo https://github. com/espressif/book-esp32c3-iot-projects.
12 Avventura wireless ESP32-C3: una guida completa all'IoT

2.2.1 Struttura del progetto
Il progetto Smart Light si compone di tre parti: i. Dispositivi di illuminazione intelligenti basati su ESP32-C3, responsabili dell'interazione con le piattaforme cloud IoT e del controllo dell'interruttore, della luminosità e della temperatura del colore del LED lamp perline. ii. App per smartphone (comprese le app per tablet con sistema operativo Android e iOS), responsabili della configurazione di rete dei prodotti di illuminazione intelligente, nonché dell'interrogazione e del controllo del loro stato.
iii. Una piattaforma cloud IoT basata su ESP RainMaker. Per semplificazione, in questo libro consideriamo la piattaforma cloud IoT e il server aziendale nel loro insieme. I dettagli su ESP RainMaker verranno forniti nel capitolo 3.
La corrispondenza tra la struttura del progetto Smart Light e l'architettura dell'IoT è mostrata in Figura 2.1.
Figura 2.1. Struttura del progetto di luce intelligente
2.2.2 Funzioni del progetto
Divise in base alla struttura, le funzioni di ciascuna parte sono le seguenti. Dispositivi di illuminazione intelligenti
· Configurazione e connessione di rete. · Controllo PWM LED, come interruttore, luminosità, temperatura del colore, ecc. · Automazione o controllo delle scene, ad es. interruttore orario. · Crittografia e avvio sicuro di Flash. · Aggiornamento del firmware e gestione delle versioni.
Capitolo 2. Introduzione e pratica dei progetti IoT 13

App per smartphone · Configurazione di rete e associazione del dispositivo. · Controllo intelligente dei prodotti luminosi, come interruttore, luminosità, temperatura del colore, ecc. · Automazione o impostazioni della scena, ad es. interruttore orario. · Controllo locale/remoto. · Registrazione utente, login, ecc.
Piattaforma cloud ESP RainMaker IoT · Abilitazione dell'accesso ai dispositivi IoT. · Fornire API per il funzionamento del dispositivo accessibili alle app per smartphone. · Aggiornamento del firmware e gestione delle versioni.
2.2.3 Preparazione dell'hardware
Se sei interessato a mettere in pratica il progetto, avrai bisogno anche del seguente hardware: luci intelligenti, smartphone, router Wi-Fi e un computer che soddisfi i requisiti di installazione dell'ambiente di sviluppo. Luci intelligenti
Le luci intelligenti sono un nuovo tipo di lampadine, la cui forma è la stessa delle normali lampadine a incandescenza. Una luce intelligente è composta da un alimentatore regolato con condensatore step-down, un modulo wireless (con ESP32-C3 integrato), un controller LED e una matrice LED RGB. Quando collegato all'alimentazione, il 15 V DC voltagL'uscita dopo lo step-down del condensatore, la rettifica del diodo e la regolazione fornisce energia al controller LED e alla matrice LED. Il controller LED può inviare automaticamente livelli alti e bassi a determinati intervalli, commutando la matrice LED RGB tra chiusa (luci accese) e aperta (luci spente), in modo che possa emettere ciano, giallo, verde, viola, blu, rosso e luce bianca. Il modulo wireless è responsabile della connessione al router Wi-Fi, della ricezione e della segnalazione dello stato delle luci intelligenti e dell'invio di comandi per controllare il LED.
Figura 2.2. Una luce intelligente simulata
Nei primi sviluppi stage, puoi simulare una luce intelligente utilizzando la scheda ESP32-C3DevKitM-1 collegata al LED RGB lamp perline (vedere Figura 2.2). Ma dovresti
14 Avventura wireless ESP32-C3: una guida completa all'IoT

tieni presente che questo non è l'unico modo per assemblare una luce intelligente. La progettazione hardware del progetto in questo libro contiene solo un modulo wireless (con ESP32-C3 integrato), ma non una progettazione hardware completa per la luce intelligente. Inoltre, Espressif produce anche una scheda di sviluppo audio basata su ESP32-C3 ESP32C3-Lyra per il controllo delle luci con audio. La scheda dispone di interfacce per microfoni e altoparlanti e può controllare strisce LED. Può essere utilizzato per sviluppare emittenti audio a bassissimo costo e ad alte prestazioni e strisce luminose ritmiche. La Figura 2.3 mostra una scheda ESP32-C3Lyra collegata a una striscia di 40 luci LED.
Figura 2.3. ESP32-C3-Lyra collegato con una striscia di 40 luci LED
Smartphone (Android/iOS) Il progetto Smart Light prevede lo sviluppo di un'app per smartphone per la configurazione e il controllo di prodotti di luce intelligente.
Router Wi-Fi I router Wi-Fi convertono i segnali di rete cablata e mobile in segnali di rete wireless, per consentire a computer, smartphone, tablet e altri dispositivi wireless di connettersi alla rete. Per esampLe, la banda larga in casa deve solo essere connessa a un router Wi-Fi per ottenere la rete wireless dei dispositivi Wi-Fi. Lo standard di protocollo principale supportato dai router Wi-Fi è IEEE 802.11n, con un TxRate medio di 300 Mbps o 600 Mbps al massimo. Sono retrocompatibili con IEEE 802.11b e IEEE 802.11g. Il chip ESP32-C3 di Espressif supporta IEEE 802.11b/g/n, quindi puoi scegliere un router Wi-Fi a banda singola (2.4 GHz) o dual-band (2.4 GHz e 5 GHz).
Un ambiente di sviluppo per computer (Linux/macOS/Windows) verrà introdotto nel capitolo 4. Capitolo 2. Introduzione e pratica dei progetti IoT 15

2.2.4 Processo di sviluppo
Figura 2.4. Le fasi di sviluppo del progetto Smart Light
Progettazione hardware La progettazione hardware dei dispositivi IoT è essenziale per un progetto IoT. Un progetto completo di luce intelligente è destinato a produrre alamp lavorando con alimentazione di rete. Diversi produttori producono lampEsistono modelli e tipi di driver diversi, ma i loro moduli wireless hanno solitamente la stessa funzione. Per semplificare il processo di sviluppo del progetto Smart Ligh, questo libro copre solo la progettazione hardware e lo sviluppo software dei moduli wireless.
Configurazione della piattaforma cloud IoT Per utilizzare le piattaforme cloud IoT, è necessario configurare progetti sul backend, come la creazione di prodotti, la creazione di dispositivi, l'impostazione delle proprietà del dispositivo, ecc.
Sviluppo di software integrato per dispositivi IoT Implementa le funzioni previste con ESP-IDF, l'SDK lato dispositivo di Espressif, inclusa la connessione a piattaforme cloud IoT, lo sviluppo di driver LED e l'aggiornamento del firmware.
Sviluppo di app per smartphone Sviluppa app per smartphone per sistemi Android e iOS per realizzare la registrazione e l'accesso degli utenti, il controllo del dispositivo e altre funzioni.
Ottimizzazione dei dispositivi IoT Una volta completato lo sviluppo di base delle funzioni dei dispositivi IoT, è possibile dedicarsi ad attività di ottimizzazione, come l'ottimizzazione della potenza.
Test di produzione in serie Eseguire test di produzione in serie secondo gli standard correlati, come test funzionali delle apparecchiature, test di invecchiamento, test RF, ecc.
Nonostante i passaggi sopra elencati, un progetto Smart Light non è necessariamente soggetto a tale procedura in quanto possono essere svolti anche compiti diversi contemporaneamente. Per esample, software embedded e app per smartphone possono essere sviluppati in parallelo. Potrebbe anche essere necessario ripetere alcuni passaggi, come l’ottimizzazione dei dispositivi IoT e i test sulla produzione di massa.
16 Avventura wireless ESP32-C3: una guida completa all'IoT

2.3 Riepilogo
In questo capitolo, abbiamo prima illustrato i componenti di base e i moduli funzionali di un progetto IoT, quindi abbiamo introdotto il caso Smart Light per la pratica, facendo riferimento alla sua struttura, funzioni, preparazione dell'hardware e processo di sviluppo. I lettori possono trarre conclusioni dalla pratica e acquisire la fiducia necessaria per realizzare progetti IoT in futuro con il minimo errore.
Capitolo 2. Introduzione e pratica dei progetti IoT 17

18 Avventura wireless ESP32-C3: una guida completa all'IoT

Capitolo 3

Introduzione

ESP

Creatore di pioggia

L’Internet delle cose (IoT) offre infinite possibilità per cambiare il modo in cui le persone vivono, ma lo sviluppo dell’ingegneria IoT è pieno di sfide. Con i cloud pubblici, i produttori di terminali possono implementare le funzionalità del prodotto attraverso le seguenti soluzioni:
Basato sulle piattaforme cloud dei fornitori di soluzioni. In questo modo, i produttori di terminali devono solo progettare l'hardware del prodotto, quindi connettere l'hardware al cloud utilizzando il modulo di comunicazione fornito e configurare le funzioni del prodotto seguendo le linee guida. Si tratta di un approccio efficiente poiché elimina la necessità di sviluppo, operazioni e manutenzione (O&M) lato server e lato applicazione. Consente ai produttori di terminali di concentrarsi sulla progettazione dell'hardware senza dover considerare l'implementazione del cloud. Tuttavia, tali soluzioni (ad esempio, firmware del dispositivo e app) generalmente non sono open source, quindi le funzioni del prodotto saranno limitate dalla piattaforma cloud del fornitore che non può essere personalizzata. Nel frattempo, anche i dati dell'utente e del dispositivo appartengono alla piattaforma cloud.
Basato su prodotti cloud In questa soluzione, dopo aver completato la progettazione dell'hardware, i produttori di terminali non solo devono implementare le funzioni cloud utilizzando uno o più prodotti cloud forniti dal cloud pubblico, ma devono anche collegare l'hardware al cloud. Per esample, per connettersi ad Amazon Web Services (AWS), i produttori di terminali devono utilizzare prodotti AWS come Amazon API Gateway, AWS IoT Core e AWS Lambda per consentire l'accesso ai dispositivi, il controllo remoto, l'archiviazione dei dati, la gestione degli utenti e altre funzioni di base. Non solo chiede ai produttori di terminali di utilizzare e configurare in modo flessibile i prodotti cloud con una conoscenza approfondita e una ricca esperienza, ma richiede anche loro di considerare i costi di costruzione e manutenzione per i servizi iniziali e successivi.tages Ciò pone grandi sfide alle energie e alle risorse dell'azienda.
Rispetto ai cloud pubblici, i cloud privati vengono generalmente realizzati per progetti e prodotti specifici. Agli sviluppatori di cloud privato viene concesso il massimo livello di libertà nella progettazione del protocollo e nell'implementazione della logica aziendale. I produttori di terminali possono realizzare prodotti e schemi di progettazione a piacimento e integrare e potenziare facilmente i dati degli utenti. Combina l'elevata sicurezza, scalabilità e affidabilità del cloud pubblico con advantages del cloud privato, Espressif ha lanciato ESP
19

RainMaker, una soluzione cloud privata profondamente integrata basata sul cloud Amazon. Gli utenti possono distribuire ESP RainMaker e creare cloud privato semplicemente con un account AWS.
3.1 Cos'è ESP RainMaker?
ESP RainMaker è una piattaforma AIoT completa costruita con più prodotti AWS maturi. Fornisce vari servizi richiesti per la produzione di massa come l'accesso al cloud del dispositivo, l'aggiornamento del dispositivo, la gestione del backend, l'accesso di terze parti, l'integrazione vocale e la gestione degli utenti. Utilizzando il Serverless Application Repository (SAR) fornito da AWS, i produttori di terminali possono distribuire rapidamente ESP RainMaker sui propri account AWS, in modo efficiente in termini di tempo e facile da utilizzare. Gestito e mantenuto da Espressif, il SAR utilizzato da ESP RainMaker aiuta gli sviluppatori a ridurre i costi di manutenzione del cloud e ad accelerare lo sviluppo di prodotti AIoT, creando così soluzioni AIoT sicure, stabili e personalizzabili. La Figura 3.1 mostra l'architettura di ESP RainMaker.
Figura 3.1. Architettura di ESP RainMaker
Il server pubblico ESP RainMaker di Espressif è gratuito per tutti gli appassionati, i creatori e gli educatori ESP per la valutazione della soluzione. Gli sviluppatori possono accedere con account Apple, Google o GitHub e creare rapidamente i propri prototipi di applicazioni IoT. Il server pubblico integra Alexa e Google Home e fornisce servizi di controllo vocale supportati da Alexa Skill e Google Actions. Anche la sua funzione di riconoscimento semantico è alimentata da terze parti. I dispositivi IoT RainMaker rispondono solo ad azioni specifiche. Per un elenco esaustivo dei comandi vocali supportati, controlla le piattaforme di terze parti. Inoltre, Espressif offre un'app pubblica RainMaker per consentire agli utenti di controllare i prodotti tramite smartphone. 20 Avventura wireless ESP32-C3: una guida completa all'IoT

3.2 L'implementazione di ESP RainMaker
Come mostrato nella Figura 3.2, ESP RainMaker è costituito da quattro parti: · Servizio di richiesta, che consente ai dispositivi RainMaker di ottenere dinamicamente i certificati. · RainMaker Cloud (noto anche come backend cloud), che fornisce servizi come filtraggio dei messaggi, gestione degli utenti, archiviazione dei dati e integrazioni di terze parti. · RainMaker Agent, che consente ai dispositivi RainMaker di connettersi a RainMaker Cloud. · RainMaker Client (app RainMaker o script CLI), per il provisioning, la creazione di utenti, l'associazione e il controllo dei dispositivi, ecc.
Figura 3.2. Struttura dell'ESP RainMaker
ESP RainMaker fornisce un set completo di strumenti per lo sviluppo del prodotto e la produzione di massa, tra cui: RainMaker SDK
RainMaker SDK è basato su ESP-IDF e fornisce il codice sorgente dell'agente lato dispositivo e le relative API C per lo sviluppo del firmware. Gli sviluppatori devono solo scrivere la logica dell'applicazione e lasciare il resto al framework RainMaker. Per ulteriori informazioni sulle API C, visitare https://bookc3.espressif.com/rm/c-api-reference. App RainMaker La versione pubblica dell'app RainMaker consente agli sviluppatori di completare il provisioning dei dispositivi, nonché di controllare e interrogare lo stato dei dispositivi (ad esempio, prodotti di illuminazione intelligente). È disponibile sia sugli app store iOS che Android. Per maggiori dettagli, fare riferimento al capitolo 10. API REST Le API REST aiutano gli utenti a creare le proprie applicazioni simili all'app RainMaker. Per ulteriori informazioni, visitare https://swaggerapis.rainmaker.espressif.com/.
Capitolo 3. Introduzione a ESP RainMaker 21

API Python Viene fornita una CLI basata su Python, fornita con RainMaker SDK, per implementare tutte le funzioni simili alle funzionalità dello smartphone. Per ulteriori informazioni sulle API Python, visitare https://bookc3.espressif.com/rm/python-api-reference.
CLI di amministrazione La CLI di amministrazione, con un livello di accesso più elevato, viene fornita per la distribuzione privata di ESP RainMaker per generare certificati del dispositivo in blocco.
3.2.1 Servizio di richiesta
Tutte le comunicazioni tra i dispositivi RainMaker e il backend cloud vengono effettuate tramite MQTT+TLS. Nel contesto di ESP RainMaker, "Claiming" è il processo in cui i dispositivi ottengono certificati dal Claiming Service per connettersi al backend cloud. Tieni presente che il servizio di richiesta è applicabile solo al servizio RainMaker pubblico, mentre per la distribuzione privata i certificati del dispositivo devono essere generati in blocco tramite la CLI di amministrazione. ESP RainMaker supporta tre tipi di servizio di rivendicazione: Self Claiming
Il dispositivo stesso recupera i certificati tramite una chiave segreta preprogrammata in eFuse dopo la connessione a Internet. Richiesta guidata dall'host I certificati vengono ottenuti dall'host di sviluppo con l'account RainMaker. Assisted Claiming I certificati vengono ottenuti tramite applicazioni smartphone durante il provisioning.
3.2.2 Agente RainMaker
Figura 3.3. Struttura di RainMaker SDK La funzione principale di RainMaker Agent è fornire connettività e assistere il livello dell'applicazione nell'elaborazione dei dati cloud di uplink/downlink. È realizzato tramite RainMaker SDK 22 ESP32-C3 Wireless Adventure: una guida completa all'IoT

e sviluppato sulla base del collaudato framework ESP-IDF, utilizzando componenti ESP-IDF come RTOS, NVS e MQTT. La Figura 3.3 mostra la struttura dell'SDK RainMaker.
L'SDK RainMaker include due funzionalità principali.
Connessione
io. Collaborazione con Claiming Service per ottenere certificati del dispositivo.
ii. Connessione al backend cloud utilizzando il protocollo MQTT sicuro per fornire connettività remota e implementare controllo remoto, reporting dei messaggi, gestione degli utenti, gestione dei dispositivi, ecc. Utilizza il componente MQTT in ESP-IDF per impostazione predefinita e fornisce un livello di astrazione per interfacciarsi con altri stack di protocolli.
iii. Fornisce il componente di provisioning Wi-Fi per la connessione e il provisioning Wi-Fi, il componente esp https ota per gli aggiornamenti OTA e il componente esp local ctrl per il rilevamento e la connessione del dispositivo locale. Tutti questi obiettivi possono essere raggiunti attraverso una semplice configurazione.
Elaborazione dei dati
io. Memorizzando i certificati del dispositivo emessi dal Claiming Service e i dati necessari durante l'esecuzione di RainMaker, per impostazione predefinita utilizzando l'interfaccia fornita dal componente flash nvs e fornendo API agli sviluppatori per l'uso diretto.
ii. Utilizzando il meccanismo di callback per elaborare i dati cloud di uplink/downlink e sbloccare automaticamente i dati al livello dell'applicazione per una facile elaborazione da parte degli sviluppatori. Per esample, RainMaker SDK fornisce interfacce avanzate per stabilire i dati TSL (Thing Specifica Language), necessari per definire i modelli TSL per descrivere i dispositivi IoT e implementare funzioni come temporizzazione, conto alla rovescia e controllo vocale. Per le funzionalità interattive di base come la temporizzazione, RainMaker SDK fornisce una soluzione priva di sviluppo che può essere semplicemente abilitata quando necessario. Quindi, l'agente RainMaker elaborerà direttamente i dati, li invierà al cloud tramite l'argomento MQTT associato e restituirà le modifiche dei dati nel backend cloud tramite il meccanismo di callback.
3.2.3 Back-end cloud
Il backend cloud è basato su AWS Serverless Computing e ottenuto tramite AWS Cognito (sistema di gestione delle identità), Amazon API Gateway, AWS Lambda (servizio di elaborazione serverless), Amazon DynamoDB (database NoSQL), AWS IoT Core (core di accesso IoT che fornisce accesso MQTT e filtraggio delle regole), Amazon Simple Email Service (servizio di posta semplice SES), Amazon CloudFront (rete di consegna veloce), Amazon Simple Queue Service (accodamento di messaggi SQS) e Amazon S3 (servizio di storage bucket). Ha lo scopo di ottimizzare la scalabilità e la sicurezza. Con ESP RainMaker, gli sviluppatori possono gestire i dispositivi senza dover scrivere codice nel cloud. I messaggi riportati dai dispositivi vengono trasmessi in modo trasparente
Capitolo 3. Introduzione a ESP RainMaker 23

client di applicazioni o altri servizi di terze parti. La tabella 3.1 mostra i prodotti e le funzioni cloud AWS utilizzati nel backend cloud, con ulteriori prodotti e funzionalità in fase di sviluppo.
Tabella 3.1. Prodotti e funzioni cloud AWS utilizzati dal backend cloud

Prodotto cloud AWS utilizzato da RainMaker

Funzione

AWS Cognito

Gestione delle credenziali utente e supporto degli accessi di terze parti

AWS Lambda

Implementare la logica aziendale principale del backend cloud

Amazon Timestream Archiviazione di dati di serie temporali

Amazon DynamoDB Archiviazione delle informazioni private dei clienti

AWS IoT Core

Supporta la comunicazione MQTT

Amazon SES

Fornitura di servizi di invio di e-mail

Amazon CloudFront Accelerazione della gestione del backend webaccesso al sito

Amazon SQS

Inoltro di messaggi da AWS IoT Core

3.2.4 Cliente RainMaker
I client RainMaker, come App e CLI, comunicano con il backend cloud tramite API REST. Informazioni dettagliate e istruzioni sulle API REST sono disponibili nella documentazione Swagger fornita da Espressif. Il client dell'applicazione mobile di RainMaker è disponibile sia per i sistemi iOS che Android. Consente il provisioning, il controllo e la condivisione dei dispositivi, nonché la creazione e l'attivazione di attività di conto alla rovescia e la connessione a piattaforme di terze parti. Può caricare automaticamente l'interfaccia utente e le icone in base alla configurazione riportata dai dispositivi e visualizzare completamente il TSL del dispositivo.
Per esempioample, se una luce intelligente è costruita sull'SDK fornito da RainMaker example, l'icona e l'interfaccia utente della lampadina verranno caricate automaticamente al termine del provisioning. Gli utenti possono modificare il colore e la luminosità della luce attraverso l'interfaccia e ottenere il controllo di terze parti collegando Alexa Smart Home Skill o Google Smart Home Actions ai propri account ESP RainMaker. La Figura 3.4 mostra l'icona e l'interfaccia utente example della lampadina rispettivamente su Alexa, Google Home e sull'app ESP RainMaker.

24 Avventura wireless ESP32-C3: una guida completa all'IoT

(a) Esample – Alexa

(b) Esample – Google Home

(c) Esample – ESP RainMaker
Figura 3.4. Esampfile di icone e interfaccia utente della lampadina su Alexa, Google Home e sull'app ESP RainMaker
3.3 Pratica: punti chiave per lo sviluppo con ESP RainMaker
Una volta completato il livello del driver del dispositivo, gli sviluppatori possono iniziare a creare modelli TSL ed elaborare i dati di downlink utilizzando le API fornite da RainMaker SDK e abilitare i servizi di base ESP RainMaker in base alla definizione e ai requisiti del prodotto.
Capitolo 3. Introduzione a ESP RainMaker 25

La sezione 9.4 di questo libro spiegherà l'implementazione della luce intelligente a LED in RainMaker. Durante il debug, gli sviluppatori possono utilizzare gli strumenti CLI nell'SDK RainMaker per comunicare con la luce intelligente (o chiamare le API REST da Swagger).
Il capitolo 10 elaborerà l'utilizzo delle API REST nello sviluppo di applicazioni per smartphone. Gli aggiornamenti OTA delle luci intelligenti a LED saranno trattati nel capitolo 11. Se gli sviluppatori hanno abilitato il monitoraggio remoto ESP Insights, il backend di gestione ESP RainMaker visualizzerà i dati ESP Insights. I dettagli saranno presentati nel capitolo 15.
ESP RainMaker supporta la distribuzione privata, che differisce dal server RainMaker pubblico nei seguenti modi:
Servizio di richiesta Per generare certificati nelle distribuzioni private, è necessario utilizzare la CLI di amministrazione di RainMaker anziché la richiesta. Con il server pubblico, agli sviluppatori devono essere concessi i diritti di amministratore per implementare l'aggiornamento del firmware, ma ciò non è auspicabile nelle distribuzioni commerciali. Pertanto, non è possibile fornire né un servizio di autenticazione separato per la rivendicazione autonoma, né diritti di amministratore per la rivendicazione guidata o assistita dall'host.
App del telefono Nelle distribuzioni private, le applicazioni devono essere configurate e compilate separatamente per garantire che i sistemi di account non siano interoperabili.
Accessi di terze parti e integrazione vocale Gli sviluppatori devono effettuare la configurazione separatamente tramite gli account Google e Apple Developer per abilitare gli accessi di terze parti, nonché l'integrazione di Alexa Skill e Google Voice Assistant.
SUGGERIMENTI Per dettagli sull'implementazione del cloud, visitare https://customer.rainmaker.espressif. com. In termini di firmware, la migrazione dal server pubblico al server privato richiede solo la sostituzione dei certificati del dispositivo, il che migliora notevolmente l'efficienza della migrazione e riduce i costi di migrazione e debug secondario.
3.4 Caratteristiche di ESP RainMaker
Le funzionalità di ESP RainMaker sono principalmente mirate a tre aspetti: gestione degli utenti, utenti finali e amministratori. Tutte le funzionalità sono supportate sia nei server pubblici che in quelli privati, salvo diversa indicazione.
3.4.1 Gestione utenti
Le funzionalità di gestione degli utenti consentono agli utenti finali di registrarsi, accedere, modificare password, recuperare password, ecc.
26 Avventura wireless ESP32-C3: una guida completa all'IoT

Registrati e accedi I metodi di registrazione e accesso supportati da RainMaker includono: · ID e-mail + password · Numero di telefono + password · Account Google · Account Apple · Account GitHub (solo server pubblico) · Account Amazon (solo server privato)
NOTA La registrazione utilizzando Google/Amazon condivide l'indirizzo email dell'utente con RainMaker. L'iscrizione utilizzando Apple condivide un indirizzo fittizio che Apple assegna all'utente appositamente per il servizio RainMaker. Verrà creato automaticamente un account RainMaker per gli utenti che accedono per la prima volta con un account Google, Apple o Amazon.
Modifica password Valido solo per accessi basati su ID e-mail/numero di telefono. Tutte le altre sessioni attive verranno disconnesse dopo la modifica della password. Secondo il comportamento di AWS Cognito, le sessioni disconnesse possono rimanere attive fino a 1 ora.
Recupera password Valido solo per accessi basati su ID e-mail/numero di telefono.
3.4.2 Funzionalità per l'utente finale
Le funzionalità aperte agli utenti finali includono controllo e monitoraggio locale e remoto, pianificazione, raggruppamento di dispositivi, condivisione di dispositivi, notifiche push e integrazioni di terze parti.
Controllo e monitoraggio remoto · Interroga configurazione, valori dei parametri e stato della connessione per uno o tutti i dispositivi. · Impostare i parametri per dispositivi singoli o multipli.
Controllo e monitoraggio locale Il telefono cellulare e il dispositivo devono essere collegati alla stessa rete per il controllo locale.
Pianificazione · Gli utenti preimpostano determinate azioni in un momento specifico. · Nessuna connessione Internet richiesta per il dispositivo durante l'esecuzione della pianificazione. · Una volta o ripeti (specificando i giorni) per dispositivi singoli o multipli.
Raggruppamento dei dispositivi Supporta il raggruppamento astratto multilivello I metadati del gruppo possono essere utilizzati per creare una struttura Home Room.
Capitolo 3. Introduzione a ESP RainMaker 27

Condivisione dispositivo Uno o più dispositivi possono essere condivisi con uno o più utenti.
Notifiche push Gli utenti finali riceveranno notifiche push per eventi quali · Nuovi dispositivi aggiunti/rimossi · Dispositivo connesso al cloud · Dispositivo disconnesso dal cloud · Richieste di condivisione del dispositivo create/accettate/rifiutate · Messaggi di avviso segnalati dai dispositivi
Integrazioni di terze parti Sono supportate Alexa e Google Voice Assistant per controllare i dispositivi RainMaker, tra cui luci, interruttori, prese, ventole e sensori di temperatura.
3.4.3 Funzionalità di amministrazione
Le funzionalità di amministrazione consentono agli amministratori di implementare la registrazione dei dispositivi, il raggruppamento dei dispositivi e gli aggiornamenti OTA view statistiche e dati ESP Insights.
Registrazione del dispositivo Genera certificati del dispositivo e registrati con l'Admin CLI (solo server privato).
Raggruppamento dei dispositivi Crea gruppi astratti o strutturati in base alle informazioni del dispositivo (solo server privato).
Aggiornamenti Over-the-Air (OTA) Carica il firmware in base alla versione e al modello, su uno o più dispositivi o un gruppo Monitora, annulla o archivia processi OTA.
View statistica Viewle statistiche disponibili includono: · Registrazioni dei dispositivi (certificati registrati dall'amministratore) · Attivazioni dei dispositivi (dispositivo connesso per la prima volta) · Account utente · Associazione utente-dispositivo
View Dati ESP Insights ViewI dati ESP Insights includono: · Errori, avvisi e registri personalizzati · Report e analisi sugli arresti anomali · Motivi del riavvio · Metriche come utilizzo della memoria, RSSI, ecc. · Metriche e variabili personalizzate
28 Avventura wireless ESP32-C3: una guida completa all'IoT

3.5 Riepilogo
In questo capitolo abbiamo introdotto alcune differenze chiave tra la distribuzione pubblica di RainMaker e quella privata. La soluzione privata ESP RainMaker lanciata da Espressif è altamente affidabile ed estensibile. Tutti i chip della serie ESP32 sono stati collegati e adattati ad AWS, il che riduce notevolmente i costi. Gli sviluppatori possono concentrarsi sulla verifica del prototipo senza dover conoscere i prodotti cloud AWS. Abbiamo anche spiegato l'implementazione e le funzionalità di ESP RainMaker e alcuni punti chiave per lo sviluppo utilizzando la piattaforma.
Scansione per scaricare ESP RainMaker per Android Scansione per scaricare ESP RainMaker per iOS
Capitolo 3. Introduzione a ESP RainMaker 29

30 Avventura wireless ESP32-C3: una guida completa all'IoT

Capitolo Impostazione 4 Ambiente di sviluppo
Questo capitolo si concentra su ESP-IDF, il framework di sviluppo software ufficiale per ESP32-C3. Spiegheremo come configurare l'ambiente su vari sistemi operativi e introdurremo la struttura del progetto e il sistema di creazione di ESP-IDF, nonché l'utilizzo dei relativi strumenti di sviluppo. Quindi presenteremo il processo di compilazione ed esecuzione di un example progetto, offrendo al contempo una spiegazione dettagliata del registro di output ad ogni stage.
4.1 ESP-IDF Finitaview
ESP-IDF (Espressif IoT Development Framework) è un framework di sviluppo IoT completo fornito da Espressif Technology. Utilizza C/C++ come linguaggio di sviluppo principale e supporta la compilazione incrociata con i sistemi operativi tradizionali come Linux, Mac e Windows. L'exampi programmi inclusi in questo libro sono sviluppati utilizzando ESP-IDF, che offre le seguenti funzionalità: · Driver a livello di sistema SoC. ESP-IDF include driver per ESP32, ESP32-S2, ESP32-C3,
e altri chip. Questi driver comprendono libreria periferica di basso livello (LL), libreria HAL (hardware abstraction layer), supporto RTOS e software driver di livello superiore, ecc. · Componenti essenziali. ESP-IDF incorpora componenti fondamentali necessari per lo sviluppo dell'IoT. Ciò include più stack di protocolli di rete come HTTP e MQTT, un framework di gestione dell'alimentazione con modulazione di frequenza dinamica e funzionalità come crittografia Flash e avvio sicuro, ecc. · Strumenti di sviluppo e produzione. ESP-IDF fornisce strumenti comunemente utilizzati per la creazione, il flashing e il debug durante lo sviluppo e la produzione di massa (vedere Figura 4.1), come il sistema di creazione basato su CMake, la catena di strumenti di compilazione incrociata basata su GCC e JTAG strumento di debug basato su OpenOCD, ecc. Vale la pena notare che il codice ESP-IDF aderisce principalmente alla licenza open source Apache 2.0. Gli utenti possono sviluppare software personale o commerciale senza restrizioni rispettando i termini della licenza open source. Inoltre, agli utenti vengono concesse licenze di brevetto permanenti gratuitamente, senza l'obbligo di rendere open source eventuali modifiche apportate al codice sorgente.
31

Figura 4.1.

Compilazione, flashing e debug-

strumenti per lo sviluppo e la produzione di massa

4.1.1 Versioni ESP-IDF
Il codice ESP-IDF è ospitato su GitHub come progetto open source. Attualmente sono disponibili tre versioni principali: v3, v4 e v5. Ogni versione principale solitamente contiene varie sottoversioni, come v4.2, v4.3 e così via. Espressif Systems garantisce un supporto di 30 mesi per correzioni di bug e patch di sicurezza per ogni sottoversione rilasciata. Pertanto, vengono rilasciate regolarmente anche revisioni delle subversioni, come v4.3.1, v4.2.2, ecc. La tabella 4.1 mostra lo stato di supporto delle diverse versioni ESP-IDF per i chip Espressif, indicando se sono in una versione preview stage (offrendo supporto per preview versioni, che potrebbero non avere determinate funzionalità o documentazione) o che siano ufficialmente supportate.

Tabella 4.1. Stato di supporto di diverse versioni ESP-IDF per i chip Espressif

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

v4.1 supportato

v4.2 supportato supportato

v4.3 supportato supportato supportato

v4.4 supportato supportato supportato supportato
preview

v5.0 supportato supportato supportato supportato supportato supportato preview

32 Avventura wireless ESP32-C3: una guida completa all'IoT

L'iterazione delle versioni principali comporta spesso adeguamenti alla struttura del framework e aggiornamenti al sistema di compilazione. Per esample, il cambiamento principale da v3.* a v4.* è stata la migrazione graduale del sistema di compilazione da Make a CMake. D'altra parte, l'iterazione di versioni minori comporta tipicamente l'aggiunta di nuove funzionalità o il supporto per nuovi chip.
È importante distinguere e comprendere la relazione tra versioni stabili e rami GitHub. Le versioni etichettate come v*.* o v*.*.* rappresentano versioni stabili che hanno superato test interni completi da parte di Espressif. Una volta risolto il problema, il codice, la catena di strumenti e i documenti di rilascio per la stessa versione rimangono invariati. Tuttavia, i rami GitHub (ad esempio il ramo release/v4.3) sono sottoposti a frequenti commit del codice, spesso su base giornaliera. Pertanto, due frammenti di codice sotto lo stesso ramo potrebbero differire, rendendo necessario che gli sviluppatori aggiornino tempestivamente il proprio codice di conseguenza.
4.1.2 Flusso di lavoro Git ESP-IDF
Espressif segue un flusso di lavoro Git specifico per ESP-IDF, delineato come segue:
· Vengono apportate nuove modifiche al ramo master, che funge da ramo di sviluppo principale. La versione ESP-IDF sul ramo master porta sempre un -dev tag per indicare che è attualmente in fase di sviluppo, come v4.3-dev. Le modifiche sul ramo principale verranno prima reimpostateviewelaborato e testato nel repository interno di Espressif, quindi inviato a GitHub al termine del test automatizzato.
· Una volta che una nuova versione ha completato lo sviluppo delle funzionalità sul ramo principale e ha soddisfatto i criteri per accedere al beta testing, passa a un nuovo ramo, come la release/v4.3. Inoltre, questa nuova filiale è tagconcepito come una versione pre-release, come v4.3-beta1. Gli sviluppatori possono fare riferimento alla piattaforma GitHub per accedere all'elenco completo dei rami e tags per ESP-IDF. È importante notare che la versione beta (versione pre-release) potrebbe presentare ancora un numero significativo di problemi noti. Poiché la versione beta è sottoposta a test continui, le correzioni dei bug vengono aggiunte contemporaneamente sia a questa versione che al ramo principale. Nel frattempo, il ramo principale potrebbe aver già iniziato a sviluppare nuove funzionalità per la prossima versione. Quando il test è quasi completo, al ramo viene aggiunta un'etichetta release candidate (rc), che indica che si tratta di un potenziale candidato per il rilascio ufficiale, come v4.3-rc1. A questo puntotage, il ramo rimane una versione pre-release.
· Se non vengono scoperti o segnalati bug importanti, la versione pre-release riceve eventualmente un'etichetta di versione maggiore (ad esempio, v5.0) o un'etichetta di versione minore (ad esempio, v4.3) e diventa una versione di rilascio ufficiale, che è documentata nella pagina delle note sulla versione. Successivamente, eventuali bug identificati in questa versione vengono corretti nel ramo di rilascio. Una volta completato il test manuale, al ramo viene assegnata un'etichetta di versione di correzione dei bug (ad esempio, v4.3.2), che si riflette anche nella pagina delle note di rilascio.
Capitolo 4. Impostazione dell'ambiente di sviluppo 33

4.1.3 Scelta di una versione adatta
Poiché ESP-IDF ha iniziato ufficialmente a supportare ESP32-C3 dalla versione v4.3 e la v4.4 non è stata ancora rilasciata ufficialmente al momento della stesura di questo libro, la versione utilizzata in questo libro è la v4.3.2, che è una versione rivista della v4.3. Tuttavia, è importante notare che nel momento in cui leggerai questo libro, potrebbe essere già disponibile la versione 4.4 o successiva. Quando si seleziona una versione, si consiglia quanto segue:
· Per gli sviluppatori entry-level, è consigliabile scegliere la versione stabile v4.3 o la sua versione rivista, che si allinea con l'exampla versione utilizzata in questo libro.
· Per scopi di produzione di massa, si consiglia di utilizzare l'ultima versione stabile per beneficiare del supporto tecnico più aggiornato.
· Se intendi sperimentare nuovi chip o esplorare nuove funzionalità del prodotto, utilizza il ramo principale. L'ultima versione contiene tutte le funzionalità più recenti, ma tieni presente che potrebbero essere presenti bug noti o sconosciuti.
· Se la versione stabile utilizzata non include le nuove funzionalità desiderate e desideri ridurre al minimo i rischi associati al ramo master, considera l'utilizzo del ramo di rilascio corrispondente, come il ramo release/v4.4. Il repository GitHub di Espressif creerà prima il ramo release/v4.4 e successivamente rilascerà la versione stabile v4.4 sulla base di un'istantanea storica specifica di questo ramo, dopo aver completato tutto lo sviluppo e il test delle funzionalità.
4.1.4 Oltreview della directory dell'SDK ESP-IDF
L'SDK ESP-IDF è costituito da due directory principali: esp-idf e .espressif. Il primo contiene il codice sorgente del repository ESP-IDF filese script di compilazione, mentre quest'ultimo memorizza principalmente catene di strumenti di compilazione e altro software. La familiarità con queste due directory aiuterà gli sviluppatori a utilizzare meglio le risorse disponibili e ad accelerare il processo di sviluppo. La struttura delle directory di ESP-IDF è descritta di seguito:
(1) Directory del codice del repository ESP-IDF (/esp/esp-idf), come mostrato nella Figura 4.2.
UN. Componenti della directory dei componenti
Questa directory principale integra numerosi componenti software essenziali di ESP-IDF. Nessun codice di progetto può essere compilato senza fare affidamento sui componenti all'interno di questa directory. Include il supporto dei driver per vari chip Espressif. Dalla libreria LL e dalle interfacce della libreria HAL per le periferiche al driver e virtuale di livello superiore File Supporto del livello di sistema (VFS), gli sviluppatori possono scegliere i componenti appropriati a diversi livelli per le loro esigenze di sviluppo. ESP-IDF supporta anche più stack di protocolli di rete standard come TCP/IP, HTTP, MQTT, WebSocket, ecc. Gli sviluppatori possono utilizzare interfacce familiari come Socket per creare applicazioni di rete. I componenti forniscono
34 Avventura wireless ESP32-C3: una guida completa all'IoT

Figura 4.2. Directory dei codici del repository ESP-IDF
funzionalità sive e possono essere facilmente integrati nelle applicazioni, consentendo agli sviluppatori di concentrarsi esclusivamente sulla logica aziendale. Alcuni componenti comuni includono: · driver: questo componente contiene programmi driver periferici per vari Espressif
serie di chip, come GPIO, I2C, SPI, UART, LEDC (PWM), ecc. I programmi di driver periferici in questo componente offrono interfacce astratte indipendenti dal chip. Ogni periferica ha un'intestazione comune file (come gpio.h), eliminando la necessità di gestire diverse domande di supporto specifiche del chip. · esp_wifi: il Wi-Fi, in quanto periferica speciale, viene trattato come un componente separato. Include più API come l'inizializzazione di varie modalità del driver Wi-Fi, la configurazione dei parametri e l'elaborazione degli eventi. Alcune funzioni di questo componente vengono fornite sotto forma di librerie di collegamento statiche. ESP-IDF fornisce inoltre una documentazione completa del conducente per facilità d'uso.
Capitolo 4. Impostazione dell'ambiente di sviluppo 35

· freertos: questo componente contiene il codice FreeRTOS completo. Oltre a fornire un supporto completo per questo sistema operativo, Espressif ha esteso il suo supporto anche ai chip dual-core. Per i chip dual-core come ESP32 ed ESP32-S3, gli utenti possono creare attività su core specifici.
B. Documenti della directory dei documenti
Questa directory contiene i documenti di sviluppo relativi a ESP-IDF, tra cui la Guida introduttiva, il Manuale di riferimento API, la Guida allo sviluppo, ecc.
NOTA Dopo essere stati compilati da strumenti automatizzati, i contenuti di questa directory vengono distribuiti su https://docs.espressif.com/projects/esp-idf. Assicurati di cambiare la destinazione del documento su ESP32-C3 e selezionare la versione ESP-IDF specificata.
C. Strumenti dello strumento di script
Questa directory contiene strumenti front-end di compilazione comunemente usati come idf.py e lo strumento terminale di monitoraggio idf_monitor.py, ecc. La sottodirectory cmake contiene anche lo script principale files del sistema di compilazione, che funge da base per l'implementazione delle regole di compilazione ESP-IDF. Quando si aggiungono le variabili d'ambiente, i contenuti all'interno della directory tools vengono aggiunti alla variabile d'ambiente di sistema, consentendo l'esecuzione di idf.py direttamente nel percorso del progetto.
D. Example directory del programma esamples
Questa directory comprende una vasta raccolta di ESP-IDF exampprogrammi le che dimostrano l'utilizzo delle API dei componenti. L'exampi le sono organizzati in varie sottodirectory in base alle loro categorie:
· get-started: questa sottodirectory include entry-level example come "ciao mondo" e "lampeggia" per aiutare gli utenti a cogliere le nozioni di base.
· Bluetooth: è possibile trovare informazioni relative al Bluetooth, ad esample qui, inclusi Bluetooth LE Mesh, Bluetooth LE HID, BluFi e altro ancora.
· wifi: questa sottodirectory si concentra su Wi-Fi example, inclusi programmi di base come Wi-Fi SoftAP, Wi-Fi Station, espnow, nonché il protocollo di comunicazione proprietario examples da Espressif. Include anche più livelli di applicazione, ad esample basati su Wi-Fi, come Iperf, Sniffer e Smart Config.
· periferiche: questa vasta sottodirectory è ulteriormente suddivisa in numerose sottocartelle in base ai nomi delle periferiche. Contiene principalmente driver periferici examples per i chip Espressif, con ogni example con diversi sub-examples. Ad esempio, la sottodirectory gpio include due example: tastiera GPIO e matrice GPIO. È importante notare che non tutti gli exampi le in questa directory sono applicabili a ESP32-C3.
36 Avventura wireless ESP32-C3: una guida completa all'IoT

Per esempioample, l'esampi le in usb/host sono applicabili solo alle periferiche con hardware host USB (come ESP32-S3) e ESP32-C3 non dispone di questa periferica. Il sistema di compilazione in genere fornisce suggerimenti durante l'impostazione della destinazione. Il README file di ogni example elenca i chip supportati. · protocolli: questa sottodirectory contiene example per vari protocolli di comunicazione, inclusi MQTT, HTTP, HTTP Server, PPPoS, Modbus, mDNS, SNTP, che coprono un'ampia gamma di protocolli di comunicazione, ad es.ample necessari per lo sviluppo IoT. · provisioning: qui troverai il provisioning, ad esample per metodi diversi, come il provisioning Wi-Fi e il provisioning Bluetooth LE. · system: questa sottodirectory include il debug del sistema, ad esample (ad es. stack tracing, runtime tracing, monitoraggio delle attività), gestione dell'alimentazione esample (ad esempio, varie modalità di sospensione, coprocessori) ed esample relativi a componenti di sistema comuni come terminale della console, loop di eventi e timer di sistema. · storage: all'interno di questa sottodirectory scoprirai examples di tutti file sistemi e meccanismi di archiviazione supportati da ESP-IDF (come lettura e scrittura di Flash, scheda SD e altri supporti di archiviazione), nonché example di archiviazione non volatile (NVS), FatFS, SPIFFS e altri file operazioni di sistema. · sicurezza: questa sottodirectory contiene example relativi alla crittografia flash. (2) Directory della catena degli strumenti di compilazione ESP-IDF (/.espressif), come mostrato nella Figura 4.3.
Figura 4.3. Directory della catena degli strumenti di compilazione ESP-IDF
Capitolo 4. Impostazione dell'ambiente di sviluppo 37

UN. Directory di distribuzione del software dist
La catena di strumenti ESP-IDF e altri software sono distribuiti sotto forma di pacchetti compressi. Durante il processo di installazione, lo strumento di installazione scarica prima il pacchetto compresso nella directory dist, quindi lo estrae nella directory specificata. Una volta completata l'installazione, il contenuto di questa directory può essere rimosso in modo sicuro.
B. Directory dell'ambiente virtuale Python python env
Diverse versioni di ESP-IDF si basano su versioni specifiche di pacchetti Python. L'installazione di questi pacchetti direttamente sullo stesso host può portare a conflitti tra le versioni dei pacchetti. Per risolvere questo problema, ESP-IDF utilizza ambienti virtuali Python per isolare diverse versioni del pacchetto. Con questo meccanismo, gli sviluppatori possono installare più versioni di ESP-IDF sullo stesso host e passare facilmente dall'una all'altra importando diverse variabili di ambiente.
C. Strumenti di directory della catena di strumenti di compilazione ESP-IDF
Questa directory contiene principalmente strumenti di compilazione incrociata necessari per compilare progetti ESP-IDF, come strumenti CMake, strumenti di compilazione Ninja e la catena di strumenti gcc che genera il programma eseguibile finale. Inoltre questa directory ospita la libreria standard del linguaggio C/C++ insieme all'intestazione corrispondente fileS. Se un programma fa riferimento a un'intestazione di sistema file come #include , la catena degli strumenti di compilazione individuerà stdio.h file all'interno di questa directory.
4.2 Impostazione dell'ambiente di sviluppo ESP-IDF
L'ambiente di sviluppo ESP-IDF supporta i sistemi operativi tradizionali come Windows, Linux e macOS. Questa sezione introdurrà come impostare l'ambiente di sviluppo su ciascun sistema. Si consiglia di sviluppare ESP32-C3 sul sistema Linux, che verrà introdotto in dettaglio qui. Molte istruzioni sono applicabili su tutte le piattaforme a causa della somiglianza degli strumenti di sviluppo. Si consiglia pertanto di leggere attentamente il contenuto di questa sezione.
NOTA È possibile fare riferimento ai documenti online disponibili all'indirizzo https://bookc3.espressif.com/esp32c3, che forniscono i comandi menzionati in questa sezione.
4.2.1 Configurazione dell'ambiente di sviluppo ESP-IDF su Linux
Gli strumenti di sviluppo e debug GNU richiesti per l'ambiente di sviluppo ESP-IDF sono nativi del sistema Linux. Inoltre, il terminale della riga di comando di Linux è potente e facile da usare, rendendolo la scelta ideale per lo sviluppo ESP32-C3. Puoi
38 Avventura wireless ESP32-C3: una guida completa all'IoT

seleziona la tua distribuzione Linux preferita, ma ti consigliamo di utilizzare Ubuntu o altri sistemi basati su Debian. Questa sezione fornisce indicazioni sulla configurazione dell'ambiente di sviluppo ESP-IDF su Ubuntu 20.04.
1. Installa i pacchetti richiesti
Apri un nuovo terminale ed esegui il comando seguente per installare tutti i pacchetti necessari. Il comando salterà automaticamente i pacchetti già installati.
$ 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
SUGGERIMENTI È necessario utilizzare l'account e la password dell'amministratore per il comando sopra. Per impostazione predefinita, nessuna informazione verrà visualizzata quando si immette la password. Basta premere il tasto “Invio” per continuare la procedura.
Git è uno strumento di gestione dei codici chiave in ESP-IDF. Dopo aver configurato correttamente l'ambiente di sviluppo, puoi utilizzare il comando git log to view tutte le modifiche al codice apportate dalla creazione di ESP-IDF. Inoltre, Git viene utilizzato anche in ESP-IDF per confermare le informazioni sulla versione, necessarie per installare la catena di strumenti corretta corrispondente a versioni specifiche. Insieme a Git, altri importanti strumenti di sistema includono Python. ESP-IDF incorpora numerosi script di automazione scritti in Python. Strumenti come CMake, Ninja-build e Ccache sono ampiamente utilizzati nei progetti C/C++ e fungono da strumenti predefiniti per la compilazione e la creazione di codice in ESP-IDF. libusb-1.0-0 e dfu-util sono i principali driver utilizzati per la comunicazione seriale USB e la masterizzazione del firmware. Una volta installati i pacchetti software, è possibile utilizzare apt show comando per ottenere descrizioni dettagliate di ciascun pacchetto. Per esample, utilizzare apt show git per stampare le informazioni descrittive per lo strumento Git.
D: Cosa fare se la versione Python non è supportata? R: ESP-IDF v4.3 richiede una versione Python non inferiore a v3.6. Per le versioni precedenti di Ubuntu, scarica e installa manualmente una versione successiva di Python e imposta Python3 come ambiente Python predefinito. Puoi trovare istruzioni dettagliate cercando la parola chiave update-alternatives python.
2. Scarica il codice del repository ESP-IDF
Apri un terminale e crea una cartella denominata esp nella tua directory home utilizzando il comando mkdir. Se preferisci, puoi scegliere un nome diverso per la cartella. Utilizzare il comando cd per accedere alla cartella.
Capitolo 4. Impostazione dell'ambiente di sviluppo 39

$ mkdir -p /esp $ cd /esp
Utilizza il comando git clone per scaricare il codice del repository ESP-IDF, come mostrato di seguito:
$ git clone -b v4.3.2 –recursive https://github.com/espressif/esp-idf.git
Nel comando precedente, il parametro -b v4.3.2 specifica la versione da scaricare (in questo caso, la versione 4.3.2). Il parametro –recursive garantisce che tutti i sottorepository di ESP-IDF vengano scaricati in modo ricorsivo. Le informazioni sui sottorepository possono essere trovate nel file .gitmodules file.
3. Installare la catena di strumenti di sviluppo ESP-IDF
Espressif fornisce uno script automatizzato install.sh per scaricare e installare la catena di strumenti. Questo script controlla la versione corrente di ESP-IDF e l'ambiente del sistema operativo, quindi scarica e installa la versione appropriata dei pacchetti di strumenti Python e delle catene di strumenti di compilazione. Il percorso di installazione predefinito per la catena di strumenti è /.espressif. Tutto quello che devi fare è accedere alla directory esp-idf ed eseguire install.sh.
$ cd /esp/esp-idf $ ./install.sh
Se installi correttamente la catena di strumenti, il terminale visualizzerà:
Fatto!
A questo punto, hai configurato con successo l'ambiente di sviluppo ESP-IDF.
4.2.2 Configurazione dell'ambiente di sviluppo ESP-IDF su Windows
1. Scarica il programma di installazione degli strumenti ESP-IDF
SUGGERIMENTI Si consiglia di configurare l'ambiente di sviluppo ESP-IDF su Windows 10 o versioni successive. È possibile scaricare il programma di installazione da https://dl.espressif.com/dl/esp-idf/. Anche il programma di installazione è un software open source e il suo codice sorgente può esserlo viewed su https: //github.com/espressif/idf-installer.
· Programma di installazione online degli strumenti ESP-IDF
Questo programma di installazione è relativamente piccolo, ha una dimensione di circa 4 MB e altri pacchetti e codici verranno scaricati durante il processo di installazione. L'avantitagLa peculiarità del programma di installazione online è che non solo è possibile scaricare pacchetti software e codice su richiesta durante il processo di installazione, ma consente anche l'installazione di tutte le versioni disponibili di ESP-IDF e dell'ultimo ramo del codice GitHub (come il ramo principale) . Lo svantaggiotage è che richiede una connessione di rete durante il processo di installazione, che potrebbe causare errori di installazione a causa di problemi di rete.
40 Avventura wireless ESP32-C3: una guida completa all'IoT

· Programma di installazione degli strumenti ESP-IDF offline Questo programma di installazione è più grande, circa 1 GB e contiene tutti i pacchetti software e il codice necessari per la configurazione dell'ambiente. Il vantaggio principaletagLa caratteristica principale del programma di installazione offline è che può essere utilizzato su computer senza accesso a Internet e generalmente ha una percentuale di successo dell'installazione più elevata. Va notato che il programma di installazione offline può installare solo versioni stabili di ESP-IDF identificate da v*.* o v*.*.*.
2. Eseguire il programma di installazione degli strumenti ESP-IDF Dopo aver scaricato una versione adatta del programma di installazione (utilizzare ESP-IDF Tools Offline 4.3.2 ad es.ample qui), fare doppio clic sul file exe file per avviare l'interfaccia di installazione ESP-IDF. Di seguito viene illustrato come installare ESP-IDF versione stabile v4.3.2 utilizzando il programma di installazione offline.
(1) Nell'interfaccia "Seleziona lingua di installazione" mostrata nella Figura 4.4, selezionare la lingua da utilizzare dall'elenco a discesa.
Figura 4.4. Interfaccia "Seleziona lingua di installazione" (2) Dopo aver selezionato la lingua, fare clic su "OK" per visualizzare l'interfaccia "Contratto di licenza"
(vedere Figura 4.5). Dopo aver letto attentamente il contratto di licenza di installazione, selezionare “Accetto il contratto” e fare clic su “Avanti”.
Figura 4.5. Interfaccia “Contratto di licenza” Capitolo 4. Configurazione dell'ambiente di sviluppo 41

(3) Rifview la configurazione del sistema nell'interfaccia “Verifica del sistema pre-installazione” (vedere Figura 4.6). Controlla la versione di Windows e le informazioni sul software antivirus installato. Fare clic su "Avanti" se tutti gli elementi di configurazione sono normali. Altrimenti, puoi fare clic su "Registro completo" per soluzioni basate su elementi chiave.
Figura 4.6. SUGGERIMENTI per l'interfaccia “Controllo del sistema prima dell'installazione”.
Puoi inviare i log a https://github.com/espressif/idf-installer/issues per ricevere assistenza. (4) Selezionare la directory di installazione ESP-IDF. Qui, seleziona D:/.espressif, come mostrato in
Figura 4.7 e fare clic su "Avanti". Tieni presente che .espressif qui è una directory nascosta. Una volta completata l'installazione, puoi farlo view il contenuto specifico di questa directory aprendo il file file manager e visualizzare gli elementi nascosti.
Figura 4.7. Seleziona la directory di installazione ESP-IDF 42 ESP32-C3 Wireless Adventure: una guida completa all'IoT

(5) Controllare i componenti che devono essere installati, come mostrato nella Figura 4.8. Si consiglia di utilizzare l'opzione predefinita, ovvero completare l'installazione, quindi fare clic su "Avanti".
Figura 4.8. Selezionare i componenti da installare (6) Confermare i componenti da installare e fare clic su “Installa” per avviare l'installazione automatizzata
processo di stallo, come mostrato nella Figura 4.9. Il processo di installazione può durare decine di minuti e la barra di avanzamento del processo di installazione è mostrata nella Figura 4.10. Per favore aspetta pazientemente.
Figura 4.9. Preparazione per l'installazione (7) Al termine dell'installazione, si consiglia di selezionare “Registra ESP-IDF
Strumenti eseguibili come esclusioni di Windows Defender…” per impedire l'eliminazione del software antivirus fileS. L'aggiunta di elementi di esclusione può anche saltare le scansioni frequenti da parte dell'antivirus
Capitolo 4. Impostazione dell'ambiente di sviluppo 43

Figura 4.10. Software della barra di avanzamento dell'installazione, che migliora notevolmente l'efficienza di compilazione del codice del sistema Windows. Fare clic su "Fine" per completare l'installazione dell'ambiente di sviluppo, come mostrato nella Figura 4.11. Puoi scegliere di selezionare "Esegui ambiente PowerShell ESP-IDF" o "Esegui prompt dei comandi ESP-IDF". Eseguire la finestra di compilazione subito dopo l'installazione per garantire che l'ambiente di sviluppo funzioni normalmente.
Figura 4.11. Installazione completata (8) Aprire l'ambiente di sviluppo installato nell'elenco dei programmi (o ESP-IDF 4.3
CMD o ESP-IDF 4.3 PowerShell, come mostrato nella Figura 4.12) e la variabile di ambiente ESP-IDF verrà aggiunta automaticamente durante l'esecuzione nel terminale. Successivamente, puoi utilizzare il comando idf.py per le operazioni. Il CMD ESP-IDF 4.3 aperto è mostrato nella Figura 4.13. 44 Avventura wireless ESP32-C3: una guida completa all'IoT

Figura 4.12. Ambiente di sviluppo installato
Figura 4.13. ESP-IDF 4.3 CMD
4.2.3 Configurazione dell'ambiente di sviluppo ESP-IDF su Mac
Il processo di installazione dell'ambiente di sviluppo ESP-IDF su un sistema Mac è lo stesso di un sistema Linux. I comandi per scaricare il codice del repository e installare la catena di strumenti sono esattamente gli stessi. Solo i comandi per l'installazione dei pacchetti di dipendenze sono leggermente diversi. 1. Installa i pacchetti di dipendenze Apri un terminale e installa pip, lo strumento di gestione dei pacchetti Python, eseguendo il seguente comando:
% sudo installazione facile pip
Installa Homebrew, uno strumento di gestione dei pacchetti per macOS, eseguendo il seguente comando:
% /bin/bash -c “$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)”
Installa i pacchetti di dipendenze richiesti eseguendo il comando seguente:
% brew python3 installa cmake ninja ccache dfu-util
2. Scaricare il codice del repository ESP-IDF Seguire le istruzioni fornite nella sezione 4.2.1 per scaricare il codice del repository ESP-IDF. I passaggi sono gli stessi del download su un sistema Linux.
Capitolo 4. Impostazione dell'ambiente di sviluppo 45

3. Installare la catena di strumenti di sviluppo ESP-IDF
Seguire le istruzioni fornite nella sezione 4.2.1 per installare la catena di strumenti di sviluppo ESP-IDF. I passaggi sono gli stessi dell'installazione su un sistema Linux.
4.2.4 Installazione di VS Code
Per impostazione predefinita, l'SDK ESP-IDF non include uno strumento di modifica del codice (sebbene l'ultimo programma di installazione ESP-IDF per Windows offra la possibilità di installare ESP-IDF Eclipse). Puoi utilizzare qualsiasi strumento di modifica del testo di tua scelta per modificare il codice e quindi compilarlo utilizzando i comandi del terminale.
Uno strumento di modifica del codice popolare è VS Code (Visual Studio Code), un editor di codice gratuito e ricco di funzionalità con un'interfaccia intuitiva. Offre vari plugins che forniscono funzionalità come la navigazione del codice, l'evidenziazione della sintassi, il controllo della versione Git e l'integrazione del terminale. Inoltre, Espressif ha sviluppato un plugin dedicato chiamato Espressif IDF per VS Code, che semplifica la configurazione e il debug del progetto.
È possibile utilizzare il comando code nel terminale per aprire rapidamente la cartella corrente in VS Code. In alternativa, puoi utilizzare la scorciatoia Ctrl+ per aprire la console terminale predefinita del sistema in VS Code.
SUGGERIMENTI Si consiglia di utilizzare VS Code per lo sviluppo del codice ESP32-C3. Scarica e installa l'ultima versione di VS Code su https://code.visualstudio.com/.
4.2.5 Introduzione agli ambienti di sviluppo di terze parti
Oltre all'ambiente di sviluppo ufficiale ESP-IDF, che utilizza principalmente il linguaggio C, ESP32-C3 supporta anche altri linguaggi di programmazione tradizionali e un'ampia gamma di ambienti di sviluppo di terze parti. Alcune opzioni degne di nota includono:
Arduino: una piattaforma open source sia per hardware che per software, che supporta vari microcontrollori, incluso ESP32-C3.
Utilizza il linguaggio C++ e offre un'API semplificata e standardizzata, comunemente denominata linguaggio Arduino. Arduino è ampiamente utilizzato nello sviluppo di prototipi e in contesti educativi. Fornisce un pacchetto software estensibile e un IDE che consente una facile compilazione e flashing.
MicroPython: un interprete del linguaggio Python 3 progettato per funzionare su piattaforme di microcontrollori embedded.
Con un semplice linguaggio di script, può accedere direttamente alle risorse periferiche di ESP32-C3 (come UART, SPI e I2C) e alle funzioni di comunicazione (come Wi-Fi e Bluetooth LE).
46 Avventura wireless ESP32-C3: una guida completa all'IoT

Ciò semplifica l'interazione hardware. MicroPython, combinato con l'ampia libreria di operazioni matematiche di Python, consente l'implementazione di algoritmi complessi su ESP32-C3, facilitando lo sviluppo di applicazioni relative all'intelligenza artificiale. Essendo un linguaggio di script, non è necessaria una compilazione ripetuta; è possibile apportare modifiche e eseguire direttamente gli script.
NodeMCU: un interprete del linguaggio LUA sviluppato per i chip della serie ESP.
Supporta quasi tutte le funzioni periferiche dei chip ESP ed è più leggero di MicroPython. Similmente a MicroPython, NodeMCU utilizza un linguaggio di script, eliminando la necessità di compilazioni ripetute.
Inoltre, ESP32-C3 supporta anche i sistemi operativi NuttX e Zephyr. NuttX è un sistema operativo in tempo reale che fornisce interfacce compatibili con POSIX, migliorando la portabilità delle applicazioni. Zephyr è un piccolo sistema operativo in tempo reale progettato specificamente per le applicazioni IoT. Include numerose librerie software necessarie nello sviluppo IoT, evolvendosi gradualmente in un ecosistema software completo.
Questo libro non fornisce istruzioni dettagliate sull'installazione per gli ambienti di sviluppo sopra menzionati. È possibile installare un ambiente di sviluppo in base alle proprie esigenze seguendo la rispettiva documentazione e istruzioni.
4.3 Sistema di compilazione ESP-IDF
4.3.1 Concetti base del sistema di compilazione
Un progetto ESP-IDF è una raccolta di un programma principale con una funzione di ingresso e molteplici componenti funzionali indipendenti. Per esample, un progetto che controlla gli interruttori LED è costituito principalmente da un programma di ingresso principale e da un componente driver che controlla GPIO. Se vuoi realizzare il telecomando LED, devi anche aggiungere Wi-Fi, stack di protocolli TCP/IP, ecc.
Il sistema di compilazione può compilare, collegare e generare eseguibili files (.bin) per il codice attraverso una serie di regole di costruzione. Il sistema di compilazione di ESP-IDF v4.0 e versioni successive è basato su CMake per impostazione predefinita e lo script di compilazione CMakeLists.txt può essere utilizzato per controllare il comportamento di compilazione del codice. Oltre a supportare la sintassi di base di CMake, il sistema di compilazione ESP-IDF definisce anche un insieme di regole di compilazione predefinite e funzioni CMake ed è possibile scrivere lo script di compilazione con semplici istruzioni.
4.3.2 Progetto File Struttura
Un progetto è una cartella che contiene una voce del programma principale, componenti definiti dall'utente e fileÈ necessario per creare applicazioni eseguibili, come script di compilazione, configurazione
Capitolo 4. Impostazione dell'ambiente di sviluppo 47

files, tabelle delle partizioni, ecc. I progetti possono essere copiati e passati e lo stesso eseguibile file può essere compilato e generato su macchine con la stessa versione dell'ambiente di sviluppo ESP-IDF. Un tipico progetto ESP-IDF file la struttura è mostrata nella Figura 4.14.
Figura 4.14. Tipico progetto ESP-IDF file struttura Poiché ESP-IDF supporta più chip IoT di Espressif, inclusi ESP32, serie ESP32-S, serie ESP32-C, serie ESP32-H, ecc., è necessario determinare un obiettivo prima di compilare il codice. Il target è sia il dispositivo hardware che esegue il programma applicativo sia il target di compilazione del sistema di compilazione. A seconda delle tue esigenze, puoi specificare uno o più target per il tuo progetto. Per esample, tramite il comando idf.py set-target esp32c3, è possibile impostare la destinazione della compilazione su ESP32-C3, durante la quale verranno caricati i parametri predefiniti e il percorso della catena degli strumenti di compilazione per ESP32C3. Dopo la compilazione, è possibile generare un programma eseguibile per ESP32C3. Puoi anche eseguire nuovamente il comando set-target per impostare una destinazione diversa e il sistema di compilazione pulirà e riconfigurerà automaticamente. Componenti
I componenti in ESP-IDF sono unità di codice modulari e indipendenti gestite all'interno del sistema di compilazione. Sono organizzati come cartelle, con il nome della cartella che rappresenta il nome del componente per impostazione predefinita. Ogni componente ha il proprio script di compilazione che 48 ESP32-C3 Wireless Adventure: A Comprehensive Guide to IoT

specifica i parametri di compilazione e le dipendenze. Durante il processo di compilazione, i componenti vengono compilati in librerie statiche separate (.a files) ed eventualmente combinato con altri componenti per formare il programma applicativo.
ESP-IDF fornisce funzioni essenziali, come il sistema operativo, i driver delle periferiche e lo stack di protocolli di rete, sotto forma di componenti. Questi componenti sono archiviati nella directory dei componenti situata all'interno della directory principale ESP-IDF. Gli sviluppatori non hanno bisogno di copiare questi componenti nella directory dei componenti di myProject. Devono invece solo specificare le relazioni di dipendenza di questi componenti nel file CMakeLists.txt del progetto file utilizzando le direttive REQUIRES o PRIV_REQUIRES. Il sistema di compilazione individuerà e compilerà automaticamente i componenti richiesti.
Pertanto la directory dei componenti in myProject non è necessaria. Viene utilizzato solo per includere alcuni componenti personalizzati del progetto, che possono essere librerie di terze parti o codice definito dall'utente. Inoltre, i componenti possono provenire da qualsiasi directory diversa da ESP-IDF o dal progetto corrente, ad esempio da un progetto open source salvato in un'altra directory. In questo caso, devi solo aggiungere il percorso del componente impostando la variabile EXTRA_COMPONENT_DIRS nel CMakeLists.txt nella directory root. Questa directory sovrascriverà qualsiasi componente ESP-IDF con lo stesso nome, garantendo che venga utilizzato il componente corretto.
Programma di ingresso main La directory principale all'interno del progetto segue la stessa cosa file struttura come altri componenti (ad esempio, componente1). Tuttavia, ha un significato speciale in quanto è una componente obbligatoria che deve esistere in ogni progetto. La directory principale contiene il codice sorgente del progetto e il punto di ingresso del programma utente, in genere denominato app_main. Per impostazione predefinita, l'esecuzione del programma utente inizia da questo punto di ingresso. Il componente principale differisce anche in quanto dipende automaticamente da tutti i componenti all'interno del percorso di ricerca. Pertanto, non è necessario indicare esplicitamente le dipendenze utilizzando le direttive REQUIRES o PRIV_REQUIRES nel CMakeLists.txt file.
Configurazione file La directory root del progetto contiene una configurazione file chiamato sdkconfig, che contiene i parametri di configurazione per tutti i componenti all'interno del progetto. Il file sdkconfig file viene generato automaticamente dal sistema di compilazione e può essere modificato e rigenerato tramite il comando idf.py menuconfig. Le opzioni menuconfig provengono principalmente dal Kconfig.projbuild del progetto e dal Kconfig dei componenti. Gli sviluppatori di componenti generalmente aggiungono elementi di configurazione in Kconfig per rendere il componente flessibile e configurabile.
Directory di build Per impostazione predefinita, la directory di build all'interno del progetto memorizza i file intermedi files e il fi-
Capitolo 4. Impostazione dell'ambiente di sviluppo 49

programmi eseguibili finali generati dal comando build idf.py. In generale non è necessario accedere direttamente al contenuto della directory build. ESP-IDF fornisce comandi predefiniti per interagire con la directory, come l'utilizzo del comando flash idf.py per individuare automaticamente il file binario compilato file e eseguirne il flashing all'indirizzo flash specificato oppure utilizzare il comando idf.py fullclean per pulire l'intera directory di build.
Tabella delle partizioni (partitions.csv) Ogni progetto richiede una tabella delle partizioni per dividere lo spazio della flash e specificare la dimensione e l'indirizzo iniziale del programma eseguibile e lo spazio dei dati utente. Il comando idf.py flash o il programma di aggiornamento OTA eseguiranno il flashing del firmware all'indirizzo corrispondente in base a questa tabella. ESP-IDF fornisce diverse tabelle delle partizioni predefinite in Components/ Partition_table, come Partitions_singleapp.csv e Partitions_two_ ota.csv, che possono essere selezionate in menuconfig.
Se la tabella delle partizioni predefinita del sistema non può soddisfare i requisiti del progetto, è possibile aggiungere un partizioni.csv personalizzato alla directory del progetto ed essere selezionato in menuconfig.
4.3.3 Regole di creazione predefinite del sistema di compilazione
Regole per sovrascrivere componenti con lo stesso nome Durante il processo di ricerca dei componenti, il sistema di compilazione segue un ordine specifico. Innanzitutto cerca i componenti interni di ESP-IDF, quindi cerca i componenti del progetto utente e infine cerca i componenti in EXTRA_COMPONENT_DIRS. Nei casi in cui più directory contengono componenti con lo stesso nome, il componente trovato nell'ultima directory sovrascriverà eventuali componenti precedenti con lo stesso nome. Questa regola consente la personalizzazione dei componenti ESP-IDF all'interno del progetto utente, mantenendo intatto il codice ESP-IDF originale.
Regole per includere componenti comuni per impostazione predefinita Come menzionato nella sezione 4.3.2, i componenti devono specificare esplicitamente le loro dipendenze da altri componenti nel CMakeLists.txt. Tuttavia, i componenti comuni come freertos vengono automaticamente inclusi nel sistema di compilazione per impostazione predefinita, anche se le loro relazioni di dipendenza non sono definite esplicitamente nello script di compilazione. I componenti comuni di ESP-IDF includono freertos, Newlib, heap, log, soc, esp_rom, esp_common, xtensa/riscv e cxx. L'uso di questi componenti comuni evita il lavoro ripetitivo durante la scrittura di CMakeLists.txt e lo rende più conciso.
Regole per la sostituzione degli elementi di configurazione Gli sviluppatori possono aggiungere parametri di configurazione predefiniti aggiungendo una configurazione predefinita file denominato sdkconfig.defaults al progetto. Per esample, aggiungendo CONFIG_LOG_
50 Avventura wireless ESP32-C3: una guida completa all'IoT

DEFAULT_LEVEL_NONE = è possibile configurare l'interfaccia UART per non stampare i dati di registro per impostazione predefinita. Inoltre, se è necessario impostare parametri specifici per un target particolare, una configurazione file È possibile aggiungere il nome sdkconfig.defaults.TARGET_NAME, dove TARGET_NAME può essere esp32s2, esp32c3 e così via. Queste configurazioni fileI messaggi vengono importati in sdkconfig durante la compilazione, con la configurazione generale predefinita file sdkconfig.defaults verrà importato per primo, seguito dalla configurazione specifica della destinazione file, come sdkconfig.defaults.esp32c3. Nei casi in cui siano presenti elementi di configurazione con lo stesso nome, quest'ultima configurazione file sovrascriverà il primo.
4.3.4 Introduzione allo script di compilazione
Quando sviluppano un progetto utilizzando ESP-IDF, gli sviluppatori non devono solo scrivere il codice sorgente, ma devono anche scrivere CMakeLists.txt per il progetto e i componenti. CMakeLists.txt è un testo file, noto anche come script di compilazione, che definisce una serie di oggetti di compilazione, elementi di configurazione della compilazione e comandi per guidare il processo di compilazione del codice sorgente. Il sistema di compilazione di ESP-IDF v4.3.2 è basato su CMake. Oltre a supportare funzioni e comandi nativi di CMake, definisce anche una serie di funzioni personalizzate, rendendo molto più semplice la scrittura di script di compilazione.
Gli script di compilazione in ESP-IDF includono principalmente lo script di compilazione del progetto e gli script di compilazione dei componenti. Il file CMakeLists.txt nella directory root del progetto è chiamato script di compilazione del progetto, che guida il processo di compilazione dell'intero progetto. Uno script di compilazione di un progetto di base include in genere le seguenti tre righe:
1. cmake_minimum_required(VERSIONE 3.5) 2. include($ENV{IDF_PATH}/tools/cmake/project.cmake) 3. project(mioProgetto)
Tra questi, sulla prima riga va posizionato cmake_minimum_required (VERSION 3.5), che serve per indicare il numero minimo di versione CMake richiesta dal progetto. Le versioni più recenti di CMake sono generalmente retrocompatibili con le versioni precedenti, quindi modifica di conseguenza il numero di versione quando usi i comandi CMake più recenti per garantire la compatibilità.
include($ENV {IDF_PATH}/tools/cmake/project.cmake) importa elementi di configurazione e comandi predefiniti del sistema di compilazione ESP-IDF, incluse le regole di compilazione predefinite del sistema di compilazione descritte nella Sezione 4.3.3. project(myProject) crea il progetto stesso e ne specifica il nome. Questo nome verrà utilizzato come file binario di output finale file nome, ovvero mioProgetto.elf e mioProgetto.bin.
Un progetto può avere più componenti, incluso il componente principale. La directory di livello superiore di ciascun componente contiene un CMakeLists.txt file, chiamato script di compilazione del componente. Gli script di compilazione dei componenti vengono utilizzati principalmente per specificare le dipendenze dei componenti, i parametri di configurazione, il codice sorgente files e intestazione inclusa fileper
Capitolo 4. Impostazione dell'ambiente di sviluppo 51

compilazione. Con la funzione personalizzata idf_component_register di ESP-IDF, il codice minimo richiesto per uno script di compilazione del componente è il seguente:

1. idf_component_register(SRCS “src1.c”

INCLUDE_DIRS “includi”

RICHIEDE componente1)

Il parametro SRCS fornisce un elenco di fonti files nel componente, separati da spazi se ce ne sono più fileS. Il parametro INCLUDE_DIRS fornisce un elenco di intestazioni pubbliche file directory per il componente, che verranno aggiunte al percorso di ricerca di inclusione per altri componenti che dipendono dal componente corrente. Il parametro REQUIRES identifica le dipendenze del componente pubblico per il componente corrente. È necessario che i componenti indichino esplicitamente da quali componenti dipendono, ad esempio componente2 che dipende da componente1. Tuttavia, per il componente principale, che per impostazione predefinita dipende da tutti i componenti, il parametro REQUIRES può essere omesso.

Inoltre, nello script di compilazione è possibile utilizzare anche i comandi nativi di CMake. Per esample, utilizzare il comando set per impostare variabili, come set(VARIABLE “VALUE”).

4.3.5 Introduzione ai comandi comuni
ESP-IDF utilizza CMake (strumento di configurazione del progetto), Ninja (strumento di creazione del progetto) ed esptool (strumento flash) nel processo di compilazione del codice. Ciascuno strumento svolge un ruolo diverso nel processo di compilazione, creazione e flash e supporta anche diversi comandi operativi. Per facilitare il funzionamento dell'utente, ESP-IDF aggiunge un idf.py front-end unificato che consente di richiamare rapidamente i comandi di cui sopra.
Prima di utilizzare idf.py, assicurati che:
· La variabile d'ambiente IDF_PATH di ESP-IDF è stata aggiunta al terminale corrente. · La directory di esecuzione del comando è la directory root del progetto, che include il file
script di compilazione del progetto CMakeLists.txt.
I comandi comuni di idf.py sono i seguenti:
· idf.py –help: mostra un elenco di comandi e le relative istruzioni per l'uso. · idf.py imposta-obiettivo : impostando la compilazione taidf.py fullcleanrget, tale
come sostitutivo con esp32c3. · idf.py menuconfig: avvio di menuconfig, una configurazione grafica del terminale
strumento, che può selezionare o modificare le opzioni di configurazione e i risultati della configurazione vengono salvati nel file sdkconfig file. · idf.py build: avvio della compilazione del codice. L'intermedio files e il programma eseguibile finale generato dalla compilazione verrà salvato nella directory build del progetto per impostazione predefinita. Il processo di compilazione è incrementale, il che significa che è presente una sola fonte file viene modificato, solo il modificato file verrà compilato la prossima volta.

52 Avventura wireless ESP32-C3: una guida completa all'IoT

· idf.py clean: pulizia dell'intermedio files generato dalla compilazione del progetto. L'intero progetto sarà costretto a compilare nella prossima compilazione. Tieni presente che la configurazione di CMake e le modifiche alla configurazione apportate da menuconfig non verranno eliminate durante la pulizia.
· idf.py fullclean: eliminazione dell'intera directory di build, incluso tutto l'output di configurazione di CMake fileS. Quando si compila nuovamente il progetto, CMake configurerà il progetto da zero. Tieni presente che questo comando eliminerà tutti in modo ricorsivo files nella directory build, quindi usalo con cautela e la configurazione del progetto file non verrà cancellato.
· idf.py flash: lampeggia il binario del programma eseguibile file generato dalla build sul target ESP32-C3. Le opzioni -p e B vengono utilizzati per impostare rispettivamente il nome del dispositivo della porta seriale e la velocità di trasmissione per il flashing. Se queste due opzioni non vengono specificate, la porta seriale verrà rilevata automaticamente e verrà utilizzata la velocità di trasmissione predefinita.
· Monitor idf.py: visualizza l'uscita della porta seriale del target ESP32-C3. L'opzione -p può essere utilizzata per specificare il nome del dispositivo della porta seriale lato host. Durante la stampa dalla porta seriale, premere la combinazione di tasti Ctrl+] per uscire dal monitor.
I comandi precedenti possono anche essere combinati secondo necessità. Per esample, il comando idf.py build flash monitor eseguirà la compilazione del codice, eseguirà il flashing e aprirà il monitor della porta seriale in sequenza.
Puoi visitare https://bookc3.espressif.com/build-system per saperne di più sul sistema di compilazione ESP-IDF.
4.4 Esercitazione: Compilazione dell'Esampil Programma “Blink”
4.4.1 Esample Analisi
Questa sezione prenderà come ex il programma Blinkample per analizzare il file struttura e regole di codifica di un progetto reale in dettaglio. Il programma Blink implementa l'effetto lampeggiante del LED e il progetto si trova nella directory examples/get-started/blink, che contiene un codice sorgente file, configurazione files e diversi script di compilazione.
Il progetto di luce intelligente presentato in questo libro si basa su questo esempioampil programma. Le funzioni verranno gradualmente aggiunte nei capitoli successivi per completarlo definitivamente.
Codice sorgente Per dimostrare l'intero processo di sviluppo, il programma Blink è stato copiato in esp32c3-iot-projects/device firmware/1 flick.
La struttura delle directory del progetto Blink files è mostrato nella Figura 4.15.
Il progetto Blink contiene solo una directory principale, che è un componente speciale che
Capitolo 4. Impostazione dell'ambiente di sviluppo 53

Figura 4.15. File struttura delle directory del progetto Blink

devono essere inclusi come descritto nella sezione 4.3.2. La directory principale viene utilizzata principalmente per memorizzare l'implementazione della funzione app_main(), che è il punto di ingresso al programma utente. Il progetto flick non include la directory dei componenti, poiché questa example deve utilizzare solo i componenti forniti con ESP-IDF e non richiede componenti aggiuntivi. Il CMakeLists.txt incluso nel progetto flick viene utilizzato per guidare il processo di compilazione, mentre Kconfig.projbuild viene utilizzato per aggiungere elementi di configurazione per questo example programma nel menuconfig. Altro inutile filenon influenzeranno la compilazione del codice, quindi non verranno discussi qui. Un'introduzione dettagliata al progetto flick files è il seguente.

1. /*blink.c include la seguente intestazione fileS*/

2. #includere

//Intestazione della libreria C standard file

3. #include “freertos/freeRTOS.h” //Intestazione principale di FreeRTOS file

4. #include “freertos/task.h”

//Intestazione dell'attività FreeRTOS file

5. #include "sdkconfig.h"

//Intestazione di configurazione file generato da kconfig

6. #include “driver/gpio.h”

//Intestazione del driver GPIO file

La fonte file flick.c contiene una serie di header files corrispondente alla dichiarazione di funzione

zioni. ESP-IDF generalmente segue l'ordine di inclusione dell'intestazione della libreria standard files, FreeR-

Intestazione TOS files, intestazione del driver files, intestazione dell'altro componente files e l'intestazione del progetto files.

L'ordine in cui header filesono inclusi potrebbero influenzare il risultato finale della compilazione, quindi prova a farlo

seguire le regole predefinite. Va notato che sdkconfig.h viene generato automaticamente

da kconfig e può essere configurato solo tramite il comando idf.py menuconfig.

Modifica diretta di questa intestazione file verrà sovrascritto.

1. /*Puoi selezionare il GPIO corrispondente al LED in idf.py menuconfig e il risultato della modifica di menuconfig è che il valore di CONFIG_BLINK

_GPIO verrà modificato. È inoltre possibile modificare direttamente la definizione della macro

qui e modifica CONFIG_BLINK_GPIO su un valore fisso.*/ 2. #define BLINK_GPIO CONFIG_BLINK_GPIO

3. void app_main(void)

4. {

/*Configura IO come funzione GPIO predefinita, abilita la modalità pull-up e

disabilita le modalità di input e output*/

gpio_reset_pin(BLINK_GPIO);

54 Avventura wireless ESP32-C3: una guida completa all'IoT

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

/*Imposta GPIO sulla modalità di output*/ gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT); mentre(1) {
/*Stampa registro*/ printf(“Spegnimento del LEDn”); /*Spegne il LED (livello di uscita basso)*/ gpio_set_level(BLINK_GPIO, 0); /*Ritardo (1000 ms)*/ vTaskDelay(1000 / portTICK_PERIOD_MS); printf("Accendere il LEDn"); /*Accendi il LED (uscita ad alto livello)*/ gpio_set_level(BLINK_GPIO, 1); vTaskDelay(1000 / portTICK_PERIOD_MS); }

La funzione app_main() in Blink exampil programma funge da punto di ingresso per i programmi utente. È una funzione semplice senza parametri e senza valore restituito. Questa funzione viene richiamata dopo che il sistema ha completato l'inizializzazione, che comprende attività quali l'inizializzazione della porta seriale del registro, la configurazione del single/dual core e la configurazione del watchdog.

La funzione app_main() viene eseguita nel contesto di un'attività denominata main. La dimensione dello stack e la priorità di questa attività possono essere regolate nel menuconfig Componentconfig Comune relativo a ESP.

Per compiti semplici come far lampeggiare un LED, tutto il codice necessario può essere implementato direttamente nella funzione app_main(). Ciò in genere comporta l'inizializzazione del GPIO corrispondente al LED e l'utilizzo di un ciclo while(1) per accendere e spegnere il LED. In alternativa, puoi utilizzare l'API FreeRTOS per creare una nuova attività che gestisca il lampeggiamento del LED. Una volta creata correttamente la nuova attività, puoi uscire dalla funzione app_main().

Il contenuto di main/CMakeLists.txt file, che guida il processo di compilazione del componente principale, è il seguente:

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

Tra questi, main/CMakeLists.txt chiama solo una funzione del sistema di compilazione, ovvero idf_component_register. Similmente a CMakeLists.txt per la maggior parte degli altri componenti, flick.c viene aggiunto a SRCS e il sorgente fileI messaggi aggiunti a SRCS verranno compilati. Allo stesso tempo, ".", che rappresenta il percorso in cui si trova CMakeLists.txt, dovrebbe essere aggiunto a INCLUDE_DIRS come directory di ricerca per l'intestazione fileS. Il contenuto di CMakeLists.txt è il seguente:
1. #Specifica v3.5 come la versione CMake più vecchia supportata dal progetto corrente 2. #Le versioni inferiori alla v3.5 devono essere aggiornate prima che la compilazione continui 3. cmake_minimum_required(VERSION 3.5) 4. #Includi la configurazione CMake predefinita dell'ESP -Sistema di compilazione IDF

Capitolo 4. Impostazione dell'ambiente di sviluppo 55

5. include($ENV{IDF_PATH}/tools/cmake/project.cmake) 6. #Crea un progetto chiamato "blink" 7. project(myProject)
Tra questi, CMakeLists.txt nella directory root include principalmente $ENV{IDF_ PATH}/tools/cmake/project.cmake, che è la configurazione principale di CMake file fornito da ESP-IDF. È usato per con

Documenti / Risorse

Sistemi Espressif ESP32-C3 Avventura wireless [pdf] Guida utente
ESP32-C3 Avventura senza fili, ESP32-C3, Avventura senza fili, Avventura

Riferimenti

Manuale d'uso

ESP32-C3 Avventura senza fili