#include <EEPROM.h>

// Цифровые и аналоговые входы/выходы
#define BEEPER  5  // Пищалка
#define BUTTON  2  // Кнопка
#define LED_RED 6  // Светодиод активированного замка
#define LED_GREEN  3 // Светодиод деактивированного замка
#define LOCK_POWER  7 // Затвор полевого транзистора, управляющего цепью питания замка
#define LOCK_OPEN  9 // Вход транзисторного ключа, открывающего замок
#define NO_PIN  8 // Датчик открытой двери

// Константы событий для основного цикла loop()
#define EVENT_NONE  0  // Ничего не происходит
#define EVENT_BUTTON  1 // Нажата кнопка
#define EVENT_ACTIVATE  2 // Получена команда активации замка
#define EVENT_DEACTIVATE  3 // Получена команда деактивации замка
#define EVENT_OPEN  4 // Получена команда открыть замок
#define EVENT_SERIAL  99 // Получена строка через UART

char deviceID[12];

int eventButton = EVENT_NONE;
int lockActive = LOW;

String inputString = "";

void pressButton(){ // Обработчик прерывания нажатия кнопки
  eventButton = EVENT_BUTTON;
}

void setup(){
  pinMode(BEEPER, OUTPUT);
  pinMode(LED_RED, OUTPUT);
  pinMode(LED_GREEN, OUTPUT);
  pinMode(LOCK_POWER, OUTPUT);
  pinMode(LOCK_OPEN, OUTPUT);
  pinMode(BUTTON, INPUT);
  pinMode(NO_PIN, INPUT);
  Serial.begin(9600);


  inputString.reserve(30);
  attachInterrupt(0, pressButton, RISING);
 
  eventButton = EVENT_NONE;
  lockActive = EEPROM.read(0); // Считываем настройку активации замка "по умолчанию"
 
  digitalWrite(LOCK_POWER, lockActive);
  digitalWrite(LED_RED, lockActive);
  digitalWrite(LED_GREEN, !lockActive);
}

int commandProcessor(String incomingString){
  incomingString.trim();
  incomingString.toUpperCase();
  if (incomingString == "OPEN") {
    return EVENT_OPEN;
  }
  else if (incomingString == "ACTIVATE") {
    return EVENT_ACTIVATE;
  }
  else if (incomingString == "DEACTIVATE") {
    return EVENT_DEACTIVATE;
  }
  else {
    return EVENT_NONE;
  }
}

void loop(){

  // Предварительный обработчик событий от интерфейсов

  if (eventButton == EVENT_SERIAL){
    // сначала обработка только команд от Serial
    inputString.trim();
    inputString.toUpperCase();
    if (inputString == "STATUS") { //Запрос статуса замка
      if (lockActive == HIGH) {
        Serial.println("ACTIVE");
      }
      else {
        Serial.println("NOTACTIVE");
      }
    }
    else if (inputString == "DOOR") { // Запрос состояния двери по датчику
      if (digitalRead(NO_PIN) == HIGH) {
        Serial.println("CLOSE");
      }
      else {
        Serial.println("OPEN");
      }
    }
    else if (inputString == "NORMAL OPEN") { // Настройка начального состояния замка
      if (EEPROM.read(0) != LOW) {
        EEPROM.write(0, LOW);
        delay(10);
      }
    }
    else if (inputString == "NORMAL CLOSE") {
      if (EEPROM.read(0) != HIGH) {
        EEPROM.write(0, HIGH);
        delay(10);
      }
    }

    // Затем общие команды
    eventButton = commandProcessor(inputString);

    inputString = "";
  }

  // Основной обработчик событий

  if (eventButton == EVENT_BUTTON) {
    eventButton = EVENT_OPEN; // что делать при нажатой кнопке решаем здесь и идем дальше
  }
  else if (eventButton == EVENT_ACTIVATE) {
    lockActive = HIGH;
    digitalWrite(LOCK_POWER, HIGH);
    digitalWrite(LED_RED, HIGH);
    digitalWrite(LED_GREEN, LOW);
    tone(BEEPER, 700, 50);
  }
  else if (eventButton == EVENT_DEACTIVATE) {
    lockActive = LOW;
    digitalWrite(LOCK_POWER, LOW);
    digitalWrite(LED_RED, LOW);
    digitalWrite(LED_GREEN, HIGH);
    tone(BEEPER, 700, 50);
  }  
  else if (eventButton == EVENT_OPEN) {
    digitalWrite(LOCK_OPEN, HIGH);
    if (lockActive == HIGH) {
      tone(BEEPER, 750, 50);
    }
    delay(10);
    digitalWrite(LOCK_OPEN, LOW);
    eventButton = EVENT_NONE;
  }

  eventButton = EVENT_NONE;
}

void serialEvent() {
  while (Serial.available()) {
    char inChar = (char)Serial.read();
    inputString += inChar;
    if (inChar == '\n') {
      eventButton = EVENT_SERIAL;
    }
  }
}

from twisted.protocols import basic
from twisted.internet import reactor
from twisted.internet.protocol import ServerFactory 
from twisted.protocols.basic import LineOnlyReceiver
from twisted.application import service, internet
import hashlib 
import threading
import MySQLdb
from MySQLdb import Error
import random


class ChatProtocol(LineOnlyReceiver): 

    name = ""
    isKey = False
    authKey = ""
    
    def getSecret(self,isKey):
        if not self.factory.conn:
            self.factory.mySQLdbConnect()
        if isKey:
            reqTable = "lockkeys"
        else:
            reqTable = "locks"
        try:
            cursor = self.factory.conn.cursor()
            cursor.execute("SELECT `secret` FROM `" + reqTable + "` WHERE id='" + self.getName() + "'")
            rows = cursor.fetchall()
                        
            if cursor.rowcount > 0:
                cursor.close()
                return rows[0][0].strip() 
            else:
                cursor.close()
                return None
            
        except Error as e:
            print(e)
            return None

        finally:
            cursor.close()
            
    def validKey(self,lockID):
        if not self.isKey:
            return False
        if self.transport.getPeer().host == "127.0.0.1":
            return True
        if not self.factory.conn:
            self.factory.mySQLdbConnect()
        try:
            cursor = self.factory.conn.cursor()
            cursor.execute("SELECT `rights` FROM `hosts` WHERE (`lock`='" + lockID + "') AND (`lockkey`='"+ self.getName() + "')")
            rows = cursor.fetchall()
            
            if cursor.rowcount > 0:
                cursor.close()
                return rows[0][0]
            else:
                cursor.close()
                return False
        except Error as e:
            print(e)
            return False

        finally:
            cursor.close()            

    def getName(self): 
        if self.name!="": 
            return self.name 
        return self.transport.getPeer().host 

    def connectionMade(self): 
        print "New connection from "+self.getName()
        if self.transport.getPeer().host == "127.0.0.1":
            self.isKey = True 
        d = {self.getName() : self}
        self.factory.clients.update(d)

    def connectionLost(self, reason): 
        print "Lost connection from "+self.getName() 
        self.factory.clients.pop(self.getName()) 
        self.factory.sendMessageToAllclients(self.getName()+" has disconnected.") 
        

    def lineReceived(self, line): 
        #print self.getName()+" said "+line
        #if line[:3] == "/OK"
        if line[:5]=="/KEY:":
            str1 = '123456789'
            str2 = 'qwertyuiopasdfghjklzxcvbnm'
            str3 = str2.upper()
            str4 = str1+str2+str3
            ls = list(str4)
            random.shuffle(ls)
            self.authKey = ''.join([random.choice(ls) for x in range(12)])
            self.sendLine("ANSW:"+self.authKey)
            oldName = self.getName() 
            self.name = line[5:].strip() 
            self.factory.clients.pop(oldName)
            self.factory.clients.update({self.getName() : self})
            self.isKey = False
            print oldName+" has requested to be Key ID:"+self.getName()
        elif line=="/EXIT": 
            self.transport.loseConnection()
        elif line[:6]=="/ANSW:":
            secret = self.getSecret(True)
            if secret:
                m = hashlib.md5()
                m.update(self.authKey + secret)
                if m.hexdigest() == line[6:].strip():
                    self.isKey = True
                    print self.getName() + " was authorisated as Key"
                else:
                    self.sendLine("Authorisation fail")
                    self.transport.loseConnection()             
            else:
                self.sendLine("Authorisation fail")
                self.transport.loseConnection()


                
        if self.isKey: #Only from keys
            
            if line[:6]=="/OPEN:":
                if self.validKey(line[6:]):
                    adresat = self.factory.clients.get(line[6:],None)
                    if adresat:
                        adresat.sendLine("OPEN:" + self.getName() +  "\r\n")
                    else:
                        self.sendLine("DeviceID="+ line[6:] + " is not online\r\n")
            elif line[:10]=="/ACTIVATE:":
                if self.validKey(line[10:]):
                    adresat = self.factory.clients.get(line[10:],None)
                    if adresat:
                        adresat.sendLine("ACTIVATE:" + self.getName() +  "\r\n")
                    else:
                        self.sendLine("DeviceID="+ line[10:] + " is not online\r\n")
            elif line[:12]=="/DEACTIVATE:":
                if self.validKey(line[12:]):
                    adresat = self.factory.clients.get(line[12:],None)
                    if adresat:
                        adresat.sendLine("DEACTIVATE:" + self.getName() +  "\r\n")
                    else:
                        self.sendLine("DeviceID="+ line[12:] + " is not online\r\n")           
        else: # Only from locks
            if line[:4]=="/ID:": 
                oldName = self.getName() 
                self.name = line[4:].strip() 
                self.factory.clients.pop(oldName)
                self.factory.clients.update({self.getName() : self})
                print oldName+" changed name to "+self.getName() 
            elif line[:4]=="/RE:":
                secret = self.getSecret(self.isKey)
                if secret == None:
                    self.sendLine("Your Device ID is not register in Command Server")
                    self.transport.loseConnection()
                else:
                    requestCode = line[4:]
                    m = hashlib.md5()
                    m.update(requestCode + secret)
                    self.sendLine("AUTH:" + m.hexdigest() + "\r\n")
            elif line[:4]=="/OK:":
                adresat = self.factory.clients.get(line[4:],None)
                if adresat:
                    adresat.sendLine("OK:" + self.getName())
            else: 
                self.factory.sendMessageToAllclients(self.getName()+" says "+line)
    
    def sendLine(self, line): 
        self.transport.write(line+"\r\n") 
        
        

class ChatProtocolFactory(ServerFactory): 

    protocol = ChatProtocol 
    clients = {} 
    
    def mySQLdbConnect(self):
        try:
            self.conn = MySQLdb.connect(host='127.0.0.1',user='guestlock',passwd='passw',db='guestlock')
        except Error as e:
            print(e)
            return False
        else:
            return True
            
    def __init__(self):
        print "Starting server..." 
        self.clients = {}
        if self.mySQLdbConnect():
            print "Server ready!"
        else:
            print "Data base error. Server doesn't work correctly."
        

    def sendMessageToAllclients(self, mesg): 
        for client in self.clients.values():
            client.sendLine(mesg) 


factory = ChatProtocolFactory()
application = service.Application("CommandServer")
internet.TCPServer(12345, factory).setServiceParent(application)

#include <EEPROM.h>
#include <SPI.h>
#include <Ethernet.h>
#include <MD5.h>

// Цифровые и аналоговые входы/выходы
#define BEEPER  5  // Пищалка
#define BUTTON  2  // Кнопка
#define LOCK_POWER 7  // Замок активирован 
#define LED_DEACTIVE  6 // Замок деактивирован  
#define LOCK_OPEN  9  // Открытие замка
#define LED_ETHERNET  8 // Индикатор подключения к серверу
#define NO_PIN  A0  //Датчик NO замка АНАЛОГОВЫЙ


// Константы событий для основного цикла loop()
#define EVENT_NONE  0
#define EVENT_ETHERNET 98
#define EVENT_SERIAL  99


#define RECONNECT_TIME  5000 // Интервал попыток подключения к серверу, мс


char deviceID[12];
byte mac[] = { 
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
EthernetClient client;
IPAddress server(192,168,1,7);
long port = 12345;

unsigned long lastConnectionTime = 0;       
unsigned long disconnectTime = 0;
boolean lastConnected = false;                

volatile int eventButton = EVENT_NONE;  // Индикатор события для основного цикла loop()
int lockActive = LOW;

String inputString = "";        
String ethernetString = "";

long requestCode;

void pressButton(){ // Обработчик прерывания нажатия кнопки
  lockOpen();
}

void majorBeep() {
  tone(BEEPER, 750, 50);
}

void minorBeep() {
  tone(BEEPER, 300, 100);
}


void lockActivate(boolean lockState){
  digitalWrite(LOCK_POWER, lockState);
  digitalWrite(LED_DEACTIVE, !lockState);
  lockActive = lockState;
  majorBeep();
}

void lockOpen() {
  digitalWrite(LOCK_OPEN, HIGH);
  delay(50);
  digitalWrite(LOCK_OPEN, LOW);
  majorBeep();
}

void lockSetDefaultState(int state){
  if (EEPROM.read(0) != state) { 
    EEPROM.write(0, state); 
    delay(10);
  }
  majorBeep();
}

boolean serverAuthRequest() {
  if (!client.connected()){
    return false;
  }
  client.print("/ID:");
  client.println(deviceID);
  delay(1000);
  char rCode[6];
  ultoa(random(99999),rCode,16);

  unsigned char* hash=MD5::make_hash(rCode);
  char *md5str = MD5::make_digest(hash, 16);

  client.print("/RE:");
  client.println(md5str);

  String answerHash = md5str;
  answerHash.trim();
  for (int i=0; EEPROM.read(50+i) != 0; i++){
    answerHash += char(EEPROM.read(50+i));
  } 

  char *aCode = (char*)malloc(answerHash.length()+1);
  ;
  answerHash.toCharArray(aCode,answerHash.length()+1);

  hash=MD5::make_hash(aCode);
  md5str = MD5::make_digest(hash, 16);

  answerHash = md5str;

  free(md5str);
  free(aCode);

  unsigned long mm = millis();
  ethernetString = "";
  while (millis()-mm < RECONNECT_TIME) {
    if (client.available()) {
      char inChar = client.read();
      ethernetString += inChar;
      if (inChar == '\n') {
        ethernetString.trim();
        if (ethernetString.startsWith("AUTH:")) {

          ethernetString = ethernetString.substring(5);
          break;
        } 
        else {
          ethernetString = "";
        }
      } 
    }
  }
  return (ethernetString == answerHash);
}


boolean serverConnect() {
  if (client.connect(server, port)) {
    lastConnectionTime = millis();
    if (serverAuthRequest()) {
      Serial.println("Server autenfication sucsesseful");
      majorBeep();
      digitalWrite(LED_ETHERNET, HIGH);
      ethernetString = "";
      return true;
    } 
    else{
      Serial.println("Server autenfication fail");
      minorBeep();
      digitalWrite(LED_ETHERNET, LOW);
      ethernetString = "";
      client.stop();
      return false;
    }
  }   
  else {
    Serial.println("Connection fail");
    client.stop();
    digitalWrite(LED_ETHERNET, LOW);
    disconnectTime = millis();
    ethernetString = "";
    return false;
  }
}


void setup(){
  pinMode(BEEPER, OUTPUT);
  pinMode(LOCK_OPEN, OUTPUT);
  pinMode(BUTTON, INPUT);
  pinMode(LOCK_POWER, OUTPUT);
  pinMode(LED_DEACTIVE, OUTPUT);
  pinMode(LED_ETHERNET, OUTPUT);


  lockActivate(EEPROM.read(0));

  Serial.begin(9600);

  randomSeed(analogRead(A1));

  for (int i=1; i<12; i++) {
    deviceID[i-1] = EEPROM.read(i);
  }

  Serial.print("Device ID: "); 
  Serial.println(deviceID); 

  delay(1000);
  // start the Ethernet connection using a DNS server:
  Ethernet.begin(mac);

  Serial.print("My IP address: ");
  Serial.println(Ethernet.localIP());

  if (!serverConnect()) {
    disconnectTime = millis();
  }

  inputString.reserve(30);
  attachInterrupt(0, pressButton, RISING);
  eventButton = EVENT_NONE;
}

boolean commandProcessor(String incomingString, int commandSource){
  
  boolean result = true;
  String report = "OK";
  incomingString.trim();
  incomingString.toUpperCase();
  if (incomingString.startsWith("OPEN")) {
    lockOpen();
  } 
  else if (incomingString.startsWith("ACTIVATE")) {
    lockActivate(HIGH);
  } 
  else if (incomingString.startsWith("DEACTIVATE")) {
    lockActivate(LOW);
  } 
  else if (incomingString.startsWith("STATUS")) {
    if (lockActive == HIGH) {
      report = "ACTIVE";
    } 
    else {
      report = "NOTACTIVE";
    }    
  }
  else if (incomingString.startsWith("DOOR")) {
    if (analogRead(NO_PIN) > 1000) {
      report = "CLOSE";
    } 
    else {
      report = "OPEN";
    }
  }
  else {
    result = false;
  }

  if (result && (commandSource == EVENT_ETHERNET) && client.connected()) {
    if (incomingString.indexOf(":") > 0) {
      client.print("/" + report + incomingString.substring(incomingString.indexOf(":")));
    } 
    else {
      client.println("/" + report);
    }    
  }
  
  if (result && (commandSource == EVENT_SERIAL)) {
    Serial.println(report);
  }

}



void ethernetEvent() {
  if (client.available()) {
    char inChar = client.read();
    ethernetString += inChar;
    if (inChar == '\n') {
      eventButton = EVENT_ETHERNET;
    } 
  }
}


void loop(){

  if (eventButton == EVENT_ETHERNET) {
    commandProcessor(ethernetString, eventButton);
    ethernetString = "";
    eventButton = EVENT_NONE;
  }

  if (eventButton == EVENT_SERIAL) {
    commandProcessor(inputString, eventButton);
    inputString = "";
    eventButton = EVENT_NONE;
  }

  if (!client.connected() && lastConnected) {
    Serial.println("Disconnecting.");
    minorBeep();
    digitalWrite(LED_ETHERNET, LOW);
    disconnectTime = millis();
    client.stop();
  }

  lastConnected = client.connected();

  if ((!lastConnected) && (millis() > disconnectTime+RECONNECT_TIME)) {
    disconnectTime = millis();
    serverConnect();
  }

  ethernetEvent();
}

void serialEvent() {
  while (Serial.available()) {
    char inChar = (char)Serial.read();
    inputString += inChar;
    if (inChar == '\n') {
      eventButton = EVENT_SERIAL;
    } 
  }
}