Simulink^{®} Control Design™ lets you linearize continuous-time
nonlinear systems. The resulting linearized model is in state-space
form.

In continuous time, the state space equations of a nonlinear system are:

$$\begin{array}{l}\dot{x}(t)=f\left(x(t),u(t),t\right)\\ y(t)=g\left(x(t),u(t),t\right)\end{array}$$

where *x*(*t*) are the
system states, *u*(*t*) are
the input signals, and *y*(*t*)
are the output signals.

To describe the linearized model, define a new set of variables of the states, inputs, and outputs centered about the operating point:

$$\begin{array}{l}\delta x(t)=x(t)-{x}_{0}\\ \delta u(t)=u(t)-{u}_{0}\\ \delta y(t)=y(t)-{y}_{0}\end{array}$$

The output of the system at the operating point is *y*(*t*_{0})=*g*(*x*_{0},*u*_{0},*t*_{0})=*y*_{0}.

The linearized state-space equations in terms of δ*x*(*t*),
δ*u*(*t*), and δ*y*(*t*)
are:

$$\begin{array}{l}\delta \dot{x}(t)=A\delta x(t)+B\delta u(t)\\ \delta y(t)=C\delta x(t)+D\delta u(t)\end{array}$$

where *A*, *B*, *C*,
and *D* are constant coefficient matrices. These
matrices are the Jacobians of the system, evaluated at the operating
point:

$$\begin{array}{l}A={\frac{\partial f}{\partial x}|}_{{t}_{0},{x}_{0},{u}_{0}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}B={\frac{\partial f}{\partial u}|}_{{t}_{0},{x}_{0},{u}_{0}}\\ C={\frac{\partial g}{\partial x}|}_{{t}_{0},{x}_{0},{u}_{0}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}D={\frac{\partial g}{\partial u}|}_{{t}_{0},{x}_{0},{u}_{0}}\end{array}$$

This linear time-invariant approximation to the nonlinear system
is valid in a region around the operating point at *t*=*t*_{0}, *x*(*t*_{0})=*x*_{0},
and *u*(*t*_{0})=*u*_{0}.
In other words, if the values of the system states, *x*(*t*),
and inputs, *u*(*t*), are close
enough to the operating point, the system behaves approximately linearly.

The transfer function of the linearized model is the ratio of
the Laplace transform of δ*y*(*t*)
and the Laplace transform of δ*u*(*t*):

$${P}_{lin}(s)=\frac{\delta Y(s)}{\delta U(s)}$$

Simulink Control Design lets you linearize multirate nonlinear systems. The resulting linearized model is in state-space form.

*Multirate models* include states with different
sampling rates. In multirate models, the state variables change values
at different times and with different frequencies. Some of the variables
might change continuously.

The general state-space equations of a nonlinear, multirate system are:

$$\begin{array}{ccc}\dot{x}\left(t\right)& =& f\left(x\left(t\right),{x}_{1}\left({k}_{1}\right),\dots ,{x}_{m}\left({k}_{m}\right),u\left(t\right),t\right)\\ {x}_{1}({k}_{1}+1)& =& {f}_{1}\left(x\left(t\right),{x}_{1}\left({k}_{1}\right),\dots ,{x}_{m}\left({k}_{m}\right),u\left(t\right),t\right)\\ \vdots & & \vdots \\ {x}_{m}({k}_{m}+1)& =& {f}_{i}\left(x\left(t\right),{x}_{1}\left({k}_{1}\right),\dots ,{x}_{m}\left({k}_{m}\right),u\left(t\right),t\right)\\ y\left(t\right)& =& g\left(x\left(t\right),{x}_{1}\left({k}_{1}\right),\dots ,{x}_{m}\left({k}_{m}\right),u\left(t\right),t\right)\end{array}$$

where *k*_{1},..., *k*_{m} are
integer values and $${t}_{{k}_{1}}$$,...,$${t}_{{k}_{m}}$$ are discrete times.

The linearized equations that approximate this nonlinear system as a single-rate discrete model are:

$$\begin{array}{ccc}\delta {x}_{k+1}& \approx & A\text{\hspace{0.05em}}\delta {x}_{k}+\text{\hspace{0.05em}}B\text{\hspace{0.05em}}\delta {u}_{k}\\ \delta {y}_{k}& \approx & C\text{\hspace{0.05em}}\delta {x}_{k}+D\text{\hspace{0.05em}}\delta {u}_{k}\end{array}$$

The rate of the linearized model is typically the least common multiple of the sample times, which is usually the slowest sample time.

For more information, see Linearization of Multirate Models .

Simulink Control Design linearizes blocks that do not have preprogrammed linearization using numerical perturbation. The software computes block linearization by numerically perturbing the states and inputs of the block about the operating point of the block.

The block perturbation algorithm introduces a small *perturbation* to
the nonlinear block and measures the response to this perturbation.
The default difference between the perturbed value and the operating
point value is $${10}^{-5}\left(1+\left|x\right|\right)$$, where *x* is
the operating point value. The software uses this perturbation and
the resulting response to compute the linear state-space of this block.

In general, a continuous-time nonlinear Simulink block in state-space form is given by:

$$\begin{array}{l}\dot{x}(t)=f\left(x(t),u(t),t\right)\\ y(t)=g\left(x(t),u(t),t\right).\end{array}$$

In these equations, *x*(*t*)
represents the states of the block, *u*(*t*)
represents the inputs of the block, and *y*(*t*)
represents the outputs of the block.

A linearized model of this system is valid in a small region
around the operating point *t*=*t*_{0}, *x*(*t*_{0})=*x*_{0}, *u*(*t*_{0})=*u*_{0},
and *y*(*t*_{0})=*g*(*x*_{0},*u*_{0},*t*_{0})=*y*_{0}.

To describe the linearized block, define a new set of variables of the states, inputs, and outputs centered about the operating point:

$$\begin{array}{l}\delta x(t)=x(t)-{x}_{0}\\ \delta u(t)=u(t)-{u}_{0}\\ \delta y(t)=y(t)-{y}_{0}\end{array}$$

The linearized state-space equations in terms of these new variables are:

$$\begin{array}{l}\delta \dot{x}(t)=A\delta x(t)+B\delta u(t)\\ \delta y(t)=C\delta x(t)+D\delta u(t)\end{array}$$

A linear time-invariant approximation to the nonlinear system is valid in a region around the operating point.

The state-space matrices *A*, *B*, *C*,
and *D* of this linearized model represent the
Jacobians of the block.

To compute the state-space matrices during linearization, the software performs these operations:

Perturbs the states and inputs, one at a time, and measures the response of the system to this perturbation by computing $$\delta \dot{x}$$ and δ

*y*.Computes the state-space matrices using the perturbation and the response.

where

*x*_{p,i}is the state vector whose*i*th component is perturbed from the operating point value.*x*_{o}is the state vector at the operating point.*u*_{p,i}is the input vector whose*i*th component is perturbed from the operating point value.*u*_{o}is the input vector at the operating point.$${\dot{x}|}_{{x}_{p,i}}$$ is the value of $$\dot{x}$$ at

*x*_{p,i},*u*_{o}.$${\dot{x}|}_{{u}_{p,i}}$$ is the value of $$\dot{x}$$ at

*u*_{p,i},*x*_{o}.$${\dot{x}}_{o}$$ is the value of $$\dot{x}$$ at the operating point.

$${y|}_{{x}_{p,i}}$$ is the value of $$y$$ at

*x*_{p,i},*u*_{o}.$${y|}_{{u}_{p,i}}$$ is the value of $$y$$ at

*u*_{p,i},*x*_{o}.*y*_{o}is the value of*y*at the operating point.

All user defined blocks such as S-Function and MATLAB Function blocks, are compatible with linearization. These blocks are linearized using numerical perturbation.

User-defined blocks do not linearize when these blocks use nondouble precision data types.

See Linearize Blocks with Nondouble Precision Data Type Signals.

Regular look up tables are numerically perturbed. Pre-lookup tables have a preprogrammed (exact) block-by-block linearization.

Was this topic helpful?