低成本单片机实现SVPWM、PID、PLL算法

SVPWM、PID、PLL算法的C语言实现（基于低成本单片机）

以下代码示例基于STM32F103C8T6（Cortex-M3内核）编写，适用于大多数低成本单片机。假设使用标准外设库或HAL库，并配置了PWM定时器、ADC和GPIO。

---

SVPWM实现

// 定义三相PWM输出引脚和定时器
#define PWM_TIMER htim1
#define PWM_CH_U TIM_CHANNEL_1
#define PWM_CH_V TIM_CHANNEL_2
#define PWM_CH_W TIM_CHANNEL_3

// SVPWM参数计算
void SVPWM_Generate(float Ualpha, float Ubeta) {
    float Uref = sqrtf(Ualpha*Ualpha + Ubeta*Ubeta);
    float angle = atan2f(Ubeta, Ualpha);
    
    // 扇区判断
    int sector = (int)(angle / (M_PI/3)) % 6;
    
    // 计算占空比
    float T1 = (sqrtf(3)*sinf(sector*M_PI/3 - angle) * Uref);
    float T2 = (sqrtf(3)*sinf(angle - (sector-1)*M_PI/3) * Uref);
    float T0 = 1 - T1 - T2;
    
    // 各相占空比映射
    float Ta, Tb, Tc;
    switch(sector) {
        case 0: Ta = T1 + T2 + T0/2; Tb = T2 + T0/2; Tc = T0/2; break;
        case 1: Ta = T1 +  T0/2; Tb = T1 + T2 + T0/2; Tc = T0/2; break;
        case 2: Ta = T0/2; Tb = T1 + T2 + T0/2; Tc = T2 + T0/2; break;
        case 3: Ta = T0/2; Tb = T1 + T0/2; Tc = T1 + T2 + T0/2; break;
        case 4: Ta = T2 + T0/2; Tb = T0/2; Tc = T1 + T2 + T0/2; break;
        case 5: Ta = T1 + T2 + T0/2; Tb = T0/2; Tc = T1 + T0/2; break;
    }
    
    // 设置PWM占空比
    __HAL_TIM_SET_COMPARE(&PWM_TIMER, PWM_CH_U, Ta * PWM_TIMER.Init.Period);
    __HAL_TIM_SET_COMPARE(&PWM_TIMER, PWM_CH_V, Tb * PWM_TIMER.Init.Period);
    __HAL_TIM_SET_COMPARE(&PWM_TIMER, PWM_CH_W, Tc * PWM_TIMER.Init.Period);
}

---

PID控制器实现

typedef struct {
    float Kp, Ki, Kd;
    float integral;
    float prev_error;
    float output_limit;
} PID_Controller;

void PID_Init(PID_Controller* pid, float Kp, float Ki, float Kd, float limit) {
    pid->Kp = Kp;
    pid->Ki = Ki;
    pid->Kd = Kd;
    pid->integral = 0;
    pid->prev_error = 0;
    pid->output_limit = limit;
}

float PID_Update(PID_Controller* pid, float setpoint, float measurement, float dt) {
    float error = setpoint - measurement;
    
    // 比例项
    float P = pid->Kp * error;
    
    // 积分项（抗饱和）
    pid->integral += error * dt;
    if(pid->integral > pid->output_limit) pid->integral = pid->output_limit;
    if(pid->integral < -pid->output_limit) pid->integral = -pid->output_limit;
    float I = pid->Ki * pid->integral;
    
    // 微分项
    float derivative = (error - pid->prev_error) / dt;
    float D = pid->Kd * derivative;
    pid->prev_error = error;
    
    // 输出限幅
    float output = P + I + D;
    if(output > pid->output_limit) output = pid->output_limit;
    if(output < -pid->output_limit) output = -pid->output_limit;
    
    return output;
}

---

PLL（锁相环）实现

typedef struct {
    float phase;
    float frequency;
    float Kp;
    float Ki;
    float max_freq;
    float min_freq;
} PLL_Controller;

void PLL_Init(PLL_Controller* pll, float Kp, float Ki, float init_freq, float min_f, float max_f) {
    pll->phase = 0;
    pll->frequency = init_freq;
    pll->Kp = Kp;
    pll->Ki = Ki;
    pll->min_freq = min_f;
    pll->max_freq = max_f;
}

void PLL_Update(PLL_Controller* pll, float input_phase, float dt) {
    // 相位误差（归一化到[-π, π]）
    float phase_error = input_phase - pll->phase;
    while(phase_error > M_PI) phase_error -= 2*M_PI;
    while(phase_error < -M_PI) phase_error += 2*M_PI;
    
    // PI控制器更新频率
    float freq_correction = pll->Kp * phase_error + pll->Ki * phase_error * dt;
    pll->frequency += freq_correction;
    
    // 频率限幅
    if(pll->frequency > pll->max_freq) pll->frequency = pll->max_freq;
    if(pll->frequency < pll->min_freq) pll->frequency = pll->min_freq;
    
    // 更新相位（防止溢出）
    pll->phase += 2 * M_PI * pll->frequency * dt;
    if(pll->phase > M_PI) pll->phase -= 2*M_PI;
    if(pll->phase < -M_PI) pll->phase += 2*M_PI;
}

---

应用示例（电机控制）

// 系统初始化
PID_Controller speed_pid;
PLL_Controller pll;
SVPWM_Init();  // 初始化PWM定时器

PID_Init(&speed_pid, 0.1, 0.01, 0.001, 1.0);
PLL_Init(&pll, 10.0, 100.0, 50.0, 10.0, 100.0);

// 主控制循环
while(1) {
    float dt = 0.001;  // 1ms控制周期
    float speed_ref = 1000;  // RPM
    float speed_meas = Read_Encoder_Speed();
    
    // PID速度控制
    float Iq_ref = PID_Update(&speed_pid, speed_ref, speed_meas, dt);
    
    // PLL获取转子角度
    float rotor_angle = Get_Rotor_Angle();  // 从编码器或观测器获取
    PLL_Update(&pll, rotor_angle, dt);
    
    // SVPWM生成
    float theta = pll.phase;
    float Ualpha = Iq_ref * cosf(theta);
    float Ubeta = Iq_ref * sinf(theta);
    SVPWM_Generate(Ualpha, Ubeta);
    
    HAL_Delay(1);  // 控制周期1ms
}

---

关键优化技巧

1. 定点数运算：对于M0/M3内核，将浮点运算转换为Q格式定点数（如Q15）可提升速度：

   #define Q15_MUL(a,b) ((int32_t)(a)*(b) >> 15)
   

2. 查表法：预计算三角函数值存储为查找表，节省计算时间：

   const float sin_table[256] = {...};
   

3. DMA传输：使用DMA自动更新PWM占空比，减少CPU干预。

4. 中断优先级：将PWM定时器中断设为最高优先级，确保时序精确。

5. ADC同步采样：配置ADC同步采样三相电流，提高采样精度。

以上代码经过适当修改可移植到STC8/STM8/ATmega等低成本单片机，需根据具体硬件调整外设配置。