zoukankan      html  css  js  c++  java

  • rt-thread的定时器管理源码分析

    1 前言

    rt-thread可以采用软件定时器或硬件定时器来实现定时器管理的，所谓软件定时器是指由操作系统提供的一类系统接口，它构建在硬件定时器基础之上，使系统能够提供不受数目限制的定时器服务。而硬件定时器是芯片本身提供的定时功能。一般是由外部晶振提供给芯片输入时钟，芯片向软件模块提供一组配置寄存器，接受控制输入，到达设定时间值后芯片中断控制器产生时钟中断。硬件定时器的精度一般很高，可以达到纳秒级别，并且是中断触发方式。软件定时器的精度取决于它使用的硬件定时器精度。而rt-thread操作系统在默认情况下是采用的硬件定时器的方式，用户可以通过修改宏定义#ifdef RT_USING_TIMER_SOFT来修改采用哪种。

    2 rt-thread的定时器的基本工作原理

    在RT-Thread定时器模块维护两个重要的全局变量，一个是当前系统的时间rt_tick（当硬件定时器中断来临时，它将加1），另一个是定时器链表rt_timer_list，系统中新创建的定时期都会被以排序的方式插入到rt_timer_list(硬件定时器模式下使用)链表中,rt_timer_list的每个节点保留了一个定时器的信息，并且在这个节点加入链表时就计算好了产生时间到达时的时间点，即tick,在rt-thread系统中如果采用软件定时器模式，则存在一定时器线程rt_thread_timer_entry，不断获取当前TICK值并与定时器链表rt_timer_list上的定时器对比判断是否时间已到，一旦发现就调用对应的回调函数，即事件处理函数进行处理，而如果采用硬件定时器管理模式的话，则该检查过程放到系统时钟中断例程中进行处理，此时，是不存在定时器线程的。如下图：注：如果采用软件定时器软件定时器，则该定时器链表为rt_soft_timer_list。

    3 源码分析

    3.1 数据定义

    [cpp] view plain copy
     
    1. /** 
    2.  * timer structure 
    3.  */  
    4. struct rt_timer  
    5. {  
    6.     struct rt_object parent; //内核对象  
    7.   
    8.     rt_list_t        list;      //链表节点  
    9.   
    10.     void (*timeout_func)(void *parameter);  //定时器超时例程  
    11.     void            *parameter;       //定时器例程的传入参数  
    12.   
    13.     rt_tick_t        init_tick;       //定时器的超时时间,即总共多长时间将产生超时事件  
    14.     rt_tick_t        timeout_tick;     //定时器超时的时间点，即产生超时事件时那一该的时间点  
    15. };  
    16. typedef struct rt_timer *rt_timer_t;  

    3.2 rt-thread的软件定时器模式

    软件定时器线程初始化及启动:

    [cpp] view plain copy
     
    1. /** 
    2.  * @ingroup SystemInit 
    3.  * 
    4.  * This function will initialize system timer thread 
    5.  */  
    6. void rt_system_timer_thread_init(void)  
    7. {  
    8. #ifdef RT_USING_TIMER_SOFT//如果采用软件定时器管理模式，则启动定时器线程  
    9.     rt_list_init(&rt_soft_timer_list);//初始化软件定时器链表  
    10.   
    11.     /* start software timer thread */  
    12.     rt_thread_init(&timer_thread,//初始化软件定时器线程，并启动  
    13.                    "timer",  
    14.                    rt_thread_timer_entry,  
    15.                    RT_NULL,  
    16.                    &timer_thread_stack[0],  
    17.                    sizeof(timer_thread_stack),  
    18.                    RT_TIMER_THREAD_PRIO,  
    19.                    10);  
    20.   
    21.     /* startup */  
    22.     rt_thread_startup(&timer_thread);  
    23. #endif  
    24. }  


    软件定时器线程如下：

    [cpp] view plain copy
     
    1. /* system timer thread entry */  
    2. static void rt_thread_timer_entry(void *parameter)  
    3. {  
    4.     rt_tick_t next_timeout;  
    5.       
    6.     while (1)  
    7.     {  
    8.         /* get the next timeout tick */  
    9.         next_timeout = rt_timer_list_next_timeout(&rt_soft_timer_list);//得到软件定时器链表上的下一个定时器的超时时间点  
    10.         if (next_timeout == RT_TICK_MAX)//如果超过范围，则挂起当前线程，继续线程调度  
    11.         {  
    12.             /* no software timer exist, suspend self. */  
    13.             rt_thread_suspend(rt_thread_self());  
    14.             rt_schedule();  
    15.         }  
    16.         else  
    17.         {  
    18.             rt_tick_t current_tick;  
    19.   
    20.             /* get current tick */  
    21.             current_tick = rt_tick_get();//获取当前时间点  
    22.   
    23.             if ((next_timeout - current_tick) < RT_TICK_MAX/2)//离下个中断时间点还差些时候  
    24.             {  
    25.                 /* get the delta timeout tick */  
    26.                 next_timeout = next_timeout - current_tick;//计算还差多长时间  
    27.                 rt_thread_delay(next_timeout);//休眠一段时间  
    28.             }  
    29.         }  
    30.   
    31.         /* lock scheduler */  
    32.         rt_enter_critical();//时间到，进入临界区  
    33.         /* check software timer */  
    34.         rt_soft_timer_check();//检查是否该产生超时事件  
    35.         /* unlock scheduler */  
    36.         rt_exit_critical();//退出临界区  
    37.     }  
    38. }  


    检查是否产生中断函数rt_soft_timer_check函数如下定义:

    [cpp] view plain copy
     
    1. /** 
    2.  * This function will check timer list, if a timeout event happens, the 
    3.  * corresponding timeout function will be invoked. 
    4.  */  
    5. void rt_soft_timer_check(void)  
    6. {  
    7.     rt_tick_t current_tick;  
    8.     rt_list_t *n;  
    9.     struct rt_timer *t;  
    10.   
    11.     RT_DEBUG_LOG(RT_DEBUG_TIMER, ("software timer check enter "));  
    12.   
    13.     current_tick = rt_tick_get();//得到当前时间点  
    14.   
    15.     for (n = rt_soft_timer_list.next; n != &(rt_soft_timer_list);)//得到下一定时器节点  
    16.     {  
    17.         t = rt_list_entry(n, struct rt_timer, list);//t指向rt_timer定时器  
    18.   
    19.         /* 
    20.          * It supposes that the new tick shall less than the half duration of 
    21.          * tick max. 
    22.          */  
    23.         if ((current_tick - t->timeout_tick) < RT_TICK_MAX / 2)//如果当前的时间点超过定时器的超时时间点  
    24.         {  
    25.             RT_OBJECT_HOOK_CALL(rt_timer_timeout_hook, (t));//使用钩子函数  
    26.   
    27.             /* move node to the next */  
    28.             n = n->next;//指向下一定时器  
    29.   
    30.             /* remove timer from timer list firstly */  
    31.             rt_list_remove(&(t->list));//移除当前定时器  
    32.   
    33.             /* call timeout function */  
    34.             t->timeout_func(t->parameter);//产生定时器超时事件，调用对应处理函数  
    35.   
    36.             /* re-get tick */  
    37.             current_tick = rt_tick_get();//再次获取当前时间点  
    38.   
    39.             RT_DEBUG_LOG(RT_DEBUG_TIMER, ("current tick: %d ", current_tick));  
    40.   
    41.             if ((t->parent.flag & RT_TIMER_FLAG_PERIODIC) &&//如果当前定时器是周期性定时器，则将其再次按序放入软件定时器链表  
    42.                 (t->parent.flag & RT_TIMER_FLAG_ACTIVATED))  
    43.             {  
    44.                 /* start it */  
    45.                 t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;//置标志为非激活状态  
    46.                 rt_timer_start(t);//再次将定时器t放入软件定时器链表末尾  
    47.             }  
    48.             else  
    49.             {  
    50.                 /* stop timer */  
    51.                 t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;//置标志为非激活状态  
    52.             }  
    53.         }  
    54.         else break; /* not check anymore */  
    55.     }  
    56.   
    57.     RT_DEBUG_LOG(RT_DEBUG_TIMER, ("software timer check leave "));  
    58. }  

    上面代码中，为什么定时器里判断超时的条件是((current_tick - t→timeout_tick) < RT_TICK_MAX/2)？

    因为系统时钟溢出后会自动回绕。取定时器比较最大值是定时器最大值的一半，即RT_TICK_MAX/2（在比较两个定时器值时，值是32位无符号数，相减运算将会自动回绕）。系统支持的定时器最大长度就是RT_TICK_MAX的一半：即248天(10ms/tick)，124天(5ms/tick)，24.5天(1ms/tick)，以下内容相同道理。

    其上rt_timer_start函数如下定义:

    [cpp] view plain copy
     
    1. /** 
    2.  * This function will start the timer 
    3.  * 
    4.  * @param timer the timer to be started 
    5.  * 
    6.  * @return the operation status, RT_EOK on OK, -RT_ERROR on error 
    7.  */  
    8. rt_err_t rt_timer_start(rt_timer_t timer)  
    9. {  
    10.     struct rt_timer *t;  
    11.     register rt_base_t level;  
    12.     rt_list_t *n, *timer_list;  
    13.   
    14.     /* timer check */  
    15.     RT_ASSERT(timer != RT_NULL);  
    16.     if (timer->parent.flag & RT_TIMER_FLAG_ACTIVATED)//如果传入的定时器已经激活，则直接返回错误  
    17.         return -RT_ERROR;  
    18.   
    19.     RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(timer->parent)));//使用钩子函数  
    20.   
    21.     /* 
    22.      * get timeout tick, 
    23.      * the max timeout tick shall not great than RT_TICK_MAX/2 
    24.      */  
    25.     RT_ASSERT(timer->init_tick < RT_TICK_MAX / 2);  
    26.     timer->timeout_tick = rt_tick_get() + timer->init_tick;//得到定时器超时的时间点  
    27.   
    28.     /* disable interrupt */  
    29.     level = rt_hw_interrupt_disable();//关中断  
    30.   
    31. #ifdef RT_USING_TIMER_SOFT//如果采用的是软件定时器管理模式，则将定时器加入到rt_soft_timer_list中  
    32.     if (timer->parent.flag & RT_TIMER_FLAG_SOFT_TIMER)  
    33.     {  
    34.         /* insert timer to soft timer list */  
    35.         timer_list = &rt_soft_timer_list;  
    36.     }  
    37.     else  
    38. #endif  
    39.     {  
    40.         /* insert timer to system timer list */  
    41.         timer_list = &rt_timer_list;  
    42.     }  
    43.   
    44.     for (n = timer_list->next; n != timer_list; n = n->next)//将定时器按序加入到定时器链表中  
    45.     {  
    46.         t = rt_list_entry(n, struct rt_timer, list);  
    47.           
    48.         /* 
    49.          * It supposes that the new tick shall less than the half duration of 
    50.          * tick max. 
    51.          */  
    52.         if ((t->timeout_tick - timer->timeout_tick) < RT_TICK_MAX / 2)  
    53.         {  
    54.             rt_list_insert_before(n, &(timer->list));//将定时器timer插入到t之前  
    55.             break;  
    56.         }  
    57.     }  
    58.     /* no found suitable position in timer list */  
    59.     if (n == timer_list)//没有找到合适的位置，则放到链表头  
    60.     {  
    61.         rt_list_insert_before(n, &(timer->list));  
    62.     }  
    63.   
    64.     timer->parent.flag |= RT_TIMER_FLAG_ACTIVATED;//置定时器为激活状态  
    65.   
    66.     /* enable interrupt */  
    67.     rt_hw_interrupt_enable(level);  
    68.   
    69. #ifdef RT_USING_TIMER_SOFT  
    70.     if (timer->parent.flag & RT_TIMER_FLAG_SOFT_TIMER)//如果系统采用的是软件定时器管理模式，且软件定时器线程处理ready状态，则恢复此线程  
    71.     {  
    72.         /* check whether timer thread is ready */  
    73.         if (timer_thread.stat != RT_THREAD_READY)  
    74.         {  
    75.             /* resume timer thread to check soft timer */  
    76.             rt_thread_resume(&timer_thread);//恢复定时器线程  
    77.             rt_schedule();//开始线程调度  
    78.         }  
    79.     }  
    80. #endif  
    81.   
    82.     return -RT_EOK;  
    83. }  


    软件定时器管理模式的源码分析完了，接下来介绍RTT的硬件定时器管理模式。

    3.3 RTT的硬件定时器管理模式

    硬件定时器管理模式顾名思义，就是说与硬件相关，因此，不用的MCU，其部分源码是不一样的，因为其要采用MCU的系统时钟中断例程来实现。

    以STM32F2XX为例，先找到其启动汇编，位置在：RTT/bsp/stm32f2xx/Libraries/CMSIS/CM3/DeviceSupport/ST/STM32F2xx/startup/arm/startup_stm32f2xx.s

    找到中断向量:

    [plain] view plain copy
     
    1. DCD     SysTick_Handler            ; SysTick Handler  

    这是系统时钟中断向量，再找到其中断例程实现：

    在bsp/stm32f2xx/drivers/board.c文件中:

    [cpp] view plain copy
     
    1. /** 
    2.  * This is the timer interrupt service routine. 
    3.  * 
    4.  */  
    5. void SysTick_Handler(void)//系统时钟中断例程  
    6. {  
    7.     /* enter interrupt */  
    8.     rt_interrupt_enter();  
    9.   
    10.     rt_tick_increase();  
    11.   
    12.     /* leave interrupt */  
    13.     rt_interrupt_leave();  
    14. }  


    其中rt_tick_increase函数在RTT/src/clock.c文件中的实现如下:

    [cpp] view plain copy
     
    1. /** 
    2.  * This function will notify kernel there is one tick passed. Normally, 
    3.  * this function is invoked by clock ISR. 
    4.  */  
    5. void rt_tick_increase(void)  
    6. {  
    7.     struct rt_thread *thread;  
    8.   
    9.     /* increase the global tick */  
    10.     ++ rt_tick;//全局rt_tick加1  
    11.   
    12.     /* check time slice */  
    13.     thread = rt_thread_self();//得到当前正在运行的线程  
    14.   
    15.     -- thread->remaining_tick;//纯种剩下时间减1  
    16.     if (thread->remaining_tick == 0)//如果线程剩余时间为0，即调度时间已到  
    17.     {  
    18.         /* change to initialized tick */  
    19.         thread->remaining_tick = thread->init_tick;//将线程剩余时间重新设置初始化值  
    20.   
    21.         /* yield */  
    22.         rt_thread_yield();//调度时间到，切换到其它线程  
    23.     }  
    24.   
    25.     /* check timer */  
    26.     rt_timer_check();//检查硬件定时器链表是否有定时器产生超时事件  
    27. }  


    其中rt_timer_check函数在RTT/src/timer.c文件中如下定义:

    [cpp] view plain copy
     
    1. /** 
    2.  * This function will check timer list, if a timeout event happens, the 
    3.  * corresponding timeout function will be invoked. 
    4.  * 
    5.  * @note this function shall be invoked in operating system timer interrupt. 
    6.  */  
    7. void rt_timer_check(void)  
    8. {  
    9.     struct rt_timer *t;  
    10.     rt_tick_t current_tick;  
    11.     register rt_base_t level;  
    12.   
    13.     RT_DEBUG_LOG(RT_DEBUG_TIMER, ("timer check enter "));  
    14.   
    15.     current_tick = rt_tick_get();  
    16.   
    17.     /* disable interrupt */  
    18.     level = rt_hw_interrupt_disable();  
    19.   
    20.     while (!rt_list_isempty(&rt_timer_list))  
    21.     {  
    22.         t = rt_list_entry(rt_timer_list.next, struct rt_timer, list);  
    23.   
    24.         /* 
    25.          * It supposes that the new tick shall less than the half duration of 
    26.          * tick max. 
    27.          */  
    28.         if ((current_tick - t->timeout_tick) < RT_TICK_MAX/2)  
    29.         {  
    30.             RT_OBJECT_HOOK_CALL(rt_timer_timeout_hook, (t));  
    31.   
    32.             /* remove timer from timer list firstly */  
    33.             rt_list_remove(&(t->list));  
    34.   
    35.             /* call timeout function */  
    36.             t->timeout_func(t->parameter);  
    37.   
    38.             /* re-get tick */  
    39.             current_tick = rt_tick_get();  
    40.   
    41.             RT_DEBUG_LOG(RT_DEBUG_TIMER, ("current tick: %d ", current_tick));  
    42.   
    43.             if ((t->parent.flag & RT_TIMER_FLAG_PERIODIC) &&  
    44.                 (t->parent.flag & RT_TIMER_FLAG_ACTIVATED))  
    45.             {  
    46.                 /* start it */  
    47.                 t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;  
    48.                 rt_timer_start(t);  
    49.             }  
    50.             else  
    51.             {  
    52.                 /* stop timer */  
    53.                 t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;  
    54.             }  
    55.         }  
    56.         else  
    57.             break;  
    58.     }  
    59.   
    60.     /* enable interrupt */  
    61.     rt_hw_interrupt_enable(level);  
    62.   
    63.     RT_DEBUG_LOG(RT_DEBUG_TIMER, ("timer check leave "));  
    64. }  


    此函数与rt_soft_timer_check基本大致相同，只不过一个是查找硬件定时器链表rt_timer_list，一个是查找rt_soft_timer_list.

    在此，硬件定时器管理模式基本上介绍完毕，接下来介绍一些定时器接口.

    4 定时器接口

    4.1 定时器初始化

    静态初始化定义器

    [cpp] view plain copy
     
    1. /** 
    2.  * This function will initialize a timer, normally this function is used to 
    3.  * initialize a static timer object. 
    4.  * 
    5.  * @param timer the static timer object 
    6.  * @param name the name of timer 
    7.  * @param timeout the timeout function 
    8.  * @param parameter the parameter of timeout function 
    9.  * @param time the tick of timer 
    10.  * @param flag the flag of timer 
    11.  */  
    12. void rt_timer_init(rt_timer_t  timer,  
    13.                    const char *name,  
    14.                    void (*timeout)(void *parameter),  
    15.                    void       *parameter,  
    16.                    rt_tick_t   time,  
    17.                    rt_uint8_t  flag)  
    18. {  
    19.     /* timer check */  
    20.     RT_ASSERT(timer != RT_NULL);  
    21.   
    22.     /* timer object initialization */  
    23.     rt_object_init((rt_object_t)timer, RT_Object_Class_Timer, name);//初始化内核对象  
    24.   
    25.     _rt_timer_init(timer, timeout, parameter, time, flag);  
    26. }  


    _rt_timer_init函数如下定义:

    [cpp] view plain copy
     
    1. static void _rt_timer_init(rt_timer_t timer,  
    2.                            void (*timeout)(void *parameter),  
    3.                            void      *parameter,  
    4.                            rt_tick_t  time,  
    5.                            rt_uint8_t flag)  
    6. {  
    7.     /* set flag */  
    8.     timer->parent.flag  = flag;//置flag  
    9.   
    10.     /* set deactivated */  
    11.     timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;//初始化时，设置为非激活状态  
    12.   
    13.     timer->timeout_func = timeout;//设置超时事件处理函数  
    14.     timer->parameter    = parameter;//超时事件处理函数的传入参数  
    15.   
    16.     timer->timeout_tick = 0;//定时器的超时时间点初始化时为0  
    17.     timer->init_tick    = time;//置超时时间  
    18.   
    19.     /* initialize timer list */  
    20.     rt_list_init(&(timer->list));//初始化本身节点  
    21. }  

    动态创建定时器

    [cpp] view plain copy
     
    1. /** 
    2.  * This function will create a timer 
    3.  * 
    4.  * @param name the name of timer 
    5.  * @param timeout the timeout function 
    6.  * @param parameter the parameter of timeout function 
    7.  * @param time the tick of timer 
    8.  * @param flag the flag of timer 
    9.  * 
    10.  * @return the created timer object 
    11.  */  
    12. rt_timer_t rt_timer_create(const char *name,  
    13.                            void (*timeout)(void *parameter),  
    14.                            void       *parameter,  
    15.                            rt_tick_t   time,  
    16.                            rt_uint8_t  flag)  
    17. {  
    18.     struct rt_timer *timer;  
    19.   
    20.     /* allocate a object */  
    21.     timer = (struct rt_timer *)rt_object_allocate(RT_Object_Class_Timer, name);//动态分配定时器内核对象  
    22.     if (timer == RT_NULL)  
    23.     {  
    24.         return RT_NULL;  
    25.     }  
    26.   
    27.     _rt_timer_init(timer, timeout, parameter, time, flag);//调用上述的初始化接口  
    28.   
    29.     return timer;  
    30. }  



    4.2 脱离和删除

    脱离:

    [cpp] view plain copy
     
    1. /** 
    2.  * This function will detach a timer from timer management. 
    3.  * 
    4.  * @param timer the static timer object 
    5.  * 
    6.  * @return the operation status, RT_EOK on OK; RT_ERROR on error 
    7.  */  
    8. rt_err_t rt_timer_detach(rt_timer_t timer)  
    9. {  
    10.     register rt_base_t level;  
    11.   
    12.     /* timer check */  
    13.     RT_ASSERT(timer != RT_NULL);  
    14.   
    15.     /* disable interrupt */  
    16.     level = rt_hw_interrupt_disable();//关中断  
    17.   
    18.     /* remove it from timer list */  
    19.     rt_list_remove(&(timer->list));//从定时器链表中移除  
    20.   
    21.     /* enable interrupt */  
    22.     rt_hw_interrupt_enable(level);//开中断  
    23.   
    24.     rt_object_detach((rt_object_t)timer);//脱离内核对象  
    25.   
    26.     return -RT_EOK;  
    27. }  

    删除动态创建的定时器

    [cpp] view plain copy
     
    1. /** 
    2.  * This function will delete a timer and release timer memory 
    3.  * 
    4.  * @param timer the timer to be deleted 
    5.  * 
    6.  * @return the operation status, RT_EOK on OK; RT_ERROR on error 
    7.  */  
    8. rt_err_t rt_timer_delete(rt_timer_t timer)  
    9. {  
    10.     register rt_base_t level;  
    11.   
    12.     /* timer check */  
    13.     RT_ASSERT(timer != RT_NULL);  
    14.   
    15.     /* disable interrupt */  
    16.     level = rt_hw_interrupt_disable();//关中断  
    17.   
    18.     /* remove it from timer list */  
    19.     rt_list_remove(&(timer->list));//从定时器链表中移除  
    20.   
    21.     /* enable interrupt */  
    22.     rt_hw_interrupt_enable(level);//开中断  
    23.   
    24.     rt_object_delete((rt_object_t)timer);//删除动态创建的定时器内核对象  
    25.   
    26.     return -RT_EOK;  
    27. }  

    4.3 启动定时器

    [cpp] view plain copy
     
    1. /** 
    2.  * This function will start the timer 
    3.  * 
    4.  * @param timer the timer to be started 
    5.  * 
    6.  * @return the operation status, RT_EOK on OK, -RT_ERROR on error 
    7.  */  
    8. rt_err_t rt_timer_start(rt_timer_t timer)  

    此接口已在上面介绍软件定时器模式时已有分析，这里就不再重复了。

    4.4 停止定时器

    [cpp] view plain copy
     
    1. /** 
    2.  * This function will stop the timer 
    3.  * 
    4.  * @param timer the timer to be stopped 
    5.  * 
    6.  * @return the operation status, RT_EOK on OK, -RT_ERROR on error 
    7.  */  
    8. rt_err_t rt_timer_stop(rt_timer_t timer)  
    9. {  
    10.     register rt_base_t level;  
    11.   
    12.     /* timer check */  
    13.     RT_ASSERT(timer != RT_NULL);  
    14.     if (!(timer->parent.flag & RT_TIMER_FLAG_ACTIVATED))//如果定时器已经为非激活状态  
    15.         return -RT_ERROR;  
    16.   
    17.     RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(timer->parent)));//使用钩子函数  
    18.   
    19.     /* disable interrupt */  
    20.     level = rt_hw_interrupt_disable();//关中断  
    21.   
    22.     /* remove it from timer list */  
    23.     rt_list_remove(&(timer->list));//从定时器链表中移除  
    24.   
    25.     /* enable interrupt */  
    26.     rt_hw_interrupt_enable(level);//开中断  
    27.   
    28.     /* change stat */  
    29.     timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;//置非激活状态  
    30.   
    31.     return RT_EOK;  
    32. }  

    4.5 控制

    此接口是用来修改一个定时器的参数，如下代码：

    [cpp] view plain copy
     
    1. /** 
    2.  * This function will get or set some options of the timer 
    3.  * 
    4.  * @param timer the timer to be get or set 
    5.  * @param cmd the control command 
    6.  * @param arg the argument 
    7.  * 
    8.  * @return RT_EOK 
    9.  */  
    10. rt_err_t rt_timer_control(rt_timer_t timer, rt_uint8_t cmd, void *arg)  
    11. {  
    12.     /* timer check */  
    13.     RT_ASSERT(timer != RT_NULL);  
    14.   
    15.     switch (cmd)  
    16.     {  
    17.     case RT_TIMER_CTRL_GET_TIME://获取时间参数  
    18.         *(rt_tick_t *)arg = timer->init_tick;  
    19.         break;  
    20.   
    21.     case RT_TIMER_CTRL_SET_TIME://修改时间参数  
    22.         timer->init_tick = *(rt_tick_t *)arg;  
    23.         break;  
    24.   
    25.     case RT_TIMER_CTRL_SET_ONESHOT://修改定时器模式为单次触发定时器  
    26.         timer->parent.flag &= ~RT_TIMER_FLAG_PERIODIC;  
    27.         break;  
    28.   
    29.     case RT_TIMER_CTRL_SET_PERIODIC://修改定时器为周期触发定时器  
    30.         timer->parent.flag |= RT_TIMER_FLAG_PERIODIC;  
    31.         break;  
    32.     }  
    33.   
    34.     return RT_EOK;  
    35. }  



    完!
  • 相关阅读:
    分享一个文件的工具类
    关于itext生成pdf的新的demo(包含简单的提取txt文件的内容 和xml内容转化为pdf)
    全文检索的Demo
    dom4j操作xml的demo
    利用Java获取ip地址
    利用htmlparser读取html文档的内容
    关于pdfbox操作pdf的分享链接手长
    poi读取word的内容
    基于NPOI对Excel进行简单的操作
    “尝试加载 Oracle 客户端库时引发 BadImageFormatException。如果在安装 32 位 Oracle 客户端组件的情况下以 64 位模式运行，将出现此问题。”
  • 原文地址：https://www.cnblogs.com/jiangzhaowei/p/8523543.html
Copyright © 2011-2022 走看看