Smart Irrigation with ESP8266: Full Build Log and Firmware

A soil-moisture sensor, a relay and a Wi-Fi board make a demo. Making it survive a season outdoors is a different project — one where the capacitive sensor matters more than the code, the pump needs its own supply, and the firmware has to assume the Wi-Fi will disappear.

This is the full build log for the eARgle smart irrigation node: bill of materials with real part choices, the wiring that avoids the ESP8266 boot traps, calibration procedure, the complete firmware with fail-safes, and what actually went wrong across eight weeks of running it on a rooftop garden in Vellore.

• Board ESP8266 (NodeMCU)
• Sensor Capacitive v2.0
• Pump 12 V, 5 W
• Build time ~3 hours
• Runtime 8 weeks tested
• Level Intermediate

What the node has to do

Written as requirements before any hardware was bought — which is the step most project builds skip:

• Water a 2 m × 1 m raised bed when the soil dries past a set point, not on a clock.
• Never run the pump for more than 90 seconds in one go, and never more than twice an hour, even if the sensor fails.
• Keep working with no internet: Wi-Fi is for telemetry and manual override, not for the control loop.
• Report moisture, pump runtime and uptime so a dead sensor is visible remotely.
• Survive 40 °C afternoons, monsoon humidity and the occasional direct splash.

Bill of materials — and the two parts not to cheap out on

Wiring and power architecture

Power: the 12 V adapter feeds the pump side directly and an LM2596 buck module steps it to 5 V for the NodeMCU’s VIN. Grounds are joined at one point next to the buck module, not daisy-chained through the relay board. The flyback diode goes across the pump terminals, banded end to +12 V. With this arrangement the pump’s switch-off spike stops reaching the ESP8266 at all; without it, expect a reset every few cycles and hours of blaming the firmware.

Calibrating the moisture sensor properly

A capacitive sensor gives you an arbitrary ADC number, not a percentage. Calibration is two readings and takes five minutes — and without it your threshold is a guess:

1. Dry readingHold the probe in air, or in a cup of bone-dry soil. Log the raw ADC value. On our NodeMCU + capacitive v2.0: ~790.
2. Wet readingInsert the probe into a glass of water up to the marked line only — never past it, the top of the board is not waterproof. Ours: ~370.
3. Map, remembering the sensor is invertedHigher ADC means drier. moisture% = map(raw, dry, wet, 0, 100).
4. Find the real set point in the bedWater thoroughly, then log moisture every 30 minutes for two days. The percentage at which the plants first look thirsty is your threshold — for our loam-and-compost mix it was 38 %, not the 50 % we had assumed.

Firmware, with the fail-safes that matter

The sketch below is the control core, trimmed of telemetry specifics so you can point it at whatever backend you use. The important parts are not the watering logic — they are the four guards: sensor sanity, maximum run time, minimum interval, and daily cap.

ESP8266 · irrigation control core

#include <ESP8266WiFi.h>

// ---- calibration (from the steps above) ----
const int RAW_DRY = 790;
const int RAW_WET = 370;

// ---- policy ----
const int           THRESHOLD_PCT   = 38;      // water below this
const int           TARGET_PCT      = 55;      // stop above this
const unsigned long MAX_RUN_MS      = 90UL * 1000UL;
const unsigned long MIN_GAP_MS      = 30UL * 60UL * 1000UL;
const uint8_t       MAX_CYCLES_DAY  = 6;

const uint8_t PIN_RELAY = 14;   // D5
const uint8_t PIN_SENSE = A0;

bool          pumping      = false;
unsigned long pumpStart    = 0;
unsigned long lastPumpEnd  = 0;
uint8_t       cyclesToday  = 0;
unsigned long dayStart     = 0;

int readMoisturePct() {
  long sum = 0;                          // 8 samples, 20 ms apart
  for (uint8_t i = 0; i < 8; i++) { sum += analogRead(PIN_SENSE); delay(20); }
  int raw = sum / 8;
  if (raw < 150 || raw > 1000) return -1;     // open circuit / shorted probe
  int pct = map(raw, RAW_DRY, RAW_WET, 0, 100);
  return constrain(pct, 0, 100);
}

void pumpOn()  { digitalWrite(PIN_RELAY, HIGH); pumping = true;  pumpStart = millis(); cyclesToday++; }
void pumpOff() { digitalWrite(PIN_RELAY, LOW);  pumping = false; lastPumpEnd = millis(); }

void setup() {
  pinMode(PIN_RELAY, OUTPUT);
  digitalWrite(PIN_RELAY, LOW);          // pump off before anything else
  Serial.begin(115200);
  dayStart = millis();
  // WiFi.begin(...) — telemetry only; the loop below never waits for it
}

void loop() {
  if (millis() - dayStart >= 24UL * 3600UL * 1000UL) { dayStart = millis(); cyclesToday = 0; }

  int pct = readMoisturePct();

  // GUARD 1 — a failed sensor must never water
  if (pct < 0) {
    if (pumping) pumpOff();
    Serial.println(F("SENSOR FAULT - pump inhibited"));
    delay(5000);
    return;
  }

  if (pumping) {
    // GUARD 2 — hard ceiling on a single run
    if (millis() - pumpStart >= MAX_RUN_MS) { pumpOff(); Serial.println(F("max run reached")); }
    else if (pct >= TARGET_PCT)             { pumpOff(); Serial.println(F("target reached")); }
  } else {
    bool dry      = pct < THRESHOLD_PCT;
    bool rested   = (lastPumpEnd == 0) || (millis() - lastPumpEnd >= MIN_GAP_MS);  // GUARD 3
    bool quotaOk  = cyclesToday < MAX_CYCLES_DAY;                                  // GUARD 4
    if (dry && rested && quotaOk) pumpOn();
  }

  Serial.printf("moisture %d%%  pump %s  cycles %u\n", pct, pumping ? "ON" : "off", cyclesToday);
  delay(2000);
}

Eight weeks of field results

Water use over the eight weeks came out roughly 30–40 % below the previous fixed-timer schedule for the same bed, almost entirely because the node skips watering after rain — the case a timer can never handle.

What we would change next

• Move to an ESP32-C3 and a battery. The node is mains-powered only because the ESP8266 dev board’s sleep current makes battery operation pointless. A C3 sleeping at microamps between 15-minute checks would run for a season on a cell — see the board comparison for the numbers.
• Two probes, not one. One at 5 cm and one at 15 cm tells you whether water is reaching the roots. That needs a second ADC channel — an ADS1115, or simply the ESP32.
• A flow sensor on the outlet. Runtime is a proxy for water delivered; a blocked dripper or an empty tank looks identical to a healthy cycle without one.
• Rain forecast as a veto. Cheap to add once telemetry exists, and the safest kind of cloud dependency: it can only prevent watering, never cause it.

Frequently asked questions