/************************************************************************* 
* 版权所有： 
* 文件版本： V1.00
* 文件名称： Oc.c 
* 生成日期： 2008年11月10日
* 作	 者： 保护部
* 功	 能：  备自投逻辑
                                  
**************************************************************************/
#include "head.h"

//#define BZT_PRINTF_DEBUG

#ifdef	CUSTOMIZE_BZT //备自投

void Bzt_ModeSwitch(int sw)
{
	bool bY1, bY2, bY3;	
	TRELAY_T *pR=&g_tRelay[sw];
	TSETSW *pSet = &pRunSet->tSwSet[sw];	
	UBZT *uBZT   = &pR->tBzt.uBZT; 

	if(pSet->bAUTO)
	{
		bY1 = pR->tSWST.uSWST.bFlag.b1DLHW;
		bY2 = pR->tSWST.uSWST.bFlag.b2DLHW;
		bY3 = pR->tSWST.uSWST.bFlag.b3DLHW;
		if(bY1 && bY2 && !bY3)
		{
			uBZT->bBZT.bFD = 1;
			uBZT->bBZT.bJX = 0;
		}
		if(((!bY1 && bY2)||(bY1 && !bY2)) && bY3)
		{
			uBZT->bBZT.bFD = 0;
			uBZT->bBZT.bJX = 1;
		}
		uBZT->bBZT.bDJX = 0;
	}
	else if(pSet->bDJX)
	{
		uBZT->bBZT.bDJX = 1;
	}
	else
	{
		uBZT->bBZT.bFD  = pSet->bFD;
		uBZT->bBZT.bJX  = pSet->bJX;
		uBZT->bBZT.bDJX = 0;
		uBZT->bBZT.bZF = pSet->bZF;
	}	
}

void OC_FaultEventClear(int sw)
{
	pro_rst_event(sw,EV_LX_FAULT);	 //零序总
	pro_rst_event(sw,EV_BH_FAULT);	 //保护总
	pro_rst_event(sw,EV_ALL_FAULT);	 //故障总
	pro_rst_event(sw, EV_GL1TZ);
	pro_rst_event(sw, EV_GL2TZ);
	pro_rst_event(sw, EV_GL3TZ);
	pro_rst_event(sw, EV_LX1TZ);
	pro_rst_event(sw, EV_LX2TZ);
#ifdef DISP_SET_LX3
	pro_rst_event(sw, EV_LX3TZ);
#endif
	
//	pro_rst_event(sw, EV_FA_GLTZ);
//	pro_rst_event(sw, EV_FA_LXTZ);
	pro_rst_event(sw, EV_GLJS);
	pro_rst_event(sw, EV_LXJS);
//	pro_rst_event(sw, EV_BS_FZ_LX);
	pro_rst_event(sw, EV_HHGZ);
//	pro_rst_event(sw, EV_BS_FZ_LX);
}


void Bzt_Dataset(int sw, DWORD  dStep)
{
	bool bY1, bY2, bY3, bY4, bY5, bY6, bY7, bY8, bY9, bY10;	
	TRELAY_T *pR=&g_tRelay[sw];
	TSETSW *pSet = &pRunSet->tSwSet[sw];	
	DWORD I_ct_1, I_ct_2;
	int ui_begin;

	//母线1有压检测
	bY1 = OverRelay(g_ui[pSet->bzt_mx_pt1].m2[0], pSet->dMX1UPower, pSet->dMX1UPower_fh, pR->tBzt.uBZTUI.bBZT.b1MYY);
	RunTR(&pR->tBzt.tDL3_PT1_YY_25ms, bY1, dStep);	
	pR->tBzt.uBZTUI.bBZT.b1MYY = pR->tBzt.tDL3_PT1_YY_25ms.boolTrip;
	//母线1无压检测
	bY2 = LowRelay(g_ui[pSet->bzt_mx_pt1].m2[0], pSet->dMX1UPowerLost, pSet->dMX1UPowerLost_fh, pR->tBzt.uBZTUI.bBZT.b1MWY);
	RunTR(&pR->tBzt.tDL3_PT1_WY_25ms, bY2, dStep);	
	pR->tBzt.uBZTUI.bBZT.b1MWY = pR->tBzt.tDL3_PT1_WY_25ms.boolTrip;
	//母线2有压检测
	bY3 = OverRelay(g_ui[pSet->bzt_mx_pt2].m2[0], pSet->dMX2UPower, pSet->dMX2UPower_fh, pR->tBzt.uBZTUI.bBZT.b2MYY);
	RunTR(&pR->tBzt.tDL3_PT2_YY_25ms, bY3, dStep);	
	pR->tBzt.uBZTUI.bBZT.b2MYY = pR->tBzt.tDL3_PT2_YY_25ms.boolTrip;
	//母线2无压检测
	bY4 = LowRelay(g_ui[pSet->bzt_mx_pt2].m2[0], pSet->dMX2UPowerLost, pSet->dMX2UPowerLost_fh, pR->tBzt.uBZTUI.bBZT.b2MWY);
	RunTR(&pR->tBzt.tDL3_PT2_WY_25ms, bY4, dStep);	
	pR->tBzt.uBZTUI.bBZT.b2MWY = pR->tBzt.tDL3_PT2_WY_25ms.boolTrip;
	
	//进线1电压有压检测
	bY5 = OverRelay(g_ui[pSet->bzt_dl1_pt].m2[0], pSet->dJX1UPower, pSet->dJX1UPower_fh, pR->tBzt.uBZTUI.bBZT.Ux1YY);
	RunTR(&pR->tBzt.tDL1_YY_25ms, bY5, dStep);	
	pR->tBzt.uBZTUI.bBZT.Ux1YY = pR->tBzt.tDL1_YY_25ms.boolTrip;
	//进线1电压无压检测
	bY6 = LowRelay(g_ui[pSet->bzt_dl1_pt].m2[0], pSet->dJX1UPowerLost, pSet->dJX1UPowerLost_fh, pR->tBzt.uBZTUI.bBZT.Ux1WY);
	RunTR(&pR->tBzt.tDL1_WY_25ms, bY6, dStep);	
	pR->tBzt.uBZTUI.bBZT.Ux1WY = pR->tBzt.tDL1_WY_25ms.boolTrip;
	
	//进线2电压有压检测
	bY7 = OverRelay(g_ui[pSet->bzt_dl2_pt].m2[0], pSet->dJX2UPower, pSet->dJX2UPower_fh, pR->tBzt.uBZTUI.bBZT.Ux2YY);
	RunTR(&pR->tBzt.tDL2_YY_25ms, bY7, dStep);	
	pR->tBzt.uBZTUI.bBZT.Ux2YY = pR->tBzt.tDL2_YY_25ms.boolTrip;
	//进线2电压无压检测
	bY8 = LowRelay(g_ui[pSet->bzt_dl2_pt].m2[0], pSet->dJX2UPowerLost, pSet->dJX2UPowerLost_fh, pR->tBzt.uBZTUI.bBZT.Ux2WY);
	RunTR(&pR->tBzt.tDL2_WY_25ms, bY8, dStep);	
	pR->tBzt.uBZTUI.bBZT.Ux2WY = pR->tBzt.tDL2_WY_25ms.boolTrip;

	ui_begin = UI_SW_INDEX_BEGIN(sw);
	I_ct_1   = g_ui[ui_begin + pSet->bzt_dl1_ct].m2[0];
	I_ct_2   = g_ui[ui_begin + pSet->bzt_dl2_ct].m2[0];
	//#1进线无流判断
	bY9 = LowRelay(I_ct_1, pSet->dwl, pSet->dwl, pR->tBzt.uBZTUI.bBZT.Ix1WL);
	RunTR(&pR->tBzt.tDL1_WL_25ms, bY9, dStep);	
	pR->tBzt.uBZTUI.bBZT.Ix1WL = pR->tBzt.tDL1_WL_25ms.boolTrip;	
	//#2进线无流判断
	bY10 = LowRelay(I_ct_2, pSet->dwl, pSet->dwl, pR->tBzt.uBZTUI.bBZT.Ix2WL);
	RunTR(&pR->tBzt.tDL2_WL_25ms, bY10, dStep);	
	pR->tBzt.uBZTUI.bBZT.Ix2WL = pR->tBzt.tDL2_WL_25ms.boolTrip;
}

void Bzt_RunStatus(int sw, DWORD  dStep)
{
	TSETSW *pSet = &pRunSet->tSwSet[sw];
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 	
	bool bY1;//, bY2;


	RunTR(&pR->tBzt.tDL1_HZ_BW_Timer, !pR->tSWST.uSWST.bFlag.b1DLHW, dStep);    
	bY1 = pR->tBzt.tDL1_HZ_BW_Timer.boolTrip && pR->tSWST.uSWST.bFlag.b1DLHW;
	if(bY1)  // DL1开关由分到合	
	{
		ResetTR(&pR->tBzt.tDL1_HZ_BW_Timer);
#ifdef BZT_PRINTF_DEBUG		
		rt_printf("\r\n DL1合闸变位");
#endif
		uBZT->bBZT.bHFAIL = 0;
		pR->tSWST.uSWST.bFlag.bBZTSY = 0;
		pR->tBzt.uBZTUI.bBZT.bZFCD = 0;
	}
	
	RunTR(&pR->tBzt.tDL1_TZ_BW_Timer, pR->tSWST.uSWST.bFlag.b1DLHW, dStep);    
	bY1 = pR->tBzt.tDL1_TZ_BW_Timer.boolTrip && !pR->tSWST.uSWST.bFlag.b1DLHW;
	if(bY1)  // DL1开关由合到分
	{
		ResetTR(&pR->tBzt.tDL1_TZ_BW_Timer);
#ifdef BZT_PRINTF_DEBUG			
		rt_printf("\r\n DL1分闸变位");
#endif
		uBZT->bBZT.bTFAIL = 0;
		//不是控制器跳闸瞬时放电
		if(!uBZT->bBZT.auto_tz)
			pR->tBzt.uBZTUI.bBZT.bFDZTCD = false;	
		uBZT->bBZT.auto_tz = 0;
		uBZT->bBZT.dl1_tz = 1;
	}
	if((g_sw[sw].do_cfg_index[SW_DO_JX2_SY] < g_equ_config->do_num) && (g_sw[sw].do_cfg_index[SW_DO_JX1_SY] == 0xffff))
	{
		bY1 = !pR->tSWST.uSWST.bFlag.bBZTSY;
		RunTR(&pR->tBzt.tDL1_CD_RESET_Timer, uBZT->bBZT.dl1_tz&&bY1, dStep);  
		if(pR->tBzt.tDL1_CD_RESET_Timer.boolTrip)
		{
			uBZT->bBZT.dl1_tz = 0;
			pR->tBzt.uBZTUI.bBZT.bZFCD = 0;	
		}
	}

	
	RunTR(&pR->tBzt.tDL2_HZ_BW_Timer, !pR->tSWST.uSWST.bFlag.b2DLHW, dStep);    
	bY1 = pR->tBzt.tDL2_HZ_BW_Timer.boolTrip && pR->tSWST.uSWST.bFlag.b2DLHW;
	if(bY1)  // DL2开关由分到合	
	{
		ResetTR(&pR->tBzt.tDL2_HZ_BW_Timer);
#ifdef BZT_PRINTF_DEBUG			
		rt_printf("\r\n DL2合闸变位");
#endif
		uBZT->bBZT.bHFAIL = 0;
		uBZT->bBZT.CMDZF_STEP_T = 0;
	}
	RunTR(&pR->tBzt.tDL2_TZ_BW_Timer, pR->tSWST.uSWST.bFlag.b2DLHW, dStep);    
	bY1 = pR->tBzt.tDL2_TZ_BW_Timer.boolTrip && !pR->tSWST.uSWST.bFlag.b2DLHW;
	if(bY1)  // DL2开关由合到分
	{
		ResetTR(&pR->tBzt.tDL2_TZ_BW_Timer);
#ifdef BZT_PRINTF_DEBUG		
		rt_printf("\r\n DL2分闸变位");
#endif
		uBZT->bBZT.bTFAIL = 0;
		if(!uBZT->bBZT.auto_tz)
			pR->tBzt.uBZTUI.bBZT.bFDZTCD = false;	
		uBZT->bBZT.auto_tz = 0;
		uBZT->bBZT.CMDZF_STEP_H = 0;
	}
	RunTR(&pR->tBzt.tDL3_HZ_BW_Timer, !pR->tSWST.uSWST.bFlag.b3DLHW, dStep);    
	bY1 = pR->tBzt.tDL3_HZ_BW_Timer.boolTrip && pR->tSWST.uSWST.bFlag.b3DLHW;
	if(bY1)  // DL3开关由分到合	
	{
		ResetTR(&pR->tBzt.tDL3_HZ_BW_Timer);
#ifdef BZT_PRINTF_DEBUG			
		rt_printf("\r\n DL3合闸变位");
#endif
		uBZT->bBZT.bHFAIL = 0;
		OC_FaultEventClear(sw);
	}

	RunTR(&pR->tBzt.tDL3_TZ_BW_Timer, pR->tSWST.uSWST.bFlag.b3DLHW, dStep);    
	bY1 = pR->tBzt.tDL3_TZ_BW_Timer.boolTrip && !pR->tSWST.uSWST.bFlag.b3DLHW;
	if(bY1)  // DL3开关由合到分
	{
		ResetTR(&pR->tBzt.tDL3_TZ_BW_Timer);
#ifdef BZT_PRINTF_DEBUG			
		rt_printf("\r\n DL3分闸变位");
#endif
		uBZT->bBZT.bTFAIL = 0;
		uBZT->bBZT.CMDZTH	= 0;	 //避免合上后有故障分闸，报合闸失败SOE
		uBZT->bBZT.CMDJXHTH = 0;
		uBZT->bBZT.CMDDJXHTH = 0;
		pR->uBHDZ.bFlag.bTZSB = 0;
	}
#if 0	
	// 合位灯、跳位灯
	if (pR->tSWST.uSWST.bFlag.b3DLHW)
	{			 
		led_set_sw(sw,SW_LED_HW, LED_ON);
	}
	else
	{	
		led_set_sw(sw,SW_LED_HW, LED_OFF);
	}		
	if (!pR->tSWST.uSWST.bFlag.b3DLHW)
	{
		led_set_sw(sw,SW_LED_TW, LED_ON);
	}		
	else
	{
		led_set_sw(sw,SW_LED_TW, LED_OFF);
	}
#endif
	if(uBZT->bBZT.bHFAIL == 0)
	{
		if(soe_check(EV_BZT_HZ1_FAIL+sw*EV_SW_NUM)==true)
		{
			soe_record_ev(EV_BZT_HZ1_FAIL+sw*EV_SW_NUM, 0, 0,0,0 );
		}
		if(soe_check(EV_BZT_HZ2_FAIL+sw*EV_SW_NUM)==true)
		{
			soe_record_ev(EV_BZT_HZ2_FAIL+sw*EV_SW_NUM, 0, 0,0,0 );
		}	
		if(soe_check(EV_BZT_HZ3_FAIL+sw*EV_SW_NUM)==true)
		{
			soe_record_ev(EV_BZT_HZ3_FAIL+sw*EV_SW_NUM, 0, 0,0,0 );
		}
	}
	if(uBZT->bBZT.bTFAIL == 0)
	{
		if(soe_check(EV_BZT_TZ1_FAIL+sw*EV_SW_NUM)==true)
		{
			soe_record_ev(EV_BZT_TZ1_FAIL+sw*EV_SW_NUM, 0, 0,0,0 );
		}
		if(soe_check(EV_BZT_TZ2_FAIL+sw*EV_SW_NUM)==true)
		{
			soe_record_ev(EV_BZT_TZ2_FAIL+sw*EV_SW_NUM, 0, 0,0,0 );
		}	
		if(soe_check(EV_BZT_TZ3_FAIL+sw*EV_SW_NUM)==true)
		{
			soe_record_ev(EV_BZT_TZ3_FAIL+sw*EV_SW_NUM, 0, 0,0,0 );
		}		
	}
	//DL3常规保护跳闸失败
	if(pSet->bBZT_BH_TT)
	{
		if (pR->uBHDZ.bFlag.bTZSB)
		{
			if(soe_check(EV_BZT_TZ3_FAIL+sw*EV_SW_NUM)==false)
			{
				soe_record_ev(EV_BZT_TZ3_FAIL+sw*EV_SW_NUM, 1, 0,0,0 );
			}
		}
		else
		{
			if(soe_check(EV_BZT_TZ3_FAIL+sw*EV_SW_NUM)==true)
			{
				soe_record_ev(EV_BZT_TZ3_FAIL+sw*EV_SW_NUM, 0, 0,0,0 );
			}
		}	
	}
}

int BZT_ManualOnEnableCheck(int sw, u32 index)
{
	TRELAY_T *pR=&g_tRelay[sw];

	if(index == SW_DO_FD_HZ)
	{
		if(!pR->tSWST.uSWST.bFlag.b3DLHW && (!pR->tSWST.uSWST.bFlag.b1DLHW|| !pR->tSWST.uSWST.bFlag.b2DLHW))
		{
			return 0;
		}
		return -1;
	}
	else if(index == SW_DO_DL1_HZ)
	{
		if((pR->tSWST.uSWST.bFlag.b3DLHW && !pR->tSWST.uSWST.bFlag.b2DLHW) || !pR->tSWST.uSWST.bFlag.b3DLHW)
		{
			return 0;
		}	
#ifdef BZT_PRINTF_DEBUG			
		rt_printf("\r\n 闭锁1#开关人工合闸");
#endif
		return -1;
	}
	else if(index == SW_DO_DL2_HZ)
	{
		if((pR->tSWST.uSWST.bFlag.b3DLHW && !pR->tSWST.uSWST.bFlag.b1DLHW) || !pR->tSWST.uSWST.bFlag.b3DLHW)
		{
			return 0;
		}	
#ifdef BZT_PRINTF_DEBUG	
		rt_printf("\r\n 闭锁2#开关人工合闸");
#endif
		return -1;
	}
	return 0;
}

int BZT_ManualOnOffHandle(int sw, u32 index)
{
	TRELAY_T *pR=&g_tRelay[sw];

	if(index == SW_DO_FD_HZ)
	{
#ifdef BZT_PRINTF_DEBUG		
		rt_printf("\r\n 3#开关人工合闸");
#endif
		if(!pR->tSWST.uSWST.bFlag.b3DLHW && (!pR->tSWST.uSWST.bFlag.b1DLHW|| !pR->tSWST.uSWST.bFlag.b2DLHW))
		{
			sw_do(sw,SW_DO_FD_HZ,SW_DO_TYPE_ON);
			return 0;
		}
		return -1;
	}
	else if(index == SW_DO_DL1_HZ)
	{
#ifdef BZT_PRINTF_DEBUG		
		rt_printf("\r\n 1#开关人工合闸");
#endif
		if((pR->tSWST.uSWST.bFlag.b3DLHW && !pR->tSWST.uSWST.bFlag.b2DLHW) || !pR->tSWST.uSWST.bFlag.b3DLHW)
		{
			sw_do(sw,SW_DO_DL1_HZ,SW_DO_TYPE_ON);
			return 0;
		}	
		return -1;
	}
	else if(index == SW_DO_DL2_HZ)
	{
#ifdef BZT_PRINTF_DEBUG		
		rt_printf("\r\n 2#开关人工合闸");
#endif
		if((pR->tSWST.uSWST.bFlag.b3DLHW && !pR->tSWST.uSWST.bFlag.b1DLHW) || !pR->tSWST.uSWST.bFlag.b3DLHW)
		{
			sw_do(sw,SW_DO_DL2_HZ,SW_DO_TYPE_ON);
			return 0;
		}		
		return -1;
	}
	else if(index == SW_DO_FD_FZ) 
	{
#ifdef BZT_PRINTF_DEBUG		
		rt_printf("\r\n 3#开关人工分闸");
#endif
		sw_do(sw,SW_DO_FD_FZ,SW_DO_TYPE_ON);
	}
	else if(index == SW_DO_DL1_FZ) 
	{
#ifdef BZT_PRINTF_DEBUG		
		rt_printf("\r\n 1#开关人工分闸");
#endif
		sw_do(sw,SW_DO_DL1_FZ,SW_DO_TYPE_ON);
	}
	else if(index == SW_DO_DL2_FZ) 
	{
#ifdef BZT_PRINTF_DEBUG	
		rt_printf("\r\n 2#开关人工分闸");
#endif
		sw_do(sw,SW_DO_DL2_FZ,SW_DO_TYPE_ON);
	}
	return 0;
}

void bzt_oc_sw_off(int sw)
{
	//TSETSW *pSet = &pRunSet->tSwSet[sw];
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 	
	//bool bY1;//, bY2;
#if 0
	if(pR->tSWST.uSWST.bFlag.b1DLHW)
	{
		sw_do(sw,SW_DO_DL1_FZ,SW_DO_TYPE_ON);
	}
	if(pR->tSWST.uSWST.bFlag.b2DLHW)
	{
		sw_do(sw,SW_DO_DL2_FZ,SW_DO_TYPE_ON);
	}	
#endif
	if(uBZT->bBZT.bZF)
	{
		if((g_sw[sw].do_cfg_index[SW_DO_JX1_SY] < g_equ_config->do_num) && (g_sw[sw].do_cfg_index[SW_DO_JX2_SY] == 0xffff))
		{
			sw_do(sw,SW_DO_DL1_FZ,SW_DO_TYPE_ON);
		}
		else if((g_sw[sw].do_cfg_index[SW_DO_JX2_SY] < g_equ_config->do_num) && (g_sw[sw].do_cfg_index[SW_DO_JX1_SY] == 0xffff))
		{
			sw_do(sw,SW_DO_DL2_FZ,SW_DO_TYPE_ON);
		}	
	}
	else
	{
		if(pR->tSWST.uSWST.bFlag.b3DLHW)
		{
			sw_do(sw,SW_DO_FD_FZ,SW_DO_TYPE_ON);
		}	
	}
}


/**************************************************************************
函数名称：BztProcess
函数版本：1.00 
作者：   
创建日期： 
函数功能说明：备自投逻辑				  
输入参数：
其他输入:
输出参数：
返回值：无
***************************************************************************/
void BztProcess(int sw, DWORD Step)
{
	TRELAY_T *pR=&g_tRelay[sw];
	UBZT *uBZT =&pR->tBzt.uBZT; 

	/**********************************************************************
	备自投发跳令前投入启动判断，防止发跳令前启动-返回-再启动的过程出现:
	***********************************************************************/
	if(uBZT->bBZT.bFD)
	{
		if(!uBZT->bBZT.CMDZTT)
		{
			BztFdZtQdLogic(sw, Step);	
		}
	}
	else if(uBZT->bBZT.bJX)
	{
		if(!uBZT->bBZT.CMDJXHTT)
		{
			BztJxHtQdLogic(sw, Step);
		}
	}
	else if(uBZT->bBZT.bDJX)
	{
	//	if(!uBZT->bBZT.CMDDJXHTT)
		{
			BztJxHtQdLogic(sw, Step);
		}
	}		
		
	/**********************************************************************
	 只有备自投真正启动后才进入备自投故障处理
	/保证不因其他启动后，备自投动作，其他启动返回，整组复归的情况出现。
	***********************************************************************/
	if(!uBZT->bBZT.CJQD)
	{
		return;
	}	

	if(uBZT->bBZT.bFD && uBZT->bBZT.FDZTQD)
	{
		BztProcessFdZt(sw, Step);
	}

	if(uBZT->bBZT.bJX && uBZT->bBZT.JXHTQD)
	{
		BztProcessJXHt(sw, Step);
	}
	if(uBZT->bBZT.bDJX && (uBZT->bBZT.JX1HTQD || uBZT->bBZT.JX2HTQD))
	{
		BztProcessDJXHt(sw, Step);
	}
	if(uBZT->bBZT.bZF && uBZT->bBZT.ZFHTQD)
	{
		BztDL1_ZFHt(sw, Step);
		BztDL2_ZFHt(sw, Step);
	}
}

void BztTimerInit(int sw)
{
	TSETSW *pSet = &pRunSet->tSwSet[sw];
	TRELAY_T *pR = &g_tRelay[sw];

	InitTR(&pR->tBzt.tTb_JXFS_T, pSet->dT_BTTZ, 0); 
	InitTR(&pR->tBzt.tTb_JXFS_H, pSet->dT_BTHZ, 0); 

	InitTR(&pR->tBzt.tTb_FDFS_T, pSet->dT_BTTZ, 0); 
	InitTR(&pR->tBzt.tTb_FDFS_H, pSet->dT_BTHZ, 0); 
	InitTR(&pR->tBzt.tTb_ZF_T, pSet->dT_BTHZ, 0); 

	InitTR(&pR->tBzt.tTb_DJXFS_T, pSet->dT_BTTZ, 0); 
	InitTR(&pR->tBzt.tTb_DJXFS_H, pSet->dT_BTHZ, 0); 
	InitTR(&pR->tBzt.tTb_ZF_H, pSet->dT_BTHZ, 0); 
	
	
	InitTR(&pR->tBzt.tTJxZtCd, pSet->dT_BTCD, 0);
	InitTR(&pR->tBzt.tTFdZtCd, pSet->dT_BTCD, 0);

	InitTR(&pR->tBzt.tTJx1ZtCd, pSet->dT_BTCD, 0);
	InitTR(&pR->tBzt.tTJx2ZtCd, pSet->dT_BTCD, 0);
	InitTR(&pR->tBzt.tTZfZCd, pSet->dT_BTCD, 0);
	

	//InitTR(&pR->tBzt.tTbttsb, pRunSet->dT_TZSB, 0);
	InitTR(&pR->tBzt.tTbttsb, T_1s*2, 0);
	InitTR(&pR->tBzt.tTbthsb, T_1s*2, 0);
	InitTR(&pR->tBzt.tDL1_YY_25ms,T_25ms*2, T_25ms*2);
	InitTR(&pR->tBzt.tDL1_WY_25ms,T_25ms*2, T_25ms*2);
	InitTR(&pR->tBzt.tDL2_YY_25ms,T_25ms*2, T_25ms*2);
	InitTR(&pR->tBzt.tDL2_WY_25ms,T_25ms*2, T_25ms*2);
	InitTR(&pR->tBzt.tDL3_PT1_YY_25ms,T_25ms*2, T_25ms*2);
	InitTR(&pR->tBzt.tDL3_PT1_WY_25ms,T_25ms*2, T_25ms*2);
	InitTR(&pR->tBzt.tDL3_PT2_YY_25ms,T_25ms*2, T_25ms*2);
	InitTR(&pR->tBzt.tDL3_PT2_WY_25ms,T_25ms*2, T_25ms*2);
	InitTR(&pR->tBzt.tDL1_WL_25ms,T_25ms*2, T_25ms*2);
	InitTR(&pR->tBzt.tDL1_WL_25ms,T_25ms*2, T_25ms*2);
	
	InitTR(&pR->tBzt.tDL1_HZ_BW_Timer,T_100ms, T_100ms);
	InitTR(&pR->tBzt.tDL1_TZ_BW_Timer,T_100ms, T_100ms);
	InitTR(&pR->tBzt.tDL2_HZ_BW_Timer,T_100ms, T_100ms);
	InitTR(&pR->tBzt.tDL2_TZ_BW_Timer,T_100ms, T_100ms);
	InitTR(&pR->tBzt.tDL3_HZ_BW_Timer,T_100ms, T_100ms);
	InitTR(&pR->tBzt.tDL3_TZ_BW_Timer,T_100ms, T_100ms);
	InitTR(&pR->tBzt.tDL3_TZ_BW_500ms_Timer, T_100ms, T_500ms);	
	InitTR(&pR->tBzt.tDL1_CD_RESET_Timer, T_300ms, 0);	
	
	InitTR(&pR->tBzt.tTb_FD_delay_fd, pSet->dT_BTTZ + pSet->dT_BTHZ + T_1s*2, 0); 	//分段延时放电计时
	InitTR(&pR->tBzt.tTb_JX_delay_fd, pSet->dT_BTTZ + pSet->dT_BTHZ + T_1s*2, 0);	//进线延时放电计时
	InitTR(&pR->tBzt.tTb_DJX_delay_fd, pSet->dT_BTTZ + pSet->dT_BTHZ + T_1s*2, T_500ms);	//单进线延时放电计时

	InitTR(&g_tVolLost.tQDTime, pRunSet->tVolLostSet.dTVol, 0);
	InitTR(&g_tVolLost.tCYYTime,  T_25ms, 0); 	
}

void BztTimerChange(int sw)
{
	TSETSW *pSet = &pRunSet->tSwSet[sw];
	TRELAY_T *pR = &g_tRelay[sw];

	InitTR_Time(&pR->tBzt.tTb_JXFS_T, pSet->dT_BTTZ, 0); 
	InitTR_Time(&pR->tBzt.tTb_JXFS_H, pSet->dT_BTHZ, 0); 
	InitTR_Time(&pR->tBzt.tTb_FDFS_T, pSet->dT_BTTZ, 0); 
	InitTR_Time(&pR->tBzt.tTb_FDFS_H, pSet->dT_BTHZ, 0); 
	InitTR_Time(&pR->tBzt.tTb_DJXFS_T, pSet->dT_BTTZ, 0); 
	InitTR_Time(&pR->tBzt.tTb_DJXFS_H, pSet->dT_BTHZ, 0); 
	
	InitTR(&pR->tBzt.tTb_ZF_T, pSet->dT_BTTZ, 0); 
	InitTR_Time(&pR->tBzt.tTb_ZF_H, pSet->dT_BTHZ, 0); 
	

	InitTR_Time(&pR->tBzt.tTJxZtCd, pSet->dT_BTCD, 0);
	InitTR_Time(&pR->tBzt.tTFdZtCd, pSet->dT_BTCD, 0);
	InitTR_Time(&pR->tBzt.tTJx1ZtCd, pSet->dT_BTCD, 0);
	InitTR_Time(&pR->tBzt.tTJx2ZtCd, pSet->dT_BTCD, 0);
	InitTR_Time(&pR->tBzt.tTZfZCd, pSet->dT_BTCD, 0);

	InitTR(&pR->tBzt.tTb_FD_delay_fd, pSet->dT_BTTZ + pSet->dT_BTHZ + T_1s*2, T_100ms); 	//分段延时放电计时
	InitTR(&pR->tBzt.tTb_JX_delay_fd, pSet->dT_BTTZ + pSet->dT_BTHZ + T_1s*2, T_500ms);	//进线延时放电计时
	InitTR(&pR->tBzt.tTb_DJX_delay_fd, pSet->dT_BTTZ + pSet->dT_BTHZ + T_1s*2, T_500ms);	//单进线延时放电计时

	InitTR_Time(&g_tVolLost.tQDTime, pRunSet->tVolLostSet.dTVol, 0);
}

/**************************************************************************
函数名称：BztProcessFdZt
函数版本：1.00 
作者：   xj
创建日期：2007.8.31    
函数功能说明：分段自投方式逻辑					  
输入参数：
其他输入:
输出参数：
返回值：无
***************************************************************************/
void BztProcessFdZt(int sw, DWORD Step)
{
	bool boolH2,boolH3;
	bool boolY1,boolY2,boolY3;
	bool boolY7,boolY9;
	BYTE dl_x = 0;
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 	


	/**********************************************************************
	boolY3 = 自投充电标志 && （（母线1无压 && 进线1无流 && 母线2有压）||（&& 母线2无压  && 进线2无流 && 母线1有压））
	***********************************************************************/
#if 1	//不采集进线侧电流
	boolY1 = (pR->tBzt.uBZTUI.bBZT.b1MWY && pR->tBzt.uBZTUI.bBZT.Ix1WL && pR->tBzt.uBZTUI.bBZT.b2MYY);
	boolY2 = (pR->tBzt.uBZTUI.bBZT.b2MWY && pR->tBzt.uBZTUI.bBZT.Ix2WL && pR->tBzt.uBZTUI.bBZT.b1MYY);
#else
	boolY1 = (pR->tBzt.uBZTUI.bBZT.b1MWY && pR->tSWST.uSWST.bFlag.b1DLHW && pR->tBzt.uBZTUI.bBZT.b2MYY);
	boolY2 = (pR->tBzt.uBZTUI.bBZT.b2MWY && pR->tSWST.uSWST.bFlag.b2DLHW && pR->tBzt.uBZTUI.bBZT.b1MYY);	
#endif
	boolY3 = pR->tBzt.uBZTUI.bBZT.bFDZTCD && (boolY1 || boolY2) && uBZT->bBZT.FDZTQD;

	RunTR(&pR->tBzt.tTb_FDFS_T,boolY3,Step);
	/**********************************************************************
	正常或加速跳工作断路器
	***********************************************************************/		
	boolH2 = pR->tBzt.tTb_FDFS_T.boolTrip;
	
	boolH3 = boolH2 || uBZT->bBZT.CMDZTT;
    uBZT->bBZT.CMDZTT = boolH3;


	if(boolY1)
	{
		dl_x = DL_1;			//跳进线1	
	}
	else if(boolY2)
	{
		dl_x = DL_2;			//跳进线2	
	}
	Out_BZT_ZTTZ(sw, uBZT->bBZT.CMDZTT,dl_x);


	/**********************************************************************
	跳闸后合分段开关
	发出跳工作电源命令&&(工作断路器跳位&&I母电压低于残压)||(工作断路器跳位&&II母电压低于残压)
	***********************************************************************/
	boolY7 = uBZT->bBZT.CMDZTT 					//是否发出跳工作电源命令
			&&(((!pR->tSWST.uSWST.bFlag.b1DLHW) && pR->tBzt.uBZTUI.bBZT.b1MWY && (pR->tBzt.tBZT_dlx.fz_dlx == DL_1))
			||((!pR->tSWST.uSWST.bFlag.b2DLHW) && pR->tBzt.uBZTUI.bBZT.b2MWY && (pR->tBzt.tBZT_dlx.fz_dlx == DL_2)));
	
	RunTR(&pR->tBzt.tTb_FDFS_H,boolY7 ,Step);				//分段开关合闸延时
	boolY9 = pR->tBzt.tTb_FDFS_H.boolTrip || uBZT->bBZT.CMDZTH;			
	uBZT->bBZT.CMDZTH = boolY9;
	Out_BZT_ZTHZ(sw, uBZT->bBZT.CMDZTH,DL_3);//合分段开关
}




/**************************************************************************
函数名称：BztProcessHt
函数版本：1.00 
作者：   xj
创建日期：    
函数功能说明：互投方式逻辑					  
输入参数：
其他输入:
输出参数：
返回值：无
***************************************************************************/
void BztProcessJXHt(int sw, DWORD Step)
{
	bool boolH2,boolH3;
	bool boolY1,boolY2,boolY3,boolY4;
	bool boolY7,boolY8,boolY9,boolY10;
	BYTE dl_x=0,dl_y=0;
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 
	
	#if 1
	/**********************************************************************
	boolY1 = 充电标志 
	***********************************************************************/
	boolY1 = pR->tBzt.uBZTUI.bBZT.bJXHTCD;
						
	/**********************************************************************
	boolY2 = (线路1无压) && (母线1无压) 
	***********************************************************************/
	boolY2 = pR->tBzt.uBZTUI.bBZT.Ux1WY && pR->tBzt.uBZTUI.bBZT.b1MWY;

	/**********************************************************************
	boolY3 = (线路2无压) && (母线2无压) 
	***********************************************************************/
	boolY3 = pR->tBzt.uBZTUI.bBZT.Ux2WY && pR->tBzt.uBZTUI.bBZT.b2MWY;

	/**********************************************************************
	boolY4 = boolY1 && 进线1无流 && 进线2无流 &&((boolY2 && DL2分位) || (boolY3 && DL1分位))
	***********************************************************************/
	boolY4 = uBZT->bBZT.JXHTQD && boolY1 && pR->tBzt.uBZTUI.bBZT.Ix1WL && pR->tBzt.uBZTUI.bBZT.Ix2WL &&
			((boolY2 && (!pR->tSWST.uSWST.bFlag.b2DLHW)) || (boolY3 && (!pR->tSWST.uSWST.bFlag.b1DLHW)));

	/**********************************************************************
	跳工作电源开关延时
	***********************************************************************/		
	RunTR(&pR->tBzt.tTb_JXFS_T,boolY4,Step);	
	/**********************************************************************
	正常或加速跳工作断路器
	***********************************************************************/		
	boolH2 = pR->tBzt.tTb_JXFS_T.boolTrip;
	
	boolH3 = boolH2 || uBZT->bBZT.CMDJXHTT;
    uBZT->bBZT.CMDJXHTT = boolH3;

	if(boolY2)
	{
		dl_x = DL_1;			//跳进线1	
	}
	else if(boolY3)
	{
		dl_x = DL_2;			//跳进线2	
	}
	Out_BZT_ZTTZ(sw, uBZT->bBZT.CMDJXHTT,dl_x);		//跳工作电源进线开关	

	/**********************************************************************
	跳闸后合备用开关
	发出跳工作电源命令&&工作开关跳位  
	***********************************************************************/

	boolY8 = (!pR->tSWST.uSWST.bFlag.b1DLHW) && (pR->tBzt.tBZT_dlx.fz_dlx == DL_1);
	boolY9 = (!pR->tSWST.uSWST.bFlag.b2DLHW) && (pR->tBzt.tBZT_dlx.fz_dlx == DL_2);
	
	boolY7 = uBZT->bBZT.CMDJXHTT 					//是否发出跳工作电源命令
				&&(boolY8 || boolY9) && uBZT->bBZT.JXHTQD;
	
	RunTR(&pR->tBzt.tTb_JXFS_H,boolY7,Step);				//备用开关合闸延时
	boolY10 = pR->tBzt.tTb_JXFS_H.boolTrip || uBZT->bBZT.CMDJXHTH;			
	uBZT->bBZT.CMDJXHTH = boolY10;

	if(pR->tBzt.tBZT_dlx.fz_dlx == DL_1)
	{
		dl_y = DL_2;			//合进线2	
	}
	else if(pR->tBzt.tBZT_dlx.fz_dlx == DL_2)
	{
		dl_y = DL_1;			//合进线1
	}
	Out_BZT_ZTHZ(sw, uBZT->bBZT.CMDJXHTH, dl_y);					//合备用开关		
#endif
}

void BztProcessDJXHt(int sw, DWORD Step)
{
	bool boolY1,boolY2,boolY3,boolY4,boolY5,boolY6;
	bool boolY7,boolY8,boolY9;
	BYTE dl_x=0;
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 
	
	#if 1
	/**********************************************************************
	boolY1 = 充电标志 
	***********************************************************************/
	boolY1 = pR->tBzt.uBZTUI.bBZT.bJX1ZTCD;
	boolY2 = pR->tBzt.uBZTUI.bBZT.bJX2ZTCD;
						
	/**********************************************************************
	boolY3 = (线路1无压) && (母线1无压) 
	***********************************************************************/
	boolY3 = pR->tBzt.uBZTUI.bBZT.Ux1WY && pR->tBzt.uBZTUI.bBZT.b1MWY;

	/**********************************************************************
	boolY4 = (线路2无压) && (母线2无压) 
	***********************************************************************/
	boolY4 = pR->tBzt.uBZTUI.bBZT.Ux2WY && pR->tBzt.uBZTUI.bBZT.b2MWY;
#if 0
	/**********************************************************************
	boolY5 = boolY1 && 进线1无流 && 进线2无流 &&((boolY2 && DL2分位) || (boolY3 && DL1分位))
	***********************************************************************/
	boolY5 = uBZT->bBZT.JXHTQD && boolY1 && pR->tBzt.uBZTUI.bBZT.Ix1WL && pR->tBzt.uBZTUI.bBZT.Ix2WL &&
			((boolY2 && (!pR->tSWST.uSWST.bFlag.b2DLHW)) || (boolY3 && (!pR->tSWST.uSWST.bFlag.b1DLHW)));
#endif
	/**********************************************************************
	boolY5 = 进线1充电完成 && 进线1启动 && 线路1无压 && 母线1无压 && 进线1无流)
	***********************************************************************/
	boolY5 = uBZT->bBZT.JX1HTQD && pR->tBzt.uBZTUI.bBZT.bJX1ZTCD && boolY3
				&& pR->tBzt.uBZTUI.bBZT.Ix1WL;

	/**********************************************************************
	boolY6 = 进线2充电完成 && 进线2启动 && 线路2无压 && 母线2无压 && 进线2无流)
	***********************************************************************/
	boolY6 = uBZT->bBZT.JX2HTQD && pR->tBzt.uBZTUI.bBZT.bJX1ZTCD && boolY4
				&& pR->tBzt.uBZTUI.bBZT.Ix2WL;

	/**********************************************************************
	跳工作电源开关延时
	***********************************************************************/		
	RunTR(&pR->tBzt.tTb_DJXFS_T, (boolY5||boolY6)&&!uBZT->bBZT.JX_CD_BH, Step);	
	/**********************************************************************
	正常或加速跳工作断路器
	***********************************************************************/		
    uBZT->bBZT.CMDDJXHTT = pR->tBzt.tTb_DJXFS_T.boolTrip || uBZT->bBZT.CMDDJXHTT;
	if(boolY5)
	{
		dl_x = DL_1;			//跳进线1	
	}
	else if(boolY6)
	{
		dl_x = DL_2;			//跳进线2	
	}
	Out_BZT_ZTTZ(sw, uBZT->bBZT.CMDDJXHTT,dl_x);		//跳工作电源进线开关	

	/**********************************************************************
	跳闸后合备用开关
	发出跳工作电源命令&&工作开关跳位  
	***********************************************************************/
	boolY8 = (!pR->tSWST.uSWST.bFlag.b1DLHW) && ((pR->tBzt.tBZT_dlx.fz_dlx == DL_1) || uBZT->bBZT.JX_CD_BH);
	boolY9 = (!pR->tSWST.uSWST.bFlag.b2DLHW) && ((pR->tBzt.tBZT_dlx.fz_dlx == DL_2) || uBZT->bBZT.JX_CD_BH);
	boolY7 = (uBZT->bBZT.CMDDJXHTT||uBZT->bBZT.JX_CD_BH) 					//是否发出跳工作电源命令
				&&(boolY8 || boolY9) && (uBZT->bBZT.JX1HTQD || uBZT->bBZT.JX2HTQD);
	
	RunTR(&pR->tBzt.tTb_DJXFS_H,boolY7,Step);				//备用开关合闸延时	
	uBZT->bBZT.CMDDJXHTH = pR->tBzt.tTb_DJXFS_H.boolTrip || uBZT->bBZT.CMDDJXHTH;
	Out_BZT_ZTHZ(sw, uBZT->bBZT.CMDDJXHTH, DL_3);			//合分段开关		
#endif
}

void BztDL1_ZFHt(int sw, DWORD Step)
{
	bool boolY1=0,boolY2=0,boolY3=0;
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 

	if((g_sw[sw].do_cfg_index[SW_DO_JX1_SY] < g_equ_config->do_num) && (g_sw[sw].do_cfg_index[SW_DO_JX2_SY] == 0xffff))
	{
		//合进线1
		boolY1 = !pR->tSWST.uSWST.bFlag.b1DLHW && !pR->tSWST.uSWST.bFlag.b2DLHW; 
		/**********************************************************************
		boolY2 = (线路1有压) && (母线1有压) && (母线2有压) 
		***********************************************************************/
		boolY2 = pR->tBzt.uBZTUI.bBZT.Ux1YY && pR->tBzt.uBZTUI.bBZT.b1MYY && pR->tBzt.uBZTUI.bBZT.b2MYY;
		
		boolY3 = pR->tSWST.uSWST.bFlag.bBZTSY && pR->tBzt.uBZTUI.bBZT.bZFCD;
		RunTR(&pR->tBzt.tTb_ZF_H, boolY1&&boolY2&&boolY3, Step);	
		uBZT->bBZT.CMDZFHTH = pR->tBzt.tTb_ZF_H.boolTrip || uBZT->bBZT.CMDZFHTH;
		Out_BZT_ZTHZ(sw, uBZT->bBZT.CMDZFHTH, DL_1);	
	}
}

void BztDL2_ZFHt(int sw, DWORD Step)
{
	bool boolY1=0,boolY2=0,boolY3=0,boolY4=0;
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 
		
	if((g_sw[sw].do_cfg_index[SW_DO_JX2_SY] < g_equ_config->do_num) && (g_sw[sw].do_cfg_index[SW_DO_JX1_SY] == 0xffff))//进线2	
	{	
		/**********************************************************************
		boolY1 = 充电标志 
		***********************************************************************/
		boolY1 = pR->tBzt.uBZTUI.bBZT.bZFCD;
		boolY2 = pR->tSWST.uSWST.bFlag.bBZTSY && uBZT->bBZT.ZFHTQD;
		boolY3 = pR->tBzt.uBZTUI.bBZT.b1MWY && pR->tBzt.uBZTUI.bBZT.b2MWY 
					&& pR->tBzt.uBZTUI.bBZT.Ux1WY && pR->tBzt.uBZTUI.bBZT.Ux2YY;
		boolY4 = !pR->tSWST.uSWST.bFlag.b1DLHW	&& !pR->tSWST.uSWST.bFlag.b2DLHW;
		RunTR(&pR->tBzt.tTb_ZF_H, boolY1&&boolY2&&boolY3&&boolY4, Step);				//备用开关合闸延时	
		uBZT->bBZT.CMDZFHTH = pR->tBzt.tTb_ZF_H.boolTrip || uBZT->bBZT.CMDZFHTH;
		uBZT->bBZT.CMDZF_STEP_H = uBZT->bBZT.CMDZFHTH || uBZT->bBZT.CMDZF_STEP_H;
		Out_BZT_ZTHZ(sw, uBZT->bBZT.CMDZFHTH, DL_2);

		boolY1 = uBZT->bBZT.CMDZF_STEP_H;
		/**********************************************************************
		boolY2 = (线路1有压) && (线路2有压) && (母线1有压)	&& (母线2有压)
		***********************************************************************/
		boolY2 = pR->tBzt.uBZTUI.bBZT.Ux1YY && pR->tBzt.uBZTUI.bBZT.Ux2YY
					&& pR->tBzt.uBZTUI.bBZT.b1MYY && pR->tBzt.uBZTUI.bBZT.b2MYY;
		boolY3 = !pR->tSWST.uSWST.bFlag.b1DLHW	&& pR->tSWST.uSWST.bFlag.b2DLHW;
		RunTR(&pR->tBzt.tTb_ZF_T, boolY1&&boolY2&&boolY3, Step);	
		uBZT->bBZT.CMDZFHTT = pR->tBzt.tTb_ZF_T.boolTrip || uBZT->bBZT.CMDZFHTT;
		uBZT->bBZT.CMDZF_STEP_T = uBZT->bBZT.CMDZFHTT || uBZT->bBZT.CMDZF_STEP_T;
		Out_BZT_ZTTZ(sw, uBZT->bBZT.CMDZFHTT, DL_2);// 自己先跳闸
	}
}

void fz_dl(int sw, BYTE dl_x)
{
	TRELAY_T *pR = &g_tRelay[sw];
	
	if((dl_x > DL_3) || (dl_x < DL_1))
		return;

	switch(dl_x)
	{
		case DL_1:
		//	uTRIP.bTRIP.bT1DL = true;
			pR->tBzt.tBZT_dlx.fz_dlx = DL_1;
			break;
		case DL_2:
		//	uTRIP.bTRIP.bT2DL = true;
			pR->tBzt.tBZT_dlx.fz_dlx = DL_2;
			break;
		case DL_3:
		//	uTRIP.bTRIP.bT3DL = true;
			pR->tBzt.tBZT_dlx.fz_dlx = DL_3;
			break;
		default:
			break;
	}
}


void hz_dl(int sw, BYTE dl_x)
{
	TRELAY_T *pR = &g_tRelay[sw];

	if((dl_x > DL_3) || (dl_x < DL_1))
		return;
	
	switch(dl_x)
	{
		case DL_1:
		//	uTRIP.bTRIP.bH1DL = true;
			pR->tBzt.tBZT_dlx.hz_dlx = DL_1;
			break;
		case DL_2:
		//	uTRIP.bTRIP.bH2DL = true;
			pR->tBzt.tBZT_dlx.hz_dlx = DL_2;
			break;
		case DL_3:
		//	uTRIP.bTRIP.bH3DL = true;
			pR->tBzt.tBZT_dlx.hz_dlx = DL_3;
			break;
		default:
			break;

	}
}


/**************************************************************************
函数名称：Out_BZT_ZTTZ
函数版本：1.00 
作者：   
创建日期：2007.8.31    
函数功能说明：自投跳
输入参数：byState false--返回   true--动作
其他输入:
输出参数：
返回值：无
***************************************************************************/
void Out_BZT_ZTTZ(int sw,     bool bState,BYTE dl_x)
{
	BYTE code;
	BYTE dl_tzx;
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 	

	if((dl_x > DL_3) || (dl_x < DL_1))
		return;

	dl_tzx = dl_x - 1;
	code = (dl_tzx  + EV_ZT_TZ1);
	if(bState)			     	//备自投动作跳工作断路器
	{	
		if(!uBZT->bBZT.bZTTZ)
		{
		//	DWORD Ux1,Ux2;
			
		//	Ux1=(_Mul_Div_U(sqrt_32fix(UIVal.dUx1), 256, pRunSet->dKU58));
		//	Ux2=(_Mul_Div_U(sqrt_32fix(UIVal.dUx2), 256, pRunSet->dKU58));
	
		//	Set_Fault_On();					//设置故障总信号
		//	RecordEvent(code, 1, Ux1,Ux2,0 );
			//RCD_Rcd(RECORD_WAVE_TYPE_TZ,RECORD_TRIPWAVLGH);  

		//	SetOnLed(LED_BTDZ);				//亮备自投动作灯
		//	fz_dl(sw, dl_x);
		//	pro_kc_qd();
			pR->tBzt.tBZT_dlx.fz_dlx = dl_x;
		//	ResetTR(&pR->tBzt.tTb_JXFS_T);
		//	ResetTR(&pR->tBzt.tTb_FDFS_T); 
			if(dl_x == DL_1)
			{
				if(soe_check(EV_ZT_TZ1+sw*EV_SW_NUM)==false)
				{
					soe_record_ev(EV_ZT_TZ1+sw*EV_SW_NUM, 1, 0,0,0 );
				}
				if(pRunSet->tSwSet[sw].bZF)
				{
					sw_do(sw,SW_DO_FZ,SW_DO_TYPE_ON);	
					sw_do(sw,SW_DO_BHT,SW_DO_TYPE_ON);
				}
				else
				{
					sw_do(sw,SW_DO_DL1_FZ,SW_DO_TYPE_ON);
					sw_do(sw,SW_DO_FZ,SW_DO_TYPE_ON);
				}
				uBZT->bBZT.auto_tz = 1;
#ifdef BZT_PRINTF_DEBUG					
				rt_printf("\r\n #1线路跳闸");
#endif
			}
			else if(dl_x == DL_2)
			{
				if(soe_check(EV_ZT_TZ2+sw*EV_SW_NUM)==false)
				{
					soe_record_ev(EV_ZT_TZ2+sw*EV_SW_NUM, 1, 0,0,0 );
				}
				if(pRunSet->tSwSet[sw].bZF)
				{
					sw_do(sw,SW_DO_FZ,SW_DO_TYPE_ON);	
					sw_do(sw,SW_DO_BHT,SW_DO_TYPE_ON);	
				}
				else
					sw_do(sw,SW_DO_DL2_FZ,SW_DO_TYPE_ON);
				uBZT->bBZT.auto_tz = 1;
#ifdef BZT_PRINTF_DEBUG					
				rt_printf("\r\n #2线路跳闸");
#endif
			}
			else if(dl_x == DL_3)
			{
				if(soe_check(EV_ZT_TZ3+sw*EV_SW_NUM)==false)
				{
					soe_record_ev(EV_ZT_TZ3+sw*EV_SW_NUM, 1, 0,0,0 );
				}
				sw_do(sw,SW_DO_FD_FZ,SW_DO_TYPE_ON);
#ifdef BZT_PRINTF_DEBUG					
				rt_printf("\r\n #3线路跳闸");
#endif
			}
			uBZT->bBZT.bZTTZ = true;	
		}
	}
	else
	{
	
		if(uBZT->bBZT.bZTTZ)
		{
		//	uTRIP.bTRIP.bT1DL = false;
		//	uTRIP.bTRIP.bT2DL = false;
		//	uTRIP.bTRIP.bH3DL = false;
		//	RecordEvent(code, 0, 0, 0, 0); 
			uBZT->bBZT.bZTTZ = false;	
		}	
		
	}
}



/**************************************************************************
函数名称：Out_BZT_ZTHZ
函数版本：1.00 
作者：   
创建日期：2007.8.31    
函数功能说明：自投合		  
输入参数：byState false--返回   true--动作
其他输入:
输出参数：
返回值：无
***************************************************************************/
void Out_BZT_ZTHZ(int sw, bool bState,BYTE dl_x)
{
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 	

	BYTE code;
	BYTE dl_hzx;

	if((dl_x > DL_3) || (dl_x < DL_1))
			return;
	
	dl_hzx = dl_x - 1;
	code = (dl_hzx  + EV_ZT_HZ1);
	if(bState)					//备自投动作跳工作断路器
	{
		if(!uBZT->bBZT.bZTHZ)
		{
			pR->tBzt.tBZT_dlx.hz_dlx = dl_x;
		//	ResetTR(&pR->tBzt.tTb_JXFS_H); 
		//	ResetTR(&pR->tBzt.tTb_FDFS_H); 
			ResetTR(&pR->tBzt.tTb_DJXFS_H); 
			if(dl_x == DL_1)
			{
				if(soe_check(EV_ZT_HZ1+sw*EV_SW_NUM)==false)
				{
					soe_record_ev(EV_ZT_HZ1+sw*EV_SW_NUM, 1, 0,0,0 );
				}
				if(pRunSet->tSwSet[sw].bZF)
				{
					sw_do(sw,SW_DO_HZ,SW_DO_TYPE_ON);		
					sw_do(sw,SW_DO_BHH,SW_DO_TYPE_ON);	
				}
				else
				{
					sw_do(sw,SW_DO_DL1_HZ,SW_DO_TYPE_ON);
					sw_do(sw,SW_DO_HZ,SW_DO_TYPE_ON);
				}
#ifdef BZT_PRINTF_DEBUG					
				rt_printf("\r\n #1线路合闸");
#endif
			}
			else if(dl_x == DL_2)
			{
				if(soe_check(EV_ZT_HZ2+sw*EV_SW_NUM)==false)
				{
					soe_record_ev(EV_ZT_HZ2+sw*EV_SW_NUM, 1, 0,0,0 );
				}
				if(pRunSet->tSwSet[sw].bZF)
				{
					sw_do(sw,SW_DO_HZ,SW_DO_TYPE_ON);	
					sw_do(sw,SW_DO_BHH,SW_DO_TYPE_ON);	
				}
				else		
				{
					sw_do(sw,SW_DO_DL2_HZ,SW_DO_TYPE_ON);
				}
#ifdef BZT_PRINTF_DEBUG					
				rt_printf("\r\n #2线路合闸");
#endif
			}
			else if(dl_x == DL_3)
			{
				if(soe_check(EV_ZT_HZ3+sw*EV_SW_NUM)==false)
				{
					soe_record_ev(EV_ZT_HZ3+sw*EV_SW_NUM, 1, 0,0,0 );
				}
				sw_do(sw,SW_DO_FD_HZ,SW_DO_TYPE_ON);
#ifdef BZT_PRINTF_DEBUG					
				rt_printf("\r\n #3线路合闸");
#endif
			}
			uBZT->bBZT.bZTHZ = true; 
		}
	}
	else
	{
		if(uBZT->bBZT.bZTHZ)
		{
			uBZT->bBZT.bZTHZ = false;
		}			
	}
}




/**************************************************************************
函数名称：BztFGpb
函数版本：1.00 
作者：   
创建日期：2007.8.31    
函数功能说明：备自投复归判别
输入参数：备自投方式
其他输入:
输出参数：
返回值：无
***************************************************************************/


void BztFGpb(int sw, DWORD Step)
{
	bool hw_x=0,tw_x=0;
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 	
	u8 dl_x = 0;

	/**********************************************************************
	启动返回判别:BZTQDFHPB();
	***********************************************************************/
	uBZT->bBZT.bQDFH = (!pR->uBHQD.bFlag.bBZTQD)	//备自投未启动,实时刷新
	       		&&(!uBZT->bBZT.CMDZTT)				//没有跳命令
	       		&&(!uBZT->bBZT.CMDZTH)				//没有合命令	
	       		&&(!uBZT->bBZT.CMDJXHTT)
	       		&&(!uBZT->bBZT.CMDJXHTH)
	       		&&(!uBZT->bBZT.CMDDJXHTT)
	       		&&(!uBZT->bBZT.CMDDJXHTH) && !uBZT->bBZT.CMDZFHTH	   
	       		&& uBZT->bBZT.CJQD;				//备投曾经启动标志,整组复归时清除
   
	/**********************************************************************
	分段方式动作成功,失败判别:
	***********************************************************************/			
	if(uBZT->bBZT.bFD && uBZT->bBZT.FDZTQD) 
	{
		if(pR->tBzt.tBZT_dlx.fz_dlx == DL_1)
		{
			tw_x = pR->tSWST.uSWST.bFlag.b1DLHW;
		}
		else if(pR->tBzt.tBZT_dlx.fz_dlx == DL_2)
		{
			tw_x = pR->tSWST.uSWST.bFlag.b2DLHW;
		}
		BZTSBFGPB(sw, uBZT->bBZT.CMDZTT,uBZT->bBZT.CMDZTH,tw_x, 
					pR->tSWST.uSWST.bFlag.b3DLHW, pR->tBzt.tBZT_dlx.fz_dlx, Step);
		BZTCGFGPB(sw, uBZT->bBZT.CMDZTT,uBZT->bBZT.CMDZTH,tw_x, pR->tSWST.uSWST.bFlag.b3DLHW, Step);
	}
	if(uBZT->bBZT.bJX && uBZT->bBZT.JXHTQD) 
	{
		if(pR->tBzt.tBZT_dlx.fz_dlx == DL_1)
		{
			tw_x = pR->tSWST.uSWST.bFlag.b1DLHW;
		}
		else if(pR->tBzt.tBZT_dlx.fz_dlx == DL_2)
		{
			tw_x = pR->tSWST.uSWST.bFlag.b2DLHW;
		}

		if(pR->tBzt.tBZT_dlx.hz_dlx == DL_1)
		{
			hw_x = pR->tSWST.uSWST.bFlag.b1DLHW;
		}
		else if(pR->tBzt.tBZT_dlx.hz_dlx == DL_2)
		{
			hw_x = pR->tSWST.uSWST.bFlag.b2DLHW;
		}
	
		BZTSBFGPB(sw, uBZT->bBZT.CMDJXHTT,uBZT->bBZT.CMDJXHTH,
						tw_x, hw_x, pR->tBzt.tBZT_dlx.hz_dlx, Step);
		BZTCGFGPB(sw, uBZT->bBZT.CMDJXHTT,uBZT->bBZT.CMDJXHTH,tw_x, hw_x, Step);
		
	}
	if(uBZT->bBZT.bDJX && (uBZT->bBZT.JX1HTQD || uBZT->bBZT.JX2HTQD))
	{
		if(pR->tBzt.tBZT_dlx.fz_dlx == DL_1)
		{
			tw_x = pR->tSWST.uSWST.bFlag.b1DLHW;
		}
		else if(pR->tBzt.tBZT_dlx.fz_dlx == DL_2)
		{
			tw_x = pR->tSWST.uSWST.bFlag.b2DLHW;
		}
		BZTSBFGPB(sw, uBZT->bBZT.CMDZTT,uBZT->bBZT.CMDZTH,tw_x, 
					pR->tSWST.uSWST.bFlag.b3DLHW, pR->tBzt.tBZT_dlx.fz_dlx, Step);
		BZTCGFGPB(sw, uBZT->bBZT.CMDDJXHTT || uBZT->bBZT.JX_CD_BH, uBZT->bBZT.CMDDJXHTH,
					tw_x, pR->tSWST.uSWST.bFlag.b3DLHW, Step);
	}	
	if(uBZT->bBZT.bZF && uBZT->bBZT.CMDZFHTH) //自复
	{
		if((g_sw[sw].do_cfg_index[SW_DO_JX1_SY] < g_equ_config->do_num) && (g_sw[sw].do_cfg_index[SW_DO_JX2_SY] == 0xffff))
		{
			tw_x = pR->tSWST.uSWST.bFlag.b1DLHW;
			dl_x = DL_1;			//合进线1
		}
		else if((g_sw[sw].do_cfg_index[SW_DO_JX2_SY] < g_equ_config->do_num) && (g_sw[sw].do_cfg_index[SW_DO_JX1_SY] == 0xffff))
		{
			tw_x = pR->tSWST.uSWST.bFlag.b2DLHW;
			dl_x = DL_2;			//合进线2	
		}
		BZTSBFGPB(sw, 0,uBZT->bBZT.CMDZFHTH, 0, tw_x, dl_x, Step);
		BZTCGFGPB(sw, 0, uBZT->bBZT.CMDZFHTH, 0, tw_x, Step);
	}
	if(uBZT->bBZT.bZF && uBZT->bBZT.CMDZFHTT) //自复
	{
		if((g_sw[sw].do_cfg_index[SW_DO_JX1_SY] < g_equ_config->do_num) && (g_sw[sw].do_cfg_index[SW_DO_JX2_SY] == 0xffff))
		{
			tw_x = pR->tSWST.uSWST.bFlag.b1DLHW;
			dl_x = DL_1;			//合进线1
		}
		else if((g_sw[sw].do_cfg_index[SW_DO_JX2_SY] < g_equ_config->do_num) && (g_sw[sw].do_cfg_index[SW_DO_JX1_SY] == 0xffff))
		{
			tw_x = pR->tSWST.uSWST.bFlag.b2DLHW;
			dl_x = DL_2;			//合进线2	
		}
		BZTSBFGPB(sw, uBZT->bBZT.CMDZFHTT,0, tw_x, 0, dl_x, Step);
		BZTCGFGPB(sw, uBZT->bBZT.CMDZFHTT, 0, tw_x, 0, Step);
	}	
	/**********************************************************************
	备自投复归条件: 备投动作成功||备投动作失败||备投启动后返回   
	***********************************************************************/
	uBZT->bBZT.bBZTFG = uBZT->bBZT.bOK || uBZT->bBZT.bFAIL || uBZT->bBZT.bQDFH;	
	/**********************************************************************
	备自投复归条件: 备投动作成功||备投动作失败||备投启动后返回  
	***********************************************************************/
	if(uBZT->bBZT.bBZTFG)
	{
		uBZT->bBZT.FDZTQD  = false;
		uBZT->bBZT.JXHTQD  = false;
		uBZT->bBZT.JX1HTQD = false;
		uBZT->bBZT.JX2HTQD = false;		
		uBZT->bBZT.ZFHTQD  = false;
	}
}


/**************************************************************************
函数名称：BztFGpb
函数版本：1.00 
作者：   
创建日期：2007.8.31    
函数功能说明：备自投成功复归判别
输入参数：备自投方式
其他输入:
输出参数：
返回值：无
***************************************************************************/
void BZTCGFGPB(int sw, bool bCMDT, bool bCMDH,bool bGZDL,bool bBYDL, DWORD Step)
{
	
	bool boolY1,boolY2,boolY4,boolY5;
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 

	/**********************************************************************
	备自投动作成功判断:
	***********************************************************************/
	boolY1 = bCMDT; 							//跳命令
	boolY2 = bGZDL;										//被跳开关位置
	boolY4 = bCMDH; 							//合命令	
	boolY5 = bBYDL;										//被合开关位置
	
	uBZT->bBZT.bTOK = boolY1 && (!boolY2);				//跳成功
	uBZT->bBZT.bHOK = boolY4 && boolY5;					//合成功
	uBZT->bBZT.bOK  = uBZT->bBZT.bTOK && uBZT->bBZT.bHOK;	//动作成功	
	/**********************************************************************
	备自投动作成功SOE:
	***********************************************************************/
	//if(uBZT->bBZT.bOK)	
	{
	//	if(!uBZT->bBZT.bCZCG)									
		{
			//uBZT->bBZT.bCZCG = true;
			//Set_Fault_On();								//设置故障总信号
			//RecordEvent(EV_BZTOK,1,0,0,0); 		
			//RCD_Rcd(RECORD_WAVE_TYPE_TZ,RECORD_TRIPWAVLGH);  
			if(uBZT->bBZT.bTOK)
			{
#ifdef BZT_PRINTF_DEBUG				
				rt_printf("\r\n 跳闸成功");
#endif
				uBZT->bBZT.bZTTZ  = 0;
				uBZT->bBZT.CMDZTT = 0;
				uBZT->bBZT.CMDJXHTT = 0;
				uBZT->bBZT.CMDDJXHTT = 0;
				uBZT->bBZT.CMDZFHTT = false;
				uBZT->bBZT.CMDZF_STEP_H = false;
				uBZT->bBZT.CMDZF_STEP_T = false;
				if((g_sw[sw].do_cfg_index[SW_DO_JX2_SY] < g_equ_config->do_num) && (g_sw[sw].do_cfg_index[SW_DO_JX1_SY] == 0xffff))
				{
#ifdef BZT_PRINTF_DEBUG					
					rt_printf("\r\n 发送失压信号");
#endif
					sw_do(sw,SW_DO_JX2_SY,SW_DO_TYPE_ON);
				}	
				if(soe_check(EV_ZT_TZ1+sw*EV_SW_NUM)==true)
				{
					soe_record_ev(EV_ZT_TZ1+sw*EV_SW_NUM, 0, 0,0,0 );
				}
				if(soe_check(EV_ZT_TZ2+sw*EV_SW_NUM)==true)
				{
					soe_record_ev(EV_ZT_TZ2+sw*EV_SW_NUM, 0, 0,0,0 );
				}
				if(soe_check(EV_ZT_TZ3+sw*EV_SW_NUM)==true)
				{
					soe_record_ev(EV_ZT_TZ3+sw*EV_SW_NUM, 0, 0,0,0 );
				}
			}
			if(uBZT->bBZT.bHOK)
			{
#ifdef BZT_PRINTF_DEBUG				
				rt_printf("\r\n 合闸成功");
#endif
				uBZT->bBZT.bZTHZ   = false;
				uBZT->bBZT.CMDZTH  = false;
				uBZT->bBZT.JXHTQD  = false;
				uBZT->bBZT.JX1HTQD = false;
				uBZT->bBZT.JX2HTQD = false; 
				uBZT->bBZT.CMDJXHTH  = false;
				uBZT->bBZT.CMDDJXHTH = false;
				uBZT->bBZT.JX_CD_BH  = false;
				uBZT->bBZT.ZFHTQD  = false;
				uBZT->bBZT.CMDZFHTH = false;
				if(soe_check(EV_ZT_HZ1+sw*EV_SW_NUM)==true)
				{
					soe_record_ev(EV_ZT_HZ1+sw*EV_SW_NUM, 0, 0,0,0 );
				}
				if(soe_check(EV_ZT_HZ2+sw*EV_SW_NUM)==true)
				{
					soe_record_ev(EV_ZT_HZ2+sw*EV_SW_NUM, 0, 0,0,0 );
				}
				if(soe_check(EV_ZT_HZ3+sw*EV_SW_NUM)==true)
				{
					soe_record_ev(EV_ZT_HZ3+sw*EV_SW_NUM, 0, 0,0,0 );
				}
			}
		}
	}
}


/**************************************************************************
函数名称：BztFGpb
函数版本：1.00 
作者：   
创建日期：2007.8.31    
函数功能说明：备自投工作电源跳，备用电源合失败复归判别
输入参数：备自投方式
其他输入:
输出参数：
返回值：无
***************************************************************************/
void BZTSBFGPB(int sw, bool bCMDT, bool bCMDH,bool bGZDL,bool bBYDL,
					bool dlx, DWORD Step)
{
	bool boolY1,boolY2,boolY4,boolY5;
	bool boolY6,boolY8;
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 

	#if 1
	/**********************************************************************
	
	***********************************************************************/
	boolY1 = bCMDT; 				//跳命令
	boolY2 = bGZDL;					//被跳开关位置
	boolY4 = bCMDH; 				//合命令	
	boolY5 = bBYDL;					//被合开关位置
	
	/**********************************************************************
	正常跳失败:跳命令后1S,被跳开关仍然在合位.
	***********************************************************************/
	boolY6 = boolY1 && boolY2;
	RunTR(&pR->tBzt.tTbttsb, boolY6, Step);			
	/**********************************************************************
	
	***********************************************************************/
	if(pR->tBzt.tTbttsb.boolTrip)	
	{
		if(!uBZT->bBZT.bTFAIL)
		{
			//RecordEvent(EV_BZTTFAIL,1,0,0,0); 
			//RCD_Rcd(RECORD_WAVE_TYPE_TZ,RECORD_TRIPWAVLGH);  
			//Set_Fault_On();   
			uBZT->bBZT.bZTTZ   = false;
			uBZT->bBZT.CMDZTT  = false;
			uBZT->bBZT.JXHTQD  = false;
			uBZT->bBZT.JX1HTQD = false;
			uBZT->bBZT.JX2HTQD = false; 			
			uBZT->bBZT.CMDJXHTT = false;
			uBZT->bBZT.CMDDJXHTT = false;
			uBZT->bBZT.ZFHTQD  = false;
			uBZT->bBZT.CMDZFHTT = false;
			uBZT->bBZT.CMDZF_STEP_T = false;
#ifdef BZT_PRINTF_DEBUG				
			rt_printf("\r\n 跳闸失败");
#endif
			if(soe_check(EV_BZT_TZ1_FAIL+sw*EV_SW_NUM)==false && dlx == DL_1)
			{
				soe_record_ev(EV_BZT_TZ1_FAIL+sw*EV_SW_NUM, 1, 0,0,0 );
			}
			else if(soe_check(EV_BZT_TZ2_FAIL+sw*EV_SW_NUM)==false && dlx == DL_2)
			{
				soe_record_ev(EV_BZT_TZ2_FAIL+sw*EV_SW_NUM, 1, 0,0,0 );
			}
		}
		uBZT->bBZT.bTFAIL = true;
	}
	
	/**********************************************************************
	备投合失败:合命令后1S,被合开关仍然在分位.---直接报备投失败:
	***********************************************************************/
	boolY8 = boolY4 && !boolY5;
	RunTR(&pR->tBzt.tTbthsb, boolY8, Step);
	if(pR->tBzt.tTbthsb.boolTrip)	
	{
		if(!uBZT->bBZT.bHFAIL)
		{
		//	RecordEvent(EV_BZTHFAIL,1,0,0,0); 
		//	RCD_Rcd(RECORD_WAVE_TYPE_TZ,RECORD_TRIPWAVLGH);  
		//	Set_Fault_On();    
			uBZT->bBZT.bZTHZ    = false;
			uBZT->bBZT.CMDZTH   = false;
			uBZT->bBZT.JXHTQD   = false;
			uBZT->bBZT.JX1HTQD  = false;
			uBZT->bBZT.JX2HTQD  = false; 			
			uBZT->bBZT.CMDJXHTH = false;
			uBZT->bBZT.CMDDJXHTH = false;
			uBZT->bBZT.ZFHTQD  = false;
			uBZT->bBZT.CMDZFHTH = false;
			uBZT->bBZT.CMDZF_STEP_H = false;
#ifdef BZT_PRINTF_DEBUG				
			rt_printf("\r\n 合闸失败");
#endif
			if(soe_check(EV_BZT_HZ1_FAIL+sw*EV_SW_NUM)==false && dlx == DL_1)
			{
				soe_record_ev(EV_BZT_HZ1_FAIL+sw*EV_SW_NUM, 1, 0,0,0 );
			}
			else if(soe_check(EV_BZT_HZ2_FAIL+sw*EV_SW_NUM)==false && dlx == DL_2)
			{
				soe_record_ev(EV_BZT_HZ2_FAIL+sw*EV_SW_NUM, 1, 0,0,0 );
			}
			else 
			{
				soe_record_ev(EV_BZT_HZ3_FAIL+sw*EV_SW_NUM, 1, 0,0,0 );
			}

		}
		uBZT->bBZT.bHFAIL= true;
	}

	/**********************************************************************
	备自投动作失败:有一种情况，有跳闸命令后，跳闸成功后，一直没有符合合闸的命令，
	则等待超时间后
	***********************************************************************/
	
	/**********************************************************************
	备自投动作失败:
	***********************************************************************/
	uBZT->bBZT.bFAIL = uBZT->bBZT.bHFAIL || uBZT->bBZT.bTFAIL;
	if(uBZT->bBZT.bFAIL)	
	{
	//	SetErrFlag(GER_BZTFAIL,EFT_GENERR);		//???
	}
#endif
	
}

/**************************************************************************
函数名称：BztQdLogic
函数版本：1.00 
作者：   
创建日期：2007.8.31    
函数功能说明：备自投启动逻辑			  
输入参数：备自投方式
其他输入:
输出参数：
返回值：无
***************************************************************************/
void BztQdLogic(int sw, DWORD Step)
{
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 

	/**********************************************************************
	分段方式启动逻辑:
	***********************************************************************/
	if(uBZT->bBZT.bFD)
	{
		BztFdZtQdLogic(sw, Step);
	}	
	else if(uBZT->bBZT.bJX)
	{
		BztJxHtQdLogic(sw, Step);
	}
	else if(uBZT->bBZT.bDJX)
		BztDJxHtQdLogic(sw, Step);
	else if(uBZT->bBZT.bZF)
		BztZFQdLogic(sw, Step);
	/**********************************************************************
	备自投引起总启动:
	***********************************************************************/
	pR->uBHQD.bFlag.bBZTQD = uBZT->bBZT.FDZTQD || uBZT->bBZT.JXHTQD 
								|| uBZT->bBZT.JX1HTQD || uBZT->bBZT.JX2HTQD || uBZT->bBZT.ZFHTQD;
	if(pR->uBHQD.bFlag.bBZTQD)
	{
		uBZT->bBZT.CJQD = true;				//备自投曾经启动标志
	}
}

/**************************************************************************
函数名称：BztFdZtQdLogic
函数版本：1.00 
作者：   xj
创建日期：   
函数功能说明：备自投分段自投启动逻辑			  
输入参数：
其他输入:
输出参数：
返回值：无
***************************************************************************/
void BztFdZtQdLogic(int sw, DWORD Step)
{
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 
	bool boolY1;

	/**********************************************************************
	分段自投启动:自投充电标志 &&（  I母无压及II母有压）||（  II母无压及I母有压）
	***********************************************************************/
	boolY1 = pR->tBzt.uBZTUI.bBZT.bFDZTCD 
			&& ((pR->tBzt.uBZTUI.bBZT.b1MWY && pR->tBzt.uBZTUI.bBZT.b2MYY)
				||(pR->tBzt.uBZTUI.bBZT.b2MWY && pR->tBzt.uBZTUI.bBZT.b1MYY));

	uBZT->bBZT.FDZTQD = boolY1;
}


/**************************************************************************
函数名称：BztJXHTQdLogic
函数版本：1.00 
作者：   xj
创建日期：  
函数功能说明：进线互投启动逻辑			  
输入参数：
其他输入:
输出参数：
返回值：无
***************************************************************************/
void BztJxHtQdLogic(int sw, DWORD Step)
{
	//TSETSW *pSet = &pRunSet->tSwSet[sw];
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 
	bool boolY1;

	/**********************************************************************
	进线互投启动:自投充电标志 &&(（ I母无压 && DL1无压  && DL1无流）||（II母无压 && DL2无压 && DL2无流）)
	***********************************************************************/
	#if 1
	boolY1 = pR->tBzt.uBZTUI.bBZT.bJXHTCD 
				&& ((pR->tBzt.uBZTUI.bBZT.b1MWY && pR->tBzt.uBZTUI.bBZT.Ux1WY && pR->tBzt.uBZTUI.bBZT.Ix1WL)
				||( pR->tBzt.uBZTUI.bBZT.b2MWY && pR->tBzt.uBZTUI.bBZT.Ux2WY && pR->tBzt.uBZTUI.bBZT.Ix2WL));
	#else
	boolY1 = pR->tBzt.uBZTUI.bBZT.bJXHTCD 
				&& ((pR->tBzt.uBZTUI.bBZT.b1MWY && pR->tBzt.uBZTUI.bBZT.Ux1WY)
				||( pR->tBzt.uBZTUI.bBZT.b2MWY && pR->tBzt.uBZTUI.bBZT.Ux2WY));
	#endif
	uBZT->bBZT.JXHTQD = boolY1 || uBZT->bBZT.JXHTQD;
}

void BztDJxHtQdLogic(int sw, DWORD Step)
{
	//TSETSW *pSet = &pRunSet->tSwSet[sw];
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 
	bool boolY1,boolY2;

	boolY1 = pR->tBzt.uBZTUI.bBZT.bJX1ZTCD 
				&& (pR->tBzt.uBZTUI.bBZT.b1MWY && pR->tBzt.uBZTUI.bBZT.Ux1WY && pR->tBzt.uBZTUI.bBZT.Ix1WL);
	boolY2 = pR->tBzt.uBZTUI.bBZT.bJX2ZTCD 
				&& ( pR->tBzt.uBZTUI.bBZT.b2MWY && pR->tBzt.uBZTUI.bBZT.Ux2WY && pR->tBzt.uBZTUI.bBZT.Ix2WL);
	if(boolY1)
		uBZT->bBZT.JX1HTQD = 1;
	else if(boolY2)
		uBZT->bBZT.JX2HTQD = 1;	
}

void BztZFQdLogic(int sw, DWORD Step)
{
	//TSETSW *pSet = &pRunSet->tSwSet[sw];
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 
	bool boolY1;
	static u32 count;

	count++;
	if(count > 300)
		count = 0;

	boolY1 = pR->tBzt.uBZTUI.bBZT.bZFCD 
				&& pR->tSWST.uSWST.bFlag.bBZTSY;
	if(boolY1)
		uBZT->bBZT.ZFHTQD = 1;	
/*
	if(count == 0)
	{
		rt_printf("boolY1=%d\r\n", boolY1);
		rt_printf("pR->tBzt.uBZTUI.bBZT.bZFCD=%d\r\n", pR->tBzt.uBZTUI.bBZT.bZFCD);
		rt_printf("pR->tSWST.uSWST.bFlag.bBZTSY=%d\r\n", pR->tSWST.uSWST.bFlag.bBZTSY); 
	}
*/
}


/**************************************************************************
函数名称：Bsbtpb
函数版本：1.00 
作者：   
创建日期：2007.8.31    
函数功能说明：闭锁备自投逻辑判断
输入参数：备自投方式
其他输入:
输出参数：
返回值：无
***************************************************************************/
void Bsbtpb(int sw, DWORD Step)
{
	TRELAY_T *pR = &g_tRelay[sw];
	
	#if 1
	/**********************************************************************
	闭锁备自投开入闭锁:  延时80ms
	***********************************************************************/
/*	uZTSB.bZTSB.bBSBZT = SigKrRelayResult(KR_BSBZT);
	
	RunTR(&tTkrbsbt, uZTSB.bZTSB.bBSBZT, Step);   
	pR->tBzt.uBZTUI.bBZT.KRBS = tTkrbsbt.boolTrip; 
	*/
	/**********************************************************************
	备自投动作闭锁: 
	***********************************************************************/	
	//pR->tBzt.uBZTUI.bBZT.DZBS = uBZT->bBZT.bBZTFG && (!uBZT->bBZT.bQDFH);
	
	/**********************************************************************
	备自投闭锁: 
	***********************************************************************/
	//boolH1 = pR->tBzt.uBZTUI.bBZT.DZBS || pR->tSWST.uSWST.bFlag.bBZTBS;
	//RunTR(&tTbsbt,boolH1,Step);
	//pR->tBzt.uBZTUI.bBZT.ZBS = tTbsbt.boolTrip;
	pR->tBzt.uBZTUI.bBZT.ZBS = pR->tSWST.uSWST.bFlag.bBZTBS;
	if(pR->tBzt.uBZTUI.bBZT.ZBS)
	{
		led_set_sw(sw, SW_LED_LOCK, LED_ON);
	}
	else
	{
		led_set_sw(sw, SW_LED_LOCK, LED_OFF);
	}

	#endif
}


void BztCdLogic(int sw, DWORD Step) 
{
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 

	if(uBZT->bBZT.bFD)
	{
		BztFdZtCdLogic(sw, Step);
	}
	else if(uBZT->bBZT.bJX)
	{
		BztJxHtCdLogic(sw, Step);
	}
	else if(uBZT->bBZT.bDJX)
		BztDJxHtCdLogic(sw, Step);
	else if(uBZT->bBZT.bZF)
		BztZFCdLogic(sw, Step);
	if(pR->tBzt.uBZTUI.bBZT.bFDZTCD
			||pR->tBzt.uBZTUI.bBZT.bJX1ZTCD||pR->tBzt.uBZTUI.bBZT.bJX2ZTCD
			||pR->tBzt.uBZTUI.bBZT.bJXHTCD||pR->tBzt.uBZTUI.bBZT.bZFCD)
	{
		Out_BZTCFD(sw, true);
	}
	else
	{
		Out_BZTCFD(sw, false);
	}
}



/**************************************************************************
函数名称：BztFdZtCdLogic
函数版本：1.00 
作者：   
创建日期：2007.8.31    
函数功能说明：备自投分段方式自投充放电逻辑			  
输入参数：
其他输入:
输出参数：
返回值：无
***************************************************************************/
void BztFdZtCdLogic(int sw, DWORD Step)
{
	bool boolH1=0,boolH2=0,boolH3=0,boolH4=0,boolH5=0;
	bool boolY1,boolY2,boolY4;	
	bool bFsyx;
	//TSETSW *pSet = &pRunSet->tSwSet[sw];
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 	
	//u8 i;
	
	bFsyx = (!pR->tBzt.uBZTUI.bBZT.ZBS)					//未闭锁备自投
			&& uBZT->bBZT.bFD;						//分段方式

	// I母及II母，均有压:
	boolY1 = pR->tBzt.uBZTUI.bBZT.b1MYY && pR->tBzt.uBZTUI.bBZT.b2MYY; 

	//开关位置--DL1合位,DL2合位,DL3跳位:
	boolY2 = pR->tSWST.uSWST.bFlag.b1DLHW && pR->tSWST.uSWST.bFlag.b2DLHW 
					&& (!pR->tSWST.uSWST.bFlag.b3DLHW);

	if(soe_check(EV_BH_FAULT+sw*EV_SW_NUM)==true)
		boolY2 = 0;
	/**********************************************************************
	 分段方式自投充电延时:
	***********************************************************************/
	boolY4= bFsyx && boolY1 && boolY2;					//备自投充电启动
	RunTR(&pR->tBzt.tTFdZtCd,boolY4,Step);
	if(pR->tBzt.tTFdZtCd.boolTrip)
	{
		pR->tBzt.uBZTUI.bBZT.bFDZTCD = true;
	}	
	/**********************************************************************
	 分段方式自投放电:
	***********************************************************************/
	boolH1 = pR->tSWST.uSWST.bFlag.b3DLHW;// DL3 在合位
	boolH2 = pR->tBzt.uBZTUI.bBZT.b1MWY && pR->tBzt.uBZTUI.bBZT.b2MWY;	//#1、#2 进线均无压
	#if 0
	boolH3 = uZTSB.bZTSB.bSDHZ || uZTSB.bZTSB.bSDFZ;	//手动合闸信号,手动分闸信号
	boolH4 = ((UIVal.dIMax >= pRunSet->dOCUR1_SQR) && (pRunSet->bOC1))
				||((UIVal.dIMax >= pRunSet->dOCUR2_SQR) && (pRunSet->bOC2))
				||((UIVal.dIMax >= pRunSet->dOCUR3_SQR) && (pRunSet->bOC3));
	boolH5 = uBHDZ.bFlag.bBHTrip;
	#endif
	boolH4 = 0;
    #if 0
	for(i=OC_GL1;i<(OC_GL3+1);i++) // 过流类定值
	{
		if(i==OC_GL1||i==OC_GL2||i==OC_GL3)
		{
			if(pSet->tOcSet[i].bTT_Gj || pSet->tOcSet[i].bTT_Tz)
			{
				//直接用>号比较，不行？？？
				boolH4 = OverRelay(g_sw[sw].m2_max, pSet->tOcSet[i].dIgl, pSet->tOcSet[i].dIgl, false); 
			}
		}
	}
    #endif
	if(boolH1||boolH2||boolH3||boolH4||boolH5||(!bFsyx)||soe_check(EV_BH_FAULT+sw*EV_SW_NUM))
	{
		pR->tBzt.uBZTUI.bBZT.bFDZTCD = false;	//瞬时放电
	}
	
	//RunTR(&pR->tBzt.tTb_FD_delay_fd, !pR->tSWST.uSWST.bFlag.b3DLHW && (!pR->tSWST.uSWST.bFlag.b1DLHW || !pR->tSWST.uSWST.bFlag.b2DLHW),Step);
}


/**************************************************************************
函数名称：BztJxHtCdLogic
函数版本：1.00 
作者：   
创建日期： 
函数功能说明：进线互投方式自投充放电逻辑			  
输入参数：
其他输入:
输出参数：
返回值：无
***************************************************************************/
void BztJxHtCdLogic(int sw, DWORD Step)
{
	bool boolH1=0,boolH2=0,boolH3=0,boolH4=0;
	bool boolY1,boolY2,boolY3,boolY4,boolY5,boolY6;	
	bool bFsyx;
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 	

	bFsyx = (!pR->tBzt.uBZTUI.bBZT.ZBS)			//未闭锁备自投
				&& uBZT->bBZT.bJX;					//进线方式1

	/**********************************************************************
	 I母及进线DL1均有压:
	***********************************************************************/
	boolY1 = pR->tBzt.uBZTUI.bBZT.b1MYY && pR->tBzt.uBZTUI.bBZT.Ux1YY;
	/**********************************************************************
	 II母及进线DL2均有压:
	***********************************************************************/
	boolY2 = pR->tBzt.uBZTUI.bBZT.b2MYY && pR->tBzt.uBZTUI.bBZT.Ux2YY;

	//boolY2 = pR->tBzt.uBZTUI.bBZT.b2MYY;
	//DL1跳位,DL2合位
	boolY3 = (!pR->tSWST.uSWST.bFlag.b1DLHW) && pR->tSWST.uSWST.bFlag.b2DLHW;
	//DL2跳位,DL1合位
	boolY4 = (!pR->tSWST.uSWST.bFlag.b2DLHW) && pR->tSWST.uSWST.bFlag.b1DLHW;
	//分段开关在合位
	boolY5 = (boolY3||boolY4) && pR->tSWST.uSWST.bFlag.b3DLHW;

	/**********************************************************************
	进线互投方式充电延时:
	***********************************************************************/
	boolY6 = bFsyx && boolY1 && boolY2 && boolY5;					//备自投充电启动
	RunTR(&pR->tBzt.tTJxZtCd,boolY6,Step);
	if(pR->tBzt.tTJxZtCd.boolTrip)
	{
		pR->tBzt.uBZTUI.bBZT.bJXHTCD = true;	
	}	

	/**********************************************************************
	 进线互投方式放电:
	***********************************************************************/
	boolH1 = (boolY3 && pR->tBzt.uBZTUI.bBZT.Ux1WY) || (boolY4 && pR->tBzt.uBZTUI.bBZT.Ux2WY); 	//备用进线无压
#if 0	
	boolH2 = uZTSB.bZTSB.bSDHZ || uZTSB.bZTSB.bSDFZ;
#endif
	boolH3 = ((pR->tSWST.uSWST.bFlag.b1DLHW && pR->tSWST.uSWST.bFlag.b2DLHW)
				||((!pR->tSWST.uSWST.bFlag.b1DLHW)&&(!pR->tSWST.uSWST.bFlag.b2DLHW))) && ((pR->tSWST.uSWST.bFlag.b3DLHW && uBZT->bBZT.bFD)||(!uBZT->bBZT.bFD)); 	
#if 0
	boolH4 = ((UIVal.dIMax >= pRunSet->dOCUR1_SQR) && (pRunSet->bOC1))
				||((UIVal.dIMax >= pRunSet->dOCUR2_SQR) && (pRunSet->bOC2))
				||((UIVal.dIMax >= pRunSet->dOCUR3_SQR) && (pRunSet->bOC3));
#endif	

	if(boolH1||boolH2||boolH3||boolH4||(!bFsyx)||soe_check(EV_BH_FAULT+sw*EV_SW_NUM))			//瞬时放电 
	{
		pR->tBzt.uBZTUI.bBZT.bJXHTCD = false;
	}
	
	//RunTR(&pR->tBzt.tTb_JX_delay_fd, pR->tSWST.uSWST.bFlag.b3DLHW && (pR->tSWST.uSWST.bFlag.b1DLHW == pR->tSWST.uSWST.bFlag.b2DLHW), Step);
}

/**************************************************************************
函数名称：BztDJxHtCdLogic
函数版本：1.00 
作者：   
创建日期： 
函数功能说明：单进线互投方式自投充放电逻辑			  
输入参数：
其他输入:
输出参数：
返回值：无
***************************************************************************/
void BztDJxHtCdLogic(int sw, DWORD Step)
{
	bool boolH1=0,boolH2=0,boolH3=0,boolH4=0;
	bool boolY1,boolY2,boolY3,boolY4,boolY5,boolY6,boolY7;	
	bool bFsyx;
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 	

	bFsyx = (!pR->tBzt.uBZTUI.bBZT.ZBS)			//未闭锁备自投
				&& uBZT->bBZT.bDJX;					//进线方式1

	/**********************************************************************
	 I母、II母及进线DL1均有压:
	***********************************************************************/
	boolY1 = pR->tBzt.uBZTUI.bBZT.b1MYY && pR->tBzt.uBZTUI.bBZT.b2MYY && pR->tBzt.uBZTUI.bBZT.Ux1YY;
	/**********************************************************************
	 I母、II母及进线DL2均有压:
	***********************************************************************/
	boolY2 = pR->tBzt.uBZTUI.bBZT.b1MYY && pR->tBzt.uBZTUI.bBZT.b2MYY && pR->tBzt.uBZTUI.bBZT.Ux2YY;
	//DL1合位
	boolY3 = pR->tSWST.uSWST.bFlag.b1DLHW;
	//DL2合位
	boolY4 = pR->tSWST.uSWST.bFlag.b2DLHW;
	//分段开关在分位
	boolY5 = !pR->tSWST.uSWST.bFlag.b3DLHW;
	/**********************************************************************
	进线互投方式充电延时:
	***********************************************************************/
	boolY6 = bFsyx && boolY1 && boolY3 && !boolY4 && boolY5;					//备自投充电启动
	boolY7 = bFsyx && boolY2 && boolY4 && !boolY3 && boolY5;
	RunTR(&pR->tBzt.tTJx1ZtCd,boolY6,Step);
	RunTR(&pR->tBzt.tTJx2ZtCd,boolY7,Step);
	if(pR->tBzt.tTJx1ZtCd.boolTrip)
	{
		pR->tBzt.uBZTUI.bBZT.bJX1ZTCD = 1;	
	}	
	if(pR->tBzt.tTJx2ZtCd.boolTrip)
	{
		pR->tBzt.uBZTUI.bBZT.bJX2ZTCD = 1;
	}
	/**********************************************************************
	 进线互投方式放电:
	***********************************************************************/
	boolH1 = pR->tSWST.uSWST.bFlag.b3DLHW;
	boolH2 = !pR->tSWST.uSWST.bFlag.b1DLHW && !pR->tSWST.uSWST.bFlag.b2DLHW;
//	boolH3 = pR->tBzt.uBZTUI.bBZT.b1MWY && pR->tBzt.uBZTUI.bBZT.b2MWY;	//母线1、2线均无压
#if 0
	boolH4 = ((UIVal.dIMax >= pRunSet->dOCUR1_SQR) && (pRunSet->bOC1))
					||((UIVal.dIMax >= pRunSet->dOCUR2_SQR) && (pRunSet->bOC2))
					||((UIVal.dIMax >= pRunSet->dOCUR3_SQR) && (pRunSet->bOC3));
#endif
	uBZT->bBZT.JX_CD_BH = uBZT->bBZT.JX_CD_BH; //|| uTRIP_cd.bFlag.bBHDZ;
	if(boolH1||boolH2||boolH3||boolH4||(!bFsyx)||soe_check(EV_BH_FAULT+sw*EV_SW_NUM))		//瞬时放电 
	{
		if(uBZT->bBZT.JX_CD_BH == 0)
		{
			pR->tBzt.uBZTUI.bBZT.bJX1ZTCD = false;
			pR->tBzt.uBZTUI.bBZT.bJX2ZTCD = false;
		}
	}
}


/**************************************************************************
函数名称：BztZFCdLogic
函数版本：1.00 
作者：   
创建日期： 
函数功能说明：自复充放电逻辑			  
输入参数：
其他输入:
输出参数：
返回值：无
***************************************************************************/
void BztZFCdLogic(int sw, DWORD Step)
{
	bool boolH1=0,boolH2=0,boolH3=0,boolH4=0;
	bool boolY1=0,boolY2=0,boolY3=0;	
	bool bFsyx;
	TRELAY_T *pR = &g_tRelay[sw];
	UBZT *uBZT   = &pR->tBzt.uBZT; 		

	bFsyx = (!pR->tBzt.uBZTUI.bBZT.ZBS)			//未闭锁备自投
				&& uBZT->bBZT.bZF;				//进线方式1

	if((g_sw[sw].do_cfg_index[SW_DO_JX1_SY] < g_equ_config->do_num) && (g_sw[sw].do_cfg_index[SW_DO_JX2_SY] == 0xffff))
	{
		/**********************************************************************
		 I母、II母及进线DL1均有压:
		***********************************************************************/
		//boolY1 = pR->tBzt.uBZTUI.bBZT.b1MYY && pR->tBzt.uBZTUI.bBZT.b2MYY && pR->tBzt.uBZTUI.bBZT.Ux1YY;
		boolY1 = pR->tBzt.uBZTUI.bBZT.b1MYY && pR->tBzt.uBZTUI.bBZT.Ux1YY;
	}
	else if((g_sw[sw].do_cfg_index[SW_DO_JX2_SY] < g_equ_config->do_num) && (g_sw[sw].do_cfg_index[SW_DO_JX1_SY] == 0xffff))
	{
		/**********************************************************************
		 I母、II母及进线DL2均有压:
		***********************************************************************/
		//boolY1 = pR->tBzt.uBZTUI.bBZT.b1MYY && pR->tBzt.uBZTUI.bBZT.b2MYY && pR->tBzt.uBZTUI.bBZT.Ux2YY;	
		boolY1 = pR->tBzt.uBZTUI.bBZT.b2MYY && pR->tBzt.uBZTUI.bBZT.Ux2YY;	
	}
	boolY2 = pR->tSWST.uSWST.bFlag.b1DLHW && !pR->tSWST.uSWST.bFlag.b2DLHW;	
	/**********************************************************************
	自复充电延时:
	***********************************************************************/
	boolY3 = bFsyx && boolY1 && boolY2;					//备自投充电启动
	RunTR(&pR->tBzt.tTZfZCd, boolY3, Step);
	if(pR->tBzt.tTZfZCd.boolTrip)
	{
		pR->tBzt.uBZTUI.bBZT.bZFCD = 1;
	}
	/**********************************************************************
	 自复放电:
	***********************************************************************/
#if 0	
	if((g_sw[sw].do_cfg_index[SW_DO_JX1_SY] < g_equ_config->do_num) && (g_sw[sw].do_cfg_index[SW_DO_JX2_SY] == 0xffff))
	{
		boolH2 = !pR->tSWST.uSWST.bFlag.b1DLHW;
	}
	else if((g_sw[sw].do_cfg_index[SW_DO_JX2_SY] < g_equ_config->do_num) && (g_sw[sw].do_cfg_index[SW_DO_JX1_SY] == 0xffff))
	{
		boolH2 = pR->tSWST.uSWST.bFlag.b2DLHW;
	}
	boolH4 = ((UIVal.dIMax >= pRunSet->dOCUR1_SQR) && (pRunSet->bOC1))
					||((UIVal.dIMax >= pRunSet->dOCUR2_SQR) && (pRunSet->bOC2))
					||((UIVal.dIMax >= pRunSet->dOCUR3_SQR) && (pRunSet->bOC3));
#endif
	//uBZT->bBZT.JX_CD_BH = uBZT->bBZT.JX_CD_BH; //|| uTRIP_cd.bFlag.bBHDZ;
	if(boolH1||boolH2||boolH3||boolH4||(!bFsyx)||soe_check(EV_BH_FAULT+sw*EV_SW_NUM))		//瞬时放电 
	{
		pR->tBzt.uBZTUI.bBZT.bZFCD = 0;
	}
}


/**************************************************************************
函数名称：Out_BZTCFD
函数版本：1.00 
作者：   
创建日期：2007.8.31    
函数功能说明：备自投方式1及方式2充放电逻辑			  
输入参数：步长
其他输入:
输出参数：
返回值：无
***************************************************************************/
void Out_BZTCFD(int sw, bool bState)
{
	if(bState)
	{
		led_set_sw(sw, SW_LED_CD, LED_ON);
	}
	else
	{
		led_set_sw(sw, SW_LED_CD, LED_OFF);
	}
}  

void bzt_process(int sw, DWORD Step)
{
	//if(g_tRelay[sw].run_stu.bhtt && pRunSet->tSwSet[sw].bBZT_TT && FUN_ALL_EN(sw))
	if(pRunSet->tSwSet[sw].bBZT_TT)
	{
		Bzt_Dataset(sw, Step);
		Bzt_RunStatus(sw, Step);
		vol_lost_tz(sw,Step); //备自投失压	
		BztQdLogic(sw, Step); //备自投启动逻辑判别
		BztProcess(sw, Step); //备自投动作逻辑
		Bsbtpb(sw, Step); 	//闭锁备自投逻辑判断
		BztCdLogic(sw, Step); //备自投充放电		
		BztFGpb(sw, Step);	//备自投复归判别
		Bzt_ModeSwitch(sw); //切换模式放在最后处理	
	}    
}
#endif


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