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.

Per chi lavora con vb.net vi allego il codice scritto da Alberto De Luca che gentilmente mi ha concesso per condividerlo con voi. Il listato seguente esegue il calcolo del checksum
del tag acquisito con il lettore RFID ID-12 come spiegato nell’articolo precedente.

Public Shared Function VerifyCheckSum(b As Byte()) As Boolean

Dim RetValue As Boolean
Dim tag As [Byte]() = New [Byte](9) {}
Dim Hex01 As [Byte], Hex02 As [Byte], Hex03 As [Byte],
Hex04 As [Byte], Hex05 As [Byte], crc As [Byte]

Array.Copy(b, 1, tag, 0, 10)

Dim ValoriAsc As New [String](UTF8Encoding.UTF8.GetChars(tag))

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))

crc = CByte(Hex01 Xor Hex02 Xor Hex03 Xor Hex04 Xor Hex05)

Debug.Print(crc.ToString())

RetValue = (b(0) = &H2 AndAlso b(13) = &HD AndAlso b(14) = &HA AndAlso b(15) = &H3)

Return RetValue

End Function

Private Shared Function ConvHexToByte(Value As String) As Byte

If Value.Length = 2 Then
Dim str1 As [String] = Value.Substring(0, 1)
Dim str2 As [String] = Value.Substring(1, 1)

If str1.ToUpper() = "A" Then
str1 = "10"
End If

If str1.ToUpper() = "B" Then
str1 = "11"
End If

If str1.ToUpper() = "C" Then
str1 = "12"
End If

If str1.ToUpper() = "D" Then
str1 = "13"
End If

If str1.ToUpper() = "E" Then
str1 = "14"
End If

If str1.ToUpper() = "F" Then
str1 = "15"
End If

If str2.ToUpper() = "A" Then
str2 = "10"
End If

If str2.ToUpper() = "B" Then
str2 = "11"
End If

If str2.ToUpper() = "C" Then
str2 = "12"
End If

If str2.ToUpper() = "D" Then
str2 = "13"
End If

If str2.ToUpper() = "E" Then
str2 = "14"
End If

If str2.ToUpper() = "F" Then
str2 = "15"
End If

Dim b1 As [Byte] = [Byte].Parse(str1)
Dim b2 As [Byte] = [Byte].Parse(str2)
Dim cv As [Byte] = CByte(b1 * 16 + b2)

Return cv

End If

Return 0

End Function

Potete visitare il blog di Alberto ed il suo progetto di Rivelatore presenze con RFID.

The post Calcolare il checksum del tag tramite lettore RFID ID-12 (versione vb.net) 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.