Using Linear System Model Objects
After you represent your dynamic system as a model object, you can: Attach additional information to the model using model attributes (properties). See Model Properties on page 3-2. Manipulate the model using arithmetic and model interconnection operations. See Chapter 5, Operations on Models. Analyze the model response using commands such as bode and step. See Chapter 6, Model Analysis Tools. Perform parameter studies using model arrays. See Model Arrays on page 2-58. Design compensators. You can:
Design compensators for systems specified as numeric LTI models. Available compensator design techniques include PID tuning, root locus analysis, pole placement, LQG optimal control, and frequency domain loop-shaping. See Designing Compensators. Manually tune many control architectures using the Chapter 13, SISO Design Tool. Use hinfstruct to automatically tune a control system that you represent as a genss model with tunable blocks (requires Robust Control Toolbox software). See H-Infinity Tuning of Fixed Control Structures in the Robust Control Toolbox Getting Started Guide.
Converting Between Model Types
In this section. Explicit Conversion on page 1-24 Automatic Conversion on page 1-24 Caution About Model Conversions on page 1-25

Explicit Conversion

You can convert from one type of model to another using the model-creation command for the target model type (for example, ss, tf, pid, or genss). In general, you can convert from any model type to any other. However, there are a few limitations. For example: You cannot convert from frd to analytic model types such as ss, tf, or zpk (unless you perform system identification with System Identification Toolbox software) You cannot convert ss models with internal delays to tf or zpk You can convert between Numeric LTI models and Generalized LTI models: Converting a Generalized LTI model to a Numeric LTI model evaluates any Control Design Blocks at their current (nominal) value. Converting a Numeric LTI model to a Generalized LTI model creates a Generalized LTI model with an empty Blocks property. For information about converting to a particular model type, see the reference page for that model type.

Automatic Conversion

Some algorithms operate only on one type of model object. For example, the algorithm for zero-order-hold discretization with c2d can only be performed on state-space models. Similarly, commands such as tfdata expect one particular type of model (tf). For convenience, such commands automatically convert input models to the appropriate or required model type. For example, in

frequency with good phase and magnitude approximation.

Tnd3 = pade(Tcl,3);

6 Observe the behavior of the third-order Pad approximation of Tcl.
Compare the frequency response of Tcl and Tnd3.
bode(Tcl,'-b',Tnd3,'-.r',Tnd1,'--k',{.1,10},h); legend('Exact delay','Third-Order Pade','First-Order Pade',. 'Location','SouthWest');
The magnitude and phase approximation errors are reduced when a third-order Pad approximation is used. Increasing the Pad approximation order extends the frequency band where the approximation is good. However, too high an approximation order may result in numerical issues and possibly unstable poles. Therefore, avoid Pad approximations with order N>10. More About About Internal Delays on page 2-46
Approximate Different Delays with Different Approximation Orders
This example shows how to specify different Pad approximation orders to approximate internal and output delays in a continuous-time open-loop system.
1 Load sample continuous-time open-loop system that contains internal and

output time delays.

load PadeApproximation1 sys; sys is a second-order continuous-time ss model with internal delay 3.4 s
and output delay 1.5 s. Tip Enter get(sys) for more properties of sys.
2 Use pade to compute a third-order approximation of the internal delay and
a first-order approximation of the output delay.

P13 = pade(sys,inf,1,3);

The three input arguments following sys specify the approximation orders of any input, output, and internal delays of sys, respectively. inf specifies that a delay is not to be approximated. The approximation orders for the output and internal delays are one and three respectively.
P13 is a sixth-order continuous-time ss model with no delays.
3 (Optional) For comparison, approximate only the internal delay of sys,
leaving the output delay intact.
P3 = pade(sys,inf,inf,3); P3 is a fifth-order continuous-time ss model with an output delay of 1.5
s. The internal delay is approximated and absorbed into the state-space matrices.

3 (Optional) Examine the dimensions of m2d.

arraydim = size(m2d)

This command produces the result:

arraydim = 2 3

The first entries of arraydim, 2 and 1, show that m2d is an array of two-output, one-input transfer functions.
The remaining entries in arraydim give the array dimensions of m2d, 2-by-3. In general, the dimensions of a model array are [Ny,Nu,S1,.,Sk]. Ny and Nu are the numbers of outputs and inputs of each model in the array. S1,.,Sk are the array dimensions. Thus, Si is the number of models along the ith array dimension.
4 Select the transfer function in the second row, first column of m2d.
To do so, use MATLAB array indexing.

sys = m2d(:,:,2,1)

Tip You can also access models using single index referencing of the array dimensions. For example,

sys = m2d(:,:,4)

selects the same model as m2d(:,:,2,1).
5 Select the array of subsystems from the first input to the first output

of each model in m2d.

m11 = m2d(1,1,:,:)
6 (Optional) Plot the step response of m11.

step(m11)

The step response shows that m11 is an array of six single-input, single-output (SISO) models. Note For frequency response data (FRD) models, the array indices can be followed by the keyword 'frequency' and some expression selecting a subset of the frequency points as in
sys (outputs,inputs,n1,.,nk,'frequency',SelectedFreqs)
See Referencing FRD Models Through Frequencies on page 5-11 for details on frequency point selection in FRD models.
More About Visualizing Selection of Models From Model Arrays on page 2-60
Array With Variations in Two Parameters
This example shows how to create a two-dimensional (2-D) array of transfer functions using for loops. One parameter of the transfer function varies in each dimension of the array. You can use the technique of this example to create higher-dimensional arrays with variations of more parameters.
The second-order single-input, single-output (SISO) transfer function

H ( s) =

s2 + 2 s + 2
depends on two parametersthe damping ratio and natural frequency. If both and vary, you obtain multiple transfer functions of the form:

Hij s

si j s 2 j

where i and j represent different measurements or sampled values of the variable parameters. You can collect all of these transfer functions in a single variable to create a two-dimensional model array.
1 (Optional) Preallocate memory for the model array.
You can enhance computation efficiency by preallocating memory. To do this, create an array of the required size and initialize its entries to zero.

H = tf(zeros(1,1,3,3));

In this example, there are three values for each parameter in the transfer function H. Therefore, this command creates a 3-by-3 array of single-input, single-output (SISO) zero transfer functions.
2 Create arrays containing the parameter values.
zeta = [0.66,0.71,0.75]; w = [1.0,1.2,1.5];
3 Build the array by looping through all combinations of parameter values.
for i = 1:length(zeta) for j = 1:length(w) H(:,:,i,j) = tf(w(j)^2,[1 2*zeta(i)*w(j) w(j)^2]);
end end H is a 3-by-3 array of transfer functions. varies as you move from model to model along a single column of H. The parameter varies as you move along a single row. Plotting the step response of H shows how the parameter
variation affects the step response.

step(H)

Sample a Tunable (Parametric) Model for Parameter Studies
This example shows how to sample a parametric model of a second-order filter across a grid of parameter values using replaceBlock.
1 Create a tunable (parametric) model of the second-order filter:
where the damping and the natural frequency n are the parameters.
wn = realp('wn',3); zeta = realp('zeta',0.8); F = tf(wn^2,[1 2*zeta*wn wn^2]); F is a genss model with two tunable Control Design Blocks, the realp blocks wn and zeta. The blocks wn and zeta have initial values of 3 and

0.8, respectively.

2 Sample F over a 2-by-3 grid of (wn,zeta) values.
Fsample = replaceBlock(F,'wn',[3;5],'zeta',[0.6 0.8 1.0]); Fsample is 2-by-3 array of state-space models.
3 (Optional) Plot the step response of Fsample.

step(Fsample)

The step response plot show the variation in the natural frequency and damping constant across the six models in the array Fsample. More About Models with Tunable Coefficients on page 1-19
[1] P. Gahinet and L.F. Shampine, "Software for Modeling and Analysis of Linear Systems with Delays," Proc. American Control Conf., Boston, 2004, pp. 5600-5605 [2] L.F. Shampine and P. Gahinet, Delay-differential-algebraic Equations in Control Theory, Applied Numerical Mathematics, 56 (2006), pp. 574-588
Chapter 3, Data Manipulation Chapter 4, Model Interconnections Chapter 5, Operations on Models Chapter 6, Model Analysis Tools
Model Properties on page 3-2 Extract Model Coefficients on page 3-5 Attach Metadata to Models on page 3-9 Query Model Characteristics on page 3-14 Customize Model Display on page 3-17

1 Create a MIMO transfer function.
G1 = tf(3,[1 10]); G2 = tf([1 2],[1 0]); G = [G1,G2];
2 Assign names to the model inputs.
G.InputName = {'temperature';'pressure'};
Because G has two inputs, use a cell array of two strings to specify the channel names.
3 Extract the subsystem of G that contains all dynamics from the
'temperature' input to all outputs. Gt = G(:,'temperature');
Specify and Select Input and Output Groups
This example shows how to specify groups of input and output channels in a model object and extract subsystems using the groups. Channel groups are useful for keeping track of inputs and outputs in complex MIMO models.
1 Create a state-space model with three inputs and four outputs.

H = rss(3,4,3);

2 Group the inputs as follows:
Inputs 1 and 2 in a group named controls Outputs 1 and 3 to a group named temperature Outputs 1, 3, and 4 to a group named measurements
H.InputGroup.controls = [1 2]; H.OutputGroup.temperature = [1 3]; H.OutputGroup.measurements = [4]; InputGroup and OutputGroup are structures. The name of each field in the
structure is the name of the input or output group. The value of each field is a vector that identifies the channels in that group.
3 Extract the subsystem corresponding to the controls inputs and the

temperatureoutputs.

You can use group names to index into subsystems.
Hc = H('temperature','controls') Hc is a two-input, three-output ss model containing the I/O channels from the 'controls' input the 'temperature' outputs.
The following illustration shows the relationship between H and the subsystem Hc.

Hc controls 3

temperature
Query Model Characteristics
In this section. Query Model Dynamics on page 3-14 Query Array Size on page 3-15 How to query model characteristics such as stability, time domain, and number of inputs and outputs.

Query Model Dynamics

This example shows how to query model dynamics such as stability, time domain, and model order.
1 Load the saved state-space model T.

load queryexample.mat T;

2 Query whether T has stable dynamics.
isstable(T) isstable returns a Boolean value of 1 (true) if all system poles are in the
open left-half plane (for continuous-time models) or inside the open unit disk (for discrete-time models). Otherwise, isstable returns 0 (false).
3 Query whether T has any time delays.

hasdelay(T)

This command returns 1,which indicates that T has input delay, output delay, or internal delay. Use get(T) to determine which property of T holds the time delay.
4 Query whether T is proper.

isproper(T)

This command returns 1 if the system has relative degree 0.

5 (Optional) Plot the step response of the closed-loop system.
When you build models by combining components, you can operate on those models with Control System Toolbox control design and analysis commands
Build a Model of a Multi-Input, Multi-Output (MIMO) Feedback Loop
This example shows how to build a MIMO closed-loop model using feedback.
Build a Model of a Multi-Loop Control System
This example shows how to combine models to construct an arbitrary block diagram using connect. The system of this example is a Smith Predictor, the single-input, single-output (SISO) multi-loop control system illustrated in the following block diagram.

sum1 + e

P yp Dp y1
For more information about the Smith Predictor system, see the Control System Toolbox demo Control of Processes with Long Dead Time: The Smith Predictor. The connect command lets you construct the complex interconnections of this system. To use connect, you name the input and output channels of the components of the block diagram. connect joins ports that have the same name. For example, the following illustration shows how connect joins an output of model B1 named error with an input of model B2 that has the same name.
To build the closed loop model of the Smith Predictor system from ysp to y:
1 Create model objects representing the process model P, the predictor model
Gp, and the delay model Dp. s = tf('s'); P = exp(-93.9*s) * 5.6/(40.2*s+1); P.InputName = 'u'; P.OutputName = 'y'; Gp = 5.6/(40.2*s+1); Gp.InputName = 'u'; Gp.OutputName = 'yp'; Dp = exp(-93.9*s); Dp.InputName = 'yp'; Dp.OutputName = 'y1';
Use the InputName and OutputName properties to specify signal names for the input and output of each model. When you connect these models to build the control system, these names tell connect how the models are interconnected in your block diagram. Therefore, for example, because P and Gp receive the same input signal u in the block diagram, assign them the same InputName, u. Likewise, because the output of Gp is the input of the delay Dp, set Gp.OutputName and Dp.InputName to yp.

The ss model has the highest precedence among Numeric LTI models. Therefore, combining P and C with any model interconnection command returns an ss model. For example, entering:

CL = feedback(P*C,1)

returns a state-space model. Combining the ss model CL with the Control Design Block F returns a Generalized state-space (genss) model.

CLF = F*CL

Recommended Model Type for Building Block Diagrams
You can represent block diagram components with any model type. However, some connection operations convert models to ss form before computing the combined model. Therefore, working with tf or zpk models causes the software to perform multiple conversions to and from thess representation. These conversions can result in high-order polynomials whose evaluation can be plagued by inaccuracies. Additionally, the tf or zpk representations are inefficient for manipulating multi-input multi-output (MIMO) systems and tend to inflate the model order. Therefore, ss or frd models yield the most accurate numerical results. For example, load the models Pd and Cd, which are are 9th-order and 2nd-order discrete-time transfer functions, respectively.

load numdemo Pd Cd

Even connecting these two models in series can lead to numerical inaccuracies. To see this, compute the open-loop transfer function L = Pd*Cd using the tf, zpk, ss, and frd representations.
Ltf = Pd*Cd; Lzp = zpk(Pd)*Cd; Lss = ss(Pd)*Cd; w = logspace(-1,3,100); Lfrd = frd(Pd,w)*Cd;
Plot the magnitude of the frequency response to compare the four representations.
bodemag(Ltf,Lzp,Lss,Lfrd) legend('tf','zpk','ss','frd')
The tf representation has lost low-frequency dynamics that are preserved in the other representations.
Overview on page 5-2 Precedence and Property Inheritance on page 5-3 Viewing LTI Systems as Matrices on page 5-5 Data Retrieval on page 5-6 Extracting and Modifying Subsystems on page 5-8 Arithmetic Operations on LTI Models on page 5-15 Model Interconnection Functions on page 5-20 Converting Between Continuous- and Discrete-Time Representations on page 5-24 Resampling of Discrete-Time Models on page 5-37 References on page 5-41

Overview

You can perform basic matrix operations such as addition, multiplication, or concatenation on models objects or model arrays. Such operations are "overloaded," which means that they use the same syntax as they do for matrices, but are adapted to apply to model objects. These overloaded operations and their interpretation in this context are discussed in this chapter. You can read about discretization methods in this chapter as well. These operations can be applied to model objects of different types. As a result, before discussing operations on LTI models, we discuss model type precedence and how LTI model properties are inherited when models are combined using these operations. To read about functions for analyzing LTI models, see Chapter 6, Model Analysis Tools.

creates the one-output/two-input transfer function
s 1 H ( s) = 2 s + 2s + 10

Typing

[num,den] = tfdata(H); num{1,1}, den{1,1}
displays the coefficients of the numerator and denominator of the first input channel.

ans = 0 ans = -1

Note that the same result is obtained using dot notation:

H.num{1,1}, H.den{1,1}

To obtain the numerator and denominator of SISO systems directly as row vectors, use the syntax
[num,den,Ts] = tfdata(sys,'v')

For example, typing

sys = tf([1 3],[5]); [num,den] = tfdata(sys,'v')

produces

num = 0 den = 3

Similarly,

[z,p,k,Ts] = zpkdata(sys,'v')
returns the zeros, z, and the poles, p, as vectors for SISO systems.
Extracting and Modifying Subsystems
In this section. What is a Subsystem? on page 5-8 Basic Subsystem Concepts on page 5-8 Referencing FRD Models Through Frequencies on page 5-11 Referencing Channels by Name on page 5-12 Resizing LTI Systems on page 5-13

What is a Subsystem?

Subsystems relate subsets of the inputs and outputs of a system. The transfer matrix of a subsystem is a submatrix of the system transfer matrix.

Basic Subsystem Concepts

For example, if sys is a system with two inputs, three outputs, and I/O relation y = Hu then H(3, 1) gives the relation between the first input and third output: y3 = H(3, 1)u1. Accordingly, use matrix-like subindexing to extract this subsystem.

SubSys = sys(3,1)

The resulting subsystem SubSys is an LTI model of the same type as sys, with its sample time, time delay, I/O name, and I/O group property values inherited from sys. For example, if sys has an input group named controls consisting of channels one, two, and three, then SubSys also has an input group named controls with the first channel of SubSys assigned to it.
If sys is a state-space model with matrices a, b, c, d, the subsystem sys(3,1) is a state-space model with data a, b(:,1), c(3,:), d(3,1). Note the following rules when extracting subystems: In the expression sys(3,1), the first index selects the output channel while the second index selects the input channel. When extracting a subsystem from a given state-space model, the resulting state-space model may not be minimal. Use the command sminreal to eliminate unnecessary states in the subsystem. You can use similar syntax to modify the LTI model sys. For example,

Inversion and Related Operations
Inversion of LTI models amounts to inverting the following input/output relationship. y = Hu u = H-1y. This operation is defined only for square systems (that is, systems with as many inputs as outputs) and is performed using

inv(sys)

The resulting inverse model is of the same type as sys. Related operations include: Left division sys1\sys2, which is equivalent to inv(sys1)*sys2 Right division sys1/sys2, which is equivalent to sys1*inv(sys2) For a state-space model sys with data A, B, C, D, inv(sys) is defined only when D is a square invertible matrix, in which case its state-space data is ABD1C, BD1, D1C, D1.

Transposition

You can transpose an LTI model sys using
This is a literal operation with the following effect: For TF models (with input arguments, num and den), the cell arrays num and den are transposed. For ZPK models (with input arguments, z, p, and k), the cell arrays, z and p, and the matrix k are transposed.
For SS models (with model data A, B, C, D), transposition produces the state-space model AT, CT, BT, DT. For FRD models (with complex frequency response matrix Response), the matrix of frequency response data at each frequency is transposed.

Pertransposition

For a continuous-time system with transfer function H(s), the pertransposed system has the transfer function G(s) = [H(s)]T. The discrete-time counterpart is G(z) = [H(z1)]T. Pertransposition of an LTI model sys is performed using
You can use pertransposition to obtain the Hermitian (conjugate) transpose of the frequency response of a given system. The frequency response of the pertranspose of H(s), G(s) = [H(s)]T, is the Hermitian transpose of the frequency response of H(s): G(jw) = H(jw)H. To obtain the Hermitian transpose of the frequency response of a system sys over a frequency range specified by the vector w, type

freqresp(sys', w);

Model Interconnection Functions
In this section. Supported Interconnection Functions on page 5-20 Concatenation of LTI Models on page 5-21 Feedback and Other Interconnection Functions on page 5-22

oloop = H * sys11;

and draw another root locus for this open-loop model.

rlocus(-oloop) sgrid

Create and drag a data marker around the upper curve to locate the maximum damping, which is about = 0.3.
This figure shows a data marker at the maximum damping ratio; the gain is approximately 2.07.
Look at the closed-loop response from rudder to yaw rate.
K = 2.07; cl11 = feedback(oloop,-K); impulse(cl11,20)
The response settles nicely but has less damping than your previous design. Finally, you can verify that the washout filter has fixed the spiral mode problem. First form the complete washout filter kH(s) (washout + gain).

WOF = -K * H;

Then close the loop around the first I/O pair of the MIMO model sys and simulate the impulse response.
cloop = feedback(sys,WOF,1,1); % Final closed-loop impulse response impulse(sys,'b--',cloop,'r',20)
The bank angle response (output 2) due to an aileron impulse (input 2) now has the desired nearly constant behavior over this short time frame. To inspect the response more closely, use the I/O Selector in the right-click menu to select the (2,2) I/O pair.
Although you did not quite meet the damping specification, your design has increased the damping of the system substantially and now allows the pilot to fly the aircraft normally.
Hard-Disk Read/Write Head Controller
In this section. Overview of this Case Study on page 11-19 Creating the Read/Write Head Model on page 11-19 Model Discretization on page 11-20 Adding a Compensator Gain on page 11-22 Adding a Lead Network on page 11-23 Design Analysis on page 11-26
This case study demonstrates the ability to perform classical digital control design by going through the design of a computer hard-disk read/write head position controller.
Creating the Read/Write Head Model
Using Newtons law, a simple model for the read/write head is the differential equation

d + K = K ii dt

where J is the inertia of the head assembly, C is the viscous damping coefficient of the bearings, K is the return spring constant, Ki is the motor torque constant, is the angular position of the head, and i is the input current. Taking the Laplace transform, the transfer function from i to is

rlocus(oloop) zgrid

Open the Property Editor by right-clicking in the plot away from the curve. On the Limits page, set the x- and y-axis limits from -1 to 1.01. This figure shows the result.
This time, the poles stay within the unit circle for some time (the lines drawn by zgrid show the damping ratios from = 0 to 1 in steps of 0.1). Use a data marker to find the point on the curve where the gain equals 4.111e+03. This figure shows the data marker at the correct location.

Design Analysis

To analyze this design, form the closed-loop system and plot the closed-loop step response.
K = 4.11e+03; cloop = feedback(oloop,K); step(cloop)
This response depends on your closed loop set point. The one shown here is relatively fast and settles in about 0.07 seconds. Therefore, this closed loop disk drive system has a seek time of about 0.07 seconds. This is slow by todays standards, but you also started with a very lightly damped system. Now look at the robustness of your design. The most common classical robustness criteria are the gain and phase margins. Use the function margin to determine these margins. With output arguments, margin returns the gain and phase margins as well as the corresponding crossover frequencies. Without output argument, margin plots the Bode response and displays the margins graphically. To compute the margins, first form the unity-feedback open loop by connecting the compensator D(z), plant model, and feedback gain k in series.

olk = K * oloop;

Next apply margin to this open-loop model. Type
[Gm,Pm,Wcg,Wcp] = margin(olk); Margins = [Gm Wcg Pm Wcp] Margins = 3.7987 296.7978 43.2031 106.2462
To obtain the gain margin in dB, type
20*log10(Gm) ans = 11.5926
You can also display the margins graphically by typing

margin(olk)

The command produces the plot shown below.
This design is robust and can tolerate a 11 dB gain increase or a 40 degree phase lag in the open-loop system without going unstable. By continuing this design process, you may be able to find a compensator that stabilizes the open-loop system and allows you to reduce the seek time.

from: The MATLAB workspace A MAT-file
3 Click Import, then click Close. You can now see the model loaded into the
system selected in the System Data dialog.
4 Click OK. The Graphical Tuning window is updated with the model you
loaded. Alternatively, you can import by entering a valid expression or variable (double, LTI object or row or column array of LTI objects) in the Data column in the System Data window. For more information, see Importing Models into the SISO Design Tool.
Sample Times for Continuous/Discrete Conversions
Click Sample Time Conversion to convert the sample time of the system or switch between different sample times to design different compensators.
Choose from Zero-Order Hold, First-Order Hold, Impulse Variant, Tustin, Tustin w/Prewarping, and Matched Pole-Zero. For a full description, see Continuous/Discrete Conversions Using the Sample Time Conversion Dialog Box on page 13-50.

Multimodel Configuration

The Multimodel Configuration button is enabled only when you import or open the SISO Design Tool GUI with a row or column arrays of LTI models for the plant G or sensor H or both. The LTI arrays model system variations in the plant and sensor. If both G and H are arrays, their sizes must match. Click Multimodel Configuration to specify the nominal model and frequency grid for multimodel computations. This action opens the Multimodel Configuration Dialog window, as shown in the next figure.
For more information, see Control Design Analysis of Multiple Models.

Compensator Editor

Use the Compensator Editor for adding or editing gains, poles, and zeros.
Compensator Editor Pane on the SISO Design Task Node
1 Enter the compensator gain in the text box in the top part of the pane. 2 Add or remove compensator poles and zeros by right-clicking in the

Dynamics table.

3 Adjust pole and zero settings by entering values directly in the Edit
Selected Dynamics group box.

Graphical Tuning

Use the Graphical Tuning pane for Configuring Design Plots for the Graphical Tuning Window on page 13-20 Selecting New Loops to Tune on page 13-22 Refocusing on the Graphical Tuning Window on page 13-22

Note Click items on the menu bar pictured below to get help contents.
Open-Loop Right-Click Menu Note that if you have a closed-loop response, the Gain Target menu item is replaced by Select Compensator on page 13-78.

Add Pole/Zero

The Add Pole/Zero menu options give you the ability to add dynamics to your compensator design, including poles, zeros, lead and lag networks, and notch filters. The following pole/zero configurations are available: Real Pole Complex Pole Integrator Real Zero Complex Zero Differentiator Lead Lag Notch In all but the integrator and differentiator, once you select the configuration, your cursor changes to an x. To add the item to your compensator design,
place the x at the desired location on the plot and left-click your mouse. You will see the root locus design automatically update to include the new compensator dynamics. The notch filter has three adjustable parameters. For a discussion about how to add and adjust notch filters, see "Adding a Notch Filter" in the Control System Toolbox Getting Started Guide. Note For systems with FRD plants, you cannot add or modify poles and zeros outside the plotted frequency range on Bode and Nichols plots. Instead, you can make such modifications using the Compensator Editor pane of the Control and Estimation Tools Manager. For more information, see Compensator Editor on page 13-18.
Example: Adding a Complex Pair of Poles
This example shows you how to add a complex pair of poles to the open-loop Bode diagram. First, type
load ltiexamples sisotool('bode',sys_dc)
at the MATLAB prompt. This opens the SISO Design Tool with the DC motor example loaded and the open-loop Bode diagram displayed in the Graphical Tuning window.
To add a complex pair of poles:
1 Select Add Pole/Zero->Complex Pole from the right-click menu 2 Place the mouse cursor where you want the pole to be located 3 Left-click to add the pole
Your Graphical Tuning window should look similar to this.
In the case of Bode diagrams, when you place a complex pole, the default damping value is 1, which means you have a double real pole. To change the damping, grab the red x by left-clicking on it and drag it upward with your mouse. You will see damping ratio change in the Status pane at the bottom of the SISO Design Tool.