You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
329 lines
8.3 KiB
C
329 lines
8.3 KiB
C
/* Includes ------------------------------------------------------------------*/
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#ifdef CFG_DEV_TYPE_LAND_PD
|
|
/* 标准C库头文件. */
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <pthread.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/prctl.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
#include <termios.h>
|
|
#include <fcntl.h>
|
|
|
|
/* 用户代码头文件. */
|
|
#include "main.h"
|
|
#include "cmd.h"
|
|
#include "fifo.h"
|
|
#include "pd_dau.h"
|
|
#include "pd_hf.h"
|
|
#include "pd_csg.h"
|
|
|
|
/* Define --------------------------------------------------------------------*/
|
|
#define DUA_UDP_PORT 23760
|
|
#define DUA_SEND_FIFO_NUM (8)
|
|
|
|
/* Private typedef -----------------------------------------------------------*/
|
|
|
|
/* Private variables ---------------------------------------------------------*/
|
|
dau_t daus[PD_SLOTS_MAX];
|
|
|
|
/* Private function prototypes -----------------------------------------------*/
|
|
|
|
/* Internal functions --------------------------------------------------------*/
|
|
/* 包头填充 */
|
|
void _dau_head_init(dau_t *dau, dau_head_init_t *head_data)
|
|
{
|
|
dau_pkt_head_t *head = (dau_pkt_head_t*)head_data->pkt;
|
|
|
|
/* 封装报文头. */
|
|
head->len = head_data->len;
|
|
head->dev_type_m = dau->info.type_m;
|
|
head->dev_type_s= dau->info.type_s;
|
|
head->dev_id = dau->info.dev_id;
|
|
head->cmd_type = head_data->cmd_type;
|
|
head->cmd = head_data->cmd;
|
|
head->version = 1;
|
|
head->pkt_id = head_data->pkt_id;
|
|
}
|
|
|
|
/* dau 插入处理 */
|
|
int _dau_insert(dau_t *dau)
|
|
{
|
|
if (3 == dau->info.type_m && 1 == dau->info.type_s)
|
|
{
|
|
dau->recv_cb = hf_recv_process;
|
|
dau->send_cb = hf_send_process;
|
|
dau->private_data = hf_data_malloc();
|
|
}
|
|
else
|
|
{
|
|
return E_NOT_FOUND;
|
|
}
|
|
|
|
dau->state.is_connect = TRUE;
|
|
|
|
return E_NONE;
|
|
}
|
|
|
|
/* 初始化UDP服务器 */
|
|
int32_t _dau_udp_server_init(dau_t *dau)
|
|
{
|
|
struct sockaddr_in server = {0};
|
|
int fd = -1;
|
|
|
|
fd = socket(AF_INET, SOCK_DGRAM, 0);
|
|
if (fd < 0)
|
|
{
|
|
log_err(LOG_DAU, "ERROR at socket creating 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(DUA_UDP_PORT + dau->slot);
|
|
if (bind(fd, (struct sockaddr*)&server, sizeof(server)) < 0)
|
|
{
|
|
log_err(LOG_DAU, "ERROR at socket bind return %s!", safe_strerror(errno));
|
|
close(fd);
|
|
return E_SYS_CALL;
|
|
}
|
|
|
|
dau->fd = fd;
|
|
return E_NONE;
|
|
}
|
|
|
|
/* dau 开机联络处理函数 */
|
|
void _dau_recv_connect(dau_t *dau, uint16_t recv_len)
|
|
{
|
|
dau_head_init_t head_data;
|
|
dau_pkt_head_t *head = (dau_pkt_head_t*)dau->buf_recv;
|
|
dau_contact_t *pnet = (dau_contact_t*)(dau->buf_recv + sizeof(dau_pkt_head_t));
|
|
dau_ack_t *ack = (dau_ack_t*)(dau->buf_recv + sizeof(dau_pkt_head_t));
|
|
dau_contact_t *info = NULL;
|
|
|
|
/* 复制设备信息 */
|
|
memcpy(&dau->info, pnet, sizeof(dau_contact_t));
|
|
|
|
/* 添加 dau */
|
|
LD_N_RETURN_N(_dau_insert(dau));
|
|
|
|
/* 回复报文 */
|
|
ack->result = 0;
|
|
head_data.cmd_type = DAU_REQUEST;
|
|
head_data.cmd = DAU_C_CONTACT;
|
|
head_data.pkt_id = head->pkt_id;
|
|
head_data.pkt = dau->buf_recv;
|
|
head_data.len = sizeof(dau_pkt_head_t) + sizeof(dau_ack_t);
|
|
dau_data_send(dau, &head_data);
|
|
|
|
/* 给后台发送添加信息 */
|
|
/* 申请内存 */
|
|
info = XMALLOC(MTYPE_CSG, sizeof(dau_contact_t));
|
|
if (!info)
|
|
{
|
|
DBG(DBG_M_PD_DAU_ERR, "XMALLOC ERROR!\r\n");
|
|
return;
|
|
}
|
|
|
|
/* 复制设备信息 */
|
|
memcpy(info, &dau->info, sizeof(dau_contact_t));
|
|
|
|
/* 发送给后台 */
|
|
if (dau_msg_send_cmd(DAU_SEND_ADD, info) != E_NONE)
|
|
{
|
|
XFREE(MTYPE_CSG, info);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/* dau 数据包处理函数 */
|
|
void _dau_recv_data_process(dau_t *dau, uint16_t recv_len, struct sockaddr_in *server)
|
|
{
|
|
dau_pkt_head_t *head = (dau_pkt_head_t*)dau->buf_recv;
|
|
|
|
if (DAU_REPLY == head->cmd_type && DAU_C_CONTACT == head->cmd)
|
|
{
|
|
/* 响应连接报文 */
|
|
if (head->len > DAU_BUF_SIZE)
|
|
{
|
|
DBG(DBG_M_PD_DAU_ERR, "Recvfrom len %d ERROR!\r\n", head->len);
|
|
return;
|
|
}
|
|
|
|
memcpy(&dau->server, server, sizeof(struct sockaddr_in));
|
|
_dau_recv_connect(dau, recv_len);
|
|
}
|
|
else
|
|
{
|
|
/* 响应其他报文 */
|
|
if (dau->recv_cb)
|
|
{
|
|
dau->recv_cb(dau->slot, dau->buf_recv, recv_len);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/* dau 收包线程 */
|
|
void *_dau_recv_handle(void *arg)
|
|
{
|
|
dau_t *dau = (dau_t*)arg;
|
|
struct sockaddr_in server;
|
|
socklen_t server_len = sizeof(struct sockaddr_in);
|
|
uint16_t data_len = 0;
|
|
|
|
/* 初始化 socket */
|
|
if (_dau_udp_server_init(dau) != E_NONE)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
/* 等待初始化完成 */
|
|
while(!is_system_init)
|
|
{
|
|
sleep(1);
|
|
}
|
|
|
|
while(1)
|
|
{
|
|
/* 读取数据. */
|
|
data_len = recvfrom(dau->fd, dau->buf_recv, DAU_BUF_SIZE, 0, (struct sockaddr*)&server, &server_len);
|
|
if (data_len <= 0)
|
|
{
|
|
DBG(DBG_M_PD_DAU_ERR, "Recvfrom return ERROR %s!\r\n", safe_strerror(errno));
|
|
continue;
|
|
}
|
|
|
|
_dau_recv_data_process(dau, data_len, &server);
|
|
}
|
|
|
|
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 预初始化 */
|
|
int32_t dau_handle_init(void)
|
|
{
|
|
uint8_t i = 0;
|
|
|
|
memset(&daus, 0, sizeof(dau_t) * PD_SLOTS_MAX);
|
|
|
|
for (i = 0; i < PD_SLOTS_MAX; i++)
|
|
{
|
|
daus[i].slot = i;
|
|
}
|
|
|
|
return E_NONE;
|
|
}
|
|
|
|
/* dau 初始化 */
|
|
int32_t dau_handle_init_after(void)
|
|
{
|
|
thread_param_t param = {0};
|
|
char fifo_name[THREAD_NAME_LEN];
|
|
uint8_t i = 0;
|
|
|
|
/* 初始收包线程 */
|
|
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.priority = 80;
|
|
param.log_module = LOG_DAU;
|
|
snprintf(param.thread_name, THREAD_NAME_LEN, "DAU_RECV_%d", i);
|
|
create_thread(_dau_recv_handle, ¶m);
|
|
|
|
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, ¶m);
|
|
}
|
|
|
|
return E_NONE;
|
|
}
|
|
|
|
/* 数据发送 */
|
|
void dau_data_send(dau_t *dau, dau_head_init_t *head_data)
|
|
{
|
|
int32_t rv = 0;
|
|
|
|
/* 封装报文头. */
|
|
_dau_head_init(dau, head_data);
|
|
|
|
rv = sendto(dau->fd, head_data->pkt, head_data->len, 0, (struct sockaddr*)&dau->server, sizeof(dau->server));
|
|
if (rv < 0)
|
|
{
|
|
DBG(DBG_M_PD_DAU_ERR, "Sendto return %s!\r\n", safe_strerror(errno));
|
|
}
|
|
}
|
|
|
|
/* 发送数据到后台通讯进程. */
|
|
int32_t dau_msg_send_cmd(uint32_t type, void *data)
|
|
{
|
|
dau_send_msg_t msg;
|
|
|
|
/* 封装消息. */
|
|
msg.type = type;
|
|
msg.data = data;
|
|
|
|
/* 发送消息 */
|
|
if (fifo_write(csg.fifo_cmd_id, (void*)(&msg), sizeof(dau_send_msg_t)) != sizeof(dau_send_msg_t))
|
|
{
|
|
DBG(DBG_M_PD_DAU_ERR, "DAU write ERROR! type=%d\r\n", type);
|
|
return E_ERROR;
|
|
}
|
|
|
|
return E_NONE;
|
|
}
|
|
|
|
#endif
|