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: El nivel de seguridad de este este proyecto es muy bajo y no debe ser utilizado en aplicaciones muy delicadas, pues podría hackearse con facilidad:
FIN DEL POST
