#include "tcpserver.h"


struct tcp_pcb *server_pcb_modbus = NULL;
struct tcp_pcb *server_pcb_hart = NULL;
uint8_t tcp_rx_data[1024] = {0}; // 接受数据缓存区
uint8_t tcp_tx_data[1024] = {0}; // 发送数据缓存区
uint8_t rx_data_len = 0;
uint8_t tx_data_len = 0;
uint8_t tcp_flag_modbus = 0;
uint8_t tcp_flag_hart = 0;

//接收回调函数
static err_t tcp_recv_modbus(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{
    if (p != NULL)
    {
		tcp_flag_modbus = 1;
        /* 更新窗口*/
        tcp_recved(tpcb, p->tot_len); // 读取数据的控制块   得到所有数据的长度
        server_pcb_modbus = tpcb;    // 直接赋值
        memcpy(tcp_rx_data, (int *)p->payload, p->tot_len);//数据复制
        rx_data_len = p->tot_len;
		
        modbus_process_tcp();
		
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
		tcp_flag_modbus = 0;
        return tcp_close(tpcb);
    }

    return ERR_OK;
}

static err_t tcp_recv_hart(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{
    if (p != NULL)
    {
		tcp_flag_hart = 1;
        /* 更新窗口*/
        tcp_recved(tpcb, p->tot_len); // 读取数据的控制块   得到所有数据的长度
        server_pcb_hart = tpcb;    // 直接赋值
        memcpy(tcp_rx_data, (int *)p->payload, p->tot_len);//数据复制
        rx_data_len = p->tot_len;
		
		hart_flag = 2;
		
        pbuf_free(p);
    }
    else if (p == NULL) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
		tcp_flag_hart = 0;
        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_hart(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_hart);  // 当收到数据时，回调用户自己写的tcpecho_recv
    return ERR_OK;
}

void tcp_server_init(void)
{
    struct tcp_pcb *server_modbus = NULL;
    struct tcp_pcb *server_hart = 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_hart = tcp_new();

    /* 绑定TCP控制块 */
    tcp_bind(server_hart, IP_ADDR_ANY, TCP_PORT_HART);

    /* 进入监听状态 */
    server_hart = tcp_listen(server_hart);

    /* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
    tcp_accept(server_hart, tcpecho_accept_hart); // 侦听到连接后，回调用户编写的tcpecho_accept

}

void tcp_server_task(void)
{
	uint32_t phyreg = 0;
    HAL_ETH_ReadPHYRegister(&heth, 0x00, PHY_BSR, &phyreg);
    if (((phyreg >> 2) & 0x1) != 0x1)
    {
      /* When the netif link is down this function must be called */

      netif_set_link_down(&gnetif);
      netif_set_down(&gnetif); // 热插拔下线时调用
      if (tcp_flag_modbus == 1)
      {
        tcp_abort(server_pcb_modbus); // 热插拔下线时调用
        tcp_flag_modbus = 0;
      }
      if (tcp_flag_hart == 1)
      {
        tcp_abort(server_pcb_hart); // 热插拔下线时调用
        tcp_flag_hart = 0;
      }
    }
    else
    {
      /* When the netif is fully configured this function must be called */
      netif_set_link_up(&gnetif);
      netif_set_up(&gnetif); // 热插拔上线时调用

    }
}