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

5 E  Z) k  m; e$ C) p前一篇帖子我写了时驱函数的设计本质是一种前后台程序，本文依旧如故。后台程序放到定时器里面，周期性的调用。这个程序程序是扫描一个链表，链表中每一个成员 噢 应该说没一个节点都设计好数据的结构体，到达设定的时间就执行回调函数。
功能：完成约定时间调用回调函数。
头文件：
6 R' C6 l5 {1 b* \% K( E* p$ p- _4 L% g" [

1. #ifndef _TIMELIST_H_
   
2. #define _TIMELIST_H_
   
3. 
   # ]1 [7 K0 k" _! d$ s
4. #include "sys.h"
   9 H5 Y# B1 }/ i6 F- h
5. typedef struct  _time
   
6. {
   6 X3 V9 Q/ B+ \' p& r$ f. `& z& e
7.         void        *next;//指向后一个
   
8.         uint8_t     handle;//自己的ID号
   
9.         uint8_t     start;//开关1开0关
   
10.         uint32_t    cnt;//累计次数的变量
    
11.         uint32_t    time_out;//设定次数的常量
    ' G9 [$ O7 j; q2 p+ ]) r
12.         void        (*fun)(void);//计数达到以后做啥的函数
    + r2 @" X5 J3 t6 A( K9 M4 q
13. }time_type;
    ! @5 q4 }- J, l& }7 R& n2 Q
14. 
    7 L: Y0 L" s" ~' C: B, d7 p
15. 
    " a9 ^. O; b1 n- w4 a0 Z
16. 
    3 Z: C. i5 ?: @
17. typedef void    (*time_call_back)(void);
    
18. typedef struct
    
19. {
    
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);
    
23. }time_ops_type;
    
24. 
    
25. extern time_ops_type   timer;
    # a1 O) F% L% _! @* q( j& A
26. 
    2 _* p. h2 {* d' L$ [9 c
27. 
    0 X4 v4 }6 b+ v4 f
28. void timer_isr( void );
    
29. 
    - T! b" z# V1 b/ t, u# m
30. #endif
    9 ~+ X7 H! W1 W: s$ ?: ?
31. 
    

复制代码

看这个头文件基本就能懂一大半了。每个节点的6个成员我都批注了，handle这个词语意思很宽 ID更准确。
# a! p2 m/ }, T, {, w6 H

1. #include "timelist.h"
   
2. #include "malloc.h"        
   ) v3 ~9 e) @3 _
3. #define NULL 0
   
4. enum
   : }- ~8 k! ~+ k
5. {
   
6.         false,
   " z0 h( L0 _! e$ n: h5 _
7.         true
   
8. };
   
9. uint8_t                         timerTaskId = 0;//全局变量 每个节点的ID号从0开始
   
10. time_type           *time = NULL; //链表的头 第一个节点
    ! {0 b6 b& T( N
11. 
    $ l; w% Q: b1 K: Z! j) d9 w
12. 
    ) d7 o7 h1 o) V$ w
13. void timer_isr( void )
    8 ]. i5 i$ @/ F
14. {
    ( O/ c8 Y% L8 C  n) @
15.         time_type          *priv = time;
    
16. 
    
17.         while( priv != NULL )
    
18.     {
    
19.         if( priv->start)//这个节点是开的 就进去 否则pass
    
20.         {
    8 A" u, K. h2 _
21.             if( ++priv->cnt >= priv->time_out)//进来累计一次 直达到达约定设定值
    & @& u" @4 v0 O4 Q/ ^& w7 q
22.             {
    4 C  C+ f. F7 P- H5 n/ k
23.                 priv->cnt = 0;
    5 [$ r" h6 H" n- K
24.                 if(priv->fun != NULL)        
    
25.                                                                         priv->fun();
    * J& Z* e5 L0 X: O
26.             }
    % J6 O; U$ c4 ?( l2 \: u3 k
27.         }
    
28.         priv = priv->next;      
    
29.         }
    ; i& e- P1 z% |
30. }
    
31. 
    
32. //只有malloc没有free 我没有释放
    
33. //返回void*
    4 T  V  _; j" Q5 y! F( O
34. 
    
35. void *timer_malloc(int size)
    
36. {
    & J5 w! P5 f& ?* o
37.         return mymalloc(SRAMIN,sizeof(time_type));
    ) ^% W& S! Z1 Y. x3 X5 X$ U
38. }
    9 W5 n8 p4 ?  \# O0 A" {3 J
39. 
    / r/ i$ F* T0 l
40. uint8_t timer_stop_time(uint8_t handle)
    
41. {
    
42.         time_type *priv = time;
    * `6 J4 M  b9 w: d  l$ w
43.         
    
44.         while( priv != NULL )
    
45.     {
    
46.         if( priv->handle == handle)
    
47.         {
    ' }' K! q* s3 Y" ]* s0 c* c
48.             priv->start = false;
    * A  Y' R% N' z" U
49.                                                 priv->cnt = 0;
    
50.             return true;
    1 N/ I! A1 Z/ h2 w3 U3 _
51.         }
    
52.         priv = priv->next;     
    6 b) \  c% s" G- `* p
53.         }  
    % n/ b; z2 |- _
54.    
    ! v/ E1 l* L  {% \7 o
55.     return false;
    
56. }
    
57. 
    
58. uint8_t timer_start_time(uint8_t handle)
    9 G; L! J$ Z% e) N  Y
59. {
    ' E, I# w4 W5 }
60.         time_type *priv = time;
    ; A0 d7 G( ]( R: r' H
61.         
    / k4 l/ W5 Y5 S: F
62.         while( priv != NULL )
    
63.     {
    , ]2 Y, R+ v- i
64.         if( priv->handle == handle)
    : K- {3 x+ p9 j  n
65.         {
    
66.             priv->start = true;
    9 e1 l; h; R9 e" w7 z: |1 `
67.             return true;
    
68.         }
    
69.         priv = priv->next;     
    7 D5 Q0 f- N3 a5 p" S! G0 r; X
70.         }  
    
71.    
    0 F9 }# S( Y% _1 P, {0 G% J
72.     return false;
    
73. }
    
74. 
    
75. uint8_t timer_register_isr(  uint32_t time_out ,uint8_t start, time_call_back call_back)
    
76. {
    ) f$ n/ g9 F; |# C+ X
77.         time_type *priv;
    
78.         time_type        *this;
    
79. 
    
80.         this = (time_type *)timer_malloc(sizeof(time_type));
    9 o, ], @- y$ E
81.         if( this != NULL)
    
82.         {
    ' ]2 H, d  Y. ?" G
83. 
    
84.                 this->cnt = 0;
    
85.                 this->start = start;
    
86.                 this->handle = timerTaskId++;
    ; U  D2 y& g" T
87.                 this->time_out = time_out;
    
88.                 this->fun = call_back;
    - e  @1 C& p! T$ U8 I3 c
89.                 this->next = NULL;
    
90.         if( time == NULL)
    / r1 l" u- H8 w1 }" F! P0 [
91.                 {
    
92.                          time = this;
    # q$ E+ n; m* Y% K9 K$ ~) F$ ]
93.                 }
    
94.                 else
    3 `3 K: {, D6 ]4 s& y4 B% [9 t5 x* _
95.                 {
    ( o' b' S5 i1 {( M4 l  I
96.                         priv = time;
    2 O5 ~6 Q2 M/ _4 \, B+ g
97.                         while( priv->next != NULL )        priv = priv->next;
    
98.                         priv->next = this;
    2 m, J$ h2 ?6 T$ j$ Z  q0 C' R
99.                 }   
    
100.         }
     
101.         else
     , \4 C9 l+ J/ c- g/ P' j% z3 W
102.         {
     7 x  q; U) P' E& \
103.                 return 0xFF;
       n0 Y; ^- I/ M4 S; Y
104.         }
     
105. 
     
106. 
     
107.     return (this->handle);
     3 V. Q! y& u, Z" f0 K3 m4 z; I
108. 
     
109. }
     & j3 u/ V9 R3 G5 y1 B/ G, b9 K1 B
110. 
     
111. //KEIL不支持该写法？？
     
112. //time_ops_type  timer =
     
113. //{
     $ ~% V( W6 i! B8 A# Y" J
114. //    .creat = timer_register_isr,
     . v9 g5 |, G: G+ K& ~" \6 K
115. //    .stop  = timer_stop_time ,
     
116. //    .start = timer_start_time,
     
117. //};
     
118. 
     
119. 
     
120. time_ops_type  timer =
     
121. {
     
122.     timer_register_isr,
     4 C& P- ]( ]1 `# \$ ]
123.     timer_stop_time ,
     
124.     timer_start_time,
     ( |* f+ B. h0 Y$ V1 d
125. };
     , U! I6 `9 }' m$ |/ A- }$ Z; L$ `

复制代码

实现如上 因为用了链表需要malloc函数 我没有用C库 而是自己写的内存分配模块
, J4 F! \$ x- W% A& t6 s
举一个例子吧
+ s$ c& p+ p# Q8 w2 q+ U6 hint IDID=0;
int wang=0;
3 s7 h" Q( h  \* t8 Nvoid saywang(void)
3 u! C3 T+ u- R2 |{
    wang++;
    if(wang==4)
        timer.stop(IDID);
}
void Business_Init(void)
{
# P* j; M, o6 |/ B: C. D3 v        IDID=timer.creat(100,1,saywang);
0 l3 I" ^" b: t* q
' M0 t. ]0 V) _3 R; w) k' h/ p。。。。。
}

初始化的时候创建了一个定时器节点，时间是100个节拍，1是直接打开，到达设定时间就会调用saywang函数。
2 J5 U; G0 [( o8 o可以在找一个条件比较按键来                                timer.start(IDID); 再次打开这个节点功能。
3 \5 W6 k  F* w  j$ F  y6 b# {
而后天程序放到it.c即可
5 C1 m- @* V1 N6 U9 C% q0 Yvoid TIM3_IRQHandler(void)
4 r/ q2 n6 r% C  O) ?3 x{
        static char count=0;        
        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
       timer_isr(  );
$ D( X* i: R5 ?; m# s: N+ N" \3 j}
" T7 H( T5 P  D) O( U" V* m

好像很厉害的样子

学习了 涨姿势了

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

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

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

好贴，收藏了