FreeRTOS消息队列queue.c文件详解

消息队列的作用

消息队列主要用来传递消息，可以在任务与任务之间、中断与任务之间传递消息。

  1. 传递消息是通过复制的形式，发送方发送时需要不断复制，接收方接收时也需要不断复制。虽然会有内存资源的浪费，但是可以保证安全。
    在这里插入图片描述
    假设：如果发送方和接收方直接操作一块内存空间，多个发送方操作写，接收方操作读，会导致时序混乱，是不安全的。
    在这里插入图片描述
  2. 简述传递消息的过程
    初始状态：队列在初始的状态下，头指针和尾指针都指向一个位置，是空队列。
    在这里插入图片描述
    入队：发送方往队列里写数据，写在头指针指向的位置，尾指针自动向后偏移一格，尾指针永远指向可以存内容的格子。
    在这里插入图片描述
    出队：接收方从队列中读数据，头指针往后移。形成一个循环队列。
    在这里插入图片描述

消息队列定义

在这里插入图片描述

  1. 消息队列的结构体成员除了上图所示，还有一下成员：
    ① pcReadFrom：指向出队消息空间的最后一个，读取消息时候是从pcReadFrom指向的空间读取消息内容。
    ② uxRecursiveCallCount：当结构体用作互斥量时，用于计数，记录递归互斥量被“调用”的次数。
    ③ xTasksWaitingToSend ：发送方消息阻塞列表，用于保存阻塞在此队列的任务，任务按照优先级进行排序。（由于队列已满，想要发送消息的任务无法发送消息，所以需要保存阻塞在此队列的任务。）
    ④ xTasksWaitingToReceive：接收方消息阻塞列表，用于保存阻塞在此队列的任务，任务按照优先级进行排序。（由于队列是空的，想要获取消息的任务无法获取到消息。）
    ⑤ cRxLock：列表上锁后，存储出队的数量。
    ⑥ cTxLock：列表上锁后，存储入队的数量。
  2. 消息队列的定义代码：
typedef struct QueueDefinition
{int8_t *pcHead;			/*< pcHead指向队列消息存储区域的起始位置 */int8_t *pcTail;			/*< pcTail指向消息队列信息存储区的结束位置 */int8_t *pcWriteTo;		/*< pcWriteTo指向队列存储下一个可用消息空间 */union	{int8_t *pcReadFrom;		/*< 当结构体用作队列时，pcReadFrom指向出队消息空间的最后一个。*/UBaseType_t uxRecursiveCallCount;	/*< 当结构体用作互斥量时，uxRecursiveCallCount用于计数，记录递归互斥量被“调用”的次数。*/} u;List_t xTasksWaitingToSend;		/*< xTasksWaitingToSend是一个发送消息阻塞列表，用于保存阻塞在此队列的任务，任务按照优先级进行排序，由于队列已满，想要发送消息的任务无法发送消息。 */List_t xTasksWaitingToReceive;	/*< xTasksWaitingToReceive是一个获取消息阻塞列表，用于保存阻塞在此队列的任务，任务按照优先级进行排序，由于队列是空的，想要获取消息的任务无法获取到消息。*/volatile UBaseType_t uxMessagesWaiting;/*< uxMessagesWaiting用于记录当前消息队列的消息个数，如果消息队列被用于信号量的时候，这个值就表示有效信号量个数。*/UBaseType_t uxLength;			/*< uxLength表示队列的长度，也就是能存放多少消息。*/UBaseType_t uxItemSize;			/*< uxItemSize表示单个消息的大小。*/volatile int8_t cRxLock;		/*< 队列上锁后，储存从队列收到的列表项数目，也就是出队的数量，如果队列没有上锁，设置为queueUNLOCKED。*/volatile int8_t cTxLock;		/*< 队列上锁后，储存发送到队列的列表项数目，也就是入队的数量，如果队列没有上锁，设置为queueUNLOCKED。 */#if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )uint8_t ucStaticallyAllocated;	/*< 如果队列使用的内存是静态分配的，则设置为pdTRUE以确保不会尝试释放内存 */#endif#if ( configUSE_QUEUE_SETS == 1 )struct QueueDefinition *pxQueueSetContainer;#endif#if ( configUSE_TRACE_FACILITY == 1 )UBaseType_t uxQueueNumber;uint8_t ucQueueType;#endif
} xQUEUE;

消息队列控制块的初始化及创建

在这里插入图片描述

图例的简单解释：

  1. 这是消息队列整个的框架图，左侧和右侧是上下连接起来看的。
  2. 首先首指针和指向队列空间首地址，pcWriteTo指向写入的位置，当发送方写入一个数据的时候会从这个位置开始。
  3. pcTail和左侧的xMutexHolder，pcReadFrom和左侧的xTasksWaitingToReceive是共用体，内存数据一样，名称不同。可以用左边解释也可以用右边来解释。左侧是信号量处理时用的，这里使用右侧。pcTail当指向队列空间末尾地址，pcReadFrom指向读取的位置。
  4. 发送列表，假设队列空间已满，再发送数据需要在发送列表中等待。接收列表，假设队列是空的，接收数据需要在接收列表里等待。
  5. uxMessagesWaiting消息等待计数，默认为0。在使用信号量模式时，没有队列空间。就是使用的uxMessagesWaiting来计数。在使用队列模式时，uxMessagesWaiting用来计数队列空间里的消息，也就是目前队列空间里现存的消息数。通过它，很容易判断队列空间里有没有成员。
  6. 队列空间部分是发送消息存放的空间。发送消息时，需要把发送的内容复制到队列空间，往外读消息时，需要从队列空间中读取消息。队列空间的长度N由创建时uxLength决定。
  7. 每个队列空间的大小由uxItemSize决定，uxItemSize以字节为单位。假设uxItemSize=5，发送时发送3个字节，往外读消息时仍然是5个字节。
  8. cRxLock接收锁，默认状态为1，不上锁。
  9. cTxLock发送锁，默认状态为1，不上锁。
QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, const uint8_t ucQueueType )
  • 如消息队列控制模块图所示，在队列空间前的部分是消息队列的自有属性。创建消息队列时，FreeRTOS会先给消息队列分配一块内存空间。内存空间的大小=消息队列控制块大小（自有属性的大小）+ 队列空间大小（单个消息空间大小uxItemSize*消息队列长度uxQueueLength）。接着，初始化消息队列，此时消息队列为空。每个消息队列都与消息空间在同一段连续的内存空间中，在创建成功的时候，这些内存就被占用了，只有删除了消息队列的时候，这段内存才会被释放掉。
  • 创建队列时传入的第一个参数是uxQueueLength，uxLength=uxQueueLength。创建队列时传入的第二参数是uxItemSize，决定每个队列空间的大小。创建队列的第三个参数是队列的类型，类型的选择如下面定义所示，我们这里使用的是queueQUEUE_TYPE_BASE即基本的消息队列。
#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 ) /* 递归互斥信号量 */

下面是消息队列的创建完整代码，首先pvPortMalloc分配内存，然后调用prvInitialiseNewQueue()进行队列的初始化。返回值：pxNewQueue消息队列控制块，消息队列在内存中的地址。

#define xQueueCreate( uxQueueLength, uxItemSize ) xQueueGenericCreate( ( uxQueueLength ), ( uxItemSize ), ( queueQUEUE_TYPE_BASE ) )QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, const uint8_t ucQueueType )
{Queue_t *pxNewQueue; /* 消息队列控制块，一个结构体指针*/size_t xQueueSizeInBytes; /* 需要分配的内存大小，Bytes为单位 */uint8_t *pucQueueStorage; /* 实际存放消息的地址，即消息队列控制块的后面 */configASSERT( uxQueueLength > ( UBaseType_t ) 0 ); /*判断要创建的消息队列的长度是否大于0*/if( uxItemSize == ( UBaseType_t ) 0 ){   /* 若消息队列单个项的大小为0，则不会分配队列存储区域 */xQueueSizeInBytes = ( size_t ) 0;}else{   /* 计算需要分配的内存大小：队列的长度*单个消息的大小 */xQueueSizeInBytes = ( size_t ) ( uxQueueLength * uxItemSize );}/* 调用pvPortMalloc分配内存：其大小为消息队列控制块的大小+实际的消息占用的大小 */pxNewQueue = ( Queue_t * ) pvPortMalloc( sizeof( Queue_t ) + xQueueSizeInBytes );/* 若成功分配了内存，则pxNewQueue这个结构体指针(消息队列控制块)不为NULL */if( pxNewQueue != NULL ){    /* 跳过消息队列控制块以获取实际的队列存储区域的指针 */ pucQueueStorage = ( ( uint8_t * ) pxNewQueue ) + sizeof( Queue_t );#if( configSUPPORT_STATIC_ALLOCATION == 1 ){   /* 队列可以静态创建，也可以动态创建，因此请注意，此任务是动态创建的，以防以后删除 */pxNewQueue->ucStaticallyAllocated = pdFALSE;}#endif /* configSUPPORT_STATIC_ALLOCATION *//*初始化一个队列*/prvInitialiseNewQueue( uxQueueLength, uxItemSize, pucQueueStorage, ucQueueType, pxNewQueue );}return pxNewQueue;
}

上述代码中的初始化队列成员具体由prvInitialiseNewQueue完成，需要参数：初始化队列的长度，消息大小，pucQueueStorage实际存放消息的地址，ucQueueType队列的类型，pxNewQueue消息队列控制块。
初始化队列成员，然后调用xQueueGenericReset()函数进行队列复位(初始化)。

static void prvInitialiseNewQueue( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, const uint8_t ucQueueType, Queue_t *pxNewQueue )
{( void ) ucQueueType;/* 判断单个消息的大小是否为0*/if( uxItemSize == ( UBaseType_t ) 0 ){/* 没有为队列存储区域分配RAM，但是pcHead不能设置为NULL，因为NULL被用作一个键来表示队列被用作互斥锁。因此，只需将pcHead设置为消息队列控制块的地址 */pxNewQueue->pcHead = ( int8_t * ) pxNewQueue;}else{   /* 将pcHead设置为实际存放消息的地址 */pxNewQueue->pcHead = ( int8_t * ) pucQueueStorage;}/* 按照定义队列类型的位置初始化队列成员 */pxNewQueue->uxLength = uxQueueLength;pxNewQueue->uxItemSize = uxItemSize;( void ) xQueueGenericReset( pxNewQueue, pdTRUE ); /*队列复位(初始化)*/#if ( configUSE_TRACE_FACILITY == 1 ){pxNewQueue->ucQueueType = ucQueueType;}#endif /* configUSE_TRACE_FACILITY */#if( configUSE_QUEUE_SETS == 1 ){pxNewQueue->pxQueueSetContainer = NULL;}#endif /* configUSE_QUEUE_SETS */traceQUEUE_CREATE( pxNewQueue );
}

上述初始化队列成员的函数中xQueueGenericReset()函数主要用来重置队列，将队列中的队列项都清空，将队列中的一些指针也都恢复成最初状态。

  1. 队列的尾地址指向队列的最后一项的末尾地址，pxQueue->pcHead已经指向队列的首地址了，那么在该基础上再偏移所有队列项内存占用内存空间和，就指向了该队列所申请空间的最后一个字节。
  2. 队列的消息个数初始化为0，初始化pcWriteTo的指向位置，初始时和 pcHead 指向同一地方。初始化pcReadFrom 指向队列中最后一项的首地址。
  3. 接收消息(出队)不锁定，发送消息(入队)不锁定，是否是新创建的队列，判断因为队列已满而不能入队导致的任务阻塞列表是否为空，任务阻塞列表不为空，则将任务从事件列表中移除，并判断是否需要重新进行任务调度。如果队列为新创建的队列，则初始化任务发送等待列表。
BaseType_t xQueueGenericReset( QueueHandle_t xQueue, BaseType_t xNewQueue )
{
Queue_t * const pxQueue = ( Queue_t * ) xQueue; /* 将内存地址转为消息队列控制块结构体类型，并赋值给局部变量pxQueue */configASSERT( pxQueue );taskENTER_CRITICAL(); /* 进入临界区 */{/* 队列尾地址 = 头地址 + 队列长度*单个消息的大小 */pxQueue->pcTail = pxQueue->pcHead + ( pxQueue->uxLength * pxQueue->uxItemSize );/* 当前消息队列的消息个数初始化为0 */pxQueue->uxMessagesWaiting = ( UBaseType_t ) 0U;/* 可写入消息的位置，初始为pcHead这个位置 */pxQueue->pcWriteTo = pxQueue->pcHead;/* 可读取消息的位置，初始为消息队列的队尾位置? */pxQueue->u.pcReadFrom = pxQueue->pcHead + ( ( pxQueue->uxLength - ( UBaseType_t ) 1U ) * pxQueue->uxItemSize );pxQueue->cRxLock = queueUNLOCKED;pxQueue->cTxLock = queueUNLOCKED;if( xNewQueue == pdFALSE )  /* 不是新的队列 */{/* 如果有阻塞的任务等待从队列读取，那么这些任务将保持阻塞状态，因为在此函数退出后，队列仍然是空的。如果有被阻塞的任务等待写入队列，那么应该解除阻塞，因为在这个函数退出后，将可能写入它*/if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE ){if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE ){queueYIELD_IF_USING_PREEMPTION();}}}else /* 是新的队列，则构建消息队列结构 */{vListInitialise( &( pxQueue->xTasksWaitingToSend ) );vListInitialise( &( pxQueue->xTasksWaitingToReceive ) );}}taskEXIT_CRITICAL(); /* 退出临界区 */return pdPASS;
}

消息队列发送与接收

向队列发送消息

  1. 任务级入队函数
/**********发送消息到队尾********************************************************************************/
BaseType_t xQueueSend(QueueHandle_t xQueue,//队列句柄,指明向哪个队列发送数据const void *pvItemToQueue,//指向要发送的消息TickType_t xTicksToWait);//队列满时，任务进入阻塞态等待队列空闲的最大时间（阻塞时间）
/**********发送消息到队尾********************************************************************************/
BaseType_t xQueueSendToBack(QueueHandle_t xQueue,//队列句柄,指明向哪个队列发送数据const void *pvItemToQueue,//指向要发送的消息TickType_t xTicksToWait);//阻塞时间
/**********发送消息到队头********************************************************************************/
BaseType_t xQueueSendToFront(QueueHandle_t xQueue,//队列句柄,指明向哪个队列发送数据const void *pvItemToQueue,//指向要发送的消息TickType_t xTicksToWait);//阻塞时间
/**********发送消息到队列（带覆写功能，即队列满了以后会覆写掉旧的数据）*************************************/
BaseType_t xQueueOverwrite(QueueHandle_t xQueue,//队列句柄,指明向哪个队列发送数据const void *pvItemToQueue);//指向要发送的消息
/**********任务级通用入队函数***************************************************************************/
BaseType_t xQueueGenericSend(QueueHandle_t xQueue, //队列句柄,指明向哪个队列发送数据const void * const pvItemToQueue, //指向要发送的消息TickType_t xTicksToWait,//阻塞时间const BaseType_t xCopyPosition);//入队方式（后向/前向/覆写）
/******************************************************************************************************/
返回值：发送消息成功，返回pdPASS;队列满消息发送失败，返回errQUEUE_FULL

任务级入队函数最终都是调用xQueueGenericSend()函数

BaseType_t xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, const BaseType_t xCopyPosition )

参数1：消息队列控制块，参数2：要发送的消息数据，参数3：发送允许的阻塞时间，参数4：发送到消息队列的位置。其中参数4的位置可选为队尾、队头、覆盖写入3种：

#define queueSEND_TO_BACK       ( ( BaseType_t ) 0 )
#define queueSEND_TO_FRONT      ( ( BaseType_t ) 1 )
#define queueOVERWRITE          ( ( BaseType_t ) 2 )

xQueueGenericSend()函数源码：

BaseType_t xQueueGenericSend(QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, const BaseType_t xCopyPosition){BaseType_t xEntryTimeSet = pdFALSE, xYieldRequired;TimeOut_t xTimeOut;Queue_t * const pxQueue = ( Queue_t * ) xQueue;/* 使用for死循环，是为了快速的处理消息拷贝 */for( ;; ){		taskENTER_CRITICAL(); //进入了临界段{/* 判断消息队列是否满了以及是否允许覆盖入队，任一条件成立都执行入队操作	*/if((pxQueue->uxMessagesWaiting < pxQueue->uxLength)||(xCopyPosition == queueOVERWRITE))			{/* 拷贝数据到队列操作空间内 */xYieldRequired = prvCopyDataToQueue(pxQueue, pvItemToQueue, xCopyPosition);#if ( configUSE_QUEUE_SETS == 1 ){ /*......省略掉与队列集相关代码......*/	}#else /* configUSE_QUEUE_SETS */{/* 判断等待接收的列表是否为空. */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 /* configUSE_QUEUE_SETS */taskEXIT_CRITICAL();	//退出临界段return pdPASS;			//返回pdPASS,标记入队成功}else{/* 队列满了不允许入队时，先判断是否需要阻塞 */if( xTicksToWait == ( TickType_t ) 0 ){/* 为0表示，表示没有阻塞时间 */taskEXIT_CRITICAL();//退出临界段traceQUEUE_SEND_FAILED( pxQueue );return errQUEUE_FULL;//返回队列已满}else if( xEntryTimeSet == pdFALSE ){/* 若有阻塞时间，就初始化时间结构体*/vTaskSetTimeOutState( &xTimeOut );xEntryTimeSet = pdTRUE;}else{/* 时间结构体已经初始化过了 */mtCOVERAGE_TEST_MARKER();}}}		taskEXIT_CRITICAL();//退出临界段		/* 执行到这里说明当前队列已满，并且设置了不为0的阻塞时间 */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;//返回队列已满}}
}
  1. 中断级入队函数
/**********发送消息到队尾*****************************************************************************/
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);
/**********发送消息到队列（带覆写功能，即队列满了以后会覆写掉旧的数据）********************************/
BaseType_t xQueueOverwriteFromISR(QueueHandle_t xQueue, const void * pvItemToQueue, BaseType_t * pxHigherPriorityTaskWoken);
/**********中断级通用入队函数***********************************************************************/
BaseType_t xQueueGenericSendFromISR(QueueHandle_t xQueue, const void * pvItemToQueue, BaseType_t * pxHigherPriorityTaskWoken, BaseType_t xCopyPosition);//入队方式（后向/前向/覆写）
/*************************************************************************************************/
返回值：发送消息成功，返回pdPASS;队列满消息发送失败，返回errQUEUE_FULL

中断级入队函数最终都是调用xQueueGenericSendFromISR()函数，下面来分析该函数源码

BaseType_t xQueueGenericSendFromISR(QueueHandle_t xQueue, const void * const pvItemToQueue, BaseType_t * const pxHigherPriorityTaskWoken, const BaseType_t xCopyPosition){BaseType_t xReturn;UBaseType_t uxSavedInterruptStatus;Queue_t * const pxQueue = ( Queue_t * ) xQueue;/* 带返回值的关闭中断，需要保存上次关闭中断的状态值，恢复时候写入 */uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();{/* 判断消息队列是否满了以及是否允许覆盖入队，任一条件成立都执行入队操作	*/if( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) ){/* 获取队列发送锁的状态值 */const int8_t cTxLock = pxQueue->cTxLock;/* 拷贝数据到队列操作空间内 */( void ) prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );/* 判断队列是否上锁 */if( cTxLock == queueUNLOCKED ){	//若队列未上锁#if ( configUSE_QUEUE_SETS == 1 ){/*......省略掉与队列集相关代码......*/}#else /* configUSE_QUEUE_SETS */{/* 判断等待接收的列表是否为空. */if(listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToReceive) == pdFALSE){/* 若不为空，表示有任务由于请求消息而阻塞，则改变阻塞态为就绪态. */if(xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive))!= pdFALSE){/* 若上一步变成就绪态的任务优先级比当前任务高，则标记为pdTRUE，表示要进行任务切换 */if( pxHigherPriorityTaskWoken != NULL ){*pxHigherPriorityTaskWoken = pdTRUE;}else{mtCOVERAGE_TEST_MARKER();}}else{mtCOVERAGE_TEST_MARKER();}}else{mtCOVERAGE_TEST_MARKER();}}#endif /* configUSE_QUEUE_SETS */}else{ //若队列已经上锁/* 发送锁加一，表示进行了一次入队操作 */pxQueue->cTxLock = ( int8_t ) ( cTxLock + 1 );}xReturn = pdPASS;//返回pdPASS，表示入队完成}else{	//若队列满		traceQUEUE_SEND_FROM_ISR_FAILED( pxQueue );xReturn = errQUEUE_FULL;//返回errQUEUE_FULL，表示队列满}}/* 开启中断，保存上次状态值 */portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );return xReturn;
}

从队列读取消息

  1. 任务级出队函数
/**********从队列中读取队列项，读取完后删除队列项**************************************************/
BaseType_t xQueueReceive(QueueHandle_t xQueue,//队列句柄 void * const pvBuffer,//保存数据的缓冲区TickType_t xTicksToWait);//阻塞时间，表示队列空时进入阻塞态等待数据的最大时间
/**********从队列中读取队列项，读取完后不删除队列项************************************************/
BaseType_t xQueuePeek(QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait);
/**********从队列中读取队列项通用函数************************************************************/
BaseType_t xQueueGenericReceive(QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait, const BaseType_t xJustPeeking);//标记读取成功后是否需要删除队列项
/**********************************************************************************************/
返回值：读取数据成功，返回pdTRUE；读取失败，返回pdFALSE

任务级出队函数最终都是调用xQueueGenericReceive()函数
xQueue：消息队列控制块
pvBuffer：要接收的消息数据
xTicksToWait：接收允许的阻塞时间
xJustPeeking：是否是Peek(只获取不删除)模式

BaseType_t xQueueGenericReceive( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait, const BaseType_t xJustPeeking )
{
BaseType_t xEntryTimeSet = pdFALSE;
TimeOut_t xTimeOut;
int8_t *pcOriginalReadPosition;
Queue_t * const pxQueue = ( Queue_t * ) xQueue;configASSERT( pxQueue );configASSERT( !( ( pvBuffer == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) ){configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );}#endif/* 这个函数放松了编码标准，允许在函数本身中使用返回语句。这样做是为了提高执行时间效率 */for( ;; ){taskENTER_CRITICAL();{const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;/* 现在队列中是否有数据?要运行调用任务，必须是希望访问队列的优先级最高的任务 */if( uxMessagesWaiting > ( UBaseType_t ) 0 ) /*消息队列中有数据*/{pcOriginalReadPosition = pxQueue->u.pcReadFrom;/* 记住读取位置，以防队列被读取 */prvCopyDataFromQueue( pxQueue, pvBuffer );/* 从队列中复制数据 */if( xJustPeeking == pdFALSE ) /*不是Peeking模式读取消息*/{traceQUEUE_RECEIVE( pxQueue );pxQueue->uxMessagesWaiting = uxMessagesWaiting - 1;/* 实际上删除数据，而不仅仅是读取 */#if ( configUSE_MUTEXES == 1 ){if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX ){   /* 如果有必要，记录实现优先级继承所需的信息 */pxQueue->pxMutexHolder = ( int8_t * ) pvTaskIncrementMutexHeldCount();}}#endif /* configUSE_MUTEXES */if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE ){if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE ){ queueYIELD_IF_USING_PREEMPTION(); }}}else  /*是Peeking模式读取消息（只读取，不删除）*/{traceQUEUE_PEEK( pxQueue ); /*执行PEEK*/pxQueue->u.pcReadFrom = pcOriginalReadPosition;/* 数据没有被移除，所以重置读指针 *//* 数据被留在队列中，因此请查看是否有其他任务在等待该数据 */if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE ){if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE ){  /* 等待的任务具有比该任务更高的优先级 */queueYIELD_IF_USING_PREEMPTION(); /*进行任务切换*/}}}taskEXIT_CRITICAL();return pdPASS;}else /*消息队列中没有数据*/{if( xTicksToWait == ( TickType_t ) 0 ){   /* 队列是空的，没有指定块时间(或者块时间已经过期)，所以现在离开 */taskEXIT_CRITICAL();traceQUEUE_RECEIVE_FAILED( pxQueue ); return errQUEUE_EMPTY;}else if( xEntryTimeSet == pdFALSE ){   /* 对列是空的，并且指定了块时间，因此配置超时结构 */vTaskSetTimeOutState( &xTimeOut );xEntryTimeSet = pdTRUE;}}}taskEXIT_CRITICAL();/* 临界区已经退出，中断和其他任务可以向队列发送或从队列接收消息 */vTaskSuspendAll();prvLockQueue( pxQueue );/* 更新超时状态，查看它是否已经过期 */if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )//阻塞等待未超时{if( prvIsQueueEmpty( pxQueue ) != pdFALSE )//消息队列为空{#if ( configUSE_MUTEXES == 1 ){if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX ){taskENTER_CRITICAL();{ vTaskPriorityInherit( ( void * ) pxQueue->pxMutexHolder ); }taskEXIT_CRITICAL();}}#endifvTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );/*添加任务到阻塞列表*/prvUnlockQueue( pxQueue );if( xTaskResumeAll() == pdFALSE ){ portYIELD_WITHIN_API(); }}else //消息队列为空{   /* 再试一次 */prvUnlockQueue( pxQueue );( void ) xTaskResumeAll();}}else//阻塞等待已超时{prvUnlockQueue( pxQueue );( void ) xTaskResumeAll();if( prvIsQueueEmpty( pxQueue ) != pdFALSE )//消息队列为空{traceQUEUE_RECEIVE_FAILED( pxQueue );return errQUEUE_EMPTY;}}}
}
  1. 中断级出队函数
/**********从队列中读取队列项，读取完后删除队列项*******************************************/
BaseType_t xQueueReceiveFromISR(QueueHandle_t xQueue,//队列句柄 void * const pvBuffer,//保存数据的缓冲区BaseType_t * pxTaskWoken);//标记退出函数后是否进行任务切换
/**********从队列中读取队列项，读取后不删除队列项*******************************************/
BaseType_t xQueuePeekFromISR(QueueHandle_t xQueue,//队列句柄 void * const pvBuffer,//保存数据的缓冲区);
返回值：读取数据成功，返回pdTRUE；读取失败，返回pdFALSE

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/704610.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Zynq UltraScale+ RFSoC 配置存储器器件

Zynq UltraScale+ RFSoC 配置存储器器件

Zynq UltraScale RFSoC 配置存储器器件 下表所示闪存器件支持通过 Vivado 软件对 Zynq UltraScale RFSoC 器件执行擦除、空白检查、编程和验证等配置操 作。 本附录中的表格所列赛灵思系列非易失性存储器将不断保持更新 &#xff0c; 并支持通过 Vivado 软件对其中所列…
阅读更多...
5.2 操作系统安装必备知识

5.2 操作系统安装必备知识

目前操作系统安装方式接近于全自动化&#xff0c;用户无需做过多操作就能完成操作系统安装。但是操作系统安装也有其复杂的一面&#xff0c;例如固件及分区表的不同就会导致操作系统安装失败。本节主要介绍系统安装的一些必备知识。 5.2.1 BIOS 概述 BIOS(Basic Input/Output …
阅读更多...
OpenAI 刚刚宣布了 “GPT-4o“ 免费用户开放、通过 API 可用

OpenAI 刚刚宣布了 “GPT-4o“ 免费用户开放、通过 API 可用

OpenAI 刚刚宣布了 “GPT-4o”。它可以通过语音、视觉和文本进行推理。 该模型速度提高了 2 倍&#xff0c;价格降低了 50%&#xff0c;比 GPT-4 Turbo 的速率限制高出了 5 倍。 它将对免费用户开放、通过 API 可用。 与 GPT-4 相比&#xff0c;GPT-4o 的速度和额外的编码能力…
阅读更多...
申请一个开发者域名

申请一个开发者域名

申请一个开发者域名 教程 fourm.js.org 因本地没安装 hexo 环境&#xff0c;模板下载的 html
阅读更多...
构建智能化不动产管理系统：数字化引领未来房地产行业发展

构建智能化不动产管理系统：数字化引领未来房地产行业发展

随着城市化进程的不断推进和房地产市场的持续发展&#xff0c;不动产管理系统的重要性日益凸显。在这一背景下&#xff0c;构建智能化不动产管理系统成为推动房地产行业数字化转型的关键举措。本文将深入探讨智能化不动产管理系统的构建与优势&#xff0c;助力房地产企业把握数…
阅读更多...
【上海大学计算机组成原理实验报告】五、机器语言程序实验

【上海大学计算机组成原理实验报告】五、机器语言程序实验

一、实验目的 理解计算机执行程序的实际过程。 学习编制机器语言简单程序的方法。 二、实验原理 根据实验指导书的相关内容&#xff0c;指令的形式化表示是指采用一种规范化的符号系统&#xff0c;以更清晰、精确地描述和表示指令的逻辑功能和操作步骤。 汇编是一种编程语言…
阅读更多...
MYSQL中的DQL

MYSQL中的DQL

语法&#xff1a; select 字段列表 from 表名列表 where 条件列表 group by 分组字段列表 having 分组后条件列表 order by 排序字段 limit 分页参数 条件查询 语法&#xff1a; 查询多个字段&#xff1a;select 字段1&#xff0c;字段2 from表名 查询所有字段&#xff1a…
阅读更多...
【Python大数据】PySpark

【Python大数据】PySpark

CSDN不支持多个资源绑定&#xff0c;另外两个数据文件下载&#xff1a; 订单数据-json.zip search-log.zip Apache Spark是用于大规模数据(large-scala data)处理的统一(unified)分析引擎 简单来说&#xff0c;Spark是一款分布式的计算框架&#xff0c;用于调度成百上千的服…
阅读更多...
ChatGPT未来可能应用于iPhone？

ChatGPT未来可能应用于iPhone？

苹果接即将与OpenAI达成协议 ChatGPT未来应用于iPhone 前言 就在5月11日&#xff0c;苹果公司正与OpenAI进行深入讨论&#xff0c;计划在其最新的iOS操作系统中整合OpenAI的先进技术。这一举措是苹果公司在为其产品线融入更先进的人工智能功能所做努力的一部分。 目前情况双方…
阅读更多...
知从科技战略客户经理张志强受邀出席2024 AutoSec中国汽车网络安全与数据安全峰会

知从科技战略客户经理张志强受邀出席2024 AutoSec中国汽车网络安全与数据安全峰会

4月11-12日&#xff0c;AutoSec8周年年会暨中国汽车网络安全及数据安全合规峰会在上海成功举办。此次峰会吸引了来自全球各地的头部汽车网络安全企业、OEM厂商、安全专家和学者等齐聚盛会&#xff0c;零距离共话智能网联汽车产业的新发展、新趋势。 知从科技董事长成云霞亲自带…
阅读更多...
JSP技术

JSP技术

三、JSP指令 1、page指令 在JSP页面中&#xff0c;经常需要对页面的某些特性进行描述&#xff0c;例如&#xff0c;页面的编码方式&#xff0c;JSP页面采用的语言等&#xff0c;这些特性的描述可以通过page指令实现。page指令的具体语法格式如下所示&#xff1a; <% page…
阅读更多...
zabbix触发器配置定期生效教程

zabbix触发器配置定期生效教程

在企业生产过程中&#xff0c;并非所有的设备都需要全天候、满负载运转&#xff0c;也有些仅需要周期性的运转即可。例如&#xff0c;在某家企业&#xff0c;有一批这样的机器&#xff0c;每天都会在固定的时间跑批量任务&#xff0c;期间&#xff0c;机器的CPU使用率会有明显的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023