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

5 o$ r. M. U% g% R* {0 p# |& R前一篇帖子我写了时驱函数的设计本质是一种前后台程序，本文依旧如故。后台程序放到定时器里面，周期性的调用。这个程序程序是扫描一个链表，链表中每一个成员 噢 应该说没一个节点都设计好数据的结构体，到达设定的时间就执行回调函数。
功能：完成约定时间调用回调函数。
头文件：

1. #ifndef _TIMELIST_H_
   
2. #define _TIMELIST_H_
   & ?2 O1 m. e- U# |2 q4 ^- a
3. 
   
4. #include "sys.h"
   
5. typedef struct  _time
   
6. {
   1 x, j1 G; f3 \6 ~) `9 @
7.         void        *next;//指向后一个
   ' c- ^9 y5 w- ^8 {9 x
8.         uint8_t     handle;//自己的ID号
   
9.         uint8_t     start;//开关1开0关
   
10.         uint32_t    cnt;//累计次数的变量
    ! ^; v; }0 ?( |- s% B
11.         uint32_t    time_out;//设定次数的常量
    
12.         void        (*fun)(void);//计数达到以后做啥的函数
    
13. }time_type;
    
14. 
    9 L$ q3 p# K$ x. v: h6 D; p
15. 
    
16. 
    ; p( o/ q$ p, Z. s" E
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;
    
26. 
    
27. 
    ( J$ N; d& L7 l
28. void timer_isr( void );
    
29. 
    
30. #endif
    
31. 
    

复制代码

看这个头文件基本就能懂一大半了。每个节点的6个成员我都批注了，handle这个词语意思很宽 ID更准确。
7 w( ?/ I5 Z7 I5 K! Y/ }1 T

1. #include "timelist.h"
   ! n, f( l! S2 B" i0 [: z
2. #include "malloc.h"        
   
3. #define NULL 0
   6 b4 U( X6 s6 ^( _0 d+ i) l! t
4. enum
   
5. {
   
6.         false,
   ( Y% L  K" q; @
7.         true
   
8. };
   
9. uint8_t                         timerTaskId = 0;//全局变量 每个节点的ID号从0开始
   0 ~: a% _4 U- g2 I7 F
10. time_type           *time = NULL; //链表的头 第一个节点
    
11. 
    9 p. @. `9 w. {6 N9 [% j
12. 
    
13. void timer_isr( void )
    * ~7 S  U+ \* M! y. h3 Y! o* `
14. {
    
15.         time_type          *priv = time;
    
16. 
    : h  _7 k# r) c# c* Q9 w( @. W
17.         while( priv != NULL )
    : I8 M# w/ i' x2 E) x
18.     {
    ; t9 P1 V% \8 u# o! g5 D) s7 M! E
19.         if( priv->start)//这个节点是开的 就进去 否则pass
    
20.         {
    
21.             if( ++priv->cnt >= priv->time_out)//进来累计一次 直达到达约定设定值
    
22.             {
    
23.                 priv->cnt = 0;
    
24.                 if(priv->fun != NULL)        
    : ~& {6 u! ?" x
25.                                                                         priv->fun();
    
26.             }
    
27.         }
    - H  ?" B8 b+ ^, a) u: Z
28.         priv = priv->next;      
    ) H5 l( M* S# {% \1 n; Q- @
29.         }
    5 y' k5 G. ~8 S  r
30. }
    . S7 G: v, L6 `6 x2 P; M; K7 N
31. 
    1 k5 l# \0 b+ E- c
32. //只有malloc没有free 我没有释放
    % u: E" P" g/ F) n
33. //返回void*
    % j2 L5 C2 d2 s
34. 
    
35. void *timer_malloc(int size)
    % K, X4 O; N- {( K4 U
36. {
    
37.         return mymalloc(SRAMIN,sizeof(time_type));
    + K# L$ j" a; D7 ?$ D% T. Z
38. }
    ; W; Q3 Q/ v7 y9 R' y
39. 
    0 D" I, i1 `8 W9 I. O4 o, y
40. uint8_t timer_stop_time(uint8_t handle)
    7 z& C4 a/ K- [
41. {
    0 {5 w( H$ R: S9 q1 x# }
42.         time_type *priv = time;
    
43.         
    
44.         while( priv != NULL )
    ! \9 @1 e; N' f. [* @
45.     {
    
46.         if( priv->handle == handle)
    & i  s4 ]- @6 y: ]7 M' M1 @; V
47.         {
    
48.             priv->start = false;
    6 K! B, O# S0 o, ~: F6 t9 X
49.                                                 priv->cnt = 0;
    
50.             return true;
    
51.         }
    
52.         priv = priv->next;     
    
53.         }  
    & M% ^3 J7 n$ I8 r5 c# Z  X0 \6 {  H
54.    
    
55.     return false;
    1 z% \7 S* F8 C, r* Q- |) z; c
56. }
    & r- c* ^# V6 g$ J# m# r; Z! T) A
57. 
    
58. uint8_t timer_start_time(uint8_t handle)
    7 B: t/ e9 O3 S9 B6 {
59. {
      `! d4 o: k) {! w9 i
60.         time_type *priv = time;
    
61.         
    . A3 u2 m$ Q7 F* Z3 D
62.         while( priv != NULL )
    ; {* T4 y$ m, x) S5 v
63.     {
    
64.         if( priv->handle == handle)
    1 d) A5 d2 l5 [# l2 o
65.         {
    9 Q1 s. n/ R0 N$ w" c
66.             priv->start = true;
    
67.             return true;
    
68.         }
    
69.         priv = priv->next;     
      I& w! S0 b+ }+ u) N# y! _
70.         }  
    % i# v( q5 l; \! {5 D3 R
71.    
    ; |4 _6 c1 g3 P% N3 {# `, [
72.     return false;
    3 |0 }" @7 Z9 ]; l0 s
73. }
    
74. 
    + s7 P7 U" {) P9 a
75. uint8_t timer_register_isr(  uint32_t time_out ,uint8_t start, time_call_back call_back)
    & O9 }& g, L2 s6 Q7 B* f
76. {
    
77.         time_type *priv;
    + m# A- {- Y6 I& n' |
78.         time_type        *this;
    6 e9 E6 z7 p9 E/ y, R# I9 s
79. 
    2 w' Q6 g4 ]: z' l8 Q1 {
80.         this = (time_type *)timer_malloc(sizeof(time_type));
    ) V8 Y2 ^! I: n% J# v# S
81.         if( this != NULL)
    
82.         {
    * @4 ~) A, w$ I: r% l6 f: ^# B
83. 
    
84.                 this->cnt = 0;
    
85.                 this->start = start;
    
86.                 this->handle = timerTaskId++;
    2 `0 o) N7 ^( s2 s8 t" y: I7 w
87.                 this->time_out = time_out;
    . H) w' E, H' {
88.                 this->fun = call_back;
    2 t7 t2 `6 K) }$ k! m, q7 j5 {
89.                 this->next = NULL;
    
90.         if( time == NULL)
    , G: a8 z& a1 V! `/ S6 h" e
91.                 {
    & n, T. A9 q+ w" o5 l
92.                          time = this;
    7 X& j) S$ `% \7 o" }, {9 k; ]
93.                 }
    
94.                 else
      j$ y; s) E' y+ x2 c: i6 c
95.                 {
    0 j8 y& X  @" a2 A: ^
96.                         priv = time;
    $ ^8 o4 [, q8 s2 C$ H  V- u4 H
97.                         while( priv->next != NULL )        priv = priv->next;
    
98.                         priv->next = this;
    , C; H, J$ J7 W
99.                 }   
    3 A0 _7 m  p: X8 M  ^
100.         }
     
101.         else
     / O8 ?3 ?2 m: e5 K! m* g9 Y2 u
102.         {
     6 r; G7 I- {+ j1 E  r. A! P' h
103.                 return 0xFF;
     ' l4 w7 f4 ^- J4 u( @
104.         }
     # ^6 U. h: v2 |- [6 p
105. 
       _  @. \, k* C& q7 u, j$ R( i
106. 
     
107.     return (this->handle);
     % l; F8 c% P' e2 t; Q' u
108. 
     $ Q+ s  f+ _0 S" l  G0 L8 n
109. }
     3 n! L' Y% L8 \* m* n+ ?5 {3 A8 h
110. 
     ) v( c# s- r% L+ R. }& b7 F
111. //KEIL不支持该写法？？
     7 s4 ^& m/ n$ L: J
112. //time_ops_type  timer =
     
113. //{
     
114. //    .creat = timer_register_isr,
     
115. //    .stop  = timer_stop_time ,
     
116. //    .start = timer_start_time,
     
117. //};
     ) H* G5 }5 t* v+ y
118. 
     $ u. x  \- T" U: C6 v
119. 
     
120. time_ops_type  timer =
     5 P; J( _& j$ s' f7 {4 R( }
121. {
     . E8 k5 a% x3 l. j# i1 f
122.     timer_register_isr,
     
123.     timer_stop_time ,
     
124.     timer_start_time,
     3 @5 `! N: v$ O! ^" e
125. };
     

复制代码

实现如上 因为用了链表需要malloc函数 我没有用C库 而是自己写的内存分配模块

举一个例子吧
int IDID=0;
int wang=0;
0 m/ x8 |7 I/ T9 K" n2 svoid saywang(void)
{
4 u$ r) ?# o. e) j, N- H# }    wang++;
" E. S( @6 L3 z8 y    if(wang==4)
        timer.stop(IDID);
}
% d# s( S/ T. ^- R' B9 S1 v4 O5 dvoid Business_Init(void)
{
        IDID=timer.creat(100,1,saywang);
/ p, d+ C; ]4 Z+ B5 L' m
' X( @. Y( \/ b: i* k: ~# v。。。。。
8 r3 B! T& b; H4 n! m3 Y}

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

而后天程序放到it.c即可
$ i- s' |- R: @0 O/ b* ?3 W1 Nvoid TIM3_IRQHandler(void)
{
" q- M7 p* R. P4 c! u( D        static char count=0;        
        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
# e2 _" u) J# A7 [       timer_isr(  );
}
; D$ k; A# e$ H! r! F7 i9 Z$ i1 I9 F

好像很厉害的样子

学习了 涨姿势了

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

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

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

好贴，收藏了