Timed Bolt Lock Box

#include <Arduino.h>
#include <U8g2lib.h>
#include <SPI.h>
#include <ESP32Servo.h>

// ── Pin definitions ─────────────────────────────────────────────────────────
#define OLED_SCK    6
#define OLED_MOSI   7
#define OLED_CS    10
#define OLED_DC     4
#define OLED_RST    3
#define SERVO_PIN   5
#define BTN_UP      0
#define BTN_START   1

// ── Hardware objects ─────────────────────────────────────────────────────────
// U8g2 SW SPI: (rotation, SCK, MOSI, CS, DC, RST)

enum State { SET_TIME, LOCKING, COUNTDOWN, UNLOCKING };


// Forward declarations
bool btnUpPressed();
bool btnStartPressed();
bool upFired();
bool startFired();
void drawSetTime();
void drawCountdown();
void drawMessage(const char* line1, const char* line2);

U8G2_SSD1306_72X40_ER_1_4W_SW_SPI u8g2(
    U8G2_R0, OLED_SCK, OLED_MOSI, OLED_CS, OLED_DC, OLED_RST);

Servo lockServo;

// ── Config ───────────────────────────────────────────────────────────────────
static const int OPEN_ANGLE   = 10;   // servo angle = bolt retracted (unlocked)
static const int LOCKED_ANGLE = 170;  // servo angle = bolt extended (locked)
static const int MIN_MINUTES  = 1;
static const int MAX_MINUTES  = 60;

// ── State machine ────────────────────────────────────────────────────────────

State state = SET_TIME;

int     setMinutes    = 5;         // default 5 min
long    countdownSec  = 0;
unsigned long lastTick     = 0;    // millis of last 1-second tick
unsigned long lastUpPress  = 0;    // for button debounce / repeat
unsigned long lockHoldStart = 0;   // for emergency hold-to-cancel

// ── Button helpers ───────────────────────────────────────────────────────────
bool btnUpPressed()    { return digitalRead(BTN_UP)    == LOW; }
bool btnStartPressed() { return digitalRead(BTN_START) == LOW; }

// Debounce with auto-repeat for UP button (hold to scroll fast)
static unsigned long lastUpFire = 0;
static bool          upHeld     = false;
bool upFired() {
    if (!btnUpPressed()) { upHeld = false; return false; }
    unsigned long now = millis();
    if (!upHeld) {
        if (now - lastUpFire < 50) return false; // initial debounce
        upHeld = true; lastUpFire = now; return true;
    }
    // held: fire every 400 ms, then every 150 ms after 2 s
    unsigned long repeat = (now - lastUpFire > 2000) ? 150 : 400;
    if (now - lastUpFire >= repeat) { lastUpFire = now; return true; }
    return false;
}

// Debounce for START button (single-press)
static bool startWasDown = false;
bool startFired() {
    bool down = btnStartPressed();
    if (down && !startWasDown) { startWasDown = true; return true; }
    if (!down) startWasDown = false;
    return false;
}

// ── Display helpers ──────────────────────────────────────────────────────────
// 72x40 display; xOffset=30 maps GDDRAM 132-wide → visible 72 cols
static const int XO = 30;  // horizontal pixel offset for SSD1306 72x40

void drawSetTime() {
    char buf[12];
    u8g2.clearBuffer();

    // Title row
    u8g2.setFont(u8g2_font_5x7_tr);
    u8g2.setCursor(XO + 6, 8);
    u8g2.print("SET TIME");

    // Large minutes
    u8g2.setFont(u8g2_font_logisoso16_tr);
    snprintf(buf, sizeof(buf), "%02d:00", setMinutes);
    u8g2.setCursor(XO + 3, 28);
    u8g2.print(buf);

    // Help row
    u8g2.setFont(u8g2_font_5x7_tr);
    u8g2.setCursor(XO, 38);
    u8g2.print("^UP >LOCK");

    u8g2.sendBuffer();
}

void drawCountdown() {
    char buf[12];
    long s = countdownSec;
    int hh = s / 3600; s %= 3600;
    int mm = s / 60;
    int ss = s % 60;

    u8g2.clearBuffer();

    // Status row
    u8g2.setFont(u8g2_font_5x7_tr);
    u8g2.setCursor(XO + 2, 8);
    u8g2.print("*LOCKED*");

    // Countdown digits
    u8g2.setFont(u8g2_font_logisoso16_tr);
    if (hh > 0) {
        snprintf(buf, sizeof(buf), "%d:%02d", hh, mm);
    } else {
        snprintf(buf, sizeof(buf), "%02d:%02d", mm, ss);
    }
    u8g2.setCursor(XO + 2, 28);
    u8g2.print(buf);

    // Cancel hint
    u8g2.setFont(u8g2_font_5x7_tr);
    u8g2.setCursor(XO, 38);
    u8g2.print("hld>cncl");

    u8g2.sendBuffer();
}

void drawMessage(const char* line1, const char* line2) {
    u8g2.clearBuffer();
    u8g2.setFont(u8g2_font_5x7_tr);
    u8g2.setCursor(XO, 16);
    u8g2.print(line1);
    if (line2) {
        u8g2.setCursor(XO, 28);
        u8g2.print(line2);
    }
    u8g2.sendBuffer();
}

// ── Arduino entry points ─────────────────────────────────────────────────────
void setup() {
    pinMode(BTN_UP,    INPUT_PULLUP);
    pinMode(BTN_START, INPUT_PULLUP);

    // Servo – park at open position
    ESP32PWM::allocateTimer(0);
    lockServo.setPeriodHertz(50);
    lockServo.attach(SERVO_PIN, 500, 2400);
    lockServo.write(OPEN_ANGLE);

    // Display init
    u8g2.begin();
    u8g2.setContrast(255);

    drawSetTime();
}

void loop() {
    unsigned long now = millis();

    switch (state) {

    // ── SET TIME ─────────────────────────────────────────────────────────────
    case SET_TIME:
        if (upFired()) {
            setMinutes++;
            if (setMinutes > MAX_MINUTES) setMinutes = MIN_MINUTES;
            drawSetTime();
        }
        if (startFired()) {
            state = LOCKING;
            drawMessage("LOCKING", "...");
            lockServo.write(LOCKED_ANGLE);
            delay(800); // let servo travel
            countdownSec = (long)setMinutes * 60L;
            lastTick = millis();
            lockHoldStart = 0;
            state = COUNTDOWN;
            drawCountdown();
        }
        break;

    // ── COUNTDOWN ────────────────────────────────────────────────────────────
    case COUNTDOWN:
        // 1-second tick
        if (millis() - lastTick >= 1000) {
            lastTick += 1000;
            countdownSec--;
            if (countdownSec <= 0) {
                // Time's up — unlock
                state = UNLOCKING;
                drawMessage("TIME UP", "UNLOCKED");
                lockServo.write(OPEN_ANGLE);
                delay(800);
                state = SET_TIME;
                setMinutes = 5;
                drawSetTime();
            } else {
                drawCountdown();
            }
        }

        // Emergency cancel: hold START for 3 seconds
        if (btnStartPressed()) {
            if (lockHoldStart == 0) lockHoldStart = millis();
            if (millis() - lockHoldStart >= 3000) {
                state = UNLOCKING;
                drawMessage("CANCELLED", "UNLOCKED");
                lockServo.write(OPEN_ANGLE);
                delay(800);
                state = SET_TIME;
                setMinutes = 5;
                lockHoldStart = 0;
                drawSetTime();
            }
        } else {
            lockHoldStart = 0;
        }
        break;

    default:
        break;
    }
}