COMTRADE（IEEE标准电力系统暂态数据交换通用格式STD C37.1111991/1999）文件格式解析

comtrade_format.h

/*
 * 分析解析COMTRADE（IEEE标准电力系统暂态数据交换通用格式）文件格式。
 *
 * （一）IEEE的COMTRADE数据格式
 *
 * COMTRADE是IEEE标准电力系统暂态数据交换通用格式。标准为电力系统或电力系统模型采集到的暂态波形和事故数据的文件定义了一种格式。
 * 该格式意欲提供一种易于说明的数据交换通用格式。IEEE于1991年提出，并于1999进行了修订和完善。每个COMTRADE记录都有一组最多4个与
 * 其相关的文件，4个文件中的每一个都具有一个不同的信息等级。4个文件如下：
 *
 * （1）、标题文件（xxxxxxxx.HDR）
 * 标题文件是由COMTRADE数据的原创者建立的一种可选的ASCII文本文件，标题文件的创建者可以以任何需要的顺序创建任何信息。标题文件的
 * 格式为ASCII。
 *
 * （2）、 配置文件（xxxxxxxx.CFG）
 * 配置文件为一种ASCII文本文件，用于正确地说明数据（.DAT）文件的格式，因此必须以一种具体的格式保存。该文件诠释了数据（.DAT）文
 * 件所包含信息，其中包括诸如采样速率、通道数量、频率、通道信息等项。配置文件第一行中的一个字段识别文件所依照的 COMTRADE标准版
 * 本的年份（例如1991、1999等）。如果该字段不存在或是空的，则假设文件则遵照标准的最初发行日期（1991）。配置文件还包含识别伴随
 * 的数据文件是以ASCII格式还是以二进制格式存储的字段。 配置文件有下列信息：
 * （a）站名，记录装置的特征，COMTRADE 标准的修改年份
 * （b）通道的数量和类型
 * （c）通道名称、单位和转换系数
 * （d）线路频率
 * （e）采样速率和每一速率下的采样数量
 * （f）第一数据点的日期和时间
 * （g）触发点和日期和时间
 * （h）数据文件类型
 * （i）时间标记倍乘系数
 *
 * （3）、 数据文件（xxxxxxxx.DAT）
 * 数据文件包含记录中每个采样所有输入通道的值。数据文件包含一个顺序号和每次采样的时间标志。这些采样值除记录模拟输入的数据之外，
 * 也记录状态，即表示开/关信号的输入。
 *
 * （4）、 信息文件（xxxxxxxx.INF）
 * 信息文件是一种文件创建者希望使之对用户有用的信息之外的特别信息。信息文件是可选文件。
 *
 * COMTRADE定义的所有文件，都在IEEE 标准电力系统暂态数据交换通用格式Std C37.111-1991或IEEE Std C37.111-1999版本中进行了诠释。
 *
 * （二） 电力系统故障动态记录技术准则
 *
 * 电力行业标准《220kV~500kV电力系统故障动态记录技术准则》（DL/T 553-94），是故障录波装置研制和开发中必须依据的标准。标准在3.6.5
 * 条中规定了，输出的动态过程记录数据应符合的标准格式与ANSI/IEEE Std C37.111-1991 COMTRADE兼容。同时，标准规定了电力系统发生故障
 * 的整个过程中，模拟量采集方式的数据记录按时段顺序进行。
 * A时段：系统在扰动开始前的状态数据，直接输出原始采集波形，记录时间≥0.04S
 * B时段：系统大扰动初期的状态数据，直接输出原始采集波形，记录时间≥0.1S
 * C时段：系统大扰动后的中期状态数据，可输出连续工频有效值，记录时间≥1.0S
 * D时段：系统动态过程数据，每0.1S输出一个工频有效值，记录时间≥20S
 * E时段：系统长过程的动态数据,每0.1S输出一个工频有效值,记录时间≥10min
 * 这里，技术标准的数据记录有两个主要特点，一是分段记录，二是记录的数据不仅可以有按某一采样率的采样数据，而且可按一定间隔记录有效
 * 值以代替采样值。
 *
 *（三） 微机故障录波装置和COMTRADE文件
 *
 * 微机故障录波装置，基本配置分为一台采集站和一台分析站，采集站和分析站之间通过高速以太网连接。采集站负责采集、记录故障数据；采集
 * 站采集的原始数据或记录的原始故障数据，除了存入采集站的硬盘保存外，还将通过网络把数据上传到分析站。分析站程序采用VC 6.0编制，完
 * 成对数据处理、波形显示、自动分析、与远方通信功能。数据处理中，自动生成符合COMTRADE格式的文件。装置接收故障采样数据后，直接将数
 * 据处理成COMTRADE数据格式的文件。故障录波装置模拟量采样频率为5000次/秒，采样时段根据电力系统故障动态记录技术准则，做了相应调整，
 * 将C时段调整为直接输出原始采集波形，记录时间≥1.0S，这样ABC时段采样频率为5000次/秒，存实时的模拟数据；而DE时段采样频率为10次/秒，
 * 用存最大值数据来代替有效值，这样便于产生包络线波形。我们省略了标题文件和信息文件，并且根据不同的批次和故障次数，定义文件名，生
 * 成的配置文件( DIR00．CFG )和数据文件( DIR00．DAT )，并同时存放于同一批次文件夹DIR00内。文件示例如下列所示。
 *
 * （1）、配置文件( DIR00．CFG )
 * 城东变电所,03                                                                                     【注：变电站名称 录波器编号】
 * 12, 8A, 4D                                                                           【注：12格通道，8个模拟通道，4个数字通道】
 * 1, 1 Ia, A, mx1, A, 8.46830338, 0.00000000, 0, -2048, 2047   【注：模拟量依次为:通道编号,通道名称，通道相，XX，单位，fCoefA[变
 *              换因子A]，fCoefB[变换因子B]，fTime[时间偏移]，fMin[此模拟量采样记录数据最小值], fMax[此模拟量采样记录数据最大值]，
 *              其中：实际值y与采样记录数据X的关系：y = fCoefA * X + fCoefB, 所以实际的最值：
 *                      Min = fCoefA * fMin + fCoefB;    Max = fCoefA * fMax~ + fCoefB;                                         】
 * 2, 1 Ib, B, mx1, A, 8.46830338, 0.00000000, 0, -2048, 2047
 * 3, 1 Ic, C, mx1, A, 8.46830338, 0.00000000, 0, -2048, 2047
 * 4, 1 IN, N, mx1, A, 8.46830338, 0.00000000, 0, -2048, 2047
 * 5, mx1 Ua, A, , kV, 0.15540126, 0.00000000, 0, -2048, 2047
 * 6, mx1 Ub, B, , kV, 0.15540126, 0.00000000, 0, -2048, 2047
 * 7, mx1 Uc, C, , kV, 0.15540126, 0.00000000, 0, -2048, 2047
 * 8, mx1 UN, N, , kV, 0.15540126, 0.00000000, 0, -2048, 2047
 * 1,开关1,0                                                                      【注：通道编号/序号、通道名称、数字量初始状态】
 * 2,开关2,0
 * 3,开关3,0
 * 4,开关4,1
 * 50                                                                                            【注：系统电流电压的频率为50Hz】
 * 2                                                                                                       【注：有两个采样频率】
 * 5000, 6300                                                              【注：第一个采样频率: 在采样率为5000Hz下采了6300个点】
 * 10, 200                                                                    【注：第二个采样频率: 在采样率为10Hz下采了200个点】
 * 03/07/03,14:46:48.850000                                                                                  【注：采样开始时间】
 * 03/07/03,14:46:49.010000                                                                                  【注：采样结束时间】
 * ASCII                                                           【注：dat文件记录格式为ASCII, 还有一种是BINARY（二进制格式）】
 *
 *（2）、 数据文件( DIR00．DAT )
 * 1, 0, 46, -54, 10, 0, 1204, -734, -442, 60, 0, 1, 0, 1       【注：依次为：序号，采样时间，模拟采样记录值[按cfg文件的顺序],数
 *              字采样记录值[按cfg文件的顺序]，其中模拟量实际值算法：y = fCoefA * X + fCoefB, 同最值计算方法；如：
 *              对于46表示的实际值y为：y = fCoefA（即8.46830338） * X（即46） + fCoefB（即0.00000000）
 *              对于－54表示的实际值y为：y = fCoefA（即8.46830338） * X（即－54） + fCoefB（即0.00000000）
 *              对于10表示的实际值y为：y = fCoefA（即8.46830338） * X（即10） + fCoefB（即0.00000000）
 *              对于0表示的实际值y为：y = fCoefA（即0.15540126） * X（即0） + fCoefB（即0.00000000）
 *              对于1024表示的实际值y为：y = fCoefA（即0.15540126） * X（即1024） + fCoefB（即0.00000000）                     】
 * 2, 200, 48, -54, 6, 0, 1218, -682, -504, 60, 0, 1, 0, 1
 * 3, 400, 50, -52, 4, -2, 1206, -616, -554, 58, 0, 1, 0, 1
 * 4, 600, 52,-50, -2, 0, 1192, -542, -614, 56, 0, 1, 0, 1
 *
 * 注：以上说明文字部分来自网络。
 *
 * 另外，对于Binary保存方式的数据文件（dat文件），数据保存格式为：序号[4字节]、采样时间[4字节]、模拟量值[按cfg文件的顺序，两字节
 * 表示一个模拟量采样值]、数字量组值[按cfg文件的顺序，16个数字量一组，一组用2字节表示，不够一组的空位（高位）补零构成一组，组内
 * 从低位bit依次到高位bit与cfg文件里的数字量顺序对应]。
 *
 * 经验表明，目前大部分comtrade文件中的cfg文件中所表示的通道最值与dat中实际的最值都是不相符（出入很大），所以在读dat的接口中引入
 * 了最值统计。
 *
 * 本代码支持win32平台和linux平台。
 *
 * Copyright,lizhi<ibox>
 *
 * 2012-10-10 V1.0 lizhi<QQ:252240557,msn:ddgooo@hotmail.com> created
 *
 */


#ifndef __INCLUDE_COMTRADE_FORMAT_H
#define __INCLUDE_COMTRADE_FORMAT_H



/*
 * 头文件
 */
#include "base_type.h"


#if defined (__cplusplus)
extern "C" {
#endif /* defined (__cplusplus) */


/*
 * 宏开关 定义为文件读写
 */
#define CMTR_IOFILE



/*
 * 宏定义文件的读写操作，可以根据需要改写该接口，如重定义
 * 为网口的recv\send、串口r\w等。
 *
 * _my_read_cmtr_bufn/_my_read_cmtr_bufn - cmtr的读写操作
 * @pfd: 读写地址，可以为文件的fd、或者buffer地址等
 * @buf: 缓冲区地址
 * @count: 需要读写的字节数
 *
 */
#if defined(CMTR_IOFILE)
typedef int _my_cmtr_ioptr;
#define _my_read_cmtr_bufn(pfd, buf, count)             \
        do {                                            \
                if (read((pfd), (buf), (count)) <= 0) { \
                        (pfd) = -1;                     \
                }                                       \
        } while(0);
#define _my_write_cmtr_bufn(pfd, buf, count)            \
        do {                                            \
                if (write((pfd), (buf), (count)) <= 0) {\
                        (pfd) = -1;                     \
                }                                       \
        } while(0);
#define _my_check_cmtr_ptr(pfd)                            \
        (((pfd) != -1) && ((pfd) != 0))
#elif defined(CMTR_IOBUFFER)
typedef u8* _my_cmtr_ioptr;
#define _my_read_cmtr_bufn(pfd, buf, count)             \
        do {                                            \
                memcpy((buf), (pfd), (count));          \
                (pfd) += (count);                       \
        } while(0);
#define _my_write_cmtr_bufn(pfd, buf, count)            \
        do {                                            \
                memcpy((pfd), (buf), (count));          \
                (pfd) += (count);                       \
        } while(0);
#define _my_check_cmtr_ptr(pfd)                            \
        (((pfd) != -1) && ((pfd) != 0))
#endif



/*
 * 关于comtrade文件配置文件的宏定义。
 * 在此采用预定义最大个数方法，避免动态内存管理的问题。
 *
 * 相关字符串最大字符个数，一般不会超过16个；
 * 模拟量端口最大个数，一般不会超过64个；
 * 数字量量端口最大个数，一般不会超过64个；
 * 采样率最大个数，一般不会超过8个；
 *
 */
#define  CMTR_STRING_MAX_LENGTH         64
#define  CMTR_ANALOG_MAX_COUNT          255
#define  CMTR_DIGIT_MAX_COUNT           255
#define  CMTR_SMPRATE_MAX_COUNT         255



/*
 * cmtr_cfg_analog - 配置文件模拟量信息
 * @index: 模拟量端口序号（只是编号，解析时不做序号用）；
 * @name: 模拟量端口名称；
 * @phase: 模拟量端口相标识,值如（A、B、C、N等）；
 * @element：标识（还未知，待补充），一般为空；
 * @unit: 模拟量端口数值的单位，该单位常用来区分该端口是电流还是电流，值如：kV、V、A、mA等；
 * @factor_a: 系数a，一般为整数，可以是浮点数；
 * @factor_b: 系数b，一般为整数，可以是浮点数；
 * @offset_time: 时间偏移,指第一个点的时间偏移量，一般为0；
 * @smp_min: 通道的最小采用值，一般为整数,国内有些变态的仪器会生成浮点数(在次不支持)；
 * @smp_max: 通道的最大采用值，一般为整数,国内有些变态的仪器会生成浮点数(在次不支持)；
 *
 * 通道采样的实际值计算方法：实际值 = factor_a * smp_value + factor_b；所以根据该公式，可以计算
 * 通道的最小值为：factor_a * smp_min + factor_b，最大值为：factor_a * smp_max + factor_b。
 *
 * 注：本来smp_min、smp_max为两个字节的一个数据（即最大为65535），但不同厂家会生成很大的四字节数据，
 *    所以采用s32类型；factor_a、factor_b用double类型，用float可能会丢精度；为了提供解析程序的适
 *    应性，以适应国内各种变态的有标准不遵循的厂家的仪器生成的cmtr文件。
 *
 */
struct cmtr_cfg_analog {
        s32 index;
        u8 name[CMTR_STRING_MAX_LENGTH];
        u8 phase[CMTR_STRING_MAX_LENGTH];
        u8 element[CMTR_STRING_MAX_LENGTH];
        u8 unit[CMTR_STRING_MAX_LENGTH];
        f64 factor_a;
        f64 factor_b;
        s32 offset_time;
        s32 smp_min;
        s32 smp_max;
};


/*
 * cmtr_cfg_digit - 配置文件数字量信息
 * @index: 数字量端口序号（只是编号，解析时不做序号用）；
 * @name: 数字量端口名称；
 * @state: 数字量起始状态值，一般为1或者0，很少情况下会为2；
 *
 */
struct cmtr_cfg_digit {
        s32 index;
        u8 name[CMTR_STRING_MAX_LENGTH];
        s8 state;
};

/*
 * cmtr_cfg_smprate_info - 配置文件采样点信息
 * @rate: 采样率，一般为整数，也有小数表示的；
 * @point: 该采样率下采样的点数，为整数；
 *
 */
struct cmtr_cfg_smprate {
        f32 rate;
        s32 point;
};

/*
 * cmtr_cfg_info - 配置文件信息。
 * @station_name: 厂站名称；
 * @kymograph_id: 录波器编号；
 * @analog_count: 模拟量个数；
 * @digit_count: 数字量个数；
 * @analogs: 模拟量信息；
 * @digits: 数字量信息；
 * @frequency: 基本频率，一般为额定频率，指的是电网频率；
 * @smprate_count: 采样率个数；
 * @smprates: 采样率信息；
 * @begin_time: 录波开始时间；
 * @end_time: 录波结束时间；
 * @file_type: 数据文件类型，可以“ASCII”和“Binary”，ASCII类型为dat文件可以用记事本打开看详
 *             细的采样信息；binary格式的只能用特殊的工具查看，为二进制数据文件；
 *
 */
typedef struct cmtr_cfg_info {
        u8 station_name[CMTR_STRING_MAX_LENGTH];
        u8 kymograph_id[CMTR_STRING_MAX_LENGTH];
        s32 analog_count;
        s32 digit_count;
        struct cmtr_cfg_analog analogs[CMTR_ANALOG_MAX_COUNT];
        struct cmtr_cfg_digit digits[CMTR_DIGIT_MAX_COUNT];
        f32 frequency;
        s32 smprate_count;
        struct cmtr_cfg_smprate smprates[CMTR_SMPRATE_MAX_COUNT];
        u8 begin_time[CMTR_STRING_MAX_LENGTH];
        u8 end_time[CMTR_STRING_MAX_LENGTH];
        u8 file_type[CMTR_STRING_MAX_LENGTH];
};



/*
 * cmtr_dat_smpdot - 数据文件中的采样点数据信息.
 * @index: 端口序号（只是编号，解析时不做序号用）；
 * @time: 采样点采样时间偏移量，单位微妙；
 * @analogs: 模拟量信息，一般为有符号整数，国内有些变态的仪器会生成浮点数(在此不支持)；
 * @digits: 数字量信息，为有符号整数；
 *
 */
struct cmtr_dat_smpdot{
        s32 index;
        s32 time;
        s32 analogs[CMTR_ANALOG_MAX_COUNT];
        s8 digits[CMTR_DIGIT_MAX_COUNT];
};





/*
 * write_cmtr_cfg_info - 写cmtr配置文件.
 * @pfd:  输入输出参数，地址
 * @cfg：输入参数，cmtr(cfg文件)结构体
 * @counter:  输出参数，写入的字节计数器；
 *
 * 返回当前pfd指针,写失败返回NULL
 *
 */
_my_cmtr_ioptr write_cmtr_cfg_info(_my_cmtr_ioptr pfd,
                                   struct cmtr_cfg_info *cfg,
                                   int *counter);


/*
 * write_cmtr_dat_smpdot_ascii - 写cmtr采样点数据信息(ascii格式).
 * @pfd:  输入输出参数，地址
 * @analog_count: 输入参数，模拟量个数；
 * @digit_count: 输入参数，数字量个数；
 * @dot:  输入参数，采样点信息；
 * @counter:  输出参数，写入的字节计数器；
 *
 * 返回当前pfd指针,写失败返回NULL
 *
 */
_my_cmtr_ioptr write_cmtr_dat_smpdot_ascii(_my_cmtr_ioptr pfd,
                                           int analog_count, int digit_count,
                                           struct cmtr_dat_smpdot *dot,
                                           int* counter);

/*
 * write_cmtr_dat_smpdot_binary - 写cmtr采样点数据信息（binary格式）.
 * @pfd:  输入输出参数，地址
 * @big_endian_tag: 输入参数，标识文件中数据的字节顺序，为FALSE按照小端写（默认值），True按照大端写；
 * @analog_count: 输入参数，模拟量个数；
 * @digit_count: 输入参数，数字量个数；
 * @dot:  输入参数，采样点信息；
 * @counter:  输出参数，写入的字节计数器；
 *
 * 返回当前pfd指针,写失败返回NULL
 *
 */
_my_cmtr_ioptr write_cmtr_dat_smpdot_binary(_my_cmtr_ioptr pfd,
                                            u8 big_endian_tag,
                                            int analog_count, int digit_count,
                                            struct cmtr_dat_smpdot *dot,
                                            int* counter);


/*
 * read_cmtr_cfg_info - 读cmtr配置文件.
 * @pfd:  输入输出参数，地址
 * @cfg：输出参数，cmtr(cfg文件)结构体
 * @counter:  输出参数，读取的字节计数器；
 *
 * 返回当前pfd指针,读失败返回NULL
 *
 */
_my_cmtr_ioptr read_cmtr_cfg_info(_my_cmtr_ioptr pfd,
                                  struct cmtr_cfg_info *cfg,
                                  int* counter);


/*
 * read_cmtr_dat_smpdot_ascii - 读ascii格式cmtr采样点数据信息.
 * @pfd:  输入输出参数，地址
 * @read_buf: 输入参数，读缓冲,在外部申请内存，避免在内部频繁申请、释放内存；
 * @buf_size: 输入参数，读缓冲区的大小；
 * @analog_count: 输入参数，模拟量个数；
 * @digit_count: 输入参数，数字量个数；
 * @dot:  输出参数，采样点信息；
 * @the_smp_mins: 输出参数，统计最小值,为数组，个数至少为analog_count个,值为NULL时忽略统计；
 * @the_smp_maxs: 输出参数，统计最大值,为数组，个数至少为analog_count个,值为NULL时忽略统计；
 * @counter:  输出参数，读取的字节计数器；
 *
 * 返回当前pfd指针,读失败返回NULL
 *
 */
_my_cmtr_ioptr read_cmtr_dat_smpdot_ascii(_my_cmtr_ioptr pfd,
                                          u8 *read_buf, int buf_size,
                                          int analog_count, int digit_count,
                                          struct cmtr_dat_smpdot *dot,
                                          u16* the_smp_mins, u16* the_smp_maxs,
                                          int* counter);

/*
 * read_cmtr_dat_smpdot_binary - 读bin格式cmtr采样点数据信息.
 * @pfd:  输入输出参数，地址
 * @big_endian_tag: 输入参数，标识文件中数据的字节顺序，为FALSE按照小端读（默认值），True按照大端读；
 * @analog_count: 输入参数，模拟量个数；
 * @digit_count: 输入参数，数字量个数；
 * @dot:  输出参数，采样点信息；
 * @the_smp_mins: 输出参数，统计最小值,为数组，个数至少为analog_count个,值为NULL时忽略统计；
 * @the_smp_maxs: 输出参数，统计最大值,为数组，个数至少为analog_count个,值为NULL时忽略统计；
 * @counter:  输出参数，读取的字节计数器；
 *
 * 返回当前pfd指针,读失败返回NULL
 *
 */
_my_cmtr_ioptr read_cmtr_dat_smpdot_binary(_my_cmtr_ioptr pfd, u8 big_endian_tag,
                                           int analog_count, int digit_count,
                                           struct cmtr_dat_smpdot *dot,
                                           u32* the_smp_mins, u32* the_smp_maxs,
                                           int* counter);

/*
 * print_cmtr_cfg_info - 打印cmtr文件配置数.
 * @cfg:  输入参数，cmtr文件配置数据;
 *
 */
void print_cmtr_cfg_info(struct cmtr_cfg_info *cfg);

/*
 * print_cmtr_dat_smpdot - 打印cmtr数据文件采样点.
 * @cfg:  输入参数，cmtr文件配置数据;
 * @analog_count: 输入参数，模拟量个数；
 * @digit_count: 输入参数，数字量个数；
 * @dot:  输入参数，采样点信息；
 *
 */
void print_cmtr_dat_smpdot(int analog_count, int digit_count,
                           struct cmtr_dat_smpdot *dot);



#if defined (__cplusplus)
}
#endif /* defined (__cplusplus) */


#endif /* __INCLUDE_COMTRADE_FORMAT_H */

comtrade_format.c

/*
 * 分析解析COMTRADE（IEEE标准电力系统暂态数据交换通用格式）文件格式。
 *
 *
 * 本代码支持win32平台和linux平台。
 *
 * Copyright,lizhi<ibox>
 *
 * 2012-10-10 V1.0 lizhi<QQ:252240557,msn:ddgooo@hotmail.com> created
 *
 */

/*
 * 头文件
 */
#include "base_type.h"
#include "base_include.h"
#include "base_debug.h"
#include "base_endian.h"
#include "base_function.h"
#include "comtrade_format.h"


/*
 * 测试宏开关
 */
///*
#define CMTR_CONSOLE_DEMO
//*/


/*
 * _my_read_cmtr_data/_my_write_cmtr_data - 读取/写入并且转换cmtr数据。
 * @src: 读写地址，为buffer地址；
 * @data:  读取/写入的数据；
 * @count: 需要读取/写入的字节个数；
 * @counter:  读取/写入的字节计数器；
 *
 */
#define _my_read_cmtr_data(src, data, count, counter)                   \
        do {                                                            \
                if (_my_check_cmtr_ptr(src)) {                          \
                        _my_read_cmtr_bufn((src), (data), (count));     \
                        (counter) += (count);                           \
                }                                                       \
        } while(0);
#define _my_write_cmtr_data(src, data, count, counter)                  \
        do {                                                            \
                if (_my_check_cmtr_ptr(src)) {                          \
                        _my_write_cmtr_bufn((src), (data), (count));    \
                        (counter) +=(count);                            \
                }                                                       \
        } while(0);

/*
 * write_cmtr_cfg_info - 写cmtr配置文件.
 * @pfd:  输入输出参数，地址
 * @cfg：输入参数，cmtr(cfg文件)结构体
 * @counter:  输出参数，写入的字节计数器；
 *
 * 返回当前pfd指针,写失败返回NULL
 *
 */
_my_cmtr_ioptr write_cmtr_cfg_info(_my_cmtr_ioptr pfd, struct cmtr_cfg_info *cfg, int *counter)
{
        u32 strlenr = 0;
        u32 strmaxl = CMTR_STRING_MAX_LENGTH * 10;
        u8* strline = (u8 *)_my_buf_malloc((size_t)(strmaxl));
        u32 index = 0;

        _my_cmtr_ioptr curr_pfd = pfd;

        memset(strline, '\0', strmaxl);
        strlenr = sprintf(strline, "%s,%s\n", cfg->station_name, cfg->kymograph_id);
        _my_write_cmtr_data(curr_pfd, strline, strlenr, *counter);

        memset(strline, '\0', strmaxl);
        strlenr = sprintf(strline, "%d,%dA,%dD\n", cfg->analog_count + cfg->digit_count, cfg->analog_count, cfg->digit_count);
        _my_write_cmtr_data(curr_pfd, strline, strlenr, *counter);

        for (index = 0; index < cfg->analog_count; index++) {
                memset(strline, '\0', strmaxl);
                strlenr = sprintf(strline, "%d,%s,%s,%s,%s,%lf,%lf,%d,%d,%d\n",
                                  cfg->analogs[index].index,
                                  cfg->analogs[index].name,
                                  cfg->analogs[index].phase,
                                  cfg->analogs[index].element,
                                  cfg->analogs[index].unit,
                                  cfg->analogs[index].factor_a,
                                  cfg->analogs[index].factor_b,
                                  cfg->analogs[index].offset_time,
                                  cfg->analogs[index].smp_min,
                                  cfg->analogs[index].smp_max);
                _my_write_cmtr_data(curr_pfd, strline, strlenr, *counter);
        }

        for (index = 0; index < cfg->digit_count; index++) {
                memset(strline, '\0', strmaxl);
                strlenr = sprintf(strline, "%d,%s,%d\n",
                                  cfg->digits[index].index,
                                  cfg->digits[index].name,
                                  cfg->digits[index].state);
                _my_write_cmtr_data(curr_pfd, strline, strlenr, *counter);
        }

        memset(strline, '\0', strmaxl);
        strlenr = sprintf(strline, "%f\n", cfg->frequency);
        _my_write_cmtr_data(curr_pfd, strline, strlenr, *counter);

        memset(strline, '\0', strmaxl);
        strlenr = sprintf(strline, "%d\n", cfg->smprate_count);
        _my_write_cmtr_data(curr_pfd, strline, strlenr, *counter);
        for (index = 0; index < cfg->smprate_count; index++) {
                memset(strline, '\0', strmaxl);
                strlenr = sprintf(strline, "%f,%d\n", cfg->smprates[index].rate, cfg->smprates[index].point);
                _my_write_cmtr_data(curr_pfd, strline, strlenr, *counter);
        }

        memset(strline, '\0', strmaxl);
        strlenr = sprintf(strline, "%s\n", cfg->begin_time);
        _my_write_cmtr_data(curr_pfd, strline, strlenr, *counter);
        memset(strline, '\0', strmaxl);
        strlenr = sprintf(strline, "%s\n", cfg->end_time);
        _my_write_cmtr_data(curr_pfd, strline, strlenr, *counter);
        strlenr = sprintf(strline, "%s\n", cfg->file_type);
        _my_write_cmtr_data(curr_pfd, strline, strlenr, *counter);

        _my_buf_free(strline);

        return curr_pfd;
}


/*
 * write_cmtr_dat_smpdot_ascii - 写cmtr采样点数据信息(ascii格式).
 * @pfd:  输入输出参数，地址
 * @analog_count: 输入参数，模拟量个数；
 * @digit_count: 输入参数，数字量个数；
 * @dot:  输入参数，采样点信息；
 * @counter:  输出参数，写入的字节计数器；
 *
 * 返回当前pfd指针,写失败返回NULL
 *
 */
_my_cmtr_ioptr write_cmtr_dat_smpdot_ascii(_my_cmtr_ioptr pfd, int analog_count, int digit_count, struct cmtr_dat_smpdot *dot, int* counter)
{
        u32 strlenr = 0;
        u32 strmaxl = CMTR_STRING_MAX_LENGTH;
        u8* strline = (u8 *)_my_buf_malloc((size_t)(strmaxl));
        int index = 0;

        _my_cmtr_ioptr curr_pfd = pfd;

        _my_assert(pfd && dot);

        memset(strline, '\0', strmaxl);
        strlenr = sprintf(strline, "%d,%d", dot->index, dot->time);
        _my_write_cmtr_data(curr_pfd, strline, strlenr, *counter);
        for (index = 0; index < analog_count; index++) {
                memset(strline, '\0', strmaxl);
                strlenr = sprintf(strline, ",%d", dot->analogs[index]);
                _my_write_cmtr_data(curr_pfd, strline, strlenr, *counter);
        }
        for (index = 0; index < digit_count; index++) {
                memset(strline, '\0', strmaxl);
                strlenr = sprintf(strline, ",%d", dot->digits[index]);
                _my_write_cmtr_data(curr_pfd, strline, strlenr, *counter);
        }
        memset(strline, '\0', strmaxl);
        strlenr = sprintf(strline, "\n");
        _my_write_cmtr_data(curr_pfd, strline, strlenr, *counter);

        _my_buf_free(strline);

        return curr_pfd;
}


/*
 * write_cmtr_dat_smpdot_binary - 写cmtr采样点数据信息（binary格式）.
 * @pfd:  输入输出参数，地址
 * @big_endian_tag: 输入参数，标识文件中数据的字节顺序，为FALSE按照小端写（默认值），True按照大端写；
 * @analog_count: 输入参数，模拟量个数；
 * @digit_count: 输入参数，数字量个数；
 * @dot:  输入参数，采样点信息；
 * @counter:  输出参数，写入的字节计数器；
 *
 * 返回当前pfd指针,写失败返回NULL
 *
 */
_my_cmtr_ioptr write_cmtr_dat_smpdot_binary(_my_cmtr_ioptr pfd, u8 big_endian_tag, int analog_count, int digit_count, struct cmtr_dat_smpdot *dot, int* counter)
{
        s16 data16 = 0x00;
        s32 data32 = 0x00;
        int oldnum = 0;

        s16 datatp = 0x00;

        int index = 0;

        _my_cmtr_ioptr curr_pfd = pfd;

        oldnum = (*counter);
        data32 = big_endian_tag ? _my_htob32(dot->index) : _my_htol32(dot->index);
        _my_write_cmtr_data(curr_pfd, &data32, 4, *counter);
        if ((*counter) <= oldnum) {
                return NULL;
        }
        oldnum = (*counter);
        data32 = big_endian_tag ? _my_htob32(dot->time) : _my_htol32(dot->time);
        _my_write_cmtr_data(curr_pfd, &data32, 4, *counter);
        if ((*counter) <= oldnum) {
                return NULL;
        }
        for (index = 0; index < analog_count; index++) {
                oldnum = (*counter);
                datatp = (s16)(dot->analogs[index]);
                data16 = big_endian_tag ? _my_htob16(datatp) : _my_htol16(datatp);
                _my_write_cmtr_data(curr_pfd, &data16, 2, *counter);
                if ((*counter) <= oldnum) {
                        return NULL;
                }
        }

        data16 = 0x0000;
        for (index = 0; index < digit_count; index++) {
                if (dot->digits[index]) {
                        data16 |= (0x0001 << (index % 16));
                }
                if (((index % 16) == 0) && (index != 0)) {
                        oldnum = (*counter);
                        data16 = big_endian_tag ? _my_htob16(data16) : _my_htol16(data16);
                        _my_write_cmtr_data(curr_pfd, &data16, 2, *counter);
                        if ((*counter) <= oldnum) {
                                return NULL;
                        }
                }
        }
        if (((index % 16) != 1) && (index != 0)) {
                oldnum = (*counter);
                data16 = big_endian_tag ? _my_htob16(data16) : _my_htol16(data16);
                _my_write_cmtr_data(curr_pfd, &data16, 2, *counter);
                if ((*counter) <= oldnum) {
                        return NULL;
                }
        }

        return curr_pfd;
}


/*
 * read_cmtr_cfg_line - 读cmtr配置文件一行，跳过空行.
 * @pfd:  输入输出参数，地址；
 * @strline：输出参数，内容缓冲区；
 * @size：输入参数，缓冲区大小；
 * @strlend: 输出参数，读取的line的结束字符指针；
 * @counter:  输出参数，读取的字节计数器；
 *
 * 返回当前pfd指针,读失败返回NULL。
 *
 */
static _my_cmtr_ioptr read_cmtr_cfg_line(_my_cmtr_ioptr pfd, char *strline, int size, char **strlend,int *counter)
{
        int pos = 0;
        int oldnum = 0;
        u8 datard = 0;
        _my_cmtr_ioptr curr_pfd = pfd;
        (*strlend) = NULL;
        if (size <= 0) {
                return NULL;
        }
        if ((!strline) || (!counter)) {
                return NULL;
        }

        memset(strline, '\0', size);
        while (_my_check_cmtr_ptr(curr_pfd)) {
                oldnum = (*counter);
                datard = '\0';
                _my_read_cmtr_data(curr_pfd, &datard, 1, *counter);
                if ((*counter) > oldnum) {
                        if (( datard != '\0') && ( datard != '\r') && ( datard != '\n')) {
                                if ((*strlend) < (strline + size)) {
                                        (*(strline + pos)) = datard;
                                        (*strlend) = strline + pos;
                                }
                                pos += 1;
                                continue;
                        } else {
                                break;
                        }
                }
        }
        if (pos == 0) {
                if (_my_check_cmtr_ptr(curr_pfd)) {
                        return read_cmtr_cfg_line(curr_pfd, strline, size, strlend, counter);
                } else {
                        return NULL;
                }
        }

        return curr_pfd;
}

/*
 * read_cmtr_cfg_one_analog - 分析一行模拟量信息.
 * @analog:  输出参数，模拟量信息；
 * @strline：输入参数，内容缓冲区；
 * @size：输入参数，缓冲区大小；
 * @strlend: 输入参数，读取的line结束指针；
 *
 * 返回TRUE成功,失败返回FALSE。
 *
 */
static u8 read_cmtr_cfg_one_analog(struct cmtr_cfg_analog *analog, char *strline, int size, char *strlend)
{
        int dataint = 0;
        f64 dataflt = 0;
        char* ptrpos = 0;
        char* strlcur = strline;

        ptrpos = strchr(strlcur, ',');
        if ((!ptrpos) || (ptrpos >= strlend)) {
                return FALSE;
        }
        if (sscanf(strlcur, "%d%*s", &dataint) <= 0) {
                return FALSE;
        }
        analog->index = dataint;

        strlcur = ptrpos += 1;
        ptrpos = strchr(strlcur, ',');
        if ((!ptrpos) || (ptrpos >= strlend)) {
                return FALSE;
        }
        memset(analog->name, '\0', CMTR_STRING_MAX_LENGTH);
        memcpy(analog->name, strlcur, ptrpos-strlcur);

        strlcur = ptrpos += 1;
        ptrpos = strchr(strlcur, ',');
        if ((!ptrpos) || (ptrpos >= strlend)) {
                return FALSE;
        }
        memset(analog->phase, '\0', CMTR_STRING_MAX_LENGTH);
        memcpy(analog->phase, strlcur, ptrpos-strlcur);

        strlcur = ptrpos += 1;
        ptrpos = strchr(strlcur, ',');
        if ((!ptrpos) || (ptrpos >= strlend)) {
                return FALSE;
        }
        memset(analog->element, '\0', CMTR_STRING_MAX_LENGTH);
        memcpy(analog->element, strlcur, ptrpos-strlcur);

        strlcur = ptrpos += 1;
        ptrpos = strchr(strlcur, ',');
        if ((!ptrpos) || (ptrpos >= strlend)) {
                return FALSE;
        }
        memset(analog->unit, '\0', CMTR_STRING_MAX_LENGTH);
        memcpy(analog->unit, strlcur, ptrpos-strlcur);

        strlcur = ptrpos += 1;
        ptrpos = strchr(strlcur, ',');
        if ((!ptrpos) || (ptrpos >= strlend)) {
                return FALSE;
        }
        if (sscanf(strlcur, "%lf%*s", &dataflt) <= 0) {
                return FALSE;
        }
        analog->factor_a = dataflt;

        strlcur = ptrpos += 1;
        ptrpos = strchr(strlcur, ',');
        if ((!ptrpos) || (ptrpos >= strlend)) {
                return FALSE;
        }
        if (sscanf(strlcur, "%lf%*s", &dataflt) <= 0) {
                return FALSE;
        }
        analog->factor_b = dataflt;

        strlcur = ptrpos += 1;
        ptrpos = strchr(strlcur, ',');
        if ((!ptrpos) || (ptrpos >= strlend)) {
                return FALSE;
        }
        if (sscanf(strlcur, "%d%*s", &dataint) <= 0) {
                return FALSE;
        }
        analog->offset_time = dataint;

        strlcur = ptrpos += 1;
        ptrpos = strchr(strlcur, ',');
        if ((!ptrpos) || (ptrpos >= strlend)) {
                return FALSE;
        }
        if (sscanf(strlcur, "%d%*s", &dataint) <= 0) {
                return FALSE;
        }
        analog->smp_min = dataint;

        strlcur = ptrpos += 1;
        if (ptrpos > strlend) {
                return FALSE;
        }
        if (sscanf(strlcur, "%d%*s", &dataint) <= 0) {
                return FALSE;
        }
        analog->smp_max = dataint;

        return TRUE;
}

/*
 * read_cmtr_cfg_one_digit - 分析一行数字量信息.
 * @analog:  输出参数，数字量信息；
 * @strline：输入参数，内容缓冲区；
 * @size：输入参数，缓冲区大小；
 * @strlend: 输入参数，读取的line结束指针；
 *
 * 返回TRUE成功,失败返回FALSE。
 *
 */
static u8 read_cmtr_cfg_one_digit(struct cmtr_cfg_digit *digit, char *strline, int size, char *strlend)
{
        int dataint = 0;
        char* ptrpos = 0;
        char* strlcur = strline;
        ptrpos = strchr(strlcur, ',');
        if ((!ptrpos) || (ptrpos >= strlend)) {
                return FALSE;
        }
        if (sscanf(strlcur, "%d%*s", &dataint) <= 0) {
                return FALSE;
        }
        digit->index = dataint;

        strlcur = ptrpos += 1;
        ptrpos = strchr(strlcur, ',');
        if ((!ptrpos) || (ptrpos >= strlend)) {
                return FALSE;
        }
        memset(digit->name, '\0', CMTR_STRING_MAX_LENGTH);
        memcpy(digit->name, strlcur, ptrpos-strlcur);

        strlcur = ptrpos += 1;
        if (ptrpos > strlend) {
                return FALSE;
        }
        if (sscanf(strlcur, "%d", &dataint) <= 0) {
                return FALSE;
        }
        digit->state = dataint;

        return TRUE;
}

/*
 * read_cmtr_cfg_info - 读cmtr配置文件.
 * @pfd:  输入输出参数，地址
 * @cfg：输出参数，cmtr(cfg文件)结构体
 * @counter:  输出参数，读取的字节计数器；
 *
 * 返回当前pfd指针,读失败返回NULL
 *
 */
_my_cmtr_ioptr read_cmtr_cfg_info(_my_cmtr_ioptr pfd, struct cmtr_cfg_info *cfg, int* counter)
{
        u8 returntag = FALSE;

        int strsize = 1024;
        char* strline = NULL;
        char* strlcur = NULL;
        char* strlend = NULL;
        _my_cmtr_ioptr curr_pfd = pfd;

        char* ptrpos = 0;

        int port1num = 0;
        int port2num = 0;
        char port1chr = '\0';
        char port2chr = '\0';

        int index = 0;
        int dataint = 0;
        f32 dataflt = 0;

        _my_assert(pfd && cfg);

        strline = _my_buf_malloc(strsize);
        memset(strline, '\0', strsize);

        /* read station name and  kymograph id */
        curr_pfd = read_cmtr_cfg_line(curr_pfd, strline, strsize, &strlend, counter);

        if (!curr_pfd) {
                goto RETURN_FINISH;
        }
        strlcur = strline;
        ptrpos = strchr(strlcur, ',');
        memset(cfg->station_name, '\0', CMTR_STRING_MAX_LENGTH);
        memset(cfg->kymograph_id, '\0', CMTR_STRING_MAX_LENGTH);
        if (ptrpos) {
                memcpy(cfg->station_name, strlcur, ptrpos - strlcur);
                if (ptrpos < strlend) {
                        ptrpos += 1;
                        memcpy(cfg->kymograph_id, ptrpos, strlen(ptrpos));
                }
        } else {
                memcpy(cfg->station_name, strlcur, strlen(strlcur));
        }

        /* read port count */
        curr_pfd = read_cmtr_cfg_line(curr_pfd, strline, strsize, &strlend, counter);
        if (!curr_pfd) {
                goto RETURN_FINISH;
        }
        strlcur = strline;
        ptrpos = strchr(strlcur, ',');
        if ((!ptrpos) || (ptrpos >= strlend)) {
                goto RETURN_FINISH;
        }
        ptrpos += 1;
        if (sscanf(ptrpos, "%d%c%*s", &port1num, &port1chr) <= 0) {
                goto RETURN_FINISH;
        }
        ptrpos = strchr(ptrpos, ',');
        if ((!ptrpos) || (ptrpos >= strlend)) {
                goto RETURN_FINISH;
        }
        ptrpos += 1;
        if (sscanf(ptrpos, "%d%c", &port2num, &port2chr) <= 0) {
                goto RETURN_FINISH;
        }
        if ((port1chr == 'A') || (port1chr == 'a')) {
                cfg->analog_count = port1num;
                cfg->digit_count = port2num;
        } else if ((port1chr == 'D') || (port1chr == 'd')) {
                cfg->analog_count = port2num;
                cfg->digit_count = port1num;
        } else {
                goto RETURN_FINISH;
        }

        /* read analog port info */
        for (index = 0; index < cfg->analog_count; index++) {
                curr_pfd = read_cmtr_cfg_line(curr_pfd, strline, strsize, &strlend, counter);
                if (!curr_pfd) {
                        goto RETURN_FINISH;
                }
                if (!read_cmtr_cfg_one_analog((cfg->analogs)+index, strline, strsize, strlend)) {
                        goto RETURN_FINISH;
                }
        }
        /* read digit port info */
        for (index = 0; index < cfg->digit_count; index++) {
                curr_pfd = read_cmtr_cfg_line(curr_pfd, strline, strsize, &strlend, counter);
                if (!curr_pfd) {
                        goto RETURN_FINISH;
                }
                if (!read_cmtr_cfg_one_digit((cfg->digits)+index, strline, strsize, strlend)) {
                        goto RETURN_FINISH;
                }
        }

        /* read Frequency info */
        curr_pfd = read_cmtr_cfg_line(curr_pfd, strline, strsize, &strlend, counter);
        if (!curr_pfd) {
                goto RETURN_FINISH;
        }
        if (strline > strlend) {
                goto RETURN_FINISH;
        }
        if (sscanf(strline, "%f", &dataflt) <= 0) {
                goto RETURN_FINISH;
        }
        cfg->frequency = dataflt;

        /* read smprate count info */
        curr_pfd = read_cmtr_cfg_line(curr_pfd, strline, strsize, &strlend, counter);
        if (!curr_pfd) {
                goto RETURN_FINISH;
        }
        if (strline > strlend) {
                goto RETURN_FINISH;
        }
        if (sscanf(strline, "%d", &dataint) <= 0) {
                goto RETURN_FINISH;
        }
        cfg->smprate_count = dataint;

        /* read smprate info */
        for (index = 0; index < cfg->smprate_count; index ++) {
                curr_pfd = read_cmtr_cfg_line(curr_pfd, strline, strsize, &strlend, counter);
                if (!curr_pfd) {
                        goto RETURN_FINISH;
                }
                strlcur = strline;
                ptrpos = strchr(strlcur, ',');
                if ((!ptrpos) || (ptrpos >= strlend)) {
                        goto RETURN_FINISH;
                }
                if (sscanf(strlcur, "%f%*s", &dataflt) <= 0) {
                        goto RETURN_FINISH;
                }
                cfg->smprates[index].rate = dataflt;
                strlcur = ptrpos += 1;
                if (ptrpos > strlend) {
                        goto RETURN_FINISH;
                }
                if (sscanf(strlcur, "%d", &dataint) <= 0) {
                        goto RETURN_FINISH;
                }
                cfg->smprates[index].point = dataint;
        }

        /* read time info */
        curr_pfd = read_cmtr_cfg_line(curr_pfd, strline, strsize, &strlend, counter);
        if (!curr_pfd) {
                goto RETURN_FINISH;
        }
        memset(cfg->begin_time, '\0', CMTR_STRING_MAX_LENGTH);
        if (strlend - strline >= 0) {
                memcpy(cfg->begin_time, strline, strlend - strline + 1);
        }
        curr_pfd = read_cmtr_cfg_line(curr_pfd, strline, strsize, &strlend, counter);
        if (!curr_pfd) {
                goto RETURN_FINISH;
        }
        memset(cfg->end_time, '\0', CMTR_STRING_MAX_LENGTH);
        if (strlend - strline >= 0) {
                memcpy(cfg->end_time, strline, strlend - strline + 1);
        }

        /* read dat type info */
        curr_pfd = read_cmtr_cfg_line(curr_pfd, strline, strsize, &strlend, counter);
        if (!curr_pfd) {
                goto RETURN_FINISH;
        }
        strlcur =_my_strupr(strline);
        ptrpos = strstr(strlcur, "BIN");
        memset(cfg->file_type, '\0', CMTR_STRING_MAX_LENGTH);
        if (ptrpos > 0) {
                strcpy(cfg->file_type, "BINARY");
        } else if (strstr(strlcur, "ASC") > 0) {
                strcpy(cfg->file_type, "ASCII");
        }
        else {
                goto RETURN_FINISH;
        }

        returntag = TRUE;

RETURN_FINISH:
        _my_buf_free(strline);
        return returntag ? curr_pfd : NULL;
}

/*
 * read_cmtr_dat_smpdot_binary - 读bin格式cmtr采样点数据信息.
 * @pfd:  输入输出参数，地址
 * @big_endian_tag: 输入参数，标识文件中数据的字节顺序，为FALSE按照小端读（默认值），True按照大端读；
 * @analog_count: 输入参数，模拟量个数；
 * @digit_count: 输入参数，数字量个数；
 * @dot:  输出参数，采样点信息；
 * @the_smp_mins: 输出参数，统计最小值,为数组，个数至少为analog_count个,值为NULL时忽略统计；
 * @the_smp_maxs: 输出参数，统计最大值,为数组，个数至少为analog_count个,值为NULL时忽略统计；
 * @counter:  输出参数，读取的字节计数器；
 *
 * 返回当前pfd指针,读失败返回NULL
 *
 */
_my_cmtr_ioptr read_cmtr_dat_smpdot_binary(_my_cmtr_ioptr pfd, u8 big_endian_tag,
                                           int analog_count, int digit_count,
                                           struct cmtr_dat_smpdot *dot,
                                           u32* the_smp_mins, u32* the_smp_maxs,
                                           int* counter)
{
        u16 data16 = 0x00;
        u32 data32 = 0x00;
        int oldnum = 0;

        int index = 0;
        int bitpos = 0;

        _my_cmtr_ioptr curr_pfd = pfd;

        oldnum = (*counter);
        data32 = 0x00;
        _my_read_cmtr_data(curr_pfd, &data32, 4, *counter);
        if ((*counter) <= oldnum) {
                return NULL;
        }
        dot->index =  big_endian_tag ? _my_btoh32(data32) : _my_ltoh32(data32);

        oldnum = (*counter);
        data32 = 0x00;
        _my_read_cmtr_data(curr_pfd, &data32, 4, *counter);
        if ((*counter) <= oldnum) {
                return NULL;
        }
        dot->time =  big_endian_tag ? _my_btoh32(data32) : _my_ltoh32(data32);

        /* read analog port info */
        for (index = 0; index < analog_count; index ++) {
                oldnum = (*counter);
                data16 = 0x00;
                _my_read_cmtr_data(curr_pfd, &data16, 2, *counter);
                if ((*counter) <= oldnum) {
                        return NULL;
                }
                dot->analogs[index] =  big_endian_tag ? _my_btoh16(data16) : _my_ltoh16(data16);
                if (the_smp_mins) {
                        if (the_smp_mins + index) {
                                the_smp_mins[index] = _my_min(the_smp_mins[index], dot->analogs[index]);
                        }
                }
                if (the_smp_maxs) {
                        if (the_smp_maxs + index) {
                                the_smp_maxs[index] = _my_min(the_smp_maxs[index], dot->analogs[index]);
                        }
                }
        }
        /* read digit port info */
        for (index = 0; index < digit_count; index ++) {
                oldnum = (*counter);
                data16 = 0x00;
                _my_read_cmtr_data(curr_pfd, &data16, 2, *counter);
                if ((*counter) <= oldnum) {
                        return NULL;
                }
                data16 =  big_endian_tag ? _my_btoh16(data16) : _my_ltoh16(data16);
                for (bitpos = 0; bitpos < 16; bitpos++) {
                        if ((index * 16 + bitpos) < digit_count) {
                                dot->digits[index * 16 + bitpos] = (data16 & (0x0001 << bitpos));
                        } else {
                                break;
                        }
                }
        }

        return curr_pfd;
}

/*
 * read_cmtr_dat_smpdot_ascii - 读ascii格式cmtr采样点数据信息.
 * @pfd:  输入输出参数，地址
 * @read_buf: 输入参数，读缓冲,在外部申请内存，避免在内部频繁申请、释放内存；
 * @buf_size: 输入参数，读缓冲区的大小；
 * @analog_count: 输入参数，模拟量个数；
 * @digit_count: 输入参数，数字量个数；
 * @dot:  输出参数，采样点信息；
 * @the_smp_mins: 输出参数，统计最小值,为数组，个数至少为analog_count个,值为NULL时忽略统计；
 * @the_smp_maxs: 输出参数，统计最大值,为数组，个数至少为analog_count个,值为NULL时忽略统计；
 * @counter:  输出参数，读取的字节计数器；
 *
 * 返回当前pfd指针,读失败返回NULL
 *
 */
_my_cmtr_ioptr read_cmtr_dat_smpdot_ascii(_my_cmtr_ioptr pfd,
                                          u8 *read_buf, int buf_size,
                                          int analog_count, int digit_count,
                                          struct cmtr_dat_smpdot *dot,
                                          u16* the_smp_mins,u16* the_smp_maxs,
                                          int* counter)
{
        char* ptrpos = 0;
        char* strlend = 0;

        int index = 0;

        int dataint = 0;
        float dataflt = 0;

        _my_cmtr_ioptr curr_pfd = pfd;

        memset(read_buf, '\0', buf_size);
        curr_pfd = read_cmtr_cfg_line(curr_pfd, read_buf, buf_size, &strlend, counter);
        if (!curr_pfd) {
                return NULL;
        }

        ptrpos = read_buf;
        if ((!ptrpos) || (ptrpos >= strlend)) {
                return NULL;
        }
        if (sscanf(ptrpos, "%d%*s", &dataint) <= 0) {
                return NULL;
        }
        dot->index = dataint;
        ptrpos = strchr(ptrpos, ',');
        if (!ptrpos) {
                return NULL;
        }
        ptrpos += 1;
        if ((!ptrpos) || (ptrpos > strlend)) {
                return NULL;
        }
        if (sscanf(ptrpos, "%d%*s", &dataint) <= 0) {
                return NULL;
        }
        dot->time = dataint;

        /* read analog port info */
        for (index = 0; index < analog_count; index ++) {
                ptrpos = strchr(ptrpos, ',');
                if (!ptrpos) {
                        return NULL;
                }
                ptrpos += 1;
                if ((!ptrpos) || (ptrpos > strlend)) {
                        return NULL;
                }
                if (sscanf(ptrpos, "%f%*s", &dataflt) <= 0) {
                        return NULL;
                }
                dot->analogs[index] = dataflt;
                if (the_smp_mins) {
                        if (the_smp_mins + index) {
                                the_smp_mins[index] = _my_min(the_smp_mins[index], dataflt);
                        }
                }
                if (the_smp_maxs) {
                        if (the_smp_maxs + index) {
                                the_smp_maxs[index] = _my_min(the_smp_maxs[index], dataflt);
                        }
                }
        }
        /* read digit port info */
        for (index = 0; index < digit_count; index ++) {
                ptrpos = strchr(ptrpos, ',');
                if (!ptrpos) {
                        return NULL;
                }
                ptrpos += 1;
                if ((!ptrpos) || (ptrpos > strlend)) {
                        return NULL;
                }
                if (sscanf(ptrpos, "%d%*s", &dataint) <= 0) {
                        return NULL;
                }
                dot->digits[index] = dataint;
        }

        return curr_pfd;
}

/*
 * print_cmtr_cfg_info - 打印cmtr文件配置数.
 * @cfg:  输入参数，cmtr文件配置数据;
 *
 */
void print_cmtr_cfg_info(struct cmtr_cfg_info *cfg)
{
        u32 index = 0;
        if ( cfg ) {
                _my_printf("=====================\n");
                _my_printf("%s,%s\n", cfg->station_name, cfg->kymograph_id);
                _my_printf("%d,%dA,%dD\n", cfg->analog_count + cfg->digit_count, cfg->analog_count, cfg->digit_count);
                for (index = 0; index < cfg->analog_count; index++) {
                        _my_printf("%d,%s,%s,%s,%s,%.6lf,%.6lf,%d,%d,%d\n",
                                 cfg->analogs[index].index,
                                 cfg->analogs[index].name,
                                 cfg->analogs[index].phase,
                                 cfg->analogs[index].element,
                                 cfg->analogs[index].unit,
                                 cfg->analogs[index].factor_a,
                                 cfg->analogs[index].factor_b,
                                 cfg->analogs[index].offset_time,
                                 cfg->analogs[index].smp_min,
                                 cfg->analogs[index].smp_max);
                }
                for (index = 0; index < cfg->digit_count; index++) {
                        _my_printf("%d,%s,%d\n",
                                 cfg->digits[index].index,
                                 cfg->digits[index].name,
                                 cfg->digits[index].state);
                }
                _my_printf("%.6f\n", cfg->frequency);
                for (index = 0; index < cfg->smprate_count; index++) {
                        _my_printf("%f,%d\n", cfg->smprates[index].rate, cfg->smprates[index].point);
                }
                _my_printf("%s\n", cfg->begin_time);
                _my_printf("%s\n", cfg->end_time);
                _my_printf("%s\n", cfg->file_type);
                _my_printf("=====================\n");
        }
}

/*
 * print_cmtr_dat_smpdot - 打印cmtr数据文件采样点.
 * @cfg:  输入参数，cmtr文件配置数据;
 * @analog_count: 输入参数，模拟量个数；
 * @digit_count: 输入参数，数字量个数；
 * @dot:  输入参数，采样点信息；
 *
 */
void print_cmtr_dat_smpdot(int analog_count, int digit_count, struct cmtr_dat_smpdot *dot)
{
        int index = 0;
        if ( dot ) {
                _my_printf("%u,%d", dot->index, dot->time);
                for (index = 0; index < analog_count; index++) {
                        _my_printf(",%d", dot->analogs[index]);
                }
                for (index = 0; index < digit_count; index++) {
                        _my_printf(",%d", dot->digits[index]);
                }
                _my_printf("\n");
        }
}


#ifdef CMTR_CONSOLE_DEMO


/*
 * _my_cmtr_openrb/_my_cmtr_openwb/_my_cmtr_openab/_my_cmtr_close
 *              - 可以根据需要改写该接口，如重定义为网口的recv\send、串口r\w等
 * @pfd:  文件地址、缓冲区地址、或者socket地址等
 * @str:  文件路径或者联机ip或者串口地址或者共享内存名称
 *
 */
#define _my_cmtr_openrb(str)    (open((str), O_RDONLY, S_IWRITE | S_IREAD))
#define _my_cmtr_openwb(str)    (open((str), O_CREAT | O_RDWR, S_IWRITE | S_IREAD))
#define _my_cmtr_openab(str)    (open((str), O_CREAT | O_APPEND | O_RDWR, S_IWRITE | S_IREAD))
#define _my_cmtr_close(pfd)     (close(pfd))


/*
 * cmtr_test_demo - 测试函数
 *
 */

void cmtr_test_demo()
{
        int counter1 = 0;
        int counter2 = 0;
        struct cmtr_dat_smpdot dot0;
        struct cmtr_cfg_info cfg0;
        _my_cmtr_ioptr fdcfg1 = 0;
        _my_cmtr_ioptr fddat1 = 0;
        _my_cmtr_ioptr fdcfg2 = 0;
        _my_cmtr_ioptr fddat2 = 0;
        int buf_size = 1024;
        u8 *read_buf = _my_buf_malloc(buf_size);
        int analog_count = 0;
        int digit_count = 0;
        u16 *the_smp_mins = 0;
        u16 *the_smp_maxs = 0;

        fdcfg1 = _my_cmtr_openrb("E:/iec-61850/test_r.cfg");
        fdcfg2 = _my_cmtr_openwb("E:/iec-61850/test_w.cfg");
        _my_assert(fdcfg1);
        _my_assert(fdcfg2);
        read_cmtr_cfg_info(fdcfg1, &cfg0, &counter1);
        print_cmtr_cfg_info(&cfg0);
        write_cmtr_cfg_info(fdcfg2, &cfg0, &counter2);
        _my_cmtr_close(fdcfg1);
        _my_cmtr_close(fdcfg2);


        fddat1 = _my_cmtr_openrb("E:/iec-61850/test_r.dat");
        fddat2 = _my_cmtr_openwb("E:/iec-61850/test_w.dat");
        while (_my_check_cmtr_ptr(fddat1)) {
                analog_count = cfg0.analog_count;
                digit_count = cfg0.digit_count;
                if (analog_count > 0) the_smp_mins = _my_buf_malloc(2*analog_count);
                if (analog_count > 0) the_smp_maxs = _my_buf_malloc(2*analog_count);
                fddat1 = read_cmtr_dat_smpdot_ascii(fddat1,
                                           read_buf, buf_size,
                                           analog_count, digit_count,
                                           &dot0,
                                           the_smp_mins, the_smp_maxs,
                                           &counter1);
                if (_my_check_cmtr_ptr(fddat1)) {
                        print_cmtr_dat_smpdot(analog_count, digit_count, &dot0);
                        fddat2 = write_cmtr_dat_smpdot_ascii(fddat2, analog_count, digit_count, &dot0, &counter2);
                }
        }
        _my_cmtr_close(fddat1);
        _my_cmtr_close(fddat2);
}


/*
 * main - 测试main函数
 *
 */
int main(int argc, char* argv[])
{
        cmtr_test_demo();
        getchar();
        return 0;
}


#endif /* CMTR_CONSOLE_DEMO */