#include "..\h\predefine.h" #ifdef _atbh_c_ /*SYS relational*/ #include #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