/******************************************************************************* 版权所有： 版本号： 1.00 文件名： set.c 生成日期： 2008.8.16 作者： 功能说明：定值结构和定值修改 修改日志： 日志1： 修改者： 修改日期： 修改内容： 修改原因： ****************************************************************************/ #include "head.h" #ifdef CPU_FUXI #include #include #include // #include "shm_comm_packet.h" #include "shmem.h" #else #include "uart_user.h" #include #endif #include "m.h" #include "m_set.h" #define MAX_3(x, y, z) (x > y ? (x > z ? x : z) : (y > z ? y : z)) #define MIN_3(x, y, z) (((x > y ? y : x) > z) ? z : (x > y ? y : x)) #define MIN_2(x, y) (x > y ? y : x) #define FIXED_ARGS_NUM 7 #define SET_FILE_VERSION 0X01010102 // 定值文件版本 #define SW_AC_SET_NUM (SW_AC_IN_SET_END - SW_AC_IN_SET_BEGIN + 1) const short sw_ac_set_index[SW_AC_SET_NUM] = { SET_GL1_I, SET_GL1_T, SET_GL2_I, SET_GL2_T, SET_LX1_I, SET_LX1_T, SET_LX1_TT, SET_CH_T1, SET_CH_T2, SET_FA_X_T, SET_FA_Y_T, SET_SL_TT, }; enum { RMT_DEAD_I = 0, RMT_DEAD_U, RMT_DEAD_ZL, RMT_DEAD_PQ, RMT_DEAD_F, RMT_DEAD_COS, RMT_DEAD_NUM }; struct U_QUA { u32 run_time[2]; u32 ok_time[2]; u16 crc; }; u8 g_creat_set_file = 0; u16 g_crc_set_desc; u16 g_crc_set_data; bool gb_yx_ac = false; bool bRunSetModify; WORD m_runsection = 0; int ParaIDNum; uint32_t g_debugnet_ip, g_debugnet_mask, g_debugnet_gate; // 调试网口IP,MASK,GATE等网络参数 TSECTIONINFO tSecInfo; // 定值信息(包括定值区号及有效定值区) RUN_PARA tRunPara; TSET tRunSet[2]; // 运行定值缓冲区 TSET tBakSet; TSET *pRunSet = &tRunSet[0]; SET_PARAID tParaID[MAX_SET_NUMBER]; #ifdef YPARA_LINK SET_PARA_VAL tPara_val[MAX_SET_NUMBER]; #endif struct set_file_head_data g_fh_data; struct file_contrast setdesc_contrast; struct set_disp_index g_set_disp; // 挑选后的保护定值 const char *SetUints[]= //单位符号定义，对应定值 { "", //0 无单位 "V", "A", // "s", //4 "天", //4 "％", "°", "W", "Var", //4 "H", "时", "kV", "ms", "分", "Hz", "％Un", "Hz/s", "V/s", }; BH_SET_GROUP SetGroups[]= //单位符号定义，对应定值 { {SETGROUP_TYPE_BY, 0, 0, GROUP_SET_BY, "备用定值", "备用",}, {SETGROUP_TYPE_BH, 1, SET_HYB_BH, GROUP_SET_YB_GN, "保护定值", "功能软压板", }, {SETGROUP_TYPE_BH, 1, SET_HYB_BH, GROUP_SET_YB_YX, "保护定值", "运行软压板", }, {SETGROUP_TYPE_BH, 1, SET_HYB_BH, GROUP_SET_BHTT, "保护定值", "常规保护控制字", }, {SETGROUP_TYPE_BH, 1, SET_HYB_BH, GROUP_SET_BHDZ, "保护定值", "常规保护定值", }, {SETGROUP_TYPE_BH, 1, SET_HYB_BH, GROUP_SET_CHZKZ, "保护定值", "自动重合闸控制字", }, {SETGROUP_TYPE_BH, 1, SET_HYB_BH, GROUP_SET_CHZDZ, "保护定值", "自动重合闸定值", }, {SETGROUP_TYPE_BH, 1, SET_HYB_BH, GROUP_SET_FAYB, "保护定值", "就地馈线自动化软压板", }, {SETGROUP_TYPE_BH, 1, SET_HYB_BH, GROUP_SET_FATT, "保护定值", "就地馈线自动化控制字", }, {SETGROUP_TYPE_BH, 1, SET_HYB_BH, GROUP_SET_FADZ, "保护定值", "就地馈线自动化定值", }, {SETGROUP_TYPE_BH, 1, SET_HYB_BH, GROUP_SET_GOOSETT, "保护定值", "智能分布式控制字", }, {SETGROUP_TYPE_BH, 1, SET_HYB_BH, GROUP_SET_GOOSEDZ, "保护定值", "智能分布式定值", }, {SETGROUP_TYPE_TQ, 1, SET_HYB_TQ, GROUP_SET_TQHZ, "保护定值", "同期合闸定值", }, {SETGROUP_TYPE_JL, 1, SET_HYB_JL, GROUP_SET_JLTT, "保护定值", "自动解列控制字", }, {SETGROUP_TYPE_JL, 1, SET_HYB_JL, GROUP_SET_JLDZ, "保护定值", "自动解列定值", }, #ifdef XDL_ZT {SETGROUP_TYPE_BH, 1, 0, GROUP_SET_XDLJDTT, "保护定值", "小电流接地控制字", }, {SETGROUP_TYPE_BH, 1, 0, GROUP_SET_XDLJDDZ, "保护定值", "小电流接地定值", }, #elif defined FUN_JDXX {SETGROUP_TYPE_BH, 1, 0, GROUP_SET_XDLJD, "保护定值", "小电流接地", }, #endif {SETGROUP_TYPE_JL, 1, 0, GROUP_SET_LA, "保护定值", "线路断线告警", }, #ifdef FUNC_DRIVE {SETGROUP_TYPE_BH, 1, 0, GROUP_SET_BTDCD, "保护定值", "传动开关定值", }, #endif #ifdef FUNC_DRIVE_JY {SETGROUP_TYPE_BH, 1, 0, GROUP_SET_DRIVE, "保护定值", "传动功能", }, #endif {SETGROUP_TYPE_BH, 1, 0, GROUP_SET_FSX, "保护定值", "反时限保护", }, {SETGROUP_TYPE_BH, 1, 0, GROUP_SET_DLYX, "保护定值", "电流越限", }, {SETGROUP_TYPE_BH, 1, 0, GROUP_SET_RECORD, "保护定值", "录波", }, {SETGROUP_TYPE_BH, 1, 0, GROUP_SET_SWSET, "保护定值", "辅助定值", }, #ifdef CUSTOMIZE_BZT //备自投 {SETGROUP_TYPE_BH, 1, 0, GROUP_SET_BZT, "保护定值", "备自投", }, #endif {SETGROUP_TYPE_PUB, 1, 0, GROUP_SET_EQPPARA, "公共定值", "设备参数", }, {SETGROUP_TYPE_PUB, 1, 0, GROUP_SET_SCT, "公共定值", "定值区", }, {SETGROUP_TYPE_PUB, 1, 0, GROUP_SET_PUBYB, "公共定值", "运行软压板", }, {SETGROUP_TYPE_PUB, 1, 0, GROUP_SET_PUBSET, "公共定值", "电压参数", }, {SETGROUP_TYPE_PUB, 1, 0, GROUP_SET_FDL, "公共定值", "非电量保护", }, {SETGROUP_TYPE_PUB, 1, 0, GROUP_SET_OTHERS_PUB, "公共定值", "其它", }, {SETGROUP_TYPE_PARA, 1, 0, GROUP_PARA_PROTOCAL, "装置参数", "规约参数", }, {SETGROUP_TYPE_PARA, 1, 0, GROUP_PARA_LINK, "装置参数", "104子站通信", }, {SETGROUP_TYPE_PARA, 1, 0, GROUP_PARA_SERIAL, "装置参数", "串行口通信", }, {SETGROUP_TYPE_PARA, 1, 0, GROUP_PARA_ETHERNET, "装置参数", "以太网通道", }, {SETGROUP_TYPE_PARA, 1, 0, GROUP_PARA_TIME, "装置参数", "对时", }, {SETGROUP_TYPE_PARA, 1, 0, GROUP_PARA_BATTERY, "装置参数", "电池管理", }, {SETGROUP_TYPE_PARA, 1, 0, GROUP_PARA_RMT, "装置参数", "远动参数", }, {SETGROUP_TYPE_PARA, 1, 0, GROUP_PARA_OTHERS, "装置参数", "其它", }, #ifdef FUN_FUXI_ESAM {SETGROUP_TYPE_PARA, 1, 0, GROUP_PARA_S1, "装置参数", "南网加密配置", }, #endif #ifdef METERING_ENERGY {SETGROUP_TYPE_PARA, 1, 0, GROUP_PARA_HISFILE, "装置参数", "历史文件", }, #endif {SETGROUP_TYPE_CSTSET, 1, 0, GROUP_CSTSET_PROTECT, "内部定值", "保护功能", }, {SETGROUP_TYPE_CSTSET, 1, 0, GROUP_CSTSET_CALC, "内部定值", "计算功能", }, {SETGROUP_TYPE_CSTSET, 1, 0, GROUP_CSTSET_COMM, "内部定值", "通讯功能", }, {SETGROUP_TYPE_CSTSET, 1, 0, GROUP_CSTSET_FA, "内部定值", "馈线自动化", }, {SETGROUP_TYPE_CSTSET, 1, 0, GROUP_CSTSET_RECORD, "内部定值", "录波功能", }, {SETGROUP_TYPE_CSTSET, 1, 0, GROUP_CSTSET_OTHERS, "内部定值", "辅助定值", }, }; //保护投退列表 const SET_LIST TTList[]= { {"退 出", 0, }, {"投 入", 1, }, }; #define TTListNum sizeof(TTList)/sizeof(SET_LIST) const SET_LIST LinkList[]= { {"串口1", 0, }, {"串口2", 1, }, {"串口3", 2, }, {"串口4", 3, }, {"串口5", 4, }, {"串口6", 5, }, {"网口1", 6, }, {"网口2", 7, }, }; #define LinkListNum sizeof(LinkList)/sizeof(SET_LIST) //装置类型类表 const SET_LIST EQUList[]= { {"测控装置", 0, }, {"管理机装置", 1, }, }; #define EQUListNum sizeof(EQUList)/sizeof(SET_LIST) //电压输入方式 const SET_LIST VOLTYPEList[]= { {"电源电压 ", 0, }, {"测量电压 ", 1, }, {"测量+电源", 2, }, }; #define VOLTYPEListNum sizeof(VOLTYPEList)/sizeof(SET_LIST) const SET_LIST DISPMODEList[]= { {"二次值", 0,}, {"一次值", 1,}, }; #define DISPMODEListNum sizeof(DISPMODEList)/sizeof(SET_LIST) // 系统接地方式 const SET_LIST JDTYPE[]= { {"中性点不接地 ", 0, }, {"经消弧线圈接地", 1,}, {"经小电阻接地 ", 2,}, {"经高阻接地 ", 3,}, }; #define JDTYPENum sizeof(JDTYPE)/sizeof(SET_LIST) const SET_LIST XDLQDList[]= { {"零序电压", 0,}, {"零序电流", 1,}, }; #define XDLQDListNum sizeof(XDLQDList)/sizeof(SET_LIST) //告警合闸投退列表 const SET_LIST GJHZList[]= { {"退 出", 0,}, {"合 闸", 1,}, // {"告 警", 2,}, }; #define GJTZListNum sizeof(GJHZList)/sizeof(SET_LIST) //告警跳闸投退列表 const SET_LIST TZList[]= { {"告 警", 0,}, {"跳 闸", 1, }, }; #define TZListNum sizeof(TZList)/sizeof(SET_LIST) //告警跳闸投退列表 const SET_LIST HZList[]= { {"合 闸", 0, }, {"告 警", 1,}, }; #define HZListNum sizeof(HZList)/sizeof(SET_LIST) //跳闸检出投退列表 const SET_LIST TZCKList[]= { {"退 出", 0, }, {"告 警", 1,}, {"跳 闸", 2, }, }; #define TZCKListNum sizeof(TZCKList)/sizeof(SET_LIST) //告警跳闸投退列表 const SET_LIST TZGJList[]= { {"退 出 ", 0, }, {"跳 闸 ", 1, }, {"告 警 ", 2,}, {"告 警+跳闸", 3,}, }; #define TZGJListNum sizeof(TZGJList)/sizeof(SET_LIST) const SET_LIST FSXList[]= { {"一般反时限", RVS_STD, }, {"非常反时限", RVS_VERY, }, {"极端反时限", RVS_EXT, }, }; #define FSXListNum sizeof(FSXList)/sizeof(SET_LIST) const SET_LIST CHZList[]= { {"一次重合闸", 1, }, {"二次重合闸", 2, }, {"三次重合闸", 3, }, }; #define CHZListNum sizeof(CHZList)/sizeof(SET_LIST) const SET_LIST CHJSList[]= { {"后加速", 0, }, {"前加速", 1, }, }; #define CHJSListNum sizeof(CHJSList)/sizeof(SET_LIST) const SET_LIST KGFunList[]= { #if (defined GD_AREA_ECZD_2020) ||defined GD_AREA_HEYUAN_2021_2021 {"联 络", 0, }, {"分 段", 1,}, #else {"无 效", 0,}, {"分 段", LINE_TYPE_FD,}, {"联 络", LINE_TYPE_LL, }, // #endif }; #define KGFunListNum sizeof(KGFunList)/sizeof(SET_LIST) const SET_LIST KGFun1List[]= { {"分段联络", 0, }, {"分界 ", 1, }, }; #define KGFun1ListNum sizeof(KGFun1List)/sizeof(SET_LIST) #ifdef CUSTOMIZE_BZT //备自投 const SET_LIST BZTFSList[]= { {"分 段", 0, }, {"进 线", 1, }, {"互 投", 2, }, //{"单进线", 3, }, {"自 复", 3, }, }; #define BZTFSListNum sizeof(BZTFSList)/sizeof(SET_LIST) #endif const SET_LIST HHFunList[]= { {"退 出", 0, }, {"合环闭锁", 1, }, {"同期合闸", 2, }, }; #define HHFunListNum sizeof(HHFunList)/sizeof(SET_LIST) const SET_LIST BaudList[]= // 波特率列表 { {"600 ",600, }, {"1200 ",1200, }, {"2400 ",2400, }, {"4800 ",4800, }, {"9600 ",9600, }, {"19200",19200,}, {"38400",38400,}, {"57600",57600,}, {"115200",115200,}, }; #define BaudListNum sizeof(BaudList)/sizeof(SET_LIST) const SET_LIST ParityList[]= //校验位列表 { {"偶校验",PARITY_EVEN,}, {"奇校验",PARITY_ODD, }, {"无校验",PARITY_NONE_1,}, }; #define ParityListNum sizeof(ParityList)/sizeof(SET_LIST) const SET_LIST ProtocolList[]= // 规约类型列表 { {"子站非平衡101", PROTOCOL_101, }, {"子站平衡式101", PROTOCOL_101_PH,}, {"IEC104 ", PROTOCOL_104, }, {"主站非平衡101", PROTOCOL_101_M, }, {"主站平衡式101", PROTOCOL_101_PH_M,}, {"主站MODBUS ", PROTOCOL_MODBUS,}, #if !defined CPU_FUXI {"状态板 ", PROTOCOL_FAULT,}, {"面板 ", PROTOCOL_HMI,}, #endif {"维护规约 ", PROTOCOL_MAINTAIN,}, {"GPS模块 ", PROTOCOL_GPS,}, {"蓝牙加密模块 ", PROTOCOL_AUTHOR_BL,}, {"其它应用 ", PROTOCOL_IDLE,}, // 本应用程序完全不初始化、不使用。供其它程序(例如通讯子站，内部GPRS等)使用 #ifdef BATTERY_WITH_COMM #ifdef FUNC_SEL_BAT_MODULE {"兴通力规约 ", PROTOCOL_POWER_MOD,}, {"中电规约 ", PROTOCOL_PWRM,}, #else {"电源模块规约", PROTOCOL_POWER_MOD,}, #endif #endif {" 无 ", PROTOCOL_NULL,}, #ifdef FUNC_ENCRY_IN_ONE_SERIAL {"纬德多隧道 ", PROTOCOL_WED_ENC,}, #endif }; #define ProtocolListNum sizeof(ProtocolList)/sizeof(SET_LIST) const SET_LIST TimeList[]= //对时方式 { {"网络对时 ",0,}, {"B码对时 ",1, }, {"B码对时(带年)",2, }, {"秒脉冲对时 ",3, }, {"1588对时 ",4, }, }; #define TimeListNum sizeof(TimeList)/sizeof(SET_LIST) const SET_LIST TimeListSelect[]= //标准化对时方式选择 { {"全方式对时 ",0,}, {"仅卫星对时 ",1, }, {"仅主站对时 ",2, }, {"仅时间同步装置",3, }, }; #define TimeListSelectNum sizeof(TimeListSelect)/sizeof(SET_LIST) const SET_LIST PTTypeList[]= //对时方式 { {"单 点",0,}, {"双 点",1, }, {"单双点",2, }, }; #define PTTypeListNum sizeof(PTTypeList)/sizeof(SET_LIST) const SET_LIST YCTypeList[]= //遥测类型 { {"规一化值",0,}, {"标度化值",1, }, {"浮点数值",2, }, }; #define YCTypeListNum sizeof(YCTypeList)/sizeof(SET_LIST) const SET_LIST YCTypeDead[]= //遥测死区类型 { {"额定值",0,}, {"当前值",1, }, }; #define YCTypeDeadNum sizeof(YCTypeDead)/sizeof(SET_LIST) const SET_LIST IEC101AddrList[]= // 101规约地址个数 { {"单字节",0,}, {"双字节",1, }, }; #define IEC101AddrListNum sizeof(IEC101AddrList)/sizeof(SET_LIST) // 字节个数 const SET_LIST AddrNumList[]= { {"两字节", 0,}, {"三字节", 1,}, }; #define AddrNumListNum (sizeof(AddrNumList) / sizeof(SET_LIST)) const SET_LIST Net_Eth_List[]= //网卡地址列表 { {"网口1",0,}, {"网口2",1,}, {"网口3",2,}, }; #define Net_Eth_ListNum sizeof(Net_Eth_List)/sizeof(SET_LIST) const SET_LIST WFList[]= //录波文件格式 { {"ASCII",0,}, {"BINARY",1,}, }; #define WFListNum sizeof(WFList)/sizeof(SET_LIST) const SET_LIST LB_VOL_List[]= { {"第一组", 0}, {"第二组", 1}, {"全 部", 2}, }; #define LB_VOL_ListNum sizeof(LB_VOL_List)/sizeof(SET_LIST) const SET_LIST RCL_List[]= { {"中 文", 0}, {"英 文", 1}, }; #define RCL_ListNum sizeof(RCL_List)/sizeof(SET_LIST) const SET_LIST FA_List[]= { {"自适应综合型 ",0,}, {"电压时间型 ",1,}, {"电压电流时间型",2,}, }; #define FA_ListNum sizeof(FA_List)/sizeof(SET_LIST) //加密功能投退列表 const SET_LIST JMList[]= { {"退 出", 0,}, {"软件加密", 1,}, {"芯片加密", 2,}, }; #define JMListNum sizeof(JMList)/sizeof(SET_LIST) #ifdef FIX_PARAM_FORMAT const SET_LIST TULF8List[]= { {"G B K ", 0,}, {"UTF-8 ", 1,}, {"UNICODE", 2,}, }; #define TULF8ListNum sizeof(TULF8List)/sizeof(SET_LIST) #endif //加密功能投退列表 const SET_LIST T104ServerList[]= { {"服务器", 0,}, {"客户端", 1,}, }; #define T104ServerListNum sizeof(T104ServerList)/sizeof(SET_LIST) const SET_LIST HisFileFormatList[]= { {"msg格式", 0,}, {"xml格式", 1,}, }; #define HisFileFormatListNum sizeof(HisFileFormatList)/sizeof(SET_LIST) //电压选择功能投退列表 const SET_LIST TVolSelList[]= { {"Uab1", PUB_AC_UAB1,}, {"Ubc1", PUB_AC_UBC1,}, {"Uca1", PUB_AC_UCA1,}, {"Uab2", PUB_AC_UAB2,}, {"Ubc2", PUB_AC_UBC2,}, {"Uca2", PUB_AC_UCA2,}, {"Us1 ", PUB_AC_US1,}, {"Us2 ", PUB_AC_US2,}, {"U01 ", PUB_AC_U01,}, {"U02 ", PUB_AC_U02,}, #ifdef FUN_JDXX {"Ua1 ", PUB_AC_UA1,}, {"Ua2 ", PUB_AC_UA2,}, #endif }; #define TVolSelListNum sizeof(TVolSelList)/sizeof(SET_LIST) #ifdef CUSTOMIZE_BZT //备自投 const SET_LIST TISelList[]= { {"BIA", SW_AC_IA}, {"BIB", SW_AC_IB}, {"BIC", SW_AC_IC}, {"CIA", SW_AC_CIA}, {"CIB", SW_AC_CIB}, {"CIC", SW_AC_CIC}, }; #define TISelListNum sizeof(TISelList)/sizeof(SET_LIST) #endif const SET_LIST TGooseKG[]= { #ifdef GD_AREA_ECZD_2020 /*#ifdef GD_AREA_ZHONGSHAN_2020 {"首 开 关", 0,}, {"分段开关", 1,}, {"支线开关", 2,}, {"联络开关", 3,}, #else*/ {"其 他", 0,}, {"首开关", 1,}, {"末开关", 2,}, //#endif #else {"首 开 关", 0,}, {"分段开关", 1,}, {"支线开关", 2,}, {"联络开关", 3,}, #endif }; #define TGooseKGNum sizeof(TGooseKG)/sizeof(SET_LIST) const SET_LIST FAKGTYPE[]= { {"主环开关", 0,}, {"支线开关", 1,}, }; #define FAKGTYPENum sizeof(FAKGTYPE)/sizeof(SET_LIST) const SET_LIST TGooseFA[]= { {"退 出", 0,}, {"缓 动", 1,}, {"速 动", 2,}, }; #define TGooseFANum sizeof(TGooseFA)/sizeof(SET_LIST) const SET_LIST THHTYPE[]= { {"开 环", 0,}, {"闭 环", 1,}, }; #define THHTYPENum sizeof(THHTYPE)/sizeof(SET_LIST) const SET_LIST TPT_Type[]= { {"单相PT ", 0,}, {"VV接线PT", 1,}, {"YY接线PT", 2,}, }; #define TPT_TypeNum sizeof(TPT_Type)/sizeof(SET_LIST) const SET_LIST PUList[]= { {"UAB2", 0,}, {"UBC2", 1,}, {"UCA2", 2,}, }; #define TPT_UNum sizeof(PUList)/sizeof(SET_LIST) const SET_LIST TFA_Type[]= { {"无 效", 0,}, {"不依赖通信", 1,}, {"依赖通信 ", 2,}, }; #define TFA_TypeNum sizeof(TFA_Type)/sizeof(SET_LIST) const SET_LIST GOOSE_NET_List[]= { {"NORMAL", 0,}, {"H S R ", 1,}, {"P R P ", 2,}, }; #define GOOSE_NET_ListNum sizeof(GOOSE_NET_List)/sizeof(SET_LIST) const SET_LIST TFGKEY_Type[]= { {"复 归", 0,}, {"解 锁", 1,}, {"复 位", 2,}, }; #define TFGKEY_TYPE_TOTAL sizeof(TFGKEY_Type)/sizeof(SET_LIST) const SET_LIST UYY_List[]= { {"三相电压最小值", 0,}, {"三相电压最大值", 1,}, }; #define UYY_ListNum sizeof(UYY_List)/sizeof(SET_LIST) //电度列表 #ifdef METERING_ENERGY const SET_LIST DDList[]= { {"硬 件", 0, }, {"软 件", 1, }, }; #define DDListNum sizeof(DDList)/sizeof(SET_LIST) const SET_LIST JLFSList[]= { {"三相四线", 0, }, {"三相三线", 1, }, }; #define JLFSListNum sizeof(JLFSList)/sizeof(SET_LIST) const SET_LIST WGFSList[]= { {"标 准", 0, }, {"贵 州", 1, }, }; #define WGFSListNum sizeof(WGFSList)/sizeof(SET_LIST) #endif // 小电流突变启动方式 const SET_LIST TBLTYPE[]= { {"小电流突变", 0, }, {"电压突变", 1,}, }; #define TBLTYPENum sizeof(TBLTYPE)/sizeof(SET_LIST) // 小信号滤波方式 const SET_LIST FilterTYPE[]= { {"三点线性", 0,}, {"小波矩阵", 1,}, {"小波卷积", 2,}, }; #define FilterTYPENum sizeof(FilterTYPE)/sizeof(SET_LIST) // 小波类型 优化选低维度，高维度运算量大 const SET_LIST WaveletTYPE[]= { {"haar", 0,}, {"db2", 1,}, {"db3", 2,}, {"db4", 3,}, {"sym2", 4,}, {"sym3", 5,}, {"sym4", 6,}, {"coif1", 7,}, {"coif2", 8,}, {"coif3", 9,}, {"coif4", 10,}, }; #define WaveletTYPENum sizeof(WaveletTYPE)/sizeof(SET_LIST) const SET_LIST START_List[]= { {"不启动", 0}, {"启 动", 1}, }; #define START_ListNum sizeof(START_List)/sizeof(SET_LIST) const SET_LIST BMLList[] = { {"非全相", 0, }, {"加判零压", 1, }, {"加判零流低压", 2, }, }; #define BMLListNum (sizeof(BMLList) / sizeof(SET_LIST)) const SET_LIST JWYList[] = { {"母有线无", 0, }, {"母无线有", 1, }, {"两侧无压", 2, }, }; #define JWYListNum (sizeof(JWYList) / sizeof(SET_LIST)) int g_goose_net_type=0; /********************************************************************** 公共定值 ***********************************************************************/ const TSETTABLE tPubSetTable[]= { /* 类型 单位 最小值 最大值 默认值 列表 列表数 组 步长 描述 */ {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_EQPPARA, 0, "设备参数"}, {SETTYPE_5INT, SET_A, 0, 2000, 600, 0, 0, GROUP_SET_EQPPARA, 1, "CT额定一次值"}, {SETTYPE_5INT, SET_A, 0, 100, 5, 0, 0, GROUP_SET_EQPPARA, 1, "CT额定二次值"}, {SETTYPE_5INT, SET_A, 0, 2000, 100, 0, 0, GROUP_SET_EQPPARA, 1, "零序CT额定一次值"}, {SETTYPE_5INT, SET_A, 0, 100, 5, 0, 0, GROUP_SET_EQPPARA, 1, "零序CT额定二次值"}, {SETTYPE_5INT, SET_U, 0, 99999, 10000, 0, 0, GROUP_SET_EQPPARA, 1, "电源侧PT额定一次值"}, {SETTYPE_5INT, SET_U, 0, 1000, 100, 0, 0, GROUP_SET_EQPPARA, 1, "电源侧PT额定二次值"}, {SETTYPE_5INT, SET_U, 0, 99999, 10000, 0, 0, GROUP_SET_EQPPARA, 1, "负荷侧PT额定一次值"}, {SETTYPE_5INT, SET_U, 0, 1000, 100, 0, 0, GROUP_SET_EQPPARA, 1, "负荷侧PT额定二次值"}, {SETTYPE_LIST, SET_NULL, 0, TPT_TypeNum - 1, 2, TPT_Type, TPT_TypeNum, GROUP_SET_EQPPARA, 1, "A侧PT接线方式"}, {SETTYPE_LIST, SET_NULL, 0, TPT_TypeNum - 1, 2, TPT_Type, TPT_TypeNum, GROUP_SET_EQPPARA, 1, "B侧PT接线方式"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_SCT, 0, "定值区"}, #ifdef FIXAREA_VERSION_T {SETTYPE_UINT, SET_NULL, 0, SEC_NUMBER - 1, 1, 0, 0, GROUP_SET_SCT, 1, "当前定值区号"}, {SETTYPE_UINT, SET_NULL, 0, SEC_NUMBER - 1, 1, 0, 0, GROUP_SET_SCT, 1, "待召唤定值区号"}, {SETTYPE_UINT, SET_NULL, 0, SEC_NUMBER - 1, 1, 0, 0, GROUP_SET_SCT, 1, "待执行定值区号"}, #else {SETTYPE_UINT, SET_NULL, 1, SEC_NUMBER - 1, 1, 0, 0, GROUP_SET_SCT, 1, "定值区号"}, #endif {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_PUBYB, 0, "运行软压板"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 1, TTList, TTListNum, GROUP_SET_PUBYB, 1, "远程运维投入"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_PUBSET, 0, "电压参数"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_PUBSET, 1, "过电压投退"}, {SETTYPE_F, SET_U, 10.0, 380.0, 110.0, 0, 0, GROUP_SET_PUBSET, 0.01, "过电压定值"}, {SETTYPE_F, SET_S, 0, 999.0, 999.0, 0, 0, GROUP_SET_PUBSET, 0.01, "过电压时间"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_PUBSET, 1, "低电压投退"}, {SETTYPE_F, SET_U, 10.0, 380.0, 90.0, 0, 0, GROUP_SET_PUBSET, 0.01, "低电压定值"}, {SETTYPE_F, SET_S, 0, 999.0, 999.0, 0, 0, GROUP_SET_PUBSET, 0.01, "低电压时间"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_PUBSET, 1, "线路有压投退"}, {SETTYPE_F, SET_U, 10.0, 380.0, 70.0, 0, 0, GROUP_SET_PUBSET, 0.01, "有压定值"}, {SETTYPE_F, SET_S, 0, 999.0, 0.1, 0, 0, GROUP_SET_PUBSET, 0.01, "有压时间"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_PUBSET, 1, "线路无压投退"}, {SETTYPE_F, SET_U, 10.0, 380.0, 30.0, 0, 0, GROUP_SET_PUBSET, 0.01, "无压定值"}, {SETTYPE_F, SET_S, 0, 999.0, 0.1, 0, 0, GROUP_SET_PUBSET, 0.01, "无压时间"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_PUBSET, 1, "直流电压1告警投退"}, {SETTYPE_F, SET_U, 10.0, 100.0, 20.0, 0, 0, GROUP_SET_PUBSET, 0.01, "直流电压1告警定值"}, {SETTYPE_F, SET_S, 0.1, 999.0, 999.0, 0, 0, GROUP_SET_PUBSET, 0.01, "直流电压1告警时间"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_PUBSET, 1, "直流电压2告警投退"}, {SETTYPE_F, SET_U, 10.0, 100.0, 20.0, 0, 0, GROUP_SET_PUBSET, 0.01, "直流电压2告警定值"}, {SETTYPE_F, SET_S, 0.1, 999.0, 999.0, 0, 0, GROUP_SET_PUBSET, 0.01, "直流电压2告警时间"}, #ifdef CUSTOMIZE_BZT //备自投 {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_PUBSET, 1, "失压分闸投退"}, {SETTYPE_F, SET_U, 0.0, 220.0, 66.0, 0, 0, GROUP_SET_PUBSET, 0.01, "失压分闸定值"}, {SETTYPE_F, SET_S, 0.0, 99, 0.1, 0, 0, GROUP_SET_PUBSET, 0.01, "失压分闸时间"}, #endif {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_FDL, 0, "非电量保护"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_FDL, 1, "非电量1保护"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_FDL, 1, "非电量2保护"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_FDL, 1, "非电量3保护"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_FDL, 1, "非电量4保护"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_FDL, 1, "非电量5保护"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_FDL, 1, "非电量6保护"}, {SETTYPE_F, SET_S, 0, 999.0, 999.0, 0, 0, GROUP_SET_FDL, 0.01, "非电量1时间"}, {SETTYPE_F, SET_S, 0, 999.0, 999.0, 0, 0, GROUP_SET_FDL, 0.01, "非电量2时间"}, {SETTYPE_F, SET_S, 0, 999.0, 999.0, 0, 0, GROUP_SET_FDL, 0.01, "非电量3时间"}, {SETTYPE_F, SET_S, 0, 999.0, 999.0, 0, 0, GROUP_SET_FDL, 0.01, "非电量4时间"}, {SETTYPE_F, SET_S, 0, 999.0, 999.0, 0, 0, GROUP_SET_FDL, 0.01, "非电量5时间"}, {SETTYPE_F, SET_S, 0, 999.0, 999.0, 0, 0, GROUP_SET_FDL, 0.01, "非电量6时间"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_OTHERS_PUB, 0, "其它"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 1, TTList, TTListNum, GROUP_SET_OTHERS_PUB, 1, "经高阻接地方式"}, {SETTYPE_LIST, SET_NULL, 0, TBLTYPENum - 1, 0, TBLTYPE, TBLTYPENum, GROUP_SET_OTHERS_PUB, 1, "小电流突变方式"}, {SETTYPE_LIST, SET_NULL, 0, FilterTYPENum - 1, 2, FilterTYPE, FilterTYPENum, GROUP_SET_OTHERS_PUB, 1, "信号滤波方式"}, {SETTYPE_LIST, SET_NULL, 0, WaveletTYPENum - 1, 0, WaveletTYPE,WaveletTYPENum, GROUP_SET_OTHERS_PUB, 1, "小波类型"}, {SETTYPE_UINT, SET_NULL, 1, 4, 2, 0, 0, GROUP_SET_OTHERS_PUB, 1, "小波卷积阶数"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_OTHERS_PUB, 1, "H 变换"}, {SETTYPE_F, SET_S, 0, 999.0, 10.0, 0, 0, GROUP_SET_OTHERS_PUB, 0.01, "同期合闸判断返回时间"}, #ifdef FUNC_SET_FA_JS {SETTYPE_F, SET_S, 0, 10, 0.05, 0, 0, GROUP_SET_OTHERS_PUB, 0.01, "FA合闸解锁时间"}, #endif #ifdef VOLT_ADAPTIVE_FACTOR {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_OTHERS_PUB, 1, "自适应电压系数"}, #endif }; const int PUB_SET_NUMBER = sizeof( tPubSetTable ) / sizeof(tPubSetTable[0]); // 定值数目 /********************************************************************** 保护定值参数 ***********************************************************************/ const TSETTABLE tSwSetTable[] = // min max default { /* 类型 单位 最小值 最大值 默认值 列表 列表数 组 步长 描述 */ {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_YB_GN, 0, "功能软压板"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_YB_GN, 1, "常规保护投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_YB_GN, 1, "自动重合闸投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_YB_GN, 1, "就地馈线自动化投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_YB_GN, 1, "智能分布式投入"}, #ifdef JZS_FUNCTION {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_YB_GN, 1, "集中式压板"}, #endif {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_YB_GN, 1, "同期合闸投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_YB_GN, 1, "自动解列投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_YB_GN, 1, "小电流接地保护投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_YB_GN, 1, "线路断线告警投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_YB_GN, 1, "不停电传动投入"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_YB_YX, 0, "运行软压板"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 1, TTList, TTListNum, GROUP_SET_YB_YX, 1, "自动化功能总投退软压板"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 1, TTList, TTListNum, GROUP_SET_YB_YX, 1, "自动化功能总出口软压板"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 1, TTList, TTListNum, GROUP_SET_YB_YX, 1, "重合闸软压板"}, #ifdef YK_SOFT_YB {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_YB_YX, 1, "遥控软压板"}, #endif /* 类型 单位 最小值 最大值 默认值 列表 列表数 组 步长 描述 */ {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_BHTT, 0, "常规保护控制字"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_BHTT, 1, "过流Ⅰ段投入"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_BHTT, 1, "过流Ⅱ段投入"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_BHTT, 1, "过流Ⅲ段投入"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_BHTT, 1, "过流Ⅰ段投方向"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_BHTT, 1, "过流Ⅱ段投方向"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_BHTT, 1, "过流Ⅲ段投方向"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_BHTT, 1, "PT断线检测投入"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_BHTT, 1, "零序过流Ⅰ段投入"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_BHTT, 1, "零序过流Ⅱ段投入"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_BHTT, 1, "零序过流Ⅲ段投入"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_BHTT, 1, "零序过电压保护"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_BHTT, 1, "后加速保护投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 1, TTList, TTListNum, GROUP_SET_BHTT, 1, "过流保护启动重合闸"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_BHTT, 1, "零序过流保护启动重合闸"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_BHTT, 1, "涌流识别投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_BHTT, 1, "非遮断保护投入"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_BHDZ, 0, "常规保护整定值"}, {SETTYPE_F, SET_A, 0, 100.0, 100.0, 0, 0, GROUP_SET_BHDZ, 0.01, "过流Ⅰ段定值"}, {SETTYPE_F, SET_S, 0, 99.0, 99.0, 0, 0, GROUP_SET_BHDZ, 0.01, "过流Ⅰ段时间"}, {SETTYPE_F, SET_A, 0, 100.0, 100.0, 0, 0, GROUP_SET_BHDZ, 0.01, "过流Ⅱ段定值"}, {SETTYPE_F, SET_S, 0, 99.0, 99.0, 0, 0, GROUP_SET_BHDZ, 0.01, "过流Ⅱ段时间"}, {SETTYPE_F, SET_A, 0, 100.0, 100.0, 0, 0, GROUP_SET_BHDZ, 0.01, "过流Ⅲ段定值"}, {SETTYPE_F, SET_S, 0, 99.0, 99.0, 0, 0, GROUP_SET_BHDZ, 0.01, "过流Ⅲ段时间"}, {SETTYPE_F, SET_A, 0, 50.0, 50.0, 0, 0, GROUP_SET_BHDZ, 0.01, "零序过流Ⅰ段定值"}, {SETTYPE_F, SET_S, 0, 99.0, 99.0, 0, 0, GROUP_SET_BHDZ, 0.01, "零序过流Ⅰ段时间"}, {SETTYPE_F, SET_A, 0, 50.0, 50.0, 0, 0, GROUP_SET_BHDZ, 0.01, "零序过流Ⅱ段定值"}, {SETTYPE_F, SET_S, 0, 99.0, 99.0, 0, 0, GROUP_SET_BHDZ, 0.01, "零序过流Ⅱ段时间"}, {SETTYPE_F, SET_A, 0, 50.0, 50.0, 0, 0, GROUP_SET_BHDZ, 0.01, "零序过流Ⅲ段定值"}, {SETTYPE_F, SET_S, 0, 99.0, 99.0, 0, 0, GROUP_SET_BHDZ, 0.01, "零序过流Ⅲ段时间"}, {SETTYPE_F, SET_U, 0, 100.0, 100.0, 0, 0, GROUP_SET_BHDZ, 0.01, "零序过电压保护定值"}, {SETTYPE_F, SET_S, 0, 99.0, 99.0, 0, 0, GROUP_SET_BHDZ, 0.01, "零序过电压保护时间"}, {SETTYPE_F, SET_S, 0, 600.0, 600.0, 0, 0, GROUP_SET_BHDZ, 0.01, "加速段保护开放时间"}, {SETTYPE_F, SET_A, 0, 50.0, 50.0, 0, 0, GROUP_SET_BHDZ, 0.01, "后加速过流保护定值"}, {SETTYPE_F, SET_S, 0, 99.0, 99.0, 0, 0, GROUP_SET_BHDZ, 0.01, "后加速过流保护时间"}, {SETTYPE_F, SET_A, 0, 100.0, 100.0, 0, 0, GROUP_SET_BHDZ, 0.01, "后加速零序电流保护定值"}, {SETTYPE_F, SET_S, 0, 99.0, 99.0, 0, 0, GROUP_SET_BHDZ, 0.01, "后加速零序电流保护时间"}, {SETTYPE_F, SET_NULL, 0.1, 0.35, 0.35, 0, 0, GROUP_SET_BHDZ, 0.01, "二次谐波闭锁系数"}, {SETTYPE_F, SET_A, 0, 100.0, 100.0, 0, 0, GROUP_SET_BHDZ, 0.01, "非遮断电流定值"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_CHZKZ, 0, "自动重合闸控制字"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_CHZKZ, 1, "一次重合闸投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_CHZKZ, 1, "二次重合闸投入"}, #ifdef DISP_SET_CH_T3 {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_CHZKZ, 1, "三次重合闸投入"}, #endif {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_CHZKZ, 1, "重合闸检同期"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_CHZKZ, 1, "重合闸检无压"}, {SETTYPE_LIST, SET_NULL, 0, JWYListNum - 1, 0, JWYList, JWYListNum, GROUP_SET_CHZKZ, 1, "重合闸检无压方式"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_CHZKZ, 1, "大电流闭锁重合投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_CHZKZ, 1, "偷跳启动重合"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_CHZDZ, 0, "自动重合闸定值"}, {SETTYPE_F, SET_S, 0.3, 900, 900, 0, 0, GROUP_SET_CHZDZ, 0.01, "重合闸开放时间"}, #ifdef FUNC_CHZ_CHARGE_TIME {SETTYPE_F, SET_S, 0, 199.0, 199.0, 0, 0, GROUP_SET_CHZDZ, 0.01, "重合闸充电时间"}, #else {SETTYPE_F, SET_S, 0, 199.0, 199.0, 0, 0, GROUP_SET_CHZDZ, 0.01, "单次重合充电时间"}, {SETTYPE_F, SET_S, 0, 199.0, 199.0, 0, 0, GROUP_SET_CHZDZ, 0.01, "多次重合充电时间"}, #endif {SETTYPE_F, SET_S, 0, 199.0, 199.0, 0, 0, GROUP_SET_CHZDZ, 0.01, "一次重合闸时间"}, {SETTYPE_F, SET_S, 0, 99.0, 99.0, 0, 0, GROUP_SET_CHZDZ, 0.01, "二次重合闸闭锁时间"}, {SETTYPE_F, SET_S, 0, 199.0, 199.0, 0, 0, GROUP_SET_CHZDZ, 0.01, "二次重合闸时间"}, #ifdef DISP_SET_CH_T3 {SETTYPE_F, SET_S, 0, 199.0, 199.0, 0, 0, GROUP_SET_CHZDZ, 0.01, "三次重合闸时间"}, #endif {SETTYPE_F, SET_A, 0, 100.0, 100.0, 0, 0, GROUP_SET_CHZDZ, 0.01, "大电流闭锁重合闸定值"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_FAYB, 0, "就地馈线自动化软压板"}, {SETTYPE_LIST, SET_NULL, 0, KGFunListNum - 1, 1, KGFunList, KGFunListNum, GROUP_SET_FAYB, 1, "分段/联络模式"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_FATT, 0, "就地馈线自动化控制字"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_FATT, 1, "电源侧得电延时合闸"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_FATT, 1, "负荷侧得电延时合闸"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_FATT, 1, "A侧失电延时合闸"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_FATT, 1, "B侧失电延时合闸"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_FATT, 1, "合到故障分闸"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_FATT, 1, "短时闭锁失压分"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_FATT, 1, "相间过流告警投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_FATT, 1, "接地告警投入"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TTList, TZCKListNum, GROUP_SET_FATT, 1, "合到零压保护"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_FATT, 1, "非遮断电流保护"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_FATT, 1, "PT断线告警"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_FATT, 1, "多次失压分闸闭锁"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_FATT, 1, "涌流识别投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_FATT, 1, "硬件残压闭锁"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 1, TTList, TTListNum, GROUP_SET_FATT, 1, "残压闭锁"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 1, TTList, TTListNum, GROUP_SET_FATT, 1, "双侧有压闭锁合闸"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 1, TTList, TTListNum, GROUP_SET_FATT, 1, "手动/遥控分闸闭锁得电合"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_FATT, 1, "手合无压闭锁分闸"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 1, TTList, TTListNum, GROUP_SET_FATT, 1, "合到故障分闸闭锁合闸"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 1, TTList, TTListNum, GROUP_SET_FATT, 1, "失电延时分闸"}, #ifdef FA_OC_COUNT {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_FATT, 1, "过流脉冲计数投退"}, #endif {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_FADZ, 0, "馈线自动化定值"}, {SETTYPE_F, SET_PERUN, 0, 220.0, 80.0, 0, 0, GROUP_SET_FADZ, 0.01, "有压定值"}, {SETTYPE_F, SET_PERUN, 0, 220.0, 30.0, 0, 0, GROUP_SET_FADZ, 0.01, "无压定值"}, {SETTYPE_F, SET_S, 0, 99, 99, 0, 0, GROUP_SET_FADZ, 0.01, "得电合闸延时(X时限)"}, {SETTYPE_F, SET_S, 0, 99, 99, 0, 0, GROUP_SET_FADZ, 0.01, "故障检测时限(Y时限)"}, {SETTYPE_F, SET_S, 0, 300, 300, 0, 0, GROUP_SET_FADZ, 0.01, "失压合闸延时(XL时限)"}, {SETTYPE_F, SET_S, 0, 99, 99, 0, 0, GROUP_SET_FADZ, 0.01, "失电分闸延时(Z时限)"}, {SETTYPE_F, SET_S, 0, 99, 99, 0, 0, GROUP_SET_FADZ, 0.01, "闭锁分闸复归时间"}, {SETTYPE_F, SET_A, 0, 100.0, 100.0, 0, 0, GROUP_SET_FADZ, 0.01, "相间故障电流I段定值"}, {SETTYPE_F, SET_S, 0, 99, 99, 0, 0, GROUP_SET_FADZ, 0.01, "相间故障电流I段时间"}, {SETTYPE_F, SET_A, 0, 100.0, 100.0, 0, 0, GROUP_SET_FADZ, 0.01, "相间故障电流II段定值"}, {SETTYPE_F, SET_S, 0, 99, 99, 0, 0, GROUP_SET_FADZ, 0.01, "相间故障电流II段时间"}, {SETTYPE_F, SET_A, 0, 100.0, 100.0, 0, 0, GROUP_SET_FADZ, 0.01, "接地故障电流定值"}, {SETTYPE_F, SET_S, 0, 99, 99, 0, 0, GROUP_SET_FADZ, 0.01, "接地故障时间定值"}, {SETTYPE_F, SET_U, 0, 100.0, 100.0, 0, 0, GROUP_SET_FADZ, 0.01, "复合电压低电压定值"}, {SETTYPE_F, SET_U, 0, 100.0, 100.0, 0, 0, GROUP_SET_FADZ, 0.01, "复合电压负序电压定值"}, {SETTYPE_F, SET_A, 0, 100.0, 100.0, 0, 0, GROUP_SET_FADZ, 0.01, "相间过流告警电流定值"}, {SETTYPE_F, SET_S, 0, 99, 99, 0, 0, GROUP_SET_FADZ, 0.01, "相间过流告警时间定值"}, {SETTYPE_F, SET_A, 0, 100.0, 100.0, 0, 0, GROUP_SET_FADZ, 0.01, "接地告警电流定值"}, {SETTYPE_F, SET_S, 0, 99, 99, 0, 0, GROUP_SET_FADZ, 0.01, "接地告警时间定值"}, {SETTYPE_F, SET_U, 0, 660.0, 660.0, 0, 0, GROUP_SET_FADZ, 0.01, "零序电压保护电压定值"}, {SETTYPE_F, SET_S, 0, 99.0, 0.6, 0, 0, GROUP_SET_FADZ, 0.01, "零序电压保护时间定值"}, {SETTYPE_F, SET_A, 0, 100.0, 100.0, 0, 0, GROUP_SET_FADZ, 0.01, "非遮断电流值"}, {SETTYPE_F, SET_NULL, 0.10, 0.35, 0.35, 0, 0, GROUP_SET_FADZ, 0.01, "二次谐波闭锁系数"}, {SETTYPE_UINT, SET_NULL, 1, 5, 3, 0, 0, GROUP_SET_FADZ, 1, "多次失压分闸闭锁次数"}, {SETTYPE_F, SET_S, 0, 65536.0, 480.0, 0, 0, GROUP_SET_FADZ, 0.01, "多次失压分闸闭锁时间"}, {SETTYPE_F, SET_A, 0, 100.0, 0.05, 0, 0, GROUP_SET_FADZ, 0.01, "无流定值"}, {SETTYPE_F, SET_S, 0, 99.0, 0.1, 0, 0, GROUP_SET_FADZ, 0.01, "有压判定时间"}, {SETTYPE_F, SET_S, 0, 99.0, 0.1, 0, 0, GROUP_SET_FADZ, 0.01, "无压判定时间"}, {SETTYPE_F, SET_S, 0, 99, 6, 0, 0, GROUP_SET_FADZ, 0.01, "联络充电时间"}, #if defined GD_AREA_ZHONGSHAN_2020 {SETTYPE_F, SET_S, 0, 99, 99, 0, 0, GROUP_SET_FADZ, 0.01, "快速跳闸延时"}, #endif #ifdef FA_OC_COUNT {SETTYPE_UINT, SET_NULL, 1, 1000, 3, 0, 0, GROUP_SET_FADZ, 1, "过流脉冲次数"}, {SETTYPE_F, SET_S, 0.1, 65536.0, 300.0, 0, 0, GROUP_SET_FADZ, 0.01, "过流脉冲复归时间"}, #endif #if defined GD_AREA_ECZD_2020 {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_GOOSETT, 0, "智能分布式控制字"}, {SETTYPE_LIST, SET_NULL, 0, TGooseFANum - 1, 0, TGooseFA, TGooseFANum, GROUP_SET_GOOSETT, 1, "分布式FA方式"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_GOOSETT, 1, "联络自投投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_GOOSETT, 1, "过载闭锁自投投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_GOOSETT, 1, "首开关失压保护投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_GOOSETT, 1, "智能分布式启动重合闸"}, {SETTYPE_LIST, SET_NULL, 0, TGooseKGNum - 1, 1, TGooseKG, TGooseKGNum, GROUP_SET_GOOSETT, 1, "本接点开关类型"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_GOOSEDZ, 0, "智能分布式定值"}, #if defined GD_AREA_ZHONGSHAN_2020 {SETTYPE_F, SET_A, 0.05, 100.0, 50.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "故障切除相电流I段"}, {SETTYPE_F, SET_S, 0, 100.0, 100.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "相电流I段跳闸延时"}, {SETTYPE_F, SET_A, 0.05, 100.0, 50.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "故障切除相电流II段"}, {SETTYPE_F, SET_S, 0, 100.0, 100.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "相电流II段跳闸延时"}, {SETTYPE_F, SET_A, 0.05, 100.0, 50.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "故障切除零序电流"}, {SETTYPE_F, SET_S, 0, 100.0, 100.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "零序电流跳闸延时"}, {SETTYPE_F, SET_S, 0.00, 100.0, 0.1, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "故障点下游开关隔离时间"}, {SETTYPE_F, SET_S, 0.01, 100.0, 1.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "首开关失压跳闸时限"}, {SETTYPE_F, SET_S, 0.01, 100.0, 5.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "供电恢复时限"}, {SETTYPE_LIST, SET_NULL, 0, TGooseKGNum - 1, 1, TGooseKG, TGooseKGNum, GROUP_SET_GOOSEDZ, 1, "本接点开关类型"}, {SETTYPE_LIST, SET_NULL, 0, FAKGTYPENum - 1, 1, FAKGTYPE, FAKGTYPENum, GROUP_SET_GOOSEDZ, 1, "开关位置类型"}, #else {SETTYPE_F, SET_U, 0.0, 330.0, 30.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "无压定值"}, {SETTYPE_F, SET_U, 0.0, 330.0, 70.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "有压定值"}, {SETTYPE_F, SET_A, 0.0, 100.0, 0.02, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "无流定值"}, {SETTYPE_F, SET_A, 0.05, 100.0, 50.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "分布式FA过流定值"}, {SETTYPE_F, SET_S, 0, 100.0, 100.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "分布式FA过流时间"}, {SETTYPE_F, SET_A, 0.05, 100.0, 50.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "分布式FA零序过流定值"}, {SETTYPE_F, SET_S, 0, 100.0, 100.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "分布式FA零序过流时间"}, {SETTYPE_F, SET_S, 0, 100.0, 100.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "联络自投充电延时"}, {SETTYPE_F, SET_S, 0.01, 100.0, 1.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "首开关失压跳闸延时"}, {SETTYPE_F, SET_A, 0.05, 100.0, 50.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "过载判断定值"}, {SETTYPE_F, SET_S, 0, 100.0, 100.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "失灵判断延时"}, {SETTYPE_F, SET_S, 0.01, 100.0, 100.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "故障隔离时限"}, {SETTYPE_F, SET_S, 0, 100.0, 5.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "供电恢复时限"}, #endif #else {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_GOOSETT, 0, "分布式FA控制字"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_GOOSETT, 1, "分布式FA功能"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_GOOSETT, 1, "首开关失压分闸"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_GOOSETT, 1, "本节点供电恢复"}, {SETTYPE_LIST, SET_NULL, 0, TGooseFANum - 1, 0, TGooseFA, TGooseFANum, GROUP_SET_GOOSETT, 1, "智能分布式动作类型"}, {SETTYPE_LIST, SET_NULL, 0, TGooseKGNum - 1, 1, TGooseKG, TGooseKGNum, GROUP_SET_GOOSETT, 1, "本节点开关类型"}, {SETTYPE_LIST, SET_NULL, 0, THHTYPENum - 1, 0, THHTYPE, THHTYPENum, GROUP_SET_GOOSETT, 1, "组网方式"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_GOOSETT, 1, "母线故障跳末开关"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_GOOSETT, 1, "涌流识别"}, #ifdef GOOSE_NETTYPE_SET {SETTYPE_LIST, SET_NULL, 0, GOOSE_NET_ListNum - 1, 0, GOOSE_NET_List, GOOSE_NET_ListNum, GROUP_CSTSET_OTHERS, 1, "goose网络类型"}, #endif {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_GOOSEDZ, 0, "分布式FA定值"}, #ifdef GD_AREA_ZHONGSHAN {SETTYPE_F, SET_A, 0.05, 100.0, 50.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "故障切除相电流I段"}, {SETTYPE_F, SET_S, 0, 100.0, 100.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "相电流I段跳闸延时"}, {SETTYPE_F, SET_A, 0.05, 100.0, 50.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "故障切除相电流II段"}, {SETTYPE_F, SET_S, 0, 100.0, 100.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "相电流II段跳闸延时"}, {SETTYPE_F, SET_A, 0.05, 100.0, 50.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "故障切除零序电流"}, {SETTYPE_F, SET_S, 0, 100.0, 100.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "零序电流跳闸延时"}, #endif {SETTYPE_F, SET_S, 0.01, 100.0, 1.0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "首开关失压分闸延时"}, {SETTYPE_F, SET_S, 100.0, 5.0, 0, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "恢复供电时间"}, {SETTYPE_F, SET_S, 0.00, 100.0, 0.1, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "故障隔离时间"}, {SETTYPE_F, SET_NULL, 0, 1.00, 0.15, 0, 0, GROUP_SET_GOOSEDZ, 0.01, "涌流识别定值"}, #endif {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_TQHZ, 0, "同期合闸定值"}, {SETTYPE_F, SET_PERUN, 0, 220.0, 220.0, 0, 0, GROUP_SET_TQHZ, 0.01, "同期允许电压差"}, {SETTYPE_F, SET_ANG, 0.0, 30.0, 30.0, 0, 0, GROUP_SET_TQHZ, 0.01, "同期允许相角差"}, {SETTYPE_F, SET_HZ, 0.0, 5.0, 5.0, 0, 0, GROUP_SET_TQHZ, 0.01, "同期允许频率差"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_JLTT, 0, "自动解列控制字"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_JLTT, 1, "电压越限解列投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_JLTT, 1, "电压滑差闭锁功能"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_JLTT, 1, "频率越限解列投入"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_JLTT, 1, "频率滑差闭锁功能"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_JLDZ, 0, "自动解列定值"}, {SETTYPE_F, SET_S, 0, 60.0, 60.0, 0, 0, GROUP_SET_JLDZ, 0.01, "解列充电时间"}, {SETTYPE_F, SET_PERUN, 0, 220.0, 220.0, 0, 0, GROUP_SET_JLDZ, 0.01, "电压过低解列定值"}, {SETTYPE_F, SET_S, 0, 999.0, 999.0, 0, 0, GROUP_SET_JLDZ, 0.01, "电压过低解列时间"}, {SETTYPE_F, SET_PERUN, 0, 220.0, 220.0, 0, 0, GROUP_SET_JLDZ, 0.01, "低电压解列定值"}, {SETTYPE_F, SET_S, 0, 999.0, 999.0, 0, 0, GROUP_SET_JLDZ, 0.01, "低电压解列时间"}, {SETTYPE_F, SET_PERUN, 0, 380.0, 380.0, 0, 0, GROUP_SET_JLDZ, 0.01, "高电压解列定值"}, {SETTYPE_F, SET_S, 0, 999.0, 999.0, 0, 0, GROUP_SET_JLDZ, 0.01, "高电压解列时间"}, {SETTYPE_F, SET_PERUN, 0, 380.0, 380.0, 0, 0, GROUP_SET_JLDZ, 0.01, "电压过高解列定值"}, {SETTYPE_F, SET_S, 0, 999.0, 999.0, 0, 0, GROUP_SET_JLDZ, 0.01, "电压过高解列时间"}, {SETTYPE_F, SET_U_S, 0, 500.0, 500.0, 0, 0, GROUP_SET_JLDZ, 0.01, "电压滑差定值"}, {SETTYPE_F, SET_HZ, 45.0, 50.0, 50.0, 0, 0, GROUP_SET_JLDZ, 0.01, "频率过低解列定值"}, {SETTYPE_F, SET_S, 0, 999.0, 999.0, 0, 0, GROUP_SET_JLDZ, 0.01, "频率过低解列时间"}, {SETTYPE_F, SET_HZ, 45.0, 50.0, 50.0, 0, 0, GROUP_SET_JLDZ, 0.01, "低频解列定值"}, {SETTYPE_F, SET_S, 0, 999.0, 999.0, 0, 0, GROUP_SET_JLDZ, 0.01, "低频解列时间"}, {SETTYPE_F, SET_HZ, 50.0, 55.0, 55.0, 0, 0, GROUP_SET_JLDZ, 0.01, "高频解列定值"}, {SETTYPE_F, SET_S, 0, 999.0, 999.0, 0, 0, GROUP_SET_JLDZ, 0.01, "高频解列时间"}, {SETTYPE_F, SET_HZ, 50.0, 55.0, 55.0, 0, 0, GROUP_SET_JLDZ, 0.01, "频率过高解列定值"}, {SETTYPE_F, SET_S, 0, 999.0, 999.0, 0, 0, GROUP_SET_JLDZ, 0.01, "频率过高解列时间"}, {SETTYPE_F, SET_HZ_S, 0.5, 20.0, 20.0, 0, 0, GROUP_SET_JLDZ, 0.01, "频率滑差定值"}, #ifdef XDL_ZT // 小电流接地 {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_XDLJDTT, 0, "小电流接地控制字"}, {SETTYPE_LIST, SET_NULL, 0, TZCKListNum - 1, 0, TZCKList, TZCKListNum, GROUP_SET_XDLJDTT, 1, "小电流接地保护"}, {SETTYPE_LIST, SET_NULL, 0, START_ListNum - 1, 0, START_List, START_ListNum, GROUP_SET_XDLJDTT, 1, "小电流接地保护启动重合闸"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_XDLJDTT, 1, "小电流接地保护后加速"}, {SETTYPE_LIST, SET_NULL, 0, XDLQDListNum - 1, 1, XDLQDList, XDLQDListNum, GROUP_SET_XDLJDTT, 1, "小电流启动类型"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_XDLJDDZ, 0, "小电流接地定值"}, {SETTYPE_F, SET_S, 0, 99.0, 99.0, 0, 0, GROUP_SET_XDLJDDZ, 0.01, "小电流接地故障时间"}, {SETTYPE_F, SET_S, 0, 900.0, 900.0, 0, 0, GROUP_SET_XDLJDDZ, 0.01, "后加速开放时间"}, {SETTYPE_F, SET_A, 0, 100.0, 100.0, 0, 0, GROUP_SET_XDLJDDZ, 0.01, "小电流暂态电流"}, #elif defined FUN_JDXX // 接地选线 {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_XDLJD, 0, "小电流接地辅助定值"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_XDLJD, 1, "接地选线告警投退"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_XDLJD, 1, "接地选线跳闸投退"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_XDLJD, 1, "接地选相投退"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_XDLJD, 1, "零序功率方向投退"}, {SETTYPE_F, SET_A, 0, 0.1, 0.001, 0, 0, GROUP_SET_XDLJD, 0.01, "接地电流零漂值"}, {SETTYPE_F, SET_A, 0, 1.8, 0.005, 0, 0, GROUP_SET_XDLJD, 0.01, "启动值"}, {SETTYPE_UINT, SET_NULL, 1, 32, 2, 0, 0, GROUP_SET_XDLJD, 1, "启动点数"}, {SETTYPE_UINT, SET_NULL, 1, 32, 4, 0, 0, GROUP_SET_XDLJD, 1, "确认点数"}, {SETTYPE_UINT, SET_NULL, 1, 128, 16, 0, 0, GROUP_SET_XDLJD, 1, "采样点数"}, {SETTYPE_LIST, SET_NULL, 0, TVolSelListNum - 1, 8, TVolSelList,TVolSelListNum, GROUP_SET_XDLJD, 1, "参考电压选择"}, {SETTYPE_F, SET_U, 0.01, 220, 0.1, 0, 0, GROUP_SET_XDLJD, 0.01, "参考电压启动值"}, {SETTYPE_F, SET_U, 0, 100.0, 1.0, 0, 0, GROUP_SET_XDLJD, 0.01, "接地零序电压定值"}, {SETTYPE_F, SET_S, 0, 1000, 0, 0, 0, GROUP_SET_XDLJD, 0.01, "接地选线动作时间"}, {SETTYPE_F, SET_S, 0, 1000, 0, 0, 0, GROUP_SET_XDLJD, 0.01, "接地选线告警时间"}, {SETTYPE_LIST, SET_NULL, 0, JDTYPENum - 1, 0, JDTYPE, JDTYPENum, GROUP_SET_SWSET, 1, "系统接地方式"}, #endif {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_LA, 0, "线路断线告警"}, {SETTYPE_F, SET_S, 0, 99.0, 99.0, 0, 0, GROUP_SET_LA, 0.01, "线路断线告警确认时间"}, {SETTYPE_UINT, SET_NULL, 0, BMLListNum, 0, BMLList, BMLListNum, GROUP_SET_LA, 1, "线路断线判定方式"}, {SETTYPE_F, SET_U, 0, 380.0, 380.0, 0, 0, GROUP_SET_LA, 0.01, "线路断线零压"}, {SETTYPE_F, SET_A, 0, 50.0, 50.0, 0, 0, GROUP_SET_LA, 0.01, "线路断线零流"}, {SETTYPE_F, SET_U, 0, 380.0, 380.0, 0, 0, GROUP_SET_LA, 0.01, "线路断线低电压"}, #ifdef FUNC_DRIVE {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_BTDCD, 0, "传动开关定值"}, {SETTYPE_F, SET_S, 0, 99.0, 10, 0, 0, GROUP_SET_BTDCD, 0.01, "延时合闸时间"}, {SETTYPE_F, SET_S, 0, 99.0, 15, 0, 0, GROUP_SET_BTDCD, 0.01, "结束传动时间"}, {SETTYPE_F, SET_S, 0, 99.0, 0, 0, 0, GROUP_SET_BTDCD, 0.01, "延时分闸时间"}, {SETTYPE_F, SET_S, 0, 99.0, 0.3, 0, 0, GROUP_SET_BTDCD, 0.01, "合闸结束传动时间"}, #endif #ifdef FUNC_DRIVE_JY {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_DRIVE, 0, "传动功能"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_DRIVE, 1, "开关传动投入"}, {SETTYPE_F, SET_U, 0, 220.0, 0.0, 0, 0, GROUP_SET_DRIVE, 0.01, "传动模拟电源侧电压"}, {SETTYPE_F, SET_U, 0, 220.0, 0.0, 0, 0, GROUP_SET_DRIVE, 0.01, "传动模拟负荷侧电压"}, {SETTYPE_F, SET_U, 0, 220.0, 25.0, 0, 0, GROUP_SET_DRIVE, 0.01, "传动模拟零序电压"}, {SETTYPE_F, SET_A, 0, 100.0, 10.0, 0, 0, GROUP_SET_DRIVE, 0.01, "传动模拟电流"}, {SETTYPE_F, SET_A, 0, 100.0, 10.0, 0, 0, GROUP_SET_DRIVE, 0.01, "传动模拟零流"}, {SETTYPE_F, SET_S, 0, 100.0, 6.0, 0, 0, GROUP_SET_DRIVE, 0.01, "传动电源侧电压时间"}, {SETTYPE_F, SET_S, 0, 100.0, 6.0, 0, 0, GROUP_SET_DRIVE, 0.01, "传动负荷侧电压时间"}, {SETTYPE_F, SET_S, 0, 100.0, 1.0, 0, 0, GROUP_SET_DRIVE, 0.01, "传动零压时间"}, {SETTYPE_F, SET_S, 0, 100.0, 0.2, 0, 0, GROUP_SET_DRIVE, 0.01, "传动过流时间"}, {SETTYPE_F, SET_S, 0, 100.0, 0.2, 0, 0, GROUP_SET_DRIVE, 0.01, "传动零流时间"}, {SETTYPE_F, SET_S, 0, 100.0, 10.0, 0, 0, GROUP_SET_DRIVE, 0.01, "再次传动时间"}, #endif {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_FSX, 0, "反时限保护"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_FSX, 1, "反时限投退"}, {SETTYPE_F, SET_A, 0.3, 10.0, 5.0, 0, 0, GROUP_SET_FSX, 0.01, "反时限基准值"}, {SETTYPE_F, SET_S, 0.005, 120.0, 120.0, 0, 0, GROUP_SET_FSX, 0.01, "反时限时间"}, {SETTYPE_LIST, SET_NULL, 0, FSXListNum - 1, 0, FSXList, FSXListNum, GROUP_SET_FSX, 1, "反时限曲线"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_DLYX, 0, "电流越限"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_DLYX, 1, "电流重载投入"}, {SETTYPE_F, SET_A, 0, 100.0, 100.0, 0, 0, GROUP_SET_DLYX, 0.01, "电流重载定值"}, {SETTYPE_F, SET_S, 0, 99.0, 99, 0, 0, GROUP_SET_DLYX, 0.01, "电流重载时间"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_DLYX, 1, "电流过载投入"}, {SETTYPE_F, SET_A, 0, 100.0, 100.0, 0, 0, GROUP_SET_DLYX, 0.01, "电流过载定值"}, {SETTYPE_F, SET_S, 0, 99.0, 99, 0, 0, GROUP_SET_DLYX, 0.01, "电流过载时间"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_DLYX, 1, "负荷越上限投入"}, {SETTYPE_F, SET_A, 0, 10.0, 5.0, 0, 0, GROUP_SET_DLYX, 0.01, "负荷越上限定值"}, {SETTYPE_F, SET_S, 0, 99.0, 99, 0, 0, GROUP_SET_DLYX, 0.01, "负荷越上限时间"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_DLYX, 1, "零序电流越限投退"}, {SETTYPE_F, SET_A, 0.1, 10.0, 5.0, 0, 0, GROUP_SET_DLYX, 0.01, "零序电流越限定值"}, {SETTYPE_F, SET_S, 0, 99.0, 99, 0, 0, GROUP_SET_DLYX, 0.01, "零序电流越限时间"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_RECORD, 0, "录波"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_RECORD, 1, "过流故障启动"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_RECORD, 1, "零序过流启动"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_RECORD, 1, "零序电压启动"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_RECORD, 1, "线路失压启动"}, {SETTYPE_LIST, SET_NULL, 0 , TTListNum - 1, 0 , TTList, TTListNum, GROUP_SET_RECORD, 1, "零压突变启动"}, {SETTYPE_F, SET_U, 0.01, 220.0, 6.5 , 0, 0, GROUP_SET_RECORD, 0.01, "零压突变定值"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_RECORD, 1, "零流突变启动"}, {SETTYPE_F, SET_A, 0.01, 100.0, 5.0 , 0, 0, GROUP_SET_RECORD, 0.01, "零流突变定值"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_RECORD, 1, "重合闸启动"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_RECORD, 1, "残压启动"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_RECORD, 1, "FA动作"}, #if defined FUN_JDXX || defined XDL_ZT {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_RECORD, 1, "小电流接地启动"}, #endif {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_SWSET, 0, "辅助定值"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_SWSET, 1, "功率取反投退"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_SWSET, 1, "保护方向取反投退"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_SWSET, 1, "未储能告警"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_SWSET, 1, "控制回路检查"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_SWSET, 1, "气压低闭锁分合闸"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_SWSET, 1, "PT1断线检查投退"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_SWSET, 1, "PT2断线检查投退"}, #ifdef CUSTOMIZE_BZT // 备自投 {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_SET_BZT, 0, "备自投"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_SET_BZT, 1, "备自投投退 "}, {SETTYPE_LIST, SET_NULL, 0, BZTFSListNum - 1, 0, BZTFSList, BZTFSListNum, GROUP_SET_BZT, 1, "备自投方式 "}, {SETTYPE_F, SET_S, 0.01, 15.0, 10.0, 0, 0, GROUP_SET_BZT, 0.01, "备自投跳闸时间"}, {SETTYPE_F, SET_S, 0.01, 15.0, 10.0, 0, 0, GROUP_SET_BZT, 0.01, "备自投合闸时间"}, {SETTYPE_F, SET_S, 1.0, 20.0, 5.0, 0, 0, GROUP_SET_BZT, 0.01, "备自投充电时间"}, {SETTYPE_F, SET_U, 0, 440.0, 100, 0, 0, GROUP_SET_BZT, 0.01, "备自投有压定值"}, {SETTYPE_F, SET_U, 0, 440.0, 40, 0, 0, GROUP_SET_BZT, 0.01, "备自投失压定值"}, {SETTYPE_F, SET_A, 0, 5.0, 0.1, 0, 0, GROUP_SET_BZT, 0.01, "备自投无流定值"}, {SETTYPE_LIST, SET_NULL, 0, TVolSelListNum - 1, 0, TVolSelList, TVolSelListNum, GROUP_SET_BZT, 1, "备自投母线电压1"}, {SETTYPE_LIST, SET_NULL, 0, TVolSelListNum - 1, 3, TVolSelList, TVolSelListNum, GROUP_SET_BZT, 1, "备自投母线电压2"}, {SETTYPE_LIST, SET_NULL, 0, TVolSelListNum - 1, 0, TVolSelList, TVolSelListNum, GROUP_SET_BZT, 1, "备自投1#进线电压"}, {SETTYPE_LIST, SET_NULL, 0, TVolSelListNum - 1, 3, TVolSelList, TVolSelListNum, GROUP_SET_BZT, 1, "备自投2#进线电压"}, {SETTYPE_LIST, SET_NULL, 0, TISelListNum - 1, 0, TISelList, TISelListNum, GROUP_SET_BZT, 1, "备自投1#进线电流"}, {SETTYPE_LIST, SET_NULL, 0, TISelListNum - 1, 0, TISelList, TISelListNum, GROUP_SET_BZT, 1, "备自投2#进线电流"}, #endif }; const int SW_SET_NUMBER = sizeof(tSwSetTable) / sizeof(tSwSetTable[0]); // 定值数目 const int SET_NUMBER = ((sizeof(tSwSetTable) / sizeof(tSwSetTable[0])) * SWITCH_NUM_MAX + sizeof(tPubSetTable) / sizeof(tPubSetTable[0])); // 内部定值 const TSETTABLE tCstSetTable[] = { /* 类型 单位 最小值 最大值 默认值 列表 列表数 组 步长 描述 */ {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_CSTSET_PROTECT, 0, "保护功能"}, #ifdef XDL_ZT {SETTYPE_F, SET_U, 0, 220.0, 220.0, 0, 0, GROUP_CSTSET_PROTECT, 0.01, "小电流零压1定值"}, {SETTYPE_F, SET_S, 0, 99.0, 0.04, 0, 0, GROUP_CSTSET_PROTECT, 0.01, "小电流零压1时间"}, {SETTYPE_F, SET_U, 0, 220.0, 220.0, 0, 0, GROUP_CSTSET_PROTECT, 0.01, "小电流零压2定值"}, {SETTYPE_F, SET_S, 0, 99.0, 0.04, 0, 0, GROUP_CSTSET_PROTECT, 0.01, "小电流零压2时间"}, #endif {SETTYPE_F, SET_NULL, 0, 65536.0, 1.2, 0, 0, GROUP_CSTSET_PROTECT, 0.01, "幅值加速滤波系数"}, {SETTYPE_F, SET_A, 0.01, 25.0, 2.0, 0, 0, GROUP_CSTSET_PROTECT, 0.01, "突变量定值"}, {SETTYPE_F, SET_A, 0, 5.0, 0.1, 0, 0, GROUP_CSTSET_PROTECT, 0.01, "无流定值"}, {SETTYPE_F, SET_S, 0.2, 60.0, 5.0, 0, 0, GROUP_CSTSET_PROTECT, 0.01, "整组复归时间"}, {SETTYPE_F, SET_S, 0.01, 10.0, 0.15, 0, 0, GROUP_CSTSET_PROTECT, 0.01, "跳闸失败时间"}, {SETTYPE_F, SET_S, 0.01, 10.0, 2.0, 0, 0, GROUP_CSTSET_PROTECT, 0.01, "合闸失败时间"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_PROTECT, 1, "零压闭锁零流"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_PROTECT, 1, "低压闭锁过流"}, {SETTYPE_F, SET_U, 1.0, 100.0, 100.0, 0, 0, GROUP_CSTSET_PROTECT, 0.01, "零压闭锁定值"}, {SETTYPE_F, SET_U, 10.0, 220.0, 80.0, 0, 0, GROUP_CSTSET_PROTECT, 0.01, "低压闭锁定值"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_PROTECT, 1, "低频滑差闭锁投退"}, {SETTYPE_F, SET_HZ_S, 0.3, 10.0, 0.3, 0, 0, GROUP_CSTSET_PROTECT, 0.01, "低频减载滑差"}, #ifdef PRO_AL_LOCK_HZ {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_PROTECT, 1, "解列闭锁重合闸"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_PROTECT, 1, "解列后启动重合闸判频率"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_PROTECT, 1, "解列后启动重合闸判电压"}, #endif {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_CSTSET_CALC, 0, "计算功能"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_CALC, 1, "频率跟踪投退"}, {SETTYPE_UINT, SET_NULL, 1, 15, 13, 0, 0, GROUP_CSTSET_CALC, 1, "谐波计算次数"}, {SETTYPE_F, SET_NULL, 0, 1.0, 0.01, 0, 0, GROUP_CSTSET_CALC, 0.01, "谐波校正系数"}, {SETTYPE_5INT, SET_NULL, -100.0, 100.0, 0.0, 0, 0, GROUP_CSTSET_CALC, 1, "交流温漂(ppm)"}, {SETTYPE_5INT, SET_NULL, -10000.0, 10000.0, 0.0, 0, 0, GROUP_CSTSET_CALC, 1, "直流温漂(ppm)"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 1, TTList, TTListNum, GROUP_CSTSET_CALC, 1, "归零值投退"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_CALC, 1, "零序电压自产"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_CSTSET_COMM, 0, "通讯功能"}, {SETTYPE_5INT, SET_S, 0, 3600, 20, 0, 0, GROUP_CSTSET_COMM, 1, "101子站重发"}, {SETTYPE_5INT, SET_S, 0, 3600, 600, 0, 0, GROUP_CSTSET_COMM, 1, "101通道时间"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_COMM, 1, "101初始化原因03"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_COMM, 1, "104序号检查"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_COMM, 1, "101FCB检查"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_COMM, 1, "点号连续上送"}, {SETTYPE_LIST, SET_NULL, 0, JMListNum - 1, 0, JMList, JMListNum, GROUP_CSTSET_COMM, 1, "加密功能"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_COMM, 1, "远动测试模式"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_COMM, 1, "SOE通讯续传"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_COMM, 1, "SOE上电续传"}, #ifdef FIX_PARAM_FORMAT {SETTYPE_LIST, SET_NULL, 0, TULF8ListNum - 1, 1, TULF8List, TULF8ListNum, GROUP_CSTSET_COMM, 1, "固定参数上送格式"}, #endif {SETTYPE_LIST, SET_NULL, 0, EQUListNum - 1, 0, EQUList, EQUListNum, GROUP_CSTSET_COMM, 1, "装置类型"}, {SETTYPE_F, SET_NULL, 0, 1.0, 0.01, 0, 0, GROUP_CSTSET_COMM, 0.01, "遥测滤波系数"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_CSTSET_FA, 0, "馈线自动化"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_FA, 1, "瞬压板投退"}, {SETTYPE_F, SET_S, 0, 100.0, 15, 0, 0, GROUP_CSTSET_FA, 0.01, "DFA充电时间"}, {SETTYPE_F, SET_S, 1.0, 100.0, 60, 0, 0, GROUP_CSTSET_FA, 0.01, "DFA隔离放电时间"}, {SETTYPE_F, SET_S, 1.0, 100.0, 15, 0, 0, GROUP_CSTSET_FA, 0.01, "DFA恢复放电时间"}, {SETTYPE_F, SET_S, 1.0, 100.0, 15, 0, 0, GROUP_CSTSET_FA, 0.01, "DFA禁止转发时间 "}, {SETTYPE_F, SET_S, 0.1, 100.0, 0.3, 0, 0, GROUP_CSTSET_FA, 0.01, "DFA发送展宽时间"}, {SETTYPE_F, SET_S, 0.01, 0.1, 0.040, 0, 0, GROUP_CSTSET_FA, 0.01, "goose判断时间"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_FA, 1, "负荷开关goose发布"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_FA, 1, "goose发布在故障确认后"}, {SETTYPE_F, SET_S, 0.00, 10.0, 6.0, 0, 0, GROUP_CSTSET_FA, 0.01, "单侧来电解锁时间"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_FA, 1, "FA闭锁合闸禁止遥合"}, #ifdef FA_PL_PJ {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_FA, 1, "有压判频率"}, #endif {SETTYPE_LIST, SET_NULL, 0, UYY_ListNum - 1, 0, UYY_List, UYY_ListNum, GROUP_CSTSET_FA, 1, "有压判据"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_CSTSET_RECORD, 0, "录波功能"}, {SETTYPE_LIST, SET_NULL, 0, WFListNum - 1, 1, WFList, WFListNum, GROUP_CSTSET_RECORD, 1, "文件格式"}, {SETTYPE_LIST, SET_NULL, 0, LB_VOL_ListNum - 1, 0, LB_VOL_List,LB_VOL_ListNum, GROUP_CSTSET_RECORD, 1, "电压选择"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_RECORD, 1, "虚拟遥信记录"}, {SETTYPE_LIST, SET_NULL, 0, RCL_ListNum - 1, 0, RCL_List, RCL_ListNum, GROUP_CSTSET_RECORD, 1, "遥信描述类型"}, {SETTYPE_UINT, SET_NULL, 1, 32, 1, 0, 0, GROUP_CSTSET_RECORD, 1, "本开关间隔号"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_CSTSET_OTHERS, 0, "辅助定值"}, {SETTYPE_UINT, SET_S, 1, 30, 20, 0, 0, GROUP_CSTSET_OTHERS, 1, "未储能告警时间"}, {SETTYPE_UINT, SET_S, 0, 65535, 0, 0, 0, GROUP_CSTSET_OTHERS, 1, "失电闭锁遥信时间"}, {SETTYPE_F, SET_HOUR, 0, 100.0, 0.5, 0, 0, GROUP_CSTSET_OTHERS, 0.01, "电池充满维持时间"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 1, TTList, TTListNum, GROUP_CSTSET_OTHERS, 1, "记录文件投退"}, {SETTYPE_LIST, SET_NULL, 0, HisFileFormatListNum - 1, 0,HisFileFormatList, HisFileFormatListNum, GROUP_CSTSET_OTHERS, 1, "记录文件格式"}, {SETTYPE_LIST, SET_NULL, 0, TFGKEY_TYPE_TOTAL - 1, 1, TFGKEY_Type, TFGKEY_TYPE_TOTAL, GROUP_CSTSET_OTHERS, 1, "复归按键复用功能选择"}, {SETTYPE_UINT, SET_S, 0, 60, 3, 0, 0, GROUP_CSTSET_OTHERS, 1, "复归按键复用功能防抖时间"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_OTHERS, 1, "远动参数有效"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_OTHERS, 1, "现场运行模式"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_OTHERS, 1, "101文件传输确认帧"}, {SETTYPE_UINT, SET_NULL, 0, 2000, 0, 0, 0, GROUP_CSTSET_OTHERS, 1, "测量差值"}, {SETTYPE_F, SET_U, 0, 150, 48, 0, 0, GROUP_CSTSET_OTHERS, 0.01, "直流电压定值"}, {SETTYPE_UINT, SET_NULL, 1, 2, 1, 0, 0, GROUP_CSTSET_OTHERS, 1, "直流通道数"}, {SETTYPE_LIST, SET_NULL, 0, TPT_UNum - 1, 0, PUList, TPT_UNum, GROUP_CSTSET_OTHERS, 1, "负荷侧电压选择"}, {SETTYPE_LIST, SET_NULL, 0, DISPMODEListNum - 1,0, DISPMODEList, DISPMODEListNum, GROUP_CSTSET_OTHERS, 1, "液晶遥测数据显示"}, {SETTYPE_LIST, SET_NULL, 0, AddrNumListNum - 1, 0, AddrNumList, AddrNumListNum, GROUP_CSTSET_OTHERS, 1, "故障事件遥信地址长度"}, #ifdef YC_QUANTITY {SETTYPE_UINT, SET_NULL, 1, 999, 50, 0, 0, GROUP_CSTSET_OTHERS, 1, "每间隔遥参数量"}, #endif #ifdef METERING_ENERGY {SETTYPE_LIST, SET_NULL, 0, DDListNum - 1, DDListNum - 1, DDList, DDListNum, GROUP_CSTSET_OTHERS, 1, "电度计算方式"}, {SETTYPE_LIST, SET_NULL, 0, JLFSListNum - 1, 0, JLFSList, JLFSListNum, GROUP_CSTSET_OTHERS, 1, "计量接线方式"}, {SETTYPE_LIST, SET_NULL, 0, WGFSListNum - 1, 0, WGFSList, WGFSListNum, GROUP_CSTSET_OTHERS, 1, "无功电能算法"}, #endif {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_OTHERS, 1, "SOE遥测系数投退"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_CSTSET_OTHERS, 1, "遥测总死区有效投退"}, }; const int CSTSET_NUMBER = (sizeof(tCstSetTable) / sizeof(tCstSetTable[0])); /********************************************************************** 装置参数 ***********************************************************************/ const TSETTABLE tEquipParaTable[] = // min max default { /* 类型 单位 最小值 最大值 默认值 列表 列表数 组 步长 描述 */ {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_PARA_PROTOCAL, 0, "规约参数"}, {SETTYPE_5INT, SET_NULL, 1, 65535, 1, 0, 0, GROUP_PARA_PROTOCAL, 1, "装置地址"}, {SETTYPE_LIST, SET_NULL, 0, PTTypeListNum - 1, 0, PTTypeList, PTTypeListNum, GROUP_PARA_PROTOCAL, 1, "遥信报文类型"}, {SETTYPE_LIST, SET_NULL, 0, PTTypeListNum - 1, 2, PTTypeList, PTTypeListNum, GROUP_PARA_PROTOCAL, 1, "遥控报文类型"}, {SETTYPE_LIST, SET_NULL, 0, YCTypeListNum - 1, 2, YCTypeList, YCTypeListNum, GROUP_PARA_PROTOCAL, 1, "遥测报文类型"}, {SETTYPE_F, SET_S, 0, 3600, 0.4, 0, 0, GROUP_PARA_PROTOCAL, 0.01, "遥测发送间隔"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 1, TTList, TTListNum, GROUP_PARA_PROTOCAL, 1, "遥测自动上送"}, {SETTYPE_LIST, SET_NULL, 0, YCTypeDeadNum - 1, 0, YCTypeDead, YCTypeDeadNum, GROUP_PARA_PROTOCAL, 1, "遥测上传死区类型"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 1, TTList, TTListNum, GROUP_PARA_PROTOCAL, 1, "COS自动上送"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_PARA_PROTOCAL, 1, "事件参数上送"}, {SETTYPE_5INT, SET_S, 10, 3600, 300, 0, 0, GROUP_PARA_PROTOCAL, 1, "遥控超时时间"}, {SETTYPE_LIST, SET_NULL, 0, IEC101AddrListNum - 1, 1, IEC101AddrList, IEC101AddrListNum, GROUP_PARA_PROTOCAL, 1, "101链路地址"}, {SETTYPE_LIST, SET_NULL, 0, IEC101AddrListNum - 1, 1, IEC101AddrList, IEC101AddrListNum, GROUP_PARA_PROTOCAL, 1, "101应用地址"}, {SETTYPE_LIST, SET_NULL, 0, IEC101AddrListNum - 1, 1, IEC101AddrList, IEC101AddrListNum, GROUP_PARA_PROTOCAL, 1, "101传送原因"}, {SETTYPE_LIST, SET_NULL, 0, T104ServerListNum - 1, 0, T104ServerList, T104ServerListNum, GROUP_PARA_PROTOCAL, 1, "104规约模式"}, {SETTYPE_5INT, SET_NULL, 0, 65535, 2404, 0, 0, GROUP_PARA_PROTOCAL, 1, "104规约端口"}, {SETTYPE_5INT, SET_S, 1, 65535, 30, 0, 0, GROUP_PARA_PROTOCAL, 1, "104确认超时"}, {SETTYPE_5INT, SET_S, 1, 65535, 30, 0, 0, GROUP_PARA_PROTOCAL, 1, "104测试超时"}, {SETTYPE_5INT, SET_NULL, 0, 48, 12, 0, 0, GROUP_PARA_PROTOCAL, 1, "104 K值"}, {SETTYPE_5INT, SET_NULL, 0, 48, 8, 0, 0, GROUP_PARA_PROTOCAL, 1, "104 W值"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_PROTOCAL, 1, "104主站1 IP"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_PROTOCAL, 1, "104主站2 IP"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_PROTOCAL, 1, "104主站3 IP"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_PROTOCAL, 1, "104主站4 IP"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_PARA_LINK, 0, "104子站通信"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_LINK, 1, "104子站1 IP"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_LINK, 1, "104子站2 IP"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_LINK, 1, "104子站3 IP"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_LINK, 1, "104子站4 IP"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_LINK, 1, "104子站5 IP"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_LINK, 1, "104子站6 IP"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_LINK, 1, "104子站7 IP"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_LINK, 1, "104子站8 IP"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_PARA_SERIAL, 0, "串行口通道"}, {SETTYPE_LIST, SET_NULL, 0, ProtocolListNum - 1,0, ProtocolList, ProtocolListNum, GROUP_PARA_SERIAL, 1, "485口1规约"}, {SETTYPE_LIST, SET_NULL, 0, BaudListNum - 1, 4, BaudList, BaudListNum, GROUP_PARA_SERIAL, 1, "485口1波特率"}, {SETTYPE_LIST, SET_NULL, 0, ParityListNum - 1, 2, ParityList, ParityListNum, GROUP_PARA_SERIAL, 1, "485口1校验"}, {SETTYPE_LIST, SET_NULL, 0, ProtocolListNum - 1,0, ProtocolList, ProtocolListNum, GROUP_PARA_SERIAL, 1, "485口2规约"}, {SETTYPE_LIST, SET_NULL, 0, BaudListNum - 1, 4, BaudList, BaudListNum, GROUP_PARA_SERIAL, 1, "485口2波特率"}, {SETTYPE_LIST, SET_NULL, 0, ParityListNum - 1, 2, ParityList, ParityListNum, GROUP_PARA_SERIAL, 1, "485口2校验"}, {SETTYPE_LIST, SET_NULL, 0, ProtocolListNum - 1,0, ProtocolList, ProtocolListNum, GROUP_PARA_SERIAL, 1, "232口1规约"}, {SETTYPE_LIST, SET_NULL, 0, BaudListNum - 1, 4, BaudList, BaudListNum, GROUP_PARA_SERIAL, 1, "232口1波特率"}, {SETTYPE_LIST, SET_NULL, 0, ParityListNum - 1, 2, ParityList, ParityListNum, GROUP_PARA_SERIAL, 1, "232口1校验方式"}, {SETTYPE_LIST, SET_NULL, 0, ProtocolListNum - 1,0, ProtocolList, ProtocolListNum, GROUP_PARA_SERIAL, 1, "232口2规约"}, {SETTYPE_LIST, SET_NULL, 0, BaudListNum - 1, 4, BaudList, BaudListNum, GROUP_PARA_SERIAL, 1, "232口2波特率"}, {SETTYPE_LIST, SET_NULL, 0, ParityListNum - 1, 2, ParityList, ParityListNum, GROUP_PARA_SERIAL, 1, "232口2校验方式"}, {SETTYPE_LIST, SET_NULL, 0, ProtocolListNum - 1,7, ProtocolList, ProtocolListNum, GROUP_PARA_SERIAL, 1, "GPS串口5规约"}, {SETTYPE_LIST, SET_NULL, 0, BaudListNum - 1, 4, BaudList, BaudListNum, GROUP_PARA_SERIAL, 1, "GPS串口5波特率"}, {SETTYPE_LIST, SET_NULL, 0, ParityListNum - 1, 2, ParityList, ParityListNum, GROUP_PARA_SERIAL, 1, "GPS串口5校验"}, {SETTYPE_LIST, SET_NULL, 0, ProtocolListNum - 1,0, ProtocolList, ProtocolListNum, GROUP_PARA_SERIAL, 1, "备用串口6规约"}, {SETTYPE_LIST, SET_NULL, 0, BaudListNum - 1, 4, BaudList, BaudListNum, GROUP_PARA_SERIAL, 1, "备用串口6波特率"}, {SETTYPE_LIST, SET_NULL, 0, ParityListNum - 1, 2, ParityList, ParityListNum, GROUP_PARA_SERIAL, 1, "备用串口6校验方式"}, {SETTYPE_LIST, SET_NULL, 0, ProtocolListNum - 1,0, ProtocolList, ProtocolListNum, GROUP_PARA_SERIAL, 1, "备用串口7规约"}, {SETTYPE_LIST, SET_NULL, 0, BaudListNum - 1, 4, BaudList, BaudListNum, GROUP_PARA_SERIAL, 1, "备用串口7波特率"}, {SETTYPE_LIST, SET_NULL, 0, ParityListNum - 1, 2, ParityList, ParityListNum, GROUP_PARA_SERIAL, 1, "备用串口7校验"}, #ifdef FUN_FUXI_ESAM {SETTYPE_LIST, SET_NULL, 0, ProtocolListNum - 1,2, ProtocolList, ProtocolListNum, GROUP_PARA_SERIAL, 1, "南网加密规约"}, {SETTYPE_LIST, SET_NULL, 0, BaudListNum - 1, 7, BaudList, BaudListNum, GROUP_PARA_SERIAL, 1, "南网加密波特率"}, {SETTYPE_LIST, SET_NULL, 0, ParityListNum - 1, 0, ParityList, ParityListNum, GROUP_PARA_SERIAL, 1, "南网加密校验"}, #endif {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_PARA_ETHERNET, 0, "以太网通道"}, {SETTYPE_LIST, SET_NULL, 0, Net_Eth_ListNum - 1,0, Net_Eth_List, Net_Eth_ListNum, GROUP_PARA_ETHERNET, 1, "1#_网络"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0xc0a80164, 0, GROUP_PARA_ETHERNET, 1, "1#IP地址"}, // IP 192.168.1.100 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0xffffff00, 0, GROUP_PARA_ETHERNET, 1, "1#子网掩码"}, // 255.255.255.0 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_ETHERNET, 1, "1#目标网络"}, // 192.168.64.240 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_ETHERNET, 1, "1#目标掩码"}, // 0.0.0.0 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_ETHERNET, 1, "1#网关"}, // 192.168.64.240 {SETTYPE_LIST, SET_NULL, 0, Net_Eth_ListNum - 1,1, Net_Eth_List, Net_Eth_ListNum, GROUP_PARA_ETHERNET, 1, "2#_网络"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0xc0a80264, 0, GROUP_PARA_ETHERNET, 1, "2#IP地址"}, // IP 192.168.2.100 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0xffffff00, 0, GROUP_PARA_ETHERNET, 1, "2#子网掩码"}, // 255.255.255.0 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_ETHERNET, 1, "2#目标网络"}, // IP 192.168.2.100 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_ETHERNET, 1, "2#目标掩码"}, // 0.0.0.0 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_ETHERNET, 1, "2#网关"}, // 192.168.2.100 {SETTYPE_LIST, SET_NULL, 0, Net_Eth_ListNum - 1,2, Net_Eth_List, Net_Eth_ListNum, GROUP_PARA_ETHERNET, 1, "3#_网络"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0xc0a80364, 0, GROUP_PARA_ETHERNET, 1, "3#IP地址"}, // IP 192.168.3.100 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0xffffff00, 0, GROUP_PARA_ETHERNET, 1, "3#子网掩码"}, // 255.255.255.0 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_ETHERNET, 1, "3#目标网络"}, // IP 192.168.3.100 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_ETHERNET, 1, "3#目标掩码"}, // 0.0.0.0 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_ETHERNET, 1, "3#网关"}, // 192.168.3.100 {SETTYPE_LIST, SET_NULL, 0, Net_Eth_ListNum - 1,2, Net_Eth_List, Net_Eth_ListNum, GROUP_PARA_ETHERNET, 1, "4#_网络"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0xc0a840f0, 0, GROUP_PARA_ETHERNET, 1, "4#IP地址"}, // IP 192.168.4.100 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0xffffff00, 0, GROUP_PARA_ETHERNET, 1, "4#子网掩码"}, // 255.255.255.0 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_ETHERNET, 1, "4#目标网络"}, // 192.168.3.100 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_ETHERNET, 1, "4#目标掩码"}, // 0.0.0.0 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_ETHERNET, 1, "4#网关"}, // 192.168.3.254 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0xc0a840fe, 0, GROUP_PARA_ETHERNET, 1, "默认网关"}, // 192.168.64.254 {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_PARA_TIME, 0, "对时"}, {SETTYPE_LIST, SET_NULL, 0, TimeListNum - 1, 0, TimeList, TimeListNum, GROUP_PARA_TIME, 1, "对时方式"}, {SETTYPE_LIST, SET_NULL, 0, TimeListSelectNum - 1, 0, TimeListSelect, TimeListSelectNum, GROUP_PARA_TIME, 1, "标准化对时方式"}, {SETTYPE_4INT, SET_S, 1, 300, 1, 0, 0, GROUP_PARA_TIME, 1, "卫星对时间隔"}, {SETTYPE_4INT, SET_MIN, 1, 6000, 60, 0, 0, GROUP_PARA_TIME, 1, "对时切换时长"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_TIME, 1, "SNTP服务器IP"}, {SETTYPE_5INT, SET_S, 10, 1024, 64, 0, 0, GROUP_PARA_TIME, 1, "SNTP对时间隔"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_PARA_BATTERY, 0, "电池管理"}, {SETTYPE_YMD, SET_NULL, 0, 0xffffffff, 0, 0, 0, GROUP_PARA_BATTERY, 1, "活化启动时间"}, {SETTYPE_UINT, SET_HOUR, 0, 23, 0, 0, 0, GROUP_PARA_BATTERY, 1, "电池活化时刻"}, {SETTYPE_UINT, SET_D, 0, 360, 0, 0, 0, GROUP_PARA_BATTERY, 1, "电池活化周期"}, {SETTYPE_F, SET_HOUR, 1.0, 100.0, 6.0, 0, 0, GROUP_PARA_BATTERY, 0.01, "电池告警阀值"}, {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_PARA_RMT, 0, "远动参数"}, #ifdef PARAM_DEAD_PER {SETTYPE_F, SET_PER, 0.0, 100.0, 1.0, 0, 0, GROUP_PARA_RMT, 0.01, "遥测死区"}, #else {SETTYPE_F, SET_NULL, 0, 0.3, 0.01, 0, 0, GROUP_PARA_RMT, 0.01, "遥测死区"}, #endif #ifndef PARAM_DEAD_PER {SETTYPE_F, SET_PER, 0.0, 0.3, 0.01, 0, 0, GROUP_PARA_RMT, 0.01, "电流死区"}, {SETTYPE_F, SET_PER, 0.0, 0.3, 0.01, 0, 0, GROUP_PARA_RMT, 0.01, "交流电压死区"}, {SETTYPE_F, SET_PER, 0.0, 0.3, 0.01, 0, 0, GROUP_PARA_RMT, 0.01, "直流电压死区"}, {SETTYPE_F, SET_PER, 0.0, 0.3, 0.01, 0, 0, GROUP_PARA_RMT, 0.01, "功率死区"}, {SETTYPE_F, SET_PER, 0.0, 0.3, 0.05, 0, 0, GROUP_PARA_RMT, 0.01, "频率死区"}, {SETTYPE_F, SET_PER, 0.0, 0.3, 0.01, 0, 0, GROUP_PARA_RMT, 0.01, "功率因数死区"}, #else {SETTYPE_F, SET_PER, 0.0, 100.0, 1.0, 0, 0, GROUP_PARA_RMT, 0.01, "电流死区"}, {SETTYPE_F, SET_PER, 0.0, 100.0, 1.0, 0, 0, GROUP_PARA_RMT, 0.01, "交流电压死区"}, {SETTYPE_F, SET_PER, 0.0, 100.0, 1.0, 0, 0, GROUP_PARA_RMT, 0.01, "直流电压死区"}, {SETTYPE_F, SET_PER, 0.0, 100.0, 1.0, 0, 0, GROUP_PARA_RMT, 0.01, "功率死区"}, {SETTYPE_F, SET_PER, 0.0, 100.0, 1.0, 0, 0, GROUP_PARA_RMT, 0.01, "频率死区"}, {SETTYPE_F, SET_PER, 0.0, 100.0, 1.0, 0, 0, GROUP_PARA_RMT, 0.01, "功率因数死区"}, #endif {SETTYPE_LINT, SET_MS, 0.0, 60000.0, 20.0, 0, 0, GROUP_PARA_RMT, 1, "遥信防抖时间"}, {SETTYPE_LINT, SET_MS, 0.0, 60000.0, 200.0, 0, 0, GROUP_PARA_RMT, 1, "分闸脉冲"}, {SETTYPE_LINT, SET_MS, 0.0, 60000.0, 200.0, 0, 0, GROUP_PARA_RMT, 1, "合闸脉冲"}, {SETTYPE_F, SET_U, 0, 20.0, 5, 0, 0, GROUP_PARA_RMT, 0.01, "电压零漂"}, {SETTYPE_F, SET_A, 0, 1.0, 0.25, 0, 0, GROUP_PARA_RMT, 0.01, "相电流零漂"}, {SETTYPE_F, SET_A, 0, 1.0, 0.04, 0, 0, GROUP_PARA_RMT, 0.01, "零序电流零漂"}, #ifdef CPU_FUXI {SETTYPE_F, SET_U, 0, 20.0, 1, 0, 0, GROUP_PARA_RMT, 0.01, "直流电压零漂"}, #endif {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_PARA_OTHERS, 0, "其它"}, {SETTYPE_LINT, SET_MS, 0.0, 60000.0, 200.0, 0, 0, GROUP_PARA_OTHERS, 1, "合分闸脉冲"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_PARA_OTHERS, 1, "自动复归投退"}, {SETTYPE_5INT, SET_MIN, 0, 3000, 480, 0, 0, GROUP_PARA_OTHERS, 1, "自动复归时间"}, #ifdef YX_RESET_TIME {SETTYPE_F, SET_S, 0, 6000, 3, 0, 0, GROUP_PARA_OTHERS, 0.01, "故障遥信保持时间"}, #endif {SETTYPE_5INT, SET_S, 0, 65535, 180, 0, 0, GROUP_PARA_OTHERS, 1, "液晶背光时间"}, {SETTYPE_LIST, SET_NULL, 0, LinkListNum - 1, 1, LinkList, LinkListNum, GROUP_PARA_OTHERS, 1, "级联状态监测"}, #if (defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020) {SETTYPE_UINT, SET_NULL, 1, 32, 1, 0, 0, GROUP_PARA_OTHERS, 1, "GOOSE通信ID"}, {SETTYPE_F, SET_S, 0, 100.0, 6.0, 0, 0, GROUP_PARA_OTHERS, 0.01, "GOOSE通信T1"}, {SETTYPE_F, SET_S, 0, 100.0, 3.0, 0, 0, GROUP_PARA_OTHERS, 0.01, "GOOSE通信T2"}, #endif #ifdef RCD_STRAN_M_EN {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_PARA_OTHERS, 1, "级联录波主站使能"}, #endif #ifdef YPARA_LINK_S_EN {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_PARA_OTHERS, 1, "子站参数变化通知"}, #endif #ifdef FUN_FUXI_ESAM {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_PARA_S1, 0, "南网加密配置(重新配置需重启)"}, {SETTYPE_LIST, SET_NULL, 0, T104ServerListNum - 1, 0, T104ServerList, T104ServerListNum, GROUP_PARA_S1, 1, "加密工作模式"}, {SETTYPE_5INT, SET_NULL, 0, 65535, 2404, 0, 0, GROUP_PARA_S1, 1, "加密监听端口"}, {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0x00000000, 0, GROUP_PARA_S1, 1, "NAT"}, // 192.168.1.100 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0xc0a80296, 0, GROUP_PARA_S1, 1, "加密IP地址"}, // 192.168.1.100 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0xffffff00, 0, GROUP_PARA_S1, 1, "加密掩码"}, // 255.255.255.0 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0xc0a80201, 0, GROUP_PARA_S1, 1, "加密网关"}, // 192.168.1.1 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0xac100001, 0, GROUP_PARA_S1, 1, "远端IP地址"}, // 192.168.0.2 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0xffffff00, 0, GROUP_PARA_S1, 1, "远端掩码"}, // 255.255.255.0 {SETTYPE_IP, SET_NULL, 0, 0xffffffff, 0, (void *)0xac100014, 0, GROUP_PARA_S1, 1, "远端网关"}, // 192.168.0.1 #endif #ifdef METERING_ENERGY {SETTYPE_LABEL, SET_NULL, 0, 0, 0, 0, 0, GROUP_PARA_HISFILE, 0, "历史文件"}, {SETTYPE_UINT, SET_MIN, 5, 60.0, 15.0, 0, 0, GROUP_PARA_HISFILE, 1, "遥测定点间隔时间"}, {SETTYPE_LIST, SET_NULL, 0, TTListNum - 1, 0, TTList, TTListNum, GROUP_PARA_HISFILE, 1, "线损文件投退"}, {SETTYPE_UINT, SET_NULL, 1, 16.0, 1.0, 0, 0, GROUP_PARA_HISFILE, 1, "开关ID"}, {SETTYPE_UINT, SET_MIN, 5, 60.0, 15.0, 0, 0, GROUP_PARA_HISFILE, 1, "线损定点间隔时间"}, {SETTYPE_UINT, SET_D, 1, 28.0, 1.0, 0, 0, GROUP_PARA_HISFILE, 1, "考核日冻结日"}, {SETTYPE_UINT, SET_HOUR, 0, 23.0, 0, 0, 0, GROUP_PARA_HISFILE, 1, "考核日冻结小时"}, #endif }; const int EQUIP_PARA_NUMBER = sizeof(tEquipParaTable) / sizeof(tEquipParaTable[0]); // 时间设置 const TSETTABLE tTimeTable[] = { {SETTYPE_UINT, SET_NULL, 0, 99, 15, 0, 0, 0, 0, "年"}, {SETTYPE_UINT, SET_NULL, 1, 12, 1, 0, 0, 0, 0, "月"}, {SETTYPE_UINT, SET_NULL, 1, 31, 1, 0, 0, 0, 0, "日"}, {SETTYPE_UINT, SET_NULL, 0, 24, 8, 0, 0, 0, 0, "时"}, {SETTYPE_UINT, SET_NULL, 0, 59, 8, 0, 0, 0, 0, "分"}, {SETTYPE_UINT, SET_NULL, 0, 59, 8, 0, 0, 0, 0, "秒"}, }; const int TIME_SET_NUMBER = sizeof(tTimeTable) / sizeof(tTimeTable[0]); // 密码设置 const TSETTABLE tCodeTable[] = { {SETTYPE_4INT, SET_NULL, 0, 9999, 0, 0, 0, 0, 0, "用户密码"}, }; const int CODE_SET_NUMBER = sizeof(tCodeTable) / sizeof(tCodeTable[0]); // 输入密码 const TSETTABLE tPasswordTable[] = { {SETTYPE_4INT, SET_NULL, 0, 9999, 0, 0, 0, 0, 0, "输入密码"}, }; const TRMTSETTABLE tRmtsettable[]= // { // 点号 单位 定值组属性 开关定值偏移索引 系数 对应索引 #if (0) {0x5001, FLOAT_R, RMT_GRP_EQSET, 0, 1.0, PARA_CT_ONE,}, // CT额定一次值 {0x5002, FLOAT_R, RMT_GRP_EQSET, 0, 1.0, PARA_CT_TWO,}, // CT额定二次值 {0x5003, FLOAT_R, RMT_GRP_EQSET, 0, 1.0, PARA_0CT_ONE,}, // 零序CT额定一次值 {0x5004, FLOAT_R, RMT_GRP_EQSET, 0, 1.0, PARA_0CT_TWO,}, // 零序CT额定二次值 {0x5005, FLOAT_R, RMT_GRP_EQSET, 0, 1.0, PARA_PPT_ONE,}, // 电源侧PT额定一次值 {0x5006, FLOAT_R, RMT_GRP_EQSET, 0, 1.0, PARA_PPT_TWO,}, // 电源侧PT额定二次值 {0x5007, FLOAT_R, RMT_GRP_EQSET, 0, 1.0, PARA_LPT_ONE,}, // 负荷侧PT额定一次值 {0x5008, FLOAT_R, RMT_GRP_EQSET, 0, 1.0, PARA_LPT_TWO,}, // 负荷侧PT额定二次值 {0x5009, FLOAT_R, RMT_GRP_EQSET, 0, 1.0, PARA_0PPT_ONE,}, // 电源侧零序PT额定一次值 {0x500A, FLOAT_R, RMT_GRP_EQSET, 0, 1.0, PARA_0PPT_TWO,}, // 电源侧零序PT额定二次值 {0x500B, FLOAT_R, RMT_GRP_EQSET, 0, 1.0, PARA_0LPT_ONE,}, // 负荷侧零序PT额定一次值 {0x500C, FLOAT_R, RMT_GRP_EQSET, 0, 1.0, PARA_0LPT_TWO,}, // 负荷侧零序PT额定二次值 {0x500D, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_FUNSOFTPLT_GEN_TT,}, // 常规保护投入 {0x500E, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_FUNSOFTPLT_AR_TT,}, // 自动重合闸投入 {0x500F, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_FUNSOFTPLT_FA_TT,}, // 就地馈线自动化投入 {0x5010, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_FUNSOFTPLT_DFA_TT,}, // 智能分布式投入 {0x5011, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_FUNSOFTPLT_SYNC_TT,}, // 同期合闸投入 {0x5012, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_FUNSOFTPLT_STE_TT,}, // 自动解列投入 {0x5013, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_FUNSOFTPLT_XDL_TT,}, // 小电流接地保护投入 {0x5014, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_FUNSOFTPLT_LA_TT,}, // 线路断线告警投入 {0x5015, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_FUNSOFTPLT_TRASW_TT,}, // 不停电传动投入 {0x5016, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_RUNSOFTOLT_TOTALFUN_TT,}, // 自动化功能总投退软压板 {0x5017, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_RUNSOFTOLT_TOTALOUT_TT,}, // 自动化功能总出口软压板 {0x5018, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_RUNSOFTOLT_AROUT_TT,}, // 重合闸软压板 {0x5019, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_RUNSOFTOLT_REMOPT_TT,}, // 远程运维投入 {0x501A, FLOAT_R, RMT_GRP_EQSET, 0, 1.0, PARA_FIX_AREA,}, // 定值区号 {0x501B, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GL1_TT,}, // 过流Ⅰ段投入 {0x501C, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GL2_TT,}, // 过流Ⅱ段投入 {0x501D, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GL3_TT,}, // 过流Ⅲ段投入 {0x501E, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GL1_Dir_TT,}, // 过流Ⅰ段投方向 {0x501F, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GL2_Dir_TT,}, // 过流Ⅱ段投方向 {0x5020, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GL3_Dir_TT,}, // 过流Ⅲ段投方向 {0x5021, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_LA_CON_PTBREAK_TT,}, // PT断线检测投入 {0x5022, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_LX1_TT,}, // 零序过流Ⅰ段投入 {0x5023, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_LX2_TT,}, // 零序过流Ⅱ段投入 {0x5024, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GENDY_U0HV_TT,}, // 零序过电压保护 {0x5025, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GLJS_TT,}, // 后加速保护投入 {0x5026, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GLQDCH_TT,}, // 过流保护启动重合闸 {0x5027, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_LXQDCH_TT,}, // 零序过流保护启动重合闸 {0x5028, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_YLBS_TT,}, // 涌流闭锁投入 {0x5029, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GL1_I,}, // 过流Ⅰ段定值 {0x502A, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GL1_T,}, // 过流Ⅰ段时间 {0x502B, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GL2_I,}, // 过流Ⅱ段定值 {0x502C, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GL2_T,}, // 过流Ⅱ段时间 {0x502D, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GL3_I,}, // 过流Ⅲ段定值 {0x502E, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GL3_T,}, // 过流Ⅲ段时间 {0x502F, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_LX1_I,}, // 零序过流Ⅰ段定值 {0x5030, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_LX1_T,}, // 零序过流Ⅰ段时间 {0x5031, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_LX2_I,}, // 零序过流Ⅱ段定值 {0x5032, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_LX2_T,}, // 零序过流Ⅱ段时间 {0x5033, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GENDY_U0HV_U,}, // 零序过电压保护定值 {0x5034, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GENDY_U0HV_T,}, // 零序过电压保护时间 {0x5035, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_JSKF_T,}, // 加速段保护开放时间 {0x5036, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GLJS_I,}, // 后加速过流保护定值 {0x5037, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_GLJS_T,}, // 后加速过流保护时间 {0x5038, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_LXJS_I,}, // 后加速零序电流保护定值 {0x5039, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_LXJS_T,}, // 后加速零序电流保护时间 {0x503A, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_YLBS_V,}, // 二次谐波闭锁系数 {0x503B, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_CH1_TT,}, // 一次重合闸投入 {0x503C, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_CH2_TT,}, // 二次重合闸投入 {0x503D, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_CHJTQ_TT,}, // 重合闸检同期 {0x503E, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_CHJWY_TT,}, // 重合闸检无压 {0x503F, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_CH_DLBS_TT,}, // 大电流闭锁重合投入 {0x5040, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_CHKF_T,}, // 重合闸开放时间 {0x5041, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_CHCD_T,}, // 重合闸充电时间 {0x5042, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_CH1_T,}, // 一次重合闸时间 {0x5043, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_ECBS_T,}, // 二次重合闸闭锁时间 {0x5044, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_CH2_T,}, // 二次重合闸时间 {0x5045, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_CH_DLBS_I,}, // 大电流闭锁重合定值 {0x5046, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_TYPE,}, // 分段/联络模式 {0x5047, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_S_A_VO,}, // 电源侧得电延时合闸 {0x5048, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_S_B_VO,}, // 负荷侧得电延时合闸 {0x5049, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_L_A_LO,}, // A侧失压延时合闸 {0x504A, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_L_B_LO,}, // B侧失压延时合闸 {0x504B, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_CUR_TT,}, // 合到故障分闸 {0x504C, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_CLOK_LF_TT,}, // 短时失压闭锁分闸 {0x504D, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_OVI_ALM_TT,}, // 相间过流告警投入 {0x504E, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_OVI0_ALM_TT,}, // 接地告警投入 {0x504F, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_U0_TT,}, // 合到零压保护 {0x5050, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_ILOCKOFF_TT,}, // 非遮断电流保护 {0x5051, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_LA_FA_PTBREAK_TT,}, // PT断线告警 {0x5052, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_LOST_V_LOCK_TT,}, // 多次失压分闸闭锁 {0x5053, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_INRUSH_C_TT,}, // 涌流闭锁投入 {0x5054, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_HW_RESI_VOLT_TT,}, // 硬件残压模块投入 {0x5055, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_U_HAVE,}, // 有压定值 {0x5056, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_U_NO,}, // 无压定值 {0x5057, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_X_T,}, // 得电合闸延时（X时限） {0x5058, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_Y_T,}, // 故障检测时限（Y时限） {0x5059, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_XL_T,}, // 失压合闸延时（XL时限） {0x505A, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_Z_T,}, // 失电分闸延时（Z时限） {0x505B, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_CLOK_LF_T,}, // 闭锁分闸复归时间 {0x505C, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_GL1_I,}, // 相间故障电流I段定值 {0x505D, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_GL1_T,}, // 相间故障电流I段时间 {0x505E, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_GL2_I,}, // 相间故障电流II段定值 {0x505F, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_GL2_T,}, // 相间故障电流II段时间 {0x5060, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_LX_I,}, // 接地故障电流定值 {0x5061, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_LX_T,}, // 接地故障时间定值 {0x5062, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_COMPOUND_LOWU,}, // 复合电压低电压定值 {0x5063, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_COMPOUND_NSU,}, // 复合电压负序电压定值 {0x5064, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_OVI_ALM_I,}, // 相间过流告警电流定值 {0x5065, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_OVI_ALM_T,}, // 相间过流告警时间定值 {0x5066, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_OVI0_ALM_I,}, // 接地告警电流定值 {0x5067, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_OVI0_ALM_T,}, // 接地告警时间定值 {0x5068, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_U0_U,}, // 零序电压保护电压定值 {0x5069, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_U0_T,}, // 零序电压保护时间定值 {0x506A, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_FA_ILOCKOFF_I,}, // 非遮断电流值 {0x506B, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_INRUSH_C_I,}, // 二次谐波闭锁系数 {0x506C, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_TYPE_TT,}, // 分布式FA方式 {0x506D, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_L_TYPE_TT,}, // 联络自投投入 {0x506E, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_OVI_LOCK_L_TT,}, // 过载闭锁自投投入 {0x506F, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_FSW_LV_TT,}, // 首开关失压保护投入 {0x5070, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_STR_AR_TT,}, // 智能分布式启动重合闸 {0x5071, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_U_HAVE,}, // 有压定值 {0x5072, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_U_NO,}, // 无压定值 {0x5073, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_C_NO,}, // 无流定值 {0x5074, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_GL_I,}, // 分布式FA过流定值 {0x5075, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_GL_T,}, // 分布式FA过流时间 {0x5076, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_LX_I,}, // 分布式FA零序过流定值 {0x5077, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_LX_T,}, // 分布式FA零序过流时间 {0x5078, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_L_CHG_T,}, // 联络自投充电延时 {0x5079, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_XL_T,}, // 联络自投合闸延时 {0x507A, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_FSW_LVOFF_T,}, // 首开关失压跳闸延时 {0x507B, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_FAULT_CUT_T,}, // 故障隔离时限 {0x507C, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_OVI_I,}, // 过载判断定值 {0x507D, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_DFA_NOTWORK_T,}, // 失灵判断延时 {0x507E, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_SYNC_ALLOW_U,}, // 同期允许电压差 {0x507F, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_SYNC_ALLOW_ANG,}, // 同期允许相角差 {0x5080, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_SYNC_ALLOW_FRQ,}, // 同期允许频率差 {0x5081, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_U_TT,}, // 电压越限解列投入 {0x5082, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_U_SLIP_T,}, // 电压滑差闭锁功能 {0x5083, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_F_TT,}, // 频率越限解列投入 {0x5084, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_F_SLIP_T,}, // 频率滑差闭锁功能 {0x5085, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_CHAR_T,}, // 解列充电时间 {0x5086, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_LOW_U,}, // 低电压解列定值 {0x5087, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_LOW_T,}, // 低电压解列时间 {0x5088, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_TOO_LOW_U,}, // 电压过低解列定值 {0x5089, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_TOO_LOW_T,}, // 电压过低解列时间 {0x508A, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_HIGH_U,}, // 高电压解列定值 {0x508B, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_HIGH_T,}, // 高电压解列时间 {0x508C, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_TOO_HIGH_U,}, // 电压过高解列定值 {0x508D, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_TOO_HIGH_T,}, // 电压过高解列时间 {0x508E, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_U_RATE,}, // 电压滑差定值 {0x508F, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_LOW_FRQ,}, // 低频解列定值 {0x5090, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_LOW_FRQ_T,}, // 低频解列时间 {0x5091, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_TOO_LOW_FRQ,}, // 频率过低解列定值 {0x5092, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_TOO_LOW_FRQ_T,}, // 频率过低解列时间 {0x5093, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_HIGH_FRQ,}, // 高频解列定值 {0x5094, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_HIGH_FRQ_T,}, // 高频解列时间 {0x5095, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_TOO_HIGH_FRQ,}, // 频率过高解列定值 {0x5096, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_TOO_HIGH_FRQ_T,}, // 频率过高解列时间 {0x5097, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_STE_FRQ_RATE,}, // 频率滑差定值 {0x5098, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_XDL_TT,}, // 小电流接地保护 {0x5099, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_XDL_STR_AR_TT,}, // 小电流接地保护启动重合闸 {0x509A, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_XDL_HJS_TT,}, // 小电流接地保护后加速 {0x509B, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_CET_U0_OVV_T,}, // 小电流接地故障时间 TODO 暂时使用集中式的零压时间来代替 因为波形回放是暂态 不能有延时 {0x509C, FLOAT_R, RMT_GRP_SWSET, 0, 1.0, SET_XDL_HJSKF_T,}, // 后加速开放时间 {0x509D, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_LA_BREAKLINE_A_T,}, // 线路断线告警确认时间 {0x509E, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_TRASW_DELAY_ON_T,}, // 延时合闸时间 {0x509F, FLOAT_R, RMT_GRP_PUSET, 0, 1.0, SET_TRASW_END_T,}, // 结束传动时间 {0x8001, STR_R, RMT_GRP_NUMBER, 0, 1.0, PARA_NUM, }, /* 终端ID */ {0x8002, STR_R, RMT_GRP_NUMBER, 0, 1.0, PARA_NUM, }, /* 终端厂商 */ {0x8003, STR_R, RMT_GRP_NUMBER, 0, 1.0, PARA_NUM, }, /* 终端型号 */ {0x8004, STR_R, RMT_GRP_NUMBER, 0, 1.0, PARA_NUM, }, /* 终端硬件版本 */ {0x8005, STR_R, RMT_GRP_NUMBER, 0, 1.0, PARA_NUM, }, /* 终端软件版本 */ {0x8006, INT_R, RMT_GRP_EQSET, 0, 1.0, CSTSET_AP_COM, }, /* 规约参数 */ {0x8007, INT_R, RMT_GRP_EQSET, 0, 1.0, CSTSET_AP_EQU_ADDR }, /* 终端逻辑地址 */ {0x8008, FLOAT_R, RMT_GRP_EQSET, 0, 1.0, CSTSET_AP_YC_DEAD_ZONE }, /* 遥测死区 */ {0x8009, FLOAT_R, RMT_GRP_EQSET, 0, 1.0, CSTSET_AP_DI_AS_TIME }, /* 开入量采集防抖时间 */ {0x800a, FLOAT_R, RMT_GRP_EQSET, 0, 1.0, CSTSET_AP_BAAC }, /* 蓄电池自动活化周期 */ {0x800b, STR_R, RMT_GRP_EQSET, 0, 1.0, CSTSET_AP_IP_M1 }, /* 主站侧IP1地址 */ {0x800c, STR_R, RMT_GRP_EQSET, 0, 1.0, CSTSET_AP_IP_M2 }, /* 主站侧IP2地址 */ {0x800d, STR_R, RMT_GRP_EQSET, 0, 1.0, CSTSET_AP_IP_M3 }, /* 主站侧IP3地址 */ {0x800e, STR_R, RMT_GRP_EQSET, 0, 1.0, CSTSET_AP_IP_M4 }, /* 主站侧IP4地址 */ #endif }; const int RMT_SET_TABLE_NUMBER = sizeof( tRmtsettable ) / sizeof(tRmtsettable[0]); const TFIXEDSETTABLE tfixedsettable[]= // { #if !defined CPU_FUXI {FIXED_SET_EQU, 0x8001, STR_R, "D30", "终端类型",}, {FIXED_SET_SYS, 0x8002, STR_R, "Linux 5.10.214", "操作系统",}, {FIXED_SET_MAU, 0x8003, STR_R, "", " 制造商",}, {FIXED_SET_HVR, 0x8004, STR_R, "HV01.02", "硬件版本",}, {FIXED_SET_SVR, 0x8005, STR_R, "", "软件版本",}, {FIXED_SET_CRC, 0x8006, USHORT_R,"", "软件校验",}, {FIXED_SET_COM, 0x8007, STR_R, "101-2016,104-2016", "通信规约",}, {FIXED_SET_TPE, 0x8008, STR_R, "CSP-6000", "出厂型号",}, {FIXED_SET_ID, 0x8009, STR_R, "", "终端ID号",}, {FIXED_SET_MAC1, 0x800A, STR_R, "", "网卡1MAC",}, {FIXED_SET_MAC2, 0x800B, STR_R, "", "网卡2MAC",}, {FIXED_SET_PTRATE, 0x800C, STR_R, "100", "PT变比",}, {FIXED_SET_CTRATE, 0x800D, STR_R, "120", "CT变比",}, #else {FIXED_SET_ID, 0x8001, STR_R, "", "终端ID",}, {FIXED_SET_MAU, 0x8002, STR_R, "", "终端厂商",}, {FIXED_SET_TPE, 0x8003, STR_R, "", "终端型号",}, {FIXED_SET_HVR, 0x8004, STR_R, "HV01.00", "终端硬件版本",}, {FIXED_SET_SVR, 0x8005, STR_R, "SV01.00", "终端软件版本",}, {FIXED_SET_COM, 0x8006, UINT_R, "104", "规约参数",}, {FIXED_SET_EQU_ADDR, 0x8007, UINT_R, "1", "终端逻辑地址",}, {FIXED_SET_YC_DEAD_ZONE, 0x8008, FLOAT_R, "2", "遥测死区",}, {FIXED_SET_DI_AS_TIME, 0x8009, FLOAT_R, "20", "开入量采集防抖时间",}, {FIXED_SET_BAAC, 0x800a, FLOAT_R, "2", "蓄电池自动活化周期",}, {FIXED_SET_IP_M1, 0x800b, STR_R, "", "主站侧IP1地址",}, {FIXED_SET_IP_M2, 0x800c, STR_R, "", "主站侧IP2地址",}, {FIXED_SET_IP_M3, 0x800d, STR_R, "", "主站侧IP3地址",}, {FIXED_SET_IP_M4, 0x800e, STR_R, "", "主站侧IP4地址",}, {FIXED_SET_CRC, 0x800f, STR_R, "", "软件校验",}, {FIXED_SET_MAN, 0x8010, STR_R, "", "终端名称",}, {FIXED_SET_CPT, 0x8011, STR_R, "", "编译时间",}, #endif }; const int FIXEDSET_TABLE_NUMBER = sizeof( tfixedsettable ) / sizeof(tfixedsettable[0]); const CSTVAL_FORWARD_TABLE tCstValForwardTable[] = {//以下元素排序时需按分组排序：装置参数、公共定值、保护定值、内部定值 #if defined GD_AREA_NAME //举例 // 装置参数 {SETGROUP_TYPE_PARA, PARA_ADDR, 0x5001}, //装置地址 {SETGROUP_TYPE_PARA, PARA_DEAD_I, 0x5002}, //电流死区 {SETGROUP_TYPE_PARA, PARA_DEAD_U, 0x5003}, //交流电压死区 {SETGROUP_TYPE_PARA, PARA_DEAD_P, 0x5004}, //功率死区 {SETGROUP_TYPE_PARA, PARA_DEAD_COS, 0x5005}, //功率因数死区 {SETGROUP_TYPE_PARA, PARA_YXFD, 0x5006}, //遥信防抖时间 {SETGROUP_TYPE_PARA, PARA_BAT_INTERVAL, 0x5007}, //电池活化间隔 // 公共定值 {SETGROUP_TYPE_PUB, SET_SECTION, 0x5008}, //定值区 {SETGROUP_TYPE_PUB, SET_BHCT1_A, 0x5009}, //保护CT额定值1次 {SETGROUP_TYPE_PUB, SET_BHCT2_A, 0x500A}, //保护CT额定值2次 {SETGROUP_TYPE_PUB, SET_I0CT1_A, 0x500B}, //零序CT额定值1次 {SETGROUP_TYPE_PUB, SET_I0CT2_A, 0x500C}, //零序CT额定值2次 // 保护定值 {SETGROUP_TYPE_BH, SET_EDIT_PAR_YB, 0x5010}, // 远方修改投入 {SETGROUP_TYPE_BH, SET_GL1_TT, 0x5012}, // 过流1投入 {SETGROUP_TYPE_BH, SET_GL2_TT, 0x5013}, // 过流2投入 {SETGROUP_TYPE_BH, SET_BH_PTDX, 0x5014}, // PT断线检查 {SETGROUP_TYPE_BH, SET_LX1_TT, 0x5015}, // 零序1投入 {SETGROUP_TYPE_BH, SET_BH_XBBS_TT, 0x5016}, // 涌流闭锁投入 {SETGROUP_TYPE_BH, SET_CH1_TT, 0x5017}, // 一次重合闸投入 {SETGROUP_TYPE_BH, SET_DLYX_TT, 0x5018}, // 过负荷告警投入 #endif }; struct THREE_REMOTE g_three_remote_func[]= { {KEYWORD_YX,"遥信","<交流>","可配置成交流遥信",get_yx_ac}, //示例： //{KEYWORD_YC,"遥测","<**>","****",void}, //{KEYWORD_YK,"遥控","<**>","****",void}, }; const int REMOTE_NUM = (sizeof(g_three_remote_func)/sizeof(g_three_remote_func[0])); struct _list_item { const SET_LIST *list; int num; }; struct _list_item g_list_all[] = { {TTList, sizeof(TTList) / sizeof(SET_LIST),}, {GJHZList, sizeof(GJHZList) / sizeof(SET_LIST),}, {TZList, sizeof(TZList) / sizeof(SET_LIST),}, {FSXList, sizeof(FSXList) / sizeof(SET_LIST),}, {CHZList, sizeof(CHZList) / sizeof(SET_LIST),}, {CHJSList, sizeof(CHJSList) / sizeof(SET_LIST),}, {BaudList, sizeof(BaudList) / sizeof(SET_LIST),}, {ParityList, sizeof(ParityList) / sizeof(SET_LIST),}, {ProtocolList, sizeof(ProtocolList) / sizeof(SET_LIST),}, {KGFunList, sizeof(KGFunList) / sizeof(SET_LIST),}, {TimeList, sizeof(TimeList) / sizeof(SET_LIST),}, {PTTypeList, sizeof(PTTypeList) / sizeof(SET_LIST),}, {YCTypeList, sizeof(YCTypeList) / sizeof(SET_LIST),}, {IEC101AddrList, sizeof(IEC101AddrList) / sizeof(SET_LIST),}, {AddrNumList, sizeof(AddrNumList) / sizeof(SET_LIST),}, {TZCKList, sizeof(TZCKList) / sizeof(SET_LIST),}, {TZGJList, sizeof(TZGJList) / sizeof(SET_LIST),}, {HHFunList, sizeof(HHFunList) / sizeof(SET_LIST),}, {Net_Eth_List, sizeof(Net_Eth_List) / sizeof(SET_LIST),}, {FA_List, sizeof(FA_List) / sizeof(SET_LIST),}, {WFList, sizeof(WFList) / sizeof(SET_LIST),}, {LB_VOL_List, sizeof(LB_VOL_List) / sizeof(SET_LIST),}, {RCL_List, sizeof(RCL_List) / sizeof(SET_LIST),}, {JMList, sizeof(JMList) / sizeof(SET_LIST),}, {JDTYPE, sizeof(JDTYPE) / sizeof(SET_LIST),}, {XDLQDList, sizeof(XDLQDList) / sizeof(SET_LIST),}, {KGFun1List, sizeof(KGFun1List) / sizeof(SET_LIST),}, {T104ServerList, sizeof(T104ServerList) / sizeof(SET_LIST),}, {TVolSelList, sizeof(TVolSelList) / sizeof(SET_LIST),}, {HZList, sizeof(HZList) / sizeof(SET_LIST),}, {TGooseKG, sizeof(TGooseKG) / sizeof(SET_LIST),}, {TGooseFA, sizeof(TGooseFA) / sizeof(SET_LIST),}, {THHTYPE, sizeof(THHTYPE) / sizeof(SET_LIST),}, {TFA_Type, sizeof(TFA_Type) / sizeof(SET_LIST),}, {TPT_Type, sizeof(TPT_Type) / sizeof(SET_LIST),}, {EQUList, sizeof(EQUList) / sizeof(SET_LIST),}, {YCTypeDead, sizeof(YCTypeDead) / sizeof(SET_LIST),}, {PUList, sizeof(PUList) / sizeof(SET_LIST),}, {LinkList, sizeof(LinkList) / sizeof(SET_LIST),}, {DISPMODEList, sizeof(DISPMODEList) / sizeof(SET_LIST),}, {GOOSE_NET_List, sizeof(GOOSE_NET_List) / sizeof(SET_LIST),}, {FAKGTYPE, sizeof(FAKGTYPE) / sizeof(SET_LIST),}, #ifdef CUSTOMIZE_BZT // 备自投 {BZTFSList, sizeof(BZTFSList) / sizeof(SET_LIST),}, {TISelList, sizeof(TISelList) / sizeof(SET_LIST),}, #endif {TFGKEY_Type, sizeof(TFGKEY_Type) / sizeof(SET_LIST),}, {UYY_List, sizeof(UYY_List) / sizeof(SET_LIST),}, #ifdef METERING_ENERGY {DDList, sizeof(DDList) / sizeof(SET_LIST),}, {JLFSList, sizeof(JLFSList) / sizeof(SET_LIST),}, {WGFSList, sizeof(WGFSList) / sizeof(SET_LIST),}, #endif {HisFileFormatList, sizeof(HisFileFormatList) / sizeof(SET_LIST),}, #ifdef FIX_PARAM_FORMAT {TULF8List, sizeof(TULF8List) / sizeof(SET_LIST),}, #endif {TimeListSelect, sizeof(TimeListSelect) / sizeof(SET_LIST),}, {TBLTYPE, sizeof(TBLTYPE) / sizeof(SET_LIST),}, {FilterTYPE, sizeof(FilterTYPE) / sizeof(SET_LIST),}, {WaveletTYPE, sizeof(WaveletTYPE) / sizeof(SET_LIST),}, {START_List, sizeof(START_List) / sizeof(SET_LIST),}, {BMLList, sizeof(BMLList) / sizeof(SET_LIST),}, {JWYList, sizeof(JWYList) / sizeof(SET_LIST),}, }; #define LIST_ALL_NUM (sizeof(g_list_all) / sizeof(struct _list_item)) // 得到一个固定参数的值 int set_get_fixed_arg(int index, char *buf, int len) { RMT_FIXED_TABLE tfixedset; int i; iec_init_fixedset(&g_t104[0], &tfixedset, true); // 获取固定定值 // 检查参数 if (index < 0 || index >= FIXEDSET_TABLE_NUMBER) // FIXEDSET_TABLE_NUMBER) { return -1; } if (buf == NULL || len < 32) { return -2; } memset(buf, 0, len); len--; #if !defined CPU_FUXI for (i = 0; i < RMT_FIXED_SET_NUM; i++) { if (index == tfixedset.set[i].type) { switch (index) { case FIXED_SET_CRC: // 软件校验。 sprintf(buf, "%04x", (tfixedset.set[i].str[0] + (tfixedset.set[i].str[1] << 8))); break; #if !defined CPU_FUXI case FIXED_SET_MAC1: case FIXED_SET_MAC2: sprintf(buf, "%02x-%02x-%02x-%02x-%02x-%02x", tfixedset.set[i].str[0], tfixedset.set[i].str[1], tfixedset.set[i].str[2], tfixedset.set[i].str[3], tfixedset.set[i].str[4], tfixedset.set[i].str[5]); break; #endif default: strncpy(buf, tfixedset.set[i].str, len); break; } return 0; } } return -3; #else for (i = 0; i < RMT_FIXED_SET_NUM; i++) { if (index == tfixedset.set[i].type) { switch (index) { case FIXED_SET_CRC: // 软件校验。 sprintf(buf, "%04x", (tfixedset.set[i].str[0] + (tfixedset.set[i].str[1] << 8))); break; default: strncpy(buf, tfixedset.set[i].str, len); break; } } } return 0; #endif } // 得到固定参数字符串，维护工具接口用 int set_get_fixed_args_sz(int index, char *buf, int len) { int i, len_line, len_all, num; char sz[64], arg[64]; len_all = 0; num = 0; for (i = index * FIXED_ARGS_NUM; i < FIXEDSET_TABLE_NUMBER && num < FIXED_ARGS_NUM; i++, num++) { set_get_fixed_arg(i, arg, 64); len_line = sprintf(sz, "%s[%04x]:%s\r\n", tfixedsettable[i].name, tfixedsettable[i].di, arg); strncpy(buf + len_all, sz, len - len_all); len_all += len_line; // dp_err_n_c("index = %ld, i = %d, len_all = %d, len_line = %d, arg: %s, sz: %s", index, i, len_all, len_line, arg, sz); if (len_all >= len) { buf[len - 1] = 0; return len; } } // 删除最后的回车换行 if (len_all > 2) { len_all -= 2; } buf[len_all] = 0; return len_all + 1; } /*********************eep操作通用函数:包含装置型号及CRC信息*******************/ /************************************************************************** 函数名称：SaveEppData 函数版本：1.00 作者： 创建日期：2008.8.20 函数功能说明：在EEP中，保存信息，附加了装置类型及校验码 输入参数： 输出参数：无 返回值： 成功时返回1，否则，0 函数扇入清单： ***************************************************************************/ bool SaveEppData(DWORD wAddr, void *pdat, WORD num) { EQUIP_INF tInf; tInf.wType = EQUIP_TYPE; // 装置类型 tInf.wVerH = SOFT_VERH; // 版本号 tInf.wVerL = SOFT_VERL; tInf.wCrc = CrcStr((BYTE *)pdat, num); tInf.wdescCrc = g_crc_set_desc; if (e2prom_write(wAddr, (BYTE *)pdat, num) != 0) // 保存信息 { return false; } if (e2prom_write((wAddr + num), (BYTE *)&tInf, sizeof(EQUIP_INF)) != 0) // 保存校验信息，包括校验码 { return false; } return true; } /************************************************************************** 函数名称：ReadEppData 函数版本：1.00 作者： 创建日期：2008.8.20 函数功能说明：读EEP中保存信息，并进行装置类型及校验码的校验 输入参数： 输出参数：无 返回值： 成功时返回1，否则，0 函数扇入清单： ***************************************************************************/ bool ReadEppData(DWORD wAddr, void *pdat, WORD num) { EQUIP_INF tInf; WORD crc; e2prom_read(wAddr, (BYTE *)pdat, num); e2prom_read((wAddr + num), (BYTE *)&tInf, sizeof(EQUIP_INF)); if (tInf.wType != EQUIP_TYPE) // 不是本装置 { return false; } if (tInf.wdescCrc != g_crc_set_desc) { // return false; } crc = CrcStr((BYTE *)pdat, num); if (crc != tInf.wCrc) { return false; } return true; } /******************下面是关于定值区及定值读取及校验的操作********************************/ /********************************************************** 函数名称：ReadSet 函数版本：1.00 作者： 创建日期：2008.8.20 函数功能说明：从指定定值区setno读取定值到pf中,并进行CRC-16校验 输入参数：BYTE setno指定定值区 输出参数：无 返回值： 成功时返回1，否则，0 函数扇入清单： ************************************************************/ bool ReadSet(WORD setno, void *pbuf) { float *pf = (float *)pbuf; if (setno >= SEC_NUMBER) { rt_printf("定值区号异常section=%d", setno); return false; } if (!ReadPara((void *)pf, EEP_PUB_ADDR + setno * PUB_SETSIZE, PUB_SET_NUMBER, &tPubSetTable[0])) { return false; } if (!ReadPara((void *)&pf[PUB_SET_NUMBER], EEP_SET_ADDR + setno * SETSIZE, SW_SET_NUMBER, &tSwSetTable[0])) { return false; } return true; } /************************************************************************** 函数名称：SaveSet 函数版本：1.00 作者： 创建日期：2008.8.20 函数功能说明：从指定定值区setno读取定值到pf中,并进行CRC-16校验 输入参数：BYTE setno指定定值区 输出参数：无 返回值： 成功时返回1，否则，0 函数扇入清单： ***************************************************************************/ bool SaveSet(WORD setno, void *pf) { float *pff = (float *)pf; bool ret1 = false, ret2 = false; if (setno >= SEC_NUMBER) { rt_printf("定值区号异常section=%d", setno); return false; } ret1 = SavePara((void *)pff, EEP_PUB_ADDR + setno * PUB_SETSIZE, PUB_SET_NUMBER, &tPubSetTable[0]); ret2 = SavePara((void *)&pff[PUB_SET_NUMBER], (EEP_SET_ADDR + setno * SETSIZE), SW_SET_NUMBER, &tSwSetTable[0]); if (ret1 || ret2) { g_creat_set_file |= 0x01; } return (ret1 || ret2); } /************************************************************************** 函数名称：CheckRunSet 函数版本：1.00 作者： 创建日期：2008.8.20 函数功能说明：检查运行定值 检查运行定值指针的正确性 检查当前运行的定值的值是否与备份的定值的信息互为反码 输入参数： 其他输入: 输出参数： 返回值： true 检查的内容均正常 false 检查的内容至少有一项不正常 函数扇入清单： ***************************************************************************/ bool CheckRunSet(void) { BYTE *pBak = (BYTE *)&tBakSet; BYTE *pRun = (BYTE *)pRunSet; int i = sizeof(struct TSET); for (; i > 0; i--) { if ((BYTE)*pRun != (BYTE)(~*pBak)) { return false; } pRun++; pBak++; } return true; } /************************************************************************** 函数名称：GetSetNormal 函数版本：1.00 作者： 创建日期：2008.8.20 函数功能说明：转换定值，将定值转为运行程序可使用的值，目的为了减少代码 输入参数：fk为转换的系数 其他输入: 输出参数： 返回值： 函数扇入清单： ***************************************************************************/ static DWORD GetSetNormal(float ff, float fk) { DWORD ret; ret = (DWORD)rt_round((ff * fk)); return ret; } /************************************************************************** 函数名称：GetSetSQR 函数版本：1.00 作者： 创建日期：2008.8.20 函数功能说明：转换定值，将定值转为运行程序可使用的平方值, 目的为了减少代码 输入参数：fk为转换的系数 其他输入: 输出参数： 返回值： 函数扇入清单： ***************************************************************************/ DWORD GetSetSQR(float ff, float fk) { DWORD ret; float fv; fv = ff * fk; if (fv >= 65536.0) { ret = ((DWORD)65536 * 65535); } else { ret = (DWORD)rt_round((ff * fk) * (ff * fk)); } return ret; } /************************************************************************** 函数名称：GetSetTIME 函数版本：1.00 作者： 创建日期：2008.8.20 函数功能说明：转换时间定值，将时间转为系统的定时tick值 目的为了减少代码 输入参数： 其他输入: 输出参数： 返回值： 函数扇入清单： ***************************************************************************/ static DWORD GetSetTIME(float ff) { DWORD ret; ret = (DWORD)(0.5 + ff * SAM_FREQUENCY); return ret; } void fresh_set_soe(WORD soe_no, bool bY, bool bFirst, int sw) { WORD code = soe_no + EV_SW_NUM * sw; if (bFirst) // 第一次不上送 { if (bY) // 开出压板状态更新到事件记录中 { soe_ev_set(code, 1); } else { soe_ev_set(code, 0); } } else { if (bY) // 开出压板状态更新到事件记录中 { if (!soe_check(code)) { soe_record_ev(code, 1, 0, 0, 0); } } else { if (soe_check(code)) { soe_record_ev(code, 0, 0, 0, 0); } } } } void fresh_sw_ac_set(SET_VALUE *psetbuf, int sw) { int i; int index; for (i = 0; i < SW_AC_SET_NUM; i++) { index = sw_ac_set_index[i]; // 针对佛山供电局遥测中的定值部分（零序一段、二段）和遥参不对应，特殊处理 if ((index == SET_LX1_TT) || (index == SET_LX2_TT)) { if (psetbuf[index + sw * SW_SET_NUMBER].ff == 0) { g_sw[sw].ac_in[SW_AC_IN_SET_BEGIN + i] = 2 * Q16_BASE; } else { g_sw[sw].ac_in[SW_AC_IN_SET_BEGIN + i] = psetbuf[index + sw * SW_SET_NUMBER].ff * Q16_BASE; } } else { g_sw[sw].ac_in[SW_AC_IN_SET_BEGIN + i] = psetbuf[index + sw * SW_SET_NUMBER].ff * Q16_BASE; } } } /************************************************************************** 函数名称：get_yx_ac 创建日期：2021.11 函数功能说明：获取开入通道配置"<交流>"关键字以确定是否配置为交流遥信 输入参数：无 输出参数：无 返回值： s_bYX_AC ***************************************************************************/ void get_yx_ac(u8 index, u32 type) { gb_yx_ac = true; } /** * @brief 检测频率跟踪投退是否有变化 * @author lch (lch_work@foxmail.com) * @version 1.0 * @date 20260106 * @return * void * @retval none * * @warning none * @note none */ void check_shmdata_change(void) { static uint8_t suc_freq_track = 0xff; struct t_shmdata_cvalue t_cvale = {0}; if (suc_freq_track != pRunSet->bTT_FREQ) { t_cvale.uc_freq_track = pRunSet->bTT_FREQ; shm_packet_write_v2(SHM_ADDR_R_MACHINEPARAM, (uint8_t *)&t_cvale, sizeof(struct t_shmdata_cvalue)); suc_freq_track = pRunSet->bTT_FREQ; } } /************************************************************************** 函数名称：MakeRunSet 函数版本：1.00 作者： 创建日期：2008.8.18 函数功能说明：将psetbuf中保存的定值转换为运行定值 输入参数： 输出参数：无 返回值： 成功时返回1，否则，0 函数扇入清单： ***************************************************************************/ bool MakeRunSet(bool bFirst) { TSET *ptSet; SET_VALUE *psetbuf = m_SetBuf; float fKI, fKI0, fKU[PUB_AC_NUM], fIn, fUn; // 电流电压系数及额定电流值 int sw, i; bool bRet; #ifdef CPU_FUXI SHM_FREQ_TR_T freq_tr; #endif #ifdef CUSTOMIZE_BZT // 备自投 int dw = 0; #endif BYTE mode_total; bRet = true; // 检查定值个数 if (SET_NUMBER > MAX_SET_NUMBER) { rt_printf("SET_NUMBER(%d) > MAX_SET_NUMBER(%d).\r\n", SET_NUMBER, MAX_SET_NUMBER); rt_err_set(ERR_CODE_SET, 0); return false; } if (pRunSet == (&tRunSet[0])) // 运行定值缓冲区切换 { ptSet = &tRunSet[1]; } else { ptSet = &tRunSet[0]; } for (i = 0; i < PUB_AC_NUM; i++) { ptSet->dKU[i] = sw_v_m2_factor_k(i); // 电压互感器系数 fKU[i] = (float)ptSet->dKU[i] / 256.0; } /* 读取内部定值 */ if (!ReadPara((void *)psetbuf, EEP_CSTSET_ADDR, CSTSET_NUMBER, &tCstSetTable[0])) { rt_err_set(ERR_CODE_SET_IN, 0); GetDefPara((void *)psetbuf, CSTSET_NUMBER, &tCstSetTable[0]); } else { rt_err_clr(ERR_CODE_SET_IN, 0); } ptSet->fFZLBXS = psetbuf[CSTSET_FZLBXS].ff; // 幅值加速滤波系数 #ifdef XDL_ZT // 小电流接地零压定值，有效值非瞬时值 ptSet->dU_xdl_u0[0] = GetSetSQR(psetbuf[CSTSET_XDL_U0_U1].ff, fKU[PUB_AC_U01]); // 小电流接地零压定值1 ptSet->dU_xdl_u0_fh[0] = _Mul_Div_U(ptSet->dU_xdl_u0[0], 96, 100); // 0.96=0.98*0.98 ptSet->dU_xdl_u0_zt[0] = GetSetNormal(psetbuf[CSTSET_XDL_U0_U1].ff, 1 / (g_ui[PUB_AC_U01].e_factor0)); ptSet->dT_xdl_u0[0] = GetSetTIME(psetbuf[CSTSET_XDL_U0_T1].ff); ptSet->dU_xdl_u0[1] = GetSetSQR(psetbuf[CSTSET_XDL_U0_U2].ff, fKU[PUB_AC_U02]); // 小电流接地零压定值2 ptSet->dU_xdl_u0_fh[1] = _Mul_Div_U(ptSet->dU_xdl_u0[1], 96, 100); // 0.96=0.98*0.98 ptSet->dU_xdl_u0_zt[1] = GetSetNormal(psetbuf[CSTSET_XDL_U0_U2].ff, 1 / (g_ui[PUB_AC_U02].e_factor0)); ptSet->dT_xdl_u0[1] = GetSetTIME(psetbuf[CSTSET_XDL_U0_T2].ff); ptSet->dU_xdl_22V[0] = GetSetNormal(20, 1 / (g_ui[PUB_AC_U01].e_factor0)); ptSet->dU_xdl_22V[1] = GetSetNormal(20, 1 / (g_ui[PUB_AC_U02].e_factor0)); #endif for (sw = 0; sw < SWITCH_NUM_MAX; sw++) { int ui_begin; ui_begin = UI_SW_INDEX_BEGIN(sw); fKI = (float)(g_ui[ui_begin + SW_AC_IA].m2_factor_k) / 256.0; fIn = (float)(g_ui[ui_begin + SW_AC_IA].m2_factor_k) / 256.0; fKI0 = (float)(g_ui[ui_begin + SW_AC_I0].m2_factor_k) / 256.0; ptSet->dTBLValue[sw] = GetSetNormal(psetbuf[CSTSET_TBLQD].ff, fIn); // 突变量 ptSet->dIWL_SQR[sw] = GetSetSQR(psetbuf[CSTSET_IWL].ff, fIn); } ptSet->dT_ZZFG = GetSetTIME(psetbuf[CSTSET_TZZ].ff); // 整组复归时间定值 ptSet->dT_TZSB = GetSetTIME(psetbuf[CSTSET_TZSB].ff); // 跳闸失败时间 ptSet->dT_HZSB = GetSetTIME(psetbuf[CSTSET_HZSB].ff); // 合闸失败时间 ptSet->bTT_FREQ = ((WORD)psetbuf[CSTSET_FREQ].ff == 1) ? true : false; // 频率跟踪投退 #ifdef CPU_FUXI if (ptSet->bTT_FREQ) freq_tr.enable_flag = 0x55; else freq_tr.enable_flag = 0; write_freq_tr((uint8_t *)&freq_tr); #endif ptSet->bTT_U0BS = ((WORD)psetbuf[CSTSET_U0BS_TT].ff == 1) ? true : false; // 零压闭锁零流 ptSet->bTT_DDYBS = ((WORD)psetbuf[CSTSET_DDYBS_TT].ff == 1) ? true : false; // 低压闭锁过流 ptSet->dU_U0BS = GetSetSQR(psetbuf[CSTSET_U0BS_U].ff, fKU[PUB_AC_U01]); // 零压闭锁定值 ptSet->dU_DDYBS = GetSetSQR(psetbuf[CSTSET_DDYBS_U].ff, fKU[PUB_AC_UAB1]); // 零压闭锁定值 ptSet->bKG2_DP_DELTAF = ((WORD)psetbuf[CSTSET_DP_DELTAF_TT].ff == 1) ? true : false; // 低频滑差投入 ptSet->dDP_DELTAF = GetSetNormal(psetbuf[CSTSET_DP_DELTAF].ff, 65536); // 滑差，扩大了65536倍 #ifdef PRO_AL_LOCK_HZ ptSet->bTT_JLlockCHZ = ((WORD)psetbuf[CSSET_JL_LOCK_CHZ].ff == 1) ? true : false; // 解列闭锁重合闸 ptSet->bTT_StartCHZ_judgeFreq = ((WORD)psetbuf[CSSET_START_CHZ_JUDGE_FREQ].ff == 1) ? true : false; // 解列后启动重合闸判频率 ptSet->bTT_StartCHZ_judgeVolt = ((WORD)psetbuf[CSSET_START_CHZ_JUDGE_VOLT].ff == 1) ? true : false; // 解列后启动重合闸判电压 #endif { int ui_begin; ui_begin = UI_SW_INDEX_BEGIN(0); fKI = (float)(g_ui[ui_begin + SW_AC_IA].m2_factor_k) / 256.0; fKI0 = (float)(g_ui[ui_begin + SW_AC_I0].m2_factor_k) / 256.0; } // 谐波 { int i; float f; g_harmonic_num = (int)psetbuf[CSSET_HARMONIC_NUM].ff; f = psetbuf[CSSET_HARMONIC_FACTOR].ff / (CFG_ADC_DOTS_PER_PERIOD / 2 - 2); for (i = 1; i < (CFG_ADC_DOTS_PER_PERIOD / 2); i++) { g_harmonic_factor[i] = 1.0 + f * (i - 1); } } // 模拟量温度校正系数 ptSet->f_temp_factor_ac = psetbuf[CSSET_TEMP_FACTOR_AC].ff; // 交流温漂 ptSet->f_temp_factor_dc = psetbuf[CSSET_TEMP_FACTOR_DC].ff; // 直流温漂 ptSet->bTT_RET_ZERO = ((WORD)psetbuf[CSTSET_RET_ZERO].ff == 1) ? true : false; // 归零值投退 ptSet->bTT_U0ZC = ((WORD)psetbuf[CSTSET_U0ZC_TT].ff == 1) ? true : false; // 零序电压自产 ptSet->dT101Resend = (DWORD)(psetbuf[CSSET_101RESEND_T].ff); // 101规约通道检查时间 ptSet->dT101Check = (DWORD)(psetbuf[CSSET_IEC101].ff); // 101规约通道检查时间 xj 2015.5.8 ptSet->bTT_101Cot03 = ((WORD)psetbuf[CSSET_101_COT03].ff == 1) ? true : false; // 平衡101初始化结束传输原因03 ptSet->bTT_104ChkAck = ((WORD)psetbuf[CSSET_104_CHECK_ACK].ff == 1) ? true : false; // 104检查确认序号 ptSet->bTT_101FCB = ((WORD)psetbuf[CSSET_101FCB].ff == 1) ? true : false; // 101规约FCB不判断 ptSet->bDIContinue = ((WORD)psetbuf[CSSET_DI_CONTINUE].ff == 1) ? true : false; // 连续点号上送 ptSet->bTT_SM2 = ((WORD)psetbuf[CSSET_SM2_TT].ff == 1) ? true : false; // 规约软件加密 ptSet->bTT_ESAM = ((WORD)psetbuf[CSSET_SM2_TT].ff == 2) ? true : false; // 规约硬件加密 ptSet->bTT_RmtTest = ((WORD)psetbuf[CSSET_RMTTEST_TT].ff == 1) ? true : false; // 远动测试模式 ptSet->bTT_SoeResumeComm = ((WORD)psetbuf[CSSET_SOE_RESUME_COMM].ff == 1) ? true : false; // SOE通讯续传，通讯重连时上送未确认的SOE ptSet->bTT_SoeResumePower = ((WORD)psetbuf[CSSET_SOE_RESUME_POWER].ff == 1) ? true : false; // SOE上电续传 ptSet->wEquTypeDFTU = ((WORD)psetbuf[CSSET_EQU_TYPE].ff == 0) ? true : false; // 装置类型 DTFU模式 ptSet->wEquTypeManager = ((WORD)psetbuf[CSSET_EQU_TYPE].ff == 1) ? true : false; // 装置类型 通信管理机模式 ptSet->f_yc_filter_factor = psetbuf[CSSET_YC_FILTER_FACTOR].ff; // 遥测滤波系数 #ifdef FIX_PARAM_FORMAT ptSet->bTT_Utf8 = ((WORD)psetbuf[CSSET_SET_ULF8].ff == 1) ? true : false; // 固定参数上送格式 ptSet->bTT_Unicode = ((WORD)psetbuf[CSSET_SET_ULF8].ff == 2) ? true : false; // 固定参数上送格式 #endif ptSet->dGroupYxSize = 0; // 组召遥信分组大小 ptSet->dGroupYcSize = 0; // 组召遥测分组大小 // 瞬压检出 ptSet->bTT_SY_Board = ((WORD)psetbuf[CSTSET_SYBOARD_TT].ff == 1) ? true : false; // 零压闭锁零流 // ptSet->dT_XCY = GetSetTIME(0.05); //残压检出时间默认50毫秒 #ifdef GD_AREA_ECZD_2020 // 25V/30ms ptSet->dT_XCY = GetSetTIME(0.02); // 残压检出时间默认20毫秒 #else ptSet->dT_XCY = GetSetTIME(0.03); // 残压检出时间默认30毫秒 #endif // goose 内部定值 ptSet->dT_cd = GetSetTIME(psetbuf[CSTSET_GOOSE_CD_T].ff); // DFA充电时间 ptSet->dT_glfd = GetSetTIME(psetbuf[CSTSET_GOOSE_GLFD_T].ff); // DFA隔离放电时间 ptSet->dT_llfd = GetSetTIME(psetbuf[CSTSET_GOOSE_LLFD_T].ff); // DFA恢复放电时间 ptSet->dT_frobit = GetSetTIME(psetbuf[CSTSET_GOOSE_FORBIT_T].ff); // DFA禁止转发时间 ptSet->dT_sendext = GetSetTIME(psetbuf[CSTSET_GOOSE_SENDEXT_T].ff); // DFA发送展宽时间 ptSet->dT_goosecheck = GetSetTIME(psetbuf[CSTSET_GOOSE_CHECK_T].ff); // goose判断时间 ptSet->bTT_fhkg_pub = ((WORD)psetbuf[CSTSET_GOOSE_FHKG_PUB].ff == 1) ? true : false; // 负荷开关发送goose投退 ptSet->dT_ldjs = GetSetTIME(psetbuf[CSTSET_SHORT_LDJS_T].ff); // 单侧来电解锁时间 ptSet->bTT_bs_ykon = ((WORD)psetbuf[CSTSET_BS_YKON_TT].ff == 1) ? true : false; // FA闭锁合闸禁止遥合 ptSet->bTT_goose_send_after = (((WORD)psetbuf[CSTSET_GOOSE_SEND_FAULT].ff == 1) ? true : false); // goose发布在故障确认后 // 录波 g_wave_filetype = (int)psetbuf[CSTSET_WAVE_FILETYPE].ff; // 录波文件格式 ptSet->lb_vol_type = (WORD)psetbuf[CSTSET_WAVE_VOL_TYPE].ff; // 录波 电压选择 0 第一组 1第二组 2全部 ptSet->lb_xyx = (((WORD)psetbuf[CSTSET_WAVE_XNYX].ff == 1) ? true : false); // 虚拟遥信记录 ptSet->lb_yx_type = (((WORD)psetbuf[CSTSET_WAVE_YXDES_TYPE].ff == 1) ? true : false); // 遥信描述类型 ptSet->lb_sw_num = (WORD)psetbuf[CSTSET_WAVE_SWNUM].ff; // 本开关间隔号 ptSet->dWCN_T = GetSetTIME(psetbuf[CSTSET_WCNALARM_T].ff); // 未储能告警时间 ptSet->dSDYX_T = GetSetTIME(psetbuf[CSTSET_SD_YX_T].ff); // 失电闭锁遥信时间 ptSet->bat_chargeok_time = psetbuf[CSTSET_CHARGEOK_TIME].ff; // 电池充满维持时间 ptSet->bTT_HistoryFile = (((WORD)psetbuf[CSSET_HS_FILE_TT].ff == 1) ? true : false); // 历史记录投退 ptSet->wHSFileFormat = (WORD)psetbuf[CSSET_HS_FILE_FORMAT].ff; // 记录文件格式 ptSet->bTT_MsgFile = (ptSet->wHSFileFormat == 0) ? true : false; // 记录文件格式 msg ptSet->bTT_XmlFile = (ptSet->wHSFileFormat == 1) ? true : false; // 记录文件格式 xml if (pRunSet->bTT_HistoryFile != ptSet->bTT_HistoryFile) { histrory_file_set = true; } if (pRunSet->wHSFileFormat != ptSet->wHSFileFormat) { b_hisfile_format = true; } ptSet->resReuseFuncSelect = (BYTE)psetbuf[CSSET_RST_REUSE_FUNC].ff; // 复归按键复用功能选择 ptSet->resReuseFuncFilterTime = (WORD)psetbuf[CSSET_RST_REUSE_FILTER_TIME].ff; // 复归按键复用功能防抖时长 ptSet->bTT_LogPrintf = (((WORD)psetbuf[CSSET_LOG_PRINTF_TT].ff == 1) ? true : false); // 现场运行模式 ptSet->bTT_101Transsure = (((WORD)psetbuf[CSSET_101_TRANSSURE_TT].ff == 1) ? true : false); // 101文件传输确认帧 ptSet->dSmoothZero = (DWORD)(psetbuf[CSSET_ZERO].ff); // 零漂值 ptSet->dwZL = (DWORD)(psetbuf[CSSET_ZL].ff * 65536); // 直流判断 ptSet->bTT_faultparaDKY = (((WORD)psetbuf[CSSET_FAULT_PARA_DKY].ff == 1) ? true : false); // 故障事件遥信地址长度 ptSet->bTT_RmtPara = (((WORD)psetbuf[CSSET_RMT_PARA_TT].ff == 1) ? true : false); // 远动参数有效 if ((WORD)psetbuf[CSSET_PT2_VOL].ff == 1) // 负荷侧电压选择 bc ptSet->pt2vol = PUB_AC_UBC2; else if ((WORD)psetbuf[CSSET_PT2_VOL].ff == 2) // 负荷侧电压选择 ca ptSet->pt2vol = PUB_AC_UCA2; else ptSet->pt2vol = PUB_AC_UAB2; ptSet->bTT_ShowOne = ((WORD)psetbuf[CSSET_DISP_ONE_TWO].ff == 1) ? true : false; // 液晶遥测数据显示 ptSet->dDc_num = (DWORD)(psetbuf[CSSET_SET_DC_NUM].ff); // 直流通道数量 #ifdef YC_QUANTITY ptSet->dYC_num = (DWORD)(psetbuf[CSSET_YC_NUM].ff); // 每间隔遥参数量 #endif #ifdef FA_PL_PJ ptSet->bTT_judgeFreq = ((WORD)psetbuf[CSSET_JUDGE_FREQ].ff == 1) ? true : false; // 有压判频率投退 #endif ptSet->bTT_UYYmin = ((WORD)psetbuf[CSSET_U_PJ].ff == 0) ? true : false; // 电压判据，取三相最小值时标志为1 #ifdef METERING_ENERGY ptSet->dd_calc_mode = (((WORD)psetbuf[CSSET_DD_CALC_MODE].ff == 1) ? true : false); // 电度计算方式 ptSet->wJLJX = (WORD)psetbuf[CSSET_JLJX].ff; ptSet->wWGFS = (WORD)psetbuf[CSSET_WGFS].ff; #endif ptSet->bTT_EV_YCRate = ((WORD)psetbuf[CSSET_SET_EV_YC_RATE].ff == 1) ? true : false; // SOE遥测系数投退 ptSet->bTT_YC_DeadZone_All = ((WORD)psetbuf[CSSET_SET_YC_DEAD_ZONE_ALL].ff == 1) ? true : false; // 遥测总死区有效投退 ptSet->bTT_CheckPhase = false; // 相序检查 ptSet->bTT_CTYC = true; // CT异常检查 #ifdef PUB_SET_SECTION /*先读取定值区0的公共定值*/ if (!ReadPara((void *)psetbuf, EEP_PUB_ADDR, PUB_SET_NUMBER, &tPubSetTable[0])) { rt_err_set(ERR_CODE_SET_PUB, 0); GetDefPara((void *)psetbuf, PUB_SET_NUMBER, &tPubSetTable[0]); rt_printf("%s(a):m_runsection=%d\r\n", __func__, m_runsection); } else { rt_err_clr(ERR_CODE_SET_PUB, 0); } // 公共定值 ptSet->section = (u8)psetbuf[SET_SECTION].ff; // 定值区 /*读取公共定值*/ if (!ReadPara((void *)psetbuf, EEP_PUB_ADDR + ptSet->section * PUB_SETSIZE, PUB_SET_NUMBER, &tPubSetTable[0])) { rt_err_set(ERR_CODE_SET_PUB, 0); GetDefPara((void *)psetbuf, PUB_SET_NUMBER, &tPubSetTable[0]); rt_printf("%s(b):m_runsection=%d\r\n", __func__, m_runsection); } else { rt_err_clr(ERR_CODE_SET_PUB, 0); } #else /*读取公共定值*/ if (!ReadPara((void *)psetbuf, EEP_PUB_ADDR, PUB_SET_NUMBER, &tPubSetTable[0])) { rt_err_set(ERR_CODE_SET_PUB, 0); GetDefPara((void *)psetbuf, PUB_SET_NUMBER, &tPubSetTable[0]); } else { rt_err_clr(ERR_CODE_SET_PUB, 0); } ptSet->section = (u8)psetbuf[SET_SECTION].ff; // 定值区 #endif // 公共定值 ptSet->ct_one = (u32)psetbuf[SET_BHCT1_A].ff; // CT额定一次值 ptSet->ct_two = (u32)psetbuf[SET_BHCT2_A].ff; // CT额定二次值 ptSet->ct0_one = (u32)psetbuf[SET_I0CT1_A].ff; // 零序CT额定一次值 ptSet->ct0_two = (u32)psetbuf[SET_I0CT2_A].ff; // 零序CT额定二次值 ptSet->a_pt_one = (u32)psetbuf[SET_APT1_U].ff; // 电源侧PT额定一次值 ptSet->a_pt_two = (u32)psetbuf[SET_APT2_U].ff; // 电源侧PT额定二次值 ptSet->b_pt_one = (u32)psetbuf[SET_BPT1_U].ff; // 负荷侧PT额定一次值 ptSet->b_pt_two = (u32)psetbuf[SET_BPT2_U].ff; // 负荷侧PT额定二次值 ptSet->a_side_pt_type = (u8)psetbuf[SET_PPT_TYPE].ff; // A侧PT接线方式 ptSet->b_side_pt_type = (u8)psetbuf[SET_LPT_TYPE].ff; // B侧PT接线方式 ptSet->bTT_EDIT_YB = ((WORD)psetbuf[SET_EDIT_PAR_YB].ff == 1) ? true : false; // 远程运维投入 ptSet->pt_rate = 10; // 10KV,一次值单位为KV /* 非电量 */ for (i = 0; i < 6; i++) { ptSet->bTT_FDLGj[i] = ((WORD)psetbuf[SET_FDL1_TT + i].ff == 1) ? true : false; ptSet->bTT_FDLTz[i] = ((WORD)psetbuf[SET_FDL1_TT + i].ff == 2) ? true : false; ptSet->dTFDL[i] = GetSetTIME(psetbuf[SET_FDL1_T + i].ff); } #ifdef VOLT_ADAPTIVE_FACTOR ptSet->bTT_AdaptiveFactor = (((WORD)psetbuf[SET_ADAPTIVEFACTOR].ff == 1) ? true : false); // 投退自适应电压系数 #endif #ifdef FUNC_SET_FA_JS ptSet->dT_FA_JS = GetSetTIME(psetbuf[SET_FA_JS].ff); // FA合闸解锁时间 #endif ptSet->dT_tq_fh = GetSetTIME(psetbuf[SET_TQ_FH].ff); // 同期判断返回时间 fUn = ptSet->a_pt_two; // 额定电压 #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ECZD_2020 || defined GD_AREA_ZHONGSHAN_2020 // 中山局将此定值放至公共定值 for (sw = 0; sw < SWITCH_NUM_MAX; sw++) { ptSet->tSwSet[sw].bTT_KZHL = (((WORD)psetbuf[SET_TT_KZHL].ff == 1) ? true : false); // 控制回路 #ifdef YF_TQ_JL_TY_PUBLIC ptSet->tSwSet[sw].bTT_BH_ALL_YB = (((WORD)psetbuf[SET_BH_YB].ff == 0) ? true : false); // 停用压板 #endif } #endif for (i = 0; i < VOL_NUMBER; i++) { VOL_SET *pvol = &ptSet->tVolSet[i]; // 电压定值 含 过电压、低电压、电源有压，电源无压 U0告警 float fKU1; if (i == VOL_GDY_Uab1 || i == VOL_DDY_Uab1) { fKU1 = fKU[PUB_AC_UAB1]; } else if (i == VOL_GDY_Ubc1 || i == VOL_DDY_Ubc1) { fKU1 = fKU[PUB_AC_UBC1]; } else if (i == VOL_GDY_Uca1 || i == VOL_DDY_Uca1) { fKU1 = fKU[PUB_AC_UCA1]; } else if (i == VOL_GDY_Uab2 || i == VOL_DDY_Uab2) { fKU1 = fKU[PUB_AC_UAB2]; } else if (i == VOL_GDY_Ubc2 || i == VOL_DDY_Ubc2) { fKU1 = fKU[PUB_AC_UBC2]; } else if (i == VOL_GDY_Uca2 || i == VOL_DDY_Uca2) { fKU1 = fKU[PUB_AC_UCA2]; } #if (0) // 计算PT1、PT2定值 else if (i == VOL_YY_POW1 || i == VOL_WY_POW1) { fKU1 = fKU[PUB_AC_US1]; } else if (i == VOL_YY_POW2 || i == VOL_WY_POW2) { fKU1 = fKU[PUB_AC_US2]; } #endif else { fKU1 = 0; } // 线路电压鉴别 if (i == VOL_YY_POW1 || i == VOL_YY_POW2) { pvol->dUVol = GetSetSQR(psetbuf[SET_YY_U].ff, fKU1); // 有压定值 pvol->dUVol_fh = _Mul_Div_U(pvol->dUVol, 96, 100); // 0.96=0.98*0.98 pvol->dTVol = GetSetTIME(psetbuf[SET_YY_T].ff); pvol->bTT = ((((WORD)psetbuf[SET_YY_TT].ff) == 1) ? true : false); } if (i == VOL_WY_POW1 || i == VOL_WY_POW2) { pvol->dUVol = GetSetSQR(psetbuf[SET_WY_U].ff, fKU1); // 无压定值 pvol->dUVol_fh = _Mul_Div_U(pvol->dUVol, 104, 100); // 1.04=1.02*1.02 pvol->dTVol = GetSetTIME(psetbuf[SET_YY_T].ff); pvol->bTT = ((((WORD)psetbuf[SET_WY_TT].ff) == 1) ? true : false); } // 电压越限 if (i == VOL_GDY_Uab1 || i == VOL_GDY_Ubc1 || i == VOL_GDY_Uca1 || i == VOL_GDY_Uab2 || i == VOL_GDY_Ubc2 || i == VOL_GDY_Uca2) { pvol->dUVol = GetSetSQR(psetbuf[SET_GDY_U].ff, fKU1); // 过电压定值 pvol->dUVol_fh = _Mul_Div_U(pvol->dUVol, 96, 100); // 0.96=0.98*0.98 pvol->dTVol = GetSetTIME(psetbuf[SET_GDY_T].ff); pvol->bTT = ((((WORD)psetbuf[SET_GDY_TT].ff) == 1) ? true : false); } if (i == VOL_DDY_Uab1 || i == VOL_DDY_Ubc1 || i == VOL_DDY_Uca1 || i == VOL_DDY_Uab2 || i == VOL_DDY_Ubc2 || i == VOL_DDY_Uca2) { pvol->dUVol = GetSetSQR(psetbuf[SET_DDY_U].ff, fKU1); // 低电压定值 pvol->dUVol_fh = _Mul_Div_U(pvol->dUVol, 104, 100); // 1.04=1.02*1.02 pvol->dTVol = GetSetTIME(psetbuf[SET_DDY_T].ff); pvol->bTT = ((((WORD)psetbuf[SET_DDY_TT].ff) == 1) ? true : false); } if (i == VOL_DDY_DC1) { pvol->dUVol = (DWORD)(psetbuf[SET_DC1GJ_U].ff * Q16_BASE); // 直流电压1告警定值 pvol->dUVol_fh = pvol->dUVol * 98 / 100; pvol->dTVol = GetSetTIME(psetbuf[SET_DC1GJ_T].ff); pvol->bTT = ((((WORD)psetbuf[SET_DC1GJ_TT].ff) == 1) ? true : false); } if (i == VOL_DDY_DC2) { pvol->dUVol = (DWORD)(psetbuf[SET_DC2GJ_U].ff * Q16_BASE); // 直流电压2告警定值 pvol->dUVol_fh = pvol->dUVol * 98 / 100; pvol->dTVol = GetSetTIME(psetbuf[SET_DC2GJ_T].ff); pvol->bTT = ((((WORD)psetbuf[SET_DC2GJ_TT].ff) == 1) ? true : false); } } #ifdef CUSTOMIZE_BZT // 备自投 ptSet->tVolLostSet.dUVol = GetSetSQR(psetbuf[SET_LOST_U].ff, fKU[PUB_AC_UAB1]); ptSet->tVolLostSet.dUVol_fh = _Mul_Div_U(ptSet->tVolLostSet.dUVol, 96, 100); // 0.96=0.98*0.98 ptSet->tVolLostSet.dTVol = GetSetTIME(psetbuf[SET_LOST_T].ff); ptSet->tVolLostSet.bTT = ((((WORD)psetbuf[SET_LOST_TT].ff) == 1) ? true : false); #endif ptSet->wZDJG = 15; // 定点保存数据间隔，默认15秒 ptSet->wDDJG = 15; #ifdef FUN_JDXX // 接地选线定值:系统接地方式 tJDXX_val[0].jd_type = ((WORD)psetbuf[SET_JDTYPE].ff); // 系统接地方式 #endif // if(bFirst) m_runsection = ptSet->section; // 第一次初始化，取公共定值终端运行区为整定区 /*读取开关定值*/ if (!ReadPara((void *)psetbuf, EEP_SET_ADDR + m_runsection * SETSIZE, SW_SET_NUMBER, &tSwSetTable[0])) { rt_err_set(ERR_CODE_SET, 0); GetDefPara((void *)psetbuf, SW_SET_NUMBER, &tSwSetTable[0]); } else { rt_err_clr(ERR_CODE_SET, 0); } // 开关定值 for (sw = 0; sw < SWITCH_NUM_MAX; sw++) { int ui_begin; OC_SET *poc; ui_begin = UI_SW_INDEX_BEGIN(sw); fKI = (float)(g_ui[ui_begin + SW_AC_IA].m2_factor_k) / 256.0; fKI0 = (float)(g_ui[ui_begin + SW_AC_I0].m2_factor_k) / 256.0; fresh_sw_ac_set(psetbuf, sw); // 将定值刷新到测量值中 /* 压板 */ { ptSet->tSwSet[sw].btt_gnyb_cg = (((WORD)psetbuf[SET_BH_YBTT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 常规保护投入 ptSet->tSwSet[sw].btt_gnyb_zdchz = (((WORD)psetbuf[SET_CHZ_YB + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 自动重合闸投入 ptSet->tSwSet[sw].btt_gnyb_fa = (((WORD)psetbuf[SET_FA_YBTT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 就地馈线自动化投入 ptSet->tSwSet[sw].btt_gnyb_dfa = (((WORD)psetbuf[SET_GOOSE_YBTT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 智能分布式投入 // ptSet->tSwSet[sw].btt_gnyb_jzs = (((WORD)psetbuf[SET_MODE_JZS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 集中模式压板 ptSet->tSwSet[sw].btt_gnyb_jzs = false; // 集中模式压板 ptSet->tSwSet[sw].btt_gnyb_tqhz = (((WORD)psetbuf[SET_TQ_YB + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 同期合闸投入 ptSet->tSwSet[sw].btt_gnyb_zdjl = (((WORD)psetbuf[SET_JL_YB + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 自动解列投入 ptSet->tSwSet[sw].btt_gnyb_xdljd = (((WORD)psetbuf[SET_XDL_YB + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 小电流接地保护投入 ptSet->tSwSet[sw].btt_gnyb_xldxgj = (((WORD)psetbuf[SET_LA_YB + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 线路断线告警投入 ptSet->tSwSet[sw].btt_gnyb_btdcd = (((WORD)psetbuf[SET_TRASW_YB + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 不停电传动投入 ptSet->tSwSet[sw].btt_yxyb_gnztt = (((WORD)psetbuf[SET_BH_YB + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 自动化功能总投退软压板 ptSet->tSwSet[sw].btt_yxyb_gnzck = (((WORD)psetbuf[SET_KZ_OUT_YB + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 自动化功能总出口软压板 ptSet->tSwSet[sw].btt_yxyb_chz = (((WORD)psetbuf[SET_RECS_YB + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 重合闸软压板 mode_total = (BYTE)(psetbuf[SET_BH_YBTT + sw * SW_SET_NUMBER].ff + psetbuf[SET_FA_YBTT + sw * SW_SET_NUMBER].ff + psetbuf[SET_GOOSE_YBTT + sw * SW_SET_NUMBER].ff); if (mode_total > 1) { // 当前只允许一种功能模式投入运行 ptSet->tSwSet[sw].btt_gnyb_cg = false; ptSet->tSwSet[sw].btt_gnyb_fa = false; ptSet->tSwSet[sw].btt_gnyb_dfa = false; } #ifdef YK_SOFT_YB // 遥控压板 ptSet->bTT_SOFT_YK_YB = ((WORD)psetbuf[SET_YK_YBTT + sw * SW_SET_NUMBER].ff == 1) ? true : false; #endif } // 过流类定值 { poc = &ptSet->tSwSet[sw].toc[BH_GL1]; // 过流1段 poc->bTz = (((WORD)psetbuf[SET_GL1_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false); poc->bGj = (((WORD)psetbuf[SET_GL1_TT + sw * SW_SET_NUMBER].ff == 0) ? false : true); poc->bDir = (((WORD)psetbuf[SET_GL1_DIR + sw * SW_SET_NUMBER].ff == 1) ? true : false); poc->dT = GetSetTIME(psetbuf[SET_GL1_T + sw * SW_SET_NUMBER].ff); #ifdef OCI_XB_0MS ptSet->tSwSet[sw].bTT_bh_xbbs = (((WORD)psetbuf[SET_BH_XBBS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 谐波闭锁 if ((psetbuf[SET_GL1_T + sw * SW_SET_NUMBER].ff == 0) && (ptSet->tSwSet[sw].bTT_bh_xbbs)) { poc->dT = GetSetTIME(0.026); } #endif poc->dI = GetSetSQR(psetbuf[SET_GL1_I + sw * SW_SET_NUMBER].ff, fKI); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值 poc = &ptSet->tSwSet[sw].toc[BH_GL2]; // 过流2段 poc->bTz = (((WORD)psetbuf[SET_GL2_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false); poc->bGj = (((WORD)psetbuf[SET_GL2_TT + sw * SW_SET_NUMBER].ff == 0) ? false : true); poc->bDir = (((WORD)psetbuf[SET_GL2_DIR + sw * SW_SET_NUMBER].ff == 1) ? true : false); poc->dT = GetSetTIME(psetbuf[SET_GL2_T + sw * SW_SET_NUMBER].ff); poc->dI = GetSetSQR(psetbuf[SET_GL2_I + sw * SW_SET_NUMBER].ff, fKI); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值 poc = &ptSet->tSwSet[sw].toc[BH_GL3]; // 过流3段 poc->bTz = (((WORD)psetbuf[SET_GL3_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false); poc->bGj = (((WORD)psetbuf[SET_GL3_TT + sw * SW_SET_NUMBER].ff == 0) ? false : true); poc->bDir = (((WORD)psetbuf[SET_GL3_DIR + sw * SW_SET_NUMBER].ff == 1) ? true : false); poc->dT = GetSetTIME(psetbuf[SET_GL3_T + sw * SW_SET_NUMBER].ff); poc->dI = GetSetSQR(psetbuf[SET_GL3_I + sw * SW_SET_NUMBER].ff, fKI); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值 poc = &ptSet->tSwSet[sw].toc[BH_LX1]; // 零序1段 poc->bTz = (((WORD)psetbuf[SET_LX1_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false); poc->bGj = (((WORD)psetbuf[SET_LX1_TT + sw * SW_SET_NUMBER].ff == 0) ? false : true); poc->bDir = false; poc->dT = GetSetTIME(psetbuf[SET_LX1_T + sw * SW_SET_NUMBER].ff); poc->dI = GetSetSQR(psetbuf[SET_LX1_I + sw * SW_SET_NUMBER].ff, fKI0); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); poc = &ptSet->tSwSet[sw].toc[BH_LX2]; // 零序2段 poc->bTz = (((WORD)psetbuf[SET_LX2_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false); poc->bGj = (((WORD)psetbuf[SET_LX2_TT + sw * SW_SET_NUMBER].ff == 0) ? false : true); poc->bDir = false; poc->dT = GetSetTIME(psetbuf[SET_LX2_T + sw * SW_SET_NUMBER].ff); poc->dI = GetSetSQR(psetbuf[SET_LX2_I + sw * SW_SET_NUMBER].ff, fKI0); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); poc = &ptSet->tSwSet[sw].toc[BH_LX3]; // 零序3段 poc->bTz = (((WORD)psetbuf[SET_LX3_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false); poc->bGj = (((WORD)psetbuf[SET_LX3_TT + sw * SW_SET_NUMBER].ff == 0) ? true : false); poc->bDir = false; poc->dT = GetSetTIME(psetbuf[SET_LX3_T + sw * SW_SET_NUMBER].ff); poc->dI = GetSetSQR(psetbuf[SET_LX3_I + sw * SW_SET_NUMBER].ff, fKI0); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); poc = &ptSet->tSwSet[sw].toc[BH_DLBS]; // 常规保护大电流闭锁 poc->bGj = (((WORD)psetbuf[SET_BH_DLBS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); poc->bTz = (((WORD)psetbuf[SET_BH_DLBS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); poc->dI = GetSetSQR(psetbuf[SET_BH_DLBS_I + sw * SW_SET_NUMBER].ff, fKI); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值 poc = &ptSet->tSwSet[sw].toc[BH_GLJS]; // 后加速，固定为过流1段定值 poc->bTz = (((WORD)psetbuf[SET_GLJS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); poc->bDir = false; poc->bGj = false; poc->dT = GetSetTIME(psetbuf[SET_GLJS_T + sw * SW_SET_NUMBER].ff); if (GetSetSQR(psetbuf[SET_GLJS_I + sw * SW_SET_NUMBER].ff, fKI)) poc->dI = GetSetSQR(psetbuf[SET_GLJS_I + sw * SW_SET_NUMBER].ff, fKI); else poc->dI = GetSetSQR(psetbuf[SET_GL1_I + sw * SW_SET_NUMBER].ff, fKI); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); ptSet->tSwSet[sw].dT_SpeedUp_Open = GetSetTIME(psetbuf[SET_JSOPEN_T + sw * SW_SET_NUMBER].ff);; // 加速段保护开放时间 poc = &ptSet->tSwSet[sw].toc[BH_LXJS]; // 零序加速段 poc->bTz = (((WORD)psetbuf[SET_GLJS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); poc->bGj = false; poc->bDir = false; poc->dT = GetSetTIME(psetbuf[SET_LXJS_T + sw * SW_SET_NUMBER].ff); if (GetSetSQR(psetbuf[SET_LXJS_I + sw * SW_SET_NUMBER].ff, fKI0)) poc->dI = GetSetSQR(psetbuf[SET_LXJS_I + sw * SW_SET_NUMBER].ff, fKI0); else poc->dI = GetSetSQR(psetbuf[SET_LX1_I + sw * SW_SET_NUMBER].ff, fKI0); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); poc = &ptSet->tSwSet[sw].toc[BH_OVI_ZZ]; // 电流重载 poc->bGj = (((WORD)psetbuf[SET_DLZZ_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); poc->bDir = false; poc->bTz = false; poc->dT = GetSetTIME(psetbuf[SET_DLZZ_T + sw * SW_SET_NUMBER].ff); poc->dI = GetSetSQR(psetbuf[SET_DLZZ_I + sw * SW_SET_NUMBER].ff, fKI); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值 poc = &ptSet->tSwSet[sw].toc[BH_OVI_GZ]; // 电流过载 poc->bGj = (((WORD)psetbuf[SET_DLGZ_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); poc->bDir = false; poc->bTz = false; poc->dT = GetSetTIME(psetbuf[SET_DLGZ_T + sw * SW_SET_NUMBER].ff); poc->dI = GetSetSQR(psetbuf[SET_DLGZ_I + sw * SW_SET_NUMBER].ff, fKI); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值 poc = &ptSet->tSwSet[sw].toc[BH_OVI]; // 电流越限 poc->bGj = (((WORD)psetbuf[SET_DLYX_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); poc->bDir = false; poc->bTz = false; poc->dT = GetSetTIME(psetbuf[SET_DLYX_T + sw * SW_SET_NUMBER].ff); poc->dI = GetSetSQR(psetbuf[SET_DLYX_I + sw * SW_SET_NUMBER].ff, fKI); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值 poc = &ptSet->tSwSet[sw].toc[BH_OVI0]; // 零序电流越限 poc->bGj = (((WORD)psetbuf[SET_LXYX_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); poc->bDir = false; poc->bTz = false; poc->dT = GetSetTIME(psetbuf[SET_LXYX_T + sw * SW_SET_NUMBER].ff); poc->dI = GetSetSQR(psetbuf[SET_LXYX_I + sw * SW_SET_NUMBER].ff, fKI0); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值 } // 零序过电压投入 { ptSet->tSwSet[sw].bTT_3U0Tz = (((WORD)psetbuf[SET_3U0_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false); ptSet->tSwSet[sw].bTT_3U0Gj = (((WORD)psetbuf[SET_3U0_TT + sw * SW_SET_NUMBER].ff == 0) ? false : true); ptSet->tSwSet[sw].dBHOverU0 = GetSetSQR(psetbuf[SET_U0_U + sw * SW_SET_NUMBER].ff, fKU[PUB_AC_U01]); ptSet->tSwSet[sw].dBHOverU0_fh = _Mul_Div_U(ptSet->tSwSet[sw].dBHOverU0, 96, 100); // 0.96=0.98*0.98 ptSet->tSwSet[sw].dBHTOverU0 = GetSetTIME(psetbuf[SET_U0_T + sw * SW_SET_NUMBER].ff); } // 智能分布式定值 { GOC_SET *poc = &ptSet->tSwSet[sw].tGocSet; poc->bKg_mainloop = false; #if defined GD_AREA_ECZD_2020 poc->bTT_gooseFA = true; // 默认智能分布式投入 ptSet->tSwSet[sw].bTT_goose_xbbs = false; poc->bTT_DIR = false; // 合环运行 poc->bFA_slow = (((WORD)psetbuf[SET_GOOSE_FA_TYPE + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 速动/缓动 #if defined GD_AREA_ZHONGSHAN // 中山要求联络开关固定 poc->bsw_sd = (((WORD)psetbuf[SET_GOOSE_FTU_TYPE + sw * SW_SET_NUMBER].ff == 0) ? true : false); // 首端 poc->bsw_fz = (((WORD)psetbuf[SET_GOOSE_FTU_TYPE + sw * SW_SET_NUMBER].ff == 2) ? true : false); // 末端 poc->bsw_ll = (((WORD)psetbuf[SET_GOOSE_FTU_TYPE + sw * SW_SET_NUMBER].ff == 3) ? true : false); // 联络 #else poc->bsw_sd = (((WORD)psetbuf[SET_GOOSE_FTU_TYPE + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 首端 poc->bsw_fz = (((WORD)psetbuf[SET_GOOSE_FTU_TYPE + sw * SW_SET_NUMBER].ff == 2) ? true : false); // 末端 poc->bsw_ll = false; // 非中山局，联络开关不固定 #endif poc->dIgl = GetSetSQR(psetbuf[SET_GOOSET_GL_I + sw * SW_SET_NUMBER].ff, fKI); // 过流定值 poc->dIgl_fh = _Mul_Div_U(poc->dIgl, 96, 100); // 过流定值返回值 poc->dTgl = GetSetTIME(psetbuf[SET_GOOSET_GL_T + sw * SW_SET_NUMBER].ff); poc->dIlx = GetSetSQR(psetbuf[SET_GOOSET_LX_I + sw * SW_SET_NUMBER].ff, fKI0); // 零序定值 poc->dIlx_fh = _Mul_Div_U(poc->dIlx, 96, 100); // 零序定值返回值 poc->dTlx = GetSetTIME(psetbuf[SET_GOOSET_GL_T + sw * SW_SET_NUMBER].ff); // 2020指导意见默认只有一个时限,共用 "故障跳闸时限" #if defined GD_AREA_ZHONGSHAN_2020 poc->dIgl2 = GetSetSQR(psetbuf[SET_GOOSET_GL2_I + sw * SW_SET_NUMBER].ff, fKI); // 过流2定值 poc->dIgl2_fh = _Mul_Div_U(poc->dIgl2, 96, 100); // 返回值 poc->dTgl2 = GetSetTIME(psetbuf[SET_GOOSET_GL2_T + sw * SW_SET_NUMBER].ff); poc->dTlx = GetSetTIME(psetbuf[SET_GOOSET_LX_T + sw * SW_SET_NUMBER].ff); // 中山分开零序延时 poc->bKg_mainloop = (((WORD)psetbuf[SET_GOOSE_KG_TYPE + sw * SW_SET_NUMBER].ff == 0) ? true : false); // 主环开关 poc->dTgzgl = GetSetTIME(psetbuf[SET_GOOSET_GZGL_T + sw * SW_SET_NUMBER].ff); // 故障隔离时间 #endif poc->dTsdlost = GetSetTIME(psetbuf[SET_GOOSET_SDLOST_T + sw * SW_SET_NUMBER].ff); // 首端失压时间 poc->bTT_sdlost = (((WORD)psetbuf[SET_GOOSE_SDLOSTVOL_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 首端失压分闸 poc->bTT_ll = (((WORD)psetbuf[SET_GOOSE_LL_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 联络合闸 poc->dTll = GetSetTIME(psetbuf[SET_GOOSET_LL_T + sw * SW_SET_NUMBER].ff); // 联络合闸时间 // poc->bTT_DIR = (((WORD)psetbuf[SET_GOOSET_DIR_TT+sw*SW_SET_NUMBER ].ff == 1 )?true:false); // 合环运行 // poc->bTT_mxTfz = (((WORD)psetbuf[SET_GOOSET_MXTFZ_TT+sw*SW_SET_NUMBER ].ff == 1 )?true:false); // 母线故障跳分支 #else poc->bTT_gooseFA = (((WORD)psetbuf[SET_GOOSE_FA_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 智能分布式投退 poc->bFA_slow = (((WORD)psetbuf[SET_GOOSE_FA_TYPE + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 速动/缓动 poc->bsw_sd = (((WORD)psetbuf[SET_GOOSE_FTU_TYPE + sw * SW_SET_NUMBER].ff == 0) ? true : false); // 首端 poc->bsw_fz = (((WORD)psetbuf[SET_GOOSE_FTU_TYPE + sw * SW_SET_NUMBER].ff == 2) ? true : false); // 末端 poc->bsw_ll = (((WORD)psetbuf[SET_GOOSE_FTU_TYPE + sw * SW_SET_NUMBER].ff == 3) ? true : false); // 联络 poc->dIgl = GetSetSQR(psetbuf[SET_GOOSET_GL_I + sw * SW_SET_NUMBER].ff, fKI); // 过流定值 poc->dIgl_fh = _Mul_Div_U(poc->dIgl, 96, 100); // 过流定值返回值 poc->dTgl = GetSetTIME(psetbuf[SET_GOOSET_GL_T + sw * SW_SET_NUMBER].ff); #ifdef GD_AREA_ZHONGSHAN poc->dIgl2 = GetSetSQR(psetbuf[SET_GOOSET_GL2_I + sw * SW_SET_NUMBER].ff, fKI); // 过流2定值 poc->dIgl2_fh = _Mul_Div_U(poc->dIgl2, 96, 100); // 返回值 poc->dTgl2 = GetSetTIME(psetbuf[SET_GOOSET_GL2_T + sw * SW_SET_NUMBER].ff); #endif poc->dIlx = GetSetSQR(psetbuf[SET_GOOSET_LX_I + sw * SW_SET_NUMBER].ff, fKI0); // 零序定值 poc->dIlx_fh = _Mul_Div_U(poc->dIlx, 96, 100); // 零序定值返回值 poc->dTlx = GetSetTIME(psetbuf[SET_GOOSET_LX_T + sw * SW_SET_NUMBER].ff); poc->dTsdlost = GetSetTIME(psetbuf[SET_GOOSET_SDLOST_T + sw * SW_SET_NUMBER].ff); // 首端失压时间 poc->bTT_sdlost = (((WORD)psetbuf[SET_GOOSE_SDLOSTVOL_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 首端失压分闸 poc->dTgzgl = GetSetTIME(psetbuf[SET_GOOSET_GZGL_T + sw * SW_SET_NUMBER].ff); // 故障隔离时间 poc->bTT_ll = (((WORD)psetbuf[SET_GOOSE_LL_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 联络合闸 poc->dTll = GetSetTIME(psetbuf[SET_GOOSET_LL_T + sw * SW_SET_NUMBER].ff); // 联络合闸时间 poc->bTT_DIR = (((WORD)psetbuf[SET_GOOSET_DIR_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 合环运行 poc->bTT_mxTfz = (((WORD)psetbuf[SET_GOOSET_MXTFZ_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 母线故障跳分支 ptSet->tSwSet[sw].d_goose_xbcoe = GetSetSQR(psetbuf[SET_GOOSE_XBCOE + sw * SW_SET_NUMBER].ff / 100, 256); ptSet->tSwSet[sw].bTT_goose_xbbs = ((DWORD)psetbuf[SET_GOOSE_XBBS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; #ifdef GOOSE_NETTYPE_SET g_goose_net_type = (WORD)psetbuf[SET_GOOSE_NET_TYPE].ff; #endif #endif } // 重合闸 { bool bch1, bch2, bch3; bch1 = (((WORD)psetbuf[SET_CH1_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 一次重合闸 bch2 = (((WORD)psetbuf[SET_CH2_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 二次重合闸 #ifdef DISP_SET_CH_T3 bch3 = (((WORD)psetbuf[SET_CH3_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 多次重合闸 #else bch3 = false; #endif ptSet->tSwSet[sw].bTT_CHZ = bch1 || bch2 || bch3; ptSet->tSwSet[sw].bTT_chz_tq = (((WORD)psetbuf[SET_CH_TQ + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 重合检同期 ptSet->tSwSet[sw].bTT_chz_wy = (((WORD)psetbuf[SET_CH_WY + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 重合检无压 ptSet->tSwSet[sw].bTT_chz_wy_type = (WORD)psetbuf[SET_CH_WY_TYPE + sw * SW_SET_NUMBER].ff; // 重合检无压方式 0母有线无 1母无线有 2两侧无压 ptSet->tSwSet[sw].bTT_TTCH_TT = (((WORD)psetbuf[SET_TTCH_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 偷跳启动重合 ptSet->tSwSet[sw].dT_chz[0] = GetSetTIME(psetbuf[SET_CH_T1 + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_chz[1] = GetSetTIME(psetbuf[SET_CH_T2 + sw * SW_SET_NUMBER].ff); #ifdef DISP_SET_CH_T3 ptSet->tSwSet[sw].dT_chz[2] = GetSetTIME(psetbuf[SET_CH_T3 + sw * SW_SET_NUMBER].ff); #else ptSet->tSwSet[sw].dT_chz[2] = 0; #endif ptSet->tSwSet[sw].dT_ch_gl_tt = (((WORD)psetbuf[SET_CH_GL_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); ptSet->tSwSet[sw].dT_ch_jd_tt = (((WORD)psetbuf[SET_CH_JD_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); #ifdef FUNC_CHZ_CHARGE_TIME ptSet->tSwSet[sw].dT_chz_cd = GetSetTIME(psetbuf[SET_CHZCD + sw * SW_SET_NUMBER].ff); // 重合闸充电时间 #else ptSet->tSwSet[sw].dT_chz_cd = (bch2 || bch3) ? GetSetTIME(psetbuf[SET_CHZCD_1 + sw * SW_SET_NUMBER].ff) : GetSetTIME(psetbuf[SET_CHZCD_2 + sw * SW_SET_NUMBER].ff); // 投一次重合闸，充电时间15秒，投二次重合闸，充电180秒 #endif ptSet->tSwSet[sw].dT_chz_bs = GetSetTIME(psetbuf[SET_CHBS_T + sw * SW_SET_NUMBER].ff); #if (0) /* 直接使用重合闸充电时间 */ ptSet->tSwSet[sw].dT_chz_ok = (bch2 || bch3) ? ptSet->tSwSet[sw].dT_chz_ok : T_1s * 15; // 只投一次重合闸的时候，重合闸确认时间强制为15S 2020-7-25 #else ptSet->tSwSet[sw].dT_chz_ok = ptSet->tSwSet[sw].dT_chz_cd; // 直接使用重合闸充电时间 #endif if (bch3) ptSet->tSwSet[sw].d_chz_times = 3; else if (bch2) ptSet->tSwSet[sw].d_chz_times = 2; else ptSet->tSwSet[sw].d_chz_times = 1; ptSet->tSwSet[sw].dU_chz_deltaU = GetSetNormal(0.2 * fUn, fKU[PUB_AC_UAB1]); // 0.2 倍的额定值 ptSet->tSwSet[sw].dA_chz_deltaAng = GetSetNormal(30, 65536); // 30度压差 ptSet->tSwSet[sw].dU_chz_wy = GetSetSQR(0.4 * fUn, fKU[PUB_AC_UAB1]); // 0.4 倍的额定值 #ifdef FUNC_TQ_YY ptSet->tSwSet[sw].dU_chz_yy = GetSetSQR(0.8 * fUn, fKU[PUB_AC_UAB1]); // 0.8 倍的额定值 #else ptSet->tSwSet[sw].dU_chz_yy = GetSetSQR(0.5 * fUn, fKU[PUB_AC_UAB1]); // 0.5 倍的额定值 #endif } // 反时限定值 { ptSet->tSwSet[sw].bTT_FSX = (((WORD)psetbuf[SET_FSX_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 反时限投退 ptSet->tSwSet[sw].dIglfsx = GetSetNormal(psetbuf[SET_FSX_I + sw * SW_SET_NUMBER].ff, fKI); // 反时限基准值 ptSet->tSwSet[sw].dTglfsx = GetSetTIME(psetbuf[SET_FSX_Tp + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].wFsxType = (WORD)psetbuf[SET_FSX_TYPE + sw * SW_SET_NUMBER].ff; ptSet->tSwSet[sw].dIglfsx098 = _Mul_Div_U(ptSet->tSwSet[sw].dIglfsx, 96, 100); // 反时限过流*0.96 ptSet->tSwSet[sw].dIglfsx105 = _Mul_Div_U(ptSet->tSwSet[sw].dIglfsx, 105, 100); // 反时限过流*1.05*1.05 ptSet->tSwSet[sw].dRVS_MIN_T = GetSetTIME(0.025); // 反时限最短时间 ptSet->tSwSet[sw].dRVS_MAX_T = GetSetTIME(9999); // 反时限最长时间 } ptSet->tSwSet[sw].d_bh_xbcoe = GetSetSQR(psetbuf[SET_BH_XBCOE + sw * SW_SET_NUMBER].ff, 256); // 二次谐波闭锁系数 ptSet->tSwSet[sw].bTT_bh_ptdx = (((WORD)psetbuf[SET_BH_PTDX + sw * SW_SET_NUMBER].ff == 1) ? true : false); // PT断线检查 ptSet->tSwSet[sw].bTT_bh_xbbs = (((WORD)psetbuf[SET_BH_XBBS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 谐波闭锁 // 同期 { ptSet->tSwSet[sw].dU_tq_deltaU = GetSetNormal(psetbuf[SET_TQ_U + sw * SW_SET_NUMBER].ff * fUn / 100, fKU[PUB_AC_UAB1]); ptSet->tSwSet[sw].dA_tq_delatA = GetSetNormal(psetbuf[SET_TQ_ANG + sw * SW_SET_NUMBER].ff, 65536); ptSet->tSwSet[sw].dF_tq_deltaF = GetSetNormal(psetbuf[SET_TQ_F + sw * SW_SET_NUMBER].ff, 65536); ptSet->tSwSet[sw].dT_tq = GetSetTIME(1.0); // 同期默认时间1秒 } // 电压解列 { ptSet->tSwSet[sw].bTT_jl_dy = (((WORD)psetbuf[SET_VOLJL_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); ptSet->tSwSet[sw].dT_jl_gddy = GetSetTIME(psetbuf[SET_GDYJL_T + sw * SW_SET_NUMBER].ff); // 过低电压 ptSet->tSwSet[sw].dT_jl_ddy = GetSetTIME(psetbuf[SET_DYJL_T + sw * SW_SET_NUMBER].ff); // 低电压 ptSet->tSwSet[sw].dT_jl_gdy = GetSetTIME(psetbuf[SET_GYJL_T + sw * SW_SET_NUMBER].ff); // 高电压 ptSet->tSwSet[sw].dT_jl_ggdy = GetSetTIME(0.2); // 过高电压 ptSet->tSwSet[sw].dU_jl_gdy = GetSetSQR(psetbuf[SET_GYJL_U + sw * SW_SET_NUMBER].ff * fUn / 100, fKU[PUB_AC_UAB1]); // 0.4 倍的额定值 ptSet->tSwSet[sw].dU_jl_ddy = GetSetSQR(psetbuf[SET_DYJL_U + sw * SW_SET_NUMBER].ff * fUn / 100, fKU[PUB_AC_UAB1]); // 0.4 倍的额定值 ptSet->tSwSet[sw].dU_jl_ggdy = GetSetSQR(1.35 * fUn, fKU[PUB_AC_UAB1]); // 1.35 倍的额定值 ptSet->tSwSet[sw].dU_jl_gddy = GetSetSQR(psetbuf[SET_GDYJL_U + sw * SW_SET_NUMBER].ff * fUn / 100, fKU[PUB_AC_UAB1]); // 0.5 倍的额定值 ptSet->tSwSet[sw].dU_jl_gddy_fh = _Mul_Div_U(ptSet->tSwSet[sw].dU_jl_gddy, 104, 100); // 1.02的返回值 ptSet->tSwSet[sw].dU_jl_ddy_fh = _Mul_Div_U(ptSet->tSwSet[sw].dU_jl_ddy, 104, 100); // 1.02的返回值 ptSet->tSwSet[sw].dU_jl_gdy_fh = _Mul_Div_U(ptSet->tSwSet[sw].dU_jl_gdy, 96, 100); // 0.98的返回值 ptSet->tSwSet[sw].dU_jl_ggdy_fh = _Mul_Div_U(ptSet->tSwSet[sw].dU_jl_ggdy, 96, 100); // 0.98的返回值 #ifdef PRO_AL_LOCK_HZ ptSet->tSwSet[sw].dU_reclose_gdy_fh = _Mul_Div_U(ptSet->tSwSet[sw].dU_jl_gdy, 104, 100); // 1.04的高电压解列值为返回值 ptSet->tSwSet[sw].dU_reclose_ddy_fh = _Mul_Div_U(ptSet->tSwSet[sw].dU_jl_ddy, 96, 100); // 0.96的低电压解列值为返回值 #endif } // 频率解列 { ptSet->tSwSet[sw].bTT_jl_hz = (((WORD)psetbuf[SET_PLJL_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); ptSet->tSwSet[sw].dT_jl_ghz = GetSetTIME(psetbuf[SET_GPJL_T + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_jl_dhz = GetSetTIME(psetbuf[SET_DPJL_T + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_jl_lowhz = GetSetTIME(0.2); // 频率过低 ptSet->tSwSet[sw].dU_jl_ghz = GetSetNormal(psetbuf[SET_GPJL_HZ + sw * SW_SET_NUMBER].ff, 65536); ptSet->tSwSet[sw].dU_jl_dhz = GetSetNormal(psetbuf[SET_DPJL_HZ + sw * SW_SET_NUMBER].ff, 65536); ptSet->tSwSet[sw].dU_jl_lowhz = GetSetNormal(47.0, 65536); ptSet->tSwSet[sw].dU_jl_dhz_fh = ptSet->tSwSet[sw].dU_jl_dhz + 1310; // 返回值小 0.02 ptSet->tSwSet[sw].dU_jl_lowhz_fh = ptSet->tSwSet[sw].dU_jl_lowhz + 1310; // 0.98的返回值 ptSet->tSwSet[sw].dU_jl_ghz_fh = ptSet->tSwSet[sw].dU_jl_ghz - 1310; // 0.98的返回值 } ptSet->tSwSet[sw].bTT_hcbs_dy = (((WORD)psetbuf[SET_DYJL_HCBS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 电压滑差投退 ptSet->tSwSet[sw].bTT_hcbs_hz = (((WORD)psetbuf[SET_DPJL_HCBS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 频率滑差投退 ptSet->tSwSet[sw].dhcbs_hz = GetSetNormal(psetbuf[SET_DPJL_HCBS_HZ + sw * SW_SET_NUMBER].ff, 65536); // 频率滑差定值 ptSet->tSwSet[sw].dhcbs_u = GetSetNormal(psetbuf[SET_DYJL_HCBS_U + sw * SW_SET_NUMBER].ff, fKU[PUB_AC_UAB1]); // 电压滑差定值 #ifdef XDL_ZT // 小电流接地 ptSet->tSwSet[sw].bTT_xdlgj = (((WORD)psetbuf[SET_XDL_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false || ((WORD)psetbuf[SET_XDL_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false); ptSet->tSwSet[sw].bTT_xdltz = (((WORD)psetbuf[SET_XDL_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false); if (ptSet->tSwSet[sw].bTT_xdlgj || ptSet->tSwSet[sw].bTT_xdltz) { ptSet->tSwSet[sw].bTT_xdlqd = (((WORD)psetbuf[SET_XDLQD_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); ptSet->bTT_xdl = true; } else { ptSet->tSwSet[sw].bTT_xdlqd = -1; } if (g_ui[UI_SW_INDEX(sw, SW_AC_I0)].chn_index == CFG_ADC_CHANNEL_ZERO) { ptSet->tSwSet[sw].dI_xdl_zt = -1; } else { // 定值由峰值改为有效值 // ptSet->tSwSet[sw].dI_xdl_zt = GetSetNormal(psetbuf[SET_XDL_I+sw*SW_SET_NUMBER].ff,1/(g_ui[UI_SW_INDEX(sw,SW_AC_I0)].e_factor0*1.4142)); ptSet->tSwSet[sw].dI_xdl_zt = GetSetNormal(psetbuf[SET_XDL_I + sw * SW_SET_NUMBER].ff, 1 / (g_ui[UI_SW_INDEX(sw, SW_AC_I0)].e_factor0)); ptSet->tSwSet[sw].dI_xdl_300ma = GetSetNormal(0.2, 1 / (g_ui[UI_SW_INDEX(sw, SW_AC_I0)].e_factor0)); // 200毫安，电流定值 } ptSet->tSwSet[sw].dI_xdl = GetSetSQR(psetbuf[SET_XDL_I + sw * SW_SET_NUMBER].ff, fKI0); // 过流定值 ptSet->tSwSet[sw].dI_xdl_fh = _Mul_Div_U(ptSet->tSwSet[sw].dI_xdl, 96, 100); #endif #ifdef FUNC_DRIVE ptSet->tSwSet[sw].btt_gnyb_btdcd = ((WORD)psetbuf[SET_XDL_YB + sw * SW_SET_NUMBER].ff == 1) ? true : false; // 不停电传动功能软压板 fresh_set_soe(EV_DRIVE, ptSet->tSwSet[sw].btt_gnyb_btdcd, bFirst, 0); ptSet->tSwSet[sw].dT_Drive_hz = GetSetTIME(psetbuf[SET_DRIVE_HZ_T + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_Drive_fz = GetSetTIME(psetbuf[SET_DRIVE_FZ_T + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_fz_end = GetSetTIME(psetbuf[SET_FZ_END_T + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_hz_end = GetSetTIME(psetbuf[SET_HZ_END_T].ff); #endif ptSet->tSwSet[sw].bTT_IBSCHZ = (((WORD)psetbuf[SET_CH_DLBS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); ptSet->tSwSet[sw].dIBSCHZ = GetSetSQR(psetbuf[SET_CH_DLBS_I + sw * SW_SET_NUMBER].ff, fKI); ptSet->tSwSet[sw].dT_chz_Topen = GetSetTIME(psetbuf[SET_CHZ_OPEN + sw * SW_SET_NUMBER].ff); // 重合闸开放时间，默认300秒 // FA { ptSet->tSwSet[sw].bTT_fa_poweron = ((DWORD)psetbuf[SET_P_YY_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_fa_lineon = ((DWORD)psetbuf[SET_L_YY_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_fa_poweroff = (BYTE)psetbuf[SET_P_WY_TT + sw * SW_SET_NUMBER].ff; ptSet->tSwSet[sw].bTT_fa_lineoff = (BYTE)psetbuf[SET_L_WY_TT + sw * SW_SET_NUMBER].ff; ptSet->tSwSet[sw].bTT_fa_Lostfz = ((DWORD)psetbuf[SET_LOSTFZ_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_fa_Icheck = ((DWORD)psetbuf[SET_GZCHECK_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_fa_gzTz = (((DWORD)psetbuf[SET_GZCHECK_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); #ifdef GD_AREA_ECZD_2020 // 2020-9-8 ptSet->tSwSet[sw].bTT_fa_scyy_bs = false; // 联络双侧有压闭锁自动合闸但不闭锁遥控合闸、电动合闸、手动合闸 ptSet->tSwSet[sw].bTT_fa_sfbs = true; // 默认手分闭锁 ptSet->tSwSet[sw].bTT_fa_gzbshz = true; // 默认合后故障闭锁合闸 ptSet->tSwSet[sw].bTT_fa_shbs = false; // 默认手合无压，闭锁分闸 ptSet->tSwSet[sw].bTT_FA = true; // 默认投入就地FA功能 ptSet->tSwSet[sw].bTT_fa_LL = ((DWORD)psetbuf[SET_SL_TT + sw * SW_SET_NUMBER].ff == 0) ? true : false; #else ptSet->tSwSet[sw].bTT_fa_scyy_bs = ((DWORD)psetbuf[SET_SCYY_BSHZ + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_fa_sfbs = ((DWORD)psetbuf[SET_SF_BSHZ + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_fa_gzbshz = ((DWORD)psetbuf[SET_GZBSHZ_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_fa_shbs = ((DWORD)psetbuf[SET_SH_BSFZ + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_fa_LL = ((DWORD)psetbuf[SET_SL_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false; ptSet->tSwSet[sw].bTT_FA = ((DWORD)psetbuf[SET_FA_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; #endif #if defined GD_AREA_HEYUAN_2021_2021 ptSet->tSwSet[sw].bTT_fa_LL = ((DWORD)psetbuf[SET_SL_TT + sw * SW_SET_NUMBER].ff == 0) ? true : false; #endif ptSet->tSwSet[sw].bTT_fa_gl2 = ((DWORD)psetbuf[SET_FA_GL2_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_fa_lx2 = ((DWORD)psetbuf[SET_FA_LX2_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_fa_bsTz = ((DWORD)psetbuf[SET_BSTZ_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_fa_cybs = ((DWORD)psetbuf[SET_CYBS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_fa_xbbs = ((DWORD)psetbuf[SET_FA_XBBS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_fa_U0Tz = ((DWORD)psetbuf[SET_U0TZ_TT + sw * SW_SET_NUMBER].ff == 2) ? true : false; ptSet->tSwSet[sw].bTT_fa_U0Gj = ((DWORD)psetbuf[SET_U0TZ_TT + sw * SW_SET_NUMBER].ff == 0) ? false : true; ptSet->tSwSet[sw].bTT_fa_ptdx = ((DWORD)psetbuf[SET_FA_PTDX + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_hzbs = (((DWORD)psetbuf[SET_HZBS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); ptSet->tSwSet[sw].dU_fa_YY = GetSetSQR(psetbuf[SET_FA_YY_U + sw * SW_SET_NUMBER].ff * fUn / 100, fKU[PUB_AC_UAB1]); // 0.4 倍的额定值 ptSet->tSwSet[sw].dU_fa_WY = GetSetSQR(psetbuf[SET_FA_WY_U + sw * SW_SET_NUMBER].ff * fUn / 100, fKU[PUB_AC_UAB1]); // 0.4 倍的额定值 ptSet->tSwSet[sw].dU_fa_YY_fh = _Mul_Div_U(ptSet->tSwSet[sw].dU_fa_YY, 96, 100); // 0.98的返回值 ptSet->tSwSet[sw].dU_fa_WY_fh = _Mul_Div_U(ptSet->tSwSet[sw].dU_fa_WY, 104, 100); // 1.02的返回值 ptSet->tSwSet[sw].dT_fa_YY = GetSetTIME(psetbuf[SET_FA_YY_T + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_fa_WY = GetSetTIME(psetbuf[SET_FA_WY_T + sw * SW_SET_NUMBER].ff); // ptSet->tSwSet[sw].dT_fa_YY = GetSetTIME(0.025);//有压延时默认25ms // ptSet->tSwSet[sw].dT_fa_WY = GetSetTIME(0.025);//无压延时默认25ms // FA负荷侧pt变比生效 ptSet->tSwSet[sw].dU_fa_YY2 = GetSetSQR(psetbuf[SET_FA_YY_U + sw * SW_SET_NUMBER].ff * ptSet->b_pt_two / 100, fKU[PUB_AC_UAB2]); // 0.4 倍的额定值 ptSet->tSwSet[sw].dU_fa_WY2 = GetSetSQR(psetbuf[SET_FA_WY_U + sw * SW_SET_NUMBER].ff * ptSet->b_pt_two / 100, fKU[PUB_AC_UAB2]); // 0.4 倍的额定值 ptSet->tSwSet[sw].dU_fa_YY2_fh = _Mul_Div_U(ptSet->tSwSet[sw].dU_fa_YY2, 96, 100); // 0.98的返回值 ptSet->tSwSet[sw].dU_fa_WY2_fh = _Mul_Div_U(ptSet->tSwSet[sw].dU_fa_WY2, 104, 100); // 1.02的返回值 ptSet->tSwSet[sw].dT_X = GetSetTIME(psetbuf[SET_FA_X_T + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_Y = GetSetTIME(psetbuf[SET_FA_Y_T + sw * SW_SET_NUMBER].ff); #ifdef GD_AREA_ZHONGSHAN_2020 ptSet->tSwSet[sw].dT_LL_CD = GetSetTIME(psetbuf[SET_FA_LL_CD_T + sw * SW_SET_NUMBER].ff); #endif ptSet->tSwSet[sw].dT_XL = GetSetTIME(psetbuf[SET_FA_XL_T + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_Z = GetSetTIME(psetbuf[SET_FA_Z_T + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_fa_bsTz = GetSetTIME(psetbuf[SET_FA_BSTZ_T + sw * SW_SET_NUMBER].ff); #ifdef FA_OC_COUNT ptSet->tSwSet[sw].bTT_fa_oc_count = (((DWORD)psetbuf[SET_FA_OC_COUNT_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); ptSet->tSwSet[sw].fa_oc_count_m = ((DWORD)psetbuf[SET_FA_OC_COUNT_M + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].fa_oc_conut_time = GetSetTIME(psetbuf[SET_FA_OC_COUNT_T + sw * SW_SET_NUMBER].ff); // ((WORD)psetbuf[SET_FA_OC_COUNT_T+sw*SW_SET_NUMBER].ff); if (ptSet->tSwSet[sw].fa_oc_count_m == 0 || ptSet->tSwSet[sw].fa_oc_conut_time == 0) ptSet->tSwSet[sw].bTT_fa_oc_count = FALSE; #endif ptSet->tSwSet[sw].d_fa_xbcoe = GetSetSQR(psetbuf[SET_FA_XBCOE + sw * SW_SET_NUMBER].ff, 256); ptSet->tSwSet[sw].dU_OverU0 = GetSetSQR(psetbuf[SET_FA_U0_U + sw * SW_SET_NUMBER].ff, fKU[PUB_AC_U01]); // ptSet->tSwSet[sw].dU_OverU0_fh = _Mul_Div_U(ptSet->tSwSet[sw].dU_OverU0, 96, 100); ptSet->tSwSet[sw].dT_OverU0 = GetSetTIME(psetbuf[SET_FA_U0_T + sw * SW_SET_NUMBER].ff); #if defined GD_AREA_ECZD_2020 ptSet->tSwSet[sw].dU_UF = GetSetSQR(0.20 * fUn, fKU[PUB_AC_UAB1]); // 瞬压定值固定取20%额定值 ptSet->tSwSet[sw].dU_UF2 = GetSetSQR(0.20 * ptSet->b_pt_two, fKU[PUB_AC_UAB2]); // 瞬压定值固定取20%额定值 #else ptSet->tSwSet[sw].dU_UF = GetSetSQR(0.25 * fUn, fKU[PUB_AC_UAB1]); // 瞬压定值固定取25%额定值 ptSet->tSwSet[sw].dU_UF2 = GetSetSQR(0.25 * ptSet->b_pt_two, fKU[PUB_AC_UAB2]); // 瞬压定值固定取25%额定值 #endif ptSet->tSwSet[sw].hzbstimes = ((DWORD)psetbuf[SET_HZBS_TIMES + sw * SW_SET_NUMBER].ff); // psetbuf[SET_HZBS_TIMES+sw*SW_SET_NUMBER].ff) ptSet->tSwSet[sw].dT_hzbs = GetSetTIME(psetbuf[SET_HZBS_T + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_wldz = GetSetSQR(psetbuf[SET_FA_WLDZ].ff, fIn); poc = &ptSet->tSwSet[sw].toc[FA_GL]; // 相间故障 poc->bTz = ((((WORD)psetbuf[SET_GZCHECK_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false)); poc->bDir = false; poc->bGj = false; #if defined GD_AREA_ECZD_2020 poc->dT = GetSetTIME(psetbuf[SET_FA_GLI_T + sw * SW_SET_NUMBER].ff); #else poc->dT = GetSetTIME(psetbuf[SET_FA_GZTZ_T + sw * SW_SET_NUMBER].ff); #endif if (poc->dT < T_FA_TZ_MIN_TIME) poc->dT = T_FA_TZ_MIN_TIME; // 不小于20ms poc->dI = GetSetSQR(psetbuf[SET_FA_GL_I + sw * SW_SET_NUMBER].ff, fKI); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值 poc = &ptSet->tSwSet[sw].toc[FA_GL_II]; // 相间II段故障 poc->bTz = ((((WORD)psetbuf[SET_GZCHECK_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false)); poc->bDir = false; poc->bGj = false; #if defined GD_AREA_ECZD_2020 #ifdef GD_AREA_ZHONGSHAN_2020 if (ptSet->tSwSet[sw].bTT_fa_hjs) { poc->dT = GetSetTIME(psetbuf[SET_FA_GZTZ_T + sw * SW_SET_NUMBER].ff); } else { poc->dT = GetSetTIME(psetbuf[SET_FA_GLII_T + sw * SW_SET_NUMBER].ff); } ptSet->tSwSet[sw].dT_fa_ocing = GetSetTIME(psetbuf[SET_FA_GLII_T + sw * SW_SET_NUMBER].ff); #else poc->dT = GetSetTIME(psetbuf[SET_FA_GLII_T + sw * SW_SET_NUMBER].ff); #endif #else poc->dT = GetSetTIME(psetbuf[SET_FA_GZTZ_T + sw * SW_SET_NUMBER].ff); #endif if (poc->dT < T_FA_TZ_MIN_TIME) poc->dT = T_FA_TZ_MIN_TIME; // 不小于20ms #if defined GD_AREA_ECZD_2020 // 合后电流两段处理 poc->dI = GetSetSQR(psetbuf[SET_FA_GL_II + sw * SW_SET_NUMBER].ff, fKI); #else poc->bTz = false; poc->bDir = false; poc->bGj = false; poc->dI = false; #endif poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值 poc = &ptSet->tSwSet[sw].toc[FA_GL2]; // 相间告警 poc->bTz = false; poc->bDir = false; poc->bGj = (((WORD)psetbuf[SET_FA_GL2_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); poc->dT = GetSetTIME(psetbuf[SET_FA_GL2_T + sw * SW_SET_NUMBER].ff); poc->dI = GetSetSQR(psetbuf[SET_FA_GL2_I + sw * SW_SET_NUMBER].ff, fKI); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值 #ifdef GD_AREA_ECZD_2020 poc->dU = GetSetSQR(psetbuf[SET_FA_FHDDY + sw * SW_SET_NUMBER].ff * fUn / 100, fKU[PUB_AC_UAB1]); // 低电压定值 poc->dU_fh = _Mul_Div_U(poc->dU, 104, 100); // 返回值 poc->dU2 = GetSetSQR(psetbuf[SET_FA_FHFDY + sw * SW_SET_NUMBER].ff * fUn / 100, fKU[PUB_AC_UAB1]); // 负序电压值 poc->dU2_fh = _Mul_Div_U(poc->dU2, 96, 100); #endif poc = &ptSet->tSwSet[sw].toc[FA_DLBS]; poc->bTz = (((WORD)psetbuf[SET_DLBS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); poc->bDir = false; poc->bGj = false; poc->dT = GetSetTIME(0.00); // 大电流闭锁0毫秒 poc->dI = GetSetSQR(psetbuf[SET_FA_DLBS_I + sw * SW_SET_NUMBER].ff, fKI); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值 poc = &ptSet->tSwSet[sw].toc[FA_LX]; // 零序故障 poc->bTz = (((WORD)psetbuf[SET_GZCHECK_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); poc->bDir = false; poc->bGj = false; #if defined GD_AREA_ECZD_2020 #ifdef GD_AREA_ZHONGSHAN_2020 if (ptSet->tSwSet[sw].bTT_fa_hjs) { poc->dT = GetSetTIME(psetbuf[SET_FA_GZTZ_T + sw * SW_SET_NUMBER].ff); } else { poc->dT = GetSetTIME(psetbuf[SET_FA_LX_T + sw * SW_SET_NUMBER].ff); } ptSet->tSwSet[sw].dT_fa_lxing = GetSetTIME(psetbuf[SET_FA_LX_T + sw * SW_SET_NUMBER].ff); #else poc->dT = GetSetTIME(psetbuf[SET_FA_LX_T + sw * SW_SET_NUMBER].ff); #endif #else poc->dT = GetSetTIME(psetbuf[SET_FA_GZTZ_T + sw * SW_SET_NUMBER].ff); #endif if (poc->dT < T_FA_TZ_MIN_TIME) poc->dT = T_FA_TZ_MIN_TIME; // 不小于20ms poc->dI = GetSetSQR(psetbuf[SET_FA_LX_I + sw * SW_SET_NUMBER].ff, fKI0); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值 poc = &ptSet->tSwSet[sw].toc[FA_LX2]; // 零序告警 poc->bTz = false; poc->bDir = false; poc->bGj = (((WORD)psetbuf[SET_FA_LX2_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); poc->dT = GetSetTIME(psetbuf[SET_FA_LX2_T + sw * SW_SET_NUMBER].ff); poc->dI = GetSetSQR(psetbuf[SET_FA_LX2_I + sw * SW_SET_NUMBER].ff, fKI0); poc->dI_fh = _Mul_Div_U(poc->dI, 96, 100); // 返回值 } #ifdef GD_AREA_ZHONGSHAN_2020 // 中山智能分布式手合故障处理 ptSet->tSwSet[sw].tGocSet.tOc[FAG_GL1] = ptSet->tSwSet[sw].toc[FA_GL]; // 使用相间故障1段定值 ptSet->tSwSet[sw].tGocSet.tOc[FAG_GL2] = ptSet->tSwSet[sw].toc[FA_GL2]; // 使用相间故障2段定值 ptSet->tSwSet[sw].tGocSet.tOc[FAG_LX] = ptSet->tSwSet[sw].toc[FA_LX]; // 使用FA零序定值 #endif { ptSet->tSwSet[sw].bTT_rcd_type[RECORD_TYPE_SD] = 1; ptSet->tSwSet[sw].bTT_rcd_type[RECORD_TYPE_QD] = 1; int l_data_ops = sw * SW_SET_NUMBER; ptSet->tSwSet[sw].bTT_rcd_type[RECORD_TYPE_GLGZ] = ((WORD)psetbuf[SET_WAVE_GLGZ + l_data_ops].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_rcd_type[RECORD_TYPE_LXGL] = ((WORD)psetbuf[SET_WAVE_LXGL + l_data_ops].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_rcd_type[RECORD_TYPE_LXDY] = ((WORD)psetbuf[SET_WAVE_LXDY + l_data_ops].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_rcd_type[RECORD_TYPE_XLSY] = ((WORD)psetbuf[SET_WAVE_XLSY + l_data_ops].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_rcd_type[RECORD_TYPE_LYTB] = ((WORD)psetbuf[SET_WAVE_LYTB + l_data_ops].ff == 1) ? true : false; ptSet->tSwSet[sw].dU_u0TB = (DWORD)(psetbuf[SET_U0_TB + sw * SW_SET_NUMBER].ff * 65536); ptSet->tSwSet[sw].bTT_rcd_type[RECORD_TYPE_LLTB] = ((WORD)psetbuf[SET_WAVE_LLTB + l_data_ops].ff == 1) ? true : false; ptSet->tSwSet[sw].dI_i0TB = (DWORD)(psetbuf[SET_I0_TB + sw * SW_SET_NUMBER].ff * 65536); ptSet->tSwSet[sw].bTT_rcd_type[RECORD_TYPE_CHZ] = ((WORD)psetbuf[SET_WAVE_CHZ + l_data_ops].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_rcd_type[RECORD_TYPE_TV] = ((WORD)psetbuf[SET_WAVE_TV + l_data_ops].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_rcd_type[RECORD_TYPE_FA] = ((WORD)psetbuf[SET_WAVE_FA + l_data_ops].ff == 1) ? true : false; #if defined FUN_JDXX || defined XDL_ZT ptSet->tSwSet[sw].bTT_rcd_type[RECORD_TYPE_XDLJD] = ((WORD)psetbuf[SET_WAVE_XDLJD + l_data_ops].ff == 1) ? true : false; #endif } // 其他定值 { ptSet->tSwSet[sw].bTT_Current_Inv = ((WORD)psetbuf[SET_CURRENT_INV_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_DIR_Inv = ((WORD)psetbuf[SET_DIR_INV_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_WCN = (((WORD)psetbuf[SET_TT_TWCN + sw * SW_SET_NUMBER].ff == 1) ? true : false); //&ptSet->bFUN_TWCN; //弹簧未储能 #ifndef GD_AREA_ZHONGSHAN ptSet->tSwSet[sw].bTT_KZHL = (((WORD)psetbuf[SET_TT_KZHL + sw * SW_SET_NUMBER].ff == 1) ? true : false); //&ptSet->bFUN_TWCN; //控制回路 #endif ptSet->tSwSet[sw].bTT_QYD_BS = ((WORD)psetbuf[SET_QYD_BS_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_Power_v2 = false; #ifdef CUSTOMIZE_BZT // 备自投 ptSet->tSwSet[sw].bBZT_TT = ((WORD)psetbuf[SET_BZT_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bFD = ((WORD)psetbuf[SET_BZT_FS + sw * SW_SET_NUMBER].ff == 0) ? true : false; ptSet->tSwSet[sw].bJX = ((WORD)psetbuf[SET_BZT_FS + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bAUTO = ((WORD)psetbuf[SET_BZT_FS + sw * SW_SET_NUMBER].ff == 2) ? true : false; // ptSet->tSwSet[sw].bDJX = ((WORD)psetbuf[SET_BZT_FS+sw*SW_SET_NUMBER].ff==3 )?true:false; ptSet->tSwSet[sw].bZF = ((WORD)psetbuf[SET_BZT_FS + sw * SW_SET_NUMBER].ff == 3) ? true : false; // ptSet->tSwSet[sw].bZF = ((WORD)psetbuf[SET_BZF_TT+sw*SW_SET_NUMBER].ff==1 )?true:false; ptSet->tSwSet[sw].dT_BTTZ = GetSetTIME(psetbuf[SET_BZTT_T + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_BTHZ = GetSetTIME(psetbuf[SET_BZTH_T + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_BTCD = GetSetTIME(psetbuf[SET_TCD + sw * SW_SET_NUMBER].ff); // 母线pt1电压电压选择 dw = (int)(psetbuf[SET_BZT_MX_PT1 + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].bzt_mx_pt1 = (u8)tSwSetTable[SET_BZT_MX_PT1].list[dw].dat; // 母线pt2电压电压选择 dw = (int)(psetbuf[SET_BZT_MX_PT2 + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].bzt_mx_pt2 = (u8)tSwSetTable[SET_BZT_MX_PT2].list[dw].dat; // 进线1pt电压 dw = (int)(psetbuf[SET_BZT_DL1_PT + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].bzt_dl1_pt = (u8)tSwSetTable[SET_BZT_DL1_PT].list[dw].dat; // 进线2pt电压 dw = (int)(psetbuf[SET_BZT_DL2_PT + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].bzt_dl2_pt = (u8)tSwSetTable[SET_BZT_DL2_PT].list[dw].dat; // 进线1pt电流 dw = (int)(psetbuf[SET_BZT_DL1_I + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].bzt_dl1_ct = (u8)tSwSetTable[SET_BZT_DL1_I].list[dw].dat; // 进线2pt电流 dw = (int)(psetbuf[SET_BZT_DL2_I + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].bzt_dl2_ct = (u8)tSwSetTable[SET_BZT_DL2_I].list[dw].dat; ptSet->tSwSet[sw].dJX1UPower = GetSetSQR(psetbuf[SET_POWERON_U + sw * SW_SET_NUMBER].ff, fKU[ptSet->tSwSet[sw].bzt_dl1_pt]); // 备自投进线1有压定值 ptSet->tSwSet[sw].dJX2UPower = GetSetSQR(psetbuf[SET_POWERON_U + sw * SW_SET_NUMBER].ff, fKU[ptSet->tSwSet[sw].bzt_dl2_pt]); // 备自投进线2有压定值 ptSet->tSwSet[sw].dMX1UPower = GetSetSQR(psetbuf[SET_POWERON_U + sw * SW_SET_NUMBER].ff, fKU[ptSet->tSwSet[sw].bzt_mx_pt1]); // 备自投母线1有压定值 ptSet->tSwSet[sw].dMX2UPower = GetSetSQR(psetbuf[SET_POWERON_U + sw * SW_SET_NUMBER].ff, fKU[ptSet->tSwSet[sw].bzt_mx_pt2]); // 备自投母线2有压定值 ptSet->tSwSet[sw].dJX1UPower_fh = _Mul_Div_U(ptSet->tSwSet[sw].dJX1UPower, 96, 100); ptSet->tSwSet[sw].dJX2UPower_fh = _Mul_Div_U(ptSet->tSwSet[sw].dJX2UPower, 96, 100); ptSet->tSwSet[sw].dMX1UPower_fh = _Mul_Div_U(ptSet->tSwSet[sw].dMX1UPower, 96, 100); ptSet->tSwSet[sw].dMX2UPower_fh = _Mul_Div_U(ptSet->tSwSet[sw].dMX2UPower, 96, 100); ptSet->tSwSet[sw].dJX1UPowerLost = GetSetSQR(psetbuf[SET_POWEROFF_U + sw * SW_SET_NUMBER].ff, fKU[ptSet->tSwSet[sw].bzt_dl1_pt]); // 备自投进线1无压定值 ptSet->tSwSet[sw].dJX2UPowerLost = GetSetSQR(psetbuf[SET_POWEROFF_U + sw * SW_SET_NUMBER].ff, fKU[ptSet->tSwSet[sw].bzt_dl1_pt]); // 备自投进线2无压定值 ptSet->tSwSet[sw].dMX1UPowerLost = GetSetSQR(psetbuf[SET_POWEROFF_U + sw * SW_SET_NUMBER].ff, fKU[ptSet->tSwSet[sw].bzt_dl1_pt]); // 备自投母线1无压定值 ptSet->tSwSet[sw].dMX2UPowerLost = GetSetSQR(psetbuf[SET_POWEROFF_U + sw * SW_SET_NUMBER].ff, fKU[ptSet->tSwSet[sw].bzt_dl1_pt]); // 备自投母线2无压定值 ptSet->tSwSet[sw].dJX1UPowerLost_fh = _Mul_Div_U(ptSet->tSwSet[sw].dJX1UPowerLost, 104, 100); ptSet->tSwSet[sw].dJX2UPowerLost_fh = _Mul_Div_U(ptSet->tSwSet[sw].dJX2UPowerLost, 104, 100); ptSet->tSwSet[sw].dMX1UPowerLost_fh = _Mul_Div_U(ptSet->tSwSet[sw].dMX1UPowerLost, 104, 100); ptSet->tSwSet[sw].dMX2UPowerLost_fh = _Mul_Div_U(ptSet->tSwSet[sw].dMX2UPowerLost, 104, 100); poc->dI = GetSetSQR(psetbuf[SET_GL1_I + sw * SW_SET_NUMBER].ff, fKI); ptSet->tSwSet[sw].dwl = GetSetSQR(psetbuf[SET_BZT_WL + sw * SW_SET_NUMBER].ff, fKI); ptSet->tSwSet[sw].dwl_fh = _Mul_Div_U(ptSet->tSwSet[sw].dwl, 96, 100); #endif } ptSet->tSwSet[sw].bTT_PT1_ll_check = ((WORD)psetbuf[SET_PT1_LL_CHECK_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; ptSet->tSwSet[sw].bTT_PT2_ll_check = ((WORD)psetbuf[SET_PT2_LL_CHECK_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false; // 功能模块配置项目表 ptSet->tSwSet[sw].bTT_jl_dy = (ptSet->tSwSet[sw].bTT_jl_dy && ptSet->tSwSet[sw].btt_gnyb_zdjl); ptSet->tSwSet[sw].bTT_jl_hz = (ptSet->tSwSet[sw].bTT_jl_hz && ptSet->tSwSet[sw].btt_gnyb_zdjl); #ifdef FUN_JDXX { // 接地选线定值 JDXX_SET *poc = &tJDXX_val[sw]; poc->bTT_jdxx_gj = (((WORD)psetbuf[SET_JDXXGJ_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 投退字 poc->bTT_jdxx_tz = (((WORD)psetbuf[SET_JDXXTZ_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 投退字 poc->bTT_jdxx = poc->bTT_jdxx_gj || poc->bTT_jdxx_tz; poc->bTT_jdxx_cph = (((WORD)psetbuf[SET_JDXX_CPH_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 选相投退字 poc->bTT_jdxx = poc->bTT_jdxx_gj || poc->bTT_jdxx_tz; poc->bTT_jdxx_p0dir = (((WORD)psetbuf[SET_JDXX_P0_TT + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 零序功率方向投退字 #ifdef SW_AC_I0S_SAMPLE if (g_ui[UI_SW_INDEX(sw, SW_AC_I0s)].chn_index != CFG_ADC_CHANNEL_ZERO) { poc->jd_zero = (short)(psetbuf[SET_JDXX_ZERO + sw * SW_SET_NUMBER].ff * g_ui[UI_SW_INDEX(sw, SW_AC_I0s)].m2_factor_k / 256.0 + 0.5); // 高精度零序零漂值 码值 poc->jd_qdval = (short)(psetbuf[SET_JDXX_QD + sw * SW_SET_NUMBER].ff * g_ui[UI_SW_INDEX(sw, SW_AC_I0s)].m2_factor_k / 256.0 + 0.5); // 高精度零序启动值,转为电流对应的码值 poc->jd_qdval2 = GetSetSQR(psetbuf[SET_JDXX_QD + sw * SW_SET_NUMBER].ff, g_ui[UI_SW_INDEX(sw, SW_AC_I0s)].m2_factor_k / 256.0); poc->jd_ov_val = (short)(0.5 * g_ui[UI_SW_INDEX(sw, SW_AC_I0s)].m2_factor_k / 256.0 + 0.5); // 高精度零序 1.9A满偏，采用1.7A作为满偏定值 poc->jd_ov_val2 = GetSetSQR(0.3, g_ui[UI_SW_INDEX(sw, SW_AC_I0)].m2_factor_k / 256.0); poc->i0_chan = UI_SW_INDEX(sw, SW_AC_I0s); } else #endif { poc->jd_zero = (short)(psetbuf[SET_JDXX_ZERO + sw * SW_SET_NUMBER].ff * g_ui[UI_SW_INDEX(sw, SW_AC_I0)].m2_factor_k / 256.0 + 0.5); // 高精度零序零漂值 码值 poc->jd_qdval = (short)(psetbuf[SET_JDXX_QD + sw * SW_SET_NUMBER].ff * g_ui[UI_SW_INDEX(sw, SW_AC_I0)].m2_factor_k / 256.0 + 0.5); // 高精度零序启动值,转为电流对应的码值 poc->jd_qdval2 = GetSetSQR(psetbuf[SET_JDXX_QD + sw * SW_SET_NUMBER].ff, g_ui[UI_SW_INDEX(sw, SW_AC_I0)].m2_factor_k / 256.0); poc->i0_chan = UI_SW_INDEX(sw, SW_AC_I0); } poc->jd_qdPoints = (WORD)psetbuf[SET_JDXX_QDPOINTS + sw * SW_SET_NUMBER].ff; poc->jd_surePoints = (WORD)psetbuf[SET_JDXX_SUREPOINTS + sw * SW_SET_NUMBER].ff; poc->jd_faultPoints = (WORD)psetbuf[SET_JDXX_FAULTPOINTS + sw * SW_SET_NUMBER].ff; poc->jd_voltype = tSwSetTable[SET_JDXX_VOLTYPE].list[(WORD)psetbuf[SET_JDXX_VOLTYPE + sw * SW_SET_NUMBER].ff].dat; poc->jd_volzero = (WORD)(psetbuf[SET_JDXX_VOLZERO + sw * SW_SET_NUMBER].ff * g_ui[poc->jd_voltype].m2_factor_k / 256.0 + 0.5); poc->jd_U0gl = GetSetSQR(psetbuf[SET_JDXX_U0 + sw * SW_SET_NUMBER].ff, g_ui[poc->jd_voltype].m2_factor_k / 256.0); poc->jd_U0gl_fh = _Mul_Div_U(poc->jd_U0gl, 96, 100); poc->jd_trip_time = GetSetTIME(psetbuf[SET_JDXX_TRIP_TIME + sw * SW_SET_NUMBER].ff); poc->jd_alarm_time = GetSetTIME(psetbuf[SET_JDXX_GJ_TIME + sw * SW_SET_NUMBER].ff); } #endif #ifdef FUNC_DRIVE_JY ptSet->tSwSet[sw].bTT_drive = ((WORD)psetbuf[SET_DRIVE + sw * SW_SET_NUMBER].ff == 1) ? true : false; // 不停电传动功能软压板 ptSet->tSwSet[sw].dU_drive_ua1 = (psetbuf[SET_UA1 + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dU_drive_ua2 = (psetbuf[SET_UA2 + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dU_drive_u0 = (psetbuf[SET_U0 + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dU_drive_i = (psetbuf[SET_I + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dU_drive_i0 = (psetbuf[SET_I0 + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_drive_ua1 = GetSetTIME(psetbuf[SET_DRIVE_UA1_T + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_drive_ua2 = GetSetTIME(psetbuf[SET_DRIVE_UA2_T + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_drive_u0 = GetSetTIME(psetbuf[SET_DRIVE_U0_T + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_drive_i = GetSetTIME(psetbuf[SET_DRIVE_I_T + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_drive_i0 = GetSetTIME(psetbuf[SET_DRIVE_I0_T + sw * SW_SET_NUMBER].ff); ptSet->tSwSet[sw].dT_drive_again = GetSetTIME(psetbuf[SET_DRIVE_AGAIN_T + sw * SW_SET_NUMBER].ff); #endif } // 无压定值为0.3倍的电压值 ptSet->dU02V_SQR = (DWORD)rt_round((0.8 * fKU[PUB_AC_U01]) * (0.8 * fKU[PUB_AC_U01])); // 16电压 #if 0 ptSet->dVOL10V_SQR =(DWORD)rt_round((10.0*fKU[PUB_AC_UAB1])*(16.0*fKU[PUB_AC_UAB1])); // 16电压 ptSet->dVOL16V_SQR =(DWORD)rt_round((16.0*fKU[PUB_AC_UAB1])*(16.0*fKU[PUB_AC_UAB1])); // 16电压 ptSet->dVOL50V_SQR =(DWORD)rt_round((50.0*fKU[PUB_AC_UAB1])*(50.0*fKU[PUB_AC_UAB1])); // 70电压 ptSet->dVOL90V_SQR =(DWORD)rt_round((90.0*fKU[PUB_AC_UAB1])*(90.0*fKU[PUB_AC_UAB1])); // 64电压 ptSet->dVOL70V_SQR =(DWORD)rt_round((70.0*fKU[PUB_AC_UAB1])*(70.0*fKU[PUB_AC_UAB1])); // 64电压 #else ptSet->dVOL10V_SQR = (DWORD)rt_round((0.1 * fUn * fKU[PUB_AC_UAB1]) * (0.1 * fUn * fKU[PUB_AC_UAB1])); // 10电压 ptSet->dVOL16V_SQR = (DWORD)rt_round((0.16 * fUn * fKU[PUB_AC_UAB1]) * (0.16 * fUn * fKU[PUB_AC_UAB1])); // 16电压 ptSet->dVOL50V_SQR = (DWORD)rt_round((0.5 * fUn * fKU[PUB_AC_UAB1]) * (0.5 * fUn * fKU[PUB_AC_UAB1])); // 70电压 ptSet->dVOL90V_SQR = (DWORD)rt_round((0.9 * fUn * fKU[PUB_AC_UAB1]) * (0.9 * fUn * fKU[PUB_AC_UAB1])); // 64电压 ptSet->dVOL70V_SQR = (DWORD)rt_round((0.7 * fUn * fKU[PUB_AC_UAB1]) * (0.7 * fUn * fKU[PUB_AC_UAB1])); // 64电压 #endif // 转换当前运行定值的镜象，做定值有效性检查时用 { BYTE *pBak = (BYTE *)&tBakSet; BYTE *pRun = (BYTE *)ptSet; int i = sizeof(struct TSET); for (; i > 0; i--) { *pBak++ = ~*pRun++; } } pRunSet = ptSet; // 将运行定值切换 bRunSetModify = true; if ((histrory_file_set && pRunSet->bTT_HistoryFile) || b_hisfile_format) { hf_init(); init_hs_file(b_hisfile_format && !bFirst); } else { for (i = 0; i < HS_FILE_NUM; i++) { p_his_file[i] = pRunSet->bTT_MsgFile ? (char *)history_file_name[i][0] : (char *)history_file_name[i][1]; } } m_runsection = pRunSet->section; #if !defined CPU_FUXI create_set_data_txt(); #else extern int g_l_shm_init; if (0 == g_l_shm_init) { check_shmdata_change(); } #endif return bRet; } /****************************************************************************** 函数名称： print_EquipParaTable 函数版本： 01.01 创建作者： 创建日期： 函数说明： 打印装置参数. 参数说明： 返回值： 成功返回0，失败返回负数 修改记录： */ int print_EquipParaTable(void) { SET_VALUE *psetbuf = m_SetBuf; TSETTABLE *pTable; DWORD dat, dw; int i; if (!ReadPara((void *)psetbuf, EEP_EQUIP_PARA_ADDR, EQUIP_PARA_NUMBER, &tEquipParaTable[0])) { rt_printf("读取装置参数发生错误!\r\n"); return -1; } rt_printf("装置参数:\r\n"); rt_printf("序号\t名称\t\t\t\t当前值\r\n"); for (i = 0; i < PARA_NUM; i++) { pTable = (TSETTABLE *)&tEquipParaTable[i]; dat = (DWORD)psetbuf[i].ff; rt_printf("%d\t%-20s\t\t", i + 1, pTable->szName); switch (pTable->wType) { case SETTYPE_F: rt_printf("%f", psetbuf[i].ff); break; case SETTYPE_UINT: // 16进制显示 控制字 rt_printf("%d", dat); break; case SETTYPE_4INT: // 10进制显示 4位 rt_printf("%d", dat); break; case SETTYPE_5INT: // 10进制显示 5位 rt_printf("%d", dat); break; case SETTYPE_LINT: // 16进制显示 控制字 rt_printf("%d", dat); break; case SETTYPE_LIST: // 列表选择 { dw = (WORD)(psetbuf[i].ff); // 通信规约 rt_printf("%s", tEquipParaTable[i].list[dw].str); } break; case SETTYPE_IP: { dat = (DWORD)psetbuf[i].tt; rt_printf("%d.%d.%d.%d", (dat >> 24) & 0xFF, (dat >> 16) & 0xFF, (dat >> 8) & 0xFF, (dat >> 0) & 0xFF); } break; case SETTYPE_YMD: { struct timespec ts; struct rtc_time_t tTime; memset(&ts, 0, sizeof(ts)); memset(&tTime, 0, sizeof(tTime)); // 年月日 ts.tv_sec = (long)psetbuf[i].tt; timespec_to_rtc(ts, &tTime, 1); rt_printf("%04d-%02d-%02d", 2000 + tTime.year, tTime.month, tTime.day); } break; case SETTYPE_HMS: { struct timespec ts; struct rtc_time_t tTime; extern int timespec_to_rtchms(struct timespec ts, struct rtc_time_t * p_rtc, int is_round); memset(&ts, 0, sizeof(ts)); memset(&tTime, 0, sizeof(tTime)); // 年月日 ts.tv_sec = (long)psetbuf[i].tt; timespec_to_rtchms(ts, &tTime, 1); rt_printf("%02d:%02d:%02d", tTime.hour, tTime.min, tTime.ms % 1000); } break; } rt_printf("\r\n"); } return 0; } /******************下面是关于装置参数读取及校验的操作********************************/ /****************************************************************************** 函数名称： string_to_ip 函数版本： 01.01 创建作者： xxxxxx 创建日期： 2015-01-07 函数说明： 字符串IP转整形IP. 参数说明： s:字符串IP 返回值： 整形IP。 修改记录： */ static uint32_t string_to_ip(char *s) { uint32_t addr; char *e; int i; if (s == NULL) return (0); for (addr = 0, i = 0; i < 4; ++i) { uint32_t val = s ? simple_strtoul(s, &e, 10) : 0; addr <<= 8; addr |= (val & 0xFF); if (s) { s = (*e) ? e + 1 : e; } } return (htonl(addr)); } /****************************************************************************** 函数名称： notify_sock_close 函数版本： 01.01 创建作者： xxxxxx 创建日期： 2015-02-28 函数说明： 通知相关socket要关闭. 参数说明： bFirstInit:是否第一次初始化.true表示是第一次.false表示不是第一次. 返回值： 无。 修改记录： */ static void notify_sock_close(bool bFirstInit) { int i = 0; RUN_PARA *pRunPara = &tRunPara; // for(i=0;itNetPara[i].bInit) { // 非第一次 if (!bFirstInit) { net_maintain_set_sock_closing(i); net_debug_set_sock_closing(i); net_104_set_sock_closing(i); } } else { if (pRunPara->sock_104_flag && (!bFirstInit)) { net_104_set_sock_closing(i); } } } } /****************************************************************************** 函数名称： get_ethcnt 函数版本： 01.01 创建作者： xxxxxx 创建日期： 2016-03-29 函数说明： 获取在序号no之前有多少个eth_id 参数说明： no:tRunPara.tNetPara数组下标 eth_id: 以太网卡序号(从0开始) 返回值： 无。 修改记录： */ int get_ethcnt(int no, int eth_id) { int ret = 0; int i; for (i = 0; i < no; i++) { if ((int)tRunPara.tNetPara[i].ethid == eth_id) { ret++; } } return ret; } int get_rmtparatype(u8 sw, u8 index) { u8 unit; index -= 1; if (sw == 0) { unit = g_pub_ac_desc[index].unit; } else { unit = g_sw_ac_desc[index].unit; } if (unit == UNIT_V100 || unit == UNIT_V220 || unit == UNIT_V001) return RMT_DEAD_U; else if (unit == UNIT_A5 || unit == UNIT_A1 || unit == UNIT_BIA || unit == UNIT_I0A) return RMT_DEAD_I; else if (unit == UNIT_W || unit == UNIT_Var || unit == UNIT_kW || unit == UNIT_kVar) return RMT_DEAD_PQ; else if (unit == UNIT_Hz) return RMT_DEAD_F; else if (unit == UNIT_COS) return RMT_DEAD_COS; else if (unit == UNIT_V050) return RMT_DEAD_ZL; return -1; } void GetDefDebugNetPara(void) { SET_VALUE *psetbuf = m_SetBuf; if (g_debugnet_ip > 0) { psetbuf[PARA_IP_NET1 + (CFG_ETH_MAX_LOGIC - 1) * 6].tt = g_debugnet_ip; } if (g_debugnet_mask > 0) { psetbuf[PARA_MA_NET1 + (CFG_ETH_MAX_LOGIC - 1) * 6].tt = g_debugnet_mask; } if (g_debugnet_gate > 0) { psetbuf[PARA_GATE_NET].tt = g_debugnet_gate; } } #if (0) void eth0_debug_ip_setup(void) // 设置网口1虚拟网络IP地址 { char *argv[] = {"/sbin/ifconfig", "eth0:3", "192.168.64.240", NULL}; char *envp[] = {NULL}; call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC); } #endif void MakeRunPara(bool bFirstInit, bool bUboot) { int i; SET_VALUE *psetbuf = m_SetBuf; RUN_PARA *pRunPara = &tRunPara; DWORD dat, dw; u8 hmi_protocol = 0; u8 fault_protocol = 0; u8 protocol[CFG_UART_NUM_MAX] = {0}; int debug_port = 0; char *acteth; uint32_t ip, mask, gate; unsigned int serverip = 0; int tm = 0; #ifdef SNTP_FUNC extern int sntp_setpara(unsigned int serverip, int tm); #endif #ifdef METERING_ENERGY bool b_ll_file; #endif if (!ReadPara((void *)psetbuf, EEP_EQUIP_PARA_ADDR, EQUIP_PARA_NUMBER, &tEquipParaTable[0])) { rt_err_set(ERR_CODE_EQU_PARA, 0); GetDefPara((void *)psetbuf, EQUIP_PARA_NUMBER, &tEquipParaTable[0]); } else { rt_err_clr(ERR_CODE_EQU_PARA, 0); } for (i = 0; i < CFG_UART_NUM_MAX; i++) { dw = (WORD)(psetbuf[PARA_PROTOCOL_S1 + i * 3].ff); // 通信规约 dat = (WORD)tEquipParaTable[PARA_PROTOCOL_S1 + i * 3].list[dw].dat; if (pRunPara->tUartPara[i].wProtocol != dat) { pRunPara->tUartPara[i].wProtocol = dat; pRunPara->tUartPara[i].bInit = true; } dw = (WORD)(psetbuf[PARA_BAUD_S1 + i * 3].ff); // 波特率 dat = (DWORD)tEquipParaTable[PARA_BAUD_S1 + i * 3].list[dw].dat; if (pRunPara->tUartPara[i].dBaud != dat) { pRunPara->tUartPara[i].dBaud = dat; pRunPara->tUartPara[i].bInit = true; } dw = (WORD)(psetbuf[PARA_PARITY_S1 + i * 3].ff); // 校验位 dat = (WORD)tEquipParaTable[PARA_PARITY_S1 + i * 3].list[dw].dat; if (pRunPara->tUartPara[i].wParity != dat) { pRunPara->tUartPara[i].wParity = dat; pRunPara->tUartPara[i].bInit = true; } pRunPara->tUartPara[i].b101PH = ((((WORD)(psetbuf[PARA_PROTOCOL_S1 + i * 3].ff)) == PROTOCOL_101_PH) || (((WORD)(psetbuf[PARA_PROTOCOL_S1 + i * 3].ff)) == PROTOCOL_MAINTAIN)) ? true : false; // 101为平衡式 if (bFirstInit) pRunPara->tUartPara[i].bInit = true; // 第一次初始化，置通道初始化标志 #if !defined CPU_FUXI if (pRunPara->tUartPara[i].wProtocol == PROTOCOL_HMI) { protocol[hmi_protocol] = i; hmi_protocol++; } if (pRunPara->tUartPara[i].wProtocol == PROTOCOL_FAULT) { fault_protocol++; } #endif } #if !defined CPU_FUXI // 判断是否有多个串口配置为面板或状态板 if (hmi_protocol > 1) { for (i = 0; i < hmi_protocol; i++) { if (UART_CHANNEL[protocol[hmi_protocol]] != CFG_UART_HMI) { // 有多个时，除RS232_3外，都配置为平衡101 pRunPara->tUartPara[protocol[hmi_protocol]].wProtocol = 1; } } rt_printf("面板配置超限制 \n"); } if (fault_protocol > 1) { rt_err_set(ERR_CODE_FAULT_BOARD, 0); } else { rt_err_clr(ERR_CODE_FAULT_BOARD, 0); } #endif // 从环境变量得到调试网口 acteth = env_get_info(ENV_ETHACT); if (acteth != NULL) { if (strcmp(acteth, "FEC0") == 0) { debug_port = 0; } else if (strcmp(acteth, "FEC1") == 0) { debug_port = 1; } else if (strcmp(acteth, "DM9000") == 0) { debug_port = 2; } else { debug_port = 2; } } else { debug_port = 2; } // 从环境变量得到IP地址 ip = string_to_ip(env_get_info(ENV_IPADDR)); Swap_32(&ip); // 从环境变量得到MASK mask = string_to_ip(env_get_info(ENV_NETMASK)); Swap_32(&mask); // 从环境变量得到默认网关 gate = string_to_ip(env_get_info(ENV_GATEWAYIP)); Swap_32(&gate); for (i = 0; i < CFG_ETH_MAX_LOGIC; i++) { pRunPara->tNetPara[i].changed = 0; // 清零 dat = (DWORD)(psetbuf[PARA_NET1 + i * 6].ff); // 物理网卡序号 if (pRunPara->tNetPara[i].ethid != dat) { pRunPara->tNetPara[i].ethid = dat; pRunPara->tNetPara[i].bInit = true; if (!bUboot) { // 网口已经改变,标志需要将网口写到UBOOT中 pRunPara->tNetPara[i].changed |= 1 << 6; } } dat = (DWORD)(psetbuf[PARA_IP_NET1 + i * 6].tt); if (pRunPara->tNetPara[i].wIp != dat) { pRunPara->tNetPara[i].wIp = dat; pRunPara->tNetPara[i].bInit = true; if (!bUboot) { // IP已经改变,标志需要将IP写到UBOOT中 pRunPara->tNetPara[i].changed |= 1 << 0; } } dat = (DWORD)(psetbuf[PARA_GATE_NET].tt); if (pRunPara->tNetPara[i].wGate != dat) { pRunPara->tNetPara[i].wGate = dat; pRunPara->tNetPara[i].bInit = true; if (!bUboot) { // 网关已经改变,标志需要将网关写到UBOOT中 pRunPara->tNetPara[i].changed |= 1 << 1; } } dat = (DWORD)(psetbuf[PARA_MA_NET1 + i * 6].tt); if (pRunPara->tNetPara[i].wMask != dat) { pRunPara->tNetPara[i].wMask = dat; pRunPara->tNetPara[i].bInit = true; if (!bUboot) { // MASK已经改变,标志需要将MASK写到UBOOT中 pRunPara->tNetPara[i].changed |= 1 << 2; } } // 网段 dat = (DWORD)(psetbuf[PARA_ROUTE_NET1 + i * 6].tt); if (pRunPara->tNetPara[i].wRouteNet != dat) { pRunPara->tNetPara[i].wRouteNet = dat; pRunPara->tNetPara[i].bInit = true; if (!bUboot) { // MASK已经改变,标志需要将MASK写到UBOOT中 pRunPara->tNetPara[i].changed |= 1 << 3; } } // 网段掩码 dat = (DWORD)(psetbuf[PARA_ROUTE_NETMASK1 + i * 6].tt); if (pRunPara->tNetPara[i].wRouteNetMask != dat) { pRunPara->tNetPara[i].wRouteNetMask = dat; pRunPara->tNetPara[i].bInit = true; if (!bUboot) { // MASK已经改变,标志需要将MASK写到UBOOT中 pRunPara->tNetPara[i].changed |= 1 << 4; } } // 网关 dat = (DWORD)(psetbuf[PARA_ROUTE_GATE1 + i * 6].tt); if (pRunPara->tNetPara[i].wRouteGate != dat) { pRunPara->tNetPara[i].wRouteGate = dat; pRunPara->tNetPara[i].bInit = true; if (!bUboot) { // MASK已经改变,标志需要将MASK写到UBOOT中 pRunPara->tNetPara[i].changed |= 1 << 5; } } if (bFirstInit) { pRunPara->tNetPara[i].bInit = true; // 第一次初始化，置通道初始化标志 // 第一次初始化网络号和索引号默认同步 pRunPara->tNetPara[i].old_ethid = pRunPara->tNetPara[i].ethid; pRunPara->tNetPara[i].old_index = pRunPara->tNetPara[i].index; } } #if (0) eth0_debug_ip_setup(); #endif // 保存调试网口的IP,子网掩码 g_debugnet_ip = psetbuf[PARA_IP_NET1 + (CFG_ETH_MAX_LOGIC - 1) * 6].tt; g_debugnet_mask = psetbuf[PARA_MA_NET1 + (CFG_ETH_MAX_LOGIC - 1) * 6].tt; g_debugnet_gate = psetbuf[PARA_GATE_NET].tt; // 如果端口和主站IP有修改，需重新初始化104连接。 pRunPara->sock_104_flag = false; // 104端口判断 dat = (WORD)psetbuf[PARA_104_PORT].ff; // 104协议端口号 if (pRunPara->w104Port != dat) { pRunPara->sock_104_flag = true; } // 104主站IP1地址改变 dat = (DWORD)(psetbuf[PARA_IP_104MASTER1].tt); if (pRunPara->ip104Master1 != dat) { // 104 socket需重新初始化 pRunPara->sock_104_flag = true; } // 104主站IP2地址改变 dat = (DWORD)(psetbuf[PARA_IP_104MASTER2].tt); if (pRunPara->ip104Master2 != dat) { // 104 socket需重新初始化 pRunPara->sock_104_flag = true; } // 104主站IP3地址改变 dat = (DWORD)(psetbuf[PARA_IP_104MASTER3].tt); if (pRunPara->ip104Master3 != dat) { // 104 socket需重新初始化 pRunPara->sock_104_flag = true; } // 104主站IP4地址改变 dat = (DWORD)(psetbuf[PARA_IP_104MASTER4].tt); if (pRunPara->ip104Master4 != dat) { // 104 socket需重新初始化 pRunPara->sock_104_flag = true; } pRunPara->byAddr = (WORD)psetbuf[PARA_ADDR].ff; // 装置地址 pRunPara->fYcTime = psetbuf[PARA_YCTIME].ff; // 遥测主动发送间隔 pRunPara->dYKTime = GetSetTIME(psetbuf[PARA_YK_TIME].ff); // 遥控超时 pRunPara->dSM2Time = (DWORD)rt_round(psetbuf[PARA_YK_TIME].ff); // 加密遥控超时 dido_qd_set_keeptime(pRunPara->dSM2Time * USTIMER_SEC); // 以遥控超时作为启动继电器超时 if (sizeof(SYSTEM_DATA) == EEP_SYSTEM_DATA_SIZE) ReadSysData(&pRunPara->sysData); else rt_printf("SYSTEM_DATA define error!\r\n "); pRunPara->wPassword = ReadPassword(); // 装置密码 pRunPara->bGPS = (((WORD)(psetbuf[PARA_TIMETYPE].ff)) == 1) ? true : false; // 对时方式，默认是网络对时 pRunPara->set_time_mode = (WORD)(psetbuf[PARA_TIMETYPE_STANDER].ff); // 标准化对时方式选择 // 全方式对时或者仅卫星对时都使能卫星同步 pRunPara->bGPS_sync_enable = (pRunPara->set_time_mode == 0 || pRunPara->set_time_mode == 1) ? true : false; pRunPara->GPS_sync_time = (WORD)(psetbuf[PARA_GPS_INTERVAL].ff); // 卫星对时时间隔 pRunPara->GPS_switch_delay = (WORD)(psetbuf[PARA_CHANGETIME].ff); // 无卫星信号对时切换延时 pRunPara->bDPI = (((WORD)(psetbuf[PARA_YXTYPE].ff)) == 1) ? true : false; // 遥信双点上送 pRunPara->bSDPI = (((WORD)(psetbuf[PARA_YXTYPE].ff)) == 2) ? true : false; // 遥信单双点上送 pRunPara->YKtype = rt_round(psetbuf[PARA_YKTYPE].ff); // 遥控类型 pRunPara->bYcBDH = (((WORD)(psetbuf[PARA_YCTYPE].ff)) == 1) ? true : false; // 遥测标度化值上送 pRunPara->bYcFloat = (((WORD)(psetbuf[PARA_YCTYPE].ff)) == 2) ? true : false; // 遥测浮点数上送 pRunPara->b101Addr2Byte = (((WORD)(psetbuf[PARA_101LINKADDR].ff)) == 1) ? true : false; // 101为双字节地址 pRunPara->b101App2Byte = (((WORD)(psetbuf[PARA_101APPADDR].ff)) == 1) ? true : false; // 101应用单元 pRunPara->b101Cot2Byte = (((WORD)(psetbuf[PARA_101COT].ff)) == 1) ? true : false; // 101为双字节地址 pRunPara->bAutoSendYc = (((WORD)(psetbuf[PARA_YCAUTO].ff)) == 1) ? true : false; // 遥测自动上送 pRunPara->bDeadType = (((WORD)(psetbuf[PARA_YC_DEAD_TYPE].ff)) == 0) ? true : false; // 规约死区上传类型 pRunPara->bAutoCos = (((WORD)(psetbuf[PARA_COSAUTO].ff)) == 1) ? true : false; // COS自动上送 pRunPara->bEvPara = (((WORD)(psetbuf[PARA_EVPARA].ff)) == 1) ? true : false; // 事件参数上送 pRunPara->bAutoRst = (((WORD)(psetbuf[PARA_RST_TT].ff)) == 1) ? true : false; // 自动复归投退 pRunPara->dTRstT = GetSetTIME(psetbuf[PARA_RSTTIME].ff * 60); #ifdef RCD_STRAN_M_EN pRunPara->b_lb_master = (((WORD)(psetbuf[PARA_LB_MASTER_TT].ff)) == 1) ? true : false; // 级联录波主站使能投退 #endif #ifdef YPARA_LINK_S_EN pRunPara->b_ypar_slave = (((WORD)(psetbuf[PARA_YPAR_CHG_TT].ff)) == 1) ? true : false; // 参数变化通知使能 #endif dat = (DWORD)rt_round(psetbuf[PARA_BATBEGIN_YMD].tt) + (DWORD)rt_round(psetbuf[PARA_BATBEGIN_HMS].ff * 3600); #ifdef YX_RESET_TIME pRunPara->dTEventRst = GetSetTIME(psetbuf[PARA_EVTRSTTIME].ff); pRunPara->fT_LBXH_RST = psetbuf[PARA_EVTRSTTIME].ff; #endif if (pRunPara->dTBatBegin != dat) { pRunPara->dTBatBegin = dat; bat_begin_time(); // 修改电池活化启动时间 } pRunPara->dTBatInterval = (DWORD)rt_round(psetbuf[PARA_BAT_INTERVAL].ff * 24 * 3600); // 电池活化间隔 小时数 pRunPara->bat_alarm = psetbuf[PARA_BAT_ALARM].ff; // 电池告警阀值 fresh_set_soe(EV_TT_BAT, (pRunPara->dTBatInterval > 0 ? true : false), bFirstInit, 0); pRunPara->dLightTime = GetSetTIME(psetbuf[PARA_LHTTIME].ff); // 背光时间默认1分钟 pRunPara->dMainTime = GetSetTIME(psetbuf[PARA_LHTTIME].ff); // 返回时间默认3分钟 pRunPara->dLinkStateCh = (WORD)(psetbuf[PARA_LINK_STATE].ff); // 级联状态通道 pRunPara->w104Port = (WORD)psetbuf[PARA_104_PORT].ff; // 104协议端口号 pRunPara->w104AckTime = (WORD)psetbuf[PARA_104_ACK_TIME].ff; // 104确认超时 pRunPara->w104TestTime = (WORD)psetbuf[PARA_104_TEST_TIME].ff; // 104测试超时 pRunPara->w104K = (WORD)psetbuf[PARA_104_K].ff * 2; // 104 K值 pRunPara->w104W = (WORD)psetbuf[PARA_104_W].ff * 2; // 104 W值 pRunPara->ip104Master1 = (DWORD)(psetbuf[PARA_IP_104MASTER1].tt); // 104主站IP1 pRunPara->ip104Master2 = (DWORD)(psetbuf[PARA_IP_104MASTER2].tt); // 104主站IP2 pRunPara->ip104Master3 = (DWORD)(psetbuf[PARA_IP_104MASTER3].tt); // 104主站IP3 pRunPara->ip104Master4 = (DWORD)(psetbuf[PARA_IP_104MASTER4].tt); // 104主站IP4 pRunPara->b104Client = (((WORD)(psetbuf[PARA_104_Client].ff)) == 1) ? true : false; // 104是客户端还是服务器端 pRunPara->ip104Master[0] = pRunPara->ip104Master1; pRunPara->ip104Master[1] = pRunPara->ip104Master2; pRunPara->ip104Master[2] = pRunPara->ip104Master3; pRunPara->ip104Master[3] = pRunPara->ip104Master4; for (i = 0; i < CFG_LINK_104_NUM; i++) { pRunPara->ip104Link[i] = (DWORD)(psetbuf[PARA_IP_104LINK1 + i].tt); // 104级联IP } #ifdef METERING_ENERGY b_ll_file = (((WORD)psetbuf[PARA_LL_FILE_TT].ff == 1) ? true : false); if (b_ll_file != pRunPara->bTT_LLFile) { ll_file_set = true; pRunPara->bTT_LLFile = b_ll_file; } pRunPara->wZDJG = (WORD)psetbuf[PARA_YC_JG_T].ff; // 定点保存数据间隔，默认15秒 pRunPara->wSWID = (WORD)psetbuf[PARA_LL_SW_ID].ff; pRunPara->wDDJG = (WORD)psetbuf[PARA_LL_JG_T].ff; pRunPara->wMonday = (WORD)psetbuf[PARA_LL_MONTHD_DAY].ff; pRunPara->wMonhour = (WORD)psetbuf[PARA_LL_MONTHD_HOUR].ff; /*if(histrory_file_set&&pRunPara->bTT_HistoryFile) { hf_init(); init_hs_file(); }*/ if (ll_file_set && pRunPara->bTT_LLFile) { ll_init(); init_ll_file(); } #endif /************零漂处理*******************/ { s32 uzero; s32 phase_i_zero, zero_i_zero; uzero = (s32)(psetbuf[PARA_U_ZERO].ff * 65536); // 电压零漂 phase_i_zero = (s32)(psetbuf[PARA_PHASE_I_ZERO].ff * 65536); // 相电流零漂 zero_i_zero = (s32)(psetbuf[PARA_ZERO_I_ZERO].ff * 65536); // 零序电流零漂 for (i = 0; i < UNIT_NUM; i++) { if (i == UNIT_V100 || i == UNIT_V220) { g_unit[i].zero = uzero; } if (i == UNIT_A1 || i == UNIT_A5 || i == UNIT_BIA) { g_unit[i].zero = phase_i_zero; } else if (i == UNIT_I0A) { g_unit[i].zero = zero_i_zero; } } } #ifdef CPU_FUXI pRunPara->wDC_ZERO = psetbuf[PARA_DC_ZERO].ff; #endif pRunPara->wFAFZT = (DWORD)rt_round(psetbuf[PARA_FZPULSE].ff); // 分闸脉冲 pRunPara->wFAHZT = (DWORD)rt_round(psetbuf[PARA_HZPULSE].ff); // 合闸脉冲 #if (defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020) pRunPara->gse_id = (WORD)rt_round(psetbuf[PARA_GOOSE_ID].ff) - 1; pRunPara->gse_T1 = GetSetTIME(psetbuf[PARA_GOOSE_T1].ff); pRunPara->gse_T2 = GetSetTIME(psetbuf[PARA_GOOSE_T2].ff); #endif #ifdef FUN_FUXI_ESAM /* 加密芯片 */ pRunPara->s1_mode = (((WORD)(psetbuf[PARA_S1_MODE].ff)) == 1) ? true : false; // pRunPara->s1_port = (WORD)(psetbuf[PARA_S1_PORT].ff); // 104协议端口号 pRunPara->s1_nat = (DWORD)(psetbuf[PARA_S1_NAT].tt); // 加密芯片IP pRunPara->s1_ip = (DWORD)(psetbuf[PARA_S1_IP].tt); // 加密芯片IP pRunPara->s1_mask = (DWORD)(psetbuf[PARA_S1_MASK].tt); // 掩码 pRunPara->s1_gate = (DWORD)(psetbuf[PARA_S1_GATE].tt); // 网关 pRunPara->s1_far_ip = (DWORD)(psetbuf[PARA_S1_FAR_IP].tt); // 远端IP pRunPara->s1_far_mask = (DWORD)(psetbuf[PARA_S1_FAR_MASK].tt); // 掩码 pRunPara->s1_far_gate = (DWORD)(psetbuf[PARA_S1_FAR_GATE].tt); // 网关 #endif /**远动参数处理，死区及跳合闸脉宽，需更新到配置文件中************************/ if (pRunSet->bTT_RmtPara) { int i; qs16 deadval[RMT_DEAD_NUM]; if (pRunSet->bTT_YC_DeadZone_All) { deadval[RMT_DEAD_I] = deadval[RMT_DEAD_U] = deadval[RMT_DEAD_ZL] = deadval[RMT_DEAD_PQ] = deadval[RMT_DEAD_F] = deadval[RMT_DEAD_COS] = (qs16)(psetbuf[PARA_DEAD_ZONE_ALL].ff * 65536); // 遥测死区 } else { deadval[RMT_DEAD_I] = (qs16)(psetbuf[PARA_DEAD_I].ff * 65536); // 电流死区 deadval[RMT_DEAD_U] = (qs16)(psetbuf[PARA_DEAD_U].ff * 65536); // 电压死区 deadval[RMT_DEAD_ZL] = (qs16)(psetbuf[PARA_DEAD_ZL].ff * 65536); // 直流死区 deadval[RMT_DEAD_PQ] = (qs16)(psetbuf[PARA_DEAD_P].ff * 65536); // 功率死区 deadval[RMT_DEAD_F] = (qs16)(psetbuf[PARA_DEAD_F].ff * 65536); // 频率死区 deadval[RMT_DEAD_COS] = (qs16)(psetbuf[PARA_DEAD_COS].ff * 65536); // 功率因数死区 } for (i = 0; i < g_table_head->ac_num; i++) // 将定值死区更新到点表数据中 { int type; type = get_rmtparatype(g_ac_table[i].owner, g_ac_table[i].indexno); if (type >= 0 && type < RMT_DEAD_NUM) { #ifndef PARAM_DEAD_PER g_ac_table[i].dead_value = deadval[type] * 100; #else g_ac_table[i].dead_value = deadval[type]; #endif } } { int bChanged = 0; dw = (DWORD)rt_round(psetbuf[PARA_YXFD].ff); // 遥信防抖时间 if (dw != pRunPara->wYXFD) { pRunPara->wYXFD = dw; bChanged = 1; } dw = (DWORD)rt_round(psetbuf[PARA_FZPULSE].ff); // 分闸脉冲 if (dw != pRunPara->wFZMC) { pRunPara->wFZMC = dw; bChanged = 1; } dw = (DWORD)rt_round(psetbuf[PARA_HZPULSE].ff); // 合闸脉冲 if (dw != pRunPara->wHZMC) { pRunPara->wHZMC = dw; bChanged = 1; } // 如果不是第一次初始化，且子板参数有变化，复位子板 if (bFirstInit == 0 && bChanged) { #if defined(BSP_CAN_ENABLE) // 复位所有子板 can_app_reset(0); #endif } // 如果是第一次初始化，或子板参数有变化，复位子板 if (bFirstInit || bChanged) { extern int equ_config_di_yd(void); extern int equ_config_do_yd(void); equ_config_di_yd(); equ_config_do_yd(); equ_reinit_rv_di(); } } } // 通知socket关闭 notify_sock_close(bFirstInit); IEC_CommInit(); // 串口参数修改外部通信重新初始化 Net_Init(); // 设置SNTP同步对时参数 #ifdef SNTP_FUNC tm = (int)(psetbuf[PARA_SNTP_SYNC_TM].ff); // SNTP对时间隔 serverip = (DWORD)(psetbuf[PARA_IP_SNTP].tt); // SNTP服务器IP sntp_setpara(serverip, tm); #endif bRunSetModify = true; #if !defined CPU_FUXI create_set_data_txt(); #endif } /*************************************************** 函数名称：ReadSysPara 函数版本：1.00 作者： 创建日期：2008.8.20 函数功能说明：读取参数到pf中,并进行CRC-16校验 输入参数： 输出参数：无 返回值： 成功时返回1，否则，0 函数扇入清单： ***************************************************/ bool ReadPara(void *pbuf, DWORD wAddr, WORD num, const TSETTABLE *pTable) { int i; bool ret; float *pf = (float *)pbuf; ret = ReadEppData(wAddr, (void *)pbuf, (num * 4)); if (!ret) { return false; } for (i = 0; i < num; i++) { if ((pTable[i].wType == SETTYPE_IP) || (pTable[i].wType == SETTYPE_YMD) || (pTable[i].wType == SETTYPE_HMS)) { continue; // IP地址方式，不判断最大最小值 } if (CheckFloatSet(&pf[i], pTable[i].fMax, pTable[i].fMin) > 0) return false; } return true; } /************************************************************************** 函数名称：SaveSysPara 函数版本：1.00 作者： 创建日期：2008.8.20 函数功能说明：保存测控参数到EEP中, 输入参数： 输出参数：无 返回值： 成功时返回1，否则，0 函数扇入清单： ***************************************************************************/ bool SavePara(void *pbuf, DWORD wAddr, WORD num, const TSETTABLE *pTable) { int i; bool ret; float *pf = (float *)pbuf; u8 buf[128]; for (i = 0; i < num; i++) { if ((pTable[i].wType == SETTYPE_IP) || (pTable[i].wType == SETTYPE_YMD) || (pTable[i].wType == SETTYPE_HMS)) { continue; // IP地址方式，不判断最大最小值 } if (CheckFloatSet(&pf[i], pTable[i].fMax, pTable[i].fMin) > 0) { sprintf(buf, "%s越限(%f)\r\n", pTable[i].szName, pf[i]); rt_printf(buf); log_str_time(LOG_OPERATE, buf, 0, 0); return false; } } para_change_check_soe(pf, wAddr, num, pTable); // 判断定值变化，上送soe ret = SaveEppData(wAddr, (void *)pbuf, (num * 4)); if (ret) { g_creat_set_file |= 0x02; } return ret; } /************************************************************************** 函数名称：GetDefSysPara 函数版本：1.00 作者： 创建日期：2008.8.20 函数功能说明：获得默认定值 输入参数： 输出参数：无 返回值： 函数扇入清单： ***************************************************************************/ void GetDefPara(float *pbuf, WORD num, const TSETTABLE *pTable) { int i; for (i = 0; i < num; i++) { if ((pTable[i].wType == SETTYPE_IP) // 数据类型为IP地址，默认值从pTable[i].list中获取 || (pTable[i].wType == SETTYPE_YMD) || (pTable[i].wType == SETTYPE_HMS)) { *((DWORD *)pbuf++) = (DWORD)pTable[i].list; } else { *pbuf++ = pTable[i].fDef; } } } void GetDefSet(float *pbuf) { int i, sw; for (i = 0; i < PUB_SET_NUMBER; i++) // 公共定值 { *pbuf++ = tPubSetTable[i].fDef; } for (sw = 0; sw < SWITCH_NUM_MAX; sw++) // 线路定值 { for (i = 0; i < SW_SET_NUMBER; i++) { *pbuf++ = tSwSetTable[i].fDef; } } } bool ReadSysData(SYSTEM_DATA *st) { WORD crc; e2prom_read(EEP_SYSTEM_DATA_START, (BYTE *)st, EEP_SYSTEM_DATA_SIZE); crc = Modbus_CRC16(((BYTE *)st) + 2, EEP_SYSTEM_DATA_SIZE - 4); if (st->wCrc != crc) // 数据不合法 { memset((char *)st, 0, EEP_SYSTEM_DATA_SIZE); st->bWriteFlag = TRUE; // 初始化以下数据区，防止跟初始数据一致造成数据未刷新 sprintf(m_TzCount, "%d", tRunPara.sysData.wSwTzCount); sprintf(m_HzCount, "%d", tRunPara.sysData.wSwHzCount); } return TRUE; } bool WriteSysData(SYSTEM_DATA *st) { if (st->bWriteLock) // 简易多线程写数据互锁处理 { // rt_printf("bWriteLock....\r\n"); return FALSE; } st->bWriteLock = TRUE; st->wCrc = Modbus_CRC16(((BYTE *)st) + 2, EEP_SYSTEM_DATA_SIZE - 4); if (e2prom_write(EEP_SYSTEM_DATA_START, (BYTE *)st, EEP_SYSTEM_DATA_SIZE) != 0) ; // return false; st->bWriteFlag = FALSE; st->bWriteLock = FALSE; // rt_printf("WriteSysData OK...\r\n"); return TRUE; } /******************下面是关于密码读取及校验的操作********************************/ /***************************************************************************** 函数名称：ReadPassword 函数版本：1.00 作者： 创建日期：2008.8.18 函数功能说明：读密码，若校验错误，则返回默认密码 输入参数： 输出参数：无 返回值： 成功时返回1，否则，0 函数扇入清单： *********************************************************************************/ WORD ReadPassword(void) { BYTE pass1[12]; WORD crc1, crc2; e2prom_read(EEP_PASSWORD_ADDR, (BYTE *)pass1, 10); crc2 = Modbus_CRC16((BYTE *)pass1, PASSWORD_LEN); e2prom_read(EEP_PASSWORD_ADDR + PASSWORD_LEN, (BYTE *)&crc1, 2); if (crc1 == crc2) { memcpy(tRunPara.wPasswordstr, pass1, PASSWORD_LEN); tRunPara.wPasswordstr[PASSWORD_LEN] = '\0'; #ifdef PASSWORD_4_STR tRunPara.wPasswordstr[4] = '\0'; #endif } else { #ifdef PASSWORD_4_STR strcpy(tRunPara.wPasswordstr, INIT_PASSWORD_STR_4); #else strcpy(tRunPara.wPasswordstr, INIT_PASSWORD_STR); #endif } // 二级密码读取 e2prom_read(EEP_PASSWORD2_ADDR, (BYTE *)pass1, 10); crc2 = Modbus_CRC16((BYTE *)pass1, PASSWORD_LEN); e2prom_read(EEP_PASSWORD2_ADDR + PASSWORD_LEN, (BYTE *)&crc1, 2); if (crc1 == crc2) { memcpy(tRunPara.wPasswordstr2, pass1, PASSWORD_LEN); tRunPara.wPasswordstr2[PASSWORD_LEN] = '\0'; #ifdef PASSWORD_4_STR tRunPara.wPasswordstr2[4] = '\0'; #endif } else { #ifdef PASSWORD_4_STR strcpy(tRunPara.wPasswordstr2, INIT_PASSWORD_STR_4); #else strcpy(tRunPara.wPasswordstr2, INIT_PASSWORD_STR); #endif } return INIT_PASSWORD; // 返回初始密码 } /*********************************** 函数名称：SavePassword 函数版本：1.00 作者： 创建日期：2008.8.18 函数功能说明：保存密码到eep中 输入参数： 输出参数：无 返回值： 成功时返回1，否则，0 函数扇入清单： ***************************************/ bool SavePassword(BYTE *str) { WORD crc; if (e2prom_write(EEP_PASSWORD_ADDR, (BYTE *)str, PASSWORD_LEN) != 0) return false; crc = Modbus_CRC16((BYTE *)str, PASSWORD_LEN); if (e2prom_write(EEP_PASSWORD_ADDR + PASSWORD_LEN, (BYTE *)&crc, 2) != 0) return false; return true; } bool SavePassword2(BYTE *str) { WORD crc; if (e2prom_write(EEP_PASSWORD2_ADDR, (BYTE *)str, PASSWORD_LEN) != 0) return false; crc = Modbus_CRC16((BYTE *)str, PASSWORD_LEN); if (e2prom_write(EEP_PASSWORD2_ADDR + PASSWORD_LEN, (BYTE *)&crc, 2) != 0) return false; return true; } /******************下面是关于电压合格率读取及校验的操作********************************/ /***************************************************************************** 函数名称：ReadUqua 函数版本：1.00 作者： 创建日期：2008.8.18 函数功能说明：读密码，若校验错误，则返回默认密码 输入参数： 输出参数：无 返回值： 成功时返回1，否则，0 函数扇入清单： *********************************************************************************/ void ReadUqua(void) { struct U_QUA uq; u16 crc; e2prom_read(EEP_UEUQ_ADDR, (BYTE *)&uq, sizeof(uq)); crc = Modbus_CRC16((BYTE *)&uq, 16); if (crc == uq.crc) { g_sw_pub.vol_qua_ok_time[0] = uq.ok_time[0]; g_sw_pub.vol_qua_run_time[0] = uq.run_time[0]; g_sw_pub.vol_qua_ok_time[1] = uq.ok_time[1]; g_sw_pub.vol_qua_run_time[1] = uq.run_time[1]; } } /*********************************** 函数名称：SaveUqua 函数版本：1.00 作者： 创建日期：2008.8.18 函数功能说明：保存密码到eep中 输入参数： 输出参数：无 返回值： 成功时返回1，否则，0 函数扇入清单： ***************************************/ void SaveUqua(bool clr) { struct U_QUA uq; if (!clr) { uq.ok_time[0] = g_sw_pub.vol_qua_ok_time[0]; uq.run_time[0] = g_sw_pub.vol_qua_run_time[0]; uq.ok_time[1] = g_sw_pub.vol_qua_ok_time[1]; uq.run_time[1] = g_sw_pub.vol_qua_run_time[1]; } else { uq.ok_time[0] = 0; uq.run_time[0] = 0; uq.ok_time[1] = 0; uq.run_time[1] = 0; g_sw_pub.bclearqua = true; } uq.crc = Modbus_CRC16((BYTE *)&uq, 16); e2prom_write(EEP_UEUQ_ADDR, (BYTE *)&uq, sizeof(uq)); } // 逻辑网络索引 int set_get_network_id_from_socket(SOCKET s) { struct sockaddr_in local_addr; unsigned int len = sizeof(local_addr); int i; rt_getsockname(s, (struct sockaddr *)&local_addr, &len); for (i = 0; i < CFG_ETH_MAX_LOGIC; i++) { if (tRunPara.tNetPara[i].wIp == local_addr.sin_addr.s_addr) { return i; } } return -1; } /****************以下是远方修改定值及程序更新相关代码************/ int set_get_list_index(const SET_LIST *p_list) { int i; for (i = 0; i < LIST_ALL_NUM; i++) { if (p_list == g_list_all[i].list) { return i; } } return -1; } int set_create_desc_file(void) { unsigned int i, j, len, num, file_length; char *p; loff_t pos; struct file *pfile; struct set_file_head_desc fh; struct set_item set_item; struct list_item list_item; struct list_sum_item list_sum_item; struct unit_item unit_item; // 写文件头 // 配置文件头 memset(&fh, 0, sizeof(fh)); fh.cfh.signature = SIG_SET_DESC_FILE; fh.cfh.version = SET_FILE_VERSION; fh.equ_sw_num = SWITCH_NUM_MAX; // 增加开关数量，这样工具能够正确识别数据文件的大小 // 外部定值 fh.set_extpub_addr = FILE_ADDR_ALGIN(sizeof(fh)); fh.set_extpub_num = PUB_SET_NUMBER; fh.set_extsw_addr = FILE_ADDR_ALGIN(fh.set_extpub_addr + fh.set_extpub_num * sizeof(struct set_item)); fh.set_extsw_num = SW_SET_NUMBER; // 内部定值 fh.set_int_addr = FILE_ADDR_ALGIN(fh.set_extsw_addr + fh.set_extsw_num * sizeof(struct set_item)); fh.set_int_num = CSTSET_NUMBER; // 装置参数 fh.set_arg_addr = FILE_ADDR_ALGIN(fh.set_int_addr + fh.set_int_num * sizeof(struct set_item)); fh.set_arg_num = EQUIP_PARA_NUMBER; // 列表结构 fh.list_addr = FILE_ADDR_ALGIN(fh.set_arg_addr + fh.set_arg_num * sizeof(struct set_item)); fh.list_num = 0; for (i = 0; i < LIST_ALL_NUM; i++) { fh.list_num += g_list_all[i].num; } // 列表结构描述总表 fh.list_sum_addr = FILE_ADDR_ALGIN(fh.list_addr + fh.list_num * sizeof(struct list_item)); fh.list_sum_num = LIST_ALL_NUM; // 单位表 fh.unit_addr = FILE_ADDR_ALGIN(fh.list_sum_addr + fh.list_sum_num * sizeof(struct list_sum_item)); fh.unit_num = sizeof(SetUints) / sizeof(char *); // 得到文件长度 file_length = FILE_ADDR_ALGIN(fh.unit_addr + fh.unit_num * sizeof(struct unit_item)); // 分配并初始化空间 p = rt_malloc(file_length + 2); // 加crc长度 if (!p) { return -1; } memset(p, 0, file_length); // 写入文件头 memcpy(p, (char *)&fh, sizeof(fh)); // 写外部定值 for (i = 0; i < fh.set_extpub_num; i++) { set_item.type = tPubSetTable[i].wType; set_item.unit = tPubSetTable[i].wUnit; len = strlen(tPubSetTable[i].szName); if (len >= MOD_NAME_LEN - 1) { rt_free(p); return -3; } memset(set_item.name, 0, sizeof(set_item.name)); memcpy(set_item.name, tPubSetTable[i].szName, len); set_item.max = tPubSetTable[i].fMax; set_item.min = tPubSetTable[i].fMin; set_item.def = tPubSetTable[i].fDef; set_item.list_index = set_get_list_index(tPubSetTable[i].list); set_item.group = tPubSetTable[i].group; memcpy(p + fh.set_extpub_addr + i * sizeof(set_item), (char *)&set_item, sizeof(set_item)); } for (i = 0; i < fh.set_extsw_num; i++) { set_item.type = tSwSetTable[i].wType; set_item.unit = tSwSetTable[i].wUnit; len = strlen(tSwSetTable[i].szName); if (len >= MOD_NAME_LEN - 1) { rt_free(p); return -3; } memset(set_item.name, 0, sizeof(set_item.name)); memcpy(set_item.name, tSwSetTable[i].szName, len); { set_item.max = tSwSetTable[i].fMax; set_item.min = tSwSetTable[i].fMin; } set_item.def = tSwSetTable[i].fDef; set_item.list_index = set_get_list_index(tSwSetTable[i].list); set_item.group = tSwSetTable[i].group; memcpy(p + fh.set_extsw_addr + i * sizeof(set_item), (char *)&set_item, sizeof(set_item)); } // 写内部定值 for (i = 0; i < fh.set_int_num; i++) { set_item.type = tCstSetTable[i].wType; set_item.unit = tCstSetTable[i].wUnit; len = strlen(tCstSetTable[i].szName); if (len >= MOD_NAME_LEN - 1) { rt_free(p); return -4; } memset(set_item.name, 0, sizeof(set_item.name)); memcpy(set_item.name, tCstSetTable[i].szName, len); set_item.max = tCstSetTable[i].fMax; set_item.min = tCstSetTable[i].fMin; set_item.def = tCstSetTable[i].fDef; set_item.list_index = set_get_list_index(tCstSetTable[i].list); set_item.group = tCstSetTable[i].group; memcpy(p + fh.set_int_addr + i * sizeof(set_item), (char *)&set_item, sizeof(set_item)); } // 写装置参数 for (i = 0; i < fh.set_arg_num; i++) { set_item.type = tEquipParaTable[i].wType; set_item.unit = tEquipParaTable[i].wUnit; len = strlen(tEquipParaTable[i].szName); if (len >= MOD_NAME_LEN - 1) { rt_free(p); return -5; } memset(set_item.name, 0, sizeof(set_item.name)); memcpy(set_item.name, tEquipParaTable[i].szName, len); set_item.max = tEquipParaTable[i].fMax; set_item.min = tEquipParaTable[i].fMin; if ((tEquipParaTable[i].wType == SETTYPE_IP) || (tEquipParaTable[i].wType == SETTYPE_YMD) || (tEquipParaTable[i].wType == SETTYPE_HMS)) { memcpy(&set_item.def, &tEquipParaTable[i].list, 4); } else { set_item.def = tEquipParaTable[i].fDef; } set_item.list_index = set_get_list_index(tEquipParaTable[i].list); set_item.group = tEquipParaTable[i].group; memcpy(p + fh.set_arg_addr + i * sizeof(set_item), (char *)&set_item, sizeof(set_item)); } // 写列表结构 num = 0; for (i = 0; i < fh.list_sum_num; i++) { for (j = 0; j < g_list_all[i].num; j++) { list_item.value = g_list_all[i].list[j].dat; len = strlen(g_list_all[i].list[j].str); if (len >= MOD_NAME_LEN - 1) { rt_free(p); return -6; } memset(list_item.name, 0, sizeof(list_item.name)); memcpy(list_item.name, g_list_all[i].list[j].str, len); memcpy(p + fh.list_addr + num * sizeof(list_item), (char *)&list_item, sizeof(list_item)); num++; } } // 写列表结构描述总表 num = 0; for (i = 0; i < fh.list_sum_num; i++) { list_sum_item.index = num; list_sum_item.num = g_list_all[i].num; memcpy(p + fh.list_sum_addr + i * sizeof(list_sum_item), (char *)&list_sum_item, sizeof(list_sum_item)); num += list_sum_item.num; } // 写单位表 for (i = 0; i < fh.unit_num; i++) { len = strlen(SetUints[i]); if (len >= MOD_NAME_LEN - 1) { rt_free(p); return -7; } memset(unit_item.unit, 0, sizeof(unit_item.unit)); memcpy(unit_item.unit, SetUints[i], len); memcpy(p + fh.unit_addr + i * sizeof(unit_item), (char *)&unit_item, sizeof(unit_item)); } // 创建描述文件 pfile = rt_file_open("/tmp/" FILE_NAME_SET_DESC, O_CREAT | O_RDWR | O_TRUNC, 0); if (IS_ERR(pfile)) { return -8; } // 计算CRC g_crc_set_desc = CrcStr(p, file_length); memcpy(p + file_length, &g_crc_set_desc, 2); pos = 0; rt_file_write(pfile, p, file_length + 2, &pos); rt_file_close(pfile, 0); setdesc_contrast.version = fh.cfh.version; setdesc_contrast.signature = fh.cfh.signature; setdesc_contrast.length = file_length + 2; setdesc_contrast.crc = g_crc_set_desc; rt_free(p); return 0; } /***************************************************************************** 函数名称：read_prjname 函数版本：1.00 作者： 创建日期：2013.10.14 函数功能说明： 输入参数： 输出参数：无 返回值： 成功时返回1，否则，0 函数扇入清单： *********************************************************************************/ int read_prjname(s8 *name) { if (e2prom_read(EEP_PRJNAME_ADDR, name, 64) != 0) return false; else return true; } /*********************************** 函数名称：write_prjname 函数版本：1.00 作者： 创建日期：2013.10.14 函数功能说明： 输入参数： 输出参数：无 返回值： 成功时返回1，否则，0 函数扇入清单： ***************************************/ int write_prjname(s8 *name) { if (e2prom_write(EEP_PRJNAME_ADDR, name, 64) != 0) return false; else return true; } // 建立数据文件 int set_create_data_file(void) { unsigned int addr, file_length; char *p; loff_t pos; struct file *pfile; // 写文件头 memset(&g_fh_data, 0, sizeof(g_fh_data)); g_fh_data.cfh.signature = SIG_SET_DATA_FILE; g_fh_data.cfh.version = SET_FILE_VERSION; g_fh_data.desc_signature = setdesc_contrast.signature; g_fh_data.desc_version = setdesc_contrast.version; g_fh_data.desc_length = setdesc_contrast.length; g_fh_data.desc_crc = setdesc_contrast.crc; read_prjname(g_fh_data.prj_name); g_fh_data.equ_sw_num = SWITCH_NUM_MAX; // 外部定值 g_fh_data.set_extpub_addr = FILE_ADDR_ALGIN(sizeof(g_fh_data)); g_fh_data.set_extpub_num = PUB_SET_NUMBER; addr = g_fh_data.set_extpub_addr + g_fh_data.set_extpub_num * 4; g_fh_data.set_extsw_addr = addr; g_fh_data.set_extsw_num = SW_SET_NUMBER * SWITCH_NUM_MAX; // 内部定值 addr = g_fh_data.set_extsw_addr + g_fh_data.set_extsw_num * 4; addr += (g_fh_data.set_extpub_num + g_fh_data.set_extsw_num + 7) / 8; g_fh_data.set_int_addr = FILE_ADDR_ALGIN(addr); g_fh_data.set_int_num = CSTSET_NUMBER; // 装置参数 addr = g_fh_data.set_int_addr + g_fh_data.set_int_num * 4; addr += (g_fh_data.set_int_num + 7) / 8; g_fh_data.set_arg_addr = FILE_ADDR_ALGIN(addr); g_fh_data.set_arg_num = EQUIP_PARA_NUMBER; // 得到文件长度 addr = g_fh_data.set_arg_addr + g_fh_data.set_arg_num * 4; addr += (g_fh_data.set_arg_num + 7) / 8; file_length = FILE_ADDR_ALGIN(addr); // 分配并初始化空间 p = rt_malloc(file_length + 2); // 加crc长度 if (!p) { return -1; } memset(p, 0, file_length); // 写入文件头 memcpy(p, (char *)&g_fh_data, sizeof(g_fh_data)); // 写外部定值 if (!ReadSet(m_runsection, (void *)(p + g_fh_data.set_extpub_addr))) // 读当前定值无效 { GetDefSet((float *)(p + g_fh_data.set_extpub_addr)); } // 写内部定值 if (!ReadPara((void *)(p + g_fh_data.set_int_addr), EEP_CSTSET_ADDR, CSTSET_NUMBER, &tCstSetTable[0])) { GetDefPara((float *)(p + g_fh_data.set_int_addr), CSTSET_NUMBER, &tCstSetTable[0]); } // 写装置参数 if (!ReadPara((void *)(p + g_fh_data.set_arg_addr), EEP_EQUIP_PARA_ADDR, EQUIP_PARA_NUMBER, &tEquipParaTable[0])) { GetDefPara((float *)(p + g_fh_data.set_arg_addr), EQUIP_PARA_NUMBER, &tEquipParaTable[0]); } // 创建数据文件 pfile = rt_file_open("/tmp/set_data.bin", O_CREAT | O_RDWR | O_TRUNC, 0); if (IS_ERR(pfile)) { rt_free(p); return -8; } // 计算CRC g_crc_set_data = CrcStr(p, file_length); memcpy(p + file_length, &g_crc_set_data, 2); pos = 0; rt_file_write(pfile, p, file_length + 2, &pos); rt_file_close(pfile, 0); rt_free(p); return 0; } int set_save_data_file(s32 index) { unsigned char *change_field, *local_data; unsigned int i, addr, file_length, len; unsigned short crc; int ret; u8 updata_flag[3] = {0}; int setdata_err = 0; struct set_file_head_data fh_data; u8 *buf; char file_name[64]; struct file *pfile; loff_t pos; local_data = 0; sprintf(file_name, "%s%s", g_file_item[index].file_dir, g_file_item[index].file_name); // 打开文件 pfile = rt_file_open(file_name, O_RDONLY, 0); if (IS_ERR(pfile)) { return -1; } // 得到文件长度 len = rt_file_getfile_size(pfile); if (len <= 0) { rt_file_close(pfile, 0); return -11; } // 分配内存 buf = rt_malloc(len); if ((buf) == NULL) { rt_file_close(pfile, 0); return -2; } // 读出内容 pos = 0; if (rt_file_read(pfile, buf, len, &pos) != len) { rt_file_close(pfile, 0); rt_free(buf); return -3; } // 关闭文件 rt_file_close(pfile, 0); // 检查CRC crc = CrcStr(buf, len - 2); if (crc != *(u16 *)(buf + len - 2)) { rt_free(buf); return -4; } // 配置文件头 memcpy(&fh_data, buf, sizeof(fh_data)); // 检查文件签名 if (fh_data.cfh.signature != SIG_SET_DATA_FILE) { rt_free(buf); return -6; } // 比对定值描述文件 if ((fh_data.desc_version != setdesc_contrast.version) || (fh_data.desc_signature != setdesc_contrast.signature) || (fh_data.desc_length != setdesc_contrast.length) || (fh_data.desc_crc != setdesc_contrast.crc)) { rt_free(buf); return -7; } // 得到文件长度 file_length = fh_data.set_arg_addr + fh_data.set_arg_num * 4; file_length += (fh_data.set_arg_num + 7) / 8; file_length = FILE_ADDR_ALGIN(file_length); file_length += 2; // CRC 长度 if (len != file_length) { rt_free(buf); return -8; } // 分配内存，用来保存本地定值参数值 local_data = rt_malloc(len); if (local_data == NULL) { rt_free(buf); // sunxi 20180719 return -9; } // 读取外部定值 if (!ReadSet(m_runsection, local_data + fh_data.set_extpub_addr)) { GetDefSet((void *)(local_data + fh_data.set_extpub_addr)); updata_flag[0] = true; setdata_err |= 0x01; } // 读取内部定值 if (!ReadPara((void *)(local_data + fh_data.set_int_addr), EEP_CSTSET_ADDR, CSTSET_NUMBER, &tCstSetTable[0])) { GetDefPara((void *)(local_data + fh_data.set_int_addr), CSTSET_NUMBER, &tCstSetTable[0]); updata_flag[1] = true; setdata_err |= 0x02; } // 读取装置参数 if (!ReadPara((void *)(local_data + fh_data.set_arg_addr), EEP_EQUIP_PARA_ADDR, EQUIP_PARA_NUMBER, &tEquipParaTable[0])) { GetDefPara((void *)(local_data + fh_data.set_arg_addr), EQUIP_PARA_NUMBER, &tEquipParaTable[0]); updata_flag[2] = true; setdata_err |= 0x04; } // 合并外部定值 change_field = buf + fh_data.set_extpub_addr + fh_data.set_extpub_num * 4 + fh_data.set_extsw_num * 4; for (i = 0; i < fh_data.set_extpub_num + fh_data.set_extsw_num; i++) { if ((change_field[i / 8] & (1 << (i % 8))) == 0) { // 使用本地数据 addr = fh_data.set_extpub_addr + i * 4; memcpy(buf + addr, local_data + addr, 4); } else { updata_flag[0] = true; } } // 合并内部定值 change_field = buf + fh_data.set_int_addr + fh_data.set_int_num * 4; for (i = 0; i < fh_data.set_int_num; i++) { if ((change_field[i / 8] & (1 << (i % 8))) == 0) { // 使用本地数据 addr = fh_data.set_int_addr + i * 4; memcpy(buf + addr, local_data + addr, 4); } else { updata_flag[1] = true; } } // 合并装置参数 change_field = buf + fh_data.set_arg_addr + fh_data.set_arg_num * 4; for (i = 0; i < fh_data.set_arg_num; i++) { if ((change_field[i / 8] & (1 << (i % 8))) == 0) { // 使用本地数据 addr = fh_data.set_arg_addr + i * 4; memcpy(buf + addr, local_data + addr, 4); } else { updata_flag[2] = true; } } // 保存外部定值 if (updata_flag[0]) { if (SaveSet(m_runsection, (void *)(buf + fh_data.set_extpub_addr))) { soe_record_opt(EV_SET_OK, 0); MakeRunSet(false); rt_err_clr(ERR_CODE_SET, 0); } else { setdata_err |= 0x10; } } // 保存内部定值 if (updata_flag[1]) { if (SavePara((void *)(buf + fh_data.set_int_addr), EEP_CSTSET_ADDR, CSTSET_NUMBER, &tCstSetTable[0])) { soe_record_opt(EV_CSTSET_OK, 0); // 内部定值整定成功 MakeRunSet(false); // 将当前运行定值区转换为运行定值区 rt_err_clr(ERR_CODE_SET_IN, 0); } else { setdata_err |= 0x20; } } // 保存装置参数 if (updata_flag[2]) { if (SavePara((void *)(buf + fh_data.set_arg_addr), EEP_EQUIP_PARA_ADDR, EQUIP_PARA_NUMBER, &tEquipParaTable[0])) { soe_record_opt(EV_EQUPARA_OK, 0); MakeRunPara(false, false); rt_err_clr(ERR_CODE_EQU_PARA, 0); } else { setdata_err |= 0x40; } } #ifdef YPARA_LINK_S set_para_flag(); #endif write_prjname(fh_data.prj_name); if (setdata_err) { ret = setdata_err; } else { ret = 0; } // RET: if (local_data) { rt_free(local_data); } rt_free(buf); // sunxi 20180719 return ret; } void create_set_file(void) { if (g_creat_set_file) { set_create_data_file(); g_creat_set_file = 0; } } /****************************************************************************** 函数名称： mmd_get_set_dip_index() 函数版本： 01.01 创建作者： xxxxxx 创建日期： 2014-12-16 函数说明： 开关类型刷新定值显示 参数说明： set_type: 1 装置参数，2 保护定值，3 内部定值 返回值： 成功返回0. 修改记录： */ void mmd_get_set_dip_index(const TSETTABLE *pTable, int num) { int i; g_set_disp.num = 0; for (i = 0; i < num; i++) { if (pTable[i].wType != SETTYPE_LABEL) { g_set_disp.no[g_set_disp.num] = i; g_set_disp.num++; } } } void get_set_value(char *str, const TSETTABLE *pTable, float value) { WORD type = pTable->wType; DWORD wDat; wDat = (DWORD)value; if (type == SETTYPE_F) { sprintf(str, "%.3f", value); } else if (type == SETTYPE_LIST) { sprintf(str, "%s", pTable->list[wDat].str); } else if (type == SETTYPE_UINT || type == SETTYPE_5INT || type == SETTYPE_LINT || type == SETTYPE_4INT) { sprintf(str, "%d", wDat); } else if (type == SETTYPE_IP) { sprintf(str, "%d.%d.%d.%d", (u8)(wDat >> 24), (u8)(wDat >> 16), (u8)(wDat >> 8), (u8)(wDat >> 0)); } else if (type == SETTYPE_YMD) { sprintf(str, "%d年%d月%d日", 2000 + (u8)(wDat >> 16), (u8)(wDat >> 8), (u8)(wDat >> 0)); } else if (type == SETTYPE_HMS) { sprintf(str, "%d:%d:%d秒", (u8)(wDat >> 16), (u8)(wDat >> 8), (u8)(wDat >> 0)); } else { strcpy(str, "非法值"); } } void creatListString(void) { int i, j; loff_t pos; char tmpstr[256]; struct file *pfile; char *p = tmpstr; pfile = rt_file_open("/tmp/typeDefine.csv", O_CREAT | O_RDWR | O_TRUNC, 0); if (IS_ERR(pfile)) { return; } pos = 0; sprintf(p, "List序号,0,1,2,3,4,5,6,7,8,9,10,11,12 \r\n"); rt_file_write(pfile, p, strlen(p), &pos); for (i = 0; i < LIST_ALL_NUM; i++) { sprintf(p, "%d,", i + 1); for (j = 0; j < g_list_all[i].num; j++) { strcat(p, g_list_all[i].list[j].str); strcat(p, ","); } strcat(p, "\r\n"); rt_file_write(pfile, p, strlen(p), &pos); } rt_file_close(pfile, 0); } extern void creatModifyFile(void); void create_set_data_txt(void) // 生成txt格式的定值文件，保存在tmp文件下 { struct file *pfile; loff_t pos; char tmpstr[128]; char valstr[24]; char *p = tmpstr; int i; u8 setgroup[GROUP_NUM]; creatModifyFile(); creatListString(); return; // 创建描述文件 pfile = rt_file_open("/tmp/setdata_file.txt", O_CREAT | O_RDWR | O_TRUNC, 0); if (IS_ERR(pfile)) { return; } pos = 0; if (!ReadEppData(EEP_SETGROUP_ADDR, setgroup, GROUP_NUM)) { GetDefSetGroup(setgroup); } /*读取压板定值*/ if (!ReadPara((void *)m_SetBuf, EEP_PUB_ADDR + PUB_SETSIZE * m_runsection, PUB_SET_NUMBER, &tPubSetTable[0])) { GetDefPara((void *)m_SetBuf, PUB_SET_NUMBER, &tPubSetTable[0]); } for (i = 0; i < PUB_SET_NUMBER; i++) { if ((tPubSetTable[i].group == 0 || setgroup[tPubSetTable[i].group - 1])) // 定值分类组为0 或显示定制为1 { if (tPubSetTable[i].wType == SETTYPE_LABEL) { sprintf(p, "%s:\r\n", tPubSetTable[i].szName); } else { get_set_value(valstr, &tPubSetTable[i], m_SetBuf[i].ff); sprintf(p, " %-20.20s%-10.10s%s\r\n", tPubSetTable[i].szName, valstr, SetUints[tPubSetTable[i].wUnit]); } rt_file_write(pfile, p, strlen(p), &pos); } } if (!ReadPara((void *)m_SetBuf, EEP_SET_ADDR + SETSIZE * m_runsection, SW_SET_NUMBER, &tSwSetTable[0])) { GetDefPara((void *)m_SetBuf, SW_SET_NUMBER, &tSwSetTable[0]); } for (i = 0; i < SW_SET_NUMBER; i++) { if ((tSwSetTable[i].group == 0 || setgroup[tSwSetTable[i].group - 1])) // 定值分类组为0 或显示定制为1 { if (tSwSetTable[i].wType == SETTYPE_LABEL) { sprintf(p, "%s:\r\n", tSwSetTable[i].szName); } else { get_set_value(valstr, &tSwSetTable[i], m_SetBuf[i].ff); sprintf(p, " %-20.20s%-10.10s%s\r\n", tSwSetTable[i].szName, valstr, SetUints[tSwSetTable[i].wUnit]); } rt_file_write(pfile, p, strlen(p), &pos); } } rt_file_close(pfile, 0); } /************************************************************************ 函数名称：getTypeBeginIndexAndEndIndex 函数版本：V0.01 作 者： 创建日期：2021.08.05 形参说明：type：定值类型(公共、装置、开关、内部) *p_begin_no：存放在缓存区开始索引号的地址 *p_end_no：存放在缓存区结束索引号的地址 函数说明：获取这种类型的定值在缓存区的起始索引号和结束索引号 返 回 值：true：获取成功 false：获取失败 ************************************************************************/ static bool getTypeBeginIndexAndEndIndex(const BYTE type, int *p_begin_no, int *p_end_no) { int i; int arr_total; bool b_bg = false, b_eg = false; arr_total = sizeof(tCstValForwardTable) / sizeof(CSTVAL_FORWARD_TABLE); if (!arr_total) return false; for (i = 0; i < arr_total; i++) { if (tCstValForwardTable[i].valType == type && !b_bg) { *p_begin_no = i; b_bg = true; continue; } if (tCstValForwardTable[i].valType != type && b_bg) { *p_end_no = i; b_eg = true; break; } } if (!b_bg) return false; if (b_bg && !b_eg) { *p_end_no = i; } return true; } /************************************************************************ 函数名称：GetCstValForwardAddr 函数版本：V0.01 作 者： 创建日期：2021.08.05 形参说明：type：定值类型(公共、装置、开关、内部) index：定值索引号 函数说明：获取定值转发地址 返 回 值：定值转发地址 0：表示获取失败 ************************************************************************/ WORD GetCstValForwardAddr(const BYTE type, const int index) { int i; WORD addr = 0; int begin_no = 0, end_no = 0; if (!getTypeBeginIndexAndEndIndex(type, &begin_no, &end_no)) return 0; for (i = begin_no; i < end_no; i++) { if (tCstValForwardTable[i].arrIndex != index) continue; addr = tCstValForwardTable[i].forwardAddr; break; } return addr; } //========================== 本文件结束 =============================