直流无刷电机 FOC 控制算法详解

FOC 控制算法的实现流程，主要分为以下几大步：

1. 采集电机三相相电流 Ia Ib Ic。
2. 将三相相电流通过 Clarke 变换得到 Iα Iβ。
3. 将 Iα Iβ 通过 Park 变换得到 Id Iq。
4. 根据 Id Iq 和目标 Id_target Iq_target 进行 PID 计算得到 Uq Ud（电流环）。
5. 将 Uq Ud 通过反 Park 变换得到 Uα Uβ。
6. 将 Uα Uβ 作为 SVPWM 的输入，得到三路半桥的 PWM 输出定时器的比较寄存器值 CCR。

FOC 算法 Clarke 变换

Clarke 变化也就是将无刷电机静止的三相相电流 Ia Ib Ic 三相坐标系转化为静止的 α-β 两相直角坐标系。

通过 ADC 采样得到电机的 Ia 和 Ib 两项电流信息，由于基尔霍夫电流定律（公式：Ia + Ib + Ic = 0），同一个节点流入电流值与流出电流相等，我们可以计算出 Ic，三个电流的相位差为 120°。

通过 Clark 变换，将三相定子坐标系（三个轴互为 120°，Ia , Ib , Ic）转化为两相的定子直角坐标系（i α , i β）。这个过程有点类似于力的矢量分解，把三相映射到两相的坐标轴之上。

根据上图把三相映射到两相的坐标轴之上，可以得出 Clarke 变换的推导公式。上式中，系数 K = 2/3，变换前后，幅值不变（即合成矢量的大小和方向相等）。等幅值变换其实就是将 Iα = Ia，将系数 K = 2/3 代入上式得最终结果。

Clarke 逆变换公式推导

我们学习了怎么把一个三相时域上的复杂问题用矢量表示，并且用克拉克变换对它进行了降维，得到了降维后的简化表达形式。那么，有没有什么办法能够反过来把降维后的形式重新升维变回原来的 Ia, Ib, Ic 三相电流波形呢？有，这就被称为克拉克逆变换。这个在后续的 FOC 算法中也会很常用到。

我们已经知道了克拉克变换后的 Iα、Iβ，在此基础上研究 Clarke 逆变换。首先，Ia 的逆变换我们是不需要研究的，因为我们已经知道了 Iα = Ia。进一步的，我们研究逆变换 Ib。最后，还是根据基尔霍夫电流定律：Ia + Ib + Ic = 0，我们得到逆变换 Ic。则克拉克逆变换三式皆得。

FOC 算法 Park 变换

将电机三相相电流通过 Clark 变化得到 Iα Iβ，然后再将 Iα Iβ 通过变换得到随电机转子转动的 Iq Id 坐标系称为 Park 变换。

Park 变换公式推导

根据三角关系推出，Iα 在 d 轴上的投影分量为 Iαcosθ，q 轴与β轴的夹角为θ，因此 iβ 在 d 轴上的投影分量为 iβsinθ; iα 在 q 轴上的投影分量为 -iαsinθ，因为它的投影分量在 q 轴的负方向上; iβ 在 q 轴上的投影分量为 iβcosθ。综合以上，可以得出公式。

这个 id, iq 坐标系是始终跟着转子旋转的：

1. d 轴方向与转子磁链方向重合，又叫直轴。
2. q 轴方向与转子磁链方向垂直，又叫交轴。

经过这一步的变换，我们会发现，一个匀速旋转向量在这个坐标系下变成了一个定值，这个坐标系下两个控制变量都被线性化了。

Park 逆变换公式推导

Vd 在β轴上的投影分量为 Vdsinθ，Vq 在β轴上的投影分量为 Vqcosθ，由此可得出下式。

FOC 算法 SVPWM（空间矢量脉冲调制）原理及实现

SVPWM（Space Vector Pulse Width Modulation）即空间矢量脉宽调制。它通过三项逆变器的 6 个功率管输出随时间变化的 PWM 波，模拟三项对称正弦波电流形成的电压矢量圆，产生接近圆形的磁链轨迹。

SVPWM 的原理如下：

1. 基本矢量电压：SVPWM 将三相电压分解为两个正弦波和一个直流分量，这三个分量构成了基本矢量电压。
2. 扇区判断：根据电机的电角度，判断当前所处的扇区。扇区是将电机的 360 度分为六个等分，每个扇区对应一个基本矢量电压。
3. 计算相邻两个基本矢量电压的作用时间：根据当前所处的扇区，计算相邻两个基本矢量电压的作用时间。作用时间是指每个基本矢量电压在一个电周期内的持续时间。
4. 三路 PWM 占空比计算：根据相邻两个基本矢量电压的作用时间，计算三相 PWM 的占空比。占空比是指 PWM 信号高电平的持续时间与一个电周期的比值。

算法流程如下：

• Step1：根据电机的电角度，判断当前所处的扇区。
• Step2：根据当前所处的扇区，计算相邻两个基本矢量电压的作用时间。
• Step3：根据相邻两个基本矢量电压的作用时间，计算三相 PWM 的占空比。

七段式 SVPWM 和五段式 SVPWM 的区别

七段式 SVPWM 和五段式 SVPWM 都是一种常用的交流电机控制方法，它们的主要区别在于矢量分解时所使用的向量数不同。

1. 七段式：使用七个不同的向量进行矢量分解，可以得到更高的电机效率和更低的谐波失真率。但是，七段式 SVPWM 需要更复杂的计算，因此需要更高的控制精度和计算能力。
2. 五段式：只使用五个向量进行矢量分解，计算较为简单，适用于控制较为简单的电机系统。但是，五段式 SVPWM 相对于七段式 SVPWM 的效率和失真率会略差一些。

本设计采用七段式 SVPWM 设计。

基本矢量电压

（此处省略具体矢量图，逻辑同上）

扇区判断

（此处省略扇区判断图，逻辑同上）

相邻两个基本矢量电压的作用时间

（此处省略作用时间计算图，逻辑同上）

根据时间计算三路 PWM 占空比

根据上图（以扇区一为例）可以得出三路 PWM 占空比值的公式：

cvalue_a = (tpwm - Ta - Tb)/4;
value_b = value_a + Ta/2;
value_c = value_b + Tb/2;

value_a：占空比占比最多；value_b：占空比占比中等；value_c：占空比占比最少。

每个扇区 A、B、C 占空比占比都不一样，根据六个扇区的七段式波形图，得出的 value_a、value_b、value_c 代入相对应的扇区。

STM32CubeMX 配置

时钟原配置

（配置截图）

调试接口配置

（配置截图）

时钟配置

（配置截图）

高级定时器配置 (用于 FOC 算法，产生 PWM)

（配置截图）

ADC 配置 (用于电机三相电流采样)

（配置截图）

代码讲解

核心算法实现

这里展示 FOC 矢量控制的核心 C 语言代码，包含反 Park 变换、扇区判断、矢量作用时间计算及 CCR 时间计算。

#include "foc.h"
// 反 Park 变换，将静止两相坐标系 D/Q 转换为旋转两相坐标系 Valpha/Vbeta
void RevParkOperate(float vd, float vq, float theta, float *valpha, float *vbeta)
{
    *valpha = vd * cos(theta) - vq * sin(theta);
    *vbeta = vd * sin(theta) + vq * cos(theta);
}

// 扇区判断函数，通过 valpha 和 vbeta 判断扇区
// 返回值：315462 对应扇区 123456
unsigned char SectorJude(float valpha, float vbeta)
{
    float A = vbeta;
    float B = valpha * sqrt3 / 2.0f - vbeta / 2.0f;
    float C = -valpha * sqrt3 / 2.0f - vbeta / 2.0f;
    unsigned char N = 0;
    if (A > 0) { N = N + 1; }
    if (B > 0) { N = N + 2; }
    if (C > 0) { N = N + 4; }
    return N;
}

// 矢量作用时间计算
void VectorActionTime(uint8_t n, float valpha, float vbeta, uint32_t udc, uint32_t tpwm, float *ta, float *tb)
{
    float X = (sqrt3 * tpwm) / udc * vbeta;
    float Y = (sqrt3 * tpwm) / udc * ((sqrt3 / 2.0f) * valpha - vbeta / 2.0f);
    float Z = (sqrt3 * tpwm) / udc * (-(sqrt3 / 2.0f) * valpha - vbeta / 2.0f);
    if (n == 3) // 第一扇区
    {
        *ta = Y;
        *tb = X;
    }
    if (n == 1) // 第二扇区
    {
        *ta = -Y;
        *tb = -Z;
    }
    if (n == 5) // 第三扇区
    {
        *ta = X;
        *tb = Z;
    }
    if (n == 4) // 第四扇区
    {
        *ta = -X;
        *tb = -Y;
    }
    if (n == 6) // 第五扇区
    {
        *ta = Z;
        *tb = Y;
    }
    if (n == 2) // 第六扇区
    {
        *ta = -Z;
        *tb = -X;
    }
}

// CCR 时间计算
void CCRCalculate(uint8_t n, float ta, float tb, uint32_t tpwm, uint32_t *ccr1, uint32_t *ccr2, uint32_t *ccr3)
{
    /* 限制 ta 和 tb，ta+tb 不能超过 tpwm */
    float temp = ta + tb;
    if (temp > tpwm) { ta = ta / temp * tpwm; tb = tb / temp * tpwm; }
    float value1 = (tpwm - ta - tb) / 4.0f;
    float value2 = value1 + ta / 2.0f;
    float value3 = value2 + tb / 2.0f;
    switch (n)
    {
    case 3: *ccr1 = value1; *ccr2 = value2; *ccr3 = value3; break;
    case 1: *ccr1 = value2; *ccr2 = value1; *ccr3 = value3; break;
    case 5: *ccr1 = value3; *ccr2 = value1; *ccr3 = value2; break;
    case 4: *ccr1 = value3; *ccr2 = value2; *ccr3 = value1; break;
    case 6: *ccr1 = value2; *ccr2 = value3; *ccr3 = value1; break;
    case 2: *ccr1 = value1; *ccr2 = value3; *ccr3 = value2; break;
    }
}

// 通过 Vd,Vq,THETA,Udc,Tpwm 计算每一步的 CCR 值并写入定时器
/* Vd:给电机 Vd 的电压 Vq:给电机 Vq 的电压 theta:电角度 theta:母线电压 tpwm:PWM 周期 */
void SvpwmAlgorithm(float vd, float vq, float theta, uint32_t udc, uint32_t tpwm)
{
    float valpha = 0;
    float vbeta = 0;
    RevParkOperate(vd, vq, theta, &valpha, &vbeta); // 计算当前 valpha 和 vbeta
    unsigned char n = SectorJude(valpha, vbeta); // 计算当前扇区
    float ta = 0;
    float tb = 0;
    VectorActionTime(n, valpha, vbeta, udc, tpwm, &ta, &tb); // 计算两个矢量的作用时间
    uint32_t ccr1 = 0;
    uint32_t ccr2 = 0;
    uint32_t ccr3 = 0;
    CCRCalculate(n, ta, tb, tpwm, &ccr1, &ccr2, &ccr3); // CCR 时间计算（计算占空比值）
    __HAL_TIM_SET_COMPARE(&htim8, TIM_CHANNEL_1, ccr1); // 输出三路占空比
    __HAL_TIM_SET_COMPARE(&htim8, TIM_CHANNEL_2, ccr2);
    __HAL_TIM_SET_COMPARE(&htim8, TIM_CHANNEL_3, ccr3);
}

/* FOC-Park 和 Clark 变换 */
/* APhaseCurrent：电机 A 相电流 BPhaseCurrent：电机 B 相电流 Electronic_Angle：电角度 */
void Clark_Park(int APhaseCurrent, int BPhaseCurrent, float Electronic_Angle, FOC_CURRENT *Current)
{
    // Clark 变换 I_alfa = APhaseCurrent; I_beta = 1/sqrt3 *(2*BPhaseCurrent + APhaseCurrent);
    Current->Id = APhaseCurrent * cos(Electronic_Angle) + (1.0f / sqrt3) * (2 * BPhaseCurrent + APhaseCurrent) * sin(Electronic_Angle);
    Current->Iq = -(APhaseCurrent * sin(Electronic_Angle)) + (1.0f / sqrt3) * (2 * BPhaseCurrent + APhaseCurrent) * cos(Electronic_Angle);
    Current->Id = Current->Id / 1600.0;
    Current->Iq = Current->Iq / 1600.0;
}

头文件定义

#ifndef __FOC_H__
#define __FOC_H__
#include "tim.h"
#include <math.h>
#include <stdio.h>
#define sqrt3 1.7320508f

/* FOC 变换之后的电流值 */
typedef struct {
    float Id;
    float Iq;
} FOC_CURRENT;
extern FOC_CURRENT foc_current;

void SvpwmAlgorithm(float vd, float vq, float theta, uint32_t udc, uint32_t tpwm);
void Clark_Park(int APhaseCurrent, int BPhaseCurrent, float Electronic_Angle, FOC_CURRENT *Current);
#endif

主要运行代码

/* TIM3 回调函数 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
/* 进入中断时间为 1ms 秒 */
{
    if (htim->Instance == TIM3)
    {
        if (motor_state == 1)
        {
            Get_Pos(); // 编码器多圈数据累加
            Encoder_TypeDef.angle = Get_Elec_Angle(); // 获取机械角度
            /* 角度补偿 */
            if (Encoder_TypeDef.angle >= Encoder_TypeDef.angle_rad_offset)
            {
                Encoder_TypeDef.angle = Encoder_TypeDef.angle - Encoder_TypeDef.angle_rad_offset;
            }
            else
            {
                Encoder_TypeDef.angle = 6.2831852f - Encoder_TypeDef.angle_rad_offset + Encoder_TypeDef.angle;
            }
            Encoder_TypeDef.electronic_angle = Encoder_TypeDef.angle * 7; // 将机械角度转换成电角度
            Encoder_TypeDef.electronic_angle = fmod(Encoder_TypeDef.electronic_angle, 6.2831852f); // 将电角度限制在 0-6.2831852f 之间
            /* 位置环 */
            PID_Position_Out = PID_Function(&pid_position_TypeDef, target_location, encoder.rad_comulative);
            /* 速度计算 */
            vel_LPF = LPF_velocity(MT6701_GetVelocity()); // 速度计算以及低通滤波处理
            /* 速度环 */
            PID_Speed_Out = PID_Function(&pid_speed_TypeDef, PID_Position_Out, vel_LPF);
            /* Clark_Park 变换 */
            Clark_Park(PhaseACurrent, PhaseBCurrent, Encoder_TypeDef.electronic_angle, &foc_current);
            /* 电流环 */
            PID_Out_Value = PID_Function(&pid_current_Typedef, PID_Speed_Out, foc_current.Iq);
            SvpwmAlgorithm(0, PID_Out_Value, Encoder_TypeDef.electronic_angle, 12, 3600); // SVPWM 算法
        }
    }
}