Offline Home Security Hub

#include <Arduino.h>
#include "thread_mesh_stubs.h"

// Nivasa Core Thread: local security controller.
// UART1 uses GPIO22 TX -> Core WiFi GPIO23 RX and GPIO23 RX <- Core WiFi GPIO22 TX.
constexpr int HOME_KEY_PIN = 10;
constexpr int AWAY_KEY_PIN = 11;
constexpr int NIGHT_KEY_PIN = 2; // GPIO14 is not exposed by the resolved WeAct-compatible pinout.
constexpr int PANIC_KEY_PIN = 3;
constexpr int GREEN_LED_PIN = 6;
constexpr int YELLOW_LED_PIN = 7;
constexpr int RED_LED_PIN = 19;
constexpr int BUZZER_PIN = 18;
constexpr int MQ_PIN = 0;
constexpr int DHT_PIN = 1; // Reserved for optional DHT-11 hardware.
constexpr int LINK_TX_PIN = 22;
constexpr int LINK_RX_PIN = 23;

constexpr unsigned long PANIC_HOLD_MS = 2000;
constexpr unsigned long MQ_WARMUP_MS = 120000;
constexpr int SMOKE_THRESHOLD = 2200; // ADC raw value after the divider; tune only after observing a clean-air baseline.
constexpr unsigned long LOCK_IDLE_MS = 30000; // Demo value requested.
constexpr unsigned long LOCK_COUNTDOWN_MS = 120000;
constexpr unsigned long HEARTBEAT_MS = 5000;

enum Mode { HOME, AWAY, NIGHT, ALARM, SMOKE, LOCK_AWAY };
Mode mode = HOME;
String uartLine;
String states[8];
String stateNames[8];
uint8_t stateCount = 0;
String outPeople[8];
uint8_t outCount = 0;
bool mainDoorLocked = false;
bool locking = false;
unsigned long bootMs;
unsigned long panicPressedAt = 0;
unsigned long lockingStartedAt = 0;
unsigned long lastMovementAt = 0;
unsigned long lastHeartbeatAt = 0;
unsigned long lastSmokeSampleAt = 0;
unsigned long lastBuzzerChangeAt = 0;
bool buzzerOn = false;
uint8_t alarmStep = 0;

const char *modeText(Mode value) {
  switch (value) {
    case HOME: return "HOME";
    case AWAY: return "AWAY";
    case NIGHT: return "NIGHT";
    case ALARM: return "ALARM";
    case SMOKE: return "SMOKE";
    case LOCK_AWAY: return "LOCK_AWAY";
  }
  return "HOME";
}

void sendWiFi(const String &line) {
  Serial1.println(line);
  Serial.println("UART> " + line);
}

void setBuzzer(bool on) {
  buzzerOn = on;
  digitalWrite(BUZZER_PIN, on ? HIGH : LOW);
}

void updateLights() {
  digitalWrite(GREEN_LED_PIN, (mode == HOME) ? HIGH : LOW);
  digitalWrite(YELLOW_LED_PIN, (mode == AWAY || mode == NIGHT || mode == LOCK_AWAY) ? HIGH : LOW);
  digitalWrite(RED_LED_PIN, (mode == ALARM || mode == SMOKE) ? HIGH : LOW);
}

void setMode(Mode next, bool report = true) {
  if (mode == SMOKE && next != SMOKE) return; // Smoke remains dominant until power reset in this prototype.
  if (mode == next) return;
  mode = next;
  locking = false;
  updateLights();
  broadcastMode(modeText(mode));
  if (report) sendWiFi("MODE " + String(modeText(mode)));
}

void rememberState(const String &piece, const String &text) {
  for (uint8_t i = 0; i < stateCount; ++i) {
    if (stateNames[i] == piece) { states[i] = text; return; }
  }
  if (stateCount < 8) {
    stateNames[stateCount] = piece;
    states[stateCount] = text;
    ++stateCount;
  }
}

void raiseAlarm(const String &piece, const String &reason) {
  if (mode == SMOKE) return;
  onEvent(piece, reason);
  setMode(ALARM);
  sendWiFi("ALARM " + piece);
}

void enterSmoke() {
  if (mode == SMOKE) return;
  mode = SMOKE;
  locking = false;
  updateLights();
  broadcastMode("SMOKE");
  sendCmd("all", "UNLOCK");
  sendWiFi("SMOKE");
  sendWiFi("MODE SMOKE");
}

void startLockCountdown() {
  if (locking || mode == SMOKE || mode == ALARM) return;
  locking = true;
  lockingStartedAt = millis();
  sendWiFi("LOCKING 120");
}

void finishLockAway() {
  locking = false;
  sendCmd("all", "LOCK");
  setMode(LOCK_AWAY);
}

bool everyoneOut() {
  return outCount > 0; // Prototype has no configured family roster; each /out is treated as the known roster for demonstration.
}

void handleCommand(String line) {
  line.trim();
  if (line.length() == 0) return;
  Serial.println("CMD< " + line);

  if (line.startsWith("event ")) {
    int first = line.indexOf(' ', 6);
    if (first > 0) {
      String piece = line.substring(6, first);
      String name = line.substring(first + 1);
      if (name == "forced" || name == "tamper") raiseAlarm(piece, name);
      else if (name == "movement") lastMovementAt = millis();
    }
    return;
  }
  if (line == "smoke") { enterSmoke(); return; }
  if (line.startsWith("MODE ")) {
    String value = line.substring(5); value.toUpperCase();
    if (value == "HOME") setMode(HOME);
    else if (value == "AWAY") setMode(AWAY);
    else if (value == "NIGHT") setMode(NIGHT);
    return;
  }
  if (line.startsWith("UNLOCK ")) {
    String piece = line.substring(7);
    sendCmd(piece, "UNLOCK");
    return;
  }
  if (line.startsWith("OUT ")) {
    String person = line.substring(4);
    bool known = false;
    for (uint8_t i = 0; i < outCount; ++i) if (outPeople[i] == person) known = true;
    if (!known && outCount < 8) outPeople[outCount++] = person;
    if (everyoneOut() && mainDoorLocked && millis() - lastMovementAt >= LOCK_IDLE_MS) startLockCountdown();
    return;
  }
  if (line.startsWith("HOME ")) {
    String person = line.substring(5);
    for (uint8_t i = 0; i < outCount; ++i) {
      if (outPeople[i] == person) { outPeople[i] = outPeople[--outCount]; break; }
    }
    if (locking) { locking = false; sendWiFi("STATE core LOCK_CANCELLED"); }
    setMode(HOME);
    return;
  }
  if (line.startsWith("STATE ")) {
    int space = line.indexOf(' ', 6);
    if (space > 0) {
      String piece = line.substring(6, space);
      String text = line.substring(space + 1);
      rememberState(piece, text);
      if (piece == "door" && text == "LOCKED") mainDoorLocked = true;
      if (text == "MOVEMENT") lastMovementAt = millis();
      sendWiFi(line);
    }
  }
}

void serviceUart() {
  while (Serial1.available()) {
    char c = static_cast<char>(Serial1.read());
    if (c == '\n') { handleCommand(uartLine); uartLine = ""; }
    else if (c != '\r' && uartLine.length() < 120) uartLine += c;
  }
  while (Serial.available()) {
    char c = static_cast<char>(Serial.read());
    if (c == '\n') { handleCommand(uartLine); uartLine = ""; }
    else if (c != '\r' && uartLine.length() < 120) uartLine += c;
  }
}

void serviceKeys() {
  if (digitalRead(HOME_KEY_PIN) == LOW) { setMode(HOME); delay(25); }
  if (digitalRead(AWAY_KEY_PIN) == LOW) { setMode(AWAY); delay(25); }
  if (digitalRead(NIGHT_KEY_PIN) == LOW) { setMode(NIGHT); delay(25); }
  if (digitalRead(PANIC_KEY_PIN) == LOW) {
    if (panicPressedAt == 0) panicPressedAt = millis();
    if (millis() - panicPressedAt >= PANIC_HOLD_MS) { raiseAlarm("core", "panic"); panicPressedAt = ULONG_MAX / 2; }
  } else {
    panicPressedAt = 0;
  }
}

void serviceSmoke() {
  if (millis() - bootMs < MQ_WARMUP_MS || millis() - lastSmokeSampleAt < 500) return;
  lastSmokeSampleAt = millis();
  int raw = analogRead(MQ_PIN);
  Serial.printf("MQ raw: %d\n", raw);
  if (raw >= SMOKE_THRESHOLD) enterSmoke();
}

void serviceLocking() {
  if (!locking) return;
  unsigned long elapsed = millis() - lockingStartedAt;
  if (elapsed >= LOCK_COUNTDOWN_MS) finishLockAway();
}

void serviceBuzzer() {
  unsigned long now = millis();
  if (mode == SMOKE) { setBuzzer(true); return; } // Long continuous alarm.
  if (mode != ALARM) { setBuzzer(false); return; }
  static const unsigned long pattern[] = {180, 80, 420, 220}; // Active buzzer: alternating pulse lengths, not pitch.
  if (now - lastBuzzerChangeAt >= pattern[alarmStep]) {
    lastBuzzerChangeAt = now;
    alarmStep = (alarmStep + 1) % 4;
    setBuzzer(!buzzerOn);
  }
}

void setup() {
  Serial.begin(115200);
  Serial1.begin(115200, SERIAL_8N1, LINK_RX_PIN, LINK_TX_PIN);
  pinMode(HOME_KEY_PIN, INPUT_PULLUP); pinMode(AWAY_KEY_PIN, INPUT_PULLUP);
  pinMode(NIGHT_KEY_PIN, INPUT_PULLUP); pinMode(PANIC_KEY_PIN, INPUT_PULLUP);
  pinMode(GREEN_LED_PIN, OUTPUT); pinMode(YELLOW_LED_PIN, OUTPUT); pinMode(RED_LED_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT); setBuzzer(false);
  analogReadResolution(12);
  bootMs = millis(); lastMovementAt = bootMs;
  updateLights();
  Serial.println("Nivasa Core Thread ready. Test with: event pebble forced");
  sendWiFi("MODE HOME");
}

void loop() {
  serviceUart();
  serviceKeys();
  serviceSmoke();
  serviceLocking();
  serviceBuzzer();
  if (millis() - lastHeartbeatAt >= HEARTBEAT_MS) { lastHeartbeatAt = millis(); sendWiFi("HEARTBEAT"); }
}