Lezione ESP32 a scuola: preparazione e prima ora in 40 minuti

Quando prepari una lezione ESP32 a scuola, riduci la prima ora a un solo obiettivo: alla fine ogni gruppo ha caricato il codice sul proprio ESP32 e acceso un LED. Wi-Fi, sensori e controllo dal telefono sono roba delle lezioni successive. Se 40 minuti bastano dipende meno da quello che fai in classe che da quello che fai prima: il driver USB-seriale è installato, nell'Arduino IDE c'è il pacchetto schede ESP32, il cavo sul banco trasporta davvero dati? Se queste tre cose sono pronte, il primo caricamento richiede cinque minuti; altrimenti metà lezione se ne va in "non vedo la porta".

Qui trovi un pacchetto da portare in classe domani: una checklist copiabile per una settimana prima, il giorno prima e la mattina della lezione, una tabella dei materiali, una scaletta di 40 minuti minuto per minuto, due sketch che compilano, cinque differenze tra ESP32 e Arduino Uno, soluzioni da un minuto per gli otto problemi più frequenti e domande di uscita. Mettiamo che tu abbia una classe di 24 studenti divisi in 8 gruppi da tre; tutti i numeri partono da qui. Se la tua ora dura 50 o 60 minuti, il resto è il tuo margine. Se l'ESP32 è ancora nuovo per te, leggi prima cos'è l'ESP32.

Obiettivo della prima lezione: perché un solo LED?

Nella prima lezione con l'ESP32 hai due strade: mostrare un progetto Wi-Fi d'effetto oppure far funzionare a ciascuno qualcosa di piccolo con le proprie mani. La seconda insegna molto di più. Per accendere un LED lo studente deve percorrere una volta tutta la catena dall'inizio alla fine: aprire il codice, scegliere scheda e porta, compilare, caricare, montare il circuito, vedere il risultato, poi cambiare un valore e caricare di nuovo. Una volta che questa catena funziona, nelle lezioni successive si aggiungono solo componenti nuovi. Se passi al Wi-Fi prima, password di rete, driver e cavo si sommano e capire da dove arriva l'errore diventa quasi impossibile. Per questo il piano non usa la rete nella prima ora: prima il LED interno della scheda, poi un solo LED esterno sulla breadboard e, per i gruppi veloci, i due che lampeggiano a turno.

Checklist di preparazione prima della lezione

Dividi la preparazione in tre momenti. Puoi copiare e stampare l'elenco o condividerlo con il tecnico informatico della scuola; i lavori che richiedono i permessi di amministratore, come installare driver e programmi, nella maggior parte delle scuole passano da lui. Una settimana prima:

• Conta le schede e controlla il modello. Questo piano è scritto per l'ESP32 DevKit a 30 pin (con modulo ESP32-WROOM-32); sulle schede a 38 pin il codice è lo stesso, cambia solo l'ordine dei pin.
• Leggi il piccolo chip accanto alla porta USB della scheda: è un CP2102, un CH340 o un CH9102? Da questo dipende il driver che ti serve.
• Fai installare Arduino IDE 2 sui computer del laboratorio. Sui computer della scuola di solito servono i permessi di amministratore, quindi fissa un momento con il tecnico.
• Nell'Arduino IDE installa il pacchetto esp32 by Espressif Systems dal Gestore schede. Scarica centinaia di megabyte; con la rete della scuola 40 minuti potrebbero non bastare se lo fai a lezione.
• Installa il driver USB-seriale, collega una scheda e controlla che in Strumenti > Porta compaia una nuova porta.
• Prova i cavi: carica uno sketch su una scheda con ciascun cavo, scarta quelli solo da ricarica e segna quelli dati con nastro colorato.
• Inserisci un ESP32 in una breadboard e guarda se restano fori liberi su entrambi i lati. Se no, ogni gruppo avrà due breadboard.
• Informati sui limiti della rete scolastica: l'ESP32 si collega solo al Wi-Fi a 2,4 GHz, e le reti aziendali con nome utente e password sono complicate. Nella prima lezione non userai il Wi-Fi, ma per le lezioni successive ti serve saperlo già ora.

Il giorno prima ogni computer deve essere pronto; l'idea è che in classe nessun passaggio di installazione avvenga per la prima volta. Tieni anche dieci minuti per la mattina della lezione. Le due liste sono insieme:

• Giorno prima: Fai un caricamento di prova su ogni computer. Collega la scheda, scegli ESP32 Dev Module e la porta, carica lo sketch del LED interno e controlla che lampeggi. La prima compilazione può superare il minuto; questa prova accorcia anche le successive.
• Giorno prima: Su Windows attacca sul fianco del computer un'etichetta con il numero di porta (COM3, COM5…). La stessa scheda sulla stessa presa USB di solito riceve lo stesso numero.
• Giorno prima: Prepara le scatole dei gruppi: scheda, cavo, breadboard, due LED, due resistenze da 220 Ω, quattro cavetti jumper. Tieni il kit di riserva sulla cattedra.
• Giorno prima: Salva i due sketch sul desktop di ogni computer; se internet rallenta, gli studenti aprono il codice da lì.
• Giorno prima: Controlla che il progetto Lampeggio del LED interno dell'ESP32 si apra in BlueGrays sul proiettore.
• Mattina della lezione: Accendi i computer, apri l'Arduino IDE e controlla che la scheda sia ancora impostata su ESP32 Dev Module.
• Mattina della lezione: Disegna alla lavagna uno schema semplice della scheda: porta USB, BOOT, EN, GND, 3V3 e GPIO5 (sulla scheda c'è scritto D5).
• Mattina della lezione: Scrivi una riga in un angolo della lavagna: "Bloccato su Connecting...? Tieni premuto BOOT."
• Mattina della lezione: Conta un'ultima volta LED e resistenze nelle scatole e metti i cavi sopra.

Driver, pacchetto schede e BOOT: i dettagli da sapere

Nel Gestore schede dell'Arduino IDE puoi vedere due pacchetti ESP32. Per le schede del laboratorio quello giusto è il pacchetto esp32 di Espressif; quello chiamato "Arduino ESP32 Boards" è per la Nano ESP32 di Arduino. Dopo l'installazione scegli ESP32 Dev Module in Strumenti > Scheda > esp32. Se il pacchetto non compare nell'elenco, devi aggiungere l'indirizzo del pacchetto Espressif negli URL aggiuntivi del gestore schede, nelle Impostazioni; trovi i passaggi in cos'è l'ESP32. Gli sketch ESP32 compilano più lentamente di quelli per Uno; anche per un LED lampeggiante la prima compilazione può superare il minuto. Dillo agli studenti fin dall'inizio, altrimenti premeranno Carica più volte mentre la barra sembra ferma. Il chip USB-seriale della scheda decide quale driver installare:

Il pulsante BOOT è collegato al pin GPIO0 dell'ESP32. All'inizio di un caricamento la scheda deve entrare in modalità programmazione; la maggior parte delle DevKit lo fa da sola con due segnali del chip USB-seriale. Con alcune combinazioni di scheda e cavo questo passaggio automatico non riesce: i puntini di "Connecting..." si allungano e alla fine compare l'errore "Failed to connect to ESP32". La soluzione è tenere premuto BOOT appena appare "Connecting..." e rilasciarlo quando iniziano a scorrere le righe che cominciano con "Writing at". Il pulsante EN riavvia la scheda; se il caricamento è finito ma il codice non sembra partire, basta premere EN una volta. Se il problema si ripete sempre sulla stessa scheda, abbassare Upload Speed nel menu Strumenti da 921600 a 115200 di solito risolve. Su macOS il nome della porta di solito inizia con cu.usbserial o cu.SLAB_USBtoUART.

Elenco materiali: per gruppo e per una classe di 24

Dividendo 24 studenti in gruppi da tre ottieni 8 gruppi; con un kit di riserva prepari 9 kit. Se preferisci le coppie servono 12 gruppi più una riserva, cioè 13 kit, e più computer. Nessun componente richiede saldature. Due LED e due resistenze per gruppo hanno un motivo semplice: un LED montato al contrario o con una gamba rotta è molto comune nella prima lezione, e nessun gruppo deve restare ad aspettare.

La scaletta della lezione di 40 minuti

La scaletta si basa su due progetti gratuiti di BlueGrays: prima Lampeggio del LED interno dell'ESP32 (nessun circuito, solo scheda e cavo), poi LED Lampeggiante con ESP32 (GPIO5, una resistenza da 220 Ω e un LED). In entrambi i progetti elenco dei componenti, schema, codice, blocchi e Capire il codice sono aperti gratuitamente. Assegna tre ruoli in ogni gruppo e falli ruotare a ogni fase: uno alla tastiera, uno che monta il circuito, uno che legge schema e codice dal telefono o dal proiettore. Così nessuno passa 40 minuti solo a guardare.

Il codice: LED interno e LED esterno

I due sketch qui sotto usano gli stessi pin e gli stessi tempi dei progetti nell'app e compilano direttamente nell'Arduino IDE con ESP32 Dev Module selezionato. Il primo fa lampeggiare il LED sulla scheda una volta al secondo. Sulla maggior parte delle schede ESP32 DevKit questo LED blu è collegato a GPIO2. Sull'Arduino Uno il LED interno era sul pin 13; chi ha già usato un Uno potrebbe scrivere 13 per abitudine, quindi spiega subito la differenza.

1// ESP32 Dahili LED Yakma / ESP32 built-in LED blink
2// Çoğu ESP32 DevKit kartında dahili LED GPIO2'dedir / On most ESP32 DevKit boards the built-in LED is on GPIO2
3int BUILTIN_LED_PIN = 2;   // Kartına göre değişebilir / May differ on your board
4
5void setup() {
6  pinMode(BUILTIN_LED_PIN, OUTPUT);   // Pini çıkış yap / Set the pin as output
7}
8
9void loop() {
10  digitalWrite(BUILTIN_LED_PIN, HIGH);   // LED'i yak / Turn the LED on
11  delay(1000);                           // 1 saniye bekle / Wait 1 second
12  digitalWrite(BUILTIN_LED_PIN, LOW);    // LED'i söndür / Turn the LED off
13  delay(1000);                           // 1 saniye bekle / Wait 1 second
14}
15

Il circuito del secondo sketch: da GPIO5 a un capo della resistenza da 220 Ω, dall'altro capo della resistenza alla gamba lunga del LED (anodo), dalla gamba corta (catodo) a GND. Il pin dell'ESP32 fornisce 3,3 V; su un LED rosso cadono circa 2 V e gli 1,3 V restanti su 220 Ω fanno passare circa 6 mA. Bastano per un LED ben visibile e non affaticano il pin. Se usi un altro colore, controlla la resistenza con il calcolatore della resistenza per LED. Nella mini sfida i gruppi veloci uniscono i due sketch: in setup() impostano entrambi i pin come uscita e in loop() scrivono HIGH su uno mentre l'altro è LOW.

1// ESP32 ile LED Yakma: harici LED / ESP32 external LED blink
2// Bağlantı: GPIO5 -> 220 Ω direnç -> LED uzun bacak (+), kısa bacak (-) -> GND
3// Wiring: GPIO5 -> 220 ohm resistor -> LED long leg (+), short leg (-) -> GND
4const int LED_PIN = 5;   // Harici LED pini (kartta D5) / External LED pin (D5 on the board)
5
6void setup() {
7  pinMode(LED_PIN, OUTPUT);   // Pini çıkış yap / Set the pin as output
8}
9
10void loop() {
11  digitalWrite(LED_PIN, HIGH);   // Pin 3,3 V verir, LED yanar / Pin outputs 3.3 V, LED on
12  delay(500);                    // Yarım saniye bekle / Wait half a second
13  digitalWrite(LED_PIN, LOW);    // Pin 0 V verir, LED söner / Pin outputs 0 V, LED off
14  delay(500);                    // Yarım saniye bekle / Wait half a second
15}
16

5 differenze tra ESP32 e Arduino Uno

Alcuni tuoi studenti potrebbero aver già usato un Arduino Uno. Il codice si scrive nello stesso linguaggio Arduino e setup() e loop() sono al loro posto, ma l'hardware è diverso, e la maggior parte degli errori della prima lezione nasce proprio da queste differenze. Puoi spiegare i cinque punti qui sotto in pochi minuti mentre conoscete la scheda. Per un confronto più dettagliato, leggi Arduino o ESP32.

Gli 8 problemi più frequenti in classe e la soluzione in un minuto

Domande di uscita e anteprima della seconda lezione

1. A quale pin della scheda si riferisce il numero 5 nel codice? Perché accanto a quel pin potrebbe esserci scritto "D5"?
2. Che cosa è cambiato nel LED scrivendo delay(200) invece di delay(1000)? Quante volte al secondo lampeggia ora?
3. Perché il LED non si è acceso quando era al contrario? Quale gamba del LED va dal lato della resistenza?
4. Che tensione forniscono i pin dell'ESP32? Perché non dobbiamo collegare un LED o un modulo direttamente al pin 5V?

Le risposte ti dicono quale concetto ripassare nella seconda lezione; chi risponde 2,5 alla seconda domanda ha capito la temporizzazione. Nella seconda lezione si aggiunge un pulsante allo stesso circuito: nel progetto Controllo LED ESP32 con pulsante (Push) il LED resta acceso finché tieni premuto il pulsante, in Controllo LED ESP32 con pulsante (Toggle) ogni pressione ne inverte lo stato. Sono entrambi gratuiti e hanno i blocchi; gli studenti leggono per la prima volta un ingresso e decidono con if. Nella terza o quarta lezione puoi passare al Wi-Fi; per quella lezione tieni a portata di mano la tabella dei codici di stato di l'ESP32 non si connette al Wi-Fi. I progetti ESP32 con Wi-Fi in BlueGrays sono Premium; se vuoi che i tuoi studenti proseguano con quelli, in codici Premium per la classe spieghiamo come dare a ciascuno un codice da un pacchetto educatore invece di abbonamenti separati.

Come usare BlueGrays a lezione?

• Trovare il progetto: In Scopri › Progetti usa Filtra per scegliere la piattaforma ESP32 e in Stato del Prezzo l'opzione gratuito. I progetti ESP32 adatti alle prime lezioni, come LED, pulsante, semaforo, sensore di luce e sensore di distanza, sono completamente aperti.
• Componenti Necessari e Schema del Circuito: L'elenco dei componenti è pronto con le quantità. Puoi ingrandire lo schema e proiettarlo, oppure salvarlo con Salva nella Galleria e stamparlo.
• Codice Sorgente: Con Copia il codice va negli appunti. Se uno studente ha aperto il progetto sul telefono, Copia link gli dà un link per aprire il codice sul computer, così nessuno deve ricopiarlo a mano.
• Capire il codice: Prima il riepilogo Cosa fa questo codice?, poi la spiegazione Passo dopo passo, la sezione Se ti blocchi e il compito Prova tu. È il passo successivo già pronto per i gruppi che finiscono presto la mini sfida.
• Mostra a blocchi: Tutti i progetti ESP32 gratuiti hanno la vista a blocchi. Attivando l'interruttore, al posto del codice compaiono i blocchi dello stesso programma e la scheda diventa Capire i blocchi. I blocchi servono per leggere; non si modificano nell'app e non si caricano sulla scheda, sulla scheda va sempre il codice vero.
• Costruiscilo passo dopo passo: Una modalità guidata con i passi prepara i componenti, monta il circuito, carica il codice, avvia e prova. Lo schermo resta acceso, quindi il gruppo segue i passi con il telefono appoggiato sul banco; alla fine L'ho fatto segna il progetto come completato.

La prima lezione può sembrare solo un LED, ma in quei 40 minuti gli studenti vivono una volta compilazione, caricamento, numeri dei pin, il limite dei 3,3 V e il debug, e ogni lezione ESP32 successiva si appoggia su questa base. Spieghiamo nel dettaglio tutte le sezioni della pagina di un progetto nella guida alla pagina del progetto. Se vuoi realizzare tu i due progetti una volta prima della lezione, apri Lampeggio del LED interno dell'ESP32 nell'app BlueGrays; schema, codice, blocchi e Capire il codice sono pronti, e la tua prova non supererà i dieci minuti.