T536_DTU/dtu/dtu_main_t536/app/reclose.c

/************************************************************************* 
* 版权所有：	
* 文件版本： V1.00
* 文件名称： reclose.c 
* 生成日期： 2007年10月15日
* 作     者： 保护部 MWD
* 功     能： 重合闸模块
             包含:  重合闸数据准备、
                    检同期数据准备、
                    抽取电压数据判别、
                    闭锁重合闸判别、
                    充电、
                    重合闸启动、
                    重合闸检定、
                    重合逻辑
**************************************************************************/
#define __RECLOSE_C
#include  "head.h"
    
/**********************************************************************
定义全局变量
***********************************************************************/
/*------------------------------ 函数声明 -------------------------------------
*/
static void AR_DataSet(int sw);
static void AR_Recharge(int sw,DWORD  dStep);
static void AR_Disable(int sw);
static void AR_Start(int sw,DWORD  dStep);
static void AR_Logic(int sw,DWORD  dStep);
static void AR_Reset(int sw,DWORD  dStep);
static void ARTQ_DataSet(int sw);


/**************************************************************************
函数名称: AutoReclose
函数版本：1.00 
作者：    硬件部
创建日期：2010.4.28    

函数功能说明：重合闸功能块

输入参数：
输出参数：
返回值： 
***************************************************************************/
void AutoReclose(int sw,DWORD  dStep)
{
	AR_DataSet(sw);               	// 重合闸数据准备
	ARTQ_DataSet(sw);
	AR_Recharge(sw,dStep);             // 重合闸充电
	AR_Disable(sw);                   // 重合闸闭锁
	AR_Start(sw,dStep);                // 重合闸启动
	AR_Logic(sw,dStep);                // 重合闸逻辑
	AR_Reset(sw,dStep);                // 重合闸复归
	return;
}
void ARTQ_DataSet(int sw)
{

	TCH_T *pSW=&g_tRelay[sw].tCHZ;
	TSETSW *pSet = &pRunSet->tSwSet[sw];
	bool bDa=false;
	bool bDu=false;
	long deltaA;
	qs16 ang2=0;
	TRELAY_T *pR=&g_tRelay[sw];
	static int print_flag=0;

	if(pRunSet->pt2vol==PUB_AC_UAB1)ang2=0;
	else if(pRunSet->pt2vol==PUB_AC_UBC1)ang2=-120*65536;
	else if(pRunSet->pt2vol==PUB_AC_UCA1)ang2=120*65536;
	else if(pRunSet->pt2vol==PUB_AC_UAB2)ang2=0;
	else if(pRunSet->pt2vol==PUB_AC_UBC2)ang2=-120*65536;
	else if(pRunSet->pt2vol==PUB_AC_UCA2)ang2=120*65536;


	pSW->sta.bFlag.bMxYY = OverRelay(g_ui[PUB_AC_UAB1].m2[0], pSet->dU_chz_yy,pSet->dU_chz_yy,false); 
	pSW->sta.bFlag.bMxWY = LowRelay(g_ui[PUB_AC_UAB1].m2[0], pSet->dU_chz_wy,pSet->dU_chz_wy,false); 
	pSW->sta.bFlag.bUxYY = OverRelay(g_ui[pRunSet->pt2vol].m2[0], pSet->dU_chz_yy,pSet->dU_chz_yy,false); 
	pSW->sta.bFlag.bUxWY = LowRelay(g_ui[pRunSet->pt2vol].m2[0], pSet->dU_chz_wy,pSet->dU_chz_wy,false); 

	deltaA=CalcAngSub(g_ui[PUB_AC_UAB1].ri.r,g_ui[PUB_AC_UAB1].ri.i,g_ui[pRunSet->pt2vol].ri.r,g_ui[pRunSet->pt2vol].ri.i);
	//deltaA = _AbsL(deltaA+ang2);//
	//deltaA = _AbsL((g_ui[PUB_AC_UAB1].p -ang1)- (g_ui[pRunSet->pt2vol].p-ang2));

	//bDa=((_AbsL(deltaA)  < pSet->dA_chz_deltaAng)?true:false)&&pSW->sta.bFlag.bMxYY&&pSW->sta.bFlag.bUxYY; //角差满足要求
	bDa=((_AbsL(deltaA+ang2)  < pSet->dA_chz_deltaAng)?true:false)&&pSW->sta.bFlag.bMxYY&&pSW->sta.bFlag.bUxYY; //角差满足要求

	
	bDu=(_AbsL(g_ui[PUB_AC_UAB1].fz -g_ui[pRunSet->pt2vol].fz)<pSet->dU_chz_deltaU)?true:false; //压差满足要求


	pSW->sta.bFlag.bTQMZ=
					#ifdef CHZ_JWY_LM
						(pSet->bTT_chz_tq || pSet->bTT_chz_mwy || pSet->bTT_chz_lwy) //同期合闸
					#else	
						(pSet->bTT_chz_tq||pSet->bTT_chz_wy)	//同期合闸
					#endif	
						&&pSW->sta.bFlag.bMxYY				//母线有压
						&&pSW->sta.bFlag.bUxYY 				//线路有压
						&&bDu								//压差满足
						&&bDa								//角差满足
						&&!tPT.uPT1DX.bFlag.bPTYC			//无PT 异常
						&&!tPT.uPT2DX.bFlag.bPTYC;			//无PT 异常

	pSW->sta.bFlag.bMWYMZ=
					#ifdef CHZ_JWY_LM
						(pSet->bTT_chz_mwy&&pSW->sta.bFlag.bMxWY&&pSW->sta.bFlag.bUxYY) //母线无压&&线路有压
					#else	
						(pSet->bTT_chz_wy)					//无压合闸
					#endif
						&&pSW->sta.bFlag.bMxWY				//母线有压
						&&!tPT.uPT1DX.bFlag.bPTYC;			//无PT 异常

	pSW->sta.bFlag.bUWYMZ=
					#ifdef CHZ_JWY_LM
						(pSet->bTT_chz_lwy&&pSW->sta.bFlag.bUxWY&&pSW->sta.bFlag.bMxYY)	//线路无压&&母线有压
					#else
						(pSet->bTT_chz_wy)					//无压合闸
					#endif	
						&&pSW->sta.bFlag.bUxWY				//线路无压
						&&!tPT.uPT2DX.bFlag.bPTYC;			//无PT 异常

		pSW->sta.bFlag.bCHMZ=pSW->sta.bFlag.bTQMZ				//同期满足
							||pSW->sta.bFlag.bMWYMZ 			//母线无压满足
							||pSW->sta.bFlag.bUWYMZ 				//线路无压满足
						#ifdef CHZ_JWY_LM
							||((!pSet->bTT_chz_tq)&&(!pSet->bTT_chz_mwy)&&(!pSet->bTT_chz_lwy))
						#else
							||((!pSet->bTT_chz_tq)&&(!pSet->bTT_chz_wy))
						#endif
							;
	if(pR->tCHZ.sta.bFlag.bCHQD)
	{
		if(!pSW->sta.bFlag.bTQMZ&&(print_flag++%(1*200))==0)//1S
		{
			if((!bDa)&&(pSet->bTT_chz_tq))
				rt_printf("角差不满足 pt1=%d pt2=%d ang2=%d      角差=%d 相位补偿后角差=%d        dz=%d pt2vol=%d\r\n",(g_ui[PUB_AC_UAB1].p)/65536,(g_ui[pRunSet->pt2vol].p)/65536,ang2/65536,deltaA/65536,_AbsL(deltaA+ang2)/65536,pSet->dA_chz_deltaAng/65536,pRunSet->pt2vol);
		#ifndef CHZ_JWY_LM
			if((!bDu)&&(pSet->bTT_chz_wy))
				rt_printf("压差不满足\r\n");
		#endif					
		}
	}
}


/**************************************************************************
函数名称：AR_DataSet
函数版本：1.00 
函数版本：1.00 
作者：    硬件部
创建日期：2010.4.28    

函数功能说明：重合闸数据准备

输入参数：无

输出参数：

返回值： 无
***************************************************************************/
static void AR_DataSet(int sw)
{
	u16 wNo;
	TRELAY_T *pR=&g_tRelay[sw];
	TCH_T *pSW =&pR->tCHZ;
	TSETSW *pSet = &pRunSet->tSwSet[sw];

	wNo=0;
	if(pSW->wAR_ActTimes < MAX_AR_TIMES) // 根据重合次数，设置时间继电器
	{
		wNo = pSW->wAR_ActTimes;
	}
	InitTR_Time(&pSW->tTCHJD_ARDelay,	pSet->dT_chz[wNo],		0   );         //重合闸延时
	InitTR_Time(&pSW->tTCHFAIL_TW,		pSet->dT_chz[wNo]+T_1s,	0   );         //重合闸延时
}

/**************************************************************************
函数名称: AR_Disable
函数版本：1.00 
作者：    保护产品部 
创建日期：2007.10.11    

函数功能说明：重合闸闭锁判别，刷新"闭锁重合闸"标

输入参数：
输出参数：
返回值： 
***************************************************************************/
static void AR_Disable(int sw)
{
	TRELAY_T *pR=&g_tRelay[sw];
	TCH_T *pSW =& pR->tCHZ;
	pSW->sta.bFlag.bBSCH =         pR->tOC[BH_GL1].sta.bFlag.bBSCH		// 过流闭锁重合闸
						   		|| pR->tOC[BH_GL2].sta.bFlag.bBSCH 		// 
					       		|| pR->tOC[BH_GL3].sta.bFlag.bBSCH 		// 
					       		|| pR->tOC[BH_LX1].sta.bFlag.bBSCH 		// 
					       		|| pR->tOC[BH_LX2].sta.bFlag.bBSCH 		// 
								|| pR->tOC[BH_LX3].sta.bFlag.bBSCH		// 
					       		||pR->tLostVot.uLostVot.bFlag.bTz	// 失压跳闸闭锁重合
			                    ||pR->tXXTZ.uZOV.bFlag.bTz
			                #ifdef PRO_AL_LOCK_HZ
								||(pR->tDYJL.sta.bFlag.bTz && pRunSet->bTT_JLlockCHZ)
								||(pR->tPLJL.sta.bFlag.bTz && pRunSet->bTT_JLlockCHZ)
			                #else
			                    ||pR->tDYJL.sta.bFlag.bTz
			                    ||pR->tPLJL.sta.bFlag.bTz
			                #endif
			                    ||pR->run_stu.bsch
							#ifndef PRO_UZ_START_REC//云浮要求零序电压能启动重合闸
								||pR->tOVER_U0TZ.uZOV.bFlag.bTz
			                #endif
			                    ||pR->tU0TZ.uZOV.bFlag.bTz //;			// 零压分闸闭锁重合
			                    ||pR->run_stu.chzbs;   //二次闭锁202004
}	


/**************************************************************************
函数名称: AR_Recharge
函数版本：1.00 
函数版本：1.00 
作者：    硬件部
创建日期：2010.4.28    

函数功能说明：重合闸充电，刷新"重合闸充电完成"标

输入参数：
输出参数：
返回值： 
***************************************************************************/
static void AR_Recharge(int sw,DWORD  dStep)
{                                                                      
	TRELAY_T *pR=&g_tRelay[sw];
	TCH_T *pSW =&pR->tCHZ;
	TSETSW *pSet = &pRunSet->tSwSet[sw];	
	bool bHCD1,bHCD2,bHCD3,bHCD4;	
#ifdef PRO_UZ_START_REC//云浮要求零序电压能启动重合闸	
	bool bHCD5=false;
	RunTR(&pSW->tTCH_UO_BS, pR->tOVER_U0TZ.uZOV.bFlag.bQD && pSet->bTT_3U0Tz && pR->tSWST.uSWST.bFlag.bTZWZ, dStep);//有零序电压且跳位
	bHCD5 = pSW->tTCH_UO_BS.boolTrip;
#endif

	// 放电条件
	RunTR(&pSW->tTCHFAIL_TW, pR->tSWST.uSWST.bFlag.bTZWZ, dStep);    	// 三相跳位延时
	bHCD1 = pSW->tTCHFAIL_TW.boolTrip;					// 放电标志1:三相跳位时间到

	bHCD2 =  (pR->tSWST.uSWST.bFlag.bTZWZ || pR->uBHDZ.bFlag.bBHT) //此处保护跳标志，是有100ms保持的信号   
							&& (!pSW->sta.bFlag.bCDWC);               // 放电标志2:充电未完成，跳位或保护动作
	
	bHCD3 = pR->uRmtSW.bHandTz							// 手动跳闸
						#ifdef SELF_OPEN_RELEASE
							|| pR->uRmtSW.bSwTz 		// 开关拉杆跳闸
						#endif
							|| pR->uRmtSW.bYTExecute                   	// 遥控跳闸
							|| pR->uBHDZ.bFlag.bTZSB					// 跳闸失败
							|| pR->tSWST.uSWST.bFlag.bTWYL				// 跳位有流
							|| (pR->tSWST.uSWST.bFlag.bWCN &&(!pSW->sta.bFlag.bCHQD))            // 弹簧未储能告警			正超广州样机重合闸启动后，收到弹簧未储能信号，重合闸不放电				
							|| pSW->sta.bFlag.bBSCH					// 重合闸闭锁条件
						#ifdef GD_AREA_ECZD_2020 
							||(pSet->bTT_chz_wy	&& (tPT.uPT1DX.bFlag.bPTYC || tPT.uPT2DX.bFlag.bPTYC))			//无PT 异常;		//检无压投入时，PT断线重合闸放电
						#endif
							|| pR->tSWST.uSWST.bFlag.bIBSCHZ		//大电流重合闸闭锁
							||pR->tSWST.uSWST.bFlag.bKZHL;	//控制回路断线检查
							//|| pSW->sta.bFlag.bCHFD;                  // 重合闸动作放电202004
	
	pSW->sta.bFlag.bFDBZ = (!BH_ALL_EN(sw))							// 总保护未投入
							|| (!KZ_OUT_ALL_EN(sw))					// 控制出口未投入
							|| (!pSet->bTT_CHZ)                         // 软压板: 重合闸未投入
							|| (!pRunSet->tSwSet[sw].btt_gnyb_zdchz)			// 重合闸软压板未投入
							|| (!pR->run_stu.chzyb)			// 重合闸硬压板未投入
							|| bHCD1 
							|| bHCD2
							|| bHCD3
						#ifdef PRO_UZ_START_REC
							|| bHCD5
						#endif
						#ifdef FUNC_DRIVE_JY
							|| gb_drive.b_bh_reclose
						#endif
							;
	//放电清开放时间
	if(pSW->sta.bFlag.bFDBZ)
	{
		pSW->sta.bFlag.bCHZOP=false;
		ResetTR(&pSW->tTCHOPENTime);
	}

	if(pR->tSWST.uSWST.bFlag.bIBSCHZ&&pSW->sta.bFlag.bCDWC)
	{
		if(soe_check(EV_HI_CHZ_LOCK+sw*EV_SW_NUM)==false)
		{
			soe_record_ev( EV_HI_CHZ_LOCK+sw*EV_SW_NUM, 1, 0,0,0);  // 重合闸闭锁
		}
	}
	else
	{
		if(!pR->tSWST.uSWST.bFlag.bIBSCHZ)
		{
			if(soe_check(EV_HI_CHZ_LOCK+sw*EV_SW_NUM)==true)
			{
				soe_record_ev( EV_HI_CHZ_LOCK+sw*EV_SW_NUM, 0, 0,0,0);  // 重合闸闭锁
			}
		}
	}
	
	// 充电条件
	bHCD4 = !pSW->sta.bFlag.bFDBZ                             // 重合放电标
			&& (((!pR->uBHQD.bFlag.bZQD) && pR->tSWST.uSWST.bFlag.bHZWZ )    // 非保护启动 && 合闸位置
			|| pSW->sta.bFlag.bCDWC);                          // 充电完成自保持

	RunTR(&pSW->tTCHCD15s0s, bHCD4, dStep);                // 充电15秒
	pSW->sta.bFlag.bCDWC = pSW->tTCHCD15s0s.boolTrip;


	if(pSW->sta.bFlag.bCDWC)
	{
		g_run_stu.cd|=(1<<sw);
		if(pSW->wAR_ActTimes>=pSet->d_chz_times)
		{
			g_run_stu.cd&=~(1<<sw);	
		}

		if(soe_check(EV_ARCD+sw*EV_SW_NUM)==false) // 充电标志
		{				
			soe_record_ev( EV_ARCD+sw*EV_SW_NUM,1, 0,0,0 ); 
		}
		//终止重合返回
		if(soe_check(EV_CHZ_TOPEN+sw*EV_SW_NUM)==true)
		{			
			soe_record_ev(EV_CHZ_TOPEN+sw*EV_SW_NUM, 0, 0,0,0);  // 终止重合闸过程				
		}
	}
	else
	{
	#ifdef FUNC_DRIVE_JY
		if(BH_ALL_EN(sw))
		{
			gb_drive.b_drive_success = false;	//充电未完成时,传动分后手合不允许报传动成功
		}	
	#endif
		g_run_stu.cd&=~(1<<sw);	
		if(soe_check(EV_ARCD+sw*EV_SW_NUM)==true) // // 充电标志
		{				
			soe_record_ev( EV_ARCD+sw*EV_SW_NUM,0, 0,0,0 ); 
		}
	}
}

/**************************************************************************
函数名称: AR_Start
函数版本：1.00 
函数版本：1.00 
作者：    硬件部
创建日期：2010.4.28    

函数功能说明：重合闸启动，刷新"三相偷跳启动重合闸"和"三跳启动重合闸"标

输入参数：
输出参数：
返回值：
***************************************************************************/
static void AR_Start(int sw,DWORD  dStep)
{
	bool bCHQD_CHQD;    // 三相启动重合闸
	TRELAY_T *pR=&g_tRelay[sw];
	TCH_T *pSW =&pR->tCHZ;
	TSETSW *pSet = &pRunSet->tSwSet[sw];
	bool bCQD1,bCQD2,bCQD3,bCQD4,bCQD5,bCQD6;

    // 不对应启动
    // 开关位置从合闸位置切换至分闸位置完成后，保留50ms展宽
	RunTR(&pSW->tTCHQDHW0ms50ms, pR->tSWST.uSWST.bFlag.bHZWZ, dStep); 
	bCQD1 = pSW->tTCHQDHW0ms50ms.boolTrip;                              

	// 偷跳条件准备  
	bCQD2 = pSet->bTT_TTCH_TT && bCQD1 && (!pR->tSWST.uSWST.bFlag.bHZWZ);

	// 保护启动	                           
	// 保护动作后至保护动作返回，保留50ms展宽
	RunTR(&pSW->tTCHQD0ms50ms, pR->uBHDZ.bFlag.bBHTrip, dStep); 
	bCQD3 = pSW->tTCHQD0ms50ms.boolTrip;                              

	// 重合已启动或保护启动，用于闭锁不对应启动                                                                    
	bCQD4 = pSW->sta.bFlag.bCHQD || bCQD3;
	                                                                   
	// 此处保护跳信号，是实时信号，即保护已返回
	bCQD5 = bCQD3 && (!pR->uBHDZ.bFlag.bBHTrip);      

	// 重合启动自保持
	// 重合闸出口条件，用于防止重合闸合闸过程中，TWJ没有返回时，再次误发启动重合闸报文。
	bCQD6 = pSW->sta.bFlag.bCDWC             // 重合充电完成
		                   && pSW->sta.bFlag.bCHQD            // 三相启动重合闸
		                   && (!pSW->sta.bFlag.bCHCK);        // 重合闸出口，取反
	                                                                   
	// 偷跳启动重合闸                                                   
	pSW->sta.bFlag.bTTQD =  pSW->sta.bFlag.bCDWC         	// 重合闸充电完成
		                   && bCQD2            // 偷跳判断完成                
		                   && (!bCQD4);        // 重合未启动，无保护跳过程

	// 三跳启动重合闸                                                  
	pSW->sta.bFlag.bTLQD =  pSW->sta.bFlag.bCDWC            // 重合闸充电完成
		                   &&bCQD5            // 有保护跳过程，而且保护已经返回，即故障已经解除
		                   && (!pSW->sta.bFlag.bCHQD);        // 三相启动重合闸未启动

	// 三相启动重合闸
	bCHQD_CHQD =  (((pSW->wAR_ActTimes<pSet->d_chz_times)&&	   // 重合次数未满 202004
	              (pSW->sta.bFlag.bTTQD                        // 偷跳启动重合闸
		           || pSW->sta.bFlag.bTLQD                        // 三跳启动重合闸
		           || bCQD6))                   		    // 三相启动重合闸
		       #ifdef FUNC_DRIVE_JY
		           || gb_drive.b_bh_reclose
		       #endif
		           );

	if( bCHQD_CHQD )
	{
		if( !pSW->sta.bFlag.bCHQD )                           //重合开出标尚未置位
		{
			pSW->sta.bFlag.bCHQD = true;						//此标志会一直维持到重合闸出口或充电标志放电
			pSW->sta.bFlag.bQDFG=true;						//整组复归时有效202004
			soe_record_ev(EV_AR_START+sw*EV_SW_NUM, 1, 0,0,0);//重合启动SOE         
			//rcd_start(sw,RECORD_TYPE_CHZ, RECORD_LEN_TZQD); 	//录波类型：跳闸类
		}        
	}
	else
	{
		if( pSW->sta.bFlag.bCHQD )
		{
			pSW->sta.bFlag.bCHQD = false;
			soe_record_ev(EV_AR_START+sw*EV_SW_NUM,0 ,0,0,0);   
		}
	}
	//重合开放计时		
	pSW->sta.bFlag.bCHZOP = bCHQD_CHQD||pSW->sta.bFlag.bCHZOP;
	RunTR(&pSW->tTCHOPENTime, pSW->sta.bFlag.bCHZOP, dStep);    //重合开放延时
	if(pSW->tTCHOPENTime.boolTrip)//重合闸开放时间到复归
	{
		pSW->sta.wfFlag=0;
		pR->tCHZ.wAR_ActTimes=0;			
		   rt_printf("重合闸开放时间到:整组复归!\r\n");		
		ResetTR(&pR->tCHZ.tTCHJD_ARDelay);//延时
		ResetTR(&pR->tCHZ.tTCHJD_HJS);//后加速延时
		ResetTR(&pSW->tTCHFAIL_TW);//重合失败
		ResetTR(&pSW->tTCHOKTime);//重合成功
		ResetTR(&pSW->tTCHBSDelay);//重合闭锁延时 	
		ResetTR(&pSW->tTCHJBSTime); //重合闭锁时间			
		ResetTR(&pSW->tTCHCD15s0s); //重合充电时间 
		#ifdef PRO_UZ_START_REC
			ResetTR(&pSW->tTCH_UO_BS); //U0闭锁确认
        #endif
		//soe
		if(soe_check(EV_CHZ_TOPEN+sw*EV_SW_NUM)==false)
		{			
			soe_record_ev(EV_CHZ_TOPEN+sw*EV_SW_NUM, 1, 0,0,0);  // 终止重合闸过程				
		}			
	}
}

/**************************************************************************
函数名称: AR_Logic
函数版本：1.00 
函数版本：1.00 
作者：    硬件部
创建日期：2010.4.28    

函数功能说明：重合闸逻辑判断

输入参数：
输出参数：
返回值： 
***************************************************************************/
static void AR_Logic(int sw,DWORD  dStep)
{
	bool bWCN;
	TRELAY_T *pR=&g_tRelay[sw];
	TCH_T *pSW =&pR->tCHZ;
	TSETSW *pSet = &pRunSet->tSwSet[sw];

	bool bHZL1,bHZL2,bHZL3,bHZL4,bHZL5,bHZL6,bHZL8;

#ifdef PRO_AL_LOCK_HZ
	bool bYYOK,bFreqOK;
	DWORD freq0,freq1;
	bool bVABL_OK,bVABH_OK,bVBCL_OK,bVBCH_OK;
#endif
	

	// 重合闸条件准备
	bHZL1 = (BH_ALL_EN(sw)				// 总投退
			&& pSet->bTT_CHZ         	// 软压板: 重合闸投
			&& pRunSet->tSwSet[sw].btt_gnyb_zdchz		// 软压板: 重合闸投
			&& pR->run_stu.chzyb			// 重合闸硬压板投入
			&& ((pSW->sta.bFlag.bCHQD   // 三相启动重合闸							
				&& pSW->sta.bFlag.bCDWC)		  // 重合闸充电完成
			#ifdef FUNC_DRIVE_JY
				|| gb_drive.b_bh_reclose
			#endif
			));

#ifdef PRO_AL_LOCK_HZ
	if(pRunSet->bTT_StartCHZ_judgeVolt)
	{
		bVABL_OK = OverRelay(g_sw_pub.m2_max[2], pSet->dU_jl_ddy, pSet->dU_reclose_ddy_fh, pSW->CHZ_Judge_V_F.bVABLOK) ;
		bVABH_OK = LowRelay(g_sw_pub.m2_max[2], pSet->dU_jl_gdy, pSet->dU_reclose_gdy_fh, pSW->CHZ_Judge_V_F.bVABHOK) ;
		pSW->CHZ_Judge_V_F.bVABLOK = bVABL_OK;
		pSW->CHZ_Judge_V_F.bVABHOK = bVABH_OK;
		
		bVBCL_OK = OverRelay(g_sw_pub.m2_max[3], pSet->dU_jl_ddy, pSet->dU_reclose_ddy_fh, pSW->CHZ_Judge_V_F.bVBCLOK) ;
		bVBCH_OK = LowRelay(g_sw_pub.m2_max[3], pSet->dU_jl_gdy, pSet->dU_reclose_gdy_fh, pSW->CHZ_Judge_V_F.bVBCHOK) ;
		pSW->CHZ_Judge_V_F.bVBCLOK = bVBCL_OK;
		pSW->CHZ_Judge_V_F.bVBCHOK = bVBCH_OK;
		
		if((bVABL_OK && bVABH_OK) && (bVBCL_OK && bVBCH_OK))	//需双侧电压均满足条件才允许重合闸
		{
			bYYOK = true;
		}
		else
		{
			bYYOK = false;
		}
	}
	else
	{
		bYYOK = true;
	}

	if(pRunSet->bTT_StartCHZ_judgeFreq)
	{
		freq0 = freq_get(0)*65536;
		freq1 = freq_get(1)*65536;
		
		if(((freq0 >= pRunSet->tSwSet[sw].dU_jl_dhz) && (freq0 <= pRunSet->tSwSet[sw].dU_jl_ghz))
			&& ((freq1 >= pRunSet->tSwSet[sw].dU_jl_dhz) && (freq1 <= pRunSet->tSwSet[sw].dU_jl_ghz)))	//需双侧频率均满足条件才允许重合闸
		{
			bFreqOK = true;
		}
		else
		{
			bFreqOK = false;
		}
	}
	else
	{
		bFreqOK = true;
	}

	RunTR(&pSW->tTCHJD_ARDelay, bHZL1 && bYYOK && bFreqOK, dStep);    //重合延时
#else
	RunTR(&pSW->tTCHJD_ARDelay, bHZL1, dStep);    //重合延时
#endif
	bHZL2 = pSW->tTCHJD_ARDelay.boolTrip&& pSW->sta.bFlag.bCHMZ;

	

	// 弹簧未储能下降沿展宽30ms
	bWCN = pR->run_stu.wcn && pSet->bTT_WCN;
	RunTR(&pSW->tTCHJD_0ms30ms, bWCN, dStep);
	bHZL3 = pSW->tTCHJD_0ms30ms.boolTrip;



	// 重合闸条件准备好，弹簧储能OK，重合闸出口
	pSW->sta.bFlag.bCHCK = (!bHZL3) && bHZL2;
	
	
	// 重合闸开出自保持
	bHZL4 = pSW->sta.bFlag.bHz || pSW->sta.bFlag.bCHCK;

	// 重合开出持续200ms
	RunTR(&pSW->tTCHJD_200ms0ms, bHZL4, dStep);    
	bHZL5 = pSW->tTCHJD_200ms0ms.boolTrip;                        

	// 重合闸开出,经过200ms后开出解除
	pSW->sta.bFlag.bHz =bHZL4 && (!bHZL5);                   

	// 重合闸指令发出后，且开关已经跳闸完成
	bHZL6 = pSW->sta.bFlag.bHz || pSW->sta.bFlag.bHZL7;
	pSW->sta.bFlag.bHZL7 = pR->tSWST.uSWST.bFlag.bTZWZ && bHZL6;

	// 开放后加速允许有效延时200ms展宽
	RunTR(&pSW->tTCHJD_HJS, pSW->sta.bFlag.bHZL7, dStep);                
	bHZL8 = pSW->tTCHJD_HJS.boolTrip;	
    pSW->sta.bFlag.bCHJS = pSW->tTCHJD_HJS.boolTrip
                   			&& (!pR->tSWST.uSWST.bFlag.bTZWZ);

	//出口及发信
	if(pSW->sta.bFlag.bHz)
	{
		if(!pSW->sta.bFlag.bEvent)    //重合开出标尚未置位
		{   				
			//亮重合动作灯
			pSW->sta.bFlag.bCHZLed = true;
			
			pSW->wAR_ActTimes++;    //重合动作次数
			pSW->sta.bFlag.bEvent = true;
			//pSW->uCHFG.wfFlag=0;			//每次重合出口后，清重合复归标志  修改时注意，此处需对标志字特殊处理

			pSW->sta.bFlag.bCHDZ=false;    	//重合闸动作   
			pSW->sta.bFlag.bBYSD=false;    	//重合闸闭锁时间到 
			pSW->sta.bFlag.bCHFD=false;    	//重合闸动作放电   
			pSW->sta.bFlag.bCHBS=false;    	//重合闸闭锁   
			pSW->sta.bFlag.bCK=false;		//放电条件1	

			if(pSW->wAR_ActTimes==1)
			{
				soe_record_ev(EV_AR1+sw*EV_SW_NUM, 1, 0,0,0);                   //重合动作SOE
			}
			else if(pSW->wAR_ActTimes==2)
			{
				soe_record_ev(EV_AR2+sw*EV_SW_NUM, 1, 0,0,0);                   //重合动作SOE
			}
			else if(pSW->wAR_ActTimes==3)
			{
				soe_record_ev(EV_AR3+sw*EV_SW_NUM, 1, 0,0,0);                   //重合动作SOE
			}
			
			rcd_start(sw,RECORD_TYPE_CHZ,RECORD_LEN_TZQD);  
			ResetTR(&pSW->tTCHFAIL_TW); // 重合出口后,重新复归时间继电器
			ResetTR(&pSW->tTCHOKTime);	//重合成功时间继电器，在重合出口后重新计数
			ResetTR(&pSW->tTCHBSDelay);		//闭锁重合延时继电器重新计数
			ResetTR(&pSW->tTCHJBSTime);		//闭锁重合延时继电器重新计数
			//RunTR(&pSW->tTCHJBSTime, 1, 1);  //重合闸动作后，该计时器计时，在确认时间内有保护动作，置重合闸闭锁标志

		#ifdef FUNC_DRIVE_JY
			gb_drive.b_bh_reclose = false;
		#endif
		}
	}
	else
	{
		if( pSW->sta.bFlag.bEvent )                                    //重合开出标尚未置位
		{   
			pSW->sta.bFlag.bEvent = false;
			
			if(soe_check(EV_AR1+sw*EV_SW_NUM))
			{
				soe_record_ev(EV_AR1+sw*EV_SW_NUM, 0, 0,0,0  );        //重合1动作SOE返回
			}
			if(soe_check(EV_AR2+sw*EV_SW_NUM))
			{
				soe_record_ev(EV_AR2+sw*EV_SW_NUM, 0, 0,0,0  );        //重合2动作SOE返回
			}
			if(soe_check(EV_AR3+sw*EV_SW_NUM))
			{
				soe_record_ev(EV_AR3+sw*EV_SW_NUM, 0, 0,0,0  );        //重合2动作SOE返回
			}
			}
	}
}

/**************************************************************************
函数名称: AR_Reset
函数版本：1.00 
函数版本：1.00 
作者：    硬件部
创建日期：2010.4.28    

函数功能说明：重合闸复归逻辑

输入参数：
输出参数：
返回值： 
***************************************************************************/
static void AR_Reset(int sw,DWORD  dStep)
{  
	TRELAY_T *pR=&g_tRelay[sw];
	TCH_T *pSW =&pR->tCHZ;
	TSETSW *pSet = &pRunSet->tSwSet[sw];
	bool bFD1,bCHBS1,bCHBS2;
	
	// 重合闸出口自锁202004
	pSW->sta.bFlag.bCHDZ = (pSW->sta.bFlag.bCHCK || pSW->sta.bFlag.bCHDZ);  
	// 二次重合闭锁(未到最后一次重合) 202004	                                                               
	RunTR(&pSW->tTCHBSDelay, (pSW->sta.bFlag.bCHDZ && pSW->wAR_ActTimes<pSet->d_chz_times), dStep);
	pSW->sta.bFlag.bBYSD = pSW->tTCHBSDelay.boolTrip;

	bCHBS1= (pSW->sta.bFlag.bCHDZ && pSW->wAR_ActTimes<pSet->d_chz_times)
		    &&(!pSW->sta.bFlag.bBYSD);       // 重合闸闭锁时间未到
	//重合闭锁(最后一次)
	//重合闸动作后，该计时器计时，在确认时间内有保护动作，置重合闸闭锁标志
	RunTR(&pSW->tTCHJBSTime, (pSW->sta.bFlag.bCHDZ && pSW->wAR_ActTimes>=pSet->d_chz_times), dStep); 
	
	bCHBS2= pSW->tTCHJBSTime.boolTrip;

	//重合闸闭锁
	pSW->sta.bFlag.bCHBS = pR->uBHDZ.bFlag.bBHT 
							&&(bCHBS1||bCHBS2);	
	
	 if(pSW->sta.bFlag.bCHBS )
	 {
		if(soe_check(EV_ARBS+sw*EV_SW_NUM)==false)
		{
			led_set_sw(sw,SW_LED_CHZBS, LED_ON);//重合闸闭锁灯与充电灯功能相反
			soe_record_ev( EV_ARBS+sw*EV_SW_NUM, 1, 0,0,0);  // 重合闸闭锁
			g_tRelay[sw].run_stu.chzbs=true;
		}
		ResetTR(&pSW->tTCHJBSHw);			
		ResetTR(&pSW->tTCHJBSTime);			
		ResetTR(&pSW->tTCHOKTime);		
		ResetTR(&pSW->tTCHBSDelay);
		pSW->sta.bFlag.bCHDZ=false;	
	 }

	//复归
	// 重合出口后，经过重合闸确认时间，无保护动作，即复归，完成该次重合过程202004
	// 如果在确认时间内，重合闭锁时间外，有保护动作，即进入下一计数重合
	pSW->sta.bFlag.bCK = ((!pR->uBHDZ.bFlag.bBHT)
						   && (pSW->sta.bFlag.bCHCK || pSW->sta.bFlag.bCK));	//重合出口及自保持		
	RunTR(&pSW->tTCHOKTime, pSW->sta.bFlag.bCK, dStep);
	bFD1 = pSW->tTCHOKTime.boolTrip;
	if(bFD1)
	{
		if(pR->tCHZ.wAR_ActTimes)
			rt_printf_time("重合闸复归\r\n");		
		pSW->sta.bFlag.bCHDZ=false;		
		pR->tCHZ.wAR_ActTimes=0;
	   	ResetTR(&pR->tCHZ.tTCHJD_HJS);
		ResetTR(&pSW->tTCHOKTime);
		ResetTR(&pSW->tTCHBSDelay);		
		ResetTR(&pSW->tTCHJBSTime);	//重合成功时间继电器，在重合出口后重新计数
		pSW->sta.bFlag.bCHZOP=false;
		ResetTR(&pSW->tTCHOPENTime);
	}	
	// 手动/自动复归条件:(1)重合闸闭锁(2)重合已启动，但充电标志已清零
	if(g_tRelay[sw].run_stu.chzbs	//闭锁				
	 	|| (!pSW->sta.bFlag.bCDWC && pSW->sta.bFlag.bQDFG))//已启动重合计时,又被放电
	{
	 	pSW->sta.bFlag.bQDFG = false;	
	}
}

/***************************************endfile**********************************************************/