Bottling line on an Arduino Uno

// Bottling line: a conveyor belt carries empty bottles to a filler. An IR
// sensor sees each bottle arrive and stops the belt under the nozzle, a pump
// fills it until a float switch says it is full (or a timer runs out), and
// the belt carries it away. The LCD counts the bottles.
//
// Three things protect the line, the way they do in a real factory:
//   * a guard switch on the safety door: open it and everything stops at
//     once, and closing it again does NOT restart the line. Someone has to
//     press START on purpose.
//   * a jam timeout: a filled bottle that does not leave the sensor in time
//     means it is stuck, so the line stops and beeps.
//   * a no-bottle timeout: a belt running with nothing on it is wasting
//     power, so it stops and beeps until someone loads more bottles.
//
//   guard switch  NO -> 11, COM -> GND  (door shut presses the lever: LOW)
//   START button  -> 12 and GND
//   IR sensor     FC-51 OUT -> 9 (LOW when a bottle is in front), VCC, GND
//   float switch  one wire -> 10, the other -> GND (closed = full: LOW)
//   relay board   IN1 -> 7 (belt), IN2 -> 6 (pump), VCC -> 5 V, GND
//                 belt motor and pump each on their relay's COM, NO -> 6 V
//   piezo         pin 4 -> piezo -> GND (the alarm)
//   LCD 16x2 I2C  SDA -> A4, SCL -> A5 (address 0x27)
//
// The relay board is "active low": writing LOW to IN1 switches the belt ON.
// That is why setup() writes HIGH to the relay pins BEFORE making them
// outputs, so the belt and the pump do not twitch when the Uno starts.
//
// Things to try. Change FILL_MS for bigger bottles. Make the line stop by
// itself after a crate of 12.

#include <LiquidCrystal_I2C.h>

// ---- pins ----
const int GUARD_PIN = 11;
const int START_PIN = 12;
const int BOTTLE_PIN = 9;
const int LEVEL_PIN = 10;
const int BELT_RELAY = 7;
const int PUMP_RELAY = 6;
const int ALARM_PIN = 4;

const int RELAY_ON = LOW;     // active-low relay board
const int RELAY_OFF = HIGH;

// ---- timing, in milliseconds ----
const unsigned long SETTLE_MS = 500;       // let the bottle stop wobbling
const unsigned long FILL_MS = 4000;        // the longest a fill may take
const unsigned long JAM_MS = 3000;         // a bottle must leave by then
const unsigned long NO_BOTTLE_MS = 8000;   // an empty belt stops after this
const unsigned long DEBOUNCE_MS = 30;

LiquidCrystal_I2C lcd(0x27, 16, 2);

// ---- the line's states ----
enum State { STOPPED, RUNNING, SETTLING, FILLING, RUN_OUT, FAULT };
State state = STOPPED;
unsigned long stateSince = 0;   // when the current state began
unsigned long bottles = 0;      // bottles filled since power on
bool bottleFilled = false;      // the bottle at the filler is already full
bool guardWas = false;          // the guard last loop, to report changes
bool alarmOn = false;           // the piezo is beeping right now

// A debounced input: it only changes after it has read the same for a while.
struct Input {
  int pin;
  bool stable;          // the debounced reading
  bool last;            // the raw reading last time
  unsigned long since;  // when the raw reading last changed
};
Input startBtn = {START_PIN, HIGH, HIGH, 0};
Input bottleEye = {BOTTLE_PIN, HIGH, HIGH, 0};
Input levelFloat = {LEVEL_PIN, HIGH, HIGH, 0};

// Read an input; returns true on the loop the debounced value changes.
bool update(Input &in, unsigned long now) {
  bool raw = digitalRead(in.pin);
  if (raw != in.last) { in.last = raw; in.since = now; }
  if (now - in.since >= DEBOUNCE_MS && raw != in.stable) {
    in.stable = raw;
    return true;
  }
  return false;
}

// what the sensors say, in words
bool guardClosed() { return digitalRead(GUARD_PIN) == LOW; }
bool bottleHere() { return bottleEye.stable == LOW; }
bool levelFull() { return levelFloat.stable == LOW; }

// ---- outputs ----
void belt(bool on) { digitalWrite(BELT_RELAY, on ? RELAY_ON : RELAY_OFF); }
void pump(bool on) { digitalWrite(PUMP_RELAY, on ? RELAY_ON : RELAY_OFF); }

void allOff() {
  belt(false);
  pump(false);
}

void showCount(const char *status) {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Bottles: ");
  lcd.print(bottles);
  lcd.setCursor(0, 1);
  lcd.print(status);
}

void enter(State next, unsigned long now) {
  state = next;
  stateSince = now;
}

// Stop the line for a problem: everything off, the alarm on, START to clear.
void fault(const char *why, unsigned long now) {
  allOff();
  enter(FAULT, now);
  Serial.print("FAULT: ");
  Serial.println(why);
  showCount(why);
}

void silence() {
  noTone(ALARM_PIN);
  alarmOn = false;
}

void startLine(unsigned long now) {
  silence();
  belt(true);
  // a full bottle still at the filler (after a jam) just moves on;
  // anything else waits for the next bottle to fill
  enter(bottleHere() && bottleFilled ? RUN_OUT : RUNNING, now);
  Serial.println("Belt running");
  showCount("Running");
}

void setup() {
  // relays off FIRST, then outputs: no twitch at power up
  digitalWrite(BELT_RELAY, RELAY_OFF);
  digitalWrite(PUMP_RELAY, RELAY_OFF);
  pinMode(BELT_RELAY, OUTPUT);
  pinMode(PUMP_RELAY, OUTPUT);

  pinMode(GUARD_PIN, INPUT_PULLUP);
  pinMode(START_PIN, INPUT_PULLUP);
  pinMode(BOTTLE_PIN, INPUT);        // the FC-51 drives its own output
  pinMode(LEVEL_PIN, INPUT_PULLUP);
  pinMode(ALARM_PIN, OUTPUT);

  Serial.begin(9600);
  lcd.init();
  lcd.backlight();
  Serial.println("Bottling line. Close the guard and press START");
  showCount("Close the guard");
}

void loop() {
  unsigned long now = millis();
  bool startPressed = update(startBtn, now) && startBtn.stable == LOW;
  bool bottleChanged = update(bottleEye, now);
  update(levelFloat, now);
  unsigned long inState = now - stateSince;

  // ---- the safety interlock comes first, every loop, no debounce ----
  bool guard = guardClosed();
  if (!guard) {
    if (guardWas || (state != STOPPED && state != FAULT)) {
      allOff();
      silence();
      enter(STOPPED, now);
      Serial.println("GUARD OPEN: everything stopped");
      showCount("GUARD OPEN");
    }
    guardWas = false;
    return;   // nothing else runs while the door is open
  }
  if (!guardWas) {
    guardWas = true;
    Serial.println("Guard closed. Press START");
    showCount("Press START");
  }

  switch (state) {
    case STOPPED:
      if (startPressed) startLine(now);
      break;

    case RUNNING:
      // waiting for a bottle to arrive at the filler
      if (bottleHere()) {
        belt(false);
        enter(SETTLING, now);
        Serial.println("Bottle at the filler");
        showCount("Bottle in place");
      } else if (inState >= NO_BOTTLE_MS) {
        fault("No bottles", now);
      }
      break;

    case SETTLING:
      if (inState >= SETTLE_MS) {
        pump(true);
        enter(FILLING, now);
        Serial.println("Filling");
        showCount("Filling...");
      }
      break;

    case FILLING:
      // stop at the float switch, or when the time is up, whichever first
      if (levelFull() || inState >= FILL_MS) {
        pump(false);
        bottles++;
        bottleFilled = true;
        Serial.print("Bottle ");
        Serial.print(bottles);
        Serial.print(levelFull() ? " full by level in " : " full by timer in ");
        Serial.print(inState);
        Serial.println(" ms");
        belt(true);
        enter(RUN_OUT, now);
        showCount("Moving on");
      }
      break;

    case RUN_OUT:
      // the full bottle has to leave the sensor before the next can come
      if (bottleChanged && !bottleHere()) {
        Serial.println("Bottle away");
        bottleFilled = false;
        enter(RUNNING, now);
        showCount("Running");
      } else if (inState >= JAM_MS) {
        fault("JAM at filler", now);
      }
      break;

    case FAULT:
      // beep half a second on, half a second off until START is pressed.
      // Only call tone() when the beep changes: calling it every loop
      // would restart the note over and over.
      {
        bool beep = (inState / 500) % 2 == 0;
        if (beep != alarmOn) {
          alarmOn = beep;
          if (beep) tone(ALARM_PIN, 2000); else noTone(ALARM_PIN);
        }
      }
      if (startPressed) startLine(now);
      break;
  }
}