Ví dө: Phương pháp thiӃt kӃ PID cho các hӋ

thӕng treo(- giҧm xóc) xe buýt

Adding a PID controller Thêm mӝt bӝ điӅu khiӇn PID
Plotting the closed-loop response: VӁ đӗ thӏ cho đáp ӭng vòng kín
Choosing the gains for the PID controller: Lӵa chӑn đӝ lӧi cho bӝ điӅu khiӇn
PID

From the main problem, the dynamic equations in transfer function form are the
following: Tӯ vҩn đӅ chính, cách tính hàm truyӅn cho các phương trình đӝng lӵc hӑc
như sau:

and the system schematic looks like: và dҥng sơ đӗ hӋ thӕng như sau:

For the original problem setup and the derivation of the above equations and schematic,
please refer to the bus modeling page . Đӕi vӟi nhӳng vҩn đӅ thiӃt lұp ban đҫu và nguӗn
gӕc cӫa phương trình và sơ đӗ trên, xin vui lòng tham khҧo các trang mô hình xe buýt .

We want to design a feedback controller so that when the road disturbance ( î ) is

simulated by a unit step input, the output (
  ) has a settling time less than 5 seconds
and an overshoot less than 5%. For example, when the bus runs onto a 10 cm high step,
the bus body will oscillate within a range of +/- 5 mm and will stop oscillating within 5
seconds.
Chúng tôi muӕn thiӃt kӃ mӝt bӝ điӅu khiӇn hӗi tiӃp vӅ vì thӃ khi có sai lӋnhi
 


   iî đưӧc mô phӓng bӣi mӝt đáp ӭng nҩc ӣ đҫu vào( mӝt tín hiӋu vào
có hàm nҩc đơn vӏ), ngõ ra i
  có thӡi gian đһt ít hơn 5 giây và đӝ vӑt lӕ ít hơn
5%. Ví dө, khi xe buýt chҥy lên mӝt bưӟc cao 10 cm, thân xe sӁ dao đӝng trong mӝt
phҥm vi + / - 5 mm và sӁ dӯng lҥi dao đӝng trong vòng 5 giây.

The system model can be represented in Matlab by creating a new m-file and entering the
following commands (refer to main problem for the details of getting those commands).
Mô hình hӋ thӕng có thӇ đưӧc thӵc hiӋn trong Matlab bҵng cách tҥo ra mӝt file mӟi

m-file và nhұp vào các lӋnh sau (tham khҧo vҩn đӅ chính cho các chi tiӃt cӫa viӋc sӱ
dөng các lӋnh).

m1=2500; m1 = 2500;
m2=320; m2 = 320;
k1 = 80000; k1 = 80000;
k2 = 500000; k2 = 500000;
b1 = 350; b1 = 350;
b2 = 15020; b2 = 15020;

nump=[(m1+m2) b2 k2] nump = [(m1 + m2) b2 k2]

denp=[(m1*m2) (m1*(b1+b2))+(m2*b1) (m1*(k1+k2))+(m2*k1)+(b1*b2)
(b1*k2)+(b2*k1) k1*k2] denp = [(m1 * m2) (m1 * (b1 + b2)) + (m2 *
b1) (m1 * (k1 + k2)) + (m2 * k1) + (b1 * b2) (b1 * k2) + (b2 *
k1) k1 * k2]

num1=[-(m1*b2) -(m1*k2) 0 0] num1 = [- (m1 * b2) - (m1 * k2) 0 0]

den1=[(m1*m2) (m1*(b1+b2))+(m2*b1) (m1*(k1+k2))+(m2*k1)+(b1*b2)
(b1*k2)+(b2*k1) k1*k2] den1 = [(m1 * m2) (m1 * (b1 + b2)) + (m2 *
b1) (m1 * (k1 + k2)) + (m2 * k1) + (b1 * b2) (b1 * k2) + (b2 *
k1) k1 * k2]

numf=num1; numf = num1;

denf=nump; denf = nump;

   


      

Recall that the transfer function for a PID controller is: Hãy nhӟ rҵng hàm truyӅn cho mӝt
bӝ điӅu khiӇn PID là:

where KP is the proportional gain, KI is the integral gain, and KD is the derivative gain.
nơi KP: đӝ lӧi tӍ lӋ, KI: đӝ lӧi tích phân, và KD: đӝ lӧi đҥo hàm. Let's assume that we
will need all three of these gains in our controller. Hãy giҧ sӱ rҵng chúng ta sӁ cҫn cҧ ba
đӝ lӧi này trong điӅu khiӇn cӫa chúng ta. To begin, we might start with guessing a gain
for each: — =208025, — =832100 and — =624075. This can be implemented into
Matlab by adding the following code into your m-file: ĐӇ bҳt đҫu, chúng tôi có thӇ bҳt
đҫu vӟi đoán mӝt đӝ lӧi cho mӛi: — = 208025, — = 832100 và — = 624.075.

ĐiӅu này có thӇ đưӧc thӵc hiӋn trong Matlab bҵng cách thêm vào sau m-file cӫa bҥn
vào:

— =208025; — = 208025;
—
=832100; —
= 832100;
—=624075; — = 624075;
numc=[— —
—]; numc = [—  —
 —];
denc=[1 0]; denc = [1 0];
8ow let's simulate the response of the system (the distance
-  ) to a step
disturbance on the road. Bây giӡ chúng ta hãy mô phӓng các đáp ӭng cӫa hӋ thӕng
(khoҧng cách
-  cho mӝt sӵ xáo trӝn (sai lӋnh) trên đưӡng. From the schematic
above we can find the transfer function from the road disturbance î to the output(
-
 ): Tӯ sơ đӗ trên, chúng ta có thӇ tìm thҩy hàm truyӅn tӯ các rӕi loҥn (sai lӋnh) trên
đưӡng î vӟi ngõ ra i
- 

This transfer function can be modeled in Matlab by adding the following code into your
m-file: Chӭc năng này có thӇ đưӧc mô hình chuyӇn giao trong Matlab bҵng cách thêm
đoҥn mã sau vào file-m cӫa bҥn:
numa=conv(conv(numfnump)denc); NUMA = conv (conv (numf nump)
denc);
dena=conv(denf polyadd (conv(denpdenc)conv(numpnumc))); eNA
= conv (denf polyadd (conv (denp denc) conv (nump numc)));
8ote that the function " polyadd " is not a standard function in Matlab; you will need to
copy it to a new m-file to use it. Lưu ý rҵng chӭc năng " polyadd "không phҧi là chӭc
năng tiêu chuҭn trong Matlab, bҥn sӁ cҫn phҧi sao chép nó vào mӝt file m-mӟi đӇ sӱ
dөng nó. Click here for more information on defining new functions in Matlab. Click vào
đây đӇ biӃt thêm chi tiӃt vӅ quy đӏnh chӭc năng (hàm) mӟi trong Matlab.

Refer to the bus modeling page, nump = denf as we can see in the matlab command
above. Hãy tham khҧo nhӳng trang mô hình xe buýt, nump = denf như chúng ta có thӇ
thҩy trong các lӋnh MATLAB trên. Thus we can simplified this transfer function to be
the following: 8hư vұy chúng ta có thӇ đơn giҧn hóa chӭc năng này đưӧc hàm truyӅn
như sau:

numa=conv(numfdenc); NUMA = conv (numf denc);

 dena= polyadd (conv(denpdenc)conv(numpnumc)); eNA = polyadd
(conv (denp denc) conv (nump numc));

 
 
  !" # $
 % & '( )

8ow we have created the closed-loop transfer function in Matlab that will represent the
plant, the disturbance, as well as the controller. Bây giӡ chúng tôi đã tҥo ra các hàm
truyӅn vòng kín trong Matlab sӁ thӇ hiӋn cho các nhà máy, các xáo trӝn, cũng như điӅu
khiӇn.( mô tҧ đӕi tưӧng, các rӕi loҥn, tӕt như bӝ điӅu khiӇn). Let's see what the closed-
loop step response for this system looks like before we begin the control process. Hãy
xem đáp ӭng nҩc vòng kín cho hӋ thӕng này trông giӕng như trưӟc khi chúng tôi bҳt đҫu
quá trình kiӇm soát. Keep in mind that we are going to use a 0.1 m high step as our
disturbance, to simulate this, all we need to do is to multiply numa by 0.1. Hãy nhӟ rҵng
chúng ta sӁ sӱ dөng bưӟc 0,1 m cao như tín hiӋu nhiӉu cӫa chúng tôi, đӇ mô phӓng này,
tҩt cҧ chúng ta cҫn làm là nhân NUMA vӝi 0,1. Add the following code into your m-file:
Thêm đoҥn mã sau vào file-m cӫa bҥn:

t=0:0.05:5; t = 0:0.05:5;
step (0.1*numadenat) bưӝc (01 * NUMA eNA t)
title('closed-loop response to 0.1m high step w/ pid controller')
Tiêu đӃ ('phҥn ӫng vòng kín đӅ bưӝc cao 0.1m w / pid điӃu khiӅn')

you should see the response (
-  ) to a step î like this: bҥn sӁ thҩy các phҧn ӭng
i
-  đӇ mӝt bưӟc î như thӃ này:

From the graph, the percent overshoot = 9%, which is 4% larger than the requirement, but
the settling time is satisfied, less than 5 seconds. To choose the proper gain that yields
reasonable output from the beginning, we start with choosing a pole and two zeros for
PID controller. Tӯ đӗ thӏ, đӝ vӑt lӕ = 9%, điӅu này lӟn hơn 4% so vӟi yêu cҫu, nhưng
thӡi gian giҧi quyӃt đưӧc hài lòng, ít hơn 5 giây. ĐӇ chӑn đưӧc đúng mà đҫu ra hӧp lý
ngay tӯ đҫu, chúng tôi bҳt đҫu vӟi viӋc lӵa chӑn mӝt cӵc và hai sӕ không( zero) cho điӅu
khiӇn PID. A pole of this controller must be at zero and one of the zeros has to be very
close to the pole at the origin, at 1. Mӝt cӵc cӫa bӝ điӅu khiӇn này phҧi có sӕ không và
mӝt trong sӕ không phҧi là rҩt gҫn vӟi các cӵc tҥi gӕc, tҥi 1.( Zero phҧi rҩt gҫn vӟi cӵc
gӕc, là 1.) The other zero, we will put further from the first zero, at 3, actually we can
adjust the second-zero's position to get the system to fulfill the requirement. Các khác
không, chúng tôi sӁ đưa thêm nhӳng ngưӡi đҫu tiên không, vào lúc 3( Zero khác, chúng
ta sӁ đһt xa hơn Zero đҫu tiên, là 3) , thӵc sӵ chúng ta có thӇ điӅu chӍnh thӭ hai-không
cӫa vӏ trí đӇ có đưӧc hӋ thӕng đӇ thӵc hiӋn các yêu cҫu.( thӵc sӵ chúng ta có thӇ điӅu
chӍnh vӏ trí cӫa Zero thӭ hai đӇ có đưӧc hӋ thӕng đáp ӭng đưӧc yêu cҫu) Add the
following command in the m-file, so you can adjust the second-zero's location and
choose the gain to have a rough idea what gain you should use for —*—* and —+ Thêm
các lӋnh sau đây trong tұp tin-m, vì vұy bҥn có thӇ điӅu chӍnh thӭ hai-không cӫa đӏa điӇm
và lӵa chӑn đưӧc đӇ có mӝt ý tưӣng nhӳng gì đҥt đưӧc, bҥn nên sӱ dөng cho —* —* và
—+ (vì vұy bҥn có thӇ điӅu chӍnh đӏa điӇm cӫa Zero thӭ hai và chӑn đӝ lӧi có giá trí gҫn
đúng, nhӳng đӝ lӧi mà bҥn nên chӍnh là KD,KP và KI.)
1=1;
z2=3;
p1=0;
numc=conv([1 z1][1 z2])
denc=[1 p1]
num2=conv(numpnumc);
den2=conv(denpdenc);
rlocus(num2den2)
title('root locus with
 controller')
[—p]=rlocfind(num2den2)
you should see the closed-loop poles and zeros on the s-plane like this and you can
choose the gain and dominant poles on the graph by yourself: bҥn sӁ thҩy các vòng kín
cӵc và sӕ không trên máy bay-s như thӃ này và bҥn có thӇ chӑn đưӧc và cӵc hưӣng lӟn
trong đӗ thӏ cӫa mình: ( bҥn sӁ thҩy vòng kín các cӵc và zero trên mһt phҷng s ӣ hình bên
dưӟi và bҥn có thӇ chӑn đӝ lӧi và chi phӕi các cӵc trên đӗ thӏ:)
We will explain root locus method in more detail in the "Root Locus" page. Chúng tôi sӁ
giҧi thích gӕc Phương pháp quĩ tích cө thӇ hơn trong "Root Locus" trang.(Phương pháp
root locus chi tiӃt hơn tҥi trang "Root Locus")

V   ,
 



-.
/  0
  
 

8ow that we have the closed-loop transfer function, controlling the system is simply a
matter of changing the KD,KP,and KI variables. Bây giӡ chúng ta có hàm truyӅn vòng
kín, kiӇm soát hӋ thӕng chӍ đơn giҧn là vҩn đӅ thay đәi biӃn KD,KP và KI. From the
figure above, we can see that the system has larger damping than required, but the
settling time is very short. Tӯ hình trên, chúng ta có thӇ thҩy rҵng hӋ thӕng đã có thӡi
gian әn đӏnh lӟn hơn so vӟi yêu cҫu, nhưng thӡi gian xác lұp là rҩt ngҳn. This response
still doesn't satisfy the 5% overshoot requirement. Đáp ӭng này vүn không thӓa mãn đӝ
vӑt lӕ 5%. As mentioned before, this can be rectified by adjusting the — , — and —
variables to find better response. 8hư đã đӅ cұp trưӟc đây, điӅu này có thӇ đưӧc sӱa chӳa
bҵng cách điӅu chӍnh —* — và — biӃn đӇ tìm câu trҧ lӡi tӕt hơn. (điӅu chӍnh biӃn
KD,KP và KI đӇ đҥt đưӧc đáp ӭng tӕt hơn). Let's increase —*—*— by 2 times to see
what will happen. Hãy tăng —* —* — cӫa 2 lҫn đӇ xem nhӳng gì sӁ xҧy ra. Go back to
your m-file and multiply —*—*— by 2 and then rerun the program, you should get the
following plot: Quay trӣ lҥi tұp tin-m cӫa bҥn và nhân —* —* — lҫn lưӧt cho 2 và sau
đó chҥy lҥi chương trình, bҥn sӁ nhұn đưӧc đӗ thӏ sau đây:
To compare this graph with the graph of low-gain PID controller, you can change the
axis: So sánh biӇu đӗ này vӟi các đӗ thӏ cӫa bӝ điӅu khiӇn PID có đӝ lӧi thҩp, bҥn có thӇ
thay đәi trөc:

axis ([0 5 -.01 .01]) trӧc ([0 5 001 -. 01])

8ow we see that the percent overshoot and settling time meet the requirements of the
system. Bây giӡ chúng ta thҩy phҫn trăm đӝ vӑt lӕ và thӡi gian đáp ӭng thӓa mãn yêu
cҫu cӫa hӋ thӕng. The percent overshoot is about 5% of the input's amplitude and settling
time is 2 seconds less than 5 seconds from requirement. Phҫn trăm đӝ vӑt lӕ là khoҧng
5% đҫu vào cӫa biên đӝ và thӡi gian đáp ӭng là 2 giây ít hơn 5 giây tӯ yêu cҫu.

For this problem, it turns out that the PID design method adequately controls the system.
Đӕi vӟi vҩn đӅ này, nó quay ra rҵng các phương pháp thiӃt kӃ PID đҫy đӫ điӅu khiӇn hӋ
thӕng. This can been seen by looking at the root locus plot. ĐiӅu này có thӇ đưӧc nhìn
thҩy bҵng cách nhìn vào biӇu đӗ quӻ đҥo nghiӋm sӕ. Such a task can be achieved by
simply changing only the gains of a PID controller. Coi đây như mӝt bài tұp có thӇ thӵc
hiӋn đưӧc bӣi chӍ đơn giҧn là thay đәi đӝ lӧi cӫa mӝt bӝ điӅu khiӇn PID. Feel free to
play around with all three of the parameters,KD,KP and KI, as we suggested, but you will
most likely get the response to have either large percent overshoot or very long settling
time. O , 1  ,    *    2 1

3 We are
always interested in different ways to solve our examples; we may include your solution
in a future version of these tutorials. Tӵ do thay đәi, các tham sӕ, KD, KP và KI, như
chúng tôi đӅ nghӏ, nhưng rҩt có thӇ bҥn sӁ nhұn đưӧc đáp ӭng có phҫn trăm đӝ vӑt lӕ lӟn
cũng có thӡi gian xác lұp lâu+ 4 5  6 71   5 5 * 8 '
( 

9 : '; 5 <=
> ?3 Chúng tôi luôn quan tâm nhӳng cách
giҧi quyӃt khác nhau đӇ lҩy bí quyӃt tӕt nhҩt cho ví dө cӫa chúng ta, chúng tôi có thӇ bao
gӗm cҧ giҧi pháp cӫa bҥn cho nhӳng phiên bҧn hưӟng dүn hӑc PID sau này.