Deep-Sleep Plant Waterer

FIRMWARE & POWER BUDGET

State machine. Deep sleep restarts execution at setup() every wake — there is no persistent loop() — so the whole decision lives there, backed by RTC_DATA_ATTR variables that survive sleep (but not a power-on/EN reset): bootCount, pumpLockedOut, dryRunStrikes, wateringCheckPending, preWaterMoistureRaw. Each wake: read the probe (powered only for the ~100 ms sampling window via PROBE_PWR_PIN), resolve any pending watering check from the previous wake, decide whether to water this wake, then re-arm the timer and sleep.

uint16_t readMoistureAveraged() {
  digitalWrite(PROBE_PWR_PIN, HIGH);
  delay(PROBE_SETTLE_MS);
  uint32_t sum = 0;
  for (int i = 0; i < ADC_SAMPLES; i++) { sum += analogRead(MOISTURE_ADC_PIN); delay(5); }
  digitalWrite(PROBE_PWR_PIN, LOW);   // cut probe power right after sampling
  return (uint16_t)(sum / ADC_SAMPLES);
}

Hysteresis. A capacitive probe reads a higher raw ADC count as soil gets drier. MOISTURE_DRY_RAW = 2800 triggers watering; MIN_MOISTURE_DROP = 150 is the fall in raw counts the next wake’s reading must show for the watering event to count as successful — that comparison, not a fixed wet threshold, is what drives the lockout:

int32_t drop = (int32_t)preWaterMoistureRaw - (int32_t)raw;
if (drop >= MIN_MOISTURE_DROP) {
  dryRunStrikes = 0;
} else if (++dryRunStrikes >= MAX_DRY_RUN_STRIKES) {
  pumpLockedOut = true;   // reservoir/tubing/pump suspected empty or failed
}

Safety. runPumpWithSafetyCap() enforces MAX_PUMP_RUNTIME_MS = 8000 unconditionally — it is a millis() timeout with no feedback early-exit, deliberately, since a single-shot wake-sleep node can’t watch the ADC continuously while the pump runs without abandoning the low-power design. Three consecutive failed waterings (MAX_DRY_RUN_STRIKES = 3) latch pumpLockedOut, which only clears on a power-on/EN reset.

Power budget. Every current figure below is either labeled datasheet-typical or an explicit design assumption — none of it is a field measurement, since the unit hasn’t been deployed (see STATUS). The arithmetic is driven entirely by the firmware’s own numbers:

The standby term alone (23.3 µA) already implies the design decision that matters most: an LDO with a few mA of quiescent current (a generic AMS1117, say) would outweigh the entire modeled budget by roughly three orders of magnitude and make the whole calculation moot — which is why the BOM calls out a low-Iq regulator specifically.

SIMULATION

Wokwi simulates deep sleep faithfully (the sim clock advances through esp_deep_sleep_start() and lets you fast-forward through the 30-minute intervals), so the whole state machine — including the multi-wake dry-run check — is exercisable without hardware:

1. Load sketch.ino + diagram.json into a Wokwi ESP32 project, start the simulation, open the Serial Monitor at 115200 baud.
2. Moisture probe substitution: a potentiometer (pot1) stands in for the capacitive probe — Wokwi has no capacitive soil-probe part. Its wiper feeds GPIO34 and its VCC is switched from GPIO25, exactly like the real probe. Twist it toward the “dry” end to push the raw ADC reading above MOISTURE_DRY_RAW and trigger a watering cycle on the next wake; twist it back to simulate the soil having absorbed water.
3. Pump substitution: a wokwi-relay-module (relay1) stands in for the real MOSFET/relay driver, energized from GPIO27 exactly like the real build. A green LED + 220 Ω resistor across the relay’s switched contacts just gives a visible “pump on” indicator — the real load there is a 5V pump, not an LED.
4. To rehearse the lockout: leave the potentiometer parked “dry” across three watering cycles in a row. The Serial Monitor prints PUMP LOCKED OUT on the third failure, and the relay stops firing until the simulation is reset.

STATUS

Design and Wokwi-simulated only — this has not been built or run on a real plant. The state machine, hysteresis, dry-run lockout, and max-runtime safety all execute correctly in simulation, and the power-budget arithmetic is internally consistent, but the moisture thresholds (MOISTURE_DRY_RAW, MOISTURE_WET_RAW, MIN_MOISTURE_DROP) are design values, not calibrated against a real probe in real soil, and the 80 mA/10 µA current figures are datasheet-typical, not bench-measured on this specific board/regulator combination. Next: bench-calibrate the probe in air/water, select and verify the low-Iq regulator, measure actual awake current on a scope/USB power meter, and re-run the battery-life arithmetic against measured numbers instead of datasheet ones.

USE CASES & APPLICATIONS

The pattern here — read a sensor, make a bounded actuation decision with hardware/firmware safety limits, sleep for the rest of the interval — generalizes past plant watering to any duty-cycled battery IoT node: greenhouse micro-irrigation zones (many nodes, each independent, where a single stuck-pump failure must stay local), remote environmental/soil sensing nodes that only need to report on a slow cadence, and livestock-trough or rain-barrel level control where a pump/valve needs the same max-runtime-plus-feedback safety structure. The specific lesson worth reusing elsewhere: computing the battery budget from the firmware’s actual duty cycle (not a spec-sheet “years of battery life” claim) is what turns a plausible-sounding low-power design into one whose numbers can be checked.

FILES

• sketch.ino — full firmware: RTC-persisted state machine, averaged ADC read, hysteresis watering decision, hard max-runtime pump safety, dry-run lockout, timer-based deep sleep.
• diagram.json — Wokwi circuit (ESP32 DevKitC-V4 + potentiometer probe stand-in + relay module pump-driver stand-in + LED pump indicator).
• README.md — Wokwi simulation walkthrough and real-build notes (capacitive vs. resistive probes, switched probe power, low-Iq regulator choice, pump driver wiring).

Paths: sources/electronics/plant-waterer/sketch.ino, sources/electronics/plant-waterer/diagram.json, sources/electronics/plant-waterer/README.md.