STM32F7xx —— LAN8720（FreeRTOS+LWIP）

                                STM32F7xx —— LAN8720

 

 

    STM32F767自带以太网模块，需要外接PHY芯片，完成以太网通信（MII/RMII接口）。LAN8720详细资料看手册。LWIP:1.4.1 FreeRTOS V8.2.3。

#define ETH_CHANNEL               ETH
#define ETH_PREEMPT_PRIO          ETHERNET_PRIORITY
#define ETH_CLK_ENABLE()          __HAL_RCC_ETH_CLK_ENABLE()
#define ETH_IRQ                   ETH_IRQn
#define ETH_IRQ_FUNC              ETH_IRQHandler

#define ETH_RESET_PORT            GPIOH
#define ETH_RESET_PIN             GPIO_PIN_11
#define ETH_RESET_CONFIG()        GPIOConfig(ETH_RESET_PORT, ETH_RESET_PIN, GPIO_MODE_OUTPUT_PP, GPIO_NOPULL);
#define ETH_RESET_HIGH()          HAL_GPIO_WritePin(ETH_RESET_PORT, ETH_RESET_PIN, GPIO_PIN_SET)
#define ETH_RESET_LOW()           HAL_GPIO_WritePin(ETH_RESET_PORT, ETH_RESET_PIN, GPIO_PIN_RESET)

#define ETH_MDIO_PORT             GPIOA
#define ETH_MDIO_PIN              GPIO_PIN_2
#define ETH_MDIO_AF               GPIO_AF11_ETH
#define ETH_MDIO_CONFIG()         GPIOConfigExt(ETH_MDC_PORT, ETH_MDC_PIN, GPIO_MODE_AF_PP, GPIO_NOPULL, ETH_MDC_AF);

#define ETH_MDC_PORT              GPIOC
#define ETH_MDC_PIN               GPIO_PIN_1
#define ETH_MDC_AF                GPIO_AF11_ETH
#define ETH_MDC_CONFIG()          GPIOConfigExt(ETH_MDIO_PORT, ETH_MDIO_PIN, GPIO_MODE_AF_PP, GPIO_NOPULL, ETH_MDIO_AF);

#define ETH_RMII_REF_CLK_PORT     GPIOA
#define ETH_RMII_REF_CLK_PIN      GPIO_PIN_1
#define ETH_RMII_REF_CLK_AF       GPIO_AF11_ETH
#define ETH_RMII_REF_CLK_CONFIG() GPIOConfigExt(ETH_RMII_REF_CLK_PORT, ETH_RMII_REF_CLK_PIN, GPIO_MODE_AF_PP, GPIO_NOPULL, ETH_RMII_REF_CLK_AF);

#define ETH_RMII_CRS_DV_PORT      GPIOA
#define ETH_RMII_CRS_DV_PIN       GPIO_PIN_7
#define ETH_RMII_CRS_DV_AF        GPIO_AF11_ETH
#define ETH_RMII_CRS_DV_CONFIG()  GPIOConfigExt(ETH_RMII_CRS_DV_PORT, ETH_RMII_CRS_DV_PIN, GPIO_MODE_AF_PP, GPIO_NOPULL, ETH_RMII_CRS_DV_AF);

#define ETH_RMII_RXD0_PORT        GPIOC
#define ETH_RMII_RXD0_PIN         GPIO_PIN_4
#define ETH_RMII_RXD0_AF          GPIO_AF11_ETH
#define ETH_RMII_RXD0_CONFIG()    GPIOConfigExt(ETH_RMII_RXD0_PORT, ETH_RMII_RXD0_PIN, GPIO_MODE_AF_PP, GPIO_NOPULL, ETH_RMII_RXD0_AF);

#define ETH_RMII_RXD1_PORT        GPIOC
#define ETH_RMII_RXD1_PIN         GPIO_PIN_5
#define ETH_RMII_RXD1_AF          GPIO_AF11_ETH
#define ETH_RMII_RXD1_CONFIG()    GPIOConfigExt(ETH_RMII_RXD1_PORT, ETH_RMII_RXD1_PIN, GPIO_MODE_AF_PP, GPIO_NOPULL, ETH_RMII_RXD1_AF);

#define ETH_RMII_TXEN_PORT        GPIOB
#define ETH_RMII_TXEN_PIN         GPIO_PIN_11
#define ETH_RMII_TXEN_AF          GPIO_AF11_ETH
#define ETH_RMII_TXEN_CONFIG()    GPIOConfigExt(ETH_RMII_TXEN_PORT, ETH_RMII_TXEN_PIN, GPIO_MODE_AF_PP, GPIO_NOPULL, ETH_RMII_TXEN_AF);

#define ETH_RMII_TXD0_PORT        GPIOG
#define ETH_RMII_TXD0_PIN         GPIO_PIN_13
#define ETH_RMII_TXD0_AF          GPIO_AF11_ETH
#define ETH_RMII_TXD0_CONFIG()    GPIOConfigExt(ETH_RMII_TXD0_PORT, ETH_RMII_TXD0_PIN, GPIO_MODE_AF_PP, GPIO_NOPULL, ETH_RMII_TXD0_AF);

#define ETH_RMII_TXD1_PORT        GPIOG
#define ETH_RMII_TXD1_PIN         GPIO_PIN_14
#define ETH_RMII_TXD1_AF          GPIO_AF11_ETH
#define ETH_RMII_TXD1_CONFIG()    GPIOConfigExt(ETH_RMII_TXD1_PORT, ETH_RMII_TXD1_PIN, GPIO_MODE_AF_PP, GPIO_NOPULL, ETH_RMII_TXD1_AF);

lan8720_dev_t lan8720_dev;

static void lan8720_var_init(void)
{
  lan8720_dev.dma_rx = MemAlloc(SRAM_TYPE_DTCM, ETH_RXBUFNB * sizeof(ETH_DMADescTypeDef)); //申请内存
  lan8720_dev.dma_tx = MemAlloc(SRAM_TYPE_DTCM, ETH_TXBUFNB * sizeof(ETH_DMADescTypeDef)); //申请内存
  lan8720_dev.rx_buffer = MemAlloc(SRAM_TYPE_DTCM, ETH_RX_BUF_SIZE * ETH_RXBUFNB); //申请内存
  lan8720_dev.tx_buffer = MemAlloc(SRAM_TYPE_DTCM, ETH_TX_BUF_SIZE * ETH_TXBUFNB); //申请内存
}

static void lan8720_gpio_init(void)
{
  ETH_CLK_ENABLE();

  ETH_RESET_CONFIG();
  ETH_MDIO_CONFIG();
  ETH_MDC_CONFIG();
  ETH_RMII_REF_CLK_CONFIG();
  ETH_RMII_CRS_DV_CONFIG();
  ETH_RMII_RXD0_CONFIG();
  ETH_RMII_RXD1_CONFIG();
  ETH_RMII_TXEN_CONFIG();
  ETH_RMII_TXD0_CONFIG();
  ETH_RMII_TXD1_CONFIG();
}

static void lan8720_mode_init(void)
{
  uint8_t mac[6] = {0};

  ETH_RESET_CONFIG();
  ETH_RESET_HIGH();
  delay_ms(100);
  ETH_RESET_LOW();
  delay_ms(100);

  mac[0] = lwip_dev.mac[0];
  mac[1] = lwip_dev.mac[1];
  mac[2] = lwip_dev.mac[2];
  mac[3] = lwip_dev.mac[3];
  mac[4] = lwip_dev.mac[4];
  mac[5] = lwip_dev.mac[5];

  lan8720_dev.handle.Instance = ETH;
  lan8720_dev.handle.Init.AutoNegotiation = ETH_AUTONEGOTIATION_ENABLE; // 使能自协商模式
  lan8720_dev.handle.Init.Speed = ETH_SPEED_100M;                       // 速度100M,如果开启了自协商模式，此配置就无效
  lan8720_dev.handle.Init.DuplexMode = ETH_MODE_FULLDUPLEX;             // 全双工模式，如果开启了自协商模式，此配置就无效
  lan8720_dev.handle.Init.PhyAddress = LAN8720_PHY_ADDRESS;             // LAN8720地址
  lan8720_dev.handle.Init.MACAddr = mac;                                // MAC地址
  lan8720_dev.handle.Init.RxMode = ETH_RXINTERRUPT_MODE;                // 中断接收模式
  lan8720_dev.handle.Init.ChecksumMode = ETH_CHECKSUM_BY_HARDWARE;      // 硬件帧校验
  lan8720_dev.handle.Init.MediaInterface = ETH_MEDIA_INTERFACE_RMII;    // RMII接口
  HAL_ETH_Init(&lan8720_dev.handle);
}

static void lan8720_nvic_init(void)
{
  HAL_NVIC_SetPriority(ETH_IRQ, 3, 0); // 优先级必须小于configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY
  HAL_NVIC_EnableIRQ(ETH_IRQ);
}

uint32_t LAN8720ReadPHY(uint16_t reg)
{
  uint32_t regval;

  HAL_ETH_ReadPHYRegister(&lan8720_dev.handle, reg, &regval);

  return regval;
}

void LAN8720WritePHY(uint16_t reg, uint16_t value)
{
  uint32_t temp = value;

  HAL_ETH_ReadPHYRegister(&lan8720_dev.handle, reg, &temp);
}

static uint32_t lan8720_rx_size(ETH_DMADescTypeDef *dma_rx)
{
  uint32_t length = 0;

  if(((dma_rx->Status & ETH_DMARXDESC_OWN) == (uint32_t)RESET) &&
      ((dma_rx->Status & ETH_DMARXDESC_ES) == (uint32_t)RESET) &&
      ((dma_rx->Status & ETH_DMARXDESC_LS) != (uint32_t)RESET))
  {
    length = ((dma_rx->Status & ETH_DMARXDESC_FL) >> ETH_DMARXDESC_FRAME_LENGTHSHIFT);
  }

  return length;
}

void LAN8720Init(void)
{
  lan8720_var_init();
  lan8720_gpio_init();
  lan8720_mode_init();
  lan8720_nvic_init();
}

void ETH_IRQ_FUNC(void)
{
  while(lan8720_rx_size(lan8720_dev.handle.RxDesc))
  {
    LWIPCommProcess(); // 处理以太网数据，即将数据提交给LWIP
  }
  //清除中断标志位
  __HAL_ETH_DMA_CLEAR_IT(&lan8720_dev.handle, ETH_DMA_IT_R);
  __HAL_ETH_DMA_CLEAR_IT(&lan8720_dev.handle, ETH_DMA_IT_NIS);
}

sys_arch文件：

#ifndef _ARCH_SYS_ARCH_H_
#define _ARCH_SYS_ARCH_H_

#include "arch/cc.h"
#include "FreeRTOS.h"
#include "queue.h"
#include "semphr.h"

#define MAX_QUEUE_ENTRIES     20  // 每个消息邮箱的大小

// LWIP消息邮箱结构体
typedef struct
{
  QueueHandle_t xQueue;
} lwip_mbox;

typedef SemaphoreHandle_t sys_sem_t;   // LWIP使用的信号量
typedef lwip_mbox   sys_mbox_t;       // LWIP使用的消息邮箱,其实就是UCOS中的消息队列
typedef unsigned char  sys_thread_t;  // 线程ID,也就是任务优先级

#endif /* _ARCH_SYS_ARCH_H_ */

// 参照lwip_sys.h

static const uint32_t console_null;

// 创建一个消息邮箱
err_t sys_mbox_new(sys_mbox_t *mbox, int size)
{
  if(size > MAX_QUEUE_ENTRIES)
  {
    size = MAX_QUEUE_ENTRIES;
  }
  mbox->xQueue = xQueueCreate(size, sizeof(void *));

  if(mbox->xQueue != NULL)
  {
    return ERR_OK;
  }
  else
  {
    return ERR_MEM;
  }
}

// 释放并删除一个消息邮箱
void sys_mbox_free(sys_mbox_t *mbox)
{
  vQueueDelete(mbox->xQueue);

  mbox->xQueue = NULL;
}

// 向消息邮箱中发送一条消息(必须发送成功)
void sys_mbox_post(sys_mbox_t *mbox, void *msg)
{
  BaseType_t xHigherPriorityTaskWoken = pdFALSE;

  if(msg == NULL)
  {
    msg = (void*)&console_null;  //当msg为空时 msg等于pvNullPointer指向的值
  }
  if((SCB_ICSR_REG & 0xFF) == 0) //线程执行
  {
    while(xQueueSendToBack(mbox->xQueue, &msg, portMAX_DELAY) != pdPASS);//portMAX_DELAY,死等直到发送成功
  }
  else
  {
    while(xQueueSendToBackFromISR(mbox->xQueue, &msg, &xHigherPriorityTaskWoken) != pdPASS);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
  }
}

// 尝试向一个消息邮箱发送消息
// 此函数相对于sys_mbox_post函数只发送一次消息，发送失败后不会尝试第二次发送
err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
{
  BaseType_t xHigherPriorityTaskWoken = pdFALSE;
  if(msg == NULL)
  {
    msg = (void*)&console_null;  //当消息为空，则用常量NullMessage的地址替换
  }
  if((SCB_ICSR_REG & 0xFF) == 0)
  {
    if(xQueueSendToBack(mbox->xQueue, &msg, 0) != pdPASS)
    {
      return ERR_MEM;
    }
  }
  else
  {
    if(xQueueSendToBackFromISR(mbox->xQueue, &msg, &xHigherPriorityTaskWoken) != pdPASS)
    {
      return ERR_MEM;
    }
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
  }
  return ERR_OK;
}

// 等待邮箱中的消息
u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout)
{
#if 0
	u32_t rtos_timeout;
  BaseType_t temp;
	
	if(timeout == 0)
	{
		rtos_timeout = 2;
	}
	else
	{
		rtos_timeout = timeout;
		temp = xQueueReceive(mbox->xQueue, msg, rtos_timeout);
	}
	
	return rtos_timeout;
	
#else
  u32_t rtos_timeout, timeout_new;
  BaseType_t temp;

  temp = xQueueReceive(mbox->xQueue, msg, 0);
  if((temp == pdPASS) && (*msg != NULL))
  {
    if(*msg == (void*)&console_null)
    {
      *msg = NULL;
    }
    return 0;
  }

  if(timeout != 0)
  {
    rtos_timeout = (timeout * configTICK_RATE_HZ) / 1000; // 转换为节拍数,因为freertos延时使用的是节拍数,而LWIP是用ms
    if(rtos_timeout < 1)
    {
      rtos_timeout = 1; // 至少1个节拍
    }
    else if(rtos_timeout >= portMAX_DELAY)
    {
      rtos_timeout = portMAX_DELAY - 1;
    }
  }
  else
  {
    rtos_timeout = 0;
  }
  timeout = HAL_GetTick(); //获取系统时间
  if(rtos_timeout != 0)
  {
    temp = xQueueReceive(mbox->xQueue, msg, rtos_timeout);  // 请求消息队列,等待时限为rtos_timeout
  }
  else
  {
    temp = xQueueReceive(mbox->xQueue, msg, portMAX_DELAY);  // 为0则无限等
  }

  if(temp == errQUEUE_EMPTY)
  {
    timeout = SYS_ARCH_TIMEOUT; //请求超时
    *msg = NULL;
  }
  else
  {
    if(*msg != NULL)
    {
      if(*msg == (void*)&console_null)
      {
        *msg = NULL;
      }
    }
    timeout_new = HAL_GetTick();
    if (timeout_new > timeout)
    {
      timeout_new = timeout_new - timeout;  //算出请求消息或使用的时间
    }
    else
    {
      timeout_new = 0xffffffff - timeout + timeout_new;
    }
    timeout = timeout_new * 1000 / configTICK_RATE_HZ + 1;
  }
  return timeout;
#endif
}

// 尝试获取消息
u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)
{
  BaseType_t temp;

  temp = xQueueReceive(mbox->xQueue, msg, 0);
  if((temp == pdPASS) && (*msg != NULL))
  {
    if(*msg == (void*)&console_null)
    {
      *msg = NULL;
    }

    return 0;
  }
  else
  {
    return SYS_MBOX_EMPTY;
  }
}

// 检查一个消息邮箱是否有效
// 返回值:1,有效.  0,无效
int sys_mbox_valid(sys_mbox_t *mbox)
{
  if(mbox->xQueue != NULL)
  {
    return 1;
  }

  return 0;
}

// 设置一个消息邮箱为无效
void sys_mbox_set_invalid(sys_mbox_t *mbox)
{
  mbox->xQueue = NULL;
}


// 创建一个信号量
err_t sys_sem_new(sys_sem_t* sem, uint8_t count)
{
  *sem = xSemaphoreCreateCounting(0xFF, count);
  if(*sem == NULL)
  {
    return ERR_MEM;
  }

  return ERR_OK;
}

// 等待一个信号量
u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout)
{
  u32_t rtos_timeout, timeout_new;
  BaseType_t temp;

  if(xSemaphoreTake(*sem, 0) == pdPASS)
  {
    return 0;
  }

  if( timeout != 0)
  {
    rtos_timeout = (timeout * configTICK_RATE_HZ) / 1000; // 转换为节拍数,因为UCOS延时使用的是节拍数,而LWIP是用ms
    if(rtos_timeout < 1)
    {
      rtos_timeout = 1;
    }
  }
  else
  {
    rtos_timeout = 0;
  }

  timeout = HAL_GetTick();

  if(rtos_timeout != 0)
  {
    temp = xSemaphoreTake(*sem, rtos_timeout);
  }
  else
  {
    temp = xSemaphoreTake(*sem, portMAX_DELAY);
  }

  if(temp != pdPASS)
  {
    timeout = SYS_ARCH_TIMEOUT; // 请求超时
  }
  else
  {
    timeout_new = HAL_GetTick();
    if (timeout_new >= timeout)
    {
      timeout_new = timeout_new - timeout;
    }
    else
    {
      timeout_new = 0xffffffff - timeout + timeout_new;
    }
    timeout = (timeout_new * 1000 / configTICK_RATE_HZ + 1); // 算出请求消息或使用的时间(ms)
  }

  return timeout;
}

// 发送一个信号量
void sys_sem_signal(sys_sem_t *sem)
{
  while(xSemaphoreGive(*sem) != pdTRUE);
}

// 释放并删除一个信号量
void sys_sem_free(sys_sem_t *sem)
{
  vSemaphoreDelete(*sem);
  *sem = NULL;
}

// 查询一个信号量的状态,无效或有效
int sys_sem_valid(sys_sem_t *sem)
{
  if(*sem != NULL)
  {
    return 1;
  }
  else
  {
    return 0;
  }
}

// 设置一个信号量无效
void sys_sem_set_invalid(sys_sem_t *sem)
{
  *sem = NULL;
}

// arch初始化
void sys_init(void)
{
  // 不做任何事情
}

TaskHandle_t os_lwip_handle;

sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread, void *arg, int stacksize, int prio)
{
  xTaskCreate((TaskFunction_t)thread,
              (const char*  )name,
              (uint16_t     )stacksize,
              (void*        )NULL,
              (UBaseType_t  )prio,
              (TaskHandle_t*)&os_lwip_handle);//创建TCP IP内核任务
  return 0;
}

// lwip延时函数
void sys_msleep(u32_t ms)
{
  delay_ms(ms);
}

// 获取系统时间,LWIP1.4.1增加的函数
// 返回值:当前系统时间(单位:毫秒)
u32_t sys_now(void)
{
  return (HAL_GetTick() * 1000 / configTICK_RATE_HZ + 1); // 将节拍数转换为LWIP的时间MS
}

// 用在cc.h的SYS_ARCH_PROTECT(lev)
uint32_t SysCriticalEnter(void)
{
  if(SCB_ICSR_REG & 0xFF) //在中断里
  {
    return taskENTER_CRITICAL_FROM_ISR();
  }
  else  // 在任务
  {
    taskENTER_CRITICAL();
  }

  return 0;
}

// 用在cc.YS_ARCH_UNPROTECT(lev)
void SysCriticalExit(uint32_t lev)
{
  if(SCB_ICSR_REG & 0xFF) // 在中断里
  {
    taskEXIT_CRITICAL_FROM_ISR(lev);
  }
  else  // 在任务
  {
    taskEXIT_CRITICAL();
  }
}

cpu.h：#define BYTE_ORDER LITTLE_ENDIAN  // 小端模式

cc.h：

#include "cpu.h"
#include "stdio.h"
#include "FreeRTOS.h"
#include "task.h"

// LWIP需要的类型重命名
typedef unsigned   char    u8_t;    /* Unsigned 8 bit quantity         */
typedef signed     char    s8_t;    /* Signed    8 bit quantity        */
typedef unsigned   short   u16_t;   /* Unsigned 16 bit quantity        */
typedef signed     short   s16_t;   /* Signed   16 bit quantity        */
typedef unsigned   long    u32_t;   /* Unsigned 32 bit quantity        */
typedef signed     long    s32_t;   /* Signed   32 bit quantity        */
typedef u32_t mem_ptr_t;           /* Unsigned 32 bit quantity        */
typedef int sys_prot_t;

// LWIP需要的临界段
#define OS_CRITICAL_METHOD

#ifdef OS_CRITICAL_METHOD

#define SCB_ICSR_REG    (*((volatile uint32_t * ) 0xe000ed04))

extern uint32_t SysCriticalEnter(void);
extern void SysCriticalExit(uint32_t lev);


#define SYS_ARCH_DECL_PROTECT(lev)   u32_t lev

#define SYS_ARCH_PROTECT(lev)        lev = SysCriticalEnter()

#define SYS_ARCH_UNPROTECT(lev)      SysCriticalExit(lev)

#endif


// 对齐方案
#if defined (__ICCARM__)

#define PACK_STRUCT_BEGIN
#define PACK_STRUCT_STRUCT
#define PACK_STRUCT_END
#define PACK_STRUCT_FIELD(x) x
#define PACK_STRUCT_USE_INCLUDES

#elif defined (__CC_ARM)

#define PACK_STRUCT_BEGIN __packed
#define PACK_STRUCT_STRUCT
#define PACK_STRUCT_END
#define PACK_STRUCT_FIELD(x) x

#elif defined (__GNUC__)

#define PACK_STRUCT_BEGIN
#define PACK_STRUCT_STRUCT __attribute__ ((__packed__))
#define PACK_STRUCT_END
#define PACK_STRUCT_FIELD(x) x

#elif defined (__TASKING__)

#define PACK_STRUCT_BEGIN
#define PACK_STRUCT_STRUCT
#define PACK_STRUCT_END
#define PACK_STRUCT_FIELD(x) x

#endif


#define U16_F "4d"
#define S16_F "4d"
#define X16_F "4x"
#define U32_F "8ld"
#define S32_F "8ld"
#define X32_F "8lx"

/*--------------macros--------------------------------------------------------*/
#ifndef LWIP_PLATFORM_ASSERT
#define LWIP_PLATFORM_ASSERT(x) \
    do \
    {   printf("Assertion \"%s\" failed at line %d in %s\r\n", x, __LINE__, __FILE__); \
    } while(0)
#endif

#ifndef LWIP_PLATFORM_DIAG
#define LWIP_PLATFORM_DIAG(x) do {printf x;} while(0)
#endif

lwipopts.h

#ifndef _LWIPOPTS_H_
#define _LWIPOPTS_H_

// 与FreeRTOS配置类似(FreeRTOSConfig.h)

// 线程优先级
#ifndef TCPIP_THREAD_PRIO
#define TCPIP_THREAD_PRIO     (configMAX_PRIORITIES - 1) // 定义内核任务的优先级为最高
#endif
#undef  DEFAULT_THREAD_PRIO
#define DEFAULT_THREAD_PRIO   8


#define SYS_LIGHTWEIGHT_PROT    1     // 为1时使用实时操作系统的轻量级保护,保护关键代码不被中断打断
#define NO_SYS                  0     // 使用UCOS操作系统
#define MEM_ALIGNMENT           4     // 使用4字节对齐模式
#define MEM_SIZE                16000 // 内存堆heap大小
#define MEMP_NUM_PBUF           20    // MEMP_NUM_PBUF:memp结构的pbuf数量,如果应用从ROM或者静态存储区发送大量数据时,这个值应该设置大一点
#define MEMP_NUM_UDP_PCB        6     // MEMP_NUM_UDP_PCB:UDP协议控制块(PCB)数量.每个活动的UDP"连接"需要一个PCB.
#define MEMP_NUM_TCP_PCB        10    // MEMP_NUM_TCP_PCB:同时建立激活的TCP数量
#define MEMP_NUM_TCP_PCB_LISTEN 6     // MEMP_NUM_TCP_PCB_LISTEN:能够监听的TCP连接数量
#define MEMP_NUM_TCP_SEG        15    // MEMP_NUM_TCP_SEG:最多同时在队列中的TCP段数量
#define MEMP_NUM_SYS_TIMEOUT    8     // MEMP_NUM_SYS_TIMEOUT:能够同时激活的timeout个数

// pbuf内存池
#define PBUF_POOL_SIZE          20    // PBUF_POOL_SIZE:pbuf内存池个数
#define PBUF_POOL_BUFSIZE       512   // PBUF_POOL_BUFSIZE:每个pbuf内存池大小

#define LWIP_TCP                1     // 使用TCP
#define TCP_TTL                 255   // 生存时间

#undef TCP_QUEUE_OOSEQ
#define TCP_QUEUE_OOSEQ         0     // 当TCP的数据段超出队列时的控制位,当设备的内存过小的时候此项应为0

#undef TCPIP_MBOX_SIZE
#define TCPIP_MBOX_SIZE         MAX_QUEUE_ENTRIES // tcpip创建主线程时的消息邮箱大小

#undef DEFAULT_TCP_RECVMBOX_SIZE
#define DEFAULT_TCP_RECVMBOX_SIZE       MAX_QUEUE_ENTRIES

#undef DEFAULT_ACCEPTMBOX_SIZE
#define DEFAULT_ACCEPTMBOX_SIZE         MAX_QUEUE_ENTRIES


#define TCP_MSS                 (1500 - 40) // 最大TCP分段,TCP_MSS = (MTU - IP报头大小 - TCP报头大小
#define TCP_SND_BUF             (4*TCP_MSS) // TCP发送缓冲区大小(bytes).
#define TCP_SND_QUEUELEN        (2* TCP_SND_BUF/TCP_MSS)  //TCP_SND_QUEUELEN: TCP发送缓冲区大小(pbuf).这个值最小为(2 * TCP_SND_BUF/TCP_MSS)
#define TCP_WND                 (2*TCP_MSS)   // TCP发送窗口
#define LWIP_ICMP               1   // 使用ICMP协议
#define LWIP_DHCP               0   // 使用DHCP
#define LWIP_UDP                1   // 使用UDP服务
#define UDP_TTL                 255 // UDP数据包生存时间
#define LWIP_STATS 0
#define LWIP_PROVIDE_ERRNO 1

// 帧校验和选项，STM32F7xx允许通过硬件识别和计算IP,UDP和ICMP的帧校验和
#define CHECKSUM_BY_HARDWARE // 定义CHECKSUM_BY_HARDWARE,使用硬件帧校验
#ifdef CHECKSUM_BY_HARDWARE
//CHECKSUM_GEN_IP==0: 硬件生成IP数据包的帧校验和
#define CHECKSUM_GEN_IP                 0
//CHECKSUM_GEN_UDP==0: 硬件生成UDP数据包的帧校验和
#define CHECKSUM_GEN_UDP                0
//CHECKSUM_GEN_TCP==0: 硬件生成TCP数据包的帧校验和
#define CHECKSUM_GEN_TCP                0
//CHECKSUM_CHECK_IP==0: 硬件检查输入的IP数据包帧校验和
#define CHECKSUM_CHECK_IP               0
//CHECKSUM_CHECK_UDP==0: 硬件检查输入的UDP数据包帧校验和
#define CHECKSUM_CHECK_UDP              0
//CHECKSUM_CHECK_TCP==0: 硬件检查输入的TCP数据包帧校验和
#define CHECKSUM_CHECK_TCP              0
//CHECKSUM_CHECK_ICMP==1:硬件检查输入的ICMP数据包帧校验和
#define CHECKSUM_GEN_ICMP               0
#else
//CHECKSUM_GEN_IP==1: 软件生成IP数据包帧校验和
#define CHECKSUM_GEN_IP                 1
// CHECKSUM_GEN_UDP==1: 软件生成UDOP数据包帧校验和
#define CHECKSUM_GEN_UDP                1
//CHECKSUM_GEN_TCP==1: 软件生成TCP数据包帧校验和
#define CHECKSUM_GEN_TCP                1
// CHECKSUM_CHECK_IP==1: 软件检查输入的IP数据包帧校验和
#define CHECKSUM_CHECK_IP               1
// CHECKSUM_CHECK_UDP==1: 软件检查输入的UDP数据包帧校验和
#define CHECKSUM_CHECK_UDP              1
//CHECKSUM_CHECK_TCP==1: 软件检查输入的TCP数据包帧校验和
#define CHECKSUM_CHECK_TCP              1
//CHECKSUM_CHECK_ICMP==1:软件检查输入的ICMP数据包帧校验和
#define CHECKSUM_GEN_ICMP               1
#endif

#define LWIP_NETCONN                    1 // LWIP_NETCONN==1:使能NETCON函数(要求使用api_lib.c)
#define LWIP_SOCKET                     1 // LWIP_SOCKET==1:使能Socket API(要求使用sockets.c)
#define LWIP_COMPAT_MUTEX               1
#define LWIP_SO_RCVTIMEO                1 // 通过定义LWIP_SO_RCVTIMEO使能netconn结构体中recv_timeout,使用recv_timeout可以避免阻塞线程

// 有关系统的选项
#define TCPIP_THREAD_STACKSIZE          1024  // 内核任务堆栈大小
#define DEFAULT_UDP_RECVMBOX_SIZE       2000
#define DEFAULT_THREAD_STACKSIZE        512

//LWIP调试选项
#define LWIP_DEBUG                      0 // 关闭DEBUG选项
#define ICMP_DEBUG                      LWIP_DBG_OFF // 开启/关闭ICMPdebug


#endif /* __LWIPOPTS_H__ */

主函数需调用的初始化接口：

lwip_dev_t lwip_dev;            // lwip控制结构体
static struct netif lwip_netif; // 网络接口

extern uint32_t memp_get_memorysize(void);  // 在memp.c里面定义
extern uint8_t *memp_memory;                        // 在memp.c里面定义.
extern uint8_t *ram_heap;                           // 在mem.c里面定义.

// 释放内存
static void lwip_comm_mem_free(void)
{
  MemFree(SRAM_TYPE_IN, memp_memory);
  MemFree(SRAM_TYPE_IN, ram_heap);
}

// 分配内存
static uint8_t lwip_comm_mem_malloc(void)
{
  uint32_t mempsize;
  uint32_t ramheapsize;

  mempsize = memp_get_memorysize(); // 得到memp_memory数组大小
  memp_memory = MemAlloc(SRAM_TYPE_IN, mempsize); // 为memp_memory申请内存

  ramheapsize = LWIP_MEM_ALIGN_SIZE(MEM_SIZE) + 2 * LWIP_MEM_ALIGN_SIZE(4 * 3) + MEM_ALIGNMENT; // 得到ram heap大小
  ram_heap = MemAlloc(SRAM_TYPE_IN, ramheapsize); // 为ram_heap申请内存

  if(!memp_memory || !ram_heap)
  {
    lwip_comm_mem_free();
    return 1;
  }
  return 0;
}

// 网络默认配置
static void lwip_comm_default_ip_set(lwip_dev_t *dev)
{
  uint32_t sn0;

  SocIDGet(&sn0, CONFIG_SYSTEM_HARDWARE_TYPE);

  // MAC地址设置(高三字节固定为:2.0.0,低三字节用STM32唯一ID)
  dev->mac[0] = 2;
  dev->mac[1] = 0;
  dev->mac[2] = 0;
  dev->mac[3] = (sn0 >> 16) & 0xFF;
  dev->mac[4] = (sn0 >> 8) & 0xFF;
  dev->mac[5] = sn0 & 0xFF;

  // 默认远程IP
  dev->remoteip[0] = CONFIG_ETHERNET_REMOTE_IP0;
  dev->remoteip[1] = CONFIG_ETHERNET_REMOTE_IP1;
  dev->remoteip[2] = CONFIG_ETHERNET_REMOTE_IP2;
  dev->remoteip[3] = CONFIG_ETHERNET_REMOTE_IP3;

  // 本地IP
  dev->ip[0] = CONFIG_ETHERNET_LOCAL_IP0;
  dev->ip[1] = CONFIG_ETHERNET_LOCAL_IP1;
  dev->ip[2] = CONFIG_ETHERNET_LOCAL_IP2;
  dev->ip[3] = CONFIG_ETHERNET_LOCAL_IP3;

  // 子网掩码
  dev->netmask[0] = CONFIG_ETHERNET_NETMASK0;
  dev->netmask[1] = CONFIG_ETHERNET_NETMASK1;
  dev->netmask[2] = CONFIG_ETHERNET_NETMASK2;
  dev->netmask[3] = CONFIG_ETHERNET_NETMASK3;

  // 网关
  dev->gateway[0] = CONFIG_ETHERNET_GATEWAY0;
  dev->gateway[1] = CONFIG_ETHERNET_GATEWAY1;
  dev->gateway[2] = CONFIG_ETHERNET_GATEWAY2;
  dev->gateway[3] = CONFIG_ETHERNET_GATEWAY3;

  dev->dhcpstatus = 0; // 没有DHCP
}

// LWIP初始化(LWIP启动的时候使用)
uint8_t LWIPCommInit(void)
{
  struct netif *netif_init;           // 调用netif_add()函数时的返回值,用于判断网络初始化是否成功
  struct ip_addr ipaddr, netmask, gw; //ip地址  子网掩码  网关

  if(lwip_comm_mem_malloc())
  {
    return LWIP_COMM_STATUS_RAM_ERROR;  //内存申请失败
  }

  lwip_comm_default_ip_set(&lwip_dev);  //设置默认IP等信息

  LAN8720Init(); // 硬件网口初始化

  tcpip_init(NULL, NULL); // 初始化tcp ip内核,该函数里面会创建tcpip_thread内核任务

  IP4_ADDR(&ipaddr, lwip_dev.ip[0], lwip_dev.ip[1], lwip_dev.ip[2], lwip_dev.ip[3]);
  IP4_ADDR(&netmask, lwip_dev.netmask[0], lwip_dev.netmask[1], lwip_dev.netmask[2], lwip_dev.netmask[3]);
  IP4_ADDR(&gw, lwip_dev.gateway[0], lwip_dev.gateway[1], lwip_dev.gateway[2], lwip_dev.gateway[3]);

  printf("网卡en的MAC地址%d.%d.%d.%d.%d.%d\r\n", lwip_dev.mac[0], lwip_dev.mac[1], lwip_dev.mac[2], lwip_dev.mac[3], lwip_dev.mac[4], lwip_dev.mac[5]);
  printf("静态IP地址.....%d.%d.%d.%d\r\n", lwip_dev.ip[0], lwip_dev.ip[1], lwip_dev.ip[2], lwip_dev.ip[3]);
  printf("子网掩码.......%d.%d.%d.%d\r\n", lwip_dev.netmask[0], lwip_dev.netmask[1], lwip_dev.netmask[2], lwip_dev.netmask[3]);
  printf("默认网关.......%d.%d.%d.%d\r\n", lwip_dev.gateway[0], lwip_dev.gateway[1], lwip_dev.gateway[2], lwip_dev.gateway[3]);

  netif_init = netif_add(&lwip_netif, &ipaddr, &netmask, &gw, NULL, &ethernetif_init, &tcpip_input); // 向网卡列表中添加一个网口
  if(netif_init == NULL)
  {
    return LWIP_COMM_STATUS_NET_ADD_FAIL;  // 网卡添加失败
  }
  else // 网口添加成功后,设置netif为默认值,并且打开netif网口
  {
    netif_set_default(&lwip_netif); // 设置netif为默认网口
    netif_set_up(&lwip_netif);      // 打开netif网口
  }

  return LWIP_COMM_STATUS_OK; // OK.
}

// 用于以太网中断调用
void LWIPCommProcess(void)
{
  ethernetif_input(&lwip_netif);
}

ethernetif.c：

// 由ethernetif_init()调用用于初始化硬件
// netif:网卡结构体指针
// 返回值:ERR_OK,正常
//       其他,失败
static err_t low_level_init(struct netif *netif)
{
  netif->hwaddr_len = ETHARP_HWADDR_LEN; // 设置MAC地址长度,为6个字节
  // 初始化MAC地址,设置什么地址由用户自己设置,但是不能与网络中其他设备MAC地址重复
  netif->hwaddr[0] = lwip_dev.mac[0];
  netif->hwaddr[1] = lwip_dev.mac[1];
  netif->hwaddr[2] = lwip_dev.mac[2];
  netif->hwaddr[3] = lwip_dev.mac[3];
  netif->hwaddr[4] = lwip_dev.mac[4];
  netif->hwaddr[5] = lwip_dev.mac[5];
  netif->mtu = 1500; //最大允许传输单元,允许该网卡广播和ARP功能

  netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;

  HAL_ETH_DMATxDescListInit(&lan8720_dev.handle, lan8720_dev.dma_tx, lan8720_dev.tx_buffer, ETH_TXBUFNB); // 初始化发送描述符
  HAL_ETH_DMARxDescListInit(&lan8720_dev.handle, lan8720_dev.dma_rx, lan8720_dev.rx_buffer, ETH_RXBUFNB); // 初始化接收描述符
  HAL_ETH_Start(&lan8720_dev.handle); // 开启MAC和DMA

  return ERR_OK;
}

// 用于发送数据包的最底层函数(lwip通过netif->linkoutput指向该函数)
// netif:网卡结构体指针
// p:pbuf数据结构体指针
// 返回值:ERR_OK,发送正常
//       ERR_MEM,发送失败
static err_t low_level_output(struct netif *netif, struct pbuf *p)
{
  err_t errval;
  struct pbuf *q;
  uint8_t *buffer = (uint8_t *)(lan8720_dev.handle.TxDesc->Buffer1Addr);
  __IO ETH_DMADescTypeDef *DmaTxDesc;
  uint32_t framelength = 0;
  uint32_t bufferoffset = 0;
  uint32_t byteslefttocopy = 0;
  uint32_t payloadoffset = 0;

  DmaTxDesc = lan8720_dev.handle.TxDesc;
  bufferoffset = 0;

  // 从pbuf中拷贝要发送的数据
  for(q = p; q != NULL; q = q->next)
  {
    // 判断此发送描述符是否有效，即判断此发送描述符是否归以太网DMA所有
    if((DmaTxDesc->Status & ETH_DMATXDESC_OWN) != (uint32_t)RESET)
    {
      errval = ERR_USE;
      goto error;              // 发送描述符无效，不可用
    }
    byteslefttocopy = q->len;   // 要发送的数据长度
    payloadoffset = 0;

    // 将pbuf中要发送的数据写入到以太网发送描述符中，有时候我们要发送的数据可能大于一个以太网
    // 描述符的Tx Buffer，因此我们需要分多次将数据拷贝到多个发送描述符中
    while((byteslefttocopy + bufferoffset) > ETH_TX_BUF_SIZE )
    {
      // 将数据拷贝到以太网发送描述符的Tx Buffer中
      memcpy((uint8_t*)((uint8_t*)buffer + bufferoffset), (uint8_t*)((uint8_t*)q->payload + payloadoffset), (ETH_TX_BUF_SIZE - bufferoffset));
      // DmaTxDsc指向下一个发送描述符
      DmaTxDesc = (ETH_DMADescTypeDef *)(DmaTxDesc->Buffer2NextDescAddr);
      // 检查新的发送描述符是否有效
      if((DmaTxDesc->Status & ETH_DMATXDESC_OWN) != (uint32_t)RESET)
      {
        errval = ERR_USE;
        goto error;     // 发送描述符无效，不可用
      }
      buffer = (uint8_t *)(DmaTxDesc->Buffer1Addr); // 更新buffer地址，指向新的发送描述符的Tx Buffer
      byteslefttocopy = byteslefttocopy - (ETH_TX_BUF_SIZE - bufferoffset);
      payloadoffset = payloadoffset + (ETH_TX_BUF_SIZE - bufferoffset);
      framelength = framelength + (ETH_TX_BUF_SIZE - bufferoffset);
      bufferoffset = 0;
    }
    // 拷贝剩余的数据
    memcpy( (uint8_t*)((uint8_t*)buffer + bufferoffset), (uint8_t*)((uint8_t*)q->payload + payloadoffset), byteslefttocopy );
    bufferoffset = bufferoffset + byteslefttocopy;
    framelength = framelength + byteslefttocopy;
  }
  // 当所有要发送的数据都放进发送描述符的Tx Buffer以后就可发送此帧了
  HAL_ETH_TransmitFrame(&lan8720_dev.handle, framelength);
  errval = ERR_OK;
error:
  // 发送缓冲区发生下溢，一旦发送缓冲区发生下溢TxDMA会进入挂起状态
  if((lan8720_dev.handle.Instance->DMASR & ETH_DMASR_TUS) != (uint32_t)RESET)
  {
    // 清除下溢标志
    lan8720_dev.handle.Instance->DMASR = ETH_DMASR_TUS;
    // 当发送帧中出现下溢错误的时候TxDMA会挂起，这时候需要向DMATPDR寄存器
    // 随便写入一个值来将其唤醒，此处我们写0
    lan8720_dev.handle.Instance->DMATPDR = 0;
  }
  return errval;
}

// 用于接收数据包的最底层函数
// neitif:网卡结构体指针
// 返回值:pbuf数据结构体指针
static struct pbuf * low_level_input(struct netif *netif)
{
  struct pbuf *p = NULL;
  struct pbuf *q;
  uint16_t len;
  uint8_t *buffer;
  __IO ETH_DMADescTypeDef *dmarxdesc;
  uint32_t bufferoffset = 0;
  uint32_t payloadoffset = 0;
  uint32_t byteslefttocopy = 0;
  uint32_t i = 0;

  if(HAL_ETH_GetReceivedFrame(&lan8720_dev.handle) != HAL_OK) // 判断是否接收到数据
  {
    return NULL;
  }

  len = lan8720_dev.handle.RxFrameInfos.length;               // 获取接收到的以太网帧长度
  buffer = (uint8_t *)lan8720_dev.handle.RxFrameInfos.buffer; // 获取接收到的以太网帧的数据buffer

  if(len > 0)
  {
    p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);  // 申请pbuf
  }
  if(p != NULL)                                // pbuf申请成功
  {
    dmarxdesc = lan8720_dev.handle.RxFrameInfos.FSRxDesc;  // 获取接收描述符链表中的第一个描述符
    bufferoffset = 0;
    for(q = p; q != NULL; q = q->next)
    {
      byteslefttocopy = q->len;
      payloadoffset = 0;
      // 将接收描述符中Rx Buffer的数据拷贝到pbuf中
      while((byteslefttocopy + bufferoffset) > ETH_RX_BUF_SIZE )
      {
        // 将数据拷贝到pbuf中
        memcpy((uint8_t*)((uint8_t*)q->payload + payloadoffset), (uint8_t*)((uint8_t*)buffer + bufferoffset), (ETH_RX_BUF_SIZE - bufferoffset));
        // dmarxdesc向下一个接收描述符
        dmarxdesc = (ETH_DMADescTypeDef *)(dmarxdesc->Buffer2NextDescAddr);
        // 更新buffer地址，指向新的接收描述符的Rx Buffer
        buffer = (uint8_t *)(dmarxdesc->Buffer1Addr);

        byteslefttocopy = byteslefttocopy - (ETH_RX_BUF_SIZE - bufferoffset);
        payloadoffset = payloadoffset + (ETH_RX_BUF_SIZE - bufferoffset);
        bufferoffset = 0;
      }
      // 拷贝剩余的数据
      memcpy((uint8_t*)((uint8_t*)q->payload + payloadoffset), (uint8_t*)((uint8_t*)buffer + bufferoffset), byteslefttocopy);
      bufferoffset = bufferoffset + byteslefttocopy;
    }
  }
  // 释放DMA描述符
  dmarxdesc = lan8720_dev.handle.RxFrameInfos.FSRxDesc;
  for(i = 0; i < lan8720_dev.handle.RxFrameInfos.SegCount; i++)
  {
    dmarxdesc->Status |= ETH_DMARXDESC_OWN;     //标记描述符归DMA所有
    dmarxdesc = (ETH_DMADescTypeDef *)(dmarxdesc->Buffer2NextDescAddr);
  }
  lan8720_dev.handle.RxFrameInfos.SegCount = 0;          //清除段计数器
  if((lan8720_dev.handle.Instance->DMASR & ETH_DMASR_RBUS) != (uint32_t)RESET) //接收缓冲区不可用
  {
    // 清除接收缓冲区不可用标志
    lan8720_dev.handle.Instance->DMASR = ETH_DMASR_RBUS;
    // 当接收缓冲区不可用的时候RxDMA会进去挂起状态，通过向DMARPDR写入任意一个值来唤醒Rx DMA
    lan8720_dev.handle.Instance->DMARPDR = 0;
  }
  return p;
}

// 网卡接收数据(lwip直接调用)
// netif:网卡结构体指针
// 返回值:ERR_OK,发送正常
//       ERR_MEM,发送失败
err_t ethernetif_input(struct netif *netif)
{
  err_t err;
  struct pbuf *p;
  p = low_level_input(netif); //调用low_level_input函数接收数据
  if(p == NULL)
  {
    return ERR_MEM;
  }
  err = netif->input(p, netif); //调用netif结构体中的input字段(一个函数)来处理数据包
  if(err != ERR_OK)
  {
    LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: IP input error\n"));
    pbuf_free(p);
    p = NULL;
  }
  return err;
}

// 使用low_level_init()函数来初始化网络
// netif:网卡结构体指针
// 返回值:ERR_OK,正常
//       其他,失败
err_t ethernetif_init(struct netif *netif)
{
  LWIP_ASSERT("netif!=NULL", (netif != NULL));
#if LWIP_NETIF_HOSTNAME     // LWIP_NETIF_HOSTNAME 
  netif->hostname = "lwip"; // 初始化名称
#endif
  netif->name[0] = IFNAME0; // 初始化变量netif的name字段
  netif->name[1] = IFNAME1; // 在文件外定义这里不用关心具体值
  netif->output = etharp_output; // IP层发送数据包函数
  netif->linkoutput = low_level_output; // ARP模块发送数据包函数
  low_level_init(netif);    // 底层硬件初始化函数
  return ERR_OK;
}

TCP客户端实现：

#ifndef _LWIP_TCP_CLIENT_H_
#define _LWIP_TCP_CLIENT_H_


void TCPClientProcess(void);

void TCPClientSend(uint8_t *data, uint16_t length);

#endif /* _LWIP_TCP_CLIENT_H_ */

TaskHandle_t os_tcp_handle;

#define TCP_CLIENT_RX_BUFSIZE 1500  // 接收缓冲区长度

typedef struct
{
  struct netconn *sockfd; // TCP CLIENT网络连接结构体
  err_t connect_err;
  err_t recv_err;
  err_t send_err;

  // 服务器IP和端口
  ip_addr_t server_ipaddr;
  uint16_t server_port;

  // 客户端IP和端口
  ip_addr_t loca_ipaddr;
  uint16_t loca_port;

  uint8_t state; // 网络连接的状态

	uint8_t recv_buf[TCP_CLIENT_RX_BUFSIZE];
	uint16_t recv_len;
} tcp_client_t;

static tcp_client_t tcp_client;

static void tcp_client_close(void)
{
  netconn_close(tcp_client.sockfd);
  netconn_delete(tcp_client.sockfd);
  printf("服务器	%d.%d.%d.%d断开连接 \r\n", lwip_dev.remoteip[0], lwip_dev.remoteip[1], lwip_dev.remoteip[2], lwip_dev.remoteip[3]);
}

static void tcp_client_recv(void)
{
  struct netbuf *recvbuf;
  struct pbuf *q;

  while(1)
  {
    tcp_client.recv_err = netconn_recv(tcp_client.sockfd, &recvbuf);

    if(tcp_client.recv_err == ERR_OK) //接收到数据
    {
      taskENTER_CRITICAL();

			tcp_client.recv_len = 0;

      for(q = recvbuf->p; q != NULL; q = q->next) // 遍历完整个pbuf链表
      {
        printf(" %d ...  \r\n", q->len);
        memcpy(tcp_client.recv_buf + tcp_client.recv_len, q->payload, q->len);

        tcp_client.recv_len += q->len;
      }
      taskEXIT_CRITICAL();

			LWIPParse(tcp_client.recv_buf, tcp_client.recv_len);
			
      netbuf_delete(recvbuf);
    }
    else if(tcp_client.recv_err == ERR_CLSD)   //关闭连接
    {
      tcp_client_close();
      break;
    }

    // 网线断掉 删除连接
    tcp_client.state = LAN8720ReadPHY(PHY_BSR);
    if((tcp_client.state & 0x04) == 0)
    {
      printf("close\r\n");
      tcp_client_close();
      break;
    }
  }
}

static void task_tcp_client(void *arg)
{
  tcp_client.server_port = CONFIG_ETHERNET_REMOTE_PORT;
  IP4_ADDR(&tcp_client.server_ipaddr, lwip_dev.remoteip[0], lwip_dev.remoteip[1], lwip_dev.remoteip[2], lwip_dev.remoteip[3]);

  while (1)
  {
	tcp_client.sockfd = netconn_new(NETCONN_TCP); // 创建一个TCP链接
		
	tcp_client.connect_err = netconn_connect(tcp_client.sockfd, &tcp_client.server_ipaddr, tcp_client.server_port); //连接服务器
		
	if(tcp_client.connect_err != ERR_OK)
	{
	  netconn_delete(tcp_client.sockfd); // 删除tcp_clientconn连接
	}
	else
	{
	  tcp_client.sockfd->recv_timeout = 5;
	  netconn_getaddr(tcp_client.sockfd, &tcp_client.loca_ipaddr, &tcp_client.loca_port, 1); // 获取本地IP主机IP地址和端口号
	  printf("连接上服务器: %d.%d.%d.%d, 本机端口:%d\r\n", lwip_dev.remoteip[0], lwip_dev.remoteip[1], lwip_dev.remoteip[2], lwip_dev.remoteip[3], tcp_client.loca_port);
		
	  tcp_client_recv();
	}
  }
}

void TCPClientProcess(void)
{
  LWIPCommInit();

  xTaskCreate((TaskFunction_t)task_tcp_client,
              (const char*  )"tcp_client_task",
              (uint16_t     )OS_TCP_STK_SIZE,
              (void*        )NULL,
              (UBaseType_t  )OS_PRIO_TCP,
              (TaskHandle_t*)&os_tcp_handle);
}

void TCPClientSend(uint8_t *data, uint16_t length)
{
  tcp_client.send_err = netconn_write(tcp_client.sockfd, data, length, NETCONN_COPY); //发送数据
  if(tcp_client.send_err != ERR_OK)
  {
    printf("发送失败\r\n");
    tcp_client_close();
  }
}