Occupancy-Aware Room Lock

#include <Arduino.h>
#include <ESP32Servo.h>
#include "thread_stubs.h"

constexpr uint8_t SERVO_PIN = 18;
constexpr uint8_t PIR_PIN = 2;
constexpr uint8_t DOOR_REED_PIN = 10;
constexpr uint8_t RELEASE_BUTTON_PIN = 11;
constexpr uint8_t GREEN_LED_PIN = 6;
constexpr uint8_t RED_LED_PIN = 7;
constexpr uint8_t BUZZER_PIN = 3;  // Reserved only; connect an active buzzer later if wanted.

constexpr int UNLOCKED_ANGLE = 0;
constexpr int LOCKED_ANGLE = 90;
constexpr unsigned long PIR_WARMUP_MS = 30000UL;
constexpr unsigned long VACANCY_TIMEOUT_MS = 30000UL;  // Demo: use 600000UL for the final 10-minute timeout.
constexpr unsigned long SERVO_SETTLE_MS = 450UL;
constexpr unsigned long BUTTON_DEBOUNCE_MS = 35UL;
constexpr unsigned long STATUS_LOG_MS = 1000UL;

enum Mode { HOME, NIGHT, AWAY, LOCK_AWAY, ALARM, SMOKE };

Servo boltServo;
Mode currentMode = HOME;
bool locked = false;
bool roomOccupied = true;
bool previousPir = false;
bool previousButton = true;
bool servoSignalAttached = false;
unsigned long servoDetachAtMs = 0;
unsigned long bootMs = 0;
unsigned long lastMotionMs = 0;
unsigned long lastButtonEdgeMs = 0;
unsigned long lastStatusLogMs = 0;

const char *modeName(Mode mode) {
  switch (mode) {
    case HOME: return "home";
    case NIGHT: return "night";
    case AWAY: return "away";
    case LOCK_AWAY: return "lock-away";
    case ALARM: return "alarm";
    case SMOKE: return "smoke";
  }
  return "home";
}

bool doorShut() {
  // With INPUT_PULLUP, a closed reed wired to GND reads LOW.
  return digitalRead(DOOR_REED_PIN) == LOW;
}

bool modePermitsLock() {
  return currentMode == AWAY || currentMode == LOCK_AWAY || currentMode == ALARM;
}

void updateIndicators() {
  digitalWrite(GREEN_LED_PIN, locked ? LOW : HIGH);
  digitalWrite(RED_LED_PIN, locked ? HIGH : LOW);
}

void moveBolt(int angle) {
  // Attach only while moving; loop() detaches it after the settling time.
  boltServo.setPeriodHertz(50);
  boltServo.attach(SERVO_PIN, 500, 2400);
  boltServo.write(angle);
  servoSignalAttached = true;
  servoDetachAtMs = millis() + SERVO_SETTLE_MS;
}

void lockBolt() {
  if (locked) return;
  if (!doorShut()) {
    Serial.println("LOCK skipped: door is open");
    return;
  }
  moveBolt(LOCKED_ANGLE);
  locked = true;
  updateIndicators();
  sendEvent("locked");
  Serial.println("LOCKED");
}

void requestUnlock(const char *reason) {
  if (locked) {
    moveBolt(UNLOCKED_ANGLE);
    locked = false;
    updateIndicators();
    Serial.print("UNLOCKED: ");
    Serial.println(reason);
  }
}

void setModeFromText(const char *text) {
  if (strcmp(text, "home") == 0) currentMode = HOME;
  else if (strcmp(text, "night") == 0) currentMode = NIGHT;
  else if (strcmp(text, "away") == 0) currentMode = AWAY;
  else if (strcmp(text, "lock-away") == 0) currentMode = LOCK_AWAY;
  else if (strcmp(text, "alarm") == 0) currentMode = ALARM;
  else if (strcmp(text, "smoke") == 0) currentMode = SMOKE;
  else {
    Serial.println("ERR mode must be home, night, away, lock-away, alarm, or smoke");
    return;
  }

  Serial.print("MODE ");
  Serial.println(modeName(currentMode));
  if (currentMode == SMOKE) requestUnlock("smoke");
}

String currentStateJson() {
  String state = "{\"lock\":\"";
  state += locked ? "locked" : "unlocked";
  state += "\",\"door\":\"";
  state += doorShut() ? "shut" : "open";
  state += "\",\"room_occupied\":\"";
  state += roomOccupied ? "yes" : "no";
  state += "\",\"mode\":\"";
  state += modeName(currentMode);
  state += "\"}";
  return state;
}

void processSerial() {
  static String line;
  while (Serial.available()) {
    char c = static_cast<char>(Serial.read());
    if (c == '\n' || c == '\r') {
      line.trim();
      if (line.length()) onCommand(line.c_str());
      line = "";
    } else {
      line += c;
    }
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(PIR_PIN, INPUT);
  pinMode(DOOR_REED_PIN, INPUT_PULLUP);
  pinMode(RELEASE_BUTTON_PIN, INPUT_PULLUP);
  pinMode(GREEN_LED_PIN, OUTPUT);
  pinMode(RED_LED_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(BUZZER_PIN, LOW);

  bootMs = millis();
  lastMotionMs = bootMs;
  previousPir = digitalRead(PIR_PIN) == HIGH;
  previousButton = digitalRead(RELEASE_BUTTON_PIN) == HIGH;
  updateIndicators();

  Serial.println("Nivasa Sentinel prototype started");
  Serial.println("PIR warm-up: 30 seconds. Serial commands: mode away | mode smoke | unlock | state");
}

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

  if (servoSignalAttached && static_cast<long>(now - servoDetachAtMs) >= 0) {
    boltServo.detach();
    servoSignalAttached = false;
  }

  // The inside release path is checked every pass through loop and is never delayed by lock decisions.
  const bool buttonHigh = digitalRead(RELEASE_BUTTON_PIN) == HIGH;
  if (previousButton && !buttonHigh && now - lastButtonEdgeMs >= BUTTON_DEBOUNCE_MS) {
    lastButtonEdgeMs = now;
    requestUnlock("manual_release");
    sendEvent("manual_release");
  }
  previousButton = buttonHigh;

  const bool pirHigh = digitalRead(PIR_PIN) == HIGH;
  if (now - bootMs >= PIR_WARMUP_MS && pirHigh && !previousPir) {
    lastMotionMs = now;
    roomOccupied = true;
    Serial.println("PIR motion");
    if (locked) {
      requestUnlock("person_inside");
      sendEvent("person_inside");
    }
  }
  previousPir = pirHigh;

  if (!doorShut() && locked) {
    requestUnlock("door_opened");
  }

  if (currentMode == SMOKE) {
    requestUnlock("smoke");
  }

  const unsigned long quietMs = now - lastMotionMs;
  if (!locked && modePermitsLock() && doorShut() && now - bootMs >= PIR_WARMUP_MS && quietMs >= VACANCY_TIMEOUT_MS) {
    roomOccupied = false;
    lockBolt();
  }

  if (now - lastStatusLogMs >= STATUS_LOG_MS) {
    lastStatusLogMs = now;
    Serial.print("seconds_since_last_motion=");
    Serial.print(quietMs / 1000UL);
    Serial.print(" ");
    Serial.println(currentStateJson());
  }
}