[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 :D :D !!

[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 !!!:D :D (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 :ave: )

[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;

[Mattiatn]

in questo modo mi stampa sempre lo stesso numero "77"...

[cionci]

Chiarmente devi fare un ciclo...

[Mattiatn]

il ciclo l'ho fatto in questo modo:

//Librerie standard
#include <iostream>
#include <fstream>
#include "stdio.h"
#include "windows.h"
#include "conio.h"
#include <vector>
#include <math.h>


using namespace std;

int main(int argc, char* argv[])
{

char IndirizzoSeriale[] = "COM1";


///..........................................
///Creazione della connessione fra pc e laser
///..........................................
//Apertura della connessione con la porta seriale del pc (CreateFile -> libreria API)
HANDLE PortaSeriale = CreateFile( IndirizzoSeriale , GENERIC_READ | GENERIC_WRITE , 0 , 0 , OPEN_EXISTING , 0 , 0);
//Valutazione esito della apertura
if (PortaSeriale == INVALID_HANDLE_VALUE)
{
cout<<"Errore nell'apertura della porta seriale del pc"<<endl;
cout<<"Verificare che l'indirizzo "<<IndirizzoSeriale<<" sia esatto"<<endl;
return -1;
}
else
{
cout<<"Porta seriale "<<IndirizzoSeriale<<" attivata correttamente"<<endl;
}

///........................................................
///Protocollo di configurazione della comunicazione seriale
///........................................................
//Struttura contenente le informazioni relative alla comunicazione seriale
DCB DataBaseSeriale;
//Settaggio a zero del database
memset(&DataBaseSeriale, 0, sizeof(DCB));
//Lettura delle impostazioni della comunicazione seriale
BOOL StatoOk = GetCommState( PortaSeriale , &DataBaseSeriale );
//Stampa delle principali informazioni
printf("Impostazioni seriale all'avvio\n");
printf("BaudRate %d\n", DataBaseSeriale.BaudRate);
printf("ByteSize %d\n", DataBaseSeriale.ByteSize);
printf("Parity %d\n", DataBaseSeriale.Parity);
printf("StopBits %d\n", DataBaseSeriale.StopBits);

//Cambio della velocità seriale di trasmissione
DataBaseSeriale.BaudRate = CBR_9600;
DataBaseSeriale.ByteSize = 8;
StatoOk = SetCommState( PortaSeriale , &DataBaseSeriale );

//Lettura delle impostazioni della comunicazione seriale
StatoOk = GetCommState( PortaSeriale , &DataBaseSeriale );
//Stampa delle principali informazioni
printf("\nImpostazioni seriale dopo la modifica\n");
printf("BaudRate %d\n", DataBaseSeriale.BaudRate);
printf("ByteSize %d\n", DataBaseSeriale.ByteSize);
printf("Parity %d\n", DataBaseSeriale.Parity);
printf("StopBits %d\n", DataBaseSeriale.StopBits);


///........................................................
///Protocollo di configurazione della comunicazione seriale
///........................................................
int contatore = 0;
while(1)
{
//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;
//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;

}

return 0;
}

[cionci]

A me sembra corretto, sentiamo cosa dicono gli altri.

[Mattiatn]

Scusami, errore mio, non mi ero accorto che c'era un cavo appoggiato al frontalino e allora dava errore......

così in effetti da qualcosa, ma i dati sembrano ripetersi e ci sono un pò troppe fff al suo interno.


Leggendo il libro "The Windows Serial Port Programming Handbook", come buffer nella lettura mettono un tipo BYTE, può essere utile?

[Mattiatn]

Ho provato con un array di BYTE, visto così ad occhio mi sembra abbastanza buono come risultato, il problema è che mi sembra ripetere un sacco di volte la medesima misura.

[ESSE-EFFE]

Consiglio: comincia a provare con due PC collegati tra di loro, verifica bene la lettura e poi passa al protocollo specifico.

[cionci]

Dipende da quale cavo usa e da come è inizializzato il protocollo seriale ;)

[Mattiatn]

Il collegamento fra due PC l'ho già provato tempo fa, ed immettendo solamente char il tutto funziona. Il problema è quando ho cominciato ad attaccare il laser, poiché manda segnali che non sono propriamente facili da acquisire, comunque grazie mille!!

[cionci]

Nel PDF che hai linkato il protocollo sembra che sia spiegato. Il problema è che è spiegato in tedesco :stordita:

[Mattiatn]

Nel PDF che hai linkato il protocollo sembra che sia spiegato. Il problema è che è spiegato in tedesco :stordita:

Più sotto c'è anche quello in inglese, in particolare quello che mi interessa è il CONTINUOS OUTPUT DATA. L'interpretazione del protocollo non è difficile, con il metodo precedente ce la facevo, il problema è arrivare ad ottenere i dati nella forma dei pacchetti di pagina 35 in forma esadecimale

[cionci]

Scusa, ma cosa c'entra la rappresentazione esadecimale ? Un numero è un numero, indipendentemente dalla forma in cui lo rappresenti.

[ESSE-EFFE]

manda segnali che non sono propriamente facili da acquisire


Guarda che sono byte anche quelli, esattamente come quelli che emette un PC. Solo che tramite tastiera magari invierai 'C' 'I' 'A' 'O' invece da un dispositivo esterno puoi ricevere qualunque valore da 0 a 255 (non che non si possa fare da PC ovviamente).

[Mattiatn]

Sotto il punto di vista delle tipologia di dati sono un pò carente: è che per tradurre l'output laser nella scansione polare devo avere la serie completa di pacchetti come nella forma del pdf, in modo da poter confrontare l'intestazione e ricavare le distanze misurate.

[cionci]

Allora...leggendo un carattere alla volta, cosa ottieni ?
Incolla l'output che ottieni.

Modifica la stampa in questo modo:

cout<< hex << (int)BufferRxDati << " ";
Aggiungi un cout << endl ogni 25 caratteri letti.

[Mattiatn]

print screen della lettura ad ogni byte

http://img6.imageshack.us/i/immaginelfk.jpg/

[cionci]

Ok, cambia il char in unsigned char, la conversione mettila in unsigned int.

cout<< hex << (unsigned int)BufferRxDati << " ";

[Mattiatn]

Adesso funziona!!!

Riesco a vedere a schermo le scansioni in maniera giusta!!

Però (lo so che sono un rompi), le ho sottoforma di char, mentre le vorrei in valori numerici, esadecimali, decimali, va bene comunque...

[Mattiatn]

Scusatemi ma mi sono reso conto che è abbastanza semplice trasformare il char in decimale, e questo è sufficiente per fare il resto.

Che dire, Grazie Mille per l'immenso aiuto che mi avete dato (è da più di 3 settimane che ci sto provando), spero che ci sarete anche la prossima volta (conoscendomi non sarà fra molto tempo!!)

Grazie!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!;) ;) ;) ;) ;) ;) ;) ;) ;) ;)

[Mattiatn]

Lo avevo promesso che ritornavo:D :D !!

A parte gli scherzi, grazie al vostro aiuto riesco a leggere 1 byte alla volta dalla seriale, ma mi sono accorto che dopo circa 5-6 letture, non mi torna il CRC. Mi sono chiesto quindi quale è la dinamica con cui avviene la comunicazione. La mia idea è quella che esiste un buffer d'ingresso sul pc, il quale viene riempito dalla seriale. Le sue dimensioni sono tali da poter contenere 4-5 scansioni: leggendo un solo byte alla volta il buffer si riempie più velocemente di quanto lo "scarico", quindi va in una sorta di saturazione che sovrascrive gli ultimi dati, e quindi porta all'errore del CRC. ( Ho pensato a questo perchè la velocità con cui dispongo delle scansioni non varia molto variando il baud rate, e sono sempre successive)

Questo che ho scritto è verosimile?

Ho pensato quindi che mi servirebbe una funzione che è in grado di leggere il numero di byte sulla seriale, e passarlo a quello di lettura, in maniera tale da svuotare completamente questo "supposto" buffer d'ingresso. La funzione GetFileSize() non mi viene incontro, magari perchè sbaglio ad utilizzarla, ma tendenzialmente è quella giusta?

Grazie ancora!!!

[cionci]

E' esatta la tua supposizione. Puoi continuare a leggere un byte fino a quando il buffer è vuoto.
WaitCommEvent è relativo sicuramente all'arrivo di più di un byte. Quindi è chiaro che se ne leggi solo uno ad ogni evento il buffer si riempie. Devi sapere tu, a seconda del protocollo, la dimensione caratteristica del pacchetto. In base a quello ti regoli con la dimensione del buffer e con i parametri di ReadFile.

[Mattiatn]

Finalmente (o meglio malauguratamente per voi :D :D ) sono potuto ritornare su questo progetto. Finalmente ho trovato una funzione che è in grado di dirmi quanti byte ho sul buffer di input.... Il fatto è che non è molto pubblicizzata...

La funzione è la ClearCommError, che scrive su una struttura COMSTAT il campo cbInQue. Runnando il programma è evidente che in pochi secondi il laser riempie il buffer in ingresso. Quello che ora volevo sottoporre alla vostra gentile esperienza, è come posso dare in ingresso alla ReadFile un buffer di lettura delle dimensioni volute?

[Mattiatn]

Finalmente dopo ore ho risolto, in pratica ho visto che leggendo 8bit alla volta riesco a non far riempire eccessivamente il buffer!!!

Volevo ora chiedere se è possibile emettere in uscita sulla seriale un segnale di trigger per una camera (un amico mi ha detto che dovrebbe esserci un comando con cui specificare il segnale e la sua durata...)

Grazie ancora!

[Mattiatn]

lo so che sono un rompi....

però ho ancora un problemino..... dovendo acquisire delle camere e laser, sono costretto a passare visual studio...

Il codice di lettura del laser funziona perfettamente in codeblock (compilatore gnu cc) e dopo un pò di modifiche riesco a compilarlo anche in visual studio. Il problema è però che l'exe che mi crea VS (ed anche il debug) non mi fanno aprire le porte COM..., mentre quello in codeblock lo stò già usando da parecchio tempo e funziona.

Non avete idea del perchè? E' come se VS non riuscisse a vedere/aprire la porta....

Vi ringrazio anticipatamente!!

[banryu79]

Come la apri la porta COM? Immagino con la funzione CreateFile.
Estratto da MSDN per CreateFile (qui (http://msdn.microsoft.com/en-us/library/aa363858%28VS.85%29.aspx)):

...
Communications Resources

The CreateFile function can create a handle to a communications resource, such as the serial port COM1. For communications resources, the dwCreationDisposition parameter must be OPEN_EXISTING, the dwShareMode parameter must be zero (exclusive access), and the hTemplateFile parameter must be NULL. Read, write, or read/write access can be specified, and the handle can be opened for overlapped I/O.

To specify a COM port number greater than 9, use the following syntax: "\\.\COM10". This syntax works for all port numbers and hardware that allows COM port numbers to be specified.

For more information about communications, see Communications.
...


Qua invece un esempio trovato sulla rete:
Reading and Writing to Serial Port in C++ (http://www.fogma.co.uk/foggylog/archive/140.html)