Practical case: water leak shutoff, Arduino UNO

/*
  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);
}