GSM-реле для електрозамка й сигналізації на Arduino Nano і SIM800L

/*
  GSM-сигналізація і реле з керуванням тонами DTMF
  Arduino Nano + SIM800L

  © 2026 BoxForma (boxforma.com). Ліцензія MIT, повний текст — у LICENSE.txt:
  можна вільно копіювати, змінювати й поширювати, зберігши ці рядки.
  Надається «як є», без жодних гарантій; автори не відповідають за наслідки
  використання. Пристрій ви збираєте й підключаєте на власний ризик.

  Зателефонуйте на SIM-карту пристрою з номера з білого списку: він
  відповість, і далі команди набирають на клавіатурі телефону.

    # — поставити на охорону   * — зняти з охорони
    4 — увімкнути реле         2 — вимкнути реле
        (для електрозамка: 4 — відчинити, 2 — зачинити)

  Якщо під охороною відчинити двері, пристрій обдзвонить номери з
  ALARM_PHONES. Той, хто відповів, почує повідомлення про тривогу й має
  підтвердити його будь-якою клавішею (зірочка заодно знімає охорону). Без
  підтвердження дзвінок вважається неприйнятим і обдзвін триває: так його не
  зупинить голосова пошта чи автовідповідач.

  Голосові підказки — файли C:\User\N.amr у памʼяті SIM800L:
    2 — під охороною, 3 — охорону знято, 4 — тривога,
    5 — реле ввімкнено (двері відчинено), 6 — реле вимкнено (двері зачинено),
    7 — код прийнято, 8 — хибний код (лише якщо задано DTMF_PIN).
  Як записати й завантажити свої — див. статтю на boxforma.com/statti.
*/

#include <SoftwareSerial.h>
#include <EEPROM.h>
#include <avr/wdt.h>

// ============================ НАЛАШТУВАННЯ ============================

// Кому дзвонити під час тривоги, по черзі
// Замініть на свої номери у форматі +380XXXXXXXXX
const char* const ALARM_PHONES[] = {"+380XXXXXXXXX"};

// Хто може зателефонувати й керувати
const char* const ALLOWED_PHONES[] = {
  "+380XXXXXXXXX", "+380YYYYYYYYY",
};

// Номери порівнюються за останніми цифрами: +380501234567 і 0501234567 — один номер
const uint8_t MATCH_DIGITS = 9;

// PIN-код, який треба набрати після відповіді, перш ніж пристрій прийме
// команди. "" — без коду. Номер того, хто дзвонить, можна підробити, тож
// для реле на котлі чи воротах код краще задати (не довший за 7 цифр).
// Після правильного коду звучить 7.amr, після хибного — 8.amr.
const char DTMF_PIN[] = "";
const uint8_t PIN_MAX_TRIES = 3;  // стільки хибних кодів — і слухавку покладено

// Реле керує замком дверей, які стереже геркон: «4» (відчинити) заодно знімає
// охорону, інакше двері, відчинені власником, одразу підняли б тривогу.
// І навпаки, «#» заодно зачиняє замок, щоб охорону не поставили з відчиненим.
// false — реле й охорона незалежні (для котла, насоса, воріт).
const bool UNLOCK_DISARMS = true;

const uint8_t ALARM_ROUNDS = 3;                  // скільки разів обійти ALARM_PHONES, якщо ніхто не відповів
const unsigned long DIAL_PAUSE_MS = 5000;        // пауза між дзвінками обдзвону
const unsigned long DIAL_TIMEOUT_MS = 60000UL;   // стільки чекаємо відповіді на вихідний дзвінок
const unsigned long ALARM_ACK_MS = 40000UL;      // стільки чекаємо клавішу-підтвердження в тривожному дзвінку
const unsigned long ALARM_REPEAT_MS = 6000;      // як часто повторювати тривожне повідомлення, поки не підтвердили
const unsigned long CALL_MAX_MS = 180000UL;      // будь-яку розмову кладемо через 3 хвилини
const unsigned long DOOR_DEBOUNCE_MS = 300;      // стільки геркон має тримати стан, щоб йому повірити
const unsigned long MODEM_CHECK_MS = 30000UL;    // як часто перевіряти модем і мережу

// Модуль реле вмикається низьким рівнем: під час запуску на виводі HIGH,
// «4» дає LOW, «2» — HIGH. Якщо ваше реле насправді вмикається високим
// рівнем, поміняйте ці два рядки місцями. Електрозамок, відчинений без
// живлення (як SEVEN Z-727), підключають до контактів COM і NC: поки реле
// вимкнене, замок під напругою й двері зачинено.
#define RELAY_ON LOW
#define RELAY_OFF HIGH

// Сторожовий таймер перезапустить плату, якщо вона зависне. Вмикайте (1),
// лише якщо скетч завантажується з «Processor: ATmega328P», а не «(Old
// Bootloader)»: старий завантажувач клонів Nano з ним іде в нескінченне
// перезавантаження, і плату потім рятує лише програматор.
#define USE_WATCHDOG 0

// Рівень на D8, коли двері відчинено. Геркон розімкнутий, поки двері
// зачинено, і замикається, коли їх відчиняють.
//   LOW  — геркон між D8 і GND (як на схемі монтажу). D8 тягне до плюса
//          вбудований резистор, а для довгого дроту до дверей біля Nano ще
//          4,7 кОм від D8 до +5 В і 100 нФ від D8 до GND — проти хибних тривог;
//   HIGH — геркон між +5 В і D8, резистор 10 кОм тягне D8 до GND; вбудований
//          резистор тоді вимкнено, щоб не сперечався із зовнішнім.
#define DOOR_OPEN_LEVEL LOW

// Номери звукових файлів C:\User\N.amr: у кожної дії своя фраза
enum Sound : uint8_t {
  SND_ARMED = 2,
  SND_DISARMED = 3,
  SND_ALARM = 4,
  SND_RELAY_ON = 5,
  SND_RELAY_OFF = 6,
  SND_PIN_OK = 7,
  SND_PIN_BAD = 8,
};

// ============================== ВИВОДИ ==============================

// RX, TX. Логіка модуля — 2,8 В, а Nano на 5 В гарантовано бачить «одиницю» лише від 3,0 В:
//   TXD модема → D10 через кремнієвий діод 1N4148: анод — до D10, катод — до TXD.
//     SoftwareSerial сам вмикає на D10 вбудований підтягувальний резистор до +5 В,
//     а діод притискає D10 до напруги на TXD плюс своє падіння:
//     «одиниця» — близько 3,3 В, «нуль» — близько 0,5 В.
//     Діод Шотткі не годиться: у нього падіння замале, і до 3,0 В не дотягне;
//   D11 → RXD через дільник: D11 — 10 кОм — RXD — 10 кОм — GND, це половина:
//   2,5–2,6 В із 5,0–5,2 В (модулю треба від 2,1 до 3,1 В)
SoftwareSerial SIM800(10, 11);

#define PIN_RELAY 12      // не D13: ним під час скидання блимає завантажувач, і реле клацало б
#define PIN_DOOR 8        // геркон дверей, див. DOOR_OPEN_LEVEL
#define PIN_LED_DOOR A0   // під охороною й двері зачинено
#define PIN_LED_ARMED A1  // під охороною

// Комірка EEPROM: охорона зберігається, коли зникає живлення чи плата перезапускається
#define EE_ARMED 0

// ============================== СТАН ==============================

enum CallState : uint8_t { CALL_IDLE, CALL_INCOMING, CALL_DIALING, CALL_ACTIVE };
CallState callState = CALL_IDLE;
bool callIsAlarm = false;          // поточний дзвінок — наш тривожний
unsigned long callStartedAt = 0;
unsigned long lastRingAt = 0;
unsigned long lastCallEndedAt = 0;
bool callerChecked = false;        // номер вхідного вже перевірено

bool armed = false;
bool alarmLatched = false;   // тривога спрацювала й чекає, поки двері знову зачинять
bool alarmCalling = false;   // триває обдзвін: тривогу ще ніхто не підтвердив клавішею
uint8_t alarmAttempt = 0;
unsigned long alarmMsgAt = 0;  // коли востаннє звучало тривожне повідомлення

bool unlocked = false;       // PIN набрано (або він не потрібен)
char pinBuf[8];
uint8_t pinLen = 0;
uint8_t pinTries = 0;

// Розбір рядків модема лише ставить прапорці, а команди модему надсилає loop():
// так відповідь на одну команду не переплутається з іншою.
bool wantAnswer = false;
bool wantHangup = false;
bool wantAlarmMessage = false;
bool wantModemInit = false;
char keys[8];
uint8_t keyCount = 0;

bool registered = false;
bool baudFixed = false;      // у модемі збережено швидкість 9600, а не автопідбір
uint8_t modemFails = 0;
unsigned long lastModemCheck = 0;

bool doorOpen = false;
bool doorRaw = false;
unsigned long doorChangedAt = 0;

char line[96];
uint8_t lineLen = 0;

static_assert(sizeof(DTMF_PIN) <= sizeof(pinBuf), "DTMF_PIN не довший за 7 цифр");

// ============================== ЗАПУСК ==============================

void setup() {
  MCUSR = 0;
  wdt_disable();

  pinMode(PIN_LED_DOOR, OUTPUT);
  pinMode(PIN_LED_ARMED, OUTPUT);
  // під час запуску реле вимкнено: рівень задаємо до того, як вивід стане виходом,
  // інакше він на мить піде в LOW і реле клацне
  digitalWrite(PIN_RELAY, RELAY_OFF);
  pinMode(PIN_RELAY, OUTPUT);
  pinMode(PIN_DOOR, DOOR_OPEN_LEVEL == HIGH ? INPUT : INPUT_PULLUP);

  // охорона — така, як була до зникнення живлення
  armed = EEPROM.read(EE_ARMED) == 1;

  doorRaw = doorOpen = digitalRead(PIN_DOOR) == DOOR_OPEN_LEVEL;
  // двері відчинено вже під час увімкнення: тривога лише тоді, коли їх зачинять і знову відчинять
  alarmLatched = armed && doorOpen;

  Serial.begin(9600);
  SIM800.begin(9600);
  Serial.println(F("Старт"));

#if USE_WATCHDOG
  wdt_enable(WDTO_8S);
#endif

  initModem();
}

void loop() {
  feedWatchdog();

  while (readLine()) {
    logLine(line);
    handleLine(line);
  }

  doQueuedActions();
  serviceCall();
  serviceDoor();
  serviceAlarm();
  serviceModem();
  updateLeds();

  // команди модему з монітора порту, для налагодження
  while (Serial.available()) SIM800.write(Serial.read());
}

// ============================== МОДЕМ ==============================

void feedWatchdog() {
#if USE_WATCHDOG
  wdt_reset();
#endif
}

// Збирає рядок відповіді модема в line; true, коли надійшов цілий непорожній рядок
bool readLine() {
  while (SIM800.available()) {
    char c = SIM800.read();
    if (c == '\r') continue;
    if (c == '\n') {
      if (lineLen == 0) continue;
      line[lineLen] = '\0';
      lineLen = 0;
      return true;
    }
    if (lineLen < sizeof(line) - 1) line[lineLen++] = c;
  }
  return false;
}

void logLine(const char* s) {
  Serial.print(F("<< "));
  Serial.println(s);
}

// Надсилає команду й чекає OK чи ERROR; усе інше, що надійде, розбирається як завжди
bool sendAT(const char* cmd, unsigned long timeout = 2000) {
  Serial.print(F(">> "));
  Serial.println(cmd);
  SIM800.println(cmd);
  unsigned long start = millis();
  while (millis() - start < timeout) {
    feedWatchdog();
    if (!readLine()) continue;
    logLine(line);
    if (strcmp(line, "OK") == 0) return true;
    if (strcmp(line, "ERROR") == 0 || strncmp(line, "+CME ERROR", 10) == 0) return false;
    handleLine(line);
  }
  Serial.println(F("Немає відповіді"));
  return false;
}

bool initModem() {
  // модему потрібно кілька секунд після ввімкнення, а швидкість він підбирає за першими AT
  bool alive = false;
  for (uint8_t i = 0; i < 20 && !alive; i++) alive = sendAT("AT", 1000);
  if (!alive) {
    Serial.println(F("Модем не відповідає"));
    return false;
  }
  sendAT("ATE0");           // без луни команд: так простіше розбирати відповіді
  // Швидкість 9600 замість автопідбору. В автопідборі модем, перезапустившись
  // сам, мовчить (без RDY і Call Ready), доки не отримає AT, і скетч не
  // дізнався б, що налаштування нижче скинуто. Записуємо в памʼять модема
  // лише раз, коли там ще автопідбір.
  baudFixed = false;
  sendAT("AT+IPR?");
  if (!baudFixed && sendAT("AT+IPR=9600")) sendAT("AT&W");
  sendAT("AT+CLIP=1");      // номер вхідного дзвінка
  sendAT("AT+DDET=1,0,0");  // розпізнавання тонів DTMF
  sendAT("AT+COLP=1");      // ATD відповідає OK, лише коли абонент підняв слухавку
  sendAT("AT+CREG?");
  modemFails = 0;
  return true;
}

// Раз на пів хвилини, поки немає дзвінків: модем живий, SIM-карта в мережі,
// налаштування на місці
void serviceModem() {
  if (callState != CALL_IDLE || millis() - lastModemCheck < MODEM_CHECK_MS) return;
  lastModemCheck = millis();
  if (sendAT("AT+CREG?")) {
    modemFails = 0;
    if (!registered) Serial.println(F("Немає мережі"));
    // якщо модем непомітно перезапустився, тут буде 0, і handleLine попросить налаштувати його знову
    sendAT("AT+CLIP?");
  } else if (++modemFails >= 3) {
    wantModemInit = true;
  }
}

// Рядок від модема: лише змінює стан і ставить прапорці, команд не надсилає
void handleLine(const char* s) {
  if (strcmp(s, "RING") == 0) {
    lastRingAt = millis();
    if (callState == CALL_IDLE) {
      callState = CALL_INCOMING;
      callStartedAt = millis();
      callerChecked = false;
    }
    return;
  }
  if (strncmp(s, "+CLIP:", 6) == 0) {
    const char* p = s + 6;
    while (*p == ' ') p++;
    if (isdigit(*p)) {  // відповідь на AT+CLIP? («+CLIP: 1,1»), а не номер того, хто дзвонить
      if (*p != '1') {
        Serial.println(F("Налаштування модема скинуто"));
        wantModemInit = true;
      }
      return;
    }
    if (callState == CALL_INCOMING && !callerChecked) {
      callerChecked = true;
      char number[24];
      extractQuoted(s, number, sizeof(number));
      if (isAllowed(number)) {
        wantAnswer = true;
      } else {
        Serial.print(F("Чужий номер: "));
        Serial.println(number);
        wantHangup = true;
      }
    }
    return;
  }
  if (strncmp(s, "+DTMF:", 6) == 0) {
    const char* p = s + 6;
    while (*p == ' ') p++;
    if (*p && callState == CALL_ACTIVE && keyCount < sizeof(keys)) keys[keyCount++] = *p;
    return;
  }
  if (strncmp(s, "+CREG:", 6) == 0) {
    const char* comma = strchr(s, ',');
    int stat = comma ? atoi(comma + 1) : 0;
    registered = stat == 1 || stat == 5;  // 1 — домашня мережа, 5 — роумінг
    return;
  }
  if (strncmp(s, "+IPR:", 5) == 0) {
    baudFixed = atol(s + 5) == 9600;  // 0 — автопідбір
    return;
  }
  if (callState == CALL_DIALING) {
    if (strncmp(s, "+COLP:", 6) == 0 || strcmp(s, "OK") == 0) {  // абонент відповів
      callState = CALL_ACTIVE;
      callStartedAt = millis();
      unlocked = true;  // ми самі зателефонували власникові
      // обдзвін не завершуємо: могла відповісти голосова пошта, тож чекаємо клавішу
      wantAlarmMessage = true;
      return;
    }
    if (strcmp(s, "ERROR") == 0 || strncmp(s, "+CME ERROR", 10) == 0) {
      onCallEnded();
      return;
    }
  }
  if (strcmp(s, "NO CARRIER") == 0 || strcmp(s, "BUSY") == 0 ||
      strcmp(s, "NO ANSWER") == 0 || strcmp(s, "NO DIALTONE") == 0) {
    onCallEnded();
    return;
  }
  // модем перезапустився чи вимкнувся (наприклад, просіло живлення): налаштування зникли.
  // UNDER-VOLTAGE WARNNING (саме так, з помилкою) — лише попередження, модем працює
  // далі, і дзвінок, під час якого воно зазвичай і надходить, обривати не можна.
  if (strcmp(s, "RDY") == 0 || strcmp(s, "Call Ready") == 0 ||
      strcmp(s, "UNDER-VOLTAGE POWER DOWN") == 0 || strcmp(s, "NORMAL POWER DOWN") == 0) {
    wantModemInit = true;
  }
}

void doQueuedActions() {
  if (wantModemInit) {
    wantModemInit = false;
    if (callState != CALL_IDLE) onCallEnded();
    initModem();
  }
  if (wantHangup) {
    wantHangup = false;
    sendAT("ATH");
    onCallEnded();
  }
  if (wantAnswer) {
    wantAnswer = false;
    if (sendAT("ATA", 5000)) {
      callState = CALL_ACTIVE;
      callIsAlarm = false;
      callStartedAt = millis();
      unlocked = DTMF_PIN[0] == '\0';
      pinLen = 0;
      pinTries = 0;
    } else {
      onCallEnded();
    }
  }
  if (wantAlarmMessage) {
    wantAlarmMessage = false;
    alarmMsgAt = millis();
    playSound(SND_ALARM);
  }
  for (uint8_t i = 0; i < keyCount; i++) onKey(keys[i]);
  keyCount = 0;
}

void playSound(uint8_t n) {
  char cmd[48];
  snprintf(cmd, sizeof(cmd), "AT+CREC=4,\"C:\\User\\%d.amr\",1,100", (int)n);
  sendAT(cmd, 3000);
}

// ============================== ДЗВІНКИ ==============================

void onCallEnded() {
  // тривожний дзвінок скінчився, а клавішу так і не натиснули: не відповіли,
  // відповіла голосова пошта або поклали слухавку, не підтвердивши
  bool alarmNotAnswered = callIsAlarm && alarmCalling;
  callState = CALL_IDLE;
  callIsAlarm = false;
  unlocked = false;
  pinLen = 0;
  pinTries = 0;
  keyCount = 0;
  lastCallEndedAt = millis();
  if (alarmNotAnswered) alarmAttempt++;  // не додзвонилися — далі за списком
}

void serviceCall() {
  unsigned long now = millis();
  switch (callState) {
    case CALL_INCOMING:
      // той, хто дзвонив, скинув, не дочекавшись відповіді, або номер так і не надійшов
      if (now - lastRingAt > 15000UL) onCallEnded();
      else if (!callerChecked && now - callStartedAt > 10000UL) wantHangup = true;
      break;
    case CALL_DIALING:
      if (now - callStartedAt > DIAL_TIMEOUT_MS) wantHangup = true;
      break;
    case CALL_ACTIVE:
      if (now - callStartedAt > CALL_MAX_MS) {
        wantHangup = true;
      } else if (callIsAlarm && alarmCalling) {
        // тривогу ще не підтвердили: повторюємо повідомлення, а якщо клавіші
        // так і немає — кладемо слухавку й дзвонимо далі за списком
        if (now - callStartedAt > ALARM_ACK_MS) wantHangup = true;
        else if (now - alarmMsgAt > ALARM_REPEAT_MS) wantAlarmMessage = true;
      }
      break;
    default:
      break;
  }
}

void dial(const char* number) {
  char cmd[32];
  snprintf(cmd, sizeof(cmd), "ATD%s;", number);
  Serial.print(F(">> "));
  Serial.println(cmd);
  // відповіді не чекаємо: OK надійде, коли абонент підніме слухавку (AT+COLP=1)
  SIM800.println(cmd);
  callState = CALL_DIALING;
  callIsAlarm = true;
  callStartedAt = millis();
}

// Номер із білого списку: порівнюємо останні MATCH_DIGITS цифр
bool isAllowed(const char* number) {
  for (uint8_t i = 0; i < sizeof(ALLOWED_PHONES) / sizeof(ALLOWED_PHONES[0]); i++) {
    if (sameNumber(number, ALLOWED_PHONES[i])) return true;
  }
  return false;
}

bool sameNumber(const char* a, const char* b) {
  char ta[MATCH_DIGITS + 1], tb[MATCH_DIGITS + 1];
  return tailDigits(a, ta) && tailDigits(b, tb) && strcmp(ta, tb) == 0;
}

// Останні MATCH_DIGITS цифр номера; false, якщо цифр менше (прихований чи службовий номер)
bool tailDigits(const char* s, char* out) {
  char digits[24];
  uint8_t n = 0;
  for (; *s && n < sizeof(digits) - 1; s++) {
    if (isdigit(*s)) digits[n++] = *s;
  }
  if (n < MATCH_DIGITS) return false;
  memcpy(out, digits + n - MATCH_DIGITS, MATCH_DIGITS);
  out[MATCH_DIGITS] = '\0';
  return true;
}

// Перше значення в лапках: +CLIP: "+380...",145,... -> +380...
void extractQuoted(const char* s, char* out, uint8_t size) {
  out[0] = '\0';
  const char* a = strchr(s, '"');
  if (!a) return;
  a++;
  const char* b = strchr(a, '"');
  if (!b) return;
  uint8_t n = b - a;
  if (n > size - 1) n = size - 1;
  memcpy(out, a, n);
  out[n] = '\0';
}

// ============================== КОМАНДИ ==============================

void onKey(char k) {
  Serial.print(F("Клавіша: "));
  Serial.println(k);
  if (callIsAlarm && alarmCalling) {
    // будь-яка клавіша в тривожному дзвінку: людина почула, обдзвін завершено
    alarmCalling = false;
    Serial.println(F("Тривогу підтверджено"));
  }
  if (!unlocked) {
    enterPin(k);
    return;
  }
  switch (k) {
    case '#':
      if (UNLOCK_DISARMS) setRelay(false);  // охорона — лише з зачиненим замком
      setArmed(true);
      playSound(SND_ARMED);
      break;
    case '*': setArmed(false); playSound(SND_DISARMED); break;
    case '4':
      if (UNLOCK_DISARMS && armed) setArmed(false);
      setRelay(true);
      playSound(SND_RELAY_ON);
      break;
    case '2': setRelay(false); playSound(SND_RELAY_OFF); break;
    default: break;
  }
}

void enterPin(char k) {
  const uint8_t need = sizeof(DTMF_PIN) - 1;
  pinBuf[pinLen++] = k;
  if (pinLen < need) return;
  pinBuf[pinLen] = '\0';
  pinLen = 0;
  if (strcmp(pinBuf, DTMF_PIN) == 0) {
    unlocked = true;
    Serial.println(F("PIN правильний"));
    playSound(SND_PIN_OK);
    return;
  }
  playSound(SND_PIN_BAD);
  if (++pinTries >= PIN_MAX_TRIES) {
    Serial.println(F("PIN хибний, кладу слухавку"));
    wantHangup = true;
  } else {
    Serial.println(F("PIN хибний"));
  }
}

void setRelay(bool on) {
  digitalWrite(PIN_RELAY, on ? RELAY_ON : RELAY_OFF);
}

void setArmed(bool on) {
  armed = on;
  EEPROM.update(EE_ARMED, on ? 1 : 0);
  alarmCalling = false;
  // ставлять на охорону з відчиненими дверима: тривога, коли їх зачинять і знову відчинять
  alarmLatched = on && doorOpen;
  Serial.println(on ? F("Під охороною") : F("Охорону знято"));
}

// ============================== ОХОРОНА ==============================

void serviceDoor() {
  bool raw = digitalRead(PIN_DOOR) == DOOR_OPEN_LEVEL;
  if (raw != doorRaw) {
    doorRaw = raw;
    doorChangedAt = millis();
  }
  if (raw != doorOpen && millis() - doorChangedAt >= DOOR_DEBOUNCE_MS) {
    doorOpen = raw;
    Serial.println(doorOpen ? F("Двері відчинено") : F("Двері зачинено"));
  }
  if (armed && doorOpen && !alarmLatched) triggerAlarm();
  // обдзвін завершено й двері знову зачинено: наступне відчинення — нова тривога
  if (alarmLatched && !alarmCalling && !doorOpen) alarmLatched = false;
}

void triggerAlarm() {
  Serial.println(F("ТРИВОГА"));
  alarmLatched = true;
  alarmCalling = true;
  alarmAttempt = 0;
  lastCallEndedAt = millis() - DIAL_PAUSE_MS;  // перший дзвінок — одразу
}

void serviceAlarm() {
  if (!alarmCalling || callState != CALL_IDLE) return;
  if (millis() - lastCallEndedAt < DIAL_PAUSE_MS) return;
  const uint8_t count = sizeof(ALARM_PHONES) / sizeof(ALARM_PHONES[0]);
  if (alarmAttempt >= count * ALARM_ROUNDS) {
    Serial.println(F("Ніхто не відповів, обдзвін завершено"));
    alarmCalling = false;
    return;
  }
  dial(ALARM_PHONES[alarmAttempt % count]);
}

void updateLeds() {
  digitalWrite(PIN_LED_DOOR, armed && !doorOpen ? HIGH : LOW);
  digitalWrite(PIN_LED_ARMED, armed ? HIGH : LOW);
}

/*
  GSM-реле для електрозамка з керуванням тонами DTMF
  Arduino Nano + SIM800L

  © 2026 BoxForma (boxforma.com). Ліцензія MIT, повний текст — у LICENSE.txt:
  можна вільно копіювати, змінювати й поширювати, зберігши ці рядки.
  Надається «як є», без жодних гарантій; автори не відповідають за наслідки
  використання. Пристрій ви збираєте й підключаєте на власний ризик.

  Простий варіант скетча syhnalizatsiia.ino: лише замок, без охорони й геркона.

  Зателефонуйте на SIM-карту пристрою з номера з білого списку: він
  відповість, і далі команди набирають на клавіатурі телефону.

    4 — відчинити замок (реле ввімкнено)
    2 — зачинити замок (реле вимкнено)

  Голосові підказки — файли C:\User\N.amr у памʼяті SIM800L:
    5 — двері відчинено, 6 — двері зачинено,
    7 — код прийнято, 8 — хибний код (лише якщо задано DTMF_PIN).
  Як записати й завантажити свої — див. статтю на boxforma.com/statti.
*/

#include <SoftwareSerial.h>
#include <avr/wdt.h>

// ============================ НАЛАШТУВАННЯ ============================

// Хто може зателефонувати й керувати
// Замініть на свої номери у форматі +380XXXXXXXXX
const char* const ALLOWED_PHONES[] = {
  "+380XXXXXXXXX", "+380YYYYYYYYY",
};

// Номери порівнюються за останніми цифрами: +380501234567 і 0501234567 — один номер
const uint8_t MATCH_DIGITS = 9;

// PIN-код, який треба набрати після відповіді, перш ніж пристрій прийме
// команди. "" — без коду. Номер того, хто дзвонить, можна підробити, тож
// для замка вхідних дверей код краще задати (не довший за 7 цифр).
// Після правильного коду звучить 7.amr, після хибного — 8.amr.
const char DTMF_PIN[] = "";
const uint8_t PIN_MAX_TRIES = 3;  // стільки хибних кодів — і слухавку покладено

// Клавіші команд
const char KEY_OPEN = '4';
const char KEY_CLOSE = '2';

const unsigned long CALL_MAX_MS = 180000UL;      // будь-яку розмову кладемо через 3 хвилини
const unsigned long MODEM_CHECK_MS = 30000UL;    // як часто перевіряти модем і мережу

// Модуль реле вмикається низьким рівнем: під час запуску на виводі HIGH,
// «4» дає LOW, «2» — HIGH. Якщо ваше реле насправді вмикається високим
// рівнем, поміняйте ці два рядки місцями. Електрозамок, відчинений без
// живлення (як SEVEN Z-727), підключають до контактів COM і NC: поки реле
// вимкнене, замок під напругою й двері зачинено.
#define RELAY_ON LOW
#define RELAY_OFF HIGH

// Сторожовий таймер перезапустить плату, якщо вона зависне. Вмикайте (1),
// лише якщо скетч завантажується з «Processor: ATmega328P», а не «(Old
// Bootloader)»: старий завантажувач клонів Nano з ним іде в нескінченне
// перезавантаження, і плату потім рятує лише програматор.
#define USE_WATCHDOG 0

// Номери звукових файлів C:\User\N.amr: у кожної дії своя фраза
enum Sound : uint8_t {
  SND_OPENED = 5,
  SND_CLOSED = 6,
  SND_PIN_OK = 7,
  SND_PIN_BAD = 8,
};

// ============================== ВИВОДИ ==============================

// RX, TX. Логіка модуля — 2,8 В, а Nano на 5 В гарантовано бачить «одиницю» лише від 3,0 В:
//   TXD модема → D10 через кремнієвий діод 1N4148: анод — до D10, катод — до TXD.
//     SoftwareSerial сам вмикає на D10 вбудований підтягувальний резистор до +5 В,
//     а діод притискає D10 до напруги на TXD плюс своє падіння:
//     «одиниця» — близько 3,3 В, «нуль» — близько 0,5 В.
//     Діод Шотткі не годиться: у нього падіння замале, і до 3,0 В не дотягне;
//   D11 → RXD через дільник: D11 — 10 кОм — RXD — 10 кОм — GND, це половина:
//   2,5–2,6 В із 5,0–5,2 В (модулю треба від 2,1 до 3,1 В)
SoftwareSerial SIM800(10, 11);

#define PIN_RELAY 12      // не D13: ним під час скидання блимає завантажувач, і реле клацало б

// ============================== СТАН ==============================

enum CallState : uint8_t { CALL_IDLE, CALL_INCOMING, CALL_ACTIVE };
CallState callState = CALL_IDLE;
unsigned long callStartedAt = 0;
unsigned long lastRingAt = 0;
bool callerChecked = false;        // номер вхідного вже перевірено

bool unlocked = false;       // PIN набрано (або він не потрібен)
char pinBuf[8];
uint8_t pinLen = 0;
uint8_t pinTries = 0;

// Розбір рядків модема лише ставить прапорці, а команди модему надсилає loop():
// так відповідь на одну команду не переплутається з іншою.
bool wantAnswer = false;
bool wantHangup = false;
bool wantModemInit = false;
char keys[8];
uint8_t keyCount = 0;

bool registered = false;
bool modemReady = false;     // модем прийняв CLIP, DDET і DTAM
bool baudFixed = false;      // у модемі збережено швидкість 9600, а не автопідбір
uint8_t modemFails = 0;
unsigned long lastModemCheck = 0;

char line[96];
uint8_t lineLen = 0;

static_assert(sizeof(DTMF_PIN) <= sizeof(pinBuf), "DTMF_PIN не довший за 7 цифр");

// ============================== ЗАПУСК ==============================

void setup() {
  MCUSR = 0;
  wdt_disable();

  // під час запуску реле вимкнено, замок зачинено: рівень задаємо до того,
  // як вивід стане виходом, інакше він на мить піде в LOW і реле клацне
  digitalWrite(PIN_RELAY, RELAY_OFF);
  pinMode(PIN_RELAY, OUTPUT);

  Serial.begin(9600);
  SIM800.begin(9600);
  Serial.println(F("Старт"));

#if USE_WATCHDOG
  wdt_enable(WDTO_8S);
#endif

  initModem();
}

void loop() {
  feedWatchdog();

  while (readLine()) {
    logLine(line);
    handleLine(line);
  }

  doQueuedActions();
  serviceCall();
  serviceModem();

  // команди модему з монітора порту, для налагодження
  while (Serial.available()) SIM800.write(Serial.read());
}

// ============================== МОДЕМ ==============================

void feedWatchdog() {
#if USE_WATCHDOG
  wdt_reset();
#endif
}

// Збирає рядок відповіді модема в line; true, коли надійшов цілий непорожній рядок
bool readLine() {
  while (SIM800.available()) {
    char c = SIM800.read();
    if (c == '\r') continue;
    if (c == '\n') {
      if (lineLen == 0) continue;
      line[lineLen] = '\0';
      lineLen = 0;
      return true;
    }
    if (lineLen < sizeof(line) - 1) line[lineLen++] = c;
  }
  return false;
}

void logLine(const char* s) {
  Serial.print(F("<< "));
  Serial.println(s);
}

// Надсилає команду й чекає OK чи ERROR; усе інше, що надійде, розбирається як завжди
bool sendAT(const char* cmd, unsigned long timeout = 2000) {
  Serial.print(F(">> "));
  Serial.println(cmd);
  SIM800.println(cmd);
  unsigned long start = millis();
  while (millis() - start < timeout) {
    feedWatchdog();
    if (!readLine()) continue;
    logLine(line);
    if (strcmp(line, "OK") == 0) return true;
    if (strcmp(line, "ERROR") == 0 || strncmp(line, "+CME ERROR", 10) == 0) return false;
    handleLine(line);
  }
  Serial.println(F("Немає відповіді"));
  return false;
}

bool initModem() {
  // модему потрібно кілька секунд після ввімкнення, а швидкість він підбирає за першими AT
  bool alive = false;
  for (uint8_t i = 0; i < 20 && !alive; i++) alive = sendAT("AT", 1000);
  if (!alive) {
    Serial.println(F("Модем не відповідає"));
    modemReady = false;
    return false;
  }
  sendAT("ATE0");           // без луни команд: так простіше розбирати відповіді
  // Швидкість 9600 замість автопідбору. В автопідборі модем, перезапустившись
  // сам, мовчить (без RDY і Call Ready), доки не отримає AT, і скетч не
  // дізнався б, що налаштування нижче скинуто. Записуємо в памʼять модема
  // лише раз, коли там ще автопідбір.
  baudFixed = false;
  sendAT("AT+IPR?");
  if (!baudFixed && sendAT("AT+IPR=9600")) sendAT("AT&W");
  // Без цих трьох пристрій не впізнає номер, не почує клавіш чи підказки звучатимуть
  // не тому. Поки SIM-карта не готова, модем відкидає частину з них — тоді serviceModem
  // повторить налаштування, щойно модем зареєструється в мережі.
  bool ok = sendAT("AT+CLIP=1");       // номер вхідного дзвінка
  ok = sendAT("AT+DDET=1,0,0") && ok;  // розпізнавання тонів DTMF
  // підказки AT+CREC під час дзвінка — тому, хто дзвонить (1), а не в динамік модуля
  // (0 — типово). Не зберігається, тож задаємо щоразу
  ok = sendAT("AT+DTAM=1") && ok;
  modemReady = ok;
  sendAT("AT+CREG?");
  modemFails = 0;
  return true;
}

// Раз на пів хвилини, поки немає дзвінків: модем живий, SIM-карта в мережі,
// налаштування на місці
void serviceModem() {
  if (callState != CALL_IDLE || millis() - lastModemCheck < MODEM_CHECK_MS) return;
  lastModemCheck = millis();
  if (sendAT("AT+CREG?")) {
    modemFails = 0;
    if (!registered) Serial.println(F("Немає мережі"));
    if (registered && !modemReady) {
      Serial.println(F("Модем відкинув налаштування, повторюю"));
      wantModemInit = true;
      return;
    }
    // якщо модем непомітно перезапустився, тут буде 0 (AT+DTAM не зберігається),
    // і handleLine попросить налаштувати його знову. Не AT+CLIP?: та питає мережу,
    // і модем щоразу виходив би в ефір — тріск у колонках і зайві імпульси струму
    sendAT("AT+DTAM?");
  } else if (++modemFails >= 3) {
    wantModemInit = true;
  }
}

// Рядок від модема: лише змінює стан і ставить прапорці, команд не надсилає
void handleLine(const char* s) {
  if (strcmp(s, "RING") == 0) {
    lastRingAt = millis();
    if (callState == CALL_IDLE) {
      callState = CALL_INCOMING;
      callStartedAt = millis();
      callerChecked = false;
    }
    return;
  }
  if (strncmp(s, "+DTAM:", 6) == 0) {  // відповідь на AT+DTAM?
    if (atoi(s + 6) != 1) {
      Serial.println(F("Налаштування модема скинуто"));
      wantModemInit = true;
    }
    return;
  }
  if (strncmp(s, "+CLIP:", 6) == 0) {
    if (callState == CALL_INCOMING && !callerChecked) {
      callerChecked = true;
      char number[24];
      extractQuoted(s, number, sizeof(number));
      if (isAllowed(number)) {
        wantAnswer = true;
      } else {
        Serial.print(F("Чужий номер: "));
        Serial.println(number);
        wantHangup = true;
      }
    }
    return;
  }
  if (strncmp(s, "+DTMF:", 6) == 0) {
    const char* p = s + 6;
    while (*p == ' ') p++;
    if (*p && callState == CALL_ACTIVE && keyCount < sizeof(keys)) keys[keyCount++] = *p;
    return;
  }
  if (strncmp(s, "+CREG:", 6) == 0) {
    const char* comma = strchr(s, ',');
    int stat = comma ? atoi(comma + 1) : 0;
    registered = stat == 1 || stat == 5;  // 1 — домашня мережа, 5 — роумінг
    return;
  }
  if (strncmp(s, "+IPR:", 5) == 0) {
    baudFixed = atol(s + 5) == 9600;  // 0 — автопідбір
    return;
  }
  if (strcmp(s, "NO CARRIER") == 0 || strcmp(s, "BUSY") == 0 ||
      strcmp(s, "NO ANSWER") == 0 || strcmp(s, "NO DIALTONE") == 0) {
    onCallEnded();
    return;
  }
  // модем перезапустився чи вимкнувся (наприклад, просіло живлення): налаштування зникли.
  // UNDER-VOLTAGE WARNNING (саме так, з помилкою) — лише попередження, модем працює
  // далі, і дзвінок, під час якого воно зазвичай і надходить, обривати не можна.
  if (strcmp(s, "RDY") == 0 || strcmp(s, "Call Ready") == 0 ||
      strcmp(s, "UNDER-VOLTAGE POWER DOWN") == 0 || strcmp(s, "NORMAL POWER DOWN") == 0) {
    wantModemInit = true;
  }
}

void doQueuedActions() {
  if (wantModemInit) {
    wantModemInit = false;
    if (callState != CALL_IDLE) onCallEnded();
    initModem();
  }
  if (wantHangup) {
    wantHangup = false;
    sendAT("ATH");
    onCallEnded();
  }
  if (wantAnswer) {
    wantAnswer = false;
    if (sendAT("ATA", 5000)) {
      callState = CALL_ACTIVE;
      callStartedAt = millis();
      unlocked = DTMF_PIN[0] == '\0';
      pinLen = 0;
      pinTries = 0;
    } else {
      onCallEnded();
    }
  }
  for (uint8_t i = 0; i < keyCount; i++) onKey(keys[i]);
  keyCount = 0;
}

// AT+CREC=4,<файл>,<канал>,<гучність>: канал 0 — основний аудіоканал (1 — додатковий,
// у SIM800L не виведений); кому звучить у дзвінку, задає AT+DTAM в initModem
void playSound(uint8_t n) {
  char cmd[48];
  snprintf(cmd, sizeof(cmd), "AT+CREC=4,\"C:\\User\\%d.amr\",0,100", (int)n);
  if (sendAT(cmd, 3000)) return;
  // попередня фраза ще звучить (клавіші натиснули швидко одну за одною),
  // і модем нову не приймає: зупиняємо стару й пробуємо ще раз
  sendAT("AT+CREC=5");
  sendAT(cmd, 3000);
}

// ============================== ДЗВІНКИ ==============================

void onCallEnded() {
  callState = CALL_IDLE;
  unlocked = false;
  pinLen = 0;
  pinTries = 0;
  keyCount = 0;
}

void serviceCall() {
  unsigned long now = millis();
  switch (callState) {
    case CALL_INCOMING:
      // той, хто дзвонив, скинув, не дочекавшись відповіді, або номер так і не надійшов
      if (now - lastRingAt > 15000UL) onCallEnded();
      else if (!callerChecked && now - callStartedAt > 10000UL) wantHangup = true;
      break;
    case CALL_ACTIVE:
      if (now - callStartedAt > CALL_MAX_MS) wantHangup = true;
      break;
    default:
      break;
  }
}

// Номер із білого списку: порівнюємо останні MATCH_DIGITS цифр
bool isAllowed(const char* number) {
  for (uint8_t i = 0; i < sizeof(ALLOWED_PHONES) / sizeof(ALLOWED_PHONES[0]); i++) {
    if (sameNumber(number, ALLOWED_PHONES[i])) return true;
  }
  return false;
}

bool sameNumber(const char* a, const char* b) {
  char ta[MATCH_DIGITS + 1], tb[MATCH_DIGITS + 1];
  return tailDigits(a, ta) && tailDigits(b, tb) && strcmp(ta, tb) == 0;
}

// Останні MATCH_DIGITS цифр номера; false, якщо цифр менше (прихований чи службовий номер)
bool tailDigits(const char* s, char* out) {
  char digits[24];
  uint8_t n = 0;
  for (; *s && n < sizeof(digits) - 1; s++) {
    if (isdigit(*s)) digits[n++] = *s;
  }
  if (n < MATCH_DIGITS) return false;
  memcpy(out, digits + n - MATCH_DIGITS, MATCH_DIGITS);
  out[MATCH_DIGITS] = '\0';
  return true;
}

// Перше значення в лапках: +CLIP: "+380...",145,... -> +380...
void extractQuoted(const char* s, char* out, uint8_t size) {
  out[0] = '\0';
  const char* a = strchr(s, '"');
  if (!a) return;
  a++;
  const char* b = strchr(a, '"');
  if (!b) return;
  uint8_t n = b - a;
  if (n > size - 1) n = size - 1;
  memcpy(out, a, n);
  out[n] = '\0';
}

// ============================== КОМАНДИ ==============================

void onKey(char k) {
  Serial.print(F("Клавіша: "));
  Serial.println(k);
  if (!unlocked) {
    enterPin(k);
    return;
  }
  if (k == KEY_OPEN) {
    setRelay(true);
    playSound(SND_OPENED);
  } else if (k == KEY_CLOSE) {
    setRelay(false);
    playSound(SND_CLOSED);
  }
}

void enterPin(char k) {
  const uint8_t need = sizeof(DTMF_PIN) - 1;
  pinBuf[pinLen++] = k;
  if (pinLen < need) return;
  pinBuf[pinLen] = '\0';
  pinLen = 0;
  if (strcmp(pinBuf, DTMF_PIN) == 0) {
    unlocked = true;
    Serial.println(F("PIN правильний"));
    playSound(SND_PIN_OK);
    return;
  }
  playSound(SND_PIN_BAD);
  if (++pinTries >= PIN_MAX_TRIES) {
    Serial.println(F("PIN хибний, кладу слухавку"));
    wantHangup = true;
  } else {
    Serial.println(F("PIN хибний"));
  }
}

// Реле вмикається — NC розмикається, замок без живлення, двері відчинено
void setRelay(bool on) {
  digitalWrite(PIN_RELAY, on ? RELAY_ON : RELAY_OFF);
  Serial.println(on ? F("Замок відчинено") : F("Замок зачинено"));
}