基于重复控制方法的逆变器的仿真学习笔记

重复控制器的传递函数

重复控制器（Repetitive Controller，RC）是一种基于“内模原理”（Internal Model Principle）设计的控制器，用于消除周期性参考信号或周期性扰动下的稳态误差。逆变器具有周期性参考信号的特征，采用重复控制器进行控制，可以获得更稳定的控制性能。
重复控制器的基本传递函数为：

\[G(z)=\frac{z^{-N}}{1-z^{-N}}\]
其中，\(N\) 表示在一个周期内的采样数。意思是采用一个重复周期之前的采样样本作为环路的反馈值进行计算。
通常，重复控制器更为实用的传递函数是:

\[G(z)=\frac{z^m Q(z) z^{-N}}{1-Q(z) z^{-N}}\]
其中，\(Q(z)\) 是一个低通滤波器，用于消减高频处的增益，增加相位裕量。\(z^m\) 是一个超前相位补偿器，\(m\) 表示超前的采样数。
重复控制逆变器的仿真调试

仿真过程中将搭建一个逆变器电路，并使用重复控制器对输出电压进行控制，观察其性能。仿真软件使用的 GeckoCircuits 。
步骤1：搭建逆变器电路

搭建一个全桥逆变器电路，母线电压设为 \(400V\)，输出电压有效值 \(230V\)，频率 \(50Hz\)，负载电阻 \(200 \Omega\)。

其中，LC 滤波器参数的估算过程：LC 滤波器截止频率计算公式为 \(f_c = 1/2\pi \sqrt{LC}\)，该频率应远高于 \(10\) 倍基波频率，远低于开关频率 \(10\%\)，开关频率取\(32kHz\)，即 \(500Hz = 0.980){                            vOUT = 0.980;                        }                        else if (vOUT < -0.980){                            vOUT = -0.980;                        }                                                if (vSet >= 0){                            if (vOUT < 0){                            vOUT = 0;                            }                        }                        else{                            if (vOUT > 0){                                vOUT = 0;                            }                        }                                                lpf_b1 = lpf_b0;                        lpf_a1 = vOUT;                                                bufferIndex ++;                        if (bufferIndex >= indexMAX){                            bufferIndex = 0;                        }                        theta += thetaStep;                        if (theta >= TWOPI){                            theta = 0;                        }                    }                }                else{                    countMAX = (int)(1/(sampleRate*dt));                    initialized = true;                    vOUT = 0;                }                                yOUT[0] = vOUT;                yOUT[1] = vSet;                                return yOUT;// ****************** end of code segment **********************    }}[/code]H 桥驱动器的代码内容如下：

1. public class tmpJav393624554 implements java.io.Serializable, ch.technokrat.gecko.ControlCalculatable {
2. // variables:
3.         private final double sampleRate = 32000;
4.         private final double frequency = 50;
5.         private final double vRMS = 230;
6.         private final int indexMAX = (int)(sampleRate / frequency);
7.         private final double PI = Math.PI;
8.         private final double TWOPI = 2.0*PI;
9.         private final double thetaStep = TWOPI / indexMAX;
10.         private double[] bufferIN = new double[indexMAX];
11.         private double[] bufferOUT = new double[indexMAX];
12.         private int bufferIndex;
13.         private double error;
14.         private int count;
15.         private int countMAX;
16.         private boolean initialized;
17.         private double vSet;
18.         private double theta;
19.         private double vIN;
20.         private double vOUT;
21.         private double gain, gain1;
22.         private double q_b0, q_b1, q_a1;
23.         private double y, y0, y1, y2;
24.         private double x, x0, x1, x2;
25.         private double rc0, rc1, rc2;
26.         private double lpf_b0, lpf_b1, lpf_a1;
27.         private int m;
28.         private double[] yOUT = new double[2];
30.         @Override
31.         public void init() {
32.                 initialized = false;
33.                 bufferIndex = 0;
34.                 count = 0;
35.                 theta = 0;
36.                 gain = 0.0035;
37.                 q_b0 = 0.07246376811594202;
38.                 q_b1 = 0.07246376811594202;
39.                 q_a1 = -0.855072463768116;
40.                 lpf_b0 = 0.23809523809523814;
41.                 lpf_b1 = 0.23809523809523814;
42.                 lpf_a1 = -0.5238095238095238;
43.                 m = 3;
44.         }
46.     @Override
47.     public double[] calculateYOUT(final double[] xIN, final double time, final double dt) throws Exception {
48. // ****************** your code segment **********************
49.                 if (initialized){
50.                     count ++;
51.                     if (count >= countMAX){
52.                         count = 0;
53.                         
54.                         vIN = xIN[0];
55.                         vSet = 1.414*vRMS*Math.sin(theta);
56.                         error = (vSet - vIN);
57.                         
58.                         y0 = bufferOUT[bufferIndex];
59.                         y = y0*q_b0 + y1*q_b1 - y2*q_a1;
60.                         y1 = y0;
61.                         y2 = y;
62.                         
63.                         if (bufferIndex+m < indexMAX){
64.                             x0 = bufferIN[bufferIndex+m];
65.                         }
66.                         else{
67.                             x0 = bufferIN[bufferIndex+m-indexMAX];
68.                         }
69.                         
70.                         x = x0*q_b0 + x1*q_b1 - x2*q_a1;
71.                         x1 = x0;
72.                         x2 = x;
73.                     
74.                         rc0 = x + y;
75.                         bufferIN[bufferIndex] = error;
76.                         bufferOUT[bufferIndex] = rc0;
77.                         
78.                         vOUT = rc0*lpf_b0 + rc1*lpf_b1 - rc2*lpf_a1;
79.                         vOUT = vOUT*gain;
80.                
81.                         if (vOUT >= 0.980){
82.                             vOUT = 0.980;
83.                         }
84.                         else if (vOUT < -0.980){
85.                             vOUT = -0.980;
86.                         }
87.                         
88.                         if (vSet >= 0){
89.                             if (vOUT < 0){
90.                             vOUT = 0;
91.                             }
92.                         }
93.                         else{
94.                             if (vOUT > 0){
95.                                 vOUT = 0;
96.                             }
97.                         }
98.                         
99.                         lpf_b1 = lpf_b0;
100.                         lpf_a1 = vOUT;
101.                         
102.                         bufferIndex ++;
103.                         if (bufferIndex >= indexMAX){
104.                             bufferIndex = 0;
105.                         }
106.                         theta += thetaStep;
107.                         if (theta >= TWOPI){
108.                             theta = 0;
109.                         }
110.                     }
111.                 }
112.                 else{
113.                     countMAX = (int)(1/(sampleRate*dt));
114.                     initialized = true;
115.                     vOUT = 0;
116.                 }
117.                
118.                 yOUT[0] = vOUT;
119.                 yOUT[1] = vSet;
120.                
121.                 return yOUT;
122. // ****************** end of code segment **********************
123.     }
124. }

复制代码

步骤3：运行结果

运行仿真，查看输出电压波形：

转载请注明文章出处：https://www.cnblogs.com/CIB27149/p/19656366

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！