14.1.3 中断、临界区与实时性测量
所属:全栈开发面试题库 / 14 物联网与嵌入式软件 / 14.1 实时调度与 RTOS
本节要解决的问题
实时性出问题时,多数人第一反应是"代码写慢了",但偶发延迟的根因往往是关中断时间过长、临界区跨函数、中断风暴、Flash 擦写阻塞总线这几类。本节解决四个具体问题:一是讲清 Cortex-M 上 PRIMASK/BASEPRI/FAULTMASK 三个屏蔽寄存器的差异与 taskENTER_CRITICAL 到底关了什么;二是把中断延迟从"硬件响应 + 临界区屏蔽 + 高优先级抢占 + 取指等待"拆成可测的几段;三是给出长临界区拆解、下半部下放、中断与任务之间同步的工程范式;四是讲清如何用 DWT、GPIO、trace 长时统计 P99/P100,而不是盯着示波器看单次波形下结论。
学习目标
学完本节,你应当能够:
- 解释 PRIMASK、BASEPRI、FAULTMASK 的差异,并说清
taskENTER_CRITICAL在 Cortex-M 上用哪一个。 - 画出中断延迟的完整组成,并用 GPIO + DWT 实测出最坏值。
- 判断一段代码该不该放进临界区,并给出拆解方案。
- 设计一个能在量产设备上记录最坏延迟与现场状态的机制。
先修与前置
- 建议先读 14.1.1 实时性基础与调度算法,建立响应时间分析框架。
- 本节是 14.3.2 中断处理与下半部设计 的实时性测量前置。
知识地图
中断延迟 =
中断信号置位
+ 当前指令完成(最多 1~2 周期)
+ 硬件异常进入(Cortex-M: 12 周期, 尾链时 6 周期)
+ 当前临界区剩余屏蔽时间(关键)
+ 更高优先级 ISR 抢占时间
+ 取指/流水线恢复
Cortex-M 屏蔽寄存器
PRIMASK = 1 → 关所有可屏蔽中断(NMI/HardFault 仍可)
BASEPRI = n → 屏蔽优先级数值 >= n 的中断(保留高优先级)
FAULTMASK = 1 → 连 HardFault 也屏蔽(危险)
临界区代价
taskENTER_CRITICAL = 关调度 + 关中断(BASEPRI)
portENTER_CRITICAL 只保护内核数据结构
__disable_irq 最激进: 关所有可屏蔽中断
核心术语
- 中断延迟(Interrupt Latency):从外设置位中断到 ISR 第一条指令执行的时间。
- 关中断时间(Interrupt Mask Time):中断被屏蔽的最长连续窗口,直接叠加到所有中断延迟上。
- 临界区(Critical Section):访问共享资源期间不允许被抢占的代码段。
- 下半部(Bottom Half):ISR 里只做最小动作,耗时处理推迟到任务/工作队列。
- BASEPRI:Cortex-M 中断屏蔽寄存器,只屏蔽优先级数值大于等于设定值的中断,保留高优先级中断响应。
- DWT(Data Watchpoint and Trace):Cortex-M 内嵌的周期计数器与比较单元,用于纳秒级时间戳。
- 中断风暴(Interrupt Storm):短时间内大量中断同时到达,CPU 忙于进出 ISR,任务无法运行。
- 现场(Context):故障时刻的寄存器、栈、任务状态,用于事后分析。
覆盖范围
- Cortex-M NVIC 优先级分组与中断嵌套
- 临界区实现:PRIMASK/BASEPRI/调度挂起
- 中断延迟组成与测量方法
- 长临界区拆解与下半部设计
- 中断风暴、Flash 擦写与总线干扰
- 现场取证与长时统计
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 14.1.3-001 | Cortex-M 优先级分组怎么配?中断嵌套规则? | 基础 | ★★★★ |
| 14.1.3-002 | PRIMASK、BASEPRI、FAULTMASK 区别? | 基础 | ★★★★ |
| 14.1.3-003 | taskENTER_CRITICAL 到底关了什么?代价? | 基础 | ★★★★★ |
| 14.1.3-004 | 中断延迟怎么测量?典型组成? | 进阶 | ★★★★★ |
| 14.1.3-005 | 长临界区怎么拆?什么时候用 ticket lock? | 进阶 | ★★★★ |
| 14.1.3-006 | ISR 里的活推到哪里?任务/工作队列/软件定时器? | 进阶 | ★★★★ |
| 14.1.3-007 | 为什么 Flash 擦写会破坏实时性? | 进阶 | ★★★ |
| 14.1.3-008 | 中断风暴怎么定位与缓解? | 高级 | ★★★ |
| 14.1.3-009 | 没有示波器怎么长时统计 P99/P100? | 高级 | ★★★ |
| 14.1.3-010 | HardFault 现场怎么抓取? | 高级 | ★★★★ |
14.1.3-001 Cortex-M 优先级分组怎么配?中断嵌套规则?
一句话结论
Cortex-M 把 NVIC 优先级寄存器(如 8 位)拆成**抢占优先级(group)与子优先级(sub)**两部分:抢占优先级决定能否互相嵌套,子优先级只在同一抢占级内决定同时挂起时先响应谁;STM32 默认 NVIC_PRIORITYGROUP_4(4 位抢占 + 0 位子),意味着 16 个抢占级、无嵌套同优先级。
概念解释
- 抢占优先级(Preemption Priority):数值越小优先级越高,高抢占级可打断低抢占级 ISR。
- 子优先级(Subpriority):同一抢占级内同时挂起时的响应顺序,不能互相嵌套。
- 优先级位数:Cortex-M3/M4 常见 8 位(实现 4~8 位),Cortex-M0/M0+ 通常 2~4 位。
- 中断向量表偏移:所有中断进同一入口,由硬件自动压栈并跳转到对应 ISR。
原理流程
- 系统启动时调
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4):4 位抢占、0 位子。 - 每个中断用
NVIC_SetPriority(IRQn, priority)设置优先级数值(0~15)。 - ISR A 正在跑(优先级 5),中断 B 挂起(优先级 2):因为 2 < 5,硬件自动嵌套 B。
- ISR B 跑时,中断 C 挂起(优先级 3):3 > 2,不能打断 B,C 等 B 完成。
- 同级中断同时挂起:按向量号小者先响应(不是子优先级,因为 group 4 没子优先级位)。
代码或图示
/* STM32Cube HAL 风格 */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
/* UART RX 中断:抢占优先级 5,子优先级 0 */
HAL_NVIC_SetPriority(USART1_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(USART1_IRQn);
/* SysTick:通常配最低抢占级(15),避免影响实时中断 */
HAL_NVIC_SetPriority(SysTick_IRQn, 15, 0);
/* FreeRTOS 推荐:所有可被 RTOS API 调用的中断
优先级数值 >= configMAX_SYSCALL_INTERRUPT_PRIORITY(如 5),
这样在临界区(BASEPRI=5)时它们被屏蔽,但更高优先级中断仍能响应 */
优先级数值(越小越高):
0 NMI
1 HardFault
2 ← 最高用户中断(紧急)
3
4
5 ← configMAX_SYSCALL_INTERRUPT_PRIORITY
6
...
15 ← 最低(SysTick)
常见误区
- 误区:所有中断都能互相嵌套;正解:只有抢占优先级数值更小的才能嵌套,同级不嵌套。
- 误区:优先级数值越大越高;正解:Cortex-M 数值越小越高,与 FreeRTOS 任务优先级方向相反。
- 误区:FreeRTOS 的
configMAX_SYSCALL_INTERRUPT_PRIORITY是数值;正解:它是优先级阈值,数值大于等于它的中断不能调 FromISR API,且在临界区被屏蔽。
追问
- 为什么 RTOS 推荐设置
configMAX_SYSCALL_INTERRUPT_PRIORITY?答:RTOS 临界区用 BASEPRI 屏蔽数值大于等于它的中断,让内核数据结构不被这些中断抢占;更高优先级中断仍能响应,但不能调 RTOS API。机制上 BASEPRI 只屏蔽数值 >= n 的中断,保留高优先级实时响应。边界在于:阈值设得太低(数值大)会屏蔽太多中断,设得太高(数值小)会让内核临界区关不住高优先级中断。延伸:STM32 HAL 默认把 SysTick 设到最低(15),保证 RTOS 调度不被高优先级中断影响。 - HardFault 与 NMI 的优先级?答:NMI 优先级 -2,HardFault -1,都是固定的负数值,比所有正数中断都高,且不能被 BASEPRI 屏蔽。机制上它们是硬件异常,优先级由架构固定。边界在于:NMI 里不能调 RTOS API、不能阻塞,否则系统无法恢复。延伸:安全认证项目把 NMI 用作"不可屏蔽的安全事故处理"。
- 中断嵌套层数有上限吗?答:受栈空间限制,每次异常压栈 8 个寄存器(32 字节)+ 软件保存的剩余寄存器。机制上 MSP 是中断共用栈,嵌套越深 MSP 用得越多。边界在于:MSP 栈深要按"最坏嵌套层数 × 每层栈帧"估算,通常 1~2KB。延伸:FreeRTOS 可配置独立中断栈,把最坏嵌套与任务栈隔离开。
14.1.3-002 PRIMASK、BASEPRI、FAULTMASK 区别?
一句话结论
PRIMASK 是一位开关,置 1 后关所有可屏蔽中断(NMI/HardFault 仍可);BASEPRI 是优先级阈值寄存器,只屏蔽数值大于等于设定值的中断,保留高优先级中断响应;FAULTMASK 连 HardFault 都屏蔽(只在调试时用,量产代码不应出现)。
概念解释
- PRIMASK:1 位,置 1 后所有可屏蔽中断被屏蔽,复位为 0。
- BASEPRI:可配置优先级阈值,写 n 则屏蔽数值 >= n 的中断;写 0 表示不屏蔽。
- FAULTMASK:1 位,置 1 后连 HardFault 都屏蔽(除 NMI)。
- 用法:FreeRTOS 临界区用 BASEPRI(保留高优先级中断),裸机简短临界区用 PRIMASK。
原理流程
- 进入临界区前读当前 BASEPRI,写
configMAX_SYSCALL_INTERRUPT_PRIORITY。 - 高优先级中断(数值小于阈值)仍能响应,低优先级中断被屏蔽。
- 临界区结束恢复原 BASEPRI 值。
- 若用 PRIMASK,会把所有中断都关掉,包括最高优先级实时中断,破坏实时性。
- FAULTMASK 只在 HardFault 处理函数里临时使用,避免 HardFault 嵌套。
代码或图示
/* FreeRTOS port.c 节选(语义等价) */
void vPortEnterCritical(void) {
UBaseType_t basepri = portBASEPRI_INTERRUPT_PRIORITY;
__asm volatile (
"mov %0, %1 \n"
"msr BASEPRI, %0 \n"
: : "r" (basepri) : "memory" );
/* ... */
}
/* 裸机简短临界区:临时关所有中断 */
uint32_t primask = __get_PRIMASK();
__disable_irq();
shared_counter++;
__set_PRIMASK(primask); /* 恢复而不是无条件开 */
/* 错误:无条件开中断,会破坏 RTOS 临界区 */
__disable_irq();
shared_counter++;
__enable_irq(); /* 错!应恢复原 PRIMASK */
常见误区
- 误区:
__disable_irq()就是 RTOS 临界区;正解:它关所有中断,比 RTOS 临界区激进,且不能恢复原状态。 - 误区:BASEPRI 写 0 表示关所有中断;正解:写 0 表示不屏蔽,要关中断用 PRIMASK 或写一个非零阈值。
- 误区:临界区里可以调高优先级中断处理;正解:BASEPRI 保留的高优先级中断仍可响应,但不能调 RTOS FromISR API(因为它们的优先级小于阈值,不在临界区保护范围内)。
追问
- 为什么 FreeRTOS 用 BASEPRI 而不是 PRIMASK?答:BASEPRI 保留高优先级中断响应,让紧急中断(如安全停车、电机过流)在 RTOS 临界区里仍能立即处理。机制上 BASEPRI 是"阈值屏蔽",比"全关"精细。边界在于:高优先级中断在临界区里响应时,不能调任何 RTOS API(因为内核数据结构可能正被修改)。延伸:这也是为什么
configMAX_SYSCALL_INTERRUPT_PRIORITY是 RTOS 最重要的配置之一。 - 为什么不能无条件
__enable_irq()?答:代码可能嵌套在多层临界区里,或者在 ISR 里,无条件开会破坏外层临界区。机制上正确做法是"读原值→修改→恢复原值"。边界在于:库函数里若出现无条件__enable_irq(),会让上层临界区失效。延伸:STM32 HAL 的HAL_NVIC_EnableIRQ是按中断号操作,不影响全局屏蔽。 - FAULTMASK 什么时候用?答:HardFault 处理函数里临时置 1,防止 HardFault 嵌套导致栈耗尽。机制上 HardFault 本身优先级 -1,置 FAULTMASK 后连 HardFault 也屏蔽。边界在于:FAULTMASK 置 1 后系统几乎不可恢复,应立即复位或转储现场。延伸:量产 HardFault 处理一般用
__disable_irq()即可,FAULTMASK 只在极端场景用。
14.1.3-003 taskENTER_CRITICAL 到底关了什么?代价?
一句话结论
taskENTER_CRITICAL 在 Cortex-M 上做两件事:把 BASEPRI 设为 configMAX_SYSCALL_INTERRUPT_PRIORITY(屏蔽低优先级中断)+ 递增 uxInterruptNesting 计数器;它不关调度器、不关高优先级中断,代价是该窗口内所有低优先级中断被推迟,临界区长度直接叠加到这些中断的延迟上。
概念解释
- 临界区嵌套计数:
uxInterruptNesting递增,配对taskEXIT_CRITICAL递减,减到 0 才恢复 BASEPRI。 - 调度器挂起:
vTaskSuspendAll是另一个机制,只阻止调度、不关中断,与临界区不同。 - 保护对象:内核数据结构(就绪列表、TCB、队列)在临界区里访问,避免并发破坏。
- 高优先级中断:BASEPRI 阈值以上的中断仍能响应,但不能调 RTOS API。
原理流程
- 任务调
taskENTER_CRITICAL:读原 BASEPRI,写阈值,计数加 1。 - 临界区内访问队列、TCB 等共享数据,无需再上锁。
- 高优先级中断仍可响应,但它若调
xQueueSendFromISR,会因为优先级数值 < 阈值而被断言失败。 taskEXIT_CRITICAL:计数减 1,到 0 时恢复原 BASEPRI。- 临界区结束后若有需要切换,触发 PendSV。
代码或图示
/* 错误:临界区里做耗时操作(如 Flash 写) */
void bad_update(void) {
taskENTER_CRITICAL();
flash_erase_page(0x08004000); /* 几 ms 的 Flash 操作! */
taskEXIT_CRITICAL();
}
/* 正确:临界区只保护数据结构,耗时操作推出 */
void good_update(void) {
uint32_t page = 0x08004000;
taskENTER_CRITICAL();
g_pending_page = page;
taskEXIT_CRITICAL();
flash_erase_page(page); /* 在临界区外做 */
}
/* 临界区嵌套 */
taskENTER_CRITICAL(); /* nesting = 1 */
taskENTER_CRITICAL(); /* nesting = 2, BASEPRI 不变 */
taskEXIT_CRITICAL(); /* nesting = 1 */
taskEXIT_CRITICAL(); /* nesting = 0, 恢复 BASEPRI */
常见误区
- 误区:临界区关中断;正解:它只关低优先级中断,高优先级中断仍能进。
- 误区:临界区可以无限长;正解:临界区长度 = 所有被屏蔽中断的额外延迟,长临界区直接破坏实时性。
- 误区:临界区里可以调阻塞 API;正解:阻塞 API 会让调度器在临界区里切换,破坏内核状态,必须退出临界区后再调。
追问
- 临界区里能调
printf吗?答:不能直接调,因为printf可能阻塞或耗时,且 UART 发送可能依赖中断。机制上临界区要短,任何 IO 都应推出。边界在于:调试期可用半主机(semihosting)或 ITM 输出,但生产代码应禁用。延伸:日志应在任务上下文异步写入环形缓冲。 - 临界区长度的工程建议?答:硬实时项目要求临界区 < 10us,典型 < 5us;超过就拆解。机制上每 1us 临界区会给被屏蔽中断加 1us 延迟。边界在于:访问复杂数据结构(如平衡树)可能天然超过 10us,应改用无锁结构或分段锁。延伸:用 DWT 打点统计最长临界区,纳入 CI 门禁。
vTaskSuspendAll与临界区区别?答:vTaskSuspendAll只阻止调度器切换,不关中断,中断仍可响应;临界区同时关中断与调度。机制上前者用于"短时间内批量改数据但允许中断响应",后者用于"保护内核数据结构"。边界在于:vTaskSuspendAll期间不能调阻塞 API,但允许中断里xQueueSendFromISR。延伸:这是 FreeRTOS 提供的两种并发保护粒度。
14.1.3-004 中断延迟怎么测量?典型组成?
一句话结论
中断延迟 = 中断信号置位 → 当前指令完成 → 硬件异常进入(Cortex-M 约 12 周期)→ 当前临界区剩余屏蔽 → 高优先级 ISR 抢占 → 取指/流水线恢复;测量方法是"外部信号触发中断 + ISR 第一行翻转 GPIO + 示波器量两个边沿间隔",并在长时统计中取 P99/P100。
概念解释
- 硬件异常进入:Cortex-M 在中断到达时自动压栈 R0/R3/R12/LR/PR/xPSR 共 8 个寄存器,约 12 周期(尾链时 6 周期)。
- 临界区屏蔽:若 CPU 在 BASEPRI/PRIMASK 屏蔽窗口,中断延迟到屏蔽结束。
- 高优先级抢占:若更高优先级 ISR 正在跑,当前中断等它完成。
- 取指等待:Flash 等待周期、缓存未命中会让 ISR 首条指令晚几个周期。
原理流程
- 信号源(如外部定时器)在 t=0 同时触发中断与示波器通道 CH1。
- ISR 第一行
HAL_GPIO_TogglePin翻转 CH2。 - 示波器量 CH2 上升沿 - CH1 上升沿,即为单次延迟。
- 在系统负载下重复测量:空载、跑周期任务、跑临界区、跑 Flash 擦写。
- 用 DWT->CYCCNT 在 ISR 里累计最坏值,跑 24 小时取 P100。
代码或图示
/* 测量:外部定时器触发 TIM2 中断,ISR 第一行翻 GPIO */
void TIM2_IRQHandler(void) {
/* 第一行:翻 GPIO,让示波器看到 */
GPIOC->ODR ^= GPIO_ODR_ODR0;
/* 第二行:读 DWT,记录延迟 */
uint32_t now = DWT->CYCCNT;
uint32_t d = now - g_trigger_stamp;
if (d > g_max_latency) g_max_latency = d;
/* 清标志 */
TIM2->SR = ~TIM_SR_UIF;
}
/* 信号源:另一个定时器在 t=0 同时触发 GPIO 输出 */
示波器判读:
CH1: 外部触发(中断信号)
CH2: ISR GPIO 翻转
延迟 = CH2 - CH1
典型分解(72MHz Cortex-M4):
硬件进入 ≈ 12 周期 (167ns)
当前指令完成 ≈ 1~3 周期
临界区屏蔽 = 测量变量(关键)
高优先级抢占 = 测量变量
取指等待 ≈ 0~10 周期(Flash 等待周期配置)
────────────────────────────
空载典型 ≈ 200~500ns
带 10us 临界区 ≈ 10.2~10.5us
常见误区
- 误区:只测一次波形;正解:中断延迟是分布,必须长时统计 P99/P100。
- 误区:用平均延迟做实时性判定;正解:硬实时只看最坏值或可证明上界。
- 误区:测量代码本身不影响;正解:GPIO 翻转 + DWT 读取代价几周期,高频中断下会显著扰动,应在测量模式下开启。
追问
- 为什么尾链(tail-chaining)能减少中断进入时间?答:Cortex-M 在 ISR A 结束、ISR B 已挂起时,直接从 ISR A 切到 ISR B,跳过异常返回与重新压栈的部分周期。机制上尾链把"出栈→取向量→压栈"简化为"取向量→压栈"。边界在于:尾链只在两个 ISR 连续发生时才生效,空载时仍走完整 12 周期。延伸:这也是高优先级中断频繁时延迟反而下降的原因。
- Flash 等待周期怎么影响中断延迟?答:若 ISR 首条指令在 Flash 里,Flash 等待周期(如 2 个 wait state)会让取指慢 2 个周期。机制上 Cortex-M4 在 72MHz 下通常配 2 wait state,ISR 向量从 Flash 读取也要等。边界在于:把 ISR 关键代码拷贝到 RAM 执行(
__attribute__((section(".ramfunc"))))可消除这部分延迟。延伸:高频中断(如 PWM 故障保护)应放 RAM。 - 为什么测量时要跑"最坏负载"?答:空载测的延迟是下界,真实系统里临界区、高优先级 ISR、Flash 擦写都会叠加。机制上最坏延迟 = 空载延迟 + 最长临界区 + 最高优先级 ISR 执行时间。边界在于:压测必须覆盖所有真实场景,否则 P100 不代表真实最坏。延伸:CI 里跑固定压测负载,与基线比较。
14.1.3-005 长临界区怎么拆?什么时候用 ticket lock?
一句话结论
长临界区的拆解原则是"只在共享数据真正需要保护的最小窗口内上锁",把 IO、计算、Flash 操作推到临界区外;当临界区不可避免要长(如复杂数据结构更新),用 ticket lock(排队锁)或细粒度锁替代全局锁,让等待者按顺序获得锁,避免优先级反转与饿死。
概念解释
- 最小临界区:只在访问共享数据的指令段内上锁,前后处理在临界区外。
- 细粒度锁:把一个大锁拆成多个小锁(如按链表节点分桶),降低争用。
- Ticket lock:等待者按顺序取号,锁释放时叫号,FIFO 公平,避免饿死。
- 读锁/写锁:多读单写,读操作不互斥,适合读多写少场景。
原理流程
- 识别临界区里的代码:哪些是必须保护的,哪些可以推出。
- 把 IO、Flash、计算推出临界区,只保留共享数据读写。
- 若临界区仍长,分析争用模式:读多写少用 RW 锁,多写用 ticket lock。
- 用 DWT 打点测量最长临界区,目标 < 10us。
- 把临界区长度纳入 CI 门禁,回归时报警。
代码或图示
/* 反例:临界区里做 Flash 写 */
void bad_save(void) {
taskENTER_CRITICAL();
for (int i = 0; i < PAGE_WORDS; i++) {
flash_program(g_buf[i]); /* 几 ms */
}
taskEXIT_CRITICAL();
}
/* 正例:先在临界区里快照数据,临界区外写 Flash */
void good_save(void) {
uint32_t snapshot[PAGE_WORDS];
taskENTER_CRITICAL();
memcpy(snapshot, g_data, sizeof(g_data));
taskEXIT_CRITICAL();
for (int i = 0; i < PAGE_WORDS; i++) {
flash_program(snapshot[i]);
}
}
/* Ticket lock 示意(Cortex-M SMP 用) */
struct ticket_lock { volatile uint32_t next; volatile uint32_t owner; };
void lock(struct ticket_lock *l) {
uint32_t t = __atomic_fetch_add(&l->next, 1, __ATOMIC_SEQ_CST);
while (__atomic_load_n(&l->owner, __ATOMIC_SEQ_CST) != t) { __WFE(); }
}
void unlock(struct ticket_lock *l) {
__atomic_add_fetch(&l->owner, 1, __ATOMIC_SEQ_CST);
}
常见误区
- 误区:临界区里做快照也会慢;正解:memcpy 几百字节是几 us,比 Flash 写 ms 级短三个数量级。
- 误区:细粒度锁一定更好;正解:锁越多、开销越大,且可能死锁(嵌套顺序问题),只有在争用高时才拆。
- 误区:ticket lock 解决优先级反转;正解:ticket lock 只解决公平性,不解决优先级反转(高优先级仍要排队),它需要配合优先级继承或天花板。
追问
- 什么时候必须用 ticket lock?答:SMP 下多个核争用同一把锁,普通自旋锁后到者可能一直抢不到(链式等待),ticket lock 让等待者按顺序获得。机制上每个等待者取号,锁释放时 owner++,叫到号的进入。边界在于:ticket lock 仍有优先级问题(高优先级可能排在低优先级后面),实时 SMP 项目用优先级继承自旋锁。延伸:Linux 的
queued_spinlock就是 ticket lock 的优化版。 - 读多写少场景怎么优化?答:用读写锁(RW lock),读并发、写独占。机制上读锁计数 + 写锁等待队列,读者不互斥。边界在于:读写锁在读者多时写者可能饿死,需要写优先策略或限制读者数。延伸:实时项目常避免读写锁,改用"读时快照 + 写时复制"。
- 临界区里能调用其它函数吗?答:能,但被调函数不能再进临界区(会嵌套)或阻塞。机制上嵌套临界区靠计数,允许但不推荐——它让临界区实际长度变难分析。边界在于:库函数(如
printf、malloc)内部可能有自己的锁或阻塞,绝不能在临界区里调。延伸:把临界区逻辑写成小函数,明确边界。
14.1.3-006 ISR 里的活推到哪里?任务/工作队列/软件定时器?
一句话结论
ISR 里只做最小动作(清标志、取数据、唤醒),耗时处理按延迟要求分三层:极硬实时在 ISR 里直接做(< 10us),中等实时推到高优先级任务,软实时推到工作队列或软件定时器回调;选择依据是"处理时间 vs 可容忍延迟"。
概念解释
- ISR 最小动作:清中断标志、读 FIFO、唤醒任务。
- 高优先级任务:延迟要求 < 1ms,优先级设到最高。
- 工作队列(Work Queue):内核提供的低优先级任务,上下文处理 defer work。
- 软件定时器回调:周期或延迟任务,在 Tmr Svc 任务上下文执行。
原理流程
- 判断处理时间:< 10us 可在 ISR 里做;10us~1ms 推高优先级任务;> 1ms 推工作队列。
- ISR 里用
xQueueSendFromISR或任务通知唤醒处理任务。 - 处理任务在自己的上下文里做协议解析、滤波、IO。
- 周期任务(如每秒上报)用软件定时器,不要在 ISR 里做。
- 用
portYIELD_FROM_ISR在 ISR 出口立即切换,减少唤醒延迟。
代码或图示
/* UART RX:ISR 收字节,任务里解析协议 */
void USART1_IRQHandler(void) {
uint8_t byte = USART1->DR;
BaseType_t w = pdFALSE;
xQueueSendFromISR(g_uart_q, &byte, &w);
portYIELD_FROM_ISR(w);
}
void uart_parse_task(void *arg) {
uint8_t byte;
for (;;) {
xQueueReceive(g_uart_q, &byte, portMAX_DELAY);
protocol_parse_byte(byte); /* 耗时逻辑 */
}
}
/* Zephyr 工作队列:ISR 提交 work,系统工作队列处理 */
static void work_handler(struct k_work *work) {
process_sensor_data();
}
K_WORK_DELAYABLE_DEFINE(my_work, work_handler);
void sensor_isr(void) {
k_work_schedule(&my_work, K_MSEC(1));
}
常见误区
- 误区:ISR 越短越好;正解:极硬实时(如 PWM 故障保护)必须在 ISR 里直接动作,推到任务会延迟。
- 误区:工作队列就是任务;正解:工作队列是共享的低优先级任务,多个 work 串行执行,一个 work 阻塞会推迟其它 work。
- 误区:软件定时器回调是 ISR;正解:它是 Tmr Svc 任务上下文,可以调阻塞 API(但不能阻塞)。
追问
- 工作队列和专门任务怎么选?答:工作队列适合"多个小任务共享一个线程",省栈;专门任务适合"需要高优先级或独立栈"。机制上工作队列是单线程串行,所有 work 共享一个栈。边界在于:一个 work 阻塞会推迟所有其它 work,且栈深要按最深 work 调用链估算。延伸:Zephyr 提供
k_work_q自定义工作队列,可独立优先级。 - ISR 里直接做硬实时动作有什么风险?答:ISR 长度直接叠加到所有被屏蔽中断的延迟上,且不能调阻塞 API、不能用浮点(除非惰性压栈已处理)。机制上 ISR 是中断上下文,没有 TCB。边界在于:硬实时动作要尽量短(如关 PWM、切断输出),几微秒完成。延伸:安全相关动作(如过流保护)通常在 ISR 里直接做硬件切断,再唤醒任务做后续记录。
- 为什么周期任务不用 ISR?答:周期任务有逻辑、有 IO、有状态,放在 ISR 里会让 ISR 变长,且不能阻塞。机制上周期任务应由定时器中断唤醒,任务上下文处理。边界在于:超高频(> 10kHz)周期任务可能必须在 ISR 里做,因为任务切换开销占比太大。延伸:这种场景用 DMA + 双缓冲,CPU 只在半满中断时处理。
14.1.3-007 为什么 Flash 擦写会破坏实时性?
一句话结论
Flash 擦写期间(几 ms 到几十 ms),多数 MCU 的 Flash 控制器会暂停 CPU 取指(即使代码在 RAM 里,数据在 Flash 里读也会停),且不能被中断打断;这相当于一次几 ms 的"关中断窗口",直接把所有中断延迟放大到 ms 级。
概念解释
- Flash 擦写时间:页擦除 20~50ms,半字/字编程 50~100us,取决于厂商。
- CPU 暂停:擦写期间 Flash 阵列被占用,CPU 取指暂停(等待 busy)。
- 中断不可屏蔽:擦写操作在 Flash 控制器里,中途不能取消。
- 数据读取:若擦写期间要读 Flash 数据(常量、字符串),CPU 也会停。
原理流程
- 任务调
flash_erase_page(addr),Flash 控制器开始擦除。 - 期间 CPU 取指暂停(若代码在 Flash)或数据读暂停(若数据在 Flash)。
- 中断到达,等擦写结束才能响应。
- 擦写结束后 CPU 恢复,中断排队响应。
- 结果:所有中断延迟被拉长一个擦写周期(ms 级)。
代码或图示
/* 反例:在周期任务里同步擦 Flash */
void bad_log_task(void *arg) {
for (;;) {
vTaskDelay(pdMS_TO_TICKS(100));
flash_erase_page(LOG_PAGE); /* 30ms! 所有中断停 30ms */
flash_program(g_log_data, sizeof(g_log_data));
}
}
/* 正例:用 DMA + 中断,或放到低优先级任务 */
void good_log_task(void *arg) {
for (;;) {
vTaskDelay(pdMS_TO_TICKS(100));
/* 先在临界区里快照 */
taskENTER_CRITICAL();
memcpy(snapshot, g_log_data, sizeof(g_log_data));
taskEXIT_CRITICAL();
/* 低优先级任务做擦写,硬实时任务仍能跑 */
flash_erase_page(LOG_PAGE);
flash_program(snapshot, sizeof(snapshot));
}
}
常见误区
- 误区:Flash 擦写只是慢一点;正解:它是几 ms 的 CPU 暂停窗口,所有中断延迟被放大。
- 误区:把代码放 RAM 就没事;正解:代码在 RAM 里跑,但数据在 Flash 里读(常量、查找表)仍会停。
- 误区:擦写可以被中断打断;正解:Flash 控制器一旦开始就不能中途取消,中断要等结束。
追问
- 怎么缓解 Flash 擦写的实时性影响?答:把擦写放到最低优先级任务,与硬实时任务时间错开;或用双 bank Flash(一边跑代码一边擦另一边)。机制上双 bank 让 CPU 在 bank A 取指时擦 bank B,互不干扰。边界在于:双 bank Flash 容量大、成本高,低端 MCU 没有。延伸:OTA 升级时通常接受"几 ms 不可用",产品状态机定义好降级路径。
- 为什么读 Flash 数据也会停?答:Flash 阵列同一时间只能做一件事(取指/读数据/擦写),读数据时与取指争用阵列。机制上 Flash 控制器在 busy 时,所有访问都排队。边界在于:把常用常量拷贝到 RAM 可避免读 Flash,但 RAM 容量有限。延伸:查找表、字串常量是常见的 Flash 读热点。
- 量产时怎么避免 OTA 升级破坏实时性?答:OTA 放到设备空闲时段(如凌晨 2~4 点),或分小块写(每写 1 页让出几 ms 给实时任务)。机制上分块写让 CPU 在页间隙响应中断。边界在于:分块写延长升级时间,且要处理断电续传。延伸:产品状态机里"OTA 中"模式会降低实时性能接受等级。
14.1.3-008 中断风暴怎么定位与缓解?
一句话结论
中断风暴是短时间内大量中断同时到达,CPU 忙于进出 ISR,任务无法运行;定位靠"统计每个中断的进入次数与耗时",缓解靠"中断合并(DMA 半满/全满)、限流、降低中断频率、把处理推到任务"。
概念解释
- 中断风暴:大量中断在 ms 级内同时到达,CPU 进出 ISR 占满。
- DMA 半满/全满:用 DMA 双缓冲,每半满或全满才触发一次中断,而不是每个字节触发。
- 限流:在中断里计数,超过阈值丢弃或合并。
- 中断合并(Interrupt Coalescing):硬件支持,把多个中断源合并成一个。
原理流程
- 用 trace 或计数器统计每个中断在 1 秒内的进入次数与耗时。
- 找出异常高频中断(如 UART 每字节中断,115200 波特 = 11.5kHz)。
- 改为 DMA 环形缓冲,每半满触发一次中断(降到几百 Hz)。
- 若风暴来自错误中断(如抖动导致的 EXTI 反复触发),加硬件去抖或软件屏蔽。
- 测量缓解后 CPU 占用与任务响应时间。
代码或图示
/* 反例:UART 每字节中断 */
void USART1_IRQHandler(void) {
uint8_t b = USART1->DR;
process_byte(b); /* 每字节都进 ISR,11.5kHz */
}
/* 正例:DMA 环形缓冲,半满才中断 */
void DMA1_Stream5_IRQHandler(void) {
if (DMA_GetITStatus(DMA1_Stream5, DMA_IT_HTIF)) {
/* 缓冲区前半满,通知任务处理前半 */
BaseType_t w = pdFALSE;
xSemaphoreGiveFromISR(g_rx_sem, &w);
portYIELD_FROM_ISR(w);
}
if (DMA_GetITStatus(DMA1_Stream5, DMA_IT_TCIF)) {
xSemaphoreGiveFromISR(g_rx_sem, &w);
portYIELD_FROM_ISR(w);
}
}
/* 中断计数统计 */
volatile uint32_t g_irq_count[IRQN_COUNT];
void irq_entry_profiler(void) {
g_irq_count[get_current_irqn()]++;
}
常见误区
- 误区:中断多说明系统忙;正解:中断多可能是配置错误(每字节中断 vs DMA),CPU 忙于进出 ISR。
- 误区:在 ISR 里处理越快越好;正解:处理推到任务,ISR 只唤醒,减少 ISR 占用。
- 误区:中断风暴是硬件问题;正解:多数是软件配置问题(没用 DMA、错误中断未清理)。
追问
- 怎么统计每个中断的耗时?答:在 ISR 入口翻 GPIO 或读 DWT,记录进入与退出时间,长时统计每个中断的累计 CPU 占比。机制上 trace 钩子在每个 ISR 进入/退出打时间戳。边界在于:统计本身有开销,应在调试期开启,量产关闭。延伸:Zephyr 的
CONFIG_IRQ_OFFLOAD与 FreeRTOS 的 trace 钩子都支持。 - 错误中断风暴怎么处理?答:先在 ISR 里清标志,若反复触发说明硬件问题(如 EXTI 抖动、外设错误状态),加硬件去抖或临时屏蔽该中断。机制上错误中断不清标志会反复触发。边界在于:屏蔽中断会让该外设功能失效,要记录错误并上报。延伸:GPIO 输入加 RC 滤波或软件去抖(延迟 20ms 再确认)。
- 中断风暴下任务还能跑吗?答:能跑一点,但响应时间被拉长,因为中断优先级高于任务。机制上 CPU 进出 ISR 占满,任务只能在 ISR 间隙运行。边界在于:硬实时任务若被风暴中断推迟超过截止时间,系统就违约。延伸:把风暴中断的优先级降到最低,让硬实时中断不被影响。
14.1.3-009 没有示波器怎么长时统计 P99/P100?
一句话结论
用 DWT->CYCCNT(Cortex-M 周期计数器)在关键路径上打时间戳,在 RAM 环形缓冲里记录最坏值与时间戳,长时运行(24~72 小时)后通过调试器或 UART 回传统计;不需要示波器也能给出 P99/P100 与最坏值发生时刻。
概念解释
- DWT->CYCCNT:Cortex-M 内嵌的 32 位周期计数器,每周期加 1,分辨率 1/主频(72MHz = 13.9ns)。
- 环形缓冲:在 RAM 里存最近 N 个时间戳或最坏值记录。
- 最坏值记录:每次测得更大值就更新,同时记录时间戳与上下文。
- P99/P100:把所有测量值排序,P99 是第 99% 位置,P100 是最大值。
原理流程
- 启动时使能 DWT->CYCCNT:
DEMCR |= TRCENA; CYCCNT = 0;。 - 在关键路径(ISR 入口、任务唤醒点)打时间戳,计算差值。
- 把差值与时间戳写入环形缓冲(或只更新最坏值)。
- 长时运行 24~72 小时,覆盖各种场景。
- 通过调试器 SWD 或 UART 回传缓冲,PC 上排序得 P99/P100。
代码或图示
/* 初始化 DWT */
void dwt_init(void) {
CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
DWT->CYCCNT = 0;
DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
}
/* 记录最坏中断延迟 */
typedef struct { uint32_t cycles; uint32_t tick; uint32_t arg; } lat_rec_t;
lat_rec_t g_worst[10]; /* 前 10 个最坏值 */
void record_latency(uint32_t cycles, uint32_t arg) {
/* 简单插入:若比当前最小的坏记录更大,替换 */
int min_idx = 0;
for (int i = 1; i < 10; i++) {
if (g_worst[i].cycles < g_worst[min_idx].cycles) min_idx = i;
}
if (cycles > g_worst[min_idx].cycles) {
g_worst[min_idx] = (lat_rec_t){cycles, xTaskGetTickCount(), arg};
}
}
/* 应用:ISR 里调 */
void TIM_IRQHandler(void) {
uint32_t now = DWT->CYCCNT;
uint32_t d = now - g_trigger_stamp;
record_latency(d, 0);
TIM->SR = ~TIM_SR_UIF;
}
常见误区
- 误区:DWT 计数器会溢出;正解:32 位在 72MHz 下约 59 秒溢出一次,差值计算要考虑回绕(用无符号减法自然处理)。
- 误区:记录所有样本占 RAM;正解:只保留前 N 个最坏值,或环形缓冲覆盖最老事件。
- 误区:软件打点没有误差;正解:读 DWT 本身几周期,高频测量时要扣除。
追问
- 怎么扣除测量本身的开销?答:跑一次"空测量"(只读 DWT、不做业务),得到基线开销,从所有测量值中减去。机制上基线开销稳定,可校正。边界在于:高频测量(> 10kHz)开销占比大,应减少打点次数。延伸:用 GPIO + 示波器测一次,与 DWT 结果对比校正。
- 怎么在量产设备上保留 trace?答:在备份 RAM(Standby 模式不丢失)里存最近 N 条事件,复位后 bootloader 读取并上报。机制上复位原因寄存器(RCC_CSR)告诉 bootloader 是看门狗还是 HardFault。边界在于:备份 RAM 容量有限(几 KB),只能存最关键事件。延伸:这是"现场取证"在量产设备上的标准做法。
- P99 和 P100 哪个更重要?答:硬实时看 P100(最坏值必须满足截止时间),软实时看 P99/P99.9(用户体验)。机制上 P100 是单次违约即事故,P99 是允许 1% 违约。边界在于:P100 受偶发事件(如 Flash 擦写、中断风暴)影响大,要覆盖所有场景。延伸:安全认证项目要求 P100 有可证明上界,不是实测值。
14.1.3-010 HardFault 现场怎么抓取?
一句话结论
HardFault 发生时,硬件自动把 R0/R3/R12/LR/PC/xPSR 压入当前栈(MSP 或 PSP),HardFault_Handler 要从栈指针里取出这些寄存器,结合 CFSR/HFSR/ABFSR 状态寄存器判断故障原因,并把现场转储到备份 RAM,复位后上报。
概念解释
- 压栈帧:HardFault 入口时,硬件在栈上按固定顺序压入 8 个寄存器。
- CFSR(Configurable Fault Status Register):可配置故障状态寄存器,记录精确原因(总线错误、内存管理、用法错误)。
- HFSR(HardFault Status Register):HardFault 状态,记录是否 escalate 来自其它 fault。
- LR(EXC_RETURN):异常返回值,指示返回时用 MSP 还是 PSP。
- 现场转储:把寄存器、栈、任务状态存到备份 RAM,复位后读取。
原理流程
- 故障发生,硬件压栈 8 个寄存器,跳转到 HardFault_Handler。
- Handler 读 LR(EXC_RETURN)判断用 MSP 还是 PSP。
- 从对应栈指针取 8 个寄存器,特别是 PC(故障指令地址)与 LR(返回地址)。
- 读 CFSR/HFSR/ABFSR 判断故障原因(精确总线错误、无效指令、除零等)。
- 把现场(PC/LR/寄存器/栈摘要)存到备份 RAM,触发系统复位。
- 复位后 bootloader 检测复位原因,读取备份 RAM 并上报。
代码或图示
void HardFault_Handler(void) {
__asm volatile (
"tst lr, #4 \n" /* 判断用 MSP 还是 PSP */
"ite eq \n"
"mrseq r0, msp \n"
"mrsne r0, psp \n"
"ldr r1, =hard_fault_c \n"
"bx r1 \n"
);
}
void hard_fault_c(uint32_t *stack) {
uint32_t r0 = stack[0];
uint32_t r1 = stack[1];
uint32_t r2 = stack[2];
uint32_t r3 = stack[3];
uint32_t r12 = stack[4];
uint32_t lr = stack[5];
uint32_t pc = stack[6]; /* 故障指令地址 */
uint32_t psr = stack[7];
/* 读故障状态寄存器 */
uint32_t cfsr = SCB->CFSR;
uint32_t hfsr = SCB->HFSR;
uint32_t mmfar = SCB->MMFAR;
uint32_t bfar = SCB->BFAR;
/* 转储到备份 RAM */
g_crash_dump.pc = pc;
g_crash_dump.lr = lr;
g_crash_dump.cfsr = cfsr;
/* ... 保存更多 ... */
NVIC_SystemReset();
}
CFSR 常见位:
0x00000100 (IBUSERR) = 取指总线错误
0x00000200 (PRECISERR)= 精确数据总线错误(BFAR 有效)
0x00000400 (IMPRECISERR)= 不精确数据总线错误
0x00010000 (UNDEFINSTR)= 未定义指令
0x00020000 (INVSTATE) = 非法状态(如 EPSR.T=0)
0x00040000 (INVPC) = 非法 PC 加载(返回地址错)
0x00080000 (NOCP) = 无协处理器(用 FPU 但没开)
0x02000000 (UNALIGNED)= 非对齐访问
0x04000000 (DIVBYZERO)= 除零
常见误区
- 误区:HardFault_Handler 里可以调
printf;正解:HardFault 时栈可能已损坏,printf可能再触发 fault,应只用寄存器操作。 - 误区:PC 就是故障地址;正解:精确总线错误时 PC 是故障指令,不精确错误时 PC 可能是后续指令,要看 CFSR。
- 误区:复位后现场就没了;正解:备份 RAM(Standby 模式)保持内容,bootloader 可读取。
追问
- 怎么从 PC 定位到代码行?答:用 map 文件与 elf 文件,
addr2line -e firmware.elf -f 0x08001234给出函数名与行号。机制上 map 文件记录每个函数的起止地址。边界在于:O0 编译时优化少,行号对应准;O2 优化后可能行号错位。延伸:release 固件也要保留 map 文件与 elf 用于分析。 - HardFault 时在哪个任务上下文?答:从 LR(EXC_RETURN)判断用 MSP 还是 PSP,PSP 表示任务上下文,MSP 表示 ISR 上下文。机制上 Cortex-M 异常进入时自动切换栈。边界在于:HardFault 发生在 ISR 里时,PSP 是被中断任务的栈,不是 ISR 栈(ISR 用 MSP)。延伸:转储时要记录当前任务句柄(通过
pxCurrentTCB)。 - 怎么避免 HardFault 转储再触发 fault?答:转储代码用汇编写、只做寄存器与内存写,不调任何库函数;备份 RAM 地址要在链接脚本里显式保留。机制上简单内存写不会再触发 fault。边界在于:若故障是总线错误(访问非法地址),转储时访问的备份 RAM 必须是合法地址。延伸:备份 RAM 通常选 0x40000000 以上的 SRAM 或 RTC 备份寄存器。
动手练习
练习 1:测量你的中断延迟分布
- 任务:用定时器触发中断,ISR 第一行翻 GPIO + 读 DWT,跑 24 小时,记录最坏值与前 10 个最坏值。
- 验收标准:
- 给出 P50/P99/P100 延迟(周期数或 us)。
- 在系统里加一个 5ms 的临界区,对比两组数据的 P100。
- 解释差异来自哪一段(临界区屏蔽 / 高优先级抢占 / Flash 等待)。
练习 2:HardFault 现场转储实验
- 任务:故意写一个空指针访问或除零触发 HardFault,在 Handler 里转储 PC/LR/CFSR 到备份 RAM,复位后通过 bootloader 读取并打印。
- 验收标准:
- 能正确从栈上取到 8 个寄存器,PC 指向故障指令。
- CFSR 位与故障原因对应(如 UNDEFINSTR / PRECISERR)。
- 用
addr2line从 PC 定位到源码行。
自检清单
- [ ] 能否说清 PRIMASK、BASEPRI、FAULTMASK 的差异与使用场景?
- [ ] 能否画出中断延迟的完整组成?
- [ ] 能否解释
taskENTER_CRITICAL的代价与嵌套规则? - [ ] 能否设计一个长临界区的拆解方案?
- [ ] 能否判断 ISR 里的活应该推到任务还是工作队列?
- [ ] 能否解释 Flash 擦写为什么破坏实时性?
- [ ] 能否设计一个长时统计 P99/P100 的方案?
- [ ] 能否从 HardFault 栈帧里取到 PC/LR 并读 CFSR?
延伸阅读
- ARM Cortex-M3/M4 权威指南(Joseph Yiu):异常模型、NVIC、PRIMASK/BASEPRI、DWT。
- ARM 官方文档:Cortex-M3/M4 Generic User Guide(
SCB->CFSR、SCB->HFSR、EXC_RETURN)。 - FreeRTOS 官方文档:
Critical Sections、Interrupt Nesting、Stack Overflow。 - Zephyr 官方文档:
Interrupt Context、Work Queues、IRQ Offload。 - 厂商应用笔记:STM32 AN3965(中断与DMA)、AN4621(内存保护单元)。
待整理清单
- [ ] 补充 Cortex-M7 带 D-cache 场景下的中断延迟实测数据
- [ ] 补充 Flash 擦写在不同厂商 MCU(STM32/GD32/ESP32)上的阻塞时间对比
- [ ] 备份 RAM 转储方案在不同 MCU(STM32 backup SRAM / ESP32 RTC memory)上的差异