Control de Acceso: RFID, LCD y Buzzer

El siguiente proyecto de electrónica propone la construcción de un sistema de control de acceso simplificado utilizando tres módulos fundamentales: el lector RFID RC522 para la identificación, un LCD 16×2 con interfaz I2C para la retroalimentación visual, y un Buzzer Pasivo para las alertas sonoras. Este sistema distingue entre dos identificadores (una tarjeta y un llavero) para simular el acceso permitido y denegado.

🔩Funcionamiento

El Poder de I2C en la LCD

Tradicionalmente, las pantallas LCD 16×2 requerían hasta 12 cables para funcionar en modo de 4 bits, consumiendo la mayoría de los pines digitales del Arduino. La interfaz I2C (Inter-Integrated Circuit) resuelve esto a través de un pequeño adaptador que contiene un chip (a menudo un PCF8574).

• Principio: I2C es un protocolo de comunicación serial de dos hilos (SDA y SCL) que permite que múltiples dispositivos (‘esclavos’) se comuniquen con un ‘maestro’ (el Arduino) utilizando solo esos dos pines.
• Ventaja: En este proyecto, el uso de I2C libera los pines Digitales 2 al 7 para otros usos (como controlar un relé para abrir una cerradura real), permitiendo una escalabilidad del proyecto.

PINES del I2C

La Versatilidad del Buzzer Pasivo

El módulo KY-006 es un buzzer pasivo, lo que lo distingue de uno activo:

• Pasivo: Requiere que el Arduino le suministre una señal oscilante (frecuencia) a través de un pin PWM para generar un tono audible. Esto es posible gracias a la función tone() de Arduino.
• Activo: Posee un oscilador interno y solo requiere una señal DC (digital HIGH/LOW) para emitir un tono fijo.

Al usar un buzzer pasivo, podemos crear la diferenciación sonora clave del proyecto: un tono alegre y alto para el acierto, y una serie de pitidos bajos para el error, mejorando la experiencia del usuario.

PINES del Buzzer pasivo(KY-006)

El Módulo RFID RC522

El módulo RFID RC522 es un lector/grabador de Alta Frecuencia (13.56 MHz) que funciona bajo el principio de la Inducción Electromagnética para comunicarse de forma inalámbrica con etiquetas o tarjetas pasivas.

Su funcionamiento se basa en la interacción entre su antena integrada (el lector) y la antena de la etiqueta (el transponder).

El proceso de lectura/escritura del módulo RC522 se desarrolla en los siguientes pasos:

1. Emisión del Campo Electromagnético (Lector):
   • El chip MFRC522 integrado en el módulo genera una señal de radiofrecuencia a 13.56 MHz y la transmite a través de la antena de cobre impresa en el PCB del módulo.
   • Esta energía crea un campo electromagnético que se extiende unos pocos centímetros (el rango de lectura práctico es de 0 a 6 cm).
2. Alimentación de la Etiqueta (Tarjeta Pasiva):
   • La tarjeta o llavero (conocido como tag o transponder) es un dispositivo pasivo (no tiene batería).
   • Cuando la etiqueta entra en el campo electromagnético del lector, la energía de las ondas de radio se induce en la pequeña antena interna de la tarjeta.
   • Esta energía se rectifica y se utiliza para alimentar el chip de la tarjeta.
3. Transmisión de Datos (Etiqueta):
   • Una vez alimentado, el chip de la tarjeta modula la señal del lector para transmitir la información almacenada. Esto se conoce como retrodispersión.
   • La tarjeta transmite principalmente su UID (Identificador Único), que es un código hexadecimal de 4 o 7 bytes inmutable, y puede transmitir o recibir datos de su memoria EEPROM (comúnmente 1KB dividida en sectores y bloques para tags MIFARE Classic).
4. Recepción e Interpretación (Lector):
   • El módulo RC522 detecta esta señal modulada, la demodula y la convierte en datos digitales.
   • Luego, utiliza el protocolo SPI (Serial Peripheral Interface) para enviar estos datos (UID, o datos de lectura/escritura) al microcontrolador principal (ej. Arduino).

PINES del RFID RC522

Nota: Una correcta conexión es fundamental para el éxito del proyecto. Asegúrate de alimentar el RC522 con 3.3V, mientras que el LCD y el Buzzer pueden usar 5V.

_🔨Componentes

🔌Conexiones

Conexión RFID RC522

Conexión LCD 16×2 con I2C

Conexión Buzzer Pasivo

0️⃣Código

Ejecuta el siguiente código para obtener el UID en hexadecimal del llavero, no olvidar instalar las librería “MFRC522” por Miguel balboa y la librería “LiquidCrystal_I2C” por marcoschwartz o similar.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

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

//Libreria MFRC522 by Miguel Balboa
// Definición de pines para la conexión SPI al Arduino UNO (pueden variar según el modelo)
// RST es el pin de Reset, SS (Slave Select) es el pin para seleccionar el módulo
#define RST_PIN 9
#define SS_PIN 10

// Crea una instancia de la clase MFRC522
MFRC522 mfrc522(SS_PIN, RST_PIN);

void setup() {
    Serial.begin(9600); // Inicializa la comunicación serial a 9600 baudios
    SPI.begin();        // Inicializa el bus SPI
    mfrc522.PCD_Init(); // Inicializa el módulo MFRC522
    Serial.println(F("--- Lector RFID RC522 - Esperando tarjeta... ---"));
}

void loop() {
    // Busca nuevas tarjetas
    if ( ! mfrc522.PICC_IsNewCardPresent()) {
        return; // Sale si no se presenta una tarjeta nueva
    }

    // Selecciona una de las tarjetas detectadas (obtiene el UID y el SAK)
    if ( ! mfrc522.PICC_ReadCardSerial()) {
        return; // Sale si no se puede leer el serial
    }

    // Imprime la etiqueta "UID de Tarjeta:" en el Monitor Serial
    Serial.print(F("UID de Tarjeta:"));
    
    // Recorre e imprime cada byte del UID
    for (byte i = 0; i < mfrc522.uid.size; i++) {
        // Añade un espacio y un '0' inicial si el byte es menor a 0x10 para formato hexadecimal legible
        Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
        Serial.print(mfrc522.uid.uidByte[i], HEX); // Imprime el byte en formato hexadecimal
    } 

    Serial.println(); // Salto de línea para el siguiente UID
    
    // Detiene la lectura de la tarjeta actual. Es importante para buscar tarjetas nuevas.
    mfrc522.PICC_HaltA();
}

Ya que obtengas el UID hexadecimal del llavero, sustituye el valor en el siguiente código en la línea 22.

byte uidAutorizado[4] = {0x3E, 0x1F, 0x9D, 0x04};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

#include <Arduino.h>
#include <SPI.h>
#include <MFRC522.h>//By miguel balboa
#include <LiquidCrystal_I2C.h>//By marcoschwartz

bool validarUID(byte *uid);
void tonoAcierto();
void tonoError();

// Pines del RC522
#define SS_PIN 10
#define RST_PIN 9

// Pin del buzzer
#define BUZZER_PIN 8

// Inicialización de objetos
MFRC522 rfid(SS_PIN, RST_PIN);
LiquidCrystal_I2C lcd(0x27, 16, 2); // Dirección I2C común

// UID del llavero autorizado (reemplaza con el tuyo)
byte uidAutorizado[4] = {0x3E, 0x1F, 0x9D, 0x04};

void setup() {
  Serial.begin(9600);
  SPI.begin();
  rfid.PCD_Init();
  lcd.init();
  lcd.backlight();
  pinMode(BUZZER_PIN, OUTPUT);

  lcd.setCursor(0, 0);
  lcd.print("Escanea tu RFID");
}

void loop() {
  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) {
    return;
  }

  Serial.print("UID detectado: ");
  for (byte i = 0; i < rfid.uid.size; i++) {
    Serial.print(rfid.uid.uidByte[i], HEX);
    Serial.print(" ");
  }
  Serial.println();

  if (validarUID(rfid.uid.uidByte)) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Codigo correcto");
    tonoAcierto();
  } else {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Codigo incorrecto");
    tonoError();
  }

  delay(2000);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Escanea tu RFID");

  rfid.PICC_HaltA();
  rfid.PCD_StopCrypto1();
}

bool validarUID(byte *uid) {
  for (byte i = 0; i < 4; i++) {
    if (uid[i] != uidAutorizado[i]) {
      return false;
    }
  }
  return true;
}

void tonoAcierto() {
  tone(BUZZER_PIN, 1000, 150);
  delay(200);
  tone(BUZZER_PIN, 1500, 150);
}

void tonoError() {
  tone(BUZZER_PIN, 400, 500);
}

🖌️Diseños

🎬Videos

📑Conclusión

El Display LCD 16×2 y el Módulo RFID RC522 son componentes fundamentales en la electrónica moderna para el desarrollo de sistemas interactivos, especialmente cuando se trabaja con microcontroladores como Arduino.

• El LCD 16×2 (gobernado por el controlador HD44780) sirve como el principal componente de salida (output), actuando como una interfaz hombre-máquina (HMI) visual simple y efectiva para mostrar información alfanumérica, estados del sistema, o menús (usando el modo paralelo o I2C para comunicación).
• El RFID RC522 (lector/grabador de 13.56 MHz) actúa como el principal componente de entrada (input), permitiendo la interacción sin contacto para la identificación o el intercambio de datos a corta distancia, utilizando el protocolo SPI para la comunicación de alta velocidad.

En conjunto, estos módulos facilitan la creación de proyectos de control de acceso o sistemas de gestión de inventario totalmente funcionales: el RFID RC522 lee la identidad de una tarjeta (entrada), y el LCD 16×2 muestra el resultado de la validación (salida), por ejemplo, “Acceso Aceptado” o “Tarjeta Inválida”. Su bajo costo y la disponibilidad de librerías simplifican enormemente su integración, haciéndolos ideales para la educación y el prototipado rápido.