Stadium Attendance Counter

#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <ESP32Servo.h>
#include <Preferences.h>


// Forward declarations
bool isTicketUsed(uint16_t ticketNumber);
void setTicketUsed(uint16_t ticketNumber);
void saveAttendance();
void drawScreen();
void beep(uint16_t frequency, uint16_t durationMs);
void showResult(const String &message, bool accepted);
void openBarrier();
bool parseTicket(const String &raw, uint16_t &ticketNumber);
void processTicket(const String &raw);
void clearAttendance();

constexpr int SCANNER_RX_PIN = 16;
constexpr int OLED_SDA_PIN = 21;
constexpr int OLED_SCL_PIN = 22;
constexpr int SERVO_PIN = 25;
constexpr int BUZZER_PIN = 26;
constexpr int RESET_BUTTON_PIN = 27;
constexpr int GREEN_LED_PIN = 18;
constexpr int RED_LED_PIN = 19;
constexpr uint32_t SCANNER_BAUD = 9600;
constexpr uint16_t STADIUM_CAPACITY = 20000;
constexpr size_t USED_BYTES = (STADIUM_CAPACITY + 7) / 8;
constexpr uint32_t GATE_OPEN_MS = 1800;
constexpr uint32_t RESET_HOLD_MS = 5000;

Adafruit_SSD1306 display(128, 64, &Wire, -1);
Servo barrier;
Preferences preferences;
uint8_t usedTickets[USED_BYTES] = {};
uint16_t attendeeCount = 0;
String scanBuffer;
bool barrierOpen = false;
uint32_t barrierCloseAt = 0;
uint32_t resetPressedAt = 0;
String statusLine = "Ready to scan";

bool isTicketUsed(uint16_t ticketNumber) {
  uint16_t index = ticketNumber - 1;
  return (usedTickets[index / 8] & (1 << (index % 8))) != 0;
}

void setTicketUsed(uint16_t ticketNumber) {
  uint16_t index = ticketNumber - 1;
  usedTickets[index / 8] |= (1 << (index % 8));
}

void saveAttendance() {
  preferences.putUShort("count", attendeeCount);
  preferences.putBytes("used", usedTickets, USED_BYTES);
}

void drawScreen() {
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);
  display.setTextSize(1);
  display.setCursor(0, 0);
  display.println("STADIUM ENTRY - GATE 1");
  display.drawLine(0, 10, 127, 10, SSD1306_WHITE);
  display.setTextSize(2);
  display.setCursor(0, 17);
  display.printf("%u", attendeeCount);
  display.setTextSize(1);
  display.print(" / ");
  display.println(STADIUM_CAPACITY);
  display.setCursor(0, 43);
  display.println(statusLine);
  display.display();
}

void beep(uint16_t frequency, uint16_t durationMs) {
  tone(BUZZER_PIN, frequency, durationMs);
}

void showResult(const String &message, bool accepted) {
  statusLine = message;
  digitalWrite(GREEN_LED_PIN, accepted ? HIGH : LOW);
  digitalWrite(RED_LED_PIN, accepted ? LOW : HIGH);
  beep(accepted ? 1600 : 300, accepted ? 100 : 350);
  drawScreen();
}

void openBarrier() {
  barrier.write(90);
  barrierOpen = true;
  barrierCloseAt = millis() + GATE_OPEN_MS;
}

bool parseTicket(const String &raw, uint16_t &ticketNumber) {
  String code = raw;
  code.trim();
  if (code.length() != 10 || !code.startsWith("STAD-")) {
    return false;
  }
  for (uint8_t i = 5; i < 10; i++) {
    if (!isDigit(code[i])) {
      return false;
    }
  }
  long number = code.substring(5).toInt();
  if (number < 1 || number > STADIUM_CAPACITY) {
    return false;
  }
  ticketNumber = static_cast<uint16_t>(number);
  return true;
}

void processTicket(const String &raw) {
  uint16_t ticketNumber = 0;
  if (!parseTicket(raw, ticketNumber)) {
    showResult("INVALID TICKET", false);
    return;
  }
  if (isTicketUsed(ticketNumber)) {
    showResult("ALREADY USED", false);
    return;
  }
  if (attendeeCount >= STADIUM_CAPACITY) {
    showResult("VENUE FULL", false);
    return;
  }

  setTicketUsed(ticketNumber);
  attendeeCount++;
  saveAttendance();
  showResult("ENTRY ACCEPTED", true);
  openBarrier();
  Serial.printf("ACCEPTED,gate=1,ticket=%05u,count=%u\n", ticketNumber, attendeeCount);
}

void clearAttendance() {
  memset(usedTickets, 0, USED_BYTES);
  attendeeCount = 0;
  saveAttendance();
  statusLine = "COUNT CLEARED";
  digitalWrite(GREEN_LED_PIN, LOW);
  digitalWrite(RED_LED_PIN, LOW);
  beep(1000, 150);
  drawScreen();
  Serial.println("ADMIN_RESET,gate=1,count=0");
}

void setup() {
  Serial.begin(115200);
  Serial2.begin(SCANNER_BAUD, SERIAL_8N1, SCANNER_RX_PIN, -1);
  pinMode(GREEN_LED_PIN, OUTPUT);
  pinMode(RED_LED_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(RESET_BUTTON_PIN, INPUT_PULLUP);
  digitalWrite(GREEN_LED_PIN, LOW);
  digitalWrite(RED_LED_PIN, LOW);

  preferences.begin("stadium", false);
  attendeeCount = preferences.getUShort("count", 0);
  if (preferences.getBytesLength("used") == USED_BYTES) {
    preferences.getBytes("used", usedTickets, USED_BYTES);
  } else {
    memset(usedTickets, 0, USED_BYTES);
    saveAttendance();
  }

  Wire.begin(OLED_SDA_PIN, OLED_SCL_PIN);
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println("OLED initialization failed");
  }
  barrier.setPeriodHertz(50);
  barrier.attach(SERVO_PIN, 500, 2400);
  barrier.write(0);
  drawScreen();
  Serial.println("Gate 1 ready. Ticket format: STAD-00001 to STAD-20000");
}

void loop() {
  while (Serial2.available()) {
    char received = static_cast<char>(Serial2.read());
    if (received == '\r' || received == '\n') {
      if (scanBuffer.length() > 0) {
        processTicket(scanBuffer);
        scanBuffer = "";
      }
    } else if (scanBuffer.length() < 32) {
      scanBuffer += received;
    }
  }

  if (barrierOpen && millis() >= barrierCloseAt) {
    barrier.write(0);
    barrierOpen = false;
    digitalWrite(GREEN_LED_PIN, LOW);
    statusLine = "Ready to scan";
    drawScreen();
  }

  if (digitalRead(RESET_BUTTON_PIN) == LOW) {
    if (resetPressedAt == 0) {
      resetPressedAt = millis();
    } else if (millis() - resetPressedAt >= RESET_HOLD_MS) {
      clearAttendance();
      while (digitalRead(RESET_BUTTON_PIN) == LOW) {
        delay(10);
      }
      resetPressedAt = 0;
    }
  } else {
    resetPressedAt = 0;
  }
}