1BaseType_t xTaskCreate( TaskFunction_t pvTaskCode,
2const char * const pcName,
3configSTACK_DEPTH_TYPE usStackDepth,
4void *pvParameters,
5UBaseType_t uxPriority,
6TaskHandle_t *pxCreatedTask
7);

1/* Task to be created. */
 2void vTaskCode( void * pvParameters )
 3{
 4/* The parameter value is expected to be 1 as 1 is passed in the
 5pvParameters value in the call to xTaskCreate() below. 
 6configASSERT( ( ( uint32_t ) pvParameters ) == 1 );
 7
 8for( ;; )
 9{
10/* Task code goes here. */
11}
12}
13
14/* Function that creates a task. */
15void vOtherFunction( void )
16{
17BaseType_t xReturned;
18TaskHandle_t xHandle = NULL;
19
20/* Create the task, storing the handle. */
21xReturned = xTaskCreate(
22vTaskCode, /* Function that implements the task. */
23"NAME", /* Text name for the task. */
24STACK_SIZE, /* Stack size in words, not bytes. */
25( void * ) 1, /* Parameter passed into the task. */
26tskIDLE_PRIORITY,/* Priority at which the task is created. */
27&xHandle ); /* Used to pass out the created task's handle. */
28
29if( xReturned == pdPASS )
30{
31/* The task was created. Use the task's handle to delete the task. */
32vTaskDelete( xHandle );
33}
34}

1TaskHandle_t xTaskCreateStatic( TaskFunction_t pxTaskCode,
2const char * const pcName,
3const uint32_t ulStackDepth,
4void * const pvParameters,
5UBaseType_t uxPriority,
6StackType_t * const puxStackBuffer,
7StaticTask_t * const pxTaskBuffer );

1/* Dimensions of the buffer that the task being created will use as its stack.
 2NOTE: This is the number of words the stack will hold, not the number of
 3bytes. For example, if each stack item is 32-bits, and this is set to 100,
 4then 400 bytes (100 * 32-bits) will be allocated. */
 5#define STACK_SIZE 200
 6
 7/* Structure that will hold the TCB of the task being created. */
 8StaticTask_t xTaskBuffer;
 9
10/* Buffer that the task being created will use as its stack. Note this is
11an array of StackType_t variables. The size of StackType_t is dependent on
12the RTOS port. */
13StackType_t xStack[ STACK_SIZE ];
14
15/* Function that implements the task being created. */
16void vTaskCode( void * pvParameters )
17{
18/* The parameter value is expected to be 1 as 1 is passed in the
19pvParameters value in the call to xTaskCreateStatic(). */
20configASSERT( ( uint32_t ) pvParameters == 1UL );
21
22for( ;; )
23{
24/* Task code goes here. */
25}
26}
27
28/* Function that creates a task. */
29void vOtherFunction( void )
30{
31TaskHandle_t xHandle = NULL;
32
33/* Create the task without using any dynamic memory allocation. */
34xHandle = xTaskCreateStatic(
35vTaskCode, /* Function that implements the task. */
36"NAME", /* Text name for the task. */
37STACK_SIZE, /* Number of indexes in the xStack array. */
38( void * ) 1, /* Parameter passed into the task. */
39tskIDLE_PRIORITY,/* Priority at which the task is created. */
40xStack, /* Array to use as the task's stack. */
41&xTaskBuffer ); /* Variable to hold the task's data structure. */
42
43/* puxStackBuffer and pxTaskBuffer were not NULL, so the task will have
44been created, and xHandle will be the task's handle. Use the handle
45to suspend the task. */
46vTaskSuspend( xHandle );
47}

1BaseType_t xTaskCreateRestrictedStatic( TaskParameters_t *pxTaskDefinition,
2TaskHandle_t *pxCreatedTask );

1typedef struct xTASK_PARAMETERS
 2{
 3TaskFunction_t pvTaskCode;
 4const signed char * const pcName;
 5unsigned short usStackDepth;
 6void *pvParameters;
 7UBaseType_t uxPriority;
 8portSTACK_TYPE *puxStackBuffer;
 9MemoryRegion_t xRegions[ portNUM_CONFIGURABLE_REGIONS ];
10#if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
11StaticTask_t * const pxTaskBuffer;
12#endif
13} TaskParameters_t;
14....where MemoryRegion_t is defined as:
15typedef struct xMEMORY_REGION
16{
17void *pvBaseAddress;
18unsigned long ulLengthInBytes;
19unsigned long ulParameters;
20} MemoryRegion_t;

1portMPU_REGION_READ_WRITE
2portMPU_REGION_PRIVILEGED_READ_ONLY
3portMPU_REGION_READ_ONLY
4portMPU_REGION_PRIVILEGED_READ_WRITE
5portMPU_REGION_CACHEABLE_BUFFERABLE
6portMPU_REGION_EXECUTE_NEVER

1/* Create an TaskParameters_t structure that defines the task to be created.
 2* The StaticTask_t variable is only included in the structure when
 3* configSUPPORT_STATIC_ALLOCATION is set to 1. The PRIVILEGED_DATA macro can
 4* be used to force the variable into the RTOS kernel's privileged data area. */
 5static PRIVILEGED_DATA StaticTask_t xTaskBuffer;
 6static const TaskParameters_t xCheckTaskParameters =
 7{
 8vATask, /* pvTaskCode - the function that implements the task. */
 9"ATask", /* pcName - just a text name for the task to assist debugging. */
10100, /* usStackDepth - the stack size DEFINED IN WORDS. */
11NULL, /* pvParameters - passed into the task function as the function parameters. */
12( 1UL | portPRIVILEGE_BIT ),/* uxPriority - task priority, set the portPRIVILEGE_BIT 
13if the task should run in a privileged state. */
14cStackBuffer,/* puxStackBuffer - the buffer to be used as the task stack. */
15
16/* xRegions - Allocate up to three separate memory regions for access by
17* the task, with appropriate access permissions. Different processors have
18* different memory alignment requirements - refer to the FreeRTOS documentation
19* for full information. */
20{
21/* Base address Length Parameters */
22{ cReadWriteArray, 32, portMPU_REGION_READ_WRITE },
23{ cReadOnlyArray, 32, portMPU_REGION_READ_ONLY },
24{ cPrivilegedOnlyAccessArray, 128, portMPU_REGION_PRIVILEGED_READ_WRITE }
25}
26
27&xTaskBuffer; /* Holds the task's data structure. */
28};
29
30int main( void )
31{
32TaskHandle_t xHandle;
33
34/* Create a task from the const structure defined above. The task handle
35* is requested (the second parameter is not NULL) but in this case just for
36* demonstration purposes as its not actually used. */
37xTaskCreateRestricted( &xRegTest1Parameters, &xHandle );
38
39/* Start the scheduler. */
40vTaskStartScheduler();
41
42/* Will only get here if there was insufficient memory to create the idle
43* and/or timer task. */
44for( ;; );
45}

1void vOtherFunction( void )
 2{
 3TaskHandle_t xHandle = NULL;
 4
 5// Create the task, storing the handle.
 6xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
 7
 8// Use the handle to delete the task.
 9if( xHandle != NULL )
10{
11vTaskDelete( xHandle );
12}
13}