repos_ecs/Service_1.0.0.5/Service/MainPro.cpp

#include "stdafx.h"
#include "ascprocess.h"
#include "Global.h"
#include "struct.h"
#include "MainPro.h"
#include "rtuprocess.h"
#include "tcpprocess.h"
#include "icpdasprocess.h"
#include "SnmpProcess.h"
#include "upsParadigmProcess.h"
#include "stulzprocess.h"
#include "NoticeQueue.h"
#include "PowerwareProcess.h"
#include "greeprocess.h"
#include "CarelProcess.h"
#include "Client2SrvType.h"
#include "SysLib.h"
#include "Separate.h"
#include "MostDevice.h"
#include "Const.h"
#include "ping.h"
#include "CheckDog.h"
#include "shlwapi.h"

int g_nRecordDataMaxID = -1;//数据记录表的最大行值
int g_nHourToCount = 0;//多少个小时增加一次使用次数
CRITICAL_SECTION g_csDevOnlineReadOneData;
#define		DATA_CHANGE_FLAG		0.01//0.00001


/************************************************************************/
#if IS_USER_MUL_THREAD_REQUEST	// 开关:是否每个串口都独立一个线程采集数据;
HANDLE g_hRequestDataThread[MAX_DLL_TYPE] = {0};		// 串口线程句柄值;
CString g_strPort[MAX_DLL_TYPE];						// 串口线程串口号;
#else
HANDLE g_hRequestDataThread = NULL;
#endif

HANDLE g_hReConnectCommThread = NULL;					// 串口重连线程;

INT g_nRequestDataThreadCount = 0;						// 串口线程数;

INT g_nTimingSendFinished = 0;
HANDLE g_hTimingSendSmsThread = NULL;
HANDLE g_hSoftRegisterThread = NULL;
HANDLE g_hGetBlanceThread = NULL;
HANDLE g_hDevOnlineThread = NULL;
HANDLE g_hInsertDBThread = NULL;
HANDLE g_hVoiceNoticeThread = NULL;
HANDLE g_hOutputThread = NULL;
HANDLE g_hGetDatePlanThread = NULL;

// 以下,都是g_hRequestDataThread的索引;
// ●建议:如果每个设备都预留100,那在初始化该数组时,会产生多少用不着的内存?有什么办法可以精确到一个范围的创建该数组;
INT g_nRtuThreadIndex = RTU_THREAD_START;			//预留100个Modbus Rtu设备，每个串口一个处理线程
INT g_nAscThreadIndex = ASC_THREAD_START;			//预留100个Modbus Asc设备，每个串口一个处理线程
INT g_nTcpThreadIndex = TCP_THREAD_START;			//预留100个Modbus Tcp设备，每个IP一个处理线程
INT g_nSnmpThreadIndex = SNMP_THREAD_START;			//预留200个Snmp设备，每个IP一个处理线程
INT g_nMostDeviceIndex = MOSTDEVICE_THREAD_START;	//预留100个MostDevice类型有设备，每个IP一个处理线程
INT g_nIcpdasIndex = ICPDAS_THREAD_START;			//预留10个泓格设备，每个串口一个处理线程
INT g_nParadigmIndex = PARADIGM_THREAD_START;		//预留10个Paradigm设备，每个串口一个处理线程
INT g_nStulzIndex = STULZ_THREAD_START;				//预留10个Stulz设备，每个串口一个处理线程

INT g_nPowerwareIndex = POWERWARE_THREAD_START;		//预留10个Powerware设备，每个串口一个处理线程
INT g_nGreeIndex = GREE_THREAD_START;				//预留10个Gree设备，每个串口一个处理线程
INT g_nCarelIndex = CAREL_THREAD_START;				//预留10个Carel设备，每个串口一个处理线程
INT g_nScantakIndex = SCANTAK_THREAD_START;			//预留10个Scantak设备，每个串口一个处理线程
INT g_nDeltaIndex = DELTA_THREAD_START;				//预留10个Delta设备，每个串口一个处理线程



/************************************************************************/
// 该结构体用于网络设备(eg: SNMP设备,TCP设备);
typedef struct __TCP_THREAD_STRUCT
{
	int nTcpTheadIndex;		// 每一个网络设备对应的一个线程ID索引;(每一个ip就一个线程)
	CString strUid;			// 与索引相联的网络设备UID;
}TcpThreadStruct;

INT g_nTcpThreadStructIndex = 0;		// 供g_tcpThreadStruct数组使用,下标号;
TcpThreadStruct g_tcpThreadStruct[MAX_TCP_THREAD];
/************************************************************************/

DWORD WINAPI RequestDataThreadProc(void *pPara);
DWORD WINAPI ReConnectCommThreadProc(void *Para);
DWORD WINAPI TimingSendSmsThread(void *pPara);
DWORD WINAPI DevOnlineThreadProc(void *pPara);
DWORD WINAPI VoiceNoticeThreadProc(void *pPara);
DWORD WINAPI OutputThreadProc(void *pPara);
DWORD WINAPI GetDatePlanThreadProc(void *pPara);
DWORD WINAPI SoftRegisterThread(void *pPara);
DWORD WINAPI GetBlanceThread(void *pPara);
DWORD WINAPI InsertDBThreadProc(void *pPara);
// 获取实际波特率
INT GetCommRate(int nRate);

// 获取实际数据位
INT GetCommDataBit(int nDataBitIndex);

BOOL FindRtuCommPort( CString strPort,int &iIndex );
BOOL FindAscCommPort( CString strPort,int &iIndex );
BOOL FindTcpCommPort( CString strPort,int &iIndex );
BOOL FindMostDeviceCommPort( CString strPort,int &iIndex );
BOOL FindIcpdasCommPort( CString strPort,int &iIndex );
BOOL FindParadigmCommPort( CString strPort,int &iIndex );
BOOL FindStulzCommPort( CString strPort,int &iIndex );

BOOL FindPowerwareCommPort( CString strPort,int &iIndex );
BOOL FindGreeCommPort( CString strPort,int &iIndex );
BOOL FindCarelCommPort( CString strPort,int &iIndex );
BOOL FindScanTakCommPort( CString strPort,int &iIndex );
BOOL FindDeltaCommPort( CString strPort,int &iIndex );


bool CreateDirectory(CString DirectoryName)
{
	bool re=false;
	::CreateDirectory(DirectoryName,NULL);
	return re;
}
bool ExistFolder(CString FilePath)
{
	return PathFileExists( FilePath );
}

bool MakeFolderExist( CString DirectoryName )
{
	if(DirectoryName[DirectoryName.GetLength()-1]!='\\')
		DirectoryName += "\\";

	int nStart = 3;
	CString sTemp;
	for(int n = nStart;n<DirectoryName.GetLength();n++)
	{
		if(DirectoryName[n]=='\\')
		{
			sTemp = DirectoryName.Left(n);
			bool f = ExistFolder(sTemp);
			if(!ExistFolder(sTemp))
				CreateDirectory(sTemp);
		}
	}

	return true;
}


INT StartMain()
{
	//INT iCount = GetDevProperty();
	// 初始化该结构体数组 , 每个网络设备的信息;
	// ●建议: 为什么在这就开始了网络设备的初始化呢,如果没有网络设备也初始化是不是有点浪费资源? 如何使之在有网络设备时才初始化;
	for( int i = 0; i < MAX_TCP_THREAD; i++ )
	{
		// g_tcpThreadStruct存放TCP线程索引和设备uid;
		g_tcpThreadStruct[i].nTcpTheadIndex = 0;		// 初始化所有线程索引为0;
		g_tcpThreadStruct[i].strUid = "";				// 初始化所有网络设备UID为空字符;
	}

	/////////////////////////////////得到所有用户的信息，与设备无关/////////////////////////////////////////////////
	char chTel[MAX_TEL_LENGTH] = {0};
	char chMobile[MAX_TEL_LENGTH] = {0};
	char chFax[MAX_TEL_LENGTH] = {0};
	char chEmail[MAX_EMAIL_LENGTH] = {0};

	list<string> list_tel, list_mobile, list_fax, list_email;
	list<string>::iterator it_tel, it_mobile, it_fax, it_email;

	int nUserCount = CDBInterface::GetInstancePtr()->GetUserInfoList(list_tel, list_mobile, list_fax, list_email);

	if( nUserCount>0 )
	{
		for( it_tel = list_tel.begin(), it_mobile = list_mobile.begin(), it_fax = list_fax.begin(), it_email = list_email.begin();
			it_tel != list_tel.end(), it_mobile != list_mobile.end(), it_fax != list_fax.end(), it_email != list_email.end(); )
		{
			USERINFO tagUserInfo;
			memset(&tagUserInfo, 0, sizeof(USERINFO));

			strcpy(tagUserInfo.szTel, (*it_tel++).c_str());
			strcpy(tagUserInfo.szMobileTel, (*it_mobile++).c_str());
			strcpy(tagUserInfo.szFax, (*it_fax++).c_str());
			strcpy(tagUserInfo.szEmail, (*it_email++).c_str());

			g_vtUserInfo.push_back(tagUserInfo);
		}

		for( it_tel = list_tel.begin(), it_mobile = list_mobile.begin(), it_fax = list_fax.begin(), it_email = list_email.begin();
			it_tel != list_tel.end(), it_mobile != list_mobile.end(), it_fax != list_fax.end(), it_email != list_email.end(); )
		{
			list_tel.erase(it_tel++);
			list_mobile.erase(it_mobile++);
			list_fax.erase(it_fax++);
			list_email.erase(it_email++);
		}
	}
	//////////////////////////////////////////////////////////////////////////////////////////
	// 得到所有设备与变量,并存储在全局变量g_pDeviceManager中;
	CDBInterface::GetInstancePtr()->GetDevInfo();
	GetAWAData();

	// 初始化设备在线采集数据 互斥量;
	InitializeCriticalSection( &g_csDevOnlineReadOneData );

	// **********************************************加载各种采集I/O设备动态库**********************************************;
	// ●建议:加载动态库时,应该考虑如何根据设备信息来动态加载,使用到哪种设备加载哪种动态库.而不是一次全部加载;
	LoadAscDLL(g_strDirectory);
	LoadRtuDll(g_strDirectory);
	LoadTcpDll(g_strDirectory);
	LoadIcpdasDll(g_strDirectory);
	LoadSnmpDll(g_strDirectory);
	LoadParadigmDll(g_strDirectory);
	LoadStulzDll(g_strDirectory);

	LoadPowerwareDll(g_strDirectory);
	LoadGreeDll(g_strDirectory);
	LoadCarelDll(g_strDirectory);
	LoadSeparateDll(g_strDirectory);
	LoadMostDeviceDll(g_strDirectory);

	//确保log文件夹存在
	CString str;
	str.Format( "%s\\Log",g_strSummaryLogPath);
	MakeFolderExist( str );
	//得到所有log文件，后面的删除用到
	g_GetAllLogFile();

	// 获取当前运行设备总数;
	int iSize = (int)g_pDevicesManager->m_Devices.GetSize();


#if IS_USER_MUL_THREAD_REQUEST // 是否使用多线程请求; 现在 == 1;
	int nDllType[MAX_DLL_TYPE] = {0};
	for( int i = 0; i < MAX_DLL_TYPE; i++ )
	{
		// ●建议:为什么以下三个变量,不做在一个结构体里呢;
		nDllType[i] = 0;					// 动态库类型(eg:RS232,ModbusRTU,SNMP...) ;
		g_hRequestDataThread[i] = NULL;		// 线程句柄( 每个串口对应的线程句柄); 
		g_strPort[i] = "";					// 通信端口( 每个串口线程所对应的串口);
	}
#endif

	
	/************************************************************************/
		/* 
		0.循环所有设备->next;
		1.判断设备类型->next;
		2.打开串口 ->next;
		3.判断是否使用->next;
		4.创建串口线程->end; 
		*/
	/************************************************************************/
	int iVarCount = 0;  // 存储所有变量总数;
	// 遍历所有设备,创建对应串口线程,进行设备采集;
	int nBaudRate, nDataBit;
	for( int i = 0; i < iSize; i++ )
	{
		// ●获取该设备有动态库名称,配置文件名,波特率,数据位;
		CDevice *pDev = g_pDevicesManager->m_Devices[i];

		char chDllName[MAX_PATH] = {0};		// 动态库名;
		char szIniName[MAX_PATH] = {0};		// 配置文件名;

		strcpy(chDllName, (char *)(LPCTSTR)pDev->m_strProtocoldllname);
		strcpy(szIniName, (char *)(LPCTSTR)pDev->m_strIniName);

		StrLower(chDllName,chDllName);
		StrLower(szIniName, szIniName);

		nBaudRate = GetCommRate( pDev->m_iBaudrate );	// 波特率;
		nDataBit = GetCommDataBit( pDev->m_iDatabit );	// 配置文件;

		// 累加设备下的变量数;
		iVarCount += pDev->m_Vars.GetSize();

		/************************************************************************/
		/* 
		1.判断设备类型->next;
		2.打开串口 ->next(第一次打开,成功则标记TRUE,失败标记FALSE;第2次尝试打开始,判断是否在用);
		3.判断是否使用->next(第2次尝试打开,若标记为TRUE,则在使用);
		4.创建串口线程->end; 
		*/
		/************************************************************************/
		// == 0 RTU设备;
		if( pDev->m_bySpecialdevice == 0 )
		{
			if (!InitRtuComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate, nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
			{
				LOG4C((LOG_NOTICE, "device name:%s open com%d(%d) lost！", pDev->m_strDeviceName,pDev->m_iPort,nBaudRate));
				pDev->m_bCommStatus = FALSE;
			}
			else
			{
				pDev->m_bCommStatus = TRUE;
				LOG4C((LOG_NOTICE, "device name:%s open com%d(%d) success！", pDev->m_strDeviceName,pDev->m_iPort,nBaudRate));
			}

			// 如果该 设备变量个数大于0,进行数据采集,创建线程;
			if( pDev->m_Vars.GetSize() >= 1 )
			{
				DWORD dwThreadId;int nIndex=0;
				CString strPort;
				strPort.Format("%d", pDev->m_iPort);

				// 判断串口是否已经使用(是否存在数组里),未使用继续执行代码;
				if( FALSE == FindRtuCommPort(strPort,nIndex) )
				{
					g_strPort[g_nRtuThreadIndex] = strPort;
					if( g_hRequestDataThread[g_nRtuThreadIndex] == NULL )
					{
						// 创建线程,一个串口对应一个线程;
						MTVERIFY( g_hRequestDataThread[g_nRtuThreadIndex] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)RequestDataThreadProc,(char *)(LPCTSTR)g_strPort[g_nRtuThreadIndex],0,&dwThreadId) );
						nIndex = g_nRtuThreadIndex;
						g_nRtuThreadIndex++;
					}
				}
				pDev->m_nThreadHandleIndex = nIndex;
			}
		}
		// == 1,ASC设备;
		else if( pDev->m_bySpecialdevice == 1 )
		{
			if (!InitAscComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate,nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
			{
				LOG4C((LOG_NOTICE, "device name:%s open com%d(%d) lost！", pDev->m_strDeviceName,pDev->m_iPort,nBaudRate));
				pDev->m_bCommStatus = FALSE;
			}
			else
			{
				LOG4C((LOG_NOTICE, "device name:%s open com%d(%d) success！", pDev->m_strDeviceName,pDev->m_iPort,nBaudRate));
				pDev->m_bCommStatus = TRUE;
			}

			// ASC设备对应的变量 > 0 才进行线程创建;
			if( pDev->m_Vars.GetSize() >= 1 )
			{
				DWORD dwThreadId;int nIndex=0;
				CString strPort;
				strPort.Format("%d", pDev->m_iPort);
				if( FALSE == FindAscCommPort(strPort,nIndex) )
				{
					g_strPort[g_nAscThreadIndex].Format("%d", pDev->m_iPort);
					MTVERIFY( g_hRequestDataThread[g_nAscThreadIndex] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)RequestDataThreadProc,(char *)(LPCTSTR)g_strPort[g_nAscThreadIndex],0,&dwThreadId) );
					nIndex = g_nAscThreadIndex;
					g_nAscThreadIndex++;
				}
				pDev->m_nThreadHandleIndex = nIndex;
			}
		}
		// == 2,网络设备;
		else if( pDev->m_bySpecialdevice == 2 )
		{
			if (!InitTcpNet(pDev->m_iDevideaddr, pDev->m_iIpport, (char *)(LPCTSTR)pDev->m_strIp))
			{
				LOG4C((LOG_NOTICE, "device name:%s open ip[%s],port[%d] lost！", pDev->m_strDeviceName,pDev->m_strIp, pDev->m_iIpport ));
				pDev->m_bCommStatus = FALSE;			
			}
			else
			{
				LOG4C((LOG_NOTICE, "device name:%s open ip[%s],port[%d] success！", pDev->m_strDeviceName,pDev->m_strIp, pDev->m_iIpport ));
				pDev->m_bCommStatus = TRUE;
			}

			if( pDev->m_Vars.GetSize() >= 1 )
			{
				DWORD dwThreadId;
				MTVERIFY( g_hRequestDataThread[g_nTcpThreadIndex] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)RequestDataThreadProc,(char *)(LPCTSTR)pDev->m_strUid,0,&dwThreadId) );

				g_tcpThreadStruct[g_nTcpThreadStructIndex].nTcpTheadIndex = g_nTcpThreadIndex;
				g_tcpThreadStruct[g_nTcpThreadStructIndex].strUid = pDev->m_strUid;

				g_nTcpThreadStructIndex++;
				g_nTcpThreadIndex++;
			}
		}
		// ping命令设备;
		else if( pDev->m_bySpecialdevice == 3 )
		{
			int iPingResult = 0;
			// ping 10 次，如果都是timeout, 认为设备已断线
			for( int iPingIndex = 0; iPingIndex <  5; iPingIndex++ )
			{
				if( Ping(2000, pDev->m_strIp) == 0 )
				{
					iPingResult = 0;
					break;
				}
				else
				{
					iPingResult = 1;
				}
			}

			if( 1 == iPingResult )   // 设备已断线
			{
				pDev->m_bCommStatus = FALSE;					
				LOG4C((LOG_NOTICE, "device name:%s open ip[%s] lost！", pDev->m_strDeviceName,pDev->m_strIp ));
			}
			else
			{
				pDev->m_bCommStatus = TRUE;
				LOG4C((LOG_NOTICE, "device name:%s open ip[%s] success！", pDev->m_strDeviceName,pDev->m_strIp ));
			}

			if( pDev->m_Vars.GetSize() >= 1 )
			{
				DWORD dwThreadId;
				MTVERIFY( g_hRequestDataThread[g_nSnmpThreadIndex] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)RequestDataThreadProc,(char *)(LPCTSTR)pDev->m_strUid,0,&dwThreadId) );

				g_nSnmpThreadIndex++; 
			}
		}

		// 串口设备;
		else if( pDev->m_bySpecialdevice == 4 )
		{
			if ( strcmp(chDllName, "icpdas.dll") == 0 )
			{
				if (!InitIcpdasComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate,nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
				{
					//LOG4C((LOG_NOTICE, "device name:%s, port:%d, addr=%d, baudrate=%d, databit=%d, stopbit=%d, paritybit=%d open com lost！",pDev->m_strDeviceName, pDev->m_iPort, pDev->m_iDevideaddr, nBaudRate, nDataBit, pDev->m_iStopbit, pDev->m_iParitybit));
					pDev->m_bCommStatus = FALSE;		
				}
				else
				{
					LOG4C((LOG_NOTICE, "device name:%s open com%d(%d) success！", pDev->m_strDeviceName,pDev->m_iPort,nBaudRate));
					pDev->m_bCommStatus = TRUE;
				}

				if( pDev->m_Vars.GetSize() >= 1 )
				{
					DWORD dwThreadId;int nIndex=0;
					CString strPort;
					strPort.Format("%d", pDev->m_iPort);
					if( FALSE == FindIcpdasCommPort(strPort,nIndex) )
					{
						g_strPort[g_nIcpdasIndex].Format("%d", pDev->m_iPort);
						
						MTVERIFY( g_hRequestDataThread[g_nIcpdasIndex] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)RequestDataThreadProc,(char *)(LPCTSTR)g_strPort[g_nIcpdasIndex],0,&dwThreadId) );
						nIndex = g_nIcpdasIndex;
						g_nIcpdasIndex++;

					}
					pDev->m_nThreadHandleIndex = nIndex;
				}
			}
			// ups ; 
			else if ( strcmp(chDllName, "upsparadigm.dll") == 0 ) 
			{
				if (!InitParadigmComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate,nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
				{
					LOG4C((LOG_NOTICE, "device name:%s open com%d(%d) lost！", pDev->m_strDeviceName,pDev->m_iPort,nBaudRate));
					pDev->m_bCommStatus = FALSE;					
				}
				else
				{
					LOG4C((LOG_NOTICE, "device name:%s open com%d(%d) success！", pDev->m_strDeviceName,pDev->m_iPort,nBaudRate));
					pDev->m_bCommStatus = TRUE;
				}

				if( pDev->m_Vars.GetSize() >= 1 )
				{
					DWORD dwThreadId;int nIndex=0;
					CString strPort;
					strPort.Format("%d", pDev->m_iPort);
					if( FALSE == FindParadigmCommPort(strPort,nIndex) )
					{
						g_strPort[g_nParadigmIndex].Format("%d", pDev->m_iPort);
						
						MTVERIFY( g_hRequestDataThread[g_nParadigmIndex] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)RequestDataThreadProc,(char *)(LPCTSTR)g_strPort[g_nParadigmIndex],0,&dwThreadId) );
						nIndex = g_nParadigmIndex;
						g_nParadigmIndex++;
					}
					pDev->m_nThreadHandleIndex = nIndex;
				}
			}
			// 斯图兹空调;
			else if ( strcmp(chDllName, "stulz.dll") == 0 ) 
			{
				if (!InitStulzComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate, nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
				{
					LOG4C((LOG_NOTICE, "device name:%s open com%d(%d) lost！", pDev->m_strDeviceName,pDev->m_iPort,nBaudRate));
					pDev->m_bCommStatus = FALSE;				
				}
				else
				{
					LOG4C((LOG_NOTICE, "device name:%s open com%d(%d) success！", pDev->m_strDeviceName,pDev->m_iPort,nBaudRate));
					pDev->m_bCommStatus = TRUE;
				}

				if( pDev->m_Vars.GetSize() >= 1 )
				{
					DWORD dwThreadId;int nIndex=0;
					CString strPort;
					strPort.Format("%d", pDev->m_iPort);
					if( FALSE == FindStulzCommPort(strPort,nIndex) )
					{
						g_strPort[g_nStulzIndex].Format("%d", pDev->m_iPort);
						
						MTVERIFY( g_hRequestDataThread[g_nStulzIndex] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)RequestDataThreadProc,(char *)(LPCTSTR)g_strPort[g_nStulzIndex],0,&dwThreadId) );
						nIndex = g_nStulzIndex;
						g_nStulzIndex++;
					}
					pDev->m_nThreadHandleIndex = nIndex;
				}
			}
			// 威能UPS; 
			else if ( strcmp(chDllName, "powerware.dll") == 0 ) 
			{
				if( !InitPowerwareComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate, nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000) )
				{
					LOG4C((LOG_NOTICE, "device name:%s open com%d(%d) lost！", pDev->m_strDeviceName,pDev->m_iPort,nBaudRate));
					pDev->m_bCommStatus = FALSE;
				}
				else
				{
					LOG4C((LOG_NOTICE, "device name:%s open com%d(%d) success！", pDev->m_strDeviceName,pDev->m_iPort,nBaudRate));
					pDev->m_bCommStatus = TRUE;
				}

				if( pDev->m_Vars.GetSize() >= 1 )
				{
					DWORD dwThreadId;int nIndex=0;
					CString strPort;
					strPort.Format("%d", pDev->m_iPort);
					if( FALSE == FindPowerwareCommPort(strPort,nIndex) )
					{
						g_strPort[g_nPowerwareIndex].Format("%d", pDev->m_iPort);
					
						MTVERIFY( g_hRequestDataThread[g_nPowerwareIndex] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)RequestDataThreadProc,(char *)(LPCTSTR)g_strPort[g_nPowerwareIndex],0,&dwThreadId) );
						nIndex = g_nPowerwareIndex;
						g_nPowerwareIndex++;
					}
					pDev->m_nThreadHandleIndex = nIndex;
				}
			}
			// 格力空调 ;
			else if ( strcmp(chDllName, "gree.dll") == 0 ) 
			{
				if (!InitGreeComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate, nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
				{
					LOG4C((LOG_NOTICE, "device name:%s open com%d(%d) lost！", pDev->m_strDeviceName,pDev->m_iPort,nBaudRate));
					pDev->m_bCommStatus = FALSE;
				}
				else
				{
					LOG4C((LOG_NOTICE, "device name:%s open com%d(%d) success！", pDev->m_strDeviceName,pDev->m_iPort,nBaudRate));
					pDev->m_bCommStatus = TRUE;
				}

				if( pDev->m_Vars.GetSize() >= 1 )
				{
					DWORD dwThreadId;int nIndex=0;
					CString strPort;
					strPort.Format("%d", pDev->m_iPort);
					if( FALSE == FindGreeCommPort(strPort,nIndex) )
					{
						g_strPort[g_nGreeIndex].Format("%d", pDev->m_iPort);
						
						MTVERIFY( g_hRequestDataThread[g_nGreeIndex] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)RequestDataThreadProc,(char *)(LPCTSTR)g_strPort[g_nGreeIndex],0,&dwThreadId) );
						nIndex = g_nGreeIndex;
						g_nGreeIndex++; 
						
					}
					pDev->m_nThreadHandleIndex = nIndex;
				}
			}
			// 卡乐空调;
			else if ( strcmp(chDllName, "carel.dll") == 0 ) 
			{
				if (!InitCarelComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate, nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
				{
					LOG4C((LOG_NOTICE, "device name:%s open com%d(%d) lost！", pDev->m_strDeviceName,pDev->m_iPort,nBaudRate));
					pDev->m_bCommStatus = FALSE;
				}
				else
				{
					LOG4C((LOG_NOTICE, "device name:%s open com%d(%d) success！", pDev->m_strDeviceName,pDev->m_iPort,nBaudRate));
					pDev->m_bCommStatus = TRUE;
				}

				if( pDev->m_Vars.GetSize() >= 1 )
				{
					DWORD dwThreadId;int nIndex=0;
					CString strPort;
					strPort.Format("%d", pDev->m_iPort);
					if( FALSE == FindCarelCommPort(strPort,nIndex) )
					{
						g_strPort[g_nCarelIndex].Format("%d", pDev->m_iPort);
						
						MTVERIFY( g_hRequestDataThread[g_nCarelIndex] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)RequestDataThreadProc,(char *)(LPCTSTR)g_strPort[g_nCarelIndex],0,&dwThreadId) );
						nIndex = g_nCarelIndex;
						g_nCarelIndex++;
						
					}
					pDev->m_nThreadHandleIndex = nIndex;
				}
			}
			// Mostdevice设备集;
			else if( g_FunIniOK( szIniName ) )
			{
				//LOG4C((LOG_NOTICE, "Enter InitMostDeviceComm szIniName = %s", szIniName));
				if (!InitMostDeviceComm(g_strDirectory,  szIniName, pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate, nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
				{
					LOG4C((LOG_NOTICE, "device name:%s open com%d(%d) lost！", pDev->m_strDeviceName,pDev->m_iPort,nBaudRate));
					pDev->m_bCommStatus = FALSE;
				}
				else
				{
					LOG4C((LOG_NOTICE, "device name:%s open com%d(%d) success！", pDev->m_strDeviceName,pDev->m_iPort,nBaudRate));
					pDev->m_bCommStatus = TRUE;
				}

				if( pDev->m_Vars.GetSize() >= 1 )
				{
					DWORD dwThreadId;int nIndex=0;
					CString strPort;
					strPort.Format("%d", pDev->m_iPort);
					if( FALSE == FindMostDeviceCommPort(strPort,nIndex) )
					{
						g_strPort[g_nMostDeviceIndex].Format("%d", pDev->m_iPort);
						
						MTVERIFY( g_hRequestDataThread[g_nMostDeviceIndex] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)RequestDataThreadProc,(char *)(LPCTSTR)g_strPort[g_nMostDeviceIndex],0,&dwThreadId) );
						nIndex = g_nMostDeviceIndex;
						g_nMostDeviceIndex++;
						
					}
					pDev->m_nThreadHandleIndex = nIndex;
				}
			}
			else
			{
				LOG4C((LOG_NOTICE, "找不到1 dll = %s ，ini = %s ，%s",chDllName,szIniName,pDev->m_strDeviceName )); 
			}
		}
	}

	LOG4C((LOG_NOTICE, "iVarCount = %d", iVarCount));

	// 每MAX_SINGLE_TCP_VAR_NUM个变量，建立一个监听端口
	//改为和64320一起启动
//#if 0
//	int nSocketIndex = 1;
//	if( iVarCount > MAX_SINGLE_TCP_VAR_NUM )
//	{
//		while( iVarCount / (nSocketIndex  * MAX_SINGLE_TCP_VAR_NUM) != 0 )
//		{
//			if( NULL == g_pServerSocket[nSocketIndex] )
//			{
//				g_pServerSocket[nSocketIndex] = new CServerSocket();
//				CString strPort;
//				strPort.Format("%d", SOCKET_SERVER_PORT + nSocketIndex);
//				LOG4C((LOG_NOTICE, "Create Port %s success", strPort));
//				g_pServerSocket[nSocketIndex]->SvrStart(strPort);
//				nSocketIndex++;
//			}
//		}
//	}
//#else
//	int nSocketIndex = 1;
//	
//	if( NULL == g_pServerSocket[nSocketIndex] )
//	{
//		g_pServerSocket[nSocketIndex] = new CServerSocket();
//		CString strPort;
//		strPort.Format("%d", SOCKET_SERVER_PORT + nSocketIndex);
//		LOG4C((LOG_NOTICE, "Create Port %s success", strPort));
//		g_pServerSocket[nSocketIndex]->SvrStart(strPort);
//	}
//#endif

	// 实时监控设备是否在线;
	if( g_hDevOnlineThread == NULL )
	{
		DWORD dwThreadId;
		MTVERIFY( g_hDevOnlineThread = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)DevOnlineThreadProc,0,0,&dwThreadId) );
	}

	//delete by 2012.05.30
	//if( g_hReConnectCommThread == NULL )
	//{
	//	DWORD dwThreadId;
	//	MTVERIFY( g_hReConnectCommThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ReConnectCommThreadProc, NULL, 0, &dwThreadId) );
	//}
	
	// 软件注册信息实时变更线程;
	if( g_hSoftRegisterThread == NULL )
	{
		DWORD dwThreadId;
		if( g_nEncryptionType!=476 && !g_bSoftRegisterFileIsOfficial )//g_nEncryptionType!=0 && 
		{
			if( pRegdllGetHourToCount )
				g_nHourToCount = pRegdllGetHourToCount();
			else
				g_nHourToCount = 1;
			MTVERIFY( g_hSoftRegisterThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)SoftRegisterThread, NULL, 0, &dwThreadId) );
		}
	}

	if( g_hGetBlanceThread == NULL && g_nSendSms==1 && pSmsGetBalance )
	{
		DWORD dwThreadId;
		MTVERIFY( g_hGetBlanceThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)GetBlanceThread, NULL, 0, &dwThreadId) );
	}

	if( g_hTimingSendSmsThread == NULL )
	{
		DWORD dwThreadId;
		if( g_nSendSms==1 || g_bSendVoice==1 )
		{
			MTVERIFY( g_hTimingSendSmsThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)TimingSendSmsThread, NULL, 0, &dwThreadId) );
		}
	}

	if( g_hVoiceNoticeThread == NULL )
	{
		DWORD dwThreadId;
		MTVERIFY( g_hVoiceNoticeThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)VoiceNoticeThreadProc, NULL, 0, &dwThreadId) );
	}

	if( g_hInsertDBThread == NULL )
	{
		DWORD dwThreadId;
		MTVERIFY( g_hInsertDBThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)InsertDBThreadProc, NULL, 0, &dwThreadId) );
	}

	//if( g_hOutputThread == NULL )
	//{
	//	if( 1 == g_nOutputEnable )
	//	{
	//		DWORD dwThreadId;
	//		MTVERIFY( g_hOutputThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)OutputThreadProc, NULL, 0, &dwThreadId) );
	//	}
	//}

	if( g_hGetDatePlanThread == NULL )
	{
		DWORD dwThreadId;
		MTVERIFY( g_hGetDatePlanThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)GetDatePlanThreadProc, NULL, 0, &dwThreadId) );
	}

	return 0;
}

void EndMain()
{
#if IS_USER_MUL_THREAD_REQUEST
	for( int i = 0; i < MAX_DLL_TYPE; i++ )
	{
		if (NULL != g_hRequestDataThread[i])
		{
			MTVERIFY( WaitForSingleObject( g_hRequestDataThread[i], INFINITE ) != WAIT_FAILED );
			MTVERIFY( CloseHandle( g_hRequestDataThread[i] ) );
			g_hRequestDataThread[i] = NULL;
		}
	}
#else
	if (NULL != g_hRequestDataThread)
	{
		MTVERIFY( WaitForSingleObject( g_hRequestDataThread, INFINITE ) != WAIT_FAILED );
		MTVERIFY( CloseHandle( g_hRequestDataThread ) );
		g_hRequestDataThread = NULL;
	}
#endif

	if( NULL != g_hDevOnlineThread )
	{
		MTVERIFY( WaitForSingleObject( g_hDevOnlineThread, INFINITE ) != WAIT_FAILED );
		MTVERIFY( CloseHandle( g_hDevOnlineThread ) );
		g_hDevOnlineThread = NULL;
	}

	if( NULL != g_hReConnectCommThread )
	{
		MTVERIFY( WaitForSingleObject( g_hReConnectCommThread, INFINITE ) != WAIT_FAILED );
		MTVERIFY( CloseHandle( g_hReConnectCommThread ) );
		g_hReConnectCommThread = NULL;
	}
	
	if( g_hSoftRegisterThread != NULL )
	{
		MTVERIFY( WaitForSingleObject( g_hSoftRegisterThread, INFINITE ) != WAIT_FAILED );
		MTVERIFY( CloseHandle( g_hSoftRegisterThread ) );
		g_hSoftRegisterThread = NULL;
	}

	if( g_hGetBlanceThread != NULL )
	{
		MTVERIFY( WaitForSingleObject( g_hGetBlanceThread, INFINITE ) != WAIT_FAILED );
		MTVERIFY( CloseHandle( g_hGetBlanceThread ) );
		g_hGetBlanceThread = NULL;
	}
	if( g_hTimingSendSmsThread != NULL )
	{
		MTVERIFY( WaitForSingleObject( g_hTimingSendSmsThread, INFINITE ) != WAIT_FAILED );
		MTVERIFY( CloseHandle( g_hTimingSendSmsThread ) );
		g_hTimingSendSmsThread = NULL;
	}

	if( g_hVoiceNoticeThread != NULL )
	{
		MTVERIFY( WaitForSingleObject( g_hVoiceNoticeThread, INFINITE ) != WAIT_FAILED );
		MTVERIFY( CloseHandle( g_hVoiceNoticeThread ) );
		g_hVoiceNoticeThread = NULL;
	}

	if( g_hInsertDBThread != NULL )
	{
		MTVERIFY( WaitForSingleObject( g_hInsertDBThread, INFINITE ) != WAIT_FAILED );
		MTVERIFY( CloseHandle( g_hInsertDBThread ) );
		g_hInsertDBThread = NULL;
	}
	if( 1 == g_nOutputEnable )
	{
		if( NULL != g_hOutputThread )
		{
			MTVERIFY( WaitForSingleObject( g_hOutputThread, INFINITE ) != WAIT_FAILED );
			MTVERIFY( CloseHandle( g_hOutputThread ) );
			g_hOutputThread = NULL;
		}
	}

	if( NULL != g_hGetDatePlanThread )
	{
		MTVERIFY( WaitForSingleObject( g_hGetDatePlanThread, INFINITE ) != WAIT_FAILED );
		MTVERIFY( CloseHandle( g_hGetDatePlanThread ) );
		g_hGetDatePlanThread = NULL;
	}

	DeleteCriticalSection( &g_csDevOnlineReadOneData );
}

/************************************************************************/
/*     13个重连函数不用                                                  */
/************************************************************************/
BOOL ModbusRtuReConnectProc(CDevice *pDev)
{
	BOOL bResult = FALSE;
	char chMsg[80] = {0};
	SETBASEPARAM SetBasePara = {0};
	SetBasePara.nAddr = pDev->m_iDevideaddr;
	// 循环所有变量
	int ERROR_COUNT=0;
	int RIGHT_COUNT=0;
	int nVarSize = pDev->m_Vars.GetSize();
	for( int j = 0; j < nVarSize; j++ )
	{
		CBaseVar *pBaseVar = pDev->m_Vars[j];

		if( pBaseVar->m_bReadOnly == 1 ) continue;
		if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

		SetBasePara.nRegNum = pBaseVar->m_iRegisterNum;
		SetBasePara.nStartAddr = pBaseVar->m_nRegStartAddr;
		SetBasePara.FuncCode = pBaseVar->m_iFuncID;

		if( pBaseVar->m_nVarTypeID >= SPECIAL_VAR_TYPE_MIN_ID && pBaseVar->m_nVarTypeID <= SPECIAL_VAR_TYPE_MAX_ID )	// 特殊变量
		{
			if (RtuRequestSpecData(SetBasePara, pBaseVar->m_iDataLen, pDev->m_iPort, pDev->m_iDevideaddr, 
				(char *)(LPCTSTR)pBaseVar->m_strVarUID, pBaseVar->m_nVarID, pBaseVar->m_nVarTypeID) == 0)
			{
				if( (int)pBaseVar->m_dbData>0 )//add by 2012.05.30
				{
					LOG4C((LOG_NOTICE, "ModbusRtuReConnectProc %s,m_iPort=%d,m_iDevideaddr=%d,%s = %d ", pDev->m_strDeviceName,pDev->m_iPort, pDev->m_iDevideaddr,pBaseVar->m_strName,(int)pBaseVar->m_dbData));
				
					RIGHT_COUNT++;
					if( RIGHT_COUNT>=READ_VAR_ERROR_MAX )
					{
						bResult = TRUE;
						break;
					}
				}
			}
			else
			{
				ERROR_COUNT++;
				if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
					return FALSE;
			}
		}
		else
		{
			if (pRTU_DLLInit(pDev->m_iPort, pDev->m_iDevideaddr, SetBasePara, pBaseVar->m_iDataLen, chMsg)==0)//初始化设备DLL
			{
				LOG4C((LOG_NOTICE, "ModbusRtuReConnectProc2 %s m_dbData = %d ", pDev->m_strDeviceName,(int)pBaseVar->m_dbData));
				bResult = TRUE;
				break;
			}
			else
			{
				ERROR_COUNT++;
				if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
					return FALSE;
			}
		}
	}

	return bResult;
}

BOOL ModbusAscReConnectProc(CDevice *pDev)
{
	BOOL bResult = FALSE;
	char chMsg[80] = {0};
	SETBASEPARAM SetBasePara = {0};
	SetBasePara.nAddr = pDev->m_iDevideaddr;
	// 循环所有变量
	int ERROR_COUNT = 0;
	int nVarSize = pDev->m_Vars.GetSize();
	for( int j = 0; j < nVarSize; j++ )
	{
		CBaseVar *pBaseVar = pDev->m_Vars[j];

		if( pBaseVar->m_bReadOnly == 1 ) continue;
		if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

		SetBasePara.nRegNum = pBaseVar->m_iRegisterNum;
		SetBasePara.nStartAddr = pBaseVar->m_nRegStartAddr;
		SetBasePara.FuncCode = pBaseVar->m_iFuncID;

		if( pBaseVar->m_nVarTypeID >= SPECIAL_VAR_TYPE_MIN_ID && pBaseVar->m_nVarTypeID <= SPECIAL_VAR_TYPE_MAX_ID )	// 特殊变量
		{
			if (AscRequestSpecData((char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, pBaseVar->m_nVarTypeID) == 0)
			{
				bResult = TRUE;
				break;
			}
			else
			{
				ERROR_COUNT++;
				if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
					return FALSE;
			}
		}
		else
		{
			if(pASCDLLInit(pDev->m_iPort, pDev->m_iDevideaddr, SetBasePara, pBaseVar->m_iDataLen, chMsg)==0)//初始化设备DLL
			{
				bResult = TRUE;
				break;
			}
			else
			{
				ERROR_COUNT++;
				if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
					return FALSE;
			}
		}
	}

	return bResult;
}

BOOL SnmpReConnectProc(CDevice *pDev)
{
	BOOL bResult = FALSE;
	char chMsg[80] = {0};
	// 循环所有变量
	int ERROR_COUNT = 0;
	int nVarSize = pDev->m_Vars.GetSize();
	for( int j = 0; j < nVarSize; j++ )
	{
		CBaseVar *pBaseVar = pDev->m_Vars[j];

		if( pBaseVar->m_bReadOnly == 1 ) continue;
		if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

		if( pSnmpDllGetValue )
		{
			//TRACE("变量值id=%d\r\n", pBaseVar->m_nVarID);
			int nRet = pSnmpDllGetValue((char *)(LPCTSTR)pDev->m_strIp, 
				(char *)(LPCTSTR)pBaseVar->m_strFields,
				(char *)(LPCTSTR)pBaseVar->m_strSnmpoi,
				chMsg);

			if( nRet == 0 )
			{
				bResult = TRUE;
				break;
			}
			else
			{
				ERROR_COUNT++;
				if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
					return FALSE;
			}
		}
	}

	return bResult;
}

BOOL IcpdasReConnectProc(CDevice *pDev)
{
	BOOL bResult = FALSE;
	char chMsg[80] = {0};
	SETBASEPARAM SetBasePara = {0};
	SetBasePara.nAddr = pDev->m_iDevideaddr;

	// 循环所有变量
	int ERROR_COUNT = 0;
	int nVarSize = pDev->m_Vars.GetSize();
	for( int j = 0; j < nVarSize; j++ )
	{
		CBaseVar *pBaseVar = pDev->m_Vars[j];

		if( pBaseVar->m_bReadOnly == 1 ) continue;
		if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

		SetBasePara.nRegNum = pBaseVar->m_iRegisterNum;
		SetBasePara.nStartAddr = pBaseVar->m_nRegStartAddr;
		SetBasePara.FuncCode = pBaseVar->m_iFuncID;

		if (IcpdasRequestData(j, SetBasePara, pBaseVar->m_iDataLen, pDev->m_iPort, pDev->m_iDevideaddr, 
			(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, (char *)(LPCTSTR)pBaseVar->m_strRs232cmd) == 0)
		{
			bResult = TRUE;
			break;
		}
		else
		{
			ERROR_COUNT++;
			if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
				return FALSE;
		}
	}

	return bResult;
}

BOOL ParadigmReConnectProc(CDevice *pDev)
{
	BOOL bResult = FALSE;
	char chMsg[80] = {0};

	// 循环所有变量
	int ERROR_COUNT = 0;
	int nVarSize = pDev->m_Vars.GetSize();
	for( int j = 0; j < nVarSize; j++ )
	{
		CBaseVar *pBaseVar = pDev->m_Vars[j];

		if( pBaseVar->m_bReadOnly == 1 ) continue;
		if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

		if (ParadigmRequestData(pDev->m_iPort, pDev->m_iDevideaddr, 
			(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, (char*)(LPCTSTR)pBaseVar->m_strRs232cmd) == 0)
		{
			bResult = TRUE;
			break;
		}
		else
		{
			ERROR_COUNT++;
			if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
				return FALSE;
		}
	}

	return bResult;
}

BOOL StulzReConnectProc(CDevice *pDev)
{
	BOOL bResult = FALSE;
	char chMsg[80] = {0};
	SETBASEPARAM SetBasePara = {0};
	SetBasePara.nAddr = pDev->m_iDevideaddr;

	// 循环所有变量
	int ERROR_COUNT = 0;
	int nVarSize = pDev->m_Vars.GetSize();
	for( int j = 0; j < nVarSize; j++ )
	{
		CBaseVar *pBaseVar = pDev->m_Vars[j];

		if( pBaseVar->m_bReadOnly == 1 ) continue;
		if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

		SetBasePara.nRegNum = pBaseVar->m_iRegisterNum;
		SetBasePara.nStartAddr = pBaseVar->m_nRegStartAddr;
		SetBasePara.FuncCode = pBaseVar->m_iFuncID;

		if (StulzRequestData(SetBasePara, pBaseVar->m_iDataLen, pDev->m_iPort, pDev->m_iDevideaddr, 
			(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, (char*)(LPCTSTR)pBaseVar->m_strRs232cmd) == 0)
		{
			bResult = TRUE;
			break;
		}
		else
		{
			ERROR_COUNT++;
			if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
				return FALSE;
		}
	}

	return bResult;
}

BOOL PowerwareReConnectProc(CDevice *pDev)
{
	BOOL bResult = FALSE;
	char chMsg[80] = {0};
	// 循环所有变量
	int ERROR_COUNT = 0;
	int nVarSize = pDev->m_Vars.GetSize();
	for( int j = 0; j < nVarSize; j++ )
	{
		CBaseVar *pBaseVar = pDev->m_Vars[j];

		if( pBaseVar->m_bReadOnly == 1 ) continue;
		if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

		if (PowerwareRequestData(pDev->m_iPort, pDev->m_iDevideaddr, 
			(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, (char*)(LPCTSTR)pBaseVar->m_strRs232cmd) == 0)
		{
			bResult = TRUE;
			break;
		}
		else
		{
			ERROR_COUNT++;
			if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
				return FALSE;
		}
	}

	return bResult;
}

BOOL GreeReConnectProc(CDevice *pDev)
{
	BOOL bResult = FALSE;
	char chMsg[80] = {0};
	SETBASEPARAM SetBasePara = {0};
	SetBasePara.nAddr = pDev->m_iDevideaddr;

	// 循环所有变量
	int ERROR_COUNT = 0;
	int nVarSize = pDev->m_Vars.GetSize();
	for( int j = 0; j < nVarSize; j++ )
	{
		CBaseVar *pBaseVar = pDev->m_Vars[j];

		if( pBaseVar->m_bReadOnly == 1 ) continue;
		if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

		SetBasePara.nRegNum = pBaseVar->m_iRegisterNum;
		SetBasePara.nStartAddr = pBaseVar->m_nRegStartAddr;
		SetBasePara.FuncCode = pBaseVar->m_iFuncID;

		if (GreeRequestData(SetBasePara, pBaseVar->m_iDataLen, pDev->m_iPort, pDev->m_iDevideaddr, 
			(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, (char*)(LPCTSTR)pBaseVar->m_strRs232cmd) == 0)
		{
			bResult = TRUE;
			break;
		}
		else
		{
			ERROR_COUNT++;
			if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
				return FALSE;
		}
	}

	return bResult;
}

BOOL CarelReConnectProc(CDevice *pDev)
{
	BOOL bResult = FALSE;
	char chMsg[80] = {0};

	// 循环所有变量
	int ERROR_COUNT = 0;
	int nVarSize = pDev->m_Vars.GetSize();
	for( int j = 0; j < nVarSize; j++ )
	{
		CBaseVar *pBaseVar = pDev->m_Vars[j];

		if( pBaseVar->m_bReadOnly == 1 ) continue;
		if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

		if (CarelRequestData(pDev->m_iPort, pDev->m_iDevideaddr, 
								(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, 
								(char*)(LPCTSTR)pBaseVar->m_strRs232cmd) == 0)
		{
			bResult = TRUE;
			break;
		}
		else
		{
			ERROR_COUNT++;
			if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
				return FALSE;
		}
	}

	return bResult;
}

BOOL SeparateReConnectProc(CDevice *pDev)
{
	BOOL bResult = FALSE;
	char chMsg[80] = {0};

	char szIniName[MAX_PATH] = {0};
	strcpy(szIniName, (char *)(LPCTSTR)pDev->m_strIniName);
	StrLower(szIniName, szIniName);

	// 循环所有变量
	int ERROR_COUNT = 0;
	int nVarSize = pDev->m_Vars.GetSize();
	for( int j = 0; j < nVarSize; j++ )
	{
		CBaseVar *pBaseVar = pDev->m_Vars[j];

		if( pBaseVar->m_bReadOnly == 1 ) continue;
		if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

		if (SeparateRequestData(pDev->m_iPort, pDev->m_iDevideaddr, 
								(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, 
								(char*)(LPCTSTR)pBaseVar->m_strRs232cmd,
								szIniName) == 0)
		{
			bResult = TRUE;
			break;
		}
		else
		{
			ERROR_COUNT++;
			if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
				return FALSE;
		}
	}

	return bResult;
}

BOOL MostDeviceReConnectProc(CDevice *pDev)
{
	BOOL bResult = FALSE;
	char chMsg[80] = {0};

	char szIniName[MAX_PATH] = {0};
	strcpy(szIniName, (char *)(LPCTSTR)pDev->m_strIniName);
	StrLower(szIniName, szIniName);

	// 循环所有变量
	int ERROR_COUNT = 0;
	int nVarSize = pDev->m_Vars.GetSize();
	for( int j = 0; j < nVarSize; j++ )
	{
		CBaseVar *pBaseVar = pDev->m_Vars[j];

		if( pBaseVar->m_bReadOnly == 1 ) continue;
		if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

		if (MostDeviceRequestData(pDev->m_iPort, pDev->m_iDevideaddr, 
								(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, 
								(char*)(LPCTSTR)pBaseVar->m_strRs232cmd,
								szIniName) == 0)	
		{
			bResult = TRUE;
			break;
		}
		else
		{
			ERROR_COUNT++;
			if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
				return FALSE;
		}
	}

	return bResult;
}

int GetTcpThreadStructIndex(CString strUid)
{
	int nRet = -1;
	for( int i = 0; i < MAX_TCP_THREAD; i++ )
	{
		if( g_tcpThreadStruct[i].strUid.Compare(strUid) == 0 )
		{
			nRet = i;
			break;
		}
	}

	return nRet;
}

//
//以上13个函数,均由线程重连串口ReConnectCommThreadProc调用 ;
// 功能如下:
// 0.判断是否设备是否掉线,掉线则重连串口并采集;
// 1.每个类型设备,首先初始化.判断是否打开了该串口;
// 2.串口打开成功,进行数据采集,存储到变量和设备里;
DWORD WINAPI ReConnectCommThreadProc(void *Para)
{
	do
	{
		int iSize = (int)g_pDevicesManager->m_Devices.GetSize();
		int nBaudRate, nDataBit;
		for( int i = 0; i < iSize; i++ )
		{
			CDevice *pDev = g_pDevicesManager->m_Devices[i];

			char chDllName[MAX_PATH] = {0};
			char szIniName[MAX_PATH] = {0};

			strcpy(chDllName, (char *)(LPCTSTR)pDev->m_strProtocoldllname);
			strcpy(szIniName, (char *)(LPCTSTR)pDev->m_strIniName);

			StrLower(chDllName,chDllName);
			StrLower(szIniName, szIniName);

			nBaudRate = GetCommRate( pDev->m_iBaudrate );

			nDataBit = GetCommDataBit( pDev->m_iDatabit );

			if( pDev->m_bySpecialdevice == 0 )
			{
				if( pDev->m_bCommStatus == FALSE )
				{
					if (!InitRtuComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate,
						nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
					{
						pDev->m_bCommStatus = FALSE;
					}
					else
					{
						EnterCriticalSection( &g_csRtuReadOneData );
						pDev->m_bCommStatus = ModbusRtuReConnectProc(pDev);
						if( pDev->m_bCommStatus == TRUE )
						{
							LOG4C((LOG_NOTICE, "device name:%s open com success！", pDev->m_strDeviceName));
							pDev->m_dwOnlineTick = GetTickCount();
						}
						LeaveCriticalSection( &g_csRtuReadOneData );
					}
				}
			}
			else if( pDev->m_bySpecialdevice == 1 )
			{
				if( pDev->m_bCommStatus == FALSE )
				{
					if (!InitAscComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate,
						nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
					{
						pDev->m_bCommStatus = FALSE;
					}
					else
					{
						EnterCriticalSection( &g_csAscReadOneData );
						pDev->m_bCommStatus = ModbusAscReConnectProc(pDev);
						if( pDev->m_bCommStatus == TRUE )
						{
							LOG4C((LOG_NOTICE, "device name:%s open com success！", pDev->m_strDeviceName));
							pDev->m_dwOnlineTick = GetTickCount();
						}
						LeaveCriticalSection( &g_csAscReadOneData );
					}
				}
			}
			else if( pDev->m_bySpecialdevice == 2 )
			{
				if( pDev->m_bCommStatus == FALSE )
				{
					int iPingResult = 0;
					// ping 10 次，如果都是timeout, 认为设备已断线
					for( int iPingIndex = 0; iPingIndex <  10; iPingIndex++ )
					{
						if( Ping(2000, pDev->m_strIp) == 0 )
						{
							iPingResult = 0;
							break;
						}
						else
						{
							iPingResult = 1;
						}
					}

					if( 1 == iPingResult )   // 设备已断线
					{
				
					}
					else
					{
						if (!InitTcpNet(pDev->m_iDevideaddr, pDev->m_iIpport, (char *)(LPCTSTR)pDev->m_strIp))
						{
							EnterCriticalSection( &g_csTcpReadOneData );
							pDev->m_bCommStatus = FALSE;
							LeaveCriticalSection( &g_csTcpReadOneData );
						}
						else
						{
							EnterCriticalSection( &g_csTcpReadOneData );
							pDev->m_dwOnlineTick = GetTickCount();
							pDev->m_bCommStatus = TRUE;
							LeaveCriticalSection( &g_csTcpReadOneData );

							int nIndex = GetTcpThreadStructIndex( pDev->m_strUid );
							if( nIndex != -1 )
							{
								if( g_hRequestDataThread[ g_tcpThreadStruct[nIndex].nTcpTheadIndex ] != NULL )
								{
									ResumeThread( g_hRequestDataThread[ g_tcpThreadStruct[nIndex].nTcpTheadIndex ] );
								}
							}
						}
					}
				}
			}
			else if( pDev->m_bySpecialdevice == 3 )
			{
				// 循环所有变量
				if( pDev->m_bCommStatus == FALSE )
				{
					int iPingResult = 0;
					// ping 10 次，如果都是timeout, 认为设备已断线
					for( int iPingIndex = 0; iPingIndex <  10; iPingIndex++ )
					{
						if( Ping(2000, pDev->m_strIp) == 0 )
						{
							iPingResult = 0;
							break;
						}
						else
						{
							iPingResult = 1;
						}
					}

					if( 1 == iPingResult )   // 设备已断线
					{
				
					}
					else
					{
						EnterCriticalSection( &g_csIcpdasReadOneData );
						pDev->m_dwOnlineTick = GetTickCount();
						pDev->m_bCommStatus = TRUE;
						LeaveCriticalSection( &g_csIcpdasReadOneData );
					}
				}
			}
			else if( pDev->m_bySpecialdevice == 4 )
			{
				if ( strcmp(chDllName, "icpdas.dll") == 0 ) 
				{
					if( pDev->m_bCommStatus == FALSE )
					{
						if (!InitIcpdasComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate,
											nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
						{
							pDev->m_bCommStatus = FALSE;		
						}
						else
						{
							EnterCriticalSection( &g_csIcpdasReadOneData );
							pDev->m_bCommStatus = IcpdasReConnectProc(pDev);
							if( pDev->m_bCommStatus == TRUE )
							{
								LOG4C((LOG_NOTICE, "device name:%s open com success！", pDev->m_strDeviceName));
								pDev->m_dwOnlineTick = GetTickCount();
							}
							LeaveCriticalSection( &g_csIcpdasReadOneData );
						}
					}
				}
				else if ( strcmp(chDllName, "upsparadigm.dll") == 0 ) 
				{
					if( pDev->m_bCommStatus == FALSE )
					{
						if (!InitParadigmComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate,
											nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
						{
							pDev->m_bCommStatus = FALSE;					
						}
						else
						{
							EnterCriticalSection( &g_csParadigmReadOneData );
							pDev->m_bCommStatus = ParadigmReConnectProc(pDev);
							if( pDev->m_bCommStatus == TRUE )
							{
								LOG4C((LOG_NOTICE, "device name:%s open com success！", pDev->m_strDeviceName));
								pDev->m_dwOnlineTick = GetTickCount();
							}
							LeaveCriticalSection( &g_csParadigmReadOneData );
						}
					}
				}
				else if ( strcmp(chDllName, "stulz.dll") == 0 ) 
				{
					if( pDev->m_bCommStatus == FALSE )
					{
						if (!InitStulzComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate,
											nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
						{
							pDev->m_bCommStatus = FALSE;				
						}
						else
						{
							EnterCriticalSection( &g_csStulzReadOneData );
							pDev->m_bCommStatus = StulzReConnectProc(pDev);
							if( pDev->m_bCommStatus == TRUE )
							{
								LOG4C((LOG_NOTICE, "device name:%s open com success！", pDev->m_strDeviceName));
								pDev->m_dwOnlineTick = GetTickCount();
							}
							LeaveCriticalSection( &g_csStulzReadOneData );
						}
					}
				}
				
				else if ( strcmp(chDllName, "powerware.dll") == 0 )
				{
					if( pDev->m_bCommStatus == FALSE )
					{
						if( !InitPowerwareComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate,
							nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000) )
						{
							pDev->m_bCommStatus = FALSE;
						}
						else
						{
							EnterCriticalSection( &g_csPowerwareReadOneData );
							pDev->m_bCommStatus = PowerwareReConnectProc(pDev);
							if( pDev->m_bCommStatus == TRUE )
							{
								LOG4C((LOG_NOTICE, "device name:%s open com success！", pDev->m_strDeviceName));
								pDev->m_dwOnlineTick = GetTickCount();
							}
							LeaveCriticalSection( &g_csPowerwareReadOneData );
						}
					}
				}
				else if ( strcmp(chDllName, "gree.dll") == 0 ) 
				{
					if (pDev->m_bCommStatus == FALSE)
					{
						if (!InitGreeComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate,
							nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
						{
							pDev->m_bCommStatus = FALSE;
						}
						else
						{
							EnterCriticalSection(&g_csGreeReadOneData);
							pDev->m_bCommStatus = GreeReConnectProc(pDev);
							if( pDev->m_bCommStatus == TRUE )
							{
								LOG4C((LOG_NOTICE, "device name:%s open com success！", pDev->m_strDeviceName));
								pDev->m_dwOnlineTick = GetTickCount();
							}
							LeaveCriticalSection(&g_csGreeReadOneData);
						}
					}
				}
				else if ( strcmp(chDllName, "carel.dll") == 0 )
				{
					if (pDev->m_bCommStatus == FALSE)
					{
						if (!InitCarelComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate,
							nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
						{
							pDev->m_bCommStatus = FALSE;
						}
						else
						{
							EnterCriticalSection(&g_csCarelReadOneData);
							pDev->m_bCommStatus = CarelReConnectProc(pDev);
							if( pDev->m_bCommStatus == TRUE )
							{
								LOG4C((LOG_NOTICE, "device name:%s open com success！", pDev->m_strDeviceName));
								pDev->m_dwOnlineTick = GetTickCount();
							}
							LeaveCriticalSection(&g_csCarelReadOneData);
						}
					}
				}
				else if ( strcmp(chDllName, "scantak_3c.dll") == 0 )
				{
					if (pDev->m_bCommStatus == FALSE)
					{
						if (!InitSeparateComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate,
							nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
						{
							pDev->m_bCommStatus = FALSE;
						}
						else
						{
							EnterCriticalSection(&g_csSeparateReadOneData);
							pDev->m_bCommStatus = SeparateReConnectProc(pDev);
							if( pDev->m_bCommStatus == TRUE )
							{
								LOG4C((LOG_NOTICE, "device name:%s open com success！", pDev->m_strDeviceName));
								pDev->m_dwOnlineTick = GetTickCount();
							}
							LeaveCriticalSection(&g_csSeparateReadOneData);
						}
					}
				}
				else if ( strcmp(chDllName, "delta.dll") == 0 )
				{
					if (pDev->m_bCommStatus == FALSE)
					{
						if (!InitSeparateComm(pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate,
							nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
						{
							pDev->m_bCommStatus = FALSE;
						}
						else
						{
							EnterCriticalSection(&g_csSeparateReadOneData);
							pDev->m_bCommStatus = SeparateReConnectProc(pDev);
							if( pDev->m_bCommStatus == TRUE )
							{
								LOG4C((LOG_NOTICE, "device name:%s open com success！", pDev->m_strDeviceName));
								pDev->m_dwOnlineTick = GetTickCount();
							}
							LeaveCriticalSection(&g_csSeparateReadOneData);
						}
					}
				}
				else if( g_FunIniOK( szIniName ) )
				{
					if (pDev->m_bCommStatus == FALSE)
					{
						if (!InitMostDeviceComm(g_strDirectory,  szIniName, pDev->m_iDevideaddr, pDev->m_iPort, nBaudRate,
							nDataBit, pDev->m_iStopbit, pDev->m_iParitybit, 1000))
						{
							pDev->m_bCommStatus = FALSE;
						}
						else
						{
							EnterCriticalSection(&g_csMostDeviceReadOneData);
							pDev->m_bCommStatus = MostDeviceReConnectProc(pDev);
							if( pDev->m_bCommStatus == TRUE )
							{
								LOG4C((LOG_NOTICE, "device name:%s open com success！", pDev->m_strDeviceName));
								pDev->m_dwOnlineTick = GetTickCount();
							}
							LeaveCriticalSection(&g_csMostDeviceReadOneData);		
						}				
					}
				}
				else
				{
					LOG4C((LOG_NOTICE, "找不到2 dll = %s ，ini = %s ，%s",chDllName,szIniName,pDev->m_strDeviceName )); 
				}
			}
		}
		Sleep(100);  //chn add
	}while( WaitForSingleObject( g_hRunObject, 1250L ) == WAIT_TIMEOUT );

	return 0;
}

DWORD WINAPI DevOnlineThreadProc(void *pPara)
{
	do
	{
		// 循环所有设备
		int nDeviceSize = g_pDevicesManager->m_Devices.GetSize();
		for( int i = 0; i < nDeviceSize; i++ )
		{
			CDevice *pDev = g_pDevicesManager->m_Devices[i];
			// 循环所有变量
			int nVarSize = pDev->m_Vars.GetSize();
			for( int j = 0; j < nVarSize; j++ )
			{
				CBaseVar *pBaseVar = pDev->m_Vars[j];
				if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID )		// 内存变量，判断设备是否在线
				{
					if( pDev->m_bySpecialdevice == 2 || pDev->m_bySpecialdevice == 3 )		// 网络设备
					{
						int iPingResult = 0;
						// ping 10 次，如果都是timeout, 认为设备已断线
						for( int iPingIndex = 0; iPingIndex <  5; iPingIndex++ )
						{
							if( Ping(2000, pDev->m_strIp) == 0 )
							{
								iPingResult = 0;
								break;
							}
							else
							{
								iPingResult = 1;
							}
						}

						if( 1 == iPingResult )   // 设备已断线
						{
							//if( pDev->m_bySpecialdevice == 2 )//modify by cHn 2012-07-11改为下面
							if( pDev->m_bySpecialdevice == 2 && pBaseVar->m_nStatus==0 )
							{
								int nIndex = GetTcpThreadStructIndex( pDev->m_strUid );
								if( nIndex != -1 )
								{
									if( g_hRequestDataThread[ g_tcpThreadStruct[nIndex].nTcpTheadIndex ] != NULL )
									{
										//LOG4C((LOG_NOTICE, "Enter SuspendThread."));
										SuspendThread( g_hRequestDataThread[ g_tcpThreadStruct[nIndex].nTcpTheadIndex ] );
										//LOG4C((LOG_NOTICE, "Leave SuspendThread."));
									}
								}
								//LOG4C((LOG_NOTICE, "Enter CloseTcpNet."));
								CloseTcpNet(pDev->m_iDevideaddr, pDev->m_iIpport, (char *)(LPCTSTR)pDev->m_strIp);
								//LOG4C((LOG_NOTICE, "Leave CloseTcpNet."));
							}

							//if( pDev->m_bCommStatus == TRUE )
							{
								if( pBaseVar->m_nStatus==0 )
									LOG4C((LOG_NOTICE, "devname = %s 通信发生故障", pDev->m_strDeviceName));
								EnterCriticalSection( &g_csDevOnlineReadOneData );
								pBaseVar->m_dbData = 1;
								pBaseVar->m_nStatus = 1;
								pDev->m_bCommStatus = FALSE;
								LeaveCriticalSection( &g_csDevOnlineReadOneData );
							}						
						}
						else
						{
							if( pBaseVar->m_nStatus==1 )
								LOG4C((LOG_NOTICE, "devname = %s 通信恢复正常", pDev->m_strDeviceName));
							EnterCriticalSection( &g_csDevOnlineReadOneData );
							pBaseVar->m_dbData = 0;
							pBaseVar->m_nStatus = 0;
							pDev->m_bCommStatus = TRUE;
							LeaveCriticalSection( &g_csDevOnlineReadOneData );//g_csRtuReadOneData
						}
					}
					else	// 串口设备
					{
						if( pDev->m_dwOnlineTick <= 0 )
						{
							pDev->m_dwOnlineTick = GetTickCount();
						}
						
						if( GetTickCount() - pDev->m_dwOnlineTick > 4 * 60 * 1000 && pDev->m_dwOnlineTick > 0 )
						{
							if( pBaseVar->m_nStatus==0 )
							{
								LOG4C((LOG_NOTICE, "%s %d, 串口通信发生故障！", pDev->m_strDeviceName,pDev->m_bySpecialdevice));
							}
							//if( pDev->m_bCommStatus == TRUE )
							{
								EnterCriticalSection( &g_csDevOnlineReadOneData );
								pBaseVar->m_dbData = 1;
								pBaseVar->m_nStatus = 1;
								pDev->m_bCommStatus = FALSE;
								LeaveCriticalSection( &g_csDevOnlineReadOneData );
							}
						}
						else if( GetTickCount() - pDev->m_dwOnlineTick < 4 * 60 * 1000 && pDev->m_dwOnlineTick > 0 )
						{
							if( pBaseVar->m_nStatus==1 )
								LOG4C((LOG_NOTICE, "%s, 串口通信恢复正常！", pDev->m_strDeviceName));
							EnterCriticalSection( &g_csDevOnlineReadOneData );
							pBaseVar->m_dbData = 0;
							pBaseVar->m_nStatus = 0;
							pDev->m_bCommStatus = TRUE;
							LeaveCriticalSection( &g_csDevOnlineReadOneData );
						}
					}
					break;
				}
			}

			Sleep(100);  // 每个设备之间，延时10ms
		}

	}while( WaitForSingleObject( g_hRunObject, 100L ) == WAIT_TIMEOUT );

	return 0;
}

int ModbusRtuProcessProc( CDevice *pDev,bool bTestOnLine=false )
{
	char chMsg[80] = {0};
	SETBASEPARAM SetBasePara = {0};
	SetBasePara.nAddr = pDev->m_iDevideaddr;

	if( bTestOnLine )
	{
		CBaseVar *pBaseVar = FindVar( pDev->m_strDeviceName,pDev->m_sOnLineVarName );

		if( pBaseVar==NULL )
			return -1;

		SetBasePara.nRegNum = pBaseVar->m_iRegisterNum;
		SetBasePara.nStartAddr = pBaseVar->m_nRegStartAddr;
		SetBasePara.FuncCode = pBaseVar->m_iFuncID;

		if( pBaseVar->m_nVarTypeID >= SPECIAL_VAR_TYPE_MIN_ID && pBaseVar->m_nVarTypeID <= SPECIAL_VAR_TYPE_MAX_ID )	// 特殊变量
		{
			int nRet = RtuRequestSpecData(SetBasePara, pBaseVar->m_iDataLen, pDev->m_iPort, pDev->m_iDevideaddr, 
				(char *)(LPCTSTR)pBaseVar->m_strVarUID, pBaseVar->m_nVarID, pBaseVar->m_nVarTypeID);
			
			if (nRet == 0 )
			{
				pDev->m_dwOnlineTick = GetTickCount();
			}
			else if (nRet == 30005)//Modbus rtu设备lrc校验失败
			{
				pDev->m_dwOnlineTick = GetTickCount();
			}
			//else
			//	LOG4C((LOG_NOTICE, "没数据 %s,%s",pDev->m_strDeviceName,pBaseVar->m_strName ));
		}
		else
		{
			int nRet = pRTU_DLLInit(pDev->m_iPort, pDev->m_iDevideaddr, SetBasePara, pBaseVar->m_iDataLen, chMsg);

			if (nRet == 0)//初始化设备DLL
			{
				pDev->m_dwOnlineTick = GetTickCount();
				RtuSingleResponseData((char *)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, chMsg );
			}
			else if (nRet == 30005)//Modbus rtu设备lrc校验失败
			{
				pDev->m_dwOnlineTick = GetTickCount();
			}
			//else
			//	LOG4C((LOG_NOTICE, "没数据 %s,%s",pDev->m_strDeviceName,pBaseVar->m_strName ));
		}
	}
	else
	{
		// 循环所有变量
		int ERROR_COUNT = 0;
		int nVarSize = pDev->m_Vars.GetSize();
		for( int j = 0; j < nVarSize; j++ )
		{
			CBaseVar *pBaseVar = pDev->m_Vars[j];

			if( pBaseVar->m_bReadOnly == 1 ) continue;
			if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

			// 记住上一次读到的数值
			pBaseVar->m_dbLastData = pBaseVar->m_dbData;

			SetBasePara.nRegNum = pBaseVar->m_iRegisterNum;
			SetBasePara.nStartAddr = pBaseVar->m_nRegStartAddr;
			SetBasePara.FuncCode = pBaseVar->m_iFuncID;

			if( pBaseVar->m_nVarTypeID >= SPECIAL_VAR_TYPE_MIN_ID && pBaseVar->m_nVarTypeID <= SPECIAL_VAR_TYPE_MAX_ID )	// 特殊变量
			{
				int nRet = RtuRequestSpecData(SetBasePara, pBaseVar->m_iDataLen, pDev->m_iPort, pDev->m_iDevideaddr, 
					(char *)(LPCTSTR)pBaseVar->m_strVarUID, pBaseVar->m_nVarID, pBaseVar->m_nVarTypeID);

				//if( pBaseVar->m_strDesc=="温湿度1　温度" )
				//	LOG4C((LOG_NOTICE, "%s,ID=%d, nRet=%d, 值 = %d",pBaseVar->m_strDesc,pBaseVar->m_nVarID,nRet,(int)pBaseVar->m_dbData ));

				if (nRet == 0)
				{
					if( pDev->m_sOnLineVarName=="" )
						pDev->m_sOnLineVarName = pBaseVar->m_strName;
				}
				else if (nRet == 30005)//Modbus rtu设备lrc校验失败
				{
					pDev->m_dwOnlineTick = GetTickCount();
				}
				else
				{
					ERROR_COUNT++;
					if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
						return -1;
					continue;
				}
			}
			else
			{
				int nRet = pRTU_DLLInit(pDev->m_iPort, pDev->m_iDevideaddr, SetBasePara, pBaseVar->m_iDataLen, chMsg);
				if (nRet == 0)//初始化设备DLL
				{
					RtuSingleResponseData((char *)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, chMsg );
					if( pDev->m_sOnLineVarName=="" )
						pDev->m_sOnLineVarName = pBaseVar->m_strName;
				}
				else if (nRet == 30005)//Modbus rtu设备lrc校验失败
				{
					pDev->m_dwOnlineTick = GetTickCount();
				}
				else
				{
					ERROR_COUNT++;
					if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
						return -1;
					continue;
				}
			}

			if( abs(pBaseVar->m_dbData - pBaseVar->m_dbLastData) < DATA_CHANGE_FLAG )
			{
			}
			else
			{
				pBaseVar->m_bIsChange = TRUE;
			}

			Sleep(1);
		}
	}

	return 0;
}

int ModbusAscProcessProc(CDevice *pDev,bool bTestOnLine=false)
{
	char chMsg[80] = {0};
	SETBASEPARAM SetBasePara = {0};
	SetBasePara.nAddr = pDev->m_iDevideaddr;

	if( bTestOnLine )
	{
		CBaseVar *pBaseVar = FindVar( pDev->m_strDeviceName,pDev->m_sOnLineVarName );
		if( pBaseVar==NULL )
			return -1;

		SetBasePara.nRegNum = pBaseVar->m_iRegisterNum;
		SetBasePara.nStartAddr = pBaseVar->m_nRegStartAddr;
		SetBasePara.FuncCode = pBaseVar->m_iFuncID;

		if( pBaseVar->m_nVarTypeID >= SPECIAL_VAR_TYPE_MIN_ID && pBaseVar->m_nVarTypeID <= SPECIAL_VAR_TYPE_MAX_ID )	// 特殊变量
		{
			int nRet = AscRequestSpecData((char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, pBaseVar->m_nVarTypeID);
			if( nRet==0 )
			{
				pDev->m_dwOnlineTick = GetTickCount();
			}
			else if (nRet == 20005)//Modbus asc设备lrc校验失败
			{
				pDev->m_dwOnlineTick = GetTickCount();
			}
		}
		else
		{
			int nRet = pASCDLLInit(pDev->m_iPort, pDev->m_iDevideaddr, SetBasePara, pBaseVar->m_iDataLen, chMsg);//初始化设备DLL
			if( nRet==0 )
			{
				//TRACE("变量值id=%d\r\n", pBaseVar->m_nVarID);
				AscSingleResponseData((char *)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, chMsg);
				pDev->m_dwOnlineTick = GetTickCount();
			}
			else if (nRet == 20005)//Modbus asc设备lrc校验失败
			{
				pDev->m_dwOnlineTick = GetTickCount();
			}
		}
	}
	else
	{
		// 循环所有变量
		int ERROR_COUNT = 0;
		int nVarSize = pDev->m_Vars.GetSize();
		for( int j = 0; j < nVarSize; j++ )
		{
			CBaseVar *pBaseVar = pDev->m_Vars[j];

			if( pBaseVar->m_bReadOnly == 1 ) continue;
			if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

			// 记住上一次读到的数值 
			pBaseVar->m_dbLastData = pBaseVar->m_dbData;

			SetBasePara.nRegNum = pBaseVar->m_iRegisterNum;
			SetBasePara.nStartAddr = pBaseVar->m_nRegStartAddr;
			SetBasePara.FuncCode = pBaseVar->m_iFuncID;

			//if( pBaseVar->m_strDesc=="自循环风机托水盘漏水" )
			//	LOG4C((LOG_NOTICE, "自循环风机托水盘漏水 port = %d,地址%d", pDev->m_iPort,pDev->m_iDevideaddr ));

			if( pBaseVar->m_nVarTypeID >= SPECIAL_VAR_TYPE_MIN_ID && pBaseVar->m_nVarTypeID <= SPECIAL_VAR_TYPE_MAX_ID )	// 特殊变量
			{
				//TRACE("变量值id=%d\r\n", pBaseVar->m_nVarID);
				int nRet = AscRequestSpecData((char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, pBaseVar->m_nVarTypeID);
				if( nRet==0 )
				{
					if( pDev->m_sOnLineVarName=="" )
						pDev->m_sOnLineVarName = pBaseVar->m_strName;
				}
				else if (nRet == 20005)//Modbus asc设备lrc校验失败
				{
					pDev->m_dwOnlineTick = GetTickCount();
				}
				else
				{
					ERROR_COUNT++;
					if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
						return -1;
					continue;
				}
			}
			else
			{
				int nRet = pASCDLLInit(pDev->m_iPort, pDev->m_iDevideaddr, SetBasePara, pBaseVar->m_iDataLen, chMsg);//初始化设备DLL
				if( nRet==0 )
				{
					AscSingleResponseData((char *)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, chMsg);
					if( pDev->m_sOnLineVarName=="" )
						pDev->m_sOnLineVarName = pBaseVar->m_strName;
				}
				else if (nRet == 20005)//Modbus asc设备lrc校验失败
				{
					pDev->m_dwOnlineTick = GetTickCount();
				}
				else
				{
					ERROR_COUNT++;
					if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
						return -1;
				}
			}

			if( abs(pBaseVar->m_dbData - pBaseVar->m_dbLastData) < DATA_CHANGE_FLAG )
			{
			}
			else
			{
				pBaseVar->m_bIsChange = TRUE;
			}

			Sleep(1);
		}
	}

	return 0;
}

int ModbusTcpProcessProc(CDevice *pDev,bool bTestOnLine=false)
{
	char chMsg[80] = {0};

	if( bTestOnLine )
	{
		//CBaseVar *pBaseVar = FindVar( pDev->m_strDeviceName,pDev->m_sOnLineVarName );
		//if( pBaseVar==NULL )
		//	return -1;

		//if( WaitForSingleObject( g_hRunObject, 5L ) == WAIT_OBJECT_0 )
		//{
		//	MTVERIFY( SetEvent(pDev->m_hSemNet) );
		//}

		//char chRegNum[4] = {0};
		//char chStartAddr[4] = {0};
		//char chFuncCode[4] = {0}; 

		//if( WaitForSingleObject(pDev->m_hSemNet, 0) == WAIT_OBJECT_0 )	// 有信号才发送数据
		//{
		//	g_nIndex++;
		//	ResetEvent( pDev->m_hSemNet );
		//	if (TcpRequestData(pDev->m_iIpport, 
		//						pDev->m_iDevideaddr, 
		//						(char *)(LPCTSTR)pDev->m_strIp, 
		//						pBaseVar->m_iRegisterNum, 
		//						pBaseVar->m_nRegStartAddr, 
		//						pBaseVar->m_iFuncID) == 0)
		//	{
		//		int nRet = TcpSingleResponseData((char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID);
		//		if( nRet == 0 )
		//		{
		//			pDev->m_dwOnlineTick = GetTickCount();
		//			SetEvent( pDev->m_hSemNet );
		//		}
		//		else if( nRet == 20405 )
		//		{
		//			pDev->m_dwOnlineTick = GetTickCount();
		//		}
		//		else
		//		{
		//			g_nIndex--;
		//			SetEvent( pDev->m_hSemNet );
		//		}
		//	}
		//	else
		//	{
		//		SetEvent( pDev->m_hSemNet );
		//	}
		//}
	}
	else
	{
		// 循环所有变量
		int nVarSize = pDev->m_Vars.GetSize();
		for( int j = 0; j < nVarSize; j++ )
		{
			CBaseVar *pBaseVar = pDev->m_Vars[j];

			if( pBaseVar->m_bReadOnly == 1 ) continue;
			if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

			// 记住上一次读到的数值
			pBaseVar->m_dbLastData = pBaseVar->m_dbData;

			if( WaitForSingleObject( g_hRunObject, 5L ) == WAIT_OBJECT_0 )
			{
				MTVERIFY( SetEvent(pDev->m_hSemNet) );
			}

			char chRegNum[4] = {0};
			char chStartAddr[4] = {0};
			char chFuncCode[4] = {0}; 

			if( WaitForSingleObject(pDev->m_hSemNet, 0) == WAIT_OBJECT_0 )	// 有信号才发送数据
			{
				g_nIndex++;
				ResetEvent( pDev->m_hSemNet );
				if (TcpRequestData(pDev->m_iIpport, 
									pDev->m_iDevideaddr, 
									(char *)(LPCTSTR)pDev->m_strIp, 
									pBaseVar->m_iRegisterNum, 
									pBaseVar->m_nRegStartAddr, 
									pBaseVar->m_iFuncID) == 0)
				{
					int nRet = TcpSingleResponseData((char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID);
					if( nRet == 0 )
					{
						g_nIndex--;
						if( g_nIndex != 0 )
						{
							//TRACE("ModbusTcp数据不同步！\r\n");
						}

						SetEvent( pDev->m_hSemNet );
					}
					else if( nRet == 20405 )
					{
						pDev->m_dwOnlineTick = GetTickCount();
					}
					else
					{
						g_nIndex--;
						SetEvent( pDev->m_hSemNet );
					}
				}
				else
				{
					SetEvent( pDev->m_hSemNet );
				}
			}

			if( abs(pBaseVar->m_dbData - pBaseVar->m_dbLastData) < DATA_CHANGE_FLAG )
			{
				//LOG4C((LOG_NOTICE, "var desc = %s IsChange = false", pBaseVar->m_strDesc));
			}
			else
			{
				//LOG4C((LOG_NOTICE, "var desc = %s IsChange = true", pBaseVar->m_strDesc));
				pBaseVar->m_bIsChange = TRUE;
			}

			Sleep(1);
		}
	}

	return 0;
}

int SnmpProcessProc(CDevice *pDev,bool bTestOnLine=false)
{
	char chMsg[1024] = {0};

	if( bTestOnLine )
	{
	//	CBaseVar *pBaseVar = FindVar( pDev->m_strDeviceName,pDev->m_sOnLineVarName );
	//	if( pBaseVar==NULL )
	//		return -1;

	//	if( pSnmpDllGetValue )
	//	{
	//		//TRACE("变量值id=%d\r\n", pBaseVar->m_nVarID);
	//		int nRet = pSnmpDllGetValue((char *)(LPCTSTR)pDev->m_strIp, 
	//			(char *)(LPCTSTR)pBaseVar->m_strFields,
	//			(char *)(LPCTSTR)pBaseVar->m_strSnmpoi,
	//			chMsg);

	//		LOG4C((LOG_NOTICE, "device name:%s pSnmpDllGetValue = %d", pDev->m_strDeviceName,nRet));

	//		if( nRet == 0 )
	//		{
	//			pDev->m_dwOnlineTick = GetTickCount();
	//			LOG4C((LOG_NOTICE, "SnmpProcessProc1 %s %s ip[%s] oid[%s]！", pDev->m_strDeviceName,pDev->m_sOnLineVarName,pDev->m_strIp,pBaseVar->m_strSnmpoi ));
	//		}
	//	}
	}
	else
	{
		// 循环所有变量
		int ERROR_COUNT = 0;
		int nVarSize = pDev->m_Vars.GetSize();
		for( int j = 0; j < nVarSize; j++ )
		{
			CBaseVar *pBaseVar = pDev->m_Vars[j];

			if( pBaseVar->m_bReadOnly == 1 ) continue;
			if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

			// 记住上一次读到的数值
			pBaseVar->m_dbLastData = pBaseVar->m_dbData;

			if( (pBaseVar->m_strFields!="public" || pBaseVar->m_strFields!="private") && pBaseVar->m_strSnmpoi=="" )
			{
				LOG4C((LOG_NOTICE, "变量错误：DevName=%s VarName=%s 域=%s OID=%s", pDev->m_strDeviceName,pBaseVar->m_strName,pBaseVar->m_strFields,pBaseVar->m_strSnmpoi ));
			}

			if( pSnmpDllGetValue )
			{
				int nRet = pSnmpDllGetValue((char *)(LPCTSTR)pDev->m_strIp, 
					(char *)(LPCTSTR)pBaseVar->m_strFields,
					(char *)(LPCTSTR)pBaseVar->m_strSnmpoi,
					chMsg);

				if( nRet == 0 )
				{
					ParseSnmpData(
						(char *)(LPCTSTR)pDev->m_strUid, 
						pBaseVar->m_nVarID,
						chMsg);

					if( pDev->m_sOnLineVarName=="" )
						pDev->m_sOnLineVarName = pBaseVar->m_strName;
					
					//if( pBaseVar->m_nVarID==427 )
					//{
					//	LOG4C((LOG_NOTICE, "采集成功 %s[%s] ip[%s] oid[%s] 值：%d ！", pDev->m_strDeviceName,pBaseVar->m_strDesc,pDev->m_strIp,pBaseVar->m_strSnmpoi,(int)pBaseVar->m_dbData ));
					//}
				}
				else
				{
					//if( pBaseVar->m_nVarID==427 )
					//{
					//	LOG4C((LOG_NOTICE, "采集失败 %s[%s] ip[%s] oid[%s] 值：%d ！", pDev->m_strDeviceName,pBaseVar->m_strDesc,pDev->m_strIp,pBaseVar->m_strSnmpoi,(int)pBaseVar->m_dbData ));
					//}

					ERROR_COUNT++;
					if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
						return -1;
				}
			}
			else
			{
				LOG4C((LOG_NOTICE, "不能采集，因为 pSnmpDllGetValue = NULL ！" ));
			}

			if( abs(pBaseVar->m_dbData - pBaseVar->m_dbLastData) < DATA_CHANGE_FLAG )
			{
			}
			else
			{
				pBaseVar->m_bIsChange = TRUE;
			}

			Sleep(1);
		}
	}

	return 0;
}

int IcpdasProcessProc(CDevice *pDev,bool bTestOnLine=false)
{
	char chMsg[80] = {0};
	SETBASEPARAM SetBasePara = {0};
	SetBasePara.nAddr = pDev->m_iDevideaddr;

	if( bTestOnLine )
	{
		CBaseVar *pBaseVar = FindVar( pDev->m_strDeviceName,pDev->m_sOnLineVarName );
		if( pBaseVar==NULL )
			return -1;

		SetBasePara.nRegNum = pBaseVar->m_iRegisterNum;
		SetBasePara.nStartAddr = pBaseVar->m_nRegStartAddr;
		SetBasePara.FuncCode = pBaseVar->m_iFuncID;

		int nRet = IcpdasRequestData(0, SetBasePara, pBaseVar->m_iDataLen, pDev->m_iPort, pDev->m_iDevideaddr, 
			(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, (char *)(LPCTSTR)pBaseVar->m_strRs232cmd);
		if( nRet==0 )
		{
			pDev->m_dwOnlineTick = GetTickCount();
		}
		else if( nRet == 20805 )
		{
			pDev->m_dwOnlineTick = GetTickCount();
		}
	}
	else
	{
		// 循环所有变量
		int ERROR_COUNT = 0;
		int nVarSize = pDev->m_Vars.GetSize();
		for( int j = 0; j < nVarSize; j++ )
		{
			CBaseVar *pBaseVar = pDev->m_Vars[j];

			if( pBaseVar->m_bReadOnly == 1 ) continue;
			if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

			// 记住上一次读到的数值
			pBaseVar->m_dbLastData = pBaseVar->m_dbData;

			SetBasePara.nRegNum = pBaseVar->m_iRegisterNum;
			SetBasePara.nStartAddr = pBaseVar->m_nRegStartAddr;
			SetBasePara.FuncCode = pBaseVar->m_iFuncID;

			int nRet = IcpdasRequestData(j, SetBasePara, pBaseVar->m_iDataLen, pDev->m_iPort, pDev->m_iDevideaddr, 
				(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, (char *)(LPCTSTR)pBaseVar->m_strRs232cmd);
			if( nRet==0 )
			{
				if( pDev->m_sOnLineVarName=="" )
					pDev->m_sOnLineVarName = pBaseVar->m_strName;
			}
			else if( nRet == 20805 )
			{
				pDev->m_dwOnlineTick = GetTickCount();
			}
			else
			{
				ERROR_COUNT++;
				if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
					return -1;
				continue;
			}

			if( abs(pBaseVar->m_dbData - pBaseVar->m_dbLastData) < DATA_CHANGE_FLAG )
			{
			}
			else
			{
				pBaseVar->m_bIsChange = TRUE;
			}

			Sleep(1);
		}
	}

	return 0;
}

int ParadigmProcessProc(CDevice *pDev,bool bTestOnLine=false)
{
	char chMsg[80] = {0};

	if( bTestOnLine )
	{
		CBaseVar *pBaseVar = FindVar( pDev->m_strDeviceName,pDev->m_sOnLineVarName );
		if( pBaseVar==NULL )
			return -1;

		int nRet = ParadigmRequestData(pDev->m_iPort, pDev->m_iDevideaddr, 
			(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, (char*)(LPCTSTR)pBaseVar->m_strRs232cmd);
		if( nRet == 0)
		{
			pDev->m_dwOnlineTick = GetTickCount();
		}
		else
		{
		}
	}
	else
	{
		// 循环所有变量
		int ERROR_COUNT = 0;
		int nVarSize = pDev->m_Vars.GetSize();
		for( int j = 0; j < nVarSize; j++ )
		{
			CBaseVar *pBaseVar = pDev->m_Vars[j];

			if( pBaseVar->m_bReadOnly == 1 ) continue;
			if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

			// 记住上一次读到的数值
			pBaseVar->m_dbLastData = pBaseVar->m_dbData;

			int nRet = ParadigmRequestData(pDev->m_iPort, pDev->m_iDevideaddr, 
				(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, (char*)(LPCTSTR)pBaseVar->m_strRs232cmd);
			if( nRet == 0)
			{
				if( pDev->m_sOnLineVarName=="" )
					pDev->m_sOnLineVarName = pBaseVar->m_strName;
			}
			else
			{
				ERROR_COUNT++;
				if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
					return -1;
				continue;
			}

			if( abs(pBaseVar->m_dbData - pBaseVar->m_dbLastData) < DATA_CHANGE_FLAG )
			{
			}
			else
			{
				pBaseVar->m_bIsChange = TRUE;
			}

			Sleep(1);
		}
	}

	return 0;
}

int StulzProcessProc(CDevice *pDev,bool bTestOnLine=false)
{
	char chMsg[80] = {0};
	SETBASEPARAM SetBasePara = {0};
	SetBasePara.nAddr = pDev->m_iDevideaddr;

	if( bTestOnLine )
	{
		CBaseVar *pBaseVar = FindVar( pDev->m_strDeviceName,pDev->m_sOnLineVarName );
		if( pBaseVar==NULL )
			return -1;

		SetBasePara.nRegNum = pBaseVar->m_iRegisterNum;
		SetBasePara.nStartAddr = pBaseVar->m_nRegStartAddr;
		SetBasePara.FuncCode = pBaseVar->m_iFuncID;

		int nRet = StulzRequestData(SetBasePara, pBaseVar->m_iDataLen, pDev->m_iPort, pDev->m_iDevideaddr, 
			(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, (char*)(LPCTSTR)pBaseVar->m_strRs232cmd);
		if( nRet==0 )
		{
			pDev->m_dwOnlineTick = GetTickCount();
		}
		else if( nRet == 20805 )
		{
			pDev->m_dwOnlineTick = GetTickCount();
		}
	}
	else
	{
		// 循环所有变量
		int ERROR_COUNT = 0;
		int nVarSize = pDev->m_Vars.GetSize();
		for( int j = 0; j < nVarSize; j++ )
		{
			CBaseVar *pBaseVar = pDev->m_Vars[j];

			if( pBaseVar->m_bReadOnly == 1 ) continue;
			if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

			// 记住上一次读到的数值
			pBaseVar->m_dbLastData = pBaseVar->m_dbData;

			SetBasePara.nRegNum = pBaseVar->m_iRegisterNum;
			SetBasePara.nStartAddr = pBaseVar->m_nRegStartAddr;
			SetBasePara.FuncCode = pBaseVar->m_iFuncID;

			int nRet = StulzRequestData(SetBasePara, pBaseVar->m_iDataLen, pDev->m_iPort, pDev->m_iDevideaddr, 
				(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, (char*)(LPCTSTR)pBaseVar->m_strRs232cmd);
			if( nRet==0 )
			{
				if( pDev->m_sOnLineVarName=="" )
					pDev->m_sOnLineVarName = pBaseVar->m_strName;
			}
			else if( nRet == 20805 )
			{
				pDev->m_dwOnlineTick = GetTickCount();
			}
			else
			{
				ERROR_COUNT++;
				if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
					return -1;
				continue;
			}

			if( abs(pBaseVar->m_dbData - pBaseVar->m_dbLastData) < DATA_CHANGE_FLAG )
			{
			}
			else
			{
				pBaseVar->m_bIsChange = TRUE;
			}

			Sleep(1);
		}
	}

	return 0;
}

int PowerwareProcessProc(CDevice *pDev,bool bTestOnLine=false)
{
	char chMsg[80] = {0};
	
	if( bTestOnLine )
	{
		CBaseVar *pBaseVar = FindVar( pDev->m_strDeviceName,pDev->m_sOnLineVarName );
		if( pBaseVar==NULL )
			return -1;

		int nRet = PowerwareRequestData(pDev->m_iPort, pDev->m_iDevideaddr, 
				(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, (char*)(LPCTSTR)pBaseVar->m_strRs232cmd);
		if( nRet == 0)
		{
			pDev->m_dwOnlineTick = GetTickCount();
		}
		else if( nRet == 21605 )
		{
			pDev->m_dwOnlineTick = GetTickCount();
		}
	}
	else
	{
		// 循环所有变量
		int ERROR_COUNT = 0;
		int nVarSize = pDev->m_Vars.GetSize();
		for( int j = 0; j < nVarSize; j++ )
		{
			CBaseVar *pBaseVar = pDev->m_Vars[j];

			if( pBaseVar->m_bReadOnly == 1 ) continue;
			if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

			// 记住上一次读到的数值
			pBaseVar->m_dbLastData = pBaseVar->m_dbData;

			int nRet = PowerwareRequestData(pDev->m_iPort, pDev->m_iDevideaddr, 
				(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, (char*)(LPCTSTR)pBaseVar->m_strRs232cmd);
			if( nRet == 0)
			{
				if( pDev->m_sOnLineVarName=="" )
					pDev->m_sOnLineVarName = pBaseVar->m_strName;
			}
			else if( nRet == 21605 )
			{
				pDev->m_dwOnlineTick = GetTickCount();
			}
			else
			{
				ERROR_COUNT++;
				if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
					return -1;
				continue;
			}

			if( abs(pBaseVar->m_dbData - pBaseVar->m_dbLastData) < DATA_CHANGE_FLAG )
			{
			}
			else
			{
				pBaseVar->m_bIsChange = TRUE;
			}

			Sleep(1);
		}
	}

	return 0;
}

int GreeProcessProc(CDevice *pDev,bool bTestOnLine=false)
{
	char chMsg[80] = {0};
	SETBASEPARAM SetBasePara = {0};
	SetBasePara.nAddr = pDev->m_iDevideaddr;

	if( bTestOnLine )
	{
		CBaseVar *pBaseVar = FindVar( pDev->m_strDeviceName,pDev->m_sOnLineVarName );
		if( pBaseVar==NULL )
			return -1;

		SetBasePara.nRegNum = pBaseVar->m_iRegisterNum;
		SetBasePara.nStartAddr = pBaseVar->m_nRegStartAddr;
		SetBasePara.FuncCode = pBaseVar->m_iFuncID;

		int nRet = GreeRequestData(SetBasePara, pBaseVar->m_iDataLen, pDev->m_iPort, pDev->m_iDevideaddr, 
			(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, (char*)(LPCTSTR)pBaseVar->m_strRs232cmd);
		if( nRet == 0)
		{
			pDev->m_dwOnlineTick = GetTickCount();
		}
		else if( nRet == 21805 )
		{
			pDev->m_dwOnlineTick = GetTickCount();
		}
	}
	else
	{
		// 循环所有变量
		int ERROR_COUNT = 0;
		int nVarSize = pDev->m_Vars.GetSize();
		for( int j = 0; j < nVarSize; j++ )
		{
			if( WaitForSingleObject( g_hRunObject, 5L ) == WAIT_OBJECT_0 ) return 0;
			CBaseVar *pBaseVar = pDev->m_Vars[j];

			if( pBaseVar->m_bReadOnly == 1 ) continue;
			if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

			// 记住上一次读到的数值
			pBaseVar->m_dbLastData = pBaseVar->m_dbData;

			SetBasePara.nRegNum = pBaseVar->m_iRegisterNum;
			SetBasePara.nStartAddr = pBaseVar->m_nRegStartAddr;
			SetBasePara.FuncCode = pBaseVar->m_iFuncID;

			int nRet = GreeRequestData(SetBasePara, pBaseVar->m_iDataLen, pDev->m_iPort, pDev->m_iDevideaddr, 
				(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, (char*)(LPCTSTR)pBaseVar->m_strRs232cmd);
			if( nRet == 0)
			{
				if( pDev->m_sOnLineVarName=="" )
					pDev->m_sOnLineVarName = pBaseVar->m_strName;
			}
			else if( nRet == 21805 )
			{
				pDev->m_dwOnlineTick = GetTickCount();
			}
			else
			{
				ERROR_COUNT++;
				if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
					return -1;
				continue;
			}

			if( abs(pBaseVar->m_dbData - pBaseVar->m_dbLastData) < DATA_CHANGE_FLAG )
			{
			}
			else
			{
				pBaseVar->m_bIsChange = TRUE;
			}

			Sleep(1);
		}
	}

	return 0;
}

int CarelProcessProc(CDevice *pDev,bool bTestOnLine=false)
{
	char chMsg[80] = {0};

	if( bTestOnLine )
	{
		CBaseVar *pBaseVar = FindVar( pDev->m_strDeviceName,pDev->m_sOnLineVarName );
		if( pBaseVar==NULL )
			return -1;

		int nRet = CarelRequestData(pDev->m_iPort, pDev->m_iDevideaddr, 
									(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, 
									(char*)(LPCTSTR)pBaseVar->m_strRs232cmd);
		if( nRet == 0)
		{
			pDev->m_dwOnlineTick = GetTickCount();
		}
		else if( nRet == 22205 )
		{
			pDev->m_dwOnlineTick = GetTickCount();
		}
	}
	else
	{
		// 循环所有变量
		int ERROR_COUNT = 0;
		int nVarSize = pDev->m_Vars.GetSize();
		for( int j = 0; j < nVarSize; j++ )
		{

			if( WaitForSingleObject( g_hRunObject, 5L ) == WAIT_OBJECT_0 ) return 0;
			CBaseVar *pBaseVar = pDev->m_Vars[j];

			if( pBaseVar->m_bReadOnly == 1 ) continue;
			if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

			// 记住上一次读到的数值
			pBaseVar->m_dbLastData = pBaseVar->m_dbData;

			int nRet = CarelRequestData(pDev->m_iPort, pDev->m_iDevideaddr, 
									(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, 
									(char*)(LPCTSTR)pBaseVar->m_strRs232cmd);
			if( nRet == 0)
			{
				if( pDev->m_sOnLineVarName=="" )
					pDev->m_sOnLineVarName = pBaseVar->m_strName;
			}
			else if( nRet == 22205 )
			{
				pDev->m_dwOnlineTick = GetTickCount();
			}
			else
			{
				ERROR_COUNT++;
				if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
					return -1;
				continue;
			}

			if( abs(pBaseVar->m_dbData - pBaseVar->m_dbLastData) < DATA_CHANGE_FLAG )
			{
			}
			else
			{
				pBaseVar->m_bIsChange = TRUE;
			}

			Sleep(1);
		}
	}

	return 0;
}

int SeparateProcessProc(CDevice *pDev,bool bTestOnLine=false)
{
	char chMsg[80] = {0};

	char szIniName[MAX_PATH] = {0};
	strcpy(szIniName, (char *)(LPCTSTR)pDev->m_strIniName);
	StrLower(szIniName, szIniName);

	if( bTestOnLine )
	{
		CBaseVar *pBaseVar = FindVar( pDev->m_strDeviceName,pDev->m_sOnLineVarName );
		if( pBaseVar==NULL )
			return -1;

		int nRet = SeparateRequestData(pDev->m_iPort, pDev->m_iDevideaddr, 
									(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, 
									(char*)(LPCTSTR)pBaseVar->m_strRs232cmd,
									szIniName);
		if( nRet == 0)
		{
			pDev->m_dwOnlineTick = GetTickCount();
		}
		else if( nRet == 50205 )
		{
			pDev->m_dwOnlineTick = GetTickCount();
		}
	}
	else
	{
		// 循环所有变量
		int ERROR_COUNT = 0;
		int nVarSize = pDev->m_Vars.GetSize();
		for( int j = 0; j < nVarSize; j++ )
		{
			if( WaitForSingleObject( g_hRunObject, 5L ) == WAIT_OBJECT_0 ) return 0;
			CBaseVar *pBaseVar = pDev->m_Vars[j];

			if( pBaseVar->m_bReadOnly == 1 ) continue;
			if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

			// 记住上一次读到的数值
			pBaseVar->m_dbLastData = pBaseVar->m_dbData;

			int nRet = SeparateRequestData(pDev->m_iPort, pDev->m_iDevideaddr, 
									(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, 
									(char*)(LPCTSTR)pBaseVar->m_strRs232cmd,
									szIniName);
			if( nRet == 0)
			{
				if( pDev->m_sOnLineVarName=="" )
					pDev->m_sOnLineVarName = pBaseVar->m_strName;
			}
			else if( nRet == 50205 )
			{
				pDev->m_dwOnlineTick = GetTickCount();
			}
			else
			{
				ERROR_COUNT++;
				if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
					return -1;
				continue;
			}

			if( abs(pBaseVar->m_dbData - pBaseVar->m_dbLastData) < DATA_CHANGE_FLAG )
			{
			}
			else
			{
				pBaseVar->m_bIsChange = TRUE;
			}

			Sleep(1);
		}
	}

	return 0;
}

int MostDeviceProcessProc(CDevice *pDev,bool bTestOnLine=false)
{
	char chMsg[80] = {0};

	char szIniName[MAX_PATH] = {0};
	strcpy(szIniName, (char *)(LPCTSTR)pDev->m_strIniName);
	StrLower(szIniName, szIniName);

	if( bTestOnLine )
	{
		CBaseVar *pBaseVar = FindVar( pDev->m_strDeviceName,pDev->m_sOnLineVarName );
		if( pBaseVar==NULL )
			return -1;

		int nRet = MostDeviceRequestData(pDev->m_iPort, pDev->m_iDevideaddr, 
									(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, 
									(char*)(LPCTSTR)pBaseVar->m_strRs232cmd,
									szIniName);
		if( nRet == 0)	
		{
			pDev->m_dwOnlineTick = GetTickCount();
		}
		else if( nRet == 50205 )
		{
			pDev->m_dwOnlineTick = GetTickCount();
		}
	}
	else
	{
		// 循环所有变量
		int ERROR_COUNT = 0;
		int nVarSize = pDev->m_Vars.GetSize();
		for( int j = 0; j < nVarSize; j++ )
		{
			if( WaitForSingleObject( g_hRunObject, 0 ) == WAIT_OBJECT_0 ) return 0;
			CBaseVar *pBaseVar = pDev->m_Vars[j];

			if( pBaseVar->m_bReadOnly == 1 ) continue;
			if( pBaseVar->m_nVarTypeID == ONLINE_VAR_ID || HIGH_PRIORITY_ONLINE_ID == pBaseVar->m_nVarTypeID ) continue;  // 内存变量，在DevOnlineThread处理

			// 记住上一次读到的数值
			pBaseVar->m_dbLastData = pBaseVar->m_dbData;

			int nRet = MostDeviceRequestData(pDev->m_iPort, pDev->m_iDevideaddr, 
									(char*)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID, 
									(char*)(LPCTSTR)pBaseVar->m_strRs232cmd,
									szIniName);
			if( nRet == 0)	
			{
				if( pDev->m_sOnLineVarName=="" )
					pDev->m_sOnLineVarName = pBaseVar->m_strName;
			}
			else if( nRet == 50205 )
			{
				pDev->m_dwOnlineTick = GetTickCount();
			}
			else
			{
				ERROR_COUNT++;
				if( ERROR_COUNT>=READ_VAR_ERROR_MAX )
					return -1;
				continue;
			}

			if( abs(pBaseVar->m_dbData - pBaseVar->m_dbLastData) < DATA_CHANGE_FLAG )
			{
			}
			else
			{
				pBaseVar->m_bIsChange = TRUE;
			}

			Sleep(1);
		}
	}

	return 0;
}

DWORD WINAPI RequestDataThreadProc(void *pPara)
{
	DWORD snTick = 0;
#if IS_USER_MUL_THREAD_REQUEST
	CString strName;
	strName = CString((char *)pPara);
	strName.MakeLower();
	//LOG4C((LOG_NOTICE, "RequestDataThreadProc  pPara = %s",strName ));
#endif
	do
	{
		//每二分钟取设备的第一个变量来判断设备是否在线，以前的功能保留
		
		CString sMsg;

		if( snTick==0 )
			snTick = GetTickCount();
		if( GetTickCount()-snTick>=1000*60*1.5 )
		{
			snTick = GetTickCount();
			// 循环所有设备
			int nDeviceSize = g_pDevicesManager->m_Devices.GetSize();
			for( int i = 0; i < nDeviceSize; i++ )
			{
				CDevice *pDev = g_pDevicesManager->m_Devices[i];

				char chDllName[MAX_PATH] = {0};
				strcpy(chDllName, (char *)(LPCTSTR)pDev->m_strProtocoldllname);
				StrLower(chDllName,chDllName);

				char szIniName[MAX_PATH] = {0};
				strcpy(szIniName, (char *)(LPCTSTR)pDev->m_strIniName);
				StrLower(szIniName, szIniName);

				char szUid[MAX_PATH] = {0};
				strcpy(szUid, (char *)(LPCTSTR)pDev->m_strUid);
				StrLower(szUid, szUid);
				
				char szPort[MAX_PATH] = {0};
				CString strPort;
				strPort.Format("%d", pDev->m_iPort);
				strcpy(szPort, (char *)(LPCTSTR)strPort);
				StrLower(szPort, szPort);

				if( pDev->m_bySpecialdevice == 0 )
				{
	#if IS_USER_MUL_THREAD_REQUEST
					if( strName.Compare(szPort) != 0 ) continue;
	#endif
					ModbusRtuProcessProc(pDev,true);
				}
				else if( pDev->m_bySpecialdevice == 1 )
				{
	#if IS_USER_MUL_THREAD_REQUEST
					if( strName.Compare(szPort) != 0 ) continue;
	#endif
					ModbusAscProcessProc(pDev,true);
				}
				else if( pDev->m_bySpecialdevice == 2 )
				{
	#if IS_USER_MUL_THREAD_REQUEST
					if( strName.Compare(szUid) ) continue;
	#endif
					ModbusTcpProcessProc(pDev,true);
				}
				else if( pDev->m_bySpecialdevice == 3 )
				{
	#if IS_USER_MUL_THREAD_REQUEST
					if( strName.Compare(szUid) ) continue;
	#endif

					SnmpProcessProc(pDev,true);
				}
				else if( pDev->m_bySpecialdevice == 4 )
				{
					if ( strcmp(chDllName, "icpdas.dll") == 0 )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif
						IcpdasProcessProc(pDev,true);
					}
					else if ( strcmp(chDllName, "upsparadigm.dll") == 0 )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif
						ParadigmProcessProc(pDev,true);
					}
					else if ( strcmp(chDllName, "stulz.dll") == 0 )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif
						StulzProcessProc(pDev,true);
					}
					
					else if ( strcmp(chDllName, "powerware.dll") == 0 )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif
						PowerwareProcessProc(pDev,true);
					}
					else if ( strcmp(chDllName, "gree.dll") == 0 )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif
						GreeProcessProc(pDev,true);
					}
					else if ( strcmp(chDllName, "carel.dll") == 0 )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif
						CarelProcessProc(pDev,true);
					}
					else if ( strcmp(chDllName, "scantak_3c.dll") == 0 )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif				
						SeparateProcessProc(pDev,true);
					}
					else if ( strcmp(chDllName, "delta.dll") == 0 )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif
						//TRACE("变量值id=%d\r\n", pBaseVar->m_nVarID);
						SeparateProcessProc(pDev,true);
					}
					else if( g_FunIniOK( szIniName ) )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif
						//LOG4C((LOG_NOTICE, "Enter MostDeviceProcessProc szIniName = %s", szIniName));
						MostDeviceProcessProc(pDev,true);
						//LOG4C((LOG_NOTICE, "Leave MostDeviceProcessProc szIniName = %s", szIniName));
					}
					else
					{
						LOG4C((LOG_NOTICE, "找不到3 dll = %s ，ini = %s ，%s",chDllName,szIniName,pDev->m_strDeviceName ));  
					}
				}
			}
		}
		else
		{
			// 循环所有设备
			int nDeviceSize = g_pDevicesManager->m_Devices.GetSize();
			for( int i = 0; i < nDeviceSize; i++ )
			{
				CDevice *pDev = g_pDevicesManager->m_Devices[i];

				char chDllName[MAX_PATH] = {0};
				strcpy(chDllName, (char *)(LPCTSTR)pDev->m_strProtocoldllname);
				StrLower(chDllName,chDllName);

				char szIniName[MAX_PATH] = {0};
				strcpy(szIniName, (char *)(LPCTSTR)pDev->m_strIniName);
				StrLower(szIniName, szIniName);

				char szUid[MAX_PATH] = {0};
				strcpy(szUid, (char *)(LPCTSTR)pDev->m_strUid);
				StrLower(szUid, szUid);
				
				char szPort[MAX_PATH] = {0};
				CString strPort;
				strPort.Format("%d", pDev->m_iPort);
				strcpy(szPort, (char *)(LPCTSTR)strPort);
				StrLower(szPort, szPort);

	#if 1
				if( pDev->m_bCommStatus == FALSE ) 
				{
					Sleep(1);
					continue;
				}
	#endif

				if( pDev->m_bySpecialdevice == 0 )
				{
	#if IS_USER_MUL_THREAD_REQUEST
					if( strName.Compare(szPort) != 0 ) continue;
	#endif
					ModbusRtuProcessProc(pDev);
				}
				else if( pDev->m_bySpecialdevice == 1 )
				{
	#if IS_USER_MUL_THREAD_REQUEST
					if( strName.Compare(szPort) != 0 ) continue;
	#endif
					ModbusAscProcessProc(pDev);
				}
				else if( pDev->m_bySpecialdevice == 2 )
				{
	#if IS_USER_MUL_THREAD_REQUEST
					if( strName.Compare(szUid) ) continue;
	#endif
					ModbusTcpProcessProc(pDev);
				}
				else if( pDev->m_bySpecialdevice == 3 )
				{
	#if IS_USER_MUL_THREAD_REQUEST
					if( strName.Compare(szUid) ) continue;
	#endif
					SnmpProcessProc(pDev);
				}
				else if( pDev->m_bySpecialdevice == 4 )
				{
					if ( strcmp(chDllName, "icpdas.dll") == 0 )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif
						IcpdasProcessProc(pDev);
					}
					else if ( strcmp(chDllName, "upsparadigm.dll") == 0 )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif
						ParadigmProcessProc(pDev);
					}
					else if ( strcmp(chDllName, "stulz.dll") == 0 )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif
						StulzProcessProc(pDev);
					}
					
					else if ( strcmp(chDllName, "powerware.dll") == 0 )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif
						PowerwareProcessProc(pDev);
					}
					else if ( strcmp(chDllName, "gree.dll") == 0 )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif
						GreeProcessProc(pDev);
					}
					else if ( strcmp(chDllName, "carel.dll") == 0 )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif
						CarelProcessProc(pDev);
					}
					else if ( strcmp(chDllName, "scantak_3c.dll") == 0 )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif				
						SeparateProcessProc(pDev);
					}
					else if ( strcmp(chDllName, "delta.dll") == 0 )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif
						//TRACE("变量值id=%d\r\n", pBaseVar->m_nVarID);
						SeparateProcessProc(pDev);
					}
					else if( g_FunIniOK( szIniName ) )
					{
	#if IS_USER_MUL_THREAD_REQUEST
						if( strName.Compare(szPort) != 0 ) continue;
	#endif
						//LOG4C((LOG_NOTICE, "Enter MostDeviceProcessProc szIniName = %s", szIniName));
						MostDeviceProcessProc(pDev);
						//LOG4C((LOG_NOTICE, "Leave MostDeviceProcessProc szIniName = %s", szIniName));
					}
					else
					{
						LOG4C((LOG_NOTICE, "找不到4 dll = %s ，ini = %s ，%s",chDllName,szIniName,pDev->m_strDeviceName )); 
					}
				}
			}
		}
	}while( WaitForSingleObject( g_hRunObject, 5L ) == WAIT_TIMEOUT );

	return 0;

}
DWORD WINAPI SoftRegisterThread(void *pPara)
{
	int nHourCount = 0;//软件运行了多少个小时
	bool bSendLimit=false;//判断是否已经发送只剩多少天试用期 
	DWORD snTick = 0;

	do
	{
		CString sMsg;

		if( snTick==0 )
			snTick = GetTickCount();

		//////////////////////////判断是否过期//////////////////////////
		if( g_nEncryptionType==0 && g_nUseTimeLimit==0 )
		{
			if( GetTickCount()-snTick>=1000*60*60*g_nHourToCount )//24小时=一天//if( (GetTickCount()-snTick>=1000*60*1) )//测试 24分钟=一天
			{
				snTick = GetTickCount();
				
				if( 0 != ReadDogInfo(sMsg) )
				{
					LOG4C((LOG_NOTICE, "%s", sMsg));
					g_sPassDueInfo = sMsg;
				}
			}
		}
		else if( g_nEncryptionType!=0 && g_nEncryptionType!=476 && g_nUseTimeLimit==0 && pRegdllIsValidTime )
		{
			if( GetTickCount()-snTick>=1000*60*60*g_nHourToCount )//24小时=一天//if( (GetTickCount()-snTick>=1000*60*1) )//测试 24分钟=一天
			{
				snTick = GetTickCount();

				pRegdllAddUserDate();

				nHourCount++;
				if( nHourCount%24==0 && nHourCount>0 )//软件每运行24小时检查一次是否试用期少于10了
					bSendLimit = false;
				
				if( 0 != pRegdllIsValidTime(sMsg) )
				{
					LOG4C((LOG_NOTICE, "%s", sMsg));
					g_nUseTimeLimit = 1;//过期
					g_sPassDueInfo = sMsg;
				}
			}
		}

		//////////////////////////判断是否试用期不到10天//////////////////////////
		if( !bSendLimit && g_nEncryptionType==1 && GetTickCount()-snTick>=1000*60*2 && g_nUseTimeLimit==0 )//软件启动后2分钟检查
		{
			bSendLimit = true;

			int n1=-1,n2=-1;
			n1 = g_sPassDueInfo.Find( " " );
			if( n1!=-1 )
			{
				n2 = g_sPassDueInfo.Find( "天",n1 );
				if( n2!=-1 )
				{
					CString s1,s2,sShow;
					s1 = g_sPassDueInfo.Mid(n1+1,n2-n1-1);
					s2 = g_sPassDueInfo.Mid(n1+1);
					if( atoi(s1)<g_nTryTimeLessToNotice )
					{
						LOG4C((LOG_NOTICE, "g_sPassDueInfo = %s %s", s1,s2));
						sShow.Format( g_strHintDateLimit,s2 );
						SendSmsNoticeToUser( 1,sShow );
						g_pServerSocket[1]->AutoSendOtherInfoToAllClient( 1,1,    0,0,0,  0.0,0.0,0.0,  (char *)(LPCTSTR)sShow,"","" );
					}
				}
			}
		}

		//如果试用期过了，则停止采集数据，并通过客户端（不断）,短信通知客户（一次）
		if( g_nUseTimeLimit==1 )
		{
			static bool bCloseGetData = false;
			if( !bCloseGetData )
			{
				bCloseGetData = true;
				if (g_hRunObject != NULL)
					MTVERIFY( SetEvent( g_hRunObject ) );	

				SendSmsNoticeToUser( 1,g_sPassDueInfo );
			}

			g_pServerSocket[1]->AutoSendPastDueInfoToAllClient( g_nUseTimeLimit,g_nSlaveVersion,g_sPassDueInfo );
		}
		
		Sleep( 1500 );

	}while( 1 );//WaitForSingleObject( g_hRunObject, 1000L ) == WAIT_TIMEOUT );

	return 0;
}
DWORD WINAPI GetBlanceThread(void *pPara)
{
	DWORD g_dwTick = 0;
	int nGetGlanceCount=0;//记录向10086要取余额的连续次数，如果为10则认为余额没钱了

	do
	{
		CTime ctNow = CTime::GetCurrentTime(); 
		int nWeek, nHour, nMinute,nDate;
		nWeek = ctNow.GetDayOfWeek()-1;	
		nHour = ctNow.GetHour();
		nMinute = ctNow.GetMinute();
		nDate = ctNow.GetDay()-1;

		//确保一收到10086返回的余额短信就判断余额是否不足，不足就通知客户端
		static bool bSendToIDE = false;
		if( g_bGetBlanceReturn && !bSendToIDE )
		{
			nGetGlanceCount = 0;
			bSendToIDE = true;
			if( int(g_fBlance)<g_nBlanceLessToNotice )
			{
				CString sShow;
				sShow.Format( g_strHintBlance,g_fBlance,g_nBlanceLessToNotice );
				g_pServerSocket[1]->AutoSendOtherInfoToAllClient( 1,0,    0,0,0,  0.0,0.0,0.0,  (char *)(LPCTSTR)sShow,"","" );
				
				LOG4C((LOG_NOTICE, "已经通知用户卡余额不足，不会再通知了" ));
				return 0;
			}
		}
		//////////////////////////////////////////////////////////////////////////////////////////////////////////////
		if( g_dwTick==0 )
			g_dwTick = GetTickCount();

		if( GetTickCount()-g_dwTick>=1000*60*5 )
		{
			if( !g_bGetBlanceReturn && pSmsGetBalance )
			{
				g_dwTick = GetTickCount();
				LOG4C((LOG_NOTICE, "pSmsGetBalance 发送YE到10086 5分钟" ));
				char szSendResult[500] = {0};
				pSmsGetBalance( szSendResult );

				//如果连续10次还没得到余额
				nGetGlanceCount++;
				if( nGetGlanceCount==5 )
				{
					CString sShow;
					sShow = "连续5次还没得到余额，可能是1:卡不是动感地带和神州行;2:卡没钱;3:短信猫没弄好,请检查！";
					//g_pServerSocket[1]->AutoSendOtherInfoToAllClient( 1,0,    0,0,0,  0.0,0.0,0.0,  (char *)(LPCTSTR)sShow,"","" );
					
					LOG4C((LOG_NOTICE, "连续10次还没得到余额，可能是1:卡不是动感地带和神州行;2:卡没钱;3:短信猫没弄好,请检查！" ));
					return 0;
				}
			}
		}
		else if( GetTickCount()-g_dwTick>=1000*60*60*24 )
		{
			g_dwTick = GetTickCount();
			if( pSmsGetBalance )
			{
				nGetGlanceCount++;
				g_bGetBlanceReturn = false;//把标志为0，这样如果这次没收到10086的短信，则可以通过上面的代码得到
				bSendToIDE = false;

				LOG4C((LOG_NOTICE, "pSmsGetBalance 发送YE到10086" ));
				char szSendResult[500] = {0};
				pSmsGetBalance( szSendResult );
			}
		}
		//////////////////////////////////////////////////////////////////////////////////////////////////////////////
		
		Sleep( 2000 );

	}while( 1 );//WaitForSingleObject( g_hRunObject, 1000L ) == WAIT_TIMEOUT );

	return 0;
}


DWORD WINAPI TimingSendSmsThread(void *pPara)
{
	char chTel[MAX_TEL_LENGTH] = {0};
	char chMobile[MAX_TEL_LENGTH] = {0};
	char chFax[MAX_TEL_LENGTH] = {0};
	char chEmail[MAX_EMAIL_LENGTH] = {0};
	
	if( 0 == g_vtUserInfo.size() ) 
	{
		return 0;
	}

	do
	{
		bool bEnable = false;

		CTime ctNow = CTime::GetCurrentTime(); 
		int nWeek, nHour, nMinute,nDate;
		nWeek = ctNow.GetDayOfWeek()-1;	
		nHour = ctNow.GetHour();
		nMinute = ctNow.GetMinute();
		nDate = ctNow.GetDay()-1;
		
		switch( g_nTimingPreiods )
		{
		case 0: //每天发一次
			if( nHour == g_nTimingHours && nMinute == g_nTimingMinutes && g_nTimingEnable == 1 && g_nTimingSendFinished == 0 )
			{
				g_nTimingSendFinished = 1;
				bEnable = true;
			}
			break;
		case 1://每星期发一次
			if( nWeek == g_nTimingWeeks && nHour == g_nTimingHours 	&& nMinute == g_nTimingMinutes && g_nTimingEnable == 1 && g_nTimingSendFinished == 0 )
			{
				g_nTimingSendFinished = 1;
				bEnable = true;
			}
			break;
		case 2: //每月发一次
			if( nDate == g_nTimingWeeks && nHour == g_nTimingHours 	&& nMinute == g_nTimingMinutes && g_nTimingEnable == 1 && g_nTimingSendFinished == 0 )
			{
				g_nTimingSendFinished = 1;
				bEnable = true;
			}
			break;
		}

		if( bEnable )
		{
			LOG4C((LOG_NOTICE, "******** 系统自检 ********"));

			////给勃海钢铁加的发自检时也把温度的值也发过去
			//// 循环所有设备  
			//float fWDData1=0.0,fWDData2=0.0;
			//CString sWDDesc1,sWDDesc2;
			//float fCDData1=0.0,fCDData2=0.0;
			//CString sCDDesc1,sCDDesc2;
			//int nDeviceSize = g_pDevicesManager->m_Devices.GetSize();
			//for( int i = 0; i < nDeviceSize; i++ )
			//{
			//	CDevice *pDev = g_pDevicesManager->m_Devices[i];
			//	// 循环所有变量
			//	int nVarSize = pDev->m_Vars.GetSize();
			//	for( int j = 0; j < nVarSize; j++ )
			//	{
			//		CBaseVar *pBaseVar = pDev->m_Vars[j];

			//		CString strTime;
			//		CTime tm;
			//		tm = CTime::GetCurrentTime();
			//		strTime = tm.Format("%Y-%m-%d %H:%M:%S");	
			//		int iIndex = 0;

			//		if(  pBaseVar->m_strName == "WTH10_1_Temp" )
			//		{
			//			fWDData1 = pBaseVar->m_dbData;
			//			sWDDesc1 = pBaseVar->m_strDesc;
			//		}

			//		if(  pBaseVar->m_strName == "WTH10_2_Temp" )
			//		{
			//			fWDData2 = pBaseVar->m_dbData;
			//			sWDDesc2 = pBaseVar->m_strDesc;
			//		}

			//		if(  pBaseVar->m_strName == "WTH10_1_Humidity" )
			//		{
			//			fCDData1 = pBaseVar->m_dbData;
			//			sCDDesc1 = pBaseVar->m_strDesc;
			//		}

			//		if(  pBaseVar->m_strName == "WTH10_2_Humidity" )
			//		{
			//			fCDData2 = pBaseVar->m_dbData;
			//			sCDDesc2 = pBaseVar->m_strDesc;
			//		}
			//	}
			//}
			//////////////////////////////////////////////////////

			char szResultMsg[MAX_EQUIP_DESC + 1] = {0};
			int nResult = -1;
			memset(szResultMsg, 0, sizeof(szResultMsg));

			if( g_bSendVoice == 1 )
			{
				//EnterCriticalSection( &g_csVarNotice );
				for( int i=0;i<g_vtUserInfo.size();i++ )
				{
					strcpy(chTel, g_vtUserInfo[i].szTel);
					strcpy(chMobile, g_vtUserInfo[i].szMobileTel);

					if( strcmp(chTel, "") != 0 )
					{
						InsertSendVoiceList("0.0.0.0", 1, chTel, (char *)(LPCTSTR)g_strHintSysRun,1001);
					}
				}
				//LeaveCriticalSection( &g_csVarNotice );
			}

			if( g_nSendSms==1 )
			{
#if 0
				CString sTemp;
				sTemp.Format( "%s   %s=%.1f℃, %s=%.1f, %s=%.1f℃, %s=%.1f",g_strHintSysRun,sWDDesc1,fWDData1,sCDDesc1,fCDData1,sWDDesc2,fWDData2,sCDDesc2,fCDData2 );
				InsertSendSmsList( "0.0.0.0", 1, (char *)(LPCTSTR)sTemp,1001 );
#else
				InsertSendSmsList( "0.0.0.0", 1, (char *)(LPCTSTR)g_strHintSysRun,1001 );
#endif
			}
		}

		switch( g_nTimingPreiods )
		{
		case 0: //每天发一次
			if( !( nHour == g_nTimingHours && nMinute == g_nTimingMinutes ) )
			{
				//LOG4C((LOG_NOTICE, "nHour=%d,g_nTimingHours=%d,nMinute=%d,g_nTimingMinutes=%d ", nHour,g_nTimingHours,nMinute,g_nTimingMinutes ));
				g_nTimingSendFinished = 0;
			}
			break;
		case 1://每星期发一次
			if( !( nWeek == g_nTimingWeeks && nHour == g_nTimingHours && nMinute == g_nTimingMinutes ) )
			{
				g_nTimingSendFinished = 0;
			}
			break;
		case 2: //每月发一次
			if( !( nDate == g_nTimingWeeks && nHour == g_nTimingHours && nMinute == g_nTimingMinutes ) )
			{
				g_nTimingSendFinished = 0;
			}
			break;
		}

	}while( WaitForSingleObject( g_hRunObject, 1250L ) == WAIT_TIMEOUT );

	return 0;
}
DWORD WINAPI VoiceNoticeThreadProc(void *pPara)
{
	do
	{
		// 循环所有设备
		int nDeviceSize = g_pDevicesManager->m_Devices.GetSize();
		for( int i = 0; i < nDeviceSize; i++ )
		{
			CDevice *pDev = g_pDevicesManager->m_Devices[i];

			char chDllName[MAX_PATH] = {0};
			strcpy(chDllName, (char *)(LPCTSTR)pDev->m_strProtocoldllname);
			StrLower(chDllName,chDllName);

			char szIniName[MAX_PATH] = {0};
			strcpy(szIniName, (char *)(LPCTSTR)pDev->m_strIniName);
			StrLower(szIniName, szIniName);

			char szUid[MAX_PATH] = {0};
			strcpy(szUid, (char *)(LPCTSTR)pDev->m_strUid);
			StrLower(szUid, szUid);
			
			char szPort[MAX_PATH] = {0};
			CString strPort;
			strPort.Format("%d", pDev->m_iPort);
			strcpy(szPort, (char *)(LPCTSTR)strPort);
			StrLower(szPort, szPort);

			// 循环所有变量
			int nVarSize = pDev->m_Vars.GetSize();
			for( int j = 0; j < nVarSize; j++ )
			{
				CBaseVar *pBaseVar = pDev->m_Vars[j];

				CString strTime;
				CTime tm;
				tm = CTime::GetCurrentTime();
				strTime = tm.Format("%Y-%m-%d %H:%M:%S");	
				int iIndex = 0;

				// 变量的正常范围
				if(  pBaseVar->m_nVarTypeID != SNMP_NPM_TYPE &&
					pBaseVar->m_nVarTypeID != SNMP_STRING_ID )
				{
					if( (int)pBaseVar->m_dbData < pBaseVar->m_nReserved2 || 
						(int)pBaseVar->m_dbData > pBaseVar->m_nReserved3 )
					{
						if( pBaseVar->m_strName=="ACRD101_1_MaxReturnAirTempMetric" )
						{
							LOG4C((LOG_NOTICE, "变量值不在正常范围内: %s, 值: %d ", pBaseVar->m_strDesc,(int)pBaseVar->m_dbData ));
						}
						//LOG4C((LOG_NOTICE, "变量值不在正常范围内: %s, 值: %d ", pBaseVar->m_strDesc,(int)pBaseVar->m_dbData ));
						Sleep(1);
						continue;
					}
				}
				
#if 1
				//0*39.5#温湿度上限告警，当前值39.5
				//0表示没有报警，1表示报警 2表示恢复正常
				if( 1 == g_nSnmpEnable )
				{
					if( TRUE==pBaseVar->m_bIsChange && pBaseVar->m_bReserved4==TRUE )
					{
						//LOG4C((LOG_NOTICE, "pBaseVar->m_bReserved4=%d  pBaseVar->m_bIsChange=%d", pBaseVar->m_bReserved4,pBaseVar->m_bIsChange ));
						CString strSetValue;
						strSetValue.Format("0*%.1f# ", pBaseVar->m_dbData);

						CString strObjID;
						strObjID.Format("%s.%d", g_strSnmpOidRoot, pBaseVar->m_nVarID); 
						//LOG4C((LOG_NOTICE, "strObjID: %s", strObjID ));
						pSnmpDllSetValue(
							g_strSnmpIP,
							g_strSnmpField,
							(char *)(LPCTSTR)strObjID,
							"str",
							1,
							300,
							(char *)(LPCTSTR)strSetValue
						);
					}
				}
#endif

				DWORD iTickCount = GetTickCount();
				if( TRUE == pBaseVar->m_bIsChange )
				{
					g_pServerSocket[1]->AutoSendDataToAllClient( pBaseVar );

					if( TRUE == pBaseVar->m_bRealTimeflag )
					{
						CDBInterface::GetInstancePtr()->EditSummaryRecord(
							(char *)(LPCTSTR)pDev->m_strDeviceName,		// 设备名称
							(char *)(LPCTSTR)strTime,					// 发生时间
							"",											// 备注
							(char *)(LPCTSTR)pBaseVar->m_strDesc,		// 变量描述
							pBaseVar->m_dbData,							// 变量值
							(char *)(LPCTSTR)pDev->m_strUid,			// 设备Uid
							(char *)(LPCTSTR)pBaseVar->m_strName);		// 变量名称
														
						////插入远程数据库
						//g_pServerSocket[6]->InsertRomoteDB(
						//	(char *)(LPCTSTR)pDev->m_strDeviceName,		// 设备名称
						//	(char *)(LPCTSTR)strTime,					// 发生时间
						//	"",											// 备注
						//	(char *)(LPCTSTR)pBaseVar->m_strDesc,		// 变量描述
						//	pBaseVar->m_dbData,							// 变量值
						//	(char *)(LPCTSTR)pDev->m_strUid,			// 设备Uid
						//	(char *)(LPCTSTR)pBaseVar->m_strName);		// 变量名称

						EnterCriticalSection( &g_csRtuReadOneData );
						pBaseVar->m_bIsChange = FALSE;
						LeaveCriticalSection( &g_csRtuReadOneData );
					}
				}
				if( pBaseVar->m_dwCollectTick==0 )
					pBaseVar->m_dwCollectTick = GetTickCount();
				if ((( iTickCount - pBaseVar->m_dwCollectTick) > pBaseVar->m_nCollectFreq * 1000) && pBaseVar->m_bIsSave )
				{
					if( pBaseVar->m_bRealTimeflag )
					{
						CDBInterface::GetInstancePtr()->EditSummaryRecord(
							(char *)(LPCTSTR)pDev->m_strDeviceName,		// 设备名称
							(char *)(LPCTSTR)strTime,					// 发生时间
							"",											// 备注
							(char *)(LPCTSTR)pBaseVar->m_strDesc,		// 变量描述
							pBaseVar->m_dbData,							// 变量值
							(char *)(LPCTSTR)pDev->m_strUid,			// 设备Uid
							(char *)(LPCTSTR)pBaseVar->m_strName);		// 变量名称
					
						////插入远程数据库
						//g_pServerSocket[6]->InsertRomoteDB(
						//	(char *)(LPCTSTR)pDev->m_strDeviceName,		// 设备名称
						//	(char *)(LPCTSTR)strTime,					// 发生时间
						//	"",											// 备注
						//	(char *)(LPCTSTR)pBaseVar->m_strDesc,		// 变量描述
						//	pBaseVar->m_dbData,							// 变量值
						//	(char *)(LPCTSTR)pDev->m_strUid,			// 设备Uid
						//	(char *)(LPCTSTR)pBaseVar->m_strName);		// 变量名称
					}

					//if( pBaseVar->m_bIsSave )
					//{
					//	WriteSummaryLog(
					//		(char *)(LPCTSTR)pDev->m_strDeviceName,		// 设备名称
					//		(char *)(LPCTSTR)strTime,					// 发生时间
					//		"",											// 备注
					//		0,											// 现没有用到
					//		(char *)(LPCTSTR)pBaseVar->m_strDesc,		// 变量描述
					//		pBaseVar->m_dbData,							// 变量值
					//		(char *)(LPCTSTR)pDev->m_strUid,			// 设备Uid
					//		(char *)(LPCTSTR)pBaseVar->m_strName);		// 变量名称	

					//	EnterCriticalSection(&g_csRtuReadOneData);
					//	pBaseVar->m_dwCollectTick = GetTickCount();
					//	LeaveCriticalSection(&g_csRtuReadOneData);
					//}
				}

				if( pBaseVar->m_bReserved2 == TRUE )
				{
					VarAlarmNotice(pDev, pBaseVar);
				}
			}
		}
	}while( WaitForSingleObject( g_hRunObject, 5L ) == WAIT_TIMEOUT );

	return 0;
}
DWORD WINAPI InsertDBThreadProc(void *pPara)
{
	//return 0;
	do
	{
		static DWORD dwTick = 0;
		if( dwTick==0 )
			dwTick = GetTickCount();

		if( GetTickCount()-dwTick>=60*1000*1 && g_nRecordDataMaxID==-1 )
		{
			CHAR chMaxID[MAX_ID] = {0};

			int nRet = CDBInterface::GetInstancePtr()->GetMaxIDByLastLow("t_data_rec", "id", chMaxID);
			if( 0 == atoi(chMaxID) )
			{
				g_nRecordDataMaxID = 1;
			}
			else
			{
				g_nRecordDataMaxID = atoi(chMaxID) + 1;
			}

			LOG4C((LOG_NOTICE, "***** g_nRecordDataMaxID = %d", g_nRecordDataMaxID ));
		}

		if( GetTickCount()-dwTick>=60*1000*5 && g_nRecordDataMaxID>-1 )
		{
			dwTick = GetTickCount();
			// 循环所有设备
			int nDeviceSize = g_pDevicesManager->m_Devices.GetSize();
			for( int i = 0; i < nDeviceSize; i++ )
			{
				CDevice *pDev = g_pDevicesManager->m_Devices[i];

				if( pDev->m_iIsuse==0 )
					continue;

				// 循环所有变量
				int nVarSize = pDev->m_Vars.GetSize();
				for( int j = 0; j < nVarSize; j++ )
				{
					CBaseVar *pBaseVar = pDev->m_Vars[j];

					CString strTime;
					CTime tm;
					tm = CTime::GetCurrentTime();
					strTime = tm.Format("%Y-%m-%d %H:%M:%S");	
					int iIndex = 0;

					// 变量的正常范围
					if(  pBaseVar->m_nVarTypeID != SNMP_NPM_TYPE &&
						pBaseVar->m_nVarTypeID != SNMP_STRING_ID )
					{
						if( (int)pBaseVar->m_dbData < pBaseVar->m_nReserved2 || 
							(int)pBaseVar->m_dbData > pBaseVar->m_nReserved3 )
						{
							Sleep(1);
							continue;
						}
					}

					if( pBaseVar->m_bRealTimeflag )
					{
						int nRet = CDBInterface::GetInstancePtr()->InsertDataRecord(
							g_nRecordDataMaxID,
							(char *)(LPCTSTR)pDev->m_strDeviceName,		// 设备名称
							(char *)(LPCTSTR)strTime,					// 发生时间
							(char *)(LPCTSTR)pBaseVar->m_strName,		// 变量名称
							(char *)(LPCTSTR)pBaseVar->m_strDesc,		// 变量描述
							pBaseVar->m_dbData);						// 变量值

						if( nRet!=1 )
						{
							LOG4C((LOG_NOTICE, "***** InsertDataRecord: 列为%d 失败", g_nRecordDataMaxID-1 ));
						}
					}
				}
			}
		}

		Sleep( 1000 );
	}while( WaitForSingleObject( g_hRunObject, 1000L ) == WAIT_TIMEOUT );

	return 0;
}

DWORD WINAPI OutputThreadProc(void *pPara)
{
	CString strClock, strTh;
	strClock.Format("%s", g_strOutputClock);
	strTh.Format("%s", g_strOutputFileName);
	//LOG4C((LOG_NOTICE, "%s", strClock));
	//LOG4C((LOG_NOTICE, "%s", strTh));
	CStdioFile fClock;
	CStdioFile fTh;
	bool bfClockResult = false;
	bool bfThResult = false;
	bfClockResult = fClock.Open(strClock, CFile::modeCreate | CFile::modeWrite | CFile::shareDenyWrite);
	bfThResult = fTh.Open(strTh, CFile::modeCreate | CFile::modeWrite | CFile::shareDenyWrite);
	do
	{
		CString strTime;
		CTime tm;
		tm = CTime::GetCurrentTime();
		strTime = tm.Format("%H:%M");
		strTime += "\n";

		if( bfClockResult )
		{
			//fClock.SetLength(0);
			fClock.SeekToBegin();
			fClock.Write(strTime.GetBuffer(), strTime.GetLength());
		}

		if( false == bfThResult )
		{
			Sleep(10);
			continue;
		}

		int iDeviceIndex = -1, iVarIndex = -1;
		char szVarName[MAX_UID + 1] = {0};
		
		int iSeekPos = 0;
		fTh.SeekToBegin();
		for( int iLineIndex1 = 0; iLineIndex1 < g_nOutputLineCount1; iLineIndex1++ )
		{
			SplitStr(g_strOutputLine1, ',', iLineIndex1, szVarName);
			BOOL bFind = FindVar( g_strOutputLineUid1, szVarName, iDeviceIndex, iVarIndex );
            if( bFind )
			{
				CDevice *pDev = g_pDevicesManager->m_Devices[iDeviceIndex];
				CBaseVar *pBaseVar = pDev->m_Vars[iVarIndex];

				CString strVarData;
				if( 0 == iLineIndex1 )
				{
					strVarData.Format("%.1f ", pBaseVar->m_dbData);
					fTh.Write(strVarData, strVarData.GetLength());
				}
				else if( 1 == iLineIndex1 )
				{
					strVarData.Format("%.1f%s    \r\n", pBaseVar->m_dbData, pBaseVar->m_strUnit);
					fTh.Write(strVarData, strVarData.GetLength());
				}
				iSeekPos += strVarData.GetLength();
			}
		}

		for( int iLineIndex2 = 0; iLineIndex2 < g_nOutputLineCount2; iLineIndex2++ )
		{
			SplitStr(g_strOutputLine2, ',', iLineIndex2, szVarName);
			BOOL bFind = FindVar( g_strOutputLineUid2, szVarName, iDeviceIndex, iVarIndex );
            if( bFind )
			{
				CDevice *pDev = g_pDevicesManager->m_Devices[iDeviceIndex];
				CBaseVar *pBaseVar = pDev->m_Vars[iVarIndex];

				CString strVarData;
				if( 0 == iLineIndex2 )
				{
					strVarData.Format("%.1f ", pBaseVar->m_dbData);
					fTh.Write(strVarData, strVarData.GetLength());
				}
				else if( 1 == iLineIndex2 )
				{
					strVarData.Format("%.1f%s    \r\n", pBaseVar->m_dbData, pBaseVar->m_strUnit);
					fTh.Write(strVarData, strVarData.GetLength());
				}
				iSeekPos += strVarData.GetLength();
			}
		}

		for( int iLineIndex3 = 0; iLineIndex3 < g_nOutputLineCount3; iLineIndex3++ )
		{
			SplitStr(g_strOutputLine3, ',', iLineIndex3, szVarName);
			BOOL bFind = FindVar( g_strOutputLineUid3, szVarName, iDeviceIndex, iVarIndex );
            if( bFind )
			{
				CDevice *pDev = g_pDevicesManager->m_Devices[iDeviceIndex];
				CBaseVar *pBaseVar = pDev->m_Vars[iVarIndex];

				CString strVarData;
				if( 0 == iLineIndex3 )
				{
					strVarData.Format("%.1f ", pBaseVar->m_dbData);
					fTh.Write(strVarData, strVarData.GetLength());
				}
				else if( 1 == iLineIndex3 )
				{
					strVarData.Format("%.1f%s    \r\n", pBaseVar->m_dbData, pBaseVar->m_strUnit);
					fTh.Write(strVarData, strVarData.GetLength());
				}
				iSeekPos += strVarData.GetLength();
			}
		}
	}while( WaitForSingleObject( g_hRunObject, 100L ) == WAIT_TIMEOUT );

	if( bfClockResult )
	{
		fClock.Close();
	}

	if( bfThResult )
	{
		fTh.Close();
	}

	return 0;
}

DWORD WINAPI GetDatePlanThreadProc(void *pPara)
{
	do
	{
		static int nStaticHours = -1;

		CTime time = CTime::GetCurrentTime();
		int nHours = time.GetHour();

		if( nStaticHours!=nHours )
		{
			//LOG4C((LOG_NOTICE, _T("GetDatePlanThreadProc")));
			nStaticHours = nHours;
			// 循环所有设备
			int nDeviceSize = g_pDevicesManager->m_Devices.GetSize();
			for( int i = 0; i < nDeviceSize; i++ )
			{
				CDevice *pDev = g_pDevicesManager->m_Devices[i];

				// 循环所有变量
				int nVarSize = pDev->m_Vars.GetSize();
				for( int j = 0; j < nVarSize; j++ )
				{
					CBaseVar *pBaseVar = pDev->m_Vars[j];

					EnterCriticalSection(&g_csRtuReadOneData);
					pBaseVar->m_bExistDatePlan = CDBInterface::GetInstancePtr()->IsExistDatePlan((char *)(LPCTSTR)pDev->m_strUid, pBaseVar->m_nVarID);
					LeaveCriticalSection(&g_csRtuReadOneData);
				}
			}
		}

	}while( WaitForSingleObject( g_hRunObject, 10 * 1000L ) == WAIT_TIMEOUT );

	return 0;
}

BOOL FindRtuCommPort( CString strPort,int &iIndex )
{
	BOOL bResult = FALSE;
	for( int i = RTU_THREAD_START; i < g_nRtuThreadIndex; i++ )
	{
		if( g_strPort[i].Compare(strPort) == 0 )
		{
			iIndex = i;
			bResult = TRUE;
			break;
		}
	}
	return bResult;
}

BOOL FindAscCommPort( CString strPort,int &iIndex )
{
	BOOL bResult = FALSE;
	for( int i = ASC_THREAD_START; i < g_nAscThreadIndex; i++ )
	{
		if( g_strPort[i].Compare(strPort) == 0 )
		{
			iIndex = i;
			bResult = TRUE;
			break;
		}
	}
	return bResult;
}

BOOL FindTcpCommPort( CString strPort,int &iIndex )
{
	BOOL bResult = FALSE;
	for( int i = TCP_THREAD_START; i < g_nTcpThreadIndex; i++ )
	{
		if( g_strPort[i].Compare(strPort) == 0 )
		{
			iIndex = i;
			bResult = TRUE;
			break;
		}
	}
	return bResult;
}

BOOL FindMostDeviceCommPort( CString strPort,int &iIndex )
{
	BOOL bResult = FALSE;
	for( int i = MOSTDEVICE_THREAD_START; i < g_nMostDeviceIndex; i++ )
	{
		if( g_strPort[i].Compare(strPort) == 0 )
		{
			iIndex = i;
			bResult = TRUE;
			break;
		}
	}
	return bResult;
}

BOOL FindIcpdasCommPort( CString strPort,int &iIndex )
{
	BOOL bResult = FALSE;
	for( int i = ICPDAS_THREAD_START; i < g_nIcpdasIndex; i++ )
	{
		if( g_strPort[i].Compare(strPort) == 0 )
		{
			iIndex = i;
			bResult = TRUE;
			break;
		}
	}
	return bResult;
}

BOOL FindParadigmCommPort( CString strPort,int &iIndex )
{
	BOOL bResult = FALSE;
	for( int i = PARADIGM_THREAD_START; i < g_nParadigmIndex; i++ )
	{
		if( g_strPort[i].Compare(strPort) == 0 )
		{
			iIndex = i;
			bResult = TRUE;
			break;
		}
	}
	return bResult;
}

BOOL FindStulzCommPort( CString strPort,int &iIndex )
{
	BOOL bResult = FALSE;
	for( int i = STULZ_THREAD_START; i < g_nStulzIndex; i++ )
	{
		if( g_strPort[i].Compare(strPort) == 0 )
		{
			iIndex = i;
			bResult = TRUE;
			break;
		}
	}
	return bResult;
}


BOOL FindPowerwareCommPort( CString strPort,int &iIndex )
{
	BOOL bResult = FALSE;
	for( int i = POWERWARE_THREAD_START; i < g_nPowerwareIndex; i++ )
	{
		if( g_strPort[i].Compare(strPort) == 0 )
		{
			iIndex = i;
			bResult = TRUE;
			break;
		}
	}
	return bResult;
}

BOOL FindGreeCommPort( CString strPort,int &iIndex )
{
	BOOL bResult = FALSE;
	for( int i = GREE_THREAD_START; i < g_nGreeIndex; i++ )
	{
		if( g_strPort[i].Compare(strPort) == 0 )
		{
			iIndex = i;
			bResult = TRUE;
			break;
		}
	}
	return bResult;
}

BOOL FindCarelCommPort( CString strPort,int &iIndex )
{
	BOOL bResult = FALSE;
	for( int i = CAREL_THREAD_START; i < g_nCarelIndex; i++ )
	{
		if( g_strPort[i].Compare(strPort) == 0 )
		{
			iIndex = i;
			bResult = TRUE;
			break;
		}
	}
	return bResult;
}

BOOL FindScanTakCommPort( CString strPort,int &iIndex )
{
	BOOL bResult = FALSE;
	for( int i = SCANTAK_THREAD_START; i < g_nScantakIndex; i++ )
	{
		if( g_strPort[i].Compare(strPort) == 0 )
		{
			iIndex = i;
			bResult = TRUE;
			break;
		}
	}
	return bResult;
}

BOOL FindDeltaCommPort( CString strPort,int &iIndex )
{
	BOOL bResult = FALSE;
	for( int i = DELTA_THREAD_START; i < g_nDeltaIndex; i++ )
	{
		if( g_strPort[i].Compare(strPort) == 0 )
		{
			iIndex = i;
			bResult = TRUE;
			break;
		}
	}
	return bResult;
}

// 获取实际波特率
INT GetCommRate(int nRate)
{
	int nBaudRate = 9600;
	switch( nRate )
	{
	case 0:
		nBaudRate = 1200;
		break;
	case 1:
		nBaudRate = 2400;
		break;
	case 2:
		nBaudRate = 4800;
		break;
	case 3:
		nBaudRate = 9600;
		break;
	case 4:
		nBaudRate = 14400;
		break;
	case 5:
		nBaudRate = 19200;
		break;
	case 6:
		nBaudRate = 38400;
		break;
	case 7:
		nBaudRate = 57600;
		break;
	case 8:
		nBaudRate = 115200;
		break;
	case 9:
		nBaudRate = 128000;
		break;
	case 10:
		nBaudRate = 256000;
		break;
	}

	return nBaudRate;
}

// 获取实际数据位
INT GetCommDataBit(int nDataBitIndex)
{
	int nDataBit = 8;
	switch( nDataBitIndex )
	{
	case 0:
		nDataBit = 7;
		break;
	case 1:
		nDataBit = 8;
		break;
	}

	return nDataBit;
}

//发送短信给用户
//iNoticeType=0表示通知的是手机卡的余额
//iNoticeType=1表示通知的是软加密的期限
INT SendSmsNoticeToUser( int iNoticeType,CString sContent )
{
	if( !g_bAlarmNoticeFlag )
	{
		LOG4C((LOG_NOTICE, "报警通知短信被关闭"));
		return 0 ;
	}

	if( 0 == g_vtUserInfo.size() ) 
	{
		return 0;
	}

	if( iNoticeType==0 )
	{
		LOG4C((LOG_NOTICE, "SendSmsNoticeToUser 通知用户余额不足 %s",sContent));
	}
	else
	{
		LOG4C((LOG_NOTICE, "SendSmsNoticeToUser 通知用户试用期限 %s",sContent));
	}

	if( g_nSendSms==1 )
	{
		//LOG4C((LOG_NOTICE, "test"));
		InsertSendSmsList( "0.0.0.0", 1, (char *)(LPCTSTR)sContent,1002 );
	}

	return 0;
}