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

FIX 修改接收平台的参数信息;

Browse Source
main
wangbo 6 days ago
parent 9b8eb91ed8
commit 0f3272710e
1 changed files with 223 additions and 203 deletions
Show Stats Download Patch File Download Diff File

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

@ -431,225 +431,167 @@ void _csg_reboot_recv(char *pkt)
说明：修改本地ip 设备ID 服务器地址时需要重启。 说明：修改本地ip 设备ID 服务器地址时需要重启。
*/ */
int32_t _csg_dev_info_set_recv(char *pkt) int32_t _csg_dev_info_set_recv(char *pkt)
{ {
int change_ip = 0; csg_pkt_head_t *head = (csg_pkt_head_t*)pkt;
REBOOT_MSG boottype = REBOOT_NONE; csg_dev_info_t *param = (csg_dev_info_t*)(pkt + sizeof(csg_pkt_head_t));
csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; csg_dev_info_t *data = NULL;
csg_dev_info_t *pinfo = (csg_dev_info_t *)(pkt + CSG_HEAD_LEN); uint8_t slot = head->slot - 1;
device_info.dev_id = pinfo->dev_id; if (slot > PD_SLOTS_MAX)
device_info.mask = pinfo->mask; {
device_info.gw = pinfo->gw; DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot);
return E_BAD_PARAM;
if (strncmp((char *)(pinfo->hostname), device_info.hostname, sizeof(device_info.hostname))) }
{
snprintf((char*)device_info.hostname, FILE_NAME_LEN, "%s", pinfo->hostname); data = XMALLOC(MTYPE_CSG, sizeof(csg_dev_info_t));
boottype = REBOOT_REMOTE_HOST_NAME_CHANGE; if (!data)
}
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), 0);
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)
{ {
reboot_system(LOG_CSG, boottype); DBG(DBG_M_PD_CSG_ERR, "XMALLOC ERROR!\r\n");
} return E_MEM;
}
return 0;
} 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) int32_t _csg_dev_info_get_recv(char *pkt)
{ {
csg_pkt_head_t *head = (csg_pkt_head_t*)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)); int *data = NULL;
pinfo->type_m = device_info.type_m; uint8_t slot = head->slot - 1;
pinfo->type_s = device_info.type_s; if (slot > PD_SLOTS_MAX)
pinfo->dev_id = device_info.dev_id; {
strcpy(pinfo->hostname, device_info.hostname); DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot);
pinfo->factory_date = device_info.factory_date; return E_BAD_PARAM;
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); data = XMALLOC(MTYPE_CSG, sizeof(int));
snprintf((char*)pinfo->hardware_version, DEV_VERSION_STR_LEN, "%s", device_info.hardware_version); if (!data)
snprintf((char*)pinfo->FPGA_version, DEV_VERSION_STR_LEN, "%s", device_info.FPGA_version); {
pinfo->ip = device_info.ip; DBG(DBG_M_PD_CSG_ERR, "XMALLOC ERROR!\r\n");
pinfo->mask = device_info.mask; return E_MEM;
pinfo->gw = device_info.gw; }
memcpy(pinfo->mac, device_info.mac, sizeof(pinfo->mac));
//info.server_port = device_info.server_port; if (_csg_msg_send_dau(slot, DAU_SEND_INFO_GET, data) != E_NONE)
//info.server_ipv4 = device_info.server_ipv4; {
pinfo->server_port = csg.server_port; XFREE(MTYPE_CSG, data);
pinfo->server_ipv4 = csg.server_ip; }
return E_NONE;
_csg_send_data(CSG_REPLY, head->cmd, pkt, sizeof(csg_dev_info_t), 0); }
return E_NONE;
}
/* 配置用户参数报文报文处理. */ /* 配置用户参数报文报文处理. */
int32_t _csg_config_set_recv(char *pkt) int32_t _csg_config_set_recv(char *pkt)
{ {
csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; csg_pkt_head_t *head = (csg_pkt_head_t*)pkt;
csg_config_global_t *pnet = (csg_config_global_t *)(pkt + CSG_HEAD_LEN); csg_config_global_t *param = (csg_config_global_t*)(pkt + sizeof(csg_pkt_head_t));
csg_config_global_t *data = NULL;
pd_config.config.power_frequency = pnet->power_frequency; uint8_t slot = head->slot - 1;
pd_config.config.trend_period = pnet->trend_period * 60; if (slot > PD_SLOTS_MAX)
pd_config.config.sync_mode = pnet->sync_mode; {
pd_config.config.heartbeat_period = pnet->heartbeat_period; DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot);
pd_config.config.pps_mode = pnet->pps_mode; return E_BAD_PARAM;
pd_config.config.protocol_type = pnet->protocol_type; }
pd_config.config.event_storage = pnet->event_storage;
pd_config.config.trend_storage = pnet->trend_storage; data = XMALLOC(MTYPE_CSG, sizeof(csg_config_global_t));
if (!data)
vtysh_config_save(); {
DBG(DBG_M_PD_CSG_ERR, "XMALLOC ERROR!\r\n");
csg_ack_t ack = {0}; return E_MEM;
ack.result = TRUE; }
memcpy(pkt + sizeof(csg_pkt_head_t), (char *)&ack, sizeof(csg_ack_t));
memcpy(data, param, sizeof(csg_config_global_t));
_csg_send_data(CSG_PRV_REPLY, head->cmd, pkt, sizeof(csg_ack_t), 0); if (_csg_msg_send_dau(slot, DAU_SEND_CFG_SET, data) != E_NONE)
return E_NONE; {
} XFREE(MTYPE_CSG, data);
}
return E_NONE;
}
/* 查询用户参数查询报文处理. */ /* 查询用户参数查询报文处理. */
int32_t _csg_config_get_recv(char *pkt) int32_t _csg_config_get_recv(char *pkt)
{ {
csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; csg_pkt_head_t *head = (csg_pkt_head_t*)pkt;
csg_config_global_t config = {0}; int *data = NULL;
config.power_frequency = pd_config.config.power_frequency; uint8_t slot = head->slot - 1;
config.sync_mode = pd_config.config.sync_mode; if (slot > PD_SLOTS_MAX)
config.heartbeat_period = pd_config.config.heartbeat_period; {
config.pps_mode = pd_config.config.pps_mode; DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot);
config.protocol_type = pd_config.config.protocol_type; return E_BAD_PARAM;
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; data = XMALLOC(MTYPE_CSG, sizeof(int));
memcpy(pkt + sizeof(csg_pkt_head_t), (char *)&config, sizeof(csg_config_global_t)); if (!data)
_csg_send_data(CSG_PRV_REPLY, head->cmd, pkt, sizeof(csg_config_global_t), 0); {
DBG(DBG_M_PD_CSG_ERR, "XMALLOC ERROR!\r\n");
return E_NONE; 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) int32_t _csg_port_config_set_recv(char *pkt)
{ {
//uint8_t vport = *(uint8_t*)(pkt + CSG_HEAD_LEN); csg_pkt_head_t *head = (csg_pkt_head_t*)pkt;
uint8_t unit = 0; csg_config_port_t *param = (csg_config_port_t*)(pkt + sizeof(csg_pkt_head_t));
uint8_t port = 0; csg_config_port_t *data = NULL;
//csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; uint8_t slot = head->slot - 1;
csg_config_port_t *pnet = (csg_config_port_t *)(pkt + CSG_HEAD_LEN); if (slot > PD_SLOTS_MAX)
{
pd_config.config_port[unit][port].vport = pnet->vport; DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot);
pd_config.config_port[unit][port].port_type = pnet->port_type; return E_BAD_PARAM;
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; data = XMALLOC(MTYPE_CSG, sizeof(csg_config_port_t));
pd_config.config_port[unit][port].denoise_type = pnet->denoise_type; if (!data)
pd_config.config_port[unit][port].denoise_variance = pnet->denoise_variance; {
DBG(DBG_M_PD_CSG_ERR, "XMALLOC ERROR!\r\n");
pd_config.config_port[unit][port].event_counter_h = pnet->event_counter_h; return E_MEM;
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; memcpy(data, param, sizeof(csg_config_port_t));
if (_csg_msg_send_dau(slot, DAU_SEND_PORT_SET, data) != E_NONE)
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; XFREE(MTYPE_CSG, data);
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; return E_NONE;
}
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;
}
/* 按通道提交端口参数查询结果. */ /* 按通道提交端口参数查询结果. */
int32_t _csg_port_config_get_recv(char *pkt) int32_t _csg_port_config_get_recv(char *pkt)
{ {
uint8_t vport = *(uint8_t*)(pkt + CSG_HEAD_LEN); csg_pkt_head_t *head = (csg_pkt_head_t*)pkt;
uint8_t unit = 0; uint8_t *param = (uint8_t *)(pkt + sizeof(csg_pkt_head_t));
uint8_t port = 0; uint8_t *data = NULL;
csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; uint8_t slot = head->slot - 1;
//csg_config_port_t *pnet = (csg_config_port_t *)(pkt + CSG_HEAD_LEN); if (slot > PD_SLOTS_MAX)
{
//if (dau_vport_to_port(pnet->vport, &unit, &port) != E_NONE) 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); DBG(DBG_M_PD_CSG_ERR, "XMALLOC ERROR!\r\n");
return E_ERROR; return E_MEM;
} }
csg_config_port_t config = {0}; *data = *param;
config.vport = pd_config.config_port[unit][port].vport;
config.port_type = pd_config.config_port[unit][port].port_type; if (_csg_msg_send_dau(slot, DAU_SEND_CFG_GET, data) != E_NONE)
config.filter = pd_config.config_port[unit][port].filter; {
config.sensor_type = pd_config.config_port[unit][port].sensor_type; XFREE(MTYPE_CSG, data);
config.is_auto_noise = pd_config.config_port[unit][port].is_auto_noise; }
config.denoise_type = pd_config.config_port[unit][port].denoise_type; return E_NONE;
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), 0);
return E_NONE;
}
/* 解析HUF实时图谱召唤报文. */ /* 解析HUF实时图谱召唤报文. */
int32_t _csg_real_image_recv(char *pkt) int32_t _csg_real_image_recv(char *pkt)
@ -1133,6 +1075,76 @@ void *_csg_send_prps_handle(void *arg)
return NULL; 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) void *_csg_recv_handle(void *arg)
@ -1356,9 +1368,17 @@ int32_t csg_handle_init_after(void)
snprintf(param.thread_name, THREAD_NAME_LEN, "CSG_SEND_CMD"); snprintf(param.thread_name, THREAD_NAME_LEN, "CSG_SEND_CMD");
create_thread(_csg_send_cmd_handle, &param); create_thread(_csg_send_cmd_handle, &param);
param.priority = 65; param.priority = 80;
snprintf(param.thread_name, THREAD_NAME_LEN, "CSG_SEND_PRPS"); snprintf(param.thread_name, THREAD_NAME_LEN, "CSG_SEND_PRPS");
create_thread(_csg_send_prps_handle, &param); create_thread(_csg_send_prps_handle, &param);
param.priority = 70;
snprintf(param.thread_name, THREAD_NAME_LEN, "CSG_SEND_TREND");
create_thread(_csg_send_trend_handle, &param);
param.priority = 75;
snprintf(param.thread_name, THREAD_NAME_LEN, "CSG_SEND_EVENT");
create_thread(_csg_send_event_handle, &param);
return E_NONE; return E_NONE;
} }

Write Preview
Loading…
Cancel
Save