Symbols

Files

Summary Syntax Arguments Related References

SourceVuSTM32 Libraries and SamplesFreeRTOSxTaskNotifyStateClear()

xTaskNotifyStateClear() function

If the notification state of the task referenced by the handle xTask is eNotified, then set the task's notification state to eNotWaitingNotification. The task's notification value is not altered. Set xTask to NULL to clear the notification state of the calling task.

Syntax

Show:

Summary

Declaration

Definition

from task.h:2207

BaseType_t xTaskNotifyStateClear( TaskHandle_t xTask );

Implemented in tasks.c:5112

Arguments

Argument

xTask

Return value

pdTRUE if the task's notification state was set to eNotWaitingNotification, otherwise pdFALSE.

Found 65 other functions taking a tskTaskControlBlock argument:

Function

Description

osThreadResume()

Resume execution of a suspended thread.

osThreadSuspend()

Suspend execution of a thread.

osMessageCreate()

Message Queue Management Functions ******************** Create and Initialize a Message Queue

MPU_vTaskDelete()

INCLUDE_vTaskDelete must be defined as 1 for this function to be available. See the configuration section for more information. Remove a task from the RTOS real time kernel's management. The task being deleted will be removed from all ready, blocked, suspended and event lists. NOTE: The idle task is responsible for freeing the kernel allocated memory from tasks that have been deleted. It is therefore important that the idle task is not starved of microcontroller processing time if your application makes any calls to vTaskDelete (). Memory allocated by the task code is not automatically freed, and should be freed before the task is deleted. See the demo application file death.c for sample code that utilises vTaskDelete (). Example usage:

 void vOtherFunction( void )
 {
 TaskHandle_t xHandle;
	 // Create the task, storing the handle.
	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
	 // Use the handle to delete the task.
	 vTaskDelete( xHandle );
 }
   

osThreadTerminate()

Terminate execution of a thread and remove it from Active Threads.

osThreadGetState()

Obtain the state of any thread.

MPU_xTaskCreateRestricted()

Only available when configSUPPORT_DYNAMIC_ALLOCATION is set to 1. xTaskCreateRestricted() should only be used in systems that include an MPU implementation. Create a new task and add it to the list of tasks that are ready to run. The function parameters define the memory regions and associated access permissions allocated to the task. See xTaskCreateRestrictedStatic() for a version that does not use any dynamic memory allocation. Example usage:

// Create an TaskParameters_t structure that defines the task to be created.
static const TaskParameters_t xCheckTaskParameters =
{
	vATask,		// pvTaskCode - the function that implements the task.
	"ATask",	// pcName - just a text name for the task to assist debugging.
	100,		// usStackDepth	- the stack size DEFINED IN WORDS.
	NULL,		// pvParameters - passed into the task function as the function parameters.
	( 1UL | portPRIVILEGE_BIT ),// uxPriority - task priority, set the portPRIVILEGE_BIT if the task should run in a privileged state.
	cStackBuffer,// puxStackBuffer - the buffer to be used as the task stack.
	// xRegions - Allocate up to three separate memory regions for access by
	// the task, with appropriate access permissions.  Different processors have
	// different memory alignment requirements - refer to the FreeRTOS documentation
	// for full information.
	{
		// Base address					Length	Parameters
		{ cReadWriteArray,				32,		portMPU_REGION_READ_WRITE },
		{ cReadOnlyArray,				32,		portMPU_REGION_READ_ONLY },
		{ cPrivilegedOnlyAccessArray,	128,	portMPU_REGION_PRIVILEGED_READ_WRITE }
	}
};
int main( void )
{
TaskHandle_t xHandle;
	// Create a task from the const structure defined above.  The task handle
	// is requested (the second parameter is not NULL) but in this case just for
	// demonstration purposes as its not actually used.
	xTaskCreateRestricted( &xRegTest1Parameters, &xHandle );
	// Start the scheduler.
	vTaskStartScheduler();
	// Will only get here if there was insufficient memory to create the idle
	// and/or timer task.
	for( ;; );
}
   

MPU_xTaskCreate()

osSignalSet()

Signal Management ******************************* Set the specified Signal Flags of an active thread.

xTaskCreate()

Create a new task and add it to the list of tasks that are ready to run. Internally, within the FreeRTOS implementation, tasks use two blocks of memory. The first block is used to hold the task's data structures. The second block is used by the task as its stack. If a task is created using xTaskCreate() then both blocks of memory are automatically dynamically allocated inside the xTaskCreate() function. (see http://www.freertos.org/a00111.html). If a task is created using xTaskCreateStatic() then the application writer must provide the required memory. xTaskCreateStatic() therefore allows a task to be created without using any dynamic memory allocation. See xTaskCreateStatic() for a version that does not use any dynamic memory allocation. xTaskCreate() can only be used to create a task that has unrestricted access to the entire microcontroller memory map. Systems that include MPU support can alternatively create an MPU constrained task using xTaskCreateRestricted(). Example usage:

 // Task to be created.
 void vTaskCode( void * pvParameters )
 {
	 for( ;; )
	 {
		 // Task code goes here.
	 }
 }
 // Function that creates a task.
 void vOtherFunction( void )
 {
 static uint8_t ucParameterToPass;
 TaskHandle_t xHandle = NULL;
	 // Create the task, storing the handle.  Note that the passed parameter ucParameterToPass
	 // must exist for the lifetime of the task, so in this case is declared static.  If it was just an
	 // an automatic stack variable it might no longer exist, or at least have been corrupted, by the time
	 // the new task attempts to access it.
	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, &ucParameterToPass, tskIDLE_PRIORITY, &xHandle );
	 configASSERT( xHandle );
	 // Use the handle to delete the task.
	 if( xHandle != NULL )
	 {
	 	vTaskDelete( xHandle );
	 }
 }
   

eTaskGetState()

INCLUDE_eTaskGetState must be defined as 1 for this function to be available. See the configuration section for more information. Obtain the state of any task. States are encoded by the eTaskState enumerated type.

vTaskDelete()

 void vOtherFunction( void )
 {
 TaskHandle_t xHandle;
	 // Create the task, storing the handle.
	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
	 // Use the handle to delete the task.
	 vTaskDelete( xHandle );
 }
   

uxTaskPriorityGet()

INCLUDE_uxTaskPriorityGet must be defined as 1 for this function to be available. See the configuration section for more information. Obtain the priority of any task. Example usage:

 void vAFunction( void )
 {
 TaskHandle_t xHandle;
	 // Create a task, storing the handle.
	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
	 // ...
	 // Use the handle to obtain the priority of the created task.
	 // It was created with tskIDLE_PRIORITY, but may have changed
	 // it itself.
	 if( uxTaskPriorityGet( xHandle ) != tskIDLE_PRIORITY )
	 {
		 // The task has changed it's priority.
	 }
	 // ...
	 // Is our priority higher than the created task?
	 if( uxTaskPriorityGet( xHandle ) < uxTaskPriorityGet( NULL ) )
	 {
		 // Our priority (obtained using NULL handle) is higher.
	 }
 }
   

vTaskResume()

INCLUDE_vTaskSuspend must be defined as 1 for this function to be available. See the configuration section for more information. Resumes a suspended task. A task that has been suspended by one or more calls to vTaskSuspend () will be made available for running again by a single call to vTaskResume (). Example usage:

 void vAFunction( void )
 {
 TaskHandle_t xHandle;
	 // Create a task, storing the handle.
	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
	 // ...
	 // Use the handle to suspend the created task.
	 vTaskSuspend( xHandle );
	 // ...
	 // The created task will not run during this period, unless
	 // another task calls vTaskResume( xHandle ).
	 //...
	 // Resume the suspended task ourselves.
	 vTaskResume( xHandle );
	 // The created task will once again get microcontroller processing
	 // time in accordance with its priority within the system.
 }
   

xTaskGenericNotifyFromISR()

configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this function to be available. When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private "notification value", which is a 32-bit unsigned integer (uint32_t). A version of xTaskNotify() that can be used from an interrupt service routine (ISR). Events can be sent to a task using an intermediary object. Examples of such objects are queues, semaphores, mutexes and event groups. Task notifications are a method of sending an event directly to a task without the need for such an intermediary object. A notification sent to a task can optionally perform an action, such as update, overwrite or increment the task's notification value. In that way task notifications can be used to send data to a task, or be used as light weight and fast binary or counting semaphores. A notification sent to a task will remain pending until it is cleared by the task calling xTaskNotifyWait() or ulTaskNotifyTake(). If the task was already in the Blocked state to wait for a notification when the notification arrives then the task will automatically be removed from the Blocked state (unblocked) and the notification cleared. A task can use xTaskNotifyWait() to [optionally] block to wait for a notification to be pending, or ulTaskNotifyTake() to [optionally] block to wait for its notification value to have a non-zero value. The task does not consume any CPU time while it is in the Blocked state. See http://www.FreeRTOS.org/RTOS-task-notifications.html for details. eSetBits - The task's notification value is bitwise ORed with ulValue. xTaskNofify() always returns pdPASS in this case. eIncrement - The task's notification value is incremented. ulValue is not used and xTaskNotify() always returns pdPASS in this case. eSetValueWithOverwrite - The task's notification value is set to the value of ulValue, even if the task being notified had not yet processed the previous notification (the task already had a notification pending). xTaskNotify() always returns pdPASS in this case. eSetValueWithoutOverwrite - If the task being notified did not already have a notification pending then the task's notification value is set to ulValue and xTaskNotify() will return pdPASS. If the task being notified already had a notification pending then no action is performed and pdFAIL is returned. eNoAction - The task receives a notification without its notification value being updated. ulValue is not used and xTaskNotify() always returns pdPASS in this case.

vTaskPrioritySet()

INCLUDE_vTaskPrioritySet must be defined as 1 for this function to be available. See the configuration section for more information. Set the priority of any task. A context switch will occur before the function returns if the priority being set is higher than the currently executing task. Example usage:

 void vAFunction( void )
 {
 TaskHandle_t xHandle;
	 // Create a task, storing the handle.
	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
	 // ...
	 // Use the handle to raise the priority of the created task.
	 vTaskPrioritySet( xHandle, tskIDLE_PRIORITY + 1 );
	 // ...
	 // Use a NULL handle to raise our priority to the same value.
	 vTaskPrioritySet( NULL, tskIDLE_PRIORITY + 1 );
 }
   

vTaskSuspend()

INCLUDE_vTaskSuspend must be defined as 1 for this function to be available. See the configuration section for more information. Suspend any task. When suspended a task will never get any microcontroller processing time, no matter what its priority. Calls to vTaskSuspend are not accumulative - i.e. calling vTaskSuspend () twice on the same task still only requires one call to vTaskResume () to ready the suspended task. Example usage:

 void vAFunction( void )
 {
 TaskHandle_t xHandle;
	 // Create a task, storing the handle.
	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
	 // ...
	 // Use the handle to suspend the created task.
	 vTaskSuspend( xHandle );
	 // ...
	 // The created task will not run during this period, unless
	 // another task calls vTaskResume( xHandle ).
	 //...
	 // Suspend ourselves.
	 vTaskSuspend( NULL );
	 // We cannot get here unless another task calls vTaskResume
	 // with our handle as the parameter.
 }
   

xTaskGenericNotify()

configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this function to be available. When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private "notification value", which is a 32-bit unsigned integer (uint32_t). Events can be sent to a task using an intermediary object. Examples of such objects are queues, semaphores, mutexes and event groups. Task notifications are a method of sending an event directly to a task without the need for such an intermediary object. A notification sent to a task can optionally perform an action, such as update, overwrite or increment the task's notification value. In that way task notifications can be used to send data to a task, or be used as light weight and fast binary or counting semaphores. A notification sent to a task will remain pending until it is cleared by the task calling xTaskNotifyWait() or ulTaskNotifyTake(). If the task was already in the Blocked state to wait for a notification when the notification arrives then the task will automatically be removed from the Blocked state (unblocked) and the notification cleared. A task can use xTaskNotifyWait() to [optionally] block to wait for a notification to be pending, or ulTaskNotifyTake() to [optionally] block to wait for its notification value to have a non-zero value. The task does not consume any CPU time while it is in the Blocked state. See http://www.FreeRTOS.org/RTOS-task-notifications.html for details. eSetBits - The task's notification value is bitwise ORed with ulValue. xTaskNofify() always returns pdPASS in this case. eIncrement - The task's notification value is incremented. ulValue is not used and xTaskNotify() always returns pdPASS in this case. eSetValueWithOverwrite - The task's notification value is set to the value of ulValue, even if the task being notified had not yet processed the previous notification (the task already had a notification pending). xTaskNotify() always returns pdPASS in this case. eSetValueWithoutOverwrite - If the task being notified did not already have a notification pending then the task's notification value is set to ulValue and xTaskNotify() will return pdPASS. If the task being notified already had a notification pending then no action is performed and pdFAIL is returned. eNoAction - The task receives a notification without its notification value being updated. ulValue is not used and xTaskNotify() always returns pdPASS in this case. pulPreviousNotificationValue - Can be used to pass out the subject task's notification value before any bits are modified by the notify function.

xTaskAbortDelay()

INCLUDE_xTaskAbortDelay must be defined as 1 in FreeRTOSConfig.h for this function to be available. A task will enter the Blocked state when it is waiting for an event. The event it is waiting for can be a temporal event (waiting for a time), such as when vTaskDelay() is called, or an event on an object, such as when xQueueReceive() or ulTaskNotifyTake() is called. If the handle of a task that is in the Blocked state is used in a call to xTaskAbortDelay() then the task will leave the Blocked state, and return from whichever function call placed the task into the Blocked state. There is no 'FromISR' version of this function as an interrupt would need to know which object a task was blocked on in order to know which actions to take. For example, if the task was blocked on a queue the interrupt handler would then need to know if the queue was locked.

uxTaskPriorityGetFromISR()

A version of uxTaskPriorityGet() that can be used from an ISR.

xTaskResumeFromISR()

INCLUDE_xTaskResumeFromISR must be defined as 1 for this function to be available. See the configuration section for more information. An implementation of vTaskResume() that can be called from within an ISR. A task that has been suspended by one or more calls to vTaskSuspend () will be made available for running again by a single call to xTaskResumeFromISR (). xTaskResumeFromISR() should not be used to synchronise a task with an interrupt if there is a chance that the interrupt could arrive prior to the task being suspended - as this can lead to interrupts being missed. Use of a semaphore as a synchronisation mechanism would avoid this eventuality.

pcTaskGetName()

ulTaskNotifyValueClear()

Clears the bits specified by the ulBitsToClear bit mask in the notification value of the task referenced by xTask. Set ulBitsToClear to 0xffffffff (UINT_MAX on 32-bit architectures) to clear the notification value to 0. Set ulBitsToClear to 0 to query the task's notification value without clearing any bits.

osThreadSetPriority()

Change priority of an active thread.

osThreadGetPriority()

Get current priority of an active thread.

osMailCreate()

Create and Initialize mail queue

vTaskGetInfo()

configUSE_TRACE_FACILITY must be defined as 1 for this function to be available. See the configuration section for more information. Populates a TaskStatus_t structure with information about a task. @xGetFreeStackSpace The TaskStatus_t structure contains a member to report the stack high water mark of the task being queried. Calculating the stack high water mark takes a relatively long time, and can make the system temporarily unresponsive - so the xGetFreeStackSpace parameter is provided to allow the high water mark checking to be skipped. The high watermark value will only be written to the TaskStatus_t structure if xGetFreeStackSpace is not set to pdFALSE; Example usage:

 void vAFunction( void )
 {
 TaskHandle_t xHandle;
 TaskStatus_t xTaskDetails;
    // Obtain the handle of a task from its name.
    xHandle = xTaskGetHandle( "Task_Name" );
    // Check the handle is not NULL.
    configASSERT( xHandle );
    // Use the handle to obtain further information about the task.
    vTaskGetInfo( xHandle,
                  &xTaskDetails,
                  pdTRUE, // Include the high water mark in xTaskDetails.
                  eInvalid ); // Include the task state in xTaskDetails.
 }
   

vTaskNotifyGiveFromISR()

void vTaskNotifyGiveFromISR( TaskHandle_t xTaskHandle, BaseType_t *pxHigherPriorityTaskWoken );
 configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this macro
 to be available.
 When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
 "notification value", which is a 32-bit unsigned integer (uint32_t).
 A version of xTaskNotifyGive() that can be called from an interrupt service
 routine (ISR).
 Events can be sent to a task using an intermediary object.  Examples of such
 objects are queues, semaphores, mutexes and event groups.  Task notifications
 are a method of sending an event directly to a task without the need for such
 an intermediary object.
 A notification sent to a task can optionally perform an action, such as
 update, overwrite or increment the task's notification value.  In that way
 task notifications can be used to send data to a task, or be used as light
 weight and fast binary or counting semaphores.
 vTaskNotifyGiveFromISR() is intended for use when task notifications are
 used as light weight and faster binary or counting semaphore equivalents.
 Actual FreeRTOS semaphores are given from an ISR using the
 xSemaphoreGiveFromISR() API function, the equivalent action that instead uses
 a task notification is vTaskNotifyGiveFromISR().
 When task notifications are being used as a binary or counting semaphore
 equivalent then the task being notified should wait for the notification
 using the ulTaskNotificationTake() API function rather than the
 xTaskNotifyWait() API function.
 See http://www.FreeRTOS.org/RTOS-task-notifications.html for more details.

prvTaskIsTaskSuspended()

Utility task that simply returns pdTRUE if the task referenced by xTask is currently in the Suspended state, or pdFALSE if the task referenced by xTask is in any other state.

prvDeleteTCB()

prvAddNewTaskToReadyList()

prvInitialiseNewTask()

xTaskPriorityInherit()

xTaskPriorityDisinherit()

vTaskPriorityDisinheritAfterTimeout()

vTaskAllocateMPURegions()

Memory regions are assigned to a restricted task when the task is created by a call to xTaskCreateRestricted(). These regions can be redefined using vTaskAllocateMPURegions(). Example usage:

// Define an array of MemoryRegion_t structures that configures an MPU region
// allowing read/write access for 1024 bytes starting at the beginning of the
// ucOneKByte array.  The other two of the maximum 3 definable regions are
// unused so set to zero.
static const MemoryRegion_t xAltRegions[ portNUM_CONFIGURABLE_REGIONS ] =
{
	// Base address		Length		Parameters
	{ ucOneKByte,		1024,		portMPU_REGION_READ_WRITE },
	{ 0,				0,			0 },
	{ 0,				0,			0 }
};
void vATask( void *pvParameters )
{
	// This task was created such that it has access to certain regions of
	// memory as defined by the MPU configuration.  At some point it is
	// desired that these MPU regions are replaced with that defined in the
	// xAltRegions const struct above.  Use a call to vTaskAllocateMPURegions()
	// for this purpose.  NULL is used as the task handle to indicate that this
	// function should modify the MPU regions of the calling task.
	vTaskAllocateMPURegions( NULL, xAltRegions );
	// Now the task can continue its function, but from this point on can only
	// access its stack and the ucOneKByte array (unless any other statically
	// defined or shared regions have been declared elsewhere).
}
   

uxTaskGetStackHighWaterMark()

INCLUDE_uxTaskGetStackHighWaterMark must be set to 1 in FreeRTOSConfig.h for this function to be available. Returns the high water mark of the stack associated with xTask. That is, the minimum free stack space there has been (in words, so on a 32 bit machine a value of 1 means 4 bytes) since the task started. The smaller the returned number the closer the task has come to overflowing its stack. uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the same except for their return type. Using configSTACK_DEPTH_TYPE allows the user to determine the return type. It gets around the problem of the value overflowing on 8-bit types without breaking backward compatibility for applications that expect an 8-bit return type.

MPU_vTaskAllocateMPURegions()

Memory regions are assigned to a restricted task when the task is created by a call to xTaskCreateRestricted(). These regions can be redefined using vTaskAllocateMPURegions(). Example usage:

// Define an array of MemoryRegion_t structures that configures an MPU region
// allowing read/write access for 1024 bytes starting at the beginning of the
// ucOneKByte array.  The other two of the maximum 3 definable regions are
// unused so set to zero.
static const MemoryRegion_t xAltRegions[ portNUM_CONFIGURABLE_REGIONS ] =
{
	// Base address		Length		Parameters
	{ ucOneKByte,		1024,		portMPU_REGION_READ_WRITE },
	{ 0,				0,			0 },
	{ 0,				0,			0 }
};
void vATask( void *pvParameters )
{
	// This task was created such that it has access to certain regions of
	// memory as defined by the MPU configuration.  At some point it is
	// desired that these MPU regions are replaced with that defined in the
	// xAltRegions const struct above.  Use a call to vTaskAllocateMPURegions()
	// for this purpose.  NULL is used as the task handle to indicate that this
	// function should modify the MPU regions of the calling task.
	vTaskAllocateMPURegions( NULL, xAltRegions );
	// Now the task can continue its function, but from this point on can only
	// access its stack and the ucOneKByte array (unless any other statically
	// defined or shared regions have been declared elsewhere).
}
   

MPU_xTaskAbortDelay()

MPU_uxTaskPriorityGet()

INCLUDE_uxTaskPriorityGet must be defined as 1 for this function to be available. See the configuration section for more information. Obtain the priority of any task. Example usage:

 void vAFunction( void )
 {
 TaskHandle_t xHandle;
	 // Create a task, storing the handle.
	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
	 // ...
	 // Use the handle to obtain the priority of the created task.
	 // It was created with tskIDLE_PRIORITY, but may have changed
	 // it itself.
	 if( uxTaskPriorityGet( xHandle ) != tskIDLE_PRIORITY )
	 {
		 // The task has changed it's priority.
	 }
	 // ...
	 // Is our priority higher than the created task?
	 if( uxTaskPriorityGet( xHandle ) < uxTaskPriorityGet( NULL ) )
	 {
		 // Our priority (obtained using NULL handle) is higher.
	 }
 }
   

MPU_eTaskGetState()

MPU_pcTaskGetName()

MPU_uxTaskGetStackHighWaterMark()

MPU_xTaskGenericNotify()

configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this function to be available. When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private "notification value", which is a 32-bit unsigned integer (uint32_t). Events can be sent to a task using an intermediary object. Examples of such objects are queues, semaphores, mutexes and event groups. Task notifications are a method of sending an event directly to a task without the need for such an intermediary object. A notification sent to a task can optionally perform an action, such as update, overwrite or increment the task's notification value. In that way task notifications can be used to send data to a task, or be used as light weight and fast binary or counting semaphores. A notification sent to a task will remain pending until it is cleared by the task calling xTaskNotifyWait() or ulTaskNotifyTake(). If the task was already in the Blocked state to wait for a notification when the notification arrives then the task will automatically be removed from the Blocked state (unblocked) and the notification cleared. A task can use xTaskNotifyWait() to [optionally] block to wait for a notification to be pending, or ulTaskNotifyTake() to [optionally] block to wait for its notification value to have a non-zero value. The task does not consume any CPU time while it is in the Blocked state. See http://www.FreeRTOS.org/RTOS-task-notifications.html for details. eSetBits - The task's notification value is bitwise ORed with ulValue. xTaskNofify() always returns pdPASS in this case. eIncrement - The task's notification value is incremented. ulValue is not used and xTaskNotify() always returns pdPASS in this case. eSetValueWithOverwrite - The task's notification value is set to the value of ulValue, even if the task being notified had not yet processed the previous notification (the task already had a notification pending). xTaskNotify() always returns pdPASS in this case. eSetValueWithoutOverwrite - If the task being notified did not already have a notification pending then the task's notification value is set to ulValue and xTaskNotify() will return pdPASS. If the task being notified already had a notification pending then no action is performed and pdFAIL is returned. eNoAction - The task receives a notification without its notification value being updated. ulValue is not used and xTaskNotify() always returns pdPASS in this case. pulPreviousNotificationValue - Can be used to pass out the subject task's notification value before any bits are modified by the notify function.

MPU_xTaskNotifyStateClear()

MPU_ulTaskNotifyValueClear()

MPU_vTaskGetInfo()

 void vAFunction( void )
 {
 TaskHandle_t xHandle;
 TaskStatus_t xTaskDetails;
    // Obtain the handle of a task from its name.
    xHandle = xTaskGetHandle( "Task_Name" );
    // Check the handle is not NULL.
    configASSERT( xHandle );
    // Use the handle to obtain further information about the task.
    vTaskGetInfo( xHandle,
                  &xTaskDetails,
                  pdTRUE, // Include the high water mark in xTaskDetails.
                  eInvalid ); // Include the task state in xTaskDetails.
 }
   

MPU_vTaskPrioritySet()

 void vAFunction( void )
 {
 TaskHandle_t xHandle;
	 // Create a task, storing the handle.
	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
	 // ...
	 // Use the handle to raise the priority of the created task.
	 vTaskPrioritySet( xHandle, tskIDLE_PRIORITY + 1 );
	 // ...
	 // Use a NULL handle to raise our priority to the same value.
	 vTaskPrioritySet( NULL, tskIDLE_PRIORITY + 1 );
 }
   

MPU_vTaskSuspend()

 void vAFunction( void )
 {
 TaskHandle_t xHandle;
	 // Create a task, storing the handle.
	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
	 // ...
	 // Use the handle to suspend the created task.
	 vTaskSuspend( xHandle );
	 // ...
	 // The created task will not run during this period, unless
	 // another task calls vTaskResume( xHandle ).
	 //...
	 // Suspend ourselves.
	 vTaskSuspend( NULL );
	 // We cannot get here unless another task calls vTaskResume
	 // with our handle as the parameter.
 }
   

MPU_vTaskResume()

 void vAFunction( void )
 {
 TaskHandle_t xHandle;
	 // Create a task, storing the handle.
	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
	 // ...
	 // Use the handle to suspend the created task.
	 vTaskSuspend( xHandle );
	 // ...
	 // The created task will not run during this period, unless
	 // another task calls vTaskResume( xHandle ).
	 //...
	 // Resume the suspended task ourselves.
	 vTaskResume( xHandle );
	 // The created task will once again get microcontroller processing
	 // time in accordance with its priority within the system.
 }
   

xTaskCreateRestricted()

// Create an TaskParameters_t structure that defines the task to be created.
static const TaskParameters_t xCheckTaskParameters =
{
	vATask,		// pvTaskCode - the function that implements the task.
	"ATask",	// pcName - just a text name for the task to assist debugging.
	100,		// usStackDepth	- the stack size DEFINED IN WORDS.
	NULL,		// pvParameters - passed into the task function as the function parameters.
	( 1UL | portPRIVILEGE_BIT ),// uxPriority - task priority, set the portPRIVILEGE_BIT if the task should run in a privileged state.
	cStackBuffer,// puxStackBuffer - the buffer to be used as the task stack.
	// xRegions - Allocate up to three separate memory regions for access by
	// the task, with appropriate access permissions.  Different processors have
	// different memory alignment requirements - refer to the FreeRTOS documentation
	// for full information.
	{
		// Base address					Length	Parameters
		{ cReadWriteArray,				32,		portMPU_REGION_READ_WRITE },
		{ cReadOnlyArray,				32,		portMPU_REGION_READ_ONLY },
		{ cPrivilegedOnlyAccessArray,	128,	portMPU_REGION_PRIVILEGED_READ_WRITE }
	}
};
int main( void )
{
TaskHandle_t xHandle;
	// Create a task from the const structure defined above.  The task handle
	// is requested (the second parameter is not NULL) but in this case just for
	// demonstration purposes as its not actually used.
	xTaskCreateRestricted( &xRegTest1Parameters, &xHandle );
	// Start the scheduler.
	vTaskStartScheduler();
	// Will only get here if there was insufficient memory to create the idle
	// and/or timer task.
	for( ;; );
}
   

osSignalClear()

Clear the specified Signal Flags of an active thread.

osAbortDelay()

Abort the delay for a specific thread

uxTaskGetTaskNumber()

vTaskSetTaskNumber()

MPU_uxTaskGetStackHighWaterMark2()

INCLUDE_uxTaskGetStackHighWaterMark2 must be set to 1 in FreeRTOSConfig.h for this function to be available. Returns the high water mark of the stack associated with xTask. That is, the minimum free stack space there has been (in words, so on a 32 bit machine a value of 1 means 4 bytes) since the task started. The smaller the returned number the closer the task has come to overflowing its stack. uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the same except for their return type. Using configSTACK_DEPTH_TYPE allows the user to determine the return type. It gets around the problem of the value overflowing on 8-bit types without breaking backward compatibility for applications that expect an 8-bit return type.

MPU_xTaskCallApplicationTaskHook()

Calls the hook function associated with xTask. Passing xTask as NULL has the effect of calling the Running tasks (the calling task) hook function. pvParameter is passed to the hook function for the task to interpret as it wants. The return value is the value returned by the task hook function registered by the user.

osThreadIsSuspended()

Check if a thread is already suspended or not.

uxTaskGetStackHighWaterMark2()

xTaskCallApplicationTaskHook()

MPU_xTaskCreateRestrictedStatic()

MPU_vTaskSetApplicationTaskTag()

MPU_xTaskGetApplicationTaskTag()

MPU_vTaskSetThreadLocalStoragePointer()

MPU_pvTaskGetThreadLocalStoragePointer()