🔐 Arduino • RFID RC522 • Relè

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.

DifficoltàIntermedia
LettoreRFID RC522
UsciteRelè + 2 LED
In poche parole: prima leggiamo l’UID della tessera dal Monitor Seriale. Poi inseriamo gli UID autorizzati nel secondo sketch: se la tessera viene riconosciuta si accende il LED verde e il relè commuta per un secondo; in caso contrario si accende il LED rosso.

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.

Lettore RFID RC522 per Arduino

Modulo lettore RFID RC522 utilizzato nel progetto.

Terminologia: il progetto utilizza tessere e tag RFID, letti senza contatto dal modulo RC522 tramite radiofrequenza.

Video del progetto

Materiale necessario

🔌 Arduino Uno
📡 Lettore RFID RC522
💳 Almeno 2 tessere/tag RFID
💡 1 LED verde
🔴 1 LED rosso
〰️ 2 resistenze da 220 Ω
⚡ Modulo relè 1 canale
🧩 Breadboard e jumper

🧰 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 consigliato

Link 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 Arduino

Link di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.

Collegamenti del RC522

RC522Arduino Uno
SDA / SSD10
SCKD13
MOSID11
MISOD12
IRQNon collegato
GNDGND
RSTD9
3.3V3.3V

LED e relè

ElementoPin ArduinoFunzione
RelèD2Attivazione accesso
LED verdeD3Tessera autorizzata
LED rossoD4Tessera non autorizzata
RC522 a 3,3 V: il modulo viene alimentato dal pin 3.3V di Arduino. Non collegare il pin di alimentazione del RC522 a 5 V se il tuo modulo non lo prevede.

Schema del circuito

Schema Arduino RC522 RFID relè apriporta

Schema di collegamento del lettore RC522 con Arduino, LED e modulo relè.

Elettroserratura: non alimentare una serratura direttamente da un pin Arduino. Il relè separa il comando logico dal circuito del carico; la serratura deve avere un’alimentazione adeguata alle sue specifiche. Per tensioni pericolose o impianti reali serve un’installazione appropriata e sicura.

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.

1° sketch – lettura UID RFID
#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

Codici RFID visualizzati nel Monitor Seriale Arduino

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:

Lista dei codici autorizzati
String codiceAutorizzato1 = "FCA2333B56";
String codiceAutorizzato2 = "ESEMPIO479";
String codiceAutorizzato3 = "ESEMPIO480";
Da personalizzare: sostituisci questi valori con gli UID letti dalle tue tessere prima di usare il sistema.
Inserire codici RFID autorizzati nello sketch Arduino
Aggiungere più tessere RFID autorizzate Arduino

Codice completo apriporta RFID

2° sketch – tessera autorizzata, LED e relè
#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.

Se il relè lavora al contrario: verifica il tuo modulo prima di cambiare il software. Potrebbe essere sufficiente invertire HIGH e LOW, ma dipende dalla scheda relè utilizzata.

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

⬇️ Sketch lettura codici RFID

⬇️ Sketch apriporta RFID

⬇️ Libreria RFID

Nota sulla libreria: gli sketch usano 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 su millis().

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.