Класс для COM-порта с поддержкой событий

// TestSerial.cpp : main project file.
 
#include "stdafx.h"
#include "windows.h"
#include <string>
#include <iostream>
#include <exception>
 
using namespace std;
 
using namespace System;
 
#define READ_TIMEOUT_MSEC 100
 
const DWORD READ_BUF_SIZE = 20;
 
 
BOOL WriteComPort(HANDLE hComm, char * lpBuf, DWORD dwToWrite, DWORD &dwWritten)
{
    OVERLAPPED osWrite = { 0 };
    DWORD dwRes;
    BOOL fRes = FALSE;
 
    // Create this write operation's OVERLAPPED structure's hEvent.
    osWrite.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
 
    if (osWrite.hEvent == NULL) {
    
        // error creating overlapped event handle
        return FALSE;
    }
 
    // Issue write.
    if (!::WriteFile(hComm, lpBuf, dwToWrite, &dwWritten, &osWrite)) {
 
        if (::GetLastError() != ERROR_IO_PENDING) {
            
            // WriteFile failed, but isn't delayed. Report error and abort.
            fRes = FALSE;
        }
        else {
 
            // Write is pending.
            dwRes = ::WaitForSingleObject(osWrite.hEvent, INFINITE);
 
            switch (dwRes)
            {
                // OVERLAPPED structure's event has been signaled. 
                case WAIT_OBJECT_0:
 
                    if (!::GetOverlappedResult(hComm, &osWrite, &dwWritten, TRUE))
                        fRes = FALSE;
                    else
                        // Write operation completed successfully.
                        fRes = TRUE;
                    break;
 
                default:
 
                    // An error has occurred in WaitForSingleObject.
                    // This usually indicates a problem with the
                    // OVERLAPPED structure's event handle.
                    fRes = FALSE;
                    break;
                }
            }
    }
    else {
    
        // WriteFile completed immediately.
        fRes = TRUE;
    }
 
    if (osWrite.hEvent != NULL) ::CloseHandle(osWrite.hEvent);
 
    return fRes;
}
 
 
BOOL ReadComPort(HANDLE hComm, char * lpBuf, DWORD &dwRead) {
 
    BOOL fRes = FALSE;
    OVERLAPPED osReader = { 0 };
 
    // Create the overlapped event. Must be closed before exiting
    // to avoid a handle leak.
    osReader.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
 
    if (osReader.hEvent == NULL) {
 
        // error creating overlapped event handle
        return FALSE;
    }
 
    // Issue read operation.
    DWORD fSuccess = ::ReadFile(hComm, lpBuf, READ_BUF_SIZE, &dwRead, &osReader);
    
    DWORD dwErr = GetLastError();
 
    if (!fSuccess) {
            
        //if (::GetLastError() != ERROR_IO_PENDING) {
        if (false) {
 
            // WriteFile failed, but isn't delayed. Report error and abort.
            fRes = FALSE;
        }
        else {
 
            DWORD dwRes = ::WaitForSingleObject(osReader.hEvent, READ_TIMEOUT_MSEC);
 
            switch (dwRes) {
 
                // Read completed.
                case WAIT_OBJECT_0:
 
                    if (!::GetOverlappedResult(hComm, &osReader, &dwRead, FALSE)) {
 
                        // Error in communications; report it.
                        throw new exception("Error in communications");
 
                    }
                    else {
 
                        // Read completed successfully.
                        fRes = TRUE;
                    }
 
                    break;
 
                case WAIT_TIMEOUT:
 
                    // Operation isn't complete yet. fWaitingOnRead flag isn't
                    // changed since I'll loop back around, and I don't want
                    // to issue another read until the first one finishes.
                    //
                    // This is a good time to do some background work.
                    fRes = FALSE;
                    break;
 
                default:
                    // Error in the WaitForSingleObject; abort.
                    // This indicates a problem with the OVERLAPPED structure's
                    // event handle.
                    fRes = FALSE;
                    break;
            }
 
        }
 
    }
 
    if (osReader.hEvent != NULL) ::CloseHandle(osReader.hEvent);
}
 
 
int main(array<System::String ^> ^args)
{
    wstring name;
    HANDLE hComm = NULL;
    char * buff = new char[21];
 
    try {
 
        name = L"COM1";
 
        hComm = ::CreateFile( name.c_str(),
            GENERIC_READ | GENERIC_WRITE,
            0,
            NULL,
            OPEN_EXISTING,
            FILE_FLAG_OVERLAPPED,
            NULL);
 
        if ( hComm == INVALID_HANDLE_VALUE ) {
            
            throw new exception("INVALID_HANDLE_VALUE");
        }
 
        DCB dcb;
        
        ::FillMemory(&dcb, sizeof(dcb), 0);
 
        DWORD fSuccess = ::GetCommState(hComm, &dcb);
        
        if (!fSuccess){
            
            throw new exception("GetCommState()");
        }
 
        dcb.DCBlength = sizeof(DCB);
        
        if (!::BuildCommDCB(L"9600,n,8,1", &dcb)) {
 
            // Couldn't build the DCB. Usually a problem
            // with the communications specification string.
            throw new exception("BuildCommDCB()");
        }
 
        fSuccess = ::SetCommState(hComm, &dcb);
        
        if (!fSuccess){
 
            throw new exception("SetCommState()");
        }
 
        // Contains various COM timeouts 
        COMMTIMEOUTS CommTimeouts;       
 
        // Timeouts in msec.
        CommTimeouts.ReadIntervalTimeout = MAXDWORD;
        CommTimeouts.ReadTotalTimeoutMultiplier = 10;
        CommTimeouts.ReadTotalTimeoutConstant = 100;
        CommTimeouts.WriteTotalTimeoutMultiplier = 0;
        CommTimeouts.WriteTotalTimeoutConstant = 0;
 
        // Set COM timeouts.
        fSuccess = ::SetCommTimeouts(hComm, &CommTimeouts);
 
        if (!fSuccess){
        
            throw new exception("SetCommTimeouts()");
        }
 
        // Посылаем команду чтения данных.
        string cmd = "AT02R";
        DWORD dwWritten;
 
        WriteComPort(hComm, (char *)cmd.c_str(), cmd.length(), dwWritten);
 
        // Принимаем ответ.       
        DWORD dwRead;
 
        ReadComPort(hComm, buff, dwRead);
        
    }
    catch ( exception &ex ) {
        
        cout << "[ERROR] " << ex.what() << endl;
    }
 
    if (hComm != NULL)  ::CloseHandle(hComm);
 
    return 0;
}