controller-hd/User/application/src/pdctrl.c

#include "pdctrl.h"
#include "main.h"
#include "entity.h"

static pdctrl_t pdctrl_data;

__IO static pdctrl_mode_e out_mode = PDCTRL_DAC;
__IO static BOOL pdctrl_run_flag = FALSE;

static void dac_dinit(void)
{
    DAC_STOP(DAC, PDCTRL_DAC_CHINNEL); // DAC通道禁用
    GPIO_SET_ANALOG(PDCTRL_DAC_GPIO_Port, PDCTRL_DAC_Pin);
}

static void dac_init(void)
{
    pdctrl_data.last_out = 0xffff;

    GPIO_SET_ANALOG(PDCTRL_DAC_GPIO_Port, PDCTRL_DAC_Pin);
    DAC_START(DAC, PDCTRL_DAC_CHINNEL); // DAC通道使能
}

static void pwm_dinit(void)
{
    PWM_STOP(PDCTRL_PWM_TIM, PDCTRL_PWM_CHINNEL); // PWM通道禁用
    GPIO_SET_ANALOG(PDCTRL_PWM_GPIO_Port, PDCTRL_PWM_Pin);
}

static void pwm_init(void)
{
    pdctrl_data.last_out = 0xffff;
    GPIO_SET_ALTERNATE(PDCTRL_PWM_GPIO_Port, PDCTRL_PWM_Pin);
    if (pdctrl_data.pwm_arr_default == 0)
    {
        pdctrl_data.pwm_arr_default = LL_TIM_GetAutoReload(PDCTRL_PWM_TIM);
    }
    PWM_START(PDCTRL_PWM_TIM, PDCTRL_PWM_CHINNEL); // PWM通道使能
}

static void pwmp_dinit(void)
{
    PWM_STOP(PDCTRL_PWMP_TIM, PDCTRL_PWMP_CHINNEL); // PWM通道禁用
    GPIO_SET_ANALOG(PDCTRL_PWMP_GPIO_Port, PDCTRL_PWMP_Pin);
}

static void pwmp_init(void)
{
    pdctrl_data.last_out = 0xffff;
    GPIO_SET_ALTERNATE(PDCTRL_PWM_GPIO_Port, PDCTRL_PWM_Pin);
    PWM_START(PDCTRL_PWMP_TIM, PDCTRL_PWMP_CHINNEL); // PWM通道使能
}

/**
 * @brief 控制初始化
 * @param {pdctrl_mode_e} mode
 * @param {uint8_t} pwm_frequency
 * @return {*}
 * @note
 */
void pdctrl_init(pdctrl_mode_e mode)
{
    out_mode = mode;
    osel_memset((uint8_t *)&pdctrl_data, 0, sizeof(pdctrl_t));
    dac_dinit();
    pwm_dinit();
    pwmp_dinit();
    if (out_mode == PDCTRL_DAC)
    {
        dac_init();
    }
    else if (out_mode == PDCTRL_PWM)
    {
        pwm_init();
    }
    else if (out_mode == PDCTRL_PWMP)
    {
        pwmp_init();
    }
}

/**
 * @brief 控制停止
 * @return {*}
 * @note
 */
void pdctrl_stop(void)
{
    pdctrl_run_flag = FALSE;
    if (out_mode == PDCTRL_DAC || out_mode == PDCTRL_PWMP)
    {
        dac_dinit();
    }
    else if (out_mode == PDCTRL_PWM)
    {
        pwm_dinit();
    }
    else if (out_mode == PDCTRL_PWMP)
    {
        pwmp_dinit();
    }
}

/**
 * @brief 控制运行
 * @return {*}
 * @note
 */
void pdctrl_run(void)
{
    pdctrl_run_flag = TRUE;
    if (out_mode == PDCTRL_DAC)
    {
        dac_init();
    }
    else if (out_mode == PDCTRL_PWM)
    {
        pwm_init();
    }
    else if (out_mode == PDCTRL_PWMP)
    {
        pwmp_init();
    }
}

/**
 * @brief 获取控制器
 * @return {*}
 * @note
 */
pdctrl_t *pdctrl_get(void)
{
    return &pdctrl_data;
}

/**
 * @brief 占空比转换为CCR值
 * @param {float32} out
 * @return {*}
 * @note
 */
uint16_t pdctrl_pwm_duty_convert_ccr(float32 pwm_duty)
{
    return (pwm_duty * pdctrl_data.pwm_arr_default) / 100;
}

// 计算频率
static void calculate_pwm_freq(uint32_t arr)
{
    pdctrl_data.sysclk = SystemCoreClock * 1000;
    pdctrl_data.psc = LL_TIM_GetPrescaler(TIM2);
    pdctrl_data.freq = (float32)pdctrl_data.sysclk / (float32)(pdctrl_data.psc + 1) / (float32)arr;
}

/**
 * @brief 变频计算占空比
 * @param {uint32_t} arr 自动加载值
 * @return {*}
 * @note
 */
uint16_t calculate_pwm_duty(uint32_t arr)
{
    float32 wid = PWM_WID;
    calculate_pwm_freq(arr);
    if (arr < pdctrl_data.pwm_arr_default)
    {
        wid = (pdctrl_data.pwm_arr_default - arr) * 10 / pdctrl_data.pwm_arr_default + wid;
    }

    pdctrl_data.arr_us = 1000.0f / pdctrl_data.freq;
    pdctrl_data.duty_percent = ((float32)wid * 100.0f) / pdctrl_data.arr_us;
    uint16_t duty = arr * pdctrl_data.duty_percent / 100;
    return duty;
}

/**
 * @brief 动态修改频率
 * @param {uint32_t} arr 自动加载值
 * @return {*}
 * @note
 */
void pdctrl_pwm_set_arr(uint32_t arr)
{
    static uint16_t pwm_arr = 0;
    if (arr == 0)
    {
        arr = pdctrl_data.pwm_arr_default;
    }
    if (arr > pdctrl_data.pwm_arr_default)
    {
        arr = pdctrl_data.pwm_arr_default;
    }
    if (pwm_arr != arr)
    {
        pwm_arr = arr;
        LL_TIM_SetAutoReload(PDCTRL_PWM_TIM, pwm_arr);
    }
    else
    {
        return;
    }

    uint16_t duty = calculate_pwm_duty(pwm_arr);

#if PDCTRL_PWM_CHINNEL == LL_TIM_CHANNEL_CH4
    PWM_SET_DUTY(PDCTRL_PWM_TIM, 4, duty);
#else
#error "PDCTRL_PWM_CHINNEL undefined"
#endif
}

/**
 * @brief 控制输出
 * @param {uint16_t} out
 * @return {*}
 * @note
 */
void pdctrl_out(uint16_t out)
{
    if (pdctrl_run_flag == FALSE)
    {
        return;
    }

    if (pdctrl_data.last_out == out)
    {
        return;
    }

    pdctrl_data.last_out = out;

    if (out_mode == PDCTRL_DAC)
    {
        DAC_OUT(DAC, PDCTRL_DAC_CHINNEL, out);
        ip_out = out;
    }
    else if (out_mode == PDCTRL_PWM)
    {
        pdctrl_pwm_set_arr(out);
    }
    else if (out_mode == PDCTRL_PWMP || out_mode == PDCTRL_PWMP_HD)
    {
#if PDCTRL_PWMP_CHINNEL == LL_TIM_CHANNEL_CH4
        PWM_SET_DUTY(PDCTRL_PWMP_TIM, 4, out);
#else
#error "PDCTRL_PWMP_CHINNEL undefined"
#endif
    }
}

/**
 * @brief  获取控制模式
 * @return {*}
 * @note
 */
uint8_t get_pdctrl_mode(void)
{
    return out_mode;
}