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.

¿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.
| Material | Función | Nota |
|---|---|---|
| Arduino Uno (o Nano) | Medición, decisión y menú | También sirven ESP32 y Pico |
| Sensor DS18B20 | Medir la temperatura | Se recomienda la versión sumergible con cable |
| Resistencia de 4,7 kΩ | Pull-up para la línea 1-Wire | Sin ella el sensor devuelve −127 °C |
| Módulo de relé de 1 canal y 5 V | Encender y apagar el calefactor | Elige uno con optoacoplador y diodo |
| LCD I2C 16x2 | Muestra temperatura, objetivo y estado | La dirección suele ser 0x27 o 0x3F |
| 3 pulsadores | Subir, bajar y menú | Con pull-up interno, no hace falta resistencia |
| Calefactor de 12 V y adaptador de 12 V | Ejemplo de calefacción de baja tensión | Por 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 medida | Estado previo del calefactor | Estado nuevo | Explicación |
|---|---|---|---|
| 21,3 °C | Apagado | Encendido | Por debajo del umbral de encendido (21,5 °C) |
| 21,9 °C | Encendido | Encendido | Dentro de la banda, se mantiene el estado |
| 22,6 °C | Encendido | Apagado | Por encima del umbral de apagado (22,5 °C) |
| 22,1 °C | Apagado | Apagado | Dentro de la banda, sigue enfriándose |
| −127 °C o 85 °C | Cualquiera | Apagado | Fallo del sensor, pasa al estado seguro |
¿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ística | Valor |
|---|---|
| Rango de medición | −55 °C a +125 °C |
| Precisión | ±0,5 °C (entre −10 y +85 °C) |
| Resolución | 9–12 bits (0,5 °C – 0,0625 °C) |
| Tiempo de conversión | Máximo 750 ms a 12 bits |
| Alimentación | 3,0–5,5 V |
| Comunicación | 1-Wire (una línea de datos, pull-up de 4,7 kΩ) |
| Colores del cable | Rojo VDD, negro GND, amarillo o blanco DATA |
Esquema de conexión del termostato con Arduino
| Conexión | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| DS18B20 DATA (amarillo) | D2 | GPIO 4 | GP16 |
| DS18B20 VDD (rojo) | 5V | 3V3 | 3V3(OUT) |
| DS18B20 GND (negro) | GND | GND | GND |
| Pull-up de 4,7 kΩ | Entre DATA y 5V | Entre DATA y 3V3 | Entre DATA y 3V3 |
| Relé IN | D7 | GPIO 26 | GP15 |
| Relé VCC / GND | 5V / GND | VIN (5 V) / GND | VBUS (5 V) / GND |
| Botones (subir, bajar, menú) | D3, D4, D5 (el otro extremo a GND) | Interfaz web | Fijo en el código |
| LCD I2C SDA / SCL | A4 / A5 | GPIO 21 / 22 (opcional) | GP4 / GP5 (opcional) |

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.
Montaje paso a paso
- En el IDE de Arduino, instala desde el Gestor de bibliotecas OneWire, DallasTemperature (Miles Burton) y LiquidCrystal I2C (Frank de Brabander).
- Conecta el DS18B20 a D2 y coloca la resistencia de 4,7 kΩ entre DATA y 5V.
- 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.
- 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.
- 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.
- 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.
- Sube el código y, calentando y enfriando el sensor con la mano, comprueba que el relé reacciona correctamente en los umbrales.
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ón | Qué 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 / get | Escribe 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.
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.
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íntoma | Causa probable | Solución |
|---|---|---|
| La pantalla muestra HATA, lectura de −127 °C | Falta el pull-up, cable DATA flojo o pin equivocado | Pon la resistencia de 4,7 kΩ entre DATA y VDD y revisa los colores de los cables |
| Lee siempre 85 °C | Se lee antes de terminar la medición o la alimentación es insuficiente | Espera al menos 750 ms para la conversión y alimenta el sensor en modo normal, no parásito |
| El calefactor funciona al revés | El módulo de relé es activo en HIGH | Intercambia las constantes RELAY_ON y RELAY_OFF |
| El relé traquetea sin parar | Histéresis demasiado estrecha o cable del sensor con interferencias | Amplí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ón | Usa un adaptador aparte para el calefactor y conecta bien las masas |
| La LCD se enciende pero no muestra texto | Dirección I2C incorrecta o ajuste de contraste | Encuentra la dirección con un escáner I2C y gira el potenciómetro trasero |
| La temperatura supera el objetivo y sube demasiado | Tras apagarse el calefactor, el calor sigue propagándose | Aleja el sensor del calefactor, reduce la histéresis o usa PID |
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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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…

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…

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…

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.

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.

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.

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

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.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

