timeout.c

pcom 非常好用的一个串口编程库

                EnableMenuItem(hMenu,IDM_WRITE_POLL+i,MF_ENABLED | MF_BYCOMMAND) ;
        }else{
            EnableMenuItem( hMenu, IDM_PORT_OPEN,MF_ENABLED | MF_BYCOMMAND);
            EnableMenuItem( hMenu, IDM_PORT_CLOSE,
            	MF_GRAYED | MF_DISABLED | MF_BYCOMMAND ) ;
            for(i=0;i<8;i++)
                EnableMenuItem( hMenu, IDM_WRITE_POLL+i,
            	    MF_GRAYED | MF_DISABLED | MF_BYCOMMAND ) ;
        }

        DrawMenuBar(hwnd);
}


BOOL OpenPort(void)
{
        int     ret;


        if((ret=sio_open(GCommData.Port))!=SIO_OK){
            MxShowError("sio_open",ret);
            return FALSE;
        }

        if(!PortSet()){
            sio_close(GCommData.Port);
            return FALSE;
        }

        GbOpen = TRUE;
        ShowStatus();
        SwitchMenu(GhWnd);

        return TRUE;
}


BOOL PortSet(void)
{
        int	port = GCommData.Port;
        int	mode = GCommData.Parity | GCommData.ByteSize | GCommData.StopBits;
        int	hw = GCommData.Hw ? 3 : 0;	/* bit0 and bit1 */
        int	sw = GCommData.Sw ? 12 : 0;     /* bit2 and bit3 */
        int	ret ;

        if((ret=sio_ioctl(port,GCommData.BaudRate,mode))!=SIO_OK){
            MxShowError("sio_ioctl",ret);
            return FALSE;
        }

        if((ret=sio_flowctrl(port,hw | sw))!=SIO_OK){
            MxShowError("sio_flowctrl",ret);
            return FALSE;
        }

        if((ret=sio_DTR(port,(GCommData.Dtr ? 1:0)))!=SIO_OK){
            MxShowError("sio_DTR",ret);
            return FALSE;
        }

        if(!GCommData.Hw){
            if((ret=sio_RTS(port,(GCommData.Rts ? 1:0)))!=SIO_OK){
                MxShowError("sio_RTS",ret);
                return FALSE;
            }
        }

        ShowStatus();
        return TRUE;
}


BOOL ClosePort(void)
{
        sio_close(GCommData.Port);
        GbOpen = FALSE;

        SwitchMenu(GhWnd);
        ShowStatus();

        return TRUE;
}

static void ShowStatus(void)
{
        char	szMessage[70];
        char	szbuf[20];

        lstrcpy(szMessage,GszAppName);

        if(GbOpen){
            wsprintf(szbuf," -- COM%d,",GCommData.Port);
            lstrcat(szMessage,szbuf);

            LoadString(GhInst,IDS_BAUD50+GCommData.ibaudrate,
                szbuf,20);
            lstrcat(szMessage,szbuf);
            lstrcat(szMessage,",");

            LoadString(GhInst,IDS_PARITYNONE+GCommData.iparity,
                szbuf,20);
            lstrcat(szMessage,szbuf);
            lstrcat(szMessage,",");

            LoadString(GhInst,IDS_DATABIT5+GCommData.ibytesize,
                szbuf,20);
            lstrcat(szMessage,szbuf);
            lstrcat(szMessage,",");

            LoadString(GhInst,IDS_ONESTOPBIT+GCommData.istopbits,
                szbuf,20);
            lstrcat(szMessage,szbuf);

            if(GCommData.Hw)
                lstrcat(szMessage,",RTS/CTS");

            if(GCommData.Sw)
                lstrcat(szMessage,",XON/XOFF");
        }

        SetWindowText(GhWnd,szMessage);
}


void DemoWriteTimeout(int port,UINT testitem)
{
        DWORD		dwThreadID;
        DWORD		baud;
        DWORD		to;

        switch(testitem){
        case IDM_WRITE_POLL:
            sio_SetWriteTimeouts(port,MAXDWORD);
            break;
        case IDM_WRITE_BLOCK:
            sio_SetWriteTimeouts(port,0);
            break;
        case IDM_WRITE_TIMEOUT:
            baud = sio_getbaud(port);
            /* timeout(ms)  = Buflen *(1000/ (baud/10));
                            = Buflen *  (ms /byte) */
            to = (BUFLEN / (baud/10) * 1000) * 3;
            sio_SetWriteTimeouts(port,to);
            break;
        }


        if((GhExit = CreateEvent(NULL,TRUE,FALSE,NULL))==NULL)
            return ;

        hWriteThread = CreateThread( (LPSECURITY_ATTRIBUTES) NULL,
                     0,
                     (LPTHREAD_START_ROUTINE) WriteProc,
                     (LPVOID) GhWnd,
                     0, &dwThreadID );

        if(hWriteThread==NULL){
            CloseHandle(GhExit);
            sio_close(GCommData.Port);
            return ;
        }

        DialogBox(GhInst,MAKEINTRESOURCE(IDD_WRITE_STAT),GhWnd,WStatDlgProc);
        SetEvent(GhExit);
        sio_AbortWrite(port);
        if(WaitForSingleObject(hWriteThread,3000)==WAIT_TIMEOUT)
            TerminateThread(hWriteThread,0);
        CloseHandle(GhExit);
        CloseHandle(hReadThread);
}

UINT WriteProc( LPVOID pParam )
{
        int     i;
        DWORD   t1;
        for(i=0;i<BUFLEN;i++)
            _GBuf[i] = '0'+(i%10);

        GCount  = 0;
        GCallCount = 0;
        GDifTime = 0;
        Sleep(1000);
        while(1){
            if(WaitForSingleObject(GhExit,0)==WAIT_OBJECT_0)//hExit
                break;

            t1 = GetCurrentTime();
            if(sio_write(GCommData.Port,_GBuf,BUFLEN)>0)
                GCount ++;
            GCallCount++;
            GDifTime = GetCurrentTime()-t1;
        }

        return TRUE;
}

void DemoReadTimeout(int port,UINT testitem)
{
        DWORD		dwThreadID;
        DWORD		baud;
        DWORD		to;

        baud = sio_getbaud(port);
        /* timeout(ms)  = Buflen *(1000/ (baud/10));
                        = Buflen *  (ms /byte) */
        to = (BUFLEN / (baud/10) * 1000) * 3;

        switch(testitem){
        case IDM_READ_POLL:
            sio_SetReadTimeouts(port,MAXDWORD,0);
            break;
        case IDM_READ_BLOCK:
            sio_SetReadTimeouts(port,0,0);
            break;
        case IDM_READ_BLOCK_T:
            sio_SetReadTimeouts(port,to,0);
            break;
        case IDM_READ_BLOCK_I:
            sio_SetReadTimeouts(port,0,1000);
            break;
        case IDM_READ_BLOCK_TI:
            sio_SetReadTimeouts(port,to,1000);
            break;
        }

        if((GhExit = CreateEvent(NULL,TRUE,FALSE,NULL))==NULL)
            return ;

        hReadThread = CreateThread( (LPSECURITY_ATTRIBUTES) NULL,
                    0,
                    (LPTHREAD_START_ROUTINE) ReadProc,
                    (LPVOID) GhWnd,
                    0, &dwThreadID );

        if(hReadThread==NULL){
            CloseHandle(GhExit);
            sio_close(port);
            return ;
        }

        DialogBox(GhInst,MAKEINTRESOURCE(IDD_READ_STAT),GhWnd,RStatDlgProc);

        SetEvent(GhExit);
        sio_AbortRead(port);
        if(WaitForSingleObject(hReadThread,3000)==WAIT_TIMEOUT)
            TerminateThread(hReadThread,0);
        CloseHandle(GhExit);
        CloseHandle(hReadThread);
}

UINT ReadProc( LPVOID pParam )
{
        DWORD   t1;
        DWORD   len;

        GCount  = 0;
        GCallCount  = 0;
        GDifTime = 0;
        Sleep(1000);
        while(1){
            if(WaitForSingleObject(GhExit,0)==WAIT_OBJECT_0)//hExit
                break;

            t1 = GetCurrentTime();
            len = sio_read(GCommData.Port,_GBuf,BUFLEN-1);
            GCallCount++;
            GDifTime = GetCurrentTime()-t1;
            if(len>0)
                GCount ++;
        }

        return TRUE;
}