接上篇：时驱函数了解一下
3 g2 [3 N. b% y
前一篇帖子我写了时驱函数的设计本质是一种前后台程序，本文依旧如故。后台程序放到定时器里面，周期性的调用。这个程序程序是扫描一个链表，链表中每一个成员 噢 应该说没一个节点都设计好数据的结构体，到达设定的时间就执行回调函数。
  l* H# i6 [1 f6 D5 n3 C功能：完成约定时间调用回调函数。
头文件：

1. #ifndef _TIMELIST_H_
   
2. #define _TIMELIST_H_
   
3. 
   ) u1 w! z3 A2 h) e
4. #include "sys.h"
   $ O( h* N7 s) R! I# u& f0 P/ }
5. typedef struct  _time
   # I  M. ]1 {! P: E( E4 M$ o: k
6. {
   9 I/ @5 y- q1 |0 S6 B
7.         void        *next;//指向后一个
   / ~- d( e- G# u! c+ Y
8.         uint8_t     handle;//自己的ID号
   
9.         uint8_t     start;//开关1开0关
   $ j+ l+ [# \) o) D
10.         uint32_t    cnt;//累计次数的变量
    
11.         uint32_t    time_out;//设定次数的常量
    4 @+ N; G+ _) f3 I
12.         void        (*fun)(void);//计数达到以后做啥的函数
    
13. }time_type;
    ; k( X% I/ d/ m' i! q9 W! k
14. 
    7 j0 x9 h" ]+ ?8 d
15. 
    
16. 
    * N0 P. r1 B6 w
17. typedef void    (*time_call_back)(void);
    
18. typedef struct
    7 u; w/ E* @  c
19. {
    ( g5 T" J, m+ t  }9 g
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);
    & S) I# j6 j% \) f+ E; J8 ^1 H
23. }time_ops_type;
    " I- P" ], X8 W) d1 m- U8 Z
24. 
    ; x) Z/ p  U& d4 r) K, K; w
25. extern time_ops_type   timer;
    ; z6 {' |! ^7 x; g, ]1 W
26. 
    
27. 
    " O9 f; q" }& t4 e& I. W0 ?
28. void timer_isr( void );
    
29. 
    - a: O  L3 z3 W9 y
30. #endif
    
31. 
    

复制代码

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

1. #include "timelist.h"
   5 C  Q- W6 D7 U
2. #include "malloc.h"        
   
3. #define NULL 0
   * b; m2 y1 b+ d0 v( j$ @
4. enum
     K9 |# J$ ]$ p) {/ B
5. {
   ! P' I0 ]; a4 s/ \9 [' @' j
6.         false,
   
7.         true
   0 n2 _  v, M; G8 Z; H2 o/ y3 K
8. };
   
9. uint8_t                         timerTaskId = 0;//全局变量 每个节点的ID号从0开始
   
10. time_type           *time = NULL; //链表的头 第一个节点
    
11. 
    
12. 
    
13. void timer_isr( void )
    / f1 @, w; b. ^& s
14. {
    % ^' l, C9 D7 a( D* }% B# _9 P
15.         time_type          *priv = time;
    
16. 
    % v8 E2 y8 n" {! m. y) _# ]6 [
17.         while( priv != NULL )
    
18.     {
      {# K2 Y9 A3 j0 n4 r) P
19.         if( priv->start)//这个节点是开的 就进去 否则pass
    
20.         {
    
21.             if( ++priv->cnt >= priv->time_out)//进来累计一次 直达到达约定设定值
    4 ]/ `5 \, a4 [  |9 P1 g. I* l
22.             {
    
23.                 priv->cnt = 0;
    2 q4 B7 A8 O" ]& s4 I# J1 K
24.                 if(priv->fun != NULL)        
    1 S/ A- g7 ^- z* ]
25.                                                                         priv->fun();
    
26.             }
    3 _( |& ~" C. L/ u
27.         }
    - V( B  I9 ?) d' k. o
28.         priv = priv->next;      
    ( j2 v! f  p5 N, L( C, }" t' F# U
29.         }
    
30. }
    & [) f" L" ^1 k- Y
31. 
    
32. //只有malloc没有free 我没有释放
    9 h7 |6 O# D( Q- I( N; a
33. //返回void*
    
34. 
    # y) z4 s8 m! Q. C
35. void *timer_malloc(int size)
    
36. {
    ! L/ Z$ y; x' g' J$ R0 m$ Z
37.         return mymalloc(SRAMIN,sizeof(time_type));
    $ L2 R: {% v' P% p; E% Z1 y3 [
38. }
    # _# K- r( v2 Z' k
39. 
    ! G8 s) B9 J0 c! Q% v. J0 @- ~) G
40. uint8_t timer_stop_time(uint8_t handle)
    
41. {
    
42.         time_type *priv = time;
    / V* y: B$ h+ }. c
43.         
    
44.         while( priv != NULL )
    5 S$ L% G) I9 ]# v7 Y) `( W
45.     {
    
46.         if( priv->handle == handle)
    5 Q. g! m( m) }. Z/ u6 V6 e: p
47.         {
    : m8 P, \& \9 v" A
48.             priv->start = false;
    . U' ]+ q" w) E+ [- G* v" ?( g8 w4 y" Z
49.                                                 priv->cnt = 0;
    
50.             return true;
    
51.         }
    
52.         priv = priv->next;     
    
53.         }  
    9 K+ W5 _* `9 {0 H2 \4 M4 x; J: Z% I
54.    
    8 e" z0 ]! e" e' c4 i
55.     return false;
    # f' ]! n- ~( X. z
56. }
    
57. 
    7 o9 _" a/ M/ R- c
58. uint8_t timer_start_time(uint8_t handle)
    
59. {
    / D. O, B3 B9 \+ P, G. h
60.         time_type *priv = time;
    
61.         
    ' i4 D) ?, r  k. U" v
62.         while( priv != NULL )
    
63.     {
      Y6 U, l: \; p# S. G* a
64.         if( priv->handle == handle)
    
65.         {
    $ Q3 E4 H& ]6 x2 R* f
66.             priv->start = true;
    
67.             return true;
    
68.         }
    8 L) H, L! E8 t/ O( m+ ?9 a: o
69.         priv = priv->next;     
    ; r$ v/ K$ B1 D1 e9 ?
70.         }  
    , q, x& d# G- R. G7 }( r0 W8 l: Z
71.    
    / X' n  B( ]' e0 r6 |  p$ j
72.     return false;
    ) {" N5 o  M) ^& r
73. }
    6 j/ H) ~5 X' W! K; }1 p
74. 
    
75. uint8_t timer_register_isr(  uint32_t time_out ,uint8_t start, time_call_back call_back)
    
76. {
    
77.         time_type *priv;
    9 \6 `( `, A% _" B4 x  J
78.         time_type        *this;
    9 {' \' I* G5 e$ l  H6 w
79. 
    
80.         this = (time_type *)timer_malloc(sizeof(time_type));
    2 ]% G: H+ x! T! C5 C% z0 M
81.         if( this != NULL)
    & \7 A' m' W" b
82.         {
    ; b3 C9 g5 p' `# d$ Q
83. 
    8 h, L# t7 @. a6 [/ A: n0 @
84.                 this->cnt = 0;
    ' A$ A) r& i/ ~+ X
85.                 this->start = start;
    % \( D' K+ d! a6 L' J2 |
86.                 this->handle = timerTaskId++;
    4 L4 C) t0 {0 Z- L% @* ?# s" L
87.                 this->time_out = time_out;
    8 H: M' }0 w8 @& D
88.                 this->fun = call_back;
    
89.                 this->next = NULL;
    
90.         if( time == NULL)
    5 G; n9 ]7 O+ B  a; C
91.                 {
    ; U- U. u1 A2 U* T
92.                          time = this;
    
93.                 }
    8 ]: U& P- J4 w$ R/ P3 W9 R
94.                 else
    
95.                 {
    
96.                         priv = time;
    ( g- n. j( Z" m* `6 y) s3 a: D
97.                         while( priv->next != NULL )        priv = priv->next;
    
98.                         priv->next = this;
    
99.                 }   
    % ?. S4 H. o8 j5 p! T& x
100.         }
     ! x) r  _& ^" u: g
101.         else
     
102.         {
     1 h! B( g& X+ l* L
103.                 return 0xFF;
     
104.         }
     5 B  \( O3 G5 P5 A% m. I
105. 
     
106. 
     
107.     return (this->handle);
     
108. 
     
109. }
     9 d+ E, i1 }$ }( ]! Z
110. 
     % s7 X6 x' R: Z" ~+ a
111. //KEIL不支持该写法？？
     $ q& X. j" M- k8 T1 k( W% t
112. //time_ops_type  timer =
     & b5 ?- T2 A  Z, L  F2 }/ i
113. //{
     
114. //    .creat = timer_register_isr,
     
115. //    .stop  = timer_stop_time ,
     
116. //    .start = timer_start_time,
     
117. //};
     
118. 
     
119. 
     
120. time_ops_type  timer =
     
121. {
     " ^- ^) F) j# Y0 P
122.     timer_register_isr,
       c2 @" Y  H" ?. G. y! q& B7 X- |
123.     timer_stop_time ,
     
124.     timer_start_time,
     
125. };
     

复制代码

实现如上 因为用了链表需要malloc函数 我没有用C库 而是自己写的内存分配模块
1 f6 }' Q+ T* Q: F
2 v  f4 @6 i& T( _1 Y举一个例子吧
6 Z$ Z1 r/ L( \+ S. T  iint IDID=0;
+ _/ n% w& d* ?3 y- ^int wang=0;
; s8 }' ^+ A( p6 g; R. c/ D3 Ovoid saywang(void)
3 F- X: z0 }+ g% S! I{
    wang++;
    if(wang==4)
3 |: j% B- L- ~! s1 K% Y7 ^) Z        timer.stop(IDID);
. M1 A6 R- j4 J# H& q1 x. u4 `}
+ M. a/ `9 c, o0 {! o1 _' \void Business_Init(void)
{
8 P( s% _) i* \. ~+ A: s        IDID=timer.creat(100,1,saywang);
+ ?5 N; w2 Q7 H; x, m: |, `
。。。。。
# e7 A& V/ x" N7 I5 }5 T}
$ M% T6 t1 G+ P1 z$ M/ S
初始化的时候创建了一个定时器节点，时间是100个节拍，1是直接打开，到达设定时间就会调用saywang函数。
可以在找一个条件比较按键来                                timer.start(IDID); 再次打开这个节点功能。
4 X- G$ M  D, Q1 s1 o5 P3 F
而后天程序放到it.c即可
: }) A; O, @- u, B/ d7 E5 P" Vvoid TIM3_IRQHandler(void)
{
        static char count=0;        
        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
       timer_isr(  );
) a& ~3 o; m* Z6 c& H}
* J* Q3 Z" ]9 b* l. O
9 c( j+ a7 n: Q2 l1 `6 [

好像很厉害的样子

学习了 涨姿势了

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

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

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

好贴，收藏了