ControlSystemsBase.append
ControlSystemsBase.c2d
ControlSystemsBase.delay
ControlSystemsBase.feedback
ControlSystemsBase.feedback2dof
ControlSystemsBase.minreal
ControlSystemsBase.pade
ControlSystemsBase.parallel
ControlSystemsBase.series
ControlSystemsBase.seriesform
ControlSystemsBase.sminreal
ControlSystemsBase.ss
ControlSystemsBase.ssdata
ControlSystemsBase.tf
ControlSystemsBase.zpk
See also Connecting named systems together.
Constructing systems
ControlSystemsBase.append
— Functionappend(systems::StateSpace...), append(systems::TransferFunction...)
Append systems in block diagonal form
ControlSystemsBase.c2d
— Functionsysd = c2d(sys::AbstractStateSpace{<:Continuous}, Ts, method=:zoh; w_prewarp=0)
Gd = c2d(G::TransferFunction{<:Continuous}, Ts, method=:zoh)
Convert the continuous-time system sys
into a discrete-time system with sample time Ts
, using the specified method
(:zoh
, :foh
, :fwdeuler
or :tustin
). Note that the forward-Euler method generally requires the sample time to be very small relative to the time constants of the system.
method = :tustin
performs a bilinear transform with prewarp frequency w_prewarp
.
w_prewarp
: Frequency (rad/s) for pre-warping when usingthe Tustin method, has no effect for other methods.
See also c2d_x0map
c2d(G::DelayLtiSystem, Ts, method=:zoh)
ControlSystemsBase.feedback
— Functionfeedback(sys)
feedback(sys1, sys2)
For a general LTI-system, feedback
forms the negative feedback interconnection
>-+ sys1 +-->
| |
(-)sys2 +
If no second system is given, negative identity feedback is assumed
feedback(sys1::AbstractStateSpace, sys2::AbstractStateSpace;
U1=:, Y1=:, U2=:, Y2=:, W1=:, Z1=:, W2=Int[], Z2=Int[],
Wperm=:, Zperm=:, pos_feedback::Bool=false)
Basic use feedback(sys1, sys2)
forms the (negative) feedback interconnection
┌──────────────┐
◄──────────┤ sys1 │◄──── Σ ◄──────
│ │ │ │
│ └──────────────┘ -1
│ |
│ ┌──────────────┐ │
└─────►│ sys2 ├──────┘
│ │
└──────────────┘
If no second system sys2
is given, negative identity feedback (sys2 = 1
) is assumed.
Advanced use feedback
also supports more flexible use according to the figure below
┌──────────────┐
z1◄─────┤ sys1 │◄──────w1
┌─── y1◄─────┤ │◄──────u1 ◄─┐
│ └──────────────┘ │
│ α
│ ┌──────────────┐ │
└──► u2─────►│ sys2 ├───────►y2──┘
w2─────►│ ├───────►z2
└──────────────┘
U1
, W1
specifies the indices of the input signals of sys1
corresponding to u1
and w1
Y1
, Z1
specifies the indices of the output signals of sys1
corresponding to y1
and z1
U2
, W2
, Y2
, Z2
specifies the corresponding signals of sys2
Specify Wperm
and Zperm
to reorder the inputs (corresponding to [w1; w2]) and outputs (corresponding to [z1; z2]) in the resulting statespace model.
Negative feedback (α = -1) is the default. Specify pos_feedback=true
for positive feedback (α = 1).
See also lft
, starprod
, sensitivity
, input_sensitivity
, output_sensitivity
, comp_sensitivity
, input_comp_sensitivity
, output_comp_sensitivity
, G_PS
, G_CS
.
The manual section From block diagrams to code contains higher-level instructions on how to use this function.
See Zhou, Doyle, Glover (1996) for similar (somewhat less symmetric) formulas.
ControlSystemsBase.feedback2dof
— Functionfeedback2dof(P,R,S,T)
feedback2dof(B,A,R,S,T)
- Return
BT/(AR+ST)
where B and A are the numerator and denomenator polynomials ofP
respectively - Return
BT/(AR+ST)
feedback2dof(P::TransferFunction, C::TransferFunction, F::TransferFunction)
Return the transfer function P(F+C)/(1+PC)
which is the closed-loop system with process P
, controller C
and feedforward filter F
from reference to control signal (by-passing C
).
+-------+
| |
+-----> F +----+
| | | |
| +-------+ |
| +-------+ | +-------+
r | - | | | | | y
+--+-----> C +----+----> P +---+-->
| | | | | |
| +-------+ +-------+ |
| |
+--------------------------------+
ControlSystemsBase.minreal
— Functionminreal(tf::TransferFunction, eps=sqrt(eps()))
Create a minimial representation of each transfer function in tf
by cancelling poles and zeros will promote system to an appropriate numeric type
minreal(sys::T; fast=false, kwargs...)
Minimal realisation algorithm from P. Van Dooreen, The generalized eigenstructure problem in linear system theory, IEEE Transactions on Automatic Control
For information about the options, see ?ControlSystemsBase.MatrixPencils.lsminreal
See also sminreal
, which is both numerically exact and substantially faster than minreal
, but with a much more limited potential in removing non-minimal dynamics.
ControlSystemsBase.parallel
— Functionparallel(sys1::LTISystem, sys2::LTISystem)
Connect systems in parallel, equivalent to sys2+sys1
ControlSystemsBase.series
— Functionseries(sys1::LTISystem, sys2::LTISystem)
Connect systems in series, equivalent to sys2*sys1
ControlSystemsBase.sminreal
— Functionsminreal(sys)
Compute the structurally minimal realization of the state-space system sys
. A structurally minimal realization is one where only states that can be determined to be uncontrollable and unobservable based on the location of 0s in sys
are removed.
Systems with numerical noise in the coefficients, e.g., noise on the order of eps
require truncation to zero to be affected by structural simplification, e.g.,
trunc_zero!(A) = A[abs.(A) .< 10eps(maximum(abs, A))] .= 0
trunc_zero!(sys.A); trunc_zero!(sys.B); trunc_zero!(sys.C)
sminreal(sys)
In contrast to minreal
, which performs pole-zero cancellation using linear-algebra operations, has an 𝑂(nₓ^3) complexity and is subject to numerical tolerances, sminreal
is computationally very cheap and numerically exact (operates on integers). However, the ability of sminreal
to reduce the order of the model is much less powerful.
See also minreal
.
ControlSystemsBase.ss
— Functionsys = ss(A, B, C, D) # Continuous
sys = ss(A, B, C, D, Ts) # Discrete
Create a state-space model sys::StateSpace{TE, T}
with matrix element type T
and TE is Continuous
or <:Discrete
.
This is a continuous-time model if Ts
is omitted. Otherwise, this is a discrete-time model with sampling period Ts
.
D
may be specified as 0
in which case a zero matrix of appropriate size is constructed automatically. sys = ss(D [, Ts])
specifies a static gain matrix D
.
To associate names with states, inputs and outputs, see named_ss
.
ControlSystemsBase.tf
— Functionsys = tf(num, den[, Ts])
sys = tf(gain[, Ts])
Create as a fraction of polynomials:
sys::TransferFunction{SisoRational{T,TR}} = numerator/denominator
where T is the type of the coefficients in the polynomial.
num
: the coefficients of the numerator polynomial. Either scalar or vector to create SISO systems
or an array of vectors to create MIMO system.
den
: the coefficients of the denominator polynomial. Either vector to create SISO systems
or an array of vectors to create MIMO system.
Ts
: Sample time if discrete time system.
The polynomial coefficients are ordered starting from the highest order term.
Other uses:
tf(sys)
: Convertsys
totf
form.tf("s")
,tf("z")
: Create the continuous transferfunctions
.
ControlSystemsBase.zpk
— Functionzpk(gain[, Ts])
zpk(num, den, k[, Ts])
zpk(sys)
Create transfer function on zero pole gain form. The numerator and denominator are represented by their poles and zeros.
sys::TransferFunction{SisoZpk{T,TR}} = k*numerator/denominator
where T
is the type of k
and TR
the type of the zeros/poles, usually Float64 and Complex{Float64}.
num
: the roots of the numerator polynomial. Either scalar or vector to create SISO systems
or an array of vectors to create MIMO system.
den
: the roots of the denominator polynomial. Either vector to create SISO systems
or an array of vectors to create MIMO system.
k
: The gain of the system. Obs, this is not the same asdcgain
.Ts
: Sample time if discrete time system.
Other uses:
zpk(sys)
: Convertsys
tozpk
form.zpk("s")
: Create the transferfunctions
.
ControlSystemsBase.delay
— Functiondelay(tau)
delay(tau, Ts)
delay(T::Type{<:Number}, tau)
delay(T::Type{<:Number}, tau, Ts)
Create a pure time delay of length τ
of type T
.
The type T
defaults to promote_type(Float64, typeof(tau))
.
If Ts
is given, the delay is discretized with sampling time Ts
and a discrete-time StateSpace object is returned.
Example:
Create a LTI system with an input delay of L
L = 1
tf(1, [1, 1])*delay(L)
s = tf("s")
tf(1, [1, 1])*exp(-s*L) # Equivalent to the version above
ControlSystemsBase.pade
— Functionpade(τ::Real, N::Int)
Compute the N
th order Padé approximation of a time-delay of length τ
.
pade(G::DelayLtiSystem, N)
Approximate all time-delays in G
by Padé approximations of degree N
.
ControlSystemsBase.ssdata
— FunctionA, B, C, D = ssdata(sys)
A destructor that outputs the statespace matrices.
ControlSystemsBase.seriesform
— FunctionGs, k = seriesform(G::TransferFunction{Discrete})
Convert a transfer function G
to a vector of second-order transfer functions and a scalar gain k
, the product of which equals G
.