# Documentation

## Models with Fixed Coefficients

### Numeric LTI Models

Numeric LTI models are the basic representation of linear systems or components of linear systems whose coefficients are fixed numeric values.

#### Applications of Numeric LTI Models

You can use Numeric LTI models to represent block diagram components such as plant or sensor dynamics. By connecting Numeric LTI models together, you can derive Numeric LTI models of block diagrams. Use Numeric LTI models for most modeling, analysis, and control design tasks, including:

#### Types of Numeric LTI Models

Control System Toolbox™ includes the following types of numeric LTI models:

### Transfer Functions

#### Transfer Function Representations

Control System Toolbox software supports transfer functions that are continuous-time or discrete-time, and SISO or MIMO. You can also have time delays in your transfer function representation.

A SISO transfer function is expressed as the ratio:

$G\left(s\right)=\frac{N\left(s\right)}{D\left(s\right)},$

of polynomials N(s) and D(s), called the numerator and denominator polynomials, respectively.

You can represent linear systems as transfer functions in polynomial or factorized (zero-pole-gain) form. For example, the polynomial-form transfer function:

$G\left(s\right)=\frac{{s}^{2}-3s-4}{{s}^{2}+5s+6}$

can be rewritten in factorized form as:

$G\left(s\right)=\frac{\left(s+1\right)\left(s-4\right)}{\left(s+2\right)\left(s+3\right)}.$

The `tf` model object represents transfer functions in polynomial form. The `zpk` model object represents transfer functions in factorized form.

MIMO transfer functions are arrays of SISO transfer functions. For example:

$G\left(s\right)=\left[\begin{array}{c}\frac{s-3}{s+4}\\ \frac{s+1}{s+2}\end{array}\right]$

is a one-input, two output transfer function.

#### Commands for Creating Transfer Functions

Use the commands described in the following table to create transfer functions.

Command

Description

`tf`

Create `tf` objects representing continuous-time or discrete-time transfer functions in polynomial form.

`zpk`

Create `zpk` objects representing continuous-time or discrete-time transfer functions in zero-pole-gain (factorized) form.

`filt`

Create `tf` objects representing discrete-time transfer functions using digital signal processing (DSP) convention.

### State-Space Models

#### State-Space Model Representations

State-space models rely on linear differential equations or difference equations to describe system dynamics. Control System Toolbox software supports SISO or MIMO state-space models in continuous or discrete time. State-space models can include time delays. You can represent state-space models in either explicit or descriptor (implicit) form.

State-space models can result from:

• Linearizing a set of ordinary differential equations that represent a physical model of the system.

• State-space model identification using System Identification Toolbox™ software.

• State-space realization of transfer functions. (See Conversion Between Model Types for more information.)

Use `ss` model objects to represent state-space models.

#### Explicit State-Space Models

Explicit continuous-time state-space models have the following form:

$\begin{array}{c}\frac{dx}{dt}=Ax+Bu\\ y=Cx+Du\end{array}$

where x is the state vector. u is the input vector, and y is the output vector. A, B, C, and D are the state-space matrices that express the system dynamics.

A discrete-time explicit state-space model takes the following form:

$\begin{array}{c}x\left[n+1\right]=Ax\left[n\right]+Bu\left[n\right]\\ y\left[n\right]=Cx\left[n\right]+Du\left[n\right]\end{array}$

where the vectors x[n], u[n], and y[n] are the state, input, and output vectors for the nth sample.

#### Descriptor (Implicit) State-Space Models

A descriptor state-space model is a generalized form of state-space model. In continuous time, a descriptor state-space model takes the following form:

$\begin{array}{c}E\frac{dx}{dt}=Ax+Bu\\ y=Cx+Du\end{array}$

where x is the state vector. u is the input vector, and y is the output vector. A, B, C, D, and E are the state-space matrices.

#### Commands for Creating State-Space Models

Use the commands described in the following table to create state-space models.

CommandDescription
`ss`

Create explicit state-space model.

`dss`

Create descriptor (implicit) state-space model.

`delayss`

Create state-space models with specified time delays.

### Frequency Response Data (FRD) Models

#### Frequency Response Data

In the Control System Toolbox software, you can use `frd` models to store, manipulate, and analyze frequency response data. An `frd` model stores a vector of frequency points with the corresponding complex frequency response data you obtain either through simulations or experimentally.

For example, suppose you measure frequency response data for the SISO system you want to model. You can measure such data by driving the system with a sine wave at a set of frequencies ω1ω2, ,...,ωn, as shown:

At steady state, the measured response yi(t) to the driving signal at each frequency ωi takes the following form:

${y}_{i}\left(t\right)=a\mathrm{sin}\left({\omega }_{i}t+b\right),\text{ }i=1,\text{\hspace{0.17em}}\dots ,\text{\hspace{0.17em}}n.$

The measurement yields the complex frequency response G at each input frequency:

$G\left(j{\omega }_{i}\right)=a{e}^{jb},\text{ }i=1,\text{\hspace{0.17em}}\dots ,\text{\hspace{0.17em}}n.$

You can do most frequency-domain analysis tasks on `frd` models, but you cannot perform time-domain simulations with them. For information on frequency response analysis of linear systems, see Chapter 8 of [1].

#### Commands for Creating FRD Models

Use the following commands to create FRD models.

Command

Description

`frd`Create `frd` objects from frequency response data.
`frestimate`Create `frd` objects by estimating the frequency response of a Simulink® model. This approach requires Simulink Control Design™ software. See Frequency Response Estimation in the Simulink Control Design documentation for more information.

### PID Controllers

#### Continuous-Time PID Controller Representations

You can represent continuous-time Proportional-Integral-Derivative (PID) controllers in either parallel or standard form. The two forms differ in the parameters used to express the proportional, integral, and derivative actions and the filter on the derivative term, as shown in the following table.

FormFormula
Parallel

$C={K}_{p}+\frac{{K}_{i}}{s}+\frac{{K}_{d}s}{{T}_{f}s+1},$

where:

• Kp = proportional gain

• Ki = integrator gain

• Kd = derivative gain

• Tf = derivative filter time

Standard

$C={K}_{p}\left(1+\frac{1}{{T}_{i}s}+\frac{{T}_{d}s}{\frac{{T}_{d}}{N}s+1}\right),$

where:

• Kp = proportional gain

• Ti = integrator time

• Td = derivative time

• N = derivative filter constant

Use a controller form that is convenient for your application. For example, if you want to express the integrator and derivative actions in terms of time constants, use Standard form.

#### Discrete-Time PID Controllers

Discrete-time PID controllers are expressed by the following formulas.

FormFormula
Parallel

$C={K}_{p}+{K}_{i}IF\left(z\right)+\frac{{K}_{d}}{{T}_{f}+DF\left(z\right)},$

where:

• Kp = proportional gain

• Ki = integrator gain

• Kd = derivative gain

• Tf = derivative filter time

Standard

$C={K}_{p}\left(1+\frac{1}{{T}_{i}}IF\left(z\right)+\frac{{T}_{d}}{\frac{{T}_{d}}{N}+DF\left(z\right)}\right),$

where:

• Kp = proportional gain

• Ti = integrator time

• Td = derivative time

• N = derivative filter constant

IF(z) and DF(z) are the discrete integrator formulas for the integrator and derivative filter, respectively. Use the `IFormula` and `DFormula` properties of the `pid` or `pidstd` model objects to set the IF(z) and DF(z) formulas. The next table shows available formulas for IF(z) and DF(z). Ts is the sample time.

`IFormula` or `DFormula`IF(z) or DF(z)
`ForwardEuler` (default)

$\frac{{T}_{s}}{z-1}$

`BackwardEuler`

$\frac{{T}_{s}z}{z-1}$

`Trapezoidal`

$\frac{{T}_{s}}{2}\frac{z+1}{z-1}$

If you do not specify a value for `IFormula`, `DFormula`, or both, `ForwardEuler` is used by default.