串口通讯 接收不到

[漂白猪]

#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);	//通知发送
}

-------------------------------------------------
这个接收线程一直接收不到数据，为何？

[CathySun118]

有没有调试哪里有问题？

[Elysium]

是否在一个线程里访问变量或函数

[zhaoweidf]

下一个串口调试工具 二面的通信协议一样吗
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;
}

[漂白猪]

我把上面的代码改成单线程的，发送一下，接收一下，也能接收到。

我纳闷啊

[用户 昵称]

读的时候用线程，写的时候直接写。

[scq2099yt]

线程函数是否真的被调用了

[漂白猪]

读线程有问题，我重新写了一个单线程的读写，似乎没问题，然后把代码复制进去，好像程序就好了，我也不知道为什么，我用比较工具比较代码，看不出问题

顺便说那个协议上是对不上，超时应该是3.5个字节的传输时间，我设置的不对，好像出了问题。