如何在嵌入式linux下实现定时操作？？

happybgt

如何在嵌入式linux下实现定时操作？？
比如10s内收到数据则进行操作一，10内未受到则进行操作二,请问各位大侠怎么实现定时操作啊？我也考虑用sleep/usleep来实现，不过，它会阻塞当前线程，除了处理定时功能外，什么活也干不了。谢谢！！

happybgt

不吝赐教啊~~谢谢

T-bagwell

单timer的话可以使用signal，多timer的话，可以使用rt库

下面转一篇

软件定时器的主要功能是实现状态机的超时机制和实现基于超时的计数功能。
由于协议状态机运行于Linux内核之上，也就是说在用户态运行。在Linux系统中，用户态应用程序只能调用三个定时器：ITIMER_REAL、 ITIMER_VIRTUAL和ITIMER_PROF。而在协议状态机中需要32个定时器，所以需要新的机制来完成定时功能。
软件定时器主要被用来解决硬件定时器的物理限制，并为应用程序提供更加灵活的定时器编程接口。定时器最基本的作用就是允许某个任务在将来某个特定时间点运 行。定时器超时，被注册的任务开始运行，在我们的系统中，和定时器相关的任务就是产生某个定时器超时事件。我们定义最基本的定时器结构Timer，当作我 们的软件定时器对象：

1. 
   
2. #define MAX_TIMERS N   //N为你需要的定时器的个数
   
3. struct Timer{
   
4.             long timeout;                      // 定时器超时时间，单位毫秒ms
   
5.             long expire;                      // 下一次中断时定时器剩余的超时时间，单位毫秒ms
   
6.             int inuse;                      // 定时器是否被使用
   
7.             int set;                                // 定时器是否超时
   
8.             int signal;                      // 定时器超时时，发送的事件类型
   
9.             int param;                      // 定时器超时时，发送的事件类型的参数
   
10. }T[MAX_TIMERS];// 定时器集合
    
11.        软件定时器提供给应用程序的接口主要有4个：
    
12.        Int init_timers();                                // 初始化定时器集合
    
13.        Int start_timer(struct Timer *T);        // 启动定时器T
    
14.        Int stop_timer(struct Timer *T);        // 停止定时器T
    
15.        Int get_event();                                // 查询超时的定时器事件
    

复制代码

程序初始化时调用init_timers()初始化定时器集合，初始化之后就可以在系统中调用start_timer()和stop_timer()来使用定时器功能。协议状态机循环调用get_event()查询超时的定时器事件，输入到协议状态机内部。
软件定时器基于一个内部的由Linux操作系统提供的定时器ITIMER_REAL，实际的定时工作都由该定时器完成。定时器ITIMER_REAL每次 超时时，调用update_timers()更新定时器集合，将超时的定时器的set位置位，并查询定时器集合中所有已经启动的定时器，选择expire 值最小的那个定时器，用该expire值来重置定时器ITIMER_REAL，并更新定时器集合中所有已启动定时器的expire值。也就是说在该 expire毫秒后，定时器ITIMER_REAL将重新发生超时中断，重复以上过程。如果没有软件定时器被启动，定时器ITIMER_REAL将被清 零，直到下一次调用start_timer()。
如果在两次中断之间调用start_timer(struct Timer *T)，将会比较T->expire值和离下一次时钟中断的时间间隔time_remain。如果T->expire小于 time_remain，则将把T作为最小定时器，用T->expire重置内部定时器ITIMER_REAL，并更新定时器集合中所有已启动定时 器的expire值；如果T->expire不小于time_remain，则只需更新T的expire值。
stop_timer(struct Timer *T)只需将T的使用标识位insue置零，在更新定时器集合时就会被自动忽略。

部分代码如下：
程序soft_timer.c:

1. 
   
2. #include "soft_timer.h"
   
3. int delta = 10;
   
4. long start = 0;
   
5. struct itimerval phy_timer;
   
6. struct itimerval old_timer;
   
7. struct Timer *cur_timer;
   
8. 
   
9. void update_timers(int sig)
   
10. {
    
11.        int i = 0;
    
12.        int min_timer = -1;
    
13.        long min_expire = 1000000000;
    
14. 
    
15.        if(cur_timer->inuse)cur_timer->set = 1;
    
16. 
    
17.        for(i=0; i<MAX_TIMERS; i++){
    
18.             if(T.inuse && !T.set){
    
19.                      if(T.expire<delta){
    
20.                                T.set = 1;
    
21.                      }else if(T.expire > 0 && min_expire>T.expire){
    
22.                                min_expire = T.expire;
    
23.                                min_timer = i;
    
24.                      }
    
25.             }
    
26.        }
    
27. 
    
28.        if(min_timer<0){
    
29.             timerclear(&(phy_timer.it_value));
    
30.             timerclear(&(phy_timer.it_interval));
    
31.        }else{
    
32.             phy_timer.it_value.tv_sec = min_expire/1000;
    
33.             phy_timer.it_value.tv_usec = (min_expire%1000)*1000;
    
34.             timerclear(&(phy_timer.it_interval));
    
35.             cur_timer = &T[min_timer];
    
36.             for(i=0; i<MAX_TIMERS; i++){
    
37.                      if(T.inuse && !T.set){
    
38.                                T.expire -= min_expire;
    
39.                      }
    
40.             }
    
41.        }
    
42. 
    
43.        setitimer(ITIMER_REAL, &phy_timer, NULL);
    
44. }
    
45. 
    
46. int create_phy_timer(struct itimerval *timer, void (*handler)(int))
    
47. {
    
48. int rc = 0;
    
49.        struct sigaction sa;
    
50.        memset (&sa, 0, sizeof (sa));
    
51.        sa.sa_handler = handler;
    
52.        sigaction(SIGALRM, &sa, NULL);
    
53. 
    
54.        timerclear(&(timer->it_value));
    
55.        timerclear(&(timer->it_interval));
    
56.       
    
57.        setitimer(ITIMER_REAL, timer, NULL);
    
58. 
    
59.        return rc;
    
60. 
    
61. }
    
62. 
    
63. int init_timers()
    
64. {
    
65. int ret = 0;
    
66.        int i = 0;
    
67.        for(i=0;i<MAX_TIMERS;i++){
    
68.             T.inuse = 0;
    
69.             T.param = 0;
    
70.             T.set = 0;
    
71.             T.timeout = 0;
    
72.             T.expire = 0;
    
73.        }
    
74. cur_timer = &T[0];
    
75.        create_phy_timer(&phy_timer, update_timers);
    
76. }
    
77. 
    
78. int start_timer(struct Timer *t)
    
79. {
    
80. int ret = 0;
    
81.        int i = 0;
    
82.        long diff = 0;
    
83.        long time_remain;
    
84. 
    
85.        t->expire = t->timeout;
    
86.        t->inuse = 1;
    
87.        t->set = 0;
    
88.        getitimer(ITIMER_REAL, &old_timer);
    
89. 
    
90.        time_remain = old_timer.it_value.tv_sec*1000+old_timer.it_value.tv_usec/1000;
    
91.        //printf("time_remain=%ld\n",time_remain);
    
92.        if(time_remain==0){
    
93.             
    
94.             phy_timer.it_value.tv_sec = t->timeout/1000;
    
95.             phy_timer.it_value.tv_usec = (t->timeout%1000)*1000;
    
96.             timerclear(&(phy_timer.it_interval));
    
97.             setitimer(ITIMER_REAL, &phy_timer, NULL);
    
98.             cur_timer = t;
    
99.             return ret;
    
100.        }
     
101.       
     
102.        if(t->timeout+delta<=time_remain){
     
103.             diff = time_remain - t->timeout;
     
104. 
     
105.             for(i=0; i<MAX_TIMERS; i++){
     
106.                      
     
107.                      if(cur_timer==&T){
     
108.                                cur_timer->expire = diff;
     
109.                      }else if(t==&T){
     
110.                      }else if(T.inuse && !T.set){
     
111.                                T.expire +=   diff;
     
112.                      }
     
113.             }
     
114. 
     
115.             phy_timer.it_value.tv_sec = t->timeout/1000;
     
116.             phy_timer.it_value.tv_usec = (t->timeout%1000)*1000;
     
117.             timerclear(&(phy_timer.it_interval));
     
118.             setitimer(ITIMER_REAL, &phy_timer, NULL);
     
119.             cur_timer = t;
     
120. 
     
121.             }else{
     
122.                      t->expire = t->timeout - time_remain;
     
123.                      //printf("t->expire =%ld\n", t->expire);
     
124.             }
     
125.        return ret;
     
126.       
     
127. }
     
128. int stop_timer(struct Timer *t)
     
129. {
     
130.        int ret = 0;
     
131.        t->inuse = 0;
     
132.        t->expire = t->timeout;
     
133.        t->set = 0;
     
134.        return ret;
     
135.       
     
136. }
     
137. long current_millis()
     
138. {
     
139.        struct timeval tv;
     
140.        long   now;
     
141.        gettimeofday(&tv, NULL);
     
142.        now = (tv.tv_sec%100000)*1000+tv.tv_usec/1000;
     
143.        return now;
     
144. }
     
145. 
     
146. void sleep_millis(long ms)
     
147. {
     
148.        struct timespec tv;
     
149.        tv.tv_sec = ms/1000;
     
150.        tv.tv_nsec = (long)(ms%1000)*1000000;
     
151. 
     
152.        nanosleep(&tv, NULL);
     
153. }
     
154. 
     
155. 
     

复制代码

soft_timer.h头文件如下：

1. 
   
2. #define MAX_TIMERS N
   
3. 
   
4. struct Timer{
   
5.        long timeout;
   
6.        long expire;
   
7.        int inuse;
   
8.        int set;
   
9.        int signal;
   
10.        int param;
    
11. }T[MAX_TIMERS];
    
12. 
    
13. 
    
14. extern int init_timers();
    
15. extern int start_timer(struct Timer *t);
    
16. extern int stop_timer(struct Timer *t);
    
17. extern int start_phy_timer(struct Timer *t, void (*handler)(int));
    
18. extern int stop_phy_timer(struct Timer *t);
    
19. 
    
20. extern long current_millis();
    
21. extern void sleep_millis(long ms);
    
22. 
    
23. #ifdef __cplusplus
    
24. }
    
25. #endif
    
26. 
    
27. #endif /*__soft_timer_h*/
    

复制代码

在调用的时候可以先将其初始化

1. 
   
2.        init_timers();
   
3.        for(i = 1; i< MAX_TIMERS; i++){
   
4.             if(i<N_TIMERS){
   
5.                      T.timeout = timeouts;
   
6.                      T.signal = time_events;
   
7.             }else{
   
8.                      T.timeout = T[13].timeout;
   
9.                      T.signal = T[13].signal;
   
10.             }
    
11.        }
    
12. 
    

复制代码

随后在适当的时刻start_timer(&T[n])；或者stop_timer(&T[n])；就可以了

happybgt

谢谢你，我先学习一下！

emmoblin

学习了，反正就得用定时器实现