Newsgroup: it.comp.programmare.win32
Titolo: Visual C++ e porta Seriale [lungo]

Ciao a tutto l'NG!!!
Ho un piccolo problemino con il visual C++ e la porta seriale, che vi
descriverò, e spero che qualcuno possa aiutarmi.
Allora, ho installato Visual C++ Express Edition, con windows SDK su un
professional XP. Lo scopo è quello di creare un programmino che si
interfaccia ad un dispositivo via seriale (rs232).
Il dispositivo in questione si chiama CyTerm, e monta il chip DS1615 della
Dallas Semiconductor. Il manuale (datasheet) di questo chip dice che può
comunicare in asincrono o sincrono su porta seriale con i nomralissimi
standard rs232. L'aggeggio rieceve dei comandi sottoforma di singoli byte e
da delle risposte oppure no, a seconda del comando, in parole di 32 byte.
Quindi ho provato a scrivere un programmino che sfrutta le API windows
(CreateFile, ecc...) che invia il comando 0x44, con lo scopo di fargli fare
un test facendogli accendere dei led.
Il PROBLEMA: è che l'aggeggio non riceve nulla. Ho provato a far girare il
mio pgm con una cavo nullmodem attacato ad un altro PC, e sembra che il
comando viene inviato e ricevuto correttamente. 
In fondo c'è il pgm... che cosa può essere. Che altri test posso fare per
capire come comunica il dispositivo?
Grazie a chiunque abbia voglia di darci un'occhiata e rispondermi.
// ----- programma -------
#include <stdio.h>
#include <windows.h>
#define FC_DTRDSR       0x01
#define FC_RTSCTS       0x02
#define FC_XONXOFF      0x04
#define ASCII_BEL       0x07
#define ASCII_BS        0x08
#define ASCII_LF        0x0A
#define ASCII_CR        0x0D
#define ASCII_XON       0x11
#define ASCII_XOFF      0x13
int main(int argc, char* argv[])
{
        HANDLE m_hIDComDev;
        OVERLAPPED m_OverlappedRead, m_OverlappedWrite;
        BOOL m_bOpened;
        DCB dcb;
        int nPort = 2;
        int nBaud;
        char *Port = argv[1];
    memset( &m_OverlappedRead, 0, sizeof( OVERLAPPED ) );  // buffer di
input
        memset( &m_OverlappedWrite, 0, sizeof( OVERLAPPED ) ); // buffer di output
        m_hIDComDev = NULL; // device
        m_bOpened = FALSE;  // aperta|chiusa
 
        // apertura della porta
    m_hIDComDev = CreateFile( Port, GENERIC_READ | GENERIC_WRITE, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL );
        if( m_hIDComDev == NULL ) return( FALSE );
    COMMTIMEOUTS CommTimeOuts;
        CommTimeOuts.ReadIntervalTimeout = 0x1;
        CommTimeOuts.ReadTotalTimeoutMultiplier = 0;
        CommTimeOuts.ReadTotalTimeoutConstant = 0;
        CommTimeOuts.WriteTotalTimeoutMultiplier = 0;
        CommTimeOuts.WriteTotalTimeoutConstant = 0;
        SetCommTimeouts( m_hIDComDev, &CommTimeOuts );
        nBaud = 9600; // velocità della seriale
        printf("COM%d:%d,n,8,1\n", nPort, nBaud );
        m_OverlappedRead.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
        m_OverlappedWrite.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
        dcb.DCBlength = sizeof( DCB );
        GetCommState( m_hIDComDev, &dcb );
        dcb.BaudRate = nBaud;  // setto la velocità della porta
        dcb.ByteSize = 8;      // 8 bit
 
        dcb.fDtrControl = DTR_CONTROL_ENABLE;
        dcb.fRtsControl = RTS_CONTROL_ENABLE; 
 
        unsigned char ucSet;
        ucSet = (unsigned char) ( ( FC_RTSCTS & FC_DTRDSR ) != 0 );
        ucSet = (unsigned char) ( ( FC_RTSCTS & FC_RTSCTS ) != 0 );
        ucSet = (unsigned char) ( ( FC_RTSCTS & FC_XONXOFF ) != 0 );
        if( !SetCommState( m_hIDComDev, &dcb ) ||
                !SetupComm( m_hIDComDev, 10000, 10000 ) ||
                m_OverlappedRead.hEvent == NULL ||
                m_OverlappedWrite.hEvent == NULL ){
                DWORD dwError = GetLastError();
                if( m_OverlappedRead.hEvent != NULL )
CloseHandle( m_OverlappedRead.hEvent );
                if( m_OverlappedWrite.hEvent != NULL )
CloseHandle( m_OverlappedWrite.hEvent );
                CloseHandle( m_hIDComDev );
                return( FALSE );
                }
        m_bOpened = TRUE;
 
        printf("fine apertura della porta: %i\n",(int)m_bOpened);
    // **** qui finisce il processo di inizializzazione ****
    EscapeCommFunction(m_hIDComDev, SETDTR);
        /*
        * scrivo un byte
        */
        BOOL bWriteStat;
        DWORD dwBytesWritten;
        unsigned char ucByte = 0x44;
 
        printf("Scrivo il comando 44\n");
        bWriteStat = WriteFile( m_hIDComDev, (LPSTR) &ucByte, 1, &dwBytesWritten,
&m_OverlappedWrite );
        if( !bWriteStat && ( GetLastError() == ERROR_IO_PENDING ) ){
                if( WaitForSingleObject( m_OverlappedWrite.hEvent, 1000 ) ) dwBytesWritten
= 0;
                else{
                        GetOverlappedResult( m_hIDComDev, &m_OverlappedWrite, &dwBytesWritten,
FALSE );
                        m_OverlappedWrite.Offset += dwBytesWritten;
                        }
                }
        printf("bytes scritti: %i\n", (int)dwBytesWritten);
    // chiusura della porta
        if( m_OverlappedRead.hEvent != NULL )
CloseHandle( m_OverlappedRead.hEvent );
        if( m_OverlappedWrite.hEvent != NULL )
CloseHandle( m_OverlappedWrite.hEvent );
        CloseHandle( m_hIDComDev );
        m_bOpened = FALSE;
        m_hIDComDev = NULL;
        printf("Porta COM chiusa.\n");
        return 0;
}

EscapeCommFunction(m_hIDComDev,SETDTR);
Questa potrebbe darti problemi nella comunicazione con sistemi
embedded, prova a toglierla.
Per finire, dai una sbirciatina a questo esempio della Microsoft:
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnfiles/html/msdn_serial.asp
Auguri!!!

 Auguri!!!
Grazie, provo a modificare il programma secondo i tuoi suggerimenti.