#include <Windows.h>
#include <atlstr.h>

#define BUFFER_SIZE 128

class CSerialPort  
{  
public:  
 CSerialPort(void);  
 virtual ~CSerialPort(void); 

private:  
 HANDLE  m_hComm;  
 DCB     m_dcb;  
 COMMTIMEOUTS m_CommTimeouts;  
 bool    m_bPortReady;  
 bool    m_bWriteRC;  
 bool    m_bReadRC;  
 DWORD   m_iBytesWritten;  
 DWORD   m_iBytesRead;  
 DWORD   m_dwBytesRead; 

public:  
 void ClosePort();  
 bool ReadByte(BYTE &resp);  
 bool ReadByte(BYTE* &resp, UINT size);  
 bool WriteByte(BYTE bybyte);  
 bool OpenPort(CString portname);  
 bool SetCommunicationTimeouts(DWORD ReadIntervalTimeout,  
  DWORD ReadTotalTimeoutMultiplier, DWORD ReadTotalTimeoutConstant,  
  DWORD WriteTotalTimeoutMultiplier,DWORD WriteTotalTimeoutConstant);  
 bool ConfigurePort(DWORD BaudRate, BYTE ByteSize, DWORD fParity,   
  BYTE  Parity,BYTE StopBits);  
};

 #include "serialport.h"
CSerialPort::CSerialPort()  
{  
} 

CSerialPort::~CSerialPort()  
{  
} 

bool CSerialPort::OpenPort(CString portname)  
{  
 m_hComm = CreateFile(L"//./" + portname,  
  GENERIC_READ | GENERIC_WRITE,  
  0,  
  0,  
  OPEN_EXISTING,  
  0,  
  0);  
 if(m_hComm == INVALID_HANDLE_VALUE)  
 {  
  return false;  
 }  
 else  
  return true;  
} 

bool CSerialPort::ConfigurePort(DWORD BaudRate, BYTE ByteSize, DWORD fParity,   
 BYTE Parity, BYTE StopBits)  
{  
 if((m_bPortReady = GetCommState(m_hComm, &m_dcb))==0)  
 {  
  printf("\nGetCommState Error\n");
  //"MessageBox(L, L"Error", MB_OK + MB_ICONERROR);  
  CloseHandle(m_hComm);  
  return false;  
 } 

 m_dcb.BaudRate          = BaudRate;  
 m_dcb.ByteSize          = ByteSize;  
 m_dcb.Parity            = Parity ;  
 m_dcb.StopBits          = StopBits;  
 m_dcb.fBinary           = true;  
 m_dcb.fDsrSensitivity   = false;  
 m_dcb.fParity           = fParity;  
 m_dcb.fOutX             = false;  
 m_dcb.fInX              = false;  
 m_dcb.fNull             = false;  
 m_dcb.fAbortOnError     = true;  
 m_dcb.fOutxCtsFlow      = false;  
 m_dcb.fOutxDsrFlow      = false;  
 m_dcb.fDtrControl       = DTR_CONTROL_DISABLE;  
 m_dcb.fDsrSensitivity   = false;  
 m_dcb.fRtsControl       = RTS_CONTROL_DISABLE;  
 m_dcb.fOutxCtsFlow      = false;  
 m_dcb.fOutxCtsFlow      = false; 

 m_bPortReady = SetCommState(m_hComm, &m_dcb); 

 if(m_bPortReady == 0)  
 {  
  //MessageBox(L"SetCommState Error");  
  printf("SetCommState Error");
  CloseHandle(m_hComm);  
  return false;  
 } 

 return true;  
} 

bool CSerialPort::SetCommunicationTimeouts(DWORD ReadIntervalTimeout,  
 DWORD ReadTotalTimeoutMultiplier, DWORD ReadTotalTimeoutConstant,  
 DWORD WriteTotalTimeoutMultiplier, DWORD WriteTotalTimeoutConstant)  
{  
 if((m_bPortReady = GetCommTimeouts(m_hComm, &m_CommTimeouts)) == 0)  
  return false; 

 m_CommTimeouts.ReadIntervalTimeout          = ReadIntervalTimeout;  
 m_CommTimeouts.ReadTotalTimeoutConstant     = ReadTotalTimeoutConstant;  
 m_CommTimeouts.ReadTotalTimeoutMultiplier   = ReadTotalTimeoutMultiplier;  
 m_CommTimeouts.WriteTotalTimeoutConstant    = WriteTotalTimeoutConstant;  
 m_CommTimeouts.WriteTotalTimeoutMultiplier  = WriteTotalTimeoutMultiplier; 

 m_bPortReady = SetCommTimeouts(m_hComm, &m_CommTimeouts); 

 if(m_bPortReady == 0)  
 {  
  //MessageBox(L"StCommTimeouts function failed",L"Com Port Error",MB_OK+MB_ICONERROR);  
  printf("\nStCommTimeouts function failed\n");
  CloseHandle(m_hComm);  
  return false;  
 } 

 return true;  
} 

bool CSerialPort::WriteByte(BYTE bybyte)  
{  
 //iBytesWritten=0;
 //m_iBytesWritten=0;  
 if(WriteFile(m_hComm, &bybyte, 1, &m_iBytesWritten, NULL) == 0)  
  return false;  
 else  
  return true;  
} 

bool CSerialPort::ReadByte(BYTE &resp)  
{  
 BYTE rx;  
 resp=0; 

 DWORD dwBytesTransferred=0; 

 if(ReadFile(m_hComm, &rx, 1, &dwBytesTransferred, 0))  
 {  
  if(dwBytesTransferred == 1)  
  {  
   resp=rx;  
   return true;  
  }  
 } 

 return false;  
} 

bool CSerialPort::ReadByte(BYTE* &resp, UINT size)  
{  
 DWORD dwBytesTransferred=0; 

 if(ReadFile(m_hComm, resp, size, &dwBytesTransferred, 0))  
 {  
  if(dwBytesTransferred == size)  
   return true;  
 } 

 return false;  
} 

void CSerialPort::ClosePort()  
{  
 CloseHandle(m_hComm);  
 return;  
} 

 #include "serialport.h"

#define RETURN_SUCCESS 1
#define RETURN_FAIL 0

class CSerialComm
{
public :
 CSerialComm();
 ~CSerialComm();

 CSerialPort  serial;
 int    connect(char* _portNum);
 int    sendCommand(unsigned char pos);
 void   disconnect();
};

 #include "serialcomm.h"

CSerialComm::CSerialComm(){}
CSerialComm::~CSerialComm(){}

int CSerialComm::connect(char* portNum)
{
 if(!serial.OpenPort("COM4"))
  return RETURN_FAIL;

 serial.ConfigurePort(CBR_115200, 8, FALSE, NOPARITY, ONESTOPBIT); 
 serial.SetCommunicationTimeouts(0, 0, 0, 0, 0);

 return RETURN_SUCCESS;
}

int CSerialComm::sendCommand(unsigned char pos)
{
 if(serial.WriteByte(pos))
  return RETURN_SUCCESS;
 else
  return RETURN_FAIL;
}

void CSerialComm::disconnect()
{
 serial.ClosePort();
}

 #include <stdio.h>
#include "serialcomm.h"

int main()
{
 CSerialComm serialComm;

 // STEP 1. SerialPort Connect
 if(!serialComm.connect("COM4"))
 {
  printf("connect faliled");
  return -1;
 }
 else
  printf("connect successed\n");

 // STEP 2. Send Command
 if(!serialComm.sendCommand('A'))
 { 
  printf("send command failed\n");
 }
 else
  printf("send Command success\n");

 // STEP 3. SerialPort disConnect
 serialComm.disconnect();

 printf("\nend connect\n");
  return 0;

}