RFID Smart Parking System

#include <Arduino.h>
#include <Wire.h>
#include <SPI.h>
#include <Servo.h>
#include <MFRC522.h>
#include <LiquidCrystal_I2C.h>
#include <EEPROM.h>


// Forward declarations
void showStatus();
void setMessage(const char *message);
void showWallWarning();
void openEntryGate();
void closeEntryGate();
void openExitGate();
void closeExitGate();
void loadAuthorizedCard();
void saveAuthorizedCard(const MFRC522::Uid &uid);
bool cardIsAuthorized(const MFRC522::Uid &uid);
void handleRfid();
void handleSensors();
unsigned int measureWallDistanceCm();
void handleWallAlarm();
void updateGates();

const byte ENTRY_IR_PIN = 2;
const byte WALL_BUZZER_PIN = 3;
const byte EXIT_IR_PIN = 4;
const byte ENTRY_SERVO_PIN = 5;
const byte EXIT_SERVO_PIN = 6;
const byte RFID_RST_PIN = 7;
const byte WALL_TRIG_PIN = 8;
const byte WALL_ECHO_PIN = 9;
const byte RFID_SS_PIN = 10;
const byte RFID_MOSI_PIN = 11;
const byte RFID_MISO_PIN = 12;
const byte RFID_SCK_PIN = 13;

const byte GATE_CLOSED_ANGLE = 5;
const byte GATE_OPEN_ANGLE = 90;
const unsigned long GATE_OPEN_MS = 4000;
const unsigned long SENSOR_LOCKOUT_MS = 900;
const byte LOT_CAPACITY = 10;

// Mount the ultrasonic sensor at the wall facing the car's bumper.
const unsigned int WARNING_DISTANCE_CM = 30;
const unsigned int STOP_DISTANCE_CM = 12;
const unsigned long DISTANCE_SAMPLE_MS = 100;
const unsigned long WARNING_BEEP_PERIOD_MS = 350;

const byte EEPROM_MAGIC = 0xA5;
const int EEPROM_MAGIC_ADDR = 0;
const int EEPROM_UID_LENGTH_ADDR = 1;
const int EEPROM_UID_ADDR = 2;

Servo entryGate;
Servo exitGate;
MFRC522 rfid(RFID_SS_PIN, RFID_RST_PIN);
LiquidCrystal_I2C lcd(0x27, 16, 2);

byte authorizedUid[10];
byte authorizedUidLength = 0;
byte occupiedSpaces = 0;
bool entryGateOpen = false;
bool exitGateOpen = false;
bool entryCountedThisOpen = false;
bool wallStopActive = false;
bool wallWarningActive = false;
bool buzzerOn = false;
unsigned int wallDistanceCm = 0;
unsigned long entryGateOpenedAt = 0;
unsigned long exitGateOpenedAt = 0;
unsigned long lastEntrySensorAt = 0;
unsigned long lastExitSensorAt = 0;
unsigned long lastDistanceSampleAt = 0;
unsigned long lastBuzzerChangeAt = 0;
char messageLine[17] = "Scan card at gate";

void showStatus() {
  lcd.setCursor(0, 0);
  lcd.print("Free: ");
  lcd.print(LOT_CAPACITY - occupiedSpaces);
  lcd.print("/");
  lcd.print(LOT_CAPACITY);
  lcd.print("     ");
  lcd.setCursor(0, 1);
  lcd.print(messageLine);
  lcd.print("                ");
}

void setMessage(const char *message) {
  strncpy(messageLine, message, 16);
  messageLine[16] = '\0';
  if (!wallStopActive && !wallWarningActive) showStatus();
}

void showWallWarning() {
  lcd.setCursor(0, 0);
  if (wallStopActive) {
    lcd.print("STOP! ");
  } else {
    lcd.print("SLOW DOWN ");
  }
  lcd.print(wallDistanceCm);
  lcd.print("cm   ");
  lcd.setCursor(0, 1);
  lcd.print("Wall ahead      ");
}

void openEntryGate() {
  entryGate.write(GATE_OPEN_ANGLE);
  entryGateOpen = true;
  entryCountedThisOpen = false;
  entryGateOpenedAt = millis();
}

void closeEntryGate() {
  entryGate.write(GATE_CLOSED_ANGLE);
  entryGateOpen = false;
  setMessage("Scan card at gate");
}

void openExitGate() {
  exitGate.write(GATE_OPEN_ANGLE);
  exitGateOpen = true;
  exitGateOpenedAt = millis();
}

void closeExitGate() {
  exitGate.write(GATE_CLOSED_ANGLE);
  exitGateOpen = false;
  setMessage("Scan card at gate");
}

void loadAuthorizedCard() {
  if (EEPROM.read(EEPROM_MAGIC_ADDR) != EEPROM_MAGIC) {
    authorizedUidLength = 0;
    return;
  }
  byte length = EEPROM.read(EEPROM_UID_LENGTH_ADDR);
  if (length == 0 || length > sizeof(authorizedUid)) {
    authorizedUidLength = 0;
    return;
  }
  authorizedUidLength = length;
  for (byte i = 0; i < authorizedUidLength; i++) {
    authorizedUid[i] = EEPROM.read(EEPROM_UID_ADDR + i);
  }
}

void saveAuthorizedCard(const MFRC522::Uid &uid) {
  authorizedUidLength = uid.size;
  EEPROM.update(EEPROM_UID_LENGTH_ADDR, authorizedUidLength);
  for (byte i = 0; i < authorizedUidLength; i++) {
    authorizedUid[i] = uid.uidByte[i];
    EEPROM.update(EEPROM_UID_ADDR + i, authorizedUid[i]);
  }
  EEPROM.update(EEPROM_MAGIC_ADDR, EEPROM_MAGIC);
}

bool cardIsAuthorized(const MFRC522::Uid &uid) {
  if (uid.size != authorizedUidLength) return false;
  for (byte i = 0; i < uid.size; i++) {
    if (uid.uidByte[i] != authorizedUid[i]) return false;
  }
  return true;
}

void handleRfid() {
  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) return;
  if (authorizedUidLength == 0) {
    saveAuthorizedCard(rfid.uid);
    setMessage("Card saved - enter");
    if (occupiedSpaces < LOT_CAPACITY) openEntryGate();
  } else if (cardIsAuthorized(rfid.uid)) {
    if (occupiedSpaces < LOT_CAPACITY) {
      setMessage("Access granted");
      openEntryGate();
    } else {
      setMessage("Parking is full");
    }
  } else {
    setMessage("Card not allowed");
  }
  rfid.PICC_HaltA();
  rfid.PCD_StopCrypto1();
}

void handleSensors() {
  unsigned long now = millis();
  if (entryGateOpen && !entryCountedThisOpen && digitalRead(ENTRY_IR_PIN) == LOW && now - lastEntrySensorAt > SENSOR_LOCKOUT_MS) {
    lastEntrySensorAt = now;
    entryCountedThisOpen = true;
    if (occupiedSpaces < LOT_CAPACITY) {
      occupiedSpaces++;
      setMessage("Car entered");
    }
  }
  if (!exitGateOpen && digitalRead(EXIT_IR_PIN) == LOW && now - lastExitSensorAt > SENSOR_LOCKOUT_MS) {
    lastExitSensorAt = now;
    if (occupiedSpaces > 0) occupiedSpaces--;
    setMessage("Exit gate open");
    openExitGate();
  }
}

unsigned int measureWallDistanceCm() {
  digitalWrite(WALL_TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(WALL_TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(WALL_TRIG_PIN, LOW);
  unsigned long duration = pulseIn(WALL_ECHO_PIN, HIGH, 25000UL);
  if (duration == 0) return 0;
  return duration / 58UL;
}

void handleWallAlarm() {
  unsigned long now = millis();
  if (now - lastDistanceSampleAt >= DISTANCE_SAMPLE_MS) {
    lastDistanceSampleAt = now;
    unsigned int distance = measureWallDistanceCm();
    bool wasWarning = wallWarningActive;
    bool wasStop = wallStopActive;
    wallDistanceCm = distance;
    wallStopActive = (distance > 0 && distance <= STOP_DISTANCE_CM);
    wallWarningActive = (!wallStopActive && distance > 0 && distance <= WARNING_DISTANCE_CM);
    if (wallStopActive || wallWarningActive) {
      if (!wasWarning && !wasStop) lastBuzzerChangeAt = 0;
      showWallWarning();
    } else if (wasWarning || wasStop) {
      digitalWrite(WALL_BUZZER_PIN, LOW);
      buzzerOn = false;
      showStatus();
    }
  }

  if (wallStopActive) {
    if (!buzzerOn) {
      digitalWrite(WALL_BUZZER_PIN, HIGH);
      buzzerOn = true;
    }
  } else if (wallWarningActive) {
    if (now - lastBuzzerChangeAt >= WARNING_BEEP_PERIOD_MS) {
      lastBuzzerChangeAt = now;
      buzzerOn = !buzzerOn;
      digitalWrite(WALL_BUZZER_PIN, buzzerOn ? HIGH : LOW);
    }
  } else if (buzzerOn) {
    digitalWrite(WALL_BUZZER_PIN, LOW);
    buzzerOn = false;
  }
}

void updateGates() {
  unsigned long now = millis();
  if (entryGateOpen && now - entryGateOpenedAt >= GATE_OPEN_MS) closeEntryGate();
  if (exitGateOpen && now - exitGateOpenedAt >= GATE_OPEN_MS) closeExitGate();
}

void setup() {
  pinMode(ENTRY_IR_PIN, INPUT_PULLUP);
  pinMode(EXIT_IR_PIN, INPUT_PULLUP);
  pinMode(WALL_TRIG_PIN, OUTPUT);
  pinMode(WALL_ECHO_PIN, INPUT);
  pinMode(WALL_BUZZER_PIN, OUTPUT);
  digitalWrite(WALL_TRIG_PIN, LOW);
  digitalWrite(WALL_BUZZER_PIN, LOW);

  entryGate.attach(ENTRY_SERVO_PIN);
  exitGate.attach(EXIT_SERVO_PIN);
  entryGate.write(GATE_CLOSED_ANGLE);
  exitGate.write(GATE_CLOSED_ANGLE);

  Wire.begin();
  lcd.init();
  lcd.backlight();
  setMessage("Starting system");
  SPI.begin();
  rfid.PCD_Init();
  loadAuthorizedCard();
  delay(500);
  setMessage(authorizedUidLength == 0 ? "Scan first card" : "Scan card at gate");
}

void loop() {
  handleRfid();
  handleSensors();
  handleWallAlarm();
  updateGates();
}