硬件接口

// GPIO寄存器结构
typedef struct {
    volatile uint32_t MODER;    // 模式寄存器
    volatile uint32_t OTYPER;   // 输出类型寄存器
    volatile uint32_t OSPEEDR;  // 输出速度寄存器
    volatile uint32_t PUPDR;    // 上拉下拉寄存器
    volatile uint32_t IDR;      // 输入数据寄存器
    volatile uint32_t ODR;      // 输出数据寄存器
    volatile uint32_t BSRR;     // 位设置/复位寄存器
} GPIO_TypeDef;

// 配置PA5为推挽输出
void GPIO_Init_PA5_Output(void) {
    // 1. 使能GPIOA时钟
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;

    // 2. 配置模式为输出(01)
    GPIOA->MODER &= ~(3U << (5 * 2));   // 清零
    GPIOA->MODER |= (1U << (5 * 2));    // 设置为01

    // 3. 配置为推挽输出
    GPIOA->OTYPER &= ~(1U << 5);

    // 4. 配置输出速度为高速
    GPIOA->OSPEEDR |= (3U << (5 * 2));

    // 5. 不使用上拉下拉
    GPIOA->PUPDR &= ~(3U << (5 * 2));
}

// 高效的IO操作
#define LED_ON()   (GPIOA->BSRR = (1U << 5))
#define LED_OFF()  (GPIOA->BSRR = (1U << (5 + 16)))
#define LED_TOGGLE() (GPIOA->ODR ^= (1U << 5))

#define KEY_PIN  0
#define KEY_PRESSED  0  // 按键按下为低电平

typedef enum {
    KEY_IDLE,
    KEY_DEBOUNCE,
    KEY_PRESSED_STATE
} KeyState;

uint8_t key_scan(void) {
    static KeyState state = KEY_IDLE;
    static uint32_t debounce_timer = 0;

    uint8_t key_val = (GPIOA->IDR >> KEY_PIN) & 1;

    switch (state) {
        case KEY_IDLE:
            if (key_val == KEY_PRESSED) {
                debounce_timer = HAL_GetTick();
                state = KEY_DEBOUNCE;
            }
            break;

        case KEY_DEBOUNCE:
            if (HAL_GetTick() - debounce_timer > 20) {  // 20ms消抖
                if (key_val == KEY_PRESSED) {
                    state = KEY_PRESSED_STATE;
                    return 1;  // 按键有效
                } else {
                    state = KEY_IDLE;
                }
            }
            break;

        case KEY_PRESSED_STATE:
            if (key_val != KEY_PRESSED) {
                state = KEY_IDLE;
            }
            break;
    }
    return 0;
}

// 波特率 = fCK / (16 * USARTDIV)
// 例: 72MHz时钟, 115200波特率
// USARTDIV = 72000000 / (16 * 115200) = 39.0625
// BRR = 39 + 0.0625*16 = 39 + 1 = 40(十进制) = 0x27

void UART1_Init(uint32_t baudrate) {
    // 1. 使能时钟
    RCC->APB2ENR |= RCC_APB2ENR_USART1EN;
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;

    // 2. 配置GPIO(PA9-TX, PA10-RX)
    GPIOA->MODER |= (2U << (9*2)) | (2U << (10*2));  // 复用功能
    GPIOA->AFR[1] |= (7U << ((9-8)*4)) | (7U << ((10-8)*4));  // AF7

    // 3. 配置波特率
    uint32_t apb2_clk = 72000000;
    USART1->BRR = apb2_clk / baudrate;

    // 4. 使能发送和接收
    USART1->CR1 = USART_CR1_TE | USART_CR1_RE | USART_CR1_UE;
}

// 发送单字节
void UART1_SendByte(uint8_t data) {
    while (!(USART1->SR & USART_SR_TXE));  // 等待发送寄存器空
    USART1->DR = data;
}

// 接收单字节
uint8_t UART1_RecvByte(void) {
    while (!(USART1->SR & USART_SR_RXNE));  // 等待接收完成
    return USART1->DR;
}

void UART_DMA_Send(const uint8_t *data, uint16_t len) {
    // 配置DMA通道
    DMA2_Stream7->CR &= ~DMA_SxCR_EN;  // 禁用DMA
    while (DMA2_Stream7->CR & DMA_SxCR_EN);  // 等待禁用完成

    DMA2_Stream7->PAR = (uint32_t)&USART1->DR;  // 外设地址
    DMA2_Stream7->M0AR = (uint32_t)data;         // 内存地址
    DMA2_Stream7->NDTR = len;                    // 传输长度

    // 配置:内存递增,外设到内存,8位数据
    DMA2_Stream7->CR = DMA_SxCR_CHSEL_2 |  // 通道4
                       DMA_SxCR_MINC |      // 内存递增
                       DMA_SxCR_DIR_0 |     // 内存到外设
                       DMA_SxCR_TCIE;       // 传输完成中断

    DMA2_Stream7->CR |= DMA_SxCR_EN;  // 使能DMA
    USART1->CR3 |= USART_CR3_DMAT;    // 使能UART DMA发送
}

void DMA2_Stream7_IRQHandler(void) {
    if (DMA2->HISR & DMA_HISR_TCIF7) {
        DMA2->HIFCR = DMA_HIFCR_CTCIF7;  // 清除中断标志
        // 传输完成处理
    }
}

void SPI1_Init(void) {
    // 使能时钟
    RCC->APB2ENR |= RCC_APB2ENR_SPI1EN;
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;

    // 配置GPIO: PA5-SCK, PA6-MISO, PA7-MOSI
    GPIOA->MODER |= (2U << 10) | (2U << 12) | (2U << 14);
    GPIOA->AFR[0] |= (5U << 20) | (5U << 24) | (5U << 28);  // AF5

    // 配置SPI
    SPI1->CR1 = SPI_CR1_MSTR |      // 主模式
                SPI_CR1_BR_2 |      // 波特率分频256
                SPI_CR1_SSM |       // 软件NSS管理
                SPI_CR1_SSI |       // 内部NSS
                SPI_CR1_SPE;        // 使能SPI
}

uint8_t SPI1_TransferByte(uint8_t data) {
    while (!(SPI1->SR & SPI_SR_TXE));  // 等待发送缓冲区空
    SPI1->DR = data;
    while (!(SPI1->SR & SPI_SR_RXNE)); // 等待接收完成
    return SPI1->DR;
}

// 读取W25Q128 Flash ID
void W25Q128_ReadID(uint8_t *id) {
    CS_LOW();  // 片选拉低
    SPI1_TransferByte(0x9F);  // JEDEC ID命令
    id[0] = SPI1_TransferByte(0xFF);  // Manufacturer ID
    id[1] = SPI1_TransferByte(0xFF);  // Device ID 1
    id[2] = SPI1_TransferByte(0xFF);  // Device ID 2
    CS_HIGH();  // 片选拉高
}

void I2C1_Init(void) {
    // 使能时钟
    RCC->APB1ENR |= RCC_APB1ENR_I2C1EN;
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOBEN;

    // 配置GPIO: PB6-SCL, PB7-SDA
    GPIOB->MODER |= (2U << 12) | (2U << 14);  // 复用功能
    GPIOB->OTYPER |= (1U << 6) | (1U << 7);   // 开漏输出
    GPIOB->PUPDR |= (1U << 12) | (1U << 14);  // 上拉
    GPIOB->AFR[0] |= (4U << 24) | (4U << 28); // AF4

    // 复位I2C
    I2C1->CR1 = I2C_CR1_SWRST;
    I2C1->CR1 = 0;

    // 配置时钟频率(36MHz)
    I2C1->CR2 = 36;

    // 配置CCR(100kHz标准模式)
    I2C1->CCR = 180;  // 36MHz / (2 * 100kHz)
    I2C1->TRISE = 37; // (1000ns / 28ns) + 1

    // 使能I2C
    I2C1->CR1 = I2C_CR1_PE;
}

// 发送起始信号
void I2C1_Start(void) {
    I2C1->CR1 |= I2C_CR1_START;
    while (!(I2C1->SR1 & I2C_SR1_SB));  // 等待起始条件完成
}

// 发送地址
void I2C1_SendAddr(uint8_t addr, uint8_t dir) {
    I2C1->DR = (addr << 1) | dir;
    while (!(I2C1->SR1 & I2C_SR1_ADDR));  // 等待地址发送完成
    (void)I2C1->SR2;  // 读SR2清除ADDR标志
}

// 写BMP280传感器寄存器
void BMP280_WriteReg(uint8_t reg, uint8_t data) {
    I2C1_Start();
    I2C1_SendAddr(0x76, 0);  // 写模式

    I2C1->DR = reg;
    while (!(I2C1->SR1 & I2C_SR1_TXE));

    I2C1->DR = data;
    while (!(I2C1->SR1 & I2C_SR1_TXE));

    I2C1->CR1 |= I2C_CR1_STOP;
}

// ADC配置示例(12位分辨率)
void ADC1_Init(void) {
    // 使能时钟
    RCC->APB2ENR |= RCC_APB2ENR_ADC1EN;
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;

    // 配置PA0为模拟输入
    GPIOA->MODER |= (3U << 0);

    // ADC配置
    ADC1->CR2 = 0;
    ADC1->CR1 = 0;  // 12位分辨率
    ADC1->SQR1 = 0;  // 1个转换
    ADC1->SQR3 = 0;  // 通道0
    ADC1->SMPR2 = 7;  // 采样时间480周期

    ADC->CCR = 0;  // 分频2
    ADC1->CR2 = ADC_CR2_ADON;  // 使能ADC
}

uint16_t ADC1_Read(void) {
    ADC1->CR2 |= ADC_CR2_SWSTART;  // 启动转换
    while (!(ADC1->SR & ADC_SR_EOC));  // 等待转换完成
    return ADC1->DR;
}

// 电压计算: V = (ADC_Value / 4095) * VREF
float ADC_ToVoltage(uint16_t adc_val) {
    return (adc_val / 4095.0f) * 3.3f;
}

// 使用定时器3通道1产生PWM(PA6)
void PWM_Init(uint16_t freq, uint16_t duty) {
    // 使能时钟
    RCC->APB1ENR |= RCC_APB1ENR_TIM3EN;
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;

    // 配置PA6为复用功能
    GPIOA->MODER |= (2U << 12);
    GPIOA->AFR[0] |= (2U << 24);  // AF2

    // 定时器配置
    TIM3->PSC = 72 - 1;  // 预分频器(1MHz)
    TIM3->ARR = 1000000 / freq - 1;  // 自动重装载值
    TIM3->CCR1 = (TIM3->ARR + 1) * duty / 100;  // 占空比

    // PWM模式1
    TIM3->CCMR1 = TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1PE;
    TIM3->CCER = TIM_CCER_CC1E;  // 使能输出
    TIM3->CR1 = TIM_CR1_ARPE | TIM_CR1_CEN;  // 使能计数器
}

// 设置占空比(0-100)
void PWM_SetDuty(uint16_t duty) {
    TIM3->CCR1 = (TIM3->ARR + 1) * duty / 100;
}

// 呼吸灯效果
void breathing_led(void) {
    static uint8_t duty = 0;
    static int8_t step = 1;

    PWM_SetDuty(duty);
    duty += step;

    if (duty >= 100 || duty <= 0) {
        step = -step;
    }
}

// 配置EXTI0中断(PA0外部中断)
void EXTI0_Config(void) {
    // 使能SYSCFG时钟
    RCC->APB2ENR |= RCC_APB2ENR_SYSCFGEN;

    // 配置PA0为中断源
    SYSCFG->EXTICR[0] = 0;  // EXTI0连接到PA

    // 配置EXTI
    EXTI->IMR |= EXTI_IMR_MR0;   // 使能中断
    EXTI->FTSR |= EXTI_FTSR_TR0; // 下降沿触发

    // 配置NVIC
    NVIC_SetPriority(EXTI0_IRQn, 2);
    NVIC_EnableIRQ(EXTI0_IRQn);
}

// 中断服务程序
void EXTI0_IRQHandler(void) {
    if (EXTI->PR & EXTI_PR_PR0) {
        EXTI->PR = EXTI_PR_PR0;  // 清除中断标志

        // 中断处理(尽量简短)
        button_pressed_flag = 1;
    }
}

// 实际波特率 = 时钟频率 / (16 * BRR)
// 误差 = |实际波特率 - 目标波特率| / 目标波特率 * 100%

// 例: 8MHz时钟,目标115200
float actual = 8000000.0 / (16 * 4);  // 125000
float error = fabs(actual - 115200) / 115200 * 100%;  // 8.5%

// 50Hz频率(20ms周期)
void Servo_Init(void) {
    PWM_Init(50, 0);  // 50Hz
}

// angle: 0-180度
void Servo_SetAngle(uint8_t angle) {
    // 0.5ms=2.5%, 2.5ms=12.5%
    uint16_t duty = 25 + angle * 75 / 180;  // 2.5-12.5%
    PWM_SetDuty(duty);
}