Come acquisire un tag rfid tramite lettore ID12

In un vecchio articolo avevamo visto come  utilizzare il lettore ID-12 impiegando la scheda Netduino, per acquisire il codice di un tag 125KHz. Ho ricevuto diverse richieste per creare un piccolo tutorial che prevedesse l’uso di una scheda Arduino.
La parte teorica, relativa alla tecnologia rfid e alle caratteristiche del lettore ID-12, rimane pressoché invariata. Anche lo schema elettrico è identico dato che il Netduino possiede la stessa disposizione dei pin come una Arduino UNO. Per chiarezza riporto comunque  i collegamenti tra la UNO ed il lettore di tag.

Arduino ID-12LA

nella tabella seguente trovate l’elenco dei collegamenti tra Arduino UNO e lettore ID-12

Pin Arduino UNOpin ID-12
 5V dc pin 11 (Vcc)
 Gnd pin 1 (Gnd)
 5V dcpin 2 (Res)
pin 0 (RX)pin 9 (D0)
Gndpin 7 (+/-)
pin 10 (Led)

il pin 10 (led) del lettore ID-12 può essere collegato ad un led o ad un piccolo buzzer. Ogni volta che avvicineremmo un tag rfid, sul pin 10 avremmo un segnale ad onda quadra che permette appunto di illuminare un led o di far suonare un piccolo buzzer.

Il codice dello sketch

A questo punto dovremmo scrivere alcune righe di codice che ci permetteranno semplicemente di leggere i byte in arrivo sulla seriale della UNO.

[c]

void setup()
{
//init seriale a 9600 bps
Serial.begin(9600);
}

void loop()
{
//verifico la presenza di dati in arrivo
if(Serial.available() > 0)
{
//leggo il primo dato
char rx = Serial.read();
//e lo spedisco sul serial monitor
Serial.print(rx);
}
}
[/c]

per verificare tutto il sistema apriamo il serial monitor, impostiamo la velocità di trasmissione a 9600 baud, e avviciniamo un tag rfid al lettore. Se non ci sono stati errori otterremo l’accensione del led collegato all’ID-12 e la rappresentazione sul serial monitor di un codice alfanumerico. Avvicinando più volte il tag dovremmo ottenere sempre lo stesso codice.

Il codice precedente non considera però i caratteri speciali che vengono inviati dal lettore ID-12, infatti se modifichiamo il codice in modo da restituire tutti i valori che arrivano sulla porta seriale di Arduino UNO ci accorgeremmo che oltre al codice del tag sono presenti anche dei caratteri speciali aggiuntivi, che il serial monitor non mostra:

[c]
void setup()
{
//init seriale a 9600 bps
Serial.begin(9600);
}

void loop()
{
//verifico la presenza di dati in arrivo
if(Serial.available() > 0)
{
//leggo e spedisco al serial monitor tutto cio
//che arriva alla porta seriale
//ad ogni lettura invio anche un ritorno a capo
//in modo da mostrare tutti i singoli valori
//uno in ogni riga
Serial.println(Serial.read());
}
}
[/c]

avvicinando nuovamente il tag rfid otteniamo dei valori decimali che rispecchiano questo schema:

Struttura dati ID-12 reader

nella figura seguente viene mostrato il serial monitor con tutti i byte letti dal lettore:

schema rfid

il primo carattere che viene inviato all’Arduino UNO è sempre identico per ogni tag rfid letto e ha il valore decimale 2, successivamente vengono spediti 10 caratteri che formano il codice del tag rfid, poi vengono spediti 2 caratteri che permettono di verificare il dato letto, tramite un semplice calcolo crc.
Infine viene spedito un carattere di ritorno a capo e di nuova linea, e per ultimo il carattere di chiusura 3 decimale.

Questo piccolo sistema ci permette di creare applicazioni più evolute e utili. Ad esempio per creare un piccolo sistema di controllo, per il quale se il tag rfid corrisponde ad un dato codice viene attivata un’uscita di Arduino UNO (per accendere una lampada o attivare un relè), possiamo modificare il codice in questo modo:

[c]
byte datarfid[16];
byte index = 0;

String tag ="";

void setup()
{
//init seriale a 9600 bps
Serial.begin(9600);

delay(100);
}

void loop()
{
//attendo la presenza di tutti e 16 byte provenienti
//dal lettore id-12
if(Serial.available() >= 16)
{
//leggo ogni byte e lo memorizo nell’array
//precedentemente definito
for(index = 0; index <= 15; index++)
{
datarfid[index] = Serial.read();
}

//ora ricavo i 10 byte che compongono il codice del tag
//e li concateno in un ogetto stringa
//da notare la conversione dei byte in char
for(index = 1; index <= 10; index++)
{
//concateno la stringa convertendo i byte in char
tag += (char)datarfid[index];
}

//ora verifico se il codice del tag corrisponde
//a quello memorizzato nel sistema
if(tag == "44118837F4")
//se il codice è identico allora esegui qualcosa!
Serial.println("Codice OK");

tag="";
}
}
[/c]

La gestione di tag rfid sta diventando sempre più massiccia e credo che diverrà un perno delle applicazioni legate all’IOT. L’implementazione di questi sistemi è semplice ed anche il costo dei tag e dei lettori è molto economico.