Termostato Arduino con DS18B20: Relè, Isteresi e LCD I2C
Come fare un termostato Arduino? Misura con DS18B20, controllo del riscaldatore con relè, isteresi, regolazione con pulsanti, menu LCD I2C e interfaccia web ESP32.
Un termostato Arduino è un dispositivo di controllo fatto da te che misura di continuo la temperatura di un ambiente o di un oggetto e accende e spegne automaticamente un riscaldatore (o un raffreddatore). In questa guida costruirai un termostato completo con il sensore digitale DS18B20, un modulo relè, tre pulsanti e un display LCD I2C 16x2: imposterai la temperatura target con i pulsanti, cambierai la fascia di isteresi dal menu e salverai le impostazioni nella EEPROM, così non si perdono quando manca la corrente. Questa stessa logica è il cuore di incubatrici, acquari, serre, armadi per la fermentazione o camere per stampanti 3D.
Nella seconda metà dell'articolo porterai lo stesso termostato su ESP32, impostando il valore dal browser del telefono, e vedrai anche la versione MicroPython per Raspberry Pi Pico. Il controllo del riscaldatore è la parte più rischiosa, perciò gli esempi usano un riscaldatore a bassa tensione da 12 V. In una sezione a parte spieghiamo anche a cosa fare attenzione se vuoi lavorare con la tensione di rete (230 V).

Cos'è un termostato e come funziona?
Un termostato si compone di tre parti: misura (sensore), decisione (microcontrollore) e azione (relè e riscaldatore). Arduino legge la temperatura ogni secondo e la confronta con il valore target che hai scelto. Se la temperatura scende sotto il target, attiva il relè e alimenta il riscaldatore; quando il target è raggiunto, rilascia il relè. Questo metodo si chiama controllo on-off (tutto o niente) ed è il sistema più diffuso, dai termostati delle caldaie di casa ai frigoriferi. Il riscaldatore o lavora a piena potenza o è spento, senza livelli intermedi. Se vuoi un controllo più preciso, puoi passare in futuro all'articolo sul controllo PID; ma per la maggior parte dei progetti domestici un termostato on-off ben regolato è più che sufficiente.
| Componente | Funzione | Nota |
|---|---|---|
| Arduino Uno (o Nano) | Misura, decisione e menu | Si possono usare anche ESP32 e Pico |
| Sensore DS18B20 | Misura della temperatura | Meglio la versione con cavo impermeabile |
| Resistenza da 4,7 kΩ | Pull-up per la linea 1-Wire | Senza, il sensore restituisce −127 °C |
| Modulo relè a 1 canale da 5 V | Accendere e spegnere il riscaldatore | Scegli un modulo con optoaccoppiatore e diodo |
| LCD I2C 16x2 | Mostra temperatura, target e stato | Indirizzo di solito 0x27 o 0x3F |
| 3 pulsanti | Su, giù e menu | Con pull-up interno, nessuna resistenza extra |
| Riscaldatore da 12 V e alimentatore da 12 V | Esempio di riscaldamento a bassa tensione | Per esempio un tappetino riscaldante da 12 V 10 W |
Cos'è l'isteresi e perché è indispensabile in un termostato?
Se scrivi il termostato come "se la temperatura è sotto 22 °C accendi, se è sopra spegni", quando la temperatura gira intorno ai 22 °C anche la minima oscillazione del sensore farà accendere e spegnere il relè più volte al secondo. Il relè scatta di continuo, i contatti si consumano per le scintille e il riscaldatore si stressa inutilmente. La soluzione è l'isteresi: usi due soglie separate per accensione e spegnimento. In questo progetto dividiamo la fascia di isteresi in parti uguali ai due lati del target: con target 22 °C e isteresi 1 °C, il riscaldatore si accende a 21,5 °C e si spegne a 22,5 °C. Nella zona intermedia il relè mantiene l'ultimo stato. La formula è semplice: soglia di accensione = target − H/2, soglia di spegnimento = target + H/2.
| Temperatura misurata | Stato precedente del riscaldatore | Nuovo stato | Spiegazione |
|---|---|---|---|
| 21,3 °C | Spento | Acceso | Sotto la soglia di accensione (21,5 °C) |
| 21,9 °C | Acceso | Acceso | Dentro la fascia, lo stato resta |
| 22,6 °C | Acceso | Spento | Sopra la soglia di spegnimento (22,5 °C) |
| 22,1 °C | Spento | Spento | Dentro la fascia, sta ancora raffreddando |
| −127 °C o 85 °C | Qualsiasi | Spento | Errore del sensore, passa allo stato sicuro |
Perché il DS18B20 è una buona scelta?
Il DS18B20 invia la temperatura misurata direttamente in forma digitale: a differenza dei sensori analogici, né la lunghezza del cavo né le variazioni della tensione di alimentazione falsano la lettura. Offre una precisione di ±0,5 °C tra −10 e +85 °C e una risoluzione di 0,0625 °C a 12 bit. La versione impermeabile con guaina in acciaio inox può essere immersa direttamente in un acquario, nel terreno o in una vasca d'acqua. Poiché a un solo pin dati si possono collegare più sensori, in futuro potrai misurare temperatura interna ed esterna sulla stessa linea. Per i dettagli leggi l'articolo sul sensore di temperatura DS18B20, e per il confronto con le alternative il confronto tra sensori di temperatura.
| Caratteristica | Valore |
|---|---|
| Campo di misura | da −55 °C a +125 °C |
| Precisione | ±0,5 °C (tra −10 e +85 °C) |
| Risoluzione | 9–12 bit (0,5 °C – 0,0625 °C) |
| Tempo di conversione | Al massimo 750 ms a 12 bit |
| Alimentazione | 3,0–5,5 V |
| Comunicazione | 1-Wire (un solo filo dati, pull-up da 4,7 kΩ) |
| Colori dei cavi | Rosso VDD, nero GND, giallo o bianco DATA |
Schema di collegamento del termostato Arduino
| Collegamento | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| DS18B20 DATA (giallo) | D2 | GPIO 4 | GP16 |
| DS18B20 VDD (rosso) | 5V | 3V3 | 3V3(OUT) |
| DS18B20 GND (nero) | GND | GND | GND |
| Pull-up da 4,7 kΩ | Tra DATA e 5V | Tra DATA e 3V3 | Tra DATA e 3V3 |
| Relè IN | D7 | GPIO 26 | GP15 |
| Relè VCC / GND | 5V / GND | VIN (5 V) / GND | VBUS (5 V) / GND |
| Pulsanti (su, giù, menu) | D3, D4, D5 (altro capo a GND) | Interfaccia web | Fissi nel codice |
| LCD I2C SDA / SCL | A4 / A5 | GPIO 21 / 22 (facoltativo) | GP4 / GP5 (facoltativo) |

Controllare il riscaldatore in sicurezza: esempio a bassa tensione 12 V
Per imparare non ti serve lavorare con la tensione di rete. Un tappetino riscaldante in silicone da 12 V, una resistenza di potenza o un piccolo riscaldatore PTC ti permettono di provare la stessa logica del termostato senza pericoli. Per esempio, un riscaldatore da 12 V 10 W assorbe circa 0,83 A con la formula I = P / V e ha una resistenza R = V² / P = 14,4 Ω (puoi verificarlo anche con il calcolatore della legge di Ohm). Il collegamento è questo: il positivo dell'alimentatore da 12 V va al contatto COM del relè, il contatto NO (normalmente aperto) del relè va a un capo del riscaldatore, e l'altro capo del riscaldatore va al negativo dell'alimentatore. Usare NO è importante: se Arduino si spegne o un cavo si stacca, il relè rilascia e il riscaldatore si spegne da solo. Al posto del relè puoi usare anche un MOSFET a livello logico (per esempio IRLZ44N): è silenzioso e non si consuma, i dettagli sono nell'articolo Usare il MOSFET con Arduino.
- Metti il sensore nel punto giusto: se il sensore è attaccato al riscaldatore, il termostato misura il riscaldatore e non l'ambiente e spegne troppo presto; posiziona il sensore al centro dell'ambiente che vuoi controllare.
- Limite di sicurezza nel software: nel codice, sopra il valore MAX_SAFE (40 °C) il riscaldatore si spegne indipendentemente dal target; regola questo valore in base alla tua applicazione.
- Spegni in caso di guasto del sensore: quando il cavo si stacca, il DS18B20 restituisce −127 °C; il termostato non deve scambiarlo per "troppo freddo" e accendere il riscaldatore al massimo. In questo caso il codice rilascia il relè.
- Protezione hardware di riserva: il software può bloccarsi. Con un riscaldatore serio usa un fusibile termico in serie (per esempio 70 °C) o un termostato bimetallico.
- Attenzione alla corrente dei contatti: la scritta "10 A" sul modulo vale in condizioni ideali; con carico continuo non superare la metà di quel valore.
- Alimentazione separata: la corrente del riscaldatore non deve mai passare dal pin 5V di Arduino; usa un alimentatore dedicato. Per l'alimentazione ti aiuta l'articolo Alimentazione di Arduino.
Montaggio passo dopo passo
- Nell'IDE di Arduino installa dal Gestore librerie OneWire, DallasTemperature (Miles Burton) e LiquidCrystal I2C (Frank de Brabander).
- Collega il DS18B20 a D2 e inserisci la resistenza da 4,7 kΩ tra DATA e 5V.
- Collega il pin IN del modulo relè a D7 e i pin VCC e GND ai pin 5V e GND di Arduino.
- Collega un capo dei pulsanti a D3, D4 e D5 e l'altro a GND; nel codice il pull-up interno è attivo, quindi non servono resistenze.
- Collega l'LCD I2C con SDA → A4, SCL → A5. Se lo schermo non mostra nulla, prova l'indirizzo 0x3F al posto di 0x27 oppure gira il trimmer del contrasto sul retro.
- Collega il riscaldatore da 12 V all'alimentatore tramite i contatti COM e NO del relè, ma prima prova il codice senza il riscaldatore collegato.
- Carica il codice, scalda e raffredda il sensore con la mano e osserva se il relè reagisce correttamente alle soglie.
1#include <Wire.h>
2#include <OneWire.h>
3#include <DallasTemperature.h>
4#include <LiquidCrystal_I2C.h>
5#include <EEPROM.h>
6
7const byte PIN_SENSOR = 2; // DS18B20 veri / DS18B20 data
8const byte PIN_RELAY = 7; // röle IN / relay IN
9const byte buttons[3] = {3, 4, 5}; // yukarı, aşağı, menü / up, down, menu
10const byte RELAY_ON = LOW; // çoğu modül aktif LOW / most modules are active LOW
11const byte RELAY_OFF = HIGH;
12
13const float MAX_SAFE = 40.0; // güvenlik sınırı / safety limit
14const unsigned long MIN_SWITCH_MS = 10000; // röle koruması / relay protection
15
16OneWire oneWire(PIN_SENSOR);
17DallasTemperature sensors(&oneWire);
18LiquidCrystal_I2C lcd(0x27, 16, 2);
19
20struct Settings { float target; float hyst; };
21
22float target = 22.0; // hedef sıcaklık / target temperature
23float hyst = 1.0; // histerezis bandı / hysteresis band
24float temp = NAN; // son ölçüm / last reading
25bool heaterOn = false;
26byte menu = 0; // 0: hedef, 1: histerezis / 0: target, 1: hysteresis
27unsigned long lastConv = 0;
28unsigned long lastSwitch = 0;
29byte lastState[3] = {HIGH, HIGH, HIGH};
30unsigned long lastChange[3] = {0, 0, 0};
31
32void loadSettings() {
33 Settings s;
34 EEPROM.get(0, s);
35 if (s.target >= 5 && s.target <= 35 && s.hyst >= 0.2 && s.hyst <= 5) { // boş EEPROM'u ele / reject empty EEPROM
36 target = s.target;
37 hyst = s.hyst;
38 }
39}
40
41void saveSettings() {
42 Settings s = {target, hyst};
43 EEPROM.put(0, s); // yalnız değişen baytları yazar / writes only changed bytes
44}
45
46void setHeater(bool on, bool force) {
47 if (on == heaterOn) return;
48 if (!force && millis() - lastSwitch < MIN_SWITCH_MS) return;
49 heaterOn = on;
50 lastSwitch = millis();
51 digitalWrite(PIN_RELAY, on ? RELAY_ON : RELAY_OFF);
52}
53
54void control() {
55 if (isnan(temp) || temp >= MAX_SAFE) { // sensör hatası ya da aşırı sıcaklık / sensor fault or overheat
56 setHeater(false, true);
57 return;
58 }
59 if (temp <= target - hyst / 2) setHeater(true, false); // açma eşiği / turn-on threshold
60 else if (temp >= target + hyst / 2) setHeater(false, false); // kapama eşiği / turn-off threshold
61}
62
63void drawLcd() {
64 lcd.setCursor(0, 0);
65 lcd.print("T:");
66 if (isnan(temp)) {
67 lcd.print("HATA ");
68 } else {
69 lcd.print(temp, 1);
70 lcd.print((char)223); // derece işareti / degree sign
71 lcd.print("C ");
72 }
73 lcd.setCursor(11, 0);
74 lcd.print(heaterOn ? "ISIT " : "BEKLE");
75 lcd.setCursor(0, 1);
76 lcd.print(menu == 0 ? ">" : " ");
77 lcd.print("H:");
78 lcd.print(target, 1);
79 lcd.print(menu == 1 ? " >" : " ");
80 lcd.print("d:");
81 lcd.print(hyst, 1);
82 lcd.print(" ");
83}
84
85bool pressed(byte i) {
86 byte s = digitalRead(buttons[i]);
87 if (s != lastState[i] && millis() - lastChange[i] > 50) { // 50 ms debounce
88 lastChange[i] = millis();
89 lastState[i] = s;
90 return s == LOW; // yalnız basma anı / only the press moment
91 }
92 return false;
93}
94
95void handleButtons() {
96 bool changed = false;
97 if (pressed(2)) { menu = 1 - menu; changed = true; } // menü / menu
98 if (pressed(0)) { // yukarı / up
99 if (menu == 0) target += 0.5; else hyst += 0.1;
100 changed = true;
101 }
102 if (pressed(1)) { // aşağı / down
103 if (menu == 0) target -= 0.5; else hyst -= 0.1;
104 changed = true;
105 }
106 if (changed) {
107 if (target < 5) target = 5;
108 if (target > 35) target = 35;
109 if (hyst < 0.2) hyst = 0.2;
110 if (hyst > 5) hyst = 5;
111 saveSettings();
112 control();
113 drawLcd();
114 }
115}
116
117void setup() {
118 digitalWrite(PIN_RELAY, RELAY_OFF); // açılışta kapalı / off at startup
119 pinMode(PIN_RELAY, OUTPUT);
120 for (byte i = 0; i < 3; i++) pinMode(buttons[i], INPUT_PULLUP);
121 lcd.init();
122 lcd.backlight();
123 loadSettings();
124 sensors.begin();
125 sensors.setResolution(12);
126 sensors.setWaitForConversion(false); // beklemeden ölç / non-blocking conversion
127 sensors.requestTemperatures();
128 lastConv = millis();
129 lastSwitch = millis() - MIN_SWITCH_MS;
130 drawLcd();
131}
132
133void loop() {
134 if (millis() - lastConv >= 1000) { // saniyede bir / once per second
135 float t = sensors.getTempCByIndex(0);
136 sensors.requestTemperatures(); // sonraki ölçümü başlat / start next conversion
137 lastConv = millis();
138 temp = (t == DEVICE_DISCONNECTED_C || t == 85.0) ? NAN : t;
139 control();
140 drawLcd();
141 }
142 handleButtons();
143}Come funziona il codice e come si usa il menu LCD?
| Parte | Cosa fa? |
|---|---|
| setWaitForConversion(false) | Non fa aspettare Arduino 750 ms mentre il sensore misura; pulsanti e display restano fluidi. |
| Blocco da 1 secondo in loop() | Legge la misura precedente, avvia la nuova, prende la decisione di controllo e aggiorna lo schermo. |
| control() | In caso di guasto del sensore o sovratemperatura spegne il riscaldatore; altrimenti decide in base alle soglie di isteresi. |
| setHeater() | Cambia lo stato del relè; tra una commutazione e l'altra, tranne lo spegnimento di sicurezza, lascia passare almeno 10 secondi. |
| pressed() | Legge i pulsanti con un debounce da 50 ms basato su millis() e rileva solo il momento della pressione. |
| handleButtons() | Il pulsante menu passa tra target e isteresi; i pulsanti su e giù cambiano il valore selezionato mantenendolo nei limiti. |
| EEPROM.put / get | Scrive le impostazioni nella memoria permanente; se il valore letto all'avvio non ha senso, usa i valori predefiniti. |
Sulla riga superiore dello schermo vedi la temperatura attuale e lo stato del riscaldatore (ISIT o BEKLE), sulla riga inferiore i valori di target (H) e isteresi (d). La freccia davanti al valore indica quale stai modificando. Ogni volta che premi il pulsante menu, il cursore passa tra target e isteresi; i pulsanti su e giù cambiano il target a passi di 0,5 °C e l'isteresi a passi di 0,1 °C. Il target è limitato tra 5 e 35 °C, l'isteresi tra 0,2 e 5 °C. Ogni modifica viene scritta nella EEPROM; poiché EEPROM.put aggiorna solo i byte cambiati e le celle EEPROM durano circa 100.000 scritture, le regolazioni con i pulsanti non creano problemi. Perché è importante usare millis() invece di delay() lo trovi in millis e delay, mentre il salvataggio permanente è spiegato in EEPROM di Arduino. Anche il tempo minimo di commutazione è un dettaglio importante: anche con un'isteresi molto stretta, il relè non cambia posizione più di una volta ogni 10 secondi. Se controlli un frigorifero con compressore, porta questo tempo a 3–5 minuti.
Termostato regolabile dal web con ESP32
Grazie al Wi-Fi integrato dell'ESP32 puoi impostare target e isteresi dal browser del telefono, senza pulsanti. Il codice seguente usa le librerie integrate WebServer e Preferences, che compilano senza modifiche con l'ESP32 Arduino core 2.x e 3.x; oltre a OneWire e DallasTemperature non devi installare altre librerie. Le impostazioni vengono salvate nella memoria flash con Preferences, quindi al riavvio dell'ESP32 il valore target resta. Se non riesce a collegarsi al Wi-Fi entro 15 secondi, il codice smette di aspettare e il termostato continua comunque a funzionare: la connessione di rete non deve mai bloccare il controllo del riscaldamento. Se usi l'ESP32 per la prima volta, segui prima i passaggi di installazione nell'articolo Cos'è ESP32.
1#include <WiFi.h>
2#include <WebServer.h>
3#include <Preferences.h>
4#include <OneWire.h>
5#include <DallasTemperature.h>
6
7const char* WIFI_SSID = "AgAdi"; // Wi-Fi ağ adı / Wi-Fi network name
8const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifresi / Wi-Fi password
9
10const int PIN_SENSOR = 4; // DS18B20 veri / DS18B20 data
11const int PIN_RELAY = 26; // röle IN / relay IN
12const int RELAY_ON = LOW; // aktif LOW modül / active LOW module
13const int RELAY_OFF = HIGH;
14const float MAX_SAFE = 40.0; // güvenlik sınırı / safety limit
15const unsigned long MIN_SWITCH_MS = 10000; // röle koruması / relay protection
16
17OneWire oneWire(PIN_SENSOR);
18DallasTemperature sensors(&oneWire);
19WebServer server(80);
20Preferences prefs;
21
22float target = 22.0;
23float hyst = 1.0;
24float temp = NAN;
25bool heaterOn = false;
26unsigned long lastConv = 0;
27unsigned long lastSwitch = 0;
28
29void setHeater(bool on, bool force) {
30 if (on == heaterOn) return;
31 if (!force && millis() - lastSwitch < MIN_SWITCH_MS) return;
32 heaterOn = on;
33 lastSwitch = millis();
34 digitalWrite(PIN_RELAY, on ? RELAY_ON : RELAY_OFF);
35}
36
37void control() {
38 if (isnan(temp) || temp >= MAX_SAFE) { // hata ya da aşırı sıcaklık / fault or overheat
39 setHeater(false, true);
40 return;
41 }
42 if (temp <= target - hyst / 2) setHeater(true, false);
43 else if (temp >= target + hyst / 2) setHeater(false, false);
44}
45
46void handleRoot() {
47 String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>";
48 html += "<meta name='viewport' content='width=device-width,initial-scale=1'>";
49 html += "<title>Termostat</title></head><body><h2>ESP32 Termostat</h2><p>Sicaklik: ";
50 if (isnan(temp)) {
51 html += "HATA";
52 } else {
53 html += String(temp, 1);
54 html += " C";
55 }
56 html += "</p><p>Isitici: ";
57 html += heaterOn ? "ACIK" : "KAPALI";
58 html += "</p><form action='/set'>Hedef: <input name='hedef' type='number' step='0.5' min='5' max='35' value='";
59 html += String(target, 1);
60 html += "'><br>Histerezis: <input name='hist' type='number' step='0.1' min='0.2' max='5' value='";
61 html += String(hyst, 1);
62 html += "'><br><button type='submit'>Kaydet</button></form></body></html>";
63 server.send(200, "text/html", html);
64}
65
66void handleSet() {
67 if (server.hasArg("hedef")) {
68 float v = server.arg("hedef").toFloat();
69 if (v >= 5 && v <= 35) target = v; // sınır kontrolü / range check
70 }
71 if (server.hasArg("hist")) {
72 float v = server.arg("hist").toFloat();
73 if (v >= 0.2 && v <= 5) hyst = v;
74 }
75 prefs.putFloat("hedef", target); // flash'a kaydet / save to flash
76 prefs.putFloat("hist", hyst);
77 control();
78 server.sendHeader("Location", "/");
79 server.send(303); // ana sayfaya dön / redirect to home
80}
81
82void handleJson() {
83 String j = "{\"sicaklik\":";
84 if (isnan(temp)) j += "null";
85 else j += String(temp, 2);
86 j += ",\"hedef\":";
87 j += String(target, 1);
88 j += ",\"histerezis\":";
89 j += String(hyst, 1);
90 j += ",\"isitici\":";
91 j += heaterOn ? "true" : "false";
92 j += "}";
93 server.send(200, "application/json", j);
94}
95
96void setup() {
97 Serial.begin(115200);
98 pinMode(PIN_RELAY, OUTPUT);
99 digitalWrite(PIN_RELAY, RELAY_OFF); // açılışta kapalı / off at startup
100
101 prefs.begin("termostat", false);
102 target = prefs.getFloat("hedef", 22.0);
103 hyst = prefs.getFloat("hist", 1.0);
104
105 sensors.begin();
106 sensors.setResolution(12);
107 sensors.setWaitForConversion(false);
108 sensors.requestTemperatures();
109 lastConv = millis();
110 lastSwitch = millis() - MIN_SWITCH_MS;
111
112 WiFi.mode(WIFI_STA);
113 WiFi.begin(WIFI_SSID, WIFI_PASS);
114 unsigned long t0 = millis();
115 while (WiFi.status() != WL_CONNECTED && millis() - t0 < 15000) { // en fazla 15 sn bekle / wait max 15 s
116 delay(500);
117 Serial.print(".");
118 }
119 Serial.println();
120 Serial.print("IP: ");
121 Serial.println(WiFi.localIP());
122
123 server.on("/", handleRoot);
124 server.on("/set", handleSet);
125 server.on("/json", handleJson);
126 server.begin();
127}
128
129void loop() {
130 server.handleClient();
131 if (millis() - lastConv >= 1000) {
132 float t = sensors.getTempCByIndex(0);
133 sensors.requestTemperatures();
134 lastConv = millis();
135 temp = (t == DEVICE_DISCONNECTED_C || t == 85.0) ? NAN : t;
136 control();
137 Serial.printf("T=%.2f H=%.1f d=%.1f %s\n", temp, target, hyst, heaterOn ? "ISIT" : "BEKLE");
138 }
139}Prima di caricare il codice, cambia WIFI_SSID e WIFI_PASS con quelli della tua rete. Quando scrivi nel browser l'indirizzo IP che vedi nel monitor seriale (115200 baud), vedrai la temperatura, lo stato del riscaldatore e due caselle di impostazione. Quando premi Kaydet, il modulo viene inviato all'indirizzo /set, i valori passano il controllo dei limiti e vengono salvati, e la pagina torna alla schermata principale. L'indirizzo /json fornisce le misure in un formato leggibile dalle macchine; puoi usarlo con Home Assistant o con una tua app. Poiché i GPIO dell'ESP32 lavorano a 3,3 V, alimenta il modulo relè dal pin VIN (5 V); la maggior parte dei moduli con optoaccoppiatore scatta senza problemi con un segnale a 3,3 V, e se non scatta aggiungi un transistor NPN. Se vuoi un'interfaccia aggiornata in tempo reale, guarda ESP32 web server e WebSocket, e per inviare notifiche al telefono Bot Telegram con ESP32.
Termostato MicroPython con Raspberry Pi Pico
Nel firmware MicroPython del Pico i moduli onewire e ds18x20 sono già inclusi, non devi copiare altri file. Il breve programma seguente applica la stessa logica di isteresi e sicurezza; se il sensore non viene trovato o c'è un errore di lettura, spegne il relè e continua a cercare il sensore. Puoi cambiare target e isteresi dalle costanti all'inizio del codice. Se conosci poco il Pico, l'articolo Cos'è Raspberry Pi Pico spiega passo dopo passo l'installazione di Thonny.
1from machine import Pin
2import onewire, ds18x20, time
3
4HEDEF = 22.0 # hedef sıcaklık / target temperature
5HIST = 1.0 # histerezis bandı / hysteresis band
6MAX_GUVENLI = 40.0 # güvenlik sınırı / safety limit
7ROLE_ACIK = 0 # aktif LOW modül / active LOW module
8ROLE_KAPALI = 1
9
10role = Pin(15, Pin.OUT, value=ROLE_KAPALI)
11ds = ds18x20.DS18X20(onewire.OneWire(Pin(16)))
12roms = ds.scan()
13print("Sensorler / Sensors:", roms)
14isitici = False
15
16def ayarla(ac):
17 global isitici
18 isitici = ac
19 role.value(ROLE_ACIK if ac else ROLE_KAPALI)
20
21while True:
22 t = None
23 if roms:
24 try:
25 ds.convert_temp()
26 time.sleep_ms(750) # 12 bit dönüşüm süresi / 12-bit conversion time
27 t = ds.read_temp(roms[0])
28 except Exception:
29 t = None
30 else:
31 roms = ds.scan() # sensörü yeniden ara / search sensor again
32 if t is None or t == 85.0 or t >= MAX_GUVENLI:
33 ayarla(False) # güvenli durum / safe state
34 elif t <= HEDEF - HIST / 2:
35 ayarla(True)
36 elif t >= HEDEF + HIST / 2:
37 ayarla(False)
38 print(t, "ISIT" if isitici else "BEKLE")
39 time.sleep(1)Idee di progetto con il termostato Arduino
- Incubatrice: incubazione delle uova con target 37,5 °C e isteresi 0,3 °C; aggiungi un altro sensore per monitorare l'umidità.
- Controllo del riscaldatore per acquario: mantieni l'acqua a 25 °C con un DS18B20 impermeabile.
- Serra intelligente: riunisci riscaldamento, ventilazione e irrigazione in un'unica scheda; per qualche idea guarda l'articolo sul progetto serra intelligente.
- Termostato di raffreddamento: inverti la logica e fai partire la ventola quando la temperatura sale; i dettagli sono in Controllo ventola con Arduino.
- Protezione antigelo: accendi il cavo riscaldante a 3 °C per evitare che i tubi gelino; vedi l'allarme gelo.
- Armadio per la fermentazione: termostato bidirezionale che riscalda e raffredda con una cella Peltier; l'articolo sul modulo Peltier è un buon punto di partenza.
Errori comuni e come risolverli
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Sullo schermo HATA, lettura −127 °C | Manca il pull-up, cavo DATA allentato o pin sbagliato | Metti la resistenza da 4,7 kΩ tra DATA e VDD, controlla i colori dei cavi |
| Legge sempre 85 °C | Lettura prima della fine della misura o alimentazione insufficiente | Aspetta almeno 750 ms per la conversione, alimenta il sensore in modo normale e non parassita |
| Il riscaldatore funziona al contrario | Modulo relè attivo HIGH | Scambia le costanti RELAY_ON e RELAY_OFF |
| Il relè scatta di continuo | Isteresi troppo stretta o cavo del sensore disturbato | Allarga la fascia, allontana il cavo del sensore dai cavi di potenza |
| Arduino si resetta quando il relè scatta | La corrente di bobina e riscaldatore fa crollare l'alimentazione | Usa un alimentatore separato per il riscaldatore, collega correttamente i GND |
| L'LCD è acceso ma senza testo | Indirizzo I2C sbagliato o contrasto | Trova l'indirizzo con uno scanner I2C, gira il trimmer sul retro |
| La temperatura supera il target e sale troppo | Dopo lo spegnimento il calore continua a diffondersi | Allontana il sensore dal riscaldatore, riduci l'isteresi o usa il PID |
Ora hai un termostato con isteresi, menu e sicurezze, che trasforma il valore letto dal sensore in un'azione reale; con piccole modifiche la stessa struttura si adatta anche al controllo di raffreddamento, umidità o livello dell'acqua. Nell'app BlueGrays puoi migliorare ancora il tuo termostato studiando passo dopo passo, con schemi e codice pronto, progetti come la misura di temperatura e umidità con DHT11, il termometro con NTC e LCD, il controllo di una lampada a 220 V con relè e il web server ESP32.
Domande frequenti
Quanti gradi deve essere l'isteresi di un termostato?
Dipende da quanto in fretta l'ambiente si scalda e si raffredda. In volumi piccoli e delicati come un'incubatrice, 0,3–0,5 °C sono un buon inizio; in volumi grandi come una stanza o una vasca d'acqua, 1–2 °C. Se il relè scatta spesso allarga la fascia, se la temperatura devia troppo restringila.
Perché il DS18B20 mostra -127 gradi?
−127 °C è il valore di errore con cui la libreria segnala di non riuscire a comunicare con il sensore (DEVICE_DISCONNECTED_C). Le cause più comuni sono la resistenza di pull-up da 4,7 kΩ mancante, il cavo DATA allentato o un numero di pin sbagliato nel codice. Quando vede questo valore, il codice del termostato di questo articolo spegne il riscaldatore per sicurezza.
Si può controllare un riscaldatore a 220 V con Arduino?
Tecnicamente sì: un modulo relè o un SSR può commutare un carico collegato alla rete con il segnale a bassa tensione di Arduino. Ma i 230 V sono pericolosi per la vita: i collegamenti vanno fatti in una scatola isolata, con un fusibile e sotto la supervisione di una persona esperta. Con riscaldatori di alta potenza il modulo relè non deve pilotare il carico direttamente, ma tramite un contattore.
Per un termostato devo usare un relè o un SSR?
Per un termostato on-off che scatta poche volte all'ora, un relè meccanico è economico e sufficiente. Se servono commutazioni molto frequenti, funzionamento silenzioso o controllo proporzionale nel tempo con PID, è più adatto un relè a stato solido (SSR); però l'SSR si scalda e richiede un dissipatore. Per riscaldatori a 12 V DC, un MOSFET a livello logico è la soluzione più semplice.
Le impostazioni del termostato Arduino si cancellano quando manca la corrente?
Le variabili stanno nella RAM, quindi normalmente si cancellano. Il codice di questo articolo scrive target e isteresi nella EEPROM e li rilegge all'avvio; la versione ESP32 fa lo stesso nella memoria flash con la libreria Preferences. Così, quando torna la corrente, il termostato riprende a funzionare con l'ultima impostazione.
Si può fare un termostato con il DHT11?
Si può, ma la precisione di ±2 °C e la risoluzione di 1 °C del DHT11 non bastano per un termostato accurato. Il DS18B20 offre una precisione di ±0,5 °C e una risoluzione di 0,0625 °C, ed esiste anche in versione impermeabile. Se devi controllare anche l'umidità, DHT22 o AHT20 sono un compromesso migliore.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Temperatura e umidità con DHT11
Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

Misura di temperatura con NTC e display Lcd 2x16
Misura la temperatura dell'ambiente con un sensore che sembra una piccola perlina.

Utilizzo dello schermo LCD con I2C
Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

Lampadina 220V con pulsante (Push)
Finché tieni premuto il pulsante, una vera lampadina da 220 volt resta accesa, e si spegne appena lo lasci.

Accendere e spegnere una lampadina 220V con un pulsante
Vuoi accendere e spegnere una vera lampadina di casa con un piccolo pulsante? Ogni volta che lo premi, l'Arduino fa scattare un relè e la lampadina si accende; premendo di nuovo si spegne.

ESP32 DHT22 Temperatura e umidità (con display LCD)
Si tratta di un progetto che misura la temperatura e l'umidità dell'ambiente tramite il sensore DHT22 e le visualizza in tempo reale su un display LCD I2C 16x2. I dati vengono letti dal sensore utilizzando il protocollo one-wire tramite la libreria Adafruit DHT. Questo progetto costituisce la base per stazioni meteorologiche IoT, sistemi di automazione domestica intelligente o sistemi di monitoraggio ambientale nelle serre. La comunicazione con il DHT22 avviene tramite il pin GPIO 4 dell'ESP32.

Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

