接上篇：时驱函数了解一下
/ _5 n, k% ]3 c% W% B! \7 s( t, N7 Q
6 H, i; Y# v5 b5 |% O前一篇帖子我写了时驱函数的设计本质是一种前后台程序，本文依旧如故。后台程序放到定时器里面，周期性的调用。这个程序程序是扫描一个链表，链表中每一个成员 噢 应该说没一个节点都设计好数据的结构体，到达设定的时间就执行回调函数。
功能：完成约定时间调用回调函数。
头文件：
6 x% D, k  E3 I4 O6 \

1. #ifndef _TIMELIST_H_
   
2. #define _TIMELIST_H_
   : g# E& w* q5 q% |
3. 
   
4. #include "sys.h"
   % a: b* \; K$ D% D7 D
5. typedef struct  _time
   
6. {
   
7.         void        *next;//指向后一个
     N) C( P4 h! ?. M, `4 Q1 b
8.         uint8_t     handle;//自己的ID号
   ; a: T  ?( d# R6 S
9.         uint8_t     start;//开关1开0关
   / C: E  O: c+ {7 Z! u/ J% x1 B/ _# Q
10.         uint32_t    cnt;//累计次数的变量
    
11.         uint32_t    time_out;//设定次数的常量
    $ u6 h. E. d' y4 C7 \* R" r
12.         void        (*fun)(void);//计数达到以后做啥的函数
    
13. }time_type;
    
14. 
    , P! w* R! \' ], |7 y8 M
15. 
    0 p$ M/ H+ s) v' [; L8 P% I
16. 
    % L7 S/ F% K# x( i6 v& P
17. typedef void    (*time_call_back)(void);
    : R, `! v( l: V
18. typedef struct
    % m" ]# T1 Y' e8 E3 P2 Q
19. {
    
20.     uint8_t (*creat) (  uint32_t time_out ,uint8_t start, time_call_back call_back);
    6 b1 g% h' r+ ~! G' Q: ^% X
21.     uint8_t (*stop)  (  uint8_t handle);
    # [0 W# l2 Y  Q3 W" U
22.     uint8_t (*start) (  uint8_t handle);
    
23. }time_ops_type;
    9 P; F' S* w$ }
24. 
    - {  d6 `9 [. w
25. extern time_ops_type   timer;
    
26. 
    
27. 
      L4 g6 d5 [5 O" Z( C
28. void timer_isr( void );
    
29. 
    ( j7 g$ M; _8 _$ O8 J- d1 w
30. #endif
    
31. 
    

复制代码

看这个头文件基本就能懂一大半了。每个节点的6个成员我都批注了，handle这个词语意思很宽 ID更准确。
- E: p( y5 `3 G- d5 s

1. #include "timelist.h"
   
2. #include "malloc.h"        
   
3. #define NULL 0
   
4. enum
   7 R4 j- g4 h& B/ ]  A) j* L
5. {
   : i. ^/ Z8 w' P3 \2 o$ ?) O
6.         false,
   
7.         true
     h% K! Y& ]! l/ b, n
8. };
   7 A; c- a# v4 w8 t% a
9. uint8_t                         timerTaskId = 0;//全局变量 每个节点的ID号从0开始
   & R5 q$ V; v+ p* E- e
10. time_type           *time = NULL; //链表的头 第一个节点
    / T4 P$ u4 I" ?' K3 Z
11. 
    # j3 C& k  s9 j. U
12. 
    4 b% E$ V/ K7 l' v3 \* F1 A) n( h
13. void timer_isr( void )
    4 `/ ?+ w' D; R) E6 ]1 m: ]% {
14. {
    % T. I$ j2 a' n
15.         time_type          *priv = time;
    
16. 
    ) L: b$ w  z3 o# e  i( W) Z8 O! _( C
17.         while( priv != NULL )
    
18.     {
    
19.         if( priv->start)//这个节点是开的 就进去 否则pass
    2 h+ M' L& R" z3 o
20.         {
    
21.             if( ++priv->cnt >= priv->time_out)//进来累计一次 直达到达约定设定值
    + |9 e+ Q$ T( m$ v$ C7 E8 M3 R
22.             {
    8 A2 Z0 @" U7 u1 j- j. D# ~4 N, W: T; i
23.                 priv->cnt = 0;
    
24.                 if(priv->fun != NULL)        
    
25.                                                                         priv->fun();
    
26.             }
    / c. y. n' v; q! `. @
27.         }
    6 z; P% ~$ m: L7 x
28.         priv = priv->next;      
    
29.         }
    
30. }
    8 Z* o4 s/ d& m$ P9 U$ M2 \
31. 
    
32. //只有malloc没有free 我没有释放
    + M9 `* `: B5 k, s5 J6 Z
33. //返回void*
    
34. 
    
35. void *timer_malloc(int size)
    
36. {
    
37.         return mymalloc(SRAMIN,sizeof(time_type));
    + n& D* F" w1 i
38. }
    / Z4 H5 I$ v7 L
39. 
    * F1 ~' o0 k+ K
40. uint8_t timer_stop_time(uint8_t handle)
    , k! f. ~" }4 }* o4 s
41. {
    
42.         time_type *priv = time;
    
43.         
    
44.         while( priv != NULL )
    
45.     {
    
46.         if( priv->handle == handle)
    
47.         {
    " z% @6 }+ I! y; b
48.             priv->start = false;
    ' p. O( C: \0 V9 V! g* U$ M
49.                                                 priv->cnt = 0;
    5 u5 N0 ]8 V) ]6 z
50.             return true;
    - I$ r2 e7 j% k9 s5 O
51.         }
    ( ]/ i; Y. f2 D, k6 ]! Z9 C; r4 z
52.         priv = priv->next;     
    
53.         }  
    1 `0 c) N8 E& Z( \/ S" H6 e
54.    
    , X0 w- I4 {5 }' g6 ~; E
55.     return false;
    
56. }
    ) R. e, B  C5 z5 d4 l8 p' d2 e
57. 
    . f1 a0 J6 u/ r) D5 H) ~
58. uint8_t timer_start_time(uint8_t handle)
    . J. ^1 C, c  v3 A+ w$ i
59. {
    
60.         time_type *priv = time;
    
61.         
    
62.         while( priv != NULL )
    
63.     {
    
64.         if( priv->handle == handle)
    
65.         {
    
66.             priv->start = true;
    
67.             return true;
    5 m$ ]1 y5 K: H2 |
68.         }
    9 n) ]& R' b1 u: b: ]5 j
69.         priv = priv->next;     
    
70.         }  
    
71.    
    
72.     return false;
    ( d' @7 h  h! D1 D
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;
    , r* {4 e( {9 ]9 O9 e# U( S1 S& r! C
78.         time_type        *this;
    
79. 
    . p  y+ F  H  q+ l0 D" g) U- w6 \
80.         this = (time_type *)timer_malloc(sizeof(time_type));
    
81.         if( this != NULL)
    ( \! I, W: L' S, ~7 _
82.         {
    / S  f' g& A2 v- x, ]6 M
83. 
    
84.                 this->cnt = 0;
    
85.                 this->start = start;
    
86.                 this->handle = timerTaskId++;
      X& Z+ \: F* [; v, @- V/ {* G# L  g
87.                 this->time_out = time_out;
    7 J7 P2 g* F( }
88.                 this->fun = call_back;
    
89.                 this->next = NULL;
    2 V) R3 e& p) O5 Q) T  ~$ q  j
90.         if( time == NULL)
    ! Z. a+ ^, R5 S( ?
91.                 {
    
92.                          time = this;
    : P6 ~( q* B2 W
93.                 }
    
94.                 else
    
95.                 {
    + x1 o4 {5 C$ u9 v1 B* F! A* Z+ h2 z
96.                         priv = time;
    ( C6 f) {! L' x/ _4 W. X) H0 }7 g
97.                         while( priv->next != NULL )        priv = priv->next;
    % x& J" n7 t( ?% c* q: ~
98.                         priv->next = this;
    
99.                 }   
    # f1 z& X$ H6 ~$ _, c6 @
100.         }
     
101.         else
     2 `: O4 a, Y7 g. C3 r, d; x0 ]
102.         {
     
103.                 return 0xFF;
     
104.         }
     ! P! }4 f( K9 m! b1 u4 v7 {- g5 z- u7 o
105. 
     
106. 
     
107.     return (this->handle);
     7 y. i+ v# k: D8 j& v1 K0 l* S
108. 
     1 f4 w1 d# X2 Y$ Y+ }' k
109. }
     * h7 r5 L2 J% c
110. 
     ' O" m/ ~( H, p2 D
111. //KEIL不支持该写法？？
     
112. //time_ops_type  timer =
     
113. //{
     5 @* t9 I7 Z7 c, J  I
114. //    .creat = timer_register_isr,
     
115. //    .stop  = timer_stop_time ,
     ! \5 N' T1 l& X! y+ T
116. //    .start = timer_start_time,
     
117. //};
     
118. 
     5 z5 C2 M5 b$ B' S
119. 
     ) P  w" I7 H5 W! p3 w8 s
120. time_ops_type  timer =
     
121. {
     0 b; E' A" a5 B. u2 K6 G6 B5 h
122.     timer_register_isr,
     8 C7 Y9 A8 u* ~+ `( M4 t
123.     timer_stop_time ,
     1 V. W. `- z- c$ ~! O% o( U
124.     timer_start_time,
     
125. };
     % R4 M3 O& c1 D7 l

复制代码

实现如上 因为用了链表需要malloc函数 我没有用C库 而是自己写的内存分配模块
& a! S0 m% Q8 m* r
: z$ f& D9 f  p$ c. y; z$ \! ^: C' h举一个例子吧
int IDID=0;
# ]6 `+ s. ~5 {  t3 Q2 I0 l, Tint wang=0;
void saywang(void)
3 R; W) O( K- j* _{
; U$ H- h# y, ]& P- S    wang++;
    if(wang==4)
        timer.stop(IDID);
}
void Business_Init(void)
. _* q. y3 I3 T7 M+ L{
        IDID=timer.creat(100,1,saywang);

3 c* Q# @7 {( B8 _0 d$ J。。。。。
; G( }6 m* E5 I" S# ^( z}

初始化的时候创建了一个定时器节点，时间是100个节拍，1是直接打开，到达设定时间就会调用saywang函数。
可以在找一个条件比较按键来                                timer.start(IDID); 再次打开这个节点功能。

而后天程序放到it.c即可
void TIM3_IRQHandler(void)
{
. C- H6 A3 w, U2 x( f: a( o9 Y, e: c        static char count=0;        
        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
$ B. R# V; N8 b2 ~+ T  p* ]       timer_isr(  );
5 [" Y: m$ ]0 ]}
+ Y8 M7 d. _2 O
# |! U5 t6 r! w# L# J: k6 D

好像很厉害的样子

学习了 涨姿势了

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

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

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

好贴，收藏了