Tune fixedstructure feedback loops
[G,C,gam]
= looptune(G0,C0,wc)
[G,C,gam]
= looptune(G0,C0,wc,Req1,...,ReqN)
[G,C,gam]
= looptune(...,options)
[G,C,gam,info]
= looptune(...)
[
tunes the feedback loopG
,C
,gam
]
= looptune(G0
,C0
,wc
)
to meet the following default requirements:
Bandwidth — Gain crossover for each loop falls in the frequency
interval wc
Performance — Integral action at frequencies below
wc
Robustness — Adequate stability margins and gain rolloff at
frequencies above wc
The tunable genss
model C0
specifies the controller structure, parameters, and initial values. The model
G0
specifies the plant. G0
can be a Numeric LTI model, or, for
cotuning the plant and controller, a tunable genss
model. The sensor signals y
(measurements) and
actuator signals u
(controls) define the boundary between plant and
controller.
Note
For tuning Simulink^{®} models with looptune
, use slTuner
(Simulink Control Design) to create an interface to
your Simulink model. You can then tune the control system with looptune
(Simulink Control Design) for
slTuner
(requires Simulink
Control Design™).
[
tunes the feedback loop to meet additional design requirements specified in one or more
tuning goal objects G
,C
,gam
]
= looptune(G0
,C0
,wc
,Req1,...,ReqN
)Req1,...,ReqN
. Omit wc
to
use the requirements specified in Req1,...,ReqN
instead of an
explicit target crossover frequency and the default performance and robustness
requirements.
[
specifies further options, including target gain margin, target phase margin, and
computational options for the tuning algorithm.G
,C
,gam
]
= looptune(...,options
)
[
returns a structure G
,C
,gam
,info
]
= looptune(...)info
with additional information about the
tuned result. Use info
with the loopview
command to visualize tuning constraints and validate the tuned
design.

Numeric LTI
model or tunable The plant is the portion of your control system whose outputs are sensor
signals (measurements) and whose inputs are actuator signals (controls). Use


Generalized LTI model representing controller.
The controller is the portion of your control system that receives sensor
signals (measurements) as inputs and produces actuator signals (controls) as
outputs. Use Control
Design Blocks and Generalized LTI models to represent tunable
components of the controller. Use 

Vector specifying target crossover region
A scalar 

One or more 

Set of options for 

Tuned plant. If If  

Tuned controller.  

Parameter indicating degree of success at meeting all tuning constraints.
A value of For best results, use the  

Data for validating tuning results, returned as a structure. To use the
data in

Tune the control system of the following illustration, to achieve crossover between 0.1 and 1 rad/min.
The 2by2 plant G
is represented by:
$$G\left(s\right)=\frac{1}{75s+1}\left[\begin{array}{cc}87.8& 86.4\\ 108.2& 109.6\end{array}\right].$$
The fixedstructure controller, C
, includes three components:
the 2by2 decoupling matrix D
and two PI controllers
PI_L
and PI_V
. The signals
r
, y
, and e
are
vectorvalued signals of dimension 2.
Build a numeric model that represents the plant and a tunable model that
represents the controller. Name all inputs and outputs as in the diagram, so that
looptune
knows how to interconnect the plant and controller
via the control and measurement signals.
s = tf('s'); G = 1/(75*s+1)*[87.8 86.4; 108.2 109.6]; G.InputName = {'qL','qV'}; G.OutputName = 'y'; D = tunableGain('Decoupler',eye(2)); D.InputName = 'e'; D.OutputName = {'pL','pV'}; PI_L = tunablePID('PI_L','pi'); PI_L.InputName = 'pL'; PI_L.OutputName = 'qL'; PI_V = tunablePID('PI_V','pi'); PI_V.InputName = 'pV'; PI_V.OutputName = 'qV'; sum1 = sumblk('e = r  y',2); C0 = connect(PI_L,PI_V,D,sum1,{'r','y'},{'qL','qV'}); wc = [0.1,1]; [G,C,gam,info] = looptune(G,C0,wc);
C
is the tuned controller, in this case a
genss
model with the same block types as
C0
.
You can examine the tuned result using loopview
.
looptune
automatically converts target bandwidth, performance
requirements, and additional design requirements into weighting functions that express
the requirements as an H_{∞} optimization
problem. looptune
then uses systune
to optimize tunable parameters to minimize the
H_{∞} norm. For more information
about the optimization algorithms, see [1].
looptune
computes the
H_{∞} norm using the algorithm of
[2] and structurepreserving eigensolvers from the SLICOT library. For more information
about the SLICOT library, see http://slicot.org.
For tuning Simulink models with looptune
, see slTuner
(Simulink Control Design) and looptune
(Simulink Control Design) (requires Simulink
Control Design).
[1] P. Apkarian and D. Noll, "Nonsmooth Hinfinity Synthesis." IEEE Transactions on Automatic Control, Vol. 51, Number 1, 2006, pp. 71–86.
[2] Bruinsma, N.A., and M. Steinbuch. "A Fast Algorithm to Compute the H_{∞} Norm of a Transfer Function Matrix." Systems & Control Letters, 14, no.4 (April 1990): 287–93.
TuningGoal.Tracking
 slTuner
(Simulink Control Design)  systune
 looptune (for slTuner)
(Simulink Control Design)  TuningGoal.Gain
 TuningGoal.LoopShape
 hinfstruct
(Robust Control Toolbox)  looptuneOptions
 loopview
 diskmargin
(Robust Control Toolbox)  genss
 connect