Tecnologia RFID, NCF: teoria e pratica

RFID è l’acronimo di “Radio Frequency IDentification” e indica una tecnologia che si basa sul riconoscimento di un oggetto identificato univocamente mediante l’UID (Unique IDentifier) da parte di un lettore specifico, mediante una comunicazione in radiofrequenza.
I campi di applicazione di questa tecnologia sono numerosi e svariati: carte di credito, passaporti, sistemi antitaccheggio, controllo accessi e presenze, bigliettazione, gestione volumi biblioteche; questi sono solo alcuni esempi.
Il vantaggio principale della tecnologia rispetto ad altre (banda magnetica, chip, barcode) consiste nel fatto che oggetto e lettore non devono venire a contatto tra loro e non devono nemmeno essere in condizioni di visibilità unilaterale o reciproca. Una delle ultime implementazioni dell’RFID è costituita dalle carte senza contatto (contactless) basate sull’NFC, che consentono di effettuare transazioni finanziarie in assoluta sicurezza.
Gli attori della tecnologia RFID sono i seguenti:
• Tag o transponder: è l’oggetto da leggere, in genere costituito da chip dotato di memoria e connesso a una bobina in funzione di antenna; può avere forma di portachiavi, Card ISO, chiavetta. In base alla tipologia un Tag può contenere il solo UID o anche dei messaggi di testo o dei comandi che il Reader legge o esegue nel momento in cui avviene la comunicazione.
• Controller RFID (Reader o Lettore): un sistema di ricetrasmissione a radiofrequenza controllato da un microcontrollore, il cui scopo è quello di leggere le informazioni (UID e altro) memorizzate nei Tag. Lo stesso lettore può, in determinate situazioni, trasformarsi in programmatore, per trasferire informazioni nei Tag.
• Management system (Sistema di gestione): non è una componente fondamentale, ma se esiste significa che ci si trova di fronte ad una rete di Reader interconnessi tra loro e con il sistema informativo. Esso si occupa di rilevare la lettura dei Tag, ricavarne le informazioni in essi contenute e gestire le applicazioni che gli sono demandate.

I tag sono classificabili, in base alla tecnologia di funzionamento, in:
Passivi: non hanno una propria fonte di energia, ma sfruttano quella del segnale di eccitazione proveniente dal Reader, il quale investendo l’antenna genera ai suoi capi una tensione indotta che viene raddrizzata e filtrata, così da alimentare il chip; questo si attiva e pulsa il proprio codice chiudendo in analogia i capi della bobina e determinando una reazione d’indotto nell’antenna del Reader, dove un apposito circuito rileva le variazioni di corrente trasformandole in impulsi uguali ai dati pulsati dal tag.
In base alla frequenza di lavoro possono operare a distanza di pochi cm ma anche di alcuni metri.
Attivi: alimentati da batterie, in genere sono costituiti da una coppia RTX come i Reader, poi sono caratterizzati da memoria di grande capacità ed addirittura possono essere dotati di sensori o altri elementi accessori. Le distanze in questi casi possono raggiungere 150÷250 m.
Passivi assistiti da batteria: sistemi ibridi rispetto ai primi due, in quanto la batteria è usata per alimentare solo alcuni componenti e non tutto il Tag.

Vediamo qualche informazione aggiuntiva riguardo ai Tag passivi, gli unici di nostro interesse in questo articolo; le applicazioni alle quali si prestano in genere sono correlate alle dimensioni dei Tag che, essendo di fatto costituiti da un chip miniaturizzato e da una bobina, stampata su un supporto, con funzione di antenna, possono avere essere inseriti in carte di credito, etichette adesive, ma anche capsule, rendendoli di fatto univoci al riconoscimento. La memoria del chip può essere principalmente di “sola-lettura” o “riscrivibile”; in quest’ultimo caso è possibile memorizzare messaggi o istruzioni, modificabili a piacimento nel tempo; mediante opportuni programmi è possibile formattarli (azzeramento della memoria con possibile cambio di tipologia di Tag), cancellarli (azzeramento della memoria e inserimento di un messaggio vuoto) o resettarli (ripristino allo stato di fabbrica). I tipi di memoria possono coesistere nel chip (la parte di sola lettura contiene l’UID, quella riscrivibile le informazioni modificabili). Tipicamente un chip RFID può memorizzare da qualche byte ad alcuni kB.
Le caratteristiche dell’antenna dipendono, oltre che dalla frequenza di lavoro, anche dalle necessità operative del Tag. La forma dell’antenna varia a seconda delle frequenze: per le frequenze basse si ricorre ad un certo numero di spire avvolte in aria (modelli HF) o su un cilindro di ferrite (modelli LF). Nel caso delle frequenze UHF vengono usati sistemi complessi come antenne a dipolo di varie forme.
Il funzionamento di un Tag passivo è schematizzato nella Fig.1.
Per poter comunicare tra loro il Reader ed il Tag devono utilizzare lo stesso protocollo di comunicazione. Le tipologie di protocolli, e quindi di Tag, più diffuse sono: ISO 14443, Mifare Classic, Mifare Ultralight, FeliCa, NTag2xxx.
Le frequenze di comunicazione dell’RFID sono standardizzate e le due più usate universalmente sono:
• banda LF (120÷145 kHz) è quella che è stata usata alle origini e si usa ancora oggi;
• banda HF; in essa rientra la frequenza fissa di 13,56 MHz, che oggi è quella universalmente usata come standard di riferimento per l’RFID;
• banda UHF, variabile da un continente all’altro e per tale ragione utilizzata solo in quelle applicazioni che richiedono distanze operative decisamente maggiori di quelle che raggiungono LF e HF.

Fig.1

NFC è l’acronimo di “Near Field Communication” (comunicazione a distanza ravvicinata) ed è una famiglia di sistemi di nuova generazione, strettamente correlata agli RFID a 13,56 MHz, utilizzata esclusivamente per applicazioni operative a brevissime distanze (max 10 cm). Questa nuova tecnologia include l’operatività bidirezionale P2P (acronimo di Peer-to-Peer), un particolare protocollo utilizzato per mettere in comunicazione tra loro due Reader; poiché anche questi posseggono un proprio UID e quindi sono univocamente identificabili, possono scambiare informazioni tra loro senza ricorrere ai Tag; in pratica sono costituiti da un unico circuito contenente sia un Reader attivo che un Tag passivo con caratteristiche operative compatibili con lo standard ISO 14443, adatte quindi ad applicazioni che richiedono grande sicurezza, come i pagamenti elettronici.
Quando entrano in contatto due apparecchi NFC, il Reader di quello che deve effettuare l’operazione si mette in contatto col Tag dell’altro, che gestisce l’operazione. Una volta che i due apparecchi sono in collegamento si attiva la comunicazione classica attiva-passiva che permette al primo apparecchio di assumere informazioni dall’altro, oppure quella innovativa attiva-attiva, che porta ad uno scambio di dati, in assoluta sicurezza. I circuiti NFC vengono inseriti, lato utente, in un apparato elettronico dotato di tutte le caratteristiche necessarie alla sua funzione (interfaccia utente, collegamento alla rete) come uno smartphone, mentre lato service (erogatore del servizio) in uno strumento specializzato per quella determinata operazione (POS, biglietteria). Esistono anche applicazioni P2P che sono praticabili mediante due sistemi utente. Il ruolo dell’NFC comunque si limita a creare un canale di collegamento sicuro tra due sistemi, non gli spetta la parte esecutiva dell’eventuale operazione finanziaria. La tecnologia NFC, specialmente se associata ad uno smartphone, permette di compiere svariate operazioni: aprire un link web, attivare o disattivare il Bluetooth o il WiFi, visualizzare (e salvare nella rubrica) un biglietto da visita in formato V-Card, aprire un’e-mail con campi precompilati, aprire o salvare un numero di telefono, avviare un’APP integrata nello smartphone, visualizzare un testo semplice, aprire un SMS precompilato (Fig. 2). Praticamente tutti i Tag riscrivibili di nuova generazione possono essere formattati secondo lo standard NFC, diventando interoperabili con le numerose APP disponibili per il mondo degli smartphone. I dispositivi NFC hanno 3 diverse modalità operative che vengono utilizzate in diversi scenari di comunicazione:
• Modalità Read/Write: il dispositivo NFC legge o scrive Tag NFC;
• Modalità emulazione card: il dispositivo NFC emula un Tag o una Smart Card;
• Modalità peer-to-peer (P2P): due dispositivi NFC scambiano informazioni tra loro.

Fig. 2

NDEF è l’acronimo di NFC Data Exchange Format ed è un formato standardizzato per i dati, che garantisce che le informazioni possano essere programmate su Tag NFC ed essere lette correttamente da dispositivi NFC diversi, con programmi e sistemi operativi differenti.
Per le nostre esercitazioni con l’RFID abbiamo acquistato una serie di supporti RFID/NFC, visibili in Fig. 3, si tratta di tre Tag portachiavi colorati, una CARD e due tipologie di adesivi NFC, uno neutro e l’altro con un logo colorato.

Fig. 3

Il modulo Elechouse PN532

• Modalità lettore/scrittore RFID.
• Supporto schede Mifare 1k, 4k, Ultralight e DesFire, schede ISO/IEC 14443-4 come CD97BX, CD light, DesFire, P5CN072 (SMX), carte Innovision Jewel come la IRT5001, schede FeliCa come RCS_860 e RCS_854.
• Funzionamento come card 14443-A virtuale.
• Supporto NFC con telefoni Android.
• Antenna PCB incorporata, con distanza di comunicazione 5 ÷ 7 cm.
• Cambio di livello on board, Standard 5V TTL per I²C e UART, 3,3V TTL SPI.
• Dimensioni: 42,7 x 40,4 x 4 mm.
• Tensione di alimentazione: 3,3V÷5V.
• I²C/UART: 3,3V÷24V TTL.
• Supporto I²C, SPI e HSU.
• SPI: 3.3V TTL con resistore da 100 ohm in serie. Può essere collegato direttamente all’interfaccia 5V di una scheda a microcontrollore come Arduino.

Ora che abbiamo le idee chiare sulla tecnologia RFID-NFC, possiamo presentare questo modulo realizzato dalla Elechouse e basato sul chip PN532, prodotto dalla NXP. Il modulo (codice 2846-PN532) è dotato di ben tre interfacce con il mondo dei microcontrollori: I²C, SPI e HSU (High Speed UART). Il bordo bianco disegnato attorno al modulo copre e protegge l’antenna integrata del modulo che, come abbiamo visto nell’introduzione, è estremamente importante ai fini del funzionamento del circuito. A tal proposito una nota riportata nel manuale che abbiamo tradotto in Italiano e verrà fornito con il modulo, spiega che i collegamenti tra il modulo e l’Arduino vanno effettuati in modo che i fili incrocino l’antenna a 90° altrimenti ne potrebbero compromettere il buon funzionamento. Prima di collegare il modulo ad una board Arduino, occorre settarlo in base all’interfaccia che si desidera utilizzare. A tale scopo sul modulo c’è un mini dip-switch a due poli, le cui combinazioni stabiliscono il tipo di interfaccia da adottare (Tabella 1).


Tabella 1

Per i collegamenti consigliamo di saldare sul modulo dei pin a 90°, così da soddisfare le indicazioni tecniche di Elechouse; una serie di cavetti jumper F-M e F-F permetteranno di completare il collegamento. Nel caso di un sistema stand-alone si potrebbero saldare i fili direttamente nei fori, ma sempre garantendo l’attraversamento dell’antenna a 90°. Per quanto riguarda i collegamenti tra il modulo ed Arduino occorre tenere presente che le due modalità I²C e HSU condividono gli stessi pin quindi accanto al connettore a 4 pin sono presenti due serigrafie, la prima sulla faccia superiore per l’I²C e la seconda sulla faccia inferiore per l’HSU; l’altro connettore, a 8 pin, riporta invece tutte le connessioni del collegamento SPI, oltre ad un pin aggiuntivo per l’IRQ ed un altro per il RESET. La Tabella 2 riporta tutti i collegamenti da fare per le tre modalità in base alla board Arduino che si possiede; nelle nostre sperimentazioni comunque useremo Arduino UNO. Descriviamo ora nello specifico i tre tipi di collegamenti in base all’interfaccia selezionata sul modulo; alcuni ci torneranno utili nella sperimentazione della libreria che abbiamo testato in questo articolo.

Tabella 2

Collegamenti per l’interfaccia SPI

Questi collegamenti si possono effettuare in due modi: ricorrendo agli header di Arduino oppure al connettore ICSP (più un pin dell’header).
La Fig. 4 illustra il cablaggio per la prima modalità.

Fig. 4

In Fig. 5 sono proposte le connessioni per la seconda modalità; per facilitare il collegamento ICSP ne riportiamo sotto la piedinatura. Nei dip del modulo bisogna impostare il pin 1 su OFF ed il pin 2 su ON.

Fig. 5

Collegamenti per l’interfaccia I²C

Alcuni sketch richiedono espressamente il collegamento I²C, che è più semplice in quanto necessita solo di quattro fili: due per l’alimentazione e due per i segnali, sono riportati in Fig. 6. Una volta effettuati i collegamenti occorre settare il doppio dip switch, pin 1 su ON e pin 2 su OFF.

Fig. 6

Il collegamento I²C richiede l’utilizzo di 2 resistori da 10k con funzione di pull-up, cioè collegati tra i due segnali SDA e SCL ed i 5V, in mancanza il modulo facilmente non sarà riconosciuto o lavorerà in modo anomalo. La cosa si risolve facilmente con l’aggiunta di una breadboard, di due resistori e alcuni cavetti jumper (schema proposto in Fig. 7).

Fig. 7

Collegamenti per l’interfaccia HSU

L’ultima tipologia di collegamento prevista è l’HSU che, lato PN532, usa gli stessi pin per l’interfacciamento con Arduino. Infatti la serigrafia evidenzia i collegamenti I²C sul lato superiore del PCB e quelli HSU sul lato inferiore. Quindi anche in questo caso servono solo quattro fili: due per l’alimentazione e due per i segnali, come riportato nello schema di cablaggio in Fig. 8 (pin 0 Arduino su TXD modulo e pin 1 Arduino su RXD modulo).

Fig. 8

Una volta effettuati i collegamenti occorre settare il doppio dip switch: pin 1 su OFF e pin 2 su OFF. Considerate che, nel caso in cui questa modalità di collegamento venga adottata per un firmware che preveda l’utilizzo del Monitor Seriale, si creerebbe un conflitto, in quanto l’unica seriale di Arduino UNO sarebbe già occupata per la comunicazione con il microcontrollore di Arduino e non potrebbe inviare dati anche al Monitor Seriale. In questo caso è possibile utilizzare una board Arduino MEGA 2560, che possiede ben quattro seriali. I collegamenti da effettuare sono come quelli in Fig. 9.

Fig. 9

Naturalmente anche in questo caso occorre settare il doppio dip switch: pin 1 su OFF e pin 2 su OFF.
Esiste comunque un’alternativa software, per chi non possiede una board Arduino MEGA e vuole usare Arduino UNO; è sufficiente includere nel firmware la libreria “SoftwareSerial.h” ed usare il relativo comando di simulazione seriale “SoftwareSerial SWSerial(2, 3);” con il quale in pratica si settano i pin 2 e 3 al posto dei pin 0 e 1, quindi i collegamenti da fare diventano quelli in Fig. 10.

Fig. 10

Libreria e hardware per i nostri test

Le librerie realizzate per il chip PN532 sono numerose, ognuna ha le sue peculiarità, ma fondamentalmente sono simili tra loro; nelle numerose prove che abbiamo effettuato, la più consona ai nostri scopi si è rivelata la “SEEED_ARDUINO_NFC”; per utilizzarla occorre andare al link https://github.com/Seeed-Studio/Seeed_Arduino_NFC, eseguire il comando “Download ZIP” dal pulsante CODE (Fig. 11), scegliere il percorso per scaricare il file “Seeed_Arduino_NFC-master.zip” ed infine rinominare il file in “Seeed_Arduino_NFC.zip”.
Aprire quindi un nuovo sketch con una versione aggiornata dell’IDE (nel nostro caso 1.8.12) eseguire il comando Sketch – #include libreria – Aggiungi libreria da file .ZIP… e selezionare il file .zip, quindi chiudere l’IDE. La libreria è disponibile anche nella sezione download alla fine di questo post col nome “Seeed_Arduino_NFC.zip”.
Quanto all’hardware, abbiamo deciso di collegare il modulo PN532 alla board Arduino UNO mediante I²C-Bus, visto che questo metodo ci tornerà utile per il progetto che vi presenteremo a fine articolo.

Fig. 11

Gli sketch di test

Useremo i supporti visti nell’introduzione e gli sketch che mette a disposizione la libreria.
Apriamo l’IDE chiuso in precedenza, dopo aver incluso la libreria, ed impostiamo correttamente i parametri relativi alla board Arduino UNO ed alla COM ad essa associata.

Read Tag: lettura dei dati contenuti nei supporti

Mediante il comando “Apri” troviamo lo sketch Read Tag all’interno della nostra libreria; una volta aperto chiudere eventuali altri sketch aperti nell’IDE. Prima di poter essere caricato su Arduino lo sketch deve essere correttamente impostato, in quanto prevede la possibilità di operare con tutte le modalità del modulo: SPI, HSU, Software serial e I²C. Il principio per l’impostazione è semplice in quanto bisogna agire su un ciclo “if”, impostando a 1 il tipo di collegamento adottato; per facilitare il compito del lettore abbiamo preparato la tabella riepilogativa Tabella 3. Nel nostro caso (modalità I²C) in pratica dobbiamo impostare a 0 sia l’if della riga 4 (“#if 0 // use SPI”) che le “elif” delle righe 9 e 14. Se invece decidessimo di usare una delle due modalità SPI, la riga 4 andrà impostata come “#if 1 // use SPI” e la riga 7 andrà modificata in “PN532_SPI pn532spi(SPI, 10);”, in quanto noi usiamo il pin 10 per pilotare la linea SS e non il pin 9 previsto dallo sketch originale.

Tabella 3

Attenzione che i numeri di riga potrebbero cambiare, ma sarà facile localizzarli. Infine, a chi dispone di una vecchia versione di Arduino UNO, ma in generale non si sbaglia nemmeno con quelle più recenti, conviene aggiungere, come prima riga della “void setup” l’istruzione “delay(500);” lo scopo è quello di evitare blocchi indesiderati della seriale dell’Arduino, che potrebbero impedire successivi caricamenti di sketch sulla board. Prima del caricamento su Arduino occorre salvare lo sketch con le modifiche, il programma impedisce la sovrascrittura dei file originali, poco male, scegliamo come percorso la cartella Sketch predisposta per il nostro IDE, ed al suo interno ne creiamo una per i nostri scopi “SeeedArduinoNFC_test”, e vi salviamo il nostro sketch personalizzato. A questo punto possiamo usare il comando “Carica” per programmare Arduino con lo sketch di prova. Nel momento in cui finisce il caricamento dobbiamo semplicemente aprire il Monitor Seriale, nel caso succeda nulla o appaiano caratteri strani sicuramente occorre settare la velocità del collegamento seriale, portandola allo stesso valore dello sketch, ossia 9.600 baud, immediatamente apparirà il testo:

NDEF Reader
Found chip PN532
Firmware ver. 1.6
Scan a NFC tag

Il programma, una volta lanciato, ogni 5 secondi cerca di trovare un supporto RFID/NFC, appena ne avviciniamo uno viene immediatamente intercettato e letto. In questa prova alcuni supporti sono stati precedentemente programmati, per poter mostrare cosa viene visualizzato al momento della lettura. Se si vuole leggere più volte lo stesso supporto, tra una prova e l’altra deve essere allontanato dal modulo. In Fig. 12 vedete i risultati di questo primo test.
• Tag ROSSO e ARANCIONE: non sono formattati secondo il protocollo NDEF, sono riconosciuti come NFC Tag – Mifare Classic, viene mostrato il loro UID (identificativo univoco) e segnalato che non ci sono dati memorizzati.
• Tag BLU, ADESIVO NEUTRO e CARD: sono riconosciuti come NFC Tag – NFC Forum Type 2, viene mostrato il loro UID, contengono 1 record di 3 byte vuoti.
• ADESIVO COLORATO: riconosciuto come NFC Tag – NFC Forum Type 2, viene mostrato il suo UID, contiene 2 record (25 e 37 byte), il primo è di tipo “0x2 Mime Media” e contiene l’istruzione “com.android.chrome” per aprire il browser, mentre il secondo è di tipo “0x4 External” e contiene due istruzioni: il prefisso android.com:pkg e l’istruzione “com.wakdev.nfctasks”.

Fig. 12

Write Tag: scrittura di dati nei supporti

Con le stesse modalità viste per il precedente aprire lo sketch Write Tag, all’interno della libreria, e chiudere eventuali altri sketch aperti nell’IDE. Questo sketch può operare solo con le modalità SPI e I²C: nel primo caso, il nostro, occorre impostare a “1” la riga 3, nel secondo caso va lasciata a 0; occorre poi aggiungere la solita istruzione “delay(500);” come prima riga della “void setup”, ed infine tradurre in modo adeguato i testi “messaggio” che vedremo poi sul Monitor Seriale:

Riga 28: “\n avvicina un supporto compatibile al lettore”
Riga 31: message.addUriRecord(“https://www.arduino.cc/”);
Riga 35: SERIAL.println(“Fatto. Prova a leggere il supporto col tuo smartphone.”);
Riga 32: SERIAL.println(“Scrittura fallita.”);

Questo programma, una volta rilevata la presenza di un supporto compatibile vi scrive un indirizzo internet in un record (riga 31); avvicinando successivamente uno smartphone al Tag/CARD, il browser predefinito aprirà il sito internet pre-memorizzato.
Se invece di un URL volessimo memorizzare nel Tag un messaggio di testo (in questo caso “Ciao, Arduino!”) sarà sufficiente modificare la sola riga 31, con la sintassi:

Riga 31: message.addTextRecord(“Ciao, Arduino!”);

Questa opzione ci tornerà utile per l’ultimo progetto pratico. Notate che i numeri di riga potrebbero cambiare, ma sarà facile localizzarli.
Dopo aver salvato lo sketch modificato nella nostra cartella sketch, possiamo caricarlo sull’Arduino UNO e, al termine, aprire il Monitor Seriale.
Il programma, una volta lanciato, ogni 5 secondi cerca di trovare un supporto RFID/NFC formattato, se lo trova effettua l’operazione di scrittura cancellando il contenuto precedente, in caso contrario (supporto non formattato) restituisce un errore specifico. Infatti utilizzando i supporti letti in precedenza ci siamo trovati di fronte a due esiti: i due Tag non formattati secondo lo standard NDEF hanno restituito l’errore visibile nell’immagine di sinistra in Fig. 13; tutti gli altri hanno originato l’immagine di destra.

Fig. 13

Per verificare cosa è successo nei contenuti dei supporti abbiamo fatto ricorso nuovamente al programma “Read Tag”: i due Tag non formattati (rosso e arancione) hanno ridato la stessa immagine della Fig. 13, mentre tutti gli altri hanno dato il risultato visibile nella Fig. 14: riconosciuto come NFC Tag – Mifare Classic, viene mostrato il suo UID, contiene 1 record (28 byte) di tipo “0x1 Well Known” e contiene l’istruzione “https://www.arduino.cc” per aprire il browser.

Fig. 14

A questo punto possiamo verificare il funzionamento dei supporti formattati programmati, disponendo di un qualsiasi smartphone Android dotato della funzione NFC.
La prima operazione da fare è quella di entrare nelle Impostazioni, localizzare l’icona “NFC” ed attivarla, quindi entrare nelle sue proprietà ed attivare l’opzione “Beam” (Fig. 15).

Fig. 15

A questo punto è sufficiente avvicinare il sensore dello smartphone ad uno qualsiasi dei supporti e si otterrà un segnale acustico di conferma lettura e l’immediata apertura della home page del sito ufficiale di Arduino. Nei casi in cui, come nel caso dello smartphone usato per le prove, non vi sia un browser predefinito c’è il passaggio intermedio della richiesta tipica di queste situazioni (Fig. 16).

Fig. 16

Write Tag Multiple Records: scrittura multipla di dati nei supporti

Aprire lo sketch WriteTagMultipleRecords, all’interno della nostra libreria e chiudere eventuali altri sketch aperti nell’IDE. Anche questo sketch può operare solo con le modalità SPI e I²C: nel primo caso, il nostro, occorre impostare a “1” la riga 3, nel secondo caso va lasciata a 0; occorre poi aggiungere la solita istruzione “delay(500);” come prima riga della “void setup”, ed infine tradurre in modo adeguato i testi “messaggio” che vedremo poi sul Monitor seriale:

Riga 28: “\n avvicina un supporto compatibile al lettore”
Riga 31: message.addTextRecord(“Ciao, Arduino!”);
Riga 32: message.addUriRecord(“https://www.arduino.cc/”);
Riga 33: message.addTextRecord(“Arrivederci, Arduino!”);
Riga 36: SERIAL.println(“Fatto. Prova a leggere il supporto col tuo smartphone.”);
Riga 38: SERIAL.println(“Scrittura fallita.”);

Questo programma opera in modo simile al precedente, con la differenza che prima e dopo il comando url invia dei messaggi di testo che saranno tutti visualizzati nello smartphone. I messaggi visibili nel Monitor seriale sono gli stessi del Write Tag.
Anche in questo caso ricorriamo al programma “Read Tag” per verificare il Tag appena usato per il test, con il risultato visibile nella Fig. 17: riconosciuto come NFC Tag – Mifare Classic, viene mostrato il suo UID, contiene 3 record (21, 23, 28 byte) di tipo “0x1 Well Known” e contiene il messaggio iniziale “Ciao, Arduino” (“en” è il prefisso usato automaticamente per lo sketch di testo), l’istruzione “https://www.arduino.cc” per aprire il browser ed il messaggio finale “Arrivederci, Arduino!”.

Fig. 17

Naturalmente anche in questo caso facciamo un test di lettura con il nostro smartphone, il risultato è visibile in Fig. 18: ci sono i due messaggi e tra di essi l’esecuzione dell’URL.

Fig. 18

Programmi utility

Diamo ora uno sguardo ad alcune utility per pulire, cancellare o formattare i supporti. iniziamo da CleanTag, un programma che ripristina il Tag allo stato di fabbrica; nel caso di un Mifare Classic, ad esempio formattato come Tag NFC, viene azzerato e riportato al tipo Mifare Classic originale.
Nel caso di Mifare Ultralight, i Tag vengono azzerati e lasciati vuoti.
Per usarlo aprire lo sketch dalla libreria ed eseguire le due solite modifiche (riga 6 e delay in Setup) e le traduzioni:

Riga 31: SERIAL.println(“\nposiziona un Tag Mifare Classic non formattato sul modulo.”);
Riga 37: SERIAL.println(“\nSuccesso, il Tag è stato ripristinato alle condizioni di fabbrica.”);
Riga 39: SERIAL.println(“\nTag non ripristinabile.”);

Caricare il programma su Arduino UNO; l’operazione si effettua avvicinando il Tag al modulo, e andrà a buon fine solo se il Tag originario è di tipo Mifare Classic, altrimenti il programma darà errore. In Fig. 19 la conferma del buon fine dell’operazione fatta su un Tag portachiavi Mifare Classic (blu).
Leggendo ora il Tag con il “Read Tag” verrà restituito quanto di seguito:

NDEF Reader
Found chip PN532
Firmware ver. 1.6
Scan a NFC tag
Tag is not NDEF formatted
NFC Tag – Mifare classic
UID A9 1D 1A A3
No NDEF Message

indicante che il tag non è formattato NDEF, è di tipo Mifare classic e appare anche l’UID.

Fig. 19

FormatTag

Questo programma serve per trasformare un Tag Mifare Classic in un Tag NDEF. Aprire lo sketch FormatTag all’interno della nostra libreria, e chiudere eventuali altri programmi aperti nell’IDE. Questo sketch può operare solo con le modalità SPI e I2C: nel primo caso, il nostro, occorre impostare a “1” la riga 6, nel secondo caso va lasciata a 0; occorre poi aggiungere la solita istruzione “delay(500);” come prima riga della “void setup”, ed infine tradurre in modo adeguato i testi “messaggio” che vedremo poi sul Monitor Seriale:

Riga 32: SERIAL.println(“\nposiziona un Tag Mifare Classic non formattato sul modulo.”);
Riga 37: SERIAL.println(“\nSuccesso, il Tag è stato formattato come NDEF.”);
Riga 39: SERIAL.println(“\nFormattazione fallita.”);

Carichiamo ora il programma su Arduino UNO; l’operazione si effettua avvicinando il Tag al modulo, e andrà a buon fine solo se il Tag originario è di tipo Mifare Classic, altrimenti il programma darà errore. In Fig. 20 la conferma del buon fine dell’operazione fatta su un Tag portachiavi Mifare Classic (arancione).

Fig. 20

Leggiamo ora il Tag appena formattato con il solito “Read Tag”: come mostra la Fig. 21, il contenuto del Tag ARANCIONE, che è diventato identico a quello blu, che era stato formattato prima dell’inizio di queste prove.

Fig. 21

EraseTag

Questo programma Cancella un tag NFC scrivendo un messaggio NDEF vuoto. Per provarlo caricare lo sketch dalla libreria ed eseguire le due solite modifiche (riga 4 e delay in Setup) e le traduzioni:

Riga 29: SERIAL.println(“\nPosiziona il Tag
da cancellare sul modulo.”);
Riga 35: SERIAL.println(“\nSuccesso, il Tag ora
contiene un record vuoto.”);
Riga 37: SERIAL.println(“\nTag non cancellabile.”);

Caricare il programma su Arduino UNO; l’operazione si effettua avvicinando il Tag al modulo, e andrà a buon fine solo se il Tag è di tipo NFC, altrimenti il programma darà errore. In Fig. 22 è visualizzata la conferma del buon fine dell’operazione fatta su un Tag NFC colorato.

Fig. 22

Leggendo ora il Tag con il comando “Read Tag” e confrontando la Fig. 23 con la risposta ottenuta in Fig. 12 risulta evidente come il Tag che prima conteneva due record di 62 byte totali, ora contiene un record vuoto.
Tutti gli sketch qui proposti, opportunamente modificati, sono stati compressi nel file “SeeedArduinoNFC_SKETCH.rar” e sono disponibili nella sezione download alla fine di questo post.

Fig. 23

Riepilogo dei comandi della libreria

Vediamo ora le piccole routine usate all’interno degli sketch precedenti, che ci torneranno utili nel momento in cui vorremo implementare le varie operazioni in un programma nostro.

Lettura di un messaggio memorizzato su un Tag

if (nfc.tagPresent()) {
NfcTag tag = nfc.read();
tag.print();
}

Scrivere un messaggio in un Tag

if (nfc.tagPresent()) {
NdefMessage message = NdefMessage();
message.addTextRecord(“Hello, Arduino!”);
success = nfc.write(message);
}

Cancellare un Tag

if (nfc.tagPresent()) {
success = nfc.erase();
}

Formattare un Tag Mifare Classic come NDEF

if (nfc.tagPresent()) {
success = nfc.format();
}

Resettare un Tag per riportarlo allo stato di fabbrica

if (nfc.tagPresent()) {
success = nfc.clean();
}

NfcTag

La lettura di un Tag con il modulo restituisce un oggetto Tag NFC, che contiene metadati memorizzati sul Tag, come l’UID, la tipologia, dimensione della memoria. Quando viene letto un Tag NDEF, il Tag NFC contiene un “Ndef Message”.

NdefMessage

Un NdefMessage è costituito da uno o più “NdefRecords”. L’oggetto NdefMessage dispone di metodi di supporto per l’aggiunta di record:

ndefMessage.addTextRecord(“hello, world”);
ndefMessage.addUriRecord(“https://arduino.cc/”);
// url per aprire una pagina Internet

L’oggetto NdefMessage è responsabile della codifica di un messaggio NDEF in byte in modo che possa essere scritto in un Tag. Esso inoltre effettua l’operazione opposta, decodificando i byte letti da un messaggio NDEF memorizzato in un Tag.

NdefRecord

Un NdefRecord trasporta un payload, le cui informazioni sono all’interno di un NdefMessage.

PN532 e libreria Seeed_Arduino_NFC

Per concludere questo articolo non c’è niente di meglio che mettere in pratica quanto abbiamo detto finora. Come vedremo è un circuito che si replica molto facilmente ma che può costituire la base per realizzare un sistema di controllo molto più potente. Il firmware che abbiamo preparato per il suo funzionamento è immediatamente scaricabile alla fine di questo post. Avendo chiaro che ogni Tag dispone di un proprio UID (Identificativo univoco) ovviamente il firmware dovrà essere modificato, non solo tenendo conto delle indicazioni viste con lo studio della libreria, ma anche nei valori di UID, sostituendo quelli esistenti con quelli in vostro possesso, che potrete ottenere facilmente con il programma di lettura “Read Tag”, già descritto. Il semplice circuito che vi proponiamo controlla l’accensione e lo spegnimento di tre LED di diverso colore in base al Tag che avviciniamo al modulo PN532. I colori scelti rispecchiano quelli dei tre Tag portachiavi di cui disponevamo per le prove.
Oltre ad Arduino UNO e al modulo PN532 occorre:

• una breadboard con le linee di alimentazione laterale (rossa e nera oppure rossa e blu);
• LED arancione, rosso e blu 5 mm;
• 3 resistori da 220 ohm;
• 2 resistori da 10 kohm;
• 4 cavetti jumper M-M lunghi;
• 3 cavetti jumper M-M medi;
• 4 cavetti jumper M-F lunghi;
• 3 ponticelli jumper passo 11 (o 3 da 5 + 3 da 6);
• 2 ponticelli jumper passo 5;
• 2 ponticelli jumper passo 2;
• 7 Tag, possibilmente di tipologie differenti, o comunque contrassegnati anche con un semplice numero o lettera o bollino adesivo colorato, in modo che siano distinguibili tra loro.

Per la realizzazione del circuito fate riferimento allo schema di cablaggio illustrato nella Fig. 24.
Il firmware da scaricare è LED_Control.rar (tre schede): la cartella ricavata dalla decompressione del file dovrà essere posizionata nella cartella degli sketch dell’IDE in vostro possesso, naturalmente in precedenza dovrà essere stata installata la libreria.

Fig. 24

Preparazione dei Tag:

Mediante lo sketch “Read Tag” bisogna effettuare la lettura dell’UID di tutti i Tag prendendone nota; poi bisogna sceglierne 3, ed in essi va memorizzato il testo “blu”, “rosso”, “arancione” per replicare il nostro caso, oppure ciò che decidete, mediante lo sketch “Write Tag” opportunamente modificato per la scrittura di testi. Gli altri possono essere lasciati senza contenuto, anche se qualcuno potrebbe necessitare di essere formattato con lo sketch “FormatTag” per acquisire la compatibilità con lo standard NDEF.

Modifiche al firmware

Una volta aperto lo sketch nell’IDE dell’Arduino occorrerà modificare tutte le righe contenenti gli elementi di distinzione dei Tag; in queste indicazioni daremo per scontato che replicherete il progetto come previsto da noi; coloro che sono in grado di modificare lo sketch senza particolari problemi, non avranno bisogno di indicazioni specifiche.
Nella scheda principale la riga 71 dovrà contenere il valore “c = 4” per la corretta interpretazione dei testi memorizzati sui Tag con lo sketch “Write Tag”. Scheda TAG_UID:

Riga 3: sostituire l’UID con quello del vostro
supporto mediante il quale volete ottenere
l’accensione contemporanea dei tre LED;
Riga 9: sostituire l’UID con quello del vostro
supporto mediante il quale volete ottenere
l’accensione contemporanea dei due LED blu e rosso;
Riga 15: sostituire l’UID con quello del vostro
supporto mediante il quale volete ottenere
l’accensione contemporanea dei due LED arancio e rosso;
Riga 23: questa riga non va modificata, nel momento in cui userete un Tag non previsto nelle modifiche si otterranno tre lampeggi di tutti e tre i LED in contemporanea.

Scheda TAG_messaggio:

Righe 3-9-15: contengono i testi memorizzati nei tre Tag, che serviranno per l’accensione dei singoli LED, naturalmente dovranno corrisponde ai testi effettivamente memorizzati nei Tag (facendo attenzione a maiuscole e minuscole) altrimenti il riconoscimento non avverrà.
A questo punto occorre caricare lo sketch sull’Arduino, aprire il Monitor Seriale ed avvicinare uno alla volta i Tag per verificare se tutto è stato fatto correttamente.
Come già detto noi abbiamo usato Tag di diverso tipo, ma possono essere benissimo tutti dello stesso tipo, l’importante è contrassegnarli e creare una tabella con gli elementi personalizzati, altrimenti, in caso di problemi, diventa difficile raccapezzarsi. Un esempio può essere la Tabella 4, realizzata sulla base dei nostri Tag. Per l’esperimento completo servono 7 Tag: tre con i messaggi di testo inseriti nello sketch, tre con gli UID inseriti nello sketch ed uno (o più) con informazioni non inserite nello sketch, tutti quelli di questa categoria provocheranno il lampeggiamento dei tre LED.
Una volta verificato il buon funzionamento del sistema Vi consigliamo di commentare tutte le righe dello sketch che servono per il Monitor seriale, in quanto diventano inutili e rallentano l’esecuzione del firmware. Ovviamente questo progetto è dimostrativo ed ha lo scopo di spiegare come associare un Tag ad una qualsiasi funzione, mediante l’attivazione di un pin; a partire dai comandi essenziali è possibile realizzare dei sistemi di controllo molto più sofisticati.

Tabella 4

Download file del progetto

I file del progetto sono scaricabili direttamente da questo link.

Conclusioni

Bene, arrivati a questo punto non ci resta che augurarvi buon lavoro nel mondo dell’RFID, utilizzando il modulo PN532 e mettendo a frutto le nozioni che vi abbiamo trasmesso in queste pagine.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Main Menu