|
|
/******************************************************************************
|
|
|
* file lib/process/pd_csg.c
|
|
|
* author YuLiang
|
|
|
* version 1.0.0
|
|
|
* date 27-Feb-2023
|
|
|
* brief This file provides all the csg server operation functions.
|
|
|
*
|
|
|
******************************************************************************
|
|
|
* Attention
|
|
|
*
|
|
|
* <h2><center>© COPYRIGHT(c) 2021 LandPower</center></h2>
|
|
|
*
|
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
|
* are permitted provided that the following conditions are met:
|
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
|
* this list of conditions and the following disclaimer.
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
|
* and/or other materials provided with the distribution.
|
|
|
* 3. Neither the name of LandPower nor the names of its contributors may be used to
|
|
|
* endorse or promote products derived from this software without specific
|
|
|
* prior written permission.
|
|
|
*
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
|
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
*
|
|
|
******************************************************************************/
|
|
|
|
|
|
/* Includes ------------------------------------------------------------------*/
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
#include "config.h"
|
|
|
#endif
|
|
|
|
|
|
#ifdef CFG_DEV_TYPE_LAND_PD
|
|
|
/* 标准C库头文件. */
|
|
|
#include <sys/types.h>
|
|
|
#include <sys/ipc.h>
|
|
|
#include <sys/msg.h>
|
|
|
#include <sys/stat.h>
|
|
|
#include <sys/socket.h>
|
|
|
#include <fcntl.h>
|
|
|
#include <netinet/in.h>
|
|
|
#include <arpa/inet.h>
|
|
|
#include <pthread.h>
|
|
|
|
|
|
/* 用户代码头文件. */
|
|
|
#include "cmd.h"
|
|
|
#include "fifo.h"
|
|
|
#include "pd_main.h"
|
|
|
#include "pd_dau.h"
|
|
|
#include "pd_csg.h"
|
|
|
|
|
|
/* Private define ------------------------------------------------------------*/
|
|
|
#define CSG_LOCK pthread_mutex_lock(&csg.mutex)
|
|
|
#define CSG_UNLOCK pthread_mutex_unlock(&csg.mutex)
|
|
|
|
|
|
/* Private macro -------------------------------------------------------------*/
|
|
|
|
|
|
/* Private typedef -----------------------------------------------------------*/
|
|
|
|
|
|
/* Private variables ---------------------------------------------------------*/
|
|
|
csg_t csg;
|
|
|
|
|
|
/* Private function prototypes -----------------------------------------------*/
|
|
|
extern void _csg_server_set(int32_t ip, uint16_t port);
|
|
|
|
|
|
/* Internal functions --------------------------------------------------------*/
|
|
|
CMD(csg_server_set,
|
|
|
csg_server_set_cmd,
|
|
|
"csg server A.B.C.D <1-65535>",
|
|
|
"Csg\n"
|
|
|
"Server\n"
|
|
|
"IPv4 address\n"
|
|
|
"UDP port\n")
|
|
|
{
|
|
|
return CMD_SUCCESS;
|
|
|
_csg_server_set(inet_addr((char*)argv[0]), strtol((char*)argv[1], NULL, 10));
|
|
|
|
|
|
return CMD_SUCCESS;
|
|
|
}
|
|
|
|
|
|
void _csg_server_set(int32_t ip, uint16_t port)
|
|
|
{
|
|
|
/* 比较配置 */
|
|
|
if (csg.server_ip != ip
|
|
|
|| csg.server_port != port)
|
|
|
{
|
|
|
csg.server_ip = ip;
|
|
|
csg.server_port = port;
|
|
|
|
|
|
/* 发送数据. */
|
|
|
bzero(&csg.server, sizeof(csg.server));
|
|
|
csg.server.sin_family = AF_INET;
|
|
|
csg.server.sin_addr.s_addr = csg.server_ip;
|
|
|
csg.server.sin_port = htons(csg.server_port);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* 配置保存函数. */
|
|
|
int _csg_config_save(vty_t* vty)
|
|
|
{
|
|
|
int16_t i = 0;
|
|
|
struct in_addr addr;
|
|
|
|
|
|
addr.s_addr = csg.server_ip;
|
|
|
vty_out(vty, "csg server %s %d%s", inet_ntoa(addr), csg.server_port, VTY_NEWLINE);
|
|
|
i++;
|
|
|
|
|
|
return i;
|
|
|
}
|
|
|
|
|
|
/* 校验收到包的包头, 长度, 校验码. */
|
|
|
int32_t _csg_pkt_check(char *pkt, int32_t len)
|
|
|
{
|
|
|
csg_pkt_head_t *head = (csg_pkt_head_t*)pkt;
|
|
|
csg_pkt_tail_t *tail = (csg_pkt_tail_t*)(pkt + len - CSG_TAIL_LEN);
|
|
|
uint16_t checksum = 0;
|
|
|
uint16_t i = 0;
|
|
|
|
|
|
if (head->head != 0x55aa)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Pkt head %x error!\r\n", head->head);
|
|
|
return E_ERROR;
|
|
|
}
|
|
|
if( tail->tail != 0x5a5a)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Pkt tail %x error!\r\n", tail->tail);
|
|
|
return E_ERROR;
|
|
|
}
|
|
|
|
|
|
if (head->len != (len - CSG_TOTLE_LEN))
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Pkt len %d(%d) error!\r\n", len - CSG_TOTLE_LEN, head->len);
|
|
|
return E_ERROR;
|
|
|
}
|
|
|
|
|
|
for (i = CSG_HEAD_LEN; i < len - CSG_TAIL_LEN; i++)
|
|
|
{
|
|
|
checksum += (uint8_t)pkt[i];
|
|
|
}
|
|
|
if (checksum != tail->checksum)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Pkt checksum %x(%x) error!\r\n", checksum, tail->checksum);
|
|
|
return E_ERROR;
|
|
|
}
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 包头填充. */
|
|
|
void _csg_head_init(char *buf, uint16_t cmd, uint16_t len)
|
|
|
{
|
|
|
csg_pkt_head_t *head = (csg_pkt_head_t*)buf;
|
|
|
|
|
|
memset(buf, 0, len + CSG_HEAD_LEN);
|
|
|
head->head = 0x55AA;
|
|
|
head->cmd = cmd;
|
|
|
snprintf((char*)head->dev_num, PD_DEV_NUM_LEN, "%s", host.name);
|
|
|
head->len = len;
|
|
|
}
|
|
|
|
|
|
void _csg_cheaksum(char *buf, uint16_t len)
|
|
|
{
|
|
|
char *data = buf + CSG_HEAD_LEN;
|
|
|
csg_pkt_tail_t *tail = (csg_pkt_tail_t*)(data + len);
|
|
|
uint16_t i = 0;
|
|
|
uint16_t checksum = 0;
|
|
|
|
|
|
for(i = 0; i < len; i++)
|
|
|
{
|
|
|
checksum += (uint8_t)data[i];
|
|
|
}
|
|
|
|
|
|
tail->checksum = checksum;
|
|
|
tail->tail = 0x5a5a;
|
|
|
}
|
|
|
|
|
|
/* 主动连接请求. */
|
|
|
int32_t _csg_connect_send(void)
|
|
|
{
|
|
|
char *pkt = csg.buf_reply;
|
|
|
uint16_t *data = (uint16_t*)(pkt + CSG_HEAD_LEN);
|
|
|
int32_t rv = 0;
|
|
|
uint16_t len = 8;
|
|
|
|
|
|
_csg_head_init(pkt, CSG_CONNECT_REQ, len);
|
|
|
|
|
|
*data = sofrware_version_get();
|
|
|
_csg_cheaksum(pkt, len);
|
|
|
|
|
|
rv = sendto(csg.fd, pkt, len + CSG_TOTLE_LEN, 0, (struct sockaddr*)&csg.server, sizeof(csg.server));
|
|
|
if (rv < 0)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Sendto return %s!\r\n", safe_strerror(errno));
|
|
|
return E_SYS_CALL;
|
|
|
}
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 心跳包. */
|
|
|
int32_t _csg_heartbeat_send(void)
|
|
|
{
|
|
|
char *pkt = csg.buf_reply;
|
|
|
csg_pkt_heartbeat_t *data = (csg_pkt_heartbeat_t*)(pkt + CSG_HEAD_LEN);
|
|
|
int32_t rv = 0;
|
|
|
uint16_t len = sizeof(csg_pkt_heartbeat_t);
|
|
|
uint16_t i = 0;
|
|
|
|
|
|
_csg_head_init(pkt, CSG_HEARTBEAT_REQ, len);
|
|
|
|
|
|
data->heartbeat = csg.heartbeat;
|
|
|
data->utc = time(NULL) - CSG_SHIQUCHA;
|
|
|
data->freq = 50;
|
|
|
|
|
|
for(i = 0; i < PD_DAU_SUM; i++)
|
|
|
{
|
|
|
if (dau[i])
|
|
|
{
|
|
|
data->dau_state[i] = dau[i]->is_connect;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
data->dau_state[i] = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
data->out_sync = 0;
|
|
|
data->pt_sync = 0;
|
|
|
data->in_sync = 0;
|
|
|
if (dau[0])
|
|
|
{
|
|
|
if (pd_state.sync)
|
|
|
{
|
|
|
if (PD_SYNC_PT == pd_config.config.sync_mode)
|
|
|
{
|
|
|
data->pt_sync = 1;
|
|
|
}
|
|
|
else if (PD_SYNC_POWER == pd_config.config.sync_mode)
|
|
|
{
|
|
|
data->in_sync = 1;
|
|
|
}
|
|
|
else if (PD_SYNC_OUTSIDE == pd_config.config.sync_mode)
|
|
|
{
|
|
|
data->out_sync = 1;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
for(i = 0; i < PD_PORT_SUM; i++)
|
|
|
{
|
|
|
data->port_link_alarm[i] = 0;
|
|
|
}
|
|
|
|
|
|
_csg_cheaksum(pkt, len);
|
|
|
|
|
|
rv = sendto(csg.fd, pkt, len + CSG_TOTLE_LEN, 0, (struct sockaddr*)&csg.server, sizeof(csg.server));
|
|
|
if (rv < 0)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Sendto return %s!\r\n", safe_strerror(errno));
|
|
|
return E_SYS_CALL;
|
|
|
}
|
|
|
|
|
|
csg.heartbeat++;
|
|
|
if (csg.heartbeat > 3)
|
|
|
{
|
|
|
csg.is_connect = FALSE;
|
|
|
}
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
//反馈设置状态的公共函数 2Byte
|
|
|
int32_t _csg_set_state_send(char *pkt, uint16_t cmd, uint8_t vport, uint16_t state)
|
|
|
{
|
|
|
uint16_t *data = (uint16_t*)(pkt + CSG_HEAD_LEN);
|
|
|
int32_t rv = 0;
|
|
|
uint16_t len = 4;
|
|
|
|
|
|
_csg_head_init(pkt, cmd, len);
|
|
|
|
|
|
*data = state;
|
|
|
data++;
|
|
|
*data = vport;
|
|
|
|
|
|
_csg_cheaksum(pkt, len);
|
|
|
|
|
|
rv = sendto(csg.fd, pkt, len + CSG_TOTLE_LEN, 0, (struct sockaddr*)&csg.server, sizeof(csg.server));
|
|
|
if (rv < 0)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Sendto return %s!\r\n", safe_strerror(errno));
|
|
|
return E_SYS_CALL;
|
|
|
}
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 主动提交实时图谱. */
|
|
|
int32_t _csg_real_image_send(pd_prps_t *data)
|
|
|
{
|
|
|
char *buf = csg.buf_send;
|
|
|
csg_real_image_t *head = (csg_real_image_t*)(buf + CSG_HEAD_LEN);
|
|
|
pd_prps_data_t *data_port = NULL;
|
|
|
int32_t rv = 0;
|
|
|
uint16_t len = sizeof(csg_real_image_t) + 1280;
|
|
|
uint8_t i = 0;
|
|
|
uint8_t unit = 0;
|
|
|
uint8_t port = 0;
|
|
|
|
|
|
_csg_head_init(buf, CSG_REAL_IMAGE_ACK, len);
|
|
|
|
|
|
for(unit = 0; unit < PD_DAU_SUM; unit++)
|
|
|
{
|
|
|
if (!dau[unit])
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
for(port = 0; port < dau[unit]->port_num; port++)
|
|
|
{
|
|
|
if (!pd_config.port_config[unit][port].is_concern
|
|
|
|| !data->data[unit][port].is_valid)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
data_port = &data->data[unit][port];
|
|
|
head->index = csg.pkt_index++;
|
|
|
head->vport = dau_port_to_vport(unit, port);
|
|
|
head->pkt_sum = 10;
|
|
|
head->max = data_port->max;
|
|
|
head->avg = data_port->avg;
|
|
|
head->cnt = data_port->cnt;
|
|
|
head->is_sub = 0;
|
|
|
head->interval = 0;
|
|
|
head->utc = time(NULL) - CSG_SHIQUCHA - CSG_SHIQUCHA;
|
|
|
|
|
|
for (i = 0; i < 10; i++)
|
|
|
{
|
|
|
head->pkt_index = i;
|
|
|
memcpy(buf + CSG_HEAD_LEN + sizeof(csg_real_image_t), data_port->data + 640 * i, 1280);
|
|
|
_csg_cheaksum(buf, len);
|
|
|
|
|
|
rv = sendto(csg.fd, buf, len + CSG_TOTLE_LEN, 0, (struct sockaddr*)&csg.server, sizeof(csg.server));
|
|
|
if (rv < 0)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Sendto return %s!\r\n", safe_strerror(errno));
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 趋势数据发送. */
|
|
|
int32_t _csg_trend_send(pd_trend_t *data)
|
|
|
{
|
|
|
char *buf = csg.buf_send;
|
|
|
csg_trend_head_t *head = (csg_trend_head_t*)(buf + CSG_HEAD_LEN);
|
|
|
csg_trend_t *trend = NULL;
|
|
|
pd_trend_data_t *data_port = NULL;
|
|
|
int32_t rv = 0;
|
|
|
int32_t vport = 0;
|
|
|
uint16_t len = sizeof(csg_trend_head_t);
|
|
|
uint8_t unit = 0;
|
|
|
uint8_t port = 0;
|
|
|
|
|
|
_csg_head_init(buf, CSG_TREND_ACK, len);
|
|
|
|
|
|
head->idx = data->index;
|
|
|
head->is_sub = 0;
|
|
|
head->interval = pd_config.config.trend_period;
|
|
|
head->utc = data->utc - CSG_SHIQUCHA - CSG_SHIQUCHA;
|
|
|
|
|
|
for(unit = 0; unit < PD_DAU_SUM; unit++)
|
|
|
{
|
|
|
if (!dau[unit])
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
for(port = 0; port < dau[unit]->port_num; port++)
|
|
|
{
|
|
|
vport = dau_port_to_vport(unit, port);
|
|
|
if (vport <= 0)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
trend = &head->data[vport - 1];
|
|
|
data_port = &data->data[unit][port];
|
|
|
|
|
|
trend->is_valid = 1;
|
|
|
trend->max = data_port->max;
|
|
|
trend->avg = data_port->avg;
|
|
|
trend->noise = data_port->noise;
|
|
|
trend->cnt = data_port->cnt;
|
|
|
trend->phase = data_port->phase;
|
|
|
trend->event_cnt = data_port->event_cnt;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
_csg_cheaksum(buf, len);
|
|
|
rv = sendto(csg.fd, buf, len + CSG_TOTLE_LEN, 0, (struct sockaddr*)&csg.server, sizeof(csg.server));
|
|
|
if (rv < 0)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Sendto return %s!\r\n", safe_strerror(errno));
|
|
|
return E_ERROR;
|
|
|
}
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
//按通道主动提交事件数据
|
|
|
int32_t _csg_event_send(pd_event_t *data)
|
|
|
{
|
|
|
char *buf = csg.buf_send;
|
|
|
csg_event_head_t *head = (csg_event_head_t*)(buf + CSG_HEAD_LEN);
|
|
|
int32_t rv = 0;
|
|
|
uint16_t len = sizeof(csg_event_head_t) + 1280;
|
|
|
uint8_t i = 0;
|
|
|
|
|
|
_csg_head_init(buf, CSG_EVENT_REQ, len);
|
|
|
|
|
|
head->idx = csg.pkt_index++;
|
|
|
head->vport = data->vport;
|
|
|
head->pkt_sum = 10;
|
|
|
head->type = data->type;
|
|
|
head->max = data->max;
|
|
|
head->level = data->level;
|
|
|
head->pd_Type = data->type;
|
|
|
for(i = 0;i < 8; i++)
|
|
|
{
|
|
|
head->type_per[i] = data->type_per[i];
|
|
|
}
|
|
|
head->PositionDistance = data->PositionDistance;
|
|
|
head->utc = data->utc - CSG_SHIQUCHA - CSG_SHIQUCHA;
|
|
|
head->event_idx = data->index;
|
|
|
head->cnt = data->cnt;
|
|
|
|
|
|
for (i = 0; i < 10; i++)
|
|
|
{
|
|
|
head->pkt_idx = i;
|
|
|
memcpy(buf + CSG_HEAD_LEN + sizeof(csg_event_head_t), data->data + 640 * i, 1280);
|
|
|
_csg_cheaksum(buf, len);
|
|
|
|
|
|
rv = sendto(csg.fd, buf, len + CSG_TOTLE_LEN, 0, (struct sockaddr*)&csg.server, sizeof(csg.server));
|
|
|
if (rv < 0)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Sendto return %s!\r\n", safe_strerror(errno));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
void _csg_connect_recv(void)
|
|
|
{
|
|
|
csg.is_connect = TRUE;
|
|
|
csg.heartbeat = 0;
|
|
|
}
|
|
|
|
|
|
/* 解析心跳报文. */
|
|
|
void _csg_heartbeat_recv(char *pkt)
|
|
|
{
|
|
|
csg.heartbeat = 0;
|
|
|
uint32_t server_time = *(uint32_t*)(pkt + CSG_HEAD_LEN);
|
|
|
|
|
|
server_time += CSG_SHIQUCHA;
|
|
|
if (abs(server_time - time(NULL)) > 10)
|
|
|
{
|
|
|
time_set(server_time + 28800); //北京时间
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* 主动连接请求. */
|
|
|
int32_t _csg_acitve_connect_recv(char *pkt)
|
|
|
{
|
|
|
uint16_t *data = (uint16_t*)(pkt + CSG_HEAD_LEN);
|
|
|
int32_t rv = 0;
|
|
|
uint16_t len = 8;
|
|
|
|
|
|
_csg_head_init(pkt, CSG_CONNECT_REQ, len);
|
|
|
|
|
|
*data = sofrware_version_get();
|
|
|
_csg_cheaksum(pkt, len);
|
|
|
|
|
|
rv = sendto(csg.fd, pkt, len + CSG_TOTLE_LEN, 0, (struct sockaddr*)&csg.server, sizeof(csg.server));
|
|
|
if (rv < 0)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Sendto return %s!\r\n", safe_strerror(errno));
|
|
|
return E_SYS_CALL;
|
|
|
}
|
|
|
|
|
|
csg.is_connect = TRUE;
|
|
|
csg.heartbeat = 0;
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 设备重启报文. */
|
|
|
void _csg_reboot_recv(char *pkt)
|
|
|
{
|
|
|
reboot_system(DBG_M_PD_CSG, BOOT_REMOTE_RESET);
|
|
|
}
|
|
|
|
|
|
/* 厂家参数设置报文处理.
|
|
|
说明：修改本地ip 设备ID 服务器地址时需要重启。
|
|
|
*/
|
|
|
int32_t _csg_factory_set_recv(char *pkt)
|
|
|
{
|
|
|
struct sockaddr_in server;
|
|
|
pd_factory_old_t *factory = &pd_config.factory;
|
|
|
uint8_t unit = 0;
|
|
|
uint8_t port = 0;
|
|
|
int32_t vport = 0;
|
|
|
int need_save = 0;
|
|
|
int change_ip = 0;
|
|
|
BOOT_MSG boottype = BOOT_NONE;
|
|
|
|
|
|
memcpy(factory, pkt + CSG_HEAD_LEN, sizeof(pd_factory_old_t) - 24);
|
|
|
|
|
|
if (strncmp((char *)(factory->dev_num), host.name, sizeof(host.name)))
|
|
|
{
|
|
|
snprintf((char*)host.name, PD_DEV_NUM_LEN, "%s", factory->dev_num);
|
|
|
need_save++;
|
|
|
boottype = BOOT_REMOTE_HOST_NAME_CHANGE;
|
|
|
}
|
|
|
|
|
|
if (0 == strncmp((char*)factory->dev_type, "GOM5010", 7))
|
|
|
{
|
|
|
device_info.id_major = 5010;
|
|
|
}
|
|
|
device_info.factory_date = factory->factory_date;
|
|
|
device_info.deployment_date = factory->deployment_date;
|
|
|
server.sin_addr.s_addr = factory->ipv4;
|
|
|
if (strncmp(device_info.host_ip, inet_ntoa(server.sin_addr), sizeof(device_info.host_ip)))
|
|
|
{
|
|
|
snprintf((char*)device_info.host_ip, INET_ADDRSTRLEN, "%s", inet_ntoa(server.sin_addr));
|
|
|
need_save++;
|
|
|
change_ip++;
|
|
|
boottype = BOOT_REMOTE_IP_CHANGE;
|
|
|
}
|
|
|
|
|
|
memcpy(device_info.mac, factory->mac, MAC_ADDR_LEN);
|
|
|
|
|
|
if (csg.server_ip != factory->server_ipv4)
|
|
|
{
|
|
|
csg.server_ip = factory->server_ipv4;
|
|
|
need_save++;
|
|
|
boottype = BOOT_REMOTE_SERVER_IP_CHANGE;
|
|
|
}
|
|
|
|
|
|
if (csg.server_port != factory->server_port)
|
|
|
{
|
|
|
csg.server_port = factory->server_port;
|
|
|
need_save++;
|
|
|
boottype = BOOT_REMOTE_SERVER_PORT_CHANGE;
|
|
|
}
|
|
|
|
|
|
for(unit = 0; unit < PD_DAU_SUM; unit++)
|
|
|
{
|
|
|
if (!dau[unit])
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
for(port = 0; port < dau[unit]->port_num; port++)
|
|
|
{
|
|
|
vport = dau_port_to_vport(unit, port);
|
|
|
if (vport <= 0)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
dau_port_type_set(unit, port, factory->port_type[vport - 1]);
|
|
|
|
|
|
dau_reg_port_write(unit, port);
|
|
|
|
|
|
need_save++; // save file
|
|
|
}
|
|
|
}
|
|
|
|
|
|
_csg_set_state_send(pkt, CSG_FACTORY_SET_ACK, 0, 1);
|
|
|
|
|
|
if (need_save)
|
|
|
{
|
|
|
vtysh_config_save();
|
|
|
if (change_ip)
|
|
|
{
|
|
|
uint8_t mac[MAC_ADDR_LEN] = {0};
|
|
|
mac_generate_from_ip(device_info.host_ip, mac);
|
|
|
memcpy(device_info.mac, mac, MAC_ADDR_LEN);
|
|
|
vtysh_device_save();
|
|
|
vtysh_eth0_save();
|
|
|
}
|
|
|
}
|
|
|
if (boottype)
|
|
|
{
|
|
|
reboot_system(DBG_M_PD_CSG, boottype);
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
/* 厂家参数查询报文处理. */
|
|
|
int32_t _csg_factory_get_recv(char *pkt)
|
|
|
{
|
|
|
pd_factory_old_t *factory = &pd_config.factory;
|
|
|
uint16_t len = sizeof(pd_factory_old_t);
|
|
|
uint8_t unit = 0;
|
|
|
uint8_t port = 0;
|
|
|
int32_t vport = 0;
|
|
|
int32_t rv = 0;
|
|
|
|
|
|
_csg_head_init(pkt, CSG_FACTORY_GET_ACK, len);
|
|
|
|
|
|
snprintf((char*)factory->dev_num, PD_DEV_NUM_LEN, "%s", host.name);
|
|
|
snprintf((char*)factory->dev_type, PD_DEV_TYPE_LEN, "GOM%d", device_info.id_major);
|
|
|
factory->factory_date = device_info.factory_date;
|
|
|
factory->deployment_date = device_info.deployment_date;
|
|
|
factory->ipv4 = inet_addr((char*)device_info.host_ip);
|
|
|
memcpy(factory->mac, device_info.mac, MAC_ADDR_LEN);
|
|
|
factory->server_ipv4 = csg.server_ip;
|
|
|
factory->server_port = csg.server_port;
|
|
|
for(unit = 0; unit < PD_DAU_SUM; unit++)
|
|
|
{
|
|
|
if (!dau[unit])
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
for(port = 0; port < dau[unit]->port_num; port++)
|
|
|
{
|
|
|
vport = dau_port_to_vport(unit, port);
|
|
|
if (vport <= 0)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
factory->port_type[vport - 1] = (dau[unit]->port_reg[port].CR & DAU_CR_PT_Msk) >> DAU_CR_PT_Pos;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
memcpy(pkt + CSG_HEAD_LEN, factory, len);
|
|
|
|
|
|
_csg_cheaksum(pkt, len);
|
|
|
|
|
|
rv = sendto(csg.fd, pkt, len + CSG_TOTLE_LEN, 0, (struct sockaddr*)&csg.server, sizeof(csg.server));
|
|
|
if (rv < 0)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Sendto return %s!\r\n", safe_strerror(errno));
|
|
|
return E_SYS_CALL;
|
|
|
}
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 配置用户参数报文报文处理. */
|
|
|
int32_t _csg_config_set_recv(char *pkt)
|
|
|
{
|
|
|
int need_save = 0;
|
|
|
int cpld_save = 0;
|
|
|
pd_config_old_t *pnet = (pd_config_old_t *)(pkt + CSG_HEAD_LEN);
|
|
|
|
|
|
if ((pd_config.config.sync_mode != pnet->sync_mode)
|
|
|
|| (pd_config.config.real_period != pnet->real_period)
|
|
|
|| (pd_config.config.trend_period != pnet->trend_period)
|
|
|
|| (pd_config.config.heartbeat_period != pnet->heartbeat_period))
|
|
|
{
|
|
|
need_save++;
|
|
|
}
|
|
|
if (pd_config.config.sync_mode != pnet->sync_mode)
|
|
|
{
|
|
|
cpld_save++;
|
|
|
}
|
|
|
|
|
|
memcpy(&pd_config.config, pkt + CSG_HEAD_LEN, sizeof(pd_config_old_t));
|
|
|
|
|
|
if (need_save)
|
|
|
{
|
|
|
vtysh_config_save();
|
|
|
}
|
|
|
|
|
|
if (cpld_save)
|
|
|
{
|
|
|
pd_sync_mode_set();
|
|
|
}
|
|
|
|
|
|
return _csg_set_state_send(pkt, CSG_CONFIG_SET_ACK, 0, 1);
|
|
|
}
|
|
|
|
|
|
/* 查询用户参数查询报文处理. */
|
|
|
int32_t _csg_config_get_recv(char *pkt)
|
|
|
{
|
|
|
uint16_t len = sizeof(pd_config_old_t);
|
|
|
int32_t rv = 0;
|
|
|
|
|
|
_csg_head_init(pkt, CSG_CONFIG_GET_ACK, len);
|
|
|
|
|
|
memcpy(pkt + CSG_HEAD_LEN, &pd_config.config, len);
|
|
|
|
|
|
_csg_cheaksum(pkt, len);
|
|
|
|
|
|
rv = sendto(csg.fd, pkt, len + CSG_TOTLE_LEN, 0, (struct sockaddr*)&csg.server, sizeof(csg.server));
|
|
|
if (rv < 0)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Sendto return %s!\r\n", safe_strerror(errno));
|
|
|
return E_SYS_CALL;
|
|
|
}
|
|
|
|
|
|
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;
|
|
|
|
|
|
if (dau_vport_to_port(vport, &unit, &port) != E_NONE)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Pkt port %d error!\r\n", vport);
|
|
|
return _csg_set_state_send(pkt, CSG_PORT_CONFIG_SET_ACK, vport, 0);
|
|
|
}
|
|
|
|
|
|
memcpy(&pd_config.port_config[unit][port].config, pkt + CSG_HEAD_LEN, sizeof(pd_port_config_old_t));
|
|
|
pd_config.port_config[unit][port].filter_cfg = pd_config.port_config[unit][port].config.filter;
|
|
|
dau_port_config_set(unit, port);
|
|
|
dau_reg_port_write(unit, port);
|
|
|
|
|
|
vtysh_config_save();
|
|
|
|
|
|
return _csg_set_state_send(pkt, CSG_PORT_CONFIG_SET_ACK, vport, 1);
|
|
|
}
|
|
|
|
|
|
/* 按通道提交端口参数查询结果. */
|
|
|
int32_t _csg_port_config_get_recv(char *pkt)
|
|
|
{
|
|
|
uint8_t vport = *(uint8_t*)(pkt + CSG_HEAD_LEN);
|
|
|
uint16_t len = sizeof(pd_port_config_old_t);
|
|
|
uint8_t unit = 0;
|
|
|
uint8_t port = 0;
|
|
|
int32_t rv = 0;
|
|
|
|
|
|
if (dau_vport_to_port(vport, &unit, &port) != E_NONE)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Pkt port %d error!\r\n", vport);
|
|
|
return E_ERROR;
|
|
|
}
|
|
|
|
|
|
_csg_head_init(pkt, CSG_PORT_CONFIG_GET_ACK, len);
|
|
|
|
|
|
memcpy(pkt + CSG_HEAD_LEN, &pd_config.port_config[unit][port].config, len);
|
|
|
|
|
|
_csg_cheaksum(pkt, len);
|
|
|
|
|
|
rv = sendto(csg.fd, pkt, len + CSG_TOTLE_LEN, 0, (struct sockaddr*)&csg.server, sizeof(csg.server));
|
|
|
if (rv < 0)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Sendto return %s!\r\n", safe_strerror(errno));
|
|
|
return E_SYS_CALL;
|
|
|
}
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 召唤趋势数据. */
|
|
|
int32_t _csg_trend_get_recv(char *pkt)
|
|
|
{
|
|
|
#if 0
|
|
|
uint32_t time_start = *(uint32_t*)pkt;
|
|
|
uint32_t time_end = *(uint32_t*)(pkt+4);
|
|
|
struct tm *lt = localtime(&time_start);
|
|
|
|
|
|
char basePath[256] = {0};
|
|
|
sprintf(basePath,"%s/%s/%d/%02d/",fixedHead,"Trend",lt->tm_year+1900,lt->tm_mon+1);
|
|
|
|
|
|
img_num=0;
|
|
|
if(!readFileList(basePath))LOG_ERR_RETURN
|
|
|
|
|
|
int i = 0,fLen = 0;
|
|
|
for(i = 0;i < img_num;i ++)
|
|
|
{
|
|
|
int fileUtc = getUctByFileName(img_path[i]);
|
|
|
if(fileUtc >= startTime && fileUtc <= stopTime)
|
|
|
{
|
|
|
U8 *pFile = NULL;
|
|
|
fLen = ReadHexFile(img_path[i],&pFile);
|
|
|
if(fLen < sizeof(strTrendData))continue;
|
|
|
csgAutoPostHufTrend((strTrendData *)pFile,true);
|
|
|
}
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 解析HUF实时图谱召唤报文. */
|
|
|
void _csg_real_image_recv(char *pkt)
|
|
|
{
|
|
|
csg_real_image_get_t *data = (csg_real_image_get_t*)(pkt + CSG_HEAD_LEN);
|
|
|
uint8_t unit = 0;
|
|
|
uint8_t port = 0;
|
|
|
|
|
|
if (dau_vport_to_port(data->vport, &unit, &port) != E_NONE)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Pkt port %d error!\r\n", data->vport);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
pd_config.port_config[unit][port].r_noise_reduction = data->r_noise_reduction;
|
|
|
pd_config.port_config[unit][port].auto_noise_reduction = data->auto_noise_reduction;
|
|
|
pd_config.port_config[unit][port].manual_noise_reduction = data->manual_noise_reduction * 10;
|
|
|
pd_config.port_config[unit][port].is_concern = data->is_concern;
|
|
|
|
|
|
if (data->is_concern)
|
|
|
{
|
|
|
BITMAP_SET(pd_config.concern_bitmap, data->vport - 1);
|
|
|
if ((data->filter > 0 && data->filter < 5)
|
|
|
&& data->filter != pd_config.port_config[unit][port].filter_cfg)
|
|
|
{
|
|
|
pd_config.port_config[unit][port].filter_cfg = data->filter;
|
|
|
dau_port_config_set(unit, port);
|
|
|
dau_reg_port_write(unit, port);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
BITMAP_RESET(pd_config.concern_bitmap, data->vport - 1);
|
|
|
if (pd_config.port_config[unit][port].filter_cfg != pd_config.port_config[unit][port].config.filter)
|
|
|
{
|
|
|
pd_config.port_config[unit][port].filter_cfg = pd_config.port_config[unit][port].config.filter;
|
|
|
dau_port_config_set(unit, port);
|
|
|
dau_reg_port_write(unit, port);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* DAU 报文发送处理. */
|
|
|
int32_t _csg_recv_process(char *pkt, uint32_t len)
|
|
|
{
|
|
|
csg_pkt_head_t *head = (csg_pkt_head_t*)pkt;
|
|
|
|
|
|
/* 报文头和 CRC 校验. */
|
|
|
LD_E_RETURN(DBG_M_PD_CSG_ERR, _csg_pkt_check(pkt, len));
|
|
|
|
|
|
/* 共有命令处理. */
|
|
|
switch (head->cmd)
|
|
|
{
|
|
|
case CSG_CONNECT_ACK:
|
|
|
_csg_connect_recv();
|
|
|
break;
|
|
|
case CSG_HEARTBEAT_ACK:
|
|
|
_csg_heartbeat_recv(pkt);
|
|
|
break;
|
|
|
case CSG_ACITVE_CONNECT_REQ:
|
|
|
_csg_acitve_connect_recv(pkt);
|
|
|
break;
|
|
|
case CSG_REBOOT_REQ:
|
|
|
_csg_reboot_recv(pkt);
|
|
|
break;
|
|
|
case CSG_FACTORY_SET_REQ:
|
|
|
_csg_factory_set_recv(pkt);
|
|
|
break;
|
|
|
case CSG_FACTORY_GET_REQ:
|
|
|
_csg_factory_get_recv(pkt);
|
|
|
break;
|
|
|
case CSG_CONFIG_SET_REQ:
|
|
|
_csg_config_set_recv(pkt);
|
|
|
break;
|
|
|
case CSG_CONFIG_GET_REQ:
|
|
|
_csg_config_get_recv(pkt);
|
|
|
break;
|
|
|
case CSG_PORT_CONFIG_SET_REQ:
|
|
|
_csg_port_config_set_recv(pkt);
|
|
|
break;
|
|
|
case CSG_PORT_CONFIG_GET_REQ:
|
|
|
_csg_port_config_get_recv(pkt);
|
|
|
break;
|
|
|
case CSG_TREND_REQ:
|
|
|
_csg_trend_get_recv(pkt);
|
|
|
break;
|
|
|
case CSG_REAL_IMAGE_REQ:
|
|
|
_csg_real_image_recv(pkt);
|
|
|
break;
|
|
|
default:
|
|
|
//DBG(DBG_M_PD_CSG_ERR, "Cmd %d error!\r\n", head->cmd);
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
csg.communication_time = time(NULL);
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 心跳和连接处理函数. */
|
|
|
void *_csg_recv_handle(void *arg)
|
|
|
{
|
|
|
struct sockaddr_in server;
|
|
|
socklen_t server_len;
|
|
|
int32_t addr = 0;
|
|
|
uint16_t data_len = 0;
|
|
|
|
|
|
while (!is_system_init)
|
|
|
{
|
|
|
sleep(1);
|
|
|
}
|
|
|
|
|
|
while(1)
|
|
|
{
|
|
|
/* 读取数据. */
|
|
|
data_len = recvfrom(csg.fd, csg.buf_recv, CSG_PKT_LEN, 0, (struct sockaddr*)&server, &server_len);
|
|
|
if (data_len <= 0)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "Recvfrom return ERROR %s!\r\n", safe_strerror(errno));
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
addr = server.sin_addr.s_addr;
|
|
|
if (addr != csg.server_ip)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
_csg_recv_process(csg.buf_recv, data_len);
|
|
|
}
|
|
|
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
/* 向后台服务器发送报文处理函数. */
|
|
|
void *_csg_send_handle(void *arg)
|
|
|
{
|
|
|
pd_csg_msg_t *recv_msg = NULL;
|
|
|
|
|
|
while(1)
|
|
|
{
|
|
|
if (fifo_read(csg.data_fifo_id, (void**)&recv_msg) != 0)
|
|
|
{
|
|
|
DBG(DBG_M_PD_CSG_ERR, "ERROR at fifo %d read!\r\n", csg.data_fifo_id);
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
if (csg.is_connect)
|
|
|
{
|
|
|
/* 数据处理. */
|
|
|
switch(recv_msg->type)
|
|
|
{
|
|
|
case PD_SEND_TYPE_PRPS:
|
|
|
_csg_real_image_send((pd_prps_t*)recv_msg->data);
|
|
|
break;
|
|
|
case PD_SEND_TYPE_TREND:
|
|
|
_csg_trend_send((pd_trend_t*)recv_msg->data);
|
|
|
break;
|
|
|
case PD_SEND_TYPE_EVENT:
|
|
|
_csg_event_send((pd_event_t*)recv_msg->data);
|
|
|
break;
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* 释放数据内存, 注意一定要在 fifo_push 之前调用, 因为 fifo_push 后 recv_msg 已被释放. */
|
|
|
XFREE(MTYPE_CSG, recv_msg->data);
|
|
|
fifo_push(csg.data_fifo_id);
|
|
|
|
|
|
csg.communication_time = time(NULL);
|
|
|
}
|
|
|
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
/* 心跳和连接处理函数. */
|
|
|
void *_csg_heartbeat_handle(void *arg)
|
|
|
{
|
|
|
time_t now = 0;
|
|
|
time_t t_connect = 0;
|
|
|
time_t t_heartbeat = 0;
|
|
|
|
|
|
while (!is_system_init)
|
|
|
{
|
|
|
sleep(1);
|
|
|
}
|
|
|
|
|
|
while(1)
|
|
|
{
|
|
|
sleep(1);
|
|
|
now = time(NULL);
|
|
|
|
|
|
/* 发送连接报文. */
|
|
|
if (!csg.is_connect)
|
|
|
{
|
|
|
if (now - t_connect >= 10)
|
|
|
{
|
|
|
_csg_connect_send();
|
|
|
t_connect = now;
|
|
|
}
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
/* 发送心跳包. */
|
|
|
if ((now - t_heartbeat) / 60 >= pd_config.config.heartbeat_period)
|
|
|
{
|
|
|
_csg_heartbeat_send();
|
|
|
t_heartbeat = now;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
/* 后台通讯公共部分初始化. */
|
|
|
int32_t _csg_handle_init_common(void)
|
|
|
{
|
|
|
struct sockaddr_in server;
|
|
|
struct sched_param param;
|
|
|
pthread_attr_t attr;
|
|
|
pthread_t pid;
|
|
|
int32_t rv = 0;
|
|
|
int fd = 0;
|
|
|
|
|
|
/* 创建协议 socket. */
|
|
|
if (0 == csg.fd)
|
|
|
{
|
|
|
/* 创建socket */
|
|
|
fd = socket(AF_INET, SOCK_DGRAM, 0);
|
|
|
if (fd < 0)
|
|
|
{
|
|
|
log_err(LOG_CSG, "ERROR at socket create return %s!", safe_strerror(errno));
|
|
|
return E_SYS_CALL;
|
|
|
}
|
|
|
|
|
|
/* 绑定端口 */
|
|
|
bzero(&server, sizeof(server));
|
|
|
server.sin_family = AF_INET;
|
|
|
server.sin_addr.s_addr = htonl(INADDR_ANY);
|
|
|
server.sin_port = htons(7777);
|
|
|
if(bind(fd, (struct sockaddr*)&server, sizeof(server)) < 0)
|
|
|
{
|
|
|
log_err(LOG_CSG, "ERROR at socket bind return %s!", safe_strerror(errno));
|
|
|
close(fd);
|
|
|
return E_SYS_CALL;
|
|
|
}
|
|
|
|
|
|
/* 发送数据. */
|
|
|
csg.server_ip = inet_addr("192.168.1.30");
|
|
|
csg.server_port = 10000;
|
|
|
bzero(&csg.server, sizeof(csg.server));
|
|
|
csg.server.sin_family = AF_INET;
|
|
|
csg.server.sin_addr.s_addr = csg.server_ip;
|
|
|
csg.server.sin_port = htons(csg.server_port);
|
|
|
|
|
|
/* 保存数据. */
|
|
|
csg.fd = fd;
|
|
|
}
|
|
|
|
|
|
csg.data_fifo_id = fifo_create(CSG_DATA_FIFO, 128);
|
|
|
if (csg.data_fifo_id < 0)
|
|
|
{
|
|
|
log_err(LOG_CSG, "Open fifo " CSG_DATA_FIFO " error!");
|
|
|
return E_ERROR;
|
|
|
}
|
|
|
|
|
|
pthread_mutex_init(&csg.mutex, NULL);
|
|
|
|
|
|
/* 配置线程RR调度, 优先级70 */
|
|
|
pthread_attr_init(&attr);
|
|
|
param.sched_priority = 70;
|
|
|
pthread_attr_setschedpolicy(&attr, SCHED_RR);
|
|
|
pthread_attr_setschedparam(&attr, ¶m);
|
|
|
pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
|
|
|
rv = pthread_create(&pid, &attr, _csg_send_handle, NULL);
|
|
|
if (rv != 0)
|
|
|
{
|
|
|
log_err(LOG_CSG, "PD can't create pthread %d!", rv);
|
|
|
return E_SYS_CALL;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
thread_m_add("CSG_SEND", pid);
|
|
|
}
|
|
|
pthread_attr_destroy(&attr);
|
|
|
|
|
|
/* 配置线程RR调度, 优先级70 */
|
|
|
pthread_attr_init(&attr);
|
|
|
param.sched_priority = 70;
|
|
|
pthread_attr_setschedpolicy(&attr, SCHED_RR);
|
|
|
pthread_attr_setschedparam(&attr, ¶m);
|
|
|
pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
|
|
|
rv = pthread_create(&pid, &attr, _csg_heartbeat_handle, NULL);
|
|
|
if (rv != 0)
|
|
|
{
|
|
|
log_err(LOG_CSG, "PD can't create heartbeat pthread %d!", rv);
|
|
|
return E_SYS_CALL;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
thread_m_add("CSG_HEARTBEAT", pid);
|
|
|
}
|
|
|
pthread_attr_destroy(&attr);
|
|
|
|
|
|
/* 配置线程RR调度, 优先级70 */
|
|
|
pthread_attr_init(&attr);
|
|
|
param.sched_priority = 70;
|
|
|
pthread_attr_setschedpolicy(&attr, SCHED_RR);
|
|
|
pthread_attr_setschedparam(&attr, ¶m);
|
|
|
pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
|
|
|
rv = pthread_create(&pid, &attr, _csg_recv_handle, NULL);
|
|
|
if (rv != 0)
|
|
|
{
|
|
|
log_err(LOG_CSG, "PD can't create recv pthread %d!", rv);
|
|
|
return E_SYS_CALL;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
thread_m_add("CSG_RCVE", pid);
|
|
|
}
|
|
|
pthread_attr_destroy(&attr);
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* Interface functions -------------------------------------------------------*/
|
|
|
/* 后台通讯模块初始化. */
|
|
|
int32_t csg_handle_init(void)
|
|
|
{
|
|
|
int32_t rv = 0;
|
|
|
|
|
|
#if 0
|
|
|
/* 初始化模块. */
|
|
|
LD_E_RETURN(DBG_M_PD_CSG_ERR, _csg_handle_init_common());
|
|
|
#endif
|
|
|
|
|
|
cmd_install_element(CONFIG_NODE, &csg_server_set_cmd);
|
|
|
|
|
|
#if 0
|
|
|
/* 注册配置保存函数 */
|
|
|
rv = cmd_config_node_config_register(CONFIG_PRI_CSG, _csg_config_save);
|
|
|
if (rv != E_NONE)
|
|
|
{
|
|
|
log_err(LOG_CSG, "Command save register ERROR %d!", rv);
|
|
|
return rv;
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
#endif
|
|
|
/************************ (C) COPYRIGHT LandPower ***** END OF FILE ****************/
|