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

前一篇帖子我写了时驱函数的设计本质是一种前后台程序，本文依旧如故。后台程序放到定时器里面，周期性的调用。这个程序程序是扫描一个链表，链表中每一个成员 噢 应该说没一个节点都设计好数据的结构体，到达设定的时间就执行回调函数。
功能：完成约定时间调用回调函数。
# T$ U0 P& M, f: T" z  W- T" n头文件：

1. #ifndef _TIMELIST_H_
   
2. #define _TIMELIST_H_
   + o0 j; m/ `& P% C. g
3. 
   
4. #include "sys.h"
   % j+ l$ R) M7 L$ H7 k; |
5. typedef struct  _time
   
6. {
   
7.         void        *next;//指向后一个
   
8.         uint8_t     handle;//自己的ID号
   
9.         uint8_t     start;//开关1开0关
   4 H. b3 `( I/ {) l  d
10.         uint32_t    cnt;//累计次数的变量
    2 Q" X# b9 K, E; J) u# M
11.         uint32_t    time_out;//设定次数的常量
    7 C2 ~3 C& N4 o
12.         void        (*fun)(void);//计数达到以后做啥的函数
    
13. }time_type;
    
14. 
    
15. 
    
16. 
    
17. typedef void    (*time_call_back)(void);
    * u" `4 F: x. V  G  d
18. typedef struct
    * I8 Q" o) R6 v6 q6 ~3 _7 ^1 F( s
19. {
    
20.     uint8_t (*creat) (  uint32_t time_out ,uint8_t start, time_call_back call_back);
    
21.     uint8_t (*stop)  (  uint8_t handle);
    : G8 T9 G, z( e& |  \
22.     uint8_t (*start) (  uint8_t handle);
      x+ G% A9 h  G- L. T* g
23. }time_ops_type;
    + ?3 C( h' ?- S0 O( H9 s
24. 
    
25. extern time_ops_type   timer;
    6 r) P! B) O$ F# G3 ^+ ]3 S+ J
26. 
    1 c8 ~1 P( F0 s- g
27. 
    
28. void timer_isr( void );
    : M3 t) D; d- |0 n1 y% k: z/ d
29. 
    2 L  c! O3 L9 ]5 [' T) t+ A
30. #endif
    ' y! a- a5 E" e3 B& c3 V( B, z
31. 
    * J: J6 k$ n% V% F; i

复制代码

看这个头文件基本就能懂一大半了。每个节点的6个成员我都批注了，handle这个词语意思很宽 ID更准确。
0 Q# N. A; Q. P- y7 Z

1. #include "timelist.h"
   " K6 W2 a5 F8 F/ p! d; T5 {' V2 Y& v
2. #include "malloc.h"        
   
3. #define NULL 0
   ; S: G! |, h, g0 j7 L( H
4. enum
   
5. {
   
6.         false,
   ! {0 \; E4 o9 X
7.         true
   
8. };
   
9. uint8_t                         timerTaskId = 0;//全局变量 每个节点的ID号从0开始
   - @, Q. o8 S1 @) g% ^
10. time_type           *time = NULL; //链表的头 第一个节点
    * O1 V8 K( b5 ^( m# ^" b
11. 
    
12. 
    
13. void timer_isr( void )
    
14. {
    
15.         time_type          *priv = time;
    
16. 
    $ {4 Z) y& ^* s. t% U
17.         while( priv != NULL )
    & Y8 y7 P/ u' d4 m8 {" P" w
18.     {
    
19.         if( priv->start)//这个节点是开的 就进去 否则pass
    ) |2 \$ p5 H- N6 ]
20.         {
    5 j% }/ M# R+ z6 p& `  _5 y6 m
21.             if( ++priv->cnt >= priv->time_out)//进来累计一次 直达到达约定设定值
    
22.             {
    
23.                 priv->cnt = 0;
    " u* q7 e6 ]8 Y, S, o1 z
24.                 if(priv->fun != NULL)        
    # D# A. Z8 s/ @
25.                                                                         priv->fun();
    
26.             }
    8 ?. a( c4 H/ G" a
27.         }
    
28.         priv = priv->next;      
    ! x/ A& ^. M6 p6 E& M  N3 {
29.         }
    0 |% r! v, }/ Y
30. }
    
31. 
    
32. //只有malloc没有free 我没有释放
    
33. //返回void*
    ! T- P# B3 }" S( Q
34. 
    9 M% \' e, w7 X) \; i3 [
35. void *timer_malloc(int size)
    9 u+ N( |0 z  x; v4 G- s; W+ v  e
36. {
    
37.         return mymalloc(SRAMIN,sizeof(time_type));
    
38. }
    
39. 
    
40. uint8_t timer_stop_time(uint8_t handle)
    - }7 X7 C% p) e* W1 q% g
41. {
    / P5 b6 K+ s: i2 C
42.         time_type *priv = time;
    ( I  t8 N3 v( \$ z7 Z' E* R
43.         
    
44.         while( priv != NULL )
    / L" A5 e4 [, n+ \! ^4 z
45.     {
    
46.         if( priv->handle == handle)
    5 T& l. Y* f+ c2 q' Y, w( x
47.         {
    + Z& Y+ r* I# S( d( [
48.             priv->start = false;
    8 X4 a* ]5 A; X) E
49.                                                 priv->cnt = 0;
    
50.             return true;
    / _/ ~0 y" c9 ]( h- s* n  [  J- U
51.         }
    
52.         priv = priv->next;     
    / A$ E! X8 A; l$ o* V$ E
53.         }  
    
54.    
    2 P+ |3 o4 F( Q3 q
55.     return false;
    
56. }
    
57. 
    ! H; F4 s+ S: X9 q' R
58. uint8_t timer_start_time(uint8_t handle)
    
59. {
    
60.         time_type *priv = time;
    
61.         
    
62.         while( priv != NULL )
    ; l; I/ i/ p' a; }
63.     {
    + p% G+ K1 \9 J: t
64.         if( priv->handle == handle)
    , U0 P8 ]9 K7 d6 J# f
65.         {
    2 n( v8 W$ }0 K0 d3 W+ _
66.             priv->start = true;
    1 p1 C; f. n& L; z/ ~( g$ b- E
67.             return true;
    & J+ n  G  F/ B& ]( Y" [
68.         }
    1 j) N  [. f+ C8 B5 i
69.         priv = priv->next;     
    2 l3 G8 S* D8 s2 n5 S
70.         }  
    
71.    
    
72.     return false;
    
73. }
    
74. 
    . V, c3 U9 @& m2 \" t) [
75. uint8_t timer_register_isr(  uint32_t time_out ,uint8_t start, time_call_back call_back)
    & [- d, d" V: k' c) A4 A
76. {
    
77.         time_type *priv;
    
78.         time_type        *this;
    ( F& H" s7 U/ f+ e! H6 N
79. 
    
80.         this = (time_type *)timer_malloc(sizeof(time_type));
    / ]* V7 o& B, }6 B
81.         if( this != NULL)
    
82.         {
    
83. 
    0 `# [' {7 y# ~2 F5 H
84.                 this->cnt = 0;
    3 r2 P% t" l8 F% V0 Y8 _
85.                 this->start = start;
    ( [0 s) }* S9 x
86.                 this->handle = timerTaskId++;
      B3 J2 c. E* z3 Z
87.                 this->time_out = time_out;
    
88.                 this->fun = call_back;
    
89.                 this->next = NULL;
    
90.         if( time == NULL)
    ) O- G" O9 |% T1 {- P
91.                 {
    
92.                          time = this;
    
93.                 }
    
94.                 else
    
95.                 {
    : F" `+ w2 a2 g; w& ?; [
96.                         priv = time;
    
97.                         while( priv->next != NULL )        priv = priv->next;
    
98.                         priv->next = this;
    
99.                 }   
    3 |4 K$ E* J5 O5 S
100.         }
     
101.         else
     7 _. }* [! ]; C5 E
102.         {
     
103.                 return 0xFF;
     
104.         }
     9 s0 \: u' I( [) [& P$ I
105. 
     - X2 y( k, a0 {9 j" s: M
106. 
       J* p( E- F  J1 t
107.     return (this->handle);
     / `: O$ E3 p3 p4 n7 c
108. 
     
109. }
     
110. 
     
111. //KEIL不支持该写法？？
     % Z( S9 |9 E2 f' f0 U/ q. Z
112. //time_ops_type  timer =
     6 {6 D- o5 g9 T7 Z8 h0 n' A
113. //{
     
114. //    .creat = timer_register_isr,
     # }# J7 C8 L8 E2 ~) E$ v
115. //    .stop  = timer_stop_time ,
     
116. //    .start = timer_start_time,
     # i8 T# A4 A. d3 e9 O
117. //};
     4 N6 ^. H( L2 {! t2 @
118. 
     
119. 
     , ~- o$ k; {& P) J
120. time_ops_type  timer =
     
121. {
     
122.     timer_register_isr,
     " J9 x3 F: Y+ G8 h
123.     timer_stop_time ,
     
124.     timer_start_time,
     % M, `4 Z3 R% K( ]0 a7 n8 x
125. };
     

复制代码

实现如上 因为用了链表需要malloc函数 我没有用C库 而是自己写的内存分配模块
5 {/ \3 y/ [% X' }: b* D
8 g" }- q3 p- |4 m3 Y# L( y举一个例子吧
: N/ Q4 F: t$ y+ C/ i$ {int IDID=0;
$ `7 r3 A! b2 d2 u& h; _0 q+ iint wang=0;
void saywang(void)
% l4 _6 [& a6 {1 k$ i' w! T. N{
& _+ f: q& w' u* `    wang++;
    if(wang==4)
        timer.stop(IDID);
; o, G3 L  [# j/ f}
void Business_Init(void)
{
6 w( G' [% f6 H        IDID=timer.creat(100,1,saywang);

。。。。。
}

初始化的时候创建了一个定时器节点，时间是100个节拍，1是直接打开，到达设定时间就会调用saywang函数。
可以在找一个条件比较按键来                                timer.start(IDID); 再次打开这个节点功能。
' ^: u! v9 ?( u  r" U$ i6 e
$ O% R. m$ p2 U, Y而后天程序放到it.c即可
void TIM3_IRQHandler(void)
{
        static char count=0;        
        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
7 z1 b2 u4 `  ?6 b6 W8 v' G5 T$ S       timer_isr(  );
}
4 w# x& `0 j  ]0 \3 k* E' d9 ~

好像很厉害的样子

学习了 涨姿势了

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

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

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

好贴，收藏了