// 计算 PWM 周期：1/20kHz = 50us
// ARR = 定时器时钟 / PWM 频率 - 1 = 168MHz / 20kHz - 1 = 8399
#define PWM_PERIOD    8399
#define PWM_DEAD_TIME 100  // 死区时间，单位：定时器时钟周期

void TIM1_PWM_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct;
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStruct;
    TIM_OCInitTypeDef TIM_OCInitStruct;
    TIM_BDTRInitTypeDef TIM_BDTRInitStruct;
    
    // 1. 使能时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB, ENABLE);
    
    // 2. 配置 GPIO 为复用功能
    // PA8: TIM1_CH1, PA9: TIM1_CH2, PA10: TIM1_CH3
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;
    GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
    GPIO_Init(GPIOA, &GPIO_InitStruct);
    
    // PB13: TIM1_CH1N, PB14: TIM1_CH2N, PB15: TIM1_CH3N
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
    GPIO_Init(GPIOB, &GPIO_InitStruct);
    
    // 映射复用功能
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource8, GPIO_AF_TIM1);
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource9, GPIO_AF_TIM1);
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource10, GPIO_AF_TIM1);
    GPIO_PinAFConfig(GPIOB, GPIO_PinSource13, GPIO_AF_TIM1);
    GPIO_PinAFConfig(GPIOB, GPIO_PinSource14, GPIO_AF_TIM1);
    GPIO_PinAFConfig(GPIOB, GPIO_PinSource15, GPIO_AF_TIM1);
    
    // 3. 配置时基单元
    TIM_TimeBaseStruct.TIM_Prescaler = 0;  // 不分频
    TIM_TimeBaseStruct.TIM_CounterMode = TIM_CounterMode_CenterAligned1;  // 中央对齐
    TIM_TimeBaseStruct.TIM_Period = PWM_PERIOD;
    TIM_TimeBaseStruct.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_TimeBaseStruct.TIM_RepetitionCounter = 0;
    TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStruct);
    
    // 4. 配置输出比较模式为 PWM
    TIM_OCInitStruct.TIM_OCMode = TIM_OCMode_PWM1;
    TIM_OCInitStruct.TIM_OutputState = TIM_OutputState_Enable;
    TIM_OCInitStruct.TIM_OutputNState = TIM_OutputNState_Enable;  // 使能互补输出
    TIM_OCInitStruct.TIM_Pulse = 0;  // 初始占空比为 0
    TIM_OCInitStruct.TIM_OCPolarity = TIM_OCPolarity_High;
    TIM_OCInitStruct.TIM_OCNPolarity = TIM_OCNPolarity_High;
    TIM_OCInitStruct.TIM_OCIdleState = TIM_OCIdleState_Reset;
    TIM_OCInitStruct.TIM_OCNIdleState = TIM_OCNIdleState_Reset;
    
    TIM_OC1Init(TIM1, &TIM_OCInitStruct);
    TIM_OC2Init(TIM1, &TIM_OCInitStruct);
    TIM_OC3Init(TIM1, &TIM_OCInitStruct);
    
    // 使能 CCR 预装载
    TIM_OC1PreloadConfig(TIM1, TIM_OCPreload_Enable);
    TIM_OC2PreloadConfig(TIM1, TIM_OCPreload_Enable);
    TIM_OC3PreloadConfig(TIM1, TIM_OCPreload_Enable);
    
    // 5. 配置死区时间和刹车功能
    TIM_BDTRInitStruct.TIM_OSSRState = TIM_OSSRState_Enable;
    TIM_BDTRInitStruct.TIM_OSSIState = TIM_OSSIState_Enable;
    TIM_BDTRInitStruct.TIM_LOCKLevel = TIM_LOCKLevel_OFF;
    TIM_BDTRInitStruct.TIM_DeadTime = PWM_DEAD_TIME;  // 死区时间
    TIM_BDTRInitStruct.TIM_Break = TIM_Break_Disable;  // 暂时禁用刹车
    TIM_BDTRInitStruct.TIM_BreakPolarity = TIM_BreakPolarity_High;
    TIM_BDTRInitStruct.TIM_AutomaticOutput = TIM_AutomaticOutput_Enable;
    TIM_BDTRConfig(TIM1, &TIM_BDTRInitStruct);
    
    // 使能 ARR 预装载
    TIM_ARRPreloadConfig(TIM1, ENABLE);
    
    // 6. 启动定时器
    TIM_Cmd(TIM1, ENABLE);
    
    // 7. 使能主输出（高级定时器必须设置这一步！）
    TIM_CtrlPWMOutputs(TIM1, ENABLE);
}

// 设置通道 1 占空比为 50%
TIM_SetCompare1(TIM1, PWM_PERIOD / 2);

// 设置通道 2 占空比为 25%
TIM_SetCompare2(TIM1, PWM_PERIOD / 4);

// 设置通道 3 占空比为 75%
TIM_SetCompare3(TIM1, PWM_PERIOD * 3 / 4);

volatile uint32_t capture_value = 0;
volatile uint32_t frequency = 0;
volatile uint8_t capture_done = 0;

void TIM2_IC_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct;
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStruct;
    TIM_ICInitTypeDef TIM_ICInitStruct;
    NVIC_InitTypeDef NVIC_InitStruct;
    
    // 1. 使能时钟
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
    
    // 2. 配置 PA0 为复用功能（TIM2_CH1）
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;
    GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
    GPIO_Init(GPIOA, &GPIO_InitStruct);
    
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource0, GPIO_AF_TIM2);
    
    // 3. 配置时基：1MHz 计数频率
    TIM_TimeBaseStruct.TIM_Prescaler = 83;  // 84MHz / (83+1) = 1MHz
    TIM_TimeBaseStruct.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_TimeBaseStruct.TIM_Period = 0xFFFFFFFF;  // 32位自动重装载
    TIM_TimeBaseStruct.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStruct);
    
    // 4. 配置输入捕获
    TIM_ICInitStruct.TIM_Channel = TIM_Channel_1;
    TIM_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;  // 上升沿捕获
    TIM_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;
    TIM_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
    TIM_ICInitStruct.TIM_ICFilter = 0x8;  // 开启滤波
    TIM_ICInit(TIM2, &TIM_ICInitStruct);
    
    // 5. 配置中断
    NVIC_InitStruct.NVIC_IRQChannel = TIM2_IRQn;
    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStruct);
    
    // 使能捕获中断
    TIM_ITConfig(TIM2, TIM_IT_CC1, ENABLE);
    
    // 6. 启动定时器
    TIM_Cmd(TIM2, ENABLE);
}

// 中断服务函数
void TIM2_IRQHandler(void)
{
    static uint32_t last_capture = 0;
    uint32_t current_capture;
    
    if (TIM_GetITStatus(TIM2, TIM_IT_CC1) != RESET)
    {
        TIM_ClearITPendingBit(TIM2, TIM_IT_CC1);
        
        current_capture = TIM_GetCapture1(TIM2);
        
        if (last_capture != 0)
        {
            // 计算周期（注意处理计数器溢出）
            if (current_capture > last_capture)
            {
                capture_value = current_capture - last_capture;
            }
            else
            {
                capture_value = (0xFFFFFFFF - last_capture) + current_capture + 1;
            }
            
            // 计算频率：1MHz / 周期 = 频率（Hz）
            frequency = 1000000 / capture_value;
            capture_done = 1;
        }
        
        last_capture = current_capture;
    }
}

#define ENCODER_PPR  1000  // 编码器每转脉冲数

void TIM3_Encoder_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct;
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStruct;
    TIM_ICInitTypeDef TIM_ICInitStruct;
    
    // 1. 使能时钟
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
    
    // 2. 配置 PA6(TIM3_CH1) 和 PA7(TIM3_CH2)
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;
    GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
    GPIO_Init(GPIOA, &GPIO_InitStruct);
    
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource6, GPIO_AF_TIM3);
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_TIM3);
    
    // 3. 配置时基
    TIM_TimeBaseStruct.TIM_Prescaler = 0;
    TIM_TimeBaseStruct.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_TimeBaseStruct.TIM_Period = 0xFFFF;  // 16位最大值
    TIM_TimeBaseStruct.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStruct);
    
    // 4. 配置编码器接口模式（4倍频）
    TIM_EncoderInterfaceConfig(TIM3, 
                               TIM_EncoderMode_TI12,  // 两路都计数
                               TIM_ICPolarity_Rising,
                               TIM_ICPolarity_Rising);
    
    // 5. 配置输入滤波
    TIM_ICInitStruct.TIM_Channel = TIM_Channel_1;
    TIM_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;
    TIM_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;
    TIM_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
    TIM_ICInitStruct.TIM_ICFilter = 0x6;  // 滤波
    TIM_ICInit(TIM3, &TIM_ICInitStruct);
    
    TIM_ICInitStruct.TIM_Channel = TIM_Channel_2;
    TIM_ICInit(TIM3, &TIM_ICInitStruct);
    
    // 6. 启动定时器
    TIM_Cmd(TIM3, ENABLE);
    
    // 初始计数器设为中间值，防止正负溢出
    TIM_SetCounter(TIM3, 0x8000);
}

// 读取编码器位置
int32_t Encoder_GetPosition(void)
{
    static uint16_t last_counter = 0x8000;
    static int32_t position = 0;
    uint16_t current_counter;
    int16_t delta;
    
    current_counter = TIM_GetCounter(TIM3);
    delta = (int16_t)(current_counter - last_counter);
    last_counter = current_counter;
    
    position += delta;
    
    return position;
}

// 读取电机速度（单位：RPM）
float Encoder_GetSpeed(uint32_t sample_time_ms)
{
    static int32_t last_position = 0;
    int32_t current_position;
    int32_t delta_position;
    float speed_rpm;
    
    current_position = Encoder_GetPosition();
    delta_position = current_position - last_position;
    last_position = current_position;
    
    // 4倍频下，每转脉冲数 = PPR * 4
    // 转速 = (脉冲数 / (PPR * 4)) * (60000 / 采样时间)
    speed_rpm = (float)delta_position / (ENCODER_PPR * 4.0f) * 
                (60000.0f / sample_time_ms);
    
    return speed_rpm;
}

#include "stm32f4xx.h"

#define PWM_PERIOD    8399
#define PWM_MAX       8000
#define PWM_MIN       0

// 霍尔传感器状态对应的换向表
// 索引 = (HALL_C << 2) | (HALL_B << 1) | HALL_A
// 值：对应需要导通的桥臂（AH, BH, CH, AL, BL, CL）
const uint8_t commutation_table[8] = {
    0,      // 000: 无效状态
    0x09,   // 001: AH + CL
    0x12,   // 010: BH + AL
    0x11,   // 011: BH + CL
    0x24,   // 100: CH + AL
    0x21,   // 101: AH + BL
    0x22,   // 110: CH + BL
    0       // 111: 无效状态
};

volatile uint16_t pwm_duty = 0;

// 设置 PWM 输出
void Set_PWM_Output(uint8_t state)
{
    // 先关闭所有输出
    TIM_SetCompare1(TIM1, 0);
    TIM_SetCompare2(TIM1, 0);
    TIM_SetCompare3(TIM1, 0);
    
    // 根据换向表设置相应的 PWM
    switch(state)
    {
        case 0x09:  // AH + CL
            TIM_SetCompare1(TIM1, pwm_duty);  // AH PWM
            TIM_SetCompare3(TIM1, PWM_PERIOD); // CL 全开
            break;
            
        case 0x12:  // BH + AL
            TIM_SetCompare2(TIM1, pwm_duty);  // BH PWM
            TIM_SetCompare1(TIM1, PWM_PERIOD); // AL 全开
            break;
            
        case 0x11:  // BH + CL
            TIM_SetCompare2(TIM1, pwm_duty);  // BH PWM
            TIM_SetCompare3(TIM1, PWM_PERIOD); // CL 全开
            break;
            
        case 0x24:  // CH + AL
            TIM_SetCompare3(TIM1, pwm_duty);  // CH PWM
            TIM_SetCompare1(TIM1, PWM_PERIOD); // AL 全开
            break;
            
        case 0x21:  // AH + BL
            TIM_SetCompare1(TIM1, pwm_duty);  // AH PWM
            TIM_SetCompare2(TIM1, PWM_PERIOD); // BL 全开
            break;
            
        case 0x22:  // CH + BL
            TIM_SetCompare3(TIM1, pwm_duty);  // CH PWM
            TIM_SetCompare2(TIM1, PWM_PERIOD); // BL 全开
            break;
    }
}

// 读取霍尔传感器状态
uint8_t Read_Hall_Sensors(void)
{
    uint8_t hall_a = GPIO_ReadInputDataBit(GPIOC, GPIO_Pin_0);
    uint8_t hall_b = GPIO_ReadInputDataBit(GPIOC, GPIO_Pin_1);
    uint8_t hall_c = GPIO_ReadInputDataBit(GPIOC, GPIO_Pin_2);
    
    return (hall_c << 2) | (hall_b << 1) | hall_a;
}

// 换向中断服务函数
void EXTI0_IRQHandler(void)
{
    if (EXTI_GetITStatus(EXTI_Line0) != RESET ||
        EXTI_GetITStatus(EXTI_Line1) != RESET ||
        EXTI_GetITStatus(EXTI_Line2) != RESET)
    {
        EXTI_ClearITPendingBit(EXTI_Line0);
        EXTI_ClearITPendingBit(EXTI_Line1);
        EXTI_ClearITPendingBit(EXTI_Line2);
        
        // 读取霍尔状态并执行换向
        uint8_t hall_state = Read_Hall_Sensors();
        uint8_t pwm_state = commutation_table[hall_state];
        
        if (pwm_state != 0)
        {
            Set_PWM_Output(pwm_state);
        }
    }
}

// 启动电机
void Motor_Start(void)
{
    uint8_t hall_state = Read_Hall_Sensors();
    uint8_t pwm_state = commutation_table[hall_state];
    
    if (pwm_state != 0)
    {
        Set_PWM_Output(pwm_state);
    }
}

// 停止电机
void Motor_Stop(void)
{
    TIM_SetCompare1(TIM1, 0);
    TIM_SetCompare2(TIM1, 0);
    TIM_SetCompare3(TIM1, 0);
}

// 设置转速（0-100%）
void Motor_SetSpeed(uint8_t speed_percent)
{
    if (speed_percent > 100) speed_percent = 100;
    
    pwm_duty = (uint16_t)((uint32_t)speed_percent * PWM_MAX / 100);
}