🚀 Introduzione
​
Vuoi capire subito se un progetto Arduino sta funzionando correttamente, senza collegarlo ogni volta al computer? 🛠️📟

In questo progetto realizzerai un sistema di debug con LED e display OLED, capace di mostrare lo stato di più componenti.

Tre LED indicheranno rapidamente la condizione generale:
  • verde → sistema regolare;
  • giallo → attenzione;
  • rosso → errore.

Il display OLED mostrerà invece informazioni più dettagliate, come stato del sensore, valori letti e codice dell’eventuale problema.
​
👉 È una tecnica molto utile nei progetti complessi, dove serve capire rapidamente quale parte del sistema non sta funzionando.
🎯 Cosa realizzerai
​
Con Arduino creerai un sistema che:
  • 🌡️ controlla un sensore DHT22;
  • 💡 legge una fotoresistenza;
  • 🟢 segnala il funzionamento corretto;
  • 🟡 mostra una condizione di attenzione;
  • 🔴 segnala un errore;
  • 📟 visualizza messaggi di debug su OLED;
  • 🔘 permette di cambiare schermata;
  • 🧪 esegue un test iniziale dei LED;
  • ⚠️ assegna un codice ai problemi;
  • ⏱️ aggiorna il sistema senza bloccare Arduino.
🧰 Materiale necessario
​
  • 1x Arduino UNO;
  • 1x display OLED 0,96 pollici I2C SSD1306;
  • 1x sensore DHT22;
  • 1x resistenza da 10 kΩ, se utilizzi il DHT22 senza modulo;
  • 1x fotoresistenza LDR;
  • 1x resistenza da 10 kΩ per il partitore;
  • 1x LED verde;
  • 1x LED giallo;
  • 1x LED rosso;
  • 3x resistenze da 220 Ω;
  • 1x pulsante;
  • cavetti jumper;
  • breadboard;
  • cavo USB.
🛒 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.
La libreria Wire è già inclusa nell’Arduino IDE.
🔌 Schema di collegamento
​
Display OLED SSD1306
  • VCC → 5V;
  • GND → GND;
  • SDA → A4;
  • SCL → A5.
L’indirizzo I2C utilizzato nel codice è 0x3C.
​
Sensore DHT22
Se utilizzi un modulo già assemblato:
  • VCC → 5V;
  • GND → GND;
  • DATA → pin digitale 2.
Se utilizzi il sensore senza modulo, collega una resistenza da 10 kΩ tra DATA e 5V.

Fotoresistenza LDR
Realizza un partitore di tensione:
  • un terminale della fotoresistenza → 5V;
  • terminale opposto → A0;
  • resistenza da 10 kΩ tra A0 e GND.

LED verde
  • anodo → pin digitale 8 tramite resistenza da 220 Ω;
  • catodo → GND.

LED giallo
  • anodo → pin digitale 9 tramite resistenza da 220 Ω;
  • catodo → GND.

LED rosso
  • anodo → pin digitale 10 tramite resistenza da 220 Ω;
  • catodo → GND.

Pulsante
  • un terminale → pin digitale 3;
  • terminale opposto → GND.
Il pulsante utilizza la modalità INPUT_PULLUP.
💻 Codice Arduino
​
Il programma assegna al sistema tre livelli di stato:
  • STATO_OK;
  • STATO_ATTENZIONE;
  • STATO_ERRORE.

Lo stato viene determinato analizzando:
  • validità del DHT22;
  • temperatura;
  • umidità;
  • luminosità.

Il display mostra due schermate:
  • riepilogo generale;
  • dettagli di debug.
​/*
  ============================================================
  Progetto 138 - Sistema debug LED e display
  Mostra stato, avvisi e codici di errore del sistema
  ============================================================
*/

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

// Dimensioni e indirizzo del display OLED
#define LARGHEZZA_DISPLAY 128
#define ALTEZZA_DISPLAY 64
#define RESET_OLED -1
#define INDIRIZZO_OLED 0x3C

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

// Collegamenti degli altri componenti
#define PIN_PULSANTE 3
#define PIN_LED_VERDE 8
#define PIN_LED_GIALLO 9
#define PIN_LED_ROSSO 10
#define PIN_LUCE A0

// Soglie di attenzione
const float TEMP_ATTENZIONE = 28.0;
const float UMID_ATTENZIONE = 65.0;
const int LUCE_ATTENZIONE = 25;

// Soglie di errore
const float TEMP_ERRORE = 35.0;
const float UMID_ERRORE = 80.0;
const int LUCE_ERRORE = 10;

// Tempi di aggiornamento
const unsigned long INTERVALLO_LETTURA = 2000;
const unsigned long TEMPO_DEBOUNCE = 180;

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

DHT dht(PIN_DHT, TIPO_DHT);

// Livelli generali del sistema
enum LivelloSistema {
  STATO_OK,
  STATO_ATTENZIONE,
  STATO_ERRORE
};

LivelloSistema livelloAttuale = STATO_OK;

// Codici di debug disponibili
enum CodiceDebug {
  DEBUG_OK,
  DEBUG_DHT,
  DEBUG_TEMPERATURA,
  DEBUG_UMIDITA,
  DEBUG_LUMINOSITA
};

CodiceDebug codiceAttuale = DEBUG_OK;

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

// Indica se il DHT22 ha restituito dati validi
bool sensoreDhtValido = false;

// Schermata attualmente visualizzata
byte schermataAttuale = 0;
const byte NUMERO_SCHERMATE = 2;

// Variabili temporali
unsigned long ultimaLettura = 0;
unsigned long ultimaPressione = 0;
unsigned long ultimoAggiornamentoValido = 0;

// Indica quando il display deve essere ridisegnato
bool aggiornamentoDisplayRichiesto = true;

void setup() {
  // Il pulsante è collegato tra il pin e GND
  pinMode(PIN_PULSANTE, INPUT_PULLUP);

  // Configura i tre LED come uscite
  pinMode(PIN_LED_VERDE, OUTPUT);
  pinMode(PIN_LED_GIALLO, OUTPUT);
  pinMode(PIN_LED_ROSSO, OUTPUT);

  // Spegne tutti i LED durante l'avvio
  spegniTuttiLed();

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

  // Inizializza il display OLED
  if (!display.begin(
        SSD1306_SWITCHCAPVCC,
        INDIRIZZO_OLED
      )) {
    // Se il display non viene rilevato,
    // il programma rimane bloccato
    while (true) {
    }
  }

  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);
  display.setTextWrap(false);

  mostraAvvio();

  // Esegue un test rapido dei LED
  testLed();

  // Esegue subito una prima lettura
  leggiSensori();
  valutaSistema();
  aggiornaLed();
  mostraSchermata();

  ultimaLettura = millis();
  aggiornamentoDisplayRichiesto = false;
}

void loop() {
  // Controlla il pulsante per cambiare schermata
  gestisciPulsante();

  // Legge periodicamente i sensori
  if (millis() - ultimaLettura >= INTERVALLO_LETTURA) {
    ultimaLettura = millis();

    leggiSensori();
    valutaSistema();
    aggiornaLed();

    aggiornamentoDisplayRichiesto = true;
  }

  // Ridisegna il display soltanto quando necessario
  if (aggiornamentoDisplayRichiesto) {
    mostraSchermata();
    aggiornamentoDisplayRichiesto = false;
  }
}

void leggiSensori() {
  // Legge temperatura e umidità dal DHT22
  float nuovaTemperatura = dht.readTemperature();
  float nuovaUmidita = dht.readHumidity();

  // Aggiorna i valori soltanto
  // se entrambe le letture sono valide
  if (!isnan(nuovaTemperatura) &&
      !isnan(nuovaUmidita)) {
    temperatura = nuovaTemperatura;
    umidita = nuovaUmidita;
    sensoreDhtValido = true;

    // Memorizza il momento dell'ultima lettura valida
    ultimoAggiornamentoValido = millis();
  } else {
    sensoreDhtValido = false;
  }

  // Legge la fotoresistenza
  int valoreLuce = analogRead(PIN_LUCE);

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

  luminositaPercentuale = constrain(
    luminositaPercentuale,
    0,
    100
  );
}

void valutaSistema() {
  /*
    Gli errori hanno priorità sulle condizioni
    di attenzione. Il primo errore trovato
    determina il codice mostrato sul display.
  */

  // Errore di comunicazione con il DHT22
  if (!sensoreDhtValido) {
    livelloAttuale = STATO_ERRORE;
    codiceAttuale = DEBUG_DHT;
    return;
  }

  // Temperatura oltre la soglia critica
  if (temperatura >= TEMP_ERRORE) {
    livelloAttuale = STATO_ERRORE;
    codiceAttuale = DEBUG_TEMPERATURA;
    return;
  }

  // Umidità oltre la soglia critica
  if (umidita >= UMID_ERRORE) {
    livelloAttuale = STATO_ERRORE;
    codiceAttuale = DEBUG_UMIDITA;
    return;
  }

  // Luminosità sotto la soglia critica
  if (luminositaPercentuale <= LUCE_ERRORE) {
    livelloAttuale = STATO_ERRORE;
    codiceAttuale = DEBUG_LUMINOSITA;
    return;
  }

  // Controlla le condizioni di attenzione
  if (temperatura >= TEMP_ATTENZIONE ||
      umidita >= UMID_ATTENZIONE ||
      luminositaPercentuale <= LUCE_ATTENZIONE) {
    livelloAttuale = STATO_ATTENZIONE;
    codiceAttuale = DEBUG_OK;
    return;
  }

  // Nessun problema rilevato
  livelloAttuale = STATO_OK;
  codiceAttuale = DEBUG_OK;
}

void aggiornaLed() {
  // Spegne prima tutti i LED
  spegniTuttiLed();

  // Accende il LED corrispondente
  // al livello generale del sistema
  if (livelloAttuale == STATO_OK) {
    digitalWrite(PIN_LED_VERDE, HIGH);
  } else if (livelloAttuale == STATO_ATTENZIONE) {
    digitalWrite(PIN_LED_GIALLO, HIGH);
  } else {
    digitalWrite(PIN_LED_ROSSO, HIGH);
  }
}

void spegniTuttiLed() {
  digitalWrite(PIN_LED_VERDE, LOW);
  digitalWrite(PIN_LED_GIALLO, LOW);
  digitalWrite(PIN_LED_ROSSO, LOW);
}

void testLed() {
  // Accende in sequenza i LED
  // per verificarne collegamento e polarità
  spegniTuttiLed();

  digitalWrite(PIN_LED_VERDE, HIGH);
  delay(350);
  digitalWrite(PIN_LED_VERDE, LOW);

  digitalWrite(PIN_LED_GIALLO, HIGH);
  delay(350);
  digitalWrite(PIN_LED_GIALLO, LOW);

  digitalWrite(PIN_LED_ROSSO, HIGH);
  delay(350);
  digitalWrite(PIN_LED_ROSSO, LOW);
}

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

    // Passa alla schermata successiva
    schermataAttuale++;

    if (schermataAttuale >= NUMERO_SCHERMATE) {
      schermataAttuale = 0;
    }

    aggiornamentoDisplayRichiesto = true;
  }
}

void mostraSchermata() {
  // Pulisce completamente il display
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);

  if (schermataAttuale == 0) {
    mostraRiepilogo();
  } else {
    mostraDebug();
  }

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

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

  // Titolo della schermata
  display.setCursor(0, 0);
  display.print("STATO SISTEMA");

  display.setCursor(103, 0);
  display.print("1/2");

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

  // Mostra il livello generale
  display.setCursor(0, 16);
  display.print("Livello: ");

  if (livelloAttuale == STATO_OK) {
    display.print("OK");
  } else if (livelloAttuale == STATO_ATTENZIONE) {
    display.print("ATTENZIONE");
  } else {
    display.print("ERRORE");
  }

  // Mostra la temperatura
  display.setCursor(0, 29);
  display.print("Temp: ");

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

  // Mostra l'umidità
  display.setCursor(0, 42);
  display.print("Umid: ");

  if (sensoreDhtValido) {
    display.print(umidita, 1);
    display.print("%");
  } else {
    display.print("ERR");
  }

  // Mostra la luminosità
  display.setCursor(0, 55);
  display.print("Luce: ");
  display.print(luminositaPercentuale);
  display.print("%");
}

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

  display.setCursor(0, 0);
  display.print("DEBUG SISTEMA");

  display.setCursor(103, 0);
  display.print("2/2");

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

  // Mostra il codice di debug
  display.setCursor(0, 16);
  display.print("Codice: ");
  display.print(testoCodiceDebug());

  // Mostra lo stato del DHT22
  display.setCursor(0, 29);
  display.print("DHT22: ");

  if (sensoreDhtValido) {
    display.print("ONLINE");
  } else {
    display.print("ERRORE");
  }

  // Mostra il tempo trascorso dall'ultima
  // lettura valida del sensore
  display.setCursor(0, 42);
  display.print("Ultimo OK: ");

  unsigned long secondiTrascorsi =
    (millis() - ultimoAggiornamentoValido) / 1000UL;

  display.print(secondiTrascorsi);
  display.print("s");

  // Mostra il LED che dovrebbe essere acceso
  display.setCursor(0, 55);
  display.print("LED: ");

  if (livelloAttuale == STATO_OK) {
    display.print("VERDE");
  } else if (livelloAttuale == STATO_ATTENZIONE) {
    display.print("GIALLO");
  } else {
    display.print("ROSSO");
  }
}

const char* testoCodiceDebug() {
  // Restituisce il testo corrispondente
  // al codice di errore corrente
  switch (codiceAttuale) {
    case DEBUG_DHT:
      return "D01";

    case DEBUG_TEMPERATURA:
      return "D02";

    case DEBUG_UMIDITA:
      return "D03";

    case DEBUG_LUMINOSITA:
      return "D04";

    case DEBUG_OK:
    default:
      return "D00";
  }
}

void mostraAvvio() {
  display.clearDisplay();
  display.setTextSize(1);

  display.setCursor(19, 14);
  display.print("Sistema debug");

  display.setCursor(19, 30);
  display.print("LED + display");

  display.setCursor(28, 47);
  display.print("Progetto 138");

  display.display();

  delay(1800);
}
⚙️ Come funziona

Arduino legge temperatura, umidità e luminosità ogni due secondi.
Successivamente controlla le condizioni del sistema.

Se tutto rientra nei limiti:
  • si accende il LED verde;
  • il display mostra SISTEMA OK.

Se un valore si avvicina a una soglia critica:
  • si accende il LED giallo;
  • il display mostra ATTENZIONE.

Se il sensore non risponde oppure un valore supera una soglia critica:
  • si accende il LED rosso;
  • il display mostra un codice di errore.
🟢 Stato regolare
​
Il LED verde si accende quando:
  • il DHT22 risponde correttamente;
  • la temperatura è entro i limiti;
  • l’umidità è entro i limiti;
  • la luminosità non è troppo bassa.
Il display mostra anche i valori principali del sistema.
🟡 Stato di attenzione
​
Il LED giallo indica una condizione che non è ancora un errore grave.
Per esempio:
  • temperatura superiore a 28 °C;
  • umidità superiore al 65%;
  • luminosità inferiore al 25%.
Questi valori possono essere modificati facilmente all’inizio del programma.
🔴 Stato di errore
​
Il LED rosso viene attivato quando:
  • il DHT22 non restituisce dati validi;
  • la temperatura supera 35 °C;
  • l’umidità supera 80%;
  • la luminosità scende sotto il 10%.
Il display mostra il codice associato al problema.
⚠️ Codici di debug
​
Il sistema utilizza i seguenti codici:
  • D00 → nessun errore;
  • D01 → sensore DHT22 non disponibile;
  • D02 → temperatura troppo elevata;
  • D03 → umidità troppo elevata;
  • D04 → luminosità troppo bassa.
Quando sono presenti più anomalie, il programma mostra quella con priorità più alta.
🧪 Test iniziale dei LED
​
All’accensione Arduino esegue un breve test:
  1. accende il LED verde;
  2. accende il LED giallo;
  3. accende il LED rosso;
  4. spegne tutti i LED.
​
Questo permette di verificare immediatamente:
  • collegamenti;
  • polarità;
  • funzionamento dei LED.
📟 Schermate disponibili
​
Premendo il pulsante puoi passare tra due schermate.

Schermata generale
Mostra:
  • stato del sistema;
  • temperatura;
  • umidità;
  • luminosità.

Schermata debug
Mostra:
  • codice di debug;
  • stato del DHT22;
  • ultimo aggiornamento;
  • livello generale.
🧠 Perché è un progetto importante
​
Con questo progetto impari a:
  • creare un sistema di debug autonomo;
  • utilizzare LED come indicatori di stato;
  • assegnare livelli di priorità;
  • mostrare codici di errore;
  • distinguere attenzione ed errore;
  • testare le uscite all’avvio;
  • creare più schermate OLED;
  • gestire sensori senza bloccare il programma;
  • organizzare la diagnostica in funzioni;
  • rendere più semplice la manutenzione di un progetto.
​
👉 Questa tecnica è molto utile nei sistemi domotici, nei robot, nelle centraline e nei progetti installati lontano dal computer.
🔄 Varianti possibili
​
Vuoi migliorare il progetto?
  • 🔊 aggiungi un buzzer per gli errori;
  • 💾 salva l’ultimo errore nella EEPROM;
  • ⏰ registra l’ora con RTC DS3231;
  • 📋 crea uno storico degli eventi;
  • 🔘 aggiungi un pulsante di reset;
  • ⚡ controlla anche lo stato di un relè;
  • 🔋 aggiungi un controllo della batteria;
  • 🚪 collega un reed switch;
  • 🚶 aggiungi un sensore PIR;
  • 📶 invia i codici di errore tramite Wi-Fi;
  • 🗃️ salva il debug su scheda microSD;
  • 🌈 sostituisci i tre LED con un LED RGB.