vc 串口通信代码

#include "StdAfx.h"
#include "comm.h"
#include "publib.h"
#include <process.h>

CommModule::CommModule()
{
m_hCOM = NULL;
m_bLog = FALSE;
m_hThread = NULL;
m_hStopEvt = NULL;
m_data_cb = NULL;
}

CommModule::~CommModule()
{

}

HANDLE CommModule::Init_Port(const char *port)
{
COMSTAT	comstat;
DWORD	errors;

CString s = CString(port);

m_flowCtrl = COMM_FC_HW;
m_baud = 115200;

//	20120131 by foil - open com port fail
int count = 1;
while (count <= 50)	//	try 50 times
{
m_hCOM = CreateFile(s,
GENERIC_READ|GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);

if(m_hCOM == INVALID_HANDLE_VALUE )
{
DebugOut(_T("try %d: Failed to open %s, err = %d\n"), count, (LPCTSTR)s, GetLastError());
Sleep(100);
count ++;
}
else
break;
}

if(m_hCOM == INVALID_HANDLE_VALUE )
{
//	if(m_bLog)
DebugOut(_T("eventually Failed to open %s, err = %d\n"), (LPCTSTR)s, GetLastError());
m_hCOM = NULL;
return NULL;
}
else
DebugOut(_T("Open %s succeeded!!!\n"), (LPCTSTR)s);

::ClearCommError(m_hCOM, &errors, &comstat);

//turn off fAbort first
DCB dcb;

if( GetCommState(m_hCOM, &dcb)==FALSE )
{
CloseHandle(m_hCOM);
m_hCOM = NULL;
return NULL;
}

dcb.DCBlength = sizeof(DCB);
dcb.Parity = NOPARITY;
dcb.ByteSize = 8;
dcb.StopBits = ONESTOPBIT;
dcb.BaudRate = m_baud;
dcb.fBinary = TRUE;
dcb.fParity = FALSE;

if(m_flowCtrl == COMM_FC_HW)
dcb.fOutxCtsFlow = TRUE;
else
dcb.fOutxCtsFlow = FALSE;

dcb.fOutxDsrFlow = FALSE;
dcb.fDtrControl = DTR_CONTROL_DISABLE;
dcb.fDsrSensitivity = FALSE;
dcb.fTXContinueOnXoff = FALSE;
dcb.fErrorChar = FALSE;
dcb.fNull = FALSE;
dcb.fAbortOnError = FALSE;

if(m_flowCtrl == COMM_FC_SW)
{
dcb.fOutX = TRUE;
dcb.fInX = TRUE;
}
else
{
dcb.fOutX = FALSE;
dcb.fInX = FALSE;
}

if(m_flowCtrl == COMM_FC_SW
|| m_flowCtrl == COMM_FC_NONE)
dcb.fRtsControl = RTS_CONTROL_ENABLE;
else if(m_flowCtrl == COMM_FC_HW)
dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;

if(m_flowCtrl == COMM_FC_SW)
{
dcb.XonChar = 0x11;
dcb.XoffChar = 0x13;
}
else
{
dcb.XonChar = 0;
dcb.XoffChar = 0;
}

dcb.ErrorChar = 0;
dcb.EofChar = 0;
dcb.EvtChar = 0;

::ClearCommError(m_hCOM, &errors, &comstat);

if( SetCommState(m_hCOM, &dcb)==FALSE )
{
CloseHandle(m_hCOM);
m_hCOM = NULL;
return NULL;
}

if( ::SetupComm(m_hCOM, 8192, 8192)==FALSE )
{
CloseHandle(m_hCOM);
m_hCOM = NULL;
return NULL;
}

if( ::PurgeComm(m_hCOM, PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR)==FALSE )
{
CloseHandle(m_hCOM);
m_hCOM = NULL;
return NULL;
}

// Communications Properties
COMMPROP cp;
if(GetCommProperties(m_hCOM, &cp) == FALSE)
{
CloseHandle(m_hCOM);
m_hCOM = NULL;
return NULL;
}

COMMTIMEOUTS timeouts;
timeouts.ReadIntervalTimeout = 0xFFFFFFFF;
timeouts.ReadTotalTimeoutMultiplier = 0;
timeouts.ReadTotalTimeoutConstant = 0;
timeouts.WriteTotalTimeoutMultiplier = 0;
timeouts.WriteTotalTimeoutConstant = 2000;
if( ::SetCommTimeouts(m_hCOM, &timeouts) == FALSE )
{
CloseHandle(m_hCOM);
m_hCOM = NULL;
return NULL;
}

m_hStopEvt = ::CreateEvent(NULL, TRUE, FALSE, NULL);
if(m_hStopEvt == NULL)
{
CloseHandle(m_hCOM);
m_hCOM = NULL;
return false;
}

if(StartThread() == false)
{
return NULL;
}

return m_hCOM;
}

// Wait for thread
void CommModule::WaitForExit()
{
if(m_hThread == NULL)
return;

WaitForSingleObject(m_hThread, INFINITE);
CloseHandle(m_hThread);
m_hThread = NULL;
}

void CommModule::StopThread()
{
if(m_hThread == NULL)
return ;

::SetEvent(m_hStopEvt);
WaitForExit();
}

bool CommModule::StartThread()
{
m_hThread = (HANDLE)_beginthreadex(
NULL, 0, (PBEGINTHREADEX_THREADFUNC)CommModule::HelpThreadFunc, (LPVOID)this, 0, NULL);

if( m_hThread )
return true;

return false;
}

DWORD CommModule::ThreadFunc()
{
COMSTAT	comstat;
DWORD	errors;

while(1)
{
//If dwMilliseconds is zero, the function tests the object's state and returns immediately
if( ::WaitForSingleObject(m_hStopEvt, 0)==WAIT_OBJECT_0 )
{
::ClearCommError(m_hCOM, &errors, &comstat);
break;
}

::ClearCommError(m_hCOM, &errors, &comstat);

if( !comstat.cbInQue )
{
Sleep(1); //dwMilliseconds
continue;
}

int dwBytesRead = (DWORD) comstat.cbInQue;
if( 512 <= (int) dwBytesRead )
dwBytesRead = 512;

if( ::ReadFile(m_hCOM, rawchars, dwBytesRead, &m_dwRead, NULL) )
{
if( m_dwRead==0 || m_data_cb==NULL)
continue;

m_iRead = m_dwRead;
rawchars[m_dwRead] = 0;

if(m_bLog)
DebugOutA("\r\n[rxd] %s\r\n", rawchars);
m_data_cb(0, (const char*)rawchars, m_iRead, m_pData);

}
}

return 0;
}

DWORD CommModule::HelpThreadFunc(LPVOID param)
{
CommModule *pto = (CommModule *)param;

return pto->ThreadFunc();

}

bool CommModule::WriteData(const char *Buf, const int size)
{
CString strDebug, strTemp;

int nRetryCount = 0;
int nSentBytes = 0;

while( nSentBytes < size )
{
int wbytes = 0;
int nPerSend = 0;

// reset write bytes
wbytes = 0;

// set send bytes
nPerSend = size - nSentBytes;

//	if (nPerSend%8 == 0)
//		nPerSend--;

// write to com
BOOL bWriteResult = WriteFile(m_hCOM, ((char*)Buf)+nSentBytes,
nPerSend, (unsigned long*)&wbytes, NULL);

// check result
if(!bWriteResult)
{
if(m_bLog)
DebugOutA("\r\n[error] WriteFile failed: %d\r\n", GetLastError());
// clear com error
::ClearCommError(m_hCOM, NULL, NULL);
}
else if( wbytes < nPerSend )
{
nSentBytes += wbytes;

if(m_bLog)
DebugOutA("\r\n[error] not write done. To write =%d, written = %d\r\n", nPerSend, wbytes);
}
else
{
// update the counts of sent bytes
nSentBytes += wbytes;
// reset retry count and continue to skip retry
nRetryCount = 0;
continue;
}

// check retry count
if( 3 <= nRetryCount )
{
if(m_bLog)
DebugOutA("\r\n[error] write failed: <%s>\r\n", Buf);
return false;
}

// increase retry count
nRetryCount++;

// receiver might be in busy status, sleep awhile
Sleep(100);
}
if(m_bLog)
DebugOutA("\r\n[txd] %s\r\n", Buf);
return true;
}

int CommModule::SetCallBack(DataNotify reply, void *pExt)
{
m_data_cb = reply;
m_pData = pExt;

return 1;
}

void CommModule::Deinit_Port()
{
StopThread();

if(m_hCOM!=NULL)
{
CloseHandle(m_hCOM);
m_hCOM = NULL;
}

if(m_hStopEvt!=NULL)
{
CloseHandle(m_hStopEvt);
m_hStopEvt = NULL;
}
}

void CommModule::EnableLog(BOOL bEnable)
{
m_bLog = bEnable;
}