RFID Classroom Alert Console

#include <Arduino.h>
#include <SPI.h>
#include <WiFi.h>
#include <esp_now.h>
#include <esp_wifi.h>
#include <MFRC522.h>

constexpr uint8_t RFID_SS_PIN = 7;
constexpr uint8_t RFID_SCK_PIN = 4;
constexpr uint8_t RFID_MOSI_PIN = 6;
constexpr uint8_t RFID_MISO_PIN = 5;
constexpr uint8_t RFID_RST_PIN = 10;
constexpr uint8_t LED_PIN = 1;
constexpr uint8_t BUZZER_PIN = 3;

constexpr uint8_t ESPNOW_CHANNEL = 1;
constexpr uint32_t LED_PULSE_MS = 150;
constexpr uint32_t BUZZER_PULSE_MS = 80;
constexpr uint32_t DUPLICATE_SUPPRESSION_MS = 1500;
constexpr uint32_t RFID_POLL_INTERVAL_MS = 25;

const uint8_t BROADCAST_MAC[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

struct CardMapping {
  const uint8_t *uid;
  uint8_t uidLength;
  uint8_t patternId;
};

// Replace these example UIDs with the UID printed by this console for each
// classroom picture card. Keep the UID length and every byte exact.
const uint8_t CARD_01_UID[] = {0x04, 0xA1, 0xB2, 0xC3};
const uint8_t CARD_02_UID[] = {0x04, 0xD4, 0xE5, 0xF6};
const uint8_t CARD_03_UID[] = {0x04, 0x12, 0x34, 0x56};

const CardMapping CARD_MAP[] = {
  {CARD_01_UID, sizeof(CARD_01_UID), 0x01},
  {CARD_02_UID, sizeof(CARD_02_UID), 0x02},
  {CARD_03_UID, sizeof(CARD_03_UID), 0x03},
};
constexpr size_t CARD_MAP_COUNT = sizeof(CARD_MAP) / sizeof(CARD_MAP[0]);

MFRC522 rfid(RFID_SS_PIN, RFID_RST_PIN);

uint8_t lastSentUid[10] = {};
uint8_t lastSentUidLength = 0;
uint32_t lastSentAtMs = 0;
uint32_t lastPollAtMs = 0;
uint32_t ledOffAtMs = 0;
uint32_t buzzerOffAtMs = 0;

bool timeReached(uint32_t now, uint32_t deadline) {
  return static_cast<int32_t>(now - deadline) >= 0;
}

bool uidMatches(const MFRC522::Uid &uid, const uint8_t *expected, uint8_t expectedLength) {
  if (uid.size != expectedLength) {
    return false;
  }
  return memcmp(uid.uidByte, expected, expectedLength) == 0;
}

bool sameAsLastSent(const MFRC522::Uid &uid) {
  return uid.size == lastSentUidLength &&
         memcmp(uid.uidByte, lastSentUid, uid.size) == 0;
}

int findPatternId(const MFRC522::Uid &uid) {
  for (size_t i = 0; i < CARD_MAP_COUNT; ++i) {
    if (uidMatches(uid, CARD_MAP[i].uid, CARD_MAP[i].uidLength)) {
      return CARD_MAP[i].patternId;
    }
  }
  return -1;
}

void printUid(const MFRC522::Uid &uid) {
  Serial.print("Unmapped UID:");
  for (byte i = 0; i < uid.size; ++i) {
    Serial.printf(" %02X", uid.uidByte[i]);
  }
  Serial.println();
}

void startConfirmationPulse() {
  const uint32_t now = millis();
  digitalWrite(LED_PIN, HIGH);
  digitalWrite(BUZZER_PIN, HIGH);
  ledOffAtMs = now + LED_PULSE_MS;
  buzzerOffAtMs = now + BUZZER_PULSE_MS;
}

void updateOutputs() {
  const uint32_t now = millis();
  if (ledOffAtMs != 0 && timeReached(now, ledOffAtMs)) {
    digitalWrite(LED_PIN, LOW);
    ledOffAtMs = 0;
  }
  if (buzzerOffAtMs != 0 && timeReached(now, buzzerOffAtMs)) {
    digitalWrite(BUZZER_PIN, LOW);
    buzzerOffAtMs = 0;
  }
}

bool sendPattern(uint8_t patternId) {
  const esp_err_t result = esp_now_send(BROADCAST_MAC, &patternId, sizeof(patternId));
  if (result != ESP_OK) {
    Serial.printf("ESP-NOW send failed: %d\n", static_cast<int>(result));
    return false;
  }
  Serial.printf("Broadcast pattern ID: 0x%02X\n", patternId);
  return true;
}

void configureEspNow() {
  WiFi.mode(WIFI_STA);
  WiFi.disconnect(false, true);

  esp_err_t result = esp_wifi_set_channel(ESPNOW_CHANNEL, WIFI_SECOND_CHAN_NONE);
  if (result != ESP_OK) {
    Serial.printf("Wi-Fi channel setup failed: %d\n", static_cast<int>(result));
  }

  result = esp_now_init();
  if (result != ESP_OK) {
    Serial.printf("ESP-NOW init failed: %d\n", static_cast<int>(result));
    while (true) {
      delay(1000);
    }
  }

  esp_now_peer_info_t peerInfo = {};
  memcpy(peerInfo.peer_addr, BROADCAST_MAC, sizeof(BROADCAST_MAC));
  peerInfo.channel = ESPNOW_CHANNEL;
  peerInfo.encrypt = false;
  peerInfo.ifidx = WIFI_IF_STA;

  result = esp_now_add_peer(&peerInfo);
  if (result != ESP_OK && result != ESP_ERR_ESPNOW_EXIST) {
    Serial.printf("ESP-NOW broadcast peer setup failed: %d\n", static_cast<int>(result));
    while (true) {
      delay(1000);
    }
  }
}

void checkForCard() {
  const uint32_t now = millis();
  if (now - lastPollAtMs < RFID_POLL_INTERVAL_MS) {
    return;
  }
  lastPollAtMs = now;

  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) {
    return;
  }

  const MFRC522::Uid &uid = rfid.uid;
  const int patternId = findPatternId(uid);
  if (patternId < 0) {
    printUid(uid);
    rfid.PICC_HaltA();
    rfid.PCD_StopCrypto1();
    return;
  }

  const bool duplicateWithinWindow = sameAsLastSent(uid) &&
                                     (now - lastSentAtMs < DUPLICATE_SUPPRESSION_MS);
  if (!duplicateWithinWindow) {
    if (sendPattern(static_cast<uint8_t>(patternId))) {
      memcpy(lastSentUid, uid.uidByte, uid.size);
      lastSentUidLength = uid.size;
      lastSentAtMs = now;
      startConfirmationPulse();
    }
  }

  rfid.PICC_HaltA();
  rfid.PCD_StopCrypto1();
}

void setup() {
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);
  digitalWrite(BUZZER_PIN, LOW);

  Serial.begin(115200);
  delay(100);
  Serial.println("Scanner Console starting");

  SPI.begin(RFID_SCK_PIN, RFID_MISO_PIN, RFID_MOSI_PIN, RFID_SS_PIN);
  rfid.PCD_Init();
  configureEspNow();
  Serial.println("Ready: ESP-NOW broadcast channel 1");
}

void loop() {
  updateOutputs();
  checkForCard();
  delay(1);
}