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

前一篇帖子我写了时驱函数的设计本质是一种前后台程序，本文依旧如故。后台程序放到定时器里面，周期性的调用。这个程序程序是扫描一个链表，链表中每一个成员 噢 应该说没一个节点都设计好数据的结构体，到达设定的时间就执行回调函数。
功能：完成约定时间调用回调函数。
; d) g! s4 w" z! K% V* Y# r头文件：
' c- o& P5 a% E; m1 q+ e  r7 f* Q

1. #ifndef _TIMELIST_H_
   0 }, f8 V1 [# d$ l% _) r- V; Y! W% B3 p" |
2. #define _TIMELIST_H_
   % N  i! N' j0 M4 C2 U
3. 
   
4. #include "sys.h"
   
5. typedef struct  _time
   5 G$ r: n/ X: O7 W
6. {
   8 H$ v# \7 g& O0 q, J* }; v- W
7.         void        *next;//指向后一个
   & r. ^6 g# ^" h! J0 }8 y3 r
8.         uint8_t     handle;//自己的ID号
   
9.         uint8_t     start;//开关1开0关
   ' K# J/ B/ {5 l" u8 Q* v
10.         uint32_t    cnt;//累计次数的变量
    
11.         uint32_t    time_out;//设定次数的常量
    8 ?/ t% A5 P$ a+ x
12.         void        (*fun)(void);//计数达到以后做啥的函数
    
13. }time_type;
    , }7 N$ X+ L. k; V" O
14. 
    0 K+ O" m+ n' i- _3 E: `
15. 
    
16. 
    " I0 i' E- M2 M& G6 G. H
17. typedef void    (*time_call_back)(void);
    
18. typedef struct
    ; M9 Y5 Y3 [/ l# h$ N8 Q
19. {
    / x6 s5 O  k7 r3 Q- M' m8 g& |9 I
20.     uint8_t (*creat) (  uint32_t time_out ,uint8_t start, time_call_back call_back);
    6 W/ v; e. _2 _3 P$ P6 i  q4 x
21.     uint8_t (*stop)  (  uint8_t handle);
    1 i: c6 I" [! x2 S/ @  B
22.     uint8_t (*start) (  uint8_t handle);
    
23. }time_ops_type;
    ) V) _" s7 T( b/ J; C" P
24. 
    
25. extern time_ops_type   timer;
    
26. 
    
27. 
    ' z* E0 T3 _4 ~$ T/ p( h: u
28. void timer_isr( void );
    
29. 
    
30. #endif
    
31. 
    ; w5 f! ^' B/ k

复制代码

看这个头文件基本就能懂一大半了。每个节点的6个成员我都批注了，handle这个词语意思很宽 ID更准确。
" ~/ W1 ?" K3 f9 x: x3 z4 X

1. #include "timelist.h"
   - Q1 F0 x+ @4 ^0 c
2. #include "malloc.h"        
   # P& @' M) d% H' ]4 P; i
3. #define NULL 0
     i* c( w) b7 G* i8 ~! [4 T4 A( h0 j: v
4. enum
   
5. {
   
6.         false,
   % s! d9 V9 e9 ^4 Q2 D4 S
7.         true
   
8. };
   ; h+ ^7 [& ], _" d
9. uint8_t                         timerTaskId = 0;//全局变量 每个节点的ID号从0开始
   $ q% \& m' C4 T, J; l5 y8 C; J$ o
10. time_type           *time = NULL; //链表的头 第一个节点
    % b. f4 u, J9 M# ]
11. 
    
12. 
    , E$ \  L$ U2 V: z# r+ L0 e
13. void timer_isr( void )
    
14. {
    
15.         time_type          *priv = time;
    + q4 b( p3 D& u: c) V" B# q4 ?
16. 
    
17.         while( priv != NULL )
    0 `9 T, R! {# Y( R" V0 f4 h( ^
18.     {
    
19.         if( priv->start)//这个节点是开的 就进去 否则pass
    6 q' N0 W+ [( q& u% h# W
20.         {
    . b" q" E  [6 U# X/ e+ r
21.             if( ++priv->cnt >= priv->time_out)//进来累计一次 直达到达约定设定值
    . g' R+ p7 ~& T' r* M
22.             {
    
23.                 priv->cnt = 0;
    
24.                 if(priv->fun != NULL)        
    4 ^3 N+ Z; M4 M
25.                                                                         priv->fun();
    
26.             }
    . C4 r2 E& [5 ]( @( ]# {; K& ^
27.         }
    - A2 N0 B& y! x6 U/ _- m
28.         priv = priv->next;      
    
29.         }
    0 l  C, k' i8 Z1 c* w0 t8 w
30. }
    , c& h4 Z9 j6 b& D3 C
31. 
    
32. //只有malloc没有free 我没有释放
    
33. //返回void*
    9 \* d% K! h0 M
34. 
    + h- l0 f% v6 q
35. void *timer_malloc(int size)
    
36. {
    
37.         return mymalloc(SRAMIN,sizeof(time_type));
    8 ]8 l. L5 m0 h$ k# d6 z8 e
38. }
    
39. 
    / H* z& [% I( }# `6 W: z8 F0 R
40. uint8_t timer_stop_time(uint8_t handle)
    
41. {
    
42.         time_type *priv = time;
    
43.         
    
44.         while( priv != NULL )
    
45.     {
    * S8 _# f- c( R
46.         if( priv->handle == handle)
    
47.         {
    
48.             priv->start = false;
    2 o, I7 B/ Z3 _0 ~6 I, r
49.                                                 priv->cnt = 0;
    
50.             return true;
    5 L! N" E+ _$ A. h1 B( k" _
51.         }
    5 r! v0 z' n" `/ Q
52.         priv = priv->next;     
    : O. q4 A9 i( k2 g: I
53.         }  
    ' w5 r- w# F5 d) J6 U" G
54.    
    * I$ ?7 U4 X. G: \; U
55.     return false;
    
56. }
    4 G! x* k9 t" ]. e  r
57. 
    ' q7 |) I/ I: F0 a$ F+ b
58. uint8_t timer_start_time(uint8_t handle)
    % T( p1 p4 {: F# S& u8 q: X8 f1 r
59. {
    0 l/ c( y6 Z; a; ?. {
60.         time_type *priv = time;
    3 O; i- [6 |$ S) a
61.         
    
62.         while( priv != NULL )
    ( U, ^" F( N& E8 c+ _8 O. a
63.     {
    
64.         if( priv->handle == handle)
    
65.         {
    & V* d- |7 i0 }  G- T2 Y$ I' C8 k
66.             priv->start = true;
    4 D, ]5 }2 F2 {! w! f
67.             return true;
    
68.         }
    9 U2 ~" R/ l7 e* S# I4 N; c8 s4 j
69.         priv = priv->next;     
    
70.         }  
    8 f% h% q. V7 a6 z3 y4 D
71.    
    
72.     return false;
    
73. }
    ! Q& p* C7 [4 W9 \6 e) _% G
74. 
    
75. uint8_t timer_register_isr(  uint32_t time_out ,uint8_t start, time_call_back call_back)
    
76. {
    
77.         time_type *priv;
    - \; G# E0 y/ w5 F
78.         time_type        *this;
    8 o/ c4 D/ A) f$ w  j- R
79. 
    ! M7 U1 T& D' X/ ]) }' h# A+ ~
80.         this = (time_type *)timer_malloc(sizeof(time_type));
    0 [, c1 }/ y9 `5 b" i/ `
81.         if( this != NULL)
    + g8 N* y2 d" d& @2 `" N; U* L; k
82.         {
    : A6 S/ Q% W2 W% b
83. 
    9 g( `: [5 S% a1 H
84.                 this->cnt = 0;
    ' K2 ]% o  E1 P% {& _, r% n2 d
85.                 this->start = start;
    + f  K8 M- A/ P$ K! Y( g% h: h
86.                 this->handle = timerTaskId++;
    ; u: |' R8 s( t* R: ]
87.                 this->time_out = time_out;
    
88.                 this->fun = call_back;
    
89.                 this->next = NULL;
    
90.         if( time == NULL)
    
91.                 {
    
92.                          time = this;
      m; ?1 m5 z' B- h  u
93.                 }
    
94.                 else
    
95.                 {
    
96.                         priv = time;
    & f7 G% |  n4 Q$ S
97.                         while( priv->next != NULL )        priv = priv->next;
    
98.                         priv->next = this;
    
99.                 }   
    
100.         }
     
101.         else
     
102.         {
     
103.                 return 0xFF;
     
104.         }
     4 w8 Z8 v% r3 A8 v2 t# y
105. 
     
106. 
     " [; w' W/ y) H# V6 F& S6 x
107.     return (this->handle);
     1 k: ]' L) ]/ ]$ [* I. z% ~( ]
108. 
     4 V8 p. w. e8 h- x
109. }
     
110. 
     - ?9 }' `/ j! N8 g" @3 m: _$ f, [
111. //KEIL不支持该写法？？
     $ e& D! Q6 T' a* N6 Z
112. //time_ops_type  timer =
     8 k1 C" |8 L+ I- e
113. //{
     , o$ @. t; ~! ?  X% `* B3 N2 U& D+ [
114. //    .creat = timer_register_isr,
     7 m) i8 a6 V$ Q# W- `! G
115. //    .stop  = timer_stop_time ,
     " S0 z" L2 r# B) w! C9 z
116. //    .start = timer_start_time,
     
117. //};
     7 z* v, f6 q; V; j% u+ e
118. 
     
119. 
     
120. time_ops_type  timer =
     
121. {
     
122.     timer_register_isr,
     
123.     timer_stop_time ,
     
124.     timer_start_time,
     
125. };
     

复制代码

实现如上 因为用了链表需要malloc函数 我没有用C库 而是自己写的内存分配模块
; p* t- R8 l6 Q) v) \' ~4 t
, Y, K) b# U# ?举一个例子吧
( {6 y# t, R. Y9 I) b; [! rint IDID=0;
: B0 C8 Y- i! K; Wint wang=0;
void saywang(void)
{
    wang++;
    if(wang==4)
& C4 Q; X5 K3 l) ?7 b        timer.stop(IDID);
+ h  h  c5 N& w}
: _( {- Q8 G' ?6 R; b' L5 Nvoid Business_Init(void)
2 F* _) a* H5 d{
        IDID=timer.creat(100,1,saywang);
* L/ p0 k6 `, r) J
! F, R6 U+ [6 e6 ]  m$ j' h. ^$ _9 U。。。。。
}
7 W) H$ g/ P; L0 K( b: ~/ C
初始化的时候创建了一个定时器节点，时间是100个节拍，1是直接打开，到达设定时间就会调用saywang函数。
0 n1 e$ \. }& d+ ]* k5 t3 D可以在找一个条件比较按键来                                timer.start(IDID); 再次打开这个节点功能。
4 k5 Z8 h( q+ m
5 a6 d* r# x9 K# I而后天程序放到it.c即可
void TIM3_IRQHandler(void)
{
% H0 b5 H  o1 ^6 h: P; @5 @" U        static char count=0;        
9 L3 A$ J2 W8 \& A. t0 V5 T! x) z        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
4 A5 U1 E& l5 x$ @; k* Q       timer_isr(  );
}

% ], u; E$ R3 T  D( ^6 G! \

好像很厉害的样子

学习了 涨姿势了

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

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

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

好贴，收藏了