Nonostante i pochi aggiornamenti, il progetto .Net Micro framework è ancora vivo e secondo i progettisti nel prossimo futuro avremmo importanti sviluppi della piattaforma, soprattutto considerando l’impegno di Microsoft sul fronte IoT.

Personalmente mi fa piacere avere degli aggiornamenti per questa piattaforma che reputo, nonostante le performance non esaltanti, molto semplice e versatile. Gli ultimi aggiornamenti riguardano la possibilità (finalmente) di utilizzare, come sistema di sviluppo, Visual Studio 2013.
Inoltre Microsoft ha recentemente rilasciato la versione Comunity che rende disponibile una serie di strumenti per lo sviluppo di diverse tipologie di applicazioni, comprese le app per Windows Phone e quelle per la piattaforma Azure.
L’edizione Comunity porta anche la possibilità di installare plug-in, opzione preclusa per le precedenti versioni Express.

Le versioni che andremo ad installare sono attualmente in versione beta. Scarichiamo la versione 4.3 R2 Beta del .Net MF direttamente dalla pagina del progetto su Codeplex. Eseguiamo l’installazione del pacchetto avendo cura di disinstallare le vecchie versioni:

Dopo l’installazione del Micro Framework, andiamo ad installare il Netduino SDK 4.3.1 (November 2014)

Ora installiamo il plug-in per configurare Visual Studio 2013 Comunity Edition. Il plug lo potete trovare nel file zip relativo al .Net MF scaricato precedentemente. Dovete solamente eseguire un doppio clic sul file netmfvs2013.vsix per avviare l’installazione:

dopo qualche istante il vostro ambiente è configurato.

Avviamo VS 2013 Comunity e creiamo un nuovo progetto Micro Framework:

Ora tutto è pronto per scrivere applicazioni per Netduino con il nuovo sistema di sviluppo.

Vi ricordo che è necessario installare anche l’ultima versione del firmware sul vostro Netduino:

netduino plus 2 aggiornare al netmf 4.3.1

The post Netduino, NETMF 4.3 R2 Beta e Visual Studio 2013 Comunity Edition appeared first on Esperimenti con logiche programmabili.

Dopo un lungo periodo di sviluppo e di attesa è stata rilasciata la versione 4.3 QFE1 del .Net micro Framework e in contemporanea la versione 4.3.1 del Netduino SDK. Per sfruttare le nuove versioni è necessario aggiornare il firmware della scheda portandolo appunto alla versione 4.3.1.

L’operazione risulta semplice e questo tutorial vuole solo essere un aiuto per le persone che non hanno mai eseguito questa procedura.

Per prima cosa scarichiamo:

• .Net Micro Framework disponibile sul sito Netduino.com
• l’ultima versione del Netduino SDK attualmente la  4.3.1
• Il firmware 4.3.1 per la scheda Netduino PLUS 2

Per chi ha la scheda Netduino 2 deve scaricare il firmware appropriato disponibile sul sito Netduino.com. Invece i possessori della Netduino e Netduino Plus non potranno aggiornare alla versione 4.3.1 ma solo alla 4.2.0.1 seguendo i vecchi tutorial

Di seguito vengono riportate le schermate che portano all’installazione del .Net Micro Framework ed del Netduino SDK tramite le relative procedure guidate:

Il passo successivo è quello di collegare la scheda Netduino plus 2 al pc e caricare i relativi driver.

Caricare il nuovo firmware

Per caricare il nuovo firmware è necessario porre la scheda in modalità bootloader, per far cio è sufficiente scollegare la scheda dalla porta usb, tenere premuto il pulsante BTN della scheda e contemporaneamente ricollegarla alla porta usb.
Windows avvierà la procedura automatica per il caricamento dei driver relativi al micro STM32:

la scheda è in modalità bootloader quando il diodo LED blu sulla scheda rimane acceso.

Ora tutto è pronto per caricare il nuovo firmware. Tramite la nuova utility presente nel file zip del firmware, scaricato precedentemente, sarà possibile aggiornare la scheda:

è sufficiente selezionare la scheda corretta e cliccare sul pulsante upgrade.

una volta terminato il caricamento del nuovo firmware, dobbiamo scollegare e ricollegare la scheda alla porta usb.

Tramite l’utility MFDeploy, verifichiamo la versione del firmware presente sulla scheda dal menu Target->Device Capabilities; verifichiamo che nelle voci SolutionReleaseInfo.solutionVersion, SolutionReleaseInfo.solutionVendorInfo sia presente la versione 4.3.0.1.

L’ultima operazione è quella di utilizzare MFDeploy per inserire il mac address (visibile nell’adesivo posto sotto la scheda) tramite il tool disponibile dal menu Target->Configuration->Network

The post Netduino Plus 2 aggiornare al .NetMF 4.3.1 appeared first on Esperimenti con logiche programmabili.

Nel precedente articolo abbiamo visto come utilizzare l’integrato PCF8574AP per espandere le porte IO di Arduino. Lo stesso circuito può essere adattato anche alla scheda Netduino. Dato che ho utilizzato Arduino Leonardo, i pin SCL e SDA, relativi al bus I2C, sono dedicati, mentre Netduino rispecchia la pin function della Arduino UNO e quindi i pin SDA e SCL sono disponibili rispettivamente sui pin analogico 4 e pin analogico 5.

In definitiva, per far funzionare il circuito, dobbiamo collegare i pin secondo la tabella seguente

Per quanto riguarda il codice sorgente possiamo osservare il listato seguente che permette di accendere e spegnere i led collegati alle porte del PCF8574AP

[csharp]
//buffer per memoriaazare indirizzi
//e dati
Byte[] tx_write = new Byte[1];
Byte[] tx_read = new Byte[1];

//Configurazione contenente l’indirizzo del PCF8574AP
//e la frequenza del bus i2c
I2CDevice.Configuration cnf = new I2CDevice.Configuration(0x38, 100);

//Creo un oggetto per eseguire le richieste di lettura e scrittura
I2CDevice expanderPCF8574 = new I2CDevice(cnf);

//creo un oggetto I2CReadTransaction che viene associato al buffer tx_read
//il buffer viene utilizzato per verificare lo stato delle porte del PCF8574AP
I2CDevice.I2CReadTransaction[] rt_data = new
I2CDevice.I2CReadTransaction[] { I2CDevice.CreateReadTransaction(tx_read) };

//creo un oggetto I2CWriteTransaction che viene associato al buffere tx_write
//il buffer tx viene utilizzato per spedire lo stato delle porte del PCF8574AP
I2CDevice.I2CWriteTransaction[] wt_write = new
I2CDevice.I2CWriteTransaction[] { I2CDevice.CreateWriteTransaction(tx_write) };

while (true)
{
//imposto tutte le porte a livello logico basso
tx_write[0] = (Byte)(0x00);
//eseguo il comando
expanderPCF8574.Execute(wt_write, 10);

Thread.Sleep(1000);

//imposto tutte le porte a livello logico alto
tx_write[0] = (Byte)(0xFF);
//eseguo il comando
expanderPCF8574.Execute(wt_write, 10);

Thread.Sleep(1000);
}
[/csharp]

Leggere lo stato delle porte

la lettura dello stato delle porte del PCF8574AP avviene eseguendo il comando relativo all’oggetto i2creadtransaction:

[csharp]
while (true)
{
//eseguo il comando
expanderPCF8574.Execute(rt_data, 10);

Debug.Print(tx_read[0].ToString());

Thread.Sleep(1000);
}
[/csharp]

Anche utilizzando Netduino i comandi da eseguire per utilizzare il PCF8574AP sono molto semplici ed intuitivi.

The post Netduino, utilizzare il PCF8574AP appeared first on Esperimenti con logiche programmabili.

dopo aver scritto l’articolo sull’utilizzo della memoria 24LC256 utilizzando una scheda Arduino ho realizzato questo piccolo tutorial per tutti gli utenti che possiedono una scheda Netduino.
La parte teorica e lo schema elettrico del circuito rimangono invariati, l’unica ovvia differenza è la scrittura del codice che in questo caso si basa sul linguaggio C#.

Questo è il codice:

[csharp]
//buffer per memorizzare indirizzi
//e dati
Byte[] tx_write = new Byte[3];
Byte[] tx_read = new Byte[2];
Byte[] rx_data = new Byte[1];

Int16 indirizzo = 0;
Byte data = 0;
Int32 ciclo = 0;

//creo un oggetto per usare il led onboard
OutputPort led = new OutputPort(Pins.ONBOARD_LED, false);

//accendo il led onboard
led.Write(true);

//Configurazione contenente l’indirizzo della memoria 24LC256
//e la frequenza del bus i2c
I2CDevice.Configuration cnf = new I2CDevice.Configuration(0x50, 100);

//Creo un oggetto per eseguire le richieste di lettura e scrittura
I2CDevice mem24LC256 = new I2CDevice(cnf);

//creo un oggetto I2CReadTransaction che viene associato al buffer rx_data
//il buffer tx viene utilizzato per contenere i dati letti dalla memoria 24LC256
I2CDevice.I2CReadTransaction[] rt_data = new
I2CDevice.I2CReadTransaction[] { I2CDevice.CreateReadTransaction(rx_data) };

//creo un oggetto I2CWriteTransaction che viene associato al buffere tx_write
//il buffer tx viene utilizzato per spedire i due byte dell’indirizzo della
//locazione di memoria che vogliamo utilizzare e il byte contenente il dato
//da memorizzare nella memoria
I2CDevice.I2CWriteTransaction[] wt_write = new
I2CDevice.I2CWriteTransaction[] { I2CDevice.CreateWriteTransaction(tx_write) };

//creo un oggetto I2CWriteTransaction che viene associato al buffere tx_read
//il buffer tx_read viene utilizzato per selezionare la locazione di memoria
//da cui vogliamo leggere il contenuto
I2CDevice.I2CWriteTransaction[] wt_read = new
I2CDevice.I2CWriteTransaction[] { I2CDevice.CreateWriteTransaction(tx_read) };

//info di debug
Debug.Print("START Scrittura");

//eseguo un ciclo per memorizzare dati in tutti e 32KB
for(ciclo = 0; ciclo < 32000; ciclo++)
{
//compongo il buffer con l’indirizzo di memoria
//che voglio utilizzare ed il dato che voglio
//scrivere al suo interno
tx_write[0] = (Byte)((indirizzo >> 8) & 0xff);
tx_write[1] = (Byte)(indirizzo & 0xff);
tx_write[2] = data;

//eseguo il comando
mem24LC256.Execute(wt_write, 10);

//incremento il valore di data e lo resetto
//quando raggiunge il valore 255
data++;

if (data == 255)
data = 0;

//incremento il valore della
//locazione di memoria da usare
indirizzo++;

}

Debug.Print("Fine Scrittura");

//attendo 1 secondo
Thread.Sleep(1000);

Debug.Print("Inizio lettura");

//resetto il valore dell’indirizzo
indirizzo = 0;

for (ciclo = 0; ciclo < 32000; ciclo++)
{
//utilizzo il buffer tx_read per caricare
//l’indirizzo della locazione di memoria da dove
//leggere i dati
tx_read[0] = (Byte)((indirizzo >> 8) & 0xff);
tx_read[1] = (Byte)(indirizzo & 0xff);

//eseguo il comando
mem24LC256.Execute(wt_read, 10);

//attendo 5 ms
Thread.Sleep(5);

//ora eseguo il comando per leggere i dati dalla
//locazione di memoria precedentemente selezionata
//il dato letto viene memorizzato nelbuffer rx_data
mem24LC256.Execute(rt_data, 10);

//printo l’indirizzo della locazione di memoria corrente
//ed il suo contenuto
Debug.Print(indirizzo.ToString() + ":" + rx_data[0].ToString());

//incremento il valore della
//locazione di memoria da usare
indirizzo++;
}

Debug.Print("Fine lettura");

//spengo il led onboard a fine lettura
led.Write(false);

[/csharp]

Il codice è ricco di commenti che spiegano cosa eseguono le istruzioni!

The post Netduino impiegare la memoria 24LC256 appeared first on Esperimenti con logiche programmabili.

Eccoci nuovamente al mio classico speed test per misurare la frequenza massima ottenibile dalla commutazione continua di un singolo pin.

La scheda in esame è il nuovo Netduino Plus 2 basato sulla cpu STmicro STM32F4 operante a 168Mhz. Sicuramente l’incremento di frequenza ha permesso maggiori prestazioni ma il risultato è ben lontano dai 125KHz ottenuti dall’Arduino UNO, infatti la frequenza misurata è di 44.27 KHz, che paragonata alla prima versione della scheda (quella basata sulla cpu AT91SAM7 operante a 48MHz), è comunque un ottimo risultato che fa ben sperare in evoluzioni future e miglioramenti prestazionali nell’archittetura .Net micro framework.

Di seguito la tabella aggiornata degli speed test delle board che ho provato

Questo invece lo screen shot della schermata dell’oscilloscopio

The post Netduino Plus 2 Speed Test appeared first on Esperimenti con logiche programmabili.

Circa 5 mesi fà ho realizzato un lettore badge basato sulla FEZ Cobra prodotta da GHI Electronics. Il prodotto è costituito da un display lcd, una tastiera numerica e un lettore rfid, ed è parte di un controllo accessi funzionante 24 ore su 24 7 giorni su 7.
Prima della sua messa in opera, ho seguito alcuni test “indoor” per verificarne la stabilità, e non ho avuto nessun tipo di problema sennonché il microprocessore della Cobra riscalda parecchio, nonostante il programma non esegua compiti gravosi.
Questo fatto mi ha preoccupato in quanto il lettore è posizionato in un passaggio carrabile ed è esposto ai raggi solari per quasi tutto il giorno, e visto che la scheda è racchiusa in un involucro a tenuta stagna e non avendo la possibilità di inserire un sistema di raffreddamento che mi permettesse di abbassare la temperatura interna, temevo ad un malfunzionamento del dispositivo.

Anche l’estate non è stata clemente, qui in Sardegna abbiamo raggiunto temperature di 38-40° all’ombra, di conseguenza la Cobra è stata sottoposta a temperature di lavoro quasi estreme e sinceramente mi aspettavo da un giorno all’altro la sua rottura.

Invece con mia grande sorpresa la FEZ Cobra sta ancora funzionando perfettamente dopo circa 3500 ore di lavoro continuo senza aver mai dato problemi di nessun tipo.

Certamente un solo pezzo non è sufficiente per fare una valutazione completa di questo prodotto ma viste le estreme condizioni a cui ho sottoposto la Cobra devo dire che ne sono rimasto davvero soddisfatto. Questo mi rende anche più fiducioso nel realizzare dei prodotti basati sul .Net micro framework vista la stabilità software che ho ottenuto in questo progetto.

The post FEZ Cobra esperienze e considerazioni appeared first on Esperimenti con logiche programmabili.

Dopo aver caricato il nuovo bootloader sul nostro Netduino non ci resta che caricare il firmware 4.2 per rendere la scheda operativa. Questa operazione deve essere eseguita utilizzando il tools MFdeploy contenuto nella cartella di installazione del .Net Micro framework 4.2 (che dovete installare precedentemente).
L’utility si trova, se avete fatto l’installazione standard, nella cartella C:\Program Files\Microsoft .NET Micro Framework\v4.2\Tools

Una volta avviato MFdeploy, tramite il blocco Device, dobbiamo selezionare il Netduino (precedentemente collegato alla porta USB del PC), utilizzando come canale di collegamento la voce USB. Automaticamente otterremmo nella casella di testo adiacente la voce Netduino_Netduino. Verifichiamo, utilizzando il pulsante Ping, che la comunicazione tra PC e Netduino sia attiva e funzionante.

Nel blocco Image File clicchiamo sul pulsante Browse… per selezionare sul nostro disco locale, il due file che compongono il firmware (ER_CONFIG, ER_FLASH) da scrivere sul Netduino.
Cliccando sul pulsante Deploy avvieremmo la scrittura, l’operazione richiede qualche minuto.

Al termine scolleghiamo il Netduino dalla porta USB e ricolleghiamolo dopo qualche istante.

Verifichiamo le informazioni del nuovo firmware tramite il menu Target->Device Capabilities, sempre tramite MFdeploy, per accertarci chel’operazione sia stata eseguita correttamente.

Le immagini seguenti mostrano tutte le fasi descritte precedentemente

The post Caricare nuovo firmware 4.2 sul Netduino appeared first on Esperimenti con logiche programmabili.

Con il rilascio della nuova versione del .Net micro framework 4.2 (QFE2) la Secret Labs ha rilasciato un nuovo bootloader e un nuovo firmware per le board Netduino, Netduino Plus e Netduino Mini. Viste le molte novità e migliorie della versione 4.2 consiglio vivamente l’upgrade delle board.

Le procedure principali sono le seguenti

1. Ricaricare il nuovo bootloader
2. Ricaricare il nuovo firmware

Prima di iniziare dobbiamo scaricare i seguenti software

• Firmware 4.2 del Netduino (Contenente anche il nuovo bootloader)
• Driver Netduino (Necessario per installare la scheda dop aver caricato il bootloader)
• .Net Micro Framework 4.2
• Atmel SAM-BA versione 2.12 o superiore (Contiene il software ed il driver del chip AT91SAM7X512-ex)

Installiamo il software SAM-BA che useremmo per caricare il bootloader. Di seguito alcuni screen shot dell’installazione

Scarichiamo il pacchetto zip contenente il firmware ed il bootloader. Teniamo da parte il file TinyBooterDecompressor.bin che caricheremo sul microcontrollore.

Eseguiamo la cancellazione del firmware e del bootloader del Netduino utilizzando un filo elettrico che, dal pin 3.3V andrà collegato al piccolo quadrato dorato vicino al pin0.
Alimentiamo per qualche istante il Netduino (tramite USB o alimentazione esterna) tenendo sempre collegato filo sul pad dorato. Togliamo alimentazione. Il nostro dispositivo è ora privo di firmware e di bootloader.

Ricollegando Il Netduino verrà avviata la ricerca Nuovo Hardware, annulliamo questa operazione per caricare manualmente i driver del microcontrolloare AT91SAM7X512-ek.

Le seguenti figure mostrano il processo di installazione della scheda

Una volta che il dispositivo è stato riconosciuto da Windows 7  possiamo caricare il nuovo bootloader.

Clicchiamo sull’icona SAM-BA v2.12. Nella prima schermata dobbiamo selezionare, alla voce Select the connection la porta COM dove è collegato il dispositivo, alla voce Select your board selezioniamo il chip AT91SAM7X512-ek. Clicchiamo sul pulsante connect.
Caricata la finestra principale del programma SAM-BA, bisogna, per prima, eseguire due script. Selezioniamo nel blocco Script la voce Boot from flash (GPNVM2), clicchiamo sul pulsante Execute, successivamente selezioniamo lo script Enable Flash Access, clicchiamo sempre su Execute.

Ora nel blocco Download/Upload file, selezioniamo dalla casella Send file Name il file TinyBooterDecompressor.bin precedentemente messo da parte sul nostro PC, clicchiamo sul pulsante Send File. Dopo qualche istante apparirà una finestra popup per richiedere il Lock Region, clicchiamo sul pulsante NO.

Se non si verificano errori il bootloader è stato scritto correttamente sul microcontrollore.

Le immagini seguenti mostrano il processo:

A questo punto scolleghiamo la scheda dalla porta usb per poi ricollegarla dopo qualche istante. Nuovamente verrà avviata l’installazione nuovo hardware relativa alla scheda Netduino. Seguiamo i passi rappresentati nelle seguenti figure per installare i driver della scheda Netduino:

Nel prossimo articolo vedremmo come caricare il nuovo firmware.

The post Aggiornare le schede Netduino alla versione 4.2 del .Net MF 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.

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.