ESP32 traffic emergency system with RFID

// Traffic emergency system: an ESP32 runs a junction of three roads.
//
// Each road has a red, yellow and green LED (pin -> 220 ohm -> LED -> GND)
// and its own MFRC522 RFID reader. The lights take turns on their own:
// green 5 s, yellow 2 s, then the next road. When an emergency tag is tapped
// on a road's reader, that road gets green for 8 seconds and the other two
// turn red; then that road goes yellow and the cycle carries on.
//
// The three readers share the SPI bus (SCK 18, MOSI 23, MISO 19) and one
// reset line on 22. Each has its own SDA (chip select): 5, 16 and 17. Only
// the selected reader drives MISO, so they take turns on the one wire.
//
// The timing runs on millis(), never delay(), so the readers are polled all
// the time and a tag is seen the moment it is tapped.
//
// In Mokxi: press Run, then click a card in the tray beside a reader to lay
// it on that reader, and click it again to lift it off. The white card and
// the blue fob are emergency tags; the other two are printed and ignored.

#include <SPI.h>
#include <MFRC522.h>

const byte RST_PIN = 22;
const byte SS_PINS[3] = {5, 16, 17};

MFRC522 readers[3] = {
  MFRC522(SS_PINS[0], RST_PIN),
  MFRC522(SS_PINS[1], RST_PIN),
  MFRC522(SS_PINS[2], RST_PIN),
};

//                        red  yellow green
const byte LIGHTS[3][3] = {{13, 14, 27},   // road 1
                           {26, 25, 33},   // road 2
                           {32, 21, 4}};   // road 3
const byte RED = 0, YELLOW = 1, GREEN = 2;

const unsigned long GREEN_MS = 5000;
const unsigned long YELLOW_MS = 2000;
const unsigned long EMERGENCY_MS = 8000;

// The tags that count as emergency vehicles. Tap any other card and its UID
// is printed, so a new tag can be copied into this list.
const byte EMERGENCY_TAGS[][4] = {
  {0xC3, 0x5A, 0x1E, 0x94},
  {0x7B, 0x02, 0xD4, 0x19},
};
const byte EMERGENCY_COUNT = sizeof(EMERGENCY_TAGS) / sizeof(EMERGENCY_TAGS[0]);

byte road = 0;                 // the road that has right of way
byte phase = GREEN;            // GREEN or YELLOW for that road
bool emergency = false;
unsigned long phaseStart = 0;

void show() {
  for (byte r = 0; r < 3; r++) {
    byte lit = (r == road) ? phase : RED;
    for (byte c = 0; c < 3; c++) digitalWrite(LIGHTS[r][c], c == lit ? HIGH : LOW);
  }
}

void enter(byte newRoad, byte newPhase) {
  road = newRoad;
  phase = newPhase;
  phaseStart = millis();
  show();
  Serial.print("Road ");
  Serial.print(road + 1);
  Serial.println(phase == GREEN ? (emergency ? ": GREEN (emergency)" : ": GREEN") : ": YELLOW");
}

bool isEmergencyTag(const MFRC522::Uid &uid) {
  if (uid.size != 4) return false;
  for (byte t = 0; t < EMERGENCY_COUNT; t++) {
    if (memcmp(uid.uidByte, EMERGENCY_TAGS[t], 4) == 0) return true;
  }
  return false;
}

void printUid(const MFRC522::Uid &uid) {
  for (byte i = 0; i < uid.size; i++) {
    Serial.print(uid.uidByte[i] < 0x10 ? " 0" : " ");
    Serial.print(uid.uidByte[i], HEX);
  }
}

void checkReaders() {
  for (byte r = 0; r < 3; r++) {
    MFRC522 &reader = readers[r];
    if (!reader.PICC_IsNewCardPresent() || !reader.PICC_ReadCardSerial()) continue;
    Serial.print("Reader ");
    Serial.print(r + 1);
    Serial.print(": tag");
    printUid(reader.uid);
    if (isEmergencyTag(reader.uid)) {
      Serial.println(" - EMERGENCY");
      emergency = true;
      enter(r, GREEN);
    } else {
      Serial.println(" - not an emergency tag");
    }
    reader.PICC_HaltA();   // read a tag once per tap, not once a loop
  }
}

void setup() {
  Serial.begin(115200);
  for (byte r = 0; r < 3; r++) {
    for (byte c = 0; c < 3; c++) pinMode(LIGHTS[r][c], OUTPUT);
  }
  SPI.begin();   // SCK 18, MISO 19, MOSI 23
  for (byte r = 0; r < 3; r++) {
    readers[r].PCD_Init();
    Serial.print("Reader ");
    Serial.print(r + 1);
    Serial.print(" on SS ");
    Serial.print(SS_PINS[r]);
    Serial.print(": version 0x");
    Serial.println(readers[r].PCD_ReadRegister(MFRC522::VersionReg), HEX);
  }
  Serial.println("Traffic emergency system ready: tap an emergency tag on a road's reader");
  enter(0, GREEN);
}

void loop() {
  checkReaders();

  unsigned long elapsed = millis() - phaseStart;
  if (emergency) {
    if (elapsed >= EMERGENCY_MS) {
      emergency = false;
      Serial.println("Emergency over, normal cycle resumes");
      enter(road, YELLOW);
    }
  } else if (phase == GREEN && elapsed >= GREEN_MS) {
    enter(road, YELLOW);
  } else if (phase == YELLOW && elapsed >= YELLOW_MS) {
    enter((road + 1) % 3, GREEN);
  }
}