repos_ecs/门禁OCX/StoneU_Door 不用access数据库/StoneU_Door/Thread_Controller.cpp

#include "StdAfx.h"
#include "Thread_Controller.h"
#include "StoneU_Door.h"
#include "Dlg_Frame.h"
#include   <afxmt.h> 
#include   <afxtempl.h> 
#include "mdlProject.h"
#include "XJL\GlobalXJL.h"
#include "atlbase.h"							//加入
#include "WG\_WComm_Serial.h"			//加入
#include "WG\_WComm_Serial_i.c"		//加入
#import "WG\WComm_UDP.tlb"			//加入
using namespace WComm_UDP;						//加入

#include "Dlg_ZK.h"

//JK
extern HINSTANCE hACSDLL;      //DLL handle 
extern int g_nControllerOpenCount;		//控制器打开总数
bool g_bOK = false;
void WINAPI MYOnConnect(unsigned long iLineID)
{
	CString str;
	str.Format("iLineID = %d", iLineID);

	g_bOK = true;
	return;
}
void MYOnDisConnect(unsigned long iLineID)
{
}
void MYCtrlOnReceConfigData(unsigned long iLineID, BYTE *pDataBuf,unsigned long DataLength)
{
}

void MYCtrlOnSwitchChange (unsigned long iLineID,unsigned long PortNum, unsigned long Value)
{
	
}
//end JK

CThread_Controller::CThread_Controller( CONCROLLER controller )
{
	m_bPause = false;
	m_bExitThread = false;
	m_bExitFinish = false;
	m_Thread = NULL;
	m_hRunObject = NULL;
	
	m_nErrorNum = 0;
	m_Controller = controller;

	memset( m_nDoorStatus,-1,40 );
	//InitDll();
}

CThread_Controller::~CThread_Controller(void)
{

}
void CThread_Controller::SetController( CONCROLLER controller )
{
	m_Controller = controller;
}
void CThread_Controller::GetDoorNameAndInOutInfo( int iIndex,CString &sDoorName,CString &sInOut )
{
	int nDoorCount=0;

	if( m_Controller.sDoorName[1]!="" )
		nDoorCount++;
	if( m_Controller.sDoorName[2]!="" )
		nDoorCount++;
	if( m_Controller.sDoorName[3]!="" )
		nDoorCount++;
	if( m_Controller.sDoorName[4]!="" )
		nDoorCount++;

	iIndex = iIndex/4%4;
	if( nDoorCount==1 )
	{
		if( iIndex==0 || iIndex==2 )
		{
			sInOut = "【进门】";
			sDoorName.Format("%d-%s",m_Controller.nID,m_Controller.sDoorName[1] );
		}
		else
		{
			sInOut = "【出门】";
			sDoorName.Format("%d-%s",m_Controller.nID,m_Controller.sDoorName[1] );
		}
	}
	else if( nDoorCount==2 )
	{
		if( iIndex==0 || iIndex==2 )
		{
			sInOut = "【进门】";
			if( iIndex==0 )
				sDoorName.Format("%d-%s",m_Controller.nID,m_Controller.sDoorName[1] );
			else
				sDoorName.Format("%d-%s",m_Controller.nID,m_Controller.sDoorName[2] );
		}
		else
		{
			sInOut = "【出门】";
			if( iIndex==1 )
				sDoorName.Format("%d-%s",m_Controller.nID,m_Controller.sDoorName[1] );
			else
				sDoorName.Format("%d-%s",m_Controller.nID,m_Controller.sDoorName[2] );
		}
	}
	else if( nDoorCount==4 )
	{
		sInOut = "【进门】";
		switch( iIndex )
		{
		case 0:
			sDoorName.Format("%d-%s",m_Controller.nID,m_Controller.sDoorName[1] );
			break;
		case 1:
			sDoorName.Format("%d-%s",m_Controller.nID,m_Controller.sDoorName[2] );
			break;
		case 2:
			sDoorName.Format("%d-%s",m_Controller.nID,m_Controller.sDoorName[3] );
			break;
		case 3:
			sDoorName.Format("%d-%s",m_Controller.nID,m_Controller.sDoorName[4] );
			break;
		}
	}
}
int CThread_Controller::StartThread( )
{
	if (m_hRunObject == NULL)
	{
		m_hRunObject = ::CreateEvent(
			NULL,           /* Security */
			TRUE,           /* Manual event */
			0,              /* Clear on creation */
			0);
	}
	else
	{
		ResetEvent( m_hRunObject );
	}

	memset( m_nDoorStatus,-1,40 );

	switch( m_Controller.nBrandType )
	{
	case BRAND_WG://微耕
		{
			if( m_Controller.nWordMode==0 )
			{
				if (m_Thread == NULL )
				{ 
					m_Thread = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)Thread_WG_485,this,0,NULL);
		
					if (m_Thread)
					{
						m_bExitThread = false;
						m_bPause = false;
						m_bExitFinish = true;
						m_nErrorNum = 0;
					}
				}
			}
			else if( m_Controller.nWordMode==1 )
			{
				if (m_Thread == NULL )
				{ 
					m_Thread = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)Thread_WG_TCP,this,0,NULL);
					
					if (m_Thread)
					{
						m_bExitThread = false;
						m_bPause = false;
						m_bExitFinish = true;
						m_nErrorNum = 0;
					}
				}
			}
		}
		break;
	case BRAND_ZK://中控
		{
			if (m_Thread == NULL )
			{ 
				if( g_pDlgMain->m_pDlgZK==NULL )
				{
					g_pDlgMain->m_pDlgZK = new CDlg_ZK();
					g_pDlgMain->m_pDlgZK->Create(IDD_DLG_ZK, g_pDlgMain);
					//g_pDlgMain->m_pDlgZK->ShowWindow( true );
				}

				MTVERIFY( m_Thread = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)Thread_ZK,this,0,NULL) );
				
				if (m_Thread)
				{
					m_bExitThread = false;
					m_bPause = false;
					m_bExitFinish = true;
					m_nErrorNum = 0;
				}
			}
		}
		break;
	}

	return TRUE;
}

void CThread_Controller::StopThread( )
{
	if( m_hRunObject )
		MTVERIFY( SetEvent( m_hRunObject ) );	

	m_Controller.nOperterType = OPERATE_NULL;

	//Sleep( 500 );
	if( m_Controller.nBrandType==BRAND_WG )
	{
		if( m_Thread )
		{
			// 一直等到通知结果才返回
			if( !m_bExitFinish )
				WaitForSingleObject( m_hRunObject, INFINITE );
			//MTVERIFY( WaitForSingleObject( m_Thread, INFINITE ) != WAIT_FAILED );
			MTVERIFY( CloseHandle( m_Thread ) );
			m_Thread = NULL;
		}
	}
	else if( m_Controller.nBrandType==BRAND_ZK )
	{
		if( m_Thread )
		{
			m_bExitThread = true;
			Sleep(300);
			int nCount=0;

			//while( !m_bExitFinish )
			//{
			//	Sleep(100);
			//	if( nCount++ > 20 )
			//	{
			//		TerminateThread( m_Thread , 0 ); 
			//		Sleep(300);
			//		break;
			//	}
			//}
			CloseHandle( m_Thread );
			m_Thread = NULL;
		}
	}
}

DWORD WINAPI CThread_Controller::Thread_WG_485( CThread_Controller *pThread )
{
	MSG   message;   
	CString    strTemp;
	CString    strInfo;

	HRESULT hr;
	// Now we will intilize COM
	hr = CoInitialize(0);
	if (!SUCCEEDED(hr))
	{
		::MessageBox (NULL,(LPCTSTR)(g_strInitComFail),"",0);
		return FALSE;	//出错
	}

	IWComm_Serial *wserial;	 //创建串口通信COM对象
	hr = CoCreateInstance( CLSID_CWComm_Serial, NULL, CLSCTX_INPROC_SERVER, IID_IWComm_Serial, (void**) &wserial);
	if(!SUCCEEDED(hr))
	{
		::MessageBox (NULL,(LPCTSTR)(g_strInitSerialFail),"",0);
		return 0;	//出错
	}

	//__int64 lngRet;
 	long lngRetSerial;

	BSTR bstrT;				//中间变量
	BSTR bstrFrame;	        //通信返回的数据
	BSTR bstrCmd;           //发送的指令帧
	long controllerSN;      //控制器序列号
	BSTR bstrComPort;       //通信串口号

	//刷卡记录变量
	__int64  cardId;		//卡号    
	__int64  status;        //状态    
	BSTR bstrSwipeDate;     //日期时间

	CString strRunDetail;   //运行信息

    IWCOMM_OPERATEPtr wudp(__uuidof(WComm_Operate));	//创建.NET 通信对象

	strTemp = pThread->m_Controller.sSN;//"15978";
	controllerSN = _ttol((LPCTSTR)strTemp);		//测试使用的控制器

	strTemp.Format("COM%d",pThread->m_Controller.nComPort );//"COM1";
	bstrComPort = strTemp.AllocSysString();      //使用的通信端口

	strTemp.Format("%d",controllerSN);
	strInfo = "控制器通信－" + strTemp + "-" + CString(bstrComPort) ;

	bstrT = BSTR(L"811000000000");
	bstrCmd = wudp->CreateBstrCommand(controllerSN, bstrT);	//生成指令帧 
	wserial->serial_comm(bstrCmd, bstrComPort,&bstrFrame);	    //发送指令, 并获取返回信息
	wserial->get_ErrCode((long*)&lngRetSerial);
	if (( ERROR_SUCCESS != lngRetSerial)||(CString(bstrFrame)=="" )	)	
	{
		strInfo = strInfo + char(13) + char(10) + "出错处理: 读取运行信息失败" ;
		//pBoxOne->SetWindowText(strInfo );
		//if( pThread->m_nErrorNum++>1 )
		{
			CString s;
			s.Format( "连接【%d】失败，错误码=%d",pThread->m_Controller.nComPort,lngRetSerial );
			WriteLog( s );

			//wudp -> Release();
			//wserial->Release();
			g_SetComIsOpen( pThread->m_Controller.sPort,0 );
			pThread->m_bExitFinish = true;
			g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,2 );
			g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ReConnect,false,pThread->m_Controller.sName );
			return 0;
		}
	}

	pThread->m_nErrorNum = 0;
	pThread->m_bExitFinish = false;
	g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,0 );
	g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ReConnect,true,pThread->m_Controller.sName );

	while( 1 )
	{
		//设置门控制参数(在线/延时)[108F]
		while( pThread->m_Controller.nOperterType==OPERATE_ControlAndDelayTime )
		{
			for( int i=1;i<5;i++ )
			{
				if( pThread->m_Controller.bDoorIsSet[i] )
				{
					int nDoorControlType=pThread->m_Controller.nDoorControlType[i];
					int nDoorDelayTime = pThread->m_Controller.nDoorDelayTime[i]*10;
					
					CString s;
					s.Format( "8F10%02d%02d",i,nDoorControlType );
					bstrT = wudp->NumToStrHex(nDoorDelayTime,2);
					s += CString(bstrT);
 					bstrCmd = wudp ->CreateBstrCommand(controllerSN, A2BSTR(s)) ;  //生成指令帧
					wserial->serial_comm(bstrCmd, bstrComPort,&bstrFrame);	            //发送指令, 并获取返回信息
					wserial -> get_ErrCode((long*)&lngRetSerial);
					if (( ERROR_SUCCESS != lngRetSerial)||(CString(bstrFrame)=="" ))	
					{
						if( pThread->m_nErrorNum++>READ_ERROR_NUM )
						{
							pThread->m_Controller.nOperterType = OPERATE_Moniter;
							g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ControlAndDelayTime,false );
							break;
						}
					}
					else
					{
						pThread->m_nErrorNum = 0;
						//完成把标志赋为实时监控
						pThread->m_Controller.nOperterType = OPERATE_Moniter;
						g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ControlAndDelayTime,true );
						break;
					}

					break;
				}
			}
		}
		//校准控制器时间
		while( pThread->m_Controller.nOperterType==OPERATE_JustTime )
		{
			bstrCmd = wudp -> CreateBstrCommandOfAdjustClockByPCTime(controllerSN);  //生成指令帧
			wserial->serial_comm(bstrCmd, bstrComPort,&bstrFrame);	                 //发送指令, 并获取返回信息
			wserial -> get_ErrCode((long*)&lngRetSerial);
			if (( ERROR_SUCCESS != lngRetSerial)||(CString(bstrFrame)=="" ))	
			{
				strInfo = strInfo + char(13) + char(10) + "校准控制器时间出错" ;
				if( pThread->m_nErrorNum++>READ_ERROR_NUM )
				{
					pThread->m_Controller.nOperterType = OPERATE_Moniter;
					g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_JustTime,false );
					break;
				}
			}
			else
			{
				pThread->m_nErrorNum = 0;
				//完成把标志赋为实时监控
				pThread->m_Controller.nOperterType = OPERATE_Moniter;
				g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_JustTime,true );
				break;
			}
		}
 
		//远程开门
		while( pThread->m_Controller.nOperterType==OPERATE_DoorOpen )
		{
			for( int i=1;i<10;i++ )
			{
				if( pThread->m_Controller.bDoorIsSet[i] )
				{
					CString s;
					s.Format("9D10%02d",i );
 					bstrCmd = wudp ->CreateBstrCommand(controllerSN, A2BSTR(s)) ;  //生成指令帧
					wserial->serial_comm(bstrCmd, bstrComPort,&bstrFrame);	              //发送指令, 并获取返回信息
					wserial -> get_ErrCode((long*)&lngRetSerial);
					if (( ERROR_SUCCESS != lngRetSerial)||(CString(bstrFrame)=="" ))	
					{
						strInfo = strInfo + char(13) + char(10) + "远程开门失败" ;
						if( pThread->m_nErrorNum++>READ_ERROR_NUM )
						{
							pThread->m_Controller.nOperterType = OPERATE_Moniter;
							pThread->m_Controller.bDoorIsSet[i] = false;
							g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_DoorOpen,false );
							break;
						}
					}
					else
					{
						pThread->m_nErrorNum = 0;
						//完成把标志赋为实时监控
						pThread->m_Controller.nOperterType = OPERATE_Moniter;
						pThread->m_Controller.bDoorIsSet[i] = false;
						g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_DoorOpen,true );
						break;
					}

					break;
				}
			}
		}

		//提取记录
        long recIndex;
		recIndex = 1;
		while( pThread->m_Controller.nOperterType==OPERATE_Record )
		{
			bstrT = wudp->NumToStrHex(recIndex, 4);
			strTemp = "8D10" + CString(bstrT);
			bstrCmd = wudp ->CreateBstrCommand(controllerSN, A2BSTR(strTemp)) ;  //生成指令帧 
			wserial->serial_comm(bstrCmd, bstrComPort,&bstrFrame);	             //发送指令, 并获取返回信息
			wserial->get_ErrCode((long*)&lngRetSerial);
			if (( ERROR_SUCCESS != lngRetSerial)||(CString(bstrFrame)=="" )	)	
			{
				strInfo = strInfo + char(13) + char(10) + "提取记录出错" ;

				if( pThread->m_nErrorNum++>READ_ERROR_NUM )
				{
					pThread->m_Controller.nOperterType = OPERATE_Moniter;
					break;
				}
			}
			else
			{
				pThread->m_nErrorNum = 0;
				bstrSwipeDate = wudp->GetSwipeDateFromRunInfo(bstrFrame, &cardId, &status) ;
				if (CString((bstrSwipeDate)) != "" )
				{
					int nIndex=0;
					CString sUserName,sClass,sJobNumber,sRemarks,sDoorName,sInOut;
					g_GetCardInfoByCardNumber( cardId,sUserName,sClass,sJobNumber,sRemarks );
					CString sTime,sCardID,sInfo,s;
					sInfo = g_GetStatus( pThread->m_Controller.nBrandType,cardId,status,nIndex );
					pThread->GetDoorNameAndInOutInfo( nIndex,sDoorName,sInOut );
					
					sTime.Format("%s",CString(bstrSwipeDate)  );
					sCardID.Format( "%ld",cardId );	
					if( sUserName!="" )
						sUserName.Format( "%s( %s-%s ) ",sUserName,sClass,sJobNumber );	
					sDoorName = sInOut+sDoorName;
					
					//ADOCtrl.InsertRecord( sTime,sCardID,sUserName,sDoorName,sInfo );

					recIndex = recIndex + 1;
				}
				else
				{
					if (recIndex > 1)   //只有提取了记录才进行删除
					{
						while( true )
						{
							bstrT = wudp->NumToStrHex(recIndex-1, 4);
							strTemp = "8E10" + CString(bstrT);
   							bstrCmd = wudp ->CreateBstrCommand(controllerSN, A2BSTR(strTemp)) ;  //生成指令帧 
							wserial->serial_comm(bstrCmd, bstrComPort,&bstrFrame);	             //发送指令, 并获取返回信息
							wserial -> get_ErrCode((long*)&lngRetSerial);
							if (( ERROR_SUCCESS != lngRetSerial)||(CString(bstrFrame)=="" )	)	
							{
								strInfo = strInfo + char(13) + char(10) + "删除记录失败" ;
								if( pThread->m_nErrorNum++>READ_ERROR_NUM )
								{
									pThread->m_Controller.nOperterType = OPERATE_Moniter;
									break;
								}
							}
							else
							{
								pThread->m_nErrorNum=0;
								strInfo = strInfo + char(13) + char(10) + "删除记录成功";
								break;
							}
						}
					}
					//完成提取记录把标志赋为实时监控
					pThread->m_Controller.nOperterType = OPERATE_Moniter;
					break;
				}
			}
			if(::PeekMessage   (&message,NULL,0,0,PM_REMOVE))
			{		//响应其他事件 如Exit按钮操作
						::TranslateMessage   (&message);   
						::DispatchMessage   (&message);   
			}   

		}

		//发送权限操作(1.先清空权限)
		if( pThread->m_Controller.nOperterType==OPERATE_Permit )
		{
			while( true )
			{
   				bstrCmd = wudp ->CreateBstrCommand(controllerSN, A2BSTR("9310")) ;  //生成指令帧 
				wserial->serial_comm(bstrCmd, bstrComPort,&bstrFrame);	            //发送指令, 并获取返回信息
				wserial -> get_ErrCode((long*)&lngRetSerial);
				if (( ERROR_SUCCESS != lngRetSerial)||(CString(bstrFrame)=="" )	)	
				{
					strInfo = strInfo + char(13) + char(10) + "清空权限失败" ;
					if( pThread->m_nErrorNum++>READ_ERROR_NUM )
					{
						pThread->m_Controller.nOperterType = OPERATE_Moniter;
						break;
					}
				}
				else
				{
					pThread->m_nErrorNum=0;
					strInfo = strInfo + char(13) + char(10) + "清空权限成功" ;
					break;
				}
			}

			//发送权限操作(2.再添加权限)
			//权限格式: 卡号（2）+区号（1）+门号（1）+卡起始年月日（2）+卡截止年月日（2）+ 控制时段索引号（1）+密码（3）+备用（4，用0填充）
			//发送权限按: 先发1号门(卡号小的先发), 再发2号门(卡号小的先发)
			//此案例中权限设为: 卡有效期从(2007-8-14 到2020-12-31), 采用默认时段1(任意时间有效), 缺省密码(1234), 备用值以00填充
			//以三个卡： 07217564 [9C4448]，342681[B9A603]，25409969[F126FE]为例，分别可以通过控制器的2个门。
			//实际使用按需修改
	        
	//      //!!!!!!!注意:  此处卡号已直接按从小到大排列赋值了. 实际使用中要用算法实现排序
			long privilegeIndex = 1;
			CString privilege;

			for( int nDoorIndex=1;nDoorIndex<5;nDoorIndex++ )
			{
				if( pThread->m_Controller.Card2Door[nDoorIndex].nCardCount>0 )
				{
					for( int nCardIndex=0;nCardIndex<pThread->m_Controller.Card2Door[nDoorIndex].nCardCount;nCardIndex++ )
					{
						long cardno = pThread->m_Controller.Card2Door[nDoorIndex].nCardNum[nCardIndex];
						
						privilege = ""; 
						bstrT = wudp->CardToStrHex(cardno);
						privilege = privilege + CString(bstrT);                  //卡号
 						bstrT = wudp->NumToStrHex(nDoorIndex, 1);
						privilege = privilege + CString(bstrT) ;                 //门号
						bstrT = wudp->MSDateYmdToWCDateYmd(A2BSTR("2007-8-14")) ;//有效起始日期
						privilege = privilege + CString(bstrT);                  
						bstrT = wudp->MSDateYmdToWCDateYmd(A2BSTR("2020-12-31"));//有效截止日期
						privilege = privilege + CString(bstrT) ;
						bstrT = wudp->NumToStrHex(1, 1)                 ;        //时段索引号
						privilege = privilege + CString(bstrT) ;
						bstrT = wudp->NumToStrHex(123456, 3)            ;        //用户密码
						privilege = privilege + CString(bstrT) ;
						bstrT = wudp->NumToStrHex(0, 4)                 ;        //备用4字节(用0填充)
						privilege = privilege + CString(bstrT) ;
						if (lstrlen(privilege) != (16 * 2))
						{
							//生成的权限不符合要求, 请查一下上一指令中写入的每个参数是否正确
							strInfo = strInfo + char(13) + char(10) + "生成的权限不符合要求: 添加权限失败" ;
						}

						while( true )
						{
							bstrT = wudp->NumToStrHex(privilegeIndex, 2)     ;       //权限索引号
							strTemp = "9B10" + CString(bstrT) + privilege;
							bstrCmd = wudp->CreateBstrCommand(controllerSN, A2BSTR(strTemp)) ;  //生成指令帧 
							wserial->serial_comm(bstrCmd, bstrComPort,&bstrFrame);	            //发送指令, 并获取返回信息
							wserial -> get_ErrCode((long*)&lngRetSerial);
							if (( ERROR_SUCCESS != lngRetSerial)||(CString(bstrFrame)=="" ))	
							{
								strInfo = strInfo + char(13) + char(10) + "添加权限失败" ;
								if( pThread->m_nErrorNum++>READ_ERROR_NUM )
								{
									pThread->m_Controller.nOperterType = OPERATE_Moniter;
									break;
								}
							}
							else
							{
								pThread->m_nErrorNum = 0;
								privilegeIndex = privilegeIndex + 1;
								break;
							}
						}
						if(::PeekMessage   (&message,NULL,0,0,PM_REMOVE))
						{		//响应其他事件 如Exit按钮操作
									::TranslateMessage   (&message);   
									::DispatchMessage   (&message);   
						}   
					}
				}
			}

			 //发送控制时段
			//发送要设定的时段 [注意0,1时段为系统固定化,更改是无效的, 所以设定的时段一般从2开始]
			//此案例设定时段2: 从2007-8-1到2007-12-31日
			//星期1到5允许在7:30-12:30, 13:30-17:30, 19:00-21:00通过, 其他时间不允许
			CString timeseg;
			timeseg = "";
    		bstrT = wudp->NumToStrHex(0x1F, 1);
			timeseg = timeseg + CString(bstrT) ;   //星期控制
     		bstrT = wudp->NumToStrHex(0x00, 1);
			timeseg = timeseg + CString(bstrT) ;   // 下一链接时段(0--表示无)
    		bstrT = wudp->NumToStrHex(0x00, 2);
			timeseg = timeseg + CString(bstrT) ;   // 保留2字节(0填充)
    		bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("7:30:00"));
			timeseg = timeseg + CString(bstrT) ;   //  起始时分秒1
   			bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("12:30:00"));
			timeseg = timeseg + CString(bstrT) ;   //  终止时分秒1
    		bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("13:30:00"));
			timeseg = timeseg + CString(bstrT) ;   //  起始时分秒2
   			bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("17:30:00"));
			timeseg = timeseg + CString(bstrT) ;   //  终止时分秒2
    		bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("19:00:00"));
			timeseg = timeseg + CString(bstrT) ;   //  起始时分秒3
   			bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("21:00:00"));
			timeseg = timeseg + CString(bstrT) ;   //  终止时分秒3
    		bstrT = wudp->MSDateYmdToWCDateYmd(A2BSTR("2007-8-1"));
			timeseg = timeseg + CString(bstrT) ;   //  起始日期
   			bstrT = wudp->MSDateYmdToWCDateYmd(A2BSTR("2007-12-31"));
			timeseg = timeseg + CString(bstrT) ;   //  终止日期
    		bstrT = wudp->NumToStrHex(0x00, 4);
			timeseg = timeseg + CString(bstrT) ;   // 保留4字节(0填充)

			if (lstrlen(timeseg) != (24 * 2))
			{
				//生成的时段不符合要求, 请查一下上一指令中写入的每个参数是否正确
				strInfo = strInfo + char(13) + char(10) + "生成的时段不符合要求: 修改时段失败" ;
			}

			while( true )
			{
				bstrT = wudp->NumToStrHex(2, 2)  ;                                  //时段索引号2
				strTemp = "9710" + CString(bstrT) + timeseg;
				bstrCmd = wudp->CreateBstrCommand(controllerSN, A2BSTR(strTemp)) ;  //生成指令帧 
				wserial->serial_comm(bstrCmd, bstrComPort,&bstrFrame);	            //发送指令, 并获取返回信息
				wserial -> get_ErrCode((long*)&lngRetSerial);
				if (( ERROR_SUCCESS != lngRetSerial)||(CString(bstrFrame)=="" )	)	
				{
					strInfo = strInfo + char(13) + char(10) + "添加时段失败" ;
					if( pThread->m_nErrorNum++>READ_ERROR_NUM )
					{
						pThread->m_Controller.nOperterType = OPERATE_Moniter;
						break;
					}
				}
				else
				{
					pThread->m_nErrorNum = 0;
					strInfo = strInfo + char(13) + char(10) + "添加时段成功" ;
					break;
				}
			}

			//完成把标志赋为实时监控
			pThread->m_Controller.nOperterType = OPERATE_Moniter;
		}

		 //实时监控 
       // 读取运行状态是实现监控的关键指令。 在进行监控时, 先读取最新记录索引位的记录. 读取到最新的记录， 同时可以获取到刷卡记录数。
       // 这时就可以用读取到刷卡记录数加1填充到要读取的最新记录索引位上，去读取运行状态， 以便获取下一个记录。
       // 如果读取到了新的刷卡记录， 就可以将索引位增1， 否则保持索引位不变。 这样就可以实现数据的实时监控。
       // 遇到通信不上的处理，这时可对串口通信采取超时400-500毫秒作为出错，可重试一次，再接收不到数据， 可认为设备与PC机间的不能通信。
	   __int64 watchIndex;
	   long recCnt;

       watchIndex = 0   ;                   //缺省从0, 表示先提取最近一个记录
       recCnt = 0       ;                   //监控记录计数

	   while( pThread->m_Controller.nOperterType==OPERATE_Moniter )
	   {
		    //读取在线信息
		    DWORD dwTicks = GetTickCount() - pThread->m_dwGetDoorStatusTicks;
			if(  dwTicks>=READ_DOORSTATUS_TIMESPACE )
			{
				bstrT = BSTR(L"811000000000");
				bstrCmd = wudp -> CreateBstrCommand(controllerSN, bstrT);	//生成指令帧 
				wserial->serial_comm(bstrCmd, bstrComPort,&bstrFrame);	    //发送指令, 并获取返回信息
				wserial -> get_ErrCode((long*)&lngRetSerial);
				if (( ERROR_SUCCESS != lngRetSerial)||(CString(bstrFrame)=="" )	)	
				{
				}
				else
				{
					int INDEX=0;

					__int64 lngRet = wudp->GetDoorStatusFromRunInfo(bstrFrame, 1);
					INDEX = 1;
					if (lngRet==1 && pThread->m_nDoorStatus[INDEX]!=lngRet )
					{
						pThread->m_nDoorStatus[INDEX] = lngRet;
						g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,INDEX,1 );
					}
					else if ( pThread->m_nDoorStatus[INDEX]!=lngRet )
					{
						pThread->m_nDoorStatus[INDEX] = lngRet;
						g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,INDEX,0 );
					}
					
					if( pThread->m_Controller.nDoorCount>1 )
					{
						lngRet = wudp->GetDoorStatusFromRunInfo(bstrFrame, 2);
						INDEX = 2;
						if (lngRet==1 && pThread->m_nDoorStatus[INDEX]!=lngRet )
						{
							pThread->m_nDoorStatus[INDEX] = lngRet;
							g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,INDEX,1 );
						}
						else if ( pThread->m_nDoorStatus[INDEX]!=lngRet )
						{
							pThread->m_nDoorStatus[INDEX] = lngRet;
							g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,INDEX,0 );
						}
					}
					if( pThread->m_Controller.nDoorCount>2 )
					{
						lngRet = wudp->GetDoorStatusFromRunInfo(bstrFrame, 3);
						INDEX = 3;
						if (lngRet==1 && pThread->m_nDoorStatus[INDEX]!=lngRet )
						{
							pThread->m_nDoorStatus[INDEX] = lngRet;
							g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,INDEX,1 );
						}
						else if ( pThread->m_nDoorStatus[INDEX]!=lngRet )
						{
							pThread->m_nDoorStatus[INDEX] = lngRet;
							g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,INDEX,0 );
						}

						lngRet = wudp->GetDoorStatusFromRunInfo(bstrFrame, 4);
						INDEX = 4;
						if (lngRet==1 && pThread->m_nDoorStatus[INDEX]!=lngRet )
						{
							pThread->m_nDoorStatus[INDEX] = lngRet;
							g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,INDEX,1 );
						}
						else if ( pThread->m_nDoorStatus[INDEX]!=lngRet )
						{
							pThread->m_nDoorStatus[INDEX] = lngRet;
							g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,INDEX,0 );
						}
					}
				}

				pThread->m_dwGetDoorStatusTicks = GetTickCount();
			}


		    bstrT = wudp->NumToStrHex(watchIndex, 3) ;    //表示第watchIndex个记录, 如果是0则取最新一条记录
			strTemp = "8110" + CString(bstrT);
			bstrCmd = wudp->CreateBstrCommand(controllerSN, A2BSTR(strTemp)) ;  //生成指令帧 
			wserial->serial_comm(bstrCmd, bstrComPort,&bstrFrame);	//发送指令, 并获取返回信息
			wserial -> get_ErrCode((long*)&lngRetSerial);
			if (( ERROR_SUCCESS != lngRetSerial)||(CString(bstrFrame)=="" )	)	
			{
				strInfo = strInfo + char(13) + char(10) + "实时监控失败" ;
			}
			else
			{
				pThread->m_nErrorNum = 0;
				bstrSwipeDate = wudp->GetSwipeDateFromRunInfo(bstrFrame, &cardId, &status) ;
				if (CString(bstrSwipeDate) != "" )
				{
					int nIndex=0;
					CString sUserName,sClass,sJobNumber,sRemarks,sDoorName,sInOut;
					g_GetCardInfoByCardNumber( cardId,sUserName,sClass,sJobNumber,sRemarks );
					CString sTime,sCardID,sInfo,s;
					sInfo = g_GetStatus( pThread->m_Controller.nBrandType,cardId,status,nIndex );
					pThread->GetDoorNameAndInOutInfo( nIndex,sDoorName,sInOut );
					sCardID.Format( "%ld",cardId );	
					
					if( sUserName!="" && sClass!="" && sJobNumber!="" )
						sUserName.Format( "%s( %s-%s ) ",sUserName,sClass,sJobNumber );	
					else if( sUserName!="" && sClass!="" )
						sUserName.Format( "%s( %s ) ",sUserName,sClass );	
					else if( sUserName!="" && sJobNumber!="" )
						sUserName.Format( "%s( %s ) ",sUserName,sJobNumber );	

					sTime.Format("%s",CString(bstrSwipeDate)  );
					
					sDoorName = sInOut+sDoorName;
					
                    recIndex = recIndex + 1;             //下一条记录
				   if (watchIndex == 0)                  //如果收到第一条记录
				   {
					   watchIndex = wudp->GetCardRecordCountFromRunInfo(bstrFrame);
					   watchIndex =  watchIndex + 1;     //指向(总记录数+1), 也就是下次刷卡的存储索引位
				   }
				   else
				   {
						g_pDlgMain->m_pDlg_Moniter->InsertItemToList( " "+sTime," "+sCardID," "+sUserName," "+sDoorName," "+sInfo );
						watchIndex = watchIndex + 1 ; //指向下一个记录位
				   }
					recCnt = recCnt + 1;                //记录计数				}
				  // pBoxOne->LineScroll(pBoxOne->GetLineCount());	//显示最后一行
				}
			}

			if(::PeekMessage   (&message,NULL,0,0,PM_REMOVE))
			{		//响应其他事件 如Exit按钮操作
				::TranslateMessage   (&message);   
				::DispatchMessage   (&message);   
			}   

			Sleep( 1000 );
	   }

	   if( pThread->m_Controller.nOperterType==OPERATE_NULL )
		{
			wudp -> Release();
			wserial->Release();
			CoUninitialize();
			SysFreeString(bstrComPort); 	
			SetEvent( pThread->m_hRunObject );	
			pThread->m_bExitFinish = true;
			break;
		}

	}//while( 1 );//( WaitForSingleObject(pThread->m_hRunObject, 200L) == WAIT_TIMEOUT );

    return 0;	
}
DWORD WINAPI CThread_Controller::Thread_WG_TCP( CThread_Controller *pThread )
{
	MSG   message;   
	CString    strTemp,sTemp;
	CString    strNewIPAddr;
	CString    strInfo;

	HRESULT hr;
	// Now we will intilize COM
	hr = CoInitialize(0);
	if (!SUCCEEDED(hr))
	{
		::MessageBox (NULL,(LPCTSTR)(g_strInitComFail),"",0);
		return -1;	//出错
	}

	__int64 lngRet;
	BSTR bstrT;				//中间变量
	BSTR bstrFrame;	        //通信返回的数据
	BSTR bstrCmd;           //发送的指令帧
	long controllerSN;      //控制器序列号
    
	//刷卡记录变量
	__int64  cardId;		//卡号    
	__int64  status;        //状态    
	BSTR bstrSwipeDate;     //日期时间

	CString strRunDetail;   //运行信息
	BSTR strIPAddr;			//IP地址
	CString strMac;			//MAC地址
	CString strHexNewIP;    //New IP (十六进制)
    CString strHexMask;     //掩码(十六进制)
    CString strHexGateway;  //网关(十六进制)
	long startLoc;			//字符串的起始位置

    IWCOMM_OPERATEPtr wudp(__uuidof(WComm_Operate));	//创建UDP 通信对象

	//((CWnd*)GetDlgItem(IDC_EDITSN))->GetWindowText(strTemp);
	controllerSN = _ttol((LPCTSTR)pThread->m_Controller.sSN );		//测试使用的控制器

	strIPAddr = pThread->m_Controller.sIP.AllocSysString();  //BSTR(L"");		      //一开始为空, 表示广播包方式
	//strTemp.Format("%d",controllerSN);

	if( pThread->m_Controller.sPort=="" )
		pThread->m_Controller.sPort = "60000";

 	//读取运行状态信息(1081)
	while( true )
	{
		bstrT = BSTR(L"811000000000");
		bstrCmd = wudp->CreateBstrCommand(controllerSN, bstrT);	//生成指令帧 
		bstrFrame = wudp->udp_comm(bstrCmd, strIPAddr, atoi(pThread->m_Controller.sPort) );	//发送指令, 并获取返回信息
		if (( ERROR_SUCCESS != wudp->ErrCode)||(CString(bstrFrame)=="" )	)	
		{
			//if( pThread->m_nErrorNum++>1 )
			{
				CString s;
				s.Format( "连接【%s,%s】失败，错误码=%d",pThread->m_Controller.sIP,pThread->m_Controller.sPort,wudp->ErrCode );
				WriteLog( s );

				pThread->m_bExitFinish = true;
				g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,2 );
				g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ReConnect,false,pThread->m_Controller.sName );
				return 0;
			}
		}
		else
			break;
	}

	pThread->m_nErrorNum = 0;
	pThread->m_bExitFinish = false;
	g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,0 );
	g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ReConnect,true,pThread->m_Controller.sName );

	while( 1 )
	{
		//设置门控制参数(在线/延时)[108F]
		while( pThread->m_Controller.nOperterType==OPERATE_ControlAndDelayTime )
		{
			for( int i=1;i<5;i++ )
			{
				if( pThread->m_Controller.bDoorIsSet[i] )
				{
					int nDoorControlType=pThread->m_Controller.nDoorControlType[i];
					int nDoorDelayTime = pThread->m_Controller.nDoorDelayTime[i]*10;
					
					CString s;
					s.Format( "8F10%02d%02d",i,nDoorControlType );
					bstrT = wudp->NumToStrHex(nDoorDelayTime,2);
					s += CString(bstrT);
 					bstrCmd = wudp->CreateBstrCommand(controllerSN, A2BSTR(s)) ;  //生成指令帧
					bstrFrame = wudp->udp_comm(bstrCmd, strIPAddr, atoi(pThread->m_Controller.sPort));	//发送指令, 并获取返回信息
					if (( ERROR_SUCCESS != wudp ->ErrCode)||(CString(bstrFrame)=="" )	)	
					{
						if( pThread->m_nErrorNum++>READ_ERROR_NUM )
						{
							pThread->m_Controller.nOperterType = OPERATE_Moniter;
							g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ControlAndDelayTime,false );
							break;
						}
					}
					else
					{
						pThread->m_nErrorNum = 0;
						//完成把标志赋为实时监控
						pThread->m_Controller.nOperterType = OPERATE_Moniter;
						g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ControlAndDelayTime,true );
						break;
					}

					break;
				}
			}
		}
		//校准控制器时间
		while( pThread->m_Controller.nOperterType==OPERATE_JustTime )
		{
			bstrCmd = wudp -> CreateBstrCommandOfAdjustClockByPCTime(controllerSN);  //生成指令帧
			bstrFrame = wudp -> udp_comm(bstrCmd, strIPAddr, atoi(pThread->m_Controller.sPort));	//发送指令, 并获取返回信息
			if (( ERROR_SUCCESS != wudp ->ErrCode)||(CString(bstrFrame)=="" )	)	
			{
				strInfo = strInfo + char(13) + char(10) + "校准控制器时间出错" ;
				if( pThread->m_nErrorNum++>READ_ERROR_NUM )
				{
					pThread->m_Controller.nOperterType = OPERATE_Moniter;
					g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_JustTime,false );
					break;
				}
			}
			else
			{
				pThread->m_nErrorNum=0;
				pThread->m_Controller.nOperterType = OPERATE_Moniter;
				g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_JustTime,true );
				break;
			}
		}

		//远程开门
		while( pThread->m_Controller.nOperterType==OPERATE_DoorOpen )
		{
			for( int i=1;i<5;i++ )
			{
				if( pThread->m_Controller.bDoorIsSet[i] )
				{
					CString s;
					s.Format("9D10%02d",i );
 					bstrCmd = wudp ->CreateBstrCommand(controllerSN, A2BSTR(s)) ;  //生成指令帧
					bstrFrame = wudp -> udp_comm(bstrCmd, strIPAddr, atoi(pThread->m_Controller.sPort));	          //发送指令, 并获取返回信息
					if (( ERROR_SUCCESS != wudp ->ErrCode)||(CString(bstrFrame)=="" )	)	
					{
						strInfo = strInfo + char(13) + char(10) + "远程开门失败" ;
						if( pThread->m_nErrorNum++>READ_ERROR_NUM )
						{
							pThread->m_Controller.nOperterType = OPERATE_Moniter;
							pThread->m_Controller.bDoorIsSet[i] = false;
							g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_DoorOpen,false );
							break;
						}
					}
					else
					{
						pThread->m_nErrorNum = 0;
						//完成把标志赋为实时监控
						pThread->m_Controller.nOperterType = OPERATE_Moniter;
						pThread->m_Controller.bDoorIsSet[i] = false;
						g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_DoorOpen,true );
						break;
					}

					break;
				}
			}
		}

		//提取记录
        long recIndex;
		recIndex = 1;
        while( pThread->m_Controller.nOperterType==OPERATE_Record )
		{
			bstrT = wudp->NumToStrHex(recIndex, 4);
			strTemp = "8D10" + CString(bstrT);
			bstrCmd = wudp ->CreateBstrCommand(controllerSN, A2BSTR(strTemp)) ;  //生成指令帧
			bstrFrame = wudp -> udp_comm(bstrCmd, strIPAddr, atoi(pThread->m_Controller.sPort));	         //发送指令, 并获取返回信息
			if (( ERROR_SUCCESS != wudp ->ErrCode)||(CString(bstrFrame)=="" )	)	
			{
				strInfo = strInfo + char(13) + char(10) + "提取记录出错" ;
				if( pThread->m_nErrorNum++>READ_ERROR_NUM )
				{
					pThread->m_Controller.nOperterType = OPERATE_Moniter;
					break;
				}
			}
			else
			{
				pThread->m_nErrorNum=0;
				bstrSwipeDate = wudp->GetSwipeDateFromRunInfo(bstrFrame, &cardId, &status) ;
				if (CString((bstrSwipeDate)) != "" )
				{
					int nIndex=0;
					CString sUserName,sClass,sJobNumber,sRemarks,sDoorName,sInOut;
					g_GetCardInfoByCardNumber( cardId,sUserName,sClass,sJobNumber,sRemarks );
					CString sTime,sCardID,sInfo,s;
					sInfo = g_GetStatus( pThread->m_Controller.nBrandType,cardId,status,nIndex );
					pThread->GetDoorNameAndInOutInfo( nIndex,sDoorName,sInOut );
					
					sTime.Format("%s",CString(bstrSwipeDate)  );
					sCardID.Format( "%ld",cardId );	
					if( sUserName!="" )
						sUserName.Format( "%s( %s-%s ) ",sUserName,sClass,sJobNumber );	
					
					sDoorName = sInOut+sDoorName;
					
					//ADOCtrl.InsertRecord( sTime,sCardID,sUserName,sDoorName,sInfo );
					
					recIndex = recIndex + 1;                        //下一条记录
				}
				else
				{
					strTemp.Format("%ld", (recIndex-1));
					strInfo = strInfo + char(13) + char(10) + "提取记录完成. 总共提取记录数 =" + strTemp;

					if (recIndex > 1)   //只有提取了记录才进行删除
					{
						while( true )
						{
							bstrT = wudp->NumToStrHex(recIndex-1, 4);
							strTemp = "8E10" + CString(bstrT);
   							bstrCmd = wudp ->CreateBstrCommand(controllerSN, A2BSTR(strTemp)) ;  //生成指令帧
							bstrFrame = wudp -> udp_comm(bstrCmd, strIPAddr, atoi(pThread->m_Controller.sPort));	         //发送指令, 并获取返回信息
							if (( ERROR_SUCCESS != wudp ->ErrCode)||(CString(bstrFrame)==""))	
							{
								strInfo = strInfo + char(13) + char(10) + "删除记录失败" ;
								if( pThread->m_nErrorNum++>READ_ERROR_NUM )
								{
									pThread->m_Controller.nOperterType = OPERATE_Moniter;
									break;
								}
							}
							else
							{
								pThread->m_nErrorNum = 0;
								strInfo = strInfo + char(13) + char(10) + "删除记录成功";
								break;
							}
						}
					}

					pThread->m_Controller.nOperterType = OPERATE_Moniter;
				}
			}
			if(::PeekMessage   (&message,NULL,0,0,PM_REMOVE)){		//响应其他事件 如Exit按钮操作
						::TranslateMessage   (&message);   
						::DispatchMessage   (&message);   
			}  

		}

		//发送权限操作
		if( pThread->m_Controller.nOperterType==OPERATE_Permit )
		{
			//获取权限个数
			strTemp.Format("%ld",wudp->GetPrivilegeNumFromRunInfo(bstrFrame) );
			strRunDetail = strRunDetail +  char(13) + char(10) + "权限数:        " +  char(9) + strTemp;

#if 1
			long privilegeIndex = 1;
			CString privilege;

			for( int nDoorIndex=1;nDoorIndex<5;nDoorIndex++ )
			{
				if( pThread->m_Controller.Card2Door[nDoorIndex].nCardCount>0 )
				{
					for( int nCardIndex=0;nCardIndex<pThread->m_Controller.Card2Door[nDoorIndex].nCardCount;nCardIndex++ )
					{
						long cardno = pThread->m_Controller.Card2Door[nDoorIndex].nCardNum[nCardIndex];
					
						privilege = ""; 
						bstrT = wudp->CardToStrHex(cardno);
						privilege = privilege + CString(bstrT);                  //卡号
 						bstrT = wudp->NumToStrHex(nDoorIndex, 1);
						privilege = privilege + CString(bstrT) ;                 //门号
						bstrT = wudp->MSDateYmdToWCDateYmd(A2BSTR("2007-8-14")) ;//有效起始日期
						privilege = privilege + CString(bstrT);                  
						bstrT = wudp->MSDateYmdToWCDateYmd(A2BSTR("2020-12-31"));//有效截止日期
						privilege = privilege + CString(bstrT) ;
						bstrT = wudp->NumToStrHex(1, 1)                 ;        //时段索引号
						privilege = privilege + CString(bstrT) ;
						bstrT = wudp->NumToStrHex(123456, 3)            ;        //用户密码
						privilege = privilege + CString(bstrT) ;
						bstrT = wudp->NumToStrHex(0, 4)                 ;        //备用4字节(用0填充)
						privilege = privilege + CString(bstrT) ;
						if (lstrlen(privilege) != (16 * 2))
						{
							//生成的权限不符合要求, 请查一下上一指令中写入的每个参数是否正确
							strInfo = strInfo + char(13) + char(10) + "生成的权限不符合要求: 添加权限失败" ;
						}

						while( true )
						{
							bstrT = wudp->NumToStrHex(0, 2)                 ;    //权限索引号 不是清空再添加时为空
							strTemp = "0711" + CString(bstrT) + privilege;
							bstrCmd = wudp->CreateBstrCommand(controllerSN, A2BSTR(strTemp)) ;  //生成指令帧 
							bstrFrame =( wudp -> udp_comm(bstrCmd, strIPAddr, atoi(pThread->m_Controller.sPort)));	        //发送指令, 并获取返回信息
							if (( ERROR_SUCCESS != wudp ->ErrCode)||(CString(bstrFrame)=="" )	)	
							{
								strInfo = strInfo + char(13) + char(10) + "添加权限失败" ;
								if( pThread->m_nErrorNum++>READ_ERROR_NUM )
								{
									pThread->m_Controller.nOperterType = OPERATE_Moniter;
									break;
								}
							}
							else
							{
								pThread->m_nErrorNum=0;
								privilegeIndex = privilegeIndex + 1;
								break;
							}
						}
						if(::PeekMessage   (&message,NULL,0,0,PM_REMOVE))
						{	//响应其他事件 如Exit按钮操作
							::TranslateMessage   (&message);   
							::DispatchMessage   (&message);   
						}   
					}
				}
			}

			CString timeseg;
			timeseg = "";
    		bstrT = wudp->NumToStrHex(0x1F, 1);
			timeseg = timeseg + CString(bstrT) ;   //星期控制
     		bstrT = wudp->NumToStrHex(0x00, 1);
			timeseg = timeseg + CString(bstrT) ;   // 下一链接时段(0--表示无)
    		bstrT = wudp->NumToStrHex(0x00, 2);
			timeseg = timeseg + CString(bstrT) ;   // 保留2字节(0填充)
    		bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("7:30:00"));
			timeseg = timeseg + CString(bstrT) ;   //  起始时分秒1
   			bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("12:30:00"));
			timeseg = timeseg + CString(bstrT) ;   //  终止时分秒1
    		bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("13:30:00"));
			timeseg = timeseg + CString(bstrT) ;   //  起始时分秒2
   			bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("17:30:00"));
			timeseg = timeseg + CString(bstrT) ;   //  终止时分秒2
    		bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("19:00:00"));
			timeseg = timeseg + CString(bstrT) ;   //  起始时分秒3
   			bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("21:00:00"));
			timeseg = timeseg + CString(bstrT) ;   //  终止时分秒3
    		bstrT = wudp->MSDateYmdToWCDateYmd(A2BSTR("2007-8-1"));
			timeseg = timeseg + CString(bstrT) ;   //  起始日期
   			bstrT = wudp->MSDateYmdToWCDateYmd(A2BSTR("2007-12-31"));
			timeseg = timeseg + CString(bstrT) ;   //  终止日期
    		bstrT = wudp->NumToStrHex(0x00, 4);
			timeseg = timeseg + CString(bstrT) ;   // 保留4字节(0填充)

			if (lstrlen(timeseg) != (24 * 2))
			{
				//生成的时段不符合要求, 请查一下上一指令中写入的每个参数是否正确
				strInfo = strInfo + char(13) + char(10) + "生成的时段不符合要求: 修改时段失败" ;
			}

			while( true )
			{
				bstrT = wudp->NumToStrHex(2, 2)  ;                                  //时段索引号2
				strTemp = "9710" + CString(bstrT) + timeseg;
				bstrCmd = wudp->CreateBstrCommand(controllerSN, A2BSTR(strTemp)) ;  //生成指令帧 
				bstrFrame = ( wudp -> udp_comm(bstrCmd, strIPAddr, atoi(pThread->m_Controller.sPort)));	        //发送指令, 并获取返回信息
				if (( ERROR_SUCCESS != wudp ->ErrCode)||(CString(bstrFrame)=="" ))	
				{
					strInfo = strInfo + char(13) + char(10) + "添加时段失败" ;
					if( pThread->m_nErrorNum++>READ_ERROR_NUM )
					{
						pThread->m_Controller.nOperterType = OPERATE_Moniter;
						break;
					}
				}
				else
				{
					pThread->m_nErrorNum = 0;
					strInfo = strInfo + char(13) + char(10) + "添加时段成功" ;
					break;
				}
			}
#else
			//先清空权限
			while( true )
			{
   				bstrCmd = wudp ->CreateBstrCommand(controllerSN, A2BSTR("9310")) ;  //生成指令帧 
				bstrFrame =  wudp -> udp_comm(bstrCmd, strIPAddr, atoi(pThread->m_Controller.sPort));	        //发送指令, 并获取返回信息
				if (( ERROR_SUCCESS != wudp ->ErrCode)||(CString(bstrFrame)=="" )	)	
				{
					strInfo = strInfo + char(13) + char(10) + "清空权限失败" ;
					if( pThread->m_nErrorNum++>READ_ERROR_NUM )
					{
						pThread->m_Controller.nOperterType = OPERATE_Moniter;
						break;
					}
				}
				else
				{
					pThread->m_nErrorNum = 0;
					strInfo = strInfo + char(13) + char(10) + "清空权限成功" ;
					break;
				}
			}

			//发送权限操作(2.再添加权限)
			//权限格式: 卡号（2）+区号（1）+门号（1）+卡起始年月日（2）+卡截止年月日（2）+ 控制时段索引号（1）+密码（3）+备用（4，用0填充）
			//发送权限按: 先发1号门(卡号小的先发), 再发2号门(卡号小的先发)
			//此案例中权限设为: 卡有效期从(2007-8-14 到2020-12-31), 采用默认时段1(任意时间有效), 缺省密码(1234), 备用值以00填充
			//以三个卡： 07217564 [9C4448]，342681[B9A603]，25409969[F126FE]为例，分别可以通过控制器的2个门。
			//实际使用按需修改
	        
			//!!!!!!!注意:  此处卡号已直接按从小到大排列赋值了. 实际使用中要用算法实现排序
			long privilegeIndex = 1;
			CString privilege;

			for( int nDoorIndex=1;nDoorIndex<5;nDoorIndex++ )
			{
				if( pThread->m_Controller.Card2Door[nDoorIndex].nCardCount>0 )
				{
					for( int nCardIndex=0;nCardIndex<pThread->m_Controller.Card2Door[nDoorIndex].nCardCount;nCardIndex++ )
					{
						long cardno = pThread->m_Controller.Card2Door[nDoorIndex].nCardNum[nCardIndex];
					
						privilege = ""; 
						bstrT = wudp->CardToStrHex(cardno);
						privilege = privilege + CString(bstrT);                  //卡号
 						bstrT = wudp->NumToStrHex(nDoorIndex, 1);
						privilege = privilege + CString(bstrT) ;                 //门号
						bstrT = wudp->MSDateYmdToWCDateYmd(A2BSTR("2007-8-14")) ;//有效起始日期
						privilege = privilege + CString(bstrT);                  
						bstrT = wudp->MSDateYmdToWCDateYmd(A2BSTR("2020-12-31"));//有效截止日期
						privilege = privilege + CString(bstrT) ;
						bstrT = wudp->NumToStrHex(1, 1)                 ;        //时段索引号
						privilege = privilege + CString(bstrT) ;
						bstrT = wudp->NumToStrHex(123456, 3)            ;        //用户密码
						privilege = privilege + CString(bstrT) ;
						bstrT = wudp->NumToStrHex(0, 4)                 ;        //备用4字节(用0填充)
						privilege = privilege + CString(bstrT) ;
						if (lstrlen(privilege) != (16 * 2))
						{
							//生成的权限不符合要求, 请查一下上一指令中写入的每个参数是否正确
							strInfo = strInfo + char(13) + char(10) + "生成的权限不符合要求: 添加权限失败" ;
						}

						while( true )
						{
							bstrT = wudp->NumToStrHex(privilegeIndex, 2)                 ;    //权限索引号
							strTemp = "9B10" + CString(bstrT) + privilege;
							bstrCmd = wudp->CreateBstrCommand(controllerSN, A2BSTR(strTemp)) ;  //生成指令帧 
							bstrFrame =( wudp -> udp_comm(bstrCmd, strIPAddr, atoi(pThread->m_Controller.sPort)));	        //发送指令, 并获取返回信息
							if (( ERROR_SUCCESS != wudp ->ErrCode)||(CString(bstrFrame)=="" )	)	
							{
								strInfo = strInfo + char(13) + char(10) + "添加权限失败" ;
								if( pThread->m_nErrorNum++>READ_ERROR_NUM )
								{
									pThread->m_Controller.nOperterType = OPERATE_Moniter;
									break;
								}
							}
							else
							{
								pThread->m_nErrorNum=0;
								privilegeIndex = privilegeIndex + 1;
								break;
							}
						}
						if(::PeekMessage   (&message,NULL,0,0,PM_REMOVE))
						{	//响应其他事件 如Exit按钮操作
							::TranslateMessage   (&message);   
							::DispatchMessage   (&message);   
						}   
					}
				}
			}

			CString timeseg;
			timeseg = "";
    		bstrT = wudp->NumToStrHex(0x1F, 1);
			timeseg = timeseg + CString(bstrT) ;   //星期控制
     		bstrT = wudp->NumToStrHex(0x00, 1);
			timeseg = timeseg + CString(bstrT) ;   // 下一链接时段(0--表示无)
    		bstrT = wudp->NumToStrHex(0x00, 2);
			timeseg = timeseg + CString(bstrT) ;   // 保留2字节(0填充)
    		bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("7:30:00"));
			timeseg = timeseg + CString(bstrT) ;   //  起始时分秒1
   			bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("12:30:00"));
			timeseg = timeseg + CString(bstrT) ;   //  终止时分秒1
    		bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("13:30:00"));
			timeseg = timeseg + CString(bstrT) ;   //  起始时分秒2
   			bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("17:30:00"));
			timeseg = timeseg + CString(bstrT) ;   //  终止时分秒2
    		bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("19:00:00"));
			timeseg = timeseg + CString(bstrT) ;   //  起始时分秒3
   			bstrT = wudp->MSDateHmsToWCDateHms(A2BSTR("21:00:00"));
			timeseg = timeseg + CString(bstrT) ;   //  终止时分秒3
    		bstrT = wudp->MSDateYmdToWCDateYmd(A2BSTR("2007-8-1"));
			timeseg = timeseg + CString(bstrT) ;   //  起始日期
   			bstrT = wudp->MSDateYmdToWCDateYmd(A2BSTR("2007-12-31"));
			timeseg = timeseg + CString(bstrT) ;   //  终止日期
    		bstrT = wudp->NumToStrHex(0x00, 4);
			timeseg = timeseg + CString(bstrT) ;   // 保留4字节(0填充)

			if (lstrlen(timeseg) != (24 * 2))
			{
				//生成的时段不符合要求, 请查一下上一指令中写入的每个参数是否正确
				strInfo = strInfo + char(13) + char(10) + "生成的时段不符合要求: 修改时段失败" ;
			}

			while( true )
			{
				bstrT = wudp->NumToStrHex(2, 2)  ;                                  //时段索引号2
				strTemp = "9710" + CString(bstrT) + timeseg;
				bstrCmd = wudp->CreateBstrCommand(controllerSN, A2BSTR(strTemp)) ;  //生成指令帧 
				bstrFrame = ( wudp -> udp_comm(bstrCmd, strIPAddr, atoi(pThread->m_Controller.sPort)));	        //发送指令, 并获取返回信息
				if (( ERROR_SUCCESS != wudp ->ErrCode)||(CString(bstrFrame)=="" ))	
				{
					strInfo = strInfo + char(13) + char(10) + "添加时段失败" ;
					if( pThread->m_nErrorNum++>READ_ERROR_NUM )
					{
						pThread->m_Controller.nOperterType = OPERATE_Moniter;
						break;
					}
				}
				else
				{
					pThread->m_nErrorNum = 0;
					strInfo = strInfo + char(13) + char(10) + "添加时段成功" ;
					break;
				}
			}
#endif
			pThread->m_Controller.nOperterType = OPERATE_Moniter;
		}

        //实时监控
       // 读取运行状态是实现监控的关键指令。 在进行监控时, 先读取最新记录索引位的记录. 读取到最新的记录， 同时可以获取到刷卡记录数。
       // 这时就可以用读取到刷卡记录数加1填充到要读取的最新记录索引位上，去读取运行状态， 以便获取下一个记录。
       // 如果读取到了新的刷卡记录， 就可以将索引位增1， 否则保持索引位不变。 这样就可以实现数据的实时监控。
       // 遇到通信不上的处理，这时可对串口通信采取超时400-500毫秒作为出错，可重试一次，再接收不到数据， 可认为设备与PC机间的不能通信。
	   __int64 watchIndex;
	   long recCnt;

       watchIndex = 0   ;                   //缺省从0, 表示先提取最近一个记录
       recCnt = 0       ;                   //监控记录计数

       while( pThread->m_Controller.nOperterType==OPERATE_Moniter )
	   {
			DWORD dwTicks = GetTickCount() - pThread->m_dwGetDoorStatusTicks;
			if(  dwTicks>=READ_DOORSTATUS_TIMESPACE )
			{
				bstrT = BSTR(L"811000000000");
				bstrCmd = wudp -> CreateBstrCommand(controllerSN, bstrT);	//生成指令帧 
				//strIPAddr = BSTR(L"");
				bstrFrame = wudp -> udp_comm(bstrCmd, strIPAddr, atoi(pThread->m_Controller.sPort) );	//发送指令, 并获取返回信息
				if (( ERROR_SUCCESS != wudp ->ErrCode)||(CString(bstrFrame)=="" )	)	
				{
				}
				else
				{
					int INDEX=0;

					__int64 lngRet = wudp->GetDoorStatusFromRunInfo(bstrFrame, 1);
					INDEX = 1;
					if (lngRet==1 && pThread->m_nDoorStatus[INDEX]!=lngRet )
					{
						pThread->m_nDoorStatus[INDEX] = lngRet;
						g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,INDEX,1 );
					}
					else if ( pThread->m_nDoorStatus[INDEX]!=lngRet )
					{
						pThread->m_nDoorStatus[INDEX] = lngRet;
						g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,INDEX,0 );
					}

					if( pThread->m_Controller.nDoorCount>1 )
					{
						lngRet = wudp->GetDoorStatusFromRunInfo(bstrFrame, 2);
						INDEX = 2;
						if (lngRet==1 && pThread->m_nDoorStatus[INDEX]!=lngRet )
						{
							pThread->m_nDoorStatus[INDEX] = lngRet;
							g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,INDEX,1 );
						}
						else if ( pThread->m_nDoorStatus[INDEX]!=lngRet )
						{
							pThread->m_nDoorStatus[INDEX] = lngRet;
							g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,INDEX,0 );
						}
					}
					if( pThread->m_Controller.nDoorCount>2 )
					{
						lngRet = wudp->GetDoorStatusFromRunInfo(bstrFrame, 3);
						INDEX = 3;
						if (lngRet==1 && pThread->m_nDoorStatus[INDEX]!=lngRet )
						{
							pThread->m_nDoorStatus[INDEX] = lngRet;
							g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,INDEX,1 );
						}
						else if ( pThread->m_nDoorStatus[INDEX]!=lngRet )
						{
							pThread->m_nDoorStatus[INDEX] = lngRet;
							g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,INDEX,0 );
						}

						lngRet = wudp->GetDoorStatusFromRunInfo(bstrFrame, 4);
						INDEX = 4;
						if (lngRet==1 && pThread->m_nDoorStatus[INDEX]!=lngRet )
						{
							pThread->m_nDoorStatus[INDEX] = lngRet;
							g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,INDEX,1 );
						}
						else if ( pThread->m_nDoorStatus[INDEX]!=lngRet )
						{
							pThread->m_nDoorStatus[INDEX] = lngRet;
							g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,INDEX,0 );
						}
					}
				}
				pThread->m_dwGetDoorStatusTicks = GetTickCount();
			}

		   //strTemp = "8110" + g_ReturnStr( watchIndex,6 );
		   //bstrT = sTemp.AllocSysString();
		    bstrT = wudp->NumToStrHex(watchIndex, 3) ;                          //表示第watchIndex个记录, 如果是0则取最新一条记录
			strTemp = "8110" + CString(bstrT);
			bstrCmd = wudp->CreateBstrCommand(controllerSN, A2BSTR(strTemp)) ;  //生成指令帧 
			bstrFrame =( wudp->udp_comm(bstrCmd, strIPAddr, atoi(pThread->m_Controller.sPort)));	        //发送指令, 并获取返回信息
			if (( ERROR_SUCCESS != wudp ->ErrCode)||(CString(bstrFrame)=="" )	)	
			{
			}
			else
			{
				pThread->m_nErrorNum=0;
				bstrSwipeDate = wudp->GetSwipeDateFromRunInfo(bstrFrame, &cardId, &status) ;
				if (CString(bstrSwipeDate) != "" )
				{
					int nIndex=0;
					CString sUserName,sClass,sJobNumber,sRemarks,sDoorName,sInOut;
					g_GetCardInfoByCardNumber( cardId,sUserName,sClass,sJobNumber,sRemarks );
					CString sTime,sCardID,sInfo,s;
					sInfo = g_GetStatus( pThread->m_Controller.nBrandType,cardId,status,nIndex );
					pThread->GetDoorNameAndInOutInfo( nIndex,sDoorName,sInOut );
					sCardID.Format( "%ld",cardId );	
					
					if( sUserName!="" && sClass!="" && sJobNumber!="" )
						sUserName.Format( "%s( %s-%s ) ",sUserName,sClass,sJobNumber );	
					else if( sUserName!="" && sClass!="" )
						sUserName.Format( "%s( %s ) ",sUserName,sClass );	
					else if( sUserName!="" && sJobNumber!="" )
						sUserName.Format( "%s( %s ) ",sUserName,sJobNumber );	

					sTime.Format("%s",CString(bstrSwipeDate)  );

					sDoorName = sInOut+sDoorName;
					
                    recIndex = recIndex + 1;             //下一条记录
				   if (watchIndex == 0)                  //如果收到第一条记录
				   {
						watchIndex = wudp->GetCardRecordCountFromRunInfo(bstrFrame);
						watchIndex =  watchIndex + 1;     //指向(总记录数+1), 也就是下次刷卡的存储索引位
				   }
				   else
				   {
						g_pDlgMain->m_pDlg_Moniter->InsertItemToList( " "+sTime," "+sCardID," "+sUserName," "+sDoorName," "+sInfo );

						watchIndex = watchIndex + 1 ;    //指向下一个记录位
				   }
					recCnt = recCnt + 1;                 //记录计数				}
				}
			}

			if(::PeekMessage   (&message,NULL,0,0,PM_REMOVE)){		//响应其他事件 如Exit按钮操作
				::TranslateMessage   (&message);   
				::DispatchMessage   (&message);   
			}   

			Sleep( 1000 );
	   }
		
	    if( pThread->m_Controller.nOperterType==OPERATE_NULL )
		{
			CoUninitialize();
			SysFreeString(strIPAddr); 
			wudp->Release();
			SetEvent( pThread->m_hRunObject );	
			pThread->m_bExitFinish = true;
			break;
		}

	}//while( 1 );//( WaitForSingleObject(pThread->m_hRunObject, 200L) == WAIT_TIMEOUT );

	return 0;
}

DWORD WINAPI CThread_Controller::Thread_JK( CThread_Controller *pThread )
{
	CString    strTemp;
	CString    strNewIPAddr;
	CString    strInfo;
	bool       bRet=false;
	//WriteLog( "Thread_TCP" );
	while( true )
	{
		bRet = pThread->JK_ConnetController( pThread->m_Controller.nWordMode,pThread->m_Controller.sIP,pThread->m_Controller.nComPort,pThread->m_Controller.ComPort );
		if( !bRet )	
		{
			if( pThread->m_nErrorNum++>READ_ERROR_NUM )
			{
				pThread->m_bExitFinish = true;
				g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,2 );
				g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ReConnect,false,pThread->m_Controller.sName );
				WriteLog("JK_ConnetController fail");
				return 0;
			}
		}
		else
		{
			pThread->m_Controller.LineID = 0;//g_nControllerOpenCount;
			g_nControllerOpenCount++;
			break;
		}
	}

	pThread->m_nErrorNum = 0;

	while( !g_bOK )
	{
		Sleep( 100 );
		if( pThread->m_nErrorNum++>READ_ERROR_NUM )
		{
			pThread->m_bExitFinish = true;
			g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,2 );
			g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ReConnect,false,pThread->m_Controller.sName );
			WriteLog("g_bOK=false");
			return 0;
		}
	}
	if( pThread->JK_IsOnline( pThread->m_Controller.nWordMode,pThread->m_Controller.LineID,pThread->m_Controller.ComPort,pThread->m_Controller.CtrlID ) )
	{
		pThread->m_nErrorNum = 0;
		pThread->m_bExitFinish = false;
		g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,0 );
		g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ReConnect,true,pThread->m_Controller.sName );
		g_bIsInsertReconnectInfo = false;
		WriteLog("JK_IsOnline ok");
	}
	else
	{
		pThread->m_bExitFinish = true;
		g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,2 );
		g_bIsInsertReconnectInfo = true;
		g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ReConnect,false,pThread->m_Controller.sName );
		WriteLog("JK_IsOnline fail");
		return 0;
	}

	do
	{
//		//设置门控制参数(在线/延时)[108F]
//		while( !pThread->m_bExitThread && pThread->m_Controller.nOperterType==OPERATE_ControlAndDelayTime )
//		{
//			for( int i=1;i<5;i++ )
//			{
//				if( pThread->m_Controller.bDoorIsSet[i] )
//				{
//					int nDoorControlType=pThread->m_Controller.nDoorControlType[i];
//					int nDoorDelayTime = pThread->m_Controller.nDoorDelayTime[i]*10;
//					
//					CString s;
//					s.Format( "8F10%02d%02d",i,nDoorControlType );
//					bstrT = wudp->NumToStrHex(nDoorDelayTime,2);
//					s += CString(bstrT);
// 					bstrCmd = wudp ->CreateBstrCommand(controllerSN, A2BSTR(s)) ;  //生成指令帧
//					bstrFrame = wudp -> udp_comm(bstrCmd, strIPAddr, 60000);	//发送指令, 并获取返回信息
//					if (( ERROR_SUCCESS != wudp ->ErrCode)||(CString(bstrFrame)=="" )	)	
//					{
//						if( pThread->m_nErrorNum++>READ_ERROR_NUM )
//						{
//							pThread->m_Controller.nOperterType = OPERATE_Moniter;
//							g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ControlAndDelayTime,false );
//							break;
//						}
//					}
//					else
//					{
//						pThread->m_nErrorNum = 0;
//						//完成把标志赋为实时监控
//						pThread->m_Controller.nOperterType = OPERATE_Moniter;
//						g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ControlAndDelayTime,true );
//						break;
//					}
//
//					break;
//				}
//			}
//		}
		//校准控制器时间
		while( !pThread->m_bExitThread && pThread->m_Controller.nOperterType==OPERATE_JustTime )
		{
			bRet = pThread->JK_AdjustTime( pThread->m_Controller.nWordMode,pThread->m_Controller.LineID,pThread->m_Controller.ComPort,pThread->m_Controller.CtrlID );
			if( !bRet )	
			{
				if( pThread->m_nErrorNum++>READ_ERROR_NUM )
				{
					pThread->m_Controller.nOperterType = OPERATE_Moniter;
					g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_JustTime,false );
					break;
				}
			}
			else
			{
				pThread->m_nErrorNum=0;
				pThread->m_Controller.nOperterType = OPERATE_Moniter;
				g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_JustTime,true );
				break;
			}
		}
//
//		//远程开门
//		while( !pThread->m_bExitThread && pThread->m_Controller.nOperterType==OPERATE_DoorOpen )
//		{
//			for( int i=1;i<5;i++ )
//			{
//				if( pThread->m_Controller.bDoorIsSet[i] )
//				{
//					CString s;
//					s.Format("9D10%02d",i );
// 					bstrCmd = wudp ->CreateBstrCommand(controllerSN, A2BSTR(s)) ;  //生成指令帧
//					bstrFrame = wudp -> udp_comm(bstrCmd, strIPAddr, 60000);	          //发送指令, 并获取返回信息
//					if (( ERROR_SUCCESS != wudp ->ErrCode)||(CString(bstrFrame)=="" )	)	
//					{
//						strInfo = strInfo + char(13) + char(10) + "远程开门失败" ;
//						if( pThread->m_nErrorNum++>READ_ERROR_NUM )
//						{
//							pThread->m_Controller.nOperterType = OPERATE_Moniter;
//							pThread->m_Controller.bDoorIsSet[i] = false;
//							g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_DoorOpen,false );
//							break;
//						}
//					}
//					else
//					{
//						pThread->m_nErrorNum = 0;
//						//完成把标志赋为实时监控
//						pThread->m_Controller.nOperterType = OPERATE_Moniter;
//						pThread->m_Controller.bDoorIsSet[i] = false;
//						g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_DoorOpen,true );
//						break;
//					}
//
//					break;
//				}
//			}
//		}
//
//		//提取记录
//        long recIndex;
//		recIndex = 1;
//        while( !pThread->m_bExitThread && pThread->m_Controller.nOperterType==OPERATE_Record )
//		{
//			bstrT = wudp->NumToStrHex(recIndex, 4);
//			strTemp = "8D10" + CString(bstrT);
//			bstrCmd = wudp ->CreateBstrCommand(controllerSN, A2BSTR(strTemp)) ;  //生成指令帧
//			bstrFrame = wudp -> udp_comm(bstrCmd, strIPAddr, 60000);	         //发送指令, 并获取返回信息
//			if (( ERROR_SUCCESS != wudp ->ErrCode)||(CString(bstrFrame)=="" )	)	
//			{
//				strInfo = strInfo + char(13) + char(10) + "提取记录出错" ;
//				if( pThread->m_nErrorNum++>READ_ERROR_NUM )
//				{
//					pThread->m_Controller.nOperterType = OPERATE_Moniter;
//					break;
//				}
//			}
//			else
//			{
//				pThread->m_nErrorNum=0;
//				bstrSwipeDate = wudp->GetSwipeDateFromRunInfo(bstrFrame, &cardId, &status) ;
//				if (CString((bstrSwipeDate)) != "" )
//				{
//					int nIndex=0;
//					CString sUserName,sClass,sJobNumber,sRemarks,sDoorName,sInOut;
//					g_GetCardInfoByCardNumber( cardId,sUserName,sClass,sJobNumber,sRemarks );
//					CString sTime,sCardID,sInfo,s;
//					sInfo = g_GetStatus( cardId,status,nIndex );
//					pThread->GetDoorNameAndInOutInfo( nIndex,sDoorName,sInOut );
//					sCardID.Format( "%s(%s-%s-%ld) ",sUserName,sClass,sJobNumber,cardId );	
//					sTime.Format("%s",CString(bstrSwipeDate)  );
//					
//					sDoorName = sInOut+sDoorName;
//					
//					ADOCtrl.InsertRecord( sTime,sCardID,sDoorName,sInfo );
//					
//					recIndex = recIndex + 1;                        //下一条记录
//				}
//				else
//				{
//					strTemp.Format("%ld", (recIndex-1));
//					strInfo = strInfo + char(13) + char(10) + "提取记录完成. 总共提取记录数 =" + strTemp;
//
//					if (recIndex > 1)   //只有提取了记录才进行删除
//					{
//						while( true )
//						{
//							bstrT = wudp->NumToStrHex(recIndex-1, 4);
//							strTemp = "8E10" + CString(bstrT);
//   							bstrCmd = wudp ->CreateBstrCommand(controllerSN, A2BSTR(strTemp)) ;  //生成指令帧
//							bstrFrame = wudp -> udp_comm(bstrCmd, strIPAddr, 60000);	         //发送指令, 并获取返回信息
//							if (( ERROR_SUCCESS != wudp ->ErrCode)||(CString(bstrFrame)==""))	
//							{
//								strInfo = strInfo + char(13) + char(10) + "删除记录失败" ;
//								if( pThread->m_nErrorNum++>READ_ERROR_NUM )
//								{
//									pThread->m_Controller.nOperterType = OPERATE_Moniter;
//									break;
//								}
//							}
//							else
//							{
//								pThread->m_nErrorNum = 0;
//								strInfo = strInfo + char(13) + char(10) + "删除记录成功";
//								break;
//							}
//						}
//					}
//
//					pThread->m_Controller.nOperterType = OPERATE_Moniter;
//				}
//			}
//			if(::PeekMessage   (&message,NULL,0,0,PM_REMOVE)){		//响应其他事件 如Exit按钮操作
//						::TranslateMessage   (&message);   
//						::DispatchMessage   (&message);   
//			}  
//
//		}
//
		//发送权限操作(1.先清空权限)
		if( pThread->m_Controller.nOperterType==OPERATE_Permit )
		{
			while( true )
			{
   				bRet = pThread->JK_DelPermit( pThread->m_Controller.nWordMode,pThread->m_Controller.LineID,pThread->m_Controller.ComPort,pThread->m_Controller.CtrlID );
				if( !bRet )		
				{
					if( pThread->m_nErrorNum++>READ_ERROR_NUM )
					{
						pThread->m_Controller.nOperterType = OPERATE_Moniter;
						break;
					}
				}
				else
				{
					pThread->m_nErrorNum = 0;
					break;
				}
			}

			while( true )
			{
				bRet = pThread->JK_SetPermit( pThread->m_Controller.nWordMode,pThread->m_Controller.LineID,pThread->m_Controller.ComPort,pThread->m_Controller.CtrlID );
				if( !bRet )	
				{
					if( pThread->m_nErrorNum++>READ_ERROR_NUM )
					{
						pThread->m_Controller.nOperterType = OPERATE_Moniter;
						break;
					}
				}
				else
				{
					pThread->m_nErrorNum=0;
					break;
				}
			}

			pThread->m_Controller.nOperterType = OPERATE_Moniter;
		}

        //实时监控

     while( !pThread->m_bExitThread && pThread->m_Controller.nOperterType==OPERATE_Moniter )
	   {
		   if( !pThread->m_bExitFinish )
				bRet = pThread->JK_GetEvents( pThread->m_Controller.nWordMode,pThread->m_Controller.LineID,pThread->m_Controller.ComPort,pThread->m_Controller.CtrlID );
		   Sleep( 200 );
	   }

	    if( pThread->m_Controller.nOperterType==OPERATE_NULL )
		   break;

	}while( WaitForSingleObject(pThread->m_hRunObject, 200L) == WAIT_TIMEOUT );


	return 0;
}
bool CThread_Controller::JK_ConnetController( int iWordMode,CString sIP,long nPort,int iPort )
{
	TOnConnect FOnConnect;// 声明函数指针变量 	
	TOnDisConnect FOnDisConnect;
	
	FOnConnect = (TOnConnect)MYOnConnect;

	FOnDisConnect = (TOnDisConnect)MYOnDisConnect;
	
	DLLFunNT_SetCallbackFun  NT_SetCallbackFun = (DLLFunNT_SetCallbackFun)GetProcAddress(hACSDLL,"NT_SetCallbackFun");
	
    if (NT_SetCallbackFun(FOnConnect, FOnDisConnect, NULL, NULL))
    {
		int at=0;
	}
	else
	{
		int ab=0;
	}

	if( iWordMode==1 )//tcp
	{
		if ((!hACSDLL) || (sIP == "")) return false;
		
		DLLFunNT_OpenConnect NT_OpenConnect = (DLLFunNT_OpenConnect)GetProcAddress(hACSDLL,"NT_OpenConnect");
		if (NT_OpenConnect((LPCSTR)sIP, nPort, NULL, 0))
		{
			//m_Mylist.InsertString(m_Mylist.GetCount(),"Connected Success");	
			//m_cLine.AddString(localip); 
			//LineType =1;
		//	LineID = ((CComboBox*)GetDlgItem(IDC_COMBO1))->GetCount() +1;
			return true;
		}
		else
		{
			return false;
		}
	}
	else
	{
		if (!hACSDLL) return false;
		//Get the procedure Address 取得入口地址
		DllFunOpenComm OpenComm = (DllFunOpenComm)GetProcAddress(hACSDLL,"OpenComm");
		
		if (!OpenComm) return false;
		
		if (OpenComm(iPort))
		{  
				return true;
		}
		else
		{
				return false;
		}
	}

	return true;
}
bool CThread_Controller::JK_GetModel( int iWordMode,int iLineID,int iPort,int iCtrlID )
{
	if (!hACSDLL) return false;
	
	DLLFunGetModel  JK_GetModel = (DLLFunGetModel)GetProcAddress(hACSDLL,"JK_GetModel");	
	DLLFunNT_GetModel  NT_GetModel = (DLLFunNT_GetModel)GetProcAddress(hACSDLL,"NT_GetModel");	

	memset(&m_Controller.rModel, 0, sizeof(TModel));
	int iRet;

	if (0==iWordMode)//Com Communication
	{
		iRet = JK_GetModel(iPort, iCtrlID, &m_Controller.rModel);
	}
	else
	{
		iRet = NT_GetModel(iLineID, iCtrlID, &m_Controller.rModel);
	}
	if (iRet != 0)
	{
		CString str;
		str.Format("iWordMode=%d,iLineID=%d,iCtrlID=%d   NT_GetModel fail",iWordMode,iLineID,iCtrlID );
		//WriteLog(str);
		return false;
	}
	else
	{
		CString str;
		str.Format("iWordMode=%d,iLineID=%d,iCtrlID=%d   NT_GetModel OK",iWordMode,iLineID,iCtrlID );
		//WriteLog(str);
	}
//	m_model.SetWindowText(rModel.Model);
//	memset(tmp, 0, 10);
//	memcpy(tmp, rModel.Version, 6);
//	m_ver.SetWindowText(tmp);
//
//	m_Mylist.InsertString(m_Mylist.GetCount(),"Get Model success");
//	
//	CString str1; 
//	str1.Format("model:%s",rModel.Model);
//
////	CString str ;
//	str.Format(" Ver:%s",rModel.Version);
//
//	m_Mylist.InsertString(m_Mylist.GetCount(), str1 + str);
//
	DLLFunGetDoorCount GetDoorCount = (DLLFunGetDoorCount)GetProcAddress(hACSDLL,"GetDoorCount");	
	iRet = GetDoorCount(&m_Controller.rModel);
	if (iRet)
	{
		//str.Format("%d", iRet);
		//m_DoorCount.SetWindowText (str);
	}

	//UpdateData(true);

	return true;
}

bool CThread_Controller::JK_IsOnline( int iWordMode,int iLineID,int iPort,int iCtrlID )
{
	if (!hACSDLL) return false;	
	int iRet;

	int COUNT=0;
	bool f = JK_GetModel( iWordMode,iLineID,iPort,iCtrlID );
	while( !f )
	{
		if( COUNT++>=READ_ERROR_NUM )
		{
			CString str;
			str.Format("iWordMode=%d,iLineID=%d,iCtrlID=%d   NT_GetModel fail",iWordMode,iLineID,iCtrlID );
			//WriteLog(str);
			return false;
		}
		Sleep( 100 );
		f = JK_GetModel( iWordMode,iLineID,iPort,iCtrlID );
	}
	
	if (0==iWordMode)//Com Communication
	{
		DLLFunOnLine  OnLine = (DLLFunOnLine)GetProcAddress(hACSDLL,"OnLine");	
		iRet = OnLine(iPort, iCtrlID);
	}
	else
	{
		DLLFunNT_OnLine  NT_OnLine = (DLLFunNT_OnLine)GetProcAddress(hACSDLL,"NT_OnLine");
		iRet = NT_OnLine(iLineID, iCtrlID);	
	}

	if (iRet != GDR_OK)
	{
		return false;
	}

	return true;
}
bool CThread_Controller::JK_DisconnetController( int iWordMode,int iLineID,int iPort )
{
	if( iWordMode==1 )//tcp
	{
		DLLFunNT_CloseConnect NT_CloseConnect = (DLLFunNT_CloseConnect)GetProcAddress(hACSDLL,"NT_CloseConnect");
		if (!NT_CloseConnect) return false;
		
		if (NT_CloseConnect(iLineID))
		{
			return true;
		}
	}
	else
	{
		if (!hACSDLL) return false;
		DLLFunCloseComm CloseComm = (DLLFunCloseComm)GetProcAddress(hACSDLL,"CloseComm");
		if (!CloseComm) return false;
		if (iPort>0)
		{
			//调用 
			BOOL rbool = CloseComm(iPort);    
			if (rbool)
			{
			//	m_Mylist.InsertString(m_Mylist.GetCount(),"Close Success");	
			//	CString str;
			//	m_Combo1.GetLBText(ComPort, str);
		
			//	int i =((CComboBox*)GetDlgItem(IDC_COMBO1))->FindString(-1, str);
			//	((CComboBox*)GetDlgItem(IDC_COMBO1))->DeleteString(i);
			////	for (int i=0; i<iCount; i++)
			//	ComPort = 0;
				return true;
			}
			//m_Mylist.InsertString(m_Mylist.GetCount(),"Close false");
		}
	}

	return true;
}
bool CThread_Controller::JK_AdjustTime( int iWordMode,int iLineID,int iPort,int iCtrlID )
{
	int iRet;
	if (!iWordMode) //Com	
	{
		DLLFunSetTime SetTime = (DLLFunSetTime)GetProcAddress(hACSDLL,"SetTime");
		
		iRet = SetTime(iPort, iCtrlID);
	}
	else//  TCP/IP
	{
		DLLFunNT_SetTime NT_SetTime = (DLLFunNT_SetTime)GetProcAddress(hACSDLL,"NT_SetTime");
		
		iRet =  NT_SetTime(iLineID, iCtrlID); 
	}
	
	if ( iRet == GDR_RECOK)
	{
		//m_Mylist.InsertString(m_Mylist.GetCount(),"Download system time succeed!");
		return true;
	}
	//m_Mylist.InsertString(m_Mylist.GetCount(),"Download system time false!");

	return false;
}
bool CThread_Controller::JK_SetPermit( int iWordMode,int iLineID,int iPort,int iCtrlID )
{
	TGroupCard *pCard, *pNext;
	WORD Offset,GroupCount=0;
	int iRet , i;
	DWORD TestCards[5000];

	DLLFunSetCardReg SetCardReg =  (DLLFunSetCardReg)GetProcAddress(hACSDLL,"SetCardReg");
	DLLFunNT_SetCardReg NT_SetCardReg =  (DLLFunNT_SetCardReg)GetProcAddress(hACSDLL,"NT_SetCardReg");

	for( int nDoorIndex=1;nDoorIndex<2;nDoorIndex++ )
	{
		for( int nCardIndex=0;nCardIndex<m_Controller.Card2Door[nDoorIndex].nCardCount;nCardIndex++ )
		{
			long cardno = m_Controller.Card2Door[nDoorIndex].nCardNum[nCardIndex];
			TestCards[GroupCount++] = cardno;
		}
	}

	Offset = 0;
	
	pCard = new TGroupCard[sizeof(TGroupCard) * GroupCount];

	pNext = pCard;
    for (i= 0 ;i< GroupCount; i++)
    {
      pNext->CardNumber.dwCardNo = TestCards[i];
      pNext->wCardCount =1;           //a group only have a card.
      if (i != GroupCount - 1)
         pNext->pNext = PGroupCard(DWORD(pNext) + sizeof(TGroupCard));
      else
        pNext->pNext =NULL;
    }

	if (!iWordMode)
	{
		iRet =SetCardReg(iPort, iCtrlID, Offset, GroupCount, pCard);
	}
	else
	{
		iRet = NT_SetCardReg(iLineID, iCtrlID, Offset, GroupCount, pCard);
	}
	
	if (iRet == GDR_RECOK )
	{
		//m_Mylist.InsertString(m_Mylist.GetCount(),"Set Card List  success");
		
	}
	else
	{
		//m_Mylist.InsertString(m_Mylist.GetCount(),"Set Card List fail! ");
		//return;	
	}

	delete []pCard;

	return true;
}
bool CThread_Controller::JK_DelPermit( int iWordMode,int iLineID,int iPort,int iCtrlID )
{
	int iRet;

	DLLFunDelCards DelCards =  (DLLFunDelCards)GetProcAddress(hACSDLL,"DelCards");
    DLLFunNT_DelCards NT_DelCards=(DLLFunNT_DelCards)GetProcAddress(hACSDLL,"NT_DelCards");

	if (!iWordMode)
		iRet = DelCards(iPort, iCtrlID, 0, CON_MAXCARD);
	else
	   iRet = NT_DelCards(iLineID, iCtrlID, 0, CON_MAXCARD);

	if (iRet == GDR_RECOK )
	{
		//m_Mylist.InsertString(m_Mylist.GetCount(),"Clear Card Register succeed");
		
	}
	else
	{
		//m_Mylist.InsertString(m_Mylist.GetCount(),"Clear Card Register  fail! ");
	}

	return true;
}
bool CThread_Controller::JK_GetEvents( int iWordMode,int iLineID,int iPort,int iCtrlID ) 
{
	int nRet = -1;
	PEvent lpEvent, lpNext;
	BYTE BagID;
	BYTE EventCount;
	int iRet, i;
	CString stmp, sdate ,str;

	WORD itmp = sizeof(TEvent)* CON_MAXEVENTCOUNTOFBAG ;

	lpEvent = new TEvent[itmp];

	BagID = m_Controller.SEventBagId;
	EventCount = m_Controller.SEventCount;
	

	if (!iWordMode) //Com
	{
		DLLFunGetEvent GetEvent = (DLLFunGetEvent)GetProcAddress(hACSDLL,"GetEvent");
		iRet = GetEvent(iPort, iCtrlID,  &BagID, &EventCount, lpEvent);
	}
	else
	{
		DLLFunNT_GetEvent NT_GetEvent = (DLLFunNT_GetEvent)GetProcAddress(hACSDLL,"NT_GetEvent");
		iRet = NT_GetEvent(iLineID, iCtrlID,  &BagID, &EventCount, lpEvent);
	}
	
	if (iRet == GDR_OK)
	{
		m_Controller.SEventBagId = BagID;             //Save event package number for next time
		m_Controller.SEventCount = EventCount;        //Save event count for next time
		
		str.Format("%d", BagID);
		CString str1;
		str1.Format("%d", EventCount);
		//m_Mylist.InsertString(m_Mylist.GetCount(),"Bag ID: " + str + "EventCount:" + str1);
		
		lpNext = lpEvent;
		
		for (i=0; i<EventCount; i++)
		{
			if (!lpNext) break;
			stmp.Format("%d",i);
				
			int nIndex=0;
			CString sUserName,sClass,sJobNumber,sRemarks,sDoorName,sInOut;
			g_GetCardInfoByCardNumber( lpNext->CardNumber.dwCardNo,sUserName,sClass,sJobNumber,sRemarks );
			CString sTime,sCardID,sInfo,s;
			sInfo = g_GetStatus( m_Controller.nBrandType,lpNext->CardNumber.dwCardNo,lpNext->Code,nIndex );
			GetDoorNameAndInOutInfo( lpNext->DotID,sDoorName,sInOut );
			//sCardID.Format( "%s(%s-%s-%08d) ",sUserName,sClass,sJobNumber,lpNext->CardNumber.dwCardNo );
			sCardID.Format( "%08d",lpNext->CardNumber.dwCardNo );	
			if( sUserName!="" )
				sUserName.Format( "%s( %s-%s ) ",sUserName,sClass,sJobNumber );	

			SYSTEMTIME  st;
			st = lpNext->Time;
			sTime.Format("%d-%02d-%02d %02d:%02d:%02d",st.wYear,   st.wMonth,   st.wDay,   st.wHour,   st.wMinute,   st.wSecond);   

			sDoorName = sInOut+sDoorName;
			
			if( lpNext->DotID==1 && lpNext->CardNumber.dwCardNo>100000 )
			{
				g_pDlgMain->m_pDlg_Moniter->InsertItemToList( " "+sTime," "+sCardID," "," "+sDoorName," "+sInfo );
				//ADOCtrl.InsertRecord( sTime,sCardID,sUserName,sDoorName,sInfo );
			}
			else if( lpNext->DotID==96 && sInfo=="离开按钮开门" )
			{
				g_pDlgMain->m_pDlg_Moniter->InsertItemToList( " "+sTime," "," "," "," "+sInfo );
				//ADOCtrl.InsertRecord( sTime,"","","",sInfo );
			}

			lpNext = lpNext->pNext;	
		}
	}
	else if (iRet == GDR_UPLOADOK)
	{
		//m_Mylist.InsertString(m_Mylist.GetCount(),"No Data!");
		m_Controller.SEventBagId = 0;
		m_Controller.SEventCount = 0;
	}
	else
	{
		if( iRet==-1 )
		{
			if( lpEvent )
			{
				delete lpEvent;	
				lpEvent = NULL;
			}
			
			if( m_bExitThread )
				m_bExitFinish = true;
			else
			{
				WriteLog( "WM_RECONNECT" );
				SendMessage( g_pDlgMain->GetSafeHwnd(),WM_RECONNECT,(WPARAM)m_Controller.sName.GetBuffer(m_Controller.sName.GetLength()),0 );
				m_Controller.sName.ReleaseBuffer();
			}

			return true;
		}
	}	

	if( lpEvent )
	{
		delete lpEvent;	
		lpEvent = NULL;
	}

	if( m_bExitThread )
		m_bExitFinish = true;

	return true;
}
DWORD WINAPI CThread_Controller::Thread_ZK( CThread_Controller *pThread )
{
	MSG   message;   
	CString    strTemp;

	if( pThread->m_Controller.sPort=="" )
		pThread->m_Controller.sPort = "4370";

	while( true )
	{
		bool bRet = false;

		if( pThread->m_Controller.nWordMode==0 )
			bRet = g_pDlgMain->m_pDlgZK->Connect_Com( pThread->m_Controller.sSN, pThread->m_Controller.nComPort );
		else
			bRet = g_pDlgMain->m_pDlgZK->Connect_Net( pThread->m_Controller.sSN, pThread->m_Controller.sIP,pThread->m_Controller.sPort );

		if ( !bRet )	
		{
			//if( pThread->m_nErrorNum++>1 )
			{
				pThread->m_bExitFinish = true;
				g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,2 );
				g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ReConnect,false,pThread->m_Controller.sName );
				return 0;
			}
		}
		else
			break;
	}

	pThread->m_nErrorNum = 0;
	pThread->m_bExitFinish = false;
	g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,0 );
	g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ReConnect,true,pThread->m_Controller.sName );

	do//while( 1 )
	{
		//设置门控制参数(在线/延时)[108F]
		while( pThread->m_Controller.nOperterType==OPERATE_ControlAndDelayTime )
		{
			//if( pThread->m_Controller.bDoorIsSet[i] )
			//{
			//	int nDoorControlType=pThread->m_Controller.nDoorControlType[i];
			//	int nDoorDelayTime = pThread->m_Controller.nDoorDelayTime[i]*10;
			//	
			//	CString s;
			//	s.Format( "8F10%02d%02d",i,nDoorControlType );
			//	bstrT = wudp->NumToStrHex(nDoorDelayTime,2);
			//	s += CString(bstrT);
 		//		bstrCmd = wudp ->CreateBstrCommand(controllerSN, A2BSTR(s)) ;  //生成指令帧
			//	bstrFrame = wudp -> udp_comm(bstrCmd, strIPAddr, 60000);	//发送指令, 并获取返回信息
			//	if (( ERROR_SUCCESS != wudp ->ErrCode)||(CString(bstrFrame)=="" )	)	
			//	{
			//		if( pThread->m_nErrorNum++>READ_ERROR_NUM )
			//		{
			//			pThread->m_Controller.nOperterType = OPERATE_Moniter;
			//			g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ControlAndDelayTime,false );
			//			break;
			//		}
			//	}
			//	else
			//	{
			//		pThread->m_nErrorNum = 0;
			//		//完成把标志赋为实时监控
			//		pThread->m_Controller.nOperterType = OPERATE_Moniter;
			//		g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_ControlAndDelayTime,true );
			//		break;
			//	}
		}
		//校准控制器时间
		while( pThread->m_Controller.nOperterType==OPERATE_JustTime )
		{
			bool bRet = g_pDlgMain->m_pDlgZK->SetDeviceTime( pThread->m_Controller.sSN );

			if( !bRet )	
			{
				if( pThread->m_nErrorNum++>5 )
				{
					pThread->m_Controller.nOperterType = OPERATE_Moniter;
					g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_JustTime,false );
					break;
				}
			}
			else
			{
				pThread->m_nErrorNum=0;
				pThread->m_Controller.nOperterType = OPERATE_Moniter;
				g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_JustTime,true );
				break;
			}
		}

		//远程开门
		while( pThread->m_Controller.nOperterType==OPERATE_DoorOpen )
		{
			bool bBreak = false;
			for( int i=1;i<5;i++ )
			{
				if( pThread->m_Controller.bDoorIsSet[i] )
				{
					bBreak = true;
					bool bRet = g_pDlgMain->m_pDlgZK->OpenDoor( pThread->m_Controller.sSN );
					if( !bRet )	
					{
						if( pThread->m_nErrorNum++>5 )
						{
							pThread->m_Controller.nOperterType = OPERATE_Moniter;
							pThread->m_Controller.bDoorIsSet[i] = false;
							g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_DoorOpen,false );
							break;
						}
					}
					else
					{
						pThread->m_nErrorNum = 0;
						//完成把标志赋为实时监控
						pThread->m_Controller.nOperterType = OPERATE_Moniter;
						pThread->m_Controller.bDoorIsSet[i] = false;
						g_pDlgMain->m_pDlg_Moniter->InsertItemToList( OPERATE_DoorOpen,true );
						break;
					}
				}
			}
			if( bBreak )
				break;
		}

        //实时监控
       while( pThread->m_Controller.nOperterType==OPERATE_Moniter )
	   {
			//CString sShow;
			//sShow.Format( "%s  实时监控 1",pThread->m_Controller.sName );
			//WriteLog( sShow );
			DWORD dwTicks = GetTickCount() - pThread->m_dwGetDoorStatusTicks;
			if(  dwTicks>=READ_DOORSTATUS_TIMESPACE )
			{
				int nStatus=0,INDEX=0;

				if( g_pDlgMain->m_pDlgZK->GetDoorState(pThread->m_Controller.sSN,nStatus) )
				{
					INDEX = 1;
					if (nStatus==1 && pThread->m_nDoorStatus[INDEX]!=nStatus )
					{
						pThread->m_nDoorStatus[INDEX] = nStatus;
						g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,1,1 );
					}
					else if ( pThread->m_nDoorStatus[INDEX]!=nStatus )
					{
						pThread->m_nDoorStatus[INDEX] = nStatus;
						g_pDlgMain->m_pDlg_Moniter->AddDoorToList( pThread->m_Controller.sName,1,0 );
					}
				}
				
				if( pThread->m_Controller.nDoorCount>1 )
				{
					
				}
				if( pThread->m_Controller.nDoorCount>2 )
				{
					
				}

				pThread->m_dwGetDoorStatusTicks = GetTickCount();
			}

			if( g_pDlgMain->m_pDlgZK->ReadRTLog(pThread->m_Controller.sSN) && g_pDlgMain->m_pDlgZK->m_bNewRecord )
			{
				g_pDlgMain->m_pDlgZK->m_bNewRecord = false;

				int nIndex=0;
				long cardId = g_pDlgMain->m_pDlgZK->m_nCardNum; 
				int status = g_pDlgMain->m_pDlgZK->m_nIsInValid;
				CString sUserName,sClass,sJobNumber,sRemarks,sDoorName,sInOut;
				g_GetCardInfoByCardNumber( cardId,sUserName,sClass,sJobNumber,sRemarks );
				CString sTime,sCardID,sInfo,s;
				sInfo = g_GetStatus( pThread->m_Controller.nBrandType,cardId,status,nIndex );
				pThread->GetDoorNameAndInOutInfo( nIndex,sDoorName,sInOut );
				sCardID.Format( "%ld",cardId );	
				
				if( sUserName!="" && sClass!="" && sJobNumber!="" )
					sUserName.Format( "%s( %s-%s ) ",sUserName,sClass,sJobNumber );	
				else if( sUserName!="" && sClass!="" )
					sUserName.Format( "%s( %s ) ",sUserName,sClass );	
				else if( sUserName!="" && sJobNumber!="" )
					sUserName.Format( "%s( %s ) ",sUserName,sJobNumber );	

				sTime.Format("%s",g_pDlgMain->m_pDlgZK->m_sTime  );

				sDoorName = sInOut+sDoorName;

				if( sTime.GetLength()<10 && status==1 )
				{
					SYSTEMTIME st;
					::GetLocalTime( &st );
					sTime.Format( "%d-%02d-%02d %02d:%02d:%02d",st.wYear,st.wMonth,st.wDay,st.wHour,st.wMinute,st.wSecond );
				}

				if( sCardID=="0" )
				{
					sCardID = "";
				}

				g_pDlgMain->m_pDlg_Moniter->InsertItemToList( " "+sTime," "+sCardID," "+sUserName," "+sDoorName," "+sInfo );
			}

			//if(::PeekMessage   (&message,NULL,0,0,PM_REMOVE)){		//响应其他事件 如Exit按钮操作
			//	::TranslateMessage   (&message);   
			//	::DispatchMessage   (&message);   
			//}   

			//sShow.Format( "%s  实时监控 2",pThread->m_Controller.sName );
			//WriteLog( sShow );
			//Sleep( 1000 );
	   }

		if( pThread->m_Controller.nOperterType==OPERATE_NULL )
		{
			g_pDlgMain->m_pDlgZK->Disconnect(pThread->m_Controller.sSN);
			//SetEvent( pThread->m_hRunObject );	
			pThread->m_bExitFinish = true;
			break;
		}

	}while( WaitForSingleObject( pThread->m_hRunObject, 200L ) == WAIT_TIMEOUT );

	return 0;
}