COM-порт чтение\запись

#ifndef __SERIAL_H__
#define __SERIAL_H__
 
#include <string>
#include <windows.h>
 
typedef std::basic_string<TCHAR> tstring;
 
class Serial
{
private:
    HANDLE commHandle;
 
public:
    Serial(tstring &commPortName, int bitRate = 115200);
 
    virtual ~Serial();
 
    int write(const char buffer[]);
 
    int read(char *buffer, int buffLen, bool nullTerminate = true);
 
    ///очищаем все из буфера порта
    void flush();
};
 
#endif

#include <iostream>
//using namespace std;
 
#include "Serial.h"
 
Serial::Serial(tstring &commPortName, int bitRate)
{
    commHandle = CreateFile(commPortName.c_str(), GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
 
    if(commHandle == INVALID_HANDLE_VALUE) 
    {
        throw("ERROR: Could not open com port");
    }
    else 
    {
        // set timeouts
        COMMTIMEOUTS cto = {MAXDWORD, 0, 0, 0, 0};
        DCB dcb;
        if(!SetCommTimeouts(commHandle, &cto))
        {
            Serial::~Serial();
            throw("ERROR: Could not set com port time-outs");
        }
 
        // set DCB
        memset(&dcb, 0, sizeof(dcb));
        dcb.DCBlength = sizeof(dcb);
        dcb.BaudRate = bitRate;
        dcb.fBinary = 1;
        dcb.fDtrControl = DTR_CONTROL_ENABLE;
        dcb.fRtsControl = RTS_CONTROL_ENABLE;
 
        dcb.Parity = NOPARITY;
        dcb.StopBits = ONESTOPBIT;
        dcb.ByteSize = 8;
 
        if(!SetCommState(commHandle, &dcb))
        {
            Serial::~Serial();
            throw("ERROR: Could not set com port parameters");
        }
    }
}
 
Serial::~Serial()
{
    CloseHandle(commHandle);
}
 
int Serial::write(const char *buffer)
{
    DWORD numWritten;
    WriteFile(commHandle, buffer, strlen(buffer), &numWritten, NULL); 
 
    return numWritten;
}
 
int Serial::read(char *buffer, int buffLen, bool nullTerminate)
{
    DWORD numRead;
    if(nullTerminate)
    {
        --buffLen;
    }
 
    BOOL ret = ReadFile(commHandle, buffer, buffLen, &numRead, NULL);
 
    if(!ret)
    {
        return 0;
    }
 
    if(nullTerminate)
    {
        buffer[numRead] = '\0';
    }
 
    return numRead;
}
 
#define FLUSH_BUFFSIZE 10
 
void Serial::flush()
{
    char buffer[FLUSH_BUFFSIZE];
    int numBytes = read(buffer, FLUSH_BUFFSIZE, false);
    while(numBytes != 0)
    {
        numBytes = read(buffer, FLUSH_BUFFSIZE, false);
    }
}

// SerialTest.cpp : Defines the entry point for the console application.
//
 
#include <iostream>
#include <windows.h>
 
#include "Serial.h"
#include "stdafx.h"
 
 
#define RX_BUFFSIZE 20
 
void printUsage(_TCHAR progName[]);
 
int _tmain(int argc, _TCHAR* argv[])
{
    if(argc != 2)
    {
        printUsage(argv[0]);
        return 10;
    }
 
    try
    {
        std::cout<<"Opening com port"<<std::endl;
        Serial serial((tstring)argv[1], 115200);
        std::cout<<"Port opened"<<std::endl;
 
        std::cout<<"writing something to the serial port"<<std::endl;
        serial.flush();
 
        int bytesWritten = serial.write("AT");
        
        std::cout<<bytesWritten<<" bytes were written to the serial port"<<std::endl;
 
        char buffer[RX_BUFFSIZE];
        std::cout<<"Reading from the serial port: ";
        for(int i(0); i < 10; i++)
        {
            int charsRead = serial.read(buffer, RX_BUFFSIZE);
            std::cout<<buffer;
            Sleep(100);
        }
        std::cout<<std::endl;
 
    }
    catch(const char *msg)
    {
        std::cout<<msg<<std::endl;
    }
 
    return 0;
}
 
void printUsage(_TCHAR progName[])
{
    #if defined(UNICODE)
        std::wcout<<progName<<" <comm port>"<<std::endl<< "e.g., "<<progName<<" COM1"<<std::endl;
    #else
        std::cout<<progName<<" <comm port>"<<std::endl<<"e.g., "<<progName<<" COM1"<<std::endl;
    #endif
}