// 全局的I2C句柄和互斥量
I2C_HandleTypeDef hi2c1;
SemaphoreHandle_t i2c_mutex;

// ADC读取函数
void read_adc(uint16_t *val) {
    xSemaphoreTake(i2c_mutex, portMAX_DELAY);
    HAL_I2C_Mem_Read(&hi2c1, 0x48, 0x00, I2C_MEMADD_SIZE_8BIT, (uint8_t*)val, 2, 100);
    xSemaphoreGive(i2c_mutex);
}

// DAC写入函数
void set_dac(uint16_t val) {
    uint8_t buf[2] = {val >> 8, val & 0xFF};
    xSemaphoreTake(i2c_mutex, portMAX_DELAY);
    HAL_I2C_Mem_Write(&hi2c1, 0x60, 0x00, I2C_MEMADD_SIZE_8BIT, buf, 2, 100);
    xSemaphoreGive(i2c_mutex);
}

// 切档函数
void switch_channel(uint8_t ch) {
    xSemaphoreTake(i2c_mutex, portMAX_DELAY);
    HAL_I2C_Mem_Write(&hi2c1, 0x70, 0x01, I2C_MEMADD_SIZE_8BIT, &ch, 1, 100);
    xSemaphoreGive(i2c_mutex);
}

// 联动功能：切换档位并读取ADC
void change_and_read(uint8_t ch, uint16_t *out) {
    switch_channel(ch);
    HAL_Delay(1);   // 等待信号稳定
    read_adc(out);
}

use core::cell::RefCell;
use embedded_hal_bus::i2c::RefCellDevice;

// 第1步：初始化I2C外设，并放入 RefCell
let i2c = I2c1::new(/* ... */);
let i2c_refcell = RefCell::new(i2c);  // 把钥匙锁进盒子

// 第2步：为每个设备创建"代理"（Proxy）——相当于给每个人发一张门禁卡
let adc_proxy = RefCellDevice::new(&i2c_refcell);
let dac_proxy = RefCellDevice::new(&i2c_refcell);
let switch_proxy = RefCellDevice::new(&i2c_refcell);

// 第3步：把代理传给驱动（驱动只认 I2c trait，不关心它是不是代理）
let mut adc = AdcDriver::<_, 0x48>::new(adc_proxy);
let mut dac = DacDriver::<_, 0x60>::new(dac_proxy);
let mut switch = SwitchDriver::<_, 0x70>::new(switch_proxy);

use embassy_sync::mutex::Mutex;
use embassy_sync::blocking_mutex::raw::NoopRawMutex; // 或 CriticalSectionRawMutex
use embassy_embedded_hal::shared_bus::asynch::i2c::I2cDevice;
use static_cell::StaticCell;

// 第1步：创建静态的 Mutex 容器（生命周期 'static）
static I2C_BUS: StaticCell<Mutex<NoopRawMutex, I2c<'static, ...>>> = StaticCell::new();
let i2c = I2c::new(/* ... */);
let i2c_mutex = I2C_BUS.init(Mutex::new(i2c));

// 第2步：为每个设备生成带锁的代理
let adc_bus = I2cDevice::new(i2c_mutex);
let dac_bus = I2cDevice::new(i2c_mutex);
let switch_bus = I2cDevice::new(i2c_mutex);

// 第3步：传给驱动（用法和方案A完全一样！）
let mut adc = AdcDriver::new(adc_bus);
let mut dac = DacDriver::new(dac_bus);
let mut switch = SwitchDriver::new(switch_bus);

// 驱动层：不包含任何锁逻辑，只操作 I2c trait
impl<I2C, const ADDR: u8> AdcDriver<I2C, ADDR>
where
    I2C: embedded_hal_async::i2c::I2c,  // 使用异步trait
{
    pub async fn read(&mut self) -> Result<u16, Error> {
        let mut buf = [0u8; 2];
        self.i2c.write_read(ADDR, &[0x00], &mut buf).await?;
        Ok(u16::from_be_bytes(buf))
    }
}

// 应用层：统一加锁，保证原子性
struct MyApp<'a> {
    adc: AdcDriver<I2cDevice<'a, ...>, 0x48>,
    dac: DacDriver<I2cDevice<'a, ...>, 0x60>,
    switch: SwitchDriver<I2cDevice<'a, ...>, 0x70>,
    // 注意：这里不直接持有总线锁，而是通过驱动内部代理获得
}

impl<'a> MyApp<'a> {
    pub async fn change_and_read(&mut self, ch: u8) -> Result<u16, Error> {
        // 注意：每个驱动内部的代理已经封装了 Mutex，但它们是独立加锁的
        // 如果我们想保证"切档+延时+读ADC"的原子性，需要在更上层加锁
        // 方式1：让驱动提供"使用已锁总线"的方法（高级用法，略）
        // 方式2：将联动逻辑放在一个单独的任务中，通过Channel串行化（推荐）
        // 方式3：在应用层显式获取一个总线锁（假设驱动提供了 get_bus() 方法）
        
        // 这里展示最常用的方式：单独创建一个"协调任务"，通过消息传递串行化
        // 具体实现见下方的"完整代码骨架"
        unimplemented!()
    }
}

use embassy_executor::Spawner;
use embassy_time::Timer;

// ---------- 1. 定义应用结构体 ----------
struct MyApp {
    adc: AdcDriver<...>,
    dac: DacDriver<...>,
    switch: SwitchDriver<...>,
}

impl MyApp {
    // 联动函数：切档并读取ADC（注意原子性）
    pub async fn change_and_read(&mut self, ch: u8) -> Result<u16, Error> {
        // 直接调用驱动方法——如果驱动内部使用 I2cDevice（自带Mutex），
        // 那么每次调用都会独立加锁/解锁。
        // 如果担心两个操作之间被其他任务插入，可以改用 Channel 串行化。
        self.switch.set_channel(ch).await?;
        Timer::after_millis(1).await;   // 等待信号稳定
        self.adc.read().await
    }
    
    pub async fn set_dac(&mut self, val: u16) -> Result<(), Error> {
        self.dac.write(val).await
    }
}

// ---------- 2. 主函数 ----------
#[embassy_executor::main]
async fn main(spawner: Spawner) {
    // 初始化硬件 (I2C, GPIO等)
    let p = embassy_stm32::init(/* ... */);
    let i2c = I2c::new(p.I2C1, p.PB6, p.PB7, 100.kHz(), Default::default());
    
    // 创建共享总线（使用方案B的 Mutex）
    let i2c_mutex = /* 参考第六节 */;
    
    // 为每个设备生成代理
    let adc_bus = I2cDevice::new(&i2c_mutex);
    let dac_bus = I2cDevice::new(&i2c_mutex);
    let switch_bus = I2cDevice::new(&i2c_mutex);
    
    // 实例化驱动
    let adc = AdcDriver::new(adc_bus);
    let dac = DacDriver::new(dac_bus);
    let switch = SwitchDriver::new(switch_bus);
    
    // 构建应用层协调结构体
    let app = MyApp { adc, dac, switch };
    
    // 启动主任务（把 app 传进去）
    spawner.spawn(app_task(app)).unwrap();
}

// ---------- 3. 主任务 ----------
#[embassy_executor::task]
async fn app_task(mut app: MyApp) {
    loop {
        // 每隔1秒切一次档并读取ADC
        let value = app.change_and_read(2).await.unwrap();
        log::info!("ADC value after switch: {}", value);
        
        // 同时DAC也在独立更新
        app.set_dac(2048).await.unwrap();
        
        Timer::after_secs(1).await;
    }
}