volatile bool g_uart_ready   = false;
volatile bool g_sensor_ready = false;

void main(void) {
    while (1) {
        if (g_uart_ready)   { process_uart();   g_uart_ready   = false; }
        if (g_sensor_ready) { update_display();  g_sensor_ready = false; }
        // 每加一个功能，就要在这里加一个 if
    }
}

void SensorTask(void *p) {
    sensor_data_t data;
    while (1) {
        ReadSensor(&data);
        xQueueSend(ui_queue,  &data, 0);  // 传感器任务必须知道 UI 队列
        xQueueSend(log_queue, &data, 0);  // 还要知道日志队列
    }
}

pthread_mutex_lock(&data_mutex);
shared_data = new_value;
pthread_cond_signal(&data_cond);
pthread_mutex_unlock(&data_mutex);

// 生产者只管发，不知道谁在监听
embedmq_post(q, "sensor.temp", &data, sizeof(data));

// 消费者只管注册，不知道谁在发
embedmq_register(q, "sensor.temp", on_temp, NULL);

embedmq_register(q, "sensor.temp.ui",  on_ui,  NULL);
embedmq_register(q, "sensor.temp.log", on_log, NULL);

#include "embedmq.h"
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>

typedef struct { float celsius; int humidity; } sensor_data_t;
typedef struct { int rssi; char ssid[32]; } wifi_info_t;

static embedmq_t *g_bus;

/* ── 消费者：UI 线程注册的 handler，启动时绑定一次 ── */

static void on_sensor(const void *data, size_t size, void *ctx)
{
    const sensor_data_t *d = data;
    printf("[UI] 温度: %.1f°C  湿度: %d%%\n", d->celsius, d->humidity);
}

static void on_wifi_connected(const void *data, size_t size, void *ctx)
{
    const wifi_info_t *w = data;
    printf("[UI] WiFi 已连接: %s (RSSI=%d)\n", w->ssid, w->rssi);
}

/* ── 生产者：传感器线程，只管发，完全不知道 UI 的存在 ── */

static void *sensor_thread(void *arg)
{
    sensor_data_t d = {0};
    while (1) {
        d.celsius  = 25.0f + (rand() % 50) * 0.1f;
        d.humidity = 55 + rand() % 20;
        embedmq_post(g_bus, "sensor.update", &d, sizeof(d));
        usleep(100000);
    }
    return NULL;
}

/* ── 生产者：网络线程，只管发 ── */

static void *network_thread(void *arg)
{
    wifi_info_t w = { .rssi = -55 };
    snprintf(w.ssid, sizeof(w.ssid), "HomeNetwork");
    embedmq_post(g_bus, "wifi.connected", &w, sizeof(w));
    return NULL;
}

int main(void)
{
    g_bus = embedmq_create(NULL);

    /* 启动阶段统一注册，两个生产者线程完全不需要知道这里 */
    embedmq_register(g_bus, "sensor.update",  on_sensor,         NULL);
    embedmq_register(g_bus, "wifi.connected", on_wifi_connected, NULL);

    pthread_t t1, t2;
    pthread_create(&t1, NULL, sensor_thread,  NULL);
    pthread_create(&t2, NULL, network_thread, NULL);

    sleep(1);
    embedmq_destroy(g_bus);
}

static void ring_write_bytes(embedmq_t *q, const void *src, size_t n)
{
    size_t end = q->buf_size - q->tail;  // 尾部剩余空间

    if (end >= n) {
        memcpy(q->buf + q->tail, src, n);        // 一次搞定
    } else {
        memcpy(q->buf + q->tail, src, end);       // 写到末尾
        memcpy(q->buf,           src + end, n - end); // 剩余从头写
    }
}

uint32_t embedmq_uuid(const char *name)
{
    uint32_t hash = 0x811C9DC5;          // FNV offset basis
    for (const unsigned char *p = name; *p; ++p) {
        hash ^= (uint32_t)*p;
        hash *= 0x01000193;              // FNV prime
    }
    return hash ? hash : 1;             // 保证非零（0 用作无效哨兵）
}

uint32_t uuid = embedmq_uuid("sensor.temp");  // 启动时算一次

while (1) {
    sensor_t d = read_sensor();
    embedmq_post_id(q, uuid, &d, sizeof(d));   // 直接用整数，跳过 hash
}

embedmq_pal_sem_create / destroy / give / take      // 信号量
embedmq_pal_mutex_create / destroy / lock / unlock  // 互斥锁
embedmq_pal_thread_create / join                    // 线程

size_t embedmq_mem_size(const embedmq_config_t *cfg) {
    return sizeof(struct embedmq_s)
         + cfg->max_handlers * sizeof(embedmq_handler_entry_t)
         + cfg->queue_size
         + cfg->max_msg_size;   // dispatch 缓冲区
}

static embedmq_config_t cfg = { .queue_size = 2048, .max_handlers = 8 };
static uint8_t mq_buf[2048 + 8*12 + 1024 + 64];  // 或用 embedmq_mem_size 算

static void task_trampoline(void *param)
{
    embedmq_pal_thread_t *t = param;
    t->fn(t->arg);             // 运行消费者循环……
    xSemaphoreGive(t->done);   // ……通知外部"我跑完了"……
    vTaskDelete(NULL);         // ……然后正确地删除自己，永不 return
}

typedef struct {
    TaskHandle_t      handle;
    SemaphoreHandle_t done;   // task 退出前 give 这个信号量
    void            (*fn)(void *);
    void             *arg;
} embedmq_pal_thread_t;

void embedmq_pal_thread_join(embedmq_pal_thread_t *t)
{
    xSemaphoreTake(t->done, portMAX_DELAY);  // 等 task 给信号
    vSemaphoreDelete(t->done);
}

// 用字节数除以 StackType_t 大小，得到正确的 depth
#define configMINIMAL_STACK_SIZE \
    ((unsigned short)(PTHREAD_STACK_MIN / sizeof(unsigned long)))

static embedmq_config_t cfg = {
    .queue_size   = 2048,
    .max_msg_size = 64,
    .max_handlers = 8,
};

static uint8_t mq_buf[4096];  // embedmq_mem_size(&cfg) 算出确切大小
static embedmq_t *q;

void app_init(void)
{
    q = embedmq_create_static(mq_buf, sizeof(mq_buf), &cfg);
    embedmq_register(q, "sensor.update", on_sensor, NULL);
    // 之后不再碰堆
}

// 编译：cmake -B build -DEMBEDMQ_PAL=none
embedmq_t *q = embedmq_create(&cfg);
embedmq_register(q, "tick.10ms", on_tick, NULL);

void TIM_IRQHandler(void) {
    embedmq_post(q, "tick.10ms", NULL, 0);
}

void main(void) {
    while (1) {
        embedmq_poll(q);  // 手动触发派发
        __WFI();
    }
}

uint8_t k;
uint8_t p;
uint8_t s;
int c;
void scan() {
    for (k = 0; k < 8; k++) {
        p = read(0x50 + k);
        s = p ^ 0xFF;
        if (s != 0 && s != last[k]) {
            c = __builtin_ctz(s);
            if (s > last[k])
                cb_press(k, c);
            else
                cb_release(k, c);
            last[k] = s;
        }
    }
}

typedef enum {
    KEY_EVENT_PRESS = 0,
    KEY_EVENT_RELEASE = 1,
} KeyEvent;

typedef void (*KeyCallback)(uint8_t row, uint8_t col, KeyEvent event);

static constexpr uint8_t kKeyMatrixBaseAddr = 0x50;
static constexpr uint8_t kKeyMatrixRows = 8;
static constexpr uint8_t kKeyMatrixMask = 0xFF;

static uint8_t g_key_last_state[kKeyMatrixRows];
static KeyCallback g_key_callbacks[kKeyMatrixRows][8];

void KeyMatrix_Scan(void) {
    for (uint8_t row = 0; row < kKeyMatrixRows; row++) {
        const uint8_t raw_state = GPIO_ReadPort(kKeyMatrixBaseAddr + row);
        const uint8_t inverted_state = raw_state ^ kKeyMatrixMask;

        if (inverted_state == g_key_last_state[row])
            continue;

        for (uint8_t col = 0; col < 8; col++) {
            const uint8_t bit_mask = 1U << col;
            const bool was_pressed = g_key_last_state[row] & bit_mask;
            const bool is_pressed = inverted_state & bit_mask;

            if (is_pressed == was_pressed)
                continue;

            const KeyEvent event = is_pressed ? KEY_EVENT_PRESS : KEY_EVENT_RELEASE;
            if (g_key_callbacks[row][col] != NULL)
                g_key_callbacks[row][col](row, col, event);
        }

        g_key_last_state[row] = inverted_state;
    }
}

// 匈牙利命名变体：g_ 全局、s_ 静态、p_ 指针
static uint8_t s_key_last_state[8];  // 文件作用域 static
UART_HandleTypeDef *g_huart1;        // 全局可见

// ❌ 裸函数名——链接时容易撞
void Init(void);
void Read(float *out);
void Reset(void);

// ✅ 模块前缀——C 的"命名空间"
void TempCtrl_Init(void);
void TempCtrl_Read(float *out);
void TempCtrl_Reset(void);

// struct 名 — PascalCase
// 成员 — snake_case，无后缀
typedef struct {
    float proportional;
    float integral;
    float derivative;
    float output_max;
} PidParams;

// 函数 — 模块前缀_PascalCase
bool Pid_Init(const PidParams *params);
float Pid_Compute(float setpoint, float measured);

// ❌ C enum — 全部漏到全局命名空间
enum { OK, ERROR, TIMEOUT };

// ✅ 加前缀隔离
typedef enum {
    RINGBUF_OK = 0,
    RINGBUF_ERR_NULL = 1,
    RINGBUF_ERR_FULL = 2,
} RingBuf_Error;

#define SENSOR_MAX_CHANNELS 8           // 宏 — 全大写
#define SENSOR_SAMPLE_RATE_HZ 1000      // 宏 — 全大写

static const uint32_t kPollIntervalMs = 100;  // const — k前缀

SemaphoreHandle_t xSemaphoreCreateBinary(void);

// 消费者
if (xSemaphoreTake(sem, portMAX_DELAY) == pdTRUE) {
    // 拿到令牌，干活
}

// 生产者（任务或 ISR）
xSemaphoreGive(sem);              // 任务里用
xSemaphoreGiveFromISR(sem, &woken); // ISR 里用

SemaphoreHandle_t g_data_ready;

// UART 中断：数据收完，通知任务处理
void UART_RxComplete_IRQ(void) {
    BaseType_t woken = pdFALSE;
    xSemaphoreGiveFromISR(g_data_ready, &woken);
    portYIELD_FROM_ISR(woken);
}

// 任务：等信号量，拿到就处理
void vUARTProcessor(void *pv) {
    while (1) {
        xSemaphoreTake(g_data_ready, portMAX_DELAY);
        ProcessReceivedData();
    }
}

SemaphoreHandle_t g_dma_sem = xSemaphoreCreateCounting(3, 3);

void vTask(void *pv) {
    // 申请一个 DMA 通道
    if (xSemaphoreTake(g_dma_sem, pdMS_TO_TICKS(100)) == pdTRUE) {
        UseDMA();
        xSemaphoreGive(g_dma_sem); // 用完归还
    } else {
        // 超时，三个通道都在忙
    }
}

SemaphoreHandle_t xSemaphoreCreateMutex(void);

// ❌ 会死锁
void DoSomething(void) {
    xSemaphoreTake(mutex, portMAX_DELAY);
    DoSomethingElse();  // 里面又 Take 同一个 mutex
    xSemaphoreGive(mutex);
}

SemaphoreHandle_t xSemaphoreCreateRecursiveMutex(void);
xSemaphoreTakeRecursive(mutex, portMAX_DELAY);    // 可以多次调
xSemaphoreGiveRecursive(mutex);                   // 给几次拿几次必须对等

#define configASSERT(x) if(!(x)) { taskDISABLE_INTERRUPTS(); for(;;); }

// 任务通知版（比信号量快 3-5 倍）
xTaskNotifyGive(handle);                  // 发通知
ulTaskNotifyTake(pdTRUE, portMAX_DELAY);  // 等通知

// 信号量版
xSemaphoreGive(sem);
xSemaphoreTake(sem, portMAX_DELAY);

QueueHandle_t xQueueCreate(
    UBaseType_t uxQueueLength,   // 最多存几条消息
    UBaseType_t uxItemSize       // 每条消息多大
);

BaseType_t xQueueSend(
    QueueHandle_t xQueue,
    const void *  pvItemToQueue,
    TickType_t    xTicksToWait   // 满时最多等多久，0 = 不等，portMAX_DELAY = 死等
);

xQueueSendToBack()   // 跟 xQueueSend 一样，放队尾
xQueueSendToFront()  // 插队到队首（紧急消息用）
xQueueOverwrite()    // 覆盖式发送，即使队列满了也写（适合只有一条最新数据的场景）

BaseType_t xQueueReceive(
    QueueHandle_t xQueue,
    void *        pvBuffer,      // 读出来的数据放这里
    TickType_t    xTicksToWait   // 空时最多等多久
);

xQueuePeek(queue, &buf, timeout);  // 看一眼，数据还在队列里

// 生产者任务：每 200ms 产生一个传感器数据
QueueHandle_t g_sensor_queue;

typedef struct {
    float temperature;
    int   humidity;
} sensor_data_t;

void vSensorTask(void *pv) {
    sensor_data_t data;
    while (1) {
        data.temperature = 25.0f + (rand() % 50) * 0.1f;
        data.humidity    = 55 + rand() % 20;
        xQueueSend(g_sensor_queue, &data, portMAX_DELAY);
        vTaskDelay(pdMS_TO_TICKS(200));
    }
}

// 消费者任务：收到数据后处理
void vDisplayTask(void *pv) {
    sensor_data_t data;
    while (1) {
        if (xQueueReceive(g_sensor_queue, &data, portMAX_DELAY) == pdTRUE) {
            printf("温度: %.1f°C  湿度: %d%%\r\n",
                   data.temperature, data.humidity);
        }
    }
}

int main(void) {
    g_sensor_queue = xQueueCreate(10, sizeof(sensor_data_t));
    xTaskCreate(vSensorTask,  "Sensor",  256, NULL, 2, NULL);
    xTaskCreate(vDisplayTask, "Display", 256, NULL, 1, NULL);
    vTaskStartScheduler();
    while (1);
}

BaseType_t xQueueSendFromISR(
    QueueHandle_t xQueue,
    const void *  pvItemToQueue,
    BaseType_t *  pxHigherPriorityTaskWoken  // 关键参数
);

// UART 接收中断
void UART_Rx_IRQHandler(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    uint8_t byte = UART->DR;

    xQueueSendFromISR(g_uart_queue, &byte, &xHigherPriorityTaskWoken);

    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

// ❌ 大结构体拷贝
xQueueCreate(8, sizeof(net_packet_t));  // 一条消息 516 字节

// ✅ 只传指针
xQueueCreate(8, sizeof(net_packet_t *));  // 一条消息 4 字节

void MyTask(void *pvParameters) {
    while (1) {
        // 干点什么
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

BaseType_t xTaskCreate(
    TaskFunction_t   pvTaskCode,       // 函数指针
    const char *     pcName,           // 调试用，别太长
    configSTACK_DEPTH_TYPE usStackDepth, // 堆栈，单位是 word 不是 byte
    void *           pvParameters,     // 传参
    UBaseType_t      uxPriority,       // 数字越大越高
    TaskHandle_t *   pxCreatedTask     // 句柄
);

void vTaskDelay(TickType_t xTicksToDelay);                    // 相对延时
void vTaskDelayUntil(TickType_t *pxWakeTime, TickType_t inc); // 绝对延时

// ❌ 实际周期 = 10ms + 执行时间
while (1) {
    ReadSensor();
    vTaskDelay(pdMS_TO_TICKS(10));
}

// ✅ 严格 10ms
TickType_t last = xTaskGetTickCount();
while (1) {
    ReadSensor();
    vTaskDelayUntil(&last, pdMS_TO_TICKS(10));
}

vTaskPrioritySet(handle, prio);      // 改优先级
uxTaskPriorityGet(handle);           // 查优先级
vTaskSuspend(handle);                // 挂起
vTaskResume(handle);                 // 恢复（任务上下文）
xTaskResumeFromISR(handle);          // 恢复（ISR 中）
xTaskGetTickCount();                 // 启动以来的 tick 数
uxTaskGetNumberOfTasks();            // 当前任务数
pcTaskGetName(handle);               // 任务名（调试用）
vTaskSuspendAll();                   // 关调度（ISR 仍可触发）
xTaskResumeAll();                    // 开调度

#include "FreeRTOS.h"
#include "task.h"

// LED 闪烁，500ms 一次
void vLEDTask(void *pv) {
    while (1) {
        HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
        vTaskDelay(pdMS_TO_TICKS(500));
    }
}

// 串口打印，严格 1 秒周期
void vLogTask(void *pv) {
    TickType_t last = xTaskGetTickCount();
    while (1) {
        printf("Uptime: %lu ms\r\n",
               xTaskGetTickCount() * portTICK_PERIOD_MS);
        vTaskDelayUntil(&last, pdMS_TO_TICKS(1000));
    }
}

// 按键扫描，20ms 轮询
void vButtonTask(void *pv) {
    while (1) {
        if (HAL_GPIO_ReadPin(BUTTON_GPIO_Port, BUTTON_Pin)) {
            printf("Button pressed!\r\n");
            vTaskDelay(pdMS_TO_TICKS(200)); // 去抖
        }
        vTaskDelay(pdMS_TO_TICKS(20));
    }
}

int main(void) {
    HAL_Init();
    SystemClock_Config();

    xTaskCreate(vLEDTask,    "LED",    128, NULL, 1, NULL);
    xTaskCreate(vLogTask,    "Logger", 256, NULL, 2, NULL);
    xTaskCreate(vButtonTask, "Button", 128, NULL, 3, NULL);

    vTaskStartScheduler();
    while (1);
}

const osThreadAttr_t attr = {
    .name       = "LED",
    .stack_size = 512,  // 注意：byte，不是 word
    .priority   = osPriorityNormal,
};
osThreadNew(vLEDTask, NULL, &attr);

// 空闲钩子里每 60 秒打印一次堆栈使用
void vApplicationIdleHook(void) {
    static uint32_t count = 0;
    if (++count % 60000 == 0) {
        printf("LED stack free: %lu words\r\n",
               uxTaskGetStackHighWaterMark(xLEDHandle));
    }
}

#define configCHECK_FOR_STACK_OVERFLOW 2

void vApplicationIdleHook(void) {
    // ✅ 低功耗：配合 configUSE_TICKLESS_IDLE 进入 sleep
    // ✅ 喂狗：前提是保证所有任务阻塞后 idle 能及时喂
    // ✅ 调试：打印堆栈使用量
    // ✅ 性能：递增一个计数器，vTaskGetRunTimeStats() 可以看到 idle 跑了多少时间
}