linwei/protect_source
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
protect_source/标准版4.0/lib_atbh.c

3279 lines
97 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#include "..\h\predefine.h"
#ifdef _atbh_c_
/*SYS relational*/
#include <math.h>
#include "stdio.h"
#include "stdLib.h"
#include "..\h\lib.h"
#include "..\h\variable.h"
#include ".\inc\atbh.h"
#include "..\h\predefine.h"
#include "..\h\com_lib.h"
#include ".\inc\parameter_atbh.h"
#include ".\inc\analog_atbh.h"
#include ".\inc\inout_atbh.h"
extern void Reset_Init(void);
void timer_interrupt(void);
void TimerManage(void);
void Check_QDZT (void); //启动AT自投
void Send_QDZT(); //向对侧发启动自投信号
void ATBH_FLDProtect(void); //非电量保护
void JiSuanUI(void); //计算电流电压
void ComputeTemperature(); //计算温度
void FaultProcess(void); //故障处理
void JiSuanMeasureValue(void); //计算测量值
void ChaDongProtect(void); //差动保护
void CheckDLQHW(void); //检测断路器位置
extern void CWWDProtectUnit(NoDirectProtectItemType *CWWDYJ); //温度告警
void SaveFaultData(void);
void SaveFaultTime(void);
void ATBH_FLDAlarm(void);
void Check_PTDX(NoDirectProtectItemType *pPrtcUnit,char tvtype);
void ChongHeZha(void);
void CheckChongDianTime(void);
void StartTiaoZha_atbh(void);
extern void StatusLightKCHandle(unsigned int KCNo,unsigned char status);
extern int CheckAnLedRecord(AnLEDCtrlType * pObject,unsigned int timeDelay);
extern int SwitchContrl(unsigned char ObjectNo, unsigned char Property,unsigned int *timer,unsigned char type);
void ATZTDongZuo(void);
extern void gse_handle(void);
extern void SendGetTimeCommand();
extern void CopyYaoXinBianWei();
extern void digit_mainTask();
void SaveWave_Id();
void atbh_check_u();
void record_reclose_soe(void);
void atbh_check_position_change(); //检测位置变化
extern void printf_record(int tag1, int tag2,int tag3,int tag4,int tag5);
int fristFaultIndex = 0;
static int ZB_fristFaultIndex = 0;
static int ZB_SYZT_able = ON;
//float xb2,xb3,xb5= 0;
/********************************************************
* void timer_interrupt(void)
* 描述：保护中断服务程序，中断时间间隔为：20ms/24=5ms/6
* 历史: 创建日期不详
*
******************************************************/
void timer_interrupt(void)
{
unsigned int BaoHuQiDongIP_OLD;
static volatile int intFlag = 0;
int isprtcopen;
if(0 != intFlag)
{
printf("ms int is not return\n");
return;
}
intFlag = 1;
ClockTick(&SysTime);
ModiClock(); //时钟管理
#ifdef CCES_ADI
execute_as_subscriber();
#endif
isprtcopen = check_prtc_open();
if(Init_IP==TEST_START) //屏蔽采样中断服务程序
{
digit_Polling();
//SaveWave_Id();
#if 0
//20140701 luoyang add for test
if(IP != InPort.Status[ATBH_WD2_KR])
{
IP = InPort.Status[ATBH_WD2_KR];
//将受到的状态发送出去
RecordSoftYaoXin(ATBH_YAOXIN_WD2,IP);
D_OUT(ATBH_QF_TZ_KC,IP);
}
#endif
//changeFourierVarType();//
JiSuanUI(); //计算电流电压
CheckAnalogZcp(&ZcpSet);
//#ifdef DEVICE_TYPE_CONVENTIONAL
//ComputeTemperature(); //计算温度
//#endif
//TimerManage(); //定时器管理
//SaveWave(); //保存4周波实时波形数据
SaveLoadWave(); //负荷录波
//SaveFaultWave(); //故障录波
CheckChuanDongTest(); //传动试验
CheckChongDianTime(); //重合闸充电
//OUTManage(); //开出管理
Check_QDZT(); //启动AT自投
ATZTDongZuo();
ItemClsDwnProcess();//
if(LS_TR == ATBH_LS)
{
block_CheckYaoXin();
}
BaoHuQiDongIP_OLD=BaoHuQiDongIP;
FaultSoeStartCode = get_protect_soe_write_ip();
atbh_check_position_change(); //检测位置变化
//用户定值正确
if(isprtcopen)
{
/*
StartTiaoZha();
FaultProcess();
SetFaultStart();
CheckFaultEnd();
*/
CheckRmote();
//SoeRcordDecision();
ChaDongProtect(); //差动保护
atbh_check_u(); //检有压
switch(IntCount)
{
case 0:
//SoeRcordDecision();
//ChaDongProtect(); //差动保护
CheckDLQHW(); //检测断路器位置
UIProtectUnit1(&ATBH_SYYJ,ATBH_HW_BIT); //失压保护
//UIProtectUnit(&ATBH_JDIYJ,1,1); //碰壳保护
#ifdef TEMPERATURE_ENABLE
UIAlarmUnit(&ATBH_CWWD1YJ,0,2); //温度1告警元件
UIAlarmUnit(&ATBH_CWWD2YJ,0,2); //温度2告警元件
#endif
ATBH_FLDProtect(); //非电量保护
ATBH_FLDAlarm(); //非电量告警
IntCount=1;
break;
case 1:
//UIAlarmUnit(&ATBH_CLYXYJ,0,2); //差流越限告警
//过负荷告警
if(ISOLATOR_TYPE == ATBH_ATMode)
{
UIAlarmUnit(&ATBH_FIYJ,!(TempQiDongIP & ATBH_HW_BIT),2);
}
else
{
UIAlarmUnit(&ATBH_FIYJ,0,2); //过负荷告警
}
Check_PTDX(&ATBH_TPTDXYJ,0); //T线PT断线检测
Check_PTDX(&ATBH_FPTDXYJ,1); //F线PT断线检测
IntCount=0;
break;
default:
IntCount=0;
break;
} //endcase
}
TimerManage(); //定时器管理
if(isprtcopen)
{
SaveFaultWave(); //故障录波 20220629
// 重合闸后加速启动时避免出现另外一次故障报告，如果出现任何故障重合闸程序就会完成跳闸
if(CHZValue.Status == CHZ_CLOSE)
{
StartTiaoZha_atbh();
}
FaultProcess();
ChongHeZha();
record_reclose_soe();
SetFaultStart();
CheckFaultEnd();
}
if((BaoHuQiDongIP_OLD==0)&&(BaoHuQiDongIP!=0)&&(QiDongTime==0)) QiDongTime=1;
}//end of if(Init_IP==TEST_START)
//gse_handle();
intFlag = 0;
}
void CheckDLQHW(void)
{
//功能说明：检测断路器位置
if(YaoXinStatus[ATBH_rmtsignal_run]!=OFF)
{
TempQiDongIP|=ATBH_HW_BIT;
}
else
{
TempQiDongIP&=~ATBH_HW_BIT;
}
}
void computedlldiff(unsigned int startbit)
{
tagDLL_Rated_Frq *pDiffBuffer,*pResBuffer;
if(BH_RUN != ATBH_DLLDIFFTouRu)
{
return;
}
pDiffBuffer = &ATBH_DLLDIFFBUF;
pResBuffer = &ATBH_DLLRESBUF;
if(BaoHuQiDongIP & startbit)
{
//增量启动
DLLDiffValue.CDI.Value = ChaDongValue.CDI.Value - pDiffBuffer->basevalue;
DLLDiffValue.ZDI.Value = ChaDongValue.ZDI.Value - pResBuffer->basevalue;
}
else
{
//增量未启动
DLLDiffValue.CDI.Value = ChaDongValue.CDI.Value - pDiffBuffer->buffer[pDiffBuffer->recordip];
pDiffBuffer->basevalue = pDiffBuffer->buffer[pDiffBuffer->recordip];
DLLDiffValue.ZDI.Value = ChaDongValue.ZDI.Value - pResBuffer->buffer[pResBuffer->recordip];
pResBuffer->basevalue = pResBuffer->buffer[pResBuffer->recordip];
}
pDiffBuffer->buffer[pDiffBuffer->recordip] = ChaDongValue.CDI.Value; //保存当前保护绕组电流
pResBuffer->buffer[pResBuffer->recordip] = ChaDongValue.ZDI.Value; //保存当前保护绕组电流
//pDiffBuffer->recordip = (pDiffBuffer->recordip + 1) % (DDL_BUFFFER_RATED_FRQ_LEN_HALF); //修改指针
pDiffBuffer->recordip++;
if(pDiffBuffer->recordip >= DDL_BUFFFER_RATED_FRQ_LEN)
{
pDiffBuffer->recordip -= DDL_BUFFFER_RATED_FRQ_LEN;
}
//pResBuffer->recordip = (pResBuffer->recordip + 1) % (DDL_BUFFFER_RATED_FRQ_LEN_HALF); //修改指针
pResBuffer->recordip++;
if(pResBuffer->recordip >= DDL_BUFFFER_RATED_FRQ_LEN)
{
pResBuffer->recordip -= DDL_BUFFFER_RATED_FRQ_LEN;
}
}
/************************************************************
* void JiSuanUI(void)
* 描述：有效值、谐波含量、差动电流、制动电流
* 历史：创建日期不详
*
***********************************************************/
void JiSuanUI(void)
{
float FS_temp,FC_temp;
float FS_temp_TCD,FC_temp_TCD,FS_temp_FCD,FC_temp_FCD,val,currentflag;
unsigned char Switch_status;
//计算基波有效值
//T线电压
FS_temp=ChannelValue[CH_ATBH_UT].YouXiaoZhi[JiBo].FS;
FC_temp=ChannelValue[CH_ATBH_UT].YouXiaoZhi[JiBo].FC;
ChannelValue[CH_ATBH_UT].YouXiaoZhi[JiBo].Analog.Value=sqrt(FS_temp*FS_temp+FC_temp*FC_temp);
//printf("fs = %f,fc = %f,val = %f\n",FS_temp,FC_temp,ChannelValue[CH_ATBH_UT].YouXiaoZhi[JiBo].Analog.Value);
//F线电压
FS_temp=ChannelValue[CH_ATBH_UF].YouXiaoZhi[JiBo].FS;
FC_temp=ChannelValue[CH_ATBH_UF].YouXiaoZhi[JiBo].FC;
ChannelValue[CH_ATBH_UF].YouXiaoZhi[JiBo].Analog.Value=sqrt(FS_temp*FS_temp+FC_temp*FC_temp);
//T线保护绕组电流
FS_temp=ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[JiBo].FS;
FC_temp=ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[JiBo].FC;
ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[JiBo].Analog.Value=sqrt(FS_temp*FS_temp+FC_temp*FC_temp);
//T线测量绕组电流
FS_temp=ChannelValue[CH_ATBH_CL_I].YouXiaoZhi[JiBo].FS;
FC_temp=ChannelValue[CH_ATBH_CL_I].YouXiaoZhi[JiBo].FC;
ChannelValue[CH_ATBH_CL_I].YouXiaoZhi[JiBo].Analog.Value=sqrt(FS_temp*FS_temp+FC_temp*FC_temp);
//T线差动绕组电流
FS_temp=ChannelValue[CH_ATBH_CD_IT].YouXiaoZhi[JiBo].FS;
FC_temp=ChannelValue[CH_ATBH_CD_IT].YouXiaoZhi[JiBo].FC;
ChannelValue[CH_ATBH_CD_IT].YouXiaoZhi[JiBo].Analog.Value=sqrt(FS_temp*FS_temp+FC_temp*FC_temp);
//F线保护绕组电流
FS_temp=ChannelValue[CH_ATBH_BH_IF].YouXiaoZhi[JiBo].FS;
FC_temp=ChannelValue[CH_ATBH_BH_IF].YouXiaoZhi[JiBo].FC;
ChannelValue[CH_ATBH_BH_IF].YouXiaoZhi[JiBo].Analog.Value=sqrt(FS_temp*FS_temp+FC_temp*FC_temp);
//F线测量绕组电流
FS_temp=ChannelValue[CH_ATBH_CL_IF].YouXiaoZhi[JiBo].FS;
FC_temp=ChannelValue[CH_ATBH_CL_IF].YouXiaoZhi[JiBo].FC;
ChannelValue[CH_ATBH_CL_IF].YouXiaoZhi[JiBo].Analog.Value=sqrt(FS_temp*FS_temp+FC_temp*FC_temp);
//T线差动绕组电流
FS_temp=ChannelValue[CH_ATBH_CD_IF].YouXiaoZhi[JiBo].FS;
FC_temp=ChannelValue[CH_ATBH_CD_IF].YouXiaoZhi[JiBo].FC;
ChannelValue[CH_ATBH_CD_IF].YouXiaoZhi[JiBo].Analog.Value=sqrt(FS_temp*FS_temp+FC_temp*FC_temp);
//接地电流
//FS_temp=ChannelValue[CH_ATBH_JDI].YouXiaoZhi[JiBo].FS;
//FC_temp=ChannelValue[CH_ATBH_JDI].YouXiaoZhi[JiBo].FC;
//ChannelValue[CH_ATBH_JDI].YouXiaoZhi[JiBo].Analog.Value=sqrt(FS_temp*FS_temp+FC_temp*FC_temp);
//计算保护电流
//保护电流=T线电流I+F线电流IF
//基波电流
//FS_temp=((float)ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[JiBo].FS+(float)ChannelValue[CH_ATBH_BH_IF].YouXiaoZhi[JiBo].FS);
//FC_temp=((float)ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[JiBo].FC+(float)ChannelValue[CH_ATBH_BH_IF].YouXiaoZhi[JiBo].FC);
//ATBH_BaoHu_I.Value=sqrt(FS_temp*FS_temp+FC_temp*FC_temp);
//计算差动电流
//断路器连接方式或隔开连接方式下GK0位置不为合位
//if(BREAKER_TYPE == ATBH_ATMode || (ISOLATOR_TYPE == ATBH_ATMode && ON != YaoXinStatus[ATBH_YAOXIN_GK0]))
if(BREAKER_TYPE == ATBH_ATMode || (ISOLATOR_TYPE == ATBH_ATMode && OFF == YaoXinStatus[ATBH_YAOXIN_GK0])) //modi by 20240520 LW
{
//AT是采用断路器接入
//T线保护电流
ATBH_BaoHu_IT.Value = ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[JiBo].Analog.Value;
//差动电流
FS_temp=(float)ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[JiBo].FS-(float)ChannelValue[CH_ATBH_BH_IF].YouXiaoZhi[JiBo].FS;
FC_temp=(float)ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[JiBo].FC-(float)ChannelValue[CH_ATBH_BH_IF].YouXiaoZhi[JiBo].FC;
ChaDongValue.CDI.Value=sqrt(FS_temp*FS_temp+FC_temp*FC_temp);
//制动电流
FS_temp=((float)ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[JiBo].FS+(float)ChannelValue[CH_ATBH_BH_IF].YouXiaoZhi[JiBo].FS)/2;
FC_temp=((float)ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[JiBo].FC+(float)ChannelValue[CH_ATBH_BH_IF].YouXiaoZhi[JiBo].FC)/2;
ChaDongValue.ZDI.Value=sqrt(FS_temp*FS_temp+FC_temp*FC_temp);
//差动二次谐波电流含量
FS_temp=(float)ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[XieBo2].FS-(float)ChannelValue[CH_ATBH_BH_IF].YouXiaoZhi[XieBo2].FS;
FC_temp=(float)ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[XieBo2].FC-(float)ChannelValue[CH_ATBH_BH_IF].YouXiaoZhi[XieBo2].FC;
ATBH_ChaDong_I2.Value=sqrt(FS_temp*FS_temp+FC_temp*FC_temp);
if(ChaDongValue.CDI.Value>ATBH_JD_I)
{
ATBH_ChaDong_I2.Value=ATBH_ChaDong_I2.Value/ChaDongValue.CDI.Value;
#ifdef IH_PERCENT_UNIT
ATBH_ChaDong_I2.Value *= PERCENT_UNIT_COEFFI;
#endif
}
else
{
ATBH_ChaDong_I2.Value=0;
}
}
else
{
//差动电流
FS_temp_TCD = (float)ChannelValue[CH_ATBH_CD_IT].YouXiaoZhi[JiBo].FS + (float)ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[JiBo].FS;
FC_temp_TCD = (float)ChannelValue[CH_ATBH_CD_IT].YouXiaoZhi[JiBo].FC + (float)ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[JiBo].FC;
//T线保护电流
ATBH_BaoHu_IT.Value = sqrt(FS_temp_TCD * FS_temp_TCD + FC_temp_TCD * FC_temp_TCD);
FS_temp_FCD = (float)ChannelValue[CH_ATBH_CD_IF].YouXiaoZhi[JiBo].FS + (float)ChannelValue[CH_ATBH_BH_IF].YouXiaoZhi[JiBo].FS;
FC_temp_FCD = (float)ChannelValue[CH_ATBH_CD_IF].YouXiaoZhi[JiBo].FC + (float)ChannelValue[CH_ATBH_BH_IF].YouXiaoZhi[JiBo].FC;
FS_temp = FS_temp_TCD - FS_temp_FCD;
FC_temp = FC_temp_TCD - FC_temp_FCD;
ChaDongValue.CDI.Value=sqrt(FS_temp*FS_temp+FC_temp*FC_temp);
//制动电流
FS_temp = (FS_temp_TCD + FS_temp_FCD ) / 2;
FC_temp = (FC_temp_TCD + FC_temp_FCD ) / 2;
ChaDongValue.ZDI.Value=sqrt(FS_temp*FS_temp+FC_temp*FC_temp);
//差动二次谐波电流含量
FS_temp_TCD = (float)ChannelValue[CH_ATBH_CD_IT].YouXiaoZhi[XieBo2].FS + (float)ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[XieBo2].FS;
FC_temp_TCD = (float)ChannelValue[CH_ATBH_CD_IT].YouXiaoZhi[XieBo2].FC + (float)ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[XieBo2].FC;
FS_temp_FCD = (float)ChannelValue[CH_ATBH_CD_IF].YouXiaoZhi[XieBo2].FS + (float)ChannelValue[CH_ATBH_BH_IF].YouXiaoZhi[XieBo2].FS;
FC_temp_FCD = (float)ChannelValue[CH_ATBH_CD_IF].YouXiaoZhi[XieBo2].FC + (float)ChannelValue[CH_ATBH_BH_IF].YouXiaoZhi[XieBo2].FC;
FS_temp = FS_temp_TCD - FS_temp_FCD;
FC_temp = FC_temp_TCD - FC_temp_FCD;
ATBH_ChaDong_I2.Value=sqrt(FS_temp*FS_temp+FC_temp*FC_temp);
if(ChaDongValue.CDI.Value>ATBH_JD_I)
{
ATBH_ChaDong_I2.Value=ATBH_ChaDong_I2.Value/ChaDongValue.CDI.Value;
#ifdef IH_PERCENT_UNIT
ATBH_ChaDong_I2.Value *= PERCENT_UNIT_COEFFI;
#endif
}
else
{
ATBH_ChaDong_I2.Value=0;
}
}
//之前没有差流
//识别空投
currentflag = ATBH_JD_I < ChaDongValue.CDI.Value || ATBH_JD_I < ChaDongValue.ZDI.Value ;
#if 0
if(OFF == YaoXinStatus[ATBH_YAOXIN_QF] && currentflag)
{
if(0 == ATBH_I_Flag)
{
//从无流到有流
ATBH_I_Flag = 1;
ATBH_I_Timer = 1;
}
}
else
{
//无流
ATBH_I_Flag = 0;
}
#else
Switch_status = ON;
if(BREAKER_TYPE == ATBH_ATMode)
{//断路器接入方式
if(OFF == YaoXinStatus[ATBH_YAOXIN_QF])
{
Switch_status = OFF;
}
}
else
{//隔开接入接入方式
if(OFF == YaoXinStatus[ATBH_YAOXIN_1QSDD_1QF])
{
Switch_status = OFF;
}
else if(OFF != YaoXinStatus[ATBH_YAOXIN_GK0] && OFF == YaoXinStatus[ATBH_YAOXIN_2QSDD_2QF])
{
Switch_status = OFF;
}
}
if(OFF == Switch_status && currentflag)
{
if(0 == ATBH_I_Flag)
{
//从无流到有流
ATBH_I_Flag = 1;
ATBH_I_Timer = 1;
}
}
else
{
//无流
ATBH_I_Flag = 0;
}
#endif
//电压最大值，用于失压
if(ChannelValue[CH_ATBH_UT].YouXiaoZhi[JiBo].Analog.Value >= ChannelValue[CH_ATBH_UF].YouXiaoZhi[JiBo].Analog.Value)
{
ATBH_Baohu_UMax = ChannelValue[CH_ATBH_UT].YouXiaoZhi[JiBo].Analog;
}
else
{
ATBH_Baohu_UMax = ChannelValue[CH_ATBH_UF].YouXiaoZhi[JiBo].Analog;
}
//计算增量差动、制动电流
computedlldiff(ATBH_DLLDIFF_BIT);
/*
if(SaveFaultDataIP!=0)
{
SaveFaultDataIP++;
if(SaveFaultDataIP>= 3)
{//延时10ms记录
SaveFaultDataIP=0;
SaveFaultData();
}
}
*/
#ifdef TEMPERATURE_ENABLE
//温度1
digital_getTemperature(CH_ATBH_WD1);
//温度2
digital_getTemperature(CH_ATBH_WD2);
#endif
}
/************************************************************
* void ComputeTemperature()
* 描述：计算温度
* 历史：
************************************************************/
void ComputeTemperature()
{
#ifdef AD_TEMPERATURE_ENABLE
float I1,T1,K1; //温度1 温度基准 电流基准 曲线斜率
float I2,T2,K2; //温度2 温度基准 电流基准 曲线斜率
float Itemp1,Itemp2;
I1=ATBH_WD1ISet;
T1=ATBH_WD1TSet;
K1=ATBH_WD1KSet;
I2=ATBH_WD2ISet;
T2=ATBH_WD2TSet;
K2=ATBH_WD2KSet;
//20150416 luoyang modi 温度采样点取40点平均值
//Itemp1=(float)ChannelValue[CH_ATBH_WD1].SampleValue_Digit[ChannelValue[CH_ATBH_WD1].FSCount];
//Itemp2=(float)ChannelValue[CH_ATBH_WD2].SampleValue_Digit[ChannelValue[CH_ATBH_WD2].FSCount];
if(WD_SOURCE_GSE != ChannelValue[CH_ATBH_WD1].source)
{
Itemp1 = SmpValueSet[CH_ATBH_WD1].averageValue;
ChannelValue[CH_ATBH_WD1].YouXiaoZhi[JiBo].Analog.Value=K1*(Itemp1-I1)+T1;//温度1
}
if(WD_SOURCE_GSE != ChannelValue[CH_ATBH_WD2].source)
{
Itemp2 = SmpValueSet[CH_ATBH_WD2].averageValue;
ChannelValue[CH_ATBH_WD2].YouXiaoZhi[JiBo].Analog.Value=K2*(Itemp2-I2)+T2;//温度2
}
#endif
}
//检有压功能，用于重合闸及自投
void atbh_check_u()
{
float setval;
if(ATBH_YY_BIT & TempQiDongIP)
{
setval = ATBH_JYYSet.SetValue * COEFFI_RETURN_OVER;
}
else
{
setval = ATBH_JYYSet.SetValue;
}
if(ATBH_Baohu_UMax.Value >= setval)
{
if(ATBH_checku_timer >= ATBH_JYYSet.Time)
{
TempQiDongIP |= ATBH_YY_BIT;
}
else
{
ATBH_checku_timer++;
}
}
else
{
ATBH_checku_timer = 0;
TempQiDongIP &= ~ATBH_YY_BIT;
}
}
//检并联隔开位置变化，用于单开关并联的检有压自投
void atbh_check_position_change() //检测位置变化
{
CanShuType canshu;
canshu.Number=0;
static unsigned char RecordDlstatus = OFF;
if(RecordDlstatus != YaoXinStatus[ATBH_YAOXIN_GK0])
{
if(RecordDlstatus == ON)
{//变位前为合位
kcDelayTimer_11 = 1;
}
else
{//变位前为分位
if(ON == YaoXinStatus[ATBH_YAOXIN_GK0])
{
//kcDelayTimer_9 = 1;
kcDelayTimer_11 = 0;
}
}
RecordDlstatus = YaoXinStatus[ATBH_YAOXIN_GK0];
}
}
/********************************************************************
* void Check_PTDX(void)
* 描述: PT断线检测
* 历史: 创建日期不详
* luoyang 修改启动判据，增加对截断电流的判断
********************************************************************/
void Check_PTDX(NoDirectProtectItemType *pPrtcUnit,char tvtype)
{
CanShuType CanShuValue;
DataType *DataValue;
float U_setval,U_setval_l;
float uvalue;
float ut,uf;
DataValue = pPrtcUnit->MeasureValue;
CanShuValue.Number = 1;
CanShuValue.CSValue[0] = DataValue;
//闭锁或者元件退出时，元件返回
if(pPrtcUnit->ClsDwnIP != 0 || pPrtcUnit->TouRuIP != BH_RUN)
{
//PT断线未投入
*((unsigned int *)(pPrtcUnit->IPAddress)) &= (~pPrtcUnit->QiDongBit); //清除启动标志
AlarmUnitActIP &= ~pPrtcUnit->QiDongBit;
pPrtcUnit->TimeValue = 0; //清除计时器
if(ON == YaoXinStatus[pPrtcUnit->YaoXinNumber] || TEST_END == pPrtcUnit->SoeRecordIP)
{
//PT断线解除SOE事件记录
RecordSOE(pPrtcUnit->FanHuiCode,CanShuValue);
//RecordSoftYaoXin(pPrtcUnit->YaoXinNumber,OFF); //软遥信记录
pPrtcUnit->SoeRecordIP=TEST_START;
//RecordSoftYaoXin(pPrtcUnit->YaoXinNumber,OFF); //软遥信记录
//printf("val3 = %f,val4 = %f,cls = %d\n",DataValue->Value,CanShuValue.CSValue[0]->Value,pPrtcUnit->ClsDwnIP);
}
if(OFF != YaoXinStatus[pPrtcUnit->YaoXinNumber])
{
RecordSoftYaoXin(pPrtcUnit->YaoXinNumber,OFF); //软遥信记录
}
return;
}
if(0 == tvtype)
{
uvalue = ChannelValue[CH_ATBH_UF].YouXiaoZhi[JiBo].Analog.Value;
}
else
{
uvalue = ChannelValue[CH_ATBH_UT].YouXiaoZhi[JiBo].Analog.Value;
}
if((*((unsigned int *)(pPrtcUnit->IPAddress))&pPrtcUnit->QiDongBit) != 0)
{
U_setval = ATBH_PTDXSet * COEFFI_RETURN_UNDER;
U_setval_l = ATBH_PTDXSet * COEFFI_RETURN_OVER;
}
else
{
U_setval = ATBH_PTDXSet;
U_setval_l = ATBH_PTDXSet;
}
if(uvalue > U_setval_l && DataValue->Value <= U_setval)
{
//PT断线
*((unsigned int *)(pPrtcUnit->IPAddress))|=pPrtcUnit->QiDongBit; //设置启动标志
if(pPrtcUnit->TimeValue > pPrtcUnit->SetTime)
{
AlarmUnitActIP |= pPrtcUnit->QiDongBit;
if(pPrtcUnit->SoeRecordIP==TEST_START)
{//PT断线SOE事件记录
RecordSOE(pPrtcUnit->QiDongCode,CanShuValue);
//RecordSoftYaoXin(pPrtcUnit->YaoXinNumber,ON); //软遥信记录
pPrtcUnit->SoeRecordIP=TEST_END;
//printf("val1 = %f,val2 = %f\n",DataValue->Value,CanShuValue.CSValue[0]->Value);
}
if(ON != YaoXinStatus[pPrtcUnit->YaoXinNumber])
{
RecordSoftYaoXin(pPrtcUnit->YaoXinNumber,ON); //软遥信记录
}
}
else pPrtcUnit->TimeValue+=2; //计时器加2
}
else
{
*((unsigned int *)(pPrtcUnit->IPAddress))&=(~pPrtcUnit->QiDongBit); //清除启动标志
AlarmUnitActIP &= ~pPrtcUnit->QiDongBit;
pPrtcUnit->TimeValue=0; //清除计时器
if(pPrtcUnit->SoeRecordIP==TEST_END || ON == YaoXinStatus[pPrtcUnit->YaoXinNumber])
{
//PT断线解除SOE事件记录
RecordSOE(pPrtcUnit->FanHuiCode,CanShuValue);
//RecordSoftYaoXin(pPrtcUnit->YaoXinNumber,OFF); //软遥信记录
pPrtcUnit->SoeRecordIP=TEST_START;
//printf("val1 = %f,val2 = %f\n",DataValue->Value,CanShuValue.CSValue[0]->Value);
}
if(OFF != YaoXinStatus[pPrtcUnit->YaoXinNumber])
{
RecordSoftYaoXin(pPrtcUnit->YaoXinNumber,OFF); //软遥信记录
}
}
}
/***********************************************************
* void Check_QDZT (void)
* 描述: 检测启动自投信号
* 历史: 启动自投信号为分的时候才能响应复归，
* 复归时收回软遥信
***********************************************************/
void Check_QDZT (void)
{
static unsigned char ATBH_QDZT_KR_OLD_status = ON ;
if(ON == drv_GetInputStatus(ATBH_ZTTR_KR)&& BH_RUN == ATBH_SoftStrap_AtSwitch)
{
//ATBH_ZT_ENABLE = BH_RUN;
if(ON != YaoXinStatus[ATBH_YAOXIN_AT_SWITCH])
{
RecordSoftYaoXin(ATBH_YAOXIN_AT_SWITCH,ON);
}
}
else
{
//ATBH_ZT_ENABLE = BH_STOP;
if(OFF != YaoXinStatus[ATBH_YAOXIN_AT_SWITCH])
{
RecordSoftYaoXin(ATBH_YAOXIN_AT_SWITCH,OFF);
}
}
//1.自投处于未动作状态
//2.硬压板及软压板已投入
//3.并联隔开处于合位
//4.AT处于退出态
//5.有压
//6.无本体故障标志(本体未动作或动作后已复归)20220331增加
/*if(TEST_CLOSE == ZTDongZuoIP &&
ON == YaoXinStatus[ATBH_YAOXIN_AT_SWITCH] &&
(OFF != YaoXinStatus[ATBH_YAOXIN_GK0]) && 0 == BaoHuQiDongIP &&
(ATBH_YY_BIT & TempQiDongIP) &&
0 == CheckPrtcFlag(ATBH_BTGZ_KC,0,0,ON))*/
//modi by 20240521 LW 修改自投就绪判据 由不在分位判断改为（本侧线路有压且并联开关分位）或并联开关不在分位
//1.自投处于未动作状态或动作成功
//2.硬压板及软压板已投入
//3.（本侧线路有压且并联开关分位）或并联开关不在分位
//4.AT处于退出态
//5.无本体故障标志(本体未动作或动作后已复归)20220331增加
if(TEST_CLOSE == ZTDongZuoIP &&
ON == YaoXinStatus[ATBH_YAOXIN_AT_SWITCH] &&
(BH_RUN != ATBH_SYYJ.TouRuIP || (BH_RUN == ATBH_SYYJ.TouRuIP && (ATBH_YY_BIT & TempQiDongIP))) &&
(OFF == YaoXinStatus[ATBH_rmtsignal_run]) &&
0 == BaoHuQiDongIP && 0 == CheckPrtcFlag(ATBH_BTGZ_KC,0,0,ON))
{
//自投就绪
if(ON != YaoXinStatus[ATBH_YAOXIN_AT_SWITCH_RESET])
{
RecordSoftYaoXin(ATBH_YAOXIN_AT_SWITCH_RESET,ON);
D_OUT(ATBH_ZTJX_LED_KC,ON);
}
//20210414 统一硬件时修改为自投均检有压
//if(ON == drv_GetInputStatus(ATBH_QDZT_KR) && OFF == YaoXinStatus[ATBH_rmtsignal_run] )
if(ON == drv_GetInputStatus(ATBH_QDZT_KR) && (ATBH_QDZT_KR_OLD_status !=drv_GetInputStatus(ATBH_QDZT_KR)) )
{
//有压
//if(ATBH_Baohu_UMax.Value >= ATBH_JYYSet.SetValue)
//{
ZTDongZuoIP = TEST_START; //启动自投
//}
}
}
else
{
//自投就绪
if(OFF != YaoXinStatus[ATBH_YAOXIN_AT_SWITCH_RESET])
{
RecordSoftYaoXin(ATBH_YAOXIN_AT_SWITCH_RESET,OFF);
D_OUT(ATBH_ZTJX_LED_KC,OFF);
}
}
ATBH_QDZT_KR_OLD_status = drv_GetInputStatus(ATBH_QDZT_KR);
#if 0
switch(ZTDongZuoIP)
{
case TEST_CLOSE: //可以进行自投
if(BH_RUN == ATBH_ZT_ENABLE)
{
//自投就绪
if(ON != YaoXinStatus[ATBH_YAOXIN_AT_SWITCH_RESET])
{
RecordSoftYaoXin(ATBH_YAOXIN_AT_SWITCH_RESET,ON);
}
//20210414 统一硬件时修改为自投均检有压
if(ON == drv_GetInputStatus(ATBH_QDZT_KR))
{
//ZTDongZuoIP = TEST_START; //启动自投
//有压
if(ATBH_Baohu_UMax.Value >= ATBH_JYYSet.SetValue)
{
ZTDongZuoIP = TEST_START; //启动自投
}
}
/*
else if(ON == YaoXinStatus[ATBH_YAOXIN_JYYZT])
{
//有压
if(BREAKER_TYPE == ATBH_ATMode && ATBH_Baohu_UMax.Value >= ATBH_JYYSet.SetValue)
{
ZTDongZuoIP = TEST_START; //启动自投
}
}
*/
}
break;
case TEST_START: //处于自投状态
break;
case TEST_END: //自投结束，等待复归
break;
default:
break;
}//endcase
#endif
}
/***********************************************************
* void Send_QDZT (void)
* 描述: 向对侧发启动自投信号
* 历史:
***********************************************************/
void Send_QDZT(int start)
{
//if(TEST_CLOSE != ZTDongZuoIP )
if( TEST_CLOSE != ZTDongZuoIP || ZB_fristFaultIndex >= 2 )
{
return;
}
if(kcDelayTimer_1==0)
{
if(!start)
{
if((BaoHuDongZuoIP & ATBH_QDZT_Mask) != 0)
{
//modi by 20240521 LW 并联开关不定态当成合位判断 不在分位情况下方能发出自投信号
if(YaoXinStatus[ATBH_YAOXIN_GK0]!=OFF)
{
D_OUT(ATBH_CDJQ_KC,ON);
kcDelayTimer_1 = 1;
}
}
}
else
{
D_OUT(ATBH_CDJQ_KC,ON);
kcDelayTimer_1 = 1;
}
}
/*if(((BaoHuDongZuoIP & ATBH_QDZT_Mask) != 0 || 0 != start)&&(kcDelayTimer_1==0))
{
//modi by 20240520 LW 并联开关不定态当成合位判断 不在分位情况下方能发出自投信号
if(YaoXinStatus[ATBH_YAOXIN_GK0]!=OFF)
{
D_OUT(ATBH_CDJQ_KC,ON);
kcDelayTimer_1 = 1;
}
}*/
}
/*****************************************************
* void ChaDongProtect(void)
* 描述：差动保护功能实现，差动保护的实现方式与AT的接入方式有关
* 历史：创建日期不详
*
*****************************************************/
void ChaDongProtect(void)
{
unsigned int blockbit = 0;
ATBH_CD_StartIP = 0;
static int chenckIP=0;
CanShuType canshu;
canshu.Number=0;
if(ATBH_ATMode==BREAKER_TYPE)
{
//AT是采用断路器接入方式
//DiffXieBo2Unit(&ATBH_XieBo2CDIYJ,1,BaoHuQiDongIP & (ATBH_CD_BIT | ATBH_DLLDIFF_BIT)); //比率差动二次谐波闭锁元件（差动）
DiffXieBo2UnitPlus(&ATBH_XieBo2CDIYJ,1,BaoHuQiDongIP & (ATBH_CD_BIT | ATBH_DLLDIFF_BIT),ATBH_I_Timer); //比率差动二次谐波闭锁元件（差动）
//DiffXieBo2Unit(&ATBH_XieBo2CDIYJ,1,1); //比率差动二次谐波闭锁元件（差动）
UIProtectUnit(&ATBH_CDSDYJ,1,1); //差动速断
//blockbit = DiffProtectUnit(&ATBH_CDYJ,ATBH_XieBoCDI2_BIT,NULL); //比率差动
blockbit = DiffProtectUnit(&ATBH_CDYJ,ATBH_XieBoCDI2_BIT,&ATBH_CD_StartIP); //比率差动
if(BH_RUN == ih_diff_alram_block)
{
blockbit |= DiffAlarmUnit(&ATBH_CLYXYJ,ATBH_XieBoCDI2_BIT,1); //差流越限告警
}
else
{
DiffAlarmUnit(&ATBH_CLYXYJ,0,1); //差流越限告警
}
blockbit |= DeltaDiffProtectUnitplus(&ATBH_DLLDIFFAYJ,ATBH_XieBoCDI2_BIT,&ATBH_CD_StartIP); //增量差动
}
else
{
//隔离开关接入方式
//若AT投入运行，才有差动保护
//if((YaoXinStatus[ATBH_rmtsignal_run]!=OFF)|| (BaoHuQiDongIP&(ATBH_CDSD_BIT|ATBH_CD_BIT | ATBH_DLLDIFF_BIT)) || ( TempQiDongIP & ATBH_CLYX_BIT ))//
if((YaoXinStatus[ATBH_rmtsignal_run]!=OFF)|| (BaoHuQiDongIP&(ATBH_CDSD_BIT|ATBH_CD_BIT | ATBH_DLLDIFF_BIT)) || (ATBH_CLYX_BIT & TempQiDongIP ))//
{
//DiffXieBo2Unit(&ATBH_XieBo2CDIYJ,1,BaoHuQiDongIP & (ATBH_CD_BIT | ATBH_DLLDIFF_BIT)); //差动二次谐波闭锁元件（差动）
DiffXieBo2UnitPlus(&ATBH_XieBo2CDIYJ,1,BaoHuQiDongIP & (ATBH_CD_BIT | ATBH_DLLDIFF_BIT),ATBH_I_Timer); //比率差动二次谐波闭锁元件（差动）
UIProtectUnit(&ATBH_CDSDYJ,1,1); //差动速断
//blockbit = DiffProtectUnit(&ATBH_CDYJ,ATBH_XieBoCDI2_BIT,NULL); //比率差动
blockbit = DiffProtectUnit(&ATBH_CDYJ,ATBH_XieBoCDI2_BIT,&ATBH_CD_StartIP); //比率差动
if(BH_RUN == ih_diff_alram_block)
{
blockbit |= DiffAlarmUnit(&ATBH_CLYXYJ,ATBH_XieBoCDI2_BIT,1); //差流越限告警
}
else
{
DiffAlarmUnit(&ATBH_CLYXYJ,0,1); //差流越限告警
}
blockbit |= DeltaDiffProtectUnitplus(&ATBH_DLLDIFFAYJ,ATBH_XieBoCDI2_BIT,&ATBH_CD_StartIP); //增量差动
}
} //endelse
hi_blcok_soe_record(&ATBH_XieBo2CDIYJ,blockbit);
}
/**********************************************************
* void IProtectUnit(void)
* 描述：过流保护元件功能的实现
* 历史：创建日期不详
*
**********************************************************/
/*
void IProtectUnit(void)
{
float SetValue;
CanShuType CanShuValue;
DataType *DataValue;
float TempValue;
unsigned char QiDongValue;
DataValue=ATBH_IYJ.MeasureValue; //取测量值
//设置参数
CanShuValue.Number = 1;
CanShuValue.CSValue[0]=DataValue;
if(ATBH_IYJ.ClsDwnIP != 0 || (ATBH_IYJ.TouRuIP!=BH_RUN && ATBH_IYJ.TouRuIP != BH_TEST))
{ //保护元件未投入
//清除启动标志
*((unsigned int *)(ATBH_IYJ.IPAddress))&=~ATBH_IYJ.QiDongBit;
//清除计时器
ATBH_IYJ.TimeValue=0;
if(ATBH_IYJ.SoeRecordIP==TEST_END)
{
RecordSOE(ATBH_IYJ.FanHuiCode,CanShuValue);
ATBH_IYJ.SoeRecordIP=TEST_START;
}
return;
}
//检测综合谐波抑制元件是否启动
if((TempQiDongIP&ATBH_XieBoSum_BIT)!=0){
//综合谐波抑制
if(DataValue->Value>=2*ATBH_IYJ.SetValue)
TempValue=DataValue->Value; //超过定值两倍则不抑制
else
TempValue=DataValue->Value*(1-ATBH_BaoHu_IE.Value*ATBH_XieBo_XiShu);
}
else
TempValue=DataValue->Value; //不抑制
//检测元件是否已启动
if(((*((unsigned int *)ATBH_IYJ.IPAddress))&ATBH_IYJ.QiDongBit)!=0) SetValue=0.97*ATBH_IYJ.SetValue; //保护元件已启动，整定值*返回系数
else SetValue=ATBH_IYJ.SetValue;
if(TempValue>=SetValue) QiDongValue=1; //启动
else QiDongValue=0; //返回
//检查二次谐波是否启动
if((TempQiDongIP&ATBH_XieBoI2_BIT)!=0) QiDongValue=0; //二次谐波启动，闭锁保护
if(((ATBH_DYYJ.TouRuIP==BH_RUN)||(ATBH_DYYJ.TouRuIP==BH_TEST))&&((TempQiDongIP&ATBH_LU_BIT)==0)) QiDongValue=0; //低压启动元件未启动，闭锁保护
if(QiDongValue==1){
//启动
*((unsigned int *)(ATBH_IYJ.IPAddress))|=ATBH_IYJ.QiDongBit;
//启动计时器
if(ATBH_IYJ.TimeValue==0) ATBH_IYJ.TimeValue=1;
//启动事件记录
if(ATBH_IYJ.SoeRecordIP==TEST_START){
RecordSOE(ATBH_IYJ.QiDongCode,CanShuValue);
ATBH_IYJ.SoeRecordIP=TEST_END;
}
}
else{
//返回
//清除启动标志
*((unsigned int *)(ATBH_IYJ.IPAddress))&=(~ATBH_IYJ.QiDongBit);
//清除计时器
ATBH_IYJ.TimeValue=0;
//返回事件记录
if(ATBH_IYJ.SoeRecordIP==TEST_END){
RecordSOE(ATBH_IYJ.FanHuiCode,CanShuValue);
ATBH_IYJ.SoeRecordIP=TEST_START;
}
}
}
*/
/*********************************************************
* void ATBH_FLDProtect(void)
* 描述：非电量保护功能实现
* 历史：创建日期不详
**********************************************************/
void ATBH_FLDProtect(void)
{
//unsigned int Status;
FDLProtectUnit_SWTRELA(&ATBH_ZWSYJ,ATBH_rmtsignal_run); //重瓦斯元件
FDLProtectUnit_SWTRELA(&ATBH_WD2YJ,ATBH_rmtsignal_run); //温度Ⅱ段元件
FDLProtectUnit_SWTRELA(&ATBH_YLSFYJ,ATBH_rmtsignal_run); //压力释放元件 z
FDLProtectUnit_SWTRELA(&ATBH_BYXHYJ,ATBH_rmtsignal_run); //备用信号元件 z
//Status=0;
//if(!(BaoHuQiDongIP & (ATBH_ZWS_BIT | ATBH_WD1_BIT | ATBH_YLSF_BIT | ATBH_BAK_BIT)))
//{
// BaoHuQiDongIP &= ~ATBH_FDL_BIT;
//}
if (TZValue.IP != SUCCESS)
{
return; //在跳闸失灵时，保护元件动作时限判断不执行
}
//检测非电量保护是否启动
if(((*((unsigned int *)(ATBH_ZWSYJ.IPAddress)))&(ATBH_ZWSYJ.QiDongBit))!=0)
{//启动
if(ATBH_ZWSYJ.YaoXinRecordIP==TEST_START)
{
//if(RecordSoftYaoXin(ATBH_YAOXIN_ZWS,ON)==SUCCESS)
ATBH_ZWSYJ.YaoXinRecordIP=TEST_END;
TempBaoHuDongZuoIP |= ATBH_ZWS_BIT; //记录保护辅助动作标志字
BaoHuDongZuoIP |= ATBH_ZWS_BIT;
if(BH_RUN == ATBH_nonui_prtc_trip)
{
BaoHuChuKouIP |= ATBH_ZWS_BIT;
}
}
//Status=1;
}
else
{
if(ATBH_ZWSYJ.YaoXinRecordIP==TEST_END)
{
ATBH_ZWSYJ.YaoXinRecordIP=TEST_START;
//RecordSoftYaoXin(ATBH_YAOXIN_ZWS,OFF);
}
//TempBaoHuDongZuoIP &= ~ATBH_ZWS_BIT; //记录保护辅助动作标志字
}
if(((*((unsigned int *)(ATBH_WD2YJ.IPAddress)))&(ATBH_WD2YJ.QiDongBit))!=0)
{
//启动
if(ATBH_WD2YJ.YaoXinRecordIP==TEST_START)
{
//if(RecordSoftYaoXin(ATBH_YAOXIN_WD2,ON)==SUCCESS)
ATBH_WD2YJ.YaoXinRecordIP=TEST_END;
TempBaoHuDongZuoIP|=ATBH_WD2_BIT; //记录保护辅助动作标志字
BaoHuDongZuoIP|=ATBH_WD2_BIT;
//BaoHuQiDongIP|=ATBH_FDL_BIT;
if(BH_RUN == ATBH_nonui_prtc_trip)
{
BaoHuChuKouIP |= ATBH_WD2_BIT;
}
}
//Status=1;
}
else
{
if(ATBH_WD2YJ.YaoXinRecordIP==TEST_END)
{
ATBH_WD2YJ.YaoXinRecordIP=TEST_START;
//RecordSoftYaoXin(ATBH_YAOXIN_WD2,OFF);
}
//TempBaoHuDongZuoIP &= ~ATBH_WD2_BIT;
}
if(((*((unsigned int *)(ATBH_YLSFYJ.IPAddress)))&(ATBH_YLSFYJ.QiDongBit))!=0)
{
//启动
if(ATBH_YLSFYJ.YaoXinRecordIP==TEST_START)
{
//if(RecordSoftYaoXin(ATBH_YAOXIN_YLSF,ON)==SUCCESS)
ATBH_YLSFYJ.YaoXinRecordIP=TEST_END;
TempBaoHuDongZuoIP|=ATBH_YLSF_BIT; //记录保护辅助动作标志字
BaoHuDongZuoIP |= ATBH_YLSF_BIT;
//BaoHuQiDongIP|=ATBH_FDL_BIT;
if(BH_RUN == ATBH_nonui_prtc_trip)
{
BaoHuChuKouIP|=ATBH_YLSF_BIT;
}
}
//Status=1;
}
else
{
if(ATBH_YLSFYJ.YaoXinRecordIP==TEST_END)
{
ATBH_YLSFYJ.YaoXinRecordIP=TEST_START;
//RecordSoftYaoXin(ATBH_YAOXIN_YLSF,OFF);
}
//TempBaoHuDongZuoIP &= ~ATBH_YLSF_BIT;
}
if(((*((unsigned int *)(ATBH_BYXHYJ.IPAddress)))&(ATBH_BYXHYJ.QiDongBit))!=0)
{
//启动
if(ATBH_BYXHYJ.YaoXinRecordIP==TEST_START)
{
//if(RecordSoftYaoXin(ATBH_YAOXIN_YLSF,ON)==SUCCESS)
ATBH_BYXHYJ.YaoXinRecordIP=TEST_END;
TempBaoHuDongZuoIP|=ATBH_BAK_BIT; //记录保护辅助动作标志字
BaoHuDongZuoIP|=ATBH_BAK_BIT;
//BaoHuQiDongIP|=ATBH_FDL_BIT;
if(BH_RUN == ATBH_nonui_prtc_trip)
{
BaoHuChuKouIP|=ATBH_BAK_BIT;
}
}
//Status=1;
}
else
{
if(ATBH_BYXHYJ.YaoXinRecordIP==TEST_END)
{
ATBH_BYXHYJ.YaoXinRecordIP=TEST_START;
//RecordSoftYaoXin(ATBH_YAOXIN_YLSF,OFF);
}
//TempBaoHuDongZuoIP &= ATBH_BAK_BIT;
}
//if(Status==0) BaoHuQiDongIP&=~ATBH_FDL_BIT;
}
/*
void ATBH_FIAlarm()
{
if(BREAKER_TYPE == ATBH_ATMode)
{
UIAlarmUnit(&ATBH_FIYJ,0,2);
}
else
{
UIAlarmUnit(&ATBH_FIYJ,ON != YaoXinStatus[ATBH_rmtsignal_run],2);
}
}
*/
//非电量告警
//20220705 取消判断位置信号 modi by L.Y.
void ATBH_FLDAlarm(void)
{
CanShuType param;
param.Number = 0;
//unsigned int isrun = 0;
unsigned char fzjs;
int start;
//static int cls_reset_ip = 0;//重合闸充电标志
//if(ON == YaoXinStatus[ATBH_rmtsignal_run])
//{
// isrun = 1;
//}
//轻瓦斯
if(ON == drv_GetInputStatus(ATBH_QWS_KR))
{
if(!(TempQiDongIP & ATBH_QWS_BIT))
{
TempQiDongIP |= ATBH_QWS_BIT;
AlarmUnitActIP |= ATBH_QWS_BIT;
RecordSOE(ATBH_QWS_GJ,param);
}
}
else if(TempQiDongIP & ATBH_QWS_BIT)
{
TempQiDongIP &= ~ATBH_QWS_BIT;
AlarmUnitActIP &= ~ATBH_QWS_BIT;
//RecordSOE(ATBH_QWS_GJ,param);
}
//温度1段
if(ON == drv_GetInputStatus(ATBH_WD1_KR))
{
if(!(TempQiDongIP & ATBH_WD1_BIT))
{
TempQiDongIP |= ATBH_WD1_BIT;
AlarmUnitActIP |= ATBH_WD1_BIT;
RecordSOE(ATBH_WD1_GJ,param);
}
}
else if(TempQiDongIP & ATBH_WD1_BIT)
{
TempQiDongIP &= ~ATBH_WD1_BIT;
AlarmUnitActIP &= ~ATBH_WD1_BIT;
//RecordSOE(ATBH_QWS_GJ,param);
}
//油位低
if(ON == drv_GetInputStatus(ATBH_YWD_KR))
{
if(!(TempQiDongIP & ATBH_YWD_BIT))
{
TempQiDongIP |= ATBH_YWD_BIT;
AlarmUnitActIP |= ATBH_YWD_BIT;
RecordSOE(ATBH_YWD_GJ,param);
}
}
else if(TempQiDongIP & ATBH_YWD_BIT)
{
TempQiDongIP &= ~ATBH_YWD_BIT;
AlarmUnitActIP &= ~ATBH_YWD_BIT;
//RecordSOE(ATBH_QWS_GJ,param);
}
//油位高
if(ON == drv_GetInputStatus(ATBH_YWG_KR))
{
if(!(TempQiDongIP & ATBH_YWG_BIT))
{
TempQiDongIP |= ATBH_YWG_BIT;
AlarmUnitActIP |= ATBH_YWG_BIT;
RecordSOE(ATBH_YWG_GJ,param);
}
}
else if(TempQiDongIP & ATBH_YWG_BIT)
{
TempQiDongIP &= ~ATBH_YWG_BIT;
AlarmUnitActIP &= ~ATBH_YWG_BIT;
//RecordSOE(ATBH_QWS_GJ,param);
}
if(BREAKER_TYPE == ATBH_ATMode)
{
start = check_dl_open_innormal(&ATBH_dl_open_innormal_param,2);
if(ON == YaoXinStatus[ATBH_YAOXIN_DL_YCFZ])
{
//起动重合闸
if(BH_RUN == ATBH_YCFZ_CHZ_TuoRu && 0 == BaoHuQiDongIP && TZ_CLOSE == TZValue.Status && CHZ_CLOSE == CHZValue.Status && !(ATBH_YCFZ_BIT & AlarmUnitActIP))
{
CHZValue.CHZTime = ATBH_CHZ_Time - 500; //启动重合闸延时计时器 500ms
CHZValue.Status = CHZ_START; //启动重合闸
fristFaultIndex = FaultRecord.RecordIP;
}
AlarmUnitActIP |= ATBH_YCFZ_BIT;
}
else
{
AlarmUnitActIP &= ~ATBH_YCFZ_BIT;
}
fzjs = drv_GetInputStatus(ATBH_DL_FZJS_KR);
if(fzjs != YaoXinStatus[ATBH_YAOXIN_DL_FZJS])
{
RecordSoftYaoXin(ATBH_YAOXIN_DL_FZJS,fzjs);
}
//异常分闸起动重合闸
if(BH_RUN == ATBH_YCFZ_CHZ_TuoRu && 1 == start)
{
if(SUCCESS == CHZValue.ChongDianOK)
{
TempQiDongIP |= ATBH_CHZ_CDOK_BIT;
}
else
{
TempQiDongIP &= ~ATBH_CHZ_CDOK_BIT;
}
}
}
else
{
if(ON == YaoXinStatus[ATBH_YAOXIN_DL_YCFZ])
{
AlarmUnitActIP |= ATBH_YCFZ_BIT;
}
else
{
AlarmUnitActIP &= ~ATBH_YCFZ_BIT;
}
}
}
/****************************************************
* void TimerManage()
* 描述:定时器管理
* 历史:创建日期不详
*****************************************************/
void TimerManage(void)
{
static int temp = 0;
CanShuType CanShu;
CanShu.Number = 0;
int cls_do,open_do;
//BHCount++;
MeasureSendDelay++;
if(DelayTime!=0) DelayTime++; //延时计数器
if(RemoteValue.DelayTime!=0) RemoteValue.DelayTime++; //遥控计时器
if(TZValue.DelayCount!=0) TZValue.DelayCount++; //跳闸延时计数器
if(QiDongTime!=0) QiDongTime++;
if(ChuanDongTest.TestDelay!=0) ChuanDongTest.TestDelay++;
//开出计时
if(kcDelayTimer_0!=0) kcDelayTimer_0++;
if(kcDelayTimer_1!=0) kcDelayTimer_1++;
if(kcDelayTimer_2!=0) kcDelayTimer_2++;
if(kcDelayTimer_3!=0) kcDelayTimer_3++;
if(kcDelayTimer_4!=0) kcDelayTimer_4++;
if(kcDelayTimer_5!=0) kcDelayTimer_5++;
if(kcDelayTimer_6!=0) kcDelayTimer_6++;
if(kcDelayTimer_7!=0) kcDelayTimer_7++;
//if(kcDelayTimer_9!=0 && kcDelayTimer_9<=10000) kcDelayTimer_9++;//10以内
if(kcDelayTimer_10!=0) kcDelayTimer_10++;
if(kcDelayTimer_11!=0 && kcDelayTimer_11<=10000) kcDelayTimer_11++;
if(kcDelayTimer_12!=0) kcDelayTimer_12++;
//自投开关控制定时器
if(ATZT_TIMER != 0) ATZT_TIMER ++;
if(ATBH_I_Timer != 0)
{
ATBH_I_Timer++;
//防止涌流衰减时间过长
if(ATBH_I_Timer > 2000 && 0 == ATBH_CD_StartIP)
{
ATBH_I_Timer = 0;
}
}
//重合闸延时
if(CHZValue.CHZTime != 0) CHZValue.CHZTime++; //重合闸时间
if(CHZValue.DelayCount != 0) CHZValue.DelayCount++; //合闸延时计数器
//接口记录动作状态
WritePrtcFlagToInf();
//检测重合闸动作
CheckPrtcFlag(ATBH_CHZDZ_LED_KC,1,1,ON);
//CheckAnLedRecord(&CHZDZLEDObject,RECORD_ST_KEEP_TIME);
//检测跳闸动作
CheckPrtcFlag(ATBH_TZ_LED_KC,1,1,ON);
//CheckAnLedRecord(&TZLEDObjdect,RECORD_ST_KEEP_TIME);
//检测自投动作
//temp = CheckAnLedRecord(&ZTDZLEDObject,RECORD_ST_KEEP_TIME);
if(0 == temp)
{
temp = 1;
//初始化时检测到自投动作，动作过，未复归
if(1 == CheckPrtcFlag(ATBH_ZTDZ_LED_KC,1,1,ON))
{
/*if(TEST_CLOSE == ZTDongZuoIP)
{
ZTDongZuoIP = TEST_END;
}*/
//if(YaoXinStatus[ATBH_YAOXIN_ZT]!= ON)
//{
//YaoXinStatus[ATBH_YAOXIN_ZT] = ON;
// RecordSoftYaoXin(ATBH_YAOXIN_ZT,ON);
//}
}
if(1 == CheckPrtcFlag(ATBH_BTGZ_KC,0,0,ON))
{
ZB_fristFaultIndex++;
}
}
if(kcDelayTimer_6 >= 1000)
{
if(OFF != YaoXinStatus[ATBH_YAOXIN_CHZDZ])
{
RecordSoftYaoXin(ATBH_YAOXIN_CHZDZ,OFF);
}
kcDelayTimer_6 = 0;
}
if(ChuanDongTest.TestIP==TEST_CLOSE) //传动实验未完成不操作继电器
{
//开出保护跳闸，测试端子
if(0 != BaoHuChuKouIP && 0 == ATBH_triptest_timer)
{
D_OUT(ATBH_TRIP_TEST_KC,ON);
ATBH_triptest_timer = 1;
}
if(ATBH_triptest_timer > 0)
{
if(ATBH_triptest_timer > 100)
{
if(0 == BaoHuChuKouIP)
{
ATBH_triptest_timer = 0;
}
D_OUT(ATBH_TRIP_TEST_KC,OFF);
}
else
{
ATBH_triptest_timer++;
}
}
if(kcDelayTimer_0>=SLKC_DELAY_TIME)
{
kcDelayTimer_0=0;
D_OUT(ATBH_SL_KC,OFF); //收回断路器失灵开出
}
if(kcDelayTimer_5>=SLKC_DELAY_TIME)
{
kcDelayTimer_5=0;
D_OUT(ATBH_SL2_KC,OFF); //收回断路器2失灵开出
}
if(kcDelayTimer_1>=500)
{
D_OUT(ATBH_CDJQ_KC,OFF);
kcDelayTimer_1=0;
}
if(kcDelayTimer_7>=BHQDKC_DELAY_TIME)
{
D_OUT(ATBH_BHQD_KC,OFF);
kcDelayTimer_7=0;
}
if(kcDelayTimer_2>=WITHDRAW_QFCTRL_MINTIME)
{
if(BCJ_OFF_IP == 1)
{
BCJ_OFF_IP = 0;
kcDelayTimer_2 = 0;
D_OUT(ATBH_BCJQ_KC,OFF);
}
}
if(kcDelayTimer_3>=WITHDRAW_QFCTRL_MINTIME)
{
if(BCJ1_OFF_IP == 1)
{
BCJ1_OFF_IP = 0;
kcDelayTimer_3 = 0;
D_OUT(ATBH_1QS_DD_1QF_TZ_KC,OFF);
}
}
if(kcDelayTimer_4>=WITHDRAW_QFCTRL_MINTIME)
{//
if(BCJ2_OFF_IP == 1)
{
BCJ2_OFF_IP = 0;
kcDelayTimer_4 = 0;
D_OUT(ATBH_2QS_DD_2QF_TZ_KC,OFF);
}
}
//分位、合位灯
#ifdef DEVICE_TYPE_CONVENTIONAL
if(BREAKER_TYPE == ATBH_ATMode)
{
cls_do = ATBH_QF_HW_KR;
open_do = ATBH_QF_FW_KR;
}
else
{
cls_do = ATBH_QS1_HW_KR;
open_do = ATBH_QS1_FW_KR;
}
if(ON == drv_GetInputStatus(cls_do))
{
D_OUT(ATBH_QF_CLS_LED_DO,ON);//断路器合位
}
else
{
D_OUT(ATBH_QF_CLS_LED_DO,OFF);//断路器合位
}
if(ON == drv_GetInputStatus(open_do))
{
D_OUT(ATBH_QF_OPEN_LED_DO,ON);//断路器分位
}
else
{
D_OUT(ATBH_QF_OPEN_LED_DO,OFF);//断路器分位
}
#else
if(ON == YaoXinStatus[ATBH_rmtsignal_run])
{
D_OUT(KX_QF_CLS_LED_DO,ON);//断路器合位
D_OUT(KX_QF_OPEN_LED_DO,OFF);//断路器分位
}
else
{
D_OUT(KX_QF_CLS_LED_DO,OFF);//断路器合位
D_OUT(KX_QF_OPEN_LED_DO,ON);//断路器分位
}
#endif
}
//保护元件计时器管理
if(TZValue.IP!=SUCCESS) return; //在跳闸失灵时，保护元件动作时限判断不执行
RecordChuKouSoe1(&ATBH_CDSDYJ,1); //差动速断
RecordChuKouSoe_CD(&ATBH_CDYJ); //比率差动
RecordChuKouSoe1Plus(&ATBH_SYYJ,1); //失压元件
RecordChuKouSoe_CD(&ATBH_DLLDIFFAYJ);
}
void CheckChongDianTime(void)
{
//重合闸软压板投入
//20190610 L.Y. modi
if(BH_RUN == ATBH_SoftStrap_Reclse && ON == drv_GetInputStatus(ATBH_CHZTR_KR))
{
ATBH_RECLS_ENABLE = BH_RUN;
if(ON != YaoXinStatus[ATBH_YAOXIN_RECLS])
{
RecordSoftYaoXin(ATBH_YAOXIN_RECLS,ON);
}
}
else
{
ATBH_RECLS_ENABLE = BH_STOP;
if(OFF != YaoXinStatus[ATBH_YAOXIN_RECLS])
{
RecordSoftYaoXin(ATBH_YAOXIN_RECLS,OFF);
}
}
//功能说明：重合闸充电时间检测。
if((YaoXinStatus[ATBH_YAOXIN_QF] == ON) && BH_RUN == ATBH_RECLS_ENABLE)
{
//开关在合位且重合闸投入
if(CHZValue.ChongDianTime < ATBH_CHZ_ChongDianTime)
{
CHZValue.ChongDianTime++;
if(CHZValue.ChongDianTime >= ATBH_CHZ_ChongDianTime)
{
CHZValue.ChongDianOK = SUCCESS;
if(ON != YaoXinStatus[ATBH_YAOXIN_CHZRSET])
{
RecordSoftYaoXin(ATBH_YAOXIN_CHZRSET,ON);
}
//重合闸充电灯
if(ChuanDongTest.TestIP == TEST_CLOSE)
{
D_OUT(ATBH_CHZCD_LED_KC, ON); //亮重合闸充电指示灯
}
}
else if(ChuanDongTest.TestIP == TEST_CLOSE)
{
if(((CHZValue.ChongDianTime / 1000) % 2) == 0)
{
D_OUT(ATBH_CHZCD_LED_KC, ON); //亮重合闸充电指示灯
}
else
{
D_OUT(ATBH_CHZCD_LED_KC, OFF); //灭重合闸充电指示灯
}
}
}
}
else
{
if(SUCCESS == CHZValue.ChongDianOK)
{
CHZValue.ChongDianTime++;
//延时10ms
if(CHZValue.ChongDianTime >= (ATBH_CHZ_ChongDianTime + 10))
{
CHZValue.ChongDianTime = 0; //开关不在合位
CHZValue.ChongDianOK = FAIL;
if(OFF != YaoXinStatus[ATBH_YAOXIN_CHZRSET])
{
RecordSoftYaoXin(ATBH_YAOXIN_CHZRSET,OFF);
}
if(ChuanDongTest.TestIP == TEST_CLOSE)
{
D_OUT(ATBH_CHZCD_LED_KC, OFF); //灭重合闸充电指示灯
}
}
}
else
{
CHZValue.ChongDianTime = 0; //开关不在合位
CHZValue.ChongDianOK = FAIL;
if(OFF != YaoXinStatus[ATBH_YAOXIN_CHZRSET])
{
RecordSoftYaoXin(ATBH_YAOXIN_CHZRSET,OFF);
}
if(ChuanDongTest.TestIP == TEST_CLOSE)
{
D_OUT(ATBH_CHZCD_LED_KC, OFF); //灭重合闸充电指示灯
}
}
}
}
void ClearTiaoZhaIP(void)
{
//功能说明：清除跳闸相关标志
QiDongTime=0; //清除保护元件启动时间
BaoHuDongZuoIP=0; //清除保护元件动作标志
//TempBaoHuDongZuoIP=0; //清除保护元件辅助动作标志
BaoHuChuKouIP=0; //清除保护元件出口标志
ATBH_RecloseFlag = 0;
ATBH_CDSDYJ.ChuKouRecordIP=TEST_START; //差动速断
ATBH_CDYJ.ChuKouRecordIP=TEST_START; //比率差动
ATBH_DLLDIFFAYJ.ChuKouRecordIP = TEST_START; //增量差动
//ATBH_SDIYJ.ChuKouRecordIP=TEST_START; //电流速断
//ATBH_IYJ.ChuKouRecordIP=TEST_START; //过电流
//ATBH_JDIYJ.ChuKouRecordIP=TEST_START; //碰壳保护
ATBH_SYYJ.ChuKouRecordIP=TEST_START; //失压元件
//ATBH_FI2YJ.ChuKouRecordIP=TEST_START; //过负荷Ⅱ段元件
}
void RecordYaoXin(void)
{
//功能说明：记录保护元件动作软遥信
if((BaoHuDongZuoIP&ATBH_CDSD_BIT)!=0) RecordSoftYaoXin(ATBH_YAOXIN_CDSD,OFF); //差动速断
if((BaoHuDongZuoIP&ATBH_CD_BIT)!=0) RecordSoftYaoXin(ATBH_YAOXIN_CD,OFF); //差动
if((BaoHuDongZuoIP&ATBH_DLLDIFF_BIT)!=0) RecordSoftYaoXin(ATBH_YAOXIN_DLLDIFF,OFF); //增量差动
//if((BaoHuDongZuoIP&ATBH_SDI_BIT)!=0) RecordSoftYaoXin(ATBH_YAOXIN_SDI,OFF); //电流速断
//if((BaoHuDongZuoIP&ATBH_I_BIT)!=0) RecordSoftYaoXin(ATBH_YAOXIN_I,OFF); //过电流
//if((BaoHuDongZuoIP&ATBH_FI_BIT)!=0) RecordSoftYaoXin(ATBH_YAOXIN_FI2,OFF); //过负荷
//if((BaoHuDongZuoIP&ATBH_JDI_BIT)!=0) RecordSoftYaoXin(ATBH_YAOXIN_JDI,OFF); //碰壳
if((BaoHuDongZuoIP&ATBH_SY_BIT)!=0) RecordSoftYaoXin(ATBH_YAOXIN_SY,OFF); //失压
}
/***********************************************************
* void SaveFault(void)
* 描述：保存故障报告数据
* 历史：创建日期不详
*
***********************************************************/
void SaveFault(int isFaultEnd)
{
unsigned char i,k;
FaultReportType *FaultReport = MemPtrSet.pFaultReport;
RecordYaoXin(); //记录保护元件动作软遥信
i=FaultRecord.RecordIP;
if(FaultRecord.Buffer[i].StatusIP!=TEST_START){
//故障报告缓冲区已满，返回
ClearTiaoZhaIP(); //清除跳闸相关标志
TZValue.FaultProcessEndIP=FAULT_END; //置故障跳闸完成标志
TZValue.DelayCount=0; //清除跳闸延时计数器
return;
}
//故障报告记录
//故障发生时间
//FaultReport->Buffer[i].FaultDate.Msecond=ATBH_Fault_Time.Msecond; //毫秒，2字节，范围：0～59999
//FaultReport->Buffer[i].FaultDate.Minute=ATBH_Fault_Time.Minute; //分，1字节，范围：0～59
//FaultReport->Buffer[i].FaultDate.Hour=ATBH_Fault_Time.Hour; //小时，1字节，范围：0～23
//FaultReport->Buffer[i].FaultDate.Date=ATBH_Fault_Time.Date; //日期，1字节，范围：1～31
//FaultReport->Buffer[i].FaultDate.Month=ATBH_Fault_Time.Month; //月，1字节，范围：1～12
//FaultReport->Buffer[i].FaultDate.Year=ATBH_Fault_Time.Year; //年，2字节，范围：2000～2099
FaultReport->Buffer[i].FaultDate = FaultRecord.Buffer[i].FaultDate; //故障时间
FaultReport->Buffer[i].WaveValue.LBTime = FaultReport->Buffer[i].FaultDate;//录波结束，记录录波时间,与故障时间相同
//断路器号
FaultReport->Buffer[i].DLQNo=ATBH_DLQNo;
//动作标志，2字节
FaultReport->Buffer[i].DongZuoIP=BaoHuDongZuoIP;
//重合闸标志
FaultReport->Buffer[i].ChongZha = ATBH_RecloseFlag;
//故障参数
k = 0;
//参数1：T线电压
FaultReport->Buffer[i].DataBuffer[k++].Value=ATBH_Fault_UT.Value;
//参数2：F线电压
FaultReport->Buffer[i].DataBuffer[k++].Value=ATBH_Fault_UF.Value;
//参数3：T线保护绕组
FaultReport->Buffer[i].DataBuffer[k++].Value=ATBH_Fault_IT.Value;
//参数4：F线保护绕组
FaultReport->Buffer[i].DataBuffer[k++].Value=ATBH_Fault_IF.Value;
if(ISOLATOR_TYPE == ATBH_ATMode)
{
//参数5：T线差动绕组
FaultReport->Buffer[i].DataBuffer[k++].Value=ATBH_Fault_CDIT.Value;
//参数6：F线差动绕组
FaultReport->Buffer[i].DataBuffer[k++].Value=ATBH_Fault_CDIF.Value;
}
//参数7：接地电流
//FaultReport->Buffer[i].DataBuffer[6].Value=ATBH_Fault_IJD.Value;
//参数8：差动电流
FaultReport->Buffer[i].DataBuffer[k++].Value=ATBH_Fault_ICD.Value;
//参数9：制动电流
FaultReport->Buffer[i].DataBuffer[k++].Value=ATBH_Fault_IZD.Value;
//参数10：保护电流二次谐波含量
//FaultReport->Buffer[i].DataBuffer[9].Value=ATBH_Fault_XB2I.Value;
//参数11：差动电流二次谐波含量
FaultReport->Buffer[i].DataBuffer[k++].Value=ATBH_Fault_XB2ICD.Value;
FaultReport->Buffer[i].HasWave=1;//
TZValue.FaultProcessEndIP = FAULT_END; //置故障跳闸完成标志
//清除保护跳闸相关标志
ClearTiaoZhaIP();
TZValue.DelayCount=0; //清除跳闸延时计数器
SetFaultEnd(); //设置故障记录结束标志
//FaultRecord.Buffer[i].StatusIP=TEST_END; //设置故障报告记录结束标志
//SetFaultEnd(); //设置故障记录结束标志
if(0 == isFaultEnd)
{
FaultRecord.Buffer[i].StatusIP = TEST_DELAY; //设置故障报告记录还未处理结束标志
}
else
{
FaultRecord.Buffer[i].StatusIP = TEST_END; //设置故障报告记录结束标志
}
}
/*****************************************
* void SaveFaultTime(void)
* 描述：记录故障发生的时间
* 历史：
*****************************************/
void SaveFaultTime(void)
{
//故障发生时间
ATBH_Fault_Time.Msecond=Clock.Msecond; //毫秒，2字节，范围：0～59999
ATBH_Fault_Time.Minute=Clock.Minute; //分，1字节，范围：0～59
ATBH_Fault_Time.Hour=Clock.Hour; //小时，1字节，范围：0～23
ATBH_Fault_Time.Date=Clock.Date; //日期，1字节，范围：1～31
ATBH_Fault_Time.Month=Clock.Month; //月，1字节，范围：1～12
ATBH_Fault_Time.Year=Clock.Year; //年，2字节，范围：2000～2099
}
/*************************************************
* void SaveFaultData(void)
* 描述：记录保护故障数据
* 历史：
***********************************************/
void SaveFaultData(void)
{
//故障电压（T线电压）
ATBH_Fault_UT.Value=ChannelValue[CH_ATBH_UT].YouXiaoZhi[JiBo].Analog.Value;
//故障电压（F线电压）
ATBH_Fault_UF.Value=ChannelValue[CH_ATBH_UF].YouXiaoZhi[JiBo].Analog.Value;
if(BREAKER_TYPE == ATBH_ATMode)
{
//故障电流（T线保护绕组）
ATBH_Fault_IT.Value=ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[JiBo].Analog.Value;
//故障电流（F线保护绕组）
ATBH_Fault_IF.Value=ChannelValue[CH_ATBH_BH_IF].YouXiaoZhi[JiBo].Analog.Value;
}
else
{
//故障电流（T线保护绕组）
ATBH_Fault_IT.Value=ChannelValue[CH_ATBH_BH_I].YouXiaoZhi[JiBo].Analog.Value;
//故障电流（F线保护绕组）
ATBH_Fault_IF.Value=ChannelValue[CH_ATBH_BH_IF].YouXiaoZhi[JiBo].Analog.Value;
//故障电流（对侧T线保护绕组）
ATBH_Fault_CDIT.Value=ChannelValue[CH_ATBH_CD_IT].YouXiaoZhi[JiBo].Analog.Value;
//故障电流（对侧F线保护绕组）
ATBH_Fault_CDIF.Value=ChannelValue[CH_ATBH_CD_IF].YouXiaoZhi[JiBo].Analog.Value;
}
//故障电流（T线差动绕组）
//ATBH_Fault_CDIT.Value=ChannelValue[CH_ATBH_CD_IT].YouXiaoZhi[JiBo].Analog.Value;
//故障电流（F线差动绕组）
//ATBH_Fault_CDIF.Value=ChannelValue[CH_ATBH_CD_IF].YouXiaoZhi[JiBo].Analog.Value;
//故障电流（接地电流）
//ATBH_Fault_IJD.Value=ChannelValue[CH_ATBH_JDI].YouXiaoZhi[JiBo].Analog.Value;
//故障电流（差动电流）
ATBH_Fault_ICD.Value=ChaDongValue.CDI.Value;
//故障电流（制动电流）
ATBH_Fault_IZD.Value=ChaDongValue.ZDI.Value;
//故障电流（保护二次谐波含量）
//ATBH_Fault_XB2I.Value=ATBH_BaoHu_I2.Value;
//故障电流（差动二次谐波含量）
ATBH_Fault_XB2ICD.Value=ATBH_ChaDong_I2.Value;
}
/****************************************************
* void SetTiaoZha(void)
* 描述：发保护跳闸命令
* 历史：创建日期不详
*
****************************************************/
void SetTiaoZha(void)
{
unsigned int IP;
IP = ATBH_FDL_BIT| ATBH_CDSD_BIT | ATBH_CD_BIT | ATBH_DLLDIFF_BIT;
//判断AT接入方式
if(ATBH_ATMode==BREAKER_TYPE)
{
//断路器接入方式
if(0 != BaoHuChuKouIP)
{
Outlet_trip(ATBH_BCJQ_KC,ON); //发跳闸命令
}
kcDelayTimer_2 = 1;
D_OUT(ATBH_TZ_LED_KC,ON); //驱动跳闸灯
//AT本身故障才发启动信号
if(BaoHuQiDongIP & IP)
{
D_OUT(ATBH_BHQD_KC,ON);
kcDelayTimer_7 = 1;
}
}
else if((ATBH_ATMode==ISOLATOR_TYPE)&&(ATBH_LianJieMode==D_BREAKER_CONNECT))
{
//AT是隔离开关接入方式，且为双断路器并联
//先跳并联断路器
if(0 != BaoHuChuKouIP)
{
Outlet_trip(ATBH_1QS_DD_1QF_TZ_KC,ON);
}
//D_OUT(ATBH_1QS_TZ_KC,ON); //发并联断路器1跳闸命令
D_OUT(ATBH_TZ_LED_KC,ON); //驱动跳闸灯
kcDelayTimer_3 = 1;
//AT本身故障才发启动信号
if(BaoHuQiDongIP & IP)
{
D_OUT(ATBH_BHQD_KC,ON);
kcDelayTimer_7 = 1;
}
//if(YaoXinStatus[ATBH_YAOXIN_GK0]==ON)
//modi by 20240618 LW 并联开关不定态当成合位判断
if(YaoXinStatus[ATBH_YAOXIN_GK0]!=OFF)
{
//D_OUT(ATBH_2QS_TZ_KC,ON); //发并联断路器2跳闸命令
if(0 != BaoHuChuKouIP)
{
Outlet_trip(ATBH_2QS_DD_2QF_TZ_KC,ON);
}
kcDelayTimer_4 = 1;
}
TiaoZhaIP=TEST_START;
}
if(IP & BaoHuDongZuoIP)
{
//记录本体故障
RecordPrtcFlag(ATBH_BTGZ_KC,1,0,0,ON);
}
}
/***************************************************************************************
* unsigned int CheckFW(unsigned int FaultIP)
* 描述：
* 历史：创建时间不详
*
***************************************************************************************/
unsigned int CheckFW(unsigned int FaultIP,unsigned char *FzQFFailIP)
{
unsigned int Key,ip = 0;
CanShuType CanShuValue;
DataType Data;
CanShuValue.Number = 0;
if(ATBH_ATMode==BREAKER_TYPE)
{
//断路器接入方式
if((YaoXinStatus[ATBH_YAOXIN_QF]==OFF)&&(FaultIP == 0) && 0 == check_breaker_err(&ATBH_Breaker_err_param[ATBH_BREAKER_1])) return SUCCESS;
return FAIL;
}
if((ATBH_ATMode==ISOLATOR_TYPE)&&(ATBH_LianJieMode==D_BREAKER_CONNECT))
{
//AT是隔离开关接入方式，且为双断路器并联
switch(TiaoZhaIP)
{
case TEST_START:
ip = check_breaker_err(&ATBH_Breaker_err_param[ATBH_BREAKER_1]);
//检测并联断路器是否处于分位
//if(YaoXinStatus[ATBH_YAOXIN_GK0]==ON)
//modi by 20240618 LW 并联开关不定态当成合位判断
if(YaoXinStatus[ATBH_YAOXIN_GK0]!=OFF)
{
ip += check_breaker_err(&ATBH_Breaker_err_param[ATBH_BREAKER_2]);
if((YaoXinStatus[ATBH_YAOXIN_1QSDD_1QF]==OFF)&&(YaoXinStatus[ATBH_YAOXIN_2QSDD_2QF]==OFF)) Key=1;
else Key=0;
}
else
{
if(YaoXinStatus[ATBH_YAOXIN_1QSDD_1QF]==OFF) Key=1;
else Key=0;
}
if((Key==1)&&(FaultIP == 0) && 0 == ip)
{
//并联断路器处于分位，分AT隔离开关
if(0 != BaoHuChuKouIP)
{
Outlet_trip(ATBH_1QS_BHTZ_KC,ON); //发跳闸命令
}
//#ifdef DEVICE_TYPE_DIGITAL
//D_OUT(ATBH_QF_TZ_KC,ON); //发跳闸命令20140227 luoyang 修改为通过控制跳闸
//#endif
if((kcDelayTimer_3 != 0)&&(kcDelayTimer_3 < WITHDRAW_QFCTRL_MINTIME)) BCJ1_OFF_IP = 1;
else
{
kcDelayTimer_3 = 0;
Outlet_trip(ATBH_1QS_DD_1QF_TZ_KC,OFF); //收回并联断路器1跳闸命令
}
//if(YaoXinStatus[ATBH_YAOXIN_GK0]==ON)
//modi by 20240618 LW 并联开关不定态当成合位判断
if(YaoXinStatus[ATBH_YAOXIN_GK0]!=OFF)
{
if((kcDelayTimer_4 != 0)&&(kcDelayTimer_4 < WITHDRAW_QFCTRL_MINTIME)) BCJ2_OFF_IP = 1;
else
{
kcDelayTimer_4 = 0;
Outlet_trip(ATBH_2QS_DD_2QF_TZ_KC,OFF); //收回并联断路器1跳闸命令
}
}
TiaoZhaIP=TEST_END;
TZValue.DelayCount=1; //启动跳闸延时计时器
return FAIL;
}
//跳断路器失败
if(TZValue.DelayCount>=ATBH_OperationTime)
{
//超时判断
//收回跳闸命令
/*
if((kcDelayTimer_3 != 0)&&(kcDelayTimer_3 < (WITHDRAW_QFCTRL_MINTIME*timeFrac[RatedFreq][0]/timeFrac[RatedFreq][1]))) BCJ1_OFF_IP = 1;// modi 110110/ modi 110129
else
{
kcDelayTimer_3 = 0;
D_OUT(ATBH_1QS_TZ_KC,OFF); //收回并联断路器1跳闸命令
}
if(InPort.Status[ATBH_GK0_KR]==ON)
{//
if((kcDelayTimer_4 != 0)&&(kcDelayTimer_4 < (WITHDRAW_QFCTRL_MINTIME*timeFrac[RatedFreq][0]/timeFrac[RatedFreq][1]))) BCJ2_OFF_IP = 1;// modi 110129
else
{
kcDelayTimer_4 = 0;
D_OUT(ATBH_2QS_TZ_KC,OFF); //收回并联断路器1跳闸命令
}
}
*/
TiaoZhaIP = TEST_CLOSE;
//开关未到位
if(1 != Key)
{
if(OFF != YaoXinStatus[ATBH_YAOXIN_1QSDD_1QF])
{
RecordSOE(ATBH_TRIP1_ERROR,CanShuValue);//跳闸回路异常记录
}
//modi by 20240618 LW 并联开关不定态当成合位判断
//if(ON == YaoXinStatus[ATBH_YAOXIN_GK0] && OFF != YaoXinStatus[ATBH_YAOXIN_2QSDD_2QF])
if(OFF != YaoXinStatus[ATBH_YAOXIN_GK0] && OFF != YaoXinStatus[ATBH_YAOXIN_2QSDD_2QF])
{
RecordSOE(ATBH_TRIP2_ERROR,CanShuValue);//跳闸回路异常记录
}
}
//检测失灵
if(0 != check_breaker_err(&ATBH_Breaker_err_param[ATBH_BREAKER_1]))
{
D_OUT(ATBH_SL_KC,ON); //断路器失灵开出
RecordSOE(ATBH_DLQ1_ERROR,CanShuValue);//断路器失灵
if(kcDelayTimer_0==0) kcDelayTimer_0=1;
}
//if(ON == YaoXinStatus[ATBH_YAOXIN_GK0] && 0 != check_breaker_err(&ATBH_Breaker_err_param[ATBH_BREAKER_2]))
//modi by 20240618 LW 并联开关不定态当成合位判断
if(OFF != YaoXinStatus[ATBH_YAOXIN_GK0] && 0 != check_breaker_err(&ATBH_Breaker_err_param[ATBH_BREAKER_2]))
{
D_OUT(ATBH_SL2_KC,ON); //断路器失灵开出
RecordSOE(ATBH_DLQ2_ERROR,CanShuValue);//断路器失灵
if(kcDelayTimer_5==0) kcDelayTimer_5=1;
}
if(NULL != FzQFFailIP)
{
*FzQFFailIP = TEST_START;
}
return SUCCESS;
}
break;
case TEST_END:
//检测AT隔离开关是否处于分位
if(YaoXinStatus[ATBH_YAOXIN_1QS]==OFF)
{
//分闸成功
Outlet_trip(ATBH_1QS_BHTZ_KC,OFF); //收回AT隔离开关跳闸命令
//#ifdef DEVICE_TYPE_DIGITAL
//D_OUT(ATBH_QF_TZ_KC,OFF); //发跳闸命令20140227 luoyang 修改为通过控制跳闸
//#endif
TiaoZhaIP=TEST_CLOSE;
//printf("here3");
return SUCCESS;
}
if(TZValue.DelayCount>=ATBH_QSOperationTime)
{
//超时判断
//收回跳闸命令
RecordSOE(ATBH_QS_TRIP_FAIL,CanShuValue);
Outlet_trip(ATBH_1QS_BHTZ_KC,OFF); //收回AT隔离开关跳闸命令
if(NULL != FzQFFailIP)
{
*FzQFFailIP = TEST_START;
}
//#ifdef DEVICE_TYPE_DIGITAL
//D_OUT(ATBH_QF_TZ_KC,OFF); //发跳闸命令20140227 luoyang 修改为通过控制跳闸
//#endif
TiaoZhaIP=TEST_CLOSE;
//printf("here4");
return SUCCESS;
}
break;
case TEST_CLOSE:
if(YaoXinStatus[ATBH_YAOXIN_1QS]==OFF) return SUCCESS;
else return FAIL;
default:
TiaoZhaIP=TEST_CLOSE;
return FAIL;
}//endcase
return FAIL;
}
return FAIL;
}
/******************************************************************************
* Function: record_firstfault_end_soe
* Description:记录第一次故障报告结束事件
* Calls: none
* Called By:
* Input:
* Ouput:
* Return:
* others:
* History:
* 1.luoyang created 20210220
*
*******************************************************************************/
static void record_firstfault_end_soe()
{
if(0 == BaoHuQiDongIP)
{
//FaultRecord.Buffer[fristFaultIndex].SOE_EndIP = MemPtrSet.pSoeBuf->WriteIP;
FaultRecord.Buffer[fristFaultIndex].SOE_EndIP = get_protect_soe_write_ip();
}
}
void record_reclose_soe(void)
{
if(TZ_CLOSE != TZValue.Status || CHZ_CLOSE == CHZValue.Status)
{
return; //跳闸未完成，不进行重合闸
}
switch(CHZValue.Status)
{
//重合闸状态
case CHZ_START:
case CHZ_CHECK_DELAY: //检测重合闸延时
case CHZ_SEND_COMMAND: //发合闸命令
case CHZ_CHECK_HW: //检测合位
case CHZ_RESET: //一次重合闸结束
record_firstfault_end_soe();
break;
}//endcase
}
/*****************************************************************************
* void SetRecloseEnd(void)
* 描述: 设置重合闸结束
* 历史: 20180806
******************************************************************************/
void SetRecloseEnd(void)
{
FaultReportType *pFaultReport = MemPtrSet.pFaultReport;
//第一次报告还未送接口记录
if(TEST_DELAY == FaultRecord.Buffer[fristFaultIndex].StatusIP)
{
//拷贝重合闸标志
if(0 != ATBH_RecloseFlag)
{
pFaultReport->Buffer[fristFaultIndex].ChongZha = ATBH_RecloseFlag;
}
record_firstfault_end_soe();
FaultRecord.Buffer[fristFaultIndex].StatusIP = TEST_END;
//QiDongZiTou(pFaultReport->Buffer[fristFaultIndex].DongZuoIP | BaoHuDongZuoIP);
}
//只有后加速出口才记录第二次报告
//if(ATBH_ACC_BIT & BaoHuDongZuoIP)
//{
//重合闸失败，记录第二次故障报告
// SaveFault(1);
//}
//再次清动作标志
//BaoHuDongZuoIP = 0;
}
/***********************************************************
* void FaultProcess(void)
* 描述：检测元件出口，解决非电量跟电量保护同时产生的情况
* 历史：20220114 L.Y.创建
***********************************************************/
void check_prtc_outlet()
{
CanShuType Value;
if(TZ_CHECK_FW != TZValue.Status)
{
return;
}
if(0 == TempBaoHuChuKouIP && 0 != BaoHuChuKouIP)
{
SetTiaoZha(); //发跳闸命令
Value.Number = 0;
RecordSOE(BH_CK,Value); //保护出口事件记录
//重新记录故障参数
SaveFaultData(); //保存故障数据
TZValue.DelayCount=1; //启动跳闸延时计时器
TZValue.Status=TZ_CHECK_FW;
CHZValue.CHZTime = 1; //启动重合闸延时计时器
TempBaoHuChuKouIP = BaoHuChuKouIP;
}
}
/***********************************************************
* void FaultProcess(void)
* 描述：完成故障跳闸功能
* 历史：创建时间不详
***********************************************************/
void FaultProcess(void)
{
CanShuType Value;
int IP;
unsigned char FZQFFailIP = TEST_CLOSE;
unsigned int operationTimeOut;
static int ZB_fault_QDIP = 0;
static int ZB_first_faultIP = ON;
ZB_fault_QDIP = BaoHuQiDongIP & (ATBH_FDL_BIT|ATBH_CDSD_BIT|ATBH_CD_BIT|ATBH_DLLDIFF_BIT);
if(0==ZB_fault_QDIP && ZB_first_faultIP == OFF)
{
ZB_first_faultIP = ON;
}
if(CHZValue.Status != CHZ_CLOSE) return; //在重合闸过程中，返回
Value.Number=0;
switch(TZValue.Status)
{
case TZ_START: //开始跳闸，发跳闸命令
//检测保护元件是否动作
if(BaoHuDongZuoIP!=0)
{
//printf("分位延时 %d,跳闸前变成合位时间%d\n",kcDelayTimer_11,kcDelayTimer_9);
if( ((BaoHuDongZuoIP & ATBH_SY_BIT)==ATBH_SY_BIT) && ( kcDelayTimer_11<2000 ))
{//失压跳闸前2s并联开关处于合位，允许发出检有压重合闸失败后的备自投 2024618 add by L.W.
ZB_SYZT_able=ON;
}
else
{
ZB_SYZT_able=OFF;
}
if(CHZValue.ChongDianOK == SUCCESS)
{
TempQiDongIP |= ATBH_CHZ_CDOK_BIT; //重合闸充电成功
}
else
{
TempQiDongIP &= (~ATBH_CHZ_CDOK_BIT); //重合闸充电失败
}
//有保护元件动作
//if(QiDongTime < 10)
//{
// SaveFaultDataIP=1;
//SaveFaultTime();
//SaveFaultData();
//}
//else
//{
//SaveFaultTime();
SaveFaultData(); //保存故障数据
//}
SetTiaoZha(); //发跳闸命令
if(BaoHuChuKouIP != 0)
{
RecordSOE(BH_CK,Value); //保护出口事件记录
}
TZValue.DelayCount=1; //启动跳闸延时计时器
TZValue.Status=TZ_CHECK_FW;
CHZValue.CHZTime = 1; //启动重合闸延时计时器
TempBaoHuChuKouIP = BaoHuChuKouIP;
}
break;
case TZ_CHECK_FW: //检测分位
check_prtc_outlet(); //检测出口 20220114 added by L.Y.
IP = ~ATBH_FDL_BIT;
if(CheckFW(BaoHuQiDongIP&IP,&FZQFFailIP)==SUCCESS && TEST_CLOSE == FZQFFailIP)
{
//断路器处于分位，并且故障消失
TZValue.IP=SUCCESS; //跳闸成功
TZValue.Status=TZ_RESET; //跳闸结束
if(ATBH_ATMode==BREAKER_TYPE)
{
if((kcDelayTimer_2 != 0)&&(kcDelayTimer_2 < WITHDRAW_QFCTRL_MINTIME)) BCJ_OFF_IP = 1;
else
{
kcDelayTimer_2 = 0;
Outlet_trip(ATBH_BCJQ_KC,OFF); //断路器接入方式,收回跳闸命令
}
}
if(ON == ZB_first_faultIP)
{
Send_QDZT(0);
ZB_first_faultIP = OFF;
}
BaoHuDongZuoFailIP = BaoHuDongZuoIP; //记录最后的动作标志，为重合闸前的判断
return;
}
if(ATBH_ATMode == BREAKER_TYPE) operationTimeOut=ATBH_OperationTime;
else operationTimeOut = ATBH_QSOperationTime+ATBH_OperationTime;
if(TZValue.DelayCount > operationTimeOut || TEST_START == FZQFFailIP)
{
//跳闸超时
TZValue.IP=FAIL; //跳闸失败
#if 0
if((ATBH_ATMode==ISOLATOR_TYPE)&&(ATBH_LianJieMode==D_BREAKER_CONNECT))
{
D_OUT(ATBH_1QS_TZ_KC,ON); //发并联断路器1跳闸命令
kcDelayTimer_3 = 1;
BCJ1_OFF_IP = 0;
if(InPort.Status[ATBH_GK0_KR]==ON)
{
D_OUT(ATBH_2QS_TZ_KC,ON); //发并联断路器2跳闸命令
kcDelayTimer_4 = 1;
BCJ2_OFF_IP = 0;
}
}
#endif
/*if(ATBH_ATMode==BREAKER_TYPE)
{
if((kcDelayTimer_2 != 0)&&(kcDelayTimer_2 < (WITHDRAW_QFCTRL_MINTIME*timeFrac[RatedFreq][0]/timeFrac[RatedFreq][1]))) BCJ_OFF_IP = 1;// modi 110129
else
{
kcDelayTimer_2 = 0;
D_OUT(ATBH_BCJQ_KC,OFF); //断路器接入方式,收回跳闸命令
}
}*/
/*20140605 luoyang modi
D_OUT(ATBH_SL_KC,ON); //断路器失灵开出
RecordSOE(ATBH_DLQ_ERROR,Value);//断路器失灵
if(kcDelayTimer_0==0) kcDelayTimer_0=1;
//RecordSOE(TZ_ERROR,Value); //跳闸回路异常记录
*/
if(ATBH_ATMode==BREAKER_TYPE)
{
if(0 != check_breaker_err(&ATBH_Breaker_err_param[ATBH_BREAKER_1]))
{
D_OUT(ATBH_SL_KC,ON); //断路器失灵开出
RecordSOE(ATBH_DLQ_ERROR,Value);//断路器失灵
if(kcDelayTimer_0==0) kcDelayTimer_0=1;
}
if(OFF != YaoXinStatus[ATBH_YAOXIN_QF])
{
RecordSOE(ATBH_TRIP_ERROR,Value); //跳闸回路异常记录
}
}
TZValue.DelayCount=0; //清除跳闸延时计时器
TZValue.Status=TZ_CLOSE; //关闭跳闸命令
//printf("here1");
ATBH_RecloseFlag = RECLS_STATUS_UNSTART;
ZB_SYZT_able = OFF ;
SaveFault(1); //故障报告记录结束,保存故障报告
return;
}
break;
case TZ_RESET: //跳闸结束
TZValue.Status=TZ_CLOSE; //关闭跳闸命令
TZValue.DelayCount=0; //清除跳闸延时计时器
if(BREAKER_TYPE == ATBH_ATMode && ATBH_SY_BIT == BaoHuDongZuoFailIP)
{
BaoHuDongZuoFailIP = 0;
CHZValue.Status = CHZ_START; //启动重合闸
//CHZValue.CHZTime = 1; //启动重合闸延时计时器
fristFaultIndex = FaultRecord.RecordIP; //保存第一次故障索引20180806
SaveFault(0);
}
else
{
//隔开接入或不是失压跳闸，无重合闸
ATBH_RecloseFlag = RECLS_STATUS_UNSTART;
SaveFault(1); //故障报告记录结束,保存故障报告
}
/*
TZValue.Status = TZ_CLOSE; //关闭跳闸命令
//仅失压跳闸，启动重合闸
if(ATBH_SY_BIT == (BaoHuDongZuoFailIP & ATBH_SY_BIT))
{
//非电量保护没启动的前提下才会启动重合闸
BaoHuDongZuoFailIP = 0;
CHZValue.Status = CHZ_START; //启动重合闸
fristFaultIndex = FaultRecord.RecordIP; //保存第一次故障索引20180806
SaveFault(0);
}
else
{
//BaoHuDongZuoIP |= KX_NO_CHZ_BIT; //20180806 置无重合闸标志
KX_RecloseFlag = RECLS_STATUS_UNSTART;
QiDongZiTou(BaoHuDongZuoIP);
SaveFault(1); //故障报告记录结束,保存故障报告
}
*/
break;
}//end of switch
}
/*****************************************************************************
* void ChongHeZha(void)
* 描述: 实现重合闸功能
* 历史: 创建日期不详
******************************************************************************/
void ChongHeZha(void)
{
CanShuType Value;
if(TZValue.Status != TZ_CLOSE) return; //跳闸未完成，不进行重合闸
/*
if(CHZValue.ClsDwnIP != 0)
{
//发生模拟量通道不良
switch(CHZValue.Status)
{
case CHZ_START:
CHZValue.Status = CHZ_RESET;
break;
case CHZ_CHECK_DELAY:
CHZValue.CHZTime = 0; //清除重合闸延时
CHZValue.Status = CHZ_RESET;
break;
case CHZ_SEND_COMMAND:
D_OUT(ATBH_HCJ_KC, OFF); //收回合闸命令
CHZValue.Status = CHZ_RESET;
break;
case CHZ_CHECK_HW:
if(YaoXinStatus[ATBH_YAOXIN_QF] != OFF)
{
//如果已经合闸
D_OUT(ATBH_HCJ_KC, OFF); //收回合闸命令
D_OUT(ATBH_BCJQ_KC, ON); //发跳闸命令
kcDelayTimer_2 = 1;
BCJ_OFF_IP = 1;
}
else
{
//如果尚未合闸
D_OUT(ATBH_HCJ_KC, OFF); //收回合闸命令
}
CHZValue.Status = CHZ_RESET;
break;
case CHZ_FAULT_CHECK:
D_OUT(ATBH_BCJQ_KC, ON); //发跳闸命令
kcDelayTimer_2 = 1;
BCJ_OFF_IP = 1;
CHZValue.Status = CHZ_RESET;
break;
case CHZ_CHECK_FW:
BCJ_OFF_IP = 1;
CHZValue.Status = CHZ_RESET;
break;
default:
break;
}//end of switch
}//end of if(CHZValue.ClsDwnIP!=0)
*/
Value.Number = 0;
switch(CHZValue.Status)
{
//重合闸状态
case CHZ_START:
//检测重合闸是否投入
if(ATBH_RECLS_ENABLE != BH_RUN)
{
//重合闸未投入
ATBH_RecloseFlag = RECLS_STATUS_UNENABLE; //重合闸未投入
CHZValue.Status = CHZ_RESET; //重合闸结束
RecordSOE(ATBH_RCLSUNENABLE,Value);
return;
}
//检测重合闸充电时间
if((TempQiDongIP & ATBH_CHZ_CDOK_BIT) == 0)
{
//设置无重合闸标志
//无重合闸
ATBH_RecloseFlag = RECLS_STATUS_UNSTART; //重合闸未起动
CHZValue.Status = CHZ_RESET; //重合闸结束
RecordSOE(ATBH_CHZ_NOTCHARGE, Value); //重合闸未充电
return;
}
CHZValue.Status = CHZ_CHECK_DELAY;
break;
case CHZ_CHECK_DELAY: //检测重合闸延时
if(CHZValue.CHZTime < ATBH_CHZ_Time)
{
return; //重合闸时间未到，返回
}
//重合闸时间到
CHZValue.CHZTime = 0; //清除重合闸延时
//检有压
if(!(ATBH_YY_BIT & TempQiDongIP))
{
//无压，闭锁重合闸
//无重合闸
//失压动作引起的保护跳闸，且跳闸前2s并联开关为合位，才允许有压自投
if(ON == ZB_SYZT_able)
{
ZB_SYZT_able =OFF;
Send_QDZT(1);
}
RecordSOE(ATBH_WY_BSCHZ, Value); //无压闭锁重合闸事件
ATBH_RecloseFlag = RECLS_STATUS_UNSTART; //重合闸未起动
CHZValue.Status = CHZ_RESET; //重合闸结束
return;
}
CHZValue.Status = CHZ_SEND_COMMAND;
break;
case CHZ_SEND_COMMAND: //发合闸命令
D_OUT(ATBH_HCJ_KC, ON); //驱动HCJ
D_OUT(ATBH_CHZDZ_LED_KC, ON); //驱动CHZ动作灯 //
#if TESTSHOW
//logMsg("\n\n ******* KX Send CHZ cmd ***********\n\n");
//ShowTime(0);
#endif
RecordSOE(ATBH_CHZCK, Value); //重合闸出口事件记录
if(ON != YaoXinStatus[ATBH_YAOXIN_CHZDZ])
{
RecordSoftYaoXin(ATBH_YAOXIN_CHZDZ,ON);
kcDelayTimer_6 = 1;
}
CHZValue.DelayCount = 1;
CHZValue.Status = CHZ_CHECK_HW;
kcDelayTimer_10 = 0;
break;
case CHZ_CHECK_HW: //检测合位
if(YaoXinStatus[ATBH_YAOXIN_QF] == ON)
{
//断路器处于合位
CHZValue.Status = CHZ_RESET; //故障检测
CHZValue.DelayCount = 0; //启动延时计时器
D_OUT(ATBH_HCJ_KC, OFF); //收回合闸命令
ATBH_RecloseFlag = RECLS_STATUS_SUCCESS; //重合闸成功
#if TESTSHOW
//logMsg("\n\n ******* CHZ: success ,KX_HCJQ_KC Kc OFF ***********\n\n");
//ShowTime(0);
#endif
return;
}
if(CHZValue.DelayCount >= ATBH_OperationTime)
{
//合闸超时
ATBH_RecloseFlag = RECLS_STATUS_FAIL; //重合闸失败
CHZValue.Status = CHZ_RESET; //重合闸结束
D_OUT(ATBH_HCJ_KC, OFF); //收回合闸命令
RecordSOE(ATBH_RCLS_ERROR, Value); //合闸回路异常记录
#if TESTSHOW
//logMsg("\n\n ******* CHZ: timeout ,chz error ***********\n\n");
//ShowTime(0);
#endif
return;
}
//有保护启动，重合闸失败
if(BaoHuQiDongIP != 0)
{
ATBH_RecloseFlag = RECLS_STATUS_FAIL; //重合闸失败
CHZValue.Status = CHZ_RESET; //重合闸结束
D_OUT(ATBH_HCJ_KC, OFF); //收回合闸命令
}
break;
/*
case CHZ_FAULT_CHECK: //故障检测
if(BaoHuQiDongIP != 0)
{
//加30ms延时 20160310 合闸时有干扰导致保护元件启动，合闸成功后后加速出口，在沪昆线发现该问题
if(kcDelayTimer_10 < 30)
{
if(kcDelayTimer_10 == 0)
{
kcDelayTimer_10 = 1;
}
return;
}
kcDelayTimer_10 = 0;
//有故障，发跳闸命令，重合闸失败
ATBH_RecloseFlag = RECLS_STATUS_FAIL; //重合闸失败
BaoHuDongZuoIP |= ATBH_ACC_BIT; //后加速动作标志
SaveFaultData(); //记录第二次故障参数 20180807
D_OUT(ATBH_HCJ_KC, OFF); //收回合闸命令
D_OUT(ATBH_BCJQ_KC, ON); //发跳闸命令
kcDelayTimer_2 = 1;
//后加速出口事件记录
#if TESTSHOW
//logMsg("\n\n ******* CHZ: HJS KC ***********\n\n");
ShowTime(0);
#endif
RecordSOE(ATBH_HJSCK, Value); //后加速出口事件记录
CHZValue.DelayCount = 1; //启动延时计时器
CHZValue.Status = CHZ_CHECK_FW; //检测分位
return;
}
kcDelayTimer_10 = 0;
if(CHZValue.DelayCount >= 3000 )
{
//3000ms无故障，重合闸成功
D_OUT(ATBH_HCJ_KC, OFF); //收回合闸命令
ATBH_RecloseFlag = RECLS_STATUS_SUCCESS; //重合闸成功
CHZValue.DelayCount = 0; //合闸延时计时器
CHZValue.Status = CHZ_RESET; //重合闸结束
return;
}
break;
case CHZ_CHECK_FW: //检测
if((YaoXinStatus[ATBH_YAOXIN_QF] == OFF) && (BaoHuQiDongIP == 0))
{
//断路器处于分位且故障消失
//在20ms内不收回跳闸命令
if((kcDelayTimer_2 != 0) && (kcDelayTimer_2 < WITHDRAW_QFCTRL_MINTIME )) BCJ_OFF_IP = 1;
else
{
kcDelayTimer_2 = 0;
D_OUT(ATBH_BCJQ_KC, OFF); //收回跳闸命令
}
CHZValue.Status = CHZ_RESET; //故障检测
return;
}
if(CHZValue.DelayCount >= ATBH_OperationTime)
{
//分闸超时
//在20ms内不收回跳闸命令
if((kcDelayTimer_2 != 0) && (kcDelayTimer_2 < WITHDRAW_QFCTRL_MINTIME)) BCJ_OFF_IP = 1;
else
{
kcDelayTimer_2 = 0;
D_OUT(ATBH_BCJQ_KC, OFF); //收回跳闸命令
}
//故障量未消失
if(BaoHuQiDongIP != 0)
{
D_OUT(ATBH_SL_KC, ON); //断路器失灵开出
RecordSOE(ATBH_DLQ_ERROR, Value); //断路器失灵
if(kcDelayTimer_0 == 0) kcDelayTimer_0 = 1;
}
//开关未跳开
if(OFF != YaoXinStatus[ATBH_YAOXIN_QF])
{
RecordSOE(ATBH_TRIP_ERROR,Value); //跳闸回路异常记录
}
TZValue.IP = FAIL; //跳闸失败 ,避免再次跳闸 20181022
CHZValue.Status = CHZ_RESET; //重合闸结束
return;
}
break;
*/
case CHZ_RESET: //一次重合闸结束
CHZValue.Status = CHZ_CLOSE; //重合闸状态
CHZValue.CHZTime = 0; //重合闸时间
CHZValue.DelayCount = 0; //合闸延时计时器
kcDelayTimer_10 = 0;
D_OUT(ATBH_HCJ_KC, OFF); //收回合闸命令
//SaveFault(); //故障报告记录结束,保存故障报告
SetRecloseEnd(); //设置重合闸结束
//SaveFault(1); //故障报告记录结束,保存故障报告
break;
}//endcase
}
void JiSuanMeasureValue(void)
{
//功能说明：测量值处理
unsigned int i,j;
int temp,number,basechannel;
float fre,angle_adjust = 0,angle_adjust_curr;
//计算原始采样通道有效值
genera_computemeasure();
if((TempQiDongIP & ATBH_TPTDX_BIT) && !(TempQiDongIP & ATBH_FPTDX_BIT))
{
basechannel = CH_ATBH_UF; //KX_u_transform.channel_curr;
}
else
{
basechannel = CH_ATBH_UT; //KX_u_transform.channel_curr;
}
angle_adjust_curr = angle_amend_value;
if(CH_ATBH_UF == basechannel)
{
angle_adjust = 180;
angle_adjust_curr += 180;
}
//计算角度
genera_computemeasure_angle(basechannel,angle_adjust_curr,angle_adjust);
//计算量
number = MeasureValue.Number / 2;
//频率
temp = basechannel - 7;
ComputeFrequency(&ZcpSet.zcpset[temp],&fre);
MeasureValue.Buffer[ATBH_MX_Fre].Value = fre;
MeasureValue.Buffer[ATBH_MX_Fre].Quality = ChannelValue[basechannel].Quality;
//二次值
temp = number + ATBH_MX_Fre;
MeasureValue.Buffer[temp].Value = fre;
MeasureValue.Buffer[temp].Quality = MeasureValue.Buffer[ATBH_MX_Fre].Quality;
//差动二次谐波含量
MeasureValue.Buffer[ATBH_MX_Id2].Value = ATBH_ChaDong_I2.Value;
MeasureValue.Buffer[ATBH_MX_Id2].Quality = ChannelValue[CH_ATBH_BH_I].Quality;
temp = number + ATBH_MX_Id2;
//二次值
MeasureValue.Buffer[temp].Value = MeasureValue.Buffer[ATBH_MX_Id2].Value;
MeasureValue.Buffer[temp].Quality = MeasureValue.Buffer[ATBH_MX_Id2].Quality;
if(SETVALUE_MODE_1 == DisplayMode)
{
//差动电流
MeasureValue.Buffer[ATBH_MX_IDIFF].Value = ChaDongValue.CDI.Value;
MeasureValue.Buffer[ATBH_MX_IDIFF].Quality = ChannelValue[CH_ATBH_BH_I].Quality;
//二次差动电流
temp = number + ATBH_MX_IDIFF;
MeasureValue.Buffer[temp].Value = MeasureValue.Buffer[ATBH_MX_IDIFF].Value / ChannelValue[CH_ATBH_BH_I].BianBi;
MeasureValue.Buffer[temp].Quality = MeasureValue.Buffer[ATBH_MX_IDIFF].Quality;
//制动电流
MeasureValue.Buffer[ATBH_MX_IREST].Value = ChaDongValue.ZDI.Value;
MeasureValue.Buffer[ATBH_MX_IREST].Quality = ChannelValue[CH_ATBH_BH_I].Quality;
//二次制动电流
temp = number + ATBH_MX_IREST;
MeasureValue.Buffer[temp].Value = MeasureValue.Buffer[ATBH_MX_IREST].Value / ChannelValue[CH_ATBH_BH_I].BianBi;
MeasureValue.Buffer[temp].Quality = MeasureValue.Buffer[ATBH_MX_IREST].Quality;
}
else
{
//差动电流
temp = number + ATBH_MX_IDIFF;
MeasureValue.Buffer[temp].Value = ChaDongValue.CDI.Value;
MeasureValue.Buffer[temp].Quality = ChannelValue[CH_ATBH_BH_I].Quality;
//一次差动电流
MeasureValue.Buffer[ATBH_MX_IDIFF].Value = MeasureValue.Buffer[temp].Value * ChannelValue[CH_ATBH_BH_I].BianBi;
MeasureValue.Buffer[ATBH_MX_IDIFF].Quality = MeasureValue.Buffer[temp].Quality;
//制动电流
temp = number + ATBH_MX_IREST;
MeasureValue.Buffer[temp].Value = ChaDongValue.ZDI.Value;
MeasureValue.Buffer[temp].Quality = ChannelValue[CH_ATBH_BH_I].Quality;
//一次差动电流
MeasureValue.Buffer[ATBH_MX_IREST].Value = MeasureValue.Buffer[temp].Value * ChannelValue[CH_ATBH_BH_I].BianBi;
MeasureValue.Buffer[ATBH_MX_IREST].Quality = MeasureValue.Buffer[temp].Quality;
}
//装置时间
MeasureValue.Time.Msecond=Clock.Msecond; //毫秒，2字节，范围：0～59999
MeasureValue.Time.Minute=Clock.Minute; //分，1字节，范围：0～59
MeasureValue.Time.Hour=Clock.Hour; //小时，1字节，范围：0～23
MeasureValue.Time.Date=Clock.Date; //日期，1字节，范围：1～31
MeasureValue.Time.Month=Clock.Month; //月，1字节，范围：1～12
MeasureValue.Time.Year=Clock.Year; //年，2字节，范围：2000～2099
}
/**********************************************************
* void atbh_main(void)
* 描述: 保护与接口交互任务入口函数
* 历史: 创建日期不详
*
***********************************************************/
void maintask(void)
{
ProcessFaultReport(); //处理故障报告
SysResetSoeRecord(); //系统复位事件记录
CopyYaoXinBianWei(); //拷贝遥信
digit_mainTask();
ComputeAnalogTrueRms(&ZcpSet);
if(MeasureSendDelay >= MEASURE_SEND_DELAY_TIME)
{
JiSuanMeasureValue(); //计算测量值
SendMeasureValue(); //发送测量值 测量值改为队列，就不需要给接口发命令，这个函数就没必要使用了
}
SendGetTimeCommand();
ReceiveData(); //接收数据
ProcessASDU(); //处理接收数据
//SendData(); //往实时库发送数据
//AT_ZT_TaskCreate();
setValueSelfCheck();
#ifdef DEVICE_TYPE_DIGITAL
//CheckIOYaoXin(IO_TYPE_IN20_OUT6,0); //检测记录IO自检软遥信 luoyang add
//CheckIOYaoXin(IO_TYPE_IN20_OUT6,1); //检测记录IO自检软遥信 lw add
#else
//CheckIOYaoXinEx(IO_TYPE_IN30_OUT0,0); //检测记录IO自检软遥信
//CheckIOYaoXinEx(IO_TYPE_IN30_OUT0,1); //检测记录IO自检软遥信
//CheckIOYaoXinEx(IO_TYPE_IN0_OUT16,2); //检测记录IO自检软遥信
#endif
//检测遥控控制字
CheckRemote_ryb();
//检测软压板控制
CheckSoftStrapCtrl();
//公共轮询
main_polling();
if(LS_TR == ATBH_LS)
{
block_CalcStatus();
}
}
/******************************************************************************
* Function: ATZTDongZuo
* Description:投退处理
* Calls: none
* Called By:
* Input:
* Ouput:
* Return:
* others:
* History:
* 1.luoyang created
*
*******************************************************************************/
void ATZTDongZuo(void)
{
static int ZTStep = 0;
CanShuType CanShuValue;
int ZTRst;
CanShuValue.Number = 0;
//printf("ZTDongZuoIP = %d,ZTStep = %d",ZTDongZuoIP,ZTStep);
if(ZTDongZuoIP==TEST_START)
{
//检测AT是否处于退出状态
//if(YaoXinStatus[ATBH_rmtsignal_run] != OFF || 0 != BaoHuQiDongIP)
//{
// ZTDongZuoIP = TEST_CLOSE; //自投结束
// return; //AT不处于退出状态，返回
//}
//if(YaoXinStatus[ATBH_YAOXIN_GK0] != ON)
//{
// ZTDongZuoIP = TEST_CLOSE; //自投结束
// return;
//}
D_OUT(ATBH_ZTDZ_LED_KC,ON); //驱动自投动作灯
RecordSOE(ATBH_ZT_START,CanShuValue);
//RecordSoftYaoXin(ATBH_YAOXIN_ZT,ON); //记录自投软遥信
ZTDongZuoIP = TEST_DELAY; //标明自投状态
ATZT_TIMER = 0;
ZTStep = 1;
}
if(TEST_DELAY != ZTDongZuoIP)
{
return;
}
if(BREAKER_TYPE == ATBH_ATMode)
{
switch(ZTStep)
{
case 0:
if(ON != YaoXinStatus[ATBH_YAOXIN_AT_SWITCH_FAIL])
{
RecordSoftYaoXin(ATBH_YAOXIN_AT_SWITCH_FAIL,ON);
}
RecordSOE(ATBH_ZT_FAIL,CanShuValue); //AT自投失败事件记录
ZTDongZuoIP = TEST_END; //自投结束
break;
case 1:
ZTRst = SwitchContrl(ATBH_ZT_QS,ON,&ATZT_TIMER,ISOLATOR_TYPE);
//自投过程中发生故障，直接退出
if(0 != BaoHuQiDongIP)
{
D_OUT(RemoteObject.Object[ATBH_ZT_QS].Out_On_No,OFF);
//RecordSOE(ATBH_ZT_FAIL,CanShuValue); //AT自投失败
ZTStep = 0;
return;
}
//失败
if(TEST_CLOSE == ZTRst)
{
//RecordSOE(ATBH_ZT_FAIL,CanShuValue); //AT自投失败
ZTStep = 0;
}
//成功
else if(TEST_END == ZTRst)
{
ZTStep = 2;
}
break;
case 2:
ZTRst = SwitchContrl(ATBH_ZT_QF,ON,&ATZT_TIMER,BREAKER_TYPE);
//自投过程中发生故障，直接退出
if(0 != BaoHuQiDongIP)
{
D_OUT(RemoteObject.Object[ATBH_ZT_QF].Out_On_No,OFF);
//RecordSOE(ATBH_ZT_FAIL,CanShuValue); //AT自投失败
ZTStep = 0;
return;
}
//失败
if(TEST_CLOSE == ZTRst)
{
//RecordSOE(ATBH_ZT_FAIL,CanShuValue); //AT自投失败
ZTStep = 0;
}
//成功
else if(TEST_END == ZTRst)
{
ZTStep = 3;
}
break;
//自投成功
case 3:
RecordSOE(ATBH_ZT_OK,CanShuValue); //AT自投成功
if(ON != YaoXinStatus[ATBH_YAOXIN_AT_SWITCH_SUCCESS])
{
RecordSoftYaoXin(ATBH_YAOXIN_AT_SWITCH_SUCCESS,ON);
}
ZTDongZuoIP = TEST_END; //自投结束
break;
}
}
else if(ISOLATOR_TYPE == ATBH_ATMode)
{
if(D_BREAKER_CONNECT != ATBH_LianJieMode)
{
//RecordSOE(ATBH_ZT_FAIL,CanShuValue); //AT自投失败事件记录
ZTStep = 0; //自投结束
}
switch(ZTStep)
{
case 0:
if(ON != YaoXinStatus[ATBH_YAOXIN_AT_SWITCH_FAIL])
{
RecordSoftYaoXin(ATBH_YAOXIN_AT_SWITCH_FAIL,ON);
}
RecordSOE(ATBH_ZT_FAIL,CanShuValue); //AT自投失败事件记录
ZTDongZuoIP = TEST_END; //自投结束
break;
//分1QS
case 1:
ZTRst = SwitchContrl(ATBH_ZT_1QF,OFF,&ATZT_TIMER,BREAKER_TYPE);
//失败
if(TEST_CLOSE == ZTRst)
{
//RecordSOE(ATBH_ZT_FAIL,CanShuValue); //AT自投失败
ZTStep = 0;
}
//成功
else if(TEST_END == ZTRst)
{
ZTStep = 2;
}
break;
//分2QS
case 2:
ZTRst = SwitchContrl(ATBH_ZT_2QF,OFF,&ATZT_TIMER,BREAKER_TYPE);
//失败
if(TEST_CLOSE == ZTRst)
{
//RecordSOE(ATBH_ZT_FAIL,CanShuValue); //AT自投失败
ZTStep = 0;
}
//成功
else if(TEST_END == ZTRst)
{
ZTStep = 3;
}
break;
//并联断路器处于分位，合AT隔离开关
case 3:
ZTRst = SwitchContrl(ATBH_ZT_QS,ON,&ATZT_TIMER,ISOLATOR_TYPE);
//自投过程中发生故障，直接退出
if(0 != BaoHuQiDongIP)
{
D_OUT(RemoteObject.Object[ATBH_ZT_QS].Out_On_No,OFF);
//RecordSOE(ATBH_ZT_FAIL,CanShuValue); //AT自投失败
ZTStep = 0;
return;
}
//失败
if(TEST_CLOSE == ZTRst)
{
//RecordSOE(ATBH_ZT_FAIL,CanShuValue); //AT自投失败
ZTStep = 0;
}
//成功
else if(TEST_END == ZTRst)
{
ZTStep = 4;
}
break;
//合并联断路器
case 4:
ZTRst = SwitchContrl(ATBH_ZT_1QF,ON,&ATZT_TIMER,BREAKER_TYPE);
//自投过程中发生故障，直接退出
if(0 != BaoHuQiDongIP)
{
D_OUT(RemoteObject.Object[ATBH_ZT_1QF].Out_On_No,OFF);
//RecordSOE(ATBH_ZT_FAIL,CanShuValue); //AT自投失败
ZTStep = 0;
return;
}
//失败
if(TEST_CLOSE == ZTRst)
{
ZTStep = 5;
}
//成功
else if(TEST_END == ZTRst)
{
ZTStep = 6;
}
break;
//合并联断路器失败
//分AT隔离开关
case 5:
ZTRst = SwitchContrl(ATBH_ZT_QS,OFF,&ATZT_TIMER,ISOLATOR_TYPE);
if(TEST_DELAY != ZTRst)
{
//RecordSOE(ATBH_ZT_FAIL,CanShuValue); //AT自投失败
ZTStep = 0;
}
break;
//合2QS
case 6:
ZTRst = SwitchContrl(ATBH_ZT_2QF,ON,&ATZT_TIMER,BREAKER_TYPE);
//自投过程中发生故障，直接退出
if(0 != BaoHuQiDongIP)
{
D_OUT(RemoteObject.Object[ATBH_ZT_2QF].Out_On_No,OFF);
//RecordSOE(ATBH_ZT_FAIL,CanShuValue); //AT自投失败
ZTStep = 0;
return;
}
//失败
if(TEST_CLOSE == ZTRst)
{
//分1QS
ZTStep = 7;
}
//自投成功
else if(TEST_END == ZTRst)
{
//RecordSOE(ATBH_ZT_OK,CanShuValue); //AT自投成功
ZTStep = 9;
}
break;
//合2QS失败
//分1QS
case 7:
ZTRst = SwitchContrl(ATBH_ZT_1QF,OFF,&ATZT_TIMER,BREAKER_TYPE);
//失败
if(TEST_CLOSE == ZTRst)
{
ZTStep = 0;
//RecordSOE(ATBH_ZT_FAIL,CanShuValue); //AT自投失败
}
//成功
else if(TEST_END == ZTRst)
{
ZTStep = 8;
}
break;
//分AT隔离开关
case 8:
ZTRst = SwitchContrl(ATBH_ZT_QS,OFF,&ATZT_TIMER,ISOLATOR_TYPE);
if(TEST_DELAY != ZTRst)
{
//RecordSOE(ATBH_ZT_FAIL,CanShuValue); //AT自投失败
ZTStep = 0;
}
break;
case 9:
if(ON != YaoXinStatus[ATBH_YAOXIN_AT_SWITCH_SUCCESS])
{
RecordSoftYaoXin(ATBH_YAOXIN_AT_SWITCH_SUCCESS,ON);
}
RecordSOE(ATBH_ZT_OK,CanShuValue); //AT自投成功
ZTDongZuoIP = TEST_END; //自投结束
break;
default:
ZTStep = 0;
break;
}
}
else
{
if(ON != YaoXinStatus[ATBH_YAOXIN_AT_SWITCH_FAIL])
{
RecordSoftYaoXin(ATBH_YAOXIN_AT_SWITCH_FAIL,ON);
}
RecordSOE(ATBH_ZT_FAIL,CanShuValue); //AT自投失败事件记录
ZTDongZuoIP=TEST_END; //自投结束
}
if(ZTDongZuoIP == TEST_END) //自投结束
ZTDongZuoIP = TEST_CLOSE ;
}
/******************************************************************************
* Function: SoftReset
* Description:软件复归，遥控、复归按钮等
* Calls: none
* Called By:
* Input: RstMode复归方式 FG_MODE_YK-遥控复归 FG_MODE_AN-按钮复归
* Ouput:
* Return:
* others:
* History:
* 1.luoyang created
*
*******************************************************************************/
void SoftReset(unsigned char RstMode)
{
CanShuType CanShuValue;
CanShuValue.Number = 0;
//遥控复归
if(FG_MODE_YK == RstMode)
{
RecordSOE(FG_YK, CanShuValue);
}
//手动复归
else if(FG_MODE_SD == RstMode)
{
RecordSOE(FG_AN, CanShuValue);
}
//复位跳闸灯、重合闸动作灯
//复位跳闸灯
D_OUT(ATBH_TZ_LED_KC,OFF);
D_OUT(ATBH_CHZDZ_LED_KC,OFF);
//复位偷跳遥信
dl_open_innormal_reset(&ATBH_dl_open_innormal_param);
RecordPrtcFlag(ATBH_BTGZ_KC,1,0,0,OFF);
ZB_fristFaultIndex = 0;
//复位自投动作灯
//printf("ZTDongZuoIP = %d,InPort.Status[ATBH_QDZT_KR] = %d",ZTDongZuoIP,InPort.Status[ATBH_QDZT_KR]);
if(TEST_END == ZTDongZuoIP || TEST_CLOSE == ZTDongZuoIP)
{
//if(OFF != YaoXinStatus[ATBH_YAOXIN_ZT])
//{
// RecordSoftYaoXin(ATBH_YAOXIN_ZT,OFF);//记录自投软遥信
//}
if(OFF != YaoXinStatus[ATBH_YAOXIN_AT_SWITCH_SUCCESS])
{
RecordSoftYaoXin(ATBH_YAOXIN_AT_SWITCH_SUCCESS,OFF);
}
if(OFF != YaoXinStatus[ATBH_YAOXIN_AT_SWITCH_FAIL])
{
RecordSoftYaoXin(ATBH_YAOXIN_AT_SWITCH_FAIL,OFF);
}
D_OUT(ATBH_ZTDZ_LED_KC,OFF);//自投复归熄灭自投动作灯
ZTDongZuoIP=TEST_CLOSE; //自投复归
}
}
void StartTiaoZha_atbh(void)
{
unsigned int IP,mask = 0;
CanShuType CanShu;
CanShu.Number = 0;
//功能说明：启动跳闸程序
//IP = 0xffffffff;
/*
if(BH_RUN == ATBH_nonui_prtc_trip)
{
mask = 0;
}
else
{
mask = ATBH_FDL_BIT;
}
*/
//IP = recover_failure_trip(ATBH_FDL_BIT,ATBH_nonui_prtc_trip);
if(FAIL == TZValue.IP && 0 != recover_failure_trip(ATBH_FDL_BIT,ATBH_nonui_prtc_trip))
{
//在跳闸失灵的情况下，保护已返回，清除动作标志
if(kcDelayTimer_2 != 0)
{
if(kcDelayTimer_2 < WITHDRAW_QFCTRL_MINTIME ) BCJ_OFF_IP = 1;
else
{
kcDelayTimer_2 = 0;
Outlet_trip(ATBH_BCJQ_KC, OFF); //收回跳闸命令
}
}
if(kcDelayTimer_3 != 0)
{
if(kcDelayTimer_3 < WITHDRAW_QFCTRL_MINTIME ) BCJ1_OFF_IP = 1;
else
{
kcDelayTimer_3 = 0;
Outlet_trip(ATBH_1QS_DD_1QF_TZ_KC, OFF); //收回跳闸命令
}
}
if(kcDelayTimer_4 != 0)
{
if(kcDelayTimer_4 < WITHDRAW_QFCTRL_MINTIME ) BCJ2_OFF_IP = 1;
else
{
kcDelayTimer_4 = 0;
Outlet_trip(ATBH_2QS_DD_2QF_TZ_KC, OFF); //收回跳闸命令
}
}
TZValue.IP = SUCCESS;
QiDongTime = 0;
}
if((TZValue.Status == TZ_CLOSE) && (TZValue.IP == SUCCESS) && (BaoHuDongZuoIP != 0) && (TZValue.DelayCount == 0))
{
//跳闸未启动，上次跳闸已成功
TZValue.Status = TZ_START;
TZValue.FaultProcessEndIP = FAULT_START; //置故障开始标志
}
}
/******************************************************************************
* Function: HSV_PhaseToLine
* Description:将高压侧相电压转化为线电压
* Calls: none
* Called By:
* Input:
* Ouput:
* Return:
* others:
* History:
* 1.luoyang created 2017-05-08
*
******************************************************************************/
void SaveWave_Id()
{
int i,readIP;
int smpval_t,smpval_f,smpval_d;
for(i = 0; i < LoadWave.LengthOfNewData;i++)
{
readIP = (LoadWave.IP_last + i + REALWAVE_LEN - 1) % (REALWAVE_LEN);
//if(BREAKER_TYPE == ATBH_ATMode || (ISOLATOR_TYPE == ATBH_ATMode && ON != YaoXinStatus[ATBH_YAOXIN_GK0]))
//modi by 20240618 LW 并联开关不定态当成合位判断
if(BREAKER_TYPE == ATBH_ATMode || (ISOLATOR_TYPE == ATBH_ATMode && OFF == YaoXinStatus[ATBH_YAOXIN_GK0]))
{
smpval_d = LoadWave.Buffer[ATBH_BH_I_WAVE][readIP] - LoadWave.Buffer[ATBH_BH_IF_WAVE][readIP];
LoadWave.Buffer[ATBH_IDIFF_WAVE][readIP] = (short int)smpval_d;
}
else
{
smpval_t = LoadWave.Buffer[ATBH_BH_I_WAVE][readIP] + LoadWave.Buffer[ATBH_DC_IT_WAVE][readIP];
smpval_f = LoadWave.Buffer[ATBH_BH_IF_WAVE][readIP] + LoadWave.Buffer[ATBH_DC_IF_WAVE][readIP];
LoadWave.Buffer[ATBH_IDIFF_WAVE][readIP] = (short int)(smpval_t - smpval_f);
}
}
}
void SaveFaultWave_Id(FaultItemType *pBuffer)
{
int i;
int smpval_t,smpval_f,smpval_d;
for(i = 0; i < pBuffer->WaveValue.ChannelData[ATBH_BH_I_WAVE].Length;i++)
{
//if(BREAKER_TYPE == ATBH_ATMode || (ISOLATOR_TYPE == ATBH_ATMode && ON != YaoXinStatus[ATBH_YAOXIN_GK0]))
//modi by 20240618 LW 并联开关不定态当成合位判断
if(BREAKER_TYPE == ATBH_ATMode || (ISOLATOR_TYPE == ATBH_ATMode && OFF == YaoXinStatus[ATBH_YAOXIN_GK0]))
{
smpval_d = pBuffer->WaveValue.ChannelData[ATBH_BH_I_WAVE].Data[i] - pBuffer->WaveValue.ChannelData[ATBH_BH_IF_WAVE].Data[i];
pBuffer->WaveValue.ChannelData[ATBH_IDIFF_WAVE].Data[i] = (short int)smpval_d;
}
else
{
smpval_t = pBuffer->WaveValue.ChannelData[ATBH_BH_I_WAVE].Data[i] + pBuffer->WaveValue.ChannelData[ATBH_DC_IT_WAVE].Data[i];
smpval_f = pBuffer->WaveValue.ChannelData[ATBH_BH_IF_WAVE].Data[i] + pBuffer->WaveValue.ChannelData[ATBH_DC_IF_WAVE].Data[i];
pBuffer->WaveValue.ChannelData[ATBH_IDIFF_WAVE].Data[i] = (short int)(smpval_t - smpval_f);
}
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink