Caso práctico: cerradura RFID con Arduino UNO R3

Objetivo y caso de uso

Qué construirás: Un prototipo básico de cerradura de puerta controlada por RFID usando un Arduino UNO R3, lector RFID MFRC522 y relé de 1 canal. Cuando se detecta una tarjeta o llavero autorizado, el Arduino valida el UID y energiza el relé durante 2–5 segundos para accionar una cerradura eléctrica de pestillo, una interfaz de cerradura magnética o un circuito de cerradura de bajo voltaje.

Por qué importa / Casos de uso

Prototipo de acceso para pequeño taller o gabinete: Controla el acceso a un gabinete de herramientas, cajón de laboratorio o recinto de demostración para que solo las etiquetas RFID conocidas puedan desbloquearlo.
Demostrador conceptual de sistema de entrada: Practica el mismo flujo usado en sistemas más grandes: lectura de credencial, coincidencia de UID, desbloqueo temporizado y control de cerradura basado en relé.
Práctica de integración electromecánica: Combina detección RFID basada en SPI con una salida de relé, avanzando más allá de proyectos solo con LED hacia conmutación real de actuadores.
Resolución de problemas y auditoría con monitor serie: Imprime los UID detectados y eventos de permitir/denegar por serie a 9600 baudios para depuración rápida y registros básicos de acceso durante las pruebas.

Resultado esperado

Una tarjeta RFID se detecta y compara normalmente en menos de 200 ms desde su presentación hasta la decisión.
El relé se activa durante una ventana de desbloqueo configurable, comúnmente de 3 segundos, y luego vuelve automáticamente al estado bloqueado.
Las etiquetas no autorizadas se rechazan de inmediato, mostrando el UID en el Monitor Serie para registro o diagnóstico.
El prototipo funciona cómodamente en el ATmega328P de 16 MHz del UNO con baja carga de CPU y sin requerimiento de GPU.

Audiencia: principiantes en Arduino, estudiantes y personas aprendiendo sistemas embebidos/electrónica que construyen demostraciones de control de acceso; Nivel: principiante a intermedio

Arquitectura/flujo: El MFRC522 lee el UID de la etiqueta por SPI → Arduino UNO compara el UID con una lista autorizada en el código → si coincide, una salida digital activa el relé de 1 canal → el relé acciona la interfaz de cerradura durante un intervalo temporizado → el Monitor Serie informa el estado de permitir/denegar y los valores UID.

Nota educativa de validación

Antes de la publicación, este caso pasó la compuerta de validación automatizada de Prometeo con estado PASS. El validador comprobó los bloques de código, la estructura del artículo, los comandos seguros para copiar/pegar y la coherencia con el catálogo de dispositivos compatibles.

Evidencia de validación publicada

Resultado automático: PASS.
Estructura analizada: 3 secciones, 1 tablas y 24 bloques de código detectados antes de la publicación.
Código comprobado: 7 comprobaciones estáticas de C/C++, 12 comprobaciones de Bash/copiar-pegar.
Catálogo compatible: el texto del artículo fue verificado contra los perfiles de dispositivos con capacidad de validación de Prometeo, y las pilas no compatibles bloquean la publicación.
Hallazgos del informe: sin hallazgos bloqueantes.

Esta validación confirma la compatibilidad de sintaxis y herramientas del material publicado, pero no sustituye las pruebas físicas en tu hardware, cableado y entorno de ejecución exactos.

Nota educativa de seguridad

Este prototipo es para aprendizaje educativo de control de acceso de bajo voltaje. No es un producto de seguridad certificado y no debe considerarse la única protección para hogares, negocios, áreas peligrosas o salidas de seguridad vital.

Límites y precauciones importantes:

No conmutas tensión de red directamente a menos que estés capacitado y uses hardware y prácticas de encapsulado correctamente dimensionados.
Para uso estudiantil, valida primero el relé con una carga segura de bajo voltaje.
La autorización RFID basada solo en UID es una seguridad débil.
Muchas etiquetas RFID de bajo costo pueden clonarse, y verificar solo el UID no es lo bastante seguro para protección seria.
Importa el voltaje del módulo MFRC522.
El lector es un dispositivo de 3.3 V. Revisa la tolerancia lógica de tu módulo específico antes de conectarlo a líneas SPI de Arduino de 5 V.
Las cerraduras eléctricas reales pueden requerir alimentación y protección separadas.
Sigue los requisitos de corriente, voltaje y supresión del fabricante de la cerradura.
No uses este proyecto para puertas de evacuación de emergencia ni cerraduras críticas para la seguridad.
Un fallo de software, fallo del relé, pérdida de alimentación o defecto de cableado podría impedir el funcionamiento esperado.
Monta y aísla el cableado correctamente.
Los cables sueltos pueden causar reinicios, activaciones falsas o módulos dañados.

Diagrama de bloques conceptual

Vista de alto nivel: qué entra, qué procesa cada bloque y qué sale del sistema.

Arquitectura funcional

El MFRC522 lee el UID de la etiqueta por SPI

Arduino UNO compara el UID con una lista…

si coincide, una salida digital activa el…

el relé acciona la interfaz de cerradura…

el Monitor Serie informa el estado de per…

Flujo conceptual de señales y responsabilidades entre bloques del dispositivo.

Ruta de validación

Sketch

arduino-cli compile

Upload

Prueba funcional

Resumen conceptual de las herramientas usadas para comprobar el material publicado.

Requisitos previos

Antes de comenzar, deberías sentirte cómodo con:

Subir un sketch a un Arduino UNO
Abrir el Monitor Serie
Hacer conexiones simples con cables jumper en una protoboard o encabezados de módulos
Entender que un relé es un interruptor controlado eléctricamente

No necesitas experiencia previa con RFID. Este tutorial explica lo mínimo necesario para hacer un prototipo de control de acceso utilizable.

Materiales

Usa la familia y modelo exactos de dispositivo solicitados:

Arduino UNO R3 (ATmega328P) + módulo RFID MFRC522 + módulo de relé de 1 canal

Lista completa de piezas recomendada:

1 x Arduino UNO R3 (ATmega328P)
1 x módulo lector RFID MFRC522 con tarjeta RFID o llavero compatible
1 x módulo de relé de 1 canal
Prefiere un módulo con controlador por transistor y optoaislamiento o protección flyback integrada
El lado de la bobina normalmente se alimenta con 5 V
Cables jumper
Cable USB para Arduino UNO
Protoboard o superficie de cableado estable
Opcional pero muy recomendable para pruebas visibles:
1 x LED
1 x resistencia de 220 ohm
Carga educativa opcional del lado de la cerradura:
Lámpara de bajo voltaje, indicador LED o pequeña carga DC controlada a través de los contactos del relé
Si más adelante conectas una cerradura eléctrica de pestillo real o una interfaz de cerradura magnética, usa la fuente de alimentación externa recomendada por el fabricante de la cerradura

Configuración/Conexión

Cómo funciona el sistema

El MFRC522 lee el UID de una etiqueta RFID cercana por SPI.
El Arduino compara ese UID con una pequeña lista de UID autorizados almacenada en el sketch.
Si el UID coincide, el Arduino acciona la entrada del módulo de relé durante un breve tiempo.
Los contactos del relé pueden entonces conmutar un circuito de cerradura separado o una carga educativa de prueba.

Nota importante de voltaje antes del cableado

El lector MFRC522 es un dispositivo de 3.3 V. La mayoría de las placas breakout comunes exponen pines etiquetados como SDA, SCK, MOSI, MISO, RST, 3.3V y GND. En tutoriales típicos para aficionados, el módulo se alimenta desde 3.3 V, mientras que las líneas SPI se conectan directamente al UNO. Muchos estudiantes lo hacen con éxito en la práctica, pero eléctricamente el UNO entrega lógica de 5 V. Si tu placa MFRC522 no tolera 5 V en los pines lógicos, usa adaptación de nivel adecuada. Para una construcción educativa básica, sigue el patrón de uso común del módulo solo si se sabe que tu módulo específico funciona así.

Asignación de pines

Usa el cableado SPI común de MFRC522 a UNO y un pin digital para el relé.

Módulo/Señal	Pin de Arduino UNO R3	Notas
MFRC522 SDA / SS	D10	Selección de esclavo SPI
MFRC522 SCK	D13	Reloj SPI
MFRC522 MOSI	D11	SPI MOSI
MFRC522 MISO	D12	SPI MISO
MFRC522 RST	D9	Pin de reinicio del lector
MFRC522 3.3V	3.3V	No uses 5V para alimentar el lector
MFRC522 GND	GND	Tierra común
Relay IN	D7	Señal de control del relé
Relay VCC	5V	Alimentación típica del módulo de relé
Relay GND	GND	Tierra común
Ánodo del LED opcional mediante resistencia de 220 ohm	D6	Indicador de estado
Cátodo del LED opcional	GND	Retorno del LED

Pasos de conexión solo texto

Apaga el Arduino antes de hacer o cambiar el cableado.
Conecta el MFRC522:
MFRC522 3.3V -> UNO 3.3V
MFRC522 GND -> UNO GND
MFRC522 SDA/SS -> UNO D10
MFRC522 SCK -> UNO D13
MFRC522 MOSI -> UNO D11
MFRC522 MISO -> UNO D12
MFRC522 RST -> UNO D9
Conecta el módulo de relé:
Relay VCC -> UNO 5V
Relay GND -> UNO GND
Relay IN -> UNO D7
LED de estado visible opcional:
UNO D6 -> resistencia de 220 ohm
Resistencia -> ánodo del LED
Cátodo del LED -> GND
Si pruebas los contactos del relé con una carga segura de bajo voltaje:
Usa COM y NO del relé para “normalmente apagado, encendido solo cuando se desbloquea”
Cablea la ruta de alimentación de bajo voltaje a través de COM y NO
Mantén el circuito conmutado eléctricamente adecuado para las especificaciones del relé y el diseño del módulo

Concepto de contactos del relé

El módulo de relé tiene dos lados:

Lado de control
VCC, GND, IN
Conectado al Arduino
Lado de conmutación
COM, NO, NC
Conectado al circuito de cerradura o carga de prueba

Para una acción de desbloqueo de puerta, COM + NO suele ser lo más simple:
– En reposo: circuito abierto
– Tarjeta autorizada: el relé conecta COM a NO durante unos segundos

Código validado

Sketch de Arduino: `rfid_door_lock_relay.ino`

Vista pública parcial del archivo validado. El código completo se muestra a miembros y en PDF/Print.

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

static const uint8_t SS_PIN = 10;
static const uint8_t RST_PIN = 9;
static const uint8_t RELAY_PIN = 7;
static const uint8_t STATUS_LED_PIN = 6;

// Many relay modules are ACTIVE LOW.
// Set to true if your relay turns on when the Arduino pin goes LOW.
// Set to false if your relay turns on when the Arduino pin goes HIGH.
static const bool RELAY_ACTIVE_LOW = true;

// Unlock timing in milliseconds
static const unsigned long UNLOCK_TIME_MS = 3000;

// Example authorized UIDs.
// Replace these with the UIDs printed by your own cards during enrollment/testing.
const byte AUTHORIZED_UIDS[][4] = {
  {0xDE, 0xAD, 0xBE, 0xEF},
  {0x12, 0x34, 0x56, 0x78}
};
const size_t AUTHORIZED_UID_COUNT = sizeof(AUTHORIZED_UIDS) / sizeof(AUTHORIZED_UIDS[0]);

MFRC522 mfrc522(SS_PIN, RST_PIN);

bool relayActive = false;
unsigned long relayActivatedAt = 0;
String lastUidString = "";
unsigned long lastScanAt = 0;

// Ignore repeated reads of the same card within this time window
static const unsigned long SAME_CARD_DEBOUNCE_MS = 1500;

void setRelay(bool on) {
  relayActive = on;

  if (RELAY_ACTIVE_LOW) {
    digitalWrite(RELAY_PIN, on ? LOW : HIGH);
  } else {
    digitalWrite(RELAY_PIN, on ? HIGH : LOW);
  }

  digitalWrite(STATUS_LED_PIN, on ? HIGH : LOW);
}

void printUid(const MFRC522::Uid *uid) {
  for (byte i = 0; i < uid->size; i++) {
    if (uid->uidByte[i] < 0x10) {
      Serial.print("0");
    }
    Serial.print(uid->uidByte[i], HEX);
    if (i < uid->size - 1) {
      Serial.print(":");
    }
  }
}

String uidToString(const MFRC522::Uid *uid) {
  String s = "";
  for (byte i = 0; i < uid->size; i++) {
    if (uid->uidByte[i] < 0x10) {
      s += "0";
    }
    s += String(uid->uidByte[i], HEX);
    if (i < uid->size - 1) {
      s += ":";
    }
  }
  s.toUpperCase();
  return s;
}

bool isAuthorized(const MFRC522::Uid *uid) {
  // This basic example checks only 4-byte UIDs against a fixed list.
  if (uid->size != 4) {
    return false;
  }

  for (size_t i = 0; i < AUTHORIZED_UID_COUNT; i++) {
    bool match = true;
    for (byte j = 0; j < 4; j++) {
      if (uid->uidByte[j] != AUTHORIZED_UIDS[i][j]) {
        match = false;
        break;
      }
// ...

    }
    if (match) {
      return true;
    }
  }
  return false;
}

void handleAuthorizedCard() {
  setRelay(true);
  relayActivatedAt = millis();
  Serial.print("ACCESS GRANTED - relay ON for ");
  Serial.print(UNLOCK_TIME_MS);
  Serial.println(" ms");
}

void setup() {
  pinMode(RELAY_PIN, OUTPUT);
  pinMode(STATUS_LED_PIN, OUTPUT);

  setRelay(false);

  Serial.begin(9600);
  while (!Serial) {
    ; // UNO usually continues immediately
  }

  SPI.begin();

🔒 Este contenido es premium. Con la suscripción mensual (7 días gratis) podrás desbloquear el material didáctico completo y el pack PDF listo para imprimir.🔓 Desbloquéalo — 7 días gratis

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

static const uint8_t SS_PIN = 10;
static const uint8_t RST_PIN = 9;
static const uint8_t RELAY_PIN = 7;
static const uint8_t STATUS_LED_PIN = 6;

// Many relay modules are ACTIVE LOW.
// Set to true if your relay turns on when the Arduino pin goes LOW.
// Set to false if your relay turns on when the Arduino pin goes HIGH.
static const bool RELAY_ACTIVE_LOW = true;

// Unlock timing in milliseconds
static const unsigned long UNLOCK_TIME_MS = 3000;

// Example authorized UIDs.
// Replace these with the UIDs printed by your own cards during enrollment/testing.
const byte AUTHORIZED_UIDS[][4] = {
  {0xDE, 0xAD, 0xBE, 0xEF},
  {0x12, 0x34, 0x56, 0x78}
};
const size_t AUTHORIZED_UID_COUNT = sizeof(AUTHORIZED_UIDS) / sizeof(AUTHORIZED_UIDS[0]);

MFRC522 mfrc522(SS_PIN, RST_PIN);

bool relayActive = false;
unsigned long relayActivatedAt = 0;
String lastUidString = "";
unsigned long lastScanAt = 0;

// Ignore repeated reads of the same card within this time window
static const unsigned long SAME_CARD_DEBOUNCE_MS = 1500;

void setRelay(bool on) {
  relayActive = on;

  if (RELAY_ACTIVE_LOW) {
    digitalWrite(RELAY_PIN, on ? LOW : HIGH);
  } else {
    digitalWrite(RELAY_PIN, on ? HIGH : LOW);
  }

  digitalWrite(STATUS_LED_PIN, on ? HIGH : LOW);
}

void printUid(const MFRC522::Uid *uid) {
  for (byte i = 0; i < uid->size; i++) {
    if (uid->uidByte[i] < 0x10) {
      Serial.print("0");
    }
    Serial.print(uid->uidByte[i], HEX);
    if (i < uid->size - 1) {
      Serial.print(":");
    }
  }
}

String uidToString(const MFRC522::Uid *uid) {
  String s = "";
  for (byte i = 0; i < uid->size; i++) {
    if (uid->uidByte[i] < 0x10) {
      s += "0";
    }
    s += String(uid->uidByte[i], HEX);
    if (i < uid->size - 1) {
      s += ":";
    }
  }
  s.toUpperCase();
  return s;
}

bool isAuthorized(const MFRC522::Uid *uid) {
  // This basic example checks only 4-byte UIDs against a fixed list.
  if (uid->size != 4) {
    return false;
  }

  for (size_t i = 0; i < AUTHORIZED_UID_COUNT; i++) {
    bool match = true;
    for (byte j = 0; j < 4; j++) {
      if (uid->uidByte[j] != AUTHORIZED_UIDS[i][j]) {
        match = false;
        break;
      }
    }
    if (match) {
      return true;
    }
  }
  return false;
}

void handleAuthorizedCard() {
  setRelay(true);
  relayActivatedAt = millis();
  Serial.print("ACCESS GRANTED - relay ON for ");
  Serial.print(UNLOCK_TIME_MS);
  Serial.println(" ms");
}

void setup() {
  pinMode(RELAY_PIN, OUTPUT);
  pinMode(STATUS_LED_PIN, OUTPUT);

  setRelay(false);

  Serial.begin(9600);
  while (!Serial) {
    ; // UNO usually continues immediately
  }

  SPI.begin();
  mfrc522.PCD_Init();

  delay(50);

  Serial.println();
  Serial.println("RFID Door Lock Relay Prototype");
  Serial.println("Present a card/tag to the MFRC522 reader.");
  Serial.println("Known 4-byte UIDs will activate the relay.");
}

void loop() {
  // Turn relay off after unlock period
  if (relayActive && (millis() - relayActivatedAt >= UNLOCK_TIME_MS)) {
    setRelay(false);
    Serial.println("Relay OFF - lock returned to idle state");
  }

  // No new card
  if (!mfrc522.PICC_IsNewCardPresent()) {
    return;
  }

  // Unable to read card serial
  if (!mfrc522.PICC_ReadCardSerial()) {
    return;
  }

  String currentUid = uidToString(&mfrc522.uid);
  unsigned long now = millis();

  // Debounce repeated scans of the same card
  if (currentUid == lastUidString && (now - lastScanAt < SAME_CARD_DEBOUNCE_MS)) {
    mfrc522.PICC_HaltA();
    mfrc522.PCD_StopCrypto1();
    return;
  }

  lastUidString = currentUid;
  lastScanAt = now;

  Serial.print("Card detected. UID=");
  printUid(&mfrc522.uid);
  Serial.println();

  if (isAuthorized(&mfrc522.uid)) {
    handleAuthorizedCard();
  } else {
    Serial.println("ACCESS DENIED - unauthorized card");
  }

  mfrc522.PICC_HaltA();
  mfrc522.PCD_StopCrypto1();
}

Instalación de dependencia de biblioteca

La biblioteca MFRC522 no forma parte del núcleo estándar integrado de Arduino, así que instálala explícitamente con Arduino CLI.

arduino-cli lib install "MFRC522"

Comandos de compilación/flash/ejecución

Los siguientes comandos coinciden con el flujo de trabajo requerido de Arduino CLI para Arduino UNO R3.

1) Actualizar el índice de placas

arduino-cli core update-index

2) Instalar el núcleo AVR

arduino-cli core install arduino:avr

3) Instalar la biblioteca RFID

arduino-cli lib install "MFRC522"

4) Crear la carpeta del sketch

Directorio de ejemplo:

mkdir -p rfid-door-lock-relay

Guarda el sketch como:

rfid-door-lock-relay/rfid_door_lock_relay.ino

5) Compilar

Ejecuta esto desde el directorio padre de la carpeta del sketch, o especifica la ruta completa.

arduino-cli compile --fqbn arduino:avr:uno rfid-door-lock-relay

6) Encontrar tu puerto serie

En Linux:

arduino-cli board list

En Windows, el puerto puede aparecer como COM3, COM4, etc.
En Linux, algo como /dev/ttyACM0 o /dev/ttyUSB0.
En macOS, algo como /dev/cu.usbmodem....

7) Subir

Reemplaza <PORT> por tu puerto detectado real.

arduino-cli upload --fqbn arduino:avr:uno --port <PORT> rfid-door-lock-relay

8) Abrir el monitor serie

arduino-cli monitor --port <PORT> --config baudrate=9600

Validación paso a paso

Esta sección te ayuda a demostrar que el prototipo se comporta como se pretende.

1. Validar la etapa de compilación

Objetivo:
– Confirmar que la sintaxis del sketch, la placa objetivo y la biblioteca instalada son correctas.

Procedimiento:
1. Ejecuta:
bash arduino-cli compile --fqbn arduino:avr:uno rfid-door-lock-relay
2. Resultado esperado:
– La compilación se completa correctamente.
– No hay errores de biblioteca faltante para MFRC522.h.

Qué valida esto:
– El código es estructuralmente válido para Arduino UNO.
– La dependencia de biblioteca está correctamente instalada.

Qué no valida esto:
– Cableado
– Legibilidad de la tarjeta
– Polaridad del relé
– Compatibilidad de la cerradura física

2. Validar el comportamiento de arranque en reposo

Objetivo:
– Confirmar que la placa arranca y el relé comienza en el estado bloqueado/en reposo.

Procedimiento:
1. Sube el sketch.
2. Abre el monitor serie a 9600 baudios.
3. Reinicia la placa si es necesario.

Patrón de registro esperado:

RFID Door Lock Relay Prototype
Present a card/tag to the MFRC522 reader.
Known 4-byte UIDs will activate the relay.

Comportamiento de hardware esperado:
– El relé debe estar en reposo, no energizado continuamente.
– El LED opcional debe estar apagado.

Si el relé está ENCENDIDO en reposo:
– Tu módulo puede usar lógica de entrada opuesta.
– Cambia:
cpp static const bool RELAY_ACTIVE_LOW = true;
a:
cpp static const bool RELAY_ACTIVE_LOW = false;
– Vuelve a compilar y subir.

3. Descubrir el UID de tu tarjeta

Objetivo:
– Leer el UID real de tu tarjeta RFID o llavero.

Procedimiento:
1. Presenta una tarjeta al lector.
2. Observa el monitor serie.

Ejemplo de salida esperada:

Card detected. UID=93:4A:1C:7F
ACCESS DENIED - unauthorized card

Registra el UID exactamente.

Notas:
– El ejemplo de código proporcionado autoriza solo UID de 4 bytes.
– Muchas tarjetas MIFARE comunes funcionan así, pero algunas etiquetas pueden tener longitudes de UID diferentes.
– Para un proyecto básico, usa una tarjeta con UID de 4 bytes si es posible.

4. Agregar tu UID autorizado real

Objetivo:
– Hacer que tu tarjeta desbloquee el relé.

Procedimiento:
1. Edita esta sección:
cpp const byte AUTHORIZED_UIDS[][4] = { {0xDE, 0xAD, 0xBE, 0xEF}, {0x12, 0x34, 0x56, 0x78} };
2. Reemplaza una línea con los bytes UID reales.
Ejemplo, si el monitor mostró 93:4A:1C:7F:
cpp const byte AUTHORIZED_UIDS[][4] = { {0x93, 0x4A, 0x1C, 0x7F} };
3. Vuelve a compilar y subir.

5. Validar acceso exitoso

Objetivo:
– Confirmar que una tarjeta autorizada activa el relé durante la duración configurada.

Procedimiento:
1. Presenta la tarjeta autorizada una vez.
2. Observa la salida serie.
3. Escucha el clic del relé y observa el LED opcional.

Salida esperada:

Card detected. UID=93:4A:1C:7F
ACCESS GRANTED - relay ON for 3000 ms
Relay OFF - lock returned to idle state

Comportamiento medible esperado:
– El relé se activa una vez
– El relé permanece activo alrededor de 3 segundos
– El relé vuelve al reposo automáticamente

6. Validar acceso denegado

Objetivo:
– Asegurarse de que una tarjeta no listada no desbloquee.

Procedimiento:
1. Presenta una tarjeta RFID o llavero diferente.
2. Observa el monitor serie.

Salida esperada:

Card detected. UID=11:22:33:44
ACCESS DENIED - unauthorized card

Comportamiento de hardware esperado:
– Sin acción de desbloqueo del relé
– El LED opcional permanece apagado

7. Validar el manejo de lecturas repetidas

Objetivo:
– Confirmar que la misma tarjeta sostenida cerca del lector no vuelva a dispararse rápidamente.

Procedimiento:
1. Mantén una tarjeta autorizada sobre el lector continuamente.
2. Observa el comportamiento durante unos segundos.

Resultado esperado:
– Debe ocurrir un evento de desbloqueo.
– La ventana de antirrebote evita el re-disparo repetido inmediato de la misma lectura.

Solución de problemas

El lector RFID no detecta ninguna tarjeta

Comprueba:

MFRC522 alimentado desde 3.3 V, no 5 V
Los pines SPI son exactamente:
D10 -> SDA/SS
D11 -> MOSI
D12 -> MISO
D13 -> SCK
D9 -> RST
La tarjeta es compatible con la frecuencia y el tipo del lector MFRC522
Las tierras son comunes entre todos los módulos

Síntoma:
– No hay mensajes de UID en absoluto en el Monitor Serie

Causas probables:
– Cableado SPI incorrecto
– Biblioteca faltante poco probable si el código ya se subió
– Problema de alimentación del lector
– Mal contacto de jumper

El relé permanece encendido todo el tiempo

Causa probable:
– La polaridad del módulo de relé es opuesta a la configuración de tu código

Corrección:
– Cambia:
cpp static const bool RELAY_ACTIVE_LOW = true;
a:
cpp static const bool RELAY_ACTIVE_LOW = false;
– Vuelve a compilar y subir

La tarjeta autorizada sigue apareciendo como denegada

Comprueba:

Bytes UID copiados correctamente
Los valores hexadecimales incluyen 0x
La tarjeta tiene UID de 4 bytes
Volviste a subir después de editar

La salida serie muestra el UID en minúsculas o con estilo mixto

Eso está bien siempre que los valores de bytes sean correctos. La lógica de coincidencia usa bytes sin procesar, no el formato impreso.

El relé hace clic pero tu cerradura o carga de prueba no se activa

Comprueba el lado de conmutación:

¿Estás usando COM y NO?
¿Está presente la fuente externa de bajo voltaje?
¿Está completo el circuito de carga a través de los contactos del relé?
¿Está la carga dentro de la corriente/voltaje nominal del relé?

El Arduino se reinicia cuando conmuta el relé

Posibles razones:

La alimentación USB es débil
El módulo de relé causa ruido o caída de suministro
El cableado está demasiado suelto o es demasiado largo

Prueba:

Cables más cortos
Mejor fuente de 5 V para el módulo de relé si corresponde
Asegúrate de que la tierra común sea sólida
Prueba primero solo con el módulo de relé, luego agrega la carga del lado de la cerradura

Mejoras

Una vez que el prototipo básico funcione, estos son pasos siguientes útiles:

Agregar LED de estado separados

Usa:
– LED verde para acceso concedido
– LED rojo para acceso denegado

Esto mejora la usabilidad sin necesidad del Monitor Serie.

Agregar un zumbador

Un pitido corto para acceso válido y un patrón diferente para acceso denegado hace que el sistema se sienta más realista.

Agregar modo de registro

En lugar de codificar los UID directamente, podrías:
– pulsar un botón,
– escanear una tarjeta maestra,
– almacenar nuevos UID en EEPROM.

Eso haría el prototipo más práctico.

Agregar un sensor de puerta

Un interruptor magnético reed puede detectar si la puerta realmente se abrió o permaneció abierta demasiado tiempo.

Mejorar la lógica de seguridad

Este proyecto verifica solo el UID de la tarjeta. Para un sistema más realista, podrías explorar:
– conceptos de autenticación por sector,
– tarjetas maestras/admin,
– ideas de anti-passback,
– registro de eventos en almacenamiento externo.

Agregar un temporizador de bloqueo

Después de varios intentos denegados, el sistema podría ignorar escaneos durante 30 segundos y parpadear un LED de advertencia.

Lista de verificación final

Usa esta lista de verificación antes de dar el proyecto por terminado:

[ ] Arduino UNO R3 está cableado correctamente
[ ] MFRC522 está alimentado desde 3.3 V
[ ] El módulo de relé está cableado a D7, 5V y GND
[ ] Existe tierra común entre Arduino, módulo RFID y módulo de relé
[ ] El sketch está guardado como rfid_door_lock_relay.ino
[ ] La biblioteca MFRC522 está instalada con Arduino CLI
[ ] El proyecto compila con:
bash arduino-cli compile --fqbn arduino:avr:uno rfid-door-lock-relay
[ ] El proyecto se sube con:
bash arduino-cli upload --fqbn arduino:avr:uno --port <PORT> rfid-door-lock-relay
[ ] El Monitor Serie a 9600 baudios muestra el texto de inicio
[ ] Una tarjeta desconocida produce ACCESS DENIED
[ ] Una tarjeta autorizada produce ACCESS GRANTED
[ ] El relé se activa durante aproximadamente 3000 ms
[ ] El relé vuelve al reposo automáticamente
[ ] La carga de prueba de bajo voltaje conmuta correctamente a través de los contactos del relé
[ ] Entiendes que este es un prototipo educativo, no un sistema de seguridad certificado

Con eso, tienes un prototipo práctico de relé de cerradura de puerta RFID que un principiante puede realmente montar, probar y ampliar hacia un proyecto de control de acceso más realista.

Encuentra este producto y/o libros sobre este tema en Amazon

Ir a Amazon

Como afiliado de Amazon, gano con las compras que cumplan los requisitos. Si compras a través de este enlace, ayudas a mantener este proyecto.

Carlos Núñez Zorrilla

Electronics & Computer Engineer

Ingeniero Superior en Electrónica de Telecomunicaciones e Ingeniero en Informática (titulaciones oficiales en España).

Sígueme:

¿Quiénes somos?