tokenserial.cpp

自己写得串口多线程控制程序

// TokenSerial.cpp: implementation of the CTokenSerial class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "TokenSerial.h"

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

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

CTokenSerial::CTokenSerial()
{
	m_Event_TokenAck=CreateEvent(NULL, TRUE, FALSE, NULL);
	if(m_Event_TokenAck==INVALID_HANDLE_VALUE)
		return;

	m_Event_CardPoped=CreateEvent(NULL, TRUE, FALSE, NULL);
	if(m_Event_CardPoped==INVALID_HANDLE_VALUE)
		return;

	m_Event_Dealed=CreateEvent(NULL, TRUE, FALSE, NULL);
	if(m_Event_Dealed==INVALID_HANDLE_VALUE)
		return;

	m_Event_CardNum=CreateEvent(NULL, TRUE, FALSE, NULL);
	if(m_Event_CardNum==INVALID_HANDLE_VALUE)
		return;

	m_Event_ReadBoxNum=CreateEvent(NULL, TRUE, FALSE, NULL);
	if(m_Event_ReadBoxNum==INVALID_HANDLE_VALUE)
		return;
}

CTokenSerial::~CTokenSerial()
{
	TRACE("\nCTokenSerial destructure!");
	if(m_Event_TokenAck!=INVALID_HANDLE_VALUE&&m_Event_TokenAck!=0)
	{
		CloseHandle(m_Event_TokenAck);
		m_Event_TokenAck=0;
	}
	
	if(m_Event_CardPoped!=INVALID_HANDLE_VALUE&&m_Event_CardPoped!=0)
	{
		CloseHandle(m_Event_CardPoped);
		m_Event_CardPoped=0;
	}
	
	if(m_Event_Dealed!=INVALID_HANDLE_VALUE&&m_Event_Dealed!=0)
	{
		CloseHandle(m_Event_Dealed);
		m_Event_Dealed=0;
	}
	
	if(m_Event_CardNum!=INVALID_HANDLE_VALUE&&m_Event_CardNum!=0)
	{
		CloseHandle(m_Event_CardNum);
		m_Event_CardNum=0;
	}
	
	if(m_Event_ReadBoxNum!=INVALID_HANDLE_VALUE&&m_Event_ReadBoxNum!=0)
	{
		CloseHandle(m_Event_ReadBoxNum);
		m_Event_ReadBoxNum=0;
	}
}

void CTokenSerial::ResetHandle()
{
	ResetEvent(m_Event_TokenAck);
	ResetEvent(m_Event_CardPoped);
	ResetEvent(m_Event_Dealed);
	ResetEvent(m_Event_CardNum);
	ResetEvent(m_Event_ReadBoxNum);
}

BOOL CTokenSerial::CheckCard(UCHAR  CardId[5])
 {
 	//判断该卡号是不是合法
	if(CardId[4]==0x00)
	{
 		return TRUE;
	}
	else
	{
		return TRUE;
	}
}

UCHAR* CTokenSerial::FormBuff(UCHAR* sBuff, UCHAR sCommd, UCHAR* sData, int DataLen)
{
	UCHAR  CHK=0x00;
	sBuff[0]=0x55;
	sBuff[1]=DataLen+5;
	sBuff[2]=TERMI_ADDRESS;
	sBuff[3]=TOKEN_ADDRESS;
	sBuff[4]=sCommd;
	for(int i=0;i<DataLen;i++)
	{
		sBuff[5+i]=sData[i];
	}
	for(int j=1;j<=4+DataLen;j++)
		CHK=CHK^sBuff[j];
	sBuff[4+DataLen+1]=CHK;
	sBuff[4+DataLen+2]=0xaa;

	return sBuff;
}

BOOL CTokenSerial::ToTokenAck()
{
	UCHAR sCmd=TOKEN_RIGHT_ACK;
	UCHAR sBuff[MAXWRITEBUFFLEN]={0};
	UCHAR sData[MAXWRITEBUFFLEN]={0};
	int  sDataLen=0;
	FormBuff(sBuff, sCmd, sData, sDataLen);
	WriteData(sBuff , sDataLen+7,"ToTokenAck");
	return 1;
}

BOOL CTokenSerial::ToTokenReadBoxNum()
{
	UCHAR sCmd=TOKEN_READBOXNUM;
	UCHAR sBuff[MAXWRITEBUFFLEN]={0};
	UCHAR sData[MAXWRITEBUFFLEN]={0};
	int  sDataLen=0;
	FormBuff(sBuff, sCmd, sData, sDataLen);

	for(int i=0; i<MAXTOKENSENDTIMES; i++)
	{
		WriteData(sBuff , sDataLen+7,"ToTokenReadBoxNum");
		DWORD Ret=WaitForSingleObject(m_Event_ReadBoxNum, TOKENWAITTIME);
		if(Ret==WAIT_OBJECT_0)
		{
			ResetEvent(m_Event_ReadBoxNum);
			return 1;
		}
		else if(Ret==WAIT_TIMEOUT)
		{
			continue;
		}
		else
		{
			break;
		}
	}
	return 0;
}

BOOL CTokenSerial::ToTokenReset()
{
	UCHAR sCmd=TOKEN_RESET;
	UCHAR sBuff[MAXWRITEBUFFLEN]={0};
	UCHAR sData[MAXWRITEBUFFLEN]={0};
	int  sDataLen=0;
	FormBuff(sBuff, sCmd, sData, sDataLen);

	for(int i=0; i<MAXTOKENSENDTIMES; i++)
	{
		WriteData(sBuff , sDataLen+7,"ToTokenReset");
		DWORD Ret=WaitForSingleObject(m_Event_TokenAck, TOKENWAITTIME);
		if(Ret==WAIT_OBJECT_0)
		{
			ResetEvent(m_Event_TokenAck);
			return 1;
		}
		else if(Ret==WAIT_TIMEOUT)
		{
			continue;
		}
		else
		{
			ResetEvent(m_Event_TokenAck);
			break;
		}
	}
	return 0;
}

BOOL CTokenSerial::ToTokenPopCard(UCHAR CardNum, UCHAR CardValue) 
{
	// TODO: Add your control notification handler code here
	UCHAR sCmd=TOKEN_POP;
	UCHAR sBuff[MAXWRITEBUFFLEN]={0};
	UCHAR sData[MAXWRITEBUFFLEN]={0};
	int  sDataLen=2;
	sData[0]=CardNum;
	sData[1]=CardValue;
	FormBuff(sBuff, sCmd, sData, sDataLen);

	for(int i=0; i<MAXTOKENSENDTIMES; i++)
	{
		WriteData(sBuff , sDataLen+7,"ToTokenPopCard");
		DWORD Ret=WaitForSingleObject(m_Event_TokenAck, TOKENWAITTIME);
		if(Ret==WAIT_OBJECT_0)
		{
			ResetEvent(m_Event_TokenAck);
			return 1;
		}
		else if(Ret==WAIT_TIMEOUT)
		{
			continue;
		}
		else
		{
			ResetEvent(m_Event_TokenAck);
			break;
		}
	}
	return 0;
}

BOOL CTokenSerial::ToTokenCardStatus(BOOL IsGoodCard)
{
	UCHAR sCmd=TOKEN_GOODCARD;
	UCHAR sBuff[MAXWRITEBUFFLEN]={0};
	UCHAR sData[MAXWRITEBUFFLEN]={0};
	int  sDataLen=1;
	if(IsGoodCard)
	{
		sData[0]=0x00;
		IsGoodCard=FALSE;
	}
	else
	{
		sData[0]=0xff;
	}
	FormBuff(sBuff, sCmd, sData, sDataLen);

	for(int i=0; i<MAXTOKENSENDTIMES; i++)
	{
		WriteData(sBuff , sDataLen+7,"ToTokenCardStatus");
		DWORD Ret=WaitForSingleObject(m_Event_TokenAck, TOKENWAITTIME);
		if(Ret==WAIT_OBJECT_0)
		{
			ResetEvent(m_Event_TokenAck);
			return 1;
		}
		else if(Ret==WAIT_TIMEOUT)
		{
			continue;
		}
		else
		{
			ResetEvent(m_Event_TokenAck);
			break;
		}
	}
	return 0;
}