T536_DTU/dtu/dtu_main_t536/app/key_menu.c

/******************************************************************************
版权所有：	深圳市金宏威实业发展有限公司 
文件名称：	key_menu.c
文件版本：	01.01
创建作者:	钟务贵
创建日期：	2014-12-29
功能说明：	按键菜单管理
其它说明：
修改记录：
*/

/*------------------------------- 头文件 --------------------------------------
*/
#include "head.h"
#include "key_menu.h"
/*------------------------------- 宏定义 --------------------------------------
*/
// 密码定义
#define PASS_WORD_USE	0000
#define PASS_WORD_ALL	1234
#define PASS_WORD_SUPER 321

/*------------------------------ 全局变量 -------------------------------------
*/
EVENT_SHOW event_cur;  				// 当前查询事件
EVENT_SHOW event_Auto; 				// 突发弹出事件的结构

SET_VALUE m_SetBuf[MAX_SET_NUMBER];	// 定义定值查看及整定时的buf
static TSETTABLE *pset;				// 取当前编辑的设置查表
u8 g_slavemenu;						// 保留次级菜单
u8 g_mastermenu;					// 保留上级菜单
u8 strGprsInf[20][24];

u32 rmtpair_dely[2][2]={{0, 0},{0, 0}};	// 用于遥控器配对延时返回
u32 gprs_info_up[2]={0, 0};

int ac_adjust_result=0;				// 交流校准结果
int  g_gprs_info_num;				// GPRS信息个数

SET_VALUE g_netpara[PARA_NUM*4];	// 网卡类型定值
SET_VALUE g_timepara[2*3];			// 时间类型定值

static TSETTABLE *run_para_pick_set=NULL;  //运行参数
static SET_VALUE *run_para_setbuf=NULL;    //运行参数setbuf

/*------------------------------ 函数声明 -------------------------------------
*/
static int _key_menu(u8 key);
static int _key_set(u8 key);
static int _key_query_page(u8 key);
static int _key_query_line(u8 key);
static int _key_action(u8 key);
static int _esc_key_menu(void);
static int _esc_key_set(void);
static int _esc_key_action(void);
static int _up_key_menu(void);
static int _down_key_menu(void);
static int _left_key_menu(void);
static int _left_key_set_query(void);
static int _left_key_set_modify(void);
static int _left_key_sjsoe(u16 addr);
static int _left_key_czsoe(void);
static int _left_key_query(void);
static int _left_key_action(void);
static int _right_key_menu(void);
static int _right_key_set_query(void);
static int _right_key_set_modify(void);
static int _right_key_sjsoe(u16 addr);
static int _right_key_czsoe(void);
static int _right_key_action(void);
static int _add_key_set(void);
static int _add_key_query(void);
static int _sub_key_query(void);
static int _sub_key_set(void);
static int _enter_key_menu(void);
static int _enter_key_set(void);
static int _enter_key_action(void);
static int _enter_menu_init(void);
static int _check_slave_menu(u8 menu_m, u8 cur_focus);
static int _wnd_item_num_init(void);
static int _soe_init(u16 addr, u16 soe_index, u16 soe_number, u16 soe_cur);
static int _soe_show(EVENT_STRUCT *pe);
static int _soe_auto_check(void);
static int _info_err_init(void);
static int _info_debug_init(void);
static int _info_gprs_init(void);
static int _info_equ_init(u8 menu_no, u8 wnd_no);
static int _passerr_init(void);
static int _rmt_pair_init(void);
static int _rmt_delpair_init(void);
static int _save_result_init(u8 result);
static int _ac_adjust_result_init(int result);
static int _set_init(u8 type);
static int _set_change_disp(void);
static int _set_modify_update(int cur_focus);
static int _set_get_dispdata(int no, int setno, struct set_dis *pt, const TSETTABLE *pTable, SET_VALUE *setbuf);
static int _set_fmt_init_modify(u8 index, struct set_dis *pt, const char *FmtStr,...);
static int _set_spcl_fmt_init_modify(int type, u8 index, struct set_dis *pt, const char *FmtStr,...);
static int _set_change_type(const TSETTABLE *pSet,int num,SET_VALUE *setbuf);
static int _set_is_integer(u16 type);
static int _set_is_have_point(void);
static int _set_move_point(int bFlag);
static int _set_get_modify_value(void);
static char * _set_fmtstr_Precison(char *FmtStr,BYTE *len);
static int _set_get_float_disp(void *pdat);
static void _set_change_set(const TSETTABLE *pSet,int num, int index);
static int _set_check_set(const TSETTABLE *pSet,int num,SET_VALUE *setbuf);
static int _set_net_init(void);
static int _set_time_init(int set_no);
static int _set_net_save(void);
static int _set_time_save(void);
static int _set_save_func(u8 menu);
static int _password_check(u8 code);
int _reset_page_dis(void);
int _blk_light_app(u8 key);
static void _save_result_autoback(void);
int _rmt_pair_dely(u8 key);
static int _gprs_disp_update(void);
int gprs_net_get_gprs_info(void);

unsigned long mktimehms(const unsigned int hour,const unsigned int min, const unsigned int sec);
int timespec_to_rtchms(struct timespec ts, struct rtc_time_t * p_rtc,int is_round);

/*------------------------------ 外部函数 -------------------------------------
*/
/******************************************************************************
函数名称：	key_hmi_app
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	按键翻屏应用
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
int key_hmi_app(void)
{
	u8 key;
	int update_ret=0;
	
	key = Get_Key();

	key = _rmt_pair_dely(key);
	
	switch (g_page_cur.pagetype)
	{
		case MENU_TYPE:
		case MENU_TYPE_CH8:
			update_ret = _key_menu(key);
		break;

		case SET_TYPE:
			update_ret = _key_set(key);
		break;

		case QUERY_PAGE_TYPE:
			update_ret = _key_query_page(key);
		break;

		case QUERY_1LINE_TYPE:
			update_ret = _key_query_line(key);
		break;

		case ACTION_TYPE:
			update_ret = _key_action(key);
		break;
	}
	
	// 有效或有突发事件才更新
	if ((update_ret == 0)
		|| (_soe_auto_check()==0)
		|| (_gprs_disp_update()==0))
	{
		reset_update_flag();
	}

	// 背光处理
	_blk_light_app(key);
	_save_result_autoback();
	return 0;
}

/**************************************************************************
函数名称：mmd_InitDefaultEquipSet
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：恢复出厂设置，定值，定值区信息，压板，内部定值，参数均设为默认值，
              清事件记录、操作记录，运行定值区0 ，有效区一个 0
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/
int init_default_equip_set(int value)
{
	GetDefPara((float*)m_SetBuf,EQUIP_PARA_NUMBER,&tEquipParaTable[0]); //装置参数默认
	//调试网口参数做特殊处理。调试网口的默认参数以UBOOT中的环境变量为默认值.
	GetDefDebugNetPara();
	SavePara((void *)m_SetBuf,EEP_EQUIP_PARA_ADDR,EQUIP_PARA_NUMBER,&tEquipParaTable[0]);

	GetDefSet((float*)m_SetBuf);
	SaveSet(m_runsection,(void *)m_SetBuf);

	GetDefPara((float*)m_SetBuf,CSTSET_NUMBER,&tCstSetTable[0]);//定值默认
	SavePara((void *)m_SetBuf,EEP_CSTSET_ADDR,CSTSET_NUMBER,&tCstSetTable[0]);

	tSecInfo.sCurSec=0;         // 当前运行定值区为 0区
	SavePassword(INIT_PASSWORD);  // 密码初始化
	soe_clear_ev(); 				// 清事件记录
	soe_clear_opt() ;   			// 清操作记录
	soe_record_opt(EV_INIT_EQUIP,0);	// 记录操作记录
	tSecInfo.sCurSec=0;
	MakeRunSet(true); 			// 将当前运行定值区转换为运行定值区
	MakeRunPara(false, true);  		// 转换参数到运行参数区

	rt_printf("恢复为出厂设置\r\n");
	return 0;	
}

/******************************************************************************
函数名称：	check_cur_wnd_item
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	获取当前屏分配的实体数
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
int check_cur_wnd_item(void)
{	
	// 当前屏号离屏总数还差一屏时，当前屏分配实体数为每屏可容纳的最大数(cur_wnd从0开始计数)
	if ((g_page_cur.cur_wnd+2) <= g_page_cur.wnd_num)
	{
		g_page_cur.cur_wnd_item = g_page_cur.wnd_item;
	}
	else
	{
		// 最后一屏分配的实体数为总数减其他屏实体数
		g_page_cur.cur_wnd_item = g_page_cur.item_num - g_page_cur.wnd_item*(g_page_cur.wnd_num-1);
	}
	return 0;
}

/******************************************************************************
函数名称：	gprs_get_info
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	获取当前屏分配的实体数
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
int gprs_get_info(void)
{
	u8 *pd=tGprsInf.data;
	int num=0;
	
	//获取内部GPRS状态信息
	num = mmd_get_gprs_info();
	
	g_gprs_info_num = num;
	if(num > 0) 
	{	
		return num;
	}
	
	if(!tGprsInf.bInf)
	{
		return 0;
	}
	tGprsInf.bInf=false;
	
	if((pd[0]|(pd[1]<<8))==0x0001)
	{
		strcpy(strGprsInf[num++],"模块状态 :正常");
	}
	else
	{
		strcpy(strGprsInf[num++],"模块状态 :异常");

	}

	if((pd[2]|(pd[3]<<8))==0x0001)
	{
		strcpy(strGprsInf[num++],"SIM卡状态:正常");
	}
	else
	{
		strcpy(strGprsInf[num++],"SIM卡状态:异常");

	}

	if((pd[4]|(pd[5]<<8))==0x0001)
	{
		strcpy(strGprsInf[num++],"PPP拨号  :正常");
	}
	else
	{
		strcpy(strGprsInf[num++],"PPP拨号  :异常");

	}

	sprintf(strGprsInf[num++],"信号强度 :%2d",(pd[16]|(pd[17]<<8)));
	// SIM卡IP
	sprintf(strGprsInf[num++],"%d.%d.%d.%d",pd[36],pd[37],pd[38],pd[39]);	

	// CH1是否正常，端口是多少,IP1
	if((pd[6]|(pd[7]<<8))==0x0001)
	{
		sprintf(strGprsInf[num++],"CH1:正常 %d",(pd[44]|(pd[45]<<8)));
	}
	else
	{
		sprintf(strGprsInf[num++],"CH1:异常 %d",(pd[44]|(pd[45]<<8)));
	}
	sprintf(strGprsInf[num++],"%d.%d.%d.%d",pd[40],pd[41],pd[42],pd[43]);		

	// CH2是否正常，端口是多少,IP2
	if((pd[8]|(pd[9]<<8))==0x0001)
	{
		sprintf(strGprsInf[num++],"CH2:正常 %d",(pd[50]|(pd[51]<<8)));
	}
	else
	{
		sprintf(strGprsInf[num++],"CH2:异常 %d",(pd[50]|(pd[51]<<8)));
	}
	sprintf(strGprsInf[num++],"%d.%d.%d.%d",pd[46],pd[47],pd[48],pd[49]);	

	strcpy(strGprsInf[num++],"频段:自适应");
	strcpy(strGprsInf[num++],"流量(秒):");
	sprintf(strGprsInf[num++],"%d",(pd[26]|(pd[27]<<8)|(pd[28]<<16)|(pd[29]<<24)));
	strcpy(strGprsInf[num++],"流量(B) :");
	sprintf(strGprsInf[num++],"%d",(pd[30]|(pd[31]<<8)|(pd[32]<<16)|(pd[33]<<24)));

	if((pd[14]|(pd[15]<<8))==0x0001)
	{
		strcpy(strGprsInf[num++],"重启状态:重启");
	}
	else
	{
		strcpy(strGprsInf[num++],"重启状态:未重启");
	}

	g_gprs_info_num = num;

	return num;
}
/*------------------------------ 内部函数 -------------------------------------
*/
/******************************************************************************
函数名称：	_key_menu
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	按键翻菜单
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _key_menu(u8 key)
{
	int update_ret=0;

	if (key == NO_KEY)
		return -1;

	switch (key)
	{
		case HA_KEY_ESC:
			update_ret = _esc_key_menu();
			Add_Clear_Screen();
		break;

		case HA_KEY_RST:
			SignalReset(0,false);
			update_ret = -1;
			g_file_led_sign = 1;			// 故障LED状态文件记录标志	
			g_protect_restore = 1;
			clear_tfd_fault();
		break;

		case HA_KEY_UP:
			update_ret = _up_key_menu();
		break;

		case HA_KEY_DOWN:
			update_ret = _down_key_menu();
		break;

		case HA_KEY_LEFT:
			update_ret = _left_key_menu();
		break;

		case HA_KEY_RIGHT:
			update_ret = _right_key_menu();
		break;

		case HA_KEY_ADD:
			update_ret = _up_key_menu();
		break;
		
		case HA_KEY_SUB:
			update_ret = _down_key_menu();
		break;

		case HA_KEY_ENTER:
		{
			update_ret = _enter_key_menu();
			Add_Clear_Screen();
		}
		break;

		default:
			update_ret = -1;
		break;
	}
	
	return update_ret;
}

/******************************************************************************
函数名称：	_key_set
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	设置类人机操作
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _key_set(u8 key)
{
	int update_ret=0;

	if (key == NO_KEY)
		return -1;

	switch (key)
	{
		case HA_KEY_ESC:
			update_ret = _esc_key_set();
			Add_Clear_Screen();
		break;

		case HA_KEY_RST:
		{
			SignalReset(0,false);
			update_ret = -1;
			g_file_led_sign = 1;			// 故障LED状态文件记录标志
			g_protect_restore = 1;
			clear_tfd_fault();
		}
		break;

		case HA_KEY_UP:
			g_set_dis[g_page_cur.cur_focus].modify = 0;
			update_ret = _left_key_set_query();
			g_set_dis[g_page_cur.cur_focus].modify = 1;
		break;

		case HA_KEY_DOWN:
			g_set_dis[g_page_cur.cur_focus].modify = 0;
			update_ret = _right_key_set_query();
			g_set_dis[g_page_cur.cur_focus].modify = 1;
		break;

		case HA_KEY_LEFT:
			if (g_set_dis[g_page_cur.cur_focus].modify)
			{
				update_ret = _left_key_set_modify();				
			}
			else
			{
				update_ret = _left_key_set_query();
			}
		break;

		case HA_KEY_RIGHT:
			if (g_set_dis[g_page_cur.cur_focus].modify)
			{
				update_ret = _right_key_set_modify();				
			}
			else
			{
				update_ret = _right_key_set_query();
			}
		break;

		case HA_KEY_ADD:
			if (g_set_dis[g_page_cur.cur_focus].modify)
			{
				update_ret = _add_key_set();
			}
		break;

		case HA_KEY_SUB:
			if (g_set_dis[g_page_cur.cur_focus].modify)
			{
				update_ret = _sub_key_set();
			}
		break;

		case HA_KEY_ENTER:
		{
			update_ret = _enter_key_set();
		}
		break;

		default:
			update_ret = -1;
		break;
	}
	
	return update_ret;
}

/******************************************************************************
函数名称：	_key_query_page
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	页面查询类人机操作
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _key_query_page(u8 key)
{
	int update_ret=0;

	if (key == NO_KEY)
		return -1;

	switch (key)
	{
		case HA_KEY_ESC:
			update_ret = _esc_key_menu();
			if (rmtpair_dely[0][0])
			{
				rmtpair_dely[0][0] = 0;
			}
			if (rmtpair_dely[1][0])
			{
				rmtpair_dely[1][0] = 0;
			}
			if (gprs_info_up[0])
			{
				gprs_info_up[0] = 0;
			}
			Add_Clear_Screen();
		break;

		case HA_KEY_RST:
		{
			SignalReset(0,false);
			update_ret = -1;
			g_file_led_sign = 1;			// 故障LED状态文件记录标志	
			g_protect_restore = 1;
			clear_tfd_fault();
		}
		break;
		
		case HA_KEY_UP:
		case HA_KEY_LEFT:
		{
			if ((g_page_cur.menu_cur == MENU_SJSOE)
				|| (g_page_cur.menu_cur == MENU_EVENT))
			{			
				update_ret = _left_key_sjsoe(EEP_SOE_ADDR);
			}
			else if (g_page_cur.menu_cur == MENU_CZSOE)
			{
				update_ret = _left_key_czsoe();
			}
			else if ((g_page_cur.menu_cur == MENU_INFO_ERR)
				|| (g_page_cur.menu_cur == MENU_INFO_DEBUG)
				|| (g_page_cur.menu_cur == MENU_INFO_GPRS))
			{
				update_ret = _left_key_query();				
			}
			else if ( (g_page_cur.menu_cur == MENU_INFO_EQU)
			        ||(g_page_cur.menu_cur == MENU_COMM_PARA) )
            {
                update_ret = _sub_key_query();
                _info_equ_init(g_page_cur.menu_cur, g_page_cur.cur_wnd);
            }
			else if ( (g_page_cur.menu_cur == MENU_INFO_YX)
			        ||(g_page_cur.menu_cur == MENU_INFO_YC) )
            {
                update_ret = _sub_key_query();
            }
			Add_Clear_Screen();
		}

		break;

		case HA_KEY_DOWN:
		case HA_KEY_RIGHT:
		{
			if ((g_page_cur.menu_cur == MENU_SJSOE)
				|| (g_page_cur.menu_cur == MENU_EVENT))
			{			
				update_ret = _right_key_sjsoe(EEP_SOE_ADDR);
			}
			else if (g_page_cur.menu_cur == MENU_CZSOE)
			{
				update_ret = _right_key_czsoe();
			}
			else if ((g_page_cur.menu_cur == MENU_INFO_ERR)
				|| (g_page_cur.menu_cur == MENU_INFO_DEBUG)
				|| (g_page_cur.menu_cur == MENU_INFO_GPRS))
			{
				update_ret = _add_key_query();				
			}
			else if ( (g_page_cur.menu_cur == MENU_INFO_EQU)
			        ||(g_page_cur.menu_cur == MENU_COMM_PARA))
            {
                update_ret = _add_key_query();
                _info_equ_init(g_page_cur.menu_cur, g_page_cur.cur_wnd);
            }
			else if ( (g_page_cur.menu_cur == MENU_INFO_YX)
			        ||(g_page_cur.menu_cur == MENU_INFO_YC))
            {
                update_ret = _add_key_query();
            }

			Add_Clear_Screen();
		}
		break;
		
		case HA_KEY_ADD:
			if (gprs_info_up[0])
			{
				IEC101_PH_GprsInfo();
			}
			else if ( (g_page_cur.menu_cur == MENU_INFO_EQU)
			        ||(g_page_cur.menu_cur == MENU_COMM_PARA))
            {
				update_ret = _add_key_query();
                _info_equ_init(g_page_cur.menu_cur, g_page_cur.cur_wnd);
				Add_Clear_Screen();
				break;
            }
			update_ret = _add_key_query();
			Add_Clear_Screen();
		break;
		
		case HA_KEY_SUB:
			if (gprs_info_up[0])
			{
				IEC101_PH_GprsInfo();
			}
			else if ( (g_page_cur.menu_cur == MENU_INFO_EQU)
			        ||(g_page_cur.menu_cur == MENU_COMM_PARA))
            {
				update_ret = _sub_key_query();
                _info_equ_init(g_page_cur.menu_cur, g_page_cur.cur_wnd);
				Add_Clear_Screen();
				break;
            }
			update_ret = _sub_key_query();
			Add_Clear_Screen();
		break;

		case HA_KEY_ENTER:
			update_ret = -1;
		break;

		default:
			update_ret = -1;
		break;
	}

	return update_ret;
}

/******************************************************************************
函数名称：	_key_query_line
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	行查询类人机操作
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _key_query_line(u8 key)
{
	int update_ret = 0;

	if (key == NO_KEY)
		return -1;

	switch (key)
	{
		case HA_KEY_ESC:
			update_ret = _esc_key_menu();
			Add_Clear_Screen();
		break;

		case HA_KEY_RST:	
		{
			SignalReset(0,false);
			update_ret = -1;
			g_file_led_sign = 1;			// 故障LED状态文件记录标志	
			g_protect_restore = 1;
			clear_tfd_fault();
		}
		break;

		case HA_KEY_UP:
		case HA_KEY_LEFT:
		case HA_KEY_SUB:
			update_ret = _left_key_query();
			if (update_ret==0)
			{
				Add_Clear_Screen();
			}
		break;

		case HA_KEY_DOWN:
		case HA_KEY_RIGHT:
		case HA_KEY_ADD:
			update_ret = _add_key_query();
			if (update_ret==0)
			{
				Add_Clear_Screen();
			}
		break;

		case HA_KEY_ENTER:
			update_ret = -1;
		break;

		default:
			update_ret = -1;
		break;
	}	
	return update_ret;
}

/******************************************************************************
函数名称：	_key_action
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	动作类人机操作
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _key_action(u8 key)
{
	int update_ret=0;

	if (key == NO_KEY)
		return -1;

	switch (key)
	{
		case HA_KEY_ESC:
		{
			update_ret = _esc_key_action();
			Add_Clear_Screen();
		}
		break;

		case HA_KEY_RST:
		{
			SignalReset(0,false);
			update_ret = -1;
			g_file_led_sign = 1;			// 故障LED状态文件记录标志	
			g_protect_restore = 1;
			clear_tfd_fault();
		}
		break;

		case HA_KEY_UP:
		case HA_KEY_LEFT:
			update_ret = _left_key_action();
		break;

		case HA_KEY_DOWN:
		case HA_KEY_RIGHT:
			update_ret = _right_key_action();			
		break;

		case HA_KEY_ADD:
		case HA_KEY_SUB:
			update_ret = -1;
		break;

		case HA_KEY_ENTER:
		{
			update_ret = _enter_key_action();
			if (update_ret == 0)
			{
				Add_Clear_Screen();
			}
		}
		break;

		default:
			update_ret = -1;
		break;
	}
	
	return update_ret;
}

/******************************************************************************
函数名称：	_up_key_menu
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	上键-菜单
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _up_key_menu(void)
{
	// 当前聚焦点未到当前屏最小，减一
	if (g_page_cur.cur_focus > 1)
	{
		g_page_cur.cur_focus -= 2;
	}
	else
	{
		// 当前屏非最小，上翻一屏
		if (g_page_cur.cur_wnd > 0)
		{
			g_page_cur.cur_wnd--;
			check_cur_wnd_item();
			Add_Clear_Screen();
		}
		else
		{
			// 否则聚焦点移至当前屏最末
			g_page_cur.cur_focus = g_page_cur.cur_wnd_item-1;
		}				
	}
	return 0;
}

/******************************************************************************
函数名称：	_down_key_menu
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	右键-菜单
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _down_key_menu(void)
{
	// 当前聚焦点加一
	if (g_page_cur.cur_focus < (g_page_cur.cur_wnd_item-2))
	{
		g_page_cur.cur_focus += 2;
	}
	else
	{
		// 当前屏非最大，下翻一屏
		if (g_page_cur.cur_wnd < (g_page_cur.wnd_num-1))
		{
			g_page_cur.cur_wnd++;
			check_cur_wnd_item();
			Add_Clear_Screen();
		}
		// 聚焦移至最首
		g_page_cur.cur_focus = 0;
	}
	return 0;
}

/******************************************************************************
函数名称：	_left_key_menu
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	左键-菜单
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _left_key_menu(void)
{
	// 当前聚焦点未到当前屏最小，减一
	if (g_page_cur.cur_focus > 0)
	{
		g_page_cur.cur_focus--;
	}
	else
	{
		// 当前屏非最小，上翻一屏
		if (g_page_cur.cur_wnd > 0)
		{
			g_page_cur.cur_wnd--;
			check_cur_wnd_item();
			Add_Clear_Screen();
		}
		else
		{
			// 否则聚焦点移至当前屏最末
			g_page_cur.cur_focus = g_page_cur.cur_wnd_item-1;
		}				
	}
	return 0;
}

/******************************************************************************
函数名称：	_left_key_set_query
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	左键-定值查询
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _left_key_set_query(void)
{
	// 当前聚焦点未到当前屏最小，减一
	if (g_page_cur.cur_focus > 0)
	{
		// 当前聚焦定值重新刷新
		g_item_update.data[g_page_cur.cur_focus] = 1;

		g_set_dis[g_page_cur.cur_focus].cursor = 0;
		
		// 聚焦移位
		g_page_cur.cur_focus--;
		
		// 新聚焦定值重新刷新
		g_item_update.data[g_page_cur.cur_focus] = 1;

		g_set_dis[g_page_cur.cur_focus].cursor = 0;

		// 不刷新其他项
		return -1;
	}
	else
	{
		// 当前屏非最小，上翻一屏
		if (g_page_cur.cur_wnd > 0)
		{
			Add_Clear_Screen();
			g_page_cur.cur_wnd--;
			check_cur_wnd_item();			
			_set_change_disp();
			g_page_cur.cur_focus=g_page_cur.cur_wnd_item-1;
		}
		else
		{
			Add_Clear_Screen();
			g_page_cur.cur_wnd = g_page_cur.wnd_num-1;
			check_cur_wnd_item();			
			_set_change_disp();
			g_page_cur.cur_focus = g_page_cur.cur_wnd_item-1;
		}				
	}
	return 0;
}

/******************************************************************************
函数名称：	_left_key_set_modify
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	左键-设置左移
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _left_key_set_modify(void)
{
	u8 focus;

	// 当前屏内聚焦的定值
	focus = g_page_cur.cur_focus;

	if (g_set_dis[focus].list)	// 列表型定值
	{
		return -1;
	}

	// 数字型定值左移
	if (g_set_dis[focus].cursor > 0)
	{
		g_set_dis[focus].cursor--;

	}
	else
	{
		g_set_dis[focus].cursor = g_set_dis[focus].lenth-1;
	}

	// 如果左移后的项是小数点，且当前类型为浮点型，再左移一位
	if ((g_set_dis[focus].str[SET_DATA][g_set_dis[focus].cursor] == '.')
		&& (g_set_dis[focus].type == 'F'))
	{
		g_set_dis[focus].cursor--;			
	}

	// 如果左移后的项是小数点，且当前类型为网卡地址型，再左移一位
	if ((g_set_dis[focus].str[SET_DATA][g_set_dis[focus].cursor] == '.')
		&& g_set_dis[focus].spcl_type == DISP_IP)
	{
		g_set_dis[focus].cursor--;			
	}

	// 如果左移后的项是横杠，且当前类型为年月日型，再左移一位
	if ((g_set_dis[focus].str[SET_DATA][g_set_dis[focus].cursor] == '-')
		&& g_set_dis[focus].spcl_type == DISP_YMD)
	{
		g_set_dis[focus].cursor--;			
	}

	// 如果左移后的项是':'，且当前类型为时分秒型，再左移一位
	if ((g_set_dis[focus].str[SET_DATA][g_set_dis[focus].cursor] == ':')
		&& g_set_dis[focus].spcl_type == DISP_HMS)
	{
		g_set_dis[focus].cursor--;			
	}

	// 当前聚焦定值重新刷新
	g_item_update.data[g_page_cur.cur_focus] = 1;
	
	return -1;
}

/******************************************************************************
函数名称：	_left_key_sjsoe
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	左键-事件记录
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _left_key_sjsoe(u16 addr)
{
	if(g_soe_info.wEvNumber > 1)
	{
		if(event_cur.wCurrent == 1)
		{
			event_cur.wCurrent = g_soe_info.wEvNumber;
		}
		else
		{
			event_cur.wCurrent--;
		}				
		
		if(event_cur.wIndex > 0)
		{
			event_cur.wIndex--;
		}
		else
		{
			if(g_soe_info.wEvNumber == MAX_EVENT_NUMBER)
			{
				event_cur.wIndex = MAX_EVENT_NUMBER-1;
			}
			else
			{
				event_cur.wIndex = g_soe_info.wEvIndex;
			}
		}
		_soe_init(addr, event_cur.wIndex, g_soe_info.wEvNumber, event_cur.wCurrent);
	}
	return 0;
}

/******************************************************************************
函数名称：	_left_key_czsoe
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	左键-操作记录
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _left_key_czsoe(void)
{
	if(g_soe_info.wOpNumber > 1)
	{
		if(event_cur.wCurrent == 1)
		{
			event_cur.wCurrent = g_soe_info.wOpNumber;
		}
		else
		{
			event_cur.wCurrent--;
		}				
		
		if(event_cur.wIndex > 0)
		{
			event_cur.wIndex--;
		}
		else
		{
			if(g_soe_info.wOpNumber == MAX_EVENT_NUMBER)
			{
				event_cur.wIndex = MAX_EVENT_NUMBER-1;
			}
			else
			{
				event_cur.wIndex = g_soe_info.wOpIndex;
			}
		}
		_soe_init(EEP_OPERATE_ADDR, event_cur.wIndex, g_soe_info.wOpNumber, event_cur.wCurrent);
	}
	return 0;
}

/******************************************************************************
函数名称：	_left_key_query
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	左键-查询
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _left_key_query(void)
{
	if (g_page_cur.wnd_num > 1)
	{
		// 当前屏非最小，上翻一屏
		if (g_page_cur.cur_wnd > 0)
		{
			g_page_cur.cur_wnd--;			
		}
		else
		{
			g_page_cur.cur_wnd = g_page_cur.wnd_num-1;
		}
		check_cur_wnd_item();
	}
	else
	{
		return 1;
	}
	return 0;
}

/******************************************************************************
函数名称：	_left_key_action
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	左键-动作
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _left_key_action(void)
{
	// 当前聚焦点未到当前屏最小，减一
	if (g_page_cur.cur_focus > 0)
	{
		g_page_cur.cur_focus--;
	}
	else
	{
		// 当前屏非最小，上翻一屏
		if (g_page_cur.cur_wnd > 0)
		{
			g_page_cur.cur_wnd--;
			check_cur_wnd_item();
			Add_Clear_Screen();			
		}
		else
		{
			g_page_cur.cur_wnd = g_page_cur.wnd_num-1;
			check_cur_wnd_item();
			Add_Clear_Screen();
			g_page_cur.cur_focus = g_page_cur.cur_wnd_item-1;
		}
		memset(g_action.action, 0, 10);
	}
	return 0;
}

/******************************************************************************
函数名称：	_right_key_menu
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	右键-菜单
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _right_key_menu(void)
{
	// 当前聚焦点加一
	if (g_page_cur.cur_focus < (g_page_cur.cur_wnd_item-1))
	{
		g_page_cur.cur_focus++;
	}
	else
	{
		// 当前屏非最大，下翻一屏
		if (g_page_cur.cur_wnd < (g_page_cur.wnd_num-1))
		{
			g_page_cur.cur_wnd++;
			check_cur_wnd_item();
			Add_Clear_Screen();
		}
		// 聚焦移至最首
		g_page_cur.cur_focus = 0;
	}
	return 0;
}

/******************************************************************************
函数名称：	_right_key_set_query
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	右键-定值查询
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _right_key_set_query(void)
{
	// 当前聚焦点未到当前屏最小，加一
	if (g_page_cur.cur_focus < (g_page_cur.cur_wnd_item-1))
	{
		// 当前聚焦定值重新刷新
		g_item_update.data[g_page_cur.cur_focus] = 1;

		g_set_dis[g_page_cur.cur_focus].cursor = 0;
		
		// 聚焦移位
		g_page_cur.cur_focus++;

		g_set_dis[g_page_cur.cur_focus].cursor = 0;
		
		// 新聚焦定值重新刷新
		g_item_update.data[g_page_cur.cur_focus] = 1;

		// 不刷新其他项
		return -1;
	}
	else
	{
		// 当前屏非最小，下翻一屏
		if (g_page_cur.cur_wnd < (g_page_cur.wnd_num-1))
		{
			Add_Clear_Screen();
			g_page_cur.cur_wnd++;
			check_cur_wnd_item();			
			_set_change_disp();
			g_page_cur.cur_focus = 0;
		}
		else
		{
			Add_Clear_Screen();
			g_page_cur.cur_wnd = 0;
			check_cur_wnd_item();			
			_set_change_disp();
			g_page_cur.cur_focus = 0;
		}				
	}
	return 0;
}

/******************************************************************************
函数名称：	_right_key_set
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	右键-菜单
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _right_key_set_modify(void)
{
	u8 focus;

	// 当前屏内聚焦的定值
	focus = g_page_cur.cur_focus;

	if (g_set_dis[focus].list)	// 列表型定值
	{
		return -1;
	}

	// 数字型定值左移
	if (g_set_dis[focus].cursor < g_set_dis[focus].lenth-1)
	{
		g_set_dis[focus].cursor++;
	}
	else
	{
		g_set_dis[focus].cursor = 0;
	}

	// 如果左移后的项是小数点，且当前类型为浮点型，再左移一位
	if ((g_set_dis[focus].str[SET_DATA][g_set_dis[focus].cursor] == '.')
		&& (g_set_dis[focus].type == 'F'))
	{
		g_set_dis[focus].cursor++;			
	}

	// 如果左移后的项是小数点，且当前类型为网卡地址型，再左移一位
	if ((g_set_dis[focus].str[SET_DATA][g_set_dis[focus].cursor] == '.')
		&& g_set_dis[focus].spcl_type == DISP_IP)
	{
		g_set_dis[focus].cursor++;			
	}

	// 如果左移后的项是横杠，且当前类型为年月日型，再左移一位
	if ((g_set_dis[focus].str[SET_DATA][g_set_dis[focus].cursor] == '-')
		&& g_set_dis[focus].spcl_type == DISP_YMD)
	{
		g_set_dis[focus].cursor++;			
	}

	// 如果左移后的项是':'，且当前类型为时分秒型，再左移一位
	if ((g_set_dis[focus].str[SET_DATA][g_set_dis[focus].cursor] == ':')
		&& g_set_dis[focus].spcl_type == DISP_HMS)
	{
		g_set_dis[focus].cursor++;			
	}

	// 当前聚焦定值重新刷新
	g_item_update.data[g_page_cur.cur_focus] = 1;

	
	return -1;
}

/******************************************************************************
函数名称：	_right_key_sjsoe
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	右键-事件记录
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _right_key_sjsoe(u16 addr)
{
	if(g_soe_info.wEvNumber > 1)
	{
		if(event_cur.wCurrent == g_soe_info.wEvNumber)
		{
			event_cur.wCurrent = 1;
		}
		else
		{
			event_cur.wCurrent++;
		}				
		
		if(event_cur.wIndex < (g_soe_info.wEvNumber-1))
		{
			event_cur.wIndex++;
		}
		else
		{
			event_cur.wIndex = 0;
		}
		_soe_init(addr, event_cur.wIndex, g_soe_info.wEvNumber, event_cur.wCurrent);
	}	
	return 0;
}

/******************************************************************************
函数名称：	_right_key_czsoe
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	右键-事件记录
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _right_key_czsoe(void)
{
	if(g_soe_info.wOpNumber > 1)
	{
		if(event_cur.wCurrent == g_soe_info.wOpNumber)
		{
			event_cur.wCurrent = 1;
		}
		else
		{
			event_cur.wCurrent++;
		}				
		
		if(event_cur.wIndex < (g_soe_info.wOpNumber-1))
		{
			event_cur.wIndex++;
		}
		else
		{
			event_cur.wIndex = 0;
		}
		_soe_init(EEP_OPERATE_ADDR, event_cur.wIndex, g_soe_info.wOpNumber, event_cur.wCurrent);
	}
	return 0;
}

/******************************************************************************
函数名称：	_right_key_action
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	右键-动作
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _right_key_action(void)
{
	// 当前聚焦点加一
	if (g_page_cur.cur_focus < (g_page_cur.cur_wnd_item-1))
	{
		g_page_cur.cur_focus++;
	}
	else
	{
		// 当前屏非最大，下翻一屏
		if (g_page_cur.cur_wnd < (g_page_cur.wnd_num-1))
		{
			g_page_cur.cur_wnd++;
			check_cur_wnd_item();
			Add_Clear_Screen();
			g_page_cur.cur_focus = 0;
		}
		else
		{			
			g_page_cur.cur_wnd = 0;
			check_cur_wnd_item();	
			Add_Clear_Screen();
			g_page_cur.cur_focus = 0;
		}		
		memset(g_action.action, 0, 10);
	}
	return 0;
}

/******************************************************************************
函数名称：	_add_key_set
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	加键-设置
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _add_key_set(void)
{
	u8 focus, index;
	int no, no1;
	int value;
	char dat;

	// 当前屏内聚焦的定值
	focus = g_page_cur.cur_focus;

	if (g_page_cur.cur_wnd > 0)
	{
		index = g_page_cur.wnd_item * g_page_cur.cur_wnd;
	}
	
	// 当前设置项No,即对应定值列表	
	no = focus + index;
	no1 = 0;
	if (g_pub_setdisp.type == MENU_FIX_PUB)
	{
		no = g_pub_setdisp.no[no];
	}
	else if (g_sw_setdisp.type == MENU_GLBH)
	{
		no = class_GLBH.idx[no];
		no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_GLBH.sw_idx;
	}
    else if (g_sw_setdisp.type == MENU_LXBH)
    {
        no = class_LXBH.idx[no];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_LXBH.sw_idx;
    }
    else if (g_sw_setdisp.type == MENU_JDBH)
    {
        no = class_JDBH.idx[no];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_JDBH.sw_idx;
    }
    else if (g_sw_setdisp.type == MENU_RECLOSE)
    {
        no = class_reclose.idx[no];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_reclose.sw_idx;
    }
    else if (g_sw_setdisp.type == MENU_BH_STATUS)
    {
        no = class_BH_sts.idx[no];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_BH_sts.sw_idx;
    }
	else if (g_sw_setdisp.type == MENU_DLYX)
    {
        no = class_DLYX.idx[no];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_DLYX.sw_idx;
    }
	else if (g_sw_setdisp.type == MENU_HJS)
    {
        no = class_HJS.idx[no];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_HJS.sw_idx;
    }
	else if (g_equip_paradisp.type == MENU_PARA)
	{
		no = g_equip_paradisp.no[no];
	}
    else if (g_faultRst_setdisp.type == MENU_FAULT_RESET)
    {
        no = g_faultRst_setdisp.no[no];
    }
    else if (g_rmt_para_disp.type == MENU_RUN_PARA)
    {
        //do nothing
    }
	else if (g_cst_setdisp.type == MENU_INFIX)
	{
		no = g_cst_setdisp.no[no];
	}

	// 定值修改
	if (g_set_dis[focus].list)	// 列表型定值
	{
		value = (WORD)m_SetBuf[no1+no].ff;
		if (value < (pset[no].listnum-1))
		{
			value++;
		}
		else
		{	
			value = 0;
		}
		m_SetBuf[no1+no].ff = (float)value;
	}
	else	// 数字型定值
	{
		dat = g_set_dis[focus].str[SET_DATA][g_set_dis[focus].cursor];	// 取当前修改字符
		if(g_set_dis[focus].type != 's') // 不是汉字修改
		{
			switch(g_set_dis[focus].type)
			{
				case 'o': // 8进制有符号整数
				{
					if(dat=='7')dat='0';else dat++;
					if(dat>'7')dat='0';
				}
				break;
				
				case 'u': // 10进制无符号整数
				{
					if(dat=='9')dat='0';else dat++;
					if(dat>'9')dat='0';
				}
				break;
				
				case 'x': // 16进制无符号整数,小写
				{
					switch(dat)
					{
						case '9':	dat='a';	break;
						case 'f':	dat='0';	break;
						default:	dat++;		break;
					}
				}
				break;
				
				case 'X':  // 16进制无符号整数,大写
				{
					switch(dat)
					{
						case '9':	dat='A';	break;
						case 'F':	dat='0';	break;
						default:	dat++;		break;
					}
				}
				break;
				
				case 'c': // 输出单个字符
				{
					if(dat=='9')dat='0';else dat++;
					if(dat>'9')dat='0';
				}
				break;
				
				case 'B':
				case 'b':  // 2进制数
				{
					if(dat=='1')dat='0';else dat='1';
				}
				break;
				
				case 'd':  // 10进制有符号整数
				case 'i': 
				{
					if(g_set_dis[focus].cursor == 0)
					{
						dat=' ';
					}
					else
					{
						switch(dat)
						{
							case '9':   dat='0';break;
							default:	dat++;	break;
						}
						if(dat<'0'||dat>'9')dat='0';
					}
				}
				break;
				
				case 'f':  // 浮点数
				case 'F':  // 浮点数
				{
					if(g_set_dis[focus].cursor == 0)
					{
						dat=' ';
					}
					else
					{
						switch(dat)
						{
							case '9':
								if((g_set_dis[focus].cursor == g_set_dis[focus].lenth-1)
									&& (!_set_is_have_point()))
								{
									dat='.';  /*防止没有小数点的情况出现*/
								}
								else
								{
									dat='0';
								}
							break;
							
							case '.':	
								_set_move_point(1);
							break;
							
							default:
								if(dat>='0' && dat<='9')
								{
									dat++;
								}
								else 
								{
									dat='0';							
								}
							break;
						}
					}	
				}
				break;
				
				default:
				{
					dat='0';
				}
				break;
			}

			// 修改内容装载入字符串
			if(dat!='.')
			{
				g_set_dis[focus].str[SET_DATA][g_set_dis[focus].cursor] = dat;
			}
		}

		// 将修改内容转换为数值
		_set_get_modify_value();
	}

	// 更新显示
	_set_modify_update(g_page_cur.cur_focus);
	
	// 当前聚焦定值重新刷新
	g_item_update.data[g_page_cur.cur_focus] = 1;

	return -1;
}

/******************************************************************************
函数名称：	_add_key_query
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	加键-查询
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _add_key_query(void)
{
	// 仅一屏，不翻屏
	if (g_page_cur.wnd_num > 1)
	{		
		// 当前屏非最大，下翻一屏
		if (g_page_cur.cur_wnd < (g_page_cur.wnd_num-1))
		{
			g_page_cur.cur_wnd++;
		}		
		else
		{
			g_page_cur.cur_wnd = 0;
		}
		check_cur_wnd_item();
	}
	else
	{
		return 1;
	}
	return 0;
}

/******************************************************************************
函数名称：	_sub_key_set
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	减键-设置
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _sub_key_set(void)
{
	u8 focus, index;
	int no, no1;
	int value;
	char dat;

	// 当前屏内聚焦的定值
	focus = g_page_cur.cur_focus;

	if (g_page_cur.cur_wnd > 0)
	{
		index = g_page_cur.wnd_item * g_page_cur.cur_wnd;
	}
	
	// 当前设置项No,即对应定值列表	
	no = focus + index;
	no1 = 0;
	if (g_pub_setdisp.type == MENU_FIX_PUB)
	{
		no = g_pub_setdisp.no[no];
	}
	else if (g_sw_setdisp.type == MENU_GLBH)
	{
        no  = class_GLBH.idx[no];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_GLBH.sw_idx;
	}
    else if (g_sw_setdisp.type == MENU_LXBH)
    {
        no  = class_LXBH.idx[no];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_LXBH.sw_idx;
    }
    else if (g_sw_setdisp.type == MENU_JDBH)
    {
        no  = class_JDBH.idx[no];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_JDBH.sw_idx;
    }
    else if (g_sw_setdisp.type == MENU_RECLOSE)
    {
        no  = class_reclose.idx[no];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_reclose.sw_idx;
    }
    else if (g_sw_setdisp.type == MENU_BH_STATUS)
    {
        no  = class_BH_sts.idx[no];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_BH_sts.sw_idx;
    }
    else if (g_sw_setdisp.type == MENU_DLYX)
    {
        no  = class_DLYX.idx[no];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_DLYX.sw_idx;
    }
	else if (g_sw_setdisp.type == MENU_HJS)
    {
        no  = class_HJS.idx[no];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_HJS.sw_idx;
    }
	else if (g_equip_paradisp.type == MENU_PARA)
	{
		no = g_equip_paradisp.no[no];
	}
    else if (g_faultRst_setdisp.type == MENU_FAULT_RESET)
    {
        no = g_faultRst_setdisp.no[no];
    }
    else if (g_rmt_para_disp.type == MENU_RUN_PARA)
    {
        //do nothing
    }
	else if (g_cst_setdisp.type == MENU_INFIX)
	{
		no = g_cst_setdisp.no[no];
	}
	
	// 定值修改
	if (g_set_dis[focus].list)	// 列表型定值
	{
		value = (WORD)m_SetBuf[no1+no].ff;
		if (value > 0)
		{
			value--;
		}
		else
		{	
			value = pset[no].listnum-1;
		}
		m_SetBuf[no1+no].ff = (float)value;
	}
	else	// 数字型定值
	{
		dat = g_set_dis[focus].str[SET_DATA][g_set_dis[focus].cursor];	// 取当前修改字符
		if(g_set_dis[focus].type != 's') // 不是汉字修改
		{
			switch(g_set_dis[focus].type)
			{
				case 'o': // 8进制有符号整数
				{
					if(dat=='0')dat='7';else dat--;
					if(dat<'0')dat='7';
				}
				break;
				
				case 'u': // 10进制无符号整数
				{
					if(dat=='0')dat='9';else dat--;
					if(dat<'0')dat='9';
				}
				break;
				
				case 'x': // 16进制无符号整数,小写
				{
					switch(dat)
					{
						case 'a':	dat='9';	break;
						case '0':	dat='f';	break;
						default:	dat--;		break;
					}
				}
				break;
				
				case 'X':  // 16进制无符号整数,大写
				{
					switch(dat)
					{
						case 'A':	dat='9';	break;
						case '0':	dat='F';	break;
						default:	dat--;		break;
					}
				}
				break;
				
				case 'c': // 输出单个字符
				{
					if(dat=='0')dat='9';else dat--;
					if(dat<'0')dat='9';
				}
				break;
				
				case 'B':
				case 'b':  // 2进制数
				{
					if(dat=='0')dat='1';else dat='0';
				}
				break;
				
				case 'd':  // 10进制有符号整数
				case 'i': 
				{
					if(g_set_dis[focus].cursor == 0)
					{
						dat=' ';
					}
					else
					{
						switch(dat)
						{
							case '0':   dat='9';break;
							default:	dat--;	break;
						}
						if(dat<'0'||dat>'9')dat='0';
					}
				}
				break;
				
				case 'f':  // 浮点数
				case 'F':  // 浮点数
				{
					if(g_set_dis[focus].cursor == 0)
					{
						dat=' ';
					}
					else
					{
						switch(dat)
						{
							case '9':
								if((g_set_dis[focus].cursor == g_set_dis[focus].lenth-1)
									&& (!_set_is_have_point()))
								{
									dat='.';  /*防止没有小数点的情况出现*/
								}
								else
								{
									dat='0';
								}
							break;
							
							case '.':	
								_set_move_point(0);
							break;
							
							default:
								if(dat>='0' && dat<='9')
								{
									dat--;
								}
								else 
								{
									dat='0';							
								}
							break;
						}
					}	
				}
				break;
				
				default:
				{
					dat='0';
				}
				break;
			}

			// 修改内容装载入字符串
			if(dat!='.')
			{
				g_set_dis[focus].str[SET_DATA][g_set_dis[focus].cursor] = dat;
			}
		}

		// 将修改内容转换为数值
		_set_get_modify_value();
	}

	// 更新显示
	_set_modify_update(g_page_cur.cur_focus);
	
	// 当前聚焦定值重新刷新
	g_item_update.data[g_page_cur.cur_focus] = 1;
	
	return -1;
}
/******************************************************************************
函数名称：	_sub_key_query
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	减键-查询
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _sub_key_query(void)
{
	// 仅一屏，不翻屏
	if (g_page_cur.wnd_num > 1)
	{		
		// 当前屏非最大，下翻一屏
		if (g_page_cur.cur_wnd > 0)
		{
			g_page_cur.cur_wnd--;
		}		
		else
		{
			g_page_cur.cur_wnd = g_page_cur.wnd_num-1;
		}
		check_cur_wnd_item();
	}
	else
	{
		return 1;
	}

	return 0;
}

/******************************************************************************
函数名称：	_esc_key_menu
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	返回键-菜单
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _esc_key_menu(void)
{
	// 保留当前菜单现场
	g_item_update.autoback = 0;
	g_page_cur.cur_focus = 0;
	g_page_cur.cur_wnd = 0;
	check_cur_wnd_item();
	page_table[g_page_cur.menu_cur] = g_page_cur;

	// 返回上一级菜单
	g_page_cur = page_table[g_page_cur.menu_m];
	check_cur_wnd_item();
	return 0;
}

/******************************************************************************
函数名称：	_esc_key_set
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	返回键-设置
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _esc_key_set(void)
{
	u8 master_menu;

	// 保留当前编辑状态，以便返回
	g_page_set = g_page_cur;

	// 保留当前菜单现场
	g_page_cur.cur_focus = 0;
	g_page_cur.cur_wnd = 0;
	check_cur_wnd_item();
	page_table[g_page_cur.menu_cur] = g_page_cur;

	// 如果退出时需保存确认
	if (menu_base_table[g_page_cur.menu_cur].save)
	{
		// 取出上级页面
		master_menu = g_page_cur.menu_m;
		// 暂存当前页面
		g_mastermenu = g_page_cur.menu_cur;
		
		// 进入保存页面
		g_page_cur = page_table[MENU_SAVE];			
		check_cur_wnd_item();
		if (g_mastermenu == MENU_GLBH || g_mastermenu == MENU_LXBH
			|| g_mastermenu == MENU_JDBH || g_mastermenu == MENU_RECLOSE || g_mastermenu == MENU_BH_STATUS
			|| g_mastermenu == MENU_DLYX || g_mastermenu == MENU_HJS)
		{
			g_page_cur.menu_m = MENU_FIX_SW1 + class_GLBH.sw_idx;
		}
		else g_page_cur.menu_m = master_menu;
	}
	else
	{
		// 直接保存并退出
		// 返回上一级菜单
		g_page_cur = page_table[g_page_cur.menu_m];
		check_cur_wnd_item();
	}	

	return 0;
}

/******************************************************************************
函数名称：	_esc_key_action
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	返回键-动作
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _esc_key_action(void)
{
	// 保留当前菜单现场
	g_page_cur.cur_focus = 0;
	g_page_cur.cur_wnd = 0;
	check_cur_wnd_item();
	page_table[g_page_cur.menu_cur] = g_page_cur;

	// 如果是保存页面,返回保存前编辑状态
	if (g_page_cur.menu_cur == MENU_SAVE)
	{		
		//g_page_cur = page_table[g_mastermenu];
		g_page_cur = g_page_set;
		check_cur_wnd_item();
		return 0;
	}

	// 返回上一级菜单
	g_page_cur = page_table[g_page_cur.menu_m];
	check_cur_wnd_item();

	return 0;
}

/******************************************************************************
函数名称：	_enter_key_menu
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	确认键-菜单
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _enter_key_menu(void)
{
	u8 master_menu, slave_menu;
	u8 code;	
	
	// 取出当前级菜单
	master_menu = g_page_cur.menu_cur;

	// 保留当前级别操作
	page_table[g_page_cur.menu_cur] = g_page_cur;

	// 检索次级菜单
	slave_menu = _check_slave_menu(g_page_cur.menu_cur, g_page_cur.wnd_item*g_page_cur.cur_wnd + g_page_cur.cur_focus);

	code = menu_base_table[slave_menu].code;
	// 需密码进入的菜单
	if (code)
	{
		g_page_cur = page_table[MENU_PASSWORD];
		check_cur_wnd_item();
		g_page_cur.menu_m = master_menu;
		g_slavemenu = slave_menu;
	}
	// 不需密码进入的菜单
	else
	{
		g_page_cur = page_table[slave_menu];
		check_cur_wnd_item();
	}

	// 初始化部分未初始化的页面
	_enter_menu_init();
	
	return 0;
}

/******************************************************************************
函数名称：	_enter_key_set
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	确认键-设置
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _enter_key_set(void)
{
	u8 code;
	
	// 如果是密码页面，进入密码检查
	if (g_page_cur.menu_cur == MENU_PASSWORD)
	{			
		code = menu_base_table[g_slavemenu].code;
		Add_Clear_Screen();
		_password_check(code);		
		return 0;
	}
	
	// 切换编辑和查看状态
	g_set_dis[g_page_cur.cur_focus].cursor = 0;
	g_set_dis[g_page_cur.cur_focus].modify = g_set_dis[g_page_cur.cur_focus].modify ? 0 : 1;

	// 刷新一次数据显示
	g_item_update.data[g_page_cur.cur_focus] = 1;
	return -1;
}

/******************************************************************************
函数名称：	_enter_key_action
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	确认键-动作类
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _enter_key_action(void)
{
	u8 master_menu, result;

	switch(g_page_cur.menu_cur)
	{
		case MENU_SAVE:	// 如果是保存页面
		{
			// 确认
			if (g_page_cur.cur_focus == 0)
			{
				// 保留当前菜单现场
				g_page_cur.cur_focus = 0;
				g_page_cur.cur_wnd = 0;
				check_cur_wnd_item();
				page_table[g_page_cur.menu_cur] = g_page_cur;

				// 取出上级菜单
				master_menu = g_page_cur.menu_m;

				// 固化定值
				result = _set_save_func(g_mastermenu);
				
				// 进入保存结果页面
				g_page_cur = page_table[MENU_SAVE_RESULT];
				check_cur_wnd_item();
				g_page_cur.menu_m = master_menu;			
				_save_result_init(result);

				// 定值设置越限页面
				
			}
			// 取消
			else if (g_page_cur.cur_focus == 1)
			{
			    if(g_mastermenu == MENU_RUN_PARA) {
		            rt_free(run_para_pick_set);
		            rt_free(run_para_setbuf);
		            run_para_pick_set = NULL;
		            run_para_setbuf   = NULL;
			    }
				_esc_key_menu();
			}
		}
		break;

		case MENU_TEST_KC://对应关系还需修改 问题 zwg
		{			
			u8 index=0;
			if (g_page_cur.cur_wnd > 0)
			{
				index = g_page_cur.wnd_item * g_page_cur.cur_wnd;
			}

			if (g_action.action[g_page_cur.cur_focus] == 0)
			{
				bMaintain_test = 1;
				if (g_equ_config_do[g_cfg_index.kc[g_page_cur.cur_focus+index][0]].owner == 0)
				{
					sw_do_pub(g_cfg_index.kc[g_page_cur.cur_focus+index][1],SW_DO_TYPE_ON);
				}
				else
				{
					//DTU4 需单独合一下预置继电器
					sw_do(g_equ_config_do[g_cfg_index.kc[g_page_cur.cur_focus+index][0]].owner-1, \
					g_cfg_index.kc[g_page_cur.cur_focus+index][1],SW_DO_TYPE_SELECT_ON);

					sw_do(g_equ_config_do[g_cfg_index.kc[g_page_cur.cur_focus+index][0]].owner-1, 
						  g_cfg_index.kc[g_page_cur.cur_focus+index][1], 
						  SW_DO_TYPE_ON);
				}	
				ustimer_delay(250*USTIMER_MS);
				bMaintain_test = 0;
				g_action.action[g_page_cur.cur_focus] = 1;
			}
			else
			{
				g_action.action[g_page_cur.cur_focus] = 0;				
			}

			g_item_update.data[g_page_cur.cur_focus] = 1;

			return -1;
		}
		break;

		case MENU_BAT:
		{			
			u8 index =0;
			if (g_page_cur.cur_wnd > 0)
			{
				index = g_page_cur.wnd_item * g_page_cur.cur_wnd;
			}

			if (g_action.action[g_page_cur.cur_focus] == 0)
			{
				if (g_equ_config_do[g_cfg_index.kc[g_page_cur.cur_focus+index+PUB_DO_DCHH][0]].owner == 0)
				{
					sw_do_pub(g_cfg_index.kc[g_page_cur.cur_focus+index+PUB_DO_DCHH][1],SW_DO_TYPE_ON);

					if (g_cfg_index.kc[g_page_cur.cur_focus+index+PUB_DO_DCHH][1] == PUB_DO_DCHH)
					{
						g_batt_mana.hhstart_from = FROM_DEVICE;
					}
					if (g_cfg_index.kc[g_page_cur.cur_focus+index+PUB_DO_DCHH][1] == PUB_DO_HHTC)
					{
						g_batt_mana.hhquit_from = FROM_DEVICE;
					}
				}
				g_action.action[g_page_cur.cur_focus] = 1;
			}
			else
			{
				g_action.action[g_page_cur.cur_focus] = 0;
			}

			g_item_update.data[g_page_cur.cur_focus] = 1;

			return -1;
		}
		break;

		case MENU_CLR:
		{
			if (g_page_cur.page_item[g_page_cur.cur_focus].no == ITEM_CLR_SJ)
			{
				if (g_action.action[g_page_cur.cur_focus] == 0)
				{
					soe_clear_ev();
					soe_record_opt(EV_CLEAR_SOE,0);
					g_action.action[g_page_cur.cur_focus] = 1;
				}
				else
				{
					g_action.action[g_page_cur.cur_focus] = 0;
				}
			}
			else if (g_page_cur.page_item[g_page_cur.cur_focus].no == ITEM_CLR_CZ)
			{
				if (g_action.action[g_page_cur.cur_focus] == 0)
				{
					soe_clear_opt();
					soe_record_opt(EV_CLEAR_OPE,0);
					g_action.action[g_page_cur.cur_focus] = 1;
				}
				else
				{
					g_action.action[g_page_cur.cur_focus] = 0;
				}
			}

			g_item_update.data[g_page_cur.cur_focus] = 1;
			
			return -1;
		}
		break;

		case MENU_TEST_HMI:
		{
			if (g_page_cur.page_item[g_page_cur.cur_focus].no == ITEM_TEST_LCD)
			{
				if (g_action.action[g_page_cur.cur_focus] == 0)
				{
					add_led_test(TEST_LCD);
					g_action.action[g_page_cur.cur_focus] = 1;
				}
				else
				{
					g_action.action[g_page_cur.cur_focus] = 0;
				}				
			}
			if (g_page_cur.page_item[g_page_cur.cur_focus].no == ITEM_TEST_LED)
			{
				if(g_action.action[g_page_cur.cur_focus] == 0)
				{
					add_led_test(TEST_LED);
					g_action.action[g_page_cur.cur_focus] = 1;
				}
				else
				{
					g_action.action[g_page_cur.cur_focus] = 0;
				}				
			}

			g_item_update.data[g_page_cur.cur_focus] = 1;
			
			return -1;
		}
		break;

		case MENU_ADJUST_AC:
		{
			if (g_action.action[g_page_cur.cur_focus] == 0)
			{
				ac_adjust_result = sw_auto_adjust(-1);

				if (ac_adjust_result == 0)
				{
					g_action.action[g_page_cur.cur_focus] = 1;
				}
				else
				{
					// 保存页面
					page_table[g_page_cur.menu_cur] = g_page_cur;
	
					// 进入校准失败页面
					g_page_cur = page_table[MENU_ADJUST_RESULT];

					check_cur_wnd_item();
					
					// 初始化部分未初始化的页面
					_enter_menu_init();
					
					return 0;
				}
			}
			else
			{
				g_action.action[g_page_cur.cur_focus] = 0;
			}				
			g_item_update.data[g_page_cur.cur_focus] = 1;

			return -1;
		}
		break;

		case MENU_ADJUST_DC:
		{
			int ret=0;
			static int adjust_flag=0;
			if (g_page_cur.page_item[g_page_cur.cur_focus].no == ITEM_ADJUST_DC10)
			{
				if (g_action.action[g_page_cur.cur_focus] == 0)
				{
					ret = sw_adjust_dc_0();
					if (ret == 0)
					{
						g_action.action[g_page_cur.cur_focus] = 1;
						adjust_flag = 1;
					}
					else
					{
						g_action.action[g_page_cur.cur_focus] = 2;
					}
				}
				else
				{
					g_action.action[g_page_cur.cur_focus] = 0;
				}	
			}
			if (g_page_cur.page_item[g_page_cur.cur_focus].no == ITEM_ADJUST_DC50)
			{
				if ((g_action.action[g_page_cur.cur_focus] == 0) && (adjust_flag == 1))
				{
					ret = sw_adjust_dc_1();
					adjust_flag = 0;
					if (ret == 0)
					{
						g_action.action[g_page_cur.cur_focus] = 1;
					}
					else
					{
						g_action.action[g_page_cur.cur_focus] = 2;
					}
				}
				else
				{
					g_action.action[g_page_cur.cur_focus] = 0;
				}	
			}
			g_item_update.data[g_page_cur.cur_focus] = 1;

			return -1;
		}
		break;

		case MENU_RMT:	// 如果是保存页面
		{
			if (g_page_cur.page_item[g_page_cur.cur_focus].no == ITEM_RMT_PAIR)
			{
				if (g_action.action[g_page_cur.cur_focus] == 0)
				{	
					g_action.action[g_page_cur.cur_focus] = 1;

					add_rmt_pair(RMT_PAIR);
					// 保存页面
					page_table[g_page_cur.menu_cur] = g_page_cur;
	
					// 进入遥控器配对页面
					g_page_cur = page_table[MENU_RMT_PAIR];

					check_cur_wnd_item();
					// 初始化部分未初始化的页面
					_enter_menu_init();

					// 启动计时
					rmtpair_dely[0][0] = 1;
					rmtpair_dely[0][1] = ustimer_get_origin();
				}
				else
				{
					g_action.action[g_page_cur.cur_focus] = 0;
				}				
			}
			else if (g_page_cur.page_item[g_page_cur.cur_focus].no == ITEM_DEL_PAIR)
			{
				if (g_action.action[g_page_cur.cur_focus] == 0)
				{
					g_action.action[g_page_cur.cur_focus] = 1;
					add_rmt_pair(RMT_CLRPAIR);
					// 保存页面
					page_table[g_page_cur.menu_cur] = g_page_cur;

					// 进入遥控器配对页面
					g_page_cur = page_table[MENU_DEL_PAIR];

					check_cur_wnd_item();
					
					// 初始化部分未初始化的页面
					_enter_menu_init();
					
					// 启动计时
					rmtpair_dely[1][0] = 1;
					rmtpair_dely[1][1] = ustimer_get_origin();
				}
				else
				{
					g_action.action[g_page_cur.cur_focus] = 0;
				}				
			}
		}
		break;

	}
	
	return 0;
}

/******************************************************************************
函数版本：   01.01
创建作者：   康文广
创建日期：   2021-6-15
函数说明：   根据给定长度截断字符串
参数说明：   pin_str:截断前的字符串
             pout_str:截断后的字符串 (含结束符)
             cutoff_len: 截断长度
返回值：     返回截断后的字符串长度
修改记录：
*/
static u8 _cutoff_string(char *pin_str, char *pout_str, u8 cutoff_len)
{
    u8  i=0;
    u8  cnt=0;

    i=0;
    while((i < cutoff_len) && (pin_str[i] !=0)) {
        if((u8)pin_str[i] > 0x80) {
            if(i+2 <= cutoff_len){
                pout_str[cnt++] = pin_str[i];
                pout_str[cnt++] = pin_str[i+1];
                i += 2;
            }else{  //half
                break;
            }
        }else{
            pout_str[cnt++] = pin_str[i];
            i++;
        }
    }
    pout_str[cnt] = 0;

    return  cnt;
}

/******************************************************************************
函数名称：	_check_slave_menu
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	获取子菜单
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _check_slave_menu(u8 menu_m, u8 cur_focus)
{
	int i;

	for (i=0; i<slave_menu_num; i++)
	{
		if (menu_m == slave_table[i].menu_m)
		{
			return slave_table[i].menu_s[cur_focus];
		}
	}
	return -1;
}

/******************************************************************************
函数名称：	_wnd_item_num_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	实体、屏数初始化
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _wnd_item_num_init(void)
{
	// 页面分配的总屏数
	if (g_page_cur.item_num <= g_page_cur.wnd_item)
	{
		g_page_cur.wnd_num = 1;
	}
	else
	{
		g_page_cur.wnd_num = g_page_cur.item_num / g_page_cur.wnd_item;
		if (g_page_cur.item_num % g_page_cur.wnd_item != 0)
		{
			g_page_cur.wnd_num++;
		}
	}

	// 获取当前屏分配的实体数
	check_cur_wnd_item();

	return 0;
}

/******************************************************************************
函数名称：	_enter_menu_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	初始化之前未初始化的内容
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _enter_menu_init(void)
{	
	switch (g_page_cur.menu_cur)
	{

#if ((SWITCH_NUM_MAX == 16) || (SWITCH_NUM_MAX == 6) || (SWITCH_NUM_MAX == 4) || (SWITCH_NUM_MAX == 1) )
		case MENU_FIX_SW1:
#if ((SWITCH_NUM_MAX == 16) || (SWITCH_NUM_MAX == 6) || (SWITCH_NUM_MAX == 4) )			
		case MENU_FIX_SW2:
		case MENU_FIX_SW3:
		case MENU_FIX_SW4:
#endif	
#if ((SWITCH_NUM_MAX == 16) || (SWITCH_NUM_MAX == 6) )			
		case MENU_FIX_SW5:
		case MENU_FIX_SW6:
#endif	
#if SWITCH_NUM_MAX == 16
		case MENU_FIX_SW7:
		case MENU_FIX_SW8:
		case MENU_FIX_SW9:
		case MENU_FIX_SW10:
		case MENU_FIX_SW11:
		case MENU_FIX_SW12:
		case MENU_FIX_SW13:
		case MENU_FIX_SW14:
		case MENU_FIX_SW15:
		case MENU_FIX_SW16:
#endif	

		{
		    class_GLBH.sw_idx = g_page_cur.menu_cur - MENU_FIX_SW1;
		    class_LXBH.sw_idx = g_page_cur.menu_cur - MENU_FIX_SW1;
		    class_JDBH.sw_idx = g_page_cur.menu_cur - MENU_FIX_SW1;
		    class_reclose.sw_idx = g_page_cur.menu_cur - MENU_FIX_SW1;
			class_BH_sts.sw_idx =  g_page_cur.menu_cur - MENU_FIX_SW1;
			class_DLYX.sw_idx =  g_page_cur.menu_cur - MENU_FIX_SW1;
			class_HJS.sw_idx =  g_page_cur.menu_cur - MENU_FIX_SW1;
		    g_page_cur.cur_wnd_item = sw_menu_num;
		}
		break;
#endif
		case MENU_FIX_PUB:
		case MENU_PARA:
		case MENU_RUN_PARA:
		case MENU_FAULT_RESET:
		case MENU_INFIX:
		case MENU_TIMESET:
		case MENU_PASSWORD:
		case MENU_CODE:
		{
			_set_init(g_page_cur.menu_cur);
		}
		break;
		
        case MENU_GLBH:
        case MENU_LXBH:
        case MENU_JDBH:
        case MENU_RECLOSE:
		case MENU_BH_STATUS:
		case MENU_DLYX:
		case MENU_HJS:
        {
            _set_init(g_page_cur.menu_cur);
        }
		break;

		case MENU_TIME:
		{
			g_page_cur.wnd_num = 1;
			g_page_cur.cur_wnd = 0;
		}
		break;
	
		case MENU_SJSOE:
		{
			_soe_init(EEP_SOE_ADDR, g_soe_info.wEvIndex, g_soe_info.wEvNumber, g_soe_info.wEvNumber);
			event_cur.wIndex = g_soe_info.wEvIndex;
			event_cur.wNumber = g_soe_info.wEvNumber;
			event_cur.wCurrent = g_soe_info.wEvNumber;
		}
		break;

		case MENU_CZSOE:
		{
			_soe_init(EEP_OPERATE_ADDR, g_soe_info.wOpIndex, g_soe_info.wOpNumber, g_soe_info.wOpNumber);
			event_cur.wIndex = g_soe_info.wOpIndex;
			event_cur.wNumber = g_soe_info.wOpNumber;
			event_cur.wCurrent = g_soe_info.wOpNumber;
		}
		break;

		case MENU_INFO_EQU:
		case MENU_COMM_PARA:
        {
            _info_equ_init(g_page_cur.menu_cur, g_page_cur.cur_wnd);
        }
        break;

		case MENU_INFO_YX:
		case MENU_INFO_YC:
        {

        }
        break;

		case MENU_INFO_ERR:
		{
			_info_err_init();
		}
		break;

		case MENU_INFO_DEBUG:
		{
			_info_debug_init();
		}
		break;

		case MENU_INFO_GPRS:
		{
			IEC101_PH_GprsInfo();
			_info_gprs_init();
		}
		break;
		
		case MENU_PASSERR:
		{
			_passerr_init();
		}
		break;

		case MENU_TEST_KC:
		case MENU_CLR:
		case MENU_ADJUST_AC:
		case MENU_ADJUST_DC:	
		case MENU_RMT:
		{
			memset(g_action.action, 0, 10);
		}
		break;

		case MENU_RMT_PAIR:
		{
			_rmt_pair_init();
		}
		break;

		case MENU_DEL_PAIR:
		{
			_rmt_delpair_init();
		}
		break;

		case MENU_ADJUST_RESULT:
		{
			_ac_adjust_result_init(ac_adjust_result);
		}
		break;		
	}
	return 0;
}


/******************************************************************************
函数名称：	_soe_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	记录查询初始化
参数说明：	无
返回值：  	成功返回0
修改记录：	
*/
static int _soe_init(u16 addr, u16 soe_index, u16 soe_number, u16 soe_cur)
{
	u16 address;
	EVENT_STRUCT tEv;
	int soe_null=0;

	_reset_page_dis();	
	
	// 无事件产生
	switch (addr)
	{
		case EEP_SOE_ADDR:
		{
			if(g_soe_info.wEvNumber==0)
			{
				strcpy(g_page_dis.str[0],"无事件记录信息");
				g_page_dis.str_num = 1;
				soe_null = 1;
			}
		}
		break;

		case EEP_OPERATE_ADDR:
		{
			if(g_soe_info.wOpNumber==0)
			{
				strcpy(g_page_dis.str[0],"无操作记录信息");
				g_page_dis.str_num = 1;
				soe_null = 1;
			}
		}
		break;
	}

	if (!soe_null)
	{
		// 读出最新条目
		address = addr + soe_index * (sizeof(EVENT_SAVE)) + 4;
		e2prom_read(address, (u8 *)&tEv, sizeof(EVENT_STRUCT)); 

		// 刚进入事件时，显示最新的事件
		g_page_dis.no_cur = soe_cur;
		g_page_dis.no_num = soe_number;	
		g_page_dis.no_index = soe_index;

		// 获取打印内容
		_soe_show(&tEv);
	}

	if (addr == 0)
	{
		event_Auto.tEv = g_soe_queue.soe[g_soe_info.wDpAutoShow].es_ev;

		// 刚进入事件时，显示最新的事件
		g_page_dis.no_cur = soe_cur;
		g_page_dis.no_num = soe_number;	
		g_page_dis.no_index = soe_index;

		_soe_show(&event_Auto.tEv);
		event_cur.wIndex = g_soe_info.wEvIndex;
		event_cur.wNumber = g_soe_info.wEvNumber;
		event_cur.wCurrent = g_soe_info.wEvNumber;		
	}
	// 需显示行
	g_page_cur.item_num = g_page_dis.str_num;

	g_page_cur.cur_wnd = 0;
	_wnd_item_num_init();
	return 0;
}

/******************************************************************************
函数名称：	_soe_show
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	打印记录
参数说明：	常用到"%-16.16s"，是为了写满一行，以避免出现花屏
返回值：  	成功返回0.
修改记录：	
*/
static int _soe_show(EVENT_STRUCT *pe)
{
	EVENT_STRUCT *er = pe;
	struct page_dis *p = &g_page_dis;
	char tmpstr[24]={0};
	char tmpstr1[24]={0};
	struct rtc_time_t tTime;
	u8 soe_type;

	// 初始化
	p->str_num = 0;	

	// 将事件的时间转为rtc_time方式
	timespec_to_rtc(er->ts,&tTime,1);

	if (lcdtype != SMALL)
	{	
		// 第一行
		// 填写序号、年月日
		sprintf((char *)p->str[p->str_num++], "%02d-%02d-%02d %03d/%03d", 
			tTime.year, 
			tTime.month, 
			tTime.day,
			p->no_cur,
			p->no_num);
		// 第二行
		// 填写时分秒毫秒
		sprintf((char *)p->str[p->str_num++], "%02d:%02d:%02d.%03d    ", 
			tTime.hour, 
			tTime.min, 
			(tTime.ms/1000), 
			(tTime.ms%1000));

	}
	else
	{
		// 第一行
		// 填写时分秒毫秒
		sprintf((char *)p->str[p->str_num++], "%03d %02d:%02d:%02d.%03d", 
			p->no_cur,
			tTime.hour, 
			tTime.min, 
			(tTime.ms/1000), 
			(tTime.ms%1000));

	}

	// 事件记录，操作记录
	soe_type = er->ev_type&SOE_TYPE_MASK;
	if(soe_type==SOE_TYPE_EV || soe_type==SOE_TYPE_OPT)   
	{
		int i;
		int ev_sw=0;
//		int len=0;
		u16 code;
		const SOE_DEF * psoe;
		
		if(er->ev_code>=EV_NUMBER)
		{
			// 第三行
			// 填写事件名称
			sprintf(tmpstr, "错误代码:%d", er->ev_code);
			sprintf((char *)p->str[p->str_num++], "%-16.16s", tmpstr);
			return 0;
		}		

		if (er->ev_code < EV_SW_NUM)
		{
			code = er->ev_code;
			ev_sw = 1;
		}
		else if ((er->ev_code >= EV_SW_NUM)&& (er->ev_code < EV_PUB_START))
		{
			code = er->ev_code % EV_SW_NUM;
			ev_sw = (er->ev_code / EV_SW_NUM) + 1;
		}
		else
		{
			code = er->ev_code - EV_SW_NUM*(SWITCH_NUM_MAX-1);
		}
		
		#if SWITCH_NUM_MAX != 1
		{
			if ((ev_sw > 0) && (ev_sw < SWITCH_NUM_MAX))
			{
				sprintf(p->str[p->str_num++],"开关%02d ",ev_sw);
			//	len = strlen(p->str[p->str_num]);
			}
		}
		#endif

		psoe=&tAllSOE[code];		
		
		// 置1 ,产生，显示参数
		if(soe_ev_is_on(er))
		{		
			// 第三行
			// 填写事件名称
			sprintf((char *)p->str[p->str_num++], "%-16.16s", psoe->strName);

			// 第四行~第六行
			// 填写故障记录			
			for(i=0;i<3;i++)
			{
				u8 index = (psoe->Attrib[i]&0x1f);
				
				if(index)
				{
					switch((psoe->Attrib[i]>>5)&0x07)
					{
						case 0:  // 浮点数
							FUC_Get_LongValue_String(er->ev_arg[i],tmpstr1);
							sprintf((char*)tmpstr,"%s=%s%s",ev_para[index].strName,tmpstr1,g_unit[ev_para[index].byNo].name);
						break;
						
						case 1: // 整型值
							sprintf(tmpstr,"%s=%d%s",ev_para[index].strName,er->ev_arg[i],g_unit[ev_para[index].byNo].name);
						break;

						case 2: // 遥控操作,为适应液晶的显示尺寸，将遥遥控来源拆成两行 zwg
						{
							BYTE sw=(er->ev_arg[0]>>8)&0xff; //开关号
							BYTE no=(er->ev_arg[0]>>0)&0xff;	//序号
							char *ykowner;
							ykowner=get_yk_owner((er->ev_arg[0]>>16)&0xff);
							if(sw==0)
							{
								if (i==0)
								{
									sprintf(tmpstr,"%s",ykowner);
								}
								else if (i==1)
								{
									sprintf(tmpstr,"公共开出%02d",no);
								}								
							}
							else
							{
								if (i==0)
								{
									sprintf(tmpstr,"%s",ykowner);
								}
								else if (i==1)
								{
									sprintf(tmpstr,"开关%02d开出%02d",sw,no);	// 修复遥控事件记录查询不显示开关号的问题 	modify by zhy 20201016
								}
							}
						}						
						break;
												
						case 3: // 压板操作
						{
							strcpy(tmpstr,"投入");
						}						
						break;	
							
						default:strcpy(tmpstr,"参数错误");		
						break;
					}
					if (((psoe->Attrib[i]>>5)&0x07) == 3)
					{
						memset(p->str[p->str_num--], 0, 18);
						strcpy((char *)p->str[p->str_num],psoe->strName);
						strcat((char *)p->str[p->str_num++],tmpstr);
					}
					else
					{
						sprintf((char *)p->str[p->str_num++],"%-16.16s",tmpstr);
					}
				}
			}
		}
		// 置 0，显示返回值
		else 
		{
			// 第三行
			// 填写事件名称
			strcpy((char *)p->str[p->str_num],psoe->strName);
			strcat((char *)p->str[p->str_num++],ev_back[(psoe->soe_def&0x03)]);
		}
		
	}
	// 遥信变位记录
	else  if(soe_type==SOE_TYPE_YX)
	{
		u8 solt=(u8)(er->ev_code>>8);	//板卡号
		u8 dino=(u8)(er->ev_code);		//遥信号
	
		// 第三行
		// 填写事件名称
		// 采用160x160液晶显示遥信乱码	  add by zhy 2020.08.03
		// sprintf((char *)p->str[p->str_num], "%-14.14s", equ_di_name(solt,dino)); //开入对应的开关遥信名称
		if(soe_ev_is_on(er)) // 置1 ,产生，显示参数
		{
			strcpy(tmpstr,"合");
		}
		else
		{
			strcpy(tmpstr,"分");

		}
		strcpy((char *)p->str[p->str_num],equ_di_name(solt,dino));	// add by zhy 2020.08.03
		strcat((char *)p->str[p->str_num++],tmpstr);
	}	
 	else  if(soe_type==SOE_TYPE_LNK )
	{
		char name[TRANS_SZ_BUF_LEN];
		LINK_TABLE * lt;

		lt = (LINK_TABLE *)er->ev_arg[0];
		tbl_getname(RES_TYPE_YX,lt->tbl_index,name);

		// 第三行
		// 填写事件名称
		// name[0] = 0;
		sprintf((char *)p->str[p->str_num], "%-16.16s", name); //开入对应的开关遥信名称
		if(soe_ev_is_on(er)) // 置1 ,产生，显示参数
		{
			strcpy(tmpstr,"合");
		}
		else
		{
			strcpy(tmpstr,"分");

		}
		strcat((char *)p->str[p->str_num++],tmpstr);
	}	
 	// 双点变位记录
 	else if(soe_type==SOE_TYPE_DPI)
	{
		sprintf((char *)p->str[p->str_num++],"双点[%04x]: %d",g_di_db_table[er->ev_code].cp,er->ev_value); 
 	}
 	// PLC变位记录
 	else if(soe_type==SOE_TYPE_PLC)
	{
		int  index;
 	    int  cutoffLen;
 	    char name[TRANS_SZ_BUF_LEN]={0};
        int  chars_per_line = sizeof(p->str[0])- 2;

		sprintf((char *)p->str[p->str_num++],"PLC[%04x]: 值%d",g_plc[er->ev_code].cp, er->ev_value);

		index = tbl_cp2index(g_plc[er->ev_code].cp);
		if(index >= 0){
		    tbl_getname(RES_TYPE_YX, index, name);
		    if(strlen(name) > chars_per_line) {
		        cutoffLen = _cutoff_string(name, (char *)p->str[p->str_num], chars_per_line);
		        p->str[p->str_num++][chars_per_line] = 0;
		        _cutoff_string(name+cutoffLen, (char *)p->str[p->str_num++], chars_per_line);
		    }else{
		        _cutoff_string(name, (char *)p->str[p->str_num++], chars_per_line);
		    }
		    p->str[p->str_num][chars_per_line] = 0;

		}
 	}
	else
	{
		sprintf(tmpstr,"未知类型:%d",er->ev_code);
		sprintf((char *)p->str[p->str_num++],"%-16.16s",tmpstr);
	}		

	if (lcdtype == SMALL)
	{
		// 最后一行
		// 填写序号、年月日
		sprintf((char *)p->str[p->str_num++], "20%02d-%02d-%02d", 
			tTime.year, 
			tTime.month, 
			tTime.day);
		sprintf((char *)p->str[p->str_num++], "%02d:%02d:%02d.%03d", 
			tTime.hour, 
			tTime.min, 
			(tTime.ms/1000), 
			(tTime.ms%1000));

	}

	return 0;
}

/******************************************************************************
函数名称：	_soe_auto_check
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	突发事件巡检
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _soe_auto_check(void)
{
	if(g_page_cur.menu_cur != MENU_MAIN 
	&&g_page_cur.menu_cur != MENU_EVENT) // 主菜单弹窗
	{
		g_soe_info.bDpNew = false;
		return -2;
	}

	if(!g_soe_info.bDpNew) //没有事件产生
	{
		return -1;
	}
	g_soe_info.bDpNew = false;

	// 若背光关闭，即打开背光
	if (g_tLcdComm.tLight.light != LIGHT_ON)
	{
		g_tLcdComm.tLight.light = LIGHT_ON;
		g_tLcdComm.tLight.flag = true;
	}
	
	// 进入突发事件页面
	g_page_cur = page_table[MENU_EVENT];
	check_cur_wnd_item();
	g_page_cur.menu_m = MENU_MAIN;

	// 若面板未清屏，即清屏
	if (!g_tLcdComm.bClrflag)
	{
		Add_Clear_Screen();
		g_tLcdComm.bClrflag = true;
	}
	else
	{
		//清发送缓冲区
		g_tLcdComm.tContinue.head=g_tLcdComm.tContinue.tail=0;
		g_tLcdComm.tContinue.index=0;
	}

	_soe_init(EEP_SOE_ADDR, g_soe_info.wEvIndex, g_soe_info.wEvNumber, g_soe_info.wEvNumber);
	event_cur.wIndex = g_soe_info.wEvIndex;
	event_cur.wNumber = g_soe_info.wEvNumber;
	event_cur.wCurrent = g_soe_info.wEvNumber;

	return 0;
}

/******************************************************************************
函数名称：	_info_err_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	错误信息显示初始化
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _info_err_init(void)
{
	int i, j=0;
	int err[8];
	int errno=0;
	for(i=0;i<ERR_CODE_NUM;i++)
	{
		if(rt_err_test(i)>0)
		{
			errno++;
			err[j] = i;
			j++;
		}		
	}

	// 需显示行
	// 错误信息少于8个，更新实体总数
	if(errno == 0)
	{
		g_page_cur.item_num = 1;
	}	
	else if (errno < INFO_ERR_QUERY)
	{
		g_page_cur.item_num = errno;
	}
	
	if(errno == 0)
	{
		strcpy(g_page_dis.str[0],"无错误信息");
	}
	else
	{
		for (i=0; i<errno; i++)
		{
			sprintf(g_page_dis.str[i],"%-17.17s",rt_err_msg(err[i]));
		}
	}
	
	_wnd_item_num_init();
	return 0;
}

/******************************************************************************
函数名称：	_info_debug_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	调试信息显示初始化
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _info_debug_init(void)
{
	int i=0;
	int debug_port;
	char * acteth;

	// 取出调试网口
	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 = 0;			
		}	
		
	}
	else 
	{
		debug_port = 0;			
			
	}

	sprintf(g_page_dis.str[i++],"调试串口:%d",g_con_uart_index);
	strcpy(g_page_dis.str[i++],"115200,无校验");
	
	sprintf(g_page_dis.str[i++],"调试网口:%d",debug_port+1);
	
	strcpy(g_page_dis.str[i++],"I P 地址:");
	sprintf(g_page_dis.str[i++],"%s",env_get_info(ENV_IPADDR));
	
	strcpy(g_page_dis.str[i++],"MASK地址:");
	sprintf(g_page_dis.str[i++],"%s",env_get_info(ENV_NETMASK));
	
	strcpy(g_page_dis.str[i++],"GATE地址:");
	sprintf(g_page_dis.str[i++],"%s",env_get_info(ENV_GATEWAYIP));	

	_wnd_item_num_init();
	return 0;
}

/******************************************************************************
函数名称：	_info_gprs_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	GPRS信息显示初始化
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _info_gprs_init(void)
{
	int i, num;
	
	//获取内部GPRS状态信息
	num = gprs_get_info();

	// 如果有信息，存入显示缓存
	if (num != 0)
	{
		g_page_dis.str_num = num;
		for (i=0; i<g_page_dis.str_num; i++)
		{
			memcpy(&g_page_dis.str[i], &strGprsInf[i], 18);
		}
	}
	// 如果没有信息,且是第一次刷新，进入等待页面
	else if (!gprs_info_up[0])
	{
		strcpy(g_page_dis.str[0],"  信息获取中... ");
		g_page_dis.str_num = 1;
	}	

	if ((!gprs_info_up[0]) || (g_page_cur.item_num != g_page_dis.str_num))
	{
		// 需显示行
		g_page_cur.item_num = g_page_dis.str_num;
		_wnd_item_num_init();
		gprs_info_up[0] = 1;
		gprs_info_up[1] = ustimer_get_origin();
	}
	return 0;
}

/******************************************************************************
函数说明：   装置信息显示初始化
函数版本：   01.01
创建作者：   KangWenguang
创建日期：   2021-06-10
参数说明：   无
返回值：    成功返回0.
修改记录：
*/
#define  max_line_char   18

struct _disp_page
{
     u8  begin;
     u8  end;
     u8  lines;
};
static struct _disp_page s_disp_equ[] =
{
    {FIXED_SET_EQU,   FIXED_SET_HVR,   9},  //公司名 用两行显示
    {FIXED_SET_SVR,   FIXED_SET_TPE,   8},
    {FIXED_SET_ID,    FIXED_SET_MAC1,  5},  //终端ID号用两行显示
};
static int s_disp_equ_pages = sizeof( s_disp_equ ) / sizeof(s_disp_equ[0]);

static struct _disp_page s_disp_comm_para[] =
{ 
   {0,    0,  0},  
};
static int s_disp_comm_pages = sizeof( s_disp_comm_para ) / sizeof(s_disp_comm_para[0]);


static int _info_equ_init(u8 menu_no, u8 wnd_no)
{
    int  i=0;
    int  idx=0;
    int  len=0;
    int  cutoff_len;
    int  line_num = INFO_EQU_QUERY;
    char buf[48] ={0};
    int  begin, end;

    if(menu_no == MENU_INFO_EQU) {
        begin    = s_disp_equ[wnd_no].begin;
        end      = s_disp_equ[wnd_no].end;
        line_num = s_disp_equ[wnd_no].lines;
    }else{  //MENU_COMM_PARA
        begin    = s_disp_comm_para[wnd_no].begin;
        end      = s_disp_comm_para[wnd_no].end;
        line_num = s_disp_comm_para[wnd_no].lines;
    }

	for ( i = 0; i < 16; i++)
	{
		memset(g_page_dis.str[i], 0, sizeof(u8)*20);
	}

    for(i=begin; i<=end && idx <line_num; i++) {
        //name
        sprintf(buf, "%s[%04X]:", tfixedsettable[i].name, tfixedsettable[i].di);
        cutoff_len = _cutoff_string(buf, g_page_dis.str[idx], max_line_char);
        g_page_dis.str[idx][cutoff_len] = 0;
        idx++;

        len = strlen(buf);
        if(len >= max_line_char) {
            cutoff_len = _cutoff_string(buf+cutoff_len, (char *)g_page_dis.str[idx], max_line_char);
            g_page_dis.str[idx][cutoff_len] = 0;
            idx++;
        }

        //content
        set_get_fixed_arg(i,buf,48);
        cutoff_len = _cutoff_string(buf, g_page_dis.str[idx], max_line_char);
        g_page_dis.str[idx][cutoff_len] = 0;
        idx++;

        len = strlen(buf);
        if(len >= max_line_char) {
            cutoff_len = _cutoff_string(buf+cutoff_len, (char *)g_page_dis.str[idx], max_line_char);
            g_page_dis.str[idx][cutoff_len] = 0;
            idx++;
        }
    }

    if(menu_no == MENU_INFO_EQU) {
        for(i=0; i<s_disp_equ_pages; i++) {
            g_page_cur.item_num += s_disp_equ[wnd_no].lines;
        }
        g_page_cur.wnd_num  = s_disp_equ_pages;

    }else{   //MENU_COMM_PARA
        for(i=0; i<s_disp_comm_pages; i++) {
            g_page_cur.item_num += s_disp_comm_para[wnd_no].lines;
        }
        g_page_cur.wnd_num  = s_disp_comm_pages;
    }

    g_page_cur.wnd_item = INFO_EQU_QUERY;
    g_page_cur.cur_wnd_item = line_num;

    return 0;
}

/******************************************************************************
函数名称：	_passerr_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	密码错误显示初始化
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _passerr_init(void)
{
	int i=0;

	strcpy(g_page_dis.str[i++],"    输入密码    ");	
	strcpy(g_page_dis.str[i++],"  密码输入错误  ");
	_wnd_item_num_init();

	return 0;
}


/******************************************************************************
函数名称：	_rmt_pair_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	遥控器配对显示初始化
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _rmt_pair_init(void)
{
	int i=0;

	strcpy(g_page_dis.str[i++]," 请在30秒内按下 ");	
	strcpy(g_page_dis.str[i++],"  遥控器任意键  ");
	_wnd_item_num_init();

	return 0;
}

/******************************************************************************
函数名称：	_rmt_delpair_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	遥控器清除配对显示初始化
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _rmt_delpair_init(void)
{
	int i=0;

	strcpy(g_page_dis.str[i++],"请耐心等待10秒后 ");	
	strcpy(g_page_dis.str[i++],"  再操作遥控器  ");
	_wnd_item_num_init();

	return 0;
}

/******************************************************************************
函数名称：	_save_result_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	保存结果显示初始化
参数说明：	result:0 成功，1 失败
返回值：  	成功返回0.
修改记录：	
*/
static int _save_result_init(u8 result)
{
	strcpy(g_page_dis.str[0],"保存");

	if (result == 1)
	{
		//保存成功自动返回上一级菜单，失败时则不自动返回
		g_item_update.autoback = 1;
		g_item_update.autoback_dly = dTCounter;

		strcat(g_page_dis.str[0],"成功");
	}
	else
	{
		strcat(g_page_dis.str[0],"失败");
	}
	
	_wnd_item_num_init();
	return 0;
}

/******************************************************************************
函数名称：	_ac_adjust_result_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	交流校准结果显示初始化
参数说明：	result:0 成功，1 失败
返回值：  	成功返回0.
修改记录：	
*/
static int _ac_adjust_result_init(int result)
{

	if(result == 0)
	{
		strcpy(g_page_dis.str[0],"通道校正成功");
	}
	else if(result == -1)
	{
		strcpy(g_page_dis.str[0],"输入校正值太大");
	}
	else if(result == -2)
	{
		strcpy(g_page_dis.str[0],"通道系数超范围");
	}
	else if(result == -3)
	{
		strcpy(g_page_dis.str[0],"输入角度值太小");
	}
	else if(result == -4)
	{
		strcpy(g_page_dis.str[0],"输入角度值太小");
	}
	else if(result == -5)
	{
		strcpy(g_page_dis.str[0],"角度系数超范围");
	}
	else if(result == -6)
	{
		strcpy(g_page_dis.str[0],"系数保存错误");
	}
	else 
	{
		strcpy(g_page_dis.str[0],"未知错误");
	}
	
	_wnd_item_num_init();
	return 0;
}
/******************************************************************************
函数名称：	_set_get_list_man_len
函数版本：	01.01
创建作者：	 
创建日期：	2017-5-18
函数说明：	获取list字符串的最大长度
参数说明：	
			pTable: 整定值参数表结构
返回值：  	list字符串的最大长度.
修改记录：	
*/
static int _set_get_list_man_len(const TSETTABLE *pTable)
{
	int i;
	int len=0, max=0;

	for(i=0; i< pTable->listnum;i++)
	{
		len = strlen(pTable->list[i].str);
		if(len > max )
		{
			max = len;
		}
	}

	return max;
}
static int _get_i_by_sw0idx(u8 sw0idx)
{
    int i;

    for(i=0; i<g_rmt_para_disp.sw0_idx_sum; i++ ){
        if(g_rmt_para_disp.sw0_idx[i] == sw0idx){
            return i;
        }
    }

    return -1;
}

static int _get_rmt_para_val(void)
{
    int i;
    int offset=0;
    TSETTABLE *psettbl =NULL;
    struct grp_pick *pgroup =NULL;
    char buf[20] ={0};
    u8  idx_cnt[256] = {0};
    int find_i = 0;

    //公共定值
    psettbl = (TSETTABLE *)&tPubSetTable[0];
    if(!ReadSet(m_runsection,(void *)m_SetBuf))
    {
        rt_err_set(ERR_CODE_SET,0);
        GetDefSet((float*)m_SetBuf);
    }

    pgroup = &g_rmt_para_disp.pgrp[RMT_GRP_PUSET];
    for(i=0; i< pgroup->num; i++){
        run_para_pick_set[pgroup->rmt_idx[i]] = psettbl[pgroup->grp_idx[i]];
        run_para_setbuf[pgroup->rmt_idx[i]]   = m_SetBuf[pgroup->grp_idx[i]];
    }

    //开关定值
    psettbl = (TSETTABLE *)&tSwSetTable[0];
    if(!ReadSet(m_runsection,(void *)m_SetBuf))
    {
        rt_err_set(ERR_CODE_SET,0);
        GetDefSet((float*)m_SetBuf);
    }

    pgroup = &g_rmt_para_disp.pgrp[RMT_GRP_SWSET];
    for(i=0; i< pgroup->num; i++){
        TSETTABLE *psettmp =NULL;

        run_para_pick_set[pgroup->rmt_idx[i]] = psettbl[pgroup->grp_idx[i]];

        //修改定值名称
        psettmp = &run_para_pick_set[pgroup->rmt_idx[i]];

        find_i = _get_i_by_sw0idx( pgroup->grp_idx[i]);
		// rt_printf("RMT_GRP_SWSET find_i=%d grp_idx[%d]=%d index=%d type=%d, name=%s \r\n", find_i, i, pgroup->grp_idx[i], pgroup->rmt_idx[i],psettmp->wType, psettmp->szName);
        if(find_i >= 0) {
            snprintf(buf, 20, "L%02d%s", idx_cnt[find_i]+1, psettmp->szName);
            strncpy(psettmp->szName, buf, 20);
			// rt_printf("RMT_GRP_SWSET index=%d type=%d, name=%s \r\n", pgroup->rmt_idx[i],psettmp->wType, psettmp->szName);
            offset = PUB_SET_NUMBER + idx_cnt[find_i]*SW_SET_NUMBER;
            idx_cnt[find_i]++;

        }else{
            offset = PUB_SET_NUMBER;
        }

        _cutoff_string(psettmp->szName, psettmp->szName, 19);

        run_para_setbuf[pgroup->rmt_idx[i]] = m_SetBuf[offset + pgroup->grp_idx[i]];
    }

    //装置参数
    psettbl = (TSETTABLE *)&tEquipParaTable[0];
    if(!ReadPara((void*)m_SetBuf, EEP_EQUIP_PARA_ADDR, EQUIP_PARA_NUMBER, psettbl))
    {
        rt_err_set(ERR_CODE_EQU_PARA,0);
        GetDefPara((void*)m_SetBuf, EQUIP_PARA_NUMBER, psettbl);
    }

    pgroup = &g_rmt_para_disp.pgrp[RMT_GRP_EQSET];
    for(i=0; i< pgroup->num; i++){
        run_para_pick_set[pgroup->rmt_idx[i]] = psettbl[pgroup->grp_idx[i]];
        run_para_setbuf[pgroup->rmt_idx[i]]   = m_SetBuf[pgroup->grp_idx[i]];
    }

	//内部定值
    psettbl = (TSETTABLE *)&tCstSetTable[0];
    if(!ReadPara((void*)m_SetBuf, EEP_CSTSET_ADDR, CSTSET_NUMBER, psettbl))
    {
        rt_err_set(ERR_CODE_SET_IN,0);
        GetDefPara((float*)m_SetBuf, CSTSET_NUMBER, psettbl);
    }
 
    pgroup = &g_rmt_para_disp.pgrp[RMT_GRP_CSSET];
    for(i=0; i< pgroup->num; i++){
        run_para_pick_set[pgroup->rmt_idx[i]] = psettbl[pgroup->grp_idx[i]];
        run_para_setbuf[pgroup->rmt_idx[i]]   = m_SetBuf[pgroup->grp_idx[i]];
        // rt_printf("RMT_GRP_CSSET index=%d type=%d, name=%s \r\n", pgroup->rmt_idx[i],run_para_pick_set[pgroup->rmt_idx[i]].wType, run_para_pick_set[pgroup->rmt_idx[i]].szName);
    }


    return 0;
}

static int _save_rmt_para_val(u8 sw_num)
{
    int i;
    int sw=0;
    int offset=0;
    TSETTABLE *psettbl =NULL;
    struct grp_pick *pgroup =NULL;
    u8  idx_cnt[16] = {0};
    int find_i = 0;

    _set_change_set(&run_para_pick_set[0], g_rmt_para_disp.total, offset);
	
    memcpy(&run_para_setbuf[0], &m_SetBuf[0], g_rmt_para_disp.total *sizeof(SET_VALUE));
	
    //---公共定值----
    if(!ReadSet(m_runsection,(void *)m_SetBuf))
    {
        rt_err_set(ERR_CODE_SET,0);
        GetDefSet((float*)m_SetBuf);
    }
    //更新相应值
    pgroup = &g_rmt_para_disp.pgrp[RMT_GRP_PUSET];
    for(i=0; i< pgroup->num; i++){
        m_SetBuf[pgroup->grp_idx[i]] = run_para_setbuf[pgroup->rmt_idx[i]];
    }

    if(!_set_check_set(&tPubSetTable[0], PUB_SET_NUMBER, m_SetBuf))
    {
        soe_record_opt(EV_SET_FAIL,0);
        return -11;
    }
    else if(SaveSet(m_runsection,(void *)m_SetBuf))
    {
        soe_record_opt(EV_SET_OK,0);
        MakeRunSet(false);
        rt_err_clr(ERR_CODE_SET,0);
    }
    else
    {
        soe_record_opt(EV_SET_FAIL,0);
        return -12;
    }
	
    //---开关定值----
    if(!ReadSet(m_runsection,(void *)m_SetBuf))
    {
        rt_err_set(ERR_CODE_SET,0);
        GetDefSet((float*)m_SetBuf);
    }
    //更新相应值
    pgroup = &g_rmt_para_disp.pgrp[RMT_GRP_SWSET];
    for(i=0; i< pgroup->num; i++) {
        find_i = _get_i_by_sw0idx( pgroup->grp_idx[i]);
        if(find_i >= 0) {
            offset = PUB_SET_NUMBER + idx_cnt[find_i]*SW_SET_NUMBER;
            idx_cnt[find_i]++;

        }else{
            offset = PUB_SET_NUMBER;
        }
        m_SetBuf[offset + pgroup->grp_idx[i]] = run_para_setbuf[pgroup->rmt_idx[i]];
    }
	
    for(sw=0; sw < sw_num; sw++){
        offset = PUB_SET_NUMBER + sw*SW_SET_NUMBER;
        if(!_set_check_set(&tSwSetTable[0], SW_SET_NUMBER, &m_SetBuf[offset]))
        {
            soe_record_opt(EV_SET_FAIL,0);
            return -21;
        }
    }

    if(SaveSet(m_runsection,(void *)m_SetBuf))
    {
        soe_record_opt(EV_SET_OK,0);
        MakeRunSet(false);
        rt_err_clr(ERR_CODE_SET,0);
    }
    else
    {
        soe_record_opt(EV_SET_FAIL,0);
        return -22;
    }
	
    //---装置参数----
    psettbl = (TSETTABLE *)&tEquipParaTable[0];
    if(!ReadPara((void*)m_SetBuf, EEP_EQUIP_PARA_ADDR, EQUIP_PARA_NUMBER, psettbl))
    {
        rt_err_set(ERR_CODE_EQU_PARA,0);
        GetDefPara((void*)m_SetBuf, EQUIP_PARA_NUMBER, psettbl);
    }
    //更新相应值
    pgroup = &g_rmt_para_disp.pgrp[RMT_GRP_EQSET];
    for(i=0; i< pgroup->num; i++){
        m_SetBuf[pgroup->grp_idx[i]] = run_para_setbuf[pgroup->rmt_idx[i]];
    }

    if(!_set_check_set(&tEquipParaTable[0], EQUIP_PARA_NUMBER, m_SetBuf))
    {
        soe_record_opt(EV_EQUPARA_FAIL,0);
        return -31;
    }
    else if(SavePara((void *)m_SetBuf,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
    {
        soe_record_opt(EV_EQUPARA_FAIL,0);
        return -32;
    }

	//---内部定值----
    psettbl = (TSETTABLE *)&tCstSetTable[0];
    if(!ReadPara((void*)m_SetBuf, EEP_CSTSET_ADDR, CSTSET_NUMBER, psettbl))
    {
        rt_err_set(ERR_CODE_SET_IN,0);
        GetDefPara((float*)m_SetBuf, CSTSET_NUMBER, psettbl);
    }
    //更新相应值
    pgroup = &g_rmt_para_disp.pgrp[RMT_GRP_CSSET];
    for(i=0; i< pgroup->num; i++){
        m_SetBuf[pgroup->grp_idx[i]] = run_para_setbuf[pgroup->rmt_idx[i]];
    }
 
    if(!_set_check_set(&tCstSetTable[0], CSTSET_NUMBER, m_SetBuf))
    {
        soe_record_opt(EV_CSTSET_FAIL,0);
        return -33;
    }
    else if(SavePara((void *)m_SetBuf,EEP_CSTSET_ADDR,CSTSET_NUMBER,&tCstSetTable[0]))
    {
        soe_record_opt(EV_CSTSET_OK,0);
        MakeRunPara(false, false);
        rt_err_clr(ERR_CODE_SET_IN,0);
    }
    else
    {
        soe_record_opt(EV_CSTSET_FAIL,0);
        return -34;
    }

    return 0;
}

/******************************************************************************
函数名称：	_set_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	定值显示初始化
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _set_init(u8 type)
{
	int i, no=0, no1=0,	num=0, index=0;

	// 清除之前页面的g_set_dis
	memset(g_set_dis, 0, sizeof(g_set_dis));

	// 清除菜单类型
	g_sw_setdisp.type = 0;
	g_equip_paradisp.type = 0;
	g_cst_setdisp.type    = 0;
	g_pub_setdisp.type    = 0;
	g_rmt_para_disp.type  = 0;
	g_faultRst_setdisp.type=0;

	// 读取定值
	switch(type)
	{
		case MENU_FIX:
		{
		    //do nothing
		}
		break;
		
		case MENU_FIX_PUB:
		{
			num = PUB_SET_NUMBER;
			index = 0;
			if(!ReadSet(m_runsection,(void *)m_SetBuf))
			{
				rt_err_set(ERR_CODE_SET,0);
				GetDefSet((float*)m_SetBuf);
			}
			pset = (TSETTABLE *)&tPubSetTable[0];
			g_pub_setdisp.type = type;
			
			// 更新公共保护定值数量
			g_page_cur.item_num = g_pub_setdisp.num;

			// 重新分配窗体
			g_page_cur.wnd_num = g_page_cur.item_num / g_page_cur.wnd_item;
			if (g_page_cur.item_num % g_page_cur.wnd_item != 0)
			{
				g_page_cur.wnd_num++;
			}
		}
		break;

		case MENU_GLBH:
		case MENU_LXBH:
		case MENU_JDBH:
        case MENU_RECLOSE:
		case MENU_BH_STATUS:
		case MENU_DLYX:
		case MENU_HJS:
		{
            u16 sw_index =0, bh_num =0;
            if(type == MENU_GLBH){
                sw_index = class_GLBH.sw_idx;
                bh_num   = class_GLBH.num;
            }else if(type == MENU_LXBH){
                sw_index = class_LXBH.sw_idx;
                bh_num   = class_LXBH.num;
            }else if(type == MENU_JDBH){
                sw_index = class_JDBH.sw_idx;
                bh_num   = class_JDBH.num;
            }else if(type == MENU_RECLOSE){
                sw_index = class_reclose.sw_idx;
                bh_num   = class_reclose.num;
            }
			else if(type == MENU_BH_STATUS){
				sw_index = class_BH_sts.sw_idx;
				bh_num   = class_BH_sts.num;
			}
			else if(type == MENU_DLYX){
				sw_index = class_DLYX.sw_idx;
				bh_num   = class_DLYX.num;
			}
			else if(type == MENU_HJS){
				sw_index = class_HJS.sw_idx;
				bh_num   = class_HJS.num;
			}
			num = SW_SET_NUMBER;
		    index = PUB_SET_NUMBER + sw_index*SW_SET_NUMBER;
			if(!ReadSet(m_runsection,(void *)m_SetBuf))
			{
				rt_err_set(ERR_CODE_SET,0);
				GetDefSet((float*)m_SetBuf);
			}
			pset = (TSETTABLE *)&tSwSetTable[0];
			g_sw_setdisp.type = type;
			
			// 更新开关保护定值数量
			g_page_cur.item_num = bh_num;

			// 重新分配窗体
			g_page_cur.wnd_num = g_page_cur.item_num / g_page_cur.wnd_item;
			if (g_page_cur.item_num % g_page_cur.wnd_item != 0)
			{
				g_page_cur.wnd_num++;
			}
		}
		break;

		case MENU_PARA:
		{
			num = EQUIP_PARA_NUMBER;
			index = 0;
			pset = (TSETTABLE *)&tEquipParaTable[0];
			if(!ReadPara((void*)m_SetBuf, EEP_EQUIP_PARA_ADDR, num, pset))
			{
				rt_err_set(ERR_CODE_EQU_PARA,0);
				GetDefPara((void*)m_SetBuf,num,pset);
			}

			// 网卡参数初始化
			_set_net_init();

			// 时钟参数初始化
			_set_time_init(PARA_BATBEGIN_YMD);
			
			g_equip_paradisp.type = type;
			
			// 更新装置参数数量
			g_page_cur.item_num = g_equip_paradisp.num;	

			// 重新分配窗体
			g_page_cur.wnd_num = g_page_cur.item_num / g_page_cur.wnd_item;
			if (g_page_cur.item_num % g_page_cur.wnd_item != 0)
			{
				g_page_cur.wnd_num++;
			}
		}
		break;
		
        case MENU_FAULT_RESET:
        {
            num = EQUIP_PARA_NUMBER;
            index = 0;
            pset = (TSETTABLE *)&tEquipParaTable[0];
            if(!ReadPara((void*)m_SetBuf, EEP_EQUIP_PARA_ADDR, num, pset))
            {
                rt_err_set(ERR_CODE_EQU_PARA,0);
                GetDefPara((void*)m_SetBuf,num,pset);
            }

            g_faultRst_setdisp.type = type;

            // 更新装置参数数量
            g_page_cur.item_num = g_faultRst_setdisp.num;

            // 重新分配窗体
            g_page_cur.wnd_num = g_page_cur.item_num / g_page_cur.wnd_item;
            if (g_page_cur.item_num % g_page_cur.wnd_item != 0)
            {
                g_page_cur.wnd_num++;
            }
        }
        break;

        case MENU_RUN_PARA:
        {

            if(run_para_pick_set != NULL) {
                rt_printf("[%s , %d] free run_para_pick_set ERROR! \r\n", __func__, __LINE__);
                rt_free(run_para_pick_set);
            }
            if(run_para_setbuf != NULL) {
                rt_printf("[%s , %d] free run_para_setbuf ERROR! \r\n", __func__, __LINE__);
                rt_free(run_para_setbuf);
            }

            // 分配内存
            run_para_pick_set = rt_malloc(g_rmt_para_disp.total * 2 * sizeof(TSETTABLE));
            if(run_para_pick_set == NULL)
            {
                rt_printf("[%s , %d] MENU_RUN_PARA rt_malloc FAIL !\r\n", __func__, __LINE__ );
                break;
            }
            run_para_setbuf = rt_malloc(g_rmt_para_disp.total * 2 * sizeof(SET_VALUE));
            if(run_para_setbuf == NULL){
                rt_printf("[%s , %d] MENU_RUN_PARA rt_malloc setbuf FAIL !\r\n", __func__, __LINE__ );
                break;
            }

            _get_rmt_para_val();


            pset = (TSETTABLE *)&run_para_pick_set[0];
            memcpy(&m_SetBuf[0], &run_para_setbuf[0], g_rmt_para_disp.total *sizeof(SET_VALUE));
            index = 0;
            num   = g_rmt_para_disp.total;

            g_rmt_para_disp.type = type;

            // 更新远动参数数量
            g_page_cur.item_num = g_rmt_para_disp.total;

            // 重新分配窗体
            g_page_cur.wnd_num = g_page_cur.item_num / g_page_cur.wnd_item;
            if (g_page_cur.item_num % g_page_cur.wnd_item != 0)
            {
                g_page_cur.wnd_num++;
            }
        }
        break;
		
		case MENU_TIMESET:
		{
			struct timespec ts;
			struct rtc_time_t rtc;
			num = TIME_SET_NUMBER;
			index = 0;
			pset = (TSETTABLE *)&tTimeTable[0];

			clk_time_get(&ts);
			timespec_to_rtc(ts,&rtc,1);
			
			m_SetBuf[TIME_YEAR].ff = rtc.year;
			m_SetBuf[TIME_MONTH].ff = rtc.month;
			m_SetBuf[TIME_DAY].ff = rtc.day;
			m_SetBuf[TIME_HOUR].ff = rtc.hour;
			m_SetBuf[TIME_MINUTE].ff = rtc.min;
			m_SetBuf[TIME_SECOND].ff = rtc.ms/1000;
		}
		break;
		
		case MENU_INFIX:
		{
			num = CSTSET_NUMBER;
			index = 0;
			pset = (TSETTABLE *)&tCstSetTable[0];
			if(!ReadPara((void*)m_SetBuf, EEP_CSTSET_ADDR, num, pset))
			{
				rt_err_set(ERR_CODE_SET_IN,0);
				GetDefPara((float*)m_SetBuf, num, pset);
			}

			g_cst_setdisp.type = type;
			
			// 更新内部定值数量
			g_page_cur.item_num = g_cst_setdisp.num;	

			// 重新分配窗体
			g_page_cur.wnd_num = g_page_cur.item_num / g_page_cur.wnd_item;
			if (g_page_cur.item_num % g_page_cur.wnd_item != 0)
			{
				g_page_cur.wnd_num++;
			}
		}
		break;

		case MENU_CODE:
		{
			num = CODE_SET_NUMBER;
			index = 0;
			pset = (TSETTABLE *)&tCodeTable[0];
			m_SetBuf[0].ff = ReadPassword();
		}
		break;

		case MENU_PASSWORD:
		{
			num = 1;
			index = 0;
			pset = (TSETTABLE *)&tPasswordTable[0];
			m_SetBuf[0].ff = 0;   //显示全0
		}
		break;
	}

	// 将INT型定值转换为菜单设置用内容, 保存时要调用  _set_change_set()再转换回来
	_set_change_type(pset, num, &m_SetBuf[index]);

	// 初始化屏数
	g_page_cur.cur_wnd = 0;
	g_page_cur.cur_focus = 0;
	
	check_cur_wnd_item();
	
	// 初始化首屏定值,第一行取序号和名称，第二行取数据，定值范围由desc取得
	for (i=0; i<g_page_cur.cur_wnd_item; i++)
	{
		no1 = 0;
		if (g_pub_setdisp.type == MENU_FIX_PUB)
		{
			no = g_pub_setdisp.no[i];
		}		
		else if (g_sw_setdisp.type == MENU_GLBH)
        {
		    no = class_GLBH.idx[i];
		    no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_GLBH.sw_idx;
        }
        else if (g_sw_setdisp.type == MENU_LXBH)
        {
            no = class_LXBH.idx[i];
            no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_LXBH.sw_idx;
        }
        else if (g_sw_setdisp.type == MENU_JDBH)
        {
            no = class_JDBH.idx[i];
            no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_JDBH.sw_idx;
        }
        else if (g_sw_setdisp.type == MENU_RECLOSE)
        {
            no = class_reclose.idx[i];
            no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_reclose.sw_idx;
        }
        else if (g_sw_setdisp.type == MENU_BH_STATUS)
        {
            no = class_BH_sts.idx[i];
            no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_BH_sts.sw_idx;
        }
        else if (g_sw_setdisp.type == MENU_DLYX)
        {
            no = class_DLYX.idx[i];
            no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_DLYX.sw_idx;
        }
		else if (g_sw_setdisp.type == MENU_HJS)
        {
            no = class_HJS.idx[i];
            no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_HJS.sw_idx;
        }
		else if (g_equip_paradisp.type == MENU_PARA)
		{
			no = g_equip_paradisp.no[i];
		}
        else if (g_faultRst_setdisp.type == MENU_FAULT_RESET)
        {
            no = g_faultRst_setdisp.no[i];
        }
		else if (g_cst_setdisp.type == MENU_INFIX)
		{
			no = g_cst_setdisp.no[i];
		}		
		else
		{
			no = i;
		}

		if (pset[no].wType == SETTYPE_IP)
		{

			_set_get_dispdata(i, no*4, &g_set_dis[i], &pset[no], g_netpara);
			g_set_dis[i].lenth = 0;
			g_set_dis[i].lenth = _set_spcl_fmt_init_modify(DISP_IP, i, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata1);
			g_set_dis[i].lenth += _set_spcl_fmt_init_modify(DISP_IP, i, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata2);
			g_set_dis[i].lenth += _set_spcl_fmt_init_modify(DISP_IP, i, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata3);
			g_set_dis[i].lenth += _set_spcl_fmt_init_modify(DISP_IP, i, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata4);
		}
		else if (pset[no].wType == SETTYPE_YMD)
		{

			_set_get_dispdata(i, (no-PARA_BATBEGIN_YMD)*3, &g_set_dis[i], &pset[no], g_timepara);
			g_set_dis[i].lenth = 0;
			g_set_dis[i].lenth = _set_spcl_fmt_init_modify(DISP_YMD, i, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata1);
			g_set_dis[i].lenth += _set_spcl_fmt_init_modify(DISP_YMD, i, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata2);
			g_set_dis[i].lenth += _set_spcl_fmt_init_modify(DISP_YMD, i, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata3);
		}
		else if (pset[no].wType == SETTYPE_HMS)
		{

			_set_get_dispdata(i, (no-PARA_BATBEGIN_HMS)*3, &g_set_dis[i], &pset[no], &g_timepara[3]);
			g_set_dis[i].lenth = 0;
			g_set_dis[i].lenth = _set_spcl_fmt_init_modify(DISP_HMS, i, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata1);
			g_set_dis[i].lenth += _set_spcl_fmt_init_modify(DISP_HMS, i, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata2);
			g_set_dis[i].lenth += _set_spcl_fmt_init_modify(DISP_HMS, i, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata3);
		}
		else if (pset[no].wType == SETTYPE_LIST)
		{
			u16 len,len1;
			char p = ' ';
			_set_get_dispdata(i, no, &g_set_dis[i], &pset[no], &m_SetBuf[no1]);
			//取得list字符串的最大长度
			len = _set_get_list_man_len(&pset[no]);
			//本次字符串的长度
			len1=strlen((char *)g_set_dis[i].pdata);
			//清零
			memset(g_set_dis[i].list_str, 0, sizeof(g_set_dis[i].list_str));
			//拷贝到list_str
			strcat(g_set_dis[i].list_str, (char *)g_set_dis[i].pdata);
			//不够长的，补" "
            if(len > len1)
                memset(&g_set_dis[i].list_str[len1],  p, len-len1);
			//末尾置0
			g_set_dis[i].list_str[len] = 0;
			//指向list_str
			g_set_dis[i].pdata =(void *)g_set_dis[i].list_str;
			_set_fmt_init_modify(i, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata);
		}
		else
		{

			_set_get_dispdata(i, no, &g_set_dis[i], &pset[no], &m_SetBuf[no1]);
			_set_fmt_init_modify(i, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata);
		}
		g_set_dis[i].cursor = 0;
	}

	g_set_dis[g_page_cur.cur_focus].modify = 1;
	return 0;
}

/******************************************************************************
函数名称：	_set_change_disp
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	定值显示切屏
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _set_change_disp(void)
{
	int i, index=0, no, no1;
	// 当前设置项No
	if (g_page_cur.cur_wnd > 0)
	{
		index = g_page_cur.wnd_item * g_page_cur.cur_wnd;
	}

	// 初始化屏数
	check_cur_wnd_item();

	// 清除之前页面的g_set_dis
	memset(g_set_dis, 0, sizeof(g_set_dis));
	
	// 初始化首屏定值,第一行取序号和名称，第二行取数据，第三行取定值范围
	for (i=0; i<g_page_cur.cur_wnd_item; i++)
	{
		no1 = 0;
		if (g_pub_setdisp.type == MENU_FIX_PUB)
		{
			no = g_pub_setdisp.no[i+index];
		}
		else if (g_sw_setdisp.type == MENU_GLBH)
		{
		    no = class_GLBH.idx[i+index];
			no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_GLBH.sw_idx;
		}
        else if (g_sw_setdisp.type == MENU_LXBH)
        {
            no = class_LXBH.idx[i+index];
            no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_LXBH.sw_idx;
        }
        else if (g_sw_setdisp.type == MENU_JDBH)
        {
            no = class_JDBH.idx[i+index];
            no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_JDBH.sw_idx;
        }
        else if (g_sw_setdisp.type == MENU_RECLOSE)
        {
            no = class_reclose.idx[i+index];
            no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_reclose.sw_idx;
        }
        else if (g_sw_setdisp.type == MENU_BH_STATUS)
        {
            no = class_BH_sts.idx[i+index];
            no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_BH_sts.sw_idx;
        }
        else if (g_sw_setdisp.type == MENU_DLYX)
        {
            no = class_DLYX.idx[i+index];
            no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_DLYX.sw_idx;
        }
        else if (g_sw_setdisp.type == MENU_HJS)
        {
            no = class_HJS.idx[i+index];
            no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_HJS.sw_idx;
        }
		else if (g_equip_paradisp.type == MENU_PARA)
		{
			no = g_equip_paradisp.no[i+index];
		}
	    else if (g_faultRst_setdisp.type == MENU_FAULT_RESET)
	    {
	        no = g_faultRst_setdisp.no[i+index];
	    }
		else if (g_cst_setdisp.type == MENU_INFIX)
		{
			no = g_cst_setdisp.no[i+index];
		}		
		else
		{
			no = i+index;
		}
		if (pset[no].wType == SETTYPE_IP)
		{

			_set_get_dispdata(i+index, no*4, &g_set_dis[i], &pset[no], g_netpara);
			g_set_dis[i].lenth = 0;
			g_set_dis[i].lenth = _set_spcl_fmt_init_modify(DISP_IP, i+index, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata1);
			g_set_dis[i].lenth += _set_spcl_fmt_init_modify(DISP_IP, i+index, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata2);
			g_set_dis[i].lenth += _set_spcl_fmt_init_modify(DISP_IP, i+index, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata3);
			g_set_dis[i].lenth += _set_spcl_fmt_init_modify(DISP_IP, i+index, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata4);
		}
		else if (pset[no].wType == SETTYPE_YMD)
		{

			_set_get_dispdata(i+index, (no-PARA_BATBEGIN_YMD)*3, &g_set_dis[i], &pset[no], g_timepara);
			g_set_dis[i].lenth = 0;
			g_set_dis[i].lenth = _set_spcl_fmt_init_modify(DISP_YMD, i+index, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata1);
			g_set_dis[i].lenth += _set_spcl_fmt_init_modify(DISP_YMD, i+index, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata2);
			g_set_dis[i].lenth += _set_spcl_fmt_init_modify(DISP_YMD, i+index, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata3);
		}
		else if (pset[no].wType == SETTYPE_HMS)
		{

			_set_get_dispdata(i+index, (no-PARA_BATBEGIN_HMS)*3, &g_set_dis[i], &pset[no], &g_timepara[3]);
			g_set_dis[i].lenth = 0;
			g_set_dis[i].lenth = _set_spcl_fmt_init_modify(DISP_HMS, i+index, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata1);
			g_set_dis[i].lenth += _set_spcl_fmt_init_modify(DISP_HMS, i+index, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata2);
			g_set_dis[i].lenth += _set_spcl_fmt_init_modify(DISP_HMS, i+index, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata3);
		}
		else if (pset[no].wType == SETTYPE_LIST)
		{
			int len,len1;
			char p = ' ';
			_set_get_dispdata(i+index, no, &g_set_dis[i], &pset[no], &m_SetBuf[no1]);
			//取得list字符串的最大长度
			len = _set_get_list_man_len(&pset[no]);
			//本次字符串的长度
			len1=strlen((char *)g_set_dis[i].pdata);
			//清零
			memset(g_set_dis[i].list_str, 0, sizeof(g_set_dis[i].list_str));
			//拷贝到list_str
			strcat(g_set_dis[i].list_str, (char *)g_set_dis[i].pdata);
			//不够长的，补" "
			if(len > len1)
			    memset(&g_set_dis[i].list_str[len1],  p, len-len1);
			//末尾置0
			g_set_dis[i].list_str[len] = 0;
			//指向list_str
			g_set_dis[i].pdata = g_set_dis[i].list_str;
			_set_fmt_init_modify(i, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata);
		}		
		else
		{
			_set_get_dispdata(i+index, no, &g_set_dis[i], &pset[no], &m_SetBuf[no1]);
			_set_fmt_init_modify(i, &g_set_dis[i], (char *)g_set_dis[i].desc, (void *)g_set_dis[i].pdata);
		}
		g_set_dis[i].cursor = 0;
	}

	return 0;
}

/******************************************************************************
函数名称：	_set_modify_update
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	定值修改更新显示
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _set_modify_update(int cur_focus)
{
	int index=0, no, no1;
	// 当前设置项No
	if (g_page_cur.cur_wnd > 0)
	{
		index = g_page_cur.wnd_item * g_page_cur.cur_wnd;
	}
	
	no1 = 0;
	if (g_pub_setdisp.type == MENU_FIX_PUB)
	{
		no = g_pub_setdisp.no[cur_focus+index];
	}
	else if (g_sw_setdisp.type == MENU_GLBH)
	{
		no = class_GLBH.idx[cur_focus+index];
		no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_GLBH.sw_idx;
	}
    else if (g_sw_setdisp.type == MENU_LXBH)
    {
        no = class_LXBH.idx[cur_focus+index];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_LXBH.sw_idx;
    }
    else if (g_sw_setdisp.type == MENU_JDBH)
    {
        no = class_JDBH.idx[cur_focus+index];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_JDBH.sw_idx;
    }
    else if (g_sw_setdisp.type == MENU_RECLOSE)
    {
        no = class_reclose.idx[cur_focus+index];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_reclose.sw_idx;
    }
    else if (g_sw_setdisp.type == MENU_BH_STATUS)
    {
        no = class_BH_sts.idx[cur_focus+index];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_BH_sts.sw_idx;
    }
    else if (g_sw_setdisp.type == MENU_DLYX)
    {
        no = class_DLYX.idx[cur_focus+index];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_DLYX.sw_idx;
    }
	else if (g_sw_setdisp.type == MENU_HJS)
    {
        no = class_HJS.idx[cur_focus+index];
        no1 = PUB_SET_NUMBER + SW_SET_NUMBER * class_HJS.sw_idx;
    }
	else if (g_equip_paradisp.type == MENU_PARA)
	{
		no = g_equip_paradisp.no[cur_focus+index];
	}
    else if (g_faultRst_setdisp.type == MENU_FAULT_RESET)
    {
        no = g_faultRst_setdisp.no[cur_focus+index];
    }
	else if (g_cst_setdisp.type == MENU_INFIX)
	{
		no = g_cst_setdisp.no[cur_focus+index];
	}		
	else
	{
		no = cur_focus+index;
	}
	if (pset[no].wType == SETTYPE_IP)
	{

		_set_get_dispdata(cur_focus+index, no*4, &g_set_dis[cur_focus], &pset[no], g_netpara);
		g_set_dis[cur_focus].lenth = 0;
		g_set_dis[cur_focus].lenth = _set_spcl_fmt_init_modify(DISP_IP, cur_focus, &g_set_dis[cur_focus], (char *)g_set_dis[cur_focus].desc, (void *)g_set_dis[cur_focus].pdata1);
		g_set_dis[cur_focus].lenth += _set_spcl_fmt_init_modify(DISP_IP, cur_focus, &g_set_dis[cur_focus], (char *)g_set_dis[cur_focus].desc, (void *)g_set_dis[cur_focus].pdata2);
		g_set_dis[cur_focus].lenth += _set_spcl_fmt_init_modify(DISP_IP, cur_focus, &g_set_dis[cur_focus], (char *)g_set_dis[cur_focus].desc, (void *)g_set_dis[cur_focus].pdata3);
		g_set_dis[cur_focus].lenth += _set_spcl_fmt_init_modify(DISP_IP, cur_focus, &g_set_dis[cur_focus], (char *)g_set_dis[cur_focus].desc, (void *)g_set_dis[cur_focus].pdata4);
	}
	else if (pset[no].wType == SETTYPE_YMD)
	{

		_set_get_dispdata(cur_focus+index, (no-PARA_BATBEGIN_YMD)*3, &g_set_dis[cur_focus], &pset[no], g_timepara);
		g_set_dis[cur_focus].lenth = 0;
		g_set_dis[cur_focus].lenth = _set_spcl_fmt_init_modify(DISP_YMD, cur_focus, &g_set_dis[cur_focus], (char *)g_set_dis[cur_focus].desc, (void *)g_set_dis[cur_focus].pdata1);
		g_set_dis[cur_focus].lenth += _set_spcl_fmt_init_modify(DISP_YMD, cur_focus, &g_set_dis[cur_focus], (char *)g_set_dis[cur_focus].desc, (void *)g_set_dis[cur_focus].pdata2);
		g_set_dis[cur_focus].lenth += _set_spcl_fmt_init_modify(DISP_YMD, cur_focus, &g_set_dis[cur_focus], (char *)g_set_dis[cur_focus].desc, (void *)g_set_dis[cur_focus].pdata3);
	}
	else if (pset[no].wType == SETTYPE_HMS)
	{

		_set_get_dispdata(cur_focus+index, (no-PARA_BATBEGIN_HMS)*3, &g_set_dis[cur_focus], &pset[no], &g_timepara[3]);
		g_set_dis[cur_focus].lenth = 0;
		g_set_dis[cur_focus].lenth = _set_spcl_fmt_init_modify(DISP_HMS, cur_focus, &g_set_dis[cur_focus], (char *)g_set_dis[cur_focus].desc, (void *)g_set_dis[cur_focus].pdata1);
		g_set_dis[cur_focus].lenth += _set_spcl_fmt_init_modify(DISP_HMS, cur_focus, &g_set_dis[cur_focus], (char *)g_set_dis[cur_focus].desc, (void *)g_set_dis[cur_focus].pdata2);
		g_set_dis[cur_focus].lenth += _set_spcl_fmt_init_modify(DISP_HMS, cur_focus, &g_set_dis[cur_focus], (char *)g_set_dis[cur_focus].desc, (void *)g_set_dis[cur_focus].pdata3);
	}
	else if (pset[no].wType == SETTYPE_LIST)
	{
		int len,len1;
		char p = ' ';
		_set_get_dispdata(cur_focus+index, no, &g_set_dis[cur_focus], &pset[no], &m_SetBuf[no1]);
		//取得list字符串的最大长度
		len = _set_get_list_man_len(&pset[no]);
		//本次字符串的长度
		len1=strlen((char *)g_set_dis[cur_focus].pdata);
		//清零
		memset(g_set_dis[cur_focus].list_str, 0, sizeof(g_set_dis[cur_focus].list_str));
		//拷贝到list_str
		strcat(g_set_dis[cur_focus].list_str, (char *)g_set_dis[cur_focus].pdata);
		//不够长的，补" "
		if(len > len1)
		    memset(&g_set_dis[cur_focus].list_str[len1],  p, len-len1);
		//末尾置0
		g_set_dis[cur_focus].list_str[len] = 0;
		//指向list_str
		g_set_dis[cur_focus].pdata = g_set_dis[cur_focus].list_str;
		_set_fmt_init_modify(cur_focus, &g_set_dis[cur_focus], (char *)g_set_dis[cur_focus].desc, (void *)g_set_dis[cur_focus].pdata);
	}	
	else
	{
		_set_get_dispdata(cur_focus+index, no, &g_set_dis[cur_focus], &pset[no], &m_SetBuf[no1]);
		_set_fmt_init_modify(cur_focus, &g_set_dis[cur_focus], (char *)g_set_dis[cur_focus].desc, (void *)g_set_dis[cur_focus].pdata);
	}

	return 0;
}


/******************************************************************************
函数名称：	_set_get_dispdata
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	获取显示用定值
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _set_get_dispdata(int no, int setno, struct set_dis *pt, const TSETTABLE *pTable, SET_VALUE *setbuf)
{
	float ff;

	// 取定值序号和名称
	if (g_page_cur.menu_cur == MENU_PASSWORD)
	{
		strcpy(pt->str[SET_NAME], pTable->szName);
	}
	else
	{
	    char  *pname=NULL;
		sprintf(pt->str[SET_NAME], "%02d ", no+1);
		//湖南版本特殊处理
		if((g_page_cur.menu_cur == MENU_GLBH) ||
		   (g_page_cur.menu_cur == MENU_LXBH) ||
		   (g_page_cur.menu_cur == MENU_RECLOSE) ||
		   (g_page_cur.menu_cur == MENU_FAULT_RESET)) {
		    pname = get_replace_setdisp(no, g_page_cur.menu_cur);
		    if(pname != NULL)
		        strcat(pt->str[SET_NAME], pname);
		}else{
		    strcat(pt->str[SET_NAME], pTable->szName);
		}
	}
	
	// 取定值、取定值范围
	switch(pTable->wType)
	{
		case SETTYPE_UINT:   //16进制显示  控制字
		{
			// “*”符:用以表示该输入项,读入后不赋予相应的变量，即跳过该输入值
			strcpy(pt->desc, "%*3u");   //对齐符号位
			pt->pdata = (void*)&setbuf[setno].tt;
		}
		break;

		case SETTYPE_4INT:   //10进制显示  4位
		{
			strcpy(pt->desc, "%*4u");   //对齐符号位
			pt->pdata = (void*)&setbuf[setno].tt;
		}
		break;		

		case SETTYPE_5INT:   //10进制显示  5位
		{
			strcpy(pt->desc, "%*5u");   //对齐符号位
			pt->pdata = (void*)&setbuf[setno].tt;
		}
		break;

        case SETTYPE_6INT:   //10进制显示  6位
        {
            strcpy(pt->desc, "%*6u");   //对齐符号位
            pt->pdata = (void*)&setbuf[setno].tt;
        }
        break;

		case SETTYPE_LINT:   //16进制显示  控制字
		{
			strcpy(pt->desc, "%*6u");   //对齐符号位
			pt->pdata=(void*)&setbuf[setno].tt;
		}
		break;
		
		case SETTYPE_LIST:   //列表选择 
		{
			DWORD dw = (WORD)(setbuf[setno].ff);	
			strcpy(pt->desc, "%s");   
			pt->pdata = (void*)pTable->list[dw].str;
			//pt->pdata = (void*)pTable->list[setbuf[setno].tt].str;
			pt->list = TRUE;
		}
		break;

		case SETTYPE_IP:
		{
			// “*”符:用以表示该输入项,读入后不赋予相应的变量，即跳过该输入值
			strcpy(pt->desc, "%*3u");   //对齐符号位
			pt->pdata1 = (void*)&setbuf[setno].tt;
			pt->pdata2 = (void*)&setbuf[setno+1].tt;
			pt->pdata3 = (void*)&setbuf[setno+2].tt;
			pt->pdata4 = (void*)&setbuf[setno+3].tt;
		}
		break;

		case SETTYPE_YMD:
		case SETTYPE_HMS:
		{
			// “*”符:用以表示该输入项,读入后不赋予相应的变量，即跳过该输入值
			strcpy(pt->desc, "%*2u");   //对齐符号位
			pt->pdata1 = (void*)&setbuf[setno].tt;
			pt->pdata2 = (void*)&setbuf[setno+1].tt;
			pt->pdata3 = (void*)&setbuf[setno+2].tt;
		}
		break;
		
		case SETTYPE_F:
		{
			ff=setbuf[setno].ff;
			switch(_set_get_float_disp((void *)&ff))
			{
				
				case 0:   //浮点数
					strcpy(pt->desc, "%+-6.1f");
				break;
				
				case 1:   //浮点数
					strcpy(pt->desc, "%+-6.1f");
				break;
				
				case 2:   //浮点数
					strcpy(pt->desc, "%+-6.2f");
				break;
				
				case 3:   //浮点数
					strcpy(pt->desc, "%+-6.3f");
				break;
				
				default:
					strcpy(pt->desc, "%+-6.1f");
				break;
			}
			pt->pdata=(void*)&setbuf[setno].ff;
		}
		break;

        default:
        {
            rt_printf("[%s, %d] ERROR: %d, %d \r\n", __func__, __LINE__, pTable->wType, setno);
            return -1;
        }
        //break;
	}

	// 给定值赋单位
	if ((pTable->wType != SETTYPE_IP)
		|| (pTable->wType != SETTYPE_YMD)
		|| (pTable->wType != SETTYPE_HMS))
	{
		strcat(pt->desc, " ");  //单位
		strcat(pt->desc, SetUints[pTable->wUnit]);  //单位
	}
	return 0;
}

/******************************************************************************
函数名称：	_set_fmt_init_modify
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	进入修改模式，初始化函数
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _set_fmt_init_modify(u8 index, struct set_dis *pt, const char *FmtStr,...)
{
	int i, j=0;
	char postart=0; 
	char fmtstr[24];	// 格式描述字符串
	u8 fmt_flag = TRUE; // %号只分析一次 
	va_list  ap;		//定义字符指针
	
	fmtstr[0] = '\0';
	pt->type = 'u';
	pt->lenth = 0;
	
	// 获取可变参数列表的第一个参数的地址（ap是类型为va_list的指针，FmtStr是可变参数最左边的参数）
	va_start(ap,FmtStr);

	// 循环到结构描述的字符串结尾
	for(; *FmtStr!='\0' ;)
	{
		if(*FmtStr=='%' && fmt_flag)
		{	
			// 数据
			pt->x = postart;
			
			// 复制数值格式描述串,并获取描述所占长度
			i = ScanFmtStr(&pt->type, FmtStr, fmtstr);
			
			// 小数点是否需编辑
			if((index<0xff) && (pt->type=='f'))
			{
				pt->point_mdf = TRUE;
				pt->pdesc = (void*)FmtStr;
			}
			else
			{
				pt->point_mdf = FALSE;
			}
			if(i)
			{
				// 从格式描述串中略过数值格式描述串,以便从list中取得定值指针
				FmtStr += i;
				
				// 将格式描述与数据对接，获得按格式打印数据的效果，并将数据转为字符串存入Valstr，返回长度给Lenth
				pt->lenth = ValuePtrToStr(pt->str[SET_DATA], fmtstr, ap);
			}
			fmt_flag = FALSE;
		}
		else
		{
			/*将字符输出到输出字符串中*/
			pt->str[SET_UNIT][j]=*FmtStr++;
			j++;
			pt->str[SET_UNIT][j]='\0';
			pt->len = j;
		}
		postart++;
	}
	
	// 清空va_list可变参数列表
	va_end(ap);	 

	// 要编辑符号的话，先跳过符号位,即正负位
	/*if(pt->type=='f'||pt->type=='d'||pt->type=='i') 
	{
		pt->cursor = 1;
	}*/

	return 0;
}


/******************************************************************************
函数名称：	_set_spcl_fmt_init_modify
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	进入修改模式，初始化函数
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _set_spcl_fmt_init_modify(int type, u8 index, struct set_dis *pt, const char *FmtStr,...)
{
	int i=0, j=0, len=0;
	char postart=0; 
	char fmtstr[24];	// 格式描述字符串
	u8 fmt_flag = TRUE; // %号只分析一次 
	va_list  ap;		//定义字符指针
	
	fmtstr[0] = '\0';
	pt->type = 'u';
	pt->spcl_type = type;
	
	// 获取可变参数列表的第一个参数的地址（ap是类型为va_list的指针，FmtStr是可变参数最左边的参数）
	va_start(ap,FmtStr);

	// 循环到结构描述的字符串结尾
	for(; *FmtStr!='\0' ;)
	{
		if(*FmtStr=='%' && fmt_flag)
		{	
			// 数据
			pt->x = postart;
			
			// 复制数值格式描述串,并获取描述所占长度
			i = ScanFmtStr(&pt->type, FmtStr, fmtstr);
			
			// 小数点是否需编辑
			if((index<0xff) && (pt->type=='f'))
			{
				pt->point_mdf = TRUE;
				pt->pdesc = (void*)FmtStr;
			}
			else
			{
				pt->point_mdf = FALSE;
			}
			if(i)
			{
				// 从格式描述串中略过数值格式描述串,以便从list中取得定值指针
				FmtStr += i;
				
				// 将格式描述与数据对接，获得按格式打印数据的效果，并将数据转为字符串存入Valstr，返回长度给Lenth
				len = ValuePtrToStr(&pt->str[SET_DATA][pt->lenth], fmtstr, ap);
				if (type == DISP_IP)
				{
					if (pt->lenth < 12)
					{
						pt->str[SET_DATA][pt->lenth+3] = '.';
						len++;
					}
				}
				else if (type == DISP_YMD)
				{
					if (pt->lenth < 6)
					{
						pt->str[SET_DATA][pt->lenth+2] = '-';
						len++;
					}
				}
				else if (type == DISP_HMS)
				{
					if (pt->lenth < 6)
					{
						pt->str[SET_DATA][pt->lenth+2] = ':';
						len++;
					}
				}
			}
			fmt_flag = FALSE;
		}
		else
		{
			/*将字符输出到输出字符串中*/
			pt->str[SET_UNIT][j]=*FmtStr++;
			j++;
			pt->str[SET_UNIT][j]='\0';
			pt->len = j;
		}
		postart++;
	}
	
	// 清空va_list可变参数列表
	va_end(ap);	 

	// 要编辑符号的话，先跳过符号位,即正负位
	/*if(pt->type=='f'||pt->type=='d'||pt->type=='i') 
	{
		pt->cursor = 1;
	}*/

	return len;
}


/******************************************************************************
函数名称：	_set_change_type
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	转换定值，将EEPROM中的值转换为菜单整定时使用的值，主要是控制字
          由浮点数转为定点数
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _set_change_type(const TSETTABLE *pSet,int num,SET_VALUE *setbuf)
{
	int i;
	for(i=0;i<num;i++)
	{
		if(_set_is_integer(pSet[i].wType))
		{			
			float ff = setbuf[i].ff;
			setbuf[i].tt = (long)ff;		
		}
	}

	return 0;
}

/******************************************************************************
函数名称：	_is_integ_type
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	判断参数类型是否为整型类型的
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _set_is_integer(u16 type)
{
	if ((type == SETTYPE_UINT)
		|| (type == SETTYPE_LINT)
		|| (type == SETTYPE_4INT)
		|| (type == SETTYPE_5INT)
		|| (type == SETTYPE_6INT))
	{
		return TRUE;
	}
	return FALSE;
}

/******************************************************************************
函数名称：	_set_is_have_point
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	判断是否有小数点
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _set_is_have_point(void)
{
	u8 cnt;
	for(cnt=0; cnt<g_set_dis[g_page_cur.cur_focus].lenth; cnt++)
	{
		if(g_set_dis[g_page_cur.cur_focus].str[SET_DATA][cnt] == '.')
		{
			return 1;
		}
	}
	return 0;
}

/******************************************************************************
函数名称：	_set_move_point
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	判断是否有小数点
参数说明：	bFlag: 1 右移, 0 左移
返回值：  	成功返回0.
修改记录：	
*/
static int _set_move_point(int bFlag)
{
	u8 point,cnt,focus,len,cursor;
	char TempStr[40];
	char *p = TempStr;

	focus = g_page_cur.cur_focus;
	len = g_set_dis[focus].lenth;
	cursor = g_set_dis[focus].cursor;

	// 检索除小数点外的其他内容
	for(cnt=0; cnt<len; cnt++)
	{
		if(g_set_dis[focus].str[SET_DATA][cnt] == '.')
		{
			continue;
		}
		*p++ = g_set_dis[focus].str[SET_DATA][cnt];
	}

	// 取小数点位置
	point = cursor;

	// 小数点移位
    if(bFlag) // 小数点右移
	{
		if(point >= len-1)
		{
			point=1;  		// 到最右边
		}
		else
		{
			point++;
		}
	}
	else	// 小数点左移
	{
		if(point <= 1)
		{
			point = len-1;  // 到最左边
		}
		else 
		{
			point--;
		}
	}

	// 将移位结果装载回字符串
	p=TempStr;
	for(cnt=0; cnt<len; cnt++)
	{
		if(cnt == point)
		{
			g_set_dis[focus].str[SET_DATA][cnt] = '.';
		}
		else 
		{
			g_set_dis[focus].str[SET_DATA][cnt] = *p++;
		}
	}

	// 光标移位
	g_set_dis[focus].cursor=point;

	return 0;
}

/**************************************************************************
函数名称：_set_get_modify_value
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能：分析编辑字符串的格式，并取得编辑状态下数据的值
输入参数：
输出参数：
返回值：
日期：	  
*/
static int _set_get_modify_value(void)
{	
	u8 precison,len,focus;
	char *p;

	len = 0;
	focus = g_page_cur.cur_focus;

	if (g_set_dis[focus].spcl_type == DISP_IP)
	{
		StrToValue(&g_set_dis[focus].str[SET_DATA][0], g_set_dis[focus].desc, g_set_dis[focus].pdata1);
		StrToValue(&g_set_dis[focus].str[SET_DATA][4], g_set_dis[focus].desc, g_set_dis[focus].pdata2);
		StrToValue(&g_set_dis[focus].str[SET_DATA][8], g_set_dis[focus].desc, g_set_dis[focus].pdata3);
		StrToValue(&g_set_dis[focus].str[SET_DATA][12], g_set_dis[focus].desc, g_set_dis[focus].pdata4);		
	}
	else if ((g_set_dis[focus].spcl_type == DISP_YMD) || (g_set_dis[focus].spcl_type == DISP_HMS))
	{
		StrToValue(&g_set_dis[focus].str[SET_DATA][0], g_set_dis[focus].desc, g_set_dis[focus].pdata1);
		StrToValue(&g_set_dis[focus].str[SET_DATA][3], g_set_dis[focus].desc, g_set_dis[focus].pdata2);
		StrToValue(&g_set_dis[focus].str[SET_DATA][6], g_set_dis[focus].desc, g_set_dis[focus].pdata3);
	}
	else
	{
		// 字符串转数值
		StrToValue(g_set_dis[focus].str[SET_DATA], g_set_dis[focus].desc, g_set_dis[focus].pdata);

		// 打印出正在修改的定值
		//rt_printf("%s, %s, %f, %d\r\n", g_set_dis[focus].str[SET_DATA], g_set_dis[focus].desc, *(float *)g_set_dis[focus].pdata, *(long *)g_set_dis[focus].pdata);

		// 小数点可变
		if(g_set_dis[focus].point_mdf && (g_set_dis[focus].type=='f'))  
		{
			// 获取定值数据的精度，即小数点后的位数
			precison = _set_get_float_disp((void *)g_set_dis[focus].pdata); 
			p = _set_fmtstr_Precison(g_set_dis[focus].pdesc, &len);
			if((len!=precison) && (p!=NULL)) /*小数点后有效位数不同*/
			{
				*p = precison+'0';
			}
			strcpy(g_set_dis[focus].desc,g_set_dis[focus].pdesc);
		}
	}
	return 0;
}

/**************************************************************************
函数名称：_set_fmtstr_Precison
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能：分析格式字符串代表的数据的精度
输入参数：
输出参数：
返回值：
日期：	  
*/
static char * _set_fmtstr_Precison(char *FmtStr,BYTE *len)
{
	char *TempPtr,*ret;
	char Temp[4];
	int i;
	char Precision=6;		
	FmtStr++;	// =%
	// 分解出标志字符序列
	for(; *FmtStr<'0'; FmtStr++){} // + - * # .
	// 分解出数据的显示宽度
	for(; (*FmtStr<='9')&&(*FmtStr>='0'); FmtStr++){}// 0~9 
	// 分解出数据的显示精度
	if(*FmtStr == '.')
	{
		FmtStr++;
		TempPtr = (char *)FmtStr;
		ret = (char *)FmtStr;
		for(; *TempPtr<='9'&&*TempPtr>='0'; TempPtr++){}// 0~9 
		for(i=0; FmtStr<TempPtr; Temp[i]=*FmtStr++,i++){}
		Temp[i] = '\0';
		Precision = (u8)atoi(Temp);
	}
	else 
	{		
		ret = NULL;
	}
	return ret;	
}

/**************************************************************************
函数名称：_set_get_float_disp
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：取浮点数的的显示类型
输入参数：
输出参数：
返回值：
日期：	  
*/
static int _set_get_float_disp(void *pdat)
{
	int factor=0;
	
	float fdata=*((float*)pdat);
	
	if(fdata<0)
	{
		fdata=-fdata;
	}
	if(fdata>9999.5)
	{
		return 0;
	}
	else if(fdata>999.95)
	{
		factor=0;
	}
	else if(fdata>99.995)
	{
		factor=1;
	}
	else if(fdata>9.9995)
	{
		factor=2;
	}
	else
	{
		factor=3;
	}
	return factor;
}

/**************************************************************************
函数名称：_set_change_set
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：将整定值转换为要保存的值
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/

static void _set_change_set(const TSETTABLE *pSet,int num, int index)
{
	int i;
	for(i=0;i<num;i++)
	{
		if(_set_is_integer(pSet[i].wType))
		{
			long tt=m_SetBuf[i+index].tt;
			m_SetBuf[i+index].ff=tt;			
		}
	}	
}

/******************************************************************************
函数名称：	_set_check_set
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	检查设置是否在定值范围
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _set_check_set(const TSETTABLE *pSet,int num,SET_VALUE *setbuf)
{	
	int i, j=0;
	char tmpstr[24];

	// 检查浮点值是否在定值范围内
	for(i=0;i<num;i++)
	{
		if(pSet[i].wType==SETTYPE_IP)
			continue;  //  IP地址类型数据，不判断
		if(pSet[i].wType==SETTYPE_YMD)
			continue;  //  IP地址类型数据，不判断
		if(pSet[i].wType==SETTYPE_HMS)
			continue;  //  IP地址类型数据，不判断
		if(CheckFloatSet((void *)&setbuf[i].ff,pSet[i].fMax,pSet[i].fMin)>0)
			break;
	}	
	// 当某个定值不在范围内
	if(i<num)
	{
		rt_printf("%s, %0.3f,范围:%.0f~%.0f\r\n", pSet[i].szName, setbuf[i].ff, pSet[i].fMin,pSet[i].fMax);
		// 打印该定值名称
		strcpy(g_page_dis.str[j++],pSet[i].szName);

		// 打印定值范围
		if(_set_is_integer(pSet[i].wType))
		{
			sprintf(g_page_dis.str[j++],"范围:%.0f~%.0f",pSet[i].fMin,pSet[i].fMax);	
		}
		else
		{
			strcpy(g_page_dis.str[j],"范围");
			switch(_set_get_float_disp((void *)&pSet[i].fMin))
			{
				
			case 0:   //浮点数
				sprintf(tmpstr,"%.0f",pSet[i].fMin);	
				break;
			case 1:   //浮点数
				sprintf(tmpstr,"%.1f",pSet[i].fMin);	
				break;
			case 2:   //浮点数
				sprintf(tmpstr,"%.2f",pSet[i].fMin);	
				break;
			case 3:   //浮点数
				sprintf(tmpstr,"%.3f",pSet[i].fMin);	
				break;
			default:
				sprintf(tmpstr,"%.2f",pSet[i].fMin);	
				break;
			}
			strcat(g_page_dis.str[j],tmpstr);
			strcat(g_page_dis.str[j],"~");
			switch(_set_get_float_disp((void *)&pSet[i].fMax))
			{
			case 0:   //浮点数
				sprintf(tmpstr,"%.0f",pSet[i].fMax);	
				break;
			case 1:   //浮点数
				sprintf(tmpstr,"%.1f",pSet[i].fMax);	
				break;
			case 2:   //浮点数
				sprintf(tmpstr,"%.2f",pSet[i].fMax);	
				break;
			case 3:   //浮点数
				sprintf(tmpstr,"%.3f",pSet[i].fMax);	
				break;
			default:
				sprintf(tmpstr,"%.2f",pSet[i].fMax);	
				break;
			}
			strcat(g_page_dis.str[j],tmpstr);		
		}

		return FALSE;
	}
	return TRUE; 	
}


/******************************************************************************
函数名称：	_set_net_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	网卡类型参数初始化
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _set_net_init(void)
{
	int i;
	for(i=PARA_IP_104MASTER1; i<(PARA_IP_104MASTER4+1); i++)
	{
		g_netpara[i*4+0].tt = ((DWORD)m_SetBuf[i].tt>>24)&0xff;
		g_netpara[i*4+1].tt = ((DWORD)m_SetBuf[i].tt>>16)&0xff;
		g_netpara[i*4+2].tt = ((DWORD)m_SetBuf[i].tt>>8)&0xff;
		g_netpara[i*4+3].tt = (DWORD)m_SetBuf[i].tt&0xff;	
	}

	for(i=PARA_IP_NET1; i<(PARA_GATE_NET+1); i++)
	{
		g_netpara[i*4+0].tt = ((DWORD)m_SetBuf[i].tt>>24)&0xff;
		g_netpara[i*4+1].tt = ((DWORD)m_SetBuf[i].tt>>16)&0xff;
		g_netpara[i*4+2].tt = ((DWORD)m_SetBuf[i].tt>>8)&0xff;
		g_netpara[i*4+3].tt = (DWORD)m_SetBuf[i].tt&0xff;	
	}

	g_netpara[PARA_IP_SNTP*4+0].tt = ((DWORD)m_SetBuf[PARA_IP_SNTP].tt>>24)&0xff;
	g_netpara[PARA_IP_SNTP*4+1].tt = ((DWORD)m_SetBuf[PARA_IP_SNTP].tt>>16)&0xff;
	g_netpara[PARA_IP_SNTP*4+2].tt = ((DWORD)m_SetBuf[PARA_IP_SNTP].tt>>8)&0xff;
	g_netpara[PARA_IP_SNTP*4+3].tt = (DWORD)m_SetBuf[PARA_IP_SNTP].tt&0xff;	
	
	return 0;
}


/******************************************************************************
函数名称：	_set_time_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	时钟类型参数初始化
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _set_time_init(int set_no)
{
	struct timespec ts;
	struct rtc_time_t tTime;

	memset(&ts, 0, sizeof(ts));
	memset(&tTime, 0, sizeof(tTime));

	// 年月日
	ts.tv_sec = (long)m_SetBuf[set_no].tt;	
	timespec_to_rtc(ts,&tTime,1);

	g_timepara[0].tt = tTime.year;
	g_timepara[1].tt = tTime.month;
	g_timepara[2].tt = tTime.day;

	// 时分秒
	memset(&ts, 0, sizeof(ts));
	ts.tv_sec = (long)m_SetBuf[set_no+1].tt;
	timespec_to_rtchms(ts,&tTime,1);
	
	g_timepara[3].tt = tTime.hour;
	g_timepara[4].tt = tTime.min;
	g_timepara[5].tt = tTime.ms/1000;

	return 0;
}

/******************************************************************************
函数名称：	_set_net_save
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	网卡类型参数保存
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _set_net_save(void)
{
	int i;
	
	for(i=PARA_IP_104MASTER1; i<(PARA_IP_104MASTER4+1); i++)
	{
		m_SetBuf[i].tt = (u32)(g_netpara[i*4+0].tt<<24) | (g_netpara[i*4+1].tt<<16) | (g_netpara[i*4+2].tt<<8) | (g_netpara[i*4+3].tt);
	}

	for(i=PARA_IP_NET1; i<(PARA_GATE_NET+1); i++)
	{
		m_SetBuf[i].tt = (u32)(g_netpara[i*4+0].tt<<24) | (g_netpara[i*4+1].tt<<16) | (g_netpara[i*4+2].tt<<8) | (g_netpara[i*4+3].tt);
	}

	i = PARA_IP_SNTP;
	m_SetBuf[i].tt = (u32)(g_netpara[i*4+0].tt<<24) | (g_netpara[i*4+1].tt<<16) | (g_netpara[i*4+2].tt<<8) | (g_netpara[i*4+3].tt);

	return 0;
}

  
/******************************************************************************
函数名称：	_set_time_save
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	时钟类型参数保存
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static int _set_time_save(void)
{
	struct timespec ts;
	struct rtc_time_t tTime;

	memset(&ts, 0, sizeof(ts));
	memset(&tTime, 0, sizeof(tTime));

	tTime.year = g_timepara[0].tt;
	tTime.month = g_timepara[1].tt;
	tTime.day = g_timepara[2].tt;
	rtc_to_timespec(&tTime, &ts);
	m_SetBuf[PARA_BATBEGIN_YMD].tt = ts.tv_sec;
	
	memset(&ts, 0, sizeof(ts));
	memset(&tTime, 0, sizeof(tTime));
	tTime.hour = g_timepara[3].tt;
	tTime.min = g_timepara[4].tt;
	tTime.ms = g_timepara[5].tt;
	ts.tv_sec = mktimehms(tTime.hour, tTime.min, tTime.ms);
	m_SetBuf[PARA_BATBEGIN_HMS].tt = ts.tv_sec;

	return 0;
}

/******************************************************************************
函数名称：	_set_save_func
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-30
函数说明：	保存设置
参数说明：	无
返回值：  	成功返回1.
修改记录：	
*/
static int _set_save_func(u8 menu)
{
	u8 result = 0;
	int index;
	
	switch(menu)
	{
		case MENU_FIX:
		{
		    //do nothing

		}
		break;

		case MENU_FIX_PUB:
		{
			index = 0;
			_set_change_set(&tPubSetTable[0], PUB_SET_NUMBER, index);		
			if(!_set_check_set(&tPubSetTable[0], PUB_SET_NUMBER, m_SetBuf))
			{
				soe_record_opt(EV_SET_FAIL,0);
				result = -1;
				break;
			}
			else if(SaveSet(m_runsection,(void *)m_SetBuf))
			{
				soe_record_opt(EV_SET_OK,0);
				MakeRunSet(false); 
				rt_err_clr(ERR_CODE_SET,0);
				result = 1;
			}
			else
			{
				soe_record_opt(EV_SET_FAIL,0);
				result = -2;
				break;
			}
		}
		break;

		case MENU_GLBH:
		case MENU_LXBH:
		case MENU_JDBH:
		case MENU_RECLOSE:
		case MENU_BH_STATUS:
		case MENU_DLYX:
		case MENU_HJS:
		{
		    u8  sw_index =0;

		    if(menu == MENU_GLBH)
		        sw_index = class_GLBH.sw_idx;
		    else if(menu == MENU_LXBH)
		        sw_index = class_LXBH.sw_idx;
            else if(menu == MENU_JDBH)
                sw_index = class_JDBH.sw_idx;
            else if(menu == MENU_RECLOSE)
                sw_index = class_reclose.sw_idx;
            else if(menu == MENU_BH_STATUS)
                sw_index = class_BH_sts.sw_idx;
			else if(menu == MENU_DLYX)
                sw_index = class_DLYX.sw_idx;
			else if(menu == MENU_HJS)
                sw_index = class_HJS.sw_idx;
            else
                sw_index = 0;

		    //------------
			index = PUB_SET_NUMBER + sw_index *SW_SET_NUMBER;
			_set_change_set(&tSwSetTable[0], SW_SET_NUMBER, index);		
			if(!_set_check_set(&tSwSetTable[0], SW_SET_NUMBER, &m_SetBuf[index]))
			{
				soe_record_opt(EV_SET_FAIL,0);
				result = -1;
				break;
			}
			else if(SaveSet(m_runsection,(void *)m_SetBuf))
			{
				soe_record_opt(EV_SET_OK,0);
				MakeRunSet(false); 
				rt_err_clr(ERR_CODE_SET,0);
				result = 1;
			}
			else
			{
				soe_record_opt(EV_SET_FAIL,0);
				result = -2;
				break;
			}
		}
		break;
	
		case MENU_PARA:
		{
			index = 0;
			_set_net_save();
			_set_time_save();
			_set_change_set(&tEquipParaTable[0], EQUIP_PARA_NUMBER, index);		
			if(!_set_check_set(&tEquipParaTable[0], EQUIP_PARA_NUMBER, m_SetBuf))
			{
				soe_record_opt(EV_EQUPARA_FAIL,0);
				result = -1;
			}
			else if(SavePara((void *)m_SetBuf,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);
				result = 1;
			}
			else
			{
				soe_record_opt(EV_EQUPARA_FAIL,0);
				result = -2;
			}
		}
		break;

        case MENU_FAULT_RESET:
        {
            index = 0;
            _set_change_set(&tEquipParaTable[0], EQUIP_PARA_NUMBER, index);
            if(!_set_check_set(&tEquipParaTable[0], EQUIP_PARA_NUMBER, m_SetBuf))
            {
                soe_record_opt(EV_EQUPARA_FAIL,0);
                result = -1;
            }
            else if(SavePara((void *)m_SetBuf,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);
                result = 1;
            }
            else
            {
                soe_record_opt(EV_EQUPARA_FAIL,0);
                result = -2;
            }
        }
        break;

		case  MENU_RUN_PARA:
		{
            int ret;
            index = 0;

            ret = _save_rmt_para_val(g_rmt_para_disp.sw_num);
            if(ret==0)  //Save OK
                result = 1;
            else
                result = -1;

            rt_free(run_para_pick_set);
            rt_free(run_para_setbuf);
            run_para_pick_set = NULL;
            run_para_setbuf   = NULL;
		}
		break;

		case MENU_INFIX:
			index = 0;
			_set_change_set(&tCstSetTable[0],CSTSET_NUMBER, index);	
			if(!_set_check_set(&tCstSetTable[0],CSTSET_NUMBER,m_SetBuf))
			{
				soe_record_opt(EV_CSTSET_FAIL,0);
				result = -1;
			}
			else if(SavePara((void *)m_SetBuf,EEP_CSTSET_ADDR,CSTSET_NUMBER,&tCstSetTable[0]))
			{
				soe_record_opt(EV_CSTSET_OK,0);  // 内部定值整定成功
				MakeRunSet(false); 			// 将当前运行定值区转换为运行定值区
				rt_err_clr(ERR_CODE_SET_IN,0);	
				result = 1;
			}
			else
			{
				soe_record_opt(EV_CSTSET_FAIL,0);  
				result = -2;
			}
		break;

		case MENU_TIMESET:
		{
			TIME mt;
			index = 0;
			_set_change_set(&tTimeTable[0],TIME_SET_NUMBER, index);
			mt.year=m_SetBuf[TIME_YEAR].ff;
			mt.month=m_SetBuf[TIME_MONTH].ff;
			mt.day=m_SetBuf[TIME_DAY].ff;
			mt.hour=m_SetBuf[TIME_HOUR].ff;
			mt.min=m_SetBuf[TIME_MINUTE].ff;
			mt.ms=(WORD)m_SetBuf[TIME_SECOND].ff*1000;
			if(!_set_check_set(&tTimeTable[0],TIME_SET_NUMBER,m_SetBuf))
			{
				result = -1;
			}
			else if(sys_time_set(&mt) == 0)
			{
				result = 1;
			}
			else
			{
				result = -2;
			}
		}
		break;

		case MENU_CODE:
		{
			index = 0;
			_set_change_set(&tCodeTable[0],CODE_SET_NUMBER, index);
			if(!_set_check_set(&tCodeTable[0],CODE_SET_NUMBER,m_SetBuf))
			{
				result = -1;
			}
			else if(m_SetBuf[0].ff==INTER_PASSWORD)
			{
				rt_printf("新密码无效");
				result = -1;
			}
			else if (SavePassword((DWORD )m_SetBuf[0].ff))
			{
				tRunPara.wPassword=ReadPassword();				
				result = 1;
			}
			else
			{
				result = -2;
			}

		}
		break;
	}

	return result;
}
/**************************************************************************
函数名称：_password_check
函数版本：1.00 
作    者：   
创建日期：2008.9.1     
函数说明：检查密码是否正确
输入参数：
输出参数：
返回值：
日期：	  
*/ 
static int _password_check(u8 code)
{
    u32 password;
	u8  mater_menu;

	// 将设置值转为数值
	_set_change_set(&tPasswordTable[0], 1, 0);

	// 取出当前输入的密码
	password = m_SetBuf[0].ff;

	if (((password == tRunPara.wPassword) && (code&0x01))
		|| ((password == PASS_WORD_SUPER) && (code&0x02)))
	{
		// 进入次级菜单
		g_page_cur = page_table[g_slavemenu];
		check_cur_wnd_item();
	}
	else 
	{
		// 保留上级菜单
		mater_menu = g_page_cur.menu_m;
		
		// 进入密码错误页面
		g_page_cur = page_table[MENU_PASSERR];		
		check_cur_wnd_item();
		g_page_cur.menu_m = mater_menu;
	}

	// 初始化部分未初始化的页面
	_enter_menu_init();

	return 0;
}

int _reset_page_dis(void)
{
	memset (g_page_dis.str, 0, 10*18);

	return 0;
}

/**************************************************************************
函数名称：_blk_light_app
函数版本：1.00 
作    者：   
创建日期：2008.9.1     
函数说明: 液晶背光自动关闭
输入参数：
输出参数：
返回值：
日期：	  
*/ 
int _blk_light_app(u8 key)
{
	static unsigned long us0, us1;
	static int flag=TRUE, flag1=TRUE;

	// 初始化定时器
	if (flag)
	{
		us0 = ustimer_get_origin();
		flag = FALSE;
	}
	// 5分钟无按键，关背光，重新初始化定时器
	if((ustimer_get_duration(us0) >= tRunPara.dLightTime*USTIMER_SEC)
		&& (key == NO_KEY)
		&& (g_tLcdComm.tLight.light == LIGHT_ON)
		&& (tRunPara.dLightTime!=0))
	{
		g_tLcdComm.tLight.light = LIGHT_OFF;
		g_tLcdComm.tLight.flag = true;
		query_page_other_proc();
		while(g_page_cur.menu_cur != MENU_MAIN)
		{
			
			_esc_key_menu();
			Add_Clear_Screen();
			reset_update_flag();
		}
		flag = TRUE;
	}

	// 有按键，亮背光，清定时器
	if (key != NO_KEY)
	{
		g_tLcdComm.tLight.light = LIGHT_ON;
		g_tLcdComm.tLight.flag = true;
		flag = TRUE;
	}
	// 无按键，无背光，清定时器
	else if (g_tLcdComm.tLight.light == LIGHT_OFF)
	{
		flag = TRUE;
	}

	// 初始化定时器
	if (flag1)
	{
		us1 = ustimer_get_origin();
		flag1 = FALSE;
	}
	
	#if 0
	// 5分钟无按键，关背光，重新初始化定时器
	if((ustimer_get_duration(us1) >= 300*USTIMER_SEC)
		&& (key == NO_KEY))
	{
		while(g_page_cur.menu_cur != MENU_MAIN)
		{
			_esc_key_menu();
			Add_Clear_Screen();
			reset_update_flag();
		}
		flag1 = TRUE;
	}
	#endif
	// 有按键，亮背光，清定时器
	if (key != NO_KEY)
	{
		flag1 = TRUE;
	}
	return 0;
}

/**************************************************************************
函数名称：_save_resulr_autoback
函数版本：1.00 
作    者：EW   
创建日期：2023.11.15     
函数说明: 保存成功界面自动返回，失败时不自动返回
输入参数：
输出参数：
返回值：
日期：	  
*/ 
static void _save_result_autoback(void)
{
	if(g_item_update.autoback)
	{
		if(dTCounter-g_item_update.autoback_dly > (T_1s*1))
		{
			g_item_update.autoback = 0;
			// 返回上一级菜单
			g_page_cur = page_table[g_page_cur.menu_m];
			check_cur_wnd_item();
			Add_Clear_Screen();
		}
	}
}

/**************************************************************************
函数名称：_rmt_pair_dely
函数版本：1.00 
作    者：   
创建日期：2008.9.1     
函数说明: 遥控器配对界面自动返回
输入参数：
输出参数：
返回值：
日期：	  
*/ 
int _rmt_pair_dely(u8 key)
{
	if (rmtpair_dely[0][0])
	{
		if(ustimer_get_duration(rmtpair_dely[0][1]) >= 30*USTIMER_SEC)
		{
			rmtpair_dely[0][0] = 0;
			return HA_KEY_ESC;
		}
	}

	if (rmtpair_dely[1][0])
	{
		if(ustimer_get_duration(rmtpair_dely[1][1]) >= 10*USTIMER_SEC)
		{
			rmtpair_dely[1][0] = 0;
			return HA_KEY_ESC;
		}
	}

	return key;
}

/**************************************************************************
函数名称：_gprs_disp_update
函数版本：1.00 
作    者：   
创建日期：2008.9.1     
函数说明: GPRS信息自动刷新
输入参数：
输出参数：
返回值：
日期：	  
*/ 
static int _gprs_disp_update(void)
{
	if (gprs_info_up[0])
	{
		if(ustimer_get_duration(gprs_info_up[1]) >= 3*USTIMER_SEC)
		{
			_info_gprs_init();
			Add_Clear_Screen();
			gprs_info_up[1] = ustimer_get_origin();
			return 0;
		}		
	}

	return -1;
}
//query_page的其它处理.当进入query_page时，如果这时面板重启，则应处理一些特殊的变量
//比如		rmtpair_dely，rmtpair_dely，gprs_info_up
//如果不处理这些的话，会导致页面的实体数量item_num产生错误的值，从而使得界面显示凌乱
void query_page_other_proc(void)
{

	if (rmtpair_dely[0][0])
	{
		rmtpair_dely[0][0] = 0;
	}
	if (rmtpair_dely[1][0])
	{
		rmtpair_dely[1][0] = 0;
	}
	if (gprs_info_up[0])
	{
		gprs_info_up[0] = 0;
	}
	//Add_Clear_Screen();
}

int mmd_get_gprs_info(void) 
{

	BYTE *pd=tGprsInf.data;
	int num=0;
	if(!tGprsInf.bInf)return 0;
	tGprsInf.bInf=false;

	if(pd[0]==1)
	{
		strcpy(strGprsInf[num++],"模块状态 :正常");
	}
	else
	{
		strcpy(strGprsInf[num++],"模块状态 :异常");

	}

	if(pd[1]==1)
	{
		strcpy(strGprsInf[num++],"SIM卡状态:正常");
	}
	else
	{
		strcpy(strGprsInf[num++],"SIM卡状态:异常");

	}

	if(pd[2]==1)
	{
		strcpy(strGprsInf[num++],"PPP拨号  :正常");
	}
	else
	{
		strcpy(strGprsInf[num++],"PPP拨号  :异常");

	}

	sprintf(strGprsInf[num++],"信号强度 :%2d",pd[9]);
	sprintf(strGprsInf[num++],"IP:%d.%d.%d.%d",pd[19],pd[20],pd[21],pd[22]);	
	


	if(pd[10]==1)
	{
		strcpy(strGprsInf[num++],"频段:900MHz");
	}
	else
	{
		strcpy(strGprsInf[num++],"频段:1800MHz(其他)");

	}

	sprintf(strGprsInf[num++],"ICMP延时:%d ms",(pd[24]|(pd[23]<<8)));

	sprintf(strGprsInf[num++],"上传字节数:%d",(pd[34]|(pd[33]<<8)|(pd[32]<<16)|(pd[31]<<24)));
	sprintf(strGprsInf[num++],"下载字节数:%d",(pd[38]|(pd[37]<<8)|(pd[36]<<16)|(pd[35]<<24)));
	

	g_gprs_info_num = num;

	return num;
}
/*------------------------------ 测试函数 -------------------------------------
*/