Leak detector with shutoff valve on an Arduino Uno

// Leak detector: a YF-S201 flow sensor, a totalizer that survives a reset, and
// a solenoid valve that closes the main when a leak is confirmed.
//
// A TEACHING MODEL with low-voltage stand-ins. Do not wire it into a building's
// water main, and do not count on it to protect a house. A real shutoff is a
// listed valve with its own controller and a leak sensor that is certified for
// the job.
//
//   pin 2    the flow sensor's SIG (interrupt 0); VCC and GND from the 5 V rails
//   pin 3    REOPEN button to GND (reopens the valve after a leak)
//   pin 4    DAILY button to GND (zeroes today's total)
//   pin 5    UNITS slide switch to GND: down is liters, up is gallons
//   pin 6    USAGE slide switch to GND: down means someone is home and using
//            water, up means quiet hours or nobody home
//   pin 8    an active buzzer (its other leg to GND), beeped on and off
//   pin 9    the valve driver: gate of an IRLZ44N on the 12 V valve, with a
//            1N4007 across the coil to catch the kick when it lets go
//   pin 12   the red alarm LED, through 220 ohms
//
// The sensor. The wheel in a YF-S201 pulses SIG about 7.5 times a second for
// each liter a minute, so 450 pulses make a liter. That is the datasheet's
// typical figure, the same one the water meter uses. In the real world the
// K-factor varies from unit to unit and with the flow rate (a unit reads off at
// the very low and very high ends, and a trickle may not turn the wheel at
// all), so a real install calibrates against a measured bucket of water.
//
// Time scale. A leak is a slow thing and a simulator is not. The two limits
// below are written in seconds and are scaled 30 to 1, so the simulator can
// run them in a moment:
//
//   LONG_FLOW_S  20 s here stands for 10 minutes of flow that never lets up
//   TRICKLE_S    40 s here stands for 20 minutes of a small flow that never
//                stops while nobody is using water
//
// The two rules.
//   1. Continuous flow: more than a trickle, without a gap of GAP_S seconds,
//      for LONG_FLOW_S. That is a burst line, a stuck toilet fill valve or a
//      hose left running. (A sprinkler on a timer would trip it too.)
//   2. Slow leak: a flow of 0.5 L/min or less that never stops for TRICKLE_S
//      while the USAGE switch says nobody is using water. A running toilet or
//      a dripping fixture looks like this. Flow while someone is home is use,
//      not a leak, and clears the count.
// Half way to either limit the state is WATCH (the LED blinks). At the limit
// it is LEAK: the valve closes, the LED lights and the buzzer beeps.
//
// The valve is a normally closed solenoid, held OPEN by 12 V on the coil. A
// leak (or a dead supply, or a dead Arduino) lets go of it and it shuts: the
// safe side to fail on. The leak is remembered in EEPROM, so a reset does not
// reopen the main by itself; only the REOPEN button does.
//
// The totals. Pulses are the only thing counted, so liters and gallons are
// worked out when they are shown (450 pulses a liter, 1703 a gallon). The
// total and today's total are written to EEPROM every 5 liters, and when a
// leak is confirmed or cleared. A cell takes about 100,000 writes, so the
// sketch saves rarely; a longer-lived design would also spread the writes
// with a wear-leveling library. Up to 5 liters can be lost in a power cut.

#include <EEPROM.h>

const int FLOW_PIN = 2;
const int REOPEN_BUTTON = 3;
const int DAILY_BUTTON = 4;
const int UNITS_SWITCH = 5;
const int USAGE_SWITCH = 6;
const int BUZZER = 8;
const int VALVE = 9;
const int LED = 12;

const unsigned long PULSES_PER_LITER = 450;
const unsigned long PULSES_PER_GALLON = 1703;    // 450 x 3.785
const unsigned long LONG_FLOW_S = 20;            // stands for 10 minutes
const unsigned long TRICKLE_S = 40;              // stands for 20 minutes
const unsigned long GAP_S = 3;                   // quiet seconds that end a run of flow
const unsigned long TRICKLE_MAX = 5;             // tenths of a liter a minute (0.5)
const unsigned long SAVE_EVERY = 5 * PULSES_PER_LITER;
const byte MAGIC = 0x4C;

struct Saved {
  byte magic;
  unsigned long total;   // pulses, for good
  unsigned long today;   // pulses since the DAILY button
  byte leak;             // 1 while a leak is latched
};

volatile unsigned long pulses = 0;
unsigned long counted = 0;
unsigned long total = 0;
unsigned long today = 0;
unsigned long savedTotal = 0;
unsigned long lastSecond = 0;
unsigned long ring[5];
byte ringAt = 0;
unsigned long quietS = 99;
unsigned long contS = 0;
unsigned long trickleS = 0;
bool leak = false;
const char *state = "OK";

struct Button {
  int pin;
  bool last;
  unsigned long changed;
};
Button reopenButton = {REOPEN_BUTTON, false, 0};
Button dailyButton = {DAILY_BUTTON, false, 0};

void onPulse() {
  pulses++;
}

// True once per press, after the contact has held for 40 ms.
bool pressed(Button &b) {
  bool down = digitalRead(b.pin) == LOW;
  if (down != b.last) {
    b.last = down;
    b.changed = millis();
    return false;
  }
  if (down && b.changed != 0 && millis() - b.changed >= 40) {
    b.changed = 0;
    return true;
  }
  return false;
}

void save() {
  Saved s = {MAGIC, total, today, (byte)(leak ? 1 : 0)};
  EEPROM.put(0, s);
  savedTotal = total;
  Serial.print("saved total ");
  Serial.print(total);
  Serial.print(" pulses, today ");
  Serial.print(today);
  Serial.print(", leak ");
  Serial.println(leak ? 1 : 0);
}

void printTenths(unsigned long t) {
  Serial.print(t / 10);
  Serial.print('.');
  Serial.print(t % 10);
}

void closeValve(const char *why) {
  leak = true;
  digitalWrite(VALVE, LOW);
  Serial.print("LEAK: ");
  Serial.print(why);
  Serial.println(", valve closed");
  save();
}

void setup() {
  Serial.begin(115200);
  Serial.println("Mokxi Arduino Uno: leak detector");
  pinMode(FLOW_PIN, INPUT_PULLUP);
  pinMode(REOPEN_BUTTON, INPUT_PULLUP);
  pinMode(DAILY_BUTTON, INPUT_PULLUP);
  pinMode(UNITS_SWITCH, INPUT_PULLUP);
  pinMode(USAGE_SWITCH, INPUT_PULLUP);
  pinMode(BUZZER, OUTPUT);
  pinMode(VALVE, OUTPUT);
  pinMode(LED, OUTPUT);

  Saved s;
  EEPROM.get(0, s);
  if (s.magic == MAGIC) {
    total = s.total;
    today = s.today;
    leak = s.leak == 1;
  }
  savedTotal = total;
  // Open the main only if no leak is waiting to be cleared.
  digitalWrite(VALVE, leak ? LOW : HIGH);
  Serial.print("boot: total ");
  Serial.print(total);
  Serial.print(" pulses, today ");
  Serial.print(today);
  Serial.println(leak ? ", leak latched, valve stays closed" : ", valve open");

  attachInterrupt(digitalPinToInterrupt(FLOW_PIN), onPulse, FALLING);
  lastSecond = millis();
}

// Once a second: count, judge and report.
void tick() {
  noInterrupts();
  unsigned long all = pulses;
  interrupts();
  unsigned long delta = all - counted;
  counted = all;
  total += delta;
  today += delta;

  ring[ringAt] = delta;
  ringAt = (ringAt + 1) % 5;
  unsigned long five = 0;
  for (int i = 0; i < 5; i++) five += ring[i];

  bool gallons = digitalRead(UNITS_SWITCH) == HIGH;
  bool using_water = digitalRead(USAGE_SWITCH) == LOW;
  unsigned long perUnit = gallons ? PULSES_PER_GALLON : PULSES_PER_LITER;
  unsigned long perMinute10 = (five * 120 + perUnit / 2) / perUnit;     // in display units
  unsigned long liters10 = (five * 120 + PULSES_PER_LITER / 2) / PULSES_PER_LITER;

  quietS = delta > 0 ? 0 : quietS + 1;
  bool flowing = quietS < GAP_S;
  if (!flowing) {
    contS = 0;
    trickleS = 0;
  } else if (liters10 > TRICKLE_MAX) {
    // The seconds after the water stops (while the average still reads high)
    // are not flow, so only a second with pulses adds to the run.
    if (delta > 0) contS++;
    trickleS = 0;
  } else {
    contS = 0;
    trickleS = using_water ? 0 : trickleS + 1;
  }

  if (!leak) {
    if (contS >= LONG_FLOW_S) closeValve("flow never stopped");
    else if (trickleS >= TRICKLE_S) closeValve("slow leak, nobody using water");
  }
  if (leak) state = "LEAK";
  else if (contS * 2 >= LONG_FLOW_S || trickleS * 2 >= TRICKLE_S) state = "WATCH";
  else state = "OK";

  if (!leak && total - savedTotal >= SAVE_EVERY) save();

  Serial.print("flow ");
  printTenths(perMinute10);
  Serial.print(gallons ? " gal/min total " : " L/min total ");
  printTenths(total * 10 / perUnit);
  Serial.print(gallons ? " gal state " : " L state ");
  Serial.print(state);
  Serial.print(" today ");
  printTenths(today * 10 / perUnit);
  Serial.print(gallons ? " gal valve " : " L valve ");
  Serial.println(leak ? "closed" : "open");
}

void loop() {
  if (millis() - lastSecond >= 1000) {
    lastSecond += 1000;
    tick();
  }

  if (pressed(reopenButton) && leak) {
    leak = false;
    contS = 0;
    trickleS = 0;
    quietS = 99;
    digitalWrite(VALVE, HIGH);
    Serial.println("valve reopened");
    save();
  }
  if (pressed(dailyButton)) {
    today = 0;
    Serial.println("daily total reset");
    save();
  }

  // LEAK: solid LED and a buzzer beeping twice a second. WATCH: a slow blink.
  bool beat = (millis() / 500) % 2;
  if (leak) {
    digitalWrite(LED, HIGH);
    digitalWrite(BUZZER, beat ? HIGH : LOW);
  } else {
    digitalWrite(LED, state[0] == 'W' && beat ? HIGH : LOW);
    digitalWrite(BUZZER, LOW);
  }
}