wangbo
/
IntegratedCMU
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

FIX 优化csg

Browse Source
main
wangbo 7 days ago
parent 993d711d10
commit 9b8eb91ed8
3 changed files with 454 additions and 105 deletions
Show Stats Download Patch File Download Diff File

63
app/include/pd_csg.h
Unescape Escape View File

@ -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 ****************/

496
app/lib/a_process/pd_csg.c
Unescape Escape View File

@ -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);
@ -427,7 +468,7 @@ int32_t _csg_dev_info_set_recv(char *pkt)
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));
_csg_send_data(CSG_REPLY, head->cmd, pkt, sizeof(csg_ack_t), 0);
vtysh_config_save();
if (change_ip)
@ -471,7 +512,7 @@ int32_t _csg_dev_info_get_recv(char *pkt)
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));
_csg_send_data(CSG_REPLY, head->cmd, pkt, sizeof(csg_dev_info_t), 0);
return E_NONE;
}
@ -497,7 +538,7 @@ int32_t _csg_config_set_recv(char *pkt)
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));
_csg_send_data(CSG_PRV_REPLY, head->cmd, pkt, sizeof(csg_ack_t), 0);
return E_NONE;
}
@ -515,7 +556,7 @@ int32_t _csg_config_get_recv(char *pkt)
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));
_csg_send_data(CSG_PRV_REPLY, head->cmd, pkt, sizeof(csg_config_global_t), 0);
return E_NONE;
}
@ -605,7 +646,7 @@ int32_t _csg_port_config_get_recv(char *pkt)
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));
_csg_send_data(CSG_PRV_REPLY, head->cmd, pkt, sizeof(pd_config_port_t), 0);
return E_NONE;
}
@ -613,19 +654,28 @@ int32_t _csg_port_config_get_recv(char *pkt)
/* 解析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 +745,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 +840,301 @@ 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;
}
/* 后台接收处理函数. */
void *_csg_recv_handle(void *arg)
{
struct sockaddr_in server;
@ -811,7 +1153,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 +1171,7 @@ void *_csg_recv_handle(void *arg)
return NULL;
}
/* 心跳和连接处理函数. */
void *_csg_heartbeat_handle(void *arg)
@ -878,12 +1220,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 +1344,21 @@ 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, &param);
param.priority = 45;
param.priority = 55;
snprintf(param.thread_name, THREAD_NAME_LEN, "CSG_HEARTBEAT");
create_thread(_csg_heartbeat_handle, &param);
param.priority = 60;
snprintf(param.thread_name, THREAD_NAME_LEN, "CSG_SEND_CMD");
create_thread(_csg_send_cmd_handle, &param);
param.priority = 65;
snprintf(param.thread_name, THREAD_NAME_LEN, "CSG_SEND_PRPS");
create_thread(_csg_send_prps_handle, &param);
return E_NONE;
}
@ -1028,7 +1376,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)

0
app/lib/m_management/memory.c
Unescape Escape View File

Write Preview
Loading…
Cancel
Save