ESP32 e MicroPython — IoT Low-Cost con WiFi e Bluetooth per PMI

Hai un magazzino da monitorare, una macchina da controllare a distanza o un sensore ambientale da installare in un capannone. Vuoi una soluzione IoT che funzioni, costi poco e non ti leghi a piattaforme chiuse con canoni mensili. Il classico Arduino non basta perché ti serve connettività. Un Raspberry Pi è troppo costoso e complesso per un sensore singolo. La via di mezzo esiste: ESP32 con MicroPython. Noi, di Meteora Web, abbiamo iniziato a usare questo chip quando un cliente ci chiese di monitorare l’umidità nei suoi silos di grano, senza spendere una fortuna in hardware proprietario. Da lì abbiamo costruito decine di dispositivi. Questa guida ti mostra come partire — dal firmware al primo dato inviato via WiFi — con tutto quello che serve per un deploy concreto.

Perché ESP32 e MicroPython per l'IoT low-cost rispetto ad altre piattaforme?

Se arrivi da Arduino, conosci il linguaggio C++ e la sensazione di scrivere codice di basso livello per accendere un LED. Con MicroPython puoi prototipare in ore, non in giorni. Ma la vera differenza è il rapporto costo-prestazioni: un modulo ESP32 costa tra 5 e 10 euro, ha WiFi e Bluetooth nativi, due core a 240 MHz, 520 KB di RAM e supporto per periferiche come SPI, I2C, UART, ADC, DAC. Roba da far impallidire un Arduino Uno. In più, con MicroPython hai un interprete Python interattivo via seriale o WiFi — debug immediato, senza ricompilare. Noi l'abbiamo usato per un piccolo sistema di logging di temperatura in un frantoio: sensore DS18B20 con cavo lungo, ESP32 che scrive su un foglio Google via HTTP POST. Costo totale: meno di 20 euro. Zero abbonamenti. Funziona da due anni.

Come configurare l'ambiente di sviluppo per ESP32 con MicroPython?

Prima di tutto, niente IDE enormi. Basta un editor di testo, il firmware MicroPython e un tool per flashare. Vediamo i passi.

Scaricare e installare il firmware MicroPython

Vai su micropython.org/download e prendi l’ultima release stabile per ESP32 generic. Collega la scheda via USB, individua la porta seriale (es. /dev/ttyUSB0 su Linux, COM3 su Windows). Usa esptool.py per cancellare la memoria e flashare:

pip install esptool
# Cancella flash
python -m esptool --chip esp32 --port /dev/ttyUSB0 erase_flash
# Flash del firmware
python -m esptool --chip esp32 --port /dev/ttyUSB0 --baud 460800 write_flash -z 0x1000 esp32-20220117-v1.18.bin

Dopo il flash, connettiti via seriale con screen o PuTTY e premi Invio: dovresti vedere il prompt REPL di MicroPython.

Strumenti di sviluppo consigliati

Noi usiamo Thonny (IDE Python per principianti con supporto nativo MicroPython) o ampy (tool da riga di comando per caricare file). Con Thonny selezioni la porta, fai click su Interpreter > MicroPython (ESP32) e sei pronto a scrivere codice direttamente sulla scheda. Per progetti più complessi, MicroPython-viper o mip (package manager).

Come connettere ESP32 al WiFi con MicroPython e inviare dati?

Il bello di MicroPython è che la connessione WiFi richiede poche righe. Ecco uno script base che si connette alla rete, fa una richiesta HTTP a un API e stampa la risposta.

import network
import urequests
import time

SSID = "TuaReteWiFi"
PASS = "TuaPassword"

def connetti_wifi():
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    if not wlan.isconnected():
        print("Connessione a", SSID)
        wlan.connect(SSID, PASS)
        while not wlan.isconnected():
            time.sleep(1)
    print("Connesso! IP:", wlan.ifconfig()[0])
    return wlan

wlan = connetti_wifi()

# Esempio: invio dati a un endpoint
response = urequests.get("https://api.meteoweb.com/sensors?temp=22.5")
print("Risposta:", response.text)
response.close()

Attenzione: se il tuo endpoint usa HTTPS, assicurati di avere i certificati CA (MicroPython li include di base per alcuni domini) oppure usa HTTP per test. Questo codice funziona su qualsiasi ESP32 con firmware MicroPython.

Come gestire il Bluetooth con MicroPython su ESP32?

ESP32 supporta sia Bluetooth Classic che BLE. Per IoT low-cost, il BLE è la scelta standard: consuma meno energia, perfetto per sensori a batteria. MicroPython ha un modulo bluetooth (nella versione 1.18+). Ecco come creare un server BLE che pubblica un valore.

import bluetooth
import struct
import time

bt = bluetooth.BLE()
bt.active(True)

# Definisci un servizio e una caratteristica
UART_SERVICE_UUID = bluetooth.UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
UART_TX_CHAR_UUID = bluetooth.UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E")
UART_RX_CHAR_UUID = bluetooth.UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E")

TX_CHAR = (UART_TX_CHAR_UUID, bluetooth.FLAG_NOTIFY | bluetooth.FLAG_READ,)
RX_CHAR = (UART_RX_CHAR_UUID, bluetooth.FLAG_WRITE,)
UART_SERVICE = (UART_SERVICE_UUID, (TX_CHAR, RX_CHAR,))

((tx_handle,),) = bt.gatts_register_services((UART_SERVICE,))

# Scrivi un valore nella caratteristica
valore = 25.3
bt.gatts_write(tx_handle, struct.pack('<f', valore))

# Avvia advertising
bt.gap_advertise(100, adv_data=b'\x02\x01\x06\x03\x03\x9e\x40')
print("BLE attivo, valore pubblicato:", valore)

Questo codice è minimale ma funzionante. Per un'app reale, devi gestire le connessioni, notifiche e consumo energetico. Noi abbiamo costruito un ponte BLE-WiFi per raccogliere dati da sensori posti in cantina (nessun segnale WiFi) e inviarli al cloud tramite un ESP32 centrale.

Quali sono i limiti reali di ESP32 con MicroPython e come superarli?

MicroPython è comodo, ma non è C. La gestione della memoria è automatica, ma l'heap può frammentarsi dopo lunghi periodi. La velocità di esecuzione è circa 10-20 volte più lenta di Arduino C++. Per applicazioni che richiedono tempi stretti (ad esempio lettura di encoder a 10 kHz), meglio tornare a C. Inoltre, la profondità di stack delle interrupt è limitata. Per aggirare questi limiti, noi usiamo una combinazione: prototipazione rapida con MicroPython e, se serve, riscriviamo le funzioni critiche in C usando il modulo micropython.viper o chiamate native tramite @micropython.native. Per la maggior parte dei progetti di monitoraggio ambientale (campioni ogni minuto o ora), MicroPython è più che sufficiente.

Cosa fare adesso per iniziare con ESP32 e MicroPython?

1. Compra un ESP32 — modelli economici: ESP32-DevKitC, NodeMCU-32S, o ESP-WROOM-32. Costano tra 5 e 12 euro su Amazon o AliExpress.
2. Flasha il firmware MicroPython — segui la procedura sopra. Usa Thonny per testare.
3. Salda i primi sensori — un DHT22 per temperatura/umidità o un DS18B20 (impermeabile). Collega VCC, GND e DATA a un GPIO.
4. Scrivi uno script che legge il sensore e invia i dati a un server — usa il codice WiFi di esempio.
5. Automatizza l'avvio — rinominare il file principale in main.py sulla scheda: MicroPython lo esegue all'accensione.
6. Monitora i consumi — se usi batteria, metti l'ESP32 in deep sleep tra una lettura e l'altra. Ecco un frammento:

import machine
import time

# Leggi sensore, invia dati, poi deep sleep per 300 secondi
# machine.deepsleep(300_000)  # in millisecondi

Noi abbiamo progettato un sistema di monitoraggio di celle frigo per un distributore di gelati: ogni ESP32 si sveglia ogni 10 minuti, legge temperatura, invia via WiFi e torna in deep sleep. Con due batterie AA dura oltre un anno. Questo è il bello dell'IoT low-cost: controllo totale, costi irrisori, niente cloud esterno a pagamento. Se vuoi approfondire architetture e protocolli IoT, leggi il nostro pillar sull'IoT e hardware programmabile. Per la sicurezza dei tuoi dispositivi connessi, dai un'occhiata alla guida su Smart Contract Security — sebbene sia su blockchain, i principi di hardening firmware sono simili.