T536_DTU/dtu/dtu_main_t536/app/set.c

/*******************************************************************************
版权所有：	
版本号：    1.00 
文件名：    set.c 
生成日期：  2008.8.16    
作者：      
功能说明：定值结构和定值修改
    
修改日志：  
日志1：           
修改者：    
修改日期：
修改内容：
修改原因：
****************************************************************************/
#include "head.h"
#ifdef CPU_FUXI
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
// #include "shm_comm_packet.h"
#include "shmem.h"
#else
#include "uart_user.h"
#include <linux/kmod.h>
#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))

int g_goose_net_type=0;

/**********************************************************************
公共定值
***********************************************************************/
const TSETTABLE tPubSetTable[]=
{
    /* 类型         单位        最小值 最大值               默认值    列表        列表数            组                遥调地址  类型    描述 */
	{SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_EQPPARA,  0x0000, NULL_R, "设备参数"},
    {SETTYPE_5INT, 	SET_A,      0,      2000,               600,    0,          0,              GROUP_SET_EQPPARA,  0x5001, FLOAT_R, "CT额定一次值"},	
    {SETTYPE_5INT, 	SET_A,      0,      100,                5,      0,          0,              GROUP_SET_EQPPARA,  0x5002, FLOAT_R, "CT额定二次值"},
	{SETTYPE_5INT, 	SET_A,      0,      2000,               100,    0,          0,              GROUP_SET_EQPPARA,  0x5003, FLOAT_R, "零序CT额定一次值"},
	{SETTYPE_5INT, 	SET_A,      0,      100,                5,      0,          0,              GROUP_SET_EQPPARA,  0x5004, FLOAT_R, "零序CT额定二次值"},
    {SETTYPE_5INT,  SET_U,	    0,      99999,              10000,  0,          0,              GROUP_SET_EQPPARA,  0x5005, FLOAT_R, "电源侧PT额定一次值"},
    {SETTYPE_5INT,  SET_U,	    0,      1000,               100,    0,          0,              GROUP_SET_EQPPARA,  0x5006, FLOAT_R, "电源侧PT额定二次值"},
    {SETTYPE_5INT,  SET_U, 	    0,      99999,              10000,  0,          0,              GROUP_SET_EQPPARA,  0x5007, FLOAT_R, "负荷侧PT额定一次值"},
    {SETTYPE_5INT,  SET_U, 	    0,      1000,               100,    0,          0,              GROUP_SET_EQPPARA,  0x5008, FLOAT_R, "负荷侧PT额定二次值"},
	{SETTYPE_LIST,	SET_NULL,   0,      TPT_TypeNum - 1,    2,      TPT_Type,	TPT_TypeNum,    GROUP_SET_EQPPARA,  0x0000, UINT_R,	"A侧PT接线方式"},
	{SETTYPE_LIST,	SET_NULL,   0,      TPT_TypeNum - 1,    2,		TPT_Type,	TPT_TypeNum,    GROUP_SET_EQPPARA,  0x0000, UINT_R,	"B侧PT接线方式"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,  	0,          0,              GROUP_SET_SCT,      0x0000, NULL_R,	"定值区"},
#ifdef FIXAREA_VERSION_T
    {SETTYPE_UINT,  SET_NULL,   0,      SEC_NUMBER - 1,     1,		0,          0,              GROUP_SET_SCT,      0x501a, UINT_R, "当前定值区号"},
    {SETTYPE_UINT,  SET_NULL,   0,      SEC_NUMBER - 1,     1,      0,          0,              GROUP_SET_SCT,      0x0000, UINT_R, "待召唤定值区号"},
    {SETTYPE_UINT,  SET_NULL,   0,      SEC_NUMBER - 1,     1,      0,          0,              GROUP_SET_SCT,      0x0000, UINT_R, "待执行定值区号"},
#else
    {SETTYPE_UINT,	SET_NULL,   1,      SEC_NUMBER - 1,     1,		0,          0,              GROUP_SET_SCT,      0x501a, UINT_R,	"定值区号"},
#endif

	{SETTYPE_LABEL, SET_NULL,   0,      0,                  0,  	0,			0,				GROUP_SET_PUBYB,    0x0000, NULL_R,	"运行软压板"},
    {SETTYPE_LIST,	SET_NULL,   0,      TTListNum - 1,		1,		TTList, 	TTListNum,		GROUP_SET_PUBYB,    0x5019, BOOL_R,	"远程运维投入"},

	{SETTYPE_LABEL,	SET_NULL,   0,      0,				    0, 		0,			0,				GROUP_SET_PUBSET,   0x0000, NULL_R,	"电压参数"},
	{SETTYPE_LIST,	SET_NULL,   0,      TTListNum - 1,		0,		TTList,		TTListNum,		GROUP_SET_PUBSET,   0x0000, BOOL_R,	"过电压投退"},
	{SETTYPE_F,		SET_U,      10.0,   380.0,			    110.0, 	0,			0,				GROUP_SET_PUBSET,   0x0000, FLOAT_R, "过电压定值"},
	{SETTYPE_F,		SET_S,      0,      999.0,			    999.0, 	0,			0,				GROUP_SET_PUBSET,   0x0000, FLOAT_R, "过电压时间"},
	{SETTYPE_LIST,	SET_NULL,   0,      TTListNum - 1,		0,		TTList,		TTListNum,		GROUP_SET_PUBSET,   0x0000, BOOL_R,	"低电压投退"},
	{SETTYPE_F,		SET_U,      10.0,  	380.0,			    90.0, 	0,			0,				GROUP_SET_PUBSET,   0x0000, FLOAT_R, "低电压定值"},
	{SETTYPE_F,		SET_S,      0,    	999.0,			    999.0, 	0,			0,				GROUP_SET_PUBSET,   0x0000, FLOAT_R, "低电压时间"},
	{SETTYPE_LIST,	SET_NULL,   0,      TTListNum - 1,		0,	    TTList,	    TTListNum,		GROUP_SET_PUBSET,   0x0000, BOOL_R,	"线路有压投退"},
	{SETTYPE_F, 	SET_U,      10.0,   380.0,			    70.0,   0,			0,			    GROUP_SET_PUBSET,   0x0000, FLOAT_R, "有压定值"},
	{SETTYPE_F, 	SET_S,      0,      999.0,			    0.1,    0,			0,			    GROUP_SET_PUBSET,   0x0000, FLOAT_R, "有压时间"},
	{SETTYPE_LIST,	SET_NULL,   0,      TTListNum - 1,		0,	    TTList,	    TTListNum,		GROUP_SET_PUBSET,   0x0000, BOOL_R,	"线路无压投退"},
	{SETTYPE_F, 	SET_U,      10.0,   380.0,			    30.0,   0,			0,			    GROUP_SET_PUBSET,   0x0000, FLOAT_R, "无压定值"},
	{SETTYPE_F, 	SET_S,      0,      999.0,			    0.1,    0,			0,			    GROUP_SET_PUBSET,   0x0000, FLOAT_R, "无压时间"},
	{SETTYPE_LIST,	SET_NULL,	0,      TTListNum - 1,		0,		TTList,     TTListNum,	    GROUP_SET_PUBSET,   0x0000, BOOL_R,	"直流电压1告警投退"},
	{SETTYPE_F, 	SET_U,		10.0,   100.0,			    20.0, 	0,			0,			    GROUP_SET_PUBSET,   0x0000, FLOAT_R, "直流电压1告警定值"},
	{SETTYPE_F, 	SET_S,	    0.1,    999.0,			    999.0,  0,			0,			    GROUP_SET_PUBSET,   0x0000, FLOAT_R, "直流电压1告警时间"},
	{SETTYPE_LIST,	SET_NULL,	0,      TTListNum - 1,		0,		TTList,     TTListNum,	    GROUP_SET_PUBSET,   0x0000, BOOL_R,	"直流电压2告警投退"},
	{SETTYPE_F, 	SET_U,		10.0,   100.0,			    20.0, 	0,			0,			    GROUP_SET_PUBSET,   0x0000, FLOAT_R, "直流电压2告警定值"},
	{SETTYPE_F, 	SET_S,	    0.1,    999.0,			    999.0,  0,			0,			    GROUP_SET_PUBSET,   0x0000, FLOAT_R, "直流电压2告警时间"},
#ifdef	CUSTOMIZE_BZT //备自投
	{SETTYPE_LIST,	SET_NULL,	0,      TTListNum - 1,		0,		TTList, 	TTListNum,	    GROUP_SET_PUBSET,   0x0000, BOOL_R, "失压分闸投退"},
	{SETTYPE_F, 	SET_U,	    0.0, 	220.0,			    66.0, 	0,			0,			    GROUP_SET_PUBSET,   0x0000, FLOAT_R, "失压分闸定值"},
	{SETTYPE_F, 	SET_S,	    0.0, 	99,			        0.1, 	0,			0,			    GROUP_SET_PUBSET,   0x0000, FLOAT_R, "失压分闸时间"},
#endif

	{SETTYPE_LABEL,	SET_NULL,   0,      0,                  0, 		0,			0,				GROUP_SET_FDL,      0x0000, NULL_R,	"非电量保护"},
	{SETTYPE_LIST,	SET_NULL,   0,      TZCKListNum - 1,    0,		TZCKList,   TZCKListNum,    GROUP_SET_FDL,      0x0000, UINT_R,	"非电量1保护"},
	{SETTYPE_LIST,	SET_NULL,   0,      TZCKListNum - 1,    0,		TZCKList,   TZCKListNum,    GROUP_SET_FDL,      0x0000, UINT_R,	"非电量2保护"},
	{SETTYPE_LIST,	SET_NULL,   0,      TZCKListNum - 1,    0,		TZCKList,   TZCKListNum,    GROUP_SET_FDL,      0x0000, UINT_R,	"非电量3保护"},
	{SETTYPE_LIST,	SET_NULL,   0,      TZCKListNum - 1,    0,		TZCKList,   TZCKListNum,    GROUP_SET_FDL,      0x0000, UINT_R,	"非电量4保护"},
	{SETTYPE_LIST,	SET_NULL,   0,      TZCKListNum - 1,    0,		TZCKList,   TZCKListNum,    GROUP_SET_FDL,      0x0000, UINT_R,	"非电量5保护"},
	{SETTYPE_LIST,	SET_NULL,   0,      TZCKListNum - 1,    0,		TZCKList,   TZCKListNum,    GROUP_SET_FDL,      0x0000, UINT_R,	"非电量6保护"},
	{SETTYPE_F,		SET_S, 		0,    	999.0,			    999.0,  0,			0,				GROUP_SET_FDL,      0x0000, FLOAT_R, "非电量1时间"},
	{SETTYPE_F,		SET_S, 		0,    	999.0,			    999.0,  0,			0,				GROUP_SET_FDL,      0x0000, FLOAT_R, "非电量2时间"},
	{SETTYPE_F,		SET_S, 		0,    	999.0,			    999.0,  0,			0,				GROUP_SET_FDL,      0x0000, FLOAT_R, "非电量3时间"},
	{SETTYPE_F,		SET_S, 		0,    	999.0,			    999.0,  0,			0,				GROUP_SET_FDL,      0x0000, FLOAT_R, "非电量4时间"},
	{SETTYPE_F,		SET_S, 		0,    	999.0,			    999.0,  0,			0,				GROUP_SET_FDL,      0x0000, FLOAT_R, "非电量5时间"},
	{SETTYPE_F,		SET_S, 		0,    	999.0,			    999.0,  0,			0,				GROUP_SET_FDL,      0x0000, FLOAT_R, "非电量6时间"},

    {SETTYPE_LABEL,	SET_NULL,	0,      0,				    0, 		0,			0,			    GROUP_SET_OTHERS_PUB, 	0x0000, NULL_R,	"其它"},
	{SETTYPE_LIST,	SET_NULL,	0,      TTListNum - 1,	    1,		TTList,     TTListNum,	    GROUP_SET_OTHERS_PUB, 	0x0000, NULL_R,	"经高阻接地方式"},
	{SETTYPE_LIST,	SET_NULL,	0,      TBLTYPENum - 1,	    0,		TBLTYPE,    TBLTYPENum,	    GROUP_SET_OTHERS_PUB, 	0x0000, NULL_R,	"小电流突变方式"},
	{SETTYPE_LIST,	SET_NULL,	0,      FilterTYPENum - 1,  2,		FilterTYPE, FilterTYPENum,	GROUP_SET_OTHERS_PUB, 	0x0000, NULL_R,	"信号滤波方式"},
	{SETTYPE_LIST,	SET_NULL,	0,      WaveletTYPENum - 1, 0,		WaveletTYPE,WaveletTYPENum,	GROUP_SET_OTHERS_PUB, 	0x0000, NULL_R,	"小波类型"},
	{SETTYPE_UINT,	SET_NULL,	1,      4,				    2,		0,			0,			    GROUP_SET_OTHERS_PUB, 	0x0000, NULL_R,	"小波卷积阶数"},
	{SETTYPE_LIST,	SET_NULL,	0,      TTListNum - 1,	    0,		TTList,     TTListNum,	    GROUP_SET_OTHERS_PUB, 	0x0000, NULL_R,	"H 变换"},
	{SETTYPE_F,	    SET_S,      0,   	999.0,		        10.0,   0,		    0,			    GROUP_SET_OTHERS_PUB,   0x0000, FLOAT_R, "同期合闸判断返回时间"},
#ifdef FUNC_SET_FA_JS
	{SETTYPE_F,		SET_S,      0,   	10,		            0.05,   0,		    0,			    GROUP_SET_OTHERS_PUB,   0x0000, FLOAT_R, "FA合闸解锁时间"},
#endif
#ifdef VOLT_ADAPTIVE_FACTOR
    {SETTYPE_LIST,	SET_NULL,   0,      TTListNum - 1,	    0, 	    TTList,	    TTListNum,		GROUP_SET_OTHERS_PUB,   0x0000, BOOL_R, "自适应电压系数"},
#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,      0x0000, NULL_R, "功能软压板"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_YB_GN,      0x500d, BOOL_R, "常规保护投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_YB_GN,      0x500e, BOOL_R, "自动重合闸投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_YB_GN,      0x500f, BOOL_R, "就地馈线自动化投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_YB_GN,      0x5010, BOOL_R, "智能分布式投入"},
#ifdef JZS_FUNCTION
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_YB_GN,      0,      BOOL_R, "集中式压板"},
#endif
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_YB_GN,      0x5011, BOOL_R, "同期合闸投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_YB_GN,      0x5012, BOOL_R, "自动解列投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_YB_GN,      0x5013, BOOL_R, "小电流接地保护投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_YB_GN,      0x5014, BOOL_R, "线路断线告警投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_YB_GN,      0x5015, BOOL_R, "不停电传动投入"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_YB_YX,      0x0000, NULL_R, "运行软压板"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      1,      TTList,     TTListNum,      GROUP_SET_YB_YX,      0x5016, BOOL_R, "自动化功能总投退软压板"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      1,      TTList,     TTListNum,      GROUP_SET_YB_YX,      0x5017, BOOL_R, "自动化功能总出口软压板"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      1,      TTList,     TTListNum,      GROUP_SET_YB_YX,      0x5018, BOOL_R, "重合闸软压板"},
#ifdef YK_SOFT_YB
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_YB_YX,      0,      BOOL_R, "遥控软压板"},
#endif

    /* 类型         单位        最小值 最大值               默认值    列表        列表数            组                      遥调地址  类型    描述 */
    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_BHTT,         0x0000, NULL_R, "常规保护控制字"},
    {SETTYPE_LIST,  SET_NULL,   0,      TZCKListNum - 1,    0,      TZCKList,   TZCKListNum,    GROUP_SET_BHTT,         0x500b, BOOL_R, "过流Ⅰ段投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TZCKListNum - 1,    0,      TZCKList,   TZCKListNum,    GROUP_SET_BHTT,         0x500c, BOOL_R, "过流Ⅱ段投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TZCKListNum - 1,    0,      TZCKList,   TZCKListNum,    GROUP_SET_BHTT,         0x0000, BOOL_R, "过流Ⅲ段投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TZCKListNum - 1,    0,      TZCKList,   TZCKListNum,    GROUP_SET_BHTT,         0x500d, BOOL_R, "过流Ⅰ段投方向"},
    {SETTYPE_LIST,  SET_NULL,   0,      TZCKListNum - 1,    0,      TZCKList,   TZCKListNum,    GROUP_SET_BHTT,         0x500e, BOOL_R, "过流Ⅱ段投方向"},
    {SETTYPE_LIST,  SET_NULL,   0,      TZCKListNum - 1,    0,      TZCKList,   TZCKListNum,    GROUP_SET_BHTT,         0x0000, BOOL_R, "过流Ⅲ段投方向"},
    {SETTYPE_LIST,  SET_NULL,   0,      TZCKListNum - 1,    0,      TZCKList,   TZCKListNum,    GROUP_SET_BHTT,         0x500f, BOOL_R, "PT断线检测投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TZCKListNum - 1,    0,      TZCKList,   TZCKListNum,    GROUP_SET_BHTT,         0x5010, BOOL_R, "零序过流Ⅰ段投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TZCKListNum - 1,    0,      TZCKList,   TZCKListNum,    GROUP_SET_BHTT,         0x5011, BOOL_R, "零序过流Ⅱ段投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TZCKListNum - 1,    0,      TZCKList,   TZCKListNum,    GROUP_SET_BHTT,         0x0000, BOOL_R, "零序过流Ⅲ段投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TZCKListNum - 1,    0,      TZCKList,   TZCKListNum,    GROUP_SET_BHTT,         0,      BOOL_R, "零序过电压保护"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_BHTT,         0,      BOOL_R, "后加速保护投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_BHTT,         0x5013, BOOL_R, "过流保护启动重合闸"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_BHTT,         0x5014, BOOL_R, "零序过流保护启动重合闸"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_BHTT,         0x5012, BOOL_R, "涌流识别投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_BHTT,         0x5012, BOOL_R, "非遮断保护投入"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_BHDZ,         0x0000, NULL_R, "常规保护整定值"},
    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_BHDZ,         0x5017, FLOAT_R, "过流Ⅰ段定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_BHDZ,         0x5018, FLOAT_R, "过流Ⅰ段时间"},
    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_BHDZ,         0x5019, FLOAT_R, "过流Ⅱ段定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_BHDZ,         0x501A, FLOAT_R, "过流Ⅱ段时间"},
    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_BHDZ,         0x0000, FLOAT_R, "过流Ⅲ段定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_BHDZ,         0x0000, FLOAT_R, "过流Ⅲ段时间"},
    {SETTYPE_F,     SET_A,      0,      50.0,               50.0,   0,          0,              GROUP_SET_BHDZ,         0x501B, FLOAT_R, "零序过流Ⅰ段定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_BHDZ,         0x501C, FLOAT_R, "零序过流Ⅰ段时间"},
    {SETTYPE_F,     SET_A,      0,      50.0,               50.0,   0,          0,              GROUP_SET_BHDZ,         0x501D, FLOAT_R, "零序过流Ⅱ段定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_BHDZ,         0x501E, FLOAT_R, "零序过流Ⅱ段时间"},
    {SETTYPE_F,     SET_A,      0,      50.0,               50.0,   0,          0,              GROUP_SET_BHDZ,         0x0000, FLOAT_R, "零序过流Ⅲ段定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_BHDZ,         0x0000, FLOAT_R, "零序过流Ⅲ段时间"},
    {SETTYPE_F,     SET_U,      0,      100.0,              100.0,  0,          0,              GROUP_SET_BHDZ,         0,      FLOAT_R, "零序过电压保护定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_BHDZ,         0,      FLOAT_R, "零序过电压保护时间"},
    {SETTYPE_F,     SET_S,      0,      600.0,              600.0,  0,          0,              GROUP_SET_BHDZ,         0,      FLOAT_R, "加速段保护开放时间"},
    {SETTYPE_F,     SET_A,      0,      50.0,               50.0,   0,          0,              GROUP_SET_BHDZ,         0,      FLOAT_R, "后加速过流保护定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_BHDZ,         0,      FLOAT_R, "后加速过流保护时间"},
    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_BHDZ,         0,      FLOAT_R, "后加速零序电流保护定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_BHDZ,         0,      FLOAT_R, "后加速零序电流保护时间"},
    {SETTYPE_F,     SET_NULL,   0.1,    0.35,               0.35,   0,          0,              GROUP_SET_BHDZ,         0x501F, FLOAT_R, "二次谐波闭锁系数"},
    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_BHDZ,         0x5017, FLOAT_R, "非遮断电流定值"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_CHZKZ,        0x0000, NULL_R, "自动重合闸控制字"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_CHZKZ,        0x5013, BOOL_R, "一次重合闸投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_CHZKZ,        0x5014, BOOL_R, "二次重合闸投入"},
#ifdef DISP_SET_CH_T3
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_CHZKZ,        0x0000, BOOL_R, "三次重合闸投入"},
#endif
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_CHZKZ,        0x5015, BOOL_R, "重合闸检同期"},
#ifdef CHZ_JWY_LM
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_CHZKZ,        0x0000, BOOL_R, "母线无压线路有压"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_CHZKZ,        0x0000, BOOL_R, "线路无压母线有压"},
#else
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_CHZKZ,        0x5016, BOOL_R, "重合闸检无压"},
#endif
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_CHZKZ,        0x5016, BOOL_R, "大电流闭锁重合投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_CHZKZ,        0x0000, BOOL_R, "偷跳启动重合"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_CHZDZ,        0x0000, NULL_R, "自动重合闸定值"},
    {SETTYPE_F,     SET_S,      0.3,    900,                900,    0,          0,              GROUP_SET_CHZDZ,        0x0000, FLOAT_R, "重合闸开放时间"},
    {SETTYPE_F,     SET_S,      0,      199.0,              199.0,  0,          0,              GROUP_SET_CHZDZ,        0x0000, FLOAT_R, "重合闸充电时间"},
    {SETTYPE_F,     SET_S,      0,      199.0,              199.0,  0,          0,              GROUP_SET_CHZDZ,        0x5020, FLOAT_R, "一次重合闸时间"},
    {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_CHZDZ,        0x5021, FLOAT_R, "二次重合闸闭锁时间"},
    {SETTYPE_F,     SET_S,      0,      199.0,              199.0,  0,          0,              GROUP_SET_CHZDZ,        0x5022, FLOAT_R, "二次重合闸时间"},
#ifdef DISP_SET_CH_T3
    {SETTYPE_F,     SET_S,      0,      199.0,              199.0,  0,          0,              GROUP_SET_CHZDZ,        0x0000, FLOAT_R, "三次重合闸时间"},
#endif
#ifdef DISP_CHZOKCHR_2_SW
    {SETTYPE_F,     SET_S,      0,      199.0,              199.0,  0,          0,              GROUP_SET_CHZDZ,        0x0000, FLOAT_R, "tou多次重合充电时间"},
    {SETTYPE_F,     SET_S,      0,      199.0,              199.0,  0,          0,              GROUP_SET_CHZDZ,        0x0000, FLOAT_R, "重合闸确认时间"},
#endif
    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_CHZDZ,        0x501F, FLOAT_R, "大电流闭锁重合闸定值"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_FAYB,         0x0000, NULL_R, "就地馈线自动化软压板"},
    {SETTYPE_LIST,  SET_NULL,   0,      KGFunListNum - 1,   1,      KGFunList,  KGFunListNum,   GROUP_SET_FAYB,         0x500C, UINT_R, "分段/联络模式"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_FATT,         0x0000, NULL_R, "就地馈线自动化控制字"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_FATT,         0x500D, BOOL_R, "电源侧得电延时合闸"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_FATT,         0x500E, BOOL_R, "负荷侧得电延时合闸"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_FATT,         0x500F, UINT_R, "A侧失电延时合闸"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_FATT,         0x5010, UINT_R, "B侧失电延时合闸"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_FATT,         0x5013, BOOL_R, "合到故障分闸"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_FATT,         0x5015, BOOL_R, "短时闭锁失压分"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_FATT,         0x5015, BOOL_R, "相间过流告警投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_FATT,         0x5015, BOOL_R, "接地告警投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TZCKListNum - 1,    0,      TTList,     TZCKListNum,    GROUP_SET_FATT,         0x5018, UINT_R, "合到零压保护"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_FATT,         0x5019, BOOL_R, "非遮断电流保护"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_FATT,         0x501A, BOOL_R, "PT断线告警"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_FATT,         0x0000, BOOL_R, "多次失压分闸闭锁"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_FATT,         0,      BOOL_R, "涌流识别投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_FATT,         0,      BOOL_R, "硬件残压闭锁"},

    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      1,      TTList,     TTListNum,      GROUP_SET_FATT,         0,      BOOL_R, "残压闭锁"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      1,      TTList,     TTListNum,      GROUP_SET_FATT,         0x5015, BOOL_R, "双侧有压闭锁合闸"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      1,      TTList,     TTListNum,      GROUP_SET_FATT,         0x5015, BOOL_R, "手动/遥控分闸闭锁得电合"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_FATT,         0x5015, BOOL_R, "手合无压闭锁分闸"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      1,      TTList,     TTListNum,      GROUP_SET_FATT,         0,      BOOL_R, "合到故障分闸闭锁合闸"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      1,      TTList,     TTListNum,      GROUP_SET_FATT,         0x5012, BOOL_R, "失电延时分闸"},
#ifdef FA_OC_COUNT
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_FATT,         0x0000, BOOL_R, "过流脉冲计数投退"},
#endif

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_FADZ,         0x0000, NULL_R, "馈线自动化定值"},
    {SETTYPE_F,     SET_PERUN,  0,      220.0,              80.0,   0,          0,              GROUP_SET_FADZ,         0x501B, FLOAT_R, "有压定值"},
    {SETTYPE_F,     SET_PERUN,  0,      220.0,              30.0,   0,          0,              GROUP_SET_FADZ,         0x501D, FLOAT_R, "无压定值"},
    {SETTYPE_F,     SET_S,      0,      99,                 99,     0,          0,              GROUP_SET_FADZ,         0x501F, FLOAT_R, "得电合闸延时(X时限)"},
    {SETTYPE_F,     SET_S,      0,      99,                 99,     0,          0,              GROUP_SET_FADZ,         0x5020, FLOAT_R, "故障检测时限(Y时限)"},
    {SETTYPE_F,     SET_S,      0,      300,                300,    0,          0,              GROUP_SET_FADZ,         0x5021, FLOAT_R, "失压合闸延时(XL时限)"},
    {SETTYPE_F,     SET_S,      0,      99,                 99,     0,          0,              GROUP_SET_FADZ,         0x5022, FLOAT_R, "失电分闸延时(Z时限)"},
    {SETTYPE_F,     SET_S,      0,      99,                 99,     0,          0,              GROUP_SET_FADZ,         0x5023, FLOAT_R, "闭锁分闸复归时间"},
    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_FADZ,         0x5024, FLOAT_R, "相间故障电流I段定值"},
    {SETTYPE_F,     SET_S,      0,      99,                 99,     0,          0,              GROUP_SET_FADZ,         0x5026, FLOAT_R, "相间故障电流I段时间"},
    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_FADZ,         0x5025, FLOAT_R, "相间故障电流II段定值"},
    {SETTYPE_F,     SET_S,      0,      99,                 99,     0,          0,              GROUP_SET_FADZ,         0x5026, FLOAT_R, "相间故障电流II段时间"},
    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_FADZ,         0x5025, FLOAT_R, "接地故障电流定值"},
    {SETTYPE_F,     SET_S,      0,      99,                 99,     0,          0,              GROUP_SET_FADZ,         0x0000, FLOAT_R, "接地故障时间定值"},
    {SETTYPE_F,     SET_U,      0,      100.0,              100.0,  0,          0,              GROUP_SET_FADZ,         0x0000, FLOAT_R, "复合电压低电压定值"},
    {SETTYPE_F,     SET_U,      0,      100.0,              100.0,  0,          0,              GROUP_SET_FADZ,         0x0000, FLOAT_R, "复合电压负序电压定值"},
    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_FADZ,         0x5024, FLOAT_R, "相间过流告警电流定值"},
    {SETTYPE_F,     SET_S,      0,      99,                 99,     0,          0,              GROUP_SET_FADZ,         0x5026, FLOAT_R, "相间过流告警时间定值"},
    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_FADZ,         0x5025, FLOAT_R, "接地告警电流定值"},
    {SETTYPE_F,     SET_S,      0,      99,                 99,     0,          0,              GROUP_SET_FADZ,         0x0000, FLOAT_R, "接地告警时间定值"},
    {SETTYPE_F,     SET_U,      0,      660.0,              660.0,  0,          0,              GROUP_SET_FADZ,         0x0000, FLOAT_R, "零序电压保护电压定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               0.6,    0,          0,              GROUP_SET_FADZ,         0x0000, FLOAT_R, "零序电压保护时间定值"},
    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_FADZ,         0x5027, FLOAT_R, "非遮断电流值"},
    {SETTYPE_F,     SET_NULL,   0.10,   0.35,               0.35,   0,          0,              GROUP_SET_FADZ,         0x0000, FLOAT_R, "二次谐波闭锁系数"},

    {SETTYPE_UINT,  SET_NULL,   1,      5,                  3,      0,          0,              GROUP_SET_FADZ,         0x0000, UINT_R, "多次失压分闸闭锁次数"},
    {SETTYPE_F,     SET_S,      0,      65536.0,            480.0,  0,          0,              GROUP_SET_FADZ,         0x0000, FLOAT_R, "多次失压分闸闭锁时间"},
    {SETTYPE_F,     SET_A,      0,      100.0,              0.05,   0,          0,              GROUP_SET_FADZ,         0x5025, FLOAT_R, "无流定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               0.1,    0,          0,              GROUP_SET_FADZ,         0x501C, FLOAT_R, "有压判定时间"},
    {SETTYPE_F,     SET_S,      0,      99.0,               0.1,    0,          0,              GROUP_SET_FADZ,         0x501E, FLOAT_R, "无压判定时间"},
    {SETTYPE_F,     SET_S,      0,      99,                 6,      0,          0,              GROUP_SET_FADZ,         0x5020, FLOAT_R, "联络充电时间"},
#if defined GD_AREA_ZHONGSHAN_2020
    {SETTYPE_F,     SET_S,      0,      99,                 99,     0,          0,              GROUP_SET_FADZ,         0x5026, FLOAT_R, "快速跳闸延时"},
#endif
#ifdef FA_OC_COUNT
    {SETTYPE_UINT,  SET_NULL,   1,      1000,               3,      0,          0,              GROUP_SET_FADZ,         0x0000, UINT_R, "过流脉冲次数"},
    {SETTYPE_F,     SET_S,      0.1,    65536.0,            300.0,  0,          0,              GROUP_SET_FADZ,         0x0000, FLOAT_R, "过流脉冲复归时间"},
#endif

#if defined GD_AREA_ECZD_2020
    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_GOOSETT,      0x0000, NULL_R, "智能分布式控制字"},
    {SETTYPE_LIST,  SET_NULL,   0,      TGooseFANum - 1,    0,      TGooseFA,   TGooseFANum,    GROUP_SET_GOOSETT,      0x0000, BOOL_R, "分布式FA方式"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_GOOSETT,      0x0000, BOOL_R, "联络自投投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_GOOSETT,      0x0000, BOOL_R, "过载闭锁自投投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_GOOSETT,      0x0000, BOOL_R, "首开关失压保护投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_GOOSETT,      0x0000, BOOL_R, "智能分布式启动重合闸"},
    {SETTYPE_LIST,  SET_NULL,   0,      TGooseKGNum - 1,    1,      TGooseKG,   TGooseKGNum,    GROUP_SET_GOOSETT,      0x0000, UINT_R, "本接点开关类型"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_GOOSEDZ,      0x0000, NULL_R, "智能分布式定值"},
    #if defined GD_AREA_ZHONGSHAN_2020
        {SETTYPE_F,     SET_A,      0.05,   100.0,              50.0,   0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "故障切除相电流I段"},
        {SETTYPE_F,     SET_S,      0,      100.0,              100.0,  0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "相电流I段跳闸延时"},
        {SETTYPE_F,     SET_A,      0.05,   100.0,              50.0,   0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "故障切除相电流II段"},
        {SETTYPE_F,     SET_S,      0,      100.0,              100.0,  0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "相电流II段跳闸延时"},
        {SETTYPE_F,     SET_A,      0.05,   100.0,              50.0,   0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "故障切除零序电流"},
        {SETTYPE_F,     SET_S,      0,      100.0,              100.0,  0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "零序电流跳闸延时"},
        {SETTYPE_F,     SET_S,      0.00,   100.0,              0.1,    0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "故障点下游开关隔离时间"},
        {SETTYPE_F,     SET_S,      0.01,   100.0,              1.0,    0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "首开关失压跳闸时限"},
        {SETTYPE_F,     SET_S,      0.01,   100.0,              5.0,    0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "供电恢复时限"},
        {SETTYPE_LIST,  SET_NULL,   0,      TGooseKGNum - 1,    1,      TGooseKG,   TGooseKGNum,    GROUP_SET_GOOSEDZ,      0x0000, UINT_R, "本接点开关类型"},
        {SETTYPE_LIST,  SET_NULL,   0,      FAKGTYPENum - 1,    1,      FAKGTYPE,   FAKGTYPENum,    GROUP_SET_GOOSEDZ,      0x0000, UINT_R, "开关位置类型"},
    #else
        {SETTYPE_F,     SET_U,      0.0,    330.0,              30.0,   0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "无压定值"},
        {SETTYPE_F,     SET_U,      0.0,    330.0,              70.0,   0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "有压定值"},
        {SETTYPE_F,     SET_A,      0.0,    100.0,              0.02,   0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "无流定值"},
        {SETTYPE_F,     SET_A,      0.05,   100.0,              50.0,   0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "分布式FA过流定值"},
        {SETTYPE_F,     SET_S,      0,      100.0,              100.0,  0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "分布式FA过流时间"},
        {SETTYPE_F,     SET_A,      0.05,   100.0,              50.0,   0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "分布式FA零序过流定值"},
        {SETTYPE_F,     SET_S,      0,      100.0,              100.0,  0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "分布式FA零序过流时间"},
        {SETTYPE_F,     SET_S,      0,      100.0,              100.0,  0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "联络自投充电延时"},
        {SETTYPE_F,     SET_S,      0.01,   100.0,              1.0,    0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "首开关失压跳闸延时"},
        {SETTYPE_F,     SET_A,      0.05,   100.0,              50.0,   0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "过载判断定值"},
        {SETTYPE_F,     SET_S,      0,      100.0,              100.0,  0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "失灵判断延时"},

        {SETTYPE_F,     SET_S,      0.01,   100.0,              100.0,  0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "故障隔离时限"},
        {SETTYPE_F,     SET_S,      0,      100.0,              5.0,    0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "供电恢复时限"},
    #endif
#else
    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_GOOSETT,         0x0000, NULL_R, "分布式FA控制字"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_GOOSETT,         0x0000, BOOL_R, "分布式FA功能"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_GOOSETT,         0x0000, BOOL_R, "首开关失压分闸"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_GOOSETT,         0x0000, BOOL_R, "本节点供电恢复"},
    {SETTYPE_LIST,  SET_NULL,   0,      TGooseFANum - 1,    0,      TGooseFA,   TGooseFANum,    GROUP_SET_GOOSETT,         0x0000, BOOL_R, "智能分布式动作类型"},
    {SETTYPE_LIST,  SET_NULL,   0,      TGooseKGNum - 1,    1,      TGooseKG,   TGooseKGNum,    GROUP_SET_GOOSETT,         0x0000, UINT_R, "本节点开关类型"},
    {SETTYPE_LIST,  SET_NULL,   0,      THHTYPENum - 1,     0,      THHTYPE,    THHTYPENum,     GROUP_SET_GOOSETT,         0x0000, UINT_R, "组网方式"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_GOOSETT,         0x0000, BOOL_R, "母线故障跳末开关"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_GOOSETT,         0x0000, BOOL_R, "涌流识别"},
    #ifdef GOOSE_NETTYPE_SET
        {SETTYPE_LIST,  SET_NULL,   0,      GOOSE_NET_ListNum - 1, 0,   GOOSE_NET_List, GOOSE_NET_ListNum, GROUP_CSTSET_OTHERS, 0x0000, UINT_R, "goose网络类型"},
    #endif

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_GOOSEDZ,         0x0000, NULL_R, "分布式FA定值"},
    #ifdef GD_AREA_ZHONGSHAN
        {SETTYPE_F,     SET_A,      0.05,   100.0,              50.0,   0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "故障切除相电流I段"},
        {SETTYPE_F,     SET_S,      0,      100.0,              100.0,  0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "相电流I段跳闸延时"},
        {SETTYPE_F,     SET_A,      0.05,   100.0,              50.0,   0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "故障切除相电流II段"},
        {SETTYPE_F,     SET_S,      0,      100.0,              100.0,  0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "相电流II段跳闸延时"},
        {SETTYPE_F,     SET_A,      0.05,   100.0,              50.0,   0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "故障切除零序电流"},
        {SETTYPE_F,     SET_S,      0,      100.0,              100.0,  0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "零序电流跳闸延时"},
    #endif
    {SETTYPE_F,     SET_S,      0.01,   100.0,              1.0,    0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "首开关失压分闸延时"},
    {SETTYPE_F,     SET_S,      100.0,  5.0,                0,      0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "恢复供电时间"},
    {SETTYPE_F,     SET_S,      0.00,   100.0,              0.1,    0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "故障隔离时间"},
    {SETTYPE_F,     SET_NULL,   0,      1.00,               0.15,   0,          0,              GROUP_SET_GOOSEDZ,      0x0000, FLOAT_R, "涌流识别定值"},
#endif

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_TQHZ,         0x0000, NULL_R, "同期合闸定值"},
    {SETTYPE_F,     SET_PERUN,  0,      220.0,              220.0,  0,          0,              GROUP_SET_TQHZ,         0x0000, FLOAT_R, "同期允许电压差"},
    {SETTYPE_F,     SET_ANG,    0.0,    30.0,               30.0,   0,          0,              GROUP_SET_TQHZ,         0x0000, FLOAT_R, "同期允许相角差"},
    {SETTYPE_F,     SET_HZ,     0.0,    5.0,                5.0,    0,          0,              GROUP_SET_TQHZ,         0x0000, FLOAT_R, "同期允许频率差"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_JLTT,         0x0000, NULL_R, "自动解列控制字"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_JLTT,         0x0000, BOOL_R, "电压越限解列投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_JLTT,         0x0000, BOOL_R, "电压滑差闭锁功能"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_JLTT,         0x0000, BOOL_R, "频率越限解列投入"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_JLTT,         0x0000, BOOL_R, "频率滑差闭锁功能"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_JLDZ,         0x0000, NULL_R, "自动解列定值"},
    {SETTYPE_F,     SET_S,      0,      60.0,               60.0,   0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "解列充电时间"},
    {SETTYPE_F,     SET_PERUN,  0,      220.0,              220.0,  0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "电压过低解列定值"},
    {SETTYPE_F,     SET_S,      0,      999.0,              999.0,  0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "电压过低解列时间"},
    {SETTYPE_F,     SET_PERUN,  0,      220.0,              220.0,  0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "低电压解列定值"},
    {SETTYPE_F,     SET_S,      0,      999.0,              999.0,  0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "低电压解列时间"},
    {SETTYPE_F,     SET_PERUN,  0,      380.0,              380.0,  0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "高电压解列定值"},
    {SETTYPE_F,     SET_S,      0,      999.0,              999.0,  0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "高电压解列时间"},
    {SETTYPE_F,     SET_PERUN,  0,      380.0,              380.0,  0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "电压过高解列定值"},
    {SETTYPE_F,     SET_S,      0,      999.0,              999.0,  0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "电压过高解列时间"},
    {SETTYPE_F,     SET_U_S,    0,      500.0,              500.0,  0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "电压滑差定值"},
    {SETTYPE_F,     SET_HZ,     45.0,   50.0,               50.0,   0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "频率过低解列定值"},
    {SETTYPE_F,     SET_S,      0,      999.0,              999.0,  0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "频率过低解列时间"},
    {SETTYPE_F,     SET_HZ,     45.0,   50.0,               50.0,   0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "低频解列定值"},
    {SETTYPE_F,     SET_S,      0,      999.0,              999.0,  0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "低频解列时间"},
    {SETTYPE_F,     SET_HZ,     50.0,   55.0,               55.0,   0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "高频解列定值"},
    {SETTYPE_F,     SET_S,      0,      999.0,              999.0,  0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "高频解列时间"},
    {SETTYPE_F,     SET_HZ,     50.0,   55.0,               55.0,   0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "频率过高解列定值"},
    {SETTYPE_F,     SET_S,      0,      999.0,              999.0,  0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "频率过高解列时间"},
    {SETTYPE_F,     SET_HZ_S,   0.5,    20.0,               20.0,   0,          0,              GROUP_SET_JLDZ,         0x0000, FLOAT_R, "频率滑差定值"},

#ifdef XDL_ZT // 小电流接地
    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_XDLJDTT,      0x0000, NULL_R, "小电流接地控制字"},
    {SETTYPE_LIST,  SET_NULL,   0,      TZCKListNum - 1,    0,      TZCKList,   TZCKListNum,    GROUP_SET_XDLJDTT,      0x0000, BOOL_R, "小电流接地保护"},
    {SETTYPE_LIST,  SET_NULL,   0,      START_ListNum - 1,  0,      START_List, START_ListNum,  GROUP_SET_XDLJDTT,      0x0000, BOOL_R, "小电流接地保护启动重合闸"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_XDLJDTT,      0x0000, BOOL_R, "小电流接地保护后加速"},
    {SETTYPE_LIST,  SET_NULL,   0,      XDLQDListNum - 1,   1,      XDLQDList,  XDLQDListNum,   GROUP_SET_XDLJDTT,      0x0000, UINT_R, "小电流启动类型"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_XDLJDDZ,      0x0000, NULL_R, "小电流接地定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               99.0,  0,          0,               GROUP_SET_XDLJDDZ,      0x0000, FLOAT_R, "小电流接地故障时间"},
    {SETTYPE_F,     SET_S,      0,      900.0,              900.0,  0,          0,              GROUP_SET_XDLJDDZ,      0x0000, FLOAT_R, "后加速开放时间"},
    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_XDLJDDZ,      0x0000, FLOAT_R, "小电流暂态电流"},
#elif defined FUN_JDXX 		// 接地选线
    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_XDLJD,         0x0000, NULL_R, "小电流接地辅助定值"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_XDLJD,         0x0000, BOOL_R, "接地选线告警投退"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_XDLJD,         0x0000, BOOL_R, "接地选线跳闸投退"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_XDLJD,         0x0000, BOOL_R, "接地选相投退"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_XDLJD,         0x0000, BOOL_R, "零序功率方向投退"},
    {SETTYPE_F,     SET_A,      0,      0.1,                0.001,  0,          0,              GROUP_SET_XDLJD,         0x0000, FLOAT_R, "接地电流零漂值"},
    {SETTYPE_F,     SET_A,      0,      1.8,                0.005,  0,          0,              GROUP_SET_XDLJD,         0x0000, FLOAT_R, "启动值"},
    {SETTYPE_UINT,  SET_NULL,   1,      32,                 2,      0,          0,              GROUP_SET_XDLJD,         0x0000, UINT_R, "启动点数"},
    {SETTYPE_UINT,  SET_NULL,   1,      32,                 4,      0,          0,              GROUP_SET_XDLJD,         0x0000, UINT_R, "确认点数"},
    {SETTYPE_UINT,  SET_NULL,   1,      128,                16,     0,          0,              GROUP_SET_XDLJD,         0x0000, UINT_R, "采样点数"},
    {SETTYPE_LIST,  SET_NULL,   0,      TVolSelListNum - 1, 8,      TVolSelList,TVolSelListNum, GROUP_SET_XDLJD,         0x0000, UINT_R, "参考电压选择"},
    {SETTYPE_F,     SET_U,      0.01,   220,                0.1,    0,          0,              GROUP_SET_XDLJD,         0x0000, FLOAT_R, "参考电压启动值"},
    {SETTYPE_F,     SET_U,      0,      100.0,              1.0,    0,          0,              GROUP_SET_XDLJD,         0x0000, FLOAT_R, "接地零序电压定值"},
    {SETTYPE_F,     SET_S,      0,      1000,               0,      0,          0,              GROUP_SET_XDLJD,         0x0000, FLOAT_R, "接地选线动作时间"},
    {SETTYPE_F,     SET_S,      0,      1000,               0,      0,          0,              GROUP_SET_XDLJD,         0x0000, FLOAT_R, "接地选线告警时间"},
    {SETTYPE_LIST,  SET_NULL,   0,      JDTYPENum - 1,      0,      JDTYPE,     JDTYPENum,      GROUP_SET_SWSET,         0x0000, UINT_R, "系统接地方式"},
#endif

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_LA,           0x0000, FLOAT_R, "线路断线告警"},
    {SETTYPE_F,     SET_S,      0,      99.0,               99.0,   0,          0,              GROUP_SET_LA,           0x0000, FLOAT_R, "线路断线告警确认时间"},
    {SETTYPE_F,     SET_NULL,   0,      BMLListNum,         0,      BMLList,    BMLListNum,     GROUP_SET_LA,           0x0000, FLOAT_R, "线路断线判定方式"},
    {SETTYPE_F,     SET_U,      0,      380.0,              380.0,  0,          0,              GROUP_SET_LA,           0x0000, FLOAT_R, "线路断线零压"},
    {SETTYPE_F,     SET_A,      0,      50.0,               50.0,   0,          0,              GROUP_SET_LA,           0x0000, FLOAT_R, "线路断线零流"},
    {SETTYPE_F,     SET_U,      0,      380.0,              380.0,  0,          0,              GROUP_SET_LA,           0x0000, FLOAT_R, "线路断线低电压"},

#ifdef FUNC_DRIVE
	{SETTYPE_LABEL, SET_NULL,   0,      0,                  0,  	0,			0,				GROUP_SET_BTDCD,    0x0000, NULL_R,	"传动开关定值"},
    {SETTYPE_F, 	SET_S,      0,      99.0,			    10,     0,			0,		        GROUP_SET_BTDCD,    0x0000, FLOAT_R, "延时合闸时间"},
    {SETTYPE_F, 	SET_S,      0,      99.0,			    15,     0,			0,		        GROUP_SET_BTDCD,    0x0000, FLOAT_R, "结束传动时间"},
    {SETTYPE_F, 	SET_S,      0,      99.0,			    0,	    0,			0,		        GROUP_SET_BTDCD,    0x0000, FLOAT_R, "延时分闸时间"},
    {SETTYPE_F, 	SET_S,      0,      99.0,			    0.3,    0,			0,		        GROUP_SET_BTDCD,    0x0000, FLOAT_R, "合闸结束传动时间"},
#endif

#ifdef FUNC_DRIVE_JY
    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_DRIVE,        0x0000, NULL_R, "传动功能"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_DRIVE,        0x0000, BOOL_R, "开关传动投入"},
    {SETTYPE_F,     SET_U,      0,      220.0,              0.0,    0,          0,              GROUP_SET_DRIVE,        0x0000, FLOAT_R, "传动模拟电源侧电压"},
    {SETTYPE_F,     SET_U,      0,      220.0,              0.0,    0,          0,              GROUP_SET_DRIVE,        0x0000, FLOAT_R, "传动模拟负荷侧电压"},
    {SETTYPE_F,     SET_U,      0,      220.0,              25.0,   0,          0,              GROUP_SET_DRIVE,        0x0000, FLOAT_R, "传动模拟零序电压"},
    {SETTYPE_F,     SET_A,      0,      100.0,              10.0,   0,          0,              GROUP_SET_DRIVE,        0x0000, FLOAT_R, "传动模拟电流"},
    {SETTYPE_F,     SET_A,      0,      100.0,              10.0,   0,          0,              GROUP_SET_DRIVE,        0x0000, FLOAT_R, "传动模拟零流"},
    {SETTYPE_F,     SET_S,      0,      100.0,              6.0,    0,          0,              GROUP_SET_DRIVE,        0x0000, FLOAT_R, "传动电源侧电压时间"},
    {SETTYPE_F,     SET_S,      0,      100.0,              6.0,    0,          0,              GROUP_SET_DRIVE,        0x0000, FLOAT_R, "传动负荷侧电压时间"},
    {SETTYPE_F,     SET_S,      0,      100.0,              1.0,    0,          0,              GROUP_SET_DRIVE,        0x0000, FLOAT_R, "传动零压时间"},
    {SETTYPE_F,     SET_S,      0,      100.0,              0.2,    0,          0,              GROUP_SET_DRIVE,        0x0000, FLOAT_R, "传动过流时间"},
    {SETTYPE_F,     SET_S,      0,      100.0,              0.2,    0,          0,              GROUP_SET_DRIVE,        0x0000, FLOAT_R, "传动零流时间"},
    {SETTYPE_F,     SET_S,      0,      100.0,              10.0,   0,          0,              GROUP_SET_DRIVE,        0x0000, FLOAT_R, "再次传动时间"},
#endif

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_FSX,          0x0000, NULL_R, "反时限保护"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_FSX,          0x0000, BOOL_R, "反时限投退"},
    {SETTYPE_F,     SET_A,      0.3,    10.0,               5.0,    0,          0,              GROUP_SET_FSX,          0x0000, FLOAT_R, "反时限基准值"},
    {SETTYPE_F,     SET_S,      0.005,  120.0,              120.0,  0,          0,              GROUP_SET_FSX,          0x0000, FLOAT_R, "反时限时间"},
    {SETTYPE_LIST,  SET_NULL,   0,      FSXListNum - 1,     0,      FSXList,    FSXListNum,     GROUP_SET_FSX,          0x0000, UINT_R, "反时限曲线"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,					0,		0,			0,				GROUP_SET_DLYX,         0x0000, NULL_R, "电流越限"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_DLYX,         0x0000, BOOL_R, "电流重载投入"},
    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_DLYX,         0x0000, FLOAT_R, "电流重载定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               99,     0,          0,              GROUP_SET_DLYX,         0x0000, FLOAT_R, "电流重载时间"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_DLYX,         0x0000, BOOL_R, "电流过载投入"},
    {SETTYPE_F,     SET_A,      0,      100.0,              100.0,  0,          0,              GROUP_SET_DLYX,         0x0000, FLOAT_R, "电流过载定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               99,     0,          0,              GROUP_SET_DLYX,         0x0000, FLOAT_R, "电流过载时间"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_DLYX,         0x0000, BOOL_R, "负荷越上限投入"},
    {SETTYPE_F,     SET_A,      0,      10.0,               5.0,    0,          0,              GROUP_SET_DLYX,         0x0000, FLOAT_R, "负荷越上限定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               99,     0,          0,              GROUP_SET_DLYX,         0x0000, FLOAT_R, "负荷越上限时间"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_DLYX,         0x0000, BOOL_R, "零序电流越限投退"},
    {SETTYPE_F,     SET_A,      0.1,    10.0,               5.0,    0,          0,              GROUP_SET_DLYX,         0x0000, FLOAT_R, "零序电流越限定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               99,     0,          0,              GROUP_SET_DLYX,         0x0000, FLOAT_R, "零序电流越限时间"},
    
    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_RECORD,    0x0000, NULL_R, "录波"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_RECORD,    0x0000, BOOL_R, "过流故障启动"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_RECORD,    0x0000, BOOL_R, "零序过流启动"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_RECORD,    0x0000, BOOL_R, "零序电压启动"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_RECORD,    0x0000, BOOL_R, "线路失压启动"},
	{SETTYPE_LIST,	SET_NULL, 	0 , 	TTListNum - 1,	    0 ,		TTList,	    TTListNum,	    GROUP_SET_RECORD,    0x0000, BOOL_R, "零压突变启动"},
	{SETTYPE_F,		SET_U, 	    0.01, 	220.0,			    6.5 ,	0,		    0,			    GROUP_SET_RECORD,    0x0000, FLOAT_R, "零压突变定值"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_RECORD,    0x0000, BOOL_R, "零流突变启动"},
	{SETTYPE_F,		SET_A, 	    0.01, 	100.0,			    5.0 ,	0,		    0,			    GROUP_SET_RECORD,    0x0000, FLOAT_R, "零流突变定值"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_RECORD,    0x0000, BOOL_R, "重合闸启动"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_RECORD,    0x0000, BOOL_R, "残压启动"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_RECORD,    0x0000, BOOL_R, "FA动作"},
#if defined FUN_JDXX || defined XDL_ZT
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_RECORD,    0x0000, BOOL_R, "小电流接地启动"},
#endif

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_SWSET,         0x0000, NULL_R, "辅助定值"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_SWSET,         0x0000, BOOL_R, "功率取反投退"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_SWSET,         0x0000, BOOL_R, "保护方向取反投退"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_SWSET,         0x0000, BOOL_R, "未储能告警"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_SWSET,         0x0000, BOOL_R, "控制回路检查"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_SWSET,         0x0000, BOOL_R, "气压低闭锁分合闸"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_SWSET,         0x0000, BOOL_R, "PT1断线检查投退"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_SWSET,         0x0000, BOOL_R, "PT2断线检查投退"},

#ifdef CUSTOMIZE_BZT // 备自投
    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_SET_BZT,         0x0000, NULL_R, "备自投"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_SET_BZT,         0x0000, BOOL_R, "备自投投退	"},
    {SETTYPE_LIST,  SET_NULL,   0,      BZTFSListNum - 1,   0,      BZTFSList,  BZTFSListNum,   GROUP_SET_BZT,         0x0000, UINT_R, "备自投方式	"},
    {SETTYPE_F,     SET_S,      0.01,   15.0,               10.0,   0,          0,              GROUP_SET_BZT,         0x0000, FLOAT_R, "备自投跳闸时间"},
    {SETTYPE_F,     SET_S,      0.01,   15.0,               10.0,   0,          0,              GROUP_SET_BZT,         0x0000, FLOAT_R, "备自投合闸时间"},
    {SETTYPE_F,     SET_S,      1.0,    20.0,               5.0,    0,          0,              GROUP_SET_BZT,         0x0000, FLOAT_R, "备自投充电时间"},
    {SETTYPE_F,     SET_U,      0,      440.0,              100,    0,          0,              GROUP_SET_BZT,         0x0000, FLOAT_R, "备自投有压定值"},
    {SETTYPE_F,     SET_U,      0,      440.0,              40,     0,          0,              GROUP_SET_BZT,         0x0000, FLOAT_R, "备自投失压定值"},
    {SETTYPE_F,     SET_A,      0,      5.0,                0.1,    0,          0,              GROUP_SET_BZT,         0x0000, FLOAT_R, "备自投无流定值"},

    {SETTYPE_LIST,  SET_NULL,   0,      TVolSelListNum - 1, 0,      TVolSelList, TVolSelListNum, GROUP_SET_BZT,         0x0000, UINT_R, "备自投母线电压1"},
    {SETTYPE_LIST,  SET_NULL,   0,      TVolSelListNum - 1, 3,      TVolSelList, TVolSelListNum, GROUP_SET_BZT,         0x0000, UINT_R, "备自投母线电压2"},
    {SETTYPE_LIST,  SET_NULL,   0,      TVolSelListNum - 1, 0,      TVolSelList, TVolSelListNum, GROUP_SET_BZT,         0x0000, UINT_R, "备自投1#进线电压"},
    {SETTYPE_LIST,  SET_NULL,   0,      TVolSelListNum - 1, 3,      TVolSelList, TVolSelListNum, GROUP_SET_BZT,         0x0000, UINT_R, "备自投2#进线电压"},
    {SETTYPE_LIST,  SET_NULL,   0,      TISelListNum - 1,   0,      TISelList,  TISelListNum,   GROUP_SET_BZT,          0x0000, UINT_R, "备自投1#进线电流"},
    {SETTYPE_LIST,  SET_NULL,   0,      TISelListNum - 1,   0,      TISelList,  TISelListNum,   GROUP_SET_BZT,          0x0000, UINT_R, "备自投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,   0x0000, NULL_R, "保护功能"},
#ifdef XDL_ZT
    {SETTYPE_F,     SET_U,      0,      220.0,              220.0,  0,          0,              GROUP_CSTSET_PROTECT,   0x0000, FLOAT_R, "小电流零压1定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               0.04,   0,          0,              GROUP_CSTSET_PROTECT,   0x0000, FLOAT_R, "小电流零压1时间"},
    {SETTYPE_F,     SET_U,      0,      220.0,              220.0,  0,          0,              GROUP_CSTSET_PROTECT,   0x0000, FLOAT_R, "小电流零压2定值"},
    {SETTYPE_F,     SET_S,      0,      99.0,               0.04,   0,          0,              GROUP_CSTSET_PROTECT,   0x0000, FLOAT_R, "小电流零压2时间"},
#endif

    {SETTYPE_F,     SET_NULL,   0,      65536.0,            1.2,    0,          0,              GROUP_CSTSET_PROTECT,   0x0000, FLOAT_R, "幅值加速滤波系数"},
    {SETTYPE_F,     SET_A,      0.01,   25.0,               2.0,    0,          0,              GROUP_CSTSET_PROTECT,   0x0000, FLOAT_R, "突变量定值"},
    {SETTYPE_F,     SET_A,      0,      5.0,                0.1,    0,          0,              GROUP_CSTSET_PROTECT,   0x0000, FLOAT_R, "无流定值"},
    {SETTYPE_F,     SET_S,      0.2,    60.0,               5.0,    0,          0,              GROUP_CSTSET_PROTECT,   0x0000, FLOAT_R, "整组复归时间"},
    {SETTYPE_F,     SET_S,      0.01,   10.0,               0.15,   0,          0,              GROUP_CSTSET_PROTECT,   0x0000, FLOAT_R, "跳闸失败时间"},
    {SETTYPE_F,     SET_S,      0.01,   10.0,               2.0,    0,          0,              GROUP_CSTSET_PROTECT,   0x0000, FLOAT_R, "合闸失败时间"},
#ifndef DISP_CHZOKCHR_2_SW
    {SETTYPE_F,     SET_S,      15.0,   300.0,              180.0,  0,          0,              GROUP_CSTSET_PROTECT,   0x0000, FLOAT_R, "二次重合充电时间"},
    {SETTYPE_F,     SET_S,      0.3,    999.0,              180.0,  0,          0,              GROUP_CSTSET_PROTECT,   0x0000, FLOAT_R, "重合确认时间"},
#endif

    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_PROTECT,   0x0000, BOOL_R, "零压闭锁零流"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_PROTECT,   0x0000, BOOL_R, "低压闭锁过流"},
    {SETTYPE_F,     SET_U,      1.0,    100.0,              100.0,  0,          0,              GROUP_CSTSET_PROTECT,   0x0000, FLOAT_R, "零压闭锁定值"},
    {SETTYPE_F,     SET_U,      10.0,   220.0,              80.0,   0,          0,              GROUP_CSTSET_PROTECT,   0x0000, FLOAT_R, "低压闭锁定值"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_PROTECT,   0x0000, BOOL_R, "低频滑差闭锁投退"},
    {SETTYPE_F, SET_HZ_S,       0.3,    10.0,               0.3,    0,          0,              GROUP_CSTSET_PROTECT,   0x0000, FLOAT_R, "低频减载滑差"},
#ifdef PRO_AL_LOCK_HZ
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_PROTECT,   0x0000, BOOL_R, "解列闭锁重合闸"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_PROTECT,   0x0000, BOOL_R, "解列后启动重合闸判频率"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_PROTECT,   0x0000, BOOL_R, "解列后启动重合闸判电压"},
#endif

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_CSTSET_CALC,      0x0000, NULL_R, "计算功能"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_CALC,      0x0000, BOOL_R, "频率跟踪投退"},
    {SETTYPE_UINT,  SET_NULL,   1,      15,                 13,     0,          0,              GROUP_CSTSET_CALC,      0x0000, UINT_R, "谐波计算次数"},
    {SETTYPE_F,     SET_NULL,   0,      1.0,                0.01,   0,          0,              GROUP_CSTSET_CALC,      0x0000, BOOL_R, "谐波校正系数"},
    {SETTYPE_5INT,  SET_NULL,   -100.0, 100.0,              0.0,    0,          0,              GROUP_CSTSET_CALC,      0x0000, INT_R, "交流温漂(ppm)"},
    {SETTYPE_5INT,  SET_NULL,   -10000.0, 10000.0,          0.0,    0,          0,              GROUP_CSTSET_CALC,      0x0000, INT_R, "直流温漂(ppm)"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      1,      TTList,     TTListNum,      GROUP_CSTSET_CALC,      0x0000, BOOL_R, "归零值投退"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_CALC,      0x0000, BOOL_R, "零序电压自产"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_CSTSET_COMM,      0x0000, NULL_R, "通讯功能"},
    {SETTYPE_5INT,  SET_S,      0,      3600,               20,     0,          0,              GROUP_CSTSET_COMM,      0x0000, UINT_R, "101子站重发"},
    {SETTYPE_5INT,  SET_S,      0,      3600,               600,    0,          0,              GROUP_CSTSET_COMM,      0x0000, UINT_R, "101通道时间"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_COMM,      0x0000, BOOL_R, "101初始化原因03"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_COMM,      0x0000, BOOL_R, "104序号检查"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_COMM,      0x0000, BOOL_R, "101FCB检查"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_COMM,      0x0000, BOOL_R, "点号连续上送"},
    {SETTYPE_LIST,  SET_NULL,   0,      JMListNum - 1,      0,      JMList,     JMListNum,      GROUP_CSTSET_COMM,      0x0000, UINT_R, "加密功能"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_COMM,      0x0000, BOOL_R, "远动测试模式"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_COMM,      0x0000, BOOL_R, "SOE通讯续传"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_COMM,      0x0000, BOOL_R, "SOE上电续传"},
#ifdef FIX_PARAM_FORMAT
    {SETTYPE_LIST,  SET_NULL,   0,      TULF8ListNum - 1,   1,      TULF8List,  TULF8ListNum,   GROUP_CSTSET_COMM,      0x0000, UTINY_R, "固定参数上送格式"},
#endif
    {SETTYPE_LIST,  SET_NULL,   0,      EQUListNum - 1,     0,      EQUList,    EQUListNum,     GROUP_CSTSET_COMM,      0x0000, BOOL_R, "装置类型"},
    {SETTYPE_F,     SET_NULL,   0,      1.0,                0.01,   0,          0,              GROUP_CSTSET_COMM,      0x0000, FLOAT_R, "遥测滤波系数"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_CSTSET_FA,        0x0000, NULL_R, "馈线自动化"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_FA,        0x0000, BOOL_R, "瞬压板投退"},
    {SETTYPE_F,     SET_S,      0,      100.0,              15,     0,          0,              GROUP_CSTSET_FA,        0x0000, FLOAT_R, "DFA充电时间"},
    {SETTYPE_F,     SET_S,      1.0,    100.0,              60,     0,          0,              GROUP_CSTSET_FA,        0x0000, FLOAT_R, "DFA隔离放电时间"},
    {SETTYPE_F,     SET_S,      1.0,    100.0,              15,     0,          0,              GROUP_CSTSET_FA,        0x0000, FLOAT_R, "DFA恢复放电时间"},
    {SETTYPE_F,     SET_S,      1.0,    100.0,              15,     0,          0,              GROUP_CSTSET_FA,        0x0000, FLOAT_R, "DFA禁止转发时间 "},
    {SETTYPE_F,     SET_S,      0.1,    100.0,              0.3,    0,          0,              GROUP_CSTSET_FA,        0x0000, FLOAT_R, "DFA发送展宽时间"},
    {SETTYPE_F,     SET_S,      0.01,   0.1,                0.040,  0,          0,              GROUP_CSTSET_FA,        0x0000, FLOAT_R, "goose判断时间"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_FA,        0x0000, BOOL_R, "负荷开关goose发布"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_FA,        0x0000, BOOL_R, "goose发布在故障确认后"},
    {SETTYPE_F,     SET_S,      0.00,   10.0,               6.0,    0,          0,              GROUP_CSTSET_FA,        0x0000, FLOAT_R, "单侧来电解锁时间"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_FA,        0x0000, BOOL_R, "FA闭锁合闸禁止遥合"},
#ifdef FA_PL_PJ
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_FA,        0x0000, BOOL_R, "有压判频率"},
#endif
    {SETTYPE_LIST,  SET_NULL,   0,      UYY_ListNum - 1,    0,      UYY_List,   UYY_ListNum,    GROUP_CSTSET_FA,        0x0000, UINT_R, "有压判据"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_CSTSET_RECORD,    0x0000, NULL_R, "录波功能"},
    {SETTYPE_LIST,  SET_NULL,   0,      WFListNum - 1,      1,      WFList,     WFListNum,      GROUP_CSTSET_RECORD,    0x0000, UINT_R, "文件格式"},
    {SETTYPE_LIST,  SET_NULL,   0,      LB_VOL_ListNum - 1, 0,      LB_VOL_List,LB_VOL_ListNum, GROUP_CSTSET_RECORD,    0x0000, UINT_R, "电压选择"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_RECORD,    0x0000, BOOL_R, "虚拟遥信记录"},
    {SETTYPE_LIST,  SET_NULL,   0,      RCL_ListNum - 1,    0,      RCL_List,   RCL_ListNum,    GROUP_CSTSET_RECORD,    0x0000, BOOL_R, "遥信描述类型"},
    {SETTYPE_UINT,  SET_NULL,   1,      32,                 1,      0,          0,              GROUP_CSTSET_RECORD,    0x0000, UINT_R, "本开关间隔号"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_CSTSET_OTHERS,    0x0000, NULL_R, "辅助定值"},
    {SETTYPE_UINT,  SET_S,      1,      30,                 20,     0,          0,              GROUP_CSTSET_OTHERS,    0x0000, UINT_R, "未储能告警时间"},
    {SETTYPE_UINT,  SET_S,      0,      65535,              0,      0,          0,              GROUP_CSTSET_OTHERS,    0x0000, UINT_R, "失电闭锁遥信时间"},
    {SETTYPE_F,     SET_HOUR,   0,      100.0,              0.5,    0,          0,              GROUP_CSTSET_OTHERS,    0x0000, FLOAT_R, "电池充满维持时间"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_OTHERS,    0x0000, BOOL_R, "记录文件投退"},
    {SETTYPE_LIST,  SET_NULL,   0,      HisFileFormatListNum - 1, 0,HisFileFormatList, HisFileFormatListNum, GROUP_CSTSET_OTHERS, 0x0000, UTINY_R, "记录文件格式"},
    {SETTYPE_LIST,  SET_NULL,   0,      TFGKEY_TYPE_TOTAL - 1, 1,   TFGKEY_Type, TFGKEY_TYPE_TOTAL, GROUP_CSTSET_OTHERS, 0x0000, UINT_R, "复归按键复用功能选择"},
    {SETTYPE_UINT,  SET_S,      0,      60,                 3,      0,          0,              GROUP_CSTSET_OTHERS,    0x0000, UINT_R, "复归按键复用功能防抖时间"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_OTHERS,    0x0000, BOOL_R, "远动参数有效"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_OTHERS,    0x0000, BOOL_R, "现场运行模式"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_OTHERS,    0x0000, BOOL_R, "101文件传输确认帧"},
    {SETTYPE_UINT,  SET_NULL,   0,      2000,               0,      0,          0,              GROUP_CSTSET_OTHERS,    0x0000, UINT_R, "测量差值"},
    {SETTYPE_F,     SET_U,      0,      150,                48,     0,          0,              GROUP_CSTSET_OTHERS,    0x0000, FLOAT_R, "直流电压定值"},
    {SETTYPE_UINT,  SET_NULL,   1,      2,                  1,      0,          0,              GROUP_CSTSET_OTHERS,    0x0000, UINT_R, "直流通道数"},
    {SETTYPE_LIST,  SET_NULL,   0,      TPT_UNum - 1,       0,      PUList,     TPT_UNum,       GROUP_CSTSET_OTHERS,    0x0000, UINT_R, "负荷侧电压选择"},
    {SETTYPE_LIST,  SET_NULL,   0,      DISPMODEListNum - 1,0,      DISPMODEList, DISPMODEListNum,  GROUP_CSTSET_OTHERS, 0x0000, UINT_R, "液晶遥测数据显示"},
    {SETTYPE_LIST,  SET_NULL,   0,      AddrNumListNum - 1, 0,      AddrNumList, AddrNumListNum,    GROUP_CSTSET_OTHERS, 0x0000, BOOL_R, "故障事件遥信地址长度"},
#ifdef YC_QUANTITY
    {SETTYPE_UINT,  SET_NULL,   1,      999,                50,     0,          0,              GROUP_CSTSET_OTHERS,    0x0000, UINT_R, "每间隔遥参数量"},
#endif

#ifdef METERING_ENERGY
    {SETTYPE_LIST,  SET_NULL,   0,      DDListNum - 1,      DDListNum - 1, DDList, DDListNum,   GROUP_CSTSET_OTHERS,    0x0000, UINT_R, "电度计算方式"},
    {SETTYPE_LIST,  SET_NULL,   0,      JLFSListNum - 1,    0,      JLFSList,   JLFSListNum,    GROUP_CSTSET_OTHERS,    0x0000, UINT_R, "计量接线方式"},
    {SETTYPE_LIST,  SET_NULL,   0,      WGFSListNum - 1,    0,      WGFSList,   WGFSListNum,    GROUP_CSTSET_OTHERS,    0x0000, UINT_R, "无功电能算法"},
#endif
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_OTHERS,    0x0000, BOOL_R, "SOE遥测系数投退"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_CSTSET_OTHERS,    0x0000, BOOL_R, "遥测总死区有效投退"},
};
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,    0x0000, NULL_R, "规约参数"},
    {SETTYPE_5INT,  SET_NULL,   1,      65535,              1,      0,          0,              GROUP_PARA_PROTOCAL,    0x0000, UINT_R, "装置地址"},
    {SETTYPE_LIST,  SET_NULL,   0,      PTTypeListNum - 1,  0,      PTTypeList, PTTypeListNum,  GROUP_PARA_PROTOCAL,    0x0000, UINT_R, "遥信报文类型"},
    {SETTYPE_LIST,  SET_NULL,   0,      PTTypeListNum - 1,  2,      PTTypeList, PTTypeListNum,  GROUP_PARA_PROTOCAL,    0x0000, UINT_R, "遥控报文类型"},
    {SETTYPE_LIST,  SET_NULL,   0,      YCTypeListNum - 1,  2,      YCTypeList, YCTypeListNum,  GROUP_PARA_PROTOCAL,    0x0000, UINT_R, "遥测报文类型"},
    {SETTYPE_F,     SET_S,      0,      3600,               0.4,    0,          0,              GROUP_PARA_PROTOCAL,    0x0000, FLOAT_R, "遥测发送间隔"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_PARA_PROTOCAL,    0x0000, BOOL_R, "遥测自动上送"},
    {SETTYPE_LIST,  SET_NULL,   0,      YCTypeDeadNum - 1,  0,      YCTypeDead, YCTypeDeadNum,  GROUP_PARA_PROTOCAL,    0x0000, BOOL_R, "遥测上传死区类型"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_PARA_PROTOCAL,    0x0000, BOOL_R, "COS自动上送"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_PARA_PROTOCAL,    0x0000, BOOL_R, "事件参数上送"},
    {SETTYPE_5INT,  SET_S,      10,     3600,               300,    0,          0,              GROUP_PARA_PROTOCAL,    0x0000, UINT_R, "遥控超时时间"},
    {SETTYPE_LIST,  SET_NULL,   0,      IEC101AddrListNum - 1, 1, IEC101AddrList, IEC101AddrListNum, GROUP_PARA_PROTOCAL, 0x0000, BOOL_R, "101链路地址"},
    {SETTYPE_LIST,  SET_NULL,   0,      IEC101AddrListNum - 1, 1, IEC101AddrList, IEC101AddrListNum, GROUP_PARA_PROTOCAL, 0x0000, BOOL_R, "101应用地址"},
    {SETTYPE_LIST,  SET_NULL,   0,      IEC101AddrListNum - 1, 1, IEC101AddrList, IEC101AddrListNum, GROUP_PARA_PROTOCAL, 0x0000, BOOL_R, "101传送原因"},
    {SETTYPE_LIST,  SET_NULL,   0,      T104ServerListNum - 1, 0, T104ServerList, T104ServerListNum, GROUP_PARA_PROTOCAL, 0x0000, BOOL_R, "104规约模式"},
    {SETTYPE_5INT,  SET_NULL,   0,      65535,              2404,   0,          0,              GROUP_PARA_PROTOCAL,    0x0000, UINT_R, "104规约端口"},
    {SETTYPE_5INT,  SET_S,      1,      65535,              30,     0,          0,              GROUP_PARA_PROTOCAL,    0x0000, UINT_R, "104确认超时"},
    {SETTYPE_5INT,  SET_S,      1,      65535,              30,     0,          0,              GROUP_PARA_PROTOCAL,    0x0000, UINT_R, "104测试超时"},
    {SETTYPE_5INT,  SET_NULL,   0,      48,                 12,     0,          0,              GROUP_PARA_PROTOCAL,    0x0000, UINT_R, "104 K值"},
    {SETTYPE_5INT,  SET_NULL,   0,      48,                 8,      0,          0,              GROUP_PARA_PROTOCAL,    0x0000, UINT_R, "104 W值"},
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0,      GROUP_PARA_PROTOCAL,    0x0000, STR_R, "104主站1 IP"},
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0,      GROUP_PARA_PROTOCAL,    0x0000, STR_R, "104主站2 IP"},
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0,      GROUP_PARA_PROTOCAL,    0x0000, STR_R, "104主站3 IP"},
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0,      GROUP_PARA_PROTOCAL,    0x0000, STR_R, "104主站4 IP"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_PARA_LINK,        0x0000, NULL_R, "104子站通信"},
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0,      GROUP_PARA_LINK,         0x0000, STR_R, "104子站1 IP"},
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0,      GROUP_PARA_LINK,         0x0000, STR_R, "104子站2 IP"},
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0,      GROUP_PARA_LINK,         0x0000, STR_R, "104子站3 IP"},
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0,      GROUP_PARA_LINK,         0x0000, STR_R, "104子站4 IP"},
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0,      GROUP_PARA_LINK,         0x0000, STR_R, "104子站5 IP"},
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0,      GROUP_PARA_LINK,         0x0000, STR_R, "104子站6 IP"},
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0,      GROUP_PARA_LINK,         0x0000, STR_R, "104子站7 IP"},
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0,      GROUP_PARA_LINK,         0x0000, STR_R, "104子站8 IP"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_PARA_SERIAL,          0x0000, NULL_R, "串行口通道"},
    {SETTYPE_LIST,  SET_NULL,   0,      ProtocolListNum - 1,0,      ProtocolList, ProtocolListNum, GROUP_PARA_SERIAL,       0x0000, UINT_R, "485口1规约"},
    {SETTYPE_LIST,  SET_NULL,   0,      BaudListNum - 1,    4,      BaudList,   BaudListNum,    GROUP_PARA_SERIAL,          0x0000, UINT_R, "485口1波特率"},
    {SETTYPE_LIST,  SET_NULL,   0,      ParityListNum - 1,  2,      ParityList, ParityListNum,  GROUP_PARA_SERIAL,          0x0000, UINT_R, "485口1校验"},
    {SETTYPE_LIST,  SET_NULL,   0,      ProtocolListNum - 1,0,      ProtocolList, ProtocolListNum, GROUP_PARA_SERIAL,       0x0000, UINT_R, "485口2规约"},
    {SETTYPE_LIST,  SET_NULL,   0,      BaudListNum - 1,    4,      BaudList,   BaudListNum,    GROUP_PARA_SERIAL,          0x0000, UINT_R, "485口2波特率"},
    {SETTYPE_LIST,  SET_NULL,   0,      ParityListNum - 1,  2,      ParityList, ParityListNum,  GROUP_PARA_SERIAL,          0x0000, UINT_R, "485口2校验"},
    {SETTYPE_LIST,  SET_NULL,   0,      ProtocolListNum - 1,0,      ProtocolList, ProtocolListNum, GROUP_PARA_SERIAL,       0x0000, UINT_R, "232口1规约"},
    {SETTYPE_LIST,  SET_NULL,   0,      BaudListNum - 1,    4,      BaudList,   BaudListNum,    GROUP_PARA_SERIAL,          0x0000, UINT_R, "232口1波特率"},
    {SETTYPE_LIST,  SET_NULL,   0,      ParityListNum - 1,  2,      ParityList, ParityListNum,  GROUP_PARA_SERIAL,          0x0000, UINT_R, "232口1校验方式"},
    {SETTYPE_LIST,  SET_NULL,   0,      ProtocolListNum - 1,0,      ProtocolList, ProtocolListNum, GROUP_PARA_SERIAL,       0x0000, UINT_R, "232口2规约"},
    {SETTYPE_LIST,  SET_NULL,   0,      BaudListNum - 1,    4,      BaudList,   BaudListNum,    GROUP_PARA_SERIAL,          0x0000, UINT_R, "232口2波特率"},
    {SETTYPE_LIST,  SET_NULL,   0,      ParityListNum - 1,  2,      ParityList, ParityListNum,  GROUP_PARA_SERIAL,          0x0000, UINT_R, "232口2校验方式"},
    {SETTYPE_LIST,  SET_NULL,   0,      ProtocolListNum - 1,7,      ProtocolList, ProtocolListNum, GROUP_PARA_SERIAL,       0x0000, UINT_R, "GPS串口5规约"},
    {SETTYPE_LIST,  SET_NULL,   0,      BaudListNum - 1,    4,      BaudList, BaudListNum, GROUP_PARA_SERIAL,               0x0000, UINT_R, "GPS串口5波特率"},
    {SETTYPE_LIST,  SET_NULL,   0,      ParityListNum - 1,  2,      ParityList, ParityListNum, GROUP_PARA_SERIAL,           0x0000, UINT_R, "GPS串口5校验"},
    {SETTYPE_LIST,  SET_NULL,   0,      ProtocolListNum - 1,0,      ProtocolList, ProtocolListNum, GROUP_PARA_SERIAL,       0x0000, UINT_R, "备用串口6规约"},
    {SETTYPE_LIST,  SET_NULL,   0,      BaudListNum - 1,    4,      BaudList,   BaudListNum,    GROUP_PARA_SERIAL,          0x0000, UINT_R, "备用串口6波特率"},
    {SETTYPE_LIST,  SET_NULL,   0,      ParityListNum - 1,  2,      ParityList, ParityListNum,  GROUP_PARA_SERIAL,          0x0000, UINT_R, "备用串口6校验方式"},
    {SETTYPE_LIST,  SET_NULL,   0,      ProtocolListNum - 1,0,      ProtocolList, ProtocolListNum, GROUP_PARA_SERIAL,       0x0000, UINT_R, "备用串口7规约"},
    {SETTYPE_LIST,  SET_NULL,   0,      BaudListNum - 1,    4,      BaudList,   BaudListNum,    GROUP_PARA_SERIAL,          0x0000, UINT_R, "备用串口7波特率"},
    {SETTYPE_LIST,  SET_NULL,   0,      ParityListNum - 1,  2,      ParityList, ParityListNum,  GROUP_PARA_SERIAL,          0x0000, UINT_R, "备用串口7校验"},
#ifdef FUN_FUXI_ESAM
    {SETTYPE_LIST,  SET_NULL,   0,      ProtocolListNum - 1,2,      ProtocolList, ProtocolListNum, GROUP_PARA_SERIAL,       0x0000, UINT_R, "南网加密规约"},
    {SETTYPE_LIST,  SET_NULL,   0,      BaudListNum - 1,    7,      BaudList,   BaudListNum,    GROUP_PARA_SERIAL,          0x0000, UINT_R, "南网加密波特率"},
    {SETTYPE_LIST,  SET_NULL,   0,      ParityListNum - 1,  0,      ParityList, ParityListNum,  GROUP_PARA_SERIAL,          0x0000, UINT_R, "南网加密校验"},
#endif

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_PARA_ETHERNET,        0x0000, NULL_R, "以太网通道"},
    {SETTYPE_LIST,  SET_NULL,   0,      Net_Eth_ListNum - 1,0,      Net_Eth_List, Net_Eth_ListNum, GROUP_PARA_ETHERNET,     0x0000, UINT_R, "1#_网络"},
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0xc0a80164, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "1#IP地址"},   // IP 192.168.1.100
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0xffffff00, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "1#子网掩码"}, // 255.255.255.0
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "1#目标网络"}, // 192.168.64.240
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "1#目标掩码"}, // 0.0.0.0
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "1#网关"},     // 192.168.64.240
    {SETTYPE_LIST,  SET_NULL,   0,      Net_Eth_ListNum - 1,1, Net_Eth_List, Net_Eth_ListNum, GROUP_PARA_ETHERNET,          0x0000, UINT_R, "2#_网络"},
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0xc0a80264, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "2#IP地址"},   // IP 192.168.2.100
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0xffffff00, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "2#子网掩码"}, // 255.255.255.0
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "2#目标网络"}, // IP 192.168.2.100
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "2#目标掩码"}, // 0.0.0.0
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "2#网关"},     // 192.168.2.100
    {SETTYPE_LIST,  SET_NULL,   0,      Net_Eth_ListNum - 1,2, Net_Eth_List, Net_Eth_ListNum, GROUP_PARA_ETHERNET,          0x0000, UINT_R, "3#_网络"},
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0xc0a80364, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "3#IP地址"},   // IP 192.168.3.100
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0xffffff00, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "3#子网掩码"}, // 255.255.255.0
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "3#目标网络"}, // IP 192.168.3.100
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "3#目标掩码"}, // 0.0.0.0
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "3#网关"},     // 192.168.3.100
    {SETTYPE_LIST,  SET_NULL,   0,      Net_Eth_ListNum - 1,2, Net_Eth_List, Net_Eth_ListNum, GROUP_PARA_ETHERNET,          0x0000, UINT_R, "4#_网络"},
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0xc0a840f0, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "4#IP地址"},   // IP 192.168.4.100
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0xffffff00, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "4#子网掩码"}, // 255.255.255.0
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "4#目标网络"}, // 192.168.3.100
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "4#目标掩码"}, // 0.0.0.0
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "4#网关"},     // 192.168.3.254
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0xc0a840fe, 0, GROUP_PARA_ETHERNET,             0x0000, STR_R, "默认网关"},   // 192.168.64.254

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_PARA_TIME,            0x0000, NULL_R, "对时"},
    {SETTYPE_LIST,  SET_NULL,   0,      TimeListNum - 1,    0,      TimeList,   TimeListNum,    GROUP_PARA_TIME,            0x0000, UINT_R, "对时方式"},
    {SETTYPE_LIST,  SET_NULL,   0,      TimeListSelectNum - 1, 0,   TimeListSelect, TimeListSelectNum, GROUP_PARA_TIME,     0x0000, UINT_R, "标准化对时方式"},
    {SETTYPE_4INT,  SET_S,      1,      300,                1,      0,          0,              GROUP_PARA_TIME,            0x0000, UINT_R, "卫星对时间隔"},
    {SETTYPE_4INT,  SET_MIN,    1,      6000,               60,     0,          0,              GROUP_PARA_TIME,            0x0000, UINT_R, "对时切换时长"},
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff,         0,      (void *)0x00000000, 0,      GROUP_PARA_TIME,             0x0000, STR_R, "SNTP服务器IP"},
    {SETTYPE_5INT,  SET_S,      10,     1024,               64,     0,          0,              GROUP_PARA_TIME,            0x0000, UINT_R, "SNTP对时间隔"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_PARA_BATTERY,         0x0000, NULL_R, "电池管理"},
    {SETTYPE_YMD,   SET_NULL,   0,      0xffffffff,         0,      0,          0,              GROUP_PARA_BATTERY,         0x0000, ULONG_R, "活化启动时间"},
    {SETTYPE_UINT,  SET_HOUR,   0,      23,                 0,      0,          0,              GROUP_PARA_BATTERY,         0x0000, UINT_R, "电池活化时刻"},
    {SETTYPE_UINT,  SET_D,      0,      360,                0,      0,          0,              GROUP_PARA_BATTERY,         0x0000, UINT_R, "电池活化周期"},
    {SETTYPE_F,     SET_HOUR,   1.0,    100.0,              6.0,    0,          0,              GROUP_PARA_BATTERY,         0x0000, FLOAT_R, "电池告警阀值"},

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_PARA_RMT,             0x0000, NULL_R, "远动参数"},
#ifdef PARAM_DEAD_PER
    {SETTYPE_F,     SET_PER,    0.0,    100.0,              1.0,    0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "遥测死区"},
#else
    {SETTYPE_F,     SET_NULL,   0,      0.3,                0.01,   0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "遥测死区"},
#endif
#ifndef PARAM_DEAD_PER
    {SETTYPE_F,     SET_PER,    0.0,    0.3,                0.01,   0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "电流死区"},
    {SETTYPE_F,     SET_PER,    0.0,    0.3,                0.01,   0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "交流电压死区"},
    {SETTYPE_F,     SET_PER,    0.0,    0.3,                0.01,   0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "直流电压死区"},
    {SETTYPE_F,     SET_PER,    0.0,    0.3,                0.01,   0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "功率死区"},
    {SETTYPE_F,     SET_PER,    0.0,    0.3,                0.05,   0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "频率死区"},
    {SETTYPE_F,     SET_PER,    0.0,    0.3,                0.01,   0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "功率因数死区"},
#else
    {SETTYPE_F,     SET_PER,    0.0,    100.0,              1.0,    0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "电流死区"},
    {SETTYPE_F,     SET_PER,    0.0,    100.0,              1.0,    0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "交流电压死区"},
    {SETTYPE_F,     SET_PER,    0.0,    100.0,              1.0,    0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "直流电压死区"},
    {SETTYPE_F,     SET_PER,    0.0,    100.0,              1.0,    0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "功率死区"},
    {SETTYPE_F,     SET_PER,    0.0,    100.0,              1.0,    0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "频率死区"},
    {SETTYPE_F,     SET_PER,    0.0,    100.0,              1.0,    0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "功率因数死区"},
#endif
    {SETTYPE_LINT,  SET_MS,     0.0,    60000.0,            20.0,   0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "遥信防抖时间"},
    {SETTYPE_LINT,  SET_MS,     0.0,    60000.0,            200.0,  0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "分闸脉冲"},
    {SETTYPE_LINT,  SET_MS,     0.0,    60000.0,            200.0,  0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "合闸脉冲"},
    {SETTYPE_F,     SET_U,      0,      20.0,               5,      0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "电压零漂"},
    {SETTYPE_F,     SET_A,      0,      1.0,                0.25,   0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "相电流零漂"},
    {SETTYPE_F,     SET_A,      0,      1.0,                0.04,   0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "零序电流零漂"},
#ifdef CPU_FUXI
    {SETTYPE_F,     SET_U,      0,      20.0,               1,      0,          0,              GROUP_PARA_RMT,             0x0000, FLOAT_R, "直流电压零漂"},
#endif

    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_PARA_OTHERS,          0x0000, NULL_R, "其它"},
    {SETTYPE_LINT,  SET_MS,     0.0,    60000.0,            200.0,  0,          0,              GROUP_PARA_OTHERS,          0x0000, FLOAT_R, "合分闸脉冲"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_PARA_OTHERS,          0x0000, BOOL_R, "信号自动复归投退"},
    {SETTYPE_5INT,  SET_MIN,    0,      3000,               2880,   0,          0,              GROUP_PARA_OTHERS,          0x0000, FLOAT_R, "信号自动复归时间"},

#ifdef YX_RESET_TIME
    {SETTYPE_F,     SET_S,      0,      6000,               3,      0,          0,              GROUP_PARA_OTHERS,          0x0000, FLOAT_R, "故障遥信保持时间"},
#endif

    {SETTYPE_5INT,  SET_S,      0,      65535,              180,    0,          0,              GROUP_PARA_OTHERS,          0x0000, UINT_R, "液晶背光时间"},
    {SETTYPE_LIST,  SET_NULL,   0,      LinkListNum - 1,    1,      LinkList,   LinkListNum,    GROUP_PARA_OTHERS,          0x0000, UINT_R, "级联状态监测"},
#if (defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020)
    {SETTYPE_UINT,  SET_NULL,   1,      32,                 1,      0,          0,              GROUP_PARA_OTHERS,          0x0000, FLOAT_R, "GOOSE通信ID"},
    {SETTYPE_F,     SET_S,      0,      100.0,              6.0,    0,          0,              GROUP_PARA_OTHERS,          0x0000, FLOAT_R, "GOOSE通信T1"},
    {SETTYPE_F,     SET_S,      0,      100.0,              3.0,    0,          0,              GROUP_PARA_OTHERS,          0x0000, FLOAT_R, "GOOSE通信T2"},
#endif

#ifdef RCD_STRAN_M_EN
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_PARA_OTHERS,         0x0000, BOOL_R, "级联录波主站使能"},
#endif

#ifdef YPARA_LINK_S_EN
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_PARA_OTHERS,         0x0000, BOOL_R, "子站参数变化通知"},
#endif

#ifdef FUN_FUXI_ESAM
    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_PARA_S1,              0x0000, NULL_R, "南网加密配置(重新配置需重启)"},
    {SETTYPE_LIST,  SET_NULL,   0,      T104ServerListNum - 1,  0,  T104ServerList, T104ServerListNum, GROUP_PARA_S1,       0x0000, BOOL_R, "加密工作模式"},
    {SETTYPE_5INT,  SET_NULL,   0,      65535,              2404,   0,          0,              GROUP_PARA_S1,              0x0000, UINT_R, "加密监听端口"},

    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff, 0,  (void *)0x00000000, 0, GROUP_PARA_S1,   0x0000, STR_R, "NAT"},        // 192.168.1.100
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff, 0,  (void *)0xc0a80296, 0, GROUP_PARA_S1,   0x0000, STR_R, "加密IP地址"}, // 192.168.1.100
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff, 0,  (void *)0xffffff00, 0, GROUP_PARA_S1,   0x0000, STR_R, "加密掩码"},   // 255.255.255.0
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff, 0,  (void *)0xc0a80201, 0, GROUP_PARA_S1,   0x0000, STR_R, "加密网关"},   // 192.168.1.1
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff, 0,  (void *)0xac100001, 0, GROUP_PARA_S1,   0x0000, STR_R, "远端IP地址"}, // 192.168.0.2
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff, 0,  (void *)0xffffff00, 0, GROUP_PARA_S1,   0x0000, STR_R, "远端掩码"},   // 255.255.255.0
    {SETTYPE_IP,    SET_NULL,   0,      0xffffffff, 0,  (void *)0xac100014, 0, GROUP_PARA_S1,   0x0000, STR_R, "远端网关"},   // 192.168.0.1
#endif

#ifdef METERING_ENERGY
    {SETTYPE_LABEL, SET_NULL,   0,      0,                  0,      0,          0,              GROUP_PARA_HISFILE,         0x0000, NULL_R, "历史文件"},
    {SETTYPE_UINT,  SET_MIN,    5,      60.0,               15.0,   0,          0,              GROUP_PARA_HISFILE,         0x0000, UINT_R, "遥测定点间隔时间"},
    {SETTYPE_LIST,  SET_NULL,   0,      TTListNum - 1,      0,      TTList,     TTListNum,      GROUP_PARA_HISFILE,         0x0000, BOOL_R, "线损文件投退"},
    {SETTYPE_UINT,  SET_NULL,   1,      16.0,               1.0,    0,          0,              GROUP_PARA_HISFILE,         0x0000, UINT_R, "开关ID"},
    {SETTYPE_UINT,  SET_MIN,    5,      60.0,               15.0,   0,          0,              GROUP_PARA_HISFILE,         0x0000, UINT_R, "线损定点间隔时间"},
    {SETTYPE_UINT,  SET_D,      1,      28.0,               1.0,    0,          0,              GROUP_PARA_HISFILE,         0x0000, UINT_R, "考核日冻结日"},
    {SETTYPE_UINT,  SET_HOUR,   0,      23.0,               0,      0,          0,              GROUP_PARA_HISFILE,         0x0000, UINT_R, "考核日冻结小时"},
#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, 0, "年"},
    {SETTYPE_UINT,  SET_NULL,   1, 12, 1, 0, 0, 0, 0, 0, "月"},
    {SETTYPE_UINT,  SET_NULL,   1, 31, 1, 0, 0, 0, 0, 0, "日"},
    {SETTYPE_UINT,  SET_NULL,   0, 24, 8, 0, 0, 0, 0, 0, "时"},
    {SETTYPE_UINT,  SET_NULL,   0, 59, 8, 0, 0, 0, 0, 0, "分"},
    {SETTYPE_UINT,  SET_NULL,   0, 59, 8, 0, 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, 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, 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),},
};
#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);

#ifndef DISP_CHZOKCHR_2_SW
        ptSet->tSwSet[sw].dT_chz_ok = GetSetTIME(psetbuf[CSTSET_CHZ_OK].ff); // GetSetTIME(180); //重合闸确认时间，默认180秒
#endif
    }

    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
#ifndef DISP_CHZOKCHR_2_SW
    ptSet->dT_chzcd_2 = GetSetTIME(psetbuf[CSTSET_CHZCD_2].ff); // 二次充电时间
#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); // 重合检同期
#ifdef CHZ_JWY_LM
            ptSet->tSwSet[sw].bTT_chz_mwy = (((WORD)psetbuf[SET_CH_MWY + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 检母线无压
            ptSet->tSwSet[sw].bTT_chz_lwy = (((WORD)psetbuf[SET_CH_XWY + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 检线路无压
#else
            ptSet->tSwSet[sw].bTT_chz_wy = (((WORD)psetbuf[SET_CH_WY + sw * SW_SET_NUMBER].ff == 1) ? true : false); // 无压重合闸
#endif

            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 DISP_CHZOKCHR_2_SW
            ptSet->tSwSet[sw].dT_chz_cd = GetSetTIME(psetbuf[SET_CHZCD_2 + sw * SW_SET_NUMBER].ff);
            ptSet->tSwSet[sw].dT_chz_ok = GetSetTIME(psetbuf[SET_CHZ_OK + sw * SW_SET_NUMBER].ff);
#else /* DISP_CHZOKCHR_2_SW */
#ifdef FUNC_CHZ_CHARGE_TIME
            ptSet->tSwSet[sw].dT_chz_cd = GetSetTIME(psetbuf[SET_CHZCD + sw * SW_SET_NUMBER].ff); // 重合闸充电时间
#else /* FUNC_CHZ_CHARGE_TIME */
            ptSet->tSwSet[sw].dT_chz_cd = (bch2 || bch3) ? ptSet->dT_chzcd_2 : T_1s * 15; // 投一次重合闸，充电时间15秒，投二次重合闸，充电180秒
#endif /* FUNC_CHZ_CHARGE_TIME */
#endif /* DISP_CHZOKCHR_2_SW */

            ptSet->tSwSet[sw].dT_chz_bs = GetSetTIME(psetbuf[SET_CHBS_T + sw * SW_SET_NUMBER].ff);
            ptSet->tSwSet[sw].dT_chz_ok = (bch2 || bch3) ? ptSet->tSwSet[sw].dT_chz_ok : T_1s * 15; // 只投一次重合闸的时候，重合闸确认时间强制为15S 2020-7-25
            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;i<g_net_num;i++)
    for (i = 0; i < CFG_ETH_MAX_LOGIC; i++)
    {
        // 已经修改网络参数
        if (pRunPara->tNetPara[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;
}

//========================== 本文件结束 =============================