Level crossing on an Arduino Uno

// Level crossing: two infrared beam detectors, alternating red lamps, a gate servo and a bell.
//
//   pin 3   west detector (a slotted beam sensor, HIGH while a car breaks the beam)
//   pin 2   east detector, the same
//   pin 5   left red lamp     pin 4   right red lamp
//   pin 9   the gate servo    pin 8   the bell, a piezo
//
// The sequence follows the prototype. A train reaches either detector: the lamps
// start alternating and the bell rings at once, and the gate waits a few seconds
// before it comes down, slowly, so a car already on the crossing can clear it.
// The train trips the far detector as it leaves; once that detector has seen
// nothing for CLEAR_MS (the gaps between cars are short), the gate rises and the
// lamps and bell stop. The detector a train leaves by is ignored for a moment, so
// the last car rolling off it does not start the crossing again.
//
// The lamps flash 50 times a minute each, inside the range U.S. rules set for
// real crossing lights. Many crossings stop the bell once the gates are down;
// RING_WHILE_DOWN chooses.
//
// Mokxi has no train: click a detector's card into its slot to put a car in the beam.

#include <Servo.h>

const int WEST_PIN = 3;
const int EAST_PIN = 2;
const int LAMP_LEFT = 5;
const int LAMP_RIGHT = 4;
const int BELL_PIN = 8;
const int GATE_PIN = 9;

const int GATE_UP = 90;
const int GATE_DOWN = 0;
const unsigned long GATE_DELAY_MS = 3000;  // lamps and bell first, then the gate
const unsigned long GATE_STEP_MS = 40;     // one degree per step: about 3.6 s to lower
const unsigned long FLASH_MS = 600;        // each lamp on for 0.6 s: 50 flashes a minute
const unsigned long CLEAR_MS = 2000;       // the exit detector quiet this long
const unsigned long IGNORE_MS = 4000;      // then ignore detectors while things settle
const bool RING_WHILE_DOWN = false;

enum Phase { IDLE, WARNING, CLEARING };
Phase phase = IDLE;
int exitPin = -1;              // the detector the train will leave by
bool exitSeen = false;
unsigned long phaseAt = 0, lastExit = 0, idleAt = 0, lastGateStep = 0, lastStrike = 0;
int gateAngle = GATE_UP;
Servo gate;

bool over(int pin) { return digitalRead(pin) == HIGH; }

void startWarning(int enteredBy) {
  phase = WARNING;
  phaseAt = millis();
  exitPin = enteredBy == WEST_PIN ? EAST_PIN : WEST_PIN;
  exitSeen = false;
  Serial.println(enteredBy == WEST_PIN ? "train from the west: warning" : "train from the east: warning");
}

void setup() {
  Serial.begin(9600);
  pinMode(WEST_PIN, INPUT);  // the sensor board has its own pull-up
  pinMode(EAST_PIN, INPUT);
  pinMode(LAMP_LEFT, OUTPUT);
  pinMode(LAMP_RIGHT, OUTPUT);
  gate.attach(GATE_PIN);
  gate.write(GATE_UP);
  Serial.println("Level crossing ready");
}

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

  if (phase == IDLE) {
    if (now - idleAt > IGNORE_MS || idleAt == 0) {
      if (over(WEST_PIN)) startWarning(WEST_PIN);
      else if (over(EAST_PIN)) startWarning(EAST_PIN);
    }
  } else {
    // Wait for the train at the far detector, then for that detector to stay clear.
    if (over(exitPin)) {
      exitSeen = true;
      lastExit = now;
    }
    if (phase == WARNING && exitSeen && now - lastExit >= CLEAR_MS) {
      phase = CLEARING;
      Serial.println("train clear: gate rising");
    }
  }

  // The gate: down after the delay while warning, back up when clearing.
  int target = (phase == WARNING && now - phaseAt >= GATE_DELAY_MS) ? GATE_DOWN : GATE_UP;
  if (gateAngle != target && now - lastGateStep >= GATE_STEP_MS) {
    lastGateStep = now;
    gateAngle += gateAngle < target ? 1 : -1;
    gate.write(gateAngle);
    if (gateAngle == GATE_DOWN) Serial.println("gate down");
    if (gateAngle == GATE_UP && phase == CLEARING) {
      phase = IDLE;
      idleAt = now;
      Serial.println("gate up: crossing idle");
    }
  }

  // Lamps alternate while the crossing is active, and go dark when it is idle.
  bool active = phase != IDLE;
  bool leftOn = (now / FLASH_MS) % 2 == 0;
  digitalWrite(LAMP_LEFT, active && leftOn ? HIGH : LOW);
  digitalWrite(LAMP_RIGHT, active && !leftOn ? HIGH : LOW);

  // The bell: a short strike every 300 ms, like an electronic crossing bell.
  bool ringing = active && (RING_WHILE_DOWN || gateAngle != GATE_DOWN);
  if (ringing && now - lastStrike >= 300) {
    lastStrike = now;
    tone(BELL_PIN, 1800, 60);
  }
  delay(5);
}