Engine hour meter on an Arduino Uno

// Engine hour meter: counts the time an engine runs, keeps the total and the
// hours since the last service in EEPROM, shows both on a 16x2 I2C LCD, and
// lights a service light and beeps when the service interval comes round.
// For tractors, generators, boats, forklifts and shop equipment, where hours
// matter more than miles.
//
//   A0      the sense divider's middle: 33 k from the switched 12 V feed,
//           10 k to ground, and a 5.1 V Zener (1N4733A) from A0 to ground,
//           band to A0
//   2       the service reset button to GND (hold it 3 s)
//   A1      the service light: 220 R then a red LED to GND
//   8       the active buzzer's plus leg, its other leg on GND
//   LCD     SDA -> A4    SCL -> A5    VCC -> 5 V    GND -> GND (address 0x27)
//   The 12 V minus goes to the Uno's GND: one ground for both.
//
// SAFETY. This is a teaching simulation. Never connect a project like this to
// a running vehicle's safety systems (brakes, airbags, steering, ECU wiring,
// or anything that can strand or hurt someone). Try it on a bench supply or a
// 12 V battery on the bench, with a fuse in the plus lead. A real install
// needs a proper automotive front end: an inline fuse where the sense wire
// taps the feed, a TVS diode for load dump, and the clamp below.
//
// IS THE ENGINE RUNNING? The sense wire is on a switched feed (one that is
// live only with the key on). Key on and engine stopped, that feed is the
// battery: about 12.6 V when full. With the engine running the alternator
// lifts it to 13.8 to 14.7 V. So:
//   13.3 V or more for 2 s       running: the meter counts
//   under 13.0 V for 2 s         stopped (key on, engine off, or a stall)
//   under 6 V                    key off: stopped at once, and saved at once
// The 2 s debounce keeps a short sag (a big load switching on) or a spike
// from starting or stopping the count, and the two thresholds 0.3 V apart are
// hysteresis, so a voltage sitting right on the line cannot flicker. The 2 s
// it takes to agree the engine started and the 2 s to agree it stopped
// roughly cancel out. A cranking dip (9 to 10 V) is not running, so a start
// counts from when the alternator charges. Simplified: a tired alternator
// that only makes 13.2 V would not count; set RUN_ON lower for one.
//
// THE OTHER WAY: an oil pressure switch. Most engines have one for the oil
// light. It closes to ground when there is no oil pressure (engine stopped)
// and opens once the engine pumps oil. Wired to a pin with INPUT_PULLUP, the
// pin is HIGH while running: no divider needed, and it works on engines with
// no alternator. Debounce it the same way. Do not share the dash light's
// wire with a second load without checking the switch's rating.
//
// THE DIVIDER. 10 k of 33 k + 10 k is 0.2326 of the input, so 14.4 V reads as
// 3.35 V on A0 and 5 V on A0 is 21.5 V at the feed. The Zener clamps A0 near
// 5 V during load dump (tens of volts for a few hundred ms) and near -0.7 V
// with jump leads on backwards; the 33 k limits its current to under 2 mA
// at 60 V.
//
// TIME KEEPING WITH millis(). millis() counts milliseconds since reset and
// wraps round after 49.7 days. "now - lastTick" is still right across the
// wrap, because unsigned subtraction wraps too. Each pass adds the elapsed
// milliseconds while running and moves whole seconds out into the counters,
// so no time is lost to rounding however fast or slow loop() goes.
//
// THE EEPROM AND ITS WEAR. The ATmega328P's EEPROM is rated for about
// 100,000 writes per cell. Saving every minute to one address would wear it
// out in 100,000 minutes: 1,667 engine hours, which a farm tractor does in a
// couple of years. So:
//   * it saves every 6 minutes of running (0.1 h), and when the engine stops
//   * each save goes to the NEXT of 64 slots of 16 bytes, round and round,
//     so each cell is written once every 64 saves: 6.4 running hours apart,
//     about 640,000 hours before any cell reaches 100,000 writes
//   * every slot carries a sequence number; at start-up the slot with the
//     highest one that passes its checksum is the newest
//   * a power cut in the middle of a save leaves a slot whose checksum fails,
//     and the slot before it is still good: the worst case loses 6 minutes
//
// POWER-LOSS SAFETY. Here the Uno has its own 5 V and the sense wire tells it
// the key went off, so it saves at once. If you power the Uno from the same
// switched feed, it dies when the key turns off, so give it a hold-up: a
// diode into a 4700 uF capacitor ahead of the regulator. At about 50 mA that
// cap takes 0.0047 F x 5 V / 0.05 A = 0.47 s to fall from 12 V to the 7 V
// the regulator needs, and a 16 byte save takes about 55 ms (3.4 ms a byte).
// Sense the feed BEFORE the diode, so the Uno sees it drop while it still has
// power.
//
// THE SERVICE INTERVAL. SERVICE_HOURS is 250, a common oil change interval on
// small engines; your engine maker's manual has the real one. At 250 h the
// service light comes on and the buzzer beeps three times, and again at every
// start while it is due. Hold the button 3 s after the service: the "since
// service" count goes back to zero and a long beep says so. A short press
// does nothing, so it cannot be reset by accident.
//
// SETTING IT. Fitting the meter to an engine that already has hours? Type in
// the serial monitor:
//   H 1234.5     sets the total to 1234.5 h
//   S 12.25      sets the hours since service to 12.25 h
// (to 0.01 h, which is 36 s).
//
// Press Run, then set the supply to 14.2 V (running), 12.6 V (stopped) and
// 0 V (key off). Type S 249.99 and run it for a minute to see the service due.

#include <Wire.h>
#include <EEPROM.h>
#include <LiquidCrystal_I2C.h>

const int SENSE_PIN = A0;
const int BUTTON_PIN = 2;
const int SERVICE_LED_PIN = A1;
const int BUZZER_PIN = 8;

// The divider: (R1 + R2) / R2 turns the volts at A0 back into feed volts.
const float R1 = 33000.0;
const float R2 = 10000.0;

const float RUN_ON = 13.3;    // the alternator is charging: running
const float RUN_OFF = 13.0;   // under this, the engine has stopped
const float KEY_OFF = 6.0;    // under this, the switched feed is off
const unsigned long DEBOUNCE_MS = 2000;

const unsigned long SERVICE_HOURS = 250;  // follow your engine's manual
const unsigned long SERVICE_SECONDS = SERVICE_HOURS * 3600UL;
const unsigned long SAVE_EVERY_S = 360;   // 6 minutes, 0.1 h
const unsigned long HOLD_MS = 3000;       // the service reset press

// One save: 16 bytes, 64 of them fill the Uno's 1024 byte EEPROM.
struct Record {
  unsigned long seq;         // counts up with every save
  unsigned long totalS;      // the engine's total running seconds
  unsigned long serviceS;    // running seconds since the last service
  byte check;                // see checksum()
  byte spare[3];
};
const int SLOT_SIZE = sizeof(Record);
const int SLOTS = 1024 / SLOT_SIZE;

LiquidCrystal_I2C lcd(0x27, 16, 2);

unsigned long totalS = 0;
unsigned long serviceS = 0;
unsigned long seq = 0;            // the newest record's number
int slot = -1;                    // where the newest record is, -1 for none
unsigned long savedTotalS = 0;    // totalS at the last save

bool running = false;
unsigned long changeSince = 0;    // when the reading first disagreed with running
unsigned long lastTick = 0;
unsigned long carryMs = 0;        // running milliseconds not yet a whole second

bool due = false;
int beepsLeft = 0;                // half beeps: on, off, on, off...
unsigned long beepAt = 0;
unsigned long beepLen = 150;

bool buttonDown = false;
unsigned long pressedAt = 0;
bool pressDone = false;

unsigned long lastReport = 0;
char line[16];
byte lineLen = 0;

// The sum of the record's first 12 bytes plus a constant: an all-0xFF blank
// slot never passes. (A CRC would catch more; this catches a torn write.)
byte checksum(const Record &r) {
  const byte *p = (const byte *)&r;
  byte sum = 0x5A;
  for (int i = 0; i < 12; i++) sum += p[i];
  return sum;
}

// Find the newest good record, if there is one.
void load() {
  for (int i = 0; i < SLOTS; i++) {
    Record r;
    EEPROM.get(i * SLOT_SIZE, r);
    if (r.check != checksum(r)) continue;
    if (slot < 0 || r.seq > seq) {
      slot = i;
      seq = r.seq;
      totalS = r.totalS;
      serviceS = r.serviceS;
    }
  }
  savedTotalS = totalS;
}

// Write the counters to the next slot round.
void save(const char *why) {
  Record r;
  seq++;
  slot = (slot + 1) % SLOTS;
  r.seq = seq;
  r.totalS = totalS;
  r.serviceS = serviceS;
  r.check = checksum(r);
  r.spare[0] = r.spare[1] = r.spare[2] = 0;
  EEPROM.put(slot * SLOT_SIZE, r);
  savedTotalS = totalS;
  Serial.print(why);
  Serial.print(", saved to slot ");
  Serial.println(slot);
}

float readVolts() {
  long sum = 0;
  for (int i = 0; i < 8; i++) sum += analogRead(SENSE_PIN);
  return sum / 8.0 * 5.0 / 1023.0 * (R1 + R2) / R2;
}

void beep(int times, unsigned long len) {
  beepsLeft = times * 2;
  beepLen = len;
  beepAt = millis();
  digitalWrite(BUZZER_PIN, HIGH);
}

// Seconds as hours to 0.1 h, rounded down so it never claims time not run.
void printTenths(Print &out, unsigned long s) {
  unsigned long tenths = s / 360;
  out.print(tenths / 10);
  out.print('.');
  out.print(tenths % 10);
}

void checkDue() {
  bool now = serviceS >= SERVICE_SECONDS;
  if (now && !due) {
    Serial.println("SERVICE DUE");
    beep(3, 150);
  }
  due = now;
  digitalWrite(SERVICE_LED_PIN, due ? HIGH : LOW);
}

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(SERVICE_LED_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  Serial.begin(9600);
  Serial.println("Engine hour meter");
  lcd.init();
  lcd.backlight();
  load();
  if (slot < 0) {
    Serial.println("blank EEPROM, starting from 0");
  } else {
    Serial.print("loaded slot ");
    Serial.print(slot);
    Serial.print(": total ");
    Serial.print(totalS);
    Serial.print(" s, service ");
    Serial.print(serviceS);
    Serial.println(" s");
  }
  due = serviceS >= SERVICE_SECONDS;  // no beep until the engine starts
  digitalWrite(SERVICE_LED_PIN, due ? HIGH : LOW);
  lastTick = millis();
}

// The engine's state from the sense voltage, debounced.
void sense(float v, unsigned long now) {
  if (running && v < KEY_OFF) {
    running = false;
    Serial.println("key off");
    save("stopped");
    return;
  }
  bool looksRunning = running ? v >= RUN_OFF : v >= RUN_ON;
  if (looksRunning == running) {
    changeSince = now;
    return;
  }
  if (now - changeSince < DEBOUNCE_MS) return;
  running = looksRunning;
  changeSince = now;
  if (running) {
    Serial.println("engine running");
    if (due) beep(3, 150);
  } else {
    save("engine stopped");
  }
}

// Add the time since the last pass while running.
void tick(unsigned long now) {
  unsigned long dt = now - lastTick;
  lastTick = now;
  if (!running) return;
  carryMs += dt;
  while (carryMs >= 1000) {
    carryMs -= 1000;
    totalS++;
    serviceS++;
  }
  if (totalS - savedTotalS >= SAVE_EVERY_S) save("6 minutes");
  checkDue();
}

// Hold the button 3 s to zero the service count.
void button(unsigned long now) {
  bool down = digitalRead(BUTTON_PIN) == LOW;
  if (down && !buttonDown) {
    pressedAt = now;
    pressDone = false;
  }
  buttonDown = down;
  if (down && !pressDone && now - pressedAt >= HOLD_MS) {
    pressDone = true;
    serviceS = 0;
    Serial.println("service reset");
    save("service reset");
    checkDue();
    beep(1, 800);
  }
}

// Steps the beeps along without delay(). It reads millis() itself rather
// than the loop's "now", because beep() may have stamped beepAt later in the
// same pass, and an unsigned "now - beepAt" would then wrap to a huge number.
void buzzer() {
  unsigned long now = millis();
  if (beepsLeft == 0 || now - beepAt < beepLen) return;
  beepAt = now;
  beepsLeft--;
  digitalWrite(BUZZER_PIN, beepsLeft > 0 && beepsLeft % 2 == 0 ? HIGH : LOW);
}

// Hours typed as "H 1234.5" or "S 12.25", to seconds, to 0.01 h.
long parseHours(const char *s) {
  long hundredths = 0;
  int decimals = -1;
  for (; *s; s++) {
    if (*s == '.' && decimals < 0) {
      decimals = 0;
    } else if (*s >= '0' && *s <= '9') {
      if (decimals >= 2) continue;
      hundredths = hundredths * 10 + (*s - '0');
      if (decimals >= 0) decimals++;
    } else if (*s != ' ') {
      return -1;
    }
  }
  if (decimals < 0) decimals = 0;
  for (; decimals < 2; decimals++) hundredths *= 10;
  return hundredths * 36;
}

void command() {
  while (Serial.available() > 0) {
    char c = Serial.read();
    if (c != '\n' && c != '\r') {
      if (lineLen < sizeof(line) - 1) line[lineLen++] = c;
      continue;
    }
    if (lineLen == 0) continue;
    line[lineLen] = 0;
    lineLen = 0;
    char which = line[0] & ~0x20;  // upper case
    long s = parseHours(line + 1);
    if ((which != 'H' && which != 'S') || s < 0) {
      Serial.println("type H 1234.5 for the total or S 12.25 for since service");
      continue;
    }
    if (which == 'H') totalS = s;
    else serviceS = s;
    save(which == 'H' ? "total set" : "service set");
    checkDue();
  }
}

void show(float v) {
  lcd.setCursor(0, 0);
  lcd.print("Total ");
  printTenths(lcd, totalS);
  lcd.print(" h");
  lcd.print(running ? " RUN    " : "        ");
  lcd.setCursor(0, 1);
  if (due) lcd.print("SVC DUE ");
  else lcd.print("Service ");
  printTenths(lcd, serviceS);
  lcd.print(" h        ");

  Serial.print("total ");
  printTenths(Serial, totalS);
  Serial.print(" h (");
  Serial.print(totalS / 3600);
  Serial.print(" h ");
  Serial.print(totalS / 60 % 60);
  Serial.print(" min)  service ");
  printTenths(Serial, serviceS);
  Serial.print(" h of ");
  Serial.print(SERVICE_HOURS);
  Serial.print(due ? " DUE  " : "  ");
  Serial.print(v, 1);
  Serial.println(running ? " V running" : " V stopped");
}

void loop() {
  unsigned long now = millis();
  float v = readVolts();
  sense(v, now);
  tick(now);
  button(now);
  buzzer();
  command();
  if (now - lastReport >= 1000) {
    lastReport = now;
    show(v);
  }
  delay(20);
}