La programmazione in ESPHome ci permette anche di programmare una ESP32 con un sensore di umidità del suolo (igrometro) e calibrarne anche la sensibilità, in modo da avere uno strumento in più su Home Assistant

Negli ultimi anni l’automazione domestica ha reso sempre più semplice prendersi cura delle piante, anche a distanza. Tra i componenti più utili in un sistema di irrigazione intelligente troviamo l’igrometro capacitivo, un sensore che permette di misurare l’umidità del terreno in modo preciso e duraturo. Se stai progettando un sistema basato su ESP32, ESP8266 o Arduino, questo piccolo dispositivo è un alleato prezioso.

Acquistalo su Amazon: https://amzn.to/3JlO6jD

Specifiche tecniche

L’igrometro capacitivo è un sensore che misura il livello di umidità del terreno senza utilizzare contatti elettrici diretti con l’acqua. A differenza dei classici sensori resistivi, che tendono a ossidarsi rapidamente a causa della corrente che attraversa il terreno, il modello capacitivo è molto più resistente nel tempo.

La sua struttura è semplice: una piastra in circuito stampato (PCB) rivestita da uno strato protettivo e dotata di un piccolo circuito elettronico. Quando il sensore viene inserito nel terreno, la sua capacità elettrica varia in base alla quantità di acqua presente nel suolo. L’acqua, infatti, ha una costante dielettrica molto più alta rispetto all’aria o ai materiali secchi, quindi un terreno umido aumenta la capacità del sensore, mentre un terreno asciutto la riduce.

Il circuito interno dell’igrometro converte la variazione di capacità in un segnale di tensione analogica, generalmente compreso tra 0 e 3,3 volt (nei modelli più diffusi). In pratica, quando il terreno è molto secco, il sensore restituisce una tensione più alta (circa 2.8–3.0 V), con terreno umido, la tensione scende intorno a 1.5–2.0 V, mentre se il sensore è bagnato o immerso, la tensione può arrivare fino a 0.8–1.2 V.

La principale differenza tra un igrometro capacitivo e uno resistivo è la durata nel tempo. I sensori resistivi, pur essendo economici, tendono a corrodersi dopo pochi mesi perché la corrente elettrica passa direttamente attraverso il terreno e l’umidità accelera l’ossidazione dei contatti. L’igrometro capacitivo, invece, non ha contatti esposti alla corrente e mantiene una precisione stabile anche dopo anni di utilizzo. Tra i vantaggi più rilevanti troviamo l’assenza di ossidazione, la stabilità delle misure nel tempo, la facilità di utilizzo e la compatibilità con sistemi a 3.3 V e 5 V, come ESP32 e Arduino.

Collegamenti

Collegare un igrometro capacitivo ad un ESP32 è semplice: il pin VCC del sensore va al 3.3 V dell’ESP32, il GND alla massa comune e l’uscita AO a un pin analogico, come il GPIO34. In questo modo il sensore riceve alimentazione e invia al microcontrollore una tensione proporzionale all’umidità del terreno.

Per migliorare la stabilità delle letture, soprattutto se i cavi sono lunghi o soggetti a disturbi, è consigliabile aggiungere un piccolo condensatore (circa 100 nF) tra il pin del segnale e il GND: aiuta a filtrare il rumore e a rendere le misurazioni più regolari.

Codice

Andiamo a creare un nuovo device su ESPHome e chiamiamolo Igrometro. Saltiamo per il momento la connessione e selezioniamo la scheda che dobbiamo programmare (ESP32).

Una volta creato, clicchiamo su EDIT per modificare il codice.

Questo è il codice per configurare una ESP32 per leggere lo stato del sensore e inviarlo a Home Assistant tramite ESPHome. Il dispositivo sarà accessibile in rete tramite Wi-Fi e potrà essere aggiornato via OTA (Over-The-Air) senza bisogno di connessione fisica. Potete scaricarlo a questo LINK.

All’inizio, il codice definisce il nome del dispositivo, sia quello tecnico (“igrometro”) che quello più leggibile per Home Assistant (“Igrometro”).

esphome:
  name: igrometro
  friendly_name: Igrometro

Poi si specifica che il microcontrollore utilizzato è un ESP32 e che il firmware verrà compilato usando il frameworkArduino, che è più semplice e supportato rispetto ad altre alternative come ESP-IDF.

esp32:
  board: esp32dev
  framework:
    type: arduino

Il codice attiva il logger, che serve a registrare gli eventi e inviare messaggi di debug. Inoltre, viene attivata l’API di ESPHome, che permette a Home Assistant di comunicare con il dispositivo in modo sicuro grazie a una chiave di crittografia.

logger:

api:
  encryption:
    key: "PVVHkXq5E5wFbmxE0yji5ALetCSbG8LQSM2SUuZ4h5w="/

Per evitare di dover collegare il dispositivo fisicamente ogni volta che si vuole aggiornare il firmware, viene attivata la modalità OTA (Over-The-Air), con una password di sicurezza.

ota:
  - platform: esphome
    password: "7c0e8eece8cfb0e2c832e99e34dd48c0"

Per collegarsi alla rete, il codice usa le credenziali Wi-Fi salvate nei secrets di ESPHome (file separato non visibile nel codice). Se la connessione fallisce, il dispositivo crea un hotspot Wi-Fi di emergenza (“Igrometro Fallback Hotspot”) con una password predefinita, in modo che sia possibile riconfigurarlo. Inoltre, è presente la funzione captive portal, che permette di riconfigurare il Wi-Fi direttamente da un browser in caso di problemi di connessione.

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

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Igrometro Fallback Hotspot"
    password: "aqovithxwN4a"

captive_portal:

Creiamo due box numeriche direttamente in ESPHome/Home Assistant, senza dover creare l’entità in HA. Per ogni box forniamo un nome ed un id che andremo ad usare nelle prossime righe di codice. Per consentire il cambiamento dei valori delle box, settiamo optimistic come true, definendo poi i range e la precisione delle box. Fissiamo pure un valore iniziale, dal quale la calibrazione deve partire, settando restore_value su true per mantenere il valore salvato dopo un reboot. Impostiamo l’inserimento dei valori tramite box, ma se preferiamo uno slider basterà cambiarlo.

number:
  - platform: template
    name: "Igrometro - Bagnato (V)"
    id: wet_value
    optimistic: true
    min_value: 0.0
    max_value: 3.3
    step: 0.01
    initial_value: 0.45
    restore_value: true
    mode: box

  - platform: template
    name: "Igrometro - Asciutto (V)"
    id: dry_value
    optimistic: true
    min_value: 0.0
    max_value: 3.3
    step: 0.01
    initial_value: 2.40
    restore_value: true
    mode: box

Generiamo il sensore analogico che leggerà il segnale dall’igrometro capacitivo direttamente al GPIO34 della ESP32, impostando il range di lettura a 11db e fornendo un nome ed un id. L’accuratezza è settata alla 3 cifra decimale.

sensor:
  - platform: adc
    pin: GPIO34
    attenuation: 11db
    id: adc_raw
    name: "Tensione grezza"
    update_interval: 5s
    accuracy_decimals: 3
    unit_of_measurement: "V"

In ultimo, occupiamoci del sensore calibrato che stamperà un valore in percentuale.

  - platform: template
    name: "Umidità Suolo (%)"
    id: calibrated_humidity
    unit_of_measurement: "%"
    accuracy_decimals: 1
    update_interval: 5s

Iniziamo ottenendo la tensione letta dal sensore e i valori letti dalle box.

    lambda: |-
      float raw_v = id(adc_raw).state;
      float wet_v = id(wet_value).state;
      float dryv = id(dry_value).state;

Se non abbiamo lavorato con le box, modificandone i valori, vengono letti i valori di default. Assicuriamoci anche una piccola protezione per evitare di dividere per zero.

      if (isnan(wet_v)) wet_v = 0.45;
      if (isnan(dry_v)) dry_v = 2.40;
      if (fabs(dry_v - wet_v) < 0.0001) dry_v = wet_v + 0.0001;

I valori vengono “Normalizzati”, traducendo la tensione in un numero tra 0 e 1, cioè una scala normalizzata.

      float norm = (raw_v - wet_v) / (dry_v - wet_v);

Poniamo poi dei limiti, in modo tale che anche se il sensore va fuori range, la percentuale resta tra 0 e 100%.

      if (norm < 0.0) norm = 0.0; if (norm > 1.0) norm = 1.0;

Infine, convertiamo in percentuale. Ricordiamoci che il sensori capacitivi funzionando in modo diverso, leggendo una tensione alta quando il suolo è asciutto, mentre una tensione bassa quando il suolo è bagnato. Con return mandiamo il valore calcolato al sensore Umidità Suolo (%).

      float humidity = (1.0 - norm) * 100.0;

      return humidity;

Salvate e verificate con Validate se il codice è stato scritto correttamente.

Collegate la ESP32 al computer tramite cavo USB, e cliccate su Install.

Dovrebbe essere arrivata una notifica sulla plancia. In ogni caso, per integrarlo andate su Impostazioni -> Dispositivi e servizi e apparirà il dispositivo Igrometro da integrare.