freeRtos学习笔（4）消息队列

最新推荐文章于 2024-03-21 21:52:29 发布

不咸不要钱

最新推荐文章于 2024-03-21 21:52:29 发布

阅读量2k

点赞数 1

分类专栏： freertos学习笔记

本文链接：https://blog.csdn.net/weixin_42378319/article/details/112378321

版权

freertos学习笔记专栏收录该内容

12 篇文章 13 订阅

订阅专栏

freeRtos学习笔记

freeRtos消息队列

为什么要用消息队列

消息队列可以在任务与任务间，中断与任务间传递信息。为什么不用全局数组？全局数组也可以传递信息，但是和消息队列相比，消息队列有一下优势：

全局数组需要解决多任务访问冲突，需要加临界区保护
消息队列可以实现超时机制
消息队列可以实现FIFO和LIFO机制

消息队列创建

QueueHandle_t xQueueCreate(UBaseType_t uxQueueLength,  /* 消息个数 */
                           UbaseType_t uxItemSize);    /* 消息大小 单位字节 */

函数 xQueueCreate 用于创建消息队列。

第 1 个参数是消息队列支持的消息个数。
第 2 个参数是每个消息的大小，单位字节。
返回值，如果创建成功会返回消息队列的句柄，如果由于 FreeRTOSConfig.h 文件中 heap 大小不足，
无法为此消息队列提供所需的空间会返回 NULL。
需要注意，消息队列传递消息是消息本身被copy到消息队列中，而不是传递指针,因此消息尽量不要太大，否则可能会影响实时性。

消息队列删除

void vQueueDelete(QueueHandle_t xQueue);

消息队列删除函数

第 1 个参数是消息队列
注意，消息队列删除后，会释放消息队列的内存空间，但是如果删除消息队列时，有任务正在等待消息，则不应
该进行删除操作

消息队列发送

BaseType_t xQueueSend(QueueHandle_t xQueue,       /* 消息队列 */
                      const void* pvItemToQueue,  /* 要发送消息地址 */
                      TickType_t  xTicksToWait);  /* 如果消息队列已满，等待超时时间 */

/* 和xQueueSend函数作用相同，将消息添加在消息队列尾部 */
BaseType_t xQueueSendToBack(QueueHandle xQueue,      
                            const void* pvItemToQueue,
                            TickType_t xTicksToWait);

/* 将消息添加在消息队列头部 */
BaseType_t xQueueSendToFront(QueueHandle_t xQueue,
                             const void* pvItemToQueue,
                             TickType_t xTicksToWait);

/* 在中断中发送消息，为了实时性，中断中不应该存在堵塞或者延时，因此这里没有发送超时参数 */       
BaseType_t xQueueSendFromISR(QueueHandle_t xQueue,                    /* 消息队列 */
                             const void* pvItemToQueue,               /* 要发送消息地址 */
                             BaseType_t* pxHigherPriorityTaskWoken);  /* 消息发送后，是否有更高级别的任务就绪 */

BaseType_t xQueueSendToBackFromISR(QueueHandle_t xQueue,              /* 消息队列 */
                             const void* pvItemToQueue,               /* 要发送消息地址 */
                             BaseType_t* pxHigherPriorityTaskWoken);  /* 消息发送后，是否有更高级别的任务就绪 */

BaseType_t xQueueSendToFrontFromISR(QueueHandle_t xQueue,             /* 消息队列 */
                             const void* pvItemToQueue,               /* 要发送消息地址 */
                             BaseType_t* pxHigherPriorityTaskWoken);  /* 消息发送后，是否有更高级别的任务就绪 */

消息队列发送函数

第 1 个参数是消息队列句柄。
第 2 个参数要传递数据地址，每次发送都是将消息队列创建函数 xQueueCreate 所指定的单个消息大
小复制到消息队列空间中。
在任务中第 3 个参数是当消息队列已经满时，等待消息队列有空间时的最大等待时间，单位系统时钟节拍。
在中断中第 3 个参数是消息发送后，是否有更高级别的任务就绪，如果有更高级别任务就绪(优先级更高的任务堵塞在消息接收上，这里发送了消息，导致任务从堵塞态转变为就绪态)，则pxHigherPriorityTaskWoken变为pdTRUE,然后在中断结束处调用taskYIELD()进行任务调度。
返回值，如果消息成功发送返回 pdTRUE，否则返回 pdFALSE
使用消息队列函数要注意以下问题：

FreeRTOS 的消息传递是数据的复制，而不是传递的数据地址。
用于任务代码中调用的和在中断服务程序中调用的函数不同，需要注意区分，中断服务程序中使用的是FromISR结尾的。
任务代码中，如果消息队列已经满且第三个参数为 0，那么此函数会立即返回。
任务代码中，如果用户将第三个参数配置为 portMAX_DELAY，那么此发送函数会永久等待直到消息队列有空间可以使用。
消息队列发送函数 xQueueSendToBack 和 xQueueSend是一样的，实现的是 FIFO 方式的存取，函数 xQueueSendToFront 实现的是 LIFO 方式的读写。

消息队列接收

BaseType_t xQueueReceive(QueueHandle_t xQueue,     /* 消息队列 */
                         void* pvBuffer,           /* 接收消息缓冲区 */
                         TickType_t xTicksToWait); /* 如果消息队列为空，等待超时时间 */

BaseType_t xQueueReceiveFromISR(QueueHandle_t xQueue, /* 消息队列 */
                                void* pvBuffer,       /* 接收消息缓冲区 */
                                BaseType_t pxHigherPriorityTaskWoken);  /* 消息接收后，是否有更高级别的任务就绪 */

消息队列接收函数

第 1 个参数是消息队列句柄。
第 2 个参数消息接收地址，每次接收都是将消息队列创建函数 xQueueCreate 所指定的单个消息大
小复制到消息接收地址中。
在任务中第 3 个参数是当消息队列为空时，等待消息队列有消息的最大等待时间，单位系统时钟节拍。
在中断中第 3 个参数是消息接收后，是否有更高级别的任务就绪，如果有更高级别任务就绪(消息队列已满，且有优先级更高的任务堵塞在消息发送上，这里接收了消息，导致该任务从堵塞态转变为就绪态)，则pxHigherPriorityTaskWoken变为pdTRUE,然后在中断结束处调用taskYIELD()进行任务调度。
返回值，如果接到到消息返回 pdTRUE，否则返回 pdFALSE。
使用消息队列函数要注意以下问题：

FreeRTOS 的消息传递是数据的复制，而不是传递的数据地址。
用于任务代码中调用的和在中断服务程序中调用的函数不同，需要注意区分，中断服务程序中使用的是FromISR结尾的。
任务代码中，如果消息队列已经满且第三个参数为 0，那么此函数会立即返回。
任务代码中，如果用户将第三个参数配置为 portMAX_DELAY，那么此接收函数会永久等待直到消息队列有消息可以使用。

消息队列覆盖式发送

BaseType_t xQueueOverWrite(QueueHandle_t xQueue,         /* 消息队列 */
                           const void* pvItemToQueue);   /* 要发送消息地址 */

BaseType_t xQueueOverWriteFromISR(QueueHandle_t xQueue,       /* 消息队列 */
                                  const void* pvItemToQueue,  /* 要发送消息地址 */
                                  BaseType_t *pxHigherPriorityTaskWoken); /* 消息发送后，是否有更高级别的任务就绪 */

消息队列覆盖式发送函数

第 1 个参数是消息队列句柄。
第 2 个参数要传递数据地址，每次发送都是将消息队列创建函数 xQueueCreate 所指定的单个消息大
小复制到消息队列空间中。
在中断中第 3 个参数是消息发送后，是否有更高级别的任务就绪，如果有更高级别任务就绪(优先级更高的任务堵塞在消息接收上，这里发送了消息，导致任务从堵塞态转变为就绪态)，则pxHigherPriorityTaskWoken变为pdTRUE,然后在中断结束处调用taskYIELD()进行任务调度。
返回值，只返回 pdTRUE
使用消息队列函数要注意以下问题：

FreeRTOS 的消息传递是数据的复制，而不是传递的数据地址。
用于任务代码中调用的和在中断服务程序中调用的函数不同，需要注意区分，中断服务程序中使用的是FromISR结尾的。
和普通的消息队列发送函数相比，覆盖式发送函数需要在消息队列在创建时，消息个数一定要是1.在写入的时候会直接写入覆盖当前数据，不会检查消息队列是否已满。

消息队列消息预读取

BaseType_t xQueuePeek(QueueHandle_t xQueue,
                      void *pvBuffer,
                      TickType_t xTicksToWait);

BaseType_t xQueuePeekFromISR(QueueHandle_t xQueue,
                             void *pvBuffer);

消息队列预读取函数

第 1 个参数是消息队列句柄。
第 2 个参数消息接收地址，每次接收都是将消息队列创建函数 xQueueCreate 所指定的单个消息大
小复制到消息接收地址中。
在任务中第 3 个参数是当消息队列为空时，等待消息队列有消息的最大等待时间，单位系统时钟节拍。
返回值，如果接到到消息返回 pdTRUE，否则返回 pdFALSE。
使用消息队列预读取函数要注意以下问题：

FreeRTOS 的消息传递是数据的复制，而不是传递的数据地址。
用于任务代码中调用的和在中断服务程序中调用的函数不同，需要注意区分，中断服务程序中使用的是FromISR结尾的。
任务代码中，如果消息队列已经满且第三个参数为 0，那么此函数会立即返回。
任务代码中，如果用户将第三个参数配置为 portMAX_DELAY，那么此接收函数会永久等待直到消息队列有消息可以使用。
和消息队列接收函数 xQueueReceive 相比，消息队列预读取函数只会将消息复制到消息接收缓冲区，并不会删除消息队列中的消息。

获取消息队列消息个数

/* 获取消息队列中可用消息个数 */
UBaseType_t uxQueueMessagesWaiting(const QueueHandle_t xQueue);
UBaseType_t uxQueueMessagesWaitingFromISR(const QueueHandle_t xQueue);

/* 获取消息队列剩余空间 */
UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue );

/* 获取消息队列是否为空 */
BaseType_t xQueueIsQueueEmptyFromISR( const QueueHandle_t pxQueue );

/* 获取消息队列是否已满 */
BaseType_t xQueueIsQueueFullFromISR( const QueueHandle_t pxQueue );

消息队列集

队列集提供了一种机制，允许RTOS任务同时阻止（挂起）来自多个RTOS队列或信号量的读取操作。


/* 创建消息队列集 
参数：
    uxEventQueueLength 队列设置存储在集合中包含的队列和信号量上的事件。 uxEventQueueLength指定一次可以排队的最大事件数。
    为了绝对确定事件没有丢失，必须将uxEventQueueLength设置为添加到集合的队列长度的总和，其中二进制信号量和互斥量的长度为1，计数信号量的长度由其最大计数值设置。例如：
        如果队列集要保存长度为5的队列，另一个长度为12的队列和一个二进制信号量，则uxEventQueueLength应设置为（5 + 12 + 1）。
        如果队列集要保存三个二进制信号量，则uxEventQueueLength应设置为（1 + 1 + 1）。
        如果队列集要保存最大计数为5的计数信号量，以及最大计数为3的计数信号量，则uxEventQueueLength应设置为（5 + 3）。
返回：
    如果成功创建了队列集，则返回创建的队列集的句柄。否则返回NULL。*/
QueueSetHandle_t xQueueCreateSet( const UBaseType_t uxEventQueueLength );

/* 将消息队列或者信号量添加到消息队列集中 */
BaseType_t xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,
                           QueueSetHandle_t xQueueSet );

/* 获取消息队列集中哪一个IPC接收到了信号 */
QueueSetMemberHandle_t xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
                                            const TickType_t xTicksToWait );

QueueSetMemberHandle_t xQueueSelectFromSetFromISR( QueueSetHandle_t xQueueSet );

先使用xQueueCreateSet()创建队列集，然后使用xQueueAddToSet()将标准FreeRTOS队列和信号量添加到集合中。最后使用xQueueSelectFromSet（）来确定集合中包含的队列或信号量中的哪一个（如果有）处于队列读取或信号量获取操作成功的状态。

注意：
将队列和信号量添加到队列集时，它们必须为空。
添加到队列集的每个队列中的每个空间都需要额外的4个字节的RAM。因此，不应将最大计数值较高的计数信号量添加到队列集。

/* 下面是一个使用例子 */

/* 消息队列长度. */
#define QUEUE_LENGTH_1 10
#define QUEUE_LENGTH_2 10

/* 二值信号量长度. */
#define BINARY_SEMAPHORE_LENGTH 1

/* 消息队列数据类型 */
#define ITEM_SIZE_QUEUE_1 sizeof( uint32_t )
#define ITEM_SIZE_QUEUE_2 sizeof( something_else_t )

/* 消息队列集长度. */
#define COMBINED_LENGTH ( QUEUE_LENGTH_1 + QUEUE_LENGTH_2 + BINARY_SEMAPHORE_LENGTH )

void vAFunction( void )
{
    static QueueSetHandle_t xQueueSet;
    QueueHandle_t xQueue1, xQueue2, xSemaphore;
    QueueSetMemberHandle_t xActivatedMember;
    uint32_t xReceivedFromQueue1;
    something_else_t xReceivedFromQueue2;

    /* 创建消息队列集 */
    xQueueSet = xQueueCreateSet( COMBINED_LENGTH );

    /* 创建消息队列 */
    xQueue1 = xQueueCreate( QUEUE_LENGTH_1, ITEM_SIZE_QUEUE_1 );
    xQueue2 = xQueueCreate( QUEUE_LENGTH_2, ITEM_SIZE_QUEUE_2 );
    
    /* 创建二值信号量. */
    xSemaphore = xSemaphoreCreateBinary();

    /* 将消息队列和二值信号量添加到队列集中. */
    xQueueAddToSet( xQueue1, xQueueSet );
    xQueueAddToSet( xQueue2, xQueueSet );
    xQueueAddToSet( xSemaphore, xQueueSet );

    for( ;; )
    {
        /* 等待队列集中有可以信号 队列集中任意一消息队列或者二值信号量有消息即可 堵塞时间200ms */
        xActivatedMember = xQueueSelectFromSet( xQueueSet, pdMS_TO_TICKS( 200 ) );

        /* 根据队列集返回信息，分别对队列集中不同IPC接收到消息进行处理 */
        if( xActivatedMember == xQueue1 )
        {
            xQueueReceive( xActivatedMember, &xReceivedFromQueue1, 0 );
            vProcessValueFromQueue1( xReceivedFromQueue1 );
        }
        else if( xActivatedQueue == xQueue2 )
        {
            xQueueReceive( xActivatedMember, &xReceivedFromQueue2, 0 );
            vProcessValueFromQueue2( &xReceivedFromQueue2 );
        }
        else if( xActivatedQueue == xSemaphore )
        {
            xSemaphoreTake( xActivatedMember, 0 );
            vProcessEventNotifiedBySemaphore();
            break;
        }
        else
        {
            /* 200ms堵塞处理. */
        }
    }
}

本文参考 freertos官方文档 https://freertos.org/a00110.html
《安富莱 STM32-V6 开发板 FreeRTOS 教程》

不咸不要钱

关注

1
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
freeRtos学习笔（4）消息队列

freeRtos学习笔记freeRtos消息队列为什么要用消息队列消息队列可以在任务与任务间，中断与任务间传递信息。为什么不用全局数组？全局数组也可以传递信息，但是和消息队列相比，消息队列有一下优势：全局数组需要解决多任务访问冲突，需要加临界区保护消息队列可以实现超时机制消息队列可以实现FIFO和LIFO机制消息队列创建QueueHandle_t xQueueCreate(UBaseType_t uxQueueLength, /* 消息个数 */
复制链接

扫一扫