学习FreeRTOS之队列管理（转载）

最新推荐文章于 2024-09-03 17:38:03 发布
最新推荐文章于 2024-09-03 17:38:03 发布
阅读量461 收藏 4
点赞数

转载于：http://blog.chinaunix.net/uid-22072065-id-5201508.html

1. 概述

 

基于FreeRTOS 的应用程序由一组独立的任务构成——每个任务都是具有独立权限的小程序。这些独立的任务之间很可能会通过相互通信以提供有用的系统功能。FreeRTOS 中所有的通信与同步机制都是基于队列实现的。
 

2. 队列特性

 

数据存储

队列可以保存有限个具有确定长度的数据单元。队列可以保存的最大单元数目被称为队列的“深度”。在队列创建时需要设定其深度和每个单元的大小。
通常情况下，队列被作为FIFO(先进先出)使用，即数据由队列尾写入，从队列首读出。当然，由队列首写入也是可能的。
往队列写入数据是通过字节拷贝把数据复制存储到队列中；从队列读出数据使得把队列中的数据拷贝删除。
 

可被多任务存取

队列是具有自己独立权限的内核对象，并不属于或赋予任何任务。所有任务都可以向同一队列写入和读出。一个队列由多方写入是经常的事，但由多方读出倒是很少遇到。
 

读队列时阻塞

当某个任务试图读一个队列时，其可以指定一个阻塞超时时间。在这段时间中，如果队列为空，该任务将保持阻塞状态以等待队列数据有效。当其它任务或中断服务例程往其等待的队列中写入了数据，该任务将自动由阻塞态转移为就绪态。当等待的时间超过了指定的阻塞时间，即使队列中尚无有效数据，任务也会自动从阻塞态转移为就绪态。（这个是不是类似于linux中的poll机制，设定了超时时间。其实知识原理都是相通的。）

由于队列可以被多个任务读取，所以对单个队列而言，也可能有多个任务处于阻塞状态以等待队列数据有效。这种情况下，一旦队列数据有效，只会有一个任务会被解除阻塞，这个任务就是所有等待任务中优先级最高的任务。而如果所有等待任务的优先级相同，那么被解除阻塞的任务将是等待最久的任务。
 

写队列时阻塞

同读队列一样，任务也可以在写队列时指定一个阻塞超时时间。这个时间是当被写队列已满时，任务进入阻塞态以等待队列空间有效的最长时间。

由于队列可以被多个任务写入，所以对单个队列而言，也可能有多个任务处于阻塞状态以等待队列空间有效。这种情况下，一旦队列空间有效，只会有一个任务会被解除阻塞，这个任务就是所有等待任务中优先级最高的任务。而如果所有等待任务的优先级相同，那么被解除阻塞的任务将是等待最久的任务。

读写队列过程：

 

3. 使用队列

 

xQueueCreate() API 函数

队列在使用前必须先被创建。
队列由声明为xQueueHandle 的变量进行引用。xQueueCreate()用于创建一个队列，并返回一个xQueueHandle 句柄以便于对其创建的队列进行引用。
当创建队列时，FreeRTOS 从堆空间中分配内存空间。分配的空间用于存储队列数据结构本身以及队列中包含的数据单元。如果内存堆中没有足够的空间来创建队列，xQueueCreate()将返回NULL。
函数原型：
xQueueHandle xQueueCreate( unsigned portBASE_TYPE uxQueueLength, unsigned portBASE_TYPE uxItemSize );

uxQueueLength 
队列能够存储的最大单元数目，即队列深度。
uxItemSize 
队列中数据单元的长度，以字节为单位。
返回值 NULL 
表示没有足够的堆空间分配给队列而导致创建失败。非NULL 值表示队列创建成功。此返回值应当保存下来，以作为操作此队列的句柄。
 

xQueueSendToBack() 与 xQueueSendToFront() API 函数

xQueueSendToBack()用于将数据发送到队列尾；而xQueueSendToFront()用于将数据发送到队列首。
xQueueSend()完全等同于xQueueSendToBack()。
但切记不要在中断服务例程中调用xQueueSendToFront() 或xQueueSendToBack()。系统提供中断安全版本的xQueueSendToFrontFromISR()与xQueueSendToBackFromISR()用于在中断服务中实现相同的功能。
函数原型：
portBASE_TYPE xQueueSendToFront( xQueueHandle xQueue, const void * pvItemToQueue, portTickType xTicksToWait );
portBASE_TYPE xQueueSendToBack( xQueueHandle xQueue, const void * pvItemToQueue, portTickType xTicksToWait );

xQueue 
目标队列的句柄。这个句柄即是调用xQueueCreate()创建该队列时的返回值。
pvItemToQueue 
发送数据的指针。其指向将要复制到目标队列中的数据单元。由于在创建队列时设置了队列中数据单元的长度，所以会从该指针指向的空间复制对应长度的数据到队列的存储区域。
xTicksToWait 
阻塞超时时间。
（1）如果在发送时队列已满，这个时间即是任务处于阻塞态等待队列空间有效的最长等待时间。
（2）如果xTicksToWait设为0， 并且队列已满， 则xQueueSendToFront()与xQueueSendToBack()均会立即返回。阻塞时间是以系统心跳周期为单位的，所以绝对时间取决于系统心跳频率。常量portTICK_RATE_MS 可以用来把心跳时间单位转换为毫秒时间单位。
（3）如果把xTicksToWait 设置为portMAX_DELAY ， 并且在FreeRTOSConig.h 中设定INCLUDE_vTaskSuspend 为1，那么阻塞等待将没有超时限制。（这里的意思就是： 永久等待，直到发送队列变为有效。）
返回值 有两个可能的返回值:
1. pdPASS
返回pdPASS 只会有一种情况，那就是数据被成功发送到队列中。
如果设定了阻塞超时时间(xTicksToWait，非0)，在函数返回之前任务将被转移到阻塞态以等待队列空间有效，在超时到来前能够将数据成功写入到队列，函数则会返回pdPASS （意思就是：还没等超时时间到，数据写入成功，不然等到超时时间到了，数据才来的话，任务早已经超时返回了。）。
2. errQUEUE_FULL
如果由于队列已满而无法将数据写入， 则将返回errQUEUE_FULL。
如果设定了阻塞超时时间（xTicksToWait 非0），在函数返回之前任务将被转移到阻塞态以等待队列空间有效。但直到超时也没有其它任务或是中断服务例程读取队列而腾出空间，函数则会返回errQUEUE_FULL。（这是另一种情况）
 

xQueueReceive()与xQueuePeek() API 函数

xQueueReceive()用于从队列中接收（读取）数据单元。接收到的单元同时会从队列中删除。
xQueuePeek()也是从从队列中接收数据单元，不同的是并不从队列中删出接收到的单元。xQueuePeek()从队列首接收到数据后，不会修改队列中的数据，也不会改变 数据在队列中的存储顺序。
切记不要在中断服务例程中调用xQueueRceive()和xQueuePeek()，中断安全版本：xQueueReceiveFromISR()函数。
函数原型：
portBASE_TYPE xQueueReceive( xQueueHandle xQueue, const void * pvBuffer, portTickType xTicksToWait );
portBASE_TYPE xQueuePeek    ( xQueueHandle xQueue, const void * pvBuffer, portTickType xTicksToWait );

xQueue 被读队列的句柄。
这个句柄即是调用xQueueCreate()创建该队列时的返回值。
pvBuffer 
接收缓存指针。其指向一段内存区域，用于接收从队列中拷贝来的数据。
数据单元的长度在创建队列时就已经被设定，所以该指针指向的内存区域大小应当足够保存一个数据单元。
xTicksToWait 
阻塞超时时间。
（1）如果在接收时队列为空，则这个时间是任务处于阻塞状态以等待队列数据有效的最长等待时间。
（2）如果xTicksToWait 设为0，并且队列为空，则xQueueRecieve()与xQueuePeek()均会立即返回。阻塞时间是以系统心跳周期为单位的，所以绝对时间取决于系统心跳频率。常量portTICK_RATE_MS 可以用来把心跳时间单位转换为毫秒时间单位。
（3）如果把xTicksToWait 设置为portMAX_DELAY ， 并且在FreeRTOSConig.h 中设定INCLUDE_vTaskSuspend 为1，那么阻塞等待将没有超时限制。
返回值 
有两个可能的返回值:
1. pdPASS
只有一种情况会返回pdPASS，那就是成功地从队列中读到数据。
如果设定了阻塞超时时间(xTicksToWait 非0)，在函数返回之前任务将被转移到阻塞态以等待队列数据有效， 在超时到来前能够从队列中成功读取数据，函数则会返回pdPASS。
2. errQUEUE_FULL
如果在读取时由于队列已空而没有读到任何数据，则将返回errQUEUE_FULL。
如果设定了阻塞超时时间（xTicksToWait 非0），在函数返回之前任务将被转移到阻塞态以等待队列数据有效。但直到超时也没有其它任务或是中断服务例程往队列中写入数据，函数则会返回errQUEUE_FULL。
 

uxQueueMessagesWaiting() API 函数

uxQueueMessagesWaiting()用于查询队列中当前有效数据单元个数。
切记不要在中断服务例程中调用uxQueueMessagesWaiting()。应当在中断服务中使用其中断安全版本uxQueueMessagesWaitingFromISR()。
函数原型：
unsigned portBASE_TYPE uxQueueMessagesWaiting( xQueueHandle xQueue );

xQueue 
被查询队列的句柄。这个句柄即是调用xQueueCreate()创建该队列时的返回值。
返回值 
当前队列中保存的数据单元个数。返回0 表明队列为空。

 

例子10：

本例示范创建一个队列，由多个任务往队列中写数据，以及从队列中把数据读出。
这个队列创建出来保存long 型数据单元。往队列中写数据的任务没有设定阻塞超时时间，而读队列的任务设定了超时时间。

往队列中写数据的任务的优先级低于读队列任务的优先级。这意味着队列中永远不会保持超过一个的数据单元。因为一旦有数据被写入队列，读队列任务立即解除阻塞，抢占写队列任务，并从队列中接收数据，同时数据从队列中删除—队列再一次变为空队列。

写队列任务实现：
这个任务被创建了两个实例，一个不停地往队列中写数值100，而另一个实例不停地往队列中写入数值200。任务的入口参数被用来为每个实例传递各自的写入值。
这里：两个写任务是不停地写buffer的。除非时间片到，或者被高优先级任务抢占。

读队列任务实现：
读队列任务设定了100 毫秒的阻塞超时时间，所以会进入阻塞态以等待队列数据有效。一旦队列中数据单元有效，或者即使队列数据无效但等待时间超过100 毫秒，此任务将会解除阻塞。在本例中，将永远不会出现100 毫秒超时，因为有两个任务在不停地往队列中写数据。
注意：这里如果读任务不设置100ms阻塞超时时间，会发生什么呢？

main()函数的实现。
其在启动调度器之前创建了一个队列和三个任务。尽管对任务的优先级的设计使得队列实际上在任何时候都不可能多于一个数据单元，本例代码还是创建了一个可以保存最多5 个long 型值的队列。

代码实现：

点击(此处)折叠或打开

  1. #include "led.h"
  2. #include "delay.h"
  3. #include "sys.h"
  4. #include "usart.h"
  5.  
  6. // FreeRTOS head file, add here.
  7. #include "FreeRTOS.h"
  8. #include "task.h"
  9. #include "queue.h"
  10. #include "list.h"
  11. #include "portable.h"
  12. #include "FreeRTOSConfig.h"
  13.  
  14. /* declare a queueHandle variable, using to save queue handler. */
  15. xQueueHandle xQueue;
  16.  
  17.  
  18.  
  19. void vSendTask(void *pvParameters)
  20. {
  21.     long valueToSend;
  22.     portBASE_TYPE status;
  23.  
  24.     /* 该任务会被创建两个实例，所以写入队列的值通过任务入口参数传递 – 这种方式使得每个实例使用不同的
    值。队列创建时指定其数据单元为long型，所以把入口参数强制转换为数据单元要求的类型 */
  25.  
  26.     valueToSend = (long)pvParameters;
  27.     
  28.     while(1)
  29.     {
  30. /* 往队列发送数据
    第一个参数是要写入的队列。队列在调度器启动之前就被创建了，所以先于此任务执行。
    第二个参数是被发送数据的地址，本例中即变量lValueToSend的地址。
    第三个参数是阻塞超时时间 – 当队列满时，任务转入阻塞状态以等待队列空间有效。本例中没有设定超
    时时间，因为此队列决不会保持有超过一个数据单元的机会，所以也决不会满。
    */
  31.         status = xQueueSendToBack(xQueue, &valueToSend, 0);
  32.         if(status != pdPASS)
  33.         {
  34.             /* 发送操作由于队列满而无法完成 – 这必然存在错误，因为本例中的队列不可能满。 */
  35.             printf("could not send to the queue. \r\n");
  36.         }
  37.  
  38.         /* 允许其它发送任务执行。 taskYIELD()通知调度器现在就切换到其它任务，而不必等到本任务的时间片耗尽 */
  39.         taskYIELD();
  40.     }
  41. }
  42.  
  43.  
  44. void vReceiveTask(void *pvParameters)
  45. {
  46.     long lReceivedValue;
  47.     portBASE_TYPE status;
  48.  
  49.     while(1)
  50.     {
  51.             /* 此调用会发现队列一直为空，因为本任务将立即删除刚写入队列的数据单元。 这里要问为什么？？？ */ 
  52.  
  53.         if( uxQueueMessagesWaiting( xQueue ) != 0 )
  54.         {
  55.             printf( "Queue should have been empty! \r\n");  // 这句话不会得到执行，为什么？？思考。。。。。
  56.         }
  57.             /* 从队列中接收数据
    第一个参数是被读取的队列。队列在调度器启动之前就被创建了，所以先于此任务执行。
    第二个参数是保存接收到的数据的缓冲区地址，本例中即变量lReceivedValue的地址。此变量类型与
    队列数据单元类型相同，所以有足够的大小来存储接收到的数据。
    第三个参数是阻塞超时时间 – 当队列空时，任务转入阻塞状态以等待队列数据有效。本例中常量
    portTICK_RATE_MS用来将100毫秒绝对时间转换为以系统心跳为单位的时间值。
    */
  58.  
  59.         status = xQueueReceive( xQueue, &lReceivedValue, 100 / portTICK_RATE_MS );
  60.         if( status == pdPASS )
  61.         {
  62.             printf( "Received = %ld\r\n", lReceivedValue );
  63.         }
  64.         else
  65.         {
  66. /* 等待100ms也没有收到任何数据。
    必然存在错误，因为发送任务在不停地往队列中写入数据 */
  67.             printf( "Could not receive from the queue.\r\n" );
  68.         }
  69.     }
  70. }
  71.  
  72. int main(void)
  73. {
  74.     // board initialize. 
  75.     LED_Init();             
  76.     uart_init(115200);
  77.     
  78.     // create queue, can store 5 value which data type islong
  79.     xQueue = xQueueCreate(5, sizeof(long));
  80.     
  81.     if(xQueue != NULL) // adjust the return value, to confirm whether create queue successful.
  82.     {
  83.         // Create two write queue task, priority = 1;
  84.         xTaskCreate(vSendTask, "SendTask1", configMINIMAL_STACK_SIZE, (void *)100, 1, NULL);
  85.         xTaskCreate(vSendTask, "SendTask2", configMINIMAL_STACK_SIZE, (void *)200, 1, NULL);
  86.         
  87.         // create one read queue task, priority = 2;
  88.         xTaskCreate(vReceiveTask, "RecTask", configMINIMAL_STACK_SIZE, NULL, 2, NULL);
  89.         
  90.         // start scheduler now
  91.         vTaskStartScheduler(); 
  92.     }
  93.     else
  94.     {
  95.         // queue create unsuccessful here. add your code.
  96.     }
  97.     
  98.     return 0;
  99. }

写队列任务在每次循环中都调用taskYIELD()。taskYIELD()通知调度器立即进行任务切换，而不必等到当前任务的时间片耗尽。某个任务调用taskYIELD()等效于其自愿放弃运行态。由于本例中两个写队列任务具有相同的任务优先级，所以一旦其中一个任务调用了taskYIELD()，另一个任务将会得到执行 — 调用taskYIELD()的任务转移到就绪态，同时另一个任务进入运行态。这样就可以使得这两个任务轮翻地往队列发送数据。

执行流程：

上面有一个思考问题：
在接收queue任务中：
  1.         if( uxQueueMessagesWaiting( xQueue ) != 0 )
  2.         {
  3.             printf( "Queue should have been empty! \r\n");  // 这句话不会得到执行，为什么？？思考。。。。。
  4.         }
注意到：接收任务是高优先的任务，首先得到运行，第一次运行的时候，queue还是空的，这句话不成立，不会执行；
然后，执行到读队列的函数，由于队列为空，则任务由运行态进入阻塞态，这时候退出CPU的占有权限，写队列的任务得到执行，一旦有写队列任务写进一个数据到队列中，将会唤醒读队列，因为读队列任务优先级高啊，读队列任务得到运行，读取队列，并且删除队列中的元素，导致队列继续为空，循环到上面的语句的时候，还是条件不成立，不会打印这句字符串。以此循环下去，该句话永远得不到执行。

上面的执行流程的问号：
为什么接收队列运行完了，还要执行一小块发送的任务呢？
void vSendTask(void *pvParameters)
{
    long valueToSend;
    portBASE_TYPE status;
    
    valueToSend = (long)pvParameters;
    
    while(1)
    {
       
       printf("enter \r\n");     // 这里加上打印语句
        status = xQueueSendToBack(xQueue, &valueToSend, 0);
        printf("exit \r\n");     // 这里加上打印语句
   

//     一旦这行到这里，队列里面有数据了，则将会唤醒读队列任务，从这里切换出去，知道读任务进入阻塞态，该任务继续占有CPU而执行未完成的代码。优先级高就是牛逼啊。。

        if(status != pdPASS)
        {
            printf("could not send to the queue. \r\n");
        }
        
        taskYIELD();
    }
}

这个问题可以测试一下，在status = xQueueSendToBack(xQueue, &valueToSend, 0); 的前面和后面各加上一句打印语句，就可以看出执行顺序了。
打印结果：





 
小相619
关注
Arduino与FreeRTOS-FreeRTOS队列管理
视觉与物联智能
12-19 1113
FreeRTOS队列管理 在上一篇文章Arduino与FreeRTOS-FreeRTOS配置与简单任务创建中，已经了解了 FreeRTOS 与 Arduino的任务管理过程。 在本文中，我们将学习如何使用 FreeRTOS API 创建队列。 单个任务无法创建一个高效且完整的应用程序。 因为这些独立的任务是具有自己的堆栈、内存和执行作业的较小程序。 因此，很明显我们需要一种机制让这些自主任务相互通信。 以便他们可以相互共享数据或消息。 与其他现代 RTOS 内核一样，FreeRTOS 内核也提供了任务间数据
FreeRTOS中的xQueueCreate，xQueueSend，xQueueReceive
热门推荐
浮若于心
06-11 2万+
xQueueCreate 原型： portBASE_TYPE xQueueReceive( xQueueHandle xQueue, void *pvBuffer, portTickType xTicksToWait );
【FreeRTOS学习 - 消息队列学习】
晨少的博客
03-31 733
【FreeRTOS学习 - 消息队列学习 - 详细笔记】1.创建队列 2.写队列 3.读队列 4.队列阻塞访问 5.分辨数据源头 6.传输大块数据
＜FreeRTOS入门第六节＞消息队列
sinat_58149788的博客
08-06 757
今天我学习了FreeRTOS的新知识消息队列FreeRTPS消息队列产生就是为了解决任务与任务，任务与中断之间的消息传递，一般我们在任务和任务直接消息的传递是使用一个全局变量来实现的，但是我们使用这种方法也存在一些问题。所以在FreeRTOS中就出现了消息队列。他就是相当于把任务和任务直接传递的信息拷贝到队列里面，然后在调用队列里面的信息，这样就实现了任务与任务之间消息的传递 队列不属于某一个任务，是所以任务都可以调用的入队阻塞：当wait等待设置为0时就是没有发送数据马上执行其他任务，当wait等待为我们
7.FreeRTOS之队列
sycc512的博客
09-03 793
在编写项目应用时，常常会遇到一个任务和另一个任务进行“沟通交流”的情况，在没有操作系统时，全局变量可以解决这个问题，但是如果在使用操作系统的应用中用全部变量来传递信息就会涉及到“资源管理”的问题，而且全局变量不易维护，往往逻辑复杂的程序中，无法追踪全局变量被谁使用或被谁更改。FreeRTOS对此提供一个叫做“队列”的机制。队列是为了任务与任务、任务与中断之间的通信而准备的，可以在任务与任务、任务与中断之间传递消息，队列中可以存储有限的、大小固定的数据项目。
freeRtos中入队列最底层函数xQueueGenericSend解析
m0_56214103的博客
02-02 806
freeRtos中入队列最底层函数xQueueGenericSend解析
消息队列MSG（多进程ipc）
takashi77的博客
08-30 515
消息队列： 1.在任意进程间有选择性地进行通讯的方式 2.发送数据时需要携带一定的消息标志 3.消息队列创建后由于是存在于内核中由内核管理，使用过后需要人工删除以释放资源 ##### 4.消息队列发送和接收时可以选择性地发送和接收 相关函数原型： ...
Free RTOS-9消息队列2传结构体
fanzhipeng7000的博客
06-29 159
1, // 任务优先级。2, // 任务优先级。vTaskCode, // 任务函数。4096, // 分配内存。vTaskCode1, // 任务函数。4096, // 分配内存。(void *)QHandle, // 传参数。(void *)QHandle, // 传参数。"Ttask", // 名字。"Rtask1", // 名字。
基于STM32的FreeRTOS串口队列通信
11-30
而FreeRTOS作为一款轻量级实时操作系统，为STM32提供了多任务调度和管理的能力。在这个项目中，我们将深入探讨如何利用FreeRTOS的队列机制实现STM32上的串口通信，确保任务与中断之间的高效、安全数据传输。 首先，...
2.FreeRTOS之队列
最新发布
11-01
2.FreeRTOS之队列
FreeRTOS学习笔记之——-FreeRTOS队列基础知识 2020.3.30
01-06
在没有操作系统的时候，两个应用程序进行消息传递一般是使用全局变量的方式，但是如果在使用操作系统的应用中用全局变量来传递消息，则会涉及资源管理的问题。 2.队列是为了任务与任务、任务与中断之间的通信而准备...
FreeRTOS 消息队列
longjingcha110的博客
04-07 830
队列又称消息队列, 是一种常用于任务间通信的数据结构, 队列可以在任务与任务之间, 中断和任务间传递消息. 当任务从消息队列中读取消息的时候, 队列如果是空的, 那么当前任务会被阻塞, 用户还可以指定阻塞的时间xTicksToWait. 超过这个时间, 任务也会从阻塞态转化为就绪态, . 消息队列是一种异步通信方式. ...
FreeRTOS操作系统——队列及队列API函数（十）
戚晨夕的博客
01-19 3390
FreeRTOS操作系统学习 文章目录FreeRTOS操作系统学习前言一、队列功能介绍1.数据存储2.多任务访问3.出队阻塞4.入队阻塞二、队列工作过程1.API函数1.队列创建函数2.入队函数2.队列操作实验总结 前言 队列是为了任务与任务、任务与中断之间的通信而准备的，可以在任务与任务、任务与中断之间传递消息，队列中可以存储有限的、大小固定的数据项目。任务与任务、任务与中断之间要交流的数据保存在队列中，叫做队列项目。队列所能保存的最大数据项目数量叫做队列的长度，创建队列的时候会指定数据项目的大小和队
【FreeRTOS】【应用篇】消息队列【下篇】
Beihai_Van的博客
08-30 2034
本篇文章主要对 FreeRTOS 中消息队列的概念和相关函数进行了详解 消息队列【下篇】详细剖析了消息队列中发送、接收时队列消息控制块中各种指针的行为，以及几个发送消息和接收消息的函数的运作流程 笔者有关于 【FreeRTOS】【应用篇】消息队列【上篇】——队列基本概念、创建和删除，讲解了消息队列的基本概念（作用、存储结构、出入队列逻辑、阻塞机制）以及相关函数（队列创建和删除） 一部分代码和图片参考野火 FreeRTOS 教程。
FreeRTOS系列|消息队列二
kunkliu的博客
05-25 908
本文主要介绍如何在任务或中断中向队列发送消息或者从队列中接收消息。 使用STM32CubeMX将FreeRTOS移植到工程中，创建两个任务以及两个消息队列，并开启两个中断 两个任务 Keyscan_Task：读取按键的键值，并将键值发送到队列Key_Queue中Keyprocess_Task：按键处理任务，读取队列Key_Queue中的消息，并根据不同的消息值做相应的处理 两个队列 Msg_Queue：用于传递串口发送过来的消息Key_Queue：用于传递按键值 两
STM32CubeMX——FREERTOS学习：消息队列Queue
m0_49968063的博客
03-28 2397
队列，也叫消息队列，就是把消息一条一条的排个队。 比如创建了一个消息队列，这个消息队列可以存10条消息。任务A可以往里存消息，任务B也可以往里存。这个存的消息是要讲先来后到的，存满了10条消息就不能存了。假设任务C从里面去消息，也是一条一条的取，按照先后顺序取，先存的先取，后存的后取。信息取一个，队列里面就少一个，取10个之后，消息队列就空了。 往队列里面存消息，如果队列已经满了，可以一直等着，直到队列里面有空位置，也可以等一会，没空位离开。 从队列里面取消息，如果队列已经空了，可以一直等着，直到队列
FreeRTOS — 消息队列
流风回雪的博客
04-20 1万+
以下内容转载自安富莱电子：http://forum.armfly.com/forum.phpFreeRTOS 的一个重要的通信机制----消息队列，消息队列在实际项目中应用较多。1、消息队列 1.1 消息队列的概念及其作用　　消息队列就是通过 RTOS 内核提供的服务，任务或中断服务子程序可以将一个消息（注意，FreeRTOS消息队列传递的是实际数据，并不是数据地址，RTX，uCOS-II 和 u...
007_FreeROTS队列
陆小果哥哥的博客
12-24 197
（一）目的：进程间的通信 （二）队列创建 动态创建队列，函数 xQueueCreate() QueueHandle_t xQueueCreate(　UBaseType_t uxQueueLength, 　　　　　　　　　　　　　　 UBaseType_t uxItemSize) 参数： uxQueueLength： 要创建的队列的队列长度，这里是队列的项目数。 uxItemSize： 队列...
FreeRTOS-队列管理
weixin_44483794的博客
10-25 1028
队列”提供了任务到任务、任务到中断和中断到任务的通信机制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值