FIX | 添加其他命令回复

app/include/pd_dau.h

@@ -108,7 +108,15 @@ enum DAU_SEND_TYPE
 {
     DAU_SEND_ADD = 1,
     DAU_SEND_RESET = 2,
-    DAU_SEND_PRPS = 3,
+    DAU_SEND_INFO_SET = 4,
+    DAU_SEND_INFO_GET = 5,
+    DAU_SEND_HEARTBEAT = 7,
+    DAU_SEND_CFG_SET = 8,
+    DAU_SEND_CFG_GET = 9,
+    DAU_SEND_PORT_SET = 10,
+    DAU_SEND_PORT_GET = 11,
+    DAU_SEND_PRPS_GET = 12,
+    DAU_SEND_PRPS = 14,
     DAU_SEND_MAX
 };
 
@@ -217,6 +225,7 @@ extern dau_t daus[PD_SLOTS_MAX];
 extern int32_t dau_handle_init(void);
 extern int32_t dau_handle_init_after(void);
 extern void dau_data_send(dau_t *dau, dau_head_init_t *head_data);
+extern int32_t dau_msg_send(uint32_t type, void *data);
 extern int32_t dau_msg_send_cmd(uint32_t type, void *data);
 #endif
 #endif

app/include/pd_hf.h

@@ -32,28 +32,26 @@ typedef struct
     uint8_t reserved[2];        // 保留 
 } hf_ack_t;
 
+/* 设备信息 */
 typedef struct
 {
-    uint8_t slot;                   // 槽位号
     uint8_t type_m;                 // 主设备号
     uint8_t type_s;                 // 次设备号
-    uint8_t reserved1[1];           // 保留
+    uint8_t reserved1[2];           // 保留
     uint32_t dev_id;                // 设备ID
     char hostname[FILE_NAME_LEN];   // 设备名 128byte
     uint32_t factory_date;          // 出厂日期.
     uint32_t deployment_date;       // 部署日期.
-    uint8_t app_version[32];        // 软件版本
-    uint8_t app_compile_time[32];   // 软件编译时间
-    uint8_t hardware_version[32];   // 硬件版本
-    uint8_t FPGA_version[32];       // fpga版本
+    uint8_t app_version[DEV_VERSION_STR_LEN];       // 软件版本
+    uint8_t app_compile_time[DEV_VERSION_STR_LEN];  // 软件编译时间
+    uint8_t hardware_version[DEV_VERSION_STR_LEN];  // 硬件版本
+    uint8_t FPGA_version[DEV_VERSION_STR_LEN];      // fpga版本
     uint32_t ip;                    // 本机 IP.
     uint32_t mask;                  // 本机 MASK.
     uint32_t gw;                    // 本机网关
     uint8_t mac[6];                 // MAC地址.
     uint16_t server_port;           // 服务器端口号.
     uint32_t server_ipv4;           // 服务器 IP.
-    uint8_t port[8];
-    uint8_t port_type[8];
 } hf_dev_info_t;
 
 /* 心跳报文. */
@@ -69,6 +67,57 @@ typedef struct
     uint8_t dau_port_num[4];                    // 采集板端口数量.
 } hf_heartbeat_t;
 
+/* 全局配置 */
+typedef struct
+{ 
+    uint16_t power_frequency;                   // 工频频率, 单位: 0.1Hz
+    uint16_t trend_period;                      // 趋势数据上送周期, 单位: 秒.
+    uint8_t sync_mode;                          // 同步方式 1: PT 同步 2: 内同步(默认) 3: 外接信号同步.
+    uint8_t heartbeat_period;                   // 心跳包周期, 单位: 分钟.
+    uint8_t pps_mode;                           // pps 主从模式 PD_PPS_XXX.
+    uint8_t protocol_type;                      // 0:朗德协议 1:南网协议
+    uint16_t trend_storage;                     // 趋势存储文件数量阈值
+    uint16_t event_storage;                     // 事件存储文件数量阈值
+} hf_cfg_t;
+
+/* 端口配置 */
+typedef struct
+{
+    uint8_t vport;                              // 通道编号.
+    uint8_t port_type;                          // 采集通道类型      , 1 表示特高频局放 2 表示超声局放 3 表示 TEV 4 表示高频.
+    uint8_t filter;                             // 滤波器类型 1: 低频段 2: 全频段 3: 窄频段 4: 高频段
+    uint8_t sensor_type;                        // 0: 无配置; 1: UHF信号传感器; 2: UHF噪声传感器  ; 3: UHF信号传感器, 关联噪声降噪.
+    uint8_t is_auto_noise;                      // 是否自动调整降噪等级.
+    uint8_t denoise_type;                       // 0-无配置 1-自动 2-手动降噪
+    uint16_t denoise_variance;                  // 方差降噪系数, 单位: 1%
+    
+    uint32_t event_counter_h;                   // 事件次数阀值高.
+    uint16_t event_sec_h;                       // 事件每秒次数阀值高.
+    uint16_t event_thr_h;                       // 事件值阈值高.
+    uint32_t event_counter_thr_h;               // 事件值阈值高的次数.
+    
+    uint32_t event_counter_l;                   // 事件次数阀值低.
+    uint16_t event_sec_l;                       // 事件每秒次数阀值低.
+    uint16_t event_thr_l;                       // 事件值阈值低.
+    uint32_t event_counter_thr_l;               // 事件值阈值低的次数.
+
+    uint8_t burst_time;                         // 事件突发计算时间
+    uint8_t reserved1[1];
+    uint16_t burst_thr;                         // 事件突发阈值
+    
+    int16_t denoise_manual;                     // 手动底噪等级
+    int16_t denoise_auto;                       // 自动降噪水平
+} hf_cfg_port_t;
+
+/* 端口配置回复 */
+typedef struct
+{
+    uint8_t vport;                              // 通道编号.
+    uint8_t result;                             // 应答结果. 0:失败 1:成功
+    uint8_t slot;                               // slot id
+    uint8_t reserved[1];                        // 保留 
+} hf_cfg_port_ack_t;
+
 /* 实时图谱关注 */
 typedef struct
 {
@@ -81,6 +130,30 @@ typedef struct
     uint16_t denoise_manual;                    // 手动降噪等级
 } hf_prps_get_t;
 
+/* 实时图谱报文头 */
+typedef struct
+{
+    uint16_t index;                             // 每10包传完之后自动自加，用于区分当前包结束.
+    uint8_t pkt_sum;                            // 总包数 10.
+    uint8_t pkt_index;                          // 当前包数 0 ~ 9.
+    uint16_t fre_cnt;                           // 工频周期计数.
+    uint8_t vport;                              // 通道编号.
+    uint8_t reserved1[1];
+    int16_t max;
+    int16_t avg;
+    uint32_t cnt;
+    uint32_t utc;
+    float freq;                                 // 频率.
+    uint32_t len;
+} hf_prps_head_t;
+
+/* 实时图谱结构体 */
+typedef struct
+{
+    hf_prps_head_t head;
+    int16_t prps[PD_PRPS_NUM_MAX];              // 1s prps 降噪数据.
+} hf_prps_t;
+
 /* 趋势头 */
 typedef struct
 {
@@ -199,6 +272,7 @@ typedef struct
 {
     hf_heartbeat_t run_status;
     hf_event_t event;
+    hf_prps_t *prps;
     hf_trend_t trend;
 } hf_data_t;
 

app/include/pd_main.h

@@ -54,7 +54,7 @@
 #define PD_PHASE_NUM 256
 #define PD_VAULE_NUM 256
 #define PD_PRPS_NUM 12800
-#define PD_PRPS_NUM_MAX 98304
+#define PD_PRPS_NUM_MAX 76800
 #define PD_EVENT_POINT_MAX 768000
 #define PD_TREND_PHASE_POINT_CNT 256
 #define PD_TREND_POINT_MAX 768000

app/lib/a_process/pd_dau.c

@@ -306,6 +306,35 @@ void dau_data_send(dau_t *dau, dau_head_init_t *head_data)
     }
 }
 
+/* 发送数据到后台通讯进程. */
+int32_t dau_msg_send(uint32_t type, void *data)
+{
+    uint32_t fifo = 0;
+    dau_send_msg_t msg;
+
+    if (DAU_SEND_PRPS == type)
+    {
+        fifo = csg.fifo_prps_id;
+    }
+    else
+    {
+        DBG(DBG_M_PD_DAU_ERR, "DAU write ERROR! type=%d\r\n", type);
+        return E_BAD_PARAM;
+    }
+    
+    /* 封装消息. */
+    msg.type = type;
+    msg.data = data;
+
+    /* 发送消息 */
+    if (fifo_write(fifo, (void*)(&msg), sizeof(dau_send_msg_t)) != sizeof(dau_send_msg_t))
+    {
+        return E_ERROR;
+    }
+    
+    return E_NONE;
+}
+
 /* 发送数据到后台通讯进程. */
 int32_t dau_msg_send_cmd(uint32_t type, void *data)
 {
@@ -318,11 +347,9 @@ int32_t dau_msg_send_cmd(uint32_t type, void *data)
     /* 发送消息 */
     if (fifo_write(csg.fifo_cmd_id, (void*)(&msg), sizeof(dau_send_msg_t)) != sizeof(dau_send_msg_t))
     {
-        DBG(DBG_M_PD_DAU_ERR, "DAU write ERROR! type=%d\r\n", type);
         return E_ERROR;
     }
     
     return E_NONE;
 }
-
 #endif

app/lib/a_process/pd_hf.c

@@ -57,69 +57,133 @@
 
 /* Private variables ---------------------------------------------------------*/
 
-
 /* Private function prototypes -----------------------------------------------*/
-extern void _hf_send_reset(uint8_t slot, void *data);
-extern void _hf_send_prps_get(uint8_t slot, void *data);
+/* 重启发送 */
+void _hf_send_reset(uint8_t slot, void *data)
+{
+    dau_head_init_t head_data;
+    dau_t *dau = &daus[slot];
 
-extern void _hf_recv_heartbeat(uint8_t slot, char *pkt, uint16_t len);
-extern void _hf_recv_prps_get(uint8_t slot, char *pkt, uint16_t len);
-extern void _hf_recv_trend(uint8_t slot, char *pkt, uint16_t len);
-extern void _hf_recv_event(uint8_t slot, char *pkt, uint16_t len);
+    /* 回复报文 */
+    head_data.cmd_type = DAU_REQUEST;
+    head_data.cmd = DAU_C_RESET;
+    head_data.pkt_id = dau->pkt_id++;
+    head_data.pkt = dau->buf_send;
+    head_data.len = sizeof(dau_pkt_head_t);
     
-// 命令映射表
-static dau_recv_fun_cb _hf_command[] = 
+    dau_data_send(dau, &head_data);
+
+    return;
+}
+
+/* 设备信息配置发送 */
+void _hf_send_info_set(uint8_t slot, void *data)
 {
-    NULL,                       // 0
-    NULL,                       // DAU_C_CONTACT            1
-    NULL,                       // DAU_C_ADD_DAU            2
-    NULL,                       // DAU_C_RESET              3
-    NULL,                       // 4
-    NULL,                       // DAU_C_UPDATE             5
-    NULL,                       // DAU_C_DEV_INFO_SET       6
-    NULL,                       // DAU_C_DEV_INFO_GET       7
-    NULL,                       // 8
-    NULL,                       // DAU_C_UPDATE_RESULT      9
-    _hf_recv_heartbeat,         // DAU_C_HEARTBEAT          10
-};
+    dau_head_init_t head_data;
+    dau_t *dau = &daus[slot];
+    hf_dev_info_t *param = (hf_dev_info_t*)(dau->buf_send + sizeof(dau_pkt_head_t));
 
-// 命令映射表
-static dau_recv_fun_cb _hf_prv_command[] = 
+    /* 回复报文 */
+    head_data.cmd_type = DAU_REQUEST;
+    head_data.cmd = DAU_C_DEV_INFO_SET;
+    head_data.pkt_id = dau->pkt_id++;
+    head_data.pkt = dau->buf_send;
+    head_data.len = sizeof(dau_pkt_head_t) + sizeof(hf_dev_info_t);
+
+    memcpy(param, data, sizeof(hf_dev_info_t));
+    
+    dau_data_send(dau, &head_data);
+
+    return;
+}
+
+/* 设备信息获取发送 */
+void _hf_send_info_get(uint8_t slot, void *data)
 {
-    NULL,                       // 0
-    NULL,                       // DAU_P_CONFIG_SET         1
-    NULL,                       // DAU_P_CONFIG_GET         2
-    NULL,                       // DAU_P_CONFIG_PORT_SET    3
-    NULL,                       // DAU_P_CONFIG_PORT_GET    4
-    _hf_recv_prps_get,          // DAU_P_CONFIG_REAL_WAVE   5
-    NULL,                       // 6
-    NULL,                       // 7
-    NULL,                       // 8
-    NULL,                       // 9
-    _hf_recv_trend,             // DAU_P_TREND              10
-    NULL,                       // DAU_P_REAL_PRPS          11
-    _hf_recv_event,             // DAU_P_EVENT              12
-};
+    dau_head_init_t head_data;
+    dau_t *dau = &daus[slot];
 
-// 命令映射表
-static dau_send_fun_cb _hf_send_command[] = 
+    /* 回复报文 */
+    head_data.cmd_type = DAU_REQUEST;
+    head_data.cmd = DAU_C_DEV_INFO_GET;
+    head_data.pkt_id = dau->pkt_id++;
+    head_data.pkt = dau->buf_send;
+    head_data.len = sizeof(dau_pkt_head_t);
+    
+    dau_data_send(dau, &head_data);
+
+    return;
+}
+
+/* 设备配置发送 */
+void _hf_send_cfg_set(uint8_t slot, void *data)
 {
-    NULL,                       // 0
-    NULL,                       // DAU_SEND_ADD             1
-    _hf_send_reset,             // DAU_SEND_RESET           2
-    _hf_send_prps_get,          // DAU_SEND_PRPS            3
-};
+    dau_head_init_t head_data;
+    dau_t *dau = &daus[slot];
+    hf_cfg_t *param = (hf_cfg_t*)(dau->buf_send + sizeof(dau_pkt_head_t));
 
-/* Interface functions -------------------------------------------------------*/
-/* PRPS 重启发送 */
-void _hf_send_reset(uint8_t slot, void *data)
+    /* 回复报文 */
+    head_data.cmd_type = DAU_PRV_REQUEST;
+    head_data.cmd = DAU_P_CONFIG_SET;
+    head_data.pkt_id = dau->pkt_id++;
+    head_data.pkt = dau->buf_send;
+    head_data.len = sizeof(dau_pkt_head_t) + sizeof(hf_cfg_t);
+
+    memcpy(param, data, sizeof(hf_cfg_t));
+    
+    dau_data_send(dau, &head_data);
+
+    return;
+}
+
+/* 设备配置获取发送 */
+void _hf_send_cfg_get(uint8_t slot, void *data)
 {
     dau_head_init_t head_data;
     dau_t *dau = &daus[slot];
 
     /* 回复报文 */
-    head_data.cmd_type = DAU_REQUEST;
-    head_data.cmd = DAU_C_RESET;
+    head_data.cmd_type = DAU_PRV_REQUEST;
+    head_data.cmd = DAU_P_CONFIG_GET;
+    head_data.pkt_id = dau->pkt_id++;
+    head_data.pkt = dau->buf_send;
+    head_data.len = sizeof(dau_pkt_head_t);
+    
+    dau_data_send(dau, &head_data);
+
+    return;
+}
+
+/* 设备端口配置发送 */
+void _hf_send_cfg_set_port(uint8_t slot, void *data)
+{
+    dau_head_init_t head_data;
+    dau_t *dau = &daus[slot];
+    hf_cfg_port_t *param = (hf_cfg_port_t*)(dau->buf_send + sizeof(dau_pkt_head_t));
+
+    /* 回复报文 */
+    head_data.cmd_type = DAU_PRV_REQUEST;
+    head_data.cmd = DAU_P_CONFIG_PORT_SET;
+    head_data.pkt_id = dau->pkt_id++;
+    head_data.pkt = dau->buf_send;
+    head_data.len = sizeof(dau_pkt_head_t) + sizeof(hf_cfg_port_t);
+
+    memcpy(param, data, sizeof(hf_cfg_port_t));
+    
+    dau_data_send(dau, &head_data);
+
+    return;
+}
+
+/* 设备端口配置获取发送 */
+void _hf_send_cfg_get_port(uint8_t slot, void *data)
+{
+    dau_head_init_t head_data;
+    dau_t *dau = &daus[slot];
+
+    /* 回复报文 */
+    head_data.cmd_type = DAU_PRV_REQUEST;
+    head_data.cmd = DAU_P_CONFIG_PORT_GET;
     head_data.pkt_id = dau->pkt_id++;
     head_data.pkt = dau->buf_send;
     head_data.len = sizeof(dau_pkt_head_t);
@@ -177,6 +241,59 @@ void _hf_recv_reset(uint8_t slot, char *pkt, uint16_t len)
     return;
 }
 
+/* 设备信息配置报文接收 */
+void _hf_recv_info_set(uint8_t slot, char *pkt, uint16_t len)
+{
+    hf_ack_t *ack = (hf_ack_t*)(pkt + sizeof(dau_pkt_head_t));
+    hf_ack_t *data = NULL;
+
+    /* 申请内存 */
+    data = XMALLOC(MTYPE_CSG, sizeof(hf_ack_t));
+    if (!data)
+    {
+        DBG(DBG_M_PD_HF_ERR, "XMALLOC ERROR!\r\n");
+        return;
+    }
+
+    /* 装填数据 */
+    data->result = ack->result;
+    data->slot = slot;
+
+    /* 发送给后台 */
+    if (dau_msg_send_cmd(DAU_SEND_INFO_SET, data) != E_NONE)
+    {
+        XFREE(MTYPE_CSG, data);
+    }
+
+    return;
+}
+
+/* 设备信息配置报文接收 */
+void _hf_recv_info_get(uint8_t slot, char *pkt, uint16_t len)
+{
+    hf_dev_info_t *param = (hf_dev_info_t*)(pkt + sizeof(dau_pkt_head_t));
+    hf_dev_info_t *data = NULL;
+
+    /* 申请内存 */
+    data = XMALLOC(MTYPE_CSG, sizeof(hf_dev_info_t));
+    if (!data)
+    {
+        DBG(DBG_M_PD_HF_ERR, "XMALLOC ERROR!\r\n");
+        return;
+    }
+
+    /* 装填数据 */
+    memcpy(data, param, sizeof(hf_dev_info_t));
+
+    /* 发送给后台 */
+    if (dau_msg_send_cmd(DAU_SEND_INFO_GET, data) != E_NONE)
+    {
+        XFREE(MTYPE_CSG, data);
+    }
+
+    return;
+}
+
 /* 心跳报文接收 */
 void _hf_recv_heartbeat(uint8_t slot, char *pkt, uint16_t len)
 {
@@ -186,6 +303,7 @@ void _hf_recv_heartbeat(uint8_t slot, char *pkt, uint16_t len)
     hf_heartbeat_t *data = (hf_heartbeat_t*)(pkt + sizeof(dau_pkt_head_t));
     hf_data_t *hf_data = (hf_data_t*)dau->private_data;
     uint32_t *timestamp = (uint32_t*)(pkt + sizeof(dau_pkt_head_t));
+    hf_heartbeat_t *param = NULL;
 
     memcpy(&hf_data->run_status, data, sizeof(hf_heartbeat_t));
 
@@ -198,10 +316,134 @@ void _hf_recv_heartbeat(uint8_t slot, char *pkt, uint16_t len)
     *timestamp = time(NULL);
     dau_data_send(dau, &head_data);
 
+    /* 申请内存 */
+    data = XMALLOC(MTYPE_CSG, sizeof(hf_heartbeat_t));
+    if (!data)
+    {
+        DBG(DBG_M_PD_HF_ERR, "XMALLOC ERROR!\r\n");
         return;
     }
 
-/* 心跳报文接收 */
+    /* 装填数据 */
+    memcpy(param, &hf_data->run_status, sizeof(hf_heartbeat_t));
+
+    /* 发送给后台 */
+    if (dau_msg_send_cmd(DAU_SEND_HEARTBEAT, data) != E_NONE)
+    {
+        XFREE(MTYPE_CSG, data);
+    }
+
+    return;
+}
+
+/* 设备配置报文接收 */
+void _hf_recv_cfg_set(uint8_t slot, char *pkt, uint16_t len)
+{
+    hf_ack_t *ack = (hf_ack_t*)(pkt + sizeof(dau_pkt_head_t));
+    hf_ack_t *data = NULL;
+
+    /* 申请内存 */
+    data = XMALLOC(MTYPE_CSG, sizeof(hf_ack_t));
+    if (!data)
+    {
+        DBG(DBG_M_PD_HF_ERR, "XMALLOC ERROR!\r\n");
+        return;
+    }
+
+    /* 装填数据 */
+    data->result = ack->result;
+    data->slot = slot;
+
+    /* 发送给后台 */
+    if (dau_msg_send_cmd(DAU_SEND_CFG_SET, data) != E_NONE)
+    {
+        XFREE(MTYPE_CSG, data);
+    }
+
+    return;
+}
+
+/* 设备配置报文接收 */
+void _hf_recv_cfg_get(uint8_t slot, char *pkt, uint16_t len)
+{
+    hf_cfg_t *param = (hf_cfg_t*)(pkt + sizeof(dau_pkt_head_t));
+    hf_cfg_t *data = NULL;
+
+    /* 申请内存 */
+    data = XMALLOC(MTYPE_CSG, sizeof(hf_cfg_t));
+    if (!data)
+    {
+        DBG(DBG_M_PD_HF_ERR, "XMALLOC ERROR!\r\n");
+        return;
+    }
+
+    /* 装填数据 */
+    memcpy(data, param, sizeof(hf_cfg_t));
+
+    /* 发送给后台 */
+    if (dau_msg_send_cmd(DAU_SEND_CFG_GET, data) != E_NONE)
+    {
+        XFREE(MTYPE_CSG, data);
+    }
+
+    return;
+}
+
+/* 设备端口配置报文接收 */
+void _hf_recv_cfg_set_port(uint8_t slot, char *pkt, uint16_t len)
+{
+    hf_cfg_port_ack_t *ack = (hf_cfg_port_ack_t*)(pkt + sizeof(dau_pkt_head_t));
+    hf_cfg_port_ack_t *data = NULL;
+
+    /* 申请内存 */
+    data = XMALLOC(MTYPE_CSG, sizeof(hf_cfg_port_ack_t));
+    if (!data)
+    {
+        DBG(DBG_M_PD_HF_ERR, "XMALLOC ERROR!\r\n");
+        return;
+    }
+
+    /* 装填数据 */
+    data->vport = ack->vport;
+    data->result = ack->result;
+    data->slot = slot;
+
+    /* 发送给后台 */
+    if (dau_msg_send_cmd(DAU_SEND_PORT_SET, data) != E_NONE)
+    {
+        XFREE(MTYPE_CSG, data);
+    }
+
+    return;
+}
+
+/* 设备端口配置报文接收 */
+void _hf_recv_cfg_get_port(uint8_t slot, char *pkt, uint16_t len)
+{
+    hf_cfg_port_t *param = (hf_cfg_port_t*)(pkt + sizeof(dau_pkt_head_t));
+    hf_cfg_port_t *data = NULL;
+
+    /* 申请内存 */
+    data = XMALLOC(MTYPE_CSG, sizeof(hf_cfg_port_t));
+    if (!data)
+    {
+        DBG(DBG_M_PD_HF_ERR, "XMALLOC ERROR!\r\n");
+        return;
+    }
+
+    /* 装填数据 */
+    memcpy(data, param, sizeof(hf_cfg_port_t));
+
+    /* 发送给后台 */
+    if (dau_msg_send_cmd(DAU_SEND_PORT_GET, data) != E_NONE)
+    {
+        XFREE(MTYPE_CSG, data);
+    }
+
+    return;
+}
+
+/* PRPS 关注报文接收 */
 void _hf_recv_prps_get(uint8_t slot, char *pkt, uint16_t len)
 {
     hf_ack_t *ack = (hf_ack_t*)(pkt + sizeof(dau_pkt_head_t));
@@ -220,7 +462,7 @@ void _hf_recv_prps_get(uint8_t slot, char *pkt, uint16_t len)
     data->slot = slot;
 
     /* 发送给后台 */
-    if (dau_msg_send_cmd(DAU_SEND_PRPS, data) != E_NONE)
+    if (dau_msg_send_cmd(DAU_SEND_PRPS_GET, data) != E_NONE)
     {
         XFREE(MTYPE_CSG, data);
     }
@@ -298,6 +540,47 @@ void _hf_recv_trend(uint8_t slot, char *pkt, uint16_t len)
     return;
 }
 
+/* PRPS 图谱接收 */
+void _hf_recv_prps(uint8_t slot, char *pkt, uint16_t len)
+{
+    dau_t *dau = &daus[slot];
+    hf_data_t *hf_data = (hf_data_t*)dau->private_data;
+    hf_prps_t *prps = hf_data->prps;
+    hf_prps_head_t *head_prps = (hf_prps_head_t*)(pkt + sizeof(dau_pkt_head_t));
+    char *data = (char*)(pkt + sizeof(dau_pkt_head_t) + sizeof(hf_prps_head_t));
+    char *point = NULL;
+        
+    /* 第一个报文 */
+    if (0 == head_prps->pkt_index)
+    {
+        memcpy(&prps->head, head_prps, sizeof(hf_prps_head_t));
+    }
+
+    point = (char*)prps->prps;
+    point += head_prps->pkt_index * HF_DATA_LEN;
+    memcpy(point, data, head_prps->len);
+
+    if ((head_prps->pkt_index + 1) == head_prps->pkt_sum)
+    {
+        /* 发送给后台, 内存由后台释放 */
+        if (dau_msg_send(DAU_SEND_PRPS, prps) != E_NONE)
+        {
+            return;
+        }
+
+        /* 重新申请内存 */
+        hf_data->prps = XMALLOC_Q(MTYPE_CSG, sizeof(hf_prps_t));
+        if (!hf_data->prps)
+        {
+            DBG(DBG_M_PD_HF_ERR, "XMALLOC ERROR!\r\n");
+            return;
+        }
+    }
+
+    return;
+}
+
+
 /* 事件报文接收 */
 void _hf_recv_event(uint8_t slot, char *pkt, uint16_t len)
 {
@@ -396,6 +679,62 @@ int32_t _hf_pkt_check(uint8_t slot, char *pkt)
     return E_NONE;
 }
 
+/* 命令映射表 */
+static dau_recv_fun_cb _hf_command[] = 
+{
+    NULL,                       // 0
+    NULL,                       // DAU_C_CONTACT            1
+    NULL,                       // DAU_C_ADD_DAU            2
+    _hf_recv_reset,             // DAU_C_RESET              3
+    NULL,                       // 4
+    NULL,                       // DAU_C_UPDATE             5
+    _hf_recv_info_set,          // DAU_C_DEV_INFO_SET       6
+    _hf_recv_info_get,          // DAU_C_DEV_INFO_GET       7
+    NULL,                       // 8
+    NULL,                       // DAU_C_UPDATE_RESULT      9
+    _hf_recv_heartbeat,         // DAU_C_HEARTBEAT          10
+};
+
+/* 命令映射表 */
+static dau_recv_fun_cb _hf_prv_command[] = 
+{
+    NULL,                       // 0
+    _hf_recv_cfg_set,           // DAU_P_CONFIG_SET         1
+    _hf_recv_cfg_get,           // DAU_P_CONFIG_GET         2
+    _hf_recv_cfg_set_port,      // DAU_P_CONFIG_PORT_SET    3
+    _hf_recv_cfg_get_port,      // DAU_P_CONFIG_PORT_GET    4
+    _hf_recv_prps_get,          // DAU_P_CONFIG_REAL_WAVE   5
+    NULL,                       // 6
+    NULL,                       // 7
+    NULL,                       // 8
+    NULL,                       // 9
+    _hf_recv_trend,             // DAU_P_TREND              10
+    _hf_recv_prps,              // DAU_P_REAL_PRPS          11
+    _hf_recv_event,             // DAU_P_EVENT              12
+};
+
+/* 命令映射表 */
+static dau_send_fun_cb _hf_send_command[] = 
+{
+    NULL,                       // 0
+    NULL,                       // DAU_SEND_ADD             1
+    _hf_send_reset,             // DAU_SEND_RESET           2
+    NULL,                       // 3
+    _hf_send_info_set,          // DAU_SEND_INFO_SET        4
+    _hf_send_info_get,          // DAU_SEND_INFO_GET        5
+    NULL,                       // 6
+    NULL,                       // DAU_SEND_HEARTBEAT       7
+    _hf_send_cfg_set,           // DAU_SEND_CFG_SET         8
+    _hf_send_cfg_get,           // DAU_SEND_CFG_GET         9
+    _hf_send_cfg_set_port,      // DAU_SEND_PORT_SET        10
+    _hf_send_cfg_get_port,      // DAU_SEND_PORT_GET        11
+    _hf_send_prps_get,          // DAU_SEND_PRPS_GET        12
+    NULL,                       // 13
+    NULL,                       // DAU_SEND_PRPS            14
+    NULL,                       // 15
+};
+
+/* Interface functions -------------------------------------------------------*/
 /* 高频收包处理函数 */
 int32_t hf_recv_process(uint8_t slot, char *pkt, uint16_t len)
 {
@@ -436,7 +775,23 @@ int32_t hf_send_process(uint8_t slot, uint8_t type, void *data)
 /* 高频私有数据 */
 void* hf_data_malloc(void)
 {
-    return XMALLOC_Q(MTYPE_HF, sizeof(hf_data_t));
+    hf_data_t *p = XMALLOC_Q(MTYPE_HF, sizeof(hf_data_t));
+
+    if (!p)
+    {
+        DBG(DBG_M_PD_HF_ERR, "XMALLOC ERROR!\r\n");
+        return NULL;
+    }
+
+    p->prps = XMALLOC_Q(MTYPE_CSG, sizeof(hf_prps_t));
+    if (!p->prps)
+    {
+        DBG(DBG_M_PD_HF_ERR, "XMALLOC ERROR!\r\n");
+        XFREE(MTYPE_HF, p);
+        return NULL;
+    }
+
+    return p;
 }
 
 #endif