RFID Solenoid Door Lock

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


// Forward declarations
bool doorIsOpen();
bool enclosureIsOpen();
bool lockoutActive();
void buzz(unsigned long durationMs);
void setIndicators(bool green, bool red);
void lockDoor();
void unlockDoor(const char *reason);
void denyAccess(const char *reason);
void saveCards();
void loadCards();
int findCard(const uint8_t *uid, uint8_t length);
bool readCardUid(uint8_t *uid, uint8_t &uidLength);
void enterEnrollmentMode();
void addCard(const uint8_t *uid, uint8_t uidLength);
void updateEnrollmentButton();

constexpr uint8_t RC522_SS_PIN = 4;
constexpr uint8_t RC522_RST_PIN = 22;
constexpr uint8_t RC522_SCK_PIN = 18;
constexpr uint8_t RC522_MISO_PIN = 19;
constexpr uint8_t RC522_MOSI_PIN = 23;
constexpr uint8_t LOCK_PIN = 27;
constexpr uint8_t ENROLL_BUTTON_PIN = 25;
constexpr uint8_t DOOR_REED_PIN = 26;
constexpr uint8_t TAMPER_PIN = 13;
constexpr uint8_t EXIT_BUTTON_PIN = 16;
constexpr uint8_t GREEN_LED_PIN = 32;
constexpr uint8_t RED_LED_PIN = 33;
constexpr uint8_t BUZZER_PIN = 14;

constexpr unsigned long UNLOCK_TIME_MS = 5000;
constexpr unsigned long ENROLL_HOLD_MS = 8000;
constexpr unsigned long ENROLL_TIMEOUT_MS = 30000;
constexpr unsigned long LOCKOUT_TIME_MS = 30000;
constexpr unsigned long CARD_COOLDOWN_MS = 1000;
constexpr uint8_t MAX_CARDS = 4;
constexpr uint8_t MAX_UID_BYTES = 10;
constexpr uint8_t FAILED_ATTEMPTS_BEFORE_LOCKOUT = 5;

MFRC522 rfid(RC522_SS_PIN, RC522_RST_PIN);
Preferences preferences;
uint8_t authorizedUids[MAX_CARDS][MAX_UID_BYTES] = {};
uint8_t authorizedLengths[MAX_CARDS] = {};
uint8_t authorizedCount = 0;

bool unlocked = false;
bool doorOpenedDuringUnlock = false;
bool enrollmentMode = false;
bool enrollButtonWasDown = false;
unsigned long unlockStartedAt = 0;
unsigned long enrollmentStartedAt = 0;
unsigned long enrollButtonDownAt = 0;
unsigned long lockoutStartedAt = 0;
unsigned long lastCardAt = 0;
uint8_t failedAttempts = 0;

bool doorIsOpen() {
  return digitalRead(DOOR_REED_PIN) == HIGH;
}

bool enclosureIsOpen() {
  return digitalRead(TAMPER_PIN) == HIGH;
}

bool lockoutActive() {
  return lockoutStartedAt != 0 && millis() - lockoutStartedAt < LOCKOUT_TIME_MS;
}

void buzz(unsigned long durationMs) {
  digitalWrite(BUZZER_PIN, HIGH);
  delay(durationMs);
  digitalWrite(BUZZER_PIN, LOW);
}

void setIndicators(bool green, bool red) {
  digitalWrite(GREEN_LED_PIN, green ? HIGH : LOW);
  digitalWrite(RED_LED_PIN, red ? HIGH : LOW);
}

void lockDoor() {
  digitalWrite(LOCK_PIN, LOW);
  unlocked = false;
  doorOpenedDuringUnlock = false;
  setIndicators(false, enclosureIsOpen() || lockoutActive());
  Serial.println("Lock engaged.");
}

void unlockDoor(const char *reason) {
  digitalWrite(LOCK_PIN, HIGH);
  unlocked = true;
  doorOpenedDuringUnlock = false;
  unlockStartedAt = millis();
  setIndicators(true, false);
  Serial.print("Door unlocked: ");
  Serial.println(reason);
  buzz(80);
}

void denyAccess(const char *reason) {
  setIndicators(false, true);
  Serial.print("Access denied: ");
  Serial.println(reason);
  buzz(250);
}

void saveCards() {
  preferences.putUChar("count", authorizedCount);
  preferences.putBytes("uids", authorizedUids, sizeof(authorizedUids));
  preferences.putBytes("lens", authorizedLengths, sizeof(authorizedLengths));
}

void loadCards() {
  authorizedCount = preferences.getUChar("count", 0);
  if (authorizedCount > MAX_CARDS) {
    authorizedCount = 0;
  }
  preferences.getBytes("uids", authorizedUids, sizeof(authorizedUids));
  preferences.getBytes("lens", authorizedLengths, sizeof(authorizedLengths));
  for (uint8_t i = 0; i < authorizedCount; ++i) {
    if (authorizedLengths[i] == 0 || authorizedLengths[i] > MAX_UID_BYTES) {
      authorizedCount = 0;
      break;
    }
  }
}

int findCard(const uint8_t *uid, uint8_t length) {
  for (uint8_t card = 0; card < authorizedCount; ++card) {
    if (authorizedLengths[card] != length) continue;
    bool match = true;
    for (uint8_t i = 0; i < length; ++i) {
      if (authorizedUids[card][i] != uid[i]) {
        match = false;
        break;
      }
    }
    if (match) return card;
  }
  return -1;
}

bool readCardUid(uint8_t *uid, uint8_t &uidLength) {
  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) {
    return false;
  }
  uidLength = rfid.uid.size;
  if (uidLength > MAX_UID_BYTES) uidLength = MAX_UID_BYTES;
  for (uint8_t i = 0; i < uidLength; ++i) uid[i] = rfid.uid.uidByte[i];
  rfid.PICC_HaltA();
  rfid.PCD_StopCrypto1();
  return true;
}

void enterEnrollmentMode() {
  enrollmentMode = true;
  enrollmentStartedAt = millis();
  setIndicators(true, false);
  Serial.println("Enrollment mode is active for 30 seconds. Scan a card to add it.");
  buzz(70);
  delay(80);
  buzz(70);
}

void addCard(const uint8_t *uid, uint8_t uidLength) {
  if (findCard(uid, uidLength) >= 0) {
    Serial.println("That card is already authorized.");
    buzz(80);
  } else if (authorizedCount >= MAX_CARDS) {
    Serial.println("Card list is full. This prototype stores four cards.");
    denyAccess("card list full");
  } else {
    for (uint8_t i = 0; i < uidLength; ++i) authorizedUids[authorizedCount][i] = uid[i];
    authorizedLengths[authorizedCount] = uidLength;
    authorizedCount++;
    saveCards();
    Serial.println("Card saved.");
    buzz(80);
    delay(80);
    buzz(80);
  }
  enrollmentMode = false;
  setIndicators(false, enclosureIsOpen());
}

void updateEnrollmentButton() {
  bool pressed = digitalRead(ENROLL_BUTTON_PIN) == LOW;
  if (pressed && !enrollButtonWasDown) {
    enrollButtonDownAt = millis();
  }
  if (pressed && !enrollmentMode && millis() - enrollButtonDownAt >= ENROLL_HOLD_MS) {
    enterEnrollmentMode();
  }
  enrollButtonWasDown = pressed;
}

void setup() {
  pinMode(LOCK_PIN, OUTPUT);
  digitalWrite(LOCK_PIN, LOW);
  pinMode(GREEN_LED_PIN, OUTPUT);
  pinMode(RED_LED_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(BUZZER_PIN, LOW);
  pinMode(ENROLL_BUTTON_PIN, INPUT_PULLUP);
  pinMode(DOOR_REED_PIN, INPUT_PULLUP);
  pinMode(TAMPER_PIN, INPUT_PULLUP);
  pinMode(EXIT_BUTTON_PIN, INPUT_PULLUP);
  setIndicators(false, false);

  Serial.begin(115200);
  preferences.begin("doorlock", false);
  loadCards();
  SPI.begin(RC522_SCK_PIN, RC522_MISO_PIN, RC522_MOSI_PIN, RC522_SS_PIN);
  rfid.PCD_Init();
  lockDoor();
  Serial.println("RFID door-lock controller ready.");
  Serial.println("UID matching is suitable only for a prototype; it is not high-security card authentication.");
  if (authorizedCount == 0) {
    Serial.println("No cards saved. Hold the hidden service button for 8 seconds, then scan a card.");
  }
}

void loop() {
  updateEnrollmentButton();

  if (enclosureIsOpen() && !unlocked) {
    setIndicators(false, true);
  }

  if (lockoutStartedAt != 0 && !lockoutActive()) {
    lockoutStartedAt = 0;
    failedAttempts = 0;
    setIndicators(false, enclosureIsOpen());
    Serial.println("Lockout ended.");
  }

  if (enrollmentMode && millis() - enrollmentStartedAt >= ENROLL_TIMEOUT_MS) {
    enrollmentMode = false;
    setIndicators(false, enclosureIsOpen());
    Serial.println("Enrollment timed out.");
  }

  if (unlocked) {
    if (doorIsOpen()) doorOpenedDuringUnlock = true;
    if ((doorOpenedDuringUnlock && !doorIsOpen()) || millis() - unlockStartedAt >= UNLOCK_TIME_MS) {
      lockDoor();
    }
  }

  if (!unlocked && digitalRead(EXIT_BUTTON_PIN) == LOW) {
    unlockDoor("inside exit button");
    delay(250);
    return;
  }

  uint8_t uid[MAX_UID_BYTES] = {};
  uint8_t uidLength = 0;
  if (!readCardUid(uid, uidLength)) return;
  if (millis() - lastCardAt < CARD_COOLDOWN_MS) return;
  lastCardAt = millis();

  if (enrollmentMode) {
    addCard(uid, uidLength);
    return;
  }
  if (enclosureIsOpen()) {
    denyAccess("enclosure tamper switch is open");
    return;
  }
  if (lockoutActive()) {
    denyAccess("temporary lockout is active");
    return;
  }
  if (findCard(uid, uidLength) >= 0) {
    failedAttempts = 0;
    unlockDoor("authorized card");
  } else {
    failedAttempts++;
    denyAccess("unknown card");
    if (failedAttempts >= FAILED_ATTEMPTS_BEFORE_LOCKOUT) {
      lockoutStartedAt = millis();
      Serial.println("Five failed scans: locked out for 30 seconds.");
    }
  }
}