sergon63tlt

/*
 * Программа управления нагрузкой с помощью RFID-RC522 13.56 мГц
 *  
 * - РАСПИНОВКА ----------------------------------------------------------------------------
 *             MFRC522      Arduino       Arduino   Arduino    Arduino          Arduino
 *             Reader/PCD   Uno           Mega      Nano v3    Leonardo/Micro   Pro Micro
 * Signal      Pin          Pin           Pin       Pin        Pin              Pin
 * -----------------------------------------------------------------------------------------
 * RST/Reset   RST          9             5         D9         RESET/ICSP-5     RST
 * SPI SS      SDA(SS)      10            53        D10        10               10
 * SPI MOSI    MOSI         11 / ICSP-4   51        D11        ICSP-4           16
 * SPI MISO    MISO         12 / ICSP-1   50        D12        ICSP-1           14
 * SPI SCK     SCK          13 / ICSP-3   52        D13        ICSP-3           15
 * -----------------------------------------------------------------------------------------
 *
 */

// Необходимые библиотеки
#include <avr/wdt.h>
#include <EEPROM.h>
#include <SPI.h>
#include <MFRC522.h>
#include <Bounce2.h>

// Необходимые пины
#define PIN_RESET         4        // RESER MEMORY
#define PIN_OPEN          2        // OPEN

#define PIN_RELAY_1       6        // RELAY CLOSE
#define PIN_RELAY_2       7        // RELAY OPEN
#define PIN_TONE          3        // TONE

#define PIN_RST           9        // RFID
#define PIN_SS            10       // RFID

#define PIN_MODE          8        // MODE

#define PIN_ALARM         14       // ALARM ON/OFF
#define PIN_ALARM_1M      15       // ALARM SIGNAL 1M
#define PIN_ALARM_LONG    16       // ALARM SIGNAL LONG TIME         

// Инициализация RFID ридера
MFRC522 mfrc522(PIN_SS, PIN_RST);

// Переменные необходимые для работы со списком ключей
byte **keys;
byte keys_count = EEPROM.read(0);

// Переменные необходимые для режима программирования
byte modeProgTime           = 5;     // Количество секунд удержания мастер ключа для входа\выхода в\из режим\а программирования
bool mode                   = false; // НЕ МЕНЯТЬ!
bool modeLock               = false; // НЕ МЕНЯТЬ!
byte modeClean              = 0;     // НЕ МЕНЯТЬ!
unsigned long modeTimer     = 0;     // НЕ МЕНЯТЬ!
unsigned long resetTimer    = 0;     // НЕ МЕНЯТЬ!

// Переменные для сигнализации
bool invert                 = true;  // Инвертировать выходы сигнализации (A1, A2)
bool alarm                  = false; // НЕ МЕНЯТЬ!
byte alarmCount             = 0;     // НЕ МЕНЯТЬ!
unsigned long alarmTimer    = 0;     // НЕ МЕНЯТЬ!
unsigned long alarmInterval = 0;     // НЕ МЕНЯТЬ!

// Управление замком
unsigned long openTimer     = 0;
bool lockStat               = false;

// Защита кнопок от дребезга
Bounce key_reset = Bounce();
Bounce key_open  = Bounce();
/*
  Якобы программный reset, но мы с Вами знаем, что это не так ;)
*/
void(* resetFunc) (void) = 0;
/*
  Функция звукового оповещения.
  Принимает параметры: количество звуковых сигналов, частота в герцах, продолжительность звука, пауза в милесекундах (не обязательно)
*/
void squeaker(byte count, unsigned int Hz, unsigned int duration, unsigned int sleep = 0) 
{
  for(int i=0; i<count; i++) {
    tone(PIN_TONE, Hz, duration);
    if(sleep > 0) delay(sleep);
  }
}
/*
  Функция читает EEPROM и составляет список активных ключей
  Первый байт в памяти содержит количество ключей
  UID ключа содержит 4 байта
  Общая память 1 + количество ключей * 4
  Максимум можно записать 255 ключей
*/
void keysRead() {
  // Выводим количество ключей
  Serial.print(F("KEYS COUNT: "));
  Serial.println(keys_count);
  int eb = 0;
  keys = (byte**)malloc(sizeof(byte*)*keys_count);
  // Читаем список ключей из EPROM
  Serial.println(F("------------------------------"));
  for(byte i=0; i<keys_count; i++) {
    Serial.print(F("KEY: "));Serial.print(i);Serial.print(" | ");
    keys[i] = (byte*)malloc(sizeof(byte)*4);
    for(byte b=0; b<4; b++) {
      keys[i][b] = EEPROM.read(++eb);
      Serial.print(keys[i][b]);
      if(b < 3) Serial.print(F(" "));
    }
    Serial.println();
  }
  Serial.println(F("------------------------------"));
  Serial.println();
}
/*
  Функция выводит UID ключа и, при необходимости, сопроводительное сообщение
*/
void uidPrint(String text = "") {
  Serial.print(F("UID: "));
  for(byte i=0; i<mfrc522.uid.size; i++) {
    Serial.print(mfrc522.uid.uidByte[i]);
    if(i < mfrc522.uid.size - 1) Serial.print(F(" "));
  }
  Serial.println();
  if(text.length() != 0) Serial.println(text + "\n");
}
/*
  Управление соленоидом с использованием пары реле.
  1 - закрытие, 0 - открытие
*/
void lock(bool lock) {
  digitalWrite(lock ? PIN_RELAY_1 : PIN_RELAY_2, LOW);
  delay(400);
  digitalWrite(lock ? PIN_RELAY_1 : PIN_RELAY_2, HIGH);
  lockStat = lock;
}
/*
  Инициализация программы
*/
void setup() {
  // Настраиваем сторожевой таймер
  wdt_disable();
  delay(8000); // <- ЗАКОМЕНТИРУЙТЕ ЭТУ СТРОКУ, ЕСЛИ ЗНАЕТЕ, ЧТО ТАКОЕ wdt_enable(WDTO_8S);
  wdt_enable(WDTO_8S);
    
  // Инициализация используемых пинов
  // Реле
  pinMode(PIN_RELAY_1, OUTPUT);
  digitalWrite(PIN_RELAY_1, HIGH);
  pinMode(PIN_RELAY_2, OUTPUT);
  digitalWrite(PIN_RELAY_2, HIGH);
  
  // Кнопка сброса памяти
  pinMode(PIN_RESET,INPUT_PULLUP);
  key_reset.attach(PIN_RESET);
  key_reset.interval(5);
  
  // Кнопка открытия двери
  pinMode(PIN_OPEN,INPUT_PULLUP);
  key_open.attach(PIN_OPEN);
  key_open.interval(5);   

  // Перемычка выбора режима работы (0 - автоматическое закрытие двери, 1 - закрытие двери по ключу)
  pinMode(PIN_MODE, INPUT);
  digitalWrite(PIN_MODE, HIGH);

  // Переменные для сигнализации
  pinMode(PIN_ALARM, INPUT_PULLUP);
  digitalWrite(PIN_ALARM, HIGH);

  pinMode(PIN_ALARM_1M, OUTPUT);
  digitalWrite(PIN_ALARM_1M, invert ? HIGH : LOW);

  pinMode(PIN_ALARM_LONG, OUTPUT);
  digitalWrite(PIN_ALARM_LONG, invert ? HIGH : LOW);
  
  // Инициализация консоли
  Serial.begin(9600);
  while (!Serial);
  // Приглашаем в гости
  Serial.println(F("iT4iT CLUB (C) 2015\nhttps://it4it.club\n"));
  
  // Инициализация ридера
  SPI.begin();
  mfrc522.PCD_Init();

  // Читаем количество ключей
  // Значение должно быть равным или больше 1 т.к первый ключ это мастер
  // В случае утери мастер ключа, мы можем сбросить EEPROM и прикрутить новый мастер ключ
  if(keys_count > 0 and keys_count < 255) {
    keysRead();
    lock(true);
  }
  else {
    keys_count = 0;
    Serial.println(F("The master key is not in memory. The first presentation to the key will be the master!\n"));
    lock(false);
  }
}
/*
  Лупаем, что происходит
*/
void loop() {
  // Сбрасываем сторожевой таймер микроконтроллера
  wdt_reset();

  if(alarmInterval > millis()+10000) alarmInterval = 0;
  if(alarmTimer > millis()+10000) alarmTimer = 0;
  if(resetTimer > millis()+10000) resetTimer = 0;
  if(openTimer > millis()+10000) openTimer = 0;
   
  // Изменение режима работы закрытия
  modeLock = !digitalRead(PIN_MODE);
  // Изменение режима работы сигнализации
  alarm    = !digitalRead(PIN_ALARM);
  // Очистка памяти
  key_reset.update();
  if(key_reset.read()) {
    if(resetTimer == 0) resetTimer = millis();
    else {
      if((millis()-resetTimer)/1000 > 5) {
        Serial.println(F("Launched memory cleaning"));
        squeaker(4, 1600, 300, 200);
        wdt_disable();
        for(int i=1; i<=EEPROM.length(); i++) {
          EEPROM.write(i, 0);
          if(!(i%50)) Serial.println(F("#")); else Serial.print(F("#"));
        }
        Serial.println(F("\nMemory cleaning is completed\n"));
        delay(1000);
        resetFunc();
      }
    }
  }
  else if(resetTimer != 0) resetTimer = 0;
  // Открытие двери с кнопки
  key_open.update();
  if(!key_open.read() and openTimer == 0) {
    if(keys_count > 0) {
      if(modeLock or (!modeLock and digitalRead(PIN_RELAY_2) == HIGH)) {
        openTimer = millis()/1000;
        lock(false);
        Serial.println(F("The door opened from the inside\n"));
        squeaker(5, 3200, 100, 300);
      }
    }
    else Serial.println(F("\nAttempting to open the lock from the inside.\nAccess denied. The master key is unknown. The castle is always open.\n"));
    delay(2000);
  }
  // Автоматическое отключение сигнализации
  if(alarmTimer != 0) {
    if(millis()/1000 - alarmTimer > 60) {
      alarmTimer = 0;
      digitalWrite(PIN_ALARM_1M, invert ? HIGH : LOW);
      Serial.println(F("Automatic shutdown of the first signaling channel.\n"));
    }
  }
  // Сброс счетчика подбора ключа
  if(alarmInterval != 0) {
    if(millis()/1000 - alarmInterval > 60) {
      alarmInterval = 0;
      alarmCount = 0;
      Serial.println(F("Time selection key expired.\n"));
    }
  }
  // Автоматическое закрытие двери
  if(openTimer != 0) {
    if(millis()/1000 - openTimer > 5) {
      openTimer = 0;
      if(modeLock) {
        lock(true);
        Serial.println(F("* closed lock\n"));
      }
    }
  }
  // Если ключ отсутствует или не читается, не выполняем дальнейший код
  if(!mfrc522.PICC_IsNewCardPresent()) {
    // Очистка таймера входа в режим программирования, в случае если ридер свободен
    if(modeTimer != 0) {
      if(++modeClean > 5) modeTimer = modeClean = 0;
    }
    return;
  }
  if(!mfrc522.PICC_ReadCardSerial()) return;
  // Останавливаем режим очистки
  modeClean = 0;
  
  // Кривое создание мастер ключа
  if(keys_count == 0) {
    for(byte i=0; i<4; i++) EEPROM.write(i+1, mfrc522.uid.uidByte[i]);
    EEPROM.write(0, keys_count = 1);
    uidPrint(F("master key is created"));
    digitalWrite(PIN_RELAY_2, HIGH);
    keysRead();
    squeaker(8, 1200, 100, 100);
    delay(2000);
    return;
  }
  
  // Проверка ключа на соответствие
  bool access = false;
  bool master = false;
  for(byte i=0; i<keys_count; i++) {
    for(byte b=0; b<4; b++) {
      if(keys[i][b] != mfrc522.uid.uidByte[b]) break;
      if(b == 3) {
        access = true;
        if(i == 0) master = true;
        // Останавливаем проверку костылем т.к "break 2;" не работает
        i = keys_count;
      }
    }
  }
  // ========================================================================================
  // Следующая секция имеет двойное назначение:
  //  1. В обычном режиме - контроль доступа
  //  2. В режиме программирования - запись ключа при его отсутствие в EEPROM
  // ========================================================================================
  // ОБЫЧНЫЙ РЕЖИМ
  // ========================================================================================
  if(access and !mode and !master) {
    // Доступ разрешен
    if(modeLock) {
      openTimer = millis()/1000;
      lock(false); 
    }
    else lock(!lockStat);
    if(alarm) {
      alarmInterval = alarmTimer = alarmCount = 0;
      if((invert and (!digitalRead(PIN_ALARM_1M) or !digitalRead(PIN_ALARM_LONG))) or (!invert and (digitalRead(PIN_ALARM_1M) or digitalRead(PIN_ALARM_LONG)))) {
        digitalWrite(PIN_ALARM_1M, invert ? HIGH : LOW);
        digitalWrite(PIN_ALARM_LONG, invert ? HIGH : LOW);
        Serial.println(F("Clear active alarms signaling\n"));
      }
    }
    uidPrint(F("access allow"));
    squeaker(2, 2200, 200, 200);
    delay(2000);
  }
  else if(!access and !mode and !master) {
    if(alarm) {
      if(alarmInterval == 0) alarmInterval = millis()/1000;
      if(++alarmCount >= 3) {
        if(alarmCount > 3) alarmCount = 3;
        alarmTimer = millis()/1000;
        digitalWrite(PIN_ALARM_1M, invert ? LOW : HIGH);
        digitalWrite(PIN_ALARM_LONG, invert ? LOW : HIGH);
        Serial.println(F("Attention! Attempt selection key! Activate both signaling channel!\n"));
      }
    }
    // Доступ запрещен
    uidPrint(F("access dany"));
    squeaker(1, 500, 1000);
    delay(2000);
  }
  // ========================================================================================
  // РЕЖИМ ПРОГРАММИРОВАНИЯ
  // ========================================================================================
  else if(access and mode and !master) {
    // Попытка записи существующего ключа
    uidPrint(F("error: key elrady exists in eeprom"));
    squeaker(2, 500, 300);
    delay(2000);
  }
  else if(!access and mode and !master) {
    // Записываем новый ключ
    // Максимум 255 ключей (с учетом первого байта) для 328 камня
    if(keys_count < 255) {
      for(byte i=0; i<4; i++) EEPROM.write(1 + keys_count*4 + i, mfrc522.uid.uidByte[i]);
      EEPROM.write(0, ++keys_count);
      uidPrint(F("add key in eeprom"));
      keysRead();
      squeaker(2, 2200, 200, 200);      
    }
    else {
      uidPrint(F("error: not enough memory for recording key!"));
      squeaker(2, 500, 300);
    }
    delay(2000);
  }
  // ========================================================================================
  // РАБОТА С МАСТЕР КЛЮЧОМ
  // ========================================================================================
  else if(access and master) {
    if(alarm) {
      alarmInterval = alarmTimer = alarmCount = 0;
      if((invert and (!digitalRead(PIN_ALARM_1M) or !digitalRead(PIN_ALARM_LONG))) or (!invert and (digitalRead(PIN_ALARM_1M) or digitalRead(PIN_ALARM_LONG)))) {
        digitalWrite(PIN_ALARM_1M, invert ? HIGH : LOW);
        digitalWrite(PIN_ALARM_LONG, invert ? HIGH : LOW);
        Serial.println(F("Clear active alarms signaling\n"));
      }
    }
    // Мастер ключ в обычном режиме
    if(modeTimer == 0) {
      modeTimer = millis()/1000;
      if(!mode) {
        if(modeLock) {
          openTimer = millis()/1000;
          lock(false); 
        }
        else lock(!lockStat);
        // Сигнал о наличии мастер ключа в обычном режиме
        uidPrint(F("MASTER KEY"));
        squeaker(2, 2200, 200, 200);
      }
    }
    else {
      if(millis()/1000 - modeTimer > modeProgTime and modeTimer != 0) {
        modeTimer = 0;
        if((mode = !mode) == true) {
          // Вход в режим программирования
          digitalWrite(PIN_RELAY_2, LOW);
          uidPrint(F("MASTER PROGRAMMING MODE ON"));
          squeaker(4, 1200, 200, 200);
        }
        else {
          // Выход из режима программирования
          digitalWrite(PIN_RELAY_2, HIGH);
          uidPrint(F("MASTER PROGRAMMING MODE OFF"));
          squeaker(4, 2200, 200, 200);
        }
      }
      delay(2000);
      // Дополнительные действия по таймеру modeProgTime
    }
    // Мастер ключ удерживается у ридера
  }
}