STM32

Lwip做服务端发送数据会卡死，请各位大神指点迷津！

2019-12-09 20:02发布

站内问答 / STM32/STM8
7938 10 11
本帖最后由 mii 于 2017-8-31 20:12 编辑

使用开发板平台是STM32F429 + LAN8720a,LWIP版本是1.4.1.
测试例程开发板自己带例程，主要移植了ST的ETH库。测试例程实现在裸跑情况下开发板建立一个服务端，使用TCP调试助手连接，发送、接收同样数据的回环测试。
下面是接收回调函数，开发板例程原程序，中文注释为返回接收到数据。
  1. static err_t tcp_echoserver_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
  2. {
  3. #ifdef SERIAL_DEBUG
  4.         char *recdata=0;
  5. #endif
  6.        
  7.   struct tcp_echoserver_struct *es;
  8.   err_t ret_err;

  10.   LWIP_ASSERT("arg != NULL",arg != NULL);
  11.   
  12.   es = (struct tcp_echoserver_struct *)arg;
  13.   
  14.   /* if we receive an empty tcp frame from client => close connection */
  15.   if (p == NULL)
  16.   {
  17.     /* remote host closed connection */
  18.     es->state = ES_CLOSING;
  19.     if(es->p == NULL)
  20.     {
  21.        /* we're done sending, close connection */
  22.        tcp_echoserver_connection_close(tpcb, es);
  23.     }
  24.     else
  25.     {
  26.       /* we're not done yet */
  27.       /* acknowledge received packet */
  28.       tcp_sent(tpcb, tcp_echoserver_sent);
  29.       
  30.       /* send remaining data*/
  31.       tcp_echoserver_send(tpcb, es);
  32.     }
  33.     ret_err = ERR_OK;
  34.   }   
  35.   /* else : a non empty frame was received from client but for some reason err != ERR_OK */
  36.   else if(err != ERR_OK)
  37.   {
  38.     /* free received pbuf*/
  39.     es->p = NULL;
  40.     pbuf_free(p);
  41.     ret_err = err;
  42.   }
  43.   else if(es->state == ES_ACCEPTED)
  44.   {
  45.     /* first data chunk in p->payload */
  46.     es->state = ES_RECEIVED;
  47.    
  48.     /* store reference to incoming pbuf (chain) */
  49.     es->p = p;
  50.    
  51.     /* initialize LwIP tcp_sent callback function */
  52.     tcp_sent(tpcb, tcp_echoserver_sent);
  53.                
  54. #ifdef SERIAL_DEBUG
  55.                         recdata=(char *)malloc(p->len*sizeof(char));
  56.                         if(recdata!=NULL)
  57.                         {
  58.                                 memcpy(recdata,p->payload,p->len);
  59.                                 printf("upd_rec:%s",recdata);
  60.                         }
  61.                         free(recdata);
  62. #endif   
  63.                
  64.     /* send back the received data (echo) */
  65.     tcp_echoserver_send(tpcb, es);
  66.    
  67.     ret_err = ERR_OK;
  68.   }
  69.   else if (es->state == ES_RECEIVED)
  70.   {
  71.     /* more data received from client and previous data has been already sent*/
  72.     if(es->p == NULL)
  73.     {
  74.       es->p = p;
  75.                        
  76. #ifdef SERIAL_DEBUG
  77.                         recdata=(char *)malloc(p->len*sizeof(char));
  78.                         if(recdata!=NULL)
  79.                         {
  80.                                 memcpy(recdata,p->payload,p->len);
  81.                                 printf("upd_rec:%s",recdata);
  82.                         }
  83.                         free(recdata);
  84. #endif
  85.                
  86.    /* send back received data */
  87.       tcp_echoserver_send(tpcb, es);//返回接收到数据
  88.     }
  89.     else
  90.     {
  91.       struct pbuf *ptr;

  93.       /* chain pbufs to the end of what we recv'ed previously  */
  94.       ptr = es->p;
  95.       pbuf_chain(ptr,p);
  96.     }
  97.     ret_err = ERR_OK;
  98.   }
  99.   
  100.   /* data received when connection already closed */
  101.   else
  102.   {
  103.     /* Acknowledge data reception */
  104.     tcp_recved(tpcb, p->tot_len);
  105.    
  106.     /* free pbuf and do nothing */
  107.     es->p = NULL;
  108.     pbuf_free(p);
  109.     ret_err = ERR_OK;
  110.   }
  111.   return ret_err;
  112. }
复制代码
以上回环测试中，随便发送一个字符串，1ms发送接收都不会卡死。
然而修改后，注意中文注释。只想实现只要接收数据就发送一个数组数据。下面是修改后程序
  1. static err_t tcp_echoserver_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
  2. {
  3.         char HeartDatSend[5] = {0x01,0x02,0x03,0x04,0x05};
  4. #ifdef SERIAL_DEBUG
  5.         char *recdata=0;
  6. #endif
  7.        
  8.         struct pbuf *spbuf;
  9.        
  10.   struct tcp_echoserver_struct *es;
  11.   err_t ret_err;

  13.   LWIP_ASSERT("arg != NULL",arg != NULL);
  14.   
  15.   es = (struct tcp_echoserver_struct *)arg;
  16.   
  17.   /* if we receive an empty tcp frame from client => close connection */
  18.   if (p == NULL)
  19.   {
  20.     /* remote host closed connection */
  21.     es->state = ES_CLOSING;
  22.     if(es->p == NULL)
  23.     {
  24.        /* we're done sending, close connection */
  25.        tcp_echoserver_connection_close(tpcb, es);
  26.     }
  27.     else
  28.     {
  29.       /* we're not done yet */
  30.       /* acknowledge received packet */
  31.       tcp_sent(tpcb, tcp_echoserver_sent);
  32.       
  33.       /* send remaining data*/
  34.       tcp_echoserver_send(tpcb, es);
  35.     }
  36.     ret_err = ERR_OK;
  37.   }   
  38.   /* else : a non empty frame was received from client but for some reason err != ERR_OK */
  39.   else if(err != ERR_OK)
  40.   {
  41.     /* free received pbuf*/
  42.     es->p = NULL;
  43.     pbuf_free(p);
  44.     ret_err = err;
  45.   }
  46.   else if(es->state == ES_ACCEPTED)
  47.   {
  48.     /* first data chunk in p->payload */
  49.     es->state = ES_RECEIVED;
  50.    
  51.     /* store reference to incoming pbuf (chain) */
  52.     es->p = p;
  53.    
  54.     /* initialize LwIP tcp_sent callback function */
  55.     tcp_sent(tpcb, tcp_echoserver_sent);
  56.                
  57. #ifdef SERIAL_DEBUG
  58.                         recdata=(char *)malloc(p->len*sizeof(char));
  59.                         if(recdata!=NULL)
  60.                         {
  61.                                 memcpy(recdata,p->payload,p->len);
  62.                                 printf("upd_rec:%s",recdata);
  63.                         }
  64.                         free(recdata);
  65. #endif   
  66.                
  67.     /* send back the received data (echo) */
  68.     tcp_echoserver_send(tpcb, es);
  69.    
  70.     ret_err = ERR_OK;
  71.   }
  72.   else if (es->state == ES_RECEIVED)
  73.   {
  74.     /* more data received from client and previous data has been already sent*/
  75.     if(es->p == NULL)
  76.     {
  77.       es->p = p;
  78.                        
  79. #ifdef SERIAL_DEBUG
  80.                         recdata=(char *)malloc(p->len*sizeof(char));
  81.                         if(recdata!=NULL)
  82.                         {
  83.                                 memcpy(recdata,p->payload,p->len);
  84.                                 printf("upd_rec:%s",recdata);
  85.                         }
  86.                         free(recdata);
  87. #endif
  88.                        
  89.                         spbuf = pbuf_alloc(PBUF_TRANSPORT,256,PBUF_RAM);//开一个新缓冲
  90.                         spbuf->payload = HeartDatSend;//装载数据
  91.                         spbuf->len = sizeof(HeartDatSend)/sizeof(HeartDatSend[0]);//设置发送长度
  92.                         spbuf->tot_len = sizeof(HeartDatSend)/sizeof(HeartDatSend[0]);//设备总长度
  93.                         es->p = spbuf;//将缓冲更新到要发送PCB中
  94.                
  95.       /* send back received data */
  96.       tcp_echoserver_send(tpcb, es);//发送
  97.                         // tcp_echoserver_send(es->pcb, es);
  98.                         pbuf_free(spbuf);//释放缓冲区
  99.     }
  100.     else
  101.     {
  102.       struct pbuf *ptr;

  104.       /* chain pbufs to the end of what we recv'ed previously  */
  105.       ptr = es->p;
  106.       pbuf_chain(ptr,p);
  107.     }
  108.     ret_err = ERR_OK;
  109.   }
  110.   
  111.   /* data received when connection already closed */
  112.   else
  113.   {
  114.     /* Acknowledge data reception */
  115.     tcp_recved(tpcb, p->tot_len);
  116.    
  117.     /* free pbuf and do nothing */
  118.     es->p = NULL;
  119.     pbuf_free(p);
  120.     ret_err = ERR_OK;
  121.   }
  122.   return ret_err;
  123. }
复制代码
然而上面测试中，可能有十次回环左右是成功的，然后就会卡死了协议栈。用WireSark捕捉出来的数据是发生多次重连，下面是截图
微信截图_20170831200527.png (61.32 KB, 下载次数: 0) 下载附件 2017-8-31 20:07 上传

就以上情况，摸索了好几天都没想明白，请教一下怎么解决这种情况？
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
该问题目前已经被作者或者管理员关闭, 无法添加新回复
10条回答
sunjun
1楼-- · 2019-12-09 20:48
 精彩回答 2  元偷偷看……
mii
2楼-- · 2019-12-09 21:03
sunjun 发表于 2017-8-31 20:39
pbuf不是像你这样玩的
用pbuf_take向pbuf拷贝数据，结构体内的参数不要随意去修改，pbuf填充和读取数据都有 ...

明白，我试试
mii
3楼-- · 2019-12-10 01:51
sunjun 发表于 2017-8-31 20:39
pbuf不是像你这样玩的
用pbuf_take向pbuf拷贝数据，结构体内的参数不要随意去修改，pbuf填充和读取数据都有 ...

感谢大神指点，确实要用PBUF的专用函数就不会出现问题。感谢，发送部分修改如下，
  1. spbuf = pbuf_alloc(PBUF_TRANSPORT,strlen((char*)HeartDatSend),PBUF_RAM);
  2.                 pbuf_take(es->p, (char*)HeartDatSend, strlen((char*)HeartDatSend));
  3.                        
  4.                
  5.       /* send back received data */
  6.       tcp_echoserver_send(tpcb, es);
  7.                 pbuf_free(spbuf);
复制代码
mii
4楼-- · 2019-12-10 04:52
sunjun 发表于 2017-8-31 20:39
pbuf不是像你这样玩的
用pbuf_take向pbuf拷贝数据，结构体内的参数不要随意去修改，pbuf填充和读取数据都有 ...

大神，上次使用PBUF_take这个函数装载是没有问题，但发送数据长度不对。就是我只复制了5个字节，但会发出11个字节数据。
单步调试发现这个函数只会简单对初始的缓冲区域进行覆盖，不会调整发送长度 。
我自己去手动调整发送长度的话，发送一会，接收窗口就变成0了。
这个应该怎么解决
sunjun
5楼-- · 2019-12-10 07:12
pbuf的数据长度是你申请的时候就确定了(pbuf_alloc)，你需要多长就申请多长，与你填充多长没有关系
mii
6楼-- · 2019-12-10 09:03
 精彩回答 2  元偷偷看……
1 2 下一页

一周热门 更多>