diff --git a/app/include/pd_csg.h b/app/include/pd_csg.h index 20a4a41..76d37cb 100755 --- a/app/include/pd_csg.h +++ b/app/include/pd_csg.h @@ -51,17 +51,21 @@ #define CSG_FIFO_TREND "CSG_FIFO_TREND" #define CSG_CMD_FIFO_NUM (16) #define CSG_PRPS_FIFO_NUM (8) -#define CSG_EVENT_FIFO_NUM (4) -#define CSG_TREND_FIFO_NUM (2) +#define CSG_EVENT_FIFO_NUM (32) +#define CSG_TREND_FIFO_NUM (4) #define CSG_HEAD_LEN (32) #define CSG_TOTLE_LEN (26) #define CSG_PKT_LEN (1300) +#define CSG_BUF_LEN (1500) #define MAX_FILES (128) #define MAX_PATH_LEN (256) #define THRESHOLD_MS 10 // 时间差阈值 #define UDP_SEND_TIMEOUT (2) #define CSG_SEND_ERR_CNT (3) + +#define DAU_INSERT 1 +#define DAU_UNPLUG 0 /* 配置文件结构体 */ #define FILE_FIFO_PATH_LEN 256 @@ -80,6 +84,7 @@ enum CSG_CMD CSG_C_CONTACT = 1, CSG_C_ADD_DAU = 2, CSG_C_RESET = 3, + CSG_C_DEL_DAU = 4, CSG_C_UPDATE = 5, CSG_C_DEV_INFO_SET = 6, /* 设备基本信息设置 */ CSG_C_DEV_INFO_GET = 7, /* 设备基本信息获取 */ @@ -101,6 +106,10 @@ enum DEBUG_CM_CMD CSG_PRV_EVENT = 12 }; +typedef int32_t (*csg_send_cb)(uint8_t, uint8_t, void*); +typedef void (*csg_send_fun_cb)(uint8_t, void*); + + // 定义命令字常量 typedef enum { //CMD_CONTACT = 0x00, @@ -139,10 +148,13 @@ typedef struct int32_t fifo_prps_id; // 实时图谱 fifo int32_t fifo_event_id; // 事件 fifo int32_t fifo_trend_id; // 趋势 fifo - char buf_send[1500]; - char buf_recv[1500]; - char event_booster_buf[1500]; - char trend_booster_buf[1500]; + char buf_send[CSG_BUF_LEN]; + char buf_recv[CSG_BUF_LEN]; + char real_buf[CSG_BUF_LEN]; + char event_buf[CSG_BUF_LEN]; + char trend_buf[CSG_BUF_LEN]; + char event_booster_buf[CSG_BUF_LEN]; + char trend_booster_buf[CSG_BUF_LEN]; struct sockaddr_in server; int32_t server_ip; // server ip. uint16_t server_port; // server port. @@ -152,6 +164,7 @@ typedef struct time_t heartbeat_timeout_cnt; pthread_mutex_t mutex; pthread_mutex_t lock; + csg_send_cb send_cb; } csg_t; /* 报文头结构. */ @@ -188,6 +201,12 @@ typedef struct uint8_t dau_port_num[4]; // 采集板端口数量. } csg_heartbeat_t; +typedef struct +{ + uint32_t sec; + uint32_t msec; +} csg_timestamp_t; + typedef struct{ uint8_t type_m; // 主设备号 uint8_t type_s; // 次设备号 @@ -245,6 +264,12 @@ typedef struct { int16_t denoise_manual; // 手动底噪等级 int16_t denoise_auto; // 自动降噪水平 }csg_config_port_t; + +typedef struct { + uint8_t vport; // 通道编号. + uint8_t result; // 应答结果. 0:成功 1:失败 + uint8_t reserved[2]; // 保留 +}csg_config_port_ack_t; typedef struct { @@ -359,30 +384,6 @@ typedef struct uint8_t port_type[8]; } csg_contact_t; -typedef struct -{ - uint8_t type_m; // 主设备号 - uint8_t type_s; // 次设备号 - uint8_t slot; // 槽位号 - uint8_t status; // 1:插入 0:拔出 - uint32_t dev_id; // 设备ID - char hostname[FILE_NAME_LEN]; // 设备名 128byte - uint32_t factory_date; // 出厂日期. - uint32_t deployment_date; // 部署日期. - 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[MAC_ADDR_LEN]; // MAC地址. - uint16_t server_port; // 服务器端口号. - uint32_t server_ipv4; // 服务器 IP. - uint8_t port[PD_PORT_SUM]; - uint8_t port_type[PD_PORT_SUM]; -} csg_add_dau_t; - typedef struct { uint32_t dev_id; @@ -404,7 +405,7 @@ extern int32_t csg_handle_init_after(void); extern void csg_upgrade_result_send(int32_t rv, char *buf); extern void _print_sockaddr_in(const struct sockaddr_in *addr); extern command_handler _csg_get_table_handle(command_entry *ptable, command_type cmd); -extern void _csg_send_data(uint8_t cmd_type, uint8_t cmd, char *pkt, int32_t len); +extern void _csg_send_data(uint8_t cmd_type, uint8_t cmd, char *pkt, int32_t len, uint8_t); #endif #endif /************************ (C) COPYRIGHT LandPower ***** END OF FILE ****************/ diff --git a/app/lib/a_process/pd_csg.c b/app/lib/a_process/pd_csg.c index d1b8d85..c350bd5 100755 --- a/app/lib/a_process/pd_csg.c +++ b/app/lib/a_process/pd_csg.c @@ -65,6 +65,7 @@ #include "pd_csg.h" #include "pd_upgrade.h" #include "pd_dau.h" +#include "pd_hf.h" /* Private define ------------------------------------------------------------*/ @@ -76,8 +77,78 @@ csg_t csg; /* Private function prototypes -----------------------------------------------*/ -extern void _csg_server_set(int32_t ip, uint16_t port); +void _csg_server_set(int32_t ip, uint16_t port); void _csg_show(); +void _csg_send_add_dau(uint8_t slot, void *data); +void _csg_send_reset(uint8_t, void *data); +void _csg_send_info_set(uint8_t, void *data); +void _csg_send_info_get(uint8_t, void *data); +void _csg_send_heartbeat(uint8_t slot, void *data); +void _csg_send_cfg_set(uint8_t, void *data); +void _csg_send_cfg_get(uint8_t, void *data); +void _csg_send_cfg_set_port(uint8_t, void *data); +void _csg_send_cfg_get_port(uint8_t, void *data); +void _csg_send_prps_get(uint8_t, void *data); +void _csg_send_trend_data(uint8_t, void *data); +void _csg_send_prps_data(uint8_t, void *data); +void _csg_send_event_data(uint8_t, void *data); + +#if 1 +// 命令映射表 +static csg_send_fun_cb _csg_send_command[] = +{ + NULL, // 0 + _csg_send_add_dau, // DAU_SEND_ADD 1 + _csg_send_reset, // DAU_SEND_RESET 2 + NULL, // 3 + _csg_send_info_set, // DAU_SEND_INFO_SET 4 + _csg_send_info_get, // DAU_SEND_INFO_GET 5 + NULL, // 6 + _csg_send_heartbeat, // DAU_SEND_HEARTBEAT 7 + _csg_send_cfg_set, // DAU_SEND_CFG_SET 8 + _csg_send_cfg_get, // DAU_SEND_CFG_GET 9 + _csg_send_cfg_set_port, // DAU_SEND_PORT_SET 10 + _csg_send_cfg_get_port, // DAU_SEND_PORT_GET 11 + _csg_send_prps_get, // DAU_SEND_PRPS_GET 12 + NULL, // 13 + _csg_send_prps_data, // DAU_SEND_PRPS 14 + NULL, // 15 +}; +#else + +// 命令映射表 +static csg_send_fun_cb _csg_send_command[] = +{ + NULL, // 0 + NULL, // DAU_C_CONTACT 1 + NULL, // DAU_C_ADD_DAU 2 + _csg_send_reset, // DAU_C_RESET 3 + NULL, // 4 + NULL, // DAU_C_UPDATE 5 + _csg_send_info_set, // DAU_C_DEV_INFO_SET 6 + _csg_send_info_get, // DAU_C_DEV_INFO_GET 7 + NULL, // 8 + NULL, // DAU_C_UPDATE_RESULT 9 + //_hf_recv_heartbeat, // DAU_C_HEARTBEAT 10 +}; + +static csg_send_fun_cb _csg_send_prv_command[] = +{ + NULL, // 0 + _csg_send_cfg_set, // DAU_P_CONFIG_SET 1 + _csg_send_cfg_get, // DAU_P_CONFIG_GET 2 + _csg_send_cfg_set_port, // DAU_P_CONFIG_PORT_SET 3 + _csg_send_cfg_get_port, // DAU_P_CONFIG_PORT_GET 4 + _csg_send_prps_get, // DAU_P_CONFIG_REAL_WAVE 5 + NULL, // 6 + NULL, // 7 + NULL, // 8 + NULL, // 9 + _csg_send_trend, // DAU_P_TREND 10 + _csg_send_prps, // DAU_P_REAL_PRPS 11 + _csg_send_event, // DAU_P_EVENT 12 +}; +#endif /* Internal functions --------------------------------------------------------*/ /* 服务器地址设置 */ @@ -121,6 +192,11 @@ void _print_sockaddr_in(const struct sockaddr_in *addr) void _csg_show() { printh("CSG connect: %s \n", (csg.is_connect == 1)? "OK" : "FAIL"); + for (int i = 0; i < PD_SLOTS_MAX; i++) + { + printh("dau[%d]:is_connect=%d is_insert=%d\n", i, daus[i].state.is_connect, + daus[i].state.is_insert); + } } void _csg_server_set(int32_t ip, uint16_t port) @@ -140,7 +216,7 @@ void _csg_server_set(int32_t ip, uint16_t port) } /* 封装数据并写fifo */ -int32_t _csg_msg_send(uint32_t type, void *data) +int32_t _csg_msg_send_dau(int slot, uint32_t type, void *data) { pd_csg_msg_t msg; @@ -149,14 +225,14 @@ int32_t _csg_msg_send(uint32_t type, void *data) msg.data = data; /* 发送消息 */ - if (fifo_write(csg.fifo_cmd_id, (void*)(&msg), sizeof(pd_csg_msg_t)) != sizeof(pd_csg_msg_t)) + if (fifo_write(daus[slot].fifo_send, (void*)(&msg), sizeof(pd_csg_msg_t)) != sizeof(pd_csg_msg_t)) { DBG(DBG_M_FIFO, "SSG write ERROR! type=%d\r\n", msg.type); return E_ERROR; } return E_NONE; -} +} /* 校验收到包的包头, 长度, 校验码. */ @@ -181,7 +257,7 @@ int32_t _csg_pkt_check(char *pkt) } /* 包头填充. */ -void _csg_head_init(char *buf, uint16_t len, uint8_t cmdType, uint8_t cmd) +void _csg_head_init(char *buf, uint16_t len, uint8_t cmdType, uint8_t cmd, uint8_t slot) { csg_pkt_head_t *head = (csg_pkt_head_t*)buf; @@ -194,16 +270,17 @@ void _csg_head_init(char *buf, uint16_t len, uint8_t cmdType, uint8_t cmd) head->cmd = cmd; head->version = 1; head->pkt_id = csg.pkt_index++; + head->slot = slot; } /* 数据发送 */ -void _csg_send_data(uint8_t cmd_type, uint8_t cmd, char *pkt, int32_t len) +void _csg_send_data(uint8_t cmd_type, uint8_t cmd, char *pkt, int32_t len, uint8_t slot) { int32_t rv = 0; csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; /* 封装报文头. */ - _csg_head_init(pkt, sizeof(csg_pkt_head_t) + len, cmd_type, cmd); + _csg_head_init(pkt, sizeof(csg_pkt_head_t) + len, cmd_type, cmd, slot); rv = sendto(csg.skfd, pkt, head->len, 0, (struct sockaddr*)&csg.server, sizeof(csg.server)); if (rv < 0) @@ -247,7 +324,7 @@ int32_t _csg_connect_send(void) memset(pinfo->port, 0, sizeof(pinfo->port)); memset(pinfo->port_type, 0, sizeof(pinfo->port_type)); - _csg_send_data(CSG_REPLY, CSG_C_CONTACT, pkt, sizeof(csg_contact_t)); + _csg_send_data(CSG_REPLY, CSG_C_CONTACT, pkt, sizeof(csg_contact_t), 0); return E_NONE; } @@ -298,7 +375,7 @@ int32_t _csg_heartbeat_send(void) pinfo->port_link_alarm[i] = 0; } - _csg_send_data(CSG_REPLY, CSG_C_HEARTBEAT, pkt, sizeof(csg_heartbeat_t)); + _csg_send_data(CSG_REPLY, CSG_C_HEARTBEAT, pkt, sizeof(csg_heartbeat_t), 0); return E_NONE; } @@ -312,52 +389,16 @@ void _csg_connect_recv(void) void _csg_add_dau_recv(char *pkt) { csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; - int slot = head->slot; - if (slot < 0 || slot >= PD_SLOTS_MAX) + uint8_t slot = head->slot; + if (slot >= PD_SLOTS_MAX || slot == 0) { DBG(DBG_M_PD_CSG_ERR, "Add DAU %d error!\r\n", slot); return; } + slot--; printf("_csg_add_dau_recv slot = %d\n", slot); - head->dev_id = head->sdev_id; - head->cmd_type = CSG_REQUEST; - head->cmd = CSG_C_CONTACT; - head->len = CSG_HEAD_LEN + 4; - uint32_t *timestamp = (uint32_t *)(pkt + CSG_HEAD_LEN); - *timestamp = time(NULL); - daus[slot].state.is_insert = TRUE; - //_dau_response(slot, pkt, head->len); -} - -void _csg_add_dau_send(int slot, int status) -{ - char *pkt = csg.buf_send; - csg_add_dau_t *pinfo = (csg_add_dau_t *)(pkt + sizeof(csg_pkt_head_t)); - dau_contact_t *pdau = &daus[slot].info; - pinfo->type_m = pdau->type_m; - pinfo->type_s = pdau->type_s; - pinfo->slot = slot; - pinfo->status = status; - pinfo->dev_id = pdau->dev_id; - strncpy(pinfo->hostname, pdau->hostname, sizeof(pinfo->hostname)-1); - pinfo->factory_date = pdau->factory_date; - pinfo->deployment_date = pdau->deployment_date; - strncpy((char *)pinfo->app_version, (char *)pdau->app_version, sizeof(pinfo->app_version)-1); - strncpy((char *)pinfo->app_compile_time, (char *)pdau->app_compile_time, sizeof(pinfo->app_compile_time)-1); - strncpy((char *)pinfo->hardware_version, (char *)pdau->hardware_version, sizeof(pinfo->hardware_version)-1); - strncpy((char *)pinfo->FPGA_version, (char *)pdau->FPGA_version, sizeof(pinfo->FPGA_version)-1); - pinfo->ip = pdau->ip; - pinfo->mask = pdau->mask; - pinfo->gw = pdau->gw; - memcpy(pinfo->mac, pdau->mac, sizeof(pinfo->mac)); - pinfo->server_port = pdau->server_port; - pinfo->server_ipv4 = pdau->server_ipv4; - memcpy(pinfo->port, pdau->port, sizeof(pinfo->port)); - memcpy(pinfo->port_type, pdau->port_type, sizeof(pinfo->port_type)); - - _csg_send_data(CSG_REPLY, CSG_C_ADD_DAU, pkt, sizeof(csg_add_dau_t)); } /* 解析心跳报文. */ @@ -380,7 +421,7 @@ void _csg_reboot_recv(char *pkt) ack.result = TRUE; memcpy(pkt + sizeof(csg_pkt_head_t), (char *)&ack, sizeof(csg_ack_t)); - _csg_send_data(CSG_REPLY, head->cmd, pkt, sizeof(csg_ack_t)); + _csg_send_data(CSG_REPLY, head->cmd, pkt, sizeof(csg_ack_t), 0); sleep(3); reboot_system(LOG_CSG, REBOOT_REMOTE_RESET); @@ -390,242 +431,193 @@ void _csg_reboot_recv(char *pkt) 说明：修改本地ip 设备ID 服务器地址时需要重启。 */ int32_t _csg_dev_info_set_recv(char *pkt) -{ - int change_ip = 0; - REBOOT_MSG boottype = REBOOT_NONE; - csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; - csg_dev_info_t *pinfo = (csg_dev_info_t *)(pkt + CSG_HEAD_LEN); - device_info.dev_id = pinfo->dev_id; - device_info.mask = pinfo->mask; - device_info.gw = pinfo->gw; - - if (strncmp((char *)(pinfo->hostname), device_info.hostname, sizeof(device_info.hostname))) - { - snprintf((char*)device_info.hostname, FILE_NAME_LEN, "%s", pinfo->hostname); - boottype = REBOOT_REMOTE_HOST_NAME_CHANGE; - } - - if (device_info.ip != pinfo->ip) - { - device_info.ip = pinfo->ip; - change_ip++; - boottype = REBOOT_REMOTE_IP_CHANGE; - } - - if (csg.server_ip != pinfo->server_ipv4) - { - csg.server_ip = pinfo->server_ipv4; - boottype = REBOOT_REMOTE_SERVER_IP_CHANGE; - } - - if (csg.server_port != pinfo->server_port) - { - csg.server_port = pinfo->server_port; - boottype = REBOOT_REMOTE_SERVER_IP_CHANGE; - } - - csg_ack_t ack = {0}; - ack.result = TRUE; - memcpy(pkt + sizeof(csg_pkt_head_t), (char *)&ack, sizeof(csg_ack_t)); - _csg_send_data(CSG_REPLY, head->cmd, pkt, sizeof(csg_ack_t)); - - vtysh_config_save(); - if (change_ip) - { - uint8_t mac[MAC_ADDR_LEN] = {0}; - mac_generate_from_ip(device_info.ip, mac); - memcpy(device_info.mac, mac, MAC_ADDR_LEN); - vtysh_eth0_save(); - } - vtysh_device_save(); - - if (boottype) +{ + csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; + csg_dev_info_t *param = (csg_dev_info_t*)(pkt + sizeof(csg_pkt_head_t)); + csg_dev_info_t *data = NULL; + uint8_t slot = head->slot - 1; + if (slot > PD_SLOTS_MAX) + { + DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot); + return E_BAD_PARAM; + } + + data = XMALLOC(MTYPE_CSG, sizeof(csg_dev_info_t)); + if (!data) { - reboot_system(LOG_CSG, boottype); - } - - return 0; -} + DBG(DBG_M_PD_CSG_ERR, "XMALLOC ERROR!\r\n"); + return E_MEM; + } + + memcpy(data, param, sizeof(csg_dev_info_t)); + if (_csg_msg_send_dau(slot, DAU_SEND_INFO_SET, data) != E_NONE) + { + XFREE(MTYPE_CSG, data); + } + return E_NONE; +} /* 厂家参数查询报文处理. */ int32_t _csg_dev_info_get_recv(char *pkt) -{ - csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; - csg_dev_info_t *pinfo = (csg_dev_info_t *)(pkt + sizeof(csg_pkt_head_t)); - pinfo->type_m = device_info.type_m; - pinfo->type_s = device_info.type_s; - pinfo->dev_id = device_info.dev_id; - strcpy(pinfo->hostname, device_info.hostname); - pinfo->factory_date = device_info.factory_date; - pinfo->deployment_date = device_info.deployment_date; - snprintf((char*)pinfo->app_version, DEV_VERSION_STR_LEN, "%s", device_info.app_version); - snprintf((char*)pinfo->app_compile_time, DEV_VERSION_STR_LEN, "%s", device_info.app_compile_time); - snprintf((char*)pinfo->hardware_version, DEV_VERSION_STR_LEN, "%s", device_info.hardware_version); - snprintf((char*)pinfo->FPGA_version, DEV_VERSION_STR_LEN, "%s", device_info.FPGA_version); - pinfo->ip = device_info.ip; - pinfo->mask = device_info.mask; - pinfo->gw = device_info.gw; - memcpy(pinfo->mac, device_info.mac, sizeof(pinfo->mac)); - //info.server_port = device_info.server_port; - //info.server_ipv4 = device_info.server_ipv4; - pinfo->server_port = csg.server_port; - pinfo->server_ipv4 = csg.server_ip; - - _csg_send_data(CSG_REPLY, head->cmd, pkt, sizeof(csg_dev_info_t)); - - return E_NONE; -} +{ + csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; + int *data = NULL; + uint8_t slot = head->slot - 1; + if (slot > PD_SLOTS_MAX) + { + DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot); + return E_BAD_PARAM; + } + + data = XMALLOC(MTYPE_CSG, sizeof(int)); + if (!data) + { + DBG(DBG_M_PD_CSG_ERR, "XMALLOC ERROR!\r\n"); + return E_MEM; + } + + if (_csg_msg_send_dau(slot, DAU_SEND_INFO_GET, data) != E_NONE) + { + XFREE(MTYPE_CSG, data); + } + return E_NONE; +} /* 配置用户参数报文报文处理. */ int32_t _csg_config_set_recv(char *pkt) -{ - csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; - csg_config_global_t *pnet = (csg_config_global_t *)(pkt + CSG_HEAD_LEN); - - pd_config.config.power_frequency = pnet->power_frequency; - pd_config.config.trend_period = pnet->trend_period * 60; - pd_config.config.sync_mode = pnet->sync_mode; - pd_config.config.heartbeat_period = pnet->heartbeat_period; - pd_config.config.pps_mode = pnet->pps_mode; - pd_config.config.protocol_type = pnet->protocol_type; - pd_config.config.event_storage = pnet->event_storage; - pd_config.config.trend_storage = pnet->trend_storage; - - vtysh_config_save(); - - csg_ack_t ack = {0}; - ack.result = TRUE; - memcpy(pkt + sizeof(csg_pkt_head_t), (char *)&ack, sizeof(csg_ack_t)); - - _csg_send_data(CSG_PRV_REPLY, head->cmd, pkt, sizeof(csg_ack_t)); - return E_NONE; -} +{ + csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; + csg_config_global_t *param = (csg_config_global_t*)(pkt + sizeof(csg_pkt_head_t)); + csg_config_global_t *data = NULL; + uint8_t slot = head->slot - 1; + if (slot > PD_SLOTS_MAX) + { + DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot); + return E_BAD_PARAM; + } + + data = XMALLOC(MTYPE_CSG, sizeof(csg_config_global_t)); + if (!data) + { + DBG(DBG_M_PD_CSG_ERR, "XMALLOC ERROR!\r\n"); + return E_MEM; + } + + memcpy(data, param, sizeof(csg_config_global_t)); + if (_csg_msg_send_dau(slot, DAU_SEND_CFG_SET, data) != E_NONE) + { + XFREE(MTYPE_CSG, data); + } + return E_NONE; +} /* 查询用户参数查询报文处理. */ int32_t _csg_config_get_recv(char *pkt) -{ - csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; - csg_config_global_t config = {0}; - config.power_frequency = pd_config.config.power_frequency; - config.sync_mode = pd_config.config.sync_mode; - config.heartbeat_period = pd_config.config.heartbeat_period; - config.pps_mode = pd_config.config.pps_mode; - config.protocol_type = pd_config.config.protocol_type; - config.trend_period = pd_config.config.trend_period / 60; - config.trend_storage = pd_config.config.trend_storage; - config.event_storage = pd_config.config.event_storage; - memcpy(pkt + sizeof(csg_pkt_head_t), (char *)&config, sizeof(csg_config_global_t)); - _csg_send_data(CSG_PRV_REPLY, head->cmd, pkt, sizeof(csg_config_global_t)); - - return E_NONE; -} +{ + csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; + int *data = NULL; + uint8_t slot = head->slot - 1; + if (slot > PD_SLOTS_MAX) + { + DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot); + return E_BAD_PARAM; + } + + data = XMALLOC(MTYPE_CSG, sizeof(int)); + if (!data) + { + DBG(DBG_M_PD_CSG_ERR, "XMALLOC ERROR!\r\n"); + return E_MEM; + } + + if (_csg_msg_send_dau(slot, DAU_SEND_CFG_GET, data) != E_NONE) + { + XFREE(MTYPE_CSG, data); + } + return E_NONE; +} /* 通道提交端口参数设置. */ int32_t _csg_port_config_set_recv(char *pkt) -{ - //uint8_t vport = *(uint8_t*)(pkt + CSG_HEAD_LEN); - uint8_t unit = 0; - uint8_t port = 0; - //csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; - csg_config_port_t *pnet = (csg_config_port_t *)(pkt + CSG_HEAD_LEN); - - pd_config.config_port[unit][port].vport = pnet->vport; - pd_config.config_port[unit][port].port_type = pnet->port_type; - pd_config.config_port[unit][port].filter = pnet->filter; - pd_config.config_port[unit][port].sensor_type = pnet->sensor_type; - pd_config.config_port[unit][port].is_auto_noise = pnet->is_auto_noise; - pd_config.config_port[unit][port].denoise_type = pnet->denoise_type; - pd_config.config_port[unit][port].denoise_variance = pnet->denoise_variance; - - pd_config.config_port[unit][port].event_counter_h = pnet->event_counter_h; - pd_config.config_port[unit][port].event_sec_h = pnet->event_sec_h; - pd_config.config_port[unit][port].event_thr_h = pnet->event_thr_h; - pd_config.config_port[unit][port].event_counter_thr_h = pnet->event_counter_thr_h; - - pd_config.config_port[unit][port].event_counter_l = pnet->event_counter_l; - pd_config.config_port[unit][port].event_sec_l = pnet->event_sec_l; - pd_config.config_port[unit][port].event_thr_l = pnet->event_thr_l; - pd_config.config_port[unit][port].event_counter_thr_l = pnet->event_counter_thr_l; - - pd_config.config_port[unit][port].burst_time = pnet->burst_time; - pd_config.config_port[unit][port].burst_thr = pnet->burst_thr; - pd_config.config_port[unit][port].denoise_manual = pnet->denoise_manual; - pd_config.config_port[unit][port].denoise_auto = pnet->denoise_auto; - - pd_config.config_real[unit][port].filter_cfg = pd_config.config_port[unit][port].filter; - //dau_port_filter_set(unit, port); - - vtysh_config_save(); - - //csg_config_port_ack_t ack = {0}; - //ack.vport = pnet->vport; - //ack.result = TRUE; - //memcpy(pkt + sizeof(csg_pkt_head_t), (char *)&ack, sizeof(csg_config_port_ack_t)); - //_csg_send_data(CSG_PRV_REPLY, head->cmd, pkt, sizeof(csg_config_port_ack_t)); - return E_NONE; -} +{ + csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; + csg_config_port_t *param = (csg_config_port_t*)(pkt + sizeof(csg_pkt_head_t)); + csg_config_port_t *data = NULL; + uint8_t slot = head->slot - 1; + if (slot > PD_SLOTS_MAX) + { + DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot); + return E_BAD_PARAM; + } + + data = XMALLOC(MTYPE_CSG, sizeof(csg_config_port_t)); + if (!data) + { + DBG(DBG_M_PD_CSG_ERR, "XMALLOC ERROR!\r\n"); + return E_MEM; + } + + memcpy(data, param, sizeof(csg_config_port_t)); + if (_csg_msg_send_dau(slot, DAU_SEND_PORT_SET, data) != E_NONE) + { + XFREE(MTYPE_CSG, data); + } + return E_NONE; +} /* 按通道提交端口参数查询结果. */ int32_t _csg_port_config_get_recv(char *pkt) -{ - uint8_t vport = *(uint8_t*)(pkt + CSG_HEAD_LEN); - uint8_t unit = 0; - uint8_t port = 0; - csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; - //csg_config_port_t *pnet = (csg_config_port_t *)(pkt + CSG_HEAD_LEN); - - //if (dau_vport_to_port(pnet->vport, &unit, &port) != E_NONE) +{ + csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; + uint8_t *param = (uint8_t *)(pkt + sizeof(csg_pkt_head_t)); + uint8_t *data = NULL; + uint8_t slot = head->slot - 1; + if (slot > PD_SLOTS_MAX) + { + DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot); + return E_BAD_PARAM; + } + + data = XMALLOC(MTYPE_CSG, sizeof(int)); + if (!data) { - DBG(DBG_M_PD_CSG_ERR, "Pkt port %d error!\r\n", vport); - return E_ERROR; - } - csg_config_port_t config = {0}; - config.vport = pd_config.config_port[unit][port].vport; - config.port_type = pd_config.config_port[unit][port].port_type; - config.filter = pd_config.config_port[unit][port].filter; - config.sensor_type = pd_config.config_port[unit][port].sensor_type; - config.is_auto_noise = pd_config.config_port[unit][port].is_auto_noise; - config.denoise_type = pd_config.config_port[unit][port].denoise_type; - config.denoise_variance = pd_config.config_port[unit][port].denoise_variance; - - config.event_counter_h = pd_config.config_port[unit][port].event_counter_h; - config.event_sec_h = pd_config.config_port[unit][port].event_sec_h; - config.event_thr_h = pd_config.config_port[unit][port].event_thr_h; - config.event_counter_thr_h = pd_config.config_port[unit][port].event_counter_thr_h; - - config.event_counter_l = pd_config.config_port[unit][port].event_counter_l; - config.event_sec_l = pd_config.config_port[unit][port].event_sec_l; - config.event_thr_l = pd_config.config_port[unit][port].event_thr_l; - config.event_counter_thr_l = pd_config.config_port[unit][port].event_counter_thr_l; - - config.burst_time = pd_config.config_port[unit][port].burst_time; - config.burst_thr = pd_config.config_port[unit][port].burst_thr; - config.denoise_manual = pd_config.config_port[unit][port].denoise_manual; - config.denoise_auto = pd_config.config_port[unit][port].denoise_auto; - - memcpy(pkt + sizeof(csg_pkt_head_t), (char *)&config, sizeof(csg_config_port_t)); - - _csg_send_data(CSG_PRV_REPLY, head->cmd, pkt, sizeof(pd_config_port_t)); - - return E_NONE; -} + DBG(DBG_M_PD_CSG_ERR, "XMALLOC ERROR!\r\n"); + return E_MEM; + } + *data = *param; + + if (_csg_msg_send_dau(slot, DAU_SEND_CFG_GET, data) != E_NONE) + { + XFREE(MTYPE_CSG, data); + } + return E_NONE; +} /* 解析HUF实时图谱召唤报文. */ int32_t _csg_real_image_recv(char *pkt) { - csg_real_image_get_t *pdata = (csg_real_image_get_t*)(pkt + sizeof(csg_pkt_head_t)); - void *data = NULL; - - DBG(DBG_M_PD_CSG, "vport=%d \r\n", pdata->vport); - DBG(DBG_M_PD_CSG, "is_concern=%d\r\n", pdata->is_concern); - DBG(DBG_M_PD_CSG, "denoise_correlation=%d\r\n", pdata->denoise_correlation); - DBG(DBG_M_PD_CSG, "denoise_type=%d\r\n", pdata->denoise_type); - DBG(DBG_M_PD_CSG, "denoise_manual=%d\r\n", pdata->denoise_manual); - DBG(DBG_M_PD_CSG, "filter_cfg=%d\r\n", pdata->filter); + csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; + csg_real_image_get_t *param = (csg_real_image_get_t*)(pkt + sizeof(csg_pkt_head_t)); + csg_real_image_get_t *data = NULL; + uint8_t slot = head->slot - 1; + if (slot > PD_SLOTS_MAX) + { + DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot); + return E_BAD_PARAM; + } data = XMALLOC(MTYPE_CSG, sizeof(csg_real_image_get_t)); - memcpy(data, pdata, sizeof(csg_real_image_get_t)); - _csg_msg_send(PD_SEND_TYPE_CMD, data); + if (!data) + { + DBG(DBG_M_PD_CSG_ERR, "XMALLOC ERROR!\r\n"); + return E_MEM; + } + + memcpy(data, param, sizeof(csg_real_image_get_t)); + if (_csg_msg_send_dau(slot, DAU_SEND_PRPS_GET, data) != E_NONE) + { + XFREE(MTYPE_CSG, data); + } return E_NONE; } @@ -695,7 +687,7 @@ int32_t _csg_upgrade_recv(char *pkt) /* 发送应答 */ memcpy(pkt + sizeof(csg_pkt_head_t), (char *)&ack, sizeof(csg_ack_t)); - _csg_send_data(CSG_REPLY, head->cmd, pkt, sizeof(ack)); + _csg_send_data(CSG_REPLY, head->cmd, pkt, sizeof(ack), 0); /* 如果升级线程开启失败返回错误信息. */ if (rv != E_NONE) @@ -790,9 +782,371 @@ int32_t _csg_recv_process(char *pkt, uint32_t len) } return E_NONE; } + +void _csg_send_add_dau(uint8_t slot, void *data) +{ + char *pkt = csg.buf_send; + if (NULL == data) + { + return; + } + memcpy(pkt + sizeof(csg_pkt_head_t), data, sizeof(csg_contact_t)); + _csg_send_data(CSG_REPLY, CSG_C_ADD_DAU, pkt, sizeof(csg_contact_t), slot + 1); +} + +void _csg_send_reset(uint8_t slot, void *data) +{ + char *pkt = csg.buf_send; + csg_ack_t ack = {0}; + ack.result = TRUE; + memcpy(pkt + sizeof(csg_pkt_head_t), (char *)&ack, sizeof(csg_ack_t)); + _csg_send_data(CSG_REPLY, CSG_C_RESET, pkt, sizeof(csg_ack_t), slot + 1); +} + +void _csg_send_info_set(uint8_t slot, void *data) +{ + char *pkt = csg.buf_send; + csg_ack_t ack = {0}; + ack.result = TRUE; + memcpy(pkt + sizeof(csg_pkt_head_t), (char *)&ack, sizeof(csg_ack_t)); + _csg_send_data(CSG_REPLY, CSG_C_DEV_INFO_SET, pkt, sizeof(csg_ack_t), slot + 1); +} + +void _csg_send_info_get(uint8_t slot, void *data) +{ + char *pkt = csg.buf_send; + if (NULL == data) + { + return; + } + + memcpy(pkt + sizeof(csg_pkt_head_t), data, sizeof(csg_dev_info_t)); + _csg_send_data(CSG_REPLY, CSG_C_DEV_INFO_GET, pkt, sizeof(csg_dev_info_t), slot + 1); +} + +void _csg_send_heartbeat(uint8_t slot, void *data) +{ + csg_timestamp_t *param = NULL; + struct timespec t; + + param = XMALLOC(MTYPE_CSG, sizeof(csg_timestamp_t)); + if (!param) + { + DBG(DBG_M_PD_CSG_ERR, "XMALLOC ERROR!\r\n"); + return; + } + clock_gettime(CLOCK_MONOTONIC, &t); + param->sec = time(NULL); + param->msec = t.tv_nsec / 1000000; + printf("sec=%u msec=%u\n", param->sec, param->msec); + + if (_csg_msg_send_dau(slot, DAU_SEND_HEARTBEAT, param) != E_NONE) + { + XFREE(MTYPE_CSG, param); + } +} + +void _csg_send_cfg_set(uint8_t slot, void *data) +{ + char *pkt = csg.buf_send; + csg_ack_t ack = {0}; + ack.result = TRUE; + memcpy(pkt + sizeof(csg_pkt_head_t), (char *)&ack, sizeof(csg_ack_t)); + _csg_send_data(CSG_PRV_REPLY, CSG_PRV_CONFIG_GLOBAL_SET, pkt, sizeof(csg_ack_t), slot + 1); +} + +void _csg_send_cfg_get(uint8_t slot, void *data) +{ + char *pkt = csg.buf_send; + if (NULL == data) + { + return; + } + memcpy(pkt, data, sizeof(csg_config_global_t)); + _csg_send_data(CSG_REPLY, CSG_PRV_CONFIG_GLOBAL_SET, pkt, sizeof(csg_config_global_t), slot + 1); +} + +void _csg_send_cfg_set_port(uint8_t slot, void *data) +{ + char *pkt = csg.buf_send; + csg_config_port_ack_t ack = {0}; + hf_cfg_port_ack_t *psrc = (hf_cfg_port_ack_t *)data; + ack.result = TRUE; + ack.vport = psrc->vport; + memcpy(pkt + sizeof(csg_pkt_head_t), (char *)&ack, sizeof(csg_ack_t)); + _csg_send_data(CSG_PRV_REPLY, CSG_PRV_CONFIG_PORT_SET, pkt, sizeof(csg_ack_t), slot + 1); +} + +void _csg_send_cfg_get_port(uint8_t slot, void *data) +{ + char *pkt = csg.buf_send; + if (NULL == data) + { + return; + } + + memcpy(pkt, data, sizeof(csg_config_global_t)); + _csg_send_data(CSG_PRV_REPLY, CSG_PRV_CONFIG_PORT_GET, pkt, sizeof(csg_config_global_t), slot + 1); +} + +void _csg_send_prps_get(uint8_t slot, void *data) +{ + char *pkt = csg.buf_send; + csg_ack_t ack = {0}; + ack.result = TRUE; + memcpy(pkt + sizeof(csg_pkt_head_t), (char *)&ack, sizeof(csg_ack_t)); + _csg_send_data(CSG_PRV_REPLY, CSG_PRV_CONFIG_REAL_WAVE, pkt, sizeof(csg_ack_t), slot + 1); +} + +void _csg_send_prps_data(uint8_t slot, void *data) +{ + char *pkt = csg.real_buf; + csg_real_image_t *head = (csg_real_image_t *)(pkt + sizeof(csg_pkt_head_t)); + char *pdata = pkt + sizeof(csg_pkt_head_t) + sizeof(csg_real_image_t); + hf_prps_t *real = (hf_prps_t *)data; + + uint8_t i = 0; + uint32_t sum = 0; + uint32_t len = 0; + uint32_t last_pack_len = 0; + uint32_t port_len = 0; + + if (NULL != data) + { + return; + } + + head->index = real->head.index; + head->fre_cnt = real->head.fre_cnt; + head->vport = real->head.vport; + head->max = real->head.max; + head->avg = real->head.avg; + head->cnt = real->head.cnt; + head->utc = real->head.utc; + head->freq = real->head.freq; + + /* 每个工频周期 256 个点, 每个点占 2byte */ + port_len = real->head.fre_cnt << 9; + sum = port_len / CSG_PKT_LEN; + last_pack_len = port_len % CSG_PKT_LEN; + if (last_pack_len != 0) + { + sum += 1; + } + head->pkt_sum = sum; + + DBG(DBG_M_PD_CSG, "max = %d avg = %d cnt=%d fre_cnt=%d freq=%f port_len=%d\r\n", head->max, head->avg, head->cnt, head->fre_cnt, head->freq, port_len); + for (i = 0; i < sum; i++) + { + len = (i == sum - 1) ? last_pack_len : CSG_PKT_LEN; + head->pkt_index = i; + head->len = len; + memcpy(pdata, (char *)real->prps + CSG_PKT_LEN * i, len); + /* 这里延迟 500us, 是因为当使用 100M 光转电模块时, 因为我们的光口是千兆的所以会丢包 */ + usleep(500); + _csg_send_data(CSG_PRV_REPLY, CSG_PRV_REAL_PRPS, pkt, sizeof(csg_real_image_t) + len, slot + 1); + } +} + +void _csg_send_trend(uint8_t slot, void *data) +{ + char *pkt = csg.buf_send; + if (NULL != data) + { + return; + } + memcpy(pkt + sizeof(csg_pkt_head_t), data, sizeof(csg_ack_t)); + _csg_send_data(CSG_PRV_REPLY, CSG_PRV_TREND, pkt, sizeof(csg_ack_t), slot + 1); +} + +void _csg_send_prps(uint8_t slot, void *data) +{ + char *pkt = csg.buf_send; + if (NULL != data) + { + return; + } + memcpy(pkt + sizeof(csg_pkt_head_t), data, sizeof(csg_ack_t)); + _csg_send_data(CSG_PRV_REPLY, CSG_PRV_REAL_PRPS, pkt, sizeof(csg_ack_t), slot + 1); +} + +void _csg_send_event(uint8_t slot, void *data) +{ + char *pkt = csg.buf_send; + if (NULL != data) + { + return; + } + memcpy(pkt + sizeof(csg_pkt_head_t), data, sizeof(csg_ack_t)); + _csg_send_data(CSG_PRV_REPLY, CSG_PRV_EVENT, pkt, sizeof(csg_ack_t), slot + 1); +} + +/* csg向后台发包处理函数 */ +int32_t _csg_send_process(uint8_t type, uint8_t slot, void *data) +{ + //csg_pkt_head_t *head = (csg_pkt_head_t*)data; + /* 报文头和 CRC 校验. */ + //LD_E_RETURN_N(_hf_pkt_check(slot, pkt)); + if (_csg_send_command[type]) + { + _csg_send_command[type](slot, data); + } + +#if 0 + if (CSG_REQUEST == head->cmd_type) + { + _csg_send_command[type](slot, data); + } + else if (CSG_PRV_REQUEST == head->cmd_type) + { + _csg_send_prv_command[type](slot, data); + } +#endif + + return E_NONE; +} + +/* 普通命令发送平台线程 */ +void *_csg_send_cmd_handle(void *arg) +{ + dau_send_msg_t *recv_msg = NULL; + /* 等待初始化完成 */ + while(!is_system_init) + { + sleep(1); + } + + csg.send_cb = _csg_send_process; -/* 心跳和连接处理函数. */ + while(1) + { + if (fifo_read(csg.fifo_cmd_id, (void**)&recv_msg) != 0) + { + DBG(DBG_M_PD_CSG_ERR, "ERROR at fifo %d read!\r\n", csg.fifo_cmd_id); + continue; + } + + /* 响应其他报文 */ + if (csg.send_cb) + { + csg.send_cb(recv_msg->type, recv_msg->slot, recv_msg->data); + } + + /* 释放数据内存, 注意一定要在 fifo_push 之前调用, 因为 fifo_push 后 recv_msg 已被释放. */ + XFREE(MTYPE_CSG, recv_msg->data); + fifo_push(csg.fifo_cmd_id); + } + + return NULL; +} + +/* prps 发送平台线程 */ +void *_csg_send_prps_handle(void *arg) +{ + dau_send_msg_t *recv_msg = NULL; + + /* 等待初始化完成 */ + while(!is_system_init) + { + sleep(1); + } + + csg.send_cb = _csg_send_process; + + while(1) + { + if (fifo_read(csg.fifo_prps_id, (void**)&recv_msg) != 0) + { + DBG(DBG_M_PD_DAU_ERR, "ERROR at fifo %d read!\r\n", csg.fifo_prps_id); + continue; + } + + /* 响应其他报文 */ + if (csg.send_cb) + { + csg.send_cb(recv_msg->type, recv_msg->slot, recv_msg->data); + } + + /* 释放数据内存, 注意一定要在 fifo_push 之前调用, 因为 fifo_push 后 recv_msg 已被释放. */ + XFREE(MTYPE_CSG, recv_msg->data); + fifo_push(csg.fifo_prps_id); + } + + return NULL; +} + +/* trend 发送平台线程 */ +void *_csg_send_trend_handle(void *arg) +{ + dau_send_msg_t *recv_msg = NULL; + + /* 等待初始化完成 */ + while(!is_system_init) + { + sleep(1); + } + + csg.send_cb = _csg_send_process; + + while(1) + { + if (fifo_read(csg.fifo_trend_id, (void**)&recv_msg) != 0) + { + DBG(DBG_M_PD_DAU_ERR, "ERROR at fifo %d read!\r\n", csg.fifo_trend_id); + continue; + } + + /* 响应其他报文 */ + if (csg.send_cb) + { + csg.send_cb(recv_msg->type, recv_msg->slot, recv_msg->data); + } + + /* 释放数据内存, 注意一定要在 fifo_push 之前调用, 因为 fifo_push 后 recv_msg 已被释放. */ + XFREE(MTYPE_CSG, recv_msg->data); + fifo_push(csg.fifo_trend_id); + } + + return NULL; +} + +/* event 发送平台线程 */ +void *_csg_send_event_handle(void *arg) +{ + dau_send_msg_t *recv_msg = NULL; + + /* 等待初始化完成 */ + while(!is_system_init) + { + sleep(1); + } + + csg.send_cb = _csg_send_process; + + while(1) + { + if (fifo_read(csg.fifo_event_id, (void**)&recv_msg) != 0) + { + DBG(DBG_M_PD_DAU_ERR, "ERROR at fifo %d read!\r\n", csg.fifo_event_id); + continue; + } + + /* 响应其他报文 */ + if (csg.send_cb) + { + csg.send_cb(recv_msg->type, recv_msg->slot, recv_msg->data); + } + + /* 释放数据内存, 注意一定要在 fifo_push 之前调用, 因为 fifo_push 后 recv_msg 已被释放. */ + XFREE(MTYPE_CSG, recv_msg->data); + fifo_push(csg.fifo_event_id); + } + + return NULL; +} + +/* 后台接收处理函数. */ void *_csg_recv_handle(void *arg) { struct sockaddr_in server; @@ -811,7 +1165,6 @@ void *_csg_recv_handle(void *arg) while(1) { /* 读取数据. */ - memset(csg.buf_recv, 0, sizeof(csg.buf_recv)); data_len = recvfrom(csg.skfd, csg.buf_recv, CSG_PKT_LEN, 0, (struct sockaddr*)&server, &server_len); if (data_len <= 0) { @@ -830,6 +1183,7 @@ void *_csg_recv_handle(void *arg) return NULL; } + /* 心跳和连接处理函数. */ void *_csg_heartbeat_handle(void *arg) @@ -878,12 +1232,10 @@ void *_csg_heartbeat_handle(void *arg) for (int i = 0; i < PD_SLOTS_MAX; i++) { - printf("dau[%d]:is_connect=%d is_insert=%d\n", i, daus[i].state.is_connect, - daus[i].state.is_insert); if (daus[i].state.is_connect == TRUE && daus[i].state.is_insert != TRUE) { - _csg_add_dau_send(i + 1, 1); + _csg_send_add_dau(i, &daus[i].info); } } } @@ -1004,13 +1356,29 @@ int32_t csg_handle_init_after(void) param.arg = NULL; param.log_module = LOG_CSG; - param.priority = 45; + param.priority = 70; snprintf(param.thread_name, THREAD_NAME_LEN, "CSG_RCVE"); create_thread(_csg_recv_handle, ¶m); - param.priority = 45; + param.priority = 55; snprintf(param.thread_name, THREAD_NAME_LEN, "CSG_HEARTBEAT"); create_thread(_csg_heartbeat_handle, ¶m); + + param.priority = 60; + snprintf(param.thread_name, THREAD_NAME_LEN, "CSG_SEND_CMD"); + create_thread(_csg_send_cmd_handle, ¶m); + + param.priority = 80; + snprintf(param.thread_name, THREAD_NAME_LEN, "CSG_SEND_PRPS"); + create_thread(_csg_send_prps_handle, ¶m); + + param.priority = 70; + snprintf(param.thread_name, THREAD_NAME_LEN, "CSG_SEND_TREND"); + create_thread(_csg_send_trend_handle, ¶m); + + param.priority = 75; + snprintf(param.thread_name, THREAD_NAME_LEN, "CSG_SEND_EVENT"); + create_thread(_csg_send_event_handle, ¶m); return E_NONE; } @@ -1028,7 +1396,7 @@ void csg_upgrade_result_send(int32_t rv, char *buf) strcpy(ack.context, buf); memcpy(pkt + sizeof(csg_pkt_head_t), (char *)&ack, sizeof(csg_ack_t)); - _csg_send_data(CSG_REPLY, CSG_C_UPDATE_RESULT, pkt, sizeof(upgrade_res_t)); + _csg_send_data(CSG_REPLY, CSG_C_UPDATE_RESULT, pkt, sizeof(upgrade_res_t), 0); } command_handler _csg_get_table_handle(command_entry *ptable, command_type cmd) diff --git a/app/lib/m_management/memory.c b/app/lib/m_management/memory.c old mode 100644 new mode 100755