Guides · 12 min de lecture

Thermostat Arduino : DS18B20, relais, hystérésis et écran LCD

Comment faire un thermostat Arduino ? Mesure avec DS18B20, commande de chauffage par relais, hystérésis, réglage par boutons, menu LCD I2C et interface web ESP32.

Un thermostat Arduino est un appareil de régulation que tu fabriques toi-même : il mesure en continu la température d'une pièce ou d'un objet et allume ou éteint automatiquement un chauffage (ou un refroidisseur). Dans ce guide, tu vas construire un thermostat complet avec un capteur numérique DS18B20, un module relais, trois boutons et un écran LCD I2C 16x2 : tu régleras la consigne avec les boutons, tu changeras la bande d'hystérésis dans le menu et tu enregistreras les réglages en EEPROM pour qu'ils survivent à une coupure de courant. Cette logique se trouve au cœur de nombreux projets : couveuse, aquarium, serre, armoire de fermentation ou caisson d'imprimante 3D.

Dans la seconde moitié de l'article, tu porteras le même thermostat sur l'ESP32 pour régler la consigne depuis le navigateur de ton téléphone, et tu verras aussi la version MicroPython pour le Raspberry Pi Pico. La commande du chauffage étant la partie la plus risquée, nos exemples utilisent un chauffage basse tension de 12 V. Une section à part explique à quoi faire attention si tu veux travailler avec la tension du secteur (230 V).

Capteur de température numérique DS18B20
DS18B20 : il donne la température avec une résolution de 0,0625 °C sur un seul fil de données (1-Wire) et constitue la partie mesure du thermostat.

Qu'est-ce qu'un thermostat et comment fonctionne-t-il ?

Un thermostat se compose de trois parties : la mesure (le capteur), la décision (le microcontrôleur) et l'action (le relais et le chauffage). L'Arduino lit la température chaque seconde et la compare à la consigne que tu as choisie. Si la température passe sous la consigne, il fait coller le relais pour alimenter le chauffage ; une fois la consigne atteinte, il relâche le relais. Cette méthode s'appelle la régulation tout ou rien (on-off) et c'est la plus répandue, des thermostats de chaudière aux réfrigérateurs. Le chauffage fonctionne soit à pleine puissance, soit pas du tout, sans niveau intermédiaire. Si tu veux une régulation plus fine, tu pourras passer plus tard à l'article sur la régulation PID ; mais pour la plupart des projets domestiques, un thermostat tout ou rien bien réglé suffit largement.

ComposantRôleRemarque
Arduino Uno (ou Nano)Mesure, décision et menuL'ESP32 et le Pico fonctionnent aussi
Capteur DS18B20Mesure de la températureVersion étanche à câble recommandée
Résistance 4,7 kΩPull-up du bus 1-WireSans elle, le capteur renvoie −127 °C
Module relais 5 V 1 canalAllumer et éteindre le chauffagePréfère un module avec optocoupleur et diode
LCD I2C 16x2Affichage température, consigne et étatAdresse généralement 0x27 ou 0x3F
3 boutons poussoirsHaut, bas et menuAvec pull-up interne, aucune résistance nécessaire
Chauffage 12 V et adaptateur 12 VExemple de chauffage basse tensionPar exemple un tapis chauffant 12 V 10 W

Qu'est-ce que l'hystérésis et pourquoi est-elle indispensable ?

Si tu programmes ton thermostat avec « allume sous 22 °C, éteins au-dessus », dès que la température tourne autour de 22 °C, la moindre fluctuation du capteur fera commuter le relais plusieurs fois par seconde. Le relais cliquette, ses contacts s'usent par étincelles et le chauffage est sollicité inutilement. La solution, c'est l'hystérésis : tu utilises deux seuils distincts pour l'allumage et l'extinction. Dans ce projet, on répartit la bande également de part et d'autre de la consigne ; avec une consigne de 22 °C et une hystérésis de 1 °C, le chauffage s'allume à 21,5 °C et s'éteint à 22,5 °C. Entre les deux, le relais garde son dernier état. La formule est simple : seuil d'allumage = consigne − H/2, seuil d'extinction = consigne + H/2.

Température mesuréeÉtat précédent du chauffageNouvel étatExplication
21,3 °CÉteintAlluméSous le seuil d'allumage (21,5 °C)
21,9 °CAlluméAlluméDans la bande, l'état est conservé
22,6 °CAlluméÉteintAu-dessus du seuil d'extinction (22,5 °C)
22,1 °CÉteintÉteintDans la bande, le refroidissement continue
−127 °C ou 85 °CQuelconqueÉteintDéfaut du capteur, passage en état sûr
Pour choisir l'hystérésis, pense à l'inertie thermique du milieu. Dans une petite couveuse, 0,3 à 0,5 °C suffit ; dans une pièce ou un grand bac d'eau, 1 à 2 °C est plus raisonnable. Si la bande est trop étroite, le relais travaille trop souvent ; si elle est trop large, la température s'écarte trop de la consigne. Même après l'arrêt du chauffage, la chaleur accumulée fait monter la température encore un moment (dépassement, ou overshoot) : observe-le et ajuste la bande en conséquence.

Pourquoi le DS18B20 est-il un bon choix ?

Le DS18B20 envoie directement la température sous forme numérique ; contrairement aux capteurs analogiques, la longueur du câble ou les variations de tension d'alimentation ne faussent pas la lecture. Il offre une précision de ±0,5 °C entre −10 et +85 °C et une résolution de 0,0625 °C en 12 bits. Sa version étanche à gaine en inox peut être plongée directement dans un aquarium, dans la terre ou dans un réservoir d'eau. Comme plusieurs capteurs peuvent partager une même broche de données, tu pourras plus tard mesurer la température intérieure et extérieure sur le même fil. Pour les détails, consulte l'article sur le capteur de température DS18B20, et pour le comparer aux autres options, la comparaison des capteurs de température.

CaractéristiqueValeur
Plage de mesure−55 °C à +125 °C
Précision±0,5 °C (entre −10 et +85 °C)
Résolution9 à 12 bits (0,5 °C à 0,0625 °C)
Temps de conversion750 ms maximum en 12 bits
Alimentation3,0 à 5,5 V
Communication1-Wire (un seul fil de données, pull-up 4,7 kΩ)
Couleurs des filsRouge VDD, noir GND, jaune ou blanc DATA

Schéma de câblage du thermostat Arduino

ConnexionArduino UnoESP32Raspberry Pi Pico
DS18B20 DATA (jaune)D2GPIO 4GP16
DS18B20 VDD (rouge)5V3V33V3(OUT)
DS18B20 GND (noir)GNDGNDGND
Pull-up 4,7 kΩEntre DATA et 5VEntre DATA et 3V3Entre DATA et 3V3
Relais IND7GPIO 26GP15
Relais VCC / GND5V / GNDVIN (5 V) / GNDVBUS (5 V) / GND
Boutons (haut, bas, menu)D3, D4, D5 (l'autre broche à GND)Interface webFixé dans le code
LCD I2C SDA / SCLA4 / A5GPIO 21 / 22 (facultatif)GP4 / GP5 (facultatif)
Les deux erreurs les plus fréquentes : oublier la résistance pull-up de 4,7 kΩ (le capteur renvoie −127 °C) et ignorer que le relais est actif à l'état BAS. La plupart des modules relais collent quand la broche IN passe à LOW ; c'est pourquoi le code définit RELAY_ON = LOW. Si ton module colle avec HIGH, échange ces deux constantes ; sinon le thermostat fera exactement l'inverse et laissera le chauffage allumé en permanence.
Module relais 5 V
Module relais : le signal de l'Arduino fait coller la bobine, qui ouvre et ferme le circuit du chauffage par un contact mécanique.

Commander le chauffage en sécurité : exemple en basse tension 12 V

Pour apprendre, tu n'as pas besoin de travailler avec la tension du secteur. Un tapis chauffant en silicone 12 V, une résistance de puissance ou un petit chauffage CTP te permettent de tester la même logique sans danger. Par exemple, un chauffage 12 V 10 W absorbe environ 0,83 A d'après I = P / V et sa résistance vaut R = V² / P = 14,4 Ω (tu peux le vérifier toi-même avec le calculateur de loi d'Ohm). Le câblage est le suivant : le plus de l'adaptateur 12 V va au contact COM du relais, le contact NO (normalement ouvert) du relais va à une borne du chauffage, et l'autre borne du chauffage va au moins de l'adaptateur. Utiliser NO est important : si l'Arduino s'éteint ou si un fil se détache, le relais retombe et le chauffage s'arrête de lui-même. À la place du relais, tu peux aussi utiliser un MOSFET logique (par exemple l'IRLZ44N) ; il est silencieux et ne s'use pas, détails dans l'article Utiliser un MOSFET avec Arduino.

  • Place bien le capteur : s'il est collé au chauffage, le thermostat mesure le chauffage et non le milieu, et coupe beaucoup trop tôt ; place le capteur au centre de la zone que tu veux réguler.
  • Limite de sécurité logicielle : dans le code, au-dessus de MAX_SAFE (40 °C), le chauffage s'éteint quelle que soit la consigne ; adapte cette valeur à ton application.
  • Coupe en cas de défaut du capteur : quand le câble est coupé, le DS18B20 renvoie −127 °C ; le thermostat ne doit pas y voir « très froid » et chauffer à fond. Le code relâche alors le relais.
  • Protection matérielle de secours : un logiciel peut se bloquer. Pour un chauffage sérieux, utilise un fusible thermique (par exemple 70 °C) ou un thermostat bimétallique en série.
  • Attention au courant des contacts : l'inscription « 10 A » sur le module vaut pour des conditions idéales ; en charge continue, ne dépasse pas la moitié de cette valeur.
  • Alimentation séparée : le courant du chauffage ne doit jamais passer par la broche 5V de l'Arduino ; utilise un adaptateur dédié pour le chauffage. L'article Alimentation de l'Arduino t'aidera sur ce point.
Le 230 V du secteur est mortel. Si tu veux commander un chauffage branché sur le secteur, monte le circuit sous la surveillance d'un adulte ou d'un électricien expérimenté, place toutes les connexions 230 V dans un boîtier fermé et isolé, ne laisse aucune extrémité à nu et protège le circuit par un fusible. Un chauffage de 2000 W absorbe environ 8,7 A sous 230 V, ce qui est trop pour un module relais bon marché. Pour de telles puissances, le module relais ne doit piloter qu'un contacteur, ou il faut utiliser un relais statique (SSR) avec un dissipateur adapté.

Montage pas à pas

  1. Dans l'IDE Arduino, installe depuis le gestionnaire de bibliothèques OneWire, DallasTemperature (Miles Burton) et LiquidCrystal I2C (Frank de Brabander).
  2. Branche le DS18B20 sur D2 et place la résistance de 4,7 kΩ entre DATA et 5V.
  3. Relie la broche IN du module relais à D7, et ses broches VCC et GND au 5V et au GND de l'Arduino.
  4. Relie une broche de chaque bouton à D3, D4 et D5, et l'autre à GND ; le pull-up interne étant activé dans le code, aucune résistance n'est nécessaire.
  5. Branche le LCD I2C : SDA → A4, SCL → A5. S'il n'affiche rien, essaie l'adresse 0x3F au lieu de 0x27 ou tourne le potentiomètre de contraste à l'arrière.
  6. Relie le chauffage 12 V à l'adaptateur via les contacts COM et NO du relais, mais teste d'abord le code sans chauffage branché.
  7. Téléverse le code, puis réchauffe et refroidis le capteur avec la main pour vérifier que le relais réagit correctement aux seuils.
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}

Comment fonctionne le code et comment utiliser le menu LCD ?

PartieCe qu'elle fait
setWaitForConversion(false)N'immobilise pas l'Arduino 750 ms pendant la mesure ; les boutons et l'écran restent fluides.
Bloc d'une seconde dans loop()Lit la mesure précédente, lance la suivante, prend la décision de régulation et met à jour l'écran.
control()Éteint le chauffage en cas de défaut du capteur ou de surchauffe ; sinon décide selon les seuils d'hystérésis.
setHeater()Change l'état du relais ; laisse au moins 10 secondes entre deux commutations, sauf pour l'arrêt de sécurité.
pressed()Lit les boutons avec un anti-rebond de 50 ms basé sur millis() et ne détecte que l'instant de l'appui.
handleButtons()Le bouton menu alterne entre consigne et hystérésis ; haut et bas modifient la valeur choisie et la maintiennent dans les limites.
EEPROM.put / getÉcrit les réglages en mémoire permanente ; si la valeur lue au démarrage est incohérente, les valeurs par défaut sont utilisées.

La ligne du haut de l'écran affiche la température actuelle et l'état du chauffage (ISIT ou BEKLE, c'est-à-dire chauffe ou attente), la ligne du bas la consigne (H) et l'hystérésis (d). La flèche devant la valeur indique celle que tu modifies. À chaque appui sur le bouton menu, le curseur passe de la consigne à l'hystérésis ; les boutons haut et bas modifient la consigne par pas de 0,5 °C et l'hystérésis par pas de 0,1 °C. La consigne est limitée à 5–35 °C et l'hystérésis à 0,2–5 °C. Chaque modification est écrite en EEPROM ; comme EEPROM.put ne met à jour que les octets modifiés et que les cellules EEPROM supportent environ 100 000 écritures, les réglages par boutons ne posent aucun problème. Pour comprendre pourquoi utiliser millis() plutôt que delay(), consulte millis et delay, et pour la sauvegarde permanente, EEPROM Arduino. Le temps minimal entre commutations est aussi un détail important : même avec une hystérésis très étroite, le relais ne change pas d'état plus d'une fois toutes les 10 secondes. Si tu commandes un réfrigérateur à compresseur, porte ce délai à 3–5 minutes.

Thermostat réglable par le web avec l'ESP32

Grâce au Wi-Fi intégré de l'ESP32, tu peux régler la consigne et l'hystérésis depuis le navigateur de ton téléphone, sans boutons. Le code ci-dessous utilise les bibliothèques intégrées WebServer et Preferences, qui compilent sans modification avec l'ESP32 Arduino core 2.x et 3.x ; hormis OneWire et DallasTemperature, tu n'as aucune bibliothèque supplémentaire à installer. Les réglages sont enregistrés en mémoire flash avec Preferences, donc la consigne est conservée au redémarrage de l'ESP32. Si le Wi-Fi n'est pas connecté au bout de 15 secondes, le code cesse d'attendre et le thermostat continue de fonctionner : la connexion réseau ne doit jamais bloquer la régulation du chauffage. Si c'est ta première fois avec l'ESP32, suis d'abord les étapes d'installation de l'article Qu'est-ce que l'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}

Avant de téléverser le code, remplace WIFI_SSID et WIFI_PASS par ceux de ton réseau. Quand tu saisis dans le navigateur l'adresse IP affichée dans le moniteur série (115200 bauds), tu vois la température, l'état du chauffage et les deux champs de réglage. En appuyant sur Kaydet (Enregistrer), le formulaire est envoyé à l'adresse /set, les valeurs passent le contrôle des limites et sont sauvegardées, puis la page revient à l'accueil. L'adresse /json fournit les mesures dans un format lisible par les machines ; tu peux l'utiliser avec Home Assistant ou ta propre application. Les GPIO de l'ESP32 fonctionnant en 3,3 V, alimente le module relais par la broche VIN (5 V) ; la plupart des modules à optocoupleur se déclenchent sans problème avec un signal 3,3 V, et si ce n'est pas le cas, ajoute un transistor NPN. Pour une interface mise à jour en direct, jette un œil à Serveur web ESP32 et WebSocket, et pour recevoir des notifications sur ton téléphone, à Bot Telegram avec l'ESP32.

Thermostat MicroPython avec le Raspberry Pi Pico

Le firmware MicroPython du Pico inclut déjà les modules onewire et ds18x20, sans fichier supplémentaire à copier. Le court programme ci-dessous applique la même logique d'hystérésis et de sécurité ; si le capteur est introuvable ou si la lecture échoue, il coupe le relais et continue de rechercher le capteur. Tu peux modifier la consigne et l'hystérésis dans les constantes au début du code. Si tu découvres le Pico, l'article Qu'est-ce que le Raspberry Pi Pico explique pas à pas l'installation de 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)

Idées de projets avec un thermostat Arduino

  • Couveuse : couvaison d'œufs avec une consigne de 37,5 °C et une hystérésis de 0,3 °C ; ajoute un capteur pour surveiller l'humidité.
  • Chauffage d'aquarium : garde l'eau à 25 °C avec un DS18B20 étanche.
  • Serre intelligente : réunis chauffage, ventilation et arrosage sur une seule carte ; pour des idées, vois le projet de serre intelligente.
  • Thermostat de refroidissement : inverse la logique pour lancer un ventilateur quand la température monte ; détails dans Commande de ventilateur avec Arduino.
  • Protection antigel : allume un câble chauffant à 3 °C pour éviter que les tuyaux ne gèlent ; voir l'alarme de gel.
  • Armoire de fermentation : thermostat bidirectionnel qui chauffe et refroidit avec un Peltier ; l'article Module Peltier est un bon point de départ.

Erreurs fréquentes et solutions

SymptômeCause probableSolution
HATA à l'écran, lecture −127 °CPas de pull-up, fil DATA mal serré ou mauvaise brochePlace la résistance 4,7 kΩ entre DATA et VDD, vérifie les couleurs des fils
Lecture constante de 85 °CLecture avant la fin de la mesure ou alimentation insuffisanteAttends au moins 750 ms pour la conversion, alimente le capteur en mode normal et non parasite
Le chauffage fonctionne à l'enversModule relais actif à l'état HAUTÉchange les constantes RELAY_ON et RELAY_OFF
Le relais cliquette sans arrêtHystérésis trop étroite ou câble du capteur parasitéÉlargis la bande, éloigne le câble du capteur des câbles de puissance
L'Arduino se réinitialise quand le relais colleLe courant de la bobine et du chauffage fait chuter l'alimentationUtilise un adaptateur séparé pour le chauffage, relie correctement les GND
Le LCD est allumé mais sans texteMauvaise adresse I2C ou contraste mal régléTrouve l'adresse avec un scanner I2C, tourne le potentiomètre à l'arrière
La température dépasse nettement la consigneLa chaleur continue de se diffuser après l'arrêt du chauffageÉloigne le capteur du chauffage, réduis l'hystérésis ou utilise un PID
Avant de brancher ton thermostat à un vrai chauffage, teste-le avec une LED : à la place du relais, relie l'anode d'une LED au 5V via 220 Ω et sa cathode à D7. Avec la logique active LOW, la LED s'allume au moment où le chauffage serait allumé. Réchauffe le capteur dans ta main puis plonge-le dans un verre d'eau froide ; si la LED s'allume et s'éteint aux bons seuils, le logiciel est prêt. Pour voir pas à pas comment brancher le relais, consulte Qu'est-ce qu'un module relais, et pour les problèmes d'écran, Écran LCD I2C.

Tu disposes désormais d'un thermostat qui transforme la valeur lue sur le capteur en action réelle, avec hystérésis, menu et sécurités ; la même structure peut s'adapter avec de petites modifications à la régulation du refroidissement, de l'humidité ou du niveau d'eau. Dans l'application BlueGrays, tu peux continuer à améliorer ton thermostat en explorant pas à pas, avec schémas et codes prêts à l'emploi, des projets comme la mesure de température et d'humidité avec le DHT11, un thermomètre avec NTC et LCD, la commande d'une ampoule 220 V par relais ou un serveur web ESP32.

Questions fréquentes

Quelle hystérésis choisir pour un thermostat ?

Cela dépend de la vitesse à laquelle le milieu chauffe et refroidit. Pour de petits volumes sensibles comme une couveuse, 0,3 à 0,5 °C est un bon départ ; pour une pièce ou un grand bac d'eau, 1 à 2 °C. Si le relais commute trop souvent, élargis la bande ; si la température dérive trop, réduis-la.

Pourquoi mon DS18B20 affiche −127 °C ?

−127 °C est la valeur d'erreur indiquant que la bibliothèque ne parvient pas à communiquer avec le capteur (DEVICE_DISCONNECTED_C). Les causes les plus courantes sont l'absence de résistance pull-up de 4,7 kΩ, un fil DATA mal connecté ou un mauvais numéro de broche dans le code. Le code du thermostat de cet article coupe le chauffage par sécurité quand il voit cette valeur.

Peut-on commander un chauffage 220 V avec Arduino ?

Techniquement oui : un module relais ou un SSR peut commuter une charge reliée au secteur avec le signal basse tension de l'Arduino. Mais le 230 V est un danger mortel ; les connexions doivent être faites dans un boîtier isolé, avec un fusible et sous la surveillance d'une personne expérimentée. Pour les chauffages de forte puissance, le module relais ne doit pas piloter la charge directement mais passer par un contacteur.

Faut-il utiliser un relais ou un SSR pour un thermostat ?

Pour un thermostat tout ou rien qui commute quelques fois par heure, un relais mécanique est économique et suffisant. Si tu as besoin de commutations très fréquentes, d'un fonctionnement silencieux ou d'une régulation proportionnelle dans le temps avec PID, le relais statique (SSR) convient mieux ; mais il chauffe et demande un dissipateur. Pour les chauffages 12 V DC, un MOSFET logique est la solution la plus simple.

Les réglages du thermostat Arduino sont-ils perdus en cas de coupure de courant ?

Les variables étant stockées en RAM, elles sont normalement perdues. Le code de cet article écrit la consigne et l'hystérésis en EEPROM et les relit au démarrage ; la version ESP32 fait la même chose en mémoire flash avec la bibliothèque Preferences. Ainsi, au retour du courant, le thermostat reprend avec les derniers réglages.

Peut-on faire un thermostat avec un DHT11 ?

C'est possible, mais la précision de ±2 °C et la résolution de 1 °C du DHT11 sont insuffisantes pour un thermostat précis. Le DS18B20 offre ±0,5 °C de précision et 0,0625 °C de résolution, avec en plus une version étanche. Si tu dois aussi contrôler l'humidité, un DHT22 ou un AHT20 est un meilleur compromis.

Voir tous les projets
Température et humidité avec DHT11
AR-55Intermédiaire

Température et humidité avec DHT11

Quelle température fait-il dans ta chambre, et l'air est-il humide ou sec ? Le capteur DHT11 mesure la température et l'humidité, et l'Arduino affiche les valeurs sur un écran LCD à deux lignes…

4.7(47)
83
Mesure de la température avec NTC et écran LCD 2x16
AR-44Débutant
Premium

Mesure de la température avec NTC et écran LCD 2x16

Mesure la température ambiante avec un capteur qui ressemble à une petite perle.

4.5(33)
44
Utilisation de l'écran LCD avec I2C
AR-32Débutant
Premium

Utilisation de l'écran LCD avec I2C

Offre un écran à ton Arduino et fais-lui écrire son premier message. L'écran LCD à deux lignes se branche avec seulement quelques fils ; un bonjour s'affiche sur la ligne du haut, puis un deuxième…

4.8(53)
70
Ampoule 220V avec bouton poussoir (Push)
AR-19Avancé
Premium

Ampoule 220V avec bouton poussoir (Push)

Tant que tu appuies sur le bouton, une vraie ampoule de 220 volts reste allumée, et elle s'éteint dès que tu relâches.

4.4(30)
38
Allumer et éteindre une ampoule 220 V avec un bouton
AR-20Avancé
Premium

Allumer et éteindre une ampoule 220 V avec un bouton

Envie d'allumer et d'éteindre une vraie ampoule de la maison avec un petit bouton ? À chaque appui, l'Arduino bascule un relais et l'ampoule s'allume ; un nouvel appui l'éteint.

4.5(33)
44
ESP32 DHT22 Température et humidité (avec écran LCD)
ES-15Intermédiaire

ESP32 DHT22 Température et humidité (avec écran LCD)

Il s'agit d'un projet permettant de mesurer la température ambiante et le taux d'humidité à l'aide d'un capteur DHT22 et d'afficher ces données en temps réel sur un écran LCD I2C 16x2. Les données du capteur sont lues à l'aide du protocole one-wire grâce à la bibliothèque Adafruit DHT. Ce projet constitue la base des stations météo IoT, de la domotique ou des systèmes de surveillance de l'environnement dans les serres.

4.8(38)
57
Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
ES-27Avancé

Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)

On transforme l'ESP32 en serveur web asynchrone que tu pilotes depuis ton téléphone ou ton ordinateur sur le même réseau Wi-Fi. Grâce à la bibliothèque ESPAsyncWebServer, le serveur traite plusieurs requêtes à la fois (il ne bloque pas sur une seule requête comme le WebServer.h classique). Ouvre l'adresse IP de l'ESP32 dans le navigateur et allume ou éteins la LED sur GPIO 5 avec les boutons ON/OFF (adresses /on et /off).

4.8(16)
26
Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avancé
Premium

Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Construis avec l'ESP32 un enregistreur de température et d'humidité horodaté ! Un capteur DHT22 mesure la température et l'humidité une fois par minute, et chaque mesure est enregistrée sur une carte microSD au format CSV avec l'heure réelle du module RTC DS1307. L'écran OLED affiche en direct, en grands caractères, la dernière température, l'humidité, l'horodatage et le nombre d'enregistrements.

4.7(7)
12