• documentation
main content

vibration control in flexible beam -凯发k8网页登录

this example shows how to tune a controller for reducing vibrations in a flexible beam.

model of flexible beam

figure 1 depicts an active vibration control system for a flexible beam.

figure 1: active control of flexible beam

in this setup, the actuator delivering the force $u$ and the velocity sensor are collocated. we can model the transfer function from control input $u$ to the velocity $y$ using finite-element analysis. keeping only the first six modes, we obtain a plant model of the form

$$ g(s) = \sum_{i = 1}^6 \frac{\alpha_i^2 s}{ s^2 2\xi w_i s w_i^2} $$

with the following parameter values.

% parameters
xi = 0.05;
alpha = [0.09877, -0.309, -0.891, 0.5878, 0.7071, -0.8091];
w = [1, 4, 9, 16, 25, 36];

the resulting beam model for $g(s)$ is given by

% beam model
g = tf(alpha(1)^2*[1,0],[1, 2*xi*w(1), w(1)^2])   ...
    tf(alpha(2)^2*[1,0],[1, 2*xi*w(2), w(2)^2])   ...
    tf(alpha(3)^2*[1,0],[1, 2*xi*w(3), w(3)^2])   ...
    tf(alpha(4)^2*[1,0],[1, 2*xi*w(4), w(4)^2])   ...
    tf(alpha(5)^2*[1,0],[1, 2*xi*w(5), w(5)^2])   ...
    tf(alpha(6)^2*[1,0],[1, 2*xi*w(6), w(6)^2]);
g.inputname = 'ug';  g.outputname = 'y';

with this sensor/actuator configuration, the beam is a passive system:

ispassive(g)

ans =
  logical
   1

this is confirmed by observing that the nyquist plot of $g$ is positive real.

nyquist(g)

lqg controller

lqg control is a natural formulation for active vibration control. the lqg control setup is depicted in figure 2. the signals $d$ and $n$ are the process and measurement noise, respectively.

figure 2: lqg control structure

first use lqg to compute the optimal lqg controller for the objective

$$ j = \lim_{t \rightarrow \infty} e \left( \int_0^t (y^2(t) 0.001 u^2(t)) dt \right) $$

with noise variances:

$$ e(d^2(t)) = 1 ,\quad e(n^2(t)) = 0.01 . $$

[a,b,c,d] = ssdata(g);
m = [c d;zeros(1,12) 1];  % [y;u] = m * [x;u]
qwv = blkdiag(b*b',1e-2);
qxu = m'*diag([1 1e-3])*m;
clqg = lqg(ss(g),qxu,qwv);

the lqg-optimal controller clqg is complex with 12 states and several notching zeros.

size(clqg)

state-space model with 1 outputs, 1 inputs, and 12 states.

bode(g,clqg,{1e-2,1e3}), grid, legend('g','clqg')

use the general-purpose tuner systune to try and simplify this controller. with systune, you are not limited to a full-order controller and can tune controllers of any order. here for example, let's tune a 2nd-order state-space controller.

c = ltiblock.ss('c',2,1,1);

build a closed-loop model of the block diagram in figure 2.

c.inputname = 'yn';  c.outputname = 'u';
s1 = sumblk('yn = y   n');
s2 = sumblk('ug = u   d');
cl0 = connect(g,c,s1,s2,{'d','n'},{'y','u'},{'yn','u'});

use the lqg criterion $j$ above as sole tuning goal. the lqg tuning goal lets you directly specify the performance weights and noise covariances.

r1 = tuninggoal.lqg({'d','n'},{'y','u'},diag([1,1e-2]),diag([1 1e-3]));

now tune the controller c to minimize the lqg objective $j$.

[cl1,j1] = systune(cl0,r1);

final: soft = 0.478, hard = -inf, iterations = 40

the optimizer found a 2nd-order controller with $j= 0.478$. compare with the optimal $j$ value for clqg:

[~,jopt] = evalgoal(r1,replaceblock(cl0,'c',clqg))

jopt =
    0.4673

the performance degradation is less than 5%, and we reduced the controller complexity from 12 to 2 states. further compare the impulse responses from $d$ to $y$ for the two controllers. the two responses are almost identical. you can therefore obtain near-optimal vibration attenuation with a simple second-order controller.

t0 = feedback(g,clqg, 1);
t1 = getiotransfer(cl1,'d','y');
impulse(t0,t1,5)
title('response to impulse disturbance d')
legend('lqg optimal','2nd-order lqg')

passive lqg controller

we used an approximate model of the beam to design these two controllers. a priori, there is no guarantee that these controllers will perform well on the real beam. however, we know that the beam is a passive physical system and that the negative feedback interconnection of passive systems is always stable. so if $-c(s)$ is passive, we can be confident that the closed-loop system will be stable.

the optimal lqg controller is not passive. in fact, its relative passive index is infinite because $1-clqg$ is not even minimum phase.

getpassiveindex(-clqg)

ans =
   inf

this is confirmed by its nyquist plot.

nyquist(-clqg)

using systune, you can re-tune the second-order controller with the additional requirement that $-c(s)$ should be passive. to do this, create a passivity tuning goal for the open-loop transfer function from yn to u (which is $c(s)$). use the "weightedpassivity" goal to account for the minus sign.

r2 = tuninggoal.weightedpassivity({'yn'},{'u'},-1,1);
r2.openings = 'u';

now re-tune the closed-loop model cl1 to minimize the lqg objective $j$ subject to $-c(s)$ being passive. note that the passivity goal r2 is now specified as a hard constraint.

[cl2,j2,g] = systune(cl1,r1,r2);

final: soft = 0.478, hard = 1, iterations = 51

the tuner achieves the same $j$ value as previously, while enforcing passivity (hard constraint less than 1). verify that $-c(s)$ is passive.

c2 = getblockvalue(cl2,'c');
passiveplot(-c2)

the improvement over the lqg-optimal controller is most visible in the nyquist plot.

nyquist(-clqg,-c2)
legend('lqg optimal','2nd-order passive lqg')

finally, compare the impulse responses from $d$ to $y$.

t2 = getiotransfer(cl2,'d','y');
impulse(t0,t2,5)
title('response to impulse disturbance d')
legend('lqg optimal','2nd-order passive lqg')

using systune, you designed a second-order passive controller with near-optimal lqg performance.

see also

| |

related topics

    网站地图