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:
u(t) are the inputs
y(t) the outputs
x(t) are the model states with initial value x0
is the state derivative vector for continuous-time systems and the state update vector 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:
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:
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™.
You can access this block from the Control System Toolbox library. For an example of using this block, see State Estimation Using Time-Varying Kalman Filter.
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).
For more information about using AnalysisPoint blocks, see:
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.
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.
If you have scripts that use pidtool, consider replacing those calls with pidTuner.
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.
If you have scripts or functions that use getSwitches, consider replacing those calls with getPoints.
|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.|
|pidtool function||Still works||pidTuner||Consider replacing pidtool with pidTuner in scripts.|
The redesigned PID Tuner streamlines workflows for interactively tuning PID controllers for reference tracking and disturbance rejection.
To access the PID Tuner, use the pidtool command. For example, to tune a PI controller for an LTI model, G:
For more information about the PID Tuner, see Designing PID Controllers with the PID Tuner.
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.
For an example, see Interactively Estimate Plant Parameters from Response Data.
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.
For more information, see the freqsep reference page.
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:
ωn is the natural frequency of the pole, and ζ is its damping ratio.
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.
For more information on the outputs, see the damp reference page.
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.
sys.SamplingGrid = struct('time',0:10)
For an additional examples, see:
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.
For more information, see the connectOptions reference page.
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.
For more information, see the connect reference page.
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.
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.
For more information, see:
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.
If you have scripts or functions that use getLoopID, consider replacing those calls with getSwitches.
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.
If you have scripts or functions that use the LoopID property, consider updating your code to use Location instead.
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
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:
The new 'elem' flag causes elementwise operation on model arrays of the model query commands:
For example, for an array, sysarray, of dynamic system models,
B = hasdelay(sysarray,'elem');
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.
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.
Control System Toolbox software includes two new frequency analysis commands:
getPeakGain — Peak gain of frequency response of a dynamic system model
getGainCrossover — Frequencies at which system gain crosses a specified gain level
These functions use the SLICOT library of numerical algorithms. For more information about the SLICOT library, see http://slicot.org.
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 more information, see the pidtune reference page.
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.
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.
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.
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.
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.
Identified linear models can be used directly with:
Any Control System Toolbox or Robust Control Toolbox functions that operate on dynamic systems, including:
For a complete list of these functions, enter:
The LTI System block in Simulink models.
|Functionality||What Happens When You Use This Functionality?||Use This Instead||Compatibility Considerations|
|impulse(sys) and impulseplot(sys), for discrete-time sys||Still works.||N/A||Amplitude of response is scaled by 1/Ts compared to previous versions. Ts is sampling time of sys.|
|c2d(sys,Ts,'impulse')||Still works.||N/A||Resulting discretized model is scaled by Ts compared to previous releases.|
|[y,t] = impulse(sys,Tfinal)|
[y,t] = step(sys,Tfinal)
[y,t,x] = initial(sys,Tfinal)
|For discrete-time sys with undefined sample time (Ts=-1), Tfinal is interpreted as the number of sampling periods to simulate.||N/A||Expect the number of simulation data points to be Tfinal + 1 instead of Tfinal.|
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');
getValue — Get nominal value of Generalized Model (replaces getNominal)
setValue — Modify value of Control Design Block
getBlockValue — Get nominal value of Control Design Block in Generalized Model
setBlockValue — Set value of Control Design Block in Generalized Model
showBlockValue — Display nominal values of Control Design Blocks in Generalized Model
For more information about these commands, see the reference pages for each command.
|Functionality||What Happens When You Use This Functionality?||Use This Instead||Compatibility Considerations|
|delay2z||Errors||absorbDelay||Replace delay2z with absorbDelay.|
|getNominal||Errors||getValue||Replace getNominal with getValue.|
|Scale and Info properties of realp parameter||Errors||None||None|
|sumblk('a','b','c','+-')||Still works||sumblk('a=b-c')||Use new formula-based syntax for sumblk.|
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:
Generalized and Uncertain LTI Models—Models representing systems that have both fixed and tunable coefficients. Generalized LTI models 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:
For more information about the new model types and about modeling systems that contain tunable coefficients, see the following in the Control System Toolbox User's Guide:
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:
Graphically, using the following editors:
Programmatically, by setting the following properties of plots:
For a discrete-time pid controller with a derivative filter (Tf≠ 0) and Dformula set to 'ForwardEuler', the sampling time Ts must be less than 2*Tf.
For a discrete-time pidstd controller with a derivative filter (N≠ Inf) and Dformula set to 'ForwardEuler', the sampling time Ts must be less than 2*Td/N.
The Trapezoidal value for DFormula is not available for a discrete-time pid or pidstd controller with no derivative filter (Tf = 0 or N = Inf).
On loading pid or pidstd controllers saved under previous versions, the software changes certain properties of controllers that do not have stable derivative filter poles.
For a discrete-time pid controller with a derivative filter (Tf≠ 0), Dformula set to 'ForwardEuler', and sampling time Ts ≥ 2*Tf, the derivative filter time is reset to Tf = Ts.
For a discrete-time pidstd controller with a derivative filter (N≠ Inf), Dformula set to 'ForwardEuler', the sampling time Ts ≥ 2*Td/N, the derivative filter constant is reset to N = Td/Ts.
For a discrete-time pid or pidstd controller with no derivative filter and DFormula = 'Trapezoidal', the derivative filter integrator formula is reset to DFormula = 'ForwardEuler'.
The software issues a warning when it changes any of these values. If you receive such a warning, validate your controller to ensure that the new values achieve the desired performance.
Use the new variable by setting the Variable property of a tf or zpk model to q^-1. For example, entering:
H = tf([1 2 3],[5 6 7],0.1,'Variable','q^-1')
creates the following discrete-time transfer function:
Transfer function: 1 + 2 q^-1 + 3 q^-2 ------------------- 5 + 6 q^-1 + 7 q^-2 Sampling time (seconds): 0.1
When you set Variable to q^-1, tf interprets the numerator and denominator vectors as ascending powers of q^-1.
This release introduces specialized tools for modeling and designing PID controllers.
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.
The PID Tuner 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 delay
For more information about using PID Tuner, see:
Designing PID Controllers in the Control System Toolbox Getting Started Guide
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.
For additional information, see:
The new Control System Toolbox demo Designing Cascade Control System with PI ControllersDesigning Cascade Control System with PI Controllers
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.
This release includes improvements to the PID Tuning options in the Automated Tuning pane of SISO Design Tool.
In addition to the Robust Response Time tuning algorithm, SISO Design Tool offers a collection of classical design formulas, including the following:
Approximate M-Constrained Integral Gain Optimization (MIGO) Frequency Response
Approximate MIGO Step Response
Skogestad Internal Model Control (IMC)
Ziegler-Nichols Frequency Response
Ziegler-Nichols Step Response
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:
Control Design Analysis of Multiple Models in the Control System Toolbox documentation.
Reference Tracking of a DC Motor with Parameter VariationsReference Tracking of a DC Motor with Parameter Variations demo in Simulink Control Design™ software.
The output of the repsys command when called with a single dimension argument has changed.
In prior versions, the output of repsys(sys,N) was the same as that of append(sys,...,sys).
Now, repsys(sys,N) returns the same result as repsys(sys,[N N]).
The results of other syntaxes for repsys have not changed.
Code that depends upon the previous result of repsys(sys,N) no longer returns that result. To obtain the previous result, replace repsys(sys,N) with sys*eye(N).
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 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.
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.
You can now remove selected data from frd models using the new fdel command. For example, use fdel to:
Remove spurious or unneeded data from frd models you create from measured frequency response data.
Remove data at intersecting frequencies from frd models before merging them into a single frd model with fcat, which can only merge frd models containing no common frequencies.
For more information, see fdel reference page.
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.
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.
The variable q is now defined in the standard way as the forward shift operator z. Previously, q was defined as z-1.
If you use the q variable, you may receive different results than in previous releases when you:
Create a transfer function
Modify the num or den properties of an existing transfer function
The resulting transfer function differs from previous releases when both the
Variable property is set to q
num and den properties have different lengths
For example, the following code:
H = tf([1,2],[1 3 8],0.1,'Variable','q')
now returns the transfer function
Previously, the code returned the transfer function
The two transfer functions have different numerators.
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.
The 'current' flag was moved from the lqgreg function to the kalman function.
The following code:
kest = kalman(sys,Qn,Rn) c = lqgreg(kest,k)
now returns the current regulator instead of the delayed regulator .
To update your code to return the same results as in previous releases, use the following code with the added string 'delayed' in the kalman command:
kest = kalman(sys,Qn,Rn,'delayed') c = lqgreg(kest,k)
You can now upsample a discrete-time system to an integer multiple of the original sampling rate without any distortion in the time or frequency domain using the upsample command.
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.
You can now reorder the states of state-space models according to a specified permutation using the xperm command.
For more information on reordering states, see the xperm reference page.
You can now make the following changes to your Control System Toolbox response plots using the figure plotting tools:
For more information on customizing the appearance of response plots using plot tools, see Customizing Response Plots Using Plot Tools in the Control System Toolbox User's Guide.
The Control System Toolbox demos have been reformatted and expanded to include more examples and content. Demos in the following categories now have new and improved content:
Getting Started with LTI Models
Discretization and Sampling Rate Conversions
How to Get Accurate Results
To open the Control System Toolbox demos, type
demo toolbox control
at the MATLAB prompt.
Control System Toolbox software now lets you:
Model, simulate, and analyze any interconnection of linear systems with delays, such as systems containing feedback loops with delays.
Exactly analyze and simulate control systems with long delays. You can evaluate control strategies, such as Smith Predictor and PID control for first-order-plus-dead-time plants.
For more information, see the section on Models with Time Delays in the Control System Toolbox documentation.
Control System Toolbox software now provides the following new and updated automated tuning methods:
New Singular Frequency Based Tuning lets you design PID compensators for both stable and unstable plants.
New H-infinity Loop Shaping lets you find compensators based on a desired open-loop bandwidth or loop shape. This feature requires Robust Control Toolbox software.
Updated Internal Model Control (IMC) Tuning now supports unstable plants.
For more information, see the section on automated tuning in the Control System Toolbox documentation.
The d2d function now includes the following new options for the resampling method:
'tustin'—Performs Bilinear (Tustin) approximation
'prewarp'—Performs Tustin approximation with frequency prewarping
For more information, see the d2d reference pages.
Two new loop configurations are available from the SISO Design Tool. See Modifying Block Diagram Structure for more information.
The LTI Viewer now supports step response and upper/lower time bound design requirements. See Adding Design Requirements to the LTI Viewer for more information.
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.
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.
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.
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.
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.
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.
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.
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.
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.
This new property lets you attach a name (string) to a given LTI model. The specified name is reflected in response plots.
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.
The frd object has the following new methods:
fcat — Concatenates one or more FRD models along the frequency dimension (data merge).
fselect — Selects frequency points or range in frd model.
fnorm — Calculates pointwise peak gain of frd model.
The .* operation is supported for transfer functions and zero-pole-gain objects. This allows you to perform element-by-element multiplication of MIMO models.
There have been several major improvements in the Control System Toolbox numerical algorithms, many of which benefit the upgraded SISO Design Tool:
New scaling algorithm that maximizes accuracy for badly scaled state-space models
Performance improvement in time and frequency response computations through MEX-files
More accurate computations of the zero-pole-gain and transfer function representations of a state-space model
More accurate state-space representations of zero-pole-gain models
Better handling of nonminimal modes in model reduction commands (balred, balreal)
canon now computes a block modal form for A matrices that are not diagonizable or are nearly defective
Exact phase computation for zero-pole-gain models in bode and nichols
Accurate handling of improper models using the descriptor state-space representation
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.
You can now create
Single piecewise linear constraints for root-locus and Bode plots
Gain/phase exclusion regions for Nichols plots
Design constraints are displayed as shaded regions.
When editing Bode and Nichols plots, you can now
Set the lower limit of the magnitude manually.
Adjust the phase offsets by multiples of 360 degrees to facilitate comparing multiple responses.
|Release||Features or Changes with Compatibility Considerations|
|R2014a||damp command display includes time constant information|
|R2012b||Option for elementwise operation of model query commands on model arrays|
|R2011b||Functionality Being Removed or Changed|
|R2011a||Discrete-Time PID Controller Objects Have Stable Derivative Filter Pole|
|R2010b||Change in Output of repsys Command|
|R2010a||New Commands for Specifying Options for Continuous-Discrete Conversions|
|R2009a||Variable q Now Defined as the Forward Shift Operator z|
|R2008b||New Design Tools for Linear-Quadratic-Gaussian (LQG) Servo Controllers with Integral Action|