Merge jam on an Arduino Uno

// Merge jam: two feeder conveyors take turns putting items onto one shared
// belt, and watchdog timers catch a jam.
//
//   2       E18-D80NK at feeder A's merge point, OUT low while it sees an item
//   3       E18-D80NK at feeder B's merge point
//   8       E18-D80NK on the shared belt, past the merge
//   4       relay 1, feeder A's motor (its 5 V is on the relay's contacts)
//   5       relay 2, feeder B's motor
//   6       RESET, a pushbutton to GND
//   13/12/11 the stack light: red, yellow, green
//   LCD     SDA -> A4    SCL -> A5    VCC -> 5 V    GND -> GND
//   (each sensor: brown on 5 V, blue on GND)
//
// Two belts that feed one belt must never push at the same time, or items
// collide at the merge. So only one feeder runs at a time, and they take
// turns, one item each. That is arbitration: a rule that decides who goes.
//
//   FEED     the feeder whose turn it is runs until an item has passed its
//            merge beam, then it stops.
//   TRANSIT  both feeders stopped. The item rides the shared belt to its
//            sensor; when it gets there it is counted, and the turn goes to
//            the other feeder.
//   JAM      both feeders stopped, red light. Only RESET gets you out.
//
// A feeder with nothing to send loses its turn after IDLE_MS, so an empty
// lane never holds up a full one.
//
// The jam detection is two watchdog timers. A machine cannot see a jam, but
// it knows how long things should take:
//
//   JAM A / JAM B   an item sits in a running feeder's merge beam for more
//                   than STUCK_MS. Something is wedged at the merge.
//   LOST ITEM       an item passed the merge but never reached the belt
//                   sensor within LOST_MS. It fell off, or it is stuck out of
//                   sight.
//
// After a jam someone has to clear it by hand, then press RESET. RESET is
// refused while any beam is still blocked, so the line cannot restart into
// the same jam.
//
// Press Run, then move the sensors' targets close and away to send items.

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

const int SENSOR_A_PIN = 2;
const int SENSOR_B_PIN = 3;
const int BELT_PIN = 8;
const int MOTOR_A_PIN = 4;
const int MOTOR_B_PIN = 5;
const int RESET_PIN = 6;
const int RED_PIN = 13;
const int YELLOW_PIN = 12;
const int GREEN_PIN = 11;

const unsigned long STUCK_MS = 5000;  // longest an item may block a merge beam
const unsigned long LOST_MS = 6000;   // longest the trip to the belt sensor may take
const unsigned long IDLE_MS = 4000;   // a feeder with nothing to send gives up its turn

// The relay board switches on a low input.
const int ON = LOW;
const int OFF = HIGH;

enum State { FEED, TRANSIT, JAM };
enum Fault { NONE, JAM_A, JAM_B, LOST_ITEM };
const char* const FAULTS[] = {"", "JAM A", "JAM B", "LOST ITEM"};

LiquidCrystal_I2C lcd(0x27, 16, 2);

State state = FEED;
Fault fault = NONE;
int turn = 0;                 // 0 = feeder A, 1 = feeder B
unsigned long enteredAt = 0;  // when this state began
unsigned long blockedSince = 0;
bool wasBlocked = false;
bool beltWasBlocked = false;
bool resetWasDown = false;
unsigned long resetAt = 0;
unsigned long counts[2] = {0, 0};

char feederName(int f) {
  return f == 0 ? 'A' : 'B';
}

bool seesItem(int pin) {
  return digitalRead(pin) == LOW;
}

bool mergeBlocked(int f) {
  return seesItem(f == 0 ? SENSOR_A_PIN : SENSOR_B_PIN);
}

void printCount(unsigned long n) {
  if (n < 100) lcd.print(' ');
  if (n < 10) lcd.print(' ');
  lcd.print(n);
}

void show() {
  lcd.setCursor(0, 0);
  lcd.print('A');
  printCount(counts[0]);
  lcd.print(" B");
  printCount(counts[1]);
  lcd.print(" Tot");
  printCount(counts[0] + counts[1]);
  lcd.setCursor(0, 1);
  if (state == JAM) {
    lcd.print(FAULTS[fault]);
    lcd.print(" press RESET");
  } else if (state == FEED) {
    lcd.print("Feeding ");
    lcd.print(feederName(turn));
  } else {
    lcd.print("To the belt");
  }
  lcd.print("                ");
}

void enter(State next) {
  state = next;
  enteredAt = millis();
  // One place sets every output, so no state can leave both feeders on.
  bool feeding = next == FEED;
  digitalWrite(MOTOR_A_PIN, feeding && turn == 0 ? ON : OFF);
  digitalWrite(MOTOR_B_PIN, feeding && turn == 1 ? ON : OFF);
  digitalWrite(GREEN_PIN, next == FEED);
  digitalWrite(YELLOW_PIN, next == TRANSIT);
  digitalWrite(RED_PIN, next == JAM);
  // A beam that is already blocked starts its watchdog now.
  wasBlocked = feeding && mergeBlocked(turn);
  blockedSince = enteredAt;
  if (next == FEED) {
    Serial.print(F("feeding "));
    Serial.println(feederName(turn));
  } else if (next == TRANSIT) {
    Serial.print(F("item from "));
    Serial.print(feederName(turn));
    Serial.println(F(" on its way"));
  }
  show();
}

void jam(Fault why) {
  fault = why;
  Serial.print(FAULTS[why]);
  if (why == LOST_ITEM) {
    Serial.print(F(": the item from "));
    Serial.print(feederName(turn));
    Serial.println(F(" never reached the belt"));
  } else {
    Serial.println(F(": an item is stuck in the merge beam"));
  }
  enter(JAM);
}

void setup() {
  // Relay pins high before they become outputs, so no motor twitches.
  digitalWrite(MOTOR_A_PIN, OFF);
  digitalWrite(MOTOR_B_PIN, OFF);
  pinMode(MOTOR_A_PIN, OUTPUT);
  pinMode(MOTOR_B_PIN, OUTPUT);
  pinMode(RED_PIN, OUTPUT);
  pinMode(YELLOW_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  pinMode(SENSOR_A_PIN, INPUT_PULLUP);
  pinMode(SENSOR_B_PIN, INPUT_PULLUP);
  pinMode(BELT_PIN, INPUT_PULLUP);
  pinMode(RESET_PIN, INPUT_PULLUP);
  Serial.begin(9600);
  Serial.println(F("Merge jam"));
  lcd.init();
  lcd.backlight();
  enter(FEED);
}

void loop() {
  unsigned long now = millis();
  bool belt = seesItem(BELT_PIN);
  bool beltArrived = belt && !beltWasBlocked;
  beltWasBlocked = belt;
  bool resetDown = digitalRead(RESET_PIN) == LOW;
  // A press counts once; the contact's bounce in the next 100 ms does not.
  bool resetPressed = resetDown && !resetWasDown && now - resetAt >= 100;
  if (resetPressed) resetAt = now;
  resetWasDown = resetDown;

  switch (state) {
    case FEED: {
      bool blocked = mergeBlocked(turn);
      if (blocked && !wasBlocked) blockedSince = now;
      if (blocked && now - blockedSince >= STUCK_MS) {
        jam(turn == 0 ? JAM_A : JAM_B);
      } else if (!blocked && wasBlocked) {
        // The item has gone through the beam onto the shared belt.
        enter(TRANSIT);
      } else if (!blocked && now - enteredAt >= IDLE_MS) {
        Serial.print(feederName(turn));
        Serial.println(F(" has nothing to send"));
        turn = 1 - turn;
        enter(FEED);
      } else {
        wasBlocked = blocked;
      }
      break;
    }
    case TRANSIT:
      if (beltArrived) {
        counts[turn]++;
        Serial.print(F("item "));
        Serial.print(counts[0] + counts[1]);
        Serial.print(F(" from "));
        Serial.print(feederName(turn));
        Serial.print(F("  A "));
        Serial.print(counts[0]);
        Serial.print(F("  B "));
        Serial.println(counts[1]);
        turn = 1 - turn;  // fairness: the other feeder goes next
        enter(FEED);
      } else if (now - enteredAt >= LOST_MS) {
        jam(LOST_ITEM);
      }
      break;
    case JAM:
      if (resetPressed) {
        if (mergeBlocked(0) || mergeBlocked(1) || belt) {
          Serial.println(F("reset refused: a beam is still blocked"));
        } else {
          Serial.println(F("reset"));
          // A lost item was sent, so the other feeder is next. A stuck
          // item was not, so the same feeder tries again.
          if (fault == LOST_ITEM) turn = 1 - turn;
          fault = NONE;
          enter(FEED);
        }
      }
      break;
  }

  delay(10);
}