FOC电机驱动开辟踩坑记载

关键技能

• SVPWM电机磁场控制
  
• 电流采样
  
• park变动和Clark变动
  
• 滑膜观测器（无感FOC）
  

SVPWM电机磁场控制

SVPWM重要头脑是通过精确的对UVW三相电流的分时控制，来控制转子的合成力矩，到达目的方向，常用的是6分区的计划，SVPWM是一种通过工程计划出来的处理惩罚步伐，不是算法，重要参考实现的博客：

示例代码：

1. // 使用查找表来替代三角函数的计算（示例，需要根据实际需要生成表格）
2. #define SIN_TABLE_SIZE 720 // 假设我们使用720项的查找表
3. float sinTable[SIN_TABLE_SIZE]; // 预先计算的正弦表
4. float cosTable[SIN_TABLE_SIZE]; // 预先计算的余弦表
6. // 初始化正弦和余弦查找表
7. void initTrigTables() {
8.     for (int i = 0; i < SIN_TABLE_SIZE; ++i) {
9.         sinTable[i] = sinf((TWO_PI * i) / SIN_TABLE_SIZE);
10.         cosTable[i] = cosf((TWO_PI * i) / SIN_TABLE_SIZE);
11.     }
12. }
14. void SVPWM(float Uq, float Ud, float angle) {
15.         if (Uq>0){
16.                 angle = normalizeAngle(angle);
17.         }else{
18.                 angle = normalizeAngle(angle);
19.         }
20.     // 使用查找表获取正弦和余弦表
21.    int index = (int)((angle / TWO_PI) * SIN_TABLE_SIZE) % SIN_TABLE_SIZE;
22.    float sin_angle = sinTable[index]; // sinf(angle_el);
23.    float cos_angle = cosTable[index]; // cosf(angle_el);
24.     float ua, ub;
25.     inverse_park_transform(Ud, Uq, &ua, &ub, cos_angle, sin_angle);
26.     float ts = 1.0;
27.     float udc = voltage_supply;
28.     float u1, u2, u3;
29.     inverse_clark_transflorm(ua, ub, &u1, &u2, &u3);
31.     int A = u1 > 0 ? 1 : 0;
32.     int B = u2 > 0 ? 1 : 0;
33.     int C = u3 > 0 ? 1 : 0;
35.     int N = 4 * A + 2 * B + C;
36.     int sector = 0;
37.     int sector_map[7] = {0, 6, 4, 5, 2, 1, 3}; // 0 index not used
38.     sector = sector_map[N];
39.     float K = SQRT3_OVER_2 * ts / udc;
40.     float t1, t2, t3, t4, t5, t6, t7, k;
42.     switch (sector) {
43.         case 1:
44.             t4 = u3 * K;
45.             t6 = u1 * K;
46.             if (t4 + t6 > ts) {
47.                 k = ts / (t4 + t6);
48.                 t4 *= k;
49.                 t6 *= k;
50.             }
51.             t7 = (ts - t4 - t6) / 2.0;
52.             ta = t4 + t6 + t7;
53.             tb = t6 + t7;
54.             tc = t7;
55.             break;
56.         case 2:
57.             t2 = -u3 * K;
58.             t6 = -u2 * K;
59.             if (t2 + t6 > ts) {
60.                 k = ts / (t2 + t6);
61.                 t2 *= k;
62.                 t6 *= k;
63.             }
64.             t7 = (ts - t2 - t6) / 2.0;
65.             tb = t2 + t6 + t7;
66.             ta = t6 + t7;
67.             tc = t7;
68.             break;
69.         case 3:
70.             t2 = u1 * K;
71.             t3 = u2 * K;
72.             if (t2 + t3 > ts) {
73.                 k = ts / (t2 + t3);
74.                 t2 *= k;
75.                 t3 *= k;
76.             }
77.             t7 = (ts - t2 - t3) / 2.0;
78.             tb = t2 + t3 + t7;
79.             tc = t3 + t7;
80.             ta = t7;
81.             break;
82.         case 4:
83.             t1 = -u1 * K;
84.             t3 = -u3 * K;
85.             if (t1 + t3 > ts) {
86.                 k = ts / (t1 + t3);
87.                 t1 *= k;
88.                 t3 *= k;
89.             }
90.             t7 = (ts - t1 - t3) / 2.0;
91.             tc = t1 + t3 + t7;
92.             tb = t3 + t7;
93.             ta = t7;
94.             break;
95.         case 5:
96.             t1 = u2 * K;
97.             t5 = u3 * K;
98.             if (t1 + t5 > ts) {
99.                 k = ts / (t1 + t5);
100.                 t1 *= k;
101.                 t5 *= k;
102.             }
103.             t7 = (ts - t1 - t5) / 2.0;
104.             tc = t1 + t5 + t7;
105.             ta = t5 + t7;
106.             tb = t7;
107.             break;
108.         case 6:
109.             t4 = -u2 * K;
110.             t5 = -u1 * K;
111.             if (t4 + t5 > ts) {
112.                 k = ts / (t4 + t5);
113.                 t4 *= k;
114.                 t5 *= k;
115.             }
116.             t7 = (ts - t4 - t5) / 2.0;
117.             ta = t4 + t5 + t7;
118.             tc = t5 + t7;
119.             tb = t7;
120.             break;
121.         default:
122.             ta = tb = tc = 0.0;
123.             break;
124.     }
125.         __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, (uint32_t)(ta/ts*MAX_DUTY_CYCLE));
126.         __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_2, (uint32_t)(tb/ts*MAX_DUTY_CYCLE));
127.         __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_3, (uint32_t)(tc/ts*MAX_DUTY_CYCLE));
128. }

复制代码

电流采样

电机的三相电流采样有3种采样的方法，1种是3相电流全部采样，长处是能采到三相的及时真实电流，缺点是资本是最高的；第二种是2相电流采样，通过3相电流之和为0可以算出第3相的电流，长处是低落了一些资本，缺点是精度没有3相的高；第三种是在总的电路上采样总电流，通过算法算出3相电流的值，长处是资本是最低的，缺点是精度也是最差的；
电机的电流采样电阻的采样位置有3种：1. 输出电流采样，优点是可以大概及时采到三相电流，缺点是对于采样器件比方INI181的电压耐受范围有要求，电压遭受本领不敷大概会导致器件破坏；2. 低压地区采样，优点是对应器件的电压遭受本领要求低，缺点是必要精确控制采样的时间，采样时间必须在H桥的下臂导通时举行采样，否则采样不到精确的电流；3. 母线电流采样，仅在有效矢量时间举行电流采样，同样存在采样盲区。
park变动和Clark变动

park变动和Clark变动为经典的变动，可以从许多博客上看原理，代码示比方下：

1. #include "main.h"
2. #include "tools.h"
3. #define SQRT3_OVER_2 0.866
5. void clark_transform(float u1, float u2, float u3, float *ualpha, float *ubeta){
6.         *ualpha = 0.66666*(u1 - 0.5*u2 - 0.5*u3);
7.         *ubeta = 0.6666*(u2*SQRT3_OVER_2 - SQRT3_OVER_2 * u3);
8. }
10. void inverse_clark_transflorm(float ualpha, float ubeta, float *u1, float *u2, float *u3){
11.         *u1 = ualpha;
12.         *u2 = -0.5*ualpha + SQRT3_OVER_2 * ubeta;
13.         *u3 = -0.5*ualpha - SQRT3_OVER_2 * ubeta;
14. }
15. void park_transform(float ialpha, float ibeta, float cos_angle, float sin_angle, float *id, float *iq){
16.         *id = ialpha * cos_angle + ibeta * sin_angle;
17.         *iq = -ialpha * sin_angle + ibeta *cos_angle;
18. }
19. void inverse_park_transform(float id, float iq, float *ialpha, float *ibeta, float cos_angle, float sin_angle){
20.         *ialpha = id * cos_angle - iq * sin_angle;
21.         *ibeta = id * sin_angle + iq * cos_angle;
22. }

复制代码

滑膜观测器

通过使用上面的技能和代码，可以做到有感FOC的控制了，但是想要不使用转子位置传感器的话还要在控制时使用一些算法。常用的无感FOC控制算法有滑膜控制器、龙博格观测器，根本都是靠观测器加锁相环来实现对转子角度位置的估计，但是都会有一些标题，滑膜控制器的标题是大概会出现电机震荡，可以通过调解参数的巨细来低落震荡的幅度但肯定会有。滑膜变阻器的MATLAB仿真图如下：

踩坑记载

• park变动与反变动和clark变动与反变动要对应好，SVPWM中的变动必须和电流采样时的每条线的次序都雷同；
  
• 电流采样时使用的是下桥采样，必要控制好采样时间，采样时间要在下桥臂导通的时间采样；
  
• 使用中心对称的PWM模式；