Chinaunix首页 | 论坛 | 博客

胡说-操作系统

首页　| 　博文目录　| 　关于我

zhuimengcanyang

  • 博客访问： 830972
  • 博文数量： 281
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 2770
  • 用 户 组： 普通用户
  • 注册时间： 2009-08-02 19:45
个人简介

邮箱：zhuimengcanyang@163.com 痴爱嵌入式技术的蜗牛

文章分类

全部博文（281）

文章存档

2020年（1）

2018年（1）

2017年（56）

2016年（72）

2015年（151）

最近访客
推荐博文
相关博文
嵌入式设计编程：软件定时器_1

分类： 嵌入式

2015-12-10 15:18:13

软件定时器，利用链表结构来封装定时器。

1. 数据结构体

点击(此处)折叠或打开

  1. typedef struct softtimer_t
  2. {
  3.     bool isRunning;
  4.     uint32_t currentTicksRemaining;

  6.     TimeOutCallbackPtr timeOutCallback;
  7.     uint32_t periodInTicks;    // non-zero for periodic timer

  9.     struct softtimer_t* next;
  10. } softtimer_t;
（1）isRunning： 标志timer是否处于允许状态
（2）currentTicksRemaining： 表示还剩下多少tick需要运行
（3）timeOutCallback：定时器时间到的处理函数
（4）periodInTicks： 设置定时器的重复周期
（5）* next：  软件定时器指针，指向下一个定时器，实现单向链表。

2. 相关配置

点击(此处)折叠或打开

  1. // 设置节拍的事件，这里设置每10ms产生一个节拍
  2. #define TIMER_MILLISECONDS_PER_TICK 10

  4. // 定时器初始化
  5. #define TIMER_INIT { /*isRunning*/false, /*currentTicksRemaining*/0, /*timeOutCallback*/NULL, /*periodInTicks*/0, /*next*/NULL }
  6. #define TIMER_DYNINIT(x) { (x).isRunning = false; (x).next=NULL; }

  8. typedef void (*TimeOutCallbackPtr)(void* data);

3. 处理函数

3.1 启动定时器

点击(此处)折叠或打开

  1. static void Timer_StartTimer(softtimer_t* timer, uint32_t periodInMilliseconds, TimeOutCallbackPtr callback)
  2. {
  3.     Timer_StopTimer(timer);
  4.     timer->currentTicksRemaining = Timer_ConvertMillisecondsToTicks(periodInMilliseconds) + (uint32_t)timerTicks; // 计算出总的tick
  5.     timer->timeOutCallback = callback;  // 设置时间到处理函数
  6.     timer->isRunning = true;            // 启动定时器
  7.     if (timer->next == NULL)            // 将timer加入到链表中
  8.     {
  9.         timer->next = timerList;
  10.         timerList = timer;
  11.     }
  12. }
可以得出software timer链表结构图：


3.2 关闭定时器

点击(此处)折叠或打开

  1. void Timer_StopTimer(softtimer_t* timer)
  2. {
  3.     timer->isRunning = false;
  4. }

3.3 设置定时器为单次或者为周期性

点击(此处)折叠或打开

  1. void Timer_StartSingleShot(softtimer_t* timer, uint32_t periodInMilliseconds, TimeOutCallbackPtr callback)
  2. {
  3.     timer->periodInTicks = 0;
  4.     Timer_StartTimer(timer, periodInMilliseconds, callback);
  5. }

  7. void Timer_StartPeriodic(softtimer_t* timer, uint32_t periodInMilliseconds, TimeOutCallbackPtr callback)
  8. {
  9.     timer->periodInTicks = Timer_ConvertMillisecondsToTicks(periodInMilliseconds);
  10.     Timer_StartTimer(timer, periodInMilliseconds, callback);
  11. }

3.4 获取定时器剩余的事件（ms）

点击(此处)折叠或打开

  1. uint32_t Timer_GetRemainingMs(softtimer_t* timer)
  2. {
  3.     return (timer->isRunning ? timer->currentTicksRemaining * TIMER_MILLISECONDS_PER_TICK : 0);
  4. }

3.5 定时器中断回调函数

点击(此处)折叠或打开

  1. void Callback_Timer_TickISR(void)
  2. {
  3.     timerTicks++;
  4.     EventQueue_Enqueue(&hwTimerExpired);
  5. }
这个函数由具体的定时器中断函数所调用，产生ticks事件，并且加入到事件队列中。
static event_t hwTimerExpired = EVENT_INIT( OnTimerTicksEvent );

当事件：hwTimerExpired 发生时，将调用其定义好的tick事件函数： OnTimerTicksEvent

点击(此处)折叠或打开

  1. static void OnTimerTicksEvent(void* data)
  2. {
  3.     uint8_t elapsedTicks;
  4.     UNUSED_PARAMETER(data);

  6.     // atomically copy and reset timer ticks
  7.     Common_AtomicSection_Begin();
  8.     elapsedTicks = timerTicks;
  9.     timerTicks = 0;
  10.     Common_AtomicSection_End();

  12.     while ( elapsedTicks > 0 )
  13.     {
  14.         OnTimerTickPassed();
  15.         elapsedTicks--;
  16.     }
  17. }
进一步调用： OnTimerTickPassed(); 实现真正的定时器操作

点击(此处)折叠或打开

  1. static void OnTimerTickPassed(void)
  2. {
  3.     softtimer_t* timer;

  5.     for (timer = timerList; timer != NULL; timer = timer->next)    // 循环队列处理
  6.     {
  7.         if (timer->isRunning )
  8.         {
  9.             timer->currentTicksRemaining--;

  11.             if (timer->currentTicksRemaining == 0)
  12.             {
  13.                 if (timer->periodInTicks == 0) // one shot timer
  14.                 {
  15.                     Timer_StopTimer(timer);
  16.                 }
  17.                 else // periodic timer
  18.                 {
  19.                     timer->currentTicksRemaining = timer->periodInTicks;
  20.                 }

  22.                 timer->timeOutCallback(NULL);   // 调用回调函数
  23.             }
  24.         }
  25.     }
  26. }



4. 完整代码：

点击(此处)折叠或打开

  1. #include "Timers.h"
  2. #include "EventQueue.h"

  4. #include "hal_time.h"


  7. static void OnTimerTickPassed(void);
  8. static void OnTimerTicksEvent(void* data);

  10. static event_t hwTimerExpired = EVENT_INIT(OnTimerTicksEvent);
  11. static volatile uint8_t timerTicks = 0;

  13. static softtimer_t sentinelAtEnd = TIMER_INIT;
  14. static softtimer_t* timerList = &sentinelAtEnd;

  16. // Private functions


  19. static uint32_t Timer_ConvertMillisecondsToTicks(uint32_t periodInMilliseconds)
  20. {
  21.     return (periodInMilliseconds + TIMER_MILLISECONDS_PER_TICK - 1) / TIMER_MILLISECONDS_PER_TICK;
  22. }

  24. static void Timer_StartTimer(softtimer_t* timer, uint32_t periodInMilliseconds, TimeOutCallbackPtr callback)
  25. {
  26.     Timer_StopTimer(timer);
  27.     timer->currentTicksRemaining = Timer_ConvertMillisecondsToTicks(periodInMilliseconds) + (uint32_t)timerTicks; // add backlog
  28.     timer->timeOutCallback = callback;
  29.     timer->isRunning = true;
  30.     if (timer->next == NULL)
  31.     {
  32.         timer->next = timerList;
  33.         timerList = timer;
  34.     }
  35. }

  37. // Public functions

  39. void Timer_Initialize(void)
  40. {
  41. #ifdef UNIT_TESTING
  42.     // to ease unit testing, deconstruct the timer list
  43.     // and reinitialize the timers that were in it.
  44.     // In production code, everything is initialized statically
  45.     // and Init must not be called more then once.
  46.     while(timerList != NULL)
  47.     {
  48.         softtimer_t* tmp = timerList;
  49.         timerList = timerList->next;

  51.         // re-initialize the timer object
  52.         TIMER_DYNINIT((*tmp));
  53.     }
  54.     timerList = &sentinelAtEnd;
  55.     timerTicks = 0;
  56. #endif
  57. }

  59. void Timer_StartSingleShot(softtimer_t* timer, uint32_t periodInMilliseconds, TimeOutCallbackPtr callback)
  60. {
  61.     timer->periodInTicks = 0;
  62.     Timer_StartTimer(timer, periodInMilliseconds, callback);
  63. }

  65. void Timer_StartPeriodic(softtimer_t* timer, uint32_t periodInMilliseconds, TimeOutCallbackPtr callback)
  66. {
  67.     timer->periodInTicks = Timer_ConvertMillisecondsToTicks(periodInMilliseconds);
  68.     Timer_StartTimer(timer, periodInMilliseconds, callback);
  69. }

  71. void Timer_StopTimer(softtimer_t* timer)
  72. {
  73.     timer->isRunning = false;
  74. }

  76. uint32_t Timer_GetRemainingMs(softtimer_t* timer)
  77. {
  78.     return (timer->isRunning ? timer->currentTicksRemaining * TIMER_MILLISECONDS_PER_TICK : 0);
  79. }

  81. void Callback_Timer_TickISR(void)
  82. {
  83.     timerTicks++;
  84.     EventQueue_Enqueue(&hwTimerExpired);
  85. }

  87. static void OnTimerTickPassed(void)
  88. {
  89.     softtimer_t* timer;

  91.     for (timer = timerList; timer != NULL; timer = timer->next)
  92.     {
  93.         if (timer->isRunning )
  94.         {
  95.             timer->currentTicksRemaining--;

  97.             if (timer->currentTicksRemaining == 0)
  98.             {
  99.                 if (timer->periodInTicks == 0) // one shot timer
  100.                 {
  101.                     Timer_StopTimer(timer);
  102.                 }
  103.                 else // periodic timer
  104.                 {
  105.                     timer->currentTicksRemaining = timer->periodInTicks;
  106.                 }

  108.                 timer->timeOutCallback(NULL);
  109.             }
  110.         }
  111.     }
  112. }

  114. static void OnTimerTicksEvent(void* data)
  115. {
  116.     uint8_t elapsedTicks;
  117.     UNUSED_PARAMETER(data);

  119.     // atomically copy and reset timer ticks
  120.     Common_AtomicSection_Begin();
  121.     elapsedTicks = timerTicks;
  122.     timerTicks = 0;
  123.     Common_AtomicSection_End();

  125. // if (elapsedTicks > 4)
  126.     {
  127. // printf ("e: %d\n", elapsedTicks);
  128.     }
  129.     while ( elapsedTicks > 0 )
  130.     {
  131.         OnTimerTickPassed();
  132.         elapsedTicks--;
  133.     }
  134. }

点击(此处)折叠或打开

  1. #ifndef TIMERS_H
  2. #define    TIMERS_H

  4. #include "Common.h"

  6. #define TIMER_MILLISECONDS_PER_TICK 10

  8. #define TIMER_INIT { /*isRunning*/false, /*currentTicksRemaining*/0, /*timeOutCallback*/NULL, /*periodInTicks*/0, /*next*/NULL }
  9. #define TIMER_DYNINIT(x) { (x).isRunning = false; (x).next=NULL; }


  12. typedef void (*TimeOutCallbackPtr)(void* data);

  14. /* A timer MUST be initialized with TIMER_INIT or TIMER_DYNINIT */
  15. /* A timer MUST not not be a stack (auto) */
  16. typedef struct softtimer_t
  17. {
  18.     bool isRunning;
  19.     uint32_t currentTicksRemaining;

  21.     TimeOutCallbackPtr timeOutCallback;
  22.     uint32_t periodInTicks;    // non-zero for periodic timer

  24.     struct softtimer_t* next;
  25. } softtimer_t;

  27. void Timer_Initialize(void);

  29. void Timer_StartSingleShot(softtimer_t* timer, uint32_t periodInMilliseconds, TimeOutCallbackPtr callback);
  30. void Timer_StartPeriodic(softtimer_t* timer, uint32_t periodInMilliseconds, TimeOutCallbackPtr callback);
  31. void Timer_StopTimer(softtimer_t* timer);
  32. uint32_t Timer_GetRemainingMs(softtimer_t* timer);
  33. void Callback_Timer_TickISR(void);

  35. #endif    /* TIMERS_H */


阅读(1409) | 评论(0) | 转发(0) |
0

上一篇：嵌入式设计编程：事件及事件队列_2

下一篇：嵌入式设计编程：软件定时器_2

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6