Apriporta RFID con Arduino, RC522 e relè
Leggiamo il codice di tessere e tag RFID con il modulo RC522, memorizziamo quelli autorizzati e attiviamo un relè con LED verde o rosso in base all’esito del riconoscimento.
Cosa imparerai
- come collegare il lettore RFID RC522 ad Arduino Uno;
- come usare il bus SPI;
- come leggere il codice di una tessera o tag RFID;
- come confrontare il codice letto con una lista di UID autorizzati;
- come comandare LED e relè in base all’esito;
- come preparare un semplice prototipo di apriporta RFID.
Che cos’è il modulo RFID RC522
Il RC522 è un lettore RFID che permette ad Arduino di identificare tag e tessere compatibili tramite radiofrequenza. In questo progetto viene usato come base per un semplice sistema di accesso: una tessera autorizzata attiva un relè, mentre una tessera sconosciuta viene rifiutata.
Modulo lettore RFID RC522 utilizzato nel progetto.
Video del progetto
Materiale necessario
🧰 Kit Arduino consigliato
Molti progetti del sito utilizzano LED, resistenze, sensori, breadboard e cavetti. Un kit completo può essere comodo per iniziare.
👉 Guarda il kit Arduino consigliatoLink di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.
📘 Vuoi imparare Arduino passo dopo passo?
Se vuoi approfondire e realizzare progetti più completi, puoi dare un’occhiata anche ai miei libri dedicati ad Arduino. All’interno troverai spiegazioni semplici, schemi chiari e molti progetti pratici pensati per chi parte da zero.
👉 Scopri i miei libri su ArduinoLink di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.
Collegamenti del RC522
| RC522 | Arduino Uno |
|---|---|
| SDA / SS | D10 |
| SCK | D13 |
| MOSI | D11 |
| MISO | D12 |
| IRQ | Non collegato |
| GND | GND |
| RST | D9 |
| 3.3V | 3.3V |
LED e relè
| Elemento | Pin Arduino | Funzione |
|---|---|---|
| Relè | D2 | Attivazione accesso |
| LED verde | D3 | Tessera autorizzata |
| LED rosso | D4 | Tessera non autorizzata |
Schema del circuito
Schema di collegamento del lettore RC522 con Arduino, LED e modulo relè.
Passo 1: leggere il codice della tessera
Prima di decidere quali tessere autorizzare dobbiamo conoscere il loro codice. Il primo sketch inizializza il RC522 e stampa sul Monitor Seriale il codice letto.
#include <SPI.h>
#include <RFID.h>
// ==========================================================
// LETTURA CODICE TESSERA RFID RC522
// ==========================================================
// SDA/SS del RC522 collegato a D10
#define SDA_DIO 10
// Reset del RC522 collegato a D9
#define RESET_DIO 9
// Pausa tra due letture consecutive
#define delayRead 1000
// Crea l'oggetto che gestisce il lettore RFID
RFID RC522(SDA_DIO, RESET_DIO);
void setup() {
// Monitor Seriale per visualizzare il codice letto
Serial.begin(9600);
// Avvia il bus SPI
SPI.begin();
// Inizializza il lettore RC522
RC522.init();
Serial.println("RFID pronto.");
}
void loop() {
// Controlla se è presente una tessera
if (RC522.isCard()) {
// Legge il seriale/UID della tessera
RC522.readCardSerial();
// Stringa che conterrà il codice completo
String codiceLetto = "";
// Lo sketch usa 5 byte dell'array serNum
for (byte i = 0; i <= 4; i++) {
// Converte ogni byte in esadecimale
// e lo concatena alla String.
codiceLetto += String(RC522.serNum[i], HEX);
// Uniforma il testo in maiuscolo
codiceLetto.toUpperCase();
}
Serial.print("Codice tessera: ");
Serial.println(codiceLetto);
delay(delayRead);
}
}
Leggere l’UID dal Monitor Seriale
Questa immagine nel sito era visualizzata a 683 px: la stessa dimensione massima viene preservata.
Avvicina una tessera alla RC522 e annota il codice visualizzato. Ripeti l’operazione per tutte le tessere che vuoi autorizzare.
Passo 2: autorizzare le tessere e comandare il relè
Nel secondo sketch i codici validi vengono salvati in tre variabili. Puoi sostituire i valori di esempio con gli UID delle tessere che vuoi autorizzare:
String codiceAutorizzato1 = "FCA2333B56";
String codiceAutorizzato2 = "ESEMPIO479";
String codiceAutorizzato3 = "ESEMPIO480";
Codice completo apriporta RFID
#include <SPI.h>
#include <RFID.h>
// ==========================================================
// APRIPORTA RFID CON ARDUINO
// RC522 + LED VERDE + LED ROSSO + RELÈ
// ==========================================================
// Pin del lettore RC522
#define SDA_DIO 10
#define RESET_DIO 9
// Tempi del progetto
const unsigned long delayRead = 1000;
const unsigned long delayLed = 2000;
// Uscite
const int ledVerde = 3;
const int ledRosso = 4;
const int rele = 2;
// Oggetto lettore RFID
RFID RC522(SDA_DIO, RESET_DIO);
// ----------------------------------------------------------
// Inserisci qui gli UID delle tessere autorizzate.
// I valori seguenti sono soltanto esempi
// e vanno sostituiti con gli UID delle tue tessere.
// ----------------------------------------------------------
String codiceAutorizzato1 = "FCA2333B56";
String codiceAutorizzato2 = "ESEMPIO479";
String codiceAutorizzato3 = "ESEMPIO480";
// ----------------------------------------------------------
// Controlla se due codici RFID coincidono.
// ----------------------------------------------------------
bool verificaCodice(
const String &codiceLetto,
const String &codiceAutorizzato
) {
return codiceLetto.equals(codiceAutorizzato);
}
// ----------------------------------------------------------
// Accende un LED per il tempo definito in delayLed.
// ----------------------------------------------------------
void accendiLed(int ledPin) {
digitalWrite(ledPin, HIGH);
delay(delayLed);
digitalWrite(ledPin, LOW);
}
void setup() {
// Monitor Seriale
Serial.begin(9600);
// Avvia SPI e lettore RFID
SPI.begin();
RC522.init();
// Configura LED e relè come uscite
pinMode(ledVerde, OUTPUT);
pinMode(ledRosso, OUTPUT);
pinMode(rele, OUTPUT);
// Stato iniziale sicuro
digitalWrite(ledVerde, LOW);
digitalWrite(ledRosso, LOW);
digitalWrite(rele, LOW);
Serial.println("Sistema RFID pronto.");
}
void loop() {
// Prosegue soltanto quando viene rilevata una tessera
if (!RC522.isCard()) {
return;
}
// Legge il codice della tessera
RC522.readCardSerial();
String codiceLetto = "";
// Compone la String esadecimale
for (byte i = 0; i <= 4; i++) {
codiceLetto += String(RC522.serNum[i], HEX);
codiceLetto.toUpperCase();
}
Serial.print("Codice letto: ");
Serial.println(codiceLetto);
// Verifica il codice contro le tre tessere autorizzate
bool autorizzata =
verificaCodice(codiceLetto, codiceAutorizzato1) ||
verificaCodice(codiceLetto, codiceAutorizzato2) ||
verificaCodice(codiceLetto, codiceAutorizzato3);
if (autorizzata) {
Serial.println("Tessera autorizzata");
// Segnalazione verde
accendiLed(ledVerde);
// Attiva il relè per un secondo,
// come nello sketch originale.
digitalWrite(rele, HIGH);
delay(1000);
digitalWrite(rele, LOW);
}
else {
Serial.println("Tessera non autorizzata");
// Segnalazione rossa
accendiLed(ledRosso);
}
// Evita letture troppo ravvicinate
delay(delayRead);
}
Come funziona il riconoscimento
1. RC522.isCard()
Controlla se una tessera è presente davanti al lettore.
2. RC522.readCardSerial()
Legge i byte del codice e li rende disponibili nell’array serNum.
3. Costruzione del codice
I byte vengono convertiti in esadecimale e concatenati in una String, poi trasformati in maiuscolo per rendere uniforme il confronto.
4. verificaCodice()
Confronta il codice appena letto con ogni codice autorizzato.
5. Accesso consentito o negato
Se uno dei confronti è positivo si accende il LED verde e il relè viene attivato per circa un secondo. Se nessun codice coincide si accende il LED rosso.
Attenzione al modulo relè
In questo sketch il relè è considerato attivo HIGH: D2 viene portato HIGH per attivarlo e LOW per disattivarlo. Alcuni moduli relè commerciali sono invece attivi LOW.
RFID come controllo accessi: limite importante
Questo progetto è ottimo per imparare RFID, SPI e gestione degli accessi, ma non va considerato da solo un sistema di sicurezza professionale. Gli UID autorizzati sono memorizzati direttamente nello sketch e il controllo si basa sul confronto del codice letto.
Nuovo tutorial RFID correlato
Per approfondire il funzionamento del RC522 puoi vedere anche il tutorial dedicato all’accensione e spegnimento di un LED:
👉 Arduino RFID RC522: accensione LED e lettura
Scarica i file originali
RFID.h. Se installi una libreria RC522 differente, nomi di classi e funzioni possono cambiare e il codice può richiedere adattamenti.Debug rapido
- verifica che il RC522 sia alimentato correttamente a 3,3 V;
- controlla D10, D13, D11, D12 e D9 seguendo la tabella SPI;
- prima prova sempre il primo sketch e verifica che l’UID compaia sul Monitor Seriale;
- copia l’UID esattamente nella lista delle tessere autorizzate;
- se il LED corretto si accende ma il relè non commuta, controlla D2 e il tipo di trigger del modulo relè;
- se il relè resta sempre attivo, verifica se il tuo modulo è active LOW;
- se il codice non compila, controlla di usare la libreria compatibile con
RFID.h.
Varianti del progetto
- aggiungere più tessere autorizzate;
- memorizzare gli UID in un array invece di variabili separate;
- salvare gli UID in EEPROM;
- aggiungere un buzzer per conferma o errore;
- visualizzare nome utente e stato su LCD/OLED;
- registrare gli accessi su scheda SD;
- aggiungere un pulsante interno di apertura;
- eliminare i
delay()con una logica basata sumillis().
Cosa devi ricordare
- Il RC522 comunica con Arduino tramite SPI.
- SDA/SS è su D10 e RST su D9.
- Il relè è su D2, LED verde su D3 e LED rosso su D4.
- Prima devi leggere l’UID della tessera con il primo sketch.
- Gli UID autorizzati vengono inseriti nel secondo sketch.
- Una tessera valida attiva il relè per circa un secondo.
- Il progetto usa la libreria
RFID.h.
Domande frequenti
Perché il RC522 non legge la tessera?
Controlla alimentazione a 3,3 V, collegamenti SPI, pin RST e compatibilità della tessera con il lettore utilizzato.
Come aggiungo una nuova tessera autorizzata?
Leggi prima il suo UID con il primo sketch, poi aggiungi il codice alla lista e includilo nella condizione di verifica.
Perché il mio relè si attiva con LOW?
Alcuni moduli relè sono active LOW. Lo sketch presume invece un’attivazione HIGH, quindi il comportamento va adattato al modulo realmente usato.
Posso alimentare l’elettroserratura da Arduino?
No: la serratura deve essere alimentata con una sorgente adatta alle sue caratteristiche. Arduino deve limitarsi al comando del modulo relè o di uno stadio di pilotaggio appropriato.
Questo sistema è adatto come serratura di sicurezza definitiva?
È soprattutto un progetto didattico. Un sistema reale di controllo accessi richiede valutazioni aggiuntive su sicurezza, alimentazione, affidabilità e protezione delle credenziali.

