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.

¿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.
| Material | Función | Nota |
|---|---|---|
| ESP32 DevKit | Mide, decide y sirve el panel web | Solo Wi-Fi de 2,4 GHz |
| Sensor de humedad de suelo capacitivo v1.2 | Convierte la humedad de la tierra en un voltaje analógico | No se oxida; funciona con 3,3–5,5 V |
| Módulo relé de 1 canal | Prende y apaga la bomba | Elige un modelo que se active con 3,3 V |
| Minibomba sumergible de 3–6 V y manguera | Lleva el agua del tanque a la maceta | Unos 100–200 mA |
| Sensor de nivel de flotador | Avisa cuando el tanque se vacía | Protege la bomba de trabajar en seco |
| Fuente de 5 V 2 A | Alimenta el ESP32, el relé y la bomba | Todas las tierras (GND) unidas |
| Diodo 1N4007 o 1N5819 | Absorbe el pico de voltaje al apagar la bomba | Cá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ón | Pin del ESP32 | Nota |
|---|---|---|
| AOUT del sensor | GPIO 34 | Canal ADC1; se lee con el Wi-Fi activo |
| VCC del sensor | 3V3 (GPIO 25 en la versión a batería) | A batería solo se alimenta mientras mide |
| GND del sensor | GND | Tierra común |
| IN del relé | GPIO 26 | La mayoría de los módulos activan en LOW |
| VCC / GND del relé | VIN (5 V) / GND | La bobina del relé necesita 5 V |
| Flotador | GPIO 27 y GND | INPUT_PULLUP; contacto cerrado mientras hay agua |
| Bomba | 5 V, a través de COM–NO del relé | La corriente de la bomba no pasa por el ESP32 |
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).
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ón | Valor crudo (ejemplo) | Humedad (%) |
|---|---|---|
| En el aire (totalmente seco) | ≈ 3000 | 0 (RAW_DRY) |
| Tierra seca | ≈ 2500–2700 | 17–29 |
| Tierra húmeda (ideal para la mayoría) | ≈ 1800–2200 | 46–69 |
| Tierra recién regada | ≈ 1500–1700 | 74–86 |
| Dentro de un vaso con agua | ≈ 1250 | 100 (RAW_WET) |
Cómo elegir el umbral de riego según tu planta
| Tipo de planta | Umbral de riego | Nota |
|---|---|---|
| Cactus y suculentas | 15–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 humedad | 55–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:
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}| Parte del código | Qué hace |
|---|---|
| RAW_DRY / RAW_WET | Los dos valores extremos que encontraste al calibrar |
| map() + constrain() | Convierte el valor crudo a 0–100 % y evita que se salga del rango |
| Preferences | Guarda en la flash el umbral, el tiempo de bomba y el de espera |
| soakMin | Espera 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 /water | Guardan 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.
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.
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íntoma | Causa probable | Solución |
|---|---|---|
| La humedad siempre da 0 % o no cambia | Sensor en un pin ADC2 con el Wi-Fi activo | Pasa el sensor a uno de los GPIO 32–39 |
| Las lecturas saltan todo el tiempo | Ruido o sensor mal asentado en la tierra | Promedia 16 lecturas y clava bien el sensor |
| El ESP32 se reinicia cuando arranca la bomba | Caída de voltaje, falta el diodo | Agrega el diodo y un capacitor de 470 µF, usa una fuente de 2 A |
| El relé nunca se suelta | El relé de 5 V no reconoce el HIGH de 3,3 V | Usa un relé compatible con 3,3 V o un MOSFET, revisa RELAY_ACTIVE_LOW |
| La maceta se desborda | Tiempo de espera corto o efecto sifón | Aumenta soakMin, deja la punta de la manguera sobre el nivel del tanque |
| La bomba funciona pero no sale agua | Aire dentro de la bomba o tanque vacío | Sumerge la bomba por completo, revisa el flotador |
| Los ajustes se borran al cortarse la luz | Los valores no se guardan en la flash | Verifica que se ejecuten las líneas con prefs.putInt() |
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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Estación de riego inteligente
Un jardinero que riega solo tus plantas para que no se sequen mientras estás de vacaciones.

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

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.

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.

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.

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.

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.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

