lwip  建议不要使能 硬件校验 CHECKSUM_BY_HARDWARE 使用软件建议 在测试 LAN8720  ping  时硬件的检验 大包会PING不通的 #define ETH_MAX_PACKET_SIZE    1524 默认的1524字节 ping 1472 以上就不回复了( 例子 ping 192.168.1.1 -t -l 2048)

 且 lwip  + EC20 PPP拨号是不能使用硬件检验的

操作系统接口已经抽象出来(创建任务 信号量) 不一定是FreeRTOS ucos 也是一样的 lwip的操作系统接口（FreeRTOS ） sys_arch.c 官方文档已经提供了

u8 LAN8720_Init(void)
{
    u8 rval=0;
    GPIO_InitTypeDef GPIO_InitStructure;
  
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA|RCC_AHB1Periph_GPIOC|RCC_AHB1Periph_GPIOG|RCC_AHB1Periph_GPIOD, ENABLE);//使能GPIO时钟 RMII接口
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);   //使能SYSCFG时钟
  
    SYSCFG_ETH_MediaInterfaceConfig(SYSCFG_ETH_MediaInterface_RMII); //MAC和PHY之间使用RMII接口

/*网络引脚设置 RMII接口
      ETH_MDIO -------------------------> PA2
      ETH_MDC --------------------------> PC1
      ETH_RMII_REF_CLK------------------> PA1
      ETH_RMII_CRS_DV ------------------> PA7
      ETH_RMII_RXD0 --------------------> PC4
      ETH_RMII_RXD1 --------------------> PC5
      ETH_RMII_TX_EN -------------------> PG11
      ETH_RMII_TXD0 --------------------> PG13
      ETH_RMII_TXD1 --------------------> PG14
      ETH_RESET-------------------------> PD3*/
                    
      //配置PA1 PA2 PA7
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_7;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;  
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource1, GPIO_AF_ETH); //引脚复用到网络接口上
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource2, GPIO_AF_ETH);
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_ETH);

//配置PC1,PC4 and PC5
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_4 | GPIO_Pin_5;
    GPIO_Init(GPIOC, &GPIO_InitStructure);
    GPIO_PinAFConfig(GPIOC, GPIO_PinSource1, GPIO_AF_ETH); //引脚复用到网络接口上
    GPIO_PinAFConfig(GPIOC, GPIO_PinSource4, GPIO_AF_ETH);
    GPIO_PinAFConfig(GPIOC, GPIO_PinSource5, GPIO_AF_ETH);
                                
    //配置PG11, PG14 and PG13 
    GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_11 | GPIO_Pin_13 | GPIO_Pin_14;
    GPIO_Init(GPIOG, &GPIO_InitStructure);
    GPIO_PinAFConfig(GPIOG, GPIO_PinSource11, GPIO_AF_ETH);
    GPIO_PinAFConfig(GPIOG, GPIO_PinSource13, GPIO_AF_ETH);
    GPIO_PinAFConfig(GPIOG, GPIO_PinSource14, GPIO_AF_ETH);
    
    //配置PD3为推完输出
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;    //推完输出
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;  
    GPIO_Init(GPIOD, &GPIO_InitStructure);
    
    GPIO_ResetBits(GPIOD,GPIO_Pin_3);                    //硬件复位LAN8720
    HAL_msleep(50);    
    GPIO_SetBits(GPIOD,GPIO_Pin_3);                         //复位结束 
    ETHERNET_NVICConfiguration();    //设置中断优先级
    rval=ETH_MACDMA_Config();        //配置MAC及DMA
    return !rval;                    //ETH的规则为:0,失败;1,成功;所以要取反一下 
}

//以太网中断分组配置 
void ETHERNET_NVICConfiguration(void)
{
    NVIC_InitTypeDef NVIC_InitStructure;

//configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY    5                       //系统可管理的最高中断优先级
    //在FreeRTOS 中中断优先级必须低于configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY 才能使用系统调用(信号量邮箱互斥量等)
    NVIC_InitStructure.NVIC_IRQChannel = ETH_IRQn;  //以太网中断
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY+1;  //中断寄存器组2最高优先级
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0X00;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
}

初始化ETH MAC层及DMA配置

u8 ETH_MACDMA_Config(void)
{
    u8 rval;
    uint32_t timeout = 0;
    ETH_InitTypeDef ETH_InitStructure; 
    
    //使能以太网MAC以及MAC接收和发送时钟
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_ETH_MAC | RCC_AHB1Periph_ETH_MAC_Tx |RCC_AHB1Periph_ETH_MAC_Rx, ENABLE);
                        
    ETH_DeInit();                                  //AHB总线重启以太网
    ETH_SoftwareReset();                          //软件重启网络
    while (ETH_GetSoftwareResetStatus() == SET)//等待软件重启网络完成 
    {
        HAL_msleep(50);
        timeout++;
        set_netifstate_resterror(timeout > 3);
    }
    set_netifstate_resterror(0);
    ETH_StructInit(&ETH_InitStructure);          //初始化网络为默认值

///网络MAC参数设置 
       ETH_InitStructure.ETH_Mode =ETH_Mode_FullDuplex;
    ETH_InitStructure.ETH_Speed = ETH_Speed_10M;
    ETH_InitStructure.ETH_AutoNegotiation = ETH_AutoNegotiation_Enable;               //开启网络自适应功能
    ETH_InitStructure.ETH_LoopbackMode = ETH_LoopbackMode_Disable;                    //关闭反馈
    ETH_InitStructure.ETH_RetryTransmission = ETH_RetryTransmission_Disable;         //关闭重传功能
    ETH_InitStructure.ETH_AutomaticPadCRCStrip = ETH_AutomaticPadCRCStrip_Disable;     //关闭自动去除PDA/CRC功能 
    ETH_InitStructure.ETH_ReceiveAll = ETH_ReceiveAll_Disable;                        //关闭接收所有的帧
    ETH_InitStructure.ETH_BroadcastFramesReception = ETH_BroadcastFramesReception_Enable;//允许接收所有广播帧
    ETH_InitStructure.ETH_PromiscuousMode = ETH_PromiscuousMode_Disable;            //关闭混合模式的地址过滤  
    ETH_InitStructure.ETH_MulticastFramesFilter = ETH_MulticastFramesFilter_Perfect;//对于组播地址使用完美地址过滤   
    ETH_InitStructure.ETH_UnicastFramesFilter = ETH_UnicastFramesFilter_Perfect;    //对单播地址使用完美地址过滤 
#ifdef CHECKSUM_BY_HARDWARE
    ETH_InitStructure.ETH_ChecksumOffload = ETH_ChecksumOffload_Enable;             //开启ipv4和TCP/UDP/ICMP的帧校验和卸载   
#endif
    //当我们使用帧校验和卸载功能的时候，一定要使能存储转发模式,存储转发模式中要保证整个帧存储在FIFO中,
    //这样MAC能插入/识别出帧校验值,当真校验正确的时候DMA就可以处理帧,否则就丢弃掉该帧
    ETH_InitStructure.ETH_DropTCPIPChecksumErrorFrame = ETH_DropTCPIPChecksumErrorFrame_Enable; //开启丢弃TCP/IP错误帧
    ETH_InitStructure.ETH_ReceiveStoreForward = ETH_ReceiveStoreForward_Enable;     //开启接收数据的存储转发模式    
    ETH_InitStructure.ETH_TransmitStoreForward = ETH_TransmitStoreForward_Enable;   //开启发送数据的存储转发模式

ETH_InitStructure.ETH_ForwardErrorFrames = ETH_ForwardErrorFrames_Disable;         //禁止转发错误帧  
    ETH_InitStructure.ETH_ForwardUndersizedGoodFrames = ETH_ForwardUndersizedGoodFrames_Disable;    //不转发过小的好帧 
    ETH_InitStructure.ETH_SecondFrameOperate = ETH_SecondFrameOperate_Enable;          //打开处理第二帧功能
    ETH_InitStructure.ETH_AddressAlignedBeats = ETH_AddressAlignedBeats_Enable;      //开启DMA传输的地址对齐功能
    ETH_InitStructure.ETH_FixedBurst = ETH_FixedBurst_Enable;                        //开启固定突发功能    
    ETH_InitStructure.ETH_RxDMABurstLength = ETH_RxDMABurstLength_32Beat;             //DMA发送的最大突发长度为32个节拍   
    ETH_InitStructure.ETH_TxDMABurstLength = ETH_TxDMABurstLength_32Beat;            //DMA接收的最大突发长度为32个节拍
    ETH_InitStructure.ETH_DMAArbitration = ETH_DMAArbitration_RoundRobin_RxTx_2_1;
    rval=ETH_Init(&ETH_InitStructure,LAN8720_PHY_ADDRESS);        //配置ETH
    if(rval==ETH_SUCCESS)//配置成功
    {
        ETH_DMAITConfig(ETH_DMA_IT_NIS|ETH_DMA_IT_R,ENABLE);      //使能以太网接收中断    
    }
    return rval;
}

//以太网DMA接收中断服务函数
void ETH_IRQHandler(void)
{
     ENTER_CRITICAL_FROM_ISR_DATA();
      ENTER_CRITICAL_FROM_ISR();//进入临界区
    
    if(ETH_GetDMAFlagStatus(ETH_DMA_FLAG_R))//(ETH_GetRxPktSize(DMARxDescToGet)!=0)     //检测是否收到数据包
    { 
        lwip_pkt_handle();    
        ETH_DMAClearITPendingBit(ETH_DMA_IT_R);     //清除DMA中断标志位
    }
    ETH_DMAClearITPendingBit(ETH_DMA_IT_NIS);    //清除DMA接收中断标志位
    EXIT_CRITICAL_FROM_ISR();//退出临界区
}

LAN8720 中断调用 lwip_pkt_handle 函数释放计数信号量 唤醒数据读取任务

//计数型信号量句柄
static   HAL_Sem_t  s_xSemaphore;//计数型信号量

//用于以太网中断调用
void lwip_pkt_handle(void)
{
     HAL_OSSemGiveFromISR(&s_xSemaphore); //释放计数信号量
    //ethernetif_input(&lwip_netif);
}

ethernetif_input_task 数据输入task 等待 s_xSemaphore

extern struct pbuf * low_level_input(struct netif *netif);
void ethernetif_input_task(void *para)
{
    struct pbuf *p;
    struct netif *netif =&lwip_netif;
    ENTER_CRITICAL_DATA();
    while(1)
    {
      if(HAL_OSSemTake( &s_xSemaphore, ALWAYS_WAITE ) == RETURN_OK)
      {
        /* move received packet into a new pbuf */
        ENTER_CRITICAL();//进入临界区
  TRY_GET_NEXT_FRAGMENT:
        p = low_level_input(netif);
        EXIT_CRITICAL();//退出临界区
        /* points to packet payload, which starts with an Ethernet header */
        if(p != NULL)
        {
          ENTER_CRITICAL();
          /* full packet send to tcpip_thread to process */
          if (netif->input(p, netif) != ERR_OK)
          {
            LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: IP input error\n"));
            pbuf_free(p);
            p = NULL;
          }
          else
          {
            HAL_OSSemTryTake( &s_xSemaphore); //尝试拿一次如果获取到数据不需要被重新换新(xSemaphoreTake( s_xSemaphore, portMAX_DELAY ) == pdTRUE)
            goto TRY_GET_NEXT_FRAGMENT;    //去获取数据
          }
          EXIT_CRITICAL();
        }
      }
    }
}

lwip_comm_init 主要是初始化 LAN8720， 创建读取任务ethernetif_input_task， 初始化tcp ip内核，网卡添加，打开netif网口等操作

//回调函数

void netif_status_callback(struct netif *netif)
{
    volatile uint8_t ctx = 0;
    ctx=0;
}

void netif_link_callback(struct netif *netif)
{
    volatile uint8_t ctx = 0;
    ctx=0;
}

void netif_remove_callback(struct netif *netif)
{
    volatile uint8_t ctx = 0;
    ctx=0;
}

u8 lwip_comm_init(int nDHCP)
{
    struct netif *Netif_Init_Flag;        //调用netif_add()函数时的返回值,用于判断网络初始化是否成功
    ip_addr_t ipaddr;              //ip地址
    ip_addr_t netmask;             //子网掩码
    ip_addr_t gw;                  //默认网关 
    
    //创建计数型信号量，最大值255，初始值0
    HAL_OSSemCreate(&s_xSemaphore,0); //创建计数信号量
    sys_thread_new("ethernetif_input_task", ethernetif_input_task, NULL , 512, LWIP_GETDATA_TASK_PRIO);
    lwip_comm_default_ip_set(&lwipdev);    //设置默认IP等信息
    while(LAN8720_Init())        //初始化LAN8720失败 
    {
        if(!(ETH_ReadPHYRegister(LAN8720_PHY_ADDRESS, PHY_BSR) & PHY_Linked_Status))
        {
            //没插网线
            lwipdev.netifstate=LWIP_ININ_ERROR_NOLINK;
        }
        else
        {
            lwipdev.netifstate=LWIP_ININ_ERROR_HW;
        }
        sys_msleep(1000);
    }
    lwipdev.netifstate=0x00;
    
    tcpip_init(NULL,NULL);                //初始化tcp ip内核,该函数里面会创建tcpip_thread内核任务
    netif_set_status_callback(&lwip_netif, netif_status_callback);//注册回调函数
    netif_set_link_callback(&lwip_netif, netif_link_callback);//注册回调函数
    netif_set_remove_callback(&lwip_netif, netif_remove_callback);
#if LWIP_DHCP        //使用动态IP
    if(nDHCP)
    {
        ipaddr.addr = 0;
        netmask.addr = 0;
        gw.addr = 0;
    }
    else
#endif
    {
        //使用静态IP
        IP4_ADDR(&ipaddr,lwipdev.ip[0],lwipdev.ip[1],lwipdev.ip[2],lwipdev.ip[3]);
        IP4_ADDR(&netmask,lwipdev.netmask[0],lwipdev.netmask[1] ,lwipdev.netmask[2],lwipdev.netmask[3]);
        IP4_ADDR(&gw,lwipdev.gateway[0],lwipdev.gateway[1],lwipdev.gateway[2],lwipdev.gateway[3]);
        #if LWIP_DNS
        ip_addr_t dnsserver;
        IP4_ADDR(&dnsserver,114,114,114,114);
        dns_setserver(0, &dnsserver);
        IP4_ADDR(&dnsserver,208,67,222,222);
        dns_setserver(1, &dnsserver);
        #endif
    }
    Netif_Init_Flag=netif_add(&lwip_netif,&ipaddr,&netmask,&gw,NULL,&ethernetif_init,&tcpip_input);//向网卡列表中添加一个网口
    if(Netif_Init_Flag==NULL)//网卡添加失败 
    {
        while(1)
        {
            lwipdev.netifstate=LWIP_ININ_ERROR_ADD;
            sys_msleep(1000);
        }
    }
    else//网口添加成功后,设置netif为默认值,并且打开netif网口
    {
        netif_set_default(&lwip_netif); //设置netif为默认网口
        netif_set_up(&lwip_netif);        //打开netif网口
    }
    lwip_comm_GetMac(lwip_netif.hwaddr);
#if LWIP_DHCP
    if(nDHCP)
    {
        DHCP_Task();
    }
#endif 
    //创建检测进程
    sys_thread_new("dhcp_thread", lwip_check_task,  NULL, 512, LWIP_CHECK_TASK_PRIO);
    return 0;//操作OK.
}

//如果使能了DHCP
#if LWIP_DHCP

void DHCP_Task(void)
{
    u32 ip=0,netmask=0,gw=0,tries=0;
    
    dhcp_start(&lwip_netif);//开启DHCP 
    lwipdev.dhcpstatus=0;    //正在DHCP
    while(1)
    { 
        ip=lwip_netif.ip_addr.addr;        //读取新IP地址
        netmask=lwip_netif.netmask.addr;//读取子网掩码
        gw=lwip_netif.gw.addr;            //读取默认网关 
        if(ip!=0)                       //当正确读取到IP地址的时候
        {
            lwipdev.dhcpstatus=2;    //DHCP成功
             //解析出通过DHCP获取到的IP地址
            lwipdev.ip[3]=(uint8_t)(ip>>24); 
            lwipdev.ip[2]=(uint8_t)(ip>>16);
            lwipdev.ip[1]=(uint8_t)(ip>>8);
            lwipdev.ip[0]=(uint8_t)(ip);
            
            //解析通过DHCP获取到的子网掩码地址
            lwipdev.netmask[3]=(uint8_t)(netmask>>24);
            lwipdev.netmask[2]=(uint8_t)(netmask>>16);
            lwipdev.netmask[1]=(uint8_t)(netmask>>8);
            lwipdev.netmask[0]=(uint8_t)(netmask);
            //解析出通过DHCP获取到的默认网关
            lwipdev.gateway[3]=(uint8_t)(gw>>24);
            lwipdev.gateway[2]=(uint8_t)(gw>>16);
            lwipdev.gateway[1]=(uint8_t)(gw>>8);
            lwipdev.gateway[0]=(uint8_t)(gw);
            
            break;

}
        else if(tries > LWIP_MAX_DHCP_TRIES) //通过DHCP服务获取IP地址失败,且超过最大尝试次数
        {  
            dhcp_stop(&lwip_netif);         //关闭DHCP
            lwipdev.dhcpstatus=0XFF;//DHCP失败.
            //使用静态IP地址
            IP4_ADDR(&(lwip_netif.ip_addr),lwipdev.ip[0],lwipdev.ip[1],lwipdev.ip[2],lwipdev.ip[3]);
            IP4_ADDR(&(lwip_netif.netmask),lwipdev.netmask[0],lwipdev.netmask[1],lwipdev.netmask[2],lwipdev.netmask[3]);
            IP4_ADDR(&(lwip_netif.gw),lwipdev.gateway[0],lwipdev.gateway[1],lwipdev.gateway[2],lwipdev.gateway[3]);

#if LWIP_DNS
            ip_addr_t dnsserver;
            IP4_ADDR(&dnsserver,114,114,114,114);
            dns_setserver(0, &dnsserver);
            IP4_ADDR(&dnsserver,208,67,222,222);
            dns_setserver(1, &dnsserver);
            #endif

break;
        }  
        sys_msleep(1000); //延时1000
        tries++;
    }

}

//lwip_check_task 检查网线插拔的情况

void lwip_check_task(void *pdata)
{
    pdata = pdata;
    while(1)
    { 
        sys_msleep(1000); //延时1000ms
        if(!(ETH_ReadPHYRegister(LAN8720_PHY_ADDRESS, PHY_BSR) & PHY_Linked_Status))
        {
            if(netif_is_link_up(&lwip_netif))
            {
                netif_set_link_down(&lwip_netif);
            }
            lwipdev.netifstate=LWIP_ININ_ERROR_NOLINK;//没插网线
        }
        else
        {
            if(!netif_is_link_up(&lwip_netif))
            {
                netif_set_link_up(&lwip_netif);
            }
            lwipdev.netifstate=0x00;
        }
    }
}

ethernetif_init 的底层初始化

/* Ethernet Rx & Tx DMA Descriptors */
extern ETH_DMADESCTypeDef  DMARxDscrTab[ETH_RXBUFNB], DMATxDscrTab[ETH_TXBUFNB];

/* Ethernet Driver Receive buffers  */
extern uint8_t Rx_Buff[ETH_RXBUFNB][ETH_RX_BUF_SIZE]; 

/* Ethernet Driver Transmit buffers */
extern uint8_t Tx_Buff[ETH_TXBUFNB][ETH_TX_BUF_SIZE]; 

/* Global pointers to track current transmit and receive descriptors */
extern ETH_DMADESCTypeDef  *DMATxDescToSet;
extern ETH_DMADESCTypeDef  *DMARxDescToGet;

/* Global pointer for last received frame infos */
extern ETH_DMA_Rx_Frame_infos *DMA_RX_FRAME_infos;

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;
}

low_level_init 底层初始化函数

static err_t low_level_init(struct netif *netif)
{
#ifdef CHECKSUM_BY_HARDWARE
    int i; 
#endif 
    
    netif->hwaddr_len = ETHARP_HWADDR_LEN; //设置MAC地址长度,为6个字节
    //初始化MAC地址,设置什么地址由用户自己设置,但是不能与网络中其他设备MAC地址重复
    netif->hwaddr[0]=1; 
    netif->hwaddr[1]=2; 
    netif->hwaddr[2]=3;
    netif->hwaddr[3]=4;
    netif->hwaddr[4]=5;
    netif->hwaddr[5]=6;
    
    netif->mtu=1500; //最大允许传输单元,允许该网卡广播和ARP功能
    //并且该网卡允许有硬件链路连接
    netif->flags = NETIF_FLAG_BROADCAST|NETIF_FLAG_ETHARP|NETIF_FLAG_LINK_UP;
    
    ETH_MACAddressConfig(ETH_MAC_Address0, netif->hwaddr); //向STM32F4的MAC地址寄存器中写入MAC地址
    ETH_DMATxDescChainInit(DMATxDscrTab, &Tx_Buff[0][0], ETH_TXBUFNB);
    ETH_DMARxDescChainInit(DMARxDscrTab, &Rx_Buff[0][0], ETH_RXBUFNB);
#ifdef CHECKSUM_BY_HARDWARE     //使用硬件帧校验
    for(i=0;i<ETH_TXBUFNB;i++)    //使能TCP,UDP和ICMP的发送帧校验,TCP,UDP和ICMP的接收帧校验在DMA中配置了
    {
        ETH_DMATxDescChecksumInsertionConfig(&DMATxDscrTab[i], ETH_DMATxDesc_ChecksumTCPUDPICMPFull);
    }
#endif
    ETH_Start(); //开启MAC和DMA                
    return ERR_OK;
}

low_level_input 以太网数据读取函数

struct pbuf * low_level_input(struct netif *netif)
{
  struct pbuf *p = NULL;
  struct pbuf *q = NULL;
  uint16_t len = 0;
  uint8_t *buffer;
  __IO ETH_DMADESCTypeDef *dmarxdesc;
  FrameTypeDef frame;
  uint32_t bufferoffset = 0;
  uint32_t payloadoffset = 0;
  uint32_t byteslefttocopy = 0;
  uint32_t i=0;
  
  
  /* get received frame */
  if (!ETH_CheckFrameReceived())
  {
      return NULL;
  }
  
  /* Obtain the size of the packet and put it into the "len" variable. */
  frame=ETH_Get_Received_Frame();
  len = frame.length;
  buffer = (uint8_t *)frame.buffer;
  
  if (len > 0)
  {
    /* We allocate a pbuf chain of pbufs from the Lwip buffer pool */
    p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);
  }
  
  if (p != NULL)
  {
    if (DMA_RX_FRAME_infos->Seg_Count >1)
   {
       dmarxdesc = DMA_RX_FRAME_infos->FS_Rx_Desc ;
   }
   else
   {
    dmarxdesc = frame.descriptor;
   }
   
    bufferoffset = 0;
    for(q = p; q != NULL; q = q->next)
    {
      byteslefttocopy = q->len;
      payloadoffset = 0;
      
      /* Check if the length of bytes to copy in current pbuf is bigger than Rx buffer size*/
      while( (byteslefttocopy + bufferoffset) > ETH_RX_BUF_SIZE )
      {
        /* Copy data to pbuf */
        memcpy( (uint8_t*)((uint8_t*)q->payload + payloadoffset), (uint8_t*)((uint8_t*)buffer + bufferoffset), (ETH_RX_BUF_SIZE - bufferoffset));
        
        /* Point to next descriptor */
        dmarxdesc = (ETH_DMADESCTypeDef *)(dmarxdesc->Buffer2NextDescAddr);
        buffer = (uint8_t *)(dmarxdesc->Buffer1Addr);
        
        byteslefttocopy = byteslefttocopy - (ETH_RX_BUF_SIZE - bufferoffset);
        payloadoffset = payloadoffset + (ETH_RX_BUF_SIZE - bufferoffset);
        bufferoffset = 0;
      }
      /* Copy remaining data in pbuf */
      memcpy( (uint8_t*)((uint8_t*)q->payload + payloadoffset), (uint8_t*)((uint8_t*)buffer + bufferoffset), byteslefttocopy);
      bufferoffset = bufferoffset + byteslefttocopy;
    }
  }  
  
    /* Release descriptors to DMA */
    /* Point to first descriptor */
   if (DMA_RX_FRAME_infos->Seg_Count >1)
   {
       dmarxdesc = DMA_RX_FRAME_infos->FS_Rx_Desc ;
   }
   else
   {
    dmarxdesc = frame.descriptor;
   }
    
    /* Set Own bit in Rx descriptors: gives the buffers back to DMA */
    for (i=0; i< DMA_RX_FRAME_infos->Seg_Count; i++)
    {  
      dmarxdesc->Status |= ETH_DMARxDesc_OWN;
      dmarxdesc = (ETH_DMADESCTypeDef *)(dmarxdesc->Buffer2NextDescAddr);
    }
    
    /* Clear Segment_Count */
    DMA_RX_FRAME_infos->Seg_Count =0;  
  
  /* When Rx Buffer unavailable flag is set: clear it and resume reception */
  if ((ETH->DMASR&ETH_DMASR_RBUS)!=(u32)RESET)  
  {
    /* Clear RBUS ETHERNET DMA flag */
    ETH->DMASR=ETH_DMASR_RBUS;
    /* Resume DMA reception */
    ETH->DMARPDR=0;
  }
  
  return p;
}

low_level_output 写数据到以太网

static err_t low_level_output(struct netif *netif, struct pbuf *p)
{
  static sys_sem_t ousem ;
  if(ousem.sem == NULL)
  {
    sys_sem_new(&ousem,0);
    sys_sem_signal(&ousem);
  }
  err_t errval;
  struct pbuf *q;

uint8_t *buffer = (uint8_t *)(DMATxDescToSet->Buffer1Addr);
  __IO ETH_DMADESCTypeDef *DmaTxDesc= DMATxDescToSet;
  uint32_t framelength = 0;
  uint32_t bufferoffset = 0;
  uint32_t byteslefttocopy = 0;
  uint32_t payloadoffset = 0;
  __IO uint32_t timeout = 0;
  
  
  sys_sem_wait(&ousem); //wait  sem

buffer = (uint8_t *)(DMATxDescToSet->Buffer1Addr);
  DmaTxDesc = DMATxDescToSet;
  bufferoffset = 0;
  /* Check if the descriptor is owned by the ETHERNET DMA (when set) or CPU (when reset) */
  /* Is this buffer available? If not, goto error */
 while((DmaTxDesc->Status & ETH_DMATxDesc_OWN) != (uint32_t)RESET)
 {
     sys_msleep(1);
    timeout++;
    if(timeout > 50) // wait 50ms
    {
        break;
    }
 }
 
  if((DmaTxDesc->Status & ETH_DMATxDesc_OWN) != (uint32_t)RESET)
  {
    errval = ERR_USE;
    goto error;
  }
  
  /* copy frame from pbufs to driver buffers */
  for(q = p; q != NULL; q = q->next)
    {
      /* Get bytes in current lwIP buffer */
      byteslefttocopy = q->len;
      payloadoffset = 0;
    
      /* Check if the length of data to copy is bigger than Tx buffer size*/
      while( (byteslefttocopy + bufferoffset) > ETH_TX_BUF_SIZE )
      {
        /* Copy data to Tx buffer*/
        memcpy( (uint8_t*)((uint8_t*)buffer + bufferoffset), (uint8_t*)((uint8_t*)q->payload + payloadoffset), (ETH_TX_BUF_SIZE - bufferoffset) );
      
        /* Point to next descriptor */
        DmaTxDesc = (ETH_DMADESCTypeDef *)(DmaTxDesc->Buffer2NextDescAddr);
      
        /* Check if the buffer is available */
     timeout =0;
     while((DmaTxDesc->Status & ETH_DMATxDesc_OWN) != (uint32_t)RESET)
     {
         sys_msleep(1);
        timeout++;
        if(timeout > 50)
        {
            break;
        }
     }
     
        if((DmaTxDesc->Status & ETH_DMATxDesc_OWN) != (uint32_t)RESET)
        {
          errval = ERR_USE;
          goto error;
        }
      
        buffer = (uint8_t *)(DmaTxDesc->Buffer1Addr);
      
        byteslefttocopy = byteslefttocopy - (ETH_TX_BUF_SIZE - bufferoffset);
        payloadoffset = payloadoffset + (ETH_TX_BUF_SIZE - bufferoffset);
        framelength = framelength + (ETH_TX_BUF_SIZE - bufferoffset);
        bufferoffset = 0;
      }
    
      /* Copy the remaining bytes */
      memcpy( (uint8_t*)((uint8_t*)buffer + bufferoffset), (uint8_t*)((uint8_t*)q->payload + payloadoffset), byteslefttocopy );
      bufferoffset = bufferoffset + byteslefttocopy;
      framelength = framelength + byteslefttocopy;
    }
  
  /* Prepare transmit descriptors to give to DMA */ 
  ETH_Prepare_Transmit_Descriptors(framelength);
  
  errval = ERR_OK;

error:
  
  /* When Transmit Underflow flag is set, clear it and issue a Transmit Poll Demand to resume transmission */
  if ((ETH->DMASR & ETH_DMASR_TUS) != (uint32_t)RESET)
  {
    /* Clear TUS ETHERNET DMA flag */
    ETH->DMASR = ETH_DMASR_TUS;

/* Resume DMA transmission*/
    ETH->DMATPDR = 0;
  }

sys_sem_signal(&ousem);  //post the  sem
  
  return errval;
}

STM32407 + FreeRTOS +LAN8720 +lwip 标准库 +stm32f4x7_eth相关推荐

1. STM32F407+FreeRTOS+LAN8720+LWIP+STM32CubeMX+DHCP

   记录一下通过STM32CubeMX配置STM32F407使用lan8720A使用lwip实现dhcp功能,使用硬件正点原子战舰开发板,STM32CubeMX版本6.4:FreeRTOS版本10.2.1 ...

2. 使用标准库对STM32F407ZGT6移植LWIP(逻机-全网最全)

   使用STM32CubeM对F407ZGT6移植LWIP(全网最全) 使用标准库对STM32F407ZGT6移植LWIP(逻机-全网最全) 基于STM32单片机的LwIP协议(一)网络协议简介 基于ST ...

3. STM32CubeMX+LAN8720+LWIP+FreeRTOS实现网络通讯

   STM32CubeMX+LAN8720+LWIP+FreeRTOS实现网络通讯 使用STM32CubeMX可以非常方便的将FreeRTOS+LWIP移植到工程中,本文就是介绍如何利用STM32Cube ...

4. freeRTOS V10.0.1移植到STM32F407标准库 - 环境Keil5

   最近因为工作需要用到FreeRTOS,其实开始本人内心是拒绝的因为自己只学习过UCOSIII还没实际上过什么大又复杂的工程,但是谁让FreeRTOS他是Free的呢公司成本考虑肯定是不会选择USOS的 ...

5. STM32cubeMX将STM32F767+LAN8720+LwIP+FreeRTOS的以太网实现

   通过STM32cubeMX将STM32F767+LAN8720+LwIP+FreeRTOS的以太网实现 本文使用了正点原子的阿波罗开发板,接下来我将粗略的对STM32F767通过STM32cubeMX ...

6. 基于keil5自动配置stm32f103标准库的官网freertos移植

   基于keil5自动配置stm32f103标准库的官网freertos移植 前言 序言:利用keil5自动配置stm32f103标准库工程 闲话 正式篇 移植官网FreeRTOS 前言   当笔者学习s ...

7. STM32系列单片机标准库移植FreeRTOS V10.4.6详解

     文中所用到的资料下载地址 https://download.csdn.net/download/qq_20222919/87370679   最近看正点原子新录制了手把手教你学FreeRTOS的视 ...

8. Keil to STM32CubeIDE标准库移植

   Keil to STM32CubeIDE标准库移植 一.新建CubeIDE空白工程 这里以个人使用的STM32F407为例,新建空白工程即不使用HAL库,上图 注意选择Empty,然后Finish 建 ...

9. 【STM32】标准库-以太网外设-LAN8720A-LWIP-无操作系统

   TCP/IP模型 TCP/IP 只有四个分层,分别为应用层.传输层.网络层以及网络访问层(物理层) 实际上,还有一个 TCP/IP 混合模型,分为五个层.它实际与 TCP/IP四层模型是相通的,只是把 ...

最新文章

1. 程序员的灯下黑：不要忘记你的目标
2. leetcode-14-最长公共前缀
3. 腾讯云Kafka海量服务自动化运营实践
4. Web前端期末大作业--响应式电竞博客网页设计（HTML+CSS+JavaScript）实现
5. 某大型银行深化系统之十八：性能设计之三
6. 地学计算方法/地统计学(第三章区域化变量理论)
7. 高斯克吕格投影 python2.x 版本
8. 近期计算机病毒爆发,最新警示！最新电脑病毒全面爆发，沉寂已久的incaseformat蠕虫病毒肆虐横行！...
9. 多点温度检测上位机显示_基于51单片机的多点温度检测系统设计
10. python之 十进制与十二进制 相互转换~clash of coding
11. 引入tinymce-vue后调试器报错 Refused to apply styl
12. 国内/国外常见搜索引擎
13. 小白的python学习实录 基础篇（八）面向对象
14. stm32核心板可以点亮灯吗_不忘初心牢记使命——自动化科协自行设计开发stm32仿真器...
15. 各种颜色十六进制代码表
16. ODC预制光纤连接器
17. 教你提取图片中文字的四种方法
18. GPS设置及原理教程-如何通过修改gps.conf文件来提高搜星速度
19. php 倒置,PHP依赖倒置案例详解
20. AD快捷键、常见问题汇总

热门文章

1. Xcode 11 beta 4 error: Command CompileSwiftSources failed with a nonzero exit code
2. 台式计算机一般多大功率,电脑主机功率一般多大
3. MySql基础知识、存储引擎与常用数据类型
4. 企业架构中的业务架构分析和理解
5. windows10 计算机打不开怎么办,Win10计算器打不开怎么办？如何解决？,爱纯净官网...
6. Python面向对象(约束,异常处理,md5加密)(五)
7. 用PHP编写圆的半径和周长,在C++中编写程序输入半径计算圆的周长和面积
8. FreeCAD中数据显示流程
9. 赶紧收藏，月薪5万的程序员必备软件清单
10. android 涂鸦 卡顿,你的手机里，需要一个好用的涂鸦板：Inkboard