Termostato com Arduino: DS18B20, relé, histerese e LCD
Como fazer um termostato com Arduino? Medição de temperatura com DS18B20, controle do aquecedor com relé, histerese, ajuste da temperatura-alvo por botões, menu no LCD I2C e interface web com ESP32.
Um termostato com Arduino é um controlador que você mesmo monta: ele mede sem parar a temperatura de um ambiente ou de um objeto e liga e desliga automaticamente um aquecedor (ou um resfriador). Neste guia, você vai montar um termostato totalmente funcional com um sensor digital de temperatura DS18B20, um módulo relé, três botões e um LCD I2C 16x2. Você vai ajustar a temperatura-alvo pelos botões, mudar a faixa de histerese por um menu e salvar as configurações na EEPROM para que não se percam numa queda de energia. Essa mesma lógica está no coração de projetos como chocadeiras, aquários, estufas, câmaras de fermentação e gabinetes de impressoras 3D.
Na segunda metade do artigo, você vai levar o mesmo termostato para um ESP32 e ajustar o alvo pelo navegador do celular. Também vai ver a versão em MicroPython para o Raspberry Pi Pico. Como controlar um aquecedor é a parte mais arriscada do trabalho, nossos exemplos usam um aquecedor de baixa tensão de 12 V. Se você quiser trabalhar com tensão da rede elétrica (230 V), há uma seção separada sobre os cuidados necessários.

O que é um termostato e como ele funciona?
Um termostato tem três partes: medição (o sensor), decisão (o microcontrolador) e ação (o relé e o aquecedor). O Arduino lê a temperatura a cada segundo e compara o valor com o alvo que você definiu. Se a temperatura caiu abaixo do alvo, ele aciona o relé para alimentar o aquecedor. Quando o alvo é atingido, ele solta o relé. Esse método se chama controle liga-desliga (on-off) e é o método de controle de temperatura mais comum, dos termostatos de aquecedores domésticos às geladeiras. O aquecedor fica ou em potência total ou totalmente desligado, sem nada no meio. Se quiser um controle mais fino mais tarde, você pode passar para o artigo sobre controle PID. Mas, para a maioria dos projetos caseiros, um termostato liga-desliga bem ajustado é mais do que suficiente.
| Componente | Função | Observação |
|---|---|---|
| Arduino Uno (ou Nano) | Medição, decisão e menu | ESP32 e Pico também servem |
| Sensor DS18B20 | Medição de temperatura | Recomenda-se a versão com cabo à prova d'água |
| Resistor de 4,7 kΩ | Pull-up da linha 1-Wire | Sem ele, o sensor retorna −127 °C |
| Módulo relé de 1 canal 5 V | Ligar e desligar o aquecedor | Prefira um módulo com optoacoplador e diodo |
| LCD I2C 16x2 | Mostra temperatura, alvo e estado | O endereço costuma ser 0x27 ou 0x3F |
| 3 botões de pressão | Subir, descer e menu | Use o pull-up interno, sem resistor extra |
| Aquecedor de 12 V e fonte de 12 V | Exemplo de aquecimento em baixa tensão | Por exemplo, uma manta aquecedora de 12 V 10 W |
O que é histerese e por que o termostato precisa dela?
Se você escrever o termostato apenas como “ligar abaixo de 22 °C, desligar acima”, quando a temperatura ficar rondando exatamente os 22 °C, até a menor oscilação do sensor vai ligar e desligar o relé várias vezes por segundo. O relé fica estalando, os contatos se desgastam com as faíscas e o aquecedor é forçado à toa. A solução é a histerese: você usa dois limites separados, um para ligar e outro para desligar. Neste projeto, dividimos a faixa de histerese igualmente dos dois lados do alvo. Com alvo de 22 °C e histerese de 1 °C, o aquecedor liga em 21,5 °C e desliga em 22,5 °C. Na zona entre eles, o relé mantém o último estado. A fórmula é simples: limite de ligar = alvo − H/2, limite de desligar = alvo + H/2.
| Temperatura medida | Estado anterior do aquecedor | Novo estado | Explicação |
|---|---|---|---|
| 21,3 °C | Desligado | Ligado | Abaixo do limite de ligar (21,5 °C) |
| 21,9 °C | Ligado | Ligado | Dentro da faixa, o estado é mantido |
| 22,6 °C | Ligado | Desligado | Acima do limite de desligar (22,5 °C) |
| 22,1 °C | Desligado | Desligado | Dentro da faixa, ainda esfriando |
| −127 °C ou 85 °C | Qualquer | Desligado | Erro do sensor, ir para o estado seguro |
Por que o DS18B20 é uma boa escolha?
O DS18B20 envia a temperatura medida diretamente em forma digital. Ao contrário dos sensores analógicos, o comprimento do cabo e as oscilações da tensão de alimentação não estragam a leitura. Ele oferece precisão de ±0,5 °C entre −10 e +85 °C e resolução de 0,0625 °C em 12 bits. A versão à prova d'água, com capa de aço inox, pode ser mergulhada diretamente num aquário, no solo ou num tanque de água. Como vários sensores podem compartilhar um único pino de dados, mais tarde você pode medir a temperatura interna e a externa na mesma linha. Para detalhes, veja o artigo sensor de temperatura DS18B20 e, para comparar com outras opções, a comparação de sensores de temperatura.
| Característica | Valor |
|---|---|
| Faixa de medição | −55 °C a +125 °C |
| Precisão | ±0,5 °C (entre −10 e +85 °C) |
| Resolução | 9–12 bits (0,5 °C – 0,0625 °C) |
| Tempo de conversão | Até 750 ms em 12 bits |
| Alimentação | 3,0–5,5 V |
| Comunicação | 1-Wire (linha de dados única, pull-up de 4,7 kΩ) |
| Cores dos fios | Vermelho VDD, preto GND, amarelo ou branco DATA |
Esquema de ligação do termostato com Arduino
| Ligação | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| DS18B20 DATA (amarelo) | D2 | GPIO 4 | GP16 |
| DS18B20 VDD (vermelho) | 5V | 3V3 | 3V3(OUT) |
| DS18B20 GND (preto) | GND | GND | GND |
| Pull-up de 4,7 kΩ | Entre DATA e 5V | Entre DATA e 3V3 | Entre DATA e 3V3 |
| Relé IN | D7 | GPIO 26 | GP15 |
| Relé VCC / GND | 5V / GND | VIN (5 V) / GND | VBUS (5 V) / GND |
| Botões (subir, descer, menu) | D3, D4, D5 (a outra ponta no GND) | Interface web | Fixo no código |
| LCD I2C SDA / SCL | A4 / A5 | GPIO 21 / 22 (opcional) | GP4 / GP5 (opcional) |

Controlando o aquecedor com segurança: um exemplo em 12 V de baixa tensão
Você não precisa trabalhar com tensão da rede enquanto aprende. Uma manta aquecedora de silicone de 12 V, um resistor de potência ou um pequeno aquecedor PTC permitem testar a mesma lógica de termostato sem perigo. Por exemplo, um aquecedor de 12 V 10 W consome cerca de 0,83 A pela fórmula I = P / V e tem resistência R = V² / P = 14,4 Ω (você mesmo pode conferir com a calculadora da lei de Ohm). A ligação fica assim: o positivo da fonte de 12 V vai ao contato COM do relé, o contato NO (normalmente aberto) do relé vai a uma ponta do aquecedor, e a outra ponta do aquecedor vai ao negativo da fonte. Usar o NO é importante: se o Arduino desligar ou um fio se romper, o relé solta e o aquecedor desliga sozinho. Em vez de um relé, você também pode usar um MOSFET de nível lógico (por exemplo, o IRLZ44N). Ele é silencioso e não se desgasta; os detalhes estão no artigo Como usar MOSFET com Arduino.
- Coloque o sensor no lugar certo: se o sensor estiver encostado no aquecedor, o termostato mede o aquecedor, e não o ambiente, e desliga cedo demais. Posicione o sensor no meio do espaço que você quer controlar.
- Limite de segurança no software: no código, acima de MAX_SAFE (40 °C) o aquecedor desliga independentemente do alvo. Ajuste esse valor para a sua aplicação.
- Desligue em caso de falha do sensor: quando o cabo se rompe, o DS18B20 retorna −127 °C. O termostato não pode confundir isso com “muito frio” e ligar o aquecedor no máximo. Nesse caso, o código solta o relé.
- Proteção de reserva no hardware: o software pode travar. Num aquecedor de verdade, use um fusível térmico em série (por exemplo, de 70 °C) ou um termostato bimetálico.
- Atenção à corrente do contato: os “10 A” impressos no módulo valem para condições ideais. Para cargas contínuas, não passe da metade desse valor.
- Alimentação separada: a corrente do aquecedor nunca deve passar pelo pino 5V do Arduino. Use uma fonte própria para o aquecedor. O artigo alimentação do Arduino ajuda nos assuntos de energia.
Montagem passo a passo
- Na Arduino IDE, instale pelo Gerenciador de Bibliotecas as bibliotecas OneWire, DallasTemperature (Miles Burton) e LiquidCrystal I2C (Frank de Brabander).
- Ligue o DS18B20 ao D2 e coloque o resistor de 4,7 kΩ entre DATA e 5V.
- Ligue o pino IN do módulo relé ao D7 e os pinos VCC e GND aos pinos 5V e GND do Arduino.
- Ligue uma ponta de cada botão ao D3, D4 e D5 e a outra ponta ao GND. Como o pull-up interno é ativado no código, não é preciso resistor extra.
- Ligue o LCD I2C como SDA → A4, SCL → A5. Se não aparecer texto na tela, tente o endereço 0x3F em vez de 0x27 ou gire o potenciômetro de contraste na parte de trás.
- Ligue o aquecedor de 12 V à fonte pelos contatos COM e NO do relé, mas teste o código primeiro com o aquecedor desconectado.
- Carregue o código, aqueça e esfrie o sensor com a mão e observe se o relé reage corretamente nos limites.
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}Como o código funciona e como usar o menu do LCD?
| Parte | O que faz |
|---|---|
| setWaitForConversion(false) (leitura sem espera) | Não deixa o Arduino esperando 750 ms enquanto o sensor mede; botões e display continuam respondendo. |
| O bloco de 1 segundo dentro do loop() | Lê a medição anterior, inicia uma nova, toma a decisão de controle e atualiza o display. |
| control() (controle) | Desliga o aquecedor em caso de erro do sensor ou superaquecimento; caso contrário, decide pelos limites da histerese. |
| setHeater() (liga/desliga o aquecedor) | Muda o estado do relé; deixa pelo menos 10 segundos entre as trocas, exceto no desligamento de segurança. |
| pressed() (leitura dos botões) | Lê os botões com debounce de 50 ms baseado em millis() e captura só o momento em que o botão é pressionado. |
| handleButtons() (tratamento dos botões) | O botão de menu alterna entre alvo e histerese; os botões de subir e descer mudam o valor selecionado e o mantêm dentro dos limites. |
| EEPROM.put / get (gravar / ler) | Grava as configurações na memória não volátil; se o valor lido na inicialização não fizer sentido, usa os valores padrão. |
A linha de cima da tela mostra a temperatura atual e o estado do aquecedor (ISIT ou BEKLE, ou seja, aquecendo ou em espera), e a linha de baixo mostra os valores de alvo (H) e histerese (d). A seta na frente de um valor indica qual deles você está editando. A cada toque no botão de menu, o cursor alterna entre alvo e histerese. Os botões de subir e descer mudam o alvo em passos de 0,5 °C e a histerese em passos de 0,1 °C. O alvo fica limitado a 5–35 °C e a histerese a 0,2–5 °C. Cada mudança é gravada na EEPROM. Como o EEPROM.put atualiza só os bytes que mudaram e as células da EEPROM aguentam cerca de 100.000 gravações, os ajustes pelos botões não são problema. Você descobre por que usar millis() em vez de delay() é importante em millis e delay, e lê mais sobre armazenamento permanente em EEPROM do Arduino. O tempo mínimo de chaveamento também é um detalhe importante: mesmo que você escolha uma histerese bem estreita, o relé não muda de posição mais de uma vez a cada 10 segundos. Se for controlar uma geladeira com compressor, aumente esse tempo para 3–5 minutos.
Termostato com ESP32 ajustável pela web
Graças ao Wi-Fi integrado do ESP32, você pode ajustar a temperatura-alvo e a histerese pelo navegador do celular, sem precisar de botões. O código abaixo usa as bibliotecas integradas WebServer e Preferences, que compilam sem alterações no core do Arduino para ESP32 2.x e 3.x. Além de OneWire e DallasTemperature, você não precisa instalar nenhuma biblioteca extra. As configurações são salvas na memória flash com o Preferences, então o valor-alvo é mantido quando o ESP32 reinicia. Se não conseguir se conectar ao Wi-Fi em 15 segundos, o código para de esperar e o termostato continua funcionando mesmo assim: a conexão de rede nunca deve bloquear o controle do aquecimento. Se é a sua primeira vez com o ESP32, siga antes os passos de instalação em O que é o 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 carregar o código, mude WIFI_SSID e WIFI_PASS de acordo com a sua rede. Ao digitar no navegador o endereço IP que aparece no Monitor Serial (115200 baud), você vê a temperatura, o estado do aquecedor e as duas caixas de configuração. Ao tocar em Kaydet (Salvar), o formulário é enviado ao endereço /set, os valores passam pela verificação de limites e são salvos, e a página volta para a tela principal. O endereço /json entrega as leituras num formato que máquinas conseguem ler; você pode usá-lo com o Home Assistant ou com o seu próprio app. Como os GPIOs do ESP32 trabalham em 3,3 V, alimente o módulo relé pelo pino VIN (5 V). A maioria dos módulos com optoacoplador aciona sem problemas com um sinal de 3,3 V; se o seu não acionar, coloque um transistor NPN no meio. Se quiser uma interface que se atualiza ao vivo, veja servidor web e WebSocket com ESP32 e, para enviar notificações ao celular, bot do Telegram com ESP32.
Termostato em MicroPython com o Raspberry Pi Pico
O firmware MicroPython do Pico já vem com os módulos onewire e ds18x20 integrados, então você não precisa copiar nenhum arquivo extra. O programa curto abaixo aplica a mesma lógica de histerese e segurança: se o sensor não for encontrado ou ocorrer um erro de leitura, ele desliga o relé e continua procurando o sensor de novo. Você pode mudar o alvo e a histerese nas constantes no início do código. Se você está começando com o Pico, o artigo O que é o Raspberry Pi Pico mostra a instalação do Thonny passo a passo.
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)Ideias de projetos com termostato Arduino
- Chocadeira: incubação de ovos com alvo de 37,5 °C e histerese de 0,3 °C; adicione um sensor extra para monitorar a umidade.
- Controle do aquecedor do aquário: mantenha a água estável em 25 °C com um DS18B20 à prova d'água.
- Estufa inteligente: reúna aquecimento, ventilação e irrigação numa só placa; para ideias, veja o artigo projeto de estufa inteligente.
- Termostato de resfriamento: inverta a lógica e ligue uma ventoinha quando a temperatura subir; os detalhes estão em controle de ventoinha com Arduino.
- Proteção contra congelamento: ligue um cabo aquecedor em 3 °C para evitar que os canos congelem; veja alarme de geada.
- Câmara de fermentação: um termostato bidirecional que aquece e resfria com uma pastilha Peltier; o artigo módulo Peltier é um bom ponto de partida.
Erros comuns e como corrigir
| Sintoma | Causa provável | Solução |
|---|---|---|
| HATA (erro) na tela, leitura de −127 °C | Sem pull-up, fio DATA solto ou pino errado | Coloque o resistor de 4,7 kΩ entre DATA e VDD e confira as cores dos fios |
| Lê sempre 85 °C | Leitura antes de a conversão terminar ou alimentação insuficiente | Espere pelo menos 750 ms pela conversão e alimente o sensor no modo normal, não parasita |
| O aquecedor funciona ao contrário | O módulo relé é ativo em HIGH | Troque as constantes RELAY_ON e RELAY_OFF |
| O relé fica estalando sem parar | Histerese estreita demais ou cabo do sensor captando ruído | Aumente a faixa e afaste o cabo do sensor dos cabos de potência |
| O Arduino reinicia quando o relé aciona | A corrente da bobina e do aquecedor derruba a alimentação | Use uma fonte separada para o aquecedor e ligue os GNDs corretamente |
| O LCD acende, mas não mostra texto | Endereço I2C errado ou ajuste de contraste | Descubra o endereço com um sketch scanner I2C e gire o potenciômetro na parte de trás |
| A temperatura passa do alvo e sobe demais | O calor continua se espalhando depois que o aquecedor desliga | Afaste o sensor do aquecedor, diminua a histerese ou use PID |
Agora você tem um termostato com histerese, menu e recursos de segurança, que transforma o valor lido de um sensor numa ação real. Com pequenas mudanças, a mesma estrutura pode ser adaptada para controle de resfriamento, umidade ou nível de água. No app BlueGrays, você pode aprimorar ainda mais o seu termostato explorando projetos como medição de temperatura e umidade com DHT11, termômetro com NTC e LCD, controle de uma lâmpada de 220 V com relé e servidor web com ESP32, cada um com esquema do circuito passo a passo e código pronto.
Perguntas frequentes
Quantos graus deve ter a histerese de um termostato?
Depende da rapidez com que o ambiente esquenta e esfria. Em volumes pequenos e sensíveis, como uma chocadeira, 0,3–0,5 °C é um bom começo. Em volumes grandes, como um cômodo ou um tanque de água, 1–2 °C. Se o relé chavear com frequência demais, aumente a faixa; se a temperatura se afastar demais, diminua.
Por que o DS18B20 mostra -127 graus?
−127 °C é o valor de erro (DEVICE_DISCONNECTED_C) que indica que a biblioteca não conseguiu se comunicar com o sensor. As causas mais comuns são a falta do resistor de pull-up de 4,7 kΩ, um fio DATA solto ou o número de pino errado no código. O código do termostato deste artigo desliga o aquecedor por segurança quando vê esse valor.
Dá para controlar um aquecedor de 220V com Arduino?
Tecnicamente, sim: um módulo relé ou um SSR consegue chavear uma carga ligada à rede com o sinal de baixa tensão do Arduino. Porém, 230 V oferece risco de morte. As ligações devem ser feitas numa caixa isolada, com fusível e sob a supervisão de uma pessoa experiente. Para aquecedores de alta potência, o módulo relé deve acionar a carga por meio de um contator, e não diretamente.
Devo usar relé ou SSR num termostato?
Para um termostato liga-desliga que chaveia algumas vezes por hora, um relé mecânico é barato e suficiente. Se você precisa de chaveamento muito frequente, funcionamento silencioso ou controle proporcional ao tempo com PID, um relé de estado sólido (SSR) é mais adequado; porém, o SSR esquenta e precisa de dissipador. Para aquecedores de 12 V CC, um MOSFET de nível lógico é a solução mais fácil.
As configurações do termostato com Arduino se apagam quando falta energia?
As variáveis ficam na RAM, então normalmente se perdem. O código deste artigo grava o alvo e a histerese na EEPROM e os lê de volta na inicialização; a versão para ESP32 faz o mesmo na memória flash com a biblioteca Preferences. Assim, quando a energia volta, o termostato continua com as últimas configurações.
Dá para fazer um termostato com DHT11?
Dá, mas a precisão de ±2 °C e a resolução de 1 °C do DHT11 não são suficientes para um termostato preciso. O DS18B20 oferece precisão de ±0,5 °C e resolução de 0,0625 °C, além de ter versão à prova d'água. Se você também precisa controlar a umidade, o DHT22 ou o AHT20 são um meio-termo melhor.
Projetos para montar depois desta leitura
Ver todos os projetos
Temperatura e umidade com DHT11
Qual é a temperatura do seu quarto? O ar está úmido ou seco? O sensor DHT11 mede a temperatura e a umidade, e o Arduino mostra os valores em um display LCD de duas linhas, atualizando a cada poucos…

Medição de temperatura com NTC e display LCD 2x16
Meça a temperatura ao seu redor com um sensor que parece uma pequena conta. Esse componente, chamado NTC, deixa a eletricidade passar com mais facilidade à medida que aquece; o Arduino lê essa…

Uso do display LCD com I2C
Dê ao seu Arduino um display próprio e faça-o escrever sua primeira mensagem. O display LCD de duas linhas é conectado com poucos fios; primeiro aparece uma saudação na linha de cima, depois uma…

Acender uma lâmpada de 220V com botão de pressão
Enquanto você mantém o botão pressionado, uma lâmpada de 220 volts fica acesa e apaga assim que você solta.

Ligar e desligar uma lâmpada de 220V com botão
Quer ligar e desligar uma lâmpada de casa com um pequeno botão? Ao pressionar o botão, o Arduino aciona um relé e a lâmpada acende; ao pressionar novamente, ela apaga.

Temperatura e umidade com ESP32 e DHT22 (com display LCD)
Este projeto mede a temperatura e a umidade do ambiente com um sensor DHT22 e exibe os dados em tempo real em um LCD I2C 16x2. Os dados são lidos do sensor pelo protocolo de um fio (one-wire) com a biblioteca Adafruit DHT. Este projeto serve de base para estações meteorológicas IoT, automação residencial ou sistemas de monitoramento ambiental em estufas. A comunicação com o DHT22 é feita pelo pino GPIO 4 do ESP32.

Servidor web assíncrono com ESP32 (IP no LCD)
Neste projeto, transformamos o ESP32 em um servidor web assíncrono que você pode controlar pelo celular ou computador na mesma rede Wi-Fi. Com a biblioteca ESPAsyncWebServer, o servidor processa várias requisições ao mesmo tempo (ao contrário do WebServer.h tradicional, que bloqueia a execução ao processar uma requisição). Você poderá abrir o endereço IP do ESP32 no navegador e clicar nos botões ON/OFF (as rotas /on e /off) para ligar e desligar o LED conectado ao GPIO 5.

Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Monte um registrador de temperatura com data e hora usando ESP32. O DHT22 mede a temperatura e a umidade a cada minuto, o DS1307 RTC fornece a hora real e cada leitura é gravada em CSV no cartão microSD. O OLED mostra em letras grandes a temperatura atual, além da umidade, da data e hora e do total de registros. Abra o arquivo /temp_log.csv no Excel, no Google Sheets ou com pandas para acompanhar uma estufa ou a temperatura de casa.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

