FreeRTOS personal notes - delay function

According to personal learning direction , Study FreeRTOS. Because brother wildfire FreeRTOS It's more implicit , I intend to be as detailed as possible in this column . As a personal note , For reference or reference only .

mixed material item ：FreeRTOS Kernel Implementation and application development practice guide 、 Wildfire FreeRTOS Supporting video source code 、b Standing wildfire FreeRTOS video . It's better to match it ！！！

The time delay function

Commonly used delay blocking function vTaskDelay()

#if ( INCLUDE_vTaskDelay == 1 )

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

		if( xTicksToDelay > ( TickType_t ) 0U )
		{
			configASSERT( uxSchedulerSuspended == 0 );
			vTaskSuspendAll();					// Suspend task scheduler 
			{
				traceTASK_DELAY();
				// Add the current task to the delay list 
				prvAddCurrentTaskToDelayedList( xTicksToDelay, pdFALSE );
			}
			xAlreadyYielded = xTaskResumeAll();	// Restore task scheduler 
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}

		
		if( xAlreadyYielded == pdFALSE )
		{
			portYIELD_WITHIN_API();		// Force switching tasks , take PendSV Of bit28  Set up 1
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}

#endif /* INCLUDE_vTaskDelay */

The above function called prvAddCurrentTaskToDelayedList() function , as follows

//xCanBlockIndefinitely： Whether it can block permanently 	pdFALSE： Permanent blocking is not allowed , That is, it is not allowed to suspend the current task 	pdTRUE： Allow permanent blocking , Support suspending the current task 
static void prvAddCurrentTaskToDelayedList( TickType_t xTicksToWait, const BaseType_t xCanBlockIndefinitely )
{
    TickType_t xTimeToWake;
    const TickType_t xConstTickCount = xTickCount;	// Get the time point when the delay function is currently called 

	/*  Omit code  */

	/*  Before adding tasks to the block list , Remove the task from the ready list , Because both lists use the same list item . */
	if( uxListRemove( &( pxCurrentTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )
	{
		portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority );
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}

	#if ( INCLUDE_vTaskSuspend == 1 )
	{
		if( ( xTicksToWait == portMAX_DELAY ) && ( xCanBlockIndefinitely != pdFALSE ) )		// Support pending 
		{
			vListInsertEnd( &xSuspendedTaskList, &( pxCurrentTCB->xStateListItem ) );		// Insert the task into the pending list 
		}
		else
		{
			// Calculate the time to wake up the task  
			xTimeToWake = xConstTickCount + xTicksToWait;

			/*  The list items will be inserted in the wake-up time order  */
			listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xStateListItem ), xTimeToWake );

			if( xTimeToWake < xConstTickCount )		// If the wake-up time overflows , Will be added to the delay overflow list 
			{
				vListInsert( pxOverflowDelayedTaskList, &( pxCurrentTCB->xStateListItem ) );
			}
			else
			{
				// Wake up time does not overflow , Add to the delay list 
				vListInsert( pxDelayedTaskList, &( pxCurrentTCB->xStateListItem ) );

				// If the next task to wake up is the current delayed task , Then you need to reset the unblocking time of the next task  xNextTaskUnblockTime  Is the time to wake up the current delayed task xTimeToWake.
				if( xTimeToWake < xNextTaskUnblockTime )
				{
					xNextTaskUnblockTime = xTimeToWake;
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
		}
	}
	#else /* INCLUDE_vTaskSuspend */
	{
		
		xTimeToWake = xConstTickCount + xTicksToWait;

		
		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 */
}

vTaskDelay () The delay of is relative , It's uncertain , Its delay is waiting vTaskDelay () The calculation starts after the call . also vTaskDelay() When the delay time is up , If a high priority task or interrupt is being executed ,
Tasks blocked by delay will not be unblocked immediately , The period of each task execution is not completely determined .

vTaskDelayUntil() The delay is absolute , Suitable for tasks that are performed periodically . When (*pxPreviousWakeTime + xTimeIncrement) After time ,vTaskDelayUntil() The function immediately returns , If the task is the highest priority ,
Then the mission will immediately unblock , So vTaskDelayUntil() The delay of a function is absolute .

Absolute delay vTaskDelayUntil() It is often used for more accurate periodic running tasks , For example, I have a task , You want it to perform regularly at a fixed frequency , Without external influence , The time interval between the beginning of a task's last run and the beginning of its next run is absolute .

vTaskDelayUntil() as follows

#if ( INCLUDE_vTaskDelayUntil == 1 )
	
	//pxPreviousWakeTime, Save the last time the task is unblocked . First use , This variable must be initialized to the current time , Then this variable will be in vTaskDelayUntil() Automatic update in function .
	//xTimeIncrement, Cycle time .  When   when   between   etc.   On  (*pxPreviousWakeTime + xTimeIncrement) when , Task unblock . If you don't change the parameters  xTimeIncrement  Value , The tasks that call this function are executed at a fixed frequency .
	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();
		{
			// Get the time point when the delay starts 
			const TickType_t xConstTickCount = xTickCount;

			// Calculate the time of delayed arrival , That is, the time to wake up the task 
			xTimeToWake = *pxPreviousWakeTime + xTimeIncrement;

			/* pxPreviousWakeTime  Is the last wake-up time , After wake-up, it takes a certain time to execute the task body code , If the last wake-up time is greater than the current time , Indicates that the beat counter overflowed */
			if( xConstTickCount < *pxPreviousWakeTime )
			{
				/*  If the wake-up time is less than the last wake-up time , And the wake-up time is greater than the start time , This is equivalent to no overflow , That is, it ensures that the periodic delay time is greater than the execution time of the task body code */
				if( ( xTimeToWake < *pxPreviousWakeTime ) && ( xTimeToWake > xConstTickCount ) )
				{
					xShouldDelay = pdTRUE;
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
			else
			{
				// Just wake up time overflow or no overflow , It ensures that the delay time is greater than the execution time of the task body code 
				if( ( xTimeToWake < *pxPreviousWakeTime ) || ( xTimeToWake > xConstTickCount ) )
				{
					xShouldDelay = pdTRUE;
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}

			// Update the last wake-up time 
			*pxPreviousWakeTime = xTimeToWake;

			if( xShouldDelay != pdFALSE )
			{
				traceTASK_DELAY_UNTIL( xTimeToWake );

				/* prvAddCurrentTaskToDelayedList() The function requires blocking time rather than wake-up time , So subtract the current tick count . */
				prvAddCurrentTaskToDelayedList( xTimeToWake - xConstTickCount, pdFALSE );
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
		xAlreadyYielded = xTaskResumeAll();

		// Force a context switch 
		if( xAlreadyYielded == pdFALSE )
		{
			portYIELD_WITHIN_API();
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}

#endif /* INCLUDE_vTaskDelayUntil */

xTimeIncrement        ： Task cycle time .
pxPreviousWakeTime    ： The time point of the last wake-up task .
xTimeToWake            ： The time point of this wake-up task .
xConstTickCount        ： Enter the time point of delay .

Absolute delay vTaskDelayUntil() example

void vTaskA( void * pvParameters )
{
	/*  Used to save the last time . The system will update automatically after calling  */
	static portTickType PreviousWakeTime;
	/*  Set delay time , Turn time into beats  */
	const portTickType TimeIncrement = pdMS_TO_TICKS(1000);
	
	/*  Get current system time  */
	PreviousWakeTime = xTaskGetTickCount();
	
	while (1)
	{
		/*  Call the absolute delay function , The task interval is  1000  individual  tick */
		vTaskDelayUntil( &PreviousWakeTime, TimeIncrement );

		// ...
		//  Here is the task body code 
		// ...
	}
}

This section officially encapsulates two functions , You can use it directly .

vTaskDelay() Relative delay function .

vTaskDelayUntil() Absolute delay function .