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.mzph.cn/pingmian/12878.shtml

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

相关文章

Java项目：基于ssm框架实现的实验室耗材管理系统（B/S架构+源码+数据库+毕业论文+答辩PPT）

Java项目：基于ssm框架实现的实验室耗材管理系统（B/S架构+源码+数据库+毕业论文+答辩PPT）

一、项目简介 本项目是一套基于ssm框架实现的实验室耗材管理系统 包含&#xff1a;项目源码、数据库脚本等&#xff0c;该项目附带全部源码可作为毕设使用。 项目都经过严格调试&#xff0c;eclipse或者idea 确保可以运行&#xff01; 二、技术实现 jdk版本&#xff1a;1.8 …
阅读更多...
2024年最新最全面的软件测试面试题（四）

2024年最新最全面的软件测试面试题（四）

1、在项目中如何保证软件质量? 项目质量不仅仅是某个人或某个团队来保障的&#xff0c;而是整个团队一起努力的结果&#xff0c;因此&#xff0c;在公司级别需要 有一个规范的项目流程。 产品&#xff0c;保证迭代过程中的产品逻辑&#xff0c;对于可能的兼容&#xff0c;升…
阅读更多...
基于Springboot+Vue的Java项目-宠物商城网站系统开发实战(附演示视频+源码+LW)

基于Springboot+Vue的Java项目-宠物商城网站系统开发实战(附演示视频+源码+LW)

大家好&#xff01;我是程序员一帆&#xff0c;感谢您阅读本文&#xff0c;欢迎一键三连哦。 &#x1f49e;当前专栏&#xff1a;Java毕业设计 精彩专栏推荐&#x1f447;&#x1f3fb;&#x1f447;&#x1f3fb;&#x1f447;&#x1f3fb; &#x1f380; Python毕业设计 &am…
阅读更多...
C++列表实现

C++列表实现

文章目录 一、listView相关内容主要思想实例全部代码 二、QTreeView 一、listView 相关内容 QAbstractItemModel&#xff1a;一个抽象的类&#xff0c;为数据项模型提供抽象的接口&#xff0c;常见的的数据模型列如&#xff1a;QStringListModel,QStandardItemMode,QDirModel…
阅读更多...
AI大模型探索之路-训练篇23：ChatGLM3微调实战-基于P-Tuning V2技术的实践指南

AI大模型探索之路-训练篇23：ChatGLM3微调实战-基于P-Tuning V2技术的实践指南

系列篇章&#x1f4a5; AI大模型探索之路-训练篇1&#xff1a;大语言模型微调基础认知 AI大模型探索之路-训练篇2&#xff1a;大语言模型预训练基础认知 AI大模型探索之路-训练篇3&#xff1a;大语言模型全景解读 AI大模型探索之路-训练篇4&#xff1a;大语言模型训练数据集概…
阅读更多...
PG 检查点管理与Oracle的比较

PG 检查点管理与Oracle的比较

之前介绍过&#xff0c;在任何数据库中&#xff0c;一条DML操作执行都需要在内存中执行&#xff0c;但当操作越来越多&#xff0c;总有时候内存会写满&#xff0c;这时候就需要把内存中的块写入到磁盘&#xff0c;释放内存&#xff0c;保存数据。 写入到磁盘这一步&#xff0c;…
阅读更多...
报错：（idea端口被占用）Web server failed to start. Port 9090 was already in use.

报错：（idea端口被占用）Web server failed to start. Port 9090 was already in use.

cmd里面输入&#xff1a; netstat -ano|findstr "9090" 可以看到pid是9644 然后再打开任务管理器
阅读更多...
如何将此电脑放到桌面上（Windows10，非快捷方式）

如何将此电脑放到桌面上（Windows10，非快捷方式）

阅读更多...
特斯拉全自动驾驶（FSD）系统发展与解析

特斯拉全自动驾驶（FSD）系统发展与解析

引言 自动驾驶技术在近年来迅猛发展&#xff0c;多家科技巨头和汽车制造商纷纷投入巨资研发&#xff0c;试图领跑这一未来出行的革命。在众多企业中&#xff0c;特斯拉的全自动驾驶&#xff08;Full Self-Driving, FSD&#xff09;系统以其独特的“纯视觉”策略脱颖而出&#…
阅读更多...
白酒：酒精度数对白酒风味的影响与品鉴技巧

白酒：酒精度数对白酒风味的影响与品鉴技巧

云仓酒庄豪迈白酒作为品质的白酒品牌&#xff0c;其酒精度数对白酒风味的影响与品鉴技巧是品鉴爱好者关注的重点。酒精度数作为衡量白酒质量的一项重要指标&#xff0c;不仅决定了白酒的口感和风格&#xff0c;更在一定程度上体现了白酒的品质和价值。本文将探讨酒精度数对云仓…
阅读更多...
用友U8_dialog_moreUser_check.jsp SQL注入漏洞复现

用友U8_dialog_moreUser_check.jsp SQL注入漏洞复现

简介 用友GRP-U8是用友软件针对政府及公共部门推出的管理软件产品。 GRP是Government Resource Planning的缩写，即政府资源计划。 这个产品设计用于满足政府部门在财务管理、人力资源管理、资产管理、供应链管理等方面的需求。 漏洞复现 FOFA： app="用友-GRP-U8&quo…
阅读更多...
【Mysql数据库进阶02】第一范式~第四范式 Normal Form

【Mysql数据库进阶02】第一范式~第四范式 Normal Form

第一范式~第四范式Normal Form 0 引言1 第一范式2 第二范式3 第三范式4 BC范式5 第四范式总结 0 引言 因为软考&#xff0c;我又重新拾起了数据库&#xff0c;那么到底如何去判断它属于第几范式呢 1 第一范式 设R是一个关系模式&#xff0c;R属于第一范式当且仅当R中每一个…
阅读更多...
Zookeeper and RPC dubbo

Zookeeper and RPC dubbo

javaguide zookeeper面试题 Zookeeper 啥是Zookeeper干啥的 ZooKeeper 可以被用作注册中心、分布式锁&#xff1b; ZooKeeper 是 Hadoop 生态系统的一员&#xff1b; 构建 ZooKeeper 集群的时候&#xff0c;使用的服务器最好是奇数台。 启动ZK 下载安装解压 不过多赘述 我的…
阅读更多...
仿C#或Java基础类型自定义

仿C#或Java基础类型自定义

class Int{ private:int _value 0; public:operator int() const{ // 隐式转换return _value;}// 显式转换explicit operator int*() const { return nullptr; }operator(const int page){_value page;}operator float() const{return static_cast<float>(_value);}ope…
阅读更多...
字节跳动在2024年春季火山引擎Force原动力大会上隆重推出了“豆包大模型”家族

字节跳动在2024年春季火山引擎Force原动力大会上隆重推出了“豆包大模型”家族

此次大会以AI为主题&#xff0c;聚焦大模型的应用与发展&#xff0c;旨在引领AI技术的落地和推动各行各业的数字化转型。 字节跳动官网&#xff1a;https://www.bytedance.com/zh/ 豆包官网&#xff1a;https://www.doubao.com/chat/ 更多消息&#xff1a;https://heehel.co…
阅读更多...
Transformer - Self-Attention层的复杂度的计算

Transformer - Self-Attention层的复杂度的计算

Transformer - Self-Attention层的复杂度的计算 flyfish 矩阵的维度 下面矩阵的维度是32即 3行&#xff0c;2列 6,10等都是矩阵里的元素 如果矩阵A的列数与矩阵B的行数相同&#xff0c;那么这两个矩阵可以相乘。即&#xff0c;若A是一个mn矩阵&#xff0c;B是一个np矩阵&am…
阅读更多...
（论文笔记）TABDDPM：使用扩散模型对表格数据进行建模

（论文笔记）TABDDPM：使用扩散模型对表格数据进行建模

了解diffusion model&#xff1a;什么是diffusion model? 它为什么好用&#xff1f; - 知乎 摘要 去噪扩散概率模型目前正成为许多重要数据模式生成建模的主要范式。扩散模型在计算机视觉社区中最为流行&#xff0c;最近也在其他领域引起了一些关注&#xff0c;包括语音、NLP…
阅读更多...
k8s证书续期

k8s证书续期

证书即将到期了如何进行证书续签 k8s版本V1.23.6 1.查看证书期限 kubeadm certs check-expiration如果证书即将到期&#xff0c;此处的天数应该是几天&#xff0c;在过期之前进行续期&#xff0c;保证集群的可用 2. 备份证书 避免出现问题可以回退 cp -r /etc/kubernetes …
阅读更多...
使用websocket和服务建立链接慢的原因分析

使用websocket和服务建立链接慢的原因分析

1、java 项目使用websocketHandler创建websocket服务&#xff0c;在拦截器HttpSessionHandshakeInterceptor中&#xff0c;beforeHandshake日志到的很快&#xff0c;afterHandshake很慢 建立链接一直在连接中 2、原因分析&#xff1a; 找到服务器上的进程名 jps -l 3、使用…
阅读更多...
电脑数据丢失如何恢复？简单数据恢复的办法分享！

电脑数据丢失如何恢复？简单数据恢复的办法分享！

在使用电脑的过程中&#xff0c;数据丢失问题几乎是每位用户都可能遭遇的困境。那么&#xff0c;当电脑数据丢失时&#xff0c;我们该如何恢复呢&#xff1f;下面小编就分享几种电脑数据丢失后的恢复方法&#xff0c;轻松找回丢失的数据。 一、回收站找回 电脑上数据丢失的常…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023