Matlab Robust Control Toolbox (1)

8/12/2019 Matlab Robust Control Toolbox (1)

1/168

April 2006 Nathan Sorensen Kedrick Black 1

Matlab Robust Control

Toolbox


2/168


Purpose

Increase Enthusiasm for Robust Controls

Learn how to simulate control algorithms

with uncertainty

Increase your knowledge in Robust

Controls


3/168


Outline What is the Robust Control Toolbox

Uncertainty

Uncertain Elements Uncertain Matricies and Systems

Manipulation of Uncertain Models

Interconnection of Uncertain Models

Model Order Reduction

Robustness Robustness and Worst Case Analysis

Parameter-Dependent Systems

MIMO Control Controller Synthesis

-synthesis

Sampled Data Systems

Gain Scheduling

Supporting Utilities

LMI Specification of Systems of LMIs LMI Characteristics

LMI Slovers

Validation of Results

Modification of Systems of LMIs


4/168


What is the Robust Control Toolbox

A collection of functions and tools that help you to analyze and design

MIMO control systems with uncertain elements

Ability to build uncertain LTI system models containing uncertain

parameters and uncertain dynamics

You get tools to analyze MIMO system stability margins and worst case

performance

Ability to simplify and reduce the order of complex models with model

reduction tools that minimize additive and multiplicative error bounds

It provides tools for implementing advanced robust control methods like H,

H2, linear matrix inequalities (LMI), and -synthesis robust control

You can shape MIMO system frequency responses and design uncertaintytolerant controllers


5/168


Modeling Uncertainty

Arises when system gains or other parameters are not precisely

known, or can vary over a given range

Examples of real parameter uncertainties include uncertain pole and

zero locations and uncertain gains

With the Robust Control Toolbox you can create uncertain LTImodels as objects specifically designed for robust control

applications


6/168


Sources of Uncertainty

Uncertainty in an system can occur in various forms and from

various sources.

Additive Uncertainty Multiplicative Uncertainty Feedback Uncertainty


7/168


Uncertain Elements

1) UComplex() is a function to define complex uncertainparameters

2) Ucomplexm() is a function for the creation of complex valueduncertain matricies.

3) Udyn() creates an unstructured uncertain dynamic systemclass, with input/output dimension specified by iosize.

4) Ultidyn() is a function to create an uncertain linear timeinveriant object where only bounds on the frequencyresponse are known.

5) Ureal() is a function to define real uncertain parameters used

in various analysis and design functions in the robust controltoolbox.


8/168


UComplex(Name,nominal value)

NameVariable name for the

uncertain parameter

Nominal Valuecenter nominal

value for the parameter

radiusparamter name to specify

a radius of uncertainty around the

nominal. Radius value should follow

the parameter specification.

percentageparameter

specifying an uncertainty percentageof the nominal for the radius. Value

should follow the parameter

specificaiton

2.5 3 3.5 4 4.5 5 5.51.5

2

2.5

3

3.5

4

4.5Sampled Complex Uncertain Parameter A

EX:A = ucomplex('A',4+3*j)

Uncertain Complex Parameter: Name

A,

Nominal Value 4+3i,

Radius 1

UComplex() is a function to define complex uncertain parameters


9/168


Ucomplexm(Name, nominal value)

NameVariable name for the

uncertain parameter

Nominal Valuecenter nominal value

for the parameter

WL,WR WL and WR are square,

invertible, and weighting matrices that

quantify the size and shape of the ball

of matrices represented by this object.

Each parameter name is to be followed

by the respective matrix. (Assumed to

be the identity if left out.)

AutoSimplify parameter to set the

type of simplification to be done on

outputs from the uncertain matrix.

Setting values are off, basic, and full.

0 0.05 0.1 0.15 0.2 0.250

2

4

6

8Sampled F(1,1) - F(1,1).NominalValue

0 0.05 0.1 0.15 0.2 0.250

5

10Sampled F(2,3) - F(2,3).NominalValue

EX:

F = ucomplexm('F',[1 2 3;4 5 6],'WL',diag([.1 .3]),...

'WR',diag([.4 .8 1.2]))

Uncertain Complex Matrix: Name F, 2x3

Ucomplexm() is a function for the creation of complex valueduncertain matricies.


10/168


n = udyn('name',iosize)

Udyn() creates an unstructured uncertain dynamic system class,with input/output dimension specified by iosize.

Input:

Name Variable name for output

Iosize - input/output dimension

specification. [Input,Output]

Output:

N - an unstructured uncertain

dynamic system class

EX:

N = udyn('N',[2 3])

Uncertain Dynamic System:Name N, size 2x3

size(N)

ans =

2 3

get(N)

Name: 'N'NominalValue: [2x3 double]

AutoSimplify: 'basic'


11/168


ultidyn('Name',iosize)Ultidyn() is a function to create an uncertain linear time inveriant

object where only bounds on the frequency response are known.

Parameters Include:

Namevariable name

Iosizethe size of [input, output]

GainBounded upper bound on themagnitude of the response.

PositiveReal lower bound on the

real part

Bound Specifies the actual bound

for the frequency response.

SampleStateDim Specifies the state

dimension to be used by usample().

AutoSimplify specifies the amount of

result simplification.

EX:B = ultidyn('B',[1 1],'Type','PositiveReal','Bound',2.5)

B.SampleStateDim = 3;

nyquist(usample(B,30))

Uncertain PositiveReal LTI Dynamics: Name B, 1x1, M+M' >=

2*(2.5)

-10 0 10 20 30 40 50 60 70 80-40

-30

-20

-10

0

10

20

30

40Nyquist Diagram

Real Axis

ImaginaryA

xis


12/168


Ureal(Name,Nominal Value)

Ureal() is a function to define real uncertain parameters used in variousanalysis and design functions in the robust control toolbox.

EX:

c = ureal('c',4,'Mode','Range','Percentage',25);

Name: 'c'NominalValue: 4

Mode: 'Range'

Range: [3 5]

PlusMinus: [-1 1]

Percentage: [-25 25]

AutoSimplify: 'basic'

Parameters Include:

Namevariable name

Nominal Value

Mode Choose uncertainty type

amongst:

Percentage percentage area

around the nominal.

Range a given interval with

the nominal inside.

PlusMinus add and subtract

from nominal

Autosimplify choose amount of

simplification for result.


13/168


Uncertain Matricies and Systems

1. Umat() Uncertain matrices2. Uss() creates uncertain state space objects given the

uncertain state space system matricies a,b,c,d.

3. Ufrd() is a function to create an uncertain frequency

response model which often arises when convertinguncertain state space objects to frequency response

objects.

4. Randatom() generates a 1-by-1 type uncertain object.

5. Randumat() Generate random uncertain umat objects6. Randuss() Generate stable, random uss objects


14/168


h = umat(m)

Uncertain matrices are usually created bymanipulation of uncertain atoms (ureal,ucomplex, ultidyn, etc.), double matrices, andother uncertain matrices

The command umat is rarely used There are two situations where it may be useful

If M is a double, then H = umat(M) recasts M asan uncertain matrix (umat object) without any

uncertainties In both cases, simplify(H,'class') is the same as

M


15/168


uss(a,b,c,d)

Uss() creates uncertain state space objects given the uncertain statespace system matricies a,b,c,d.

Parameters Include:

A,B,C,Dumat or other uncertain state

space parameters to describe thesystem.

Tssample time for a discrete time

state space object.

RefSysif a refrence uss is given, the

parameters of that object are included.

Note: if only one matrix is include, the

function assumes that it represents D

and a static gain matrix.

EX:

p1 = ureal('p1',5,'Range',[2 6]);

p2 =

ureal('p2',3,'Plusminus',0.4);

A = [-p1 0;p2 -p1];

B = [0;p2];

C = [1 1];

usys = uss(A,B,C,0);


16/168


ufrd(usys,frequency)

Ufrd() is a function to create an uncertain frequency responsemodel which often arises when converting uncertain state space

objects to frequency response objects.

-40

-30

-20

-10

0

Magnitude(dB)

10-2

10-1

100

101

102

-180

-135

-90

-45

0

45

Phase(deg)

Bode Diagram

Frequency (rad/sec)

Parameters Include:

Nameuncertain system

FrequencyRange of frequencies for ufrd

model.

Units specify units:

rad/s defaulthz

EX:

p1 = ureal('p1',5,'Range',[2 6]);

p2 = ureal('p2',3,'Plusminus',0.4);

p3 = ultidyn('p3',[1 1]);

Wt = makeweight(.15,30,10);

A = [-p1 0;p2 -p1];

B = [0;p2];

C = [1 1];

usys = uss(A,B,C,0)*(1+Wt*p3);

usysfrd = ufrd(usys,logspace(-2,2,60));

bode(usysfrd,'r',usysfrd.NominalValue,'b+')


17/168


A = randatom(Type)

Generate random uncertain atom objects

generates a 1-by-1 type uncertain object

Valid values for Type include 'ureal','ultidyn', 'ucomplex', and 'ucomplexm'

Examplexr = randatom('ureal')

Uncertain Real Parameter: Name BMSJA, NominalValue -6.75,

Range [-7.70893 -1.89278]


18/168


um = randumat(ny,nu)

Generate random uncertain umat objects generates an uncertain matrix of size ny-by-nu

andumat randomly selects from uncertain atoms of type 'ureal',

'ultidyn', and 'ucomplex

Example

The following statement creates the umat uncertain object x1 of size 2-

by-3. Note that your result can differ because a random seed is used

x1 = randumat(2,3)

UMAT: 2 Rows, 3 Columns

ROQAW: complex, nominal = 9.92+4.84i, radius = 0.568, 1

occurrence

UEPDY: real, nominal = -5.81, variability = [-1.986810.133993], 3 occurrences

VVNHL: complex, nominal = 5.64-6.13i, radius = 1.99, 2

occurrences


19/168


usys = randuss(n,p,m) Generate stable, random uss objects

generates an nth order uncertain continuous-time system with poutputs and m inputs

ExampleThe statement creates a fifth order, continuous-time uncertain system s1 of

size 2-by-3. Note your display can differ because a random seed is used.

s1 = randuss(5,2,3)USS: 5 States, 2 Outputs, 3 Inputs, Continuous System

CTPQV: 1x1 LTI, max. gain = 2.2, 1 occurrence

IGDHN: real, nominal = -4.03, variability = [-3.74667 22.7816]%, 1 occurrence

MLGCD: complex, nominal = 8.36+3.09i, +/- 7.07%, 1 occurrence

OEDJK: complex, nominal = -0.346-0.296i, radius = 0.895, 1 occurrence


20/168


Manipulation of Uncertain Models

1. isuncertain() Checks whether argument is an uncertainclass type

2. simplify() performs model-reduction-like techniques todetect and eliminate redundant copies of uncertainelements

3. usample() substitutes N random samples of the uncertain

objects in A, returning a certain array of size [size(A) N]4. usubs() used to substitute a specific value for an uncertain

element of an uncertain object.

5. gridureal() Grid ureal parameters uniformly over their range

6. lftdata() Decompose uncertain objects into fixed normalized

and fixed uncertain parts7. Ssbal() yields a system whose input/output and uncertain

properties are the same as usys, a uss object.


21/168


B = isuncertain(A) Checks whether argument is an uncertain class type (checks the

class)

does not actually verify that the input argument is truly uncertain

Returns true if input argument is uncertain, false otherwise

Uncertain classes are umat, ufrd, uss, ureal, ultidyn, ucomplex,ucomplexm, and udyn

Exampleisuncertain(rand(3,4))

ans =

0

isuncertain(ureal('p',4))

ans =

1

isuncertain(rss(4,3,2))ans =

0

isuncertain(rss(4,3,2)*[ureal('p1',4) 6;0 1])

ans =

1


22/168


B = simplify(A) Simplify representations of uncertain objects

performs model-reduction-like techniques to detect and eliminate

redundant copies of uncertain elements

After reduction, any uncertain element which does not actually affect

the result is deleted from the representation

ExampleCreate a simple umat with a single uncertain real parameter. Select specific elements, note that result remains

in class umat. Simplify those same elements, and note that class changes.

p1 = ureal('p1',3,'Range',[2 5]);

L = [2 p1];

L(1)


L(2)


p1: real, nominal = 3, range = [2 5], 1 occurrence

simplify(L(1))

ans =

2

simplify(L(2))

Uncertain Real Parameter: Name p1, NominalValue 3, Range [2 5]


23/168


B = usample(A,N) substitutes N random samples of the uncertain objects in A,

returning a certain array of size [size(A) N]

ExampleA = ureal('A',5);

Asample = usample(A,500);

size(A)

ans =

1 1size(Asample)

ans =

1 1 500

class(Asample)

ans =

double

hist(Asample(:))


24/168


B = usubs(M,StrucArray)

Substitute given values for uncertainelements of uncertain objectsExamplep = ureal('p',5);

m = [1 p;p^2 4];

size(m)

ans =2 2

m1 = usubs(m,'p',5)

m1 =

1 5

25 4

NamesValues.p = 5;

m2 = usubs(m,NamesValues)

m2 =

1 525 4

m1 - m2

ans =

0 0

0 0


25/168


B = gridreal(A,N) Grid ureal parameters uniformly over their range

substitutes N uniformly spaced samples of the uncertain real parameters in A The N samples are generated by uniformly gridding each ureal in A across its

range

Examplegamma = ureal('gamma',4);

tau = ureal('tau',.5,'Percentage',30);

p = tf(gamma,[tau 1]);

KI =

1/(2*tau.Nominal*gamma.Nominal);

c = tf(KI,[1 0]);

clp = feedback(p*c,1);

subplot(2,1,1);

step(gridureal(p,20),6)

title('Open-loop plant step responses')

subplot(2,1,2);

step(gridureal(clp,20),6)


26/168


[M,Delta] = lftdata(A) Decompose uncertain objects into fixed normalized and fixed uncertain parts

partially decompose an uncertain object into an uncertain part and a normalizeduncertain part

Uncertain objects (umat, ufrd, uss) are represented as certain objects infeedback with block-diagonal concatenations of uncertain elements

separates the uncertain object A into a certain object M and a normalizeduncertain matrix Delta such that A is equal to lft(Delta,M), as shown below

Examplep1 = ureal('p1',-3,'perc',40);p2 = ucomplex('p2',2);

A = [p1 p1+p2;1 p2];

[M,Delta] = lftdata(A);

simplify(A-lft(Delta,M))

ans =

0 0

0 0

M

M =

0 0 1.0954 1.0954

0 0 0 1.0000

1.0954 1.0000 -3.0000 -1.0000

0 1.0000 1.0000 2.0000


27/168


usysout = ssbal(usys,Wc)Ssbal() yields a system whose input/output and uncertain

properties are the same as usys, a uss object.

Input:

Usys - a continuous-time

uncertain system

Wc - the critical frequency for thebilinear prewarp transformation

from continuous time to discrete

time. (Default is 1)

Output:

Usysout - a system whose

input/output and uncertainproperties are the same as usys,

a uss object. (The numerical

conditioning of usysout is usually

better than that of usys.)

EX:

p2=ureal('p2',-17,'Range',[-19 -11]);

p1=ureal('p1',3.2,'Percentage',0.43);

A = [-12 p1;.001 p2];

B = [120 -809;503 24];C = [.034 .0076; .00019 2];

usys = ss(A,B,C,zeros(2,2))

USS: 2 States, 2 Outputs, 2 Inputs, Continuous System

p1: real, nominal = 3.2, variability = [-0.43 0.43]%, 1 occurrence

p2: real, nominal = -17, range = [-19 -11], 1 occurrence

usysout = ssbal(usys)

USS: 2 States, 2 Outputs, 2 Inputs, Continuous System

p1: real, nominal = 3.2, variability = [-0.43 0.43]%, 1

occurrence

p2: real, nominal = -17, range = [-19 -11], 1 occurrence


28/168


ndist = actual2normalized(A,V)

the normalized distance between the

nominal value of the uncertain atom A and

the given value V

If V is an array of values, then ndist is an

array of normalized distances


29/168


avalue = normalizedactual2(A,NV)

Convert the value for an atom in normalized coordinates to the

corresponding actual value

converts the value for atom in normalized coordinates, NV, to the

corresponding actual value

Examplea = ureal('a',3,'range',[1 5]);actual2normalized(a,[1 3 5])

ans =

-1.0000 -0.0000 1.0000

normalized2actual(a,[-1 1])

ans =

1.0000 5.0000

normalized2actual(a,[-1.5 1.5])ans =

0.0000 6.0000


30/168


umatout =

stack(arraydim,umat1,umat2,...)

Construct an array by stacking uncertain matrices, models, or arrays

along array dimensions of an uncertain array

All models must have the same number of columns and rows

Example

Consider usys1 and usys2, two single-input/single-output ussmodels:

zeta = ureal('zeta',1,'Range',[0.4 4]);

wn = ureal('wn',0.5,'Range',[0.3 0.7]);

P1 = tf(1,[1 2*zeta*wn wn^2]);

P2 = tf(zeta,[1 10]);

You can stack along the first dimension to produce a 2-by-1 uss array.

stack(1,P1,P1)

USS: 2 States, 1 Output, 1 Input, Continuous System [array, 2 x 1]

wn: real, nominal = 0.5, range = [0.3 0.7], 3 occurrences

zeta: real, nominal = 1, range = [0.4 4], 1 occurrence


31/168


B = squeeze(A)

Remove singleton dimensions for umatobjects

returns an array B with the same elements

as A but with all the singleton dimensionsremoved

A singleton is a dimension such that

size(A,dim)==1 2-D arrays are unaffected by squeeze sothat row vectors remain rows


32/168


Interconnection of Uncertain

Models

1. Imp2exp() transforms a linear constraint between

variables into an explicit input/output relationship

2. Sysic Builds interconnections of certain and uncertain

matrices and systems

3. Iconnect Builds complex interconnections of uncertain


4. Icsignal Specifies signal constraints described by the

interconnection of components


33/168


B = imp2exp(A,yidx,uidx)

transforms a linear constraint between variables Y and Uof the form A(:,[yidx;uidx])*[Y;U] = 0 into an explicitinput/output relationship Y = B*U

The vectors yidx and uidx refer to the columns (inputs) of

A as referenced by the explicit relationship for B The constraint matrix A can be a double, ss, tf, zpk and

frd object as well as an uncertain object, including umat,uss and ufrd

The result B will be of the same class


34/168


sysout = sysic Build interconnections of certain and uncertain


requires that 3 variables with fixed names bepresent in the calling workspace:systemnames, inputvarand outputvar

systemnamesis a char containing the namesof the subsystems that make up theinterconnection

nputvaris a char, defining the names of the

external inputs to the interconnection outputvaris a char, describing the outputs ofthe interconnection

Also requires that for every subsystem namelisted in systemnames, a correspondingvariable, input_to_ListedSubSystemNamemust exist in the calling workspace

This variable is similar to outputvar - it definesthe input signals to this particular subsystem aslinear combinations of individual subsystem'soutputs and external inputs


35/168


H = iconnect Create empty iconnect (interconnection) objects

Interconnection objects (class iconnect) are an alternative to sysic,

and are used to build complex interconnections of uncertainmatrices and systems

An iconnect object has 3 fields to be set by the user, Input, Outputand Equation

Input and Output are icsignal objects, while Equation is a cell-arrayof equality constraints (using equate) on icsignal objects

the System property is the input/output model, implied by theconstraints in Equation relating the variables defined in Input andOutput


36/168


v = icsignal(n,'name')

Create an icsignal object

creates an icsignal object of length n, which is a

symbolic column vector

used with iconnect objects to specify signal constraints

described by the interconnection of components

internal name identifiers given by the character string

argument name


37/168


Model Order Reduction and

Application

Complex models are not always required for

good control

Optimization methods generally tend to produce

controllers with at least as many states as theplant model

The Robust Control Toolbox offers you an

assortment of model-order reduction commands

Less complex low-order approximations to plant

and controller models


38/168


Model Order Reduction Tools

The Robust Control Toolbox has various controller synthesistools outlined below:

1. reduce() returns a reduced order model

2. balancmr() Balanced model truncation via square root method

3. bstmr() Balanced stochastic model truncation (BST) via Schur method

4. hankelmr() Hankel Minimum Degree Approximation (MDA) without

balancing

5. hankelsv() Computes Hankel singular values for stable/unstable or

continuous/discrete system


39/168


Model Order Reduction Tools cont:

6. modreal() returns a set of state-space LTI objects in modal form

7. ncfmr() Balanced model truncation for normalized coprime factors.

8. shurmr() Balanced model truncation via Schur method

9. slowfast() computes the slow and fast modes decompositions of a

system

10. stabproj() computes the stable and antistable projections of a minimalrealization

11. imp2ss()produces an approximate state-space realization of a given

impulse response


40/168


GRED = reduce(G,order)

Returns a reduced order model of G Groups all the Hankel SV based model reduction

routines

Hankel singular values of a stable system indicate therespective state energy of the system.

In many cases, the additive error methodGRED=reduce(G,ORDER) is adequate to provide agood reduced order model.

for systems with lightly damped poles and/or zeros, amultiplicative error method (namely,GRED=reduce(G,ORDER,'ErrorType','mult')) thatminimizes the relative error between G and GRED tendsto produce a better fit.


41/168


GRED = balancmr(G,order)

balanced truncation model reduction for

continuous/discrete & stable/unstable plant.

With only one input argument G, the function will show a

Hankel singular value plot of the original model and

prompt for model order number to reduce.


42/168


GRED = bstmr(G,order)

Balanced stochastic truncation (BST) model reduction

for continuous/discrete & stable/unstable plant.

bstmr returns a reduced order model GRED of G

With only one input argument G, the function will show a

Hankel singular value plot of the phase matrix of G and

prompt for model order number to reduce

This method guarantees an error bound on the infinity

norm of the multiplicative || GRED-1(G-GRED) || or

relative error || G-1(G-GRED) || for well-conditionedmodel reduction problems


43/168


GRED = hankelmr(G,order)

Optimal Hankel norm approximation forcontinuous/discrete & stable/unstable plant

hankelmr returns a reduced order model GRED of G

With only one input argument G, the function will show aHankel singular value plot of the original model andprompt for model order number to reduce

This method guarantees an error bound on the infinitynorm of the additive error || G-GRED || for well-conditioned model reduced problems


44/168


hankelsv(G)

Compute Hankel singular values for stable/unstable or continuous/discrete

system

draws a bar graph of the Hankel singular values such as the following:


45/168


[G1,G2] = modreal(G,cut) State-space modal truncation/realization

returns a set of state-space LTI objects G1 and G2 inmodal form given a state-space G and the model size ofG1, cut

The modal form realization has its A matrix in blockdiagonal form with either 1x1 or 2x2 blocks. The realeigenvalues will be put in 1x1 blocks and complexeigenvalues will be put in 2x2 blocks. These diagonalblocks are ordered in ascending order based oneigenvalue magnitudes

G can be stable or unstable


46/168


GRED = ncfmr(G,order)

balanced truncation model reduction for normalizedcoprime factors of continuous/discrete & stable/unstableG

ncfmr returns a reduced order model GRED formed by aset of balanced normalized coprime factors

With only one input argument G, the function will show aHankel singular value plot of the original model andprompt for model order number to reduce

The left and right normalized coprime factors are definedas:


47/168


GRED = schurmr(G,order)

Schur balanced truncation model reduction forcontinuous/discrete & stable/unstable plant

schurmr returns a reduced order model GRED ofG

With only one input argument G, the function willshow a Hankel singular value plot of the originalmodel and prompt for model order number toreduce

This method guarantees an error bound on theinfinity norm of the additive error || G-GRED || forwell-conditioned model reduced problems


48/168


G1,G2] = slowfast(G,cut)

State-space slow-fast decomposition

computes the slow and fast modes decompositions

of a system G(s) such that: fs sGsGsG

)

,

,

,

(: 11111 DCBAsG s )

,

,

,

(: 22222 DCBAsG f


49/168


[G1,G2,m] = stabproj(G)

State-space stable/anti-stable decomposition

stabproj computes the stable and antistable projections

of a minimal realization G(s) such that:

[ b d t tb d h ]


50/168


[a,b,c,d,totbnd,hsv] =

imp2ss(y,ts,nu,ny,tol) System identification via impulse response

The function imp2ss produces an approximate state-spacerealization of a given impulse response imp=mksys(y,t,nu,ny,'imp');

A continuous-time realization is computed via the inverse Tustintransform if t is positive; otherwise a discrete-time realization is

returned In the SISO case the variable y is the impulse response vector; in the

MIMO case y is an N+1-column matrix containing N + 1 timesamples of the matrix-valued impulse response H0, ..., HN of an nu-input, ny-output system stored row-wise.

The variable tol bounds the H norm of the error between theapproximate realization (a, b, c, d) and an exact realization of y

The inputs ts, nu, ny, tol are optional; if not present they default to thevalues ts = 0, nu = 1, ny = (number of rows of y)/nu, tol =1.01sigmabar1

R b t d W t C


51/168


Robustness and Worst Case

Analysis To be robust, your control system should meet your stability and performance

requirements for all possible values of uncertain parameters

Monte Carlo parameter sampling via usamplecan be used for this purpose, but

Monte Carlo methods are inherently hit or miss

The Robust Control Toolbox gives you a powerful assortment of robustness analysis

commands that let you directly calculate upper and lower bounds on worst-case

performance without random sampling:


52/168


Performance Analysis

The hyperbola is used to define the performance margin.

Systems whose performance degradation curve intersects high on the hyperbola curve

represent "non-robustly-performing systems" in that very small deviations of the uncertainelements from their nominal values can result in very large system gains.

Conversely, an intersection low on the hyperbola represent "robustly-performing systems."


53/168


Small Gain Theorem

When the plant modeling uncertainty is not too big, you can design high-gain,

high-performance feedback controllers. High loop gains significantly larger than 1

in magnitude can attenuate the effects of plant model uncertainty and reduce the

overall sensitivity of the system to plant noise.

But if your plant model uncertainty is so large that you do not even know the sign

of your plant gain, then you cannot use large feedback gains without the risk that

the system will become unstable. Thus, plant model uncertainty can be afundamental limiting factor in determining what can be achieved with feedback.

The Small Gain Theorem asserts that the overall system gain must therefore be

kept below 1 to assure stability.

R b t d W t C


54/168



Performance ToolsThe Robust Control Toolbox has various controller synthesistools outlined below:

1. cpmargin() calculates the normalized coprime factor/gap metric robust stability of the

multivariable feedback loop consisting of C in negative feedback with P.

2. Gapmetric() calculates upper bounds on the gap and nugap metric between systems

3. loopmargin() analyzes the multivariable feedback loop consisting of the loop transfer

matrix.

4. loopsens() Creates a Struct, loops, whose fields contain the multivariable sensitivity,

complementary and open-loop transfer functions.

5. mussv() calculates upper and lower bounds on the structured singular value, or , for

a given block structure.

6. Mussvextract() is used to extract the compressed information within muinfo into a

readable form.

R b t d W t C


55/168



Performance Tools cont:

7. ncfmargin() Calculates the normalized coprime stability margin of the

plant-controller feedback loop

8. popov() uses the Popov criterion to test the robust stability of dynamical

systems with possibly nonlinear and/or time-varying uncertainty.

9. robustperf() Calculates the robust performance margin of an uncertainmultivariable system.

10. robuststab() Calculate robust stability margins of an uncertain

multivariable system.

11. robopt() Creates an options object for use with robuststab and robustperf

12.wcnorm() Calculate the worst-case norm of an uncertain matrix

Rob stness and Worst Case


56/168



Performance Tools cont:13. wcgain() Calculates bounds on the worst-case gain of an uncertain system

14. wcgopt() creates a wcgain, wcsens and wcmargin options object called options in

which specified properties have specific values.

15. wcmargin() calculates the combined worst-case input and output loop-at-a-time

gain/phase margins of the feedback loop

16. wcsens() Calculate the worst-case sensitivity and complementary sensitivity

functions of a plant-controller feedback loop

[MARG FREQ]


57/168


[MARG,FREQ] =

cpmargin(P,C,TOL)Cpmargin() calculates the normalized coprime factor/gap metric robust stability ofthe multivariable feedback loop consisting of C in negative feedback with P.

Input Parameters:PLTI plant

C only feedback controller

Tol - specifies a relative accuracy for

calculating the normalized coprime

factor/gap metric robust stability margin

Output Parameters:

Marg - contains upperand lower

bound for the normalized coprime

factor/gap metric robust stability

margin

Freq - the frequency associated withthe upper bound


58/168


[gap,nugap] = gapmetric(p0,p1,tol)

Gapmetric() calculates upper bounds on the gap and nugap metric

between systems p0 and p1.

Input:

P0,P1plants of the same size

Toltolerance for the gap metric (default

is .001)

EX:

p1 = tf(1,[1 -0.001]);

p2 = tf(1,[1 0.001]);

[g,ng] = gapmetric(p1,p2)

K = 1;

H1 = loopsens(p1,K);

H2 = loopsens(p2,K);subplot(2,2,1); bode(H1.Si,'-',H2.Si,'--');

subplot(2,2,2); bode(H1.Ti,'-',H2.Ti,'--');

subplot(2,2,3); bode(H1.PSi,'-',H2.PSi,'--');

subplot(2,2,4); bode(H1.CSo,'-',H2.CSo,'--');

g = 0.0029

ng = 0.0020

-100

-50

0

Magnitude(dB)

10-5

100

0

90

180

Phase(deg)

Bode Diagram

Frequency (rad/sec)

-50

0

50

Magnitude(dB)

10-2

100

102

-90

-45

0

Phase(deg)

Bode Diagram

Frequency (rad/sec)

-50

0

50

Magnitude(dB)

10-2

100

102

-90

-45

0

Phase(deg)

Bode Diagram

Frequency (rad/sec)

-100

-50

0

Magnitude(dB)

10-5

100

0

90

180

Phase(deg)

Bode Diagram

Frequency (rad/sec)

Output:

Gapgap metric valueNugapnugap metric value

(For gap or nugap, a value close to 0 means

the plants are far apart and a value close to 1

means they are close together.)

loopmargin(L)


59/168


loopmargin(L)

[SM, DM, MM] = Loopmargin() is a tool to

determine the closed loop margins for an

uncertain system.

Outputs include:

SMA structure containing the nominal

system margins.

DMalso called disk margin. Describes

the disk of deviations from the nominalsystem.

MMestablishes guaranteed bounds on

the system with variations from all input

channels.

loopsens(P C)


60/168


loopsens(P,C)Loopsens() creates a structure which contains the multivariable

sensitivity, complementary and open-loop transfer functions.

Structure Output Fields:Poles - Closed-loop poles. NaN for

frd/ufrd objects.

Stable - 1 if nominal closed loop is

stable, 0 otherwise. NaN for frd/ufrd

objects.

Si - Input-to-plant sensitivity functionTi - Input-to-plant complementary

sensitivity function

Li - Input-to-plant loop transfer function

So - Output-to-plant sensitivity function

To - Output-to-plant complementary


Lo - Output-to-plant loop transfer

function

PSi - Plant times input-to-plant


CSo - Compensator times output-to-

plant sensitivity function

EX:

int = tf(1,[1 0]);

addunc = ultidyn('addunc',[1 1],'Bound',0.2);

uncint = int + addunc;int3 = blkdiag(int,uncint,int);

p = [1 .2 .5;-.5 0 1;1 0 0;0 1 0]*int3;

gain = ureal('gain',0.9, 'Range',[-3 1.5]);

c = [.02 .3 0 0;1 -.3 .32 gain; 0 1 -.2 .1];

loops = loopsens(p,c)

[bounds muinfo] =


61/168


[bounds,muinfo] =

mussv(M,BlockStructure)Mussv() calculates upper and lower bounds on the structured singular value, or ,for a given block structure.

Input:

M - is a double or a frd object

BlockStructure - a matrix specifying the

perturbation block structure consistingof 2 rows and as many columns as

uncertainty blocks.

Output:

Boundsupper and lower bounds on

the mu value of the system.

Muinfoa structure containing

additional information

EX:

M = randn(5,5) + sqrt(-1)*randn(5,5);

F = randn(2,5) + sqrt(-1)*randn(2,5);

BlockStructure = [-1 0;-1 0;1 1;2 0];

[ubound,Q] =

mussv(M,F,BlockStructure);

points completed (of 1) ... 1

bounds = mussv(M,BlockStructure);

optbounds =

mussv(M+Q*F,BlockStructure,'C5');

[optbounds(1) ubound]1.5917 1.5925

[bounds(1) bounds(2)]

3.8184 3.7135

[VDelta VSigma VLmi] =


62/168


[VDelta,VSigma,VLmi] =

mussvextract(muinfo)Mussvextract() is used to extract the compressed information withinmuinfo into a readable form.

Input:

Muinfoa variable returned by

mussv() with information

Ouput:

VDeltaused to verify the lower

bound

VSigma a structure of

information used to verify the

Newlin/Young upper bound

VLmia structure of information

used to verify the LMI upper

bound

EX:M = randn(4,4) + sqrt(-1)*randn(4,4);

BlockStructure = [1 1;1 1;2 2];

[bounds,muinfo] = mussv(M,BlockStructure);

[VDelta,VSigma,VLmi] = mussvextract(muinfo);


63/168


[marg,freq] = ncfmargin(P,C,tol)Ncfmargin() calculates the normalized coprime factor/gap metric

robust stability margin b(P, C), marg, of the multivariable

feedback loop consisting of C in negative feedback with P.

Input:

PLTI plant model

CCompensator in the feedback path

Toltolerance for the ncfmargin must

be between .00001 and .01

Output:

Marg - the normalized coprime

factor/gap metric robust stability marginb(P, C)

Freqdestabilizing frequency

EX:

x = tf(4,[1 0.001]);

clp1 = feedback(x,1);

clp2 = feedback(x,10);

[marg1,freq1] = ncfmargin(x,1);

[marg2,freq2] = ncfmargin(x,10);

marg1 = 0.7071

freq1 = Inf

marg2 = 0.0995

freq2 = Inf


64/168


[t,P,S,N] = popov(sys,delta,flag)

Perform the Popov robust stability test

uses the Popov criterion to test the robust

stability of dynamical systems with

possibly nonlinear and/or time-varyinguncertainty

The uncertain system must be described

as the interconnection of a nominal LTIsystem sys and some uncertainty delta

[perfmarg perfmargunc Report] =


65/168


[perfmarg,perfmargunc,Report] =

robustperf(sys)Robustperf() is a tool to determine the robust performance marginwhich sets bounds on the robustness of a nominally stable system

to given uncertainty.

Structure Output Fields:

Perfmargperformance margin: lower

bound, upper bound, and critical

frequency.

Perfmarguncstructure of values of

critical uncertain elements of the

system.

ReportA text description of therobustness analysis.

EX:

P = tf(1,[1 0]) + ultidyn('delta',[1 1],'bound',0.4);

BW = 0.8;

K = tf(BW,[1/(25*BW) 1]);

S = feedback(1,P*K);

[perfmargin,punc] = robustperf(S);

perfmargin =

UpperBound: 7.4305e-001

LowerBound: 7.4305e-001

CriticalFrequency: 5.3096e+000

Note: Output may not contain true critical frequency

because of the assigned frequency range over which the

function operates. For limitations, see the function

definition in the matlab help.

[stabmarg destabunc Report] =


66/168


[stabmarg,destabunc,Report] =

robuststab(sys)Robuststab() is used to determine the robust stability margin for anominally stable uncertain system up to the closest instability from the

stable nominal.


Stabmargrobust stability margin: lower

bound, upper bound, destabilizing frequency.Destabuncstructure of uncertain values

closest to the nominal that cause instability.

Reporttext description of the stability

analysis

EX:

P = tf(4,[1 .8 4]);

delta = ultidyn('delta',[1 1],'SampleStateDim',5);

Pu = P + 0.25*tf([1],[.15 1])*delta;

C = tf([1 1],[.1 1]) + tf(2,[1 0]);

S = feedback(1,Pu*C);

[stabmarg,destabunc,report,info] = robuststab(S);

report =

Uncertain System is NOT robustly stable to modeled uncertainty.

-- It can tolerate up to 81.8% of modeled uncertainty.

-- A destabilizing combination of 81.8% the modeled uncertainty

exists, causing an instability at 9.13 rad/s.

-- Sensitivity with respect to uncertain element ...'delta' is 100%. Increasing 'delta' by 25% leads to a 25% decrease

in the margin.

Note: Output may not contain all unstablefrequencies because of the assigned frequency

range over which the function operates. For

limitations, see the function definition in the matlab

help.

opts =


67/168


opts =

robopt('name1',value1,'name2',value2,...)

Robopt() creates an options object for use with robuststab androbustperf.

EX:

opt = robopt

Property Object Values:

Display: 'off'

Sensitivity: 'on'

VaryUncertainty: 25

Mussv: 'sm9'

Default: [1x1 struct]

Meaning: [1x1 struct]


68/168


[maxnorm,wcu] = wcnorm(m)Wcnorm() determines the maximum norm over all allowable values of

the uncertain elements and is referred to as a worst-case norm

analysis.

Input:

M - a umat or a uss

Output:

Maxnorma structure with fields:

Wcu - a structure that includes values of

uncertain elements and maximizes the

matrix norm

EX:

a=ureal('a',5,'Range',[4 6]);

b=ureal('b',2,'Range',[1 3]);

b=ureal('b',3,'Range',[2 10]);

c=ureal('c',9,'Range',[8 11]);

d=ureal('d',1,'Range',[0 2]);M = [a b;c d];

Mi = inv(M);

[maxnormM] = wcnorm(M)

maxnormM =

LowerBound: 14.7199

UpperBound: 14.7327

[maxnormMi] = wcnorm(Mi)

maxnormMi =

LowerBound: 2.5963

UpperBound: 2.5979

[maxgain maxgainunc] =


69/168


[maxgain,maxgainunc] =

wcgain(sys)Wcgain() calculates the worst case gain frequency response of agiven system due to uncertain elements. Pointwise-in-frequency

analysis creates a response curve for the system.


Maxgainmaximum gain: lower

bound, upper bound, critical frequency.Maxgainuncstructure containing

uncertain elements that maximize the

gain.

Options set in wcopt():

Pointwise-in-frequency- creates a

response curve for the system.Peak-over-frequency computes the

largest gain over all freqencies.

EX:

P = tf(1,[1 0]) + ultidyn('delta',[1 1],'bound',0.4);

BW1 = 0.8;

K1 = tf(BW1,[1/(25*BW1) 1]);S1 = feedback(1,P*K1);

BW2 = 2.0;

K2 = tf(BW2,[1/(25*BW2) 1]);

S2 = feedback(1,P*K2);

[maxgain1,wcunc1] = wcgain(S1);

maxgain1 =

LowerBound: 1.5070e+000

UpperBound: 1.5080e+000CriticalFrequency: 5.3096e+000

Note: Output may not contain all unstable frequencies because of the

assigned frequency range over which the function operates. For

limitations, see the function definition in the matlab help.

options =


70/168


options =

wcgopt('name1',value1,'name2',value2,...)Wcgopt() creates a wcgain, wcsens and wcmargin options object

called options in which specified properties have specific values.

EX:

opt = wcgopt('MaxTime',10000,'Sensitivity','off')

Property Object Values:

Sensitivity: 'off'

LowerBoundOnly: 'off'

FreqPtWise: 0ArrayDimPtWise: []

VaryUncertainty: 25

Default: [1x1 struct]

Meaning: [1x1 struct]

AbsTol: 0.0200

RelTol: 0.0500

MGoodThreshold: 1.0400

AGoodThreshold: 0.0500

MBadThreshold: 20ABadThreshold: 5

NTimes: 2

MaxCnt: 3

MaxTime: 10000


71/168


[wcmargi,wcmargo] = wcmargin(L)

Wcmargin() describes a disk within with the nominal gain margin and phase

margin are stable for an uncertain system.

Output Structure Fields:

Wcmargicontains gain margin

bound, phase margin in degrees,

frequency associate with worst case,

and a structure containing the

sensitivity to all uncertain elements.Wcmargosame structure as

wcmargi but gives single loop values

for each.

EX:

a = [0 10;-10 0];

b = eye(2);

c = [1 8;-10 1];

d = zeros(2,2);

G = ss(a,b,c,d);K = [1 -2;0 1]; ingain1 = ureal('ingain1',1,'Range',[0.97 1.06]);

b = [ingain1 0;0 1];

Gunc = ss(a,b,c,d);

unmod = ultidyn('unmod',[2 2],'Bound',0.08);

Gmod = (eye(2)+unmod)*Gunc;

Gmodg = ufrd(Gmod,logspace(-1,3,60));

[wcmi,wcmo] = wcmargin(Gmodg,K);

wcmi(1) =GainMargin: [0.3613 2.7681]

PhaseMargin: [-50.2745 50.2745]

Frequency: 0.1000

Sensitivity: [1x1 struct]

t (L)


72/168


wcst = wcsens(L)Wcsens() determines the worst case sensitivity of a system to

various input and disturbance parameters in an uncertain system L.

Output Structure Fields:

Si - Worst-case input-to-plant sensitivity

function

Ti - Worst-case input-to-plant complementary


So - Worst-case output-to-plant sensitivityfunction

To - Worst-case output-to-plant

complementary sensitivity function

PSi - Worst-case plant times input-to-plant


CSo - Worst-case compensator times output-to-plant sensitivity function

Stable - 1 if nominal closed loop is stable, 0

otherwise. NaN for frd/ufrd objects.

EX:

delta = ultidyn('delta',[1 1]);

tau = ureal('tau',5,'range',[4 6]);

P = tf(1,[tau 1])*(1+0.25*delta);

C=tf([4 4],[1 0]);

looptransfer = loopsens(P,C);

Snom = looptransfer.Si.NominalValue;wcst = wcsens(P,C) ;

Swc = wcst.Si.BadSystem;

omega = logspace(-1,1,50);

bodemag(Snom,'-',Swc,'-.',omega);

legend('Nominal Sensitivity','Worst-Case Sensitivity',...

'Location','SouthEast')

10-1

100

101

-35

-30

-25

-20

-15

-10

-5

0

5

Magnitude(dB)

Bode Diagram

Frequency (rad/sec)

Nominal Sensitivity

Worst-Case Sensitivity

Robust Analysis for Parameter


73/168



Dependent Systems

1. psys() specifies state-space models where the state-spacematrices can be uncertain, time-varying, or parameter-dependent.

2. psinfo() a multi-usage function for queries about a polytopic orparameter-dependent system

3. ispsys() returns 1 if sys is a polytopic or parameter-dependent

system4. pvec() used in conjunction with psys to specify parameter-

dependent systems.

5. pvinfo() retrieves information about a vector of real parametersdeclared with pvec and stored in pv

6. polydec() takes an uncertain parameter vector PV taking valuesranging in a box, and returns the corners or vertices of the box ascolumns of the matrix vertx



74/168



Dependent Systems cont.

6. aff2pol() Derives a polytopic representation polsys of the affineparameter- dependent system.

7. quadstab() seeks a fixed Lyapunov function that establishesquadratic stability

8. quadperf() Compute the quadratic H-inf performance of a

polytopic or parameter-dependent system9. pdlstab() uses parameter-dependent Lyapunov functions to

establish the stability of uncertain state-space models over someparameter range or polytope of systems.

10. decay() returns the quadratic decay rate drate

11. pdsimul() simulates the time response of an affine parameter-dependent system

pols = psys(syslist)


75/168


affs = psys(pv,syslist) Specify a parameter-dependent system

psys specifies state-space models where the state-space matricescan be uncertain, time-varying, or parameter-dependent.

a polytopic model with vertex systems S1, . . ., S4 is created by

pols = psys([s1,s2,s3,s4]) while an affine parameter-dependentmodel with 4 real parameters is defined by

affs = psys(pv,[s0,s1,s2,s3,s4])

The output is a structured matrix storing all the relevant information


76/168


[type,k,ns,ni,no] = psinfo(ps)

Query characteristics of a P-system

displays the type of system (affine or

polytopic)

the number k of SYSTEM matrices

involved in its definition

the numbers of ns, ni, no of states, inputs,

and outputs of the system


77/168


bool = ispsys(sys)

True for parameter-dependent systems

returns 1 if sys is a polytopic or parameter-

dependent system

pv = pvec('box' range rates)


78/168


pv pvec( box ,range,rates)

pv = pvec('pol',vertices)

Specify a vector of uncertain or time-varying parameters used inconjunction with psys to specify parameter-dependent systems

The type 'box' corresponds to independent parameters ranging in intervals

(extremal values)

The parameter vector p then takes values in a hyperrectangle of Rn called

the parameter box

range is an n-by-2 matrix that stacks up the extremal values

type 'pol' corresponds to parameter vectors p ranging in a polytope of the

parameter space Rn

efined by a set of vertices V1, . . ., Vn corresponding to "extremal" valuesof the vector p

second argument is the concatenation of the vectors v1,...,vn

[ k ] i f ( )


79/168


[typ,k,nv] = pvinfo(pv)

pvinfo(pv) displays the type of parametervector ('box' or 'pol'), the number n of

scalar parameters, and for the type 'pol',

the number of vertices used to specify theparameter range

t l d (PV)


80/168


vertx = polydec(PV)

Compute polytopic coordinates wrt. boxcorners

takes an uncertain parameter vector PV

taking values ranging in a box, and returnsthe corners or vertices of the box as

columns of the matrix vertx

l ff2 l( ff )


81/168


polsys = aff2pol(affsys)

Convert affine P-systems to polytopic representation

derives a polytopic representation polsys of the affine

parameter- dependent system

Where p = (p1, . . ., pn) is a vector of uncertain or

time- varying real parameters taking values in a box or a

polytope. The description affsys of this system should be

specified with psys

[t P] d t b( ti )


82/168


[tau,P] = quadstab(ps,options) Assess quadratic stability of parameter-dependent system

Quadratic stability of polytopic or affine parameter-dependent systems

[ f P] d f( ti )


83/168


[perf,P] = quadperf(ps,g,options)

Assess quadratic Hinf performance of P-systems

[tau Q0 Q1 ] = pdlstab(pds options)


84/168


[tau,Q0,Q1,...] pdlstab(pds,options)

Assess the robust stability of a polytopic or parameter-dependentsystem

uses parameter-dependent Lyapunov functions to establish thestability of uncertain state-space models over some parameterrange or polytope of systems

[d t P] d ( ti )


85/168


[drate,P] = decay(ps,options)

Compute quadratic decay rate

pdsimul(pds 'traj' tf 'ut' xi options)


86/168


pdsimul(pds, traj ,tf, ut ,xi,options) Time response of a parameter-dependent system along a given

parameter trajectory along a parameter trajectory p(t) and for an input

signal u(t)

The parameter trajectory and input signals are specified by two time

functions p=traj(t) and u=ut(t)

The affine system pds is specified with psys but can also use the

polytopic representation of such systems as returned by aff2pol(pds) or

hinfgs

The final time and initial state vector can be reset through tf and xi

options gives access to the parameters controlling the ODE integration

R b t C t ll S th i T l


87/168


Robust Controller Synthesis Tools

The Robust Control Toolbox has various controller synthesis

tools outlined below:

1. Augw() computes a state-space model of an augmented LTI plant with

weighting functions

2. Hinfmix() creates a suboptimal controller K(s) based on the optimization of a

mixed H2/ H criterion.

3. H2syn() computes a stabilizing LTI/SS controller K for a partitioned plant

P(s).

4. Hinfsyn() creates an optimal H-inifinity controller for a partitioned plant matrix

P.

5. Sdhinfsyn() synthesizes a sampled data H-infinity controller.

6. Loopsyn() is an Hinfinity optimal way for loopshaping controller synthisis.

Robust Controller Synthesis Tools


88/168


y

cont:

7. Ltrsyn() computes a reconstructed-state output-feedback

controller K for LTI plant G using Kalman filtering to

asymptotically recover the lost states.

8. Mixsyn() is H-infinity mixed-sensitivity synthesis method for robustcontrol loopshaping design.

9. Ncfsyn() is a normalized coprime factorization based

parameterized controller synthesis using the Glover-McFarlane

method for loopshaping.

10.Mkfilter() returns a single-input, single-output analog low pass

filter sys as an ss object.

P AUGW(G W1 W2 W3)


89/168


P = AUGW(G,W1,W2,W3)Augw() computes a state-space model of an augmented LTI plant P(s)

with weighting functions W1(s), W2(s), and W3(s) penalizing the errorsignal, control signal and output signal respectively.

Input:

GNominal Plant Model

W1weight for the error signal

W2weight for the control signal

W3weight for the output signal

Output:

Paugmented plant model

10-4

10-2

100

102

104

106

-80

-60

-40

-20

0

20

40

60

Singular Values

Frequency ( rad/sec)

SingularVa

lues(dB)

S = 1/(1+L)

GAM/W1

T=L/(1+L)

GAM*G/W2

EX:

s=zpk('s'); G=(s-1)/(s+1);W1=0.1*(s+100)/(100*s+1); W2=0.1; W3=[];

P=augw(G,W1,W2,W3);

[K,CL,GAM]=hinfsyn(P); [K2,CL2,GAM2]=h2syn(P);

L=G*K; S=inv(1+L); T=1-S;

sigma(S,'k',GAM/W1,'k-.',T,'r',GAM*G/W2,'r-.')

[gopt,h2opt,K,R,S] =


90/168


hinfmix(P,r,obj,region,dkbnd,tol)

Hinfmix() creates a suboptimal controller K(s) based on theoptimization of a mixed H2/ Hcriterion that optimizes the

following function: subject to ||T || < gamma,||T2||2 < v. The closed-loop poles lie in some prescribed LMI region D.

Input Parameters:

Plmi object such as ss or tf.

R[z2, y, u]

Obj[gamma, v, alpha, beta]

Regionidentifies the pole placement

region. Default is the open LHP.

Dkbndset bound on norm of controller

feed through matrix DK.

Toltolerance for the trade-off parameter

Output Parameters:Gopt - guaranteed Hinf performance

H2optguaranteed H2 performance

KController K(s) coefficients

R,Soptimal values of the LMI objects.

[K,CL,GAM,INFO]=


91/168


[ , , , ]

H2SYN(P,NMEAS,NCON)

H2syn() computes a stabilizing LTI/SS controller K for a partitionedplant P(s).

Input Parameters:

PLTI/SS plant model

NmeasB2 column size

NconC2 row size

Output Parameters:

Kvector of Feedback Controller

Coefficients

CLClosed loop system matrix

Gamthe H2 norm of the closed loop

system

Infostructure containing additional

information.

Plant Partitioning (if done by mktito(),

nmeas and ncon can be omitted):

B1Inputs are disturbances

B2Inputs are control signals

C1Outputs are errors to be minimized

C2Outputs are inputs to control K

[K,CL,GAM,INFO] =


92/168


[ , , , ]

hinfsyn(P,NMEAS,NCON)

Hinfsyn() creates an optimal h-inifinity controller for a partitioned plantmatrix P.

Input Parameters:

PPartitioned plant matrix

Nmeasrow size of the C2 matrix

Nconcolumn size of the B2 matrix

Output Parameters:

Kcontroller coefficient vector

CLclosed loop system matrix

GamH-inifinity norm for the closedloop system

Info - structure containing additional

information

Plant Partitioning (if done by mktito(), nmeas

and ncon can be omitted):B1Inputs are disturbances




[K GAM]=sdhinfsyn(P NMEAS NCON)


93/168


[K,GAM]=sdhinfsyn(P,NMEAS,NCON)Sdhinfsyn() synthesizes a sampled data H-infinity controller.

Input Parameters:

Ppartitioned system matrix

Nmeasrow size of C2

NConcolumn size of B2

Output parameters:

KH infinity controller coefficients

GamH infinity norm cost for the system

Plant Partitioning:B1Inputs are disturbances




Where:

[K,CL,GAM,INFO]=


94/168


loopsyn(G,Gd,RANGE)

Loopsyn() is an Hinfinity optimal way for loopshaping controllersynthisis.Input Parameters:

GLTI plant

Gddesired loop shape

Range[Wmin,Wmax] desired loop

shaping frequency range. (10*Wmin


95/168


[ , , ]

ltrsyn(G,F,XI,THETA,RHO)

Ltrsyn() computes a reconstructed-state output-feedback controller K for LTIplant G using Kalman filtering to asymptotically recover the lost states.

Input Parameters:

GLTI System matrix

F - LQ full-state-feedback gain matrix

XIplant noise intensity

Thetasensor noise intensity

Rhovector containing a set of recovery

gains

Output Parameters:Kcontroller coefficient vector

Svlsigma plot data for recovered system

W1 - frequencies for SVL plots

EX:s=tf('s');G=ss(1e4/((s+1)*(s+10)*(s+100)));[A,B,C,

D]=ssdata(G);

F=lqr(A,B,C'*C,eye(size(B,2)));

L=ss(A,B,F,0*F*B);

XI=100*C'*C; THETA=eye(size(C,1));

RHO=[1e3,1e6,1e9,1e12];W=logspace(-2,2);

nyquist(L,'k-.');hold;

[K,SVL,W1]=ltrsyn(G,F,XI,THETA,RHO,W);

[K,CL,GAM,INFO]=


96/168


[ ]

mixsyn(G,W1,W2,W3)

Mixsyn() is H-infinity mixed-sensitivity synthesis method for robustcontrol loopshaping design.

Input Parameters:

GLTI system

W1,W2,W3Weighting matricies

associated with S(s), R(s) and T(s)

Output Parameters:KController Coefficient vectorCLClosed Loop System Matrix

GamHinfinity norm for the closed

loop system


information.

Mixsyn() creates the h-infinity controllerbased on the sensitivity function S(s)

and the complimentatry sensitivitiy T(s)

function according to the weighting

matricies W1, W2, W3.;

[K,CL,GAM,INFO]=ncfsyn(G W1 W2)


97/168


ncfsyn(G,W1,W2)Ncfsyn() is a normalized coprime factorization based parameterized

controller synthisis using the Glover-McFarlane method for loopshaping.

Input Parameters:

GLTI plant model

W1,W2Pre and Post compensator

to give Gd= W1GW2a good highfrequency and low frequency response

Output Parameters:

Kcontroller coefficient vector

CLclosed loop system matrix

GamHinfinity optimal cost


information

10-2

10-1

100

101

102

-100

-80

-60

-40

-20

0

20

40

60Singular Values

Frequency ( rad/sec)

SingularValues(dB)

EX:

s=zpk('s');G=(s-1)/(s+1)^2;

W1=0.5/s;

[K,CL,GAM]=ncfsyn(G,W1);

sigma(G*K,'r',G*W1,'r-.',G*W1*GAM,'k-

.',G*W1/GAM,'k-.')

sys = mkfilter(fc ord type psbndr)


98/168


sys = mkfilter(fc,ord,type,psbndr)

Mkfilter() returns a single-input, single-output analog low pass filter

sys as an ss object.

Input:

Fccutoff frequency of the filter

Ordorder of the filter

Typetype of the filter.

'butterw- Butterworth filter

cheby - Chebyshev filter

'bessel - Bessel filter

'rc - Series of resistor/ capacitor

filters

Psbndr - the magnitude of the passband

Output:

SysDesigned filter

EX:butw = mkfilter(2,4,'butterw');

cheb = mkfilter(4,4,'cheby',0.5);

rc = mkfilter(1,4,'rc');

bode(butw,'-',cheb,'--',rc,'-.')

-100

-50

0

Magnitude(dB)

10-5

100

0

90

180

Phase(deg)

Bode Diagram

Frequency (rad/sec)

-50

0

50

Magnitude(dB)

10-2

100

102

-90

-45

0

Phase(deg)

Bode Diagram

Frequency (rad/sec)

-50

0

50

Magnitude(dB)

10-2

100

102

-90

-45

0

Phase(deg)

Bode Diagram

Frequency (rad/sec)

-200

-100

0

Magnitude(dB)

100

102

-360

-180

0

Phase(deg)

Bode Diagram

Frequency (rad/sec)

ButterworthChebyshev

RC filter

Mu synthesis


99/168


Mu-synthesisMu-synthesis functions enable the synthesis of robust optimal

controllers. Approximation tools for this type of design are shownbelow:

1. Cmsclsyn() approximately solves the constant-matrix, upper bound -

synthesis problem.

2. Dksyn() synthesizes a robust controller via D-K iteration which is an

approximation to -synthesis control design.3. Dkitopt() creates a dkitopt object called options with specific values

assigned to certain properties.

4. Drawmag() interactively uses the mouse in the plot window to create pts

and sysout, which approximately fits the frequency response (magnitude)

in pts.5. Fitfrd() fits D-scaling frequency response data with state-space model.

6. Fitmagfrd() fits frequency response magnitude data with a stable,

minimum-phase state-space model.

[qopt,bnd] =


100/168


cmsclsyn(R,U,V,BlockStructure);

Cmsclsyn() approximately solves the constant-matrix, upper bound -synthesis problem by minimization,

for given matrices and . This

applies to constant matrix data in R, U, and V.

Input:

R,U,VConstant matrices of

appropriate structure

BlockStructure a matrix

specifying the perturbation

blockstructure as defined for

mussv.

Output:

Qopt - the optimum value of Q

Bnd - the upper bound of

mussv(R+U*Q*V,BLK)

[k clp bnd] = dksyn(p nmeas ncont)


101/168


[k,clp,bnd] = dksyn(p,nmeas,ncont)

Dksyn() synthesizes a robust controller via D-K iteration which is

an approximation to -synthesis control design.

Input:

PPartitioned plant matrix

Nmeasrow size of the C2 matrix

Nconcolumn size of the B2 matrix

Output:Ksynthesized controller coefficients

ClpClosed loop system

Bndrobust performance bounds on

the closed loop system

EX:

G = tf(1,[1 -1]);

Wu = 0.25*tf([1/2 1],[1/32 1]);

InputUnc = ultidyn('InputUnc',[1 1]);

Gpert = G*(1+InputUnc*Wu);Wp = tf([1/4 0.6],[1 0.006]);

P = [Wp; 1 ]*[1 Gpert];

[K,clp,bnd1] = dksyn(P,1,1);

P = [Wp; 1 ]*[1 Gpert];

[K,clp,bnd2] = dksyn(P,1,1);

bnd1 =0.6768

bnd2 =0.6768

options =


102/168


p

dkitopt('name1',value1,'name2',value2,...)

Dkitopt() creates a dkitopt object called options with specific valuesassigned to certain properties.

[sysout,pts] = drawmag(data)


103/168


[ y p ] g( ) interactively uses the mouse in the plot window to create pts and sysout, which

approximately fits the frequency response (magnitude) in pts

data:Either a frequency response object that is plotted as a reference, or aconstant matrix of the form [xmin xmax ymin ymax] specifying the plot window onthe data.

sysoutStable:minimum-phase ss object that approximately fits, in magnitude,the pts data

ptsFrequency:response of points

While drawmag is running, all interaction with the program is through the mouse

and/or the keyboard

Examples of commands

Clicking the mouse

Typing r

Typing integers 09

Typing w

Typing p

Typing k

See help file for more info

B = fitfrd(A,N)


104/168


Fit D-scaling frequency response data with state-space model

state-space object with state dimension N, where A is an frd object and N is

a nonnegative integer The frequency response of B closely matches the D-scale frequency

response data in A

A must have either 1 row or 1 column, although it need not be 1-by-1

Examplesys = tf([1 2 2],[1 2.5 1.5])*tf(1,[1 0.1]);sys = sys*tf([1 3.75 3.5],[1 2.5 13]);

omeg = logspace(-1,1);

sysg = frd(sys,omeg);

bode(sysg,'r-');

b1 = fitfrd(sysg,1);

b3 = fitfrd(sysg,3);

b1g = frd(b1,omeg);

b3g = frd(b3,omeg);

bode(sysg,'r-',b1g,'k:',b3g,'b-.')

B = fitmagfrd(A,N)


105/168


g ( ) Fit frequency response magnitude data with a stable, minimum-phase

state-space model

a stable, minimum-phase ss object, with state-dimension N, whosefrequency response magnitude closely matches the magnitude data in A

A is a 1-by-1 frd object, and N is a nonnegative integer

Examplesys = tf([1 2 2],[1 2.5 1.5])*tf(1,[1 0.1]);

sys = sys*tf([1 3.75 3.5],[1 2.5 13]);

omeg = logspace(-1,1);sysg = abs(frd(sys,omeg));

bodemag(sysg,'r');

ord = 3;

b1 = fitmagfrd(sysg,ord);

b1g = frd(b1,omeg);

bodemag(sysg,'r',b1g,'k:');



106/168



The synthesis of robust optimal controllers with sampled data

systems can be analyzed using the following functions.

1. Sdhinfnorm() computes the L2 induced norm of a continuous-time LTI plant,

sdsys, in feedback with a discrete-time controller, k, connected through an

ideal sampler and a zero-order hold.

2. Sdlsim() plots the time response of the hybrid feedback system. lft(p,k), is

forced by the continuous input signal described by w and t.

[gaml,gamu] =


107/168


sdhinfnorm(sdsys,k,delay)

Sdhinfnorm() computes the L2 induced norm of a continuous-timeLTI plant, sdsys, in feedback with a discrete-time controller, k,

connected through an ideal sampler and a zero-order hold.

Input:

Sdsysa strictly proper partitionedplant model, such that the constant

feedback gain is be zero

Kfeedback controller gain matrix

Delaycontroller computational delay

time

Output:

Gamu - upper bound on theinduced L2 norm of the sampled-

data closed-loop system

Gaml - lower bound on the

induced L2 norm of the sampled-

data closed-loop system

Sdhinfnorm() Example


108/168


Sdhinfnorm() Example

p = ss(tf(30,[1 30])*tf([1],[1 0]));k = ss(tf(4,[1 4]));

cl = feedback(p,k);

norm(cl,'inf')

ans = 1

kd = c2d(k,0.75,'zoh');

[gu,gl] = sdhinfnorm([1; 1]*p*[1 1],-kd);

[gu gl]

ans = 3.7908 3.7929

kd = c2d(k,0.2,'zoh');

[gu,gl] = sdhinfnorm([1; 1]*p*[1 1],-kd);

[gu gl]

ans = 1.0044 1.0049

sdlsim(p k w t tf x0 z0 int)


109/168


sdlsim(p,k,w,t,tf,x0,z0,int)Sdlsim() plots the time response of the hybrid feedback system.

lft(p,k), is forced by the continuous input signal described by w and t.

Input:

P - a continuous-time LTI system

Ka discrete-time LTI system with aspecified sampling time

W,Tinput forcing functions

Tfsimulation end time

X0 - initial state vector of p, at time t(1)

Z0 - initial state vector of k, at time t(1)

Int - the continuous-time integration

step size

Sdlsim() example cont:


110/168


Sdlsim() example cont:

EX cont:

M2 = [0,1,1;1,0,0;0,1,1]*blkdiag(1,1,P);

t = [0:.001:1]';

dist = 0.1*sin(41*t);

u = ones(size(t));

[y3,meas,act] = sdlsim(M2,C,[u dist],t,1);plot(y3{:},'-',t,dist,'b--',t,u,'g-.')

xlabel('Time: seconds')

title('Step response: disturbance (dashed) & output

(solid)')

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1-0.2

0

0.2

0.4

0.6

0.8

1

1.2

1.4

Time: seconds

Step response: disturbance (dashed) & output (solid)

EX:

P = tf(1,[1, 1e-5,0]);

T = 1.0/20;

C = ss([-1.5 T/4; -2/T -.5],[ .5 2;1/T

1/T],...

[-1/T^2 -1.5/T], [1/T^2 0],T);Pd = c2d(P,T,'zoh');

systemnames = 'Pd C';

inputvar = '[ref]';

outputvar = '[Pd]';

input_to_Pd = '[C]';

input_to_C = '[ref ; Pd]';

sysoutname = 'dclp';

cleanupsysic = 'yes';

sysic;

Gain Scheduling


111/168


Gain Scheduling

Gain scheduling is a useful tool for controller design. The RobustControl Toolbox offers one function to optimally achieve this.

1. Hinfigs() synthesizes gain-scheduled H controllers.

[gopt,pdK,R,S] =

hinfgs(pdP r gmin tol tolred)


112/168


hinfgs(pdP,r,gmin,tol,tolred)

Synthesis of gain-scheduled Hcontrollers returns the optimal closed-loop quadratic

performance gopt and a polytopic description ofthe gain-scheduled controller pdK

To test if a closed-loop quadratic performance is achievable, set the third input gmin to

The arguments tol and tolred control therequired relative accuracy on gopt and thethreshold for order reduction

also returns solutions R, S of the characteristicLMI system

Synthesis Supporting Utilities


113/168


Synthesis Supporting Utilities

The following functions are useful in setting up systems forcontroller synthesis:

1. Bilin() gives the multivariable bilinear transform of frequency (s or z).2. Mktito() adds TITO (two-input-two-output) partitioning to LTI system SYS,

assigning OutputGroup and InputGroup properties.

3. Sectf() gives the state-space sector bilinear transformation.

4. Skewdec() forms an m-by-m skew-symmetric matrix.

5. Symdec() forms an m-by-m symmetric matrix.

GT = bilin(G,VERS,METHOD,AUG)M lti i bl bili t f f f ( )


114/168


Multivariable bilinear transform of frequency (s or z)

bilin computes the effect on a system of the frequency-variable substitution

The variable VERS denotes the transformation direction: VERS= 1, forwardtransform or VERS=-1, reverse transform

computes several state-space bilinear transformations such as backward

rectangular, etc., based on the METHOD you select

SYS=mktito(SYS NMEAS NCONT)


115/168


SYS mktito(SYS,NMEAS,NCONT)

Plant Partitioning:B1Inputs are disturbances




Mktito() adds TITO (two-input-two-output) partitioning to LTI system SYS,

assigning OutputGroup and InputGroup properties.

EX:P=rss(2,4,5); P=mktito(P,2,2);

disp(P.OutputGroup);

disp(P.InputGroup);Y1: [1 2]

Y2: [3 4]

U1: [1 2 3]

U2: [4 5]

[G T] = sectf(F SECF SECG)


116/168


[G,T] sectf(F,SECF,SECG)

State-space sector bilinear transformation computes a linear fractional transform T such that the system lft(F,K) is in

sector SECF if and only if the system lft(G,K) is in sector SECG where

G=lft(T,F,NU,NY) where NU and NY are the dimensions of uT2 and yT2,

respectively


117/168

x = symdec(m n)


118/168


x symdec(m,n)Symdec() forms an m-by-m symmetric matrix of the form:

NOTE: This function is useful to define symmetric matrix variables. n is the

number of decision variables.

LMIs in the Robust Control Toolbox


119/168


LMIs in the Robust Control Toolbox

The Robust Control Toolbox LMI functionality serves twopurposes:

Provide state-of-the-art tools for the LMI-based analysis anddesign of robust control systems

Offer a flexible and user-friendly environment to specify andsolve general LMI problems (the LMI Lab)

Examples of LMI-based analysis and design tools include:

Functions to analyze the robust stability and performance ofuncertain systems with varying parameters (popov, quadstab,quadperf ...)

Functions to design robust control with a mix of H2, H, andpole placement objectives (h2hinfsyn)

Functions for synthesizing robust gain-scheduled Hcontrollers (hinfgs)

Linear Matrix Inequalities


120/168


Linear Matrix Inequalities

A linear matrix inequality (LMI) is any constraint of the form

where x = (x1, . . . , xN) is a vector of unknown scalars (the decision or

optimization variables) A0, . . . , AN are given symmetric matrices < 0 stands

for "negative definite," i.e., the largest eigenvalue of A(x) is negative

Note that the constraints A(x) > 0 and A(x) < B(x) are special cases of (1-1)

since they can be rewritten as -A(x) < 0 and A(x) - B(x) < 0, respectively.

Specifying/Modifying LMI Systems


121/168


LMI Systems can be specified and modified in various ways briefly

outlined below

The specification of an LMI system involves two steps:

1. Declare the dimensions and structure of each matrix variable X1, . . . , XK.

2. Describe the term content of each LMI.

This process creates the so-called internal representation of the LMI system. This

computer description of the problem is used by the LMI solvers and in allsubsequent manipulations of the LMI system. It is stored as a single vector called

LMISYS.

There are two ways of generating the internal description of a given LMI system:

1. by a sequence of lmivar/lmiterm commands that build it incrementally

2. via the LMI Editor lmiedit where LMIs can be specified directly as symbolic matrixexpressions. Though somewhat less flexible and powerful than the command-

based description, the LMI Editor is more straightforward to use, hence

particularly well-suited for beginners.

Specification Functions


122/168


Specification FunctionsThe following functions are used for the LMI Specificiation:

1. Lmiedit is a graphical user interface for the symbolic specification of

LMI problems.

2. Setlmis() is a command to be used to initialize or add to an internal

representation for an lmi.

3. Lmivar() defines a new matrix variable X in the LMI system currently

described.

4. Lmiterm() specifies the term content of an LMI one term at a time.

5. Newlmi adds a new LMI to the LMI system currently described and

returns an identifier tag for this LMI.

6. Getlmis returns the internal representation of a lmi system declaredusing lmivars() and lmiterm().

lmiedit


123/168


lmieditLmiedit is a graphical user interface for the symbolic specification

of LMI problems.Instructions:

Documents

Matlab Robust Control Toolbox (1)