最典型的一段代码:主循环里读按键,读到低电平就点亮 LED,中间夹一句 delay(100) 做消抖。跑起来发现按键十次有三次没反应,按住不动反而偶尔触发。把 delay 改小,又变成按一下触发好几次。

另一类更隐蔽:串口每收几个字节就丢一个,日志里能看到半截命令;加了几句打印之后丢得更厉害,删掉打印又好了。以为是线的问题,换了线、换了 USB 口、换了波特率,还是丢。

这两个现象都属于同一类问题:CPU 在某个时刻没空处理该处理的事。前一个是主循环被 delay 卡住,按键状态变化发生在那 100 毫秒里,代码根本没机会看;后一个是中断服务函数太长,串口的下一个字节到了还没被取走,硬件缓冲区溢出,字节就没了。

这篇讲中断怎么进出、优先级怎么排、ISR 该写成什么样、延迟从哪来、怎么算。文中会算几笔 CPU 占用和字节时间的账,数字是 Python 按公式算出来的,不是用逻辑分析仪测的;本机没有开发板、示波器和逻辑分析仪,所有中断响应时间、波形和丢包现象都未在本机实测。

中断是什么:一次被硬件打断的函数调用

中断是硬件或软件发出的一个信号,让 CPU 暂停当前正在执行的流程,跳去执行一段专门的代码,执行完再回到原处。这段专门的代码叫中断服务函数,英文缩写 ISR,Interrupt Service Routine。

它和普通函数调用最大的差别是“谁来发起”。普通函数是你写代码调用的,什么时候调用你清楚;中断是外设或异常事件发起的,什么时候来你只能约束、不能完全控制。串口收到一个字节、定时器计数到点、引脚电平跳变、ADC 转换完成,都会发中断。

进出中断有一套固定动作。硬件先保存当前程序的现场(至少是返回地址和部分寄存器),再根据中断号查向量表,跳到对应 ISR;ISR 结束时执行一条特殊返回指令,硬件恢复现场,回到被打断的地方。整个过程对写 C 代码的人是透明的,但它的开销实实在在存在,这就是“中断有成本”的来源。

一次中断的完整路径
主循环运行CPU 正在执行普通代码
外设发请求串口收到字节、定时器到点、引脚跳变
保存现场硬件压栈,记录返回地址和寄存器
执行 ISR查向量表,跳到对应服务函数
恢复现场特殊返回指令,弹栈还原
继续主循环从被打断的那条指令接着跑

注意最后一步:中断不是“跳过去就不回来”,它必须能回到原处,而且不能破坏原处的状态。ISR 里改了主循环正在用的变量、动了外设配置却不恢复,就会出现“主循环行为莫名其妙变了”的问题。这类 bug 比单纯的丢数据更难查。

优先级:谁能打断谁

中断不止一个,同时来两个怎么办?靠优先级。Cortex-M 系列里管这件事的模块叫 NVIC,Nested Vectored Interrupt Controller,嵌套向量中断控制器。它给每个中断分配一个优先级,高优先级的可以打断正在执行的低优先级 ISR,这叫嵌套。

优先级通常分两段:抢占优先级和子优先级。抢占优先级决定“能不能打断”,子优先级只在同时挂起、抢占级别又相同时决定“谁先执行”。很多芯片把优先级寄存器实现成 4 位,也就是 16 个级别,具体几位、怎么分组,要看芯片手册里 NVIC 那一章。配错分组,会出现“明明设了高优先级,却没能抢占”的情况。

还有两个词要分清。挂起(pending):中断事件已经发生,但 CPU 还没开始执行它的 ISR,这个请求被记在挂起寄存器里。活动(active):ISR 正在执行。同一个中断在活动期间又来了,会被记为挂起,等当前 ISR 返回后立刻再进一次,不会丢,但会叠加延迟。

优先级不是越高越好。把所有中断都设成最高,等于没有优先级,谁也不能打断谁,关键中断照样被前面的长 ISR 挡住。正确做法是按“错过会有什么后果”排序:会丢数据、会损坏设备的放高,慢速的人机交互放低。

内核还有两个优化细节值得知道。尾链(tail-chaining):一个 ISR 刚返回、另一个已经挂起的中断立刻开始,省掉一次完整的恢复再保存,延迟比“返回后重新进”短。晚到(late arrival):高优先级中断在低优先级 ISR 保存现场的过程中到来,内核会直接切换到高优先级,不必等低优先级跑完。这些是硬件帮你省的时间,但前提是优先级配对了;配反了,优化也救不回来。

轮询和中断,先选一种

不用中断也能干活,那就是轮询:主循环不停读状态,看到事件就处理。两种方式各有适用面。

轮询

实现简单,不用配 NVIC,不会因为优先级配错出怪问题。缺点是 CPU 一直在等,事件来得不规律时要么响应慢,要么空转浪费。适合事件慢、量小、时序要求不严的场景,比如每秒读一次温度。

中断

事件来了才处理,响应快,CPU 可以去做别的事。缺点是每次进出都有开销,ISR 写错会影响全局,优先级和共享变量都要小心。适合按键、串口、定时器这类“随时可能发生、不能错过”的事件。

实际项目常常是混合:主循环轮询低频状态,中断处理高频事件。判断的关键是“最坏情况下能容忍多久的延迟”。如果容忍度是几百毫秒,轮询够用;如果是几十微秒,就得上中断,而且要把中断延迟算清楚。

ISR 的三条铁律

第一条:短。ISR 里只做必须立刻做的事——读走数据、清标志、置一个变量、把数据塞进队列,然后马上返回。解析协议、算浮点、打印日志、等外设,全部放到主循环。判断标准很直接:ISR 执行时间乘以触发频率,不能把 CPU 占满,也不能让更高优先级的中断等太久。

第二条:共享变量要加 volatile。编译器看到主循环里有个变量一直没被自己改过,可能把它优化成寄存器缓存,只读一次;而 ISR 在另一个时刻改了内存里的值,主循环却永远看不到变化。加 volatile 是告诉编译器“这个变量可能被你看不见的代码改”,每次都去内存读。它不解决原子性,只解决“看不见”。

第三条:临界区要短,关中断要有数。主循环改一个 ISR 也会改的多字节变量时,需要短暂关中断,改完立刻开。关中断期间所有中断都被推迟,关得越久,延迟越大。更好的办法是用“读—改—写”原子指令,或者用队列传递数据,从根上避免共享。

不要在 ISR 里调用会阻塞的函数:串口打印、延时、等标志、动态分配内存,都可能让 ISR 卡住几十毫秒。卡住期间同优先级和更低优先级的中断全部排队,表现出来就是“系统偶尔卡一下,然后丢一堆数据”。

按键为什么会丢

回到开头那段代码。按键丢的本质是“采样间隔大于事件持续时间”。机械按键按下去到松开,快的也有几十毫秒;主循环里一个 delay 一百毫秒,中间这段时间代码在空转,根本没读引脚,按键按下又松开,这一次动作就完全没被看见。

把 delay 拿掉、改成轮询,又会出现另一个问题:抖动。按键触点在闭合瞬间会弹跳几毫秒,代码读得太快,一次按下被读成好几次。所以消抖不能靠“延时挡住 CPU”,要靠“记录状态、按时间确认”。

常见做法是定时器每 1 到 5 毫秒进一次中断,在 ISR 里采样引脚、更新一个计数器;主循环只读“稳定状态”和“事件标志”。这样采样是定时的,不受主循环忙不忙影响;消抖是计数的,不占 CPU 等待时间。按键事件还可以进一个很小的队列,主循环慢慢取,连按几下也不会丢。

// 定时器每 2ms 调一次;连续 5 次相同才认,约 10ms 消抖
void key_scan_2ms(void) {
    static uint8_t last, cnt;
    uint8_t now = read_key_pin();
    if (now != last) { last = now; cnt = 0; return; }
    if (cnt < 5) cnt++;
    if (cnt == 5 && stable != now) {
        stable = now;
        if (now == 0) ring_push(&key_queue, KEY_DOWN);  // 只入队,不处理
    }
}

这段代码里没有任何 delay,主循环再忙也不会漏采样,因为采样发生在定时器中断里。真正处理“按下后要做什么”的代码在主循环,ISR 只负责记录。这就是“ISR 短、主循环干活”的具体样子。

串口为什么丢字节

串口丢字节的原因比按键更物理。串口接收通常只有一个或几个字节的硬件缓冲,新字节到齐时如果上一个还没被读走,就会触发溢出错误,新数据直接丢。这个错误标志在很多芯片上叫 ORE,Overrun Error。

算一下时间就明白了。115200 波特率、每字节 10 位(起始位、8 数据位、停止位),一个字节占用大约 86.8 微秒;921600 波特率下只有 10.85 微秒。这是 Python 按公式算的:

for baud in (115200, 921600):
    t = 10 / baud * 1e6
    print(baud, round(t, 2), "us")

输出是 115200 86.81 us 和 921600 10.85 us。也就是说在高波特率下,ISR 必须在十微秒量级内把数据取走,否则下一字节就到。ISR 里如果有一句串口打印,或者有一次浮点运算,这个时间很容易超。

解决办法有几个层次:ISR 只把字节塞进环形缓冲;提高串口中断优先级,让它不被慢中断挡住;数据量大时改用 DMA 接收,设成循环模式,半传输和传输完成各发一次中断,CPU 一次处理半屏数据;再加一层协议,用帧头帧尾和校验发现丢了再重传。前三个属于本篇范围,最后一个属于协议组。

中断延迟的账怎么算

“实时”不是“快”,是“最坏情况下也能在期限内响应”。所以要看的是延迟上限,不是平均速度。中断延迟大致由四段组成:硬件响应时间、当前指令执行完的时间、更高优先级 ISR 占用的时间、以及你自己关中断的时间。

硬件响应这一段,Cortex-M 内核手册给的典型值是十几个时钟周期;如果正在执行长指令、访问慢速存储器,还会多几个等待周期。这部分你改不了,只能知道它存在。真正能控制的是后两段:别在 ISR 里磨蹭,别长时间关中断。

CPU 占用也要算。假设定时器每 1 毫秒中断一次,ISR 执行 2 微秒,占用就是百分之零点二;如果每 100 微秒中断一次、ISR 执行 10 微秒,占用就是百分之十。用 Python 算一遍:

for isr_us, period_us in [(2, 1000), (2.5, 1000), (10, 100), (20, 1000)]:
    print(isr_us, period_us, round(isr_us / period_us * 100, 3))

输出依次是 0.2、0.25、10.0、2.0,单位是百分比。这里假设 ISR 执行时间是估算值,实际要用示波器翻转引脚或内核计数器测,本机没有这些条件,所以只给模型。但数量级足够用来判断“这个中断频率合不合理”。

出错时先查哪里

现象真实原因第一步查什么
按键十次有三次没反应主循环被 delay 或耗时任务阻塞,采样间隔大于按键动作时间找主循环里所有阻塞调用,改成定时采样加事件队列
串口偶尔少一个字节ISR 太长或优先级太低,硬件缓冲溢出看溢出标志是否置位,统计 ISR 最大执行时间
系统偶尔卡顿一下,随后丢一批数据ISR 里做了打印、延时、等外设这类阻塞操作把耗时逻辑移出 ISR,只留取数据和置标志
ISR 改了变量,主循环看不到变量没加 volatile,或被编译器缓存进寄存器检查共享变量的声明和优化等级,必要时用内存屏障
设了高优先级却不抢占优先级分组配错,抢占位和子优先级位搞反查 NVIC 分组设置和每个中断的实际优先级数值
关键中断响应变慢临界区太长,或低优先级 ISR 执行太久统计最长关中断时间和最长 ISR 时间,按优先级重排
同一次按键触发多次没有消抖,或消抖只在主循环里做,采样不稳定改成定时采样计数消抖,事件只入队一次
中断进不去外设中断使能开了,但 NVIC 里没使能,或全局中断被关查外设、NVIC、全局三处使能位是否都打开

边界与代价

中断不是越多越好。每个中断都要保存恢复现场,频率一高,CPU 大部分时间都在进出中断,业务代码被切得零碎。能用 DMA 搬的批量数据,不要用字节中断;能用状态机轮询的低频事件,不要占一个中断通道。

优先级设计错了,比没有优先级更糟。高优先级中断源源不断,低优先级永远轮不上,这叫饿死;低优先级 ISR 里等一个只有高优先级才能给的资源,就是死锁。嵌入式里没有操作系统兜底,这些问题只能靠设计避免。

ISR 里不能随便调用库函数。很多库函数内部有锁、有延时、有内存分配,放在中断上下文里行为不确定。标准做法是自己写最朴素的取数据和入队,复杂的都推到主循环。

“实时”是延迟上限,不是平均速度。平均响应一毫秒、偶尔卡五十毫秒的系统,不能叫实时系统。要给出最坏情况,就必须知道最长关中断时间、最长 ISR、最高优先级占用,这三样都得能测或者能算。本机没有仪器,这篇只能给模型和公式,真实数字要在你的板子上测。

今天就能验证的五个练习

  1. 估算你项目里一个 1 毫秒定时中断的 CPU 占用:数一数 ISR 里大约多少条指令,按主频折算成微秒,再用文中的公式算百分比。
  2. 写一段“ISR 只置标志、主循环处理”的伪代码:定时器中断置位,主循环看到标志后清零并执行动作,检查有没有竞态。
  3. 查你手上 MCU 的内核手册,确认 NVIC 优先级实际实现了几位、分成几组,写下 16 级优先级里哪些数值是抢占级。
  4. 设计一个按键状态机:松开、按下抖动、按下稳定、松开抖动四个状态,写出每个状态在 2 毫秒采样下的转移条件。
  5. 列一张中断延迟来源表:硬件响应、当前指令、高优先级 ISR、关中断时间,各写一句你能怎么减小它。

收束:先保证不丢,再谈快

中断的核心是三件事:进出有成本,所以要短;共享数据会被优化,所以要 volatile;多个中断会抢顺序,所以要按后果排优先级。按键丢不是“按键坏了”,串口丢也不是“线不好”,多数时候是 CPU 在该看的时候没看,或者该取的时候没取。把采样交给定时器、把处理放回主循环、把批量数据交给 DMA,这三招能解决大部分丢数据问题。

代码写得再对,也得能烧进板子、能看见它跑。下一个绕不开的环节是固件怎么下载、怎么调试:为什么工具报找不到目标,为什么下载成功却不运行,OTA 升级断电能怎么办。下一篇讲 固件烧录与调试:SWD、JTAG、串口下载。