La tecnología RFID ha revolucionado la forma en que interactuamos con el mundo que nos rodea. En este artículo, exploraremos qué es la RFID, cómo funciona y cómo podemos utilizar el módulo RFID RC522 con Arduino para crear proyectos innovadores. ¡Prepárate para adentrarte en el fascinante mundo de la identificación por radiofrecuencia!
Gracias a la tecnología RFID, se acabaron los días en que las personas hacían largas colas en la caja del supermercado. Con un Solución de pago automático basada en RFID con recorrido, puedes llenar tu carrito y salir directamente por la puerta. Ya no tendrá que esperar a que alguien registre cada artículo de su carrito individualmente; Con la ayuda de etiquetas RFID adheridas a los artículos, ahora cada artículo del carrito de compras se reconoce y se llama casi de inmediato.
Para la mayoría de nuestros proyectos Arduino basados en RFID, el módulo de lectura/escritura RFID RC522 es una buena opción. Es energéticamente eficiente, económico, muy robusto, fácil de conectar y extremadamente popular entre los aficionados.
¿Qué es la tecnología RFID y cómo funciona?
A RFID Un sistema de identificación por radiofrecuencia consta de dos componentes principales: una etiqueta que se adhiere al objeto a identificar y un lector que lee la etiqueta.
Un lector consta de un módulo de alta frecuencia y una antena que genera un campo electromagnético de alta frecuencia. Mientras que la etiqueta suele ser un dispositivo pasivo (no tiene batería). Consta de un microchip que almacena y procesa información y una antena para recibir y enviar una señal.
Cuando la etiqueta se acerca al lector, el lector genera un campo electromagnético. Esto hace que los electrones se muevan a través de la antena de la etiqueta y luego suministren energía al chip.
Luego, el chip responde enviando la información almacenada al lector en forma de otra señal de radio. Esto se llama retrodispersión. El lector detecta e interpreta esta retrodispersión y envía los datos a una computadora o microcontrolador.
Descripción general del hardware
El módulo RFID RC522 se basa en el Circuito integrado MFRC522 de NXP es una de las opciones RFID más baratas que puedes conseguir online por menos de cuatro dólares. Por lo general, viene con una etiqueta de tarjeta RFID y una etiqueta de llavero con 1 KB de memoria. Y la mejor parte es que puede escribir una etiqueta para que puedas almacenar cualquier mensaje en ella.
El módulo lector RFID RC522 está diseñado para generar un campo electromagnético de 13,56 MHz y comunicarse con etiquetas RFID (etiquetas estándar ISO 14443A).
El lector puede comunicarse con un microcontrolador a través de un SPI de 4 pines con una velocidad de datos máxima de 10 Mbit/s. También admite comunicación mediante protocolos I2C y UART.
El módulo RFID RC522 se puede programar para generar una interrupción de modo que el módulo nos notifique cuando una etiqueta se acerca, en lugar de preguntar constantemente al módulo «¿Hay una tarjeta cerca?»
El voltaje de funcionamiento del módulo está entre 2,5 y 3,3 V, pero la buena noticia es que los pines lógicos son tolerantes a 5 voltios, por lo que podemos conectarlo fácilmente a un Arduino o cualquier microcontrolador lógico de 5 V sin necesidad de utilizar un convertidor de nivel lógico.
Especificaciones técnicas
Aquí están las especificaciones:
| Rango de frecuencia | Banda ISM de 13,56 MHz |
| Interfaz de host | SPI/I2C/UART |
| Tensión de alimentación de funcionamiento | 2,5 V a 3,3 V |
| Corriente de funcionamiento máx. | 13-26mA |
| Mínimo. Encendido (apagar) | 10 µA |
| Entradas lógicas | Tolerante a 5V |
| Zona de lectura | 5cm |
Consulte la siguiente hoja de datos para obtener más detalles.
Asignación de pines del módulo RFID RC522
El módulo RC522 tiene un total de 8 pines que lo conectan con el mundo exterior. Las conexiones son las siguientes:
VCC suministra energía al módulo. Puede estar entre 2,5 y 3,3 voltios. Puedes conectarlo a la salida de 3.3V de tu Arduino. Sin embargo, recuerde que conectarse al pin de 5 V probablemente destruirá su módulo.
primero es una entrada para reinicio y apagado. Cuando este pin baja, el módulo entra en modo de apagado. El oscilador se apaga y los pines de entrada se separan del mundo exterior. El módulo, por el contrario, se reinicia en el flanco ascendente de la señal.
Tierra es el pin de tierra y debe conectarse al pin GND del Arduino.
IRQ Es un pin de interrupción que notifica al microcontrolador cuando hay una etiqueta RFID cerca.
MISO/SCL/Tx El pin actúa como maestro de entrada y salida cuando la interfaz SPI está habilitada, un reloj en serie cuando la interfaz I2C está habilitada y una salida de datos en serie cuando la interfaz UART está habilitada.
MOSI (Master Out Slave In) es la entrada SPI al módulo RC522.
SCK (reloj serie) Acepta los pulsos de reloj proporcionados por el bus maestro SPI, es decir, Arduino.
SS/SDA/Rx El pin actúa como entrada de señal cuando la interfaz SPI está habilitada, una entrada de datos en serie cuando la interfaz I2C está habilitada y una entrada de datos en serie cuando la interfaz UART está habilitada. El marcado de este pin generalmente se realiza encerrándolo en un cuadrado para que pueda usarse como referencia para identificar otros pines.
Cableado de un módulo RFID RC522 a un Arduino
Ahora que sabemos todo sobre el módulo, ¡comencemos a conectarlo a nuestro Arduino!
Primero, conecte el pin VCC del módulo a 3.3V y el pin GND a tierra del Arduino. El pin RST se puede conectar a cualquier pin digital de Arduino. En nuestro caso está conectado al pin digital número 5. El pin IRQ permanece desconectado porque la biblioteca Arduino que usaremos no lo admite.
Ahora nos quedan los pines que se utilizan para la comunicación SPI. Dado que los módulos RC522 requieren muchas transferencias de datos, funcionan mejor cuando se conectan a los pines SPI del hardware del microcontrolador. En placas Arduino como UNO/Nano V3.0, estos pines son digitales 13 (SCK), 12 (MISO), 11 (MOSI) y 10 (SS).
Si utiliza un Arduino distinto de las placas anteriores, comuníquese con el funcionario de Arduino. documentación Antes de continuar.
La siguiente tabla enumera las conexiones de pines:
| módulo RC522 | arduino | |
| VCC | 3,3 V | |
| Tierra | Tierra | |
| primero | 5 | |
| MISO/SCL/Tx | 12 | |
| MOSI | 11 | |
| SCK | 13 | |
| SS/SDA/Rx | 10 |
La siguiente imagen muestra cómo conectar el módulo RC522 al Arduino.
Una vez que tengas todo conectado, ¡estarás listo para comenzar!
Instalación de biblioteca
Comunicarse con un módulo RFID RC522 es mucho trabajo, pero afortunadamente para nosotros existe una biblioteca llamada Biblioteca MFRC522 Esto facilita la lectura y escritura de etiquetas RFID.
Esta biblioteca no está incluida en el IDE de Arduino, por lo que primero debes instalarla.
Para instalar la biblioteca, navegue hasta Sketch > Incluir bibliotecas > Administrar bibliotecas… Espere a que el Administrador de bibliotecas descargue el índice de la biblioteca y actualice la lista de bibliotecas instaladas.
Filtra tu búsqueda escribiendo “mfrc522'. Busque la biblioteca de Comunidad Github. Haga clic en esta entrada y luego seleccione Instalar.
Código Arduino: lectura de una etiqueta RFID
Una vez que haya instalado la biblioteca, abra el submenú Ejemplos y seleccione MFRC522 > DumpInfo Ejemplo de boceto.
Este boceto simplemente lee la etiqueta y muestra la información almacenada en ella. ¡Este boceto puede resultar muy útil antes de probar nuevas etiquetas!
Vaya al principio del boceto y asegúrese RST_PIN se inicializa correctamente, en nuestro caso estamos usando el pin digital número 5, así que cámbielo a 5.
Ahora cargue el boceto y abra Serial Monitor. Si acercas la etiqueta al módulo obtendrás algo como esto. No mueva la etiqueta hasta que se muestre toda la información.
Muestra toda la información útil sobre la etiqueta, incluido el ID único (UID) de la etiqueta, el tamaño de almacenamiento y el almacenamiento total de 1 KB.
Diseño de almacenamiento MIFARE Classic 1K
La memoria de 1KB del tag se divide en 16 memorias sectores (de 0 a 15). Cada sector se divide a su vez en 4 bloques (Bloques 0 a 3). Y cada bloque puede almacenar 16 bytes. Datos (de 0 a 15).
Por supuesto, esto nos dice que tenemos:
16 sectores x 4 bloques x 16 bytes de datos = 1024 bytes = 1 KB de memoria
A continuación se resalta toda la memoria de 1 KB, así como los sectores, bloques y datos.
Aquí está la representación 3D del diseño de la tarjeta de memoria MIFARE Classic 1K.
El último bloque de cada sector se llama Remolque sector. Contiene información denominada bits de acceso que permiten el acceso de lectura y escritura a los bloques restantes del sector. Esto significa que sólo 3 bloques de cada sector (bloques 0, 1 y 2) son realmente escribibles, lo que significa que sólo 48 bytes por sector están disponibles para su uso.
El bloque #0 del Sector #0 también se llama bloque del fabricante que contiene datos del fabricante de IC y un identificador único (UID). El bloque del fabricante está resaltado en rojo.
Advertencia:
Recuerde que sobrescribir el bloqueo del fabricante es muy riesgoso y puede bloquear la tarjeta permanentemente.
Código Arduino: escritura de una etiqueta RFID
Suponiendo que haya leído con éxito una etiqueta RFID, pasemos a nuestro siguiente experimento. El siguiente esquema muestra la escritura de datos personalizados en una etiqueta RFID. Antes de comenzar un análisis detallado, pruebe Sketch.
#include <SPI.h> //include the SPI bus library
#include <MFRC522.h> //include the RFID reader library
#define SS_PIN 10 //slave select pin
#define RST_PIN 5 //reset pin
MFRC522 mfrc522(SS_PIN, RST_PIN); // instatiate a MFRC522 reader object.
MFRC522::MIFARE_Key key; //create a MIFARE_Key struct named 'key', which will hold the card information
//this is the block number we will write into and then read.
int block=2;
byte blockcontent[16] = {"Last-Minute-Engg"}; //an array with 16 bytes to be written into one of the 64 card blocks is defined
//byte blockcontent[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //all zeros. This can be used to delete a block.
//This array is used for reading out a block.
byte readbackblock[18];
void setup()
{
Serial.begin(9600); // Initialize serial communications with the PC
SPI.begin(); // Init SPI bus
mfrc522.PCD_Init(); // Init MFRC522 card (in case you wonder what PCD means: proximity coupling device)
Serial.println("Scan a MIFARE Classic card");
// Prepare the security key for the read and write functions.
for (byte i = 0; i < 6; i++) {
key.keyByte[i] = 0xFF; //keyByte is defined in the "MIFARE_Key" 'struct' definition in the .h file of the library
}
}
void loop()
{
// Look for new cards
if ( ! mfrc522.PICC_IsNewCardPresent()) {
return;
}
// Select one of the cards
if ( ! mfrc522.PICC_ReadCardSerial())
{
return;
}
Serial.println("card selected");
//the blockcontent array is written into the card block
writeBlock(block, blockcontent);
//read the block back
readBlock(block, readbackblock);
//uncomment below line if you want to see the entire 1k memory with the block written into it.
//mfrc522.PICC_DumpToSerial(&(mfrc522.uid));
//print the block contents
Serial.print("read block: ");
for (int j=0 ; j<16 ; j++)
{
Serial.write (readbackblock[j]);
}
Serial.println("");
}
//Write specific block
int writeBlock(int blockNumber, byte arrayAddress[])
{
//this makes sure that we only write into data blocks. Every 4th block is a trailer block for the access/security info.
int largestModulo4Number=blockNumber/4*4;
int trailerBlock=largestModulo4Number+3;//determine trailer block for the sector
if (blockNumber > 2 && (blockNumber+1)%4 == 0){Serial.print(blockNumber);Serial.println(" is a trailer block:");return 2;}
Serial.print(blockNumber);
Serial.println(" is a data block:");
//authentication of the desired block for access
byte status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid));
if (status != MFRC522::STATUS_OK) {
Serial.print("PCD_Authenticate() failed: ");
Serial.println(mfrc522.GetStatusCodeName(status));
return 3;//return "3" as error message
}
//writing the block
status = mfrc522.MIFARE_Write(blockNumber, arrayAddress, 16);
//status = mfrc522.MIFARE_Write(9, value1Block, 16);
if (status != MFRC522::STATUS_OK) {
Serial.print("MIFARE_Write() failed: ");
Serial.println(mfrc522.GetStatusCodeName(status));
return 4;//return "4" as error message
}
Serial.println("block was written");
}
//Read specific block
int readBlock(int blockNumber, byte arrayAddress[])
{
int largestModulo4Number=blockNumber/4*4;
int trailerBlock=largestModulo4Number+3;//determine trailer block for the sector
//authentication of the desired block for access
byte status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid));
if (status != MFRC522::STATUS_OK) {
Serial.print("PCD_Authenticate() failed (read): ");
Serial.println(mfrc522.GetStatusCodeName(status));
return 3;//return "3" as error message
}
//reading a block
byte buffersize = 18;//we need to define a variable with the read buffer size, since the MIFARE_Read method below needs a pointer to the variable that contains the size...
status = mfrc522.MIFARE_Read(blockNumber, arrayAddress, &buffersize);//&buffersize is a pointer to the buffersize variable; MIFARE_Read requires a pointer instead of just a number
if (status != MFRC522::STATUS_OK) {
Serial.print("MIFARE_read() failed: ");
Serial.println(mfrc522.GetStatusCodeName(status));
return 4;//return "4" as error message
}
Serial.println("block was read");
}La salida en el monitor serie se parece a esto.
Explicación del código:
El boceto comienza incluyendo las bibliotecas MFRC522 y SPI, definiendo los pines Arduino a los que está conectado el RC522 y creando una instancia del objeto lector MFRC522.
#include <SPI.h>//include the SPI bus library
#include <MFRC522.h>//include the RFID reader library
#define SS_PIN 10 //slave select pin
#define RST_PIN 5 //reset pin
MFRC522 mfrc522(SS_PIN, RST_PIN); // instatiate a MFRC522 reader object.
MFRC522::MIFARE_Key key;//create a MIFARE_Key struct named 'key', which will hold the card informationDespués de eso, definimos un bloque en el que almacenamos nuestros datos. Aquí se selecciona el Sector #0 Bloque #2. Recuerda nunca seleccionar el bloque #3 de un sector. Escribir en un bloque Sector Trailer puede inutilizar el bloque.
//this is the block number we will write into and then read.
int block=2;A continuación definimos una matriz de 16 bytes llamada blockcontent, que contiene el mensaje que queremos escribir en el bloque. Puedes especificar cuándo quieres eliminar un bloque. blockcontent a 0.
byte blockcontent[16] = {"Last-Minute-Engg"}; //an array with 16 bytes to be written into one of the 64 card blocks is defined
//byte blockcontent[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //all zeros. This can be used to delete a block.A continuación definimos una matriz de 18 bytes llamada readbackblock. Lo usaremos para leer contenido escrito. Espera… ¿18 bytes? ¿No deberían ser 16 bytes? La respuesta es no. El MIFARE_Read El método de la biblioteca MFRC522 requiere un búfer de al menos 18 bytes de longitud y que contenga 16 bytes de un bloque.
//This array is used for reading out a block.
byte readbackblock[18];En la configuración inicializamos la comunicación serie, la biblioteca SPI y el objeto MFRC522. También preparamos una clave de seguridad para operaciones de lectura y escritura. Los seis bytes de la clave se especifican aquí. 0xFF.
Recuerde que las tarjetas más nuevas tienen los seis bytes de la clave configurados en 0xFF. Si tiene una tarjeta programada por otra persona, necesitará saber la clave para acceder a la tarjeta. Mantenga esta clave en uno key luego variable.
Serial.begin(9600); // Initialize serial communications with the PC
SPI.begin(); // Init SPI bus
mfrc522.PCD_Init(); // Init MFRC522 card (in case you wonder what PCD means: proximity coupling device)
Serial.println("Scan a MIFARE Classic card");
// Prepare the security key for the read and write functions.
for (byte i = 0; i < 6; i++) {
key.keyByte[i] = 0xFF; //keyByte is defined in the "MIFARE_Key" 'struct' definition in the .h file of the library
}En el loop buscamos la nueva tarjeta y la seleccionamos para escritura y lectura.
// Look for new cards
if ( ! mfrc522.PICC_IsNewCardPresent()) {
return;
}
// Select one of the cards
if ( ! mfrc522.PICC_ReadCardSerial())
{
return;
}
Serial.println("card selected");Escribir bloques ahora es mucho más fácil. Simplemente llamamos a una función personalizada llamada writeBlock() lo que requiere dos parámetros: un número de bloque donde queremos escribir los datos y los datos en sí.
//the blockcontent array is written into the card block
writeBlock(block, blockcontent);Para comprobar si la escritura fue exitosa, volvemos a leer el contenido del bloque. Para hacer esto usamos una función personalizada llamada readBlock() lo que a su vez requiere dos parámetros: el número de bloque y la matriz para almacenar el contenido del bloque. Si desea ver todo el almacenamiento de 1K, puede llamar PICC_DumpToSerial() Función.
//read the block back
readBlock(block, readbackblock);
//uncomment below line if you want to see the entire 1k memory with the block written into it.
//mfrc522.PICC_DumpToSerial(&(mfrc522.uid));Finalmente imprimimos el contenido. readbackblock Matriz en el monitor serie con un for Cinta.
//print the block contents
Serial.print("read block: ");
for (int j=0 ; j<16 ; j++)
{
Serial.write (readbackblock[j]);
}
Serial.println("");Proyecto Arduino: sistema de control de acceso a puertas basado en RFID
Creemos rápidamente un proyecto Arduino para demostrar cómo se puede utilizar un módulo lector RFID RC522 simple para construir un sistema de control de acceso a puertas.
El siguiente programa escanea la identificación única de cada etiqueta RFID. Si el UID de la etiqueta coincide con un valor predefinido (etiqueta maestra) almacenado en la memoria de Arduino, se concede el acceso. Se deniega el acceso a etiquetas desconocidas. ¡Impresionantemente! ¿Bien?
Así es como se ve el resultado.
Por supuesto, este proyecto se puede ampliar para abrir puertas, cambiar relés, encender LED o cualquier otra cosa que se le ocurra.
Si no está familiarizado con las pantallas LCD de 16×2 caracteres, debería leer el siguiente tutorial.
LECTURAS SUGERIDAS
alambrado
Antes de cargar el código y comenzar a escanear las etiquetas, veamos el cableado del proyecto.
Probemos el siguiente boceto.
#include <SPI.h>
#include <MFRC522.h>
#include <LiquidCrystal.h>
#define RST_PIN 9
#define SS_PIN 10
byte readCard[4];
String MasterTag = "20C3935E"; // REPLACE this Tag ID with your Tag ID!!!
String tagID = "";
// Create instances
MFRC522 mfrc522(SS_PIN, RST_PIN);
LiquidCrystal lcd(7, 6, 5, 4, 3, 2); //Parameters: (rs, enable, d4, d5, d6, d7)
void setup()
{
// Initiating
SPI.begin(); // SPI bus
mfrc522.PCD_Init(); // MFRC522
lcd.begin(16, 2); // LCD screen
lcd.clear();
lcd.print(" Access Control ");
lcd.setCursor(0, 1);
lcd.print("Scan Your Card>>");
}
void loop()
{
//Wait until new tag is available
while (getID())
{
lcd.clear();
lcd.setCursor(0, 0);
if (tagID == MasterTag)
{
lcd.print(" Access Granted!");
// You can write any code here like opening doors, switching on a relay, lighting up an LED, or anything else you can think of.
}
else
{
lcd.print(" Access Denied!");
}
lcd.setCursor(0, 1);
lcd.print(" ID : ");
lcd.print(tagID);
delay(2000);
lcd.clear();
lcd.print(" Access Control ");
lcd.setCursor(0, 1);
lcd.print("Scan Your Card>>");
}
}
//Read new tag if available
boolean getID()
{
// Getting ready for Reading PICCs
if ( ! mfrc522.PICC_IsNewCardPresent()) { //If a new PICC placed to RFID reader continue
return false;
}
if ( ! mfrc522.PICC_ReadCardSerial()) { //Since a PICC placed get Serial and continue
return false;
}
tagID = "";
for ( uint8_t i = 0; i < 4; i++) { // The MIFARE PICCs that we use have 4 byte UID
//readCard[i] = mfrc522.uid.uidByte[i];
tagID.concat(String(mfrc522.uid.uidByte[i], HEX)); // Adds the 4 bytes in a single String variable
}
tagID.toUpperCase();
mfrc522.PICC_HaltA(); // Stop reading
return true;
}Explicación del código:
El programa es bastante sencillo. Para comenzar, incluimos las bibliotecas necesarias, definimos los pines de Arduino, creamos instancias de objetos LCD y MFRC522 y definimos la etiqueta maestra.
#include <SPI.h>
#include <MFRC522.h>
#include <LiquidCrystal.h>
#define RST_PIN 9
#define SS_PIN 10
byte readCard[4];
String MasterTag = "20C3935E"; // REPLACE this Tag ID with your Tag ID!!!
String tagID = "";
// Create instances
MFRC522 mfrc522(SS_PIN, RST_PIN);
LiquidCrystal lcd(7, 6, 5, 4, 3, 2); //Parameters: (rs, enable, d4, d5, d6, d7)En la configuración inicializamos la interfaz SPI, el objeto MFRC522 y la pantalla LCD. Después de eso imprimimos el mensaje de bienvenida en la pantalla LCD.
void setup()
{
// Initiating
SPI.begin(); // SPI bus
mfrc522.PCD_Init(); // MFRC522
lcd.begin(16, 2); // LCD screen
lcd.clear();
lcd.print(" Access Control ");
lcd.setCursor(0, 1);
lcd.print("Scan Your Card>>");
}En el bucle esperamos a que se escanee la nueva etiqueta. Después del escaneo, comparamos la ID de la etiqueta desconocida con la ID maestra. Si ambos coinciden, se concede el acceso; en caso contrario, se deniega el acceso.
void loop()
{
//Wait until new tag is available
while (getID())
{
lcd.clear();
lcd.setCursor(0, 0);
if (tagID == MasterTag)
{
lcd.print(" Access Granted!");
// You can write any code here like opening doors, switching on a relay, lighting up an LED, or anything else you can think of.
}
else
{
lcd.print(" Access Denied!");
}
lcd.setCursor(0, 1);
lcd.print(" ID : ");
lcd.print(tagID);
delay(2000);
lcd.clear();
lcd.print(" Access Control ");
lcd.setCursor(0, 1);
lcd.print("Scan Your Card>>");
}
}El código más importante aquí es este. getID() función personalizada. Una vez escaneada la nueva tarjeta, aparecerá dentro for Loop, convierte los 4 bytes del UID en una cadena y lo concatena en una sola cadena.
boolean getID()
{
// Getting ready for Reading PICCs
if ( ! mfrc522.PICC_IsNewCardPresent()) { //If a new PICC placed to RFID reader continue
return false;
}
if ( ! mfrc522.PICC_ReadCardSerial()) { //Since a PICC placed get Serial and continue
return false;
}
tagID = "";
for ( uint8_t i = 0; i < 4; i++) { // The MIFARE PICCs that we use have 4 byte UID
//readCard[i] = mfrc522.uid.uidByte[i];
tagID.concat(String(mfrc522.uid.uidByte[i], HEX)); // Adds the 4 bytes in a single String variable
}
tagID.toUpperCase();
mfrc522.PICC_HaltA(); // Stop reading
return true;
}¿Qué es la RFID?
La tecnología RFID o Identificación por Radiofrecuencia consiste en dos componentes principales, una etiqueta adherida al objeto que se desea identificar y un lector que lee la etiqueta. El lector genera un campo electromagnético de alta frecuencia, lo que alimenta el chip de la etiqueta. El chip responde enviando la información almacenada de vuelta al lector en forma de una señal de radio.
¿Cómo funciona?
El módulo lector/escritor RFID RC522 es una excelente opción para proyectos de Arduino basados en RFID. Es de bajo costo, bajo consumo, muy resistente, fácil de interfacear y extremadamente popular entre los aficionados. Funciona creando un campo electromagnético de 13.56MHz y se comunica con etiquetas RFID estándar ISO 14443A. Puede ser programado para generar una interrupción y alertar cuando una etiqueta se acerca a él.
Interfaz del módulo RFID RC522 con Arduino
El módulo RC522 RFID tiene 8 pines que se conectan al mundo exterior, entre ellos VCC para suministrar energía, RST para reset y apagado, GND para tierra, IRQ para interrupciones, MISO/SCL/Tx, MOSI, SCK para comunicación SPI, y SS/SDA/Rx para entrada de señales.
Especificaciones Técnicas
- Rango de Frecuencia: 13.56 MHz
- Interfaz de Host: SPI / I2C / UART
- Voltaje de Alimentación: 2.5V a 3.3V
- Corriente de Operación Máx.: 13-26mA
- Corriente Mínima (Apagado): 10µA
- Entradas Lógicas: Tolerantes a 5V
- Rango de Lectura: 5 cm
Conexión del Módulo RFID RC522 con Arduino
Para conectar el módulo con Arduino, se debe conectar VCC a 3.3V, GND a tierra, RST a un pin digital, y los pines de comunicación SPI a los pines correspondientes del Arduino. Es importante usar los pines de comunicación de hardware SPI para obtener el mejor rendimiento.
Instalación de Biblioteca
Para comunicarse con el módulo RC522, se recomienda instalar la biblioteca MFRC522, que simplifica la lectura y escritura de etiquetas RFID.
Código Arduino – Lectura de una Etiqueta RFID
El siguiente código muestra cómo leer una etiqueta RFID con el módulo RC522 y Arduino. Cuando se acerca una etiqueta, se muestra la información en el monitor serial. El código también muestra la organización de la memoria de la etiqueta MIFARE Classic 1K.
Código Arduino – Escritura en una Etiqueta RFID
Además de la lectura, es posible escribir en una etiqueta RFID. El código mencionado muestra cómo escribir datos personalizados en una etiqueta y leerlos de vuelta. Se debe tener cuidado al escribir en el bloque del fabricante para evitar bloqueos permanentes.
Proyecto Arduino – Sistema de Control de Acceso de Puerta basado en RFID
Finalmente, se presenta un proyecto que utiliza el módulo RC522 para crear un sistema de control de acceso de puerta. Si el ID de la etiqueta coincide con el ID maestro, se garantiza el acceso; de lo contrario, se niega. Este proyecto puede ser ampliado para controlar dispositivos como puertas, relés, luces, etc.
La RFID es como una especie de etiqueta para objetos, ¿no? ¡Interesante! Voy a intentar hacerlo con mi Arduino. ¡Gracias por la guía!