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.

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.
| Bauteil | Aufgabe | Hinweis |
|---|---|---|
| Arduino Uno (oder Nano) | Messen, Entscheiden und Menü | ESP32 und Pico gehen auch |
| DS18B20-Sensor | Temperaturmessung | Wasserdichte Version mit Kabel empfohlen |
| 4,7-kΩ-Widerstand | Pull-up für die 1-Wire-Leitung | Fehlt er, liefert der Sensor −127 °C |
| 1-Kanal-5-V-Relaismodul | Heizung ein- und ausschalten | Modul mit Optokoppler und Diode wählen |
| 16x2-I2C-LCD | Anzeige von Temperatur, Ziel und Status | Adresse meist 0x27 oder 0x3F |
| 3 Taster | Hoch, runter und Menü | Mit internem Pull-up, kein Widerstand nötig |
| 12-V-Heizung und 12-V-Netzteil | Niederspannungs-Heizbeispiel | Z. 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 Temperatur | Vorheriger Heizungszustand | Neuer Zustand | Erklärung |
|---|---|---|---|
| 21,3 °C | Aus | Ein | Unter der Einschaltschwelle (21,5 °C) |
| 21,9 °C | Ein | Ein | Im Band, Zustand bleibt |
| 22,6 °C | Ein | Aus | Über der Ausschaltschwelle (22,5 °C) |
| 22,1 °C | Aus | Aus | Im Band, Abkühlung läuft |
| −127 °C oder 85 °C | Beliebig | Aus | Sensorfehler, in den sicheren Zustand wechseln |
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.
| Eigenschaft | Wert |
|---|---|
| Messbereich | −55 °C bis +125 °C |
| Genauigkeit | ±0,5 °C (zwischen −10 und +85 °C) |
| Auflösung | 9–12 Bit (0,5 °C – 0,0625 °C) |
| Wandlungszeit | Max. 750 ms bei 12 Bit |
| Versorgung | 3,0–5,5 V |
| Schnittstelle | 1-Wire (eine Datenleitung, 4,7-kΩ-Pull-up) |
| Kabelfarben | Rot VDD, schwarz GND, gelb oder weiß DATA |
Arduino-Thermostat: Schaltplan und Verdrahtung
| Verbindung | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| DS18B20 DATA (gelb) | D2 | GPIO 4 | GP16 |
| DS18B20 VDD (rot) | 5V | 3V3 | 3V3(OUT) |
| DS18B20 GND (schwarz) | GND | GND | GND |
| 4,7-kΩ-Pull-up | Zwischen DATA und 5V | Zwischen DATA und 3V3 | Zwischen DATA und 3V3 |
| Relais IN | D7 | GPIO 26 | GP15 |
| Relais VCC / GND | 5V / GND | VIN (5 V) / GND | VBUS (5 V) / GND |
| Tasten (hoch, runter, Menü) | D3, D4, D5 (anderes Ende an GND) | Weboberfläche | Fest im Code |
| I2C-LCD SDA / SCL | A4 / A5 | GPIO 21 / 22 (optional) | GP4 / GP5 (optional) |

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.
Schritt für Schritt aufbauen
- Installiere in der Arduino IDE über den Bibliotheksverwalter die Bibliotheken OneWire, DallasTemperature (Miles Burton) und LiquidCrystal I2C (Frank de Brabander).
- Schließe den DS18B20 an D2 an und setze den 4,7-kΩ-Widerstand zwischen DATA und 5V.
- Verbinde den IN-Pin des Relaismoduls mit D7 sowie VCC und GND mit 5V und GND des Arduino.
- 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.
- 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.
- Schließe die 12-V-Heizung über COM und NO des Relais ans Netzteil an, teste den Code aber zuerst ohne angeschlossene Heizung.
- Lade den Code hoch, erwärme und kühle den Sensor mit der Hand und beobachte, ob das Relais an den Schwellen richtig reagiert.
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ü?
| Abschnitt | Was 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 / get | Schreibt 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.
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.
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
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Anzeige FEHLER, Messwert −127 °C | Kein Pull-up, DATA-Kabel locker oder falscher Pin | 4,7-kΩ-Widerstand zwischen DATA und VDD setzen, Kabelfarben prüfen |
| Dauerhaft 85 °C | Auslesen vor Ende der Messung oder zu schwache Versorgung | Mindestens 750 ms auf die Wandlung warten, Sensor im normalen statt im parasitären Modus versorgen |
| Heizung arbeitet verkehrt herum | Relaismodul ist active HIGH | Konstanten RELAY_ON und RELAY_OFF tauschen |
| Relais klappert ständig | Hysterese zu schmal oder Sensorkabel gestört | Band verbreitern, Sensorkabel von Stromkabeln fernhalten |
| Arduino resettet, wenn das Relais anzieht | Spulen- und Heizstrom brechen die Versorgung ein | Eigenes Netzteil für die Heizung nutzen, GND-Verbindungen korrekt herstellen |
| LCD leuchtet, aber kein Text | Falsche I2C-Adresse oder Kontrast | Adresse mit I2C-Scanner finden, Poti auf der Rückseite drehen |
| Temperatur schießt weit übers Ziel | Wärme breitet sich nach dem Abschalten weiter aus | Sensor von der Heizung entfernen, Hysterese verkleinern oder PID nutzen |
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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
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…

Temperaturmessung mit NTC und 2x16 Lcd Display
Miss die Umgebungstemperatur mit einem Sensor, der aussieht wie eine kleine Perle.

Verwendung des LCD-Bildschirms mit I2C
Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.

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.

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.

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.

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.

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.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

