SemaphoreHandle_t xSemaphoreCreateBinary(void);

// 创建二进制信号量
SemaphoreHandle_t xBinarySemaphore;

void vInitSemaphores(void) {
    xBinarySemaphore = xSemaphoreCreateBinary();

    if(xBinarySemaphore != NULL) {
        // 创建成功后立即使其可用
        xSemaphoreGive(xBinarySemaphore);
        printf("Binary semaphore created and made available\n");
    } else {
        printf("Failed to create binary semaphore\n");
    }
}

SemaphoreHandle_t xSemaphoreCreateBinaryStatic(StaticSemaphore_t *pxSemaphoreBuffer);

// 静态分配信号量控制块
static StaticSemaphore_t xBinarySemaphoreBuffer;

void vInitStaticSemaphores(void) {
    // 静态创建二进制信号量
    SemaphoreHandle_t xStaticBinarySemaphore;
    xStaticBinarySemaphore = xSemaphoreCreateBinaryStatic(&xBinarySemaphoreBuffer);

    if(xStaticBinarySemaphore != NULL) {
        xSemaphoreGive(xStaticBinarySemaphore);
        printf("Static binary semaphore created successfully\n");
    }
}

SemaphoreHandle_t xSemaphoreCreateCounting(UBaseType_t uxMaxCount,
                                         UBaseType_t uxInitialCount);

// 创建各种计数信号量示例
SemaphoreHandle_t xParkingSemaphore;      // 停车场信号量
SemaphoreHandle_t xBufferSemaphore;       // 缓冲区信号量
SemaphoreHandle_t xConnectionSemaphore;   // 连接数信号量

void vCreateCountingSemaphores(void) {
    // 停车场：10个车位，初始全部空着
    xParkingSemaphore = xSemaphoreCreateCounting(10, 10);

    // 缓冲区：最多5个缓冲块，初始有3个可用
    xBufferSemaphore = xSemaphoreCreateCounting(5, 3);

    // 数据库连接：最多8个连接，初始全部可用
    xConnectionSemaphore = xSemaphoreCreateCounting(8, 8);

    // 检查创建结果
    if(xParkingSemaphore == NULL || xBufferSemaphore == NULL || xConnectionSemaphore == NULL) {
        printf("Error: Failed to create counting semaphores\n");
    } else {
        printf("All counting semaphores created successfully\n");
    }
}

SemaphoreHandle_t xSemaphoreCreateCountingStatic(UBaseType_t uxMaxCount,
                                                UBaseType_t uxInitialCount,
                                                StaticSemaphore_t *pxSemaphoreBuffer);

BaseType_t xSemaphoreTake(SemaphoreHandle_t xSemaphore, 
                         TickType_t xTicksToWait);

void vTaskUsingSemaphore(void *pvParameters) {
    TickType_t xLastWakeTime = xTaskGetTickCount();

    while(1) {
        // 尝试获取信号量，等待100ms
        if(xSemaphoreTake(xBinarySemaphore, 100 / portTICK_PERIOD_MS) == pdTRUE) {
            // 成功获取信号量，执行受保护的操作
            printf("Semaphore acquired, performing critical operation\n");
            vPerformCriticalOperation();

            // 释放信号量
            xSemaphoreGive(xBinarySemaphore);
            printf("Semaphore released\n");
        } else {
            // 获取信号量超时
            printf("Failed to acquire semaphore within timeout\n");
        }

        // 任务周期执行
        vTaskDelayUntil(&xLastWakeTime, 1000 / portTICK_PERIOD_MS);
    }
}

BaseType_t xSemaphoreGive(SemaphoreHandle_t xSemaphore);

void vProducerTask(void *pvParameters) {
    while(1) {
        // 生产数据
        vProduceData();

        // 释放信号量通知消费者
        if(xSemaphoreGive(xDataReadySemaphore) == pdTRUE) {
            printf("Signal sent to consumer\n");
        } else {
            printf("Failed to give semaphore\n");
        }

        vTaskDelay(500 / portTICK_PERIOD_MS);
    }
}

BaseType_t xSemaphoreTakeFromISR(SemaphoreHandle_t xSemaphore,
                                BaseType_t *pxHigherPriorityTaskWoken);

BaseType_t xSemaphoreGiveFromISR(SemaphoreHandle_t xSemaphore,
                                BaseType_t *pxHigherPriorityTaskWoken);

// 外部中断处理函数
void EXTI0_IRQHandler(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;

    // 清除中断标志
    EXTI->PR = EXTI_PR_PR0;

    // 在中断中释放信号量
    if(xSemaphoreGiveFromISR(xInterruptSemaphore, &xHigherPriorityTaskWoken) == pdTRUE) {
        printf("Semaphore given from ISR\n");
    }

    // 必要时进行任务切换
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

// 处理中断的任务
void vInterruptHandlerTask(void *pvParameters) {
    while(1) {
        // 等待中断信号
        if(xSemaphoreTake(xInterruptSemaphore, portMAX_DELAY) == pdTRUE) {
            printf("Interrupt received, processing...\n");
            vProcessInterrupt();
        }
    }
}

void vSemaphoreDelete(SemaphoreHandle_t xSemaphore);

void vCleanupResources(void) {
    // 删除不再使用的信号量
    if(xBinarySemaphore != NULL) {
        vSemaphoreDelete(xBinarySemaphore);
        xBinarySemaphore = NULL;
        printf("Binary semaphore deleted\n");
    }

    if(xCountingSemaphore != NULL) {
        vSemaphoreDelete(xCountingSemaphore);
        xCountingSemaphore = NULL;
        printf("Counting semaphore deleted\n");
    }

    if(xMutex != NULL) {
        vSemaphoreDelete(xMutex);
        xMutex = NULL;
        printf("Mutex deleted\n");
    }
}

UBaseType_t uxSemaphoreGetCount(SemaphoreHandle_t xSemaphore);

void vMonitorSemaphoreStatus(void) {
    UBaseType_t uxBinaryCount, uxCountingCount, uxMutexCount;

    // 获取各种信号量的当前计数值
    uxBinaryCount = uxSemaphoreGetCount(xBinarySemaphore);
    uxCountingCount = uxSemaphoreGetCount(xCountingSemaphore);
    uxMutexCount = uxSemaphoreGetCount(xMutex);

    printf("Semaphore Status:\n");
    printf("  Binary: %lu\n", uxBinaryCount);
    printf("  Counting: %lu\n", uxCountingCount);
    printf("  Mutex: %lu\n", uxMutexCount);

    // 根据状态采取行动
    if(uxCountingCount == 0) {
        printf("Warning: No resources available in counting semaphore!\n");
    }
}

#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
#include "stdio.h"
#include "string.h"

// 系统信号量定义
SemaphoreHandle_t xParkingSpaces;      // 停车位计数信号量
SemaphoreHandle_t xEntryGate;          // 入口闸机二进制信号量
SemaphoreHandle_t xExitGate;           // 出口闸机二进制信号量
SemaphoreHandle_t xDisplayMutex;       // 显示屏互斥量

// 系统状态变量
static uint32_t ulCarsInParking = 0;
static uint32_t ulTotalCarsServed = 0;

// 显示屏输出函数（受互斥量保护）
void vSafePrintf(const char *format, ...) {
    va_list args;

    // 获取显示屏互斥量
    if(xSemaphoreTake(xDisplayMutex, 100 / portTICK_PERIOD_MS) == pdTRUE) {
        va_start(args, format);
        vprintf(format, args);
        va_end(args);

        // 释放互斥量
        xSemaphoreGive(xDisplayMutex);
    }
}

// 车辆入场任务
void vCarEntryTask(void *pvParameters) {
    uint8_t car_id = (uint8_t)pvParameters;
    char car_plate[10];

    // 生成车牌号
    snprintf(car_plate, sizeof(car_plate), "CAR%03d", car_id);

    vSafePrintf("[ENTRY] Car %s arrived at entrance\n", car_plate);

    while(1) {
        // 等待入口闸机可用（二进制信号量）
        if(xSemaphoreTake(xEntryGate, 2000 / portTICK_PERIOD_MS) == pdTRUE) {
            vSafePrintf("[ENTRY] Car %s is at gate\n", car_plate);

            // 尝试获取停车位（计数信号量）
            if(xSemaphoreTake(xParkingSpaces, 1000 / portTICK_PERIOD_MS) == pdTRUE) {
                // 成功获取停车位
                ulCarsInParking++;
                ulTotalCarsServed++;

                vSafePrintf("[ENTRY] Car %s entered. Parking: %lu/%lu, Total: %lu\n",
                           car_plate, ulCarsInParking, 
                           uxSemaphoreGetCount(xParkingSpaces) + ulCarsInParking,
                           ulTotalCarsServed);

                // 释放入口闸机
                xSemaphoreGive(xEntryGate);

                // 模拟停车时间（1-10秒）
                vTaskDelay((1000 + (rand() % 9000)) / portTICK_PERIOD_MS);

                // 车辆准备离开
                vSafePrintf("[EXIT]  Car %s preparing to leave\n", car_plate);

                // 等待出口闸机
                if(xSemaphoreTake(xExitGate, 2000 / portTICK_PERIOD_MS) == pdTRUE) {
                    // 释放停车位
                    xSemaphoreGive(xParkingSpaces);
                    ulCarsInParking--;

                    vSafePrintf("[EXIT]  Car %s left. Parking: %lu/%lu\n",
                               car_plate, ulCarsInParking,
                               uxSemaphoreGetCount(xParkingSpaces) + ulCarsInParking);

                    // 释放出口闸机
                    xSemaphoreGive(xExitGate);
                }

            } else {
                // 没有停车位可用
                vSafePrintf("[ENTRY] Car %s left - no parking space available\n", car_plate);
                xSemaphoreGive(xEntryGate);
            }
        } else {
            vSafePrintf("[ENTRY] Car %s gave up waiting for gate\n", car_plate);
        }

        // 车辆离开后等待一段时间再回来
        vTaskDelay((5000 + (rand() % 10000)) / portTICK_PERIOD_MS);
        vSafePrintf("[ENTRY] Car %s arrived again\n", car_plate);
    }
}

// 停车场监控任务
void vParkingMonitorTask(void *pvParameters) {
    UBaseType_t uxAvailableSpaces;
    UBaseType_t uxMaxSpaces = 10;  // 假设总共10个车位

    vSafePrintf("[MONITOR] Parking monitor started\n");

    while(1) {
        // 获取当前可用车位数量
        uxAvailableSpaces = uxSemaphoreGetCount(xParkingSpaces);

        vSafePrintf("\n=== Parking Status ===\n");
        vSafePrintf("Available spaces: %lu\n", uxAvailableSpaces);
        vSafePrintf("Cars in parking:  %lu\n", ulCarsInParking);
        vSafePrintf("Total served:     %lu\n", ulTotalCarsServed);
        vSafePrintf("Utilization:      %.1f%%\n", 
                   (float)(uxMaxSpaces - uxAvailableSpaces) / uxMaxSpaces * 100);

        // 状态警告
        if(uxAvailableSpaces == 0) {
            vSafePrintf("WARNING: Parking lot FULL!\n");
        } else if(uxAvailableSpaces <= 2) {
            vSafePrintf("WARNING: Parking lot almost full\n");
        }

        vSafePrintf("=====================\n\n");

        // 每5秒监控一次
        vTaskDelay(5000 / portTICK_PERIOD_MS);
    }
}

// 紧急车辆优先任务
void vEmergencyVehicleTask(void *pvParameters) {
    vSafePrintf("[EMERGENCY] Emergency vehicle service started\n");

    while(1) {
        // 随机模拟紧急车辆到达
        vTaskDelay((30000 + (rand() % 30000)) / portTICK_PERIOD_MS);

        vSafePrintf("[EMERGENCY] Emergency vehicle arriving!\n");

        // 紧急车辆优先入场
        if(xSemaphoreTake(xEntryGate, portMAX_DELAY) == pdTRUE) {
            vSafePrintf("[EMERGENCY] Emergency vehicle entering\n");

            // 强制获取停车位（可能等待）
            if(xSemaphoreTake(xParkingSpaces, portMAX_DELAY) == pdTRUE) {
                ulCarsInParking++;
                ulTotalCarsServed++;

                vSafePrintf("[EMERGENCY] Emergency vehicle parked\n");

                // 释放入口闸机
                xSemaphoreGive(xEntryGate);

                // 紧急处理时间较短
                vTaskDelay(2000 / portTICK_PERIOD_MS);

                // 紧急离开
                if(xSemaphoreTake(xExitGate, portMAX_DELAY) == pdTRUE) {
                    xSemaphoreGive(xParkingSpaces);
                    ulCarsInParking--;

                    vSafePrintf("[EMERGENCY] Emergency vehicle departed\n");
                    xSemaphoreGive(xExitGate);
                }
            }
        }
    }
}

// 系统初始化函数
void vInitializeParkingSystem(void) {
    printf("Initializing Parking Management System...\n");

    // 创建计数信号量：10个停车位，初始全部可用
    xParkingSpaces = xSemaphoreCreateCounting(10, 10);

    // 创建二进制信号量：入口和出口闸机，初始可用
    xEntryGate = xSemaphoreCreateBinary();
    xExitGate = xSemaphoreCreateBinary();

    // 创建互斥量：保护显示屏输出
    xDisplayMutex = xSemaphoreCreateMutex();

    // 检查信号量创建结果
    if(xParkingSpaces == NULL || xEntryGate == NULL || 
       xExitGate == NULL || xDisplayMutex == NULL) {
        printf("ERROR: Failed to create semaphores!\n");
        while(1); // 系统停止
    }

    // 使二进制信号量初始可用
    xSemaphoreGive(xEntryGate);
    xSemaphoreGive(xExitGate);

    printf("Parking system initialized successfully\n");
    printf("Total parking spaces: 10\n");
}

// 主函数
int main(void) {
    // 初始化停车场系统
    vInitializeParkingSystem();

    // 创建车辆任务（5辆常规车辆）
    for(int i = 1; i <= 5; i++) {
        xTaskCreate(vCarEntryTask, "CarEntry", 1024, (void*)i, 2, NULL);
    }

    // 创建监控任务
    xTaskCreate(vParkingMonitorTask, "Monitor", 1024, NULL, 1, NULL);

    // 创建紧急车辆任务（较高优先级）
    xTaskCreate(vEmergencyVehicleTask, "Emergency", 1024, NULL, 3, NULL);

    printf("Starting FreeRTOS scheduler...\n");
    vTaskStartScheduler();

    // 如果调度器启动失败
    while(1) {
        printf("ERROR: Scheduler failed to start!\n");
    }

    return 0;
}

BaseType_t xResult = xSemaphoreTake(xSemaphore, timeout);
if(xResult != pdTRUE) {
    // 处理策略：重试、使用备用方案、报告错误等
    handle_semaphore_timeout();
}

xSemaphore = xSemaphoreCreateBinary();
if(xSemaphore == NULL) {
    // 内存不足处理
    handle_memory_allocation_failure();
}