Control System Toolbox Release Notes

R2015a

Improved input disturbance rejection with the PID tuning algorithm​

Controller tuning with the PID Tuner app or the pidtune command now
yields better disturbance rejection by default. For a given target
phase margin, the tuning algorithm selects PID coefficients that achieve
a balance between reference tracking and input disturbance rejection.
If you require more disturbance rejection or better reference tracking
than the default algorithm provides, PID Tuner and pidtune have a
new Design Focus option. Use this option to alter the balance that
the tuning algorithm sets between reference tracking and input disturbance
rejection. For instance, setting the design focus to reference tracking
improves the reference tracking performance of the tuned controller,
with some cost to disturbance rejection. Similarly, setting the design
focus to input disturbance rejection improves rejection with some
cost to reference tracking. Changing design focus is most effective
when tuning PID and PIDF controllers,
rather than controllers with fewer free parameters, such as PI.

To use the Design Focus option in PID Tuner, click Options and
select a design focus from the Focus menu.

You can still use the Response Time and Transient
Behavior sliders to further adjust the balance between
reference tracking and input disturbance rejection.

To specify a design focus for command-line
tuning with pidtune, use pidtuneOptions to
set the DesignFocus option. For example, the following
commands design a PIDF controller for the plant G with
a crossover frequency of 10 rad/s, specifying reference tracking as
the design focus.

connect command syntax for specifying analysis
point locations

When you interconnect dynamic system models using the connect command, you can now specify
analysis point locations as an input argument to the command. The
following syntax creates a dynamic system model with analysis points
by interconnecting multiple models sys1,sys2,...,sysN:

sys = connect(sys1,sys2,...,sysN,inputs,outputs,APs);

inputs and outputs are
string vectors that specify the names of the inputs and outputs of
the interconnected model. APs is a string vector
that lists the signal locations at which to insert analysis points.
The software automatically inserts an AnalysisPoint block
with channels corresponding to these locations. Previously, you had
to create AnalysisPoint blocks separately and
include them in the list of models to connect.

For example, consider the following control system.

Use connect to build this system with an
analysis point at the plant input, u.

LTI Viewer renamed to Linear System Analyzer

The LTI Viewer app is now called Linear System Analyzer. The
functionality of the app is unchanged.

You can access Linear System Analyzer in two ways:

From the MATLAB® desktop, in the Apps tab,
in the Control System Design and Analysis section,
click Linear System Analyzer.

From the MATLAB command line, use the linearSystemAnalyzer function. Previously,
this function was called ltiview. Using ltiview to
open Linear System Analyzer does not generate an error in this release,
but the function might be removed in a future release.

Compatibility Considerations

If you have scripts or functions that use ltiview,
consider replacing those calls with linearSystemAnalyzer.

sisotool function renamed to controlSystemDesigner

The sisotool function is now called controlSystemDesigner. The controlSystemDesigner opens
the SISO Design Tool. You can also access SISO Design Tool from MATLAB desktop.
In the Apps tab, in the Control System
Design and Analysis section, click Control System
Designer.

Using sisotool to open SISO Design Tool
does not generate an error in this release, but the function might
be removed in a future release.

Compatibility Considerations

If you have scripts or functions that use sisotool,
consider replacing those calls with controlSystemDesigner.

getBlockValue returns all block values in
structure

A new syntax of the getBlockValue command
now returns the current values of all Control Design Blocks of a generalized
model (genss) in a structure. The following syntax
returns a structure, S, whose field names are
the names of the blocks in the genss model M.
The values of the fields are numerical LTI models or numerical values
equal to the current values of the corresponding Control Design Blocks.

S = getBlockValue(M)

This syntax lets you transfer the block values from one generalized
model to another model that uses the same Control Design Blocks, as
follows:

R2014b

LPV System block for modeling and simulating linear parameter-varying
systems

This release introduces the LPV System block.
You use this block to represent Linear Parameter Varying (LPV) systems
in Simulink®.

An LPV system is a linear state-space system whose dynamics
vary as a function of certain time-varying parameters called the scheduling
parameters. Mathematically, an LPV system is represented
as:

dx(t)=A(p)x(t)+B(p)u(t)y(t)=C(p)x(t)+D(p)u(t)x(0)=x0

where

u(t) are the inputs

y(t) the outputs

x(t) are the model states with
initial value x0

dx(t) is
the state derivative vector x˙ for
continuous-time systems and the state update vector x(t+ΔT) for
discrete-time systems. ΔT is the sample time.

A(p), B(p), C(p) and D(p) are
the state-space matrices parameterized by the scheduling parameter
vector p.

The parameters p = p(t) are measurable
functions of the inputs and the states of the model. They can be a
scalar quantity or a vector of several parameters. The set of scheduling
parameters define the scheduling space over which
the LPV model is defined.

The linear system can be extended to contain offsets in the
system's states, input, and output signals. Mathematically,
the LPV system is represented by the following equations:

dx¯(p),x¯(p),u¯(p),y¯(p) are
the offsets in the values of dx(t), x(t), u(t) and y(t) at
a given parameter value p = p(t).

LPV system can be thought of as a first-order approximation
of a nonlinear system over a grid of scheduling parameter values.
For example, you can linearize a Simulink model between a given
input and output ports over a grid of equilibrium operating conditions.
The values of the model inputs, outputs and state values at each operating
point define the offsets, while the linear state-space models obtained
by linearization define the state-space data. The LPV system thus
generated can work as a proxy for the original model for facilitating
faster simulations and control system design. For more information,
see Linear
Parameter-Varying Models.

The LPV System block accepts the state-space
matrices and offsets over a grid of scheduling parameter values. The
state-space matrices must be specified as an array of
model objects. The SamplingGrid property
of the array defines the scheduling parameters for the LPV system.
For examples of using this block, see:

Kalman Filter block for estimating states of linear time-invariant
and linear time-varying systems

Use the Kalman
Filter block to estimate the states of linear time-invariant
and linear time-varying systems online. The states are estimated as
new data becomes available during the operation of the system. The
system can be continuous-time or discrete-time. You can generate code
for this block using code generation products such as Simulink Coder™.

AnalysisPoint Control Design Block for Marking Points of Interest
for Linear Analysis

The new AnalysisPoint block is a unit-gain
Control Design Block that you can insert anywhere in a control system
model to mark points of interest for linear analysis and tuning. Incorporate AnalysisPoint blocks
into generalized state-space (genss) control
system models by interconnecting them with numeric LTI models and
other Control Design Blocks. When you mark a location in a control
system model with an AnalysisPoint block, you
can use that location for linear analysis tasks, such as extracting
responses using getIOTransfer or getLoopTransfer.
You can also use such locations to specify design requirements for
control system tuning using systune or Control
System Tuner (requires Robust Control Toolbox™ software).

Compatibility Considerations

AnalysisPoint replaces the loopswitch Control
Design Block.

Models that contain loopswitch blocks continue
to work, for backward compatibility. However, it is recommended that
you use AnalysisPoint blocks in new models. If
you have scripts or functions that use loopswitch blocks,
consider updating them to use AnalysisPoint instead.

For documentation of loopswitch, see loopswitch in
the R2014a documentation.

pidtool function renamed to pidTuner

The pidtool function is now called pidTuner.
To open PID Tuner, use the pidTuner command or,
in the MATLAB desktop Apps tab, click PID
Tuner.

Using pidtool does not generate an error
in this release, but the function may be removed in a future release.

Compatibility Considerations

If you have scripts that use pidtool, consider
replacing those calls with pidTuner.

getSwitches function renamed to getPoints

The getSwitches function is now called getPoints to
match the renaming of loopswitch to AnalysisPoint.
Using getSwitches does not generate an error
in this release, but the function may be removed in a future release.

Compatibility Considerations

If you have scripts or functions that use getSwitches,
consider replacing those calls with getPoints.

Functionality being removed or changed

Functionality

What
Happens When You Use This Functionality?

Use
This Instead

Compatibility Considerations

loopswitch Control Design Block

Still works

AnalysisPoint

Consider replacing loopswitch with AnalysisPoint in
scripts and functions.

getSwitches function

Returns loopswitch and AnalysisPoint blocks
in model

getPoints

Consider replacing getSwitches with getPoints in
scripts and functions.

PID controller tuning using system identification to model
the plant from measured input-output data in the PID Tuner app (with System Identification Toolbox)

If you have System Identification Toolbox™ software, you can
use PID Tuner to fit a linear model to the measured SISO response
data from your system and tune a PID controller for the resulting
model. For example, if you want to design a PID controller for a manufacturing
process, you can start with response data from a bump test on your
system.

PID Tuner uses system identification to estimate an LTI model
from the response data. You can interactively adjust the identified
parameters to obtain an LTI model with a response that fits your response
data. PID Tuner automatically tunes a PID controller for the estimated
model. You can then interactively adjust the performance of the tuned
control system, and save the estimated plant and tuned controller.

freqsep function for decomposing a linear
system into fast dynamics and slow dynamics

Use the new freqsep command for separating
numeric LTI models into fast and slow components. freqsep allows
you to specify the cutoff frequency about which the model is decomposed.
The slow component contains poles with natural frequency below the
cutoff frequency. The fast component contains poles at or above the
cutoff.

damp command display includes time constant
information

When you call the damp command with no
output arguments, the display now includes the time constant for each
pole. The time constant is calculated as follows:

τ=1ωnζ.

ωn is the natural
frequency of the pole, and ζ is its damping
ratio.

Compatibility Considerations

For a discrete-time system with unspecified sample time (Ts
= -1), damp now calculates the natural
frequency and damping ratio by assuming Ts = 1.
Previously, the software returned [] for the natural
frequency and damping ratio of such systems.

damp returns outputs in order of increasing
natural frequency. Therefore, this change can result in reordered
poles for systems with unspecified sample times.

R2013b

SamplingGrid property for tracking dependence
of array of sampled models on variable values

In Control System Toolbox™, you can derive arrays of numeric
or generalized LTI models by sampling one or more independent variables.
The new SamplingGrid property of LTI models tracks
the variable values associated with each model in such an array.

Set this property to a structure whose fields are the names
of the sampling variables and contain the sampled variable values
associated with each model. All sampling variables should be numeric
and scalar valued, and all arrays of sampled values should match the
dimensions of the model array.

For example, suppose you create a 11-by-1 array of linear models, sysarr,
by taking snapshots of a linear time-varying system at times t
= 0:10. The following code stores the time samples with
the linear models.

Option to retain unconnected states when interconnecting models
using connect command

By default, the connect command discards
states that do not contribute to the dynamics in the path between
the inputs and outputs of the interconnected system. You can now optionally
retain such unconnected states. This option can be useful, for example,
when you want to compute the interconnected system response from known
initial state values of the components.

To instruct connect to retain unconnected
states, use the new connectOptions command with
the existing connect command.

The connect command now always returns
a state-space model, such as an ss, genss,
or uss model, unless one or more of the input
models is a frequency response data model. In that case, connect returns
a frequency response data model, such as an frd or genfrd model.

Compatibility Considerations

In previous releases, connect returned
a tf or zpk model when all
input models were tf or zpk models.
Therefore, connect might now return state-space
models in cases where it previously returned tf or zpk models.

updateSystem command for updating dynamic
system data in a response plot

The new updateSystem command replaces the
system data used to compute a response plot with data derived from
a different dynamic system, and updates the plot. updateSystem is
useful, for example, to cause a plot in a GUI to update in response
to interactive input.

getLoopID renamed to getSwitches

The getLoopID function is now called getSwitches to
more clearly reflect the purpose of the function. Using getLoopID does
not generate an error in this release, but the function may be removed
in a future release.

Compatibility Considerations

If you have scripts or functions that use getLoopID,
consider replacing those calls with getSwitches.

LoopID property of loopswitch renamed
to Location

The LoopID property of the loopswitch model
component is now called Location to more clearly
reflect the purpose of the property. Using LoopID does
not generate an error in this release, but the name may be removed
in a future release.

Compatibility Considerations

If you have scripts or functions that use the LoopID property,
consider updating your code to use Location instead.

R2013a

The PID Tuner now has a Transient behavior slider
for emphasizing either reference tracking or disturbance rejection.
When you open the PID Tuner, the tool starts in the Time
domain design mode, displaying a step plot of the reference
tracking response. The new Transient behavior slider
is beneath the Response time slider.

You can use the Transient behavior slider
when:

The tuned system's disturbance rejection response
is too sluggish for your requirements. In this case, try moving the Transient
behavior slider to the left to make the controller more
aggressive at disturbance rejection.

The tuned system's reference tracking response
has too much overshoot for your requirements. In this case, try moving
the Transient behavior slider to the right to
increase controller robustness and reduce overshoot.

In Frequency domain design mode,
the PID Tuner has Bandwidth and Phase
margin sliders. These sliders are the frequency-domain
equivalents of the Response time and Transient
behavior sliders, respectively.

New Control Design Blocks allow you to specify more control
structures and more types of constraints for fixed-structure control
system tuning in MATLAB:

ltiblock.pid2 — Tunable
two-degree-of-freedom PID controller

loopswitch — Control Design
Block for specifying feedback loop opening locations in a tunable genss model
of a control system

You can use these Control Design Blocks to build control systems
for tuning with Robust Control Toolbox tuning commands such as systune and looptune.
For more information, see the ltiblock.pid2 and loopswitch reference
pages.

Commands for obtaining open-loop responses, closed-loop responses,
and current values of tunable components from control system models

New commands allow you to compute open-loop and closed-loop
responses from a Generalized LTI model representing a control system.

getLoopTransfer —
Compute point-to-point open-loop response of a Generalized LTI model
of a control system, at a loop-opening site defined by a loopswitch block.
The new command getLoopID returns
a list of such loop-opening sites.

getIOTransfer —
Extract the closed-loop response from a specified input to a specified
output of a control system.

These commands are particularly useful for validating the response
functions of control systems tuned using Robust Control Toolbox tuning
commands such as systune.

Additionally, the new showTunable command
displays the current value of tunable components in a generalized
LTI model of a control system. This command is useful for querying
tuned parameter values of control systems tuned using Robust Control Toolbox tuning
commands such as systune.

For more information, see the reference pages for these new
commands and the following topics:

returns a logical array. B of the same size
as sysarray indicating whether the corresponding
model in sysarray contains a time delay. Without
the 'elem' flag,

B = hasdelay(sysarray);

returns a scalar logical value that is equal to 1 if
any entry in sysarray contains a time delay.

Compatibility Considerations

isfinite and isstable now
return a scalar logical value when invoked without the 'elem' flag.
Previously, isfinite and isstable returned
a logical array by default.

If you have scripts or functions that use isfinite(sysarray) or isstable(sysarray),
replace those calls with isfinite(sysarray,'elem') or isstable(sysarray,'elem') to
perform an elementwise query and obtain a logical array.

These functions use the SLICOT library of numerical algorithms.
For more information about the SLICOT library, see http://slicot.org.

Specify Target Crossover Frequency as Input to pidtune

A new syntax for pidtune lets you specify
a target crossover frequency directly as an input argument. For example,
the following command designs a PI controller, C,
for a plant model sys. The command also specifies
a target value wc for the 0 dB gain crossover
frequency of the open-loop response L = sys*C.

C = pidtune(sys,'pi',wc);

Previously, you had to use pidtuneOptions to
specify a target crossover frequency.

For discrete-time dynamic system models, the input signal applied
by impulse is now a unit area pulse of length Ts and
height 1/Ts. Ts is the sampling
time of the discrete-time system. Previously, impulse applied
a pulse of length Ts and unit height.

Compatibility Considerations

Results of this change include:

The amplitude of the impulse response calculated by impulse and impulseplot is
scaled by 1/Ts relative to previous versions.

Discretization using the impulse-invariant ('impulse')
method of c2d returns a model that is scaled
by Ts compared to previous releases. This scaling
ensures a close match between the frequency responses of the continuous-time
model and the impulse-invariant discretization as Ts approaches
zero (for strictly proper models). In previous releases, the frequency
responses differed by a factor of Ts.

First-Order Hold Method for d2c

The d2c command now supports the first-order
hold (FOH) method for converting a discrete-time dynamic system model
to continuous time. The FOH method converts by performing linear interpolation
of the inputs, assuming the control inputs are piecewise linear over
the sampling period. For more information about using this method,
see the d2c reference
page and Continuous-Discrete
Conversion Methods.

tzero Computes Invariant Zeros and Transmission Zeros

The tzero command computes the invariant
zeros of SISO and MIMO dynamic system models. For minimal realizations, tzero computes
transmission zeros. tzero also returns the normal
rank of the transfer function of the system. For more information,
see the tzero reference
page.

Models Created With System Identification Toolbox Can Be
Used Directly With Control System Toolbox Functions

Identified linear models that you create using System Identification Toolbox software
can now be used directly with Control System Toolbox analysis and
compensator design commands. In prior releases, doing so required
conversion to Control System Toolbox LTI model types.

R2011b

Formula-Based Specification of Summing Junctions and Vector
Signal Naming for sumblk and connect

You can now use formula strings to specify the behavior of summing
junctions with sumblk. For example, to create
a summing junction, S, that takes the difference
between signals r and y to produce
signal e, enter the following command:

S = sumblk('e = r-y');

Additionally, both sumblk and connect now
support vector-based signal naming for interconnecting multi-input,
multi-output (MIMO) models. For more information, see the sumblk and connect reference
pages.

Commands for Interacting with Control Design Blocks in Generalized
LTI Models

R2011a

New Model Objects for Representing Tunable Parameters and Systems
with Tunable Components

Control System Toolbox includes new model objects that you
can use to represent systems with tunable components. You can use
these models for parameter studies or controller synthesis using hinfstruct (requires Robust Control Toolbox).
The new model types include:

Control
Design Blocks—Parametric components that are the building
blocks for constructing tunable models of control systems. Control
Design Blocks include:

These models arise from interconnections between numeric LTI
models (such as tf , ss,
or frd) and Control Design Blocks. You can also
create genss models by using the tf or ss commands
with one or more realp or genmat inputs.

This release also adds new functions for working with generalized
models:

New Time and Frequency Units for Models and Response Plots

All linear model
objects now have a TimeUnit property for
specifying unit of the time variable, time delays in continuous-time
models, and sampling time in discrete-time models. The default time
units is seconds. You can specify the time units, for example, as
hours. See Specify
Model Time Units for examples.

Frequency-response data ( frd and genfrd)
models also have a new FrequencyUnit property for
specifying units of the frequency vector. The default frequency units
is rad/TimeUnit, where TimeUnit is
the system time units. You can specify the units, for example as KHz,
independently of the system time units. See Specify
Frequency Units of Frequency-Response Data Model for examples.
If your code uses the Units property of frequency-response
data models, it continues to work as before.

See the model reference pages for available time and frequency
units options.

Changing the TimeUnit and FrequencyUnit properties
changes the overall system behavior. If you want to simply change
the time and frequency units without modifying system behavior, use chgTimeUnit and chgFreqUnit,
respectively.

The time and frequency units of the model appear on the response
plots by default. For multiple systems, the units of the first system
are used. You can change the units of the time and frequency axes:

R2010b

New Commands and GUI for Modeling and Tuning PID Controllers

PID Controller Design with the New PID Tuner GUI

The new PID Tuner GUI lets you interactively tune a PID controller
for your required response characteristics. Using the GUI, you can
adjust and analyze your controller's performance with response plots,
such as reference tracking, load disturbance rejection, and controller
effort, in both time and frequency domains.

PID Controller Design with the New pidtune Command

The new pidtune command lets you tune PID
controller gains at the command line.

pidtune automatically tunes the PID gains
to balance performance (response time) and robustness (stability margins).
You can specify your own response time and phase margin targets using
the new pidtuneOptions command.

pidtune supports all types of SISO plant
models, including:

Continuous- or discrete-time plant models.

Stable, unstable, or integrating plant models.

Plant models that include I/O time delays or internal
time delays.

Arrays of plant models. If sys is
an array, pidtune designs a separate controller
for each plant in the array.

Modeling PID Controllers in Parallel Form or Standard Form

The new LTI model objects pid and pidstd are
specialized for modeling PID controllers.

With pid and pidstd you
can model a PID controller directly with the PID parameters, expressed
in parallel (pid) or standard (pidstd)
form. The pid and pidstd commands
can also convert to PID form any type of LTI object that represents
a PID controller.

Previously, to model a PID controller, you had to derive the
controller's equivalent transfer function (or other model), and could
not directly store the PID parameters.

For information about using SISO Design Tool, see SISO Design
Tool in the Control System Toolbox User's Guide.
For specific information about the automatic PID Tuning options in
SISO Design Tool, see PID
Tuning in the Control System Toolbox User's
Guide.

You can now analyze a controller design for multiple models
simultaneously using the SISO Design Tool. This feature helps you
analyze whether the controller satisfies design requirements on a
system whose exact dynamics are not known and may vary.

System dynamics can vary because of parameter variations or
different operating conditions. You represent variations in system
dynamics of the plant (G), sensor (H),
or both in a feedback structure using arrays of LTI
models. Then, design a controller for a nominal model in the
array and analyze that the controller satisfies the design requirements
on the remaining models using the design and analysis plots. For more
information, see:

R2010a

The c2d command can now approximate fractional
time delays when discretizing linear models with the tustin or matched methods.
The new c2dOptions command lets you specify an
optional Thiran all-pass filter. The Thiran filter approximates fractional
delays for improved phase matching between continuous and discretized
models. Previously, c2d rounded fractional time
delays to the nearest multiple of the sampling time when using the tustin or matched methods.
For more information, see the c2d and c2dOptions reference
pages and Continuous-Discrete
Conversion Methods in the Control System Toolbox User
Guide.

New Commands for Specifying Options for Continuous-Discrete
Conversions

New commands c2dOptions, d2dOptions,
and d2cOptions make it easier to specify options
for

Discretization using c2d

Resampling using d2d.

Conversion from discrete to continuous time using d2c.

Compatibility Considerations

This release deprecates the prewarp method
for c2d, d2d, and d2c.
Instead, use c2dOptions, d2dOptions,
or d2cOptions to specify the tustin method
and a prewarp frequency. For more information, see Continuous-Discrete
Conversion Methods and the c2d, d2d,
and d2c reference
pages.

R2009b

Ability to Design Compensators for New Types of Plants

In the SISO Design Tool, you can now design compensators for
plants models that:

Contain time delays

Previously, you had to approximate delays before designing compensators.

You specify as frequency-response data (FRD)

For more information on designing compensators using the SISO
Design Tool, see SISO Design
Tool.

New Automated PID Tuning Method

You can now tune compensators using a new automated PID tuning
algorithm called Robust Response Time, which is available in the SISO
Design Tool. You specify the open-loop bandwidth and phase margin,
and the software computes PID parameters to robustly stabilize your
system.

For information on tuning compensators using automated tuning
methods, see Automated
Tuning.

R2008b

You can now design a Linear-Quadratic-Gaussian (LQG) servo controller
for set-point tracking using the new lqi and lqgtrack commands.
This compensator ensures that the system output tracks the reference
command and rejects process disturbances and measurement noise.

New Scaling Tools to Enhance the Accuracy of Computations with
State-Space Models

You can now scale state-space models to maximize accuracy over
the frequency band of interest using the prescale command
and associated GUI. Use this functionality when you cannot achieve
good accuracy at all frequencies and some tradeoff is necessary. A
warning alerts you when accuracy may be poor and using prescaling
is recommended.

New Design Requirements

R2006a

SISO Design Tool

The SISO Design Tool now provides one-click automated tuning
using systematic algorithms such as Ziegler-Nichols PID tuning, IMC
design, and LQG design. In addition, you can calculate low-order approximations
of the IMC/LQG compensators to keep the control system complexity
low.

Compensator Optimization Is Now Supported

If you have installed Simulink Response Optimization™ software,
you can now optimize the compensator parameters inside the SISO Design
Tool GUI. You can specify time- and frequency-domain requirements
on SISO Design Tool plots such as bode and step,
and use numerical optimization algorithms to automatically tune your
compensator to meet your requirements. See the Simulink Response Optimization documentation
for more details.

Improved Compensator Editor

The Compensator Editor used to edit the numerical values of
poles and zeros has been upgraded to better handle common control
components such as lead/lag and notch filters.

Multi-Loop Compensator Design Support

Many control systems involve multiple feedback loops, some of
which are coupled and need joint tuning. The SISO Design Tool now
lets you analyze and tune multi-loop configurations. You can focus
on a specific loop by opening signals to remove the effects of other
loops, gain insight into loop interactions, and jointly tune several
SISO loops.

To improve workflow and better leverage other tools, such as Simulink Control Design software
and Simulink Response Optimization software, the SISO Design Tool
is now fully integrated with the Controls & Estimation Tools Manager
(CETM). This provides a signal environment for the design and tuning
of compensators.

When you open the SISO Design Tool, the CETM also opens with
a SISO Design Task. Many SISO Design Tool features, such as importing
models, changing loop configurations, etc., have been moved to the
SISO Design Task in CETM. In addition, related tasks such as Simulink based
Tuning and Compensator Optimization are seamlessly integrated with
the SISO Design Task. See the Control System Toolbox Getting
Started Guide for details on the new work flow.

LTI Viewer Enhancements

The LTI Viewer now lets you plot the response of a system to
user-defined input signals (lsim) and initial conditions
(initial). A new GUI lets you select input signals
from a signal generator library, or import signal data from a variety
of file formats.

LTI Objects

Descriptor and Improper State-Space Models Fully Supported

There is now full support for descriptor state-space models
with a singular E matrix. This now lets you build
state-space representations, such as PID, and manipulate improper
models with the superior accuracy of state-space computations. In
previous versions, only descriptor models with a nonsingular E matrix
were supported.

New Commands to Calculate Time Response Metrics

The new stepinfo and lsiminfo commands
compute time-domain performance metrics, such as rise time, settling
time, and overshoot. You can use these commands to write scripts that
automatically verify or optimize such performance requirements. Previously,
these metrics were available only from response plots.

Simplified System Interconnections Using I/O Channel Names

The commands connect, feedback, series, parallel,
and lft now
let you connect systems by matching names of I/O channels. A helper
function, sumblk, has also been added to simplify
the specification of summing junctions. Altogether this considerably
simplifies the task of deriving models for complicated block diagrams.
In previous releases, only index-based system connection was supported.

Changes in the Representation of I/O Delays in State-Space
Models

The ioDelay property is deprecated from state-space
models. Instead, these models have a new property called InternalDelay for
logging all delays that cannot be pushed to the inputs or outputs.
Driving this change is the switch to a representation of delays in
terms of delayed differential equations rather than frequency response.
See Models
with Time Delays in the Control System Toolbox documentation
for more details on internal delays, and ss/getdelaymodel for
details on the new internal representation of state-space models with
delays.

New Name Property for LTI Objects

This new property lets you attach a name (string) to a given
LTI model. The specified name is reflected in response plots.

New Commands and Operations for LTI Objects

The new exp command simplifies the creations
of continuous-time transfer functions with delays. For more information,
type help lti/exp at the MATLAB prompt.

R14SP3

R14SP2

Command-Line API for Customizing Plots

The Control System Toolbox software now provides a command-line
API for customizing units, labels, limits, and other plot options.
You can now change default plot options before generating a plot,
or modify plot properties after creation.

For a detailed description of the commands, see the Control System Toolbox documentation.