接上篇：时驱函数了解一下

前一篇帖子我写了时驱函数的设计本质是一种前后台程序，本文依旧如故。后台程序放到定时器里面，周期性的调用。这个程序程序是扫描一个链表，链表中每一个成员 噢 应该说没一个节点都设计好数据的结构体，到达设定的时间就执行回调函数。
功能：完成约定时间调用回调函数。
头文件：
; v6 |. H! j9 W/ z+ R

1. #ifndef _TIMELIST_H_
   . G8 h6 V* e- Z& z# C
2. #define _TIMELIST_H_
   2 P) x* x0 V( g4 Y# I
3. 
   
4. #include "sys.h"
   
5. typedef struct  _time
   
6. {
   " o7 t! k5 z) ?* \- y6 l; a; v
7.         void        *next;//指向后一个
   + Q. I/ k2 i0 G! d# D
8.         uint8_t     handle;//自己的ID号
   0 J7 Y+ e, L# A( C, i8 x% P; }
9.         uint8_t     start;//开关1开0关
   9 _; s" w5 N0 A8 H9 a- T
10.         uint32_t    cnt;//累计次数的变量
    $ L8 Y  @' ?7 n. {3 n) K
11.         uint32_t    time_out;//设定次数的常量
    
12.         void        (*fun)(void);//计数达到以后做啥的函数
    + L3 f4 @3 V: O9 Q
13. }time_type;
    1 B! F, m1 ^; K/ l
14. 
    
15. 
    . u1 ]9 O: l+ x+ j9 G* Q- t4 C
16. 
    
17. typedef void    (*time_call_back)(void);
    / r& t# k7 \1 f1 C" u0 {, N6 C: i: a
18. typedef struct
    
19. {
    1 W5 v+ a2 f, g' O& |) k
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);
    * ]0 ~8 E6 X8 k7 y/ e7 }0 M
23. }time_ops_type;
    7 a4 K$ H1 S% [- H. E
24. 
    8 `* F8 B, `+ e; |; G, N
25. extern time_ops_type   timer;
    . h' X0 n4 A( g% j
26. 
    
27. 
    
28. void timer_isr( void );
    
29. 
    
30. #endif
    : b1 e+ u$ c9 j& P$ P5 R
31. 
    8 R3 `# O" [4 D% h

复制代码

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

1. #include "timelist.h"
   ) }8 {  J; i7 E1 O) l" y" j
2. #include "malloc.h"        
   ( M: ]7 N: g9 p0 U) }$ I+ H; t
3. #define NULL 0
   . w% [, H: f& |+ t
4. enum
   & y# a; d$ b: g9 S6 s& c( }
5. {
   + z! E  m8 ]/ Q& o7 l; `, w
6.         false,
   ! v5 r$ C/ B; y1 Y0 c/ R3 _
7.         true
   
8. };
   5 w- O8 I9 L' n1 R3 L
9. uint8_t                         timerTaskId = 0;//全局变量 每个节点的ID号从0开始
   1 h5 j" X7 Q% ^3 o- M0 `! c, d
10. time_type           *time = NULL; //链表的头 第一个节点
    
11. 
    ( U5 c; d  p8 ~2 K
12. 
    - f+ G) Q! H0 z7 c# a; d7 L; M, F
13. void timer_isr( void )
    / [9 u* X% L; v
14. {
    
15.         time_type          *priv = time;
    0 d. f: A3 ^9 N" U
16. 
    
17.         while( priv != NULL )
    5 B4 _/ E& Z2 Z9 Z
18.     {
    
19.         if( priv->start)//这个节点是开的 就进去 否则pass
    
20.         {
    3 ]% e8 `* O2 Y5 Y5 E, G
21.             if( ++priv->cnt >= priv->time_out)//进来累计一次 直达到达约定设定值
    ! e9 O; ^& O$ N- ]! U+ s5 b% D
22.             {
    
23.                 priv->cnt = 0;
    
24.                 if(priv->fun != NULL)        
    : k( V4 d0 W/ Y
25.                                                                         priv->fun();
    
26.             }
    
27.         }
    ' z% S9 M' R8 t: z( d* D2 P
28.         priv = priv->next;      
    ! i2 s! M" v) `1 B
29.         }
    7 p* v: O9 D7 N) K2 |+ q
30. }
    
31. 
    
32. //只有malloc没有free 我没有释放
      G( l; [2 R6 U6 ^; e
33. //返回void*
    4 c7 ?1 s2 t% R. N* L) q
34. 
    
35. void *timer_malloc(int size)
    
36. {
    ; s+ K8 B) A" o+ {: ~
37.         return mymalloc(SRAMIN,sizeof(time_type));
    
38. }
    
39. 
    2 Q7 ^" o+ K( y: O# s
40. uint8_t timer_stop_time(uint8_t handle)
    
41. {
    8 s4 j# f+ t- p$ {( y
42.         time_type *priv = time;
    0 ~% P1 J$ e( w; n
43.         
    
44.         while( priv != NULL )
    
45.     {
      D) x6 F# T. w  U3 `; b: x7 E# @! o
46.         if( priv->handle == handle)
    , j! H0 T2 x& L+ j' q* r
47.         {
    ) _# \+ o- x/ l  q9 J
48.             priv->start = false;
    
49.                                                 priv->cnt = 0;
    
50.             return true;
    $ [& {) m+ p+ o4 j7 l% @
51.         }
    
52.         priv = priv->next;     
    1 q/ n+ w, w/ d. @8 }
53.         }  
    
54.    
    
55.     return false;
    9 ~6 V- T5 Q# Z( j
56. }
    9 i4 T% I$ v: M; E' c
57. 
      V0 J8 d+ P, L% |( R$ D7 l5 T
58. uint8_t timer_start_time(uint8_t handle)
    % }/ T2 r3 R; f8 n
59. {
    ! i8 y1 @, b2 w! X9 q: s4 r
60.         time_type *priv = time;
    
61.         
    & R$ s- X3 t  ^. J9 g, E" t
62.         while( priv != NULL )
    
63.     {
    6 L3 G& a  U% W3 g& B
64.         if( priv->handle == handle)
    $ F; Y  A, d$ n8 c
65.         {
    ' @4 n5 _8 g3 P0 y( _* v
66.             priv->start = true;
    
67.             return true;
    5 ]- |" b% A- Q% |8 P" l/ a& W* G8 e7 E
68.         }
    . e; [0 i+ d! C
69.         priv = priv->next;     
    
70.         }  
    
71.    
      o) A: y+ J# O! T" _3 Y
72.     return false;
    
73. }
    4 w* T$ ~0 t7 e
74. 
    
75. uint8_t timer_register_isr(  uint32_t time_out ,uint8_t start, time_call_back call_back)
    ; H5 p5 h+ M( V8 f: K" p9 c7 c, w
76. {
    " Q2 f/ z& a2 u! B& z7 v: Y; ]6 u3 g
77.         time_type *priv;
    4 S) y0 [) S+ e: t) d+ @' g
78.         time_type        *this;
    ) J3 K- v5 E' u7 j0 p6 _3 B
79. 
    
80.         this = (time_type *)timer_malloc(sizeof(time_type));
    ; {; `' D% K, }1 u) A
81.         if( this != NULL)
    4 ^( W! K; y/ N0 e
82.         {
    / S3 ^9 A/ c! _0 O: t( J1 q
83. 
    - g* i" \) z$ P3 @" c
84.                 this->cnt = 0;
    0 m+ ~& B* x" p; w3 W
85.                 this->start = start;
    ) R8 Y# c3 |3 L' O
86.                 this->handle = timerTaskId++;
    
87.                 this->time_out = time_out;
    
88.                 this->fun = call_back;
    
89.                 this->next = NULL;
    
90.         if( time == NULL)
    
91.                 {
    % X2 ^6 j$ U, n! ^
92.                          time = this;
    
93.                 }
    & K0 z2 B8 J' A5 Q6 a
94.                 else
    
95.                 {
    
96.                         priv = time;
    
97.                         while( priv->next != NULL )        priv = priv->next;
    9 Q( K; G1 x- a2 o. r7 @8 ]
98.                         priv->next = this;
    
99.                 }   
    
100.         }
     
101.         else
     6 F% X) u% ^0 J/ t6 Z! I4 `' F
102.         {
     ( O# A! T3 N' h
103.                 return 0xFF;
     1 c. ?5 x1 f6 H; R. @9 d
104.         }
     ( _8 [- O, ~) ~1 ?* {
105. 
     4 J3 @* d" Z: |* C
106. 
     ) p3 x3 x! c" W$ d' H( V
107.     return (this->handle);
     
108. 
     & Q! I* R6 D4 z' w4 T7 h
109. }
     7 |& w# u# E, E6 k1 L; @, ^9 I
110. 
     8 A3 v& u% u  o8 t( R& ?9 U
111. //KEIL不支持该写法？？
     
112. //time_ops_type  timer =
     
113. //{
     
114. //    .creat = timer_register_isr,
     
115. //    .stop  = timer_stop_time ,
     
116. //    .start = timer_start_time,
     ! _2 C  Y) P7 N; g
117. //};
     
118. 
     ) S2 F+ S' ^) {8 k! c( N
119. 
     
120. time_ops_type  timer =
     1 n& A9 J0 a9 T! a: W. {$ g
121. {
     9 p& l; b+ G. a
122.     timer_register_isr,
     
123.     timer_stop_time ,
     ( `! c5 x" u; K2 v( A) L9 w0 T9 B; }
124.     timer_start_time,
     5 k& p8 C% s. g) k' W1 L. _
125. };
     ! u5 ^0 g0 `  y- S* k: B# ^9 J9 Y

复制代码

实现如上 因为用了链表需要malloc函数 我没有用C库 而是自己写的内存分配模块
4 Y3 V/ G1 _% R( e. m
4 X5 N+ z- L6 q/ i- e举一个例子吧
int IDID=0;
' @$ f& x) u; L) x' T9 i# K: Sint wang=0;
2 W4 J! p# o$ \8 ?+ {# b# u# Vvoid saywang(void)
" \, V, c; n* h) |{
    wang++;
, p7 {/ t: g/ F# y2 j    if(wang==4)
        timer.stop(IDID);
}
void Business_Init(void)
, i% W! V, z, e; i3 z' f{
; H" f# W0 a# w9 r3 [        IDID=timer.creat(100,1,saywang);
% q$ C& `# o( f4 K5 i
。。。。。
}
- Z0 a# F  p: ?  E
初始化的时候创建了一个定时器节点，时间是100个节拍，1是直接打开，到达设定时间就会调用saywang函数。
4 ]) x3 Q! ~7 j! f/ U8 i7 W6 N可以在找一个条件比较按键来                                timer.start(IDID); 再次打开这个节点功能。
& K- l6 [9 t* ], g: _$ ~% h6 W
而后天程序放到it.c即可
# e0 Y! Y) G9 _$ Gvoid TIM3_IRQHandler(void)
{
        static char count=0;        
        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
       timer_isr(  );
}
1 C$ G' t( U8 X; \: t( w. F

好像很厉害的样子

学习了 涨姿势了

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

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

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

好贴，收藏了