Basato su Arduino e una speciale breakout board, comanda un relé quando rileva e riconosce un tag RFiD precedentemente abbinato; idoneo anche alla lettura di card contactless NFC.
RFID e NFC: una tecnologia ormai diffusa
Il riconoscimento e il controllo di varchi operato da tornelli, cancelli e porte motorizzati e comandati da sistemi elettronici RFiD è ormai una realtà assodata in molti ambiti, che toccano sia le aziende, sia i condomini; ormai molti di noi hanno in tasca un tag (transponder) wireless passivo che permette di accedere al luogo di lavoro, di consumare una bevanda in una macchina per il vending alimentare, di entrare in palestra, ma anche di aprire il portoncino di casa e di “timbrare il cartellino” al lavoro. Sulla stessa tecnologia, che è quella nota come RFiD, si basano i più recenti e ormai diffusi sistemi di identificazione e pagamento elettronico contactless, anche noti come NFC, integrati nelle tessere bancomat o negli apparati “mobile” come smartphone e tablet.
Alla tecnologia RFiD/NFC dedichiamo il progetto che trovate in queste pagine, che è insieme un’applicazione fatta e finita per il controllo accessi ed una piattaforma di sviluppo e prototipazione dei sistemi di identificazione a brevissima distanza basati su transponder (tag) passivi o attivi.
Come funziona un tag RFID passivo
Prima di entrare nel vivo del progetto facciamo un preambolo propedeutico a comprendere il funzionamento dell’RFiD: i sistemi del genere funzionano come dei veri e propri transponder e sono tipicamente passivi, nel senso che il dispositivo di identificazione (detto tag) portatile agisce solo se viene eccitato dal sistema fisso eccitatore e non possiede alcuna fonte di alimentazione autonoma. Il funzionamento è questo: il sistema di rilevamento ha un circuito eccitatore che genera un campo elettromagnetico, tipicamente a bassa frequenza (si sta normalmente sui 125 kHz ma esistono sistemi operanti a frequenze maggiori) irradiandolo mediante una bobina a breve distanza; si va da pochi cm dei sistemi di pagamento contactless e degli NFC (dove la trasmissione va ristretta il più possibile ad evitare captazioni fraudolente da parte di hacker e malintenzionati) a poche decine di cm dei varchi per persone e autoveicoli.
Induzione e identificazione del tag
Quando un tag entra nel campo elettromagnetico, nella bobina che ha al proprio interno si induce una tensione alternata che viene raddrizzata da un diodo e carica un condensatore, tra le armature del quale rimane abbastanza energia da far funzionare la logica del tag; quest’ultima si basa su un encoder che, una volta alimentato, genera un codice identificativo (di solito univoco) che pilota la base di un transistor, il quale ad ogni livello logico alto va in conduzione e “carica” elettricamente la bobina, causando nella bobina del circuito eccitatore una reazione d’indotto, per effetto della quale ogni conduzione aumenta l’assorbimento di corrente.
Tramite un resistore di sense il circuito eccitatore rileva gli impulsi e ricostruisce il codice prodotto dall’encoder, riuscendo quindi e identificare il tag. Il diodo permette, nei periodi in cui il transistor carica la bobina, di non scaricare il condensatore permettendo che l’energia in esso accumulata faccia funzionare l’encoder per il tempo necessario a completare l’identificazione.
Il progetto
Ciò detto, passiamo a vedere in cosa consiste il sistema di identificazione tramite RFiD, che sostanzialmente è una serratura elettronica a transponder, programmabile e dotata di interfaccia utente per un agevole utilizzo.
Il progetto si basa su Arduino Uno dotato di LCD Shield, su un modulo relé a 5 volt e su un modulo specifico per la lettura di tag RFiD e per NFC in generale. Il modulo (Fig. 1) in questione è il PN532 ed è un lettore/scrittore di tag NFC/RFID (la scrittura vale per i tag attivi) dotato di bobina integrata nel PCB, interfaccia di comunicazione I²C, SPI e HSU (High Speed UART), oltre che di un LED di segnalazione. La scheda, dalle dimensioni di 43x41x4 mm, può funzionare come lettore/scrittore di RFID card, come lettore NFC per smartphone Android (funziona solo con alcuni tipi) e in modalità wireless peer-to-peer tra due dispositivi analoghi.
Il modulo PN532: interfacce e tag supportati
Il circuito funziona con una tensione da 3,3 a 5 V e l’interfaccia di comunicazione, disponibile su una fila di pad posta su un lato della basetta, si seleziona tramite dip-switch secondo quanto esposto nella Tabella 1. In realtà la scheda, come potete vedere dalla Fig.1, riporta due file di contatti: una con quattro pad e una con 8; insieme formano sia le interfacce dati, sia le connessioni di servizio, vale a dire alimentazione, e segnali di controllo.
La fila di quattro pad riporta il bus I²C, ossia SCL, SDA, massa comune e alimentazione; quella da 8 pad riporta il bus SPI completo, quindi SCK, MISO, MOSI ed SS, oltre a Vcc, GND, reset (RST0) e IRQ, che sono pin da utilizzare per la gestione diretta da microcontrollore: in particolare IRQ fornisce un segnale ogni volta che viene effettuato un rilevamento di tag, per richiedere l’attenzione del microcontrollore.
I tag supportati e la distanza di lettura
Tra i tag supportati dal modulo ci sono i Mifare 1k, 4k (Mifare è uno standard realizzato da NXP Semiconductors e largamente utilizzato nelle card per RFiD ed NFC), Ultralight e card DesFire, oltre che card ISO/IEC 14443-4 come CD97BX, CD light, Desfire, P5CN072 (SMX), Innovision Jewel cards come IRT5001 ed anche FeliCa card come RCS_860 e RCS_854. Lo standard ISO/IEC 14443 prevede il funzionamento con un campo elettromagnetico di eccitazione alla frequenza di 13,56 MHz.
La massima distanza di captazione e comunicazione del tag è, per il nostro modulo PN532, compresa tipicamente tra 30 e 70 mm. Il modulo può essere utilizzato con Arduino per realizzare dispositivi di controllo accessi, ecc., grazie alla dotazione di una libreria che provvede alla sua gestione.
La libreria per la sua gestione è fornita da Adafruit e può essere scaricata sia dal sito del produttore, sia dalla pagina www.futurashop.it/NFC-RFID?search=RFiD (la libreria si chiama adafruit pn532).
Realizzazione pratica
Bene, passiamo adesso all’assemblaggio dei componenti del sistema; riepilogando, l’insieme dell’hardware è composto da:
• Arduino UNO;
• LCD Keypad Shield (1686-SHIELD-LCD);
• modulo RFiD (2846-PN532);
• modulo relé 5V-10A (2846-RELAY1CH).
Il tutto è disponibile presso la Futura Elettronica (shop on-line www.futurashop.it) e i codici del prodotto sono quelli riportati tra parentesi. Una volta procurato l’hardware, va collegato mediante jumper per Arduino rispettando i collegamenti indicati nello schema di cablaggio che trovate in queste pagine.
Per quanto riguarda il modulo RFiD, i collegamenti ad Arduino, o meglio, all’LCD Shield, sono:
• il contatto SCK va al pin 13 dello shield;
• il contatto MISO va al pin 12 dello shield;
• il contatto MOSI va al pin 3 dello shield;
• il contatto SS va al pin 2 dello shield;
• il contatto VCC va al pin 5V dello shield;
• la massa (GND) va al pin GND dello shield.
Collegamenti del relè e interfaccia utente
Invece il modulo relé si collega con il 5V al 5V di Arduino (insieme all’alimentazione del modulo RFiD) e GND ad un pin GND libero di Arduino (o dell’LCD Shield); l’input di comando del relé va connesso al pin D5 di Arduino (dello Shield).
Per gestire lo shield con LCD, che costituisce l’interfaccia utente del sistema, nello sketch si include l’apposita libreria (scaricabile anch’essa da www.futurashop.it) che consente di comandare il display alfanumerico e leggere i pulsanti.
A proposito di pulsanti, nel progetto hanno le seguenti funzioni:
• UP e DOWN consentono di spostarsi tra le voci di menu;
• SELECT serve scegliere una voce di menu;
• DOWN avvia l’interrogazione del transponder;
• LEFT, dalla schermata iniziale del display consente di testare il relé d’uscita;
• RST; permette di tornare alla schermata iniziale.
Per l’utilizzo del sistema consigliamo di racchiudere l’intera elettronica in un contenitore in plastica lavorato per far fuoriuscire i pulsanti e per rendere visibile il display LCD; la scheda RFiD può essere incollata con del silicone sigillante appena sotto al pannello frontale del contenitore, il quale, essendo in plastica, non interferisce in alcun modo con il campo elettromagnetico generato dalla bobina né con il rilevamento della reazione d’indotto.
Ciò detto possiamo vedere le funzionalità del sistema.
Avvio e menu principale
Diamo dunque uno sguardo al funzionamento dell’insieme, premettendo che dovrà essere alimentato tramite il jack DC di Arduino Uno con un alimentatore da rete capace di fornire almeno 500 milliampere e una tensione di 9÷10 volt.
Appena il dispositivo viene alimentato, sul display LCD compare la scritta “Lettore Schede di Accesso” (Fig. 2).
In seguito viene visualizzata la scritta “Lettura: Lettura in corso”. Quindi il sistema eseguirà la lettura del tag eventualmente presente nel raggio d’azione (campo elettromagnetico) del modulo, fornendo in risposta il messaggio di autorizzazione concessa o negata. Naturalmente il tutto ha senso se preventivamente il sistema ha memorizzato uno o più tag, altrimenti l’autorizzazione sarà sempre negata; in caso di autorizzazione concessa viene attivato il relé.
Dalla schermata principale, premendo il pulsante “DOWN” accedete al menu, che propone le seguenti opzioni:
• Mod. Lettura (Fig. 3) corrispondente alla procedura iniziale di lettura del tag;
• Mod. Modifica (Fig. 4) corrispondente alla procedura di apprendimento di un tag e alla scrittura nella memoria di Arduino;
• Mod. Elimina (Fig. 5) che consente di eliminare tutti i tag già appresi e il cui codice è nella memoria di Arduino.
Per scorrere tra le opzioni utilizzare i tasti “UP” e “DOWN”, mentre per selezionare un’opzione dovete premere il tasto “SELECT”. Premete il tasto “RST” per tornare in qualsiasi momento alla procedura iniziale. Durante la schermata “Menu’ principale” potete premere il tasto “LEFT” per testare il corretto funzionamento del relé.
Modalità Modifica: registrare un nuovo tag
Analizziamo brevemente le modalità, partendo dalla Modalità Modifica: una volta selezionata, permette all’utente di registrare un nuovo tag.
La procedura, che inizia quando il display mostra la schermata proposta in Fig. 4, prevede che si passi il tag da apprendere sopra il modulo a una distanza massima di 7 cm, allorché il sistema ne acquisirà e salverà automaticamente il codice tra quelli autorizzati. Se il tag non viene rilevato (ve ne accorgerete perché il display mostrerà un contenuto immutato), provate a passarlo a una distanza minore finché non viene rilevato.
Resta inteso che il modulo può riconoscere determinati tipi di tag, che sono poi i più diffusi, quindi quelli che vorrete far apprendere dovranno essere tra quelli riepilogati qualche paragrafo indietro.
In ogni caso, se l’operazione di memorizzazione sarà andata a buon fine, sul display comparirà la scritta “TESSERA SALVATA” (Fig. 6).
A questo punto, se rimanete nella Modalità Modifica e ripassate lo stesso tag appena appreso, il codice di quest’ultimo viene rimosso dalla memoria; tale condizione di cancellazione verrà confermata dalla scritta “TESSERA RIMOSSA” (Fig. 7).
Modalità Elimina e Modalità Lettura
Passiamo adesso alla Modalità Elimina, che si avvia quando il display mostra la schermata già vista nella Fig. 5; da qui, per rimuovere dalla memoria tutti i tag precedentemente appresa bisogna premere il tasto SELECT; fatto ciò, sul display appare la schermata visibile nella Fig. 8.
Al termine dell’operazione dovete premere il tasto “RST” per tornare al menu principale. Una volta che la memoria è stata cancellata, il display propone la schermata visibile nella Fig. 9.
Terminiamo con la Modalità Lettura: quando si entra in essa dal menu principale (ci si trova con la schermata di Fig. 3 sul display) e si passa un tag davanti al modulo, appare quanto in Fig. 8.
In pratica, quando il modulo rileva un tag nel proprio campo di azione lo interroga e in questa fase il display mostra il messaggio di cui alla predetta figura. A completamento della lettura possono verificarsi due condizioni mostrate nella Fig. 9: se il tag è uno di quelli già appresi nella Modalità Modifica, questo viene riconosciuto e sul display appare il messaggio Acc. Consentito, accompagnato dall’accensione del relé. Invece se il tag non è riconosciuto come uno di quelli già appresi, viene mostrato Acc. Negato e nulla accade al relé.
Personalizzare il firmware
Queste sono tutte le funzioni previste, ma naturalmente “mettendo mano” al firmware è possibile implementarne di altre; per esempio all’uscita a relé è possibile aggiungere segnalazioni locali di vario genere, come un cicalino che suona al riconoscimento di un tag oppure un LED che al verificarsi della predetta condizione si illumini.
Volendo, senza “manomettere” lo sketch di Arduino è possibile aggiungere un LED o un cicalino collegandoli in parallelo (il LED richiede un resistore di limitazione tipicamente da 270 ohm…) alla bobina del relé, ovvero in serie al collettore di un transistor NPN connesso ad emettitore comune con la base pilotata dall’uscita di Arduino Uno che comanda la scheda relé.
Il firmware
Visto l’hardware e descritto il funzionamento, spendiamo qualche riga per il firmware che consente la gestione della serratura elettronica.
Lo sketch da caricare nella board Arduino Uno è abbastanza voluminoso e per questo ne riportiamo, nel Listato 1, soltanto la porzione più significativa, che è quella riguardante il normale funzionamemto. L’intero sketch (file .ino) potete comunque scaricarlo dal nostro sito web www.elettronicain.it, insieme ai file di questo numero della rivista.
Listato 1
if (success)
{
// Display some basic information about the card
if(debug) {
Serial.println(“Found an ISO14443A card”);
Serial.print(“ UID Length: “);Serial.print(uidLength, DEC);Serial.println(“ bytes”);
Serial.print(“ UID Value: “);nfc.PrintHex(uid, uidLength);
}
cardid = getCardIdAsInt(uid,uidLength);
//is MASTER
if (cardid == uid_master) {
master_mode = 1;
master_mode_counter = 0;
if(debug) Serial.println(“MASTER detected, going into MASTER MODE “);
}
// is not MASTER
else {
int32_t findUid = findRfidInEeprom( uidLength, uid);
// is MASTER MODE, include or exclude RFID from storage
if(master_mode == 1) {
// card rfid already exists so exlude it from storage
if( findUid != -1) {
if(debug) {
Serial.println(“removing card from eeprom”); Serial.println(“ “);
lcd.setCursor(0,1);
lcd.print(“Tessera Rimossa “);
delay(2000);
lcd.setCursor(0,1);
lcd.print(“Modifica... “);
}
deleteRfidfromEeprom(findUid, uidLength);
}
// card rfid not found in storage so include it
else if (findUid == -1) {
// check if space to store rfid available
int32_t storageAddress = getEepromStorageAddress(uidLength);
// storage available
if(storageAddress >= 0) {
if(debug) {
Serial.print(“storing card in position = “);Serial.print(storageAddress);Serial.println(“ “);
}
// storing card
writeRfidToEeprom( storageAddress, uidLength, uid);
lcd.setCursor(0,1);
lcd.print(“Tessera Salvata “);
delay(2000);
lcd.setCursor(0,1);
lcd.print(“Modifica... “);
}
else { // no storage space available or error
if(debug) Serial.println(“memory full or error”);
}
}
master_mode = 0;
}
// no MASTER MODE, authorise or deny door access
else {
// card authorised
if( findUid != -1) {
// open door
// write routine for door access, example set an output to high
if(debug) Serial.println(“Card authorised”);
lcd.clear();
lcd.setCursor(0,0);
lcd.print(“Lettura:”);
lcd.setCursor(0,1);
lcd.print(“Acc. Consentito”);
digitalWrite(11,HIGH);
delay(2000);
digitalWrite(11, LOW);
lcd.setCursor(0,1);
lcd.print(“Lettura in corso”);
}
else {
// deny access
if(debug) Serial.println(“Card not authorised”);
lcd.clear();
lcd.setCursor(0,0);
lcd.print(“Lettura:”);
lcd.setCursor(0,1);
lcd.print(“Acc. Negato”);
delay(2000);
lcd.setCursor(0,1);
lcd.print(“Lettura in corso”);
}
}
}
delay(500);
}Come al solito il firmware inizia con la definizione degli I/O e l’inclusione delle librerie, che in questo progetto sono due: quella del lettore RFiD e quella per l’LCD Shield.
Segue il setup e poi ci troviamo la porzione riportata nel predetto Listato 1, dove in base alla modalità impostata da noi mediante i pulsanti dello shield la tessera (il tag RFiD) verrà memorizzata, cancellata o, nel caso di funzionamento “normale”, verra semplicemente letta per confrontarne il codice identificativo con i dati in memoria; in questo caso, se il codice letto è già presente nella memoria Flash di Arduino verrà attivato il relé sulla scheda.
L’attivazione del relé avviene in modalità impulsiva, ossia monostabile e il tempo di permanenza nello stato “eccitato” (quindi di chiusura dello scambio del relé) è di 2 secondi, come definito dalla porzione di codice:
digitalWrite(11,HIGH); delay(2000); digitalWrite(11, LOW);
dove digitalWrite (11, HIGH) è l’istruzione che attiva la linea digitale 11 (che comanda la scheda a relé), delay(2000) stabilisce il tempo di permanenza a livello alto attraverso il ritardo con cui l’uscita D11 torna a livello basso e, infine, digitalWrite (11, LOW) riporta a livello logico basso la predetta linea di Arduino.
Se volete, potete modificare il tempo di attivazione del relé cambiando, nello sketch, il valore tra parentesi che segue delay, ricordando che è in millisecondi.
Conclusioni
Siamo dunque giunti alla fine della descrizione di questo progetto, che pur nascendo come serratura elettronica con chiave a transponder può essere utilizzato per svariate applicazioni e, con qualche ritocco al firmware, può trovare impiego nell’identificazione tramite NFC grazie al pieno supporto fornito dalla scheda sensore e all’abbinamento ad un Personal Computer.
