前言：这里不谈RTOS，而是主要针对裸机开发，很多时候，我们发现硬件定时器是不够用的，于是乎，很多时候，
程序员都会利用一个硬件定时器来产生N个软件定时器，误差是肯定有的，但是误差范围是可接受的，这样，
就能解决了很多时候定时器不够用的场合。
当然，楼主也遇到这种时候，所以就临时写了个软件定时器。

主题：这个软甲定时器采用了数组+回调的机制，硬件定时器产生tick，而主循环中获取tick产生计数，计数到达之后
调用定时器对应的回调函数。其中包含删除，注册的功能。

数据结构

1. typedef struct soft_timer {
   
2.     uint32_t timer_count;      //定时器用的计数器
   
3.     uint32_t time_out;           //阀值
   
4.     void (*time_out_callback)(void *param); //回调函数
   
5.     void *param; //回调函数参数
   
6.     uint8_t timer_flag; //定时器属性标志
   
7. }soft_timer_t;

复制代码

原理很简单，主循环timer_count不断的自减，到0的时候就调用一次函数，不停循环。

1. <blockquote>/*

复制代码

以上是使用到的api接口，分别是注册，删除，初始化，中断调用，主循环任务函数，
一下是源码：

1. /*
   
2. * !brief include header
   
3. */
   
4. #include <stdint.h>
   
5. #include "soft_timer.h"
   
6. 
   
7. 
   
8. #ifndef NULL
   
9. #define NULL ((void *)0)
   
10. #endif
    
11. 
    
12. 
    
13. 
    
14. /*
    
15. * !brief
    
16. */
    
17. static uint8_t exec_run_flag;
    
18. 
    
19. /*
    
20. * !brief timer_list, you can change the timers num by SOFT_TIMERS_MAX
    
21. */
    
22. static soft_timer_t timer_list[SOFT_TIMERS_MAX];
    
23. 
    
24. /*
    
25. * !brief module init, you can run this function in first main
    
26. */
    
27. void soft_timer_init(void)
    
28. {
    
29.     uint8_t i;
    
30.     for (i = 0; i < SOFT_TIMERS_MAX; i++) {
    
31.         timer_list[i].timer_count = 0;
    
32.         timer_list[i].timer_flag = 0;
    
33.         timer_list[i].time_out = 0;
    
34.         timer_list[i].time_out_callback = NULL;
    
35.         timer_list[i].param = NULL;
    
36.     }
    
37. }
    
38. 
    
39. /*
    
40. * !brief use this function to create a soft_timer
    
41. * !param first time the timer count machine's period
    
42. * !param every loop cycles
    
43. * !param callback run with the time up
    
44. * !param callback 's param
    
45. * !param 0:periods 1:one shot
    
46. * !retval timer handle
    
47. */
    
48. soft_timer_handle_t soft_timer_registered(uint32_t first_timer_period,
    
49.                                           uint32_t period,
    
50.                                           timer_out_callback *callback,
    
51.                                           void *callback_param,
    
52.                                           uint8_t flag)
    
53. {
    
54.     uint8_t i;
    
55.    
    
56.     if (callback == NULL) return NULL;
    
57.    
    
58.     for (i = 0; i < SOFT_TIMERS_MAX; i++) {
    
59.         if (timer_list[i].time_out_callback != NULL) continue;
    
60.         timer_list[i].timer_count = first_timer_period;
    
61.         timer_list[i].time_out = period;
    
62.         timer_list[i].time_out_callback = callback;
    
63.         timer_list[i].param = callback_param;
    
64.         timer_list[i].timer_flag = flag;
    
65.         break;
    
66.     }
    
67.    
    
68.     return (soft_timer_handle_t)&timer_list[i];
    
69. }
    
70. 
    
71. /*
    
72. * !brief you can use this function to delete a soft_timer
    
73. * !param timer handle
    
74. * !retval 0 is successful, 1 is fail
    
75. */
    
76. int soft_timer_delete(soft_timer_handle_t handle)
    
77. {
    
78.     soft_timer_t *p = (soft_timer_t *)handle;
    
79.    
    
80.    
    
81.     if (p == NULL) return 1;
    
82.     p->time_out_callback = NULL;
    
83.    
    
84.     return 0;
    
85. }
    
86. 
    
87. /*
    
88. * !brief you should run this function in a hardware timer interrupt
    
89. *        it can provide ticks for soft_timer
    
90. */
    
91. void soft_timer_interrupt(void)
    
92. {
    
93.     if (exec_run_flag < 100)
    
94.         exec_run_flag ++;
    
95. }
    
96. 
    
97. /*
    
98. * !brief you should run this function in main loop
    
99. */
    
100. void soft_timer_exec(void)
     
101. {
     
102.     uint8_t i;
     
103.    
     
104.     if (exec_run_flag == 0) return;
     
105.     exec_run_flag --;
     
106.     for (i = 0; i < SOFT_TIMERS_MAX; i ++) {
     
107.         if (timer_list[i].time_out_callback == NULL) continue;
     
108.         if (timer_list[i].timer_count) {
     
109.             timer_list[i].timer_count --;
     
110.         } else {
     
111.             timer_list[i].time_out_callback(timer_list[i].param);
     
112.             if (!timer_list[i].timer_flag) {
     
113.                 timer_list[i].timer_count = timer_list[i].time_out;
     
114.             } else {    //one shot
     
115.                 timer_list[i].time_out_callback = NULL;
     
116.             }
     
117.         }
     
118.     }
     
119. }

复制代码

总结，虽然误差是肯定有的，但是由于误差可接受，所以用起来还是很方便的，如果哪里写的不好，还请给点意见！

谢谢分享         

感谢分享！

标记收藏！

总体来说就是时间片！！！！当然了也相当于一个调度系统。。。。只是这里的打断要自己主动让出MCU！！！

MrJiu 发表于 2017-7-21 10:16
总体来说就是时间片！！！！当然了也相当于一个调度系统。。。。只是这里的打断要自己主动让出MCU！！！; ...

定时器的中断周期一般是1ms，也就是这个软件定时器的误差是毫秒级的，中断的处理很短基本可以忽略，主要其他任务不阻塞，还是很准确的。

把count--换成直接对比比较好，count--需要读内存，减一，放回内存，比较四步，直接对比只需要读内存，比较两步。直接比较就是当前tick+定时tick而已

Dandjinh 发表于 2017-7-21 12:09
把count--换成直接对比比较好，count--需要读内存，减一，放回内存，比较四步，直接对比只需要读内存，比较 ...

你的意思是把tick当成所有的计数器？如果这样子，定时器之间就不能相互独立了

Inc_brza 发表于 2017-7-21 12:27
你的意思是把tick当成所有的计数器？如果这样子，定时器之间就不能相互独立了 ...

定义个全局tick，定时加一，作为标准，定时器触发的标准就是注册时的tick+period

感谢分享！