#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,", exv_rcd.max_num);
        p += j;

        for (i = 0; i < exv_rcd.max_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 == exv_rcd.max_num - 1)
            {
                sprintf(p, "\r\n");
                p += 2;
            }
            else
            {
                sprintf(p, ",");
                p += 1;
            }
        }

        j = sprintf(p, "最小值：%04d,", exv_rcd.min_num);
        p += j;
        for (i = 0; i < exv_rcd.min_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 == exv_rcd.min_num - 1)
            {
                sprintf(p, "\r\n");
                p += 2;
            }
            else
            {
                sprintf(p, ",");
                p += 1;
            }
        }

        pos = MSG_EXV_FILE_HEAD_LEN;
    }
    else
    {
        for (i = 0; i < exv_rcd.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();
    }
}