Bunker airlock interlock on an Arduino Uno

// Bunker airlock: two doors that are never open together. Two servos, two
// buttons, two lights and a piezo on an Uno.
//
//   outer door   servo -> pin 5, red lamp -> pin 2, green lamp -> pin 3, yellow -> pin 6
//   inner door   servo -> pin 11, red lamp -> pin 12, green lamp -> pin 13, yellow -> pin 7
//   OUTSIDE button -> A0 to GND     INSIDE button -> A1 to GND
//   piezo        pin 8 and GND
//
// Someone outside presses OUTSIDE: the outer door opens (green) for five
// seconds and closes. Then the airlock purges for four seconds, beeping, with
// both lamps yellow. Then the inner door opens for five seconds, and closes.
// Someone inside presses INSIDE and the same happens the other way round.
// Press either button while a cycle is running and it is ignored, with a note
// on the Serial Monitor.
//
// # An interlock is a rule that cannot be broken by accident
//
// The one rule is: a door may open only if the other door is closed. It is
// written once, in openDoor(), and every route to a door goes through that
// function. Nothing else in the sketch ever moves a servo to the open
// position, so there is no path, however the buttons are pressed, that opens
// both. Real airlocks, lift doors and microwave ovens work the same way.
//
// There is a second half: "closed" has to mean closed. A command to shut a
// door is not the door being shut, because a servo takes time to swing. So
// closing sets a timestamp, and the other door waits for SWING_MS to pass
// after it before it may open.
//
// # The cycle is a state machine
//
// IDLE, FIRST_OPEN, PURGE, SECOND_OPEN. Each state has a deadline; loop()
// looks at the clock and moves on when the deadline passes. No delay(), so a
// button press during a cycle is read (and refused) at once.

#include <Servo.h>

// door 0 is the outer door and door 1 the inner door; button 0 is OUTSIDE
const uint8_t SERVO_PIN[2] = {5, 11};
const uint8_t RED_PIN[2] = {2, 12};
const uint8_t GREEN_PIN[2] = {3, 13};
const uint8_t YELLOW_PIN[2] = {6, 7};
const uint8_t BUTTON[2] = {A0, A1};  // OUTSIDE, INSIDE
const uint8_t PIEZO = 8;
const char* const NAME[2] = {"outer", "inner"};

const int CLOSED_ANGLE = 0;
const int OPEN_ANGLE = 90;
const unsigned long OPEN_MS = 5000;
const unsigned long PURGE_MS = 4000;
const unsigned long SWING_MS = 800;

enum State { IDLE, FIRST_OPEN, PURGE, SECOND_OPEN };

Servo door[2];
bool isOpen[2];
unsigned long closedAt[2];
State state = IDLE;
bool purging = false;  // both lamps yellow while the air is changed
uint8_t first;   // the door the visitor comes through first
unsigned long deadline = 0;
unsigned long lastBeep = 0;
bool wasDown[2];

void lamps() {
  for (int d = 0; d < 2; d++) {
    digitalWrite(GREEN_PIN[d], isOpen[d]);
    digitalWrite(YELLOW_PIN[d], purging && !isOpen[d]);
    digitalWrite(RED_PIN[d], !isOpen[d] && !purging);
  }
}

// The only function that opens a door, and the only place the rule is kept.
bool openDoor(uint8_t which) {
  uint8_t other = 1 - which;
  if (isOpen[other] || millis() - closedAt[other] < SWING_MS) {
    Serial.println("interlock: refused, the other door is not shut yet");
    return false;
  }
  isOpen[which] = true;
  door[which].write(OPEN_ANGLE);
  lamps();
  Serial.print(NAME[which]);
  Serial.println(" door open");
  return true;
}

void closeDoor(uint8_t which) {
  isOpen[which] = false;
  closedAt[which] = millis();
  door[which].write(CLOSED_ANGLE);
  lamps();
  Serial.print(NAME[which]);
  Serial.println(" door closed");
}

void press(uint8_t side) {
  if (state != IDLE) {
    Serial.println("busy: wait for the cycle to finish");
    return;
  }
  first = side;
  if (!openDoor(first)) return;
  state = FIRST_OPEN;
  deadline = millis() + OPEN_MS;
}

void setup() {
  Serial.begin(115200);
  for (int d = 0; d < 2; d++) {
    pinMode(RED_PIN[d], OUTPUT);
    pinMode(GREEN_PIN[d], OUTPUT);
    pinMode(YELLOW_PIN[d], OUTPUT);
    pinMode(BUTTON[d], INPUT_PULLUP);
    door[d].attach(SERVO_PIN[d]);
    door[d].write(CLOSED_ANGLE);
    closedAt[d] = 0UL - SWING_MS;  // shut long ago, as far as the clock knows
  }
  pinMode(PIEZO, OUTPUT);
  lamps();
  Serial.println("airlock idle: press OUTSIDE or INSIDE");
}

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

  for (int s = 0; s < 2; s++) {
    bool down = digitalRead(BUTTON[s]) == LOW;
    if (down && !wasDown[s]) press(s);
    wasDown[s] = down;
  }

  if (state == FIRST_OPEN && now >= deadline) {
    closeDoor(first);
    state = PURGE;
    purging = true;
    lamps();
    deadline = now + PURGE_MS;
    Serial.println("purging");
  } else if (state == PURGE) {
    if (now - lastBeep >= 500) {
      lastBeep = now;
      tone(PIEZO, 440, 100);
    }
    // the second door waits for the purge and for the first door to be shut
    if (now >= deadline) purging = false;
    if (now >= deadline && openDoor(1 - first)) {
      state = SECOND_OPEN;
      deadline = now + OPEN_MS;
    }
  } else if (state == SECOND_OPEN && now >= deadline) {
    closeDoor(1 - first);
    state = IDLE;
    Serial.println("airlock idle: press OUTSIDE or INSIDE");
  }
}