serialtestdlg.cpp

EVC下的串口测试工具

	DWORD dataSize;

	pBuff = (PBYTE)LocalAlloc(LPTR, buffSize);
	if(pBuff == NULL)
	{
		msg.Format(TEXT("ERROR : Fail to memory allocate.\r\n"));
		pDlg->LogMessage(&msg, TRUE);
		pDlg->ClosePort();
		return 0;
	}

	/* 贸府登瘤 臼篮 Read 葛滴 力芭. */
	PurgeComm(pDlg->m_hComm, PURGE_RXABORT | PURGE_RXCLEAR);
	pRead->SetReady();

	/* 览翠阑 焊郴扁 困秦 酒流 贸府登瘤 臼篮 write 檬扁拳 */
	if( (pDlg->m_fSync == TRUE) || (pDlg->m_fLoopBack == TRUE) )
	{
		( (CButton *)(pDlg->GetDlgItem(IDC_BTNSEND)) )->EnableWindow(FALSE);
		PurgeComm(pDlg->m_hComm, PURGE_TXABORT | PURGE_TXCLEAR);
		pWrite->SetReady();
	}
	((CButton *)pDlg->GetDlgItem(IDC_CHKSYNC))->EnableWindow(FALSE);
	((CButton *)pDlg->GetDlgItem(IDC_CHKLOOPBACK))->EnableWindow(FALSE);
	fReading = TRUE;
	while (fRead == TRUE)
	{
		for(unsigned int offset=0; offset<buffSize; offset++)
		{
			*(BYTE *)(pBuff + offset) = 0;
		}
		dwRead = 0;
		chkBuffer = FALSE;
		dataSize = 0;

		CString time;
		GetTimeText(&time);
		msg.Format(TEXT("Ready to Read - %s\r\n"), time);
		pDlg->LogMessage(&msg);

		do
			dwRead = pRead->QueueReader(pBuff + dwRead, BUFF_HEAD_SIZE, 5000);
		while((fRead == TRUE) && (dwRead < BUFF_HEAD_SIZE));
		if(fRead == FALSE)
			break;

		dataSize = (*(DWORD *)pBuff);
		totalRead += dwRead;

		msg.Format(TEXT("Get Data(Data Size : %d)!!\r\n"), dataSize);
		pDlg->LogMessage(&msg);

		if( dataSize > MAX_BUFF_SIZE )
		{
			DWORD tSize = pRead->QueueReader(pBuff, buffSize, 5000);
//			msg.Format(TEXT("ERROR : Data Size is Wrong\r\n"));
//			pDlg->LogMessage(&msg, TRUE);
			continue;
		}

		dwRead = pRead->QueueReader(pBuff+BUFF_HEAD_SIZE, dataSize-BUFF_HEAD_SIZE, 10000);
		totalRead += dwRead;

//		msg.Format(TEXT("%d byte read from Queue\r\n"), dwRead + BUFF_HEAD_SIZE);
//		pDlg->LogMessage(&msg);
	
		if( dwRead != (dataSize-BUFF_HEAD_SIZE) )
		{
			msg.Format(TEXT("ERROR : Test Data was Missed. - %d byte\r\n"),
				dataSize - dwRead - BUFF_HEAD_SIZE);
			pDlg->LogMessage(&msg, TRUE);
/* 叼滚弊 困秦 皋葛府 郴侩 颇老肺 免仿 */
//#ifdef _DEBUG
			CString fn;
			fn.Format(TEXT("MemoryOut%d.txt"), ecnt++);
			FILE *efile;
			efile = _wfopen(fn, TEXT("w"));
			fprintf(efile,"%d byte missed \r\n", dataSize - dwRead - BUFF_HEAD_SIZE);
			DumpMemory(pBuff, efile,dataSize,  26);
			fclose(efile);
//#endif
		}
		else if((chkBuffer = CheckBuffer(pBuff, dataSize)))
		{
			msg.Format(TEXT("Data is Complete\r\n"));
			pDlg->LogMessage(&msg);
		}
		else 
		{
			msg.Format(TEXT("Data is not Complete\r\n"));
			pDlg->LogMessage(&msg, TRUE);
		}

		msg.Format(TEXT("Total Read : %d byte\r\n"), totalRead);
		pDlg->LogMessage(&msg);

		if(pDlg->m_fSync == TRUE)
		{
			QNode buff;
			buff.data = (PBYTE)LocalAlloc(LPTR, 1);
			buff.size = 1;

			if(chkBuffer == TRUE)
				buff.data[0] = '0';
			else
				buff.data[0] = '1';

			if( pWrite->WaitForSpace(INFINITE) == WAIT_OBJECT_0)
				break;
			WaitForSingleObject(hWriteSem, INFINITE);
			pWrite->Push(&buff);
			ReleaseSemaphore(hWriteSem, 1, NULL);

			msg.Format(TEXT("%c replied\r\n"), buff.data[0]);
			pDlg->LogMessage(&msg);
		}
		if(pDlg->m_fLoopBack == TRUE)
		{
			QNode buff;
			buff.data = (PBYTE)LocalAlloc(LPTR, dwRead + BUFF_HEAD_SIZE);
			ByteCpy(pBuff, buff.data, dwRead + BUFF_HEAD_SIZE);
			buff.size = dwRead + BUFF_HEAD_SIZE;

			if( pWrite->WaitForSpace(INFINITE) == WAIT_OBJECT_0)
				break;
			WaitForSingleObject(hWriteSem, INFINITE);
			pWrite->Push(&buff);
			ReleaseSemaphore(hWriteSem, 1, NULL);

			msg.Format(TEXT("%d byte replied\r\n"), dwRead + BUFF_HEAD_SIZE);
			pDlg->LogMessage(&msg);
		}
	}
	fReading = FALSE;
	msg.Format(TEXT("Read Thread Terminating.\r\n"));
	pDlg->LogMessage(&msg);

	if( pDlg->m_fConnect == TRUE )
		( (CButton *)(pDlg->GetDlgItem(IDC_BTNSEND)) )->EnableWindow(TRUE);
	if(fWrite == FALSE)
	{
		( ((CButton *)pDlg->GetDlgItem(IDC_CHKSYNC)) )->EnableWindow(TRUE);
		( ((CButton *)pDlg->GetDlgItem(IDC_CHKLOOPBACK)) )->EnableWindow(TRUE);
	}

	if(pBuff != NULL)
		LocalFree(pBuff);

	return TRUE;
}

BOOL CSerialTestDlg::Writer(PBYTE pBuff, DWORD writeSize, DWORD *dwWritten)
{
	OVERLAPPED osWrite = {0};
	BOOL bOk = FALSE;
	CString msg;

	osWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	if (osWrite.hEvent == NULL)
		return FALSE;
	
//	msg.Format(TEXT("Writing Data...\r\n"));
//		LogMessage(&msg);

	if (!WriteFile(m_hComm, pBuff, writeSize, dwWritten, &osWrite)) 
	{
		/*
		 * wince 俊辑 GetOverlappedResult 荤侩 阂啊.
		 * winxp app俊辑  write 搬苞掘扁 困秦.
		 */
#ifdef UNDER_CE
		msg.Format(TEXT("Unkown Size Written\r\n"));
		LogMessage(&msg);
#else
		if (GetLastError() == ERROR_IO_PENDING) 
		{
			DWORD dwRes = WaitForSingleObject(osWrite.hEvent, INFINITE);

			switch(dwRes)
			{
			case WAIT_OBJECT_0:
				if (GetOverlappedResult(m_hComm, &osWrite, dwWritten, FALSE))
					bOk =  TRUE;
				break;

			default:
				bOk =  FALSE;
				break;
			}
		}
		else
			bOk = FALSE;
#endif
	}
	else
		bOk = TRUE;

	m_wSize += *dwWritten;
	UpdateData(FALSE);

	CloseHandle( osWrite.hEvent);
	return bOk;
}

BOOL CSerialTestDlg::Reader(PBYTE pBuff,DWORD readSize, DWORD *dwRead)
{
	OVERLAPPED osRead = {0};

	BOOL bOk = FALSE;
	CString msg;
	
	osRead.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	if (osRead.hEvent == NULL)
		return FALSE;

//	msg.Format(TEXT("Reading Data...\r\n"));
//	LogMessage(&msg);

	if ( !ReadFile(m_hComm, pBuff, readSize, dwRead, &osRead))
	{
#ifdef UNDER_CE
		msg.Format(TEXT("Unkown Size Read\r\n"));
		LogMessage(&msg);
#else
		if (GetLastError() == ERROR_IO_PENDING) 
		{
			DWORD dwRes = WaitForSingleObject(osRead.hEvent, INFINITE);

			switch(dwRes)
			{
			case WAIT_OBJECT_0:
				if (GetOverlappedResult(m_hComm, &osRead, dwRead, FALSE))
					bOk =  TRUE;
				break;

			default:
				bOk =  FALSE;
				break;
			}
		}
		else
			bOk = FALSE;
#endif
	}
	else 
		bOk = TRUE;

	m_rSize += *dwRead;
	UpdateData(FALSE);

	CloseHandle( osRead.hEvent);

	return bOk;
}

UINT WhatchThread(LPVOID lParam)
{
	CSerialTestDlg *pDlg = (CSerialTestDlg *)lParam;
	DWORD dwSize;
	DWORD dwEvent;
	CString msg;
	DWORD total = 0;
	DWORD dwError;
	COMSTAT comstat;

	PBYTE pBuff;
	pBuff = (PBYTE)LocalAlloc(LPTR, MAX_BUFF_SIZE);
	if(pBuff == NULL)
	{
		msg.Format(TEXT("ERROR : Fail to memory allocate.\r\n"));
		pDlg->LogMessage(&msg, TRUE);
		pDlg->ClosePort();
		return 0;
	}
	
	if(pWhatchWriteQ != NULL)
		pWhatchWriteQ->PostThreadMessage(WM_QUIT, 0,0);

	pWhatchWriteQ = AfxBeginThread(WhatchWriteQ, pDlg);

	while(pDlg->m_fConnect)
	{
		WaitCommEvent(pDlg->m_hComm, &dwEvent, NULL);

		if(( (dwEvent & EV_RXCHAR) == EV_RXCHAR )&&(fRead == TRUE))
		{

			ClearCommError(pDlg->m_hComm, &dwError, &comstat);
			if(comstat.cbInQue <= 0)
				continue ;
			if(dwError & CE_RXOVER)
			{
				msg.Format(TEXT("ERROR : Rx Over Occured.\r\n"));
				pDlg->LogMessage(&msg, TRUE);
			}

			WaitForSingleObject(hCommSem, INFINITE);
			if(pDlg->Reader(pBuff, comstat.cbInQue, &dwSize) == FALSE)
				continue;
			ReleaseSemaphore(hCommSem, 1, NULL);
			total += dwSize;
			pDlg->LogMessage(&msg);

			if( (dwSize > 0) && (fRead == TRUE) && (pDlg->m_fConnect == TRUE) )
			{
				QNode buff;
				buff.data = (PBYTE)LocalAlloc(LPTR, dwSize);
				ByteCpy(pBuff, buff.data, dwSize);
				buff.size = dwSize;

				//				pRead->WaitForSpace(INFINITE);
				if(pRead->IsFull())
				{
					msg.Format(TEXT("ERROR : Queue Overflow. Data can be Missed.\r\n"));
					pDlg->LogMessage(&msg, TRUE);
					pDlg->ClosePort();
					continue;
				}

				WaitForSingleObject(hReadSem, INFINITE);
				pRead->Push(&buff);
				ReleaseSemaphore(hReadSem, 1, NULL);
			}
			else
				continue;
		}
		
		if( (dwEvent & EV_TXEMPTY) == EV_TXEMPTY )
		{
			QNode buff;

			if(pWrite->IsEmpty())
			{
				if(pWhatchWriteQ == NULL)
					pWhatchWriteQ = AfxBeginThread(WhatchWriteQ, pDlg);
				continue;
			}

			if(pWrite->WaitForData(INFINITE) == WAIT_OBJECT_0)
			{
				break;
			}
			WaitForSingleObject(hWriteSem, INFINITE);
			pWrite->Pop(&buff);
			ReleaseSemaphore(hWriteSem, 1, NULL);

			WaitForSingleObject(hCommSem, INFINITE);
			pDlg->Writer(buff.data, buff.size, &dwSize);
			ReleaseSemaphore(hCommSem, 1, NULL);

			LocalFree(buff.data);
			if(buff.size != dwSize)
			{
				msg.Format(TEXT("ERROR : Send Data may be Missed.\r\n"));
				pDlg->LogMessage(&msg, TRUE);
			}
		}
	}

	LocalFree(pBuff);

	return 0;
}

UINT WhatchWriteQ(LPVOID lParam)
{
	CSerialTestDlg *pDlg = (CSerialTestDlg *)lParam;
	CString msg;
	DWORD dwWritten;
	QNode buff;
	
	if(pWrite->WaitForData(INFINITE) == WAIT_OBJECT_0+1)
	{
		WaitForSingleObject(hWriteSem, INFINITE);
		pWrite->Pop(&buff);
		ReleaseSemaphore(hWriteSem, 1, NULL);

		WaitForSingleObject(hCommSem, INFINITE);
		pDlg->Writer(buff.data, buff.size, &dwWritten);
		ReleaseSemaphore(hCommSem, 1, NULL);

		LocalFree(buff.data);
		if(buff.size != dwWritten)
		{
			msg.Format(TEXT("ERROR : Send Data may be Missed.\r\n"));
			pDlg->LogMessage(&msg, TRUE);
		}
	}
	pWhatchWriteQ = NULL;
	return 0;
}


BOOL ByteCpy(BYTE *source, BYTE *target, unsigned int size)
{
	for(unsigned int i=0; i<size; i++)
		target[i] = source[i];
	return TRUE;
}

BOOL CheckBuffer(PBYTE pBuff, DWORD buffSize)
{
	int start = pBuff[0] % 'A';
	for(unsigned int offset=BUFF_HEAD_SIZE; offset<buffSize-1; offset++)
	{
		if(*(BYTE *)(pBuff+offset) != (offset + start)%26 + 'A')
		{
#ifdef _DEBUG
			CString msg;
			msg.Format(TEXT("off-%d d-%d, \r\noff-%d d-%d, \r\noff-%d d-%d, \r\n"),
				(offset-1), *(BYTE *)(pBuff+offset-1),
				offset, *(BYTE *)(pBuff+offset), 
				(offset+1), *(BYTE *)(pBuff+offset+1));
			AfxMessageBox(msg);			
#endif
			return FALSE;
		}
	}

	return TRUE;
}


void CSerialTestDlg::OnBnClickedBtnread()
{
	// TODO: 咯扁俊 牧飘费 舅覆 贸府扁 内靛甫 眠啊钦聪促.
	CButton *pBtn = (CButton *)GetDlgItem(IDC_BTNREAD);

	fRead = !fRead;

	if(fRead == TRUE)
	{
		pBtn->SetWindowTextW(TEXT("READ OFF"));
		AfxBeginThread(ReadThread, this);
	}
	else
		pBtn->SetWindowTextW(TEXT("READ ON"));
}

BOOL GetTimeText(CString *msg)
{
	SYSTEMTIME sysTime;
	GetLocalTime(&sysTime);
	msg->Format(TEXT("%d.%d.%d %d:%d:%d.%d"),
		sysTime.wYear, sysTime.wMonth, sysTime.wDay, 
		sysTime.wHour, sysTime.wMinute, sysTime.wSecond, sysTime.wMilliseconds);
	return TRUE;
}

void DumpMemory(PBYTE pBuff, FILE *output, unsigned int dataSize, int delimcnt)
{
	unsigned int  i;
	for(i=0; i<dataSize; i++)
	{
		fprintf(output, "%c", *(BYTE *)(pBuff + i));
		
		if((i!= 0) && (((i+1)%delimcnt)%(delimcnt/3) == 0))
			fprintf(output, " ");
		if( (i!= 0) && (((i+1)%delimcnt) == 0) )
			fprintf(output, "\r\n");
		
	}
	fprintf(output, "\r\n\r\n-----------------------------------------------------------\r\n");
		CString msg;
		msg = "";

	for(i=0; i<dataSize; i++)
	{
		fprintf(output, "%2x ", *(BYTE *)(pBuff + i));
		
		if((i!= 0) && (((1+i)%delimcnt)%(delimcnt/3) == 0))
			fprintf(output, " ");
		if( (i!= 0) && (((1+i)%delimcnt) == 0) )
			fprintf(output, "\r\n");
	}
}

void CSerialTestDlg::OnEnChangeEdttime()
{
	m_RepeatTime = m_SpnTime.GetPos();
}

void CSerialTestDlg::OnEnChangeEdtterm()
{
	m_RepeatTerm = m_SpnTerm.GetPos();
}

void CSerialTestDlg::OnEnChangeEdtrepeat()
{
	m_RepeatCount = m_SpnCount.GetPos();
}