Engine tachometer with shift light on an Arduino Uno

// Engine tachometer with shift light: engine pulses on pin 2, the rpm on a
// 16x2 I2C LCD, and a ten-segment LED bar that fills as the revs climb and
// flashes at the shift point.
//
//   2        the conditioned engine pulse (INT0), 0 V / 5 V, through 1 k;
//            its pull-up is on, so a loose wire reads no pulses
//   3 to 12  the bar graph's anodes A1 to A10, each through its own 220 ohm;
//            the cathodes to GND
//   LCD      SDA -> A4    SCL -> A5    VCC -> 5 V    GND -> GND
//
// SAFETY: this is a teaching simulation. Never connect a project like this to
// a running car's safety systems (brakes, airbags, steering, ECU wiring,
// anything that can strand or hurt someone). Try it on the bench with a bench
// supply or a 12 V battery, fused. The negative side of an ignition coil
// swings to a few hundred volts each spark, and a car's 12 V line carries
// load-dump spikes, so a real install needs an automotive-rated front end
// (a fuse, a clamp or TVS diode, and an optocoupler or a divider) that hands
// the Uno a clean 0 to 5 V pulse. A Hall sensor such as the A3144 on 5 V, with
// a pull-up on its open-collector output, gives that pulse directly.
//
// Pulses per revolution depend on what you trigger from:
//   a magnet on the crank pulley and one Hall sensor   1 pulse a turn
//   a 4-cylinder 4-stroke ignition (coil or tach out)  2 pulses a turn
//   (a 4-stroke fires every cylinder once in two turns: cylinders / 2;
//    a 6-cylinder gives 3, a V8 gives 4)
// This sketch is set for the 4-cylinder ignition: 800 rpm idle is 26.7 Hz,
// 6500 rpm is 216.7 Hz.
//
// Why time the period instead of counting pulses: at 800 rpm only about 6.7
// pulses arrive in a quarter second, so a counter would read 720 or 840 and
// jump between them. Timing the gap between two pulses with micros() (4 us
// steps) measures 37500 us to a hundredth of a percent, after one pulse. The
// rpm is then 60,000,000 us a minute / (period x pulses per rev).
//
// The sketch averages the last 8 periods to steady the reading (smoothing),
// throws away any gap shorter than 2 ms (spark ringing, a bounce: that would
// be 15000 rpm), and reads 0 when no pulse has come for half a second.
//
// Shift light: no bars under 2500 rpm, then one more bar each 400 rpm (bar 10
// at 6100 rpm). From 6500 rpm, the shift point, the whole bar flashes. From
// 7000 rpm, a typical redline for a small 4-cylinder, the LCD says OVER-REV.
//
// Press Run, then set the square-wave source's frequency (hz) in its
// properties: 26.7 Hz is an 800 rpm idle, 100 Hz is 3000 rpm, 216.7 Hz is
// 6500 rpm and 240 Hz is 7200 rpm. The serial monitor prints what the LCD shows.

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

const int PULSE_PIN = 2;  // INT0
const uint8_t BAR_PINS[10] = {3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

const unsigned long PULSES_PER_REV = 2;   // 4-cylinder 4-stroke ignition
const unsigned long MIN_PERIOD_US = 2000; // shorter is noise
const unsigned long STALL_US = 500000;    // no pulse this long: engine off

const long LIGHT_START = 2500;  // first bar
const long LIGHT_STEP = 400;    // rpm per bar
const long SHIFT_RPM = 6500;    // flash: change gear now
const long REDLINE = 7000;      // over-rev warning

const uint8_t AVERAGE = 8;  // periods averaged

LiquidCrystal_I2C lcd(0x27, 16, 2);

// Written by the interrupt, read by loop(): volatile, and copied with
// interrupts off so a pulse cannot change them halfway through the copy.
volatile unsigned long lastPulse = 0;
volatile bool seenPulse = false;
volatile unsigned long periods[AVERAGE];
volatile unsigned long periodSum = 0;
volatile uint8_t slot = 0;
volatile uint8_t filled = 0;

// Runs on every rising edge: keep it short, just the time stamp and the sum.
void onPulse() {
  unsigned long now = micros();
  unsigned long period = now - lastPulse;
  if (seenPulse && period < MIN_PERIOD_US) return;  // too soon: ignore it
  lastPulse = now;
  if (seenPulse) {
    periodSum = periodSum - periods[slot] + period;
    periods[slot] = period;
    slot = (slot + 1) % AVERAGE;
    if (filled < AVERAGE) filled++;
  }
  seenPulse = true;
}

// The rpm from the averaged period, rounded to the nearest whole rpm.
long readRpm() {
  noInterrupts();
  unsigned long sum = periodSum;
  uint8_t n = filled;
  unsigned long since = micros() - lastPulse;
  if (seenPulse && since > STALL_US) {
    // Stalled: forget the old periods, or the long gap would drag the
    // average down for the first few pulses after a restart.
    seenPulse = false;
    filled = 0;
    periodSum = 0;
    for (uint8_t i = 0; i < AVERAGE; i++) periods[i] = 0;
  }
  bool stalled = !seenPulse;
  interrupts();
  if (n == 0 || stalled) return 0;
  // average period = sum / n, so rpm = 60e6 * n / (sum * pulses per rev)
  unsigned long divisor = sum * PULSES_PER_REV;
  return (long)((60000000UL * n + divisor / 2) / divisor);
}

// How many bars to light for a reading.
int barsFor(long rpm) {
  if (rpm < LIGHT_START) return 0;
  long bars = 1 + (rpm - LIGHT_START) / LIGHT_STEP;
  return bars > 10 ? 10 : (int)bars;
}

void showBars(int lit) {
  for (int i = 0; i < 10; i++) digitalWrite(BAR_PINS[i], i < lit ? HIGH : LOW);
}

void setup() {
  for (int i = 0; i < 10; i++) pinMode(BAR_PINS[i], OUTPUT);
  pinMode(PULSE_PIN, INPUT_PULLUP);  // held high, so a loose wire reads no pulses
  attachInterrupt(digitalPinToInterrupt(PULSE_PIN), onPulse, RISING);
  Serial.begin(115200);
  Serial.println("Engine tachometer");
  lcd.init();
  lcd.backlight();
  lcd.print("Tachometer");
}

unsigned long lastPrint = 0;
long lcdRpm = -1;     // what the LCD shows now, so it is only rewritten on a change
int lcdState = -1;

// What line 2 says: 0 to 10 bars, or one of these.
const int ENGINE_OFF = -1;
const int SHIFT = 11;
const int OVER_REV = 12;

int stateFor(long shown) {
  if (shown == 0) return ENGINE_OFF;
  if (shown >= REDLINE) return OVER_REV;
  if (shown >= SHIFT_RPM) return SHIFT;
  return barsFor(shown);
}

void printState(Print &out, int state) {
  if (state == ENGINE_OFF) {
    out.print("engine off");
  } else if (state == OVER_REV) {
    out.print("OVER-REV!");
  } else if (state == SHIFT) {
    out.print("SHIFT UP!");
  } else {
    out.print("bars ");
    out.print(state);
    out.print("/10");
  }
}

void loop() {
  long rpm = readRpm();
  // A real tach shows tens: the last digit only flickers.
  long shown = (rpm + 5) / 10 * 10;
  int state = stateFor(shown);

  // The bar: fill, or flash the whole bar five times a second at the shift
  // point. It goes by the rpm shown, so the light and the LCD always agree.
  if (state == SHIFT || state == OVER_REV) {
    showBars((millis() / 100) % 2 == 0 ? 10 : 0);
  } else {
    showBars(state < 0 ? 0 : state);
  }

  // An I2C LCD takes a few milliseconds a character, long enough to stall the
  // flashing, so it is only rewritten when what it shows has changed.
  if (shown != lcdRpm) {
    lcdRpm = shown;
    lcd.setCursor(0, 0);
    lcd.print("RPM ");
    lcd.print(shown);
    lcd.print("      ");
  }
  if (state != lcdState) {
    lcdState = state;
    lcd.setCursor(0, 1);
    printState(lcd, state);
    lcd.print("     ");
  }

  if (millis() - lastPrint >= 250) {
    lastPrint = millis();
    Serial.print(shown);
    Serial.print(" rpm  ");
    printState(Serial, state);
    Serial.println();
  }
}