分享：STM32下的非阻塞延时模块，可以在状态机下使用

luweixuan

        在参考各个开发板的例程的基础上，经过自身编程实践重新构建和修改，编写了以下方便在状态机模块里使用的延时计数模块。延时计数的基础是SYSTICK，设置为1ms.具体代码如下：
softtimer.h：

1. /*
   
2. *********************************************************************************************************
   
3. *
   
4. *                                                SOFTTIMER
   
5. *
   
6. *                                     ST Microelectronics STM32
   
7. *                                              on the
   
8. *
   
9. *                                         STM32Fx-DISCOVERY
   
10. *                                         Evaluation Board
    
11. *
    
12. * 文件名      : softtimer.h
    
13. * 版 本       : V0.1
    
14. * 作 者       : Lux
    
15. * 时 间       : 2014/11/27
    
16. * 编译环境    : D:\Program Files (x86)\IAR Systems\Embedded Workbench 7.0
    
17. * 摘    要    : SOFTTIMER Drive,软件方式实现的非阻塞方式的超时计时模块
    
18. *********************************************************************************************************/
    
19. #ifndef  __SOFT_TIMER_H
    
20. #define  __SOFT_TIMER_H
    
21. 
    
22. 
    
23. 
    
24. #ifdef __cplusplus
    
25. extern "C" {
    
26. #endif
    
27.   
    
28.   //-----------------------Include files--------------------------------//
    
29.   #include <stdbool.h>
    
30.   #include <stdint.h>
    
31.   //------------------------Data struct---------------------------------//
    
32.   typedef enum
    
33.   {
    
34.     ONCE_MODE = 0x00,
    
35.     CIRC_MODE = 0x01
    
36.   }TIMER_MODE_t;
    
37.   
    
38.   typedef struct SOFT_TIMER
    
39.   {
    
40.     TIMER_MODE_t          mode;
    
41.     bool                  isActivate;
    
42.     volatile uint32_t     value;
    
43.     uint32_t              totvalue;
    
44.     struct SOFT_TIMER*    next;
    
45.   }SOFT_TIMER_t;
    
46.   
    
47.   //------------------------Extern function-----------------------------//
    
48.   void soft_timer_register(SOFT_TIMER_t *st);
    
49.   void set_and_star_soft_timer(SOFT_TIMER_t *st, TIMER_MODE_t mode, uint32_t totvalue);
    
50.   bool is_soft_timer_Out(SOFT_TIMER_t *st);
    
51.   void soft_timer_release(SOFT_TIMER_t *st);
    
52.   
    
53. #ifdef __cplusplus
    
54. }
    
55. #endif
    
56. #endif  /*__SOFTTIMER_H*/

复制代码

softtimer.c:

1. #include "softtimer.h"
   
2. #include <stdlib.h>
   
3. #include "stm32f10x.h"
   
4. 
   
5. /* 使能中断 */
   
6. #define ENABLE_SYSTICK_INT()        __set_PRIMASK(0)
   
7. #define DISABLE_SYSTICK_INT()        __set_PRIMASK(1)
   
8. /* 禁止中断 */
   
9. 
   
10. static struct SOFT_TIMER *head = NULL;
    
11. 
    
12. /* SoftTimer_ISR中断服务程序，每隔1ms进入1次 ****************************************/
    
13. void SoftTimer_ISR(void)
    
14. {
    
15.   struct SOFT_TIMER *t = head;
    
16.   if (t == NULL)
    
17.     return;
    
18.   
    
19.   while(t != NULL)
    
20.   {
    
21.     if (t->isActivate == true)
    
22.       t->value++;
    
23.     t = t->next;
    
24.   }
    
25. }
    
26. 
    
27. 
    
28. // 注册软件计时器
    
29. void soft_timer_register(SOFT_TIMER_t *st)
    
30. {
    
31.   struct SOFT_TIMER *t = head;  
    
32.   st->isActivate = false;
    
33.   st->mode       = ONCE_MODE;
    
34.   st->value      = 0;
    
35.   st->totvalue   = 0;
    
36.   st->next       = NULL;
    
37. 
    
38.   if (head == NULL)
    
39.   {
    
40.     head = st;
    
41.     return;
    
42.   }
    
43.   
    
44.   while(t->next != NULL )
    
45.   {
    
46.     if (t == st) return; //此语句排除重复注册的现象
    
47.     t = t->next;
    
48.   }
    
49.   DISABLE_SYSTICK_INT();  
    
50.   t->next = st;
    
51.   ENABLE_SYSTICK_INT();
    
52. }
    
53. 
    
54. // 设置并开始软件计时器，计时单位为ms
    
55. void set_and_star_soft_timer(SOFT_TIMER_t *st, TIMER_MODE_t mode, uint32_t totvalue)
    
56. {
    
57.   st->mode = mode;
    
58.   st->totvalue = totvalue;
    
59.   DISABLE_SYSTICK_INT();
    
60.   st->value = 0;
    
61.   st->isActivate = true;
    
62.   ENABLE_SYSTICK_INT();
    
63. }
    
64. 
    
65. // 查询软件计时器是否超时
    
66. bool is_soft_timer_Out(SOFT_TIMER_t *st)
    
67. {
    
68.   bool res = false;
    
69.   if (st->value >= st->totvalue)
    
70.   {
    
71.     res = true;
    
72.     DISABLE_SYSTICK_INT();  
    
73.     if (st->mode == CIRC_MODE)
    
74.     {
    
75.       st->value = 0;  
    
76.       st->isActivate = true;
    
77.     }else
    
78.       st->isActivate = false;
    
79.     ENABLE_SYSTICK_INT();
    
80.   }  
    
81.   return res;   
    
82. }
    
83. 
    
84. // 注销软件计时器
    
85. void soft_timer_release(SOFT_TIMER_t *st)
    
86. {
    
87.   struct SOFT_TIMER *p = head,*t = head;
    
88.   
    
89.   if (head == st)
    
90.   {
    
91.     head = st->next;
    
92.     return;
    
93.   }
    
94.   
    
95.   while(t->next != NULL )
    
96.   {
    
97.     if (t == st)      //从节点删除st
    
98.     {
    
99.       DISABLE_SYSTICK_INT();
    
100.       p->next = st->next;
     
101.       ENABLE_SYSTICK_INT();
     
102.       st->next = NULL;
     
103.       return;
     
104.     }
     
105.     else
     
106.     {
     
107.       p = t;
     
108.       t = t->next;
     
109.     }
     
110.   }
     
111. }

复制代码

使用方法如下：

1. // LED模块的状态机
   
2. void led_module()
   
3. {
   
4.   static uint8_t state = 0;
   
5.   static SOFT_TIMER_t led_st;  
   
6.   
   
7.   switch(state)
   
8.   {
   
9.   case 0:// 初始状态
   
10.     led1.init();
    
11.     led1.on();
    
12.     soft_timer_register(&led_st);
    
13.     set_and_star_soft_timer(&led_st, CIRC_MODE, 500);
    
14.     state = 1;
    
15.     //break;
    
16.   case 1:// led跳变状态
    
17.     led1.tigger();
    
18.     state = 2;
    
19.     break;
    
20.   case 2:// 延时等待状态
    
21.     if (is_soft_timer_Out(&led_st) == true)
    
22.       state = 1;      
    
23.     break;
    
24.    
    
25.   }
    
26. }

复制代码

ps: 编辑原因：添加代码压缩包

semonpic

不得不说，楼主写的很精彩。谢谢。

whatcanitbe

我也曾实现了这种，不过写的没这么规范。

hitlfba11

写得真好

stm32_xiaocai

支持，前几天也自己写了用回调函数的软件定时器。

bbbbbv

虽然还未看懂，但还要支持。

hkchenhao

先mark，回头细看

lovecxm

感觉还是不够灵活，不过使用os的可以参考

ijlc1314

楼主写得真好，就是在小资源的片子上内存开销比较大

styleno1

谢分享，只是用起来有点费劲了。

dongwang_fl

这个还不错。

lihq97

好像还不错，回去和我现在用的做个比较，看效果怎么样。

luweixuan

ijlc1314 发表于 2014-12-7 14:10
楼主写得真好，就是在小资源的片子上内存开销比较大

确实，内存会占用的，可以修改两个数据类型从32位到十六位或八位，具体看你的需求了。本来想增加一个内存管理模块，然后就可以即时申请使用，用完释放的。但是这样就要依靠内存管理模块，复杂度上去了。小项目已经完成了，现在要去弄FPGA了，所以就懒得再折腾了。

ijlc1314

luweixuan 发表于 2014-12-7 22:21
确实，内存会占用的，可以修改两个数据类型从32位到十六位或八位，具体看你的需求了。本来想增加一个内存 ...

8位机我用的是数组实现的，比较简单，每需要的时候从缓冲区中申请，用完后注销

slzm40

看到这个程序，用到链表的，但我觉得开销有点大,竟然在中断中1ms带用自加，为嘛不用自减，可以少用一个4个字节的空间
typedef struct SOFT_TIMER
  {
    TIMER_MODE_t          mode;
    bool                  isActivate;         //可以和modej采用宏定义方式
    volatile uint32_t     value;
    uint32_t              totvalue;        //（可以去掉，中断调用采用自减）
    struct SOFT_TIMER*    next;
  }SOFT_TIMER_t;

这样就变成
typedef struct SOFT_TIMER
  {
    uint8_t                  status;
    volatile uint32_t     value;
    struct SOFT_TIMER*    next;
  }SOFT_TIMER_t;
宏取status 其中三位就两个模式，和isactive. 用位俺码，宏定义
中断采用
void Soft_Timer_Insert_ISR(void)
{
  SOFT_TIMER_t *t = Sthead;

   while(t != NULL)
   {
    if ( 宏isactive  && (t->value > 0))
      t->value--;
    t = t->next;
   }
}

我感觉这个延时以1ms为准，2个字节就能最大产生65.536s，都能符合要求了。

另外我对这段代码的

1. // 注册软件计时器
   
2. void soft_timer_register(SOFT_TIMER_t *st)
   
3. {
   
4.   struct SOFT_TIMER *t = head;  
   
5.   st->isActivate = false;
   
6.   st->mode       = ONCE_MODE;
   
7.   st->value      = 0;
   
8.   st->totvalue   = 0;
   
9.   st->next       = NULL;
   
10. 
    
11.   if (head == NULL)
    
12.   {
    
13.     head = st;
    
14.     return;
    
15.   }
    
16.   
    
17.   while(t->next != NULL )
    
18.   {
    
19.     if (t == st) return; //此语句排除重复注册的现象
    
20.     t = t->next;
    
21.   }
    
22.   DISABLE_SYSTICK_INT();  
    
23.   t->next = st;
    
24.   ENABLE_SYSTICK_INT();
    
25. }

复制代码

里的那个遍历 while(t->next != NULL )找重复注册现象有疑问。  假设现在判断第二个是不是重复，为嘛判断next的指针？
是不是写错了。

以上个人建议。另外这样改完后，代码量就减少很多。我现在暂时用的就是这种，

Huaan

注册、注销有问题
while(t->next != NULL)
当要删除的是最后一个节点时，删不掉，并且更坏的情况是再马上重新注册未被删除的那个节点可以被注册进去，结果就是最终倒数第二个节点和倒数第一个节点重复，倒数第二个节点的下一个节点就是自己，后果就是遍历所有节点时死循环！

天使之翼

很不错，以前实现基本都是用数组。很少用链表

xurenhui

为你点赞

semonpic

Huaan 发表于 2015-1-25 09:00
注册、注销有问题
while(t->next != NULL)
当要删除的是最后一个节点时，删不掉，并且更坏的情况是再马上重 ...

高人，确实如你所说，谢谢