multhread.cpp

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

// MulThread.cpp: implementation of the CMulThread class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "lane_new.h"
#include "Picture.h"
#include "MulThread.h"

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

extern CLane_newApp theApp;

struct TimerStruct TimerOut[MAX_TIMER_COUNT];
BOOL bKill1,bKill2,bKill3,bKill4;
BOOL bCxpFreeFlag,bSavePictureFlag,bStartCaptureFlag;
char strPictureName[PICTURE_NAME_LEN];
char strPrintInfo[PRINT_INFO_LEN];
int nPrintLen;


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
//	定时器线程执行程序，循环判断各个定时器，若已经超时，发送
//	超时消息。为了避免资源冲突，访问系统时间时用了互斥量
UINT CheckTimer(LPVOID pParam)
{
	while(1){
		theApp.muxKill1.Lock();
		if(bKill1){
			theApp.muxKill1.Unlock();
			break;
		}
		theApp.muxKill1.Unlock();
		for(int i=0;i<MAX_TIMER_COUNT;i++){
			theApp.muxTimerOut.Lock();
			if(TimerOut[i].Active==0){
				theApp.muxTimerOut.Unlock();
				continue;
			}
			theApp.muxTimerOut.Unlock();
			struct timeb loc1;
			theApp.muxTime.Lock();
			ftime(&loc1);
			theApp.muxTime.Unlock();
			theApp.muxTimerOut.Lock();
			unsigned long Interval1=loc1.time-TimerOut[i].StartTime.time;
			unsigned long Interval2,TotalInterval;
			if(loc1.millitm>=TimerOut[i].StartTime.millitm){
				Interval2=loc1.millitm-TimerOut[i].StartTime.millitm;
				TotalInterval=Interval1*1000+Interval2;
			} else {
				Interval2=TimerOut[i].StartTime.millitm-loc1.millitm;
				TotalInterval=Interval1*1000-Interval2;
			}
			if(TimerOut[i].TimerValue>TotalInterval){
				theApp.muxTimerOut.Unlock();
				continue;
			}
			TimerOut[i].Active=0;
			theApp.muxTimerOut.Unlock();
			SendMessage(AfxGetMainWnd()->m_hWnd,WM_TIMER_OUT,i,0);
		}
		Sleep(50);
	}
	theApp.muxKill1.Lock();
	bKill1=FALSE;
	theApp.muxKill1.Unlock();
	AfxEndThread(0);
	return 0;
}

//	循环查询多串口卡的接收缓冲区，若有数据等待处理，发送相应的消息
UINT MulportComm(LPVOID pParam)
{
	BOOL bSuccessFlag=TRUE;

	if(sio_open(CXP_PORT)!=SIO_OK){			//假如开串口错误
		bSuccessFlag=FALSE;
	}
	if(sio_ioctl(CXP_PORT,B9600,P_ODD|BIT_8|STOP_1)!=SIO_OK){
		bSuccessFlag=FALSE;
	}

	if(sio_open(TFI_PORT)!=SIO_OK){
		bSuccessFlag=FALSE;
	}
	if(sio_ioctl(TFI_PORT,B2400,P_NONE|BIT_8|STOP_1)!=SIO_OK){
		bSuccessFlag=FALSE;
	}
	
	if(sio_open(OVERLAY_PORT)!=SIO_OK){
		bSuccessFlag=FALSE;
	}
	if(sio_ioctl(OVERLAY_PORT,B2400,P_NONE|BIT_8|STOP_1)!=SIO_OK){
		bSuccessFlag=FALSE;
	}
	  
	if(sio_open(PRINT_PORT)!=SIO_OK){
		bSuccessFlag=FALSE;
	}
	if(sio_ioctl(PRINT_PORT,B9600,P_NONE|BIT_8|STOP_1)!=SIO_OK){
		bSuccessFlag=FALSE;
	}
	
	if(!bSuccessFlag){
//		PostMessage(AfxGetMainWnd()->m_hWnd,WM_ABNORMAL_QUIT,ERROR_MULPORT_FAILURE,0);
	}

	DWORD RetValue=1;
	unsigned char pCxpStr[16];
	char tmpStr[2];
	memset(tmpStr,0,2);
	int nCxpLen;
	BOOL tmpFlag;
	BOOL HeadFlag=FALSE;	//接收字符串不以0x0a开始,但以0x0d结束,不传此无效数据
	while(1){
		theApp.muxKill2.Lock();
		if(bKill2){
			theApp.muxKill2.Unlock();
			break;
		}
		theApp.muxKill2.Unlock();
		try{
		if(bSuccessFlag){
			theApp.muxCxpFree.Lock();
			tmpFlag=bCxpFreeFlag;
			theApp.muxCxpFree.Unlock();
			memset(tmpStr,0,2);
			if(tmpFlag){	//主线程处理完上一帧数据后再接收下一帧
				while(sio_read(CXP_PORT,(char *)tmpStr,1)>0){
					if((unsigned char)tmpStr[0]==0xa){
						memset(pCxpStr,0,16);
						nCxpLen=0;
						HeadFlag=TRUE;
					} else {
						if(HeadFlag){
							if((unsigned char)tmpStr[0]==0xd){
								theApp.muxCxpFree.Lock();
								bCxpFreeFlag=FALSE;
								theApp.muxCxpFree.Unlock();
								SendMessage(AfxGetMainWnd()->m_hWnd,WM_CXP,nCxpLen,(LPARAM)pCxpStr);
								memset(pCxpStr,0,16);
								nCxpLen=0;
								HeadFlag=FALSE;
								break;
							} else {
								if(nCxpLen<13){
									pCxpStr[nCxpLen]=(unsigned char)tmpStr[0];
									nCxpLen++;
								}
							}
						}
					}
				}
			}
		}

	//	if(sio_read(OVERLAY_PORT,tmpStr,1)>0){
	//		SendMessage(AfxGetMainWnd()->m_hWnd,WM_OVERLAY,(WPARAM)tmpStr[0],0);
	//	}		

		}
		catch(...){
			PostMessage(AfxGetMainWnd()->m_hWnd,WM_ABNORMAL,0,(LPARAM)"MulportComm()线程出现异常\n");
		}
//	将睡眠时间由50ms减少到1ms以减少对串口数据的响应延迟（目前车道
//	软件对卡机状态的相应太慢，若读取卡机状态太慢会造成某些变化的
//	状态丢失）
		Sleep(1);
	}
	sio_close(CXP_PORT);
	sio_close(TFI_PORT);
	sio_close(OVERLAY_PORT);

	//sio_close(PRINT_PORT);
	
	theApp.muxKill2.Lock();
	bKill2=FALSE;
	theApp.muxKill2.Unlock();
	AfxEndThread(0);
	return 0;
}

//	循环判断是否有图象数据需要压缩，若有，调用压缩程序，压缩完成后
//	复位图象存储标志从而允许抓拍并压缩下一幅图片
UINT SavePicture(LPVOID pParam)
{
	CImageProcess m_clsImage;
	m_clsImage.CreateHZK();
	CLaneInfo m_clsLane;		//获取图像压缩质量
	int nQuality=m_clsLane.PictureQuality();
	char strFileName[PICTURE_NAME_LEN];
	while(1){
		theApp.muxKill3.Lock();
		if(bKill3){
			theApp.muxKill3.Unlock();
			break;
		}
		theApp.muxKill3.Unlock();
		memset(strFileName,0,PICTURE_NAME_LEN);
		theApp.muxPicture.Lock();
		if(bSavePictureFlag){
			memmove(strFileName,strPictureName,PICTURE_NAME_LEN);
			theApp.muxPicture.Unlock();
			m_clsImage.ProcessPicture(strFileName,nQuality);
			theApp.muxPicture.Lock();
			bSavePictureFlag=FALSE;
			theApp.muxPicture.Unlock();
		} else {
			theApp.muxPicture.Unlock();
		}
		Sleep(50);
	}
	theApp.muxKill3.Lock();
	bKill3=FALSE;
	theApp.muxKill3.Unlock();
	AfxEndThread(0);
	return 0;
}

//	后台打印多线程。为了避免频繁开、关并行口，线程启动时打开并口，
//	线程退出前关闭并口
UINT PrintThread(LPVOID pParam)
{
	FILE *fp1;
	UCHAR tmpStr[PRINT_INFO_LEN];
	int nLen=0;
	while(1){
		theApp.muxKill4.Lock();
		if(bKill4){
			theApp.muxKill4.Unlock();
			break;
		}
		theApp.muxKill4.Unlock();
		try{
		memset(tmpStr,0,PRINT_INFO_LEN);
		theApp.muxPrint.Lock();
		memmove(tmpStr,(UCHAR *)strPrintInfo,nPrintLen);
		nLen=nPrintLen;
//	取出打印数据后清除旧的打印信息，否则该信息会一直被循环打印
		memset(strPrintInfo,0,PRINT_INFO_LEN);
		nPrintLen=0;
		theApp.muxPrint.Unlock();
		if(nLen>0){
		if((fp1=fopen("PRN","w"))!=NULL){
				fwrite(tmpStr,nLen,1,fp1);
				nLen=0;
				fclose(fp1);
			}
		}
		}
		catch(...){
			PostMessage(AfxGetMainWnd()->m_hWnd,WM_ABNORMAL,0,(LPARAM)"PrintThread()线程出现异常\n");
		}
		Sleep(20);
	}
	theApp.muxKill4.Lock();
	bKill4=FALSE;
	theApp.muxKill4.Unlock();
	AfxEndThread(0);
	return 0;
}