Package: TuningGoal
Target loop shape for control system tuning
Use the TuningGoal.LoopShape
object to specify
a target gain profile (gain as a function of
frequency) of an openloop response. The TuningGoal.LoopShape
requirement
constrains the openloop, pointtopoint response (L)
at a specified location in your control system. Use this requirement
for control system tuning with tuning commands, such as systune
or looptune
.
When you tune a control system, the target openloop gain profile is converted into constraints on the inverse sensitivity function inv(S) = (I + L) and the complementary sensitivity function T = 1–S. These constraints are illustrated for a representative tuned system in the following figure.
Where L is much greater than 1, a minimum
gain constraint on inv(S) (green shaded region)
is equivalent to a minimum gain constraint on L.
Similarly, where L is much smaller than 1, a maximum
gain constraint on T (red shaded region) is equivalent
to a maximum gain constraint on L. The gap between
these two constraints is twice the CrossTol
parameter,
which specifies the frequency band where the loop gain can cross 0
dB.
For multiinput, multioutput (MIMO) control systems, values
in the gain profile greater than 1 are interpreted as minimum performance
requirements. Such values are lower bounds on the smallest singular
value of the openloop response. Gain profile values less than one
are interpreted as minimum rolloff requirements, which are upper
bounds on the largest singular value of the openloop response. For
more information about singular values, see sigma
.
Use TuningGoal.LoopShape
when the loop shape
near crossover is simple or well understood (such as integral action).
To specify only high gain or low gain constraints in certain frequency
bands, use TuningGoal.MinLoopGain
and TuningGoal.MaxLoopGain
. When you do so,
the software determines the best loop shape near crossover.
creates
a tuning requirement for shaping the openloop response measured at
the specified location. The magnitude of the singleinput, singleoutput
(SISO) transfer function Req
=
TuningGoal.LoopShape(location
,loopgain
)loopgain
specifies the
target openloop gain profile. You can specify the target gain profile
(maximum gain across the I/O pair) as a smooth transfer function or
sketch a piecewise error profile using an frd
model.
specifies
a tolerance on the location of the crossover frequency. Req
= TuningGoal.LoopShape(location
,loopgain
,crosstol
)crosstol
expresses
the tolerance in decades. For example, crosstol
=
0.5 allows gain crossovers within half a decade on either side of
the target crossover frequency specified by loopgain
.
When you omit crosstol
, the tuning requirement
uses a default value of 0.1 decades. You can increase crosstol
when
tuning MIMO control systems. Doing so allows more widely varying crossover
frequencies for different loops in the system.
Req = TuningGoal.LoopShape(
specifies
just the target gain crossover frequency. This syntax is equivalent
to specifying a pure integrator loop shape, location
,wc
)loopgain = wc/s
.
Req = TuningGoal.LoopShape(
specifies
a range for the target gain crossover frequency. The range is a vector
of the form location
,wcrange
)wcrange
= [wc1,wc2]
.
This syntax is equivalent to using the geometric mean sqrt(wc1*wc2)
as wc
and
setting crosstol
to the halfwidth of wcrange
in
decades. Using a range instead of a single wc
value
increases the ability of the tuning algorithm to enforce the target
loop shape for all loops in a MIMO control system.

Location where the openloop response shape to be constrained is measured, specified as a string or cell array of strings that identify one or more locations in the control system to tune. What locations are available depends on what kind of system you are tuning:
The loop shape requirement applies to the pointtopoint openloop transfer function at the specified location. That transfer function is the openloop response obtained by injecting signals at the location and measuring the return signals at the same point. If 

Target openloop gain profile as a function of frequency. You can specify For multiinput, multioutput (MIMO) control systems, values
in the gain profile greater than 1 are interpreted as minimum performance
requirements. These values are lower bounds on the smallest singular
value of 

Tolerance in the location of crossover frequency, in decades.
specified as a scalar value. For example, Default: 0.1 

Target crossover frequency, specified as a positive scalar value.
Express 

Range for target crossover frequency, specified as a vector
of the form 

Target loop shape as a function of
frequency, specified as a SISO The software automatically maps the input argument 

Tolerance on gain crossover frequency, in decades. The initial value of Default: 

Frequency band in which tuning requirement is enforced, specified
as a row vector of the form Set the Req.Focus = [1,100]; Default: 

Stability requirement on closedloop dynamics, specified as
1 ( When Default: 1 ( 

Toggle for automatically scaling loop signals, specified as In multiloop or MIMO control systems, the feedback channels
are automatically rescaled to equalize the offdiagonal terms in the
openloop transfer function (loop interaction terms). Set Default: 

Location at which the openloop response shape to be constrained is measured, specified as a string or cell array of strings that identify one or more analysis points in the control system to tune. The value of the 

Models to which the tuning requirement applies, specified as a vector of indices. Use the Req.Models = 2:4; When Default: 

Feedback loops to open when evaluating the requirement, specified as a cell array of strings that identify loopopening locations. The tuning requirement is evaluated against the openloop configuration created by opening feedback loops at the locations you identify. If you are using the requirement to tune a Simulink model
of a control system, then If you are using the requirement to tune a generalized statespace
( Default: 

Name of the requirement object, specified as a string. For example, if Req.Name = 'LoopReq'; Default: 
When you tune a control system using a TuningGoal
object
to specify a tuning requirement, the software converts the requirement
into a normalized scalar value f(x),
where x is the vector of free (tunable) parameters
in the control system. The software then adjusts the parameter values
to minimize f(x) or to drive f(x)
below 1 if the tuning requirement is a hard constraint.
For the TuningGoal.LoopShape
requirement, f(x)
is given by:
$$f\left(x\right)={\Vert \begin{array}{c}{W}_{S}S\\ {W}_{T}T\end{array}\Vert}_{\infty}.$$
S = D^{–1}[I – L(s,x)]^{–1}D is the scaled sensitivity function.
L(s,x) is the openloop response being shaped.
D is an automaticallycomputed loop scaling
factor. (If the LoopScaling
property is set to 'off'
,
then D = I.)
T = S – I is the complementary sensitivity function.
W_{S} and W_{T} are weighting functions derived from the specified loop shape.
Create a target gain profile requirement for the following control system. Specify integral action, gain crossover at 1, and a rolloff requirement of 40 dB/decade.
The requirement should apply to the openloop response measured at the AnalysisPoint
block X
. Specify a crossover tolerance of 0.5 decades.
LS = frd([100 1 0.0001],[0.01 1 100]);
Req = TuningGoal.LoopShape('X',LS,0.5);
The software converts LS
into a smooth function of frequency that approximates the piecewisespecified requirement. Display the requirement using viewSpec
.
viewSpec(Req)
The green and red regions indicate the bounds for the inverse sensitivity, inv(S) = 1G*C
, and the and the complementary sensitivity, T = 1S
, respectively. The gap between these regions at 0 dB gain reflects the specified crossover tolerance, which is half a decade to either side of the target loop crossover.
When you use viewSpec(Req,CL)
to validate a tuned closedloop model of this control system, CL
, the tuned values of S
and T
are also plotted.
Create separate loop shape requirements for the inner and outer loops of the following control system.
For the inner loop, specify a loop shape with integral action, gain crossover at 1, and a rolloff requirement of 40 dB/decade. Additionally, specify that this loop shape requirement should be enforced with the outer loop open.
LS2 = frd([100 1 0.0001],[0.01 1 100]); Req2 = TuningGoal.LoopShape('X2',LS2); Req2.Openings = 'X1';
Specifying 'X2'
for the location
indicates
that Req2
applies to the pointto point, openloop
transfer function at the location X2
. Setting Req2.Openings
indicates
that the loop is opened at the analysis point X1
when Req2
is
enforced.
By default, Req2
imposes a stability requirement
on the inner loop as well as the loop shape requirement. In some control
systems, however, innerloop stability might not be required, or might
be impossible to achieve. In that case, remove the stability requirement
from Req2
as follows.
Req2.Stabilize = false;
For the outer loop, specify a loop shape with integral action, gain crossover at 0.1, and a rolloff requirement of 20 dB/decade.
LS1 = frd([10 1 0.01],[0.01 0.1 10]);
Req1 = TuningGoal.LoopShape('X1',LS1);
Specifying 'X1'
for the location
indicates
that Req1
applies to the pointto point, openloop
transfer function at the location X1
. You do not
have to set Req1.Openings
because this loop shape
is enforced with the inner loop closed.
You may need to tune the control system with both loop shaping
requirements Req1
and Req2
.
To do so, use both requirements as inputs to the tuning command. For
example, suppose CL0
is a tunable genss
model
of the closedloop control system. In that case, the following command
tunes the control system to both requirements.
[CL,fSoft] = systune(CL0,[Req1,Req2]);
Create a loopshape requirement for the feedback loop on 'q'
in
the following control system, which is the Simulink model rct_airframe2
.
Specify that the loopshape requirement is enforced with the 'az'
loop
open.
Open the model.
open_system('rct_airframe2')
Create a loop shape requirement that enforces integral action
with a crossover a 2 rad/s for the 'q'
loop. This
loop shape corresponds to a loop shape of 2/s.
s = tf('s'); shape = 2/s; Req = TuningGoal.LoopShape('q',shape);
Specify the location at which to open an additional loop when enforcing the requirement.
Req.Openings = 'az';
To use this requirement to tune the Simulink model, create
an slTuner
interface to the model. Identify the
block to tune in the interface.
ST0 = slTuner('rct_airframe2','MIMO Controller');
Designate both az
and q
as
analysis points in the slTuner
interface.
addPoint(ST0,{'az','q'});
This command makes q
available as an analysis
location. It also allows the tuning requirement to be enforced with
the loop open at az
.
You can now tune the model using Req
and
any other tuning requirements. For example:
[ST,fSoft] = systune(ST0,Req);
Create a tuning requirement specifying that the openloop response of loop identified by 'X'
cross unity gain between 50 and 100 rad/s.
Req = TuningGoal.LoopShape('X',[50,100]);
Examine the resulting requirement to see the target loop shape.
viewSpec(Req)
The plot shows that the requirement specifies an integral loop shape, with crossover around 70 rad/s, the geometrical mean of the range [50,100]. The gap at 0 dB between the minimum lowfrequency gain (green region) and the maximum highfrequency gain (red region) reflects the allowed crossover range [50,100].
frd
 looptune
 looptune
(for slTuner)
 slTuner
 systune
 systune (for slTuner)
 TuningGoal.Gain
 TuningGoal.MaxLoopGain
 TuningGoal.MinLoopGain
 TuningGoal.Tracking
 viewSpec