[c++] Lettura Dati Seriale

[Mattiatn]

Buongiorno a tutti,

vi spiego subito quale è il mio problema: praticamente devo raccogliere dei dati da uno scanner laser industriale di sicurezza, il quale è impostato sull'emmissione continua di dati, che vengono mandati sulla seriale. Da pc io vorrei leggere questi dati (sono in forma di telegrammi), e quindi ho utilizzato le Api, con ReadFile.

Il buffer che metto nella lettura è di tip LPVOID, grazie al quale riesco effettivamente ad estrarre dei dati utili. Ci sono però due problemi abbastanza importanti.

1) Non riesco a capire cosa sia effettivamente LPVOID, ma è l'unico con il quale riesco ad estrarre dati. Il problema è che per la loro elaborazione sono molto più comodo con oggetti string (non char). Non sapendo come eseguire la trasformazione da LPVOID->string per ora scrivo ogni volta un file di testo e lo rileggo immediatamente come string.... non il massimo dell'efficienza.

2) Le informazioni che ho sul laser sono veramente poche, c'è un modo per capire come vengono spediti i dati da questo (ovvero se sono caratteri ascii o che), con hyperterminal ottengo l'emissione continua di caratteri "speciali", non so se questo può esservi d'aiuto...

Vi ringrazio anticipatamente per il vostro aiuto !!!!

link al pdf dei telegrammi:

https://mysick.com/saqqara/pdf.aspx?id=im0022892

[ESSE-EFFE]

1) Non riesco a capire cosa sia effettivamente LPVOID, ma è l'unico con il quale riesco ad estrarre dati.

Puoi passare alla ReadFile anche un char *. A quel punto la conversione verso string è semplice.

2) Le informazioni che ho sul laser sono veramente poche
link al pdf dei telegrammi:

https://mysick.com/saqqara/pdf.aspx?id=im0022892

Come "veramente poche"? A me pare che nel PDF che hai postato ci sia il protocollo di comunicazione, quindi dovresti avere tutte le informazioni necessarie per estrapolare i dati che ti servono. Non sto dicendo che sia una cosa semplice, però hai anche il laser per provare quindi si tratta "solo" di implementare una classe in grado di interpretare quel protocollo.

HTH,

[fero86]

LPVOID vuol dire semplicemente puntatore a void, é una typedef definita come void*

per ottenere la stringa di caratteri basta che fai un cast esplicito a LPCSTR, che sarebbe puntatore a const CHAR (dove CHAR sarebbe banalmente char), ma come ti ha detto ESSE-EFFE puoi anche passare un puntatore a CHAR fin dall'inizio sfruttando quindi il polimorfismo.

[Mattiatn]

ok, grazie mille!

Adesso vedo di dedicarmici un pò più approfonditamente dopo questi suggerimenti, il problema è che non sono propriamente un esperto, e quindi anche le piccole difficoltà mi mettono in crisi !!

[Mattiatn]

Scusate ma proprio non riesco.....

se metto un puntatpre a char il programma salta, così come con LPCSTR, l'unico con cui funziona è ancora LPVOID....

Il problema è allora trasformare LPVOID in stringa, per ora lo faccio con il file di testo, un metodo alternativo è quello con puntatore, ma non riesco poi a metterci mano

int LetturaSeriale( HANDLE PortaSeriale )
{
    //Definizione dell'evento relativo all'arrivo di dati in ricezione
    DWORD dwEventMask = EV_RXCHAR;

    //Dichiarazione della variabile relativa al numero di Byte letti dalla seriale
    DWORD NumberOfBytesRead;

    //Settaggio della funzione di attesa di un evento
    bool DatiSuSeriale = SetCommMask( PortaSeriale , EV_RXCHAR);

    //Variabile relativa al salvataggio del buffer di lettura
    LPVOID BufferRxDati;


    //Funzione di sincronizzazione dell'acquisizione con lo scanner laser:
    //si attende l'arrivo di dati sulla seriale per la loro lettura
    WaitCommEvent(PortaSeriale , &dwEventMask, 0);

    //Lettura dei dati sulla seriale, e salvataggio dei 4 byte letti nella variabile Buffer
    bool LetturaOk = ReadFile( PortaSeriale , &BufferRxDati , 4, &NumberOfBytesRead , NULL );

    //Messaggio di errore nella lettura del buffer
    if ( !LetturaOk )
    {
        cout<<"Problema nella lettura della seriale"<<endl;
        system("Pause");
        }


    //Copia della lettura nella stringa del buffer (CON SCRITTURA DI TESTO)
    ofstream outfile2;
    outfile2.open ("temp.txt",ofstream::out | ofstream::trunc);
    outfile2<<BufferRxDati;
    outfile2.close();
    //Vettore contenitore dei dati in ingresso, di tipo double
    vector<string> DatiIngresso;
    //Componenti del vettore
    string Dato;
    ifstream in ("temp.txt");
    //Riempimento del vettore
    while(in >> Dato)
    {
        DatiIngresso.push_back(Dato);
        }
    BufferRx = DatiIngresso[0];


    //Copia LPVOID in stringa
    string* vp = (string*) BufferRxDati;

    }

[ESSE-EFFE]

se metto un puntatpre a char il programma salta, così come con LPCSTR, l'unico con cui funziona è ancora LPVOID....

Mi limito a commentare la parte relativa a LPVOID. Prova il codice modificandolo come segue:

    //Variabile relativa al salvataggio del buffer di lettura
    char BufferRxDati[4];

Oppure posta il codice che dici non funzionare quando usi char *. Ma se così com'è adesso funziona, è un puro caso perchè il puntatore non è allocato!

Tra l'altro la WaitCommEvent messa così non credo abbia molto senso perchè poi vai a leggere 4 byte dalla seriale (senza neanche controllare se effettivamente li hai letti). Insomma poi controllalo bene quel codice...

HTH,

[Mattiatn]

Infatti visto così il codice anche a me non sembra ok, a mia discolpa però c'è da dire che non ho avuto possibilità di frequentare un corso di c++, e così mi arrangio....

Visto che ci sono volevo chiederti se potresti indirizzarmi su qualche lettura che meglio potrebbe aiutarmi nel campo della seriale, grazie ancora

[ESSE-EFFE]

non ho avuto possibilità di frequentare un corso di c++,

La parte di interfacciamento con le API è più C che C++.

Visto che ci sono volevo chiederti se potresti indirizzarmi
su qualche lettura che meglio potrebbe aiutarmi nel campo della seriale,

Relativamente a Windows, anche se un po' datato, puoi cominciare a leggerti "Serial Communications in Win32": http://msdn.microsoft.com/en-us/library/ms810467.aspx.

Però dovresti dirci se ora, allocando correttamente il buffer, la lettura funziona...

[Mattiatn]

Ci ho provato ma non funziona... Il vero problema è che sto andando avanti a fari spenti, pensavo che la soluzione fosse solo quella di trasformare LPVOID in string, ma dopo quello che hai scritto mi sono reso conto che prima è meglio che mi informi parecchio sulla comunicazione seriale e sopratutto su c\c++, dove ho notevoli problemi....

[ESSE-EFFE]

Ci ho provato ma non funziona...

Facciamo un passo per volta. Comincia a postare il codice che utilizza il buffer allocato come ti ho indicato io e che non ti funziona. E dovresti anche dire che tipo di problema hai perchè "non funziona" è troppo generico...

Ah, nel caso il problema fosse questo, ovviamente allocando il buffer come char[] lo devi passare alla ReadFile direttamente come BufferRxDati e non come &BufferRxDati.

[cionci]

    //Variabile relativa al salvataggio del buffer di lettura
    char BufferRxDati[5];


    //Funzione di sincronizzazione dell'acquisizione con lo scanner laser:
    //si attende l'arrivo di dati sulla seriale per la loro lettura
    WaitCommEvent(PortaSeriale , &dwEventMask, 0);

    //Lettura dei dati sulla seriale, e salvataggio dei 4 byte letti nella variabile Buffer
    bool LetturaOk = ReadFile( PortaSeriale , (LPVOID)BufferRxDati , 4, &NumberOfBytesRead , NULL );

    //Messaggio di errore nella lettura del buffer
    if ( !LetturaOk )
    {
        cout<<"Problema nella lettura della seriale"<<endl;
        system("Pause");
    }
    BufferRxDati[4] = '/0';

[Mattiatn]

Ho provato con il char ed effettivamente funziona !!! (non che dubitassi delle vostre capacità nè)

Ora però ho un problema secondario, che succedeva anche con Labview, ovvero i caratteri non sono scritti in codice esadecimale, ma in strani disegnetti (come vedevo nell'hyperterminal)... Non avete qualche altro suggerimento (spero di non mettere a dura prova la vostra pazienza...)

nel zip vi è la bozza del file ed un txt con le letture.

Vi ringrazio ancora!!

[cionci]

Evidentemente la porta seriale non è settata al meglio... Prova a lavorare su bit dis top e bit di parità.

[Volutomitra]

Il dispositivo ti invia dei pacchetti di dati fatti di TOT byte e sei tu che devi interpretarli. Se, ad esempio, il protocollo prevede un pacchetto tipo

00 1A 32 56 7B 3C (inventato)

non è che ti arrivano i caratteri 0, 0, 1, A, 3, 2, ecc... Ti arrivano i valori esadecimali 0, 1a, 32, ecc...

[ESSE-EFFE]

Ho provato con il char ed effettivamente funziona

Bene.

ovvero i caratteri non sono scritti in codice esadecimale, ma in strani disegnetti (come vedevo nell'hyperterminal)...

Immagino che HyperTerminal provi a rappresentare i vari byte ricevuti in ASCII e dato che il protocollo del laser mi pareva binario la cosa è del tutto normale.

Non avete qualche altro suggerimento

Beh, in primo luogo ti farebbe comodo un terminale con diverse possibilità di visualizzazione in modo da verificare il protocollo. Poi, come già ti hanno detto, e come anche io ti avevo suggerito, devi scrivere il codice che interpreti il protocollo, non vedo molto altro da fare...

[Mattiatn]

scusate, ma pensavo di aver risposto verso le 11....

il fatto è che il laser emette dati in pacchetti esadecimali (si dice così?): con lpvoid riuscivo a leggere il numero esadecimale, es 0x0011bbaa, mentre ora penso che sto leggendo una codifica di questo valore. Con labview si ha lo stesso problema, solamente che nel display basta mettere l'opzione "Hex Dispaly". Mi chiedevo allora in che codifica possano essere i dati forniti dal char, per eventualmente eseguire una loro "codifica".

Dato che ci sono, volevo gentilmente chiedervi se, poteste rispondermi ad un'altra domanda. In questo momento sto leggendo 4 byte dal buffer, ma su questo possono essercene di più? E se sono di più, prendo solo 4 byte e gli altri rimangono o cancello anche quelli non letti?

Ancora una volta grazie mille!!

[cionci]

Guarda che char è solo un buffer. Puoi anche stampare ogni char in esadecimale.

[ESSE-EFFE]

il fatto è che il laser emette dati in pacchetti esadecimali

Da quel poco che ho visto il protocollo del laser è binario, che poi vengano indicati i valori in esadecimale è un altro discorso.

con lpvoid riuscivo a leggere il numero esadecimale, es 0x0011bbaa, mentre ora penso che sto leggendo una codifica di questo valore.

A parte che bisognerebbe capire dove lo leggi quel numero, comunque non ti preoccupare di questo: ogni byte ricevuto andrà a riempire i byte del tuo array di char (o unsigned char).

Con labview si ha lo stesso problema, solamente che nel display basta mettere l'opzione "Hex Dispaly". Mi chiedevo allora in che codifica possano essere i dati forniti dal char, per eventualmente eseguire una loro "codifica".

Non confondere il valore del byte con la sua rappresentazione. Se ricevi un byte di valore 65 (per esempio), lo puoi rappresentare come 65 (decimale), 41 (hex) o A (ASCII), ma sempre di quel byte si tratta.

Dato che ci sono, volevo gentilmente chiedervi se, poteste rispondermi ad un'altra domanda. In questo momento sto leggendo 4 byte dal buffer, ma su questo possono essercene di più?

Certo. Ed in effetti non capisco perchè ne leggi così pochi per volta, non ha senso. Svuota tutto ed interpreta i byte ricevuti.

E se sono di più, prendo solo 4 byte e gli altri rimangono o cancello anche quelli non letti?

Rimangono bufferizzati finchè non vengono letti o finchè non avviene uno svuotamento del buffer in altro modo (compreso un eventuale errore).

[Mattiatn]

mmm le cose si fanno difficili, anche perchè le mie conoscenza in questo campo rasentano lo zero....

Sul fatto del numero di byte sulla seriale, c'è modo di conoscere quanti effettivamente sono? Non vorrei dire una stupidaggine, ma il massimo valore è di 8 byte (quello impostato nel DCB.ByteSize)?

Dopodichè, una volta che ho la stringa di caratteri, che codifica devo eseguire per potermeli trovare in formato esadecimale (che è effettivamente quello che mi serve per estrarre la scansione)?

Grazie ancora (non so che altro dire, avete una pazienza immensa )

[cionci]

Fai così, leggi un carattere alla volta e stampalo in esdecimale. La ReadFile dovrebbe essere bloccante se non ci sono byte disponibili.

    //Variabile relativa al salvataggio del buffer di lettura
    char BufferRxDati;


    //Funzione di sincronizzazione dell'acquisizione con lo scanner laser:
    //si attende l'arrivo di dati sulla seriale per la loro lettura
    WaitCommEvent(PortaSeriale , &dwEventMask, 0);

    //Lettura dei dati sulla seriale, e salvataggio dei 4 byte letti nella variabile Buffer
    bool LetturaOk = ReadFile( PortaSeriale , (LPVOID)&BufferRxDati , 1, &NumberOfBytesRead , NULL );

    //Messaggio di errore nella lettura del buffer
    if ( !LetturaOk )
    {
        cout<<"Problema nella lettura della seriale"<<endl;
        system("Pause");
    }

    cout << hex << (int)BufferRxDati << endl;