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.

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.

La comunicazione seriale RS232 è un modo semplice per permettere alla nostra board Arduino di comunicare con il computer piuttosto che con sensori o altri dispositivi.
Principalmente Arduino UNO possiede una sola porta seriale, implementata in hardware sul chip Atmega328, e disponibile sui pin0 (Rx) e pin1 (Tx) della scheda.
Sebbene, il più delle volte, una porta seriale sia sufficiente, può essere necessario instaurare un’ulteriore comunicazione seriale, ad esempio, per motivi di debugging o monitoring con un altro dispositivo o computer.
In questo caso ci viene in aiuto la libreria SoftwareSerial (Software Serial Library) che permette di impiegare ulteriori pin disponibili sulla scheda per definire una porta seriale aggiuntiva.

Per utilizzarla è fondamentale inserire nello sketch il riferimento alla libreria tramite la parola chiave #include:

#include <SoftwareSerial.h>

successivamente si definisce una variabile utilizzando il costruttore SoftwareSerial:

SoftwareSerial PortaSeriale = SoftwareSerial(pin_RX, pin_TX);

dove PortaSeriale è il nome dell’oggetto, pin_RX definisce il pin per ricevere i dati e pin_TX definisce il pin per la trasmissione dati.

Ora nella funzione Setup(), tramite pinMode, definiamo il pin previsto per la ricezione come input, e il pin previsto per la trasmissione come output. Specifichiamo inoltre la velocità di trasmissione a 9600bps.

void setup()
{
pinMode(pin_RX, INPUT);
pinMode(pin_TX, OUTPUT);

PortaSeriale.begin(9600);
}

Per leggere e scrivere sulla seriale vengono utilizzati gli stessi metodi implementati per Serial().

Di seguito l’esempio completo che permette di testare questa funzionalità impiegando i pin7 per la ricezione ed il pin8 per la trasmissione

#include <SoftwareSerial.h>

//creo una nuova porta seriale via software
SoftwareSerial PortaSeriale =  SoftwareSerial(7, 8);

//variabile
char EchoChar = 0;

void setup()  {
//definisco il pin7(RX) come ingresso
pinMode(7, INPUT);
//definisco il pin8(TX) come uscita
pinMode(8, OUTPUT);
//setto la velocita della seriale software
PortaSeriale.begin(9600);
}

void loop() {
//leggo dalla seriale(pin7)
EchoChar = PortaSeriale.read();
//invio il dato letto
PortaSeriale.print(EchoChar);

delay(10);

}

il circuito di per il test è rappresentato nell’illustrazione seguente:

Avendo altri pin disponibili nulla ci vieta di definire un’ulteriore porta seriale o più.

Nonostante l’utilità di questa libreria, ci sono alcune limitazioni che bisogna conoscere, per evitare errori di programmazione e di progettazione:

• E’ possibile utilizzare per la porta solamente la velocità di 9600bps
• Non è possibile sapere se ci sono dati disponibili per la lettura come avviene per la funzione Serial.available()
• Il metodo read() è bloccante, quindi il codice si ferma fintanto che non arriva un byte da poter leggere
• Non essendo presente un buffer di ricezione il metodo read() deve essere richiamato velocemente per evitare la perdita di dati.

Queste limitazioni potrebbero far ripensare l’utilizzo della libreria, ma credo che sia comunque importante conoscerne il funzionamento per valutare, a seconda dei circuiti, se impiegarla o meno.
Personalmente l’ho trovata molto utile per inviare dati ad altri dispositivi come funzione di monitoring, difatti potete utilizzare solamente la funzione print e tralasciare la read().

The post Arduino aggiungere porta seriale con Software Serial Library appeared first on Esperimenti con logiche programmabili.