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

FIX | 添加高频连接功能

Browse Source
main
yuliang 1 week ago
parent 26077c703d
commit 492e481216
7 changed files with 438 additions and 187 deletions
Show Stats Download Patch File Download Diff File

1
app/include/memory.h
Unescape Escape View File

@ -69,6 +69,7 @@ enum
MTYPE_ETH, MTYPE_ETH,
MTYPE_GIS, MTYPE_GIS,
MTYPE_DAU, MTYPE_DAU,
MTYPE_HF,
MTYPE_CSG, MTYPE_CSG,
MTYPE_STORAGE, MTYPE_STORAGE,
MTYPE_DEBUG, MTYPE_DEBUG,

141
app/include/pd_dau.h
Unescape Escape View File

@ -62,7 +62,9 @@
/* Exported types ------------------------------------------------------------*/ /* Exported types ------------------------------------------------------------*/
typedef int32_t (*dau_recv_cb)(uint8_t, char*, uint16_t); typedef int32_t (*dau_recv_cb)(uint8_t, char*, uint16_t);
typedef int32_t (*dau_send_cb)(uint8_t, uint8_t, void*);
typedef void (*dau_recv_fun_cb)(uint8_t, char*, uint16_t); typedef void (*dau_recv_fun_cb)(uint8_t, char*, uint16_t);
typedef void (*dau_send_fun_cb)(uint8_t, void*);
/* 命令类型. */ /* 命令类型. */
enum DAU_CMD_TYPE enum DAU_CMD_TYPE
@ -101,72 +103,19 @@ enum DAU_P_CMD
DAU_P_MAX DAU_P_MAX
}; };
// 板卡类型枚举 /* 命令类型. */
typedef enum { enum DAU_SEND_TYPE
DAU_TYPE_UDP,
DAU_TYPE_RS485,
DAU_TYPE_NONE
} DauType;
// 板卡状态枚举
typedef enum {
DAU_STATE_DISCONNECTED,
DAU_STATE_CONNECTED,
DAU_STATE_REGISTERED
} DauState;
// 通信回调函数类型
//typedef void (*data_recv_callback)(void* priv_data, const void* data, size_t len);
//typedef void (*data_send_callback)(void* priv_data, void* data, size_t len);
// 板卡私有数据结构
typedef struct
{
DauType type;
union
{
struct
{
int sockfd;
struct sockaddr_in addr;
} udp;
struct
{ {
int fd; DAU_SEND_PRPS = 1,
char port[20]; DAU_SEND_MAX
struct termios options; };
} rs485;
} comm;
char board_id[32];
void *rx_buffer;
size_t buffer_size;
uint8_t cmd_type;
uint8_t cmd;
} dau_private_data_t;
// 板卡操作回调函数结构 /* 发送数据消息 */
typedef struct typedef struct
{ {
int (*init)(dau_private_data_t *data, const char *config); uint32_t type;
int (*receive)(dau_private_data_t *data, void *buf, size_t len); void *data;
int (*transmit)(dau_private_data_t *data, const void *buf, size_t len); } dau_send_msg_t;
void (*cleanup)(dau_private_data_t *data);
} dau_operations_t;
// UDP客户端信息
typedef struct {
struct sockaddr_in addr;
char board_id[32];
} udp_client_data;
// RS485设备信息
typedef struct {
int fd; // 串口文件描述符
char board_id[32];
uint8_t address; // 从机地址
} rs485_device_data;
/* 报文头初始化结构体 */ /* 报文头初始化结构体 */
typedef struct typedef struct
@ -226,65 +175,6 @@ typedef struct
uint8_t port_type[PD_PORT_SUM]; uint8_t port_type[PD_PORT_SUM];
} dau_contact_t; } dau_contact_t;
/* 心跳报文. */
typedef struct
{
float freq; // 实测同步源工频频率.
uint8_t dau_state[4]; // 采集模块的状态.
uint8_t out_sync; // 外接调频同步 1: 有效 0: 无效.
uint8_t pt_sync; // PT同步 1: 有效 0: 无效.
uint8_t in_sync; // 内同步 1: 有效 0: 无效.
uint8_t reserved1; // 预留 字节对齐.
uint8_t port_link_alarm[PD_PORT_SUM]; // 通道传感器连接状态 断线告警.
uint8_t dau_port_num[4]; // 采集板端口数量.
} dau_heartbeat_t;
/* 时间头 */
typedef struct
{
uint16_t index; // 包索引
uint16_t sum; // 总包数
uint8_t vport; // 通道号
uint8_t boosterpack; // 是否补包 0：否 1：是
int16_t max; // 通道的最大值.
uint32_t power_fre; // 工频周期.
uint8_t type; // 事件类型.
uint8_t reserved[3]; // 保留
uint32_t identifier; // 数据编号: 0 - (2^32-1) 循环.
uint32_t utc; // UTC 时标.
uint32_t cnt; // 通道每秒脉冲计数值.
uint16_t avg_o; // 通道原始信号 (降噪前) 的平均值.
uint16_t avg; // 脉冲平均值.
uint32_t point_cnt; // 数据累计点数
uint32_t len; // 当前包长度
} dau_event_head_t;
// 板卡管理器结构
typedef struct
{
//dau_private_data_t *private_data;
dau_operations_t ops;
// udp
int sockfd;
struct sockaddr_in addr;
// rs485
int fd;
char port[20];
struct termios options;
char board_id[32];
void *rx_buffer;
size_t buffer_size;
uint8_t cmd_type;
uint8_t cmd;
pthread_t thread_id;
int slot;
bool occupied; // 槽位占用标志
} dau_manager_t;
/* DAU 状态结构体 */ /* DAU 状态结构体 */
typedef struct typedef struct
{ {
@ -296,16 +186,17 @@ typedef struct
typedef struct typedef struct
{ {
uint8_t slot; // dau slot uint8_t slot; // dau slot
DauType type; uint16_t pkt_id; // 发送报文 id
int fd; // dau socket fd int fd; // dau socket fd
struct sockaddr_in server; // dau client ip struct sockaddr_in server; // dau client ip
char buf_recv[DAU_BUF_SIZE]; // dau 收包 buf char buf_recv[DAU_BUF_SIZE]; // dau 收包 buf
DauState stat; char buf_send[DAU_BUF_SIZE]; // dau 发包 buf
void *private_data;
dau_contact_t info; // dau 信息 dau_contact_t info; // dau 信息
dau_heartbeat_t run_status; // dau 运行状态
dau_state_t state; // dau 状态 dau_state_t state; // dau 状态
dau_recv_cb recv_cb; // dau 收包处理函数 dau_recv_cb recv_cb; // dau 收包处理函数
dau_send_cb send_cb; // dau 收包处理函数
int32_t fifo_send; // 发包 fifo
void *private_data;
} dau_t; } dau_t;
/* Exported macro ------------------------------------------------------------*/ /* Exported macro ------------------------------------------------------------*/

175
app/include/pd_hf.h
Unescape Escape View File

@ -3,6 +3,33 @@
#ifdef CFG_DEV_TYPE_LAND_PD #ifdef CFG_DEV_TYPE_LAND_PD
/* Includes ------------------------------------------------------------------*/ /* Includes ------------------------------------------------------------------*/
#include "pd_dau.h"
#define HF_DATA_LEN (1300)
/*趋势上送数据报文头c语言定义*/
enum HF_TREND_TYPE
{
HF_TREND_TYPE_PRPD = 0, // 累计PRPD
HF_TREND_TYPE_ORIG, // 原始波形
HF_TREND_TYPE_PRPS, // 后10秒PRPS
HF_TREND_TYPE_STAT, // 统计数据
HF_TREND_TYPE_MAX,
};
/* 点位数据 */
typedef struct
{
uint16_t index; // 点位
int16_t data; // 数据
} hf_data_point_t;
/* 一般应答 */
typedef struct
{
uint8_t result; // 应答结果. 0:失败 1:成功
uint8_t reserved[3]; // 保留
} hf_ack_t;
typedef struct typedef struct
{ {
@ -28,7 +55,155 @@ typedef struct
uint8_t port_type[8]; uint8_t port_type[8];
} hf_dev_info_t; } hf_dev_info_t;
/* 心跳报文. */
typedef struct
{
float freq; // 实测同步源工频频率.
uint8_t dau_state[4]; // 采集模块的状态.
uint8_t out_sync; // 外接调频同步 1: 有效 0: 无效.
uint8_t pt_sync; // PT同步 1: 有效 0: 无效.
uint8_t in_sync; // 内同步 1: 有效 0: 无效.
uint8_t reserved1; // 预留 字节对齐.
uint8_t port_link_alarm[PD_PORT_SUM]; // 通道传感器连接状态 断线告警.
uint8_t dau_port_num[4]; // 采集板端口数量.
} hf_heartbeat_t;
/* 实时图谱关注 */
typedef struct
{
uint8_t vport; // 通道编号 1 ~ 8
uint8_t is_concern; // 关注 1: 关注 0: 取消关注
uint8_t filter; // 滤波器类型
uint8_t denoise_correlation; // 关联降噪 1: 关联噪声去噪
uint8_t denoise_type; // 0-无配置 1-自动 2-手动降噪
uint8_t reserved[1];
uint16_t denoise_manual; // 手动降噪等级
} hf_prps_get_t;
/* 趋势头 */
typedef struct
{
uint16_t index; // 包索引
uint16_t sum; // 总包数
uint8_t type; // 数据类型 0：prpd 1:原始波形 2：10秒prps 3:统计数据
uint8_t vport; // 通道号
uint8_t boosterpack; // 是否补包 0：否 1：是
uint8_t reserved[1]; // 保留
uint32_t identifier; // 数据编号
uint32_t utc; // 同步时间
uint32_t len; // 当前包长度
} hf_trend_head_t;
/* 趋势应答 */
typedef struct
{
uint32_t index;
uint8_t result;
uint8_t boosterpack; // 是否补包 0:否 1:是
uint8_t reserve[2];
} hf_trend_ack_t;
/* 趋势统计 */
typedef struct
{
uint16_t data_cnt; // 数据计数
int16_t max; // 通道的最大值
uint16_t reserved; // 保留
uint16_t avg; // 通道的平均值
uint32_t cnt; // 通道的计数值
uint32_t phase; // 放电相位
uint32_t noise; // 趋势数据中的底噪值: 单位 dBm
uint32_t event_cnt; // 趋势数据中的的事件数量记录
} hf_trend_stat;
/* 趋势统计结构体 */
typedef struct
{
uint32_t index; // 数据编号: 0 - (2^32-1) 循环.
uint32_t utc; // UTC 时标.
hf_trend_stat port[PD_DAU_PORT_SUM]; // 通道 0 - 15 的计算及测量数据.
} hf_trend_col_t;
/* 趋势 PRPD 结构体 */
typedef struct
{
uint16_t data[PD_PHASE_NUM][PD_VAULE_NUM];
} hf_trend_prpd_port_t;
/* 趋势 PRPD 结构体 */
typedef struct
{
pd_trend_prpd_port_t port[PD_DAU_PORT_SUM];
} hf_trend_prpd_t;
/* 趋势 PRPS 结构体 */
typedef struct
{
uint32_t point_cnt; // 数据累计点数.
hf_data_point_t point[PD_TREND_POINT_MAX];
} hf_trend_prps_port_t;
/* 趋势 PRPS 结构体 */
typedef struct
{
hf_trend_prps_port_t port[PD_DAU_PORT_SUM];
} hf_trend_prps_t;
/* 高频趋势数据 */
typedef struct
{
hf_trend_col_t col;
hf_trend_prpd_t prpd;
hf_trend_prps_t prps;
} hf_trend_t;
/* 事件头 */
typedef struct
{
uint16_t index; // 包索引
uint16_t sum; // 总包数
uint8_t vport; // 通道号
uint8_t boosterpack; // 是否补包 0：否 1：是
int16_t max; // 通道的最大值.
uint32_t power_fre; // 工频周期.
uint8_t type; // 事件类型.
uint8_t reserved[3]; // 保留
uint32_t identifier; // 数据编号: 0 - (2^32-1) 循环.
uint32_t utc; // UTC 时标.
uint32_t cnt; // 通道每秒脉冲计数值.
uint16_t avg_o; // 通道原始信号 (降噪前) 的平均值.
uint16_t avg; // 脉冲平均值.
uint32_t point_cnt; // 数据累计点数
uint32_t len; // 当前包长度
} hf_event_head_t;
/* 事件应答 */
typedef struct
{
uint32_t index;
uint8_t result;
uint8_t boosterpack; // 是否补包 0: 否 1: 是
uint8_t reserve[2];
} hf_event_ack_t;
/* 高频事件数据 */
typedef struct
{
hf_event_head_t head;
hf_data_point_t point[PD_EVENT_POINT_MAX];
} hf_event_t;
/* 高频私有数据 */
typedef struct
{
hf_heartbeat_t run_status;
hf_event_t event;
hf_trend_t trend;
} hf_data_t;
extern int32_t hf_recv_process(uint8_t slot, char *pkt, uint16_t len); extern int32_t hf_recv_process(uint8_t slot, char *pkt, uint16_t len);
extern int32_t hf_send_process(uint8_t slot, uint8_t type, void *data);
extern void* hf_data_malloc(void);
#endif #endif
#endif #endif

4
app/include/pd_main.h
Unescape Escape View File

@ -55,9 +55,9 @@
#define PD_VAULE_NUM 256 #define PD_VAULE_NUM 256
#define PD_PRPS_NUM 12800 #define PD_PRPS_NUM 12800
#define PD_PRPS_NUM_MAX 98304 #define PD_PRPS_NUM_MAX 98304
#define PD_EVENT_POINT_MAX 983040 #define PD_EVENT_POINT_MAX 768000
#define PD_TREND_PHASE_POINT_CNT 256 #define PD_TREND_PHASE_POINT_CNT 256
#define PD_TREND_POINT_MAX 983040 #define PD_TREND_POINT_MAX 768000
#define PD_TREND_ORIGINAL_NUM 65536 #define PD_TREND_ORIGINAL_NUM 65536
#define PD_PORT_ORIGINAL_NUM 2560000 // 100M采样率, 最大40Hz #define PD_PORT_ORIGINAL_NUM 2560000 // 100M采样率, 最大40Hz

81
app/lib/a_process/pd_dau.c
Unescape Escape View File

@ -22,20 +22,18 @@
/* 用户代码头文件. */ /* 用户代码头文件. */
#include "main.h" #include "main.h"
#include "cmd.h" #include "cmd.h"
#include "fifo.h"
#include "pd_dau.h" #include "pd_dau.h"
#include "pd_hf.h" #include "pd_hf.h"
#include "pd_csg.h" #include "pd_csg.h"
/* Define --------------------------------------------------------------------*/ /* Define --------------------------------------------------------------------*/
#define DUA_UDP_PORT 23760 #define DUA_UDP_PORT 23760
#define DUA_SEND_FIFO_NUM (8)
/* Private typedef -----------------------------------------------------------*/ /* Private typedef -----------------------------------------------------------*/
/* 上传平台回调函数类型 */
typedef void (*UploadCallback)(int slot, const void *data, size_t len);
/* Private variables ---------------------------------------------------------*/ /* Private variables ---------------------------------------------------------*/
pthread_mutex_t board_mutex = PTHREAD_MUTEX_INITIALIZER;
int udp_socket;
dau_t daus[PD_SLOTS_MAX]; dau_t daus[PD_SLOTS_MAX];
/* Private function prototypes -----------------------------------------------*/ /* Private function prototypes -----------------------------------------------*/
@ -58,33 +56,14 @@ void _dau_head_init(dau_t *dau, dau_head_init_t *head_data)
head->pkt_id = head_data->pkt_id; head->pkt_id = head_data->pkt_id;
} }
void _dau_response(int slot, char *buf, int len)
{
printf("_dau_response: slot=%d len=%d\n", slot, len);
if (slot >= 0 && slot < PD_SLOTS_MAX)
{
if (daus[slot].type == DAU_TYPE_UDP)
{
udp_client_data *client = (udp_client_data*)daus[slot].private_data;
sendto(udp_socket, buf, len, 0,
(struct sockaddr*)&client->addr, sizeof(client->addr));
}
else if (daus[slot].type == DAU_TYPE_RS485)
{
rs485_device_data *dev = (rs485_device_data*)daus[slot].private_data;
write(dev->fd, buf, len);
}
}
}
/* dau 插入处理 */ /* dau 插入处理 */
int _dau_insert(dau_t *dau) int _dau_insert(dau_t *dau)
{ {
if (3 == dau->info.type_m && 1 == dau->info.type_s) if (3 == dau->info.type_m && 1 == dau->info.type_s)
{ {
dau->recv_cb = hf_recv_process; dau->recv_cb = hf_recv_process;
dau->send_cb = hf_send_process;
dau->private_data = hf_data_malloc();
} }
else else
{ {
@ -194,6 +173,12 @@ void *_dau_recv_handle(void *arg)
return NULL; return NULL;
} }
/* 等待初始化完成 */
while(!is_system_init)
{
sleep(1);
}
while(1) while(1)
{ {
/* 读取数据. */ /* 读取数据. */
@ -210,6 +195,40 @@ void *_dau_recv_handle(void *arg)
return NULL; return NULL;
} }
/* dau 收包线程 */
void *_dau_send_handle(void *arg)
{
dau_t *dau = (dau_t*)arg;
dau_send_msg_t *recv_msg = NULL;
/* 等待初始化完成 */
while(!is_system_init)
{
sleep(1);
}
while(1)
{
if (fifo_read(dau->fifo_send, (void**)&recv_msg) != 0)
{
DBG(DBG_M_PD_DAU_ERR, "ERROR at fifo %d read!\r\n", dau->fifo_send);
continue;
}
/* 响应其他报文 */
if (dau->send_cb)
{
dau->send_cb(dau->slot, recv_msg->type, recv_msg->data);
}
/* 释放数据内存, 注意一定要在 fifo_push 之前调用, 因为 fifo_push 后 recv_msg 已被释放. */
XFREE(MTYPE_CSG, recv_msg->data);
fifo_push(dau->fifo_send);
}
return NULL;
}
/* dau 预初始化 */ /* dau 预初始化 */
int32_t dau_handle_init(void) int32_t dau_handle_init(void)
{ {
@ -229,16 +248,26 @@ int32_t dau_handle_init(void)
int32_t dau_handle_init_after(void) int32_t dau_handle_init_after(void)
{ {
thread_param_t param = {0}; thread_param_t param = {0};
char fifo_name[THREAD_NAME_LEN];
uint8_t i = 0; uint8_t i = 0;
/* 初始收包线程 */ /* 初始收包线程 */
for (i = 0; i < DAU_ETH_SLOTS_SUM; i++) for (i = 0; i < DAU_ETH_SLOTS_SUM; i++)
{ {
snprintf(fifo_name, THREAD_NAME_LEN, "DAU_SEND_%d", i);
daus[i].fifo_send = fifo_create(fifo_name, DUA_SEND_FIFO_NUM);
param.arg = (void*)(&daus[i]); param.arg = (void*)(&daus[i]);
param.priority = 80; param.priority = 80;
param.log_module = LOG_DAU; param.log_module = LOG_DAU;
snprintf(param.thread_name, THREAD_NAME_LEN, "DAU_RECV_%d", i); snprintf(param.thread_name, THREAD_NAME_LEN, "DAU_RECV_%d", i);
create_thread(_dau_recv_handle, &param); create_thread(_dau_recv_handle, &param);
param.arg = (void*)(&daus[i]);
param.priority = 50;
param.log_module = LOG_DAU;
snprintf(param.thread_name, THREAD_NAME_LEN, "DAU_SEND_%d", i);
create_thread(_dau_send_handle, &param);
} }
return E_NONE; return E_NONE;
@ -255,7 +284,7 @@ void dau_send_data(dau_t *dau, dau_head_init_t *head_data)
rv = sendto(dau->fd, head_data->pkt, head_data->len, 0, (struct sockaddr*)&dau->server, sizeof(dau->server)); rv = sendto(dau->fd, head_data->pkt, head_data->len, 0, (struct sockaddr*)&dau->server, sizeof(dau->server));
if (rv < 0) if (rv < 0)
{ {
DBG(DBG_M_PD_CSG_ERR, "Sendto return %s!\r\n", safe_strerror(errno)); DBG(DBG_M_PD_DAU_ERR, "Sendto return %s!\r\n", safe_strerror(errno));
} }
} }

210
app/lib/a_process/pd_hf.c
Unescape Escape View File

@ -47,6 +47,7 @@
#include "pd_main.h" #include "pd_main.h"
#include "pd_csg.h" #include "pd_csg.h"
#include "pd_dau.h" #include "pd_dau.h"
#include "pd_hf.h"
/* Private define ------------------------------------------------------------*/ /* Private define ------------------------------------------------------------*/
@ -58,12 +59,13 @@
/* Private function prototypes -----------------------------------------------*/ /* Private function prototypes -----------------------------------------------*/
extern void _hf_contact_recv(int slot, char *pkt);
extern void _hf_heartbeat_recv(uint8_t slot, char *pkt, uint16_t len); extern void _hf_heartbeat_recv(uint8_t slot, char *pkt, uint16_t len);
extern void _hf_real_image_recv(int slot, char *pkt); extern void _hf_prps_get_recv(uint8_t slot, char *pkt, uint16_t len);
extern void _hf_trend_recv(int slot, char *pkt); extern void _hf_trend_recv(uint8_t slot, char *pkt, uint16_t len);
extern void _hf_event_recv(uint8_t slot, char *pkt, uint16_t len); extern void _hf_event_recv(uint8_t slot, char *pkt, uint16_t len);
extern void _hf_prps_get_send(uint8_t slot, void *data);
// 命令映射表 // 命令映射表
static dau_recv_fun_cb _hf_command[] = static dau_recv_fun_cb _hf_command[] =
{ {
@ -88,31 +90,43 @@ static dau_recv_fun_cb _hf_prv_command[] =
NULL, // DAU_P_CONFIG_GET 2 NULL, // DAU_P_CONFIG_GET 2
NULL, // DAU_P_CONFIG_PORT_SET 3 NULL, // DAU_P_CONFIG_PORT_SET 3
NULL, // DAU_P_CONFIG_PORT_GET 4 NULL, // DAU_P_CONFIG_PORT_GET 4
NULL, // DAU_P_CONFIG_REAL_WAVE 5 _hf_prps_get_recv, // DAU_P_CONFIG_REAL_WAVE 5
NULL, // 6 NULL, // 6
NULL, // 7 NULL, // 7
NULL, // 8 NULL, // 8
NULL, // 9 NULL, // 9
NULL, // DAU_P_TREND 10 _hf_trend_recv, // DAU_P_TREND 10
NULL, // DAU_P_REAL_PRPS 11 NULL, // DAU_P_REAL_PRPS 11
NULL, // DAU_P_EVENT 12 _hf_event_recv, // DAU_P_EVENT 12
}; };
/* Interface functions -------------------------------------------------------*/ // 命令映射表
void _hf_real_image_recv(int slot, char *pkt) static dau_send_fun_cb _hf_send_command[] =
{ {
csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; NULL, // 0
head->slot = slot; _hf_prps_get_send, // DAU_SEND_PRPS 1
head->sdev_id = head->dev_id; };
_csg_send_data(CSG_PRV_REPLY, CSG_PRV_REAL_PRPS, pkt, head->len - sizeof(csg_pkt_head_t));
}
void _hf_trend_recv(int slot, char *pkt) /* Interface functions -------------------------------------------------------*/
/* PRPS 关注报文发送 */
void _hf_prps_get_send(uint8_t slot, void *data)
{ {
csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; dau_head_init_t head_data;
head->slot = slot; dau_t *dau = &daus[slot];
head->sdev_id = head->dev_id; hf_prps_get_t *param = (hf_prps_get_t*)(dau->buf_send + sizeof(dau_pkt_head_t));
_csg_send_data(CSG_PRV_REPLY, CSG_PRV_TREND, pkt, head->len - sizeof(csg_pkt_head_t));
/* 回复报文 */
head_data.cmd_type = DAU_PRV_REQUEST;
head_data.cmd = DAU_P_CONFIG_REAL_WAVE;
head_data.pkt_id = dau->pkt_id++;
head_data.pkt = dau->buf_send;
head_data.len = sizeof(dau_pkt_head_t) + sizeof(hf_prps_get_t);
memcpy(param, data, sizeof(hf_prps_get_t));
dau_send_data(dau, &head_data);
return;
} }
/* 心跳报文接收 */ /* 心跳报文接收 */
@ -121,10 +135,11 @@ void _hf_heartbeat_recv(uint8_t slot, char *pkt, uint16_t len)
dau_head_init_t head_data; dau_head_init_t head_data;
dau_t *dau = &daus[slot]; dau_t *dau = &daus[slot];
dau_pkt_head_t *head = (dau_pkt_head_t*)pkt; dau_pkt_head_t *head = (dau_pkt_head_t*)pkt;
dau_heartbeat_t *data = (dau_heartbeat_t*)(pkt + sizeof(dau_pkt_head_t)); 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)); uint32_t *timestamp = (uint32_t*)(pkt + sizeof(dau_pkt_head_t));
memcpy(&dau->run_status, data, sizeof(dau_heartbeat_t)); memcpy(&hf_data->run_status, data, sizeof(hf_heartbeat_t));
/* 回复报文 */ /* 回复报文 */
head_data.cmd_type = DAU_REQUEST; head_data.cmd_type = DAU_REQUEST;
@ -138,19 +153,141 @@ void _hf_heartbeat_recv(uint8_t slot, char *pkt, uint16_t len)
return; return;
} }
/* 心跳报文接收 */
void _hf_prps_get_recv(uint8_t slot, char *pkt, uint16_t len)
{
return;
}
/* 趋势报文接收 */
void _hf_trend_recv(uint8_t slot, char *pkt, uint16_t len)
{
dau_head_init_t head_data;
dau_t *dau = &daus[slot];
hf_data_t *hf_data = (hf_data_t*)dau->private_data;
hf_trend_t *trend = &hf_data->trend;
dau_pkt_head_t *head = (dau_pkt_head_t*)pkt;
hf_trend_head_t *head_trend = (hf_trend_head_t*)(pkt + sizeof(dau_pkt_head_t));
char *data = (char*)(pkt + sizeof(dau_pkt_head_t) + sizeof(hf_trend_head_t));
char *point = NULL;
uint8_t port = 0;
hf_trend_ack_t ack;
hf_trend_ack_t *ack_p = (hf_trend_ack_t*)(pkt + sizeof(dau_pkt_head_t));
/* 不处理补包数据 */
if (!head_trend->boosterpack)
{
//printh("#1 %d %d %d %d\r\n", head_trend->vport, head_trend->sum, head_trend->index, head_trend->type);
//printh("#2 %d %d\r\n", head_trend->utc, head_trend->len);
port = head_trend->vport - 1;
if (HF_TREND_TYPE_STAT == head_trend->type)
{
trend->col.index = head_trend->identifier;
trend->col.utc = head_trend->utc;
memcpy(&trend->col.port[port], data, sizeof(hf_trend_stat));
if ((head_trend->index + 1) == head_trend->sum)
{
//printh("vport %d index %d utc %d max %d\r\n", head_trend->vport, trend->col.index, trend->col.utc, trend->col.port[port].max);
//printh("avg %d cnt %d phase %d noise %d\r\n", trend->col.port[port].avg, trend->col.port[port].cnt, trend->col.port[port].phase, trend->col.port[port].noise);
//printh("event_cnt %d\r\n", trend->col.port[port].event_cnt);
}
}
else if (HF_TREND_TYPE_PRPD == head_trend->type)
{
point = (char*)trend->prpd.port[port].data;
point += head_trend->index * HF_DATA_LEN;
memcpy(point, data, head_trend->len);
}
else if (HF_TREND_TYPE_PRPS == head_trend->type)
{
if (0 == head_trend->index)
{
trend->prps.port[port].point_cnt = 0;
}
/* 这里左移 2 位是因为 sizeof(hf_data_point_t) 等于 4 */
trend->prps.port[port].point_cnt += head_trend->len >> 2;
point = (char*)trend->prps.port[port].point;
point += head_trend->index * HF_DATA_LEN;
memcpy(point, data, head_trend->len);
}
}
/* 回复报文 */
head_data.cmd_type = DAU_PRV_REQUEST;
head_data.cmd = DAU_P_TREND;
head_data.pkt_id = head->pkt_id;
head_data.pkt = pkt;
head_data.len = sizeof(dau_pkt_head_t) + sizeof(hf_trend_ack_t);
ack.index = head_trend->index;
ack.result = 0;
ack.boosterpack = head_trend->boosterpack;
memcpy(ack_p, &ack, sizeof(hf_trend_ack_t));
dau_send_data(dau, &head_data);
return;
}
/* 事件报文接收 */ /* 事件报文接收 */
void _hf_event_recv(uint8_t slot, char *pkt, uint16_t len) void _hf_event_recv(uint8_t slot, char *pkt, uint16_t len)
{ {
//dau_head_init_t head_data; dau_head_init_t head_data;
//dau_t *dau = &daus[slot]; dau_t *dau = &daus[slot];
//dau_pkt_head_t *head = (dau_pkt_head_t*)pkt; hf_data_t *hf_data = (hf_data_t*)dau->private_data;
//dau_event_head_t *head_event = (dau_event_head_t*)(pkt + sizeof(dau_pkt_head_t)); hf_event_t *event = &hf_data->event;
dau_pkt_head_t *head = (dau_pkt_head_t*)pkt;
hf_event_head_t *head_event = (hf_event_head_t*)(pkt + sizeof(dau_pkt_head_t));
char *data = (char*)(pkt + sizeof(dau_pkt_head_t) + sizeof(hf_event_head_t));
char *point = NULL;
hf_event_ack_t ack;
hf_event_ack_t *ack_p = (hf_event_ack_t*)(pkt + sizeof(dau_pkt_head_t));
/* 不处理补包数据 */
if (!head_event->boosterpack)
{
//printh("#3 %d %d %d %d\r\n", head_event->vport, head_event->sum, head_event->index, head_event->type);
//printh("#4 %d %d\r\n\n", head_event->utc, head_event->len);
/* 第一个报文 */ /* 第一个报文 */
//if (0 == head_event->index) if (0 == head_event->index)
//{ {
event->head.vport = head_event->vport;
event->head.boosterpack = head_event->boosterpack;
event->head.power_fre = head_event->power_fre;
event->head.type = head_event->type;
event->head.max = head_event->max;
event->head.identifier = head_event->identifier;
event->head.utc = head_event->utc;
event->head.cnt = head_event->cnt;
event->head.avg_o = head_event->avg_o;
event->head.avg = head_event->avg;
event->head.point_cnt = head_event->point_cnt;
}
//} if ((head_event->index + 1) == head_event->sum)
{
//printh("vport %d power_fre %d type %d max %d\r\n", event->head.vport, event->head.power_fre, event->head.type, event->head.max);
//printh("identifier %d utc %d cnt %d avg %d\r\n", event->head.identifier, event->head.utc, event->head.cnt, event->head.avg);
//printh("point_cnt %d\r\n\n", event->head.point_cnt);
}
point = (char*)event->point;
point += head_event->index * HF_DATA_LEN;
memcpy(point, data, head_event->len);
}
/* 回复报文 */
head_data.cmd_type = DAU_PRV_REQUEST;
head_data.cmd = DAU_P_EVENT;
head_data.pkt_id = head->pkt_id;
head_data.pkt = pkt;
head_data.len = sizeof(dau_pkt_head_t) + sizeof(hf_event_ack_t);
ack.index = head_event->index;
ack.result = 0;
ack.boosterpack = head_event->boosterpack;
memcpy(ack_p, &ack, sizeof(hf_event_ack_t));
dau_send_data(dau, &head_data);
return; return;
} }
@ -209,12 +346,29 @@ int32_t hf_recv_process(uint8_t slot, char *pkt, uint16_t len)
{ {
if (_hf_prv_command[head->cmd]) if (_hf_prv_command[head->cmd])
{ {
_hf_command[head->cmd](slot, pkt, len); _hf_prv_command[head->cmd](slot, pkt, len);
}
} }
return E_NONE;
}
/* 高频发包处理函数 */
int32_t hf_send_process(uint8_t slot, uint8_t type, void *data)
{
if (_hf_send_command[type])
{
_hf_send_command[type](slot, data);
} }
return E_NONE; return E_NONE;
} }
/* 高频私有数据 */
void* hf_data_malloc(void)
{
return XMALLOC_Q(MTYPE_HF, sizeof(hf_data_t));
}
#endif #endif
/************************ (C) COPYRIGHT LandPower ***** END OF FILE ****************/ /************************ (C) COPYRIGHT LandPower ***** END OF FILE ****************/

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

@ -93,6 +93,7 @@ static mem_node_t mem_list_process[] =
{ {
{MTYPE_GIS, "GIS"}, {MTYPE_GIS, "GIS"},
{MTYPE_DAU, "DAU"}, {MTYPE_DAU, "DAU"},
{MTYPE_HF, "HF"},
{MTYPE_CSG, "CSG"}, {MTYPE_CSG, "CSG"},
{MTYPE_STORAGE, "STORAGE"}, {MTYPE_STORAGE, "STORAGE"},
{MTYPE_DEBUG, "DEBUG"}, {MTYPE_DEBUG, "DEBUG"},

Write Preview
Loading…
Cancel
Save