Home security prototype Blynk

Hello guys,
After many questions, research and commitment, i was able to do the project for my college.

The design has as characteristics the motion sensor, magnetic sensor, RFID, movement of a support that contains an IP camera and activation of relays.

Follow a video of working:

and the code used:

int contato = 2; //definição da porta Digital 2
int pirPin = 6; //definição da porta Digital 2

#include <EEPROM.h>     //Biblioteca para gravar dados das Tag na EEPROM
#include <SPI.h>        // RC522 Module uses SPI protocol Comunicação SPI
#include <MFRC522.h>  // Biblioteca para o RFID
#define BLYNK_PRINT Serial
#include <SPI.h>
#include <Ethernet.h> //Biblioteca para Ethernet Shield
#include <BlynkSimpleEthernet.h>
#include <Servo.h> //Biblioteca para Servo Motor
#include <SerialRelay.h> //Biblioteca para modulo Rele Serial
SerialRelay relays(22, 23, 1); // (data, clock, número de módulos)
#define COMMON_ANODE
#ifdef COMMON_ANODE
#define LED_ON LOW
#define LED_OFF HIGH
#else
#define LED_ON HIGH
#define LED_OFF LOW
#endif
#define redLed 27    // Led Vermelho
#define greenLed 26  //Led Verde
#define blueLed 25   //Led Azul
#define relay 8     // Rele para acionamento da tranca
#define wipeB 3     // Apaga as tag cadastrada
#define W5100_CS  10
#define SDCARD_CS 4

bool programMode = false;  // initialize programming mode to false

uint8_t successRead;    // Varialvel para caso seja leitura bem sucedida

byte storedCard[4];   //Armazena uma TAG lida da EEPROM
byte readCard[4];   // Armazena a Tag lida no leitor
byte masterCard[4];   //Armazena a TAG lido na EEPROM

// Create MFRC522 instance.
#define SS_PIN 53 //Definindo a porta 53 para comunicação RFID
#define RST_PIN 5 //Definindo a porta 53 para comunicação RFID
MFRC522 mfrc522(SS_PIN, RST_PIN);

char auth[] = "CODE"; //Auth Token do Projeto no Blynk

BLYNK_WRITE(V0) { //Acionamento do Relé 01
  int pinValue = param.asInt();
  //Serial.println(pinValue);
  if (pinValue == 1) {
    relays.SetRelay(1, SERIAL_RELAY_ON, 1);   // liga o relé 01
  } else {
    relays.SetRelay(1, SERIAL_RELAY_OFF, 1);  // desliga o relé 01
  }
}

BLYNK_WRITE(V1) { //Acionamento do Rele 02
  int pinValue = param.asInt();
  //Serial.println(pinValue);
  if (pinValue == 1) {
    relays.SetRelay(2, SERIAL_RELAY_ON, 1);   // liga o relé 02
  } else {
    relays.SetRelay(2, SERIAL_RELAY_OFF, 1);  // desliga o relé 02
  }
}

Servo servo; //Servo Motor X
Servo servo2; //Servo Motor Y

///////////Movimento do servo motor X////////////////////////
BLYNK_WRITE(V3)
{
  servo.write(param.asInt());
}

/////////////Movimento o Servo Motor Y/////////////////////////
BLYNK_WRITE(V4)
{
  servo2.write(param.asInt());
}

///////////////////////////////////////// Setup ///////////////////////////////////
void setup() {
  //Configuração dos pinos no Arduino
  pinMode(SDCARD_CS, OUTPUT);
  digitalWrite(SDCARD_CS, HIGH); // 
  Blynk.begin(auth);
  pinMode(redLed, OUTPUT);
  pinMode(greenLed, OUTPUT);
  pinMode(blueLed, OUTPUT);
  pinMode(wipeB, INPUT_PULLUP);   // Habilita pino resistor pull-up
  pinMode(relay, OUTPUT);
  digitalWrite(relay, HIGH);    
  digitalWrite(redLed, LED_OFF);  
  digitalWrite(greenLed, LED_OFF);  
  digitalWrite(blueLed, LED_OFF); 
  servo.attach(4);
  servo2.attach(7);
  pinMode(contato, INPUT);
  pinMode(pirPin, INPUT);

  //Protocol Configuration
  Serial.begin(9600);  // Initialize serial communications with PC
  SPI.begin();           // Protocolo de comunicação
  mfrc522.PCD_Init();    // Inicializa o leitor RFID

  Serial.println(F("Controle de Acesso Example v0.1"));   

  if (digitalRead(wipeB) == LOW) {  //Botão pressionado ativa a função WIPE
    digitalWrite(redLed, LED_ON); 
    Serial.println(F("Botao WIPE pressionado"));
    Serial.println(F("Você tem 10 segundo para cancelar essa operacao"));
    Serial.println(F("Isso removerá todos os registros e não poderá ser desfeito"));
    bool buttonState = monitorWipeButton(10000); // Delay de 10segundos
    if (buttonState == true && digitalRead(wipeB) == LOW) {    // Se o botão ainda estiver pressionado
      Serial.println(F("Iniciando processo de limpeza da EEPROM"));
      for (uint16_t x = 0; x < EEPROM.length(); x = x + 1) {    //Loop final do endereço da EEPROM
        if (EEPROM.read(x) == 0) {              //Se o endereço EEPROM = 0
        }
        else {
          EEPROM.write(x, 0);       // se não escrever 0 para limpar, leva 3.3mS
        }
      }
      Serial.println(F("Limpado EEPROM"));
      digitalWrite(redLed, LED_OFF); 
      delay(200);
      digitalWrite(redLed, LED_ON);
      delay(200);
      digitalWrite(redLed, LED_OFF);
      delay(200);
      digitalWrite(redLed, LED_ON);
      delay(200);
      digitalWrite(redLed, LED_OFF);
    }
    else {
      Serial.println(F("Limpeza Cancelada")); // Show some feedback that the wipe button did not pressed for 15 seconds
      digitalWrite(redLed, LED_OFF);
    }
  }
  if (EEPROM.read(1) != 143) {
    Serial.println(F("Nenhuma Tag Master Definida"));
    Serial.println(F("Aproxime uma Tag para defini-la como Master"));
    do {
      successRead = getID();            
      digitalWrite(blueLed, LED_ON);    
      delay(200);
      digitalWrite(blueLed, LED_OFF);
      delay(200);
    }
    while (!successRead);                  // O programa ficará lendo até encontrar uma tag
    for ( uint8_t j = 0; j < 4; j++ ) {        // Loop 4 times
      EEPROM.write( 2 + j, readCard[j] );  
    }
    EEPROM.write(1, 143);                  
    Serial.println(F("Definido Tag Master"));
  }
  Serial.println(F("-------------------"));
  Serial.println(F("Tag MasterUID"));
  for ( uint8_t i = 0; i < 4; i++ ) {          
    masterCard[i] = EEPROM.read(2 + i);   
    Serial.print(masterCard[i], HEX);
  }
  Serial.println("");
  Serial.println(F("-------------------"));
  Serial.println(F("Tudo Pronto"));
  Serial.println(F("Esperando PICCs para ser escaneadas:"));
  cycleLeds();   
}


///////////////////////////////////////// Main Loop ///////////////////////////////////
void loop () {
  do {

///////////////////////////////////////Rotina de Verificação de Estado do Sensor Magnético /////////////////////////////////
    Blynk.run();
    if (digitalRead(contato) == HIGH) {
      Blynk.notify("A PORTA FOI ABERTA");
      delay(1000);
    }

///////////////////////////////////////Rotina de Verificação de Estado do Sensor de Presença ///////////////////////////////
    int pirValue = digitalRead(pirPin);
    if (pirValue == HIGH) {
      Blynk.notify("MOVIMENTO DETECTADO");
      delay(1000);
    }
    if (pirValue == LOW) {
      delay(1000);
    }

////////////////////////////////////Rotina de Funcionamento RFID ///////////////////////////////////////////////////////
    successRead = getID();  // sets successRead to 1 when we get read from reader otherwise 0
    if (digitalRead(wipeB) == LOW) { // Confere se o botão WIPE foi pressionado
      digitalWrite(redLed, LED_ON);  
      digitalWrite(greenLed, LED_OFF);  
      digitalWrite(blueLed, LED_OFF);
      Serial.println(F("Botão WIPE Pressionado"));
      Serial.println(F("Master Card será apagado! em 10 segundos"));
      bool buttonState = monitorWipeButton(10000); // Delay 10s
      if (buttonState == true && digitalRead(wipeB) == LOW) {    // Se estiver pressionado, apaga da EEPROM
        EEPROM.write(1, 0);                  // Reset Magic Number.
        Serial.println(F("Master Card apagado do dispositivo"));
        Serial.println(F("Por favor, redefina para reprogramar o Master Card"));
        while (1);
      }
      Serial.println(F("Cancelado processo"));
    }
    if (programMode) {
      cycleLeds();              
    }
    else {
      normalModeOn();     
    }
  }
  while (!successRead);   
  if (programMode) {
    if ( isMaster(readCard) ) { //Quando no modo de programa verificar primeiro Se o cartão mestre for digitalizado novamente para sair do modo de programação
      Serial.println(F("Tag Master lida"));
      Serial.println(F("Saindo do Modo Gravação"));
      Serial.println(F("-----------------------------"));
      programMode = false;
      return;
    }
    else {
      if ( findID(readCard) ) { //  Se o cartão digitalizado for conhecido, exclua-o
        Serial.println(F("Tag já cadastrada, removendo Tag..."));
        deleteID(readCard);
        Serial.println("-----------------------------");
        Serial.println(F("Aproxime uma PICC para ADD ou REMOVE da EEPROM"));
      }
      else {                    // If scanned card is not known add it
        Serial.println(F("Tag não cadastrada, adicionando..."));
        writeID(readCard);
        Serial.println(F("-----------------------------"));
        Serial.println(F("Aproxime uma PICC para ADD ou REMOVE da EEPROM"));
      }
    }
  }
  else {
    if ( isMaster(readCard)) {    // Se o ID do cartão escaneado coincidir com o ID do cartão mestre - entre no modo de programa
      programMode = true;
      Serial.println(F("Bem-Vindo Master ao Modo Gravacao"));
      uint8_t count = EEPROM.read(0);   
      Serial.print(F("Existem "));    
      Serial.print(count);
      Serial.print(F(" registros na EEPROM"));
      Serial.println("");
      Serial.println(F("Aproxime uma PICC para ADD ou REMOVE da EEPROM"));
      Serial.println(F("Aproxime a Tag Master novamente para sair do Modo Gravacao"));
      Serial.println(F("-----------------------------"));
    }
    else {
      if ( findID(readCard) ) { // If not, see if the card is in the EEPROM
        Serial.println(F("Bem-Vindo, acesso permitido"));
        granted(300);        
      }
      else {      
        Serial.println(F("Acesso Negado"));
        denied();
      }
    }
  }
}

/////////////////////////////////////////  Acesso Permitido   ///////////////////////////////////
void granted ( uint16_t setDelay) {
  digitalWrite(blueLed, LED_OFF);   
  digitalWrite(redLed, LED_OFF);  
  digitalWrite(greenLed, LED_ON);   
  digitalWrite(relay, LOW);     // Destrava a Porta
  delay(setDelay);          
  digitalWrite(relay, HIGH);    // Tranca a porta novamente
  delay(1000);           
}

///////////////////////////////////////// Acesso Negado  ///////////////////////////////////
void denied() {
  digitalWrite(greenLed, LED_OFF);  
  digitalWrite(blueLed, LED_OFF);   
  digitalWrite(redLed, LED_ON);   
  delay(1000);
}


///////////////////////////////////////// Get PICC's UID ///////////////////////////////////
uint8_t getID() {
  if ( ! mfrc522.PICC_IsNewCardPresent()) { //Se for identificado uma nova tag
    return 0;
  }
  if ( ! mfrc522.PICC_ReadCardSerial()) {  
    return 0;
  }
  Serial.println(F("Lido PICC's UID:"));
  for ( uint8_t i = 0; i < 4; i++) {  //
    readCard[i] = mfrc522.uid.uidByte[i];
    Serial.print(readCard[i], HEX);
  }
  Serial.println("");
  mfrc522.PICC_HaltA(); // Stop reading
  return 1;
}

void ShowReaderDetails() {
  // Get the MFRC522 software version
  byte v = mfrc522.PCD_ReadRegister(mfrc522.VersionReg);
  Serial.print(F("MFRC522 Software Version: 0x"));
  Serial.print(v, HEX);
  if (v == 0x91)
    Serial.print(F(" = v1.0"));
  else if (v == 0x92)
    Serial.print(F(" = v2.0"));
  else
    Serial.print(F(" (unknown),probably a chinese clone?"));
  Serial.println("");

  if ((v == 0x00) || (v == 0xFF)) {
    Serial.println(F("WARNING: Communication failure, is the MFRC522 properly connected?"));
    Serial.println(F("SYSTEM HALTED: Check connections."));
    // Visualize system is halted
    digitalWrite(greenLed, LED_OFF);  // Make sure green LED is off
    digitalWrite(blueLed, LED_OFF);   // Make sure blue LED is off
    digitalWrite(redLed, LED_ON);   // Turn on red LED
    while (true); // do not go further
  }
}

///////////////////////////////////////// Ciclo dos LED's ///////////////////////////////////
void cycleLeds() {
  digitalWrite(redLed, LED_OFF);  // Make sure red LED is off
  digitalWrite(greenLed, LED_ON);   // Make sure green LED is on
  digitalWrite(blueLed, LED_OFF);   // Make sure blue LED is off
  delay(200);
  digitalWrite(redLed, LED_OFF);  // Make sure red LED is off
  digitalWrite(greenLed, LED_OFF);  // Make sure green LED is off
  digitalWrite(blueLed, LED_ON);  // Make sure blue LED is on
  delay(200);
  digitalWrite(redLed, LED_ON);   // Make sure red LED is on
  digitalWrite(greenLed, LED_OFF);  // Make sure green LED is off
  digitalWrite(blueLed, LED_OFF);   // Make sure blue LED is off
  delay(200);
}

//////////////////////////////////////// Normal Mode Led  ///////////////////////////////////
void normalModeOn () {
  digitalWrite(blueLed, LED_ON); 
  digitalWrite(redLed, LED_OFF);  
  digitalWrite(greenLed, LED_OFF);  
  digitalWrite(relay, HIGH);    
}

//////////////////////////////////////// Busca uma Tag na EEPROM //////////////////////////////
void readID( uint8_t number ) {
  uint8_t start = (number * 4 ) + 2;   
  for ( uint8_t i = 0; i < 4; i++ ) {     
    storedCard[i] = EEPROM.read(start + i);  
  }
}

///////////////////////////////////////// Adicionar TAG a EEPROM  ///////////////////////////////////
void writeID( byte a[] ) {
  if ( !findID( a ) ) {     // Before we write to the EEPROM, check to see if we have seen this card before!
    uint8_t num = EEPROM.read(0);     // Get the numer of used spaces, position 0 stores the number of ID cards
    uint8_t start = ( num * 4 ) + 6;  // Figure out where the next slot starts
    num++;                // Increment the counter by one
    EEPROM.write( 0, num );     // Write the new count to the counter
    for ( uint8_t j = 0; j < 4; j++ ) {   // Loop 4 times
      EEPROM.write( start + j, a[j] );  // Write the array values to EEPROM in the right position
    }
    successWrite();
    Serial.println(F("Registro de ID adicionado com sucesso à EEPROM"));
  }
  else {
    failedWrite();
    Serial.println(F("Failed! There is something wrong with ID or bad EEPROM"));
  }
}

///////////////////////////////////////// Remove TAG da EEPROM   ///////////////////////////////////
void deleteID( byte a[] ) {
  if ( !findID( a ) ) {     // Before we delete from the EEPROM, check to see if we have this card!
    failedWrite();      // If not
    Serial.println(F("Failed! There is something wrong with ID or bad EEPROM"));
  }
  else {
    uint8_t num = EEPROM.read(0);   // Get the numer of used spaces, position 0 stores the number of ID cards
    uint8_t slot;       // Figure out the slot number of the card
    uint8_t start;      // = ( num * 4 ) + 6; // Figure out where the next slot starts
    uint8_t looping;    // The number of times the loop repeats
    uint8_t j;
    uint8_t count = EEPROM.read(0); // Read the first Byte of EEPROM that stores number of cards
    slot = findIDSLOT( a );   // Figure out the slot number of the card to delete
    start = (slot * 4) + 2;
    looping = ((num - slot) * 4);
    num--;      // Decrement the counter by one
    EEPROM.write( 0, num );   // Write the new count to the counter
    for ( j = 0; j < looping; j++ ) {         // Loop the card shift times
      EEPROM.write( start + j, EEPROM.read(start + 4 + j));   // Shift the array values to 4 places earlier in the EEPROM
    }
    for ( uint8_t k = 0; k < 4; k++ ) {         // Shifting loop
      EEPROM.write( start + j + k, 0);
    }
    successDelete();
    Serial.println(F("Registro de ID removido com sucesso da EEPROM"));
  }
}

///////////////////////////////////////// Check Bytes   ///////////////////////////////////
bool checkTwo ( byte a[], byte b[] ) {
  for ( uint8_t k = 0; k < 4; k++ ) {   // Loop 4 times
    if ( a[k] != b[k] ) {     // IF a != b then false, because: one fails, all fail
      return false;
    }
  }
  return true;
}

///////////////////////////////////////// Find Slot   ///////////////////////////////////
uint8_t findIDSLOT( byte find[] ) {
  uint8_t count = EEPROM.read(0);       // Read the first Byte of EEPROM that
  for ( uint8_t i = 1; i <= count; i++ ) {    // Loop once for each EEPROM entry
    readID(i);                // Read an ID from EEPROM, it is stored in storedCard[4]
    if ( checkTwo( find, storedCard ) ) {   // Check to see if the storedCard read from EEPROM
      // is the same as the find[] ID card passed
      return i;         // The slot number of the card
    }
  }
}

///////////////////////////////////////// Encontra a ID na EEPROM  ///////////////////////////////////
bool findID( byte find[] ) {
  uint8_t count = EEPROM.read(0);     // Read the first Byte of EEPROM that
  for ( uint8_t i = 1; i < count; i++ ) {    // Loop once for each EEPROM entry
    readID(i);          // Read an ID from EEPROM, it is stored in storedCard[4]
    if ( checkTwo( find, storedCard ) ) {   // Check to see if the storedCard read from EEPROM
      return true;
    }
    else {    // If not, return false
    }
  }
  return false;
}

///////////////////////////////////////// Escrito com sucesso na EEPROM   ///////////////////////////////////
void successWrite() {
  digitalWrite(blueLed, LED_OFF);   // Make sure blue LED is off
  digitalWrite(redLed, LED_OFF);  // Make sure red LED is off
  digitalWrite(greenLed, LED_OFF);  // Make sure green LED is on
  delay(200);
  digitalWrite(greenLed, LED_ON);   // Make sure green LED is on
  delay(200);
  digitalWrite(greenLed, LED_OFF);  // Make sure green LED is off
  delay(200);
  digitalWrite(greenLed, LED_ON);   // Make sure green LED is on
  delay(200);
  digitalWrite(greenLed, LED_OFF);  // Make sure green LED is off
  delay(200);
  digitalWrite(greenLed, LED_ON);   // Make sure green LED is on
  delay(200);
}

///////////////////////////////////////// Erro ao gravar na EEPROM   ///////////////////////////////////
void failedWrite() {
  digitalWrite(blueLed, LED_OFF);   // Make sure blue LED is off
  digitalWrite(redLed, LED_OFF);  // Make sure red LED is off
  digitalWrite(greenLed, LED_OFF);  // Make sure green LED is off
  delay(200);
  digitalWrite(redLed, LED_ON);   // Make sure red LED is on
  delay(200);
  digitalWrite(redLed, LED_OFF);  // Make sure red LED is off
  delay(200);
  digitalWrite(redLed, LED_ON);   // Make sure red LED is on
  delay(200);
  digitalWrite(redLed, LED_OFF);  // Make sure red LED is off
  delay(200);
  digitalWrite(redLed, LED_ON);   // Make sure red LED is on
  delay(200);
}

///////////////////////////////////////// Concluido para remover Tag da EEPROM  ///////////////////////////////////
void successDelete() {
  digitalWrite(blueLed, LED_OFF);   // Make sure blue LED is off
  digitalWrite(redLed, LED_OFF);  // Make sure red LED is off
  digitalWrite(greenLed, LED_OFF);  // Make sure green LED is off
  delay(200);
  digitalWrite(blueLed, LED_ON);  // Make sure blue LED is on
  delay(200);
  digitalWrite(blueLed, LED_OFF);   // Make sure blue LED is off
  delay(200);
  digitalWrite(blueLed, LED_ON);  // Make sure blue LED is on
  delay(200);
  digitalWrite(blueLed, LED_OFF);   // Make sure blue LED is off
  delay(200);
  digitalWrite(blueLed, LED_ON);  // Make sure blue LED is on
  delay(200);
}

////////////////////// Verifique o cartão de leitura IF é masterCard  ///////////////////////////////////
bool isMaster( byte test[] ) {
  return checkTwo(test, masterCard);
}

bool monitorWipeButton(uint32_t interval) {
  uint32_t now = (uint32_t)millis();
  while ((uint32_t)millis() - now < interval)  {
    // check on every half a second
    if (((uint32_t)millis() % 500) == 0) {
      if (digitalRead(wipeB) != LOW)
        return false;
    }
  }
  return true;
}
3 Likes