/******************************************************************************
版权所有：	
文件名称：	Oc.c
文件版本：	01.01
创建作者：	xxxxxx
创建日期：	2012-03-28
功能说明：	过流保护
其它说明：
修改记录：
*/
/*------------------------------- 头文件 --------------------------------------
*/
#include "head.h"
 
/*------------------------------- 宏定义 --------------------------------------
*/

/*------------------------------ 类型结构 -------------------------------------
*/


/*------------------------------ 全局变量 -------------------------------------
*/

/*------------------------------ 函数声明 -------------------------------------
*/

/*------------------------------ 外部函数 -------------------------------------
外部函数供其它实体文件引用，必须仔细检查传入参数的合法性.
*/


bool CalDir_A(int sw,bool bQD,bool bInv)
{
	int indexU,indexI;	
	bool bzx=false;
	indexU=PUB_AC_UBC1;
	indexI=UI_SW_INDEX(sw,SW_AC_IA);	
	if(!tPT.uPT1DX.bFlag.bPTYC&&(g_ui[indexU].m2[0]>pRunSet->dVOL10V_SQR)&&bQD)      // UBC > 10V
	{
		if(!bInv)  //电流反向
		{
			bzx=PowerDirectionalRelay(g_ui[indexU].ri.r ,g_ui[indexU].ri.i,g_ui[indexU].m2[0],g_ui[indexI].ri.r ,g_ui[indexI].ri.i,g_ui[indexI].m2[0], pRunSet->dVOL10V_SQR, pRunSet->dIWL_SQR[sw], SIN0 , COS0, SIN300, COS300 );//计算A相电流方向
		}
		else
		{
			bzx=PowerDirectionalRelay(g_ui[indexU].ri.r ,g_ui[indexU].ri.i,g_ui[indexU].m2[0],g_ui[indexI].ri.r ,g_ui[indexI].ri.i,g_ui[indexI].m2[0], pRunSet->dVOL10V_SQR, pRunSet->dIWL_SQR[sw], SIN180 , COS180, SIN120, COS120 );//计算A相电流方向
		}
	}
	return bzx;
}


bool CalDir_B(int sw,bool bQD,bool bInv)
{
	int indexU,indexI;	
	bool bzx=false;
	indexU=PUB_AC_UCA1;
	indexI=UI_SW_INDEX(sw,SW_AC_IB);	
	if(!tPT.uPT1DX.bFlag.bPTYC&&(g_ui[indexU].m2[0]>pRunSet->dVOL10V_SQR)&&bQD)      // UCA > 10V
	{
		if(!bInv)
		{
			bzx=PowerDirectionalRelay(g_ui[indexU].ri.r ,g_ui[indexU].ri.i,g_ui[indexU].m2[0],g_ui[indexI].ri.r ,g_ui[indexI].ri.i,g_ui[indexI].m2[0], pRunSet->dVOL10V_SQR, pRunSet->dIWL_SQR[sw], SIN0 , COS0, SIN300, COS300 );//计算B相电流方向
		}
		else
		{
			bzx=PowerDirectionalRelay(g_ui[indexU].ri.r ,g_ui[indexU].ri.i,g_ui[indexU].m2[0],g_ui[indexI].ri.r ,g_ui[indexI].ri.i,g_ui[indexI].m2[0], pRunSet->dVOL10V_SQR, pRunSet->dIWL_SQR[sw], SIN180 , COS180, SIN120, COS120 );//计算B相电流方向
		}
	}
	return bzx;
}

bool CalDir_C(int sw,bool bQD,bool bInv)
{
	int indexU,indexI;	
	bool bzx=false;
	indexU=PUB_AC_UAB1;
	indexI=UI_SW_INDEX(sw,SW_AC_IC);	
	if(!tPT.uPT1DX.bFlag.bPTYC&&(g_ui[indexU].m2[0]>pRunSet->dVOL10V_SQR)&&bQD)      // UAB > 10V
	{
		if(!bInv)
		{
			bzx=PowerDirectionalRelay(g_ui[indexU].ri.r ,g_ui[indexU].ri.i,g_ui[indexU].m2[0],g_ui[indexI].ri.r ,g_ui[indexI].ri.i,g_ui[indexI].m2[0], pRunSet->dVOL10V_SQR, pRunSet->dIWL_SQR[sw], SIN0 , COS0, SIN300, COS300 );//计算C相电流方向
		}
		else
		{
			bzx=PowerDirectionalRelay(g_ui[indexU].ri.r ,g_ui[indexU].ri.i,g_ui[indexU].m2[0],g_ui[indexI].ri.r ,g_ui[indexI].ri.i,g_ui[indexI].m2[0], pRunSet->dVOL10V_SQR, pRunSet->dIWL_SQR[sw], SIN180 , COS180, SIN120, COS120 );//计算C相电流方向
		}
	}
	return bzx;
}

bool pro_check_bh_all(int sw)
{
	if(soe_check(EV_GL1TZ+sw*EV_SW_NUM)==true)return true;
	if(soe_check(EV_GL2TZ+sw*EV_SW_NUM)==true)return true;
	if(soe_check(EV_GL3TZ+sw*EV_SW_NUM)==true)return true;
	if(soe_check(EV_LX1TZ+sw*EV_SW_NUM)==true)return true;
	if(soe_check(EV_LX2TZ+sw*EV_SW_NUM)==true)return true;
#ifdef DISP_SET_LX3
	if(soe_check(EV_LX3TZ+sw*EV_SW_NUM)==true)return true;
#endif

	if(soe_check(EV_GLJS+sw*EV_SW_NUM)==true)return true;
	if(soe_check(EV_LXJS+sw*EV_SW_NUM)==true)return true;
	if(soe_check(EV_FA_GL_TZ+sw*EV_SW_NUM)==true)return true;
	if(soe_check(EV_FA_LX_TZ+sw*EV_SW_NUM)==true)return true;
#ifdef SOE_RECORD_DELAY
	if(g_soe_queue.fzsoe_wait_flag )return true;
#endif	
	return false;
}

bool pro_check_gl_all(int sw)
{
	if(soe_check(EV_GL1TZ+sw*EV_SW_NUM)==true)return true;
	if(soe_check(EV_GL2TZ+sw*EV_SW_NUM)==true)return true;
	if(soe_check(EV_GL3TZ+sw*EV_SW_NUM)==true)return true;
	if(soe_check(EV_GL1GJ+sw*EV_SW_NUM)==true)return true;
	if(soe_check(EV_GL2GJ+sw*EV_SW_NUM)==true)return true;
	if(soe_check(EV_GL3GJ+sw*EV_SW_NUM)==true)return true;
	if(soe_check(EV_GLJS+sw*EV_SW_NUM)==true)return true;
	if(soe_check(EV_FA_GL_TZ+sw*EV_SW_NUM)==true)return true;
#ifdef SOE_RECORD_DELAY
	if(g_soe_queue.fzsoe_wait_flag )return true;
#endif
	return false;
}

bool pro_check_lx_all(int sw)
{
	if(soe_check(EV_LX1GJ+sw*EV_SW_NUM)==true)return true;
	if(soe_check(EV_LX2GJ+sw*EV_SW_NUM)==true)return true;
#ifdef DISP_SET_LX3
	if(soe_check(EV_LX3GJ+sw*EV_SW_NUM)==true)return true;
#endif
	if(soe_check(EV_LX1TZ+sw*EV_SW_NUM)==true)return true;
	if(soe_check(EV_LX2TZ+sw*EV_SW_NUM)==true)return true;
#ifdef DISP_SET_LX3
	if(soe_check(EV_LX3TZ+sw*EV_SW_NUM)==true)return true;
#endif

	if(soe_check(EV_LXJS+sw*EV_SW_NUM)==true)return true;
	if(soe_check(EV_FA_LX_TZ+sw*EV_SW_NUM)==true)return true;
#ifdef SOE_RECORD_DELAY
	if(g_soe_queue.fzsoe_wait_flag )return true;
#endif	

#ifdef FUN_JDXX
		if(soe_check(EV_JDXX_GJ+sw*EV_SW_NUM)==true)return true;	
		if(soe_check(EV_JDXX_TZ+sw*EV_SW_NUM)==true)return true;		
#endif

	return false;
}

bool pro_check_fault_all(int sw)
{
	bool ret;
	ret=pro_check_gl_all(sw)||pro_check_lx_all(sw);
	return ret;
}

void  pro_check_gl_abc(int sw,DWORD i_set,DWORD I1,DWORD I2,DWORD I3)
{
	bool bIa,bIb,bIc;
	int ui_begin;
	TRELAY_T *pR=&g_tRelay[sw];
	ui_begin = UI_SW_INDEX_BEGIN(sw);

	bIa=(g_ui[ui_begin + SW_AC_IA ].m2[0] > i_set)?true:false;
	bIb=(g_ui[ui_begin + SW_AC_IB ].m2[0] > i_set)?true:false;
	bIc=(g_ui[ui_begin + SW_AC_IC ].m2[0] > i_set)?true:false;

	if(bIa&&bIb&&bIc)
	{
		if(soe_check(EV_IABC_GL+sw*EV_SW_NUM)==false)
		{				
			soe_record_ev( EV_IABC_GL+sw*EV_SW_NUM,1, I1,I2,I3 );
			pR->bYcRefresh.bAGl = true;
			pR->bYcRefresh.bBGl = true;
			pR->bYcRefresh.bCGl = true;
		}
	}
	else if(bIa&&bIb)
	{
		if(soe_check(EV_IAB_GL+sw*EV_SW_NUM)==false)
		{				
			soe_record_ev( EV_IAB_GL+sw*EV_SW_NUM,1, I1,I2,0 ); 
			pR->bYcRefresh.bAGl = true;
			pR->bYcRefresh.bBGl = true;
		}
	}
	else if(bIa&&bIc)
	{
		if(soe_check(EV_ICA_GL+sw*EV_SW_NUM)==false)
		{				
			soe_record_ev( EV_ICA_GL+sw*EV_SW_NUM,1, I1,I3,0 ); 
			pR->bYcRefresh.bAGl = true;
			pR->bYcRefresh.bCGl = true;
		}
	}
	else if(bIb&&bIc)
	{
		if(soe_check(EV_IBC_GL+sw*EV_SW_NUM)==false)
		{				
			soe_record_ev( EV_IBC_GL+sw*EV_SW_NUM,1, I2,I3,0 );
			pR->bYcRefresh.bBGl = true;
			pR->bYcRefresh.bCGl = true;
		}
	}
	else if(bIa)
	{
		if(soe_check(EV_IA_GL+sw*EV_SW_NUM)==false)
		{				
			soe_record_ev( EV_IA_GL+sw*EV_SW_NUM,1, I1,0,0 ); 
			pR->bYcRefresh.bAGl = true;
		}
	}
	else if(bIb)
	{
		if(soe_check(EV_IB_GL+sw*EV_SW_NUM)==false)
		{				
			soe_record_ev( EV_IB_GL+sw*EV_SW_NUM,1, I2,0,0 ); 
			pR->bYcRefresh.bBGl = true;
		}
	}
	else if(bIc)
	{
		if(soe_check(EV_IC_GL+sw*EV_SW_NUM)==false)
		{				
			soe_record_ev( EV_IC_GL+sw*EV_SW_NUM,1, I3,0,0 ); 
			pR->bYcRefresh.bCGl = true;
		}
	}
}

void  pro_check_fd_gl_abc(int sw,DWORD i_set,DWORD I1,DWORD I2,DWORD I3,int soe_no)
{
    bool bIa,bIb,bIc;
    int ui_begin;
    u32 code;

    ui_begin = UI_SW_INDEX_BEGIN(sw);

    bIa=(g_ui[ui_begin + SW_AC_IA ].m2[0] > i_set)?true:false;
    bIb=(g_ui[ui_begin + SW_AC_IB ].m2[0] > i_set)?true:false;
    bIc=(g_ui[ui_begin + SW_AC_IC ].m2[0] > i_set)?true:false;

    //soe_no--;
    if((soe_no==EV_GL1TZ)||(soe_no==EV_GL1GJ))
        code=EV_GL1_IA+sw*EV_SW_NUM;
    else if((soe_no==EV_GL2TZ)||(soe_no==EV_GL2GJ))
        code=EV_GL2_IA+sw*EV_SW_NUM;
    else if((soe_no==EV_GL3TZ)||(soe_no==EV_GL3GJ))
        code=EV_GL3_IA+sw*EV_SW_NUM;
    else
        return;

    if(bIa)
    {
        if(soe_check(code)==false)
        {
            soe_record_ev(code,1, I1,0,0 );
        }
    }
    if(bIb)
    {
        if(soe_check(code+1)==false)
        {
            soe_record_ev(code+1,1, I2,0,0 );
        }
    }
    if(bIc)
    {
        if(soe_check(code+2)==false)
        {
            soe_record_ev(code+2,1, I3,0,0 );
        }
    }


}

void pro_rst_fd_gl_event(int sw,int soe_no)
{
    u32 code;

    if(soe_no==EV_GL1TZ)
        code=EV_GL1_IA;
    else if(soe_no==EV_GL2TZ)
        code=EV_GL2_IA;
    else if(soe_no==EV_GL3TZ)
        code=EV_GL3_IA;
    else
        return;

    if(soe_check(code+sw*EV_SW_NUM)==true)
    {
        soe_record_ev( code+sw*EV_SW_NUM,0, 0,0,0 );
    }

    if(soe_check(code+sw*EV_SW_NUM+1)==true)
    {
        soe_record_ev( code+sw*EV_SW_NUM+1,0, 0,0,0 );
    }

    if(soe_check(code+sw*EV_SW_NUM+2)==true)
    {
        soe_record_ev( code+sw*EV_SW_NUM+2,0, 0,0,0 );
    }

}

void pro_rst_event(int sw,int soe_no)
{
	if(soe_check(soe_no+sw*EV_SW_NUM)==true)
	{				
		soe_record_ev( soe_no+sw*EV_SW_NUM,0, 0,0,0 ); 
	}
}

void xb_bs_soe(int sw,u32  dStep)
{
	int i;
	bool bxb_bs[BHOC_NUMBER]={false},xb_soe=false;

	for(i = BH_GL1;i<BHOC_NUMBER;i++) 
	{
		TOC_T *poc = &g_tRelay[sw].tOC[i];

		if((i== BH_GL1)|| (i == BH_GL2) || (i == BH_GL3) ||  (i== BH_GLJS))
			bxb_bs[i]= poc->sta.bFlag.bXBbs;
		else
			bxb_bs[i]=false;

		RunTR(&poc->tXBTime, bxb_bs[i], dStep);
		RunTR(&poc->tXBQD25ms, bxb_bs[i], dStep);

		if((poc->tXBTime.boolTrip)&&(poc->tXBQD25ms.boolTrip))
		{
			xb_soe =true;
			break;
		}	
	}
	
	if(xb_soe)
	{	
		if(soe_check(EV_XBBS+sw*EV_SW_NUM)==false) 
		{
			soe_record_ev(EV_XBBS+sw*EV_SW_NUM,1, 0,0,0 ); 
		}
	}
	else
	{
		if(soe_check(EV_XBBS+sw*EV_SW_NUM)==true) 
		{
			soe_record_ev( EV_XBBS+sw*EV_SW_NUM,0, 0,0,0 ); 
		}
	}

}


void Pro_OC(int sw,u32  dStep,int oc,int soe_no)
{
	bool bQDD,bTrip; 	
	TOC_T *poc = &g_tRelay[sw].tOC[oc];
	OC_SET *pSet = &pRunSet->tSwSet[sw].toc[oc];
	u16 soeno=soe_no+sw*EV_SW_NUM;	
	bool bfxmz,bxbbs,bxb;
	int ui_begin;
	bool bIazx,bIbzx,bIczx;	
	bool bdyenable=true; //低电压闭锁
	bool bTz=false;

	// 电流启动
	ui_begin = UI_SW_INDEX_BEGIN(sw);
	poc->sta.bFlag.bIaQD = OverRelay(g_ui[ui_begin+SW_AC_IA].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIaQD); 
	poc->sta.bFlag.bIbQD = OverRelay(g_ui[ui_begin+SW_AC_IB].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIbQD); 
	poc->sta.bFlag.bIcQD = OverRelay(g_ui[ui_begin+SW_AC_IC].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIcQD); 

	bIazx=CalDir_A(sw,poc->sta.bFlag.bIaQD&&pSet->bDir,pRunSet->tSwSet[sw].bTT_DIR_Inv);  //方向计算
	bIbzx=CalDir_B(sw,poc->sta.bFlag.bIbQD&&pSet->bDir,pRunSet->tSwSet[sw].bTT_DIR_Inv);
	bIczx=CalDir_C(sw,poc->sta.bFlag.bIcQD&&pSet->bDir,pRunSet->tSwSet[sw].bTT_DIR_Inv);

	bxb=pRunSet->tSwSet[sw].bTT_bh_xbbs;
	poc->sta.bFlag.bIaxb =bxb&&XBCalc(sw,SW_AC_IA,pRunSet->tSwSet[sw].d_bh_xbcoe,poc->sta.bFlag.bIaQD);
	poc->sta.bFlag.bIbxb=bxb&&XBCalc(sw,SW_AC_IB,pRunSet->tSwSet[sw].d_bh_xbcoe,poc->sta.bFlag.bIbQD);
	poc->sta.bFlag.bIcxb=bxb&&XBCalc(sw,SW_AC_IC,pRunSet->tSwSet[sw].d_bh_xbcoe,poc->sta.bFlag.bIcQD);

	bfxmz=(tPT.uPT1DX.bFlag.bPTYC) //PT异常，自动满足方向
			||(!pSet->bDir) //方向不投入
			||bIazx
			||bIbzx
			||bIczx;
	bQDD=poc->sta.bFlag.bIaQD||poc->sta.bFlag.bIbQD||poc->sta.bFlag.bIcQD;
	bxbbs=(poc->sta.bFlag.bIaxb||poc->sta.bFlag.bIbxb||poc->sta.bFlag.bIcxb); //谐波闭锁

#ifndef OCI_XB_0MS
	if(BH_ALL_EN(sw))
	{
		if((oc== BH_GL1)|| (oc == BH_GL2) || (oc == BH_GL3) ) 
		{
			poc->sta.bFlag.bXBbs = (BH_ALL_EN(sw)
						&& (pSet->bTz||pSet->bGj)
						&& bQDD) 
						&& bxbbs;
			if( oc== BH_GL1)
				xb_bs_soe(g_protect.sw,dStep);
		}
	}
#endif

	poc->sta.bFlag.bddyQD = LowRelay(g_sw_pub.m2_min[2], pRunSet->dU_DDYBS, pRunSet->dU_DDYBS, poc->sta.bFlag.bddyQD); 
	bdyenable=(!pRunSet->bTT_DDYBS) //低电压闭锁未投入，自动满足
			||(poc->sta.bFlag.bddyQD&&!tPT.uPT1DX.bFlag.bPTYC)		//低电压满足，TV正常
			||(tPT.uPT1DX.bFlag.bPTYC);  //PT异常，低电压自动满足


	poc->sta.bFlag.bQD  = (BH_ALL_EN(sw)
						&& (pSet->bTz || pSet->bGj)
						&& bQDD 
						&&bdyenable
						&&(!bxbbs)
						&& bfxmz); 

	if(poc->sta.bFlag.bQD)  //幅值启动
	{
		if(!poc->sta.bFlag.bQDWave)
		{
			rcd_start(sw,RECORD_TYPE_GLGZ, RECORD_LEN_TZQD); 	//录波类型：跳闸类
			poc->sta.bFlag.bQDWave=true;
		}

	}
	else
	{
		poc->sta.bFlag.bQDWave=false;
	}
#ifdef EV_GL_STATR
	gl_start_soe_set(poc->sta.bFlag.bQD,sw,soe_no+2);//过流启动SOE
#endif

	RunTR(&poc->tQDTime, poc->sta.bFlag.bQD, dStep);
	RunTR(&poc->tQD25ms, poc->sta.bFlag.bQD, dStep);

	// 如果速断时间到，启动时间未到，调用幅值启动加速模块
	if(poc->sta.bFlag.bQD && poc->tQDTime.boolTrip && !poc->tQD25ms.boolTrip)
	{
		if(protect_amp_qd_js(sw))
		{
			// 预置25ms，让下个循环再出口
			PreSetTime(&poc->tQD25ms, T_25ms);	
#ifdef CPU_FUXI
			//FUXI平台等待下一个循环会导致偶尔动作时间超40ms，改为不等待，本循环处理完
			poc->tQD25ms.boolTrip = 1;
#endif			
		}
	}

	bTrip = poc->tQDTime.boolTrip&& poc->tQD25ms.boolTrip;	
	poc->sta.bFlag.bGj=bTrip && pSet->bGj;  // 告警
	poc->sta.bFlag.bGjEvent=poc->sta.bFlag.bGj;


	// 过流三段闭锁重合闸
	poc->sta.bFlag.bBSCH = poc->sta.bFlag.bTz && !pRunSet->tSwSet[sw].dT_ch_gl_tt; 
	
	if(bTrip)	// 条件满足，置动作灯
	{	
		poc->sta.bFlag.bTripBak = true;
		//poc->sta.bFlag.bDzLed = true;		
	}	
	poc->sta.bFlag.bTz=bTrip&&pSet->bTz;	

#ifdef SOE_RECORD_DELAY	
	bTz = poc->sta.bFlag.bTz && soe_check(EV_TZFAIL+sw*EV_SW_NUM)==false;
#else
	bTz =poc->sta.bFlag.bTz;
#endif
		
#ifdef YX_RESET_TIME
	{
		bool bY1;
		//故障遥信延时复归
		bY1=(!poc->sta.bFlag.bGj)&&poc->sta.bFlag.bGjEvent;
		RunTR(&poc->tGjEvRstTime, bY1, dStep);	
		poc->sta.bFlag.bGjEvent=poc->sta.bFlag.bGj||(!poc->tGjEvRstTime.boolTrip&&bY1); 	
	
		bY1=(!poc->sta.bFlag.bTz)&&poc->sta.bFlag.bTzEvent;
		RunTR(&poc->tTzEvRstTime, bY1, dStep);	
		poc->sta.bFlag.bTzEvent=poc->sta.bFlag.bTz||(!poc->tTzEvRstTime.boolTrip&&bY1); 
	}
	bTz = poc->sta.bFlag.bTzEvent;
#endif

	if(bTz)
	{
		gl_soe_set_clr(1,sw,soeno,pSet->dI,false);
		if(soe_check(EV_BH_FAULT+sw*EV_SW_NUM)==false)  //保护总
		{				
			soe_record_ev( EV_BH_FAULT+sw*EV_SW_NUM,1, 0,0,0 ); 
		}
		poc->sta.bFlag.bDzLed = true;	
	}
	else
	{
		gl_soe_set_clr(0,sw,soeno,pSet->dI,false);
		if(pro_check_bh_all(sw)==false)
		{
			pro_rst_event(sw,EV_BH_FAULT);	 //保护总
		}
	} 

	//告警记录及出口
	if(poc->sta.bFlag.bGjEvent) 
	{
	
		gl_soe_set_clr(1,sw,soeno+1,pSet->dI,BH_WAVETIME_EN(pSet->dT));		// 大于150毫秒，出口也启动录波
		if(poc->sta.bFlag.bDzLed==false) 
		{
			poc->sta.bFlag.bGjLed = true;	
		}
	}
	else
	{
		gl_soe_set_clr(0,sw,soeno+1,pSet->dI,false);
	} 

	
}

void Pro_LX(int sw,u32  dStep,int oc,int soe_no)
{
	bool bQDD,bQDD1,bTrip; 	
	TOC_T *poc = &g_tRelay[sw].tOC[oc];
	OC_SET *pSet = &pRunSet->tSwSet[sw].toc[oc];
	u16 soeno=soe_no+sw*EV_SW_NUM;	
	int ui_begin;
	bool bTz=false;
	TRELAY_T *pR=&g_tRelay[sw];
	
	ui_begin = UI_SW_INDEX_BEGIN(sw);
	// 电流启动
	bQDD = OverRelay(g_ui[ui_begin+SW_AC_I0].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bQD); 

	bQDD1 = OverRelay(g_ui[PUB_AC_U01].m2[0], pRunSet->dU_U0BS, pRunSet->dU_U0BS, false);
	
	poc->sta.bFlag.bQD  = (BH_ALL_EN(sw))
					&& (pSet->bTz || pSet->bGj)
					&& bQDD 
					&& ((bQDD1&&pRunSet->bTT_U0BS)||(!pRunSet->bTT_U0BS));  
					

	if(poc->sta.bFlag.bQD)  //幅值启动
	{
		if(!poc->sta.bFlag.bQDWave)
		{
			rcd_start(sw,RECORD_TYPE_LXGL, RECORD_LEN_TZQD); 	//录波类型：跳闸类
			poc->sta.bFlag.bQDWave=true;
		}
	}	
	else
	{
		poc->sta.bFlag.bQDWave=false;
	}
#ifdef EV_GL_STATR
	lx_start_soe_set( poc->sta.bFlag.bQD,sw,soe_no+2);//过流启动SOE
#endif

	RunTR(&poc->tQDTime, poc->sta.bFlag.bQD, dStep);
	RunTR(&poc->tQD25ms, poc->sta.bFlag.bQD, dStep);

	// 如果时间到，启动时间未到，调用幅值启动加速模块
	if(poc->sta.bFlag.bQD && poc->tQDTime.boolTrip && !poc->tQD25ms.boolTrip)
	{
		if(protect_amp_lx_js(sw))
		{
			// 预置25ms，让下个循环再出口
			PreSetTime(&poc->tQD25ms, T_25ms);	
#ifdef CPU_FUXI
			//FUXI平台等待下一个循环会导致偶尔动作时间超40ms，改为不等待，本循环处理完
			poc->tQD25ms.boolTrip = 1;
#endif
		}
	}



	bTrip = poc->tQDTime.boolTrip&&poc->tQD25ms.boolTrip;	
	poc->sta.bFlag.bGj=bTrip&&pSet->bGj;  // 告警
	poc->sta.bFlag.bTz= bTrip&&pSet->bTz;	// 出口
	// 零序闭锁重合闸
	poc->sta.bFlag.bBSCH = poc->sta.bFlag.bTz && !pRunSet->tSwSet[sw].dT_ch_jd_tt; 

	if(bTrip)	// 条件满足，置动作灯
	{	
		poc->sta.bFlag.bTripBak = true;
		//poc->sta.bFlag.bDzLed = true;		
	}
	


#ifdef SOE_RECORD_DELAY	
	bTz = poc->sta.bFlag.bTz && soe_check(EV_TZFAIL+sw*EV_SW_NUM)==false;
#else
	bTz =poc->sta.bFlag.bTz;
#endif
	
#ifdef YX_RESET_TIME
	{
		bool bY1;
		//故障遥信延时复归
		bY1=(!poc->sta.bFlag.bGj)&&poc->sta.bFlag.bGjEvent;
		RunTR(&poc->tGjEvRstTime, bY1, dStep);	
		poc->sta.bFlag.bGjEvent=poc->sta.bFlag.bGj||(!poc->tGjEvRstTime.boolTrip&&bY1); 	
	
		bY1=(!poc->sta.bFlag.bTz)&&poc->sta.bFlag.bTzEvent;
		RunTR(&poc->tTzEvRstTime, bY1, dStep);	
		poc->sta.bFlag.bTzEvent=poc->sta.bFlag.bTz||(!poc->tTzEvRstTime.boolTrip&&bY1); 
	}
	bTz = poc->sta.bFlag.bTzEvent;
#endif

	if(bTz)
	{
		poc->sta.bFlag.bDzLed = true;	
		if(soe_check(soeno)==false)
		{
			DWORD I0,U0;
			I0 = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_I0].m2[0]), 256, g_ui[ui_begin + SW_AC_I0].m2_factor_k);
			U0 = _Mul_Div_U(sqrt_32fix(g_ui[PUB_AC_U01].m2[0]), 256, g_ui[PUB_AC_U01].m2_factor_k);				
			soe_record_ev( soeno, 1, I0,U0,0 ); 
//			rcd_start(sw,RECORD_TYPE_LXGL, RECORD_LEN_TZQD);
		}

		if(soe_check(EV_LX_FAULT+sw*EV_SW_NUM)==false) // 零序总
		{				
			soe_record_ev( EV_LX_FAULT+sw*EV_SW_NUM,1, 0,0,0 ); 
			pR->bYcRefresh.bLx = true;
		}
		if(soe_check(EV_BH_FAULT+sw*EV_SW_NUM)==false)  //保护总
		{				
			soe_record_ev( EV_BH_FAULT+sw*EV_SW_NUM,1, 0,0,0 ); 
		}
		if(soe_check(EV_ALL_FAULT+sw*EV_SW_NUM)==false)  //保护总
		{				
			soe_record_ev( EV_ALL_FAULT+sw*EV_SW_NUM,1, 0,0,0 ); 
		}
		
	}
	else
	{
		if(soe_check(soeno)==true)
		{
			soe_record_ev( soeno, 0, 0,0,0 );    
		}

		if(pro_check_lx_all(sw)==false)
		{
			pro_rst_event(sw,EV_LX_FAULT);	 //零序总
		}
		if(pro_check_bh_all(sw)==false)
		{
			pro_rst_event(sw,EV_BH_FAULT);	 //保护总
		}
		if(pro_check_fault_all(sw)==false)
		{
			pro_rst_event(sw,EV_ALL_FAULT);	 //事故总
		}
		
	} 

	// 告警记录及出口
	if(poc->sta.bFlag.bGj) 
	{		
		if(poc->sta.bFlag.bDzLed==false) 
		{
			poc->sta.bFlag.bGjLed = true;	
		}
		if(soe_check(soeno+1)==false)
		{
			DWORD I0,U0;
			I0 = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_I0].m2[0]), 256, g_ui[ui_begin + SW_AC_I0].m2_factor_k);
			U0 = _Mul_Div_U(sqrt_32fix(g_ui[PUB_AC_U01].m2[0]), 256, g_ui[PUB_AC_U01].m2_factor_k);				
			soe_record_ev( soeno+1, 1, I0,U0,0 ); 
			if(BH_WAVETIME_EN(pSet->dT))  rcd_start(sw,RECORD_TYPE_LXGL, RECORD_LEN_TZQD);
		}
		if(soe_check(EV_LX_FAULT+sw*EV_SW_NUM)==false) // 零序总
		{				
			soe_record_ev( EV_LX_FAULT+sw*EV_SW_NUM,1, 0,0,0 ); 
			pR->bYcRefresh.bLx = true;
		}
		if(soe_check(EV_ALL_FAULT+sw*EV_SW_NUM)==false)  //保护总
		{				
			soe_record_ev( EV_ALL_FAULT+sw*EV_SW_NUM,1, 0,0,0 ); 
		}
	}
	else
	{
		if(soe_check(soeno+1)==true)
		{
			soe_record_ev( soeno+1, 0, 0,0,0 );    
		}

		if(pro_check_lx_all(sw)==false)
		{
			pro_rst_event(sw,EV_LX_FAULT);	 //零序总
		}
		if(pro_check_fault_all(sw)==false)
		{
			pro_rst_event(sw,EV_ALL_FAULT);	 //事故总
		}
	} 
}
/**************************************************************************
函数名称：Pro_Accheck
函数版本：1.00 
作者：    保护产品部
创建日期：2007.10.15    

函数功能说明：加速功能块
输入参数：
其他输入:
输出参数：
返回值：  
***************************************************************************/
void Pro_Accheck(int sw,u32  dStep,int oc,int soe_no)
{
	bool bQDD,bTrip; 	
	bool bJS3,bJS4,bJS5;
	bool bY1,bY2; 
	TOC_T *poc = &g_tRelay[sw].tOC[oc];
	OC_SET *pSet = &pRunSet->tSwSet[sw].toc[oc];
	u16 soeno=soe_no+sw*EV_SW_NUM;	
	bool bxbbs,benable;
	int ui_begin;
	DWORD U0;
	TRELAY_T *pR=&g_tRelay[sw];

	ui_begin = UI_SW_INDEX_BEGIN(sw);

	
	U0 = _Mul_Div_U(sqrt_32fix(g_ui[PUB_AC_U01].m2[0]), 256, g_ui[PUB_AC_U01].m2_factor_k); 			

	if(oc==BH_GLJS||oc==BH_LXJS)
	{
		benable=BH_ALL_EN(sw);
	}
	else
	{
		benable=FA_ALL_EN(sw);
	}

	// 电流启动
	if(oc==BH_GLJS||oc==FA_GL)
	{
		bool bxb;
		DWORD  xbcoe;			// 谐波系数

		if(oc==BH_GLJS)
		{
			bxb=pRunSet->tSwSet[sw].bTT_bh_xbbs;
			xbcoe=pRunSet->tSwSet[sw].d_bh_xbcoe;
		}
		else 
		{
			bxb=pRunSet->tSwSet[sw].bTT_fa_xbbs;
			xbcoe=pRunSet->tSwSet[sw].d_fa_xbcoe;
		}
		poc->sta.bFlag.bIaQD = OverRelay(g_ui[ui_begin+SW_AC_IA].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIaQD); 
		poc->sta.bFlag.bIbQD = OverRelay(g_ui[ui_begin+SW_AC_IB].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIbQD); 
		poc->sta.bFlag.bIcQD = OverRelay(g_ui[ui_begin+SW_AC_IC].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIcQD); 

		poc->sta.bFlag.bIaxb =bxb&&XBCalc(sw,SW_AC_IA,xbcoe,poc->sta.bFlag.bIaQD);
		poc->sta.bFlag.bIbxb=bxb&&XBCalc(sw,SW_AC_IB,xbcoe,poc->sta.bFlag.bIbQD);
		poc->sta.bFlag.bIcxb=bxb&&XBCalc(sw,SW_AC_IC,xbcoe,poc->sta.bFlag.bIcQD);
		bQDD=poc->sta.bFlag.bIaQD||poc->sta.bFlag.bIbQD||poc->sta.bFlag.bIcQD;
		bxbbs=poc->sta.bFlag.bIaxb||poc->sta.bFlag.bIbxb||poc->sta.bFlag.bIcxb; //谐波闭锁
		
		if(BH_ALL_EN(sw))
		{
			if(oc == BH_GLJS) 
			{
				poc->sta.bFlag.bXBbs = (BH_ALL_EN(sw)
							&& (pSet->bTz||pSet->bGj)
							&& bQDD) 
							&& bxbbs;			
				//xb_bs_soe(g_protect.sw,dStep);
			}
		}
	}
	else  //零序加速或FA合后零序过流跳闸
	{
		// 零序电流过量继电器
		bY1 = OverRelay(g_ui[UI_SW_INDEX(sw,SW_AC_I0)].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bQD); 
		// 零序电压过量继电器
		//bY2 = OverRelay(g_ui[PUB_AC_U01].m2[0], pRunSet->dU_U0BS, pRunSet->dU_U0BS, false);
		bY2=true;
		bQDD=bY1&& ((bY2&&pRunSet->bTT_U0BS)||(!pRunSet->bTT_U0BS));
		bxbbs=false;

	}
    // 检查合闸加速标    
	if(oc==BH_GLJS||oc==BH_LXJS)
	{
		bJS3 = g_tRelay[sw].tCHZ.sta.bFlag.bCHJS  		// 重合加速标
			                 || g_tRelay[sw].tSWST.uSWST.bFlag.bSHJS; 	// 手合加速标
	}
	else
	{
		bJS3 =g_tRelay[sw].tSWST.uSWST.bFlag.bSDJS		//上电加速										
				//|| g_tRelay[sw].tSWST.uSWST.bFlag.bSHJS; 	// 手合加速标
				;
	}	
	
	poc->sta.bFlag.bQD  = (benable
						&& (pSet->bTz||pSet->bGj)
						&& bQDD) 
						&& (!bxbbs);//谐波闭锁
	// 加速标保持
	bJS4 = bJS3 || poc->sta.bFlag.bJSBC; 
			                 
	// 后加速启动条件满足
	bJS5 = poc->sta.bFlag.bQD&& bJS4;

	// 合闸加速标保持
	poc->sta.bFlag.bJSBC = bJS5 && bJS4;	


	if(bJS5)  //幅值启动
	{
		if(!poc->sta.bFlag.bQDWave)
		{
			if(oc==BH_GLJS||oc==FA_GL)
			{
				rcd_start(sw,RECORD_TYPE_GLGZ, RECORD_LEN_TZQD); 	//录波类型：跳闸类
			}
			else
			{
				rcd_start(sw,RECORD_TYPE_LXGL, RECORD_LEN_TZQD); 	//录波类型：跳闸类
			}
			poc->sta.bFlag.bQDWave=true;
		}
	}	
	else
	{
		poc->sta.bFlag.bQDWave=false;
	}
	RunTR(&poc->tQDTime, bJS5, dStep);
	RunTR(&poc->tQD25ms, bJS5, dStep);

	// 如果加速时间到，启动时间未到，调用幅值启动加速模块
	if((oc==BH_GLJS|| oc==FA_GL || BH_LXJS)&&(poc->sta.bFlag.bQD && poc->tQDTime.boolTrip && !poc->tQD25ms.boolTrip))
	{
		if(oc==BH_GLJS|| oc==FA_GL)
		{
			if(protect_amp_qd_js(sw))
			{
				// 预置25ms，让下个循环再出口
				PreSetTime(&poc->tQD25ms, T_25ms);	
			}
		}
		else
		{
			if(protect_amp_lx_js(sw))
			{
				// 预置25ms，让下个循环再出口
				PreSetTime(&poc->tQD25ms, T_25ms);	
			}
		}
		
	}


	
	bTrip = poc->tQDTime.boolTrip && poc->tQD25ms.boolTrip;	

	poc->sta.bFlag.bTz=bTrip;  // 

	if(bTrip)	// 条件满足，置动作灯
	{	
		poc->sta.bFlag.bTripBak = true;
		//poc->sta.bFlag.bDzLed = true;		
	}

#ifdef GD_TEST_2021
	// 故障遥信延时复归
	bY1=(!poc->sta.bFlag.bTz)&&poc->sta.bFlag.bTzEvent;
	RunTR(&poc->tTzEvRstTime, bY1, dStep);	
	poc->sta.bFlag.bTzEvent=poc->sta.bFlag.bTz||(!poc->tTzEvRstTime.boolTrip&&bY1); 
#endif 

	// 出口记录及出口
	if(oc==BH_GLJS||oc==FA_GL)
	{
	#ifdef GD_TEST_2021
		if(poc->sta.bFlag.bTzEvent)
	#else
		if(poc->sta.bFlag.bTz) 
	#endif	
		{
			poc->sta.bFlag.bDzLed = true;	
			gl_soe_set_clr(1,sw,soeno,pSet->dI,BH_WAVETIME_EN(pSet->dT));
			if(soe_check(EV_BH_FAULT+sw*EV_SW_NUM)==false)  //保护总
			{				
				soe_record_ev( EV_BH_FAULT+sw*EV_SW_NUM,1, 0,0,0 ); 
			}
			if(oc==FA_GL)
			{
				if(soe_check(EV_HHGZ+sw*EV_SW_NUM)==false&&pRunSet->tSwSet[sw].bTT_fa_gzbshz)
				{
					soe_record_ev(EV_HHGZ+sw*EV_SW_NUM, 1, 0,0,0 );
				}				
			}
		}
		else
		{
			gl_soe_set_clr(0,sw,soeno,pSet->dI,false);
			if(pro_check_bh_all(sw)==false)
			{
				pro_rst_event(sw,EV_BH_FAULT);	 //保护总
			}


			
		} 	
	}
	else  // 零序加速
	{
		// 出口记录及出口
	#ifdef GD_TEST_2021
		if(poc->sta.bFlag.bTzEvent) 
	#else	
		if(poc->sta.bFlag.bTz) 
	#endif	
		{
			poc->sta.bFlag.bDzLed = true;	
			if(soe_check(soeno)==false)
			{
				DWORD I0;
				I0 = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_I0].m2[0]), 256, g_ui[ui_begin + SW_AC_I0].m2_factor_k);
				//U0 = _Mul_Div_U(sqrt_32fix(g_ui[PUB_AC_U01].m2[0]), 256, g_ui[PUB_AC_U01].m2_factor_k);				
				soe_record_ev( soeno, 1, I0,U0,0 ); 
				if(BH_WAVETIME_EN(pSet->dT))rcd_start(sw,RECORD_TYPE_LXGL, RECORD_LEN_TZQD);
			}

			if(soe_check(EV_LX_FAULT+sw*EV_SW_NUM)==false) // 零序总
			{				
				soe_record_ev( EV_LX_FAULT+sw*EV_SW_NUM,1, 0,0,0 );
				pR->bYcRefresh.bLx = true;
			}
			if(soe_check(EV_BH_FAULT+sw*EV_SW_NUM)==false)  //保护总
			{				
				soe_record_ev( EV_BH_FAULT+sw*EV_SW_NUM,1, 0,0,0 ); 
			}
			if(soe_check(EV_ALL_FAULT+sw*EV_SW_NUM)==false)  //故障总
			{				
				soe_record_ev( EV_ALL_FAULT+sw*EV_SW_NUM,1, 0,0,0 ); 
			}			
			if(oc==FA_LX)
			{
				if(soe_check(EV_HHGZ+sw*EV_SW_NUM)==false&&pRunSet->tSwSet[sw].bTT_fa_gzbshz)
				{
					soe_record_ev(EV_HHGZ+sw*EV_SW_NUM, 1, 0,0,0 );
				}
			}
		}
		else
		{
			if(soe_check(soeno)==true)
			{
				soe_record_ev( soeno, 0, 0,0,0 );    
			}
			if(pro_check_lx_all(sw)==false)
			{
				pro_rst_event(sw,EV_LX_FAULT);	 //零序总
			}
			if(pro_check_bh_all(sw)==false)
			{
				pro_rst_event(sw,EV_BH_FAULT);	 //保护总
			}
			if(pro_check_fault_all(sw)==false)
			{
				pro_rst_event(sw,EV_ALL_FAULT);	 //故障总
			}
		} 	
	}	
}

/******************************************************************************
函数名称：	Pro_BSTZ
函数版本：	01.01
创建作者：	xxxxxx
创建日期：	2015-10-23
函数说明：	大电流闭锁分闸，用于负荷开关，以免过切断容量跳闸
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
void Pro_BSTZ(int sw,u32  dStep,int oc,int soe_no)
{	

	bool bQDD,bTrip; 	
	TOC_T *poc = &g_tRelay[sw].tOC[oc];
	OC_SET *pSet = &pRunSet->tSwSet[sw].toc[oc];
	u16 soeno=soe_no+sw*EV_SW_NUM;	
	// 电流启动
	bQDD = OverRelay(g_sw[sw].m2_max, pSet->dI, pSet->dI_fh, poc->sta.bFlag.bQD); 
	poc->sta.bFlag.bQD	= (BH_ALL_EN(sw)//现有程序FA模式下已处理遮断，所以只需要BH模式投入此功能
						&& (pSet->bTz||pSet->bGj)
						&& bQDD);
	if(poc->sta.bFlag.bQD)  //幅值启动
	{
		#if 0
		if(!poc->sta.bFlag.bQDWave)
		{
			rcd_start(sw,RECORD_TYPE_GLGZ, RECORD_LEN_TZQD); 	//录波类型：跳闸类
			poc->sta.bFlag.bQDWave=true;
		}
		#endif
	}

	RunTR(&poc->tQDTime, poc->sta.bFlag.bQD, dStep);
	bTrip = poc->tQDTime.boolTrip;	
	poc->sta.bFlag.bTz = bTrip&&pSet->bTz;
	g_tRelay[sw].bBSTZ = bTrip&&pSet->bTz;
	if(bTrip)	// 条件满足，置动作灯
	{	
		poc->sta.bFlag.bTripBak = true;
		poc->sta.bFlag.bDzLed = true;		
	}
	if(!BH_ALL_EN(sw))
	{
		return;
	}
	// 出口记录及出口
	if(poc->sta.bFlag.bTz) 
	{
		if(soe_check(soeno)==false)
		{
			int ui_begin;
			DWORD Ia,Ib,Ic;
			ui_begin = UI_SW_INDEX_BEGIN(sw);
			Ia = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IA].m2[0]), 256, g_ui[ui_begin + SW_AC_IA].m2_factor_k);
			Ib = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IB].m2[0]), 256, g_ui[ui_begin + SW_AC_IB].m2_factor_k);
			Ic = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IC].m2[0]), 256, g_ui[ui_begin + SW_AC_IC].m2_factor_k);
			soe_record_ev(soeno, 1, Ia,Ib,Ic );       
			//if(BH_WAVETIME_EN(pSet->dT))rcd_start(sw,RECORD_TYPE_GLGZ, RECORD_LEN_TZQD); 	//录波类型：跳闸类
		}	
	}
	else
	{
		if(soe_check(soeno)==true)
		{
			soe_record_ev(soeno, 0, 0,0,0);       
		}	
	} 

}

/***********************************
函数名称：	Pro_over_limit_i
函数版本：	01.01
创建作者：	xxxxxx
创建日期：	2015-10-23
函数说明：	电流越限
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
void  Pro_over_i(int sw,u32  dStep,int oc,int soe_no)
{
	bool bQDD,bTrip; 	
	int ui_begin;
	DWORD Ia,Ib,Ic;

#ifdef GD_TEST_2021
	bool by1;
#endif

	TOC_T *poc = &g_tRelay[sw].tOC[oc];
	OC_SET *pSet = &pRunSet->tSwSet[sw].toc[oc];
	u16 soeno=soe_no+sw*EV_SW_NUM;	
	// 电流启动
	bQDD = OverRelay(g_sw[sw].m2_max, pSet->dI, pSet->dI_fh, poc->sta.bFlag.bQD); 
	poc->sta.bFlag.bQD  = (pSet->bTz || pSet->bGj) && bQDD; 
	RunTR(&poc->tQDTime, poc->sta.bFlag.bQD, dStep);
	bTrip=poc->tQDTime.boolTrip;  // 告警	
	poc->sta.bFlag.bGj = bTrip;  // 告警

#ifdef GD_TEST_2021
	// 故障遥信延时复归
	by1 = (!poc->sta.bFlag.bGj) && poc->sta.bFlag.bGjEvent;
	RunTR(&poc->tGjEvRstTime, by1, dStep);
	poc->sta.bFlag.bGjEvent = poc->sta.bFlag.bGj || (!poc->tGjEvRstTime.boolTrip && by1);
#endif 

	//告警记录及出口
	if(bTrip)	// 条件满足，置动作灯
	{	
		poc->sta.bFlag.bDzLed = true;		
	}
	
	if(poc->sta.bFlag.bGj) 
	{
		// gz_soe_set_clr(1,sw,soeno,pSet->dI);
		if(soe_check(soeno))
			return;
		ui_begin = UI_SW_INDEX_BEGIN(sw);
		Ia = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IA].m2[0]), 256, g_ui[ui_begin + SW_AC_IA].m2_factor_k);
		Ib = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IB].m2[0]), 256, g_ui[ui_begin + SW_AC_IB].m2_factor_k);
		Ic = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IC].m2[0]), 256, g_ui[ui_begin + SW_AC_IC].m2_factor_k);
		soe_record_ev(soeno, 1, Ia,Ib,Ic );       
	}
	else
	{
		// gz_soe_set_clr(0,sw,soeno,pSet->dI);
		if(!soe_check(soeno))
			return;

		soe_record_ev(soeno, 0, 0,0,0 ); 
	} 
}

void  Pro_over_i0(int sw,u32  dStep,int oc,int soe_no)
{
	bool bQDD,bTrip; 	

#ifdef GD_TEST_2021
	bool by1;
#endif

	TOC_T *poc = &g_tRelay[sw].tOC[oc];
	OC_SET *pSet = &pRunSet->tSwSet[sw].toc[oc];
	u16 soeno=soe_no+sw*EV_SW_NUM;	
	// 电流启动
	bQDD = OverRelay(g_ui[UI_SW_INDEX(sw,SW_AC_I0)].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bQD); 
	poc->sta.bFlag.bQD  = (pSet->bTz || pSet->bGj) && bQDD; 
	RunTR(&poc->tQDTime, poc->sta.bFlag.bQD, dStep);
	bTrip=poc->tQDTime.boolTrip;  // 告警	
	poc->sta.bFlag.bGj=bTrip;  // 告警

#ifdef GD_TEST_2021
	// 故障遥信延时复归
	by1 = (!poc->sta.bFlag.bGj) && poc->sta.bFlag.bGjEvent;
	RunTR(&poc->tGjEvRstTime, by1, dStep);
	poc->sta.bFlag.bGjEvent = poc->sta.bFlag.bGj || (!poc->tGjEvRstTime.boolTrip && by1);
#endif 

	if(bTrip)	// 条件满足，置动作灯
	{	
		poc->sta.bFlag.bDzLed = true;		
	}

	if(poc->sta.bFlag.bGj) 
	{
		if(soe_check(soeno)==false)
		{
			int ui_begin;
			DWORD I0;
			ui_begin = UI_SW_INDEX_BEGIN(sw);
			I0 = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_I0].m2[0]), 256, g_ui[ui_begin + SW_AC_I0].m2_factor_k);
			soe_record_ev( soeno, 1, I0,0,0 ); 
		}
	}
	else
	{
		if(soe_check(soeno)==true)
		{
			soe_record_ev( soeno, 0, 0,0,0 ); 
		}
	} 
}
#ifdef EV_GL_STATR
void gl_start_soe_set(u8 set_clr, int sw,u16 soe_no)
{
	int ui_begin;
	DWORD Ia,Ib,Ic;
	ui_begin = UI_SW_INDEX_BEGIN(sw);
	Ia = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IA].m2[0]), 256, g_ui[ui_begin + SW_AC_IA].m2_factor_k);
	Ib = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IB].m2[0]), 256, g_ui[ui_begin + SW_AC_IB].m2_factor_k);
	Ic = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IC].m2[0]), 256, g_ui[ui_begin + SW_AC_IC].m2_factor_k);
	ui_begin = UI_SW_INDEX_BEGIN(sw);
	if(soe_check(soe_no)!=set_clr)
	{
		soe_record_ev(soe_no, set_clr, Ia,Ib,Ic );       
	}
}
void lx_start_soe_set(u8 set_clr, int sw,u16 soe_no)
{
	int ui_begin;
	DWORD I0,U0;
	ui_begin = UI_SW_INDEX_BEGIN(sw);
	I0 = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_I0].m2[0]), 256, g_ui[ui_begin + SW_AC_I0].m2_factor_k);
	U0 = _Mul_Div_U(sqrt_32fix(g_ui[PUB_AC_U01].m2[0]), 256, g_ui[PUB_AC_U01].m2_factor_k);		
	if(soe_check(soe_no)!=set_clr)
	{
		soe_record_ev(soe_no, set_clr, U0,I0,0 );       
	}
}
#endif
/******************************************************************************
函数名称：	gl_soe_set_clr
函数版本：	01.01
创建作者：	xxxxxx
创建日期：	2014-12-16
函数说明：	过流事件的建立和返回
参数说明：	set_clr: 1 建立，0 返回
			soe_no: 事件组的起始序号
			i_set: 当前过流保护的定值
返回值：  	无
修改记录：	
*/
int gl_soe_set_clr(u8 set_clr, int sw, u16 soe_no, u32 i_set,bool bfault)
{
    int ui_begin;
    ui_begin = UI_SW_INDEX_BEGIN(sw);
    switch(set_clr)
    {
        case 1:
        {
            DWORD Ia,Ib,Ic;
            Ia = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IA].m2[0]), 256, g_ui[ui_begin + SW_AC_IA].m2_factor_k);
            Ib = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IB].m2[0]), 256, g_ui[ui_begin + SW_AC_IB].m2_factor_k);
            Ic = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IC].m2[0]), 256, g_ui[ui_begin + SW_AC_IC].m2_factor_k);
            if(soe_check(soe_no)==false)
            {
                soe_record_ev(soe_no, 1, Ia,Ib,Ic );
                if(bfault)rcd_start(sw,RECORD_TYPE_GLGZ, RECORD_LEN_TZQD);  //录波类型：跳闸类
            }
            pro_check_gl_abc(sw,i_set,Ia,Ib,Ic); // 分相故障判断
            pro_check_fd_gl_abc(sw,i_set,Ia,Ib,Ic,soe_no); // 分段分相故障判断
            if(soe_check(EV_GL_FAULT+sw*EV_SW_NUM)==false) // 过流总
            {
                soe_record_ev( EV_GL_FAULT+sw*EV_SW_NUM,1, 0,0,0 );
            }
            if(soe_check(EV_ALL_FAULT+sw*EV_SW_NUM)==false)  //保护总
            {
                soe_record_ev( EV_ALL_FAULT+sw*EV_SW_NUM,1, 0,0,0 );
            }
        }
        break;
        case 0:
        {
            if(soe_check(soe_no)==true)
            {
                soe_record_ev( soe_no, 0, 0,0,0 );
            }
            if(pro_check_gl_all(sw)==false)
            {
                pro_rst_event(sw,EV_IABC_GL);
                pro_rst_event(sw,EV_IAB_GL);
                pro_rst_event(sw,EV_IBC_GL);
                pro_rst_event(sw,EV_ICA_GL);
                pro_rst_event(sw,EV_IA_GL);
                pro_rst_event(sw,EV_IB_GL);
                pro_rst_event(sw,EV_IC_GL);
                pro_rst_event(sw,EV_GL_FAULT);   //过流总
                pro_rst_fd_gl_event(sw,soe_no);  //分段分相故障返回
            }
            if(pro_check_fault_all(sw)==false)
            {
                pro_rst_event(sw,EV_ALL_FAULT);  //保护总
            }
        }
        break;
    }

	return 0;
}


/******************************************************************************
函数名称：	gz_soe_set_clr
函数版本：	01.01
创建作者：	xxxxxx
创建日期：	2014-12-16
函数说明：	过流事件的建立和返回
参数说明：	set_clr: 1 建立，0 返回
			soe_no: 事件组的起始序号
			i_set: 当前过流保护的定值
返回值：  	无
修改记录：	
*/
int gz_soe_set_clr(u8 set_clr, int sw, u16 soe_no, u32 i_set)
{
	int ui_begin, i;
	DWORD Idz;
	ui_begin = UI_SW_INDEX_BEGIN(sw);
	switch(set_clr)
	{
		case 1:
		{
			if(soe_check(soe_no)==false)
			{
				DWORD Ia,Ib,Ic;
				Ia = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IA].m2[0]), 256, g_ui[ui_begin + SW_AC_IA].m2_factor_k);
				Ib = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IB].m2[0]), 256, g_ui[ui_begin + SW_AC_IB].m2_factor_k);
				Ic = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IC].m2[0]), 256, g_ui[ui_begin + SW_AC_IC].m2_factor_k);
				soe_record_ev(soe_no, 1, Ia,Ib,Ic );       
			}
		
			for(i=0; i<3; i++)
			{
				if(soe_check(soe_no+i+1)==false)
				{
					if (g_ui[ui_begin + SW_AC_IA + i].m2[0] > i_set)
					{
						Idz = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IA + i].m2[0]), 256, g_ui[ui_begin + SW_AC_IA + i].m2_factor_k);
						soe_record_ev( soe_no+i+1, 1, Idz, 0, 0);  
					}
				}
			}
		}
		break;
		case 0:
		{
			if(soe_check(soe_no)==true)
			{
				soe_record_ev( soe_no, 0, 0,0,0 ); 
			}
		
			for (i=0; i<3; i++)
			{
				if(soe_check(soe_no+i+1)==true)
				{
					soe_record_ev( soe_no+i+1, 0, 0,0,0 ); 
				}
			}

		}
		break;
	}

	return 0;
}

bool XBCalc(int sw,int index,DWORD xBcoe,bool bQD)
{
	if(bQD)
	{
		if( g_ui[UI_SW_INDEX(sw,index)].m2[1] > _MulFac_U(g_ui[UI_SW_INDEX(sw,index)].m2[0], xBcoe ))                         
		{
			return(true);
		}
	}
	return(false);
}

/*------------------------------ 测试函数 -------------------------------------
一个实体文件必须带一个本模块的测试函数来进行单元测试，如果的确不方便在本模块中
进行单元测试，必须在此注明实际的测试位置（例如在哪个实体文件中使用哪个测试函数）.
*/


/*------------------------------ 文件结束 -------------------------------------
*/