Turn signals and hazard flasher on an Arduino Uno

// Turn signals and hazard flasher: an Uno as a car's electronic flasher unit.
// Three buttons pick left, right or hazard; a two-channel relay board switches
// two 12 V bulbs a side from a 12 V lead-acid battery; an INA219 in the feed
// measures the bulbs' current, and a burned-out bulb makes that side
// "hyper-flash" at double rate with the BULB OUT light on, as a real car does.
//
//   D2  LEFT button     D3  RIGHT button    D4  HAZARD button
//       (each to GND, using the Uno's internal pull-ups)
//   D7  BULB OUT warning LED, through 330 ohms
//   D9  relay board IN1: the left bulbs    D8  relay board IN2: the right bulbs
//   A4  INA219 SDA      A5  INA219 SCL
//
//   battery + -> INA219 VIN+ ; VIN- -> both relays' COM ; each NO -> its two
//   bulbs ; the bulbs' other ends, the battery's minus and the Uno's GND all
//   on one ground, the way a car grounds its lamps to the body.
//
// The legal rate (US FMVSS 108) is 60 to 120 flashes a minute; 90 a minute,
// on half the time, is 333 ms on and 333 ms off. A side with a bulb out flashes
// twice as fast, 180 a minute, which is outside the legal range on purpose: it
// is the driver's warning.
//
// The bulb check: each lit bulb draws about 100 mA (the catalog's 12 V 0.1 A
// lamp; a real 1156 or 7440 turn bulb is 21 to 27 W, about 2 A). The sketch
// reads the current near the end of each flash, once the cold filament's
// inrush (about ten times the running current) has died away, and counts the
// bulbs. Fewer than it expects means one is out.
//
// SAFETY: this is a teaching simulation. Never connect a project like this to
// a running car's safety systems or wiring (brakes, airbags, steering, the ECU,
// the lighting a car needs to be legal and seen). On the bench use a 12 V
// battery or supply with a fuse in its lead. A real install needs an
// automotive-rated design: fusing, load-dump and reverse-polarity protection,
// relays and wiring rated for the bulbs' amps, and DOT-legal lamps.
//
// Press Run, then press LEFT, RIGHT or HAZARD. Slide the switch by the front
// left bulb to pull that bulb out of its socket.

#include <Wire.h>
#include <Adafruit_INA219.h>

const int LEFT_BUTTON = 2;
const int RIGHT_BUTTON = 3;
const int HAZARD_BUTTON = 4;
const int WARNING_LED = 7;
const int LEFT_RELAY = 9;   // relay board IN1
const int RIGHT_RELAY = 8;  // relay board IN2

// 90 flashes a minute, and twice that with a bulb out.
const unsigned long NORMAL_HALF_MS = 333;
const unsigned long FAST_HALF_MS = 167;
// Wait this long into a flash before trusting the current: the relay takes
// about 10 ms to pull in, and a cold filament surges for tens of ms.
const unsigned long SETTLE_MS = 100;
const unsigned long DEBOUNCE_MS = 25;

// One lit 12 V 0.1 A bulb, near enough, at the battery's 12.8 V.
const float BULB_MA = 100.0;

enum Mode { OFF, LEFT, RIGHT, HAZARD };
const char *const MODE_NAMES[] = { "Off", "Left", "Right", "Hazard" };

Adafruit_INA219 ina;

// What the driver has asked for: the stalk (off, left or right) and the hazard
// switch, which overrides the stalk while it is on.
Mode stalk = OFF;
bool hazard = false;
Mode mode = OFF;

bool lampsOn = false;
unsigned long phaseStart = 0;
float lastMilliamps = 0;     // the newest settled reading this flash
bool haveReading = false;
bool bulbOut = false;
int shownBulbs = -1;         // the bulb count last printed

// A pushbutton bounces for a few ms when pressed: only a level that holds for
// DEBOUNCE_MS counts.
struct Button {
  int pin;
  int stable;
  int last;
  unsigned long changed;
};
Button buttons[] = {
  { LEFT_BUTTON, HIGH, HIGH, 0 },
  { RIGHT_BUTTON, HIGH, HIGH, 0 },
  { HAZARD_BUTTON, HIGH, HIGH, 0 },
};

// True once for each clean press.
bool pressed(Button &b) {
  int raw = digitalRead(b.pin);
  unsigned long now = millis();
  if (raw != b.last) {
    b.last = raw;
    b.changed = now;
  }
  if (now - b.changed >= DEBOUNCE_MS && raw != b.stable) {
    b.stable = raw;
    return raw == LOW;
  }
  return false;
}

// The relay board is active low: LOW on IN pulls the relay in.
void driveLamps(bool on) {
  lampsOn = on;
  bool left = on && (mode == LEFT || mode == HAZARD);
  bool right = on && (mode == RIGHT || mode == HAZARD);
  digitalWrite(LEFT_RELAY, left ? LOW : HIGH);
  digitalWrite(RIGHT_RELAY, right ? LOW : HIGH);
}

int expectedBulbs() {
  if (mode == HAZARD) return 4;
  if (mode == LEFT || mode == RIGHT) return 2;
  return 0;
}

// Hyper-flash only on a turn: a hazard flasher keeps the legal rate whatever
// the load, as the heavy-duty hazard flashers in older cars did.
unsigned long halfPeriod() {
  return (bulbOut && mode != HAZARD) ? FAST_HALF_MS : NORMAL_HALF_MS;
}

void setMode(Mode m) {
  if (m == mode) return;
  mode = m;
  bulbOut = false;
  shownBulbs = -1;
  digitalWrite(WARNING_LED, LOW);
  Serial.println(MODE_NAMES[mode]);
  // A flasher starts with the lamps lit, so the first flash is immediate.
  phaseStart = millis();
  haveReading = false;
  driveLamps(mode != OFF);
}

// At the end of each flash: count the bulbs from the current.
void checkBulbs() {
  if (!haveReading) return;
  int want = expectedBulbs();
  int bulbs = (int)(lastMilliamps / BULB_MA + 0.5);
  bulbOut = bulbs < want;
  digitalWrite(WARNING_LED, bulbOut ? HIGH : LOW);
  if (bulbs != shownBulbs) {
    shownBulbs = bulbs;
    Serial.print(MODE_NAMES[mode]);
    Serial.print(": ");
    Serial.print((int)(lastMilliamps + 0.5));
    Serial.print(" mA, ");
    Serial.print(bulbs);
    Serial.print(bulbs == 1 ? " bulb" : " bulbs");
    if (bulbOut) Serial.print(mode == HAZARD ? ": BULB OUT" : ": BULB OUT, fast flash");
    Serial.println();
  }
}

void setup() {
  // Write the relay pins HIGH before they become outputs, or both relays
  // click on for an instant at power-up.
  digitalWrite(LEFT_RELAY, HIGH);
  digitalWrite(RIGHT_RELAY, HIGH);
  pinMode(LEFT_RELAY, OUTPUT);
  pinMode(RIGHT_RELAY, OUTPUT);
  pinMode(WARNING_LED, OUTPUT);
  pinMode(LEFT_BUTTON, INPUT_PULLUP);
  pinMode(RIGHT_BUTTON, INPUT_PULLUP);
  pinMode(HAZARD_BUTTON, INPUT_PULLUP);

  Serial.begin(9600);
  Serial.println("Turn signals and hazard flasher");
  if (!ina.begin()) Serial.println("No INA219 at 0x40: check SDA and SCL");
  ina.setCalibration_32V_1A();
  delay(5);
  Serial.print("Battery ");
  Serial.print(ina.getBusVoltage_V(), 1);
  Serial.println(" V");
}

void loop() {
  // The state machine's inputs: three debounced buttons.
  if (pressed(buttons[0])) stalk = (stalk == LEFT) ? OFF : LEFT;
  if (pressed(buttons[1])) stalk = (stalk == RIGHT) ? OFF : RIGHT;
  if (pressed(buttons[2])) hazard = !hazard;
  setMode(hazard ? HAZARD : stalk);

  if (mode == OFF) return;

  unsigned long now = millis();
  unsigned long inPhase = now - phaseStart;
  if (lampsOn && inPhase >= SETTLE_MS) {
    lastMilliamps = ina.getCurrent_mA();
    haveReading = true;
  }
  unsigned long half = halfPeriod();
  if (inPhase >= half) {
    if (lampsOn) checkBulbs();
    phaseStart += half;  // not "= now", so the rate does not drift
    haveReading = false;
    driveLamps(!lampsOn);
  }
}