/*
 * ESP32 Solar Drip-Irrigation Controller
 * --------------------------------------
 * Reads a capacitive soil-moisture probe and drives a 12 V pump
 * through a relay. Runs the pump until the soil is wet enough or
 * the safety timeout fires, whichever comes first.
 *
 * Board: ESP32 DevKit V1 (Arduino core for ESP32)
 */

// ---------------- Thresholds and timing (named constants) ----------------

// Raw ADC values from the probe. dryRaw = probe in air, wetRaw = probe in water.
// Calibrate these for YOUR probe (see calibration section below).
const int DRY_RAW = 3200;   // reading when probe is bone dry
const int WET_RAW = 1300;   // reading when probe is in a glass of water

// Moisture thresholds expressed as a percentage of the dry-to-wet span.
const int START_BELOW_PERCENT = 35;   // pump starts when soil drops below this
const int STOP_ABOVE_PERCENT  = 65;   // pump stops once soil reaches this

// Safety and timing
const unsigned long MAX_PUMP_SECONDS   = 300;  // hard cap: 5 minutes of pumping
const unsigned long CHECK_EVERY_SECONDS = 180; // idle poll: every 3 minutes
const unsigned long PUMP_SAMPLE_MS      = 1000; // sample every 1 s while pumping
const unsigned long REST_AFTER_PUMP_SECONDS = 60; // cooldown between cycles

// ---------------- Pin map ----------------
const int SENSOR_PIN = 34;  // ADC1_CH6, input-only
const int RELAY_PIN  = 26;  // drives relay module IN

// Relay module is active-LOW: LOW = pump ON, HIGH = pump OFF.
const int RELAY_ON  = LOW;
const int RELAY_OFF = HIGH;

// ---------------- Globals ----------------
unsigned long pumpStartedAt = 0;
unsigned long lastPumpStoppedAt = 0;
bool pumpRunning = false;

// ---------------- Helpers ----------------

// Average several ADC samples to smooth out pump/electrical noise.
int readRawAveraged() {
  const int samples = 15;
  long total = 0;
  for (int i = 0; i < samples; i++) {
    total += analogRead(SENSOR_PIN);
    delay(5);
  }
  return (int)(total / samples);
}

// Map a raw reading to 0-100 % moisture, clamped.
// Note: raw DECREASES as soil gets wetter, so the mapping is inverted.
int rawToPercent(int raw) {
  long pct = (long)(DRY_RAW - raw) * 100L / (long)(DRY_RAW - WET_RAW);
  if (pct < 0)   pct = 0;
  if (pct > 100) pct = 100;
  return (int)pct;
}

void pumpOn() {
  digitalWrite(RELAY_PIN, RELAY_ON);
  pumpRunning = true;
  pumpStartedAt = millis();
  Serial.println("[PUMP] ON");
}

void pumpOff() {
  digitalWrite(RELAY_PIN, RELAY_OFF);
  pumpRunning = false;
  lastPumpStoppedAt = millis();
  Serial.println("[PUMP] OFF");
}

// ---------------- Setup ----------------
void setup() {
  Serial.begin(115200);
  delay(300);

  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, RELAY_OFF);  // fail-safe: pump off at boot

  analogReadResolution(12);            // 0-4095
  analogSetPinAttenuation(SENSOR_PIN, ADC_11db); // full ~0-3.3 V range

  Serial.println("ESP32 drip-irrigation controller booted.");
  Serial.printf("Start below %d%%, stop above %d%%, max pump %lu s, idle check %lu s\n",
                START_BELOW_PERCENT, STOP_ABOVE_PERCENT,
                MAX_PUMP_SECONDS, CHECK_EVERY_SECONDS);
}

// ---------------- Main loop ----------------
void loop() {
  int raw = readRawAveraged();
  int pct = rawToPercent(raw);

  if (!pumpRunning) {
    // ---- IDLE: check every CHECK_EVERY_SECONDS ----
    Serial.printf("[IDLE] raw=%d  moisture=%d%%\n", raw, pct);

    bool rested = (millis() - lastPumpStoppedAt) >= (REST_AFTER_PUMP_SECONDS * 1000UL);

    if (pct < START_BELOW_PERCENT && rested) {
      pumpOn();
    } else {
      delay(CHECK_EVERY_SECONDS * 1000UL);
    }
  } else {
    // ---- PUMPING: sample every second, stop on target or timeout ----
    unsigned long elapsed = (millis() - pumpStartedAt) / 1000UL;
    Serial.printf("[PUMP] raw=%d  moisture=%d%%  elapsed=%lus\n", raw, pct, elapsed);

    if (pct >= STOP_ABOVE_PERCENT) {
      Serial.println("[STOP] Target moisture reached.");
      pumpOff();
    } else if (elapsed >= MAX_PUMP_SECONDS) {
      Serial.println("[STOP] Safety timeout fired.");
      pumpOff();
    } else {
      delay(PUMP_SAMPLE_MS);
    }
  }
}

void setup() { Serial.begin(115200); analogReadResolution(12);
  analogSetPinAttenuation(34, ADC_11db); }
void loop() {
  long t = 0; for (int i = 0; i < 20; i++) { t += analogRead(34); delay(50); }
  Serial.printf("raw avg = %ld  ->  %d%%\n", t / 20,
    constrain((long)(3200 - (t/20)) * 100L / (3200 - 1300), 0, 100));
  delay(1000);
}