正点原子的网络实验4 RAW_TCP客户端实验解读

野性酷女 2022-02-18 21:21 1392阅读 0赞

有项目要用以太网，考虑到项目周期和目前广泛应用的TCPIP协议栈，我选择了lwip，根据以前公司

有的407的板子历程，我选择了网络实验4 RAW\_TCP客户端实验历程作为入门学习，基于裸编环境，

现在把学习到的心得记录如下，希望能够帮助需要的人。至于lwip的细节部分，请看

《STM32F4 LWIP开发手册\_V2.1.pdf》

《LwIP协议栈的设计与实现\_中文译稿.pdf》

《LwIP协议栈源码详解.pdf》

rawapi.txt 这篇入门重点看

《LwIP应用指南 V0.01.pdf》这篇入门重点看，介绍几个回调函数的意义

资料历程下载地址：[lwipv1.41RAMTCP客户端学习资料+源码历程\_if(es!=NULL)//连接处于空闲可以发送数据-网络基础代码类资源-CSDN下载][lwipv1.41RAMTCP_if_es_NULL_-_-CSDN]

Additionaly, memory (de-)allocation functions may be  
called from multiple threads (not ISR!) with NO\_SYS=0  
since they are protected by SYS\_LIGHTWEIGHT\_PROT and/or  
semaphores.

此外，NO\_SYS=0时候（这个时候有操作系统），释放内存函数

可以被多线程（不是ISR，即中断服务）调用，因为它们被

SYS\_LIGHTWEIGHT\_PROT和或semaphores保护。

Only since 1.3.0, if SYS\_LIGHTWEIGHT\_PROT is set to 1  
and LWIP\_ALLOW\_MEM\_FREE\_FROM\_OTHER\_CONTEXT is set to 1,  
pbuf\_free() may also be called from another thread or  
an ISR (since only then, mem\_free - for PBUF\_RAM - may  
be called from an ISR: otherwise, the HEAP is only  
protected by semaphores).

仅从1.3.0开始，如果SYS\_LIGHTWEIGHT\_PROT设置为1  
和LWIP\_ALLOW\_MEM\_FREE\_FROM\_OTHER\_CONTEXT设置为1，  
pbuf\_free（）也可以从另一个线程调用  
一个ISR（因为只有这样，mem\_free - 对于PBUF\_RAM - 可能  
从ISR调用：否则，HEAP只是  
受信号量保护）。

一、应用到的资源

详细的资源请看官方历程，这里只是介绍大概。

1、PYH芯片：LAN8720；

2、MCU：STM32F407ZGT6；

3、MCU资源：

1）内部RAM：110K，初始化为内存池

//mem1内存参数设定,mem1完全处于内部SRAM里面
    #define MEM1_BLOCK_SIZE	32  			//内存块大小为32字节
    #define MEM1_MAX_SIZE		100*1024 	//最大管理内存 110k
    #define MEM1_ALLOC_TABLE_SIZE MEM1_MAX_SIZE/MEM1_BLOCK_SIZE  //内存表大小

2）心跳定时器，历程在没有开启操作系统情况下，是提供精确软延时（看历程是死查询）；

//延时nms 
    //nms:0~65535
    void delay_ms(u16 nms)
    {	 	 
    	u32 temp;		   
    	SysTick->LOAD=(u32)nms*fac_ms;//时间加载(SysTick->LOAD为24bit)
    	SysTick->VAL =0x00;           //清空计数器
    	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;          //开始倒数  
    	do
    	{
    		temp=SysTick->CTRL;
    	}
    	while(temp&0x01&&!(temp&(1<<16)));//等待时间到达   
    	SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;       //关闭计数器
    	SysTick->VAL =0X00;       //清空计数器
    }

3）定时器3，提供10ms的中断，作为lwip的心跳定时器；

TIM3_Int_Init(999,839); 	//100khz的频率,计数1000为10ms

//定时器3中断服务函数
    void TIM3_IRQHandler(void)
    {
    	if(TIM_GetITStatus(TIM3,TIM_IT_Update)==SET) //溢出中断
    	{
    		lwip_localtime +=10; //加10
    	}
    	TIM_ClearITPendingBit(TIM3,TIM_IT_Update);  //清除中断标志位
    }

这里没必要单独占用一个timer中断，浪费。一些和时间先关的，都可以放到这个中断里面。

其他的按键、屏什么的，可以忽略。

4、lwip相关

1）初始化： lwip\_comm\_init()

2）lwip的poll回调函数：lwip\_periodic\_handle()

3）TCP Client的demo：tcp\_client\_test()

4）以太网的接受中断： lwip\_pkt\_handle()

二、初始化

初始化看具体的lwip\_comm\_init()函数，这里需要注意的是里面的初始化都是采用阻塞式的，

并且在不插网线情况下是初始化失败的。

如果要用裸编方式，即lwip的RAW编程模式，则必须解决阻塞问题。

看下阻塞的地方：

LAN8720_Init()的
    
        LAN8720_RST=0;                    //硬件复位LAN8720
        delay_ms(50);    
        LAN8720_RST=1;                     //复位结束

ETH\_MACDMA\_Config（）的

while (ETH\_GetSoftwareResetStatus() == SET);//等待软件重启网络完成

ETH\_Init()的

1）

/\* Delay to assure PHY reset \*/  
\_eth\_delay\_(PHY\_RESET\_DELAY);

2）

就是如下的地方，一直在死等网线被插入，超时报错。

/\* We wait for linked status... \*/  
do  
\{  
timeout++;  
\} while (!(ETH\_ReadPHYRegister(PHYAddress, PHY\_BSR) & PHY\_Linked\_Status) && (timeout < PHY\_READ\_TO));

3）

/\* Wait until the auto-negotiation will be completed \*/  
do  
\{  
timeout++;  
\} while (!(ETH\_ReadPHYRegister(PHYAddress, PHY\_BSR) & PHY\_AutoNego\_Complete) && (timeout < (uint32\_t)PHY\_READ\_TO));

4）

/\* Delay to assure PHY configuration \*/  
\_eth\_delay\_(PHY\_CONFIG\_DELAY);

硬件底层的：

ETH\_ReadPHYRegister()

do  
\{  
timeout++;  
tmpreg = ETH->MACMIIAR;  
\} while ((tmpreg & ETH\_MACMIIAR\_MB) && (timeout < (uint32\_t)PHY\_READ\_TO));

ETH\_WritePHYRegister()

/\* Check for the Busy flag \*/  
do  
\{  
timeout++;  
tmpreg = ETH->MACMIIAR;  
\} while ((tmpreg & ETH\_MACMIIAR\_MB) && (timeout < (uint32\_t)PHY\_WRITE\_TO));

我测试了下这里寄存器操作大概在timeout=380次左右，并且和网线插拔无关。这块我没有改

，因为改动起来，影响太大。所有调用的地方都需要改。因此除了ETH\_ReadPHYRegister()和

ETH\_WritePHYRegister()，其它所有函数都要改写为状态机。

三、lwip\_periodic\_handle()

这个是Lwip要求的周期性的调用函数，工程里面做的有点乱，其思路用该是放到main里面，然后

不停插延时标志，根据各个延时标志调用想用函数。

//LWIP轮询任务
    void lwip_periodic_handle()
    {
    #if LWIP_TCP
    	//每250ms调用一次tcp_tmr()函数
      if (lwip_localtime - TCPTimer >= TCP_TMR_INTERVAL)
      {
        TCPTimer =  lwip_localtime;
        tcp_tmr();
      }
    #endif
      //ARP每5s周期性调用一次
      if ((lwip_localtime - ARPTimer) >= ARP_TMR_INTERVAL)
      {
        ARPTimer =  lwip_localtime;
        etharp_tmr();
      }
    
    #if LWIP_DHCP //如果使用DHCP的话
      //每500ms调用一次dhcp_fine_tmr()
      if (lwip_localtime - DHCPfineTimer >= DHCP_FINE_TIMER_MSECS)
      {
        DHCPfineTimer =  lwip_localtime;
        dhcp_fine_tmr();
        if ((lwipdev.dhcpstatus != 2)&&(lwipdev.dhcpstatus != 0XFF))
        { 
          lwip_dhcp_process_handle();  //DHCP处理
        }
      }
    
      //每60s执行一次DHCP粗糙处理
      if (lwip_localtime - DHCPcoarseTimer >= DHCP_COARSE_TIMER_MSECS)
      {
        DHCPcoarseTimer =  lwip_localtime;
        dhcp_coarse_tmr();
      }  
    #endif
    }

模板的工程是到处调用（while(1)循环的地方都要调用），由于改为了FSM，我的工程只在一处调用

main()的while(1)里面：

while(1){
    #ifndef __DEBUG
            WDG_CLEAR();                        //Çå¹·
    #endif
    
            SYS_CALL_SUB_FSM();                 //ÄÚºË
    
            user_tcpip_process();               //lwipÈÎÎñ
        }

然后：

void user_tcpip_process(void)
    {
        tcpip_process();                        //TCPIP Á¬½Ó·þÎñÆ÷ÈÎÎñ
        if(CHECK_TCP_CLIENT_FLAG(TCP_CLIENT_FLAG_LWIP_INIT)){
            lwip_periodic_handle();             //lwip¶¨Ê±ÈÎÎñ
        }
    }

这样思路就比较清晰了。

四、tcp\_client\_test()

这个函数是实现创建TCP客户端的核心，具体的实现看源码，我只讲个大概。

tcppcb=tcp_new();	//创建一个新的pcb
    	if(tcppcb)			//创建成功
    	{
    		IP4_ADDR(&rmtipaddr,lwipdev.remoteip[0],lwipdev.remoteip[1],lwipdev.remoteip[2],lwipdev.remoteip[3]); 
    		tcp_connect(tcppcb,&rmtipaddr,TCP_CLIENT_PORT,tcp_client_connected);  //连接到目的地址的指定端口上,当连接成功后回调tcp_client_connected()函数
     	}else res=1;

这段就创建了一个TCP控制块，并且用它去连接一个服务器，这个函数是立即返回，并且不报告连接是否

成功，那么如何判断是否连接成功了呢？如果连接成功了，那么就会调用我们传入的回调函数tcp\_client\_connected

来看下它的实现：

//lwIP TCP连接建立后调用回调函数
    err_t tcp_client_connected(void *arg, struct tcp_pcb *tpcb, err_t err)
    {
    	struct tcp_client_struct *es=NULL;  
    	if(err==ERR_OK)   
    	{
    		es=(struct tcp_client_struct*)mem_malloc(sizeof(struct tcp_client_struct));  //申请内存
    		if(es) //内存申请成功
    		{
     			es->state=ES_TCPCLIENT_CONNECTED;//状态为连接成功
    			es->pcb=tpcb;  
    			es->p=NULL; 
    			tcp_arg(tpcb,es);        			//使用es更新tpcb的callback_arg
    			tcp_recv(tpcb,tcp_client_recv);  	//初始化LwIP的tcp_recv回调功能   
    			tcp_err(tpcb,tcp_client_error); 	//初始化tcp_err()回调函数
    			tcp_sent(tpcb,tcp_client_sent);		//初始化LwIP的tcp_sent回调功能
    			tcp_poll(tpcb,tcp_client_poll,1); 	//初始化LwIP的tcp_poll回调功能 
     			tcp_client_flag|=1<<5; 				//标记连接到服务器了
    			err=ERR_OK;
    		}else
    		{ 
    			tcp_client_connection_close(tpcb,es);//关闭连接
    			err=ERR_MEM;	//返回内存分配错误
    		}
    	}else
    	{
    		tcp_client_connection_close(tpcb,0);//关闭连接
    	}
    	return err;
    }

如果连接成功，那么就会初始化所有的callback函数，并且初始化了一个成功标志。这里看到有个申请内存的动作，

大小是一个应用层的tcp\_client\_struct大小，并且当做参数传递给了tcp块，

tcp\_arg(tpcb,es); //使用es更新tpcb的callback\_arg

这里一样要注意，close时候，如果已经连接了服务器，那么就要在close时候传入指针释放掉，否则内存泄漏；

如果没有连接成功，则close时候传入NULL。我感觉这样做很麻烦，一不小心就内存泄漏了，用一个static变量，

更合适。

再看看tcp\_client\_test()怎么处理的：

delay_ms(2);
    		t++;
    		if(t==200)
    		{
    			if((tcp_client_flag&1<<5)==0)//未连接上,则尝试重连
    			{ 
    				tcp_client_connection_close(tcppcb,0);//关闭连接
    				tcppcb=tcp_new();	//创建一个新的pcb
    				if(tcppcb)			//创建成功
    				{ 
    					tcp_connect(tcppcb,&rmtipaddr,TCP_CLIENT_PORT,tcp_client_connected);//连接到目的地址的指定端口上,当连接成功后回调tcp_client_connected()函数
    				}
    			}
    			t=0;
    			LED0=!LED0;
    		}

如果2\*200=400ms没有连接上，则重现发起连接，但是连接前必须先调用

tcp\_client\_connection\_close(tcppcb,0);//关闭连接

看看它的实现：

//关闭与服务器的连接
    void tcp_client_connection_close(struct tcp_pcb *tpcb, struct tcp_client_struct * es)
    {
    	//移除回调
    	tcp_abort(tpcb);//终止连接,删除pcb控制块
    	tcp_arg(tpcb,NULL);  
    	tcp_recv(tpcb,NULL);
    	tcp_sent(tpcb,NULL);
    	tcp_err(tpcb,NULL);
    	tcp_poll(tpcb,NULL,0);  
    	if(es)mem_free(es); 
    	tcp_client_flag&=~(1<<5);//标记连接断开了
    }

es参数作用上面接过来，小心内存泄漏即可，（刚开始，我没仔细看，就内存泄漏了）。

这里清除了连接标志（直接清除，不管是否连接到服务器，省掉了判断）。

到此为止，客户端连接到服务器讲解完毕。

五、发送

demo程序是怎么发送的呢？看tcp\_client\_test()，有如下语句：

if(key==KEY0_PRES)//KEY0按下了,发送数据
    		{
    			tcp_client_flag|=1<<7;//标记要发送数据
    		}

来看看哪里检测这个标志了：

//lwIP tcp_poll的回调函数
    err_t tcp_client_poll(void *arg, struct tcp_pcb *tpcb)
    {
    	err_t ret_err;
    	struct tcp_client_struct *es; 
    	es=(struct tcp_client_struct*)arg;
    	if(es!=NULL)  //连接处于空闲可以发送数据
    	{
    		if(tcp_client_flag&(1<<7))	//判断是否有数据要发送 
    		{
    			es->p=pbuf_alloc(PBUF_TRANSPORT, strlen((char*)tcp_client_sendbuf),PBUF_POOL);	//申请内存 
    			pbuf_take(es->p,(char*)tcp_client_sendbuf,strlen((char*)tcp_client_sendbuf));	//将tcp_client_sentbuf[]中的数据拷贝到es->p_tx中
    			tcp_client_senddata(tpcb,es);//将tcp_client_sentbuf[]里面复制给pbuf的数据发送出去
    			tcp_client_flag&=~(1<<7);	//清除数据发送标志
    			if(es->p)pbuf_free(es->p);	//释放内存
    		}else if(es->state==ES_TCPCLIENT_CLOSING)
    		{ 
     			tcp_client_connection_close(tpcb,es);//关闭TCP连接
    		} 
    		ret_err=ERR_OK;
    	}else
    	{ 
    		tcp_abort(tpcb);//终止连接,删除pcb控制块
    		ret_err=ERR_ABRT;
    	}
    	return ret_err;
    }

在tcp\_client\_poll()里面查询了，OK，看看哪里调用了tcp\_client\_poll(),

在tcp\_client\_connected()里面tcp\_poll(tpcb,tcp\_client\_poll,1); //初始化LwIP的tcp\_poll回调功能

设置为了lwip的poll函数，那好，看看tcp\_poll()

void
    tcp_poll(struct tcp_pcb *pcb, tcp_poll_fn poll, u8_t interval)
    {
      LWIP_ASSERT("invalid socket state for poll", pcb->state != LISTEN);
    #if LWIP_CALLBACK_API
      pcb->poll = poll;
    #else /* LWIP_CALLBACK_API */  
      LWIP_UNUSED_ARG(poll);
    #endif /* LWIP_CALLBACK_API */  
      pcb->pollinterval = interval;
    }

再接着看：

#define TCP_EVENT_POLL(pcb,ret)                                \
      do {                                                         \
        if((pcb)->poll != NULL)                                    \
          (ret) = (pcb)->poll((pcb)->callback_arg,(pcb));          \
        else (ret) = ERR_OK;                                       \
      } while (0)

在tcp\_slowtmr()里面：

/* We check if we should poll the connection. */
          ++prev->polltmr;
          if (prev->polltmr >= prev->pollinterval) {
            prev->polltmr = 0;
            LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: polling application\n"));
            tcp_active_pcbs_changed = 0;
            TCP_EVENT_POLL(prev, err);
            if (tcp_active_pcbs_changed) {
              goto tcp_slowtmr_start;
            }
            /* if err == ERR_ABRT, 'prev' is already deallocated */
            if (err == ERR_OK) {
              tcp_output(prev);
            }
          }

再看：

void
    tcp_tmr(void)
    {
      /* Call tcp_fasttmr() every 250 ms */
      tcp_fasttmr();
    
      if (++tcp_timer & 1) {
        /* Call tcp_tmr() every 500 ms, i.e., every other timer
           tcp_tmr() is called. */
        tcp_slowtmr();
      }
    }

再看，在void lwip\_periodic\_handle()里面

#if LWIP_TCP
    	//每250ms调用一次tcp_tmr()函数
      if (lwip_localtime - TCPTimer >= TCP_TMR_INTERVAL)
      {
        TCPTimer =  lwip_localtime;
        tcp_tmr();
      }
    #endif

至此我们总算理清了发送关系。这里采用250ms查询发送标志，然后发送数据，实际应用要改为立即调用发送数据，

增加实时性。

六、接收

先看接受的回调函数：

//lwIP tcp_recv()函数的回调函数
    err_t tcp_client_recv(void *arg,struct tcp_pcb *tpcb,struct pbuf *p,err_t err)
    { 
    	u32 data_len = 0;
    	struct pbuf *q;
    	struct tcp_client_struct *es;
    	err_t ret_err; 
    	LWIP_ASSERT("arg != NULL",arg != NULL);
    	es=(struct tcp_client_struct *)arg; 
    	if(p==NULL)//如果从服务器接收到空的数据帧就关闭连接
    	{
    		es->state=ES_TCPCLIENT_CLOSING;//需要关闭TCP 连接了 
     		es->p=p; 
    		ret_err=ERR_OK;
    	}else if(err!= ERR_OK)//当接收到一个非空的数据帧,但是err!=ERR_OK
    	{ 
    		if(p)pbuf_free(p);//释放接收pbuf
    		ret_err=err;
    	}else if(es->state==ES_TCPCLIENT_CONNECTED)	//当处于连接状态时
    	{
    		if(p!=NULL)//当处于连接状态并且接收到的数据不为空时
    		{
    			memset(tcp_client_recvbuf,0,TCP_CLIENT_RX_BUFSIZE);  //数据接收缓冲区清零
    			for(q=p;q!=NULL;q=q->next)  //遍历完整个pbuf链表
    			{
    				//判断要拷贝到TCP_CLIENT_RX_BUFSIZE中的数据是否大于TCP_CLIENT_RX_BUFSIZE的剩余空间，如果大于
    				//的话就只拷贝TCP_CLIENT_RX_BUFSIZE中剩余长度的数据，否则的话就拷贝所有的数据
    				if(q->len > (TCP_CLIENT_RX_BUFSIZE-data_len)) memcpy(tcp_client_recvbuf+data_len,q->payload,(TCP_CLIENT_RX_BUFSIZE-data_len));//拷贝数据
    				else memcpy(tcp_client_recvbuf+data_len,q->payload,q->len);
    				data_len += q->len;  	
    				if(data_len > TCP_CLIENT_RX_BUFSIZE) break; //超出TCP客户端接收数组,跳出	
    			}
    			tcp_client_flag|=1<<6;		//标记接收到数据了
     			tcp_recved(tpcb,p->tot_len);//用于获取接收数据,通知LWIP可以获取更多数据
    			pbuf_free(p);  	//释放内存
    			ret_err=ERR_OK;
    		}
    	}else  //接收到数据但是连接已经关闭,
    	{ 
    		tcp_recved(tpcb,p->tot_len);//用于获取接收数据,通知LWIP可以获取更多数据
    		es->p=NULL;
    		pbuf_free(p); //释放内存
    		ret_err=ERR_OK;
    	}
    	return ret_err;
    }

再看tcp\_client\_connected()的tcp\_recv(tpcb,tcp\_client\_recv); //初始化LwIP的tcp\_recv回调功能

void
    tcp_recv(struct tcp_pcb *pcb, tcp_recv_fn recv)
    {
      LWIP_ASSERT("invalid socket state for recv callback", pcb->state != LISTEN);
      pcb->recv = recv;
    }

在tcp\_impl.h中

#define TCP_EVENT_RECV(pcb,p,err,ret)                          \
      do {                                                         \
        if((pcb)->recv != NULL) {                                  \
          (ret) = (pcb)->recv((pcb)->callback_arg,(pcb),(p),(err));\
        } else {                                                   \
          (ret) = tcp_recv_null(NULL, (pcb), (p), (err));          \
        }                                                          \
      } while (0)

tcp\_input()中

if (recv_data != NULL) {
              LWIP_ASSERT("pcb->refused_data == NULL", pcb->refused_data == NULL);
              if (pcb->flags & TF_RXCLOSED) {
                /* received data although already closed -> abort (send RST) to
                   notify the remote host that not all data has been processed */
                pbuf_free(recv_data);
                tcp_abort(pcb);
                goto aborted;
              }
    
              /* Notify application that data has been received. */
              TCP_EVENT_RECV(pcb, recv_data, ERR_OK, err);
              if (err == ERR_ABRT) {
                goto aborted;
              }
    
              /* If the upper layer can't receive this data, store it */
              if (err != ERR_OK) {
                pcb->refused_data = recv_data;
                LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: keep incoming packet, because pcb is \"full\"\n"));
              }
            }

在ip\_input(struct pbuf \*p, struct netif \*inp)

#if LWIP_RAW
      /* raw input did not eat the packet? */
      if (raw_input(p, inp) == 0)
    #endif /* LWIP_RAW */
      {
        switch (IPH_PROTO(iphdr)) {
    #if LWIP_UDP
        case IP_PROTO_UDP:
    #if LWIP_UDPLITE
        case IP_PROTO_UDPLITE:
    #endif /* LWIP_UDPLITE */
          snmp_inc_ipindelivers();
          udp_input(p, inp);
          break;
    #endif /* LWIP_UDP */
    #if LWIP_TCP
        case IP_PROTO_TCP:
          snmp_inc_ipindelivers();
          tcp_input(p, inp);
          break;
    #endif /* LWIP_TCP */

在netif\_init()

netif_add(&loop_netif, &loop_ipaddr, &loop_netmask, &loop_gw, NULL, netif_loopif_init, ip_input);

在lwip\_init(void)有netif\_init();lwip\_init()被lwip\_comm\_init()调用。

咦，ip\_input0哪里调用了？接着分析

netif\_add(struct netif \*netif, ip\_addr\_t \*ipaddr, ip\_addr\_t \*netmask,  
ip\_addr\_t \*gw, void \*state, netif\_init\_fn init, netif\_input\_fn input)

有netif->input = input;

在ethernetif\_input()中有：

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

//当接收到数据后调用 
    void lwip_pkt_handle(void)
    {
      //从网络缓冲区中读取接收到的数据包并将其发送给LWIP处理 
     ethernetif_input(&lwip_netif);
    }

//以太网中断服务函数
    void ETH_IRQHandler(void)
    {
    	while(ETH_GetRxPktSize(DMARxDescToGet)!=0) 	//检测是否收到数据包
    	{ 
    		lwip_pkt_handle();		
    	}
    	ETH_DMAClearITPendingBit(ETH_DMA_IT_R);
    	ETH_DMAClearITPendingBit(ETH_DMA_IT_NIS);
    }

好了，至此我们把接收逻辑也搞清楚了。网上有的帖子说接受回调是查询方式的，其实这个主要是看tcpip\_input()的调用

方式，即lwip\_pkt\_handle()的调用方式决定，如果是查询的，那么考虑关键代码区就会少很多，如果是中断方式，那么APP

层就要考虑临界代码区保护了。

七、一些修改的心得

1、lwip\_comm\_init()初始化时候，如果初始化失败，那么可以隔一段时间再初始化，我设置的1分钟，没必要一直初始化，

可能网线没插呢；

2、在此强调tcp\_client\_connection\_close时候，注意内存泄漏；

3、判断网线插拔

if((!(ETH_ReadPHYRegister(LAN8720_PHY_ADDRESS, PHY_BSR) & PHY_Linked_Status))){
                    //TRACE_INFO("ÍøÏß¶Ï¿ª =%X \r\n",s_ptTcpPcb->callback_arg);
                    tcp_client_connection_close(s_ptTcpPcb,s_ptTcpPcb->callback_arg);//¹Ø±ÕÁ¬½Ó
    #if LWIP_DHCP
                    s_tState = FSM_USER_TCPIP_DHCP;
    #else
                    s_tState = FSM_USER_TCPIP_CREATE_TCP_CLIENT;
    #endif
                    TRACE_INFO("网线断开......\r\n");
                    break;
                }

也没必要每次否判断，只要比心跳时间短，就可以了；

4、lwip\_periodic\_handle()在初始化失败后，没必须调用，无意义；

5、裸编情况下，一定要改为非阻塞模式，否则严重影响实时性；

6、ping命令的时候不能丢包。

发送和接收时候的申请和释放内存分析，请看[Lwip pbuf分析][Lwip pbuf]

<----------------------------------------------------------------------------------------------------------------------------------->

2019.09.20

今天在做lwip的功能模块是否启用，要灵活可配置。主要实现的思路如下：

1、Lwip的要重新初始化；

2、lwip的内核的内存怎么回收、释放；

3、接收的数据释放；

4、发送的内存释放；

以上几点要保证，否则内存泄漏。鉴于以上思路比较麻烦，如果你的lwip只有一个网卡，使用

比较简单，可以采用如下思路：

1、lwip用到的所有的内存全部是独立的，和其他逻辑不共用；

2、重新初始化所有的内存池；

上面这个思路实现就很简单了，但是在测试中发Lwip重启几次，就进入一个死循环，出不来了。

随后追踪到这个函数：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1aGVueW91eXV5b3V5dQ_size_16_color_FFFFFF_t_70][]

为什么？lwip如果只初始化一次，肯定没有问题，因为测试了很长时间了。那么还要从重启里面去找，也不是内存泄漏。

我直觉是某个链表没有清掉，思路是把Lwipi用到的全局变量也全部初始化，最后测试，问题解决。

<-------------------------------------------------------问题总结--------------------------------------------------------->

### **1、ETH\_SoftwareReset 失败** ###

网口不通，查看log，提示ETH\_SoftwareReset 失败，查看代码：ETH\_GetSoftwareResetStatus()失败，肉眼检查没有发现焊接错误。于是在网上查找相似的问题，在正点原子的官方论坛上发现有好多人都是这个错误，楼下回复都是检查芯片的焊接。于是动用示波器，检测LAN8720的晶振，发现25M输入正常。检查nINT/REFCLKO 输出时钟，发现50M信号没有，查看lan8720的pdf，看到LED2/nINTSEL拉低到地，设置REFCLKO输出50M，没有发现问题，只能尝试重新焊接。我用烙铁重加焊锡后，再用风枪加热，保证焊盘的充分接触。动用风枪的原因是lan8720底部焊盘是GND。再次运行程序发现可以成功重启单片机网络。

[lwipv1.41RAMTCP_if_es_NULL_-_-CSDN]: https://download.csdn.net/download/wuhenyouyuyouyu/11119079
[Lwip pbuf]: https://blog.csdn.net/wuhenyouyuyouyu/article/details/89370512
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1aGVueW91eXV5b3V5dQ_size_16_color_FFFFFF_t_70]: /images/20220219/378b64273db14feb99dd578ac49a5a17.png