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.

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.
| Componente | Função | Observação |
|---|---|---|
| ESP32 DevKit | Medir, decidir e servir o painel web | Só Wi-Fi de 2,4 GHz |
| Sensor capacitivo de umidade do solo v1.2 | Converte a umidade do solo em uma tensão analógica | Não sofre corrosão; funciona com 3,3–5,5 V |
| Módulo relé de 1 canal | Liga e desliga a bomba | Escolha um modelo que acione com sinal de 3,3 V |
| Minibomba submersível de 3–6 V e mangueira | Bombeia a água do reservatório para o vaso | Cerca de 100–200 mA |
| Chave de nível tipo boia | Avisa quando o reservatório está vazio | Protege a bomba contra o funcionamento a seco |
| Fonte de 5 V 2 A | Alimenta o ESP32, o relé e a bomba | Todos os GNDs ligados entre si |
| Diodo 1N4007 ou 1N5819 | Absorve o pico de tensão quando a bomba desliga | Cá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ão | Pino do ESP32 | Observação |
|---|---|---|
| AOUT do sensor | GPIO 34 | Canal ADC1; pode ser lido com o Wi-Fi ligado |
| VCC do sensor | 3V3 (GPIO 25 na versão com bateria) | Na bateria, só é alimentado durante a medição |
| GND do sensor | GND | GND comum |
| IN do relé | GPIO 26 | A maioria dos módulos aciona em LOW |
| VCC / GND do relé | VIN (5 V) / GND | A bobina do relé precisa de 5 V |
| Chave boia | GPIO 27 e GND | INPUT_PULLUP; contato fechado enquanto há água |
| Bomba | 5 V, pelo COM–NA do relé | A corrente da bomba nunca passa pelo ESP32 |
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).
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ção | Valor bruto (exemplo) | Umidade (%) |
|---|---|---|
| No ar (totalmente seco) | ≈ 3000 | 0 (RAW_DRY) |
| Terra seca | ≈ 2500–2700 | 17–29 |
| Terra úmida (ideal para a maioria das plantas) | ≈ 1800–2200 | 46–69 |
| Terra recém-regada | ≈ 1500–1700 | 74–86 |
| Em um copo d'água | ≈ 1250 | 100 (RAW_WET) |
Escolhendo o limite de irrigação para sua planta
| Tipo de planta | Limite de irrigação | Observação |
|---|---|---|
| Cactos e suculentas | 15–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 umidade | 55–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:
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> · 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ódigo | O que faz |
|---|---|
| RAW_DRY / RAW_WET | Os dois valores extremos encontrados na calibração |
| map() + constrain() | Converte o valor bruto em 0–100% e o mantém dentro da faixa |
| Preferences | Guarda o limite, o tempo de bomba e o tempo de absorção na flash |
| soakMin | Espera 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 /water | Salvam 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.
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.
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
| Sintoma | Causa provável | Solução |
|---|---|---|
| Umidade sempre em 0% ou nunca muda | Sensor em um pino ADC2 com o Wi-Fi ligado | Mude o sensor para um dos GPIO 32–39 |
| Leituras pulando | Ruído, ou o sensor não está bem assentado na terra | Faça a média de 16 leituras e enterre o sensor com firmeza |
| ESP32 reinicia quando a bomba liga | Queda de tensão, falta de diodo | Adicione o diodo e um capacitor de 470 µF, use uma fonte de 2 A |
| O relé nunca desarma | Um relé de 5 V não reconhece o HIGH de 3,3 V | Use um relé compatível com 3,3 V ou um MOSFET, confira RELAY_ACTIVE_LOW |
| O vaso transborda | Tempo de absorção curto demais, ou efeito sifão | Aumente soakMin, termine a mangueira acima do nível da água do reservatório |
| A bomba funciona, mas não sai água | Ar preso na bomba, ou reservatório vazio | Mergulhe a bomba por completo, confira a chave boia |
| As configurações voltam ao padrão após queda de energia | Os valores não estão sendo salvos na flash | Garanta que as linhas prefs.putInt() sejam executadas |
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.
Projetos para montar depois desta leitura
Ver todos os projetos
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.

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.

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.

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.

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.

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.

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

