1
FreeRTOS 任务状态转换:
2

3
                    xTaskCreate()  // 创建任务
4
                         │
5
                         ▼
6
                    ┌──────────┐
7
            ┌──────│  就绪态   │◀────────────┐
8
            │      │  Ready   │              │
9
            │      └────┬─────┘              │
10
            │           │ 被调度器选中         │
11
  vTaskSuspend()        ▼                     │ vTaskDelay()超时  // 任务延时(释放CPU)
12
            │      ┌──────────┐              │ 等到信号量/消息
13
            │      │  运行态   │──────────────┤
14
            │      │ Running  │  vTaskDelay() │  // 任务延时(释放CPU)
15
            │      └────┬─────┘  等信号量/消息 │
16 collapsed lines
16
            │           │                     │
17
            │           │ vTaskSuspend()      │
18
            ▼           ▼                     │
19
       ┌──────────┐  ┌──────────┐            │
20
       │  挂起态   │  │  阻塞态   │────────────┘
21
       │Suspended │  │ Blocked  │  超时/事件到达
22
       └──────────┘  └──────────┘
23

24
调度规则:
25
  1. 最高优先级的就绪任务先运行
26
  2. 同优先级任务轮转(Round-Robin, 时间片)
27
  3. 高优先级任务就绪 → 立即抢占低优先级任务
28
  4. 空闲任务(优先级0)在没人跑时执行
29

30
  优先级:  tskIDLE_PRIORITY(0) ~ configMAX_PRIORITIES-1
31
  ★ 数字越大优先级越高(和Linux相反!)

1
┌────────────────────────────────────────────────┐
2
│           FreeRTOS 任务间通信                    │
3
├──────────┬──────────┬─────────┬────────────────┤
4
│ 机制     │ 传数据？  │ 方向    │ 典型场景        │
5
├──────────┼──────────┼─────────┼────────────────┤
6
│ 队列Queue│ ★传数据 │ 任意    │ 传感器数据传递  │
7
│ 信号量   │ 不传     │ 同步    │ ISR通知任务     │
8
│ 互斥锁   │ 不传     │ 互斥    │ 保护共享资源    │
9
│ 事件组   │ 不传     │ 多对一  │ 多条件等待      │
10
│ 任务通知 │ 可选     │ 一对一  │ 轻量级信号(快!) │
11
│ 流缓冲   │ ★传字节流│ 一对一 │ UART接收        │
12
│ 消息缓冲 │ ★传消息 │ 一对一  │ 变长消息        │
13
└──────────┴──────────┴─────────┴────────────────┘
14

15
★ 队列是FreeRTOS的"万能通信工具"——信号量、互斥锁、事件组底层都是用队列实现的!
14 collapsed lines
16

17
队列工作原理:
18
  ┌───────────────────────────────────┐
19
  │  队列存储区(环形数组)              │
20
  │  ┌───┬───┬───┬───┬───┐           │
21
  │  │ A │ B │ C │   │   │           │
22
  │  └─↑─┴───┴─↑─┴───┴───┘           │
23
  │    │        │                      │
24
  │   读指针   写指针                   │
25
  └───────────────────────────────────┘
26

27
  发送: xQueueSend() → 队列满？ 阻塞等待(可设超时)  // 发送消息到队列
28
  接收: xQueueReceive() → 队列空？ 阻塞等待(可设超时)  // 从队列接收消息
29
  ISR版: xQueueSendFromISR() (不会阻塞,满了直接返回失败)  // 发送消息到队列

1
优先级反转示例:
2
  高: Task_H ──────□□□□□□□□□□□□──运行  (被低优先级阻塞!)
3
  中: Task_M ────────■■■■■■───────        (抢占了Task_L)
4
  低: Task_L ─■■──□□□□□□□□□□□■──          (持有互斥锁)
5
                  ↑             ↑
6
              Task_L持锁     Task_L释放锁
7
              Task_H需要锁   Task_H获得锁
8

9
  ★ 解决方案: 优先级继承(Priority Inheritance)
10
    Task_L持有锁时,如果Task_H在等 → Task_L临时提升到Task_H的优先级
11
    → Task_M无法抢占Task_L → Task_L快速完成并释放锁
12
    → Task_H立即获得锁运行
13

14
  FreeRTOS中:
15
    xSemaphoreCreateMutex()     → 有优先级继承 ★推荐
1 collapsed line
16
    xSemaphoreCreateBinary()    → 无优先级继承(纯信号量)

1
FreeRTOS 中断设计:
2

3
  优先级    中断类型               能否调用FreeRTOS API?
4
  ┌───── 0 ─── 最高硬件中断优先级 ───── ✗ 不能! ──────────┐
5
  │                                                        │
6
  │       ... (高于configMAX_SYSCALL_INTERRUPT_PRIORITY)    │
7
  │                                                        │
8
  ├───── N ─── configMAX_SYSCALL_INTERRUPT_PRIORITY ────────┤
9
  │                                                        │
10
  │       ... (低于等于此值的中断)                           │
11
  │                                                        │
12
  │       ✓ 可以调用 FromISR 版本的API                      │
13
  │       如: xQueueSendFromISR()                           │  // 发送消息到队列
14
  │           xSemaphoreGiveFromISR()                       │  // 释放信号量(V操作)
15
  │           portYIELD_FROM_ISR()                          │
12 collapsed lines
16
  │                                                        │
17
  ├───── M ─── configKERNEL_INTERRUPT_PRIORITY ──── PendSV/SysTick
18
  └─────────────────────────────────────────────────────────┘
19

20
  ★ 注意: ARM-Cortex-M中数字越小优先级越高!
21
    configMAX_SYSCALL = 5 意味着优先级0~4的中断不能调FreeRTOS API
22

23
  ★ ISR中绝对不能调用的:
24
    xQueueSend()          → 要用 xQueueSendFromISR()  // 发送消息到队列
25
    xSemaphoreTake()      → 要用 xSemaphoreTakeFromISR()  // 获取信号量(P操作)
26
    vTaskDelay()          → ISR中不能延时!  // 任务延时(释放CPU)
27
    printf()              → ISR中不能调用非重入函数!

1
FreeRTOS 核心特性:
2

3
┌────────────────────────────────────────────┐
4
│ FreeRTOS — 实时操作系统内核               │
5
│                                            │
6
│ 调度: 抢占式 + 时间片轮转 + 协作式        │
7
│ 内核大小: 5~15KB Flash                     │
8
│ 支持: ARM Cortex-M/A/R, RISC-V, x86等    │
9
│                                            │
10
│ 核心组件:                                  │
11
│  ├── 任务管理(多任务+优先级抢占)          │
12
│  ├── 队列(任务间消息传递)                 │
13
│  ├── 信号量/互斥量(同步/互斥)             │
14
│  ├── 任务通知(轻量级通信)                 │
15
│  ├── 软件定时器                            │
6 collapsed lines
16
│  ├── 内存管理(heap_1~5)                   │
17
│  └── 事件组(多事件等待)                   │
18
│                                            │
19
│ 许可: MIT(可商用, 不需开源)               │
20
│ 生态: AWS IoT, CMSIS-RTOS, 社区庞大       │
21
└────────────────────────────────────────────┘

1
              vTaskCreate()
2
                   |
3
                   v
4
  +----------> Ready <-----------+
5
  |              |               |
6
  |     调度器选中(最高优先级)      |
7
  |              |               |
8
  |              v               |
9
  |          Running             |
10
  |          /      \            |
11
  |   vTaskDelay() xQueueReceive()|  // 从队列接收消息
12
  |   vTaskSuspend()   等待事件   |
13
  |        /              \      |
14
  |       v                v     |
15
  |   Blocked          Suspended |
4 collapsed lines
16
  |       |                |     |
17
  |   超时/事件到达   vTaskResume()|
18
  |       |                |     |
19
  +-------+----------------+-----+

1
裸机:                        RTOS:
2
┌──────────────┐            ┌──────────────┐
3
│  main()      │            │  Task A      │ 优先级高
4
│  while(1) {  │            ├──────────────┤
5
│    func_A(); │            │  Task B      │ 优先级中
6
│    func_B(); │            ├──────────────┤
7
│    func_C(); │            │  Task C      │ 优先级低
8
│  }           │            ├──────────────┤
9
│  轮询, 无抢占 │            │  RTOS 内核   │ 调度器
10
└──────────────┘            └──────────────┘
11
                             抢占式, 实时响应

1
                  vTaskResume()
2
  ┌─────────────────────────────────────┐
3
  ↓                                     │
4
Running ←→ Ready ←→ Blocked ←→ Suspended
5
  │          ↑        │                 ↑
6
  │          │        │                 │
7
  └──────────┘        └─────────────────┘
8
  被抢占/yield     等待事件/超时    vTaskSuspend()
9

10
Running:   正在 CPU 上执行(同一时刻只有一个)
11
Ready:     就绪态, 等待调度器分配 CPU
12
Blocked:   阻塞态, 等待事件(队列/信号量/延时)
13
Suspended: 挂起态, 只有 vTaskResume() 才能恢复

1
/* 动态创建(推荐初学) */
2
TaskHandle_t task_handle;
3
BaseType_t ret = xTaskCreate(
4
    task_function,       /* 任务函数指针 */
5
    "TaskName",          /* 任务名(调试用) */
6
    256,                 /* 栈大小(单位: word, 即 256×4=1024字节) */
7
    (void *)param,       /* 传入参数 */
8
    2,                   /* 优先级(数字越大越高) */
9
    &task_handle         /* 任务句柄(可为 NULL) */
10
);
11

12
/* 任务函数: 必须是死循环或删除自己 */
13
void task_function(void *pvParameters) {
14
    for (;;) {
15
        /* 任务逻辑 */
4 collapsed lines
16
        vTaskDelay(pdMS_TO_TICKS(100));  /* 延时 100ms */
17
    }
18
    /* 绝对不能 return！可以 vTaskDelete(NULL) 删除自己 */
19
}

1
/* 静态创建: 栈和TCB由用户提供, 不需要 heap */
2
static StaticTask_t task_tcb;
3
static StackType_t task_stack[256];
4

5
TaskHandle_t h = xTaskCreateStatic(
6
    task_func, "Static", 256,
7
    NULL, 2,
8
    task_stack,   /* 用户提供的栈数组 */
9
    &task_tcb     /* 用户提供的 TCB */
10
);
11

12
/* 需要在 FreeRTOSConfig.h 中:
13
   #define configSUPPORT_STATIC_ALLOCATION  1
14
   并且实现 vApplicationGetIdleTaskMemory() */

1
/* 优先级 0, 系统自动创建, 不可删除 */
2
/* 作用:
3
   1. 回收已删除任务的内存
4
   2. 低功耗：执行空闲钩子进入睡眠
5

6
/* 空闲钩子: */
7
void vApplicationIdleHook(void) {
8
    /* 可以在这里: 进入低功耗/喂看门狗/统计CPU空闲率 */
9
    /* 不能阻塞! 不能调用任何可能阻塞的 API */
10
    __WFI();  /* ARM 等待中断指令, 进入睡眠 */
11
}
12
/* 需要 configUSE_IDLE_HOOK = 1 */

1
/* vTaskDelay: 相对延时(从调用时刻起) */
2
void task(void *p) {
3
    for (;;) {
4
        do_work();         /* 假设耗时 20ms */
5
        vTaskDelay(pdMS_TO_TICKS(100));  /* 延时100ms, 总周期=120ms */
6
    }
7
}
8

9
/* vTaskDelayUntil: 绝对延时(精确周期) */
10
void task(void *p) {
11
    TickType_t xLastWakeTime = xTaskGetTickCount();
12
    for (;;) {
13
        do_work();         /* 假设耗时 20ms */
14
        vTaskDelayUntil(&xLastWakeTime, pdMS_TO_TICKS(100));
15
        /* 总周期精确 100ms (下次唤醒 = 上次唤醒 + 100ms) */
2 collapsed lines
16
    }
17
}

1
int main(void) {
2
    HAL_Init();
3
    SystemClock_Config();
4

5
    /* 创建任务 */
6
    xTaskCreate(task1, "T1", 256, NULL, 2, NULL);
7
    xTaskCreate(task2, "T2", 256, NULL, 1, NULL);
8

9
    /* 启动调度器 — 永不返回！ */
10
    vTaskStartScheduler();
11

12
    /* 到不了这里, 除非堆内存不足导致 Idle 任务创建失败 */
13
    for (;;);
14
}

1
#define configUSE_PREEMPTION           1    /* 1=抢占式, 0=协作式 */
2
#define configUSE_TIME_SLICING         1    /* 同优先级时间片轮转 */
3
#define configCPU_CLOCK_HZ             168000000  /* CPU 频率 */
4
#define configTICK_RATE_HZ             1000  /* Tick 频率(1ms) */
5
#define configMAX_PRIORITIES           5
6
#define configMINIMAL_STACK_SIZE       128   /* 最小栈(word) */
7
#define configTOTAL_HEAP_SIZE          (32*1024) /* 堆大小 */
8
#define configMAX_TASK_NAME_LEN        16
9

10
#define configUSE_MUTEXES              1
11
#define configUSE_COUNTING_SEMAPHORES  1
12
#define configUSE_QUEUE_SETS           1
13
#define configUSE_TASK_NOTIFICATIONS   1
14

15
/* Cortex-M 中断优先级 */
3 collapsed lines
16
#define configLIBRARY_LOWEST_INTERRUPT_PRIORITY       15
17
#define configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY   5
18
/* 优先级 0~4 的中断不受 FreeRTOS 管理(更高优先级) */

1
BaseType_t ret = xTaskCreate(myTask, "Task1", 256,
2
    NULL, 2, &taskHandle);
3
configASSERT(ret == pdPASS);
4

5
void myTask(void *param) {
6
    for (;;) {
7
        /* 任务主体 */
8
        vTaskDelay(pdMS_TO_TICKS(100));
9
    }
10
}

1
时间片轮转(Round-Robin)原理:
2

3
优先级相同的任务A、B、C:
4

5
  时间片=1tick
6
  ┌──A──┐┌──B──┐┌──C──┐┌──A──┐┌──B──┐┌──C──┐
7
  │     ││     ││     ││     ││     ││     │
8
  └─────┘└─────┘└─────┘└─────┘└─────┘└─────┘
9
  ← 1tick→← 1tick→← 1tick→...
10

11
配置: configUSE_TIME_SLICING = 1 (默认开启)
12
每个Tick中断时，调度器检查就绪列表:
13
  - 有更高优先级任务？ → 切换到高优先级
14
  - 同优先级有其他任务？ → 轮转到下一个
15
  - 否则继续当前任务

1
void myTask(void *param) {
2
    for (;;) {
3
        vTaskDelay(pdMS_TO_TICKS(500));  /* 释放CPU 500ms */
4
    }
5
}
6
/* 精确周期任务 */
7
void periodicTask(void *param) {
8
    TickType_t xLastWake = xTaskGetTickCount();
9
    for (;;) {
10
        vTaskDelayUntil(&xLastWake, pdMS_TO_TICKS(100));
11
    }
12
}

1
/* Tickless 低功耗模式 */
2

3
// 配置:
4
// #define configUSE_TICKLESS_IDLE  1
5

6
/* 原理:
7
 * 正常: 每1ms一次SysTick中断(即使CPU空闲也会唤醒)
8
 * Tickless: 空闲时关闭SysTick，用RTC/LPTIM唤醒
9
 *
10
 * 空闲任务检测:
11
 *   所有任务阻塞 → 计算最近唤醒时间T
12
 *   → 配置低功耗定时器到T
13
 *   → 进入 WFI/STOP 模式
14
 *   → 唤醒后补偿Tick计数
15
 */
16 collapsed lines
16

17
/* 自定义Tickless实现(STM32 STOP模式) */
18
void vPortSuppressTicksAndSleep(TickType_t xExpectedIdleTime) {
19
    /* 计算睡眠时间(tick转ms) */
20
    uint32_t sleep_ms = xExpectedIdleTime * portTICK_PERIOD_MS;
21

22
    /* 配置RTC唤醒(低功耗定时器) */
23
    HAL_RTCEx_SetWakeUpTimer_IT(&hrtc, sleep_ms, RTC_WAKEUPCLOCK_CK_SPRE_16BITS);
24

25
    /* 进入STOP模式 */
26
    HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
27

28
    /* 唤醒：恢复时钟 + 补偿tick */
29
    SystemClock_Config();
30
    vTaskStepTick(xExpectedIdleTime);
31
}

1
/* vTaskDelete 删除任务 */
2

3
TaskHandle_t task_handle;
4

5
void worker_task(void *param) {
6
    while (1) {
7
        // 工作...
8
        if (should_exit) {
9
            vTaskDelete(NULL);  // 删除自己(传NULL)
10
            // 此后代码不会执行
11
        }
12
        vTaskDelay(100);
13
    }
14
}
15

22 collapsed lines
16
void manager_task(void *param) {
17
    // 创建工作任务
18
    xTaskCreate(worker_task, "Worker", 256, NULL, 2, &task_handle);
19

20
    vTaskDelay(5000);
21

22
    // 从外部删除任务
23
    if (task_handle != NULL) {
24
        vTaskDelete(task_handle);
25
        task_handle = NULL;
26
    }
27
}
28

29
/*
30
 * 注意事项:
31
 * 1. 删除自己: 内存由空闲任务回收(idle task)
32
 * 2. 删除别人: 内存由调用者上下文立即回收
33
 * 3. 被删除任务申请的资源(malloc/信号量)不会自动释放!
34
 *    → 必须在删除前手动清理
35
 * 4. 空闲任务优先级最低,如果其他任务不让出CPU,
36
 *    被删任务的内存可能一直无法回收 → 内存泄漏!
37
 */

1
/* 任务挂起/恢复 */
2

3
TaskHandle_t sensor_task_handle;
4

5
void sensor_task(void *param) {
6
    while (1) {
7
        read_sensor();
8
        process_data();
9
        vTaskDelay(pdMS_TO_TICKS(100));
10
    }
11
}
12

13
/* 在另一个任务中控制 */
14
void control_task(void *param) {
15
    while (1) {
19 collapsed lines
16
        if (enter_low_power) {
17
            vTaskSuspend(sensor_task_handle);   // 挂起:从就绪列表移除
18
            // 传感器任务不再运行
19
        }
20
        if (exit_low_power) {
21
            vTaskResume(sensor_task_handle);    // 恢复:重新加入就绪列表
22
        }
23
        vTaskDelay(1000);
24
    }
25
}
26

27
/* 中断中恢复任务 */
28
void EXTI_IRQHandler(void) {
29
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
30
    xTaskResumeFromISR(sensor_task_handle);  // ISR版本
31
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
32
}
33

34
/* vTaskSuspend(NULL) = 挂起自己 → 需要别人来Resume */

1
/* 栈水位检查——检测任务栈使用峰值 */
2

3
// 需配置: #define configCHECK_FOR_STACK_OVERFLOW  2
4
//         #define INCLUDE_uxTaskGetStackHighWaterMark 1
5

6
void monitor_task(void *param) {
7
    while (1) {
8
        UBaseType_t mark;
9

10
        mark = uxTaskGetStackHighWaterMark(sensor_task_handle);
11
        printf("Sensor stack free: %lu words (%lu bytes)\r\n",
12
               mark, mark * sizeof(StackType_t));
13

14
        mark = uxTaskGetStackHighWaterMark(comm_task_handle);
15
        printf("Comm stack free: %lu words (%lu bytes)\r\n",
14 collapsed lines
16
               mark, mark * sizeof(StackType_t));
17

18
        mark = uxTaskGetStackHighWaterMark(NULL);  // 当前任务
19
        printf("Monitor stack free: %lu words\r\n", mark);
20

21
        /* 栈使用率评估:
22
         * 分配256 words, 水位线=30 → 使用了226 → 88%
23
         * 建议水位线 > 总栈的 20% (安全余量)
24
         * 水位线 < 10% → 危险! 需要加大栈
25
         */
26

27
        vTaskDelay(pdMS_TO_TICKS(5000));
28
    }
29
}

1
/* 查询任务状态 */
2

3
void print_task_state(TaskHandle_t handle, const char *name) {
4
    eTaskState state = eTaskGetState(handle);
5
    const char *state_str;
6
    switch (state) {
7
        case eRunning:   state_str = "Running";   break;
8
        case eReady:     state_str = "Ready";     break;
9
        case eBlocked:   state_str = "Blocked";   break;
10
        case eSuspended: state_str = "Suspended"; break;
11
        case eDeleted:   state_str = "Deleted";   break;
12
        default:         state_str = "Unknown";   break;
13
    }
14
    printf("Task %-12s: %s\r\n", name, state_str);
15
}
16 collapsed lines
16

17
/*
18
 * 状态转换图:
19
 *            创建
20
 *              │
21
 *              ▼
22
 *  ┌──────► Ready ◄───────┐
23
 *  │          │            │
24
 *  │   调度器选中↓     事件到达│
25
 *  │          ▼            │
26
 *  │       Running ──────► Blocked
27
 *  │       │  │            (等待队列/信号量/延时)
28
 *  │  Yield│  │Suspend
29
 *  │       │  ▼
30
 *  └───────┘ Suspended ──(Resume)──► Ready
31
 */

1
Name          State  Priority  Stack  Num
2
IDLE          R      0         112    1
3
LED_Task      B      2         84     2
4
UART_Task     B      3         210    3

1
Name          Abs.Time    %Time
2
UART_Task     34562       45%
3
LED_Task      8923        11%
4
IDLE          33515       44%

1
/* 任务通知 vs 队列/信号量 性能对比 */
2

3
/* 任务通知(45%更快, RAM少) */
4
void task_notify_example(void *param) {
5
    uint32_t value;
6
    // 等待通知(替代二值信号量)
7
    xTaskNotifyWait(0, ULONG_MAX, &value, portMAX_DELAY);
8
    // 或更简洁:
9
    ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
10
}
11
void ISR_handler(void) {
12
    BaseType_t woken = pdFALSE;
13
    vTaskNotifyGiveFromISR(task_handle, &woken);
14
    portYIELD_FROM_ISR(woken);
15
}
12 collapsed lines
16

17
/* 限制: 任务通知是"直接到任务"的
18
 * ① 只能有一个接收者(1对1)
19
 * ② 发送方不能阻塞等待(无"满"概念)
20
 * ③ 不能广播给多个任务
21
 *
22
 * 选型:
23
 *   ISR唤醒单个任务 → 任务通知(最快)
24
 *   多生产者多消费者 → 队列
25
 *   资源互斥     → Mutex
26
 *   多事件等待   → 事件组
27
 */

1
ARM Cortex-M 上下文切换保存内容:
2

3
硬件自动压栈(进入异常时):         软件保存(PendSV中):
4
┌────────────────┐ ← PSP(高)    ┌────────────────┐
5
│      xPSR      │              │       R4       │
6
│       PC       │              │       R5       │
7
│       LR       │              │       R6       │
8
│       R12      │              │       R7       │
9
│       R3       │              │       R8       │
10
│       R2       │              │       R9       │
11
│       R1       │              │      R10       │
12
│       R0       │              │      R11       │
13
└────────────────┘              └────────────────┘
14
  8个寄存器(自动)                 8个寄存器(手动)
15

8 collapsed lines
16
总共: 16个32位寄存器 = 64字节
17

18
如果使用FPU(浮点):
19
  还需保存 S0~S15 + FPSCR = 额外68字节
20
  configUSE_TASK_FPU_SUPPORT 控制
21

22
TCB中记录每个任务的栈顶指针(pxTopOfStack)
23
  切换时: 保存当前PSP → TCB → 选新任务 → 从新TCB取PSP → 恢复

1
PendSV 在 FreeRTOS 调度中的角色:
2

3
为什么不在 SysTick 中直接切换？
4
  SysTick优先级可能打断其他ISR → 中断嵌套问题!
5

6
解决: PendSV 设为最低优先级
7

8
  SysTick中断(高优先级)         PendSV(最低优先级)
9
  ┌──────────────────┐         ┌──────────────────┐
10
  │ 判断是否需要调度  │         │ 保存R4-R11到旧栈 │
11
  │ if(需要) {       │ ──set──►│ 更新TCB栈指针    │
12
  │   设置PendSV标志 │  pend   │ 选择新任务       │
13
  │ }                │         │ 从新栈恢复R4-R11 │
14
  │ 不做上下文切换!  │         │ **上下文切换**   │
15
  └──────────────────┘         └──────────────────┘
6 collapsed lines
16

17
时序:
18
  ┌─SysTick─┐ ┌─其他ISR─┐ ┌─PendSV─┐
19
  │ set pend│ │ ...     │ │ 切换   │
20
  └─────────┘ └─────────┘ └────────┘
21
  ← 先处理所有高优先级中断 → 最后才做上下文切换

1
taskENTER_CRITICAL();    /* 关闭优先级 <= configMAX_SYSCALL_INTERRUPT_PRIORITY 的中断 */
2
shared_data++;           /* 安全地修改共享数据 */
3
taskEXIT_CRITICAL();     /* 恢复中断 */

1
/* 任务栈大小确定方法 */
2

3
/*
4
 * 方法1: 先给大值，运行后检查水位线
5
 */
6
#define INITIAL_STACK  512  // 先给大
7

8
xTaskCreate(my_task, "task", INITIAL_STACK, NULL, 2, &handle);
9
// 运行一段时间后:
10
UBaseType_t free = uxTaskGetStackHighWaterMark(handle);
11
// 实际使用 = INITIAL_STACK - free
12
// 最终栈 = 实际使用 × 1.5 ~ 2.0 (安全余量)
13

14
/*
15
 * 方法2: 估算
13 collapsed lines
16
 * 任务栈消耗 = 上下文保存(16寄存器=64B)
17
 *            + 局部变量
18
 *            + 函数调用深度 × 每层开销
19
 *            + 中断嵌套(Cortex-M用MSP,不占任务栈)
20
 *            + printf/sprintf(可能需要200~500B!)
21
 *
22
 * 经验值(STM32 Cortex-M):
23
 *   简单任务(LED闪烁): 64~128 words
24
 *   普通任务(传感器读取): 128~256 words
25
 *   通信任务(含缓冲区): 256~512 words
26
 *   使用printf的任务:  512~1024 words
27
 *   使用浮点的任务:    额外+32 words (FPU寄存器)
28
 */

1
/* FreeRTOS 栈溢出检测 */
2

3
// 方法1: 检查 PSP 是否超出栈边界
4
// #define configCHECK_FOR_STACK_OVERFLOW  1
5
// 每次上下文切换时检查 PSP
6

7
// 方法2: 检查栈底pattern是否被破坏(推荐)
8
// #define configCHECK_FOR_STACK_OVERFLOW  2
9
// 创建任务时栈底填充 0xA5A5A5A5
10
// 每次切换检查这些pattern是否完好
11

12
/* 溢出回调(两种方法都用这个回调) */
13
void vApplicationStackOverflowHook(TaskHandle_t xTask, char *pcTaskName) {
14
    /* 运行到这里说明已经溢出！ */
15
    printf("Stack overflow in task: %s\r\n", pcTaskName);
15 collapsed lines
16

17
    /* 选择处理方式: */
18
    // 1. 记录到Flash后复位
19
    log_error_to_flash(pcTaskName);
20
    NVIC_SystemReset();
21

22
    // 2. 或者死循环等待调试器
23
    // while (1) { __BKPT(0); }
24
}
25

26
/* 注意:
27
 * 方法2只检查栈底16字节的pattern → 不是100%可靠
28
 * 如果溢出跳过了pattern区域(大数组),仍可能逃检
29
 * 推荐配合MPU做硬件栈保护
30
 */

1
void vApplicationStackOverflowHook(TaskHandle_t xTask, char *pcTaskName) {
2
    printf("Stack overflow in task: %s\n", pcTaskName);
3
    while (1);  /* 死循环, 方便调试器断在这里 */
4
}

1
/* 队列 = FIFO 缓冲区, 任务安全(ISR 安全) */
2
QueueHandle_t q = xQueueCreate(10, sizeof(int));  /* 10个元素, 每个 int */
3

4
/* 发送(写入队列尾部) */
5
int val = 42;
6
xQueueSend(q, &val, pdMS_TO_TICKS(100));  /* 阻塞最多 100ms */
7
xQueueSendToFront(q, &val, 0);            /* 写入队列头部 */
8

9
/* 接收(从队列头部读取) */
10
int received;
11
if (xQueueReceive(q, &received, portMAX_DELAY) == pdTRUE) {
12
    /* 成功收到 */
13
}
14

15
/* portMAX_DELAY = 永久等待(需 INCLUDE_vTaskSuspend=1) */

1
/* ISR 中必须使用 FromISR 后缀的 API */
2
void USART1_IRQHandler(void) {
3
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
4
    uint8_t ch = USART1->DR;
5

6
    xQueueSendFromISR(rx_queue, &ch, &xHigherPriorityTaskWoken);
7

8
    /* 如果唤醒了更高优先级任务, 触发上下文切换 */
9
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
10
}

1
/* 只查看不取走 */
2
int val;
3
xQueuePeek(q, &val, 0);  /* 队列中的元素仍然保留 */
4
c
5
// xQueuePeek vs xQueueReceive 的区别
6
BaseType_t xQueuePeek(QueueHandle_t xQueue,
7
                       void *pvBuffer,
8
                       TickType_t xTicksToWait);
9

10
// xQueueReceive: 读取并移除队头元素(出队)
11
// xQueuePeek:    只读取队头元素,不移除(偷看)
12

13
// 典型场景：多个任务需要读取同一条消息
14
// Task A 用 Peek 查看命令但不取走，Task B 也能读到同一条命令
15
xQueuePeek(xCmdQueue, &cmd, portMAX_DELAY);  // 不会删除队列中的数据
4 collapsed lines
16
// 下次Peek还是同一条数据，除非有人xQueueReceive取走了
17

18
// 注意：如果队列为空，Peek和Receive一样会阻塞等待
19
// Peek适用于"广播式"读取——一条消息被多个消费者查看

1
/* 同时等待多个队列/信号量 */
2
QueueSetHandle_t set = xQueueCreateSet(10 + 1);
3
xQueueAddToSet(queue1, set);
4
xQueueAddToSet(sem1, set);
5

6
QueueSetMemberHandle_t member = xQueueSelectFromSet(set, portMAX_DELAY);
7
if (member == queue1) {
8
    xQueueReceive(queue1, &data, 0);
9
} else if (member == (QueueSetMemberHandle_t)sem1) {
10
    xSemaphoreTake(sem1, 0);
11
}

1
/* 邮箱: 长度为 1 的队列, 用 xQueueOverwrite 覆盖 */
2
QueueHandle_t mailbox = xQueueCreate(1, sizeof(SensorData));
3
xQueueOverwrite(mailbox, &latest_data);  /* 总是成功, 覆盖旧值 */
4
xQueuePeek(mailbox, &data, portMAX_DELAY);  /* 读取不删除 */
5

6
/* 传指针(大结构体): 注意内存生命周期！ */
7
BigData *p = pvPortMalloc(sizeof(BigData));
8
/* 填充 p */
9
xQueueSend(q, &p, portMAX_DELAY);  /* 发送指针, 4字节 */
10
/* 接收端: */
11
BigData *received;
12
xQueueReceive(q, &received, portMAX_DELAY);
13
/* 使用 received 后必须 vPortFree(received) */

1
/* 队列 vs 全局变量 */
2

3
/* 全局变量: 无保护, 竞态风险 */
4
volatile int shared = 0;
5
// Task A: shared = value;       // 可能被Task B中途打断
6
// Task B: local = shared;       // 可能读到不完整数据
7

8
/* 队列: 线程安全 + 阻塞机制 */
9
QueueHandle_t q = xQueueCreate(10, sizeof(int));
10
// Task A: xQueueSend(q, &value, portMAX_DELAY);  // 满则等待
11
// Task B: xQueueReceive(q, &local, portMAX_DELAY); // 空则等待
12

13
/* 队列优势:
14
 * ✓ 内部有临界区保护(关中断)
15
 * ✓ 满/空时自动阻塞任务(省CPU)
5 collapsed lines
16
 * ✓ 支持多读多写
17
 * ✓ 数据拷贝(值传递, 无悬挂指针风险)
18
 *
19
 * 全局变量: 仅适合ISR设置简单标志(配合volatile)
20
 */

1
/* 队列满了的处理策略 */
2

3
int value = 42;
4

5
/* 策略1: 阻塞等待(常用) */
6
xQueueSend(q, &value, portMAX_DELAY);  // 一直等到有空位
7

8
/* 策略2: 超时等待 */
9
if (xQueueSend(q, &value, pdMS_TO_TICKS(100)) != pdPASS) {
10
    // 100ms后仍然满 → 丢弃/报警/扩展
11
}
12

13
/* 策略3: 不等待(ISR中必须用) */
14
BaseType_t woken = pdFALSE;
15
xQueueSendFromISR(q, &value, &woken);
9 collapsed lines
16
// 满则直接失败, 中断不能阻塞!
17

18
/* 策略4: 覆盖最旧(邮箱模式) */
19
xQueueOverwrite(q, &value);  // 覆盖队列中的值(队列深度=1时用)
20

21
/* 预防:
22
 * 合理设计队列深度
23
 * 消费者优先级 ≥ 生产者(及时消费)
24
 */

1
/* 多任务等待同一队列: 按优先级唤醒 */
2

3
/* FreeRTOS规则:
4
 * 多个任务xQueueReceive等待同一队列时,
5
 * 数据到来 → 唤醒优先级最高的等待任务
6
 * 同优先级 → 唤醒等待时间最长的任务(FIFO)
7
 */
8

9
void TaskHigh(void *p) {  // 优先级3
10
    int val;
11
    xQueueReceive(q, &val, portMAX_DELAY);  // 先被唤醒!
12
}
13

14
void TaskLow(void *p) {   // 优先级1
15
    int val;
9 collapsed lines
16
    xQueueReceive(q, &val, portMAX_DELAY);  // 后被唤醒
17
}
18

19
void Producer(void *p) {
20
    int data = 100;
21
    xQueueSend(q, &data, portMAX_DELAY);
22
    // → TaskHigh被唤醒(优先级高)
23
    // TaskLow继续等待下一次send
24
}

1
/* xQueueReset: 清空队列中所有数据 */
2

3
xQueueReset(myQueue);
4

5
/* 效果:
6
 * 1. 清空队列中的所有消息
7
 * 2. 重置读/写指针到初始状态
8
 * 3. 不释放队列本身的内存
9
 *
10
 * 注意:
11
 * 如果有任务在等待接收(xQueueReceive阻塞) → 不会被唤醒
12
 * 如果有任务在等待发送(队列之前满) → 会被唤醒(现在有空间了)
13
 *
14
 * 使用场景:
15
 * 系统状态切换时, 清除旧数据避免干扰
2 collapsed lines
16
 * 例: 模式从"运行"切到"待机", 清空命令队列
17
 */

1
/* 队列存储位置 */
2

3
/* FreeRTOS队列在创建时从堆中分配: */
4
QueueHandle_t q = xQueueCreate(10, sizeof(int));
5

6
/* 内部结构(简化):
7
 * ┌────────────────────────────────┐
8
 * │ Queue_t 控制块(≈76字节):      │
9
 * │   头指针/尾指针/当前元素数     │  ← 堆上分配
10
 * │   等待发送/接收的任务链表      │
11
 * │   队列长度/元素大小            │
12
 * ├────────────────────────────────┤
13
 * │ 数据存储区:                    │
14
 * │   10 × sizeof(int) = 40字节   │  ← 紧跟控制块后面
15
 * └────────────────────────────────┘
6 collapsed lines
16
 *
17
 * 静态分配(不用堆):
18
 * StaticQueue_t qBuf;
19
 * uint8_t storage[10 * sizeof(int)];
20
 * q = xQueueCreateStatic(10, sizeof(int), storage, &qBuf);
21
 */

1
StreamBufferHandle_t sb = xStreamBufferCreate(256, 1);
2
/* 256字节缓冲，触发字节=1: 有1字节就唤醒接收者 */
3
xStreamBufferSend(sb, data, len, portMAX_DELAY);   /* 发送 */
4
xStreamBufferReceive(sb, buf, sizeof(buf), portMAX_DELAY); /* 接收 */

1
/* MessageBuffer: 变长消息缓冲区 */
2

3
#include "message_buffer.h"
4

5
MessageBufferHandle_t mb = xMessageBufferCreate(256);  // 256字节总缓冲
6

7
/* 发送变长消息 */
8
char msg1[] = "short";
9
char msg2[] = "this is a longer message";
10
xMessageBufferSend(mb, msg1, strlen(msg1), portMAX_DELAY);
11
xMessageBufferSend(mb, msg2, strlen(msg2), portMAX_DELAY);
12

13
/* 接收 */
14
char rxbuf[128];
15
size_t len = xMessageBufferReceive(mb, rxbuf, sizeof(rxbuf), portMAX_DELAY);
7 collapsed lines
16
// len = 实际消息长度
17

18
/* vs Queue:
19
 * Queue: 固定大小元素, 10 × sizeof(Msg)
20
 * MessageBuffer: 变长消息, 每条消息前有4字节长度头
21
 * 限制: 只支持1个发送者+1个接收者!
22
 */

1
/* StreamBuffer vs Queue */
2

3
/* StreamBuffer: 字节流(无消息边界) */
4
StreamBufferHandle_t sb = xStreamBufferCreate(256, 1);
5
// 256=总大小, 1=触发字节数
6

7
xStreamBufferSend(sb, data, 10, portMAX_DELAY);
8
size_t n = xStreamBufferReceive(sb, buf, sizeof(buf), portMAX_DELAY);
9
// 可能收到1~sizeof(buf)任意字节数
10

11
/* 对比:
12
 * Queue:         固定大小元素, 边界清晰, 多对多
13
 * StreamBuffer:  字节流, 无边界, 1对1
14
 * MessageBuffer: 变长消息, 有边界, 1对1
15
 *
5 collapsed lines
16
 * 选型:
17
 * 结构化数据(固定格式)   → Queue
18
 * 串口字节流(不定长)     → StreamBuffer
19
 * 变长命令/JSON         → MessageBuffer
20
 */