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.

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.

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.

Era il 1999 quando acquistai il libro Programmare Microsoft Visual Basic 6.0, di Francesco Balena, quello fu il mio ingresso nel mondo della programmazione. Ancora non sapevo cosa potessi fare, che programmi potessi sviluppare, quali problemi sarei riuscito a risolvere. Ero entusiasta di quel libro, tutto veniva spiegato accuratamente e con grande precisione e professionalità. Sognavo di realizzare software di ogni tipo, di aiutare amici e parenti con i miei programmi.

La cosa che più mi intrigava fu la possibilità che il software potesse interagire con il mondo esterno. Sfruttando la porta seriale oppure quella parallela, avevo l’intenzione di costruire piccoli dispositivi per acquisire segnali da sensori e pilotare attuatori. La cosa che però mi impedì di realizzare questi circuiti, fu l’ingombro fisico del pc. Non potevo creare un sistema di irrigazione automatizzato poiché era improbabile mettere un pc nei pressi di un giardino e farlo funzionare costantemente evitando malfunzionamenti. Senza pensare ai costi realizzazione di un sistema di questo tipo!

Passarono gli anni e la parte ‘hardware’ dei miei progetti fu sopraffatta da quella software… Nel mentre nacque il .Net Framework e incominciai a migrare, dopo tanto codice vb6, verso il  nuovo linguaggio C#.

Ogni tanto sentivo parlare su vari forum e blog del .Net micro framework e di alcuni (pochi) dispositivi che potevano essere programmati utilizzando Visual C#, ma ormai ero lanciato verso lo sviluppo desktop e web e la voglia di riprendere in mano il saldatore era quasi svanita.

Successivamente il mondo dello sviluppo software ha iniziato ad entrare nelle case, nelle auto, nei dispositivi portatili, nel controllo accessi ed in generale ha ridato linfa al mondo embedded che era una nicchia riservato all’industria e alle medio-grandi imprese.Alche io ho iniziato a domandarmi se i programmatori desktop e web potessero lavorare non solo con i pc ed i server ma anche con questi piccoli dispositivi che ormai potevano essere paragonati a dei pc in miniatura.
La risposta giunse quando scoprii l’esistenza di Arduino e di Netduino poi. L’idea di poter scrivere codice per queste piattaforme era sorprendentemente fantastica! Potevo riprendere a sperimentare con i dispositivi hardware è creare nuove applicazioni.

Ma la domanda principale che mi sono posto è, cosa posso fare con Arduino Netduino?

Sicuramente trovo che questi dispositivi siano davvero versatili e duttili, ma certamente penso che non possano essere impiegati ovunque. In base alla mia esperienza professionale credo che gli ambiti migliori dove utilizzare Arduino e Netduino sono:

• Domotica
• Agricoltura
• Controllo accessi
• Robotica amatoriale
• Dispositivi di allarme
• Stazioni meteo
• Sistemi di controllo, anche remoti (esclusi quelli real time)
• Dispositivi wireless
• Dispositivi con accesso LAN
• Utilizzo per scopi didattici e sperimentali

certamente esistono altri impieghi, ma questa lista nasce secondo le mie esperienze, secondo quello che io potrei realmente realizzare con questi dispositivi. Non mi sembra giusto scrivere una serie di applicazioni, solo per avere un elenco più lungo e importante, che poi non saprei giustificare!

Analizzo meglio queste voci per dare un’idea più precisa sui vari punti

Domotica:

Circuiti elettronici che riguardano l’ambito domestico come controllo del sistema di illuminazione, gestione dell’impianto di riscaldamento, rivelazione fumi e gas, azionamento sistemi di irrigazione del giardino.

Agricoltura:

Sistemi automatici di irrigazione, riscaldamento e refrigerazione serre.

Controllo Accessi:

Gestione lettori RFID per apertura ingressi, sistemi i accesso basati su tastiere o lettori di schede magnetiche. Possibilità di interfacciamento del sistema alla rete Lan.

Robotica Amatoriale:

Creazione automi basati sulla gestione di diversi sensori e attuatori. Creazione di piccoli robot autonomi che svolgono compiti predefiniti.

Dispositivi di Allarme:

Gestione di sensori di movimento e interruttori, attivazione sirene e segnalazione intrusione via rete gsm o internet.

Stazione Meteo:

Controllo di sensori di temperatura, pressione, umidità, anemometri e pluviometri e possibilità di registrare tutti i dati su memoria solida o invio tramite lan.

Sistemi di Controllo:

Controllo e gestione di sistemi numerici, acquisizione segnali, elaborazione e attuazione. Escluderei però sistemi real-time, e impieghi in ambito industriale.

Dispositivi Wireless:

Comunicazioni e controllo di dispositivi senza file utilizzando trasmettitori RF.

Dispositivi con Accesso Lan:

Creazione di sistemi con controllo remoto del dispositivo, piccoli server web, comunicazione con protocolli UDP e TCP/IP

Utilizzo per scopi didattici:

Realizzazione di semplici esperimenti per iniziare a imparare il funzionamento dei sistemi di controllo, dell’acquisizione segnali e loro elaborazione. Come sistema sperimentale per iniziare ad esplorare il mondo dell’elettronica.

La mia considerazione non vuole dare una  risposta definitiva alla domanda, ma penso che aiuti molti principianti, che ancora stanno valutando se acquistare questi dispositivi piuttosto che altri.
Il mio consiglio è, visto il basso costo delle schede e la disponibilità di ambienti di sviluppo gratuiti, di investire un po di denaro per poter provare a sperimentare e creare piccoli circuiti. La pratica fa subito capire la potenzialità di queste schede e ci fa entrare in un mondo sicuramente interessante che puo dare tante soddisfazioni.
Buona sperimentazione a tutti!

The post Cosa posso fare con Arduino Netduino? appeared first on Esperimenti con logiche programmabili.