From 18367bfd7ee3ad8214fa9aca1d367257822bb7aa Mon Sep 17 00:00:00 2001 From: yuliang Date: Tue, 1 Jul 2025 13:14:47 +0800 Subject: [PATCH] =?UTF-8?q?FIX=20|=20=E6=B7=BB=E5=8A=A0=E5=85=B6=E4=BB=96?= =?UTF-8?q?=E5=91=BD=E4=BB=A4=E5=9B=9E=E5=A4=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app/include/pd_dau.h | 11 +- app/include/pd_hf.h | 92 +++++++- app/include/pd_main.h | 2 +- app/lib/a_process/pd_dau.c | 31 ++- app/lib/a_process/pd_hf.c | 459 ++++++++++++++++++++++++++++++++----- 5 files changed, 530 insertions(+), 65 deletions(-) diff --git a/app/include/pd_dau.h b/app/include/pd_dau.h index a846b75..4835d84 100755 --- a/app/include/pd_dau.h +++ b/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 diff --git a/app/include/pd_hf.h b/app/include/pd_hf.h index 029c4b4..4f1365f 100755 --- a/app/include/pd_hf.h +++ b/app/include/pd_hf.h @@ -32,28 +32,26 @@ typedef struct uint8_t reserved[2]; // 保留 } hf_ack_t; -typedef struct +/* 设备信息 */ +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; diff --git a/app/include/pd_main.h b/app/include/pd_main.h index d270b43..f6a717c 100755 --- a/app/include/pd_main.h +++ b/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 diff --git a/app/lib/a_process/pd_dau.c b/app/lib/a_process/pd_dau.c index 00e4c26..75d6d0f 100755 --- a/app/lib/a_process/pd_dau.c +++ b/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 diff --git a/app/lib/a_process/pd_hf.c b/app/lib/a_process/pd_hf.c index 5ea51d3..3f50ba0 100755 --- a/app/lib/a_process/pd_hf.c +++ b/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]; + + /* 回复报文 */ + 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); + + dau_data_send(dau, &head_data); -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); + return; +} -// 命令映射表 -static dau_recv_fun_cb _hf_command[] = +/* 设备信息配置发送 */ +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