串口通讯 接收不到

Question

#define RECV_BUFF_SZIE 1024
#define SEND_BUFF_SZIE 256
#define RECV_TIME_OUT 2000
#define SEND_TIME_OUT 1000//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////CComMng::CComMng()
{
m_pOwner = NULL;
m_hCom = NULL;
m_hWrite = NULL;
m_hRead = NULL;
m_dwWriteID = NULL;
m_dwReadID = NULL;
m_nWriteExitTimeOut = 2000; //写线程退出超时时间
m_nReadExitTimeOut = 2000; //读线程退出超时时间
InitializeCriticalSection(&m_cs);
m_hSendEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
m_hRecvEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
}CComMng::~CComMng()
{
Release();
DeleteCriticalSection(&m_cs);
CloseHandle(m_hSendEvent);
CloseHandle(m_hRecvEvent);
}UINT CComMng::Initial(RecvBuff *recv, void *pOwner, UINT nPort, UINT nBaudRate, BYTE nByteSize, UINT nStopBits, BYTE nParity)
{
m_pOwner = pOwner;
UINT nRes = OpenCom(nPort); //打开端口
if (ERR_OK != nRes)
{
return nRes;
} m_pRecvBuff = recv; //启动I/O线程
m_hWrite = CreateThread(NULL, NULL, WriteProc, this, NULL, &m_dwWriteID);
m_hRead = CreateThread(NULL, NULL, ReadProc, this, NULL, &m_dwReadID);
m_bEndWriteThread = FALSE;
m_bEndReadThread = FALSE;
return ERR_OK;
}UINT CComMng::Release()
{
m_bEndWriteThread = TRUE;
m_bEndReadThread = TRUE; //等待写线程退出，如果超时，则强制结束
UINT nRes =WaitForSingleObject(m_hWrite, m_nWriteExitTimeOut);
if (nRes == WAIT_TIMEOUT)
{
TerminateThread(m_hWrite, 0x02);
}
m_dwWriteID = NULL;
CloseHandle(m_hWrite); //等待读线程退出，如果超时，则强制结束
nRes =WaitForSingleObject(m_hRead, m_nReadExitTimeOut);
if (nRes == WAIT_TIMEOUT)
{
TerminateThread(m_hRead, 0x02);
}
m_dwReadID = NULL;
CloseHandle(m_hRead); CloseCom();
return ERR_OK;
}UINT CComMng::OpenCom(UINT nCom)
{
char szText[MAX_PATH] = {0};
sprintf(szText, "COM%d", nCom);
m_hCom=CreateFile(szText, 
GENERIC_READ|GENERIC_WRITE, 
0, 
NULL, 
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
NULL);

if (m_hCom == INVALID_HANDLE_VALUE)
{
return ERR_OPEN_FILE;
} //设置超时参数
COMMTIMEOUTS CommTimeOuts;
GetCommTimeouts(m_hCom, &CommTimeOuts); //设定读超时
CommTimeOuts.ReadIntervalTimeout = 5; /* 接收字符间最大时间间隔 */
CommTimeOuts.ReadTotalTimeoutMultiplier = 200;
CommTimeOuts.ReadTotalTimeoutConstant = 5000; /* 读数据总超时常量 */ //设定写超时
CommTimeOuts.WriteTotalTimeoutMultiplier = 500;
CommTimeOuts.WriteTotalTimeoutConstant = 2000;
if(!SetCommTimeouts(m_hCom, &CommTimeOuts))
{
CloseCom();
return ERR_SET_STATE;
} SetState();

SetupComm(m_hCom, 1024, 1024); //输入缓冲区和输出缓冲区的大小都是1024

PurgeComm(m_hCom, PURGE_TXCLEAR | PURGE_RXCLEAR);  /* 清除收/发缓冲区 */ return ERR_OK;
}void CComMng::CloseCom()
{
CloseHandle(m_hCom);
m_hCom = INVALID_HANDLE_VALUE;
}UINT CComMng::SetState(UINT nBaudRate, BYTE nByteSize, UINT nStopBits, BYTE nParity)
{
DCB dcb;
GetCommState(m_hCom, &dcb);
dcb.BaudRate = nBaudRate;//波特率
dcb.ByteSize = nByteSize;
dcb.StopBits= nStopBits;
dcb.Parity = nParity; /*MARKPARITY， SPACEPARITY;*/
dcb.fParity = FALSE; /* 禁止奇偶校验 */
dcb.fBinary = TRUE;
dcb.fDtrControl = DTR_CONTROL_DISABLE; /* 禁止流量控制 */
dcb.fRtsControl = RTS_CONTROL_DISABLE;
dcb.fOutX = 0;
dcb.fInX = 0;
dcb.fTXContinueOnXoff = 0; BOOL bHr = SetCommState(m_hCom, &dcb);//设置状态正确?
if (!bHr)
{
//出错了
CloseCom();
return ERR_SET_STATE;
}
return ERR_OK;
}
//---------------------------------------------------------
// 函数作者 : Stifler
// 创建日期 : 2008-6-9
// 版本 : V1.0
//*********************************************************
// 函数名称 : CComMng::WriteProc 
// 功能描述 : com的发送线程体
// 返回类型 : DWORD 
// 注释 : 
// 参数类型     : LPVOID pParam
// 注释 : 
//---------------------------------------------------------
DWORD CComMng::WriteProc (LPVOID pParam)
{
CComMng *pThis = (CComMng *)pParam;
UINT nFailure = 0; //累计发送失败的次数
while (true)
{
if(!pThis->m_hCom)
{
return ERR_OPEN_FILE;
} if(nFailure > 2) //3次失败，认为已经断线
{
return ERR_DISCONNECTED;
} WaitForSingleObject(pThis->m_hSendEvent, INFINITE); if(pThis->m_bEndWriteThread)
{
break;
}

LOCK(pThis->m_cs);
BYTE *pBuff = new BYTE[SEND_BUFF_SZIE];
memset(pBuff, 0, SEND_BUFF_SZIE);
pThis->m_buff.ReadBuff(pBuff, 1); //获取缓冲区中第一个字节，协议中规定第一字节为长度
BYTE nCmdLen = *pBuff; //缓冲区内存在一个完整的命令
if (pThis->m_buff.GetSize() >= nCmdLen)
{
pThis->m_buff.GetBuff(pBuff, nCmdLen); //获取命令
DWORD nSuccLen = 0;
OVERLAPPED oWrite;
memset(&oWrite, 0, sizeof(oWrite));
oWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
WriteFile(pThis->m_hCom, pBuff, nCmdLen, &nSuccLen, &oWrite); UINT nRes = WaitForSingleObject(oWrite.hEvent, SEND_TIME_OUT);
if (nRes == WAIT_TIMEOUT) //如果超时，丢弃这一个命令，失败计数加1
{
delete []pBuff;
pBuff = NULL;
nFailure++;
continue;
}
nFailure = 0; //发送成功失败计数清零
}
else
{
ResetEvent(pThis->m_hSendEvent);
}

delete []pBuff;
pBuff = NULL;
}
return ERR_OK;
}
//---------------------------------------------------------
// 函数作者 : Stifler
// 创建日期 : 2008-6-9
// 版本 : V1.0
//*********************************************************
// 函数名称 : CComMng::ReadProc 
// 功能描述 : 读取com的线程体
// 返回类型 : DWORD 
// 注释 :
// 参数类型     : LPVOID pParam
// 注释 : 
//---------------------------------------------------------
DWORD CComMng::ReadProc (LPVOID pParam)
{
UINT nFailure = 0; //累计读取失败的次数
CComMng *pThis = (CComMng *)pParam;
while(true)
{
WaitForSingleObject(pThis->m_hRecvEvent, 20); if (pThis->m_bEndReadThread)
{
break;
} BYTE buff[256] = {0};
DWORD dwRead = 0;
if(!pThis->m_hCom)
{
return ERR_OPEN_FILE;
}

OVERLAPPED osRead;
memset(&osRead, 0, sizeof(osRead));
osRead.hEvent=CreateEvent(NULL, TRUE, FALSE, NULL); //创建事件

//清除com错误
COMSTAT ComStat = {0};
DWORD dwErrorFlags;
ClearCommError(pThis->m_hCom, &dwErrorFlags, &ComStat); BOOL bReadStat = ReadFile(pThis->m_hCom, buff, RECV_BUFF_SZIE, &dwRead, &osRead); //在异步操作中，这里无法获取实际读取的字节数
if (GetLastError() == ERROR_IO_PENDING)
{
UINT nRes = WaitForSingleObject(osRead.hEvent, RECV_TIME_OUT);
if (WAIT_TIMEOUT == nRes) //等待超时
{
nFailure++;
}
else //接收数据完成
{
//调用回调函数，将数据发出去。
GetOverlappedResult(pThis->m_hCom, &osRead, &dwRead, FALSE); //获取实际操作的字节数
if( dwRead > 0)
{
pThis->m_pRecvBuff(buff, dwRead, pThis->m_pOwner);
nFailure = 0; //接收成功后，失败计数清零
}
}
}
else
{
GetOverlappedResult(pThis->m_hCom, &osRead, &dwRead, FALSE); //获取实际操作的字节数
if( dwRead > 0)
{
pThis->m_pRecvBuff(buff, dwRead, pThis->m_pOwner);
nFailure = 0; //接收成功后，失败计数清零
}
}
CloseHandle(osRead.hEvent);
}
return ERR_OK;
}void CComMng::PostCmd(BYTE *pBuff, UINT nSize)
{
LOCK(m_cs);
m_buff.AddBuff(pBuff, nSize);
SetEvent(m_hSendEvent); //通知发送
}
-------------------------------------------------
这个接收线程一直接收不到数据，为何？

Answer 1

下一个串口调试工具  二面的通信协议一样吗 
BOOL OpenComm(const char* pPort, int nBaudRate, int nParity, int nByteSize, int nStopBits)
{
DCB dcb; // 串口控制块
COMMTIMEOUTS timeouts = { // 串口超时控制参数
100, // 读字符间隔超时时间: 100 ms
1, // 读操作时每字符的时间: 1 ms (n个字符总共为n ms)
500, // 基本的(额外的)读超时时间: 500 ms
1, // 写操作时每字符的时间: 1 ms (n个字符总共为n ms)
100}; // 基本的(额外的)写超时时间: 100 ms hComm = CreateFile(pPort, // 串口名称或设备路径
GENERIC_READ | GENERIC_WRITE, // 读写方式
0, // 共享方式：独占
NULL, // 默认的安全描述符
OPEN_EXISTING, // 创建方式
0, // 不需设置文件属性
NULL); // 不需参照模板文件

if(hComm == INVALID_HANDLE_VALUE) return FALSE; // 打开串口失败 GetCommState(hComm, &dcb); // 取DCB dcb.BaudRate = nBaudRate;
dcb.ByteSize = nByteSize;
dcb.Parity = nParity;
dcb.StopBits = nStopBits; SetCommState(hComm, &dcb); // 设置DCB SetupComm(hComm, 4096, 1024); // 设置输入输出缓冲区大小 SetCommTimeouts(hComm, &timeouts); // 设置超时 return TRUE;
}