looptune

Tune fixed-structure feedback loops

Syntax

[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(...)

Description

[G,C,gam] = looptune(G0,C0,wc) tunes the feedback loop

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 roll-off 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 co-tuning 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™).

[G,C,gam] = looptune(G0,C0,wc,Req1,...,ReqN) tunes the feedback loop to meet additional design requirements specified in one or more tuning goal objects 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.

[G,C,gam] = looptune(...,options) specifies further options, including target gain margin, target phase margin, and computational options for the tuning algorithm.

[G,C,gam,info] = looptune(...) returns a structure info with additional information about the tuned result. Use info with the loopview command to visualize tuning constraints and validate the tuned design.

Examples

Tune Control System to Achieve Crossover Requirements

Tune the control system of the following illustration, to achieve crossover between 0.1 and 1 rad/min.

The 2-by-2 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 fixed-structure controller, C, includes three components: the 2-by-2 decoupling matrix D and two PI controllers PI_L and PI_V. The signals r, y, and e are vector-valued 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.

Input Arguments

G0 — Plant in control system to tune

tf model object | zpk model object | ss model object | pid model object | pidstd model object | pid2 model object | pidstd2 model object | genss model object

Plant in control system to tune, specified as a Numeric LTI model or tunable genss model.

The plant is the portion of your control system whose outputs are sensor signals (measurements) and whose inputs are actuator signals (controls). Use connect to build G0 from individual numeric or tunable components.

C0 — Controller structure, parameter, and initial values

genss model object

Controller structure, parameter, and initial values, specified as a Generalized LTI model model.

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 connect to build C0 from individual numeric or tunable components.

wc — Target crossover region

scalar | vector

Target crossover region, specified as a scalar or a vector. If you specify this argument as a scalar, the target crossover region is equal to [wc/2,2*wc]. If you specify this argument as a vector, the target crossover region is equal to [wcmin,wcmax]. The looptune command attempts to tune all loops in the control system so that the open-loop gain crosses 0 dB within the target crossover region.

Req1,...,ReqN — Design requirements

TuningGoal object

Design requirements, specified as one or more TuningGoal objects, such as TuningGoal.Tracking, TuningGoal.Gain, or TuningGoal.LoopShape.

options — Set of options for looptune algorithm

looptune object

Set of options for looptune algorithm, specified as a looptune object that you create using looptuneOptions. See looptuneOptions for information about the available options, including target gain margin and phase margin.

Output Arguments

G — Tuned plant

tf model object | zpk model object | ss model object | pid model object | pidstd model object | pid2 model object | pidstd2 model object | genss model object

Tuned plant, returned as a numeric LTI model or a genss model.

If G0 is a Numeric LTI model, G is the same as G0.

If G0 is a tunable genss model, G is a genss model with Control Design Blocks of the same number and types as G0. The current value of G is the tuned plant.

C — Tuned controller

genss model object

Tuned controller returned as a genss model object. C is a genss model with Control Design Blocks of the same number and types as C0. The current value of C is the tuned controller.

gam — Degree of success at meeting all tuning constraints

scalar

Parameter indicating degree of success at meeting all tuning constraints. A value of gam <= 1 indicates that all requirements are satisfied. gam >> 1 indicates failure to meet at least one requirement. Use loopview to visualize the tuned result and identify the unsatisfied requirement.

For best results, use the RandomStart option in looptuneOptions to obtain several minimization runs. Setting RandomStart to an integer N > 0 causes looptune to run the optimization N additional times, beginning from parameter values it chooses randomly. You can examine gam for each run to help identify an optimization result that meets your design requirements.

info — Data for validating tuning results

structure

Data for validating tuning results, returned as a structure. To use the data in info, use the command loopview(G,C,info) to visualize tuning constraints and validate the tuned design.

info contains these fields:

Di,Do — Optimal input and output scalings

state-space model objects

Optimal input and output scalings, returned as state-space models. The scaled plant is given by Do\G*Di.

Specs — Design requirements

vector of TuningGoal objects

Design requirements that looptune constructs for its call to systune for tuning (see Algorithms), returned as a vector of TuningGoal requirement objects.

Runs — Detailed information about each optimization run

structure

Detailed information about each optimization run performed by systune when called by looptune for tuning (see Algorithms), returned as a data structure.

The contents of Runs are the info output of the call to systune. For information about the fields of Runs, see the info output argument description on the systune reference page.

Algorithms

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 structure-preserving eigensolvers from the SLICOT library. For more information about the SLICOT library, see https://github.com/SLICOT.

Alternatives

For tuning Simulink models with looptune, see slTuner (Simulink Control Design) and looptune (Simulink Control Design) (requires Simulink Control Design).

References

[1] P. Apkarian and D. Noll, "Nonsmooth H-infinity 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.

Extended Capabilities

Automatic Parallel Support

Accelerate code by automatically running computation in parallel using Parallel Computing Toolbox™.

To run in parallel, set 'UseParallel' to true using looptuneOptions.

For more information, see Speed Up Tuning with Parallel Computing Toolbox Software.

Version History

Introduced in R2011b

R2016a: Functionality moved from Robust Control Toolbox

Prior to R2016a, this functionality required a Robust Control Toolbox™ license.