Line OEE dashboard on an Arduino Uno

// Line OEE dashboard: how well is this machine doing, as one number?
//
//   4       E18-D80NK, OUT (brown on 5 V, blue on GND): low while a part
//           passes; each part adds one to the count
//   3       REJECT button to GND: the last part was bad
//   2       RUN/STOP slide switch: middle to pin 2, one end to GND. To GND
//           means the machine runs; open means it is stopped (downtime)
//   A0      potentiometer: the ideal cycle time, 1.0 to 5.0 seconds a part
//   LCD     20x4, SDA -> A4    SCL -> A5    VCC -> 5 V    GND -> GND
//
// OEE (overall equipment effectiveness) multiplies three factors, and each
// one counts a different kind of loss:
//
//   Availability  run time / shift time so far      lost to stops
//   Performance   parts x ideal cycle / run time    lost to running slow
//   Quality       good parts / all parts            lost to rejects
//   OEE           A x P x Q
//
// A machine that runs 90 percent of the time, at 90 percent speed, with 90
// percent good parts is only at 73 percent OEE: small losses multiply. Stop
// the line and A falls while P and Q stay put. Feed parts slowly and only P
// falls. Press REJECT and only Q falls.
//
// A shift here is 60 seconds so you can watch a whole one. The numbers go to
// the serial monitor once a second. The loop never waits: not with delay(),
// and not on the LCD either. Writing all 80 characters at once takes long
// enough for a part to slip past the sensor unseen, so the screen is drawn
// one character per pass of the loop, between looks at the inputs.
//
// Press Run, then wave a target past the sensor every couple of seconds.

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

const int SENSOR_PIN = 4;
const int REJECT_PIN = 3;
const int RUN_PIN = 2;
const int SPEED_PIN = A0;

const unsigned long SHIFT_MS = 60000;   // one shift
const unsigned long REPORT_MS = 1000;   // serial and LCD once a second
const unsigned long DEBOUNCE_MS = 30;

LiquidCrystal_I2C lcd(0x27, 20, 4);

unsigned long shiftStart = 0;
unsigned long runMs = 0;        // time the machine was running this shift
unsigned long lastTick = 0;
unsigned long lastReport = 0;
unsigned long total = 0;
unsigned long rejects = 0;
bool lastRejected = true;       // nothing to reject before the first part
bool running = false;

// What the LCD should show, and the next character still to be written.
char screen[4][21];
int drawAt = 80;

// Debounced inputs: the reading, when it last changed, and the settled value.
struct Input {
  int pin;
  bool raw;
  unsigned long changed;
  bool stable;
};
Input part = {SENSOR_PIN, false, 0, false};
Input reject = {REJECT_PIN, false, 0, false};

// True once, when an input settles low (a part arrives, the button goes down).
bool fell(Input& in, unsigned long now) {
  bool low = digitalRead(in.pin) == LOW;
  if (low != in.raw) {
    in.raw = low;
    in.changed = now;
  }
  if (low != in.stable && now - in.changed >= DEBOUNCE_MS) {
    in.stable = low;
    return low;
  }
  return false;
}

// The knob, as an ideal cycle time in milliseconds, in tenths of a second.
unsigned long idealMs() {
  unsigned long ms = 1000 + (unsigned long)analogRead(SPEED_PIN) * 4000UL / 1023;
  return (ms + 50) / 100 * 100;
}

int percent(unsigned long part, unsigned long whole) {
  if (whole == 0) return 0;
  unsigned long p = (part * 100 + whole / 2) / whole;
  return p > 100 ? 100 : (int)p;
}

// Text into one row of `screen`, from column `col`; returns the column after.
int put(int row, int col, const char* text) {
  while (*text && col < 20) screen[row][col++] = *text++;
  return col;
}

// A number, right-aligned in `width` columns.
int putNumber(int row, int col, unsigned long value, int width) {
  char digits[11];
  int n = 0;
  do {
    digits[n++] = '0' + value % 10;
    value /= 10;
  } while (value > 0);
  while (width-- > n && col < 20) screen[row][col++] = ' ';
  while (n > 0 && col < 20) screen[row][col++] = digits[--n];
  return col;
}

// Write one character of `screen` to the LCD: a few hundred microseconds.
void drawOne() {
  if (drawAt >= 80) return;
  int row = drawAt / 20;
  int col = drawAt % 20;
  if (col == 0) lcd.setCursor(0, row);
  lcd.print(screen[row][col]);
  drawAt++;
}

void report(unsigned long now) {
  unsigned long elapsed = now - shiftStart;
  unsigned long ideal = idealMs();
  unsigned long good = total - rejects;
  int a = percent(runMs, elapsed);
  // Performance in whole seconds of work, so the sum fits in a long.
  int p = percent(total * (ideal / 100), runMs / 100);
  int q = total == 0 ? 100 : percent(good, total);
  int oee = (int)(((long)a * p * q + 5000) / 10000);

  Serial.print("t ");
  Serial.print(elapsed / 1000);
  Serial.print(running ? " RUN" : " STOP");
  Serial.print(" total ");
  Serial.print(total);
  Serial.print(" good ");
  Serial.print(good);
  Serial.print(" reject ");
  Serial.print(rejects);
  Serial.print(" ideal ");
  Serial.print(ideal);
  Serial.print(" A ");
  Serial.print(a);
  Serial.print(" P ");
  Serial.print(p);
  Serial.print(" Q ");
  Serial.print(q);
  Serial.print(" OEE ");
  Serial.println(oee);

  for (int row = 0; row < 4; row++) {
    for (int col = 0; col < 20; col++) screen[row][col] = ' ';
    screen[row][20] = 0;
  }
  int col = put(0, 0, running ? "RUN " : "STOP");
  col = put(0, col, "  Count ");
  putNumber(0, col, total, 1);
  col = put(1, 0, "Good ");
  col = putNumber(1, col, good, 1);
  col = put(1, col, "  Reject ");
  putNumber(1, col, rejects, 1);
  col = put(2, 0, "A");
  col = putNumber(2, col, a, 4);
  col = put(2, col, "% P");
  col = putNumber(2, col, p, 4);
  col = put(2, col, "% Q");
  col = putNumber(2, col, q, 4);
  put(2, col, "%");
  col = put(3, 0, "OEE");
  col = putNumber(3, col, oee, 4);
  col = put(3, col, "%  Ideal ");
  col = putNumber(3, col, ideal / 1000, 1);
  col = put(3, col, ".");
  col = putNumber(3, col, ideal / 100 % 10, 1);
  put(3, col, "s");
  drawAt = 0;
}

void newShift(unsigned long now) {
  shiftStart = now;
  lastTick = now;
  lastReport = now;
  runMs = 0;
  total = 0;
  rejects = 0;
  lastRejected = true;
  Serial.println("shift start");
}

void setup() {
  pinMode(SENSOR_PIN, INPUT_PULLUP);
  pinMode(REJECT_PIN, INPUT_PULLUP);
  pinMode(RUN_PIN, INPUT_PULLUP);
  Serial.begin(9600);
  Serial.println("Line OEE dashboard");
  lcd.init();
  lcd.backlight();
  newShift(millis());
}

void loop() {
  unsigned long now = millis();

  // Run time grows only while the switch says the machine runs.
  bool runNow = digitalRead(RUN_PIN) == LOW;
  if (running) runMs += now - lastTick;
  lastTick = now;
  if (runNow != running) {
    running = runNow;
    Serial.println(running ? "machine running" : "machine stopped");
  }

  if (fell(part, now)) {
    total++;
    lastRejected = false;
    Serial.print("part ");
    Serial.println(total);
  }
  // One reject per part: the button marks the last part bad, once.
  if (fell(reject, now) && !lastRejected) {
    rejects++;
    lastRejected = true;
    Serial.print("reject ");
    Serial.println(rejects);
  }

  if (now - lastReport >= REPORT_MS) {
    lastReport += REPORT_MS;
    report(now);
  }

  drawOne();

  if (now - shiftStart >= SHIFT_MS) {
    report(now);
    Serial.println("shift over");
    newShift(now);
  }
}