Importare File Dati in Excel (upgrade)

In un post precedente ho già mostrato la soluzione usata in passato per risolvere il fastidioso problema del formato decimale usato per salvare i dati acquisiti da parte di un DAQ.

La soluzione proposta era un breve listato in C da compilare, in questi giorni mi sto appassionando al C++ e nella speranza di non lasciare perdere lo studio causa cronica mancanza di tempo e/o concentrazione ho voluto rielaborare il codice C in C++ usando per quanto mi è possibile una programmazione ad oggetti, che trovo veramente affascinante.

Ecco il codice:

#include <iostream>
#include <fstream>
#include <cstdlib>

using namespace std;

int main(int argc, char *argv[]){
        ifstream in(argv[1]);
        ofstream out(argv[2]);

        char carattere;

        int dot_count = 0;

        if (argc != 3){
                cout << "Uso: " << argv[0] << " <file_in> <file_out>" << endl;
                exit(0);
        }

        while(!in.eof()){
                in.get(carattere);
                if (carattere == EOF) break;
                if (carattere == '.'){
                        dot_count++;
                        if ( dot_count > DOT_LOW_LIMIT){
                                out <<  ',';
                                cout << ',';
                        }
                        else{
                                out  << carattere;
                                cout << carattere;
                        }
                        if (dot_count == DOT_UP_LIMIT) dot_count = 0;
                }
                else{
                        out  << carattere;
                        cout << carattere;
                }
        }

        in.close();
        out.close();

        return 0;
}

Elettronica in supposte

Titolo osè per un articoletto ad aggiornamento continuo su link interessanti sull'elettronica e i componenti:

DIODI:

- http://hobbyelettronica.altervista.org/elettr_analog/diodi.pdf

CONTINUA...

Misto fritto di Link FBUS, Nokia 3310 e Arduino

Causa prematura morte del Siemes M35i su cui stavo basando tutto il mio progetto del sistema di avvisi tramite SMS mi trovo costretto a ravanare in vecchi cassetti per un nuovo cellulare.

La notizia buona è che ho trovato un fiammante Nokia 3310, la cattiva e' che non posso usare la comunicazione su porta seriale tramite comandi AT ma mi mi devo affidare al sistema FBUS di Nokia.

Per ora mi limito a inserire una lista di link per dipanare l'argomento, spero più avanti di riuscire a produrre qualcosa.

Buona lettura.

PIN OUT Nokia 3310: http://pinouts.ru/CellularPhones-Nokia/nokia_3310_pinout.shtml

Protocollo F-BUS: http://www.embedtronics.com/nokia/fbus.html

Schema cavo collegamento a FBUS: http://www.nokia-tuning.net/index.php?s=cablefbus

Progetti vari:

http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=59687

http://www.avrfreaks.net/index.php?name=PNphpBB2&file=printview&t=59687&start=20

http://www.ucdevelopers.page.tl/Tutorial-Nokia-3310-with-AT89S52.htm

http://pastebin.com/a52XLuhD

Alcuni schemi ed indicazioni utili per nokia 3310 ed il mio caro siemens M35 (proverò il circuito che emula la batteria :) )

http://www.saunalahti.fi/~tovaska/gsm/index.html

Come installare Intel(R) Fortran Compiler XE 12.1 su Ubuntu 12.04 LTS

Intel offre da anni una versione gratis del suo compilatore fortran per scopi non commerciali e non c'è dubbio che tale compilatore sia tra i migliori se non il migliore attualmente disponibile.

Quindi se state realizzando un software non commerciale, una bella compilazione con il compilatore Intel e le sue ottimizzazioni per i processori Intel potrebbe darvi grandi soddisfazioni.

Bene cominciamo, per prima cosa occorre il compilatore, lo trovate qui: http://software.intel.com/en-us/articles/non-commercial-software-download/

Scaticate e scompattate il file e lanciate come root il file "install.sh", vi apparirà il seguente menù:



date invio e andate avanti.

Ovviamente questo tutorial non avrebbe senso se l'installazione fosse stata semplice :), infatti vi trovere subito dei problemi:



Selezionate 2 per analizzare i dettagli.

Ed ecco l'origine dei nostri mali:



Provate a forzare l'installazione selezionando 1.

Legge la licenza ed alla fine digitate "accept".

Alla schermata per l'attivazione scegliete il menù 1:



A questo punto occore inserire il codice seriale che vi è stato spedito via email durante la registrazione per il download del compilatore.

Alla seguente schermata indicate dove installare i files, /opt va benissino:



Bene siamo quasi alla fine seguite le indicazione dell'ultima schermata:



date quindi un bel "$ sudo /opt/intel/bin/compilervars.sh ia32"

Nel mio caso tale comando non ha dato esito, ho quindi provveduto per via manuale alla modifica della variabile $PATH aggiungendo il percorso dei file binari del compilatore.

date i seguenti comandi:

$ cd
$ gedit .profile

e modificate il file come segue:



tutto fatto :)

Buon lavoro

Arduino, MAX232 e comunicazione seriale - Parte 2

Nel post precedente abbiamo visto il circuito che occorre realizzare per creare l'interfaccia hardware che permetta ad Arduino di avere una comunicazione seriale secondo il protocollo RS232.

La prima cosa da fare è includere la libreria nel nostro programma, indicare i PIN che vogliamo usare come RX ( comunicazione TTL in ingresso) e TX (comunicazione TTL in uscita).

#include <SoftwareSerial.h>
#define RX 6
#define TX 7
SoftwareSerial mySerial(RX, TX);

Con l'istruzione SoftwareSerial si definisce una interfaccia seriale dal nome mySerial indicando i PIN adibiti a RX ed a TX.

Nel caso si voglia usare anche il secondo canale di trasmissione disponibile nel MAX232 su può definire una seconda interfaccia usando un altro nome ed altri PIN:

SoftwareSerial secondSerial(3,4)

Abbiamo definito i PIN che trasmettono i dati, ma non abbiamo ancora definito di che tipo sono i dati da trasmettere, per tale motivo occorre dichiarare le variabili tx ed rx, che sono rispettivamente l'informazione spedita da Arduino e l'informazione ricevuto.

Tali variabili sono definite come byte, tale tipo memorizza 8 bit, permettendo di avere dei valori da 0 a 255.

byte tx = 0;    // variabile per contenere il carattere inviato
byte rx = 0;    // variabile per contenere il carattere ricevuto

Giunti a questo punto abbiamo definito sia l'interfaccia hardware che software di comunicazione, mancano ancora ancora settaggi fondamentali per la connessione come ad esempio la velocità di trasmissione dei dati.

Per eseguire dei test e dei debug uso due connessioni seriali, una dal PC ad Arduino ed una seconda da Arduino al PC (mySerial).

void setup()
    {
    Serial.begin(19200); // imposto la UART per lavorare a 19200
    pinMode(led, OUTPUT); // imposto il pin sul quale è collegato il led come uscita
    Serial.flush(); // svuoto il buffer di ricezione seriale

        mySerial.begin(19200);
        mySerial.flush();
        Serial.println("Avvio della comunicazione");
    }

Riorganizzando quanto detto in un unico programma abbiamo quanto segue:

/*

*/

#include <SoftwareSerial.h>
#define RX 6
#define TX 7
SoftwareSerial mySerial(RX, TX);

#define led 13  // led connesso al pin n°13

byte tx = 0;
byte rx = 0;    // variabile per contenere il carattere ricevuto

void setup()
    {
    Serial.begin(19200); // imposto la UART per lavorare a 19200
    pinMode(led, OUTPUT); // imposto il pin sul quale è collegato il led come uscita
    Serial.flush(); // svuoto il buffer di ricezione seriale

        mySerial.begin(19200);
        mySerial.flush();
        Serial.println("Avvio della comunicazione");
    }

void loop()
    {
        int flag=0;

    while (Serial.available() >0) // Controllo se il buffer di ricezione contiene qualcosa
        {
        tx = Serial.read(); // leggo il carattere ricevuto e lo memorizzo in rx
        mySerial.write(tx);
        Serial.print("Arduino TX ->  ");
        Serial.write(tx);
        Serial.println();

        flag = 1; // per scrivere il carattere "CR" su mySerial
        }

        if (flag == 1){
                    mySerial.println();
                    flag = 0;
                }

                if (digitalRead(RX)== 1)
                {
                    Serial.println("-------");
                }
                else
                {
                  Serial.print("RX <- ");
                  Serial.println(RX);
                }

        while (mySerial.available()>0)
                {
                  rx = mySerial.read();
                  Serial.write(rx);
                  flag = 1;
                }
                if (flag == 1){
                    Serial.println();
                    flag = 0;
                }
delay(1000);
}

Nel prossimo post vedremo come fare il debug e se finalemnte il cellulare risponde ai comandi

Arduino, Max232 e comunicazione seriale - Parte 1

Dopo vari test e semplici esercizi di studio con Arduino è giunto il momento di mettere in piedi un progetto ambizioso, permettere ad Arduino di comunicare con un cellulare o un modulo GSM, in modo da inviare informazioni e ricevere comandi tramite SMS.

Ma i grandi progetti cominciano con piccoli passi, e nel mio caso il primo passo da fare e permettere la comunicazione tra Arduino e un telefono cellulare, usando i classici comandi "AT".

Se come me state pensando di usare il PIN 0 ed il PIN 1 per collegare Arduino al cellulare, vi annuncio di lasciar perdere, lo sbaglio è già stato fatto da me.

I PIN in questione sono già utilizzati dalla comunicazione seriale che instauriamo con Arduino quando lo colleghiamo al PC tramite cavo USB.

Occorre quindi far ricorso ad altre risorse, in particolare possiamo usare due uscite digitali tra quelle disponibili (nel mio caso PIN 6 e PIN 7), e far ricorso alle librerie: "SoftwareSerial.h" che sono comprese nell'ambiente di sviluppo.

Le librerie SoftwareSerial ci permetterano di impostare i precedenti PIN 6 e 7 come i PIN adeguati ad una comunicazione tramite TTL.
In tal modo potremo usare tutti i comandi classici della comunicazione seriale di Arduino su questi due nuovi PIN.
La condizione da rispettare è che la forma "Serial.xxxxx()" diventi una forma del tipo "mySerial.xxxxx()", per tutta la documentazione del caso vi invito alla lettura del link: http://arduino.cc/en/Reference/SoftwareSerial.

Oltre alla libreria software ci occorre un famosissimo integrato, il MAX232!
Il Maxim MAX232 permette di convertire i segnali TTL provelienti dai PIN 6 e 7 nei segnali previsti dalla comunicazione RS232, per tutte le informazioni del caso cliccate qui.

Come potete vedere nel sito ufficiale della Maxim, lo schema del MAX232 è:



L'integrato permettere di realizzare due comunicazioni seriali secondo l'RS232 semplicemente usando altri due PIN di Arduino, ma per il mio scopo va bene utilizzare solo un canale di trasmissione per tale motivo nello schema successivo trovate collegati solo i PIN 11 e 12 (T1in e R1out) ad Arduino.

La porta seriale del cellulare sarà invece collegata ai PIN 13 e14 (R1in e T1out):

Dallo schema del MAX232 si vede benissimo che esso esegue un inversione del segnale di ingresso, i segnali TTL inviati da Arduino.

I segnali TTL inviati da Arduino posso assumere i valori:

• 0V per esprimere lo "0" logico;


• +5V per esprimere l' "1" logico.

Tali livelli logici sono inviati al MAX232 che li inverte dando in uscita:

TTL	RS-232
livello logico "0"/ 0V	+10 V Lo Standard RS232 prevede un valore da +6V a -15V
livello logico "1" / +5V	-10 V Lo Standard RS232 prevede un valore da -6V a -15V

Quindi se avete qualche dubbio sul corretto funzionamento dell'integrato basta collegare il PIN T1in di ingresso a +5V ed in uscita al T1out dovete leggere un valore da -6V a -15V.

Ripetendo il test mettendo a massa il PIN T1in il valore in uscita al T1out deve essere compreso tra +6V e +15V.

Il collegamento tra Arduino, il MAX232 ed il connettore DB9 dove collegare il cellulare è stato fatto rispettando lo schema ed i commenti che trovate qui.


Nel mio caso ho:
Vcc = 5 volt, prelevati dall'opportuno PIN di Arduino, verificate che il vostro max232 richieda 5 Volt e non di più.
RX = PIN 6
TX = PIN 7
GND = PIN GND di Arduino
Per il condensatore sul PIN 16 del max232 ho usato un condensatore da 100uF, causa non disponibilità del 10uF, e tutto funziona benissimo.

Bene con SoftwareSerial.h, il maxim max232, ed una manciata di condensatori abbiamo creato l'interfaccia che ci serve per la comunicazione, ma la via è ancora lunga ed il debug anche, quindi nella seconda parte metteremo mano ad un po' di codice e a qualche altro accessorio che potrebbe servire.

Il circuito realizzato, scusate la qualità, è quindi il seguente: