FreeRTOS的基本概念与其任务间通信方式

最新推荐文章于 2026-01-06 09:20:43 发布
原创 最新推荐文章于 2026-01-06 09:20:43 发布 · 1.4k 阅读 · 16 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测

记录贴：记录学习RTOS中遇到的问题

一、FreeRTOS的基本概念

（1）如何理解裸机开发与操作系统？

        在传统裸机开发中，程序通常围绕一个主循环 while(1) 构建，任务间通过状态判断和轮询处理事件。这种方式虽然简单直观，但在多任务并发、实时性需求强的场景下效率低下，易造成资源浪费，任务优先级难以管理。

        FreeRTOS 是一种轻量级实时操作系统，提供了任务（Task）调度机制，使不同功能模块能并发独立执行。通过任务优先级、时间片、信号量、队列、事件组等机制，系统可以精准控制任务执行顺序和时机。与裸机相比，FreeRTOS 更易组织复杂逻辑，提高系统响应速度与代码可维护性。

        FreeRTOS 将 CPU 时间更合理分配给多个任务，避免了“轮询死”等问题，适合对多任务协调、资源同步、响应实时性要求较高的嵌入式系统开发。

（2）FreeRTOS 的任务调度核心思想

  • 优先级抢占调度为主（Preemptive）

    • 系统总是运行“当前就绪状态中优先级最高”的任务。

    • 一旦有更高优先级的任务就绪，当前低优先级任务会立即被中断挂起。

    • 这是 FreeRTOS 默认的调度模式。

  • 时间片轮转调度（Time Slicing）为辅

    • 如果多个任务的优先级相同，FreeRTOS 会将 CPU 时间平均分配给这些任务（也就是“时间片”）。

    • 每个任务在一个“滴答周期”（tick）内运行，到了时间就切换下一个同级任务。

（3）学习路线

二、任务间的通信方式

（1）消息队列

        消息队列（Message Queue）是 FreeRTOS 中任务间通信的一种机制，用于在任务、定时器或中断之间传递数据。它像一个“邮箱”或“排队窗口”，允许任务之间 发送（send）和接收（receive）消息，以此实现任务解耦和数据同步。

在STM32中使用：

        在cubemx中配置，

在keil中添加以下代码，实现任务间数据的通信。

#include "cmsis_os.h"
#include "usart.h"
#include <stdio.h>
#include "string.h"
osThreadId_t SenderTaskHandle;
osThreadId_t ReceiverTaskHandle;
osMessageQueueId_t myQueueHandle;

// 任务函数声明
void SenderTask(void *argument);
void ReceiverTask(void *argument);

void MX_FREERTOS_Init(void) {
  // 创建队列：10个元素，每个为uint32_t大小
  myQueueHandle = osMessageQueueNew(10, sizeof(uint32_t), NULL);

  // 创建任务
  SenderTaskHandle = osThreadNew(SenderTask, NULL, NULL);
  ReceiverTaskHandle = osThreadNew(ReceiverTask, NULL, NULL);
}

void SenderTask(void *argument) {
  uint32_t count = 0;
  for (;;) {
    osMessageQueuePut(myQueueHandle, &count, 0, 0);
    count++;
    osDelay(1000);
  }
}

void ReceiverTask(void *argument) {
  uint32_t received;
  for (;;) {
    if (osMessageQueueGet(myQueueHandle, &received, NULL, osWaitForever) == osOK) {
      char msg[64];
      sprintf(msg, "Received: %lu\r\n", received);
      HAL_UART_Transmit(&hlpuart1, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
    }
  }
}

现象就是在SenderTask中发送count的值，在ReceiverTask中接受，并通过串口打印。

事实上通信队列的使用就只包含三部分：1.创建队列。2.创建任务。3在任务中发送与接收

（2）二值信号量

        信号量（Semaphore）是 FreeRTOS 中用于任务间同步与资源互斥的一种机制，常用于控制任务执行顺序或访问共享资源时避免冲突。

在cubemx中配置：

在keil中添加代码：

在中断函数中添加按键中断处理函数 发送信号

在app_freertos.c中添加以下代码：


#include "FreeRTOS.h"
#include "task.h"
#include "main.h"
#include "cmsis_os.h"

#include "stdio.h"
#include "queue.h"
#include "semphr.h"
#include "event_groups.h"

#define BIT_0 (1 << 0)
#define BIT_1 (1 << 1)

osThreadId_t Task1Handle;
const osThreadAttr_t Task1_attributes = {
  .name = "Task1",
  .priority = (osPriority_t) osPriorityNormal,
  .stack_size = 128 * 4
};
/* Definitions for Task2 */
osThreadId_t Task2Handle;
const osThreadAttr_t Task2_attributes = {
  .name = "Task2",
  .priority = (osPriority_t) osPriorityHigh,
  .stack_size = 128 * 4
};
/* Definitions for myBinarySem01 */
osSemaphoreId_t myBinarySem01Handle;
const osSemaphoreAttr_t myBinarySem01_attributes = {
  .name = "myBinarySem01"
};

void SenderTask(void *argument);

void MX_FREERTOS_Init(void);

void MX_FREERTOS_Init(void) 
{
  myBinarySem01Handle = osSemaphoreNew(1, 1, &myBinarySem01_attributes);

  Task1Handle = osThreadNew(SenderTask, NULL, &Task1_attributes);

  Task2Handle = osThreadNew(ReceiverTask, NULL, &Task2_attributes);

}


void SenderTask(void *argument)
{
  /* USER CODE BEGIN SenderTask */
  /* Infinite loop */

  for(;;)
  {
    if (osSemaphoreAcquire(myBinarySem01Handle, osWaitForever) == osOK)
    {
      printf("按键被按下，打印一次信息\r\n");
    }
  }

  /* USER CODE END SenderTask */
}

现象为按下按键后任务接受到信号量通过串口打印信息。

（3）事件标志组

        事件标志组（Event Groups）是 FreeRTOS 提供的一种 任务同步机制，用于多个任务之间的事件通信与条件等待，它比信号量或消息队列更适合表达“等待多个事件条件”的场景。

  • 事件组：一个 EventGroupHandle_t 类型的变量，内部是 32 个二进制位（bit），每个 bit 表示一个事件。

  • 事件位（Event Bits）：每个任务可以设置或等待某个 bit 被置位（设为1），也可以清除某个 bit。多个任务可以 同时等待多个事件位

在cubemx中配置：

在keil中的app_freertos.c中添加代码：

#include "FreeRTOS.h"
#include "task.h"
#include "main.h"
#include "cmsis_os.h"

#include "stdio.h"
#include "queue.h"
#include "semphr.h"
#include "event_groups.h"


#define BIT_0 (1 << 0)
#define BIT_1 (1 << 1)

osThreadId_t Task1Handle;
const osThreadAttr_t Task1_attributes = {
  .name = "Task1",
  .priority = (osPriority_t) osPriorityNormal,
  .stack_size = 128 * 4
};
/* Definitions for Task2 */
osThreadId_t Task2Handle;
const osThreadAttr_t Task2_attributes = {
  .name = "Task2",
  .priority = (osPriority_t) osPriorityHigh,
  .stack_size = 128 * 4
};
/* Definitions for myBinarySem01 */
osSemaphoreId_t myBinarySem01Handle;
const osSemaphoreAttr_t myBinarySem01_attributes = {
  .name = "myBinarySem01"
};
/* Definitions for myEventGroup */
osEventFlagsId_t myEventGroupHandle;
const osEventFlagsAttr_t myEventGroup_attributes = {
  .name = "myEventGroup"
};


void SenderTask(void *argument);
void ReceiverTask(void *argument);

void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */

void MX_FREERTOS_Init(void) {
	
  myBinarySem01Handle = osSemaphoreNew(1, 1, &myBinarySem01_attributes);

	
  Task1Handle = osThreadNew(SenderTask, NULL, &Task1_attributes);

	
  Task2Handle = osThreadNew(ReceiverTask, NULL, &Task2_attributes);
	
  myEventGroupHandle = osEventFlagsNew(&myEventGroup_attributes);

}

void SenderTask(void *argument)
{
  for(;;)
  {
		xEventGroupSetBits(myEventGroupHandle, BIT_0);
		printf("发送成功\n");
		osDelay(1000);
  }
}

void ReceiverTask(void *argument)
{
  for(;;)
  {
		if (osSemaphoreAcquire(myBinarySem01Handle, osWaitForever) == osOK)
    {
            EventBits_t bits = xEventGroupWaitBits(
            myEventGroupHandle,
            BIT_0,
            pdTRUE,    // 清除标志
            pdFALSE,   // OR关系
            portMAX_DELAY);
        if (bits & BIT_0) {
            HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
        }
			printf("同步成功\n");
		}
  }
}

现象：任务一发送标志去告诉任务二翻转LED灯。LED灯以1秒的间隔闪烁。

（4）互斥量

        互斥量（Mutex）是一种特殊的信号量，用来保护共享资源，防止多个任务“同时访问”造成数据冲突。

核心特点：

在stm32中使用：

在keil中添加代码：

  • 同一时刻只能被一个任务拥有；

  • 其他任务只能等待；

  • 通常用于保护临界区（例如：共享的全局变量、外设资源）；

  • 支持 优先级继承机制，避免优先级反转问题

#include "FreeRTOS.h"
#include "task.h"
#include "main.h"
#include "cmsis_os.h"

#include "string.h"

int counter = 0;

osThreadId_t Task1Handle;
const osThreadAttr_t Task1_attributes = {
  .name = "Task1",
  .priority = (osPriority_t) osPriorityNormal,
  .stack_size = 128 * 4
};

osThreadId_t myTask02Handle;
const osThreadAttr_t myTask02_attributes = {
  .name = "myTask02",
  .priority = (osPriority_t) osPriorityLow,
  .stack_size = 128 * 4
};

osMutexId_t myMutex01Handle;
const osMutexAttr_t myMutex01_attributes = {
  .name = "myMutex01"
};


void SenderTask(void *argument);
void StartTask02(void *argument);
void myTimerCallback(void *argument);

void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */


void MX_FREERTOS_Init(void) {

  myMutex01Handle = osMutexNew(&myMutex01_attributes);


  Task1Handle = osThreadNew(SenderTask, NULL, &Task1_attributes);

  
  myTask02Handle = osThreadNew(StartTask02, NULL, &myTask02_attributes);


}

void SenderTask(void *argument)
{
  for(;;)
  {
    osMutexAcquire(myMutex01Handle, osWaitForever); // 请求互斥量
    counter++;
    printf("Task1: counter = %d\r\n", counter);
    osMutexRelease(myMutex01Handle); // 释放互斥量
    osDelay(500);
  }
}

void StartTask02(void *argument)
{
  for(;;)
  {
    osMutexAcquire(myMutex01Handle, osWaitForever);
    counter--;
    printf("Task2: counter = %d\r\n", counter);
    osMutexRelease(myMutex01Handle);
    osDelay(1000);
  }
}

现象：

当修改代码，任务一获取互斥量但是不释放后：

任务二被堵塞，无法再获取count的值。

三、软件定时器

        软件定时器是 FreeRTOS 提供的一个轻量级机制，用于在指定时间后触发一个回调函数，而不需要持续占用任务资源。

        它由 Timer Service Task 管理，并不直接占用 CPU。

在stm32中使用：

        cubemx中配置

在keil中添加代码：

#include "FreeRTOS.h"
#include "task.h"
#include "main.h"
#include "cmsis_os.h"


#include "string.h"

osThreadId_t Task1Handle;
const osThreadAttr_t Task1_attributes = {
  .name = "Task1",
  .priority = (osPriority_t) osPriorityNormal,
  .stack_size = 128 * 4
};
/* Definitions for myTimer01 */
osTimerId_t myTimer01Handle;
const osTimerAttr_t myTimer01_attributes = {
  .name = "myTimer01"
};


void SenderTask(void *argument);
void myTimerCallback(void *argument);

void MX_FREERTOS_Init(void); 


void MX_FREERTOS_Init(void) {


  myTimer01Handle = osTimerNew(myTimerCallback, osTimerPeriodic, NULL, &myTimer01_attributes);

  Task1Handle = osThreadNew(SenderTask, NULL, &Task1_attributes);

	osTimerStart(myTimer01Handle, 1000);

}


void SenderTask(void *argument)
{

  for(;;)
  {
    osDelay(500);
		printf("默认任务运行中...\r\n");
  }

}


void myTimerCallback(void *argument)
{

	printf("定时器触发了！\r\n");

}

现象：

定时器时间到了之后就会打印触发信息。当然，定时回调函数中可以写很多功能。

四、其他

（1）生产者消费者模型

        “生产者-消费者模型”是操作系统中任务/线程通信与同步的经典模式，用来解决两个任务之间的数据协作问题。

模型核心思想

  • 生产者（Producer）任务：负责“产生资源”（例如：数据、消息等），将资源放入一个缓冲区。

  • 消费者（Consumer）任务：负责“消费资源”，从缓冲区中取出资源并处理

  • 厨师 = 生产者
    他负责炒菜、做好食物，放到窗口。

  • 顾客 = 消费者
    你来窗口取餐。

但厨师做好饭前，你不能吃；窗口满了，厨师也不能继续放

在 FreeRTOS 中如何实现？：使用信号量（或消息队列）来控制：

  • 缓冲区空位：用计数信号量限制最多放入几个

  • 缓冲区是否有数据：用二值信号量或另一个计数信号量控制消费者是否能取

（2） osDelay是阻塞式的吗？在一个任务中写，另外一个任务会等待执行完吗？

osDelay() 是阻塞当前任务的函数，但不会阻塞其他任务的运行。

当某个任务调用 osDelay(n)（或 vTaskDelay(n)），它会进入阻塞态（Blocked）让出 CPU 控制权，直到延迟时间过去。

此时：当前任务不再占用 CPU。任务调度器会调度其他就绪任务（Ready）继续运行，不管是低优先级任务还是高优先级任务

（3）互斥量与volatile修饰的变量作用区分？

        volatile的作用是告诉 编译器 该变量可能会被中断、外部线程、外设等异步地修改，不要对该变量的读写操作进行优化（比如寄存器缓存、合并读写等）。本质上volatile解决的是编译器优化的问题，而不是线程安全问题。

        而互斥量（Mutex）的作用是防止多个线程同时访问共享资源（如变量、外设、文件等），从而避免竞态条件（数据错误、异常行为等）。本质上互斥量解决的是原子性 + 临界区保护问题。

        1.volatile仅仅是告知编译器不要优化访问方式，它不会同步数据访问；

        2.互斥量才是真正用于线程同步和资源保护的机制；

        3.在实际使用中，经常是两者配合使用（如 volatile bool flag + 互斥访问 flag 状态）。

标签
#FREERTOS #任务通信方式
STM32Cube高效开发教程＜高级篇＞＜FreeRTOS＞(七)-----进程间通信与消息队列
我的博客
10-14 278
表中有一组函数是用于获取队列信息的，例如，函数pcQucueGetName()返回队列的字符串名称，函数uxQueueSpacesAvailable()返回队列刹余空间个数，函数uxQueueMessagesWaiting()返回队列中等待被读取的消息的个数，这些函数的使用非常简单，这里就不详细介绍其函数原型了，在后面的示例里会用到其中的一些函数。所以，如果传递的是比较大的数据，例如，比较长的字符串或大的结构体，可以在队列的存储单元里存储需要传递数据的指针，通过指针再去读取原始数据。
FreeRTOS简介与移植到STM32F103
2402_87909669的博客
05-26 3069
直接对硬件资源进行编程，将所有的功能函数都放在主循环中，同一时间内只能运行单一任务。裸机系统又称：前台系统即中断服务函数，后台系统即运行的主循环。
FreeRTOS入门笔记——FreeRTOS介绍
ljt2333的博客
09-18 2820
FreeRTOS是一个迷你的实时操作系统内核。作为一个轻量级的操作系统，功能包括：任务管理、时间管理、信号量、消息队列、内存管理、记录功能、软件定时器、协程等，可基本满足较小系统的需要。
FreeRTOS基础（一）：FreeRTOS入门
weixin_47040031的博客
05-29 2万+
裸机：直接对硬件资源的编程，所有功能函数放在主循环中，同⼀时间只能单⼀任务运行。裸机又称为前后台系统，前台系统指的中断服务函数，后台系统指的大循环，即应用程序。RTOS是指一类系统，如 FreeRTOS，uC/OS，RTX，RT-Thread 等，都是 RTOS 类操作系统。FreeRTOS 是一个免费的嵌入式实时操作系统，其开源、轻量级、可移植的特点使其成为许多嵌入式开发者的首选。在近几年的使用排名上位居前列。
FreeRTOS(教程非常详细）
热门推荐
qq_61672347的博客
07-12 49万+
FreeRTOS基于STM32实时操作系统教程（非常详细）
一、FreeRTOS之FreeRTOS简介
王同学
01-11 2万+
一、什么是FreeRTOS？Free即免费的，RTOS的全称是Real time operating system,中文就是实时操作系统。注意：RTOS不是指某一个确定的系统，而是指一类操作系统。比如：uc/OS,FreeRTOS，RTX，RT-Thread等这些都是RTOS类操作系统。操作系统允许多个任务同时运行，这个叫做多任务。实际上，一个处理器核心在某一时刻只能运行一个任务。操作系统中任务调度器的责任就是决定在某一时刻究竟运行的哪个任务。任务调度在各个任务之间的切换非常快，就给人们造成了同一时刻有多个
FreeRTOS 任务通知（Task Notification）详解
rechol的博客
09-26 1448
任务通知是 FreeRTOS 中一种高效的进程间通信机制，它直接通过任务控制块（TCB）进行通信，无需创建额外的通信对象。B 不会被立即唤醒，但当 B 被其他方式唤醒后，如果调用等待通知函数，会立即接收通知。：ISR 没有任务结构体，无法接收任务通知（但 ISR 可以发送通知给任务）任务通知：直接通过任务本身的 TCB 进行通信，无需额外结构体。：通知值存储在目标任务 TCB 中，只有该任务能访问。使用任务通知时需要仔细管理通知状态，避免数据丢失。：在接收到通知并保存值后，清除通知值的指定位。
FreeRTOS基本概念
weixin_63277123的博客
09-30 601
任务，也称为线程，是 FreeRTOS 最基本的执行单元。
FreeRTOS学习：12.直达任务通知
weixin_45133943的博客
08-12 542
FreeRTOS中直达任务通知的简单介绍。
FreeRTOS记录（五、FreeRTOS任务通知）
不浮夸，不将就，认真对待学知识的我们
11-07 2987
在前面几篇文章我们已经对FreeRTOS任务API和任务调度原理进行了相对深入的分析 这篇文章主要针对任务与任务之间的交互，信息传递相关的API组件进行分析 一、任务通知 简单用官方的话介绍一下： FreeRTOS 的每个任务都有一个 32 位的通知值 在大多数情况下，任务通知可以 替代二值信号量、计数信号量、事件组，也可以替代长度为 1 的队列（可以保存一个 32 位整数或指针值） 使用任务通知比通过信号量等 ICP 通信方式解除阻塞的任务要快 45%，并且更加省 RAM 内存空间（使用 GCC 编译
15.FreeRTOS 消息缓存 Message Buffer
宁子希的博客
06-02 1631
消息缓存是 FreeRTOS 提供的一种数据结构，用于在任务之间传递变长消息。与队列不同，队列适合固定长度的数据项，而消息缓存可以处理长度可变的消息。这使得消息缓存非常适用于需要传递不同长度消息的场景，比如传输字符串或结构化数据。FreeRTOS 消息缓存通过在发送和接收消息时记录和读取消息长度，确保了消息的完整传递。这样的设计使得发送的数据和接收的数据大小相等，从而保证了任务间通信的一致性和可靠性。
2025最新超详细FreeRTOS入门教程：第八章 FreeRTOS任务通知
猫头虎技术团队：授渔优于赠鱼，兴趣引领智慧，探索之乐尤显珍贵。商务合作+：Libin9iOak ，万粉变现+：CSDNWF，猫头虎承诺每年免费为100名C站创作者做账号流量诊断服务！全网搜：猫头虎技术团队，点击文章底部名片或直接私信我一切皆可谈，快找虎哥！
09-09 1514
FreeRTOS任务通知是最轻量级的任务通信机制，每个任务自带32位通知值，无需额外内存开销。它支持二值信号量、计数信号量、事件标志和消息传递等多种用途，特别适合ISR与任务间的高效通信。关键API包括xTaskNotify()发送通知和xTaskNotifyWait()接收通知。相比队列和信号量，任务通知速度最快、内存占用最少，但不支持多任务等待。典型应用场景包括中断触发任务、轻量级任务间通信等。开发中需注意避免通知丢失，并根据实际需求选择覆盖或累积模式。任务通知是FreeRTOS实时性要求高场景下的最优
FreeRTOS——消息队列篇
顺顺崽的博客
07-09 1704
消息队列在FreeRTOS中的特点使其成为任务间通信、数据缓冲、同步和调度的重要工具。其线程安全性、FIFO顺序、阻塞和超时机制、优先级继承、灵活配置、中断支持、多任务支持、优先级队列等特性，确保了系统的稳定性和性能。
FreeRTOS学习 -- 队列
不积跬步，无以至千里
06-20 817
队列所能保存的最大数据项目数量叫做队列的长度，创建队列的时候会指定数据项目的大小和队列的长度。由于队列用来传递消息的，所以也称为消息队列。队列是为了任务与任务、任务与中断之间的通信而准备的，可以在任务与任务、任务与中断之间传递消息，队列中可以存储有限的、大小固定的数据项目。任务与任务、任务与中断之间要交流的数据保存在队列中，叫做队列项目。
FreeRtos队列详解
最新发布
z8178919的博客
01-06 892
FreeRTOS队列是实现任务间通信的核心机制，支持动态和静态两种创建方式。
FreeRTOS同步与互斥：（一）队列
Pluto__xu的博客
10-01 1081
注：本文摘自韦东山《FreeRTOS完全开发手册，如有侵权请告知》
FreeRTOS学习篇四：消息队列
weixin_45647341的博客
09-10 1099
FreeRTOS消息队列的基本使用。
FreeRTOS消息队列
weixin_56979960的博客
02-20 359
动态创建队列时，FreeRTOS会在运行时从其内置的堆中为队列分配所需的内存空间。静态创建队列要求用户在编译时手动为队列分配内存，而不依赖于 FreeRTOS 的堆管理。这使得内存的分配在编写代码时就能确定，因此在资源受限或对内存使用有严 格要求的嵌入式系统中可能更为合适。队列采用先进先出 (FIFO) 的顺序，即先发送的消息会被先接收。队列操作是原子的，以确保在多任务环境中的数据完整性。FreeRTOS 支持基于优先级的消息传递，确保高优先级任务在队列操 作期间不会被低优先级任务阻塞。
175_FreeRTOS队列的使用
小灰笔记
12-01 839
关于队列大致的基础知识我自己简单了解了一下，针对我自己脑子里还有的我认为我可能很快用到的知识点做一个如下的总结。 V9.0.0之后，队列可以做成静态的，编译前就确定下来。 一般来说，队列是从heap中进行存储分配的，存储分配释放的过程则是OS来处理； 队列可以容纳一定数目的特定对象，最大的数目被成为队列长度； 队列的主要目的是提供任务与任务、任务与中断之间的信号通信方式。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值