10.FreeRTOS队列操作

已于 2024-08-16 15:38:54 修改
阅读量686 收藏 11
点赞数 22
分类专栏： 嵌入式 # 嵌入式操作系统 文章标签： STM32 freeRTOS 嵌入式软件开发
于 2024-08-10 10:16:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lshuangye/article/details/141086667
版权

01.初识freeRTOS
02.FreeRTOS的移植
03.FreeRTOS系统配置
04.FreeRTOS任务创建与删除
05.FreeRTOS任务挂起与恢复
06.FreeRTOS中断管理
07.FreeRTOS列表与列表项
08.FreeRTOS任务调度与任务切换
09.FreeRTOS时间片调度与任务相关函数
10.FreeRTOS队列操作
11.FreeRTOS信号量操作
12.FreeRTOS队列集和事件标志组
13.FreeRTOS任务通知
14.FreeRTOS软件定时器
15.FreeRTOS低功耗
16.FreeRTOS内存管理

文章目录

10. FreeRTOS队列操作

1. 队列简介

  • 队列的简介：

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

队列是一种任务到任务、任务到中断、中断到任务数据交流的一种机制。在队列中可以存储数量有限、大小固定的多个数据，队列中的每一个数据叫做队列项目，队列能够存储队列项目的最大数量称为队列的长度，在创建队列的时候，就需要指定所创建队列的长度及队列项目的大小。因为队列是用来在任务与任务或任务于中断之间传递消息的一种机制，因此队列也叫做消息队列。

  • 队列的特点：

    在这里插入图片描述

    1. 数据存储

      队列通常采用FIFO(先进先出)的存储缓冲机制，当有新的数据被写入队列中时，永远都是写入到队列的尾部，而从队列中读取数据时，永远都是读取队列的头部数据。但同时FreeRTOS的队列也支持将数据写入到队列的头部，并且还可以指定是否覆盖先前己经在队列头部的数据。

    2. 多任务访问

      队列不属于某个特定的任务，可以在任何的任务或中断中往队列中写入消息，或者从队列中读取消息。

    3. 队列读取阻塞

      在任务从队列读取消息时，可以指定一个阻塞超时时间。如果任务在读取队列时，队列为空，这时任务将被根据指定的阻塞超时时间添加到阻塞态任务列表中进行阻塞，以等待队列中有可用的消息。当有其他任务或中断将消息写入队列中，因等待队列而阻塞任务将会被添加到就绪态任务列表中，并读取队列中可用的消息。如果任务因等待队列而阻塞的时间超过指定的阻塞超时时间，那么任务也将自动被转移到就绪态任务列表中，但不再读取队列中的数据。

    4. 队列写入阻塞

      与队列读取一样，在任务往队列写入消息时，也可以指定一个阻塞超时时间。如果任务在写入队列时，队列已经满了，这时任务将被根据指定的阻塞超时时间添加到阻塞态任务列表中进行阻塞，以等待队列有空闲的位置可以写入消息。指定的阻塞超时时间为任务阻塞的最大时间，如果在阻塞超时时间到达之前，队列有空闲的位置，那么队列写入阻塞任务将会解除阻塞，并往队列中写入消息，如果达到指定的阻塞超时时间，队列依旧没有空闲的位置写入消息，那么队列写入阻塞任务将会自动转移到就绪态任务列表中，但不会往队列中写入消息。

    在这里插入图片描述

  • 队列操作基本过程

    1. 创建队列

      在这里插入图片描述

      创建了一个用于任务A与任务B之间“沟通交流”的队列，这个队列最大可容纳5个队列项目，即队列的长度为5。刚创建的队列是不包含内容的，因此这个队列为空。

    2. 往队列写入第一个消息

      在这里插入图片描述

      任务A将一个私有变量写入队列的尾部。由于在写入队列之前，队列是空的，因此新写入的消息，既是是队列的头部，也是队列的尾部。

    3. 往队列写入第二个消息

      在这里插入图片描述

      任务A改变了私有变量的值，并将新值写入队列。现在队列中包含了队列A写入的两个值，其中第一个写入的值在队列的头部，而新写入的值在队列的尾部。这时队列还有3个空闲的位置。

    4. 从队列读取第一个消息

      在这里插入图片描述

      任务B从队列中读取消息，任务B读取的消息是处于队列头部的消息，这是任务A第一次往队列中写入的消息。在任务B从队列中读取消息后，队列中任务A第二次写入的消息，变成了队列的头部，因此下次任务B再次读取消息时，将读取到这个消息。此时队列中剩余4个空闲的位置。

2. 队列结构体介绍

  • 队列结构体定义：

    在这里插入图片描述

    在这里插入图片描述

  • 队列结构体整体示意图：

    在这里插入图片描述

3. 队列相关API函数介绍

  • 创建队列：

    在这里插入图片描述

    函数的参数与返回值：

    在这里插入图片描述

    函数的其他功能：

    # xQueueGenericCreate()的其他功能
#define queueQUEUE_TYPE_BASE ( ( uint8_t ) 0U ) 				/* 队列 */
#define queueQUEUE_TYPE_SET ( ( uint8_t ) 0U ) 					/* 队列集 */
#define queueQUEUE_TYPE_MUTEX ( ( uint8_t ) 1U ) 				/* 互斥信号量 */
#define queueQUEUE_TYPE_COUNTING_SEMAPHORE ( ( uint8_t ) 2U ) 	/* 计数型信号量 */
#define queueQUEUE_TYPE_BINARY_SEMAPHORE ( ( uint8_t ) 3U ) 	/* 二值信号量 */
#define queueQUEUE_TYPE_RECURSIVE_MUTEX ( ( uint8_t ) 4U ) 		/* 递归互斥信号量 */

    函数的执行过程：

    在这里插入图片描述

  • 写入队列相关函数

    函数描述
    xQueueSend()往队列的尾部写入消息
    xQueueSendToBack()同 xQueueSend()
    xQueueSendToFront()往队列的头部写入消息
    xQueueOverwrite()覆写队列消息（只用于队列长度为 1 的情况）
    xQueueSendFromISR()在中断中往队列的尾部写入消息
    xQueueSendToBackFromISR()同 xQueueSendFromISR()
    xQueueSendToFrontFromISR()在中断中往队列的头部写入消息
    xQueueOverwriteFromISR()在中断中覆写队列消息（只用于队列长度为 1 的情况）

    在任务中往队列写入消息的函数有四个，它们均为宏定义，定义如下：

    在这里插入图片描述

    调用的函数都为xQueueGenericSend()，只是写入的位置不同，队列的三种写入方式为：

    在这里插入图片描述

    函数xQueueGenericSend()的入口参数与返回值：

    在这里插入图片描述

    函数执行过程：

    1. 参数验证
    configASSERT(pxQueue);
configASSERT(!( (pvItemToQueue == NULL) && (pxQueue->uxItemSize != (UBaseType_t) 0U)));
configASSERT(!( (xCopyPosition == queueOVERWRITE) && (pxQueue->uxLength != 1) ));
#if ( (INCLUDE_xTaskGetSchedulerState == 1) || (configUSE_TIMERS == 1) )
{
    configASSERT(!( (xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED) && (xTicksToWait != 0) ));
}
#endif
    • configASSERT(pxQueue): 确保队列句柄 pxQueue 不为空。
    • configASSERT(!( (pvItemToQueue == NULL) && (pxQueue->uxItemSize != (UBaseType_t) 0U))): 确保如果队列项的大小大于0，则消息指针不能为 NULL。
    • configASSERT(!( (xCopyPosition == queueOVERWRITE) && (pxQueue->uxLength != 1) )): 如果使用 queueOVERWRITE 模式，则队列长度必须为1。
    • configASSERT(!( (xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED) && (xTicksToWait != 0) )): 如果调度器被挂起并且 xTicksToWait 不为0，则检查调度器状态。
    1. 进入临界区
    taskENTER_CRITICAL();
    • taskENTER_CRITICAL(): 关闭中断，以保护对队列的操作，确保线程安全。
    1. 检查队列状态
    if ((pxQueue->uxMessagesWaiting < pxQueue->uxLength) || (xCopyPosition == queueOVERWRITE))
{
    traceQUEUE_SEND(pxQueue);
    
    #if (configUSE_QUEUE_SETS == 1)
    {
        const UBaseType_t uxPreviousMessagesWaiting = pxQueue->uxMessagesWaiting;
        xYieldRequired = prvCopyDataToQueue(pxQueue, pvItemToQueue, xCopyPosition);
        
        if (pxQueue->pxQueueSetContainer != NULL)
        {
            if ((xCopyPosition == queueOVERWRITE) && (uxPreviousMessagesWaiting != (UBaseType_t) 0))
            {
                mtCOVERAGE_TEST_MARKER();
            }
            else if (prvNotifyQueueSetContainer(pxQueue) != pdFALSE)
            {
                queueYIELD_IF_USING_PREEMPTION();
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
        }
        else
        {
            if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToReceive)) == pdFALSE)
            {
                if (xTaskRemoveFromEventList(&(pxQueue->xTasksWaitingToReceive)) != pdFALSE)
                {
                    queueYIELD_IF_USING_PREEMPTION();
                }
                else
                {
                    mtCOVERAGE_TEST_MARKER();
                }
            }
            else if (xYieldRequired != pdFALSE)
            {
                queueYIELD_IF_USING_PREEMPTION();
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
        }
    }
    #else
    {
        xYieldRequired = prvCopyDataToQueue(pxQueue, pvItemToQueue, xCopyPosition);
        
        if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToReceive)) == pdFALSE)
        {
            if (xTaskRemoveFromEventList(&(pxQueue->xTasksWaitingToReceive)) != pdFALSE)
            {
                queueYIELD_IF_USING_PREEMPTION();
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
        }
        else if (xYieldRequired != pdFALSE)
        {
            queueYIELD_IF_USING_PREEMPTION();
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
    }
    #endif
    taskEXIT_CRITICAL();
    return pdPASS;
}
    • if ((pxQueue->uxMessagesWaiting < pxQueue->uxLength) || (xCopyPosition == queueOVERWRITE)): 检查队列是否有空间，或是否允许覆盖写入。
    • traceQUEUE_SEND(pxQueue): 记录队列发送的跟踪信息。
    • prvCopyDataToQueue(pxQueue, pvItemToQueue, xCopyPosition): 将数据复制到队列中。
    • if (pxQueue->pxQueueSetContainer != NULL): 如果队列属于队列集，则通知队列集。
    • xTaskRemoveFromEventList(&(pxQueue->xTasksWaitingToReceive)): 如果有任务在等待接收数据，则解除其阻塞。
    • queueYIELD_IF_USING_PREEMPTION(): 根据任务的优先级决定是否进行任务切换。
    1. 处理队列满的情况
    else
{
    if (xTicksToWait == (TickType_t) 0)
    {
        taskEXIT_CRITICAL();
        traceQUEUE_SEND_FAILED(pxQueue);
        return errQUEUE_FULL;
    }
    else if (xEntryTimeSet == pdFALSE)
    {
        vTaskInternalSetTimeOutState(&xTimeOut);
        xEntryTimeSet = pdTRUE;
    }
}
    • if (xTicksToWait == (TickType_t) 0): 如果队列满且不允许阻塞，退出临界区并返回 errQUEUE_FULL。
    • else if (xEntryTimeSet == pdFALSE): 如果允许阻塞且超时未设置，配置超时结构。
    1. 处理阻塞和超时
    taskEXIT_CRITICAL();
vTaskSuspendAll();
prvLockQueue(pxQueue);

if (xTaskCheckForTimeOut(&xTimeOut, &xTicksToWait) == pdFALSE)
{
    if (prvIsQueueFull(pxQueue) != pdFALSE)
    {
        traceBLOCKING_ON_QUEUE_SEND(pxQueue);
        vTaskPlaceOnEventList(&(pxQueue->xTasksWaitingToSend), xTicksToWait);
        prvUnlockQueue(pxQueue);

        if (xTaskResumeAll() == pdFALSE)
        {
            portYIELD_WITHIN_API();
        }
    }
    else
    {
        prvUnlockQueue(pxQueue);
        (void) xTaskResumeAll();
    }
}
else
{
    prvUnlockQueue(pxQueue);
    (void) xTaskResumeAll();
    traceQUEUE_SEND_FAILED(pxQueue);
    return errQUEUE_FULL;
}
    • vTaskSuspendAll(): 暂停任务调度器，确保任务调度不影响阻塞。
    • prvLockQueue(pxQueue): 锁定队列，防止其他任务对其进行操作。
    • if (xTaskCheckForTimeOut(&xTimeOut, &xTicksToWait) == pdFALSE): 检查超时是否到期。如果未到期，继续处理。
    • if (prvIsQueueFull(pxQueue) != pdFALSE): 如果队列仍然满，将当前任务放入事件列表，进行阻塞。
    • vTaskPlaceOnEventList(&(pxQueue->xTasksWaitingToSend), xTicksToWait): 将当前任务放到等待发送事件的列表中。
    • prvUnlockQueue(pxQueue): 解锁队列。
    • if (xTaskResumeAll() == pdFALSE): 恢复任务调度器。如果需要，进行任务切换。
    • else: 如果队列不再满，尝试重新发送消息。
    • else: 如果超时已过，解除锁定，恢复任务调度器，返回 errQUEUE_FULL。

  • 队列读取相关函数

    函数描述
    xQueueReceive()从队列头部读取消息，并删除消息
    xQueuePeek()从队列头部读取消息
    xQueueReceiveFromISR()在中断中从队列头部读取消息，并删除消息
    xQueuePeekFromISR()在中断中从队列头部读取消息

    函数 xQueueReceive()的入口参数与返回值：

    在这里插入图片描述

    函数 xQueuePeek()的入口参数与返回值：

    在这里插入图片描述

    函数执行过程：

    1. 参数检查：

      configASSERT( ( pxQueue ) );
configASSERT( !( ( ( pvBuffer ) == NULL ) && ( ( pxQueue )->uxItemSize != ( UBaseType_t ) 0U ) ) );
      • 确保 pxQueue 不为空。
      • 如果 pvBuffer 为空，则只有在 uxItemSize 为0的情况下才允许（表示队列中没有实际的数据存储）。

    2. 调度器状态检查：

      #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
    configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
#endif
      • 如果调度器被挂起且 xTicksToWait 不为0，则会产生断言失败，因为在这种状态下任务不能阻塞。

    3. 主循环：

      for( ; ; )

      进入无限循环来处理队列数据接收和等待超时。

    4. 临界区保护：

      taskENTER_CRITICAL();

      进入临界区以防止中断和其他任务对队列的访问。

    5. 检查队列数据：

      const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;
if (uxMessagesWaiting > (UBaseType_t) 0)
      • 检查队列中是否有数据。如果有数据，则：
        • 从队列中复制数据到 pvBuffer。
        • 记录接收事件。
        • 减少队列中的消息计数。
        • 检查是否有任务在等待发送数据到队列，如果有，解除这些任务的阻塞。
        • 退出临界区并返回 pdPASS 表示成功接收数据。
      prvCopyDataFromQueue( pxQueue, pvBuffer );
traceQUEUE_RECEIVE( pxQueue );
pxQueue->uxMessagesWaiting = uxMessagesWaiting - ( UBaseType_t ) 1;

    6. 队列为空时处理：

      if (xTicksToWait == (TickType_t) 0)
      • 如果 xTicksToWait 为0且队列为空，退出并返回 errQUEUE_EMPTY。
      traceQUEUE_RECEIVE_FAILED( pxQueue );
return errQUEUE_EMPTY;
      • 否则，设置超时状态并进入等待。
      if (xEntryTimeSet == pdFALSE)
{
    vTaskInternalSetTimeOutState( &xTimeOut );
    xEntryTimeSet = pdTRUE;
}

    7. 退出临界区：

      taskEXIT_CRITICAL();
      • 退出临界区，允许其他任务和中断对队列进行操作。

    8. 挂起任务调度器：

      vTaskSuspendAll();
      • 挂起调度器，以确保当前任务在等待过程中不会被调度出去。

    9. 队列锁定：

      prvLockQueue( pxQueue );
      • 锁定队列，防止其他任务在此期间对队列进行操作。

    10. 检查超时状态并处理：

      if (xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE)
      • 检查超时状态。如果超时未过，继续等待：
        • 如果队列仍然为空，将当前任务添加到等待接收的任务列表中。
        • 解锁队列并恢复任务调度器。
      if (prvIsQueueEmpty( pxQueue ) != pdFALSE)
{
    traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue );
    vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );
    prvUnlockQueue( pxQueue );
    if (xTaskResumeAll() == pdFALSE)
    {
        portYIELD_WITHIN_API();
    }
}
else
{
    prvUnlockQueue( pxQueue );
    ( void ) xTaskResumeAll();
}

    11. 处理超时情况：

      • 如果超时已经到达，但队列仍然为空，解锁队列，恢复任务调度器，并返回 errQUEUE_EMPTY。
      if (prvIsQueueEmpty( pxQueue ) != pdFALSE)
{
    traceQUEUE_RECEIVE_FAILED( pxQueue );
    return errQUEUE_EMPTY;
}

    12. 重复尝试：

      • 如果队列现在有数据，再次尝试接收数据。

    内部函数调用时机

    1. prvCopyDataFromQueue：

      • 在队列中有数据时调用，从队列中复制数据到缓冲区。

    2. vTaskInternalSetTimeOutState：

      • 当队列为空且需要阻塞等待数据时，设置超时状态。

    3. xTaskRemoveFromEventList：

      • 在队列中有数据并且有任务在等待发送数据时，解除这些任务的阻塞。

    4. vTaskPlaceOnEventList：

      • 当队列仍然为空且需要阻塞等待数据时，将当前任务放到等待接收任务列表中。

    5. prvLockQueue 和 prvUnlockQueue：

      • 在等待数据和处理超时时，锁定和解锁队列以确保数据的一致性。

    6. xTaskCheckForTimeOut：

      • 检查超时状态，确定是否需要继续阻塞或解除阻塞。

    7. portYIELD_WITHIN_API：

      • 在任务调度恢复后，执行任务切换，以确保高优先级任务能够被调度。

4. 队列操作实验

创建的任务以及任务的功能：

在这里插入图片描述

相关任务：

队列创建：

//队列创建
key_queue = xQueueCreate(2, sizeof(uint8_t));
if(key_queue != NULL)
{
	printf("key_queue队列创建成功!\r\n");
}
else{
	printf("key_queue队列创建失败!\r\n");
}

big_date_queue = xQueueCreate(1, sizeof(char *));
if(big_date_queue != NULL)
{
	printf("big_date_queue队列创建成功!\r\n");
}
else{
	printf("big_date_queue队列创建失败!\r\n");
}

任务1：入队操作

/*任务一：入队操作*/
void task1(void* pvParamter)
{	
	uint8_t key = 0;
	char * buf;
	buf = &buff[0];
	
	while(1)
	{
		key = key_scan(0);
		if(key == KEY0_PRES || key == KEY1_PRES)
		{
			if(xQueueSend(key_queue, &key, portMAX_DELAY) != pdTRUE)
			{
				printf("key_queue队列发送失败\r\n");
			}
		}
		else if(key == WKUP_PRES)
		{
			if(xQueueSend(big_date_queue, &buf, portMAX_DELAY) != pdTRUE)
			{
				printf("big_date_queue队列发送失败\r\n");
			}
		}
		
		vTaskDelay(20);
	}
}

任务2：小数据出队

/*任务二：小数据出队*/
void task2(void* pvParamter)
{	
	uint8_t key = 0;
	while(1)
	{
		if(xQueueReceive(key_queue, &key, portMAX_DELAY) != pdTRUE)
		{
			printf("key_queue队列读取失败\r\n");
		}
		else
		{
			printf("读取队列成功，数据%d\r\n",key);
		}
	}
}

任务3：大数据出队

/*任务三：大数据出队*/
void task3(void* pvParamter)
{
	char * buf;
	
	while(1)
	{
		if(xQueueReceive(big_date_queue, &buf, portMAX_DELAY) != pdTRUE)
		{
			printf("big_date_queue队列读取失败\r\n");
		}
		else
		{
			printf("读取队列成功，数据%s\r\n",buf);
		}
	}
}

实验结果：

在这里插入图片描述

mseeding
关注
专栏目录
freertos- 队列及其操作API
Life_Maze的博客
12-02 784
如图1所示，相关数据类型 typedef struct xSTATIC_QUEUE { void *pvDummy1[ 3 ]; union { void *pvDummy2; UBaseType_t uxDummy2; } u; StaticList_t xDummy3[ 2 ]; UBaseType_t uxDummy4[ 3 ]; uint8_t ucDummy...
【FreeRtos队列操作】
boybs的博客
05-15 1273
FreeRtos队列操作 文章目录FreeRtos队列操作前言一、队列介绍1.1 数据存储1.2 出队阻塞1.3 入队阻塞二、队列结构体2.1 队列的动态创建2.2 队列发送消息2.3 从队列读取消息三、队列Demo演示3.1 任务需求3.2 代码演示3.3 实验结果 前言 本篇分享的是FreeRtos中的队列基础知识，通过本次的学习对队列有了一定的认识，以及如何去创建队列。 一、队列介绍 队列是为了任务与任务、任务与中断之间的通信而准备的，可以在任务与任务、任务与中断之间传递消息，队列中可以存储
队列操作（深入理解FreeRTOS队列之队列实战）
最新发布
大柯基的博客
08-22 592
队列在FreeRTOS中是用于任务间或任务与中断服务程序之间通信的机制，它支持任务间的数据交换和信息同步。
【Freertos基础入门】队列(queue)的使用
m0_62599305的博客
08-19 2302
FreeRTOS是一个广泛使用的开源实时操作系统（RTOS），它提供了丰富的功能和特性，使嵌入式系统的开发更加简单和高效。队列是FreeRTOS中常用的一种通信机制，它用于在任务之间传递数据。队列是FreeRTOS中一种有用的通信机制，可用于在任务之间传递数据。通过使用队列，我们可以实现任务之间的数据共享和同步。在使用队列时，需要注意队列的深度和每个数据项的大小，并选择适当的阻塞等待时间以避免资源争用和任务饥饿等问题。
第11章_freeRTOS入门与工程实践之队列(queue)
挨踢民工的博客
09-12 270
队列(queue)可以用于"任务到任务"、"任务到中断"、"中断到任务"直接传输信息。 本章涉及如下内容： - 怎么创建、清除、删除队列 - 队列中消息如何保存 - 怎么向队列发送数据、怎么从队列读取数据、怎么覆盖队列的数据 - 在队列上阻塞是什么意思 - 怎么在多个队列上阻塞 - 读写队列时如何影响任务的优先级
stm32f103 FreeRTOS队列操作实验.zip
03-07
STM32F103 FreeRTOS队列操作实验将教你如何创建、发送和接收队列消息。这通常涉及到以下函数： 1. `xQueueCreate`: 创建一个队列，指定元素大小和最大数量。 2. `xQueueSend`: 向队列中发送数据，如果队列已满，...
NXP i.MX RT1052实现FreeRTOS队列操作【支持RT105X系列控制器_FreeRTOS实战】.zip
05-19
在NXP i.MX RT1052上实现FreeRTOS队列操作，需要结合硬件特性，如中断处理、内存布局和处理器优化。由于i.MX RT1052拥有强大的处理能力，可以高效地处理FreeRTOS任务调度和队列操作，使其成为实时应用的理想选择。 ...
STM32F103实现FreeRTOS队列操作【支持STM32F10X系列单片机】
11-23
下面将详细介绍STM32F103与FreeRTOS队列操作的相关知识点。 1. **STM32F103简介** STM32F103拥有高性能、低功耗的特点，内置高速存储器（如闪存和SRAM）、丰富的外设接口，以及多种定时器和串行通信接口。它支持...
STM32F429 FreeRTOS实战：实现FreeRTOS队列操作【支持STM32F42X系列单片机】.zip
12-15
6. **优先级反转**：FreeRTOS队列支持消息优先级继承，以防止高优先级任务因等待低优先级任务释放资源（如队列中的数据）而被阻塞过长时间。 在STM32F429 FreeRTOS实战项目中，开发者将学习如何配置FreeRTOS系统，...
4.FreeRTOS学习笔记-消息队列
Car12
01-16 1036
消息队列 传输的数据不定长 支持先进先出FIFO,同时支持后进先出LIFO 均支持超时机制。 每个消息队列都与消息空间在同一段连续的内存空间中 消息队列的大小是消息队列控制块大小+（单个消息空间大小 * 消息队列长度） 任务或者中断服务程序都可以给消息队列发送消息 超时发送，超时发送失败返回 errQUEUE_FULL 发送紧急消息，就是放在队列头部 支持 消息读超时 包含头文件 #include <queue.h> 消息队列运作模型 读消息的3中情况 有就取出，没有 扭头就走 没
FreeRTOS的学习（二）——队列的介绍和操作
m0_58832575的博客
09-09 4338
FreeRTOS的学习（二）——队列的介绍和操作
FreeRTOS学习-队列管理
Duran.L的专栏
12-17 1523
在FreeRTOS中，提供了多种任务间通讯的机制，包括消息队列、信号量和互斥锁、事件组、任务通知。消息队列、信号量和互斥锁、事件组都是间接的任务间通信机制，而任务通知则是直接的通信方式，因此，任务通信的性能比其他几种间接的通信方式要高。严格来说，互斥锁并不是一种任务间通信机制，将他们放在一块是因为互斥锁是基于信号量实现的，便于理解。在FreeRTOS中，信号量又是基于消息队列实现的，因此，先介绍消息队列，然后再介绍信号量和互斥锁。最后介绍事件组和任务通知。
FreeRTOS 消息队列
ma123456542的博客
03-21 1019
队列实际它的内存是分为两部分，第一个就是存放结构体的内存，接着是队列里面的队列项，它用来存放数据的，我们写入数据给队列就写入到队列项里面了。int8_t * pcHead /* 存储区域的起始地址（队列项的起始地址） *//* 下一个写入的位置 */union /* 当把这个结构体用作不同的功能的时候，联合体的作用是不一样的 *//* 当用作队列的时候，就使用的上面这个 *//* 当用作互斥信号量的时候，就使用的下面这个 */} u;/* 等待发送列表 */
FreeRTOS（消息队列）
qq_57594025的博客
08-11 3094
当有多个消息发送到消息队列时，通常是将先进入消息队列的消息先传给任务，也就是说，任务先得到的是最先进入消息队列的消息，即先进先出原则(FIFO)，FreeRTOS的队列也支持后进先出原则(LIFO)。3. 消息队列还有两个函数 xQueueSendToBackFromISR 和 xQueueSendToFrontFromISR，函数xQueueSendToBackFromISR 实现的是 FIFO 方式的存取，函数 xQueueSendToFrontFromISR 实现的是 LIFO 方式的读写。
从0到1学习FreeRTOS：FreeRTOS 内核应用开发：（八）消息队列 NO.1 基本概念
sumjess
09-21 457
从0到1学习FreeRTOS：FreeRTOS 内核应用开发：（八）消息队列 NO.1 基本概念 目录 一、消息队列的基本概念： 二、消息队列的特性： 三、消息队列的运作机制： 四、消息队列的阻塞机制： 五、消息队列的应用场景： 六、消息队列控制块： 一、消息队列的基本概念： 队列又称消息队列，是一种常用于任务间通信的数据结构，队列可以在任务与任务间、中断和任务间...
freertos源码分析DAY2 （消息队列 ）
weixin_48038462的博客
06-10 1216
这节内容是信号量的基础，因为创建以及发送/等待信号量所调用的底层函数，就是创建/发送/接受消息队列时所用到的通用创建函数，这里先补充一下数据结构中关于队列的知识。目录1. 队列原理1.1 顺序队列操作1.2 循环队列操作2.消息队列原理2.1消息队列的构成2.2 消息队列出入队原则2.3 消息队列发送/接收消息原理2.4 队列锁机制3. 消息队列创建及删除3.1 创建消息队列函数3.1.1 xQueueGenericCreate通用任务创建函数 3.1.1.1 prvInitialiseNewQueue初
FreeRTOS-消息队列详解
热门推荐
k666499436的博客
01-11 1万+
本文将详细全方位的讲解FreeRTOS的队列消息，其实在FreeRTOS中队列的重要性也不言而喻，与FreeRTOS任务调度同等重要，因为后面的各种信号量基本都是基于队列的。本文主要围绕(队列的创建、队列的出队、入队函数、队列的环形缓冲区的实现(数据的拷贝、先进先出、以及后进先出的实现)、队列锁、以及队列任务级函数与中断级函数的区别)队列的重要知识，本文都会以源码分析的形式进行解析。！！
【FreeRTOS】队列的使用
凉开水白菜的博客
11-03 2435
基于 FreeRTOS 的应用程序由一组独立的任务构成——每个任务都是具有独立权限的小程序。这些独立的任务之间很可能会通过相互通信以提供有用的系统功能。FreeRTOS 中所有的通信与同步机制都是基于队列实现的；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值