Ratgeber · 10 Min. Lesezeit

Arduino Thermostat bauen: DS18B20, Relais, Hysterese, LCD

Arduino Thermostat selbst bauen: Temperatur mit dem DS18B20 messen, Heizung per Relais schalten, Hysterese, Tasten, I2C-LCD-Menü und ESP32-Weboberfläche.

Ein Arduino-Thermostat ist ein selbstgebautes Regelgerät, das die Temperatur eines Raums oder Gegenstands ständig misst und eine Heizung (oder Kühlung) automatisch ein- und ausschaltet. In dieser Anleitung baust du mit dem digitalen Temperatursensor DS18B20, einem Relaismodul, drei Tasten und einem 16x2-I2C-LCD einen voll funktionsfähigen Thermostat: Du stellst die Zieltemperatur per Taste ein, änderst das Hysterese-Band im Menü und speicherst die Einstellungen im EEPROM, damit sie bei Stromausfall nicht verloren gehen. Genau diese Logik steckt im Kern vieler Projekte wie Brutkasten, Aquarium, Gewächshaus, Gärschrank oder 3D-Drucker-Gehäuse.

In der zweiten Hälfte des Beitrags portierst du denselben Thermostat auf den ESP32 und stellst den Zielwert über den Browser deines Smartphones ein. Außerdem siehst du die MicroPython-Version für den Raspberry Pi Pico. Weil die Heizungssteuerung der riskanteste Teil ist, bauen wir die Beispiele mit einer 12-V-Niederspannungsheizung auf. Was du beim Arbeiten mit Netzspannung (230 V) beachten musst, erklären wir in einem eigenen Abschnitt.

DS18B20 digitaler Temperatursensor
DS18B20: liefert die Temperatur über eine einzige Datenleitung (1-Wire) mit 0,0625 °C Auflösung und bildet die Messseite des Thermostats.

Was ist ein Thermostat und wie funktioniert er?

Ein Thermostat besteht aus drei Teilen: Messen (Sensor), Entscheiden (Mikrocontroller) und Handeln (Relais und Heizung). Der Arduino liest jede Sekunde die Temperatur und vergleicht sie mit deinem Zielwert. Fällt die Temperatur unter das Ziel, zieht er das Relais an und versorgt die Heizung mit Strom; ist das Ziel erreicht, lässt er das Relais los. Dieses Verfahren heißt Zweipunktregelung (Ein-Aus-Regelung) und ist die häufigste Methode der Temperaturregelung, von der Heizungsthermostat bis zum Kühlschrank. Die Heizung läuft entweder mit voller Leistung oder gar nicht, Zwischenstufen gibt es nicht. Für eine genauere Regelung kannst du später den Beitrag PID-Regelung lesen; für die meisten Heimprojekte reicht ein gut eingestellter Zweipunktregler aber völlig aus.

BauteilAufgabeHinweis
Arduino Uno (oder Nano)Messen, Entscheiden und MenüESP32 und Pico gehen auch
DS18B20-SensorTemperaturmessungWasserdichte Version mit Kabel empfohlen
4,7-kΩ-WiderstandPull-up für die 1-Wire-LeitungFehlt er, liefert der Sensor −127 °C
1-Kanal-5-V-RelaismodulHeizung ein- und ausschaltenModul mit Optokoppler und Diode wählen
16x2-I2C-LCDAnzeige von Temperatur, Ziel und StatusAdresse meist 0x27 oder 0x3F
3 TasterHoch, runter und MenüMit internem Pull-up, kein Widerstand nötig
12-V-Heizung und 12-V-NetzteilNiederspannungs-HeizbeispielZ. B. 12-V-10-W-Heizmatte

Was ist Hysterese und warum braucht ein Thermostat sie?

Wenn du den Thermostat nur nach dem Muster „unter 22 °C einschalten, darüber ausschalten“ programmierst, schaltet schon das kleinste Rauschen des Sensors das Relais mehrmals pro Sekunde ein und aus, sobald die Temperatur um 22 °C pendelt. Das Relais klappert, die Kontakte verschleißen durch Funken und die Heizung wird unnötig belastet. Die Lösung ist die Hysterese: Du nutzt zwei getrennte Schwellen zum Ein- und Ausschalten. In diesem Projekt teilen wir das Band gleichmäßig auf beide Seiten des Zielwerts auf; bei 22 °C Ziel und 1 °C Hysterese schaltet die Heizung bei 21,5 °C ein und bei 22,5 °C aus. Dazwischen behält das Relais seinen letzten Zustand. Die Formel ist einfach: Einschaltschwelle = Ziel − H/2, Ausschaltschwelle = Ziel + H/2.

Gemessene TemperaturVorheriger HeizungszustandNeuer ZustandErklärung
21,3 °CAusEinUnter der Einschaltschwelle (21,5 °C)
21,9 °CEinEinIm Band, Zustand bleibt
22,6 °CEinAusÜber der Ausschaltschwelle (22,5 °C)
22,1 °CAusAusIm Band, Abkühlung läuft
−127 °C oder 85 °CBeliebigAusSensorfehler, in den sicheren Zustand wechseln
Überlege bei der Wahl der Hysterese, wie träge die Umgebung auf Wärme reagiert. In einem kleinen Brutkasten reichen 0,3–0,5 °C; in einem Raum oder großen Wassertank sind 1–2 °C sinnvoller. Ist das Band zu schmal, schaltet das Relais zu oft, ist es zu breit, weicht die Temperatur zu stark vom Ziel ab. Auch nach dem Abschalten steigt die Temperatur wegen der gespeicherten Wärme noch eine Weile weiter (Überschwingen); beobachte das und stelle das Band entsprechend ein.

Warum ist der DS18B20 eine gute Wahl?

Der DS18B20 sendet die gemessene Temperatur direkt digital; anders als bei analogen Sensoren verfälschen weder Kabellänge noch Schwankungen der Versorgungsspannung den Messwert. Er bietet ±0,5 °C Genauigkeit zwischen −10 und +85 °C und 0,0625 °C Auflösung bei 12 Bit. Die wasserdichte Version mit Edelstahlhülse kannst du direkt ins Aquarium, in die Erde oder in einen Wassertank tauchen. Da sich mehrere Sensoren an einen Datenpin anschließen lassen, kannst du später Innen- und Außentemperatur über dieselbe Leitung messen. Details findest du im Beitrag DS18B20 Temperatursensor, einen Vergleich mit anderen Sensoren im Vergleich der Temperatursensoren.

EigenschaftWert
Messbereich−55 °C bis +125 °C
Genauigkeit±0,5 °C (zwischen −10 und +85 °C)
Auflösung9–12 Bit (0,5 °C – 0,0625 °C)
WandlungszeitMax. 750 ms bei 12 Bit
Versorgung3,0–5,5 V
Schnittstelle1-Wire (eine Datenleitung, 4,7-kΩ-Pull-up)
KabelfarbenRot VDD, schwarz GND, gelb oder weiß DATA

Arduino-Thermostat: Schaltplan und Verdrahtung

VerbindungArduino UnoESP32Raspberry Pi Pico
DS18B20 DATA (gelb)D2GPIO 4GP16
DS18B20 VDD (rot)5V3V33V3(OUT)
DS18B20 GND (schwarz)GNDGNDGND
4,7-kΩ-Pull-upZwischen DATA und 5VZwischen DATA und 3V3Zwischen DATA und 3V3
Relais IND7GPIO 26GP15
Relais VCC / GND5V / GNDVIN (5 V) / GNDVBUS (5 V) / GND
Tasten (hoch, runter, Menü)D3, D4, D5 (anderes Ende an GND)WeboberflächeFest im Code
I2C-LCD SDA / SCLA4 / A5GPIO 21 / 22 (optional)GP4 / GP5 (optional)
Die zwei häufigsten Fehler: den 4,7-kΩ-Pull-up vergessen (der Sensor liefert −127 °C) und nicht wissen, dass das Relais active LOW ist. Die meisten Relaismodule ziehen an, wenn der IN-Pin LOW ist; deshalb ist im Code RELAY_ON = LOW definiert. Zieht dein Modul bei HIGH an, tausche die beiden Konstanten; sonst macht der Thermostat genau das Gegenteil und hält die Heizung dauerhaft an.
5-V-Relaismodul
Relaismodul: Es zieht per Arduino-Signal die Spule an und schaltet den Heizkreis über einen mechanischen Kontakt.

Heizung sicher steuern: Beispiel mit 12 V Niederspannung

Zum Lernen musst du nicht mit Netzspannung arbeiten. Eine 12-V-Silikon-Heizmatte, ein Leistungswiderstand oder eine kleine PTC-Heizung erlauben dir, dieselbe Thermostatlogik gefahrlos auszuprobieren. Eine 12-V-10-W-Heizung zieht nach I = P / U etwa 0,83 A und hat einen Widerstand von R = U² / P = 14,4 Ω (mit dem Ohmschen-Gesetz-Rechner kannst du das selbst nachprüfen). Die Verdrahtung: Der Pluspol des 12-V-Netzteils geht an den COM-Kontakt des Relais, der NO-Kontakt (Schließer) an ein Ende der Heizung, das andere Ende der Heizung an den Minuspol des Netzteils. Der NO-Kontakt ist wichtig: Fällt der Arduino aus oder reißt ein Kabel, fällt das Relais ab und die Heizung schaltet von selbst ab. Statt eines Relais kannst du auch einen Logic-Level-MOSFET (z. B. IRLZ44N) verwenden; er ist lautlos und verschleißfrei, Details im Beitrag Arduino MOSFET verwenden.

  • Sensor richtig platzieren: Klebt der Sensor an der Heizung, misst der Thermostat die Heizung statt der Umgebung und schaltet viel zu früh ab; setze den Sensor in die Mitte des Bereichs, den du regeln willst.
  • Software-Sicherheitsgrenze: Im Code schaltet die Heizung über MAX_SAFE (40 °C) unabhängig vom Zielwert ab; passe diesen Wert an deine Anwendung an.
  • Bei Sensorfehler abschalten: Bei einem Kabelbruch liefert der DS18B20 −127 °C; der Thermostat darf das nicht für „sehr kalt“ halten und die Heizung voll aufdrehen. Der Code lässt das Relais in diesem Fall los.
  • Hardware-Zusatzschutz: Software kann hängen. Bei einer ernsthaften Heizung nutze eine in Reihe geschaltete Thermosicherung (z. B. 70 °C) oder einen Bimetall-Thermostat.
  • Kontaktstrom beachten: Die Angabe „10 A“ auf dem Modul gilt für ideale Bedingungen; bei Dauerlast solltest du die Hälfte nicht überschreiten.
  • Getrennte Versorgung: Der Heizstrom darf niemals über den 5V-Pin des Arduino fließen; nutze für die Heizung ein eigenes Netzteil. Zur Stromversorgung hilft der Beitrag Arduino Stromversorgung.
230 V Netzspannung sind lebensgefährlich. Willst du eine am Netz betriebene Heizung steuern, baue die Schaltung unter Aufsicht eines Erwachsenen oder einer erfahrenen Elektrofachkraft auf, bringe alle 230-V-Verbindungen in ein geschlossenes, isoliertes Gehäuse, lasse keine offenen Enden und sichere den Kreis mit einer Sicherung ab. Eine 2000-W-Heizung zieht bei 230 V etwa 8,7 A; das ist für ein billiges Relaismodul zu viel. Bei solchen Lasten sollte das Relaismodul nur ein Schütz ansteuern, oder du nimmst ein Solid-State-Relais (SSR) mit passendem Kühlkörper.

Schritt für Schritt aufbauen

  1. Installiere in der Arduino IDE über den Bibliotheksverwalter die Bibliotheken OneWire, DallasTemperature (Miles Burton) und LiquidCrystal I2C (Frank de Brabander).
  2. Schließe den DS18B20 an D2 an und setze den 4,7-kΩ-Widerstand zwischen DATA und 5V.
  3. Verbinde den IN-Pin des Relaismoduls mit D7 sowie VCC und GND mit 5V und GND des Arduino.
  4. Verbinde je ein Ende der Taster mit D3, D4 und D5 und das andere mit GND; im Code ist der interne Pull-up aktiv, ein zusätzlicher Widerstand ist nicht nötig.
  5. Schließe das I2C-LCD als SDA → A4, SCL → A5 an. Siehst du keinen Text, probiere die Adresse 0x3F statt 0x27 oder drehe am Kontrastpoti auf der Rückseite.
  6. Schließe die 12-V-Heizung über COM und NO des Relais ans Netzteil an, teste den Code aber zuerst ohne angeschlossene Heizung.
  7. Lade den Code hoch, erwärme und kühle den Sensor mit der Hand und beobachte, ob das Relais an den Schwellen richtig reagiert.
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}

Wie funktioniert der Code und wie bedienst du das LCD-Menü?

AbschnittWas passiert?
setWaitForConversion(false)Der Arduino wartet während der Messung nicht 750 ms; Tasten und Anzeige bleiben flüssig.
1-Sekunden-Block in loop()Liest die vorherige Messung, startet die nächste, trifft die Regelentscheidung und aktualisiert die Anzeige.
control()Schaltet bei Sensorfehler oder Übertemperatur die Heizung ab; sonst entscheidet sie nach den Hysterese-Schwellen.
setHeater()Ändert den Relaiszustand; außer bei der Sicherheitsabschaltung liegen mindestens 10 Sekunden zwischen den Wechseln.
pressed()Liest die Tasten mit einer millis()-basierten 50-ms-Entprellung und erkennt nur den Moment des Drückens.
handleButtons()Die Menütaste wechselt zwischen Ziel und Hysterese; hoch und runter ändern den gewählten Wert und halten ihn in den Grenzen.
EEPROM.put / getSchreibt die Einstellungen in den Dauerspeicher; ist der beim Start gelesene Wert unsinnig, werden Standardwerte verwendet.

In der oberen Zeile des Displays siehst du die aktuelle Temperatur und den Heizungsstatus (ISIT oder BEKLE), in der unteren Zeile Ziel (H) und Hysterese (d). Der Pfeil vor einem Wert zeigt, welchen Wert du gerade bearbeitest. Bei jedem Druck auf die Menütaste springt der Cursor zwischen Ziel und Hysterese; hoch und runter ändern das Ziel in 0,5-°C- und die Hysterese in 0,1-°C-Schritten. Das Ziel ist auf 5–35 °C, die Hysterese auf 0,2–5 °C begrenzt. Jede Änderung wird ins EEPROM geschrieben; da EEPROM.put nur geänderte Bytes aktualisiert und EEPROM-Zellen etwa 100.000 Schreibzyklen aushalten, sind Einstellungen per Taste unproblematisch. Warum millis() statt delay() wichtig ist, erfährst du im Beitrag millis und delay, mehr zum dauerhaften Speichern unter Arduino EEPROM. Auch die Mindestschaltzeit ist ein wichtiges Detail: Selbst bei sehr schmaler Hysterese wechselt das Relais höchstens alle 10 Sekunden den Zustand. Steuerst du ein Kühlgerät mit Kompressor, erhöhe diese Zeit auf 3–5 Minuten.

Einstellbarer Thermostat per Web mit dem ESP32

Dank des eingebauten WLAN des ESP32 kannst du Zieltemperatur und Hysterese ohne Tasten im Browser deines Smartphones einstellen. Der folgende Code nutzt die integrierten Bibliotheken WebServer und Preferences, die sich mit dem ESP32-Arduino-Core 2.x und 3.x unverändert kompilieren lassen; außer OneWire und DallasTemperature musst du nichts installieren. Die Einstellungen werden per Preferences im Flash gespeichert, der Zielwert bleibt also nach einem Neustart erhalten. Gelingt die WLAN-Verbindung nicht innerhalb von 15 Sekunden, hört der Code auf zu warten und der Thermostat läuft trotzdem weiter; eine Netzwerkverbindung darf die Heizungsregelung nie blockieren. Bist du neu beim ESP32, folge zuerst den Einrichtungsschritten im Beitrag Was ist der 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}

Ändere vor dem Hochladen WIFI_SSID und WIFI_PASS auf dein Netzwerk. Gibst du die im Serial Monitor (115200 Baud) angezeigte IP-Adresse im Browser ein, siehst du Temperatur, Heizungsstatus und zwei Einstellfelder. Drückst du auf Speichern, wird das Formular an /set gesendet, die Werte werden geprüft und gespeichert, und die Seite leitet zur Startseite weiter. Unter /json bekommst du die Messwerte in maschinenlesbarer Form, die du in Home Assistant oder deiner eigenen App nutzen kannst. Da die GPIOs des ESP32 mit 3,3 V arbeiten, versorge das Relaismodul über den VIN-Pin (5 V); die meisten Module mit Optokoppler lassen sich problemlos mit 3,3 V schalten, andernfalls setze einen NPN-Transistor dazwischen. Für eine live aktualisierte Oberfläche schau dir ESP32 Webserver und WebSocket an, für Benachrichtigungen aufs Handy den ESP32 Telegram-Bot.

MicroPython-Thermostat mit dem Raspberry Pi Pico

In der MicroPython-Firmware des Pico sind die Module onewire und ds18x20 bereits enthalten, du musst keine Dateien kopieren. Das folgende kurze Programm setzt dieselbe Hysterese- und Sicherheitslogik um; wird kein Sensor gefunden oder gibt es einen Lesefehler, schaltet es das Relais ab und sucht den Sensor weiter. Zielwert und Hysterese änderst du über die Konstanten am Anfang des Codes. Bist du neu beim Pico, erklärt dir der Beitrag Was ist der Raspberry Pi Pico die Thonny-Einrichtung Schritt für Schritt.

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)

Projektideen mit dem Arduino-Thermostat

  • Brutkasten: Eierbrut mit 37,5 °C Ziel und 0,3 °C Hysterese; für die Luftfeuchtigkeit kommt ein weiterer Sensor dazu.
  • Aquarium-Heizungssteuerung: Halte das Wasser mit dem wasserdichten DS18B20 konstant bei 25 °C.
  • Smartes Gewächshaus: Vereine Heizung, Lüftung und Bewässerung auf einer Platine; Ideen im Beitrag Smartes Gewächshaus.
  • Kühlthermostat: Kehre die Logik um und starte bei steigender Temperatur einen Lüfter; Details im Beitrag Arduino Lüftersteuerung.
  • Frostschutz: Schalte bei 3 °C ein Heizkabel ein, damit Rohre nicht einfrieren; siehe Frostalarm.
  • Gärschrank: Ein Zweirichtungs-Thermostat mit Peltier-Element zum Heizen und Kühlen; der Beitrag Peltier-Modul ist ein guter Einstieg.

Häufige Fehler und ihre Lösungen

SymptomMögliche UrsacheLösung
Anzeige FEHLER, Messwert −127 °CKein Pull-up, DATA-Kabel locker oder falscher Pin4,7-kΩ-Widerstand zwischen DATA und VDD setzen, Kabelfarben prüfen
Dauerhaft 85 °CAuslesen vor Ende der Messung oder zu schwache VersorgungMindestens 750 ms auf die Wandlung warten, Sensor im normalen statt im parasitären Modus versorgen
Heizung arbeitet verkehrt herumRelaismodul ist active HIGHKonstanten RELAY_ON und RELAY_OFF tauschen
Relais klappert ständigHysterese zu schmal oder Sensorkabel gestörtBand verbreitern, Sensorkabel von Stromkabeln fernhalten
Arduino resettet, wenn das Relais anziehtSpulen- und Heizstrom brechen die Versorgung einEigenes Netzteil für die Heizung nutzen, GND-Verbindungen korrekt herstellen
LCD leuchtet, aber kein TextFalsche I2C-Adresse oder KontrastAdresse mit I2C-Scanner finden, Poti auf der Rückseite drehen
Temperatur schießt weit übers ZielWärme breitet sich nach dem Abschalten weiter ausSensor von der Heizung entfernen, Hysterese verkleinern oder PID nutzen
Teste deinen Thermostat, bevor du ihn an eine echte Heizung anschließt, mit einer LED: Schließe statt des Relais die Anode einer LED über 220 Ω an 5V und die Kathode an D7 an. Durch die active-LOW-Logik leuchtet die LED genau dann, wenn die Heizung an wäre. Erwärme den Sensor in der Hand und tauche ihn in ein Glas kaltes Wasser; blinkt die LED an den richtigen Schwellen, ist die Software bereit. Wie das Relais angeschlossen wird, siehst du Schritt für Schritt im Beitrag Was ist ein Relaismodul, bei Display-Problemen hilft I2C-LCD-Display.

Jetzt hast du einen Thermostat mit Hysterese, Menü und Sicherheitsvorkehrungen, der Messwerte in echte Aktionen umsetzt; mit kleinen Änderungen lässt sich dieselbe Struktur auch für Kühlung, Luftfeuchtigkeit oder Wasserstandsregelung anpassen. In der BlueGrays-App findest du Projekte wie Temperatur- und Feuchtemessung mit dem DHT11, ein Thermometer mit NTC und LCD, eine 220-V-Lampe per Relais steuern und einen ESP32-Webserver, jeweils mit Schaltplan und fertigem Code, um deinen Thermostat weiter auszubauen.

Häufige Fragen

Wie groß sollte die Hysterese beim Thermostat sein?

Das hängt davon ab, wie schnell sich die Umgebung erwärmt und abkühlt. Bei kleinen, empfindlichen Volumen wie einem Brutkasten sind 0,3–0,5 °C ein guter Start, bei großen Volumen wie einem Raum oder Wassertank 1–2 °C. Schaltet das Relais zu oft, verbreitere das Band; weicht die Temperatur zu stark ab, verkleinere es.

Warum zeigt der DS18B20 -127 Grad an?

−127 °C ist der Fehlerwert, mit dem die Bibliothek meldet, dass sie nicht mit dem Sensor kommunizieren kann (DEVICE_DISCONNECTED_C). Die häufigsten Ursachen sind ein fehlender 4,7-kΩ-Pull-up, ein lockeres DATA-Kabel oder eine falsche Pinnummer im Code. Der Thermostat-Code in diesem Beitrag schaltet die Heizung bei diesem Wert zur Sicherheit ab.

Kann man mit dem Arduino eine 230-V-Heizung steuern?

Technisch ja: Ein Relaismodul oder SSR kann mit dem Niederspannungssignal des Arduino eine am Netz betriebene Last schalten. 230 V sind aber lebensgefährlich; die Verbindungen müssen in einem isolierten Gehäuse, mit Sicherung und unter Aufsicht einer erfahrenen Person erfolgen. Bei leistungsstarken Heizungen sollte das Relaismodul die Last nicht direkt, sondern über ein Schütz schalten.

Sollte ich für den Thermostat ein Relais oder ein SSR nehmen?

Für einen Ein-Aus-Thermostat, der nur einige Male pro Stunde schaltet, ist ein mechanisches Relais günstig und ausreichend. Brauchst du sehr häufiges Schalten, leisen Betrieb oder zeitproportionale Regelung per PID, ist ein Solid-State-Relais (SSR) besser geeignet; es wird jedoch warm und braucht einen Kühlkörper. Für 12-V-DC-Heizungen ist ein Logic-Level-MOSFET die unkomplizierteste Lösung.

Gehen die Thermostat-Einstellungen bei Stromausfall verloren?

Variablen liegen im RAM und gehen normalerweise verloren. Der Code in diesem Beitrag schreibt Ziel und Hysterese ins EEPROM und liest sie beim Start zurück; die ESP32-Version erledigt das mit der Preferences-Bibliothek im Flash. So arbeitet der Thermostat nach der Rückkehr des Stroms mit den letzten Einstellungen weiter.

Kann man einen Thermostat mit dem DHT11 bauen?

Möglich, aber die Genauigkeit des DHT11 von ±2 °C und 1 °C Auflösung reichen für einen präzisen Thermostat nicht aus. Der DS18B20 bietet ±0,5 °C Genauigkeit und 0,0625 °C Auflösung und ist auch wasserdicht erhältlich. Musst du zusätzlich die Luftfeuchtigkeit regeln, sind DHT22 oder AHT20 der bessere Kompromiss.

Alle Projekte ansehen
Temperatur und Luftfeuchtigkeit mit DHT11
AR-55Mittel

Temperatur und Luftfeuchtigkeit mit DHT11

Wie warm ist dein Zimmer, und ist die Luft feucht oder trocken? Der DHT11-Sensor misst Temperatur und Luftfeuchtigkeit, und der Arduino schreibt die Werte auf ein zweizeiliges LCD und aktualisiert…

4.7(47)
83
Temperaturmessung mit NTC und 2x16 Lcd Display
AR-44Anfänger
Premium

Temperaturmessung mit NTC und 2x16 Lcd Display

Miss die Umgebungstemperatur mit einem Sensor, der aussieht wie eine kleine Perle.

4.5(33)
44
Verwendung des LCD-Bildschirms mit I2C
AR-32Anfänger
Premium

Verwendung des LCD-Bildschirms mit I2C

Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.

4.8(53)
70
220V Glühbirne mit Druckknopf (Push)
AR-19Fortgeschritten
Premium

220V Glühbirne mit Druckknopf (Push)

Solange du den Knopf gedrückt hältst, leuchtet eine echte 220-Volt-Glühbirne, und sobald du loslässt, geht sie aus.

4.4(30)
38
220-V-Glühbirne mit Taster ein- und ausschalten
AR-20Fortgeschritten
Premium

220-V-Glühbirne mit Taster ein- und ausschalten

Willst du eine echte Glühbirne aus dem Haushalt mit einem kleinen Taster ein- und ausschalten? Bei jedem Druck schaltet der Arduino ein Relais um und die Lampe geht an, beim nächsten Druck wieder aus.

4.5(33)
44
ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
ES-15Mittel

ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)

Bei diesem Projekt werden die Umgebungstemperatur und die Luftfeuchtigkeit mit einem DHT22-Sensor gemessen und in Echtzeit auf einem 16x2 I2C-LCD angezeigt. Mithilfe der Adafruit-DHT-Bibliothek werden die Daten über das One-Wire-Protokoll vom Sensor ausgelesen. Dieses Projekt bildet die Grundlage für IoT-Wetterstationen, Smart-Home-Automatisierung oder Umgebungsüberwachungssysteme in Gewächshäusern. Die Kommunikation mit dem DHT22 erfolgt über den GPIO-4-Pin des ESP32.

4.8(38)
57
ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
ES-27Fortgeschritten

ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)

Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

4.8(16)
26
ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Fortgeschritten
Premium

ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)

Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.

4.7(7)
12