罗罗编程学习记录 全栈面试题库
本页导航 展开查看

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 实测出最坏值。
  • 判断一段代码该不该放进临界区,并给出拆解方案。
  • 设计一个能在量产设备上记录最坏延迟与现场状态的机制。

先修与前置

知识地图

中断延迟 =
  中断信号置位
  + 当前指令完成(最多 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。

原理流程

  1. 系统启动时调 HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4):4 位抢占、0 位子。
  2. 每个中断用 NVIC_SetPriority(IRQn, priority) 设置优先级数值(0~15)。
  3. ISR A 正在跑(优先级 5),中断 B 挂起(优先级 2):因为 2 < 5,硬件自动嵌套 B。
  4. ISR B 跑时,中断 C 挂起(优先级 3):3 > 2,不能打断 B,C 等 B 完成。
  5. 同级中断同时挂起:按向量号小者先响应(不是子优先级,因为 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。

原理流程

  1. 进入临界区前读当前 BASEPRI,写 configMAX_SYSCALL_INTERRUPT_PRIORITY。
  2. 高优先级中断(数值小于阈值)仍能响应,低优先级中断被屏蔽。
  3. 临界区结束恢复原 BASEPRI 值。
  4. 若用 PRIMASK,会把所有中断都关掉,包括最高优先级实时中断,破坏实时性。
  5. 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。

原理流程

  1. 任务调 taskENTER_CRITICAL:读原 BASEPRI,写阈值,计数加 1。
  2. 临界区内访问队列、TCB 等共享数据,无需再上锁。
  3. 高优先级中断仍可响应,但它若调 xQueueSendFromISR,会因为优先级数值 < 阈值而被断言失败。
  4. taskEXIT_CRITICAL:计数减 1,到 0 时恢复原 BASEPRI。
  5. 临界区结束后若有需要切换,触发 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 首条指令晚几个周期。

原理流程

  1. 信号源(如外部定时器)在 t=0 同时触发中断与示波器通道 CH1。
  2. ISR 第一行 HAL_GPIO_TogglePin 翻转 CH2。
  3. 示波器量 CH2 上升沿 - CH1 上升沿,即为单次延迟。
  4. 在系统负载下重复测量:空载、跑周期任务、跑临界区、跑 Flash 擦写。
  5. 用 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 公平,避免饿死。
  • 读锁/写锁:多读单写,读操作不互斥,适合读多写少场景。

原理流程

  1. 识别临界区里的代码:哪些是必须保护的,哪些可以推出。
  2. 把 IO、Flash、计算推出临界区,只保留共享数据读写。
  3. 若临界区仍长,分析争用模式:读多写少用 RW 锁,多写用 ticket lock。
  4. 用 DWT 打点测量最长临界区,目标 < 10us。
  5. 把临界区长度纳入 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 任务上下文执行。

原理流程

  1. 判断处理时间:< 10us 可在 ISR 里做;10us~1ms 推高优先级任务;> 1ms 推工作队列。
  2. ISR 里用 xQueueSendFromISR 或任务通知唤醒处理任务。
  3. 处理任务在自己的上下文里做协议解析、滤波、IO。
  4. 周期任务(如每秒上报)用软件定时器,不要在 ISR 里做。
  5. 用 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 也会停。

原理流程

  1. 任务调 flash_erase_page(addr),Flash 控制器开始擦除。
  2. 期间 CPU 取指暂停(若代码在 Flash)或数据读暂停(若数据在 Flash)。
  3. 中断到达,等擦写结束才能响应。
  4. 擦写结束后 CPU 恢复,中断排队响应。
  5. 结果:所有中断延迟被拉长一个擦写周期(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):硬件支持,把多个中断源合并成一个。

原理流程

  1. 用 trace 或计数器统计每个中断在 1 秒内的进入次数与耗时。
  2. 找出异常高频中断(如 UART 每字节中断,115200 波特 = 11.5kHz)。
  3. 改为 DMA 环形缓冲,每半满触发一次中断(降到几百 Hz)。
  4. 若风暴来自错误中断(如抖动导致的 EXTI 反复触发),加硬件去抖或软件屏蔽。
  5. 测量缓解后 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 是最大值。

原理流程

  1. 启动时使能 DWT->CYCCNT:DEMCR |= TRCENA; CYCCNT = 0;。
  2. 在关键路径(ISR 入口、任务唤醒点)打时间戳,计算差值。
  3. 把差值与时间戳写入环形缓冲(或只更新最坏值)。
  4. 长时运行 24~72 小时,覆盖各种场景。
  5. 通过调试器 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,复位后读取。

原理流程

  1. 故障发生,硬件压栈 8 个寄存器,跳转到 HardFault_Handler。
  2. Handler 读 LR(EXC_RETURN)判断用 MSP 还是 PSP。
  3. 从对应栈指针取 8 个寄存器,特别是 PC(故障指令地址)与 LR(返回地址)。
  4. 读 CFSR/HFSR/ABFSR 判断故障原因(精确总线错误、无效指令、除零等)。
  5. 把现场(PC/LR/寄存器/栈摘要)存到备份 RAM,触发系统复位。
  6. 复位后 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 个最坏值。
  • 验收标准:
    1. 给出 P50/P99/P100 延迟(周期数或 us)。
    2. 在系统里加一个 5ms 的临界区,对比两组数据的 P100。
    3. 解释差异来自哪一段(临界区屏蔽 / 高优先级抢占 / Flash 等待)。

练习 2:HardFault 现场转储实验

  • 任务:故意写一个空指针访问或除零触发 HardFault,在 Handler 里转储 PC/LR/CFSR 到备份 RAM,复位后通过 bootloader 读取并打印。
  • 验收标准:
    1. 能正确从栈上取到 8 个寄存器,PC 指向故障指令。
    2. CFSR 位与故障原因对应(如 UNDEFINSTR / PRECISERR)。
    3. 用 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)上的差异