BaseType_t xTaskCreate( 
    TaskFunction_t pxTaskCode,                    // 任务函数
    const char * const pcName,                    // 任务名字
    const configSTACK_DEPTH_TYPE usStackDepth,    // 栈的深度
    void * const pvParameters,                    // 传递给任务的参数
    UBaseType_t uxPriority,                       // 任务优先级
    TaskHandle_t * const pxCreatedTask            // 任务句柄
);

void myTask(void *pvParameters) {
    while(1) {
        // 执行任务代码
    }
}

xTaskCreate(myTask, "MyTask", 128, NULL, 1, NULL);

xTaskCreate(myTask, "MyTask", 128, NULL, 1, NULL);  // 128 字节的栈

void myTask(void *pvParameters) {
    // 任务执行时，可以通过 pvParameters 获取到传递的参数
}

xTaskCreate(myTask, "MyTask", 128, (void *)parameter, 1, NULL);

xTaskCreate(myTask, "MyTask", 128, NULL, 2, NULL);  // 任务优先级为 2

TaskHandle_t xTaskHandle;
xTaskCreate(myTask, "MyTask", 128, NULL, 1, &xTaskHandle);  // 保存任务句柄

vTaskPrioritySet(xTaskHandle, 2);  // 修改任务优先级

TaskHandle_t xTaskCreateStatic( TaskFunction_t pxTaskCode,
                                   const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
                                   const uint32_t ulStackDepth,
                                   void * const pvParameters,
                                   UBaseType_t uxPriority,
                                   StackType_t * const puxStackBuffer,
                                   StaticTask_t * const pxTaskBuffer )

xTaskCreate`的最后一个参数：`TaskHandle_t * const pxCreatedTask
xTaskCreateStatic`的最后一个参数：` StaticTask_t * const pxTaskBuffer

typedef tskTCB TCB_t;

// 其中tskTCB定义如下：
typedef struct tskTaskControlBlock       /* The old naming convention is used
 to prevent breaking kernel aware debuggers. */
{
    volatile StackType_t * pxTopOfStack; /*< Points to the location of the 
last item placed on the tasks stack.  THIS MUST BE THE FIRST MEMBER OF THE TCB STRUCT. */

    #if ( portUSING_MPU_WRAPPERS == 1 )
        xMPU_SETTINGS xMPUSettings; /*< The MPU settings are defined as part
 of the port layer.  THIS MUST BE THE SECOND MEMBER OF THE TCB STRUCT. */
    #endif

    ListItem_t xStateListItem;                  /*< The list that the state list
 item of a task is reference from denotes the state of that task (Ready, Blocked, Suspended ). */
    ListItem_t xEventListItem;                  /*< Used to reference a task from an event list. */
    UBaseType_t uxPriority;                     /*< The priority of the task.  0 is the lowest priority. */
    StackType_t * pxStack;                      /*< Points to the start of the stack. */
    char pcTaskName[ configMAX_TASK_NAME_LEN ]; /*< Descriptive name given to
 the task when created.  Facilitates debugging only. */ /*lint !e971
 Unqualified char types are allowed for strings and single characters only. */

    #if ( ( portSTACK_GROWTH > 0 ) || ( configRECORD_STACK_HIGH_ADDRESS == 1 ) )
        StackType_t * pxEndOfStack; /*< Points to the highest valid address for the stack. */
    #endif

    #if ( portCRITICAL_NESTING_IN_TCB == 1 )
        UBaseType_t uxCriticalNesting; /*< Holds the critical section nesting depth 
for ports that do not maintain their own count in the port layer. */
    #endif

    #if ( configUSE_TRACE_FACILITY == 1 )
        UBaseType_t uxTCBNumber;  /*< Stores a number that increments each time a TCB is 
created.  It allows debuggers to determine when a task has been deleted and then recreated. */
        UBaseType_t uxTaskNumber; /*< Stores a number specifically for use by third party trace code. */
    #endif

    #if ( configUSE_MUTEXES == 1 )
        UBaseType_t uxBasePriority; /*< The priority last assigned to the task - used by the priority inheritance mechanism. */
        UBaseType_t uxMutexesHeld;
    #endif

    #if ( configUSE_APPLICATION_TASK_TAG == 1 )
        TaskHookFunction_t pxTaskTag;
    #endif

    #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )
        void * pvThreadLocalStoragePointers[ configNUM_THREAD_LOCAL_STORAGE_POINTERS ];
    #endif

    #if ( configGENERATE_RUN_TIME_STATS == 1 )
        uint32_t ulRunTimeCounter; /*< Stores the amount of time the task has spent in the Running state. */
    #endif

    #if ( configUSE_NEWLIB_REENTRANT == 1 )
        /* Allocate a Newlib reent structure that is specific to this task.
         * Note Newlib support has been included by popular demand, but is not
         * used by the FreeRTOS maintainers themselves.  FreeRTOS is not
         * responsible for resulting newlib operation.  User must be familiar with
         * newlib and must provide system-wide implementations of the necessary
         * stubs. Be warned that (at the time of writing) the current newlib design
         * implements a system-wide malloc() that must be provided with locks.
         *
         * See the third party link http://www.nadler.com/embedded/newlibAndFreeRTOS.html
         * for additional information. */
        struct  _reent xNewLib_reent;
    #endif

    #if ( configUSE_TASK_NOTIFICATIONS == 1 )
        volatile uint32_t ulNotifiedValue[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
        volatile uint8_t ucNotifyState[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
    #endif

    /* See the comments in FreeRTOS.h with the definition of
     * tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE. */
    #if ( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 !e9029 Macro
 has been consolidated for readability reasons. */
        uint8_t ucStaticallyAllocated;                     /*< Set to pdTRUE
 if the task is a statically allocated to ensure no attempt is made to free the memory. */
    #endif

    #if ( INCLUDE_xTaskAbortDelay == 1 )
        uint8_t ucDelayAborted;
    #endif

    #if ( configUSE_POSIX_ERRNO == 1 )
        int iTaskErrno;
    #endif
} tskTCB;

#include "FreeRTOS.h"
#include "task.h"
#include <stdio.h>

// 定义任务栈大小
#define TASK_STACK_SIZE 128

// 定义任务优先级
#define TASK_PRIORITY 1

// 定义任务栈和任务控制块 (用于静态任务创建)
static StackType_t xTaskStack[TASK_STACK_SIZE];
static StaticTask_t xTaskBuffer;

// 动态任务函数
void vTaskDynamic(void *pvParameters) {
    while(1) {
        printf("This is the dynamic task!\n");
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

// 静态任务函数
void vTaskStatic(void *pvParameters) {
    while(1) {
        printf("This is the static task!\n");
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

int main(void) {
    // 创建动态任务 (使用xTaskCreate)
    xTaskCreate(vTaskDynamic, "DynamicTask", TASK_STACK_SIZE, NULL, TASK_PRIORITY, NULL);

    // 创建静态任务 (使用xTaskCreateStatic)
    xTaskCreateStatic(
        vTaskStatic,                  // 任务函数
        "StaticTask",                 // 任务名称
        TASK_STACK_SIZE,              // 栈大小
        NULL,                         // 任务参数
        TASK_PRIORITY,                // 优先级
        xTaskStack,                   // 静态栈内存
        &xTaskBuffer                  // 静态任务控制块
    );

    // 启动调度器
    vTaskStartScheduler();

    while(1); // 程序不应该到达这里
    return 0;
}

void vTaskDelete( TaskHandle_t xTaskToDelete );

//xTaskToDelete：要删除的任务的句柄。如果传入 NULL，则删除当前任务。
//删除指定的任务。如果传入的是任务句柄，它将删除对应的任务。任务删除后，任务的内存会被释放，包括栈空间和任务控制块（TCB）。
//如果传入的是 NULL，则会删除当前正在执行的任务，也就是说，当前任务会删除自己。

#include "FreeRTOS.h"
#include "task.h"
#include <stdio.h>

// 任务句柄
TaskHandle_t xTaskHandle1 = NULL;
TaskHandle_t xTaskHandle2 = NULL;

// 任务函数1
void vTaskFunction1(void *pvParameters) {
    while(1) {
        printf("Task 1 is running.\n");

        // 任务1自杀：删除自己
        if (some_condition) {
            printf("Task 1 is deleting itself.\n");
            vTaskDelete(NULL);  // 自杀，删除自己
        }

        vTaskDelay(pdMS_TO_TICKS(1000));  // 延时1秒
    }
}

// 任务函数2
void vTaskFunction2(void *pvParameters) {
    while(1) {
        printf("Task 2 is running.\n");

        // 被杀：由其他任务删除
        if (some_condition) {
            printf("Task 2 is being deleted by Task 1.\n");
            vTaskDelete(xTaskHandle2);  // 删除任务2
        }

        vTaskDelay(pdMS_TO_TICKS(1000));  // 延时1秒
    }
}

// 任务函数3（杀人）
void vTaskFunction3(void *pvParameters) {
    while(1) {
        printf("Task 3 is running.\n");

        // 杀人：删除任务1
        if (some_condition) {
            printf("Task 3 is deleting Task 1.\n");
            vTaskDelete(xTaskHandle1);  // 删除任务1
        }

        vTaskDelay(pdMS_TO_TICKS(1000));  // 延时1秒
    }
}

int main(void) {
    // 创建任务1
    xTaskCreate(vTaskFunction1, "Task1", 128, NULL, 1, &xTaskHandle1);
    
    // 创建任务2
    xTaskCreate(vTaskFunction2, "Task2", 128, NULL, 1, &xTaskHandle2);
    
    // 创建任务3
    xTaskCreate(vTaskFunction3, "Task3", 128, NULL, 1, NULL);

    // 启动调度器
    vTaskStartScheduler();

    while(1);  // 不应该到达这里
    return 0;
}

void vTask1( void *pvParameters )
{
    const TickType_t xDelay100ms = pdMS_TO_TICKS( 100UL );
    BaseType_t ret;
    /* 任务函数的主体一般都是无限循环 */for( ;; ){
        /* 打印任务的信息 */
        printf("Task1 is running\r\n");
        ret = xTaskCreate( vTask2, "Task 2", 1000, NULL, 2, &xTask2Handle );
        if (ret != pdPASS)
            printf("Create Task2 Failed\r\n");
        // 如果不休眠的话, Idle任务无法得到执行
        // Idel任务会清理任务2使用的内存
        // 如果不休眠则Idle任务无法执行, 最后内存耗尽
        vTaskDelay( xDelay100ms );
    }
}

void vTask2( void *pvParameters )
{
    /* 打印任务的信息 */
    printf("Task2 is running and about to delete itself\r\n");
    // 可以直接传入参数NULL, 这里只是为了演示函数用法
    vTaskDelete(xTask2Handle);
}

int main( void )
{
    prvSetupHardware();
    xTaskCreate(vTask1, "Task 1", 1000, NULL, 1, NULL);
    /* 启动调度器 */
    vTaskStartScheduler();
    /* 如果程序运行到了这里就表示出错了, 一般是内存不足 */
    return 0;
}

// 伪代码示例
for (priority = configMAX_PRIORITIES - 1; priority >= 0; priority--) {
    if (uxTopReadyPriority & (1UL << priority)) {
        return priority;
    }
}

void vTask1( void *pvParameters )
{
    /* 任务函数的主体一般都是无限循环 */
    for( ;; ){
        /* 打印任务的信息 */
        printf("T1\r\n");
    }
}
void vTask2( void *pvParameters )
{
    /* 任务函数的主体一般都是无限循环 */
    for( ;; ){
        /* 打印任务的信息 */
        printf("T2\r\n");
    }
}
void vTask3( void *pvParameters )
{
    const TickType_t xDelay3000ms = pdMS_TO_TICKS( 3000UL );
    /* 任务函数的主体一般都是无限循环 */
    for( ;; ){
        /* 打印任务的信息 */
        printf("T3\r\n");
        // 如果不休眠的话, 其他任务无法得到执行
        vTaskDelay( xDelay3000ms );
    }
}
int main(void)
{
    prvSetupHardware();
    xTaskCreate(vTask1, "Task 1", 1000, NULL, 1, NULL);
    xTaskCreate(vTask2, "Task 2", 1000, NULL, 1, NULL);
    xTaskCreate(vTask3, "Task 3", 1000, NULL, 2, NULL);
    /* 启动调度器 */
    vTaskStartScheduler();
    /* 如果程序运行到了这里就表示出错了, 一般是内存不足 */
    return 0;
}

UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask );

void vTaskPrioritySet( TaskHandle_t xTask,
                        UBaseType_t uxNewPriority );

void vTask1( void *pvParameters )
{
    UBaseType_t uxPriority;
    /* Task1,Task2都不会进入阻塞或者暂停状态*/
    /* 根据优先级决定谁能运行*/
    /* 得到Task1自己的优先级 */
    uxPriority = uxTaskPriorityGet( NULL );
    for( ;; )
    {
        printf( "Task 1 is running\r\n" );
        printf("About to raise the Task 2 priority\r\n" );
        /* 提升Task2的优先级高于Task1 */
        /* Task2会即刻执行 */
        vTaskPrioritySet( xTask2Handle, ( uxPriority + 1 ) );
        /* 如果Task1能运行到这里，表示它的优先级比Task2高
        /* 那就表示Task2肯定把自己的优先级降低了*/
    }
}
void vTask2( void *pvParameters )
{
    UBaseType_t uxPriority;
    /* Task1,Task2都不会进入阻塞或者暂停状态*/
    /* 根据优先级决定谁能运行*/
    /* 得到Task2自己的优先级 */
    uxPriority = uxTaskPriorityGet( NULL );
    for( ;; )
    {
        /* 能运行到这里表示Task2的优先级高于Task1 */
        /* Task1提高了Task2的优先级 */
        printf( "Task 2 is running\r\n" );
        printf( "About to lower the Task 2 priority\r\n" );
        /* 降低Task2自己的优先级，让它小于Task1*/
        /* Task1得以运行*/
        vTaskPrioritySet( NULL, ( uxPriority - 2 ) );
    }
}

int main( void )
{
    prvSetupHardware();
    /* Task1的优先级更高, Task1先执行 */
    xTaskCreate( vTask1, "Task 1", 1000, NULL, 2, NULL );
    xTaskCreate( vTask2, "Task 2", 1000, NULL, 1, &xTask2Handle );
    /* 启动调度器 */
    vTaskStartScheduler();
    /* 如果程序运行到了这里就表示出错了, 一般是内存不足 */
    return 0;
}