Control de Acceso con Módulo RFID RC522 Arduino

Publicado por Victor Arrieta en

El módulo RFID RC522 es una placa de identificación de tags y tarjetas (lectura y escritura) por medio del estándar ISO/IEC 14443 tipo A que funciona bajo 13.56 MHz. Este módulo es extremadamente útil para proyectos de controles de acceso dándonos una gran versatilidad en los modos de encriptación de los códigos de acceso. EL módulo puede comunicarse con  un microcontrolador (una placa Arduino, por ejemplo) por medio  de comunicación SPI y por un puerto UART. los pines del módulo son los siguientes:
SDA:       Comunicación
SCK:       Comunicación
MOSI:     Comunicación
MISO:     Comunicación
IRQ:        Comunicación
GND:      Referencia Negativa
RST:        Reset
3.3V:       Voltaje de alimentación 3.3VDC máx
Con el fin de guardar tu clave de acceso, puedes usar  un algoritmo tan complejo como quieras, incluso existen algoritmos especializados (dependiendo de la aplicación) que te permiten "ocular" la clave de  una forma específica dentro del 1Kb de memoria que traen la mayoría de los tags y tarjetas, con el fin de dificultar el hacking; sin embargo, si tu  aplicación es  muy simple y más bien domestica, no deberías complicarte la vida con estas cosas y podrías sólo utilizar el serial (único para cada tag y tarjeta) de la siguiente manera: 
1. Leer el serial del dispositivo presente.
2. Compararlo con el serial guardado.
3. Y si  es el mismo, entonces es tu tarjeta y permite el acceso, de  lo contrario, no. 
Es esto precisamente lo que hacemos en el sencillo proyecto que te mostramos a continuación como un buen ejemplo de aplicación:

Control de Acceso simple con RC522 y Arduino UNO

Este proyecto te permitirá activar o desactivar un relevo por medio de la identificación de un tag o tarjeta específico que puede ser cambiado fácilmente en sólo 3 pasos: 
1. Conectar pin 3 al negativo
2. Ubicar el nuevo dispositivo en el sensor 
3. Retirar la conexión al negativo. 
Al colocar la tarjeta o tag correcto, el buzzer y el relevo serán activados por 2 segundos, en el relevo podrás conectar un seguro eléctrico de puerta o lo que desees activar con el RFID.
Si quieres utilizar más de un dispositivo de acceso, deberás modificar el código y agregar la verificación de tantas claves como tags o tarjetas uses, el proyecto usa la librería MFRC522 de autoría de la comunidad de Github.

Esquema de conexión 

Código Arduino:

 

#include <EEPROM.h> // incluimos librerías  

#include <SPI.h>

#include <MFRC522.h>

 
#define SS_PIN 10
#define RST_PIN 9
 
MFRC522 mfrc522(SS_PIN, RST_PIN);// instanciamos el módulo
 
// pines
int BuzzPin = 7;
int LoadPin = 6;
int nueva = 3;
// variables
int y;
 
// rutina para imprimir el serial en el puerto serie
void printDec(byte *buffer, byte bufferSize) {
  for (byte i = 0; i < bufferSize; i++) {
    Serial.print(buffer[i] < 0x10 ? " 0" : " ");
    Serial.print(buffer[i], DEC);
  }
  Serial.println();
}
 
// rutina que compara los seriales
boolean comparar(byte *buffer) {
 
  boolean x;
 
  if (buffer[0] == EEPROM.read(0)) {
    if (buffer[1] == EEPROM.read(1)) {
      if (buffer[2] == EEPROM.read(2)) {
        if (buffer[3] == EEPROM.read(3)) {
          if (buffer[4] == EEPROM.read(4)) {
            if (buffer[5] == EEPROM.read(5)) {
              x = true;
            }
          }
        }
      }
    }
  }
  else {
    x = false;
  }
  return x;
}
 
// rutina que guarda el serial nuevo
void guardar(byte *buffer) {
  EEPROM.write(0, buffer[0]);
  EEPROM.write(1, buffer[1]);
  EEPROM.write(2, buffer[2]);
  EEPROM.write(3, buffer[3]);
  EEPROM.write(4, buffer[4]);
  EEPROM.write(5, buffer[5]);
  Serial.println("Guardado corrrectamente");
}
 
 
void setup() {
 
  Serial.begin(9600); // inicializamos la comunicación serial
  SPI.begin();        // inicializamos la comunicación spi
  mfrc522.PCD_Init(); // inicializamos el módulo
  pinMode(BuzzPin, OUTPUT); // salidas
  pinMode(LoadPin, OUTPUT);
  pinMode(nueva, INPUT_PULLUP); // entrada
  digitalWrite(BuzzPin, LOW); //  valores iniciales
  digitalWrite(LoadPin, HIGH);
  y = 0;
}
 
void loop() {
 
  byte buffer[18];
  byte size = sizeof(buffer);
 
  // busca si hay un tag
  if ( ! mfrc522.PICC_IsNewCardPresent()) {
    Serial.println("No hay tarjeta"); // sino lo hay, dice que no ay tarjeta
  }
  else {
    // en caso de que haya un tag, se verifica si no se desea guardar ese tag
    if ((digitalRead(nueva) == LOW) && (y == 0)) {
      mfrc522.PICC_ReadCardSerial();
      guardar(mfrc522.uid.uidByte); // función para guardar
      y = 1; // de esta fora sólo se guarda ua vez
    }
    else {
      Serial.println("Se detetecta una tarjeta");
      Serial.println();
      Serial.println("Serial de la tarjeta ...");
      mfrc522.PICC_ReadCardSerial(); // funccion que lee el serial
      printDec(mfrc522.uid.uidByte, mfrc522.uid.size); //Se imprime en el puerto serial
      if (comparar(mfrc522.uid.uidByte)) { // se compara con el serial guaardado
        digitalWrite(BuzzPin, HIGH); // si es el correcto se desbloquea el sistema
        digitalWrite(LoadPin, LOW);
        Serial.println("desbloqueado");
        delay(2000);// por 2 segundos
        digitalWrite(BuzzPin, LOW);
        digitalWrite(LoadPin, HIGH); // luego se vuelve a bloquear
      }
      else {
        digitalWrite(BuzzPin, LOW); // si es incorrecto, permanece bloqueado.
        digitalWrite(LoadPin, HIGH);
        Serial.println("tarjeta invalida"); // y en el puerto serial se muestra mensaje
        Serial.println();
      }
      delay(500);
    }
  }
}
Al subir el código a tu Arduino y realizar las conexiones, podrás ver en el puerto serial del IDE de Arduino, el estado del sistema.
 
NOTA: Por el nivel de seguridad de este este proyecto no debe ser utilizado en aplicaciones muy delicadas.
 
 
 

Compartir esta publicación



← Publicación más antigua Publicación más reciente →