linwei/protect_source
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
protect_source/4.0标准版/src/kx/init_kx.c
linwei_sources 7ca6df9e6a 标准版
2025-06-26 15:28:05 +08:00

3473 lines
120 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 _kx_c_
//#undef _kx_c_
#include <math.h>
#include <stdio.h>
#include ".\inc\kx.h"
#include "..\h\lib.h"
#include "..\h\variable.h"
//#include "..\digit_protect\inc\digit_protect_inoutcode.h"
//#include "..\digit_protect\block\InterLock.h"
//#include "..\byqc\zt\byqc_zt.h"
#include ".\inc\parameter_kx.h"
#include ".\inc\analog_kx.h"
#include ".\inc\inout_kx.h"
void Reset_Init(void);
unsigned int CheckUserSetting(unsigned char *Address);
unsigned int CheckSysSetting(unsigned char *Address);
unsigned int ScaleAnalogChannel(unsigned char Number, float Parameter); //刻度校正
float checkUIScale(float Parameter, unsigned char ChNo); //
void InitProtectItem(void);
void InitAnalogChannel(void);
void InitOutStatus(void);
unsigned int GetSysSetting(void);
unsigned int GetUserSetting(unsigned int Number);
void InitRemoteObject(void);
void yaoXinSetInitial(void);//遥信配置初始化
unsigned int usrSetValueCheckSum(void);
unsigned int sysSetValueCheckSum(void);
void kx_itemClsDwnManageInit();
extern int CheckYBStatus(unsigned int YaoXinNo,unsigned int YBStatus);
extern void AninChannalCoeffInit();
extern float UIScaleCheck(float Parameter, unsigned char ChNo);
extern void AninChannallCoeff_SV_init();
void KX_ContactSignalInit();
void kx_u_param_init();
/************************************************************************
* void InitProtectItem(void)
* 保护元件初始化
*************************************************************************/
void InitProtectItem(void)
{
static int isPowerOnInit = 1;
// 阻抗1段元件
KX_Z1YJ.ClsDwnIP = 0;
KX_Z1YJ.TouRuIP = KX_Z1TouRu;
KX_Z1YJ.SetData = &KX_Z1Set;
KX_Z1YJ.MeasureValue = &KX_ZKValue;
KX_Z1YJ.QiDongBit = KX_Z1_BIT;
KX_Z1YJ.IPAddress = &BaoHuQiDongIP;
KX_Z1YJ.SoeRecordIP = TEST_START;
KX_Z1YJ.ChuKouRecordIP = TEST_START;
KX_Z1YJ.QiDongCode = KX_Z1_QD;
KX_Z1YJ.ChuKouCode = KX_Z1_CK;
KX_Z1YJ.FanHuiCode = KX_Z1_FH;
KX_Z1YJ.TimeValue = 0;
KX_Z1YJ.YaoXinNumber = KX_YAOXIN_Z1;
// 阻抗2段元件
KX_Z2YJ.ClsDwnIP = 0;//
KX_Z2YJ.TouRuIP = KX_Z2TouRu;
KX_Z2YJ.SetData = &KX_Z2Set;
KX_Z2YJ.MeasureValue = &KX_ZKValue;
KX_Z2YJ.QiDongBit = KX_Z2_BIT;
KX_Z2YJ.IPAddress = &BaoHuQiDongIP;
KX_Z2YJ.SoeRecordIP = TEST_START;
KX_Z2YJ.ChuKouRecordIP = TEST_START;
KX_Z2YJ.QiDongCode = KX_Z2_QD;
KX_Z2YJ.ChuKouCode = KX_Z2_CK;
KX_Z2YJ.FanHuiCode = KX_Z2_FH;
KX_Z2YJ.TimeValue = 0;
KX_Z2YJ.YaoXinNumber = KX_YAOXIN_Z2;
// 阻抗3段元件
KX_Z3YJ.ClsDwnIP = 0;
KX_Z3YJ.TouRuIP = KX_Z3TouRu;
KX_Z3YJ.SetData = &KX_Z3Set;
KX_Z3YJ.MeasureValue = &KX_ZKValue;
KX_Z3YJ.QiDongBit = KX_Z3_BIT;
KX_Z3YJ.IPAddress = &BaoHuQiDongIP;
KX_Z3YJ.SoeRecordIP = TEST_START;
KX_Z3YJ.ChuKouRecordIP = TEST_START;
KX_Z3YJ.QiDongCode = KX_Z3_QD;
KX_Z3YJ.ChuKouCode = KX_Z3_CK;
KX_Z3YJ.FanHuiCode = KX_Z3_FH;
KX_Z3YJ.TimeValue = 0;
KX_Z3YJ.YaoXinNumber = KX_YAOXIN_Z3;
// 电流速断元件
KX_SDIYJ.ClsDwnIP = 0;
KX_SDIYJ.TouRuIP = KX_SDITouRu;
KX_SDIYJ.Type = GL_TYPE;
KX_SDIYJ.SetData = &KX_SDISet;
KX_SDIYJ.MeasureValue = &KX_BaoHu_I;
KX_SDIYJ.QiDongBit = KX_SDI_BIT;
KX_SDIYJ.IPAddress = &BaoHuQiDongIP;
KX_SDIYJ.SoeRecordIP = TEST_START;
KX_SDIYJ.ChuKouRecordIP = TEST_START;
KX_SDIYJ.QiDongCode = KX_SDI_QD;
KX_SDIYJ.ChuKouCode = KX_SDI_CK;
KX_SDIYJ.FanHuiCode = KX_SDI_FH;
KX_SDIYJ.TimeValue = 0;
KX_SDIYJ.YaoXinNumber = KX_YAOXIN_SDI;
KX_SDIYJ.SoeParam.paramnum = 1;
KX_SDIYJ.SoeParam.paramset[0] = &KX_BaoHu_I;
// 过电流元件
KX_IYJ.ClsDwnIP = 0;
KX_IYJ.TouRuIP = KX_ITouRu;
KX_IYJ.Type = GL_TYPE;
KX_IYJ.SetData = &KX_ISet;
KX_IYJ.MeasureValue = &KX_BaoHu_I;
KX_IYJ.QiDongBit = KX_I_BIT;
KX_IYJ.IPAddress = &BaoHuQiDongIP;
KX_IYJ.SoeRecordIP = TEST_START;
KX_IYJ.ChuKouRecordIP = TEST_START;
KX_IYJ.QiDongCode = KX_I_QD;
KX_IYJ.ChuKouCode = KX_I_CK;
KX_IYJ.FanHuiCode = KX_I_FH;
KX_IYJ.TimeValue = 0;
KX_IYJ.YaoXinNumber = KX_YAOXIN_I;
KX_IYJ.SoeParam.paramnum = 1;
KX_IYJ.SoeParam.paramset[0] = &KX_BaoHu_I;
//母线保护元件
//进线
//20180910 新增
KX_BusPrtcYJ.ClsDwnIP = 0;
if(SSP_JX == KX_PositionSet && INLINE_RUNMODE_SIGNAL == KX_JXRunMode)
{
//开闭所且单进线运行
KX_BusPrtcYJ.TouRuIP = KX_BusPrtcTouRu; //保护元件投入标志
}
else
{
KX_BusPrtcYJ.TouRuIP = BH_STOP; //保护元件投入标志
}
//KX_BusPrtcYJ.Type = QL_TYPE; //过量元件
KX_BusPrtcYJ.SetData = &KX_PwrSecPrtcSet; //定值
KX_BusPrtcYJ.MeasureValue = &KX_ZKValue; //保护电量
KX_BusPrtcYJ.QiDongBit = KX_BUSPRTC_BIT; //标志位
KX_BusPrtcYJ.IPAddress = &BaoHuQiDongIP; //启动标志
KX_BusPrtcYJ.SoeRecordIP = TEST_START; //Soe记录标志
KX_BusPrtcYJ.ChuKouRecordIP = TEST_START; //出口记录标志
KX_BusPrtcYJ.QiDongCode = KX_BUSPRTC_QD; //启动事件
KX_BusPrtcYJ.ChuKouCode = KX_BUSPRTC_CK; //出口事件
KX_BusPrtcYJ.FanHuiCode = KX_BUSPRTC_FH; //返回事件
KX_BusPrtcYJ.TimeValue = 0; //计数器
KX_BusPrtcYJ.YaoXinNumber = KX_YAOXIN_BUSPRTC; //对应保护 遥信
// 电流增量元件
KX_DLTIYJ.ClsDwnIP = 0;
KX_DLTIYJ.TouRuIP = KX_DLTITouRu;
KX_DLTIYJ.Type = GL_TYPE;
KX_DLTIYJ.SetValue = KX_DLTISet.SetValue;
KX_DLTIYJ.SetTime = KX_DLTISet.Time;
KX_DLTIYJ.MeasureValue = &KX_BaoHu_DLT_I;
KX_DLTIYJ.QiDongBit = KX_DLTI_BIT;
KX_DLTIYJ.IPAddress = &BaoHuQiDongIP;
KX_DLTIYJ.SoeRecordIP = TEST_START;
KX_DLTIYJ.ChuKouRecordIP = TEST_START;
KX_DLTIYJ.QiDongCode = KX_DLTI_QD;
KX_DLTIYJ.ChuKouCode = KX_DLTI_CK;
KX_DLTIYJ.FanHuiCode = KX_DLTI_FH;
KX_DLTIYJ.TimeValue = 0;
KX_DLTIYJ.YaoXinNumber = KX_YAOXIN_DLTI;
// 进线失压元件
KX_JXSYYJ.ClsDwnIP = 0;
KX_JXSYYJ.TouRuIP = KX_JXSYTouRu;
KX_JXSYYJ.Type = QL_TYPE;
KX_JXSYYJ.SetValue = KX_SYSet.SetValue;
KX_JXSYYJ.SetTime = KX_SYSet.Time;
KX_JXSYYJ.MeasureValue = &KX_BaoHu_U_Max;
KX_JXSYYJ.QiDongBit = KX_SY_BIT;
KX_JXSYYJ.IPAddress = &BaoHuQiDongIP;
KX_JXSYYJ.SoeRecordIP = TEST_START;
KX_JXSYYJ.ChuKouRecordIP = TEST_START;
KX_JXSYYJ.QiDongCode = KX_JXSY_QD;
KX_JXSYYJ.ChuKouCode = KX_JXSY_CK;
KX_JXSYYJ.FanHuiCode = KX_JXSY_FH;
KX_JXSYYJ.TimeValue = 0;
KX_JXSYYJ.YaoXinNumber = KX_YAOXIN_SY;
KX_JXSYYJ.SoeParam.paramnum = 0;
if(NOT_AT_MODE == KX_PowerMode)
{
KX_JXSYYJ.SoeParam.paramnum = 2;
}
else
{
KX_JXSYYJ.SoeParam.paramnum = 4;
}
KX_JXSYYJ.SoeParam.paramset[0] = &ChannelValue[CH_KX_U].YouXiaoZhi[JiBo].Analog;
KX_JXSYYJ.SoeParam.paramset[1] = &ChannelValue[CH_KX_UT2].YouXiaoZhi[JiBo].Analog;
KX_JXSYYJ.SoeParam.paramset[2] = &ChannelValue[CH_KX_UF].YouXiaoZhi[JiBo].Analog;
KX_JXSYYJ.SoeParam.paramset[3] = &ChannelValue[CH_KX_UF2].YouXiaoZhi[JiBo].Analog;
// 二次谐波闭锁元件
KX_XieBo2YJ.ClsDwnIP = 0;
if(KX_ZK_Xiebo2TouRu == BH_RUN || KX_I_Xiebo2TouRu == BH_RUN || KX_DLTI_Xiebo2TouRu == BH_RUN) KX_XieBo2YJ.TouRuIP = BH_RUN; //保护元件投入标志
else KX_XieBo2YJ.TouRuIP = BH_STOP;
KX_XieBo2YJ.Type = GL_TYPE;
KX_XieBo2YJ.SetValue = KX_XieBo_2;
KX_XieBo2YJ.SetTime = KX_HI2_Block_Time_Set;
KX_XieBo2YJ.MeasureValue = &KX_BaoHu_I2;
KX_XieBo2YJ.QiDongBit = KX_XB2_BIT;
KX_XieBo2YJ.IPAddress = &TempQiDongIP;
KX_XieBo2YJ.SoeRecordIP = TEST_START;
KX_XieBo2YJ.ChuKouRecordIP = TEST_START;
KX_XieBo2YJ.QiDongCode = KX_XBBS_K2;
KX_XieBo2YJ.ChuKouCode = KX_XBBS_K2;
KX_XieBo2YJ.FanHuiCode = KX_XBBSJC_K2;
KX_XieBo2YJ.TimeValue = 0;
// 综合谐波抑制元件
KX_XieBoSumMask = 0;
KX_XieBoSumYJ.ClsDwnIP = 0;
if(KX_ZK_XieBoSTouRu == BH_RUN || KX_I_XieBoSTouRu == BH_RUN || KX_DLTI_XieBoSTouRu == BH_RUN)
{
if(KX_ZK_XieBoSTouRu == BH_RUN)
{
KX_XieBoSumMask |= KX_Z1_BIT | KX_Z2_BIT | KX_Z3_BIT;
/*
if(KX_Z1TouRu == BH_RUN)
{
}
if(KX_Z2TouRu == BH_RUN)
{
KX_XieBoSumMask |= KX_Z2_BIT;
}
if(KX_Z3TouRu == BH_RUN)
{
KX_XieBoSumMask |= KX_Z3_BIT;
}
*/
}
if(KX_I_XieBoSTouRu == BH_RUN)
{
KX_XieBoSumMask |= KX_I_BIT;
}
if(KX_DLTI_XieBoSTouRu == BH_RUN)
{
KX_XieBoSumMask |= KX_DLTI_BIT;
}
KX_XieBoSumYJ.TouRuIP = BH_RUN;
}
else
{
KX_XieBoSumYJ.TouRuIP = BH_STOP;
}
KX_XieBoSumYJ.Type = GL_TYPE;
KX_XieBoSumYJ.SetValue = KX_XieBo_S;
KX_XieBoSumYJ.SetTime = 1;
KX_XieBoSumYJ.MeasureValue = &KX_BaoHu_IE;
KX_XieBoSumYJ.QiDongBit = KX_ZHXB_BIT;
KX_XieBoSumYJ.IPAddress = &TempQiDongIP;
KX_XieBoSumYJ.SoeRecordIP = TEST_START;
KX_XieBoSumYJ.ChuKouRecordIP = TEST_START;
KX_XieBoSumYJ.QiDongCode = KX_XBBS_KE;
KX_XieBoSumYJ.ChuKouCode = KX_XBBS_KE;
KX_XieBoSumYJ.FanHuiCode = KX_XBBSJC_KE;
KX_XieBoSumYJ.TimeValue = 0;
// 低压启动元件
KX_LUYJ.ClsDwnIP = 0;
KX_LUYJ.TouRuIP = KX_LUTouRu;
KX_LUYJ.Type = QL_TYPE;
KX_LUYJ.SetValue = KX_DYUSet;
KX_LUYJ.SetTime = 1;
KX_LUYJ.MeasureValue = &KX_BaoHu_U_Min;
KX_LUYJ.QiDongBit = KX_LU_BIT;
KX_LUYJ.IPAddress = &TempQiDongIP;
KX_LUYJ.SoeRecordIP = TEST_CLOSE;
KX_LUYJ.ChuKouRecordIP = TEST_CLOSE;
KX_LUYJ.QiDongCode = KX_DYBS;
KX_LUYJ.ChuKouCode = KX_DYBS;
KX_LUYJ.FanHuiCode = KX_DYBSJC;
KX_LUYJ.TimeValue = 0;
// PT断线元件
KX_PTDXYJ.ClsDwnIP = 0;
KX_PTDXYJ.TouRuIP = KX_PTDXTouRu; //保护元件投入标志
KX_PTDXYJ.Type = QL_TYPE;
KX_PTDXYJ.SetValue = KX_PTDX_USet;
KX_PTDXYJ.SetTime = KX_PTDX_TimeSet;
KX_PTDXYJ.MeasureValue = &ChannelValue[CH_KX_U].YouXiaoZhi[JiBo].Analog;
KX_PTDXYJ.QiDongBit = KX_PTDX_U11_BIT;
KX_PTDXYJ.IPAddress = &TempQiDongIP;
//防止重复报
if(isPowerOnInit)
{
KX_PTDXYJ.SoeRecordIP = TEST_START;
//isPowerOnInit = 0;
}
KX_PTDXYJ.ChuKouRecordIP = TEST_START;
KX_PTDXYJ.QiDongCode = KX_PTDX_U1;
KX_PTDXYJ.ChuKouCode = KX_PTDX_U1;
KX_PTDXYJ.FanHuiCode = KX_PTDXJC_U1;
KX_PTDXYJ.TimeValue = 0;
KX_PTDXYJ.YaoXinNumber = KX_YAOXIN_DX_U1_1;
if(AT_MODE == KX_PowerMode)
{
KX_PTDXYJ.QiDongCode = KX_PTDX_UT1;
KX_PTDXYJ.ChuKouCode = KX_PTDX_UT1;
KX_PTDXYJ.FanHuiCode = KX_PTDXJC_UT1;
}
KX_PTDXYJ.SoeParam.paramnum = 3;
KX_PTDXYJ.SoeParam.paramset[0] = &ChannelValue[CH_KX_U].YouXiaoZhi[JiBo].Analog;
KX_PTDXYJ.SoeParam.paramset[1] = &ChannelValue[CH_KX_UT2].YouXiaoZhi[JiBo].Analog;
KX_PTDXYJ.SoeParam.paramset[2] = &KX_BaoHu_I;
//U1-2 PT断线元件
KX_T2PTDXYJ.ClsDwnIP = 0;
if(SS == KX_PositionSet || S_SWITCH_CONNECT == KX_ParallelMode )
//if(SS == KX_PositionSet || S_SWITCH_CONNECT == KX_ParallelMode || SSP_JX == KX_PositionSet)
{
KX_T2PTDXYJ.TouRuIP = KX_PTDXTouRu; //保护元件投入标志
}
else
{
KX_T2PTDXYJ.TouRuIP = BH_STOP;
}
KX_T2PTDXYJ.Type = QL_TYPE;
KX_T2PTDXYJ.SetValue = KX_PTDX_USet;
KX_T2PTDXYJ.SetTime = KX_PTDX_TimeSet;
KX_T2PTDXYJ.MeasureValue = &ChannelValue[CH_KX_UT2].YouXiaoZhi[JiBo].Analog;
KX_T2PTDXYJ.QiDongBit = KX_PTDX_U12_BIT;
KX_T2PTDXYJ.IPAddress = &TempQiDongIP;
//防止重复报
if(isPowerOnInit)
{
KX_T2PTDXYJ.SoeRecordIP = TEST_START;
//isPowerOnInit = 0;
}
KX_T2PTDXYJ.ChuKouRecordIP = TEST_START;
KX_T2PTDXYJ.QiDongCode = KX_PTDX_U2;
KX_T2PTDXYJ.ChuKouCode = KX_PTDX_U2;
KX_T2PTDXYJ.FanHuiCode = KX_PTDXJC_U2;
KX_T2PTDXYJ.TimeValue = 0;
KX_T2PTDXYJ.YaoXinNumber = KX_YAOXIN_DX_U1_2;
if(AT_MODE == KX_PowerMode)
{
KX_T2PTDXYJ.QiDongCode = KX_PTDX_UT2;
KX_T2PTDXYJ.ChuKouCode = KX_PTDX_UT2;
KX_T2PTDXYJ.FanHuiCode = KX_PTDXJC_UT2;
}
KX_T2PTDXYJ.SoeParam.paramnum = 3;
KX_T2PTDXYJ.SoeParam.paramset[0] = &ChannelValue[CH_KX_U].YouXiaoZhi[JiBo].Analog;
KX_T2PTDXYJ.SoeParam.paramset[1] = &ChannelValue[CH_KX_UT2].YouXiaoZhi[JiBo].Analog;
KX_T2PTDXYJ.SoeParam.paramset[2] = &KX_BaoHu_I;
//F线PT断线元件
KX_FPTDXYJ.ClsDwnIP = 0;
KX_FPTDXYJ.TouRuIP = KX_PTDXTouRu; //保护元件投入标志
if(AT_MODE != KX_PowerMode || BH_RUN != KX_FUJR)
{
//非at供电方式，或f线电压不接入
KX_FPTDXYJ.TouRuIP = BH_STOP; //保护元件投入标志
}
KX_FPTDXYJ.Type = QL_TYPE; //欠量
KX_FPTDXYJ.SetValue = KX_PTDX_USet;
KX_FPTDXYJ.SetTime = KX_PTDX_TimeSet; //时限
KX_FPTDXYJ.MeasureValue = &ChannelValue[CH_KX_UF].YouXiaoZhi[JiBo].Analog;
KX_FPTDXYJ.QiDongBit = KX_PTDX_U21_BIT; //启动位
KX_FPTDXYJ.IPAddress = &TempQiDongIP; //启动状态字
//防止重复报
if(isPowerOnInit)
{
KX_FPTDXYJ.SoeRecordIP = TEST_START; //
}
KX_FPTDXYJ.ChuKouRecordIP = TEST_START; //出口事件记录
KX_FPTDXYJ.QiDongCode = KX_PTDX_UF1; //启动事件代码
KX_FPTDXYJ.ChuKouCode = KX_PTDX_UF1; //出口事件代码
KX_FPTDXYJ.FanHuiCode = KX_PTDXJC_UF1; //返回事件代码
KX_FPTDXYJ.TimeValue = 0; //计数器
KX_FPTDXYJ.YaoXinNumber = KX_YAOXIN_DX_U2_1; //遥信号
KX_FPTDXYJ.SoeParam.paramnum = 3;
KX_FPTDXYJ.SoeParam.paramset[0] = &ChannelValue[CH_KX_UF].YouXiaoZhi[JiBo].Analog;
KX_FPTDXYJ.SoeParam.paramset[1] = &ChannelValue[CH_KX_UF2].YouXiaoZhi[JiBo].Analog;
KX_FPTDXYJ.SoeParam.paramset[2] = &KX_BaoHu_I;
//U2-2 PT断线元件
KX_F2PTDXYJ.ClsDwnIP = 0;
KX_F2PTDXYJ.TouRuIP = KX_PTDXTouRu; //保护元件投入标志
if(AT_MODE != KX_PowerMode || BH_RUN != KX_FUJR || (SS != KX_PositionSet && S_SWITCH_CONNECT != KX_ParallelMode))
{
//非at供电方式，或f线电压不接入
KX_F2PTDXYJ.TouRuIP = BH_STOP; //保护元件投入标志
}
KX_F2PTDXYJ.Type = QL_TYPE; //欠量
KX_F2PTDXYJ.SetValue = KX_PTDX_USet;
KX_F2PTDXYJ.SetTime = KX_PTDX_TimeSet; //时限
KX_F2PTDXYJ.MeasureValue = &ChannelValue[CH_KX_UF2].YouXiaoZhi[JiBo].Analog;
KX_F2PTDXYJ.QiDongBit = KX_PTDX_U22_BIT; //启动位
KX_F2PTDXYJ.IPAddress = &TempQiDongIP; //启动状态字
//防止重复报
if(isPowerOnInit)
{
KX_F2PTDXYJ.SoeRecordIP = TEST_START; //
}
KX_F2PTDXYJ.ChuKouRecordIP = TEST_START; //出口事件记录
KX_F2PTDXYJ.QiDongCode = KX_PTDX_UF2; //启动事件代码
KX_F2PTDXYJ.ChuKouCode = KX_PTDX_UF2; //出口事件代码
KX_F2PTDXYJ.FanHuiCode = KX_PTDXJC_UF2; //返回事件代码
KX_F2PTDXYJ.TimeValue = 0; //计数器
KX_F2PTDXYJ.YaoXinNumber = KX_YAOXIN_DX_U2_2; //遥信号
KX_F2PTDXYJ.SoeParam.paramnum = 3;
KX_F2PTDXYJ.SoeParam.paramset[0] = &ChannelValue[CH_KX_UF].YouXiaoZhi[JiBo].Analog;
KX_F2PTDXYJ.SoeParam.paramset[1] = &ChannelValue[CH_KX_UF2].YouXiaoZhi[JiBo].Analog;
KX_F2PTDXYJ.SoeParam.paramset[2] = &KX_BaoHu_I;
//isPowerOnInit = 0;
// 检有压元件
KX_JYYYJ.ClsDwnIP = 0;
KX_JYYYJ.TouRuIP = BH_RUN; //保护元件投入标志
//#ifdef DEVICE_TYPE_DIGITAL
//20171222 常规装置也具备该功能
//数字化装置，用于发送有压信号
//if(SS == KX_PositionSet)
//{
// KX_JYYYJ.TouRuIP = BH_RUN; //保护元件投入标志
//}
//#endif
KX_JYYYJ.Type = GL_TYPE;
KX_JYYYJ.SetValue = KX_JYYSet.SetValue;
KX_JYYYJ.SetTime = KX_JYYSet.Time;
//单开关并联时才判对侧电压
if(S_SWITCH_CONNECT == KX_ParallelMode)
{
//非AT供电方式 或单开关并联
KX_JYYYJ.MeasureValue = &KX_BaoHu_U_Max_DC;
}
else
{
KX_JYYYJ.MeasureValue = &KX_BaoHu_U_Max;
}
/*
if((AT_MODE == KX_PowerMode && D_SWITCH_CONNECT == KX_ParallelMode) || SSP_JX == KX_PositionSet)
{
KX_JYYYJ.MeasureValue = &KX_BaoHu_U_Max;
}
else
{
//非AT供电方式 或单开关并联
KX_JYYYJ.MeasureValue = &KX_BaoHu_U_Max_DC;
}
*/
KX_JYYYJ.QiDongBit = KX_YY_BIT;
KX_JYYYJ.IPAddress = &TempQiDongIP;
KX_JYYYJ.SoeRecordIP = TEST_CLOSE;
KX_JYYYJ.ChuKouRecordIP = TEST_START;
KX_JYYYJ.QiDongCode = 0;
KX_JYYYJ.ChuKouCode = 0;
KX_JYYYJ.FanHuiCode = 0;
KX_JYYYJ.TimeValue = 0;
//#ifdef DEVICE_TYPE_DIGITAL
// 供电臂正向阻抗侧元件
KX_PWRSECPOSYJ.ClsDwnIP = 0; // 元件闭锁标志
KX_PWRSECPOSYJ.TouRuIP = KX_PwrSecTouRu; // 保护元件投入标志
KX_PWRSECPOSYJ.SetData = &KX_PwrSecPrtcSet; // 整定值
KX_PWRSECPOSYJ.MeasureValue = &KX_ZKValue; // 测量值
KX_PWRSECPOSYJ.QiDongBit = KX_PWESECPOS_BIT; // 元件启动位
KX_PWRSECPOSYJ.IPAddress = &BaoHuQiDongIP; // 启动标志字地址
KX_PWRSECPOSYJ.SoeRecordIP = TEST_START; // Soe事件记录标志
KX_PWRSECPOSYJ.ChuKouRecordIP = TEST_START; // 保护元件出口事件记录标志
KX_PWRSECPOSYJ.QiDongCode = KX_PWESECPOS_QD; // 元件启动事件代码
KX_PWRSECPOSYJ.ChuKouCode = KX_PWESECPOS_CK; // 元件出口事件代码
KX_PWRSECPOSYJ.FanHuiCode = KX_PWESECPOS_FH; // 元件返回事件代码
KX_PWRSECPOSYJ.TimeValue = 0; // 保护元件计时器
KX_PWRSECPOSYJ.YaoXinNumber = KX_YAOXIN_POWERSECPOS; // 对应的软遥信号
//供电臂反向阻抗元件
KX_PWRSECNAGYJ.ClsDwnIP = 0;
//元件闭锁标志
//变电所或开闭所但不为双进线运行
if(SS == KX_PositionSet)
{
//变电所或开闭所进线不投入反向阻抗元件
KX_PWRSECNAGYJ.TouRuIP = BH_STOP; // 保护元件投入标志
}
else if(BH_STOP == KX_PwrSecTouRu && BH_STOP == KX_BusPrtcTouRu)
{
//供电臂保护及母线保护均未投入
KX_PWRSECNAGYJ.TouRuIP = BH_STOP;
}
else if(BH_STOP != KX_PwrSecTouRu)
{
//供电臂保护投入
KX_PWRSECNAGYJ.TouRuIP = BH_RUN;
}
else
{
//母线保护投入
KX_PWRSECNAGYJ.TouRuIP = BH_RUN;
//开闭所进线，且非双进线运行
if(SSP_JX == KX_PositionSet && INLINE_RUNMODE_DOUBLE != KX_JXRunMode)
{
KX_PWRSECNAGYJ.TouRuIP = BH_STOP;
}
else if(SSP_JX != KX_PositionSet && S_SWITCH_CONNECT == KX_ParallelMode)
{
//非开闭所进线，且为单开关并联，无母线保护
KX_PWRSECNAGYJ.TouRuIP = BH_STOP;
}
}
KX_PWRSECNAGYJ.SetData = &KX_PwrSecPrtcSet; // 整定值
KX_PWRSECNAGYJ.MeasureValue = &KX_ZKValue; // 测量值
KX_PWRSECNAGYJ.QiDongBit = KX_PWESECNAG_BIT; // 元件启动位
KX_PWRSECNAGYJ.IPAddress = &BaoHuQiDongIP; // 启动标志字地址
KX_PWRSECNAGYJ.SoeRecordIP = TEST_START; // Soe事件记录标志
KX_PWRSECNAGYJ.ChuKouRecordIP = TEST_START; // 保护元件出口事件记录标志
KX_PWRSECNAGYJ.QiDongCode = KX_PWESECNAG_QD; // 元件启动事件代码
KX_PWRSECNAGYJ.ChuKouCode = KX_PWESECNAG_CK; // 元件出口事件代码
KX_PWRSECNAGYJ.FanHuiCode = KX_PWESECNAG_FH; // 元件返回事件代码
KX_PWRSECNAGYJ.TimeValue = 0; // 保护元件计时器
KX_PWRSECNAGYJ.YaoXinNumber = KX_YAOXIN_POWERSECNAG; // 对应的软遥信号
// 联跳元件
KX_PWRSECTRIP_YJ.ClsDwnIP = 0; // 元件闭锁标志
KX_PWRSECTRIP_YJ.TouRuIP = KX_PwrSecTouRu; // 保护元件投入标志
KX_PWRSECTRIP_YJ.OldStatus = OFF;
KX_PWRSECTRIP_YJ.QiDongBit = KX_INTERTRIP_BIT; // 元件启动位
KX_PWRSECTRIP_YJ.IPAddress = &BaoHuQiDongIP; // 启动标志字地址
KX_PWRSECTRIP_YJ.SoeRecordIP = TEST_START; // Soe事件记录标志
KX_PWRSECTRIP_YJ.ChuKouRecordIP = TEST_START; // 保护元件出口事件记录标志
KX_PWRSECTRIP_YJ.QiDongCode = KX_LTRIP_CK; // 元件启动事件代码
KX_PWRSECTRIP_YJ.ChuKouCode = KX_LTRIP_CK; // 元件出口事件代码
KX_PWRSECTRIP_YJ.FanHuiCode = KX_LTRIP_FH; // 元件返回事件代码
KX_PWRSECTRIP_YJ.YaoXinRecordIP = TEST_START; // 软遥信记录标志
//供电臂闭锁元件
KX_PWRSECBLOCK_YJ.ClsDwnIP = 0; // 元件闭锁标志
KX_PWRSECBLOCK_YJ.TouRuIP = KX_PwrSecTouRu; // 投退定值
KX_PWRSECBLOCK_YJ.QiDongBit = KX_PWRSEC_BLOCK_BIT; // 动作标识
KX_PWRSECBLOCK_YJ.IPAddress = &TempQiDongIP; // 启动标识
KX_PWRSECBLOCK_YJ.SoeRecordIP = TEST_START; // Soe记录标识
KX_PWRSECBLOCK_YJ.ChuKouRecordIP = TEST_START; // 出口事件记录标识
KX_PWRSECBLOCK_YJ.QiDongCode = KX_LBLOCK_QD; // 启动事件代码
KX_PWRSECBLOCK_YJ.ChuKouCode = KX_LBLOCK_QD; // 出口事件代码
KX_PWRSECBLOCK_YJ.FanHuiCode = KX_LBLOCK_FH; // 返回事件代码
KX_PWRSECBLOCK_YJ.TimeValue = 0; // 时间
KX_PWRSECBLOCK_YJ.YaoXinRecordIP = TEST_START; // 软遥信记录标志
//供电臂失效元件
KX_PWRSECFAULT_YJ.ClsDwnIP = 0; // 元件闭锁标志
KX_PWRSECFAULT_YJ.TouRuIP = KX_PwrSecTouRu; // 投退定值
KX_PWRSECFAULT_YJ.QiDongBit = KX_PWRSEC_INVALID_BIT; // 动作标识
KX_PWRSECFAULT_YJ.IPAddress = &TempQiDongIP; // 启动标识
KX_PWRSECFAULT_YJ.SoeRecordIP = TEST_START; // Soe记录标识
KX_PWRSECFAULT_YJ.ChuKouRecordIP = TEST_START; // 出口事件记录标识
KX_PWRSECFAULT_YJ.QiDongCode = KX_LINVALID_QD; // 启动事件代码
KX_PWRSECFAULT_YJ.ChuKouCode = KX_LINVALID_QD; // 出口事件代码
KX_PWRSECFAULT_YJ.FanHuiCode = KX_LINVALID_FH; // 返回事件代码
KX_PWRSECFAULT_YJ.TimeValue = 0; // 时间
KX_PWRSECFAULT_YJ.YaoXinRecordIP = TEST_START; // 软遥信记录标志
//母线保护闭锁元件
KX_BUSPRTCBLOCK_YJ.ClsDwnIP = 0; // 元件闭锁标志
if(SS == KX_PositionSet || S_SWITCH_CONNECT == KX_ParallelMode)
{
//变电所不投入反向阻抗元件
KX_BUSPRTCBLOCK_YJ.TouRuIP = BH_STOP; // 保护元件投入标志
}
else
{
KX_BUSPRTCBLOCK_YJ.TouRuIP = KX_BusPrtcTouRu; // 保护元件投入标志
}
KX_BUSPRTCBLOCK_YJ.QiDongBit = KX_BUSPRTCBLOCK_BIT; // 动作标识
KX_BUSPRTCBLOCK_YJ.IPAddress = &TempQiDongIP; // 启动标识
KX_BUSPRTCBLOCK_YJ.SoeRecordIP = TEST_START; // Soe记录标识
KX_BUSPRTCBLOCK_YJ.ChuKouRecordIP = TEST_START; // 出口事件记录标识
KX_BUSPRTCBLOCK_YJ.QiDongCode = KX_BUSBLOCK_CK; // 启动事件代码
KX_BUSPRTCBLOCK_YJ.ChuKouCode = KX_BUSBLOCK_CK; // 出口事件代码
KX_BUSPRTCBLOCK_YJ.FanHuiCode = KX_BUSBLOCK_FH; // 返回事件代码
KX_BUSPRTCBLOCK_YJ.TimeValue = 0; // 时间
KX_BUSPRTCBLOCK_YJ.YaoXinRecordIP = TEST_START; // 软遥信记录标志
}
//公共对象定义 20210221
void commobjectinit()
{
g_comm_object_ied.do_comm.led_run = LED_RUN_DO; //运行灯
g_comm_object_ied.do_comm.led_alarm = LED_ALARM_DO; //告警灯
//g_comm_object_ied.do_comm.led_com = KX_TX_LED_KC; //通信灯
g_comm_object_ied.do_comm.led_check = LED_TEST_DO; //检修灯
g_comm_object_ied.do_comm.led_trip = KX_TZ_LED_KC; //跳闸灯
g_comm_object_ied.do_comm.led_rcls_act = KX_CHZDZ_LED_KC; //重合闸动作灯
g_comm_object_ied.do_comm.led_timesyn = KX_GPS_LED_KC; //时钟同步
g_comm_object_ied.do_comm.prtcalarm = KX_GJ_KC; //保护告警
g_comm_object_ied.relaytype = RELAY_TYPE_PROTECT; //保护装置
//驱动告警灯的元件掩码
g_comm_object_ied.param_com.prtcalarm_mask = KX_PTDX_U11_BIT | KX_PTDX_U12_BIT | KX_PTDX_U21_BIT | KX_PTDX_U22_BIT | KX_YCFZ_BIT;
#ifdef DEVICE_TYPE_DIGITAL
g_comm_object_ied.rmtsgnl_coomm.rmtsgnl_check = KX_YAOXIN_JX; //检修遥信
g_comm_object_ied.ver_comm.ver = VERSION_L_DIGTAL; //版本号
#else
g_comm_object_ied.rmtsgnl_coomm.rmtsgnl_check = KX_YAOXIN_STRIP_TEST; //检修遥信
g_comm_object_ied.ver_comm.ver = VERSION_L; //版本号
g_comm_object_ied.ver_comm.ver_build = VERSION_BUILD; //内部版本号
#endif
//IO插件类型
//io插件1
set_io_type(IO_NO_BOARD1,IO_TYPE_IN31_OUT0);
//io插件2
set_io_type(IO_NO_BOARD2,IO_TYPE_IN31_OUT0);
//io插件3
set_io_type(IO_NO_BOARD3,IO_TYPE_INT0_OUT20);
//电源插件
set_io_type(IO_NO_BOARD5,IO_TYPE_INT15_OUT0);
}
void kx_u_param_init()
{
int i,strip,powermode;
u_channel_init(&KX_U_Param.ut.u_main,CH_KX_U,KX_PTDX_U11_BIT);
u_channel_init(&KX_U_Param.ut.u_backup,CH_KX_UT2,KX_PTDX_U12_BIT);
u_channel_init(&KX_U_Param.uf.u_main,CH_KX_UF,KX_PTDX_U21_BIT);
u_channel_init(&KX_U_Param.uf.u_backup,CH_KX_UF2,KX_PTDX_U22_BIT);
//仅变电所有自动切换功能
if(SS == KX_PositionSet )
{
strip = KX_U_AutoExchange;
}
else if( S_SWITCH_CONNECT == KX_ParallelMode)
{
strip = BH_RUN;
}
else
{
strip = BH_STOP;
}
if(AT_MODE == KX_PowerMode && BH_RUN == KX_FUJR)
{
powermode = AT_MODE;
}
else
{
powermode = NOT_AT_MODE;
}
u_bus_param_init(&KX_U_Param,strip,KX_MLGK1_FW_KR,KX_MLGK2_FW_KR,KX_PTDX_USet,powermode,1);
//设置电压与母联隔开的关系
set_u_bus_gk_mode(&KX_U_Param,kx_gk_u1_u2);
}
/****************************************************
* void InitAnalogChannel(void)
* 模拟量通道初始化
*
*****************************************************/
void InitAnalogChannel(void)
{
int i, j,number;
unsigned char analogtype[][3] = {
{CH_KX_BH_I,KX_I_TYPE,KX_IT_TYPE}, //0//保护绕组电流
{CH_KX_CL_I,KX_IM_TYPE,KX_ITM_TYPE}, //1//测量绕组电流
{CH_KX_BH_IF,KX_UNUSE_TYPE,KX_IF_TYPE}, //2//F线保护绕组电流
{CH_KX_CL_IF,KX_UNUSE_TYPE,KX_IFM_TYPE}, //3//F线测量绕组电流
{CH_KX_U,KX_U1_TYPE,KX_UT1_TYPE}, //7//U1_1母线电压
{CH_KX_UT2,KX_U2_TYPE,KX_UT2_TYPE}, //8//U1_2
{CH_KX_UF,KX_UNUSE_TYPE,KX_UF1_TYPE}, //9//U2_1, F线电压
{CH_KX_UF2,KX_UNUSE_TYPE,KX_UF2_TYPE}, //10 //U2_2
};
number = sizeof(analogtype) / sizeof(analogtype[0]);
//初始化采样通道
for(i = 0; i < number; i++)
{
//AT供电
if(AT_MODE == KX_PowerMode)
{
ChannelValue[analogtype[i][0]].YouXiaoZhi[JiBo].Analog.Type = analogtype[i][2];
}
else
{
//非AT供电
ChannelValue[analogtype[i][0]].YouXiaoZhi[JiBo].Analog.Type = analogtype[i][1];
}
//保护电流计算2、3、5次谐波
if(ANIN_TYPE_BH_I == ChannelValue[analogtype[i][0]].Type)
{
ChannelValue[analogtype[i][0]].FS_IP = JiBoBit | XieBo2Bit | XieBo3Bit | XieBo5Bit;
}
else
{
ChannelValue[analogtype[i][0]].FS_IP = JiBoBit;
}
ChannelValue[analogtype[i][0]].YouXiaoZhi[JiBo].Analog.Mode = DisplayMode; //锟斤拷示模式
}
//初始化刻度校正通道
unsigned int analogadjuset[][3] = {
{KX_U,CH_KX_U,&KX_VKSet}, //0x0 //母线电压1校正
{KX_UDC,CH_KX_UT2,&KX_VK2Set}, //0x1 //母线电压1校正
{KX_UF,CH_KX_UF,&KX_VFKSet}, //0x2 //F线电压1校正
{KX_U1,CH_KX_UF2,&KX_VFK2Set}, //0x3//F线电压2校正
{KX_BH_I,CH_KX_BH_I,&KX_BaoHuIKSet}, //0x4 //保护绕组电流校正
{KX_CL_I,CH_KX_CL_I,&KX_CeLiangIKSet}, //0x5 //测量绕组电流校正
{KX_BH_IF,CH_KX_BH_IF,&KX_BaoHuFIKSet}, //0x6 //F线保护绕组电流校正
{KX_CL_IF,CH_KX_CL_IF,&KX_CeLiangFIKSet}, //0x7 //F线测量绕组电流校正
{KX_Z,0xFF,&KX_ZKSet}, //0x8 //阻抗校正
{KX_Q,CH_KX_BH_I,&KX_QSet}, //0x9 //T线角度校正
{KX_Q_F,CH_KX_BH_IF,&KX_QFSet}, //0xA //F线角度校正
};
number = sizeof(analogadjuset) / sizeof(analogadjuset[0]);
KDXZValue.Number = KX_ANALOGADJUST_NUMBER;
for(i = 0; i < number; i++)
{
KDXZValue.Table[analogadjuset[i][0]].ChannelNo = analogadjuset[i][1];
KDXZValue.Table[analogadjuset[i][0]].SetValueAdd = analogadjuset[i][2];
}
}
/******************************************************************************
* Function: AninChannalTypeInit
* Description:通道类型初始化
* Calls: none
* Called By:
* Input:
* Ouput:
* Return:
* others:
* History:
* 1.luoyang created
*
*******************************************************************************/
void AninChannalTypeInit()
{
//通道类型
ChannelValue[CH_KX_U].Type = ANIN_TYPE_BH_U;
ChannelValue[CH_KX_UT2].Type = ANIN_TYPE_BH_U;
ChannelValue[CH_KX_UF].Type = ANIN_TYPE_BH_U;
ChannelValue[CH_KX_UF2].Type = ANIN_TYPE_BH_U;
ChannelValue[CH_KX_BH_I].Type = ANIN_TYPE_BH_I;
ChannelValue[CH_KX_CL_I].Type = ANIN_TYPE_CL_I;
ChannelValue[CH_KX_BH_IF].Type = ANIN_TYPE_BH_I;
ChannelValue[CH_KX_CL_IF].Type = ANIN_TYPE_CL_I;
ChannelValue[CH_KX_AD1].Type = ANIN_TYPE_ZJ;
ChannelValue[CH_KX_AD2].Type = ANIN_TYPE_ZJ;
ChannelValue[CH_KX_AD3].Type = ANIN_TYPE_ZJ;
//通道状态遥信
ChannelValue[CH_KX_U].StYaoXinNo = KX_YAOXIN_ANIN_ST_U;
ChannelValue[CH_KX_UT2].StYaoXinNo = KX_YAOXIN_ANIN_ST_UDC;
ChannelValue[CH_KX_UF].StYaoXinNo = KX_YAOXIN_ANIN_ST_UF;
ChannelValue[CH_KX_UF2].StYaoXinNo = KX_YAOXIN_ANIN_ST_U1;
ChannelValue[CH_KX_BH_I].StYaoXinNo = KX_YAOXIN_ANIN_ST_BHI;
ChannelValue[CH_KX_CL_I].StYaoXinNo = KX_YAOXIN_ANIN_ST_CLI;
ChannelValue[CH_KX_BH_IF].StYaoXinNo = KX_YAOXIN_ANIN_ST_BHI_F;
ChannelValue[CH_KX_CL_IF].StYaoXinNo = KX_YAOXIN_ANIN_ST_CLI_F;
AninChannallCoeff_SV_init();
}
/******************************************************************************
* Function: AninParameterInit
* Description:
* Calls: none
* Called By:
* Input:
* Ouput:
* Return:
* others:
* History:
* 1.luoyang created
*
*******************************************************************************/
void AninParameterInit()
{
ChannelValue[CH_KX_U].RatioValue1 = KX_PTRated1;
ChannelValue[CH_KX_UT2].RatioValue1 = KX_PTRated1;
ChannelValue[CH_KX_UF].RatioValue1 = KX_PTRated1;
ChannelValue[CH_KX_UF2].RatioValue1 = KX_PTRated1;
ChannelValue[CH_KX_BH_I].RatioValue1 = KX_CTRated1;
ChannelValue[CH_KX_CL_I].RatioValue1 = KX_CTRated1;
ChannelValue[CH_KX_BH_IF].RatioValue1 = KX_CTRated1;
ChannelValue[CH_KX_CL_IF].RatioValue1 = KX_CTRated1;
ChannelValue[CH_KX_U].RatioValue2 = RATED_VOLTAGE_275_2;
ChannelValue[CH_KX_UT2].RatioValue2 = RATED_VOLTAGE_275_2;
ChannelValue[CH_KX_UF].RatioValue2 = RATED_VOLTAGE_275_2;
ChannelValue[CH_KX_UF2].RatioValue2 = RATED_VOLTAGE_275_2;
ChannelValue[CH_KX_BH_I].RatioValue2 = KX_CTRated2;
ChannelValue[CH_KX_CL_I].RatioValue2 = KX_CTRated2;
ChannelValue[CH_KX_BH_IF].RatioValue2 = KX_CTRated2;
ChannelValue[CH_KX_CL_IF].RatioValue2 = KX_CTRated2;
ChannelValue[CH_KX_U].VKSet = KX_VKSet;
ChannelValue[CH_KX_UT2].VKSet = KX_VK2Set;
ChannelValue[CH_KX_UF].VKSet = KX_VFKSet;
ChannelValue[CH_KX_UF2].VKSet = KX_VFK2Set;
ChannelValue[CH_KX_BH_I].VKSet = KX_BaoHuIKSet;
ChannelValue[CH_KX_CL_I].VKSet = KX_CeLiangIKSet;
ChannelValue[CH_KX_BH_IF].VKSet = KX_BaoHuFIKSet;
ChannelValue[CH_KX_CL_IF].VKSet = KX_CeLiangFIKSet;
}
void InitOutStatus(void)
{
//功能说明：根据不同的装置类型初始化结构变量OutStatus中的相关参数
//输入参数：无。
//输出参数：无。
//该程序由初始化程序调用
//20210313 简化初始化流程 Modi by L.Y.
unsigned int i,j;
/*
for(i = 0; i < OUTPUT_NUM; i++) // 传动初始化
{
OutStatus.ChuanDongObjectSet[i] = 0xff;
OutStatus.ObjectKcType[i] = 0xff;
OutStatus.ObjectKcBit[i] = 0xff;
OutStatus.BlockYaoXinNo[i] = 0xff;
//OutStatus.CurrStatus[i] = OFF; //
OutStatus.AllowKcIP[i]=TEST_START;
OutStatus.ChuanDongObjectType[i] = 0xFF;
//OutStatus.Status[i] = 0;
}
*/
OutStatus.BlockYaoXinNo[KX_QF_FZ_KC] = KX_YAOXIN_BS_QF_FZ;
OutStatus.BlockYaoXinNo[KX_QF_HZ_KC] = KX_YAOXIN_BS_QF_HZ;
OutStatus.BlockYaoXinNo[KX_1QS_TZ_KC] = KX_YAOXIN_BS_1QS_FZ;
OutStatus.BlockYaoXinNo[KX_1QS_HZ_KC] = KX_YAOXIN_BS_1QS_HZ;
OutStatus.BlockYaoXinNo[KX_2QS_TZ_KC] = KX_YAOXIN_BS_2QS_FZ;
OutStatus.BlockYaoXinNo[KX_2QS_HZ_KC] = KX_YAOXIN_BS_2QS_HZ;
OutStatus.BlockYaoXinNo[KX_3QS_TZ_KC] = KX_YAOXIN_BS_3QS_FZ;
OutStatus.BlockYaoXinNo[KX_3QS_HZ_KC] = KX_YAOXIN_BS_3QS_HZ;
OutStatus.BlockYaoXinNo[KX_4QS_TZ_KC] = KX_YAOXIN_BS_4QS_FZ;
OutStatus.BlockYaoXinNo[KX_4QS_HZ_KC] = KX_YAOXIN_BS_4QS_HZ;
OutStatus.BlockYaoXinNo[KX_5QS_TZ_KC] = KX_YAOXIN_BS_5QS_FZ;
OutStatus.BlockYaoXinNo[KX_5QS_HZ_KC] = KX_YAOXIN_BS_5QS_HZ;
OutStatus.BlockYaoXinNo[KX_6QS_TZ_KC] = KX_YAOXIN_BS_6QS_FZ;
OutStatus.BlockYaoXinNo[KX_6QS_HZ_KC] = KX_YAOXIN_BS_6QS_HZ;
OutStatus.BlockYaoXinNo[KX_7QS_TZ_KC] = KX_YAOXIN_BS_7QS_FZ;
OutStatus.BlockYaoXinNo[KX_7QS_HZ_KC] = KX_YAOXIN_BS_7QS_HZ;
OutStatus.BlockYaoXinNo[KX_8QS_TZ_KC] = KX_YAOXIN_BS_8QS_FZ;
OutStatus.BlockYaoXinNo[KX_8QS_HZ_KC] = KX_YAOXIN_BS_8QS_HZ;
//特殊类型
OutStatus.ChuanDongObjectType[KX_CDTEST_CONTACT_TEST] = CUSTOM_TYPE; //自定义类型
OutStatus.ChuanDongObjectType[KX_CDTEST_QHSX_TEST] = CUSTOM_TYPE; //自定义类型
// 初始化传动试验对象对应的开出通道
//CRCC认证添加 软压板
for(i = KX_CDTEST_CHECK,j = 0; j < KX_SOFTSTRIP_OBJECT_NUMBER; i++, j++)
{
OutStatus.ChuanDongObjectSet[i] = KX_SOFTSTRIP_OBJECT_CHECK + j;
}
//初始化全部通道的开出类型
//需要记录状态
OutStatus.ObjectKcType[KX_TZ_LED_KC] = DRIVE_RECD_FAULT_KC_TYPE; //跳闸灯
OutStatus.ObjectKcType[KX_CHZDZ_LED_KC] = DRIVE_RECD_FAULT_KC_TYPE; //重合闸动作灯
OutStatus.ObjectKcType[KX_ZTDZ_LED_KC] = DRIVE_RECD_FAULT_KC_TYPE; //自投动作灯
OutStatus.ObjectKcType[KX_BCJQ_KC] = DRIVE_BHTZ_KC_TYPE; //跳闸
OutStatus.ObjectKcType[KX_HCJQ_KC] = DRIVE_CHZ_KC_TYPE; //重合闸
RemoteValue.ModeChannelNo = KX_YAOXIN_YK;
RemoteValue.OperationTime = KX_OperationTime;
RemoteValue.QSOperationTime = KX_QSOperationTime;
//RemoteValue.DelayTime = 0;
}
/*****************************************************************************************
* void InitData(void)
*******************************************************************************************/
void InitData(void)
{
unsigned int i, j, k,m,number;
unsigned char ChannelNo;
FaultReportType *FaultReport = MemPtrSet.pFaultReport;
WaveType *LoadWaveBuffer = MemPtrSet.pWave;
//保护电流
if(AT_MODE == KX_PowerMode)
{
KX_BaoHu_I.Type = KX_ITF_TYPE;
}
else
{
KX_BaoHu_I.Type = KX_I_TYPE;
}
KX_BaoHu_I.Mode = ChannelValue[CH_KX_BH_I].YouXiaoZhi[JiBo].Analog.Mode;
KX_BaoHu_I.Value = 0;
//二次谐波
KX_BaoHu_I2.Type = KX_IH2_TYPE;
KX_BaoHu_I2.Value = 0;
//综合谐波
KX_BaoHu_IE.Type = KX_IHS_TYPE;
KX_BaoHu_IE.Value = 0;
//增量
KX_BaoHu_DLT_I.Type = KX_IDELTA_TYPE;
KX_BaoHu_DLT_I.Mode = KX_BaoHu_I.Mode;
KX_BaoHu_DLT_I.Value = 0;
//阻抗
KX_ZKValue.R.Type = KX_Z_TYPE;
KX_ZKValue.R.Mode = DisplayMode;
KX_ZKValue.R.Value = 0;
KX_ZKValue.X.Type = KX_Z_TYPE;
KX_ZKValue.X.Mode = DisplayMode;
KX_ZKValue.X.Value = 0;
KX_ZKValue.FD_R.Type = KX_Z_TYPE;
KX_ZKValue.FD_R.Mode = DisplayMode;
KX_ZKValue.FD_R.Value = 0;
KX_ZKValue.FD_X.Type = KX_Z_TYPE;
KX_ZKValue.FD_X.Mode = DisplayMode;
KX_ZKValue.FD_X.Value = 0;
KX_ZKValue.typecode_z = KX_Z_TYPE;
KX_ZKValue.typecode_q = KX_Q_Z_TYPE;
//保护电压
KX_BaoHu_U_Max.Type = ChannelValue[CH_KX_U].YouXiaoZhi[JiBo].Analog.Type;
KX_BaoHu_U_Max.Mode = ChannelValue[CH_KX_U].YouXiaoZhi[JiBo].Analog.Mode;
KX_BaoHu_U_Max.Value = 0;
KX_BaoHu_U_Min = KX_BaoHu_U_Max;
KX_BaoHu_U_Max_DC.Type = ChannelValue[CH_KX_UT2].YouXiaoZhi[JiBo].Analog.Type;
KX_BaoHu_U_Max_DC.Mode = ChannelValue[CH_KX_UT2].YouXiaoZhi[JiBo].Analog.Mode;
KX_BaoHu_U_Max_DC.Value = 0;
if(AT_MODE == KX_PowerMode)
{
KX_BaoHu_UT.Type = KX_UT_TYPE;
KX_BaoHu_UF.Type = KX_UF_TYPE;
}
else
{
KX_BaoHu_UT.Type = KX_U_TYPE;
KX_BaoHu_UF.Type = KX_UNUSE_TYPE;
}
KX_BaoHu_UT.Value = 0;
KX_BaoHu_UT.Mode = ChannelValue[CH_KX_U].YouXiaoZhi[JiBo].Analog.Mode;
KX_BaoHu_UF.Value = 0;
KX_BaoHu_UF.Mode = ChannelValue[CH_KX_U].YouXiaoZhi[JiBo].Analog.Mode;
KX_Fault_ZKValue.R.Type = KX_ZKValue.R.Type;
KX_Fault_ZKValue.R.Mode = KX_ZKValue.R.Mode;
KX_Fault_ZKValue.X.Type = KX_ZKValue.X.Type;
KX_Fault_ZKValue.X.Mode = KX_ZKValue.X.Mode;
KX_Fault_ZKValue.FD_R.Type = KX_ZKValue.FD_R.Type;
KX_Fault_ZKValue.FD_R.Mode = KX_ZKValue.FD_R.Mode;
KX_Fault_ZKValue.FD_X.Type = KX_ZKValue.FD_X.Type;
KX_Fault_ZKValue.FD_X.Mode = KX_ZKValue.FD_X.Mode;
//测距用的阻抗
KX_Fault_ZKValue_CJ.R.Type = KX_ZKValue.R.Type;
KX_Fault_ZKValue_CJ.R.Mode = KX_ZKValue.R.Mode;
KX_Fault_ZKValue_CJ.X.Type = KX_ZKValue.X.Type;
KX_Fault_ZKValue_CJ.X.Mode = KX_ZKValue.X.Mode;
//变电所公里标
KX_GLB = KX_XLSet.kmss;
//供电线长度
KX_GDX = KX_XLSet.pllen;
//重合闸失败标识
RecloseFailIP = TEST_CLOSE;
//故障电抗就时间
if(KX_AccTimeSet <= 20)
{
KX_FaultZRecordTime = 30;
}
else
{
KX_FaultZRecordTime = KX_AccTimeSet + 5;
}
KX_Fault_BaoHu_I.Type = KX_BaoHu_I.Type;
KX_Fault_BaoHu_I.Mode = KX_BaoHu_I.Mode;
KX_Fault_I.Type = ChannelValue[CH_KX_BH_I].YouXiaoZhi[JiBo].Analog.Type;
KX_Fault_I.Mode = ChannelValue[CH_KX_BH_I].YouXiaoZhi[JiBo].Analog.Mode;
KX_Fault_IF.Type = ChannelValue[CH_KX_BH_IF].YouXiaoZhi[JiBo].Analog.Type;
KX_Fault_IF.Mode = ChannelValue[CH_KX_BH_IF].YouXiaoZhi[JiBo].Analog.Mode;
KX_Fault_U.Type = KX_BaoHu_UT.Type;
KX_Fault_U.Mode = ChannelValue[CH_KX_U].YouXiaoZhi[JiBo].Analog.Mode;
KX_Fault_UF.Type = KX_BaoHu_UF.Type;
KX_Fault_UF.Mode = ChannelValue[CH_KX_UF].YouXiaoZhi[JiBo].Analog.Mode;
//二次谐波含量
KX_Fault_IH2.Type = KX_IH2_TYPE;
KX_Fault_IH2.Mode = DisplayMode;
//录波通道
WaveChannelSet[KX_U_WAVE] = CH_KX_U; //母线电压
WaveChannelSet[KX_UT2_WAVE] = CH_KX_UT2; //对侧母线电压
WaveChannelSet[KX_UF_WAVE] = CH_KX_UF; //F线电压
WaveChannelSet[KX_UF2_WAVE] = CH_KX_UF2; //U1、进线电压
WaveChannelSet[KX_BH_I_WAVE] = CH_KX_BH_I; //保护电流
WaveChannelSet[KX_BH_IF_WAVE] = CH_KX_BH_IF; //F线保护电流
WaveChannelSet[KX_CL_I_WAVE] = CH_KX_CL_I; //测量电流
WaveChannelSet[KX_CL_IF_WAVE] = CH_KX_CL_IF; //F线测量电流
unsigned int DigitalWaveSet[][3] = {
{KX_QF_DIGITALWAVE,KX_YAOXIN_QF,WAVE_CHANNEL_RMTSIGNAL}, //断路器位置
{KX_TRIP_DO_DIGITALWAVE,KX_BCJQ_KC,WAVE_CHANNEL_DO}, //跳闸开出
{KX_RECLS_DO_DIGITALWAVE,KX_HCJQ_KC,WAVE_CHANNEL_DO}, //合闸开出
{KX_Z1_DIGITALWAVE,KX_Z1_BIT,WAVE_CHANNEL_PRTC_START}, //距离1段
{KX_Z2_DIGITALWAVE,KX_Z2_BIT,WAVE_CHANNEL_PRTC_START}, //距离2段
{KX_Z3_DIGITALWAVE,KX_Z3_BIT,WAVE_CHANNEL_PRTC_START}, //距离3段
{KX_SD_DIGITALWAVE,KX_SDI_BIT,WAVE_CHANNEL_PRTC_START}, //电流速断
{KX_I_DIGITALWAVE,KX_I_BIT,WAVE_CHANNEL_PRTC_START}, //过电流
{KX_DELATAI_DIGITALWAVE,KX_DLTI_BIT,WAVE_CHANNEL_PRTC_START}, //电流增量
{KX_SY_DIGITALWAVE,KX_SY_BIT,WAVE_CHANNEL_PRTC_START}, //失压
{KX_HI2_DIGITALWAVE,KX_XB2_BIT,WAVE_CHANNEL_PRTC_ASST}, //二次谐波闭锁
{KX_HIS_DIGITALWAVE,KX_ZHXB_BIT,WAVE_CHANNEL_PRTC_ASST}, //综合谐波抑制
{KX_Z_SMALL_DIGITALWAVE,KX_XZK_BIT,WAVE_CHANNEL_PRTC_ASST}, //小阻抗
{KX_PT_U11_DIGITALWAVE,KX_PTDX_U11_BIT,WAVE_CHANNEL_PRTC_ASST}, //U1-1 PT断线
{KX_PT_U12_DIGITALWAVE,KX_PTDX_U12_BIT,WAVE_CHANNEL_PRTC_ASST}, //U1-2 PT断线
{KX_PT_U21_DIGITALWAVE,KX_PTDX_U21_BIT,WAVE_CHANNEL_PRTC_ASST}, //U2-1 PT断线
{KX_PT_U22_DIGITALWAVE,KX_PTDX_U22_BIT,WAVE_CHANNEL_PRTC_ASST}, //u2-2 PT断线
{KX_PT_DIGITALWAVE,KX_PTDX_BIT,WAVE_CHANNEL_PRTC_ASST}, //PT断线
{KX_PT_BAKEUP_T_DIGITALWAVE,KX_BAKEUP_T_BIT,WAVE_CHANNEL_RECD_STATUS}, //T线备用压互
{KX_PT_BAKEUP_F_DIGITALWAVE,KX_BAKEUP_F_BIT,WAVE_CHANNEL_RECD_STATUS}, //F线备用压互
};
number = sizeof(DigitalWaveSet) / sizeof(DigitalWaveSet[0]);
DigitalWaveChannelInit(DigitalWaveSet,number);
for(i = 0; i < FAULT_NUM; i++)
{
FaultReport->Buffer[i].DeviceType = DEV_KX;
FaultReport->Buffer[i].DongZuoIP = 0;
m = 0;
//1.T线/母线电压
FaultReport->Buffer[i].DataBuffer[m].Type = KX_Fault_U.Type;
FaultReport->Buffer[i].DataBuffer[m++].Mode = KX_Fault_U.Mode;
if(AT_MODE == KX_PowerMode)
{
//2.F线电压
FaultReport->Buffer[i].DataBuffer[m].Type = KX_Fault_UF.Type;
FaultReport->Buffer[i].DataBuffer[m++].Mode = KX_Fault_UF.Mode;
}
//5.保护电流
FaultReport->Buffer[i].DataBuffer[m].Type = KX_Fault_I.Type;
FaultReport->Buffer[i].DataBuffer[m++].Mode = KX_Fault_I.Mode;
if(AT_MODE == KX_PowerMode)
{
//6.F线保护电流
FaultReport->Buffer[i].DataBuffer[m].Type = KX_Fault_IF.Type;
FaultReport->Buffer[i].DataBuffer[m++].Mode = KX_Fault_IF.Mode;
//7.保护电流
FaultReport->Buffer[i].DataBuffer[m].Type = KX_ITF_TYPE;
FaultReport->Buffer[i].DataBuffer[m++].Mode = KX_Fault_IF.Mode;
}
//8.阻抗
FaultReport->Buffer[i].DataBuffer[m].Type = KX_Fault_ZKValue.R.Type;
FaultReport->Buffer[i].DataBuffer[m++].Mode = KX_Fault_ZKValue.R.Mode;
//9.角度
FaultReport->Buffer[i].DataBuffer[m].Type = KX_Q_Z_TYPE;
FaultReport->Buffer[i].DataBuffer[m++].Mode = DisplayMode;
//10.电阻
//IndexOfR = m;
FaultReport->Buffer[i].DataBuffer[m].Type = KX_R_TYPE;
FaultReport->Buffer[i].DataBuffer[m++].Mode = KX_Fault_ZKValue.R.Mode;
//11.电抗
//IndexOfX = m;
FaultReport->Buffer[i].DataBuffer[m].Type = KX_X_TYPE;
FaultReport->Buffer[i].DataBuffer[m++].Mode = KX_Fault_ZKValue.X.Mode;
//12.二次谐波含量
FaultReport->Buffer[i].DataBuffer[m].Type = KX_IH2_TYPE;
FaultReport->Buffer[i].DataBuffer[m++].Mode = DisplayMode;
//13.公里标
//IndexOfGLB = m;
FaultReport->Buffer[i].DataBuffer[m].Type = KX_DIS_TYPE;
FaultReport->Buffer[i].DataBuffer[m++].Mode = DisplayMode;
//14.距离
//IndexOfL = m;
FaultReport->Buffer[i].DataBuffer[m].Type = KX_L_TYPE;
FaultReport->Buffer[i].DataBuffer[m++].Mode = DisplayMode;
FaultReport->Buffer[i].HasWave = 0; //波形
FaultReport->Buffer[i].SoeNumber = 0; //事件个数
FaultReport->Buffer[i].ParameterNumber = m; //参数个数
//距离显示方式整定为不显示 20181112
if(KX_XLSet.IP == NOTCJ_MODE)
{
FaultReport->Buffer[i].ParameterNumber -= 2; //参数个数
}
else if(KX_XLSet.IP == JL_MODE)
{
FaultReport->Buffer[i].ParameterNumber -= 1; //参数个数
}
//故障录波
FaultReport->Buffer[i].WaveValue.DeviceType = DEV_KX;
//FaultReport->Buffer[i].WaveValue.ChannelNum = KX_WAVE_PROTECT_NUMBER; //录波通道数
for(j = 0; j < KX_WAVE_PROTECT_NUMBER; j++)
{
ChannelNo = WaveChannelSet[j];
//类型为0时该通道不上送
//if(ANALOG_UNDEFINE == ChannelValue[ChannelNo].YouXiaoZhi[JiBo].Analog.Type)
//{
// continue;
//}
FaultReport->Buffer[i].WaveValue.ChannelData[j].Type = ChannelValue[ChannelNo].YouXiaoZhi[JiBo].Analog.Type;
FaultReport->Buffer[i].WaveValue.ChannelData[j].Mode = SETVALUE_MODE_2;//固定录二次值 ChannelValue[ChannelNo].YouXiaoZhi[JiBo].Analog.Mode;
FaultReport->Buffer[i].WaveValue.ChannelData[j].XiShu = ChannelValue[ChannelNo].CoeffiWave2;//ChannelValue[ChannelNo].XiShu;
FaultReport->Buffer[i].WaveValue.ChannelData[j].RatioValue1 = ChannelValue[ChannelNo].RatioValue2 * ChannelValue[ChannelNo].BianBi;
FaultReport->Buffer[i].WaveValue.ChannelData[j].RatioValue2 = ChannelValue[ChannelNo].RatioValue2;
FaultReport->Buffer[i].WaveValue.ChannelData[j].SampleNumber = SAMPLE_NUM;
FaultReport->Buffer[i].WaveValue.ChannelData[j].Length = 0;
FaultReport->Buffer[i].WaveValue.DigitalData.Number = DigitalWaveChannelSet.Number;
for (k = 0; k < FAULT_WAVE_LEN; k++) FaultReport->Buffer[i].WaveValue.ChannelData[j].Data[k] = 0;
}
FaultReport->Buffer[i].WaveValue.ChannelNum = j; //录波通道数
}//endfor
//负荷录波
LoadWaveBuffer->DeviceType = DEV_KX;
//LoadWaveBuffer->ChannelNum = KX_WAVE_NUMBER; //负荷录波通道数
for(j = 0; j < KX_WAVE_NUMBER; j++)
{
ChannelNo = WaveChannelSet[j];
//类型为0时该通道不上送
//if(ANALOG_UNDEFINE == ChannelValue[ChannelNo].YouXiaoZhi[JiBo].Analog.Type)
//{
// continue;
//}
LoadWaveBuffer->ChannelData[j].Type = ChannelValue[ChannelNo].YouXiaoZhi[JiBo].Analog.Type;
LoadWaveBuffer->ChannelData[j].Mode = SETVALUE_MODE_2;//ChannelValue[ChannelNo].YouXiaoZhi[JiBo].Analog.Mode;
LoadWaveBuffer->ChannelData[j].XiShu = ChannelValue[ChannelNo].CoeffiWave2;//固定录二次值 //ChannelValue[ChannelNo].XiShu;
LoadWaveBuffer->ChannelData[j].RatioValue1 = ChannelValue[ChannelNo].RatioValue2 * ChannelValue[ChannelNo].BianBi;
LoadWaveBuffer->ChannelData[j].RatioValue2 = ChannelValue[ChannelNo].RatioValue2;
LoadWaveBuffer->ChannelData[j].SampleNumber = SAMPLE_NUM;
LoadWaveBuffer->ChannelData[j].Length = 0;
for (k = 0; k < FAULT_WAVE_LEN; k++) LoadWaveBuffer->ChannelData[j].Data[k] = 0;
}
//数字量录波
//MemPtrSet.pWave->DigitalData.Number = DigitalWaveChannelSet.Number;
LoadWaveBuffer->ChannelNum = j; //负荷录波通道数
LoadWaveBuffer->DigitalData.Number = DigitalWaveChannelSet.Number;
MeasureValue.DeviceType = DEV_KX;
MeasureValue.Number = KX_MX_NUMBER * 2;
unsigned char measureparam[][4] =
{
{KX_MX_U1M_1,CH_KX_U,KX_U1M_TYPE,KX_UT1M_TYPE}, //T线测量电压1
{KX_MX_U1M_2,CH_KX_UT2,KX_U2M_TYPE,KX_UT2M_TYPE}, //T线测量电压2
{KX_MX_U2M_1,CH_KX_UF,KX_UNUSE_TYPE,KX_UF1M_TYPE}, //F线测量电压1
{KX_MX_U2M_2,CH_KX_UF2,KX_UNUSE_TYPE,KX_UF2M_TYPE}, //F线测量电压2
{KX_MX_I1M,CH_KX_CL_I,KX_IM_TYPE,KX_ITM_TYPE}, //T线测量电流
{KX_MX_I2M,CH_KX_CL_IF,KX_UNUSE_TYPE,KX_IFM_TYPE}, //F线测量电流
{KX_MX_Fre,ANALOG_UNDEFINE,KX_FRE_TYPE,KX_FRE_TYPE}, //频率
{KX_MX_U1_1,CH_KX_U,KX_U1_TYPE,KX_UT1_TYPE}, //T线保护电压1
{KX_MX_Q_U1_1,CH_KX_U,KX_Q_U1_TYPE,KX_Q_UT1_TYPE}, //T线保护电压1角度
{KX_MX_U1_2,CH_KX_UT2,KX_U2_TYPE,KX_UT2_TYPE}, //T线保护电压2
{KX_MX_Q_U1_2,CH_KX_UT2,KX_Q_U2_TYPE,KX_Q_UT2_TYPE}, //T线保护电压2角度
{KX_MX_U2_1,CH_KX_UF,KX_UNUSE_TYPE,KX_UF1_TYPE}, //F线保护电压1
{KX_MX_Q_U2_1,CH_KX_UF,KX_UNUSE_TYPE,KX_Q_UF1_TYPE}, //F线保护电压1角度
{KX_MX_U2_2,CH_KX_UF2,KX_UNUSE_TYPE,KX_UF2_TYPE}, //F线保护电压2
{KX_MX_Q_U2_2,CH_KX_UF2,KX_UNUSE_TYPE,KX_Q_UF2_TYPE},//F线保护电压2角度
{KX_MX_I1,CH_KX_BH_I,KX_I_TYPE, KX_IT_TYPE}, //T线保护电流
{KX_MX_Q_I1,ANALOG_UNDEFINE,KX_Q_I_TYPE,KX_Q_IT_TYPE}, //T线保护电流角度
{KX_MX_I2,CH_KX_BH_IF,KX_UNUSE_TYPE,KX_IF_TYPE}, //F线保护电流
{KX_MX_Q_I2,ANALOG_UNDEFINE,KX_UNUSE_TYPE,KX_Q_IF_TYPE}, //F线保护电流角度
{KX_MX_ITF,ANALOG_UNDEFINE,KX_UNUSE_TYPE, KX_ITF_TYPE}, //TF保护电流
{KX_MX_Z,ANALOG_UNDEFINE,KX_Z_TYPE,KX_Z_TYPE}, //阻抗
{KX_MX_Q_Z,ANALOG_UNDEFINE,KX_Q_Z_TYPE,KX_Q_Z_TYPE}, //阻抗角
{KX_MX_IH2,ANALOG_UNDEFINE,KX_IH2_TYPE,KX_IH2_TYPE}, //二次谐波含量
};
number = sizeof(measureparam)/sizeof(measureparam[0]);
for(i = 0; i < number; i++)
{
k = measureparam[i][0];
m = k + KX_MX_NUMBER;
MeasureValue.Buffer[k].Value = 0; //母锟竭碉拷压
MeasureValue.Buffer[k].Mode = SETVALUE_MODE_1;
measure_param[k].smpchannel = measureparam[i][1];
if(AT_MODE == KX_PowerMode)
{
MeasureValue.Buffer[k].Type = measureparam[i][3];
}
else
{
MeasureValue.Buffer[k].Type = measureparam[i][2];
}
//二次参数
MeasureValue.Buffer[m].Value = 0;
MeasureValue.Buffer[m].Mode = SETVALUE_MODE_2;
MeasureValue.Buffer[m].Type = MeasureValue.Buffer[k].Type;
if(k < MX_MEASURE_NUMBER)
{
measure_param[k].type = ANALOG_MEASURE_TYPE;
}
else
{
measure_param[k].type = ANALOG_PROTECT_TYPE;
}
}
//偷跳监视参数初始化
dl_open_innormal_param_set(&KX_dl_open_innormal_param,KX_YAOXIN_QF,KX_DL_BTYF_KR,KX_DL_FZJS_KR,KX_DL_FZJS_KR,KX_YAOXIN_YCFZ,KX_DL_FZ_YC,kx_dl_innormal_open_alarm);
//锟截猴拷闸锟斤拷锟斤拷锟斤拷始锟斤拷
CHZValue.Status = CHZ_CLOSE; //锟截猴拷闸状态
CHZValue.ChongDianTime = 0; //锟截猴拷闸锟斤拷锟绞憋拷锟?
CHZValue.CHZTime = 0; //锟截猴拷闸时锟斤拷
CHZValue.DelayCount = 0; //锟斤拷闸锟斤拷时锟斤拷时锟斤拷
CHZValue.ChongDianOK = FAIL; //锟截猴拷闸锟斤拷锟絆K
//锟斤拷闸锟斤拷锟斤拷锟斤拷始锟斤拷
TZValue.Status = TZ_CLOSE; //锟斤拷闸状态
TZValue.IP = SUCCESS; //锟斤拷闸失锟斤拷锟街?SUCCESS:锟斤拷闸锟缴癸拷锟斤拷FAIL锟斤拷锟斤拷闸失锟斤拷
TZValue.DelayCount = 0; //锟斤拷闸锟斤拷时锟斤拷时锟斤拷
TZValue.FaultProcessEndIP = FAULT_REPORT_SENDED; //锟斤拷锟较达拷锟斤拷锟斤拷锟斤拷志
memset(KX_BaoHu_IBuffer,0,sizeof(KX_BaoHu_IBuffer));
memset(KX_US_Buffer,0,sizeof(KX_US_Buffer));
memset(KX_UC_Buffer,0,sizeof(KX_UC_Buffer));
KX_JYZK_R = 0; //锟斤拷锟斤拷锟斤拷锟?
KX_JYZK_X = 0; //锟斤拷锟斤拷缈?
KX_ZKSaveIP = 0; //锟斤拷压锟斤拷锟斤拷锟斤拷前指锟斤拷
KX_SaveIP = 0; //锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟角爸革拷锟?
KX_JD_I = KX_CTRated2; //锟斤拷锟较截断碉拷锟斤拷取锟斤拷锟斤拷锟斤拷锟斤拷锟筋定2锟斤拷值
if(DisplayMode == SETVALUE_MODE_1)
{
//锟斤拷一锟斤拷值锟斤拷
KX_JD_I = 0.03 * KX_JD_I * ChannelValue[CH_KX_BH_I].BianBi;
}
else
{
//锟斤拷锟斤拷锟斤拷值锟斤拷
KX_JD_I = 0.03 * KX_JD_I;
}
BaoHuDongZuoFailIP = 0;
//ZTDongZuoIP=TEST_CLOSE;
//if(ChannelValue[CH_KX_BH_I].BianBi != ChannelValue[CH_KX_BH_IF].BianBi)
// TFCTRatioDiffer = 1;
//else
//TFCTRatioDiffer = 0;
//if(ChannelValue[CH_KX_U].BianBi != ChannelValue[CH_KX_UF].BianBi)
// TFPTRatioDiffer = 1;
//else
//TFPTRatioDiffer = 0;
BaseValue_I = 0;
TempQiDongIP &= ~KX_BT_PTDX_SEG1FAULT;
kcDelayTimer_12 = 0;
kcDelayTimer_13 = 0;
KX_OtBigI = TEST_CLOSE;
KX_ZK2StartCounter = 0;
KX_ZK2ResetCounter = 0;
KX_I_reject_out = 0;
}
/***************************************************
* void settingtype_init()
* 定值类型初始化
****************************************************/
void settingtype_init()
{
int i = 0, j = 0;
//整定值个数初始化
USER_SET_LEN = sizeof(tagUserSetting_kx); //用户整定值
SYS_SET_LEN = sizeof(tagSysSetting_kx); //系统整定值
//用户定值
//供电方式
UserDzType[i++] = INTEGER_TYPE;
//CT额定值
for(j = 0; j < 2; j++)
{
UserDzType[i++] = FLOAT_TYPE;
}
//装置类型
UserDzType[i++] = INTEGER_TYPE;
//线路阻抗角
UserDzType[i++] = FLOAT_TYPE;
//距离保护1-3段
for(j = 0; j < 3; j++)
{
UserDzType[i++] = INTEGER_TYPE;
UserDzType[i++] = FLOAT_TYPE;
UserDzType[i++] = FLOAT_TYPE;
UserDzType[i++] = FLOAT_TYPE;
}
for(j = 0; j < 17; j++)
{
UserDzType[i++] = FLOAT_TYPE;
}
#ifdef PWPRTC_ENABLE
//供电臂保护
for(j = 0; j < 3; j++)
{
UserDzType[i++] = FLOAT_TYPE;
}
#endif
//电抗距离表
for(j = 0; j < 2; j++)
{
UserDzType[i++] = FLOAT_TYPE;
UserDzType[i++] = INTEGER_TYPE;
}
for(j = 0; j < 12; j++)
{
UserDzType[i++] = FLOAT_TYPE;
UserDzType[i++] = FLOAT_TYPE;
}
//厂家自定义
for(j = 0; j < 8; j++)
{
UserDzType[i++] = FLOAT_TYPE;
}
//控制字
for(j = 0; j < 7; j++)
{
UserDzType[i++] = INTEGER_TYPE;
}
#ifdef PWPRTC_ENABLE
for(j = 0; j < 2; j++)
{
UserDzType[i++] = INTEGER_TYPE;
}
#endif
//厂家自定义
for(j = 0; j < 4; j++)
{
UserDzType[i++] = INTEGER_TYPE;
}
//系统定值
i = 0;
//微调系数
for(j = 0; j < 11; j++)
{
SysDZType[i++] = FLOAT_TYPE;
}
//电压一次额定值
SysDZType[i++] = FLOAT_TYPE;
//流变角度修正参数
//SysDZType[i++] = FLOAT_TYPE;
//开关号
SysDZType[i++] = INTEGER_TYPE;
//动作时间
for(j = 0; j < 4; j++)
{
SysDZType[i++] = FLOAT_TYPE;
}
//断路器异常分闸告警
SysDZType[i++] = INTEGER_TYPE;
//测距参数
for(j = 0; j < 5; j++)
{
SysDZType[i++] = FLOAT_TYPE;
}
for(j = 0; j < 2; j++)
{
SysDZType[i++] = INTEGER_TYPE;
}
//距离保护参数
for(j = 0; j < 2; j++)
{
SysDZType[i++] = FLOAT_TYPE;
}
for(j = 0; j < 2; j++)
{
SysDZType[i++] = INTEGER_TYPE;
}
//综合谐波抑制
for(j = 0; j < 2; j++)
{
SysDZType[i++] = FLOAT_TYPE;
}
for(j = 0; j < 3; j++)
{
SysDZType[i++] = INTEGER_TYPE;
}
//重合闸参数
SysDZType[i++] = FLOAT_TYPE;
SysDZType[i++] = INTEGER_TYPE;
SysDZType[i++] = INTEGER_TYPE;
SysDZType[i++] = INTEGER_TYPE;
#ifdef PWPRTC_ENABLE
SysDZType[i++] = INTEGER_TYPE; //远方失灵闭锁重合闸
#endif
//进线参数
for(j = 0; j < 2; j++)
{
SysDZType[i++] = INTEGER_TYPE;
}
#ifdef PWPRTC_ENABLE
//供电臂保护参数 + 进线运行方式
for(j = 0; j < 4; j++)
{
SysDZType[i++] = INTEGER_TYPE;
}
#endif
SysDZType[i++] = INTEGER_TYPE; //无压手合加速跳闸
//电压自动切换
#ifdef KX_U_ADJUST_AUTO
SysDZType[i++] = INTEGER_TYPE;
#endif
//F压互
SysDZType[i++] = INTEGER_TYPE;
SysDZType[i++] = INTEGER_TYPE; //io插件2
SysDZType[i++] = INTEGER_TYPE;//母联隔开接线方式
//预留
for(j = 0; j < 7; j++)
{
SysDZType[i++] = FLOAT_TYPE;
}
}
/***************************************************
* unsigned int CheckSysSetting(unsigned char *Address)
****************************************************/
unsigned int CheckSysSetting(unsigned char *pAddress)
{
tagSysSetting_kx *pSysSetting,syssetting;
float *ptr;
memcpy(&syssetting,pAddress,sizeof(syssetting));
pSysSetting = &syssetting;
ptr = &pSysSetting->adjustcoeffi.VK;
//校正微调系数
for(;ptr <= &pSysSetting->adjustcoeffi.IFMK; ptr++)
{
if(*ptr < -5 || *ptr > 5)
{
SYS_RETURN_FAIL;
}
}
//校正阻抗角微调系数
if(pSysSetting->adjustcoeffi.QK < 0 || pSysSetting->adjustcoeffi.QK > 360.0)
{
SYS_RETURN_FAIL;
}
if(pSysSetting->adjustcoeffi.QFK < 0 || pSysSetting->adjustcoeffi.QFK > 360.0)
{
SYS_RETURN_FAIL;
}
//电压一次额定值
if(pSysSetting->u_rated_val < 1 || pSysSetting->u_rated_val > 100)
{
SYS_RETURN_FAIL;
}
//断路器异常分闸告警
if(pSysSetting->dl_innormal_open_alarm < 0 || pSysSetting->dl_innormal_open_alarm > 1)
{
SYS_RETURN_FAIL;
}
//校正电流角度修正值
//if(pSysSetting->angle_adjust_val_curr < 0 || pSysSetting->angle_adjust_val_curr > 359.9)
//{
//return FAIL;
//}
//校正配置参数
//单位互抗
if(pSysSetting->distanceparam.mr_unit < 0 || pSysSetting->distanceparam.mr_unit > 2.0)
{
return FAIL;
}
//供电臂长度
if(pSysSetting->distanceparam.pwarmlen < 0 || pSysSetting->distanceparam.pwarmlen > 100.0)
{
return FAIL;
}
//电抗偏移
if(pSysSetting->zparam.x_offset < 0 || pSysSetting->zparam.x_offset > 50)
{
return FAIL;
}
//小阻抗
if(pSysSetting->zparam.z_small < 0 || pSysSetting->zparam.z_small > 50)
{
return FAIL;
}
//记忆电压
if(pSysSetting->zparam.v_memory < 0 || pSysSetting->zparam.v_memory > 1)
{
return FAIL;
}
//PT安装位置
if(pSysSetting->inlineparam.qspos < 0 || pSysSetting->inlineparam.qspos > 2)
{
return FAIL;
}
//进线隔开类型
if(pSysSetting->inlineparam.qstype < 0 || pSysSetting->inlineparam.qstype > 2)
{
return FAIL;
}
//互抗补偿
if(pSysSetting->distanceparam.mzadjust < 0 || pSysSetting->distanceparam.mzadjust > 1)
{
return FAIL;
}
//分区所测距
if(pSysSetting->distanceparam.spcj < 0 || pSysSetting->distanceparam.spcj > 1)
{
return FAIL;
}
//选择性跳闸辅助判据
if(pSysSetting->selecttrip < 0 || pSysSetting->selecttrip > 1)
{
return FAIL;
}
//开关动作时间
if(pSysSetting->optime.t_qf < 0 || pSysSetting->optime.t_qf > 60.0)
{
return FAIL;
}
if(pSysSetting->optime.t_qs < 0 || pSysSetting->optime.t_qs > 60.0)
{
return FAIL;
}
//遥控脉宽
if(pSysSetting->optime.t_delay_qf < 0 || pSysSetting->optime.t_delay_qf > 60.0 || pSysSetting->optime.t_delay_qf > pSysSetting->optime.t_qf)
{
return FAIL;
}
if(pSysSetting->optime.t_delay_qs < 0 || pSysSetting->optime.t_delay_qs > 60.0 || pSysSetting->optime.t_delay_qs > pSysSetting->optime.t_qs)
{
return FAIL;
}
//综合谐波抑制
if(pSysSetting->SHI_setting.value > 0.900001 || pSysSetting->SHI_setting.value < 0.05)
{
return FAIL;
}
//抑制系数
if(pSysSetting->SHI_setting.coeffi > 5.0 || pSysSetting->SHI_setting.coeffi < 0.1)
{
return FAIL;
}
//抑制距离保护
if(pSysSetting->SHI_setting.z_enable > 1 || pSysSetting->SHI_setting.z_enable < 0)
{
return FAIL;
}
//抑制过电流
if(pSysSetting->SHI_setting.I_enable > 1 || pSysSetting->SHI_setting.I_enable < 0)
{
return FAIL;
}
//抑制增量
if(pSysSetting->SHI_setting.delta_enable > 1 || pSysSetting->SHI_setting.delta_enable < 0)
{
return FAIL;
}
//大电流闭锁重合闸
if(pSysSetting->reclose_setting.block_I_value < 0.1 || pSysSetting->reclose_setting.block_I_value > 100.0)
{
return FAIL;
}
if(pSysSetting->reclose_setting.I_block_enable < 0 || pSysSetting->reclose_setting.I_block_enable > 1)
{
return FAIL;
}
if(pSysSetting->reclose_setting.di_block_enable < 0 || pSysSetting->reclose_setting.di_block_enable > 1)
{
return FAIL;
}
if(pSysSetting->reclose_setting.dl_innormal_open_antorcls < 0 || pSysSetting->reclose_setting.dl_innormal_open_antorcls > 1)
{
return FAIL;
}
#ifdef PWPRTC_ENABLE
//远方失灵闭锁重合闸
if(pSysSetting->reclose_setting.rmt_qfbreak_block_enable < 0 || pSysSetting->reclose_setting.rmt_qfbreak_block_enable > 1)
{
return FAIL;
}
//进线运行方式
if(pSysSetting->inlineparam.mode < 0 || pSysSetting->inlineparam.mode > 2)
{
return FAIL;
}
//安装位置为分区所
if(pSysSetting->sp < 0 || pSysSetting->sp > 1)
{
return FAIL;
}
//母线越区
if(pSysSetting->busover < 0 || pSysSetting->sp > 1)
{
return FAIL;
}
//允许自动切换定值区
if(pSysSetting->autochangesetzone < 0 || pSysSetting->autochangesetzone > 1)
{
return FAIL;
}
#endif
#ifdef KX_U_ADJUST_AUTO
if(pSysSetting->pt_back_non < 0 || pSysSetting->pt_back_non > 1)
{
return FAIL;
}
#endif
if(pSysSetting->lv_non_acc < 0 || pSysSetting->lv_non_acc > 1)
{
return FAIL;
}
if(pSysSetting->pt_f_non < 0 || pSysSetting->pt_f_non > 1)
{
return FAIL;
}
if(pSysSetting->IO2_enable < 0 || pSysSetting->IO2_enable > 1)
{
return FAIL;
}
//分区所电源侧供电线长度
if(pSysSetting->distanceparam.pl_len_sp_in < 0 || pSysSetting->distanceparam.pl_len_sp_in > 100.0)
{
return FAIL;
}
//分区所越区侧供电线长度
if(pSysSetting->distanceparam.pl_len_sp_out < 0 || pSysSetting->distanceparam.pl_len_sp_out > 100.0)
{
return FAIL;
}
//分区所越区侧上网点公里标
if(pSysSetting->distanceparam.km_sp_out < 0 || pSysSetting->distanceparam.km_sp_out > 9999.0)
{
return FAIL;
}
if(pSysSetting->gk_u1_u2 < U_EXCHANGE_MODE_GK_NON || pSysSetting->gk_u1_u2 > U_EXCHANGE_MODE_U1_GK1_Gk2_T_U2)
{
return FAIL;
}
return SUCCESS;
}
/************************************************
* void ReadSysSetValue(unsigned char *Address)
*************************************************/
void ReadSysSetValue(unsigned char *pAddress)
{
tagSysSetting_kx *pSysSetting,syssetting;
memcpy(&syssetting,pAddress,sizeof(syssetting));
pSysSetting = &syssetting;
//微调系数
KX_VKSet = pSysSetting->adjustcoeffi.VK; //母线电压微调系数
KX_VK2Set = pSysSetting->adjustcoeffi.VK_2; //对侧电压微调系数
KX_VFKSet = pSysSetting->adjustcoeffi.VFK; //F线电压微调系数
KX_VFK2Set = pSysSetting->adjustcoeffi.VFK_2; //电压1微调系数
KX_BaoHuIKSet = pSysSetting->adjustcoeffi.IK; //保护电流微调系数
KX_CeLiangIKSet = pSysSetting->adjustcoeffi.IMK; //测量电流微调系数
KX_BaoHuFIKSet = pSysSetting->adjustcoeffi.IFK; //F线保护电流微调系数
KX_CeLiangFIKSet = pSysSetting->adjustcoeffi.IFMK; //F线测量电流微调系数
KX_ZKSet = pSysSetting->adjustcoeffi.ZK; //阻抗微调系数
KX_QSet = pSysSetting->adjustcoeffi.QK; //T线角度微调系数
KX_QFSet = pSysSetting->adjustcoeffi.QFK; //F线角度角微调系数
//保护配置参数
//断路器号
KX_DLQNo = pSysSetting->breakno;
kx_dl_innormal_open_alarm = pSysSetting->dl_innormal_open_alarm; //断路器异常分闸告警
//阻抗参数
KX_ZKTX_X = pSysSetting->zparam.x_offset; //容性电抗偏移量
KX_XZKSet = pSysSetting->zparam.z_small; //小阻抗设定值
KX_JYDYTouRu = pSysSetting->zparam.v_memory; //记忆电压
//进线参数
KX_GKMode = pSysSetting->inlineparam.qstype; //进线隔开类型
KX_JXPTPosition = pSysSetting->inlineparam.qspos; //进线PT安装位置
//综合谐波抑制
KX_XieBo_S = pSysSetting->SHI_setting.value; //综合谐波含量
#ifdef IH_PERCENT_UNIT
KX_XieBo_S *= PERCENT_UNIT_COEFFI;
#endif
KX_XieBo_XiShu = pSysSetting->SHI_setting.coeffi; //抑制系数
KX_ZK_XieBoSTouRu = pSysSetting->SHI_setting.z_enable; //阻抗综合谐波抑制压板，4字节
KX_I_XieBoSTouRu = pSysSetting->SHI_setting.I_enable; //过电流综合谐波抑制压板，4字节
KX_DLTI_XieBoSTouRu = pSysSetting->SHI_setting.delta_enable; //电流增量综合谐波抑制压板，4字节
#ifdef PWPRTC_ENABLE
//具备供电臂保护功能
KX_JXRunMode = pSysSetting->inlineparam.mode; //进线运行方式
if(BH_RUN == pSysSetting->busover)
{
KX_OverZoneMode = OVER_ZONE_BUS_MODE; //母线越区方式
}
else
{
KX_OverZoneMode = OVER_ZONE_NONBUS_MODE; //非母线越区方式
}
if(BH_RUN == pSysSetting->sp)
{
KX_PositionSet = SP;
}
else
{
KX_PositionSet = ATP;
}
//定值切换方式
if(BH_RUN == pSysSetting->autochangesetzone)
{
KX_SetChangeMode = CHANGE_ZD;
}
else
{
KX_SetChangeMode = CHANGE_SD; //定值切换方式
}
KX_YFBSTouRu = pSysSetting->reclose_setting.rmt_qfbreak_block_enable; //远方失灵闭锁重合闸
#else
KX_SetChangeMode = CHANGE_SD; //定值切换方式
KX_YFBSTouRu = BH_STOP;
#endif
//动作及操作时间
KX_OperationTime = pSysSetting->optime.t_qf * S_TO_MS_COEFFI; //断路器动作时间
KX_QSOperationTime = pSysSetting->optime.t_qs * S_TO_MS_COEFFI; //隔离开关动作时间
QFDelayTime = pSysSetting->optime.t_delay_qf * S_TO_MS_COEFFI; //断路器操作延时
QSDelayTime = pSysSetting->optime.t_delay_qs * S_TO_MS_COEFFI; //隔离开关操作延时
//测距参数
KX_XLSet.pwarmlen = pSysSetting->distanceparam.pwarmlen; //供电臂长度,不含供电线
//分区所测距参数，20231113
KX_XLSet.pllen_sp_in = pSysSetting->distanceparam.pl_len_sp_in; //分区所电源侧供电线长度
KX_XLSet.pllen_sp_out = pSysSetting->distanceparam.pl_len_sp_out; //分区所越区侧供电线长度
KX_XLSet.kmsp_out = pSysSetting->distanceparam.km_sp_out; //分区所越区侧上网点公里标
KX_XLSet.mrunit = pSysSetting->distanceparam.mr_unit; //单位互抗值
KX_CJTouRu = pSysSetting->distanceparam.spcj; //测距
KX_SelectTripTouRu = pSysSetting->selecttrip; //选择性跳闸辅助元件
//互抗补偿
if(BH_RUN == pSysSetting->distanceparam.mzadjust)
{
KX_BTMode = BT_DLINE_MODE;
}
else
{
KX_BTMode = BT_SLINE_MODE;
}
//重合闸参数
KX_CHZ_ISet = pSysSetting->reclose_setting.block_I_value; //大电流闭锁值
KX_DDLBSTouRu = pSysSetting->reclose_setting.I_block_enable; //大电流闭锁重合闸
KX_YJGZBSTouRu = pSysSetting->reclose_setting.di_block_enable; //外部开入闭锁重合闸
//20221226屏蔽该功能，需要时开放
//KX_YCFZ_CHZ_TuoRu = pSysSetting->reclose_setting.dl_innormal_open_antorcls; //异常分闸起动重合闸
KX_YCFZ_CHZ_TuoRu = BH_STOP; //异常分闸起动重合闸
//KX_YJGZBSTouRu = BH_RUN;
#ifdef KX_U_ADJUST_AUTO
//无备用压互
if(BH_RUN == pSysSetting->pt_back_non)
{
KX_U_AutoExchange = BH_STOP; //电压自动切换
}
else
{
KX_U_AutoExchange = BH_RUN; //电压自动切换
}
#else
KX_U_AutoExchange = BH_STOP;
#endif
KX_PTRated1 = pSysSetting->u_rated_val; //电压额定值
angle_amend_value = pSysSetting->adjustcoeffi.QK * -1;
//选配IO2
if(BH_STOP == pSysSetting->IO2_enable)
{
set_io_unenable(IO_NO_BOARD2);
}
//线路无压手合加速跳闸
if(BH_RUN == pSysSetting->lv_non_acc)
{
KX_lv_Acc = BH_STOP;
}
else
{
KX_lv_Acc = BH_RUN;
}
//F线无压互
if(BH_RUN == pSysSetting->pt_f_non)
{
KX_FUJR = BH_STOP;
}
else
{
KX_FUJR = BH_RUN;
}
kx_gk_u1_u2 = pSysSetting->gk_u1_u2;
}
void ChangeSysSetValue(void)
{
COS_QSet = cos(KX_QSet * PI / 180.0);
SIN_QSet = sin(KX_QSet * PI / 180.0);
COS_QFSet = cos(KX_QFSet * PI / 180.0);
SIN_QFSet = sin(KX_QFSet * PI / 180.0);
//拷贝断路器号
DLQNo = KX_DLQNo;
}
/***********************************************************************************************
* 校验用户定值
*20190528 L.Y. 修改校验方式
************************************************************************************************/
unsigned int CheckUserSetting(unsigned char *pAddress)
{
int i;
unsigned int *ptr;
float IMax,IMin,time_min;
tagUserSetting_kx *pUserSetting,usersetting;
//printf("hehehehhe\n");
memcpy(&usersetting,pAddress,sizeof(usersetting));
pUserSetting = &usersetting;
//供电方式
if(pUserSetting->powermode > 1)
{
SYS_RETURN_FAIL;
}
//额定值
if(pUserSetting->rated_setting.ct_rated1 < 1 || pUserSetting->rated_setting.ct_rated1 > 9999)
{
SYS_RETURN_FAIL;
}
if(JudgeFloatEqual(pUserSetting->rated_setting.ct_rated2,1.0) && JudgeFloatEqual(pUserSetting->rated_setting.ct_rated2,5.0))
{
SYS_RETURN_FAIL;
}
//电流上限,20倍额定
IMax = pUserSetting->rated_setting.ct_rated2 * 20;
IMin = pUserSetting->rated_setting.ct_rated2 * 0.1; //企标是0.1，降低下限，支持非标应用
//装置类型
if(pUserSetting->ralaytype > 3)
{
SYS_RETURN_FAIL;
}
//线路阻抗角
if(pUserSetting->Q_line < 60.0 || pUserSetting->Q_line > 85.0)
{
SYS_RETURN_FAIL;
}
//距离保护
for(i = 0; i < 3; i++)
{
//方向
if(pUserSetting->z_setting[i].dir > 2)
{
SYS_RETURN_FAIL;
}
//电抗
if(pUserSetting->z_setting[i].x > 800.0 || pUserSetting->z_setting[i].x < 0.5)
{
SYS_RETURN_FAIL;
}
//电阻
if(pUserSetting->z_setting[i].r > 800.0 || pUserSetting->z_setting[i].r < 0.5)
{
SYS_RETURN_FAIL;
}
//时限
if(pUserSetting->z_setting[i].t > 10.0 || pUserSetting->z_setting[i].t < 0)
{
SYS_RETURN_FAIL;
}
}
//电流速断
if(pUserSetting->fasttrip_setting.I > IMax || pUserSetting->fasttrip_setting.I < IMin)
{
SYS_RETURN_FAIL;
}
if(pUserSetting->fasttrip_setting.t > 10.0 || pUserSetting->fasttrip_setting.t < 0)
{
SYS_RETURN_FAIL;
}
//低压起动过电流
if(pUserSetting->overcurrent_setting.I > IMax || pUserSetting->overcurrent_setting.I < IMin)
{
SYS_RETURN_FAIL;
}
if(pUserSetting->overcurrent_setting.U > 100.0 || pUserSetting->overcurrent_setting.U < 2)
{
SYS_RETURN_FAIL;
}
if(pUserSetting->overcurrent_setting.t > 10.0 || pUserSetting->overcurrent_setting.t < 0)
{
SYS_RETURN_FAIL;
}
//电流增量
if(pUserSetting->deltaI_setting.I > IMax || pUserSetting->deltaI_setting.I < IMin)
{
SYS_RETURN_FAIL;
}
if(pUserSetting->deltaI_setting.t > 10.0 || pUserSetting->deltaI_setting.t < 0)
{
SYS_RETURN_FAIL;
}
//失压
if(pUserSetting->vabsent_setting.U > 100.0 || pUserSetting->vabsent_setting.U < 10.0)
{
SYS_RETURN_FAIL;
}
if(pUserSetting->vabsent_setting.t > 10.0 || pUserSetting->vabsent_setting.t < 0.1)
{
SYS_RETURN_FAIL;
}
//PT断线
if(pUserSetting->vts_setting.U > 100.0 || pUserSetting->vts_setting.U < 10.0)
{
SYS_RETURN_FAIL;
}
if(pUserSetting->vts_setting.I > IMax || pUserSetting->vts_setting.I < IMin)
{
SYS_RETURN_FAIL;
}
if(pUserSetting->vts_setting.I_low > IMax || pUserSetting->vts_setting.I_low < 0 || pUserSetting->vts_setting.I_low > pUserSetting->vts_setting.I)
{
SYS_RETURN_FAIL;
}
//二次谐波闭锁
if(pUserSetting->IH2 > 0.300001 || pUserSetting->IH2 < 0.05)
{
SYS_RETURN_FAIL;
}
//重合闸
if(pUserSetting->recls_setting.t > 10.0 || pUserSetting->recls_setting.t < 1)
{
SYS_RETURN_FAIL;
}
if(pUserSetting->recls_setting.t_reset > 60.0 || pUserSetting->recls_setting.t_reset < 5)
{
SYS_RETURN_FAIL;
}
if(pUserSetting->recls_setting.t_acc > 1.0 || pUserSetting->recls_setting.t_acc < 0)
{
SYS_RETURN_FAIL;
}
if(pUserSetting->recls_setting.u > 100.0 || pUserSetting->recls_setting.u < 50.0)
{
SYS_RETURN_FAIL;
}
//后加速时间不能大于元件时限
//距离1段
if(BH_RUN == pUserSetting->ctrlword_setting.z1)
{
if(pUserSetting->recls_setting.t_acc > pUserSetting->z_setting[0].t)
{
SYS_RETURN_FAIL;
}
}
//距离2段
if(BH_RUN == pUserSetting->ctrlword_setting.z2)
{
if(pUserSetting->recls_setting.t_acc > pUserSetting->z_setting[1].t)
{
SYS_RETURN_FAIL;
}
}
//距离3段
if(BH_RUN == pUserSetting->ctrlword_setting.z3)
{
if(pUserSetting->recls_setting.t_acc > pUserSetting->z_setting[2].t)
{
SYS_RETURN_FAIL;
}
}
//电流速断
if(BH_RUN == pUserSetting->ctrlword_setting.fasttrip)
{
if(pUserSetting->recls_setting.t_acc > pUserSetting->fasttrip_setting.t)
{
SYS_RETURN_FAIL;
}
}
//过电流
if(BH_RUN == pUserSetting->ctrlword_setting.overcurrent)
{
if(pUserSetting->recls_setting.t_acc > pUserSetting->overcurrent_setting.t)
{
SYS_RETURN_FAIL;
}
}
//电流增量
if(BH_RUN == pUserSetting->ctrlword_setting.deltaI)
{
if(pUserSetting->recls_setting.t_acc > pUserSetting->deltaI_setting.t)
{
SYS_RETURN_FAIL;
}
}
//供电臂保护
#ifdef PWPRTC_ENABLE
//电抗
if(pUserSetting->pw_setting.x > 800.0 || pUserSetting->pw_setting.x < 0.5)
{
SYS_RETURN_FAIL;
}
//电阻
if(pUserSetting->pw_setting.r > 800.0 || pUserSetting->pw_setting.r < 0.5)
{
SYS_RETURN_FAIL;
}
//时限
if(pUserSetting->pw_setting.t > 10.0 || pUserSetting->pw_setting.t < 0)
{
SYS_RETURN_FAIL;
}
#endif
//电抗距离表
if(pUserSetting->xl_setting.km_ss > 9999.0 || pUserSetting->xl_setting.km_ss < 0)
{
SYS_RETURN_FAIL;
}
if(pUserSetting->xl_setting.km_dir > 1)
{
SYS_RETURN_FAIL;
}
if(pUserSetting->xl_setting.pl_len > 100.0 || pUserSetting->xl_setting.pl_len < 0)
{
SYS_RETURN_FAIL;
}
if(pUserSetting->xl_setting.xlpointnum > 12)
{
SYS_RETURN_FAIL;
}
for(i = 0; i < 12; i++)
{
if(pUserSetting->xl_setting.xl[i].x > 800.0 || pUserSetting->xl_setting.xl[i].x < 0)
{
SYS_RETURN_FAIL;
}
if(pUserSetting->xl_setting.xl[i].L < 0 || pUserSetting->xl_setting.xl[i].L > 100.0)
{
SYS_RETURN_FAIL;
}
}
for(i = 1; i < pUserSetting->xl_setting.xlpointnum; i++)
{
if(pUserSetting->xl_setting.xl[i].x <= pUserSetting->xl_setting.xl[i - 1].x)
{
SYS_RETURN_FAIL;
}
if(pUserSetting->xl_setting.xl[i].L < pUserSetting->xl_setting.xl[i - 1].L)
{
SYS_RETURN_FAIL;
}
}
//控制字
ptr = &pUserSetting->ctrlword_setting.z1;
i = sizeof(pUserSetting->ctrlword_setting) / 4;
for(; i > 0;i--,ptr++)
{
if(*ptr > 1)
{
SYS_RETURN_FAIL;
}
}
return SUCCESS;
}
/********************************************************************
* void ChangeUserSetValue(void)
* 校验定值范围
********************************************************************/
void ChangeUserSetValue(void)
{
//锟斤拷锟斤拷说锟斤拷锟斤拷
unsigned int i,time_min = 0,ip = 0;
float XiShuValue = 1.0;
//KX_ZKTX_QL_Return = 1.0 / tan((KX_ZKTX_QL - 0.5) * PI / 180.0);
//KX_ZKTX_Q1_Return = 1.0 / tan((KX_ZKTX_Q1 + 0.5) * PI / 180.0);
KX_ZKTX_QL = 1.0 / tan(KX_ZKTX_QL * PI / 180.0);
//转锟斤拷锟斤拷涌锟斤拷偏锟狡斤拷
KX_ZKTX_Q1 = 1.0 / tan(KX_ZKTX_Q1 * PI / 180.0);
#ifdef ZERO_DEADLINE_CONPENSATION
if(KX_Z1Set.Time <= 3) KX_Z1Set.Time = 3;
if(KX_Z2Set.Time <= 3) KX_Z2Set.Time = 3;
if(KX_Z3Set.Time <= 3) KX_Z3Set.Time = 3;
//if(KX_Z4Set.Time <= 3) KX_Z4Set.Time = 3;
if(KX_SDISet.Time <= 3) KX_SDISet.Time = 3;
if(KX_ISet.Time <= 3) KX_ISet.Time = 3;
if(KX_DLTISet.Time <= 3) KX_DLTISet.Time = 3;
if(KX_SYSet.Time <= 3) KX_SYSet.Time = 3;
if(KX_JYYSet.Time <= 3) KX_JYYSet.Time = 3;
//if(KX_FISet.Time1 <= 3) KX_FISet.Time1 = 3;
//if(KX_FISet.Time2 <= 3) KX_FISet.Time2 = 3;
//if(KX_FISet.Time3 <= 3) KX_FISet.Time3 = 3;
if(KX_PwrSecPrtcSet.Time <= 3) KX_PwrSecPrtcSet.Time = 3;
#endif
if(BH_RUN == KX_Z1TouRu)
{
time_min = KX_Z1Set.Time;
ip = 1;
}
if(BH_RUN == KX_Z2TouRu)
{
if(0 == ip || time_min > KX_Z2Set.Time)
{
time_min = KX_Z2Set.Time;
}
ip = 1;
}
if(BH_RUN == KX_Z3TouRu)
{
if(0 == ip || time_min > KX_Z3Set.Time)
{
time_min = KX_Z3Set.Time;
}
ip = 1;
}
if(BH_RUN == KX_ITouRu)
{
if(0 == ip || time_min > KX_ISet.Time)
{
time_min = KX_ISet.Time;
}
ip = 1;
}
if(BH_RUN == KX_DLTITouRu)
{
if(0 == ip || time_min > KX_DLTISet.Time)
{
time_min = KX_DLTISet.Time;
}
ip = 1;
}
if(1 == ip && time_min > KX_AccTimeSet)
{
time_min = KX_AccTimeSet;
}
if(time_min <= 10)
{
KX_HI2_Block_Time_Set = 0;
}
else
{
KX_HI2_Block_Time_Set = time_min - 10;
if(KX_HI2_Block_Time_Set > 6)
{
KX_HI2_Block_Time_Set = 6;
}
}
if(DisplayMode == SETVALUE_MODE_1)
{
XiShuValue = ChannelValue[CH_KX_U].BianBi / ChannelValue[CH_KX_BH_I].BianBi;
//二次定值转一次
KX_Z1Set.RValue = KX_Z1Set.RValue * XiShuValue;
KX_Z1Set.XValue = KX_Z1Set.XValue * XiShuValue;
//二次定值转一次
KX_Z2Set.RValue = KX_Z2Set.RValue * XiShuValue;
KX_Z2Set.XValue = KX_Z2Set.XValue * XiShuValue;
//二次定值转一次
KX_Z3Set.RValue = KX_Z3Set.RValue * XiShuValue;
KX_Z3Set.XValue = KX_Z3Set.XValue * XiShuValue;
//转锟斤拷锟借抗锟斤拷锟斤拷锟斤拷值
//KX_Z4Set.RValue = KX_Z4Set.RValue * XiShuValue;
//KX_Z4Set.XValue = KX_Z4Set.XValue * XiShuValue;
//供电臂保护
KX_PwrSecPrtcSet.RValue = KX_PwrSecPrtcSet.RValue * XiShuValue;
KX_PwrSecPrtcSet.XValue = KX_PwrSecPrtcSet.XValue * XiShuValue;
//母线保护
//20180905 用于开闭所进线
KX_BusPrtcSet.SetValue = KX_BusPrtcSet.SetValue * ChannelValue[CH_KX_BH_I].BianBi;
//二次定值转一次
KX_SDISet.SetValue = KX_SDISet.SetValue * ChannelValue[CH_KX_BH_I].BianBi;
//二次定值转一次
KX_ISet.SetValue = KX_ISet.SetValue * ChannelValue[CH_KX_BH_I].BianBi;
//二次定值转一次
KX_DLTISet.SetValue = KX_DLTISet.SetValue * ChannelValue[CH_KX_BH_I].BianBi;
//进线失压
//检有压
//进线失压
KX_SYSet.SetValue = KX_SYSet.SetValue * ChannelValue[CH_KX_U].BianBi / 1000;//KV
//检有压
KX_JYYSet.SetValue = KX_JYYSet.SetValue * ChannelValue[CH_KX_U].BianBi / 1000;
//二次定值转一次
//KX_FISet.SetValue1 = KX_FISet.SetValue1 * ChannelValue[CH_KX_BH_I].BianBi;
//KX_FISet.SetValue2 = KX_FISet.SetValue2 * ChannelValue[CH_KX_BH_I].BianBi;
//KX_FISet.SetValue3 = KX_FISet.SetValue3 * ChannelValue[CH_KX_BH_I].BianBi;
//二次定值转一次
KX_CHZ_ISet = KX_CHZ_ISet * ChannelValue[CH_KX_BH_I].BianBi;
//二次定值转一次
KX_DYUSet = KX_DYUSet * ChannelValue[CH_KX_U].BianBi / 1000;
//二次定值转一次
KX_PTDX_USet = KX_PTDX_USet * ChannelValue[CH_KX_U].BianBi / 1000;
//二次定值转一次
KX_PTDX_ISet = KX_PTDX_ISet * ChannelValue[CH_KX_BH_I].BianBi;
KX_PTDX_ILowSet = KX_PTDX_ILowSet * ChannelValue[CH_KX_BH_I].BianBi;
//二次定值转一次
KX_ZKTX_X = KX_ZKTX_X * XiShuValue;
//20190816 modi CRCC电抗距离表电抗按1次整定
//for(i = 0; i < XL_POINT_NUM; i++) KX_XLSet.Value[i].XSet = KX_XLSet.Value[i].XSet * XiShuValue;
//二次定值转一次
KX_XZKSet *= XiShuValue;
}
else //DisplayMode == SETVALUE_MODE_2
{
XiShuValue = ChannelValue[CH_KX_BH_I].BianBi / ChannelValue[CH_KX_U].BianBi;
for(i = 0; i < XL_POINT_NUM; i++)
{
KX_XLSet.Value[i].XSet = KX_XLSet.Value[i].XSet * XiShuValue;
}
//单位互抗值为1次值
KX_XLSet.mrunit = KX_XLSet.mrunit * XiShuValue;
}
}
/*****************************************************************************
* void ReadUserSetValue(unsigned char *Address)
*
*******************************************************************************/
void ReadUserSetValue(unsigned char *pAddress)
{
int i,offset,number;
tagUserSetting_kx *pUserSetting,usersetting;
memcpy(&usersetting,pAddress,sizeof(usersetting));
pUserSetting = &usersetting;
//断路器号
//KX_DLQNo = pUserSetting->breakno;
//供电方式
KX_PowerMode = pUserSetting->powermode;
//CT额定值
KX_CTRated1 = pUserSetting->rated_setting.ct_rated1;
KX_CTRated2 = pUserSetting->rated_setting.ct_rated2;
//线路阻抗角
KX_ZKTX_QL = pUserSetting->Q_line;
//距离1段
KX_Z1Set.DirMod = pUserSetting->z_setting[0].dir;
KX_Z1Set.RValue = pUserSetting->z_setting[0].r;
KX_Z1Set.XValue = pUserSetting->z_setting[0].x;
KX_Z1Set.Time = pUserSetting->z_setting[0].t * S_TO_MS_COEFFI;
//距离2段
KX_Z2Set.DirMod = pUserSetting->z_setting[1].dir;
KX_Z2Set.RValue = pUserSetting->z_setting[1].r;
KX_Z2Set.XValue = pUserSetting->z_setting[1].x;
KX_Z2Set.Time = pUserSetting->z_setting[1].t * S_TO_MS_COEFFI;
//距离3段
KX_Z3Set.DirMod = pUserSetting->z_setting[2].dir;
KX_Z3Set.RValue = pUserSetting->z_setting[2].r;
KX_Z3Set.XValue = pUserSetting->z_setting[2].x;
KX_Z3Set.Time = pUserSetting->z_setting[2].t * S_TO_MS_COEFFI;
//电流速断
KX_SDISet.Direction = NON_DIRECTION;
KX_SDISet.SetValue = pUserSetting->fasttrip_setting.I;
KX_SDISet.Time = pUserSetting->fasttrip_setting.t * S_TO_MS_COEFFI;
//过电流
KX_ISet.Direction = NON_DIRECTION;
KX_ISet.SetValue = pUserSetting->overcurrent_setting.I;
KX_ISet.Time = pUserSetting->overcurrent_setting.t * S_TO_MS_COEFFI;
//低压启动
KX_DYUSet = pUserSetting->overcurrent_setting.U;
//电流增量
KX_DLTISet.SetValue = pUserSetting->deltaI_setting.I;
KX_DLTISet.Time = pUserSetting->deltaI_setting.t * S_TO_MS_COEFFI;
//失压
KX_SYSet.SetValue = pUserSetting->vabsent_setting.U;
KX_SYSet.Time = pUserSetting->vabsent_setting.t * S_TO_MS_COEFFI;
//PT断线
KX_PTDX_USet = pUserSetting->vts_setting.U;
KX_PTDX_ISet = pUserSetting->vts_setting.I;
KX_PTDX_ILowSet = pUserSetting->vts_setting.I_low;
KX_PTDX_TimeSet = 2000; //PT断线时间固化为2000ms
//二次谐波闭锁
KX_XieBo_2 = pUserSetting->IH2;
#ifdef IH_PERCENT_UNIT
KX_XieBo_2 *= PERCENT_UNIT_COEFFI;
#endif
//重合闸
KX_CHZ_Time = pUserSetting->recls_setting.t * S_TO_MS_COEFFI;
KX_CHZ_ChongDianTime = pUserSetting->recls_setting.t_reset * S_TO_MS_COEFFI;
KX_AccTimeSet = pUserSetting->recls_setting.t_acc * S_TO_MS_COEFFI;
KX_JYYSet.SetValue = pUserSetting->recls_setting.u;
KX_JYYSet.Time = 100;
//电抗距离表
//上网点公里标
KX_XLSet.kmss = pUserSetting->xl_setting.km_ss;
//供电线长度
KX_XLSet.pllen = pUserSetting->xl_setting.pl_len;
//公里标方向
KX_XLSet.kmdir = pUserSetting->xl_setting.km_dir;
//分段点数
KX_XLSet.Number = pUserSetting->xl_setting.xlpointnum;
//XL表
memcpy(KX_XLSet.Value,pUserSetting->xl_setting.xl,sizeof(KX_XLSet.Value));
//非AT供电 馈线断路器 默认有测距功能
if(NOT_AT_MODE == KX_PowerMode && QF_TYPE_KX == pUserSetting->ralaytype)
{
KX_XLSet.IP = JL_GLB_MODE;
}
else
{
//其它情况，投入测距功能均测距
if(BH_RUN == KX_CJTouRu)
{
KX_XLSet.IP = JL_GLB_MODE;
}
else
{
KX_XLSet.IP = NOTCJ_MODE;
}
}
//控制字
KX_Z1TouRu = pUserSetting->ctrlword_setting.z1;
KX_Z2TouRu = pUserSetting->ctrlword_setting.z2;
KX_Z3TouRu = pUserSetting->ctrlword_setting.z3;
KX_SDITouRu = pUserSetting->ctrlword_setting.fasttrip;
KX_ITouRu = pUserSetting->ctrlword_setting.overcurrent;
KX_DLTITouRu = pUserSetting->ctrlword_setting.deltaI;
KX_JXSYTouRu = pUserSetting->ctrlword_setting.vabsent;
//以下为默认定值,通过既有定值转换
KX_ZKTX_Q1 = 85.0;
//KX_ZKTX_X = 0;
//AT供电方式下F线电压必须接入
if(NOT_AT_MODE == KX_PowerMode)
{
KX_FUJR = BH_STOP; //F线电压接入
}
SetValueMode = SETVALUE_MODE_2; //按二次整定
//安装位置及并联方式
//不能区分AT所与分区所
switch(pUserSetting->ralaytype)
{
case QF_TYPE_KX:
KX_PositionSet = SS; //安装位置
KX_ParallelMode = D_SWITCH_CONNECT; //并联方式
break;
case QF_TYPE_INLINE:
KX_PositionSet = SSP_JX;
KX_ParallelMode = D_SWITCH_CONNECT;
break;
case QF_TYPE_PARALLEL_S:
if(SP != KX_PositionSet)
{
KX_PositionSet = ATP;
}
KX_ParallelMode = S_SWITCH_CONNECT;
break;
case QF_TYPE_PARALLEL_D:
if(SP != KX_PositionSet)
{
KX_PositionSet = ATP;
}
KX_ParallelMode = D_SWITCH_CONNECT;
break;
default:
KX_PositionSet = SS; //安装位置
KX_ParallelMode = D_SWITCH_CONNECT;
break;
}
#ifdef PWPRTC_ENABLE
KX_PwrSecPrtcSet.XValue = pUserSetting->pw_setting.x;
KX_PwrSecPrtcSet.RValue = pUserSetting->pw_setting.r;
KX_PwrSecPrtcSet.Time = pUserSetting->pw_setting.t * S_TO_MS_COEFFI;
KX_PwrSecPrtcSet.DirMod = NON_DIRECTION; //用于母线保护
KX_PwrSecTouRu = pUserSetting->ctrlword_setting.pw;// 供电臂保护压板，4字节
KX_BusPrtcTouRu = pUserSetting->ctrlword_setting.bus;
#else
KX_PwrSecTouRu = BH_STOP; // 供电臂保护压板，4字节
KX_BusPrtcTouRu = BH_STOP; // 母线保护软压板
#endif
//KX_LS = LS_TC; //联锁定值(枚举量 1:退出 2:投入)
KX_Z4TouRu = BH_STOP; //阻抗Ⅳ段保护压板，4字节
KX_LUTouRu = KX_ITouRu; //低压启动
KX_FITouRu = BH_STOP; //过负荷保护压板，4字节
if(BH_RUN == KX_Z1TouRu || BH_RUN == KX_Z2TouRu || BH_RUN == KX_Z3TouRu || BH_RUN == KX_PwrSecTouRu || BH_RUN == KX_BusPrtcTouRu)
{
KX_ZK_Xiebo2TouRu = BH_RUN; //阻抗二次谐波闭锁压板，4字节
}
else
{
KX_ZK_Xiebo2TouRu = BH_STOP; //阻抗二次谐波闭锁压板，4字节
}
//KX_ZK_XieBoSTouRu = BH_STOP; //阻抗综合谐波抑制压板，4字节
KX_I_Xiebo2TouRu = KX_ITouRu; //过电流二次谐波闭锁压板，4字节
//KX_I_XieBoSTouRu = BH_STOP; //过电流综合谐波抑制压板，4字节
KX_DLTI_Xiebo2TouRu = KX_DLTITouRu; //电流增量二次谐波闭锁压板，4字节
//KX_DLTI_XieBoSTouRu = BH_STOP; //电流增量综合谐波抑制压板，4字节
if(SS == KX_PositionSet || (SSP_JX == KX_PositionSet && PT_POSITION_NON == KX_JXPTPosition))
{
//变电所或开闭所进线无进线PT
KX_JYYTouRu = BH_STOP; //检有压压板，4字节
}
else
{
KX_JYYTouRu = BH_RUN; //检有压压板，4字节
}
//KX_DDLBSTouRu = BH_STOP; //大电流闭锁重合闸压板，4字节
//KX_YJGZBSTouRu = BH_STOP; //永久性故障闭锁重合闸压板，4字节
//KX_YFBSTouRu = BH_STOP; // 远方失灵闭锁重合闸压板，4字节
KX_PTDXTouRu = BH_RUN; //PT断线压板，4字节
KX_SHBS = BH_STOP; //手合闭锁压板，4字节
KX_FDLTouRu = BH_STOP; //非电量压板，4字节
//控制字遥信初始化
offset = OFFSETOF(tagUserSetting_kx,ctrlword_setting);
number = sizeof(pUserSetting->ctrlword_setting) / 4;
ctrlwordinit(&pUserSetting->ctrlword_setting, offset,number,KX_YAOXIN_CTRLWD_START);
}
int checkurelatedtimeset(int channel)
{
if(SS == KX_PositionSet && BH_RUN == KX_U_AutoExchange)
{
if(CH_KX_U != channel && CH_KX_UF != channel && CH_KX_UT2 != channel && CH_KX_UF2 != channel)
{
return 0;
}
}
else if(CH_KX_U != channel && CH_KX_UF != channel)
{
return 0;
}
if(BH_RUN == KX_JXSYYJ.TouRuIP && KX_JXSYYJ.SetTime < 40)
{
return 1;
}
if(BH_RUN == KX_Z1YJ.TouRuIP && KX_Z1YJ.SetData->Time < 40)
{
return 1;
}
if(BH_RUN == KX_Z2YJ.TouRuIP && KX_Z2YJ.SetData->Time < 40)
{
return 1;
}
if(BH_RUN == KX_Z3YJ.TouRuIP && KX_Z3YJ.SetData->Time < 40)
{
return 1;
}
return 0;
}
/**************************************************************
* unsigned int GetUserSetting(unsigned int Number)
*
***************************************************************/
void GetSoftStripSetting()
{
tagSoftStripSetting_kx SoftStripSetting;
int num;
num = sizeof(SoftStripSetting) / sizeof(int);
//读软压板定值
ReadSoftStripValueFromFile();
//
ReadSoftStripSetting(SetValueBuffer,&SoftStripSetting, KX_RMTSIGNAL_SOFTSTRIP_START, num);
//检修
Check = SoftStripSetting.check;
//显示方式
if(BH_STOP == SoftStripSetting.secddisplay)
{
DisplayMode = SETVALUE_MODE_1;
}
else
{
DisplayMode = SETVALUE_MODE_2;
}
//重合闸软压板
KX_SoftStrip_Reclse = SoftStripSetting.reclse;
//进线自投软压板
KX_SoftStrip_InlineSwitch = SoftStripSetting.inlineswitch;
//联锁
#ifdef DEVICE_TYPE_DIGITAL
if(BH_RUN == SoftStripSetting.interlock)
{
KX_LS = LS_TR;
}
else
{
KX_LS = LS_TC;
}
#else
KX_LS = LS_TC;
#endif
}
/******************************************************************************
* Function: JXZT_CZ_Init
* Description:进线自投初始化
* Calls: none
* Called By:
* Input:
* Ouput:
* Return:
* others:
* History:
* 1.luoyang created
*
*******************************************************************************/
void JXZT_CZ_Init()
{
int step = 0;
switch(KX_JXPTPosition)
{
//PT在外侧
case PT_POSITION_OUT:
//检有压
JXZT_CZSet[step++] = JXZT_CZ_ISYY;
//锟界动锟斤拷锟诫开锟斤拷
//锟较革拷锟诫开锟斤拷
JXZT_CZSet[step++] = JXZT_CZ_QSHZ;
//锟较讹拷路锟斤拷
JXZT_CZSet[step++] = JXZT_CZ_QFHZ;
JXZT_CZSet[step] = JXZT_CZ_END;
break;
//PT锟节斤拷锟竭革拷锟诫开锟斤拷锟节诧拷
case PT_POSITION_IN:
//锟界动锟斤拷锟诫开锟斤拷
//锟较革拷锟诫开锟斤拷
JXZT_CZSet[step++] = JXZT_CZ_QSHZ;
//锟角凤拷锟斤拷压
JXZT_CZSet[step++] = JXZT_CZ_ISYY;
//锟较讹拷路锟斤拷
JXZT_CZSet[step++] = JXZT_CZ_QFHZ;
JXZT_CZSet[step] = JXZT_CZ_END;
break;
//锟睫斤拷锟斤拷PT
case PT_POSITION_NON:
//锟界动锟斤拷锟诫开锟斤拷
//锟较革拷锟诫开锟斤拷
JXZT_CZSet[step++] = JXZT_CZ_QSHZ;
//锟较讹拷路锟斤拷
JXZT_CZSet[step++] = JXZT_CZ_QFHZ;
//锟角凤拷锟斤拷压
JXZT_CZSet[step++] = JXZT_CZ_ISYY;
JXZT_CZSet[step] = JXZT_CZ_END;
break;
default:
JXZT_CZSet[step] = JXZT_CZ_INVALID;
break;
}
JXZT_CZSet[JXZT_CZ_FAIL_QFFZ_INDEX] = JXZT_CZ_QFFZ;
JXZT_CZSet[JXZT_CZ_FAIL_QSFZ_INDEX] = JXZT_CZ_QSFZ;
JXZT_CZSet[JXZT_CZ_FAIL_FINISH] = JXZT_CZ_FINISH;
}
void kx_breaker_err_param_init()
{
int i;
i = 0;
KX_Breaker_err_param.value[i++].channel = CH_KX_BH_I;
KX_Breaker_err_param.value[i++].channel = CH_KX_BH_IF;
KX_Breaker_err_param.number = i;
for(i = 0; i < KX_Breaker_err_param.number; i++)
{
if(SETVALUE_MODE_1 == ChannelValue[KX_Breaker_err_param.value[i].channel].YouXiaoZhi[JiBo].Analog.Mode)
{
KX_Breaker_err_param.value[i].set = BREAKER_ERR_I_COEFFI * ChannelValue[KX_Breaker_err_param.value[i].channel].RatioValue1;
}
else
{
KX_Breaker_err_param.value[i].set = BREAKER_ERR_I_COEFFI * ChannelValue[KX_Breaker_err_param.value[i].channel].RatioValue2;
}
}
}
/**************************************************
* void Reset_Init(void)
*
***************************************************/
void Reset_Init(void)
{
int i;
unsigned int CurrentSetNumber;
Init_IP = TEST_CLOSE;
LuBoValue.Length = 0;
LuBoValue.Count = 0;
LuBoValue.LoadCount = 0;
LuBoValue.LB_IP = LB_LOAD_WAVE_CLOSE;
FaultLuBoValue.Length = 0;
FaultLuBoValue.Count = 0;
FaultLuBoValue.LoadCount = 0;
FaultLuBoValue.LB_IP = LB_FAULT_WAVE_CLOSE;
pBlockEnable = &KX_LS;
GetSoftStripSetting(); //读软压板定值
CurrentSetNumber = GetSetNumber(NULL);
if(SUCCESS == GetSysSetting())
sysSV_RoutineSCIP = 0;
else
sysSV_RoutineSCIP = 1;
if(SUCCESS == GetUserSetting(CurrentSetNumber))
usrSV_RoutineSCIP = 0;
else
usrSV_RoutineSCIP = 1;
//进线自投
if(SSP_JX == KX_PositionSet)
{
JXZT_CZ_Init();
}
InitProtectItem();
InitAnalogChannel();
InitOutStatus();
InitRemoteObject();
//初始化软压板对象
InitSoftStrapCtrlObject();
InitData();
digit_Anin_Channal_Coeff_init();
AnalogRmsParamInit(&ZcpSet); //测量值计算参数初始化
InitBlock();
#ifdef PWPRTC_ENABLE
KX_ContactSignalInit(); //联络信号初始化
#endif
kx_breaker_err_param_init();
kx_itemClsDwnManageInit();
itemClsDwnManageInitV2();
kx_u_param_init();
Init_IP = TEST_START;
}
unsigned int ScaleAnalogChannel(unsigned char Number, float Parameter)
{
//锟斤拷锟斤拷说锟斤拷;锟教讹拷校锟斤拷
unsigned char ChNo;
float *Address, TempValue, tempParameter;
unsigned int DestAdd, Len, i, Sum;
union
{
unsigned char Value1[4];
// unsigned int Value2;
float Value2;//
} SetValue;
float FloatValue;
if(Number >= KDXZValue.Number) return FAIL; //通锟斤拷锟脚达拷锟襟，凤拷锟斤拷
Address = KDXZValue.Table[Number].SetValueAdd; //锟斤拷压微锟斤拷系锟斤拷锟街?
DestAdd = Number * 4;
switch(Number)
{
#if 0
case KX_Z: //锟借抗校锟斤拷
TempValue = Parameter / sqrt(KX_ZKValue.R.Value * KX_ZKValue.R.Value + KX_ZKValue.X.Value * KX_ZKValue.X.Value);
FloatValue = (*((float *)Address)) * TempValue;
break;
#endif
case KX_Q: //锟角讹拷校锟斤拷
case KX_Q_F:
if(JudgeFloatEqual(Parameter,300.0)) return FAIL;
//TempValue = Parameter - ComputeAngle(KX_ZKValue.R.Value, KX_ZKValue.X.Value);
ChNo = KDXZValue.Table[Number].ChannelNo;
TempValue = Parameter - ComputeAngleDiffPlus(CH_KX_U,ChNo);
//TempValue += *Address;
if(TempValue < 0) TempValue += 360;
if(TempValue >= 360) TempValue -= 360;
FloatValue = TempValue;
break;
default: //锟斤拷锟斤拷锟斤拷锟斤拷压校锟斤拷
ChNo = KDXZValue.Table[Number].ChannelNo; //模锟斤拷锟斤拷通锟斤拷锟斤拷
tempParameter = UIScaleCheck(Parameter, ChNo);
if(tempParameter == 0) return FAIL; //锟斤拷锟斤拷围
TempValue = Parameter / tempParameter;
if((TempValue < -5) || (TempValue > 5)) return FAIL; //锟斤拷锟斤拷围
FloatValue = (*((float *)Address)) * TempValue;
break;
} //endcase
//锟睫革拷系统锟斤拷锟斤拷锟叫碉拷值
// SetValue.Value2=(unsigned int)(FloatValue*1000); //锟斤拷锟斤拷锟斤拷锟斤拷转锟斤拷为锟斤拷锟斤拷
SetValue.Value2 = FloatValue; //
if(ReadSysSetValueFromFile(NULL,&Len,NULL) != SUCCESS) return FAIL;
//锟斤拷系统锟斤拷锟斤拷锟缴癸拷锟斤拷锟睫革拷系统锟斤拷锟斤拷
for(i = 0; i < 4; i++) SetValueBuffer[DestAdd+i] = SetValue.Value1[i];
//锟斤拷锟叫ｏ拷锟斤拷锟?
Sum = 0;
for(i = 0; i < Len; i++) Sum += SetValueBuffer[i];
//写系统锟斤拷锟斤拷锟?
if(WriteSysSetValueToFile(SetValueBuffer, Len,Sum) != SUCCESS) return FAIL;
Reset_Init(); //锟斤拷始锟斤拷系统
return SUCCESS;
}
//初始化软压板控制结构
void InitSoftStrapCtrlObject(void)
{
int i,number;
number = KX_SOFTSTRIP_OBJECT_NUMBER;
for(i = 0; i < number; i++)
{
SoftStrapObject[i].no = i;
SoftStrapObject[i].opersoecode_rm = KX_SOFTSTRIP_SOE_START_RM + i * 4;
SoftStrapObject[i].opersoecode_lc = KX_SOFTSTRIP_SOE_START_LC + i * 4;
SoftStrapObject[i].rmtsignalno = KX_RMTSIGNAL_SOFTSTRIP_START + i;
}
//
SoftStrapCtrlObject.YKStatus = TEST_CLOSE;
}
void InitRemoteObject(void)
{
RemoteObject.Number = KX_RMTCTRL_NUMBER;
// 复归
RemoteObject.Object[KX_FG].Type = FG_TYPE; //锟斤拷锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_FG].Name = 0; //锟斤拷锟斤拷锟斤拷,锟斤拷效
//RemoteObject.Object[KX_FG].Out_On_No = KX_FGQ_KC; //锟斤拷锟斤拷峡锟斤拷锟酵<E9949F>拷锟斤拷锟?
//RemoteObject.Object[KX_FG].Out_Off_No = KX_FGQ_KC; //锟斤拷锟斤拷挚锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_FG].YaoXinNo = 0; //锟斤拷应锟斤拷遥锟脚憋拷锟?锟斤拷
// QF
RemoteObject.Object[KX_QF].Type = BREAKER_TYPE; //锟斤拷锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_QF].Name = KX_DLQNo; //锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_QF].Out_On_No = KX_QF_HZ_KC; //锟斤拷锟斤拷峡锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_QF].Out_Off_No = KX_QF_FZ_KC; //锟斤拷锟斤拷挚锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_QF].YaoXinNo = KX_YAOXIN_QF; //锟斤拷应锟斤拷遥锟脚憋拷锟?
RemoteObject.Object[KX_QF].SoeCodeStart = KX_YK_QF_HZ_SUCCESS; //遥锟斤拷锟铰硷拷锟斤拷始锟斤拷锟斤拷
// 1QS
RemoteObject.Object[KX_1QS].Type = ISOLATOR_TYPE; //锟斤拷锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_1QS].Name = 0; //锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_1QS].Out_On_No = KX_1QS_HZ_KC; //锟斤拷锟斤拷峡锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_1QS].Out_Off_No = KX_1QS_TZ_KC; //锟斤拷锟斤拷挚锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_1QS].YaoXinNo = KX_YAOXIN_1QS; //锟斤拷应锟斤拷遥锟脚憋拷锟?
RemoteObject.Object[KX_1QS].SoeCodeStart = KX_YK_1QS_HZ_SUCCESS; //遥锟斤拷锟铰硷拷锟斤拷始锟斤拷锟斤拷
// 2QS
RemoteObject.Object[KX_2QS].Type = ISOLATOR_TYPE; //锟斤拷锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_2QS].Name = 0; //锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_2QS].Out_On_No = KX_2QS_HZ_KC; //锟斤拷锟斤拷峡锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_2QS].Out_Off_No = KX_2QS_TZ_KC; //锟斤拷锟斤拷挚锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_2QS].YaoXinNo = KX_YAOXIN_2QS; //锟斤拷应锟斤拷遥锟脚憋拷
RemoteObject.Object[KX_2QS].SoeCodeStart = KX_YK_2QS_HZ_SUCCESS; //遥锟斤拷锟铰硷拷锟斤拷始锟斤拷锟斤拷
// 3QS
RemoteObject.Object[KX_3QS].Type = ISOLATOR_TYPE; //锟斤拷锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_3QS].Name = 0; //锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_3QS].Out_On_No = KX_3QS_HZ_KC; //锟斤拷锟斤拷峡锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_3QS].Out_Off_No = KX_3QS_TZ_KC; //锟斤拷锟斤拷挚锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_3QS].YaoXinNo = KX_YAOXIN_3QS; //锟斤拷应锟斤拷遥锟脚憋拷锟?
RemoteObject.Object[KX_3QS].SoeCodeStart = KX_YK_3QS_HZ_SUCCESS; //遥锟斤拷锟铰硷拷锟斤拷始锟斤拷锟斤拷
// 4QS
RemoteObject.Object[KX_4QS].Type = ISOLATOR_TYPE; //锟斤拷锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_4QS].Name = 0; //锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_4QS].Out_On_No = KX_4QS_HZ_KC; //锟斤拷锟斤拷峡锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_4QS].Out_Off_No = KX_4QS_TZ_KC; //锟斤拷锟斤拷挚锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_4QS].YaoXinNo = KX_YAOXIN_4QS; //锟斤拷应锟斤拷遥锟脚憋拷锟?
RemoteObject.Object[KX_4QS].SoeCodeStart = KX_YK_4QS_HZ_SUCCESS; //遥锟斤拷锟铰硷拷锟斤拷始锟斤拷锟斤拷
#ifdef DEVICE_TYPE_DIGITAL
// 5QS
RemoteObject.Object[KX_5QS].Type = ISOLATOR_TYPE; //锟斤拷锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_5QS].Name = 0; //锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_5QS].Out_On_No = KX_5QS_HZ_KC; //锟斤拷锟斤拷峡锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_5QS].Out_Off_No = KX_5QS_TZ_KC; //锟斤拷锟斤拷挚锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_5QS].YaoXinNo = KX_YAOXIN_5QS; //锟斤拷应锟斤拷遥锟脚憋拷锟?
RemoteObject.Object[KX_5QS].SoeCodeStart = KX_YK_5QS_HZ_SUCCESS; //遥锟斤拷锟铰硷拷锟斤拷始锟斤拷锟斤拷
// 6QS
RemoteObject.Object[KX_6QS].Type = ISOLATOR_TYPE; //锟斤拷锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_6QS].Name = 0; //锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_6QS].Out_On_No = KX_6QS_HZ_KC; //锟斤拷锟斤拷峡锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_6QS].Out_Off_No = KX_6QS_TZ_KC; //锟斤拷锟斤拷挚锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_6QS].YaoXinNo = KX_YAOXIN_6QS; //锟斤拷应锟斤拷遥锟脚憋拷锟?
RemoteObject.Object[KX_6QS].SoeCodeStart = KX_YK_6QS_HZ_SUCCESS; //遥锟斤拷锟铰硷拷锟斤拷始锟斤拷锟斤拷
// 7QS
RemoteObject.Object[KX_7QS].Type = ISOLATOR_TYPE; //锟斤拷锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_7QS].Name = 0; //锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_7QS].Out_On_No = KX_7QS_HZ_KC; //锟斤拷锟斤拷峡锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_7QS].Out_Off_No = KX_7QS_TZ_KC; //锟斤拷锟斤拷挚锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_7QS].YaoXinNo = KX_YAOXIN_7QS; //锟斤拷应锟斤拷遥锟脚憋拷锟?
RemoteObject.Object[KX_7QS].SoeCodeStart = KX_YK_7QS_HZ_SUCCESS; //遥锟斤拷锟铰硷拷锟斤拷始锟斤拷锟斤拷
// 8QS
RemoteObject.Object[KX_8QS].Type = ISOLATOR_TYPE; //锟斤拷锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_8QS].Name = 0; //锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_8QS].Out_On_No = KX_8QS_HZ_KC; //锟斤拷锟斤拷峡锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_8QS].Out_Off_No = KX_8QS_TZ_KC; //锟斤拷锟斤拷挚锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_8QS].YaoXinNo = KX_YAOXIN_8QS; //锟斤拷应锟斤拷遥锟脚憋拷锟?
RemoteObject.Object[KX_8QS].SoeCodeStart = KX_YK_8QS_HZ_SUCCESS; //遥锟斤拷锟铰硷拷锟斤拷始锟斤拷锟斤拷
#endif
//检修软压板
RemoteObject.Object[KX_RMTCTRL_CHEK].Type = SOFT_STRIP_TYPE;
RemoteObject.Object[KX_RMTCTRL_CHEK].Out_On_No=KX_SOFTSTRIP_OBJECT_CHECK; //
//二次值显示软压板
RemoteObject.Object[KX_RMTCTRL_SECDDISPLAY].Type = SOFT_STRIP_TYPE;
RemoteObject.Object[KX_RMTCTRL_SECDDISPLAY].Out_On_No=KX_SOFTSTRIP_OBJECT_SECDDISPLAY; //
//重合闸软压板
RemoteObject.Object[KX_RMTCTRL_RECLS].Type = SOFT_STRIP_TYPE;
RemoteObject.Object[KX_RMTCTRL_RECLS].Out_On_No=KX_SOFTSTRIP_OBJECT_RECLS; //
//进线自投软压板
RemoteObject.Object[KX_RMTCTRL_INLINESWITCH].Type = SOFT_STRIP_TYPE;
RemoteObject.Object[KX_RMTCTRL_INLINESWITCH].Out_On_No=KX_SOFTSTRIP_OBJECT_INLINESWITCH; //
#ifdef DEVICE_TYPE_DIGITAL
//联锁软压板
RemoteObject.Object[KX_RMTCTRL_INTERBLOCK].Type = SOFT_STRIP_TYPE;
RemoteObject.Object[KX_RMTCTRL_INTERBLOCK].Out_On_No=KX_SOFTSTRIP_OBJECT_INTERLOCK; //
//联络信号测试
RemoteObject.Object[KX_CONTACT_TEST].Type = CUSTOM_TYPE;
RemoteObject.Object[KX_CONTACT_TEST].Name = 0;
#endif
//控制字遥控初始化
ctrlwordrmtctrlinit(KX_CTRLWORD_STRAT,KX_CTRLWORD_END,KX_YAOXIN_CTRLWD_START,KX_CTRLSWORD_SOE_START);
switchctrl_oper_param_init(QFDelayTime,QSDelayTime);
//以下仅用于自投
// QF自投
RemoteObject.Object[KX_QF_ZT].Type = BREAKER_TYPE; //锟斤拷锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_QF_ZT].Name = KX_DLQNo; //锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_QF_ZT].Out_On_No = KX_HCJQ_KC; //锟斤拷锟斤拷峡锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_QF_ZT].Out_Off_No = KX_BCJQ_KC; //锟斤拷锟斤拷挚锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_QF_ZT].YaoXinNo = KX_YAOXIN_QF; //锟斤拷应锟斤拷遥锟脚憋拷锟?
RemoteObject.Object[KX_QF_ZT].SoeCodeStart = KX_YK_QF_HZ_SUCCESS; //遥锟斤拷锟铰硷拷锟斤拷始锟斤拷锟斤拷
// 1QS自投
RemoteObject.Object[KX_1QS_ZT].Type = ISOLATOR_TYPE; //锟斤拷锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_1QS_ZT].Name = 0; //锟斤拷锟斤拷锟斤拷
RemoteObject.Object[KX_1QS_ZT].Out_On_No = KX_1QS_ZT_HZ_KC; //锟斤拷锟斤拷峡锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_1QS_ZT].Out_Off_No = KX_1QS_ZT_FZ_KC; //锟斤拷锟斤拷挚锟斤拷锟酵<E9949F>拷锟斤拷锟?
RemoteObject.Object[KX_1QS_ZT].YaoXinNo = KX_YAOXIN_1QS; //锟斤拷应锟斤拷遥锟脚憋拷锟?
RemoteObject.Object[KX_1QS_ZT].SoeCodeStart = KX_YK_1QS_HZ_SUCCESS; //遥锟斤拷锟铰硷拷锟斤拷始锟斤拷锟斤拷
}
void yaoXinSetInitial(void)
{
// QF
YaoXinSet[0].IP = DOUBLE_POINT;
YaoXinSet[0].HWKaiRuChannelNo = KX_QF_HW_KR;
YaoXinSet[0].FWKaiRuChannelNo = KX_QF_FW_KR;
YaoXinSet[0].HWKcChannelNo = KX_QF_HWD_KC;
YaoXinSet[0].FWKcChannelNo = KX_QF_FWD_KC;
YaoXinSet[0].pDelayTime = &KX_OperationTime;
YaoXinSet[0].Timer = 0;
YaoXinSet[0].rmtsignalno = KX_YAOXIN_QF;
// 1QS
YaoXinSet[1].IP = DOUBLE_POINT;
YaoXinSet[1].HWKaiRuChannelNo = KX_1QS_HW_KR;
YaoXinSet[1].FWKaiRuChannelNo = KX_1QS_FW_KR;
YaoXinSet[1].HWKcChannelNo = KX_1QS_HWD_KC;
YaoXinSet[1].FWKcChannelNo = KX_1QS_FWD_KC;
YaoXinSet[1].pDelayTime = &KX_QSOperationTime;
YaoXinSet[1].Timer = 0;
YaoXinSet[1].rmtsignalno = KX_YAOXIN_1QS;
// 2QS
YaoXinSet[2].IP = DOUBLE_POINT;
YaoXinSet[2].HWKaiRuChannelNo = KX_2QS_HW_KR;
YaoXinSet[2].FWKaiRuChannelNo = KX_2QS_FW_KR;
YaoXinSet[2].HWKcChannelNo = KX_2QS_HWD_KC;
YaoXinSet[2].FWKcChannelNo = KX_2QS_FWD_KC;
YaoXinSet[2].pDelayTime = &KX_QSOperationTime;
YaoXinSet[2].Timer = 0;
YaoXinSet[2].rmtsignalno = KX_YAOXIN_2QS;
// 3QS
YaoXinSet[3].IP = DOUBLE_POINT;
YaoXinSet[3].HWKaiRuChannelNo = KX_3QS_HW_KR;
YaoXinSet[3].FWKaiRuChannelNo = KX_3QS_FW_KR;
YaoXinSet[3].HWKcChannelNo = KX_3QS_HWD_KC;
YaoXinSet[3].FWKcChannelNo = KX_3QS_FWD_KC;
YaoXinSet[3].pDelayTime = &KX_QSOperationTime;
YaoXinSet[3].Timer = 0;
YaoXinSet[3].rmtsignalno = KX_YAOXIN_3QS;
// 4QS
YaoXinSet[4].IP = DOUBLE_POINT;
YaoXinSet[4].HWKaiRuChannelNo = KX_4QS_HW_KR;
YaoXinSet[4].FWKaiRuChannelNo = KX_4QS_FW_KR;
YaoXinSet[4].HWKcChannelNo = KX_4QS_HWD_KC;
YaoXinSet[4].FWKcChannelNo = KX_4QS_FWD_KC;
YaoXinSet[4].pDelayTime = &KX_QSOperationTime;
YaoXinSet[4].Timer = 0;
YaoXinSet[4].rmtsignalno = KX_YAOXIN_4QS;
#ifdef DEVICE_TYPE_DIGITAL
// 5QS
YaoXinSet[5].IP = DOUBLE_POINT;
YaoXinSet[5].HWKaiRuChannelNo = KX_5QS_HW_KR;
YaoXinSet[5].FWKaiRuChannelNo = KX_5QS_FW_KR;
YaoXinSet[5].HWKcChannelNo = KX_5QS_HWD_KC;
YaoXinSet[5].FWKcChannelNo = KX_5QS_FWD_KC;
YaoXinSet[5].pDelayTime = &KX_QSOperationTime;
YaoXinSet[5].Timer = 0;
YaoXinSet[5].rmtsignalno = KX_YAOXIN_5QS;
// 6QS
YaoXinSet[6].IP = DOUBLE_POINT;
YaoXinSet[6].HWKaiRuChannelNo = KX_6QS_HW_KR;
YaoXinSet[6].FWKaiRuChannelNo = KX_6QS_FW_KR;
YaoXinSet[6].HWKcChannelNo = KX_6QS_HWD_KC;
YaoXinSet[6].FWKcChannelNo = KX_6QS_FWD_KC;
YaoXinSet[6].pDelayTime = &KX_QSOperationTime;
YaoXinSet[6].Timer = 0;
YaoXinSet[6].rmtsignalno = KX_YAOXIN_6QS;
// 7QS
YaoXinSet[7].IP = DOUBLE_POINT;
YaoXinSet[7].HWKaiRuChannelNo = KX_7QS_HW_KR;
YaoXinSet[7].FWKaiRuChannelNo = KX_7QS_FW_KR;
YaoXinSet[7].HWKcChannelNo = KX_7QS_HWD_KC;
YaoXinSet[7].FWKcChannelNo = KX_7QS_FWD_KC;
YaoXinSet[7].pDelayTime = &KX_QSOperationTime;
YaoXinSet[7].Timer = 0;
YaoXinSet[7].rmtsignalno = KX_YAOXIN_7QS;
// 8QS
YaoXinSet[8].IP = DOUBLE_POINT;
YaoXinSet[8].HWKaiRuChannelNo = KX_8QS_HW_KR;
YaoXinSet[8].FWKaiRuChannelNo = KX_8QS_FW_KR;
YaoXinSet[8].HWKcChannelNo = KX_8QS_HWD_KC;
YaoXinSet[8].FWKcChannelNo = KX_8QS_FWD_KC;
YaoXinSet[8].pDelayTime = &KX_QSOperationTime;
YaoXinSet[8].Timer = 0;
YaoXinSet[8].rmtsignalno = KX_YAOXIN_8QS;
#endif
}
/*******************************************************
* unsigned int usrSetValueCheckSum(void)
********************************************************/
unsigned int usrSetValueCheckSum(void)
{
// 用户定值校验和计算
unsigned int sum;
sum = 0;
sum += varCheckSum((unsigned char *)(&KX_Z1Set), 16);
sum += varCheckSum((unsigned char *)(&KX_Z2Set), 16);
sum += varCheckSum((unsigned char *)(&KX_Z3Set), 16);
sum += varCheckSum((unsigned char *)(&KX_SDISet), 12);
sum += varCheckSum((unsigned char *)(&KX_ISet), 12);
sum += varCheckSum((unsigned char *)(&KX_DLTISet), 8);
sum += varCheckSum((unsigned char *)(&KX_SYSet), 8);
sum += varCheckSum((unsigned char *)(&KX_JYYSet), 8);
sum += varCheckSum((unsigned char *)(&KX_CHZ_ChongDianTime), 4);
sum += varCheckSum((unsigned char *)(&KX_CHZ_Time), 4);
sum += varCheckSum((unsigned char *)(&KX_CHZ_ISet), 4);
sum += varCheckSum((unsigned char *)(&KX_XieBo_2), 4);
sum += varCheckSum((unsigned char *)(&KX_XieBo_S), 4);
sum += varCheckSum((unsigned char *)(&KX_DYUSet), 4);
sum += varCheckSum((unsigned char *)(&KX_PTDX_USet), 4);
sum += varCheckSum((unsigned char *)(&KX_PTDX_ISet), 4);
sum += varCheckSum((unsigned char *)(&KX_PTDX_ILowSet), 4);
sum += varCheckSum((unsigned char *)(&KX_PTDX_TimeSet), 4);
sum += varCheckSum((unsigned char *)(&KX_AccTimeSet), 4);
sum += varCheckSum((unsigned char *)(&KX_ZKTX_QL), 4);
sum += varCheckSum((unsigned char *)(&KX_ZKTX_Q1), 4);
sum += varCheckSum((unsigned char *)(&KX_ZKTX_X), 4);
sum += varCheckSum((unsigned char *)(&KX_XZKSet), 4);
// 一次、二次额定值
sum += varCheckSum((unsigned char *)(&KX_CTRated1), 4);
sum += varCheckSum((unsigned char *)(&KX_CTRated2), 4);
sum += varCheckSum((unsigned char *)(&KX_PowerMode), 4);
sum += varCheckSum((unsigned char *)(&KX_FUJR), 4);
sum += varCheckSum((unsigned char *)(&KX_PositionSet), 4);
sum += varCheckSum((unsigned char *)(&KX_GKMode), 4);
sum += varCheckSum((unsigned char *)(&KX_JXPTPosition), 4);
sum += varCheckSum((unsigned char *)(&KX_JXRunMode), 4);
//sum += varCheckSum((unsigned char *)(&KX_LS), 4);
sum += varCheckSum((unsigned char *)(&KX_XLSet), sizeof(KX_XLSet));
sum += varCheckSum((unsigned char *)(&KX_BTMode), 4);
// 保护压板
sum += varCheckSum((unsigned char *)(&KX_Z1TouRu), 4);
sum += varCheckSum((unsigned char *)(&KX_Z2TouRu), 4);
sum += varCheckSum((unsigned char *)(&KX_Z3TouRu), 4);
sum += varCheckSum((unsigned char *)(&KX_SDITouRu), 4);
sum += varCheckSum((unsigned char *)(&KX_ITouRu), 4);
sum += varCheckSum((unsigned char *)(&KX_DLTITouRu), 4);
sum += varCheckSum((unsigned char *)(&KX_LUTouRu), 4);
sum += varCheckSum((unsigned char *)(&KX_JXSYTouRu), 4);
sum += varCheckSum((unsigned char *)(&KX_JYYTouRu), 4);
sum += varCheckSum((unsigned char *)(&KX_DDLBSTouRu), 4);
sum += varCheckSum((unsigned char *)(&KX_PTDXTouRu), 4);
sum += varCheckSum((unsigned char *)(&KX_JYDYTouRu), 4);
//printf("crc = %X,x = %f, r = %f, t = %d\n",sum,KX_Z1Set.XValue,KX_Z1Set.RValue,KX_Z1Set.Time);
return sum;
}
/*******************************************
* unsigned int sysSetValueCheckSum(void)
* 锟斤拷锟斤拷:系统锟斤拷值锟皆硷拷
* 锟斤拷史:锟斤拷锟斤拷锟斤拷锟节诧拷锟斤拷
*
********************************************/
unsigned int sysSetValueCheckSum(void)
{
// 系统定值校验和计算
unsigned int sum;
sum = 0;
sum += varCheckSum((unsigned char *)(&KX_VKSet), 4);
sum += varCheckSum((unsigned char *)(&KX_VK2Set), 4);
sum += varCheckSum((unsigned char *)(&KX_VFKSet), 4);
sum += varCheckSum((unsigned char *)(&KX_VFK2Set), 4);
sum += varCheckSum((unsigned char *)(&KX_BaoHuIKSet), 4);
sum += varCheckSum((unsigned char *)(&KX_CeLiangIKSet), 4);
sum += varCheckSum((unsigned char *)(&KX_BaoHuFIKSet), 4);
sum += varCheckSum((unsigned char *)(&KX_CeLiangFIKSet), 4);
//sum += varCheckSum((unsigned char *)(&KX_CeLiangI1KSet), 4);
//sum += varCheckSum((unsigned char *)(&KX_CeLiangI2KSet), 4);
sum += varCheckSum((unsigned char *)(&KX_ZKSet), 4);
sum += varCheckSum((unsigned char *)(&KX_QSet), 4);
sum += varCheckSum((unsigned char *)(&KX_QFSet), 4);
sum += varCheckSum((unsigned char *)(&QFDelayTime), 4);
sum += varCheckSum((unsigned char *)(&QSDelayTime), 4);
sum += varCheckSum((unsigned char *)(&KX_OperationTime), 4);
sum += varCheckSum((unsigned char *)(&KX_QSOperationTime), 4);
return sum;
}
/***************************************************
* void kx_itemClsDwnManageInit()
* 锟斤拷锟斤拷: 锟斤拷锟竭憋拷锟斤拷元锟斤拷锟斤拷锟斤拷锟斤拷锟结构锟斤拷锟斤拷锟斤拷始锟斤拷锟斤拷锟斤拷统装锟斤拷
* 锟斤拷锟酵ｏ拷锟斤拷AD锟斤拷锟斤拷
* 锟斤拷史:
****************************************************/
void kx_itemClsDwnManageInit()
{
int i;
ItemClsDwnManageType *pItemClsDwn;
// 一、初始化AD芯片对应通道的对应关系
ADChipContainAnaChn[0].num = 3;
ADChipContainAnaChn[0].AnaChnNo[0] = CH_KX_BH_IF; // F线保护电流
ADChipContainAnaChn[1].num = 3; //
ADChipContainAnaChn[1].AnaChnNo[0] = CH_KX_BH_I; // 保护电流
ADChipContainAnaChn[1].AnaChnNo[1] = CH_KX_UT2; // 进行电压
ADChipContainAnaChn[1].AnaChnNo[2] = CH_KX_UF2; // UF2
ADChipContainAnaChn[2].num = 2; //
ADChipContainAnaChn[2].AnaChnNo[0] = CH_KX_U; // 母线电压
ADChipContainAnaChn[2].AnaChnNo[1] = CH_KX_UF; // F线电压
// 二、初始化保护通道与元件的对应关系
for(i = 0; i < ANALOG_CHANNEL_NUMBER_MAX; i++)
{
AnaChnCorrCLDManageChn[i] = 0xff;
}
AnaChnCorrCLDManageChn[CH_KX_BH_I] = CLSDWN_CH_KX_BH_I; // 保护电流
AnaChnCorrCLDManageChn[CH_KX_U] = CLSDWN_CH_KX_U; // 母线电压
if(AT_MODE == KX_PowerMode)
{
AnaChnCorrCLDManageChn[CH_KX_BH_IF] = CLSDWN_CH_KX_BH_IF; // F线保护电流
if(BH_RUN == KX_FUJR)
{
AnaChnCorrCLDManageChn[CH_KX_UF] = CLSDWN_CH_KX_UF; // F线保护电压
}
}
//
if(SS == KX_PositionSet && BH_RUN == KX_U_AutoExchange)
{
AnaChnCorrCLDManageChn[CH_KX_UT2] = CLSDWN_CH_KX_UT2; // 对侧母线电压
if(AT_MODE == KX_PowerMode && BH_RUN == KX_FUJR)
{
AnaChnCorrCLDManageChn[CH_KX_UF2] = CLSDWN_CH_KX_UF2;
}
}
// 三、初始化闭锁管理结构数组元素与保护元件的对应关系
ItemClsDwnObjNum = BH_ANACHN_NUM;
// 1、保护电流
pItemClsDwn = &ItemClsDwnManage[CLSDWN_CH_KX_BH_I];
pItemClsDwn->ClsDwnBit = Bit0;
pItemClsDwn->counter1 = 0;
pItemClsDwn->counter2 = 0;
pItemClsDwn->ERRBIT = SYS_ERR_BLOCK_PRTC_BIT;
// 独立支持的元件
pItemClsDwn->selfItemNum = 10;
pItemClsDwn->selfItem[0] = (unsigned int *)(&KX_SDIYJ.ClsDwnIP); //电流速断
pItemClsDwn->selfItem[1] = (unsigned int *)(&KX_IYJ.ClsDwnIP); //过电流
pItemClsDwn->selfItem[2] = (unsigned int *)(&KX_DLTIYJ.ClsDwnIP); //电流增量
pItemClsDwn->selfItem[3] = (unsigned int *)(&KX_XieBo2YJ.ClsDwnIP); //二次谐波闭锁
pItemClsDwn->selfItem[4] = (unsigned int *)(&KX_XieBoSumYJ.ClsDwnIP);//综合谐波闭锁
pItemClsDwn->selfItem[5] = (unsigned int *)(&KX_Z1YJ.ClsDwnIP); //阻抗1段
pItemClsDwn->selfItem[6] = (unsigned int *)(&KX_Z2YJ.ClsDwnIP); //阻抗2段
pItemClsDwn->selfItem[7] = (unsigned int *)(&KX_Z3YJ.ClsDwnIP); //阻抗3段
pItemClsDwn->selfItem[8] = (unsigned int *)(&KX_PTDXYJ.ClsDwnIP); //PT断线
pItemClsDwn->selfItem[9] = (unsigned int *)(&CHZValue.ClsDwnIP); //重合闸
#ifdef PWPRTC_ENABLE
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_PWRSECPOSYJ.ClsDwnIP); // 供电臂正向阻抗元件
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_PWRSECNAGYJ.ClsDwnIP); // 供电臂反向阻抗元件
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_BusPrtcYJ.ClsDwnIP); //母线保护
#endif
// 联合支持的元件
pItemClsDwn->comItemNum = 0;
// 2、F线电流
pItemClsDwn = &ItemClsDwnManage[CLSDWN_CH_KX_BH_IF];
pItemClsDwn->ClsDwnBit = Bit1;
pItemClsDwn->counter1 = 0;
pItemClsDwn->counter2 = 0;
pItemClsDwn->ERRBIT = SYS_ERR_BLOCK_PRTC_BIT;
// 独立支持的元件
pItemClsDwn->selfItemNum = 10;
pItemClsDwn->selfItem[0] = (unsigned int *)(&KX_SDIYJ.ClsDwnIP); //电流速断
pItemClsDwn->selfItem[1] = (unsigned int *)(&KX_IYJ.ClsDwnIP); //过电流
pItemClsDwn->selfItem[2] = (unsigned int *)(&KX_DLTIYJ.ClsDwnIP); //电流增量
pItemClsDwn->selfItem[3] = (unsigned int *)(&KX_XieBo2YJ.ClsDwnIP); //二次谐波闭锁
pItemClsDwn->selfItem[4] = (unsigned int *)(&KX_XieBoSumYJ.ClsDwnIP);//综合谐波闭锁
pItemClsDwn->selfItem[5] = (unsigned int *)(&KX_Z1YJ.ClsDwnIP); //阻抗1段
pItemClsDwn->selfItem[6] = (unsigned int *)(&KX_Z2YJ.ClsDwnIP); //阻抗2段
pItemClsDwn->selfItem[7] = (unsigned int *)(&KX_Z3YJ.ClsDwnIP); //阻抗3段
pItemClsDwn->selfItem[8] = (unsigned int *)(&KX_PTDXYJ.ClsDwnIP); //PT断线
pItemClsDwn->selfItem[9] = (unsigned int *)(&CHZValue.ClsDwnIP); //重合闸
#ifdef PWPRTC_ENABLE
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_PWRSECPOSYJ.ClsDwnIP); // 供电臂正向阻抗元件
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_PWRSECNAGYJ.ClsDwnIP); // 供电臂反向阻抗元件
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_BusPrtcYJ.ClsDwnIP); //母线保护
#endif
// 联合支持的元件
pItemClsDwn->comItemNum = 0;
// 3、母线电压 UT1
pItemClsDwn = &ItemClsDwnManage[CLSDWN_CH_KX_U];
pItemClsDwn->ClsDwnBit = Bit2;
pItemClsDwn->counter1 = 0;
pItemClsDwn->counter2 = 0;
pItemClsDwn->unenable = 0; //特别注意!!!!!!
pItemClsDwn->ERRBIT = SYS_ERR_BLOCK_PRTC_BIT;
pItemClsDwn->pselItem_unexit = (unsigned int *)(&KX_PTDXYJ.ClsDwnIP);
// 独立支持的元件
pItemClsDwn->selfItemNum = 8;//
pItemClsDwn->selfItem[0] = (unsigned int *)(&KX_LUYJ.ClsDwnIP); // 低压启动元件
pItemClsDwn->selfItem[1] = (unsigned int *)(&KX_Z1YJ.ClsDwnIP); // 阻抗 1 段
pItemClsDwn->selfItem[2] = (unsigned int *)(&KX_Z2YJ.ClsDwnIP); // 阻抗 2 段
pItemClsDwn->selfItem[3] = (unsigned int *)(&KX_Z3YJ.ClsDwnIP); // 阻抗 3 段
pItemClsDwn->selfItem[4] = (unsigned int *)(&KX_PTDXYJ.ClsDwnIP); // PT断线
pItemClsDwn->selfItem[5] = (unsigned int *)(&CHZValue.ClsDwnIP); // 重合闸
pItemClsDwn->selfItem[6] = (unsigned int *)(&KX_JXSYYJ.ClsDwnIP); // 进线失压
pItemClsDwn->selfItem[7] = (unsigned int *)(&KX_JYYYJ.ClsDwnIP); // 检有压元件
#ifdef PWPRTC_ENABLE
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_PWRSECPOSYJ.ClsDwnIP); // 供电臂正向阻抗元件
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_PWRSECNAGYJ.ClsDwnIP); // 供电臂反向阻抗元件
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_BusPrtcYJ.ClsDwnIP); //母线保护
#endif
// 联合支持的元件
pItemClsDwn->comItemNum = 0;
// 4、F线电压1
pItemClsDwn = &ItemClsDwnManage[CLSDWN_CH_KX_UF];
pItemClsDwn->ClsDwnBit = Bit3;
pItemClsDwn->counter1 = 0;
pItemClsDwn->counter2 = 0;
pItemClsDwn->unenable = 0; //特别注意!!!!!!
pItemClsDwn->ERRBIT = SYS_ERR_BLOCK_PRTC_BIT;
pItemClsDwn->pselItem_unexit = (unsigned int *)(&KX_FPTDXYJ.ClsDwnIP);
// 独立支持的元件
pItemClsDwn->selfItemNum = 8;//
pItemClsDwn->selfItem[0] = (unsigned int *)(&KX_LUYJ.ClsDwnIP); // 低压启动元件
pItemClsDwn->selfItem[1] = (unsigned int *)(&KX_Z1YJ.ClsDwnIP); // 阻抗 1 段
pItemClsDwn->selfItem[2] = (unsigned int *)(&KX_Z2YJ.ClsDwnIP); // 阻抗 2 段
pItemClsDwn->selfItem[3] = (unsigned int *)(&KX_Z3YJ.ClsDwnIP); // 阻抗 3 段
pItemClsDwn->selfItem[4] = (unsigned int *)(&KX_FPTDXYJ.ClsDwnIP); // PT断线
pItemClsDwn->selfItem[5] = (unsigned int *)(&CHZValue.ClsDwnIP); // 重合闸
pItemClsDwn->selfItem[6] = (unsigned int *)(&KX_JXSYYJ.ClsDwnIP); // 进线失压
pItemClsDwn->selfItem[7] = (unsigned int *)(&KX_JYYYJ.ClsDwnIP); // 检有压元件
#ifdef PWPRTC_ENABLE
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_PWRSECPOSYJ.ClsDwnIP); // 供电臂正向阻抗元件
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_PWRSECNAGYJ.ClsDwnIP); // 供电臂反向阻抗元件
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_BusPrtcYJ.ClsDwnIP); //母线保护
#endif
// 联合支持的元件
pItemClsDwn->comItemNum = 0;
// 5、电压 UT2
pItemClsDwn = &ItemClsDwnManage[CLSDWN_CH_KX_UT2];
pItemClsDwn->ClsDwnBit = Bit4;
pItemClsDwn->counter1 = 0;
pItemClsDwn->counter2 = 0;
pItemClsDwn->unenable = 0; //特别注意!!!!!!
pItemClsDwn->ERRBIT = SYS_ERR_BLOCK_PRTC_BIT;
pItemClsDwn->pselItem_unexit = (unsigned int *)(&KX_T2PTDXYJ.ClsDwnIP);
// 独立支持的元件
pItemClsDwn->selfItemNum = 1;
pItemClsDwn->selfItem[0] = (unsigned int *)(&KX_T2PTDXYJ.ClsDwnIP); //UT2 PT断线
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_LUYJ.ClsDwnIP); // 低压启动元件
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_Z1YJ.ClsDwnIP); //阻抗1段
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_Z2YJ.ClsDwnIP); //阻抗2段
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_Z3YJ.ClsDwnIP); //阻抗3段
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_JXSYYJ.ClsDwnIP); //失压
// 联合支持的元件
pItemClsDwn->comItemNum = 0;
// 6、UF2
pItemClsDwn = &ItemClsDwnManage[CLSDWN_CH_KX_UF2];
pItemClsDwn->ClsDwnBit = Bit5;
pItemClsDwn->counter1 = 0;
pItemClsDwn->counter2 = 0;
pItemClsDwn->unenable = 0; //特别注意!!!!!!
pItemClsDwn->ERRBIT = SYS_ERR_BLOCK_PRTC_BIT;
pItemClsDwn->pselItem_unexit = (unsigned int *)(&KX_F2PTDXYJ.ClsDwnIP);
// 独立支持的元件
pItemClsDwn->selfItemNum = 1;
pItemClsDwn->selfItem[0] = (unsigned int *)(&KX_F2PTDXYJ.ClsDwnIP);//UT2 PT断线
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_LUYJ.ClsDwnIP); // 低压启动元件
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_Z1YJ.ClsDwnIP); //阻抗1段
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_Z2YJ.ClsDwnIP); //阻抗2段
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_Z3YJ.ClsDwnIP); //阻抗3段
pItemClsDwn->selfItem[pItemClsDwn->selfItemNum++] = (unsigned int *)(&KX_JXSYYJ.ClsDwnIP); //失压
// 联合支持的元件
pItemClsDwn->comItemNum = 0;
}
void KX_ContactSignalInit()
{
unsigned int Mask,temp,pos = PWRSEC_POSITION_UNKNOWN;
int i,nodeNum;
kcDelayTimer_11 = 1;
PwrPrtcBlockIP = TEST_START;
//备用参数
KX_BackupParam.isBackup = TEST_CLOSE;
KX_BackupParam.backupDir = BACKUP_UNENABLE;
KX_BackupParam.checkDir = CHECK_UNKNOWN;
KX_BackupParam.enable = TEST_START;
if(SS != KX_PositionSet)
{
D_OUT(KX_BACKUP_DOWN_KC,OFF);
D_OUT(KX_BACKUP_UP_KC,OFF);
}
KX_ContactSignal.SignalSend.doNo = KX_CONTACT_KC;
temp = KX_ContactSignal.SignalSend.value_new;
Mask = PWRSEC_S_SWITCH_BIT | PWRSEC_POSITIONT_BIT | PWESEC_BACKUP_BIT | PWESEC_SWITCH_UP_BIT | PWESEC_SWITCH_DOWN_BIT;
//相应位清零，备用位也清掉
temp &= ~Mask;
switch(KX_PositionSet)
{
case SS: //变电所
//case SS_DOWM: //变电所下行
//case SS_UP: //变电所上行
pos = PWRSEC_POSITION_SS;
break;
case SP: //分区所
pos = PWRSEC_POSITION_SP;
break;
case ATP: //AT所
pos = PWRSEC_POSITION_AT;
break;
case SSP: //开闭所
case SSP_JX: //开闭所进线
pos = PWRSEC_POSITION_OTHER;
break;
default: //未知
pos = PWRSEC_POSITION_UNKNOWN;
break;
}
//赋值安装位置
temp |= (pos & PWRSEC_POSITIONT_BIT);
//并联方式
if(S_SWITCH_CONNECT == KX_ParallelMode)
{
temp |= PWRSEC_S_SWITCH_BIT;
}
KX_ContactSignal.SignalSend.value_new = temp;
//初始化发送联络信号
nodeNum = PWRSECPRTC_NODE_NUM;
if(nodeNum > CONTACT_SIGNAL_DI_NUM)
{
nodeNum = CONTACT_SIGNAL_DI_NUM;
}
for(i = 0; i < nodeNum; i++)
{
KX_ContactSignal.SignalRecv[i].diNo = KX_SEC1_LL1_KR + i;
KX_ContactSignal.SignalRecv[i].status = CONTACT_SIGNAL_UNKNOWN;
}
//对侧联络信号
KX_ContactSignal.SignalRecv[PWRSECPRTC_CONTACT_OTHSIDE_INDEX].diNo = KX_LLXH_DC_KR;
//备用馈线联络信号
KX_ContactSignal.SignalRecv[PWRSECPRTC_CONTACT_BACKUP_INDEX].diNo = KX_SEC_BY_LL_KR;
}
#endif
Reference in New Issue View Git Blame Copy Permalink