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

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

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!

Arduino

Arduino è un sistema open-source che consiste in un microcontrollore e un software libero che permette di sviluppare applicazioni hardware e software basate sulla tecnologia Internet delle cose (IoT). Il microcontrollore Arduino è un dispositivo elettronico programmabile che può essere utilizzato per controllare e monitorare diversi tipi di dispositivi fisici e ambientali come sensori di luce, pressione e temperatura. Il software Arduino è un ambiente di sviluppo integrato (IDE) che consiste in un editor di codice, un compilatore e un emulatori che permettono di scrivere e testare codice sorgenti in linguaggio C++ o altre lingue supportate dal sistema. L’IDE Arduino fornisce anche un’interfaccia utente grafica che consente agli utenti di configurare e controllare i dispositivi fisici collegati al microcontrollore senza dover scrivere codice manuale.

Per iniziare a programmare Arduino, occorrono alcuni strumenti e materiali fondamentali. Innanzitutto, è necessario acquistare un microcontrollore Arduino e uno o più dispositivi fisici che vogliamo controllare o monitorare. Il microcontrollore Arduino può essere acquistato in diversi formati e modelli, adattabili alle diverse esigenze e abilità degli utenti. Per lo sviluppo di applicazioni più avanzate o complessi, è possibile utilizzare schede Arduino più grandi come Arduino Mega o Arduino Due. Per applicazioni più semplici o di prova, è possibile utilizzare schede Arduino più piccole come Arduino Uno o Arduino Nano.
Inoltre, occorre avere accesso ad uno strumento di programmazione come Arduino IDE (Integrated Development Environment). L’IDE Arduino è disponibile gratuitamente e può essere scaricato dal sito web ufficiale di Arduino. L’IDE fornisce un ambiente di sviluppo integrato che consiste in un editor di codice, un compilatore e un emulatori che permettono di scrivere e testare codice sorgenti in linguaggio C++ o altre lingue supportate dal sistema. L’IDE Arduino è compatibile con diversi sistemi operativi come Windows, macOS e Linux.
Infine, è necessario avere familiarità con alcuni concetti di base di programmazione come variabili, cicli e funzioni. Per imparare questi concetti e sviluppare le proprie abilità di programmazione Arduino, è possibile consultare manuali di riferimento e corsi online gratuiti o paganti.

In questo articolo faremo un esempio pratico di come programmare l’arduino utilizzando il linguaggio C++. Per prima cosa dobbiamo collegare l’arduino al computer tramite il cavo USB. Una volta fatto questo possiamo aprire l’IDE Arduino sul nostro computer. L’IDE Arduino è uno strumento software gratuito disponibile per Windows, Mac OS X e Linux. Una volta aperto l’IDE Arduino possiamo iniziare a scrivere il nostro codice. Per prima cosa dobbiamo includere la libreria necessaria per utilizzare l’arduino con il linguaggio C++. Per fare questo dobbiamo aggiungere la seguente riga di codice all’inizio del nostro programma:

#include <Arduino.h>

Ora possiamo iniziare a scrivere il nostro codice per controllare l’arduino. Per fare questo dobbiamo utilizzare la funzione setup() per inizializzare l’arduino e la funzione loop() per controllare il ciclo continuo dell’arduino. Ad esempio, possiamo utilizzare la funzione digitalWrite() per controllare il pin digitale dell’arduino. Per fare questo dobbiamo aggiungere il seguente codice al nostro programma:

#include <Arduino.h>
void setup() {
// inizializza il pin digitale come uscita
pinMode(13, OUTPUT);
// accende la luce LED collegata al pin digitale 13
digitalWrite(13, HIGH);
}
void loop() {
// mantieni il ciclo continuo
delay(1000);
}

In questo esempio abbiamo utilizzato la funzione digitalWrite() per controllare il pin digitale dell’arduino collegato al LED. Abbiamo impostato il pin come uscita utilizzando la funzione pinMode() e abbiamo acceso il LED utilizzando la funzione digitalWrite() con il valore HIGH. Abbiamo anche utilizzato la funzione delay() per creare una pausa di 1000 millisecondi tra ogni ciclo del loop(). Questo ci permette di vedere il LED lampeggiare con una frequenza di 1 Hz. Questo è solo un esempio molto basilare per mostrare come programmare l’arduino utilizzando il linguaggio C++. Ci sono molte altre funzioni e caratteristiche disponibili nell’IDE Arduino per creare progetti più complessi e interessanti con l’arduino. Speriamo che questo articolo ti sia stato utile per iniziare con la programmazione dell’arduino utilizzando il linguaggio C++. Buona fortuna con i tuoi progetti futuri!

HomeAssistant

HomeAssistant è una piattaforma open source per la gestione domotica, sviluppata con Python e basata su front-end e back-end web technologie. La piattaforma consente di gestire e monitorare diversi dispositivi domotici come ad esempio luci, termostati, serrature, sensori e altro ancora, da un singolo punto di controllo centrale, come ad esempio un computer, smartphone o tablet. La piattaforma offre funzionalità avanzate come automazione, scripting, integrazione con altri sistemi domotici e supporto per diversi protocolli di comunicazione come Zigbee, Z-Wave, MQTT, HTTP e altro ancora. L’interfaccia utente di HomeAssistant può essere personalizzata e adattata alle esigenze specifiche degli utenti attraverso temi e plug-in sviluppati dalla comunità.

La piattaforma si compone di due parti principali, il front-end e il back-end. Il front-end è l’interfaccia utente web, attraverso la quale gli utenti possono gestire i dispositivi domotici e visualizzare le informazioni raccolte dal sistema. Il back-end, invece, gestisce la logica di base e le comunicazioni con i dispositivi domotici, rendendo possibile la gestione e il monitoraggio degli stessi. Il back-end di HomeAssistant utilizza Python e diversi framework web come Django e Flask per gestire le richieste provenienti dall’interfaccia utente e le risposte alle stesse.

Per gestire i dispositivi domotici, HomeAssistant supporta diversi protocolli di comunicazione come Zigbee, Z-Wave, MQTT, HTTP e altro ancora. Questi protocolli consentono di comunicare con i dispositivi domotici utilizzando diversi tipi di tecnologie, come ad esempio Wi-Fi, Bluetooth Low Energy (BLE) e altre reti wireless locali (WLAN). La piattaforma può essere configurata per utilizzare uno o più gateway, cioè dispositivi specializzati per la conversione tra diversi protocolli e la comunicazione con il back-end di HomeAssistant.

HomeAssistant offre funzionalità avanzate come automazione, scripting e integrazione con altri sistemi domotici. L’automazione permette di creare sequenze di azioni da eseguire automaticamente quando si verificano determinate condizioni, ad esempio accendere le luci del soggiorno quando si attiva il sensore di movimento della porta d’ingresso o abbassare la temperatura della stanza quando si raggiunge un certo livello di umidità. Il scripting consente di scrivere codice Python personalizzato per estendere le funzionalità della piattaforma e integrare altri sistemi domotici non supportati direttamente da HomeAssistant. Infine, l’integrazione con altri sistemi domotici permette di collegare la piattaforma ad altri servizi e prodotti domotici, come ad esempio Amazon Alexa, Google Assistant, IFTTT e altro ancora, per estendere ulteriormente le funzionalità di gestione domotica offerte da HomeAssistant.

Configurazione mqtt