Portable Secure EV Charging Station

#include <Arduino.h>
#include <Wire.h>
#include <SPI.h>
#include <MFRC522.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_MCP23X17.h>
#include <ESP32Servo.h>
#include <WiFi.h>
#include <esp_now.h>

// Tabletop theft-protection demonstrator.
// Docked = servo at LOCK_ANGLE. After an approved RFID card and PIN,
// the servo moves to RELEASE_ANGLE so the small unit can be removed.


// Forward declarations
void showStatus(const String &line1, const String &line2);
void lockDock(const String &reason);
void releaseDock();
void startAlarm(const String &reason);
void serviceAlarm();
String cardUid();
void pollRfid();
char scanKeypad();
void pollKeypad();
void pollTamper();
void beginRadio();
void sendPortableRelease();

constexpr uint8_t SERVO_PIN = 14;
constexpr uint8_t CHARGE_ENABLE_PIN = 26;
constexpr uint8_t BUZZER_PIN = 27;
constexpr uint8_t RED_LED_PIN = 32;
constexpr uint8_t GREEN_LED_PIN = 33;
constexpr uint8_t RFID_SS_PIN = 4;
constexpr uint8_t RFID_RST_PIN = 13;
constexpr uint8_t RFID_SCK_PIN = 18;
constexpr uint8_t RFID_MISO_PIN = 19;
constexpr uint8_t RFID_MOSI_PIN = 23;
constexpr uint8_t I2C_SDA_PIN = 21;
constexpr uint8_t I2C_SCL_PIN = 22;
constexpr uint8_t OLED_ADDR = 0x3C;
constexpr uint8_t MCP_ADDR = 0x20;
constexpr uint8_t ROW_COUNT = 4;
constexpr uint8_t COLUMN_BASE = 4;
constexpr uint8_t VIBRATION_INPUT = 8; // MCP GPB0
constexpr int LOCK_ANGLE = 15;
constexpr int RELEASE_ANGLE = 100;
constexpr unsigned long CARD_WINDOW_MS = 30000UL;
constexpr unsigned long RELEASE_WINDOW_MS = 15000UL;
// Change both credentials before deployment.
const char AUTHORIZED_RFID_UID[] = "DEADBEEF";
const char RELEASE_PIN[] = "2580";
const char PROJECT_KEY[] = "SSPCU-DEMO-2026";
const uint8_t PORTABLE_BROADCAST_MAC[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

struct __attribute__((packed)) RadioPacket {
  char key[20];
  char event[12];
};

bool portableOnline = false;

const char KEYMAP[4][4] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

Adafruit_SSD1306 display(128, 64, &Wire, -1);
Adafruit_MCP23X17 mcp;
MFRC522 rfid(RFID_SS_PIN, RFID_RST_PIN);
Servo dockServo;

bool cardAccepted = false;
bool released = false;
bool alarmActive = false;
String enteredPin;
String shownLine1;
String shownLine2;
unsigned long cardAcceptedAt = 0;
unsigned long releasedAt = 0;
unsigned long lastAlarmToneAt = 0;

void showStatus(const String &line1, const String &line2) {
  if (line1 == shownLine1 && line2 == shownLine2) return;
  shownLine1 = line1;
  shownLine2 = line2;
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);
  display.setTextSize(1);
  display.setCursor(0, 0);
  display.println("SSPCU MINI DOCK");
  display.drawFastHLine(0, 11, 128, SSD1306_WHITE);
  display.setCursor(0, 18);
  display.println(line1);
  display.setCursor(0, 34);
  display.println(line2);
  display.setCursor(0, 52);
  display.println(released ? "LATCH: RELEASED" : "LATCH: LOCKED");
  display.display();
}

void lockDock(const String &reason) {
  released = false;
  cardAccepted = false;
  enteredPin = "";
  dockServo.write(LOCK_ANGLE);
  digitalWrite(CHARGE_ENABLE_PIN, HIGH);
  digitalWrite(GREEN_LED_PIN, LOW);
  digitalWrite(RED_LED_PIN, HIGH);
  showStatus("DOCK LOCKED", reason);
}

void releaseDock() {
  released = true;
  alarmActive = false;
  // Remove charging power before the latch can release the portable unit.
  digitalWrite(CHARGE_ENABLE_PIN, LOW);
  sendPortableRelease();
  releasedAt = millis();
  dockServo.write(RELEASE_ANGLE);
  digitalWrite(RED_LED_PIN, LOW);
  digitalWrite(GREEN_LED_PIN, HIGH);
  tone(BUZZER_PIN, 2200, 120);
  showStatus("ACCESS APPROVED", "REMOVE UNIT NOW");
}

void startAlarm(const String &reason) {
  if (released || alarmActive) return;
  alarmActive = true;
  showStatus("TAMPER ALARM", reason);
}

void serviceAlarm() {
  if (!alarmActive) return;
  if (millis() - lastAlarmToneAt >= 800UL) {
    lastAlarmToneAt = millis();
    tone(BUZZER_PIN, 3000, 260);
    digitalWrite(RED_LED_PIN, !digitalRead(RED_LED_PIN));
  }
}

String cardUid() {
  String uid;
  for (byte i = 0; i < rfid.uid.size; ++i) {
    if (rfid.uid.uidByte[i] < 0x10) uid += '0';
    uid += String(rfid.uid.uidByte[i], HEX);
  }
  uid.toUpperCase();
  return uid;
}

void onRadioReceive(const esp_now_recv_info_t *, const uint8_t *data, int length) {
  if (length != sizeof(RadioPacket)) return;
  RadioPacket packet{};
  memcpy(&packet, data, sizeof(packet));
  if (strcmp(packet.key, PROJECT_KEY) != 0) return;
  if (strcmp(packet.event, "ONLINE") == 0 || strcmp(packet.event, "ACK") == 0) portableOnline = true;
  if (strcmp(packet.event, "TAMPER") == 0) startAlarm("PORTABLE UNIT MOVED");
}

void beginRadio() {
  WiFi.mode(WIFI_STA);
  if (esp_now_init() != ESP_OK) return;
  esp_now_register_recv_cb(onRadioReceive);
  esp_now_peer_info_t peer{};
  memcpy(peer.peer_addr, PORTABLE_BROADCAST_MAC, 6);
  peer.channel = 0;
  peer.encrypt = false;
  esp_now_add_peer(&peer);
}

void sendPortableRelease() {
  RadioPacket packet{};
  strncpy(packet.key, PROJECT_KEY, sizeof(packet.key) - 1);
  strncpy(packet.event, "RELEASE", sizeof(packet.event) - 1);
  esp_now_send(PORTABLE_BROADCAST_MAC, reinterpret_cast<const uint8_t *>(&packet), sizeof(packet));
}

void pollRfid() {
  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) return;
  const String uid = cardUid();
  rfid.PICC_HaltA();
  rfid.PCD_StopCrypto1();
  if (uid == AUTHORIZED_RFID_UID) {
    cardAccepted = true;
    cardAcceptedAt = millis();
    enteredPin = "";
    tone(BUZZER_PIN, 1700, 70);
    showStatus("RFID ACCEPTED", "TYPE PIN, THEN #");
  } else {
    tone(BUZZER_PIN, 300, 200);
    showStatus("UNKNOWN RFID", "ACCESS DENIED");
  }
}

char scanKeypad() {
  for (uint8_t row = 0; row < ROW_COUNT; ++row) {
    for (uint8_t pin = 0; pin < ROW_COUNT; ++pin) mcp.digitalWrite(pin, HIGH);
    mcp.digitalWrite(row, LOW);
    delayMicroseconds(80);
    for (uint8_t column = 0; column < ROW_COUNT; ++column) {
      if (mcp.digitalRead(COLUMN_BASE + column) == LOW) {
        delay(25); // a quick tap counts once
        while (mcp.digitalRead(COLUMN_BASE + column) == LOW) delay(2);
        mcp.digitalWrite(row, HIGH);
        return KEYMAP[row][column];
      }
    }
    mcp.digitalWrite(row, HIGH);
  }
  return 0;
}

void pollKeypad() {
  const char key = scanKeypad();
  if (!key) return;
  if (key == 'D') {
    lockDock("MANUAL LOCK");
    return;
  }
  if (key == '*') {
    enteredPin = "";
    showStatus("PIN CLEARED", "TYPE PIN, THEN #");
    return;
  }
  if (key >= '0' && key <= '9' && enteredPin.length() < 8) {
    enteredPin += key;
    String masked;
    for (size_t i = 0; i < enteredPin.length(); ++i) masked += '*';
    showStatus(cardAccepted ? "PIN ENTERED" : "PRESENT RFID FIRST", masked);
    return;
  }
  if (key == '#') {
    if (cardAccepted && enteredPin == RELEASE_PIN) {
      releaseDock();
    } else {
      tone(BUZZER_PIN, 300, 250);
      showStatus("PIN DENIED", "DOCK STAYS LOCKED");
    }
    enteredPin = "";
  }
}

void pollTamper() {
  if (mcp.digitalRead(VIBRATION_INPUT) == HIGH) startAlarm("VIBRATION DETECTED");
}

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(CHARGE_ENABLE_PIN, OUTPUT);
  digitalWrite(CHARGE_ENABLE_PIN, LOW);
  pinMode(RED_LED_PIN, OUTPUT);
  pinMode(GREEN_LED_PIN, OUTPUT);
  digitalWrite(RED_LED_PIN, HIGH);
  digitalWrite(GREEN_LED_PIN, LOW);

  Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN);
  beginRadio();
  display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR);
  showStatus("STARTING", "KEEP DOCK CLOSED");

  mcp.begin_I2C(MCP_ADDR, &Wire);
  for (uint8_t pin = 0; pin < ROW_COUNT; ++pin) {
    mcp.pinMode(pin, OUTPUT);
    mcp.digitalWrite(pin, HIGH);
  }
  for (uint8_t pin = COLUMN_BASE; pin < VIBRATION_INPUT; ++pin) mcp.pinMode(pin, INPUT_PULLUP);
  mcp.pinMode(VIBRATION_INPUT, INPUT);

  SPI.begin(RFID_SCK_PIN, RFID_MISO_PIN, RFID_MOSI_PIN, RFID_SS_PIN);
  rfid.PCD_Init();
  dockServo.setPeriodHertz(50);
  dockServo.attach(SERVO_PIN, 500, 2400);
  lockDock("PRESENT RFID CARD");
}

void loop() {
  pollRfid();
  pollKeypad();
  pollTamper();
  serviceAlarm();

  if (cardAccepted && !released && millis() - cardAcceptedAt > CARD_WINDOW_MS) {
    lockDock("CARD TIMEOUT");
  }
  if (released && millis() - releasedAt > RELEASE_WINDOW_MS) {
    lockDock("RELEASE TIMEOUT");
  }
}