codeblock rs232 实例

同步收发代码。（不能分开线程读与写）

/*
* 线程控制串口的读与写操作。
*/
#include "xconfig.h"

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>

static HANDLE FCommHandle = INVALID_HANDLE_VALUE;
static BOOL FTerminated = FALSE;

static DWORD do_comm_read(DWORD iTimeOut)
{
    BOOL bRet = FALSE;
    DWORD iStart, iSpan;
    DWORD dwLength, dwFixLen, dwErrorFlags, iRet=0;
    COMSTAT comStatus;
    char Buf[BUFSIZ];

    iStart = GetTickCount();

    dwLength = 0;
    while (dwLength == 0) {
        ClearCommError(FCommHandle, &dwErrorFlags, &comStatus);
        if (dwErrorFlags > 0) {
            //Abort Sending/Reading Operation and Data
            PurgeComm(FCommHandle, (PURGE_RXABORT | PURGE_RXCLEAR | PURGE_TXABORT | PURGE_TXCLEAR));
        }
        dwLength = comStatus.cbInQue ;
        iSpan = (GetTickCount()- iStart);
        if (iSpan > iTimeOut) break ;
        if (dwLength < dwFixLen) Sleep(0);
    }
    if (dwLength > 0) {
        memset(Buf, 0, sizeof(Buf));
        dwFixLen = sizeof(Buf);
        bRet = ReadFile(FCommHandle, Buf, min(dwFixLen, dwLength), &iRet, 0);
        if ((bRet)&& (iRet > 0)) {
            printf("%s", Buf);
        }
    }
    return iRet;
}

DWORD WINAPI ThreadFunc_UartSync(LPVOID args)
{
    BOOL bRet = FALSE;
    DWORD iRet = 0, iLen=0;
    char Buf[BUFSIZ];

    while (!FTerminated)
    {
        memset(Buf, 0, sizeof(Buf));
        gets(Buf);
        iLen = strlen(Buf);
        Buf[iLen] = '\r';
        Buf[iLen+1] = '\n';
        iLen += 2;
        bRet = WriteFile(FCommHandle, Buf, iLen, &iRet, NULL);
        if (bRet) {
            //printf("WriteFile [%ld] bytes. [%s], real is [%ld] Bytes. \r\n", iLen, Buf, iRet);
        }

        while (0 != do_comm_read(1000));
    }

    return 0;
}

int main(int argc, char **argv)
{
    COMMTIMEOUTS CommTimeOut;
    DCB dcb;
    char com[64] = {0};

    sprintf(com, "%s%s", "\\\\.\\", "com6");
    FCommHandle = CreateFile(TEXT(com), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);

    if (FCommHandle == INVALID_HANDLE_VALUE) {
        printf("Open Comm failed. [%ld] \r\n", GetLastError());
        exit(0);
    }
    else {
        printf("Open Comm success.  \r\n");
    }
    //Set Commport File InQueue/OutQueue Buffer Size
    SetupComm(FCommHandle, 8*1024, 8*1024);

    //Set TimeOut Info
    GetCommTimeouts( FCommHandle, &CommTimeOut);
    CommTimeOut.ReadIntervalTimeout = 1000;
    CommTimeOut.ReadTotalTimeoutMultiplier = 1000;
    CommTimeOut.ReadTotalTimeoutConstant = 1000;
    CommTimeOut.WriteTotalTimeoutMultiplier = 1000;
    CommTimeOut.WriteTotalTimeoutConstant = 1000;
    SetCommTimeouts( FCommHandle, &CommTimeOut);

    //Set DCB Info
    GetCommState(FCommHandle, &dcb);
#if 1
    dcb.DCBlength = sizeof(DCB);
    dcb.BaudRate = CBR_115200;
    dcb.ByteSize = DATABITS_8 ;
    dcb.Parity = NOPARITY;
    dcb.StopBits = ONESTOPBIT;
    dcb.fBinary = TRUE;
 #else
    BuildCommDCB("baud=115200 parity=N data=8 stop=1" ,&dcb);
 #endif
    SetCommState(FCommHandle, &dcb);
    PurgeComm(FCommHandle, (PURGE_RXABORT | PURGE_RXCLEAR | PURGE_TXABORT | PURGE_TXCLEAR));

    //create thread to recv and send via Uart Device.
    HANDLE hdr_sync = CreateThread(NULL, 0, ThreadFunc_UartSync, NULL, 0, NULL);

    WaitForSingleObject(hdr_sync, INFINITE);

    CloseHandle(FCommHandle);
    FCommHandle = INVALID_HANDLE_VALUE;

    return 0;
}

异步代码

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    HANDLE FCommHandle; //INVALID_HANDLE_VALUE; comx handler.
    BOOL FTerminated; //FALSE; thread terminate flag.
    OVERLAPPED   ovlap;
    // Event array.
    // One element is used for each event. There are two event handles for each port.
    // A Write event and a receive character event which is located in the overlapped structure (m_ov.hEvent).
    // There is a general shutdown when the port is closed.
    HANDLE   hEventArray[3];

    CRITICAL_SECTION    mutex;

    char UserCmd[BUFSIZ];
    DWORD iCmdLen;

    char Recv[BUFSIZ];
    DWORD iRecved;

} ASYNC_COMM_CONTEXT;


static ASYNC_COMM_CONTEXT g_context;



static void RecvFromCom(void)
{
    BOOL  bResult = TRUE;
    DWORD dwError = 0;
    DWORD BytesRead = 0;
    COMSTAT comstat;

    for (;;) {
        EnterCriticalSection(&g_context.mutex);
        bResult = ClearCommError(g_context.FCommHandle, &dwError, &comstat);
        LeaveCriticalSection(&g_context.mutex);
        if (comstat.cbInQue == 0) { // break out when all bytes have been read
            break;
        }

        EnterCriticalSection(&g_context.mutex);

        bResult = ReadFile(g_context.FCommHandle,        // Handle to COMM port
                               g_context.Recv,                // RX Buffer Pointer
                               1,                    // Read one byte
                               &BytesRead,            // Stores number of bytes read
                               &g_context.ovlap);        // pointer to the m_ov structure
        // deal with the error code
        if (!bResult){
            switch (dwError = GetLastError()) {
                    case ERROR_IO_PENDING: {
                            GetOverlappedResult(g_context.FCommHandle,    // Handle to COMM port
                                          &g_context.ovlap,        // Overlapped structure
                                          &BytesRead,        // Stores number of bytes read
                                          TRUE);             // Wait flag
                        }
                        break;
                    default:
                        break;
            }
        }

        LeaveCriticalSection(&g_context.mutex);

        if (BytesRead > 0) {
            g_context.Recv[BytesRead] = 0;
            printf("%s", g_context.Recv);
            BytesRead = 0;
        }
    }
}

static void SendDataToCom(void)
{
    BOOL bResult = TRUE;
    DWORD BytesSent = 0;

    ResetEvent(g_context.hEventArray[2]);

    EnterCriticalSection(&g_context.mutex);

    //start write Data.
    {
        bResult = WriteFile(g_context.FCommHandle,                            // Handle to COMM Port
                            g_context.UserCmd,                    // Pointer to message buffer in calling finction
                            g_context.iCmdLen,                    // Length of message to send
                            &BytesSent,                                // Where to store the number of bytes sent
                            &g_context.ovlap);                            // Overlapped structure
        // deal with any error codes
        if (!bResult) {
            DWORD dwError = GetLastError();
            switch (dwError) {
                case ERROR_IO_PENDING:    { // continue to GetOverlappedResults()
                        GetOverlappedResult(g_context.FCommHandle,    // Handle to COMM port
                                      &g_context.ovlap,        // Overlapped structure
                                      &BytesSent,        // Stores number of bytes sent
                                      TRUE);             // Wait flag
                        break;
                    }
                default:
                    break;
            }
        }
    }

    //write complete.
    LeaveCriticalSection(&g_context.mutex);

    //Verify that the data size send equals what we tried to send
    if (BytesSent != g_context.iCmdLen)    {// Length of message to send
        //do what???
    }
}

///////////////////////////////////////////////////////////////////////////////////////////////////
////  WIN32 异步串口
///////////////////////////////////////////////////////////////////////////////////////////////////
static VOID FinalComPort(void)
{
    CloseHandle( g_context.ovlap.hEvent );

    if (g_context.FCommHandle != INVALID_HANDLE_VALUE) {
        CloseHandle(g_context.FCommHandle);
        g_context.FCommHandle = INVALID_HANDLE_VALUE;
    }
}

static BOOL InitEvent(void)
{
    //initial Overlapped struct.
    g_context.ovlap.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
    ResetEvent(g_context.ovlap.hEvent);

    g_context.hEventArray[0] = CreateEvent(NULL, TRUE, FALSE, NULL); //rs232 shutdown event.
    g_context.hEventArray[1] = g_context.ovlap.hEvent; //rs232 read
    g_context.hEventArray[2] = CreateEvent(NULL, TRUE, FALSE, NULL); //rs232 write event.

    return TRUE;
}

static BOOL InitComPort(void)
{
    COMMTIMEOUTS CommTimeOut;
    DCB dcb;
    char com[64] = {0};

    sprintf(com, "%s%s", "\\\\.\\", "com6");
    g_context.FCommHandle = CreateFile(TEXT(com),
                         GENERIC_READ | GENERIC_WRITE,    // read/write types
                         0,                                // comm devices must be opened with exclusive access
                         NULL,                            // no security attributes
                         OPEN_EXISTING,                    // comm devices must use OPEN_EXISTING
                         FILE_FLAG_OVERLAPPED,            // Async I/O
                         0);                            // template must be 0 for comm devices

    if (g_context.FCommHandle == INVALID_HANDLE_VALUE) {
        printf("Open Comm failed. [%ld] \r\n", GetLastError());
        return FALSE;
    }
    else {
        printf("Open Comm success.  \r\n");
    }

    //Set Commport File InQueue/OutQueue Buffer Size
    SetupComm(g_context.FCommHandle, 8*1024, 8*1024);

    //Set TimeOut Info
    GetCommTimeouts( g_context.FCommHandle, &CommTimeOut);
    CommTimeOut.ReadIntervalTimeout = 1000;
    CommTimeOut.ReadTotalTimeoutMultiplier = 1000;
    CommTimeOut.ReadTotalTimeoutConstant = 1000;
    CommTimeOut.WriteTotalTimeoutMultiplier = 1000;
    CommTimeOut.WriteTotalTimeoutConstant = 1000;
    SetCommTimeouts( g_context.FCommHandle, &CommTimeOut);

    SetCommMask(g_context.FCommHandle, EV_RXFLAG | EV_RXCHAR);

    //Set DCB Info
    GetCommState(g_context.FCommHandle, &dcb);
#if 1
    dcb.DCBlength = sizeof(DCB);
    dcb.BaudRate = CBR_115200;
    dcb.ByteSize = DATABITS_8 ;
    dcb.Parity = NOPARITY;
    dcb.StopBits = ONESTOPBIT;
    dcb.fBinary = TRUE;
 #else
    BuildCommDCB("baud=115200 parity=N data=8 stop=1" ,&dcb);
 #endif
    dcb.EvtChar = 'q';
    dcb.fRtsControl = RTS_CONTROL_ENABLE;        // set RTS bit
    SetCommState(g_context.FCommHandle, &dcb);
    PurgeComm(g_context.FCommHandle, (PURGE_RXABORT | PURGE_RXCLEAR | PURGE_TXABORT | PURGE_TXCLEAR));

    return TRUE;
}


void WriteUserCmd(char *Buf, DWORD iLen)
{
    memcpy(g_context.UserCmd, Buf, iLen);
    g_context.iCmdLen = iLen;
    // set event for write
    SetEvent(g_context.hEventArray[2]);
}


DWORD WINAPI ThreadFunc_UartASync(LPVOID args)
{
    BOOL bRet = FALSE;
    DWORD Event = 0;
    DWORD CommEvent = 0;
    DWORD dwError = 0;
    COMSTAT comstat;

    while (!g_context.FTerminated)
    {
        // Make a call to WaitCommEvent(). This call will return immediatly
        // because our port was created as an async port (FILE_FLAG_OVERLAPPED)
        bRet = WaitCommEvent(g_context.FCommHandle, &Event, &g_context.ovlap);
        if (!bRet) { // If WaitCommEvent() returns FALSE, process the last error to determin the reason..
            switch (dwError = GetLastError())
            {
                case ERROR_IO_PENDING: // This is a normal return value if there are no bytes to read at the port.
                    break;
                default: // All other error codes indicate a serious error has occured. Process this error.
                    break;
            }
        }
        else {
            // If WaitCommEvent() returns TRUE, check to be sure there are actually bytes in the buffer to read.
            bRet = ClearCommError(g_context.FCommHandle, &dwError, &comstat);
            if (comstat.cbInQue == 0)
                continue;
        }

        // Main wait function. This function will normally block the thread
        // until one of nine events occur that require action.
        Event = WaitForMultipleObjects(3, g_context.hEventArray, FALSE, INFINITE);

        switch (Event)
        {
        case 0: //shutdown event.
            FinalComPort();
            return 0;
            break;
        case 1: //read event. Event will be set by Overlapped via System.
            GetCommMask(g_context.FCommHandle, &CommEvent);
            if (CommEvent & EV_RXCHAR) {// Receive character event from port.
                RecvFromCom();
            }
            break;
        case 2: //write event. this Event should be set by User Manual.
            SendDataToCom();
            break;
        } //end switch
    } //for ;;

    return 0;
}

DWORD WINAPI ThreadFunc_Console(LPVOID args)
{
    DWORD iLen=0;
    char Buf[BUFSIZ];
    while (!g_context.FTerminated)
    {
        memset(Buf, 0, sizeof(Buf));
        gets(Buf);
        iLen = strlen(Buf);
        Buf[iLen] = '\r';
        Buf[iLen+1] = '\n';
        iLen += 2;
        WriteUserCmd(Buf, iLen);
    }

    return 0;
}

int main(int argc, char **argv)
{
    if (!InitComPort()) exit(-1);
    if (!InitEvent()) exit(-2);

    // initialize critical section
    InitializeCriticalSection(&g_context.mutex);
    g_context.FTerminated = FALSE;

    //create thread to recv and send via Uart Device.
    HANDLE hdr_async = CreateThread(NULL, 0, ThreadFunc_UartASync, NULL, 0, NULL);
    HANDLE hdr_console = CreateThread(NULL, 0, ThreadFunc_Console, NULL, 0, NULL);

    //waiting for some time
    Sleep(60*1000);
    g_context.FTerminated = TRUE;

    WaitForSingleObject(hdr_async, INFINITE);
    WaitForSingleObject(hdr_console, INFINITE);

    DeleteCriticalSection(&g_context.mutex);
    FinalComPort();
    return 0;
}