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

📦 Progetto ESPHome: Rilevazione temperatura, umidità e movimento con LED RGB controllabile via MQTT

DHT22 + PIR + LED RGB: a cosa serve


1️⃣ Obiettivo del post

In questo articolo mostrerò come realizzare un firmware completo e pronto all’uso per l’ESP32, in grado di:

  • leggere temperatura e umidità con il sensore DHT22;
  • rilevare movimento tramite un modulo PIR;
  • controllare un LED RGB (RGB) con effetti personalizzati;
  • pubblicare tutti i dati su un broker MQTT (discovery per Home Assistant);
  • aggiornarsi in modalità OTA;
  • registrare eventi e errori con livello di log DEBUG.

Il file YAML è stato generato esattamente secondo la tua richiesta ed è pronto da caricare tramite ESPHome.


2️⃣ Requisiti hardware

ComponentePin consigliati (ESP32)
DHT22GPIO4
PIRGPIO12
LED RGBRed → GPIO16, Green → GPIO17, Blue → GPIO18

Nota: collega il VCC del DHT22 a 3.3 V e il GND al terra comune.


3️⃣ Configurazione Wi‑Fi

Il firmware tenta di connettersi alla rete domestica (YOUR_SSID / YOUR_PASSWORD). Se la connessione fallisce, l’ESP32 avvia un punto di accesso “ESP32-DHT-PIR-RGB-Fallback” (password: fallback_password) per consentire la configurazione manuale.


4️⃣ Funzionalità MQTT

  • Broker: YOUR_MQTT_BROKER_IP (porta 1883)
  • Discovery abilitato (homeassistant) → i sensori e il LED vengono aggiunti automaticamente a Home Assistant.
  • Messaggi di “birth” e “will” indicano lo stato online/offline.

5️⃣ Aggiornamenti OTA

Con il modulo ota è possibile aggiornare il firmware senza collegamento fisico, usando l’app ESPHome o la riga di comando. La password OTA è impostata su “OTA_PASSWORD” (sostituire con una stringa sicura).


6️⃣ Logging dettagliato

Il livello di log è DEBUG, così da avere traccia di ogni evento, utile per il debug e la verifica del corretto funzionamento.


7️⃣ Esempio completo di file YAML

esphome:
  name: esp32_dht_pir_rgb
  platform: ESP32
  board: nodemcu-32s

wifi:
  ssid: "YOUR_SSID"
  password: "YOUR_PASSWORD"
  fast_connect: true
  ap:
    ssid: "ESP32-DHT-PIR-RGB-Fallback"
    password: "fallback_password"

captive_portal:

ota:
  password: "OTA_PASSWORD"

logger:
  level: DEBUG

mqtt:
  broker: "YOUR_MQTT_BROKER_IP"
  port: 1883
  username: "MQTT_USER"
  password: "MQTT_PASS"
  discovery: true
  discovery_prefix: homeassistant
  birth_message:
    topic: "homeassistant/status"
    payload: "online"
    qos: 1
    retain: true
  will_message:
    topic: "homeassistant/status"
    payload: "offline"
    qos: 1
    retain: true

sensor:
  - platform: dht
    pin: GPIO4
    temperature:
      name: "Living Room Temperature"
      id: temp_living_room
      filters:
        - lambda: return x * 9 / 5 + 32;   # Convert to Fahrenheit if desired
    humidity:
      name: "Living Room Humidity"
      id: hum_living_room
    update_interval: 60s

binary_sensor:
  - platform: gpio
    pin:
      number: GPIO12
      mode: INPUT_PULLUP
      inverted: true
    name: "Living Room Motion Sensor"

output:
  - platform: ledc
    pin: GPIO16
    id: red_led
    frequency: 1000Hz
  - platform: ledc
    pin: GPIO17
    id: green_led
    frequency: 1000Hz
  - platform: ledc
    pin: GPIO18
    id: blue_led
    frequency: 1000Hz

light:
  - platform: rgb
    name: "Living Room RGB LED"
    red: red_led
    green: green_led
    blue: blue_led
    id: living_room_rgb
    effects:
      - pulse:
          name: "Pulse Effect"
          transition_length: 2s
          update_interval: 1s

interval:
  - interval: 60s
    then:
      - mqtt.publish:
          topic: "homeassistant/sensor/temperature/state"
          payload_template: "{{ states('sensor.living_room_temperature') }}"
          qos: 0

8️⃣ Come procedere

  1. Copia il codice YAML sopra riportato in un nuovo file .yaml su ESPHome.
  2. Sostituisci i segnaposto (YOUR_SSIDYOUR_PASSWORD, ecc.) con le tue credenziali reali.
  3. Compila e carica il firmware sul tuo ESP32 tramite l’interfaccia web di ESPHome.
  4. Verifica la connessione MQTT in Home Assistant o con un client MQTT come Mosquitto.

9️⃣ Conclusioni

Con questo progetto hai a disposizione una soluzione modulare, sicura e pronta all’uso per monitorare temperatura/umidità, rilevare movimento e controllare un LED RGB, tutto gestito tramite MQTT. L’integrazione con Home Assistant è automatica grazie al discovery, mentre l’OTA e il logging garantiscono manutenzione semplice e tracciabilità completa.

📌 Schema di collegamento dei sensori all’ESP32

Di seguito trovi una descrizione testuale del cablaggio, da inserire subito dopo la conclusione dell’articolo.

Sensore / ModuloPin ESP32Descrizione
DHT22GPIO4VCC → 3.3 V, GND → terra comune, DATA → GPIO4 (pull‑up interno).
PIRGPIO12VCC → 5 V (o 3.3 V se il modulo è a 3.3 V), GND → terra comune, OUT → GPIO12 (INPUT_PULLUP con inversione).
LED RGBRed → GPIO16Green → GPIO17Blue → GPIO18VCC → 5 V (o 3.3 V a seconda del LED), GND → terra comune; i pin sono configurati come PWM tramite ledc.

Suggerimento di cablaggio rapido

  • Utilizza un breadboard per una prototipazione veloce.
  • Per il DHT22, inserisci un resistore da 10 kΩ tra VCC e DATA (pull‑up).
  • Se usi un LED RGB a 5 V, aggiungi resistenze limitanti (220 Ω–330 Ω) su ciascun pin di colore.

Con questo schema i componenti sono correttamente collegati all’ESP32 e pronti per essere programmati con il file YAML fornito.

Perché scegliere un computer ricondizionato? Risparmia, sosteni l’ambiente e ottieni performance affidabili 🌱

In un mondo dove la tecnologia è sempre più accessibile ma anche più costosa, i computer ricondizionati offrono una soluzione intelligente per chi cerca equilibrio tra budget, sostenibilità e prestazioni. Ecco perché valori questa scelta:


💰 Risparmio economico senza compromessi

I computer ricondizionati permettono di ridurre i costi iniziali del 30-50% rispetto ai modelli nuovi, senza perdere qualità. Ad esempio, il Fujitsu Esprimo (Mini PC Desktop Intel i5-7500T, RAM 16GB DDR4, SSD 512GB, porte DVI + DP) è un modello perfetto per chi vuole un dispositivo potente a prezzo accessibile.

CaratteristicheSpecifiche
ProcessoreIntel i5-7500T
Memoria RAM16 GB DDR4
StorageSSD 512 GB
PorteDVI + DP

Questo modello è ideale per lavoro remoto, creatività digitale e uso intensivo di applicazioni professionali.


🌱 Sostenibilità ambientale: un impatto positivo

L’uso di computer ricondizionati riduce l’impatto ecologico legato alla produzione di nuovi dispositivi. Secondo dati dell’UNEP, ogni computer ricondizionato evita circa 20 kg di CO₂ emessi durante la sua vita utile.

Perché è importante?

  • Eviti il consumo di risorse naturali (minerale, energia) per la produzione di nuovi dispositivi;
  • Riduci i rifiuti elettronici in discarica;
  • Contribuisci a un futuro più sostenibile con piccole azioni quotidiane.

⚡ Prestazioni affidabili: non è solo “vecchio”

Molte persone pensano che i computer ricondizionati siano meno performanti, ma la realtà è diversa. I dispositivi vengono testati e certificati per garantire prestazioni ottimali. Il Fujitsu Esprimo, ad esempio, offre:

  1. Un processore Intel i5-7500T veloce per multitasking;
  2. 16 GB di RAM DDR4 per applicazioni intensive;
  3. SSD 512 GB per velocità di caricamento senza compromessi.

Non è “vecchio” – è un dispositivo aggiornato e adatto a esigenze moderne.


👥 Adatto a tutti: dalla scuola all’imprenditoria

I computer ricondizionati sono una soluzione universale, perfetta per diverse tipologie di utenti:

  1. Gli studenti possono utilizzarli per studiare e lavorare in modo efficiente;
  2. Le piccole imprese trovano un’ottima soluzione per il loro ambiente di lavoro;
  3. Le famiglie cercano dispositivi economici ma affidabili per la quotidianità.

❓ Risposte alle preoccupazioni comuni

“I computer ricondizionati sono sicuri?” → Sì! I fornitori certificati effettuano controlli approfonditi e eliminano i dati precedenti.
“Posso usare un computer ricondizionato per lavoro professionale?” → Assolutamente sì: molti modelli offrono prestazioni equivalenti a quelli nuovi.


✅ Conclusione: una scelta responsabile per tutti

Scegliere un computer ricondizionato è una decisione che beneficia non solo il tuo portafogli, ma anche l’ambiente e la tua produttività. Con modelli come il Fujitsu Esprimo, puoi ottenere prestazioni elevate a costi ridotti, senza compromettere qualità o sostenibilità.

🛠 Script di aggiornamento automatizzato per Debian/Proxmox e Rocky Linux

In ambienti server, mantenere il sistema aggiornato è fondamentale per la sicurezza e la stabilità. Questo articolo presenta due script bash che eseguono l’aggiornamento del sistema con conferma interattiva e inviano il log via email all’amministratore. I log non vengono salvati su disco, ma solo inviati via sendmail.

📦 Funzionalità comuni

FunzioneDebian/ProxmoxRocky Linux
Aggiornamento pacchettiapt-getdnf
Conferma interattiva
Invio log via email✅ (sendmail)✅ (sendmail)
Log solo in memoria
Nessun file temporaneo

🧬 Script per Debian/Proxmox

#!/bin/bash

# Configurazione
DATA=$(date '+%Y-%m-%d %H:%M')
HOSTNAME=$(hostname)
EMAIL="ammin@internal.lan"
SUBJECT="[$HOSTNAME] Log aggiornamento - $DATA"

# Gestione log con file temporaneo
LOGFILE=$(mktemp)
trap "rm -f $LOGFILE" EXIT

# Funzioni di logging con emoji appropriate
info() { echo -e "🟢 $@" >> "$LOGFILE"; }
warning() { echo -e "🟠 $@" >> "$LOGFILE"; }
error() { echo -e "🔴 $@" >> "$LOGFILE"; }

# Gestione interattività con controllo pipe
yn() {
    local msg="$1"
    if [ -t 0 ]; then
        read -r -p "$msg [s/N]" resp
        [[ "$resp" =~ ^[sS]$ ]]
    else
        echo "N"
    fi
}

info "Inizio aggiornamento su $HOSTNAME: $DATA"

# Aggiorna repository con gestione errori
info "🔄 Aggiorna elenco pacchetti"
apt update || { error "Fallito l'aggiornamento della lista pacchetti"; exit 1; }

# Chiedi conferma per upgrade completo
DO_UPGRADE=$(yn "Vuoi effettuare 'apt upgrade per aggiornare tutti i pacchetti'?")

if $DO_UPGRADE; then
    info "⬆️ Esegui aggiornamento pacchetti"
    apt upgrade -y || { warning "Aggiornamento pacchetti completato con errori"; }    
else
    info "⏭️ Salto aggiornamento pacchetti su richiesta utente"
fi

# Chiedi conferma per autoremove
DO_AUTOREMOVE=$(yn "Vuoi eseguire 'apt autoremove' per pulizia?")

if $DO_AUTOREMOVE; then
    info "🧹 Esecuzione apt autoremove"
    apt autoremove -y --purge || { warning "apt autoremove ha segnalato errori"; }
else
    info "⏭️ Salto apt autoremove su richiesta utente"
fi

info "🔚 Fine aggiornamento su $HOSTNAME: $(date)"

# Invio email con gestione completa
if command -v sendmail >/dev/null 2>&1; then
    cat <<EOF | sendmail -t
To: $EMAIL
Subject: $SUBJECT
Content-Type: text/plain; charset=UTF-8

$(cat "$LOGFILE")
EOF
    info "📧 Log inviato a $EMAIL tramite sendmail"
else
    warning "⚠️ Comando 'sendmail' non trovato. Impossibile inviare email."
fi

# Verifica sistema
info "🧠 Verifica sistema"
uname -a >> "$LOGFILE"
free -h >> "$LOGFILE"
df -h >> "$LOGFILE"
apt list --installed --upgradable | grep -v "^Listing$" >> "$LOGFILE"

warning "Importante: Controllare il log per confermare l'esito riuscito"

🧬 Script per Rocky Linux

#!/bin/bash

# Script di aggiornamento per Rocky Linux con invio log via sendmail
# Autore: Francesco

set -euo pipefail

DATA=$(date '+%Y-%m-%d %H:%M')
HOSTNAME=$(hostname)
EMAIL="ammin@internal.lan"
SUBJECT="[$HOSTNAME] Log aggiornamento Rocky Linux - $DATA"

# 📦 Variabile per accumulare il log
LOG="🟢 Inizio aggiornamento su $HOSTNAME (Rocky Linux): $DATA"$'\n\n'

# Funzione per eseguire un comando con log
esegui_comando() {
    local descrizione="$1"
    local comando="$2"

    LOG+="🔧 $descrizione"$'\n'
    if output=$($comando 2>&1); then
        LOG+="$output"$'\n\n'
    else
        LOG+="❌ Errore durante '$comando':"$'\n'"$output"$'\n\n'
    fi
}

# Aggiorna lista pacchetti
esegui_comando "dnf check-update" "dnf check-update"

# Conferma per upgrade
read -p "Vuoi eseguire 'dnf upgrade'? [s/N] " conferma
if [[ "$conferma" =~ ^[sS]$ ]]; then
    esegui_comando "dnf upgrade -y" "dnf upgrade -y"
else
    LOG+="❌ upgrade annullato dall'utente"$'\n\n'
fi

# Conferma per autoremove
read -p "Vuoi eseguire 'dnf autoremove'? [s/N] " conferma_autoremove
if [[ "$conferma_autoremove" =~ ^[sS]$ ]]; then
    esegui_comando "dnf autoremove -y" "dnf autoremove -y"
else
    LOG+="❌ autoremove annullato dall'utente"$'\n\n'
fi

LOG+="✅ Script completato su $HOSTNAME: $(date)"$'\n'

# 📬 Invio log via sendmail
if command -v sendmail >/dev/null 2>&1; then
    {
        echo "To: $EMAIL"
        echo "Subject: $SUBJECT"
        echo "Content-Type: text/plain; charset=UTF-8"
        echo ""
        echo "$LOG"
    } | sendmail -t
    echo "📨 Log inviato a $EMAIL tramite sendmail"
else
    echo "⚠️ Comando 'sendmail' non trovato. Impossibile inviare email."
fi

Altro codice per Debian

#!/bin/bash

# Configurazione principale
DATA=$(date '+%Y-%m-%d %H:%M')
HOSTNAME=$(hostname)
EMAIL="ammin@internal.lan"
SUBJECT="[$HOSTNAME] Log aggiornamento completo - $DATA"

# Gestione log con file temporaneo e tracciatura pacchetti
LOGFILE=$(mktemp)
APT_LOG="/var/log/apt/history.log"
trap "rm -f $LOGFILE" EXIT

# Funzioni di logging con emoji appropriate
info() { echo -e "🟢 $@" >> "$LOGFILE"; }
warning() { echo -e "🟠 $@" >> "$LOGFILE"; }
error() { echo -e "🔴 $@" >> "$LOGFILE"; }

# Gestione interattività con controllo pipe
yn() {
    local msg="$1"
    if [ -t 0 ]; then
        read -r -p "$msg [s/N]" resp
        [[ "$resp" =~ ^[sS]$ ]]
    else
        echo "N"
    fi
}

info "Inizio aggiornamento su $HOSTNAME: $DATA"

# Aggiorna repository con gestione errori estesa
info "🔄 Aggiorna elenco pacchetti"
apt update || { error "Fallito l'aggiornamento della lista pacchetti"; exit 1; }

# Chiedi conferma per upgrade completo
DO_UPGRADE=$(yn "Vuoi effettuare 'apt upgrade per aggiornare tutti i pacchetti'?")

if $DO_UPGRADE; then
    info "⬆️ Esegui aggiornamento pacchetti"
    apt upgrade -y || { warning "Aggiornamento pacchetti completato con errori"; }    
else
    info "⏭️ Salto aggiornamento pacchetti su richiesta utente"
fi

# Chiedi conferma per autoremove
DO_AUTOREMOVE=$(yn "Vuoi eseguire 'apt autoremove' per pulizia?")

if $DO_AUTOREMOVE; then
    info "🧹 Esecuzione apt autoremove"
    apt autoremove -y --purge || { warning "apt autoremove ha segnalato errori"; }
else
    info "⏭️ Salto apt autoremove su richiesta utente"
fi

info "🔚 Fine aggiornamento su $HOSTNAME: $(date)"

# Ricerca pacchetti aggiornati con analisi completa
if [ -f "$APT_LOG" ]; then
    # Pacchetti riusciti
    UPLOADED=$(grep "Upgrade:" $APT_LOG | awk '{print $2, $4}')
    
    # Pacchetti con problemi
    FAILED=$(grep "Failed-Remove:" $APT_LOG | awk '{print $2, $4}')
else
    UPLOADED="Il file log APT non esiste - impossibile tracciare pacchetti"
    FAILED="Impossibile analizzare il file log APT"
fi

# Aggiungi informazioni pacchetti al log
echo -e "\n🟠 Pacchetti aggiornati:" >> "$LOGFILE"
echo "$UPLOADED" >> "$LOGFILE"
echo -e "\n🔴 Pacchetti con problemi:" >> "$LOGFILE"
echo "$FAILED" >> "$LOGFILE"

# Informazioni sistema
info "🧠 Verifica completa del sistema"
uname -a >> "$LOGFILE"
free -h >> "$LOGFILE"
df -h >> "$LOGFILE"
apt list --installed --upgradable | grep -v "^Listing$" >> "$LOGFILE"

# Invio email con gestione completa
if command -v sendmail >/dev/null 2>&1; then
    cat <<EOF | sendmail -t
To: $EMAIL
Subject: $SUBJECT
Content-Type: text/plain; charset=UTF-8

$(cat "$LOGFILE")
EOF
    info "📧 Log inviato a $EMAIL tramite sendmail"
else
    warning "⚠️ Comando 'sendmail' non trovato. Impossibile inviare email."
fi

warning "Importante: Controllare il log per confermare l'esito riuscito con lista pacchetti"

# Nota all'utente:
# Esegui lo script una volta per generare il file /var/log/apt/history.log
# Successivamente, il tracciamento dei pacchetti funzionerà correttamente
# Se il file log non esiste, il sistema segnalerà l'impossibilità di tracciare pacchetti

Altro codice per Rocky linux

#!/bin/bash

# 📅 Info iniziali
DATA=$(date '+%Y-%m-%d %H:%M')
HOSTNAME=$(hostname)
EMAIL="ammin@internal.lan"
SUBJECT="[$HOSTNAME] Log aggiornamento - $DATA"
LOGFILE=$(mktemp)
trap "rm -f $LOGFILE" EXIT

# 🔧 Logging
log() { echo -e "$@" >> "$LOGFILE"; }
info() { log "🟢 $@"; }
warn() { log "🟠 $@"; }
err()  { log "🔴 $@"; }

# ❓ Conferma interattiva
ask() {
    local prompt="$1"
    if [ -t 0 ]; then
        read -r -p "$prompt [s/N] " reply
        [[ "$reply" =~ ^[sS]$ ]]
    else
        return 1
    fi
}

info "Inizio aggiornamento su $HOSTNAME: $DATA"

# 🔄 Aggiorna cache
info "Pulizia e aggiornamento cache..."
dnf clean all && dnf makecache || { err "Errore durante 'dnf makecache'"; exit 1; }

# ⬆️ Upgrade
if ask "Vuoi eseguire 'dnf upgrade'?"; then
    info "Eseguo 'dnf upgrade'..."
    dnf upgrade -y || warn "Upgrade completato con errori"
else
    info "Upgrade saltato"
fi

# 🧹 Autoremove
if ask "Vuoi eseguire 'dnf autoremove'?"; then
    info "Eseguo 'dnf autoremove'..."
    dnf autoremove -y || warn "Autoremove ha segnalato errori"
else
    info "Autoremove saltato"
fi

info "Fine aggiornamento: $(date '+%c')"

# 📦 Tracciamento pacchetti aggiornati
info "📜 Storico transazioni DNF"
dnf history list | head -n 10 >> "$LOGFILE"

LAST_ID=$(dnf history | awk '/Upgrade/ {print $1}' | head -n 1)
if [ -n "$LAST_ID" ]; then
    info "📦 Dettagli ultima transazione (ID $LAST_ID)"
    dnf history info "$LAST_ID" >> "$LOGFILE"
else
    warn "Nessuna transazione di upgrade trovata"
fi

# 🧠 Info sistema
info "🧠 Informazioni sistema:"
uname -a >> "$LOGFILE"
free -h >> "$LOGFILE"
df -h >> "$LOGFILE"

# 📌 Aggiornamenti disponibili
info "📌 Aggiornamenti disponibili:"
dnf check-update >> "$LOGFILE"

# 📧 Invio email con gestione dimensione
MAXSIZE=500000  # ~500 KB
LOGSIZE=$(stat -c%s "$LOGFILE")

if command -v sendmail >/dev/null 2>&1; then
    if [ "$LOGSIZE" -lt "$MAXSIZE" ]; then
        {
            echo "To: $EMAIL"
            echo "Subject: $SUBJECT"
            echo "Content-Type: text/plain; charset=UTF-8"
            echo ""
            cat "$LOGFILE"
        } | sendmail -t
        info "📧 Log inviato a $EMAIL"
    else
        {
            echo "To: $EMAIL"
            echo "Subject: $SUBJECT (estratto)"
            echo "Content-Type: text/plain; charset=UTF-8"
            echo ""
            echo "⚠️ Log troppo grande. Invio solo le ultime 500 righe:\n"
            tail -n 500 "$LOGFILE"
        } | sendmail -t
        warn "Log troppo grande: invio parziale"
    fi
else
    warn "Sendmail non disponibile. Email non inviata."
fi

warn "Controlla il log per confermare l'esito e i pacchetti aggiornati"

📌 Considerazioni finali

Questi script sono pensati per ambienti dove è importante avere controllo manuale sull’aggiornamento e una tracciabilità immediata via email. Entrambi sono compatibili con sendmail e non lasciano tracce locali del log.

Analisi di un Script Bash per la Visualizzazione dei Moduli di Memoria 💻🔍

Il codice che hai fornito è uno script Bash chiamato memory.sh progettato per recuperare e visualizzare informazioni dettagliate sui moduli di memoria installati in un sistema Linux. Analizziamolo passo per passo!

#!/usr/bin/env bash
# memory.sh – mostra direttamente i blocchi dei banchi di memoria

set -euo pipefail

if ! command -v lshw >/dev/null 2>&1; then
    echo "lshw non è installato." >&2
    exit 1
fi

echo "=== Moduli di memoria ==="
sudo lshw -C memory | grep -A 10 'bank:' | grep -v -- '--'



Spiegazione riga per riga:

  1. #!/usr/bin/env bash: Questa è la “shebang” line. Indica al sistema operativo di eseguire lo script utilizzando l’interprete Bash. env garantisce che il percorso a bash sia trovato nel sistema, rendendo lo script più portabile. ✨
  2. # memory.sh – mostra direttamente i blocchi dei banchi di memoria: Questa è una riga di commento che descrive lo scopo dello script. 📝
  3. set -euo pipefail: Questa riga imposta diverse opzioni di Bash per una maggiore robustezza:
    • -e (errexit): Lo script termina immediatamente se un comando esce con un codice di errore diverso da zero. ⚠️
    • -u (nounset): Tratta le variabili non inizializzate come errori.
    • -o pipefail: Se una pipeline (una sequenza di comandi collegati tramite pipe) fallisce, lo script termina.
  4. if ! command -v lshw >/dev/null 2>&1; then ... fi: Questa parte controlla se il comando lshw (Hardware Lister) è installato nel sistema. lshw è uno strumento potente per ottenere informazioni dettagliate sull’hardware del sistema. Se lshw non è trovato, lo script stampa un messaggio di errore e termina. 🚫

Come funziona il resto dello script:

  • echo "=== Moduli di memoria ===": Stampa un’intestazione per rendere l’output più leggibile. 📢
  • sudo lshw -C memory | grep -A 10 'bank:' | grep -v -- '--': Questa è la parte cruciale dello script.
    • sudo lshw -C memory: Esegue lshw con i privilegi di amministratore (sudo) per ottenere informazioni sull’hardware, specificamente sulla categoria “memory”.
    • grep -A 10 'bank:': Filtra l’output di lshw per trovare le righe che contengono la parola “bank:” (che indica i banchi di memoria). -A 10 significa che vengono stampate le 10 righe dopo la riga corrispondente.
    • grep -v -- '--': Esclude le righe che contengono il carattere “–” (che spesso indica separatori in lshw).

Esempio di Output:

L’output dello script sarà una serie di righe che mostrano le informazioni sui banchi di memoria. Ecco un esempio (l’output reale varierà a seconda del tuo hardware):

=== Moduli di memoria ===
    descrizione: DDR4-3200 8GB DIMM
    informazioni:  lunghezza: 16 cm
    descrizione: DDR4-3200 8GB DIMM
    informazioni:  lunghezza: 16 cm
    descrizione: DDR4-3200 8GB DIMM
    informazioni:  lunghezza: 16 cm
    descrizione: DDR4-3200 8GB DIMM
    informazioni:  lunghezza: 16 cm
    descrizione: DDR4-3200 8GB DIMM
    informazioni:  lunghezza: 16 cm

Tabella riassuntiva (ipotetica):

ComponenteTipoCapacitàVelocità
Modulo 1DDR4 DIMM8GB3200MHz
Modulo 2DDR4 DIMM8GB3200MHz
Modulo 3DDR4 DIMM8GB3200MHz

(Nota: questa tabella è un esempio, l’output effettivo dello script conterrà informazioni più dettagliate.)

Consigli Pratici:

  • Esecuzione: Salva lo script in un file (ad esempio, memory.sh), rendilo eseguibile con chmod +x memory.sh e poi eseguilo con ./memory.sh.
  • Privilegi: Lo script richiede privilegi di amministratore (sudo) per accedere alle informazioni sull’hardware.
  • Personalizzazione: Puoi modificare lo script per estrarre altre informazioni, come la dimensione totale della memoria o il tipo di memoria.

Questo script è un ottimo punto di partenza per monitorare la tua memoria e assicurarti che il tuo sistema funzioni in modo ottimale! 🚀

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!

🔍 Verificare Record DNS con Bash: Script Pratico per Admin Reti

In ambienti aziendali o laboratori, è fondamentale sapere se i propri record DNS (A, MX, PTR, SRV…) sono correttamente configurati e risolvibili. Ecco uno script in Bash che permette di eseguire questa verifica in modo semplice, elegante e documentato — con output in un file di log.

🧪 Cos’è questo script?

Un semplice tool scritto in Bash che:

  • interroga una lista personalizzata di record DNS
  • gestisce diversi tipi (A, MX, PTR, SRV)
  • salva i risultati in un file di log con timestamp
  • usa dig per ottenere le risposte dal server DNS specificato

📜 Il codice

#!/bin/bash

# 🔧 Configura IP del tuo DNS server (es. Unbound locale)
DNS_SERVER="192.168.3.123"

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
LOGFILE="$SCRIPT_DIR/dnscheck.log"

# 🧹 Pulizia del log: ogni esecuzione parte da zero
> "$LOGFILE"

DATE=$(date '+%Y-%m-%d %H:%M:%S')
echo "🔍 DNS Check — $DATE" >> "$LOGFILE"
echo "==========================" >> "$LOGFILE"

# 📋 Lista dei record da interrogare: nome,tipo
RECORDS=$(cat <<EOF
smtp.internal2.lan,A
internal2.lan,MX
192.168.3.83,PTR
_ldap._tcp.internal2.lan,SRV
_kerberos._tcp.internal2.lan,SRV
_kerberos._udp.internal2.lan,SRV
_ldap._tcp.gc._msdcs.internal2.lan,SRV
ns8.internal.lan,A
internal.lan,MX
192.168.3.76,PTR
dc1.ad.internal.lan,A
_ldap._tcp.internal.lan,SRV
_kerberos._tcp.internal.lan,SRV
_kerberos._udp.internal.lan,SRV
_ldap._tcp.gc._msdcs.internal.lan,SRV
EOF
)

# 🔄 Loop per interrogare ogni record e verificare risposta
IFS=$'\n'
for entry in $RECORDS; do
    NAME=$(echo "$entry" | cut -d',' -f1)
    TYPE=$(echo "$entry" | cut -d',' -f2)

    echo -ne "🔎 [$TYPE] $NAME... " >> "$LOGFILE"

    if [ "$TYPE" = "PTR" ]; then
        RESULT=$(dig -x "$NAME" @$DNS_SERVER +short)
    else
        RESULT=$(dig "$NAME" "$TYPE" @$DNS_SERVER +short)
    fi

    if [ -z "$RESULT" ]; then
        echo "❌ Nessuna risposta" >> "$LOGFILE"
    else
        echo "$RESULT" >> "$LOGFILE"
    fi
done

echo -e "✅ Fine verifica\n" >> "$LOGFILE"

🛡️ Come usarlo

  1. Imposta il server DNS in DNS_SERVER (es. 192.168.3.123).
  2. Personalizza la lista RECORDS con i nomi e tipi che vuoi controllare.
  3. Salva lo script come dnscheck.sh, rendilo eseguibile (chmod +x dnscheck.sh) ed eseguilo.
  4. I risultati verranno salvati in dnscheck.log nella stessa directory.