接上篇：时驱函数了解一下
1 s) Z8 c2 }2 F7 |6 o+ J( \9 G. y( j
前一篇帖子我写了时驱函数的设计本质是一种前后台程序，本文依旧如故。后台程序放到定时器里面，周期性的调用。这个程序程序是扫描一个链表，链表中每一个成员 噢 应该说没一个节点都设计好数据的结构体，到达设定的时间就执行回调函数。
功能：完成约定时间调用回调函数。
头文件：

1. #ifndef _TIMELIST_H_
   
2. #define _TIMELIST_H_
   0 Y7 X' {4 l& N6 G2 |
3. 
   $ S. X. d6 S- @( z2 b+ t: F3 T1 w2 F
4. #include "sys.h"
   ( \( R& _& n  J; Z2 R
5. typedef struct  _time
   ! G1 T, V9 K9 J% m3 g! N
6. {
   ' }2 j/ f, E; Y7 ?8 U! o1 w
7.         void        *next;//指向后一个
     Y/ A. |$ _+ [
8.         uint8_t     handle;//自己的ID号
   
9.         uint8_t     start;//开关1开0关
   
10.         uint32_t    cnt;//累计次数的变量
    ( W* L2 k% C6 I5 r* D
11.         uint32_t    time_out;//设定次数的常量
    
12.         void        (*fun)(void);//计数达到以后做啥的函数
    
13. }time_type;
    6 D( D% E# M+ u" V6 R, r' D
14. 
    
15. 
    - c, U! {8 ~1 }% X! L0 y" F: U, m
16. 
    
17. typedef void    (*time_call_back)(void);
    , {) X2 W6 ]8 s* k: P3 x7 N# h
18. typedef struct
    
19. {
    . D6 c3 H0 H8 ~5 j7 b
20.     uint8_t (*creat) (  uint32_t time_out ,uint8_t start, time_call_back call_back);
    
21.     uint8_t (*stop)  (  uint8_t handle);
    
22.     uint8_t (*start) (  uint8_t handle);
    6 R7 l  t: [' V/ h% D
23. }time_ops_type;
    
24. 
    . D! R4 ~1 Y8 w6 c& Z% @  |3 ~
25. extern time_ops_type   timer;
    8 U5 s1 x2 R$ L+ E$ ~! H
26. 
    1 Y- l) S- l1 R( O
27. 
    $ N: u( T; [4 p3 m+ P
28. void timer_isr( void );
    
29. 
    
30. #endif
    / W) ~/ [8 S5 |  }% W" m
31. 
    

复制代码

看这个头文件基本就能懂一大半了。每个节点的6个成员我都批注了，handle这个词语意思很宽 ID更准确。
# I4 J% L2 D; L  s, f% V

1. #include "timelist.h"
   
2. #include "malloc.h"        
   
3. #define NULL 0
   
4. enum
   
5. {
   ' B1 C  f( v/ X) Q% x$ k* a
6.         false,
   
7.         true
   ) |5 ^) T9 e# E+ X  M  r, |8 E
8. };
   
9. uint8_t                         timerTaskId = 0;//全局变量 每个节点的ID号从0开始
   
10. time_type           *time = NULL; //链表的头 第一个节点
    ) T6 I" F# [9 e1 l3 r7 T
11. 
    
12. 
    
13. void timer_isr( void )
    / a* ^: X# A% R4 B6 G3 D
14. {
    : p) B' ~: G3 M  b) q5 v; G' f
15.         time_type          *priv = time;
    5 g7 g& t4 b5 D2 Z# c2 H( ?' e* ~! t
16. 
    0 d$ y% n+ R) L
17.         while( priv != NULL )
    
18.     {
    & R. `0 S8 j% Q  Q8 Q5 r
19.         if( priv->start)//这个节点是开的 就进去 否则pass
    
20.         {
    
21.             if( ++priv->cnt >= priv->time_out)//进来累计一次 直达到达约定设定值
    
22.             {
    
23.                 priv->cnt = 0;
    # K% X, ^" s& e4 A" t! X6 T
24.                 if(priv->fun != NULL)        
    # o+ H+ l, u9 J, e
25.                                                                         priv->fun();
    
26.             }
    
27.         }
    - R' h4 Z7 [% b9 @8 }
28.         priv = priv->next;      
    
29.         }
    
30. }
    - r6 N. A3 N0 `3 g0 t# ?
31. 
    * U# y4 n' ?& m" `3 L
32. //只有malloc没有free 我没有释放
    2 O+ |" ^1 E3 _' A& K) u+ F
33. //返回void*
    0 A6 m/ `/ y( k# I
34. 
    
35. void *timer_malloc(int size)
    : R+ v- d, F! p( ]& K
36. {
    % S: l7 {$ h' D2 L8 S. I1 F
37.         return mymalloc(SRAMIN,sizeof(time_type));
    
38. }
    
39. 
    1 _+ `# h) ~/ {
40. uint8_t timer_stop_time(uint8_t handle)
    ' M9 O8 M& a: P: U/ l3 G
41. {
    3 T. @3 c, ^8 @8 c9 a2 A
42.         time_type *priv = time;
    
43.         
    
44.         while( priv != NULL )
    3 ?4 d/ U- E4 @' U8 E
45.     {
    
46.         if( priv->handle == handle)
    
47.         {
    
48.             priv->start = false;
    
49.                                                 priv->cnt = 0;
    , H) F7 U" F3 e' G
50.             return true;
    
51.         }
    7 W8 j  Y2 s( E- s
52.         priv = priv->next;     
    4 s! m7 S* |* i$ f
53.         }  
    
54.    
      ~9 L: w. v) L2 T/ n0 i
55.     return false;
    4 x/ ?, ]( r* ^3 @" F3 R2 N' h
56. }
      n5 |* P8 h+ R0 k
57. 
    ) T4 J0 G3 }- d5 d/ K
58. uint8_t timer_start_time(uint8_t handle)
    9 c& \5 E# d: N- g/ Q% x* }+ O
59. {
    
60.         time_type *priv = time;
    
61.         
    . f. j% ]: v! F. X9 B
62.         while( priv != NULL )
    
63.     {
    : j- j9 k5 d+ ]* k/ ~
64.         if( priv->handle == handle)
    ' @1 k3 P# U: P  o8 _- @
65.         {
    ; W1 F/ `3 M& X. i( b4 Z- n! y# C
66.             priv->start = true;
    
67.             return true;
    8 f! |0 R3 {" J9 a" q/ A$ f* \& R, p1 R
68.         }
    ; @( f4 P0 |6 Q' N
69.         priv = priv->next;     
    
70.         }  
    
71.    
    
72.     return false;
    4 P9 W2 L) {# d: d) A% K$ \' `8 t; |$ @
73. }
    
74. 
    
75. uint8_t timer_register_isr(  uint32_t time_out ,uint8_t start, time_call_back call_back)
    
76. {
    
77.         time_type *priv;
    
78.         time_type        *this;
    
79. 
    
80.         this = (time_type *)timer_malloc(sizeof(time_type));
    
81.         if( this != NULL)
    
82.         {
    
83. 
    % i6 `/ h- I' N1 w; r3 o
84.                 this->cnt = 0;
      f( }1 s+ M3 b* T- w
85.                 this->start = start;
    
86.                 this->handle = timerTaskId++;
    * ?; ?) J6 |9 t2 {, `
87.                 this->time_out = time_out;
    
88.                 this->fun = call_back;
    
89.                 this->next = NULL;
    
90.         if( time == NULL)
    
91.                 {
    / d8 ~: w5 m/ I  A  S/ O9 e8 G
92.                          time = this;
    - f* }7 E  D* E# N& T9 c
93.                 }
    " I# j5 L- A+ D* M
94.                 else
    ( o% T7 n# D/ |; O& {
95.                 {
    1 j2 I4 a/ m9 L
96.                         priv = time;
    
97.                         while( priv->next != NULL )        priv = priv->next;
    
98.                         priv->next = this;
    
99.                 }   
    
100.         }
     ( |/ |' j+ j, u# N) n
101.         else
     
102.         {
     4 Q! F+ M* _0 e
103.                 return 0xFF;
     
104.         }
     4 \% Q  \& _6 G6 O
105. 
     
106. 
     
107.     return (this->handle);
       {& R) v* s" O$ A/ M
108. 
     ' v! x/ }6 D+ L  f! c+ \
109. }
     
110. 
     
111. //KEIL不支持该写法？？
     ' f/ U1 V3 y. s" E
112. //time_ops_type  timer =
     1 C! f: B# W# M
113. //{
     
114. //    .creat = timer_register_isr,
     7 H1 z8 E0 Z, J
115. //    .stop  = timer_stop_time ,
     
116. //    .start = timer_start_time,
     / P% z2 J9 ~, V3 x. j6 ]' @! D
117. //};
     " \! T1 ]5 p( X/ Y& x
118. 
     
119. 
     & b: }/ p& S6 z6 r; U9 u; g
120. time_ops_type  timer =
     + L$ I3 Y! }5 P- Q9 o+ p
121. {
     ; ~2 J. P6 U! _+ y! b
122.     timer_register_isr,
     6 X& a: T) N& `7 k, _
123.     timer_stop_time ,
     
124.     timer_start_time,
     9 x0 }/ M  Z  V) f0 L
125. };
     

复制代码

实现如上 因为用了链表需要malloc函数 我没有用C库 而是自己写的内存分配模块

) Z1 ?9 I) {' g5 c& _6 A/ i" G举一个例子吧
int IDID=0;
0 V; I$ N& g- G# D% q; Mint wang=0;
# V  H5 Q! k1 a& R; {' g  dvoid saywang(void)
{
    wang++;
    if(wang==4)
$ @5 o4 t; G+ [) h" S$ N6 X8 o        timer.stop(IDID);
}
void Business_Init(void)
1 o& G2 @3 M7 b2 T" ^! J9 H{
        IDID=timer.creat(100,1,saywang);
6 q' ^/ P- x: P/ ?; D
。。。。。
% H# a; E# u9 q9 Y}
. e: o' }- [! a! Y; Y( e
初始化的时候创建了一个定时器节点，时间是100个节拍，1是直接打开，到达设定时间就会调用saywang函数。
) `5 v' N+ x2 {( w% g1 `可以在找一个条件比较按键来                                timer.start(IDID); 再次打开这个节点功能。

而后天程序放到it.c即可
void TIM3_IRQHandler(void)
1 b$ ^# w  W5 }2 T# z4 P/ R{
9 j% m: E" z* J& A1 \4 ^        static char count=0;        
5 Q0 J2 A! p  T; L: T) \        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
       timer_isr(  );
0 a5 P, U6 E* g( D( {}

2 F1 J7 m# R! s' P  |

好像很厉害的样子

学习了 涨姿势了

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

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

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

好贴，收藏了