Progetto 125 – Sistema notifiche su display

🚀 Introduzione

Vuoi fare in modo che Arduino mostri automaticamente avvisi e messaggi quando qualcosa cambia?🔔

In questo progetto realizzerai un sistema di notifiche su display OLED capace di controllare temperatura e luminosità ambientale.

Quando uno dei valori supera le soglie impostate, Arduino sostituisce la schermata normale con una notifica ben visibile.

👉 Il sistema può essere utilizzato come base per allarmi ambientali, serre automatiche, centraline domotiche e dispositivi di monitoraggio.

🎯 Cosa realizzerai

Con Arduino creerai un sistema che:

🌡️ misura la temperatura ambientale
💡 controlla la luminosità tramite fotoresistenza
📟 mostra i valori normali sul display OLED
⚠️ visualizza una notifica di temperatura elevata
🌑 segnala quando l’ambiente è troppo buio
🔁 alterna le notifiche quando sono presenti più avvisi
✅ permette di confermare temporaneamente una notifica
⏱️ aggiorna il sistema senza bloccare Arduino

🧰 Materiale necessario

1x Arduino UNO
1x display OLED 0,96 pollici I2C SSD1306
1x sensore DHT11
1x fotoresistenza LDR
1x resistenza da 10kΩ
1x pulsante
cavetti jumper
breadboard
cavo USB

Il pulsante utilizza la resistenza interna INPUT_PULLUP di Arduino, quindi non richiede una resistenza esterna.

🛒 Non hai ancora i componenti?

Molti dei progetti presenti su progettiarduino.com utilizzano componenti elettronici di base come LED, resistenze, sensori e breadboard.
Se stai iniziando con Arduino, il modo più semplice è utilizzare un kit completo per principianti, che include quasi tutti i componenti necessari per realizzare molti dei progetti presenti sul sito.

👉 Kit Arduino consigliato:
ℹ️ Link di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.
https://amzn.to/4b3dxjW

📘 Vuoi imparare Arduino passo dopo passo?
Se vuoi approfondire e realizzare progetti più completi, puoi dare un'occhiata anche ai miei libri dedicati ad Arduino.
All'interno troverai spiegazioni semplici, schemi chiari e molti progetti pratici pensati per chi parte da zero.

👉 Scopri i miei libri su Arduino:
ℹ️ Link di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.
https://amzn.to/4rfzjXE

📚 Librerie necessarie

Per realizzare il progetto devi installare:

Adafruit SSD1306
Adafruit GFX Library
DHT sensor library
Adafruit Unified Sensor

Puoi installarle dal Gestore librerie dell’Arduino IDE:

apri Arduino IDE;
vai su Sketch → Include Library → Manage Libraries;
cerca il nome della libreria;
premi Install;
ripeti l’operazione per tutte le librerie richieste.

🔌 Schema di collegamento

Display OLED SSD1306

VCC → 5V
GND → GND
SDA → A4
SCL → A5

L’indirizzo I2C utilizzato nel codice è 0x3C.

Sensore DHT11

VCC → 5V
GND → GND
DATA → pin digitale 2

Se utilizzi un DHT11 senza modulo, collega una resistenza da 10kΩ tra DATA e 5V.

Fotoresistenza LDR
Realizza un partitore di tensione:

un terminale della fotoresistenza → 5V
terminale opposto → A0
resistenza da 10kΩ tra A0 e GND

Pulsante di conferma

un terminale → pin digitale 3
terminale opposto → GND

Poiché viene utilizzata la modalità INPUT_PULLUP, il pulsante premuto viene letto come LOW.

💻 Codice Arduino

Il programma controlla continuamente temperatura e luminosità.
In condizioni normali, il display mostra una schermata con i valori rilevati.

Quando una soglia viene superata, Arduino mostra una notifica:

temperatura alta;
ambiente troppo buio;
entrambe le condizioni contemporaneamente.

Il pulsante permette di confermare temporaneamente la notifica.

/*
============================================================
Progetto 125 - Sistema notifiche su display OLED
Mostra avvisi per temperatura alta e luminosita bassa
============================================================
*/

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <DHT.h>

// Dimensioni del display OLED
#define LARGHEZZA_DISPLAY 128
#define ALTEZZA_DISPLAY 64
#define RESET_OLED -1

// Configurazione del sensore DHT11
#define PIN_DHT 2
#define TIPO_DHT DHT11

// Pin della fotoresistenza e del pulsante
#define PIN_LUCE A0
#define PIN_PULSANTE 3

// Soglie che attivano le notifiche
const float SOGLIA_TEMPERATURA = 30.0;
const int SOGLIA_LUMINOSITA = 25;

// Intervallo tra due letture dei sensori
const unsigned long INTERVALLO_LETTURA = 2000;

// Tempo utilizzato per alternare più notifiche
const unsigned long INTERVALLO_NOTIFICHE = 2000;

// Durata della conferma temporanea della notifica
const unsigned long DURATA_CONFERMA = 5000;

// Tempo antirimbalzo del pulsante
const unsigned long TEMPO_DEBOUNCE = 180;

// Oggetti per il display e il sensore
Adafruit_SSD1306 display(
LARGHEZZA_DISPLAY,
ALTEZZA_DISPLAY,
&Wire,
RESET_OLED
);

DHT dht(PIN_DHT, TIPO_DHT);

// Valori letti dai sensori
float temperatura = 0.0;
int luminositaPercentuale = 0;

// Stato del sensore DHT11
bool sensoreDhtValido = false;

// Stati delle notifiche
bool allarmeTemperatura = false;
bool allarmeLuminosita = false;

// Indica se una notifica è stata confermata
bool notificaConfermata = false;

// Tempi utilizzati dal programma
unsigned long ultimoAggiornamento = 0;
unsigned long ultimoCambioNotifica = 0;
unsigned long inizioConferma = 0;
unsigned long ultimaPressione = 0;

// Indice usato per alternare le notifiche
byte notificaVisualizzata = 0;

void setup() {
// Il pulsante utilizza la resistenza interna di Arduino
pinMode(PIN_PULSANTE, INPUT_PULLUP);

// Avvia il sensore DHT11
dht.begin();

// Inizializza il display OLED all'indirizzo I2C 0x3C
if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
// Se il display non viene rilevato,
// Arduino rimane bloccato in questo ciclo
while (true) {
}
}

display.clearDisplay();
display.setTextColor(SSD1306_WHITE);
display.setTextSize(1);

// Mostra la schermata iniziale
display.setCursor(12, 20);
display.println("Sistema notifiche");

display.setCursor(28, 36);
display.println("Progetto 125");

display.display();

delay(1800);

// Esegue subito una prima lettura
leggiSensori();
aggiornaNotifiche();
mostraSchermata();

ultimoAggiornamento = millis();
}

void loop() {
// Controlla il pulsante di conferma
gestisciPulsante();

// Legge periodicamente i sensori
// senza bloccare Arduino con delay()
if (millis() - ultimoAggiornamento >= INTERVALLO_LETTURA) {
ultimoAggiornamento = millis();

leggiSensori();
aggiornaNotifiche();
}

// Se ci sono più notifiche, le alterna
if (numeroNotificheAttive() > 1 &&
millis() - ultimoCambioNotifica >= INTERVALLO_NOTIFICHE) {
ultimoCambioNotifica = millis();

notificaVisualizzata++;

if (notificaVisualizzata >= numeroNotificheAttive()) {
notificaVisualizzata = 0;
}
}

// Dopo alcuni secondi termina la conferma temporanea
if (notificaConfermata &&
millis() - inizioConferma >= DURATA_CONFERMA) {
notificaConfermata = false;
}

// Ridisegna continuamente la schermata corretta
mostraSchermata();
}

void leggiSensori() {
// Legge la temperatura in gradi Celsius
float nuovaTemperatura = dht.readTemperature();

// Controlla se il DHT11 ha restituito un valore valido
if (isnan(nuovaTemperatura)) {
sensoreDhtValido = false;
} else {
sensoreDhtValido = true;
temperatura = nuovaTemperatura;
}

// Legge il partitore formato da fotoresistenza
// e resistenza da 10kΩ
int valoreLuce = analogRead(PIN_LUCE);

// Converte il valore analogico in percentuale
luminositaPercentuale = map(
valoreLuce,
0,
1023,
0,
100
);

// Mantiene il risultato tra 0 e 100
luminositaPercentuale = constrain(
luminositaPercentuale,
0,
100
);
}

void aggiornaNotifiche() {
// L'allarme temperatura viene attivato solo
// quando il sensore DHT11 funziona correttamente
allarmeTemperatura =
sensoreDhtValido &&
temperatura >= SOGLIA_TEMPERATURA;

// L'allarme luminosità si attiva quando
// la percentuale scende sotto la soglia
allarmeLuminosita =
luminositaPercentuale <= SOGLIA_LUMINOSITA;

// Se non ci sono più notifiche,
// annulla automaticamente la conferma
if (numeroNotificheAttive() == 0 &&
sensoreDhtValido) {
notificaConfermata = false;
notificaVisualizzata = 0;
}
}

void gestisciPulsante() {
// Con INPUT_PULLUP il pulsante premuto viene letto come LOW
if (digitalRead(PIN_PULSANTE) == LOW &&
millis() - ultimaPressione >= TEMPO_DEBOUNCE) {
ultimaPressione = millis();

// La conferma viene accettata solo
// quando esiste almeno una notifica
if (numeroNotificheAttive() > 0 ||
!sensoreDhtValido) {
notificaConfermata = true;
inizioConferma = millis();
}
}
}

byte numeroNotificheAttive() {
byte numero = 0;

// L'errore del DHT11 ha priorità
// e viene considerato come una notifica
if (!sensoreDhtValido) {
numero++;
}

if (allarmeTemperatura) {
numero++;
}

if (allarmeLuminosita) {
numero++;
}

return numero;
}

void mostraSchermata() {
// Pulisce il display prima di ridisegnarlo
display.clearDisplay();
display.setTextColor(SSD1306_WHITE);

// Durante la conferma temporanea
// viene mostrata la dashboard normale
if (notificaConfermata) {
mostraDashboard(true);
} else if (numeroNotificheAttive() > 0) {
mostraNotificaAttiva();
} else {
mostraDashboard(false);
}

// Invia al display tutti gli elementi disegnati
display.display();
}

void mostraDashboard(bool confermata) {
display.setTextSize(1);

// Titolo della schermata normale
display.setCursor(0, 0);
display.print("MONITOR AMBIENTE");

display.drawLine(
0,
10,
127,
10,
SSD1306_WHITE
);

// Mostra la temperatura oppure l'errore
display.setCursor(0, 17);
display.print("Temperatura: ");

if (sensoreDhtValido) {
display.print(temperatura, 1);
display.print((char)247);
display.print("C");
} else {
display.print("ERR");
}

// Mostra la luminosità in percentuale
display.setCursor(0, 32);
display.print("Luminosita: ");
display.print(luminositaPercentuale);
display.print("%");

// Mostra lo stato generale del sistema
display.setCursor(0, 48);

if (confermata) {
display.print("Avviso confermato");
} else {
display.print("Stato: NORMALE");
}

display.setCursor(0, 57);

if (confermata) {
display.print("Riappare tra poco");
} else {
display.print("Monitoraggio attivo");
}
}

void mostraNotificaAttiva() {
// Recupera il tipo di notifica da mostrare
byte tipoNotifica =
trovaNotificaDaVisualizzare(notificaVisualizzata);

// Disegna un bordo attorno alla notifica
display.drawRect(
0,
0,
128,
64,
SSD1306_WHITE
);

display.setTextSize(1);
display.setCursor(36, 5);
display.print("AVVISO");

display.drawLine(
8,
15,
119,
15,
SSD1306_WHITE
);

// Mostra il messaggio corrispondente
if (tipoNotifica == 0) {
mostraErroreDht();
} else if (tipoNotifica == 1) {
mostraAllarmeTemperatura();
} else if (tipoNotifica == 2) {
mostraAllarmeLuminosita();
}

// Indicazione per il pulsante
display.setTextSize(1);
display.setCursor(9, 54);
display.print("Premi per confermare");
}

byte trovaNotificaDaVisualizzare(byte indice) {
byte posizione = 0;

// Controlla prima l'errore del sensore
if (!sensoreDhtValido) {
if (posizione == indice) {
return 0;
}

posizione++;
}

// Controlla la temperatura elevata
if (allarmeTemperatura) {
if (posizione == indice) {
return 1;
}

posizione++;
}

// Controlla la luminosità bassa
if (allarmeLuminosita) {
if (posizione == indice) {
return 2;
}
}

// Valore di sicurezza
return 0;
}

void mostraErroreDht() {
display.setTextSize(1);

display.setCursor(20, 22);
display.print("ERRORE SENSORE");

display.setCursor(25, 36);
display.print("Controlla DHT11");
}

void mostraAllarmeTemperatura() {
display.setTextSize(1);

display.setCursor(11, 22);
display.print("TEMPERATURA ALTA");

display.setTextSize(2);
display.setCursor(34, 35);
display.print(temperatura, 1);
display.print((char)247);
display.print("C");
}

void mostraAllarmeLuminosita() {
display.setTextSize(1);

display.setCursor(19, 22);
display.print("AMBIENTE BUIO");

display.setTextSize(2);
display.setCursor(42, 35);
display.print(luminositaPercentuale);
display.print("%");
}

⚙️ Come funziona

Arduino legge la temperatura dal sensore DHT11 e la luminosità dalla fotoresistenza.
Le soglie impostate nel programma sono:

temperatura massima: 30 °C;
luminosità minima: 25%.

Se la temperatura supera 30 °C, il display mostra:
TEMPERATURA ALTA

Se la luminosità scende sotto il 25%, appare:
AMBIENTE BUIO

Quando entrambi gli avvisi sono presenti, Arduino alterna automaticamente le due notifiche.

🔔 Gestione delle notifiche

Il programma utilizza una variabile per stabilire quale messaggio mostrare.

Le possibili condizioni sono:

nessuna notifica;
temperatura elevata;
luminosità troppo bassa;
più notifiche contemporaneamente.

Le notifiche vengono visualizzate con testo ingrandito e un bordo grafico, in modo da risultare subito riconoscibili.

✅ Conferma temporanea

Premendo il pulsante, la notifica viene confermata per alcuni secondi.
Durante questo intervallo Arduino torna alla schermata normale, ma continua a controllare i sensori.

Se la condizione di allarme rimane presente, la notifica riappare automaticamente dopo il tempo impostato.
👉 In questo modo il pulsante non elimina il problema, ma silenzia soltanto temporaneamente l’avviso visivo.

🔁 Più notifiche contemporaneamente

Se temperatura e luminosità superano entrambe le soglie, Arduino alterna i messaggi ogni due secondi.
Questo sistema evita di riempire il piccolo display OLED con troppo testo.

La stessa tecnica può essere estesa aggiungendo nuovi avvisi, come:

umidità elevata;
batteria scarica;
sensore scollegato;
serbatoio vuoto;
porta aperta.

🔄 Varianti possibili

Vuoi migliorare il progetto?

🔊 aggiungi un buzzer per le notifiche sonore
🚨 collega un LED rosso di allarme
💧 aggiungi una notifica per l’umidità
🔋 segnala quando una batteria è scarica
💾 salva gli eventi nella memoria EEPROM
⏰ registra l’ora delle notifiche con RTC DS3231
📶 invia gli avvisi tramite Wi-Fi
🎛️ aggiungi pulsanti per modificare le soglie
📋 crea un elenco delle ultime notifiche
🔔 assegna priorità diverse agli allarmi

Progetto 125 ​Sistema notifiche su display

Progetto 125
Sistema notifiche su display