// C：带状态机的超级循环（处理耗时任务）
typedef enum {
    REPORT_IDLE,
    REPORT_CONNECTING,
    REPORT_SENDING,
    REPORT_WAIT_ACK,
} ReportState;

static ReportState report_state = REPORT_IDLE;
static uint32_t report_timer = 0;

void task_report_data(void) {
    switch (report_state) {
        case REPORT_IDLE:
            if (millis() - report_timer > 5000) {
                wifi_start_connect();
                report_state = REPORT_CONNECTING;
            }
            break;

        case REPORT_CONNECTING:
            if (wifi_is_connected()) {
                wifi_send(data, len);
                report_state = REPORT_SENDING;
            } else if (millis() - report_timer > 3000) {
                report_state = REPORT_IDLE;  // 超时，放弃
            }
            break;

        case REPORT_SENDING:
            if (wifi_send_done()) {
                report_state = REPORT_WAIT_ACK;
            }
            break;

        case REPORT_WAIT_ACK:
            if (wifi_ack_received()) {
                report_timer = millis();
                report_state = REPORT_IDLE;  // 完成，回到空闲
            } else if (millis() - report_timer > 2000) {
                report_state = REPORT_IDLE;  // 超时
            }
            break;
    }
}

// C：中断驱动
volatile uint8_t uart_rx_buf[256];
volatile uint16_t uart_rx_head = 0;
volatile uint16_t uart_rx_tail = 0;

// UART 接收中断
void USART2_IRQHandler(void) {
    if (USART2->SR & USART_SR_RXNE) {
        uart_rx_buf[uart_rx_head] = USART2->DR;
        uart_rx_head = (uart_rx_head + 1) % 256;
    }
}

// 定时器中断（1ms 周期）
void TIM2_IRQHandler(void) {
    system_tick++;
    TIM2->SR &= ~TIM_SR_UIF;  // 清除中断标志
}

int main(void) {
    system_init();
    enable_interrupts();

    while (1) {
        // 主循环只处理"需要时间"的任务
        if (uart_rx_head != uart_rx_tail) {
            process_command(uart_rx_buf[uart_rx_tail]);
            uart_rx_tail = (uart_rx_tail + 1) % 256;
        }

        if (system_tick % 1000 == 0) {
            read_sensor();
        }
    }
}

// C：FreeRTOS 示例
void sensor_task(void *params) {
    while (1) {
        int16_t temp = read_temperature();
        int16_t hum = read_humidity();

        // 通过队列发送数据给显示任务
        SensorData data = { .temp = temp, .hum = hum };
        xQueueSend(sensor_queue, &data, portMAX_DELAY);

        vTaskDelay(pdMS_TO_TICKS(1000));  // 等待 1 秒
    }
}

void display_task(void *params) {
    SensorData data;
    while (1) {
        // 阻塞等待数据（不消耗 CPU）
        if (xQueueReceive(sensor_queue, &data, portMAX_DELAY) == pdTRUE) {
            oled_clear();
            oled_printf("Temp: %d.%d C", data.temp / 10, data.temp % 10);
            oled_printf("Hum:  %d.%d %%", data.hum / 10, data.hum % 10);
            oled_flush();
        }
    }
}

void uart_task(void *params) {
    uint8_t byte;
    while (1) {
        // 阻塞等待 UART 数据
        if (xQueueReceive(uart_queue, &byte, portMAX_DELAY) == pdTRUE) {
            process_command(byte);
        }
    }
}

int main(void) {
    system_init();

    sensor_queue = xQueueCreate(4, sizeof(SensorData));
    uart_queue = xQueueCreate(64, sizeof(uint8_t));

    xTaskCreate(sensor_task, "sensor", 256, NULL, 2, NULL);
    xTaskCreate(display_task, "display", 512, NULL, 1, NULL);
    xTaskCreate(uart_task, "uart", 256, NULL, 3, NULL);

    vTaskStartScheduler();  // 启动调度器，不再返回

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

// 一次典型的 Cortex-M4 上下文切换（FreeRTOS 的 PendSV_Handler）
void PendSV_Handler(void) {
    // 1. 保存当前任务的寄存器（R4-R11, LR）到当前任务的栈
    //    ~8 条 STR 指令，~8 个时钟周期

    // 2. 更新当前任务指针
    //    ~2 条指令

    // 3. 从新任务的栈恢复寄存器
    //    ~8 条 LDR 指令，~8 个时钟周期

    // 4. 返回（BX LR，触发异常返回）
    //    ~1 条指令

    // 总计：~20 条指令，~20-40 个时钟周期（取决于 Flash 等待周期）
    // 在 168MHz 的 STM32F4 上：~120-240 ns
}

// 协作式调度的本质：每个任务是一个状态机
// 调度器轮流"推进"每个状态机一步

typedef struct {
    uint8_t state;
    uint32_t timer;
    uint8_t data;
} TaskState;

TaskState task_a = { .state = 0 };
TaskState task_b = { .state = 0 };

// 调度器：轮流执行每个任务的一步
void scheduler_tick(void) {
    task_a_step(&task_a);  // 推进任务 A 一步
    task_b_step(&task_b);  // 推进任务 B 一步
}

void task_a_step(TaskState *t) {
    switch (t->state) {
        case 0:  // 初始化
            start_sensor_read();
            t->state = 1;
            break;  // ← 这就是"yield"：执行完一步就返回

        case 1:  // 等待传感器
            if (sensor_done()) {
                t->data = read_sensor();
                t->state = 2;
            }
            // 如果没完成，什么都不做，直接返回（让出 CPU）
            break;

        case 2:  // 处理数据
            process(t->data);
            t->timer = millis();
            t->state = 0;  // 回到初始状态，等待下一轮
            break;
    }
}

// C：经典的竞态条件
volatile uint32_t shared_counter = 0;

// 主循环中
void main_loop(void) {
    while (1) {
        // 步骤 1：读取 counter（假设此时 counter = 42）
        uint32_t temp = shared_counter;

        // ⚡ 此时中断发生！
        // 中断中：shared_counter++ → counter 变为 43

        // 步骤 2：加 1 并写回（temp = 42，写回 43）
        shared_counter = temp + 1;

        // 💥 结果：counter = 43，但应该是 44！
        // 中断中的 +1 被"丢失"了
    }
}

// 中断中
void TIM2_IRQHandler(void) {
    shared_counter++;  // 这个 +1 可能被主循环覆盖
}

// Rust：临界区（自动管理，不会忘记恢复）
use critical_section::Mutex;
use core::cell::RefCell;

static SHARED: Mutex> = Mutex::new(RefCell::new(0));

// 在中断中
#[interrupt]
fn TIM2() {
    critical_section::with(|cs| {
        *SHARED.borrow(cs).borrow_mut() += 1;
    });
    // 离开 with 块时，中断自动恢复——不可能忘记
}

// 在主循环中
fn main_loop() {
    let value = critical_section::with(|cs| {
        *SHARED.borrow(cs).borrow()
    });
}

┌─────────────────────────────────────────────────────────┐
│                    中断发生时的硬件动作                    │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  1. 完成当前指令                                        │
│  2. 将 xPSR、PC、LR、R12、R3-R0 压入栈（8 个寄存器）    │
│  3. 从向量表中读取 ISR 地址                              │
│     向量表地址 = 0x00000000（或 SCB->VTOR 配置）         │
│     ISR 地址 = *(向量表基址 + 中断号 × 4)               │
│  4. 将 PC 设置为 ISR 地址，开始执行                      │
│                                                         │
│  硬件自动完成，无需软件干预：~12 个时钟周期              │
│                                                         │
├─────────────────────────────────────────────────────────┤
│                    中断返回时的硬件动作                    │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  1. 执行 BX LR（LR 中包含特殊的 EXC_RETURN 值）         │
│  2. 硬件自动从栈恢复 8 个寄存器                         │
│  3. 继续执行被中断的代码                                │
│                                                         │
│  硬件自动完成：~12 个时钟周期                            │
│                                                         │
└─────────────────────────────────────────────────────────┘

// ✅ 好的 ISR：极短，只做记录
volatile uint8_t rx_byte;
volatile bool rx_ready = false;

void USART2_IRQHandler(void) {
    rx_byte = USART2->DR;   // 读取数据（清除中断标志）
    rx_ready = true;         // 设置标志
}

// 主循环中处理
while (1) {
    if (rx_ready) {
        rx_ready = false;
        process_byte(rx_byte);  // 实际处理在主循环中
    }
}

┌─────────────────────────────────────────────────────────────┐
│                    嵌入式并发知识图谱                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  并发 vs 并行                                               │
│  ├── 并发：逻辑上交替（单核 MCU 的常态）                     │
│  └── 并行：物理上同时（多核 MCU）                            │
│                                                             │
│  三种经典做法                                                │
│  ├── 超级循环：简单，但响应性差                              │
│  ├── 中断驱动：响应性好，但逻辑碎片化                        │
│  └── RTOS：功能全，但资源开销大                              │
│                                                             │
│  两种调度模型                                                │
│  ├── 抢占式：调度器强制切换（RTOS）                          │
│  │   └── 优点：响应性好 / 缺点：上下文切换开销               │
│  └── 协作式：任务主动让出（状态机 / Embassy）                │
│      └── 优点：零开销 / 缺点：饿死风险                      │
│                                                             │
│  并发安全                                                    │
│  ├── 竞态条件：共享数据 + 并发访问 + 非原子操作              │
│  ├── 临界区：关中断保护（简单但影响实时性）                  │
│  └── 原子操作：硬件保证（轻量但只适用于单字）                │
│                                                             │
│  中断                                                        │
│  ├── 本质：硬件触发的函数调用                                │
│  ├── 优先级：数值越小越高，支持嵌套                          │
│  └── 限制：不能阻塞、不能分配、要尽可能短                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘