滴答定时器：
  k# h- W9 M  O$ d& w        定时器的本质就是计数器。我们设置一个定值，然后计数器开始计数，从我们给的定值开始往下一直数，当数到0时，就做相应的动作（也可以不做什么，当把它用作延时计时的时候）。
- B* W+ C8 ]2 u; ^! P. Y
滴答定时器systick是一个内核外设（即：内核自带的）
9 ?& Q# ?& n: }0 y" d
        Systick是一个24bit的系统定时器（stm32F407的寄存器名字与位数都与f103一样，但是有些芯片定时器位数不同），向下计数（从定值开始数到0），当计数到0时，在下一个时钟边沿，会重复计数。所以如果我们用完定时器后，不再继续使用它时，记得要将定时器关掉，否则它就一直在重复计数，增加了功耗。
+ e& G) M& D" }4 n
Systick的作用
1.产生一个精准的定时
2.FreeRTOS时基由Systick提供
0 j7 c' O1 q7 Q, x6 Q      
  M: S- Y2 z: r+ E' j5 q在说定时器前，我们先来看一看如何计数？
! s9 i: q0 T9 d( X8 i6 @# }配置滴答定时器：
9 }: Y$ z/ b: e5 g, I$ j! D, A. r
- j1 P7 x$ y0 k. P

        红框中就是滴答定时器的时钟，我们可以看到分频系数为8，所以滴答定时器的频率为：72M/8 = 9Mhz

& L- B0 r* n0 {" l9 i! E0 s配置滴答定时器我们需要下面几个寄存器：
; ?) f, Q4 |0 A' d, ^* X


% v4 L9 E! B/ i4 Y9 h 注意：第16位，是定时完成标志位，每当计数到0时，该标志位就会置1。

& }' }1 o9 w$ T4 t& n1 y

注意：由于定时器是24位的，所以给定时器装载的定值是有一个范围的，红框中就是范围，范围为0x000001 ~ 0xFFFFFF   
4 Z3 u/ e% ^4 U$ M3 P
) I* ?1 Y% x0 |$ b2 _即：1~     也就是：1 ~ 16,777,215，如果填入的定值不是在0x000001 ~ 0xFFFFFF这个范围，则无法定时计数。
) N9 R* [( T9 G0 P" b( g3 @
; V' l7 a/ ?/ B* R

编程
产生Nms定时编程步骤：
  |  |' x: A" O+ c! e        1》配置时钟源---AHB8分频，并且关闭定时器-----初始化（while（1）之前）
        2》设置计数值---N*9000
        3》清除当前值寄存器----注意：清除当前值寄存器，STK_CTRL寄存器的第16位会自动清0
        4》打开定时器
& M/ o% T- r# k& c8 w        5》等待定时器结束
        6》关闭定时器

代码：

1. uint32_t fu_ms;  // 1ms需要计的次数
   
2. uint32_t fu_us;  // 1us需要计的次数
   
3. 
   
4. 
   ) J$ R6 W# i' L' {7 C2 m
5. void Systick_Config(uint32_t Sysclk)        //Sysclk就是系统时钟频率72Mhz，但是这里用72表示72Mhz
   
6. {
   - j1 S& T+ X+ [6 J3 V
7.     // 1》配置时钟源---AHB8分频，并且关闭定时器-----初始化（while（1）之前）
   % R: p! p( l3 A$ e. D
8.     SysTick->CTRL  &=~0x05;        //这里关闭定时器的原因是，有可能之前没有关闭，所以一开始先将其关闭，再进行配置
   
9. 
   % y5 W2 o( Z' ~* u1 i2 W
10.     fu_us  =Sysclk/8;                // 72/8 = 9，即：表示9Mhz
    
11.     fu_ms  =fu_us*1000;        //9*1000 = 9000，由前面知道，在9Mhz下，计数9000次为1ms
    ! x0 @0 e( N  g6 Y. M
12. }
    
13. 
      f& R) X* G7 c- k
14. 
    - R/ d# A! O$ B1 @9 e& k: Y
15. // 定时Nms程序，ms级延时
    
16. void Systick_NmsDelay(uint32_t Nms)
    
17. {
    0 d- Y6 n/ p- R7 `9 F8 c* h% m
18.     uint32_t temp;
    3 u5 \5 q7 Q9 m& c; Q/ U7 f
19.     // 2》设置计数值---N*9000
    3 u: x2 A4 V9 |! D  h. g
20.     SysTick->LOAD =Nms * fu_ms;
    
21. 
    
22.     // 3》清除当前值寄存器----因为清除当前值寄存器，STK_CTRL的第16位（定时完成标志位）就会自动清0
    ( ?; ]' i' o5 G( _4 D9 ?- H0 |
23.     SysTick->VAL =0;        //清除标志位
    
24. 
    
25.     // 4》打开定时器
    $ y' T9 g8 B! s1 ~
26.     SysTick->CTRL |=0x01;
    , A0 o  K/ D3 t) s& A5 R' B
27. 
    1 A2 p! G; R% }5 w
28.     // 5》等待定时器结束
    4 t: X6 u6 [+ Q; G. J. a; Y* ]3 k0 b
29.     do{
    
30.         temp=SysTick->CTRL;        
    & t% @" }9 H5 E; o; I  L( s* ?9 I% ~
31.     }while(!(temp&(1<<16)));        //判断CTRL寄存器第16位是否为1。如果为1，则说明计数数到0了，此时计数完成
    + v( c0 f; n5 ?* F2 \6 z! ?
32. 
    
33.     // 6》关闭定时器
    
34.     SysTick->CTRL &=~0x01;
    " G( Y! n  R5 |  ]4 ?" m$ m7 Q
35. }
    5 x' C+ c4 H4 K2 ?
36. 
    1 a) a+ H, ~" {( N7 @

复制代码

解析：
1.我们先来看程序，定时器程序为什么被分成  Systick_Config(uint32_t Sysclk)  、Systick_NmsDelay(uint32_t Nms)两部分来写？
        因为，Systick_Config(uint32_t Sysclk) 中的配置，在整个程序中只需要被初始化一次就行了，而Systick_NmsDelay(uint32_t Nms)是延时函数，它会被多次使用。如果将Systick_Config(uint32_t Sysclk)与Systick_NmsDelay(uint32_t Nms)写在一起的话，那么多次调用该函数时，原本只需要被初始化一次的语句，就会被多次执行，浪费CPU资源。

2.为什么程序中的这部分需要用do.....while而不用while()?
0 \) e9 r+ ^6 s4 c# s5 u
! d+ o+ E! n. t
5 D) L  B- O. c. `  i  H6 {# J5 G
        这里需要用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循环将不再循环下去，此时计数器计数完成。
9 ~: i6 u8 o6 D5 x/ I' v
3 O% ~) ]% ?( {+ o+ b/ D+ h+ S% [
3.  由上面知滴答定时器的计数器是24位的，其计数范围为 0x000001 ~ 0xFFFFFF ，即：1 ~ 16,777,215，那么如果我需要计的数超过了这个范围呢？我该怎么办？
8 ?( s* u; q0 y* b% T; r
$ s8 Y3 B% S* u' _        由前面知，计数9000下，延时1ms。所以，16,777,215可以延时1864ms，即：  =  1864 。也就是说，在9Mhz频率下，将计数器计满，可以实现延时1864ms。
0 w4 ]+ S; R0 C; h5 z2 N
6 }0 Q8 D! S- M4 ^3 c4 R1 ]& Z        的确，如果我想要延时2000ms，那么由于超过计数器的计数范围，那么滴答定时器就不会正常工作了。

8 N# }% x& c0 N4 K0 x0 g7 `9 n
所以，我们改下一下程序：
( ~5 c7 T- r6 x' Z: G0 F$ g% ^

1. // 定时Nms程序
   9 k" @& T! j2 k+ b
2. void Systick_NmsDelay(uint32_t Nms)
   2 s% v1 a# s2 Y
3. {
   * }+ A8 e* Z2 Y7 S
4.     uint8_t  systick_flag=0;
   2 Q9 ?% d4 I7 D! o! l/ R$ f
5.     uint32_t temp;
   
6. 
     ?7 `! f9 i% m' q/ g5 @5 _
7. 
   
8.     while(0==systick_flag){
   
9. 
   
10. 
    
11.         if(Nms>1864){
    
12.             SysTick->LOAD =1864 * fu_ms;
    " }; r- N7 j1 C# |0 [2 p
13.             Nms =Nms -1864;
    / O3 h! [1 y3 |
14.         }else{
    - D5 }) C  I' s. B
15.             // 2》设置计数值---N*9000
    
16.             SysTick->LOAD =Nms * fu_ms;
    , g0 P, e, w; n( z1 k1 @' Z& B& i
17.             systick_flag=1;
    - t3 w* z1 w* [4 W* D) {" a
18.          }
    
19. 
    ; i# r6 v6 ~% B+ J" z0 {8 O
20. 
    
21.         // 3》清除当前值寄存器----因为清除当前值寄存器，STK_CTRL的第16位会清0
    
22.         SysTick->VAL =0;
    % s+ o' s  B- H8 {/ P& i
23. 
    
24.         // 4》打开定时器
    6 K/ v' n) `6 R7 v1 Q9 T
25.         SysTick->CTRL |=0x01;
    2 M& v# g! g/ ]8 _
26. 
    
27.         // 5》等待定时器结束
    2 i% o: m% M# d& E! d
28.         do{
    # j% g" g6 a4 |4 R; [$ g
29.             temp=SysTick->CTRL;
    
30.         }while(!(temp&(1<<16)));
    + B' N1 X: z8 d$ Z( I: Z
31. 
    ' j3 |' K" l& e: ^9 [5 |
32.         // 6》关闭定时器
    . ]  v0 O- o! ?2 S3 u
33.         SysTick->CTRL &=~0x01;
    
34. 
    
35.      }
    
36. 
    2 C3 }; N: Z4 ]- }( A3 h% q
37. 
    
38. }
    : K2 V! K) j8 c  X2 K% E( `
39. 
    4 c  |! f0 p5 U  Q3 O' T9 ?7 i+ q: F

复制代码

8 p1 E5 m2 D: a% b这样的话，就解决了1864问题了。
' t$ `' U$ C0 M$ v0 W

4.us级的延时程序是什么？
& N! N" D, ~1 x8 G% D& J4 u# I

1. // 定时Nus程序
   
2. void Systick_NusDelay(uint32_t Nus)
   # Y" \) }2 g. X" k
3. {
   - T" w# r3 Q& z/ l* }+ J
4.     uint32_t temp;
   
5.     // 2》设置计数值---N*9
   
6.     SysTick->LOAD =Nus * fu_us;        //us与ms的程序就只有这里改变了
   2 X% C8 W% M- Y9 S! i
7. 
   7 \* L1 R4 f5 t9 i) V  Q
8.     // 3》清除当前值寄存器----因为清除当前值寄存器，STK_CTRL的第16位会清0
   
9.     SysTick->VAL =0;
   , @# E" c0 W3 C& O6 z' \
10. 
    * A( V# a0 G0 S3 D
11.     // 4》打开定时器
    
12.     SysTick->CTRL |=0x01;
    
13. 
    
14.     // 5》等待定时器结束
    " y$ A: K3 l1 O; x
15.     do{
    % Y  a1 v2 d! _; v) Z  k; d5 L
16.         temp=SysTick->CTRL;
    # `, N$ F2 F) a
17.     }while(!(temp&(1<<16)));
    
18. 
    
19.     // 6》关闭定时器
    
20.     SysTick->CTRL &=~0x01;
    
21. }
    
22. 
    

复制代码

注意:
& w- ^: @) s' \6 h. [  r        在FreeRTOS操作系统中，不能使用我们自己设置的Systick来进行延时，因为FreeRTOS时基是由Systick提供（裸机的时基是由晶振提供的）。这是什么意思？
+ ?$ m) ~) _  f: P- C8 t* G( _
        FreeRTOS时基是由Systick提供，时基是需要保持不变的，所以Systick寄存器中的值必须是固定的，是不允许被修改的。但是，如果我们在FreeRTOS中用我们手动设置的Systick来进行延时，我们必定会去修改Systick寄存器中的值来得到我们需要的延时。所以，此时如果在FreeRTOS中使用我们手动设置的Systick去进行延时，那么就会卡死。解决办法：使用软件延时，delay()函数来代替Systick延时。代码如下：

1. //初始化延迟函数
   
2. //SYSTICK的时钟固定为AHB时钟，基础例程里面SYSTICK时钟频率为AHB/8
   - @  k. U1 H+ E" Y. m; F. y! F1 [0 \
3. //这里为了兼容FreeRTOS，所以将SYSTICK的时钟频率改为AHB的频率！
   : F. U" q  a1 \" o6 \7 ]+ }/ o. ~
4. //SYSCLK:系统时钟频率
   
5. void delay_init(u8 SYSCLK)
   # b8 G5 k8 z0 T* o
6. {
   
7.     u32 reload;
   9 X/ ]( W5 d& Z; m' \( `! K; K
8.      SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);
   4 i, w" ?0 @# E# H# b
9.     fac_us=SYSCLK;                            //不论是否使用OS,fac_us都需要使用
   
10.     reload=SYSCLK;                            //每秒钟的计数次数 单位为M      
    ) c% f& j' ?) s  P2 ?# U
11.     reload*=1000000/configTICK_RATE_HZ;        //根据configTICK_RATE_HZ设定溢出时间
    
12.                                             //reload为24位寄存器,最大值:16777216,在168M下,约合0.0998s左右   
    . y7 x# C0 }+ h4 A  U) R8 F
13.     fac_ms=1000/configTICK_RATE_HZ;            //代表OS可以延时的最少单位      
    
14.     SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;//开启SYSTICK中断
    4 I( {; o: p# G3 y$ B
15.     SysTick->LOAD=reload;                     //每1/configTICK_RATE_HZ断一次   
    , o4 ^) @% o; l4 j8 d/ G
16.     SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk; //开启SYSTICK     
    
17. }            
    * H7 `! I9 L, h- {, e$ Z( k* P2 z) W
18. 
    ) r+ E4 O9 R# N- t
19.                        
    
20. 
    
21. //延时nus
    ) I( a; ]$ d& H6 o6 c
22. //nus:要延时的us数.   
    9 e: L) @' y, z4 u3 P1 v$ N
23. //nus:0~204522252(最大值即2^32/fac_us@fac_us=168)                                          
    
24. void delay_us(u32 nus)
    5 D  P0 B) p5 e# Y/ Y+ [" }
25. {        
    3 k& Z+ v' y9 S# |1 ^
26.     u32 ticks;
    
27.     u32 told,tnow,tcnt=0;
    
28.     u32 reload=SysTick->LOAD;                //LOAD的值            
    : e( w- X0 r% W7 S
29.     ticks=nus*fac_us;                         //需要的节拍数
    
30.     told=SysTick->VAL;                        //刚进入时的计数器值
    
31.     while(1)
    ( W: B; u( J, Q" J
32.     {
    
33.         tnow=SysTick->VAL;   
    
34.         if(tnow!=told)
    5 s  l: W' l) v. `) E, E
35.         {        
    ' r& W5 d8 \7 i8 Y3 d4 ]& ]+ K
36.             if(tnow<told)tcnt+=told-tnow;    //这里注意一下SYSTICK是一个递减的计数器就可以了.
    
37.             else tcnt+=reload-tnow+told;        
    , W7 C( r6 i, m( h4 g
38.             told=tnow;
    ! L  @- b, j7 I6 M+ E
39.             if(tcnt>=ticks)break;            //时间超过/等于要延迟的时间,则退出.
    
40.         }  
    
41.     };                                            
    
42. }  
    
43. 
    : E1 ]6 A0 U9 h% v2 _
44. 
    
45. //延时nms
    
46. //nms:要延时的ms数
    # q+ I8 Z" Z  m4 p
47. //nms:0~65535
    
48. void delay_ms(u32 nms)
    , Y% i; B5 u) ?  I4 A6 X, z# c
49. {   
    8 Z8 `1 N7 @) J: B. U' ~
50.     if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
    
51.     {        
    
52.         if(nms>=fac_ms)                        //延时的时间大于OS的最少时间周期
    
53.         {
    - c% l- n8 g2 g) Q  c
54.                vTaskDelay(nms/fac_ms);             //FreeRTOS延时
    
55.         }
    9 N+ v& v7 S$ Q* x7 t
56.         nms%=fac_ms;                        //OS已经无法提供这么小的延时了,采用普通方式延时   
    / A5 P. n: q" B% z7 M
57.     }
    
58.     delay_us((u32)(nms*1000));                //普通方式延时
    ! q+ f6 [( I0 {! r
59. }
    
60. 
    
61. //延时nms,不会引起任务调度
    4 o% @# o/ O5 z1 d- v. m3 l
62. //nms:要延时的ms数
    
63. void delay_xms(u32 nms)
    
64. {
    - k6 u. L- ~$ a/ o) L
65.     u32 i;
    % `5 y# ^  j% b" a
66.     for(i=0;i<nms;i++) delay_us(1000);
    
67. }
    & |& l$ x7 @( ^7 r$ d$ ]" {8 a, s
68. ————————————————
    : H* {/ g; `' g0 ^
69. 版权声明：本文为CSDN博主「无敌小小雷」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
    : X) b9 M9 K( r* O) s, {  I% {
70. 原文链接：https://blog.csdn.net/qq_39577221/article/details/125153214

复制代码

————————————————
/ D0 {. W0 N  r2 S版权声明：无敌小小雷
如有侵权请联系删除
1 [" s  F2 r% f
2 c8 \& a2 U! |: V  b