uint8_t id = 0;
// 最稳的方式：等 10ms，读不到就报错
HAL_I2C_Mem_Read(&hi2c2, 0xD0, 0x75, I2C_MEMADD_SIZE_8BIT, &id, 1, 10);

uint8_t id_it = 0;
// 潇洒的方式：命令发完 CPU 直接走人，传输完了硬件会叫你
HAL_I2C_Mem_Read_IT(&hi2c2, 0xD0, 0x75, I2C_MEMADD_SIZE_8BIT, &id_it, 1);

// 你需要在回调函数里接收结果
void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef *hi2c) {
    if (hi2c->Instance == I2C2) {
        // 这时候 id_it 里的值才是 0x68
    }
}

uint8_t id_dma = 0;
// 最强悍的方式：CPU 连个招呼都不打，DMA 直接把 0x68 搬到 id_dma 的内存里
HAL_I2C_Mem_Read_DMA(&hi2c2, 0xD0, 0x75, I2C_MEMADD_SIZE_8BIT, &id_dma, 1);

// 回调函数和中断共用同一个
void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef *hi2c) {
    if (hi2c->Instance == I2C2) {
        // id_dma 已准备就绪
    }
}

uint8_t reg_addr = 0x75;
uint8_t id = 0;

// 第一步：写。发送我们要读的寄存器地址
HAL_I2C_Master_Transmit(&hi2c2, 0xD0, &reg_addr, 1, 10);
// 第二步：读。接收传感器吐回来的数据
HAL_I2C_Master_Receive(&hi2c2, 0xD0, &id, 1, 10);

uint8_t reg_addr = 0x75;
uint8_t id_it = 0;

// 启动第一步：发送寄存器地址
HAL_I2C_Master_Transmit_IT(&hi2c2, 0xD0, &reg_addr, 1);

// 你需要处理两个回调：
void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c) {
    if (hi2c->Instance == I2C2) {
        // 第一步发完了，赶紧启动第二步：接收数据
        HAL_I2C_Master_Receive_IT(hi2c, 0xD0, &id_it, 1);
    }
}

void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c) {
    if (hi2c->Instance == I2C2) {
        // 这时候 id_it 终于拿到值了 (0x68)
    }
}

uint8_t reg_addr = 0x75;
uint8_t id_dma = 0;

// 启动第一步：DMA 发送
HAL_I2C_Master_Transmit_DMA(&hi2c2, 0xD0, &reg_addr, 1);

// 回调函数处理（代码与 IT 模式几乎一致，只需把启动函数换成 _DMA 后缀）
void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c) {
    if (hi2c->Instance == I2C2) {
        HAL_I2C_Master_Receive_DMA(hi2c, 0xD0, &id_dma, 1);
    }
}

// 1. 发起写地址任务
HAL_I2C_Master_Transmit_IT(&hi2c2, 0xD0, &reg, 1);

// 2. 你必须写两个回调函数来衔接
void HAL_I2C_MasterTxCpltCallback(...) {
    // 第一次中断：地址发完了，现在赶紧手动启动读任务
    HAL_I2C_Master_Receive_IT(...); 
}
void HAL_I2C_MasterRxCpltCallback(...) {
    // 第二次中断：数据终于读完了，可以处理数据了
}

// 1. 发起读寄存器任务
HAL_I2C_Mem_Read_IT(&hi2c2, 0xD0, 0x75, 1, &data, 1);

// 2. 你只需要一个回调函数
void HAL_I2C_MemRxCpltCallback(...) {
    // 唯一的一次中断：整个“发地址+读数据”的过程全完了，直接拿数据
}

void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef *hi2c) {
    if (hi2c->Instance == I2C1) {
        // OLED 那边的回调
    } else if (hi2c->Instance == I2C2) {
        // MPU6050 那边的回调
    }
}

uint8_t tx_data = 0x9F; // 读取 ID 指令
uint8_t rx_data[3];

// 1. 拉低片选 (开始通讯)
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET);

// 2. 发送指令
HAL_SPI_Transmit(&hspi1, &tx_data, 1, 10);
// 3. 接收数据
HAL_SPI_Receive(&hspi1, rx_data, 3, 10);

// 4. 拉高片选 (结束通讯)
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);

// 发起异步传输
HAL_SPI_TransmitReceive_IT(&hspi1, tx_buf, rx_buf, 10);

// 回调函数
void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi) {
    if (hspi->Instance == SPI1) {
        // 传输完成，拉高 CS 引脚
        HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);
    }
}

// 发起 DMA 传输
HAL_SPI_Transmit_DMA(&hspi1, long_buffer, 1024);

// 回调函数
void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi) {
    // 逻辑同上
}

// 发送（阻塞，发完才返回）
char msg[] = "Hello";
HAL_UART_Transmit(&huart1, (uint8_t *)msg, 5, 100);

// 接收（阻塞，收满指定字节数才返回）
uint8_t buf[10];
HAL_UART_Receive(&huart2, buf, 10, 100);  // 等 10 个字节，超时 100ms

static uint8_t rx_byte;  // 必须 static！

// 启动接收（只收 1 个字节，收完自动停）
HAL_UART_Receive_IT(&huart2, &rx_byte, 1);

// 回调函数
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
    if (huart->Instance == USART2) {
        // rx_byte 里有数据了
        ringbuffer_write(&ring, &rx_byte, 1);  // 存到缓冲区

        // 重新装弹！不装的话后面的数据就丢了
        HAL_UART_Receive_IT(&huart2, &rx_byte, 1);
    }
}

#define DMA_BUF_SIZE 128
#define RING_BUF_SIZE 256

static uint8_t dma_rx_buf[DMA_BUF_SIZE];  // DMA 写入的缓冲区（必须 static）
static uint8_t ring_mem[RING_BUF_SIZE];
static ringbuffer_st rx_ring;

extern DMA_HandleTypeDef hdma_usart1_rx;

// 启动
void APP_UART_Init(void)
{
    ringbuffer_init(&rx_ring, ring_mem, RING_BUF_SIZE);

    HAL_UARTEx_ReceiveToIdle_DMA(&huart1, dma_rx_buf, DMA_BUF_SIZE);

    // 关闭半传输中断（只要完整帧，不要半帧通知）
    __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT);
}

// 回调
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
{
    if (huart->Instance == USART1)
    {
        // Size = 本次实际收到的字节数
        ringbuffer_write(&rx_ring, dma_rx_buf, Size);

        // 重新装弹
        HAL_UARTEx_ReceiveToIdle_DMA(&huart1, dma_rx_buf, DMA_BUF_SIZE);
        __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT);
    }
}

// 发送（立即返回，DMA 后台搬运）
char msg[] = "data";
HAL_UART_Transmit_DMA(&huart1, (uint8_t *)msg, 4);

// 注意：DMA 还在发的时候，不能修改 msg 的内容！
// 如果连续发，要等上一次完成
while (huart1.gState != HAL_UART_STATE_READY);  // 等 DMA 空闲
// 现在可以写新的数据了

void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size) {
    if (huart->Instance == USART1) {
        // 调试口
    } else if (huart->Instance == USART2) {
        // 蓝牙
    }
}