Light curtain on an Arduino Uno

// Light curtain: two infrared beams guard a press, and a hand in the beams
// stops it. A fault latches until someone clears it on purpose.
//
//   2, 3    two E18-D80NK beams across the press opening, OUT (brown on 5 V,
//           blue on GND): low while something is in that beam
//   4       the green start button, its other side on GND
//   5       the reset button, its other side on GND
//   6       the e-stop switch: closed to GND while it is safe to run
//   8       the active buzzer's plus leg, its other leg on GND
//   9       the press ram, a servo (0 = up, 90 = down)
//   13/12/11 the stack light: red, yellow, green
//   LCD     SDA -> A4    SCL -> A5    VCC -> 5 V    GND -> GND
//
// An interlock is a rule the machine checks before and during every move:
//
//   READY     ram up, green light. Start with both beams clear -> DOWN.
//             Start with a beam blocked is refused.
//   DOWN      the ram travels down over STROKE_MS, waits, then -> UP. A
//             broken beam on the way down -> LOCKOUT.
//   UP        the ram returns. Done -> READY, one more cycle.
//   LOCKOUT   ram up at once, red light flashing, buzzer pulsing. Only the
//             reset button gets out, and only with both beams clear.
//   STOPPED   the e-stop is open: ram up, red light. It needs the e-stop
//             closed, both beams clear and a press of reset.
//
// The e-stop is fail-safe: the pin's pull-up reads HIGH when the switch is
// open AND when its wire is cut, so a broken wire stops the press too. A
// fault never clears itself; a person has to look, clear it and press reset.
//
// Press Run, press start, and drag a sensor's target close while the ram
// is coming down.

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

const int BEAM_A_PIN = 2;
const int BEAM_B_PIN = 3;
const int START_PIN = 4;
const int RESET_PIN = 5;
const int ESTOP_PIN = 6;
const int BUZZER_PIN = 8;
const int RAM_PIN = 9;
const int RED_PIN = 13;
const int YELLOW_PIN = 12;
const int GREEN_PIN = 11;

const unsigned long STROKE_MS = 2000;  // ram travel, top to bottom
const unsigned long DWELL_MS = 300;    // ram held down
const unsigned long RETURN_MS = 800;   // ram back up before the next cycle
const unsigned long PULSE_MS = 250;    // lockout flash and beep
const unsigned long DEBOUNCE_MS = 30;  // a button steady this long
const int RAM_UP = 0;
const int RAM_DOWN = 90;

enum State { READY, DOWN, UP, LOCKOUT, STOPPED };
const char* const NAMES[] = {"READY", "DOWN", "UP", "LOCKOUT", "STOPPED"};

LiquidCrystal_I2C lcd(0x27, 16, 2);
Servo ram(RAM_PIN);

struct Button {
  int pin;
  bool down;
  bool raw;
  unsigned long changedAt;
};

Button startButton = {START_PIN, false, false, 0};
Button resetButton = {RESET_PIN, false, false, 0};

State state = READY;
unsigned long enteredAt = 0;
unsigned long cycles = 0;
bool lastClear = true;

// True once for each press.
bool pressed(Button& b, unsigned long now) {
  bool raw = digitalRead(b.pin) == LOW;
  if (raw != b.raw) {
    b.raw = raw;
    b.changedAt = now;
  }
  if (raw != b.down && now - b.changedAt >= DEBOUNCE_MS) {
    b.down = raw;
    return raw;
  }
  return false;
}

bool beamsClear() {
  return digitalRead(BEAM_A_PIN) == HIGH && digitalRead(BEAM_B_PIN) == HIGH;
}

bool estopOpen() {
  return digitalRead(ESTOP_PIN) == HIGH;
}

// The LCD takes a few milliseconds a character, so it is written only when
// something changes, and always after the outputs have been set.
void showInfo() {
  lcd.setCursor(0, 1);
  if (state == LOCKOUT || state == STOPPED) {
    lcd.print(lastClear ? "Press reset     " : "Clear the beams ");
  } else if (!lastClear) {
    lcd.print("Beam blocked    ");
  } else {
    lcd.print("Cycles ");
    lcd.print(cycles);
    lcd.print("    ");
  }
}

void show() {
  lcd.setCursor(0, 0);
  lcd.print("Press ");
  lcd.print(NAMES[state]);
  lcd.print("   ");
  showInfo();
}

// Every output, from the state and the ram's angle.
void outputs(int ramAngle) {
  bool flash = (millis() - enteredAt) % (2 * PULSE_MS) < PULSE_MS;
  ram.write(ramAngle);
  digitalWrite(RED_PIN, state == STOPPED || (state == LOCKOUT && flash));
  digitalWrite(YELLOW_PIN, state == DOWN || state == UP);
  digitalWrite(GREEN_PIN, state == READY);
  digitalWrite(BUZZER_PIN, state == LOCKOUT && flash);
}

void enter(State next) {
  state = next;
  enteredAt = millis();
  // Every state starts with the ram up, and the outputs go before anything
  // slow, so a lockout pulls the ram back on the pass that sees the beam.
  outputs(RAM_UP);
  Serial.print("state ");
  Serial.println(NAMES[next]);
  lastClear = beamsClear();
  show();
  enteredAt = millis();
}

void setup() {
  pinMode(BEAM_A_PIN, INPUT_PULLUP);
  pinMode(BEAM_B_PIN, INPUT_PULLUP);
  pinMode(START_PIN, INPUT_PULLUP);
  pinMode(RESET_PIN, INPUT_PULLUP);
  pinMode(ESTOP_PIN, INPUT_PULLUP);
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(RED_PIN, OUTPUT);
  pinMode(YELLOW_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  Serial.begin(9600);
  Serial.println("Light curtain");
  ram.begin();
  ram.write(RAM_UP);
  lcd.init();
  lcd.backlight();
  // An e-stop that is open at power up holds the press stopped.
  enter(estopOpen() ? STOPPED : READY);
}

void loop() {
  unsigned long now = millis();
  bool clear = beamsClear();
  bool start = pressed(startButton, now);
  bool reset = pressed(resetButton, now);
  unsigned long t = now - enteredAt;
  int ramAngle = RAM_UP;

  // The e-stop wins over everything, in every state.
  if (estopOpen() && state != STOPPED) {
    Serial.println("e-stop");
    enter(STOPPED);
    t = 0;
  }

  switch (state) {
    case READY:
      if (start) {
        if (clear) {
          enter(DOWN);
          t = 0;
        } else {
          Serial.println("start refused: beam blocked");
        }
      }
      break;
    case DOWN:
      if (!clear) {
        // The ram goes back up on this very pass.
        Serial.println("beam broken: lockout");
        enter(LOCKOUT);
        break;
      }
      ramAngle = t >= STROKE_MS ? RAM_DOWN : (int)((long)RAM_DOWN * t / STROKE_MS);
      if (t >= STROKE_MS + DWELL_MS) {
        enter(UP);
        ramAngle = RAM_UP;
      }
      break;
    case UP:
      if (t >= RETURN_MS) {
        cycles++;
        Serial.print("cycle ");
        Serial.println(cycles);
        enter(READY);
      }
      break;
    case LOCKOUT:
    case STOPPED:
      if (reset) {
        if (estopOpen()) {
          Serial.println("reset refused: e-stop open");
        } else if (!clear) {
          Serial.println("reset refused: beam blocked");
        } else {
          Serial.println("reset");
          enter(READY);
        }
      }
      break;
  }

  outputs(ramAngle);
  if (clear != lastClear) {
    lastClear = clear;
    showInfo();
  }
  delay(20);
}