deviceclass.old

高速公路收费系统车道软件. 功能: 1 检测公路过往车辆 2 收费过程控制和数据采集 3 车辆信息和图片上传服务器.

	char tmpStr[2];
	tmpStr[0]=0x18;				//清除打印缓冲区
	tmpStr[1]=0;
	SendPrintData(tmpStr,1);
}

//	处理打印机状态并生成相应的外设消息
void CPrinter::ProcessPrinterInfo(char Status)
{
	if(chPrinterStatus!=Status){
		chPrinterStatus=Status;
//	清除/绘制信息以提醒操作员
		CScreen m_clsScreen;
		if(chPrinterStatus==0x11){
			bNormalFlag=TRUE;
			m_clsScreen.DrawAlarmInfo(" ");
		} else {
			bNormalFlag=FALSE;
			m_clsScreen.DrawAlarmInfo("打印机故障");
		}
//	记录设备状态
		CStatInfo m_clsStat;
		m_clsStat.DeviceStatus(PRINTER_DEVICE,bNormalFlag);
	}
} 

//	通过多串口卡按指定的格式打印票据
void CPrinter::PrintInvoice()
{
	CTransInfo m_clsTrans;
	CLaneInfo m_clsLane;
	CStatInfo m_clsStat;
	CTimeInfo m_clsTime;
	char pBuff[86];
	memset(pBuff,0,86);
	pBuff[0]=0x18;					//清除打印缓冲区的数据
	pBuff[1]=0x1b;
	pBuff[2]=0x6c;
	pBuff[3]=13;					//左边距为13个字符
	pBuff[4]=0x1b;
	pBuff[5]='a';
	pBuff[6]=8;						//进纸8行
	memset(pBuff,' ',20);
	sprintf(pBuff+7,"%.2d",m_clsLane.LaneSerial());//车道号
	sprintf(pBuff+23,"%.4d",m_clsStat.CollectNO());//收费员号
	pBuff[27]='\n';
	pBuff[28]=0x1b;
	pBuff[29]='a';
	pBuff[30]=2;					//进纸2行
	memset(pBuff+31,' ',20);		//车型、金额
	pBuff[32]=m_clsTrans.BusClass();
	sprintf(pBuff+46,"%.4d",m_clsTrans.RealMoney());
	pBuff[50]='\n';
	pBuff[51]=0x1b;
	pBuff[52]='a';
	pBuff[53]=2;					//进纸2行
	memset(pBuff+54,' ',14);		//日期
	sprintf(pBuff+58,"%.4d/%.2d/%.2d",m_clsTime.GetYear(),
		m_clsTime.GetMonth(),m_clsTime.GetDay());
	pBuff[68]='\n';
	pBuff[69]=0x1b;
	pBuff[70]='a';
	pBuff[71]=1;					//进纸1行
	memset(pBuff+72,' ',9);			//时间
	sprintf(pBuff+76,"%.2d:%.2d",m_clsTime.GetHour(),
		m_clsTime.GetMinute());
	pBuff[81]='\n';
	pBuff[82]=0x1b;
	pBuff[83]='a';
	pBuff[84]=7;					//进纸7行
	SendPrintData(pBuff,85);
}

//	通知打印机清空打印缓冲区
void CPrinter::ClearBuff()
{
	char pBuff[2];
	memset(pBuff,0,2);
	pBuff[0]=0x18;					//清除打印缓冲区的数据
	SendPrintData(pBuff,1);
}

//	通知打印机进纸
void CPrinter::Feed()
{
	char pBuff[4];
	memset(pBuff,0,4);
	pBuff[0]=0x1b;
	pBuff[1]='a';
	pBuff[2]=8;						//进纸8行
	SendPrintData(pBuff,3);
}

//	通过控制打印机打印票据
void CPrinter::SendPrintData(char *pBuff,int iLen)
{
	try{
	sio_write(PRINT_PORT,pBuff,iLen);
	}
	catch(...){
		SendMessage(theApp.m_pMainWnd->m_hWnd,WM_ABNORMAL,0,(LPARAM)"CPrinter::PrintInvoice()出现异常\n");
	}
}

//	返回票据打印机状态
BOOL CPrinter::NormalFlag()
{
	return bNormalFlag;
}

COverlay::COverlay()
{
}

//	字符叠加器初始化时需要设置时间、字体、车道信息，但这些信息
//	不能同时发送到叠加器，因此启动一定时器，定时器每超时一次则
//	发送一帧信息
void COverlay::Initial()
{
	OverlaySetStatus(LINE_1);		//设置车道信息行字体
	SendMessage(theApp.m_pMainWnd->m_hWnd,WM_STARTUP_TIMER,INITIAL_TIMER,0);
}

//	初始化定时器超时，继续下发其他尚未发完的命令
void COverlay::InitialTimerOut()
{
//	由于和字符叠加器通讯时经常丢失数据，每种消息我们都至少发送
//	8次以防止丢失
	static int nCount=1;
	if(nCount>31) return;
	switch(nCount%4){
	case 0:
		OverlaySetStatus(LINE_1);	//设置车道信息行字体
		break;
	case 1:
		OverlaySetStatus(LINE_2);	//设置交易信息行字体
		break;
	case 2:
		OverlayLaneInfo();			//叠加车道信息
		break;
	case 3:
		OverlaySetTime();			//设置叠加器时间
		break;
	}
	nCount++;
	SendMessage(theApp.m_pMainWnd->m_hWnd,WM_STARTUP_TIMER,INITIAL_TIMER,0);    
}

//	用空格代替交易信息区
void COverlay::ProcessTimerOut()
{
	UCHAR tmpStr[38];
	memset(tmpStr,0,38);
	tmpStr[0]=OVERLAY_WORD;
	tmpStr[1]=LINE_2;
	tmpStr[2]=COL_2;
	tmpStr[3]=0x10;				//通道1叠加
	memset(tmpStr+4,' ',26);
	SendOverlayData(tmpStr,30);
}

//	将指定行字体设置为小字体
void COverlay::OverlaySetStatus(int nLine)
{
	UCHAR tmpStr[6];
	memset(tmpStr,0,6);
	tmpStr[0]=OVERLAY_SMALL;
	tmpStr[1]=nLine;
	tmpStr[2]=0;
	tmpStr[3]=0;
	SendOverlayData(tmpStr,4);
}

//	叠加车道信息
void COverlay::OverlayLaneInfo()
{
	CLaneInfo m_clsLane;
	CStatInfo m_clsStat;
	char tmpStr[38];
	memset(tmpStr,0,38);
	tmpStr[0]=OVERLAY_WORD;		//发送显示字符
	tmpStr[1]=LINE_1;
	tmpStr[2]=COL_1;
	tmpStr[3]=0x10;				//通道1叠加
	memset(tmpStr+4,' ',16);
	m_clsLane.GetPlazaName(tmpStr+4);
	sprintf(tmpStr+20,"车道  %.2d   %.3d",
		m_clsLane.LaneSerial(),m_clsStat.CollectNO());
	SendOverlayData((UCHAR *)tmpStr,34);
}

//	叠加交易信息
void COverlay::OverlayTransInfo()
{
	CTransInfo m_clsTrans;
	char tmpStr[38];
	memset(tmpStr,0,38);
	tmpStr[0]=OVERLAY_WORD;
	tmpStr[1]=LINE_2;
	tmpStr[2]=COL_2;
	tmpStr[3]=0x10;				//通道1叠加
	sprintf(tmpStr+4,"车型 %.1d  人民币  %.4d",m_clsTrans.BusClass(),
		m_clsTrans.Fare());
	SendOverlayData((UCHAR *)tmpStr,24);
//	启动定时器，10秒后清除叠加信息
	SendMessage(theApp.m_pMainWnd->m_hWnd,WM_STARTUP_TIMER,OVERLAY_TIMER,10000);
}

//	设定叠加器时间
void COverlay::OverlaySetTime()
{
	CTimeInfo m_clsTime;
	UCHAR tmpStr[12];
	memset(tmpStr,0,12);
	tmpStr[0]=OVERLAY_SET_TIME;
	tmpStr[1]=0;
	tmpStr[2]=0;
	tmpStr[3]=0;
	tmpStr[4]=m_clsTime.GetYear()%100;
	tmpStr[5]=m_clsTime.GetMonth();
	tmpStr[6]=m_clsTime.GetDay();
	tmpStr[7]=m_clsTime.GetHour();
	tmpStr[8]=m_clsTime.GetMinute();
	tmpStr[9]=m_clsTime.GetSecond();
	SendOverlayData(tmpStr,10);
}

//	向字符叠加器发送数据
void COverlay::SendOverlayData(UCHAR *pStr,int nLen)
{
	UCHAR tmpStr[42];
	memset(tmpStr,0,42);
	tmpStr[0]=0xff;				//起始符
	tmpStr[1]=0xfe;
	tmpStr[2]=0;				//机器地址
	memmove(tmpStr+3,pStr,nLen);
	for(int i=2;i<39;i++)
		tmpStr[39]=tmpStr[39]^tmpStr[i];
	try{
		sio_write(OVERLAY_PORT,(char *)tmpStr,40);
	}
	catch(...){
		SendMessage(theApp.m_pMainWnd->m_hWnd,WM_ABNORMAL,0,(LPARAM)"COverlay::SendOverlayData()出现异常\n");
	}
}

//	在进行发卡、收卡等具有限制性条件的命令前备份发出的命令，同时
//	启动一定时器，如果定时器超时前命令被安全地执行，定时器被提前
//	关闭；否则当定时器超时时将再次发出该命令。

//	卡机共使用2个专用定时器和一个初始化定时器，其中初始化定时器
//	用于程序刚启动时获取卡机信息；其中长定时器用语弹出卡等需要较
//	长时间的定时操作，短定时器用于切换通道等可立即完成的定时操作。
UCHAR CMachine::chReadyData;	//要发出的命令
UCHAR CMachine::chBackupData;	//备份刚发出的命令
char CMachine::chCountType=NONE_COUNT;	//缺省不计数
BOOL CMachine::bBusyFlag=FALSE;			//缺省卡机不忙
BOOL CMachine::bFaultFlag=FALSE;		//缺省卡机无故障
CMachine::CMachine()
{
}

//	初始化卡机：负责弹出卡并读取卡机的所有状态字，两个命令不能
//	同时发送，因此启动一定时器，定时器超时后再读取状态字
void CMachine::Initial()
{
	SendMessage(theApp.m_pMainWnd->m_hWnd,WM_STARTUP_TIMER,INITIAL_TIMER,0);
}

//	初始化定时器超时：读取卡机的所有状态字
void CMachine::InitialTimerOut()
{
	static int nCount=1;
	if(nCount==1){			//发弹出卡命令后读机器状态字
		EjectCard();
		SendMessage(theApp.m_pMainWnd->m_hWnd,WM_STARTUP_TIMER,INITIAL_TIMER,0);
	}
	if(nCount==2){
		ProcessMachine(0xff);
	}
	nCount++;
}

//	卡机一次只能收一个命令，因此如果几个状态字都改变的话，车道软件
//	需要分次读取状态字，譬如：卡机通知车道软件状态字1、2、3发生变
//	化，车道软件先读取状态字1，卡机返回状态字1后再读取状态字2
//	特别地：车道软件暂时不发读所有状态字命令，因此此处暂时不处理
void CMachine::ProcessMachine(UCHAR status)
{
	static BOOL bRSW_Flag=FALSE;
	static BOOL bRSW1_Flag=FALSE;
	static BOOL bRSW3_Flag=FALSE;
	static BOOL bRSW4_Flag=FALSE;
	static int nLen=0;
	static UCHAR RSW_Buff[4];
	if(bRSW_Flag==TRUE){			//假如正在接收状态字？
		switch(nLen){
		case 1:
			RSW_Buff[nLen]=status;
			nLen++;
			break;
		case 2:
			RSW_Buff[nLen]=status;
			nLen=0;
			bRSW_Flag=FALSE;
//	判断状态字传送时是否有错误，若有，重传；若无，处理状态字
			if((RSW_Buff[0]^RSW_Buff[1])==RSW_Buff[2]){
				if(RSW_Buff[0]==RSW1_HEAD)
					ProcessRSW1(RSW_Buff[1]);
				if(RSW_Buff[0]==RSW2_HEAD)
					ProcessRSW2(RSW_Buff[1]);
				if(RSW_Buff[0]==RSW3_HEAD)
					ProcessRSW3(RSW_Buff[1]);
				if(RSW_Buff[0]==RSW4_HEAD)
					ProcessRSW4(RSW_Buff[1]);
				if(bRSW3_Flag){
					ReadRSW3();		//假如RSW3尚未读取，读取RSW3
					bRSW3_Flag=FALSE;
					break;
				}
				if(bRSW4_Flag){
					ReadRSW4();		//假如RSW4尚未读取，读取RSW4
					bRSW4_Flag=FALSE;
					break;
				}
				if(bRSW1_Flag){
					ReadRSW1();		//假如RSW1尚未读取，读取RSW1
					bRSW1_Flag=FALSE;
					break;
				}
			} else {				//若状态字传送错误，重传
				if(RSW_Buff[0]==RSW1_HEAD){
					ReadRSW1();
					break;
				}
				if(RSW_Buff[0]==RSW2_HEAD){
					ReadRSW2();
					break;
				}
				if(RSW_Buff[0]==RSW3_HEAD){
					ReadRSW3();
					break;
				}
				if(RSW_Buff[0]==RSW4_HEAD)
					ReadRSW4();
			}
			break;
		}
		return;
	}
	switch(status){
	case RSW1_HEAD:
	case RSW2_HEAD:
	case RSW3_HEAD:
	case RSW4_HEAD:
		RSW_Buff[0]=status;			//正在接收状态字
		bRSW_Flag=TRUE;
		nLen=1;
		break;
	case ERROR_OPTION:				//收到不正确的操作指令
		break;
	case ERROR_COMMAND:				//收到不正确的命令
		SendMachineData(chBackupData);
		break;
	case RSW_NO_CHANGE:
		RSW_NoChange();				//状态字未变化
		break;
	default:
		if((status&REQUEST_MASK)==REQUEST_MASK){	//请求读取状态字？
//	由于收/发卡机采用半双工通讯，车道软件不能连续地发送几个命令到
//	卡机（否则卡机只认第一个命令），因为这个原因，车道软件收到请求
//	读状态字命令后连续读取RSW1、RSW2、RSW3导致经常只能读到RSW1而读
//	不到RSW2、RSW3。另外，因为复位后卡机状态可能发生改变，因此我们
//	应优先处理复位标志，即：若几个状态字同时发生变化时优先处理状态
//	字2；若状态字2指明发生复位，则重新读取其他三个状态字	*/
			if((status&MACHINE_RSW2)!=0){
				ReadRSW2();
				if((status&MACHINE_RSW3)!=0){
					bRSW3_Flag=TRUE;
				}
				if((status&MACHINE_RSW4)!=0){
					bRSW4_Flag=TRUE;
				}
				if((status&MACHINE_RSW1)!=0){
					bRSW1_Flag=TRUE;
				}
				break;
			}
			if((status&MACHINE_RSW3)!=0){
				ReadRSW3();
				if((status&MACHINE_RSW4)!=0){
					bRSW4_Flag=TRUE;
				}
				if((status&MACHINE_RSW1)!=0){
					bRSW1_Flag=TRUE;
				}
				break;
			}
			if((status&MACHINE_RSW4)!=0){
				ReadRSW4();
				if((status&MACHINE_RSW1)!=0){
					bRSW1_Flag=TRUE;