FreeRTOS源码理解（七）——队列

已于 2023-10-15 22:27:16 修改
阅读量288 收藏 3
点赞数
CC 4.0 BY-SA版权
分类专栏： freeRTOS 文章标签： c语言 单片机
于 2023-10-15 22:08:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_59201432/article/details/133848693
该博客围绕FreeRTOS源码展开，涵盖思路梳理、中断、任务等多方面内容。重点介绍了队列，包括队列结构体、创建、上锁、解锁等操作，还提及信号量均用队列实现，最后进行了文档汇总。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

FreeRTOS源码理解（一）——FreeRTOS思路梳理

FreeRTOS源码理解（二）——中断和列表项

FreeRTOS源码理解（三）——任务

FreeRTOS源码理解（四）——任务调度器

FreeRTOS源码理解（五）——任务切换

FreeRTOS源码理解（六）——时间管理

FreeRTOS源码理解（七）——队列

FreeRTOS源码理解（八）——信号量

FreeRTOS源码理解（九）——事件组和任务通知

FreeRTOS源码理解（十）——软件定时器和空闲任务

FreeRTOS源码理解（十一）——内存管理

FreeRTOS源码理解（十二）——汇总

文章目录

队列

信号量均是用队列实现的，包括二值信号量，计数信号量，互斥信号量，递归互斥信号量

队列结构体

typedef struct QueueDefinition
{
	int8_t *pcHead;					/* 指向队列存储区开始地址 */
	int8_t *pcTail;					/* 指向队列存储区末尾 */
	int8_t *pcWriteTo;				/* 指向存储区下一个空闲区域 */

	union							/* 用一个union，节省空间 */
	{
		int8_t *pcReadFrom;			/* 用作队列时，指向第一个出队的队列项首地址 */
		UBaseType_t uxRecursiveCallCount;/* 用作递归互斥量时，用来记录递归互斥量被调用的次数 */
	} u;

	List_t xTasksWaitingToSend;		/* 等待发送列表，因为队列满了而无法入队的任务挂在此列表上，按优先级顺序挂载 */
	List_t xTasksWaitingToReceive;	/* 等待接收队列，因为队列为而接收失败的任务挂在此列表上，按优先级顺序挂载 */

	volatile UBaseType_t uxMessagesWaiting;/* 目前队列中的消息数量 */
	UBaseType_t uxLength;			/* 队列存储区长度 */
	UBaseType_t uxItemSize;			/* 队列项最大长度，以字节为单位 */

	volatile int8_t cRxLock;		/* 队列上锁后，出队的队列项数量；当队列没有上锁，此字段为queueUNLOCKED */
	volatile int8_t cTxLock;		/* 队列上锁后，入队的队列项数量；当队列没有上锁，此字段为queueUNLOCKED */

	#if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
		uint8_t ucStaticallyAllocated;	/* 静态存储的话，设置为pdTURE */
	#endif

	#if ( configUSE_QUEUE_SETS == 1 )	//队列集
		struct QueueDefinition *pxQueueSetContainer;
	#endif

	#if ( configUSE_TRACE_FACILITY == 1 )	//跟踪调试
		UBaseType_t uxQueueNumber;
		uint8_t ucQueueType;
	#endif

} xQUEUE;

typedef xQUEUE Queue_t;

队列创建

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 )
    {
        /* 队列项大小为0，不需要存储区 */
        xQueueSizeInBytes = ( size_t ) 0;
    }
    else
    {
        /* 分配相应大小的存储区 */
        xQueueSizeInBytes = ( size_t ) ( uxQueueLength * uxItemSize ); 
    }

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

    /* 申请内存成功 */
    if( pxNewQueue != NULL )
    {
        pucQueueStorage = ( ( uint8_t * ) pxNewQueue ) + sizeof( Queue_t );

        #if( configSUPPORT_STATIC_ALLOCATION == 1 )
        {
            /* 动态方法创建，这个字段赋为pdFALSE */
            pxNewQueue->ucStaticallyAllocated = pdFALSE;
        }
        #endif /* configSUPPORT_STATIC_ALLOCATION */

        /* 初始化一个新的队列，为队列中的成员变量赋值，处理发送和接收列表 */
        prvInitialiseNewQueue( uxQueueLength, uxItemSize, pucQueueStorage, ucQueueType, pxNewQueue );
    }

    return pxNewQueue;
}

队列上锁

#define prvLockQueue( pxQueue )								\
	taskENTER_CRITICAL();									\
	{														\
		if( ( pxQueue )->cRxLock == queueUNLOCKED )			\
		{													\
			( pxQueue )->cRxLock = queueLOCKED_UNMODIFIED;	\
		}													\
		if( ( pxQueue )->cTxLock == queueUNLOCKED )			\
		{													\
			( pxQueue )->cTxLock = queueLOCKED_UNMODIFIED;	\
		}													\
	}														\
	taskEXIT_CRITICAL()

将cRxLock和cTxLock设置为queueLOCKED_UNMODIFIED

队列解锁

static void prvUnlockQueue( Queue_t * const pxQueue )
{
	/* 此函数必须在任务调度器挂起后调用 */

    /* 上锁计数器会记录上锁期间入队或出队的队列项数量 */
	/* 上锁后队列项可以加入或移出队列，但是相应的事件列表不会更新 */
    /* 解锁时要更新相应的事件列表 */
	taskENTER_CRITICAL();
	{
		int8_t cTxLock = pxQueue->cTxLock;

		/* 判断数据在上锁期间是否被加入到队列中 */
		while( cTxLock > queueLOCKED_UNMODIFIED )
		{
			/**********************************************************/
            /**********************省略队列集代码************************/
            /**********************************************************/
            
			#else /* configUSE_QUEUE_SETS */
			{
				/* 将任务从事件列表中移除 */
				if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
				{
					if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
					{
						/* 从列表中移除任务优先级更高，进行一次任务切换 */
						vTaskMissedYield();
					}
					else
					{
						mtCOVERAGE_TEST_MARKER();
					}
				}
				else
				{
					break;
				}
			}
			#endif /* configUSE_QUEUE_SETS */

			--cTxLock;
		}

		pxQueue->cTxLock = queueUNLOCKED;
	}
	taskEXIT_CRITICAL();

	/* 处理cRxLock */
	taskENTER_CRITICAL();
	{
		int8_t cRxLock = pxQueue->cRxLock;

		while( cRxLock > queueLOCKED_UNMODIFIED )
		{
			if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
			{
				if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
				{
					vTaskMissedYield();
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}

				--cRxLock;
			}
			else
			{
				break;
			}
		}

		pxQueue->cRxLock = queueUNLOCKED;
	}
	taskEXIT_CRITICAL();
}

向队列发送消息

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;

	configASSERT( pxQueue );
	configASSERT( !( ( pvItemToQueue == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );
	configASSERT( !( ( xCopyPosition == queueOVERWRITE ) && ( pxQueue->uxLength != 1 ) ) );
	#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
	{
		configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
	}
	#endif

	for( ;; )
	{
        /* 关中断，进入临界区 */
		taskENTER_CRITICAL();
		{
			/* 查看队列中是否还有剩余空间，如果采用的覆写方式入队则不用在乎队列是否是满的 */
			if( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) )
			{
				traceQUEUE_SEND( pxQueue );
                /* 将数据拷贝到队列中 */
				xYieldRequired = prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );
				
                /**********************************************************/
                /**********************省略队列集代码************************/
                /**********************************************************/
                
                #else /* configUSE_QUEUE_SETS */
				{
					/* 判断是否有任务在等待队列消息而阻塞 */
					if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
					{
                        /* 有的话移除任务，取消阻塞：将TCB中的事件等待列表项和状态等待列表项从当前所在列表中移除，添加任务到就绪列表 */
						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();
					}
				}

				taskEXIT_CRITICAL();
				return pdPASS;
			}
            /* 如果队列满了 */
			else
			{
				if( xTicksToWait == ( TickType_t ) 0 )
				{
					taskEXIT_CRITICAL();
					/* 阻塞时间为0则直接返回 */
					traceQUEUE_SEND_FAILED( pxQueue );
					return errQUEUE_FULL;
				}
				else if( xEntryTimeSet == pdFALSE )
				{
					/* 阻塞时间不为0则初始化超时时间结构体 */
					vTaskSetTimeOutState( &xTimeOut );
					xEntryTimeSet = pdTRUE;
				}
				else
				{
					/* 时间结构体已经初始化过了 */
					mtCOVERAGE_TEST_MARKER();
				}
			}
		}
		taskEXIT_CRITICAL();

        /* 挂起任务调度器 */
		vTaskSuspendAll();
        /* 队列上锁 */
		prvLockQueue( pxQueue );

		/* 更新时间并检查是否超时 */
		if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )
		{
            /* 未超时 */
			if( prvIsQueueFull( pxQueue ) != pdFALSE )
			{
				traceBLOCKING_ON_QUEUE_SEND( pxQueue );
                /* 将当前任务的事件列表项加入到队列的等待发送列表中 */
                /* 将当前任务的状态列表项从就绪列表中移除，将其加入到延时列表中 */
				vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToSend ), xTicksToWait );

				/* 解锁队列 */
				prvUnlockQueue( pxQueue );

				/* 唤醒所有，开启OS时钟计数 */
				if( xTaskResumeAll() == pdFALSE )
				{
                    /* 保证执行一次上下文切换 */
					portYIELD_WITHIN_API();
				}
			}
			else
			{
				/* 如果队列未满，解锁队列，再试一次 */
				prvUnlockQueue( pxQueue );
				( void ) xTaskResumeAll();
			}
		}
		else
		{
			/* 超时 */
			prvUnlockQueue( pxQueue );
			( void ) xTaskResumeAll();

			traceQUEUE_SEND_FAILED( pxQueue );
			return errQUEUE_FULL;
		}
	}
}

读取队列数据

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 )		//如果队列中有数据
			{
				/* 读取数据到pvBuffer中，并更新u.pcReadFrom的值 */
				pcOriginalReadPosition = pxQueue->u.pcReadFrom;

				prvCopyDataFromQueue( pxQueue, pvBuffer );

                /* 判断是否删除读取的队列项 */
				if( xJustPeeking == pdFALSE ) //如果要删除读取的队列项
				{
					traceQUEUE_RECEIVE( pxQueue );

					/* 更新队列中队列项数量，完成数据的删除 */
					pxQueue->uxMessagesWaiting = uxMessagesWaiting - 1;

					#if ( configUSE_MUTEXES == 1 )		//用户定义了互斥信号量
					{
						if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )	//如果此队列是互斥信号量
						{
							/* 将pxMutexHolder标记为获取到互斥信号量的任务TCB */
                            /* 将任务TCB中互斥信号量的数量加一   ( pxCurrentTCB->uxMutexesHeld )++; */
							pxQueue->pxMutexHolder = ( int8_t * ) pvTaskIncrementMutexHeldCount(); 
						}
						else
						{
							mtCOVERAGE_TEST_MARKER();
						}
					}
					#endif /* configUSE_MUTEXES */

                    /* 如果等待发送列表不为空，有任务因队列满而阻塞，则唤醒一个发送任务 */
					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 //如果不删除队列项
				{
					traceQUEUE_PEEK( pxQueue );

					/* 不删除队列项，恢复u.pcReadFrom */
					pxQueue->u.pcReadFrom = pcOriginalReadPosition;

					/* 队列中还有数据，查看是否有其他任务阻塞在获取队列数据中，有的话唤醒 */
					if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
					{
						if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
						{
							queueYIELD_IF_USING_PREEMPTION();
						}
						else
						{
							mtCOVERAGE_TEST_MARKER();
						}
					}
					else
					{
						mtCOVERAGE_TEST_MARKER();
					}
				}

				taskEXIT_CRITICAL();
				return pdPASS;
			}
			else	//队列中无数据
			{
				if( xTicksToWait == ( TickType_t ) 0 )
				{
					/* 队列为空且等待时间为0，直接返回 */
					taskEXIT_CRITICAL();
					traceQUEUE_RECEIVE_FAILED( pxQueue );
					return errQUEUE_EMPTY;
				}
				else if( xEntryTimeSet == pdFALSE )
				{
					/* 确保时间结构体的初始化 */
					vTaskSetTimeOutState( &xTimeOut );
					xEntryTimeSet = pdTRUE;
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
		}
		taskEXIT_CRITICAL();

		/* 中断和其他任务可以向队列中发送和接收数据，现在关键部分已退出 */

		vTaskSuspendAll();
		prvLockQueue( pxQueue );

		/* 更新时钟，检查是否超时 */
		if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )
		{
            /* 未超时 */
            /* 队列仍为空 */
			if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
			{
				traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue );

				#if ( configUSE_MUTEXES == 1 )		/* 是否使用互斥信号量 */
				{
					if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )		/* 此队列表示互斥信号量 */
					{
						taskENTER_CRITICAL();
						{
                            //到这说明队列为空，互斥信号量在其他任务中
                            //处理优先级继承，避免优先级翻转
							vTaskPriorityInherit( ( void * ) pxQueue->pxMutexHolder );
						}
						taskEXIT_CRITICAL();
					}
					else
					{
						mtCOVERAGE_TEST_MARKER();
					}
				}
				#endif

                /* 将任务的时间列表项插入到队列的等待列表 */
                /* 将任务的状态列表项插入到延时列表 */
				vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );
				prvUnlockQueue( pxQueue );
				if( xTaskResumeAll() == pdFALSE )
				{
					portYIELD_WITHIN_API();
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
			else
			{
				/* 队列不为空，有其他任务或中断往队列中写了数据 */
                /* 解锁队列，再试一次 */
				prvUnlockQueue( pxQueue );
				( void ) xTaskResumeAll();
			}
		}
		else
		{
			prvUnlockQueue( pxQueue );
			( void ) xTaskResumeAll();

			if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
			{
				traceQUEUE_RECEIVE_FAILED( pxQueue );
				return errQUEUE_EMPTY;
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
	}
}

取消事件列表任务阻塞 xTaskRemoveFromEventList

BaseType_t xTaskRemoveFromEventList( const List_t * const pxEventList )
{
    TCB_t *pxUnblockedTCB;
    BaseType_t xReturn;

    //获取列表中第一个列表项的所属任务TCB
	pxUnblockedTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxEventList );
	configASSERT( pxUnblockedTCB );
    /* 将要解除阻塞的任务事件列表项移出 */
	( void ) uxListRemove( &( pxUnblockedTCB->xEventListItem ) );

	if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )	//任务调度器未被挂起
	{
        /* 将任务TCB的状态列表项从延时列表中移出，将其添加到就绪列表中 */
		( void ) uxListRemove( &( pxUnblockedTCB->xStateListItem ) );
		prvAddTaskToReadyList( pxUnblockedTCB );
	}
	else
	{
		/* 将任务事件列表项添加到等待唤醒列表中 */
		vListInsertEnd( &( xPendingReadyList ), &( pxUnblockedTCB->xEventListItem ) );
	}

	if( pxUnblockedTCB->uxPriority > pxCurrentTCB->uxPriority )
	{
		/* 如果解除阻塞的优先级较现在运行的任务优先级高 */
		xReturn = pdTRUE;

		/* 标志一下，之后调用一次任务切换 */
		xYieldPending = pdTRUE;
	}
	else
	{
		xReturn = pdFALSE;
	}

	#if( configUSE_TICKLESS_IDLE != 0 )
	{
		/* If a task is blocked on a kernel object then xNextTaskUnblockTime
		might be set to the blocked task's time out time.  If the task is
		unblocked for a reason other than a timeout xNextTaskUnblockTime is
		normally left unchanged, because it is automatically reset to a new
		value when the tick count equals xNextTaskUnblockTime.  However if
		tickless idling is used it might be more important to enter sleep mode
		at the earliest possible time - so reset xNextTaskUnblockTime here to
		ensure it is updated at the earliest possible time. */
		prvResetNextTaskUnblockTime();
	}
	#endif

	return xReturn;
}

文档汇总

文档汇总

FreeRTOS源码理解（一）——FreeRTOS思路梳理
m0_59201432的博客
10-15 820
对FreeRTOS任务调度，信号量等实现基本机制进行梳理
FreeRTOS源码理解（十一）——内存管理
m0_59201432的博客
10-15 317
heap_1,heap_2,heap_3,heap_4,heap_5内存分配方法
FreeRTOS源码探析之——消息队列
码农爱学习的博客
01-03 935
1 消息队列基础 1.1 消息队列的运作机制 创建消息队列时FreeRTOS会先给消息队列分配一块内存空间，这块内存的大小等于消息队列控制块大小加上（单个消息空间大小与消息队列长度的乘积），接着再初始化消息队列，此时消息队列为空。 任务或者中断服务程序都可以给消息队列发送消息，当发送消息时: 如果队列未满或者允许覆盖入队，FreeRTOS会将消息拷贝到消息队列队尾 否则（队列已满），会根据用户指定的阻塞超时时间进行阻塞，在这段时间中，如果队列一直不允许入队，该任务将保持阻塞状态以等待队列允许入队。 当其
手把手教你FreeRTOS源码详解（三）——队列
weixin_46461874的博客
12-27 4082
当xNewQueue为pdFALSE时，该队列已经初始化过了，只需要进行复位，队列复位后为空，出队阻塞的任务仍然保存阻塞状态，但入队阻塞的任务不再阻塞，应该从对应的列表中删除。如果采用覆写入队，直接将队列消息数目减1，在任务结尾会重新将队列消息数目加1，这样队列中的消息数目会一直为0，队列不会进行阻塞，在下一次入队时会直接将前面的数据进行覆盖。首先初始化队列存储区的起始地址，若队列长度为0（队列没有存储区），则指向队列的起始地址，若队列长度不为0，指向队列存储区的起始地址。
FreeRTOS源码探析之——任务调度相关
码农爱学习的博客
12-13 1241
FreeRTOS可以运行多任务，在于其内核的任务调度功能，本篇介绍任务调度的基本思路与部分源码分析。 1 裸机编程与RTOS 的区别 1.1 裸机程序基本框架 /*主函数*/ int main() { init();//一些初始化 /*死循环*/ while(1) { do_something_1();//执行一些逻辑 do_something_2(); }//循环执行 } /*中断服务函数*/ IRQ_Handler() {
FreeRTOS源码探析之——事件标志组
码农爱学习的博客
11-30 1253
事件是一种实现任务间通信的机制，主要用于实现多任务间的同步，但事件通信只能是事件类型的通信，无数据传输。 1 基础概述 1.1 基本作用 事件标志的作用类似于全局型的flag，多个标志组合在一起构成事件标志组，这里先分析一下事件标志组于全局flag的区别： 使用事件标志组可以让 FreeRTOS内核有效地管理任务，而全局变量是无法做到的，任务的超时等机制需要用户自己去实现 使用了全局变量就要防止多任务的访问冲突，而使用事件标志组则处理好了这个问题，用户无需担心 使用事件标志组可以有效地解决中断服务程序和任
八，FreeRTOS之——队列集
菜鸟江多多的博客
09-26 2427
声明：本专栏参考韦东山，野火，正点原子以及其他博主的FreeRTOS教程，如若侵权请告知，马上删帖致歉，个人总结，如有不对，欢迎指正。队列集实验一：队列集---传送数据实验描述：圈重点仿真效果 队列集 转：队列集概述 队列知道是什么，那么队列集呢，没错就是套娃，队列集里面是队列。 看看代码就懂了， 实验一：队列集—传送数据 /** FreeRTOS v9.0.0 + STM32 动态创建任务 实验平台:韦东山 STM32F103ZE开发板 **/ #include "FreeRTOS.
FreeRTOS源码探析之——软件定时器
码农爱学习的博客
11-22 2244
软件定时器是FreeRTOS中的一个重要模块，使用软件定时器可以方便的实现一些与超时或周期性相关的功能，本篇从FreeRTOS的源码入手，来分析FreeRTOS软件定时器的运行机理。 1 基础知识 1.1 软件定时器与硬件定时器的区别 硬件定时器 每次在定时时间到达之后就会自动触发一个中断，用户在中断服务函数中处理信息 硬件定时器的精度一般很高，可以达到纳秒级别 硬件定时器是芯片本身提供的定时功能 软件定时器 指定时间到达后要调用回调函数（也称超时函数），用户在回调函数中处理信息 硬件定时器的定时精度
FreeRTOS源码解析——列表
xin950130的博客
11-20 331
本文主要描述freertos中链表的实现方式。源码请参考list.c/list.h。
wrap go qrcode generator as dll for c to use
m0_69086552的博客
08-17 243
/ 纠错级别（与Go代码中定义一致）QR_EC_LEVEL_L = 0, // 7%纠错能力QR_EC_LEVEL_M = 1, // 15%纠错能力QR_EC_LEVEL_Q = 2, // 25%纠错能力QR_EC_LEVEL_H = 3 // 30%纠错能力// 错误码（与Go代码中定义一致）QR_ERROR_INVALID_PARAM = 1, // 参数无效QR_ERROR_CREATE_FAILED = 2, // QR码创建失败。
为单片机专门定制的Unicode字库和API接口
BW.SU的博客
08-19 187
本文介绍了基于RA8889开发板的Unicode字符显示方案。该方案支持简体/繁体汉字、日文、拉丁字符等多种字符集，提供16/24/32点阵字库（容量707KB-2.9MB）。通过硬件加速实现快速显示，仅需调用简单API接口（如Show_UTF16函数）即可完成字符渲染，基本不占用MCU资源。使用步骤包括烧写字库到FLASH、添加库文件、设置地址参数等，配套资源可免费获取。方案适用于需要多语言显示的嵌入式场景，具有高效、易用的特点。
嵌入式学习 day52 IMX6ULL裸机开发-I2C
2301_81142331的博客
08-15 725
I2C：总线、时序
设置电机数据（闭环驱动器C5-E） ——易格斯igus
m0_69351944的博客
08-18 851
设置电机数据（闭环驱动器C5-E） ——易格斯igus
基于单片机智能手环/健康手环/老人健康监测
Holidaylive的博客
08-19 442
单片机智能手环是一种基于低功耗微控制器（如STM32）设计的可穿戴设备，集成了运动监测、健康管理及无线通信功能。通过加速度传感器、心率传感器等模块实时采集用户步数、心率等数据，经单片机处理后通过蓝牙传输至手机APP，实现数据可视化。智能手环可应用于健康监测、运动追踪等场景，为用户提供便捷的个人健康管理方案，具备成本低、体积小、扩展性强等特点，展现了单片机在可穿戴设备中的高效应用潜力。
窗口看门狗（WWDG）
weixin_45854148的博客
08-18 697
摘要 窗口看门狗（WWDG）是一种用于提高MCU系统可靠性的看门狗定时器，通过强制复位防止程序跑飞或异常占用。其核心特性包括7位递减计数器、窗口喂狗机制及提前唤醒中断（EWI）。WWDG时钟源自APB1分频，需在特定窗口内（T≤W且T>0x3F）喂狗，否则触发复位。EWI在计数器降至0x40时产生中断，提供最后一次喂狗机会。HAL库提供了初始化、喂狗和中断回调等API，支持调试时冻结计数器。与独立看门狗（IWDG）相比，WWDG强调时序约束，适用于需严格节拍控制的系统。
STM32 定时器(主从模式实现 3路PWM相位差)
qq_37669710的博客
08-19 315
摘要：本文介绍基于STM32定时器硬件触发实现多路PWM相位同步控制的方法。通过配置主定时器（TIM1）输出基准PWM并作为触发源，从定时器（TIM2/3/4）采用门控模式，以不同的计数器初值实现精确相位差（如120°间隔）。关键点包括：主从定时器需同频同源、高级定时器需使能MOE、通过TIM_SetCounter()动态调整相位。该方法具有纳秒级精度，适用于三相电机驱动、RGB调光等场景，可减轻CPU负载。
为什么电路板GND与外壳GND之间接一个电阻一个电容？
domen_pan的博客
08-15 334
安全防护：电阻限制漏电流（如AC市电设备的漏电流），防止触电风险，满足安规标准（如IEC 60950要求漏电流<0.1mA），如果外面有静电，高压之类的，也能有效降低电流，不会对电路内的芯片造成损坏。阻断地环路电流：若PCB GND与外壳直接短接，不同接地点间的电位差会形成地环路电流（如50Hz工频干扰），电阻（通常1MΩ~10MΩ）可阻断低频环路，避免共模噪声。外壳是金属的，中间是一个螺丝孔，也就是跟大地连接起来了。这里通过一个1M的电阻跟一个1nF的电容并联，跟电路板的地连接在一起，这样有什么好处呢？
STM32 定时器(中断源)
qq_37669710的博客
08-19 569
通过合理选择中断类型并优化配置，可充分发挥STM32定时器的硬件效能，实现高可靠性实时控制系统。
基于单片机智能拐杖/导盲杖/老人防摔倒设计
Holidaylive的博客
08-19 655
该设计针对老年人及行动不便人群的需求，开发了一款集成单片机控制的智能拐杖。拐杖采用STM32单片机作为核心控制器，结合多种传感器模块实现跌倒检测、GPS定位、环境监测及紧急呼救功能。通过加速度传感器和陀螺仪实时监测用户姿态变化，当检测到跌倒时自动触发声光报警并通过GSM模块发送位置信息至预设联系人。拐杖内置超声波避障模块，通过振动反馈提醒用户避开障碍物。该设计提升了传统拐杖的安全性与实用性，为特殊人群提供智能化辅助工具，具有较高的社会价值和应用前景。
基于单片机智能密码锁/密码箱/门锁/门禁系统
最新发布
Holidaylive的博客
08-19 455
智能密码锁以单片机为核心控制器，结合电子密码验证技术，实现安全便捷的门禁管理。系统采用矩阵键盘输入密码，通过LCD显示屏实时反馈操作状态，支持用户自定义修改密码，并具备错误报警功能。当连续输入错误密码超过设定次数时，系统自动锁定或触发蜂鸣器报警。部分设计集成指纹识别或RFID模块，增强身份验证的多样性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值