/************************************************************************* 
* 版权所有：	
* 文件版本： V1.00
* 文件名称： DILogic.c 
* 生成日期： 2008年11月15日
* 作    者：
* 功    能： 开入逻辑功能
* 更新信息：
* 更新日志1：
* 日期：      
* 修改者：    
* 修改内容：  
* 修改原因：  
* 更新日志2：
**************************************************************************/
#include  "head.h"

/******************************************************************************
函数名称：	ProtectRelayInit
函数版本：	01.01
创建作者：	
创建日期：	2013-08-08
函数说明：	上电时初始化保护相关的定时器，包括定值设置的、固定的
参数说明：
返回值：	
修改记录：	
*/
void ProtectRelayInit(void)
{
	int sw,i;

	for(sw=0;sw<g_sw_num;sw++)
	{
		TRELAY_T *pR=&g_tRelay[ sw];
		TSETSW *pSet = &pRunSet->tSwSet[sw];
		int i;
		
#ifdef	CUSTOMIZE_BZT //备自投
		BztTimerInit(sw);
#endif
		for(i=0;i<BHOC_NUMBER;i++)
		{
			TOC_T *poc=&pR->tOC[i];

		#ifdef YX_RESET_TIME
			InitTR(&poc->tTzEvRstTime, tRunPara.dTEventRst,  0);   // 遥信复归时间
			InitTR(&poc->tGjEvRstTime, tRunPara.dTEventRst,  0);   // 遥信复归时间
		#endif

			InitTR(&poc->tQDTime,    pSet->toc[i].dT,  PRO_RET_TIME); //CorrectTR(&poc->tQDTime); 
			InitTR(&poc->tXBTime,    T_20ms,  0); 
			InitTR(&poc->tXBQD25ms, T_25ms*2, 0);
			InitTR(&poc->tFz25ms,    T_25ms,  0); 
			if(i>=BH_OVI)
			{
				InitTR(&poc->tQDTime,    pSet->toc[i].dT,  WRN_RET_TIME);  // 过载及重载，返回时间为1秒
			}
		}
		{
			TGOC_T *poc=&pR->tgoc;
			GOC_SET *pgset=&pSet->tGocSet;
			DWORD dTsytime;

			dTsytime=((pgset->dTgzgl>pgset->dTsdlost)?pgset->dTgzgl:pgset->dTsdlost)+T_300ms;    
			if(pRunSet->bTT_goose_send_after)
			{
				InitTR(&poc->tTZX_300ms,   pgset->dTgl,   pRunSet->dT_sendext);  //
				InitTR(&poc->tTFX_300ms,   pgset->dTgl,   pRunSet->dT_sendext);  //
				InitTR(&poc->tTWX_300ms,   pgset->dTgl, pRunSet->dT_sendext);  //
				InitTR(&poc->tTLX_300ms,   pgset->dTlx,   pRunSet->dT_sendext);  //
			}
			else
			{
				InitTR(&poc->tTZX_300ms,   T_5ms,   pRunSet->dT_sendext);  //
				InitTR(&poc->tTFX_300ms,   T_5ms,   pRunSet->dT_sendext);  //
				InitTR(&poc->tTWX_300ms,  T_5ms, pRunSet->dT_sendext);  //
				InitTR(&poc->tTLX_300ms,   T_5ms,   pRunSet->dT_sendext);  //
			}
			InitTR(&poc->tTGLBS_300ms,  T_5ms,   pRunSet->dT_sendext);  //
			InitTR(&poc->tglFz25ms,    T_25ms,  0); 
			InitTR(&poc->tlxFz25ms,    T_25ms,  0); 
			InitTR(&poc->tglQD25ms,    T_25ms,  0); 
			InitTR(&poc->tlxQD25ms,    T_25ms,  0); 
			InitTR(&poc->tTHz1s,    T_1s,  0); 
		
			InitTR(&poc->tgoose15ms_gzgl,    pRunSet->dT_goosecheck,  0);  //

			InitTR(&poc->tqccd.tCDTime,pRunSet->dT_cd,  0); 
			InitTR(&poc->tqccd.tWYTime,pRunSet->dT_glfd,  0); 
			InitTR(&poc->tglcd.tCDTime,pRunSet->dT_cd,  0); 
			InitTR(&poc->tglcd.tWYTime,pRunSet->dT_glfd,  0); 
			if(pRunSet->dT_cd==0)
			{
				InitTR(&poc->tllcd.tCDTime,T_1s*15,  0); 
			}
			else
			{
				InitTR(&poc->tllcd.tCDTime,pRunSet->dT_cd,  0); 
			}
			InitTR(&poc->tllcd.tWYTime,pRunSet->dT_llfd,  0); 
			
			if(pRunSet->bTT_goose_send_after)
			{			
				InitTR(&poc->tglQDTime,   pgset->dTgl+pRunSet->dT_goosecheck,  PRO_RET_TIME);  //
				InitTR(&poc->tlxQDTime,   	pgset->dTlx+pRunSet->dT_goosecheck,  PRO_RET_TIME);  //
			}
			else
			{
				InitTR(&poc->tglQDTime,   ((pgset->dTgl>pRunSet->dT_goosecheck)?pgset->dTgl:pRunSet->dT_goosecheck),  PRO_RET_TIME);  //
				InitTR(&poc->tlxQDTime,   	((pgset->dTlx>pRunSet->dT_goosecheck)?pgset->dTlx:pRunSet->dT_goosecheck),  PRO_RET_TIME);  //
			}
			InitTR(&poc->tgzglTime,   	pgset->dTgzgl,  0);  //
			InitTR(&poc->tsdlostTime,   pgset->dTsdlost,  0);  //
			InitTR(&poc->terrlostTime,	pgset->dTgzgl,  0);  //
			InitTR(&poc->tllhzTime,   	pgset->dTll,  0);  //
			InitTR(&poc->tllQdTime,   	pgset->dTll+((pgset->dTgzgl>pgset->dTsdlost)?pgset->dTgzgl:pgset->dTsdlost)+T_1s,  0);  //

			InitTR(&poc->tglslowTime,   0,pgset->dTgl+T_1s);  //
			InitTR(&poc->tlxslowTime,   0,pgset->dTlx+T_1s);  //

#if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
			InitTR(&poc->tgl2Fz25ms,	T_25ms, 0); 
			InitTR(&poc->tgl2QD25ms,	T_25ms, 0); 
			InitTR(&poc->tgl2slowTime,	0,pgset->dTgl2+T_1s);  //#ifdef GD_AREA_GDDKY_TEST
			if(pRunSet->bTT_goose_send_after)
			{
				InitTR(&poc->tgl2QDTime,   pgset->dTgl2+pRunSet->dT_goosecheck,  PRO_RET_TIME);  //
				InitTR(&poc->tTZX2_300ms,   pgset->dTgl2,   pRunSet->dT_sendext);  //
				InitTR(&poc->tTFX2_300ms,   pgset->dTgl2,   pRunSet->dT_sendext);  //
				InitTR(&poc->tTWX2_300ms,   pgset->dTgl2, pRunSet->dT_sendext);  //	
			}
			else
			{
				InitTR(&poc->tgl2QDTime,   ((pgset->dTgl2>pRunSet->dT_goosecheck)?pgset->dTgl2:pRunSet->dT_goosecheck),  PRO_RET_TIME);  //
				InitTR(&poc->tTZX2_300ms,	T_5ms,	pRunSet->dT_sendext);  //
				InitTR(&poc->tTFX2_300ms,	T_5ms,	pRunSet->dT_sendext);  //
				InitTR(&poc->tTWX2_300ms,	T_5ms, pRunSet->dT_sendext);  // 
			}
#endif
			InitTR(&poc->tTzcheckTime,   	pRunSet->dT_TZSB,  0);  //开关失灵判断时间
			InitTR(&poc->tHzcheckTime,   	pRunSet->dT_HZSB,  0);  //开关失灵判断时间

			InitTR(&poc->ttzsbextTime,   	0,pRunSet->dT_sendext);  //  跳闸失败(开关失灵)展宽时间
			InitTR(&poc->tgzglokextTime,   	0,pRunSet->dT_sendext);  // 发送展宽 300毫秒
			InitTR(&poc->tgzglokForbitTime, 0,pRunSet->dT_frobit);  //发送故障隔离成功后闭锁时间
			InitTR(&poc->tCYY3sdelayms,  T_1s*3,dTsytime);    	
			InitTR(&poc->tgoosedelayms_ll,    dTsytime+pRunSet->dT_TZSB*2,  0); 

			InitTR(&poc->tllWY1Time,    T_100ms,  T_100ms); 
			InitTR(&poc->tllWY2Time,    T_100ms,  T_100ms); 
			InitTR(&poc->tllYY1Time,    T_100ms,  T_100ms+T_20ms); 
			InitTR(&poc->tllYY2Time,    T_100ms,  T_100ms+T_20ms); 
			InitTR(&poc->textbsTime,    0,  pRunSet->dT_sendext+T_100ms); 
		}


		//重合闸
		InitTR(&pR->tCHZ.tTCHQDHW0ms50ms,	0,T_10ms*5);           //合闸位置下降沿展宽50ms
		InitTR(&pR->tCHZ.tTCHQD0ms50ms,		0,T_10ms*5  );           //跳闸开出下降沿展宽50ms
		InitTR(&pR->tCHZ.tTCHJD_0ms30ms,	0,T_10ms*3  );           //弹簧未储能下降沿展宽30ms
		InitTR(&pR->tCHZ.tTCHJD_200ms0ms,	T_200ms,0   );           //重合开出宽度
		InitTR(&pR->tCHZ.tTCHCD15s0s,		pSet->dT_chz_cd,0   );           //充电１５秒
		InitTR(&pR->tCHZ.tTCHJD_ARDelay,		pSet->dT_chz[0],0   );           //重合闸延时
		InitTR(&pR->tCHZ.tTCHFAIL_TW,		pSet->dT_chz[0]+T_1s, 0   );           //三相跳位延时: 重合失败返回时间
		InitTR(&pR->tCHZ.tTCHBSDelay,		pSet->dT_chz_bs,0   );           //重合闭锁延时
		InitTR(&pR->tCHZ.tTCHOKTime,			pSet->dT_chz_ok,0   );           //重合闭锁延时	
		//InitTR(&pR->tCHZ.tTCHJD_HJS,			0,			T_1s);		// zwg20151019,后加速有效展宽,从200ms改为1s，方便测试
		InitTR(&pR->tCHZ.tTCHJD_HJS, 0, T_300ms ); // 2020-07-23 分位持续检测时间改为1s，按照广东标准2020 手合开放检测时间，将3s时间改为0.3s，即分闸持续1S以上，手合0.3秒内可启动后加速
		InitTR(&pR->tCHZ.tTCHJBSTime,		0,pSet->dT_chz_ok );           //重合闭锁时间
		InitTR(&pR->tCHZ.tTCHJBSHw,			T_100ms,	0);           // 开关合位100ms确认

	#ifdef PRO_UZ_START_REC
		InitTR(&pR->tCHZ.tTCH_UO_BS,		T_100ms, 0   );           // 零序电压重合闭锁延时
	#endif
		InitTR(&pR->tCHZ.tTCHOPENTime,		pSet->dT_chz_Topen, 0   );           // 重合开放时间
	
	#ifdef SELF_OPEN_RELEASE
		InitTR(&pR->tTripBHTKeep,  0,	tRunPara.wYXFD*T_5ms/5+T_40ms); 
	#endif
		// 保护跳闸脉宽
		InitTR(&pR->tTrip_BHT40MS, 0,			T_40ms);  		//跳闸脉冲最短时间40ms ,以前为100ms，在做多次重合闸是，若时间整定为100ms左右，会有异常
		
		 //配网功能定值
		InitTR(&pR->tSDHZ.tOnXSTime, pSet->dT_X,0);
		InitTR(&pR->tSDHZ.tOnYSTime, pSet->dT_Y,0);
		InitTR(&pR->tSDHZ.tOnZSTime, T_100ms*35,0);  //  3.5秒
		InitTR(&pR->tSDHZ.tOnXLTime, pSet->dT_XL,0);
		InitTR(&pR->tSDHZ.tOnYLTime, pSet->dT_Y,0);
	#ifdef GD_AREA_ZHONGSHAN_2020
		InitTR(&pR->tSDHZ.tOnLLCDYLTime, pSet->dT_LL_CD,0);
	#endif
	
		InitTR(&pR->tSDHZ.tOnBSTZTime, pSet->dT_fa_bsTz,0);  
		InitTR(&pR->tSDHZ.tOnZLTime, T_100ms*35,0);  //  3.5秒
		InitTR(&pR->tSDHZ.tOnOCingTime, pSet->dT_fa_ocing,pSet->dT_Y); 
		InitTR(&pR->tSDHZ.tOnLXingTime, pSet->dT_fa_lxing,pSet->dT_Y); 
		InitTR(&pR->tSDHZ.tOnJSTime, pRunSet->dT_ldjs, 0);		 ////初始化单侧来电解锁计时器
	#ifdef GD_AREA_ZHONGSHAN_2020
		InitTR(&pR->tSDHZ.tOnY_JSTime, 0, 0);		
	#elif defined GD_AREA_ECZD_2020 || defined GD_AREA_ZHONGSHAN
		InitTR(&pR->tSDHZ.tOnY_JSTime, T_1s*6, 0);	
	#else
		InitTR(&pR->tSDHZ.tOnY_JSTime, T_1s*3, 0);		
	#endif

	#if defined GD_AREA_ZHONGSHAN_2020 || defined GD_AREA_ECZD_2020 || defined GD_AREA_ZHONGSHAN
		#if defined GD_AREA_ECZD_2020
			#if defined FUNC_SET_FA_JS
			InitTR(&pR->tSDHZ.tOnHW_FA_JSTime, pRunSet->dT_FA_JS, 0);
			#else
			InitTR(&pR->tSDHZ.tOnHW_FA_JSTime, 5*T_10ms, 0);
			#endif
		#else
			InitTR(&pR->tSDHZ.tOnHW_FA_JSTime, T_1s*6, 0);
		#endif
	#else
		InitTR(&pR->tSDHZ.tOnHW_FA_JSTime, T_1s, 0);
	#endif
	#ifdef	FA_OC_COUNT
		InitTR(&pR->tSDHZ.tFaOcCountTime, pSet->fa_oc_conut_time, 0);
	#endif

		if(pSet->toc[FA_GL].dT>T_FA_TZ_MIN_TIME)
		{
			InitTR(&pR->tSDHZ.tGZJYRstGLTime,pSet->toc[FA_GL].dT,pSet->dT_Y);
		}
		else
		{
			InitTR(&pR->tSDHZ.tGZJYRstGLTime,T_FA_TZ_MIN_TIME,pSet->dT_Y);
		}
		if(pSet->toc[FA_GL_II].dT>T_FA_TZ_MIN_TIME)
		{
			InitTR(&pR->tSDHZ.tGZJYRstGL_II_Time,pSet->toc[FA_GL_II].dT,pSet->dT_Y);
		}
		else
		{
			InitTR(&pR->tSDHZ.tGZJYRstGL_II_Time,T_FA_TZ_MIN_TIME,pSet->dT_Y);
		}
		
		
		if(pSet->toc[FA_GL2].dT>T_FA_TZ_MIN_TIME)
			InitTR(&pR->tSDHZ.tGZJYRstGL2Time,pSet->toc[FA_GL2].dT,T_20ms);
		else
			InitTR(&pR->tSDHZ.tGZJYRstGL2Time,T_FA_TZ_MIN_TIME,T_20ms);

		if(pSet->toc[FA_LX].dT>T_FA_TZ_MIN_TIME)
		{
			InitTR(&pR->tSDHZ.tGZJYRstJDTime,pSet->toc[FA_LX].dT,pSet->dT_Y);
		}
		else
		{
			InitTR(&pR->tSDHZ.tGZJYRstJDTime,T_FA_TZ_MIN_TIME,pSet->dT_Y);
		}		
		
		if(pSet->toc[FA_LX2].dT>T_FA_TZ_MIN_TIME)
			InitTR(&pR->tSDHZ.tGZJYRstJD2Time,pSet->toc[FA_LX2].dT,pSet->dT_Y);
		else
			InitTR(&pR->tSDHZ.tGZJYRstJD2Time,T_FA_TZ_MIN_TIME,pSet->dT_Y);
		
		InitTR(&pR->tSDHZ.tL_RELAYONL3s,	pSet->dT_Y,	0);	
		InitTR(&pR->tSDHZ.tHzS100ms,0, T_200ms);	
		InitTR(&pR->tSDHZ.tUDBS100ms,T_100ms, 0);	
		InitTR(&pR->tSDHZ.tUABS25ms,pSet->dT_fa_YY, T_25ms*2);
		InitTR(&pR->tSDHZ.tUBCS25ms,pSet->dT_fa_YY, T_25ms*2);
#ifdef FUNC_NYY_NWY
		InitTR(&pR->tSDHZ.tUABS_NYY_NWY_50ms,T_25ms*2, T_25ms*2);
		InitTR(&pR->tSDHZ.tUBCS_NYY_NWY_50ms,T_25ms*2, T_25ms*2);
		InitTR(&pR->tSDHZ.tUABL_NYY_NWY_50ms,T_25ms*2, T_25ms*2);
		InitTR(&pR->tSDHZ.tUBCL_NYY_NWY_50ms,T_25ms*2, T_25ms*2);
#endif
		InitTR(&pR->tSDHZ.tUFABL80ms,pRunSet->dT_XCY, pSet->dT_Y-T_1s);
		InitTR(&pR->tSDHZ.tUFBCL80ms,pRunSet->dT_XCY, pSet->dT_Y-T_1s);
		InitTR(&pR->tSDHZ.tUFDBTime,pRunSet->dT_XCY, 0);
		InitTR(&pR->tSDHZ.tUABL25ms,pSet->dT_fa_YY, T_25ms*2);
		InitTR(&pR->tSDHZ.tUBCL25ms,pSet->dT_fa_YY, T_25ms*2); 
		InitTR(&pR->tSDHZ.tUFABS80ms,pRunSet->dT_XCY, pSet->dT_Y-T_1s);
		InitTR(&pR->tSDHZ.tUFBCS80ms,pRunSet->dT_XCY, pSet->dT_Y-T_1s);
		InitTR(&pR->tSDHZ.tUFABS25ms,T_25ms, pRunSet->dT_XCY+T_1s);
		InitTR(&pR->tSDHZ.tUFBCS25ms,T_25ms, pRunSet->dT_XCY+T_1s);
		InitTR(&pR->tSDHZ.tUFABL25ms,T_25ms, pRunSet->dT_XCY+T_1s);
		InitTR(&pR->tSDHZ.tUFBCL25ms,T_25ms, pRunSet->dT_XCY+T_1s);

	#ifdef FA_PL_PJ
		InitTR(&pR->tSDHZ.tFREQAB25ms_SCY,T_25ms*2, T_25ms*2);
		InitTR(&pR->tSDHZ.tFREQBC25ms_SCY,T_25ms*2, T_25ms*2);
		InitTR(&pR->tSDHZ.tFREQAB25ms_LCY,T_25ms*2, T_25ms*2);
		InitTR(&pR->tSDHZ.tFREQBC25ms_LCY,T_25ms*2, T_25ms*2);
		InitTR(&pR->tSDHZ.tFREQSAB25ms,T_25ms, T_25ms*2);
		InitTR(&pR->tSDHZ.tFREQSBC25ms,T_25ms, T_25ms*2);
		InitTR(&pR->tSDHZ.tFREQLAB25ms,T_25ms, T_25ms*2);
		InitTR(&pR->tSDHZ.tFREQLBC25ms,T_25ms, T_25ms*2);
	#endif
	
		InitTR(&pR->tSDHZ.tOpsiteYY100ms,0, 0);
		InitTR(&pR->tSDHZ.tPowerYY100ms,0, 0);		
		InitTR(&pR->tSDHZ.tHw100ms100ms,T_100ms,T_100ms);
		InitTR(&pR->tSDHZ.tTw100ms100ms,T_100ms,T_100ms);		
		InitTR(&pR->tSDHZ.tHz0ms1s,0,tRunPara.wFAHZT*T_5ms/5+T_1s);
		InitTR(&pR->tSDHZ.tTz0ms1s,0,tRunPara.wFAFZT*T_5ms/5+T_1s);	
		InitTR(&pR->tSDHZ.tHz0ms2s,pRunSet->dT_HZSB,0);
		InitTR(&pR->tSDHZ.tTz0ms2s,pRunSet->dT_TZSB,0);	
		InitTR(&pR->tSDHZ.tTSDHzHJS, 0, pSet->dT_Y); //上电合闸加速判断 
		
		InitTR(&pR->tU0TZ.tZOVTime,  		pSet->dT_OverU0, T_20ms); 
		InitTR(&pR->tOVER_U0TZ.tZOVTime,  	pSet->dBHTOverU0, T_20ms); 

		//InitTR(&pR->tGdy.tQDTime,  pSet->dT_gy, T_20ms); 	

		InitTR(&pR->tLostVot.tCYY25ms0ms,  T_25ms, 0);    	
		InitTR(&pR->tLostVot.tLostVotTime,  pSet->dT_Z, T_20ms);    	
		InitTR(&pR->tLostVot.tLostVLockTime,0,pSet->dT_fa_bsTz);
		InitTR(&pR->tTQHz.tTQTime,pSet->dT_tq,0); //同期
		InitTR(&pR->tTQHz.tTQQDTime,0, pRunSet->dT_tq_fh);
		//解列
		InitTR(&pR->tDYJL.tDdyTime,  pSet->dT_jl_ddy, T_20ms);   //CorrectTR(&pR->tDYJL.tDdyTime);  CorrectTR(&pR->tDYJL.tDdyTime);   	
		InitTR(&pR->tDYJL.tGdyTime,  pSet->dT_jl_gdy, T_20ms);   //CorrectTR(&pR->tDYJL.tGdyTime);  CorrectTR(&pR->tDYJL.tGdyTime);     	
		InitTR(&pR->tDYJL.tHighTime,  pSet->dT_jl_ggdy, T_20ms); //CorrectTR(&pR->tDYJL.tHighTime); CorrectTR(&pR->tDYJL.tHighTime);
		InitTR(&pR->tDYJL.tLowTime,  pSet->dT_jl_gddy, T_20ms);	

		InitTR(&pR->tPLJL.tDhzTime,  pSet->dT_jl_dhz, T_40ms);  //CorrectTR(&pR->tPLJL.tDhzTime);   CorrectTR(&pR->tPLJL.tDhzTime);    	
		InitTR(&pR->tPLJL.tHighTime,  pSet->dT_jl_ghz, T_40ms); //CorrectTR(&pR->tPLJL.tHighTime);  CorrectTR(&pR->tPLJL.tHighTime);   	
		InitTR(&pR->tPLJL.tLowTime,  pSet->dT_jl_lowhz, T_40ms);//CorrectTR(&pR->tPLJL.tLowTime);   CorrectTR(&pR->tPLJL.tLowTime); 

		InitTR(&pR->tDYJL.thcbs1_0ms_100ms,  0, T_100ms);   // 滑差闭锁延迟返回继电器
		InitTR(&pR->tDYJL.thcbs2_0ms_100ms,  0, T_100ms); 
		InitTR(&pR->tPLJL.thcbs1_0ms_100ms,  0, T_100ms);  
		InitTR(&pR->tPLJL.thcbs2_0ms_100ms,  0, T_100ms);  		
		
		//手合加速
        InitTR(&pR->tSWST.tTRunST_20s1s, T_1s, T_300ms ); // 2020-07-23 分位持续检测时间改为1s，按照广东标准2020 手合开放检测时间，将3s时间改为0.3s，即分闸持续1S以上，手合0.3秒内可启动后加速
	#if defined GD_AREA_ECZD_2020
		InitTR(&pR->tSWST.tSHz3s10ms,  T_1s, T_10ms);     	
	#else
		InitTR(&pR->tSWST.tSHz3s10ms,  T_1s*3, T_10ms); 
	#endif
		InitTR(&pR->tSWST.tSTz3s10ms,  T_1s*3, T_10ms); 
		InitTR(&pR->tSWST.tSf3s,  T_1s*3, 0); 		
		InitTR(&pR->tSWST.tTTWYL_10S1S,T_1s*10, T_1s); 
		InitTR(&pR->tSWST.tTWCNGJ1s,  pRunSet->dWCN_T,   WRN_RET_TIME);	
		InitTR(&pR->tSWST.tTKZHLGJ1s,  T_1s*10,   WRN_RET_TIME);
		InitTR(&pR->tSWST.tIBSCHZ,  T_25ms,   WRN_RET_TIME);//	T_1s
		InitTR(&pR->tTripfail_2s, 	pRunSet->dT_TZSB,		0);  		//跳闸失败时间继电器
		InitTR(&pR->tTripfail_hz, 0	,		pRunSet->dT_TZSB);  		//跳闸失败时间继电器
		
		InitTR(&pR->tSWST.tCTXXYC, 	T_1s*3,	WRN_RET_TIME);  		// CT相序异常
		InitTR(&pR->tSWST.tCTYC, 	T_1s*10,	WRN_RET_TIME);  		// CT断线 
		InitTR(&pR->tSWST.tBatChk, 	T_1s*3,	WRN_RET_TIME);  		// 电池电压低
		InitTR(&pR->tSWST.tBatOver, T_1s*3,	WRN_RET_TIME);
		InitTR(&pR->tMb_yuk_time,  T_1s*5, 0); 
		InitTR(&pR->tTZZFG_5S0ms,  pRunSet->dT_ZZFG, 0);     	//无故障延时5s
		InitTR(&pR->thzbs.tBSHZTime, 	pSet->dT_hzbs,	T_20ms);  		// 分闸次数过多，闭锁合闸
		InitTR(&pR->thzbs.tTw100ms100ms,T_100ms,T_100ms);	
		for(i=0;i<8;i++)
		{
			if(pRunSet->bTT_FDLTz[i])
			{
				InitTR(&pR->tFdl[i].tFdlTime,pRunSet->dTFDL[i], PRO_RET_TIME);  
			}

			else
			{
				InitTR(&pR->tFdl[i].tFdlTime,pRunSet->dTFDL[i], WRN_RET_TIME);  
			}
		}
		fresh_set_soe(EV_TYPE_S, !g_tRelay[sw].run_stu.fa_ls,true,sw);
		fresh_set_soe(EV_TYPE_L, g_tRelay[sw].run_stu.fa_ls,true,sw);

		//自供电功能投入
		{
			//bool bll;
			//bll=(g_tRelay[sw].run_stu.fa_ls&&pRunSet->tSwSet[sw].bTT_FA&&FA_ALL_EN(sw))
			//	||(g_tRelay[sw].tgoc.tllcd.sta.bFlag.bCD&&BH_GOOSE_EN(sw));
			//fresh_set_soe(EV_FA_LL_EN,(g_tRelay[sw].tgoc.tllcd.sta.bFlag.bCD&&BH_GOOSE_EN(sw)),true,sw);
		}
		//soft_yb set		
		fresh_set_soe(EV_KZ_YB, pRunSet->tSwSet[sw].btt_yxyb_gnzck, true,sw); 	
		fresh_set_soe(EV_EDIT_YB, pRunSet->bTT_EDIT_YB, true,sw); 
		
		#if defined GD_AREA_ECZD_2020
			fresh_set_soe(EV_CHZ_YB,CHZ_ALL_EN(sw) , true,sw);//重合闸投入
		#else
			fresh_set_soe(EV_CHZ_YB,!CHZ_ALL_EN(sw) , true,sw);//停用重合闸
		#endif		

		fresh_set_soe(EV_BH_YB, FUN_ALL_EN(sw), true,sw);
	   	
	#if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 || defined GD_AREA_ECZD_2020
		fresh_set_soe(EV_BH_YBTT, BH_ALL_EN(sw), true,sw);
		fresh_set_soe(EV_FA_YBTT, FA_ALL_EN(sw), true,sw);
		fresh_set_soe(EV_GOOSE_YBTT, BH_GOOSE_EN(sw), true,sw);			
	#endif  
		fresh_set_soe(EV_TQ_YBTT,TYTQ_ALL_EN(sw),true,sw);
		fresh_set_soe(EV_JL_YBTT,JL_ALL_EN(sw),true,sw);// 自动解列软压板

	#ifdef FUNC_DRIVE_JY
		InitTR(&gb_drive.tDriveUa1Time,pSet->dT_drive_ua1, 0);
		InitTR(&gb_drive.tDriveUa2Time,pSet->dT_drive_ua2, 0);
		InitTR(&gb_drive.tDriveU0Time,pSet->dT_drive_u0, 0);
		InitTR(&gb_drive.tDriveITime,pSet->dT_drive_i, 0);
		InitTR(&gb_drive.tDriveI0Time,pSet->dT_drive_i0, 0);
		InitTR(&gb_drive.tDriveAgainTime,pSet->dT_drive_again, 0);
		InitTR(&gb_drive.tDriveFaBSTime,T_25ms*2, 0);
	#endif
	
	#ifdef FUNC_DRIVE
		InitTR(&gb_drive.tQDTime_hz,pRunSet->tSwSet[sw].dT_Drive_hz, 0);
		InitTR(&gb_drive.tQDTime_fz,pRunSet->tSwSet[sw].dT_Drive_fz, 0);
		InitTR(&gb_drive.tQDTime_fz_end,pRunSet->tSwSet[sw].dT_fz_end, 0);
		InitTR(&gb_drive.tQDTime_hz_end,pRunSet->tSwSet[sw].dT_hz_end, 0);
	#endif
	#ifdef FUNC_REBOOT_BS_HA_JS_3S
		InitTR(&pR->tSDHZ.tHW_JS_HA_3STime, T_1s*3, 0);
	#endif
	}

	for(i=0;i<VOL_NUMBER;i++)
	{
		InitTR(&g_tVol[i].tQDTime,pRunSet->tVolSet[i].dTVol, WRN_RET_TIME);  
		InitTR(&g_tVol[i].tCYYTime,T_40ms, 0);  
		InitTR(&g_tVol[i].tWaveYYTime,T_40ms, 0);  
	}
	
	InitTR(&g_rmt_op.tTULK3STime,  T_1s*3, 0);     	
	InitTR(&g_tJLSDTime,pRunSet->dSDYX_T, T_1s*5);  

	InitTR(&tPT.tTPT1DXTime,T_1s*10, WRN_RET_TIME);  
	InitTR(&tPT.tTPT2DXTime,T_1s*10, WRN_RET_TIME); 
	SetTR_TRTT(&tPT.tTPT1DXTime, WRN_RET_TIME);
	SetTR_TRTT(&tPT.tTPT2DXTime, WRN_RET_TIME);
	InitTR(&tPT.tBatOnTime,T_1s*2, WRN_RET_TIME);  
	InitTR(&tPT.tTPT1XXYC,T_1s*3, WRN_RET_TIME);  
	InitTR(&tPT.tTPT2XXYC,T_1s*3, WRN_RET_TIME);  	

#ifdef IEC_NOLINK_NO_CALLYX
	InitTR(&g_link_comm.tLinkBreak,T_1s*60*3, 0);									
#endif

#ifdef FUN_JDXX
	jdxx_relayinit();	
#endif	
}

/******************************************************************************
函数名称：	ProtectRelayInit1
函数版本：	01.01
创建作者：	
创建日期：	2013-08-08
函数说明：	在保护巡检时有定值修改，重新初始化与保护相关的定时器，使修改后的延时有效
参数说明：
返回值：	
修改记录：	
*/
void ProtectRelayInit1(void)
{  	    
	int sw,i;

	for(sw=0;sw<g_sw_num;sw++)
	{
		TRELAY_T *pR=&g_tRelay[ sw];
		TSETSW *pSet = &pRunSet->tSwSet[sw];
		int i;
		
#ifdef	CUSTOMIZE_BZT //备自投
		BztTimerChange(sw);
#endif
		for(i=0;i<BHOC_NUMBER;i++)
		{
			TOC_T *poc=&pR->tOC[i];

		#ifdef YX_RESET_TIME
			InitTR(&poc->tTzEvRstTime, tRunPara.dTEventRst,  0);   // 遥信复归时间
			InitTR(&poc->tGjEvRstTime, tRunPara.dTEventRst,  0);   // 遥信复归时间
		#endif	

			InitTR_Time(&poc->tQDTime,    pSet->toc[i].dT,  PRO_RET_TIME); 
			InitTR_Time(&poc->tXBTime,    pSet->toc[i].dT,  PRO_RET_TIME); 
			InitTR(&poc->tXBQD25ms, T_25ms*2, 0);
			if(i>=BH_OVI)
			{
				InitTR_Time(&poc->tQDTime,    pSet->toc[i].dT,  WRN_RET_TIME);  // 过载及重载，返回时间为1秒
			}
		}
		{
			TGOC_T *poc=&pR->tgoc;
			GOC_SET *pgset=&pSet->tGocSet;
			DWORD dTsytime;

			dTsytime=((pgset->dTgzgl>pgset->dTsdlost)?pgset->dTgzgl:pgset->dTsdlost)+T_300ms;    
			if(pRunSet->bTT_goose_send_after)
			{
				InitTR_Time(&poc->tTZX_300ms,   pgset->dTgl,   pRunSet->dT_sendext);  //
				InitTR_Time(&poc->tTFX_300ms,   pgset->dTgl,   pRunSet->dT_sendext);  //
				InitTR_Time(&poc->tTWX_300ms,   pgset->dTgl, pRunSet->dT_sendext);  //
				InitTR_Time(&poc->tTLX_300ms,   pgset->dTlx,   pRunSet->dT_sendext);  //
			}
			else			
			{
				InitTR_Time(&poc->tTZX_300ms,	T_5ms,   pRunSet->dT_sendext);  //
				InitTR_Time(&poc->tTFX_300ms,	T_5ms,   pRunSet->dT_sendext);  //
				InitTR_Time(&poc->tTWX_300ms,	T_5ms, pRunSet->dT_sendext);	//
				InitTR_Time(&poc->tTLX_300ms,	T_5ms,   pRunSet->dT_sendext);  //
			}
			InitTR_Time(&poc->tTGLBS_300ms,   T_5ms,   pRunSet->dT_sendext);  //
			InitTR_Time(&poc->tgoose15ms_gzgl,    pRunSet->dT_goosecheck,  0);  //

			InitTR_Time(&poc->tqccd.tCDTime,pRunSet->dT_cd,  0); 
			InitTR_Time(&poc->tqccd.tWYTime,pRunSet->dT_glfd,  0); 
			InitTR_Time(&poc->tglcd.tCDTime,pRunSet->dT_cd,  0); 
			InitTR_Time(&poc->tglcd.tWYTime,pRunSet->dT_glfd,  0); 
			if(pRunSet->dT_cd==0)
			{
				InitTR_Time(&poc->tllcd.tCDTime,T_1s*15,  0); 
			}
			else
			{
				InitTR_Time(&poc->tllcd.tCDTime,pRunSet->dT_cd,  0); 
			}
			
			InitTR_Time(&poc->tllcd.tWYTime,pRunSet->dT_llfd,  0); 
			if(pRunSet->bTT_goose_send_after)
			{			
				InitTR_Time(&poc->tglQDTime,   pgset->dTgl+pRunSet->dT_goosecheck,  PRO_RET_TIME);  //
				InitTR_Time(&poc->tlxQDTime,   	pgset->dTlx+pRunSet->dT_goosecheck,  PRO_RET_TIME);  //
			}
			else
			{
				InitTR_Time(&poc->tglQDTime,   ((pgset->dTgl>pRunSet->dT_goosecheck)?pgset->dTgl:pRunSet->dT_goosecheck),  PRO_RET_TIME);  //
				InitTR_Time(&poc->tlxQDTime,   	((pgset->dTlx>pRunSet->dT_goosecheck)?pgset->dTlx:pRunSet->dT_goosecheck),  PRO_RET_TIME);  //
			}	
			
			InitTR_Time(&poc->tgzglTime,   	pgset->dTgzgl,  0);  //
			InitTR_Time(&poc->tsdlostTime,   pgset->dTsdlost,  0);  //
			InitTR_Time(&poc->terrlostTime,	pgset->dTgzgl,  0);  //
			InitTR_Time(&poc->tllhzTime,   	pgset->dTll,  0);  //
			InitTR_Time(&poc->tllQdTime,   	pgset->dTll+((pgset->dTgzgl>pgset->dTsdlost)?pgset->dTgzgl:pgset->dTsdlost)+T_1s,  0);  //

			InitTR_Time(&poc->tglslowTime,   0,pgset->dTgl+T_1s);  //
			InitTR_Time(&poc->tlxslowTime,   0,pgset->dTlx+T_1s);  //

#if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
			if(pRunSet->bTT_goose_send_after)
			{
				InitTR_Time(&poc->tgl2QDTime,	pgset->dTgl2+pRunSet->dT_goosecheck,  PRO_RET_TIME);  //
				InitTR_Time(&poc->tTZX2_300ms,   pgset->dTgl2,   pRunSet->dT_sendext);  //
				InitTR_Time(&poc->tTFX2_300ms,   pgset->dTgl2,   pRunSet->dT_sendext);  //
				InitTR_Time(&poc->tTWX2_300ms,   pgset->dTgl2, pRunSet->dT_sendext);  //
			}
			else			
			{
				InitTR_Time(&poc->tgl2QDTime,   ((pgset->dTgl2>pRunSet->dT_goosecheck)?pgset->dTgl2:pRunSet->dT_goosecheck),  PRO_RET_TIME);  //
				InitTR_Time(&poc->tTZX2_300ms,	 T_5ms,	 pRunSet->dT_sendext);	//
				InitTR_Time(&poc->tTFX2_300ms,	 T_5ms,	 pRunSet->dT_sendext);	//
				InitTR_Time(&poc->tTWX2_300ms,	 T_5ms, pRunSet->dT_sendext);  //
			}
			InitTR_Time(&poc->tglslowTime,	0,pgset->dTgl2+T_1s);  //
#endif
			InitTR_Time(&poc->tTzcheckTime,   	pRunSet->dT_TZSB,  0);  //开关失灵判断时间
			InitTR_Time(&poc->tHzcheckTime,   	pRunSet->dT_HZSB,  0);  //开关失灵判断时间

			InitTR_Time(&poc->ttzsbextTime,   	0,pRunSet->dT_sendext);  //  跳闸失败(开关失灵)展宽时间
			InitTR_Time(&poc->tgzglokextTime,   	0,pRunSet->dT_sendext);  // 发送展宽 300毫秒
			InitTR_Time(&poc->tgzglokForbitTime, 0,pRunSet->dT_frobit);  //发送故障隔离成功后闭锁时间
			InitTR_Time(&poc->tCYY3sdelayms,  T_1s*3,dTsytime);    	
			InitTR_Time(&poc->tgoosedelayms_ll,    dTsytime+pRunSet->dT_TZSB*2,  0); 
			InitTR_Time(&poc->textbsTime,    0,  pRunSet->dT_sendext+T_100ms); 
		}


		//重合闸
		InitTR_Time(&pR->tCHZ.tTCHCD15s0s,		pSet->dT_chz_cd,0   );           //充电１５秒
		InitTR_Time(&pR->tCHZ.tTCHJD_ARDelay,		pSet->dT_chz[0],0   );           //重合闸延时
		InitTR_Time(&pR->tCHZ.tTCHFAIL_TW,		pSet->dT_chz[0]+T_1s, 0   );           //三相跳位延时: 重合失败返回时间
		InitTR_Time(&pR->tCHZ.tTCHBSDelay,		pSet->dT_chz_bs,0   );           //重合闭锁延时
		InitTR_Time(&pR->tCHZ.tTCHOKTime,			pSet->dT_chz_ok,0   );           //重合闭锁延时	
		 InitTR_Time(&pR->tCHZ.tTCHJBSTime,		 0,pSet->dT_chz_ok );			//重合闭锁时间
	#ifdef PRO_UZ_START_REC
		InitTR(&pR->tCHZ.tTCH_UO_BS,		 T_100ms, 0   );			// 零序电压重合闭锁延时
	#endif
		InitTR(&pR->tCHZ.tTCHOPENTime, 	 pSet->dT_chz_Topen, 0	 ); 		  // 重合开放时间
		
		 //配网功能定值
		InitTR_Time(&pR->tSDHZ.tOnXSTime, pSet->dT_X,0);
		InitTR_Time(&pR->tSDHZ.tOnYSTime, pSet->dT_Y,0);
		InitTR_Time(&pR->tSDHZ.tOnXLTime, pSet->dT_XL,0);
		InitTR_Time(&pR->tSDHZ.tOnYLTime, pSet->dT_Y,0);
	#ifdef GD_AREA_ZHONGSHAN_2020
		InitTR_Time(&pR->tSDHZ.tOnLLCDYLTime, pSet->dT_LL_CD,0);
	#endif
	

		InitTR_Time(&pR->tSDHZ.tOnBSTZTime, pSet->dT_fa_bsTz,0);   
		InitTR_Time(&pR->tSDHZ.tOnJSTime, pRunSet->dT_ldjs, 0);		 ////初始化单侧来电解锁计时器
	#if defined GD_AREA_ZHONGSHAN_2020 || defined GD_AREA_ECZD_2020 || defined GD_AREA_ZHONGSHAN
		#if defined GD_AREA_ECZD_2020
			#if defined FUNC_SET_FA_JS
			    InitTR_Time(&pR->tSDHZ.tOnHW_FA_JSTime, pRunSet->dT_FA_JS, 0);
			#else
			    InitTR_Time(&pR->tSDHZ.tOnHW_FA_JSTime, 5*T_10ms, 0);
			#endif
		#else
			InitTR_Time(&pR->tSDHZ.tOnHW_FA_JSTime, T_1s*6, 0);
		#endif
	#else
		InitTR_Time(&pR->tSDHZ.tOnHW_FA_JSTime, T_1s, 0);
	#endif
		InitTR_Time(&pR->tSDHZ.tOnOCingTime, pSet->dT_fa_ocing,pSet->dT_Y); 
		InitTR_Time(&pR->tSDHZ.tOnLXingTime, pSet->dT_fa_lxing,pSet->dT_Y); 
	#ifdef GD_AREA_ZHONGSHAN_2020
		InitTR_Time(&pR->tSDHZ.tOnY_JSTime, 0, 0);		
	#elif defined GD_AREA_ECZD_2020 || defined GD_AREA_ZHONGSHAN
		InitTR_Time(&pR->tSDHZ.tOnY_JSTime, T_1s*6, 0);	
	#else
		InitTR_Time(&pR->tSDHZ.tOnY_JSTime, T_1s*3, 0);		
		#endif
	#ifdef	FA_OC_COUNT
		InitTR_Time(&pR->tSDHZ.tFaOcCountTime, pSet->fa_oc_conut_time, 0);
	#endif

		#if 0
		if(pSet->toc[FA_GL].dT>T_10ms*3)
		{
			InitTR_Time(&pR->tSDHZ.tGZJYRstGLTime,pSet->toc[FA_GL].dT-T_10ms*3,pSet->dT_Y);
		}
		else
		{
			InitTR_Time(&pR->tSDHZ.tGZJYRstGLTime,0,pSet->dT_Y);
		}
		if(pSet->toc[FA_GL2].dT>T_10ms*3)
			InitTR_Time(&pR->tSDHZ.tGZJYRstGL2Time,pSet->toc[FA_GL2].dT-T_10ms*3,pSet->dT_Y);
		else
			InitTR_Time(&pR->tSDHZ.tGZJYRstGL2Time,0,pSet->dT_Y);


		if(pSet->toc[FA_LX].dT>T_10ms*3)
		{
			InitTR_Time(&pR->tSDHZ.tGZJYRstJDTime,pSet->toc[FA_LX].dT-T_10ms*3,pSet->dT_Y);
		}
		else
		{
			InitTR_Time(&pR->tSDHZ.tGZJYRstJDTime,0,pSet->dT_Y);
		}
		if(pSet->toc[FA_LX2].dT>T_10ms*3)
			InitTR_Time(&pR->tSDHZ.tGZJYRstJD2Time,pSet->toc[FA_LX2].dT-T_10ms*3,pSet->dT_Y);
		else
			InitTR_Time(&pR->tSDHZ.tGZJYRstJD2Time,0,pSet->dT_Y);
		#else
		if(pSet->toc[FA_GL].dT>T_FA_TZ_MIN_TIME)
			InitTR_Time(&pR->tSDHZ.tGZJYRstGLTime,pSet->toc[FA_GL].dT,pSet->dT_Y);
		else
			InitTR_Time(&pR->tSDHZ.tGZJYRstGLTime,T_FA_TZ_MIN_TIME,pSet->dT_Y);

		if(pSet->toc[FA_GL_II].dT>T_FA_TZ_MIN_TIME)
			InitTR_Time(&pR->tSDHZ.tGZJYRstGL_II_Time,pSet->toc[FA_GL_II].dT,pSet->dT_Y);
		else
			InitTR_Time(&pR->tSDHZ.tGZJYRstGL_II_Time,T_FA_TZ_MIN_TIME,pSet->dT_Y);

		if(pSet->toc[FA_GL2].dT>T_FA_TZ_MIN_TIME)
			InitTR_Time(&pR->tSDHZ.tGZJYRstGL2Time,pSet->toc[FA_GL2].dT,T_20ms);
		else
			InitTR_Time(&pR->tSDHZ.tGZJYRstGL2Time,T_FA_TZ_MIN_TIME,T_20ms);

		if(pSet->toc[FA_LX].dT>T_FA_TZ_MIN_TIME)
			InitTR_Time(&pR->tSDHZ.tGZJYRstJDTime,pSet->toc[FA_LX].dT,pSet->dT_Y);
		else
			InitTR_Time(&pR->tSDHZ.tGZJYRstJDTime,T_FA_TZ_MIN_TIME,pSet->dT_Y);
		
		if(pSet->toc[FA_LX2].dT>T_FA_TZ_MIN_TIME)
			InitTR_Time(&pR->tSDHZ.tGZJYRstJD2Time,pSet->toc[FA_LX2].dT,pSet->dT_Y);
		else
			InitTR_Time(&pR->tSDHZ.tGZJYRstJD2Time,T_FA_TZ_MIN_TIME,pSet->dT_Y);
		#endif

		InitTR_Time(&pR->tSDHZ.tUABS25ms,pSet->dT_fa_YY, T_25ms*2);
		InitTR_Time(&pR->tSDHZ.tUBCS25ms,pSet->dT_fa_YY, T_25ms*2);

		InitTR_Time(&pR->tSDHZ.tUABL25ms,pSet->dT_fa_YY, T_25ms*2);
		InitTR_Time(&pR->tSDHZ.tUBCL25ms,pSet->dT_fa_YY, T_25ms*2); 

		InitTR_Time(&pR->tSDHZ.tL_RELAYONL3s,	pSet->dT_Y,	0);		
		InitTR_Time(&pR->tSDHZ.tUFABL80ms,pRunSet->dT_XCY, pSet->dT_Y-T_1s);
		InitTR_Time(&pR->tSDHZ.tUFBCL80ms,pRunSet->dT_XCY, pSet->dT_Y-T_1s);
		InitTR_Time(&pR->tSDHZ.tUFDBTime,pRunSet->dT_XCY, 0);
		InitTR_Time(&pR->tSDHZ.tUFABS80ms,pRunSet->dT_XCY, pSet->dT_X);
		InitTR_Time(&pR->tSDHZ.tUFBCS80ms,pRunSet->dT_XCY, pSet->dT_X);
		InitTR_Time(&pR->tSDHZ.tUFABS25ms,T_25ms, pRunSet->dT_XCY+T_1s);
		InitTR_Time(&pR->tSDHZ.tUFBCS25ms,T_25ms, pRunSet->dT_XCY+T_1s);
		InitTR_Time(&pR->tSDHZ.tUFABL25ms,T_25ms, pRunSet->dT_XCY+T_1s);
		InitTR_Time(&pR->tSDHZ.tUFBCL25ms,T_25ms, pRunSet->dT_XCY+T_1s);

	#ifdef FA_PL_PJ
		InitTR(&pR->tSDHZ.tFREQAB25ms_SCY,T_25ms*2, T_25ms*2);
		InitTR(&pR->tSDHZ.tFREQBC25ms_SCY,T_25ms*2, T_25ms*2);
		InitTR(&pR->tSDHZ.tFREQAB25ms_LCY,T_25ms*2, T_25ms*2);
		InitTR(&pR->tSDHZ.tFREQBC25ms_LCY,T_25ms*2, T_25ms*2);
		InitTR(&pR->tSDHZ.tFREQSAB25ms,T_25ms, T_25ms*2);
		InitTR(&pR->tSDHZ.tFREQSBC25ms,T_25ms, T_25ms*2);
		InitTR(&pR->tSDHZ.tFREQLAB25ms,T_25ms, T_25ms*2);
		InitTR(&pR->tSDHZ.tFREQLBC25ms,T_25ms, T_25ms*2);
	#endif
	
		InitTR_Time(&pR->tSDHZ.tHz0ms1s,0,tRunPara.wFAHZT*T_5ms/5+T_1s);
		InitTR_Time(&pR->tSDHZ.tTz0ms1s,0,tRunPara.wFAFZT*T_5ms/5+T_1s);	
		InitTR_Time(&pR->tSDHZ.tHz0ms2s,pRunSet->dT_HZSB,0);
		InitTR_Time(&pR->tSDHZ.tTz0ms2s,pRunSet->dT_TZSB,0);	
		
		InitTR_Time(&pR->tSDHZ.tTSDHzHJS, 0, pSet->dT_Y); //上电合闸加速判断 
		
		InitTR_Time(&pR->tU0TZ.tZOVTime,  pSet->dT_OverU0, T_20ms); 
		InitTR_Time(&pR->tOVER_U0TZ.tZOVTime,  	pSet->dBHTOverU0, T_20ms); 

		//解列

		InitTR_Time(&pR->tDYJL.tDdyTime,  pSet->dT_jl_ddy, T_20ms);    	
		InitTR_Time(&pR->tDYJL.tGdyTime,  pSet->dT_jl_gdy, T_20ms);    	
		InitTR_Time(&pR->tDYJL.tHighTime,  pSet->dT_jl_ggdy, T_20ms);    	
		InitTR_Time(&pR->tDYJL.tLowTime,  pSet->dT_jl_gddy, T_20ms);    

		InitTR_Time(&pR->tPLJL.tDhzTime,  pSet->dT_jl_dhz, T_40ms);    	
		InitTR_Time(&pR->tPLJL.tHighTime,  pSet->dT_jl_ghz, T_40ms);    	
		InitTR_Time(&pR->tPLJL.tLowTime,  pSet->dT_jl_lowhz, T_40ms);    

		InitTR_Time(&pR->tLostVot.tLostVotTime,  pSet->dT_Z, T_20ms);    	
		InitTR_Time(&pR->tLostVot.tLostVLockTime,0,pSet->dT_fa_bsTz);
		InitTR_Time(&pR->tTQHz.tTQTime,pSet->dT_tq,0); //同期



		InitTR_Time(&pR->tSWST.tTWCNGJ1s,  pRunSet->dWCN_T,   WRN_RET_TIME);	
		InitTR_Time(&pR->tSWST.tTKZHLGJ1s,  T_1s*10,   WRN_RET_TIME);	
		InitTR_Time(&pR->tTripfail_2s, 	pRunSet->dT_TZSB,		0);  		//跳闸失败时间继电器
		InitTR_Time(&pR->tTripfail_hz, 0	,		pRunSet->dT_TZSB);  		//跳闸失败时间继电器
		
		InitTR_Time(&pR->tSWST.tCTXXYC, 	T_1s*3,	WRN_RET_TIME);  		// CT相序异常
		InitTR_Time(&pR->tSWST.tCTYC, 	T_1s*10,	WRN_RET_TIME);  		// CT断线 
		InitTR_Time(&pR->tTZZFG_5S0ms,  pRunSet->dT_ZZFG, 0);     	//无故障延时5s

		for(i=0;i<8;i++)
		{
			if(pRunSet->bTT_FDLTz[i])
			{
				InitTR_Time(&pR->tFdl[i].tFdlTime,pRunSet->dTFDL[i], PRO_RET_TIME);  
			}

			else
			{
				InitTR_Time(&pR->tFdl[i].tFdlTime,pRunSet->dTFDL[i], WRN_RET_TIME);  
			}
		}

	#ifdef FUNC_DRIVE_JY
		InitTR(&gb_drive.tDriveUa1Time,pSet->dT_drive_ua1, 0);
		InitTR(&gb_drive.tDriveUa2Time,pSet->dT_drive_ua2, 0);
		InitTR(&gb_drive.tDriveU0Time,pSet->dT_drive_u0, 0);
		InitTR(&gb_drive.tDriveITime,pSet->dT_drive_i, 0);
		InitTR(&gb_drive.tDriveI0Time,pSet->dT_drive_i0, 0);
		InitTR(&gb_drive.tDriveAgainTime,pSet->dT_drive_again, 0);
		InitTR(&gb_drive.tDriveFaBSTime,T_25ms*2, 0);
	#endif
	#ifdef FUNC_DRIVE
		InitTR(&gb_drive.tQDTime_hz,pRunSet->tSwSet[sw].dT_Drive_hz, 0);
		InitTR(&gb_drive.tQDTime_fz,pRunSet->tSwSet[sw].dT_Drive_fz, 0);
		InitTR(&gb_drive.tQDTime_fz_end,pRunSet->tSwSet[sw].dT_fz_end, 0);
		InitTR(&gb_drive.tQDTime_hz_end,pRunSet->tSwSet[sw].dT_hz_end, 0);
	#endif
	}

	for(i=0;i<VOL_NUMBER;i++)
	{
		InitTR_Time(&g_tVol[i].tQDTime,pRunSet->tVolSet[i].dTVol, WRN_RET_TIME);  
	}
	InitTR_Time(&g_tJLSDTime,pRunSet->dSDYX_T, T_1s*5);  
	InitTR_Time(&tFAg.tRstTime,pRunSet->dT_sendext*10, 0);  	

#ifdef FUN_JDXX
	jdxx_relayinit();	
#endif	
}
	

/**************************************************************************
函数名称：ValueOverRelay
函数版本：1.00 
作者：    mwd
创建日期：2007.9.29    
函数功能说明：过量继电器

输入参数：dI、dIdz 相比较
          CONST_FHXISHU: 返回系数，常数
          bEN: 1--返回系数有效，0－返回系数无效
其他输入:
输出参数?
返回值：?I>dIdz,返回true ,否则，返回false
***************************************************************************/
bool OverRelay(DWORD dI,DWORD dIdz,DWORD dfhdz ,bool bEN)
{
	if(bEN)
	{
    	if(dI>dfhdz)
    	{
    		return (true);
    	}
    	else
    	{
    		return (false);
    	}
	}
	else
	{
    	if(dI>dIdz)
    	{
    		return (true);
    	}
    	else
    	{
    		return (false);
    	}
	}
}

/**************************************************************************
函数名称：ValueLowRelay
函数版本：1.00 
作者：    
创建日期：2007.9.29    
函数功能说明：欠量继电器

输入参数：dI、dIdz 相比较
          CONST_FHXISHU: 返回系数，常数
          bEN: 1--返回系数有效，0－返回系数无效
其他输入:
输出参数?
返回值：?I>dIdz,返回true ,否则，返回false
***************************************************************************/
bool LowRelay(DWORD dI,DWORD dIdz,DWORD dfhdz ,bool bEN)
{
	if(bEN)
	{
    	if(dI<dfhdz)
    	{
    		return (true);
    	}
    	else
    	{
    		return (false);
    	}
	}
	else
	{
    	if(dI<dIdz)
    	{
    		return (true);
    	}
    	else
    	{
    		return (false);
    	}
	}
}

/**************************************************************************
函数名称：SelectFrom
函数版本：1.00 
作者：    MWD
创建日期：2007.9.29     
函数功能说明：二选一函数

输入参数：DWORD A: 待选数
          DWORD B: 待选数
          bool  bSelect

输出参数：
返回值：  bSelect=0 时，返回 A; bSelect=1 时，返回 B; 
**************************************************************************/
DWORD SelectMax(DWORD A, DWORD B, DWORD C)
{
    DWORD max;
    max=A;
    if(B>max)
    {
        max=B;
    }
    if(C>max)
    {
        max=C;
    }
    
    return (max);
}

/**************************************************************************
函数名称：CalcAngSub
函数版本：1.00 
作者：    MWD
创建日期：2007.9.29     
函数功能说明：计算向量角差，并转换至 0~360之间

输入参数：long Real1,
          long Imag1,
          long Imag2,
          long Imag2

输出参数：
返回值：  long 角差; 
**************************************************************************/
long CalcAngSub(long Real1, long Imag1, long Real2, long Imag2)
{
    long lTmp;

    lTmp = _AngPQ(Real1, Imag1)- _AngPQ(Real2,Imag2); 

    //规格化在0 ~ 360之间
    if(lTmp < 0)
    {
        lTmp += ANGLE_P360;
    }
    if(lTmp>ANGLE_P180)  //转换为-180 ~180
    {
	lTmp-=ANGLE_P360;
    }

    return (lTmp);
}
/**************************************************************************
函数名称：SynJudge
函数版本：1.00 
作者：    保护组 MWD
创建日期：2007.10.13     
函数功能说明：同期判别

输入参数：long ANG1:    UX与UA角差
          long ANG2:    UX与UA角差记忆值
          DWORD ANGSET: 同期角度定值
输出参数：
返回值：  TRUE－－－同期满足，
          FALSE－－同期不满足
**************************************************************************/
 bool SynJudge(long lANG1,long lANG2,DWORD dANGSET)//同期判别
{
    bool bStatus;
    long lTemp;
    
    lTemp = lAbs(lANG1 - lANG2);
    
    if(   ( (long)dANGSET > lTemp )
        ||( lTemp > (ANGLE_P360 - (long)dANGSET)) )
    {
        bStatus = 1;
    }
    else
    {
        bStatus = 0;
    }
    return( bStatus );
}
/**************************************************************************
函数名称：PowerDirectionalRelay 
函数版本：1.00 
作者：    Chenlei
创建日期：2007.11.4     
函数功能说明：输入电压、电流和阻抗角定值以及电压门槛定值，判断测量阻抗是否
              落在动作特性区内，并输出动作标志。                      
输入参数：Ur -- 电压实部     
          Ui -- 电压虚部     
          U  -- 电压幅值
　　　　　Ir -- 电流实部     
          Ii -- 电流虚部     
          I  -- 电流幅值
          Umk -- 电压门槛     
          Imk -- 电流门槛     
          Ang1 -- 灵敏角1  
          Ang2 -- 灵敏角2                   

输出参数：管脚10_动作标志    

返回值：  false-不动作；true-动作
**************************************************************************/
bool PowerDirectionalRelay(long Ur,long Ui,DWORD U, long Ir,long Ii,DWORD I, DWORD Umk,DWORD Imk,long sina1,long cosa1,long sina2,long cosa2)
{    
    bool  bDIRB;
    
    long  lTemp;         //中间变量
    long  lTemp1;        //中间变量
    long  lTemp2;        //中间变量
    
    bDIRB = false;    
    if (( U > Umk ) && ( I > Imk ))          //电压、电流均大于门槛，进行方向判断；否则，返回
    {
       
        lTemp1 = _MulFac_S(Ur,( Ir * cosa1 - Ii * sina1 ));
        lTemp2 = _MulFac_S(Ui, ( Ii * cosa1 + Ir * sina1 ));
        lTemp = lTemp1 + lTemp2;
        
        if ( lTemp > 0 )
        {
            lTemp1 = _MulFac_S(Ur, ( Ir * cosa2 - Ii * sina2 ));
            lTemp2 = _MulFac_S(Ui, ( Ii * cosa2 + Ir * sina2 ));
            lTemp = lTemp1 + lTemp2;
            
            if ( lTemp > 0 )
            {
                 bDIRB = true;
            }
        }
    }
    return( bDIRB );

}











/******************************end*****************************************/