Guida Completa ai Gateway Ecowitt GW1100 / GWI100: Installazione, Configurazione e Gestione dei Sensori

I gateway Ecowitt della serie GWI100 / GW1100 rappresentano il cuore di una stazione meteo personale moderna. Questi dispositivi raccolgono i dati provenienti dai sensori wireless Ecowitt e li inviano sia alla rete locale sia ai principali servizi meteorologici online. In questa guida completa scoprirai come configurarli, come collegare i sensori e come sfruttare tutte le funzioni disponibili.


Cos’è il Gateway Ecowitt GW1100 / GWI100

Il GW1100 è un piccolo hub Wi‑Fi che riceve i dati dai sensori Ecowitt (temperatura, umidità, vento, pioggia, UV, luminosità, ecc.) e li rende disponibili:

  • tramite pagina web interna
  • tramite app Ecowitt
  • sul portale ecowitt.net
  • su servizi meteo esterni come Wunderground, WeatherCloud, WOW
  • su server personalizzati

È compatto, facile da configurare e compatibile con un’ampia gamma di sensori Ecowitt.


1. Prima Accensione e Accesso al Dispositivo

1.1 Avvio del gateway

Dopo aver alimentato il dispositivo:

  • attendi l’accensione
  • premi il pulsante RESET per 5 secondi per entrare in modalità configurazione

1.2 Connessione al Wi‑Fi del gateway

Il dispositivo crea un access point temporaneo:

GWI100X-XXXXXXXX

Collegati con il tuo smartphone.

1.3 Accesso alla pagina web

Apri il browser e digita:

192.168.4.1

Al primo accesso non è richiesta alcuna password.


2. Configurazione del Dispositivo

2.1 Impostazioni principali

Dalla pagina Device Setting puoi configurare:

  • Nome del dispositivo
  • Fuso orario
  • Localizzazione
  • Unità di misura
  • Password di accesso (opzionale)

Se abiliti Auto Timezone, ricordati di impostare il fuso orario corretto anche su ecowitt.net.


3. Collegamento alla Rete Wi‑Fi Domestica

3.1 Configurazione rete locale

Nella sezione Local Network:

  1. seleziona la tua rete Wi‑Fi
  2. inserisci la password
  3. premi Apply
  4. verifica che il gateway abbia ottenuto un indirizzo IP

4. Invio dei Dati ai Servizi Meteo

Il gateway può inviare i dati a diversi servizi online.

4.1 Ecowitt.net

È il servizio principale e più completo.

Per configurarlo:

  • copia il MAC address del gateway
  • registrati su ecowitt.net
  • aggiungi il dispositivo
  • imposta l’intervallo di upload (minimo 1 minuto)

4.2 Wunderground, WeatherCloud, WOW

Per ciascun servizio devi inserire:

  • Station ID
  • Station Key

4.3 Server personalizzato

Puoi inviare i dati anche a un tuo server:

  • protocollo Ecowitt o Wunderground
  • IP/hostname
  • path (es. /data/report/)
  • porta
  • intervallo di upload

5. Gestione dei Sensori Ecowitt

Il gateway supporta numerosi sensori. Ecco i principali:

5.1 Sensori di temperatura e umidità

  • WH31: multicanale (fino a 8 canali)
  • WH32: sensore esterno prioritario

5.2 Sensori di pioggia

  • WH40: pluviometro con livella a bolla

5.3 Sensori di vento

  • WS68: anemometro + UV + luce
  • WS80: anemometro ultrasonico

5.4 Sensori combinati

  • WS69: array completo (vento, pioggia, T/H, UV, luce)

6. Installazione dei Sensori

Il manuale raccomanda:

  • installare i sensori in giornate asciutte
  • verificare la ricezione del segnale prima del montaggio definitivo
  • evitare ostacoli metallici
  • montare il sensore del vento in posizione elevata
  • mantenere il pluviometro perfettamente in bolla

7. Avvertenze Importanti

  • Non installare durante un temporale
  • I pali metallici possono attirare fulmini
  • Valuta la messa a terra se monti su un edificio
  • Esegui test preliminari a terra

Conclusione

Il gateway Ecowitt GW1100/GWI100 è uno strumento potente e versatile per creare una stazione meteo completa e affidabile. Con pochi passaggi puoi configurarlo, collegarlo alla rete, aggiungere sensori e inviare i dati ai principali servizi meteorologici.

Questa guida ti permette di sfruttare al massimo tutte le funzioni del dispositivo.

Il Motore della Previsione Solare: Un’Analisi Passo-Passo delle Formule dietro i Pannelli Fotovoltaici ☀️🔬


👋 Introduzione: Quando la Tecnologia Prevede il Futuro

Hai mai voluto sapere non solo quanta energia produce oggi il tuo impianto solare, ma quanto potrebbe produrre nel momento esatto? Questo è il potere dei “Template” avanzati che utilizziamo nei sistemi di casa intelligente. Questi Template sono veri e propri mini-calcolatori, scritti in un linguaggio chiamato Jinja2, capaci di trasformare semplici letture meteo (come l’intensità del sole o la temperatura) in una previsione molto dettagliata della potenza reale prodotta dal tuo impianto FV.

In questo articolo, smonteremo questa “ricetta digitale” per capire esattamente quali formule vengono usate e perché ogni piccolo numero conta. Prepariamoci a fare un viaggio didattico tra fisica e tecnologia!

🧱 La Struttura: Ingredienti e Obiettivo

Il template ha due compiti principali:

  1. Controllare la Salute: Verificare che tutti i dati di ingresso siano presenti e validi.
  2. Simulare la Produzione: Usando le leggi della fisica, calcolare quanta energia il pannello riceve e quanta ne riesce a trasformare.

Gli Ingredienti Necessari (I Dati Iniziali)

Il sistema parte da due letture chiave dai sensori esterni:

  • GrawGraw​: L’intensità della luce solare che arriva sull’area di misura (Irradiazione GlobaleIrradiazione Globale).
  • TrawTraw​: La temperatura dell’aria all’esterno.

📐 Analisi Passo-Passo: Le Formule Semplificate (Il Cuore del Template)

Il template non fa un singolo calcolo, ma una catena di trasformazioni. Vediamo i passaggi chiave e le formule che li guidano.

Fase 1: Preparazione della Luce

Prima di tutto, dobbiamo capire quanta luce è davvero utile per il pannello e come questa luce cade su di esso.

  • Aggiustamento dell’Altezza (GG): Il template prende l’intensità grezza (GrawGraw​) e la corregge leggermente con un fattore (sensor_height_factor = 0.98). Cosa significa? È una piccola correzione per tenere conto del fatto che il sensore non è perfettamente allineato o misurato alla stessa altezza dell’impianto reale. G=Graw×0.98G=Graw​×0.98
  • La Distribuzione della Luce (DiffuseDiffuse vs DirectDirect): Il sole non è sempre un fascio dritto e perfetto; a volte la luce viene “sparsa” dall’atmosfera.
    • Il template calcola una frazione diffusa basandosi su quanto forte sta brillando il cielo (clearnessclearness). Questa frazione ci dice quanta luce arriva da tutte le direzioni, non solo dal punto esatto del sole.
    • Successivamente, usa i dati di orientamento (tilt_deg=30tilt_deg=30∘) per capire quanto è efficace la superficie del pannello a catturare quella luce diretta e diffusa.

Fase 2: Calcolare l’Energia Reale sul Pannello (GPOAGPOA​)

Questo è il passaggio fondamentale! Stiamo chiedendo: “Quanta energia colpisce davvero la superficie orientata del pannello?”

Il template mescola le frazioni di luce diretta, diffusa e riflessa dal terreno (l’albedo) con i fattori geometrici legati all’angolo di inclinazione ($30^\circ$). La formula combina questi elementi per ottenere GPOAGPOA​:

GPOA=G×(Frazione Diretta×Fattore Diretto+Frazione Diffusa×Fattore Diffuso+Riflesso Terreno×Fattore Riflesso)GPOA​=G×(Frazione Diretta×Fattore Diretto+Frazione Diffusa×Fattore Diffuso+Riflesso Terreno×Fattore Riflesso)

In parole semplici: Stiamo dando al sistema una mappa precisa di come la luce cade sul pannello, tenendo conto sia dell’orientamento che del tipo di cielo.

Fase 3: La Potenza Iniziale (Dal Calore alla Forza)

Una volta che sappiamo quanta energia colpisce il pannello (GPOAGPOA​), dobbiamo trasformarla in Watt. Usiamo la potenza nominale massima (PSTC_totalPSTC_total​, ovvero quanto produce l’impianto in condizioni perfette di laboratorio) e la confrontiamo con l’irradiazione ricevuta:

Potenza Iniziale=(GPOA1000.0)×PSTC_totalPotenza Iniziale=(1000.0GPOA​​)×PSTC_total​ (Il diviso per 1000 serve perché le nostre misurazioni sono spesso in W/m2W/m2, mentre la potenza nominale è espressa su tutta l’area del modulo).

Fase 4: La Correzione Finale (L’Effetto della Temperatura)

Questo è il tocco di finitura. Anche se tutto va bene, quando i pannelli si scaldano troppo, diventano meno efficienti. Il template simula questo calore e applica una “penalità” basata sul delta termico (ΔT=Temperatura Cella25CΔT=Temperatura Cella−25∘C).

La formula di correzione finale è questa: Potenza Corretta=Potenza Iniziale×(1+γpΔT)Potenza Corretta=Potenza Iniziale×(1+γp​⋅ΔT)

Spiegazione Semplice: Se il pannello si scalda molto (ΔTΔT alto), e γpγp​ è un numero negativo, la parentesi (1+...)(1+…) diventa minore di 1, riducendo artificialmente la potenza calcolata. Questo assicura che la nostra previsione sia realistica.

✅ Conclusione: Un Modello Potente ma Semplificato

Il template è estremamente potente perché automatizza un processo che, se lo facessi a mano, richiederebbe ore di calcoli trigonometrici e termici!

Cosa abbiamo imparato? Abbiamo visto che il valore finale in Watt non dipende solo da “quanto c’è sole”, ma da: come cade la luce sul mio pannello (GPOAGPOA​), e quanto è caldo quel pannello (Correzione Termica).

È un esempio brillante di come i dati, quando vengono incartati con una buona dose di logica scolastica e fisica, possano trasformarsi in strumenti di previsione super diretti per la nostra vita quotidiana.

template:
  - sensor:
      - name: "FV Potenza Teorica Reale"
        unique_id: fv_potenza_teorica_reale
        unit_of_measurement: "W"
        device_class: power
        state_class: measurement
        state: >
          {% set G_raw = states('sensor.gw1100a_solar_radiation') %}
          {% set T_raw = states('sensor.gw1100a_outdoor_temperature') %}
          {% if G_raw in ['unknown','unavailable','none'] or T_raw in ['unknown','unavailable','none'] %}
            unavailable
          {% else %}
            {% set modules_count = 4 %}
            {% set P_stc_module = 585.0 %}
            {% set area_module = 2.582 %}
            {% set eta = 0.2266 %}
            {% set noct = 45 %}
            {% set gamma_p = -0.003 %}
            {% set tilt_deg = 30 %}
            {% set albedo = 0.20 %}
            {% set sensor_height_factor = 0.98 %}
            {% set G = (G_raw | float(0)) * sensor_height_factor %}
            {% set T_amb = (T_raw | float(20)) %}
            {% set _ = states('sensor.time') %}
            {% set area_total = area_module * modules_count %}
            {% set clearness = G / 1000.0 %}
            {% set df_raw = 0.45 + (1 - clearness) * 0.35 %}
            {% set diffuse_frac = [df_raw, 0.9] | min %}
            {% set diffuse_frac = [diffuse_frac, 0.1] | max %}
            {% set direct_frac = 1.0 - diffuse_frac %}
            {% set tilt_rad = (tilt_deg * pi / 180.0) %}
            {% set direct_factor = [ (cos(tilt_rad)), 0.0 ] | max %}
            {% set diffuse_factor = (1.0 + cos(tilt_rad)) / 2.0 %}
            {% set ground_reflect_factor = (1.0 - cos(tilt_rad)) / 2.0 %}
            {% set G_poa = G * ( direct_frac * direct_factor + diffuse_frac * diffuse_factor + albedo * ground_reflect_factor ) %}
            {% set P_stc_total = P_stc_module * modules_count %}
            {% set P_from_irradiance = (G_poa / 1000.0) * P_stc_total %}
            {% set T_cell = T_amb + (G_poa / 800.0) * (noct - 20.0) %}
            {% set deltaT = T_cell - 25.0 %}
            {% set P_temp_corr = P_from_irradiance * (1.0 + gamma_p * deltaT) %}
            {{ [ (P_temp_corr) | round(0), 0 ] | max }}
          {% endif %}

.

✨ Sistema RFID con ESP32, RC522, OLED, Relè, LED e Buzzer

Una guida completa per realizzare un accesso elettronico affidabile, elegante e totalmente integrato con ESPHome.

🔧 Componenti necessari

  • ESP32 DevKit
  • Lettore RFID RC522 (SPI)
  • Display OLED SSD1306 128×64 (I2C)
  • Modulo relè 5V
  • LED verde + LED rosso (con resistenze 220–330 Ω)
  • Buzzer attivo a 3 pin
  • Alimentazione 5V
  • Cavi dupont

🧩 Collegamenti elettrici

Tabella completa dei collegamenti ESP32 → Componenti

RC522 (SPI)

Funzione RC522Pin RC522Pin ESP32
AlimentazioneVCC3.3V
MassaGNDGND
ResetRSTGPIO22
SS / SDASDAGPIO5
SCKSCKGPIO18
MOSIMOSIGPIO23
MISOMISOGPIO19


Display OLED SSD1306 (I2C)

Funzione OLEDPin OLEDPin ESP32
AlimentazioneVCC3.3V
MassaGNDGND
SDASDAGPIO21
SCLSCLGPIO17


LED di stato

LEDAnodo → ESP32Catodo →
VerdeGPIO14 (via resistenza)GND
RossoGPIO27 (via resistenza)GND


Relè cancello

FunzionePin modulo relèPin ESP32
SegnaleINGPIO32
AlimentazioneVCC5V
MassaGNDGND


Buzzer attivo 3 pin

FunzionePin buzzerPin ESP32
AlimentazioneVCC5V
MassaGNDGND
SegnaleI/OGPIO26

💡 Funzionamento del sistema

  • Quando un tag RFID viene avvicinato, l’ESP32 legge l’UID tramite il modulo RC522.
  • Se il tag è autorizzato:
    • Il relè invia un impulso per aprire il cancello
    • Il LED verde si accende per 8 secondi
    • Il display mostra “ACCESSO CONSENTITO”
    • Il buzzer emette due beep
  • Se il tag non è autorizzato:
    • Il LED rosso si accende per 8 secondi
    • Il display mostra “ACCESSO NEGATO”
    • Il buzzer emette tre beep rapidi

🧠 Codice ESPHome completo e funzionante

esphome:
  name: esphome-web-568b34
  friendly_name: Esp32 RFID
  min_version: 2025.11.0
  name_add_mac_suffix: false
  on_boot:
    priority: -100
    then:
      - switch.turn_on: rele

esp32:
  variant: esp32
  framework:
    type: esp-idf

logger:
  level: DEBUG

api:

ota:
  platform: esphome

wifi:
  ssid: "xxx"
  password: "sxxxxx"

spi:
  clk_pin: 18
  mosi_pin: 23
  miso_pin: 19

rc522_spi:
  cs_pin: 5
  reset_pin: 22
  update_interval: 1s
  on_tag:
    then:
      - lambda: |-
          std::string uid = x;

          uint32_t now = millis();
          if (now - id(ultimo_lettura) < 2000) {
            return;
          }
          id(ultimo_lettura) = now;

          ESP_LOGI("rfid", "Tag rilevato: %s", uid.c_str());

          id(ultimo_tag).publish_state(uid);

          for (auto &t : id(tag_autorizzati)) {
            if (t == uid) {
              ESP_LOGI("rfid", "Accesso consentito");

              id(accesso_consentito).publish_state(true);
              id(accesso_negato).publish_state(false);

              id(led_ok).execute();
              id(display_ok).execute();

              return;
            }
          }

          ESP_LOGW("rfid", "Accesso negato");

          id(accesso_consentito).publish_state(false);
          id(accesso_negato).publish_state(true);

          id(led_ko).execute();
          id(display_ko).execute();

globals:
  - id: tag_autorizzati
    type: std::vector<std::string>
    initial_value: '{"67-89-90-C9", "67-FA-0A-c9"}'

  - id: ultimo_lettura
    type: uint32_t
    initial_value: '0'

output:
  - platform: gpio
    pin: 14
    id: led_verde_pin

  - platform: gpio
    pin: 27
    id: led_rosso_pin

script:
  - id: led_ok
    then:
      - switch.turn_on: buzzer
      - delay: 120ms
      - switch.turn_off: buzzer
      - delay: 120ms
      - switch.turn_on: buzzer
      - delay: 120ms
      - switch.turn_off: buzzer

      - switch.turn_off: rele
      - delay: 1s
      - switch.turn_on: rele

      - light.turn_on: led_verde
      - delay: 8s
      - light.turn_off: led_verde
      - lambda: |-
          id(accesso_consentito).publish_state(false);

  - id: led_ko
    then:
      - switch.turn_on: buzzer
      - delay: 80ms
      - switch.turn_off: buzzer
      - delay: 80ms
      - switch.turn_on: buzzer
      - delay: 80ms
      - switch.turn_off: buzzer
      - delay: 80ms
      - switch.turn_on: buzzer
      - delay: 80ms
      - switch.turn_off: buzzer

      - light.turn_on: led_rosso
      - delay: 8s
      - light.turn_off: led_rosso
      - lambda: |-
          id(accesso_negato).publish_state(false);

  - id: display_ok
    then:
      - display.page.show: page_ok
      - delay: 8s
      - display.page.show: page_idle

  - id: display_ko
    then:
      - display.page.show: page_ko
      - delay: 8s
      - display.page.show: page_idle

light:
  - platform: binary
    id: led_verde
    name: "LED Verde RFID"
    output: led_verde_pin

  - platform: binary
    id: led_rosso
    name: "LED Rosso RFID"
    output: led_rosso_pin

switch:
  - platform: gpio
    id: rele
    name: "Relè Cancello"
    pin:
      number: 32
      inverted: true
    restore_mode: ALWAYS_ON

  - platform: gpio
    id: buzzer
    name: "Buzzer RFID"
    pin:
      number: 26
    restore_mode: ALWAYS_OFF

text_sensor:
  - platform: template
    id: ultimo_tag
    name: "Ultimo TAG RFID"
  - platform: wifi_info
    ip_address:
      name: "ESP32 IP Address"
    ssid:
      name: "ESP32 WiFi SSID"
  - platform: version
    name: "Firmware ESPHome"

button:
  - platform: restart
    id: riavvia_esp
    name: "Riavvia Proxy ESP32"

binary_sensor:
  - platform: template
    id: accesso_consentito
    name: "Accesso RFID Consentito"

  - platform: template
    id: accesso_negato
    name: "Accesso RFID Negato"

i2c:
  sda: 21
  scl: 17
  scan: true

font:
  - file: "gfonts://Roboto"
    id: font1
    size: 20

display:
  - platform: ssd1306_i2c
    model: "SSD1306 128x64"
    address: 0x3C
    id: oled
    pages:
      - id: page_idle
        lambda: |-
          it.printf(0, 0, id(font1), "RFID");
          it.printf(0, 28, id(font1), "READY");

      - id: page_ok
        lambda: |-
          it.printf(0, 0, id(font1), "ACCESSO");
          it.printf(0, 28, id(font1), "CONSENTITO");

      - id: page_ko
        lambda: |-
          it.printf(0, 0, id(font1), "ACCESSO");
          it.printf(0, 28, id(font1), "NEGATO");

sensor:
  - platform: uptime
    name: Uptime Sensor
    filters:
      - lambda: return x / 3600;
    unit_of_measurement: "h"
    accuracy_decimals: 2

Sistema RFID con ESP32, RC522 e Display OLED

Questo progetto realizza un sistema RFID completo basato su ESP32, pensato per il controllo accessi e perfettamente integrabile con Home Assistant. Il dispositivo utilizza un lettore RC522 per rilevare i tag RFID, un display OLED per mostrare lo stato del sistema e due LED per fornire un feedback visivo immediato all’utente.

Il cuore del progetto è il firmware sviluppato con ESPHome, che gestisce in modo autonomo la lettura dei badge, la verifica delle autorizzazioni e la visualizzazione delle informazioni. Quando un tag viene avvicinato al lettore, il sistema ne acquisisce l’UID e lo confronta con una lista interna di codici autorizzati. Se il badge è valido, il dispositivo segnala l’accesso consentito tramite il LED verde e una schermata dedicata sul display. In caso contrario, viene mostrato un messaggio di accesso negato e si attiva il LED rosso.

Per evitare letture ripetute dello stesso tag, è presente un sistema di controllo che introduce un intervallo minimo tra una scansione e l’altra. Questo rende il comportamento più stabile e impedisce attivazioni multiple indesiderate.

Il display OLED svolge un ruolo importante nell’esperienza utente: mostra lo stato di attesa, conferma l’accesso o segnala un rifiuto, con testi chiari e ben leggibili. I LED completano il feedback visivo, rendendo il sistema utilizzabile anche senza guardare il display.

Il firmware espone inoltre diversi sensori utili per l’integrazione con Home Assistant, come l’ultimo tag letto, lo stato dell’accesso, l’indirizzo IP del dispositivo e il tempo di attività. Questo permette di creare automazioni avanzate, registrare gli accessi o attivare scenari personalizzati.

Il risultato è un sistema RFID affidabile, semplice da usare e completamente personalizzabile, ideale per progetti di domotica, controllo accessi domestici o piccoli sistemi di sicurezza.

📌 Collegamenti RC522 (SPI → ESP32)

RC522ESP32
SDA / CSGPIO 5
SCKGPIO 18
MOSIGPIO 23
MISOGPIO 19
RSTGPIO 22
3.3V3.3V
GNDGND

📌 Collegamenti Display OLED SSD1306 (I2C → ESP32)

OLEDESP32
SDAGPIO 21
SCLGPIO 17
VCC3.3V
GNDGND

📌 Collegamenti LED di Stato

LEDESP32
LED VerdeGPIO 14
LED RossoGPIO 27

📌 Riepilogo Pin Utilizzati

FunzionePin ESP32
SPI CLK18
SPI MOSI23
SPI MISO19
RC522 CS5
RC522 RST22
I2C SDA21
I2C SCL17
LED Verde14
LED Rosso27
esphome:
  name: esphome-web-568b34
  friendly_name: Esp32 RFID
  min_version: 2025.11.0
  name_add_mac_suffix: false

esp32:
  variant: esp32
  framework:
    type: esp-idf

logger:
  level: DEBUG

api:

ota:
  platform: esphome

wifi:
  ssid: "xxxxxxxxx"
  password: "xxxxxxxx"

# ---------------- SPI + RC522 ----------------
spi:
  clk_pin: 18
  mosi_pin: 23
  miso_pin: 19

rc522_spi:
  cs_pin: 5
  reset_pin: 22
  update_interval: 1s
  on_tag:
    then:
      - lambda: |-
          std::string uid = x;

          // --- ANTILOOP: evita letture ripetute entro 2 secondi ---
          uint32_t now = millis();
          if (now - id(ultimo_lettura) < 2000) {
            return;
          }
          id(ultimo_lettura) = now;

          ESP_LOGI("rfid", "Tag rilevato: %s", uid.c_str());

          // Aggiorna sensore ultimo tag
          id(ultimo_tag).publish_state(uid);

          // Controllo accesso
          for (auto &t : id(tag_autorizzati)) {
            if (t == uid) {
              ESP_LOGI("rfid", "Accesso consentito");

              id(accesso_consentito).publish_state(true);
              id(accesso_negato).publish_state(false);

              id(led_ok).execute();
              id(display_ok).execute();

              return;
            }
          }

          ESP_LOGW("rfid", "Accesso negato");

          id(accesso_consentito).publish_state(false);
          id(accesso_negato).publish_state(true);

          id(led_ko).execute();
          id(display_ko).execute();

# ---------------- Lista badge autorizzati ----------------
globals:
  - id: tag_autorizzati
    type: std::vector<std::string>
    initial_value: '{"67-89-90-C9", "67-FA-0A-c9"}'

  # --- Cooldown letture RFID ---
  - id: ultimo_lettura
    type: uint32_t
    initial_value: '0'

# ---------------- OUTPUT (LED) ----------------
output:
  - platform: gpio
    pin: 14
    id: led_verde_pin

  - platform: gpio
    pin: 27
    id: led_rosso_pin
  
# ---------------- Script vari ----------------
script:
  - id: led_ok
    then:
      - light.turn_on: led_verde
      - delay: 15s
      - light.turn_off: led_verde
      - lambda: |-
          id(accesso_consentito).publish_state(false);

  - id: led_ko
    then:
      - light.turn_on: led_rosso
      - delay: 15s
      - light.turn_off: led_rosso
      - lambda: |-
          id(accesso_negato).publish_state(false);

  # --- SCRIPT DISPLAY OK ---
  - id: display_ok
    then:
      - display.page.show: page_ok
      - delay: 15s
      - display.page.show: page_idle

  # --- SCRIPT DISPLAY KO ---
  - id: display_ko
    then:
      - display.page.show: page_ko
      - delay: 15s
      - display.page.show: page_idle
  
# ---------------- LED verde e rosso ----------------
light:
  - platform: binary
    id: led_verde
    name: "LED Verde RFID"
    output: led_verde_pin

  - platform: binary
    id: led_rosso
    name: "LED Rosso RFID"
    output: led_rosso_pin

# ---------------- SENSORI RFID AGGIUNTI ----------------
text_sensor:
  - platform: template
    id: ultimo_tag
    name: "Ultimo TAG RFID"
  - platform: wifi_info
    ip_address:
      name: "ESP32 IP Address"
    ssid:
      name: "ESP32 WiFi SSID"
  - platform: version
    name: "Firmware ESPHome"           

button:
  - platform: restart
    id: riavvia_esp
    name: "Riavvia Proxy ESP32"  
          
binary_sensor:
  - platform: template
    id: accesso_consentito
    name: "Accesso RFID Consentito"

  - platform: template
    id: accesso_negato
    name: "Accesso RFID Negato"

# ---------------- OLED SSD1306 ----------------
i2c:
  sda: 21
  scl: 17
  scan: true

font:
  - file: "gfonts://Roboto"
    id: font1
    size: 20

display:
  - platform: ssd1306_i2c
    model: "SSD1306 128x64"
    address: 0x3C
    id: oled
    pages:
      - id: page_idle
        lambda: |-
          it.printf(0, 0, id(font1), "RFID");
          it.printf(0, 28, id(font1), "READY");

      - id: page_ok
        lambda: |-
          it.printf(0, 0, id(font1), "ACCESSO");
          it.printf(0, 28, id(font1), "CONSENTITO");

      - id: page_ko
        lambda: |-
          it.printf(0, 0, id(font1), "ACCESSO");
          it.printf(0, 28, id(font1), "NEGATO");

sensor:
  - platform: uptime
    name: Uptime Sensor
    filters:
      - lambda: return x / 3600;
    unit_of_measurement: "h"
    accuracy_decimals: 2

Monitorare un Victron SmartSolar con ESP32, ESPHome e Display OLED SSD1306

Integrare un regolatore Victron SmartSolar con un ESP32 permette di ottenere un monitoraggio locale, immediato e completamente personalizzabile dei parametri principali del proprio impianto fotovoltaico. Questo documento descrive un sistema compatto che legge via BLE i dati del Victron, li elabora con ESPHome e li visualizza su un display OLED SSD1306.

Perché usare un ESP32 con ESPHome

L’ESP32 è un microcontrollore economico, potente e dotato di Bluetooth Low Energy. ESPHome semplifica la configurazione e consente di:

  • Leggere i dati via BLE dal regolatore Victron.
  • Inviarli a Home Assistant.
  • Visualizzarli su un display locale.
  • Creare logiche personalizzate.
  • Aggiornare il firmware OTA.

Il display SSD1306

Il display OLED SSD1306 (128×64 pixel) è ideale per visualizzare informazioni essenziali:

  • Consumo ridotto.
  • Ottima leggibilità.
  • Collegamento semplice tramite I2C.
  • Supporto nativo in ESPHome.

Nel progetto vengono visualizzati ciclicamente:

  1. PV Power (W)
  2. Battery Voltage (V)
  3. Battery Current (A)
  4. Stato MPPT

Collegamenti hardware

SSD1306 → ESP32
SDA     → GPIO 21
SCL     → GPIO 22
VCC     → 3.3V o 5V (in base al modulo)
GND     → GND

Codice completo ESPHome

esphome:
  name: esphome-web-660f74
  friendly_name: Victron 35
  min_version: 2025.11.0
  name_add_mac_suffix: false

esp32:
  variant: esp32
  framework:
    type: esp-idf

logger:
  level: INFO

api:

ota:
  - platform: esphome

wifi:
  networks:
    - ssid: xxx
      password: xxxx

esp32_ble_tracker:

external_components:
  - source: github://Fabian-Schmidt/esphome-victron_ble

victron_ble:
  - id: MySmartSolar
    mac_address: "de630e81b151"
    bindkey: "9d9701c7ec7acd40e063725bc6ce5591"

sensor:
  - platform: victron_ble
    victron_ble_id: MySmartSolar
    name: "PV Power"
    id: pv_power
    type: PV_POWER

  - platform: victron_ble
    victron_ble_id: MySmartSolar
    name: "Battery Voltage"
    id: battery_voltage
    type: BATTERY_VOLTAGE

  - platform: victron_ble
    victron_ble_id: MySmartSolar
    name: "Battery Current"
    id: battery_current
    type: BATTERY_CURRENT

  - platform: internal_temperature
    name: "Temperatura interna"
    id: internal_temp
    update_interval: 60s

text_sensor:
  - platform: victron_ble
    victron_ble_id: MySmartSolar
    name: "MPPT state"
    id: mppt_state
    type: DEVICE_STATE

  - platform: wifi_info
    ip_address:
      name: "ESP32 IP Address"
    ssid:
      name: "ESP32 WiFi SSID"

  - platform: version
    name: "Firmware ESPHome"

i2c:
  sda: 21
  scl: 22
  scan: true

font:
  - file: "gfonts://Roboto"
    id: my_font
    size: 17

globals:
  - id: lcd_page
    type: int
    restore_value: no
    initial_value: '0'

interval:
  - interval: 5s
    then:
      - lambda: |-
          id(lcd_page)++;
          if (id(lcd_page) > 3) id(lcd_page) = 0;

display:
  - platform: ssd1306_i2c
    model: "SSD1306 128x64"
    address: 0x3C
    lambda: |-
      int page = id(lcd_page);

      if (page == 0) {
        it.printf(0, 0, id(my_font), "PV Power:");
        it.printf(0, 20, id(my_font), "%.1f W", id(pv_power).state);
      }

      if (page == 1) {
        it.printf(0, 0, id(my_font), "Batt Volt:");
        it.printf(0, 20, id(my_font), "%.2f V", id(battery_voltage).state);
      }

      if (page == 2) {
        it.printf(0, 0, id(my_font), "Batt Curr:");
        it.printf(0, 20, id(my_font), "%.2f A", id(battery_current).state);
      }

      if (page == 3) {
        it.printf(0, 0, id(my_font), "MPPT State:");
        it.printf(0, 20, id(my_font), "%s", id(mppt_state).state.c_str());
      }

Risultato finale

Il display mostra ciclicamente:

  • Potenza PV
  • Tensione batteria
  • Corrente batteria
  • Stato MPPT

Il sistema è autonomo, affidabile e perfetto per monitorare un impianto solare senza aprire Home Assistant.

Spiegazione didattica del funzionamento del codice (ID sensori, globals, interval, display)

1. Perché prima servono gli ID dei sensori

Prima di poter usare un sensore nel display o in una lambda, ESPHome deve sapere come si chiama quel sensore. Questo nome è l’id:.

Senza ID, il display non può leggere il valore del sensore e il codice non compila.

Esempio corretto:

id: battery_voltage


Questo permette al display di usare:

id(battery_voltage).state

Gli ID sono quindi etichette obbligatorie che collegano i sensori al codice del display.

2. La variabile globale `lcd_page`

globals:
  - id: lcd_page
    type: int
    restore_value: no
    initial_value: '0'

Questa variabile è un contatore che indica quale pagina del display deve essere mostrata.

  • `type int → è un numero intero
  • `initialvalue: ‘0’ → parte dalla pagina 0
  • `restorevalue: no → al riavvio riparte da 0

È il “segnalibro” del display.

3. Il timer `interval` che cambia pagina ogni 5 secondi

interval:
  - interval: 5s
    then:
      - lambda: |-
          id(lcd_page)++;
          if (id(lcd_page) > 3) id(lcd_page) = 0;

Ogni 5 secondi:

  1. aumenta `cd_page di 1
  2. se supera 3, torna a 0

È un ciclo continuo:

0 → 1 → 2 → 3 → 0 → …

Questo permette al display di cambiare pagina automaticamente senza pulsanti.

4. La sezione `display` che disegna la pagina corretta

int page = id(lcd_page);

l display legge quale pagina deve mostrare.

Ogni blocco if (page == X) rappresenta una pagina:

  • 0 → PV Power
  • 1 → Battery Voltage
  • 2 → Battery Current
  • 3 → MPPT State

Esempio:

if (page == 0) {
  it.printf(0, 0, id(my_font), "PV Power:");
  it.printf(0, 20, id(my_font), "%.1f W", id(pv_power).state);
}


Il display mostra solo la pagina corrispondente al valore di lcd_page.

📌 Riassunto didattico

  • Prima si definiscono gli ID dei sensori, altrimenti il display non può leggerli.
  • `cd_page è la variabile che tiene memoria della pagina corrente.
  • interval cambia pagina ogni 5 secondi.
  • `isplay legge `cd_page e mostra la pagina giusta.

È un sistema semplice, elegante e molto flessibile.

ESP32 vs Arduino: quando scegliere cosa (e perché)


Per chi si avvicina al mondo IoT o microcontrolli, le due piattaforme più citate sono Arduino e ESP32. Entrambe costano poco e offrono molta flessibilità, ma hanno punti di forza molto diversi. In questo articolo vediamo come e quando l’ESP32 “prende il sopravvento” rispetto ad Arduino in molti progetti moderni.


1. Cosa sono (breve ripasso)

  • Arduino: una piattaforma open-source basata su varie schede, tipicamente con un microcontrollore AVR (es: ATmega328P nel classico Uno).
  • Facile da programmare (IDE semplice, librerie abbondanti)
  • Ottimo per progetti didattici e semplici interfacce fisiche.
  • ESP32: un chip System-on-Chip (SoC) con:
  • CPU dual-core a 240 MHz
  • Wi-Fi + Bluetooth integrati
  • Più RAM e flash del classico Arduino Uno
  • Supporto per RTOS (FreeRTOS), filesystem, stack TCP/IP.

2. Le differenze chiave in pratica

Ecco come si traducono queste caratteristiche in situazioni reali:

a) Connettività

  • Arduino di base ha solo porte I/O e seriale. Per Wi-Fi o Bluetooth serve un modulo esterno (ESP8266, BT42), che complica cablaggi e dipendenze software.
  • ESP32: Wi-Fi + BT integrati. Questo semplifica enormemente progetti IoT: sensori remoti, home automation, nodi mesh wireless, etc.

b) Potenza di calcolo e memoria

  • Un ESP32 ha tipicamente 4–8 MB di RAM e ~512 KB di flash.
  • L’ESP32 può gestire protocolli pesanti (MQTT, HTTP/HTTPS), server web embedded, caching in memoria e più eventi concorrenti senza bloccarsi.
  • Su un Arduino Uno con ATmega328P la RAM è piccolissima (circa 2 KB) e flash limitata (32 KB): si fanno a pezzi anche programmi medi.

c) Architettura e OS

  • Arduino usa loop infinito (setup(), loop()) che può diventare un collo di bottiglia in progetti complessi.
  • ESP32 supporta RTOS: puoi definire task multipli (es: uno per Wi-Fi, uno per sensori, uno per l’UI) e pianificarli indipendentemente.

d) Flessibilità hardware

Entrambi usano GPIO, SPI, I²C, ADC/DAC.
Le differenze sono più nelle capacità extra dell’ESP32:

  • Più canali di ADC (spesso 12 bit).
  • Periferiche avanzate: USB OTG, CAN bus, ecc.
  • Supporto per touch screen capacitivi integrato su alcune schede ESP32.

3. Dove l’ESP32 è più “diffuso” e perché

Ecco alcuni esempi concreti in cui l’ESP32 ha quasi sostituito Arduino:

  1. Progetti IoT semplici (misuratori di temperatura/umidità Wi-Fi, interruttori remoti)
  • ESP32 è “out of the box”: basta scrivere il codice e si connette senza moduli extra.
  1. Home automation / domotica fai-da-te
  • Nodi Zigbee o Z-Wave via Wi-Fi/BT (ESP32 + firmware compatibile).
  • Pannelli di controllo touchscreen integrati.
  1. Wearable e dispositivi connessi a basso costo
  • Smartwatch, tracker fitness DIY, smartwatch con BT audio: ESP32 offre potenza e radio in un unico chip.
  1. Server web embedded / AP personalizzati
  • Access point Wi-Fi che serve una pagina web per configurazione o controllo (es: router mesh personalizzato).
  • Server HTTP leggero per dashboard interne su LAN.
  1. Prototipazione rapida di applicazioni complesse
  • Con RTOS e librerie TCP/IP, ESP32 permette di simulare piccoli server o client senza PC intermediario (ottimo per test IoT).

4. Arduino resta rilevante dove l’ESP32 è “troppo”

Ci sono ambiti in cui Arduino è ancora una scelta migliore:

  • Semplicità estrema
  • Per progetti educativi o didattici, la versione base (Uno/Nano) è più chiara e meno sovraccarica.
  • Basso costo per alta produzione senza connettività
  • Se ti servono centinaia di nodi che leggono un solo sensore via seriale e non Wi-Fi, un Arduino Nano resta spesso più economico.
  • Ambienti industriali legacy o certificati
  • In alcuni contesti si preferiscono microcontrollori con una storia lunga e supporti certi (es: ATmega), anche se meno potenti.

5. Conclusione: “Quando scegliere cosa”

  • Scegli ESP32 se ti serve:
  • Connettività Wi-Fi + BT integrata
  • Più potenza di calcolo e memoria (per protocolli, GUI, RTOS)
  • Flessibilità per IoT, server embedded, wearable complessi.
  • Scegli Arduino se ti serve:
  • Semplicità didattica estrema
  • Bassissimo costo per progetti semplici senza Wi-Fi/BT
  • Ambiente consolidato e ben documentato per elettronica base.

In pratica: la maggior parte dei nuovi progetti IoT, wearable, smart home, dashboard embedded e prototipi veloci finiscono usando ESP32 al posto di Arduino “puro” proprio per via della connettività e delle risorse extra in un unico chip a basso costo.

Aggiungere un Pulsante di Riavvio Manuale in ESPHome per ESP32

🔧 Come aggiungere un pulsante di riavvio manuale in ESPHome

In molte installazioni basate su ESP32 può essere utile avere un modo semplice e immediato per riavviare il dispositivo direttamente da Home Assistant.

ESPHome mette a disposizione un componente dedicato che permette di creare un pulsante virtuale capace di eseguire un reboot del microcontrollore con un solo clic.

In questo articolo vediamo come aggiungerlo al tuo file YAML in modo rapido e sicuro.

🧩 Perché aggiungere un pulsante di riavvio?

Un pulsante di riavvio manuale è utile quando:

  • vuoi riavviare l’ESP32 senza scollegare l’alimentazione
  • stai testando nuove configurazioni
  • un sensore o il BLE si blocca e vuoi ripristinare il dispositivo
  • desideri un controllo immediato da Home Assistant

È una soluzione semplice ma molto pratica, soprattutto in installazioni remote o difficili da raggiungere fisicamente.

✅ Codice YAML del pulsante di riavvio

Aggiungi questo blocco nel tuo file ESPHome:

button:
  - platform: restart
    id: riavvia_esp
    name: "Riavvia ESP32"

Questo crea un pulsante visibile in Home Assistant che, quando premuto, riavvia immediatamente il dispositivo.

🔍 Come funziona?

  • platform: restart è un componente ufficiale ESPHome
  • il pulsante appare automaticamente tra i dispositivi dell’ESP32 in Home Assistant
  • premendolo, l’ESP esegue un reboot pulito
  • non richiede configurazioni aggiuntive o dipendenze

È uno dei metodi più affidabili e compatibili con tutte le versioni moderne di ESPHome.

🎯 Conclusione

Aggiungere un pulsante di riavvio manuale è un modo semplice per migliorare la gestione del tuo ESP32.

È immediato, stabile e perfettamente integrato con Home Assistant, ideale sia per debugging che per manutenzione ordinaria.

🖥️ ESP32 + OLED

🖥️ ESP32 + OLED: Notifiche visive intelligenti con ESPHome

🔎 Descrizione del progetto

Questo progetto trasforma un microcontrollore ESP32 in un pannello di notifica visiva, utilizzando un display OLED SSD1306 da 128×64 pixel. È pensato per integrarsi con Home Assistant e mostrare messaggi testuali dinamici, come avvisi di sicurezza, stato degli elettrodomestici, promemoria o notifiche personalizzate.

Il cuore del sistema è un’entità input_text in Home Assistant: ogni volta che viene aggiornata, il messaggio appare sul display OLED. Il messaggio rimane visibile finché non ne arriva uno nuovo. Non c’è più alcun timeout automatico: il display mostra sempre l’ultimo messaggio ricevuto.

È una soluzione elegante, modulare e facilmente estendibile per chi vuole aggiungere un feedback visivo alle automazioni domestiche.

🔌 Collegamenti hardware

ComponentePin ESP32Pin periferica
Display OLED SSD1306GPIO 21SDA
Display OLED SSD1306GPIO 22SCL
Alimentazione3.3V / GNDVCC / GND

Il display comunica via I²C, usando i pin GPIO 21 (SDA) e GPIO 22 (SCL). L’indirizzo I²C del display è 0x3C (standard per SSD1306). Non sono richieste resistenze di pull-up esterne: ESPHome le gestisce automaticamente.

📄 Spiegazione riga per riga del file YAML

⚙️ Configurazione generale

esphome:
  name: esphome-web-33da74
  friendly_name: Esp32 LCD
  min_version: 2025.5.0
  name_add_mac_suffix: false
  • name: nome tecnico del dispositivo
  • friendly_name: nome leggibile in Home Assistant
  • min_version: versione minima di ESPHome richiesta
  • name_add_mac_suffix: se false, evita di aggiungere il MAC al nome

🧠 Specifiche hardware

esp32:
  board: esp32dev
  framework:
    type: arduino
  • board: modello della scheda ESP32
  • framework: usa il linguaggio Arduino per la compilazione

🛠️ Servizi di base

logger:
api:
ota:
  - platform: esphome
  • logger: abilita il log seriale per il debug
  • api: consente la comunicazione diretta con Home Assistant
  • ota: permette aggiornamenti firmware via Wi-Fi

📶 Connessione Wi-Fi

wifi:
  networks:
    - ssid: "TechLab_Guest"
      password: "connect1234"
    - ssid: "HomeSecure_5G"
      password: "safezone9876"

Il dispositivo proverà a connettersi alla prima rete disponibile tra quelle elencate.

🔌 Bus I²C per il display

i2c:
  sda: 21
  scl: 22
  scan: true
  • sda e scl: pin di comunicazione I²C
  • scan: true: rileva automaticamente i dispositivi collegati

🔤 Font per il display

font:
  - file: "gfonts://Roboto"
    id: my_font
    size: 12
  • file: scarica il font Roboto da Google Fonts
  • id: nome interno del font
  • size: altezza dei caratteri in pixel

🧾 Sensore testuale da Home Assistant

text_sensor:
  - platform: homeassistant
    name: "Messaggio OLED"
    entity_id: input_text.lcd_message
    id: lcd_text
  • Importa l’entità input_text.lcd_message da Home Assistant
  • Ogni volta che il valore cambia, il display si aggiorna
  • Non c’è più alcun timeout: il messaggio resta finché non ne arriva uno nuovo

🖥️ Display OLED SSD1306

display:
  - platform: ssd1306_i2c
    model: "SSD1306 128x64"
    address: 0x3C
    lambda: |-
      if (!id(lcd_text).state.empty()) {
        std::string msg = id(lcd_text).state;
        int line = 0;
        const int max_chars = 20;

        while (msg.length() > 0 && line < 4) {
          std::string segment = msg.substr(0, max_chars);
          msg = msg.length() > max_chars ? msg.substr(max_chars) : "";
          it.printf(0, line * 16, id(my_font), "%s", segment.c_str());
          line++;
        }
      }
  • platform: tipo di display usato
  • model: risoluzione del display
  • address: indirizzo I²C del display
  • lambda: codice inline in C++ che:
    • Verifica se il messaggio è vuoto
    • Divide il testo in righe da 20 caratteri
    • Le stampa verticalmente con spaziatura di 16 pixel
    • Mostra massimo 4 righe (limite del display)

✅ Conclusione

Questo progetto è una soluzione compatta e potente per creare un pannello di notifica visiva con ESP32 e OLED. È perfettamente integrato con Home Assistant, facile da modificare e ideale per chi vuole un feedback immediato e visivo delle proprie automazioni.

Il comportamento è ora più naturale: il messaggio resta visibile finché non viene aggiornato. Nessun timeout, nessuna cancellazione automatica. Il display è sempre sincronizzato con l’ultimo stato dell’automazione.

Aggiungo …

Ecco una spiegazione semplificata del codice fornito:


Funzionamento generale

Il codice gestisce la visualizzazione di un testo su uno schermo LCD (es. 20 caratteri x 4 righe) in ESPHome.


Passaggi principali

  1. Controllo inputif (!id(lcd_text).state.empty())
    • Verifica che il contenuto da visualizzare non sia vuoto (es. “Ciao mondo!” invece di “”).
  2. Inizializzazione variabilistd::string msg = id(lcd_text).state; int line = 0; const int max_chars = 20;
    • msg: memorizza il testo da visualizzare.
    • line: indica la riga corrente (da 0 a 3).
    • max_chars: numero massimo di caratteri per riga (es. 20).
  3. Loop per suddivisione del testowhile (msg.length() > 0 && line < 4)
    • Continua finché ci sono caratteri da visualizzare e non si superano le 4 righe.
  4. Suddivisione in segmentistd::string segment = msg.substr(0, max_chars); msg = msg.length() > max_chars ? msg.substr(max_chars) : "";
    • Estrae i primi max_chars caratteri (es. “Ciao mondo!” → “Ciao mondo” in prima riga).
    • Rimuove il segmento già visualizzato dal testo originale.
  5. Visualizzazione su schermoit.printf(0, line * 16, id(my_font), "%s", segment.c_str());
    • it: riferimento all’oggetto LCD.
    • printf(...): stampa il testo in posizione (0, line*16) (spaziatura tra righe).
    • id(my_font): font utilizzato per la visualizzazione.
  6. Avanzamento rigaline++;
    • Passa alla riga successiva per il prossimo segmento.

Esempio concreto

Se msg = "Questo è un testo lungo", il codice:

  1. Stampa “Questo è un t” (20 caratteri) sulla riga 0.
  2. Stampa “esto lungo” (rimanenti) sulla riga 1.

Perché funziona?

  • Gestisce testi lunghi suddividendoli in segmenti compatibili con le dimensioni dell’LCD.
  • Evita errori di sovraccarico o troncamento non previsto del messaggio.

Come collegare un sensore di livello liquido all’ESP32 e visualizzarlo in Home Assistant


1. Introduzione

Questo articolo descrive la procedura per integrare un sensore analogico di livello liquido con un ESP32, utilizzando ESPHome per la configurazione firmware e l’integrazione nativa con Home Assistant. L’approccio non richiede MQTT; i dati vengono trasmessi tramite il protocollo API di ESPHome.


2. Materiale necessario

ElementoQuantitàNote
Scheda ESP32 dev board1Modello “esp32dev” o equivalente
Sensore analogico di livello liquido1(es. sensore a resistenza variabile)
Cavi jumper3Collegamenti VCC, GND e OUT
Resistor divider (opzionale)2Se il sensore opera a 5 V
Breadboard (facoltativa)1Per prototipare

3. Collegamento hardware

Nota di sicurezza: se il sensore è alimentato a 5 V, utilizzare un divider di tensione per ridurre la tensione di uscita a 3,3 V, valore massimo accettabile dall’ESP32.

Sensore   →   ESP32
--------------------
VCC       →   3.3 V (o 5 V con divider)
GND       →   GND
OUT (analogico) → GPIO34 (ADC1_CH6)

Il pin ADC scelto, GPIO34, è un ingresso analogico non condiviso da altre funzioni critiche.


4. Configurazione ESPHome

Salvare il seguente contenuto in un file liquid_level_sensor.yaml e caricarlo con l’interfaccia di ESPHome.

esphome:
  name: liquid_level_sensor
  platform: ESP32
  board: esp32dev

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

api:

ota:

logger:

sensor:
  - platform: adc
    pin: GPIO34
    name: "Livello Liquido"
    unit_of_measurement: "%"
    accuracy_decimals: 2
    filters:
      - lambda: |-
          return clamp((x / 4095.0f) * 100.0f, 0.0f, 100.0f);

Il filtro lambda converte la lettura ADC (intervallo 0‑4095) in una percentuale di livello.


5. Verifica in Home Assistant

  1. Riavvia l’ESP32 (tramite OTA o collegamento USB).
  2. Accedi a Developer Tools → States e cerca sensor.liquid_level_sensor_livello_liquido.
  3. Il valore percentuale dovrebbe aggiornarsi automaticamente.

6. Possibili estensioni

FunzioneImplementazione
DebounceAggiungere un filtro throttle in ESPHome.
AllarmiCreare automazioni in Home Assistant basate su soglie percentuali.
GraficiInserire l’entità nel dashboard Lovelace per visualizzare la cronologia.

7. Conclusioni

Utilizzando ESPHome e l’API di Home Assistant, è possibile trasformare un semplice sensore analogico in una fonte di dati affidabile senza ricorrere a MQTT. Il procedimento descritto garantisce un’integrazione pulita e facilmente estendibile.


🛠️ Configurazione del Sensore HC-SR04 con ESPHome su ESP32 WROOM: Guida Tecnica per l’Automazione Domotica

Introduzione
Nel panorama delle soluzioni IoT, l’integrazione di sensori a basso costo come il HC-SR04 rappresenta un’opportunità per implementare sistemi di misurazione della distanza in tempo reale. Questo articolo fornisce una guida tecnica per configurare il sensore con ESPHome su un ESP32 WROOM, garantendo una implementazione ottimizzata per l’automazione domestica e l’efficienza energetica.


🔌 Connessione Fisica: Tabella di Riferimento

Per garantire una corretta integrazione elettronica, è fondamentale verificare la corretta connessione tra il sensore e il modulo ESP32. Ecco la tabella di riferimento:

Pin del SensorePin ESP32 (WROOM-32)Funzione
VCC3.3VAlimentazione (3.3V)
GNDGNDGround (0V)
TriggerGPIO12Attivazione (50μs)
EchoGPIO13Rilevamento risposta (risposta)

💡 Attenzione: Evita di utilizzare pin già assegnati a funzioni critiche (es. I²C, UART). Il WROOM-32 supporta GPIO12 e GPIO13 come pin disponibili per il sensore.


📝 Configurazione in ESPHome: Esempio Minimale

La configurazione del sensore HC-SR04 in ESPHome richiede un file YAML minimale. Ecco l’esempio ottimizzato:

esphome:
  name: "hc_sr04"
  platform: esp32
  board: esp32dev

sensor:
  - platform: ultrasonic
    name: "Distanza HC-SR04"
    trigger_pin: GPIO12
    echo_pin: GPIO13
    update_interval: 10s

Parametri Critici:
Ecco la tabella che riassume i parametri essenziali per una configurazione affidabile:

ParametroValoreDescrizione
trigger_pinGPIO12Pin utilizzato per attivare il sensore
echo_pinGPIO13Pin per ricevere il feedback del sensore
update_interval10sFrequenza di aggiornamento (riduce il consumo energetico)

🔍 Note Tecniche:

  • Il componente ultrasonic gestisce automaticamente il ciclo di attivazione (50μs) del trigger.
  • L’intervallo update_interval è impostato a 10s per minimizzare il consumo energetico, ideale per applicazioni a basso traffico.

🧪 Verifica e Test

Per validare la corretta funzionalità del sistema, segui questi passi:

  1. Conferma connessione: Esegui esphome --scan per verificare il rilevamento del sensore.
  2. Monitoraggio: Verifica il valore della distanza tramite l’interfaccia web di ESPHome o tramite il canale MQTT.
  3. Ottimizzazione: Utilizza il parametro deep_sleep per ridurre il consumo energetico in modalità standby (es. deep_sleep: 10s nel file YAML).

🌟 Consiglio: Testa con un valore di update_interval inferiore (es. 5s) per verificare la risposta del sensore in condizioni di alta frequenza.


🎯 Conclusioni

Con questa configurazione, è possibile implementare un sistema di misurazione della distanza in tempo reale, ideale per applicazioni come:

  • Automazione di porte e serrande
  • Monitoraggio ambientale (es. distanza da ostacoli)
  • Sistemi di sicurezza basati su distanza

Importante: La scelta dei pin e l’ottimizzazione dell’intervallo di aggiornamento sono fondamentali per garantire un’efficienza energetica e una corretta integrazione del sensore nel contesto IoT.

Prossimo passo: Aggiungi il sensore al tuo sistema ESPHome per integrarlo con altri dispositivi (es. Home Assistant) tramite il canale MQTT.


Articolo realizzato con precisione tecnica e adattato alle specifiche del WROOM-32. Per ulteriori dettagli, consulta il datasheet del HC-SR04 e la documentazione ufficiale di ESPHome. 🚀