接上篇：时驱函数了解一下
; t9 ~- I9 g7 F  S. Z2 u
& u0 j% _6 d5 H) K前一篇帖子我写了时驱函数的设计本质是一种前后台程序，本文依旧如故。后台程序放到定时器里面，周期性的调用。这个程序程序是扫描一个链表，链表中每一个成员 噢 应该说没一个节点都设计好数据的结构体，到达设定的时间就执行回调函数。
- W7 x3 D& I! o' }# S4 F功能：完成约定时间调用回调函数。
头文件：

1. #ifndef _TIMELIST_H_
   
2. #define _TIMELIST_H_
   
3. 
   7 b2 K' h6 m# {
4. #include "sys.h"
   
5. typedef struct  _time
   1 _$ O8 b' S' {$ k
6. {
   
7.         void        *next;//指向后一个
     d: c! v' o) K& s- q' i9 e
8.         uint8_t     handle;//自己的ID号
   # U0 E1 s5 N$ [5 F# ~0 _
9.         uint8_t     start;//开关1开0关
   
10.         uint32_t    cnt;//累计次数的变量
    ( f; k2 K7 T7 p# G. ]* ]4 C4 F5 W
11.         uint32_t    time_out;//设定次数的常量
    
12.         void        (*fun)(void);//计数达到以后做啥的函数
    
13. }time_type;
    
14. 
    : [6 B/ ^* }$ H
15. 
    . s) b% B% P- |! f1 O: @; z; q% i
16. 
    9 P% o. z" U& g+ g# g3 I3 H- ?8 ^: [
17. typedef void    (*time_call_back)(void);
    
18. typedef struct
    
19. {
    " @) ]1 ^! S* m9 p
20.     uint8_t (*creat) (  uint32_t time_out ,uint8_t start, time_call_back call_back);
    
21.     uint8_t (*stop)  (  uint8_t handle);
    / a* k+ U. v; D6 i, _
22.     uint8_t (*start) (  uint8_t handle);
    
23. }time_ops_type;
    
24. 
    5 o5 F% a4 Y; o% K* L: R: T1 `5 a
25. extern time_ops_type   timer;
    6 I5 u$ k7 E# C& N0 }
26. 
    2 I, e; A- R2 F2 k3 \, P* @' |
27. 
    
28. void timer_isr( void );
    
29. 
      e+ o5 ~# p5 k7 T' F+ ~' f; g2 k
30. #endif
    
31. 
    4 e9 b; j: r8 F

复制代码

看这个头文件基本就能懂一大半了。每个节点的6个成员我都批注了，handle这个词语意思很宽 ID更准确。

1. #include "timelist.h"
   
2. #include "malloc.h"        
   
3. #define NULL 0
   " U7 [0 N  c$ f. S
4. enum
   
5. {
   3 @/ H3 N/ f6 Q4 z! n
6.         false,
   2 }/ S# o# v$ I/ F( U8 L
7.         true
   
8. };
   " Z0 w6 a, G! t' i% O0 s. D! t
9. uint8_t                         timerTaskId = 0;//全局变量 每个节点的ID号从0开始
   1 `7 z' d* D. F7 S' l! T6 f! l
10. time_type           *time = NULL; //链表的头 第一个节点
    ( i3 c" ^3 K0 z- S7 u# {7 ~
11. 
    
12. 
    6 u; O4 r3 I% v9 Y" ^
13. void timer_isr( void )
    
14. {
      Z, K6 r/ `9 O: ~1 }# C
15.         time_type          *priv = time;
    
16. 
    
17.         while( priv != NULL )
    
18.     {
    3 u6 q! n& ~4 k4 g% g& O
19.         if( priv->start)//这个节点是开的 就进去 否则pass
    
20.         {
    8 o& k' h# K/ j$ s
21.             if( ++priv->cnt >= priv->time_out)//进来累计一次 直达到达约定设定值
    4 i1 s) ^% U, M6 j8 x% H2 t
22.             {
    
23.                 priv->cnt = 0;
    + S7 A% T, w$ {: e  r
24.                 if(priv->fun != NULL)        
    
25.                                                                         priv->fun();
    
26.             }
    
27.         }
    
28.         priv = priv->next;      
    $ `2 D* `$ @8 E+ v
29.         }
    
30. }
    7 I0 i' U5 F6 c. U6 e- c; p
31. 
    % d8 W# }. j0 s7 v+ V8 w2 |/ e6 J. H4 u
32. //只有malloc没有free 我没有释放
    . h! g1 S" @* v
33. //返回void*
    9 T( Y4 Z. j" e, d
34. 
    
35. void *timer_malloc(int size)
      H) L# A  r% W
36. {
    8 a* a2 q  h3 d6 e) E' b
37.         return mymalloc(SRAMIN,sizeof(time_type));
    , j8 w+ m- m8 a; ?# S. \5 ~
38. }
    
39. 
    
40. uint8_t timer_stop_time(uint8_t handle)
    
41. {
    5 d& M1 q6 [2 p+ D- I$ I' k% f. S
42.         time_type *priv = time;
    
43.         
    ) o; W  A! v& ]
44.         while( priv != NULL )
    
45.     {
    
46.         if( priv->handle == handle)
    
47.         {
    
48.             priv->start = false;
    ' b! m+ E8 L  M7 ^6 O
49.                                                 priv->cnt = 0;
    9 E# i. v( P3 p: t: _# a
50.             return true;
    
51.         }
    . N+ W8 C8 ^# x
52.         priv = priv->next;     
    
53.         }  
    
54.    
    " V) ^* {2 y  M/ D; ?8 C' a7 {
55.     return false;
    + H6 [- U' w4 N2 x2 j' L8 R
56. }
    : }0 H. n2 R' Y8 u+ N4 C% S% [0 {" g. ^, B
57. 
    
58. uint8_t timer_start_time(uint8_t handle)
    $ B) Z0 V! s( `0 Q8 t6 d
59. {
    - I& y( f; ^) Z0 {5 L5 h) O
60.         time_type *priv = time;
    
61.         
    ) A5 B- Q. N: z# d0 X
62.         while( priv != NULL )
    
63.     {
    
64.         if( priv->handle == handle)
    
65.         {
    & A% h8 a$ U7 }/ ~. }8 m, ]. Z4 S# h
66.             priv->start = true;
    ; ^1 V7 r; L) H1 B0 E8 b4 _
67.             return true;
    " D7 M0 O3 h0 U; B  f
68.         }
    9 y( F1 T: X$ w8 N- e
69.         priv = priv->next;     
    - M- N; D% ?* X: o/ r
70.         }  
    / f$ z' U5 P5 o
71.    
    
72.     return false;
    
73. }
    5 ?& F2 {; J# u5 D. @- t
74. 
    
75. uint8_t timer_register_isr(  uint32_t time_out ,uint8_t start, time_call_back call_back)
    
76. {
    " O( K( [! j. Q: W
77.         time_type *priv;
    9 ^/ L* G, X- l) x% e; a+ U( f
78.         time_type        *this;
    % n& z5 U1 C( [2 o. Z7 r
79. 
    : H4 P1 ~8 H7 Y( \' ]
80.         this = (time_type *)timer_malloc(sizeof(time_type));
    2 a* P6 u; ]; M* D! i
81.         if( this != NULL)
    
82.         {
    1 F8 t8 s6 k5 g& j. X$ q& T
83. 
    " l/ l5 ~. x2 S; l2 g0 R) A: f0 K
84.                 this->cnt = 0;
    
85.                 this->start = start;
    % l* n- m( R6 U; D" h0 a5 r( U0 ^8 M) H
86.                 this->handle = timerTaskId++;
    
87.                 this->time_out = time_out;
    
88.                 this->fun = call_back;
    
89.                 this->next = NULL;
    ! z6 l: S/ L6 }+ o! M3 c
90.         if( time == NULL)
    4 C1 @5 [+ B3 Z3 k
91.                 {
    7 G0 e9 ?% C. u7 t5 _  o
92.                          time = this;
    : Y7 e5 {0 `1 Z" G; l+ t4 t4 b3 J
93.                 }
    & a  N0 a; Y5 Y$ h" K- n
94.                 else
    
95.                 {
    
96.                         priv = time;
    
97.                         while( priv->next != NULL )        priv = priv->next;
    
98.                         priv->next = this;
    # ]8 z% W" v$ E$ i. E2 V" C
99.                 }   
    ' N* D1 U& F9 U
100.         }
     
101.         else
     
102.         {
     - O% @$ U$ s9 z8 l6 Y
103.                 return 0xFF;
       Y2 s7 [# \3 `5 Q% o/ |
104.         }
     
105. 
     
106. 
     7 y& d& a$ {$ [4 t0 J( n' s
107.     return (this->handle);
     , e! @4 q4 Y2 A
108. 
     
109. }
     
110. 
     
111. //KEIL不支持该写法？？
     1 m- w8 K- T- ^- Z2 m# G; J  x8 N3 T
112. //time_ops_type  timer =
     
113. //{
     " g( J5 j, W, ~& u3 m
114. //    .creat = timer_register_isr,
     
115. //    .stop  = timer_stop_time ,
       p2 \( K, [8 X. E0 I
116. //    .start = timer_start_time,
     
117. //};
     
118. 
     
119. 
     7 F" ^- H5 S5 x; N( N( b/ Q0 e- `
120. time_ops_type  timer =
     
121. {
     
122.     timer_register_isr,
     
123.     timer_stop_time ,
     
124.     timer_start_time,
     / c; c- ^. V- a$ X% W
125. };
     

复制代码

实现如上 因为用了链表需要malloc函数 我没有用C库 而是自己写的内存分配模块
5 R+ G( e7 E4 Z
举一个例子吧
int IDID=0;
int wang=0;
& M$ H: D% Z* b" Svoid saywang(void)
. C! l; f9 q: M: R/ q) Y7 E{
" n/ K4 q% X' F' B( {+ |    wang++;
    if(wang==4)
        timer.stop(IDID);
}
0 y, P6 |! ?* H/ z- V9 b! ^8 `void Business_Init(void)
; L7 L% \8 D- ?+ Y: n{
3 |8 X- Y0 U( y& R: w& V        IDID=timer.creat(100,1,saywang);
; `- b4 {! s5 i% G8 |/ e1 c
。。。。。
% B7 M1 h4 |: M; b3 J}
5 h" l) N5 [. t
初始化的时候创建了一个定时器节点，时间是100个节拍，1是直接打开，到达设定时间就会调用saywang函数。
. V0 w. `3 D+ ?& u3 [' R可以在找一个条件比较按键来                                timer.start(IDID); 再次打开这个节点功能。
' L' V: o* o2 u3 v
) m8 v$ @" R6 X; p5 z而后天程序放到it.c即可
void TIM3_IRQHandler(void)
, F% H1 m, N7 ~( M{
5 t( p" F0 `' q# m% I. y% ]# m        static char count=0;        
- y1 M- J( Y; Z/ [9 U# j        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
       timer_isr(  );
}

好像很厉害的样子

学习了 涨姿势了

这个可以好好学习一下，毕竟底层更重要

基本认同，就一个点不认同，不认可把函数放在中断里面执行。。。。如果需要，可以放在大循环里面，虽然没法保证立即执行，但是，比放在中断里面好很多！！！

楼主，你的mymalloc(SRAMIN,sizeof(time_type)); 没有啊

好贴，收藏了