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)

The post Arduino datalogger con pc appeared first on Esperimenti con logiche programmabili.

Una caratteristica che reputo molto interessante è la possibilità di espandere Arduino tramite l’uso di shield. La maggior parte di queste schede aggiuntive sono però progettate per compiere una funzione specifica, non programmabile.
Esistono alcuni metodi che permettono di comunicare con altri dispositivi utilizzando come canale di trasmissione dati i protocolli seriali (I2C, SPI o RS232). Questo rende possibile demandare ad una scheda slave funzioni di elaborazione gravose, che non vogliamo far eseguire alla scheda master. Ho realizzato questo piccolo tutorial usando il bus I2C per creare uno scambio dati tra un Arduino ed un chip ATmega328 standalone.

Il bus I2C, basandosi su due fili, non permette la comunicazione contemporanea tra Master e Slave. Lo scambio dati deve essere gestito dal Master tramite gli indirizzi (univoci) degli slave. Il flusso può essere sintetizzato in questo modo

1. Il Master invia sul bus un bit di start
2. Il Master invia sul bus l’indirizzo dello slave con cui vuole comunicare
3. Il Master decide se scrivere o leggere dal dispositivo
4. Lo Slave legge o scrive in base alla richiesta del Master

La libreria Wire dispone di tutte le funzioni necessarie alla realizzazione Master-Slave tra due schede Arduino. Lo schema del circuito che ho realizzato è visibile nella figura seguente.

Come detto precedentemente lo schema si basa su Arduino Uno impiegato come Master e con un ATmega328 impiegato come slave.

Il codice permette di inviare un dato numerico allo slave, che provvederà ad incrementarlo per poi rispedirlo al Master.

[c]
//MASTER
#include <Wire.h>

byte x = 0;
byte num = 0;

void setup()
{
//inizializzo la libreria Wire come Master
Wire.begin();

//init seiale
Serial.begin(9600);
//avviso che il programma è avviato
Serial.println("START");

}

void loop()
{
//invio sul bus I2C un byte al device
//che ha come indirizzo il valore 0x04
//start trasmissione
Wire.beginTransmission(0x04);
//invio un byte
Wire.write(x);
//fine trasmissione
Wire.endTransmission();

delayMicroseconds(500);

//richiedo un byte allo slave che ha indirizzo 0x04
Wire.requestFrom(0x04, 1);

//attendo la disponibilità di dati sul bus i2c
while(Wire.available())
{
//quando è presente un dato avvia
//la lettura
num = Wire.read();
}

//incrementa il valore del byte
x++;

//verifico che il byte letto dallo slave sia stato
//incrementato
if(num != x)
Serial.println("ERRORE");

delay(5);

}

[/c]

Il codice seguente è relativo allo Slave

[c]
//SLAVE
#include <Wire.h>

byte x = 0;

void setup()
{
//inizializzo la libreria
//imposto l’indirizzo dello slave
Wire.begin(0x04);

//eventi per la ricezione del dato
//e per la richiesta del dato
Wire.onReceive(receiveEvent);
Wire.onRequest(requestEvent);
}

void loop()
{
//esegui qualcosa
delay(1000);
}

void receiveEvent(int data)
{
//questo evento viene generato quando sul bus
//è presente un dato da leggere

//eseguo la lettura
x = Wire.read();

//elaboro il dato letto
x++;
}

void requestEvent()
{
//questo evento viene generato quando il master
//richiede ad uno specifico slave
//una richiesta di dati

//spedisco il dato al Master
Wire.write(x);

}

[/c]

I commenti presenti nel codice permettono di capire ciò che avviene tra i due dispositivi.

Di seguito uno screenshot dei dati scambiati sul bus

Di seguito invece la trasmissione del Master

The post Comunicazione tra Arduino tramite I2C appeared first on Esperimenti con logiche programmabili.

La comunicazione seriale RS422 è uno standard che prevede l’utilizzo di due fili per trasmettere i dati. Questo standard permette di realizzare una comunicazione con dispositivi che si trovano a distanze considerevoli (1000-1500 mt) grazie all’alta immunità ai disturbi e alla sensibilità dei circuiti di ricezione. Le velocità di trasmissione possono raggiungere su brevi distanza (circa 1mt) i 10Mb/s mentre si scende a circa 100Kb/s per distanze intorno ai 1000 mt. La RS422 è tipicamente impiegata in ambito industriale.

Nella figura seguente viene illustrato lo schema a blocchi composto da due driver che codificano e decodificano il segnale in ingresso.
Questo segnale viene messo in uscita, dal primo driver, con opposizione di fase,  e tramite una coppia di fili viene inviato al driver ricevente che ha il compito di ricostruirlo come in ingresso.
Nel grafico dei segnali possiamo osservare che :

• Quando il segnale in A è ALTO rispetto al segnale presente in B, otteniamo in uscita un livello ALTO (Uno digitale)
• Quando il segnale in A è BASSO rispetto al segnale presente in B, otteniamo in uscita un livello BASSO (Zero digitale)

Arduino dispone di una porta seriale (pin0 e pin1) capace di pilotare un driver TTL/RS422 utile per provare a lavorare con questo tipo di comunicazione. Questi convertitori sono di facile reperibilità, con costi contenuti e di semplice impiego. Quelli che ho usato sono l’integrato sn75174 (QUADRUPLE DIFFERENTIAL LINE DRIVER) e l’integrato sn75175 (QUADRUPLE DIFFERENTIAL LINE RECEIVERS).

Di seguito trovate  lo schema del circuito che converte il segnale TTL in RS422 e viceversa:

L’integrato 75174 convertirà il segnale TTL in RS422, mentre l’integrato 75175 convertirà il segnale rs422, proveniente dalla linea, in segnale TTL. Di fatto per noi, con Arduino, diventa trasparente trasmettere in RS232 piuttosto che RS422 poiché via codice utilizzeremo sempre la classe Serial e le relative istruzioni per la trasmissione e per la ricezione.

Per testare il circuito possiamo immaginare di posizionare Arduino ad una certa distanza dal PC, poi tramite un convertitore TTL-422-TTL abbinato ad un convertitore TTL-232 possiamo instaurare una comunicazione seriale utilizzando le istruzioni che mette a disposizione il linguaggio di sviluppo. Lo schema a blocchi è il seguente

mentre questo è lo schema elettrico

Il codice di esempio invia un carattere al PC.

void setup()
{
  Serial.begin(9600);
}

void loop()
{

  Serial.print("A");

  delay(500);

}

Viste le potenzialità della rs422 questo sistema può essere una scelta valida per i progetti dove la distanza tra Arduino e pc inizia a diventare considerevole.

The post RS422 comunicazione seriale utilizzando Arduino appeared first on Esperimenti con logiche programmabili.