
#include "head.h"
#include "rt_file.h"

//#define FILE_INIT_PRINT	

const char *history_file_name[][2]=
{
	{"soe.msg",				"soe.xml"},
	{"co.msg",				"co.xml"},
	{"fixptXXXXXXXX.msg",	"fixptXXXXXXXX.xml"},
	{"exvXXXXXXXX.msg",		"exvXXXXXXXX.xml"},
	{"frzXXXXXXXX.msg",		"frzXXXXXXXX.xml"},
	{"flowrev.msg",			"flowrev.xml"},
	{"ulog.msg",			"ulog.xml"},
};


const char *log_str_list[]=
{
	"Terminal restart record",												//类型编号(01)：终端重启记录
	"Channel connection establishment and disconnection record",			//类型编号(02)：通道连接建立与断开记录
	"Communication process anomaly record",									//类型编号(03)：通信过程异常记录
	"Abnormal self-check record of plugins and components in the device",	//类型编号(04)：装置内部各类插件、元件异常自检记录				
	"Internal software process abnormal record",							//类型编号(05)：装置内部软件进程异常记录
	"Main power on/off and abnormal voltage record",						//类型编号(06)：主电源通断及电压异常记录
	"Auxiliary power on/off, activation and abnormal voltage record",		//类型编号(07)：备用电源通断、活化及电压异常记录
	"Abnormal recording of control loop disconnection",						//类型编号(08)：控制回路断线异常记录
	"Switch position abnormal record",										//类型编号(09)：开关位置异常记录
	"Terminal parameter modification record",								//类型编号(10)：终端参数修改记录
	"Software version upgrade record",										//类型编号(11)：软件版本升级记录
};


char *p_his_file[HS_FILE_NUM];



struct history_rcd_file event_rcd_file[2];	//事件记录，包括SOE及操作记录
struct history_rcd_file fixpt_rcd_file[FIXPT_FILE_NUM_MAX];
struct history_rcd_file exv_rcd_file[EXV_FILE_NUM_MAX];
struct history_rcd_file exv_txt_file[EXV_FILE_NUM_MAX];

struct history_rcd_file frz_rcd_file[FRZ_FILE_NUM_MAX];
struct history_rcd_file flowrev_rcd_file;
struct history_rcd_file log_rcd_file;		
LOG_FLAG  log_flag;
bool hs_file_init_flag=false;






struct exv_rcd_t 		exv_rcd;
struct exv_rcd_t 		exv_rcd_dd;
struct fixpt_rcd_t 		fixpt_rcd;
struct frz_rcd_t 		frz_rcd;
struct flowrev_rcd_t 	flowrev_rcd;


struct rcd_file_info 	soe_file_info;
struct rcd_file_info 	yk_file_info;
struct rcd_file_info 	fixpt_file_info;
struct rcd_file_info	exv_file_info;
struct rcd_file_info	exv_txt_info;

struct rcd_file_info	frz_file_info;
struct rcd_file_info	flowrev_file_info;
struct rcd_file_info	log_file_info;


bool histrory_file_set=0;
bool b_hisfile_format=0;
struct log_poll log_st; 

fileInfo soeList;		//SOE事件记录
fileInfo coList;		//遥控操作记录

fileInfo flowrevList;	//潮流反向记录
fileInfo logList;		//日志记录



#if defined (CPU_FUXI)
//noted by sunxi: 20220718 函数rt_file_deldir本应在rt_file定义的。但是有的冷火没有在rt_file里定义，只能在这里定义
//最终，应该要把函数rt_file_deldir统一放回在rt_file定义。
int rt_file_deldir(char *pathname)
{
	int ret;
	
	char *argv[] = {"/bin/rm", "-rf", pathname , NULL };
	char *envp[] = { NULL };
	
	ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);

//	rt_printf("del=%d\r\n\r\n",ret);

	return ret;
}
#endif


int is_chinese(const char *str)
{
	char c;
	while(1)
	{
		c = *str++;

		if(c==0)
			break;
		if((c&0x80)&&(*str&0x80))
			return 1;
	}

	return 0;
}


int hs_read_iec_crc(void)
{
	u16 iec_crc;
		
	if (e2prom_read(IECTABLE_ADDR,(u8*)&iec_crc,2) != 0)
		return -1;

	if(g_crc_rectable!=iec_crc)
		return -2;

	return 0;
		
}

bool hs_write_iec_crc(void)
{
	
	if(e2prom_write(IECTABLE_ADDR, (u8*)&g_crc_rectable, 2)!=0)
		return false;
	else
		return true;

}


int del_history_file(u8 type)
{
	struct file * 	handle;
	char dir_name[64]={0};

	if(type>=HS_FILE_NUM)
		return -1;
	
	if(type == HS_FILE_SOE)
	{
		sprintf(dir_name,"%s%s",HF_SOE_101_DIR,HF_SOE_FILENAME);
	}
	else if(type == HS_FILE_CO)
	{
		sprintf(dir_name,"%s%s",HF_CO_101_DIR,HF_YK_FILENAME);
	}
	else if(type == HS_FILE_FLOWREV)
	{
		sprintf(dir_name,"%s%s",HF_FLOWREV_101_DIR,HF_FLOWREV_FILENAME);
	}
	else if(type == HS_FILE_LOG)
	{
		sprintf(dir_name,"%s%s",HF_LOG_101_DIR,HF_LOG_FILENAME);
	}

	handle = rt_file_open(dir_name,O_CREAT|O_RDWR,0);
	
	if(IS_ERR(handle))
	{	
		return -2;
	}
	
	rt_file_close(handle,0);
	if(rt_file_del(dir_name))	
		return -3;

	return 0;
}


/******************************************************************************
函数名称：	init_hs_file_soe
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	上电初始化事件记录文件，读取对应目录下记录文件，
			未创建文件，则创建新的事件记录文件
参数说明：	
			
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int init_hs_file_event(u8 type)
{
	struct dir_file_struct * p_file;
	struct rtc_time_t tm;	
	int file_num=0;
	int ret=0;
	
	if(type>HS_FILE_CO)
		return -1;

	ret = del_history_file(type);
	if(!ret)
	{
		ret = create_event_rcd_file(type);
		
	}
	
	memset(&event_rcd_file[type],0,sizeof(struct history_rcd_file));

	if(type == HS_FILE_SOE)
	{
		//获取SOE记录的文件信息
		p_file = hf_get_dir_file(HF_SOE_101_DIR,&file_num);
		memcpy(event_rcd_file[HS_FILE_SOE].name,HF_SOE_FILENAME,strlen(HF_SOE_FILENAME));
		
	}
	else if(type == HS_FILE_CO)
	{
		p_file = hf_get_dir_file(HF_CO_101_DIR,&file_num);
		memcpy(event_rcd_file[HS_FILE_CO].name,HF_YK_FILENAME,strlen(HF_YK_FILENAME));
	}

	if(p_file)
	{	
	#ifdef FILE_INIT_PRINT
		rt_printf("\r\n------------------------%s------------------------\r\n",(type == HS_FILE_SOE)?HF_SOE_FILENAME:HF_YK_FILENAME);
		rt_printf("文件个数:%d\r\n", file_num);
		rt_printf("文件大小:%d\r\n", p_file->file_size);
		timespec_to_rtc(p_file->file_time, &tm, 0);
		rt_printf("创建时间:20%02hu-%02hu-%02hu %02hu:%02hu:%02hu \r\n",tm.year,tm.month,tm.day,tm.hour,tm.min,tm.ms/1000);
	#endif 
		event_rcd_file[type].len = p_file->file_size;
		timespec_to_rtc(p_file->file_time, &tm, 0);		
		event_rcd_file[type].create_time = tm;
		rt_free(p_file);
		//文件名固定，为soe
		strcpy(event_rcd_file[type].name,p_file->name);
	}

	return ret;
	
}





/******************************************************************************
函数名称：	init_hs_file_exv
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	上电初始化极值历史记录文件，读取对应目录下极值记录文件，
			未创建文件，则创建新的极值记录文件
参数说明：	
			
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int init_hs_file_exv(bool b_new)
{
	struct dir_file_struct *p_file=NULL;
	struct rtc_time_t tm;
	struct timespec ts;
	int i,j;
	int file_num=0,file_n=0;
	int ret=0;
	bool exv_make_flag = false;
	char tme_cn[3]={0};
	char dir_name[64]={0};
	
	memset(exv_rcd_file,0,sizeof(exv_rcd_file));
	memset(&exv_file_info,0,sizeof(struct rcd_file_info));
	memset(&exv_rcd,0,sizeof(struct exv_rcd_t));

	exv_rcd.ac_num =g_table_head->ac_num;


	if(!b_new)
	{
		//获取极值记录的文件信息
		p_file = hf_get_dir_file(HF_EXV_101_DIR,&file_num);
	}

	if(p_file)
	{
	#ifdef FILE_INIT_PRINT
		rt_printf("\r\n------------------------%s------------------------\r\n",HF_EXV_FILENAME);
		rt_printf("文件个数:%d\r\n", file_num);

		for(i=0;i<file_num;i++)
		{
			rt_printf("文件名称(%d):%s\r\n", i+1,p_file[i].name);
			rt_printf("文件大小(%d):%d\r\n", i+1, p_file[i].file_size);
			timespec_to_rtc(p_file[i].file_time, &tm, 0);
			rt_printf("创建时间(%d):20%02hu-%02hu-%02hu %02hu:%02hu:%02hu \r\n", i+1,tm.year,tm.month,tm.day,tm.hour,tm.min,tm.ms/1000);
		}
	#endif

		
		if(file_num>EXV_FILE_NUM_MAX)
		{
			//删除最初的多余的文件
			for(j=0;j<file_num-EXV_FILE_NUM_MAX;j++)
			{
				sprintf(dir_name,"%s%s",HF_EXV_101_DIR,p_file[j].name);
				if(rt_file_del(dir_name))
				{
					exv_file_info.b_err = true;
					rt_free(p_file);
					return -1;
				}

			}
		}

		
		file_n = (file_num>EXV_FILE_NUM_MAX)?EXV_FILE_NUM_MAX:file_num;
		
		for(i=0;i<file_n;i++)
		{
			//获取文件名，极值文件的定义为 :exvXXXXXXXX.msg	表示为:文件前缀+年月日,	如:exv20170212
			strcpy(exv_rcd_file[i].name,p_file[file_num -file_n + i].name);

			memcpy(tme_cn,&exv_rcd_file[i].name[5],2);
			exv_rcd_file[i].create_time.year = atoi(tme_cn);

			memcpy(tme_cn,&exv_rcd_file[i].name[7],2);
			exv_rcd_file[i].create_time.month = atoi(tme_cn);

			memcpy(tme_cn,&exv_rcd_file[i].name[9],2);
			exv_rcd_file[i].create_time.day = atoi(tme_cn);
			
			exv_rcd_file[i].len = p_file[file_num -file_n + i].file_size;
		}
		
		exv_file_info.file_num = file_n;
		rt_free(p_file);
		exv_make_flag = true;
	}

	//获取当前时间
	clk_time_get(&ts);
	timespec_to_rtc(ts,&tm,0);

	//已经创建了
	if(exv_make_flag)
	{
		for(i=0;i<file_n;i++)
		{		
			ret = read_exv_rcd_file(i);
			if(ret<0)
				rt_printf("初始化极值记录文件,i = %d, ret=%d\r\n", i,ret);	
		}


		if(file_n>=1)
		{
			//最后一个极值文件和当前时间不是同一天,
			if(exv_rcd_file[file_n-1].create_time.day!=tm.day)
			{
				get_exv_rcd_data(tm, true);
				exv_rcd_file_deal(tm);
			}
			else 	//为同一天，取出极值数据，不去创建文件，
			{
				acquire_exv_data(file_n-1);	//读取最后一天的极值记录数据

				get_exv_rcd_data(tm, true);
					//创建新的一天的极值记录文件
				exv_rcd_file_deal(tm);
				
			}
		}
	}
	else		//还未创建任何极值文件
	{
		get_exv_rcd_data(tm, true);

		if((ret = create_exv_rcd_file(&exv_file_info))!= 0)	
		{
			return -2; ;
		}
	}

	return ret;	
}



/******************************************************************************
函数名称：	init_hs_file_fixpt
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	上电初始化定点历史记录文件，读取对应目录下定点记录文件，
			未创建文件，则创建新的定点记录文件
参数说明：	
			
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int init_hs_file_fixpt(bool b_new)
{
	struct dir_file_struct * p_file=NULL;
	struct rtc_time_t tm;	
	struct timespec ts;
	int i,j,ret=0;
	int file_num=0,file_n=0;
	bool fixpt_make_flag = false;
	char tme_cn[3]={0};
	char dir_name[64]={0};
	
	memset(&fixpt_file_info,0,sizeof(struct rcd_file_info));
	memset(fixpt_rcd_file,0,sizeof(fixpt_rcd_file));
	memset(&fixpt_rcd,0,sizeof(struct fixpt_rcd_t));

	//获取定点记录的文件信息
	if(!b_new)
	{
		p_file = hf_get_dir_file(HF_FIXPT_101_DIR,&file_num);
	}

	if(p_file)
	{
		#ifdef FILE_INIT_PRINT
		rt_printf("\r\n------------------------%s------------------------\r\n",HF_FIXPT_FILENAME);
		rt_printf("文件个数:%d\r\n", file_num);

		for(i=0;i<file_num;i++)
		{	
			rt_printf("文件名称(%d):%s\r\n", i+1,p_file[i].name);
			rt_printf("文件大小(%d):%d\r\n", i+1, p_file[i].file_size);
			timespec_to_rtc(p_file[i].file_time, &tm, 0);
			rt_printf("创建时间(%d):20%02hu-%02hu-%02hu %02hu:%02hu:%02hu \r\n", i+1,tm.year,tm.month,tm.day,tm.hour,tm.min,tm.ms/1000);
		}
		#endif

		if(file_num > FIXPT_FILE_NUM_MAX)
		{
			//删除最初的多余的文件
			for(j=0;j<file_num-FIXPT_FILE_NUM_MAX;j++)
			{
				sprintf(dir_name,"%s%s",HF_FIXPT_101_DIR,p_file[j].name);
				if(rt_file_del(dir_name))
				{
					fixpt_file_info.b_err = true;
					rt_free(p_file);
					return -1;
				}

			}
		}

		file_n = (file_num>FIXPT_FILE_NUM_MAX)?FIXPT_FILE_NUM_MAX:file_num;

		for(i=0;i<file_n;i++)
		{
			//获取文件名，定点文件的定义为 :fixptxxxxxxxx.msg	表示为:文件前缀+年月日,	如:fixpt20160810.dat
			strcpy(fixpt_rcd_file[i].name,p_file[file_num -file_n + i].name);

			memcpy(tme_cn,&fixpt_rcd_file[i].name[7],2);
			fixpt_rcd_file[i].create_time.year = atoi(tme_cn);

			memcpy(tme_cn,&fixpt_rcd_file[i].name[9],2);
			fixpt_rcd_file[i].create_time.month = atoi(tme_cn);

			memcpy(tme_cn,&fixpt_rcd_file[i].name[11],2);
			fixpt_rcd_file[i].create_time.day = atoi(tme_cn);
		
			fixpt_rcd_file[i].len = p_file[file_num -file_n + i].file_size;
		}

		fixpt_file_info.file_num = file_n;
		
		rt_free(p_file);
		fixpt_make_flag = true;
		
	}

	//获取当前时间
	clk_time_get(&ts);
	timespec_to_rtc(ts,&tm,0);
	get_fixpt_rcd_data(tm);	

	if(fixpt_make_flag)
	{
		for(i=0;i<file_n;i++)
		{
			u16 node_n;
			ret = read_fixpt_rcd_file(i,&node_n);

			if(ret<0)
				rt_printf("初始化定点记录文件,i=%d, ret=%d,part_id=%d\r\n", i,ret,node_n);

			if(ret != 0)
				ret = -1;
		}

		if(file_n>=1)
		{
			//最后一个定点文件和当前时间为不同天,去创建文件
			if(fixpt_rcd_file[file_n-1].create_time.day!=tm.day)
			{
				if(fixpt_rcd_file_deal(tm)!=0)
					ret = -2;
			}
			else	
			{
				//如果最后一个文件和当天为同一天，则获取最后一个文件节点信息，
				//并从当前节点开始添加数据，直到加满当天向第二天时间跨度为止，
				//且如果最后节点数超过96，则不更新数据

				ret = read_fixpt_rcd_file(file_n-1,&fixpt_file_info.part_id);

				if(ret !=0)
					ret = -3;
			}
			
		}
	
	}
	else
	{
		if(create_fixpt_rcd_file()!= 0)	
			ret = -4;	
	}

	return ret;
	
}



int  init_hs_file_frz(bool b_new)
{
	struct dir_file_struct * p_file=NULL;
	struct rtc_time_t tm;	
	struct timespec ts;
	int i,j;
	char tme_cn[3]={0};
	char dir_name[64]={0};
	
	int file_num=0,file_n=0;
	int ret=0;
	bool frz_make_flag =false;

	memset(&frz_file_info,0,sizeof(struct rcd_file_info));
	memset(frz_rcd_file,0,sizeof(frz_rcd_file));
	memset(&frz_rcd,0,sizeof(struct frz_rcd_t));

	if(!b_new)
	{
		//获取日冻结电能量记录的文件信息
		p_file = hf_get_dir_file(HF_FRZ_101_DIR,&file_num);
	}

	
	if(p_file)
	{
		#ifdef FILE_INIT_PRINT
		
			rt_printf("\r\n------------------------%s------------------------\r\n",HF_FRZ_FILENAME);
			rt_printf("文件个数:%d\r\n", file_num);

			for(i=0;i<file_num;i++)
			{	
				rt_printf("文件名称(%d):%s\r\n", i+1,p_file[i].name);
				rt_printf("文件大小(%d):%d\r\n", i+1, p_file[i].file_size);
				timespec_to_rtc(p_file[i].file_time, &tm, 0);
				rt_printf("创建时间(%d):20%02hu-%02hu-%02hu %02hu:%02hu:%02hu \r\n", i+1,tm.year,tm.month,tm.day,tm.hour,tm.min,tm.ms/1000);
			}
		
		#endif

		if(file_num>FRZ_FILE_NUM_MAX)
		{
			//删除最初的多余的文件
			for(j=0;j<file_num-FRZ_FILE_NUM_MAX;j++)
			{
				sprintf(dir_name,"%s%s",HF_FRZ_101_DIR,p_file[j].name);
				if(rt_file_del(dir_name))
				{
					frz_file_info.b_err = true;
					rt_free(p_file);
					
					return -1;
				}

			}
		}

		file_n = (file_num>FRZ_FILE_NUM_MAX)?FRZ_FILE_NUM_MAX:file_num;
		
		for(i=0;i<file_n;i++)
		{	
			//获取文件名，定点文件的定义为 :frzXXXXXXXX	表示为:文件前缀+年月日,	如:frz20160810
			strcpy(frz_rcd_file[i].name,p_file[file_num -file_n + i].name);

			memcpy(tme_cn,&frz_rcd_file[i].name[5],2);
			frz_rcd_file[i].create_time.year = atoi(tme_cn);

			memcpy(tme_cn,&frz_rcd_file[i].name[7],2);
			frz_rcd_file[i].create_time.month = atoi(tme_cn);

			memcpy(tme_cn,&frz_rcd_file[i].name[9],2);
			frz_rcd_file[i].create_time.day = atoi(tme_cn);
			
			frz_rcd_file[i].len = p_file[file_num -file_n + i].file_size;
		}

		frz_file_info.file_num = file_n;
		rt_free(p_file);
		frz_make_flag = true;

	}
	
	//获取当前时间
	clk_time_get(&ts);
	timespec_to_rtc(ts,&tm,0);
	get_frz_rcd_data(tm);	
	

	if(frz_make_flag)
	{
		for(i=0;i<file_n;i++)
		{
			ret = read_frz_rcd_file(i,&frz_file_info.part_id);

			if(ret<0)
				rt_printf("初始化日冻结电能量记录文件,i = %d, ret=%d,part_id=%d\r\n", i,ret,frz_file_info.part_id);

			if(ret != 0)
				ret = -2;
		}

		if(file_n>=1)
		{
			//最后一个定点文件和当前时间为不同天,去创建文件
			if(frz_rcd_file[file_n-1].create_time.day!=tm.day)
			{
				if(frz_rcd_file_deal(tm)!=0)
					ret = -3;
			}
			else	
			{
				//如果最后一个文件和当天为同一天，则获取最后一个文件节点信息，
				//并从当前节点开始添加数据，直到加满当天向第二天时间跨度为止，
				//且如果最后节点数超过96，则不更新数据
				ret = read_frz_rcd_file(file_n-1,&frz_file_info.part_id);

				if(ret !=0)
					ret = -4;
			}

		}
		

	}
	else
	{
		
		if(create_frz_rcd_file()!= 0)	
			ret = -5;
	}

	return ret;

}

int init_hs_file_flowrev(bool b_new)
{
	struct dir_file_struct *p_file=NULL;
	struct rtc_time_t tm;	
	struct timespec ts;
	
	int file_num=0;
	int ret=0;
	bool flowrev_make_flag=false;

	ret = del_history_file(HS_FILE_FLOWREV);
	if(!ret)
	{
		ret = create_flowrev_rcd_file();
	}

	memset(&flowrev_file_info,0,sizeof(struct rcd_file_info));
	memset(&flowrev_rcd_file,0,sizeof(flowrev_rcd_file));
	memset(&flowrev_rcd,0,sizeof(struct flowrev_rcd_t));

	if(!b_new)
	{
		//获取日冻结电能量记录的文件信息
		p_file = hf_get_dir_file(HF_FLOWREV_101_DIR,&file_num);
	}

	if(p_file)
	{
	#ifdef FILE_INIT_PRINT
		int i;		
		rt_printf("\r\n------------------------%s------------------------\r\n",HF_FLOWREV_FILENAME);
		rt_printf("文件个数:%d\r\n", file_num);

		for(i=0;i<file_num;i++)
		{
			rt_printf("文件名称(%d):%s\r\n", i+1,p_file[i].name);
			rt_printf("文件大小(%d):%d\r\n", i+1, p_file[i].file_size);
			timespec_to_rtc(p_file[i].file_time, &tm, 0);
			rt_printf("创建时间(%d):20%02hu-%02hu-%02hu %02hu:%02hu:%02hu \r\n", i+1,tm.year,tm.month,tm.day,tm.hour,tm.min,tm.ms/1000);
		}
	#endif

		//获取文件名，定点文件的定义为 :flowrevXXXXXXXX	表示为:文件前缀+年月日,	如:flowrev20160810
		strcpy(flowrev_rcd_file.name,p_file->name);
		timespec_to_rtc(p_file->file_time, &flowrev_rcd_file.create_time, 0);
		flowrev_rcd_file.len = p_file->file_size;
		flowrev_file_info.file_num = file_num;

		rt_free(p_file);

		flowrev_make_flag = true;

	}

	//获取当前时间
	clk_time_get(&ts);
	timespec_to_rtc(ts,&tm,0);

	if(flowrev_make_flag)
	{
		ret = read_flowrev_rcd_file();
		if(ret<0)
			rt_printf("初始化功率反向电能量冻结值记录文件, ret=%d,part_id=%d\r\n", ret,flowrev_file_info.part_id);

		if(ret != 0)
			ret = -1;

	}
	else
	{
		if(create_flowrev_rcd_file()!= 0)	
			ret = -2;
	}

	return ret;
}


int init_hs_file_log(void)
{	
	struct dir_file_struct *p_file;
	struct rtc_time_t tm;	
	
	int i;
	int file_num=0;
	int ret=0;

	ret = del_history_file(HS_FILE_LOG);
	if(!ret)
	{
		ret = create_log_rcd_file();
	}
	
	memset(&log_file_info,0,sizeof(struct rcd_file_info));
	memset(&log_rcd_file,0,sizeof(struct history_rcd_file));
	memcpy(log_rcd_file.name,HF_LOG_FILENAME,strlen(HF_LOG_FILENAME));
	memset(&log_st,0,sizeof(struct log_poll));

	//获取日志文件信息
	p_file = hf_get_dir_file(HF_LOG_101_DIR,&file_num);

	if(p_file)
	{	
	#ifdef FILE_INIT_PRINT
		rt_printf("\r\n------------------------%s------------------------\r\n",HF_LOG_FILENAME);
		rt_printf("文件个数:%d\r\n", file_num);
		rt_printf("文件大小:%d\r\n", p_file->file_size);
		timespec_to_rtc(p_file->file_time, &tm, 0);
		rt_printf("创建时间:20%02hu-%02hu-%02hu %02hu:%02hu:%02hu \r\n",tm.year,tm.month,tm.day,tm.hour,tm.min,tm.ms/1000);
	#endif 

		log_rcd_file.len = p_file->file_size;
		timespec_to_rtc(p_file->file_time, &tm, 0);		
		log_rcd_file.create_time = tm;
		
		rt_free(p_file);

		strcpy(log_rcd_file.name,p_file->name);

	}	
	i = read_log_rcd_file();
	if(i<0)
	{
		ret = create_log_rcd_file();
		rt_printf("%s:初始化LOG记录,i=%d, ret = %d\r\n",__func__, i,ret);
	}
	return ret;
}






/******************************************************************************
函数名称：	init_hs_file
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	soe记录文件、遥控记录文件、定点记录文件、极值记录文件初始化
参数说明：	
			
返回值：	
	
修改记录：	
*/
void   init_hs_file(bool b_new_dir)
{
	int i,ret;

	if(b_new_dir)//文件格式切换
	{
		rt_file_deldir(HF_HISTORY_DIR);
		rt_file_mkdir(HF_HISTORY_DIR);
		rt_file_mkdir(HF_SOE_101_DIR);
		rt_file_mkdir(HF_CO_101_DIR);
		rt_file_mkdir(HF_EXV_101_DIR);
		rt_file_mkdir(HF_FIXPT_101_DIR);
		rt_file_mkdir(HF_FRZ_101_DIR);
		rt_file_mkdir(HF_FLOWREV_101_DIR);
		rt_file_mkdir(HF_LOG_101_DIR);	
	}

	for(i=0;i<HS_FILE_NUM;i++)
	{
		p_his_file[i] = pRunSet->bTT_MsgFile?(char*)history_file_name[i][0]:(char*)history_file_name[i][1];
	}

	histrory_file_set = 0;
	hs_file_init_flag = false; 
	
	soe_file_info.b_err = false; 
	yk_file_info.b_err = false; 
	exv_file_info.b_err = false; 
	fixpt_file_info.b_err = false; 
	frz_file_info.b_err = false; 
	flowrev_file_info.b_err = false;
	log_file_info.b_err = false; 

	init_his_db();
	
	ret = hs_read_iec_crc();

	if(ret)
	{
		
		rt_file_deldir(HF_HISTORY_DIR);
		rt_file_deldir(HF_HISTORY_DB_INFO);

		init_his_db();
		rt_file_mkdir(HF_HISTORY_DB_INFO);
		rt_file_mkdir(HF_HISTORY_DIR);
		rt_file_mkdir(HF_SOE_101_DIR);
		rt_file_mkdir(HF_CO_101_DIR);
		rt_file_mkdir(HF_EXV_101_DIR);
		rt_file_mkdir(HF_FIXPT_101_DIR);
		rt_file_mkdir(HF_FRZ_101_DIR);
		rt_file_mkdir(HF_FLOWREV_101_DIR);
		rt_file_mkdir(HF_LOG_101_DIR);
		
	}
		

	//rt_printf("%s:g_crc_rectable=0x%04x,ret=%d\r\n",__func__,g_crc_rectable,ret);

	init_hs_file_event(HS_FILE_SOE);	
	init_hs_file_event(HS_FILE_CO);	
	init_hs_file_exv(b_new_dir);
	init_hs_file_fixpt(b_new_dir);
	init_hs_file_frz(b_new_dir);
	init_hs_file_flowrev(b_new_dir);
	init_hs_file_log();

	//hs_write_iec_crc();
	
	hs_file_init_flag = true;
}


/******************************************************************************
函数名称：	acquire_exv_data
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-20
函数说明：	上电初始化取当天的极值数据
参数说明：	day:第几天
			
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int  acquire_exv_data(u8 day)
{
	int file_len;
	char * file_buf;
	char *p_str;
	loff_t pos;
	int offset;
	int i=0,j=0;
	int ret=0;
	char dir_name[64]={0};
	char max_n[8]={0};
	char cp_buf[8]={0};
	char elem_buf[10]={0};
	char time_buf[4]={0};

	
	

	//极值文件最多为31个,上电初始化依次读取，如未创建则退出
	if(exv_rcd_file[day].name == NULL)
	{	
		return -2;
	}

	sprintf(dir_name,"%s%s",HF_EXV_101_DIR,exv_rcd_file[day].name);

	//打开文件
	exv_rcd_file[day].handle = rt_file_open(dir_name,O_CREAT|O_RDWR,0);


	if(IS_ERR(exv_rcd_file[day].handle))
	{ 
		exv_rcd_file[day].handle = 0;
		
		rt_printf("%s:%s open error!\r\n",__func__,exv_rcd_file[day].name);
	
		return -3; 
	}  

	//得到文件长度
	file_len = rt_file_getfile_size(exv_rcd_file[day].handle);
	if(file_len <= 0)
	{
		rt_file_close(exv_rcd_file[day].handle,0);
		return -11;
	}


	if(file_len==0)
	{
		return -4; 	
	}
		
	//分配内存
	file_buf = rt_malloc(file_len);
	if(file_buf == NULL)
	{
		return -5; 	
	}

	memset(file_buf,0,file_len);

	//读出文件内容
	pos=0;
	
	if(rt_file_read(exv_rcd_file[day].handle,file_buf, file_len,&pos)!=  file_len) 
	{
		rt_file_close(exv_rcd_file[day].handle,0);
		exv_rcd_file[day].handle = 0;
	
		rt_printf("%s:%s read error:file_len=%d,ret=%d!\r\n",__func__,exv_rcd_file[day].name,file_len,ret);

		rt_free(file_buf);
		return -6;
	}

	rt_file_close(exv_rcd_file[day].handle,0);

	
	if(pRunSet->bTT_MsgFile)
	{
		//找到最大值的个数
		p_str = strstr(file_buf ,"最大值：");
		if(p_str)
		{	
			i = p_str-file_buf;
		}
		else
		{
			rt_free(file_buf);
			return -7;
		}

		memcpy(max_n,&file_buf[i+strlen("最大值：")],4);
		exv_rcd_dd.max_num = atoi(max_n);

		offset = i+strlen("最大值：0032,");

		for(j=0;j<exv_rcd_dd.max_num;j++)
		{
			if((file_buf[j*MSG_EXV_RCD_LEN+offset] = '0')&&(file_buf[j*MSG_EXV_RCD_LEN+offset+1] = 'x'))
			{
				memcpy(cp_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset],6);
				exv_rcd_dd.max_data[j].cp = strtol(cp_buf,(char **)0,16);
				//rt_printf("max[%d]:cp=0x%04x\r\n",j,exv_rcd_dd.max_data[j].cp);

				memcpy(elem_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset+7],9);
				exv_rcd_dd.max_data[j].elem_val=atof1(elem_buf);
						
				//rt_printf("max[%d]:elem_val=%f\r\n",j,exv_rcd_dd.max_data[j].elem_val);

				memset(time_buf,0,sizeof(time_buf));
				
				memcpy(time_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset+19],2);
				exv_rcd_dd.max_data[j].time_mark.year = strtol(time_buf,(char **)0,10);

				memcpy(time_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset+22],2);
				exv_rcd_dd.max_data[j].time_mark.month = strtol(time_buf,(char **)0,10);

				memcpy(time_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset+25],2);
				exv_rcd_dd.max_data[j].time_mark.day = strtol(time_buf,(char **)0,10);

				memcpy(time_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset+28],2);
				exv_rcd_dd.max_data[j].time_mark.hour = strtol(time_buf,(char **)0,10);

				memcpy(time_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset+31],2);
				exv_rcd_dd.max_data[j].time_mark.min = strtol(time_buf,(char **)0,10);

				memcpy(time_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset+34],2);
				exv_rcd_dd.max_data[j].time_mark.ms =1000*strtol(time_buf,(char **)0,10);

				memcpy(time_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset+37],3);
				exv_rcd_dd.max_data[j].time_mark.ms +=strtol(time_buf,(char **)0,10);
				
				#if 0
				rt_printf("max[%d]:20%02hu-%02hu-%02hu %02hu:%02hu:%02hu\r\n",
					j,
					exv_rcd_dd.max_data[j].time_mark.year,
					exv_rcd_dd.max_data[j].time_mark.month,
					exv_rcd_dd.max_data[j].time_mark.day,
					exv_rcd_dd.max_data[j].time_mark.hour,
					exv_rcd_dd.max_data[j].time_mark.min,
					exv_rcd_dd.max_data[j].time_mark.ms/1000);
				#endif


				exv_rcd.max_value_bk[j] = exv_rcd_dd.max_data[j].elem_val;
				exv_rcd.max_data[j].elem_val = exv_rcd_dd.max_data[j].elem_val;
				exv_rcd.max_data[j].time_mark = exv_rcd_dd.max_data[j].time_mark;
		

			}
			
		}


		//找到最大值的个数
		p_str = strstr(file_buf ,"最小值：");
		if(p_str)
		{	
			i = p_str-file_buf;
		}
		else
		{
			rt_free(file_buf);
			return -8;
		}

		memcpy(max_n,&file_buf[i+strlen("最小值：")],4);
		exv_rcd_dd.min_num = atoi(max_n);

		offset = i+strlen("最小值：0032,");


		for(j=0;j<exv_rcd_dd.min_num;j++)
		{
			if((file_buf[j*MSG_EXV_RCD_LEN+offset] = '0')&&(file_buf[j*MSG_EXV_RCD_LEN+offset+1] = 'x'))
			{
				memcpy(cp_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset],6);
				exv_rcd_dd.min_data[j].cp = strtol(cp_buf,(char **)0,16);
				//rt_printf("min[%d]:cp=0x%04x\r\n",j,exv_rcd_dd.min_data[j].cp);

				
				memcpy(elem_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset+7],9);
				exv_rcd_dd.min_data[j].elem_val=atof1(elem_buf);
						
				//rt_printf("min[%d]:elem_val=%f\r\n",j,exv_rcd_dd.min_data[j].elem_val);


				memset(time_buf,0,sizeof(time_buf));
				
				memcpy(time_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset+19],2);
				exv_rcd_dd.min_data[j].time_mark.year = strtol(time_buf,(char **)0,10);

				memcpy(time_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset+22],2);
				exv_rcd_dd.min_data[j].time_mark.month = strtol(time_buf,(char **)0,10);

				memcpy(time_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset+25],2);
				exv_rcd_dd.min_data[j].time_mark.day = strtol(time_buf,(char **)0,10);

				memcpy(time_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset+28],2);
				exv_rcd_dd.min_data[j].time_mark.hour = strtol(time_buf,(char **)0,10);

				memcpy(time_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset+31],2);
				exv_rcd_dd.min_data[j].time_mark.min = strtol(time_buf,(char **)0,10);

				memcpy(time_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset+34],2);
				exv_rcd_dd.min_data[j].time_mark.ms =1000*strtol(time_buf,(char **)0,10);

				memcpy(time_buf,&file_buf[j*MSG_EXV_RCD_LEN+offset+37],3);
				exv_rcd_dd.min_data[j].time_mark.ms +=strtol(time_buf,(char **)0,10);

				#if 0
				rt_printf("min[%d]:20%02hu-%02hu-%02hu %02hu:%02hu:%02hu\r\n",
					j,
					exv_rcd_dd.min_data[j].time_mark.year,
					exv_rcd_dd.min_data[j].time_mark.month,
					exv_rcd_dd.min_data[j].time_mark.day,
					exv_rcd_dd.min_data[j].time_mark.hour,
					exv_rcd_dd.min_data[j].time_mark.min,
					exv_rcd_dd.min_data[j].time_mark.ms/1000);
				#endif


				exv_rcd.min_value_bk[j] = exv_rcd_dd.min_data[j].elem_val;
				exv_rcd.min_data[j].elem_val = exv_rcd_dd.min_data[j].elem_val;
				exv_rcd.min_data[j].time_mark = exv_rcd_dd.min_data[j].time_mark;


			}
			
		}
	}
	else
	{

		p_str = strstr(file_buf ,"DataAttr num=\"");
		if(p_str)
		{
			i = p_str-file_buf;
			memcpy(max_n,&file_buf[i+strlen("DataAttr num=\"")],3);
			exv_rcd_dd.max_num = atoi(max_n);
			exv_rcd_dd.min_num = exv_rcd_dd.max_num;
		}
		else
		{
			rt_free(file_buf);
			return -9;
		}
		
	
		//找到最大值的个数
		p_str = strstr(file_buf ,"<DataRec>\r\n");
		if(p_str)
		{	
			i = p_str-file_buf;
			exv_rcd_file[day].offset = i+strlen("<DataRec>\r\n");
		}
		else
		{
			rt_free(file_buf);
			return -10;
		}


		offset=0;
		for(j=0;j<exv_rcd_dd.max_num;j++)
		{	
			p_str = strstr(&file_buf[i+offset] ,"max=\"");
			if(p_str)
			{
				i = p_str-file_buf;
				offset = strlen("max=\"");
				memcpy(elem_buf,&file_buf[i+offset],9);
				exv_rcd_dd.max_data[j].elem_val = atof1(elem_buf);
				offset += 9;

				offset += strlen(" \"max_tm=\"");
				memcpy(time_buf,&file_buf[i+offset],2);
				exv_rcd_dd.max_data[j].time_mark.year = strtol(time_buf,(char **)0,10);


				offset += 2;
				memcpy(time_buf,&file_buf[i+offset],2);
				exv_rcd_dd.max_data[j].time_mark.month = strtol(time_buf,(char **)0,10);


				offset += 2;
				memcpy(time_buf,&file_buf[i+offset],2);
				exv_rcd_dd.max_data[j].time_mark.day = strtol(time_buf,(char **)0,10);


				offset += 3;
				memcpy(time_buf,&file_buf[i+offset],2);
				exv_rcd_dd.max_data[j].time_mark.hour = strtol(time_buf,(char **)0,10);

				offset += 2;
				memcpy(time_buf,&file_buf[i+offset],2);
				exv_rcd_dd.max_data[j].time_mark.min = strtol(time_buf,(char **)0,10);


				offset += 2;
				memcpy(time_buf,&file_buf[i+offset],2);
				exv_rcd_dd.max_data[j].time_mark.ms = 1000*strtol(time_buf,(char **)0,10);


				offset += 2;
				offset += strlen("\" min=\"");
				memcpy(elem_buf,&file_buf[i+offset],9);
				exv_rcd_dd.min_data[j].elem_val = atof1(elem_buf);
				offset += 9;

				offset += strlen("\" min_tm=\"");
				memcpy(time_buf,&file_buf[i+offset],2);
				exv_rcd_dd.min_data[j].time_mark.year = strtol(time_buf,(char **)0,10);

				offset += 2;
				memcpy(time_buf,&file_buf[i+offset],2);
				exv_rcd_dd.min_data[j].time_mark.month = strtol(time_buf,(char **)0,10);

				offset += 2;
				memcpy(time_buf,&file_buf[i+offset],2);
				exv_rcd_dd.min_data[j].time_mark.day = strtol(time_buf,(char **)0,10);


				offset += 3;
				memcpy(time_buf,&file_buf[i+offset],2);
				exv_rcd_dd.min_data[j].time_mark.hour = strtol(time_buf,(char **)0,10);

				offset += 2;
				memcpy(time_buf,&file_buf[i+offset],2);
				exv_rcd_dd.min_data[j].time_mark.min = strtol(time_buf,(char **)0,10);

				offset += 2;
				memcpy(time_buf,&file_buf[i+offset],2);
				exv_rcd_dd.min_data[j].time_mark.ms = 1000*strtol(time_buf,(char **)0,10);

				
			#if 0
				rt_printf("max[%d]=%f:20%02hu-%02hu-%02hu %02hu:%02hu:%02hu\r\n",
					j,
					exv_rcd_dd.max_data[j].elem_val,
					exv_rcd_dd.max_data[j].time_mark.year,
					exv_rcd_dd.max_data[j].time_mark.month,
					exv_rcd_dd.max_data[j].time_mark.day,
					exv_rcd_dd.max_data[j].time_mark.hour,
					exv_rcd_dd.max_data[j].time_mark.min,
					exv_rcd_dd.max_data[j].time_mark.ms/1000);


				rt_printf("min[%d]=%f:20%02hu-%02hu-%02hu %02hu:%02hu:%02hu\r\n",
					j,
					exv_rcd_dd.min_data[j].elem_val,
					exv_rcd_dd.min_data[j].time_mark.year,
					exv_rcd_dd.min_data[j].time_mark.month,
					exv_rcd_dd.min_data[j].time_mark.day,
					exv_rcd_dd.min_data[j].time_mark.hour,
					exv_rcd_dd.min_data[j].time_mark.min,
					exv_rcd_dd.min_data[j].time_mark.ms/1000);
			#endif


				exv_rcd.max_value_bk[j] = exv_rcd_dd.max_data[j].elem_val;
				exv_rcd.max_data[j].elem_val = exv_rcd_dd.max_data[j].elem_val;
				exv_rcd.max_data[j].time_mark = exv_rcd_dd.max_data[j].time_mark;

				
				exv_rcd.min_value_bk[j] = exv_rcd_dd.min_data[j].elem_val;
				exv_rcd.min_data[j].elem_val = exv_rcd_dd.min_data[j].elem_val;
				exv_rcd.min_data[j].time_mark = exv_rcd_dd.min_data[j].time_mark;

			}
			else
			{
				rt_free(file_buf);
				return -11;
			}

		}
		
	}
	

	exv_rcd.save_flag = true;
	

	rt_free(file_buf);

	return ret;

}




/******************************************************************************
函数名称：	pw_quality_file_init
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-20
函数说明：	初始化极值记录文件
参数说明：	
			day:		第几天的极值记录
				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int  read_exv_rcd_file(u8 day)
{
	int file_len;
	char * file_buf;
	loff_t pos;
	int ret=0;
	char dir_name[64]={0};

	//极值文件最多为30个,上电初始化依次读取，如未创建则退出

	if(exv_rcd_file[day].name == NULL)
		return -1;

	sprintf(dir_name,"%s%s",HF_EXV_101_DIR,exv_rcd_file[day].name);

	//打开文件
	exv_rcd_file[day].handle = rt_file_open(dir_name,O_CREAT|O_RDWR,0);

	if(IS_ERR(exv_rcd_file[day].handle))
	{ 
		exv_rcd_file[day].handle = 0;
		
		rt_printf("%s:%s open error!\r\n",__func__,exv_rcd_file[day].name);
		
		return -2; 
	}  

	//得到文件长度
	file_len = rt_file_getfile_size(exv_rcd_file[day].handle);

	//文件长度为0
	if(file_len<=0)
	{
		rt_file_close(exv_rcd_file[day].handle,0);
		return -3;
	}

	//分配内存
	file_buf = rt_malloc(file_len);
	if(file_buf == NULL)
	{
		return -4; 	
	}

	memset(file_buf,0,file_len);

	//读出文件内容
	pos=0;
	ret = rt_file_read(exv_rcd_file[day].handle,file_buf, file_len,&pos);
	if(ret !=  file_len) 
	{
		rt_file_close(exv_rcd_file[day].handle,0);
		exv_rcd_file[day].handle = 0;
	
		rt_printf("%s:%s read error:file_len=%d,ret=%d!\r\n",__func__,exv_rcd_file[day].name,file_len,ret);

		rt_free(file_buf);
		return -5;

	}


	rt_file_close(exv_rcd_file[day].handle,0);

	//释放内存
	rt_free(file_buf);

	return ret;
	
}





/******************************************************************************
函数名称：	read_fixpt_rcd_file
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	读取第几天的定点记录文件
参数说明：	day:第几天，p_part_id:节点索引
				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int  read_fixpt_rcd_file(u8 day,u16 *p_part_id)
{
	int file_len;
	char * file_buf;
	loff_t pos;
	char *p_str;
	bool b_find_num=false,b_find_end=false;
	int i,ret=0;
	char dir_name[64] = {0};
	
	if(day>FIXPT_FILE_NUM_MAX-1)
		return -1;	
	
	if(fixpt_rcd_file[day].name == NULL)
		return -2; 	
	
	sprintf(dir_name,"%s%s",HF_FIXPT_101_DIR,fixpt_rcd_file[day].name);
	
	//打开文件
	fixpt_rcd_file[day].handle = rt_file_open(dir_name,O_CREAT|O_RDWR,0);

	if(IS_ERR(fixpt_rcd_file[day].handle))
	{ 
		fixpt_rcd_file[day].handle = 0;
		rt_printf("%s:%s open error!\r\n",__func__,fixpt_rcd_file[day].name);
		return -3; 
	}  

	//得到文件长度
	file_len = rt_file_getfile_size(fixpt_rcd_file[day].handle);

	//文件长度为0
	if(file_len <= 0)
	{
		rt_file_close(fixpt_rcd_file[day].handle,0);
		return -4;
	}

	//分配内存
	file_buf = rt_malloc(file_len);
	if(file_buf == NULL)
		return -5; 	
	
	memset(file_buf,0,file_len);

	//读出文件内容
	pos=0;
	ret = rt_file_read(fixpt_rcd_file[day].handle,file_buf, file_len,&pos);
	if(ret !=  file_len) 
	{
		fixpt_rcd_file[day].handle = 0;
		rt_file_close(fixpt_rcd_file[day].handle,0);
		rt_printf("%s:%s read error:file_len=%d,ret=%d!\r\n",__func__,fixpt_rcd_file[day].name,file_len,ret);

		rt_free(file_buf);
		return -6;
	}

	rt_file_close(fixpt_rcd_file[day].handle,0);

	if(pRunSet->bTT_MsgFile)
	{
		//节点数
		fixpt_rcd_file[day].node_num = atoi(&file_buf[MSG_FIX_PART_ID_OFFSET]);
		//找到最后一条定点记录的位置
		fixpt_rcd_file[day].offset = pos-1;//文件结束符要去掉

		if(fixpt_rcd_file[day].node_num>FIX_RCD_NUM)
		{
			rt_free(file_buf);
			return -7;
		}
	}
	else
	{
		if(strstr(file_buf ,"sectNum=") != NULL)
		{	
			p_str = strstr(file_buf ,"sectNum=");
			i = p_str-file_buf;
			b_find_num = true;
			fixpt_rcd_file[day].node_num = atoi(&file_buf[i+9]);
			fixpt_rcd_file[day].num_pos = i+9;
		}

		if(!b_find_num)//没有找到
		{
			// 删除文件
			ret = rt_file_del(dir_name);
			rt_free(file_buf);
			return -8;
		}


		//找到最后一条定点记录的位置
		if(strstr(file_buf ,"</DataFile>") != NULL)
		{	
			p_str = strstr(file_buf ,"</DataFile>");
			i = p_str-file_buf;
			fixpt_rcd_file[day].offset = i;
			b_find_end = true;
		}

		if(!b_find_end)//没有找到
		{
			// 删除文件
			ret = rt_file_del(dir_name);
			rt_free(file_buf);
			return -9;
		}
	}
	
	*p_part_id = fixpt_rcd_file[day].node_num;

	//rt_printf("node_num[%d]=%d\r\n",day,fixpt_rcd_file[day].node_num);

	//释放内存
	rt_free(file_buf);

	return ret;
}


/******************************************************************************
函数名称：	read_frz_rcd_file
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-12-12
函数说明：	读取第几天的日冻结电能量记录文件
参数说明：	day:第几天，p_part_id:节点索引
				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int read_frz_rcd_file(u8 day,u16 *p_part_id)
{
	int file_len;
	char * file_buf;
	loff_t pos;
	char *p_str;
	bool b_find_num=false,b_find_end=false;
	int i,ret=0;
	char dir_name[64] = {0};
	
	if(frz_rcd_file[day].name == NULL)
		return -1; 	
	
	sprintf(dir_name,"%s%s",HF_FRZ_101_DIR,frz_rcd_file[day].name);

	//打开文件
	frz_rcd_file[day].handle = rt_file_open(dir_name,O_CREAT|O_RDWR,0);

	if(IS_ERR(frz_rcd_file[day].handle))
	{ 	
		frz_rcd_file[day].handle = 0;
		rt_printf("%s:%s open error!\r\n",__func__,frz_rcd_file[day].name);
		return -2; 
	}

	file_len = rt_file_getfile_size(frz_rcd_file[day].handle);
	//文件长度为0
	if(file_len <= 0)
	{
		rt_file_close(frz_rcd_file[day].handle,0);
		return -3;
	}

	//分配内存
	file_buf = rt_malloc(file_len);
	if(file_buf == NULL)
		return -4; 	
	
	memset(file_buf,0,file_len);

	//读出文件内容
	pos = 0;
	ret = rt_file_read(frz_rcd_file[day].handle,file_buf, file_len,&pos);
	if(ret !=  file_len) 
	{
		rt_file_close(frz_rcd_file[day].handle,0);
		frz_rcd_file[day].handle = 0;
		rt_printf("%s:%s read error:file_len=%d,ret=%d!\r\n",__func__,frz_rcd_file[day].name,file_len,ret);

		rt_free(file_buf);
		return -5;

	}

	rt_file_close(frz_rcd_file[day].handle,0);

	if(pRunSet->bTT_MsgFile)
	{
		//节点数
		frz_rcd_file[day].node_num = atoi(&file_buf[MSG_FRZ_PART_ID_OFFSET]);
		//找到最后一条定点记录的位置
		frz_rcd_file[day].offset = pos;

		if(frz_rcd_file[day].node_num>FRZ_RCD_NUM)
		{
			rt_free(file_buf);
			return -7;
		}
	}
	else
	{
		if(strstr(file_buf ,"sectNum=") != NULL)
		{	
			p_str = strstr(file_buf ,"sectNum=");
			i = p_str-file_buf;
			b_find_num = true;
			frz_rcd_file[day].node_num = atoi(&file_buf[i+9]);
			frz_rcd_file[day].num_pos = i+9;
		}

		if(!b_find_num)//没有找到
		{
			// 删除文件
			ret = rt_file_del(dir_name);
			rt_free(file_buf);
			return -8;
		}

		//找到最后一条定点记录的位置
		if(strstr(file_buf ,"</DataFile>") != NULL)
		{	
			p_str = strstr(file_buf ,"</DataFile>");
			i = p_str-file_buf;
			frz_rcd_file[day].offset = i;
			b_find_end = true;
		}

		if(!b_find_end)//没有找到
		{
			// 删除文件
			ret = rt_file_del(dir_name);
			rt_free(file_buf);
			return -9;
		}
	}
	
	//节点数
	frz_rcd_file[day].node_num = atoi(&file_buf[MSG_FRZ_PART_ID_OFFSET]);
	
	frz_rcd_file[day].offset = pos;
	if(pRunSet->bTT_MsgFile)
	{
		//文件结束符要去掉
		frz_rcd_file[day].offset-=1;
	}
	 
	*p_part_id = frz_rcd_file[day].node_num;
	
	//释放内存
	rt_free(file_buf);
	return ret;
	
}




/******************************************************************************
函数名称：	read_flowrev_rcd_file
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-12-12
函数说明：	读取第几天的日冻结电能量记录文件
参数说明：	day:第几天，p_part_id:节点索引
				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int read_flowrev_rcd_file(void)
{
	int file_len;
	char * file_buf;
	loff_t pos;
	int i;
	int ret=0;
	char dir_name[64] = {0};
	int node_num = 0;
	char *p_str;
	bool b_find_num=false;

	if(flowrev_rcd_file.name == NULL)
		return -1; 	
	
	sprintf(dir_name,"%s%s",HF_FLOWREV_101_DIR,flowrev_rcd_file.name);

	//打开文件
	flowrev_rcd_file.handle = rt_file_open(dir_name,O_CREAT|O_RDWR,0);

	if(IS_ERR(flowrev_rcd_file.handle))
	{ 
		flowrev_rcd_file.handle = 0;
		rt_printf("%s:%s open error!\r\n",__func__,flowrev_rcd_file.name);
		return -2; 
	}

	file_len = rt_file_getfile_size(flowrev_rcd_file.handle);
	//文件长度为0
	if(file_len <= 0)
	{
		rt_file_close(flowrev_rcd_file.handle,0);
		return -3;
	}
	

	//分配内存
	file_buf = rt_malloc(file_len);
	if(file_buf == NULL)
		return -4; 	
	
	memset(file_buf,0,file_len);

	//读出文件内容
	pos=0;
	ret = rt_file_read(flowrev_rcd_file.handle,file_buf, file_len,&pos);
	if(ret !=  file_len) 
	{
		rt_file_close(flowrev_rcd_file.handle,0);
		flowrev_rcd_file.handle = 0;
		rt_printf("%s:%s read error:file_len=%d,ret=%d!\r\n",__func__,flowrev_rcd_file.name,file_len,ret);

		rt_free(file_buf);
		return -5;
	}

	rt_file_close(flowrev_rcd_file.handle,0);

	//文件长度为0
	flowrev_rcd_file.len = file_len;
	flowrev_rcd_file.offset = pos;

	if(pRunSet->bTT_MsgFile)
	{
		for(i=0;i<file_len-MSG_FLOWREV_FILE_HEAD_LEN;i++)
		{
			if((file_buf[i+MSG_FLOWREV_FILE_HEAD_LEN] == '\r') && (file_buf[i+MSG_FLOWREV_FILE_HEAD_LEN+1] == '\n'))
			{
				node_num ++;
			}
		}

		flowrev_rcd_file.node_num = node_num;
	}
	else
	{
		if(strstr(file_buf ,"<DataRec num=\"") != NULL)
		{	
			p_str = strstr(file_buf ,"<DataRec num=\"");
			i = p_str-file_buf;
			b_find_num = true;

			flowrev_rcd_file.node_num = atoi(&file_buf[i+14]);
			flowrev_rcd_file.num_pos = i+14;
		}

		if(!b_find_num)//没有找到
		{
			// 删除文件
			ret = rt_file_del(dir_name);
			rt_free(file_buf);
			return -6;
		}
	}

	if(flowrev_rcd_file.node_num > FLOWREV_FRONT_PART_NUM)
	{
		rt_free(file_buf);
		return -7;
	}
	
	//释放内存
	rt_free(file_buf);

	return ret;
	
}



int  read_log_rcd_file(void)
{
	int file_len;
	char * file_buf;
	loff_t pos;
	char *p_str;
	int i;
	
	int ret=0;
	char dir_name[64]={0};

	if(log_rcd_file.name == NULL)
		return -1;
	
	sprintf(dir_name,"%s%s",HF_LOG_101_DIR,log_rcd_file.name);
	
	log_rcd_file.handle = rt_file_open(dir_name,O_CREAT|O_RDWR,0);

	if(IS_ERR(log_rcd_file.handle))
	{ 
		log_rcd_file.handle = 0;
		rt_printf("%s:%s open error!\r\n",__func__,log_rcd_file.name);
		return -2; 
	}  

	//得到文件长度
	file_len = rt_file_getfile_size(log_rcd_file.handle);
	//文件长度超出范围
	if(file_len <= 0)
	{
		rt_file_close(log_rcd_file.handle,0);
		return -3;
	}

	
	//分配内存
	file_buf = rt_malloc(file_len);
	if(file_buf == NULL)
	{
		return -4; 	
	}

	 //读出文件内容
	pos=0;
	ret = rt_file_read(log_rcd_file.handle,file_buf,file_len,&pos);
	if(ret !=  file_len) 
	{
		rt_file_close(log_rcd_file.handle,0);
		log_rcd_file.handle = 0;
		rt_printf("%s:%s read error:file_len=%d,ret=%d!\r\n",__func__,log_rcd_file.name,file_len,ret);
		rt_free(file_buf);
		return -5;
	}

	rt_file_close(log_rcd_file.handle,0);

	if(pRunSet->bTT_MsgFile)
	{
		log_rcd_file.rcd_num = atoi(&file_buf[MSG_LOG_RCD_NUM_OFFSET]);
		log_rcd_file.offset = pos-1;
	}
	else
	{
		p_str = strstr(file_buf ,"DataRec num=\"");
		if(p_str)
		{	
			i = p_str-file_buf;
			log_rcd_file.rcd_num = atoi(&file_buf[i+strlen("DataRec num=\"")]);
			log_rcd_file.num_pos = i+strlen("DataRec num=\"");
		}
		else	//没有找到
		{
			// 删除文件
			ret = rt_file_del(dir_name);
			rt_free(file_buf);
			return -6;
		}

		p_str = strstr(file_buf ,"</DataRec>");
		if(p_str)
		{
			log_rcd_file.offset = p_str-file_buf;
		}
		else
		{
			// 删除文件
			ret = rt_file_del(dir_name);
			rt_free(file_buf);
			return -7;
		}
		
	}
	//释放内存
	rt_free(file_buf);
	
	return ret;
}




/******************************************************************************
函数名称：	exv_rcd_file_deal
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	创建极值文件,极值记录为当前时刻的数据，如果极值文件数超过30，则删掉最初的记录文件，
			同时将第二天的文件名字修改掉，要写入文件头描述当中，当天文件记录到最后一个极值文件
			
参数说明：	
				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int exv_rcd_file_deal(struct rtc_time_t time)
{
	int i,j,k;
	int ret = 0;
	char dir_name[64]={0};
	
		//如果当天的极值文件已经存在，则删除以前的文件
	for(j=0;j<exv_file_info.file_num;j++)
	{
		if((exv_rcd_file[j].create_time.year == time.year)
			&&(exv_rcd_file[j].create_time.month== time.month)
			&&(exv_rcd_file[j].create_time.day== time.day))
		{
			//删除那一天极值记录文件
			sprintf(dir_name,"%s%s",HF_EXV_101_DIR,exv_rcd_file[j].name);
			ret = rt_file_del(dir_name);

			if(ret == 0)
			{
				exv_file_info.file_num -= 1;

				for(k=j;k<exv_file_info.file_num;k++)
				{
					memcpy(&exv_rcd_file[k],(char*)&exv_rcd_file[k+1],sizeof(struct history_rcd_file));
				}
				break;
			}
			else
				return -1;

		}
	}


	//极值文件已经满了31个，则移位文件，并创建一个新文件
	if(exv_file_info.file_num >= EXV_FILE_NUM_MAX)
	{
		// 删除最初的文件
		sprintf(dir_name,"%s%s",HF_EXV_101_DIR,exv_rcd_file[0].name);

		ret = rt_file_del(dir_name);
		
		if(ret == 0)
		{
			//文件数减1
			exv_file_info.file_num -= 1;

			for(i=0;i<(EXV_FILE_NUM_MAX-1);i++)
			{
				memcpy(&exv_rcd_file[i],(char*)&exv_rcd_file[i+1],sizeof(struct history_rcd_file));
			}
	
		}
		else
			return -2;
	
	}


	ret = create_exv_rcd_file(&exv_file_info);
	
	if(ret!=0)
		ret -= 1;

	return ret;
	
}

int  exv_txt_file_deal(void)
{
	char dir_name[64]={0};
	int ret = 0;
	int i;
	
	//极值文件已经满了31个，则移位文件，并创建一个新文件
	if(exv_txt_info.file_num >= EXV_FILE_NUM_MAX)
	{
		// 删除最初的文件
		sprintf(dir_name,"%s%s",HF_EXV_101_DIR,exv_txt_file[0].name);

		ret = rt_file_del(dir_name);
		
		if(ret == 0)
		{
			//文件数减1
			exv_txt_info.file_num -= 1;

			for(i=0;i<(EXV_FILE_NUM_MAX-1);i++)
			{
				memcpy(&exv_txt_file[i],(char*)&exv_txt_file[i+1],sizeof(struct history_rcd_file));
			}
	
		}
		else
			return -1;
	
	}

	return 0;
}


/******************************************************************************
函数名称：	fixpt_rcd_file_deal
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	创建定点文件，如果定点文件数超过30，则删掉最初的记录文件，
			同时将第二天的文件名字修改掉，要写入文件头描述当中，当天文件记录到最后一个定点文件
			
参数说明：	
				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int fixpt_rcd_file_deal(struct rtc_time_t time)
{
	int i,j,k=0;
	int ret = 0;
	char dir_name[64]={0};

	
	//如果当天的定点文件已经存在，则删除以前的文件
	for(j=0;j<fixpt_file_info.file_num;j++)
	{
		if((fixpt_rcd_file[j].create_time.year == time.year)
			&&(fixpt_rcd_file[j].create_time.month == time.month)
			&&(fixpt_rcd_file[j].create_time.day== time.day))
		{
			//删除那一天定点记录文件
			sprintf(dir_name,"%s%s",HF_FIXPT_101_DIR,fixpt_rcd_file[j].name);
			ret = rt_file_del(dir_name);


			if(ret == 0)
			{
				if(fixpt_file_info.file_num)
					fixpt_file_info.file_num -= 1;

				for(k=j;k<fixpt_file_info.file_num;k++)
				{
					memcpy(&fixpt_rcd_file[k],(char*)&fixpt_rcd_file[k+1],sizeof(struct history_rcd_file));
				}
				break;
			}
			else
				return -1;

		}
	}



	if(fixpt_file_info.file_num >=FIXPT_FILE_NUM_MAX)
	{
		//删除最初定点记录文件
		sprintf(dir_name,"%s%s",HF_FIXPT_101_DIR,fixpt_rcd_file[0].name);
		ret = rt_file_del(dir_name);

		
		if(ret == 0)
		{
			fixpt_file_info.file_num -= 1;

			for(i=0;i<FIXPT_FILE_NUM_MAX-1;i++)
			{
				memcpy(&fixpt_rcd_file[i],(char*)&fixpt_rcd_file[i+1],sizeof(struct history_rcd_file));
			}
	
		}
		else
			return -2;

	}
	

	ret = create_fixpt_rcd_file();


	if(ret!=0)
		ret -=1;

	return ret;

}



/******************************************************************************
函数名称：	frz_rcd_file_deal
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-12-21
函数说明：	创建日冻结电能量记录文件,如果文件数超过30，则删掉最初的记录文件，
			同时将第二天的文件名字修改掉，要写入文件头描述当中，当天文件记录到最后一个日冻结电能量记录文件
			
参数说明：	
				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int frz_rcd_file_deal(struct rtc_time_t time)
{
	int i,j,k;
	int ret = 0;
	char dir_name[64]={0};


	//如果当天的定点文件已经存在，则删除以前的文件
	for(j=0;j<frz_file_info.file_num;j++)
	{
		if((frz_rcd_file[j].create_time.year == time.year)
			&&(frz_rcd_file[j].create_time.month== time.month)
			&&(frz_rcd_file[j].create_time.day== time.day))
		{
			//删除那一天日冻结记录文件
			sprintf(dir_name,"%s%s",HF_FRZ_101_DIR,frz_rcd_file[j].name);
			ret = rt_file_del(dir_name);

			if(ret == 0)
			{
				frz_file_info.file_num -= 1;

				for(k=j;k<frz_file_info.file_num;k++)
				{
					memcpy(&frz_rcd_file[k],(char*)&frz_rcd_file[k+1],sizeof(struct history_rcd_file));
				}
				break;
			}
			else
				return -1;

		}
	}


	if(frz_file_info.file_num >= FRZ_FILE_NUM_MAX)
	{
		//删除最初定点记录文件
		sprintf(dir_name,"%s%s",HF_FRZ_101_DIR,frz_rcd_file[0].name);
		ret = rt_file_del(dir_name);
		
		if(ret ==0)
		{
			frz_file_info.file_num -= 1;

			for(i=0;i<FRZ_FILE_NUM_MAX-1;i++)
			{
				memcpy(&frz_rcd_file[i],(char*)&frz_rcd_file[i+1],sizeof(struct history_rcd_file));
			}
	
		}
		else
			return -1;

	}

	ret = create_frz_rcd_file();

	if(ret!=0)
		ret -=1;

	return ret;

}







/******************************************************************************
函数名称：	create_event_rcd_file
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	创建最初事件记录或操作记录文件
参数说明：	
				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int create_event_rcd_file(u8 type)
{
	int i,j;
	unsigned int file_len=0,fix_len;
	unsigned char *p,*p_file;
	loff_t pos;
	int rcd_num;
#ifdef FUNC_HISTORY_UTF8_FORMAT
	int k=0;
	u8 utf8[3];
	unsigned char *file_utf;
	u32 utf8_code;
	u16 gb2312_code;
#endif
	char dir_name[64]={0};
	char tmp_buf[64]={0};


	if(type >HS_FILE_CO)
		return -1;

	if(pRunSet->bTT_MsgFile)
	{
		fix_len = (type==HS_FILE_SOE)?(MSG_SOE_FILE_HEAD_LEN):(MSG_CO_FILE_HEAD_LEN);
		file_len = fix_len+((type==HS_FILE_SOE)?(SOE_RCD_NUM*MSG_SOE_RCD_LEN):(CO_RCD_NUM*MSG_CO_RCD_LEN));
	}
	else
	{
		fix_len = (type==HS_FILE_SOE)?(XML_SOE_FILE_HEAD_LEN):(XML_CO_FILE_HEAD_LEN);
		file_len = fix_len+((type==HS_FILE_SOE)?(SOE_RCD_NUM*XML_SOE_RCD_LEN):(CO_RCD_NUM*XML_CO_RCD_LEN));
	}

	// 分配并初始化空间
	p_file = rt_malloc(file_len); 
	if(!p_file)
	{
		return -2;
	}
	memset(p_file,0,file_len);
	p=p_file;

	rcd_num = (type == HS_FILE_SOE)?soeList.listNum:coList.listNum;
	
	if(type == HS_FILE_SOE)
	{
		if(rcd_num>SOE_RCD_NUM)
		{
			rt_free(p_file);
			return -3;
		}
	}
	else
	{
		if(rcd_num>CO_RCD_NUM)
		{
			rt_free(p_file);
			return -4;
		}
	}


	if(pRunSet->bTT_MsgFile)
	{
		if(type == HS_FILE_SOE)
		{
		#ifdef FUNC_HISTORY_UTF8_FORMAT
			j = sprintf(p,"文件头:soe.msg,v1.0\r\n"); //文件头
		#else	
			j = sprintf(p,"文件头：soe.msg,v1.0\r\n"); //文件头
		#endif	
			p += j;
		}
		else if(type == HS_FILE_CO)
		{
		#ifdef FUNC_HISTORY_UTF8_FORMAT	
			j = sprintf(p,"文件头:co.msg,v1.0\r\n"); //文件头
		#else
			j = sprintf(p,"文件头：co.msg,v1.0\r\n"); //文件头
		#endif	
			p += j;
		}

		set_get_fixed_arg(FIXED_SET_ID,tmp_buf, sizeof(tmp_buf));
		j = sprintf(p,"%.24s,%04d,02\r\n",tmp_buf,rcd_num); //文件头
		p += j;

		if(type == HS_FILE_SOE)
		{
			for(i=0;i<soeList.listNum;i++)
			{	
				u16 di;
				static struct rtc_time_t tm;	//时标
				u8 SIQ;
				readListData(&soeList,i+1,tmp_buf);
				Swap_16_memcpy((BYTE*)&di,tmp_buf);	// modify for am335x  xxxxxx 
				memcpy(&tm,tmp_buf+2,8);
				memcpy(&SIQ,tmp_buf+10,1);

				if(i==soeList.listNum-1)
				{
				#ifdef FUNC_HISTORY_UTF8_FORMAT	
					j = sprintf(p,"第%04d条SOE:0x%04x,%d,%04d-%02d-%02d %02d:%02d:%02d.%03d",
									i+1,
									di,
									SIQ,
									tm.year+2000,
									tm.month,
									tm.day,
									tm.hour,
									tm.min,
									tm.ms/1000,
									tm.ms%1000);

				#else
					j = sprintf(p,"第%04d条SOE：0x%04x,%d,%04d-%02d-%02d %02d:%02d:%02d.%03d",
									i+1,
									di,
									SIQ,
									tm.year+2000,
									tm.month,
									tm.day,
									tm.hour,
									tm.min,
									tm.ms/1000,
									tm.ms%1000);
				#endif	
				}
				else
				{
				#ifdef FUNC_HISTORY_UTF8_FORMAT		
					j = sprintf(p,"第%04d条SOE:0x%04x,%d,%04d-%02d-%02d %02d:%02d:%02d.%03d\r\n",
									i+1,
									di,
									SIQ,
									tm.year+2000,
									tm.month,
									tm.day,
									tm.hour,
									tm.min,
									tm.ms/1000,
									tm.ms%1000);
				#else
					j = sprintf(p,"第%04d条SOE：0x%04x,%d,%04d-%02d-%02d %02d:%02d:%02d.%03d\r\n",
									i+1,
									di,
									SIQ,
									tm.year+2000,
									tm.month,
									tm.day,
									tm.hour,
									tm.min,
									tm.ms/1000,
									tm.ms%1000);
				#endif				
				}
				
				p += j;

			}
				
		}
		else if(type==HS_FILE_CO)
		{
			for(i=0;i<coList.listNum;i++)
			{	
				u16 di;
				u8 cmd_data;
				u8 ix;
				static struct rtc_time_t	tm;	//时标
				const char *cmd_str[]={"选择    ","执行    ","撤销    ","选择确认","执行确认","撤销确认","否定应答","执行结束"};
				const char *cmd_ch[]={"分","合"};
				
				readListData(&coList,i+1,tmp_buf);
				Swap_16_memcpy((BYTE*)&di,tmp_buf);	// modify for am335x  xxxxxx 
				memcpy(&tm,tmp_buf+2,8);
				memcpy(&cmd_data,tmp_buf+10,1);
				memcpy(&ix,tmp_buf+11,1);

				if(ix>=8||cmd_data>1)
				{
					rt_free(p_file);
					return -5;
				}

				if(i == coList.listNum-1)
				{
				#ifdef FUNC_HISTORY_UTF8_FORMAT		
					j = sprintf(p,"第%04d条遥控操作记录:0x%04x,%s,%s,%04d-%02d-%02d %02d:%02d:%02d.%03d",
									i+1,
									di,
									cmd_str[ix],
									cmd_ch[cmd_data],
									tm.year+2000,
									tm.month,
									tm.day,
									tm.hour,
									tm.min,
									tm.ms/1000,
									tm.ms%1000);
				#else
					j = sprintf(p,"第%04d条遥控操作记录：0x%04x,%s,%s,%04d-%02d-%02d %02d:%02d:%02d.%03d",
									i+1,
									di,
									cmd_str[ix],
									cmd_ch[cmd_data],
									tm.year+2000,
									tm.month,
									tm.day,
									tm.hour,
									tm.min,
									tm.ms/1000,
									tm.ms%1000);
				#endif			
				}
				else
				{
				#ifdef FUNC_HISTORY_UTF8_FORMAT		
					j = sprintf(p,"第%04d条遥控操作记录:0x%04x,%s,%s,%04d-%02d-%02d %02d:%02d:%02d.%03d\r\n",
									i+1,
									di,
									cmd_str[ix],
									cmd_ch[cmd_data],
									tm.year+2000,
									tm.month,
									tm.day,
									tm.hour,
									tm.min,
									tm.ms/1000,
									tm.ms%1000);

				#else
					j = sprintf(p,"第%04d条遥控操作记录：0x%04x,%s,%s,%04d-%02d-%02d %02d:%02d:%02d.%03d\r\n",
									i+1,
									di,
									cmd_str[ix],
									cmd_ch[cmd_data],
									tm.year+2000,
									tm.month,
									tm.day,
									tm.hour,
									tm.min,
									tm.ms/1000,
									tm.ms%1000);
				#endif
				}

				
									
				p += j;

			}
				
		}

	
		*p = 0x0A;	//一个ASCII“文件结束”（EOF）标志（“/A”HEX）
		p += 1;
	}
	else
	{
		j = sprintf(p,"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"); //文件头
		p += j;
		
		j = sprintf(p,"<DataFile>\r\n"); 
	 	p += j;

		if(!set_get_fixed_arg(FIXED_SET_TPE,tmp_buf, 32)==0)
		{
			strcpy(tmp_buf,"FYD830");
		}

		if(type == HS_FILE_SOE)
		{
			j = sprintf(p," <Header fileType=\"SOE\" fileVer=\"1.00\" devName=\"%s\" />\r\n",tmp_buf); 
	 		p += j;
		}
		else if(type == HS_FILE_CO)
		{
			j = sprintf(p," <Header fileType=\"CO\" fileVer=\"1.00\" devName=\"%s\" />\r\n",tmp_buf); 
	 		p += j;
		}

		event_rcd_file[type].num_pos = p-p_file;

		j = sprintf(p," <DataRec num=\"%04d\">\r\n",rcd_num);
		p += j;

		event_rcd_file[type].num_pos += strlen(" <DataRec num=\"");

		if(type == HS_FILE_SOE)
		{
			for(i=0;i<soeList.listNum;i++)
			{
				u16 di;
				static struct rtc_time_t	tm;	//时标
				u8 SIQ;
		
				readListData(&soeList,i+1,tmp_buf);

				Swap_16_memcpy((BYTE*)&di,tmp_buf);	// modify for am335x  xxxxxx 
				memcpy(&tm,tmp_buf+2,8);
				memcpy(&SIQ,tmp_buf+10,1);
				
				j = sprintf(p,"  <DI ioa=\"%d\" tm=\"%02d%02d%02d_%02d%02d%02d_%03d\" val=\"%d\" />\r\n",
									di,
									tm.year,
									tm.month,
									tm.day,
									tm.hour,
									tm.min,
									tm.ms/1000,
									tm.ms%1000,
									SIQ);
				p += j;
			
			}
		}
		else if(type == HS_FILE_CO)
		{
			for(i=0;i<coList.listNum;i++)
			{
				u16 di;
				u8 cmd_data;
				u8 ix;
				static struct rtc_time_t	tm;	//时标
				const char *cmd_str[]={"select","oper","cancle","select confirm","oper confirm","cancle confirm","nack","oper finish"};

				readListData(&coList,i+1,tmp_buf);
				Swap_16_memcpy((BYTE*)&di,tmp_buf);	// modify for am335x  xxxxxx 
				memcpy(&tm,tmp_buf+2,8);
				memcpy(&cmd_data,tmp_buf+10,1);
				memcpy(&ix,tmp_buf+11,1);

				if(ix>=8)
				{
					rt_free(p_file);
					return -5;
				}
				
				j = sprintf(p,"  <DI ioa=\"%d\" tm=\"%02d%02d%02d_%02d%02d%02d_%03d\" cmd=\"%s\" val=\"%d\" />\r\n",
									di,
									tm.year,
									tm.month,
									tm.day,
									tm.hour,
									tm.min,
									tm.ms/1000,
									tm.ms%1000,
									cmd_str[ix],
									cmd_data);
				p += j;
			}
		}

		j = sprintf(p," </DataRec>\r\n"); 
	 	p += j;

		j = sprintf(p,"</DataFile>\r\n"); 
	 	p += j;

	}

	file_len = p-p_file;

	if(type == HS_FILE_SOE)
	{
		sprintf(dir_name,"%s%s",HF_SOE_101_DIR,HF_SOE_FILENAME);
		memcpy(event_rcd_file[type].name,HF_SOE_FILENAME,strlen(HF_SOE_FILENAME));	
	}
	else if(type == HS_FILE_CO)
	{
		sprintf(dir_name,"%s%s",HF_CO_101_DIR,HF_YK_FILENAME);
		memcpy(event_rcd_file[type].name,HF_YK_FILENAME,strlen(HF_YK_FILENAME));
	}

	event_rcd_file[type].handle = rt_file_open(dir_name,O_CREAT|O_RDWR,0);

	if(IS_ERR(event_rcd_file[type].handle))
	{
		event_rcd_file[type].handle = 0;
		rt_printf("%s:%s open error!\r\n",__func__,event_rcd_file[type].name);
		rt_free(p_file);
		return -6;
	}

	pos = 0;

#ifdef FUNC_HISTORY_UTF8_FORMAT
	file_utf = rt_malloc(file_len*3); 
	if(!file_utf)
	{
		rt_free(p_file);
		return -3;
	}

	for(i=0;i<file_len;) 
	{
		if(p_file[i] <= 0x80)  //非汉字
		{	
			file_utf[k] = p_file[i];
			k++;
			i++;
			continue;
		}
		
		gb2312_code = p_file[i+1]|(p_file[i]<<8);
		utf8_code = GetHzUtf8ByFontLib(gb2312_code);
		if(utf8_code == 0)
		{
			rt_err_set(ERR_CODE_INIT_SOFTWARE,0);
			return false;
		}
		utf8[0] = ((utf8_code>>16)&0xFF);
		utf8[1] = ((utf8_code>>8)&0xFF);
		utf8[2] = (utf8_code&0xFF);
		memcpy(&file_utf[k],utf8,sizeof(utf8));
		k += 3;
		i += 2;
	}

	if(rt_file_write(event_rcd_file[type].handle,file_utf,k,&pos)!=k)
	{
		rt_free(p_file);
		rt_free(file_utf);
		return -4;
	}
#else
	if(rt_file_write(event_rcd_file[type].handle,p_file,file_len,&pos) != file_len)
	{
		rt_free(p_file);
		return -7;
	}
#endif

	rt_file_close(event_rcd_file[type].handle,0);

	//释放内存
	rt_free(p_file);

#ifdef FUNC_HISTORY_UTF8_FORMAT
	rt_free(file_utf);
#endif

	return 0;
	
}


/******************************************************************************
函数名称：	create_exv_rcd_file
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	创建极值文件,当天最初时刻创建，拷贝当前极值
参数说明：	
			p_info:文件信息
				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int create_exv_rcd_file(struct rcd_file_info *p_info)
{
	unsigned int file_len=0;
	char *p,*p_file;
	loff_t pos;
	struct timespec ts;
	struct rtc_time_t tm;

	int ret = 0;
	int i,j,rcd_len=0;
	char dir_name[64]={0};
	u8 day =  p_info->file_num;
	
	char tmp_buf[64]={0};
	

	if(day>(EXV_FILE_NUM_MAX-1))
		return -1;

	//获取当前时间
	clk_time_get(&ts);
	timespec_to_rtc(ts,&tm,0);
	exv_rcd_file[day].create_time = tm;

	if(g_table_head->ac_num)//有遥测点号
	{
		if(pRunSet->bTT_MsgFile)
		{
			//其中-1为减去MSG_EXV_RCD_LEN定义多了一个逗号，
			//R_N_LEN 为 "\r\n"
			rcd_len = 2*(strlen("最大值：")+4+1+g_table_head->ac_num*MSG_EXV_RCD_LEN-1+R_N_LEN);
			// 得到文件长度 
			file_len = MSG_EXV_FILE_HEAD_LEN+rcd_len+EOF_LEN;	//最后一个字符为文件结束标志
			
		}
		else 
		{
			rcd_len = g_table_head->ac_num*XML_EXV_RCD_LEN;
			// 得到文件长度 
			file_len = XML_EXV_FILE_HEAD_LEN+rcd_len;	//最后一个字符为文件结束标志
		}
	}
	else
	{
		rcd_len = 0;
		// 得到文件长度 
		file_len = XML_EXV_FILE_HEAD_LEN+rcd_len;	//最后一个字符为文件结束标志
	}

	// 分配并初始化空间
	p_file = rt_malloc(file_len);
	
	if(!p_file)
	{
		return -2;
	}

	//极值文件的定义为 :exvXXXXXXXX.msg	表示为:文件前缀+年月日,	如:exv20170212
	memset(p_file,0,file_len);
	p = p_file;

	
	if(pRunSet->bTT_MsgFile)
	{
		sprintf(exv_rcd_file[day].name,"exv%04d%02d%02d.msg",
									tm.year+2000,
									tm.month,
									tm.day);
		j = sprintf(p,"文件头：%s,%s\r\n",exv_rcd_file[day].name,HIS_FILE_VER); //文件头
		p += j;

		
		set_get_fixed_arg(FIXED_SET_ID,tmp_buf, sizeof(tmp_buf));
		
		j = sprintf(p,"%.24s,%02d%02d%02d,02\r\n",
									tmp_buf,
									tm.year,
									tm.month,
									tm.day);
		p += j;

		
		if(g_table_head->ac_num)//有遥测点号
		{
			j = sprintf(p,"最大值：%04d,",g_table_head->ac_num);
			p += j;
			
			for(i=0;i<g_table_head->ac_num;i++)
			{
				if(i>=EXV_NUM_MAX)break;

				j = sprintf(p,"0x%04x,%09.3f,%04d-%02d-%02d %02d:%02d:%02d.%03d",
								exv_rcd.max_data[i].cp,
								exv_rcd.max_data[i].elem_val,
								exv_rcd.max_data[i].time_mark.year+2000,
								exv_rcd.max_data[i].time_mark.month,
								exv_rcd.max_data[i].time_mark.day,
								exv_rcd.max_data[i].time_mark.hour,
								exv_rcd.max_data[i].time_mark.min,
								exv_rcd.max_data[i].time_mark.ms/1000,
								exv_rcd.max_data[i].time_mark.ms%1000);
				p += j;

				if(i == g_table_head->ac_num-1)
				{
					sprintf(p,"\r\n");
					p+=2;
				}
				else
				{
					sprintf(p,",");
					p+=1;
				}
			}

	
			j = sprintf(p,"最小值：%04d,",g_table_head->ac_num);
			p += j;
			for(i=0;i<g_table_head->ac_num;i++)
			{
				if(i>=EXV_NUM_MAX)break;

				j = sprintf(p,"0x%04x,%09.3f,%04d-%02d-%02d %02d:%02d:%02d.%03d",
								exv_rcd.min_data[i].cp,
								exv_rcd.min_data[i].elem_val,
								exv_rcd.min_data[i].time_mark.year+2000,
								exv_rcd.min_data[i].time_mark.month,
								exv_rcd.min_data[i].time_mark.day,
								exv_rcd.min_data[i].time_mark.hour,
								exv_rcd.min_data[i].time_mark.min,
								exv_rcd.min_data[i].time_mark.ms/1000,
								exv_rcd.min_data[i].time_mark.ms%1000);
				p += j;

				if(i == g_table_head->ac_num-1)
				{
					sprintf(p,"\r\n");
					p += 2;
				}
				else
				{
					sprintf(p,",");
					p += 1;
				}
			}
		
			
		}
		
		*p = 0x0A;	//一个ASCII“文件结束”（EOF）标志（“/A”HEX）
		p += 1;
	
	}
	else
	{
		sprintf(exv_rcd_file[day].name,"exv%04d%02d%02d.xml",
									tm.year+2000,
									tm.month,
									tm.day);	
	
		j = sprintf(p,"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"); //文件头
		p += j;
		
		j = sprintf(p,"<DataFile>\r\n"); 
	 	p += j;

		if(!set_get_fixed_arg(FIXED_SET_TPE,tmp_buf, 32)==0)
		{
			strcpy(tmp_buf,"FYD830");
		}

		j = sprintf(p," <Header fileType=\"EXV\" fileVer=\"1.00\" devName=\"%s\" />\r\n",tmp_buf); 
	 	p += j;

		j = sprintf(p," <DataAttr num=\"%d\">\r\n",g_table_head->ac_num);
		p += j;

		for(i=0;i<g_table_head->ac_num;i++)
		{
			u8 no=g_ac_table[i].indexno;
			char cn_unit[16]={0};
			
			if(g_ac_table[i].owner == 0)// 公共测量值
			{
				if(no>=1)
					strcpy(cn_unit,g_unit[g_pub_ac_desc[no-1].unit].name);
			}
			else if(g_ac_table[i].owner <= SWITCH_NUM_MAX)
			{
				if(no>=1)
					strcpy(cn_unit,g_unit[g_sw_ac_desc[no-1].unit].name);
			}
			else if(g_ac_table[i].owner <= SWITCH_NUM_EXT) 
			{
			#ifdef PROTOCOL_PWRM_EN
				
				if((g_ac_table[i].link_cp == 100)
					||(g_ac_table[i].link_cp == 101))
				{
					strcpy(cn_unit,"V");
				}
				else if((g_ac_table[i].link_cp== 300)
					||(g_ac_table[i].link_cp == 301))
				{
					strcpy(cn_unit,"h");
				}
				else 
				{
					if(no>=1)
						strcpy(cn_unit,g_unit[g_sw_ac_desc[no-1].unit].name);
				}

			#else
				if(no>=1)
					strcpy(cn_unit,g_unit[g_sw_ac_desc[no-1].unit].name);
			#endif
				

			}

			if(is_chinese((const char *)cn_unit))	//如果单位里面有中文字符则显示空格
			{
				sprintf(cn_unit,"");
			}

			j = sprintf(p,"  <DI ioa=\"%d\" type=\"float\" unit=\"%s\" />\r\n",g_ac_table[i].cp,cn_unit);
			p += j;
			
		}

		j = sprintf(p," </DataAttr>\r\n");
		p += j;

		j = sprintf(p," <DataRec>\r\n");
		p += j;

		//下次更新极值文件的位置
		exv_rcd_file[day].offset = p-p_file;

		for(i=0;i<g_table_head->ac_num;i++)
		{
			if(i>=EXV_NUM_MAX)break;

			j = sprintf(p,"  <DI max=\"%09.3f\" max_tm=\"%02d%02d%02d_%02d%02d%02d\" min=\"%09.3f\" min_tm=\"%02d%02d%02d_%02d%02d%02d\" />\r\n",
							exv_rcd.max_data[i].elem_val,
							exv_rcd.max_data[i].time_mark.year,
							exv_rcd.max_data[i].time_mark.month,
							exv_rcd.max_data[i].time_mark.day,
							exv_rcd.max_data[i].time_mark.hour,
							exv_rcd.max_data[i].time_mark.min,
							exv_rcd.max_data[i].time_mark.ms/1000,
							exv_rcd.min_data[i].elem_val,
							exv_rcd.min_data[i].time_mark.year,
							exv_rcd.min_data[i].time_mark.month,
							exv_rcd.min_data[i].time_mark.day,
							exv_rcd.min_data[i].time_mark.hour,
							exv_rcd.min_data[i].time_mark.min,
							exv_rcd.min_data[i].time_mark.ms/1000);
			p += j;

		}

		j = sprintf(p," </DataRec>\r\n");
		p += j;

		j = sprintf(p,"</DataFile>\r\n");
		p += j;
		
	}

	
	file_len = p-p_file;

	sprintf(dir_name,"%s%s",HF_EXV_101_DIR,exv_rcd_file[day].name);	

	// 创建数据文件
	exv_rcd_file[day].handle = rt_file_open(dir_name,O_CREAT|O_RDWR,0);
	if(IS_ERR(exv_rcd_file[day].handle))
	{
		exv_rcd_file[day].handle = 0;
		rt_printf("%s:%s open error!\r\n",__func__,exv_rcd_file[day].name);
		rt_free(p_file);
		return -3;
	}
	
	pos = 0;
	if(rt_file_write(exv_rcd_file[day].handle,p_file,file_len,&pos) != file_len)
	{
		rt_free(p_file);
		return -4;
	}

	rt_file_close(exv_rcd_file[day].handle,0);
	rt_free(p_file);
	//创建成功，文件数加一
	p_info->file_num += 1;
	
	return ret;
}



/******************************************************************************
函数名称：	create_fixpt_rcd_file
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	创建定值文件，并且添加一条此时刻的节点记录，
参数说明：	
				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int create_fixpt_rcd_file(void)
{
	char *p,*p_file;
	loff_t pos;
	struct timespec ts;
	struct rtc_time_t tm;
	int i,j;
	int node_num;
	
	int file_len=0,rcd_len=0,num_pos=0;
	int ret = 0;

	char dir_name[64]={0};
	u8 day =  fixpt_file_info.file_num;
	char fixpt_pre[64]={0};
	char tmp_buf[64]={0};
	
	bool b_quarter=false;


	if(day>FIXPT_FILE_NUM_MAX-1)
		return -1;

	//获取当前时间
	clk_time_get(&ts);
	timespec_to_rtc(ts,&tm,0);

	fixpt_rcd_file[day].create_time = tm;

	if(pRunSet->wZDJG)
	{
		if((tm.min % pRunSet->wZDJG)==0)
			b_quarter = true;
	}

	node_num = b_quarter?1:0;//必须在新的一天的零十零分才记录第一个节点

	if(pRunSet->bTT_MsgFile)
	{
		if(g_table_head->ac_num&&b_quarter)
		{
			file_len = R_N_LEN;//下面代码会先装入"\r\n"
			//从第一个节点开始记
			sprintf(fixpt_pre,"第%02d节定点数据：%04d,%04d-%02d-%02d %02d:%02d:%02d.%03d,",	
								1,
								g_table_head->ac_num,
								tm.year+2000,
								tm.month,
								tm.day,
								tm.hour,
								tm.min,
								tm.ms/1000,
								tm.ms%1000);
			
			//1节点数据
			rcd_len = strlen(fixpt_pre)+g_table_head->ac_num*MSG_FIX_RCD_LEN;	
		}
		else
		{
			rcd_len = 0;
		}

		// 得到文件长度 
		file_len += rcd_len+MSG_FIX_FILE_HEAD_LEN;
		file_len -= 1;//MSG_FIX_RCD_LEN 的定义会在最后多了一个逗号
		file_len += EOF_LEN;//一个ASCII“文件结束”（EOF）标志（“/A”HEX）

	}
	else
	{
		if(g_table_head->ac_num)
		{
			//从第一个节点开始记,1节点数据
			rcd_len = XML_FIX_DATAREC_LEN+g_table_head->ac_num*XML_FIX_SECT_LEN;
		}
		else
		{
			rcd_len = 0;
		}
		// 得到文件长度 
		file_len = rcd_len+XML_FIX_FILE_FIX_LEN+g_table_head->ac_num*XML_FIX_ATTR_LEN;
	}

	// 分配并初始化空间
	p_file = rt_malloc(file_len); 
	if(!p_file)
	{
		return -2;
	}
	memset(p_file,0,file_len);
	p=p_file;
	
	if(pRunSet->bTT_MsgFile)
	{
		sprintf(fixpt_rcd_file[day].name,"fixpt%04d%02d%02d.msg",
									tm.year+2000,
									tm.month,
									tm.day);
		
		j = sprintf(p,"文件头：%s,%s\r\n",fixpt_rcd_file[day].name,HIS_FILE_VER); //文件头
		p += j;

		set_get_fixed_arg(FIXED_SET_ID,tmp_buf, sizeof(tmp_buf));

		j = sprintf(p,"%.24s,%02d%02d%02d,%03d,02",
									tmp_buf,
									tm.year,
									tm.month,
									tm.day,
									node_num);
		p += j;

		if(b_quarter)
		{
			if(g_table_head->ac_num)
			{

				j = sprintf(p,"\r\n");			
				p += j;
				
				j = sprintf(p,"%s",fixpt_pre);
				p += j;

				//加载定点记录
				for(i = 0;i<g_table_head->ac_num;i++)
				{
					if(i>=FIXPT_RCD_NUM)
						break;	
					
					j = sprintf(p,"0x%04x,%09.3f",
									fixpt_rcd.data[i].cp,
									fixpt_rcd.data[i].elem_val);
					p += j;

					if(i == g_table_head->ac_num-1)
					{
						//sprintf(p,"\r\n");
						//p+=2;
					}
					else
					{
						sprintf(p,",");
						p+=1;
					}
				}

			}
		}
		fixpt_rcd_file[day].offset = p-p_file;
		*p = 0x0A;	//一个ASCII“文件结束”（EOF）标志（“/A”HEX）
		p += 1;
		
	}
	else
	{
		sprintf(fixpt_rcd_file[day].name,"fixpt%04d%02d%02d.xml",
									tm.year+2000,
									tm.month,
									tm.day);
		
		j = sprintf(p,"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"); //文件头
		p += j;
		
		j = sprintf(p,"<DataFile>\r\n"); 
	 	p += j;

		if(!set_get_fixed_arg(FIXED_SET_TPE,tmp_buf, 32)==0)
		{
			strcpy(tmp_buf,"FYD830");
		}
		j = sprintf(p," <Header fileType=\"FIXPT\" fileVer=\"1.00\" devName=\"%s\" />\r\n",tmp_buf); 
	 	p += j;

		num_pos = p-p_file;
		j = sprintf(p," <DataAttr dataNum=\"%04d\" sectNum=\"%03d\" interval=\"%02dmin\">\r\n",g_table_head->ac_num,node_num,pRunSet->wZDJG);
		p += j;

		num_pos += strlen(" <DataAttr dataNum=\"1024\" sectNum=\"");
		
		for(i=0;i<g_table_head->ac_num;i++)
		{
			u8 no=g_ac_table[i].indexno;
			char cn_unit[16]={0};
			
			if(g_ac_table[i].owner == 0)// 公共测量值
			{
				if(no>=1)
					strcpy(cn_unit,g_unit[g_pub_ac_desc[no-1].unit].name);
			}
			else if(g_ac_table[i].owner <= SWITCH_NUM_MAX)
			{
				if(no>=1)
					strcpy(cn_unit,g_unit[g_sw_ac_desc[no-1].unit].name);
			}
			else if(g_ac_table[i].owner <= SWITCH_NUM_EXT)
			{
				#ifdef PROTOCOL_PWRM_EN
					if((g_ac_table[i].link_cp == 100)
					||(g_ac_table[i].link_cp == 101))
					{
						strcpy(cn_unit,"V");
					}
					else if((g_ac_table[i].link_cp== 300)
						||(g_ac_table[i].link_cp == 301))
					{
						strcpy(cn_unit,"h");
					}
					else 
					{
						if(no>=1)
							strcpy(cn_unit,g_unit[g_sw_ac_desc[no-1].unit].name);
					}
				#else
					if(no>=1)
						strcpy(cn_unit,g_unit[g_sw_ac_desc[no-1].unit].name);
				#endif
			}

			if(is_chinese((const char *)cn_unit))	//如果单位里面有中文字符则显示空格
			{
				sprintf(cn_unit,"");
			}

			j = sprintf(p,"  <DI ioa=\"%d\" type=\"float\" unit=\"%s\" />\r\n",g_ac_table[i].cp,cn_unit);
			p += j;
		}
		j = sprintf(p," </DataAttr>\r\n");
		p += j;

		if(b_quarter&&g_table_head->ac_num)
		{
			j = sprintf(p," <DataRec sect=\"%d\" tm=\"%02d%02d%02d_%02d%02d%02d\">\r\n",
								1,
								tm.year,
								tm.month,
								tm.day,
								tm.hour,
								tm.min,
								tm.ms/1000);		
			p += j;		

			for(i=0;i<g_table_head->ac_num;i++)
			{
				j = sprintf(p,"<DI val=\"%09.3f\" />\r\n",fixpt_rcd.data[i].elem_val);
				p += j;	
			}

			j = sprintf(p," /<DataRec>\r\n");
			p += j;
			
		}

		//下次更新定点文件的位置
		fixpt_rcd_file[day].offset = p-p_file;

		j = sprintf(p,"</DataFile>\r\n");
		p += j;
		
	}

	file_len = p-p_file;

	sprintf(dir_name,"%s%s",HF_FIXPT_101_DIR,fixpt_rcd_file[day].name);

	// 创建数据文件
	fixpt_rcd_file[day].handle = rt_file_open(dir_name,O_CREAT|O_RDWR,0);
	if(IS_ERR(fixpt_rcd_file[day].handle))
	{
		fixpt_rcd_file[day].handle = 0;
		rt_printf("%s:%s open error!\r\n",__func__,fixpt_rcd_file[day].name);
		rt_free(p_file);
		return -3;
	}
	
	pos = 0;
	
	if(rt_file_write(fixpt_rcd_file[day].handle,p_file,file_len,&pos)!=file_len)
	{
		rt_free(p_file);
		return -4;
	}

	rt_file_close(fixpt_rcd_file[day].handle,0);


	rt_free(p_file);

	fixpt_file_info.file_num += 1;

	fixpt_rcd_file[day].num_pos = num_pos;//节点个数的位置

	if(b_quarter)
	{
		fixpt_file_info.part_id = 1;	//从0个节点开始计
	}
	else
	{
		fixpt_file_info.part_id = 0;	//从0个节点开始计
	}

	return ret;

}





/******************************************************************************
函数名称：	create_frz_rcd_file
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-12-21
函数说明：	创建日冻结电能量记录文件，并且添加一条此时刻的节点记录，
参数说明：
				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int create_frz_rcd_file(void)
{
	unsigned int file_len,rcd_len=0;
	char *p,*p_file;
	loff_t pos;
	struct timespec ts;
	struct rtc_time_t tm;
	int i,j;
	int sect_num=0;
	bool b_newday=false;
	int num_pos=0;
	int ret = 0;
	char dir_name[64]={0},fix_frz[64] = {0},day_frz[64] ={0},tmp_buf[32]={0};
	u8 day =  frz_file_info.file_num;
	bool b_quarter=false;

	if(day>=FRZ_FILE_NUM_MAX)
		return -1;

	file_len = 0;

	//获取当前时间
	clk_time_get(&ts);
	timespec_to_rtc(ts,&tm,0);
	frz_rcd_file[day].create_time = tm;
	if(pRunSet->bTT_MsgFile)
	{
		sprintf(frz_rcd_file[day].name,"frz%04d%02d%02d.msg",
									tm.year+2000,
									tm.month,
									tm.day);
	}
	else
	{
		sprintf(frz_rcd_file[day].name,"frz%04d%02d%02d.xml",
									tm.year+2000,
									tm.month,
									tm.day);	
	}
	
	if(pRunSet->bTT_MsgFile)
	{
		//15分钟冻结
		if(((tm.min%pRunSet->wDDJG)==0)&&frz_rcd.min_frz_num)//必须在整点时刻更十五分钟新冻结
		{
			b_quarter = true;
			sect_num = 1;
			//从第一个节点开始记
			sprintf(fix_frz,"第01节冻结数据：%04d,%04d-%02d-%02d %02d:%02d:%02d.%03d,",	
								frz_rcd.min_frz_num,
								tm.year+2000,
								tm.month,
								tm.day,
								tm.hour,
								tm.min,
								tm.ms/1000,
								tm.ms%1000);
			
			//1节点数据
			rcd_len = strlen(fix_frz)+frz_rcd.min_frz_num*MSG_FRZ_RCD_LEN;	//0x1234,10000.123,
			rcd_len += R_N_LEN;//下面代码会先装入"\r\n"
			rcd_len -= 1;//MSG_FRZ_RCD_LEN 的定义会在最后多了一个逗号
		}

		//日冻结,必须在新的一天的零十零分才记录日冻结
		if((tm.hour==0)&&(tm.min==0)&&frz_rcd.day_frz_num)
		{
			b_newday = true;
			sect_num += 2;
			sprintf(day_frz,"第%02d节冻结数据：%04d,%04d-%02d-%02d %02d:%02d:%02d.%03d,",	
								b_quarter?2:1,
								frz_rcd.min_frz_num,
								tm.year+2000,
								tm.month,
								tm.day,
								tm.hour,
								tm.min,
								tm.ms/1000,
								tm.ms%1000);
			rcd_len += strlen(day_frz)+frz_rcd.day_frz_num*MSG_FRZ_RCD_LEN;
			rcd_len += R_N_LEN;//下面代码会先装入"\r\n"
			rcd_len -= 1;//MSG_FRZ_RCD_LEN 的定义会在最后多了一个逗号

		}

		// 得到文件长度 
		
		file_len += rcd_len+MSG_FRZ_FILE_HEAD_LEN;//最后一个字符为文件结束标志
		file_len += EOF_LEN;//一个ASCII“文件结束”（EOF）标志（“/A”HEX）

	}
	else
	{
		//15分钟冻结
		if(((tm.min%pRunSet->wDDJG)==0)&&frz_rcd.min_frz_num)//必须在整点时刻更十五分钟新冻结
		{
			b_quarter = true;
			sect_num = 1;
			//从第一个节点开始记,1节点数据
			rcd_len = XML_FRZ_MIN_DATAREC_LEN+frz_rcd.min_frz_num*XML_FRZ_SECT_LEN;
			
		}

		//日冻结,必须在新的一天的零十零分才记录日冻结
		if((tm.hour==0)&&(tm.min==0)&&frz_rcd.day_frz_num)
		{
			b_newday = true;
			sect_num += 2;
			//日冻结节点数据
			rcd_len += (XML_FRZ_DAY_DATAREC_LEN+frz_rcd.min_frz_num*XML_FRZ_SECT_LEN);
			
		}

		// 得到文件长度 
		file_len = rcd_len+XML_FRZ_FILE_FIX_LEN + g_table_head->dd_num*XML_FRZ_ATTR_LEN;
	}
	
	// 分配并初始化空间
	p_file = rt_malloc(file_len); 
	if(!p_file)
	{
		return -2;
	}
	memset(p_file,0,file_len);

	p=p_file;
	if(pRunSet->bTT_MsgFile)
	{
		if(set_get_fixed_arg(FIXED_SET_ID,tmp_buf, sizeof(tmp_buf)) == 0)	
		{
			if(strlen(tmp_buf)!=24)
			{
				strcpy(tmp_buf,"XXXXXXXXXXXXXXXXXXXXXXXX");
			}
		}
		else
		{
			strcpy(tmp_buf,"XXXXXXXXXXXXXXXXXXXXXXXX");
		}
		
		j = sprintf(p,"文件头：%s,%s\r\n%s,%02d%02d%02d,%03d,02",
						frz_rcd_file[day].name,
						HIS_FILE_VER,
						tmp_buf,
						tm.year,
						tm.month,
						tm.day,
						sect_num); 								
		p += j;

		if(b_quarter)
		{
			j = sprintf(p,"%s",fix_frz);
			p += j;
			
			for(i=0;i<frz_rcd.min_frz_num;i++)
			{
				if(frz_rcd.min_frz_num >  SW_DD_NUM_ALL)
					break;

				if(i==0)
				{	
					//浮点数
					j = sprintf(p,"\r\n");			
					p += j;
				}

				if(i == frz_rcd.min_frz_num-1)
				{
					//浮点数
					j = sprintf(p,"0x%04x,%09.3f",
								frz_rcd.min_data[i].cp,
								frz_rcd.min_data[i].elem_val);
					p += j;
				}
				else
				{
					//浮点数
					j = sprintf(p,"0x%04x,%09.3f,",
								frz_rcd.min_data[i].cp,
								frz_rcd.min_data[i].elem_val);
					p += j;
				}
				
				
			}
		}

		//下次更新十五分钟冻结文件的位置
		frz_rcd_file[day].offset = p-p_file;

		if(b_newday)
		{
			j = sprintf(p,"%s",day_frz);
			p += j;
			
			for(i = 0;i<frz_rcd.day_frz_num;i++)
			{
				if(frz_rcd.day_frz_num >  SW_DD_NUM_ALL)
					break;

				if(i==0)
				{	
					//浮点数
					j = sprintf(p,"\r\n");			
					p += j;
				}

				if(i == frz_rcd.day_frz_num-1)
				{
					//浮点数
					j = sprintf(p,"0x%04x,%09.3f",
								frz_rcd.day_data[i].cp,
								frz_rcd.day_data[i].elem_val);
					p += j;
				}
				else
				{
					//浮点数
					j = sprintf(p,"0x%04x,%09.3f,",
								frz_rcd.day_data[i].cp,
								frz_rcd.day_data[i].elem_val);
					p += j;
				}
				
				
			}
		}

		*p = 0x0A;	//一个ASCII“文件结束”（EOF）标志（“/A”HEX）
		p += 1;

	}
	else
	{
		
		j = sprintf(p,"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"); //文件头
		p += j;
	
		j = sprintf(p,"<DataFile>\r\n"); 
		p += j;
	
		if(!set_get_fixed_arg(FIXED_SET_TPE,tmp_buf, 32)==0)
		{
			strcpy(tmp_buf,"FYD830");
		}
		j = sprintf(p," <Header fileType=\"FRZ\" fileVer=\"1.00\" devName=\"%s\" />\r\n",tmp_buf); 
		p += j;
	
		num_pos = p-p_file;
		j = sprintf(p," <DataAttr type=\"FixFrz\" dataNum=\"%04d\" sectNum=\"%03d\" interval=\"%02dmin\">\r\n",frz_rcd.min_frz_num,sect_num,pRunSet->wZDJG);
		p += j;
	
		num_pos += strlen(" <DataAttr type=\"FixFrz\" dataNum=\"1024\" sectNum=\"");
	
		for(i=0;i<g_table_head->dd_num;i++)
		{
			u8 no=g_dd_table[i].indexno;
			char cn_unit[16]={0};
	
			if((g_dd_table[i].indexno >= (SW_DD_15M1+1))&&(g_dd_table[i].indexno <= (SW_DD_15M8+1)))
			{
				strcpy(cn_unit,g_unit[g_dd_desc[no-1].unit].name);
				j = sprintf(p,"  <DI ioa=\"%d\" type=\"float\" unit=\"%s\" />\r\n",g_dd_table[i].cp,cn_unit);
				p += j;
			}
			
		}
		
		j = sprintf(p," </DataAttr>\r\n");
		p += j;
	
		j = sprintf(p," <DataAttr type=\"DayFrz\" dataNum=\"%04d\">\r\n",frz_rcd.min_frz_num);
		p += j;
	
		for(i=0;i<g_table_head->dd_num;i++)
		{
			u8 no=g_dd_table[i].indexno;
			char cn_unit[16]={0};
	
			if((g_dd_table[i].indexno >= (SW_DD_DAY1+1))&&(g_dd_table[i].indexno <= (SW_DD_DAY8+1)))
			{	
				strcpy(cn_unit,g_unit[g_dd_desc[no-1].unit].name);
				
				j = sprintf(p,"  <DI ioa=\"%d\" type=\"float\" unit=\"%s\" />\r\n",g_dd_table[i].cp,cn_unit);
				p += j;
			}
	
		}
	
		j = sprintf(p," </DataAttr>\r\n");
		p += j;
	
	
		if(b_quarter&&frz_rcd.min_frz_num)
		{
			j = sprintf(p," <DataRec sect=\"%d\" tm=\"%02d%02d%02d_%02d%02d%02d\">\r\n",
								1,
								tm.year,
								tm.month,
								tm.day,
								tm.hour,
								tm.min,
								tm.ms/1000); 	
			p += j; 	
	
			for(i=0;i<frz_rcd.min_frz_num;i++)
			{
				j = sprintf(p,"  <DI val=\"%09.3f\" />\r\n",frz_rcd.min_data[i].elem_val);
				p += j; 
			}
	
			j = sprintf(p," /<DataRec>\r\n");
			p += j;
		}
	
		//下次更新十五分钟冻结文件的位置
		frz_rcd_file[day].offset = p-p_file;
	
		//
		if(b_newday&&frz_rcd.day_frz_num)
		{
			j = sprintf(p," <DataRec type=\"DayFrz\" tm=\"%02d%02d%02d_%02d%02d%02d\">\r\n",
								tm.year,
								tm.month,
								tm.day,
								tm.hour,
								tm.min,
								tm.ms/1000); 	
			p += j; 	
	
	
			for(i=0;i<frz_rcd.day_frz_num;i++)
			{
				j = sprintf(p,"<  DI val=\"%09.3f\" />\r\n",frz_rcd.day_data[i].elem_val);
				p += j; 
			}
	
			j = sprintf(p," /<DataRec>\r\n");
			p += j;
		}
	
		j = sprintf(p,"</DataFile>\r\n");
		p += j;
		
	}

	file_len = p-p_file;
				
	sprintf(dir_name,"%s%s",HF_FRZ_101_DIR,frz_rcd_file[day].name);
	// 创建数据文件
	frz_rcd_file[day].handle = rt_file_open(dir_name,O_CREAT|O_RDWR,0);
	if(IS_ERR(frz_rcd_file[day].handle))
	{
		frz_rcd_file[day].handle = 0;
		rt_printf("%s:%s open error!\r\n",__func__,frz_rcd_file[day].name);
		rt_free(p_file);
		return -3;
	}
	
	pos = 0;
	if(rt_file_write(frz_rcd_file[day].handle,p_file,file_len,&pos)!=file_len)
	{
		rt_free(p_file);
		return -4;
	}

	rt_file_close(frz_rcd_file[day].handle,0);

	rt_free(p_file);
	
	frz_rcd_file[day].len = file_len;
	frz_rcd_file[day].node_num = sect_num;
	frz_rcd_file[day].num_pos = num_pos;//节点个数的位置

	frz_file_info.file_num += 1;
	frz_file_info.part_id = sect_num; //b_quarter?1:0;
	

	return ret;
}



/******************************************************************************
函数名称：	create_flowrev_rcd_file
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-12-21
函数说明：	创建功率反向电能量冻结值记录文件，并且添加一条此时刻的节点记录，
			
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int create_flowrev_rcd_file(void)
{
	unsigned int file_len;
	char *p,*p_file;
	loff_t pos;
	struct timespec ts;
	struct rtc_time_t tm;
	int i,j;
	int ret = 0;

	char dir_name[64],tmp_buf[128];

	
	//获取当前时间
	clk_time_get(&ts);
	timespec_to_rtc(ts,&tm,0);

	if(pRunSet->bTT_MsgFile)
	{	
		//得到文件长度 
		file_len = MSG_FLOWREV_FILE_HEAD_LEN +  flowrevList.listNum * (strlen("第001节冻结数据：007,") + 8*MSG_FLOWREV_RCD_LEN + 1 ) + 1;//最后一个字符为文件结束标志
	}
	else
	{
		//得到文件长度 
		file_len = XML_FLOWREV_FILE_HEAD_LEN + flowrevList.listNum * 8 * XML_FLOWREV_RCD_LEN;	
	}
	
	// 分配并初始化空间
	p_file = rt_malloc(file_len); 
	if(!p_file)
	{
		return -1;
	}
	memset(p_file,0,file_len);

	flowrev_rcd_file.create_time = tm;
	sprintf(flowrev_rcd_file.name,HF_FLOWREV_FILENAME);
	sprintf(dir_name,"%s%s",HF_FLOWREV_101_DIR,flowrev_rcd_file.name);

	p=p_file;
	if(pRunSet->bTT_MsgFile)
	{
		if(set_get_fixed_arg(FIXED_SET_ID,tmp_buf, sizeof(tmp_buf)) == 0)	
		{
			if(strlen(tmp_buf)!=24)
			{
				strcpy(tmp_buf,"XXXXXXXXXXXXXXXXXXXXXXXX");
			}
		}
		else
		{
			strcpy(tmp_buf,"XXXXXXXXXXXXXXXXXXXXXXXX");
		}
		
		j = sprintf(p,"文件头：%s,%s\r\n%s,%02d%02d%02d,02\r\n",
						HF_FLOWREV_FILENAME,
						HIS_FILE_VER,
						tmp_buf,
						tm.year,
						tm.month,
						tm.day);//一个ASCII“文件结束”（EOF）标志（“/A”HEX）
		p += j;

		flowrev_rcd_file.offset = p-p_file;
		
		for(i=0;i<flowrevList.listNum;i++)
		{
			u16 di;
			int k;
			static struct rtc_time_t	tm;	//时标
			float f_val;

			j = sprintf(p,"第%03d节定点数据：08,",i+1);
			p += j;
			
			readListData(&flowrevList,i+1,tmp_buf);
			
			//时标(8byte) + 8*(点号(2byte)+值(4byte))
			
			for(k=0;k<8;k++)
			{
				memcpy(&di,&tmp_buf[14*k],2);
				memcpy(&f_val,&tmp_buf[14*k+2],4);
				memcpy(&tm,&tmp_buf[14*k+2+4],8);
				
				j = sprintf(p,"0x%04x,%09.3f,%04d-%02d-%02d %02d:%02d:%02d.%03d",
								di,
								f_val,
								tm.year+2000,
								tm.month,
								tm.day,
								tm.hour,
								tm.min,
								tm.ms/1000,
								tm.ms%1000);
								
				p += j;

				if(k==7)
				{
					if(i!=flowrevList.listNum-1)
					{
						j = sprintf(p,"\r\n");
						p += j;
					}
					
				}
				else
				{
					j = sprintf(p,",");
					p += j;
				}
			}
		}

		*p = 0x0A;	//一个ASCII“文件结束”（EOF）标志（“/A”HEX）
		p += 1;
	}
	else
	{
		j = sprintf(p,"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"); //文件头
		p += j;
		
		j = sprintf(p,"<DataFile>\r\n"); 
	 	p += j;

		if(!set_get_fixed_arg(FIXED_SET_TPE,tmp_buf, 32)==0)
		{
			strcpy(tmp_buf,"FYD830");
		}

		j = sprintf(p," <Header fileType=\"EXV\" fileVer=\"1.00\" devName=\"%s\" />\r\n",tmp_buf); 
	 	p += j;

		j = sprintf(p," <DataRec num=\"%d\">\r\n",flowrevList.listNum*8);
		p += j;

		
		for(i=0;i<flowrevList.listNum;i++)
		{
			u16 di;
			int k;
			static struct rtc_time_t tm; //时标
			float f_val;
			
			readListData(&flowrevList,i+1,tmp_buf);
			

			for(k=0;k<8;k++)
			{
				memcpy(&di,&tmp_buf[14*k],2);
				memcpy(&f_val,&tmp_buf[14*k+2],4);
				memcpy(&tm,&tmp_buf[14*k+2+4],8);
				j = sprintf(p,"<DI ioa=\"%05d\" tm=\"%04d%02d%02d_%02d%02d%02d_%03d\" val=\"%09.3f\" />\r\n",
								di,
								tm.year,
								tm.month,
								tm.day,
								tm.hour,
								tm.min,
								tm.ms/1000,
								tm.ms%1000,
								f_val);
				p += j;				
			}
		}

		flowrev_rcd_file.offset = p-p_file;
		j = sprintf(p," </DataRec>\r\n");
		p += j;

		j = sprintf(p,"</DataFile>\r\n");
		p += j;
		
	}

	sprintf(dir_name,"%s%s",HF_FLOWREV_101_DIR,flowrev_rcd_file.name);
	// 创建数据文件
	flowrev_rcd_file.handle = rt_file_open(dir_name,O_CREAT|O_RDWR,0);
	if(IS_ERR(flowrev_rcd_file.handle))
	{
		flowrev_rcd_file.handle = 0;
		rt_printf("%s:%s open error!\r\n",__func__,flowrev_rcd_file.name);
		rt_free(p_file);
		return -2;
	}
	pos = 0;
	file_len = p-p_file;
	if(rt_file_write(flowrev_rcd_file.handle,p_file,file_len,&pos)!=file_len)
	{
		rt_free(p_file);
		return -3;
	}

	rt_file_close(flowrev_rcd_file.handle,0);
	flowrev_rcd_file.len = file_len;

	if(pRunSet->bTT_MsgFile)
	{
		flowrev_rcd_file.offset = pos-1;
	}

	rt_free(p_file);
	
	return ret;
}



int create_log_rcd_file(void)
{
	unsigned int file_len;
	unsigned char *p,*p_file;
	loff_t pos;
	int i,j;
	u8 type,value;

	struct timespec ts;
	struct rtc_time_t tm;
	int ret = 0;
	char dir_name[64] = {0};
	char tmp_buf[64]={88};
#ifdef FUNC_HISTORY_UTF8_FORMAT
	int k=0;
	u8 utf8[3];
	unsigned char *file_utf;
	u32 utf8_code;
	u16 gb2312_code;
#endif
		//获取当前时间
	clk_time_get(&ts);
	timespec_to_rtc(ts,&tm,0);

	if(pRunSet->bTT_MsgFile)
	{
		file_len = MSG_LOG_FILE_HEAD_LEN + logList.listNum*164 + 1;//一个ASCII“文件结束”（EOF）标志（“/A”HEX）
	}
	else
	{
		file_len = XML_LOG_FILE_HEAD_LEN + logList.listNum*XML_LOG_RCD_LEN;
	}

	// 分配并初始化空间
	p_file = rt_malloc(file_len); 
	if(!p_file)
	{
		return -1;
	}

	memset(p_file,0,file_len);

	p = p_file;

	if(pRunSet->bTT_MsgFile)
	{
		set_get_fixed_arg(FIXED_SET_ID,tmp_buf, sizeof(tmp_buf));
	#ifdef FUNC_HISTORY_UTF8_FORMAT
		j = sprintf(p,"文件头:%.24s,%04d\r\n",tmp_buf,logList.listNum); //文件头
	#else	
		j = sprintf(p,"文件头：%.24s,%04d\r\n",tmp_buf,logList.listNum); //文件头
	#endif	
		p += j;

		//类型编号(1byte)+值(1byte)+时标(8byte)
		for(i=0;i<logList.listNum;i++)
		{
			readListData(&logList,i+1,tmp_buf);
			memcpy(&type,tmp_buf,1);
			memcpy(&value,tmp_buf+1,1);
			memcpy(&tm,tmp_buf+2,8);
			if((type>LOG_TYPE_NUM)||(type==0))
				continue;

		#ifdef FUNC_HISTORY_UTF8_FORMAT
			j = sprintf(p,"第%04d条LOG:%02d,%04d-%02d-%02d %02d:%02d:%02d.%03d,%s,%d",
							i+1,
							type,
							tm.year+2000,
							tm.month,
							tm.day,
							tm.hour,
							tm.min,
							tm.ms/1000,
							tm.ms%1000,
							log_str_list[type-1],
							value);
		#else
			j = sprintf(p,"第%04d条LOG：%02d,%04d-%02d-%02d %02d:%02d:%02d.%03d,%s,%d",
							i+1,
							type,
							tm.year+2000,
							tm.month,
							tm.day,
							tm.hour,
							tm.min,
							tm.ms/1000,
							tm.ms%1000,
							log_str_list[type-1],
							value);
		#endif		
			p += j;

			if(i!=logList.listNum-1)
			{
				j = sprintf(p,"\r\n");			
				p += j;
			}
	
		}

		log_rcd_file.offset = p-p_file;

		*p = 0x0A;	//一个ASCII“文件结束”（EOF）标志（“/A”HEX）
		p += 1;
	}
	else
	{
		j = sprintf(p,"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"); //文件头
		p += j;
		
		j = sprintf(p,"<DataFile>\r\n"); 
	 	p += j;

		if(set_get_fixed_arg(FIXED_SET_ID,tmp_buf, sizeof(tmp_buf)) == 0)	
		{
			if(strlen(tmp_buf)!=24)
			{
				strcpy(tmp_buf,"XXXXXXXXXXXXXXXXXXXXXXXX");
			}
		}
		else
		{
			strcpy(tmp_buf,"XXXXXXXXXXXXXXXXXXXXXXXX");
		}
		
		j = sprintf(p," <Header fileType=\"Ulog\" fileVer=\"1.00\" devID=\"%s\" />\r\n",tmp_buf); 
	 	p += j;

		
		j = sprintf(p," <DataRec num=\"%04d\">\r\n",logList.listNum);
		p += j;
	
		for(i=0;i<logList.listNum;i++)
		{
			readListData(&logList,i+1,tmp_buf);
			memcpy(&type,tmp_buf,1);
			memcpy(&value,tmp_buf+1,1);
			memcpy(&tm,tmp_buf+2,8);
			if((type>LOG_TYPE_NUM)||(type==0))
				continue;
			
			j = sprintf(p,"<DI logType=\"%d\" tm=\"%02d%02d%02d_%02d%02d%02d_%03d\" txt=\"%s\" val=\"%d\"/>\r\n",
							type,
							tm.year+2000,
							tm.month,
							tm.day,
							tm.hour,
							tm.min,
							tm.ms/1000,
							tm.ms%1000,
							log_str_list[type-1],
							value);
			p += j;
		}

		log_rcd_file.offset = p-p_file;
		j = sprintf(p," </DataRec>\r\n");
		p += j;

		j = sprintf(p,"</DataFile>\r\n");
		p += j;
	}

	file_len = p-p_file;
	
	log_rcd_file.create_time = tm;
	sprintf(log_rcd_file.name,HF_LOG_FILENAME);
	sprintf(dir_name,"%s%s",HF_LOG_101_DIR,log_rcd_file.name);

	log_rcd_file.handle = rt_file_open(dir_name,O_CREAT|O_RDWR,0);
	
	if(IS_ERR(log_rcd_file.handle))
	{
		log_rcd_file.handle = 0;
		rt_printf("%s:%s open error!\r\n",__func__,log_rcd_file.name);
		rt_free(p_file);
		return -2;
	}

	pos = 0;
#ifdef FUNC_HISTORY_UTF8_FORMAT
	file_utf = rt_malloc(log_rcd_file.offset*3); 
	if(!file_utf)
	{
		rt_free(p_file);
		return -3;
	}

	for(i=0;i<log_rcd_file.offset;) 
	{
		if(p_file[i] <= 0x80)  //非汉字
		{	
			file_utf[k] = p_file[i];
			k++;
			i++;
			continue;
		}
		
		gb2312_code = p_file[i+1]|(p_file[i]<<8);
		utf8_code = GetHzUtf8ByFontLib(gb2312_code);
		if(utf8_code == 0)
		{
			rt_err_set(ERR_CODE_INIT_SOFTWARE,0);
			return false;
		}
		utf8[0] = ((utf8_code>>16)&0xFF);
		utf8[1] = ((utf8_code>>8)&0xFF);
		utf8[2] = (utf8_code&0xFF);
		memcpy(&file_utf[k],utf8,sizeof(utf8));
		k += 3;
		i += 2;
	}

	if(rt_file_write(log_rcd_file.handle,file_utf,k,&pos) != k)
	{
		rt_free(p_file);
		rt_free(file_utf);
		return -4;
	}
#else
	if(rt_file_write(log_rcd_file.handle,p_file,file_len,&pos)!=file_len)
	{
		rt_free(p_file);
		return -3;
	}
#endif

	rt_file_close(log_rcd_file.handle,0);

	//记录文件创建时间
	log_rcd_file.create_time.year = tm.year;
	log_rcd_file.create_time.month = tm.month;
	log_rcd_file.create_time.day = tm.day;
	
	//释放内存
	rt_free(p_file);

#ifdef FUNC_HISTORY_UTF8_FORMAT
	rt_free(file_utf);
#endif

	return ret;
}



/******************************************************************************
函数名称：	load_exv_file_rcd
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	加载极值文件记录
参数说明：	
			day:第几天,
				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int load_exv_file_rcd(u8 day)
{
	int i,j,rcd_len=0,file_len=0;
	loff_t pos = 0;
	char *p,*p_file;
	char dir_name[64] = {0};

	if(day >= EXV_FILE_NUM_MAX)
	{
		return -1;
	}
		
	if(exv_rcd_file[day].name==NULL)
	{
		return -2;
	}
	
	sprintf(dir_name,"%s%s",HF_EXV_101_DIR,exv_rcd_file[day].name);
	
	exv_rcd_file[day].handle = rt_file_open(dir_name,O_CREAT|O_RDWR,0);

	if(IS_ERR(exv_rcd_file[day].handle))
	{
		return -3;
	}

	if(g_table_head->ac_num)
	{
		if(pRunSet->bTT_MsgFile)
		{
			//4+1只的1为逗号
			//其中-1为减去MSG_EXV_RCD_LEN定义多了一个逗号，
			//R_N_LEN 为 "\r\n"
			rcd_len = 2*(4+1+g_table_head->ac_num*MSG_EXV_RCD_LEN-1+R_N_LEN);
			// 得到文件长度 
			file_len = rcd_len+2*strlen("最大值：");	//最后一个字符为文件结束标志
		}
		else 
		{
			rcd_len = g_table_head->ac_num*XML_EXV_RCD_LEN;
			// 得到文件长度
			file_len = XML_EXV_FILE_HEAD_LEN+rcd_len;	
		}
		
	}
	else
	{
		return 0;
	}

	// 分配并初始化空间
	p_file = rt_malloc(file_len); 
	if(!p_file)
	{
		return -4;
	}
	memset(p_file,0,file_len);

	p=p_file;

	if(pRunSet->bTT_MsgFile)
	{
		j = sprintf(p,"最大值：%04d,",g_table_head->ac_num);
		p += j;
		
		for(i=0;i<g_table_head->ac_num;i++)
		{
			if(i>=EXV_NUM_MAX)break;

			j = sprintf(p,"0x%04x,%09.3f,%04d-%02d-%02d %02d:%02d:%02d.%03d",
							exv_rcd.max_data[i].cp,
							exv_rcd.max_data[i].elem_val,
							exv_rcd.max_data[i].time_mark.year+2000,
							exv_rcd.max_data[i].time_mark.month,
							exv_rcd.max_data[i].time_mark.day,
							exv_rcd.max_data[i].time_mark.hour,
							exv_rcd.max_data[i].time_mark.min,
							exv_rcd.max_data[i].time_mark.ms/1000,
							exv_rcd.max_data[i].time_mark.ms%1000);
			p += j;

			if(i == g_table_head->ac_num-1)
			{
				sprintf(p,"\r\n");
				p+=2;
			}
			else
			{
				sprintf(p,",");
				p+=1;
			}
		}

		j = sprintf(p,"最小值：%04d,",g_table_head->ac_num);
		p += j;
		for(i=0;i<g_table_head->ac_num;i++)
		{
			if(i>=EXV_NUM_MAX)break;

			j = sprintf(p,"0x%04x,%09.3f,%04d-%02d-%02d %02d:%02d:%02d.%03d",
							exv_rcd.min_data[i].cp,
							exv_rcd.min_data[i].elem_val,
							exv_rcd.min_data[i].time_mark.year+2000,
							exv_rcd.min_data[i].time_mark.month,
							exv_rcd.min_data[i].time_mark.day,
							exv_rcd.min_data[i].time_mark.hour,
							exv_rcd.min_data[i].time_mark.min,
							exv_rcd.min_data[i].time_mark.ms/1000,
							exv_rcd.min_data[i].time_mark.ms%1000);
			p += j;

			if(i == g_table_head->ac_num-1)
			{
				sprintf(p,"\r\n");
				p += 2;
			}
			else
			{
				sprintf(p,",");
				p += 1;
			}
		}

		pos =  MSG_EXV_FILE_HEAD_LEN;
	
	}
	else 
	{
		for(i=0;i<g_table_head->ac_num;i++)
		{
			if(i>=EXV_NUM_MAX)continue;

			j = sprintf(p,"  <DI max=\"%09.3f\" max_tm=\"%02d%02d%02d_%02d%02d%02d\" min=\"%09.3f\" min_tm=\"%02d%02d%02d_%02d%02d%02d\" />\r\n",
							exv_rcd.max_data[i].elem_val,
							exv_rcd.max_data[i].time_mark.year,
							exv_rcd.max_data[i].time_mark.month,
							exv_rcd.max_data[i].time_mark.day,
							exv_rcd.max_data[i].time_mark.hour,
							exv_rcd.max_data[i].time_mark.min,
							exv_rcd.max_data[i].time_mark.ms/1000,
							exv_rcd.min_data[i].elem_val,
							exv_rcd.min_data[i].time_mark.year,
							exv_rcd.min_data[i].time_mark.month,
							exv_rcd.min_data[i].time_mark.day,
							exv_rcd.min_data[i].time_mark.hour,
							exv_rcd.min_data[i].time_mark.min,
							exv_rcd.min_data[i].time_mark.ms/1000);
			p += j;

		}
		
		j = sprintf(p," <DataRec>\r\n");
		p += j;
	
		j = sprintf(p,"</DataFile>\r\n");
		p += j;

		pos =  exv_rcd_file[day].offset;
		
	}
	
	file_len = p-p_file;

	if(rt_file_write(exv_rcd_file[day].handle, p_file, file_len, &pos) != file_len)		
	{
		rt_free(p_file);
		return -5;
	}

	rt_file_close(exv_rcd_file[day].handle,0);

	rt_free(p_file);
	
	return 0;

}


/******************************************************************************
函数名称：	load_fixpt_file_rcd
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	加载定点文件记录

			
				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int load_fixpt_file_rcd(void)
{
	
	char *p,*p_file;
	int i,j;
	int file_len,pre_len,rcd_len;
	int end_rcd_pos=0;
	u8 day;
	int ret = 0;
	char dir_name[64] = {0};
	char fixpt_pre[64]={0};
	loff_t pos=0;
	char id_str[8]={0};

	day = fixpt_file_info.file_num - 1;

	if((fixpt_file_info.file_num > FIXPT_FILE_NUM_MAX)||(fixpt_file_info.file_num==0))
		return -1;
	
	if(g_table_head->ac_num == 0)
		return -2;
	
	if(fixpt_rcd_file[day].name==NULL)
		return -3;
	

	if(pRunSet->bTT_MsgFile)
	{
		file_len = R_N_LEN;//下面代码会先装入"\r\n"
		sprintf(fixpt_pre,"第%02d节定点数据：%04d,%04d-%02d-%02d %02d:%02d:%02d.%03d,",
						(u8)(fixpt_file_info.part_id+1),
						g_table_head->ac_num,
						fixpt_rcd.time_bk.year+2000,
						fixpt_rcd.time_bk.month,
						fixpt_rcd.time_bk.day,
						fixpt_rcd.time_bk.hour,
						fixpt_rcd.time_bk.min,
						fixpt_rcd.time_bk.ms/1000,
						fixpt_rcd.time_bk.ms%1000);
						
		pre_len = strlen(fixpt_pre);
						
		// 1节点数据
		file_len += pre_len+g_table_head->ac_num*MSG_FIX_RCD_LEN;
		file_len -= 1;//MSG_FRZ_RCD_LEN的定义会在最后多了一个逗号

		file_len += EOF_LEN;//一个ASCII“文件结束”（EOF）标志（“/A”HEX）
	}
	else
	{
		//从第一个节点开始记,1节点数据
		rcd_len = XML_FIX_DATAREC_LEN+g_table_head->ac_num*XML_FIX_SECT_LEN;
	
		file_len = rcd_len+strlen("</DataFile>\r\n");
	}
	
	// 分配并初始化空间
	p_file = rt_malloc(file_len); 
	if(!p_file)
	{
		return -3;
	}
	memset(p_file,0,file_len);
	p = p_file;

	if(pRunSet->bTT_MsgFile)
	{
	
		sprintf(p,"\r\n");
		p+=2;
		
		j = sprintf(p,"%s",fixpt_pre);
		p += j;
	
		for(i = 0;i < g_table_head->ac_num; i++)
		{
			if(i>=FIXPT_RCD_NUM)continue;	

			
			
			j = sprintf(p,"0x%04x,%09.3f",
							fixpt_rcd.data[i].cp,
							fixpt_rcd.data[i].elem_val);
			p += j;

			

			if(i == g_table_head->ac_num-1)
			{
				//sprintf(p,"\r\n");
				//p+=2;
			}
			else
			{
				sprintf(p,",");
				p+=1;
			}
		}

		*p = 0x0A;	//一个ASCII“文件结束”（EOF）标志（“/A”HEX）
		p += 1;
	}
	else
	{
		j = sprintf(p," <DataRec sect=\"%d\" tm=\"%02d%02d%02d_%02d%02d%02d\">\r\n",
						fixpt_file_info.part_id+1,
						fixpt_rcd.time_bk.year,
						fixpt_rcd.time_bk.month,
						fixpt_rcd.time_bk.day,
						fixpt_rcd.time_bk.hour,
						fixpt_rcd.time_bk.min,
						fixpt_rcd.time_bk.ms/1000);		
		p += j;		

		for(i=0;i<g_table_head->ac_num;i++)
		{
			if(i>=FIXPT_RCD_NUM)continue;
			j = sprintf(p,"  <DI val=\"%09.3f\" />\r\n",fixpt_rcd.data[i].elem_val);
			p += j;	
		}

		j = sprintf(p," </DataRec>\r\n");
		p += j;

		end_rcd_pos = p-p_file;

		j = sprintf(p,"</DataFile>\r\n");
		p += j;
		
	}
	
	file_len = p-p_file;
	
	sprintf(dir_name,"%s%s",HF_FIXPT_101_DIR,fixpt_rcd_file[day].name);
	
	fixpt_rcd_file[day].handle = rt_file_open(dir_name,O_CREAT|O_RDWR,0);

	if(IS_ERR(fixpt_rcd_file[day].handle))
	{
		return -4;
	}

	pos = fixpt_rcd_file[day].offset;

	if(rt_file_write(fixpt_rcd_file[day].handle, p_file, file_len, &pos) != file_len)		
	{
		rt_free(p_file);
		return -5;
	}

	rt_free(p_file);

	fixpt_file_info.part_id += 1;
	sprintf(id_str,"%03d",fixpt_file_info.part_id);

	if(pRunSet->bTT_MsgFile)
	{
		fixpt_rcd_file[day].offset = pos - 1;
		//更新定点文件节点数量
		pos = MSG_FIX_PART_ID_OFFSET;
	}
	else
	{
		fixpt_rcd_file[day].offset += end_rcd_pos;
		//更新定点文件节点数量
		pos = fixpt_rcd_file[day].num_pos;
	}

	if(rt_file_write(fixpt_rcd_file[day].handle, id_str, strlen(id_str), &pos) != strlen(id_str))		
	{
		return -6;
	}

	rt_file_close(fixpt_rcd_file[day].handle,0);

	return ret;

}




/******************************************************************************
函数名称：	load_frz_file_rcd
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-12-12
函数说明：	加载日冻结电能量记录文件相关记录
参数说明：	p_info:文件信息
			
				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int load_frz_file_rcd(bool b_dayfrz)
{
	loff_t pos=0;
	int i,j;
	char *p,*p_file;
	int len = 0;
	u8 day;
	int end_rcd_pos=0;
	int ret=0;
	char id_str[8]={0};	
	char dir_name[64],fix_frz[64],day_frz[64]={0};

	if((frz_file_info.file_num > FIXPT_FILE_NUM_MAX)||(frz_file_info.file_num==0))
		return -1;
	
	day = frz_file_info.file_num - 1;
	
	if((!frz_rcd.min_frz_num)&&(!frz_rcd.day_frz_num))
		return -2;

	if(pRunSet->bTT_MsgFile)
	{
		len = R_N_LEN;//下面代码会先装入"\r\n"
		sprintf(fix_frz,"第%02d节冻结数据：%04d,%04d-%02d-%02d %02d:%02d:%02d.%03d,",
						frz_file_info.part_id+1,
						frz_rcd.min_frz_num,
						frz_rcd.tm.year+2000,
						frz_rcd.tm.month,
						frz_rcd.tm.day,
						frz_rcd.tm.hour,
						frz_rcd.tm.min,
						frz_rcd.tm.ms/1000,
						frz_rcd.tm.ms%1000);
		len += strlen(fix_frz)+frz_rcd.min_frz_num*MSG_FRZ_RCD_LEN;
		len -= 1;//MSG_FRZ_RCD_LEN的定义会在最后多了一个逗号
		
		frz_file_info.part_id+=1;
		
		if(b_dayfrz)
		{
			len += R_N_LEN;//下面代码会先装入"\r\n"
			sprintf(day_frz,"第%02d节冻结数据：%04d,%04d-%02d-%02d %02d:%02d:%02d.%03d,",
								frz_file_info.part_id+1,
								frz_rcd.day_frz_num,
								frz_rcd.tm.year+2000,
								frz_rcd.tm.month,
								frz_rcd.tm.day,
								frz_rcd.tm.hour,
								frz_rcd.tm.min,
								frz_rcd.tm.ms/1000,
								frz_rcd.tm.ms%1000);
			len += strlen(day_frz)+frz_rcd.day_frz_num*MSG_FRZ_RCD_LEN;
			len -= 1;//MSG_FRZ_RCD_LEN的定义会在最后多了一个逗号
			frz_file_info.part_id+=1;
		}

		len += EOF_LEN;//一个ASCII“文件结束”（EOF）标志（“/A”HEX）
	}
	else
	{
		//从第一个节点开始记,1节点数据
		len = XML_FRZ_MIN_DATAREC_LEN + frz_rcd.min_frz_num*XML_FRZ_SECT_LEN;
		if(b_dayfrz)
		{
			len += XML_FRZ_DAY_DATAREC_LEN + frz_rcd.day_frz_num*XML_FRZ_SECT_LEN;
		}

		len +=strlen("</DataFile>\r\n");
	}

	// 分配并初始化空间
	p_file = rt_malloc(len); 
	if(!p_file)
	{
		return -3;
	}
	memset(p_file,0,len);
	p = p_file;
	if(pRunSet->bTT_MsgFile)
	{
			
		j = sprintf(p,"\r\n");			
		p += j;

		j = sprintf(p,"%s",fix_frz);
		p += j;

		for(i = 0;i < frz_rcd.min_frz_num; i++)
		{
			j = sprintf(p,"0x%04x,%09.3f",
								frz_rcd.min_data[i].cp,
								frz_rcd.min_data[i].elem_val);
			p += j;

			if(i == frz_rcd.min_frz_num -1)
			{
				//j = sprintf(p,"%s","\r\n");
				//p += j;
			}
			else
			{
				j = sprintf(p,"%s",",");
				p += j;
			}
		}

		if(b_dayfrz)
		{

			j = sprintf(p,"%s","\r\n");
			p += j;
		
			j = sprintf(p,"%s",day_frz);
			p += j;

			for(i = 0;i < frz_rcd.day_frz_num; i++)
			{

				j = sprintf(p,"0x%04x,%09.3f",
									frz_rcd.day_data[i].cp,
									frz_rcd.day_data[i].elem_val);
				p += j;

				if(i == frz_rcd.day_frz_num -1)
				{
					//j = sprintf(p,"%s","\r\n");
					//p += j;
				}
				else
				{
					j = sprintf(p,"%s",",");
					p += j;
				}
			}
		}

		*p = 0x0A;	//一个ASCII“文件结束”（EOF）标志（“/A”HEX）
		p += 1;
	}
	else
	{
		j = sprintf(p," <DataRec sect=\"%d\" tm=\"%02d%02d%02d_%02d%02d%02d\">\r\n",
						frz_file_info.part_id+1,
						frz_rcd.tm.year,
						frz_rcd.tm.month,
						frz_rcd.tm.day,
						frz_rcd.tm.hour,
						frz_rcd.tm.min,
						frz_rcd.tm.ms/1000);		
		p += j;		
		frz_file_info.part_id+=1;

		for(i=0;i<frz_rcd.min_frz_num;i++)
		{
			if(i>=SW_DD_NUM_ALL)break;
			j = sprintf(p,"  <DI val=\"%09.3f\" />\r\n",frz_rcd.min_data[i].elem_val);
			p += j;	
		}

		j = sprintf(p," </DataRec>\r\n");
		p += j;

		if(b_dayfrz)
		{
			j = sprintf(p," <DataRec type=\"DayFrz\"tm=\"%02d%02d%02d_%02d%02d%02d\">\r\n",
						frz_rcd.tm.year,
						frz_rcd.tm.month,
						frz_rcd.tm.day,
						frz_rcd.tm.hour,
						frz_rcd.tm.min,
						frz_rcd.tm.ms/1000);
			p += j;

			for(i=0;i<frz_rcd.day_frz_num;i++)
			{
				if(i>=SW_DD_NUM_ALL)break;
				j = sprintf(p,"  <DI val=\"%09.3f\" />\r\n",frz_rcd.day_data[i].elem_val);
				p += j;	
			}

			j = sprintf(p," </DataRec>\r\n");
			p += j;
			
		}

		end_rcd_pos = p-p_file;

		j = sprintf(p,"</DataFile>\r\n");
		p += j;
		
	}

	if(frz_rcd_file[day].name == NULL)
	{	
		return -4;
	}
	
	sprintf(dir_name,"%s%s",HF_FRZ_101_DIR,frz_rcd_file[day].name);
	
	frz_rcd_file[day].handle = rt_file_open(dir_name,O_CREAT|O_RDWR,0);

	if(IS_ERR(frz_rcd_file[day].handle))
	{
		rt_free(p_file);
		return -5;
	}

	pos = frz_rcd_file[day].offset;//从文件结束符上添加
	len = p-p_file;

	if(rt_file_write(frz_rcd_file[day].handle, p_file, len, &pos) != len)		
	{
		rt_free(p_file);
		return -6;
	}

	rt_free(p_file);


	sprintf(id_str,"%03d",frz_file_info.part_id);
	if(pRunSet->bTT_MsgFile)
	{
		frz_rcd_file[day].offset = pos-1 ;
		//更新日冻结文件节点数量
		pos = MSG_FRZ_PART_ID_OFFSET;
	}
	else
	{
		frz_rcd_file[day].offset += end_rcd_pos;
		//更新日冻结文件节点数量
		pos = frz_rcd_file[day].num_pos;
	}

	//frz_rcd_file[day].offset = pos;
	//frz_rcd_file[day].len += len-1;
	
	sprintf(id_str,"%03d",frz_file_info.part_id);
	
	if(rt_file_write(frz_rcd_file[day].handle, id_str, strlen(id_str), &pos) != strlen(id_str))		
	{
		return -7;
	}

	rt_file_close(frz_rcd_file[day].handle,0);
	
	return ret;

}

void log_rcd_com_err_set(void)
{
	int i;
	static char hs_log[64]={0};

	for(i=0;i <COMM_CHANNEL_NUM;i++)
	{
		if(s_stat_rx_errframe_rc(i))
		{
			
			if(!log_flag.com_err[i])
			{
				if(i<CFG_UART_NUM_MAX)
				{
					
					sprintf(hs_log,"Serial port %d abnormal communication occurs",i+1);
				}
				else
				{
					sprintf(hs_log,"Network port %d abnormal communication occurs",i-CFG_UART_NUM_MAX+1);
				}

				load_hs_log_rcd(TYPE_COMM_ERR,true,NULL,hs_log,1);
	
				log_flag.com_err[i]  = true;
			}
			
		}
		
	}


}

void log_rcd_com_err_rst(int chnl)
{
	char hs_log[64]={0};
	
	if(log_flag.com_err[chnl])
	{
		if(chnl<CFG_UART_NUM_MAX)
		{
			sprintf(hs_log,"Serial port %d abnormal communication disappear",chnl+1);
		}
		else
		{
			sprintf(hs_log,"Network port %d abnormal communication disappear",chnl-CFG_UART_NUM_MAX+1);
		}

		load_hs_log_rcd(TYPE_COMM_ERR,true,NULL,hs_log,0);
		log_flag.com_err[chnl]  = false;
	}

}


void load_hs_log_rcd(u8 id,bool rtc_flag,struct rtc_time_t *p_tm,char *buf,u8 val)
{	
	struct rtc_time_t tm;
	struct timespec ts;
	
	log_st.log[log_st.head].id = id;
	log_st.log[log_st.head].val = val;

	if(rtc_flag)
	{
		//获取当前时间
		clk_time_get(&ts);
		timespec_to_rtc(ts,&tm,0);
		log_st.log[log_st.head].time = tm;
		
	}
	else
	{
		log_st.log[log_st.head].time = *p_tm;
	}

	memset(log_st.log[log_st.head].des_str,0,128);
	memcpy(log_st.log[log_st.head].des_str,buf,strlen(buf));
		
	log_st.head = (log_st.head+1)%LOG_NUM;

	if(log_st.head == log_st.tail)
	{
		log_st.tail = (log_st.tail+1)%LOG_NUM;
	}
}


bool log_file_app(void)
{
	int ret=0;
	char rcd_buf[64]={0};
	u8 tail=log_st.tail;

	if(log_st.head == log_st.tail)
		return true;

	memcpy(rcd_buf,&log_st.log[tail].id,1);
	memcpy(&rcd_buf[1],&log_st.log[tail].val,1);
	memcpy(&rcd_buf[2],&log_st.log[tail].time,8);
	writeListData(&logList,rcd_buf);

	log_st.tail = (log_st.tail+1)%LOG_NUM;

	if(log_st.head == log_st.tail)
	{
		ret = del_history_file(HS_FILE_LOG);
		if(!ret)
		{
			ret = create_log_rcd_file();
		}
	}

	return ret;
	
}




/******************************************************************************
函数名称：	get_exv_rcd_data
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	获得当下时刻的极值记录数据
参数说明：	

返回值：	
	
修改记录：	
*/
void get_exv_rcd_data(struct rtc_time_t time,bool day_change)
{
	int i;
	long lzero=0;


	for (i=0; i<g_table_head->ac_num; i++)
	{
		union
		{
			float ff;
			u8 tt[4];
		}ff;
		
		long lmeaval;

		u8 no=g_ac_table[i].indexno;
	
		if(i>=EXV_NUM_MAX)continue;
		exv_rcd.max_data[i].cp = g_ac_table[i].cp;
		exv_rcd.min_data[i].cp = g_ac_table[i].cp;
		
		if(no>0)
		{
			DWORD dwMax=0;
			float f_65536=65536.0;			
			no-=1;
			
			dwMax=(DWORD)g_ac_table[i].normal;	
			lmeaval=GetRmtMeaVal(g_ac_table[i].owner,no,NULL);

			if(dwMax==0)f_65536=1.0;  // 额定值为0 代表整型值，没有扩大65536倍
			ff.ff=(float)lmeaval/f_65536; //转为浮点数

			if(g_ac_table[i].owner == 0)// 公共测量值
			{
				lzero=g_unit[g_pub_ac_desc[no].unit].zero;
			}
			else if(g_ac_table[i].owner <= SWITCH_NUM_EXT)
			{
				lzero=g_unit[g_sw_ac_desc[no].unit].zero;
			}
				

			//点号改变也需要重新开始记录极值
			if(day_change)	//要保存最新一天的极值记录
			{

				//极大值
				exv_rcd.max_data[i].elem_val = ff.ff;
				exv_rcd.max_data[i].time_mark = time;
			
				//极小值
				exv_rcd.min_data[i].elem_val = ff.ff;
				exv_rcd.min_data[i].time_mark = time;
						
				//备份
				exv_rcd.max_value_bk[i] =ff.ff;
				exv_rcd.min_value_bk[i] = ff.ff;

				exv_rcd.occur_flag = true;

			}
			else
			{
				//比较极值
				
				if(ff.ff>exv_rcd.max_value_bk[i])
				{
					exv_rcd.max_value_bk[i] = ff.ff;
					exv_rcd.max_data[i].elem_val = ff.ff;
					exv_rcd.max_data[i].time_mark = time;
					exv_rcd.occur_flag = true;	
				}
				else if((ff.ff < exv_rcd.min_value_bk[i] )&&(_AbsL(lmeaval) > lzero)) //必须大于零值才会去记录
				{
					exv_rcd.min_value_bk[i] = ff.ff;	
					exv_rcd.min_data[i].elem_val = ff.ff;
					exv_rcd.min_data[i].time_mark = time;
					exv_rcd.occur_flag = true;
				}
				else if(_AbsL(lmeaval) > lzero)			//记录超过零漂值最小值
				{
					exv_rcd.min_value_bk[i] = ff.ff;
				}
				else 
				{
					if(ff.ff == exv_rcd.max_value_bk[i])
					{
						exv_rcd.max_data[i].elem_val = ff.ff;
						//exv_rcd.max_data[i].time_mark = time;
					}

					if(ff.ff == exv_rcd.min_value_bk[i])
					{	
						exv_rcd.min_data[i].elem_val = ff.ff;
						//exv_rcd.min_data[i].time_mark = time;
					}
				}
				
			}

		}
		else //备用点号
		{	
			
			exv_rcd.max_data[i].elem_val = 0;
			exv_rcd.max_data[i].time_mark = time;
			
			exv_rcd.min_data[i].elem_val = 0;
			exv_rcd.min_data[i].time_mark = time;

			
		
		}

	}

	exv_rcd.max_num = g_table_head->ac_num;
	exv_rcd.min_num = g_table_head->ac_num;

	exv_rcd.ac_num = g_table_head->ac_num;

	if(day_change)
	{
		exv_rcd.time_bk = time;
	}
		
}


/******************************************************************************
函数名称：	get_fixpt_rcd_data
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	获得当下时刻的定点记录数据
参数说明：	

返回值：	
	
修改记录：	
*/
 void get_fixpt_rcd_data(struct rtc_time_t time_bk)
 {
 	int i;
	
 	for (i=0; i<g_table_head->ac_num; i++)
	{
		union
		{

			float ff;
			u8 tt[4];
		}ff;

		u8 no=g_ac_table[i].indexno;
		long lmeaval;

		if(i>=FIXPT_RCD_NUM)continue;
		fixpt_rcd.data[i].cp =g_ac_table[i].cp;

		if(no>0)
		{
			DWORD dwMax=0;
			float f_65536=65536.0;
	
			no-=1;

			dwMax=(DWORD)g_ac_table[i].normal;	
						
			if(dwMax==0)f_65536=1.0;

			lmeaval=GetRmtMeaVal(g_ac_table[i].owner,no,NULL);
			
			ff.ff=(float)lmeaval/f_65536; //转为浮点数
	
			fixpt_rcd.data[i].elem_val = ff.ff;

		}
		else
		{
			fixpt_rcd.data[i].elem_val = 0;
		}


	}

	fixpt_rcd.time_bk = time_bk;
	fixpt_rcd.info_num = g_table_head->ac_num;
 	
 }




/******************************************************************************
函数名称：	get_frz_rcd_data
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-12-21
函数说明：	获得当下时刻的日冻结电能量记录文件数据
参数说明：	day_frz:1为日冻结，0为15分钟冻结

返回值：	
	
修改记录：	
*/
int get_frz_rcd_data(struct rtc_time_t time_bk)
{
 	int i,min_num=0,day_num=0;
	
	
 	frz_rcd.tm = time_bk;

	for(i=0;i<g_table_head->dd_num;i++)
	{
		int sw,no;
		#ifdef HISFILE_DD_RATE
			float rate=1.0;
		#endif
		
		
		union{
			float ff;
			u8 tt[4];
		}ff;	

		if((g_dd_table[i].indexno >= (SW_DD_DAY1+1))&&(g_dd_table[i].indexno <= (SW_DD_DAY8+1)))
		{	
			
			sw=g_dd_table[i].owner;	
			no=g_dd_table[i].indexno;

			#ifdef HISFILE_DD_RATE
			rate=(float)g_dd_table[i].rate/65536.0;	
			#endif
			if(no>0)
			{	
			#ifndef HISFILE_DD_RATE
				ff.ff=GetRmtDdVal(sw,no-1);
			#else
				ff.ff=GetRmtDdVal(sw,no-1)*rate;
			#endif
			}
			else
			{
				ff.ff=0;
			}

			
			frz_rcd.day_data[day_num].cp = g_dd_table[i].cp;
			frz_rcd.day_data[day_num].elem_val = ff.ff;
	
			day_num++;
		}
	
		if((g_dd_table[i].indexno >= (SW_DD_15M1+1))&&(g_dd_table[i].indexno <= (SW_DD_15M8+1)))
		{
			sw=g_dd_table[i].owner;	
			no=g_dd_table[i].indexno;
			#ifdef HISFILE_DD_RATE
				rate=(float)g_dd_table[i].rate/65536.0;	
			#endif

			if(no>0)
			{
			#ifndef HISFILE_DD_RATE
				ff.ff=GetRmtDdVal(sw,no-1);
			#else
				ff.ff=GetRmtDdVal(sw,no-1)*rate;
			#endif
			}
			else
			{
				ff.ff=0;
			}
			frz_rcd.min_data[min_num].cp = g_dd_table[i].cp;
			frz_rcd.min_data[min_num].elem_val = ff.ff;
			
			min_num++;

			
			
		}

		
	}
	

	frz_rcd.day_frz_num = day_num;
	frz_rcd.min_frz_num = min_num;
	

	return (day_num+min_num);

 }


 int get_flowrev_data(void)
 {
 	int i,num=0;

	for(i=0;i<g_table_head->dd_num;i++)
	{
		int sw,no;
		union{
			float ff;
			u8 tt[4];
		}ff;	

		if(g_dd_table[i].indexno >= (SW_DD_CHA1+1)&&g_dd_table[i].indexno <= (SW_DD_CHA8+1))
		{
			

			sw=g_dd_table[i].owner;	
			no=g_dd_table[i].indexno;	
			
			if(no>0)
			{
			#ifdef HISFILE_DD_RATE
				float rate=1.0;
				rate=(float)g_dd_table[i].rate/65536.0;	
			#endif
				
			#ifndef HISFILE_DD_RATE
				ff.ff=g_sw[sw].dd[no-1].fv;
			#else
				ff.ff=g_sw[sw].dd[no-1].fv*rate;
			#endif
				//ff.ff=GetRmtDdVal(sw,no-1);
			}
			else
			{
				ff.ff=0;
			}

			if(no>0)
			{
				if(g_sw[sw].dd[no-1].bchanged)
				{
					g_sw[sw].dd[no-1].bchanged = false;
					flowrev_rcd.data[num].cp = g_dd_table[i].cp;
					flowrev_rcd.data[num].elem_val = ff.ff;
					flowrev_rcd.data[num].rev_time = g_sw[sw].dd[no-1].ct;

					
					num++;

					if(num>=8)
						break;
				}
				
			}

		}

	}

	flowrev_rcd.info_num = num;

	if(num)
	{
		char rcd_buf[128]={0};
		//点号2+值4+时标8
		for(i=0;i<8;i++)
		{
			memcpy(&rcd_buf[i*14],&flowrev_rcd.data[i].cp,2);
			memcpy(&rcd_buf[i*14+2],&flowrev_rcd.data[i].elem_val,4);
			memcpy(&rcd_buf[i*14+6],&flowrev_rcd.data[i].rev_time,8);
		}
		writeListData(&flowrevList,rcd_buf);	
		
	}
	
	return num;
	
 }


 /******************************************************************************
函数名称：	refresh_soe_file
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	SOE文件刷新，放在事件保存函数里面，每发生一次事件记录，根据点号配置是否有此点号来决定
			记录到历史文件里
参数说明：	er:SOE记录

				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
void refresh_soe_file(EVENT_STRUCT * er)
{
	u8 SIQ;
	struct rtc_time_t tm;
	char rcd_buf[64]={0};
	u16 cp = 0;

	if(!pRunSet->bTT_HistoryFile)
		return ;

	cp = soe_lp2cp(er->ev_type,er->ev_code,er->ev_arg[1]);
	if(cp == 0)
		return;

	if(!hs_file_init_flag)
		return;
	
	SIQ = er->ev_value;
	//if(tRunPara.bDPI && ((er->ev_type&SOE_TYPE_MASK) != SOE_TYPE_DPI))
	if((er->ev_type&SOE_TYPE_MASK) != SOE_TYPE_DPI)
	{
		SIQ+=1;	//转为双点信息
	}

	if(g_run_stu.bToolRmtTest||g_run_stu.bHmiRmtTest)	//测试模式，遥信置为无效
	{
		if(pRunSet->bTT_RmtTest)SIQ|=0x80;
	}

	timespec_to_rtc(er->ts,&tm,1);
	
	Swap_16_memcpy(rcd_buf,(BYTE*)&cp);	// modify for am335x  xxxxxx 
	memcpy(&rcd_buf[2],&tm,8);
	memcpy(&rcd_buf[10],&SIQ,1);
	writeListData(&soeList,rcd_buf);

}




 /******************************************************************************
函数名称：	refresh_co_file
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	遥控文件刷新，放在遥控处理函数里面，每发生一次遥控选择或者执行，就加载一次操作记录
			
参数说明：	master:主站信息为1，终端信息为0;op_type:操作类型;cp:点号;cmd:遥控命令
	
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
void refresh_co_file(bool master,u8 frametype,u8 op_type,u16 cp,u8 cot,u8 cmd)
{
	struct timespec ts;
	static struct rtc_time_t	tm;	//时标
	char rcd_buf[64]={0};
	u8 ix=0;

	if(!pRunSet->bTT_HistoryFile)
		return ;

	if(!hs_file_init_flag)
		return;

	// 双点转单点
	if(frametype == 46 )
	{
		cmd--;
	}
	
	if(cmd>=2)
		return;

	if(master)
	{
		if(op_type >= YK_TYPE_SEL)
		{
			ix = op_type-YK_TYPE_SEL;
		}
	}
	else
	{
		if(op_type == YK_TYPE_SEL)
		{
			if(cot  == IEC_COT_ACTCON)
			{
				ix = 3;
			}
			else
			{
				ix = 6;
			}
			
		}
		else if(op_type == YK_TYPE_EXE)
		{
			if(cot  == IEC_COT_ACTCON)
			{
				ix = 4;
			}
			else
			{
				ix = 6;
			}

		}
		else if(op_type == YK_TYPE_CANCEL)
		{
			
			ix = 5;
		}

		if(cot == IEC_COT_ACTTERM)
		{
			ix = 7;
		}
		
	}
	

	clk_time_get(&ts);
	timespec_to_rtc(ts,&tm,0);

	Swap_16_memcpy(rcd_buf,(BYTE*)&cp);	// modify for am335x  xxxxxx 
	memcpy(&rcd_buf[2],&tm,8);
	memcpy(&rcd_buf[10],&cmd,1);
	memcpy(&rcd_buf[11],&ix,1);
	writeListData(&coList,rcd_buf);
			
}






/******************************************************************************
函数名称：	refresh_exv_file
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	极值文件刷新，1秒钟执行一次
参数说明：	

				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
 void refresh_exv_file(void)
 {
 	struct timespec ts;
	struct rtc_time_t	time;	//时标

	static int first = 1;
	bool day_change=false;
	int ret=0;
	static uint32_t extreme_dly=0;
	static u16 extreme_min=0;

	//获取当前时间
	clk_time_get(&ts);
	timespec_to_rtc(ts,&time,0);

	//日期不对应时，保存旧值
	if(first == 1)
	{
		get_exv_rcd_data(time,!exv_rcd.save_flag);
		load_exv_file_rcd(exv_file_info.file_num-1);
		first = 0;
		extreme_dly = ustimer_get_origin();
		extreme_min=0;
		exv_rcd.time_bk.day = time.day;
		
	}
	else if(time.day!=exv_rcd.time_bk.day)
	{
		exv_rcd.time_bk = time;	
		day_change = true;

		extreme_dly = ustimer_get_origin();
		extreme_min = 0;
		
	
		//保存记录到前一天,此时保存的是上一天记录的极值
		ret = load_exv_file_rcd(exv_file_info.file_num-1);

		//create_extreme_txt(exv_txt_info.file_num);
		//exv_txt_file_deal();
		
		get_exv_rcd_data(time,day_change);
		//创建新的一天的极值记录文件
		exv_rcd_file_deal(time);

	}
	else
	{
		get_exv_rcd_data(time,false);

		exv_txt_file[exv_txt_info.file_num].create_time.year = time.year;
		exv_txt_file[exv_txt_info.file_num].create_time.month = time.month;
		exv_txt_file[exv_txt_info.file_num].create_time.day = time.day;

		
		//为避免频繁刷新极值文件记录，规定如果15分钟间隔内发生极值数据刷新，记录到极值文件中去
		if(ustimer_get_duration(extreme_dly)>=(USTIMER_SEC*60))
		{
			extreme_dly = ustimer_get_origin();
			
			if(extreme_min==0)
			{
				if(exv_rcd.occur_flag == true)
				{
					ret = load_exv_file_rcd(exv_file_info.file_num-1);
					exv_rcd.occur_flag = false;
					
				}
			}

			extreme_min=(extreme_min+1)%1;//十五分钟      五分钟
		}

	}

 }




/******************************************************************************
函数名称：	refresh_fixpt_file
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	定点文件刷新，1秒钟执行一次
参数说明：	

				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
void refresh_fixpt_file(void)
{
	static int first = 1;
 	struct timespec ts;
	static struct rtc_time_t	time;	//时标
	int ret=0;
	

	//获取当前时间
	clk_time_get(&ts);
	timespec_to_rtc(ts,&time,0);


	if(first)
	{
		fixpt_rcd.time_bk = time;
		first = 0;
		
	}
	else if(time.day!=fixpt_rcd.time_bk.day)
	{
	
		//当日期改变时，创建新的文件
		get_fixpt_rcd_data(time);
		fixpt_rcd_file_deal(time);
		fixpt_file_info.part_id = 1;


		#if  0

		rt_printf("\r\na:%s:file_num=%d,%04d-%02d-%02d_%02d:%02d\r\n",
										__func__,
										fixpt_file_info.file_num,
										time.year+2000, 
										time.month,
										time.day,
										time.hour,
										time.min);
		#endif
		
	}
	else
	{

		if((((u16)time.hour*60+(u16)time.min)>((u16)fixpt_rcd.time_bk.hour*60+(u16)fixpt_rcd.time_bk.min))
			&&(pRunSet->wZDJG!=0)&&((time.min%pRunSet->wZDJG) == 0))
		{
					
			get_fixpt_rcd_data(time);	

			if(fixpt_file_info.part_id<(1440/pRunSet->wZDJG))
			{
				ret = load_fixpt_file_rcd();
			}

			#if 0

			rt_printf("\r\nb:%s:ret=%d,file_num=%d,part_id=%d,%04d-%02d-%02d_%02d:%02d\r\n",
										__func__,
										ret,
										fixpt_file_info.file_num,
										fixpt_file_info.part_id,
										time.year+2000, 
										time.month,
										time.day,
										time.hour,
										time.min);
			#endif	

		}

	}

}



/******************************************************************************
函数名称：	refresh_frz_file
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-12-12
函数说明：	定点文件刷新，1秒钟执行一次
参数说明：	

				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
void refresh_frz_file(void)
{

	static int first = 1;
 	struct timespec ts;
	struct rtc_time_t	time;	//时标
	int ret=0;
	int sw = 0;

	//获取当前时间
	clk_time_get(&ts);
	timespec_to_rtc(ts,&time,0);


	if(first)
	{
		frz_rcd.tm = time;
		first = 0;

	}
	else if(time.day!=frz_rcd.tm.day)
	{
		//当日期改变时，创建新的文件,同时在上一天的最后节点上记录冻结数据
		
#ifdef METERING_ENERGY
/*		
//noted by sunxi: 20220716 这里dtu4_gw_test里的代码，先用metering_freeze_refresh(ENERGY_DAY_DATA)代替
		for(sw=0; sw<METERING_NUM; sw++)
		{
			metering_freeze_refresh(sw, ENERGY_DAY_FREZ,&time);
		}
*/
		metering_freeze_refresh(ENERGY_DAY_DATA, &time);
#endif
		get_frz_rcd_data(time);
		ret = load_frz_file_rcd(true);

	
		frz_rcd_file_deal(time);
		frz_file_info.part_id = 1;
	}
	else
	{
		//15 分钟加载一次，直至第二天
		//if((time.hour*4+ time.min/15)- (frz_rcd.time_bk.hour*4+ frz_rcd.time_bk.min/15) >= 1)
		if((((u16)time.hour*60+(u16)time.min)>((u16)frz_rcd.tm.hour*60+(u16)frz_rcd.tm.min))
			&&(pRunSet->wDDJG!=0)&&((time.min%pRunSet->wDDJG) == 0))
		{
		
			frz_file_info.b_new = true;
#ifdef METERING_ENERGY
/*		
//noted by sunxi: 20220716 这里dtu4_gw_test里的代码，先用metering_freeze_refresh(ENERGY_SET_DATA)代替			
			for(sw=0; sw<METERING_NUM; sw++)
			{
				metering_freeze_refresh(sw, ENERGY_QUARTER_FREZ,&time);
			}
*/
			metering_freeze_refresh(ENERGY_SET_DATA, &time);
#endif				
			get_frz_rcd_data(time);	

			if(frz_file_info.part_id<(1440/pRunSet->wDDJG+1))//97
			{
				ret = load_frz_file_rcd(false);
			}

			#if 0
			rt_printf("\r\nb:%s:ret=%d,file_num=%d,part_id=%d,%04d-%02d-%02d_%02d:%02d\r\n",
										__func__,
										ret,
										frz_file_info.file_num,
										frz_file_info.part_id,
										time.year+2000, 
										time.month,
										time.day,
										time.hour,
										time.min);
			#endif


		}
		else
		{
			//if(frz_file_info.b_new == false)
			{
			//noted by sunxi: 20220716 没有定义METERING_NUM，暂时这样
				//for(sw=0; sw<METERING_NUM; sw++)
				sw = 0;
				{
					g_sw[sw].dd[SW_DD_15M1].fv = g_sw[sw].dd[SW_DD_NOW1].fv;  //更新到15分钟冻结中
					g_sw[sw].dd[SW_DD_15M2].fv = g_sw[sw].dd[SW_DD_NOW2].fv;
					g_sw[sw].dd[SW_DD_15M3].fv = g_sw[sw].dd[SW_DD_NOW3].fv;
					g_sw[sw].dd[SW_DD_15M4].fv = g_sw[sw].dd[SW_DD_NOW4].fv;
					g_sw[sw].dd[SW_DD_15M5].fv = g_sw[sw].dd[SW_DD_NOW5].fv;
					g_sw[sw].dd[SW_DD_15M6].fv = g_sw[sw].dd[SW_DD_NOW6].fv;
					g_sw[sw].dd[SW_DD_15M7].fv = g_sw[sw].dd[SW_DD_NOW7].fv;
					g_sw[sw].dd[SW_DD_15M8].fv = g_sw[sw].dd[SW_DD_NOW8].fv;

					g_sw[sw].dd[SW_DD_DAY1].fv = g_sw[sw].dd[SW_DD_NOW1].fv;  //更新到日冻结中
					g_sw[sw].dd[SW_DD_DAY2].fv = g_sw[sw].dd[SW_DD_NOW2].fv;
					g_sw[sw].dd[SW_DD_DAY3].fv = g_sw[sw].dd[SW_DD_NOW3].fv;
					g_sw[sw].dd[SW_DD_DAY4].fv = g_sw[sw].dd[SW_DD_NOW4].fv;
					g_sw[sw].dd[SW_DD_DAY5].fv = g_sw[sw].dd[SW_DD_NOW5].fv;
					g_sw[sw].dd[SW_DD_DAY6].fv = g_sw[sw].dd[SW_DD_NOW6].fv;
					g_sw[sw].dd[SW_DD_DAY7].fv = g_sw[sw].dd[SW_DD_NOW7].fv;
					g_sw[sw].dd[SW_DD_DAY8].fv = g_sw[sw].dd[SW_DD_NOW8].fv;

					
				}
			}
			

		}
		

	}

}


/******************************************************************************
函数名称：	refresh_flowrev_file
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-12-12
函数说明：	功率反向电能量冻结值刷新，1秒钟执行一次
参数说明：	

				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
void refresh_flowrev_file(void)
{
	//潮流变化冻结
	if(get_flowrev_data())
	{
		if(!del_history_file(HS_FILE_FLOWREV))
		{
			create_flowrev_rcd_file();
		}
		
	}
}

/******************************************************************************
函数名称：extreme_create_csv
函数版本：	01.01
创建作者：XJ
创建日期：	2016-08-09
函数说明：极值记录转换为txt文件
参数说明：
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
int create_extreme_txt(u8 day)
{
	
	struct rtc_time_t time_mark;
	int i,j,k;
	loff_t pos = 0;
	char dir_name[64] = {0};
	int max_num=0,min_num=0;
	char print_cn[512]={0};
	char name_cn[32]={0};
	

	if(day >= EXV_FILE_NUM_MAX)
	{
		return -1;
	}


	time_mark.year = exv_txt_file[day].create_time.year;
	time_mark.month = exv_txt_file[day].create_time.month;
	time_mark.day = exv_txt_file[day].create_time.day;

	sprintf(exv_txt_file[day].name,"extreme%04d%02d%02d.txt",
									time_mark.year+2000,
									time_mark.month,
									time_mark.day);

	sprintf(dir_name,"%s%s",HF_EXV_101_DIR,exv_txt_file[day].name);

	// 创建数据文件
	pos = 0;
	exv_txt_file[day].handle = rt_file_open(dir_name,O_CREAT|O_RDWR,0);

	if(IS_ERR(exv_txt_file[day].handle))
	{
		return -2;
	}

	if(g_table_head->ac_num)	//有遥测点号
	{
		
		for (i=0; i<g_table_head->ac_num; i++)
		{
			if(i>=EXV_NUM_MAX)continue;
			if(exv_rcd.max_data[i].elem_val!=0)
			{
				max_num++;
			}

			if(exv_rcd.min_data[i].elem_val!=0)
			{
				min_num++;
			}
		}
	}

	sprintf(print_cn, "文件日期%04d-%02d-%02d\r\n\r\n",
											time_mark.year+2000,
											time_mark.month,
											time_mark.day);
	rt_file_write(exv_txt_file[day].handle,print_cn,strlen(print_cn),&pos);
	
	
	sprintf(print_cn,"最大值(N=%03d)\r\n",max_num);
	rt_file_write(exv_txt_file[day].handle,print_cn,strlen(print_cn),&pos);

	
	sprintf(print_cn,"名称\t\t地址\t\t值\t\t发生时间\t\r\n");
	rt_file_write(exv_txt_file[day].handle,print_cn,strlen(print_cn),&pos);


	for(j=0; j<g_table_head->ac_num ;j++)
	{
		u16 cp=0;
		float elem_val;
		u16 year,ms;
		 		
				
		if(j>=EXV_NUM_MAX)continue;
		if(exv_rcd.max_data[j].elem_val == 0)
		{
			
			continue;
		}
		
		
		for(k=0; k<g_table_head->ac_num; k++)
		{

			if(k>=EXV_NUM_MAX)continue;
			cp =  exv_rcd.max_data[j].cp;

			if(g_ac_table[k].cp == cp)
			{
				memset(name_cn,0,sizeof(name_cn));
				if(g_ac_table[k].indexno!=0)
				{
					
					tbl_getacname(g_ac_table[k].owner,g_ac_table[k].indexno,name_cn);
				}
				else
				{
					sprintf(name_cn,"备用");
				}

				break;
			}

		}

		
		year = exv_rcd.max_data[j].time_mark.year ;
		ms = exv_rcd.max_data[j].time_mark.ms;
		elem_val =  exv_rcd.max_data[j].elem_val;

		if(strlen(name_cn)>=8)
		{
			sprintf(print_cn, "%s\t0x%04x\t\t%09.3f\t\%04d-%02d-%02d_%02d:%02d:%02d-%03d\r\n",
										name_cn,
										cp,
										elem_val,
										year+2000,
										exv_rcd.max_data[j].time_mark.month,
										exv_rcd.max_data[j].time_mark.day,
										exv_rcd.max_data[j].time_mark.hour,
										exv_rcd.max_data[j].time_mark.min,
										ms/1000,
										ms%1000);	
		}
		else
		{
			sprintf(print_cn, "%s\t\t0x%04x\t\t%09.3f\t\%04d-%02d-%02d_%02d:%02d:%02d-%03d\r\n",
										name_cn,
										cp,
										elem_val,
										year+2000,
										exv_rcd.max_data[j].time_mark.month,
										exv_rcd.max_data[j].time_mark.day,
										exv_rcd.max_data[j].time_mark.hour,
										exv_rcd.max_data[j].time_mark.min,
										ms/1000,
										ms%1000);	
		}

		
		
		
		
						 	
		rt_file_write(exv_txt_file[day].handle,print_cn,strlen(print_cn),&pos);


	}

	sprintf(print_cn, "\r\n"); 	

	
	rt_file_write(exv_txt_file[day].handle,print_cn,strlen(print_cn),&pos);
	
	
	sprintf(print_cn,"最小值(N=%03d)\r\n",min_num);
	rt_file_write(exv_txt_file[day].handle,print_cn,strlen(print_cn),&pos);

	
	sprintf(print_cn,"名称\t\t地址\t\t值\t\t发生时间\t\r\n");
	rt_file_write(exv_txt_file[day].handle,print_cn,strlen(print_cn),&pos);

	
	for(j=0; j<g_table_head->ac_num ;j++)
	{
		u16 cp=0;
		float elem_val;
		u16 year,ms;

		if(j>=EXV_NUM_MAX)continue;
		if(exv_rcd.min_data[j].elem_val == 0)
			continue;
		
		for(k=0; k<g_table_head->ac_num; k++)
		{
			if(k>=EXV_NUM_MAX)continue;
			cp =  exv_rcd.min_data[j].cp;
			
			if(g_ac_table[k].cp == cp)
			{
				memset(name_cn,0,sizeof(name_cn));
				if(g_ac_table[k].indexno!=0)
				{
					tbl_getacname(g_ac_table[k].owner,g_ac_table[k].indexno,name_cn);
				}
				else
				{
					sprintf(name_cn,"备用");
				}

				break;
			}

		}


		//rt_file_write(exv_txt_file[day].handle,print_cn,strlen(print_cn),&pos);


		
		year = exv_rcd.min_data[j].time_mark.year ;
		ms = exv_rcd.min_data[j].time_mark.ms;
		elem_val =  exv_rcd.min_data[j].elem_val;

		if(strlen(name_cn)>=8)
		{
			sprintf(print_cn, "%s\t0x%04x\t\t%09.3f\t%04d-%02d-%02d_%02d:%02d:%02d-%03d\r\n",
										name_cn,
										cp,
										elem_val,
										year+2000,
										exv_rcd.min_data[j].time_mark.month,
										exv_rcd.min_data[j].time_mark.day,
										exv_rcd.min_data[j].time_mark.hour,
										exv_rcd.min_data[j].time_mark.min,
										ms/1000,
										ms%1000);
		}
		else
		{
			sprintf(print_cn, "%s\t\t0x%04x\t\t%09.3f\t%04d-%02d-%02d_%02d:%02d:%02d-%03d\r\n",
										name_cn,
										cp,
										elem_val,
										year+2000,
										exv_rcd.min_data[j].time_mark.month,
										exv_rcd.min_data[j].time_mark.day,
										exv_rcd.min_data[j].time_mark.hour,
										exv_rcd.min_data[j].time_mark.min,
										ms/1000,
										ms%1000);
		}
		
		
						 	
		rt_file_write(exv_txt_file[day].handle,print_cn,strlen(print_cn),&pos);

	}

	

		// 关闭文件
	rt_file_close(exv_txt_file[day].handle,0);

	rt_printf("极值记录txt文件生成成功\r\n");

	exv_txt_info.file_num++;

	return 0;
	
}

int init_his_soe_db(void)
{
	//soe.dat保存信息体地址、时标、值=2+8+1=11字节
	memset((char *)&soeList,0,sizeof( fileInfo));
	sprintf(soeList.fileName,"soe.dat");
	soeList.listMax = SOE_RCD_NUM;
	soeList.listSize =11;
	soeList.fileTatal=1;
	soeList.fileTableSize=0;
	initListData(&soeList);
	return 0;
}
int init_his_co_db(void)
{
	//co.dat保存信息体地址、时标、命令、值=2+8+1+1=12字节
	memset((char *)&coList,0,sizeof( fileInfo));
	sprintf(coList.fileName,"co.dat");
	coList.listMax = CO_RCD_NUM;
	coList.listSize =12;
	coList.fileTatal=1;
	coList.fileTableSize=0;
	initListData(&coList);
	return 0;
}
int init_his_flowrev_db(void)
{
	// 8*(点号(2byte)+值(4byte)+时标(8byte))
	memset((char *)&flowrevList,0,sizeof( fileInfo));
	sprintf(flowrevList.fileName,"flowrev.dat");
	flowrevList.listMax = FLOWREV_RCD_NUM/8;
	flowrevList.listSize =8*14;//112
	flowrevList.fileTatal=1;
	flowrevList.fileTableSize=0;
	initListData(&flowrevList);
	return 0;
}
int init_his_log_db(void)
{
	//类型编号(1byte)+值(1byte)+时标(8byte)
	memset((char *)&logList,0,sizeof( fileInfo));
	sprintf(logList.fileName,"log.dat");
	logList.listMax = LOG_RCD_NUM;
	logList.listSize =10;
	logList.fileTatal=1;
	logList.fileTableSize=0;
	initListData(&logList);
	return 0;
}


int init_his_db(void)
{
	init_his_soe_db();
	init_his_co_db();
	init_his_flowrev_db();
	init_his_log_db();
	return 0;
}

  /******************************************************************************
函数名称：	hisory_file_app
函数版本：	01.01
创建作者： 	xj
创建日期：	2016-08-09
函数说明：	历史文件处理程序,极值文件1秒钟扫描一次实时值，
参数说明：	

				
返回值：	
	0：		成功
	其它：	失败
修改记录：	
*/
void hisory_file_app(void)
{
	u32 us0;
	static u32 init_count = 5*10;
	static u32 hs_p_delay = 0;


	if(!pRunSet->bTT_HistoryFile)
		return;

	if(!hs_file_init_flag)
		return;


	while(init_count)
	{	
		init_count--;
		
		hs_p_delay = ustimer_get_origin();

		return;
	}	

	us0 = ustimer_get_origin();

	if ((int)(us0 - hs_p_delay) >= 0)
	{

		hs_p_delay += USTIMER_SEC;

		if(!exv_file_info.b_err)
			refresh_exv_file();

		if(!fixpt_file_info.b_err)
			refresh_fixpt_file();

		if(!frz_file_info.b_err)
			refresh_frz_file();

		refresh_flowrev_file();

		log_rcd_com_err_set();

		log_file_app();

	}
	

}


