This record defines a linear time invariant difference equation system in state space form:

x(Ts*(k+1)) =A*x(Ts*k) +B*u(Ts*k)y(Ts*k) =C*x(Ts*k) +D*u(Ts*k)x_continuous(Ts*k) =x(Ts*k) +B2*u(Ts*k)

with

**Ts**- the sample time**k**- the index of the actual sample instance (k=0,1,2,3,...)**t**- the time**u**(t) - the input vector,**y**(t) - the output vector,**x**(t) - the discrete state vector (x(t=Ts*0) is the initial state),**x**_continuous(t) - the state vector of the continuous system from which the discrete block has been derived (details see below),**A,B,C,D,B2**- matrices of appropriate dimensions.

A discrete system is usually derived by discretization from a
continuous block, e.g., by function
LinearSystems.DiscreteStateSpace.fromStateSpace. If the
discretization method, e.g., the trapezoidal method, accesses
**actual and past** values of the input **u** (e.g.
**u**(Ts*k), **u**(Ts*(k-1), **u**(Ts*(k-2))), a state
transformation is needed to get the difference equation above where
only the actual value **u**(Ts*k) is accessed.

If the original continuous state vector should be computed from
the sampled data system above, the matrices of this transformation
have to be known. For simplicity and efficiency, here only the
specific transformation used by function
LinearSystems.DiscreteStateSpace.fromStateSpace is stored in the
data record of the discrete system via matrix **B2**. Therefore,
the state vector of the underlying continuous system can be
calculated by adding the term **B2*****u** to the state
vector of the discretized system.

In Modelica notation, the difference equation above can be implemented as:

when{initial(),sample(Ts,Ts)}thennew_x = A * x + B * u; y = C * x + D * u; x =pre(new_x); x_continuous = x + B2 * u;end when;

Since no "next value" operator is available in Modelica, an
auxiliary variable new_x stores the value of x for the next
sampling instant. The relationship between new_x and x is defined
via equation "x = **pre**(new_x)".

The body of the when-clause is active during initialization and
at the next sample instant t=Ts. Note, the when-equation is not
active after the initialization at t=0 (due to
**sample**(Ts,Ts)), since the state x of the initialization has
to be used also at t=0.

In library Blocks.**Controller** additional equations are
added for the initialization to uniquely compute the initial vector
x:

initial equationifinit == InitialStatethenx = x_start;elseifinit == SteadyStatethenx = new_x;end if;

Optionally, x is set to a given start vector x_start. As
**default initialization**, the equation "x = new_x" is added
that defines steady state initialization for the discrete system.
As a consequence, the output y(Ts*k), k=0,1,2,.., remains constant
after this initialization, provided the input vector u(Ts*k)
remains constant.

Name | Description |
---|---|

'constructor' | |

timeResponse | Compute time response of DiscreteStateSpace system |

initialResponse | Compute initial response of DiscreteStateSpace system |

Conversion | Conversion functions from DiscreteStateSpace into DiscreteTransferFunction |

Plot | Functions to plot discrete state space system responses |

Internal | |

Design | Design functions for DiscreteStateSpace |

Generated at 2020-09-27T00:59:23Z by OpenModelicaOpenModelica 1.16.0~dev-655-g93494e4 using GenerateDoc.mos