SysTick高精度延时实验
3 W' M+ ]5 r( H$ v( u' [) G前面章节的实验我们使用的是HAL库里自带的API函数HAL_Delay来实现毫秒级别延时的，如果使用到更高精度的延时，例如us级别的延时，我们可以使用定时器来实现，也可以使用SysTick的时钟摘取法来实现。本节，我们介绍如何使用SysTick来实现us级别的延时。

23.1 SysTick简介
23.1.1 SysTick初识
1.什么是SysTick
SysTick即系统滴答定时器（system tick timer），它被捆绑在NVIC中，属于Cortex-M内核的一部分。SysTick是一个24位的递减定时器，它是可编程的，软件上可通过对其对应的LOAD寄存器中写入一个数值（最大为224-1）来配置定时器的定时初值。当SysTick以一定的频率工作的时，每来一个脉冲，SysTick从定时初值逐1递减，当递减到0时，SysTick产生一次中断，同时从RELOAD 寄存器（值等于LOAD）中自动重装载定时初值，并重新开始新一轮的递减计数，如此反复。此过程就和我们前面学习的通用定时器以及高级定时器的递减计数功能类似，通过递减计数产生周期性的中断、延时，从而达到计时的效果。
7 X6 z& V) S+ B; ]( P  z6 Z% N/ Q6 Y

图23.1.1. 1 SysTick是递减计数
% V2 L* A4 {, fSysTick属于Cortex-M内核的一个部分，并不是MCU片上外设，所以找遍了参考手册以及数据手册的犄角旮旯，你也看不到更多有关SysTick的详细介绍，如果想了解SysTick，应该查阅内核有关的文档，例如《ARM Cortex-M3与Cortex-M4处理器权威指南》、《Cortex-M3权威指南(中文)》以及《STM32F3与F4系列Cortex M4内核编程手册》等内核相关文件，这些资料存放在 STM32MP157开发板\开发板光盘A-基础资料\4、参考资料 下。
2. 为什么要有SysTick
SysTick设计的目的就是给操作系统（OS）提供时基，用于周期性地产生中断来定时触发OS内核，如用于任务管理和上下文切换，处理器也可以在不同时间片内处理不同的任务。若应用中存在嵌入式OS，例如TinyOS、UCOS、RTOS和FreeRTOS等操作系统，SysTick会被OS使。如果不使用OS ，SysTick可当做简单的定时器来用。
对于简单的应用程序，例如我们编写的裸机程序，都是在一个while循环里依次调用各单任务来实现的，如果要处理更多任务或者更复杂的应用，再使用裸机程序就力不从心了，而且会出现更多的问题，例如，在while循环的单任务引用中，如果某一个任务出现问题，后续的任务就被牵连，从而导致系统崩溃。为解决这个问题，操作系统就可以登场了，我们以实时操作系统（RTOS）为例子来说明。当RTOS以并行的架构处理多个任务时，SysTick的任务就是给系统的任务调度提供时钟节拍。根据这个节拍，系统的整个时间段被分成很多很多很小的时间片，而这个时间片则是RTOS实现多任务切换的最小时间单位，每个任务每次只能运行一个时间片的时长就得退出给别的任务运行，这样就可以确保任何一个任务都不会霸占整个系统。如果其中某个任务挂掉了，挂掉的任务并不一定会牵连到整个系统，系统依然可以运行，其它任务依然可以正常调度。
只要是Cortex-M内核都有SysTick，由于和MCU外设无关，这样就方便了程序在不同厂家的Coetex-M内核的MCU之间的移植，例如将RTOS移植到别的硬件平台上，由于SysTick的存在，这样就大大降低了移植的难度。
# l- d# U1 h/ e9 m3 H3. SysTick的时钟
5 W; e* v) q& }$ M: m6 B. F9 R) g& s. ASysTick是MCU内核的一个设备，其时钟来自MCU系统时钟，然后经过分频后得到其工作的时钟，分频值可以是1或者8，所以SysTick的时钟频率最大值为209MHz，可以说其时钟精度还是比较高的，我们从时钟树中就可以看出来：

0 Q, _& Q' P7 q+ H
* |- w* c) e: e+ d% O- }: B
图23.1.1. 2 SysTick的时钟频率最大为209MHz
4. SysTick和其它定时器的差别
9 ]/ L0 d; ?0 e( JSysTick属于Cortex-M内核外设，定时器和RTC属于片上外设。
3 }: i0 k+ [) u  G% K# x# dSysTick一般由ARM设计，每个Cortex-M内核里的SysTick都一样，而定时器和RTC属于片上外设，每个芯片厂家设计的芯片可能不一样，所以定时器以及RTC的资源也会不一样。
% v# w  d+ Y; L' H$ S0 s* P; {SysTick的存在主要是用于操作系统中的，如果应用中不使用操作系统，那么SysTick就当做简单的递减定时器来用；RTC可以分配给MPU使用，不能给MCU使用；定时器既可以给MPU使用，也可以给MCU使用，不过在同一个时刻只能单选。
SysTick的时钟源来自Cortex-M内核时钟，RTC时钟源可以是HSE、LSE和LSI，定时器时钟源来自APB1和APB2。默认情况下，STM32CubeMX使用Systick作为时基给其它程序提供计时，例如HAL_Delay延时函数，以及串口程序中的Timeout 超时机制等等，当然也可以选择其它定时器作为时基：
' z" \/ v- G9 L8 ^# g8 X5 h0 x
2 {8 H+ {' A3 E9 @

  P5 h- B1 @  K, j图23.1.1. 3 Systick作为时基
23.1.2 SysTick 寄存器
. b' X8 p4 h: b固件包的STM32Cube_FW_MP1_V1.2.0\Drivers\CMSIS\Core\Include文件夹下是符合CMSIS标准的内核头文件和CMSIS编译器相关的文件，core开头的是和 Cortex-M 内核相关的文件， MPU开头的是和MPU相关的文件。其中Cortex-M4内核使用core_cm4.h头文件，该文件中有很多关于NVIC中断相关的函数定义和类型定义以及内核的外设相关定义，SysTick相关的寄存器就定义在该文件中：
7 \, Y8 e- L2 a; l1 a5 T1 o- l
# Q4 ~: g# d/ g
6 k+ R, p0 A+ H; \$ e
) o6 m4 d9 g; l# _表23.1.2. 1 SysTick寄存器列表
下面我们来介绍以上4个寄存器：
8 D( m; e9 S6 p4 w* H- h4 n# ^1 B1.STK_CTRL（SysTick 控制及状态寄存器）
+ r: Z* C  u# I2 g3 R4 Q1 ~STK_CTRL各位如下：


. m: u* Z& X2 p5 V2 M3 N) g
图23.1.2. 1 STK_CTRL寄存器
' W' K: W/ n7 g% oENABLE
/ W& {6 I. p6 h7 @8 R; HENABLE是计数器使能位，用于启用计数器（也就是启用SysTick定时器）。改为置1则使能计数器，清0则关闭计数器。
当ENABLE设置为1时，SysTick定时器被使能，计数器从LOAD寄存器加载RELOAD值，然后递减计数，当递减到0时，COUNTFLAG位变为1，并根据TICKINT的值选择置位SysTick， 然后它将再次加载RELOAD值，并开始计数。
! @4 j. R5 Q7 O5 K! M% o- `TICKINT
$ E  Y% }* [1 {% M5 z! TTICKINT是SysTick异常请求使能位，该位为0时，当计数器递减到0的时候，SysTick不产生异常请求；该位为1时，当计数器递减到0时产生异常请求。
注：软件可以使用COUNTFLAG来确定SysTick是否曾经计数为零。
* e" P1 h3 [1 z  {3 P- q" O2 ~CLKSOURCE
CLKSOURCE用于配置SysTick的时钟源选择，我们前面说了，SysTick的时钟来自MCU系统时钟，分频值可以是1或者8，当该位为0时为1分频，为1时为8分频。
; X0 b" ^! u( ?' C7 X3 k7 JCOUNTFLAG
) i* r; B% b# q  Y2 o, aCOUNTFLAG是标志计数器是否已经为0，当计数器递减为0时，该位为1。如果读取寄存器或者清除计数器当前值时，该位会被清0.
0 B9 O+ j3 \8 c$ X3 O! N% u2. STK_LOAD（SysTick 重装载数值寄存器）
STK_LOAD的各位如下图所示：
: r: r) H) k0 g; @4 M% J3 D" ]

9 G; u! [. i, H1 H6 W
1 [+ Q$ ?! S% I5 d图23.1.2. 2 STK_LOAD寄存器
RELOAD[23:0]位是计数器为0时的重装载值，值可以是0x00000001-0x00FFFFFF范围内的任何值。
& T% ?! V7 H; X3. STK_VAL（SysTick当前值寄存器）
- t: f% g1 A9 F# P& U1 B


) Q- i: ?; c6 g; P" u! i  v6 l图23.1.2. 3 STK_VAL寄存器
2 g' Y$ Z0 v$ e  ZCURRENT[23:0]位是当前计数器的值，读取此位即可获得当前计数器的当前值。写入该位任何值均会清空此位为0，同时STK_CTRL寄存器中的COUNTFLAG位也会被清0。
5 ~* {9 q$ J( v: L' _) z3 L0 Q4. STK_CALIB（SysTick校准寄存器）
8 `( L6 R5 e" m8 x
  t- u; j$ F* N2 S, w0 ]1 U

图23.1.2. 4 STK_CALIB寄存器
$ e- z3 A! c% x, s7 D; C, ITENMS[23:0]
TENMS[23:0]位是10ms校准值，该值应由芯片设计者提供，若读取该值为0，表示校准值不可用。
4 s* W) Z# A5 W# F; MSKEW
1 i# h  \; r3 [SKEW位用于指示校准值（TENMS值）是否精确，读取此位：
为0，表示校准值正确；
为1，表示校准值不精确，或者校准值未知，这可能会影响SysTick作为软件实时时钟的适用性。
NOREF
7 t/ g3 G+ X9 s3 K) P2 X* v% c9 E- ?NOREF用于指示是否有参考时钟提供给处理器。读取此位：
为0，表示有外部参考时钟可供使用；
为1，表示没有外部参考时钟。
23.1.3 SysTick的HAL库驱动
SysTick的HAL库驱动我们在第七章7.4.2小节 滴答定时器相关函数 部分就已经详细分析过了，大家可以参考前面章节的分析，这里就列举出一些HAL库的API函数。

1.HAL_InitTick函数
+ N7 k5 t) Z* m! F/ B; E% WHAL_InitTick用于配置SysTick的重装载数值寄存器的值，其通过层层调用HAL_SYSTICK_Config函数和SysTick_Config函数完成SysTick的配置，此函数声明如下：
__weak HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority)
4 y, A- R4 M0 t% H# Y' i6 g/ B函数描述：
% X1 d, F/ E1 G9 s+ b7 u& X+ i- B7 o用于初始化SysTick，配置SysTick的重装载数值寄存器的值。
函数形参：
形参TickPriority是SysTick的中断优先级。
函数返回值：
无。
1 s) S1 W2 r: S3 K6 i注意事项：
3 p' X8 N. ]9 P9 m. N1、此函数是弱（weak）定义函数，如果用户在别的地方重新定义了同名函数，该函数将被覆盖，编译器会编译用户定义的那个函数；
2、系统复位后，HAL_Init最先被执行时，或者程序由HAL_RCC_ClockConfig重新配置时钟的时候，该函数都会被调用来初始化SysTick；
3、默认情况下，SysTick是计时的时基，SysTick通过周期性的中断来计时的，如果在别的中断中调用HAL_Delay就要小心了，SysTick中断的优先级必须调用它的中断具有更高的优先级（中断优先级数字上更低），否则程序会卡死。
2.HAL_GetTickPrio
4 |6 l3 J: O& c8 b; \# aHAL_GetTickPrio用于获取SysTick的中断优先级，返回值uwTickPrio是SysTick的中断优先级，函数声明如下：
uint32_t HAL_GetTickPrio(void)
3. HAL_SetTickFreq和HAL_GetTickFreq函数
        HAL_SetTickFreq 函数用于重新配置SysTick的中断频率，HAL_GetTickFreq函数用于获取SysTick的中断频率。函数声明如下：
HAL_StatusTypeDef HAL_SetTickFreq(HAL_TickFreqTypeDef Freq)
HAL_TickFreqTypeDef HAL_GetTickFreq(void)

8 W1 A7 D3 b" a" {23.2 HAL_Delay函数
" M- C( d4 T! W4 _23.2.1 SysTick的分频值为1
1.未执行SystemClock_Config函数之前
在前面我们有简单分析过HAL_Delay怎么实现的毫秒延时的，这里我们再次分析实现的过程。
1 n1 v# f* i4 B! \; d5 _2 m（1）HAL_Init函数
程序进入main.c文件以后，最先执行的是HAL_Init函数，该函数用于初始化HAL库，并配置SysTick每隔1ms生成一次中断。注意的是，此时还没有配置系统时钟（未执行SystemClock_Config函数），系统还是默认使用内部高速时钟HSI，HAL库里SysTick默认采用1分频，所以SysTick时钟频率也为64MHz。

1. stm32mp1xx_hal.c文件代码
   ) b; J- g: i$ w4 w% n& @
2. /**
   
3. * @brief     初始化HAL库，设置中断优先级分组为4，设置SysTick每隔1ms产生一次中断
   
4. * @note     1、此函数是在主程序中在调用任何其他HAL库的IPA函数前执行的第一个指令，
   
5. *               在这个阶段，还未配置用户指定的时钟，系统还默认使用内部HSI的64MHz运行。
   
6. *            2、调用HAL_NVIC_SetPriorityGrouping完成中断优先级分组，调用
   ! H5 f, u$ p: s, Y6 P
7. *              HAL_InitTick完成SysTick的初始化
   
8. *            3、同时，调用用户文件中（STM32CubeMX中生成的stm32mp1xx_hal_msp.c文件）的
   , U; _% a8 s) p) }
9. *            回调函数HAL_MspInit进行全局底层硬件初始化  。
   ) z; `3 V0 o' y$ z5 F
10. * @param     无
    5 t6 D) d* p6 H+ p$ K1 |
11. * @retval    无
    7 E. M: s( |/ G8 q4 D
12. */
    
13. HAL_StatusTypeDef HAL_Init(void)
    ( j& t3 q7 x. h) {& M- v
14. {
    
15.     /* 设置中断优先级分组为4 */
    
16.     #if defined (CORE_CM4)
    
17.     HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
    
18.     #endif
    
19.     /* 更新SystemCoreClock全局变量 */
    
20.     SystemCoreClock = HAL_RCC_GetSystemCoreClockFreq();
    & [7 S  S+ Q0 `7 M; L# C4 S" W
21.     /* 使用滴答定时器作为时钟基准，配置1ms滴答（重置后默认的时钟源为HSI）*/
    ( g4 ~  i9 R( i# Z) K. r
22.     if(HAL_InitTick(TICK_INT_PRIORITY) != HAL_OK)
      I' i+ a+ @' W" \) \% O& ?! B
23.     {
    ' Z3 T+ P9 }: j
24.         return HAL_ERROR;
    
25.     }
    
26.     HAL_MspInit();
    
27.     return HAL_OK;
    
28. }

复制代码

: {# q8 c4 ]; I5 R# Y- ~（2）HAL_InitTick函数
1 P% n) Y0 M; O* E; y% U. ]HAL_Init函数调用了HAL_InitTick函数完成SysTick的初始化，我们来看看此函数：

1. stm32mp1xx_hal.c文件代码
   : `7 e% t# K9 {
2. /**
   ) ?- ~# l+ O6 f) m5 A5 P) l: K
3. * @brief     初始化SysTick
   
4. * @param     TickPriority :SysTick的中断优先级
   2 K; J2 H' z) b5 D" ]  |6 |
5. * @note    1、该函数是弱定义函数，用户可以在别的地方重新定义一个同名函数，
   
6. *            编译以后，编译器只编译用户定义的函数。
   
7. *           2、该函数主要是初始化SysTick的中断优先级、配置SysTick的时钟频率为1kHz，
   
8. *            则周期为1/1000Hz=1ms
   ; f( V5 E  Y' O' X+ O2 I9 t
9. *            
   ( t3 o" }8 U" k) t
10. * @retval    无
    + [. `. @' N; K% L/ |
11. */
    , R7 D7 z! ?! z7 g. M! s9 p
12. __weak HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority)
    ! p4 C) A! M* a' C' `) K$ N
13. {
    
14.    /* 配置SysTick在1ms的时间产生一次中断 */
    ' v& \6 u" U1 I) U  B  ?
15. #if defined (CORE_CA7)
    
16. /****** 此处省略A7部分的代码 ******/
    
17. #endif /* CORE_CA7 */
    " n$ a2 @" g4 W. u9 I1 ?" f
18. 
    
19. #if defined (CORE_CM4)
    6 i" M/ o) ^" ?  E# L/ `# B
20. /* uwTickFreq是个枚举类型，如果检测到uwTickFreq为零，则返回1（HAL_ERROR） */
    7 c# o( B. M# e/ b6 @9 R. r! s& X
21.   if ((uint32_t)uwTickFreq == 0U)
    
22.   {
    + P! d# |( I+ ^  @
23.     return HAL_ERROR;
    7 i, @* R* W% w
24.   }
    
25.   /* 将SysTick配置为在1ms的时间产生一次中断 ，uwTickFreq的值默认为1*/
    
26.   if (HAL_SYSTICK_Config(SystemCoreClock /(1000U / uwTickFreq)) > 0U)
    
27.   {
    & E8 j4 w; ]% N  I% r
28.     return HAL_ERROR;
    
29.   }
    $ s$ R& Y) j# X0 Z6 A7 T$ ]
30.   /* 配置 SysTick的中断优先级 */
    
31.   if (TickPriority < (1UL << __NVIC_PRIO_BITS))
    / G5 f5 i( Q% x
32.   {
    
33.     HAL_NVIC_SetPriority(SysTick_IRQn, TickPriority, 0U);
    " F0 ?, d2 X3 P7 a5 y
34.     uwTickPrio = TickPriority;
    3 |+ w% e4 Y* X% h. i  ?! P
35.   }
    
36.   else
    ; c# z. @  q, j! C: P$ F
37.   {
    ' m. `7 O9 J* o
38.     return HAL_ERROR;
    0 O+ O% y  ~# C: t
39.   }
    / r3 h. D. @  @: a5 Y6 M, [
40. #endif /* CORE_CM4 */
    7 @$ Q/ l! y2 u0 y: ~& ^
41.   return HAL_OK;
    
42. }
    
43. （3）HAL_SYSTICK_Config函数        
    " R3 @7 B2 f% {" D1 c1 p
44.         从以上代码看到，通过HAL_SYSTICK_Config函数配置SysTick，我们再看看此函数的内容是什么：
    ( w* a. E5 ]  A9 t$ Z1 E, ~  K
45. stm32mp1xx_hal_cortex.c文件代码
    : q& q9 I  M, ?  n
46. /**
    
47. * @brief     初始化SysTick及其中断，并启动SysTick。
    
48. * @param     无
    & v6 u7 X0 k7 L
49. * @retval    无
    
50. */
    0 L0 X8 u: [# v# ~8 B0 S
51. uint32_t HAL_SYSTICK_Config(uint32_t TicksNumb)
    
52. {
    
53.    return SysTick_Config(TicksNumb);
    
54. }
    # Z3 e8 {- l8 ~/ X' n
55. （4）SysTick_Config函数        
    , M" `, U& i  v( ]  X  @
56.         再看看SysTick_Config文件，该函数在core_cm4.h文件中：
    % ^$ \5 N4 i& G0 i3 e! f% O
57. core_cm4.h文件代码
    3 q' m3 |5 ]) \+ A7 @0 U2 D
58. /**
    
59. * @brief     配置SysTick重载值，并启动SysTick。
    
60. * @param     无
    " U, W" R4 ^4 n
61. * @retval    无
    
62. */
    
63. __STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
    
64. {
    : p; ?5 b- F. T/ B: d
65.     /* 判断参数ticks是否符合要求，不能大于2^24-1 */
    
66.   if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
    $ R) h! H  r/ E
67.   {
    
68.     return (1UL); /* 无法重新加载值*/
    
69.   }
    
70.   SysTick->LOAD  = (uint32_t)(ticks - 1UL); /* 设置重载寄存器 */
    
71.   /* 设置Systick中断的优先级 */
    
72.   NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL);
    
73.   SysTick->VAL   = 0UL;                                           /* 清空SysTick当前值 */
    0 |1 [" l8 b& W* M* ]
74.   /* 配置SysTick分频值、启用S​​ysTick异常请求、启动SysTick*/   
    
75.   SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
    
76.                    SysTick_CTRL_TICKINT_Msk   |            
    
77.                    SysTick_CTRL_ENABLE_Msk;   
    7 F: u2 a3 C! W/ D  S3 M
78.   return (0UL);                                                     
    
79. }

复制代码

/ r5 r; m' y5 C' Z2 K1 B经过分析，最后HAL_SYSTICK_Config(SystemCoreClock /(1000U / uwTickFreq))里的参数传递给了LOAD，SysTick就是以此值逐渐递减1来达到计时的。这里，uwTickFreq为1，则参数为SystemCoreClock/1000。
经过前面的分析，在系统复位后，进入主函数前先执行的是HAL_Init函数，而此时系统时钟默认为64MHz，即SystemCoreClock为64MHz。而S​​ysTick的分频值是1，所以S​​ysTick的工作频率为64MHz，那么就可以计算出S​​ysTick多少时间产生一次中断了：S​​ysTick的一个节拍用的时间 * 总的节拍数。一个节拍用时，总的节拍数是，所以计算得S​​ysTick的中断周期：*。
0 z* Y1 w  L2 v3 w; e7 V7 f9 H, P也就是说，系统复位后或者如果时钟树中采用默认的配置，即系统时钟和S​​ysTick的时钟为64MHz，S​​ysTick的分频值为1，S​​ysTick会以每1ms产生一次中断。
（5）SysTick_Handler函数
下面我们看看S​​ysTick的中断服务函数。在前面的实验中，在STM32CubeMX配置好以后，都会在stm32mp1xx_it.c文件中生成一个SysTick的中断服务函数：

1. /**
   
2. * @brief     SysTick的中断服务函数
   ; ]! r# J7 y: u; X/ A* k8 l
3. * @note      此中断服务函数的名字要和中断向量表中的对应，如果自己
   
4. *             手动编写中断服务函数的话，该函数的名字不能写错，否则
   7 H& C6 R5 D* h3 T; x) e& K
5. *             发生中断后，找不到中断服务函数，就会默认执行Default_Handler
   1 \3 c( E4 M9 ~9 Q; k) j7 F4 i
6. *             函数，Default_Handler函数是一个死循环。
   
7. * @retval    无
   
8. */
   
9. void SysTick_Handler(void)
   ! A& {* h4 B4 G# t4 p
10. {
    : M5 p1 `- U1 k! F9 u
11.   HAL_IncTick();                        /* uwTick加1 */
    / b. y3 y8 w: J7 e) A8 j2 Y( k+ G
12. }

复制代码

（6）HAL_IncTick函数
此中断服务函数调用HAL_IncTick函数，该函数的作用就是使全局变量uwTick每次进入中断后加1，经过前面的分析，系统复位后在未配置系统时钟之前，或者说时钟树采用默认配置时，S​​ysTick每1ms进入中断，也就是每1ms变量 uwTick就自加1：

$ ~0 _5 q4 _( U* M) e# G! Z% j

1. /**
   
2. * @brief     使全局变量uwTick加1
   ' I, z# C: V. t
3. * @note      该函数是弱定义函数，用户可以在别的地方重新定义
   
4. *            一个同名函数，编译以后，编译器只编译用户定义的
   
5. *            函数。
   ; R# x; K4 S5 D* K! j& d
6. * @retval    无
   # v9 O6 H1 {$ K0 {* E* l8 I1 u7 v
7. */
   
8. __weak void HAL_IncTick(void)
   
9. {
   : ]( C8 C$ @5 d0 _  ~
10.   uwTick += (uint32_t)uwTickFreq;                 /* uwTickFreq为1 */
    3 R* W7 g) F" S$ M$ W6 {
11. }

复制代码

（7）HAL_Delay函数
当调用HAL_Delay时，HAL_Delay怎么实现的毫秒延时的呢，我们查看HAL_Delay的代码：
9 z) p) ]. a1 l" n
! N5 o' |. M  ?& c% n: f

1. 1   /**
   
2. 2    * @brief     此函数基于递增的变量提供准确的延迟（以毫秒为单位）
   9 P. [, o$ `( M3 g+ J0 p% y* K
3. 3    * @param     Delay：用户设置的延时时间
   
4. 4    * @note      SysTick是时基的来源
   0 u9 [( B) h' B! J8 @1 B& g
5. 5    * @retval    无
   ! f9 W/ K2 ~0 T8 Q1 W' C) D  H- e
6. 6    */  
   
7. 7   __weak void HAL_Delay(uint32_t Delay)
   
8. 8   {
   $ k+ o5 }$ k0 O2 u  \2 l# C
9. 9     uint32_t tickstart = HAL_GetTick();                /* 获取uwTick的值 */
   
10. 10    uint32_t wait = Delay;/* 将设置的延时时间参数赋值给wait变量 */
    
11. 11   /* uwTickFreq的值为1，wait自加1，wait最大为2^24-1*/
    
12. 12    if (wait < HAL_MAX_DELAY)
    2 B. P3 }& P# s, M6 k1 M, `
13. 13    {
    
14. 14      wait += (uint32_t)(uwTickFreq);                 /* uwTickFreq默认为0x01 */
    : `9 @% r2 O+ `5 u& x1 q) Z
15. 15    }
    
16. 16    while ((HAL_GetTick() - tickstart) < wait)
    
17. 17    {
    
18. 18    }
    6 M% ]7 s6 e+ C- A& D
19. 19  }
    

复制代码

第9行，进入HAL_Delay函数以后，先获取当前uwTick的值，并记录在tickstart中，我们称tickstart的值就是原始uwTick的值；
第10行，将用户设置的延时毫秒数Delay赋值给变量wait；
第12~15行，如果没有改动过uwTickFreq 的值，默认uwTickFreq的值为1，这里wait加1后等于(Delay+1)。这里加1为了用于第16~18行的计算。注意，因为S​​ysTick是24位的，所以wait的最大值只能是2^24-1。
第16~18行，通过HAL_GetTick函数获取当前最新的uwTick值，并与之前获取的uwTick值取差运算，当两者差值小于wait时，则一直执行空循环，当差值等于或者大于wait值时，则退出空循环。
假设Delay为10，wait加1后为11，tickstart为15，如果HAL_GetTick()-15<11，那么HAL_GetTick()应该为25，当HAL_GetTick()为26以后就退出空循环了，此时经过了S​​ysTick的10个中断周期，即为10ms。
2. 执行SystemClock_Config函数之后
在没有执行SystemClock_Config函数之前，S​​ysTick的工作频率是64MHz，分频值默认为1，S​​ysTick以1ms产生一次中断。如果我们手动配置了时钟树，例如配置系统时钟为209MHz，S​​ysTick还是1分频，那么S​​ysTick还是1ms的中断周期吗？我们通过代码来分析：
在system_stm32mp1xx.c文件中有SystemCoreClockUpdate函数，SystemCoreClockUpdate函数的作用就是根据时钟寄存器的值来更新SystemCoreClock变量，用户应用程序可以使用它来设置SysTick定时器或配置其他参数。在程序执行期间，每次内核时钟改变时，都会调用SystemCoreClockUpdate函数来更新SystemCoreClock变量的值，这么做也就是为了保证SystemCoreClock的准确性。

9 H& i$ ^+ o/ t, k; p7 B6 R; W

1. 1   uint32_t SystemCoreClock = HSI_VALUE;
   
2. 2
   1 a/ _3 U, {  B
3. 3   void SystemCoreClockUpdate (void)
   
4. 4   {
   # N3 l! h1 U3 T, u
5. 5     uint32_t   pllsource, pll3m, pll3fracen;
   + H9 v- m5 Q4 m: ^7 |
6. 6     float fracn1, pll3vco;
   
7. 7
   
8. 8     switch (RCC->MSSCKSELR & RCC_MSSCKSELR_MCUSSRC)
   
9. 9     {
   5 s2 ^, T  E, o" Y
10. 10    case 0x00:  /* HSI used as system clock source */
    ' T( t$ Z6 k/ ~9 T2 X  T/ d) P
11. 11    SystemCoreClock = (HSI_VALUE >> (RCC->HSICFGR & RCC_HSICFGR_HSIDIV));
    
12. 12      break;
    
13. 13
    " K5 z2 ^( [5 `
14. 14    case 0x01:  /* HSE used as system clock source */
    & }" V' _: n- A1 Q" U
15. 15      SystemCoreClock = HSE_VALUE;
    . a8 m, S: H3 I; r& p$ X
16. 16      break;
    
17. 17
    
18. 18    case 0x02:  /* CSI used as system clock source */
    
19. 19      SystemCoreClock = CSI_VALUE;
    
20. 20      break;
    9 C2 e* I5 u7 y; P5 D: w9 }
21. 21
    
22. 22    case 0x03:  /* PLL3_P used as system clock source */
    7 y1 u$ q# k1 L0 H4 ]) P
23. 23     /*******省略部分代码*******/
    0 u+ o$ |( h. _' q. }
24. 24      break;
    
25. 25    }
    
26. 26
    
27. 27    /* Compute mcu_ck */
    
28. 28    SystemCoreClock = SystemCoreClock >> (RCC->MCUDIVR & RCC_MCUDIVR_MCUDIV);                                                              
    7 ]8 u! D8 b0 m# y# y; K
29. 29  }

复制代码

& R; k0 U! T7 V2 m( I所以当我们配置好系统的时钟为209MHz时，SystemCoreClock的值也是209M，当SysTick还是1分频时，SysTick的频率也为209MHz。结合前面的分析，S​​ysTick的一个节拍用的时间为，S​​ysTick的总节拍数为HAL_SYSTICK_Config(SystemCoreClock /(1000U / uwTickFreq))=，那么S​​ysTick产生中断的周期是：=1ms。
! i7 G5 D+ Z+ P" k通过这里可以验证，不管配置系统时钟（MCU的时钟）为多少，只要S​​ysTick为1分频，S​​ysTick的中断周期都是1ms，使用HAL_Delay可以实现以1ms为单位来计时。
  y* q/ Z( o; Y5 Y% D% g23.2.1 SysTick的分频值为8
当SysTick的分频值为8时，S​​ysTick的中断周期是8ms，我们以系统时钟为209MHz为例子来计算一下。SystemCoreClock的值为209MHz，SysTick分频值为8，SysTick的频率为，S​​ysTick的一个节拍用的时间为，S​​ysTick的总节拍数还是不变为，那么S​​ysTick产生中断的周期是：8ms 。
( n0 w0 p' f/ |! Q2 a2 }. b  I5 n所以，当修改了SysTick的分频值为8时，执行HAL_Delay(10)函数以后不再是延时10ms，而是80ms。

23.3 SysTick高精度延时实验
本实验配置好的实验工程已经放到了开发板光盘中，路径为：开发板光盘A-基础资料\1、程序源码\11、M4 CubeIDE裸机驱动例程\CubeIDE_project\ 16-1 SysTick。
6 w. Y, o  A+ R1 x1 S% J' {, Y经过前面的分析，使用HAL库自带的HAL_Delay延时函数可以实现的是毫秒级别的延时，如果需要更精确的延时，例如微妙级别的延时，使用HAL_Delay就不能够实现了。下面，我们使用SysTick来实现微妙级别的延时。
我们将编写delay_us函数实现微妙延时，基于delay_us的基础上编写delay_ms函数实现毫秒延时。编程的思路采用时钟摘取法，以delay_us为例，在进入函数的时候先计算需要延时一段时间所需要的等待的SysTick的计数节拍数，然后我们就一直统计SysTick的计数变化，当计数器的变化节拍数达到我们计算出的节拍数时，说明延时时间到了。比如delay_us（50）表示需要延时50us，假设系统时钟为209MHz，所以要延时50us的话则需要SysTick计数50*209，所以我们的程序就是通过判断是否达到了所需的节拍数来判断所需的延时时间是否已经达到了。
通过时钟摘取法只是抓取SysTick计数器的变化，不需要去修改SysTick的任何配置状态，所以完全不影响SysTick作为UCOS时钟节拍的功能，这就是实现delay和操作系统共用SysTick定时器的原理。下面我们开始介绍这几个函数。
$ @( ]. b. H, b23.3.1 无操作系统
本实验自行编写程序实现SysTick以us计时，然后使用LED0闪烁观察效果，实验中，我们配置系统时钟为209MHz，SysTick为1分频，所以SysTick的时钟频率也为209MHz。
. a5 `; T$ m- h
1.新建和配置工程
本节实验可以在前面使用LED的工程中直接添加代码，为了方便，这里新建了一个工程SysTick，并按照前面实验的配置步骤使用HSE作为PLL3的时钟源，同时配置MCU的时钟频率为209MHz，SysTick为1分频：
# h  x: |3 p9 n& n7 |


6 \  y1 u9 @' f7 b( H. \6 a图23.3.1. 1 SysTick时钟配置
生成工程后，因为本节实验用到LED0相关的驱动，在Src下新建BSP文件夹，然后把LED0的驱动文件拷贝过来，或者直接拷贝前面实验的BSP文件夹。在BSP文件夹下新建delay.c文件，在BSB/Include文件夹下新建delay.h文件，最后生成的工程如下：
6 g3 @$ t5 C7 a- A* x
! \2 O9 V/ D0 _/ l  j
* A6 K- S& _; e3 w+ J' C; h2 L9 Q
: ~( Q7 `, ~; l5 Q图23.3.1. 2生成工程
9 v8 ?8 x, `7 d0 [2 F8 E- A2. 添加用户驱动
' E9 C  N3 e0 |, c& f: Z, S（1）添加delay.c文件代码
% V1 V$ w  q0 Y9 B$ Ddelay.c文件内容如下：
8 Q( }( V, A% c8 M! f

1. #include ./Include/delay.h
   3 c* Y7 j. q* B; z1 U
2. 1   static uint32_t g_fac_us = 0;  /* us延时倍乘数 */
   8 _' {' x. S: @5 W
3. 2   /**
   - V2 e, g7 ?' |' A
4. 3    * @brief     初始化延迟函数
   
5. 4    * @param     sysclk: 系统时钟频率, 即MCU的频率，最大为209MHz
   
6. 5    * @retval    无
   
7. 6    */  
   
8. 7   void delay_init(uint16_t sysclk)
   4 }- d' s; M" v
9. 8   {
   & ?! i. ]9 a, h# J
10. 9       g_fac_us = sysclk;                         /* SYSTICK使用内核时钟源,同MCU同频率 */  
    
11. 10  }
    
12. 11  /**
    
13. 12   * @brief     要延时n个us
    ' }2 A. F& f: h, j" H" g' i
14. 13   * @param     nus: 要延时的us数
    # q, X+ V8 u, t! i) Q, t
15. 14   * @note      注意: nus的值,不要大于80274us(最大值即(2^24)/g_fac_us)
    
16. 15   *            g_fac_us最大为209MHz            
    ( ], \9 R! K) m; H/ X( ?/ X; H
17. 16   *            told是刚进入函数时的计数器的值（我们称为旧的节拍值）
    
18. 17   *            tnow是进入while循环后实时监测到的计数器的值（我们称为新的节拍值）
    
19. 18   *            tcnt是由旧的节拍值到新的节拍值经过了多少个节拍
    
20. 19   * @retval    无
    
21. 20   */
    
22. 21  void delay_us(uint32_t nus)
      @* X- P6 h  x1 s% y
23. 22  {
    $ Z' r2 s) q0 M" L# i3 f* F6 o
24. 23      uint32_t ticks;
    
25. 24      uint32_t told, tnow, tcnt = 0;
    
26. 25      uint32_t reload = SysTick->LOAD;          /* LOAD的值 */
    . r* u6 ?, h9 s- V5 Y
27. 26      ticks = nus * g_fac_us;                   /* 计时nus需要的节拍数 */
    ) R6 l& d/ F4 Y  ?1 Z6 I
28. 27      told = SysTick->VAL;                      /* 刚进入函数时的计数器的值 */
    ! v; c( T( A, o
29. 28      while (1)
    ; `3 ~" B# N! G7 {
30. 29      {
    ( u6 U* P1 S/ n/ |$ O  k- z
31. 30          tnow = SysTick->VAL;/* 进入while循环后实时监测到的新的节拍值 */
    ( S8 n: C1 p$ n7 w
32. 31          if (tnow != told)
    " l2 B% G* m& ^" _8 X
33. 32          {
    " T9 v6 h! u0 [+ L& T4 e
34. 33              if (tnow < told)
    3 N  R# `) y8 {4 G8 p% j
35. 34              {
    
36. 35                  tcnt += told - tnow;          /* 计算经过了多少个节拍 */
    " s, Y; q8 P/ a# e
37. 36              }
    " n' z( V. x4 z! L+ ?! n
38. 37              else
    # G, ~  K% V* s
39. 38              {
    ) R- U6 _) O* w+ e' q/ k0 H
40. 39                  tcnt += reload - tnow + told;/* 计算经过了多少个节拍 */
    1 V* T# A% i* p7 s8 h  n4 Y. k
41. 40              }
    5 G" I# H% c3 A4 _; ?
42. 41              told = tnow;                                         /* 更新told的值 */
    . M+ ?8 O/ W! B3 H, p
43. 42              if (tcnt >= ticks)
    7 B+ e" Z- M+ T( n* s
44. 43              {
    
45. 44                  break;                          /* 时间超过或者等于要延迟的时间,则退出 */
    
46. 45              }
    / {6 \; l2 A) f" e# s
47. 46          }
    2 V! J! Y1 z& s/ B: b3 S8 P6 q* G( v& u
48. 47      }
    
49. 48  }
    
50. 49  /**
    9 k* d: y- ~; v! _
51. 50   * @brief     要延时n个ms
    
52. 51   * @param     nms: 要延时的ms数 (0< nms <= 65535)
    1 Z- O9 [3 c: R  @( t( C, F/ {
53. 52   * @retval    无
    
54. 53   */
    
55. 54  void delay_ms(uint16_t nms)
    $ y, u( t& e! u7 z- f- }
56. 55  {
    7 V% _. ~9 @, Y" o3 o$ x8 g6 k- T! [
57. 56      uint32_t i;
    
58. 57      for (i = 0; i < nms; i++)
    ! [, h+ r; [( h$ n: I/ D: s. o
59. 58      {
    
60. 59          delay_us(1000);/* 1ms=1000us */
    4 n* T( u. A* z9 H' ^! b6 v
61. 60      }
    
62. 61  }   
    % Q: c0 Q6 o; T0 m' z% f$ \

复制代码

6 Y" r5 I0 K. _8 |3 v以上就是时钟摘取法，此时的delay_us，可以实现最长224/209MHz，延时，大概是80274微秒。我们分析一下以上代码：
. _! D' Y8 n, I) D第7~10行，配置g_fac_us为系统时钟的值，调用该函数时参数需要我们设置。
第21~48行代码是重点部分，这部分代码实现用户设置的微妙延时的时间，我们来分析这段代码：
: q% p" A! H5 _第23~27行，先定义几个变量，其中：ticks表示实现一定的延时时间S​​ysTick需要计数多少个节拍。told是进入该函数时此时S​​ysTick的计数器的值，我们称为旧的节拍值。tnow是进入while循环后新的节拍值。tcnt是从told值到tnow值，计数器经过了多少个节拍。
第30行，进入while循环后，先获取此时计时器的值tnow；
第31行，如果前后两次得到的计数器的值不相等，说明计数器已经计数了一段时间，可以通过计算在这段时间里计数器计数了多少个节拍来反推出这段时间多长（因为计数器的频率固定，每计数一个节拍用时也固定）。
& ^1 f) P5 G: X+ ~. X' d% k' u第33~40，分情况计算出在这段时间里计数器计数了多少个节拍，注意的是S​​ysTick是从224-1递减计数的，当从224-1递减到0时，然后返回继续从2^24-1递减开始递减。
第一种情况，当tnow<told时：tcnt=told-tnow；
9 u" C' \/ C2 I* Z* R' ~6 x第二种情况，当tnow>told时，因为计数器是向下递减计数的，所以计数器已经重新开始计数了，要不然tnow不会小于told。此时tcnt=LOAD-tnow+told。
我们以图来说明：
0 e8 v4 l7 m8 q  I8 K4 u
" E5 [5 `, D& ~( u

图23.3.1. 3 计数器计数示意图
第41行，完成一次判断后，更新told的值，然后再返回到第30行重新进行判断。
第42~45行，当tcnt的值大于或等于需要的节拍数ticks时，说明计时达到或者超过指定的时间，break出循环。
) [' a( Z  b3 \+ ^5 S1 g. ?6 I$ l第54~61行，使用delay_us函数实验毫秒延时。
; |3 O( k: U. I! q（2）delay.h文件内容
, O9 w  \4 L' l" q- |! {
1 S1 H3 ^# a7 [5 t. M' u- Q" J

1. #ifndef __DELAY_H
     I" f2 X& a1 f* {/ @# ]! L9 @
2. #define __DELAY_H
   
3. #include "stm32mp1xx.h"
   
4. #include "stm32mp1xx_hal.h"
   ( U8 p0 a& Z7 c. @+ B
5. #include "core_cm4.h"
   % r! D! X6 j+ c6 P: _4 P0 g! C
6. void delay_init(uint16_t sysclk);                 /* 初始化延迟函数 */
   ) O8 n  F) l& V" W* c! [+ w% A3 f8 w
7. void delay_ms(uint16_t nms);                      /* 延时nms */
   * T9 @" `# V1 Y+ h3 c) r$ l8 X: \
8. void delay_us(uint32_t nus);                      /* 延时nus */
   4 D' y0 X$ t9 F' q
9. 
   8 r/ H: s3 h+ w  L8 J
10. #endif
    
11. （3）修改main.c文件
    
12.         main.c文件的部分内容如下，我们在红色字体之间手动添加代码：
    % I/ N: d9 V+ C. l) A
13. 1   #include "main.h"
    
14. 2   #include "gpio.h"
    ) Y0 a' v. u$ ?8 {  M6 [  N
15. 3   /* USER CODE BEGIN Includes */
    / H% k5 {5 \( u- g
16. 4   #include "./BSP/Include/led.h"
    
17. 5   #include "./BSP/Include/delay.h"
    
18. 6   /* USER CODE END Includes */
    " ?0 O# t- \  S) |8 M$ f7 l
19. 7   void SystemClock_Config(void);
    
20. 8   int main(void)
    ' v% @9 b" a2 t, M
21. 9   {
    
22. 10  /* 初始化HAL库和SysTick，系统时钟和SysTick的频率是64MHz，SysTick分频值为1 */
    ( w1 ]' z# j5 q0 [0 s
23. 11    HAL_Init();
    9 M$ c0 s6 h  @2 @, O, R
24. 12    if(IS_ENGINEERING_BOOT_MODE())
    
25. 13    {
    8 y0 b+ _" _( w& t# O( Z
26. 14      SystemClock_Config();                        /* 配置系统时钟 */
    2 ^3 @3 E3 n+ G. x# s; e
27. 15    }
    
28. 16    MX_GPIO_Init();
    6 q' K& ~5 o. ~7 D# I
29. 17    /* USER CODE BEGIN 2 */
    
30. 18    delay_init(209);                                /* 延时初始化 */
    ( p& `& B  z0 d: ]
31. 19    /* USER CODE END 2 */
      I* ?# |! v! M  a0 ?/ _
32. 20    while (1)
    & b# x: K# Y1 t0 H0 D7 p. S
33. 21    {
    ) _/ }) J! n5 M- Y/ V7 `3 c+ m
34. 22      /* USER CODE BEGIN 3 */
    4 c0 }+ J9 i! c* f- M8 f
35. 23        LED0_TOGGLE();                                        /* LED0闪烁 */
    " D* L& [3 B5 e) V7 U. k  X$ P/ T
36. 24        delay_ms(5000);                                        /* 延时5s */
    1 T0 U( y. M7 Q& T8 i. b) P2 x
37. 25    }
    
38. 26    /* USER CODE END 3 */
    5 K* n" o) l8 [  T) r$ L
39. 27  }
    & Z0 E$ m/ a7 e  K6 i( S/ H8 Q# B

复制代码

, L+ \  G0 I5 Q8 h) b! ^4 T以上代码，第18行，设置Sysclk使用内核时钟源209MHz。
第23和24，配置LED0每隔50ms翻转一次。
. t( K5 S( x" G
23.3.2 有操作系统
这里我们将介绍的是正点原子提供的最新版本的延时函数，该版本的延时函数支持在任意操作系统（OS）下面使用，它可以和操作系统共用SysTick定时器。这里，我们以UCOSII为例，介绍如何实现操作系统和我们的delay函数共用SysTick定时器。首先，我们简单介绍下UCOSII的时钟：ucos运行需要一个系统时钟节拍（类似 “心跳”），而这个节拍是固定的（由OS_TICKS_PER_SEC宏定义设置），比如要求5ms一次（即可设置：OS_TICKS_PER_SEC=200），在STM32上面，一般是由SysTick来提供这个节拍，也就是SysTick要设置为5ms中断一次，为ucos提供时钟节拍，而且这个时钟一般是不能被打断的（否则就不准了）。

1.delay.h文件
& A: A) z' J. X2 D1 m2 x" c如果要支持操作系统，在delay.h中需要添加如下内容：
$ T. d" `- b. j( b7 a7 i7 [9 A

1. void delay_osschedlock(void);
   * W, `5 q' a. l3 A6 g
2. void delay_osschedunlock(void);
   
3. void delay_ostimedly(uint32_t ticks);
   
4. void SysTick_Handler(void);
   
5. /**
   $ S: b4 m1 V% t3 t2 }% B$ W
6. * SYS_SUPPORT_OS用于定义系统文件夹是否支持OS
   
7. * 0,不支持OS
   
8. * 1,支持OS
   % Z7 n. M2 n9 R& L# f5 N
9. */
   
10. #define SYS_SUPPORT_OS         0       /* 默认不支持OS */

复制代码

2.delay_init函数
该函数用来初始化2个重要参数：g_fac_us以及g_fac_ms，同时把SysTick的时钟源选择为外部时钟，如果需要支持操作系统（OS），只需要在delay.h里面，设置SYS_SUPPORT_OS宏的值为1即可，然后，该函数会根据delay_ostickspersec宏的设置，来配置SysTick的中断时间，并开启SysTick中断。具体代码如下：

1. /**
   
2.      * @brief     初始化延迟函数
   3 d) s6 d% D) w1 o: D
3.      * @param     sysclk: 系统时钟频率, 即MCU的频率，最大为209MHz
   
4.      * @retval    无
   
5.      */
   
6. void delay_init(uint16_t sysclk)
   
7. {
   5 F- X1 a& Y* S2 q2 h
8. #if SYS_SUPPORT_OS                       /* 如果需要支持OS */
   
9.     uint32_t reload;
   : D& c$ F' e0 K) |! H0 C  c% c
10. #endif
    
11.     /* SYSTICK使用内核时钟源,同CPU同频率 */
    
12.     g_fac_us = sysclk;                  /* 不论是否使用OS,g_fac_us都需要使用 */
    9 D2 A  v# o9 D- Q) A# _1 p7 [& f
13. #if SYS_SUPPORT_OS                      /* 如果需要支持OS. */
    
14. reload = sysclk;                    /* 每秒钟的计数次数 单位为M */
    1 m# q+ T; ?+ I# E$ C
15. /* 根据delay_ostickspersec设定溢出时间,reload为24位寄存器,最大值:16777216, 在209M下,约合0.08s左右 */
    6 a2 ?' S5 V2 ]' n/ _5 c6 H
16.     reload *= 1000000 / delay_ostickspersec;            
    / q% C% C0 H5 ~  O# C# u, G- w
17.     g_fac_ms = 1000 / delay_ostickspersec;       /* 代表OS可以延时的最少单位 */
    
18.     SysTick->CTRL |= SysTick_CTRL_TICKINT_Msk;  /* 开启SYSTICK中断 */
    . _, u, y: k0 l# L- }! n( Q8 s
19.     SysTick->LOAD = reload;       /* 每1/delay_ostickspersec秒中断一次 */
    
20.     SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;   /* 开启SYSTICK */
    
21. #endif
    
22. }

复制代码

可以看到，delay_init函数使用了条件编译，来选择不同的初始化过程，如果不使用OS的时候，只是设置一下SysTick的时钟源以及确定fac_us值。而如果使用OS的时候，则会进行一些不同的配置，这里的条件编译是根据SYS_SUPPORT_OS这个宏来确定的，该宏在delay.h里面定义。
在不使用OS的时候：g_fac_us，为us延时的基数，也就是延时1us，SysTick定时器需要走过的时钟周期数。当使用OS的时候，g_fac_us，还是us延时的基数，不过这个值不会被写到SysTick->LOAD寄存器来实现延时，而是通过时钟摘取的办法实现的（前面已经介绍了）。而g_fac_ms则代表ucos自带的延时函数所能实现的最小延时时间。
3. OS相关的宏定义和函数
当需要delay_ms和delay_us支持操作系统（OS）的时候，我们需要用到3个宏定义和4个函数，宏定义及函数代码如下：
/*
+ |' k1 w  s8 q" {* j当delay_us/delay_ms需要支持OS的时候需要三个与OS相关的宏定义和函数来支持
首先是3个宏定义:
2 z( }2 ^5 N9 R! i" V  W1 [; H

1. *      delay_osrunning:用于表示OS当前是否正在运行,以决定是否可以使用相关函数
   2 `) H2 s$ O& S, n2 [, x5 m
2. *      delay_ostickspersec:用于表示OS设定的时钟节拍,delay_init
   3 H3 ^2 L3 E7 O8 U
3. *                              将根据这个参数来初始化systick
   4 N7 K0 q; |$ C, Q1 ], @0 e
4. *      delay_osintnesting :用于表示OS中断嵌套级别,因为中断里面不可以调度,
   , k) X. R) y- s
5. *                              delay_ms使用该参数来决定如何运行
   
6. *  然后是3个函数:
   / s& Q9 v8 a6 y) L
7. *      delay_osschedlock  :用于锁定OS任务调度,禁止调度
   % \5 z- E. O) J7 u( z8 ^5 H, V
8. *      delay_osschedunlock:用于解锁OS任务调度,重新开启调度
   
9. *      delay_ostimedly     :用于OS延时,可以引起任务调度.
   
10. *
    . v- c8 U& p' Z
11. *  本例程仅作UCOSII和UCOSIII的支持,其他OS,请自行参考着移植
    
12. */
    $ R2 L5 @! m' [. i' E
13. 
    
14. /* 支持UCOSII */
    
15. #ifdef  OS_CRITICAL_METHOD  /* OS_CRITICAL_METHOD定义了,说明要支持UCOSII */
    : l0 H$ t0 x+ V1 F0 B* V! w
16. #define delay_osrunning   OSRunning  /* OS是否运行标记,0,不运行;1,在运行 */
    ! f6 i) u/ g: M2 O# @& }2 d) b
17. #define delay_ostickspersec OS_TICKS_PER_SEC /* OS时钟节拍,即每秒调度次数 */
    , V/ ^- z. T1 U' j
18. #define delay_osintnesting  OSIntNesting/* 中断嵌套级别,即中断嵌套次数 */
    $ z& A  T! {  S: t3 b  r$ N$ C
19. #endif
    
20. /* 支持UCOSIII */
    
21. /* CPU_CFG_CRITICAL_METHOD定义了,说明要支持UCOSIII */
    
22. #ifdef  CPU_CFG_CRITICAL_METHOD  
    
23. #define delay_osrunning   OSRunning  /* OS是否运行标记,0,不运行;1,在运行 */
    : p3 X8 H3 ^. O6 o
24. #define delay_ostickspersec OSCfg_TickRate_Hz /* OS时钟节拍,即每秒调度次数 */
    ! b% W3 a7 D! F! b' K1 ^7 W- \
25. #define delay_osintnesting  OSIntNestingCtr/* 中断嵌套级别,即中断嵌套次数 */
    $ u2 ?7 d/ ?- O( U: W
26. #endif
    ; ^1 F$ ?+ L: X6 p+ R% \
27. 
    
28. /**
    0 n, V# l# R! l* O
29. * @brief     us级延时时,关闭任务调度(防止打断us级延迟)
    
30. * @param     无  
    
31. * @retval    无
    ! M# Q' V# B; G- A2 g& J) [2 E
32. */  
    ; u1 L( }/ V# F6 p
33. void delay_osschedlock(void)
    
34. {
    
35. #ifdef CPU_CFG_CRITICAL_METHOD /* 使用UCOSIII */
    
36.     OS_ERR err;
    3 o; g8 R& \$ m) h1 B0 C# \
37.     OSSchedLock(&err);           /* UCOSIII的方式,禁止调度，防止打断us延时 */
    0 s) F: R; h4 I* A- S) }5 @& H
38. #else                              /* 否则UCOSII */
    3 @1 G6 s6 l' ?* a" f0 c/ P
39.     OSSchedLock();               /* UCOSII的方式,禁止调度，防止打断us延时 */
    1 ]0 h$ M/ y' }; C& p: N
40. #endif
    
41. }
    
42. 
    
43. /**
    
44. * @brief     us级延时时,恢复任务调度
    
45. * @param     无  
    
46. * @retval    无
    
47. */  
    3 f; |& J$ I9 x7 x6 B0 j7 {- D* B' A( A
48. void delay_osschedunlock(void)
    1 J+ ]4 e7 T; P9 T
49. {
    - U( ]1 a) r, a/ ?  a# \* @- c" _
50. #ifdef CPU_CFG_CRITICAL_METHOD /* 使用UCOSIII */
    / ]+ x# N& b, v8 F
51.     OS_ERR err;
    
52.     OSSchedUnlock(&err);         /* UCOSIII的方式,恢复调度 */
    - D9 z1 W4 O' K
53. #else                               /* 否则UCOSII */
    
54.     OSSchedUnlock();              /* UCOSII的方式,恢复调度 */
    
55. #endif
    
56. }
    
57. 
    ) n8 X( y; \( r( ~/ Q0 g
58. /**
    
59. * @brief     us级延时时,恢复任务调度
    6 f2 R( G- _$ q# e# I+ |2 h. v
60. * @param     ticks: 延时的节拍数  
    
61. * @retval    无
    
62. */  
    
63. void delay_ostimedly(uint32_t ticks)
    
64. {
    
65. #ifdef CPU_CFG_CRITICAL_METHOD
    9 U2 e- ^* z9 t; n- R
66.     OS_ERR err;
    
67.     OSTimeDly(ticks, OS_OPT_TIME_PERIODIC, &err);   /* UCOSIII延时采用周期模式 */
    7 ]/ Z/ o0 R2 J3 s- @* d
68. #else
    7 w  Q$ _3 T2 h$ f* v7 V
69.     OSTimeDly(ticks);                              /* UCOSII延时 */
    4 L! N$ Q4 X4 f! I
70. #endif
    9 _' C! r+ a  \1 q, T
71. }
    
72. 
    6 i" j. ~9 R( O# I
73. /**
    + m* x3 e# G1 d  G- q9 G* l. n2 c# ~
74. * @brief     systick中断服务函数,使用OS时用到
    : n0 r: I, W# N2 [
75. * @param     ticks: 延时的节拍数  
    
76. * @retval    无
    9 {& h) A8 ?2 o! `/ T; \
77. */  
    : w! O- R4 z( K9 m
78. void SysTick_Handler(void)
    
79. {
    
80.     HAL_IncTick();
    
81.     if (delay_osrunning == 1)   /* OS开始跑了,才执行正常的调度处理 */
    5 ]1 a! R: D% v0 Q1 @2 D4 {
82.     {
    % t$ E7 x0 `8 ?" v9 d3 [: l
83.         OSIntEnter();             /* 进入中断 */
    2 k8 y& C) A! d/ g" r
84.         OSTimeTick();             /* 调用ucos的时钟服务程序 */
    
85.         OSIntExit();              /* 触发任务切换软中断 */
    
86.     }
    
87. }
    
88. #endif

复制代码

* j9 z6 F0 l' W1 s% H9 ]2 Y以上代码，仅支持UCOSII和UCOSIII，不过，对于其他OS的支持，也只需要对以上代码进行简单修改即可实现。
支持OS需要用到的三个宏定义（以UCOSII为例）即：
#define delay_osrunning OSRunning /* OS是否运行标记,0,不运行;1,在运行 /
' |1 [) o: s! j; M1 |$ V  T4 T#define delay_ostickspersec OS_TICKS_PER_SEC / OS时钟节拍,即每秒调度次数 /
2 Y0 A6 s4 H- @5 K#define delay_osintnesting OSIntNesting / 中断嵌套级别,即中断嵌套次数 */
! d( X$ G# t9 t宏定义：delay_osrunning，用于标记OS是否正在运行，当OS已经开始运行时，该宏定义值为1，当OS还未运行时，该宏定义值为0。
% T( t" q* h  n) C! K# q$ W- n/ @宏定义：delay_ ostickspersec，用于表示OS的时钟节拍，即OS每秒钟任务调度次数。
* V/ _4 o2 S; ?9 s& v宏定义：delay_ osintnesting，用于表示OS中断嵌套级别，即中断嵌套次数，每进入一个中断，该值加1，每退出一个中断，该值减1。
支持OS需要用到的4个函数，即：
6 M. a8 ^. B$ v1 E- o1）函数：delay_osschedlock，用于delay_us延时，作用是禁止OS进行调度，以防打断us级延时，导致延时时间不准。
5 j1 e* h1 ~; ?3 j' }2）函数：delay_osschedunlock，同样用于delay_us延时，作用是在延时结束后恢复OS的调度，继续正常的OS任务调度。
3）函数：delay_ostimedly，则是调用OS自带的延时函数，实现延时。该函数的参数为时钟节拍数。
4）函数：SysTick_Handler，则是systick的中断服务函数，该函数为OS提供时钟节拍，同时可以引起任务调度。
以上就是delay_ms和delay_us支持操作系统时，需要实现的3个宏定义和4个函数。下面 我们来看看支持操作系统时delay_us函数编写：。
4. delay_us函数
使用OS的时候，delay_us函数和前面我们不使用操作系统的类似，不同的是多加了delay_osschedlock和delay_osschedunlock是OS提供的两个函数，用于调度上锁和解锁，这里为了防止OS在delay_us的时候打断延时，可能导致的延时不准，所以我们利用这两个函数来实现免打断，从而保证延时精度！

1 H1 f) f9 i$ ^/ @- a+ s

1. /**
     A; J( @3 P$ t" j4 K3 E8 A7 Q* P* I
2. * @brief     延时nus
   ) X- H1 P" E( v1 f3 Y. |
3. * @param     nus: 要延时的us数
   
4. * @note      nus取值范围: 0~ 80274us (最大值即2^24 / g_fac_us @g_fac_us = 209)
   - i) d) g  E. k* V8 P
5. * @retval    无
   
6. */
   3 E, ?3 f' f0 w1 G! y. C  q/ I
7. void delay_us(uint32_t nus)
   
8. {
   8 T+ Z$ S4 e! C1 o
9.     uint32_t ticks;
   0 `5 F9 a. T$ W2 G# }: E. L2 l% l
10.     uint32_t told, tnow, tcnt = 0;
    - q" m7 E5 L$ I9 G
11.     uint32_t reload = SysTick->LOAD;  /* LOAD的值 */
    , b3 l3 R2 b( h& p
12.     ticks = nus * g_fac_us;             /* 需要的节拍数 */
    
13.     delay_osschedlock();                /* 阻止OS调度，防止打断us延时 */
    ; D3 [6 g0 I+ q: v0 X& r7 d2 i: ~
14.     told = SysTick->VAL;                /* 刚进入时的计数器值 */
    # t! ?6 V( i4 a
15.     while (1)
    $ I$ Q: `& F: A* m8 f  G
16.     {
    
17.         tnow = SysTick->VAL;
    
18.         if (tnow != told)
    8 D8 F: o4 ]7 Z: _; T* W
19.         {
    , i$ ~0 _2 C! \9 i5 D
20.             if (tnow < told)
    
21.             {
    ) G2 V/ v. p- `- N% y8 h& d
22.                 tcnt += told - tnow; /* 这里注意一下SYSTICK是一个递减的计数器就可以了 */
    6 k, Q9 j" i: W! i5 G
23.             }
    
24.             else
    
25.             {
    
26.                 tcnt += reload - tnow + told;
    + ^3 @: ^  J: c
27.             }
    * k6 n" Z' {" {) l
28.             told = tnow;
    + f! Z" R( F- A6 C
29.             if (tcnt >= ticks)
    ( m6 B. s5 Y4 D& V
30.             {
    
31.                 break;             /* 时间超过/等于要延迟的时间,则退出 */
    
32.             }
    
33.         }
    * G8 |; W# x7 x, I0 z
34.     }
    % t. K8 J9 ]/ @: h" n4 {$ E/ r
35.     delay_osschedunlock();      /* 恢复OS调度 */
    ) f6 N" O' j  ^# k3 h: p9 J7 P
36. }
    1 @) R+ S* X2 Q5 V  P) G; Y

复制代码

不同的是多加了delay_osschedlock和delay_osschedunlock是OS提供的两个函数，用于调度上锁和解锁，这里为了防止OS在delay_us的时候打断延时，可能导致的延时不准，所以我们利用这两个函数来实现免打断，从而保证延时精度
5. delay_ms函数
使用OS的时候，delay_ms的实现函数如下：
/ R' _% J+ r& d
- f5 c& H% d% O9 O6 \' E+ ]

1. /**
   
2. * @brief     延时nms
   
3. * @param   nms: 要延时的ms数 (0< nms <= 65535)
   
4. * @retval    无
     c8 }0 g" K2 a# S8 @
5. */
   
6. void delay_ms(uint16_t nms)
   , [- d% X4 G: x- x3 D
7. {
   
8. /* 如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度) */
   0 y: }2 U0 b) `! a) K, Q
9.     if (delay_osrunning && delay_osintnesting == 0)
   
10.     {
    
11.         if (nms >= g_fac_ms)  /* 延时的时间大于OS的最少时间周期 */
    
12.         {
    5 {1 B9 `6 m7 D% n  t  v
13.             delay_ostimedly(nms / g_fac_ms);/* OS延时 */
    
14.         }
    
15.         nms %= g_fac_ms;      /* OS已经无法提供这么小的延时了,采用普通方式延时 */
    
16.     }                                       
    
17.     delay_us((uint32_t)(nms * 1000));      /* 普通方式延时 */
    
18. }

复制代码

+ M8 C1 R: M+ l  J" _+ a& Z该函数中，delay_osrunning是OS正在运行的标志，delay_osintnesting则是OS中断嵌套次数，必须delay_osrunning为真，且delay_osintnesting为0的时候，才可以调用OS自带的延时函数进行延时（可以进行任务调度），delay_ostimedly函数就是利用OS自带的延时函数，实现任务级延时的，其参数代表延时的时钟节拍数（假设delay_ostickspersec=200，那么delay_ostimedly (1)，就代表延时5ms）。
5 W! G5 M7 B# [0 \当OS还未运行的时候，我们的delay_ms就是直接由delay_us实现的，不过由于delay_us的时候，任务调度被上锁了，所以还是建议不要用delay_us来延时很长的时间，否则影响整个系统的性能。当OS运行的时候，我们的delay_ms函数将先判断延时时长是否大于等于1个OS时钟节拍（fac_ms），当大于这个值的时候，我们就通过调用OS的延时函数来实现（此时任务可以调度），不足1个时钟节拍的时候，直接调用delay_us函数实现（此时任务无法调度）。
23.3.3 编译和测试
本实验我们的工程是无操作系统的，我们以无操作系统情况下的工程代码为例进行编译测试，编译后，测试PI0引脚的波形。PI0引脚在JP1排针处有引出：
" h4 O. A* Q9 C+ w) ]
3 G  M5 d1 J8 A7 Q
: C9 B& x% n+ B& {4 n: _2 x
图23.3.3. 1开发板的PI0引脚
$ |* A, K( G- Y: e所测试的波形如下，高电平脉冲为500ms，和我们实验的结果一致：

- [3 [  P" |, K' c% w

/ ?" V& y1 p" U. _图23.3.3. 2测试结果
————————————————
5 B3 [7 r8 ~; {. h: c* H) D版权声明：正点原子
4 O: h( P& \, o$ B1 w& |