Guías · 12 min de lectura

Termostato con Arduino: DS18B20, relé, histéresis y LCD

¿Cómo hacer un termostato con Arduino? Medición con DS18B20, control de calefactor con relé, histéresis, ajuste con botones, menú LCD I2C y web con ESP32.

Un termostato con Arduino es un controlador que puedes construir tú mismo: mide de forma continua la temperatura de un ambiente o un objeto y enciende y apaga automáticamente un calefactor (o un enfriador). En esta guía montarás un termostato completo con el sensor digital DS18B20, un módulo de relé, tres botones y una pantalla LCD I2C de 16x2: ajustarás la temperatura objetivo con los botones, cambiarás la banda de histéresis desde el menú y guardarás los ajustes en la EEPROM para que no se pierdan al cortarse la luz. Esta misma lógica está en el corazón de proyectos como una incubadora, un acuario, un invernadero, un armario de fermentación o una cabina para impresora 3D.

En la segunda mitad del artículo llevarás el mismo termostato al ESP32 para ajustar el valor objetivo desde el navegador del móvil, y verás también la versión en MicroPython para la Raspberry Pi Pico. Como el control del calefactor es la parte más arriesgada, montamos los ejemplos con un calefactor de baja tensión de 12 V. Si quieres trabajar con la tensión de red (230 V), en una sección aparte te explicamos a qué debes prestar atención.

Sensor digital de temperatura DS18B20
DS18B20: entrega la temperatura con una resolución de 0,0625 °C por una única línea de datos (1-Wire); es la parte de medición del termostato.

¿Qué es un termostato y cómo funciona?

Un termostato consta de tres partes: medición (el sensor), decisión (el microcontrolador) y acción (el relé y el calefactor). Arduino lee la temperatura cada segundo y la compara con el valor objetivo que hayas fijado. Si la temperatura baja del objetivo, activa el relé y da corriente al calefactor; cuando se alcanza el objetivo, suelta el relé. Este método se llama control todo o nada (on-off) y es el más habitual, desde los termostatos de calefacción doméstica hasta los frigoríficos. El calefactor funciona a plena potencia o está apagado, sin niveles intermedios. Si quieres un control más preciso, más adelante puedes pasar al artículo de control PID; pero para la mayoría de proyectos caseros, un termostato todo o nada bien ajustado es más que suficiente.

MaterialFunciónNota
Arduino Uno (o Nano)Medición, decisión y menúTambién sirven ESP32 y Pico
Sensor DS18B20Medir la temperaturaSe recomienda la versión sumergible con cable
Resistencia de 4,7 kΩPull-up para la línea 1-WireSin ella el sensor devuelve −127 °C
Módulo de relé de 1 canal y 5 VEncender y apagar el calefactorElige uno con optoacoplador y diodo
LCD I2C 16x2Muestra temperatura, objetivo y estadoLa dirección suele ser 0x27 o 0x3F
3 pulsadoresSubir, bajar y menúCon pull-up interno, no hace falta resistencia
Calefactor de 12 V y adaptador de 12 VEjemplo de calefacción de baja tensiónPor ejemplo, una manta calefactora de 12 V y 10 W

¿Qué es la histéresis y por qué es imprescindible en un termostato?

Si programas el termostato solo como «si la temperatura está por debajo de 22 °C, enciende; si está por encima, apaga», cuando la temperatura ronde justo los 22 °C hasta la fluctuación más pequeña del sensor hará que el relé conmute varias veces por segundo. El relé traquetea, sus contactos se desgastan con las chispas y el calefactor se fuerza sin necesidad. La solución es la histéresis: usas dos umbrales distintos, uno para encender y otro para apagar. En este proyecto repartimos la banda de histéresis a partes iguales a ambos lados del objetivo; si el objetivo es 22 °C y la histéresis 1 °C, el calefactor se enciende a 21,5 °C y se apaga a 22,5 °C. En la zona intermedia, el relé mantiene su último estado. La fórmula es sencilla: umbral de encendido = objetivo − H/2, umbral de apagado = objetivo + H/2.

Temperatura medidaEstado previo del calefactorEstado nuevoExplicación
21,3 °CApagadoEncendidoPor debajo del umbral de encendido (21,5 °C)
21,9 °CEncendidoEncendidoDentro de la banda, se mantiene el estado
22,6 °CEncendidoApagadoPor encima del umbral de apagado (22,5 °C)
22,1 °CApagadoApagadoDentro de la banda, sigue enfriándose
−127 °C o 85 °CCualquieraApagadoFallo del sensor, pasa al estado seguro
Al elegir la histéresis, piensa en la inercia térmica del entorno. En una incubadora pequeña bastan 0,3–0,5 °C; en una habitación o un depósito de agua grande tiene más sentido 1–2 °C. Si la banda es demasiado estrecha, el relé trabaja con demasiada frecuencia; si es demasiado ancha, la temperatura se desvía mucho del objetivo. Incluso después de apagarse el calefactor, el calor acumulado hace que la temperatura siga subiendo un rato (sobreoscilación u overshoot); obsérvalo y ajusta la banda en consecuencia.

¿Por qué el DS18B20 es una buena elección?

El DS18B20 envía la temperatura directamente en formato digital; a diferencia de los sensores analógicos, la longitud del cable o las variaciones de la tensión de alimentación no estropean la lectura. Ofrece una precisión de ±0,5 °C entre −10 y +85 °C y una resolución de 0,0625 °C a 12 bits. La versión sumergible con funda de acero inoxidable se puede meter directamente en un acuario, en la tierra o en un depósito de agua. Como se pueden conectar varios sensores a un solo pin de datos, más adelante podrás medir la temperatura interior y la exterior por la misma línea. Para más detalles consulta el artículo del sensor de temperatura DS18B20, y para compararlo con otras opciones, la comparativa de sensores de temperatura.

CaracterísticaValor
Rango de medición−55 °C a +125 °C
Precisión±0,5 °C (entre −10 y +85 °C)
Resolución9–12 bits (0,5 °C – 0,0625 °C)
Tiempo de conversiónMáximo 750 ms a 12 bits
Alimentación3,0–5,5 V
Comunicación1-Wire (una línea de datos, pull-up de 4,7 kΩ)
Colores del cableRojo VDD, negro GND, amarillo o blanco DATA

Esquema de conexión del termostato con Arduino

ConexiónArduino UnoESP32Raspberry Pi Pico
DS18B20 DATA (amarillo)D2GPIO 4GP16
DS18B20 VDD (rojo)5V3V33V3(OUT)
DS18B20 GND (negro)GNDGNDGND
Pull-up de 4,7 kΩEntre DATA y 5VEntre DATA y 3V3Entre DATA y 3V3
Relé IND7GPIO 26GP15
Relé VCC / GND5V / GNDVIN (5 V) / GNDVBUS (5 V) / GND
Botones (subir, bajar, menú)D3, D4, D5 (el otro extremo a GND)Interfaz webFijo en el código
LCD I2C SDA / SCLA4 / A5GPIO 21 / 22 (opcional)GP4 / GP5 (opcional)
Los dos errores más frecuentes: olvidar la resistencia pull-up de 4,7 kΩ (el sensor devuelve −127 °C) y no saber que el relé es activo en LOW. La mayoría de los módulos de relé del mercado se activan cuando el pin IN está en LOW; por eso en el código RELAY_ON = LOW. Si tu módulo se activa con HIGH, intercambia estas dos constantes; de lo contrario el termostato hará justo lo contrario y mantendrá el calefactor siempre encendido.
Módulo de relé de 5 V
Módulo de relé: con la señal de Arduino activa su bobina y abre y cierra con un contacto mecánico el circuito del calefactor.

Controlar el calefactor con seguridad: ejemplo de baja tensión de 12 V

Para aprender no necesitas trabajar con la tensión de red. Una manta calefactora de silicona de 12 V, una resistencia de potencia o un pequeño calefactor PTC te permiten probar la misma lógica del termostato sin peligro. Por ejemplo, un calefactor de 12 V y 10 W consume unos 0,83 A según I = P / V y su resistencia es R = V² / P = 14,4 Ω (puedes comprobarlo tú mismo con la calculadora de la ley de Ohm). La conexión es así: el positivo del adaptador de 12 V va al contacto COM del relé, el contacto NO (normalmente abierto) del relé va a un extremo del calefactor, y el otro extremo del calefactor va al negativo del adaptador. Usar NO es importante: si Arduino se apaga o se corta un cable, el relé se suelta y el calefactor se apaga solo. En lugar de un relé también puedes usar un MOSFET de nivel lógico (por ejemplo, el IRLZ44N); es silencioso y no se desgasta, y tienes los detalles en el artículo Uso de MOSFET con Arduino.

  • Coloca el sensor en el sitio correcto: si el sensor está pegado al calefactor, el termostato medirá el calefactor y no el ambiente, y lo apagará demasiado pronto; ponlo en el centro del entorno que quieres controlar.
  • Límite de seguridad por software: en el código, por encima de MAX_SAFE (40 °C) el calefactor se apaga sin importar el objetivo; ajusta este valor a tu aplicación.
  • Apaga ante un fallo del sensor: cuando se corta el cable, el DS18B20 devuelve −127 °C; el termostato no debe interpretarlo como «muchísimo frío» y encender el calefactor a tope. En ese caso el código suelta el relé.
  • Protección de respaldo por hardware: el software puede colgarse. En un calefactor serio usa un fusible térmico en serie (por ejemplo, de 70 °C) o un termostato bimetálico.
  • Cuidado con la corriente de contacto: el «10 A» impreso en el módulo es para condiciones ideales; con carga continua no superes la mitad de ese valor.
  • Alimentación aparte: la corriente del calefactor nunca debe pasar por el pin 5V de Arduino; usa un adaptador propio para el calefactor. Para la alimentación te ayudará el artículo Alimentación de Arduino.
La tensión de red de 230 V es mortal. Si quieres controlar un calefactor conectado a la red, monta el circuito bajo la supervisión de un adulto o de un electricista con experiencia, mete todas las conexiones de 230 V en una caja cerrada y aislada, no dejes extremos al aire y protege el circuito con un fusible. Un calefactor de 2000 W consume unos 8,7 A a 230 V; es demasiado para un módulo de relé barato. Con cargas de esta potencia, el módulo de relé solo debe accionar un contactor, o bien hay que usar un relé de estado sólido (SSR) con un disipador adecuado.

Montaje paso a paso

  1. En el IDE de Arduino, instala desde el Gestor de bibliotecas OneWire, DallasTemperature (Miles Burton) y LiquidCrystal I2C (Frank de Brabander).
  2. Conecta el DS18B20 a D2 y coloca la resistencia de 4,7 kΩ entre DATA y 5V.
  3. Conecta el pin IN del módulo de relé a D7, y los pines VCC y GND a los pines 5V y GND de Arduino.
  4. Conecta un extremo de los botones a D3, D4 y D5, y el otro a GND; como en el código el pull-up interno está activado, no hace falta resistencia.
  5. Conecta la LCD I2C como SDA → A4, SCL → A5. Si no aparece texto en la pantalla, prueba la dirección 0x3F en lugar de 0x27 o gira el potenciómetro de contraste de la parte trasera.
  6. Conecta el calefactor de 12 V al adaptador a través de los contactos COM y NO del relé, pero antes prueba el código sin el calefactor conectado.
  7. Sube el código y, calentando y enfriando el sensor con la mano, comprueba que el relé reacciona correctamente en los umbrales.
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}

¿Cómo funciona el código y cómo se usa el menú de la LCD?

SecciónQué hace
setWaitForConversion(false)No obliga a Arduino a esperar 750 ms mientras el sensor mide; los botones y la pantalla siguen fluidos.
Bloque de 1 segundo dentro de loop()Lee la medición anterior, inicia la nueva, toma la decisión de control y actualiza la pantalla.
control()Apaga el calefactor ante un fallo del sensor o una temperatura excesiva; en caso contrario decide según los umbrales de histéresis.
setHeater()Cambia el estado del relé; deja al menos 10 segundos entre conmutaciones, salvo el apagado de seguridad.
pressed()Lee los botones con un antirrebote de 50 ms basado en millis() y detecta solo el momento de la pulsación.
handleButtons()El botón de menú alterna entre objetivo e histéresis; subir y bajar cambian el valor seleccionado y lo mantienen dentro de los límites.
EEPROM.put / getEscribe los ajustes en la memoria permanente; si el valor leído al arrancar no tiene sentido, se usan los valores por defecto.

En la línea superior de la pantalla aparecen la temperatura actual y el estado del calefactor (ISIT o BEKLE), y en la inferior los valores de objetivo (H) e histéresis (d). La flecha delante del valor indica cuál estás editando. Cada vez que pulsas el botón de menú, el cursor alterna entre objetivo e histéresis; los botones de subir y bajar cambian el objetivo en pasos de 0,5 °C y la histéresis en pasos de 0,1 °C. El objetivo está limitado a 5–35 °C y la histéresis a 0,2–5 °C. Cada cambio se escribe en la EEPROM; como EEPROM.put solo actualiza los bytes que cambian y las celdas de la EEPROM aguantan unas 100.000 escrituras, los ajustes hechos con los botones no suponen ningún problema. Por qué es importante usar millis() en vez de delay() lo encontrarás en el artículo millis y delay, y el guardado permanente en EEPROM de Arduino. El tiempo mínimo de conmutación también es un detalle importante: aunque elijas una histéresis muy estrecha, el relé no cambiará de posición más de una vez cada 10 segundos. Si vas a controlar un enfriador con compresor, sube este tiempo a 3–5 minutos.

Termostato ajustable desde la web con ESP32

Gracias al Wi-Fi integrado del ESP32, puedes ajustar la temperatura objetivo y la histéresis desde el navegador del móvil, sin necesidad de botones. El código siguiente usa las bibliotecas integradas WebServer y Preferences, que compilan sin cambios con el core de Arduino para ESP32 2.x y 3.x; aparte de OneWire y DallasTemperature, no necesitas instalar ninguna biblioteca más. Los ajustes se guardan en la memoria flash con Preferences, así que el valor objetivo se conserva cuando el ESP32 se reinicia. Si no se logra conectar al Wi-Fi en 15 segundos, el código deja de esperar y el termostato sigue funcionando igualmente; la conexión de red nunca debe impedir el control de la calefacción. Si usas el ESP32 por primera vez, sigue antes los pasos de instalación del artículo Qué es el 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}

Antes de subir el código, cambia WIFI_SSID y WIFI_PASS por los de tu red. Cuando escribas en el navegador la dirección IP que aparece en el monitor serie (115200 baudios), verás la temperatura, el estado del calefactor y dos casillas de ajuste. Al pulsar Kaydet, el formulario se envía a la dirección /set, los valores pasan por la comprobación de límites, se guardan y la página vuelve a la pantalla principal. La dirección /json entrega las mediciones en un formato legible por máquinas; puedes usarlo con Home Assistant o con tu propia aplicación. Como los GPIO del ESP32 son de 3,3 V, alimenta el módulo de relé desde el pin VIN (5 V); la mayoría de los módulos con optoacoplador se activan sin problema con una señal de 3,3 V, y si no se activa, añade un transistor NPN en medio. Si quieres una interfaz con actualización en vivo, mira Servidor web y WebSocket con ESP32, y para enviar notificaciones al móvil, Bot de Telegram con ESP32.

Termostato con MicroPython en la Raspberry Pi Pico

El firmware MicroPython de la Pico trae listos los módulos onewire y ds18x20, así que no necesitas copiar ningún archivo adicional. El breve programa siguiente aplica la misma lógica de histéresis y seguridad; si no encuentra el sensor o hay un error de lectura, apaga el relé y sigue buscando el sensor. Puedes cambiar los valores de objetivo e histéresis en las constantes del principio del código. Si es tu primer contacto con la Pico, el artículo Qué es la Raspberry Pi Pico explica paso a paso la instalación 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)

Ideas de proyectos con un termostato Arduino

  • Incubadora: incubación de huevos con un objetivo de 37,5 °C y una histéresis de 0,3 °C; añade otro sensor para vigilar la humedad.
  • Control de calefactor de acuario: mantén el agua estable a 25 °C con un DS18B20 sumergible.
  • Invernadero inteligente: reúne calefacción, ventilación y riego en una sola placa; para ideas, mira el artículo proyecto de invernadero inteligente.
  • Termostato de refrigeración: invierte la lógica y pon en marcha un ventilador cuando suba la temperatura; los detalles están en Control de ventilador con Arduino.
  • Protección contra heladas: enciende un cable calefactor a 3 °C para evitar que se congelen las tuberías; consulta la alarma de helada.
  • Armario de fermentación: un termostato bidireccional que calienta y enfría con un Peltier; el artículo del módulo Peltier es un buen punto de partida.

Errores frecuentes y cómo solucionarlos

SíntomaCausa probableSolución
La pantalla muestra HATA, lectura de −127 °CFalta el pull-up, cable DATA flojo o pin equivocadoPon la resistencia de 4,7 kΩ entre DATA y VDD y revisa los colores de los cables
Lee siempre 85 °CSe lee antes de terminar la medición o la alimentación es insuficienteEspera al menos 750 ms para la conversión y alimenta el sensor en modo normal, no parásito
El calefactor funciona al revésEl módulo de relé es activo en HIGHIntercambia las constantes RELAY_ON y RELAY_OFF
El relé traquetea sin pararHistéresis demasiado estrecha o cable del sensor con interferenciasAmplía la banda y aleja el cable del sensor de los cables de potencia
Arduino se reinicia cuando se activa el reléLa corriente de la bobina y del calefactor hunde la alimentaciónUsa un adaptador aparte para el calefactor y conecta bien las masas
La LCD se enciende pero no muestra textoDirección I2C incorrecta o ajuste de contrasteEncuentra la dirección con un escáner I2C y gira el potenciómetro trasero
La temperatura supera el objetivo y sube demasiadoTras apagarse el calefactor, el calor sigue propagándoseAleja el sensor del calefactor, reduce la histéresis o usa PID
Antes de conectar tu termostato a un calefactor real, pruébalo con un LED: en lugar del relé, conecta el ánodo de un LED a 5V a través de 220 Ω y el cátodo a D7. Así, con la lógica activa en LOW, el LED se enciende justo cuando el calefactor se encendería. Calienta el sensor en la palma de la mano y sumérgelo en un vaso de agua fría; si el LED se enciende y se apaga en los umbrales correctos, el software está listo. Para ver paso a paso cómo se conecta el relé, consulta Qué es un módulo de relé, y para problemas con la pantalla, Pantalla LCD I2C.

Ya tienes un termostato con histéresis, menú y medidas de seguridad que convierte el valor leído del sensor en una acción real; con pequeños cambios, la misma estructura sirve también para controlar refrigeración, humedad o nivel de agua. En la aplicación BlueGrays puedes seguir mejorando tu termostato revisando, con esquema de conexión y código listo, proyectos como la medición de temperatura y humedad con DHT11, un termómetro con NTC y LCD, el control de una bombilla de 220 V con relé y un servidor web con ESP32.

Preguntas frecuentes

¿Cuántos grados debe tener la histéresis de un termostato?

Depende de lo rápido que se calienta y se enfría el entorno. En volúmenes pequeños y delicados, como una incubadora, 0,3–0,5 °C es un buen punto de partida; en volúmenes grandes, como una habitación o un depósito de agua, 1–2 °C. Si el relé trabaja con demasiada frecuencia, amplía la banda; si la temperatura se desvía mucho, redúcela.

¿Por qué el DS18B20 marca −127 grados?

−127 °C es el valor de error con el que la biblioteca indica que no puede comunicarse con el sensor (DEVICE_DISCONNECTED_C). Las causas más comunes son la falta de la resistencia pull-up de 4,7 kΩ, un cable DATA flojo o un número de pin equivocado en el código. El código del termostato de este artículo apaga el calefactor por seguridad cuando ve este valor.

¿Se puede controlar un calefactor de 220 V con Arduino?

Técnicamente sí; un módulo de relé o un SSR puede conmutar una carga conectada a la red con la señal de baja tensión de Arduino. Pero 230 V supone un peligro de muerte; las conexiones deben hacerse en una caja aislada, con fusible y bajo la supervisión de alguien con experiencia. Con calefactores de mucha potencia, el módulo de relé no debe conmutar la carga directamente, sino a través de un contactor.

¿Debo usar un relé o un SSR para el termostato?

Para un termostato todo o nada que conmuta unas pocas veces por hora, un relé mecánico es barato y suficiente. Si necesitas conmutar muy a menudo, un funcionamiento silencioso o un control proporcional en el tiempo con PID, un relé de estado sólido (SSR) es más adecuado; eso sí, el SSR se calienta y necesita disipador. Para calefactores de 12 V de corriente continua, un MOSFET de nivel lógico es la solución más sencilla.

¿Se borran los ajustes del termostato Arduino al cortarse la luz?

Como las variables se guardan en la RAM, normalmente se borran. El código de este artículo escribe el objetivo y la histéresis en la EEPROM y los vuelve a leer al arrancar; la versión ESP32 hace lo mismo en la memoria flash con la biblioteca Preferences. Así, cuando vuelve la luz, el termostato sigue funcionando con el último ajuste.

¿Se puede hacer un termostato con un DHT11?

Se puede, pero la precisión de ±2 °C y la resolución de 1 °C del DHT11 no bastan para un termostato preciso. El DS18B20 ofrece una precisión de ±0,5 °C y una resolución de 0,0625 °C, y además existe en versión sumergible. Si también necesitas controlar la humedad, un DHT22 o un AHT20 es un compromiso mejor.

Ver todos los proyectos
Temperatura y humedad con DHT11
AR-55Intermedio

Temperatura y humedad con DHT11

¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

4.7(47)
83
Medición de temperatura con NTC y pantalla LCD 2x16
AR-44Principiante
Premium

Medición de temperatura con NTC y pantalla LCD 2x16

Mide la temperatura del ambiente con un sensor que parece una pequeña cuenta. Esta pieza, llamada NTC, deja pasar la electricidad con más facilidad cuanto más se calienta; el Arduino lee ese cambio…

4.5(33)
44
Uso de la pantalla LCD con I2C
AR-32Principiante
Premium

Uso de la pantalla LCD con I2C

Dale a tu Arduino su propia pantalla y haz que escriba su primer mensaje. La pantalla LCD de dos líneas se conecta con solo unos pocos cables; primero aparece un saludo en la línea de arriba, luego…

4.8(53)
70
Bombilla 220V con Pulsador (Push)
AR-19Avanzado
Premium

Bombilla 220V con Pulsador (Push)

Mientras mantienes pulsado el botón, una bombilla real de 220 voltios se queda encendida, y se apaga en cuanto lo sueltas.

4.4(30)
38
Encender y apagar una bombilla de 220 V con un botón
AR-20Avanzado
Premium

Encender y apagar una bombilla de 220 V con un botón

¿Quieres encender y apagar una bombilla de verdad de casa con un pequeño botón? Cada vez que lo pulsas, el Arduino acciona un relé y la bombilla se enciende; si vuelves a pulsar, se apaga.

4.5(33)
44
ESP32 DHT22 Temperatura y humedad (con pantalla LCD)
ES-15Intermedio

ESP32 DHT22 Temperatura y humedad (con pantalla LCD)

Se trata de un proyecto que mide la temperatura y la humedad ambientales mediante el sensor DHT22 y las muestra en tiempo real en una pantalla LCD I2C 16x2. Los datos del sensor se leen mediante el protocolo de un solo cable (one-wire) utilizando la biblioteca DHT de Adafruit. Este proyecto constituye la base para estaciones meteorológicas IoT, sistemas de automatización doméstica inteligente o sistemas de monitorización ambiental en invernaderos.

4.8(38)
57
Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
ES-27Avanzado

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)

En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

4.8(16)
26
Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzado
Premium

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.

4.7(7)
12