Mis Apuntes RFID – entrada 2

En la entrada anterior vimos qué es la tecnología RFID, sus principales frecuencias (LF, HF, UHF) y qué tipo de aplicaciones tiene cada una. Ahora vamos a dar un paso adelante: nos adentraremos en una tecnología muy común dentro de la categoría de alta frecuencia (HF) —13.56 MHz—, usando el lector más popular amateur, el módulo RC522, y las tarjetas conocidas como MIFARE Classic. Veremos cómo funcionan ambos, qué “traen por dentro” esas tarjetas y cómo puedes empezar a interactuar con ellas.

¿Qué es el módulo RC522?

El RC522 es un lector/escritor de RFID que trabaja en 13.56 MHz (alta frecuencia). Está diseñado para usarse fácilmente con microcontroladores como el Arduino, gracias a su interfaz SPI. En su interior encontramos un chip MFRC522 junto con una pequeña antena de cobre, que permite generar un campo electromagnético para comunicarse con tarjetas pasivas. El lector genera ese campo, la tarjeta lo recibe, se “despierta” y puede intercambiar datos con el lector.

Este módulo es muy popular porque es económico, accesible, bien documentado y ampliamente usado en proyectos de hobby, educación y prototipos.

¿Qué tipo de tarjetas usa este lector?

Generalmente las tarjetas que funcionan con el RC522 son de tipo HF, basadas en el estándar MIFARE Classic (por ejemplo 1K). Estas tarjetas:

  • Operan a 13.56 MHz.
  • Son pasivas (no llevan batería; se alimentan del campo del lector).
  • Tienen memoria interna que puede leerse y escribirse (a diferencia de muchas de LF simples).
  • Permiten usar claves de seguridad (Key A y Key B) para proteger sectores de memoria.

Son muy usadas en control de acceso, transporte público, credenciales escolares, monederos electrónicos y demás.

¿Qué tienen dentro las tarjetas MIFARE Classic?

Para entender lo que “vemos” cuando usamos el ejemplo de código del RC522, conviene conocer su estructura interna:

Ejemplo real: en mis pruebas, la mayoría de los bloques de datos estaban llenos de 00 00 00 …, lo que significa que estaban vacíos. En el bloque 0 encontré algo así como 53 DA 33 29 93 08 04 00 62 63 64 65 66 67 68 69, lo que corresponde a UID + datos de fábrica + algunos bytes “libres”.

  • Una antena en espiral, que capta el campo electromagnético del lector.
  • Un microchip que gestiona la energía, la comunicación, las claves de seguridad y la memoria.
  • La memoria está organizada en “sectores” y “bloques”:
  • En una tarjeta de 1 KB tienes 16 sectores.
  • Cada sector tiene 4 bloques.
  • Cada bloque tiene 16 bytes de datos.
  • El último bloque de cada sector es el “bloque tráiler”: contiene la Key A, los Access bits (bits de permiso) y la Key B.
  • Ejemplo real: en mis pruebas, la mayoría de los bloques de datos estaban llenos de 00 00 00 …, lo que significa que estaban vacíos. En el bloque 0 encontré algo así como 53 DA 33 29 93 08 04 00 62 63 64 65 66 67 68 69, lo que corresponde a UID + datos de fábrica + algunos bytes “libres”.

¿Qué hace el lector cuando acercas la tarjeta?

Para que quede muy claro, imaginemos paso a paso lo que ocurre:

  1. El lector envía un campo electromagnético en 13.56 MHz.
  2. La tarjeta entra en ese campo, se alimenta y se activa.
  3. La tarjeta envía su UID al lector.
  4. El lector puede enviar un comando de autenticación para un sector (usando Key A o Key B).
  5. Si la clave es correcta, el lector puede leer o escribir datos en los bloques de ese sector.
  6. Esos datos los muestra en el monitor serie o los descarga al sistema que estés usando.

¿Qué es el UID y por qué importa?

El UID (Unique Identifier) es un identificador único de la tarjeta. Está grabado de fábrica, no se puede cambiar (o al menos no fácilmente en tarjetas estándar).
Cuando acercas la tarjeta al lector, una de las primeras respuestas que obtienes es ese UID. En el bloque 0 de la tarjeta suele aparecer en los primeros bytes.
Ese identificador lo puedes usar para “saber quién es” la tarjeta: por ejemplo, vincularlo a un usuario, asignarle un saldo o permitirle el acceso.

Probando el lector: código básico

Este ejemplo de la librería MFRC522 sirve para leer toda la información disponible dentro de una tarjeta RFID MIFARE Classic. Cuando acercas la tarjeta al lector, el código:

  1. Detecta la tarjeta y obtiene su UID (el identificador único).
  2. Identifica el tipo de tarjeta.
  3. Recorre todos los sectores y bloques de la memoria interna.
  4. Intenta autenticarse usando las claves por defecto y, si lo logra, muestra los 16 bytes de cada bloque en formato hexadecimal.
  5. También muestra los bits de acceso, indicando si un bloque es normal o si es un bloque tráiler (el que contiene las claves y permisos del sector).

En resumen, este código te permite ver exactamente qué hay guardado dentro de tu tarjeta, cómo está organizada su memoria y si los bloques están vacíos, protegidos o contienen datos útiles. Es la herramienta ideal para entender la estructura interna de una tarjeta MIFARE antes de empezar a escribir tus propios datos.

C
#include <SPI.h>
#include <MFRC522.h>

#define RST_PIN         9          // Configurable, see typical pin layout above
#define SS_PIN          10         // Configurable, see typical pin layout above

MFRC522 mfrc522(SS_PIN, RST_PIN);  // Create MFRC522 instance

void setup() {
	Serial.begin(9600);		// Initialize serial communications with the PC
	while (!Serial);		// Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
	SPI.begin();			// Init SPI bus
	mfrc522.PCD_Init();		// Init MFRC522
	delay(4);				// Optional delay. Some board do need more time after init to be ready, see Readme
	mfrc522.PCD_DumpVersionToSerial();	// Show details of PCD - MFRC522 Card Reader details
	Serial.println(F("Scan PICC to see UID, SAK, type, and data blocks..."));
}

void loop() {
	// Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle.
	if ( ! mfrc522.PICC_IsNewCardPresent()) {
		return;
	}

	// Select one of the cards
	if ( ! mfrc522.PICC_ReadCardSerial()) {
		return;
	}

	// Dump debug info about the card; PICC_HaltA() is automatically called
	mfrc522.PICC_DumpToSerial(&(mfrc522.uid));
}

Ejemplo real: dump del Monitor Serie

Cómo interpreta Arduino los bloques

Cuando usamos el ejemplo de la librería MFRC522, el código “dump” que imprime hace lo siguiente:

  • Recorre todos los sectores y bloques de la tarjeta (si la clave lo permite).
  • Para cada bloque imprime los 16 bytes en HEX.
  • Al final de cada línea suele aparecer algo como [ 0 0 0 ] o [ 0 0 1 ]. Esos corchetes resumen los bits de acceso decodificados.
    • Bloques normales de datos suelen tener [ 0 0 0 ].
    • Bloques tráiler (con claves y permisos) suelen tener [ 0 0 1 ].

Gracias a ello puedes darte cuenta de qué bloques están ocupados, cuáles están vacíos, cuáles son tráiler y cuáles datos útiles para tu proyecto.

Aquí un dump de ejemplo que muestra el monitor serie

Para qué sirve cada parte si quieres hacer un proyecto

Ahora que ya sabes qué contiene la tarjeta y qué hace el lector, veamos cómo puedes aprovecharlo:

  • El UID puede servir como identificador del usuario o del dispositivo.
  • Los bloques de datos pueden servir para almacenar saldo, ID interno, fecha de última recarga, nombre, etc.
  • Los bloques tráiler con sus claves permiten que nadie modifique los datos sin autorización. Así aseguras tu sistema.
  • Puedes decidir:
    • Guardar la mayor parte de los datos en la tarjeta (modo autónomo).
    • O usar la tarjeta solo para identificarse y guardar los datos reales en una base de datos externa.
    • O un híbrido: parte en tarjeta, parte en servidor.

Conclusión

Hemos visto qué es el módulo RC522 y cómo funciona junto con las tarjetas MIFARE Classic, qué contienen por dentro, cómo se estructuran y qué proceso sigue el lector al leerlas.
Ahora ya tienes las bases para empezar a experimentar.
En la próxima entrada veremos cómo escribir datos en la tarjeta, cómo cambiar las claves A/B para protegerla y que tipos de proyectos pueden existir.

Entradas relacionadas