typedef struct tskTaskControlBlock {
    volatile StackType_t *pxTopOfStack;    // 栈顶指针
    ListItem_t xStateListItem;             // 状态列表项
    ListItem_t xEventListItem;            // 事件列表项
    UBaseType_t uxPriority;               // 任务优先级
    StackType_t *pxStack;                 // 栈起始地址
    char pcTaskName[ configMAX_TASK_NAME_LEN ];  // 任务名称
    // ... 其他成员
} tskTCB;

BaseType_t xTaskCreate(
    TaskFunction_t pvTaskCode,
    const char * const pcName,
    configSTACK_DEPTH_TYPE usStackDepth,
    void *pvParameters,
    UBaseType_t uxPriority,
    TaskHandle_t *pxCreatedTask
);

void vMyTask(void *pvParameters) {
    // 任务初始化代码
    for(;;) {  // 必须有一个永不退出的循环
        // 任务主体
        vTaskDelay(pdMS_TO_TICKS(1000));  // 必须有阻塞调用
    }
    // 永远不会执行到这里
}

void vTaskDelete(TaskHandle_t xTaskToDelete);

// 不好的写法：忙等待，占用 CPU
void vBadTask(void *pvParameters) {
    for(;;) {
        if(xButtonPressed()) {
            processButton();
        }
        // 没有延时，一直占着 CPU
    }
}

// 好的写法：事件驱动，大部分时间阻塞
void vGoodTask(void *pvParameters) {
    for(;;) {
        // 等待按键事件，任务进入阻塞态
        if(xQueueReceive(xButtonQueue, &event, portMAX_DELAY)) {
            processButtonEvent(&event);
        }
    }
}

// 创建二值信号量
SemaphoreHandle_t xBinarySemaphore = xSemaphoreCreateBinary();

void vInterruptHandler(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    // 中断中释放信号量
    xSemaphoreGiveFromISR(xBinarySemaphore, &xHigherPriorityTaskWoken);
    // 如果有更高优先级任务被唤醒，请求上下文切换
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

void vTaskFunction(void *pvParameters) {
    for(;;) {
        // 等待信号量，阻塞直到中断释放
        if(xSemaphoreTake(xBinarySemaphore, portMAX_DELAY) == pdTRUE) {
            // 处理中断事件
            processInterruptEvent();
        }
    }
}

// 创建计数信号量，最大值 10，初始值 0
SemaphoreHandle_t xCountingSemaphore = xSemaphoreCreateCounting(10, 0);

// 生产者任务
void vProducerTask(void *pvParameters) {
    for(;;) {
        produceData();
        xSemaphoreGive(xCountingSemaphore);  // 计数 +1
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

// 消费者任务
void vConsumerTask(void *pvParameters) {
    for(;;) {
        if(xSemaphoreTake(xCountingSemaphore, pdMS_TO_TICKS(1000))) {
            consumeData();  // 计数 -1
        }
    }
}

// 创建互斥量
SemaphoreHandle_t xMutex = xSemaphoreCreateMutex();

void vHighPriorityTask(void *pvParameters) {
    for(;;) {
        if(xSemaphoreTake(xMutex, portMAX_DELAY)) {
            // 访问共享资源
            accessSharedResource();
            xSemaphoreGive(xMutex);
        }
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

SemaphoreHandle_t xRecursiveMutex = xSemaphoreCreateRecursiveMutex();

void vFunctionA(void) {
    xSemaphoreTakeRecursive(xRecursiveMutex, portMAX_DELAY);
    // 做一些事情
    vFunctionB();  // 里面也会获取同一个互斥量
    xSemaphoreGiveRecursive(xRecursiveMutex);
}

void vFunctionB(void) {
    xSemaphoreTakeRecursive(xRecursiveMutex, portMAX_DELAY);
    // 做一些事情
    xSemaphoreGiveRecursive(xRecursiveMutex);
}

// 定义消息结构体
typedef struct {
    uint32_t ulMessageID;
    uint32_t ulData;
    char pcText[20];
} xMessage;

// 创建队列，最多存放 5 个 xMessage 大小的元素
QueueHandle_t xQueue = xQueueCreate(5, sizeof(xMessage));

// 发送任务
void vSenderTask(void *pvParameters) {
    xMessage msg = {0};
    for(;;) {
        msg.ulMessageID++;
        msg.ulData = getSensorValue();
        // 发送到队列，如果队列满了，最多等待 100ms
        if(xQueueSend(xQueue, &msg, pdMS_TO_TICKS(100)) != pdPASS) {
            // 队列满，处理发送失败
        }
        vTaskDelay(pdMS_TO_TICKS(50));
    }
}

// 接收任务
void vReceiverTask(void *pvParameters) {
    xMessage msg;
    for(;;) {
        // 从队列接收，最多等待 1 秒
        if(xQueueReceive(xQueue, &msg, pdMS_TO_TICKS(1000)) == pdPASS) {
            processMessage(&msg);
        }
    }
}

// 创建队列集，可以容纳 10 个事件
QueueSetHandle_t xQueueSet = xQueueCreateSet(10);

// 把多个队列和信号量添加到集合中
xQueueAddToSet(xQueue1, xQueueSet);
xQueueAddToSet(xQueue2, xQueueSet);
xQueueAddToSet(xSemaphore, xQueueSet);

void vMultipleEventTask(void *pvParameters) {
    QueueSetMemberHandle_t xActivatedMember;
    for(;;) {
        // 等待任意一个事件
        xActivatedMember = xQueueSelectFromSet(xQueueSet, portMAX_DELAY);
        
        if(xActivatedMember == xQueue1) {
            // 处理队列 1 的消息
        } else if(xActivatedMember == xQueue2) {
            // 处理队列 2 的消息
        } else if(xActivatedMember == xSemaphore) {
            // 处理信号量事件
        }
    }
}

// 这是一个邮箱 - 大小为 1 的队列
QueueHandle_t xMailbox = xQueueCreate(1, sizeof(LargeData_t *));

// 发送方
LargeData_t *pxBuffer = pvPortMalloc(sizeof(LargeData_t));
fillLargeData(pxBuffer);
LargeData_t *pxOld = NULL;
// 覆盖旧数据
xQueueOverwrite(xMailbox, &pxBuffer);
if(pxOld != NULL) {
    vPortFree(pxOld);
}

// 接收方
LargeData_t *pxData;
xQueuePeek(xMailbox, &pxData, portMAX_DELAY);
// 直接使用指针访问，不需要复制

// 定时器回调函数
void vTimerCallback(TimerHandle_t xTimer) {
    uint32_t ulTimerID = (uint32_t)pvTimerGetTimerID(xTimer);
    switch(ulTimerID) {
        case 1: processTimer1Event(); break;
        case 2: processTimer2Event(); break;
    }
}

// 创建定时器
TimerHandle_t xTimer1 = xTimerCreate(
    "Timer1",               // 定时器名称
    pdMS_TO_TICKS(1000),    // 周期：1 秒
    pdTRUE,                 // 自动重载
    (void *)1,              // 定时器 ID
    vTimerCallback          // 回调函数
);

// 启动定时器
xTimerStart(xTimer1, 0);

// 空闲任务钩子 - 每个空闲周期调用一次
void vApplicationIdleHook(void) {
    // 可以在这里进入低功耗模式
    __WFI();
}

// Tick 钩子 - 每个系统 tick 调用一次
void vApplicationTickHook(void) {
    // 可以在这里做一些高精度的定时工作
}

// 栈溢出钩子 - 检测到栈溢出时调用
void vApplicationStackOverflowHook(
    TaskHandle_t xTask, char *pcTaskName) {
    // 严重错误，记录日志或进入安全状态
    panic("Stack overflow in task: %s", pcTaskName);
}

// 内存分配失败钩子
void vApplicationMallocFailedHook(void) {
    panic("Malloc failed!");
}

// 在 STM32 上的典型配置
#define configLIBRARY_LOWEST_INTERRUPT_PRIORITY     15
#define configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY 5

// 优先级 0-4：完全不受 FreeRTOS 影响，不能调用 API
// 优先级 5-15：可以调用 FromISR 版本的 API

// 中断服务函数 - 尽可能短
void EXTI0_IRQHandler(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    static uint32_t ulInterruptCount = 0;
    
    // 清除中断标志
    HAL_GPIO_EXTI_CLEAR_FLAG(GPIO_PIN_0);
    
    // 只做最必要的工作
    ulInterruptCount++;
    
    // 唤醒处理任务
    xTaskNotifyFromISR(xProcessTaskHandle, 
                       ulInterruptCount, 
                       eSetValueWithOverwrite,
                       &xHigherPriorityTaskWoken);
    
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

// 延迟处理任务 - 在这里做耗时工作
void vProcessTask(void *pvParameters) {
    uint32_t ulNotificationValue;
    for(;;) {
        // 等待中断通知
        xTaskNotifyWait(0, ULONG_MAX, &ulNotificationValue, portMAX_DELAY);
        
        // 执行耗时的处理工作
        performComplexCalculation();
        logInterruptEvent(ulNotificationValue);
        updateDisplay();
    }
}

// heap_1 的核心实现
static uint8_t ucHeap[configTOTAL_HEAP_SIZE];
static size_t xNextFreeByte = 0;

void *pvPortMalloc(size_t xWantedSize) {
    void *pvReturn = NULL;
    // 字节对齐
    xWantedSize = (xWantedSize + portBYTE_ALIGNMENT_MASK) 
                 & ~portBYTE_ALIGNMENT_MASK;
    
    if(xNextFreeByte + xWantedSize < configTOTAL_HEAP_SIZE) {
        pvReturn = &(ucHeap[xNextFreeByte]);
        xNextFreeByte += xWantedSize;
    }
    return pvReturn;
}

// heap_1 没有 vPortFree！

// heap_2 用链表管理空闲内存块
typedef struct A_BLOCK_LINK {
    struct A_BLOCK_LINK *pxNextFreeBlock;
    size_t xBlockSize;
} BlockLink_t;

// 分配时遍历空闲链表，找到第一个足够大的块
void *pvPortMalloc(size_t xWantedSize) {
    // 遍历空闲块链表
    BlockLink_t *pxBlock = xStart.pxNextFreeBlock;
    while(pxBlock->xBlockSize < xWantedSize) {
        pxBlock = pxBlock->pxNextFreeBlock;
    }
    // 如果块很大，分割成两块
    if(pxBlock->xBlockSize - xWantedSize > heapMINIMUM_BLOCK_SIZE) {
        // 在剩余部分创建新的空闲块
    }
    // 从空闲链表中移除
    return (void *)((uint8_t *)pxBlock + sizeof(BlockLink_t));
}

// 释放时检查相邻块是否也是空闲的，如果是就合并
static void prvInsertBlockIntoFreeList(BlockLink_t *pxBlockToInsert) {
    BlockLink_t *pxIterator;
    uint8_t *puc;
    
    // 找到地址相邻的前一个块
    for(pxIterator = &xStart; 
        pxIterator->pxNextFreeBlock < pxBlockToInsert;
        pxIterator = pxIterator->pxNextFreeBlock) {
    }
    
    // 检查能否与前一个块合并
    puc = (uint8_t *)pxIterator;
    if(puc + pxIterator->xBlockSize == (uint8_t *)pxBlockToInsert) {
        pxIterator->xBlockSize += pxBlockToInsert->xBlockSize;
        pxBlockToInsert = pxIterator;
    }
    
    // 检查能否与后一个块合并
    puc = (uint8_t *)pxBlockToInsert;
    if(puc + pxBlockToInsert->xBlockSize == 
       (uint8_t *)pxIterator->pxNextFreeBlock) {
        if(pxIterator->pxNextFreeBlock != pxEnd) {
            pxBlockToInsert->xBlockSize += 
                pxIterator->pxNextFreeBlock->xBlockSize;
            pxBlockToInsert->pxNextFreeBlock = 
                pxIterator->pxNextFreeBlock->pxNextFreeBlock;
        }
    }
}

// 获取当前空闲堆大小
size_t xFreeSize = xPortGetFreeHeapSize();

// 获取历史最小空闲堆大小（非常重要！）
size_t xMinEverFree = xPortGetMinimumEverFreeHeapSize();

// 打印堆使用状态
void vPrintHeapStats(void) {
    printf("Free heap: %u bytes\n", xPortGetFreeHeapSize());
    printf("Minimum free: %u bytes\n", 
           xPortGetMinimumEverFreeHeapSize());
}

/*************************
 * 任务优先级分配
 *************************/
#define PRIORITY_LED_TASK        1    // 最低：LED 指示
#define PRIORITY_DISPLAY_TASK    2    // 低：LCD 显示
#define PRIORITY_UART_TASK       3    // 中：串口通信
#define PRIORITY_SENSOR_TASK     4    // 中高：传感器采集
#define PRIORITY_KEY_TASK        5    // 高：按键响应

/*************************
 * 队列定义
 *************************/
typedef enum {
    MSG_KEY_PRESS,
    MSG_SENSOR_DATA,
    MSG_UART_COMMAND,
    MSG_LED_CONTROL,
    MSG_DISPLAY_UPDATE
} MessageType_t;

typedef struct {
    MessageType_t type;
    uint32_t param1;
    uint32_t param2;
    float fParam;
} SystemMessage_t;

QueueHandle_t xSystemQueue;
QueueHandle_t xDisplayQueue;

/*************************
 * 传感器采集任务
 *************************/
void vSensorTask(void *pvParameters) {
    float temperature, humidity;
    SystemMessage_t msg;
    
    for(;;) {
        // 读取传感器
        if(readDHT11(&temperature, &humidity)) {
            msg.type = MSG_SENSOR_DATA;
            msg.fParam = temperature;
            msg.param1 = (uint32_t)(humidity * 100);
            // 发送到系统队列
            xQueueSend(xSystemQueue, &msg, 0);
        }
        // 每 100ms 采集一次
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

/*************************
 * 按键处理任务
 *************************/
void vKeyTask(void *pvParameters) {
    SystemMessage_t msg;
    uint8_t keyValue, lastKey = 0;
    
    for(;;) {
        keyValue = scanKey();
        if(keyValue != lastKey && keyValue != 0) {
            // 按键按下
            msg.type = MSG_KEY_PRESS;
            msg.param1 = keyValue;
            xQueueSendToFront(xSystemQueue, &msg, 0);
        }
        lastKey = keyValue;
        // 20ms 扫描一次，实现消抖
        vTaskDelay(pdMS_TO_TICKS(20));
    }
}

/*************************
 * 主控制任务 - 事件分发
 *************************/
void vMainTask(void *pvParameters) {
    SystemMessage_t msg;
    float currentTemp = 0.0f;
    uint8_t fanSpeed = 0;
    
    for(;;) {
        // 等待系统事件
        if(xQueueReceive(xSystemQueue, &msg, pdMS_TO_TICKS(1000))) {
            switch(msg.type) {
                case MSG_KEY_PRESS:
                    handleKeyPress(msg.param1);
                    break;
                    
                case MSG_SENSOR_DATA:
                    currentTemp = msg.fParam;
                    // 自动控制风扇
                    if(currentTemp > 28.0f && fanSpeed == 0) {
                        setFanSpeed(50);
                        fanSpeed = 50;
                    } else if(currentTemp < 25.0f && fanSpeed > 0) {
                        setFanSpeed(0);
                        fanSpeed = 0;
                    }
                    // 更新显示
                    updateDisplay(currentTemp, fanSpeed);
                    break;
                    
                case MSG_UART_COMMAND:
                    executeUartCommand(msg.param1, msg.param2);
                    break;
            }
        }
        // 看门狗喂狗
        IWDG_ReloadCounter();
    }
}

int main(void) {
    // 硬件初始化
    HAL_Init();
    SystemClock_Config();
    GPIO_Init();
    UART_Init();
    LCD_Init();
    
    // 创建队列
    xSystemQueue = xQueueCreate(10, sizeof(SystemMessage_t));
    xDisplayQueue = xQueueCreate(5, sizeof(DisplayMessage_t));
    
    // 创建任务
    xTaskCreate(vSensorTask, "Sensor", 256, NULL, 
                PRIORITY_SENSOR_TASK, NULL);
    xTaskCreate(vKeyTask, "Key", 128, NULL, 
                PRIORITY_KEY_TASK, NULL);
    xTaskCreate(vMainTask, "Main", 512, NULL, 
                PRIORITY_MAIN_TASK, NULL);
    xTaskCreate(vDisplayTask, "Display", 256, NULL, 
                PRIORITY_DISPLAY_TASK, NULL);
    xTaskCreate(vUartTask, "Uart", 256, NULL, 
                PRIORITY_UART_TASK, NULL);
    xTaskCreate(vLedTask, "Led", 64, NULL, 
                PRIORITY_LED_TASK, NULL);
    
    // 启动调度器
    vTaskStartScheduler();
    
    // 永远不会执行到这里
    while(1);
}

// 1. 开启栈溢出检测
#define configCHECK_FOR_STACK_OVERFLOW  2

// 2. 打印任务栈使用情况
void vPrintTaskStackUsage(void) {
    TaskStatus_t *pxTaskStatusArray;
    UBaseType_t uxArraySize, x;
    
    uxArraySize = uxTaskGetNumberOfTasks();
    pxTaskStatusArray = pvPortMalloc(
        uxArraySize * sizeof(TaskStatus_t));
    
    uxTaskGetSystemState(pxTaskStatusArray, 
                         uxArraySize, NULL);
    
    printf("Task\t\tFree\tUsed%%\n");
    printf("--------------------------------\n");
    for(x = 0; x < uxArraySize; x++) {
        uint32_t ulUsed = 
            pxTaskStatusArray[x].usStackHighWaterMark;
        printf("%-16s %5u  %3u%%\n",
               pxTaskStatusArray[x].pcTaskName,
               (unsigned)ulUsed,
               (unsigned)(ulUsed * 100 / 
               pxTaskStatusArray[x].uxCurrentPriority));
    }
    vPortFree(pxTaskStatusArray);
}

// 任务 A
xSemaphoreTake(Mutex1, portMAX_DELAY);
vTaskDelay(1);  // 给任务 B 一个机会执行
xSemaphoreTake(Mutex2, portMAX_DELAY);  // 死锁！

// 任务 B
xSemaphoreTake(Mutex2, portMAX_DELAY);
vTaskDelay(1);
xSemaphoreTake(Mutex1, portMAX_DELAY);  // 死锁！

// 获取 CPU 使用率
void vGetRunTimeStats(void) {
    char pcWriteBuffer[512];
    vTaskGetRunTimeStats(pcWriteBuffer);
    printf("%s\n", pcWriteBuffer);
}

// 精确周期执行
void vPeriodicTask(void *pvParameters) {
    TickType_t xLastWakeTime = xTaskGetTickCount();
    const TickType_t xPeriod = pdMS_TO_TICKS(100);
    
    for(;;) {
        // 这个任务会精确地每 100ms 执行一次
        doPeriodicWork();
        vTaskDelayUntil(&xLastWakeTime, xPeriod);
    }
}