Gidsen · 11 min leestijd

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.

Digitale DS18B20-temperatuursensor
DS18B20: geeft de temperatuur door via één datalijn (1-Wire) met een resolutie van 0,0625 °C; hij vormt de meetkant van de thermostaat.

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.

OnderdeelRolOpmerking
Arduino Uno (of Nano)Meten, beslissen en menuESP32 en Pico kunnen ook
DS18B20-sensorTemperatuurmetingDe waterdichte versie met kabel wordt aanbevolen
Weerstand van 4,7 kΩPull-up voor de 1-Wire-lijnZonder deze weerstand geeft de sensor −127 °C
1-kanaals 5V-relaismoduleDe verwarming in- en uitschakelenKies liever een module met optocoupler en diode
16x2 I2C LCDToont temperatuur, doel en statusHet adres is meestal 0x27 of 0x3F
3 drukknoppenOmhoog, omlaag en menuGebruik de interne pull-up, geen extra weerstand nodig
12 V-verwarming en 12 V-adapterVoorbeeld met laagspanningsverwarmingBijvoorbeeld 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 temperatuurVorige toestand van de verwarmingNieuwe toestandUitleg
21,3 °CUitAanOnder de inschakeldrempel (21,5 °C)
21,9 °CAanAanBinnen de band, toestand blijft behouden
22,6 °CAanUitBoven de uitschakeldrempel (22,5 °C)
22,1 °CUitUitBinnen de band, nog aan het afkoelen
−127 °C of 85 °CElkeUitSensorfout, ga naar de veilige toestand
Denk bij het kiezen van de hysterese aan de thermische traagheid van de omgeving. In een kleine broedkast is 0,3–0,5 °C genoeg; in een kamer of een grote watertank is 1–2 °C zinvoller. Is de band te smal, dan schakelt het relais vaak; is hij te breed, dan wijkt de temperatuur te ver van het doel af. Ook nadat de verwarming is uitgeschakeld, blijft de opgeslagen warmte de temperatuur nog even omhoog duwen (overshoot); let hierop en pas de band daarop aan.

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.

EigenschapWaarde
Meetbereik−55 °C tot +125 °C
Nauwkeurigheid±0,5 °C (tussen −10 en +85 °C)
Resolutie9–12 bits (0,5 °C – 0,0625 °C)
ConversietijdTot 750 ms bij 12 bits
Voeding3,0–5,5 V
Communicatie1-Wire (één datalijn, 4,7 kΩ pull-up)
DraadkleurenRood VDD, zwart GND, geel of wit DATA

Bedradingsschema van de Arduino-thermostaat

AansluitingArduino UnoESP32Raspberry Pi Pico
DS18B20 DATA (geel)D2GPIO 4GP16
DS18B20 VDD (rood)5V3V33V3(OUT)
DS18B20 GND (zwart)GNDGNDGND
4,7 kΩ pull-upTussen DATA en 5VTussen DATA en 3V3Tussen DATA en 3V3
Relais IND7GPIO 26GP15
Relais VCC / GND5V / GNDVIN (5 V) / GNDVBUS (5 V) / GND
Knoppen (omhoog, omlaag, menu)D3, D4, D5 (andere kant naar GND)WebinterfaceVast in de code
I2C LCD SDA / SCLA4 / A5GPIO 21 / 22 (optioneel)GP4 / GP5 (optioneel)
De twee meest voorkomende fouten: de 4,7 kΩ pull-upweerstand vergeten (de sensor geeft −127 °C) en niet weten dat het relais active LOW is. De meeste relaismodules op de markt trekken aan als de IN-pin LOW is, daarom definieert de code RELAY_ON = LOW. Trekt jouw module aan bij HIGH, wissel dan deze twee constanten om; anders doet de thermostaat precies het tegenovergestelde en blijft de verwarming de hele tijd aan.
5V-relaismodule
Relaismodule: trekt zijn spoel aan op het signaal van de Arduino en opent en sluit het verwarmingscircuit met een mechanisch contact.

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.
230 V netspanning kan dodelijk zijn. Wil je een verwarming op het net aansturen, bouw de schakeling dan onder toezicht van een volwassene of een ervaren elektricien, plaats alle 230 V-verbindingen in een gesloten, geïsoleerde behuizing, laat geen blote uiteinden zitten en beveilig de schakeling met een zekering. Een verwarming van 2000 W trekt bij 230 V ongeveer 8,7 A, wat te hoog is voor een goedkope relaismodule. Voor belastingen met dit vermogen mag de relaismodule alleen een contactor aansturen, of er moet een solid state relay (SSR) met een geschikte koelplaat worden gebruikt.

Opbouw stap voor stap

  1. Installeer in de Arduino IDE de bibliotheken OneWire, DallasTemperature (Miles Burton) en LiquidCrystal I2C (Frank de Brabander) via de Library Manager.
  2. Sluit de DS18B20 aan op D2 en plaats de weerstand van 4,7 kΩ tussen DATA en 5V.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. Upload de code, verwarm en koel de sensor met je hand en kijk of het relais bij de drempels correct reageert.
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}

Hoe werkt de code en hoe gebruik je het LCD-menu?

DeelWat 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 / getSchrijft 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.

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}

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.

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)

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

SymptoomWaarschijnlijke oorzaakOplossing
HATA (fout) op het scherm, uitlezing −127 °CGeen pull-up, losse DATA-draad of verkeerde pinPlaats de weerstand van 4,7 kΩ tussen DATA en VDD, controleer de draadkleuren
Geeft altijd 85 °CUitlezing voordat de conversie klaar is, of onvoldoende voedingWacht minstens 750 ms op de conversie, voed de sensor in normale modus, niet parasitair
Verwarming werkt omgekeerdRelaismodule is active HIGHWissel de constanten RELAY_ON en RELAY_OFF om
Relais blijft klapperenHysterese te smal of sensorkabel vangt ruis opMaak de band breder, leg de sensorkabel uit de buurt van voedingskabels
Arduino reset als het relais aantrektSpoel- en verwarmingsstroom laten de voeding inzakkenGebruik een aparte adapter voor de verwarming, verbind de GND's goed
LCD is verlicht maar toont geen tekstVerkeerd I2C-adres of contrastinstellingZoek het adres met een I2C-scanner, draai aan de potmeter op de achterkant
Temperatuur schiet door het doel en wordt te hoogWarmte blijft zich verspreiden nadat de verwarming is uitgeschakeldZet de sensor verder van de verwarming, verlaag de hysterese of gebruik PID
Test je thermostaat met een LED voordat je hem op een echte verwarming aansluit: sluit in plaats van het relais de anode van de LED via 220 Ω aan op 5V en de kathode op D7. Met active LOW-logica gaat de LED dan branden op het moment dat de verwarming aan zou staan. Verwarm de sensor in je handpalm en dompel hem in een glas koud water; schakelt de LED bij de juiste drempels aan en uit, dan is de software klaar. Hoe een relais stap voor stap wordt aangesloten, lees je in Wat is een relaismodule, en bij problemen met het display zie het artikel I2C-LCD-display.

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.

Alle projecten bekijken
Temperatuur en luchtvochtigheid met DHT11
AR-55Gemiddeld

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…

4.7(47)
83
Temperatuur meten met NTC en 2x16 LCD-display
AR-44Beginner
Premium

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…

4.5(33)
44
Een lcd-scherm gebruiken met I2C
AR-32Beginner
Premium

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…

4.8(53)
70
230V-lamp laten branden met een drukknop
AR-19Gevorderd
Premium

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.

4.4(30)
38
230V-lamp laten branden met een knop (aan/uit)
AR-20Gevorderd
Premium

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.

4.5(33)
44
ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
ES-15Gemiddeld

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.

4.8(38)
57
ESP32 asynchrone webserver (met IP-weergave op lcd)
ES-27Gevorderd

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.

4.8(16)
26
ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Gevorderd
Premium

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.

4.7(7)
12