FreeRTOS Queue

最新推荐文章于 2024-05-15 00:15:00 发布
最新推荐文章于 2024-05-15 00:15:00 发布
阅读量405 收藏
点赞数
分类专栏： 编程 文章标签： mcu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pipimuzi/article/details/124197416
版权

变量定义

typedef void *QueueHandle_t;  // Type by which queues are referenced. 
typedef void *QueueSetHandle_t; // Type by which queue sets are referenced.
typedef void *QueueSetMemberHandle_t; 

/* For internal use only. */
#define queueSEND_TO_BACK 	((BaseType_t)0)
#define queueSEND_TO_FRONT 	((BaseType_t)1)
#define queueOVERWRITE 		((BaseType_t)2)

/* For internal use only.  These definitions *must* match those in queue.c. */
#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)

/*
 * Definition of the queue used by the scheduler.
 * Items are queued by copy, not reference.  
 */
typedef struct QueueDefinition
{
	/*< Points to the beginning of the queue storage area. */
	int8_t *pcHead;	 
	 /*< Points to the byte at the end of the queue storage area. */  
	int8_t *pcTail;	 
	/*< Points to the free next place in the storage area. */ 
	int8_t *pcWriteTo; 
	
	/* Use of a union is an exception to the coding standard to ensure two mutually exclusive structure members don't appear simultaneously (wasting RAM). */
	union 
	{
		 /*< Points to the last place that a queued item was read from when the structure is used as a queue. */
		int8_t *pcReadFrom;	
		/*< Maintains a count of the number of times a recursive mutex has been recursively 'taken' when the structure is used as a mutex. */			 
		UBaseType_t uxRecursiveCallCount; 
	} u;
	
	/*< List of tasks that are blocked waiting to post onto this queue.  Stored in priority order. */
	List_t xTasksWaitingToSend;	 
	/*< List of tasks that are blocked waiting to read from this queue.  Stored in priority order. */  
	List_t xTasksWaitingToReceive; 

	/*< The number of items currently in the queue. */
	volatile UBaseType_t uxMessagesWaiting; 
	/*< The length of the queue defined as the number of items it will hold, not the number of bytes. */
	UBaseType_t uxLength;
	/*< The size of each items that the queue will hold. */
	UBaseType_t uxItemSize;					
	
	/*< Stores the number of items received from the queue (removed from the queue) while the queue was locked.  
		Set to queueUNLOCKED when the queue is not locked. */
	volatile int8_t cRxLock; 
	/*< Stores the number of items transmitted to the queue (added to the queue) while the queue was locked.  
		Set to queueUNLOCKED when the queue is not locked. */
	volatile int8_t cTxLock; 

} xQUEUE;

typedef xQUEUE Queue_t;

创建队列

Internally, within the FreeRTOS implementation, queues use two blocks of memory. The first block is used to hold the queue’s data structures. The second block is used to hold items placed into the queue. If a queue is created using xQueueCreate() then both blocks of memory are automatically dynamically allocated inside the xQueueCreate() function. If a queue is created using xQueueCreateStatic() then the application writer must provide the memory that will get used by the queue. xQueueCreateStatic() therefore allows a queue to be created without using any dynamic memory allocation.

#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) PRIVILEGED_FUNCTION;
								  
#define xQueueCreateStatic(uxQueueLength, uxItemSize, pucQueueStorage, pxQueueBuffer) \
xQueueGenericCreateStatic((uxQueueLength), (uxItemSize), (pucQueueStorage), (pxQueueBuffer), (queueQUEUE_TYPE_BASE))

QueueHandle_t xQueueGenericCreateStatic(const UBaseType_t uxQueueLength, 
										const UBaseType_t uxItemSize, 
										uint8_t *pucQueueStorage, 
										StaticQueue_t *pxStaticQueue, 
										const uint8_t ucQueueType) PRIVILEGED_FUNCTION;

QueueHandle_t xQueueGenericCreate(const UBaseType_t uxQueueLength, 
								  const UBaseType_t uxItemSize, 
								  const uint8_t ucQueueType)
{
	Queue_t *pxNewQueue;
	size_t xQueueSizeInBytes;
	uint8_t *pucQueueStorage;

	configASSERT(uxQueueLength > (UBaseType_t)0);

	if (uxItemSize == (UBaseType_t)0)
	{
		/* There is not going to be a queue storage area. */
		xQueueSizeInBytes = (size_t)0;
	}
	else
	{
		/* Allocate enough space to hold the maximum number of items that
		can be in the queue at any time. */
		xQueueSizeInBytes = (size_t)(uxQueueLength * uxItemSize); 
	}

	pxNewQueue = (Queue_t *)pvPortMalloc(sizeof(Queue_t) + xQueueSizeInBytes);

	if (pxNewQueue != NULL)
	{
		/* Jump past the queue structure to find the location of the queue storage area. */
		pucQueueStorage = ((uint8_t *)pxNewQueue) + sizeof(Queue_t);
		prvInitialiseNewQueue(uxQueueLength, uxItemSize, pucQueueStorage, ucQueueType, pxNewQueue);
	}

	return pxNewQueue;
}

static void prvInitialiseNewQueue(const UBaseType_t uxQueueLength, 
								  const UBaseType_t uxItemSize, 
								  uint8_t *pucQueueStorage, 
								  const uint8_t ucQueueType, 
								  Queue_t *pxNewQueue)
{
	/* Remove compiler warnings about unused parameters should
	configUSE_TRACE_FACILITY not be set to 1. */
	(void)ucQueueType;

	if (uxItemSize == (UBaseType_t)0)
	{
		pxNewQueue->pcHead = (int8_t *)pxNewQueue;
	}
	else
	{
		/* Set the head to the start of the queue storage area. */
		pxNewQueue->pcHead = (int8_t *)pucQueueStorage;
	}

	/* Initialise the queue members as described where the queue type is defined. */
	pxNewQueue->uxLength = uxQueueLength;
	pxNewQueue->uxItemSize = uxItemSize;
	(void)xQueueGenericReset(pxNewQueue, pdTRUE);
	
	traceQUEUE_CREATE(pxNewQueue);
}

BaseType_t xQueueGenericReset(QueueHandle_t xQueue, BaseType_t xNewQueue)
{
	Queue_t *const pxQueue = (Queue_t *)xQueue;

	configASSERT(pxQueue);

	taskENTER_CRITICAL();
	{
		pxQueue->pcTail = pxQueue->pcHead + (pxQueue->uxLength * pxQueue->uxItemSize);
		pxQueue->uxMessagesWaiting = (UBaseType_t)0U;
		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 there are tasks blocked waiting to read from the queue, then
			the tasks will remain blocked as after this function exits the queue
			will still be empty.  If there are tasks blocked waiting to write to
			the queue, then one should be unblocked as after this function exits
			it will be possible to write to it. */
			if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToSend)) == pdFALSE)
			{
				if (xTaskRemoveFromEventList(&(pxQueue->xTasksWaitingToSend)) != pdFALSE)
				{
					queueYIELD_IF_USING_PREEMPTION();
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
		else
		{
			/* Ensure the event queues start in the correct state. */
			vListInitialise(&(pxQueue->xTasksWaitingToSend));
			vListInitialise(&(pxQueue->xTasksWaitingToReceive));
		}
	}
	taskEXIT_CRITICAL();

	/* A value is returned for calling semantic consistency with previous versions. */
	return pdPASS;
}

范例

 struct AMessage
 {
	char ucMessageID;
	char ucData[ 20 ];
 };

 void vATask( void *pvParameters )
 {
 QueueHandle_t xQueue1, xQueue2;

	// Create a queue capable of containing 10 uint32_t values.
	xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
	if( xQueue1 == 0 )
	{
		// Queue was not created and must not be used.
	}

	// Create a queue capable of containing 10 pointers to AMessage structures.
	// These should be passed by pointer as they contain a lot of data.
	xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
	if( xQueue2 == 0 )
	{
		// Queue was not created and must not be used.
	}

	// ... Rest of task code.
 }

define xQueueCreateStatic(uxQueueLength, uxItemSize, pucQueueStorage, pxQueueBuffer)	\
xQueueGenericCreateStatic((uxQueueLength), (uxItemSize), (pucQueueStorage), (pxQueueBuffer), (queueQUEUE_TYPE_BASE))

 struct AMessage
 {
	char ucMessageID;
	char ucData[ 20 ];
 };

 #define QUEUE_LENGTH 10
 #define ITEM_SIZE sizeof( uint32_t )

 // xQueueBuffer will hold the queue structure.
 StaticQueue_t xQueueBuffer;

 // ucQueueStorage will hold the items posted to the queue.  Must be at least
 // [(queue length) * ( queue item size)] bytes long.
 uint8_t ucQueueStorage[ QUEUE_LENGTH * ITEM_SIZE ];

 void vATask( void *pvParameters )
 {
 QueueHandle_t xQueue1;

	// Create a queue capable of containing 10 uint32_t values.
	xQueue1 = xQueueCreate( QUEUE_LENGTH, // The number of items the queue can hold.
							ITEM_SIZE	  // The size of each item in the queue
							&( ucQueueStorage[ 0 ] ), // The buffer that will hold the items in the queue.
							&xQueueBuffer ); // The buffer that will hold the queue structure.

	// The queue is guaranteed to be created successfully as no dynamic memory
	// allocation is used.  Therefore xQueue1 is now a handle to a valid queue.

	// ... Rest of task code.
 }

#define xQueueSendToFront(xQueue, pvItemToQueue, xTicksToWait) \
		xQueueGenericSend((xQueue), (pvItemToQueue), (xTicksToWait), queueSEND_TO_FRONT)

 struct AMessage
 {
	char ucMessageID;
	char ucData[ 20 ];
 } xMessage;

 uint32_t ulVar = 10UL;

 void vATask( void *pvParameters )
 {
 QueueHandle_t xQueue1, xQueue2;
 struct AMessage *pxMessage;

	// Create a queue capable of containing 10 uint32_t values.
	xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );

	// Create a queue capable of containing 10 pointers to AMessage structures.
	// These should be passed by pointer as they contain a lot of data.
	xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );

	// ...

	if( xQueue1 != 0 )
	{
		// Send an uint32_t.  Wait for 10 ticks for space to become
		// available if necessary.
		if( xQueueSendToFront( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10 ) != pdPASS )
		{
			// Failed to post the message, even after 10 ticks.
		}
	}

	if( xQueue2 != 0 )
	{
		// Send a pointer to a struct AMessage object.  Don't block if the
		// queue is already full.
		pxMessage = & xMessage;
		xQueueSendToFront( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0 );
	}

	// ... Rest of task code.
 }

#define xQueueSendToBack(xQueue, pvItemToQueue, xTicksToWait) \
		xQueueGenericSend((xQueue), (pvItemToQueue), (xTicksToWait), queueSEND_TO_BACK)

 struct AMessage
 {
	char ucMessageID;
	char ucData[ 20 ];
 } xMessage;

 uint32_t ulVar = 10UL;

 void vATask( void *pvParameters )
 {
 QueueHandle_t xQueue1, xQueue2;
 struct AMessage *pxMessage;

	// Create a queue capable of containing 10 uint32_t values.
	xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );

	// Create a queue capable of containing 10 pointers to AMessage structures.
	// These should be passed by pointer as they contain a lot of data.
	xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );

	// ...

	if( xQueue1 != 0 )
	{
		// Send an uint32_t.  Wait for 10 ticks for space to become
		// available if necessary.
		if( xQueueSendToBack( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10 ) != pdPASS )
		{
			// Failed to post the message, even after 10 ticks.
		}
	}

	if( xQueue2 != 0 )
	{
		// Send a pointer to a struct AMessage object.  Don't block if the
		// queue is already full.
		pxMessage = & xMessage;
		xQueueSendToBack( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0 );
	}

	// ... Rest of task code.
 }

#define xQueueSend(xQueue, pvItemToQueue, xTicksToWait) \
		xQueueGenericSend((xQueue), (pvItemToQueue), (xTicksToWait), queueSEND_TO_BACK)


 struct AMessage
 {
	char ucMessageID;
	char ucData[ 20 ];
 } xMessage;

 uint32_t ulVar = 10UL;

 void vATask( void *pvParameters )
 {
 QueueHandle_t xQueue1, xQueue2;
 struct AMessage *pxMessage;

	// Create a queue capable of containing 10 uint32_t values.
	xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );

	// Create a queue capable of containing 10 pointers to AMessage structures.
	// These should be passed by pointer as they contain a lot of data.
	xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );

	// ...

	if( xQueue1 != 0 )
	{
		// Send an uint32_t.  Wait for 10 ticks for space to become
		// available if necessary.
		if( xQueueSend( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10 ) != pdPASS )
		{
			// Failed to post the message, even after 10 ticks.
		}
	}

	if( xQueue2 != 0 )
	{
		// Send a pointer to a struct AMessage object.  Don't block if the
		// queue is already full.
		pxMessage = & xMessage;
		xQueueSend( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0 );
	}

	// ... Rest of task code.
 }

#define xQueueOverwrite(xQueue, pvItemToQueue) xQueueGenericSend((xQueue), (pvItemToQueue), 0, queueOVERWRITE)

 void vFunction( void *pvParameters )
 {
 QueueHandle_t xQueue;
 uint32_t ulVarToSend, ulValReceived;

	// Create a queue to hold one uint32_t value.  It is strongly
	// recommended *not* to use xQueueOverwrite() on queues that can
	// contain more than one value, and doing so will trigger an assertion
	// if configASSERT() is defined.
	xQueue = xQueueCreate( 1, sizeof( uint32_t ) );

	// Write the value 10 to the queue using xQueueOverwrite().
	ulVarToSend = 10;
	xQueueOverwrite( xQueue, &ulVarToSend );

	// Peeking the queue should now return 10, but leave the value 10 in
	// the queue.  A block time of zero is used as it is known that the
	// queue holds a value.
	ulValReceived = 0;
	xQueuePeek( xQueue, &ulValReceived, 0 );

	if( ulValReceived != 10 )
	{
		// Error unless the item was removed by a different task.
	}

	// The queue is still full.  Use xQueueOverwrite() to overwrite the
	// value held in the queue with 100.
	ulVarToSend = 100;
	xQueueOverwrite( xQueue, &ulVarToSend );

	// This time read from the queue, leaving the queue empty once more.
	// A block time of 0 is used again.
	xQueueReceive( xQueue, &ulValReceived, 0 );

	// The value read should be the last value written, even though the
	// queue was already full when the value was written.
	if( ulValReceived != 100 )
	{
		// Error!
	}

	// ...
}

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

	 struct AMessage
	 {
		char ucMessageID;
		char ucData[ 20 ];
	 } xMessage;

	 uint32_t ulVar = 10UL;

	 void vATask( void *pvParameters )
	 {
	 QueueHandle_t xQueue1, xQueue2;
	 struct AMessage *pxMessage;

		// Create a queue capable of containing 10 uint32_t values.
		xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );

		// Create a queue capable of containing 10 pointers to AMessage structures.
		// These should be passed by pointer as they contain a lot of data.
		xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );

		// ...

		if( xQueue1 != 0 )
		{
			// Send an uint32_t.  Wait for 10 ticks for space to become
			// available if necessary.
			if( xQueueGenericSend( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10, queueSEND_TO_BACK ) != pdPASS )
			{
				// Failed to post the message, even after 10 ticks.
			}
		}

		if( xQueue2 != 0 )
		{
			// Send a pointer to a struct AMessage object.  Don't block if the
			// queue is already full.
			pxMessage = & xMessage;
			xQueueGenericSend( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0, queueSEND_TO_BACK );
		}

		// ... Rest of task code.
	 }

#define xQueuePeek(xQueue, pvBuffer, xTicksToWait) xQueueGenericReceive((xQueue), (pvBuffer), (xTicksToWait), pdTRUE)

 struct AMessage
 {
	char ucMessageID;
	char ucData[ 20 ];
 } xMessage;

 QueueHandle_t xQueue;

 // Task to create a queue and post a value.
 void vATask( void *pvParameters )
 {
 struct AMessage *pxMessage;

	// Create a queue capable of containing 10 pointers to AMessage structures.
	// These should be passed by pointer as they contain a lot of data.
	xQueue = xQueueCreate( 10, sizeof( struct AMessage * ) );
	if( xQueue == 0 )
	{
		// Failed to create the queue.
	}

	// ...

	// Send a pointer to a struct AMessage object.  Don't block if the
	// queue is already full.
	pxMessage = & xMessage;
	xQueueSend( xQueue, ( void * ) &pxMessage, ( TickType_t ) 0 );

	// ... Rest of task code.
 }

 // Task to peek the data from the queue.
 void vADifferentTask( void *pvParameters )
 {
 struct AMessage *pxRxedMessage;

	if( xQueue != 0 )
	{
		// Peek a message on the created queue.  Block for 10 ticks if a
		// message is not immediately available.
		if( xQueuePeek( xQueue, &( pxRxedMessage ), ( TickType_t ) 10 ) )
		{
			// pcRxedMessage now points to the struct AMessage variable posted
			// by vATask, but the item still remains on the queue.
		}
	}

	// ... Rest of task code.
 }

BaseType_t xQueuePeekFromISR(QueueHandle_t xQueue, void *const pvBuffer) PRIVILEGED_FUNCTION;

#define xQueueReceive(xQueue, pvBuffer, xTicksToWait) xQueueGenericReceive((xQueue), (pvBuffer), (xTicksToWait), pdFALSE)

 struct AMessage
 {
	char ucMessageID;
	char ucData[ 20 ];
 } xMessage;

 QueueHandle_t xQueue;

 // Task to create a queue and post a value.
 void vATask( void *pvParameters )
 {
 struct AMessage *pxMessage;

	// Create a queue capable of containing 10 pointers to AMessage structures.
	// These should be passed by pointer as they contain a lot of data.
	xQueue = xQueueCreate( 10, sizeof( struct AMessage * ) );
	if( xQueue == 0 )
	{
		// Failed to create the queue.
	}

	// ...

	// Send a pointer to a struct AMessage object.  Don't block if the
	// queue is already full.
	pxMessage = & xMessage;
	xQueueSend( xQueue, ( void * ) &pxMessage, ( TickType_t ) 0 );

	// ... Rest of task code.
 }

 // Task to receive from the queue.
 void vADifferentTask( void *pvParameters )
 {
 struct AMessage *pxRxedMessage;

	if( xQueue != 0 )
	{
		// Receive a message on the created queue.  Block for 10 ticks if a
		// message is not immediately available.
		if( xQueueReceive( xQueue, &( pxRxedMessage ), ( TickType_t ) 10 ) )
		{
			// pcRxedMessage now points to the struct AMessage variable posted
			// by vATask.
		}
	}

	// ... Rest of task code.
 }

BaseType_t xQueueGenericReceive(QueueHandle_t xQueue, void *const pvBuffer, TickType_t xTicksToWait, const BaseType_t xJustPeek) PRIVILEGED_FUNCTION;

	 struct AMessage
	 {
		char ucMessageID;
		char ucData[ 20 ];
	 } xMessage;

	 QueueHandle_t xQueue;

	 // Task to create a queue and post a value.
	 void vATask( void *pvParameters )
	 {
	 struct AMessage *pxMessage;

		// Create a queue capable of containing 10 pointers to AMessage structures.
		// These should be passed by pointer as they contain a lot of data.
		xQueue = xQueueCreate( 10, sizeof( struct AMessage * ) );
		if( xQueue == 0 )
		{
			// Failed to create the queue.
		}

		// ...

		// Send a pointer to a struct AMessage object.  Don't block if the
		// queue is already full.
		pxMessage = & xMessage;
		xQueueSend( xQueue, ( void * ) &pxMessage, ( TickType_t ) 0 );

		// ... Rest of task code.
	 }

	 // Task to receive from the queue.
	 void vADifferentTask( void *pvParameters )
	 {
	 struct AMessage *pxRxedMessage;

		if( xQueue != 0 )
		{
			// Receive a message on the created queue.  Block for 10 ticks if a
			// message is not immediately available.
			if( xQueueGenericReceive( xQueue, &( pxRxedMessage ), ( TickType_t ) 10 ) )
			{
				// pcRxedMessage now points to the struct AMessage variable posted
				// by vATask.
			}
		}

		// ... Rest of task code.
	 }

BaseType_t xQueueGenericReceive(QueueHandle_t xQueue, void *const pvBuffer, TickType_t xTicksToWait, const BaseType_t xJustPeek) PRIVILEGED_FUNCTION;
皮皮木子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FreeRTOS 教程指南 学习笔记 第四章 队列管理
gjhave的博客
08-19 796
如何创建一个队列。队列如何管理其包含的数据。如何将数据发送到队列。如何从队列中接收数据。在队列上阻塞的含义。如何在多个队列上阻塞。如何覆盖队列中的数据。如何清除一个队列。写入队列和阅读队列时任务优先级的影响。本章中只介绍了任务到任务的通信。第6章介绍了任务中断和中断到任务通信。
【FreeRTOS】9.STM32移植-队列
qq_44078824的博客
08-23 288
定义： 队列是任务与任务、中断与任务直接通信二准备的。队列用于消息传递，又叫做消息队列。需要交流的数据保存在队列中，叫做队列项目。队列所能保存的队列项数量叫队列长度。 typedef struct QueueDefinition { int8_t *pcHead; //头 int8_t *pcTail; //尾 int8_t *pcWriteTo; //下一个空闲区域 union //联合体 { int8_t *pcReadFrom; //当用作队列指向
浅析Free RTOS中Queue的应用
最新发布
mftang的博客
05-15 862
本文主要介绍Queue的相关知识，包括Queue的定义，发送和接收消息的方式等内容。重点使用Free RTOS中Queue的接口，实现数据在不同task之间的发送和接收的案例，并在板卡上验证该功能。
4.3 FreeRTOS----队列的应用
IoT的搬运工！！！
08-27 414
xQueueCreate（）API函数         在使用队列之前必须明确创建一个队列。         队列由句柄引用，它们是QueueHandle_t类型的变量。 xQueueCreate() API函数创建一个队列，并返回一个引用其创建的队列的QueueHandle_t。         FreeRTOS V9.0.0还包括xQueueCreateStatic（）函数，它在编译时分
【ESP32】嵌入式FreeRtos--队列Queue
保持热爱，奔赴山海。
04-09 934
多个任务输入一个队列，一个任务读队列中的数据，此时注意设置任务的优先级别，队列：先入先出(FIFO,first in first out)
C++它 typedef void *HANDLE
weixin_33742618的博客
07-17 613
阅读时编写代码的代码，经常看到一个代码： typedef void *HANDLE ，这是它背后的故事？怎么理解呢？ 不明白的时候。这是非常美妙的感觉，后来我才知道这，这是typedef定义，就在void*键入罢了。那是，HANDLE相当于void *，们能够叫它披着句柄皮的指针(PS:指针和句柄是有差别的，在这说句废话)； 对于void* 神通广大。由于它作为函数參数or函数返回值，...
stm32-freeRTOS-queue
04-08
主要介绍Queue的相关知识，包括Queue的定义，发送和接收消息的方式等内容。重点使用Free RTOS中Queue的接口，实现数据在不同task之间的发送和接收的案例，并在板卡上验证该功能。
FreeRTOS 原创代码示例
07-10
Write a program using FreeRTOS that performs the following:  The program has three tasks: TxTask1, TxTask2, RxTask  The program has one global counter (an unsigned integer): globalCount  The ...
05_FreeRTOS_Simple_Queue.rar
07-08
介绍如何使用Queue在任务之间进行通信。队列是任务之间发送和接收数据的最简单方法。在一个简单的队列中，所有元素都是同一类型。
freertos分享.docx
08-26
3.2 队列（Queue） FreeRTOS提供了多种类型的队列，如发送接收队列、事件标志组、二进制信号量等，用于任务间的数据交换和同步。 3.3 软件定时器（Software Timer） 软件定时器允许开发者设置周期性的事件，它们...
FreeRTOS_RAM使用情况及优化方法.pdf
11-16
| 队列 | 76 bytes/Queue | 存储信息额外，必须 | | 任务 | 64 bytes/Task | 任务堆栈额外，必须 | | 定时器 | 56 bytes/Timer | 可选，推荐客户使用 | 在产品评估阶段，参考这些信息进行一般的估计是可行的，但...
FreeRTOS-队列管理
weixin_44483794的博客
10-25 618
队列”提供了任务到任务、任务到中断和中断到任务的通信机制。
FreeRTOS队列集、事件标志组 | FreeRTOS十一
qq_57663276的博客
02-12 1004
FreeRTOS队列集、事件标志组
FreeRTOS笔记（四）消息队列
m0_58575472的博客
03-14 325
如果有多个任务同时在阻塞状态等待队列数据，优先级高的任务会在数据到达时进入就绪状态；写队列的任务个数没有限制，当多个任务写"满队列"时，这些任务都会进入阻塞状态：有多个任务在等待同一个队列的空间。[5]的优先级最高，创建的任务优先级为x就挂在ReadList[x]的链表中，系统执行任务时先从ReadList[5]开始依次向下检索。，当多个任务读取空队列时，这些任务都会进入阻塞状态：有多个任务在等待同一个队列的数据。使用拷贝方法时，则无此限制：内核有足够的权限，把数据复制进队列、再把数据复制出队列。
韦东山freeRTOS系列教程之【第五章】队列(queue)
韦东山嵌入式专栏
11-22 1万+
文章目录系列教程总目录概述5.1 队列的特性5.1.1 常规操作5.1.2 传输数据的两种方法5.1.3 队列的阻塞访问5.2 队列函数5.2.1 创建5.2.2 复位5.2.3 删除5.2.4 写队列5.2.5 读队列5.2.6 查询5.2.7 覆盖/偷看5.3 示例8: 队列的基本使用5.4 示例9: 分辨数据源5.5 示例10: 传输大块数据5.6 示例11: 邮箱(Mailbox) 需要获取更好阅读体验的同学，请访问我专门设立的站点查看，地址：http://rtos.100ask.net/ 系列
C++之 typedef void *HANDLE
Jackery's Special Column
11-20 5273
在书写代码与阅读代码的时候，经常会看到这一句代码： typedef void *HANDLE ，它是何方神圣呢？如何理解呢？ 不理解它的时候，感觉它很神奇，知道它以后，它就是个typedef的定义，只不过是void*类型罢了，也就是HANDLE等价于void *，我们可以叫它披着句柄皮的指针(PS:指针和句柄是有区别的，在这说句废话)；
FreeRTOS内核详解----Queue
热门推荐
hehao9051的专栏
05-29 1万+
FreeRTOS内核详解—-Queue队列的主要作用是任务间或者任务与中断之间的通信或者同步，对于FreeRTOS内核而言，队列的主要用在信号量的实现上。因为供外部使用的函数基本都是对几个特定主要函数，使用宏进行包装实现的，这里只讲述主要的函数。同时FreeRTOS给没有队列基本操作函数提供了一个可选简化版本，简化版本中所有的操作都需要关中断，以此来达到简化操作，提高速度的目的。简化版本的函数中带有
STM32CubeMX——FREERTOS学习：消息队列Queue
m0_49968063的博客
03-28 2127
队列，也叫消息队列，就是把消息一条一条的排个队。 比如创建了一个消息队列，这个消息队列可以存10条消息。任务A可以往里存消息，任务B也可以往里存。这个存的消息是要讲先来后到的，存满了10条消息就不能存了。假设任务C从里面去消息，也是一条一条的取，按照先后顺序取，先存的先取，后存的后取。信息取一个，队列里面就少一个，取10个之后，消息队列就空了。 往队列里面存消息，如果队列已经满了，可以一直等着，直到队列里面有空位置，也可以等一会，没空位离开。 从队列里面取消息，如果队列已经空了，可以一直等着，直到队列
【FreeRTOS】09 消息队列
小白白学电子
07-13 1293
本节来讲讲freeRTOS的消息队列。操作系统里常说的“消息队列”，和数据结构课程里常说的“队列”是同一个概念，都是一个线性的存储表。只不过数据结构里的“队列”通常指的是先进先出队列（也就是FIFO），有一个写入口和一个读出口，从一端写入数据，另一端读出数据，先写入队列的先被读出；而操作系统里实现的消息队列功能会更丰富一些，比如FreeRTOS的消息队列支持FIFO（先进先出）和LIFO（后进先出）两种存取方式，并且它还解决了多任务访问冲突、实现了任务等待队列时的阻塞功能。......
freertos queue
08-19
FreeRTOS queue 是一个在 FreeRTOS 实时操作系统中用于线程间通信的机制。它允许一个任务将数据发送到队列中，然后另一个任务可以从队列中接收到这些数据。 队列可以是固定长度的，也可以是动态分配的。固定长度...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值