monitor.cpp

本程序是2005年参加中国机器人大赛的比赛程序

// Monitor.cpp: implementation of the Monitor class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "Monitor.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

Monitor::Monitor()
{
	ctrl_dead = CreateEvent(NULL, TRUE, TRUE, NULL);
	ctrl_ready = CreateEvent(NULL, TRUE, FALSE, NULL);
	ctrl_thread = NULL;
	ctrl_end_signal = false;
	state = MS_Unready;
	memset(&overlap, 0, sizeof(OVERLAPPED));
	overlap.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	ctrl_thread = (HANDLE)AfxBeginThread((AFX_THREADPROC)MonitorProc,this,THREAD_PRIORITY_NORMAL,0 );
	playmode='s';
}

Monitor::~Monitor()
{
	ctrl_end_signal = true;
		
	if(ctrl_thread != NULL){
		SetEvent(ctrl_ready);
		WaitForSingleObject(ctrl_dead, 1000);
	}
		
	if (ctrl_thread != NULL){
		CloseHandle(ctrl_thread);
	}
	if(ctrl_dead != NULL){
		CloseHandle(ctrl_dead);
	}
	if(ctrl_ready != NULL){
		CloseHandle(ctrl_ready);
	}
	if(overlap.hEvent != NULL){
		CloseHandle(overlap.hEvent);
	}
	Close();

}

MonitorState Monitor::GetState()const {
	return state;
}
const char* Monitor::GetPortName() const
{return _portname;}

const char* Monitor::GetComName(int port)
{
	switch(port){
	case 1: return "COM1";
	case 2: return "COM2";
	default: return "Unknown";
	}
}
int Monitor::OpenCom(int Port)
{
	if(isopen && !strcmp(GetPortName(), GetComName(Port))){//如果要打开的串口已经打开
	//no change.
	return 0;
	}
	if(isopen){//打开的是别的串口
		ResetEvent(ctrl_ready);
		state = MS_Unready;
		//SetCommMask(rfcomobj.handle, 0);
		SetEvent(overlap.hEvent);
		Close();
	}

	if(!Open(GetComName(Port), true, true)){//打开串口
		return -1;
	}
		
	DCB dcb;
	memset(&dcb, 0, sizeof(DCB));
	dcb.DCBlength         = sizeof(dcb);
	dcb.BaudRate          = 9600;
	dcb.ByteSize          = 8;
	dcb.Parity            = NULL;//-- even parirty
	dcb.StopBits          = 0;
	dcb.EvtChar           = '\0';
	dcb.fDtrControl       = DTR_CONTROL_ENABLE;
	dcb.fRtsControl       = RTS_CONTROL_TOGGLE;	//-- enable
	dcb.fOutxCtsFlow      = FALSE;
	dcb.fOutxDsrFlow      = FALSE;
	dcb.fDsrSensitivity   = FALSE;
	dcb.fOutX             = FALSE;
	dcb.fInX              = FALSE;
	dcb.fTXContinueOnXoff = TRUE;
	dcb.fParity           = FALSE;
	
	if (!SetCommState(handle, &dcb)){
	
	Close();
	return -2;
	}
		
	COMMTIMEOUTS cto;
	memset(&cto, 0 , sizeof(COMMTIMEOUTS));
	cto.ReadIntervalTimeout = 0;		//in milliseconds
	cto.ReadTotalTimeoutConstant = 0;
	cto.ReadTotalTimeoutMultiplier = 0;		
	if (!SetCommTimeouts(handle, &cto))
	{
		AfxMessageBox("Error Setting Time Out");
	}
	
	//SetCommMask(rfcomobj.handle, EV_RXCHAR);
	ResetEvent(overlap.hEvent);
	SetEvent(ctrl_ready);
	state = MS_Runing;
	
	return 0;
}

bool Monitor::Open(const char* portname, bool pisread, bool isoverlapped)
{
	if(isopen){
		Close();
	}
	isread = pisread;
	strcpy(_portname, portname);
	handle = CreateFile(_portname,
		isread ? GENERIC_READ : GENERIC_WRITE,
		0,
		0,
		OPEN_EXISTING,
		isoverlapped ? FILE_FLAG_OVERLAPPED : FILE_ATTRIBUTE_NORMAL,
		0);
	isopen = bool(handle != INVALID_HANDLE_VALUE);
	if(!isopen){
		AfxMessageBox("Open Com Error");
	}
	return isopen;
}
	
void Monitor::Close()
{
	if(!isopen) return;
	
	BOOL rt;
	rt = CloseHandle(handle);
	isopen = false;
	if(!rt)
	{
		AfxMessageBox("close error");
	}
}

DWORD Monitor::SendPacket(const void* buf, DWORD buflen)
{
	
	DWORD dwWritten;		
	
	if(!EscapeCommFunction(handle,SETRTS)){
		AfxMessageBox("Error Setting RTS");
	}
	
	if(!WriteFile(handle, buf, buflen, &dwWritten, NULL))
	{
		AfxMessageBox("Error Sending Data");
	}
	
	if(!EscapeCommFunction(handle,CLRRTS)){
		AfxMessageBox("Error Clearing RTS");
	}
	return dwWritten;
}

void Monitor::ReceiveData(char c)
{
	FILE *pFile=fopen("received.txt","a+");
	if(c == ' ')
	{
		//m_pReadDlg->m_char=(BYTE)c;
		return;
	}
	fprintf(pFile,"%c",c);
	fclose(pFile);
	pm = GetPlayMode(c);
	playmode=c;
}

PlayMode Monitor::GetPlayMode(const char c)
{
	switch(c){
	case 's': return PM_Start;
	case 'S': return PM_Stop;
	case 'l': return PM_Begin_first_half;
	case 'h': return PM_Begin_half_time;
	case '2': return PM_Begin_second_half;
	case 'o': return PM_Begin_overtime;
	case 'a': return PM_Begin_penalty_shootout;
	case 'n': return PM_Neutral_restart;
	//ver1.0	case 'r': return PM_Neutral_restart;
	case 'k': return PM_Kick_off_Y;
	case 'K': return PM_Kick_off_B;
	case 'p': return PM_Penalty_Y;
	case 'P': return PM_Penalty_B;
	case 'f': return PM_Free_kick_Y;
	case 'F': return PM_Free_kick_B;
	case 't': return PM_Timeout_Y;
	case 'T': return PM_Timeout_B;
	case 'z': return PM_Timeout_end;
    case 'g': return PM_Goal_Y;
	case 'G': return PM_Goal_B;
	case 'i': return PM_Indirect_Kick_Y;
	case 'I': return PM_Indirect_Kick_B;
	case 'y': return PM_YellowCard_Y;
	case 'Y': return PM_YellowCard_B;
	case 'r': return PM_RedCard_Y;
	case 'R': return PM_RedCard_B;
	case 'c': return PM_Cancel;
	default : return PM_Unknown;
	}
}

int Monitor::GetPort() 
{
	if(!strcmp(GetPortName(), GetComName(1))){
		return 1;
	}else if(!strcmp(GetPortName(), GetComName(2))){
		return 2;
	}else{
		return -1;
	}
}

extern Monitor monitor;
unsigned int WINAPI MonitorProc(void* lpParameter)
{
	Monitor* pReferee = (Monitor*)lpParameter;
	ResetEvent(pReferee->ctrl_dead);//如果线程退出
	while(true)
	{
		WaitForSingleObject(pReferee->ctrl_ready, INFINITE);//串口打开以后ctrl_ready处于激活状态
		if(pReferee->ctrl_end_signal) break;
		DWORD received;
		char c;
		BOOL rt;
		DWORD dwError;
		rt = ReadFile(pReferee->handle, &c, sizeof(char), &received, &pReferee->overlap);
		if(!rt)
		{
			dwError = GetLastError();
			switch(dwError)
			{
			case ERROR_IO_PENDING:
				rt = GetOverlappedResult(pReferee->handle, &pReferee->overlap, &received, TRUE);
				if(rt)
				{
					pReferee->ReceiveData(c); 
				}
				else
				{
					//for example, reopen
					dwError = GetLastError();
				}
				break;
				default:				break;
			}
		}
		else
		{
			pReferee->ReceiveData(c); 
		}
	}
	SetEvent(pReferee->ctrl_dead);
	return 0;
}