滴答定时器：
        定时器的本质就是计数器。我们设置一个定值，然后计数器开始计数，从我们给的定值开始往下一直数，当数到0时，就做相应的动作（也可以不做什么，当把它用作延时计时的时候）。
/ a% d- s8 w) q* A: n% \8 k' u
滴答定时器systick是一个内核外设（即：内核自带的）
$ r. x. T0 n' v* }4 d& @
  e. U$ y2 X9 j  U7 E3 R' P        Systick是一个24bit的系统定时器（stm32F407的寄存器名字与位数都与f103一样，但是有些芯片定时器位数不同），向下计数（从定值开始数到0），当计数到0时，在下一个时钟边沿，会重复计数。所以如果我们用完定时器后，不再继续使用它时，记得要将定时器关掉，否则它就一直在重复计数，增加了功耗。

4 y/ x6 g' Q! M. o% i6 y, x/ vSystick的作用
/ Z7 N8 S+ b. |; i& s& Z* C) V1.产生一个精准的定时
2.FreeRTOS时基由Systick提供
2 ]: b0 d! \- j' T# D      
在说定时器前，我们先来看一看如何计数？
配置滴答定时器：
. A! l  I* P( L; P) I


        红框中就是滴答定时器的时钟，我们可以看到分频系数为8，所以滴答定时器的频率为：72M/8 = 9Mhz
+ _! \. E2 Y3 u% F8 b
5 @/ G+ t( _0 J% K2 m5 i配置滴答定时器我们需要下面几个寄存器：



注意：第16位，是定时完成标志位，每当计数到0时，该标志位就会置1。
( |7 u: m1 F% W: P/ u. ]: m, h
5 ^1 U9 F& @) ?6 j1 X

注意：由于定时器是24位的，所以给定时器装载的定值是有一个范围的，红框中就是范围，范围为0x000001 ~ 0xFFFFFF   
$ T1 P5 a- G' ]$ ]9 ^' P
即：1~     也就是：1 ~ 16,777,215，如果填入的定值不是在0x000001 ~ 0xFFFFFF这个范围，则无法定时计数。


3 f, D% k1 w5 F# S: g' c5 _
+ d3 N0 C9 c1 _# q7 p编程
1 Z% A- X- ]6 a- z产生Nms定时编程步骤：
        1》配置时钟源---AHB8分频，并且关闭定时器-----初始化（while（1）之前）
        2》设置计数值---N*9000
2 h+ r* ^8 A$ c) _        3》清除当前值寄存器----注意：清除当前值寄存器，STK_CTRL寄存器的第16位会自动清0
/ N* e9 K& O2 g4 I) H2 }        4》打开定时器
: w+ i9 S* u0 x        5》等待定时器结束
        6》关闭定时器
1 o1 U+ ?% d6 J) o% t$ _  J; {
代码：

1. uint32_t fu_ms;  // 1ms需要计的次数
   
2. uint32_t fu_us;  // 1us需要计的次数
   - T( M0 j9 m  y1 b. z
3. 
   
4. 
   
5. void Systick_Config(uint32_t Sysclk)        //Sysclk就是系统时钟频率72Mhz，但是这里用72表示72Mhz
   9 a5 N. g/ |! A' n7 j# O" U
6. {
   
7.     // 1》配置时钟源---AHB8分频，并且关闭定时器-----初始化（while（1）之前）
   $ _' b) o5 V; h1 n# i
8.     SysTick->CTRL  &=~0x05;        //这里关闭定时器的原因是，有可能之前没有关闭，所以一开始先将其关闭，再进行配置
   
9. 
   4 C0 B! y) E) n/ m' o
10.     fu_us  =Sysclk/8;                // 72/8 = 9，即：表示9Mhz
    4 L4 G4 _+ ?( D5 G4 j9 b
11.     fu_ms  =fu_us*1000;        //9*1000 = 9000，由前面知道，在9Mhz下，计数9000次为1ms
    * U( k$ i8 h# ~9 Z) U7 d
12. }
      X' S' v& m) V/ x1 T+ J
13. 
    $ d# l5 G! q! X( p! B' t
14. 
    6 y+ P) l4 M; F+ |- a9 D
15. // 定时Nms程序，ms级延时
    6 P" o$ P# v/ O' T, E
16. void Systick_NmsDelay(uint32_t Nms)
      O" G# _- {  F+ j& [0 M) h4 P" o
17. {
    3 Y: l0 J, ^) e7 o
18.     uint32_t temp;
    
19.     // 2》设置计数值---N*9000
      L* y8 w. K: e4 y2 j
20.     SysTick->LOAD =Nms * fu_ms;
      J/ |. K$ u' E1 u) F; A
21. 
    * ~+ Z" B: A( X, h5 b
22.     // 3》清除当前值寄存器----因为清除当前值寄存器，STK_CTRL的第16位（定时完成标志位）就会自动清0
    
23.     SysTick->VAL =0;        //清除标志位
    
24. 
      D( `1 j3 y# Q# l9 Y* }/ S) M
25.     // 4》打开定时器
    
26.     SysTick->CTRL |=0x01;
    * X- q% Q9 K$ \6 L" b+ A3 W7 t6 e
27. 
    
28.     // 5》等待定时器结束
    
29.     do{
    
30.         temp=SysTick->CTRL;        
    
31.     }while(!(temp&(1<<16)));        //判断CTRL寄存器第16位是否为1。如果为1，则说明计数数到0了，此时计数完成
    ; q7 p% K0 c1 r7 V# C
32. 
    
33.     // 6》关闭定时器
    
34.     SysTick->CTRL &=~0x01;
    
35. }
    5 I8 d8 V0 o: a3 f5 ?3 _6 r& B* L: e
36. 
    

复制代码

& |; G! t, N# @解析：
1.我们先来看程序，定时器程序为什么被分成  Systick_Config(uint32_t Sysclk)  、Systick_NmsDelay(uint32_t Nms)两部分来写？
" W; n! Q' S. f3 d        因为，Systick_Config(uint32_t Sysclk) 中的配置，在整个程序中只需要被初始化一次就行了，而Systick_NmsDelay(uint32_t Nms)是延时函数，它会被多次使用。如果将Systick_Config(uint32_t Sysclk)与Systick_NmsDelay(uint32_t Nms)写在一起的话，那么多次调用该函数时，原本只需要被初始化一次的语句，就会被多次执行，浪费CPU资源。
3 J: _+ c8 |  P# R3 l! M( }
6 ^! U) r- B( h+ j+ ?2.为什么程序中的这部分需要用do.....while而不用while()?
5 \, O0 N* ]" i( k% ^


1 j3 y) y4 B8 Y0 j2 y# s        这里需要用do....while而不用while，是因为需要先执行temp = SysTick->CTRL; 将SysTick->CTRL寄存器中的值赋值给变量temp，然后再对temp进行真假判断，即：!(temp&(1<<16))。temp&(1<<16)为读取SysTick->CTRL中的第16位是1还是0，如果第16位是1，则为真，但是由于非 "!" 的存在，所以 ! (temp & (1<<16))就为假，所以此时do.....while循环不再循环下去。如果第16位是0，则为假，但是由于非 "!" 的存在，所以 ! (temp & (1<<16))为真，所以此时do.....while循环将继续循环下去。等到第16位变为1，也就是定时完成标志位置1时，如上所述，while循环将不再循环下去，此时计数器计数完成。


& _' V) a3 y; d% k/ g/ @8 u8 O3.  由上面知滴答定时器的计数器是24位的，其计数范围为 0x000001 ~ 0xFFFFFF ，即：1 ~ 16,777,215，那么如果我需要计的数超过了这个范围呢？我该怎么办？
! ^" R/ o% w% z& y' i$ z9 Y; O
1 H  q4 _+ O0 _1 n! @7 q        由前面知，计数9000下，延时1ms。所以，16,777,215可以延时1864ms，即：  =  1864 。也就是说，在9Mhz频率下，将计数器计满，可以实现延时1864ms。
* O. H$ s0 e$ k
        的确，如果我想要延时2000ms，那么由于超过计数器的计数范围，那么滴答定时器就不会正常工作了。
6 O  g) |4 [# G5 w! j8 p; n# |0 x: X; M

所以，我们改下一下程序：
8 D, O( S& W+ i- U) N

1. // 定时Nms程序
   
2. void Systick_NmsDelay(uint32_t Nms)
   # M% L- L$ N1 ?# A$ o" {
3. {
   
4.     uint8_t  systick_flag=0;
   
5.     uint32_t temp;
   
6. 
   $ ?, \) h+ B8 n
7. 
   
8.     while(0==systick_flag){
   
9. 
   
10. 
    8 ]' f+ R5 e$ g2 A0 i0 z
11.         if(Nms>1864){
    3 A5 |( c# j4 O% j
12.             SysTick->LOAD =1864 * fu_ms;
    / k: V# i" c$ B
13.             Nms =Nms -1864;
    2 x- I5 ]. R. o0 U! x
14.         }else{
    $ j; n! q8 c. s9 _
15.             // 2》设置计数值---N*9000
    : `/ i; H# H* X& K/ ^) K8 [
16.             SysTick->LOAD =Nms * fu_ms;
      ~- A* W- M( B
17.             systick_flag=1;
    6 b) c+ E+ Q/ R# t" i% o# R
18.          }
    2 W9 H5 ~% _3 Z* _5 R
19. 
    
20. 
    $ e4 {  p; b& w; ~  ^
21.         // 3》清除当前值寄存器----因为清除当前值寄存器，STK_CTRL的第16位会清0
    # ~9 M, f: J3 h6 \
22.         SysTick->VAL =0;
    
23. 
    % e, t- j8 S$ K" e* ~" w
24.         // 4》打开定时器
    
25.         SysTick->CTRL |=0x01;
    : A$ X9 L5 a$ K# p
26. 
    6 D; \$ d! K8 e$ [
27.         // 5》等待定时器结束
    
28.         do{
    
29.             temp=SysTick->CTRL;
    
30.         }while(!(temp&(1<<16)));
    . i% I  |4 m" {1 v- j
31. 
    
32.         // 6》关闭定时器
    
33.         SysTick->CTRL &=~0x01;
    
34. 
    
35.      }
    
36. 
    
37. 
    " o$ O3 K6 W& t" N6 M: m
38. }
    . T/ Y  n  L% z* K
39. 
    

复制代码

这样的话，就解决了1864问题了。


  ]; ^; ~- p' _3 w3 S* Y; x" h4.us级的延时程序是什么？
2 D+ C5 V' m4 l4 C- V

1. // 定时Nus程序
   + l# i+ g* _8 A* v. N
2. void Systick_NusDelay(uint32_t Nus)
   
3. {
   
4.     uint32_t temp;
   5 A7 c4 B8 y( C) ?" T; ^; e
5.     // 2》设置计数值---N*9
   / [8 Y4 e. @  v% X. a
6.     SysTick->LOAD =Nus * fu_us;        //us与ms的程序就只有这里改变了
   
7. 
   
8.     // 3》清除当前值寄存器----因为清除当前值寄存器，STK_CTRL的第16位会清0
   6 Q9 r% `& O  j- Z7 j
9.     SysTick->VAL =0;
   4 s1 x) W+ h6 X, ]* ~7 H2 U
10. 
    $ |% Z$ }3 ]+ t9 b
11.     // 4》打开定时器
    
12.     SysTick->CTRL |=0x01;
    1 }* W3 q; @7 O1 i8 g$ I$ N
13. 
    % F  `) D/ x/ W- r5 S& I- c
14.     // 5》等待定时器结束
    ( x3 u- w. q7 Q% [9 h
15.     do{
    
16.         temp=SysTick->CTRL;
    
17.     }while(!(temp&(1<<16)));
    
18. 
    
19.     // 6》关闭定时器
    ( |* y- V0 A6 c  y; o; V5 }. ^% _9 E
20.     SysTick->CTRL &=~0x01;
    
21. }
    + m/ J, U: t! |- A% q3 G! F
22. 
    

复制代码

+ T7 E: U# z# Z- Y$ z: o3 @注意:
: E" w: ~: P; Z+ a2 H! u        在FreeRTOS操作系统中，不能使用我们自己设置的Systick来进行延时，因为FreeRTOS时基是由Systick提供（裸机的时基是由晶振提供的）。这是什么意思？
+ o6 J# ~4 W# b9 j6 z) f& T
        FreeRTOS时基是由Systick提供，时基是需要保持不变的，所以Systick寄存器中的值必须是固定的，是不允许被修改的。但是，如果我们在FreeRTOS中用我们手动设置的Systick来进行延时，我们必定会去修改Systick寄存器中的值来得到我们需要的延时。所以，此时如果在FreeRTOS中使用我们手动设置的Systick去进行延时，那么就会卡死。解决办法：使用软件延时，delay()函数来代替Systick延时。代码如下：

! p8 C  S, u. S2 v" O  H6 r

1. //初始化延迟函数
   , C4 A! B2 N7 P3 d
2. //SYSTICK的时钟固定为AHB时钟，基础例程里面SYSTICK时钟频率为AHB/8
   
3. //这里为了兼容FreeRTOS，所以将SYSTICK的时钟频率改为AHB的频率！
   
4. //SYSCLK:系统时钟频率
   $ F, x1 l3 l( P0 y
5. void delay_init(u8 SYSCLK)
   , |/ `" x/ D& p
6. {
   4 Z3 i$ C' A  m: D
7.     u32 reload;
   
8.      SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);
   
9.     fac_us=SYSCLK;                            //不论是否使用OS,fac_us都需要使用
   
10.     reload=SYSCLK;                            //每秒钟的计数次数 单位为M      
    
11.     reload*=1000000/configTICK_RATE_HZ;        //根据configTICK_RATE_HZ设定溢出时间
    , {6 P3 Z  ]5 _* {* H
12.                                             //reload为24位寄存器,最大值:16777216,在168M下,约合0.0998s左右   
    8 n+ a& o( C1 c4 G$ G
13.     fac_ms=1000/configTICK_RATE_HZ;            //代表OS可以延时的最少单位      
    $ u# w# m/ J2 Q9 q' y1 L  Z
14.     SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;//开启SYSTICK中断
    
15.     SysTick->LOAD=reload;                     //每1/configTICK_RATE_HZ断一次   
    6 l, a9 V8 Q4 I$ v
16.     SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk; //开启SYSTICK     
    / P& t* J7 c. N5 V
17. }            
    
18. 
    - `. s5 Z; `  A/ q2 ?7 D
19.                        
    
20. 
      @6 D) z9 \& ]4 Q! N7 h
21. //延时nus
    9 D  {$ e# c" G
22. //nus:要延时的us数.   
    
23. //nus:0~204522252(最大值即2^32/fac_us@fac_us=168)                                          
    
24. void delay_us(u32 nus)
    # z- u* I0 A6 P# R6 V+ F
25. {        
    : ?7 y) n4 I/ r
26.     u32 ticks;
    
27.     u32 told,tnow,tcnt=0;
    , K* M0 V* |8 I9 V' d
28.     u32 reload=SysTick->LOAD;                //LOAD的值            
    
29.     ticks=nus*fac_us;                         //需要的节拍数
    + k6 u7 M# U! C9 j5 S" d! R, s+ G
30.     told=SysTick->VAL;                        //刚进入时的计数器值
    
31.     while(1)
    % N: y- |5 C) W6 Z7 Y
32.     {
    " F2 L- k) u3 ^4 ~6 f9 k2 n
33.         tnow=SysTick->VAL;   
    
34.         if(tnow!=told)
    % V5 D( \5 F1 `4 S
35.         {        
    7 h( {5 ?/ b) a3 k) g- W7 M% ~
36.             if(tnow<told)tcnt+=told-tnow;    //这里注意一下SYSTICK是一个递减的计数器就可以了.
      ~! M8 I$ @! V2 L% z5 l/ X3 {$ z
37.             else tcnt+=reload-tnow+told;        
    
38.             told=tnow;
    
39.             if(tcnt>=ticks)break;            //时间超过/等于要延迟的时间,则退出.
    , n" E6 [) K% j
40.         }  
    , {: L* j5 E6 q# j; ?
41.     };                                            
    
42. }  
    
43. 
    ( r9 _2 h0 H: F* E3 I$ I% e
44. 
    2 ?- z7 I; j0 e, N* J+ ]
45. //延时nms
    # A9 g1 |4 @& g2 P& U1 E
46. //nms:要延时的ms数
    
47. //nms:0~65535
    
48. void delay_ms(u32 nms)
    8 o, V" e9 j' Y
49. {   
    $ v1 L$ Y( `7 J' P& A9 S
50.     if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
    ! b/ P+ D2 \& r# g
51.     {        
    
52.         if(nms>=fac_ms)                        //延时的时间大于OS的最少时间周期
    0 n; t& ^' I) d8 C
53.         {
    
54.                vTaskDelay(nms/fac_ms);             //FreeRTOS延时
    
55.         }
    
56.         nms%=fac_ms;                        //OS已经无法提供这么小的延时了,采用普通方式延时   
    
57.     }
    
58.     delay_us((u32)(nms*1000));                //普通方式延时
    1 G" f$ p' t" p+ S! C+ s: {
59. }
    
60. 
    
61. //延时nms,不会引起任务调度
    
62. //nms:要延时的ms数
    
63. void delay_xms(u32 nms)
      Q6 q- S3 x4 f$ E
64. {
    
65.     u32 i;
    
66.     for(i=0;i<nms;i++) delay_us(1000);
    
67. }
    
68. ————————————————
    0 Z1 {/ m2 i$ q- r7 q  C6 V
69. 版权声明：本文为CSDN博主「无敌小小雷」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
    . O9 ~: p+ @0 q% U- I
70. 原文链接：https://blog.csdn.net/qq_39577221/article/details/125153214

复制代码

————————————————
版权声明：无敌小小雷
如有侵权请联系删除

. Z$ \/ X+ M( v/ B/ }8 L+ T( n; n. b