/*
  dual_ir_beam_visitor_counter.ino

  Target:
    Arduino UNO R3 (ATmega328P)

  Hardware:
    - 2x IR break-beam receivers on D2 and D3
    - TM1637 4-digit display on D4 (CLK) and D5 (DIO)

  Behavior:
    - Beam A then Beam B => ENTRY => count++
    - Beam B then Beam A => EXIT  => count-- (not below zero)
    - Serial output logs events for validation
    - Display shows occupancy count from 0 to 9999

  Notes:
    - Assumes receiver outputs are active-low:
        beam clear   -> HIGH
        beam broken  -> LOW
    - Uses INPUT_PULLUP for stable idle state
*/

#include <Arduino.h>

// -----------------------------
// Pin configuration
// -----------------------------
const uint8_t PIN_BEAM_A = 2;
const uint8_t PIN_BEAM_B = 3;
const uint8_t PIN_TM1637_CLK = 4;
const uint8_t PIN_TM1637_DIO = 5;

// -----------------------------
// Behavior configuration
// -----------------------------
const bool SENSOR_ACTIVE_LOW = true;
const unsigned long DEBOUNCE_MS = 20;
const unsigned long SEQUENCE_TIMEOUT_MS = 1200;
const unsigned long COOLDOWN_MS = 300;

// Display brightness: 0 to 7
const uint8_t DISPLAY_BRIGHTNESS = 4;

// -----------------------------
// Simple TM1637 driver
// -----------------------------
class SimpleTM1637 {
public:
  SimpleTM1637(uint8_t clkPin, uint8_t dioPin)
    : _clk(clkPin), _dio(dioPin) {}

  void begin() {
    pinMode(_clk, OUTPUT);
    pinMode(_dio, OUTPUT);
    digitalWrite(_clk, HIGH);
    digitalWrite(_dio, HIGH);
    setBrightness(DISPLAY_BRIGHTNESS, true);
  }

  void setBrightness(uint8_t brightness, bool on = true) {
    if (brightness > 7) brightness = 7;
    _brightnessCmd = 0x88 | (on ? brightness : 0);
  }

  void showNumber(int value) {
    if (value < 0) value = 0;
    if (value > 9999) value = 9999;

    uint8_t digits[4];
    digits[0] = encodeDigit((value / 1000) % 10);
    digits[1] = encodeDigit((value / 100) % 10);
    digits[2] = encodeDigit((value / 10) % 10);
    digits[3] = encodeDigit(value % 10);

    // Leading blanking except for zero itself
    if (value < 1000) digits[0] = 0x00;
    if (value < 100)  digits[1] = 0x00;
    if (value < 10)   digits[2] = 0x00;
    if (value == 0) {
      digits[0] = 0x00;
      digits[1] = 0x00;
      digits[2] = 0x00;
      digits[3] = encodeDigit(0);
    }

    setSegments(digits);
  }

  void showDashes() {
    uint8_t dash = 0x40;
    uint8_t digits[4] = {dash, dash, dash, dash};
    setSegments(digits);
  }

private:
  uint8_t _clk;
  uint8_t _dio;
  uint8_t _brightnessCmd = 0x8F;

  uint8_t encodeDigit(uint8_t digit) {
    static const uint8_t map[10] = {
      0x3F, // 0
      0x06, // 1
      0x5B, // 2
      0x4F, // 3
      0x66, // 4
      0x6D, // 5
      0x7D, // 6
      0x07, // 7
      0x7F, // 8
      0x6F  // 9
    };
    if (digit < 10) return map[digit];
    return 0x00;
  }

  void bitDelay() {
    delayMicroseconds(5);
  }

  void start() {
    pinMode(_dio, OUTPUT);
    digitalWrite(_dio, HIGH);
    digitalWrite(_clk, HIGH);
    bitDelay();
    digitalWrite(_dio, LOW);
  }

  void stop() {
    pinMode(_dio, OUTPUT);
    digitalWrite(_clk, LOW);
    bitDelay();
    digitalWrite(_dio, LOW);
    bitDelay();
    digitalWrite(_clk, HIGH);
    bitDelay();
    digitalWrite(_dio, HIGH);
  }

  bool writeByte(uint8_t b) {
    for (uint8_t i = 0; i < 8; i++) {
      digitalWrite(_clk, LOW);
      bitDelay();

      if (b & 0x01) {
        digitalWrite(_dio, HIGH);
      } else {
        digitalWrite(_dio, LOW);
      }

      bitDelay();
      digitalWrite(_clk, HIGH);
      bitDelay();
      b >>= 1;
    }

    // ACK
    digitalWrite(_clk, LOW);
    pinMode(_dio, INPUT_PULLUP);
    bitDelay();
    digitalWrite(_clk, HIGH);
    bitDelay();
    bool ack = (digitalRead(_dio) == LOW);
    digitalWrite(_clk, LOW);
    pinMode(_dio, OUTPUT);
    return ack;
  }

  void setSegments(uint8_t segments[4]) {
    start();
    writeByte(0x40); // auto increment mode
    stop();

    start();
    writeByte(0xC0); // address 0
    for (uint8_t i = 0; i < 4; i++) {
      writeByte(segments[i]);
    }
    stop();

    start();
    writeByte(_brightnessCmd);
    stop();
  }
};

SimpleTM1637 display(PIN_TM1637_CLK, PIN_TM1637_DIO);

// -----------------------------
// Debounced sensor input
// -----------------------------
struct DebouncedInput {
  uint8_t pin;
  bool stableState;
  bool lastRawState;
  unsigned long lastChangeMs;

  void begin(uint8_t p) {
    pin = p;
    pinMode(pin, INPUT_PULLUP);
    stableState = digitalRead(pin);
    lastRawState = stableState;
    lastChangeMs = millis();
  }

  void update() {
    bool raw = digitalRead(pin);
    unsigned long now = millis();

    if (raw != lastRawState) {
      lastRawState = raw;
      lastChangeMs = now;
    }

    if ((now - lastChangeMs) >= DEBOUNCE_MS) {
      stableState = lastRawState;
    }
  }

  bool isBroken() const {
    if (SENSOR_ACTIVE_LOW) {
      return stableState == LOW;
    } else {
      return stableState == HIGH;
    }
  }
};

DebouncedInput beamA;
DebouncedInput beamB;

// -----------------------------
// Direction state machine
// -----------------------------
enum CountState {
  IDLE,
  WAIT_B_AFTER_A,
  WAIT_A_AFTER_B,
  COOLDOWN
};

CountState countState = IDLE;
unsigned long stateStartMs = 0;
unsigned int occupancyCount = 0;

bool prevBrokenA = false;
bool prevBrokenB = false;

void enterState(CountState newState) {
  countState = newState;
  stateStartMs = millis();
}

void logState(const char* msg) {
  Serial.print("[");
  Serial.print(millis());
  Serial.print(" ms] ");
  Serial.println(msg);
}

void handleEvents() {
  bool brokenA = beamA.isBroken();
  bool brokenB = beamB.isBroken();

  bool risingBreakA = (!prevBrokenA && brokenA);
  bool risingBreakB = (!prevBrokenB && brokenB);

  unsigned long now = millis();

  switch (countState) {
    case IDLE:
      if (risingBreakA && !brokenB) {
        enterState(WAIT_B_AFTER_A);
        logState("Sequence start: A first");
      } else if (risingBreakB && !brokenA) {
        enterState(WAIT_A_AFTER_B);
        logState("Sequence start: B first");
      }
      break;

    case WAIT_B_AFTER_A:
      if ((now - stateStartMs) > SEQUENCE_TIMEOUT_MS) {
        enterState(IDLE);
        logState("TIMEOUT after A first");
      } else if (risingBreakB) {
        if (occupancyCount < 9999) {
          occupancyCount++;
        }
        display.showNumber(occupancyCount);
        Serial.print("[");
        Serial.print(now);
        Serial.print(" ms] ENTRY, count=");
        Serial.println(occupancyCount);
        enterState(COOLDOWN);
      }
      break;

    case WAIT_A_AFTER_B:
      if ((now - stateStartMs) > SEQUENCE_TIMEOUT_MS) {
        enterState(IDLE);
        logState("TIMEOUT after B first");
      } else if (risingBreakA) {
        if (occupancyCount > 0) {
          occupancyCount--;
        }
        display.showNumber(occupancyCount);
        Serial.print("[");
        Serial.print(now);
        Serial.print(" ms] EXIT, count=");
        Serial.println(occupancyCount);
        enterState(COOLDOWN);
      }
      break;

    case COOLDOWN:
      // Wait until both beams are clear or cooldown expires
      if ((!brokenA && !brokenB) && ((now - stateStartMs) > COOLDOWN_MS)) {
        enterState(IDLE);
      } else if ((now - stateStartMs) > (COOLDOWN_MS + 1000)) {
        enterState(IDLE);
      }
      break;
  }

  prevBrokenA = brokenA;
  prevBrokenB = brokenB;
}

void setup() {
  Serial.begin(115200);

  beamA.begin(PIN_BEAM_A);
  beamB.begin(PIN_BEAM_B);

  display.begin();
  display.showNumber(occupancyCount);

  prevBrokenA = beamA.isBroken();
  prevBrokenB = beamB.isBroken();

  logState("Dual IR beam visitor counter started");
  Serial.println("Rule: A then B = ENTRY, B then A = EXIT");
  Serial.println("Initial count=0");
}

void loop() {
  beamA.update();
  beamB.update();

  handleEvents();

  static unsigned long lastRefreshMs = 0;
  unsigned long now = millis();
  if ((now - lastRefreshMs) >= 100) {
    display.showNumber(occupancyCount);
    lastRefreshMs = now;
  }
}

/*
  workshop_countdown_relay_timer.ino

  Device model:
  Arduino UNO R3 (ATmega328P) + pushbuttons + 1-channel relay module + piezo buzzer

  Project goal:
  workshop-countdown-relay-timer

  Behavior:
  - ADD button: increase preset time by 1 minute (1..60, wrap around)
  - START/PAUSE button:
      * if idle -> start countdown
      * if running -> pause
      * if paused -> resume
  - CANCEL/RESET button:
      * stop countdown
      * relay off
      * restore remaining time to preset
  - Relay is active while countdown is running
  - Buzzer gives short feedback on actions and a completion pattern at the end

  Notes:
  - Buttons use INPUT_PULLUP, so pressed = LOW
  - Relay modules are often active-low; set RELAY_ACTIVE_LOW accordingly
*/

const byte PIN_BTN_ADD = 2;
const byte PIN_BTN_START = 3;
const byte PIN_BTN_CANCEL = 4;
const byte PIN_RELAY = 8;
const byte PIN_BUZZER = 9;

const bool RELAY_ACTIVE_LOW = true;

const unsigned long DEBOUNCE_MS = 35;
const unsigned long STATUS_PRINT_MS = 1000;
const unsigned long MINUTES_MAX = 60;
const unsigned long DEFAULT_PRESET_MIN = 5;

enum TimerState {
  IDLE,
  RUNNING,
  PAUSED,
  FINISHED
};

TimerState timerState = IDLE;

unsigned long presetMinutes = DEFAULT_PRESET_MIN;
unsigned long remainingMs = DEFAULT_PRESET_MIN * 60UL * 1000UL;
unsigned long lastTickMs = 0;
unsigned long lastStatusPrintMs = 0;

struct Button {
  byte pin;
  bool stableState;
  bool lastReading;
  unsigned long lastChangeMs;
};

Button btnAdd    = {PIN_BTN_ADD, HIGH, HIGH, 0};
Button btnStart  = {PIN_BTN_START, HIGH, HIGH, 0};
Button btnCancel = {PIN_BTN_CANCEL, HIGH, HIGH, 0};

void setRelay(bool on) {
  if (RELAY_ACTIVE_LOW) {
    digitalWrite(PIN_RELAY, on ? LOW : HIGH);
  } else {
    digitalWrite(PIN_RELAY, on ? HIGH : LOW);
  }
}

void beep(unsigned int frequency, unsigned long durationMs) {
  tone(PIN_BUZZER, frequency, durationMs);
}

void shortBeep() {
  beep(2200, 70);
}

void doubleBeep() {
  beep(2000, 60);
  delay(100);
  beep(2600, 80);
}

void finishBeepPattern() {
  for (int i = 0; i < 3; i++) {
    beep(1800, 120);
    delay(180);
  }
  beep(2600, 350);
  delay(400);
}

bool buttonPressedEvent(Button &button) {
  bool reading = digitalRead(button.pin);

  if (reading != button.lastReading) {
    button.lastChangeMs = millis();
    button.lastReading = reading;
  }

  if ((millis() - button.lastChangeMs) > DEBOUNCE_MS) {
    if (reading != button.stableState) {
      button.stableState = reading;

      // Because INPUT_PULLUP is used, LOW means pressed
      if (button.stableState == LOW) {
        return true;
      }
    }
  }

  return false;
}

void printHelp() {
  Serial.println(F("Workshop Countdown Relay Timer"));
  Serial.println(F("Buttons:"));
  Serial.println(F("  ADD         -> +1 minute preset (1..60)"));
  Serial.println(F("  START/PAUSE -> start, pause, resume"));
  Serial.println(F("  CANCEL      -> stop and reset to preset"));
  Serial.println();
}

void printStateLine() {
  unsigned long totalSeconds = remainingMs / 1000UL;
  unsigned int minutesPart = totalSeconds / 60UL;
  unsigned int secondsPart = totalSeconds % 60UL;

  Serial.print(F("Preset="));
  Serial.print(presetMinutes);
  Serial.print(F(" min, Remaining="));
  if (minutesPart < 10) Serial.print('0');
  Serial.print(minutesPart);
  Serial.print(':');
  if (secondsPart < 10) Serial.print('0');
  Serial.print(secondsPart);
  Serial.print(F(", State="));

  switch (timerState) {
    case IDLE: Serial.print(F("IDLE")); break;
    case RUNNING: Serial.print(F("RUNNING")); break;
    case PAUSED: Serial.print(F("PAUSED")); break;
    case FINISHED: Serial.print(F("FINISHED")); break;
  }

  Serial.print(F(", Relay="));
  Serial.println((timerState == RUNNING) ? F("ON") : F("OFF"));
}

void resetToPreset() {
  remainingMs = presetMinutes * 60UL * 1000UL;
  lastTickMs = millis();
}

void handleAddButton() {
  // For simplicity in a basic project, allow preset changes only when not running
  if (timerState == RUNNING) {
    doubleBeep();
    Serial.println(F("ADD ignored while running. Pause or cancel first."));
    return;
  }

  presetMinutes++;
  if (presetMinutes > MINUTES_MAX) {
    presetMinutes = 1;
  }

  resetToPreset();

  if (timerState == FINISHED) {
    timerState = IDLE;
  }

  shortBeep();
  Serial.print(F("Preset changed to "));
  Serial.print(presetMinutes);
  Serial.println(F(" minute(s)."));
  printStateLine();
}

void handleStartButton() {
  if (timerState == IDLE || timerState == FINISHED) {
    resetToPreset();
    timerState = RUNNING;
    setRelay(true);
    lastTickMs = millis();
    shortBeep();
    Serial.println(F("Countdown started."));
    printStateLine();
    return;
  }

  if (timerState == RUNNING) {
    timerState = PAUSED;
    setRelay(false);
    shortBeep();
    Serial.println(F("Countdown paused."));
    printStateLine();
    return;
  }

  if (timerState == PAUSED) {
    timerState = RUNNING;
    setRelay(true);
    lastTickMs = millis();
    shortBeep();
    Serial.println(F("Countdown resumed."));
    printStateLine();
    return;
  }
}

void handleCancelButton() {
  timerState = IDLE;
  setRelay(false);
  resetToPreset();
  doubleBeep();
  Serial.println(F("Countdown canceled and reset to preset."));
  printStateLine();
}

void updateTimer() {
  if (timerState != RUNNING) {
    return;
  }

  unsigned long now = millis();
  unsigned long elapsed = now - lastTickMs;
  lastTickMs = now;

  if (elapsed >= remainingMs) {
    remainingMs = 0;
    timerState = FINISHED;
    setRelay(false);
    Serial.println(F("Countdown complete. Relay turned OFF."));
    printStateLine();
    finishBeepPattern();
    return;
  }

  remainingMs -= elapsed;
}

void setup() {
  pinMode(PIN_BTN_ADD, INPUT_PULLUP);
  pinMode(PIN_BTN_START, INPUT_PULLUP);
  pinMode(PIN_BTN_CANCEL, INPUT_PULLUP);

  pinMode(PIN_RELAY, OUTPUT);
  pinMode(PIN_BUZZER, OUTPUT);

  setRelay(false);

  Serial.begin(9600);
  delay(300);

  printHelp();
  resetToPreset();
  printStateLine();
}

void loop() {
  if (buttonPressedEvent(btnAdd)) {
    handleAddButton();
  }

  if (buttonPressedEvent(btnStart)) {
    handleStartButton();
  }

  if (buttonPressedEvent(btnCancel)) {
    handleCancelButton();
  }

  updateTimer();

  unsigned long now = millis();
  if (now - lastStatusPrintMs >= STATUS_PRINT_MS) {
    lastStatusPrintMs = now;
    printStateLine();
  }
}

#include <LiquidCrystal.h>

// LCD pins: RS, E, D4, D5, D6, D7
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

// Analog pins
const uint8_t PIN_BATTERY = A0;
const uint8_t PIN_CURRENT = A1;

// ADC reference
const float ADC_REF_VOLTAGE = 5.0;
const int ADC_MAX = 1023;

// Voltage divider values
const float R1 = 47000.0; // ohms, top resistor
const float R2 = 10000.0; // ohms, bottom resistor

// ACS712 settings
// Set according to your module:
// 5A module  -> 185.0 mV/A
// 20A module -> 100.0 mV/A
// 30A module -> 66.0  mV/A
const float ACS712_MV_PER_AMP = 185.0;

// Calibration values
float currentZeroVoltage = 2.50;   // Will be refined during startup calibration
float voltageCalibrationFactor = 1.000; // Adjust after comparing to multimeter if needed
float currentCalibrationFactor = 1.000; // Adjust after comparing to multimeter if needed

// Sampling
const int NUM_SAMPLES_VOLTAGE = 20;
const int NUM_SAMPLES_CURRENT = 100;

// Timing
unsigned long lastDisplayUpdate = 0;
const unsigned long DISPLAY_INTERVAL_MS = 500;

// Optional status thresholds
const float LOW_BATTERY_VOLTAGE = 11.8;
const float IDLE_CURRENT_THRESHOLD = 0.08;

float readAverageVoltageAtPin(uint8_t pin, int samples) {
  long sum = 0;
  for (int i = 0; i < samples; i++) {
    sum += analogRead(pin);
    delay(2);
  }
  float adc = sum / (float)samples;
  return (adc * ADC_REF_VOLTAGE) / ADC_MAX;
}

float readBatteryVoltage() {
  float dividedVoltage = readAverageVoltageAtPin(PIN_BATTERY, NUM_SAMPLES_VOLTAGE);
  float batteryVoltage = dividedVoltage * ((R1 + R2) / R2);
  batteryVoltage *= voltageCalibrationFactor;
  return batteryVoltage;
}

float readCurrent() {
  float sensorVoltage = readAverageVoltageAtPin(PIN_CURRENT, NUM_SAMPLES_CURRENT);
  float deltaVoltage = sensorVoltage - currentZeroVoltage; // volts
  float current = (deltaVoltage * 1000.0) / ACS712_MV_PER_AMP; // amps
  current *= currentCalibrationFactor;
  return current;
}

void calibrateCurrentZero() {
  // Assumes no current is flowing through ACS712 during startup.
  float total = 0.0;
  const int rounds = 10;
  for (int i = 0; i < rounds; i++) {
    total += readAverageVoltageAtPin(PIN_CURRENT, 50);
    delay(20);
  }
  currentZeroVoltage = total / rounds;
}

const char* stateText(float current, float batteryVoltage) {
  if (current > IDLE_CURRENT_THRESHOLD) {
    return "CHARGING";
  } else if (current < -IDLE_CURRENT_THRESHOLD) {
    return "DISCHARGE";
  } else if (batteryVoltage < LOW_BATTERY_VOLTAGE) {
    return "LOW BAT";
  } else {
    return "IDLE";
  }
}

void printPadded(String text, uint8_t width) {
  if (text.length() >= width) {
    lcd.print(text.substring(0, width));
  } else {
    lcd.print(text);
    for (uint8_t i = text.length(); i < width; i++) {
      lcd.print(' ');
    }
  }
}

void setup() {
  lcd.begin(16, 2);
  Serial.begin(9600);

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Solar Battery");
  lcd.setCursor(0, 1);
  lcd.print("Monitor Start");
  delay(1200);

  calibrateCurrentZero();

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Zero I V=");
  lcd.print(currentZeroVoltage, 3);
  delay(1500);

  Serial.println("solar-battery-lcd-monitor");
  Serial.print("Current zero voltage = ");
  Serial.println(currentZeroVoltage, 4);
}

void loop() {
  if (millis() - lastDisplayUpdate >= DISPLAY_INTERVAL_MS) {
    lastDisplayUpdate = millis();

    float batteryVoltage = readBatteryVoltage();
    float current = readCurrent();
    float power = batteryVoltage * current;
    const char* state = stateText(current, batteryVoltage);

    // LCD line 1: Voltage and current
    lcd.setCursor(0, 0);
    String line1 = "V:";
    line1 += String(batteryVoltage, 2);
    line1 += " I:";
    line1 += String(current, 2);
    printPadded(line1, 16);

    // LCD line 2: Power and state
    lcd.setCursor(0, 1);
    String line2 = "P:";
    line2 += String(power, 1);
    line2 += " ";
    line2 += state;
    printPadded(line2, 16);

    // Serial output for validation
    Serial.print("Battery_V=");
    Serial.print(batteryVoltage, 3);
    Serial.print(", Current_A=");
    Serial.print(current, 3);
    Serial.print(", Power_W=");
    Serial.print(power, 3);
    Serial.print(", State=");
    Serial.println(state);
  }
}

#include <LiquidCrystal.h>

// LCD pins: RS, E, D4, D5, D6, D7
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const int LM35_PIN = A0;
const int RELAY_PIN = 8;

// Adjust these thresholds for your chamber.
// Hysteresis prevents rapid relay toggling.
const float TEMP_ON_C = 36.5;   // Heater turns ON below this
const float TEMP_OFF_C = 37.5;  // Heater turns OFF above this

// Set this to true if your relay module is active LOW.
// Many Arduino relay boards energize the relay when IN is LOW.
const bool RELAY_ACTIVE_LOW = true;

bool heaterOn = false;
unsigned long lastSampleMs = 0;
const unsigned long SAMPLE_INTERVAL_MS = 1000;

float readTemperatureC() {
  const int samples = 10;
  long sum = 0;

  for (int i = 0; i < samples; i++) {
    sum += analogRead(LM35_PIN);
    delay(5);
  }

  float averageAdc = sum / (float)samples;
  float voltage = averageAdc * (5.0 / 1023.0);

  // LM35 output is 10 mV per degree C
  float temperatureC = voltage * 100.0;
  return temperatureC;
}

void setRelay(bool on) {
  heaterOn = on;

  if (RELAY_ACTIVE_LOW) {
    digitalWrite(RELAY_PIN, on ? LOW : HIGH);
  } else {
    digitalWrite(RELAY_PIN, on ? HIGH : LOW);
  }
}

void updateControl(float temperatureC) {
  if (!heaterOn && temperatureC < TEMP_ON_C) {
    setRelay(true);
  } else if (heaterOn && temperatureC > TEMP_OFF_C) {
    setRelay(false);
  }
}

void updateDisplay(float temperatureC) {
  lcd.setCursor(0, 0);
  lcd.print("Temp: ");
  lcd.print(temperatureC, 1);
  lcd.print((char)223); // degree symbol
  lcd.print("C   ");

  lcd.setCursor(0, 1);
  lcd.print("Set ");
  lcd.print(TEMP_ON_C, 1);
  lcd.print("-");
  lcd.print(TEMP_OFF_C, 1);
  lcd.print(" ");

  lcd.setCursor(12, 1);
  if (heaterOn) {
    lcd.print("ON ");
  } else {
    lcd.print("OFF");
  }
}

void printSerial(float temperatureC) {
  Serial.print("Temperature_C=");
  Serial.print(temperatureC, 2);
  Serial.print(", Heater=");
  Serial.println(heaterOn ? "ON" : "OFF");
}

void setup() {
  pinMode(RELAY_PIN, OUTPUT);

  // Start with heater off
  setRelay(false);

  lcd.begin(16, 2);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Incubator Ctrl");
  lcd.setCursor(0, 1);
  lcd.print("Starting...");

  Serial.begin(9600);
  delay(1500);
  lcd.clear();
}

void loop() {
  unsigned long now = millis();

  if (now - lastSampleMs >= SAMPLE_INTERVAL_MS) {
    lastSampleMs = now;

    float temperatureC = readTemperatureC();
    updateControl(temperatureC);
    updateDisplay(temperatureC);
    printSerial(temperatureC);
  }
}

/*
  water_leak_shutoff_relay.ino

  Device model:
  Arduino UNO R3 (ATmega328P) + water leak sensor + 1-channel relay module + piezo buzzer

  Goal:
  Detect water using analog input, confirm the leak with simple timing/filter logic,
  trigger an audible alarm, and switch a relay for shutoff control.

  Serial output:
  9600 baud
*/

const int SENSOR_PIN = A0;
const int RELAY_PIN = 8;
const int BUZZER_PIN = 9;

// Relay module behavior:
// true  = relay input is active LOW
// false = relay input is active HIGH
const bool RELAY_ACTIVE_LOW = true;

// Sensor thresholds:
// Lower analog readings often mean "more water" on many common modules,
// but some modules behave differently. Validate with Serial Monitor first.
const int LEAK_THRESHOLD_WET = 500;   // Reading at or below this means "wet"
const int LEAK_THRESHOLD_DRY = 560;   // Reading at or above this means "dry again"

// Timing filters to avoid false triggers from noise or tiny splashes
const unsigned long WET_CONFIRM_MS = 400;
const unsigned long DRY_CONFIRM_MS = 1500;
const unsigned long STATUS_PRINT_MS = 500;

// Buzzer pattern timing
const unsigned long BUZZER_ON_MS = 180;
const unsigned long BUZZER_OFF_MS = 220;

bool leakAlarm = false;

unsigned long wetStartMs = 0;
unsigned long dryStartMs = 0;
unsigned long lastStatusPrintMs = 0;
unsigned long buzzerToggleMs = 0;
bool buzzerState = false;

void setRelayAlarmState(bool alarmActive) {
  // For shutoff wiring using COM + NC:
  // alarmActive should cause the relay to switch away from NC.
  bool relayEnergized = alarmActive;

  if (RELAY_ACTIVE_LOW) {
    digitalWrite(RELAY_PIN, relayEnergized ? LOW : HIGH);
  } else {
    digitalWrite(RELAY_PIN, relayEnergized ? HIGH : LOW);
  }
}

void setBuzzer(bool on) {
  if (on) {
    tone(BUZZER_PIN, 2400);  // 2.4 kHz tone
  } else {
    noTone(BUZZER_PIN);
  }
}

void printState(const char* stateName, int sensorValue) {
  Serial.print("State: ");
  Serial.print(stateName);
  Serial.print(" | sensor=");
  Serial.print(sensorValue);
  Serial.print(" | relay_alarm=");
  Serial.println(leakAlarm ? "ON" : "OFF");
}

void setup() {
  pinMode(RELAY_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);

  // Default safe startup for this tutorial:
  // no alarm until a confirmed leak is detected.
  leakAlarm = false;
  setRelayAlarmState(leakAlarm);
  setBuzzer(false);

  Serial.begin(9600);
  delay(300);
  Serial.println("Water leak shutoff relay controller starting...");
  Serial.println("Using analog leak sensing on A0");
  Serial.println("Check dry and wet readings before final installation.");

  // Initialize timing references
  wetStartMs = 0;
  dryStartMs = 0;
  lastStatusPrintMs = 0;
  buzzerToggleMs = 0;
  buzzerState = false;
}

void loop() {
  unsigned long now = millis();
  int sensorValue = analogRead(SENSOR_PIN);

  bool wetCandidate = (sensorValue <= LEAK_THRESHOLD_WET);
  bool dryCandidate = (sensorValue >= LEAK_THRESHOLD_DRY);

  // Leak detection state machine with hysteresis and timing confirmation
  if (!leakAlarm) {
    if (wetCandidate) {
      if (wetStartMs == 0) {
        wetStartMs = now;
      }
      if (now - wetStartMs >= WET_CONFIRM_MS) {
        leakAlarm = true;
        dryStartMs = 0;
        setRelayAlarmState(leakAlarm);
        Serial.println("LEAK DETECTED: relay shutoff activated");
        printState("LEAK", sensorValue);
      }
    } else {
      wetStartMs = 0;
    }
  } else {
    if (dryCandidate) {
      if (dryStartMs == 0) {
        dryStartMs = now;
      }
      if (now - dryStartMs >= DRY_CONFIRM_MS) {
        leakAlarm = false;
        wetStartMs = 0;
        setRelayAlarmState(leakAlarm);
        setBuzzer(false);
        buzzerState = false;
        Serial.println("RESET TO DRY: relay returned to normal");
        printState("DRY", sensorValue);
      }
    } else {
      dryStartMs = 0;
    }
  }

  // Buzzer pattern during active alarm
  if (leakAlarm) {
    if (now - buzzerToggleMs >= (buzzerState ? BUZZER_ON_MS : BUZZER_OFF_MS)) {
      buzzerState = !buzzerState;
      setBuzzer(buzzerState);
      buzzerToggleMs = now;
    }
  } else {
    if (buzzerState) {
      buzzerState = false;
      setBuzzer(false);
    }
  }

  // Periodic status prints
  if (now - lastStatusPrintMs >= STATUS_PRINT_MS) {
    printState(leakAlarm ? "LEAK" : "DRY", sensorValue);
    lastStatusPrintMs = now;
  }

  delay(20);
}

#include <LiquidCrystal.h>

// LCD pins: RS, E, D4, D5, D6, D7
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// Pin assignments
const int PIN_BATTERY = A0;
const int PIN_RELAY = 8;

// Relay module behavior:
// Many modules are ACTIVE LOW.
// Set RELAY_ON_LEVEL and RELAY_OFF_LEVEL to match your hardware.
const int RELAY_ON_LEVEL = LOW;
const int RELAY_OFF_LEVEL = HIGH;

// Voltage divider values in ohms
const float R1 = 30000.0;  // battery+ to A0
const float R2 = 7500.0;   // A0 to GND

// ADC reference for standard UNO powered by USB
const float ADC_REF_VOLTAGE = 5.0;
const int ADC_MAX = 1023;

// Battery thresholds
const float DISCONNECT_VOLTAGE = 11.80;
const float RECONNECT_VOLTAGE  = 12.40;

// Timing
const unsigned long SAMPLE_INTERVAL_MS = 250;
const unsigned long LCD_INTERVAL_MS = 500;
const unsigned long SERIAL_INTERVAL_MS = 1000;
const unsigned long LOW_VOLTAGE_DELAY_MS = 5000;

// Averaging
const int NUM_SAMPLES = 20;

// State variables
bool loadConnected = true;
bool lowVoltagePending = false;
unsigned long lowVoltageStartMs = 0;
unsigned long lastSampleMs = 0;
unsigned long lastLcdMs = 0;
unsigned long lastSerialMs = 0;
float filteredBatteryVoltage = 0.0;

// Read battery voltage using averaging
float readBatteryVoltage() {
  long total = 0;

  for (int i = 0; i < NUM_SAMPLES; i++) {
    total += analogRead(PIN_BATTERY);
    delay(2);
  }

  float adc = total / (float)NUM_SAMPLES;
  float vA0 = adc * ADC_REF_VOLTAGE / ADC_MAX;
  float batteryVoltage = vA0 * ((R1 + R2) / R2);

  return batteryVoltage;
}

void setLoadConnected(bool enabled) {
  loadConnected = enabled;
  digitalWrite(PIN_RELAY, enabled ? RELAY_ON_LEVEL : RELAY_OFF_LEVEL);
}

void updateControlLogic(float vbat, unsigned long nowMs) {
  if (loadConnected) {
    if (vbat < DISCONNECT_VOLTAGE) {
      if (!lowVoltagePending) {
        lowVoltagePending = true;
        lowVoltageStartMs = nowMs;
      } else if ((nowMs - lowVoltageStartMs) >= LOW_VOLTAGE_DELAY_MS) {
        setLoadConnected(false);
        lowVoltagePending = false;
      }
    } else {
      lowVoltagePending = false;
    }
  } else {
    // Load is disconnected; reconnect only after voltage rises enough
    if (vbat > RECONNECT_VOLTAGE) {
      setLoadConnected(true);
      lowVoltagePending = false;
    }
  }
}

void updateLcd(float vbat, unsigned long nowMs) {
  if (nowMs - lastLcdMs < LCD_INTERVAL_MS) {
    return;
  }
  lastLcdMs = nowMs;

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Bat:");
  lcd.print(vbat, 2);
  lcd.print("V");

  lcd.setCursor(0, 1);

  if (loadConnected) {
    if (lowVoltagePending) {
      unsigned long elapsed = nowMs - lowVoltageStartMs;
      unsigned long remain = 0;
      if (elapsed < LOW_VOLTAGE_DELAY_MS) {
        remain = (LOW_VOLTAGE_DELAY_MS - elapsed + 999) / 1000;
      }
      lcd.print("LOW WAIT ");
      lcd.print(remain);
      lcd.print("s");
    } else {
      lcd.print("LOAD ON");
    }
  } else {
    lcd.print("CUT OFF");
  }
}

void printSerialStatus(float vbat, unsigned long nowMs) {
  if (nowMs - lastSerialMs < SERIAL_INTERVAL_MS) {
    return;
  }
  lastSerialMs = nowMs;

  Serial.print("Vbat=");
  Serial.print(vbat, 3);
  Serial.print(" V, Load=");
  Serial.print(loadConnected ? "ON" : "OFF");
  Serial.print(", Pending=");
  Serial.println(lowVoltagePending ? "YES" : "NO");
}

void setup() {
  pinMode(PIN_RELAY, OUTPUT);
  setLoadConnected(true);

  lcd.begin(16, 2);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Battery Guard");
  lcd.setCursor(0, 1);
  lcd.print("Starting...");

  Serial.begin(9600);
  delay(1500);

  filteredBatteryVoltage = readBatteryVoltage();
}

void loop() {
  unsigned long nowMs = millis();

  if (nowMs - lastSampleMs >= SAMPLE_INTERVAL_MS) {
    lastSampleMs = nowMs;

    float rawV = readBatteryVoltage();

    // Light smoothing filter
    filteredBatteryVoltage = 0.8 * filteredBatteryVoltage + 0.2 * rawV;

    updateControlLogic(filteredBatteryVoltage, nowMs);
    updateLcd(filteredBatteryVoltage, nowMs);
    printSerialStatus(filteredBatteryVoltage, nowMs);
  }
}