#include "tcpserverc.h"
#include "lwip/netif.h"
#include "lwip/ip.h"
#include "lwip/tcp.h"
#include "lwip/init.h"
#include "netif/etharp.h"
#include "lwip/udp.h"
#include "lwip/pbuf.h"
#include <stdio.h>
#include <string.h>
#include "main.h"
#include "ht1200m.h"
#include "user_lib.h"
#include "communication_protocol.h"
#include "user_gpio.h"
#include "ch438q.h"

err_t (*tcpecho_accept_hart[TCP_MAX])(void *arg, struct tcp_pcb *newpcb, err_t err);
struct tcp_pcb *server_pcb_hart[TCP_MAX] = {0};

// communication_di_t *user_communication_di = NULL;
// communication_do_t *user_communication_do = NULL;
// communication_ai_t *user_communication_ai = NULL;
// communication_ao_t *user_communication_ao = NULL;

uint8_t tcp_echo_flags[TCP_MAX] = {0};
uint32_t tcp_times[TCP_MAX] = {0};
uart_t hart_uart[TCP_MAX] = {0};

extern uint8_t tcp_echo_flags_control;
extern uint8_t send_data_flag_cmd;

/*接收回调函数*/
static err_t tcpecho_recv_hart1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags[TCP_HART1] = 1;
        tcp_recved(tpcb, p->tot_len);      // 读取数据的控制块   得到所有数据的长度
        server_pcb_hart[TCP_HART1] = tpcb; // 直接赋值
        memcpy(hart_uart[TCP_HART1].tx_data, (int *)p->payload, p->tot_len);
        HAL_GPIO_TogglePin(PE5_LED_GPIO_Port, PE5_LED_Pin); // 接收数据时，LED闪烁
        ch438_send_data(TCP_HART1, hart_uart[TCP_HART1].tx_data, p->tot_len);
        tcp_times[TCP_HART1]++;
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_hart2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags[TCP_HART2] = 1;
        tcp_recved(tpcb, p->tot_len);      // 读取数据的控制块   得到所有数据的长度
        server_pcb_hart[TCP_HART2] = tpcb; // 直接赋值
        memcpy(hart_uart[TCP_HART2].tx_data, (int *)p->payload, p->tot_len);
        ch438_send_data(TCP_HART2, hart_uart[TCP_HART2].tx_data, p->tot_len);
        tcp_times[TCP_HART2]++;
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_hart3(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags[TCP_HART3] = 1;
        tcp_recved(tpcb, p->tot_len);      // 读取数据的控制块   得到所有数据的长度
        server_pcb_hart[TCP_HART3] = tpcb; // 直接赋值
        memcpy(hart_uart[TCP_HART3].tx_data, (int *)p->payload, p->tot_len);
        ch438_send_data(TCP_HART3, hart_uart[TCP_HART3].tx_data, p->tot_len);
        tcp_times[TCP_HART3]++;
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_hart4(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags[TCP_HART4] = 1;
        tcp_recved(tpcb, p->tot_len);      // 读取数据的控制块   得到所有数据的长度
        server_pcb_hart[TCP_HART4] = tpcb; // 直接赋值
        memcpy(hart_uart[TCP_HART4].tx_data, (int *)p->payload, p->tot_len);
        ch438_send_data(TCP_HART4, hart_uart[TCP_HART4].tx_data, p->tot_len);
        tcp_times[TCP_HART4]++;
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_hart5(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags[TCP_HART5] = 1;
        tcp_recved(tpcb, p->tot_len);      // 读取数据的控制块   得到所有数据的长度
        server_pcb_hart[TCP_HART5] = tpcb; // 直接赋值
        memcpy(hart_uart[TCP_HART5].tx_data, (int *)p->payload, p->tot_len);
        ch438_send_data(TCP_HART5, hart_uart[TCP_HART5].tx_data, p->tot_len);
        tcp_times[TCP_HART5]++;
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_hart6(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags[TCP_HART6] = 1;
        tcp_recved(tpcb, p->tot_len);      // 读取数据的控制块   得到所有数据的长度
        server_pcb_hart[TCP_HART6] = tpcb; // 直接赋值
        memcpy(hart_uart[TCP_HART6].tx_data, (int *)p->payload, p->tot_len);
        ch438_send_data(TCP_HART6, hart_uart[TCP_HART6].tx_data, p->tot_len);
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_hart7(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags[TCP_HART7] = 1;
        tcp_recved(tpcb, p->tot_len);      // 读取数据的控制块   得到所有数据的长度
        server_pcb_hart[TCP_HART7] = tpcb; // 直接赋值
        memcpy(hart_uart[TCP_HART7].tx_data, (int *)p->payload, p->tot_len);
        ch438_send_data(TCP_HART7, hart_uart[TCP_HART7].tx_data, p->tot_len);
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_hart8(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags[TCP_HART8] = 1;
        tcp_recved(tpcb, p->tot_len);      // 读取数据的控制块   得到所有数据的长度
        server_pcb_hart[TCP_HART8] = tpcb; // 直接赋值
        memcpy(hart_uart[TCP_HART8].tx_data, (int *)p->payload, p->tot_len);
        ch438_send_data(TCP_HART8, hart_uart[TCP_HART8].tx_data, p->tot_len);
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_hart9(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags[TCP_HART9] = 1;
        tcp_recved(tpcb, p->tot_len);      // 读取数据的控制块   得到所有数据的长度
        server_pcb_hart[TCP_HART9] = tpcb; // 直接赋值
        memcpy(hart_uart[TCP_HART9].tx_data, (int *)p->payload, p->tot_len);
        ch438_send_data(TCP_HART9, hart_uart[TCP_HART9].tx_data, p->tot_len);
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_hart10(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags[TCP_HART10] = 1;
        tcp_recved(tpcb, p->tot_len);       // 读取数据的控制块   得到所有数据的长度
        server_pcb_hart[TCP_HART10] = tpcb; // 直接赋值
        memcpy(hart_uart[TCP_HART10].tx_data, (int *)p->payload, p->tot_len);
        ch438_send_data(TCP_HART10, hart_uart[TCP_HART10].tx_data, p->tot_len);
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_hart11(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags[TCP_HART11] = 1;
        tcp_recved(tpcb, p->tot_len);       // 读取数据的控制块   得到所有数据的长度
        server_pcb_hart[TCP_HART11] = tpcb; // 直接赋值
        memcpy(hart_uart[TCP_HART11].tx_data, (int *)p->payload, p->tot_len);
        ch438_send_data(TCP_HART11, hart_uart[TCP_HART11].tx_data, p->tot_len);
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_hart12(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags[TCP_HART12] = 1;
        tcp_recved(tpcb, p->tot_len);       // 读取数据的控制块   得到所有数据的长度
        server_pcb_hart[TCP_HART12] = tpcb; // 直接赋值
        memcpy(hart_uart[TCP_HART12].tx_data, (int *)p->payload, p->tot_len);
        ch438_send_data(TCP_HART12, hart_uart[TCP_HART12].tx_data, p->tot_len);
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_hart13(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags[TCP_HART13] = 1;
        tcp_recved(tpcb, p->tot_len);       // 读取数据的控制块   得到所有数据的长度
        server_pcb_hart[TCP_HART13] = tpcb; // 直接赋值
        memcpy(hart_uart[TCP_HART13].tx_data, (int *)p->payload, p->tot_len);
        ch438_send_data(TCP_HART13, hart_uart[TCP_HART13].tx_data, p->tot_len);
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_hart14(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags[TCP_HART14] = 1;
        tcp_recved(tpcb, p->tot_len);       // 读取数据的控制块   得到所有数据的长度
        server_pcb_hart[TCP_HART14] = tpcb; // 直接赋值
        memcpy(hart_uart[TCP_HART14].tx_data, (int *)p->payload, p->tot_len);
        ch438_send_data(TCP_HART14, hart_uart[TCP_HART14].tx_data, p->tot_len);
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_hart15(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags[TCP_HART15] = 1;
        tcp_recved(tpcb, p->tot_len);       // 读取数据的控制块   得到所有数据的长度
        server_pcb_hart[TCP_HART15] = tpcb; // 直接赋值
        memcpy(hart_uart[TCP_HART15].tx_data, (int *)p->payload, p->tot_len);
        ch438_send_data(TCP_HART15, hart_uart[TCP_HART15].tx_data, p->tot_len);
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_recv_hart16(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块   接收到的数据
    if (p != NULL)
    {
        /* 更新窗口*/
        tcp_echo_flags[TCP_HART16] = 1;
        tcp_recved(tpcb, p->tot_len);       // 读取数据的控制块   得到所有数据的长度
        server_pcb_hart[TCP_HART16] = tpcb; // 直接赋值
        memcpy(hart_uart[TCP_HART16].tx_data, (int *)p->payload, p->tot_len);
        ch438_send_data(TCP_HART16, hart_uart[TCP_HART16].tx_data, p->tot_len);
        pbuf_free(p);
    }
    else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
    {
        return tcp_close(tpcb);
    }
    return ERR_OK;
}

static err_t tcpecho_accept_hart1(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
                                                                                // 形参的数量和类型必须一致
{
    tcp_recv(newpcb, tcpecho_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_recv(newpcb, tcpecho_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_recv(newpcb, tcpecho_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_recv(newpcb, tcpecho_recv_hart4); // 当收到数据时，回调用户自己写的tcpecho_recv

    return ERR_OK;
}

static err_t tcpecho_accept_hart5(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
                                                                                // 形参的数量和类型必须一致
{
    tcp_recv(newpcb, tcpecho_recv_hart5); // 当收到数据时，回调用户自己写的tcpecho_recv

    return ERR_OK;
}

static err_t tcpecho_accept_hart6(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
                                                                                // 形参的数量和类型必须一致
{
    tcp_recv(newpcb, tcpecho_recv_hart6); // 当收到数据时，回调用户自己写的tcpecho_recv

    return ERR_OK;
}

static err_t tcpecho_accept_hart7(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
                                                                                // 形参的数量和类型必须一致
{
    tcp_recv(newpcb, tcpecho_recv_hart7); // 当收到数据时，回调用户自己写的tcpecho_recv

    return ERR_OK;
}

static err_t tcpecho_accept_hart8(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
                                                                                // 形参的数量和类型必须一致
{
    tcp_recv(newpcb, tcpecho_recv_hart8); // 当收到数据时，回调用户自己写的tcpecho_recv

    return ERR_OK;
}
static err_t tcpecho_accept_hart9(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
    tcp_recv(newpcb, tcpecho_recv_hart9); // 当收到数据时，回调用户自己写的tcpecho_recv

    return ERR_OK;
}

static err_t tcpecho_accept_hart10(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
    tcp_recv(newpcb, tcpecho_recv_hart10); // 当收到数据时，回调用户自己写的tcpecho_recv

    return ERR_OK;
}
static err_t tcpecho_accept_hart11(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
    tcp_recv(newpcb, tcpecho_recv_hart11); // 当收到数据时，回调用户自己写的tcpecho_recv

    return ERR_OK;
}
static err_t tcpecho_accept_hart12(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
    tcp_recv(newpcb, tcpecho_recv_hart12); // 当收到数据时，回调用户自己写的tcpecho_recv

    return ERR_OK;
}
static err_t tcpecho_accept_hart13(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
    tcp_recv(newpcb, tcpecho_recv_hart13); // 当收到数据时，回调用户自己写的tcpecho_recv

    return ERR_OK;
}
static err_t tcpecho_accept_hart14(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
    tcp_recv(newpcb, tcpecho_recv_hart14); // 当收到数据时，回调用户自己写的tcpecho_recv

    return ERR_OK;
}
static err_t tcpecho_accept_hart15(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
    tcp_recv(newpcb, tcpecho_recv_hart15); // 当收到数据时，回调用户自己写的tcpecho_recv

    return ERR_OK;
}
static err_t tcpecho_accept_hart16(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
    tcp_recv(newpcb, tcpecho_recv_hart16); // 当收到数据时，回调用户自己写的tcpecho_recv

    return ERR_OK;
}
void tcp_echo_init(void)
{
    struct tcp_pcb *server_hart[TCP_MAX] = {0};
    // struct tcp_pcb *server_hart2 = NULL;
    // struct tcp_pcb *server_hart3 = NULL;
    // struct tcp_pcb *server_hart4 = NULL;
    // struct tcp_pcb *server_hart5 = NULL;
    // struct tcp_pcb *server_hart6 = NULL;
    // struct tcp_pcb *server_hart7 = NULL;
    // struct tcp_pcb *server_hart8 = NULL;
    // struct tcp_pcb *server_hart9 = NULL;
    // struct tcp_pcb *server_hart10 = NULL;
    // struct tcp_pcb *server_hart11 = NULL;
    // struct tcp_pcb *server_hart12 = NULL;
    // struct tcp_pcb *server_hart13 = NULL;
    // struct tcp_pcb *server_hart14 = NULL;
    // struct tcp_pcb *server_hart15 = NULL;
    // struct tcp_pcb *server_hart16 = NULL;
    tcpecho_accept_hart[TCP_HART1] = tcpecho_accept_hart1;
    tcpecho_accept_hart[TCP_HART2] = tcpecho_accept_hart2;
    tcpecho_accept_hart[TCP_HART3] = tcpecho_accept_hart3;
    tcpecho_accept_hart[TCP_HART4] = tcpecho_accept_hart4;
    tcpecho_accept_hart[TCP_HART5] = tcpecho_accept_hart5;
    tcpecho_accept_hart[TCP_HART6] = tcpecho_accept_hart6;
    tcpecho_accept_hart[TCP_HART7] = tcpecho_accept_hart7;
    tcpecho_accept_hart[TCP_HART8] = tcpecho_accept_hart8;
    tcpecho_accept_hart[TCP_HART9] = tcpecho_accept_hart9;
    tcpecho_accept_hart[TCP_HART10] = tcpecho_accept_hart10;
    tcpecho_accept_hart[TCP_HART11] = tcpecho_accept_hart11;
    tcpecho_accept_hart[TCP_HART12] = tcpecho_accept_hart12;
    tcpecho_accept_hart[TCP_HART13] = tcpecho_accept_hart13;
    tcpecho_accept_hart[TCP_HART14] = tcpecho_accept_hart14;
    tcpecho_accept_hart[TCP_HART15] = tcpecho_accept_hart15;
    tcpecho_accept_hart[TCP_HART16] = tcpecho_accept_hart16;
    /* 创建一路HART  */
    for (uint8_t i = TCP_HART1; i < TCP_MAX; i++)
    {
        server_hart[i] = NULL;
        tcp_echo_flags[i] = 0;
        server_hart[i] = tcp_new();
        /* 绑定TCP控制块 */
        tcp_bind(server_hart[i], IP_ADDR_ANY, TCP_PORT_HART1 + i);
        /* 进入监听状态 */
        server_hart[i] = tcp_listen(server_hart[i]);
        /* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
        tcp_accept(server_hart[i], tcpecho_accept_hart[i]); // 侦听到连接后，回调用户编写的tcpecho_accept
    }
    // for (uint8_t i = TCP_HART9; i < TCP_MAX; i++)
    // {
    //     server_hart[i] = NULL;
    //     tcp_echo_flags[i] = 0;
    //     server_hart[i] = tcp_new();
    //     /* 绑定TCP控制块 */
    //     tcp_bind(server_hart[i], IP_ADDR_ANY, TCP_PORT_HART9 + i);
    //     /* 进入监听状态 */
    //     server_hart[i] = tcp_listen(server_hart[i]);
    //     /* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
    //     tcp_accept(server_hart[i], tcpecho_accept_hart[i]); // 侦听到连接后，回调用户编写的tcpecho_accept
    // }
}

void user_send_data_hart(uint8_t ch, uint8_t *data, uint16_t len)
{

    tcp_write(server_pcb_hart[ch], data, len, 1);
}
// void user_send_data_hart9(uint8_t *data, uint16_t len)
// {

//     tcp_write(server_pcb_hart9, data, len, 1);
// }

// void user_send_data_control(uint8_t *data, uint16_t len)
// {

//     tcp_write(server_pcb_control, data, len, 1);
// }