Guías · 10 min de lectura

Riego automático con ESP32: sistema Wi-Fi con sensor de humedad

Riego automático con ESP32: sensor capacitivo de humedad, módulo relé y minibomba, umbral y tiempo desde panel web, calibración, deep sleep y protección.

Un sistema de riego automático con ESP32 combina un sensor que mide la humedad de la tierra de una maceta con una pequeña bomba de agua, para que tu planta se riegue en el momento justo aunque no estés en casa. Cuando la tierra se seca por debajo del nivel que elegiste, el ESP32 hace funcionar la bomba unos segundos a través de un módulo relé, espera a que el agua se absorba y vuelve a medir. Gracias al Wi-Fi puedes ver la humedad desde el celular y cambiar el umbral y el tiempo de riego desde un panel web.

En esta guía avanzamos paso a paso: desde calibrar el sensor capacitivo de humedad de suelo hasta un código de riego completo con panel web y, después, una versión a batería con deep sleep para balcones sin enchufe. También veremos cómo elegir el umbral según el tipo de planta, cómo calcular el tiempo de bomba a partir del caudal y, sobre todo, cómo evitar que la bomba trabaje en seco cuando se vacía el tanque.

Minibomba de agua sumergible
Minibomba sumergible de 3–6 V: va dentro del tanque, empuja el agua hasta la maceta por una manguera fina y consume unos 100–200 mA.

¿Cómo funciona el riego automático con ESP32?

El sistema funciona con un ciclo sencillo. Cada 10 segundos el ESP32 toma 16 lecturas del sensor, saca el promedio y lo convierte en una humedad entre 0 % (totalmente seco) y 100 % (dentro del agua). Si la humedad está por debajo de tu umbral, hay agua en el tanque y pasó suficiente tiempo desde el último riego, hace funcionar la bomba el tiempo que configuraste. Luego empieza un tiempo de espera para que el agua se reparta en la tierra; hasta que termine no hay un nuevo riego. Todos estos ajustes se cambian desde el panel web y quedan guardados en la memoria flash del ESP32.

MaterialFunciónNota
ESP32 DevKitMide, decide y sirve el panel webSolo Wi-Fi de 2,4 GHz
Sensor de humedad de suelo capacitivo v1.2Convierte la humedad de la tierra en un voltaje analógicoNo se oxida; funciona con 3,3–5,5 V
Módulo relé de 1 canalPrende y apaga la bombaElige un modelo que se active con 3,3 V
Minibomba sumergible de 3–6 V y mangueraLleva el agua del tanque a la macetaUnos 100–200 mA
Sensor de nivel de flotadorAvisa cuando el tanque se vacíaProtege la bomba de trabajar en seco
Fuente de 5 V 2 AAlimenta el ESP32, el relé y la bombaTodas las tierras (GND) unidas
Diodo 1N4007 o 1N5819Absorbe el pico de voltaje al apagar la bombaCátodo al + de la bomba

¿Capacitivo o resistivo? El sensor de humedad correcto

Los sensores resistivos baratos (dos patas metálicas como un tenedor) miden haciendo pasar corriente directamente por la tierra. Esa corriente provoca electrólisis en las patas: en pocas semanas el metal se corroe, las lecturas se desvían y quedan iones metálicos en la tierra. En el sensor capacitivo, en cambio, los electrodos están bajo un recubrimiento aislante y no tienen contacto eléctrico con la tierra; el sensor mide cómo el agua del suelo cambia su capacidad. Por eso puede quedarse enterrado meses o incluso años. Para un riego que funciona todo el tiempo, el sensor capacitivo es prácticamente obligatorio. Tienes una comparación detallada de los dos en Sensor de humedad de suelo.

Conexiones: ESP32, sensor, relé y bomba

ConexiónPin del ESP32Nota
AOUT del sensorGPIO 34Canal ADC1; se lee con el Wi-Fi activo
VCC del sensor3V3 (GPIO 25 en la versión a batería)A batería solo se alimenta mientras mide
GND del sensorGNDTierra común
IN del reléGPIO 26La mayoría de los módulos activan en LOW
VCC / GND del reléVIN (5 V) / GNDLa bobina del relé necesita 5 V
FlotadorGPIO 27 y GNDINPUT_PULLUP; contacto cerrado mientras hay agua
Bomba5 V, a través de COM–NO del reléLa corriente de la bomba no pasa por el ESP32
En el ESP32, los pines de los canales ADC2 (GPIO 0, 2, 4, 12–15 y 25–27) no se pueden leer con analogRead() mientras el Wi-Fi está activo, porque el Wi-Fi usa ese conversor. Conecta siempre el sensor a un canal ADC1, es decir, entre GPIO 32 y 39. Ojo también con el relé: algunos módulos relé con optoacoplador alimentados con 5 V no toman el HIGH de 3,3 V del ESP32 como "apagado" y el relé queda activado todo el tiempo. Elige un módulo que se active con 3,3 V o maneja la bomba con un MOSFET de nivel lógico.

Al apagarse, el motor de la bomba genera un pico de voltaje inverso que puede reiniciar el ESP32; por eso conecta un diodo en paralelo con la bomba en sentido inverso (cátodo al +) y pon un capacitor de 100–470 µF cerca de la entrada de 5 V del ESP32. Las tierras del módulo relé, la bomba y el ESP32 tienen que estar unidas. Deja el tanque más abajo que la maceta y haz que la manguera termine por encima del nivel del agua del tanque; si no, el agua sigue corriendo por efecto sifón aunque la bomba se apague y la maceta se desborda. Explicamos en detalle cómo manejar la bomba en Bomba de agua con Arduino.

Paso 1: calibrar el sensor (valor seco y mojado)

Cada sensor capacitivo, cada largo de cable y cada voltaje de alimentación dan valores un poco distintos, así que tienes que ajustar el código a los dos extremos de tu propio sensor. Sube el código de abajo y abre el Monitor Serie a 115200 baudios. Primero sostén el sensor en el aire y anota el valor: ese es RAW_DRY, o sea 0 %. Después mete el sensor en un vaso con agua hasta la línea marcada y anota el nuevo valor: ese es RAW_WET, o sea 100 %. En el sensor capacitivo el valor baja cuando sube la humedad; el porcentaje se calcula con humedad % = (RAW_DRY − crudo) × 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}
CondiciónValor crudo (ejemplo)Humedad (%)
En el aire (totalmente seco)≈ 30000 (RAW_DRY)
Tierra seca≈ 2500–270017–29
Tierra húmeda (ideal para la mayoría)≈ 1800–220046–69
Tierra recién regada≈ 1500–170074–86
Dentro de un vaso con agua≈ 1250100 (RAW_WET)
Mete el sensor en el agua o la tierra solo hasta la línea impresa; si se moja la electrónica de arriba, el sensor se arruina. Para lecturas parejas, clávalo siempre a la misma profundidad y aprieta bien la tierra alrededor; los huecos de aire hacen que la tierra parezca más seca. Si quieres la referencia "mojada" más realista, riega bien la maceta, espera una hora y usa el valor que veas en ese momento.

Cómo elegir el umbral de riego según tu planta

Tipo de plantaUmbral de riegoNota
Cactus y suculentas15–25 %Deja que la tierra se seque casi por completo
Plantas de interior (potus, monstera, ficus)30–40 %Cuando se secan los 2–3 cm de arriba
Hortalizas y plantines (tomate, albahaca, ají)45–60 %Que la tierra siempre esté apenas húmeda
Helechos y plantas que aman la humedad55–70 %Que nunca se seque del todo

Hay dos ajustes tan importantes como el umbral: el tiempo de bomba y el tiempo de espera. Una minibomba de 100 L/h mueve en teoría unos 28 ml por segundo, pero con una manguera fina y unas decenas de centímetros de altura en la práctica salen unos 15–20 ml por segundo. Lo mejor es hacerla funcionar 10 segundos sobre una jarra medidora y medir el caudal real. Para una maceta de 15 cm suelen alcanzar 80–150 ml por riego, o sea 5–8 segundos. El tiempo de espera sirve para que el agua se reparta en la tierra y llegue al sensor: sin él, el sensor todavía no se mojó, el sistema vuelve a prender la bomba una y otra vez y la maceta se inunda. 30 minutos es un buen punto de partida.

Paso 2: código de riego con ESP32 y panel web

El código principal se encarga del riego automático y además sirve un pequeño panel que abres en el celular. El panel actualiza cada 3 segundos la humedad, el estado de la bomba y del tanque y el tiempo desde el último riego. Desde el formulario cambias el umbral, el tiempo de bomba y el tiempo de espera, y con el botón "Water now" riegas a mano. Los ajustes se guardan en la flash con la librería Preferences, así que no se pierden si se corta la luz. Aunque no logre conectarse al Wi-Fi, el código sigue a los 20 segundos y el riego automático continúa funcionando. No olvides poner los dos valores de la calibración en las líneas RAW_DRY y 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}
Parte del códigoQué hace
RAW_DRY / RAW_WETLos dos valores extremos que encontraste al calibrar
map() + constrain()Convierte el valor crudo a 0–100 % y evita que se salga del rango
PreferencesGuarda en la flash el umbral, el tiempo de bomba y el de espera
soakMinEspera entre riegos para que el agua se reparta en la tierra
waterAvailable()Si el flotador indica tanque vacío, la bomba no arranca o se detiene al instante
/save y /waterGuardan los ajustes del formulario e inician un riego manual

Después de subir el código, abre en un celular conectado al mismo Wi-Fi la IP que aparece en el Monitor Serie. Según cómo montes el flotador, su contacto puede estar abierto cuando hay agua; si el panel muestra siempre el tanque como "EMPTY", cambia LOW por HIGH en waterAvailable(). El panel no tiene contraseña, así que úsalo solo en la red de tu casa; si quieres una dirección fácil de recordar en lugar de la IP y una interfaz más dinámica, agrega lo que explicamos en Servidor web asíncrono ESP32 y WebSocket.

Cómo proteger la bomba cuando se acaba el agua

Las minibombas sumergibles se enfrían y se lubrican con el agua que pasa por ellas. Si trabajan en seco, en pocos minutos se calientan y se gastan los sellos y el impulsor; una bomba que queda funcionando en un tanque vacío durante unas vacaciones casi siempre termina rota. Por eso un buen sistema de riego protege la bomba en varias capas:

  • Flotador: Cuando el agua del tanque baja de cierto nivel el contacto se abre y el código nunca arranca la bomba; si el agua se acaba en pleno riego, la detiene de inmediato. Los detalles de conexión están en Sensor de flotador.
  • Límite de tiempo: La bomba nunca funciona más que el tiempo configurado (60 s como máximo); el software la apaga pase lo que pase.
  • Tiempo de espera: Entre riegos pasan al menos soakMin minutos, así un sensor fallado no puede obligar al sistema a regar sin parar.
  • Control de aumento de humedad: Si quieres, lleva un contador de errores cuando la humedad no sube después de regar; tras tres riegos fallidos, detén el riego automático y manda un aviso con un bot de Telegram. Sirve cuando se salió la manguera o el sensor quedó fuera de la tierra.
  • Sensor de nivel sin contacto: En lugar de un flotador, el XKC-Y25 mide desde afuera de la pared del tanque y no hay que meter nada en el agua.

Riego a batería con deep sleep

Para hacer funcionar el sistema a batería en un balcón o un jardín sin enchufe, pones el ESP32 en deep sleep entre mediciones. La versión de abajo no usa el panel web, porque tener el Wi-Fi siempre prendido agotaría la batería en pocos días. La placa despierta cada 30 minutos, alimenta el sensor por el GPIO 25 solo mientras mide, hace funcionar la bomba si hace falta y vuelve a dormir. Los contadores de despertares y riegos se guardan en la memoria RTC con RTC_DATA_ATTR, así que sobreviven al sueño. En la versión a batería la bobina de un relé de 5 V consume mucho y puede no activarse con voltaje bajo, por eso conviene manejar la bomba con un MOSFET de nivel lógico; más detalles en Cómo usar un MOSFET con 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}

Lo que define la duración de la batería es, sobre todo, el consumo de la placa mientras duerme. Un ESP32 DevKit común puede consumir 5–10 mA dormido por su regulador y su chip USB-serie: con 10 mA, una batería de 3000 mAh dura apenas 300 horas, unos 12 días. Con una placa de bajo consumo que duerme a 0,15 mA la cosa cambia: 48 despertares por día (0,5 segundos cada uno a 50 mA), 0,15 mA de sueño y un riego diario de 5 segundos suman unos 4,3 mAh; la misma batería duraría en teoría casi dos años, aunque en la práctica la autodescarga lo limita a algunos meses. Haz la cuenta con tus valores en la herramienta Duración de la batería y mira cómo bajar el consumo en reposo en ESP32 Deep Sleep.

Durante el deep sleep los pines del ESP32 quedan flotando. La mayoría de los módulos relé toman una entrada flotante como "apagado", pero si usas un MOSFET pon una resistencia de 100 kΩ entre gate y GND; si no, el gate queda al aire y la bomba podría arrancar sola mientras la placa duerme. Apaga siempre la bomba en el código antes de dormir y vigila el montaje los primeros días.

Ideas de proyectos y mejoras

  • Varias macetas: Ponle a cada maceta su propio sensor y su bomba; los pines ADC1 del ESP32 alcanzan para hasta seis macetas.
  • Notificaciones: Manda un mensaje al celular con Telegram cuando el tanque se vacía o la tierra sigue muy seca.
  • Registro de humedad: Guarda las lecturas en Google Sheets y mira en una gráfica cada cuánto necesita agua tu planta.
  • Riego solar: Carga la batería de día con un pequeño panel solar y un TP4056.
  • Control de lluvia: Al aire libre, agrega un sensor de lluvia y saltea el riego si está lloviendo.
  • Invernadero inteligente: Suma temperatura, humedad ambiente y un ventilador para convertirlo en un proyecto de invernadero inteligente.

Errores comunes y soluciones

SíntomaCausa probableSolución
La humedad siempre da 0 % o no cambiaSensor en un pin ADC2 con el Wi-Fi activoPasa el sensor a uno de los GPIO 32–39
Las lecturas saltan todo el tiempoRuido o sensor mal asentado en la tierraPromedia 16 lecturas y clava bien el sensor
El ESP32 se reinicia cuando arranca la bombaCaída de voltaje, falta el diodoAgrega el diodo y un capacitor de 470 µF, usa una fuente de 2 A
El relé nunca se sueltaEl relé de 5 V no reconoce el HIGH de 3,3 VUsa un relé compatible con 3,3 V o un MOSFET, revisa RELAY_ACTIVE_LOW
La maceta se desbordaTiempo de espera corto o efecto sifónAumenta soakMin, deja la punta de la manguera sobre el nivel del tanque
La bomba funciona pero no sale aguaAire dentro de la bomba o tanque vacíoSumerge la bomba por completo, revisa el flotador
Los ajustes se borran al cortarse la luzLos valores no se guardan en la flashVerifica que se ejecuten las líneas con prefs.putInt()
Antes de probarlo con una planta de verdad, ensaya el sistema con un vaso de agua y una toalla: comprueba que la bomba arranca con el sensor en el aire, se detiene al meterlo en el agua y se apaga al instante cuando bajas el flotador. Pon la electrónica en una caja cerrada lejos del agua y no dejes el ESP32 y el tanque en el mismo estante.

Como junta medición, toma de decisiones, seguridad y control remoto en un solo proyecto, este riego automático con ESP32 también es un gran primer paso hacia la domótica. Si quieres ver un circuito de riego paso a paso, el proyecto Estación de riego inteligente de la app BlueGrays tiene el diagrama de conexión y el código listo para cargar de una versión con Arduino.

Preguntas frecuentes

¿Cómo hago un riego automático con ESP32?

Conecta un sensor de humedad de suelo capacitivo a un pin ADC1 del ESP32 y un módulo relé a un pin digital, y alimenta la minibomba desde una fuente de 5 V aparte a través del relé. Calibra el sensor en el aire y en agua y define un umbral de humedad en el código; cuando la humedad baja de ese valor, la bomba funciona unos segundos y el sistema espera a que el agua se absorba.

¿A qué pin del ESP32 se conecta el sensor de humedad de suelo?

Conecta la salida analógica a uno de los pines ADC1 entre GPIO 32 y 39; en esta guía usamos el GPIO 34. Los pines ADC2 no se pueden leer con analogRead() cuando el Wi-Fi está activo, así que en proyectos con Wi-Fi el sensor siempre va en ADC1.

¿Con qué porcentaje de humedad hay que regar?

Depende de la planta: 15–25 % para cactus y suculentas, 30–40 % para la mayoría de las plantas de interior y 45–60 % para hortalizas como el tomate o la albahaca son buenos puntos de partida. Como los porcentajes dependen de la calibración de tu sensor, observa la planta unos días y ajusta el umbral.

¿Conviene manejar la bomba con un relé o con un MOSFET?

En un sistema enchufado a la red, un módulo relé que se active con 3,3 V es práctico y seguro. Si funciona a batería o quieres regular la velocidad de la bomba con PWM, un MOSFET de nivel lógico consume menos y es silencioso; en los dos casos hay que poner un diodo inverso en la bomba.

¿Se rompe la minibomba si funciona sin agua?

Sí. Las minibombas sumergibles se enfrían y se lubrican con el agua que pasa por ellas, y en seco se calientan y se desgastan en pocos minutos. Poner un flotador o un sensor de nivel sin contacto en el tanque y detener la bomba por software es la protección más fácil.

¿Cuánto dura a batería un riego con ESP32?

Con el Wi-Fi siempre prendido, la batería se agota en pocos días. Con deep sleep depende del consumo de la placa dormida: un DevKit común que consume 10 mA en reposo dura unos 12 días con 3000 mAh, mientras que una placa de bajo consumo a 0,15 mA aguanta meses.

Ver todos los proyectos
Estación de riego inteligente
AR-83Avanzado
Premium

Estación de riego inteligente

Un jardinero que riega solo tus plantas para que no se sequen mientras estás de vacaciones.

5.0(42)
57
Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
ES-27Avanzado

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)

En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

4.8(16)
26
Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
ES-25Avanzado

Conexión Wi-Fi STA con ESP32 (con pantalla LCD)

En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.

4.4(21)
38
Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)
ES-33Avanzado
Premium

Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)

El modo Deep Sleep del ESP32 apaga la CPU y la mayoría de los periféricos y reduce el consumo a unos 10µA, algo clave para dispositivos IoT con batería. Este proyecto usa tres fuentes de activación: un temporizador (15 s), un pin externo (EXT0, el botón en GPIO 33) y un pin táctil (T0/GPIO 4). Los contadores marcados con RTC_DATA_ATTR se conservan durante el deep sleep.

4.3(10)
16
ESP32 DHT22 Temperatura y humedad (con pantalla LCD)
ES-15Intermedio

ESP32 DHT22 Temperatura y humedad (con pantalla LCD)

Se trata de un proyecto que mide la temperatura y la humedad ambientales mediante el sensor DHT22 y las muestra en tiempo real en una pantalla LCD I2C 16x2. Los datos del sensor se leen mediante el protocolo de un solo cable (one-wire) utilizando la biblioteca DHT de Adafruit. Este proyecto constituye la base para estaciones meteorológicas IoT, sistemas de automatización doméstica inteligente o sistemas de monitorización ambiental en invernaderos.

4.8(38)
57
Iluminación Inteligente ESP32 (PIR + LDR + Relé + OLED)
ES-37Avanzado
Premium

Iluminación Inteligente ESP32 (PIR + LDR + Relé + OLED)

Con un ESP32, un sensor de movimiento PIR, un sensor de luz LDR y un módulo de relé convertimos el pasillo, el baño o la despensa de tu casa en iluminación inteligente. Si ya hay luz, la lámpara no se enciende aunque haya movimiento, así no gasta energía de día. La luz se queda encendida 30 segundos y el tiempo se alarga solo mientras siga habiendo movimiento.

4.3(6)
11
Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzado
Premium

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.

4.7(7)
12