滴答定时器：
, v* k, A% t7 ^        定时器的本质就是计数器。我们设置一个定值，然后计数器开始计数，从我们给的定值开始往下一直数，当数到0时，就做相应的动作（也可以不做什么，当把它用作延时计时的时候）。

  F/ U( n# p7 k* r+ d" L# Z滴答定时器systick是一个内核外设（即：内核自带的）
- m5 p3 _- `8 o, e. S- N: ~
        Systick是一个24bit的系统定时器（stm32F407的寄存器名字与位数都与f103一样，但是有些芯片定时器位数不同），向下计数（从定值开始数到0），当计数到0时，在下一个时钟边沿，会重复计数。所以如果我们用完定时器后，不再继续使用它时，记得要将定时器关掉，否则它就一直在重复计数，增加了功耗。
9 }$ x# [) p" n) B, y
Systick的作用
, ]9 }# k; D- N1.产生一个精准的定时
0 H: h4 g5 U% F, r" T, y( @/ I2.FreeRTOS时基由Systick提供
      
在说定时器前，我们先来看一看如何计数？
8 V  s5 t: Y" J3 _配置滴答定时器：
! C/ f& \! z/ S: ~+ f2 P0 d" T
7 I3 V# d6 G" q. u6 F- u
( I6 S% e1 X' T' X2 c3 O) I; F; m
+ f1 f+ k0 b0 E1 C6 v        红框中就是滴答定时器的时钟，我们可以看到分频系数为8，所以滴答定时器的频率为：72M/8 = 9Mhz
  B1 c. c: {+ |( z
! D! x  e$ C0 ]/ X6 g/ W配置滴答定时器我们需要下面几个寄存器：

4 @" X- x1 v$ h$ y$ ^0 _% }5 }

& M7 z4 P; z3 ]$ n3 ~9 S: B 注意：第16位，是定时完成标志位，每当计数到0时，该标志位就会置1。

; X+ _4 x9 v: t! x! m8 _$ @6 o$ d

注意：由于定时器是24位的，所以给定时器装载的定值是有一个范围的，红框中就是范围，范围为0x000001 ~ 0xFFFFFF   
- l# }7 n0 f7 h( o. m
0 Z$ B. v2 A! H/ j" d即：1~     也就是：1 ~ 16,777,215，如果填入的定值不是在0x000001 ~ 0xFFFFFF这个范围，则无法定时计数。
$ _9 J* H) h) H/ @# t# l0 X9 k

- ?. A& ?! N3 I
编程
产生Nms定时编程步骤：
1 J+ g+ H3 o5 o  R/ k1 L0 v        1》配置时钟源---AHB8分频，并且关闭定时器-----初始化（while（1）之前）
        2》设置计数值---N*9000
, S  |" d$ J: N5 g$ f: B6 ?        3》清除当前值寄存器----注意：清除当前值寄存器，STK_CTRL寄存器的第16位会自动清0
+ u! _/ H* [0 `3 O+ h# C4 ]5 q# H: R        4》打开定时器
: f# w; I, x9 d+ _. m/ S0 U        5》等待定时器结束
        6》关闭定时器
4 t# W& J/ q! F
: U, F, ?5 S; O; ^7 {) S代码：
* v, x( t$ Y' g- a

1. uint32_t fu_ms;  // 1ms需要计的次数
   
2. uint32_t fu_us;  // 1us需要计的次数
   
3. 
   ' Y' x! N+ m/ N+ d0 Z) _9 K$ C
4. 
   
5. void Systick_Config(uint32_t Sysclk)        //Sysclk就是系统时钟频率72Mhz，但是这里用72表示72Mhz
   
6. {
   / w. H6 m7 \( Z) f. ~4 O: y
7.     // 1》配置时钟源---AHB8分频，并且关闭定时器-----初始化（while（1）之前）
   0 k& F6 T, n  n, B" p4 B9 {
8.     SysTick->CTRL  &=~0x05;        //这里关闭定时器的原因是，有可能之前没有关闭，所以一开始先将其关闭，再进行配置
   
9. 
   1 o4 }* B* v: x" |& H+ B+ {6 d8 ?
10.     fu_us  =Sysclk/8;                // 72/8 = 9，即：表示9Mhz
    
11.     fu_ms  =fu_us*1000;        //9*1000 = 9000，由前面知道，在9Mhz下，计数9000次为1ms
    
12. }
    
13. 
    
14. 
    
15. // 定时Nms程序，ms级延时
    
16. void Systick_NmsDelay(uint32_t Nms)
    
17. {
    
18.     uint32_t temp;
    2 O5 J! T9 u8 p
19.     // 2》设置计数值---N*9000
    
20.     SysTick->LOAD =Nms * fu_ms;
    6 V5 d# H# B( Z4 j- R9 D0 n
21. 
    
22.     // 3》清除当前值寄存器----因为清除当前值寄存器，STK_CTRL的第16位（定时完成标志位）就会自动清0
    . c4 n& s+ \5 n# _0 q9 o
23.     SysTick->VAL =0;        //清除标志位
    % A* l9 k, R* A( u
24. 
    2 M$ h/ L) _; C) E4 E1 ^4 |$ d. h
25.     // 4》打开定时器
    
26.     SysTick->CTRL |=0x01;
    8 R7 A# a1 M7 N! h
27. 
    / ~/ v# ?& P! W9 ?2 X
28.     // 5》等待定时器结束
    & X4 F9 b0 t' Y
29.     do{
    
30.         temp=SysTick->CTRL;        
    , c& F* E/ Y8 t( k6 v2 q  V
31.     }while(!(temp&(1<<16)));        //判断CTRL寄存器第16位是否为1。如果为1，则说明计数数到0了，此时计数完成
    
32. 
      l9 p1 U1 m5 W* E/ a$ E, D
33.     // 6》关闭定时器
    ) H& Z! e8 Z6 V3 k
34.     SysTick->CTRL &=~0x01;
    ! u# u- h: J/ d
35. }
    5 t* `4 M9 c0 Z5 t4 M4 K: T
36. 
    ; a7 y2 p% n8 M. N8 F- v2 ]2 L

复制代码

0 u7 |0 Y' I6 i+ u# H解析：
% e* R7 k3 ?8 w6 p3 {& A2 j1.我们先来看程序，定时器程序为什么被分成  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()?
5 k4 u: V- y% s9 t: O' e
/ i$ t4 d5 m4 e) ]

2 E5 s+ H- c$ x2 t- j4 B* C+ ?2 X        这里需要用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 S7 A# H% d9 s/ R, O

% C2 i+ g( }3 ]7 D% G3 e8 l2 ?3.  由上面知滴答定时器的计数器是24位的，其计数范围为 0x000001 ~ 0xFFFFFF ，即：1 ~ 16,777,215，那么如果我需要计的数超过了这个范围呢？我该怎么办？

        由前面知，计数9000下，延时1ms。所以，16,777,215可以延时1864ms，即：  =  1864 。也就是说，在9Mhz频率下，将计数器计满，可以实现延时1864ms。
: P6 T* [5 Q4 c7 n
( T" R/ X4 B) K$ d  ]3 _        的确，如果我想要延时2000ms，那么由于超过计数器的计数范围，那么滴答定时器就不会正常工作了。
9 j$ w1 ?0 ?* j" l' G- m
4 z! f- ]) T+ r6 W
. @, C+ y$ a4 C2 c6 C$ T5 x所以，我们改下一下程序：

1. // 定时Nms程序
   0 A& F! t  F$ ?  y0 s9 I3 n
2. void Systick_NmsDelay(uint32_t Nms)
   ) U' F8 R& p/ s9 p+ j- J
3. {
   
4.     uint8_t  systick_flag=0;
   . g& ~& Z" \- G+ a
5.     uint32_t temp;
   7 L6 L+ a3 V, x
6. 
   
7. 
   : A3 P. g# ^3 h
8.     while(0==systick_flag){
   
9. 
   * a" u7 i3 {2 J3 W% Q9 S$ b. E
10. 
    
11.         if(Nms>1864){
    3 j. V2 |6 y( h6 u( n6 r, v8 S
12.             SysTick->LOAD =1864 * fu_ms;
    ( r4 l9 p. ^& n* W2 n5 E
13.             Nms =Nms -1864;
    
14.         }else{
    8 A) w& j: U8 D5 Q
15.             // 2》设置计数值---N*9000
    
16.             SysTick->LOAD =Nms * fu_ms;
    
17.             systick_flag=1;
    ! {% L0 L( j+ e( g) u
18.          }
    " ^2 ~$ I7 u  Y) ]/ B
19. 
    
20. 
    
21.         // 3》清除当前值寄存器----因为清除当前值寄存器，STK_CTRL的第16位会清0
    
22.         SysTick->VAL =0;
    2 h$ b# j2 w- t% a$ U
23. 
    * w1 \7 o  ?2 O" F8 K
24.         // 4》打开定时器
    ' D0 ], h' `) T4 H: r/ J; e4 E
25.         SysTick->CTRL |=0x01;
    8 G9 W' c1 B4 v; Z1 o/ `% e7 W
26. 
    
27.         // 5》等待定时器结束
    7 N4 D+ k3 j% G
28.         do{
    0 l3 _6 g; e/ R( I
29.             temp=SysTick->CTRL;
    * v$ p& b0 q# |* ~1 c
30.         }while(!(temp&(1<<16)));
    
31. 
    / X% C; x; B: h% e6 h  d$ q
32.         // 6》关闭定时器
    
33.         SysTick->CTRL &=~0x01;
    , R- E# m$ S& [  ~& S% k% _
34. 
    
35.      }
    
36. 
    * M2 c( B4 k, Q; s8 o( `
37. 
    
38. }
    
39. 
    3 V: g  w" U+ C1 p  ]& R

复制代码

) A2 [8 b( I0 ~! h3 ]这样的话，就解决了1864问题了。
* N2 @2 |5 O7 w, ]

- D5 I5 S3 Z2 |8 P; E4.us级的延时程序是什么？
9 _' ~" E, K+ f3 {4 x1 b

1. // 定时Nus程序
   4 d- ^8 ]' D3 A! F. a( p
2. void Systick_NusDelay(uint32_t Nus)
     Z3 B8 r/ J0 k# |/ g% R- l
3. {
   * G3 y" a" N- S7 r; j1 v
4.     uint32_t temp;
   * H, s; d/ }! D& E( C) g
5.     // 2》设置计数值---N*9
   ( E& R: j. {$ D, a
6.     SysTick->LOAD =Nus * fu_us;        //us与ms的程序就只有这里改变了
   
7. 
   
8.     // 3》清除当前值寄存器----因为清除当前值寄存器，STK_CTRL的第16位会清0
   
9.     SysTick->VAL =0;
   
10. 
    
11.     // 4》打开定时器
    3 ~) `0 m4 x8 j$ |$ b5 [, p/ b- G
12.     SysTick->CTRL |=0x01;
    4 X. z: ~) a( P. J: k
13. 
    
14.     // 5》等待定时器结束
    
15.     do{
    # }1 Q; E7 N' e# c. _+ M7 n4 x
16.         temp=SysTick->CTRL;
    ) r6 Z* B  ~% S; _6 z; b+ M
17.     }while(!(temp&(1<<16)));
    
18. 
    . N( i# }) A" _- E1 T& P
19.     // 6》关闭定时器
    3 \7 `4 p( w8 E! i8 E# M
20.     SysTick->CTRL &=~0x01;
    
21. }
    
22. 
    ! y/ Q( \0 T! w5 X

复制代码

9 ?/ I! \, L1 U: a' A注意:
        在FreeRTOS操作系统中，不能使用我们自己设置的Systick来进行延时，因为FreeRTOS时基是由Systick提供（裸机的时基是由晶振提供的）。这是什么意思？
. Y3 }+ ]7 C2 R, w6 O9 ?
1 B# v( o% J  x- n+ Z: D5 u3 }5 O        FreeRTOS时基是由Systick提供，时基是需要保持不变的，所以Systick寄存器中的值必须是固定的，是不允许被修改的。但是，如果我们在FreeRTOS中用我们手动设置的Systick来进行延时，我们必定会去修改Systick寄存器中的值来得到我们需要的延时。所以，此时如果在FreeRTOS中使用我们手动设置的Systick去进行延时，那么就会卡死。解决办法：使用软件延时，delay()函数来代替Systick延时。代码如下：

0 i' R2 A' g$ _5 H7 D9 c

1. //初始化延迟函数
   3 s" a. ?; k6 t! n! }6 \1 `  d
2. //SYSTICK的时钟固定为AHB时钟，基础例程里面SYSTICK时钟频率为AHB/8
   
3. //这里为了兼容FreeRTOS，所以将SYSTICK的时钟频率改为AHB的频率！
   
4. //SYSCLK:系统时钟频率
   4 A& S6 W5 M5 Y, f- _% j* }
5. void delay_init(u8 SYSCLK)
   ' h  U# v, W) q/ c1 _
6. {
   4 ]3 i- G$ L; P1 U/ |
7.     u32 reload;
   3 T# Q% Z6 C. w
8.      SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);
   0 N3 G/ l. p+ B5 l- z1 T8 G
9.     fac_us=SYSCLK;                            //不论是否使用OS,fac_us都需要使用
   
10.     reload=SYSCLK;                            //每秒钟的计数次数 单位为M      
    
11.     reload*=1000000/configTICK_RATE_HZ;        //根据configTICK_RATE_HZ设定溢出时间
    
12.                                             //reload为24位寄存器,最大值:16777216,在168M下,约合0.0998s左右   
    6 r* B: r  b: S5 j! v( }* g/ N
13.     fac_ms=1000/configTICK_RATE_HZ;            //代表OS可以延时的最少单位      
    6 M( Y2 J+ U5 p, n& ~4 G& [6 P8 X
14.     SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;//开启SYSTICK中断
    
15.     SysTick->LOAD=reload;                     //每1/configTICK_RATE_HZ断一次   
    * H9 T$ T) e3 \' d
16.     SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk; //开启SYSTICK     
    6 k* [2 C, `9 o# A+ c3 l
17. }            
    
18. 
    
19.                        
    8 d8 b* R9 I. r6 c1 T8 Z" ^
20. 
    
21. //延时nus
    
22. //nus:要延时的us数.   
    
23. //nus:0~204522252(最大值即2^32/fac_us@fac_us=168)                                          
    0 C' R" w: v$ H7 Z9 i9 d
24. void delay_us(u32 nus)
    
25. {        
    1 T  j1 ]8 H+ q9 r" |
26.     u32 ticks;
    6 ]! e2 u. [7 O! H
27.     u32 told,tnow,tcnt=0;
    ( ?9 _& u* L9 \- E6 r1 ~
28.     u32 reload=SysTick->LOAD;                //LOAD的值            
    1 d- H2 ^$ Q6 b  N/ o$ ^
29.     ticks=nus*fac_us;                         //需要的节拍数
    6 ]: \0 J/ f* n& z
30.     told=SysTick->VAL;                        //刚进入时的计数器值
    : f( f) \  `4 L- t
31.     while(1)
    
32.     {
    ) q4 `/ q/ ^* N0 ^& E4 \
33.         tnow=SysTick->VAL;   
    - \7 X8 V; `- o* Q$ B
34.         if(tnow!=told)
    
35.         {        
    ' [1 d1 x( U# ~/ c+ v
36.             if(tnow<told)tcnt+=told-tnow;    //这里注意一下SYSTICK是一个递减的计数器就可以了.
    6 P6 K0 I. v: s0 L- v/ Y
37.             else tcnt+=reload-tnow+told;        
    
38.             told=tnow;
    
39.             if(tcnt>=ticks)break;            //时间超过/等于要延迟的时间,则退出.
    
40.         }  
    
41.     };                                            
    
42. }  
    1 d" h% t0 H$ {  c7 I
43. 
    
44. 
    ; r( O6 Z5 W  d: r) ]
45. //延时nms
    
46. //nms:要延时的ms数
    
47. //nms:0~65535
    / s. T$ _) c+ A9 ]9 f. e3 A& \1 N
48. void delay_ms(u32 nms)
    " q- }$ ~% L7 L5 E2 _
49. {   
    - ^- ], `! c- d. x7 W# d+ A$ m: t8 h9 M- a
50.     if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
    
51.     {        
    % ~) }9 U: z' l1 p
52.         if(nms>=fac_ms)                        //延时的时间大于OS的最少时间周期
    
53.         {
    
54.                vTaskDelay(nms/fac_ms);             //FreeRTOS延时
    
55.         }
    2 H: G$ A9 y* Q8 J' L3 C1 o' d% ^
56.         nms%=fac_ms;                        //OS已经无法提供这么小的延时了,采用普通方式延时   
    
57.     }
    
58.     delay_us((u32)(nms*1000));                //普通方式延时
    
59. }
    
60. 
    2 s' n0 g; q7 R* `' w
61. //延时nms,不会引起任务调度
    
62. //nms:要延时的ms数
    3 N( w/ O3 A; i
63. void delay_xms(u32 nms)
    ) J3 C  s5 a" g* E& b, m) W- C
64. {
    7 l  Y0 V3 b6 T& U+ a# u
65.     u32 i;
    
66.     for(i=0;i<nms;i++) delay_us(1000);
    % R! J: \' X) ]# B3 a; Y- H2 I3 N
67. }
    
68. ————————————————
    / J  a0 I2 E# m% ]" h$ v2 S
69. 版权声明：本文为CSDN博主「无敌小小雷」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
    
70. 原文链接：https://blog.csdn.net/qq_39577221/article/details/125153214

复制代码

$ ?) C4 v8 M7 @# L+ A5 S————————————————
/ z2 b1 _  K8 Z( B4 c2 a" z版权声明：无敌小小雷
如有侵权请联系删除
2 Z4 t$ u2 i( K