coco
1040 lines
22 KiB
C++
1040 lines
22 KiB
C++
// SComPort.cpp: implementation of the CSComPort class.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include "SComPort.h"
|
|
|
|
#include "GeoMative.h"
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[]=__FILE__;
|
|
#define new DEBUG_NEW
|
|
#endif
|
|
|
|
OVERLAPPED rOverLaped = {0};
|
|
OVERLAPPED wOverLaped = {0};
|
|
|
|
OVERLAPPED rZModemOverLaped = {0};
|
|
|
|
extern CGeoMativeApp theApp;
|
|
extern SYSTEMTIME g_sysCurTime;
|
|
extern int g_iTransMode;
|
|
extern void TransDelay(int iTransMode, int iDS0, int iDS1, HWND hWnd = NULL);
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Construction/Destruction
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
CSComPort::CSComPort()
|
|
{
|
|
m_szComName = _T("");
|
|
|
|
// memset(&m_CriticalSection, 0 ,sizeof(CRITICAL_SECTION));
|
|
|
|
memset(&m_dcbBlock, 0, sizeof(DCB));
|
|
m_hCom = NULL;
|
|
|
|
memset(m_aWriteBuffer, 0, WRITEBUFFER_SIZE);
|
|
m_iWriteSize = 0;
|
|
|
|
memset(m_aReadBuffer, 0, READBUFFER_SIZE);
|
|
m_iReadSize = 0;
|
|
|
|
m_dwBLThreadID = 0;
|
|
m_hBLThread = NULL;
|
|
|
|
m_hOwnerWnd = NULL;
|
|
m_lCommID = 0;
|
|
|
|
m_bIsDetBreakFun = FALSE;
|
|
m_bIsScanBreak = TRUE;
|
|
|
|
m_dwFactdata = 0;
|
|
m_Log = fopen("log\\commLog.txt","ab+");
|
|
|
|
}
|
|
|
|
|
|
CSComPort::CSComPort(HWND hOwnerWnd, long lCommID)
|
|
{
|
|
m_szComName = _T("");
|
|
|
|
memset(&m_dcbBlock, 0, sizeof(DCB));
|
|
m_hCom = NULL;
|
|
|
|
memset(m_aWriteBuffer, 0, WRITEBUFFER_SIZE);
|
|
m_iWriteSize = 0;
|
|
|
|
memset(m_aReadBuffer, 0, READBUFFER_SIZE);
|
|
m_iReadSize = 0;
|
|
|
|
m_dwBLThreadID = 0;
|
|
m_hBLThread = NULL;
|
|
|
|
m_hOwnerWnd = hOwnerWnd;
|
|
m_lCommID = lCommID;
|
|
|
|
m_bIsScanBreak = TRUE;
|
|
|
|
m_dwFactdata = 0;
|
|
m_Log = fopen("log\\commLog.txt","ab+");
|
|
|
|
}
|
|
|
|
CSComPort::~CSComPort()
|
|
{
|
|
fclose(m_Log);
|
|
CloseComm();
|
|
}
|
|
|
|
BOOL CSComPort::FindComName(CStringArray *pStringArray)
|
|
{
|
|
HKEY hKey = NULL;
|
|
long lRes = 0;
|
|
char aPortName[256] = {0};
|
|
char aComName[256] = {0};
|
|
DWORD dwIndex = 0;
|
|
DWORD dwSize = 0;
|
|
DWORD dwType = REG_SZ;
|
|
|
|
if (NULL != pStringArray)
|
|
{
|
|
pStringArray->RemoveAll();
|
|
|
|
lRes = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("Hardware\\DeviceMap\\SerialComm"), NULL, KEY_READ, &hKey);
|
|
if ( ERROR_SUCCESS == lRes )
|
|
{
|
|
dwSize = sizeof(aPortName);
|
|
|
|
while (::RegEnumValue(hKey, dwIndex, aPortName, &dwSize, NULL, &dwType, (LPBYTE)aComName, &dwSize) == ERROR_MORE_DATA)
|
|
{
|
|
pStringArray->Add(aComName);
|
|
|
|
dwSize = sizeof(aPortName);
|
|
dwIndex++;
|
|
}
|
|
::RegCloseKey(hKey);
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL CSComPort::OpenComm(CString szComName)
|
|
{
|
|
unsigned long uParam = 0;
|
|
|
|
if (NULL == m_hCom)
|
|
{
|
|
m_szComName = _T("");
|
|
|
|
memset(&m_dcbBlock, 0, sizeof(DCB));
|
|
m_hCom = NULL;
|
|
|
|
memset(m_aWriteBuffer, 0, WRITEBUFFER_SIZE);
|
|
m_iWriteSize = 0;
|
|
|
|
memset(m_aReadBuffer, 0, READBUFFER_SIZE);
|
|
m_iReadSize = 0;
|
|
|
|
m_bIsDetBreakFun = FALSE;
|
|
|
|
if (4 == szComName.GetLength())
|
|
{
|
|
m_szComName = szComName;
|
|
}
|
|
else if (szComName.GetLength() > 4)
|
|
{
|
|
m_szComName = _T("\\\\.\\") + szComName;
|
|
}
|
|
|
|
|
|
this->m_hCom = CreateFile(m_szComName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
|
|
|
|
if (INVALID_HANDLE_VALUE == this->m_hCom)
|
|
{
|
|
DWORD dwError = GetLastError();
|
|
CloseHandle(m_hCom);
|
|
m_hCom = NULL;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
SetupComm(this->m_hCom, READBUFFER_SIZE, WRITEBUFFER_SIZE);
|
|
|
|
memset(&m_dcbBlock, 0, sizeof(DCB));
|
|
GetCommState(this->m_hCom, &m_dcbBlock);
|
|
|
|
m_dcbBlock.BaudRate = CBR_115200;
|
|
m_dcbBlock.fBinary = TRUE;
|
|
m_dcbBlock.fParity = FALSE;
|
|
m_dcbBlock.ByteSize = 8;
|
|
m_dcbBlock.Parity = NOPARITY;
|
|
m_dcbBlock.StopBits = ONESTOPBIT;
|
|
|
|
if (!SetCommState(this->m_hCom, &m_dcbBlock))
|
|
{
|
|
CloseHandle(m_hCom);
|
|
m_hCom = NULL;
|
|
|
|
// AfxMessageBox(_T("Setup State is failed!"));
|
|
TRACE(_T("Setup State is failed!\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
if (!SetCommMask(this->m_hCom, EV_BREAK | EV_CTS | EV_DSR | EV_ERR | EV_RING | EV_RLSD | EV_RXCHAR | EV_RXFLAG | EV_TXEMPTY))
|
|
{
|
|
CloseHandle(m_hCom);
|
|
m_hCom = NULL;
|
|
// AfxMessageBox(_T("Setup mask is failed"));
|
|
TRACE(_T("Setup mask is failed\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
/*waston_0429
|
|
if (TRUE == m_bIsScanBreak)
|
|
{
|
|
// TRACE("OK1\n");
|
|
m_bIsDetBreakFun = FALSE;
|
|
m_dwBLThreadID = 0;
|
|
uParam = (unsigned long)this;
|
|
m_hBLThread = NULL;
|
|
m_hBLThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)SComPortDetectBreakThreadFun, (void *)uParam, 0, &m_dwBLThreadID);
|
|
if (INVALID_HANDLE_VALUE == m_hBLThread)
|
|
{
|
|
CloseHandle(m_hBLThread);
|
|
CloseHandle(m_hCom);
|
|
m_hCom = NULL;
|
|
|
|
// AfxMessageBox("To create thread fail!");
|
|
TRACE(_T("To create scan break line thread fail!"));
|
|
return FALSE;
|
|
}
|
|
CloseHandle(m_hBLThread);
|
|
// TRACE("OK2\n");
|
|
}
|
|
*/
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
UINT CSComPort::SComPortDetectBreakThreadFun(LPVOID pParam)
|
|
{
|
|
CSComPort* pSComPort = (CSComPort*)pParam;
|
|
|
|
HANDLE hCom = NULL;
|
|
DWORD dwError = 0;
|
|
|
|
while (!(pSComPort->m_bIsDetBreakFun))
|
|
{
|
|
hCom = NULL;
|
|
hCom = CreateFile(pSComPort->m_szComName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
|
|
|
|
if (INVALID_HANDLE_VALUE == hCom)
|
|
{
|
|
dwError = GetLastError();
|
|
if (ERROR_FILE_NOT_FOUND == dwError)
|
|
{
|
|
pSComPort->m_bIsDetBreakFun = TRUE;
|
|
pSComPort->CloseComm();
|
|
::SendMessage(pSComPort->m_hOwnerWnd, WM_BREAKLINE, 0, pSComPort->m_lCommID);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CloseHandle(hCom);
|
|
hCom = NULL;
|
|
}
|
|
Sleep(50);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CSComPort::SetOwnerWnd(HWND hOwnerWnd)
|
|
{
|
|
this->m_hOwnerWnd = hOwnerWnd;
|
|
}
|
|
|
|
void CSComPort::SetCommID(long lCommID)
|
|
{
|
|
m_lCommID = lCommID;
|
|
}
|
|
|
|
void CSComPort::CloseComm()
|
|
{
|
|
m_bIsDetBreakFun = TRUE;
|
|
Sleep(50);
|
|
|
|
memset(m_aWriteBuffer, 0, WRITEBUFFER_SIZE);
|
|
m_iWriteSize = 0;
|
|
|
|
memset(m_aReadBuffer, 0, READBUFFER_SIZE);
|
|
m_iReadSize = 0;
|
|
|
|
if (NULL != m_hCom)
|
|
{
|
|
PurgeComm(m_hCom, PURGE_TXCLEAR | PURGE_TXABORT | PURGE_RXCLEAR | PURGE_RXABORT);
|
|
CloseHandle(m_hCom);
|
|
m_hCom = NULL;
|
|
}
|
|
}
|
|
|
|
BOOL CSComPort::ReceiveDataDirectly(char *pDataBuff, int* iDataSize)
|
|
{
|
|
|
|
DWORD dwRes = 0;
|
|
DWORD dwCurReadSize = 0;
|
|
COMSTAT comStat = {0};
|
|
OVERLAPPED Overlapped = {0};
|
|
OVERLAPPED tOverLaped= {0};
|
|
char aReadBuffer[READBUFFER_SIZE] = {0};
|
|
DWORD dwReadSize = 0;
|
|
DWORD dwEvtMask ,dwResult,dwByteNumber;
|
|
|
|
if (NULL != m_hCom)
|
|
{
|
|
tOverLaped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
WaitCommEvent(m_hCom, &dwEvtMask, &tOverLaped);//将事件和串口的动态联系起来
|
|
dwResult = WaitForSingleObject(tOverLaped.hEvent, COMM_TIMEOUT);
|
|
|
|
if (WAIT_OBJECT_0 == dwResult)
|
|
{
|
|
dwByteNumber = 0;
|
|
if (GetOverlappedResult(m_hCom, &tOverLaped, &dwByteNumber, TRUE))
|
|
{
|
|
CloseHandle(tOverLaped.hEvent);
|
|
|
|
if (dwByteNumber > 0)
|
|
{
|
|
Overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
ClearCommError(m_hCom, &dwRes, &comStat);
|
|
|
|
if (0 == comStat.cbInQue)
|
|
{
|
|
CloseHandle(Overlapped.hEvent);
|
|
return TRUE;
|
|
}
|
|
|
|
memset(m_aReadBuffer, 0, READBUFFER_SIZE);
|
|
memset(aReadBuffer, 0, READBUFFER_SIZE);
|
|
m_iReadSize = 0;
|
|
|
|
if (comStat.cbInQue >= READBUFFER_SIZE)
|
|
{
|
|
dwReadSize = READBUFFER_SIZE;
|
|
}
|
|
else
|
|
{
|
|
dwReadSize = comStat.cbInQue;
|
|
}
|
|
|
|
if (!ReadFile(m_hCom, aReadBuffer, dwReadSize, &dwCurReadSize, &Overlapped))
|
|
{
|
|
if (ERROR_IO_PENDING == GetLastError())
|
|
{
|
|
dwRes = WaitForSingleObject(Overlapped.hEvent, COMM_TIMEOUT);
|
|
if ((WAIT_FAILED == dwRes) || (WAIT_TIMEOUT == dwRes))
|
|
{
|
|
CloseHandle(Overlapped.hEvent);
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
CloseHandle(Overlapped.hEvent);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// AfxMessageBox(pSComPort->m_aReadBuffer);
|
|
m_iReadSize = dwCurReadSize;
|
|
|
|
if (dwReadSize == dwCurReadSize)
|
|
{
|
|
memcpy(m_aReadBuffer, aReadBuffer, (UINT)dwCurReadSize);
|
|
memcpy(pDataBuff, m_aReadBuffer, (UINT)dwCurReadSize);
|
|
*iDataSize = m_iReadSize;
|
|
|
|
memset(m_aReadBuffer, 0, (UINT)dwCurReadSize);
|
|
m_iReadSize = 0;
|
|
|
|
CloseHandle(Overlapped.hEvent);
|
|
return TRUE;
|
|
}
|
|
|
|
CloseHandle(Overlapped.hEvent);
|
|
}
|
|
}
|
|
}
|
|
SetLastError(ERROR_TIMEOUT);
|
|
CloseHandle(tOverLaped.hEvent);
|
|
}
|
|
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL CSComPort::SendDataDirectly(char *pDataBuff, int iDataSize)
|
|
{
|
|
unsigned long uCurWriteSize = 0;
|
|
DWORD dwRes = 0;
|
|
OVERLAPPED Overlapped = {0};
|
|
|
|
if (NULL == m_hCom)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (NULL == pDataBuff)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
memset(&Overlapped, 0, sizeof(OVERLAPPED));
|
|
memset(m_aWriteBuffer, 0, WRITEBUFFER_SIZE);
|
|
|
|
m_iWriteSize = iDataSize;
|
|
memcpy(m_aWriteBuffer, pDataBuff, iDataSize);
|
|
|
|
Overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
|
|
if (!WriteFile(m_hCom, m_aWriteBuffer, m_iWriteSize, &uCurWriteSize, (LPOVERLAPPED)&Overlapped))
|
|
{
|
|
dwRes = WaitForSingleObject(Overlapped.hEvent, 500);
|
|
|
|
CloseHandle(Overlapped.hEvent);
|
|
|
|
if (WAIT_OBJECT_0 != dwRes)
|
|
{
|
|
// PurgeComm(m_hCom, PURGE_TXCLEAR);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void CSComPort::SetScanBreakSign(BOOL bIsScanBreak)
|
|
{
|
|
m_bIsScanBreak = bIsScanBreak;
|
|
}
|
|
|
|
|
|
void CSComPort::ClearCommSendBuff()
|
|
{
|
|
PurgeComm(m_hCom, PURGE_TXCLEAR | PURGE_TXABORT);
|
|
memset(m_aWriteBuffer, 0, WRITEBUFFER_SIZE);
|
|
}
|
|
|
|
void CSComPort::ClearCommReceiveBuff()
|
|
{
|
|
PurgeComm(m_hCom, PURGE_RXCLEAR | PURGE_RXABORT);
|
|
memset(m_aReadBuffer, 0, READBUFFER_SIZE);
|
|
}
|
|
|
|
/*
|
|
BOOL CSComPort::ZmodemReceiveDataDirectly(char *pDataBuff, int *iDataSize)
|
|
{
|
|
|
|
#define READBUFFER_SIZE 8192
|
|
DWORD m_iReadSize = 0;
|
|
// char m_aReadBuffer[READBUFFER_SIZE];
|
|
|
|
DWORD dwRes = 0;
|
|
DWORD dwCurReadSize = 0;
|
|
COMSTAT comStat = {0};
|
|
OVERLAPPED Overlapped = {0};
|
|
OVERLAPPED tOverLaped= {0};
|
|
char aReadBuffer[READBUFFER_SIZE] = {0};
|
|
DWORD dwReadSize = 0;
|
|
DWORD dwEvtMask ,dwResult,dwByteNumber;
|
|
|
|
|
|
if (NULL != m_hCom)
|
|
{
|
|
tOverLaped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
WaitCommEvent(m_hCom, &dwEvtMask, &tOverLaped);//将事件和串口的动态联系起来
|
|
dwResult = WaitForSingleObject(tOverLaped.hEvent, 200);
|
|
|
|
if (WAIT_OBJECT_0 == dwResult)
|
|
{
|
|
dwByteNumber = 0;
|
|
if (GetOverlappedResult(m_hCom, &tOverLaped, &dwByteNumber, TRUE))
|
|
{
|
|
if (dwByteNumber > 0)
|
|
{
|
|
Overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
|
|
ClearCommError(m_hCom, &dwRes, &comStat);
|
|
|
|
if (0 == comStat.cbInQue)
|
|
{
|
|
CloseHandle(Overlapped.hEvent);
|
|
return TRUE;
|
|
}
|
|
|
|
memset(aReadBuffer, 0, READBUFFER_SIZE);
|
|
m_iReadSize = 0;
|
|
|
|
if (comStat.cbInQue >= READBUFFER_SIZE)
|
|
{
|
|
dwReadSize = READBUFFER_SIZE;
|
|
}
|
|
else
|
|
{
|
|
dwReadSize = comStat.cbInQue;
|
|
}
|
|
|
|
if (!ReadFile(m_hCom, aReadBuffer, dwReadSize, &dwCurReadSize, &Overlapped))
|
|
{
|
|
if (ERROR_IO_PENDING == GetLastError())
|
|
{
|
|
dwRes = WaitForSingleObject(Overlapped.hEvent, 200);
|
|
PurgeComm(m_hCom, PURGE_RXCLEAR);
|
|
|
|
if (WAIT_FAILED == dwRes)
|
|
{
|
|
CloseHandle(Overlapped.hEvent);
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CloseHandle(Overlapped.hEvent);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// AfxMessageBox(pSComPort->m_aReadBuffer);
|
|
// PurgeComm(m_hCom, PURGE_RXCLEAR);
|
|
m_iReadSize = dwCurReadSize;
|
|
|
|
if (dwReadSize == dwCurReadSize)
|
|
{
|
|
memcpy(aReadBuffer, aReadBuffer, (UINT)dwCurReadSize);
|
|
memcpy(pDataBuff, aReadBuffer, (UINT)dwCurReadSize);
|
|
*iDataSize = m_iReadSize;
|
|
|
|
memset(aReadBuffer, 0, (UINT)dwCurReadSize);
|
|
m_iReadSize = 0;
|
|
|
|
CloseHandle(Overlapped.hEvent);
|
|
return TRUE;
|
|
}
|
|
|
|
CloseHandle(Overlapped.hEvent);
|
|
|
|
}
|
|
|
|
}
|
|
CloseHandle(tOverLaped.hEvent);
|
|
}
|
|
|
|
|
|
}
|
|
return FALSE;
|
|
}
|
|
*/
|
|
|
|
/*
|
|
BOOL CSComPort::ZmodemSendDataDirectly(char *pDataBuff, int iDataSize)
|
|
{
|
|
if(WriteFile(m_hCom, pDataBuff, iDataSize, &m_dwFactdata, &wOverLaped) == TRUE)
|
|
{
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
*/
|
|
|
|
|
|
BOOL CSComPort::ZmodemSendDataDirectly(char *pDataBuff, int iDataSize)
|
|
{
|
|
OVERLAPPED wZModemOverLaped = {0};
|
|
|
|
char cReadLog[2048];
|
|
memset(cReadLog, 0, 2048);
|
|
DWORD factdata;
|
|
factdata = 0;
|
|
DWORD res;
|
|
wZModemOverLaped.hEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
|
|
|
|
PurgeComm(m_hCom, PURGE_TXCLEAR);
|
|
|
|
if (WriteFile(m_hCom, pDataBuff, iDataSize, &factdata, &wZModemOverLaped))
|
|
{
|
|
// PurgeComm(m_hCom, PURGE_TXCLEAR);
|
|
CloseHandle(wZModemOverLaped.hEvent);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
if (GetLastError() == ERROR_IO_PENDING)
|
|
{
|
|
int nTimeOut = 0;
|
|
BOOL bStop = TRUE;
|
|
while(bStop)
|
|
{
|
|
res = WaitForSingleObject(wZModemOverLaped.hEvent,100);
|
|
switch (res)
|
|
{
|
|
case WAIT_OBJECT_0:
|
|
GetOverlappedResult(m_hCom, &wZModemOverLaped, &factdata, TRUE);
|
|
bStop = FALSE;
|
|
break;
|
|
case WAIT_TIMEOUT :
|
|
if (nTimeOut++ == 5)
|
|
{
|
|
bStop = FALSE;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// PurgeComm(m_hCom, PURGE_TXCLEAR);
|
|
CloseHandle(wZModemOverLaped.hEvent);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CSComPort::ZmodemReceiveDataDirectly(char *pDataBuff, int *iDataSize)
|
|
{
|
|
COMSTAT rst;
|
|
DWORD res ;
|
|
DWORD factdata;
|
|
res = 0;
|
|
factdata = 0;
|
|
memset(&rst, 0, sizeof(rst));
|
|
|
|
// openLog();
|
|
|
|
CString szLog = _T("");
|
|
DWORD dwNeedRead = 100;
|
|
|
|
if (TRUE != ClearCommError(m_hCom,&res,&rst))
|
|
{
|
|
szLog.Format(_T("ClearCommError Error, errorno = %d, res = %d, InQue = %d"), GetLastError(), res, rst.cbInQue);
|
|
PrintLogLast(szLog);
|
|
}
|
|
else
|
|
dwNeedRead = rst.cbInQue;
|
|
|
|
|
|
rZModemOverLaped.hEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
|
|
|
|
// szLog.Format("begin--------------------------");
|
|
// PrintLogLast(szLog);
|
|
|
|
if (ReadFile(m_hCom, pDataBuff, dwNeedRead, &factdata, &rZModemOverLaped))
|
|
{
|
|
*iDataSize = factdata;
|
|
|
|
// if (0 == factdata)
|
|
// {
|
|
// //log
|
|
// szLog.Format("ReadFile = TRUE,rst.cbInQue = %d, factdata = %d",rst.cbInQue,factdata);
|
|
// PrintLogLast(szLog);
|
|
// //log
|
|
//
|
|
// }
|
|
|
|
|
|
PurgeComm(m_hCom, PURGE_RXCLEAR);
|
|
CloseHandle(rZModemOverLaped.hEvent);
|
|
|
|
// szLog.Format("end-----------------------------\r\n");
|
|
// PrintLogLast(szLog);
|
|
// closeLog();
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
DWORD dwError = GetLastError();
|
|
if (dwError == ERROR_IO_PENDING)
|
|
{
|
|
int nTimeOut = 0;
|
|
BOOL bStop = TRUE;
|
|
|
|
//log
|
|
szLog.Format("ReadFile = FALSE,GetLastError = ERROR_IO_PENDING");
|
|
PrintLogLast(szLog);
|
|
//log
|
|
|
|
while(bStop)
|
|
{
|
|
res = WaitForSingleObject(rZModemOverLaped.hEvent,100);
|
|
switch (res)
|
|
{
|
|
case WAIT_OBJECT_0:
|
|
if (GetOverlappedResult(m_hCom, &rZModemOverLaped, &factdata, TRUE))
|
|
{
|
|
*iDataSize = factdata;
|
|
bStop = FALSE;
|
|
|
|
//log
|
|
szLog.Format("WaitForSingleObject = WAIT_OBJECT_0,GetOverlappedResult = TRUE, factdata = %d",factdata);
|
|
PrintLogLast(szLog);
|
|
//log
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
//log
|
|
szLog.Format("WaitForSingleObject = WAIT_OBJECT_0,GetOverlappedResult = FALSE, factdata = %d",factdata);
|
|
PrintLogLast(szLog);
|
|
//log
|
|
break;
|
|
}
|
|
case WAIT_TIMEOUT :
|
|
if (nTimeOut++ == 5)
|
|
{
|
|
bStop = FALSE;
|
|
}
|
|
//log
|
|
szLog.Format("WaitForSingleObject = WAIT_TIMEOUT,nTimeOut = %d",nTimeOut);
|
|
PrintLogLast(szLog);
|
|
//log
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//log
|
|
TCHAR szBuf[128];
|
|
LPVOID lpMsgBuf;
|
|
FormatMessage(
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
|
|
NULL,
|
|
dwError,
|
|
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
|
(LPTSTR) &lpMsgBuf,
|
|
0, NULL );
|
|
wsprintf(szBuf,
|
|
_T("出错码:%d: %s"),
|
|
dwError, lpMsgBuf);
|
|
// AfxMessageBox(szBuf);
|
|
LocalFree(lpMsgBuf);
|
|
|
|
szLog.Format("ReadFile = FALSE,GetLastError = %d, desc: %s",GetLastError(),szBuf);
|
|
PrintLogLast(szLog);
|
|
//log
|
|
}
|
|
}
|
|
|
|
PurgeComm(m_hCom, PURGE_RXCLEAR);
|
|
CloseHandle(rZModemOverLaped.hEvent);
|
|
|
|
szLog.Format("end-----------------------------");
|
|
PrintLogLast(szLog);
|
|
|
|
// closeLog();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CSComPort::DetectLine()
|
|
{
|
|
unsigned long uParam = 0;
|
|
|
|
try
|
|
{
|
|
if (TRUE == m_bIsScanBreak)
|
|
{
|
|
// TRACE("OK1\n");
|
|
m_bIsDetBreakFun = FALSE;
|
|
m_dwBLThreadID = 0;
|
|
uParam = (unsigned long)this;
|
|
m_hBLThread = NULL;
|
|
m_hBLThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)SComPortDetectBreakThreadFun, (void *)uParam, 0, &m_dwBLThreadID);
|
|
if (INVALID_HANDLE_VALUE == m_hBLThread)
|
|
{
|
|
CloseHandle(m_hBLThread);
|
|
CloseHandle(m_hCom);
|
|
m_hCom = NULL;
|
|
|
|
// AfxMessageBox("To create thread fail!");
|
|
TRACE(_T("To create scan break line thread fail!"));
|
|
return FALSE;
|
|
}
|
|
CloseHandle(m_hBLThread);
|
|
// TRACE("OK2\n");
|
|
}
|
|
}
|
|
catch (...)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
void CSComPort::PrintLogLast(CString& strLog)
|
|
{
|
|
if (NULL == m_Log)
|
|
{
|
|
MessageBox(NULL, "can't write device_log, log File point is NULL", "LOG_ERROR", MB_OK);
|
|
return;
|
|
}
|
|
CString strOutPut = _T("");
|
|
strOutPut.Format(_T("%04d-%02d-%02d %02d:%02d:%02d.%03d %s \r\n"),g_sysCurTime.wYear, g_sysCurTime.wMonth, g_sysCurTime.wDay,
|
|
g_sysCurTime.wHour, g_sysCurTime.wMinute, g_sysCurTime.wSecond, g_sysCurTime.wMilliseconds, strLog.GetBuffer(0));
|
|
fwrite(strOutPut.GetBuffer(0), 1, strOutPut.GetLength(), m_Log);
|
|
fflush(m_Log);
|
|
}
|
|
|
|
void CSComPort::openLog()
|
|
{
|
|
m_Log = fopen("log\\commLog.txt","ab+");
|
|
}
|
|
|
|
void CSComPort::closeLog()
|
|
{
|
|
fclose(m_Log);
|
|
}
|
|
|
|
|
|
|
|
//执行传给设备的指令: strOrder: 传给设备的指令 strSign:收到的结果, pStrResult:希望等待到的字符串，nRepeatCnt:重发指令的次数
|
|
BOOL CSComPort::ExecuteOrder(CString strOrder, CString strSign, CString *pStrResult, int nRepeatCnt)
|
|
{
|
|
for (int i = 0; i < nRepeatCnt; i++)
|
|
{
|
|
if (ExecuteSignleOrder(strOrder, strSign, pStrResult))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//执行单次设备指令: f_szOrder: 传给设备的指令 f_szResult:收到的结果,f_szSign:希望等待到的字符串
|
|
BOOL CSComPort::ExecuteSignleOrder(CString f_szOrder, CString f_szSign, CString *f_szResult)
|
|
{
|
|
//log
|
|
CString szlog = _T("");
|
|
DWORD dwBegin = GetTickCount();
|
|
|
|
//log
|
|
CString szOrder = _T("");
|
|
CString szResBuff = _T("");
|
|
|
|
int iPollingTime = (int)VAL_ZERO;
|
|
int iResSize = (int)VAL_ZERO;
|
|
char aResBuff[2048] = {0};
|
|
|
|
TransDelay(g_iTransMode, 10, 50, NULL);
|
|
|
|
//清空串口缓冲区
|
|
ClearCommSendBuff();
|
|
ClearCommReceiveBuff();
|
|
|
|
//判断设备是否等待就绪
|
|
szOrder.Empty();
|
|
szResBuff.Empty();
|
|
iResSize = (int)VAL_ZERO;
|
|
iPollingTime = (int)VAL_ZERO;
|
|
memset(aResBuff, 0, sizeof(aResBuff));
|
|
|
|
szOrder.Format(_T("\r\n"));
|
|
SendDataDirectly(szOrder.GetBuffer(szOrder.GetLength()), szOrder.GetLength());
|
|
|
|
//log
|
|
szlog.Empty();
|
|
szlog.Format("[%d] send %s, cost_ticks = %d",__LINE__,szOrder.GetBuffer(0), GetTickCount() - dwBegin);
|
|
PrintLogLast(szlog);
|
|
//log
|
|
|
|
while ((szResBuff.Find(">") == -1) && (iPollingTime < 100))
|
|
{
|
|
Sleep(3);
|
|
while (ReceiveDataDirectly(aResBuff, &iResSize) == TRUE)
|
|
{
|
|
szResBuff.Insert(szResBuff.GetLength(), aResBuff);
|
|
|
|
iResSize = (int)VAL_ZERO;
|
|
memset(aResBuff, 0, sizeof(aResBuff));
|
|
}
|
|
|
|
iPollingTime++;
|
|
if (iPollingTime % 25 == 0)//设备没有响应,准备重发,每循环25次就重发
|
|
{
|
|
szOrder.Format(_T("\r\n"));
|
|
SendDataDirectly(szOrder.GetBuffer(szOrder.GetLength()), szOrder.GetLength());
|
|
}
|
|
}
|
|
|
|
//log
|
|
szlog.Empty();
|
|
szlog.Format("[%d] recv %s, cost_ticks = %d",__LINE__,szResBuff.GetBuffer(0), GetTickCount() - dwBegin);
|
|
PrintLogLast(szlog);
|
|
//log
|
|
|
|
|
|
//设备没有响应
|
|
if (iPollingTime == 100 )
|
|
{
|
|
szlog.Empty();
|
|
if (szResBuff.IsEmpty())
|
|
{
|
|
szlog.Format("[%d] recv start_respose_cmd timeout",__LINE__);
|
|
PrintLogLast(szlog);
|
|
}
|
|
else
|
|
{
|
|
szlog.Format("[%d] recv wrong cmd_responses signal, cmd = %s",__LINE__,szResBuff.GetBuffer(0));
|
|
PrintLogLast(szlog);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//设备准备局就绪,准备发送指令
|
|
ClearCommSendBuff();
|
|
ClearCommReceiveBuff();
|
|
|
|
//初始化值
|
|
szOrder.Empty();
|
|
szResBuff.Empty();
|
|
iResSize = (int)VAL_ZERO;
|
|
iPollingTime = (int)VAL_ZERO;
|
|
memset(aResBuff, 0, sizeof(aResBuff));
|
|
|
|
//发送指令
|
|
SendDataDirectly(f_szOrder.GetBuffer(f_szOrder.GetLength()), f_szOrder.GetLength());
|
|
|
|
//log
|
|
szlog.Empty();
|
|
szlog.Format("[%d] send %s, cost_ticks = %d",__LINE__,f_szOrder.GetBuffer(0), GetTickCount() - dwBegin);
|
|
PrintLogLast(szlog);
|
|
//log
|
|
|
|
while ((szResBuff.Find(f_szSign) == -1) && (iPollingTime < 100))
|
|
{
|
|
Sleep(3);
|
|
while (ReceiveDataDirectly(aResBuff, &iResSize) == TRUE)
|
|
{
|
|
szResBuff.Insert(szResBuff.GetLength(), aResBuff);
|
|
|
|
iResSize = (int)VAL_ZERO;
|
|
memset(aResBuff, 0, sizeof(aResBuff));
|
|
}
|
|
iPollingTime++;
|
|
}
|
|
|
|
|
|
|
|
if (iPollingTime == 100 )
|
|
{
|
|
//log
|
|
szlog.Empty();
|
|
szlog.Format("[%d] recv wrong cmd_responses_signal, cmd = %s",__LINE__,szResBuff.GetBuffer(0));
|
|
PrintLogLast(szlog);
|
|
//log
|
|
return FALSE;
|
|
}
|
|
f_szResult->Format("%s", szResBuff.GetBuffer(0));
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CSComPort::ExecuteNoResOrder(CString f_szOrder)
|
|
{
|
|
//log
|
|
CString szlog = _T("");
|
|
DWORD dwBegin = GetTickCount();
|
|
|
|
//log
|
|
CString szOrder = _T("");
|
|
CString szResBuff = _T("");
|
|
|
|
int iPollingTime = (int)VAL_ZERO;
|
|
int iResSize = (int)VAL_ZERO;
|
|
char aResBuff[2048] = {0};
|
|
|
|
TransDelay(g_iTransMode, 10, 50, NULL);
|
|
|
|
//清空串口缓冲区
|
|
ClearCommSendBuff();
|
|
ClearCommReceiveBuff();
|
|
|
|
//判断设备是否等待就绪
|
|
szOrder.Empty();
|
|
szResBuff.Empty();
|
|
iResSize = (int)VAL_ZERO;
|
|
iPollingTime = (int)VAL_ZERO;
|
|
memset(aResBuff, 0, sizeof(aResBuff));
|
|
|
|
szOrder.Format(_T("\r\n"));
|
|
SendDataDirectly(szOrder.GetBuffer(szOrder.GetLength()), szOrder.GetLength());
|
|
|
|
//log
|
|
szlog.Empty();
|
|
szlog.Format("[%d] send %s, cost_ticks = %d",__LINE__,szOrder.GetBuffer(0), GetTickCount() - dwBegin);
|
|
PrintLogLast(szlog);
|
|
//log
|
|
|
|
while ((szResBuff.Find(">") == -1) && (iPollingTime < 100))
|
|
{
|
|
Sleep(3);
|
|
while (ReceiveDataDirectly(aResBuff, &iResSize) == TRUE)
|
|
{
|
|
szResBuff.Insert(szResBuff.GetLength(), aResBuff);
|
|
|
|
iResSize = (int)VAL_ZERO;
|
|
memset(aResBuff, 0, sizeof(aResBuff));
|
|
}
|
|
|
|
iPollingTime++;
|
|
if (iPollingTime % 25 == 0)//设备没有响应,准备重发,每循环25次就重发
|
|
{
|
|
szOrder.Format(_T("\r\n"));
|
|
SendDataDirectly(szOrder.GetBuffer(szOrder.GetLength()), szOrder.GetLength());
|
|
}
|
|
}
|
|
|
|
//log
|
|
szlog.Empty();
|
|
szlog.Format("[%d] recv %s, cost_ticks = %d",__LINE__,szResBuff.GetBuffer(0), GetTickCount() - dwBegin);
|
|
PrintLogLast(szlog);
|
|
//log
|
|
|
|
|
|
//设备没有响应
|
|
if (iPollingTime == 100 )
|
|
{
|
|
szlog.Empty();
|
|
if (szResBuff.IsEmpty())
|
|
{
|
|
szlog.Format("[%d] recv start_respose_cmd timeout",__LINE__);
|
|
PrintLogLast(szlog);
|
|
}
|
|
else
|
|
{
|
|
szlog.Format("[%d] recv wrong cmd_responses signal, cmd = %s",__LINE__,szResBuff.GetBuffer(0));
|
|
PrintLogLast(szlog);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//设备准备局就绪,准备发送指令
|
|
ClearCommSendBuff();
|
|
ClearCommReceiveBuff();
|
|
|
|
//发送指令
|
|
SendDataDirectly(f_szOrder.GetBuffer(f_szOrder.GetLength()), f_szOrder.GetLength());
|
|
|
|
//log
|
|
szlog.Empty();
|
|
szlog.Format("[%d] send %s, cost_ticks = %d",__LINE__,f_szOrder.GetBuffer(0), GetTickCount() - dwBegin);
|
|
PrintLogLast(szlog);
|
|
|
|
return TRUE;
|
|
} |