/* 注意：这是 CubeMX 生成的代码，存在优化空间 */
static void MX_TIM3_Init(void)
{
  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_OC_InitTypeDef sConfigOC = {0};

  htim3.Instance = TIM3;
  htim3.Init.Prescaler = 83;
  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim3.Init.Period = 999;
  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_Init(&htim3) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 500;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  HAL_TIM_MspPostInit(&htim3);
}

htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;

sConfigOC.OCPreload = TIM_OC_PRELOAD_ENABLE;  // 加上这一行！

HAL_TIM_Base_Start(&htim3);       // 先启动定时器基准
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);  // 再启动 PWM 通道

// 不好的写法：每层 HAL 调用都有开销
__HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, new_duty);

// 高效写法：直接操作寄存器
TIM3->CCR1 = new_duty;

// 必须做边界检查，否则会出现异常波形
uint32_t set_pwm_duty(TIM_HandleTypeDef *htim, uint32_t channel, uint32_t duty)
{
    uint32_t arr = htim->Instance->ARR;
    
    // 边界检查：占空比不能超过周期值
    if (duty > arr) {
        duty = arr;
    }
    
    switch (channel) {
        case TIM_CHANNEL_1: htim->Instance->CCR1 = duty; break;
        case TIM_CHANNEL_2: htim->Instance->CCR2 = duty; break;
        case TIM_CHANNEL_3: htim->Instance->CCR3 = duty; break;
        case TIM_CHANNEL_4: htim->Instance->CCR4 = duty; break;
        default: return HAL_ERROR;
    }
    
    return HAL_OK;
}

/* 输入捕获状态结构体 */
typedef struct {
    uint32_t capture_start;    /* 第一次捕获值 */
    uint32_t capture_end;      /* 第二次捕获值 */
    uint32_t period;           /* 周期计数值 */
    uint32_t high_time;        /* 高电平时间 */
    uint8_t  capture_done;     /* 捕获完成标志 */
    uint8_t  edge_state;       /* 边沿状态：0-等待上升沿，1-等待下降沿 */
} Capture_HandleTypeDef;

Capture_HandleTypeDef cap_handle = {0};

/**
 * @brief  输入捕获中断回调函数
 * @note   这个函数在 HAL_TIM_IRQHandler 中被调用
 */
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM2) {
        if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1) {
            uint32_t capture_val = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);
            
            if (cap_handle.edge_state == 0) {
                /* 上升沿：记录起始时间 */
                cap_handle.capture_start = capture_val;
                cap_handle.edge_state = 1;
                
                /* 切换为下降沿捕获 */
                __HAL_TIM_SET_CAPTUREPOLARITY(htim, TIM_CHANNEL_1, 
                    TIM_INPUTCHANNELPOLARITY_FALLING);
            } else {
                /* 下降沿：计算高电平时间 */
                if (capture_val >= cap_handle.capture_start) {
                    cap_handle.high_time = capture_val - cap_handle.capture_start;
                } else {
                    /* 处理计数器溢出 */
                    cap_handle.high_time = (0xFFFFFFFF - cap_handle.capture_start) 
                        + capture_val + 1;
                }
                
                /* 切换为上升沿捕获，等待下一个周期 */
                cap_handle.edge_state = 0;
                cap_handle.capture_done = 1;
                cap_handle.period = cap_handle.high_time;
                
                __HAL_TIM_SET_CAPTUREPOLARITY(htim, TIM_CHANNEL_1, 
                    TIM_INPUTCHANNELPOLARITY_RISING);
            }
        }
    }
}

/**
 * @brief  获取测量的频率和占空比
 * @retval HAL status
 */
HAL_StatusTypeDef capture_get_measurement(float *frequency, float *duty_cycle)
{
    if (cap_handle.capture_done == 0) {
        return HAL_BUSY;
    }
    
    /* 禁止中断，保证数据一致性 */
    __disable_irq();
    uint32_t period = cap_handle.period;
    uint32_t high_time = cap_handle.high_time;
    cap_handle.capture_done = 0;
    __enable_irq();
    
    if (period == 0) {
        return HAL_ERROR;
    }
    
    /* 计算频率：TIM2 时钟 84MHz，PSC = 83 → 计数周期 1us */
    *frequency = 1000000.0f / period;
    
    /* 计算占空比 */
    *duty_cycle = (float)high_time / period * 100.0f;
    
    return HAL_OK;
}

/**
 * @brief  初始化输入捕获
 */
void capture_init(void)
{
    /* 配置 TIM2 为输入捕获模式 */
    htim2.Instance = TIM2;
    htim2.Init.Prescaler = 83;        /* 84MHz / 84 = 1MHz → 1us 计数 */
    htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim2.Init.Period = 0xFFFFFFFF;   /* 32位最大周期 */
    htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    HAL_TIM_IC_Init(&htim2);
    
    /* 配置通道 1 */
    TIM_IC_InitTypeDef sConfigIC = {0};
    sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
    sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
    sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
    sConfigIC.ICFilter = 8;           /* 8 次采样滤波，消除抖动 */
    HAL_TIM_IC_ConfigChannel(&htim2, &sConfigIC, TIM_CHANNEL_1);
    
    /* 启动捕获，使能中断 */
    HAL_TIM_IC_Start_IT(&htim2, TIM_CHANNEL_1);
    
    /* 初始化状态 */
    cap_handle.edge_state = 0;
    cap_handle.capture_done = 0;
}

/**
 * @brief  定时器编码器模式初始化
 * @param  htim: 定时器句柄
 * @param  max_count: 最大计数值（通常是编码器线数×4）
 * @retval HAL status
 */
HAL_StatusTypeDef encoder_init(TIM_HandleTypeDef *htim, uint32_t max_count)
{
    TIM_Encoder_InitTypeDef sConfig = {0};
    TIM_MasterConfigTypeDef sMasterConfig = {0};
    
    /* 1. 配置定时器基本参数 */
    htim->Init.Prescaler = 0;                    /* 不分频，最高分辨率 */
    htim->Init.CounterMode = TIM_COUNTERMODE_UP;
    htim->Init.Period = max_count - 1;           /* 自动重装载值 */
    htim->Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    htim->Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
    
    /* 2. 配置编码器接口 */
    sConfig.EncoderMode = TIM_ENCODERMODE_TI12;  /* 模式 3：4 倍频 */
    sConfig.IC1Polarity = TIM_ICPOLARITY_RISING; /* TI1 上升沿触发 */
    sConfig.IC1Selection = TIM_ICSELECTION_DIRECTTI;
    sConfig.IC1Prescaler = TIM_ICPSC_DIV1;       /* 不分频 */
    sConfig.IC1Filter = 10;                      /* 输入滤波，消除机械抖动 */
    sConfig.IC2Polarity = TIM_ICPOLARITY_RISING; /* TI2 上升沿触发 */
    sConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI;
    sConfig.IC2Prescaler = TIM_ICPSC_DIV1;
    sConfig.IC2Filter = 10;
    
    if (HAL_TIM_Encoder_Init(htim, &sConfig) != HAL_OK) {
        return HAL_ERROR;
    }
    
    /* 3. 配置主从模式 */
    sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    HAL_TIMEx_MasterConfigSynchronization(htim, &sMasterConfig);
    
    /* 4. 启动编码器接口 */
    HAL_TIM_Encoder_Start(htim, TIM_CHANNEL_ALL);
    
    /* 5. 计数器清零，从零开始 */
    htim->Instance->CNT = 0;
    
    return HAL_OK;
}

int32_t position = (int32_t)htim2.Instance->CNT;

/* 配置 Z 相为外部中断，上升沿触发 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    if (GPIO_Pin == ENCODER_Z_Pin) {
        /* Z 相信号到来，计数器归零 */
        htim2.Instance->CNT = 0;
    }
}

/* 每 10ms 调用一次 */
float encoder_get_speed(void)
{
    static int32_t last_cnt = 0;
    int32_t current_cnt = (int32_t)htim2.Instance->CNT;
    int32_t delta = current_cnt - last_cnt;
    last_cnt = current_cnt;
    
    /* delta / 4000 圈 / 0.01 秒 = 转/秒 */
    /* 转/秒 × 60 = RPM（转/分钟） */
    return (float)delta / 4000.0f / 0.01f * 60.0f;
}

/* 在更新中断里处理溢出 */
int32_t total_count = 0;

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM2) {
        if (__HAL_TIM_IS_TIM_COUNTING_DOWN(htim)) {
            /* 下溢 */
            total_count -= 65536;
        } else {
            /* 上溢 */
            total_count += 65536;
        }
    }
}

/* 读取绝对位置 */
int32_t encoder_get_absolute_position(void)
{
    return total_count + (int32_t)htim2.Instance->CNT;
}

#define FILTER_SIZE 5
int32_t position_buffer[FILTER_SIZE] = {0};
uint8_t buffer_index = 0;

int32_t encoder_get_filtered_position(void)
{
    position_buffer[buffer_index] = (int32_t)htim2.Instance->CNT;
    buffer_index = (buffer_index + 1) % FILTER_SIZE;
    
    /* 取中位数而不是平均值，抗跳变能力更强 */
    int32_t sorted[FILTER_SIZE];
    memcpy(sorted, position_buffer, sizeof(sorted));
    
    /* 简单冒泡排序，数据量小无所谓 */
    for (int i = 0; i < FILTER_SIZE - 1; i++) {
        for (int j = 0; j < FILTER_SIZE - i - 1; j++) {
            if (sorted[j] > sorted[j + 1]) {
                int32_t temp = sorted[j];
                sorted[j] = sorted[j + 1];
                sorted[j + 1] = temp;
            }
        }
    }
    
    return sorted[FILTER_SIZE / 2];
}

/**
 * @brief  单脉冲模式初始化
 * @param  pulse_width_us: 脉冲宽度（微秒）
 * @retval HAL status
 */
HAL_StatusTypeDef one_pulse_init(uint32_t pulse_width_us)
{
    TIM_OnePulse_InitTypeDef sConfig = {0};
    TIM_OC_InitTypeDef sConfigOC = {0};
    
    /* 定时器时钟 84MHz，PSC = 83 → 1us 计数 */
    htim3.Instance = TIM3;
    htim3.Init.Prescaler = 83;
    htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim3.Init.Period = pulse_width_us * 2;  /* 周期是脉冲宽度的两倍 */
    htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    HAL_TIM_Base_Init(&htim3);
    
    /* 配置单脉冲模式 */
    sConfig.OCMode = TIM_OCMODE_PWM1;
    sConfig.Pulse = pulse_width_us;           /* CCR 值决定脉冲宽度 */
    sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
    sConfig.ICFilter = 0;
    sConfig.ICPolarity = TIM_ICPOLARITY_RISING;
    sConfig.ICSelection = TIM_ICSELECTION_DIRECTTI;
    sConfig.ICPrescaler = TIM_ICPSC_DIV1;
    
    if (HAL_TIM_OnePulse_Init(&htim3, &sConfig) != HAL_OK) {
        return HAL_ERROR;
    }
    
    return HAL_OK;
}

/**
 * @brief  启动单脉冲输出
 */
void one_pulse_start(void)
{
    HAL_TIM_OnePulse_Start(&htim3, TIM_CHANNEL_1);
}

/* 不要这样写 */
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
__HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, duty);
HAL_TIM_IRQHandler(&htim3);

/* 应该这样写 */
TIM3->CR1 |= TIM_CR1_CEN;          /* 启动定时器 */
TIM3->CCR1 = duty;                 /* 修改占空比 */
TIM3->SR = ~TIM_FLAG_CC1IF;        /* 清中断标志 */

/**
 * @brief  TIM3 中断服务函数（优化版本）
 * @note   直接在这里处理，不经过 HAL 回调
 */
void TIM3_IRQHandler(void)
{
    /* 检查更新中断标志 */
    if (TIM3->SR & TIM_SR_UIF) {
        /* 立即清除标志 */
        TIM3->SR = ~TIM_SR_UIF;
        
        /* 在这里直接处理你的代码 */
        control_loop();
    }
    
    /* 其他中断标志处理... */
}

/* LL 库启动定时器 */
LL_TIM_EnableCounter(TIM3);

/* LL 库修改占空比 */
LL_TIM_OC_SetCompareCH1(TIM3, duty);

/* LL 库清中断 */
LL_TIM_ClearFlag_UPDATE(TIM3);

/* 推荐的中断优先级配置 */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);

/* 输入捕获：最高优先级 */
HAL_NVIC_SetPriority(TIM2_IRQn, 1, 0);

/* 编码器：次高优先级 */
HAL_NVIC_SetPriority(TIM3_IRQn, 2, 0);

/* PWM 输出：中等优先级 */
HAL_NVIC_SetPriority(TIM1_IRQn, 5, 0);

/* 普通定时：低优先级 */
HAL_NVIC_SetPriority(TIM6_DAC_IRQn, 10, 0);

/* SysTick：必须是最低优先级 */
HAL_NVIC_SetPriority(SysTick_IRQn, 15, 0);