当前位置：首页 > news >正文

STM32 SysTick定时器原理与裸机延时编程实战

news 2026/7/30 8:58:15

1. 项目概述：为什么SysTick是STM32的“心跳”

玩STM32的兄弟，肯定都跟定时器打过交道。从基本定时器到高级定时器，功能一个比一个花哨。但今天聊的这个“滴答定时器”（SysTick），它有点特殊。它不像TIM1、TIM2那样挂在某个总线上，功能繁多；SysTick是内核自带的，是Cortex-M系列处理器心脏的一部分。简单说，它就是给操作系统（比如FreeRTOS、uCOS）提供“心跳”的，或者在没有操作系统时，给我们提供一个精准的延时基准。

我第一次接触SysTick，是在移植FreeRTOS的时候。系统要求一个稳定的时基来调度任务，当时就纳闷，为什么非得是它？用个通用定时器不行吗？后来折腾多了才明白，SysTick的优势在于“与生俱来”和“简单直接”。它是内核级别的，不受外设总线时钟开关的影响，只要内核在跑，它就能工作，这为操作系统的稳定运行提供了最基础的保障。而且它的配置极其简单，就几个寄存器，不像通用定时器那样有一堆模式、通道要配置，对于实现一个精准的毫秒级延时函数来说，它是最轻量、最可靠的选择。

所以，这篇笔记，我们就抛开那些复杂的操作系统，聚焦在裸机环境下，如何把SysTick用起来，实现一个精准、可靠的延时函数，并理解其背后的中断机制。这对于所有STM32开发者，无论是刚入门的新手，还是想优化底层驱动的老鸟，都是一个必须掌握的基础技能。

2. SysTick定时器核心原理与寄存器精讲

2.1 SysTick的“三驾马车”：三个核心寄存器

SysTick的硬件结构非常简洁，总共就4个寄存器，我们常用的核心是三个：CTRL（控制及状态寄存器）、LOAD（重装载值寄存器）、VAL（当前值寄存器）。还有一个CALIB（校准值寄存器）通常用不上，我们暂时不管。

1. SysTick控制及状态寄存器 (SysTick->CTRL)这个寄存器是大脑，负责开关和状态汇报。我们主要关注它的三个位：

位0：ENABLE。SysTick定时器的使能位。写1启动，写0停止。这个好理解。
位1：TICKINT。中断使能位。这是关键！当SysTick倒数到0时，如果此位为1，则会触发SysTick中断；如果为0，则只将COUNTFLAG标志位置1，不会进入中断。我们做延时函数，通常需要开启中断。
位2：CLKSOURCE。时钟源选择位。这是精度和灵活性的关键。
- 设置为1：选择内核时钟（AHB总线时钟，对于STM32F1就是72MHz，对于F4可能是168MHz等）。这是最常用的选择，延时最精准。
- 设置为0：选择AHB时钟8分频后的时钟（即HCLK/8）。当系统时钟频率很高时，选择这个可以降低计数频率，扩大延时范围，但精度会降低。
位16：COUNTFLAG。这是一个只读的标志位。当SysTick从1倒数到0时，硬件会自动将此位置1。我们可以通过查询这个位来判断一次计时是否完成，这是实现非阻塞式查询延时的基础。

2. SysTick重装载值寄存器 (SysTick->LOAD)这个寄存器决定了SysTick的“心跳”周期。它是一个24位的寄存器（最大值0xFFFFFF）。当我们写入一个值N后，SysTick的计数器VAL就会从N开始向下递减，减到0后，如果开启了中断就触发，同时VAL会自动重载这个N值，开始下一轮计数。这个N值怎么算？很简单：N = (时钟频率 / 分频系数) * 期望的周期。例如，我们想实现1ms的定时中断，系统时钟是72MHz，选择内核时钟源（不分频）。那么：N = 72,000,000 Hz * 0.001 s = 72,000。所以，向LOAD寄存器写入71999（因为从0开始计数，所以计数值=72000-1）。

3. SysTick当前值寄存器 (SysTick->VAL)这是一个24位的可读写寄存器。读取它，返回当前倒计数的值。向它写入任何值，都会将其清0，同时会清除COUNTFLAG标志位。这个特性非常有用，在初始化SysTick时，我们通常先写VAL清空计数器，避免一上电就马上进入中断。

注意：LOAD和VAL寄存器都是24位有效的，写入超过0xFFFFFF的值会被截断。计算重载值时务必确保结果在24位范围内，否则定时周期会出错。

2.2 时钟源选择：精度与范围的权衡

CLKSOURCE这个位的选择，直接决定了延时的精度和最大范围。

选择内核时钟（CLKSOURCE=1）：这是最推荐的方式。时钟频率高，计时精度高。例如72MHz下，每个计数周期是1/72,000,000 ≈ 13.89纳秒。实现1ms定时，重载值就是72000。此时，最大定时周期为 (2^24) / 72,000,000 ≈ 0.233秒。
选择8分频时钟（CLKSOURCE=0）：时钟频率降为9MHz（72MHz/8）。每个计数周期约111.1纳秒。实现1ms定时，重载值就是9000。此时，最大定时周期扩大到 (2^24) / 9,000,000 ≈ 1.86秒。

如何选择？如果你的延时需求在几百毫秒以内，且对精度要求高（比如驱动WS2812B灯带这种对时序要求严苛的），务必选择内核时钟。如果你的项目需要实现秒级的延时，又不想做多次中断累计，可以考虑使用8分频时钟来扩大单次定时范围，但需要接受精度上的损失。更常见的做法是，依然使用内核时钟，在中断服务函数里对一个32位的软件计数器进行累加，来实现更长的延时。

3. 裸机环境下SysTick的两种实战用法

理解了原理，我们来看怎么用。在裸机程序里，SysTick主要有两种用法：中断法和查询法。

3.1 中断法实现精准延时（`HAL_Delay`的基石）

这是最标准、最常用的方法，也是STM32 HAL库中HAL_Delay()函数的实现原理。它的核心思想是：配置SysTick每1ms中断一次，在中断服务函数里对一个全局变量（比如uwTick）进行递增。延时函数就是获取当前的uwTick值，然后循环等待，直到uwTick的增量达到我们设定的毫秒数。

步骤拆解：

初始化SysTick：

// 假设系统时钟频率 SysClkFreq = 72MHz uint32_t reload = SysClkFreq / 1000 - 1; // 计算1ms对应的重载值，72000-1=71999 SysTick->LOAD = reload; // 设置重装载值 SysTick->VAL = 0; // 清空当前计数器，清标志位 // 选择内核时钟源，开启中断，使能定时器 SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | SysTick_CTRL_TICKINT_Msk | SysTick_CTRL_ENABLE_Msk; NVIC_SetPriority(SysTick_IRQn, 0); // 设置SysTick中断优先级（通常设为最高或最低）

编写中断服务函数： SysTick的中断服务函数名是固定的SysTick_Handler（在启动文件startup_stm32fxxx.s中已声明弱定义）。

volatile uint32_t uwTick = 0; // 必须加volatile，防止编译器优化 void SysTick_Handler(void) { uwTick++; // 每1ms加1 // 这里还可以添加其他需要每毫秒执行一次的任务，但务必保持简短！ }

实现毫秒延时函数：

void delay_ms(uint32_t ms) { uint32_t tickstart = uwTick; uint32_t wait = ms; // 考虑uwTick溢出的情况（约49.7天溢出一次） if (wait < HAL_MAX_DELAY) { wait += (uint32_t)(uwTick - tickstart); while ((uwTick - tickstart) < wait) { // 空循环，等待时间到达 } } }

这个函数先记录进入时的uwTick值，然后计算目标值，并通过循环比较当前uwTick与目标值的差值来实现阻塞等待。

实操心得：中断法延时的优点是精准、不占用CPU进行无聊的递减计数。但缺点是这个delay_ms函数是“阻塞”的，调用它时，CPU就在那儿空等，什么也干不了。这在简单的顺序程序中没问题，但在需要同时响应多个事件的系统中（比如一边采集数据一边闪烁LED），这种阻塞延时就会成为瓶颈。所以，中断法更适合作为系统时基，或者在对实时性要求不高的初始化、调试阶段使用。

3.2 查询法实现单次定时与微秒延时

查询法不依赖中断，它利用CTRL寄存器中的COUNTFLAG标志位。我们启动一次倒计时，然后不断地查询这个标志位是否被置1，置1就表示一次定时完成。

实现一个微秒级延时函数（阻塞式）：由于SysTick通常被设置为1ms中断，我们不能再改动它的配置来实现微秒延时。但我们可以利用其计数器VAL的当前值，进行“单次”精准的短时间延时。

void delay_us(uint32_t us) { uint32_t start_tick = SysTick->VAL; // 获取当前计数器值 uint32_t ticks_needed = us * (SystemCoreClock / 1000000); // 计算需要的节拍数 uint32_t elapsed_ticks; // 如果需要的节拍数大于24位计数器最大值，这个函数就不适用了 if (ticks_needed > 0xFFFFFF) { return; // 或者调用毫秒延时函数 } while (1) { uint32_t current_tick = SysTick->VAL; // 注意：VAL是递减的，所以start_tick可能大于current_tick（未溢出） // 也可能小于current_tick（发生了从0到重载值的溢出） if (current_tick <= start_tick) { elapsed_ticks = start_tick - current_tick; } else { // 发生了一次溢出，需要加上从start_tick到0，再从重载值到current_tick的计数 elapsed_ticks = start_tick + ((SysTick->LOAD & 0x00FFFFFF) - current_tick) + 1; } if (elapsed_ticks >= ticks_needed) { break; } } }

实现一个非阻塞的单次定时器：查询法的另一个妙用是实现非阻塞定时。比如，你想让一个LED每500ms闪烁，但又不想用阻塞的delay_ms(500)卡住程序。

uint32_t led_last_toggle_time = 0; #define LED_TOGGLE_INTERVAL 500 // 500ms void main_loop(void) { // 检查是否到达翻转时间 if ((uwTick - led_last_toggle_time) >= LED_TOGGLE_INTERVAL) { HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin); led_last_toggle_time = uwTick; // 更新上次动作时间 } // 这里可以放心地执行其他任务，如按键扫描、串口处理等 scan_keys(); process_uart(); }

这种方法的核心是“状态机”思维和“时间戳”比较。程序主循环可以快速执行，通过检查时间差来决定是否执行某个动作，从而实现了“并行”处理多个定时任务的效果，这是裸机编程中实现多任务调度的基础。

4. 基于SysTick构建一个简易的软件定时器框架

仅仅用uwTick做时间比较还是有点原始。我们可以基于SysTick中断，构建一个更通用、更易用的软件定时器框架。这对于裸机项目来说，是一个巨大的生产力提升。

4.1 框架设计与数据结构

这个框架的目标是：允许用户创建多个定时器，每个定时器可以独立设置超时时间、运行模式（单次/循环），并指定超时后要执行的回调函数。

首先，我们定义定时器的结构体：

typedef enum { TIMER_STOPPED = 0, TIMER_RUNNING, TIMER_TIMEOUT } TimerState; typedef enum { MODE_ONE_SHOT = 0, // 单次 MODE_PERIODIC // 循环 } TimerMode; typedef struct { uint32_t timeout_ticks; // 设定的超时节拍数 uint32_t remain_ticks; // 剩余的节拍数 TimerState state; // 当前状态 TimerMode mode; // 工作模式 void (*callback)(void); // 超时回调函数指针 } SoftTimer;

然后，我们需要一个定时器列表（数组）来管理所有定时器，并在SysTick中断中更新它们。

4.2 核心调度器实现

1. 定时器列表与初始化

#define MAX_TIMERS 10 // 支持的最大定时器数量 SoftTimer timer_list[MAX_TIMERS]; void soft_timer_init(void) { for (int i = 0; i < MAX_TIMERS; i++) { timer_list[i].state = TIMER_STOPPED; timer_list[i].callback = NULL; } }

2. 改造SysTick中断服务函数中断函数不再只是增加uwTick，还要遍历所有运行中的定时器，进行“滴答”更新。

void SysTick_Handler(void) { uwTick++; // 更新所有软件定时器 for (int i = 0; i < MAX_TIMERS; i++) { if (timer_list[i].state == TIMER_RUNNING) { if (--timer_list[i].remain_ticks == 0) { timer_list[i].state = TIMER_TIMEOUT; // 注意：回调函数在中断上下文执行，必须简短！ if (timer_list[i].callback != NULL) { timer_list[i].callback(); } // 处理定时器模式 if (timer_list[i].mode == MODE_PERIODIC) { // 循环模式，重装定时值，继续运行 timer_list[i].remain_ticks = timer_list[i].timeout_ticks; timer_list[i].state = TIMER_RUNNING; } else { // 单次模式，停止定时器 timer_list[i].state = TIMER_STOPPED; } } } } }

3. 用户API函数提供创建、启动、停止、检查定时器的接口。

// 创建一个定时器，返回其ID（索引），失败返回-1 int8_t timer_create(uint32_t timeout_ms, TimerMode mode, void (*cb)(void)) { for (int i = 0; i < MAX_TIMERS; i++) { if (timer_list[i].state == TIMER_STOPPED) { timer_list[i].timeout_ticks = timeout_ms; // 假设1 tick = 1ms timer_list[i].remain_ticks = timeout_ms; timer_list[i].mode = mode; timer_list[i].callback = cb; timer_list[i].state = TIMER_STOPPED; // 创建后默认停止 return i; } } return -1; // 定时器池已满 } // 启动定时器 void timer_start(int8_t timer_id) { if (timer_id >= 0 && timer_id < MAX_TIMERS) { timer_list[timer_id].remain_ticks = timer_list[timer_id].timeout_ticks; timer_list[timer_id].state = TIMER_RUNNING; } } // 停止定时器 void timer_stop(int8_t timer_id) { if (timer_id >= 0 && timer_id < MAX_TIMERS) { timer_list[timer_id].state = TIMER_STOPPED; } } // 在主循环中检查并处理超时（另一种设计，将回调放到主循环执行，更安全） void soft_timer_poll(void) { for (int i = 0; i < MAX_TIMERS; i++) { if (timer_list[i].state == TIMER_TIMEOUT) { timer_list[i].state = TIMER_STOPPED; // 先改变状态，防止重入 if (timer_list[i].callback != NULL) { timer_list[i].callback(); // 在主循环中执行回调 } // 如果是循环定时器，需要重启 if (timer_list[i].mode == MODE_PERIODIC) { timer_list[i].remain_ticks = timer_list[i].timeout_ticks; timer_list[i].state = TIMER_RUNNING; } } } }

4.3 应用示例：多任务定时调度

有了这个框架，你的主程序会变得非常清晰：

void led1_toggle(void) { HAL_GPIO_TogglePin(LED1_GPIO_Port, LED1_Pin); } void led2_toggle(void) { HAL_GPIO_TogglePin(LED2_GPIO_Port, LED2_Pin); } void send_sensor_data(void) { /* 模拟发送数据 */ } int8_t timer_led1, timer_led2, timer_sensor; int main(void) { // 硬件初始化... SysTick_Config(SystemCoreClock / 1000); // 1ms中断 soft_timer_init(); // 创建定时器：LED1每500ms闪烁，LED2每1s闪烁，传感器每2s上报一次 timer_led1 = timer_create(500, MODE_PERIODIC, led1_toggle); timer_led2 = timer_create(1000, MODE_PERIODIC, led2_toggle); timer_sensor = timer_create(2000, MODE_PERIODIC, send_sensor_data); // 启动所有定时器 timer_start(timer_led1); timer_start(timer_led2); timer_start(timer_sensor); while (1) { soft_timer_poll(); // 在主循环中处理超时回调 // 这里可以执行其他低优先级或非实时任务 // 比如：按键防抖处理、非紧急的串口命令解析等 key_debounce_handler(); uart_command_parser(); } }

通过这种方式，你实现了类似小型操作系统的多任务定时调度。LED闪烁、数据上报这些周期性任务被定时器自动管理，主循环while(1)被解放出来处理其他逻辑，程序结构从“顺序执行+阻塞延时”进化到了“事件驱动+状态机”，这是裸机编程能力的一个分水岭。

5. 常见问题排查与深度优化技巧

5.1 中断服务函数执行时间过长

这是新手最容易踩的坑。SysTick中断默认是1ms一次，如果你的中断服务函数SysTick_Handler里执行了非常耗时的操作（比如软件延时、复杂的计算、打印大量日志），会导致中断无法及时返回。

现象：程序整体变慢，其他中断响应延迟，甚至可能因为频繁中断嵌套导致栈溢出。

排查与解决：

检查中断服务函数：确保其中只有最必要的、极其简短的操作，如递增计数器、设置标志位。绝对不要在中断里调用HAL_Delay或printf。
使用volatile变量：在中断和主程序之间共享的变量（如uwTick），必须用volatile关键字修饰，防止编译器优化导致数据不一致。
测量中断时间：可以用一个IO口在中断入口拉高、出口拉低，然后用示波器测量高电平脉冲宽度，直观看到中断执行时间。确保它远小于中断间隔（1ms）。

5.2 延时函数不准确或程序“卡死”

可能原因及解决方案：

时钟源配置错误：这是最常见的原因。你计算重载值时用的SystemCoreClock变量，是否真实反映了当前系统的核心时钟频率？务必在SystemClock_Config函数之后，确认SystemCoreClock已被正确更新。可以用SystemCoreClock变量打印出来看看。
中断优先级冲突：SysTick中断的优先级默认可能不是最高的。如果有一个更高优先级的中断长时间执行或频繁发生，就会阻塞SysTick中断，导致延时变长。可以通过NVIC_SetPriority(SysTick_IRQn, 0);将其设置为最高优先级（数值越小优先级越高）。
全局中断被意外关闭：如果在某些操作中（如临界区保护）使用了__disable_irq()关闭了全局中断，一定要确保在操作完成后用__enable_irq()及时打开。SysTick中断被屏蔽，自然就无法触发了。
uwTick溢出处理：前面延时函数代码里提到了HAL_MAX_DELAY和溢出处理。如果你的延时函数没考虑uwTick从最大值绕回0的情况，当延时时间跨度很长时（虽然概率低），就可能陷入死循环。确保你的延时函数逻辑能正确处理(uwTick - startTick)当uwTick溢出时的情况。

5.3 软件定时器框架的进阶优化

上面实现的简易框架还有很大优化空间：

使用链表而非数组：数组查询是O(n)复杂度。当定时器数量多时，每次SysTick中断遍历所有定时器开销大。可以改用双向链表管理，只遍历活跃的定时器。
减少中断内处理：在中断内直接调用用户回调函数是危险的（回调函数可能很长）。更优的设计是，在中断里只设置标志位或将要执行的回调函数指针放入一个队列，然后在主循环的soft_timer_poll函数中统一执行这些回调。这能极大减少中断占用时间，提高系统实时性。
提供更丰富API：比如timer_restart、timer_change_period、查询定时器剩余时间等。
增加调试信息：为每个定时器增加一个ID或名称字符串，在调试时更容易定位是哪个定时器出了问题。

5.4 与RTOS的SysTick冲突问题

当你最终需要移植FreeRTOS或uCOS这类RTOS时，它们也需要使用SysTick作为系统时钟节拍。这时就会和你自己写的SysTick初始化代码冲突。

解决方案：

彻底移交：在RTOS启动后（如调用osKernelStart()），SysTick就完全由RTOS管理。你之前的延时函数、软件定时器框架都应该弃用，转而使用RTOS提供的vTaskDelay、软件定时器（如FreeRTOS的xTimerCreate）等API。
使用其他定时器：如果你的裸机软件定时器框架写得很好，不想放弃，又需要RTOS。可以考虑将框架的时基切换到另一个硬件定时器（如TIM2）。只需将原来在SysTick_Handler中的更新逻辑，移植到TIM2的中断服务函数中即可。这样，SysTick给RTOS，TIM2给你的应用，互不干扰。

SysTick虽小，却是连接硬件定时与软件逻辑的桥梁。从最简单的delay_ms，到构建一个事件驱动的裸机系统，再到为RTOS铺路，对它理解得越深，你对STM32乃至整个嵌入式系统的时间管理艺术就掌握得越透彻。我个人的习惯是，在每个裸机项目中，都会先基于SysTick搭建一个轻量级的软件定时器框架，这能让后续的功能开发像搭积木一样顺畅。

查看全文

http://www.jsqmd.com/news/1292754/