Practical case: sump pump monitor with Raspberry Pi

"""
sump_monitor.py
Main application for monitoring sump pump runtime.
Reads analog current data, applies threshold logic, and logs events to CSV.
"""

import argparse
import time
import datetime
import csv
import os
from mcp3008_driver import MCP3008

# Configuration
ADC_CHANNEL = 0
# Threshold out of 1023. Adjust based on your sensor's output when the pump is ON.
# 100 is roughly 0.32V on a 3.3V reference.
ON_THRESHOLD = 100 
LOG_FILE = "sump_pump_log.csv"

def initialize_csv(filepath):
    """Creates the CSV file and writes headers if it doesn't exist."""
    if not os.path.exists(filepath):
        with open(filepath, mode='w', newline='') as file:
            writer = csv.writer(file)
            writer.writerow(["Timestamp_Start", "Timestamp_End", "Duration_Seconds", "Peak_ADC_Value"])
        print(f"[*] Created new log file: {filepath}")

def log_event(filepath, start_time, end_time, peak_val):
    """Appends a completed pump cycle to the CSV log."""
    duration = round(end_time - start_time, 2)
    start_str = datetime.datetime.fromtimestamp(start_time).strftime('%Y-%m-%d %H:%M:%S')
    end_str = datetime.datetime.fromtimestamp(end_time).strftime('%Y-%m-%d %H:%M:%S')

    with open(filepath, mode='a', newline='') as file:
        writer = csv.writer(file)
        writer.writerow([start_str, end_str, duration, peak_val])

    print(f"[LOG] Cycle recorded: {duration} seconds (Peak ADC: {peak_val})")

def simulate_environment(mcp, script_start_time):
    """
    Simulates a pump cycling on and off for dry-run validation.
    Pump turns ON for 5 seconds every 20 seconds.
    """
    elapsed = time.time() - script_start_time
    cycle_time = elapsed % 20
    if 5 <= cycle_time <= 10:
        # Simulate pump running (high current)
        mcp.mock_val = 650 
    else:
        # Simulate pump off (noise floor)
        mcp.mock_val = 15 

def main():
    parser = argparse.ArgumentParser(description="Sump Pump Runtime Monitor")
    parser.add_argument("--mock", action="store_true", help="Run in mock mode without physical hardware")
    args = parser.parse_args()

    print("======================================")
    print("      Sump Pump Runtime Monitor       ")
    print("======================================")

    if args.mock:
        print("[!] Running in MOCK mode. Hardware bypassed.")
    else:
        print("[!] Running in HARDWARE mode.")

    initialize_csv(LOG_FILE)

    # Initialize ADC
    adc = MCP3008(bus=0, device=0, mock=args.mock)

    # State machine variables
    pump_is_running = False
    cycle_start_time = 0
    peak_adc_in_cycle = 0
    script_start_time = time.time()

    print(f"[*] Monitoring started. Press Ctrl+C to exit.")
    print(f"[*] Threshold set to ADC > {ON_THRESHOLD}")

    try:
        while True:
            # Inject simulated data if in mock mode
            if args.mock:
                simulate_environment(adc, script_start_time)

            # Read current sensor
            current_val = adc.read_channel(ADC_CHANNEL)

            # State Machine Logic
            if current_val > ON_THRESHOLD:
                if not pump_is_running:
                    # Transition: OFF -> ON
                    pump_is_running = True
                    cycle_start_time = time.time()
                    peak_adc_in_cycle = current_val
                    print(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] PUMP ON DETECTED (ADC: {current_val})")
                else:
                    # Update peak value during the cycle
                    if current_val > peak_adc_in_cycle:
                        peak_adc_in_cycle = current_val
            else:
                if pump_is_running:
                    # Transition: ON -> OFF
                    pump_is_running = False
                    cycle_end_time = time.time()
                    print(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] PUMP OFF DETECTED")
                    log_event(LOG_FILE, cycle_start_time, cycle_end_time, peak_adc_in_cycle)

            # Sample rate: ~10Hz is sufficient for this application
            time.sleep(0.1)

    except KeyboardInterrupt:
        print("\n[*] Shutting down monitor gracefully...")
    finally:
        adc.close()
        print("[*] Cleanup complete. Exiting.")

if __name__ == "__main__":
    main()