Умный дом #6: Умный полив на ESP32

Автоматический полив на ESP32 — практичный проект, который помогает поддерживать здоровое состояние растений дома и на участках. В этой статье мы соберём систему на базе ESP32 с датчиком влажности почвы и реле для насоса: реализуем автоматический режим по порогу влажности, ручной режим, а также удобное WEB-управление с телефона/ПК. Приведём полностью рабочий код и разберём ключевые нюансы — от подключения датчика до защиты насоса от «закипания» и частых включений.

Список оборудования и компонентов

ESP32 DevKit (с поддержкой Wi-Fi).
Датчик влажности почвы — рекомендуется ёмкостной (capacitive soil moisture sensor) на 3.3 В. Он долговечнее резистивных «вилок» и меньше подвержен коррозии.
Реле/модуль реле для управления насосом:
- Для DC-насоса 5–12–24 В — лучше использовать транзисторный ключ (MOSFET) с обратным диодом на катушке/моторе.
- Для AC 220 В — твердотельное реле (SSR) или модуль реле с оптронной развязкой и отсечкой дуги. Соблюдайте электробезопасность!
Насос (погружной или поверхностный) под ваше напряжение.
Блок питания соответствующей мощности (для ESP32 — 5 В; для насоса — по паспорту).
Соединительные провода, клеммы, при необходимости — корпус/бокс IP-класса.
По желанию: MOSFET-ключ для питания датчика от GPIO (через транзистор) — чтобы уменьшить коррозию, подавая питание только на время измерения.

Схема подключения и принцип работы

Система состоит из трёх частей: ESP32 (мозг), датчик влажности (измерение), исполнительный модуль (реле/транзистор для насоса). ESP32 периодически опрашивает датчик, вычисляет текущую влажность в процентах и принимает решение: если режим Auto и влажность ниже порога — включить насос. Насос работает до достижения порога (с гистерезисом) или до максимального времени полива (защита от «залипания»/сухого хода). Между поливами выдерживается «охлаждение» (cooldown), чтобы избежать частых стартов.

Рекомендуемые пины (можно менять):

Сигнал	ESP32 пин	Примечание
Датчик влажности — аналоговый выход	`GPIO34` (ADC1)	Вход только на чтение; типичные ёмкостные датчики работают от 3.3 В
Питание датчика (через ключ)	`GPIO25`	GPIO управляет MOSFET/транзистором, подающим 3.3 В на датчик только на время измерения
Реле насоса / MOSFET-ключ	`GPIO26`	Часто реле — active LOW; уточните ваш модуль
GND	GND	Общий «минус» для ESP32, датчика и ключа

Важно: не подавайте 5 В на аналоговый выход датчика, если он подключен к ADC ESP32. Для многих ёмкостных датчиков корректно питание от 3.3 В. Если используете DC-насос, установите диод Шоттки параллельно мотору (обратной полярностью) для гашения ЭДС самоиндукции. При работе с 220 В — используйте правильную розетку/корпус, клеммы, заземление и соблюдайте нормы электробезопасности.

Пример кода (ESP32 + датчик влажности + реле насоса + WEB)

Код реализует авто/ручной режимы, защиту по времени, «охлаждение» между поливами и простую веб-страницу со статусом и настройками. Тайминги и режим сохраняются в NVS, переживают перезагрузку.

// ====== ESP32 Smart Irrigation (Soil Moisture + Pump + Web UI) ======
#include <WiFi.h>
#include <WebServer.h>
#include <Preferences.h>

// ------- Wi-Fi -------
const char* WIFI_SSID     = "YOUR_SSID";
const char* WIFI_PASSWORD = "YOUR_PASSWORD";

// ------- Pins (change to your wiring) -------
const int PIN_MOISTURE_ADC = 34;   // ADC1 input (GPIO34)
const int PIN_SENSOR_PWR   = 25;   // drives transistor/MOSFET that powers sensor
const int PIN_RELAY        = 26;   // relay / MOSFET to pump
const bool RELAY_ACTIVE_LOW = true;

// ------- Preferences (NVS) keys -------
Preferences prefs;
const char* NS = "irrigation";
const char* K_MODE = "mode";           // 0=auto, 1=manual
const char* K_THRESH = "thresh";       // % soil moisture
const char* K_COOL_S = "cool_s";       // cooldown seconds
const char* K_MAXON_S = "maxon_s";     // max pump on seconds

// ------- Settings (defaults) -------
enum Mode : uint8_t { MODE_AUTO=0, MODE_MANUAL=1 };
Mode mode = MODE_AUTO;
int  threshold_pct = 35;               // start watering below this (%)
int  hysteresis_pct = 5;               // stop at threshold + hysteresis
unsigned long cooldown_ms = 15UL*60UL*1000UL; // 15 min between runs
unsigned long max_on_ms   = 30UL*1000UL;      // 30 sec max pumping

// ------- Moisture calibration (tune for your sensor) -------
int ADC_DRY = 3200;  // ADC value when completely dry
int ADC_WET = 1700;  // ADC value when fully wet (lower is wetter on many sensors)

// ------- Runtime state -------
WebServer server(80);
bool pumpOn = false;
unsigned long pumpStart = 0;
unsigned long lastWaterStop = 0;

// Simple moving average of ADC to reduce noise
const int AVG_N = 8;
int samples[AVG_N]; int sp = 0; bool bufFilled = false;

void pumpWrite(bool on) {
  pumpOn = on;
  if (RELAY_ACTIVE_LOW) digitalWrite(PIN_RELAY, on ? LOW : HIGH);
  else                  digitalWrite(PIN_RELAY, on ? HIGH : LOW);
  if (on) pumpStart = millis();
  else    lastWaterStop = millis();
}

int readADC() {
  // Power sensor only while reading (via transistor)
  digitalWrite(PIN_SENSOR_PWR, HIGH);
  delay(40); // give sensor time to settle
  long sum = 0;
  for (int i=0;i<10;i++){ sum += analogRead(PIN_MOISTURE_ADC); delay(5); }
  digitalWrite(PIN_SENSOR_PWR, LOW);
  return (int)(sum/10);
}

int adcToPercent(int raw) {
  // Map dry..wet to 0..100, clamp
  long p = map(raw, ADC_DRY, ADC_WET, 0, 100);
  if (p < 0) p = 0; if (p > 100) p = 100;
  return (int)p;
}

int readMoisturePercent() {
  int raw = readADC();
  samples[sp++] = raw; if (sp==AVG_N){ sp=0; bufFilled=true; }
  long sum=0; int n = bufFilled?AVG_N:sp;
  for (int i=0;i<n;i++) sum += samples[i];
  int avg = (int)(sum/n);
  return adcToPercent(avg);
}

// ---------- Web ----------
String htmlPage() {
  String s;
  s.reserve(4000);
  s += F("<!DOCTYPE html><html><head><meta charset='utf-8'><meta name='viewport' content='width=device-width, initial-scale=1'>");
  s += F("<title>ESP32 Smart Irrigation</title><style>");
  s += F("body{font-family:Verdana,Arial,sans-serif;max-width:780px;margin:24px auto;line-height:1.6} h1{font-size:20px}");
  s += F(".box{border:1px solid #ddd;padding:12px;border-radius:8px;margin:12px 0}");
  s += F(".row{display:flex;gap:12px;align-items:center;flex-wrap:wrap}");
  s += F("button,input,select{font-size:14px;padding:8px} .chip{display:inline-block;padding:4px 10px;border-radius:999px;color:#fff;font-weight:bold}");
  s += F(".ok{background:#2e7d32}.warn{background:#ef6c00}.off{background:#9e9e9e}.mono{font-family:monospace}");
  s += F("</style></head><body>");
  s += F("<h1>Умный полив на ESP32</h1>");

  s += F("<div class='box'><h3>Статус</h3><div class='row'>");
  s += F("<div>Влажность: <span id='moist' class='mono'>—</span> %</div>");
  s += F("<div>Насос: <span id='pump' class='chip off'>—</span></div>");
  s += F("<div>Режим: <span id='mode' class='chip off'>—</span></div>");
  s += F("<div>Порог: <span id='thr' class='mono'>—</span> %</div>");
  s += F("</div></div>");

  s += F("<div class='box'><h3>Настройки</h3><div class='row'>");
  s += F("<label>Режим: <select id='selmode' onchange='setMode()'><option value='auto'>Auto</option><option value='manual'>Manual</option></select></label>");
  s += F("<label>Порог, %: <input id='thrIn' type='number' min='1' max='99' value='35' onblur='setThr()'></label>");
  s += F("<label>Cooldown, c: <input id='coolIn' type='number' min='0' max='86400' value='900' onblur='setCool()'></label>");
  s += F("<label>Max ON, c: <input id='maxIn' type='number' min='1' max='3600' value='30' onblur='setMax()'></label>");
  s += F("</div></div>");

  s += F("<div class='box'><h3>Ручное управление</h3><div class='row'>");
  s += F("<button onclick='pump(1)'>Включить насос</button>");
  s += F("<button onclick='pump(0)'>Выключить насос</button>");
  s += F("</div></div>");

  s += F("<script>");
  s += F("function cls(el,c){el.className='chip '+c;}");
  s += F("function upd(){fetch('/status').then(r=>r.json()).then(s=>{");
  s += F("document.getElementById('moist').textContent=s.moist_pct;");
  s += F("document.getElementById('thr').textContent=s.thr;");
  s += F("document.getElementById('selmode').value = s.mode?'manual':'auto';");
  s += F("const m=document.getElementById('mode'); m.textContent=s.mode?'MANUAL':'AUTO'; cls(m, s.mode?'warn':'ok');");
  s += F("const p=document.getElementById('pump'); p.textContent=s.pump?'ON':'OFF'; cls(p, s.pump?'ok':'off');");
  s += F("document.getElementById('thrIn').value=s.thr; document.getElementById('coolIn').value=s.cool_s; document.getElementById('maxIn').value=s.maxon_s;");
  s += F("});}");
  s += F("function setMode(){const v=document.getElementById('selmode').value; fetch('/setmode?mode='+v).then(upd);}");
  s += F("function setThr(){const v=document.getElementById('thrIn').value; fetch('/set?thr='+v).then(upd);}");
  s += F("function setCool(){const v=document.getElementById('coolIn').value; fetch('/set?cool='+v).then(upd);}");
  s += F("function setMax(){const v=document.getElementById('maxIn').value; fetch('/set?max='+v).then(upd);}");
  s += F("function pump(on){fetch('/pump?cmd='+(on?1:0)).then(upd);} upd(); setInterval(upd,2000);");
  s += F("</script></body></html>");
  return s;
}

void sendStatus() {
  int moist = readMoisturePercent();
  String j = "{";
  j += "\"moist_pct\":" + String(moist) + ",";
  j += "\"pump\":" + String(pumpOn ? 1:0) + ",";
  j += "\"mode\":" + String((int)mode) + ",";
  j += "\"thr\":" + String(threshold_pct) + ",";
  j += "\"cool_s\":" + String(cooldown_ms/1000) + ",";
  j += "\"maxon_s\":" + String(max_on_ms/1000);
  j += "}";
  server.send(200, "application/json", j);
}

void handleSet() {
  bool changed=false;
  if (server.hasArg("thr")) {
    int t = server.arg("thr").toInt();
    if (t<1) t=1; if (t>98) t=98;
    threshold_pct = t; changed=true;
  }
  if (server.hasArg("cool")) {
    long s = server.arg("cool").toInt();
    if (s<0) s=0; if (s>86400) s=86400;
    cooldown_ms = (unsigned long)s*1000UL; changed=true;
  }
  if (server.hasArg("max")) {
    long s = server.arg("max").toInt();
    if (s<1) s=1; if (s>3600) s=3600;
    max_on_ms = (unsigned long)s*1000UL; changed=true;
  }
  if (changed) {
    prefs.begin(NS,false);
    prefs.putUInt(K_THRESH, (uint32_t)threshold_pct);
    prefs.putUInt(K_COOL_S, (uint32_t)(cooldown_ms/1000));
    prefs.putUInt(K_MAXON_S, (uint32_t)(max_on_ms/1000));
    prefs.end();
  }
  sendStatus();
}

void handleSetMode() {
  String m = server.arg("mode");
  if (m=="auto")  mode = MODE_AUTO;
  else            mode = MODE_MANUAL;
  prefs.begin(NS,false);
  prefs.putUChar(K_MODE, (uint8_t)mode);
  prefs.end();
  sendStatus();
}

void handlePump() {
  int cmd = server.arg("cmd").toInt();
  // Разрешим ручное управление всегда (если хотите — ограничьте им MODE_MANUAL)
  pumpWrite(cmd ? true:false);
  sendStatus();
}

void setup() {
  Serial.begin(115200);
  pinMode(PIN_SENSOR_PWR, OUTPUT); digitalWrite(PIN_SENSOR_PWR, LOW); // датчик изначально обесточен
  pinMode(PIN_RELAY, OUTPUT);
  pumpWrite(false);

  // ADC setup (опционно можно установить аттенюацию)
  analogReadResolution(12);

  // Load prefs
  prefs.begin(NS,true);
  mode = (Mode)prefs.getUChar(K_MODE, MODE_AUTO);
  threshold_pct = prefs.getUInt(K_THRESH, threshold_pct);
  cooldown_ms = (unsigned long)prefs.getUInt(K_COOL_S, cooldown_ms/1000)*1000UL;
  max_on_ms   = (unsigned long)prefs.getUInt(K_MAXON_S, max_on_ms/1000)*1000UL;
  prefs.end();

  // Wi-Fi
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("WiFi connecting");
  while (WiFi.status()!=WL_CONNECTED){ delay(400); Serial.print("."); }
  Serial.print("\nIP: "); Serial.println(WiFi.localIP());

  // HTTP routes
  server.on("/", [](){ server.send(200, "text/html; charset=utf-8", htmlPage()); });
  server.on("/status", [](){ sendStatus(); });
  server.on("/set", [](){ handleSet(); });
  server.on("/setmode", [](){ handleSetMode(); });
  server.on("/pump", [](){ handlePump(); });
  server.begin();
  Serial.println("HTTP server started");
}

void loop() {
  server.handleClient();

  // Automatic control
  int moist = readMoisturePercent();
  unsigned long now = millis();

  if (mode==MODE_AUTO) {
    // cooldown protection
    bool cooldownOK = (lastWaterStop==0) || (now - lastWaterStop >= cooldown_ms);

    if (!pumpOn) {
      if (cooldownOK && moist <= (threshold_pct - hysteresis_pct)) {
        pumpWrite(true);
      }
    } else {
      bool reached = (moist >= (threshold_pct + hysteresis_pct));
      bool overtime = (now - pumpStart >= max_on_ms);
      if (reached || overtime) {
        pumpWrite(false);
      }
    }
  } else {
    // Manual: ничего не делаем, помпа управляется из веб-интерфейса
  }

  // Небольшая пауза между циклами опроса датчика
  delay(150);
}

Короткое объяснение кода

Чтение влажности: датчик питается только во время измерения (PIN_SENSOR_PWR), затем производится несколько чтений ADC и усреднение. Сырые значения калибруются в проценты с помощью пар ADC_DRY/ADC_WET (подберите под ваш датчик).
Режимы: MODE_AUTO включает насос при влажности ниже порога (с гистерезисом), отключает при достижении порога или по истечении Max ON. Между циклами соблюдается Cooldown. В MODE_MANUAL насос управляется только из WEB.
WEB-интерфейс: корневая страница показывает статус (влажность, режим, состояние насоса) и позволяет менять порог/тайминги/режим. Обновление — запросом /status каждые 2 секунды. Ручные команды — /pump?cmd=1|0.
Хранение настроек: порог и тайминги сохраняются в NVS (Preferences) и восстанавливаются при старте.
Безопасность: логика ограничивает максимальное непрерывное время работы насоса и предотвращает «дёрганье» частыми включениями.

Применение и расширение проекта

Капельный полив комнатных растений и грядок: стабильная подача небольших доз воды, защита от пересушивания и перелива.
Мультисекция: расширьте проект несколькими каналами (несколько датчиков/насосов) и общим WEB-интерфейсом с вкладками.
MQTT и Home Assistant: добавьте публикацию показаний и состояния в брокер, настройте автоматизации по расписанию и уведомления в Telegram.
Графики: отправляйте данные во временное хранилище (InfluxDB) и визуализируйте в Grafana или ThingsBoard.
Датчик уровня бака и защита от сухого хода: запрет включения насоса при пустом резервуаре, сигнализация о низком уровне.
Климат-зависимый полив: учитывайте прогноз погоды/осадки (через облачный API) и корректируйте пороги.
Журнал событий: логируйте время поливов, длительность, влажность до/после — это поможет калибровать систему.
Питание датчика по расписанию: если датчик «шумный», читайте реже и дольше «прогревайте» перед чтением.

Заключение

Мы собрали полноценный контроллер полива на базе ESP32 с датчиком влажности почвы, реле насоса, автоматическим и ручным режимами и удобным WEB-управлением. Проект легко адаптируется: меняйте пороги и тайминги под конкретные растения, добавляйте MQTT/графики, подключайте дополнительные датчики. Такой модуль хорошо подходит как для домашнего применения, так и для лабораторных или учебных стендов.

Если вам нужен индивидуальный проект — разработка схемы, печатной платы, прошивки и корпуса под ваши требования — мы можем помочь. Создаём надёжные решения на ESP32 и берём на себя изготовление плат и сборку. Посмотрите примеры в нашем портфолио и напишите нам — обсудим задачу.