Termometro con display LCD
Descrizione
Questo progetto è un sistema digitale di misurazione della temperatura basato su una scheda Arduino, un display LCD I2C e un sensore di temperatura analogico collegato al pin A0. Il circuito legge continuamente il valore del sensore, lo converte in una temperatura espressa in gradi Celsius e mostra il risultato su un display LCD 16x2 insieme a un simbolo personalizzato dei gradi. Il progetto include anche una schermata iniziale di benvenuto che visualizza “TERMOMETER” e “by Nemiatools” prima di passare al monitoraggio della temperatura in tempo reale. Grazie alla sua struttura semplice e all'output chiaro, è un ottimo progetto per imparare le basi dei sensori analogici, dei display LCD, dei caratteri personalizzati e del monitoraggio ambientale basato su Arduino. Può essere utilizzato come base per termometri digitali, stazioni meteorologiche, sistemi di monitoraggio degli ambienti o altre applicazioni elettroniche basate sulla temperatura.
Componenti necessari:
- 1x Arduino UNO
- 1x Display LCD con modulo I2C integrato
- 1x Sensore di temperatura TMP36 (o altri compatibili)
- Cavi jumper (breadboard opzionale)
Schema:
Codice:
// https://nemiatools.com
#include <Wire.h> // Includi la libreria di comunicazione I2C
#include <LiquidCrystal_I2C.h> // Libreria LCD
LiquidCrystal_I2C lcd_1(0x27, 16, 2); // Oggetto LCD
byte degree_symbol[8] = { // Simbolo di "grado"
B00110, // riga 1
B01001, // riga 2
B01001, // riga 3
B00110, // riga 4
B00000, // riga 5
B00000, // riga 6
B00000, // riga 7
B00000 // riga 8
};
void setup()
{
lcd_1.init(); // Inizializzazione display LCD
pinMode(A0, INPUT); // Sensore di temperatura in input
lcd_1.backlight(); // Attiva la retroilluminazione
lcd_1.createChar(0, degree_symbol); // Creazione simbolo "grado"
lcd_1.setCursor(3, 0); // Prima linea
lcd_1.print("TERMOMETER"); // Il titolo
lcd_1.setCursor(2, 1); // Seconda linea
lcd_1.print("by Nemiatools"); // L'autore
delay(3000); // 3 secondi per la schermata iniziale
lcd_1.clear(); // Cancellazione del display
lcd_1.setCursor(0, 0); // Prima linea
lcd_1.print("Temperature:"); // Testo statico
lcd_1.setCursor(10, 1); // Posizione del simbolo di g"grado"
lcd_1.write(byte(0)); // Scrive il simbolo
lcd_1.setCursor(11, 1); // Simbolo unità di misura
lcd_1.print("C"); // Gradi Celsius
}
void loop()
{
lcd_1.setCursor(3, 1); // Posizione del valore della temperatura
lcd_1.print((-40 + 0.488155 * (analogRead(A0) - 20))); // Calcola la temperatura e la scrive
delay(10); // Piccolo delay
}Come funziona:
Questo progetto utilizza una scheda Arduino per leggere la temperatura da un sensore analogico collegato al pin A0 e visualizzare il risultato su un display LCD 16x2 con interfaccia I2C.
La prima riga importante è #include <LiquidCrystal_I2C.h>. Questa libreria permette ad Arduino di comunicare con un display LCD che utilizza un adattatore I2C. Un normale display LCD senza interfaccia I2C richiede solitamente molti pin digitali per il controllo, come RS, E, D4, D5, D6 e D7. Con l'interfaccia I2C sono necessari solo due pin di comunicazione: SDA e SCL. Questo rende il cablaggio molto più semplice, libera pin di Arduino e rende il circuito più ordinato e facile da realizzare.
La riga LiquidCrystal_I2C lcd_1(0x27, 16, 2); crea l'oggetto LCD. Il valore 0x27 è l'indirizzo I2C del modulo display. Questo indirizzo viene utilizzato da Arduino per identificare l'LCD sul bus I2C. I valori 16 e 2 indicano che il display possiede 16 colonne e 2 righe.
Successivamente il codice definisce un simbolo personalizzato dei gradi utilizzando l'array byte degree_symbol[8]. Ogni riga di questo array rappresenta una linea di pixel all'interno di un carattere personalizzato dell'LCD. Questo carattere viene poi utilizzato per visualizzare il simbolo dei gradi prima della lettera C, rendendo la lettura della temperatura più professionale e facile da comprendere.
All'interno della funzione setup(), la riga lcd_1.init(); inizializza il display LCD e lo prepara a ricevere comandi da Arduino tramite l'interfaccia I2C. La riga pinMode(A0, INPUT); configura il pin analogico A0 come ingresso, poiché riceve il segnale di tensione proveniente dal sensore di temperatura.
La riga lcd_1.backlight(); accende la retroilluminazione del display LCD, rendendo il testo chiaramente visibile. Successivamente lcd_1.createChar(0, degree_symbol); salva il simbolo personalizzato dei gradi nella memoria dell'LCD alla posizione 0. Questo permette di visualizzarlo successivamente usando lcd_1.write(byte(0));.
Le righe lcd_1.setCursor(3, 0); e lcd_1.print("TERMOMETER"); posizionano il cursore sulla prima riga e visualizzano il titolo del progetto. Poi lcd_1.setCursor(2, 1); e lcd_1.print("by Nemiatools"); mostrano il testo dell'autore sulla seconda riga. Questo crea una schermata iniziale di benvenuto all'avvio del circuito.
La riga delay(3000); mantiene visibile la schermata di benvenuto per 3 secondi. Successivamente, lcd_1.clear(); rimuove il testo iniziale dal display e prepara l'LCD alla schermata di lettura della temperatura in tempo reale.
La riga lcd_1.setCursor(0, 0); sposta il cursore all'inizio della prima riga e lcd_1.print("Temperature:"); visualizza l'etichetta che descrive il valore misurato. Successivamente il codice posiziona il simbolo dei gradi e la lettera Celsius sulla seconda riga usando lcd_1.setCursor(10, 1);, lcd_1.write(byte(0));, lcd_1.setCursor(11, 1); e lcd_1.print("C");.
All'interno della funzione loop(), Arduino aggiorna continuamente il valore della temperatura. La riga lcd_1.setCursor(3, 1); posiziona il cursore sulla seconda riga, dove verrà visualizzato il valore numerico della temperatura.
La riga più importante per la misurazione è lcd_1.print((-40 + 0.488155 * (analogRead(A0) - 20)));. La funzione analogRead(A0) legge la tensione proveniente dal sensore di temperatura e la converte in un valore digitale compreso tra 0 e 1023. Questo avviene perché il convertitore analogico-digitale di Arduino rappresenta la tensione di ingresso come un numero all'interno di questo intervallo.
La formula -40 + 0.488155 * (analogRead(A0) - 20) converte il valore analogico grezzo in gradi Celsius. Il valore 20 agisce come offset, cioè il calcolo parte da un punto di riferimento invece che direttamente da zero. Il valore 0.488155 rappresenta la variazione approssimativa di temperatura per ogni incremento della lettura analogica. In altre parole, ogni aumento di una unità nella lettura analogica corrisponde a circa 0,488 gradi Celsius. Infine, -40 trasla il risultato affinché corrisponda alla scala di temperatura prevista dal sensore.
Questo tipo di formula viene comunemente utilizzato con sensori di temperatura analogici nelle simulazioni e nei progetti Arduino, dove la tensione di uscita del sensore varia in funzione della temperatura misurata. Arduino legge questa tensione, la converte in un numero e la formula trasforma tale numero in una temperatura espressa in gradi Celsius facilmente leggibile.
La riga delay(10); aggiunge una pausa molto breve tra una lettura e la successiva. Poiché il ciclo viene ripetuto continuamente, il display LCD viene aggiornato molto rapidamente, dando l'impressione di un monitoraggio della temperatura in tempo reale.
Nel complesso, il sistema funziona leggendo un segnale analogico di temperatura, convertendolo in un valore in gradi Celsius e visualizzandolo su un display LCD con interfaccia I2C. Grazie all'interfaccia I2C, il display richiede meno pin di Arduino, il cablaggio è più semplice e il progetto rimane facile da espandere con altri sensori o moduli.
Per un funzionamento corretto, assicurati che l'indirizzo I2C del display corrisponda a quello utilizzato nel codice. Molti moduli LCD I2C usano l'indirizzo 0x27, ma alcuni utilizzano 0x3F. Se il display non mostra alcun testo, controllare l'indirizzo I2C è uno dei primi passaggi di diagnostica da eseguire.