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. 🚀

DHT22 + ESP32: Come trasformare un semplice sensore in una “smart zone”

1️⃣ Materiale necessario

ElementoQuantitàNote
ESP32 (es. esp32dev o nodemcu‑32s)1Assicurati di avere i driver installati sul PC.
DHT22 (temperatura + umidità)1Più preciso del DHT11.
Resistor 10 kΩ1Pull‑up per il pin DATA.
Condensatore 100 nF (opzionale)1Filtra eventuali rumori sulla linea di alimentazione.
Cavi jumperVariPer collegamenti in breadboard o direttamente ai pin.

2️⃣ Schema di collegamento

🔌 DHT22 → ESP32

DTH22ESP32Commento
VCC3V3Alimentazione a 3,3 V (compatibile con ESP32).
GNDGNDTerra comune.
DATAGPIO4Pin digitale libero; scegli un altro se preferisci.

Pull‑up: collega il resistore 10 kΩ tra VCC e il pin DATA per stabilizzare la linea.
Condensatore (opzionale): posizionalo vicino al DHT22, dal GND a VCC.


3️⃣ Configurazione ESPHome (YAML)

esphome:
  name: dth22_esp32
  platform: ESP32
  board: esp32dev   # cambia se usi un altro modello

wifi:
  ssid: "NOME_Rete"
  password: "PASSWORD"

api:
ota:

logger:

sensor:
  - platform: dht
    pin: GPIO4          # stesso pin usato nel collegamento
    temperature:
      name: "Temperatura DTH22"
      unit_of_measurement: °C
      accuracy_decimals: 1
    humidity:
      name: "Umidità DTH22"
      unit_of_measurement: "%"
      accuracy_decimals: 0
    update_interval: 60s   # lettura ogni minuto

Come procedere

  1. Crea un nuovo file dth22_esp32.yaml nella cartella ESPHome del tuo progetto.
  2. Inserisci le tue credenziali Wi‑Fi al posto di NOME_Rete e PASSWORD.
  3. Carica il firmware: esphome run dth22_esp32.yaml.

4️⃣ Visualizzare i dati in tempo reale

Una volta che l’ESP32 sta inviando le letture, puoi mostrarle ovunque tu voglia:

  • Home Assistant: aggiungi un sensore via API o MQTT.

5️⃣ Consigli pratici

ProblemaSoluzione
Letture errateVerifica la connessione GND; senza terra condivisa il sensore non funziona correttamente.
Rumore di lineaAggiungi un condensatore da 100 nF tra VCC e GND vicino al DHT22.
Pin occupatoSe GPIO4 è già in uso, scegli un altro pin digitale libero (ad es. GPIO5).

🎉 Conclusioni

Con pochi componenti, qualche riga di YAML e la potenza dell’ESP32, hai trasformato un semplice sensore DHT22 in una fonte affidabile di dati ambientali. Ora puoi monitorare temperatura e umidità ovunque tu voglia – dalla tua cucina al tuo laboratorio IoT!