#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

}