单片机与物联网 / 系统课时

RTOS 基础概念

RTOS 基础概念

当业务包含通信、采集、控制和界面等并发活动时,单一主循环会逐渐难以维护。RTOS 通过任务状态、优先级调度和内核对象管理并发,使等待事件的任务主动阻塞,让处理器优先运行当前最需要执行的就绪任务。

学习目标

  • 理解任务的运行、就绪、阻塞和挂起状态,以及优先级调度的基本规则。
  • 区分消息队列、信号量和互斥锁的用途与边界。
  • 能够识别优先级反转、死锁、队列溢出和 ISR 误用等常见问题。

调度与通信机制

RTOS 中每个任务通常拥有独立栈和任务控制块。任务等待时间、队列消息或同步对象时进入阻塞态,不再消耗 CPU;等待条件满足后回到就绪态。抢占式内核通常选择最高优先级的就绪任务运行,同优先级任务是否时间片轮转则由内核配置决定。

RTOS 任务状态、优先级调度与内核对象关系

机制 携带数据 典型用途 关键边界
消息队列 是 任务间传递采样值、命令或结构体 需要规划容量、元素大小和满队列策略
二值信号量 否 中断通知任务、一次性事件同步 连续多次事件可能合并为一次可用状态
计数信号量 否 记录多个事件或管理同类资源数量 上限设置错误会造成丢计数或永久等待
互斥锁 否 保护共享外设、缓冲区或配置对象 只能由持有者释放,通常支持优先级继承

消息队列本身通常已经能够让接收任务阻塞并在消息到达时唤醒,因此不应机械地再配一个信号量。信号量适合表达“事件发生”或“资源可用”,互斥锁表达“共享资源的唯一所有权”;二者虽然都有获取和释放操作,但所有权规则与优先级继承语义不同。

概念模拟与运行

下面的可运行 C 程序是确定性的教学模拟器,不是具体 RTOS 内核。它用数组模拟消息队列,用布尔值模拟二值信号量,并用所有者字段模拟互斥锁。偶数毫秒由 ISR 产生采样,高优先级 worker 先处理消息,低优先级 logger 随后读取共享结果。

c
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>

#define QUEUE_CAPACITY 4

typedef struct {
    int data[QUEUE_CAPACITY];
    size_t head;
    size_t tail;
    size_t count;
} MessageQueue;

typedef struct {
    bool available;
} BinarySemaphore;

typedef struct {
    const char *owner;
} Mutex;

static int latest_sample = -1;

static bool queue_send_from_isr(MessageQueue *queue, int value) {
    if (queue->count == QUEUE_CAPACITY) {
        return false;
    }
    queue->data[queue->tail] = value;
    queue->tail = (queue->tail + 1) % QUEUE_CAPACITY;
    queue->count++;
    return true;
}

static bool queue_receive(MessageQueue *queue, int *value) {
    if (queue->count == 0) {
        return false;
    }
    *value = queue->data[queue->head];
    queue->head = (queue->head + 1) % QUEUE_CAPACITY;
    queue->count--;
    return true;
}

static void semaphore_give_from_isr(BinarySemaphore *semaphore) {
    semaphore->available = true;
}

static bool semaphore_take(BinarySemaphore *semaphore) {
    if (!semaphore->available) {
        return false;
    }
    semaphore->available = false;
    return true;
}

static bool mutex_lock(Mutex *mutex, const char *task_name) {
    if (mutex->owner != NULL) {
        return false;
    }
    mutex->owner = task_name;
    return true;
}

static void mutex_unlock(Mutex *mutex) {
    mutex->owner = NULL;
}

static void worker_task(MessageQueue *queue, BinarySemaphore *ready, Mutex *lock, int tick) {
    int sample;
    if (!semaphore_take(ready) || !queue_receive(queue, &sample)) {
        return;
    }

    // 高优先级任务消费消息,并用互斥锁保护共享状态。
    if (mutex_lock(lock, "worker")) {
        latest_sample = sample;
        printf("%d ms | worker consumed %d\n", tick, sample);
        mutex_unlock(lock);
    }
}

static void logger_task(Mutex *lock, int tick) {
    if (mutex_lock(lock, "logger")) {
        printf("%d ms | logger latest=%d\n", tick, latest_sample);
        mutex_unlock(lock);
    }
}

int main(void) {
    MessageQueue queue = {0};
    BinarySemaphore sample_ready = {false};
    Mutex data_lock = {NULL};

    for (int tick = 0; tick < 6; ++tick) {
        if (tick % 2 == 0) {
            int sample = 100 + tick * 10;
            queue_send_from_isr(&queue, sample);
            semaphore_give_from_isr(&sample_ready);
            printf("%d ms | ISR produced %d\n", tick, sample);

            // worker 优先级 3,高于 logger 的优先级 1,因此先运行。
            printf("%d ms | run worker(p3)\n", tick);
            worker_task(&queue, &sample_ready, &data_lock, tick);
            printf("%d ms | run logger(p1)\n", tick);
            logger_task(&data_lock, tick);
        } else {
            printf("%d ms | run idle\n", tick);
        }
    }

    return 0;
}

将代码保存为 rtos_concepts.c,编译并运行:

bash
gcc -std=c11 -Wall -Wextra -pedantic rtos_concepts.c -o rtos_concepts
./rtos_concepts

预期输出体现了事件到达、高优先级任务先运行、共享数据更新和空闲任务接管处理器的顺序:

text
0 ms | ISR produced 100
0 ms | run worker(p3)
0 ms | worker consumed 100
0 ms | run logger(p1)
0 ms | logger latest=100
1 ms | run idle
2 ms | ISR produced 120
2 ms | run worker(p3)
2 ms | worker consumed 120
2 ms | run logger(p1)
2 ms | logger latest=120
3 ms | run idle
4 ms | ISR produced 140
4 ms | run worker(p3)
4 ms | worker consumed 140
4 ms | run logger(p1)
4 ms | logger latest=140
5 ms | run idle

真实 RTOS 中不需要手工调用高优先级任务;中断释放同步对象后,内核会根据调度规则决定是否立即切换任务。教学示例同时使用队列和二值信号量只是为了分别展示“数据传递”和“事件通知”,实际设计中若队列阻塞接收已经满足需求,应删除多余信号量。

选择与排错

为任务分配优先级时,应依据截止期、唤醒频率和阻塞影响,而不是依据功能名称。高优先级任务应短小并经常阻塞;若它持续计算或轮询,低优先级任务可能长期得不到运行。任务栈也必须按最坏调用深度、局部变量和库函数开销测量,而不能只凭经验填写。

  • 优先级反转:低优先级任务持有锁,高优先级任务等待锁,中优先级任务又不断抢占。应使用带优先级继承的互斥锁,并缩短临界区。
  • 死锁:两个任务以相反顺序获取多个互斥锁。应规定全局加锁顺序,必要时使用超时并记录持锁者。
  • 队列溢出:生产速度长期高于消费速度。应监控满队列次数,选择阻塞、丢弃旧数据、丢弃新数据或覆盖策略。
  • ISR 误用:中断中调用会阻塞的普通任务 API。应使用 RTOS 提供的 ISR 专用接口,并在退出中断前请求必要的任务切换。
  • 把延时当同步:用固定延时猜测外设或任务何时完成。应等待队列、通知、信号量或明确状态,而不是依赖时间碰巧足够。

练习

  1. 将模拟器的队列容量改为 2,并让 ISR 每毫秒产生数据、worker 每 3 ms 消费一次;要求增加丢包计数并输出最终统计,验收条件是队列不越界且丢包数可解释。
  2. 增加第二个共享资源和两个任务,先构造相反加锁顺序导致的死锁场景,再统一为固定加锁顺序;验收条件是修复版本能够完成全部任务并释放所有锁。

本课总结

  • RTOS 调度器只在就绪任务中选择运行者,阻塞任务不会通过忙等占用 CPU。
  • 队列负责传递数据,信号量负责事件或资源计数,互斥锁负责带所有权的共享资源保护。
  • 优先级、栈空间、队列容量和锁顺序必须通过测量与故障统计验证,不能只靠默认值。

下一课预告

下一阶段将把这些概念映射到具体 RTOS 的任务创建、周期延时、队列通信和并发调试流程,并进一步验证任务时序、栈余量与异常恢复能力。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

RTOS 基础概念

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通