Arduino datalogger con pc 

Come realizzare un datalogger utilizzando Arduino e un pc

Il datalogger è uno di circuiti che fanno parte del bagaglio tecnico di chi come noi smanetta con l’elettronica e l’informatica. Il suo funzionamento è in effetti semplice ma allo stesso tempo utile per realizzare tutte quelle applicazioni in cui è necessario acquisire e registrare dati (digitali o analogici), pensiamo a tutti i sistemi di monitoring (energia, gas, acqua …) alle stazioni meteo o a sistemi di controllo. Esistono circuiti dedicati che eseguono funzioni di datalogging locale e remote, persino cloud, dai costi variabili da poche decine di euro a centinaia di euro a seconda della robustezza e della precisione dei circuiti.
Per impadronirci anche di questo aspetto possiamo realizzare il nostro datalogger usando il nostro caro Arduino. Il logging può avvenire sia sui pin analogici che su quelli digitali a seconda dei segnali e dei sensori collegati alla scheda.

In questo tutorial utilizzerò i sei pin analogici della scheda per acquisire dei segnali analogici ed inviarli al pc, tramite la porta seriale, dove avverrà la memorizzazione dei dati. Ho deciso di non memorizzare i dati sulla scheda per far capire come inviare i dati e come sincronizzazione la comunicazione tra i due dispositivi.Come scheda ho impiegato la Arduino Ethernet e lato pc ho utilizzato Microsoft Visual C# 2012 (su Windows 8) per scrivere il programma di logging.

Per mancanza di tempo non ho collegato alla scheda dei sensori o delle fonti analogiche ma ho lasciato i pin analogici ‘appesi’, questo perchè i dispositivi da collegare sono infiniti e quindi lascio a voi il compito di collegarne a piacimento.

Passiamo quindi direttamente al codice caricato sulla Arduino Ethernet:

[c]
//questo arrai contiene i valori provenienti
//dall’acquisizione analogica
byte ana[12];
//avalore intero per memorizzare il dato analogico
int valAn = 0;
//variabile per selezionare il canale analogico
byte in_ana = 0;

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

void loop()
{
//verifico la presenza di un dato sulla
//porta seriale
if(Serial.available() > 0)
{
//se arriva un byte dal pc leggilo
byte data = Serial.read();
//controllo se il dato in arrivo dal pc corrisponde
//al carattere di avvio acquisizione
if(data == ‘#’)
{
//inizializzo la variabile per la selezione del
//primo canale analogico
in_ana = 0;
//eseguo un ciclo for per acquisire ciclicamente tutti i
//canali analogici da A0 a A5
for(int Ciclo = 0; Ciclo <12; Ciclo += 2)
{
//leggo il canale analogico
valAn = analogRead(in_ana);
//il valore intero viene diviso in due byte e caricato
//nell’array dichiarato precedentemente
ana[Ciclo] = highByte(valAn);
ana[Ciclo + 1] = lowByte(valAn);
//piccolo delay tra una acquisizione e l’altra
delay(1);
//incremento il canale di acquisizione
in_ana++;
}
//dopo 6 cicli spedisco tutti e 12 i byte al pc
Serial.write(ana,12);
}
}
}
[/c]

Le parti più importanti di questo codice sono il secondo blocco if che ha il compito di verificare quando il byte ricevuto è uguale al carattere #, in questo modo l’invio dei dati è subordinato alle richieste del pc. Questo permette di avere una trasmissione concordata che evita l’utilizzo di sincronismi per poter leggere coerentemente i dati acquisiti.
L’altro blocco è quello for, che ha il compito di acquisire il dato analogico e di caricarlo sull’array che verrà inviato al pc. Per farlo vengono utilizzate le istruzioni highByte() e lowByte() che hanno il compito di suddividere la variabile int valAn(composta da due byte) in due byte contenenti gli 8 bit più significativi e gli 8 bit meno significativi, questo infatti giustifica l’array da 12 byte.

La figura seguente mostra quanto detto:

volendo si potrebbe spedire direttamente il valore intero ma credo che questo approccio semplifica meglio la stesura e la comprensione dei programmi lato Arduino e lato pc.

Il datalogger sul pc

La finestra del programma che acquisisce e registra i dati è mostrata di seguito:

La parte principale del software di acquisizione dei dati da Arduino è la seguente:

[csharp]

//avvia l’acquisizione dei dati
//inviando ad arduino il carattere #
rs232.Write("#");

//entro nel ciclo
while (Continua)
{
//attendo che arduino invii i 12 byte
//contenenti i dati dalla conversione
//analogico digitale
if (rs232.BytesToRead == 12)
{
//leggo tutti i 12 byte e le assegno
//ad un array di byte
rs232.Read(dataRX, 0, 12);

//prendo il primo ed il secondo byte e li unico per
//formare yn valore intero a 16 bit
myShort = (short)(dataRX[0] << 8 | dataRX[1]);
txtValAn01.Text = myShort.ToString();

myShort = (short)(dataRX[2] << 8 | dataRX[3]);
txtValAn02.Text = myShort.ToString();

myShort = (short)(dataRX[4] << 8 | dataRX[5]);
txtValAn03.Text = myShort.ToString();

myShort = (short)(dataRX[6] << 8 | dataRX[7]);
txtValAn04.Text = myShort.ToString();

myShort = (short)(dataRX[8] << 8 | dataRX[9]);
txtValAn05.Text = myShort.ToString();

myShort = (short)(dataRX[10] << 8 | dataRX[11]);
txtValAn06.Text = myShort.ToString();

//dopo aver acquisito i dati esco dal ciclo
break;
}
}
[/csharp]

Il programma acquisisce i dati provenienti dalla scheda e li visualizza nelle apposite caselle di testo, in contemporanea viene creato un file di testo, nella stessa cartella dove viene posto il fil eseguibile, dove verranno memorizzati i dati.

Per eseguire l’applicazione è necessario installare nel proprio pc il Microsoft .Net Framework 4.5

In allegato trovate sia il file eseguibile sia il codice dell’applicazione.

Download File eseguibile: ArduinoDataLogger (~7KB)

Download File sorgente: ArduinoDataLogger_Source (~82KB)