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).

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.
| Composant | Rôle | Remarque |
|---|---|---|
| Arduino Uno (ou Nano) | Mesure, décision et menu | L'ESP32 et le Pico fonctionnent aussi |
| Capteur DS18B20 | Mesure de la température | Version étanche à câble recommandée |
| Résistance 4,7 kΩ | Pull-up du bus 1-Wire | Sans elle, le capteur renvoie −127 °C |
| Module relais 5 V 1 canal | Allumer et éteindre le chauffage | Préfère un module avec optocoupleur et diode |
| LCD I2C 16x2 | Affichage température, consigne et état | Adresse généralement 0x27 ou 0x3F |
| 3 boutons poussoirs | Haut, bas et menu | Avec pull-up interne, aucune résistance nécessaire |
| Chauffage 12 V et adaptateur 12 V | Exemple de chauffage basse tension | Par 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 chauffage | Nouvel état | Explication |
|---|---|---|---|
| 21,3 °C | Éteint | Allumé | Sous le seuil d'allumage (21,5 °C) |
| 21,9 °C | Allumé | Allumé | Dans la bande, l'état est conservé |
| 22,6 °C | Allumé | Éteint | Au-dessus du seuil d'extinction (22,5 °C) |
| 22,1 °C | Éteint | Éteint | Dans la bande, le refroidissement continue |
| −127 °C ou 85 °C | Quelconque | Éteint | Défaut du capteur, passage en état sûr |
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éristique | Valeur |
|---|---|
| Plage de mesure | −55 °C à +125 °C |
| Précision | ±0,5 °C (entre −10 et +85 °C) |
| Résolution | 9 à 12 bits (0,5 °C à 0,0625 °C) |
| Temps de conversion | 750 ms maximum en 12 bits |
| Alimentation | 3,0 à 5,5 V |
| Communication | 1-Wire (un seul fil de données, pull-up 4,7 kΩ) |
| Couleurs des fils | Rouge VDD, noir GND, jaune ou blanc DATA |
Schéma de câblage du thermostat Arduino
| Connexion | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| DS18B20 DATA (jaune) | D2 | GPIO 4 | GP16 |
| DS18B20 VDD (rouge) | 5V | 3V3 | 3V3(OUT) |
| DS18B20 GND (noir) | GND | GND | GND |
| Pull-up 4,7 kΩ | Entre DATA et 5V | Entre DATA et 3V3 | Entre DATA et 3V3 |
| Relais IN | D7 | GPIO 26 | GP15 |
| Relais VCC / GND | 5V / GND | VIN (5 V) / GND | VBUS (5 V) / GND |
| Boutons (haut, bas, menu) | D3, D4, D5 (l'autre broche à GND) | Interface web | Fixé dans le code |
| LCD I2C SDA / SCL | A4 / A5 | GPIO 21 / 22 (facultatif) | GP4 / GP5 (facultatif) |

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.
Montage pas à pas
- Dans l'IDE Arduino, installe depuis le gestionnaire de bibliothèques OneWire, DallasTemperature (Miles Burton) et LiquidCrystal I2C (Frank de Brabander).
- Branche le DS18B20 sur D2 et place la résistance de 4,7 kΩ entre DATA et 5V.
- Relie la broche IN du module relais à D7, et ses broches VCC et GND au 5V et au GND de l'Arduino.
- 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.
- 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.
- Relie le chauffage 12 V à l'adaptateur via les contacts COM et NO du relais, mais teste d'abord le code sans chauffage branché.
- 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.
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 ?
| Partie | Ce 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.
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.
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ôme | Cause probable | Solution |
|---|---|---|
| HATA à l'écran, lecture −127 °C | Pas de pull-up, fil DATA mal serré ou mauvaise broche | Place la résistance 4,7 kΩ entre DATA et VDD, vérifie les couleurs des fils |
| Lecture constante de 85 °C | Lecture avant la fin de la mesure ou alimentation insuffisante | Attends au moins 750 ms pour la conversion, alimente le capteur en mode normal et non parasite |
| Le chauffage fonctionne à l'envers | Module relais actif à l'état HAUT | Échange les constantes RELAY_ON et RELAY_OFF |
| Le relais cliquette sans arrêt | Hysté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 colle | Le courant de la bobine et du chauffage fait chuter l'alimentation | Utilise un adaptateur séparé pour le chauffage, relie correctement les GND |
| Le LCD est allumé mais sans texte | Mauvaise 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 consigne | La 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 |
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.
Projets à réaliser après cet article
Voir tous les projets
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…

Mesure de la température avec NTC et écran LCD 2x16
Mesure la température ambiante avec un capteur qui ressemble à une petite perle.

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…

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.

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.

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.

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).

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.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

