一开始项目很小,一个 while(1) 里读按键、点灯、发串口,几十行就完了。后来加功能:串口要收命令、按键要消抖、传感器要定时采集、屏幕要刷新、还要低功耗定时唤醒。每个功能都往主循环里塞,很快出现“改一处坏三处”:串口收数据时按键不响应,屏幕刷新时采集周期被拉长,加个延时整个系统都卡。

于是有人上了 RTOS,把功能拆成几个任务,以为问题解决。结果又遇到新问题:某个任务跑着跑着进 HardFault,查出来是栈溢出;两个任务共用一条 I2C 总线,高优先级任务等低优先级任务释放锁,中间又被中优先级任务插队,系统看起来“卡住”了——这就是优先级反转。

这两个阶段其实是一回事:任务多了,就需要“谁先跑、跑多久、资源怎么分”的规则。裸机靠人写顺序,RTOS 把这些规则交给调度器。前者简单但难扩展,后者有框架但要付 RAM、Flash 和调试复杂度的代价。

这篇讲裸机前后台和 RTOS 的区别、任务状态与调度、队列和信号量、栈怎么估、优先级怎么排,最后给一个选型判断。文中会用 Python 算两个账:一个任务的栈大概要多少、三个任务的 CPU 利用率是否可调度。数字是算出来的,不是在本机跑的;本机没有开发板,FreeRTOS 的具体 API 行为未在本机实测,只讲通用语义。

裸机前后台:一个主循环的极限

裸机(bare metal)指不跑操作系统,程序从 main 开始,初始化完就进一个死循环。这个循环叫后台,中断叫前台,所以这种结构叫前后台系统。前台处理“必须马上响应”的事件,后台按顺序轮询其他事情。

它的优点是清楚:谁先谁后一眼看得见,没有调度器开销,RAM 只有一份栈,出问题好查。缺点是耦合:后台里任何一个函数阻塞,后面的全等;功能一多,主循环变成几百行的状态机,每加一个功能都要重新审视所有等待关系。

裸机能撑多大?没有固定答案,但有个经验判断:如果后台里所有操作的最长阻塞时间加起来,仍然小于最紧的响应期限,裸机就够用。反过来,如果某个功能需要等一个慢速外设,而另一个功能要求几十微秒响应,一个主循环就很难同时满足。

很多“必须上 RTOS”的项目,其实用状态机加定时器就能解决。把长流程拆成若干步,每步只做一点,靠时间片轮转推进,主循环永远不阻塞。代价是代码不如顺序写法直观,但省下了 RTOS 的 RAM 和调试成本。

RTOS 是什么:把等待变成任务状态

RTOS 是实时操作系统(Real-Time Operating System),核心职责是按优先级调度任务,保证高优先级任务在限定时间内拿到 CPU。注意“实时”不等于“快”,而是“可预测”:最坏情况下的延迟有上限,比平均速度重要。

任务(task)是一段独立的执行流,有自己的栈和优先级,看起来像“多个主循环同时在跑”。实际上只有一个 CPU,调度器在任务之间快速切换,每个任务跑一小段就轮到下一个。切换时保存当前任务的寄存器到它的栈里,再从另一个任务的栈里恢复,这叫上下文切换。

任务有几种状态:运行(Running,正占着 CPU)、就绪(Ready,可以跑但没轮到)、阻塞(Blocked,在等事件或等延时)、挂起(Suspended,被显式暂停)。调度器只从“就绪”里挑优先级最高的;同优先级时按时间片轮转,或者按创建顺序。

抢占(preemption)是 RTOS 和裸机最大的区别:高优先级任务一旦就绪,立刻打断低优先级任务,不用等它主动让出。这让响应时间可控,但也意味着任何共享资源都必须加保护,否则低优先级任务写到一半被切断,数据就坏了。

内核在中间做了什么

把系统分成三层看,RTOS 的位置很清楚:

应用任务采集、通信、显示、按键。每个任务写成一个死循环,里面用阻塞函数等事件,不再自己空转。
RTOS 内核调度器、任务管理、队列、信号量、互斥量、事件组、软定时器。它决定谁运行、谁等待、谁被唤醒。
硬件与移植层CPU 内核、SysTick 或硬件定时器、中断控制器、启动文件。移植层负责上下文切换和临界区,是 RTOS 与芯片绑定的部分。

这个分层解释了很多现象。任务不调度,可能是内核节拍没起来;上下文切换出错,多半是移植层的栈对齐或中断优先级配置有问题;队列发不出去,可能是队列满了或者中断里用了非中断安全版本的 API。排查时先定位在哪一层,再往下挖。

任务之间怎么通信

任务不能随便读写共享变量,得有规矩。RTOS 提供几种常用工具:

  • 队列(queue)。先进先出的缓冲区,一个任务放、另一个任务取。放的时候如果队列满,可以等一会儿或者直接失败;取的时候如果空,可以阻塞等。它是任务间传数据最常用的方式。
  • 信号量(semaphore)。一个计数器,用来表示“有几个资源可用”或“事件发生了几次”。二值信号量常用来做任务同步,中断里给信号、任务里等信号。
  • 互斥量(mutex)。带所有权和优先级继承的信号量,专门保护共享资源。谁拿谁放,别人不能替它放。I2C 总线、串口、文件系统这类资源,必须用互斥量保护。
  • 事件组(event group)。一组比特位,任务可以等“任意一位”或“全部位”被置起。适合一个任务等多个条件同时满足的场景。
  • 任务通知(task notification)。轻量级的直接通知,比队列省 RAM,但只能一对一。中断给任务发通知,任务醒来处理。

中断里不能用会阻塞的 API。FreeRTOS 的做法是提供一组以 FromISR 结尾的版本,它们在中断上下文里只做记录和请求切换,不做等待。用错版本,轻则断言失败,重则系统卡死。这是 RTOS 项目里最常见的一类错误。

栈:最容易被低估的资源

每个任务都有自己的栈,用来放局部变量、函数返回地址、上下文切换时保存的寄存器。栈给少了,任务一深调用就溢出,表现是随机的 HardFault、变量被莫名其妙改写、任务跑飞。栈给多了,RAM 不够,其他任务开不出来。

估算方法是逐项加:最深的调用链上,每一层的局部变量和返回地址;任务入口函数的缓冲区;上下文切换保存的寄存器;再加上中断嵌套可能占用的部分。最后留百分之二十到三十的余量,向上取整到便于对齐的大小。

拿一个具体例子算:局部变量 128 字节,调用深度 5 层、每层约 64 字节,中断嵌套按 2 层、每层 96 字节估。用 Python 算一下:

loc, depth, frame, isr, isr_frame = 128, 5, 64, 2, 96
base = loc + depth * frame + isr * isr_frame
print(base)              # 640
print(round(base * 1.3)) # 832
print(1024)              # 向上取整到 1KB

输出是 640、832、1024。也就是说估算值 640 字节,留三成余量是 832,实际配 1024 字节(1KB)比较稳。这个数只是模型,真实占用要用栈水位检测或者填充魔数的方式测,本机没有板子,测不了。

还有一个容易搞错的细节:在 Cortex-M 上,任务通常跑在进程栈(PSP),中断跑在主栈(MSP),所以中断嵌套一般不算进任务栈,但要单独给主栈留足空间;某些移植层会把中断也压到当前任务的栈上,那就必须算进去。看移植层的文档,别照抄别人的数字。

FreeRTOS 提供栈溢出检测钩子,能在切换时检查栈指针有没有越界,或者检查栈末尾的魔数有没有被改写。它只能发现“已经溢出”,不能提前预警,所以还是要靠水位统计:任务跑一段时间后,看栈里未被使用的最小值,再决定加多少。

优先级:按什么排

优先级不是拍脑袋定的。一个可用的思路是速率单调(Rate Monotonic):周期越短、越紧急的任务,优先级越高。因为周期短意味着deadline近,晚一点就错过。

排完之后要验证“能不能调度”。一个粗略的判据是 CPU 利用率:每个任务的执行时间除以周期,加起来。三个任务、周期分别是 10、20、50 毫秒,执行时间分别是 2、5、10 毫秒,用 Python 算:

tasks = [(10, 2), (20, 5), (50, 10)]        # (周期ms, 执行ms)
u = sum(c / p for p, c in tasks)
bound = len(tasks) * (2 ** (1 / len(tasks)) - 1)
print(round(u * 100, 1))       # 65.0
print(round(bound * 100, 1))   # 78.0

输出是 65.0 和 78.0,单位是百分比。三个任务的利用率是百分之六十五,低于速率单调的理论上限百分之七十八,按这个简化模型是可调度的。但这个判据有前提:固定优先级、可抢占、任务之间不阻塞、截止期等于周期。真实系统里有互斥量等待、有中断开销、有缓存影响,实际余量要留得更多。利用率超过百分之七十时,就该认真做响应时间分析,而不是只看这个界限。

优先级反转是另一个坑。低优先级任务拿了互斥量,高优先级任务来等它;这时一个中优先级任务就绪,抢占了低优先级任务;结果高优先级任务被中优先级任务间接拖住,等得比谁都久。解决办法是优先级继承:低优先级任务持锁期间临时提升到等待者的优先级,放锁后恢复。互斥量通常自带这个机制,普通二值信号量没有。所以保护共享资源要用互斥量,不要用信号量凑合。

中断服务函数里不要调用任何可能阻塞的 RTOS API,也不要做耗时操作。正确做法是中断里只发通知或放队列,让任务去处理。中断优先级比系统允许调用 API 的阈值更紧急(数值更小)时,不能调用 RTOS API,否则断言直接触发。

裸机和 RTOS 怎么选

裸机前后台

代码直观、RAM 占用小、没有调度开销、调试简单,适合功能少、时序要求不复杂、只有一颗 MCU 的小项目。代价是功能一多就耦合,长流程要把自己拆成状态机,响应时间靠人保证,扩展性差。

RTOS

任务独立、阻塞式写法直观、优先级让响应时间可分析、队列和信号量把耦合显式化,适合多功能、多周期、需要联网和低功耗并存的设备。代价是 RAM 和 Flash 开销、上下文切换成本、优先级和栈的设计难度,以及更难复现的并发 bug。

判断可以问四个问题:功能是否超过五六个且互相等待?是否有不同周期的任务同时存在?是否有阻塞式外设操作(等待网络、等待传感器)?团队是否能接受多花几天做任务设计和调试?前三个有两个以上是“是”,就值得上 RTOS;如果只有一个,先用状态机试试。

出错时先查哪里

现象真实原因第一步查什么
主循环越改越乱,改一处坏三处功能耦合在一个循环里,阻塞等待互相影响把长流程拆成状态机,或按周期拆成独立任务
任务跑飞、HardFault、变量被改写任务栈太小,深调用或大数组把栈写穿开栈溢出检测,统计栈水位,给最深的调用链留余量
任务明明就绪却不运行同优先级没有让出,或任务里死循环没有阻塞点查任务里有没有延时或等事件,确认调度器节拍在跑
高优先级任务等很久优先级反转,低优先级持锁被中优先级抢占确认共享资源用的是带继承的互斥量,缩短持锁时间
队列满、数据被丢队列长度不够,或消费任务优先级低、处理慢统计队列高水位,调整长度或提高消费任务优先级
中断里调用 RTOS API 触发断言用了非 FromISR 版本,或中断优先级高于系统上限换成中断安全版本,核对中断优先级配置
系统启动就卡在调度器堆不够、任务创建失败、空闲任务没跑起来查堆配置和创建返回值,确认空闲任务有栈
加了 RTOS 后 RAM 不够任务数太多、每个栈都给得偏大、堆碎片列任务清单,按估算收紧栈,尽量用静态分配

边界与代价

RTOS 不是免费的。内核本身要占 Flash,每个任务要占栈,队列和信号量要占 RAM;一颗只有几十 KB RAM 的芯片,开五六个任务就满了。上下文切换也有成本,切换太频繁,CPU 花在保存恢复上的时间会明显上升。

并发 bug 比顺序代码难查。两个任务同时改一个变量、持锁顺序不一致导致死锁、队列在中断和任务之间来回传导致时序错乱,这些问题在实验室跑一天都未必出现,到现场才炸。用 RTOS 就要接受“调试成本上升”这件事。

优先级设计错了,比裸机更糟。裸机至少顺序是确定的,RTOS 里一个优先级配反,可能让关键任务永远轮不上,或者让低优先级任务饿死。优先级不是越多越好,通常三到五档就够,档位太多反而难维护。

不是所有项目都需要 RTOS。一个每秒读一次温度、通过串口发出去的设备,裸机加个定时器就够了,上 RTOS 属于给自己找事。反过来,一个要同时处理 Wi-Fi、蓝牙、屏幕、传感器、按键的设备,裸机的状态机会复杂到没人敢改,这时候 RTOS 的抽象是省心的。

最后,本机没有开发板,也没有跑过 FreeRTOS,文中的 API 名称和调度语义来自公开文档和通用实现,具体的配置项、断言行为、栈增长方向请以你用的移植层为准。

今天就能验证的五个练习

  1. 列出你项目里所有功能和它们的执行周期,标出哪些会阻塞、哪些必须立刻响应,看看能不能合并成三到五个任务。
  2. 按文中的方法估一个任务的栈:局部变量、最深调用层数、每层帧大小、中断嵌套,加三成余量,向上取整。
  3. 画一张优先级表:任务名、周期、执行时间、优先级、依赖的资源,再用利用率公式检查是否超过可调度界限。
  4. 用伪代码写一个队列的生产者和消费者:中断里放、任务里取,处理队列满和队列空两种情况。
  5. 给一个具体项目做裸机与 RTOS 的选型:写下功能数量、周期种类、阻塞操作、RAM 预算,给出结论和理由。

收束:规则比代码更重要

裸机和 RTOS 不是先进与落后的关系,是“用顺序换简单”和“用规则换扩展”的取舍。裸机的极限在于主循环里任何一处阻塞都会拖累全局;RTOS 的价值在于把等待变成任务状态,让高优先级任务能按时运行。上了 RTOS,真正要学的不是 API,而是任务划分、栈估算、优先级和共享资源保护这四件事。这四件做对了,RTOS 才帮你;做错了,它只是把问题藏得更深。

到这里,嵌入式基础这一组七篇就结束了:从认清 STM32 和 ESP32,到引脚、外设、中断、烧录、低功耗,再到任务调度。设备能跑、能睡、能升级,接下来就该和外面的世界说话。下一组转到通信协议,从 帧格式:一条消息怎么定义 开始,讲清楚数据在两根线上到底是怎么被组织、校验和重传的。