263 lines
7.7 KiB
C
263 lines
7.7 KiB
C
#include "tcpserver.h"
|
||
|
||
|
||
struct tcp_pcb *server_pcb_modbus = NULL;
|
||
struct tcp_pcb *server_pcb_hart1 = NULL;
|
||
struct tcp_pcb *server_pcb_hart2 = NULL;
|
||
struct tcp_pcb *server_pcb_hart3 = NULL;
|
||
struct tcp_pcb *server_pcb_hart4 = NULL;
|
||
|
||
uint8_t modbus_rx_data[TCP_DATA_LEN] = {0},hart1_rx_data[TCP_DATA_LEN] = {0},hart2_rx_data[TCP_DATA_LEN] = {0},hart3_rx_data[TCP_DATA_LEN] = {0},hart4_rx_data[TCP_DATA_LEN] = {0}; // 接受数据缓存区
|
||
uint8_t modbus_tx_data[TCP_DATA_LEN] = {0},hart1_tx_data[TCP_DATA_LEN] = {0},hart2_tx_data[TCP_DATA_LEN] = {0},hart3_tx_data[TCP_DATA_LEN] = {0},hart4_tx_data[TCP_DATA_LEN] = {0}; // 发送数据缓存区
|
||
uint16_t modbus_rx_len = 0,hart1_rx_len = 0,hart2_rx_len = 0,hart3_rx_len = 0,hart4_rx_len = 0;
|
||
uint16_t modbus_tx_len = 0,hart1_tx_len = 0,hart2_tx_len = 0,hart3_tx_len = 0,hart4_tx_len = 0;
|
||
|
||
|
||
//接收回调函数
|
||
static err_t tcp_recv_modbus(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
|
||
{
|
||
if (p != NULL)
|
||
{
|
||
/* 更新窗口*/
|
||
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
|
||
server_pcb_modbus = tpcb; // 直接赋值
|
||
memcpy(modbus_rx_data, (int *)p->payload, p->tot_len);//数据复制
|
||
modbus_rx_len = p->tot_len;
|
||
|
||
modbus_process_tcp();
|
||
|
||
pbuf_free(p);
|
||
}
|
||
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
|
||
{
|
||
return tcp_close(tpcb);
|
||
}
|
||
|
||
return ERR_OK;
|
||
}
|
||
|
||
static err_t tcp_recv_hart1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
|
||
{
|
||
if (p != NULL)
|
||
{
|
||
/* 更新窗口*/
|
||
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
|
||
server_pcb_hart1 = tpcb; // 直接赋值
|
||
memcpy(hart1_rx_data, (int *)p->payload, p->tot_len);//数据复制
|
||
hart1_rx_len = p->tot_len;
|
||
|
||
HAL_GPIO_WritePin(HART1_RTS_GPIO_Port,HART1_RTS_Pin,GPIO_PIN_RESET);
|
||
uart_send(&huart2,hart1_rx_data,hart1_rx_len);
|
||
|
||
pbuf_free(p);
|
||
}
|
||
else if (p == NULL) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
|
||
{
|
||
return tcp_close(tpcb);
|
||
}
|
||
else if(err != ERR_OK)
|
||
{
|
||
pbuf_free(p);
|
||
}
|
||
|
||
return ERR_OK;
|
||
}
|
||
|
||
static err_t tcp_recv_hart2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
|
||
{
|
||
if (p != NULL)
|
||
{
|
||
/* 更新窗口*/
|
||
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
|
||
server_pcb_hart2 = tpcb; // 直接赋值
|
||
memcpy(hart2_rx_data, (int *)p->payload, p->tot_len);//数据复制
|
||
hart2_rx_len = p->tot_len;
|
||
|
||
HAL_GPIO_WritePin(HART2_RTS_GPIO_Port,HART2_RTS_Pin,GPIO_PIN_RESET);
|
||
uart_send(&huart4,hart2_rx_data,hart2_rx_len);
|
||
|
||
pbuf_free(p);
|
||
}
|
||
else if (p == NULL) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
|
||
{
|
||
return tcp_close(tpcb);
|
||
}
|
||
else if(err != ERR_OK)
|
||
{
|
||
pbuf_free(p);
|
||
}
|
||
|
||
return ERR_OK;
|
||
}
|
||
|
||
static err_t tcp_recv_hart3(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
|
||
{
|
||
if (p != NULL)
|
||
{
|
||
/* 更新窗口*/
|
||
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
|
||
server_pcb_hart3 = tpcb; // 直接赋值
|
||
memcpy(hart3_rx_data, (int *)p->payload, p->tot_len);//数据复制
|
||
hart3_rx_len = p->tot_len;
|
||
|
||
HAL_GPIO_WritePin(HART3_RTS_GPIO_Port,HART3_RTS_Pin,GPIO_PIN_RESET);
|
||
uart_send(&huart5,hart3_rx_data,hart3_rx_len);
|
||
|
||
pbuf_free(p);
|
||
}
|
||
else if (p == NULL) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
|
||
{
|
||
return tcp_close(tpcb);
|
||
}
|
||
else if(err != ERR_OK)
|
||
{
|
||
pbuf_free(p);
|
||
}
|
||
|
||
return ERR_OK;
|
||
}
|
||
|
||
static err_t tcp_recv_hart4(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
|
||
{
|
||
if (p != NULL)
|
||
{
|
||
/* 更新窗口*/
|
||
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
|
||
server_pcb_hart4 = tpcb; // 直接赋值
|
||
memcpy(hart4_rx_data, (int *)p->payload, p->tot_len);//数据复制
|
||
hart4_rx_len = p->tot_len;
|
||
|
||
HAL_GPIO_WritePin(HART4_RTS_GPIO_Port,HART4_RTS_Pin,GPIO_PIN_RESET);
|
||
uart_send(&huart1,hart4_rx_data,hart4_rx_len);
|
||
|
||
pbuf_free(p);
|
||
}
|
||
else if (p == NULL) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
|
||
{
|
||
return tcp_close(tpcb);
|
||
}
|
||
else if(err != ERR_OK)
|
||
{
|
||
pbuf_free(p);
|
||
}
|
||
|
||
return ERR_OK;
|
||
}
|
||
|
||
static err_t tcp_accept_modbus(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
|
||
{
|
||
// /* 确认监听与连接 */
|
||
// tcp_arg(newpcb, mem_calloc(sizeof(struct name), 1));
|
||
|
||
tcp_recv(newpcb, tcp_recv_modbus); // 当收到数据时，回调用户自己写的tcpecho_recv
|
||
return ERR_OK;
|
||
}
|
||
|
||
static err_t tcpecho_accept_hart1(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
|
||
{
|
||
// /* 确认监听与连接 */
|
||
// tcp_arg(newpcb, mem_calloc(sizeof(struct name), 1));
|
||
|
||
tcp_recv(newpcb, tcp_recv_hart1); // 当收到数据时，回调用户自己写的tcpecho_recv
|
||
return ERR_OK;
|
||
}
|
||
|
||
static err_t tcpecho_accept_hart2(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
|
||
{
|
||
// /* 确认监听与连接 */
|
||
// tcp_arg(newpcb, mem_calloc(sizeof(struct name), 1));
|
||
|
||
tcp_recv(newpcb, tcp_recv_hart2); // 当收到数据时，回调用户自己写的tcpecho_recv
|
||
return ERR_OK;
|
||
}
|
||
|
||
static err_t tcpecho_accept_hart3(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
|
||
{
|
||
// /* 确认监听与连接 */
|
||
// tcp_arg(newpcb, mem_calloc(sizeof(struct name), 1));
|
||
|
||
tcp_recv(newpcb, tcp_recv_hart3); // 当收到数据时，回调用户自己写的tcpecho_recv
|
||
return ERR_OK;
|
||
}
|
||
|
||
static err_t tcpecho_accept_hart4(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
|
||
{
|
||
// /* 确认监听与连接 */
|
||
// tcp_arg(newpcb, mem_calloc(sizeof(struct name), 1));
|
||
|
||
tcp_recv(newpcb, tcp_recv_hart4); // 当收到数据时，回调用户自己写的tcpecho_recv
|
||
return ERR_OK;
|
||
}
|
||
|
||
void tcp_server_init(void)
|
||
{
|
||
struct tcp_pcb *server_modbus = NULL;
|
||
struct tcp_pcb *server_hart1 = NULL;
|
||
struct tcp_pcb *server_hart2 = NULL;
|
||
struct tcp_pcb *server_hart3 = NULL;
|
||
struct tcp_pcb *server_hart4 = NULL;
|
||
|
||
/* 创建一路MODBUS */
|
||
server_modbus = tcp_new();
|
||
|
||
/* 绑定TCP控制块 */
|
||
tcp_bind(server_modbus, IP_ADDR_ANY, TCP_PORT_MODBUS);
|
||
|
||
/* 进入监听状态 */
|
||
server_modbus = tcp_listen(server_modbus);
|
||
|
||
/* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
|
||
tcp_accept(server_modbus, tcp_accept_modbus); // 侦听到连接后，回调用户编写的tcpecho_accept
|
||
|
||
/* 创建一路HART */
|
||
server_hart1 = tcp_new();
|
||
|
||
/* 绑定TCP控制块 */
|
||
tcp_bind(server_hart1, IP_ADDR_ANY, TCP_PORT_HART1);
|
||
|
||
/* 进入监听状态 */
|
||
server_hart1 = tcp_listen(server_hart1);
|
||
|
||
/* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
|
||
tcp_accept(server_hart1, tcpecho_accept_hart1); // 侦听到连接后，回调用户编写的tcpecho_accept
|
||
|
||
/* 创建二路HART */
|
||
server_hart2 = tcp_new();
|
||
|
||
/* 绑定TCP控制块 */
|
||
tcp_bind(server_hart2, IP_ADDR_ANY, TCP_PORT_HART2);
|
||
|
||
/* 进入监听状态 */
|
||
server_hart2 = tcp_listen(server_hart2);
|
||
|
||
/* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
|
||
tcp_accept(server_hart2, tcpecho_accept_hart2); // 侦听到连接后，回调用户编写的tcpecho_accept
|
||
|
||
/* 创建三路HART */
|
||
server_hart3 = tcp_new();
|
||
|
||
/* 绑定TCP控制块 */
|
||
tcp_bind(server_hart3, IP_ADDR_ANY, TCP_PORT_HART3);
|
||
|
||
/* 进入监听状态 */
|
||
server_hart3 = tcp_listen(server_hart3);
|
||
|
||
/* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
|
||
tcp_accept(server_hart3, tcpecho_accept_hart3); // 侦听到连接后，回调用户编写的tcpecho_accept
|
||
|
||
/* 创建四路HART */
|
||
server_hart4 = tcp_new();
|
||
|
||
/* 绑定TCP控制块 */
|
||
tcp_bind(server_hart4, IP_ADDR_ANY, TCP_PORT_HART4);
|
||
|
||
/* 进入监听状态 */
|
||
server_hart4 = tcp_listen(server_hart4);
|
||
|
||
/* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
|
||
tcp_accept(server_hart4, tcpecho_accept_hart4); // 侦听到连接后，回调用户编写的tcpecho_accept
|
||
|
||
}
|
||
|
||
|