Arduino-thermostaat met DS18B20, relais, hysterese en LCD
Hoe bouw je een Arduino-thermostaat? Temperatuur meten met de DS18B20, een verwarming schakelen met een relais, hysterese, instelwaarde met knoppen, I2C-LCD-menu en ESP32-webinterface.
Een Arduino-thermostaat is een zelfgebouwde regelaar die steeds de temperatuur van een ruimte of een voorwerp meet en automatisch een verwarming (of koeling) in- en uitschakelt. In deze gids bouw je een volledig werkende thermostaat met een digitale DS18B20-temperatuursensor, een relaismodule, drie knoppen en een 16x2 I2C-LCD: je stelt de streeftemperatuur in met knoppen, past de hysteresebandbreedte aan via een menu en slaat de instellingen op in EEPROM, zodat ze een stroomuitval overleven. Precies deze logica zit in projecten zoals broedmachines, aquaria, kassen, fermentatiekasten en behuizingen voor 3D-printers.
In de tweede helft van het artikel verplaats je dezelfde thermostaat naar een ESP32 en stel je het doel in vanuit de browser op je telefoon. Ook zie je de MicroPython-versie voor de Raspberry Pi Pico. Omdat het aansturen van een verwarming het risicovolste deel van het werk is, gebruiken onze voorbeelden een 12 V-laagspanningsverwarming. Wil je met netspanning (230 V) werken, dan staat er een aparte sectie over waar je op moet letten.

Wat is een thermostaat en hoe werkt hij?
Een thermostaat heeft drie delen: meting (de sensor), beslissing (de microcontroller) en actie (het relais en de verwarming). De Arduino leest elke seconde de temperatuur uit en vergelijkt die met het doel dat je hebt ingesteld. Is de temperatuur onder het doel gezakt, dan trekt hij het relais aan om de verwarming van stroom te voorzien; is het doel bereikt, dan laat hij het relais los. Deze methode heet aan-uitregeling en is de meestgebruikte methode voor temperatuurregeling, van cv-thermostaten in huis tot koelkasten. De verwarming staat op vol vermogen of helemaal uit, niets ertussenin. Wil je later nauwkeuriger regelen, dan kun je doorstappen naar het artikel over PID-regeling; maar voor de meeste huisprojecten is een goed afgestelde aan-uitthermostaat ruim voldoende.
| Onderdeel | Rol | Opmerking |
|---|---|---|
| Arduino Uno (of Nano) | Meten, beslissen en menu | ESP32 en Pico kunnen ook |
| DS18B20-sensor | Temperatuurmeting | De waterdichte versie met kabel wordt aanbevolen |
| Weerstand van 4,7 kΩ | Pull-up voor de 1-Wire-lijn | Zonder deze weerstand geeft de sensor −127 °C |
| 1-kanaals 5V-relaismodule | De verwarming in- en uitschakelen | Kies liever een module met optocoupler en diode |
| 16x2 I2C LCD | Toont temperatuur, doel en status | Het adres is meestal 0x27 of 0x3F |
| 3 drukknoppen | Omhoog, omlaag en menu | Gebruik de interne pull-up, geen extra weerstand nodig |
| 12 V-verwarming en 12 V-adapter | Voorbeeld met laagspanningsverwarming | Bijvoorbeeld een 12 V 10 W verwarmingsmat |
Wat is hysterese en waarom heeft een thermostaat dat nodig?
Schrijf je de thermostaat als "schakel aan onder 22 °C, schakel uit erboven", dan schakelt het relais, zodra de temperatuur rond 22 °C schommelt, bij de kleinste schommeling van de sensor meerdere keren per seconde aan en uit. Het relais klappert, de contacten slijten door vonken en de verwarming wordt voor niets belast. De oplossing is hysterese: je gebruikt twee aparte drempels voor aan en uit. In dit project verdelen we de hysteresebandbreedte gelijk over beide kanten van het doel; bij een doel van 22 °C en 1 °C hysterese gaat de verwarming aan bij 21,5 °C en uit bij 22,5 °C. In de zone ertussen houdt het relais zijn laatste toestand. De formule is simpel: inschakeldrempel = doel − H/2, uitschakeldrempel = doel + H/2.
| Gemeten temperatuur | Vorige toestand van de verwarming | Nieuwe toestand | Uitleg |
|---|---|---|---|
| 21,3 °C | Uit | Aan | Onder de inschakeldrempel (21,5 °C) |
| 21,9 °C | Aan | Aan | Binnen de band, toestand blijft behouden |
| 22,6 °C | Aan | Uit | Boven de uitschakeldrempel (22,5 °C) |
| 22,1 °C | Uit | Uit | Binnen de band, nog aan het afkoelen |
| −127 °C of 85 °C | Elke | Uit | Sensorfout, ga naar de veilige toestand |
Waarom is de DS18B20 een goede keuze?
De DS18B20 stuurt de gemeten temperatuur direct digitaal door; anders dan bij analoge sensoren verstoren kabellengte of schommelingen in de voedingsspanning de meting niet. Hij haalt een nauwkeurigheid van ±0,5 °C tussen −10 en +85 °C en een resolutie van 0,0625 °C bij 12 bits. De waterdichte versie met roestvrijstalen huls kun je direct onderdompelen in een aquarium, in grond of in een watertank. Omdat meerdere sensoren één datapin kunnen delen, kun je later binnen- en buitentemperatuur op dezelfde lijn meten. Voor details zie het artikel DS18B20-temperatuursensor, en voor een vergelijking met andere opties de vergelijking van temperatuursensoren.
| Eigenschap | Waarde |
|---|---|
| Meetbereik | −55 °C tot +125 °C |
| Nauwkeurigheid | ±0,5 °C (tussen −10 en +85 °C) |
| Resolutie | 9–12 bits (0,5 °C – 0,0625 °C) |
| Conversietijd | Tot 750 ms bij 12 bits |
| Voeding | 3,0–5,5 V |
| Communicatie | 1-Wire (één datalijn, 4,7 kΩ pull-up) |
| Draadkleuren | Rood VDD, zwart GND, geel of wit DATA |
Bedradingsschema van de Arduino-thermostaat
| Aansluiting | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| DS18B20 DATA (geel) | D2 | GPIO 4 | GP16 |
| DS18B20 VDD (rood) | 5V | 3V3 | 3V3(OUT) |
| DS18B20 GND (zwart) | GND | GND | GND |
| 4,7 kΩ pull-up | Tussen DATA en 5V | Tussen DATA en 3V3 | Tussen DATA en 3V3 |
| Relais IN | D7 | GPIO 26 | GP15 |
| Relais VCC / GND | 5V / GND | VIN (5 V) / GND | VBUS (5 V) / GND |
| Knoppen (omhoog, omlaag, menu) | D3, D4, D5 (andere kant naar GND) | Webinterface | Vast in de code |
| I2C LCD SDA / SCL | A4 / A5 | GPIO 21 / 22 (optioneel) | GP4 / GP5 (optioneel) |

De verwarming veilig aansturen: een voorbeeld met 12 V laagspanning
Tijdens het leren hoef je niet met netspanning te werken. Met een 12 V siliconen verwarmingsmat, een vermogensweerstand of een kleine PTC-verwarming probeer je dezelfde thermostaatlogica zonder gevaar uit. Een 12 V 10 W verwarming trekt bijvoorbeeld ongeveer 0,83 A volgens I = P / V en heeft een weerstand van R = V² / P = 14,4 Ω (dat kun je zelf controleren met de rekenmachine voor de wet van Ohm). De bedrading is: de pluspool van de 12 V-adapter gaat naar het COM-contact van het relais, het NO-contact (normally open) van het relais gaat naar één kant van de verwarming en de andere kant van de verwarming gaat naar de minpool van de adapter. Het gebruik van NO is belangrijk; als de Arduino uitvalt of een draad breekt, laat het relais los en schakelt de verwarming vanzelf uit. In plaats van een relais kun je ook een logic-level MOSFET gebruiken (bijvoorbeeld de IRLZ44N); die is stil en slijt niet, met details in het artikel Een MOSFET gebruiken met Arduino.
- Plaats de sensor op de juiste plek: zit de sensor tegen de verwarming geplakt, dan meet de thermostaat de verwarming en niet de omgeving en schakelt hij veel te vroeg uit; plaats de sensor midden in de ruimte die je wilt regelen.
- Veiligheidsgrens in de software: in de code schakelt de verwarming boven MAX_SAFE (40 °C) uit, ongeacht het doel; pas deze waarde aan voor je eigen toepassing.
- Uitschakelen bij sensorstoring: als de kabel breekt, geeft de DS18B20 −127 °C; de thermostaat mag dit niet aanzien voor "heel koud" en de verwarming volledig aanzetten. De code laat in dit geval het relais los.
- Hardwarematige noodbeveiliging: software kan vastlopen. Gebruik bij een serieuze verwarming een thermische zekering in serie (bijvoorbeeld 70 °C) of een bimetaalthermostaat.
- Let op de contactstroom: de "10 A" op de module geldt voor ideale omstandigheden; overschrijd bij continue belasting niet de helft daarvan.
- Aparte voeding: de verwarmingsstroom mag nooit door de 5V-pin van de Arduino lopen; gebruik een eigen adapter voor de verwarming. Het artikel Arduino-voeding helpt je bij vragen over voeding.
Opbouw stap voor stap
- Installeer in de Arduino IDE de bibliotheken OneWire, DallasTemperature (Miles Burton) en LiquidCrystal I2C (Frank de Brabander) via de Library Manager.
- Sluit de DS18B20 aan op D2 en plaats de weerstand van 4,7 kΩ tussen DATA en 5V.
- Sluit de IN-pin van de relaismodule aan op D7 en de VCC- en GND-pinnen op de 5V- en GND-pinnen van de Arduino.
- Sluit één kant van elke knop aan op D3, D4 en D5 en de andere kant op GND; omdat de interne pull-up in de code is ingeschakeld, is er geen extra weerstand nodig.
- Sluit de I2C-LCD aan als SDA → A4, SCL → A5. Staat er geen tekst op het scherm, probeer dan het adres 0x3F in plaats van 0x27 of draai aan de contrastpotmeter op de achterkant.
- Sluit de 12 V-verwarming via de COM- en NO-contacten van het relais aan op de adapter, maar test de code eerst met losgekoppelde verwarming.
- Upload de code, verwarm en koel de sensor met je hand en kijk of het relais bij de drempels correct reageert.
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}Hoe werkt de code en hoe gebruik je het LCD-menu?
| Deel | Wat het doet |
|---|---|
| setWaitForConversion(false) | Laat de Arduino niet 750 ms wachten terwijl de sensor meet; knoppen en display blijven reageren. |
| Het blok van 1 seconde in loop() | Leest de vorige meting uit, start een nieuwe, neemt de regelbeslissing en werkt het display bij. |
| control() | Schakelt de verwarming uit bij een sensorfout of oververhitting; beslist anders op basis van de hysteresedrempels. |
| setHeater() | Wijzigt de relaistoestand; laat minstens 10 seconden tussen schakelmomenten, behalve bij de veiligheidsuitschakeling. |
| pressed() | Leest de knoppen met een op millis() gebaseerde contactdender van 50 ms en pakt alleen het moment van indrukken op. |
| handleButtons() | De menuknop wisselt tussen doel en hysterese; de knoppen omhoog en omlaag veranderen de gekozen waarde en houden die binnen de grenzen. |
| EEPROM.put / get | Schrijft de instellingen naar niet-vluchtig geheugen; is de bij het opstarten gelezen waarde onzinnig, dan worden de standaardwaarden gebruikt. |
De bovenste regel van het scherm toont de huidige temperatuur en de toestand van de verwarming (ISIT of BEKLE, wat verwarmen of stand-by betekent), en de onderste regel toont de waarden voor het doel (H) en de hysterese (d). De pijl voor een waarde laat zien welke je aanpast. Elke druk op de menuknop verplaatst de cursor tussen doel en hysterese; de knoppen omhoog en omlaag veranderen het doel in stappen van 0,5 °C en de hysterese in stappen van 0,1 °C. Het doel is beperkt tot 5–35 °C en de hysterese tot 0,2–5 °C. Elke wijziging wordt naar EEPROM geschreven; omdat EEPROM.put alleen de bytes bijwerkt die zijn veranderd en EEPROM-cellen ongeveer 100.000 schrijfbewerkingen meegaan, zijn aanpassingen met de knoppen geen probleem. Waarom millis() gebruiken in plaats van delay() belangrijk is, lees je in millis en delay, en meer over permanente opslag vind je in Arduino EEPROM. De minimale schakeltijd is ook een belangrijk detail: zelfs als je een heel smalle hysterese kiest, verandert het relais niet vaker dan één keer per 10 seconden van stand. Regel je een koelkast met compressor, verleng deze tijd dan naar 3–5 minuten.
Een ESP32-thermostaat die je via het web kunt instellen
Dankzij de ingebouwde Wi-Fi van de ESP32 kun je de streeftemperatuur en de hysterese vanuit de browser op je telefoon instellen, zonder knoppen. De code hieronder gebruikt de ingebouwde bibliotheken WebServer en Preferences, die ongewijzigd compileren op ESP32 Arduino core 2.x en 3.x; behalve OneWire en DallasTemperature hoef je geen extra bibliotheken te installeren. De instellingen worden met Preferences in het flashgeheugen opgeslagen, zodat de doelwaarde bewaard blijft als de ESP32 opnieuw opstart. Lukt het binnen 15 seconden niet om verbinding met Wi-Fi te maken, dan stopt de code met wachten en blijft de thermostaat toch werken; een netwerkverbinding mag de verwarmingsregeling nooit blokkeren. Gebruik je de ESP32 voor het eerst, volg dan eerst de installatiestappen in Wat is de 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}Pas voordat je de code uploadt WIFI_SSID en WIFI_PASS aan je eigen netwerk aan. Typ je het IP-adres dat in de Serial Monitor (115200 baud) staat in je browser, dan zie je de temperatuur, de toestand van de verwarming en de twee invoervelden voor de instellingen. Druk je op Kaydet (Opslaan), dan wordt het formulier naar het adres /set gestuurd, doorlopen de waarden de bereikcontrole, worden ze opgeslagen en stuurt de pagina je terug naar het hoofdscherm. Het adres /json geeft de metingen in machineleesbare vorm; je kunt het gebruiken met Home Assistant of je eigen app. Omdat de GPIO's van de ESP32 3,3 V zijn, voed je de relaismodule via de VIN-pin (5 V); de meeste optocouplermodules schakelen prima met een signaal van 3,3 V, en doet die van jou dat niet, voeg dan een NPN-transistor ertussen toe. Wil je een interface die live wordt bijgewerkt, zie dan ESP32-webserver en WebSocket, en voor meldingen op je telefoon ESP32 Telegram-bot.
MicroPython-thermostaat met de Raspberry Pi Pico
De MicroPython-firmware van de Pico bevat de modules onewire en ds18x20 al, dus je hoeft geen extra bestanden te kopiëren. Het korte programma hieronder past dezelfde hysterese- en veiligheidslogica toe; wordt de sensor niet gevonden of treedt er een leesfout op, dan schakelt het het relais uit en blijft het opnieuw naar de sensor zoeken. Je kunt het doel en de hysterese aanpassen via de constanten bovenaan de code. Ben je nieuw met de Pico, dan leidt Wat is de Raspberry Pi Pico je stap voor stap door de installatie van Thonny.
1from machine import Pin
2import onewire, ds18x20, time
3
4HEDEF = 22.0 # hedef sıcaklık / target temperature
5HIST = 1.0 # histerezis bandı / hysteresis band
6MAX_GUVENLI = 40.0 # güvenlik sınırı / safety limit
7ROLE_ACIK = 0 # aktif LOW modül / active LOW module
8ROLE_KAPALI = 1
9
10role = Pin(15, Pin.OUT, value=ROLE_KAPALI)
11ds = ds18x20.DS18X20(onewire.OneWire(Pin(16)))
12roms = ds.scan()
13print("Sensorler / Sensors:", roms)
14isitici = False
15
16def ayarla(ac):
17 global isitici
18 isitici = ac
19 role.value(ROLE_ACIK if ac else ROLE_KAPALI)
20
21while True:
22 t = None
23 if roms:
24 try:
25 ds.convert_temp()
26 time.sleep_ms(750) # 12 bit dönüşüm süresi / 12-bit conversion time
27 t = ds.read_temp(roms[0])
28 except Exception:
29 t = None
30 else:
31 roms = ds.scan() # sensörü yeniden ara / search sensor again
32 if t is None or t == 85.0 or t >= MAX_GUVENLI:
33 ayarla(False) # güvenli durum / safe state
34 elif t <= HEDEF - HIST / 2:
35 ayarla(True)
36 elif t >= HEDEF + HIST / 2:
37 ayarla(False)
38 print(t, "ISIT" if isitici else "BEKLE")
39 time.sleep(1)Projectideeën voor een Arduino-thermostaat
- Broedmachine: eieren uitbroeden met een doel van 37,5 °C en 0,3 °C hysterese; voeg een extra sensor toe om de luchtvochtigheid te bewaken.
- Aquariumverwarming regelen: houd het water constant op 25 °C met een waterdichte DS18B20.
- Slimme kas: combineer verwarming, ventilatie en bewatering op één board; voor ideeën zie het artikel project slimme kas.
- Koelthermostaat: draai de logica om en laat een ventilator draaien als de temperatuur stijgt; details staan in Arduino-ventilatorregeling.
- Vorstbeveiliging: schakel bij 3 °C een verwarmingskabel in om bevriezing van leidingen te voorkomen; zie vorstalarm.
- Fermentatiekast: een tweerichtingsthermostaat die met een Peltier zowel verwarmt als koelt; het artikel Peltier-module is een goed beginpunt.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| HATA (fout) op het scherm, uitlezing −127 °C | Geen pull-up, losse DATA-draad of verkeerde pin | Plaats de weerstand van 4,7 kΩ tussen DATA en VDD, controleer de draadkleuren |
| Geeft altijd 85 °C | Uitlezing voordat de conversie klaar is, of onvoldoende voeding | Wacht minstens 750 ms op de conversie, voed de sensor in normale modus, niet parasitair |
| Verwarming werkt omgekeerd | Relaismodule is active HIGH | Wissel de constanten RELAY_ON en RELAY_OFF om |
| Relais blijft klapperen | Hysterese te smal of sensorkabel vangt ruis op | Maak de band breder, leg de sensorkabel uit de buurt van voedingskabels |
| Arduino reset als het relais aantrekt | Spoel- en verwarmingsstroom laten de voeding inzakken | Gebruik een aparte adapter voor de verwarming, verbind de GND's goed |
| LCD is verlicht maar toont geen tekst | Verkeerd I2C-adres of contrastinstelling | Zoek het adres met een I2C-scanner, draai aan de potmeter op de achterkant |
| Temperatuur schiet door het doel en wordt te hoog | Warmte blijft zich verspreiden nadat de verwarming is uitgeschakeld | Zet de sensor verder van de verwarming, verlaag de hysterese of gebruik PID |
Je hebt nu een thermostaat met hysterese, een menu en veiligheidsfuncties die de waarde van een sensor omzet in een echte actie; met kleine aanpassingen kun je dezelfde structuur gebruiken voor koeling, luchtvochtigheid of waterniveauregeling. In de BlueGrays-app kun je je thermostaat verder verbeteren met projecten zoals temperatuur- en luchtvochtigheidsmeting met de DHT11, een thermometer met NTC en LCD, een 230 V-lamp schakelen met een relais en een ESP32-webserver, elk met een schakelschema stap voor stap en kant-en-klare code.
Veelgestelde vragen
Hoeveel graden moet de hysterese van een thermostaat zijn?
Dat hangt ervan af hoe snel de omgeving opwarmt en afkoelt. In kleine, gevoelige ruimtes zoals een broedmachine is 0,3–0,5 °C een goed begin; in grote ruimtes zoals een kamer of watertank 1–2 °C. Schakelt het relais te vaak, maak de band dan breder; wijkt de temperatuur te ver af, maak hem dan smaller.
Waarom toont de DS18B20 -127 graden?
−127 °C is de foutwaarde (DEVICE_DISCONNECTED_C) die aangeeft dat de bibliotheek niet met de sensor kon communiceren. De meest voorkomende oorzaken zijn een ontbrekende 4,7 kΩ pull-upweerstand, een losse DATA-draad of een verkeerd pinnummer in de code. De thermostaatcode in dit artikel schakelt de verwarming uit veiligheidsoverwegingen uit zodra hij deze waarde ziet.
Kun je een 230 V-verwarming aansturen met Arduino?
Technisch gezien wel; een relaismodule of SSR kan met het laagspanningssignaal van de Arduino een belasting op het net schakelen. 230 V is echter levensgevaarlijk; verbindingen moeten in een geïsoleerde behuizing worden gemaakt, met een zekering en onder toezicht van een ervaren persoon. Bij verwarmingen met veel vermogen moet de relaismodule de belasting via een contactor aansturen in plaats van rechtstreeks.
Moet ik voor een thermostaat een relais of een SSR gebruiken?
Voor een aan-uitthermostaat die een paar keer per uur schakelt, is een mechanisch relais goedkoop en voldoende. Heb je heel frequent schakelen, stille werking of tijdproportionele regeling met PID nodig, dan is een solid state relay (SSR) geschikter; een SSR wordt echter warm en heeft een koelplaat nodig. Voor 12 V DC-verwarmingen is een logic-level MOSFET de eenvoudigste oplossing.
Worden de instellingen van een Arduino-thermostaat gewist bij stroomuitval?
Variabelen staan in RAM, dus normaal gaan ze verloren. De code in dit artikel schrijft het doel en de hysterese naar EEPROM en leest ze bij het opstarten weer in; de ESP32-versie doet hetzelfde in het flashgeheugen met de bibliotheek Preferences. Zo gaat de thermostaat, als de stroom terugkomt, verder met de laatste instellingen.
Kun je een thermostaat maken met een DHT11?
Dat kan, maar de nauwkeurigheid van ±2 °C en de resolutie van 1 °C van de DHT11 zijn niet genoeg voor een nauwkeurige thermostaat. De DS18B20 biedt een nauwkeurigheid van ±0,5 °C en een resolutie van 0,0625 °C, en is er in een waterdichte versie. Moet je ook de luchtvochtigheid regelen, dan is de DHT22 of AHT20 een beter compromis.
Projecten om hierna te bouwen
Alle projecten bekijken
Temperatuur en luchtvochtigheid met DHT11
Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

Temperatuur meten met NTC en 2x16 LCD-display
Meet de temperatuur om je heen met een sensor die op een klein kraaltje lijkt. Dit onderdeel, een NTC, laat elektriciteit makkelijker door naarmate het warmer wordt; de Arduino leest die verandering…

Een lcd-scherm gebruiken met I2C
Geef je Arduino een eigen scherm en laat hem zijn eerste bericht schrijven. Het lcd-scherm met twee regels sluit je aan met maar een paar draden; op de bovenste regel verschijnt een groet, daarna een…

230V-lamp laten branden met een drukknop
Zolang je de knop vasthoudt, brandt een echte lamp op netspanning, en zodra je loslaat gaat hij uit.

230V-lamp laten branden met een knop (aan/uit)
Wil je een echte lamp uit huis met een klein knopje aan- en uitzetten? Elke keer dat je op de knop drukt, schakelt de Arduino een relais om en gaat de lamp aan; druk je nog een keer, dan gaat hij uit.

ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
Dit project meet de omgevingstemperatuur en luchtvochtigheid met een DHT22-sensor en toont de gegevens in realtime op een 16x2 I2C-LCD. De data wordt met het one-wire-protocol via de Adafruit DHT-bibliotheek uit de sensor gelezen. Dit project is de basis voor IoT-weerstations, slimme domotica of omgevingsbewaking in kassen. De communicatie met de DHT22 loopt via pin GPIO 4 van de ESP32.

ESP32 asynchrone webserver (met IP-weergave op lcd)
In dit project maken we van de ESP32 een asynchrone webserver die je met je telefoon of computer op hetzelfde wifinetwerk kunt bedienen. Dankzij de ESPAsyncWebServer-bibliotheek kan de server meerdere verzoeken tegelijk verwerken (anders dan de klassieke WebServer.h, die bij één verzoek blokkeert). Je opent het IP-adres van de ESP32 in een browser en klikt op de knoppen ON/OFF (de routes /on en /off) om de led op GPIO 5 aan en uit te zetten.

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

