ESP-NOW: com’è fatto e perché usarlo in applicazioni reali

Ci sono messaggi che non hanno bisogno di Internet. Un pulsante che accende la luce nella stanza accanto, un sensore che dice “il terreno è secco”, un telecomando che fa girare un robot: pochi byte, da un dispositivo a un altro. Con il Wi-Fi classico quel pulsante dovrebbe prima collegarsi al router, ottenere un indirizzo IP, aprire una connessione con un server e solo allora consegnare il messaggio. ESP-NOW è la scorciatoia che Espressif ha costruito per questi casi: usa la radio Wi-Fi degli ESP32 e salta tutto il resto. Cheap, robottino da due centesimi che non paga volentieri nemmeno il router, lo trova molto simpatico.

Vediamo com’è fatto, che limiti ha, quanto è sicuro e quanto consuma. Poi la domanda vera: quando conviene usarlo in un progetto reale, quando no e come farlo funzionare sul serio, con un po’ di codice per ESP-IDF v6.1.

In breve

Caratteristica	ESP-NOW (ESP-IDF v6.1)
Che cos’è	Protocollo Espressif senza connessione, dentro un action frame Wi-Fi vendor-specific
Infrastruttura	Nessuna: niente router, niente indirizzi IP, niente associazione
Dati per pacchetto	250 byte (v1.0); 1470 byte (v2.0, da ESP-IDF v5.4)
Velocità radio predefinita	1 Mbit/s, configurabile per ogni peer
Peer registrati	fino a 20; cifrati 7 di default, 17 al massimo (ESP32-C2: 2 e 4)
Sicurezza	CCMP con chiavi PMK e LMK da 16 byte; il broadcast non si può cifrare
Banda	2,4 GHz; sull’ESP32-C5 anche 5 GHz
Long Range	500 o 250 kbit/s, circa 1 km in vista (non sull’ESP32-C2)
Licenza	ESP-IDF Apache-2.0; la libreria radio è distribuita come binario

I dati vengono dalla documentazione ufficiale Espressif: guida ESP-IDF v6.1, ESP-FAQ, componente esp-now e sue application note. Dove Espressif non dà un numero, lo diciamo.

Che cos’è e com’è fatto

In una rete Wi-Fi normale un dispositivo deve prima “entrare”: cerca l’access point, si autentica, si associa, scambia le chiavi. Poi trasmette, e i dati passano comunque dal router. ESP-NOW è invece senza connessione: i dati vengono infilati in un frame Wi-Fi speciale e spediti direttamente da un ESP32 all’altro. Espressif lo descrive come un protocollo al livello di collegamento dati, in cui i cinque livelli superiori del modello OSI sono ridotti a uno: niente IP, niente TCP, niente MQTT nel mezzo. Un dispositivo appena acceso può trasmettere subito.

Confronto tra il percorso di un messaggio con Wi-Fi e MQTT (associazione, chiavi, DHCP, TCP, MQTT CONNECT, PUBLISH attraverso router e broker) e con ESP-NOW (action frame diretto tra due ESP32 con ack MAC) — Lo stesso messaggio per due strade: sei passi con il Wi-Fi classico, uno solo con ESP-NOW, ma solo tra dispositivi Espressif.

Il pacchetto

Lo standard Wi-Fi (IEEE 802.11) prevede dei frame di gestione chiamati action frame; la categoria 127 è riservata ai produttori, che si identificano con il proprio OUI (Organizationally Unique Identifier, i primi tre byte degli indirizzi MAC di un’azienda). ESP-NOW usa questo spazio con l’OUI di Espressif, 18:FE:34.

Campi del frame ESP-NOW: header MAC 24 byte, category 1 byte, OUI 3 byte, valore casuale 4 byte, contenuto vendor da 7 a x byte, FCS 4 byte; ingrandimento dell'elemento vendor-specific con Element ID 221, Length, OUI, Type 4, versione e body fino a 250 byte — Il frame ESP-NOW secondo ESP-IDF v6.1. I nostri dati stanno nel “body” di uno o più elementi vendor-specific.

Header MAC (24 byte): destinatario e mittente; il terzo indirizzo è sempre il broadcast FF:FF:FF:FF:FF:FF, perché non c’è una rete a cui appartenere.
Category (127) e OUI: “frame Espressif”. Da ESP-IDF v5.5 l’OUI si può cambiare con esp_now_set_user_oui(), per esempio per separare due prodotti.
Valore casuale (4 byte): contro i relay attack, cioè la ritrasmissione di frame catturati.
Contenuto vendor: uno o più elementi con Element ID 221, lunghezza, OUI, Type 4 (ESP-NOW), versione e il body da 0 a 250 byte con i nostri dati.
FCS (4 byte): il controllo del frame.

Versione 1.0 e versione 2.0

Il campo Length di un elemento è lungo un byte (massimo 255): tolti OUI, Type e versione restano 250 byte di dati, il limite storico di ESP-NOW. La versione 2.0 mette più elementi in fila nello stesso frame e arriva a 1470 byte. È arrivata con ESP-IDF v5.4; in v5.4 e v5.4.1 il massimo era 1490 byte, corretto a 1470 da v5.4.2.

Un dispositivo v2.0 riceve sia v2.0 sia v1.0. Un v1.0 riceve i pacchetti v2.0 solo fino a 250 byte; oltre, li tronca o li scarta. Regola pratica: in una rete mista si resta sotto i 250 byte. La versione si legge con esp_now_get_version().

Peer, broadcast e callback

Un peer è un dispositivo con cui parlare in unicast, registrato con esp_now_add_peer(): indirizzo MAC, canale, interfaccia (station o softAP), eventuale chiave. Per il broadcast si registra come peer FF:FF:FF:FF:FF:FF. Chi riceve non deve per forza registrare il mittente: riceve comunque broadcast e unicast non cifrati. Tutto il resto passa da due callback, una per l’invio e una per la ricezione, che girano nel task Wi-Fi ad alta priorità: la documentazione chiede di copiare i dati in una coda e lavorarli altrove.

I limiti da conoscere

Quanti dispositivi

La lista contiene al massimo 20 peer. I cifrati sono 7 di default e 17 al massimo con CONFIG_ESP_WIFI_ESPNOW_MAX_ENCRYPT_NUM; sull’ESP32-C2 2 e 4. Prima di ESP-IDF v5.1 il limite era fisso a 6, e nell’header c’è ancora una macro ESP_NOW_MAX_ENCRYPT_PEER_NUM che vale 6: conta la configurazione. Le chiavi hardware sono poi condivise con il softAP: peer cifrati più client del softAP non superano le chiavi del chip, 17 sull’ESP32.

Più di 20 dispositivi? Si usa il broadcast con l’indirizzo del destinatario nel payload: per la FAQ in teoria non ci sono limiti, a parte le interferenze. È ciò che fa il componente esp-now.

Il canale è uno solo, e non sempre lo scegliamo noi

ESP-NOW trasmette sul canale della radio in quel momento (nel peer, 0 vuol dire “quello attuale”). Se l’ESP32 è anche station collegata a un router, il canale lo decide il router: la FAQ dice che ESP-NOW deve usare quello dell’access point e che, una volta connesso, il dispositivo non può cambiarlo. Se il router cambia canale, tutti i nodi devono seguirlo: è il problema numero uno dei gateway. Con il canale sbagliato esp_now_send() restituisce ESP_ERR_ESPNOW_CHAN.

La radio è condivisa anche con il Bluetooth. Nella tabella di coesistenza di ESP-IDF v6.1 per l’ESP32, la trasmissione ESP-NOW è stabile con qualunque attività Bluetooth, la ricezione solo in modalità station.

L’ack della callback è solo “MAC”

È il limite più frainteso. ESP_NOW_SEND_SUCCESS significa che il frame è arrivato a livello MAC al destinatario, non che l’applicazione l’abbia letto: la coda potrebbe essere piena, il firmware in riavvio. La documentazione suggerisce la cura: ack applicativo, ritrasmissione allo scadere di un timeout e numero di sequenza per scartare i duplicati. Per i broadcast non è spiegato che cosa valga lo stato della callback: meglio non contarci. Altri due consigli ufficiali: inviare il pacchetto successivo dopo la callback del precedente e, con ESP_ERR_ESPNOW_NO_MEM, aspettare un attimo.

Il broadcast viaggia in chiaro

Cifrare action frame multicast non è supportato. Un broadcast è leggibile da chiunque sia sul canale: va bene per un “c’è qualcuno?” durante l’abbinamento, non per “apri il cancello”.

Sicurezza

ESP-NOW protegge gli unicast con CCMP, il meccanismo basato su AES del WPA2. Le chiavi sono due, da 16 byte: la PMK (Primary Master Key), una per dispositivo, impostata con esp_now_set_pmk(), che cifra le LMK con AES-128 (se manca si usa una PMK predefinita); la LMK (Local Master Key), una per peer, che cifra i frame. Senza LMK il frame parte in chiaro. E ESP-NOW non distribuisce le chiavi: l’esempio ufficiale ricorda che PMK e LMK devono essere uguali sui due lati. Come ci arrivano, è un problema nostro.

Il componente esp-now propone una strada applicativa: un handshake con ECDH (scambio di chiavi a curve ellittiche) e Proof of Possession, una stringa segreta che autorizza la configurazione; poi AES256-CTR per i dati di configurazione e AES128-CCM per i dati ESP-NOW. Secondo la documentazione si configurano 16 dispositivi in 5 secondi e, essendo applicativa, la cifratura non è soggetta al limite dei peer cifrati; costa 12 byte per pacchetto. Il componente è mantenuto: la 2.5.2 ha corretto una vulnerabilità di replay e una lettura fuori dai limiti. Meglio tenerlo aggiornato.

Prestazioni e portata

In rete circolano numeri di ogni tipo. Qui solo quelli dichiarati da Espressif, con la condizione di prova.

Dato	Valore	Condizione
Throughput tra due dispositivi	circa 214 kbit/s	ESP32-DevKitC V4, station, radio a 1 Mbit/s, ambiente aperto (ESP-FAQ)
Throughput tra due dispositivi	circa 555 kbit/s	stessa prova in camera schermata (ESP-FAQ)
Portata	200 m in spazio aperto	telecomando ESP32 con potenza fino a +21 dBm (pagina soluzioni)
Portata Long Range	circa 1 km in vista	modalità LR (guida Wi-Fi ESP-IDF)
Risposta del pulsante	entro 150 ms	interruttore a pila ESP32-C2 (pagina soluzioni)

Quello che non c’è: una latenza di laboratorio per singolo pacchetto. Espressif parla di risposta “nell’ordine dei millisecondi”; i 150 ms del pulsante comprendono l’accensione del chip. I “oltre 500 metri” di una figura del componente esp-now non hanno condizioni di prova.

La velocità si cambia per peer con esp_now_set_peer_rate_config(), che accetta tutte le velocità Wi-Fi, comprese quelle Wi-Fi 6; da ESP-IDF v6.0 la vecchia esp_wifi_config_espnow_rate() non c’è più. Più velocità vuol dire meno tempo in aria ma meno portata: va misurato sul campo.

Long Range

Il Long Range (LR) è una modalità brevettata da Espressif: circa un chilometro in vista, sensibilità migliore di circa 4 dB rispetto all’802.11b e, in teoria, distanza da 2 a 2,5 volte maggiore. La radio va a 500 o 250 kbit/s (costanti WIFI_PHY_RATE_LORA_500K e _250K, che con LoRa non c’entrano). Il README dell’esempio ufficiale scrive 512 e 256 kbit/s: seguiamo header e guida. Funziona solo a 2,4 GHz, non sull’ESP32-C2, e nell’esempio si attiva con WIFI_PROTOCOL_LR in esp_wifi_set_protocol(). Per ESP32-C61 ed ESP32-S31 la guida non lo menziona: va verificato.

Consumi: chi ascolta paga

Trasmettere costa, ma ascoltare costa di più, perché dura di più. Di default la radio resta sempre accesa in ricezione. Per risparmiare si impostano la finestra di risveglio (esp_now_set_wake_window(), 0-65535 ms) e l’intervallo (esp_wifi_connectionless_module_set_wake_interval(), 1-65535 ms, meglio multipli di 100). A ogni intervallo la radio si accende per la durata della finestra e arriva l’evento WIFI_EVENT_CONNECTIONLESS_MODULE_WAKE_INTERVAL_START, il momento consigliato per trasmettere; trasmettere però si può sempre. Il risparmio funziona solo in modalità station, e la sincronizzazione tra chi trasmette e chi dorme è a carico dell’applicazione.

Il caso ufficiale: il pulsante a pila

Il modo più elegante per non consumare in attesa è non aspettare. Nel pulsante a pila Espressif con ESP32-C2 il tasto è l’interruttore dell’alimentazione: premendolo il chip si accende, manda il comando, aspetta la conferma e si spegne al rilascio. A riposo resta una dispersione di circa 1,5 µA.

Il ricevitore dell’application note è un bridge ESP-NOW verso Matter, collegato al router (quindi sul suo canale) e in ascolto 110 ms ogni 200 ms. Il pulsante non sa quando è sveglio: trasmette, dorme 30 ms, aspetta l’ack 20 ms e ritrasmette fino a due volte.

Diagramma temporale: il bridge ha la radio accesa 110 ms ogni 200 ms; il pulsante trasmette tre volte a 50 ms di distanza, i primi due invii cadono nel sonno del bridge, il terzo nella finestra successiva e riceve l'ack — Il caso peggiore: il primo invio parte appena il bridge si addormenta; il terzo cade nella finestra successiva. Le due regole in basso valgono per qualunque coppia trasmettitore-ricevitore.

Le misure (hardware V1, ESP-NOW 2.5.1, ESP-IDF v5.2.1): un invio riuscito al primo colpo dura 125,6 ms in tutto a 20,8 mA di media, di cui circa 16 ms di trasmissione vera; tre invii 227,3 ms a 31,8 mA; la ricerca del canale dopo che il router è passato al canale 10 circa 1,6 s a 39 mA. Spostando 10 ms dall’attesa dell’ack al sonno (40 + 10 ms invece di 30 + 20) una ritrasmissione completa consuma il 38,8% in meno.

Grafico a barre della carica consumata per pressione dal pulsante ESP32-C2: 0,73 e 0,689 microamperora per un invio, 2 e 1,61 per tre invii, 17,29 e 10,56 per la ricerca del canale, nelle due configurazioni — Carica per evento nelle due configurazioni dell’application note: una ricerca del canale costa da 15 a 24 pressioni normali.

Con una CR2032 da 225 mAh (circa il 25% utilizzabile con quel circuito), 50 pressioni e una ricerca del canale al giorno, Espressif stima da 1,31 a 2,87 anni con la prima configurazione e da 1,7 a 3,42 con la seconda; la pagina commerciale dice “fino a 5 anni” con circa 10 pressioni al giorno. Lezione: il router che cambia canale da solo è il peggior nemico della batteria. Dall’altra parte il bridge, un ESP32-C3-DevKitM-1, assorbe circa 51 mA medi a riposo: il ricevitore va alimentato bene.

Per ESP-NOW con il deep sleep non abbiamo trovato una guida ufficiale, e nel componente esp-now il basso consumo è ancora tra le cose da fare. Il prodotto ufficiale il problema lo evita: spegne tutto.

Perché usarlo in applicazioni reali

ESP-NOW non è “il Wi-Fi ma meglio”: ha un campo d’azione preciso. Dentro, con lo stesso hardware, è difficile fare di meglio; fuori, è la scelta sbagliata.

Quando conviene

Risposta immediata senza infrastruttura. Niente associazione né IP. La FAQ Wi-Fi di Espressif consiglia ESP-NOW proprio quando anche l’altro capo è un ESP e serve una latenza molto bassa.
Dispositivi a batteria che si accendono, trasmettono e si spengono.
Telecomandi e pulsanti, i casi di riferimento di Espressif: il pulsante ESP32-C2 senza gateway, il telecomando per giocattoli, droni e robot (anche ESP-Drone si pilota via ESP-NOW).
Reti locali senza router o con un router poco affidabile: orti, capannoni, campi da gioco.
Gateway verso Wi-Fi e MQTT: i nodi parlano ESP-NOW, uno solo parla anche IP.
Manutenzione di flotte: credenziali, aggiornamenti, log, anche dove un cavo non arriva.

Quando non conviene

Tanti dati. Con le impostazioni predefinite siamo a qualche centinaio di kbit/s; il Wi-Fi in TCP arriva fino a 20 Mbit/s secondo ESP-IDF. Immagini, audio e file grandi vanno sul Wi-Fi.
Reti estese o a molti salti. Il componente esp-now inoltra i pacchetti ripetendoli con un limite di salti e una soglia di segnale, ma senza un vero instradamento. Per una rete a maglia ampia ci sono Thread e Zigbee.
Interoperabilità. È un protocollo Espressif: telefoni, lampadine di altre marche e Home Assistant non lo parlano. Per un ecosistema servono Matter, Bluetooth LE o il Wi-Fi standard.
Accesso diretto a Internet: senza IP serve sempre un traduttore.

Il confronto con le alternative

Solo velocità radio e caratteristiche documentate: Espressif non pubblica confronti di latenza o consumo tra protocolli, e non li inventiamo.

Tecnologia	Velocità (dato Espressif)	Infrastruttura	Con chi parla	Quando sceglierla
ESP-NOW	radio a 1 Mbit/s di default; circa 214 kbit/s misurati	nessuna	solo dispositivi Espressif	comandi e misure brevi, bassa latenza
Wi-Fi + MQTT	fino a 20 Mbit/s TCP, 30 UDP	router e broker	qualunque dispositivo IP	dati, cloud, app
Bluetooth LE	1 e 2 Mbit/s; 500 e 125 kbit/s long range (ESP32-C6)	nessuna tra due dispositivi	telefoni e dispositivi Bluetooth	configurazione da telefono, indossabili
Thread / Zigbee (802.15.4)	250 kbit/s	border router o coordinatore	standard aperti; Matter su Thread	domotica a batteria, reti a maglia

E LoRa? È la tecnologia dei chilometri con pochi byte, ma usa una radio che gli ESP32 non hanno e le fonti Espressif non la trattano: niente numeri in tabella.

Pattern di progetto per farlo funzionare sul serio

Ora la pratica, con le API di ESP-IDF v6.1 (firme controllate nell’header esp_now.h di quella versione).

Avvio e callback

Prima il Wi-Fi, poi ESP-NOW. Dalla v5.1 la callback di ricezione riceve esp_now_recv_info_t, con mittente, destinatario e dati radio come l’RSSI; dalla v5.5 quella di invio riceve esp_now_send_info_t.

#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "esp_wifi.h"
#include "esp_now.h"

typedef struct {
    uint8_t mac[ESP_NOW_ETH_ALEN];
    int8_t  rssi;
    int     len;
    uint8_t dati[ESP_NOW_MAX_DATA_LEN];   /* 250 byte: compatibili con v1.0 */
} pacchetto_t;

static QueueHandle_t coda_rx;

/* Gira nel task Wi-Fi: copia e torna subito. */
static void ricevuto(const esp_now_recv_info_t *info, const uint8_t *data, int len)
{
    pacchetto_t p = { .rssi = info->rx_ctrl->rssi, .len = len };
    if (len <= 0 || len > (int)sizeof(p.dati)) return;
    memcpy(p.mac, info->src_addr, ESP_NOW_ETH_ALEN);
    memcpy(p.dati, data, len);
    xQueueSend(coda_rx, &p, 0);
}

static void inviato(const esp_now_send_info_t *tx, esp_now_send_status_t stato)
{
    /* SUCCESS = arrivato al livello MAC del destinatario. Niente di più. */
}

void espnow_avvio(uint8_t canale, const uint8_t pmk[ESP_NOW_KEY_LEN])
{
    /* prima: nvs_flash_init(), esp_netif_init(), event loop (come l'esempio ufficiale) */
    coda_rx = xQueueCreate(16, sizeof(pacchetto_t));
    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));
    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
    ESP_ERROR_CHECK(esp_wifi_start());
    ESP_ERROR_CHECK(esp_wifi_set_channel(canale, WIFI_SECOND_CHAN_NONE));

    ESP_ERROR_CHECK(esp_now_init());
    ESP_ERROR_CHECK(esp_now_register_recv_cb(ricevuto));
    ESP_ERROR_CHECK(esp_now_register_send_cb(inviato));
    ESP_ERROR_CHECK(esp_now_set_pmk(pmk));
}

Un peer cifrato e la sua velocità

void aggiungi_gateway(const uint8_t mac[ESP_NOW_ETH_ALEN], const uint8_t lmk[ESP_NOW_KEY_LEN])
{
    esp_now_peer_info_t peer = {
        .channel = 0,             /* il canale attuale */
        .ifidx   = WIFI_IF_STA,
        .encrypt = true,
    };
    memcpy(peer.peer_addr, mac, ESP_NOW_ETH_ALEN);
    memcpy(peer.lmk, lmk, ESP_NOW_KEY_LEN);
    ESP_ERROR_CHECK(esp_now_add_peer(&peer));

    esp_now_rate_config_t rate = {          /* facoltativo */
        .phymode = WIFI_PHY_MODE_HT20,
        .rate    = WIFI_PHY_RATE_MCS0_LGI,  /* 6,5 Mbit/s in HT20 */
    };
    ESP_ERROR_CHECK(esp_now_set_peer_rate_config(mac, &rate));
}

Ack applicativo e ritrasmissioni

Ogni messaggio porta un tipo e un numero di sequenza; il ricevitore, quando l’ha davvero elaborato, risponde con un ack con lo stesso numero. Il mittente aspetta poco e, se l’ack non arriva, ritrasmette.

typedef struct __attribute__((packed)) {
    uint8_t  tipo;       /* MSG_DATI oppure MSG_ACK */
    uint16_t seq;
    uint8_t  payload[];
} msg_t;

static QueueHandle_t coda_ack;   /* riempita dal task che legge coda_rx */

bool invia_affidabile(const uint8_t *mac, const msg_t *m, size_t len)
{
    for (int tentativo = 0; tentativo < 3; tentativo++) {
        if (esp_now_send(mac, (const uint8_t *)m, len) != ESP_OK) {
            vTaskDelay(pdMS_TO_TICKS(10));   /* es. ESP_ERR_ESPNOW_NO_MEM */
            continue;
        }
        uint16_t seq_ack;
        if (xQueueReceive(coda_ack, &seq_ack, pdMS_TO_TICKS(30)) == pdTRUE && seq_ack == m->seq)
            return true;
    }
    return false;
}

Tempi e tentativi vanno tarati sulla finestra di risveglio del ricevitore, con le due regole del pulsante.

Deduplica

Se si perde l’ack, il ricevitore vede due volte lo stesso messaggio: innocuo per una misura, non per “aumenta di un grado”. Il ricevitore tiene l’ultimo numero di sequenza di ogni mittente e, se arriva un doppione, rimanda l’ack senza eseguire. L’esempio ufficiale aggiunge anche un CRC e un numero “magic” casuale; il componente esp-now ha un campo magic per i duplicati.

Abbinamento e provisioning

Lo schema più semplice da spiegare: si tiene premuto un tasto sul gateway, che per 30 secondi accetta nuovi nodi; il nodo manda un broadcast “ci sono” e viene registrato. Il punto delicato è la chiave, che non può viaggiare in un broadcast in chiaro: o la si carica in fabbrica via USB, o si usa l’handshake ECDH con Proof of Possession del componente esp-now. Il componente offre anche il provisioning Wi-Fi via ESP-NOW: il primo dispositivo si configura dal telefono e passa SSID e password agli altri. Nell’esempio ufficiale però l’autenticazione di chi chiede le credenziali non c’è: in un prodotto va aggiunta.

Il canale quando il gateway è anche station

Ricerca del canale sui nodi: il nodo prova sul canale salvato e, senza ack, passa agli altri. È l’auto channel switching del componente esp-now, che rispetta i canali del codice paese impostato con esp_wifi_set_country() (il default “01” usa i canali 1-11). Funziona, ma costa batteria.
Canale fisso sul router, se il router è nostro: evita quasi tutte le ricerche.
Gateway a due chip: un ESP32 solo per ESP-NOW su canale fisso e uno per Wi-Fi e MQTT, collegati via UART. Un chip in più, ma i nodi non dipendono dal router.

ESP-IDF v6.0 ha aggiunto esp_now_switch_channel_tx() e esp_now_remain_on_channel(), per trasmettere o ascoltare per un tempo limitato su un altro canale. Promettenti per i gateway; non le abbiamo ancora provate.

Il gateway ESP-NOW → MQTT

I nodi a batteria parlano ESP-NOW con il gateway, che è anche station Wi-Fi e pubblica su un broker MQTT, da cui leggono Home Assistant e le app. I comandi fanno la strada inversa e il gateway li consegna quando il nodo è in ascolto.

Architettura del gateway: pulsanti, sensori e attuatori ESP-NOW collegati a un gateway ESP32 che è anche station Wi-Fi; il gateway raggiunge il router e da lì il broker MQTT, Home Assistant e le app; variante con due chip collegati via UART — L’architettura che proponiamo: ack, deduplica e coda dei comandi stanno nel gateway.

un topic per nodo basato sul MAC, per esempio espnow/<mac>/stato e espnow/<mac>/comando;
il gateway pubblica anche RSSI e ritrasmissioni di ogni nodo: pochi byte che valgono oro quando qualcosa si guasta;
i comandi per un nodo che dorme restano in coda fino alla sua finestra;
messaggi sotto i 250 byte finché in rete c’è anche un solo nodo v1.0.

Precisazione doverosa: un gateway ESP-NOW generico non è un prodotto Espressif, e nel componente esp-now è ancora nella lista delle cose da fare. Espressif fornisce un bridge verso Matter (in esp-matter), il ricevitore dell’application note. Il gateway MQTT lo scriviamo noi.

OTA e diagnostica

Nel componente esp-now un dispositivo scarica il firmware da un server HTTP e lo distribuisce agli altri a pezzi: riprende dopo un’interruzione, aggiorna più nodi insieme e torna indietro se qualcosa va storto. Espressif dichiara 50 dispositivi in 3 minuti, senza dire in quali condizioni. Per la diagnostica ci sono l’RSSI di ogni pacchetto (info->rx_ctrl->rssi), i nostri contatori di ritrasmissioni ed errori e il modulo di debug del componente, con log remoti, console di comandi e test con iperf: comodo quando il nodo è sul balcone o in un quadro elettrico.

Chip supportati

Chip	ESP-NOW in ESP-IDF v6.1	Note
ESP32, ESP32-S2, ESP32-S3, ESP32-C3	sì
ESP32-C2	sì	al massimo 4 peer cifrati; niente Long Range
ESP32-C5	sì	anche a 5 GHz; Long Range solo a 2,4 GHz
ESP32-C6, ESP32-C61	sì	sul C61 Long Range non menzionato
ESP32-S31	pagina di documentazione presente	supporto da verificare
ESP32-H2 (e H4, H21)	no	non hanno il Wi-Fi
ESP32-P4	nessun supporto documentato	niente radio; Espressif non dichiara ESP-NOW tramite il coprocessore Wi-Fi
ESP8266	sì, fuori da ESP-IDF	con il proprio SDK

Su Arduino, il core ESP32 dalla versione 3.0.0 ha una libreria ESP-NOW ufficiale. Per un supervisore ESP32-P4, finché manca una dichiarazione ufficiale, la strada prudente è un ESP32-C6 accanto che fa ESP-NOW e parla con il P4 via UART: una nostra scelta di progetto, non una soluzione Espressif.

Licenze

ESP-IDF e il componente esp-now sono Apache-2.0. La parte radio, compresa libespnow.a, arriva precompilata dal repository esp32-wifi-lib, sotto la stessa licenza in forma “oggetto”: uso libero, anche commerciale, ma senza il sorgente dello stack. Per la FAQ, l’uso commerciale di ESP-NOW non richiede procedure particolari.

Dove lo usiamo

Per ora in nessun progetto: ESP-NOW compare solo nel piano editoriale della sezione ESP32, con una “mini rete di sensori senza router” in programma. Ecco dove potrebbe avere senso, come proposta:

Irrigazione: sensori a batteria nella mini-serra, o un pulsante “annaffia adesso”, potrebbero parlare con il nodo ESP32-C6 delle elettrovalvole senza cavi in più.
Cheap, il robot: niente ESP32 a bordo, ma la Cheap-shield prevede un modulo ESP32-C6 opzionale; un telecomando con un C6, se servirà, potrebbe parlargli in ESP-NOW.
Padel: oggi è previsto un access point Wi-Fi a bordo campo; se l’hub fosse un ESP32-C6, ESP-NOW sarebbe un’alternativa da valutare.
Stazione meteo: una variante ESP-NOW eviterebbe l’associazione al router a ogni risveglio, ma senza una guida ufficiale su ESP-NOW e deep sleep va prima provata al banco.

I progetti sono nelle sezioni ESP32 e Domotica. ESP32-C6, ESP32-H2 ed ESP32-P4 hanno ciascuno il proprio articolo in questa serie (pubblicazione in arrivo).

Per approfondire

ESP-NOW, riferimento API (ESP-IDF v6.1)
Driver Wi-Fi, panoramica (ESP-IDF v6.1): Long Range, chiavi hardware, prestazioni
Prestazioni e risparmio energetico del Wi-Fi (ESP-IDF v6.1)
Coesistenza RF (ESP-IDF v6.1)
Esempio examples/wifi/espnow (ESP-IDF v6.1)
ESP-FAQ: ESP-NOW
Componente esp-now e registro dei componenti (versione 2.5.3)
Application note “Coin Cell Button Design and Operations”
Soluzioni ESP-NOW (Espressif)
Libreria ESP-NOW per Arduino (blog Espressif Developer)