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

前一篇帖子我写了时驱函数的设计本质是一种前后台程序，本文依旧如故。后台程序放到定时器里面，周期性的调用。这个程序程序是扫描一个链表，链表中每一个成员 噢 应该说没一个节点都设计好数据的结构体，到达设定的时间就执行回调函数。
功能：完成约定时间调用回调函数。
) s& ?, u. @& T$ _6 ?8 J头文件：
& i% U. v: s7 ^( M/ f$ }; J

1. #ifndef _TIMELIST_H_
   
2. #define _TIMELIST_H_
   
3. 
   
4. #include "sys.h"
   
5. typedef struct  _time
   
6. {
   
7.         void        *next;//指向后一个
   
8.         uint8_t     handle;//自己的ID号
   1 |4 s4 ^2 k* K
9.         uint8_t     start;//开关1开0关
     S) W1 e! c% N" a7 v- f
10.         uint32_t    cnt;//累计次数的变量
    & A3 m3 E7 l- y1 j# B  A
11.         uint32_t    time_out;//设定次数的常量
    
12.         void        (*fun)(void);//计数达到以后做啥的函数
    
13. }time_type;
    
14. 
    3 [  X# X5 k/ }: {( q
15. 
    / n; D: J5 \$ v  p2 S2 v
16. 
    6 `& v/ I, l: V! ^" j
17. typedef void    (*time_call_back)(void);
    
18. typedef struct
    
19. {
    4 ]4 R: G5 H5 F6 P6 D1 E" U3 s# W
20.     uint8_t (*creat) (  uint32_t time_out ,uint8_t start, time_call_back call_back);
    % W' b) z( n" u3 N4 j7 R7 [7 a# A
21.     uint8_t (*stop)  (  uint8_t handle);
    
22.     uint8_t (*start) (  uint8_t handle);
    
23. }time_ops_type;
    
24. 
    
25. extern time_ops_type   timer;
    ) F+ ~9 |7 c% @
26. 
    9 z: v% P) a' a' |4 X4 r8 h
27. 
    
28. void timer_isr( void );
    % H* h8 i* Z. a4 M; b; F4 J
29. 
    + v5 l" E3 D5 \5 ~) L* ]
30. #endif
    9 K9 m; [* r5 s4 T% Q, I2 i0 k7 ?
31. 
    6 j4 O/ O4 ^; y, m+ B3 |9 ?9 f

复制代码

看这个头文件基本就能懂一大半了。每个节点的6个成员我都批注了，handle这个词语意思很宽 ID更准确。
, X6 J# p8 M) W7 Z4 x

1. #include "timelist.h"
   ) L8 g' S2 `# V
2. #include "malloc.h"        
   5 p1 J4 G# n9 L* i  R3 c2 ?
3. #define NULL 0
   $ \! |, F& z- x
4. enum
   
5. {
     h9 I' d: a$ {3 ^
6.         false,
   ) q7 ]4 n- l0 ]" G7 I5 M: T
7.         true
   - z2 c* V! Y( M! [  M9 Z
8. };
   4 D5 x( {3 M6 v( j
9. uint8_t                         timerTaskId = 0;//全局变量 每个节点的ID号从0开始
   
10. time_type           *time = NULL; //链表的头 第一个节点
    
11. 
    , Z  |; R2 e2 x+ T. N
12. 
    8 f- K+ L1 c5 V1 z* U, u& O: W
13. void timer_isr( void )
      a8 @6 }& _5 C( F
14. {
    - w$ t$ Q5 p: i/ q- T: [4 A
15.         time_type          *priv = time;
    
16. 
    9 u! |8 V. A/ e* z8 @; A7 V
17.         while( priv != NULL )
    ( |9 |4 p! Q8 D2 u) F- t) k
18.     {
    
19.         if( priv->start)//这个节点是开的 就进去 否则pass
    
20.         {
    & F2 t5 d3 O- |3 V* }
21.             if( ++priv->cnt >= priv->time_out)//进来累计一次 直达到达约定设定值
    
22.             {
    
23.                 priv->cnt = 0;
    
24.                 if(priv->fun != NULL)        
    " R3 [6 v6 \$ s+ x3 i/ D
25.                                                                         priv->fun();
    
26.             }
    7 k6 _8 n, l8 L6 H- _
27.         }
    
28.         priv = priv->next;      
    3 W  {- J5 F! y0 V2 M& L
29.         }
    ; h+ |# a7 d& `; K
30. }
    2 j& U, K3 S* g0 d6 {
31. 
    
32. //只有malloc没有free 我没有释放
    7 z8 l$ {$ }: d$ N1 y5 G
33. //返回void*
    5 |0 W4 w; s6 L1 H8 k- \, a
34. 
    
35. void *timer_malloc(int size)
    3 B" F4 S. B+ s& d5 ^% T- T
36. {
    $ z4 S, Q7 N& Z( W' e
37.         return mymalloc(SRAMIN,sizeof(time_type));
    
38. }
    
39. 
    ' S+ }2 _2 ~3 Y* i
40. uint8_t timer_stop_time(uint8_t handle)
    3 V$ G5 k3 A6 H: e+ o
41. {
    7 E, H# m8 \+ w* p" f
42.         time_type *priv = time;
      C! W6 P* r5 M& j8 R  N2 _2 f* G: K
43.         
    
44.         while( priv != NULL )
    
45.     {
    ) v; l  J* k  M1 L" R' v
46.         if( priv->handle == handle)
    + q7 K! e3 d% t1 M
47.         {
    
48.             priv->start = false;
    
49.                                                 priv->cnt = 0;
    9 D% ~- |. `- A5 V* O
50.             return true;
    , C& T+ q  Y7 m2 @" ~2 y+ }5 G
51.         }
    
52.         priv = priv->next;     
    
53.         }  
    ! L3 G' }5 z: f% V8 p! G
54.    
    ; |+ M8 c$ e7 T& m% ]9 r
55.     return false;
    
56. }
    + h# C7 {9 _* a: u2 b6 }
57. 
    5 n1 g* Z: U: U: K
58. uint8_t timer_start_time(uint8_t handle)
    
59. {
    7 J( G1 ^2 L( I* W! v5 r; J+ Y
60.         time_type *priv = time;
    8 F1 H3 I3 i% b! f
61.         
    
62.         while( priv != NULL )
    
63.     {
      l; T$ t& K, \* w/ {5 b3 Y. {
64.         if( priv->handle == handle)
    ' w; G1 P; |" H$ s/ z) T3 y
65.         {
    0 v* l9 w, j1 o- p
66.             priv->start = true;
    
67.             return true;
    
68.         }
    
69.         priv = priv->next;     
    
70.         }  
    # _0 t9 b1 O# [: |* q
71.    
    ' ^2 ?& C6 t' f* K
72.     return false;
    
73. }
    
74. 
    , U# l3 q  ?0 D+ h/ L6 `
75. uint8_t timer_register_isr(  uint32_t time_out ,uint8_t start, time_call_back call_back)
    ! M. U3 u9 \8 G$ g
76. {
    9 h; C1 ~( W& l; A( S0 Y" y
77.         time_type *priv;
    5 F9 Z9 ?+ p1 X3 Y5 E% Z/ M* @$ g& ^
78.         time_type        *this;
    
79. 
    
80.         this = (time_type *)timer_malloc(sizeof(time_type));
    " v# a% G& O0 y7 o0 \+ r
81.         if( this != NULL)
    
82.         {
    * I2 @) X+ _+ Q& i
83. 
    9 `0 v- A6 e' f* v( S/ x- H, [
84.                 this->cnt = 0;
    
85.                 this->start = start;
    9 U0 @% n6 A( P3 U; i* x( u
86.                 this->handle = timerTaskId++;
    " D+ |% d- S0 @8 w. X$ l7 C
87.                 this->time_out = time_out;
    0 ?3 J2 s9 n* A* v" H1 e
88.                 this->fun = call_back;
    
89.                 this->next = NULL;
    
90.         if( time == NULL)
    
91.                 {
    
92.                          time = this;
    
93.                 }
    
94.                 else
    3 {: u# [3 l1 i
95.                 {
    
96.                         priv = time;
    
97.                         while( priv->next != NULL )        priv = priv->next;
    
98.                         priv->next = this;
    1 C" ^4 ]% K; s% ?! b$ c
99.                 }   
    
100.         }
     
101.         else
     
102.         {
     
103.                 return 0xFF;
     6 z' q/ W1 {& ?" D
104.         }
     $ |$ s( ?$ h$ j# v1 }3 V5 ?. s: s
105. 
     ) Y0 N: D4 Z- U( I# F! X8 u
106. 
     ( K* e- v- `5 U  F( X4 S* |9 p, ~
107.     return (this->handle);
     5 W1 @, z. s. u0 k) g" [
108. 
     
109. }
     
110. 
     ; U( ^3 @1 R$ |/ v* Q! X
111. //KEIL不支持该写法？？
     
112. //time_ops_type  timer =
     0 k! m% [( h8 C; A! f# A# l1 W) x
113. //{
     
114. //    .creat = timer_register_isr,
     1 K5 |% m- L3 z' T* q
115. //    .stop  = timer_stop_time ,
     
116. //    .start = timer_start_time,
     
117. //};
     
118. 
     
119. 
     
120. time_ops_type  timer =
     ; t& E4 V5 y8 E3 S$ p! V
121. {
     
122.     timer_register_isr,
     
123.     timer_stop_time ,
     9 q2 v4 S9 q, Q0 i6 q8 m
124.     timer_start_time,
     
125. };
     

复制代码

实现如上 因为用了链表需要malloc函数 我没有用C库 而是自己写的内存分配模块
+ h3 M& O" r6 ]- \4 x: E* g
$ a) ]" _1 i1 X8 [% w举一个例子吧
int IDID=0;
, k) H% t$ M( Y9 n, o! xint wang=0;
void saywang(void)
{
    wang++;
; N$ D3 [; `" K' y8 }    if(wang==4)
. j1 W- U% q: a        timer.stop(IDID);
+ a5 ]) s+ w! a% i, }$ w}
void Business_Init(void)
{
! ?7 c' c. C& D9 y        IDID=timer.creat(100,1,saywang);

。。。。。
}

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

1 u+ O) Z: ?5 M' ]% [1 ]而后天程序放到it.c即可
void TIM3_IRQHandler(void)
3 Z5 |6 g3 ]3 y% n. y2 ~, T: i, }7 L{
        static char count=0;        
        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
       timer_isr(  );
4 i* u# c, y: F  M" v}
0 u* E8 i7 [! s: l

好像很厉害的样子

学习了 涨姿势了

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

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

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

好贴，收藏了