10 lezioni pratiche per partire da zero e arrivare al controllo di dispositivi reali

Quando si parla di IoT a scuola si rischia spesso di cadere in due estremi: da una parte attività troppo teoriche, che restano astratte e poco coinvolgenti; dall’altra una successione di mini-progetti interessanti ma scollegati tra loro, che non aiutano davvero gli studenti a costruire competenze solide.

Per questo ho deciso di raccogliere in questa pagina un percorso completo in 10 lezioni dedicato all’uso della ESP32 con MicroPython, pensato in modo particolare per docenti e per chi parte con competenze iniziali ancora fragili.

L’idea di fondo è molto semplice: costruire un corso che sia graduale, pratico e coerente, in cui ogni attività prepari la successiva. Si parte dall’ambiente di sviluppo e dai primi GPIO, si passa attraverso sensori, ADC, PWM, Wi-Fi, pagine web locali e Bluetooth BLE, per arrivare infine al controllo della velocità di un motore DC da browser.

In realtà durante la scrittura di tutte queste lezioni mi sono accorto che il corso stava diventando un libro molto pratico, pertanto se desiderate leggere in anteprima i capitoli del libro potete farlo

iscrivendovi all’area Premium del mio sito
(in abbonamento mensile o annuale)

L’iscrizione permetterà di leggere ed utilizzare la documentazione che utilizzo per i miei corsi in presenza e online destinati a docenti, studenti e appassionati di elettronica e tecnologie. Per sapere come è struttura la guida docente, le schede operative di laboratorio, valore didattico dell’opera vi invito a leggere il post di presentazione su Scholaria.

La pubblicazione avverrà periodicamente tendenzialmente un capitolo ogni 10 giorni circa.

Ho scelto di usare ESP32 perché è una piattaforma estremamente versatile e, soprattutto in un contesto scolastico, permette di lavorare con:

• ingressi e uscite digitali;
• letture analogiche;
• PWM;
• Wi-Fi;
• Bluetooth BLE;

tutto con una sola scheda e senza cambiare continuamente ambiente di lavoro.

Ho scelto invece MicroPython perché consente di introdurre la programmazione hardware con una sintassi più accessibile, pur mantenendo un buon livello di rigore tecnico.

In questo post trovate lo sviluppo dell’intero percorso in una forma ordinata, così da poterlo usare come indice generale del corso, come pagina di riferimento di studio oppure come hub centrale del blog a cui collegare le singole lezioni.

A chi è rivolto il corso

Questo percorso è pensato soprattutto per:

• insegnanti della secondaria di primo e secondo grado;
• classi che stanno iniziando a lavorare con microcontrollori e IoT;
• studenti con competenze iniziali basse o intermedie;
• docenti che desiderano una sequenza di attività già organizzata in modo progressivo.

Ogni lezione è stata costruita con una attenzione particolare a quattro aspetti:

• linguaggio semplice ma corretto;
• forte connessione tra codice e cablaggio;
• verifica immediata in laboratorio;
• crescita graduale della complessità.

Come è costruito il percorso

Il corso segue una logica molto precisa.

All’inizio si lavora sui fondamentali:

• ambiente di sviluppo;
• primo programma;
• GPIO;
• LED;
• lettura di segnali analogici.

Successivamente si passa ai sensori e alla logica di controllo:

• potenziometro;
• LDR;
• DHT11;
• soglia di intervento;
• PWM.

Dopo questa base, il percorso entra nella parte più chiaramente “IoT”:

• ESP32 come Access Point;
• pagina web locale;
• dashboard;
• controllo e monitoraggio via browser;
• collegamento BLE con smartphone.

Infine si chiude con un’attività più completa e più vicina a un sistema reale:

• controllo della velocità di un motore DC con driver L298N e slider web.

In questo modo ogni nuova lezione aggiunge un solo gradino tecnico alla volta, evitando di sovraccaricare gli studenti con troppe novità contemporaneamente.

Indice completo delle 10 lezioni

Lezione 1 – Thonny, ESP32 e MicroPython: primi passi nell’ambiente di sviluppo
In questa prima lezione si impara a installare e usare Thonny, a collegare correttamente la ESP32 al computer, a selezionare l’interprete MicroPython e a distinguere tra shell, script e file salvati sulla scheda. È la base necessaria per tutto il corso.

• Argomenti principali: Thonny, interpreter, REPL, main.py, primi test.
• Obiettivo: rendere gli studenti autonomi nei passaggi iniziali di lavoro con ESP32 e MicroPython.

Lezione 2 – GPIO digitali con ESP32: accendere e far lampeggiare un LED
La prima vera attività hardware del percorso. Si introduce il concetto di GPIO come uscita digitale e si realizza il classico circuito con LED e resistenza, pilotato da MicroPython.

• Argomenti principali: Pin.OUT, on(), off(), value(), tempi di attesa.
• Obiettivo: capire come un programma può produrre un effetto fisico reale.

Lezione 3 – Potenziometro, ADC e PWM: regolare la luminosità di un LED
Qui gli studenti scoprono come leggere una grandezza analogica con l’ADC e come usare il PWM per regolare la luminosità di un LED in modo continuo.

• Argomenti principali: potenziometro, ADC, read_u16(), PWM, duty_u16().
• Obiettivo: collegare ingresso analogico e uscita PWM in un primo sistema di controllo continuo.

Lezione 4 – LDR e soglia di intervento: luce notturna automatica con ESP32
In questa attività la ESP32 legge il livello di luce ambientale tramite una LDR e accende automaticamente un LED quando si supera una soglia di buio.

• Argomenti principali: partitore resistivo, LDR, soglia, if/else, automazione.
• Obiettivo: introdurre la logica decisionale basata su misura e confronto.

Lezione 5 – DHT11 con ESP32: misurare temperatura e umidità in locale
Si introduce il sensore DHT11, leggendo temperatura e umidità direttamente nella shell di Thonny, senza ancora coinvolgere la rete.

• Argomenti principali: modulo dht, measure(), temperature(), humidity().
• Obiettivo: comprendere il funzionamento di un sensore ambientale digitale e visualizzarne correttamente i dati.

Lezione 6 – ESP32 come Access Point: creare una rete Wi-Fi locale senza Internet
La ESP32 viene trasformata in un piccolo Access Point Wi-Fi, capace di creare una rete locale a cui collegare smartphone o computer, senza bisogno di router o connessione Internet.

• Argomenti principali: network.WLAN, AP_IF, active(True), ifconfig().
• Obiettivo: preparare la base per tutte le lezioni successive con interfaccia web locale.

Lezione 7 – DHT11 su pagina web locale: primo web server Wi-Fi con ESP32
Qui si uniscono sensore e rete: la ESP32 legge temperatura e umidità dal DHT11 e le pubblica in una pagina web locale accessibile dal browser.

• Argomenti principali: DHT11, Access Point, socket, HTML, server HTTP.
• Obiettivo: costruire un primo vero progetto IoT locale con sensore e pagina web.

Lezione 8 – Pulsanti reali e dashboard: contatore con interfaccia web
Tre pulsanti fisici collegati alla ESP32 permettono di aumentare, diminuire o azzerare un contatore, mentre una dashboard web mostra il valore aggiornato quasi in tempo reale.

• Argomenti principali: Pin.IN, Pin.PULL_UP, contatore, dashboard, aggiornamento dinamico.
• Obiettivo: collegare eventi fisici reali a una interfaccia web di monitoraggio.

Lezione 9 – Controllo wireless via Bluetooth BLE con ESP32 e MicroPython
In questa lezione si cambia tecnologia e si introduce il Bluetooth Low Energy. La ESP32 si comporta come periferica BLE e riceve comandi dallo smartphone per pilotare un LED.

• Argomenti principali: BLE, peripheral, central, advertising, servizi e caratteristiche GATT.
• Obiettivo: mostrare una seconda modalità di comunicazione wireless, diversa dal Wi-Fi ma molto utile nei dispositivi IoT.

Lezione 10 – Controllo velocità motore DC da browser con ESP32, PWM e driver L298N
La lezione conclusiva del percorso: il browser controlla la velocità di un motore DC tramite slider web, mentre la ESP32 genera il PWM e il driver L298N gestisce la parte di potenza.

• Argomenti principali: PWM, motore DC, L298N, slider HTML, controllo velocità.
• Obiettivo: integrare interfaccia web, controllo PWM e attuazione reale in un progetto finale completo.

Materiali necessari per il corso

Di seguito trovi una lista generale dei materiali utili per seguire l’intero percorso.

Hardware di base

• 1 scheda ESP32
• cavo USB dati
• breadboard
• jumper maschio-maschio

Componenti elettronici

• LED
• resistenze da 220 Ω
• potenziometro da 10 kΩ
• LDR
• resistenza da 10 kΩ per partitore
• sensore DHT11
• 3 pulsanti
• motore DC
• modulo L298N

Dispositivi esterni

• computer con Thonny
• smartphone, tablet o PC con Wi-Fi
• smartphone con app BLE generica
• alimentazione esterna per il motore DC

Per le prime lezioni bastano davvero pochi componenti:
ESP32, breadboard, LED, resistenze, potenziometro e LDR.
I moduli più “strutturati”, come DHT11, BLE e L298N, entrano solo nella parte centrale e finale del corso.

Come consiglio di usare queste lezioni

Questo percorso può essere usato in diversi modi.

Come corso lineare
È la modalità che consiglio di più. Le lezioni sono state pensate per essere affrontate in ordine, perché ogni tappa prepara la successiva.

Come raccolta di attività laboratoriali
Un docente può anche scegliere singole lezioni da usare in momenti diversi dell’anno, ma conviene comunque tenere presente la progressione logica del percorso.

Come riferimento per studio individuale
Uno studente motivato può usare il corso anche da solo, purché proceda con calma e senza saltare i passaggi fondamentali.

Un possibile uso in classe

Una scansione semplice potrebbe essere questa:

• lezioni 1–2: familiarizzazione con ambiente e GPIO
• lezioni 3–5: sensori, ADC, PWM e acquisizione dati
• lezioni 6–8: rete locale e dashboard web
• lezione 9: controllo BLE
• lezione 10: progetto finale con motore

Questa organizzazione consente di trasformare il percorso anche in un piccolo modulo laboratoriale di più settimane.

Quando si costruisce un corso IoT per studenti dell’ITIS, la vera difficoltà non è trovare idee interessanti: quelle non mancano. La difficoltà vera è creare un percorso che abbia una progressione chiara, che non spaventi chi parte da zero e che mantenga sempre un forte legame tra teoria e pratica.

Questo corso nasce proprio con questa intenzione: portare gli studenti a capire che dietro la parola “IoT” non ci sono formule magiche, ma una serie di competenze concrete che si costruiscono passo dopo passo:

• saper programmare una scheda;
• saper leggere un sensore;
• saper pilotare un’uscita;
• saper comunicare in rete;
• saper controllare un dispositivo reale.

Ed è in questa continuità che, secondo me, sta il vero valore di un buon percorso laboratoriale.

Sviluppi possibili

Chi conclude questo percorso può poi proseguire, ad esempio, verso:

• logging dati;
• dashboard più evolute;
• controllo di relè;
• servo e motori con inversione di direzione;
• sensori ambientali più accurati;
• integrazione con piattaforme cloud;
• piccoli progetti di robotica o automazione.

Se siete interessati a sostenere questo corso/libro vi invito ad iscrivervi all’area Premium.

Buon Making a tutti 🙂