自己在做项目时，需求与LWIP协议栈中的DHCP实现不太一样，发现如果修改起来没有想象的那么容易，跟大家分享一下修改过程。

一、时间变量

 
    
     
     
  1. u32_t offered_t0_lease; /* lease period (in seconds) */ 
    2.  
     
  2. u32_t offered_t1_renew; /* recommended renew time (usually 50% of lease period) */ 
    3.  
     
  3. u32_t offered_t2_rebind; /* recommended rebind time (usually 66% of lease period)  */ 
    4.  
     
  4.  
    5.  
     
  5.  
    6.  
     
  6. u16_t request_timeout; /* #ticks with period DHCP_FINE_TIMER_SECS for request timeout */ 
    7.  
     
  7. u16_t t1_timeout;  /* #ticks with period DHCP_COARSE_TIMER_SECS for renewal time */ 
    8.  
     
  8. u16_t t2_timeout;  /* #ticks with period DHCP_COARSE_TIMER_SECS for rebind time */ 
    9.  
     
  9.  
    10.  
    
 
    
 
 
    
 
     
在offered_t0_lease 租约时间，服务器在offer报文跟ack报文中都会给你，时间是秒，在lwip协议栈中则是在ack报文中获得并保存下来，option为51。其他更新时间与绑定时间也类似，看起来比较容易。可是在使用中，出现了两个疑问。
 
     
1.在dhcp的代码中，没有定时器，这个时间是如何与系统时间所匹配呢？
 
     

       2.还有几个变量t1_timeout、t2_timeout是做什么用的？ 
     
 
     

         
     
 
     

          其实解决了这两个问题，对于dhcp控制时间的思路也就比较清晰了。 
     
 
     

          解决第一个疑问，dhcp的轮询是依靠这段代码实现的。 
      
 
      
     
       
  1. for(idxtimer=0; 
    2.  
       
  2.             idxtimer < (sizeof(timers_table)/sizeof(timers_info)); 
    3.  
       
  3.             idxtimer ++) 
    4.  
       
  4.         { 
    5.  
       
  5.             ptmr_inf = &timers_table[idxtimer]; 
    6.  
       
  6.             ptmr_inf->timer += time_diff; 
    7.  
       
  7.             if (ptmr_inf->timer > ptmr_inf->timer_interval) 
    8.  
       
  8.             { 
    9.  
       
  9.                 if (ptmr_inf->timer_func) 
    10.  
       
  10.                     ptmr_inf->timer_func(); 
    11.  
       
  11.                 ptmr_inf->timer -= ptmr_inf->timer_interval; 
    12.  
       
  12.             } 
    13.  
       
  13.         } 
     
    14.  
      
 
     
 
     
 
     
     
      
  1. static timers_info timers_table[] = { 
    2.  
      
  2.     /* LWIP_TCP */ 
    3.  
      
  3.     { 0, TCP_FAST_INTERVAL,     tcp_fasttmr}, 
    4.  
      
  4.     { 0, TCP_SLOW_INTERVAL,     tcp_slowtmr}, 
    5.  
      
  5.     /* LWIP_ARP */ 
    6.  
      
  6.     { 0, ARP_TMR_INTERVAL,      etharp_tmr}, 
    7.  
      
  7.     /* LWIP_DHCP */ 
    8.  
      
  8.     #if LWIP_DHCP 
    9.  
      
  9.     { 0, DHCP_COARSE_TIMER_SECS, dhcp_coarse_tmr}, 
    10.  
      
  10.     { 0, DHCP_FINE_TIMER_MSECS,  dhcp_fine_tmr}, 
    11.  
      
  11.     #endif 
    12.  
      
  12. }; 
    13.  
     
 
     

          就是每隔DHCP_COARSE_TIMER_SECS时间后，执行一下dhcp_coarse_tmr()函数。所以是每隔系统时间DHCP_COARSE_TIMER_SECS调用一次该函数。dhcp的时间就是通过这样的方式与系统时间耦合上的。 
     
 
     

         
     
 
     

         
     
 
     

          第二个疑问。 
     
 
     

         
     
 
     
 
     
     
      
  1. timeout = (dhcp->offered_t1_renew + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS; 
    2.  
      
  2. dhcp->t1_timeout = (u16_t)timeout; 
    3.  
     
 
     

         
     
 
     

       就是这么得来的，t1_timeout为以DHCP_COARSE_TIMER_SECS为衡量的单位时间，就是说有t1个DHCP_COARSE_TIMER_SECS时间，而在dhcp_coarse_tmr()函数中的t1_timeout--也就是每次轮询，都自减一个DHCP_COARSE_TIMER_SECS时间，这样就能够做到虽然自己没有计时器，但是却很好的耦合上了系统时间。