Guias · 12 min de leitura

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.

Sensor digital de temperatura DS18B20
DS18B20: informa a temperatura por uma única linha de dados (1-Wire), com resolução de 0,0625 °C. É a parte de medição do termostato.

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.

ComponenteFunçãoObservação
Arduino Uno (ou Nano)Medição, decisão e menuESP32 e Pico também servem
Sensor DS18B20Medição de temperaturaRecomenda-se a versão com cabo à prova d'água
Resistor de 4,7 kΩPull-up da linha 1-WireSem ele, o sensor retorna −127 °C
Módulo relé de 1 canal 5 VLigar e desligar o aquecedorPrefira um módulo com optoacoplador e diodo
LCD I2C 16x2Mostra temperatura, alvo e estadoO endereço costuma ser 0x27 ou 0x3F
3 botões de pressãoSubir, descer e menuUse o pull-up interno, sem resistor extra
Aquecedor de 12 V e fonte de 12 VExemplo de aquecimento em baixa tensãoPor 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 medidaEstado anterior do aquecedorNovo estadoExplicação
21,3 °CDesligadoLigadoAbaixo do limite de ligar (21,5 °C)
21,9 °CLigadoLigadoDentro da faixa, o estado é mantido
22,6 °CLigadoDesligadoAcima do limite de desligar (22,5 °C)
22,1 °CDesligadoDesligadoDentro da faixa, ainda esfriando
−127 °C ou 85 °CQualquerDesligadoErro do sensor, ir para o estado seguro
Ao escolher a histerese, pense na inércia térmica do ambiente. Numa caixa pequena de chocadeira, 0,3–0,5 °C basta. Num cômodo ou num tanque grande de água, 1–2 °C faz mais sentido. Se a faixa for estreita demais, o relé chaveia com frequência. Se for larga demais, a temperatura se afasta muito do alvo. Mesmo depois que o aquecedor desliga, o calor acumulado nele faz a temperatura continuar subindo por um tempo (sobressinal, overshoot). Observe esse efeito e ajuste a faixa de acordo.

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ísticaValor
Faixa de medição−55 °C a +125 °C
Precisão±0,5 °C (entre −10 e +85 °C)
Resolução9–12 bits (0,5 °C – 0,0625 °C)
Tempo de conversãoAté 750 ms em 12 bits
Alimentação3,0–5,5 V
Comunicação1-Wire (linha de dados única, pull-up de 4,7 kΩ)
Cores dos fiosVermelho VDD, preto GND, amarelo ou branco DATA

Esquema de ligação do termostato com Arduino

LigaçãoArduino UnoESP32Raspberry Pi Pico
DS18B20 DATA (amarelo)D2GPIO 4GP16
DS18B20 VDD (vermelho)5V3V33V3(OUT)
DS18B20 GND (preto)GNDGNDGND
Pull-up de 4,7 kΩEntre DATA e 5VEntre DATA e 3V3Entre DATA e 3V3
Relé IND7GPIO 26GP15
Relé VCC / GND5V / GNDVIN (5 V) / GNDVBUS (5 V) / GND
Botões (subir, descer, menu)D3, D4, D5 (a outra ponta no GND)Interface webFixo no código
LCD I2C SDA / SCLA4 / A5GPIO 21 / 22 (opcional)GP4 / GP5 (opcional)
Os dois erros mais comuns: esquecer o resistor de pull-up de 4,7 kΩ (o sensor retorna −127 °C) e não saber que o relé é ativo em LOW. A maioria dos módulos relé do mercado aciona quando o pino IN está em LOW, por isso o código define RELAY_ON = LOW. Se o seu módulo aciona com HIGH, troque essas duas constantes. Caso contrário, o termostato faz exatamente o oposto e mantém o aquecedor ligado o tempo todo.
Módulo relé de 5 V
Módulo relé: com o sinal do Arduino, energiza a bobina e abre e fecha o circuito do aquecedor com um contato mecânico.

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.
A tensão da rede de 230 V pode matar. Se você quiser controlar um aquecedor ligado à rede elétrica, monte o circuito sob a supervisão de um adulto ou de um eletricista experiente, coloque todas as ligações de 230 V numa caixa fechada e isolada, não deixe pontas expostas e proteja o circuito com um fusível. Um aquecedor de 2000 W consome cerca de 8,7 A em 230 V, o que é demais para um módulo relé barato. Para cargas dessa potência, o módulo relé deve apenas acionar um contator, ou deve-se usar um relé de estado sólido (SSR) com dissipador adequado.

Montagem passo a passo

  1. Na Arduino IDE, instale pelo Gerenciador de Bibliotecas as bibliotecas OneWire, DallasTemperature (Miles Burton) e LiquidCrystal I2C (Frank de Brabander).
  2. Ligue o DS18B20 ao D2 e coloque o resistor de 4,7 kΩ entre DATA e 5V.
  3. Ligue o pino IN do módulo relé ao D7 e os pinos VCC e GND aos pinos 5V e GND do Arduino.
  4. 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.
  5. 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.
  6. Ligue o aquecedor de 12 V à fonte pelos contatos COM e NO do relé, mas teste o código primeiro com o aquecedor desconectado.
  7. Carregue o código, aqueça e esfrie o sensor com a mão e observe se o relé reage corretamente nos limites.
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}

Como o código funciona e como usar o menu do LCD?

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

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

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)

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

SintomaCausa provávelSolução
HATA (erro) na tela, leitura de −127 °CSem pull-up, fio DATA solto ou pino erradoColoque o resistor de 4,7 kΩ entre DATA e VDD e confira as cores dos fios
Lê sempre 85 °CLeitura antes de a conversão terminar ou alimentação insuficienteEspere pelo menos 750 ms pela conversão e alimente o sensor no modo normal, não parasita
O aquecedor funciona ao contrárioO módulo relé é ativo em HIGHTroque as constantes RELAY_ON e RELAY_OFF
O relé fica estalando sem pararHisterese estreita demais ou cabo do sensor captando ruídoAumente a faixa e afaste o cabo do sensor dos cabos de potência
O Arduino reinicia quando o relé acionaA corrente da bobina e do aquecedor derruba a alimentaçãoUse uma fonte separada para o aquecedor e ligue os GNDs corretamente
O LCD acende, mas não mostra textoEndereço I2C errado ou ajuste de contrasteDescubra 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 demaisO calor continua se espalhando depois que o aquecedor desligaAfaste o sensor do aquecedor, diminua a histerese ou use PID
Antes de ligar o termostato a um aquecedor de verdade, teste com um LED: no lugar do relé, ligue o ânodo do LED ao 5V por um resistor de 220 Ω e o cátodo ao D7. Com a lógica ativa em LOW, o LED acende justamente quando o aquecedor estaria ligado. Aqueça o sensor na palma da mão e mergulhe-o num copo de água fria. Se o LED acender e apagar nos limites certos, o software está pronto. Para ver passo a passo como um relé é ligado, veja O que é um módulo relé e, para problemas de display, o artigo display LCD I2C.

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.

Ver todos os projetos
Temperatura e umidade com DHT11
AR-55Intermediário

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…

4.7(47)
83
Medição de temperatura com NTC e display LCD 2x16
AR-44Iniciante
Premium

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…

4.5(33)
44
Uso do display LCD com I2C
AR-32Iniciante
Premium

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…

4.8(53)
70
Acender uma lâmpada de 220V com botão de pressão
AR-19Avançado
Premium

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.

4.4(30)
38
Ligar e desligar uma lâmpada de 220V com botão
AR-20Avançado
Premium

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.

4.5(33)
44
Temperatura e umidade com ESP32 e DHT22 (com display LCD)
ES-15Intermediário

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.

4.8(38)
57
Servidor web assíncrono com ESP32 (IP no LCD)
ES-27Avançado

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.

4.8(16)
26
Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avançado
Premium

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.

4.7(7)
12