Come costruire una serratura RFID con Arduino e RC522
Descrizione
Questo progetto realizza una serratura elettronica RFID con Arduino UNO, un lettore RC522 e un modulo relè da 5 V. Al posto della password da digitare sul tastierino, basta avvicinare una tessera o un portachiavi RFID autorizzato al lettore. Arduino verifica l’identificativo (UID) della tessera e, se è corretto, commuta lo stato del relè: alla prima lettura lo attiva, alla successiva lo disattiva. Il modulo relè usato nel circuito è attivo LOW: il pin 7 di Arduino deve essere impostato su LOW per attivarlo e su HIGH per disattivarlo. Il progetto introduce l’identificazione senza contatto, il controllo degli accessi e la gestione di un relè tramite Arduino.
Componenti necessari:
- 1x Arduino UNO
- 1x Modulo lettore RFID RC522 con tessera o portachiavi RFID compatibile
- 1x Modulo relè 5V SRD-05VDC-SL-C con ingresso di segnale attivo LOW
- Cavi jumper (breadboard opzionale)
- Adattamento dei livelli logici da 5 V a 3,3 V, se non integrato nel modulo RFID
- Serratura elettrica o altro carico a bassa tensione con alimentazione adeguata (opzionale)
Schema:
Codice:
// https://nemiatools.com
#include <SPI.h> // Libreria per la comunicazione SPI
#include <MFRC522.h> // Libreria per il lettore RFID RC522
const byte SS_PIN = 10; // Pin SDA/SS del lettore RFID
const byte RST_PIN = 9; // Pin RST del lettore RFID
const byte relaySignalPin = 7; // Pin IN del modulo relè (attivo LOW)
// UID di ESEMPIO: sostituiscilo con quello della tua tessera!
const byte authorizedUID[] = {0xA3, 0x2F, 0x91, 0x0C};
const byte authorizedUIDLength = sizeof(authorizedUID) / sizeof(authorizedUID[0]);
MFRC522 rfid(SS_PIN, RST_PIN); // Crea il lettore RFID
bool relayActive = false; // Stato iniziale del relè: disattivato
void setRelay(bool active) { // Gestisce il relè attivo LOW
relayActive = active; // Aggiorna lo stato memorizzato
digitalWrite(relaySignalPin, active ? LOW : HIGH); // LOW attiva, HIGH disattiva
}
bool isAuthorized() { // Controlla l'UID della tessera letta
if (rfid.uid.size != authorizedUIDLength) { // Verifica la lunghezza
return false; // UID con lunghezza diversa
}
for (byte i = 0; i < authorizedUIDLength; i++) { // Confronta tutti i byte
if (rfid.uid.uidByte[i] != authorizedUID[i]) {
return false; // Almeno un byte è diverso
}
}
return true; // Tutti i byte coincidono
}
void printUID() { // Visualizza l'UID nel Monitor Seriale
Serial.print(F("UID: "));
for (byte i = 0; i < rfid.uid.size; i++) {
if (rfid.uid.uidByte[i] < 0x10) {
Serial.print('0'); // Completa i valori a una cifra
}
Serial.print(rfid.uid.uidByte[i], HEX); // Stampa il byte in esadecimale
if (i + 1 < rfid.uid.size) Serial.print(' ');
}
Serial.println();
}
void setup() {
digitalWrite(relaySignalPin, HIGH); // Imposta HIGH prima di abilitare l'uscita
pinMode(relaySignalPin, OUTPUT); // Pin del relè come uscita
setRelay(false); // Relè inizialmente spento
Serial.begin(9600); // Avvia il Monitor Seriale a 9600 baud
SPI.begin(); // Avvia la comunicazione SPI
rfid.PCD_Init(); // Inizializza il lettore RC522
Serial.println(F("Avvicina una tessera RFID."));
}
void loop() {
if (!rfid.PICC_IsNewCardPresent()) { // Cerca una nuova tessera
return; // Nessuna tessera presente
}
if (!rfid.PICC_ReadCardSerial()) { // Legge l'UID della tessera
return; // Lettura non riuscita
}
printUID(); // Mostra l'UID per poter autorizzare la propria tessera
if (isAuthorized()) { // UID corretto
setRelay(!relayActive); // Inverte lo stato del relè
if (relayActive) {
Serial.println(F("Accesso autorizzato: rele ATTIVO (pin 7 LOW)."));
} else {
Serial.println(F("Accesso autorizzato: rele DISATTIVATO (pin 7 HIGH)."));
}
} else { // UID non riconosciuto
Serial.println(F("Tessera non autorizzata: stato invariato."));
}
rfid.PICC_HaltA(); // Termina la comunicazione con la tessera
rfid.PCD_StopCrypto1(); // Ripristina lo stato del lettore
delay(300); // Piccola pausa tra due letture
}Come funziona:
Questo progetto usa Arduino UNO, un lettore RFID RC522 e un modulo relè 5V attivo LOW per controllare una serratura o un altro carico tramite una tessera autorizzata. La tessera sostituisce il tastierino: anziché inserire una password, l’utente la avvicina al lettore.
Le righe #include <SPI.h> e #include <MFRC522.h> includono le librerie necessarie. SPI.h gestisce la comunicazione SPI di Arduino, mentre MFRC522.h mette a disposizione i comandi per utilizzare il modulo RC522. Prima di caricare il programma, installa la libreria MFRC522 dal Gestore librerie dell’IDE Arduino.
Nel circuito, il lettore RC522 è collegato ad Arduino nel seguente modo: SDA/SS → 10, SCK → 13, MOSI → 11, MISO → 12, RST → 9, GND → GND e 3.3V → 3.3V. Il pin IRQ non viene utilizzato. Le costanti SS_PIN e RST_PIN indicano alla libreria i pin 10 e 9.
Il modulo relè ha i collegamenti di controllo VCC → 5V, GND → GND e IN → pin 7 di Arduino. La costante relaySignalPin = 7 identifica l’uscita che pilota il relè. I morsetti COM, NO e NC permettono di collegare un circuito esterno, scegliendo il contatto normalmente aperto o normalmente chiuso in base al carico.
L’array authorizedUID contiene i byte dell’identificativo della tessera autorizzata. Il valore {0xA3, 0x2F, 0x91, 0x0C} è soltanto un esempio: va sostituito con l’UID della propria tessera. Per individuarlo, carica inizialmente il codice, apri il Monitor Seriale a 9600 baud, avvicina la tessera e copia nell’array i byte riportati dopo UID:, mantenendo la notazione esadecimale 0x. Se la tessera ha un numero diverso di byte, modifica anche il numero di elementi nell’array.
La riga const byte authorizedUIDLength = sizeof(authorizedUID) / sizeof(authorizedUID[0]); calcola automaticamente la lunghezza dell’UID autorizzato. La funzione isAuthorized() controlla prima la lunghezza della tessera letta e poi confronta, uno per uno, tutti i suoi byte con quelli memorizzati: basta un byte diverso per negare l’autorizzazione.
La variabile relayActive memorizza lo stato corrente del relè. La funzione setRelay(bool active) aggiorna questa variabile e usa digitalWrite(relaySignalPin, active ? LOW : HIGH);: quando active è true invia LOW e attiva il modulo; quando è false invia HIGH e lo disattiva. Questa logica è opposta a quella di un’uscita attiva HIGH.
Nella funzione setup(), il programma imposta il pin 7 su HIGH prima di configurarlo come OUTPUT, poi richiama setRelay(false) per mantenere il relè disattivato. Successivamente, Serial.begin(9600), SPI.begin() e rfid.PCD_Init() avviano rispettivamente la comunicazione seriale, il bus SPI e il lettore RFID.
Nel ciclo loop(), rfid.PICC_IsNewCardPresent() controlla se è stata rilevata una nuova tessera. Se è presente, rfid.PICC_ReadCardSerial() ne legge l’UID. La funzione printUID() lo mostra nel Monitor Seriale anche quando la tessera non è autorizzata, così è possibile recuperare facilmente il codice identificativo della propria tessera.
La condizione if (isAuthorized()) decide se consentire la commutazione. Se l’UID è valido, setRelay(!relayActive); inverte lo stato: da spento ad acceso oppure da acceso a spento. Se l’UID non coincide, lo stato del relè rimane invariato. Non è previsto un tempo automatico di richiusura: per cambiare nuovamente lo stato occorre presentare un’altra volta una tessera autorizzata.
Le istruzioni rfid.PICC_HaltA() e rfid.PCD_StopCrypto1() terminano la gestione della lettura, mentre delay(300) introduce una breve pausa. Per effettuare una nuova lettura della stessa tessera, allontanala dal lettore e poi riavvicinala.
Per una spiegazione dedicata all’utilizzo del modulo, consulta la guida NEMIA TOOLS sul lettore RFID RC522 con Arduino. In questo tutorial ci concentriamo soprattutto sul riconoscimento dell’UID e sul comando del relè.
Attenzione: il modulo RC522 richiede alimentazione a 3,3 V. Con Arduino UNO, i segnali a 5 V diretti agli ingressi del RC522 richiedono un adattamento dei livelli logici, se non già integrato nel modulo; lo schema mostra i collegamenti logici. Verifica inoltre il tipo di relè (attivo LOW), i limiti dei suoi contatti e l’alimentazione del carico. Un semplice UID RFID può essere copiato: questo progetto è didattico e non sostituisce un sistema di sicurezza certificato.