Guide · 11 min di lettura

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

Sensore di temperatura digitale DS18B20
DS18B20: fornisce la temperatura su un solo filo dati (1-Wire) con risoluzione di 0,0625 °C; è la parte di misura del termostato.

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.

ComponenteFunzioneNota
Arduino Uno (o Nano)Misura, decisione e menuSi possono usare anche ESP32 e Pico
Sensore DS18B20Misura della temperaturaMeglio la versione con cavo impermeabile
Resistenza da 4,7 kΩPull-up per la linea 1-WireSenza, il sensore restituisce −127 °C
Modulo relè a 1 canale da 5 VAccendere e spegnere il riscaldatoreScegli un modulo con optoaccoppiatore e diodo
LCD I2C 16x2Mostra temperatura, target e statoIndirizzo di solito 0x27 o 0x3F
3 pulsantiSu, giù e menuCon pull-up interno, nessuna resistenza extra
Riscaldatore da 12 V e alimentatore da 12 VEsempio di riscaldamento a bassa tensionePer 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 misurataStato precedente del riscaldatoreNuovo statoSpiegazione
21,3 °CSpentoAccesoSotto la soglia di accensione (21,5 °C)
21,9 °CAccesoAccesoDentro la fascia, lo stato resta
22,6 °CAccesoSpentoSopra la soglia di spegnimento (22,5 °C)
22,1 °CSpentoSpentoDentro la fascia, sta ancora raffreddando
−127 °C o 85 °CQualsiasiSpentoErrore del sensore, passa allo stato sicuro
Per scegliere l'isteresi pensa all'inerzia termica dell'ambiente. In una piccola incubatrice bastano 0,3–0,5 °C; in una stanza o in una grande vasca d'acqua hanno più senso 1–2 °C. Se la fascia è troppo stretta il relè scatta spesso, se è troppo larga la temperatura si allontana troppo dal target. Anche dopo lo spegnimento, il calore accumulato fa salire ancora un po' la temperatura (overshoot): osservalo e regola la fascia di conseguenza.

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.

CaratteristicaValore
Campo di misurada −55 °C a +125 °C
Precisione±0,5 °C (tra −10 e +85 °C)
Risoluzione9–12 bit (0,5 °C – 0,0625 °C)
Tempo di conversioneAl massimo 750 ms a 12 bit
Alimentazione3,0–5,5 V
Comunicazione1-Wire (un solo filo dati, pull-up da 4,7 kΩ)
Colori dei caviRosso VDD, nero GND, giallo o bianco DATA

Schema di collegamento del termostato Arduino

CollegamentoArduino UnoESP32Raspberry Pi Pico
DS18B20 DATA (giallo)D2GPIO 4GP16
DS18B20 VDD (rosso)5V3V33V3(OUT)
DS18B20 GND (nero)GNDGNDGND
Pull-up da 4,7 kΩTra DATA e 5VTra DATA e 3V3Tra DATA e 3V3
Relè IND7GPIO 26GP15
Relè VCC / GND5V / GNDVIN (5 V) / GNDVBUS (5 V) / GND
Pulsanti (su, giù, menu)D3, D4, D5 (altro capo a GND)Interfaccia webFissi nel codice
LCD I2C SDA / SCLA4 / A5GPIO 21 / 22 (facoltativo)GP4 / GP5 (facoltativo)
I due errori più comuni: dimenticare la resistenza di pull-up da 4,7 kΩ (il sensore restituisce −127 °C) e non sapere che il relè è attivo LOW. La maggior parte dei moduli relè scatta quando il pin IN è LOW; per questo nel codice è definito RELAY_ON = LOW. Se il tuo modulo scatta con HIGH, scambia queste due costanti; altrimenti il termostato farà il contrario e terrà il riscaldatore sempre acceso.
Modulo relè da 5 V
Modulo relè: con il segnale di Arduino eccita la bobina e apre e chiude il circuito del riscaldatore con un contatto meccanico.

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.
La tensione di rete a 230 V è letale. Se vuoi controllare un riscaldatore collegato alla rete, costruisci il circuito sotto la supervisione di un adulto o di un elettricista esperto, metti tutti i collegamenti a 230 V in una scatola chiusa e isolata, non lasciare capi scoperti e proteggi il circuito con un fusibile. Un riscaldatore da 2000 W assorbe circa 8,7 A a 230 V, troppo per un modulo relè economico. Con carichi di questa potenza il modulo relè deve pilotare solo un contattore, oppure bisogna usare un relè a stato solido (SSR) con dissipatore adeguato.

Montaggio passo dopo passo

  1. Nell'IDE di Arduino installa dal Gestore librerie OneWire, DallasTemperature (Miles Burton) e LiquidCrystal I2C (Frank de Brabander).
  2. Collega il DS18B20 a D2 e inserisci la resistenza da 4,7 kΩ tra DATA e 5V.
  3. Collega il pin IN del modulo relè a D7 e i pin VCC e GND ai pin 5V e GND di Arduino.
  4. 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.
  5. 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.
  6. 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.
  7. Carica il codice, scalda e raffredda il sensore con la mano e osserva se il relè reagisce correttamente alle soglie.
C++ (Arduino IDE)
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?

ParteCosa 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 / getScrive 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.

C++ (Arduino IDE)
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.

MicroPython
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

SintomoCausa probabileSoluzione
Sullo schermo HATA, lettura −127 °CManca il pull-up, cavo DATA allentato o pin sbagliatoMetti la resistenza da 4,7 kΩ tra DATA e VDD, controlla i colori dei cavi
Legge sempre 85 °CLettura prima della fine della misura o alimentazione insufficienteAspetta almeno 750 ms per la conversione, alimenta il sensore in modo normale e non parassita
Il riscaldatore funziona al contrarioModulo relè attivo HIGHScambia le costanti RELAY_ON e RELAY_OFF
Il relè scatta di continuoIsteresi troppo stretta o cavo del sensore disturbatoAllarga la fascia, allontana il cavo del sensore dai cavi di potenza
Arduino si resetta quando il relè scattaLa corrente di bobina e riscaldatore fa crollare l'alimentazioneUsa un alimentatore separato per il riscaldatore, collega correttamente i GND
L'LCD è acceso ma senza testoIndirizzo I2C sbagliato o contrastoTrova l'indirizzo con uno scanner I2C, gira il trimmer sul retro
La temperatura supera il target e sale troppoDopo lo spegnimento il calore continua a diffondersiAllontana il sensore dal riscaldatore, riduci l'isteresi o usa il PID
Prima di collegare il termostato a un vero riscaldatore, provalo con un LED: al posto del relè collega l'anodo di un LED a 5V tramite una resistenza da 220 Ω e il catodo a D7. Così, con la logica attiva LOW, il LED si accende proprio quando il riscaldatore sarebbe acceso. Scalda il sensore nel palmo della mano e immergilo in un bicchiere d'acqua fredda; se il LED si accende e si spegne alle soglie giuste, il software è pronto. Per vedere passo passo come si collega il relè guarda Cos'è un modulo relè, e per i problemi di schermo l'articolo sul display LCD I2C.

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.

Vedi tutti i progetti
Temperatura e umidità con DHT11
AR-55Intermedio

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…

4.7(47)
83
Misura di temperatura con NTC e display Lcd 2x16
AR-44Principiante
Premium

Misura di temperatura con NTC e display Lcd 2x16

Misura la temperatura dell'ambiente con un sensore che sembra una piccola perlina.

4.5(33)
44
Utilizzo dello schermo LCD con I2C
AR-32Principiante
Premium

Utilizzo dello schermo LCD con I2C

Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

4.8(53)
70
Lampadina 220V con pulsante (Push)
AR-19Avanzato
Premium

Lampadina 220V con pulsante (Push)

Finché tieni premuto il pulsante, una vera lampadina da 220 volt resta accesa, e si spegne appena lo lasci.

4.4(30)
38
Accendere e spegnere una lampadina 220V con un pulsante
AR-20Avanzato
Premium

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.

4.5(33)
44
ESP32 DHT22 Temperatura e umidità (con display LCD)
ES-15Intermedio

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.

4.8(38)
57
Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
ES-27Avanzato

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

4.8(16)
26
Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzato
Premium

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.

4.7(7)
12