devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

LWIP学习系列（二）：STM32中ETH外设的配置与LWIP的结合使用_lwip光纤调试 stm32

作者：从前慢现在也慢 | 2024-05-24 19:06:56

赞

踩

lwip光纤调试 stm32

目录

一、STM32中ETH外设的配置流程（HAL库）

（1）ETH大致初始化与使用流程

（2）访问外部PHY寄存器相关函数

二、LWIP关于ethernet的底层驱动移植

（1）LWIP网卡需要由用户实现的函数部分

（2）ethernetif_init 函数相关内容整理

（3）ethernetif_input 函数相关整理

（4）low_level_init 相关内容整理

（5）low_level_input 相关内容整理

（6）low_level_output 相关内容整理

三、总结

一、STM32中ETH外设的配置流程（HAL库）

（1）ETH大致初始化与使用流程

  1. 声明 ETH_HandleTypeDef heth 的ETH外设句柄
  2. 对ETH句柄根据实际情况进行赋值、然后调用 HAL_ETH_Init() 来初始ETH外设(MAC,DMA, ......)
  3. 通过 HAL_ETH_MspInit() 来初始化ETH的底层资源：（1）ETH时钟与ETH的GPIO时钟 （2）ETH的GPIO管脚（3）ETH的中断向量NVIC       
  4. 初始化ETH DMA 描述符 并指向分配好的buffer  
    1. HAL_ETH_DMATxDescListInit(); 
    2. HAL_ETH_DMARxDescListInit();
  5.  启动ETH外设            
    HAL_ETH_Start();
  6. 接受数据帧或者发送数据帧 
    1. 发送：HAL_ETH_TransmitFrame();
    2. 接收：HAL_ETH_GetReceivedFrame();（应该放入死循环中，不停接受数据） 
    3. 从中断中接收：HAL_ETH_GetReceivedFrame_IT(); 
    4.                                                                                                

（2）访问外部PHY寄存器相关函数

  1. 读取PHY 寄存器函数： 
    HAL_ETH_ReadPHYRegister();
  2. 写PHY 指定寄存器函数： 
    HAL_ETH_WritePHYRegister();
  3. 初始化ETH后，调整ethernet MAC函数 
    HAL_ETH_ConfigMAC();
  4. 初始化ETH后，调整ETH DMA函数 
    HAL_ETH_ConfigDMA();

二、LWIP关于ethernet的底层驱动移植

（1）LWIP网卡需要由用户实现的函数部分

注：LWIP提供了有关网卡接口的一系列函数需要用户自己实现。

需要用户自己实现的内容有：

  1. err_t  ethernetif_init(struct netif *netif) 【网卡初始化函数，具体初始化由 low_level_init 来实现】
  2. void  ethernetif_input(struct netif *netif); 【从网卡中读取接收到的数据，具体接收函数由low_level_input来实现】

  3. void low_level_init(struct netif *netif) 【网卡的底层初始化函数】

  4. struct pbuf * low_level_input(struct netif *netif)【网卡的底层接收函数】

  5. err_t low_level_output(struct netif *netif, struct pbuf *p)【网卡的底层发送函数】

（2）ethernetif_init 函数相关内容整理

ethernetif_init  函数，主要是给netif 网卡结构体进行赋值，将底层的输入函数传给netif 网卡结构体中

  • 由STM32CubeMX生成的lwIP的 ethernetif_init
  1. err_t ethernetif_init(struct netif *netif)
  2. {
  3.   LWIP_ASSERT("netif != NULL", (netif != NULL));
  4.   
  5. #if LWIP_NETIF_HOSTNAME
  6.   /* Initialize interface hostname */
  7.   netif->hostname = "lwip";
  8. #endif /* LWIP_NETIF_HOSTNAME */
  9.  
  10.   netif->name[0] = IFNAME0;
  11.   netif->name[1] = IFNAME1;
  12.   /* We directly use etharp_output() here to save a function call.
  13.    * You can instead declare your own function an call etharp_output()
  14.    * from it if you have to do some checks before sending (e.g. if link
  15.    * is available...) */
  16.  
  17. #if LWIP_IPV4
  18. #if LWIP_ARP || LWIP_ETHERNET
  19. #if LWIP_ARP
  20.   netif->output = etharp_output;
  21. #else
  22.   /* The user should write ist own code in low_level_output_arp_off function */
  23.   netif->output = low_level_output_arp_off;
  24. #endif /* LWIP_ARP */
  25. #endif /* LWIP_ARP || LWIP_ETHERNET */
  26. #endif /* LWIP_IPV4 */
  27.  
  28. #if LWIP_IPV6
  29.   netif->output_ip6 = ethip6_output;
  30. #endif /* LWIP_IPV6 */
  31.  
  32.   netif->linkoutput = low_level_output;
  33.  
  34.   /* initialize the hardware */
  35.   low_level_init(netif);
  36.  
  37.   return ERR_OK;
  38. }
  •  由lwip官方下载的示例代码
  1. err_t
  2. ethernetif_init(struct netif *netif)
  3. {
  4.   struct ethernetif *ethernetif;
  5.  
  6.   LWIP_ASSERT("netif != NULL", (netif != NULL));
  7.  
  8.   ethernetif = mem_malloc(sizeof(struct ethernetif));
  9.   if (ethernetif == NULL) {
  10.     LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_init: out of memory\n"));
  11.     return ERR_MEM;
  12.   }
  13.  
  14. #if LWIP_NETIF_HOSTNAME
  15.   /* Initialize interface hostname */
  16.   netif->hostname = "lwip";
  17. #endif /* LWIP_NETIF_HOSTNAME */
  18.  
  19.   /*
  20.    * Initialize the snmp variables and counters inside the struct netif.
  21.    * The last argument should be replaced with your link speed, in units
  22.    * of bits per second.
  23.    */
  24.   MIB2_INIT_NETIF(netif, snmp_ifType_ethernet_csmacd, LINK_SPEED_OF_YOUR_NETIF_IN_BPS);
  25.  
  26.   netif->state = ethernetif;
  27.   netif->name[0] = IFNAME0;
  28.   netif->name[1] = IFNAME1;
  29.   /* We directly use etharp_output() here to save a function call.
  30.    * You can instead declare your own function an call etharp_output()
  31.    * from it if you have to do some checks before sending (e.g. if link
  32.    * is available...) */
  33. #if LWIP_IPV4
  34.   netif->output = etharp_output;
  35. #endif /* LWIP_IPV4 */
  36. #if LWIP_IPV6
  37.   netif->output_ip6 = ethip6_output;
  38. #endif /* LWIP_IPV6 */
  39.   netif->linkoutput = low_level_output;
  40.  
  41.   ethernetif->ethaddr = (struct eth_addr *) & (netif->hwaddr[0]);
  42.  
  43.   /* initialize the hardware */
  44.   low_level_init(netif);
  45.  
  46.   return ERR_OK;
  47. }

小结：由上面两种程序对比，可以看出大同小异。基本上都是对netif 网卡结构体进行赋值，然后真正的初始化交由low_level_init 来进行。

（3）ethernetif_input 函数相关整理

ethernetif_input  主要是用于接收eth传来的数据包。

  • 在RTOS中，一般需要设置一个优先级很高的线程来一直循环调用该函数（主要是循环调用其真正的接收实现函数low_level_input）
  • 在裸机环境中，一般设置在主函数中设置死循环调用该函数。
  • 由STM32CubeMX生成的lwIP的 ethernetif_input 
  1. void ethernetif_input(void const * argument)
  2. {
  3.   struct pbuf *p;
  4.   struct netif *netif = (struct netif *) argument;
  5.   
  6.   for( ;; )
  7.   {
  8.     if (osSemaphoreWait(s_xSemaphore, TIME_WAITING_FOR_INPUT) == osOK)
  9.     {
  10.       do
  11.       {   
  12.         p = low_level_input( netif );
  13.         if   (p != NULL)
  14.         {
  15.           if (netif->input( p, netif) != ERR_OK )
  16.           {
  17.             pbuf_free(p);
  18.           }
  19.         }
  20.       } while(p!=NULL);
  21.     }
  22.   }
  23. }
  • 由lwIP官网下载的示例代码
  1. static void
  2. ethernetif_input(struct netif *netif)
  3. {
  4.   struct ethernetif *ethernetif;
  5.   struct eth_hdr *ethhdr;
  6.   struct pbuf *p;
  7.  
  8.   ethernetif = netif->state;
  9.  
  10.   /* move received packet into a new pbuf */
  11.   p = low_level_input(netif);
  12.   /* if no packet could be read, silently ignore this */
  13.   if (p != NULL) {
  14.     /* pass all packets to ethernet_input, which decides what packets it supports */
  15.     if (netif->input(p, netif) != ERR_OK) {
  16.       LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: IP input error\n"));
  17.       pbuf_free(p);
  18.       p = NULL;
  19.     }
  20.   }
  21. }

小结：对比上面两种程序，可以发现也是大同小异。真正的接收函数是由low_level_input 来实现。同时在带有RTOS的情况下，是将ethernetif_input 当成一个线程一直进行，通过对信号量资源的检测来判断是否数据传入，然后再将通过low_level_input 来接收数据。而lwip官网的程序，是不带操作系统的例程，所以直接交由low_level_input 来接收数据，如果要一直接收数据，则需要将ethernetif_input 放入死循环中。

（4）low_level_init 相关内容整理

low_level_init 主要任务

  • 主要是对STM32中的ETH外设进行初始化（较为具体的流程可以查看上面的ETH配置流程）
  • 然后继续对 netif 网卡结构体 进行初始化赋值操作
  • 创建 二值信号量 Semaphore 用于 ethernetif_input 网卡接收线程使用
  • 然后创建 ethernetif_input  最高优先级的线程，使能ETH
  • （然后看情况配置ETH的寄存器）

注：其实就大致四个部分（带RTOS情况下） STM32的ETH外设初始化、netif网卡结构体初始化、ETH数据接收线程、（看需求）ETH寄存器进行的设置

  • 由STM32CubeMX生成的lwIP的 low_level_init 
  1. static void low_level_init(struct netif *netif)
  2. { 
  3.   uint32_t regvalue = 0;
  4.   HAL_StatusTypeDef hal_eth_init_status;
  5.   
  6. /* Init ETH */
  7.  
  8.    uint8_t MACAddr[6] ;
  9.   heth.Instance = ETH;
  10.   heth.Init.AutoNegotiation = ETH_AUTONEGOTIATION_ENABLE;
  11.   heth.Init.PhyAddress = LAN8742A_PHY_ADDRESS;
  12.   MACAddr[0] = 0x00;
  13.   MACAddr[1] = 0x80;
  14.   MACAddr[2] = 0xE1;
  15.   MACAddr[3] = 0x00;
  16.   MACAddr[4] = 0x00;
  17.   MACAddr[5] = 0x00;
  18.   heth.Init.MACAddr = &MACAddr[0];
  19.   heth.Init.RxMode = ETH_RXINTERRUPT_MODE;
  20.   heth.Init.ChecksumMode = ETH_CHECKSUM_BY_HARDWARE;
  21.   heth.Init.MediaInterface = ETH_MEDIA_INTERFACE_RMII;
  22.  
  23.   /* USER CODE BEGIN MACADDRESS */
  24.     
  25.   /* USER CODE END MACADDRESS */
  26.  
  27.   hal_eth_init_status = HAL_ETH_Init(&heth);
  28.  
  29.   if (hal_eth_init_status == HAL_OK)
  30.   {
  31.     /* Set netif link flag */  
  32.     netif->flags |= NETIF_FLAG_LINK_UP;
  33.   }
  34.   /* Initialize Tx Descriptors list: Chain Mode */
  35.   HAL_ETH_DMATxDescListInit(&heth, DMATxDscrTab, &Tx_Buff[0][0], ETH_TXBUFNB);
  36.      
  37.   /* Initialize Rx Descriptors list: Chain Mode  */
  38.   HAL_ETH_DMARxDescListInit(&heth, DMARxDscrTab, &Rx_Buff[0][0], ETH_RXBUFNB);
  39.  
  40. #if LWIP_ARP || LWIP_ETHERNET 
  41.  
  42.   /* set MAC hardware address length */
  43.   netif->hwaddr_len = ETH_HWADDR_LEN;
  44.   
  45.   /* set MAC hardware address */
  46.   netif->hwaddr[0] =  heth.Init.MACAddr[0];
  47.   netif->hwaddr[1] =  heth.Init.MACAddr[1];
  48.   netif->hwaddr[2] =  heth.Init.MACAddr[2];
  49.   netif->hwaddr[3] =  heth.Init.MACAddr[3];
  50.   netif->hwaddr[4] =  heth.Init.MACAddr[4];
  51.   netif->hwaddr[5] =  heth.Init.MACAddr[5];
  52.   
  53.   /* maximum transfer unit */
  54.   netif->mtu = 1500;
  55.   
  56.   /* Accept broadcast address and ARP traffic */
  57.   /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */
  58.   #if LWIP_ARP
  59.     netif->flags |= NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP;
  60.   #else 
  61.     netif->flags |= NETIF_FLAG_BROADCAST;
  62.   #endif /* LWIP_ARP */
  63.   
  64. /* create a binary semaphore used for informing ethernetif of frame reception */
  65.   osSemaphoreDef(SEM);
  66.   s_xSemaphore = osSemaphoreCreate(osSemaphore(SEM), 1);
  67.  
  68. /* create the task that handles the ETH_MAC */
  69.   osThreadDef(EthIf, ethernetif_input, osPriorityRealtime, 0, INTERFACE_THREAD_STACK_SIZE);
  70.   osThreadCreate (osThread(EthIf), netif);
  71.   /* Enable MAC and DMA transmission and reception */
  72.   HAL_ETH_Start(&heth);
  73.  
  74. /* USER CODE BEGIN PHY_PRE_CONFIG */ 
  75.     
  76. /* USER CODE END PHY_PRE_CONFIG */
  77.   
  78.  
  79.   /* Read Register Configuration */
  80.   HAL_ETH_ReadPHYRegister(&heth, PHY_ISFR, &regvalue);
  81.   regvalue |= (PHY_ISFR_INT4);
  82.  
  83.   /* Enable Interrupt on change of link status */ 
  84.   HAL_ETH_WritePHYRegister(&heth, PHY_ISFR , regvalue );
  85.   
  86.   /* Read Register Configuration */
  87.   HAL_ETH_ReadPHYRegister(&heth, PHY_ISFR , &regvalue);
  88.  
  89. /* USER CODE BEGIN PHY_POST_CONFIG */ 
  90.     
  91. /* USER CODE END PHY_POST_CONFIG */
  92.  
  93. #endif /* LWIP_ARP || LWIP_ETHERNET */
  94.  
  95. /* USER CODE BEGIN LOW_LEVEL_INIT */ 
  96.     
  97. /* USER CODE END LOW_LEVEL_INIT */
  98. }
  • 由lwIP官网下载的示例代码
  1. low_level_init(struct netif *netif)
  2. {
  3.   struct ethernetif *ethernetif = netif->state;
  4.  
  5.   /* set MAC hardware address length */
  6.   netif->hwaddr_len = ETHARP_HWADDR_LEN;
  7.  
  8.   /* set MAC hardware address */
  9.   netif->hwaddr[0] = ;
  10.   ...
  11.   netif->hwaddr[5] = ;
  12.  
  13.   /* maximum transfer unit */
  14.   netif->mtu = 1500;
  15.  
  16.   /* device capabilities */
  17.   /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */
  18.   netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
  19.  
  20. #if LWIP_IPV6 && LWIP_IPV6_MLD
  21.   /*
  22.    * For hardware/netifs that implement MAC filtering.
  23.    * All-nodes link-local is handled by default, so we must let the hardware know
  24.    * to allow multicast packets in.
  25.    * Should set mld_mac_filter previously. */
  26.   if (netif->mld_mac_filter != NULL) {
  27.     ip6_addr_t ip6_allnodes_ll;
  28.     ip6_addr_set_allnodes_linklocal(&ip6_allnodes_ll);
  29.     netif->mld_mac_filter(netif, &ip6_allnodes_ll, NETIF_ADD_MAC_FILTER);
  30.   }
  31. #endif /* LWIP_IPV6 && LWIP_IPV6_MLD */
  32.  
  33.   /* Do whatever else is needed to initialize interface. */
  34. }

小结：对比两种程序，可以看到注释中大致的流程是相同的。基本上是都是 STM32ETH外设初始化、 继续对netif 网卡结构体的初始化、(信号量的创建与ETH接收数据线程的创建、 ETH寄存器部分位修改及使能)

（5）low_level_input 相关内容整理

low_level_input 主要任务

  • 通过STM32 ETH外设的 HAL_ETH_GetReceivedFrame_IT 来接收从以太网接口传来的数据包。
  • 将接收到的数据包封装成pbuf的形式（最终需要返回该pbuf的地址）
  • 释放 DMA 接收描述符（为下一次接收做准备）
  • 由STM32CubeMX生成的lwIP的 low_level_input 
  1. static struct pbuf * low_level_input(struct netif *netif)
  2. {
  3.   struct pbuf *p = NULL;
  4.   struct pbuf *q = NULL;
  5.   uint16_t len = 0;
  6.   uint8_t *buffer;
  7.   __IO ETH_DMADescTypeDef *dmarxdesc;
  8.   uint32_t bufferoffset = 0;
  9.   uint32_t payloadoffset = 0;
  10.   uint32_t byteslefttocopy = 0;
  11.   uint32_t i=0;
  12.   
  13.  
  14.   /* get received frame */
  15.   if (HAL_ETH_GetReceivedFrame_IT(&heth) != HAL_OK)
  16.     return NULL;
  17.   
  18.   /* Obtain the size of the packet and put it into the "len" variable. */
  19.   len = heth.RxFrameInfos.length;
  20.   buffer = (uint8_t *)heth.RxFrameInfos.buffer;
  21.   
  22.   if (len > 0)
  23.   {
  24.     /* We allocate a pbuf chain of pbufs from the Lwip buffer pool */
  25.     p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);
  26.   }
  27.   
  28.   if (p != NULL)
  29.   {
  30.     dmarxdesc = heth.RxFrameInfos.FSRxDesc;
  31.     bufferoffset = 0;
  32.     for(q = p; q != NULL; q = q->next)
  33.     {
  34.       byteslefttocopy = q->len;
  35.       payloadoffset = 0;
  36.       
  37.       /* Check if the length of bytes to copy in current pbuf is bigger than Rx buffer size*/
  38.       while( (byteslefttocopy + bufferoffset) > ETH_RX_BUF_SIZE )
  39.       {
  40.         /* Copy data to pbuf */
  41.         memcpy( (uint8_t*)((uint8_t*)q->payload + payloadoffset), (uint8_t*)((uint8_t*)buffer + bufferoffset), (ETH_RX_BUF_SIZE - bufferoffset));
  42.         
  43.         /* Point to next descriptor */
  44.         dmarxdesc = (ETH_DMADescTypeDef *)(dmarxdesc->Buffer2NextDescAddr);
  45.         buffer = (uint8_t *)(dmarxdesc->Buffer1Addr);
  46.         
  47.         byteslefttocopy = byteslefttocopy - (ETH_RX_BUF_SIZE - bufferoffset);
  48.         payloadoffset = payloadoffset + (ETH_RX_BUF_SIZE - bufferoffset);
  49.         bufferoffset = 0;
  50.       }
  51.       /* Copy remaining data in pbuf */
  52.       memcpy( (uint8_t*)((uint8_t*)q->payload + payloadoffset), (uint8_t*)((uint8_t*)buffer + bufferoffset), byteslefttocopy);
  53.       bufferoffset = bufferoffset + byteslefttocopy;
  54.     }
  55.   }  
  56.   
  57.     /* Release descriptors to DMA */
  58.     /* Point to first descriptor */
  59.     dmarxdesc = heth.RxFrameInfos.FSRxDesc;
  60.     /* Set Own bit in Rx descriptors: gives the buffers back to DMA */
  61.     for (i=0; i< heth.RxFrameInfos.SegCount; i++)
  62.     {  
  63.       dmarxdesc->Status |= ETH_DMARXDESC_OWN;
  64.       dmarxdesc = (ETH_DMADescTypeDef *)(dmarxdesc->Buffer2NextDescAddr);
  65.     }
  66.     
  67.     /* Clear Segment_Count */
  68.     heth.RxFrameInfos.SegCount =0;  
  69.   
  70.   /* When Rx Buffer unavailable flag is set: clear it and resume reception */
  71.   if ((heth.Instance->DMASR & ETH_DMASR_RBUS) != (uint32_t)RESET)  
  72.   {
  73.     /* Clear RBUS ETHERNET DMA flag */
  74.     heth.Instance->DMASR = ETH_DMASR_RBUS;
  75.     /* Resume DMA reception */
  76.     heth.Instance->DMARPDR = 0;
  77.   }
  78.   return p;
  79. }
  • 由lwIP官网下载的示例代码
  1. static struct pbuf *
  2. low_level_input(struct netif *netif)
  3. {
  4.   struct ethernetif *ethernetif = netif->state;
  5.   struct pbuf *p, *q;
  6.   u16_t len;
  7.  
  8.   /* Obtain the size of the packet and put it into the "len"
  9.      variable. */
  10.   len = ;
  11.  
  12. #if ETH_PAD_SIZE
  13.   len += ETH_PAD_SIZE; /* allow room for Ethernet padding */
  14. #endif
  15.  
  16.   /* We allocate a pbuf chain of pbufs from the pool. */
  17.   p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);
  18.  
  19.   if (p != NULL) {
  20.  
  21. #if ETH_PAD_SIZE
  22.     pbuf_remove_header(p, ETH_PAD_SIZE); /* drop the padding word */
  23. #endif
  24.  
  25.     /* We iterate over the pbuf chain until we have read the entire
  26.      * packet into the pbuf. */
  27.     for (q = p; q != NULL; q = q->next) {
  28.       /* Read enough bytes to fill this pbuf in the chain. The
  29.        * available data in the pbuf is given by the q->len
  30.        * variable.
  31.        * This does not necessarily have to be a memcpy, you can also preallocate
  32.        * pbufs for a DMA-enabled MAC and after receiving truncate it to the
  33.        * actually received size. In this case, ensure the tot_len member of the
  34.        * pbuf is the sum of the chained pbuf len members.
  35.        */
  36.       read data into(q->payload, q->len);
  37.     }
  38.     acknowledge that packet has been read();
  39.  
  40.     MIB2_STATS_NETIF_ADD(netif, ifinoctets, p->tot_len);
  41.     if (((u8_t *)p->payload)[0] & 1) {
  42.       /* broadcast or multicast packet*/
  43.       MIB2_STATS_NETIF_INC(netif, ifinnucastpkts);
  44.     } else {
  45.       /* unicast packet*/
  46.       MIB2_STATS_NETIF_INC(netif, ifinucastpkts);
  47.     }
  48. #if ETH_PAD_SIZE
  49.     pbuf_add_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
  50. #endif
  51.  
  52.     LINK_STATS_INC(link.recv);
  53.   } else {
  54.     drop packet();
  55.     LINK_STATS_INC(link.memerr);
  56.     LINK_STATS_INC(link.drop);
  57.     MIB2_STATS_NETIF_INC(netif, ifindiscards);
  58.   }
  59.  
  60.   return p;
  61. }

小结：可以看到两种程序的框架都是差不多的。主要都是使用底层接收函数接收数据，然后将接收到的数据封装成pbuf，以供接下来上层协议的使用。

（6）low_level_output 相关内容整理

low_level_output 主要任务

  • 将要发送的信息装填到 ETH 的 DMA 发送描述符中
  • 将数据从pbuf从拷贝到 ETH 的 DMA Tx buffer 中
  • 最后通过 HAL_ETH_TransmitFrame 将数据从 Tx buffer 中发送出去
  • 由STM32CubeMX生成的lwIP的 low_level_output
  1. static err_t low_level_output(struct netif *netif, struct pbuf *p)
  2. {
  3.   err_t errval;
  4.   struct pbuf *q;
  5.   uint8_t *buffer = (uint8_t *)(heth.TxDesc->Buffer1Addr);
  6.   __IO ETH_DMADescTypeDef *DmaTxDesc;
  7.   uint32_t framelength = 0;
  8.   uint32_t bufferoffset = 0;
  9.   uint32_t byteslefttocopy = 0;
  10.   uint32_t payloadoffset = 0;
  11.   DmaTxDesc = heth.TxDesc;
  12.   bufferoffset = 0;
  13.   
  14.   /* copy frame from pbufs to driver buffers */
  15.   for(q = p; q != NULL; q = q->next)
  16.     {
  17.       /* Is this buffer available? If not, goto error */
  18.       if((DmaTxDesc->Status & ETH_DMATXDESC_OWN) != (uint32_t)RESET)
  19.       {
  20.         errval = ERR_USE;
  21.         goto error;
  22.       }
  23.     
  24.       /* Get bytes in current lwIP buffer */
  25.       byteslefttocopy = q->len;
  26.       payloadoffset = 0;
  27.     
  28.       /* Check if the length of data to copy is bigger than Tx buffer size*/
  29.       while( (byteslefttocopy + bufferoffset) > ETH_TX_BUF_SIZE )
  30.       {
  31.         /* Copy data to Tx buffer*/
  32.         memcpy( (uint8_t*)((uint8_t*)buffer + bufferoffset), (uint8_t*)((uint8_t*)q->payload + payloadoffset), (ETH_TX_BUF_SIZE - bufferoffset) );
  33.       
  34.         /* Point to next descriptor */
  35.         DmaTxDesc = (ETH_DMADescTypeDef *)(DmaTxDesc->Buffer2NextDescAddr);
  36.       
  37.         /* Check if the buffer is available */
  38.         if((DmaTxDesc->Status & ETH_DMATXDESC_OWN) != (uint32_t)RESET)
  39.         {
  40.           errval = ERR_USE;
  41.           goto error;
  42.         }
  43.       
  44.         buffer = (uint8_t *)(DmaTxDesc->Buffer1Addr);
  45.       
  46.         byteslefttocopy = byteslefttocopy - (ETH_TX_BUF_SIZE - bufferoffset);
  47.         payloadoffset = payloadoffset + (ETH_TX_BUF_SIZE - bufferoffset);
  48.         framelength = framelength + (ETH_TX_BUF_SIZE - bufferoffset);
  49.         bufferoffset = 0;
  50.       }
  51.     
  52.       /* Copy the remaining bytes */
  53.       memcpy( (uint8_t*)((uint8_t*)buffer + bufferoffset), (uint8_t*)((uint8_t*)q->payload + payloadoffset), byteslefttocopy );
  54.       bufferoffset = bufferoffset + byteslefttocopy;
  55.       framelength = framelength + byteslefttocopy;
  56.     }
  57.   
  58.   /* Prepare transmit descriptors to give to DMA */ 
  59.   HAL_ETH_TransmitFrame(&heth, framelength);
  60.   
  61.   errval = ERR_OK;
  62.   
  63. error:
  64.   
  65.   /* When Transmit Underflow flag is set, clear it and issue a Transmit Poll Demand to resume transmission */
  66.   if ((heth.Instance->DMASR & ETH_DMASR_TUS) != (uint32_t)RESET)
  67.   {
  68.     /* Clear TUS ETHERNET DMA flag */
  69.     heth.Instance->DMASR = ETH_DMASR_TUS;
  70.  
  71.     /* Resume DMA transmission*/
  72.     heth.Instance->DMATPDR = 0;
  73.   }
  74.   return errval;
  75. }
  • 由lwIP官网下载的示例代码
  1. static err_t
  2. low_level_output(struct netif *netif, struct pbuf *p)
  3. {
  4.   struct ethernetif *ethernetif = netif->state;
  5.   struct pbuf *q;
  6.  
  7.   initiate transfer();
  8.  
  9. #if ETH_PAD_SIZE
  10.   pbuf_remove_header(p, ETH_PAD_SIZE); /* drop the padding word */
  11. #endif
  12.  
  13.   for (q = p; q != NULL; q = q->next) {
  14.     /* Send the data from the pbuf to the interface, one pbuf at a
  15.        time. The size of the data in each pbuf is kept in the ->len
  16.        variable. */
  17.     send data from(q->payload, q->len);
  18.   }
  19.  
  20.   signal that packet should be sent();
  21.  
  22.   MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p->tot_len);
  23.   if (((u8_t *)p->payload)[0] & 1) {
  24.     /* broadcast or multicast packet*/
  25.     MIB2_STATS_NETIF_INC(netif, ifoutnucastpkts);
  26.   } else {
  27.     /* unicast packet */
  28.     MIB2_STATS_NETIF_INC(netif, ifoutucastpkts);
  29.   }
  30.   /* increase ifoutdiscards or ifouterrors on error */
  31.  
  32. #if ETH_PAD_SIZE
  33.   pbuf_add_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
  34. #endif
  35.  
  36.   LINK_STATS_INC(link.xmit);
  37.  
  38.   return ERR_OK;
  39. }

小结：可以看出大致程序框架是差不多的。主要的流程就是先将数据拷贝到ETH的发送buffer中，然后再通过HAL_ETH_TransmitFrame 来发送数据，最后再清理一下ETH的寄存器标志位。

三、总结

  从上面的相关内容整理可以得知，lwip的提供low_level_init、low_level_input、low_level_output 的接口函数，其本质上都是通过对STM32 eth 外设的初始化、输入、输出的封装，并将数据整理成pbuf的形式来进行lwip中上下层中的数据传递。

  所以，在学习lwip的过程中，首先要熟悉STM32 eth 外设的相关内容，还有eth PHY的一些信息，包括寄存器的使用，以及相关标志位的判断！！！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/618756
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号