Smart Water Pump Controller

#include <Arduino.h>
// ============================================================
//  Smart Water Pump Controller  —  ESP32 + Blynk
//  Base Model: PZEM-004T | JSN-SR04T | SS Probes | DS3231
// ============================================================
//  FUTURE UPGRADE PINS (defined but not active in base code)
//  - DS18B20 temperature  :  GPIO 4  (1-Wire, 4.7K pullup on PCB)
//  - ZMPT101B AC voltage  :  GPIO 34 (ADC, unpopulated header)
//  - SD Card CS           :  GPIO 13 (SPI, unpopulated header)
//  - OLED I2C             :  GPIO 21/22 (shares bus with RTC)
// ============================================================

// ── Blynk credentials ───────────────────────────────────────
// Replace with your own from the Blynk app
#define BLYNK_TEMPLATE_ID   "TMPLxxxxxxxxxx"
#define BLYNK_TEMPLATE_NAME "SmartPumpCtrl"
#define BLYNK_AUTH_TOKEN    "YourBlynkAuthTokenHere"

// ── Blynk Virtual Pin Map ───────────────────────────────────
// V0  → Pump ON/OFF button (Blynk → device)
// V1  → Voltage (V) display
// V2  → Current (A) display
// V3  → Power (W) display
// V4  → Energy (kWh) display
// V5  → Tank level % display
// V6  → Time ON (HH:MM:SS) display
// V7  → Status string (RUNNING / DRY-RUN / PROTECTION etc.)
// V8  → Over-voltage threshold (Blynk → device), default 250V
// V9  → Under-voltage threshold (Blynk → device), default 180V
// V10 → Tank FULL threshold % (Blynk → device), default 90%
// V11 → Tank LOW threshold %  (Blynk → device), default 20%
// V12 → Current time from RTC (display)
// V13 → WASA probe raw state (0=water / 1=dry)
// V14 → Suction probe raw state (0=water / 1=dry)

// ── Includes ────────────────────────────────────────────────
#define BLYNK_PRINT Serial
#include <WiFi.h>
#include <BlynkSimpleEsp32.h>
#include <PZEM004Tv30.h>
#include <NewPing.h>
#include <Wire.h>
#include <RTClib.h>

// ── WiFi credentials ────────────────────────────────────────

// Forward declarations
void setPump(bool on);
String formatTime(unsigned long ms);
void pollSensors();

const char* WIFI_SSID     = "YourWiFiSSID";
const char* WIFI_PASSWORD = "YourWiFiPassword";

// ── Hardware Pin Definitions ────────────────────────────────
// Active in base code:
#define PZEM_RX_PIN      16   // Serial2 RX ← PZEM TX
#define PZEM_TX_PIN      17   // Serial2 TX → PZEM RX
#define TRIG_PIN         25   // JSN-SR04T TRIG
#define ECHO_PIN         26   // JSN-SR04T ECHO
#define RELAY_PIN        27   // 5V Relay IN (LOW = ON via optocoupler)
#define PROBE_WASA_PIN   32   // BC547 collector — WASA line probe
#define PROBE_SUCTION_PIN 33  // BC547 collector — Suction/sump probe

// Reserved for future population (no code using them in base):
#define DS18B20_PIN       4   // FUTURE: 1-Wire temp sensors (4.7K pullup on PCB)
#define ZMPT101B_PIN     34   // FUTURE: AC voltage analog sensor
#define SD_CS_PIN        13   // FUTURE: SD card SPI CS
// OLED & RTC share I2C GPIO21(SDA)/GPIO22(SCL) — OLED header already parallel

// ── Constants ───────────────────────────────────────────────
#define TANK_HEIGHT_CM         200   // Total tank height in cm — ADJUST FOR YOUR TANK
#define SENSOR_OFFSET_CM        10   // Distance from sensor face to max-water surface
#define MAX_DISTANCE_CM        250   // NewPing max range
#define DRY_RUN_COOLDOWN_MS  300000UL // 5-minute dry-run cooldown (ms)
#define BLYNK_UPDATE_MS       2000UL  // Blynk push interval
#define SENSOR_UPDATE_MS       500UL  // Local sensor poll interval

// ── Global Objects ──────────────────────────────────────────
PZEM004Tv30 pzem(Serial2, PZEM_RX_PIN, PZEM_TX_PIN);
NewPing sonar(TRIG_PIN, ECHO_PIN, MAX_DISTANCE_CM);
RTC_DS3231 rtc;
BlynkTimer timer;

// ── State Variables ─────────────────────────────────────────
bool pumpEnabled      = false;   // User intent from Blynk
bool pumpRunning      = false;   // Actual relay state
bool dryRunLocked     = false;   // In cooldown after dry-run
bool overvoltProtect  = false;   // OVP triggered
bool undervoltProtect = false;   // UVP triggered

unsigned long dryRunLockTime = 0;  // When dry-run cooldown started
unsigned long pumpOnTime     = 0;  // millis() when pump last started
unsigned long pumpOnAccum    = 0;  // Accumulated ON-time this session (ms)

// Adjustable thresholds (can be changed via Blynk sliders)
float threshOV   = 250.0f;  // Over-voltage limit (V)
float threshUV   = 180.0f;  // Under-voltage limit (V)
int   threshFull = 90;      // Tank full % → stop pump
int   threshLow  = 20;      // Tank low %  → auto-start pump

// Live PZEM readings
float pzemVoltage  = 0, pzemCurrent = 0;
float pzemPower    = 0, pzemEnergy  = 0;
float pzemFreq     = 0, pzemPF      = 0;

// Tank level
int tankPercent = 0;

// ── Helper: Relay Control ────────────────────────────────────
void setPump(bool on) {
  if (on && !pumpRunning) {
    digitalWrite(RELAY_PIN, LOW);   // Active LOW relay
    pumpOnTime   = millis();
    pumpRunning  = true;
  } else if (!on && pumpRunning) {
    digitalWrite(RELAY_PIN, HIGH);
    pumpOnAccum += millis() - pumpOnTime;
    pumpRunning  = false;
  }
}

// ── Helper: Format seconds to HH:MM:SS ──────────────────────
String formatTime(unsigned long ms) {
  unsigned long secs = ms / 1000;
  unsigned int h = secs / 3600;
  unsigned int m = (secs % 3600) / 60;
  unsigned int s = secs % 60;
  char buf[12];
  snprintf(buf, sizeof(buf), "%02u:%02u:%02u", h, m, s);
  return String(buf);
}

// ── Sensor Poll ─────────────────────────────────────────────
void pollSensors() {
  // — PZEM-004T —
  float v = pzem.voltage();
  float i = pzem.current();
  float p = pzem.power();
  float e = pzem.energy();
  float f = pzem.frequency();
  float pf = pzem.pf();

  if (!isnan(v)) pzemVoltage  = v;
  if (!isnan(i)) pzemCurrent  = i;
  if (!isnan(p)) pzemPower    = p;
  if (!isnan(e)) pzemEnergy   = e;
  if (!isnan(f)) pzemFreq     = f;
  if (!isnan(pf)) pzemPF      = pf;

  // Over/Under Voltage Protection
  if (pzemVoltage > 0) {
    overvoltProtect  = (pzemVoltage > threshOV);
    undervoltProtect = (pzemVoltage < threshUV && pzemVoltage > 50); // ignore 0V (no reading)
  }

  // — JSN-SR04T Tank Level —
  unsigned int distCm = sonar.ping_cm();
  if (distCm > 0 && distCm < MAX_DISTANCE_CM) {
    int waterCm = TANK_HEIGHT_CM - (distCm - SENSOR_OFFSET_CM);
    waterCm = constrain(waterCm, 0, TANK_HEIGHT_CM);
    tankPercent = map(waterCm, 0, TANK_HEIGHT_CM, 0, 100);
  }

  // — SS Probes (BC547 NPN: HIGH = dry, LOW = water present) —
  bool wasaWater    = (digitalRead(PROBE_WASA_PIN)   == LOW);  // WASA supply present
  bool suctionWater = (digitalRead(PROBE_SUCTION_PIN) == LOW); // Sump/suction has water

  // Dry-run cooldown management
  if (dryRunLocked) {
    if (millis() - dryRunLockTime >= DRY_RUN_COOLDOWN_MS) {
      dryRunLocked = false;
      Serial.println("[INFO] Dry-run cooldown expired, allowing retry.");
    }
  }

  // — Pump Decision Logic —
  // Priority: OVP/UVP > Dry-run lock > Tank full > User intent + probes
  bool shouldRun = false;
  if (!overvoltProtect && !undervoltProtect && !dryRunLocked) {
    if (pumpEnabled) {
      // Auto-stop if tank is full
      if (tankPercent >= threshFull) {
        shouldRun = false;
        pumpEnabled = false;
        Blynk.virtualWrite(V0, 0);
      } else if (!wasaWater) {
        // WASA line dry — trigger dry-run protection
        if (pumpRunning) {
          Serial.println("[WARN] WASA dry-run detected! Locking out for 5 min.");
          dryRunLocked    = true;
          dryRunLockTime  = millis();
          shouldRun       = false;
        }
      } else if (!suctionWater) {
        // Suction sump dry — trigger dry-run protection
        if (pumpRunning) {
          Serial.println("[WARN] Suction dry-run detected! Locking out for 5 min.");
          dryRunLocked    = true;
          dryRunLockTime  = millis();
          shouldRun       = false;
        }
      } else {
        shouldRun = true;
      }
    }
    // Auto-start if tank is low and WASA + suction both have water
    if (!pumpEnabled && tankPercent <= threshLow && wasaWater && suctionWater) {
      shouldRun   = true;
      pumpEnabled = true;
      Blynk.virtualWrite(V0, 1);
    }
  }

  setPump(shouldRun);

  // Status string
  String status;
  if (overvoltProtect)      status = "⚡ OVP TRIP";
  else if (undervoltProtect) status = "⚡ UVP TRIP";
  else if (dryRunLocked)    status = "🔒 DRY-RUN COOLDOWN";
  else if (pumpRunning)      status = "✅ PUMP RUNNING";
  else if (!pumpEnabled)     status = "⏸ STANDBY";
  else                       status = "⚠ WAITING";

  // — Blynk Updates (write here to avoid second timer collision) —
  Blynk.virtualWrite(V1, pzemVoltage);
  Blynk.virtualWrite(V2, pzemCurrent);
  Blynk.virtualWrite(V3, pzemPower);
  Blynk.virtualWrite(V4, pzemEnergy);
  Blynk.virtualWrite(V5, tankPercent);
  Blynk.virtualWrite(V7, status);
  Blynk.virtualWrite(V13, wasaWater    ? 0 : 1);
  Blynk.virtualWrite(V14, suctionWater ? 0 : 1);

  // Pump ON time
  unsigned long totalOnMs = pumpOnAccum + (pumpRunning ? (millis() - pumpOnTime) : 0);
  Blynk.virtualWrite(V6, formatTime(totalOnMs));

  // RTC time
  DateTime now = rtc.now();
  char tbuf[10];
  snprintf(tbuf, sizeof(tbuf), "%02d:%02d:%02d", now.hour(), now.minute(), now.second());
  Blynk.virtualWrite(V12, String(tbuf));

  // Serial debug
  Serial.printf("[PZEM] V=%.1fV  I=%.3fA  P=%.1fW  E=%.3fkWh  F=%.1fHz  PF=%.2f\n",
                pzemVoltage, pzemCurrent, pzemPower, pzemEnergy, pzemFreq, pzemPF);
  Serial.printf("[TANK] %d cm → %d%%  [WASA:%s SUCT:%s] [PUMP:%s]\n",
                distCm, tankPercent,
                wasaWater ? "OK" : "DRY", suctionWater ? "OK" : "DRY",
                pumpRunning ? "ON" : "OFF");
}

// ── Blynk Callbacks ─────────────────────────────────────────
// V0 — Manual Pump Button
BLYNK_WRITE(V0) {
  int val = param.asInt();
  pumpEnabled = (val == 1);
  if (!pumpEnabled) setPump(false);   // Immediate OFF on manual press
  Serial.printf("[BLYNK] Manual pump %s\n", pumpEnabled ? "ENABLED" : "DISABLED");
}

// V8 — Over-voltage threshold
BLYNK_WRITE(V8) { threshOV   = param.asFloat(); }

// V9 — Under-voltage threshold
BLYNK_WRITE(V9) { threshUV   = param.asFloat(); }

// V10 — Tank full %
BLYNK_WRITE(V10) { threshFull = param.asInt(); }

// V11 — Tank low %
BLYNK_WRITE(V11) { threshLow  = param.asInt(); }

// ── Setup ────────────────────────────────────────────────────
void setup() {
  Serial.begin(115200);
  Serial.println("\n=== Smart Water Pump Controller ===");

  // Relay — default OFF (HIGH for active-low relay)
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, HIGH);

  // Probes — internal pullup (BC547 collector already has 4.7K on PCB)
  // Using INPUT since external pullups are on PCB; internal disabled to avoid conflict
  pinMode(PROBE_WASA_PIN,    INPUT);
  pinMode(PROBE_SUCTION_PIN, INPUT);

  // I2C + RTC
  Wire.begin(21, 22);
  if (!rtc.begin()) {
    Serial.println("[ERROR] DS3231 RTC not found! Check wiring.");
  } else {
    if (rtc.lostPower()) {
      Serial.println("[RTC] Lost power — setting time to compile time.");
      rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    }
    Serial.println("[RTC] DS3231 OK");
  }

  // Blynk
  Blynk.begin(BLYNK_AUTH_TOKEN, WIFI_SSID, WIFI_PASSWORD);

  // Push thresholds to Blynk on startup
  Blynk.virtualWrite(V8,  threshOV);
  Blynk.virtualWrite(V9,  threshUV);
  Blynk.virtualWrite(V10, threshFull);
  Blynk.virtualWrite(V11, threshLow);

  // Timer: poll sensors + push to Blynk every 2 s
  timer.setInterval(2000L, pollSensors);

  Serial.println("[INFO] Setup complete — entering loop.");
}

// ── Loop ─────────────────────────────────────────────────────
void loop() {
  Blynk.run();
  timer.run();
}

// ============================================================
//  FUTURE UPGRADE STUBS  (un-comment when headers populated)
// ============================================================

/* ── DS18B20 Temperature ─────────────────────────────────────
#include <OneWire.h>
#include <DallasTemperature.h>
OneWire oneWire(DS18B20_PIN);
DallasTemperature tempSensors(&oneWire);
// In setup():   tempSensors.begin();
// In pollSensors() or separate timer:
//   tempSensors.requestTemperatures();
//   float t1 = tempSensors.getTempCByIndex(0);
//   float t2 = tempSensors.getTempCByIndex(1);
//   Blynk.virtualWrite(V15, t1);
//   Blynk.virtualWrite(V16, t2);
*/

/* ── ZMPT101B AC Voltage Analog ─────────────────────────────
// Read ADC, calculate RMS, cross-check with PZEM reading
// int rawVal = analogRead(ZMPT101B_PIN);
// float zmptVoltage = map(rawVal, 0, 4095, 0, 300); // calibrate
// Blynk.virtualWrite(V17, zmptVoltage);
*/

/* ── SD Card Data Logging ───────────────────────────────────
#include <SD.h>
// In setup():  SD.begin(SD_CS_PIN);
// Log to CSV:  File f = SD.open("/log.csv", FILE_APPEND);
//              f.printf("%s,%.1f,%.3f,%.1f,%.3f,%d\n",
//                       timeStr, pzemVoltage, pzemCurrent,
//                       pzemPower, pzemEnergy, tankPercent);
//              f.close();
*/

/* ── OLED SSD1306 / SH1106 ──────────────────────────────────
#include <Adafruit_SSD1306.h>
Adafruit_SSD1306 display(128, 64, &Wire, -1);
// In setup():  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
// In loop():   display.clearDisplay();
//              display.printf("V: %.1f W: %.0f", pzemVoltage, pzemPower);
//              display.display();
*/

/* ── Magnetic Contactor ─────────────────────────────────────
// No code change needed. Wire relay NO+COM screw terminals
// to the HDR_CONTACTOR pin header on the PCB.
// Contactor coil: one wire to NO header pin, other to COM header pin.
// The relay switches the 220V coil energization line.
*/