Automatic Window Lock Alarm

#include <Arduino.h>
#include <ESP32Servo.h>
#include "esp_sleep.h"
#include "driver/gpio.h"

// Thread/CoAP transport boundary: implemented as Serial stubs in src/thread_stubs.cpp.
void sendEvent(const char *name);
void onCommand(const char *cmd);
void onMode(const char *mode);
const char *getState();

constexpr int SERVO_PIN = 18;
constexpr int REED_PIN = 10;
constexpr int VIBRATION_PIN = 2;
constexpr int RELEASE_PIN = 11;
constexpr int GREEN_LED_PIN = 6;
constexpr int RED_LED_PIN = 7;

constexpr int SERVO_UNLOCK_ANGLE = 0;
constexpr int SERVO_LOCK_ANGLE = 90;
constexpr uint32_t SERVO_SETTLE_MS = 300;
constexpr uint32_t FORCED_WINDOW_MS = 2000;
constexpr uint32_t REMOTE_UNLOCK_RELOCK_MS = 15UL * 60UL * 1000UL; // Shorten for demonstrations.
constexpr uint32_t INPUT_DEBOUNCE_MS = 25;
constexpr uint64_t TIMER_WAKE_US = 1000000ULL;

// Change to LOW if the fitted SW-420 module asserts low when vibration is detected.
#define VIBRATION_ACTIVE_LEVEL HIGH
// Change to 1 for the sleep-current test. It removes the 1-second timer wake.
#define MEASURE_MODE 0

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

Servo boltServo;
Mode mode = HOME;
bool isLocked = false;
bool remoteUnlockPending = false;
bool previousWindowShut = false;
bool sawWindowOpenDuringRemoteUnlock = false;
uint32_t remoteUnlockAt = 0;
uint32_t firstVibrationAt = 0;
uint32_t lastReleaseAt = 0;
bool lastVibrationActive = false;
String serialLine;

bool windowIsShut() { return digitalRead(REED_PIN) == LOW; }
bool vibrationIsActive() { return digitalRead(VIBRATION_PIN) == VIBRATION_ACTIVE_LEVEL; }

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

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

void moveBolt(bool lock) {
  if (isLocked == lock) return;
  boltServo.setPeriodHertz(50);
  boltServo.attach(SERVO_PIN, 500, 2500);
  boltServo.write(lock ? SERVO_LOCK_ANGLE : SERVO_UNLOCK_ANGLE);
  delay(SERVO_SETTLE_MS);
  boltServo.detach(); // Removes drive pulses after each move, saving power and preventing buzz.
  isLocked = lock;
  updateIndicators();
  Serial.println(lock ? "BOLT locked" : "BOLT unlocked");
}

void lockNow(const char *eventName) {
  if (!windowIsShut()) {
    Serial.println("LOCK skipped: window is open");
    return;
  }
  moveBolt(true);
  if (eventName != nullptr) sendEvent(eventName);
}

void unlockNow(const char *eventName) {
  moveBolt(false);
  if (eventName != nullptr) sendEvent(eventName);
}

void applyModePolicy() {
  if (mode == SMOKE) {
    remoteUnlockPending = false;
    unlockNow("smoke_unlock");
  } else if ((mode == NIGHT || mode == AWAY || mode == ALARM) && windowIsShut()) {
    remoteUnlockPending = false;
    lockNow("mode_lock");
  }
}

void setModeFromText(String text) {
  text.toLowerCase();
  if (text == "home") mode = HOME;
  else if (text == "night") mode = NIGHT;
  else if (text == "away") mode = AWAY;
  else if (text == "alarm") mode = ALARM;
  else if (text == "smoke") mode = SMOKE;
  else {
    Serial.println("Unknown mode. Use home, night, away, alarm, or smoke.");
    return;
  }
  onMode(modeName(mode));
  Serial.print("MODE ");
  Serial.println(modeName(mode));
  applyModePolicy();
}

void processCommand(String text) {
  text.trim();
  text.toLowerCase();
  if (text == "unlock") {
    onCommand("unlock");
    remoteUnlockPending = true;
    sawWindowOpenDuringRemoteUnlock = !windowIsShut();
    remoteUnlockAt = millis();
    unlockNow("remote_unlock");
  } else {
    Serial.println("Unknown command. Use: cmd unlock");
  }
}

void serviceSerial() {
  while (Serial.available()) {
    char c = static_cast<char>(Serial.read());
    if (c == '\n' || c == '\r') {
      if (serialLine.length()) {
        if (serialLine.startsWith("mode ")) setModeFromText(serialLine.substring(5));
        else if (serialLine.startsWith("cmd ")) processCommand(serialLine.substring(4));
        else if (serialLine == "state") {
          Serial.printf("STATE mode=%s locked=%d windowShut=%d transport=%s\n", modeName(mode), isLocked, windowIsShut(), getState());
        } else Serial.println("Use: mode home|night|away|alarm|smoke, cmd unlock, state");
        serialLine = "";
      }
    } else if (serialLine.length() < 64) serialLine += c;
  }
}

void processInputs() {
  const uint32_t now = millis();
  const bool shut = windowIsShut();
  const bool vibration = vibrationIsActive();

  if (digitalRead(RELEASE_PIN) == LOW && now - lastReleaseAt >= INPUT_DEBOUNCE_MS) {
    lastReleaseAt = now;
    remoteUnlockPending = false;
    unlockNow("manual_release");
  }

  if (remoteUnlockPending) {
    if (!shut) sawWindowOpenDuringRemoteUnlock = true;
    if (sawWindowOpenDuringRemoteUnlock && shut) {
      remoteUnlockPending = false;
      lockNow("remote_relock_window_shut");
    } else if (now - remoteUnlockAt >= REMOTE_UNLOCK_RELOCK_MS) {
      remoteUnlockPending = false;
      lockNow("remote_relock_timeout");
    }
  }

  if (vibration && !lastVibrationActive) {
    if (firstVibrationAt != 0 && now - firstVibrationAt <= FORCED_WINDOW_MS) {
      firstVibrationAt = 0;
      lockNow("forced");
    } else {
      firstVibrationAt = now;
    }
  }
  if (firstVibrationAt != 0 && now - firstVibrationAt > FORCED_WINDOW_MS) firstVibrationAt = 0;

  previousWindowShut = shut;
  lastVibrationActive = vibration;
}

void configureLightSleepWakeSources() {
  gpio_wakeup_enable(static_cast<gpio_num_t>(REED_PIN), GPIO_INTR_LOW_LEVEL);
  gpio_wakeup_enable(static_cast<gpio_num_t>(RELEASE_PIN), GPIO_INTR_LOW_LEVEL);
  gpio_wakeup_enable(static_cast<gpio_num_t>(VIBRATION_PIN),
                      VIBRATION_ACTIVE_LEVEL == HIGH ? GPIO_INTR_HIGH_LEVEL : GPIO_INTR_LOW_LEVEL);
  esp_sleep_enable_gpio_wakeup();
#if !MEASURE_MODE
  esp_sleep_enable_timer_wakeup(TIMER_WAKE_US);
#endif
}

void enterLightSleep() {
  configureLightSleepWakeSources();
  esp_light_sleep_start();
}

void setup() {
  Serial.begin(115200);
  delay(100);
  pinMode(REED_PIN, INPUT_PULLUP);
  pinMode(RELEASE_PIN, INPUT_PULLUP);
  pinMode(VIBRATION_PIN, INPUT);
  pinMode(GREEN_LED_PIN, OUTPUT);
  pinMode(RED_LED_PIN, OUTPUT);
  previousWindowShut = windowIsShut();
  updateIndicators();
  Serial.println("Nivasa Pebble ready. Commands: mode night | cmd unlock | state");
  Serial.printf("SW-420 active level: %s; measure mode: %d\n", VIBRATION_ACTIVE_LEVEL == HIGH ? "HIGH" : "LOW", MEASURE_MODE);
  applyModePolicy();
}

void loop() {
  serviceSerial();
  processInputs();
  if (!Serial.available()) enterLightSleep();
}