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.

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

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.

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

void loop()
{
  //verifico la presenza di dati in arrivo
  if (Serial.available() == 16) 
  {
    //leggo i dati presenti sulla seriale e
    //gli invio sul serial monitor
    for (int i = 0; i < 16; i++) 
    {
      Serial.print(Serial.read());
      Serial.print(" ");
    }
    Serial.println();
  }
}

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:

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());
  }
}

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

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

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:

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="";
    }
  }
}

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.

The post Arduino leggere tag rfid con ID-12 appeared first on Esperimenti con logiche programmabili.

La realizzazione di sistemi basati sulla tecnologia rfid è oggi alla portata di tutti vista la disponibilità di componenti a basso costo necessaria alla produzione di un prodotto completo. Il prototipo che ho realizzato per questo articolo si basa principalmente su un Netduino, versione standard, e sul lettore rfid ID-12 della Innovations, utilizzato in un precedente articolo.

Lo scopo del progetto è quello di permettere l’accesso controllato in una particolare area utilizzando unicamente il Netduino per memorizzare una lista di utenti autorizzati. In caso di riconoscimento il circuito azionare un classico relè che potrebbe essere collegato ad un apri porta elettromeccanico tipico dei sistemi citofonici.

Il circuito è il seguente:

Per quanto riguarda il codice caricato sul Netduino osserviamo che i codici dei tag rfid sono memorizzati in un array di stringhe. Questi valori vengono confrontati con il codice ottenuto dal lettore ID-12 e quando si verifica un’uguaglianza viene attivato il relè che andrà a comandare l’apri porta.
Nel codice è presente anche il calcolo del crc che permette di ottenere una maggiore sicurezza nella lettura ed interpretazione del codice del tag.

[csharp]
public static Byte ConvHexToByte(String Value)
{
if (Value.Length == 2)
{
String str1 = Value.Substring(0, 1);
String str2 = Value.Substring(1, 1);

if (str1.ToUpper() == "A")
str1 = "10";

if (str1.ToUpper() == "B")
str1 = "11";

if (str1.ToUpper() == "C")
str1 = "12";

if (str1.ToUpper() == "D")
str1 = "13";

if (str1.ToUpper() == "E")
str1 = "14";

if (str1.ToUpper() == "F")
str1 = "15";

//###########################
if (str2.ToUpper() == "A")
str2 = "10";

if (str2.ToUpper() == "B")
str2 = "11";

if (str2.ToUpper() == "C")
str2 = "12";

if (str2.ToUpper() == "D")
str2 = "13";

if (str2.ToUpper() == "E")
str2 = "14";

if (str2.ToUpper() == "F")
str2 = "15";

//converto i singoli caratteri in valori byte
Byte b1 = Byte.Parse(str1);
Byte b2 = Byte.Parse(str2);
//onverto i duebyte in un valore hex
Byte cv = (Byte)(b1 * 16 + b2);

//Debug.Print(cv.ToString());
return cv;

}

return 0;

}

public static void Main()
{

String[] Codice = { "06003906B1",
"060030EF42",
"060039EF42",
"060038EF42",
"060037EF42",
"060036EF42",
"060035EF42",
"060034EF42",
"060033EF42",
"060032EF42",
"060031EF42",
"060038EF02",
"060038EF92",
"060038EF82",
"060038EF72",
};

//Creao un oggetto per lavorare con
//la porta seriale
SerialPort sp = new SerialPort("COM1", 9600, Parity.None, 8, StopBits.One);
OutputPort led = new OutputPort(Pins.ONBOARD_LED, false);
OutputPort Porta = new OutputPort(Pins.GPIO_PIN_D7, false);
OutputPort LedAut = new OutputPort(Pins.GPIO_PIN_D8, false);
OutputPort LedNoAut = new OutputPort(Pins.GPIO_PIN_D9, false);

//Apro la porta
sp.Open();

while (true)
{
//Attesa di 200 millisecondi
Thread.Sleep(200);

//aspetto la lettura di tutti i 16 byte
if (sp.BytesToRead == 16)
{
led.Write(true);
//creo un buffer di 16 byte
Byte[] b = new Byte[sp.BytesToRead];
Byte[] crcTag = new Byte[2];
Byte[] tag = new Byte[10];
Byte Hex01, Hex02, Hex03, Hex04, Hex05, crcRfid, crc;

//leggo dalla seriale i dati inviati dall’ID-12
sp.Read(b, 0, b.Length);

//copio i 10 byte dell’ID del tag in un array dedicato
Array.Copy(b, 1, tag, 0, 10);
Array.Copy(b, 11, crcTag, 0, 2);

//converto i byte in una stringa ASCII
String ValoriAsc = new String(UTF8Encoding.UTF8.GetChars(tag));
String ValoreCrc = new String(UTF8Encoding.UTF8.GetChars(crcTag));

//ottengo i valori esadecimali dalla coppia di byte Ascii
Hex01 = ConvHexToByte(ValoriAsc.Substring(0, 2));
Hex02 = ConvHexToByte(ValoriAsc.Substring(2, 2));
Hex03 = ConvHexToByte(ValoriAsc.Substring(4, 2));
Hex04 = ConvHexToByte(ValoriAsc.Substring(6, 2));
Hex05 = ConvHexToByte(ValoriAsc.Substring(8, 2));
crcRfid = ConvHexToByte(ValoreCrc.Substring(0, 2));

//calcolo il crc mettendo in xor i valori hex
crc = (byte)(Hex01 ^ Hex02 ^ Hex03 ^ Hex04 ^ Hex05);

//printo il valore di crc
Debug.Print(crcRfid.ToString());
Debug.Print(crc.ToString());

if (crcRfid == crc)
{
//eseguo un ciclo che mi printa tutti i singoli
//byte del buffer
Int32 strNumber;
Int32 strIndex = 0;
Boolean Acc = false;

for (strNumber = 0; strNumber < Codice.Length; strNumber++)
{
strIndex = Codice[strNumber].IndexOf(ValoriAsc);
if (strIndex >= 0)
{
Porta.Write(true);
Thread.Sleep(100);
Porta.Write(false);

LedAut.Write(true);
Thread.Sleep(200);
LedAut.Write(false);

Acc = true;

break;

}
}

if (Acc == false)
{
LedNoAut.Write(true);
Thread.Sleep(200);
LedNoAut.Write(false);
}

}
Debug.Print(ValoriAsc);

Thread.Sleep(150);
led.Write(false);
}
}
}

[/csharp]

Il codice per far funzionare il sistema è molto semplice. Con poco hardware è con una spesa inferiore ai 100€ possiamo costruire veramente prodotti basati su tecnologia rfid. Sostituendo il Netduino con il fratello maggiore (Netduino Plus) potremmo dotare il sistema di una memoria SD per il log degli accessi ed un webserver per leggere i file di log.

The post Controllo accessi rfid con Netduino appeared first on Esperimenti con logiche programmabili.

Nell’articolo scritto qualche tempo, che mostrava come impiegare un Netduino ed un lettore rfid ID-12 della Innovations, ho descritto solamente la parte che acquisiva l’id del tag, senza analizzare come calcolare il crc indispensabile per avere la certezza che il dato letto fosse corretto.

Riprendo questo argomento su segnalazione di una gentilissima visitatrice Sabrina Cosolo, che ringrazio per avermi fatto notare un errore nell’illustrazione del calcolo del crc, infatti scrissi che i due byte del crc fossero ottenuti ponendo in OR i 10 byte dell’id del tag.
Questo non è vero in quanto bisogna mettere in XOR i valori esadecimali ottenuti dalla conversione in ASCII dei byte letti dal lettore.

Mi spiego meglio impiegando l’illustrazione seguente

i 10 byte rappresentano l’id del tag, mentre i due byte rappresentano il valore di crc. Il calcolo viene eseguito convertendo i singoli byte in valori ASCII, per ottenere 5 valori esadecimali prendendo 2 byte alla volta, come visibile in figura. Eseguendo un calcolo XOR di questi valori esadecimali otteniamo il calore del CRC.

Ora la difficoltà che ho riscontrato è quella di convertire un byte in un valore esadecimale, semplicissimo da fare con il .Net framework ma non altrettanto con la versione micro (non sono riuscito a trovare delle risorse che svolgessero questo compito!), quindi ho scritto un po di codice per arrangiarmi, mi rendo conto che non è il massimo ma diciamo che per questo esempio funziona!!

Ho commentato il codice per spiegare meglio il funzionamento.

using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;

using System.IO.Ports;
using System.Text;

namespace Netduino_ID12Reader
{
public class Program
{
    public static Byte ConvHexToByte(String Value)
    {
      if (Value.Length == 2)
      {
        String str1 = Value.Substring(0, 1);
        String str2 = Value.Substring(1, 1);

        if (str1.ToUpper() == "A")
          str1 = "10";

        if (str1.ToUpper() == "B")
          str1 = "11";

        if (str1.ToUpper() == "C")
          str1 = "12";

        if (str1.ToUpper() == "D")
          str1 = "13";

        if (str1.ToUpper() == "E")
          str1 = "14";

        if (str1.ToUpper() == "F")
          str1 = "15";

        //###########################
        if (str2.ToUpper() == "A")
          str2 = "10";

        if (str2.ToUpper() == "B")
          str2 = "11";

        if (str2.ToUpper() == "C")
          str2 = "12";

        if (str2.ToUpper() == "D")
          str2 = "13";

        if (str2.ToUpper() == "E")
          str2 = "14";

        if (str2.ToUpper() == "F")
          str2 = "15";

        //converto i singoli caratteri in valori byte
        Byte b1 = Byte.Parse(str1);
        Byte b2 = Byte.Parse(str2);
        //onverto i duebyte in un valore hex
        Byte cv = (Byte)(b1 * 16 + b2);

        //Debug.Print(cv.ToString());

        return cv;

      }

      return 0;
    }

    public static void Main()
    {
      SerialPort sp = new SerialPort("COM1", 9600, Parity.None, 8);
      OutputPort led = new OutputPort(Pins.ONBOARD_LED, false);
      UTF8Encoding asen = new UTF8Encoding();

      //apro la oprta seriale per acquisire i dati dal lettore id-12
      sp.Open();

      while (true)
      {
        Thread.Sleep(200);
        led.Write(false);

        //controllo ciclicamente che arrivino tutti i
        //byte dal lettore
        if (sp.BytesToRead == 16)
        {
          Byte[] b = new Byte[sp.BytesToRead];
          Byte[] tag = new Byte[10];

          Byte Hex01, Hex02, Hex03, Hex04, Hex05, crc;

          //leggo tutti i byte provenienti dal lettore
          sp.Read(b, 0, b.Length);

          //copio i 10 byte dell'ID del tag in un array dedicato
          Array.Copy(b, 1, tag, 0, 10);

          //converto i byte in una stringa ASCII
          String ValoriAsc = new String(UTF8Encoding.UTF8.GetChars(tag));

          //ottengo i valori esadecimali dalla coppia di byte Ascii
          Hex01 = ConvHexToByte(ValoriAsc.Substring(0, 2));
          Hex02 = ConvHexToByte(ValoriAsc.Substring(2, 2));
          Hex03 = ConvHexToByte(ValoriAsc.Substring(4, 2));
          Hex04 = ConvHexToByte(ValoriAsc.Substring(6, 2));
          Hex05 = ConvHexToByte(ValoriAsc.Substring(8, 2));

          //calcolo il crc mettendo in xor i valori hex
          crc = (byte)(Hex01 ^ Hex02 ^ Hex03 ^ Hex04 ^ Hex05);

          //printo il valore di crc
          Debug.Print(crc.ToString());

          if (b[0] == 0x02 && b[13] == 0xD && b[14] == 0xA && b[15] == 0x03)
            led.Write(true);

        }

      }

    }
}
}

Il calcolo del crc può risultare utile nel caso di applicazioni dove la certezza di aver letto bene l’id del tag è fondamentale, come, per esempio in applicazioni come alcune delle applicazioni illustrate nella pagina di wikipedia dedicata al sistema RFID.

Per considerazioni e spiegazioni aggiuntive vi invito a scrivermi nei commenti o tramite mail

al prossimo articolo…

The post Come calcolare il crc del tag con Netduino e lettore RFID ID-12 appeared first on Esperimenti con logiche programmabili.

L’identificazione a frequenza (RFID) è un sistema molto interessante che permette, appunto, di identificare gli oggetti a distanza, in modo automatico. Questa tecnologia si basa sull’uso di transponder, definiti tag, che permettono di trasmettere al lettore (nel nostro caso il reader RFID ID-12), tramite onde radio, i dati contenuti al loro interno.

Possiamo pensare a questa tecnologia come un’evoluzione dei codici a barre, ma che presenta notevoli vantaggi come, la lettura simultanea di tag (anche 200 tag al secondo), una maggiore resistenza all’usura e la capacità di memorizzare diverse informazioni nel loro chip integrato.

I tag presenti in commercio sono di diverso tipo e si presentano spesso come smart card, portachiavi e bande adesive. La figura seguente mostra come è strutturato un tag RFID

La frequenza di funzionamento dei tag può essere tipicamente di 125KHz o 13.56MHz, ma esistono modelli che utilizzano frequenze dell’ordine dei GHz (>2.4GHz).
Le parti principali che lo compongono sono l’antenna è il microchip. L’antenna ha il compito di alimentare il microchip sfruttando il campo elettromagnetico generato dal lettore, e di veicolare verso il lettore il segnale del microchip.

In commercio esistono vari dispositivi evoluti che permettono con poca spesa di creare il proprio sistema RFID. Il dispositivo ID-12 con cui ho avuto esperienza è prodotto dalla Innovations, ha un costo di circa 25-30€ è il suo impiego risulta semplice ed intuitivo. Di seguito la pin function del dispositivo:

Nel lettore ID-12 abbiamo un’antenna integrata che genera un segnale capace di fornire l’alimentazione al tag. Quando avviciniamo il tag al lettore, il microchip viene alimentato ed invia il suo identificativo.
Per lavorare con il lettore possiamo collegare l’ID-12 in questo modo

L’alimentazione di 5Vdc viene fornita tramite i pin 11 e la massa tramite il pin1. Il pin2 (Reset) viene collegato alla 5Vdc, ponendolo a massa otteniamo il reset dell’ID-12.
Il pin10 (LED/Beeper) viene utilizzato per pilotare un bepper(cicalino); questa funzione è molto interessante poiché il segnale viene generato solo quando il tag è letto correttamente.
Il pin7 (Format Selector) gestisce il formato del dato in uscita al pin10; nel mio caso collegandolo a massa ottengo un uscita ASCII (gli altri formati supportati sono Magnet Emulation, collegando il pin7 al pin10 e Wiegand26 collegando il pin7 alla 5Vdc)
Sul pin9 (data pin D0) è disponibile il segnale TTL contenente il dato memorizzato nel tag. Il pin8 (data pin D1) fornisce lo stesso dato ma il segnale è RS232 compatibile, ed quindi possibile collegare questo pin direttamente alla porta seriale del pc.

La portata dell’antenna integrata dell’ID-12 è di qualche centimetro, sufficiente per il nostro esperimento (ma è possibile portare il range di lettura a circa 10-12 cm collegando un’antenna esterna sui pin 3 e 4).
Lo schema successivo mostra i collegamenti da effettuare con il Netduino:

Il circuito è identico allo schema base visto precedentemente, l’uscita dell’ID-12 (pin9) è collegata al pin0 (UART RX) del Netduino.

Alimentiamo il Netduino e proviamo ad avvicinare un tag al dispositivo per verificare che il led sul pin10 si accenda, dandoci conferma della corretta lettura del tag.
Il formato ASCII del dato restituito dal lettore ID-12 è composto da 16 byte ed è rappresentato in figura:

• Il primo byte rappresenta lo Start TX e vale 0x02
• Data è composto da 10 byte che rappresentano l’ID del tag
• Checksum vale 2 byte e si ottiene ponendo in XOR i 10 byte di dati
• Il byte 14 è un Carrier Return e vale 0x13
• il byte 15 è un Line Feed e vale 0x10
• il byte 16 rappresenta l’End TX e vale 0x03

Ora passiamo scrivere il codice C# per questo circuito

Int32 Ciclo = 0;
//Creao un oggetto per lavorare con
//la porta seriale
SerialPort sp = new SerialPort("COM1", 9600, Parity.None, 8);

//Apro la porta
sp.Open();

while (true)
{
//Attesa di 200 millisecondi
Thread.Sleep(200);

//aspetto la lettura di tutti i 16 byte
if (sp.BytesToRead == 16)
{
//creo un buffer di 16 byte
Byte[] b = new Byte[sp.BytesToRead];

//leggo dalla seriale i dati inviati dall'ID-12
sp.Read(b, 0, b.Length);

//eseguo un ciclo che mi printa tutti i singoli
//byte del buffer
for (Ciclo = 0; Ciclo < b.Length; Ciclo++)
{
Debug.Print(b[Ciclo].ToString());
}
}
}

Il codice precedente ha evidenziato come leggere i dati provenienti dal lettore ID-12. L’esempio è molto semplice e non ha bisogno di grosse descrizioni.
In questo modo possiamo realizzare qualsiasi applicazione basata sulla tecnologia RFID.

The post Netduino gestire lettore RFID ID-12 appeared first on Esperimenti con logiche programmabili.