FreeRTOS原理剖析：任务延时

最新推荐文章于 2024-05-16 15:55:57 发布
最新推荐文章于 2024-05-16 15:55:57 发布
阅读量3.2k 收藏 16
点赞数 5
分类专栏： FreeRTOS原理剖析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31782183/article/details/101894365
版权

1. 任务延时相关API函数

函数描述
vTaskDelay()任务相对延时
vTaskDelayUntil()任务绝对延时，相对于任务相对延时而言，即以一定的周期执行任务函数
xTaskAbortDelay()任务中止延时函数，该函数能立即解除任务的阻塞状态，将任务插入就绪列表中

任务挂起中其它重要的API函数(介绍过的函数不列出，请参考前面的文章)：

函数描述
prvAddCurrentTaskToDelayedList()将当前任务添加到延时列表或者溢出延时列表中
eTaskGetState()或者任务的状态，如运行态、挂起态、阻塞态等

2. 任务延时的基本概念

在FreeRTOS中任务的延时和阻塞都是以系统节拍时钟周期为单位，在FreeRTOSConfig.h中需要设置：

#define configTICK_RATE_HZ	(1000)             //时钟节拍频率，这里设置为1000，周期就是1ms

在FreeRTOS中，系统节拍时钟周期为时钟节拍频率的导数，即T=1/f，比如设置时钟节拍频率为1000，则系统节拍时钟周期为1/1000(s)，即为1ms。当任务调度器正常工作时，每1ms产生一次节拍中断，同时变量xTickCount加1，xTickCount记录系统节拍时钟中断次数。当变量xTickCount累加到0xFFFF FFFF时，再增加1，则会溢出。
为了解决xTickCount溢出问题，在FreeRTOS中使用了两个延时列表：xDelayedTaskList1和xDelayedTaskList2，并且使用延时列表指针和溢出延时列表指针分别指向上面两个延时列表。在创建第一个任务时，会调用函数prvInitialiseTaskLists()来初始化两个指针。当xTickCount溢出时，会调用宏taskSWITCH_DELAYED_LISTS()，将延时列表指针和溢出延时列表指针交换，这样，不管时钟节拍数xTickCount在任意数值时，都可通过插入到延时列表或者溢出延时列表，实现数值为0xFFFF FFFF的时钟节拍数延时。

#define taskSWITCH_DELAYED_LISTS()								\
{																\
	List_t *pxTemp;												\
	configASSERT( ( listLIST_IS_EMPTY( pxDelayedTaskList ) ) );	\
																\
	/* 将指向延时列表和溢出延时列表的指针交换 */						\
	pxTemp = pxDelayedTaskList;									\
	pxDelayedTaskList = pxOverflowDelayedTaskList;				\
	pxOverflowDelayedTaskList = pxTemp;							\
																\
	xNumOfOverflows++;											\
																\			
	/* 重新获取下一次解除阻塞的时间 */								\
	prvResetNextTaskUnblockTime();								\
}

说明：

  • 在延时列表中，会根据任务的延时时间先后插入到延时列表中，延时时间短的在前，延时时间长的在后，同时下一个要唤醒的任务时间值保存在xNextTaskUnblockTime中。
  • 系统节拍到达最近的唤醒时间时，系统会将应该唤醒的任务从延时列表中清除，并挂接到就绪列表中。
  • 当系统节拍溢出后，延时列表变成溢出延时列表，溢出延时列表变成了延时列表。而原先的延时列表里的任务在系统节拍溢出之后肯定已经全部被超时唤醒。

3. 任务的相对延时函数vTaskDelay()

3.1 相对延时vTaskDelay()分析

使用任务的相对延时函数vTaskDelay()时，一般先执行完任务函数的主要功能模块，再以用户设置的时钟节拍数xTicksToDelay 延时任务函数。如果xTicksToDelay 设置为0，相当于只执行了一次任务切换。
使用此函数，需要将INCLUDE_vTaskDelay设置为1，在FreeRTOSConfig.h中定义。

函数原型如下：

/********************************************************
参数：xTicksToDelay ：需要延时的时钟节拍数(0~0xFFFF FFFF)
返回：无
*********************************************************/
void vTaskDelay( const TickType_t xTicksToDelay )

函数源代码如下：

void vTaskDelay( const TickType_t xTicksToDelay )
{
	BaseType_t xAlreadyYielded = pdFALSE;

	/* 如果延时时间大于0 */
	if( xTicksToDelay > ( TickType_t ) 0U )
	{
		configASSERT( uxSchedulerSuspended == 0 );
		
		vTaskSuspendAll();	/* 挂起任务调度器 */
		{
			traceTASK_DELAY();

			/* 将该任务从就绪列表中删除，添加到延时列表或溢出延时列表，延时时长为当前节拍到唤醒时间 */
			prvAddCurrentTaskToDelayedList( xTicksToDelay, pdFALSE );
		}
		xAlreadyYielded = xTaskResumeAll();	/* 恢复任务调度器，有可能进行任务切换 */
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}

	/* 如果在函数xTaskResumeAll()中没有进行任务切换 */
	if( xAlreadyYielded == pdFALSE )
	{
		portYIELD_WITHIN_API();	/* 进行一次任务切换 */
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}
3.2 函数prvAddCurrentTaskToDelayedList()

该函数通过计算任务下一个唤醒的时间是否溢出了，从而将当前任务添加到延时列表还是溢出延时列表。

函数原型如下：

/********************************************************
参数：		  xTicksToWait：需要延时的系统节拍数
	 xCanBlockIndefinitely： pdTRUE：允许无限期阻塞
	 						pdFALSE：不允许无限期阻塞
返回：无
*********************************************************/
static void prvAddCurrentTaskToDelayedList( TickType_t xTicksToWait, const BaseType_t xCanBlockIndefinitely )

函数源代码如下：

static void prvAddCurrentTaskToDelayedList( TickType_t xTicksToWait, const BaseType_t xCanBlockIndefinitely )
{
	TickType_t xTimeToWake;
	const TickType_t xConstTickCount = xTickCount;

    /* 如果使能了中止延时功能 */
	#if( INCLUDE_xTaskAbortDelay == 1 )
	{
		pxCurrentTCB->ucDelayAborted = pdFALSE;
	}
	#endif

	/* 将当前任务从就绪列表中移除，如果此时该优先级列表中无其它任务 */
	if( uxListRemove( &( pxCurrentTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )
	{
		/* 清除相应的就绪状态位 */
		portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority );
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}

	/* 如果使能任务挂起功能 */
	#if ( INCLUDE_vTaskSuspend == 1 )
	{
		/* 延时时间为portMAX_DELAY并且允许无限期阻塞 */
		if( ( xTicksToWait == portMAX_DELAY ) && ( xCanBlockIndefinitely != pdFALSE ) )
		{
			/* 将当前任务插入到挂起列表中 */
			vListInsertEnd( &xSuspendedTaskList, &( pxCurrentTCB->xStateListItem ) );
		}
		else
		{
			/* 
			 * 计算该任务的下一次唤醒时间 
			 * xConstTickCount = xTickCount，为当前系统的时钟节拍数
			 * xTicksToWait为任务需要延时的时钟节拍数
			 */
			xTimeToWake = xConstTickCount + xTicksToWait;

			/* 设置当前运行任务的状态列表项中项值(成员xItemValue)为下一次唤醒的时间值 */
			listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xStateListItem ), xTimeToWake );

			/* 下一次唤醒时间值小于系统当前节拍，说明唤醒该任务那时的系统节拍已经溢出 */
			if( xTimeToWake < xConstTickCount )
			{
				/* 将当前正在运行的任务插入溢出延时列表中 */
				vListInsert( pxOverflowDelayedTaskList, &( pxCurrentTCB->xStateListItem ) );
			}
			else	/* 唤醒时间大于当前节拍，说明没有溢出 */
			{
				/* 将当前正在运行的任务插入延时列表中 */
				vListInsert( pxDelayedTaskList, &( pxCurrentTCB->xStateListItem ) );

				/* 当前任务唤醒时间小于原先的下一个解除阻塞任务的唤醒时间 */
				if( xTimeToWake < xNextTaskUnblockTime )
				{
					/* 当前任务唤醒时间为下一个解除阻塞任务的唤醒时间 */
					xNextTaskUnblockTime = xTimeToWake;
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
		}
	}
	#else /* INCLUDE_vTaskSuspend */
	{
		/* 下一次任务唤醒的时间 */
		xTimeToWake = xConstTickCount + xTicksToWait;

		/* 设置当前运行任务状态列表项中成员xItemValue为下一次唤醒的时间值 */
		listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xStateListItem ), xTimeToWake );

		/* 下一次唤醒时间值小于系统当前节拍，说明系统节拍已经溢出 */
		if( xTimeToWake < xConstTickCount )
		{
			/* 将当前正在运行的任务插入溢出延时列表中 */
			vListInsert( pxOverflowDelayedTaskList, &( pxCurrentTCB->xStateListItem ) );
		}
		else
		{
			/* 将当前正在运行的任务插入延时列表中 */
			vListInsert( pxDelayedTaskList, &( pxCurrentTCB->xStateListItem ) );

			/* 当前任务唤醒时间小于原先的下一个解除阻塞任务的唤醒时间 */
			if( xTimeToWake < xNextTaskUnblockTime )
			{
				/* 当前任务唤醒时间为下一个解除阻塞任务的唤醒时间 */
				xNextTaskUnblockTime = xTimeToWake;
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}

		( void ) xCanBlockIndefinitely;
	}
	#endif /* INCLUDE_vTaskSuspend */
}

4. 任务的绝对延时vTaskDelayUntil()

任务绝对延时函数vTaskDelayUntil()是相对于任务相对延时函数而言的，它能使任务以一定的周期(或频率)运行，该周期也不是绝对精准，因为有更高优先级或者中断程序运行时才轮到你。使用此函数需将INCLUDE_vTaskDelayUntil设置为1，在FreeRTOSConfig.h 中定义。

函数原型如下：

void vTaskDelayUntil( TickType_t * const pxPreviousWakeTime, const TickType_t xTimeIncrement )

参数说明：

  • pxPreviousWakeTime： 上一次任务延时被唤醒的时间节点，第一次时，需要设置该值，若不设置值或默认为0，将造成延时函数第一次不准，常用xTaskGetTickCount()得到系统时钟节拍赋值给pxPreviousWakeTime。
  • xTimeIncrement： 任务延时的时钟节拍数，可用宏定义pdMS_TO_TICKS()转换成系统时钟节拍数。

返回： 无

用法如下：

void TaskFunc(void *pvParameters) 
{ 	
	TickType_t	PreviousWakeTime; 

	/* 延时时间需要转换为系统节拍数，这里延时100ms */ 	
	const TickType_t TimerIncrement = pdMS_TO_TICKS(100);
   
   	/* 获取系统当前系统节拍数用于vTaskDelayUntil形参 */ 	
   	PreviousWakeTime =  xTaskGetTickCount(); 	
   	
   	while(1)    
   	{
   		/* 任务主体 */
       LED0=!LED0;
   
   		/* 进行延时 */
       vTaskDelayUntil(&PreviousWakeTime, TimerIncrement);	/* LED灯每隔500ms亮灭一次 */    
    } 
}

函数源代码如下：

void vTaskDelayUntil( TickType_t * const pxPreviousWakeTime, const TickType_t xTimeIncrement )
{
	TickType_t xTimeToWake;
	BaseType_t xAlreadyYielded, xShouldDelay = pdFALSE;

	configASSERT( pxPreviousWakeTime );
	configASSERT( ( xTimeIncrement > 0U ) );
	configASSERT( uxSchedulerSuspended == 0 );

	vTaskSuspendAll();	/* 挂起任务调度器 */
	{

		const TickType_t xConstTickCount = xTickCount;	/* 获取系统时钟节拍数 */

		/* 计算下一次任务唤醒的时间 */
		xTimeToWake = *pxPreviousWakeTime + xTimeIncrement;

		/* 前一次唤醒时间大于系统当前节拍，即说明此时系统节拍已经溢出 */
		if( xConstTickCount < *pxPreviousWakeTime )
		{
			/* 
			 * 在下面分析，若此时系统节拍数已经溢出，则只有一种情况，也就是下面的第三种情况。
			 * 如果前一次唤醒时间大于下一次任务唤醒时间，且下一次唤醒时间大于系统节拍 
			 */
			if( ( xTimeToWake < *pxPreviousWakeTime ) && ( xTimeToWake > xConstTickCount ) )
			{
				xShouldDelay = pdTRUE;	/* 需要延时 */
			}
			else	/* 系统节拍没有溢出 */
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
		else
		{
			/* 
			 * 如果此时系统节拍数没有溢出，则有两种情况，分别为下面分析的第二种和第三种情况
			 * 如果前一次唤醒时间大于下一次任务唤醒时间，或下一次唤醒时间大于系统节拍 
			 */
			if( ( xTimeToWake < *pxPreviousWakeTime ) || ( xTimeToWake > xConstTickCount ) )
			{
				xShouldDelay = pdTRUE;	/* 需要延时 */
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}

		*pxPreviousWakeTime = xTimeToWake;	/* 将下一次唤醒时间赋值给pxPreviousWakeTime */

		/* 如果需要延时 */
		if( xShouldDelay != pdFALSE )
		{
			traceTASK_DELAY_UNTIL( xTimeToWake );

			/* 将当前任务添加到延时列表中，延时时间为当前节拍到唤醒时间 */
			prvAddCurrentTaskToDelayedList( xTimeToWake - xConstTickCount, pdFALSE );
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}
	xAlreadyYielded = xTaskResumeAll();	/* 解除调度器挂起，解除时可能切换任务 */

	/* 如果解除任务调度器时没有执行任务切换 */
	if( xAlreadyYielded == pdFALSE )
	{
		portYIELD_WITHIN_API();		/* 请求任务切换 */
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}
}

任务绝对延时函数中主要包含四个变量：

  • pxPreviousWakeTime：保存上一次任务延时结束唤醒的时间点，每次延时都会参考该时间点。
  • xTimeIncrement：需要显示的时间节拍点，由用户提供。
  • xConstTickCount：记录系统时间节拍点。
  • xTimeToWake：记录任务唤醒时间点，该值等于pxPreviousWakeTime加上xTimeIncrement。

由于xConstTickCount和xTimeToWake变量会有溢出的情况，则有三种情况，以下三种情况都将插入到延时列表中：

第一种情况： 系统节拍数xConstTickCount此时无溢出，计算下一次任务唤醒时间点xTimeToWake无溢出。
在这里插入图片描述
第二种情况： 系统节拍数xConstTickCount此时无溢出，计算下一次任务唤醒时间点xTimeToWake溢出。
在这里插入图片描述
第三种情况： 系统节拍数已经xConstTickCount溢出，计算下一次任务唤醒时间点xTimeToWake也溢出。
在这里插入图片描述
说明：

  • 图中“任务主体”是任务正在执行的主体代码，“vTaskDelayUntil部分”是对任务的延时，“(3)处为其它执行的任务”，任务的总延时时间为xTimeIncrement。
  • 绝对延时函数是相对于相对延时函数而言的，在相对延时函数中，直接将需要函数参数xTicksToDelay作为下一次唤醒的延时时间，而绝对延时函数将函数参数xTimeIncrement加上前一次的延时时间点(*pxPreviousWakeTime) ，然后再减去系统时间节拍数xConstTickCount，最终的数值作为延时时间。
  • 对于第二种情况，xTimeToWake 小于 xConstTickCount，由于xTimeToWake 和 xConstTickCount 都是 uint32_t，则当xTimeToWake - xConstTickCount 作为延时时间时，相当于xTimeToWake 加上 xConstTickCount 的补数，也就是图中xConstTickCount 后面部分时间加上xTimeToWake 前面部分时间。

5. 任务中止延时函数xTaskAbortDelay()

5.1 任务中止延时函数xTaskAbortDelay()

该函数解除任务的阻塞状态，将任务插入就绪列表中。使用此函数需要INCLUDE_xTaskAbortDelay设置为1，在FreeRTOSConfig.h中定义。

函数原型如下：

/********************************************************
参数：xTask：函数的句柄
返回：BaseType_t：
*********************************************************/
BaseType_t xTaskAbortDelay( TaskHandle_t xTask )

BaseType_t xTaskAbortDelay( TaskHandle_t xTask )
{
	TCB_t *pxTCB = ( TCB_t * ) xTask;
	BaseType_t xReturn = pdFALSE;

	configASSERT( pxTCB );

	vTaskSuspendAll();	/* 挂起任务调度器 */
	{
		/* 获取任务的状态(如延时、挂起、就绪等)，如果任务阻塞了，满足条件进入 */
		if( eTaskGetState( xTask ) == eBlocked )
		{
			/* 解除任务所有的状态 */
			( void ) uxListRemove( &( pxTCB->xStateListItem ) );
			
			taskENTER_CRITICAL();	/* 进入临界区 */
			{
				/* 如果任务有任务事件等待 */
				if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )
				{
					/* 移除任务的事件 */
					( void ) uxListRemove( &( pxTCB->xEventListItem ) );
					
					/* 设置任务解除延时中断标志为pdTRUE */
					pxTCB->ucDelayAborted = pdTRUE;		
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
			taskEXIT_CRITICAL();	/* 退出临界区 */

			prvAddTaskToReadyList( pxTCB );	/* 将任务添加到就绪表中 */

			/* 如果使用抢占式内核 */
			#if (  configUSE_PREEMPTION == 1 )
			{
				/* 如果恢复的任务优先级比当前运行的任务优先级高 */
				if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )
				{

					xYieldPending = pdTRUE;	/* 设置需要任务切换标志 */
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
			#endif /* configUSE_PREEMPTION */
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}
	xTaskResumeAll();	/* 解除调度器挂起，解除时可能切换任务 */

	return xReturn;
}
5.2 得到任务状态函数eTaskGetState()

通过带入函数的句柄，将获取任务的状态，使用此函数需要设置INCLUDE_eTaskGetState为1，或者设置configUSE_TRACE_FACILITY为1，在FreeRTOSConfig.h中定义。

函数原型如下：

/********************************************************
参数：xTask：函数的句柄
返回：eTaskState ：eRunning：任务处于运行态
				  eBlocked：任务处于阻塞态
				eSuspended：任务处于挂起态
  				  eDeleted：任务已经需要删除或任务无挂接在任何状态下，即无用的任务
				    eReady：任务处于就绪态
*********************************************************/
eTaskState eTaskGetState( TaskHandle_t xTask )

函数源代码如下：

eTaskState eTaskGetState( TaskHandle_t xTask )
{
	eTaskState eReturn;
	List_t *pxStateList;
	const TCB_t * const pxTCB = ( TCB_t * ) xTask;

	configASSERT( pxTCB );

	/* 如果任务等于当前正在运行的任务 */
	if( pxTCB == pxCurrentTCB )
	{
		/* 标记eReturn 为运行态 */
		eReturn = eRunning;
	}
	else
	{
		taskENTER_CRITICAL();	/* 进入临界区 */
		{
			/* 得到TCB状态列表项挂接在那个列表中，如延时列表，挂起列表等 */
			pxStateList = ( List_t * ) listLIST_ITEM_CONTAINER( &( pxTCB->xStateListItem ) );
		}
		taskEXIT_CRITICAL();	/* 退出临界区 */

		/* 如果任务挂接在延时列表或者溢出延时列表中 */
		if( ( pxStateList == pxDelayedTaskList ) || ( pxStateList == pxOverflowDelayedTaskList ) )
		{
			/* 标记eReturn为阻塞态，eReturn为返回值 */
			eReturn = eBlocked;
		}

		/* 如果使能了挂起功能 */
		#if ( INCLUDE_vTaskSuspend == 1 )
			else if( pxStateList == &xSuspendedTaskList )	/* 如果任务挂接在挂起列表中 */
			{
				/* 如果列表无任何等待事件 */
				if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL )
				{
					eReturn = eSuspended;	/* 标记eReturn为挂起态，eReturn为返回值 */
				}
				else	/* 任务有等待事件 */
				{
					eReturn = eBlocked;	/* 标记eReturn为阻塞，eReturn为返回值 */
				}
			}
		#endif

		/* 如果使能任务删除功能 */
		#if ( INCLUDE_vTaskDelete == 1 )
		
			/* 如果任务挂接在等待删除列表或者任务没有挂接在任何一个列表中 */
			else if( ( pxStateList == &xTasksWaitingTermination ) || ( pxStateList == NULL ) )
			{
				eReturn = eDeleted;	/* 标记eReturn删除，eReturn为返回值 */
			}
		#endif
		else
		{
			eReturn = eReady;	/* 标记eReturn为就绪态，eReturn为返回值 */
		}
	}

	return eReturn;
}
参考资料：

【1】: 正点原子:《STM32F407 FreeRTOS开发手册V1.1》
【2】: 野火:《FreeRTOS 内核实现与应用开发实战指南》

千行代码
关注
  • 5
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
FreeRTOS实时操作系统（九）时间延时函数及消息队列
贾saisai的博客
07-02 1142
队列是任务到任务、任务到中断、中断到任务数据交流的一种机制（消息传递）一般情况下，全局变量的数据无保护，导致数据不安全，当多个任务同时对该变量操作时，数据易受损。当然，如果每次我们都采用临界区代码保护也可以，但是读写队列自带这样的操作，用起来简便在队列中可以存储数量有限、大小固定的数据。队列中的每一个数据叫做“队列项目”，队列能够存储“队列项目”的最大数量称为队列的长度，在创建队列时，指定队列长度以及队列项目的大小。
FreeRTOS的学习（五）——系统延时
LEOD的博客
05-04 6727
在前面的学习过程中大概了解了FreeRTOS的每个任务可以相互独立的编程，通过系统定时中断进行任务级别的切换。其中延时函数vTaskDelay()作为FreeRTOS的延时函数，其也具有任务切换的功能，即延时函数会将当前任务放入阻塞态等待延时时间结束，然后重新将该任务放入就绪态，按优先级运行。 freeRTOS的系统延时又分为两种模式：一种是相对模式，容易由于任务主体时间影响而导致任务执行的时间太长。另一种是绝对模式，绝对模式可以很好的解决相对模式的问题，因为其延时时间是一个周期值，即任务周期运行的时间，
FreeRTOS中实现精确的us级延时
w237838的博客
12-04 6479
在使用通讯协议来驱动外设的时候需要遵循严格的时序逻辑，往往用到微秒(us)级别的延时，在裸机编程中可以使用SysTick定时器、软件堵塞等方法来实现；但是在FreeRTOS中，SysTick定时器则是用来作为FreeRTOS系统时钟的，并且它提供的API仅能实现毫秒级别的延时，所以在网上查找资料总结了几个在FreeRTOS上运行的,可以实现us级别延时的几个方案。SysTick定时器被捆绑在NVIC中，用于产生SysTick异常(异常号15)。滴答中断对操作系统尤其重要。
FreeRTOS延时函数、软件定时器
最新发布
2301_78772787的博客
05-16 1057
延时函数是一种编程语言中常用的函数类型，用于暂停一段时间后再执行后续的操作。在延时函数执行期间，程序会暂停执行，直到指定的时间结束后才会继续执行后续代码。常见的延时函数参数是毫秒或微秒，可以控制真实时间和计算机时间的关系。延时函数常用于需要等待或暂停执行的场景，如控制程序运行速度、动画效果等。不过，过度使用延时函数可能会影响程序的性能和响应速度。简单可以理解为闹钟，到达指定一段时间后，就会响铃。
【11】FreeRTOS的延时函数
小浪宝宝的博客
02-22 4158
函数描述相对延时绝对延时相对延时：指每次延时都是从执行函数vTaskDelay()开始，直到延时指定的时间结束（任务被阻塞的时间，到调用此函数开始的时间）；绝对延时：指将整个任务的运行周期看成一个整体，适用于需要按照一定频率运行的任务（整个任务执行的时间，从头到尾的时间）。[^1]上图中的为绝对延时时间（假如绝对延时时间为100ms，那么以下三部分之和为100ms），包括以下三部分：(1)为任务主体，也就是任务真正要做的工作；
FreeRTOS专题七：任务延时列表
dingyc_ee的博客
09-06 973
任务延时列表
FreeRTOS高级篇9---FreeRTOS系统延时分析
热门推荐
朱工的专栏
06-18 8万+
FreeRTOS提供了两个系统延时函数：相对延时函数vTaskDelay()和绝对延时函数vTaskDelayUntil()。相对延时是指每次延时都是从任务执行函数vTaskDelay()开始，延时指定的时间结束；绝对延时是指每隔指定的时间，执行一次调用vTaskDelayUntil()函数的任务。换句话说：任务以固定的频率执行。在《FreeRTOS系列第11篇---FreeRTOS任务控制》一文...
NXP i.MX RT1052 FreeRTOS实战：任务延时列表的实现
12-01
在实际开发中，了解和掌握任务延时列表的实现原理对于调试和优化代码至关重要。例如，合理设置任务优先级和延时时间可以提高系统的响应性和实时性。同时，避免长时间的任务阻塞，以免影响其他任务的执行。 在提供的...
26FreeRTOS任务挂起和恢复.rar
11-24
- 延时与超时：任务可以挂起自身并设置超时，当超时期限到达，系统会自动恢复任务。 - 事件驱动：任务等待特定事件发生，例如信号量被释放或消息队列接收到新数据，事件发生时恢复任务。 总的来说，FreeRTOS的任务...
FreeRTOS任务壮态或信息查询实验
06-15
在进行实验时，会编写代码创建多个任务，然后通过示例或测试代码展示如何查询任务状态以及统计运行时间，这有助于深入理解FreeRTOS的工作原理和优化技巧。 总的来说，这个实验旨在提升开发者对FreeRTOS实时操作系统...
跟着野火学FreeRTOS：第一段（优先级）
12-24
FreeRTOS是一种广泛应用于嵌入式系统的实时操作系统（RTOS），它为微控制器和小型计算机系统提供了高效的任务调度和管理功能。本篇文章将深入讲解FreeRTOS中的优先级概念，这是理解RTOS核心特性的关键。 首先，我们...
FreeRTOS系列教程高级篇文档资料
01-19
FreeRTOS系列教程高级篇文档资料: 10、FreeRTOS高级篇10---系统节拍时钟分析.docx 11、FreeRTOS高级篇11---空闲任务分析.docx 1、 FreeRTOS高级篇1---FreeRTOS列表...9、 FreeRTOS高级篇9---FreeRTOS系统延时分析.docx
浅析 FreeRTOS SysTick 和任务延时
wangyx1234的博客
10-14 5477
FreeRTOS 提供的最小时间单元为一个 SysTick，举例：假设配置 RTOS 的 SysTick 为 100Hz，则 RTOS 能提供的最小时间单位为 1/100 s，即 10ms. 即一个 RTOS 的系统始终为 10ms.上述示例计算code()共消耗了多少个 SysTick，假设当前的 SysTick 为 上述的 100Hz，当前消耗了 10个 SysTick，则实际消耗时间为 10* 10ms = 100ms.将 10 SysTick 转为 ms 单位，使用即可。
FreeRTOS 延时函数和软件定时器 详解
wei_Embedded_z的博客
10-28 1422
FreeRTOS 延时函数和软件定时器 详解什么是延时函数? 1.延时函数分类 2.vTaskDelay 与HAL Delay 的区别 什么是定时器? 1.软件定时器优缺点 2.软件定时器原理 3.软件定时器相关配置 4.单次定时器和周期定时器软件定时器相关API函数 1.创建软件定时器 2.开启软件定时器 3.停止软件定时器 4.复位软件定时器 5.更改软件定时器定时时间延时函数和软件定时器实操
FreeRTOS --（5）任务管理之任务延时
梁的愚见
03-06 2385
目录 1、接口介绍 1.1、vTaskDelay 1.1.1、Usage 1.1.2、Implement 1.2、vTaskDelayUntil 1.2.1、Usage 1.2.2、Implement   在《FreeRTOS --（7）任务管理之入门篇》中讲过，如果有几个任务同时跑，但是又都不阻塞的话，那么最高优先级的任务将会占领整个 CPU，因为每次都会调度到它，一直处于 Read...
【STM32/FreeRTOS】精准延时的实现
chengzhou
08-25 1万+
目录 前言 SysTick定时器寄存器 裸机编程下实现 FreeRTOS中实现 前言 在使用通讯协议来驱动外设的时候需要遵循严格的时序逻辑，往往用到微秒(us)级别的延时，在裸机编程中可以使用SysTick定时器来实现；在FreeRTOS中，SysTick定时器则是用来作为FreeRTOS系统时钟的，但也可以用来做延时使用，只是与裸机编程下方式不同。 SysTick定时器寄存器 要使用SysTick定时器，首先要了解一下其相关寄存器。 裸机编程下...
FreeRTOS学习——延时函数
qq_47172243的博客
01-09 608
任务阻塞后，RTOS系统调用其它处于就绪状态的优先级最高的任务来执行。HAL_Delay 一直不停的调用获取系统时间的函数，直到指定的时间流逝然后退出。故其占用了全部CPU时间。
第十二章 FreeRTOS的时间管理
m0_66317799的博客
10-04 106
函数描述相对延时绝对延时指每次延时都是从执行函数vTaskDelay()开始，直到延时指定的时间结束（任务被阻塞的时间，到调用此函数开始的时间）；绝对延时指将整个任务的运行周期看成一个整体，适用于需要按照一定频率运行的任务（整个任务执行的时间，从头到尾的时间）。
FreeRTOS库函数 API Reference（二）任务控制
Zqx的博客
08-26 567
FreeRTOS任务控制API函数
FreeRTOS_基础.doc
09-10
FreeRTOS入门--思路超明晰的一份教程，特别适合小白。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值