Guias · 10 min de leitura

Irrigação automática com ESP32: painel Wi-Fi e sensor de umidade do solo

Monte um sistema de irrigação automática com ESP32: sensor capacitivo de umidade do solo, relé e bomba, painel web para limite e tempo, calibração, deep sleep e proteção contra funcionamento a seco.

Um sistema de irrigação automática com ESP32 junta um sensor que mede a umidade da terra no vaso com uma pequena bomba d'água, para que sua planta seja regada na hora certa mesmo quando você está fora. Quando a terra seca abaixo do nível que você definiu, o ESP32 aciona a bomba por alguns segundos através de um relé, espera a água se espalhar e mede de novo. Graças ao Wi-Fi, você acompanha a umidade pelo celular e muda o limite e a duração da irrigação em um painel web.

Neste guia vamos passo a passo, da calibração do sensor capacitivo de umidade do solo a um sketch completo de irrigação com painel web, e depois a uma versão com bateria e deep sleep para varandas sem tomada. Também vamos ver como escolher o limite para cada tipo de planta, calcular o tempo de bomba a partir da vazão e, o mais importante, proteger a bomba contra o funcionamento a seco quando o reservatório esvaziar.

Minibomba d'água submersível
Minibomba submersível de 3–6 V: fica dentro do reservatório, empurra a água até o vaso por uma mangueira fina e consome cerca de 100–200 mA.

Como funciona um sistema de irrigação automática com ESP32?

O sistema funciona em um ciclo simples. A cada 10 segundos, o ESP32 faz 16 leituras do sensor, tira a média e converte o resultado em um valor de umidade entre 0% (totalmente seco) e 100% (dentro d'água). Se a umidade estiver abaixo do seu limite, houver água no reservatório e já tiver passado tempo suficiente desde a última irrigação, ele liga a bomba pelo tempo que você definiu. Depois começa um tempo de absorção para a água se espalhar pela terra; nenhuma nova irrigação acontece até ele terminar. Todas essas configurações são alteradas pelo painel web e guardadas na memória flash do ESP32.

ComponenteFunçãoObservação
ESP32 DevKitMedir, decidir e servir o painel webSó Wi-Fi de 2,4 GHz
Sensor capacitivo de umidade do solo v1.2Converte a umidade do solo em uma tensão analógicaNão sofre corrosão; funciona com 3,3–5,5 V
Módulo relé de 1 canalLiga e desliga a bombaEscolha um modelo que acione com sinal de 3,3 V
Minibomba submersível de 3–6 V e mangueiraBombeia a água do reservatório para o vasoCerca de 100–200 mA
Chave de nível tipo boiaAvisa quando o reservatório está vazioProtege a bomba contra o funcionamento a seco
Fonte de 5 V 2 AAlimenta o ESP32, o relé e a bombaTodos os GNDs ligados entre si
Diodo 1N4007 ou 1N5819Absorve o pico de tensão quando a bomba desligaCátodo no terminal + da bomba

Capacitivo ou resistivo? Escolhendo o sensor de umidade do solo certo

Os sensores resistivos baratos (duas hastes metálicas como um garfo) medem passando corrente diretamente pela terra. Essa corrente provoca eletrólise nas hastes: em poucas semanas o metal sofre corrosão, as leituras se desviam e íons metálicos vão parar na terra. Em um sensor capacitivo, os eletrodos ficam sob um revestimento isolante e nunca têm contato elétrico com a terra; o sensor mede como a água no solo altera sua capacitância. Por isso ele pode ficar enterrado por meses ou até anos. Para um sistema de irrigação que funciona o tempo todo, o sensor capacitivo é praticamente obrigatório. Você encontra uma comparação detalhada dos dois em Sensor de umidade do solo.

Ligação: ESP32, sensor, relé e bomba

ConexãoPino do ESP32Observação
AOUT do sensorGPIO 34Canal ADC1; pode ser lido com o Wi-Fi ligado
VCC do sensor3V3 (GPIO 25 na versão com bateria)Na bateria, só é alimentado durante a medição
GND do sensorGNDGND comum
IN do reléGPIO 26A maioria dos módulos aciona em LOW
VCC / GND do reléVIN (5 V) / GNDA bobina do relé precisa de 5 V
Chave boiaGPIO 27 e GNDINPUT_PULLUP; contato fechado enquanto há água
Bomba5 V, pelo COM–NA do reléA corrente da bomba nunca passa pelo ESP32
No ESP32, os pinos dos canais ADC2 (GPIO 0, 2, 4, 12–15 e 25–27) não podem ser lidos com analogRead() enquanto o Wi-Fi está ligado, porque o próprio Wi-Fi usa esse conversor. Ligue sempre o sensor em um dos canais ADC1, ou seja, GPIO 32–39. Fique de olho também no relé: alguns módulos relé com optoacoplador alimentados com 5 V não entendem o HIGH de 3,3 V do ESP32 como “desligado”, e o relé fica acionado o tempo todo. Escolha um módulo que acione com 3,3 V ou acione a bomba com um MOSFET de nível lógico.

Quando o motor da bomba desliga, ele gera um pico de tensão reverso que pode reiniciar o ESP32; por isso, ligue um diodo invertido entre os terminais da bomba (cátodo no +) e coloque um capacitor de 100–470 µF perto da entrada de 5 V do ESP32. Os GNDs do módulo relé, da bomba e do ESP32 precisam estar todos unidos. Mantenha o reservatório abaixo do vaso e termine a mangueira acima do nível da água no reservatório; caso contrário, a água continua correndo por efeito sifão mesmo depois que a bomba para, e o vaso transborda. Explicamos em detalhes como acionar a bomba em Bomba d'água com Arduino.

Passo 1: calibrando o sensor (valores seco e molhado)

Cada sensor capacitivo, comprimento de cabo e tensão de alimentação dá valores um pouco diferentes, então você precisa ajustar o código aos dois valores extremos do seu sensor. Carregue o código abaixo e abra o Monitor Serial em 115200 baud. Primeiro segure o sensor no ar e anote o valor: esse é o RAW_DRY, ou 0%. Depois mergulhe o sensor em um copo d'água até a linha marcada na placa e anote o novo valor: esse é o RAW_WET, ou 100%. Em um sensor capacitivo, o valor diminui à medida que a umidade aumenta; a porcentagem sai de umidade % = (RAW_DRY − bruto) × 100 / (RAW_DRY − RAW_WET).

C++ (Arduino IDE)
1// Kalibrasyon: sensörü önce havada, sonra bardak suda tut / calibration: hold the sensor in air, then in a glass of water
2const int SOIL_PIN = 34;             // sensör AOUT, ADC1 kanalı / sensor AOUT, an ADC1 channel
3
4void setup() {
5  Serial.begin(115200);
6}
7
8void loop() {
9  long sum = 0;
10  for (int i = 0; i < 16; i++) {     // 16 ölçümün ortalaması / average of 16 readings
11    sum += analogRead(SOIL_PIN);
12    delay(5);
13  }
14  Serial.print("Ham deger / raw value: ");
15  Serial.println(sum / 16);          // havada → RAW_DRY, suda → RAW_WET / in air → RAW_DRY, in water → RAW_WET
16  delay(1000);
17}
CondiçãoValor bruto (exemplo)Umidade (%)
No ar (totalmente seco)≈ 30000 (RAW_DRY)
Terra seca≈ 2500–270017–29
Terra úmida (ideal para a maioria das plantas)≈ 1800–220046–69
Terra recém-regada≈ 1500–170074–86
Em um copo d'água≈ 1250100 (RAW_WET)
Enfie o sensor na água ou na terra só até a linha impressa nele; se a eletrônica da parte de cima molhar, o sensor estraga. Para leituras consistentes, coloque o sensor sempre na mesma profundidade e aperte bem a terra em volta dele; bolsões de ar fazem a terra parecer mais seca do que está. Se quiser a referência “molhada” mais realista, regue bem o vaso, espere uma hora e use o valor que aparecer nesse momento.

Escolhendo o limite de irrigação para sua planta

Tipo de plantaLimite de irrigaçãoObservação
Cactos e suculentas15–25%Deixe a terra secar quase totalmente
Plantas de interior (jiboia, costela-de-adão, ficus)30–40%Quando os 2–3 cm de cima estiverem secos
Hortaliças e mudas (tomate, manjericão, pimentão)45–60%Mantenha a terra sempre levemente úmida
Samambaias e plantas que gostam de umidade55–70%Nunca deixe secar completamente

Duas configurações importam tanto quanto o limite: o tempo de bomba e o tempo de absorção. Uma minibomba de 100 L/h move cerca de 28 ml por segundo na teoria, mas com uma mangueira fina e algumas dezenas de centímetros de altura, na prática você terá algo em torno de 15–20 ml por segundo. O melhor é ligar a bomba em um copo medidor por 10 segundos e medir a vazão real. Para um vaso de 15 cm, 80–150 ml por irrigação costumam bastar, ou seja, 5–8 segundos. O tempo de absorção dá à água a chance de se espalhar pela terra e chegar ao sensor: sem ele, o sensor ainda não está molhado, então o sistema liga a bomba de novo e de novo e alaga o vaso. 30 minutos é um bom ponto de partida.

Passo 2: código de irrigação do ESP32 com painel web

O sketch principal cuida da irrigação automática e também serve um pequeno painel que você abre no celular. O painel atualiza a umidade, o estado da bomba e do reservatório e o tempo desde a última irrigação a cada 3 segundos. Pelo formulário você muda o limite, o tempo de bomba e o tempo de absorção, e o botão “Water now” (Regar agora) faz uma irrigação manual. As configurações são gravadas na flash com a biblioteca Preferences, então sobrevivem a uma queda de energia. Mesmo que o Wi-Fi não conecte, o código segue em frente após 20 segundos e a irrigação automática continua funcionando. Não se esqueça de colocar os dois valores da sua calibração nas linhas RAW_DRY e RAW_WET:

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3#include <Preferences.h>
4
5const char* ssid = "AgAdi";              // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123";       // Wi-Fi şifren / your Wi-Fi password
7
8const int SOIL_PIN = 34;                 // sensör AOUT (ADC1) / sensor AOUT (ADC1)
9const int RELAY_PIN = 26;                // röle IN / relay IN
10const int FLOAT_PIN = 27;                // şamandıra, diğer ucu GND / float switch, other leg to GND
11const bool RELAY_ACTIVE_LOW = true;      // çoğu röle modülü LOW'da çeker / most relay modules switch on LOW
12const int RAW_DRY = 3000;                // havadaki değer (%0) / reading in air (0%)
13const int RAW_WET = 1250;                // sudaki değer (%100) / reading in water (100%)
14
15WebServer server(80);
16Preferences prefs;
17
18int threshold = 35;                      // bu nemin altında sula (%) / water below this moisture (%)
19int durationS = 5;                       // pompa süresi (sn) / pump run time (s)
20int soakMin = 30;                        // iki sulama arası bekleme (dk) / soak time between waterings (min)
21
22int moisture = 0;                        // son nem (%) / last moisture (%)
23bool pumpOn = false, tankLow = false, everWatered = false;
24unsigned long pumpStart = 0, lastWater = 0, lastCheck = 0;
25
26const char PAGE[] PROGMEM = R"HTML(<!DOCTYPE html><html><head><meta charset="utf-8">
27<meta name="viewport" content="width=device-width,initial-scale=1"><title>ESP32 Sulama</title>
28<style>body{font-family:sans-serif;margin:16px;max-width:420px}input{width:70px}button{padding:8px 14px;margin-top:8px}</style></head>
29<body><h2>ESP32 Sulama / Watering</h2>
30<p>Nem / Moisture: <b id="m">--</b> %</p>
31<p>Pompa / Pump: <b id="p">--</b> &middot; Depo / Tank: <b id="k">--</b></p>
32<p>Son sulama / Last watering: <b id="l">--</b></p>
33<form action="/save" method="POST">
34<p>Esik / Threshold (%): <input name="th" type="number" min="5" max="90" value="%TH%"></p>
35<p>Sure / Duration (s): <input name="du" type="number" min="1" max="60" value="%DU%"></p>
36<p>Bekleme / Soak (min): <input name="so" type="number" min="1" max="720" value="%SO%"></p>
37<button>Kaydet / Save</button></form>
38<form action="/water" method="POST"><button>Simdi sula / Water now</button></form>
39<script>
40function upd() {
41  fetch('/data').then(r => r.json()).then(d => {
42    document.getElementById('m').textContent = d.m;
43    document.getElementById('p').textContent = d.p ? 'ON' : 'OFF';
44    document.getElementById('k').textContent = d.k ? 'BOS / EMPTY' : 'OK';
45    document.getElementById('l').textContent = d.l < 0 ? '--' : Math.round(d.l / 60) + ' dk / min';
46  });
47}
48upd(); setInterval(upd, 3000);
49</script></body></html>)HTML";
50
51void setPump(bool on) {
52  pumpOn = on;
53  digitalWrite(RELAY_PIN, (on != RELAY_ACTIVE_LOW) ? HIGH : LOW);
54}
55
56bool waterAvailable() {                  // şamandıra yukarıda: kontak kapalı, LOW / float up: contact closed, LOW
57  return digitalRead(FLOAT_PIN) == LOW;
58}
59
60int readMoisture() {
61  long sum = 0;
62  for (int i = 0; i < 16; i++) { sum += analogRead(SOIL_PIN); delay(5); }
63  int pct = map(sum / 16, RAW_DRY, RAW_WET, 0, 100);   // kuru → 0, ıslak → 100 / dry → 0, wet → 100
64  return constrain(pct, 0, 100);
65}
66
67void startWatering() {
68  if (pumpOn || !waterAvailable()) return;   // su yoksa pompayı asla çalıştırma / never run the pump dry
69  setPump(true);
70  pumpStart = lastWater = millis();
71  everWatered = true;
72}
73
74void handleRoot() {
75  String page = PAGE;
76  page.replace("%TH%", String(threshold));
77  page.replace("%DU%", String(durationS));
78  page.replace("%SO%", String(soakMin));
79  server.send(200, "text/html", page);
80}
81
82void handleData() {
83  long ago = everWatered ? (long)((millis() - lastWater) / 1000) : -1;
84  server.send(200, "application/json", "{\"m\":" + String(moisture) + ",\"p\":" + String(pumpOn ? 1 : 0) +
85              ",\"k\":" + String(tankLow ? 1 : 0) + ",\"l\":" + String(ago) + "}");
86}
87
88void handleSave() {
89  threshold = constrain(server.arg("th").toInt(), 5, 90);
90  durationS = constrain(server.arg("du").toInt(), 1, 60);
91  soakMin = constrain(server.arg("so").toInt(), 1, 720);
92  prefs.putInt("th", threshold);         // flaşa kaydet, elektrik kesilse de kalır / saved to flash, survives power cuts
93  prefs.putInt("du", durationS);
94  prefs.putInt("so", soakMin);
95  server.sendHeader("Location", "/");
96  server.send(303);
97}
98
99void handleWater() {
100  startWatering();                       // elle sulama / manual watering
101  server.sendHeader("Location", "/");
102  server.send(303);
103}
104
105void setup() {
106  Serial.begin(115200);
107  pinMode(RELAY_PIN, OUTPUT);
108  setPump(false);                        // açılışta pompa kapalı / pump off at boot
109  pinMode(FLOAT_PIN, INPUT_PULLUP);
110  prefs.begin("sulama", false);
111  threshold = prefs.getInt("th", threshold);
112  durationS = prefs.getInt("du", durationS);
113  soakMin = prefs.getInt("so", soakMin);
114
115  WiFi.mode(WIFI_STA);
116  WiFi.begin(ssid, password);
117  for (int i = 0; i < 40 && WiFi.status() != WL_CONNECTED; i++) delay(500);   // en fazla 20 sn bekle / wait 20 s at most
118  Serial.print("IP: ");
119  Serial.println(WiFi.localIP());        // Wi-Fi yoksa da sulama çalışır / watering works even without Wi-Fi
120
121  server.on("/", handleRoot);
122  server.on("/data", handleData);
123  server.on("/save", HTTP_POST, handleSave);
124  server.on("/water", HTTP_POST, handleWater);
125  server.begin();
126}
127
128void loop() {
129  server.handleClient();
130  unsigned long now = millis();
131  if (pumpOn) {
132    tankLow = !waterAvailable();
133    if (now - pumpStart >= (unsigned long)durationS * 1000UL || tankLow) setPump(false);   // süre ya da su bitti / time or water ran out
134  }
135  if (now - lastCheck >= 10000) {        // 10 sn'de bir kontrol / check every 10 s
136    lastCheck = now;
137    moisture = readMoisture();
138    tankLow = !waterAvailable();
139    bool soaked = !everWatered || now - lastWater >= (unsigned long)soakMin * 60000UL;
140    if (!pumpOn && !tankLow && moisture < threshold && soaked) startWatering();
141    Serial.printf("Nem / Moisture: %d %%  Depo / Tank: %s\n", moisture, tankLow ? "BOS / EMPTY" : "OK");
142  }
143}
CódigoO que faz
RAW_DRY / RAW_WETOs dois valores extremos encontrados na calibração
map() + constrain()Converte o valor bruto em 0–100% e o mantém dentro da faixa
PreferencesGuarda o limite, o tempo de bomba e o tempo de absorção na flash
soakMinEspera entre irrigações para a água se espalhar pela terra
waterAvailable()Se a boia indica reservatório vazio, a bomba não liga ou para na hora
/save e /waterSalvam as configurações do formulário e iniciam uma irrigação manual

Depois de carregar, abra o endereço IP mostrado no Monitor Serial em um celular conectado ao mesmo Wi-Fi. Dependendo de como a chave boia está montada, o contato pode ficar aberto enquanto há água; se o painel mostra o reservatório sempre como “EMPTY” (vazio), troque LOW por HIGH em waterAvailable(). O painel não tem senha, então use-o só na sua rede doméstica; se quiser um endereço fácil de lembrar em vez de um IP e uma interface mais dinâmica, acrescente as técnicas de Servidor web assíncrono e WebSocket no ESP32.

Protegendo a bomba quando a água acaba

As minibombas submersíveis são resfriadas e lubrificadas pela água que passa por elas. Funcionando a seco, aquecem em minutos e desgastam vedações e rotores; uma bomba que fica ligada em um reservatório vazio durante as férias inteiras normalmente morre. Por isso, um bom sistema de irrigação protege a bomba em várias camadas:

  • Chave boia: quando a água do reservatório cai abaixo de um certo nível, o contato abre e o código nunca liga a bomba; se a água acabar no meio da irrigação, ele para a bomba imediatamente. Os detalhes de ligação estão em Chave de nível tipo boia.
  • Limite de tempo: a bomba nunca funciona mais do que o tempo definido (no máximo 60 s); mesmo que o relé fique travado do ponto de vista do software, o código o desliga.
  • Tempo de absorção: passam pelo menos soakMin minutos entre irrigações, então um sensor com defeito não consegue forçar o sistema a regar sem parar.
  • Verificação de aumento da umidade: se quiser, mantenha um contador de erros quando a leitura após a irrigação não subir; depois de três irrigações sem sucesso, pare a irrigação automática e envie um alerta com um bot do Telegram. Isso detecta uma mangueira que escapou ou um sensor que saiu da terra.
  • Sensor de nível sem contato: use um XKC-Y25, que mede por fora da parede do reservatório, no lugar da boia, e nada precisa ficar dentro da água.

Irrigação com bateria usando deep sleep

Para rodar o sistema com bateria em uma varanda ou jardim sem tomada, você coloca o ESP32 em deep sleep entre as medições. A versão abaixo dispensa o painel web, porque manter o Wi-Fi ligado esgotaria a bateria em poucos dias. A placa acorda a cada 30 minutos, alimenta o sensor pelo GPIO 25 só durante a medição, liga a bomba se necessário e volta a dormir. As contagens de despertares e irrigações ficam na memória RTC com RTC_DATA_ATTR, então sobrevivem ao sono. Na versão com bateria, uma bobina de relé de 5 V consome muita corrente e pode não acionar com tensão baixa, por isso faz mais sentido acionar a bomba com um MOSFET de nível lógico; detalhes em MOSFET com Arduino.

C++ (Arduino IDE)
1// Pilli sürüm: 30 dk'da bir uyan, ölç, gerekirse sula, uyu / battery version: wake every 30 min, measure, water if needed, sleep
2const int SOIL_PIN = 34;                 // sensör AOUT / sensor AOUT
3const int SENSOR_PWR = 25;               // sensör VCC bu pinden / sensor VCC from this pin
4const int PUMP_PIN = 26;                 // röle IN ya da MOSFET gate / relay IN or MOSFET gate
5const int FLOAT_PIN = 27;                // şamandıra / float switch
6const bool PUMP_ACTIVE_LOW = true;       // MOSFET kullanıyorsan false / false if you use a MOSFET
7const int RAW_DRY = 3000, RAW_WET = 1250;
8const int THRESHOLD = 35;                // %
9const int DURATION_S = 5;                // sn / s
10const uint64_t SLEEP_US = 30ULL * 60 * 1000000;   // 30 dakika / 30 minutes
11
12RTC_DATA_ATTR int wakeCount = 0;         // deep sleep'te silinmez / survives deep sleep
13RTC_DATA_ATTR int waterCount = 0;
14
15void pump(bool on) {
16  digitalWrite(PUMP_PIN, (on != PUMP_ACTIVE_LOW) ? HIGH : LOW);
17}
18
19void setup() {
20  Serial.begin(115200);
21  wakeCount++;
22  pinMode(PUMP_PIN, OUTPUT);
23  pump(false);
24  pinMode(FLOAT_PIN, INPUT_PULLUP);
25  pinMode(SENSOR_PWR, OUTPUT);
26  digitalWrite(SENSOR_PWR, HIGH);        // sensörü yalnız ölçerken aç / power the sensor only while measuring
27  delay(200);                            // çıkışın oturmasını bekle / let the output settle
28  long sum = 0;
29  for (int i = 0; i < 16; i++) { sum += analogRead(SOIL_PIN); delay(5); }
30  digitalWrite(SENSOR_PWR, LOW);
31  int pct = constrain(map(sum / 16, RAW_DRY, RAW_WET, 0, 100), 0, 100);
32  bool water = digitalRead(FLOAT_PIN) == LOW;
33  Serial.printf("Uyanma / Wake %d: nem / moisture %d %%, depo / tank %s, sulama / waterings %d\n",
34                wakeCount, pct, water ? "OK" : "BOS / EMPTY", waterCount);
35
36  if (pct < THRESHOLD && water) {
37    pump(true);
38    unsigned long start = millis();
39    while (millis() - start < DURATION_S * 1000UL && digitalRead(FLOAT_PIN) == LOW) delay(10);   // su biterse hemen dur / stop at once if the tank empties
40    pump(false);
41    waterCount++;
42  }
43  esp_sleep_enable_timer_wakeup(SLEEP_US);
44  esp_deep_sleep_start();                // uyanınca setup() baştan başlar / wakes up into setup()
45}
46
47void loop() {
48}

A autonomia da bateria é definida principalmente pela corrente de sono da placa. Um ESP32 DevKit comum pode consumir 5–10 mA dormindo por causa do regulador e do chip USB-serial: com 10 mA, uma bateria de 3000 mAh dura só 300 horas, cerca de 12 dias. Com uma placa de baixo consumo que dorme com 0,15 mA, o cenário muda: 48 despertares por dia (0,5 segundo cada a 50 mA), 0,15 mA de sono e um acionamento de bomba de 5 segundos por dia somam cerca de 4,3 mAh; a mesma bateria duraria quase dois anos na teoria, embora na prática a autodescarga limite isso a meses. Faça suas próprias contas com a ferramenta Autonomia da bateria e veja ESP32 Deep Sleep para formas de reduzir a corrente de sono.

Durante o deep sleep, os pinos do ESP32 ficam flutuando. A maioria dos módulos relé entende uma entrada flutuante como “desligado”, mas se você estiver usando um MOSFET, coloque um resistor de 100 kΩ entre o gate e o GND; caso contrário, o gate fica flutuando e a bomba pode ligar sozinha enquanto a placa dorme. Sempre desligue a bomba no código antes de dormir e fique de olho na montagem nos primeiros dias.

Ideias de projeto e melhorias

  • Sistema com vários vasos: dê a cada vaso seu próprio sensor e bomba; os pinos ADC1 do ESP32 bastam para até seis vasos.
  • Notificações: envie uma mensagem para o seu celular pelo Telegram quando o reservatório esvaziar ou a terra continuar seca demais.
  • Registro de umidade: salve as leituras no Google Sheets e veja em um gráfico com que frequência sua planta precisa de água.
  • Irrigação solar: carregue a bateria durante o dia com um pequeno painel solar e um TP4056.
  • Verificação de chuva: ao ar livre, adicione um sensor de chuva e pule a irrigação quando estiver chovendo.
  • Estufa inteligente: acrescente temperatura, umidade e uma ventoinha para transformar tudo em um projeto de estufa inteligente.

Problemas comuns e soluções

SintomaCausa provávelSolução
Umidade sempre em 0% ou nunca mudaSensor em um pino ADC2 com o Wi-Fi ligadoMude o sensor para um dos GPIO 32–39
Leituras pulandoRuído, ou o sensor não está bem assentado na terraFaça a média de 16 leituras e enterre o sensor com firmeza
ESP32 reinicia quando a bomba ligaQueda de tensão, falta de diodoAdicione o diodo e um capacitor de 470 µF, use uma fonte de 2 A
O relé nunca desarmaUm relé de 5 V não reconhece o HIGH de 3,3 VUse um relé compatível com 3,3 V ou um MOSFET, confira RELAY_ACTIVE_LOW
O vaso transbordaTempo de absorção curto demais, ou efeito sifãoAumente soakMin, termine a mangueira acima do nível da água do reservatório
A bomba funciona, mas não sai águaAr preso na bomba, ou reservatório vazioMergulhe a bomba por completo, confira a chave boia
As configurações voltam ao padrão após queda de energiaOs valores não estão sendo salvos na flashGaranta que as linhas prefs.putInt() sejam executadas
Antes de testar em uma planta de verdade, teste o sistema com um copo d'água e uma toalha: confira se a bomba liga quando o sensor está no ar, para quando você o mergulha na água e desliga na hora quando você abaixa a boia. Coloque a eletrônica em uma caixa fechada longe da água e não deixe o ESP32 e o reservatório na mesma prateleira.

Por juntar medição, tomada de decisão, segurança e controle remoto em um só projeto, este sistema de irrigação com ESP32 também é um ótimo primeiro passo na automação residencial. Se quiser ver um circuito de irrigação passo a passo, o projeto Estação de irrigação inteligente no app BlueGrays traz o esquema do circuito e o código pronto para carregar de uma versão com Arduino.

Perguntas frequentes

Como fazer um sistema de irrigação automática de plantas com ESP32?

Ligue um sensor capacitivo de umidade do solo em um dos pinos ADC1 do ESP32 e um módulo relé em um pino digital, e alimente a minibomba por uma fonte separada de 5 V através do relé. Calibre o sensor no ar e na água e defina um limite de umidade no código; quando a umidade cair abaixo dele, a bomba funciona por alguns segundos e o sistema espera a água se espalhar.

Em qual pino do ESP32 ligar o sensor de umidade do solo?

Ligue a saída analógica em um dos pinos ADC1 entre GPIO 32 e 39; este guia usa o GPIO 34. Os pinos ADC2 não podem ser lidos com analogRead() enquanto o Wi-Fi está ligado, então em projetos com Wi-Fi o sensor deve ir sempre no ADC1.

Com qual porcentagem de umidade do solo devo regar as plantas?

Depende da planta: 15–25% para cactos e suculentas, 30–40% para a maioria das plantas de interior e 45–60% para hortaliças como tomate e manjericão são bons pontos de partida. Como as porcentagens dependem da calibração do seu sensor, observe a planta por alguns dias e faça o ajuste fino do limite.

Devo acionar a bomba com relé ou com MOSFET?

Em um sistema ligado na tomada, um módulo relé que aciona com 3,3 V é prático e seguro. Em sistemas com bateria, ou se você quiser controlar a velocidade da bomba com PWM, um MOSFET de nível lógico consome menos energia e funciona em silêncio; em qualquer caso, coloque um diodo invertido nos terminais da bomba.

Uma minibomba d'água estraga se funcionar a seco?

Sim. As minibombas submersíveis são resfriadas e lubrificadas pela água que passa por elas e, quando funcionam a seco, aquecem e se desgastam em minutos. Uma chave boia ou um sensor de nível sem contato no reservatório que pare a bomba pelo software é a proteção mais fácil.

Quanto tempo um sistema de irrigação com ESP32 funciona com bateria?

Com o Wi-Fi ligado o tempo todo, a bateria acaba em poucos dias. Com deep sleep, depende da corrente de sono da placa: um DevKit comum que consome 10 mA dormindo dura cerca de 12 dias com uma bateria de 3000 mAh, enquanto uma placa de baixo consumo com 0,15 mA dura meses.

Ver todos os projetos
Estação de irrigação inteligente
AR-83Avançado
Premium

Estação de irrigação inteligente

Um jardineiro que rega suas plantas sozinho para que elas não sequem enquanto você está de férias.

5.0(42)
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
Conexão Wi-Fi STA com ESP32 e display LCD
ES-25Avançado

Conexão Wi-Fi STA com ESP32 e display LCD

Neste projeto, conectamos o ESP32 à rede Wi-Fi de casa no modo estação (STA), de forma segura e tolerante a falhas. Guardamos o SSID e a senha em um arquivo secrets.h separado para evitar que sejam expostos no Git, configuramos um mecanismo de reconexão automática e exibimos o nível de sinal RSSI e o endereço IP em um display LCD I2C. O LED integrado funciona como indicador de status. É um gerenciador de conexão pronto para uso em produção.

4.4(21)
38
ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)
ES-33Avançado
Premium

ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)

O modo de sono profundo do ESP32 reduz o consumo de corrente para ~10 µA ao desligar a CPU e a maioria dos periféricos, sendo essencial para dispositivos IoT alimentados por bateria. Neste projeto, usamos três fontes de despertar: um temporizador (15 segundos), um pino externo (EXT0 — botão no GPIO 33) e toque (T0/GPIO 4). As variáveis marcadas com RTC_DATA_ATTR são preservadas durante o sono profundo, mantendo os contadores de inicializações e de despertares por temporizador e botão.

4.3(10)
16
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
Iluminação inteligente com ESP32 (PIR + LDR + relé + OLED)
ES-37Avançado
Premium

Iluminação inteligente com ESP32 (PIR + LDR + relé + OLED)

Transforme a iluminação do corredor, banheiro ou despensa em iluminação inteligente com ESP32! Com um sensor de movimento PIR, um sensor de luz LDR e um módulo relé, montamos o cenário clássico de "acender a luz ao detectar movimento no escuro" — se o ambiente já estiver claro, o movimento NÃO aciona a luz, economizando energia durante o dia. A luz fica acesa por 30 segundos; se o movimento continuar, o temporizador reinicia e a luz permanece acesa por mais tempo.

4.3(6)
11
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