The Octave Control Systems Toolbox (OCST) was initially developed by Dr. A. Scottedward Hodel a.s.hodel@eng.auburn.edu with the assistance of his students
This development was supported in part by NASA's Marshall Space Flight
Center as part of an in-house CACSD environment. Additional important
contributions were made by Dr. Kai Mueller mueller@ifr.ing.tu-bs.de
and Jose Daniel Munoz Frias (place.m).
An on-line menu-driven tutorial is available via DEMOcontrol;
beginning OCST users should start with this program.
@anchor{doc-DEMOcontrol}
octave:1> DEMOcontrol O C T A V E C O N T R O L S Y S T E M S T O O L B O X Octave Controls System Toolbox Demo [ 1] System representation [ 2] Block diagram manipulations [ 3] Frequency response functions [ 4] State space analysis functions [ 5] Root locus functions [ 6] LQG/H2/Hinfinity functions [ 7] End
Command examples are interactively run for users to observe the use of OCST functions.
The OCST stores all dynamic systems in a single data structure format that can represent continuous systems, discrete-systems, and mixed (hybrid) systems in state-space form, and can also represent purely continuous/discrete systems in either transfer function or pole-zero form. In order to provide more flexibility in treatment of discrete/hybrid systems, the OCST also keeps a record of which system outputs are sampled.
Octave structures are accessed with a syntax much like that used by the C programming language. For consistency in use of the data structure used in the OCST, it is recommended that the system structure access m-files be used (see section System Construction and Interface Functions). Some elements of the data structure are absent depending on the internal system representation(s) used. More than one system representation can be used for SISO systems; the OCST m-files ensure that all representations used are consistent with one another.
@anchor{doc-sysrepdemo}
The data structure elements (and variable types) common to all system
representations are listed below; examples of the initialization
and use of the system data structures are given in subsequent sections and
in the online demo DEMOcontrol.
tf2sys or fir2sys)
zp2sys)
ss2sys)
sysupdate command.
The remaining variables of the system data structure are only present
if the corresponding entry of the sys vector is true (=1).
tf format variableszp format variablesss format variablesbode, hinfsyn)
will not accept systems with both discrete and continuous states/outputs
Construction and manipulations of the OCST system data structure (see section System Data Structure) requires attention to many details in order to ensure that data structure contents remain consistent. Users are strongly encouraged to use the system interface functions in this section. Functions for the formatted display in of system data structures are given in section System display functions.
@anchor{doc-fir2sys}
Inputs:
Outputs sys (system data structure)
Example
octave:1> sys = fir2sys([1 -1 2 4],0.342,"A/D input","filter output");
octave:2> sysout(sys)
Input(s)
1: A/D input
Output(s):
1: filter output (discrete)
Sampling interval: 0.342
transfer function form:
1*z^3 - 1*z^2 + 2*z^1 + 4
-------------------------
1*z^3 + 0*z^2 + 0*z^1 + 0
@anchor{doc-sys2fir}
Extract FIR data from system data structure; see fir2sys for parameter descriptions.
@anchor{doc-ss2sys}
Inputs
rows(a)}, @math{nz = 0}.
If tsam is greater than zero, @math{n = 0},
@math{nz = rows(a)}
see below for system partitioning
x_n for continuous states,
xd_n for discrete states
u_n
y_n
rows(c)}.
Unlike states, discrete/continous outputs may appear in any order.
Note sys2ss returns a vector yd where
yd(outlist) = 1; all other entries of yd are 0.
Outputs outsys = system data structure
System partitioning
Suppose for simplicity that outlist specified that the first several outputs were continuous and the remaining outputs were discrete. Then the system is partitioned as
x = [ xc ] (n x 1)
[ xd ] (nz x 1 discrete states)
a = [ acc acd ] b = [ bc ]
[ adc add ] [ bd ]
c = [ ccc ccd ] d = [ dc ]
[ cdc cdd ] [ dd ]
(cdc = c(outlist,1:n), etc.)
with dynamic equations: @math{d/dt xc(t) = acc*xc(t) + acd*xd(k*tsam) + bc*u(t)}
@math{xd((k+1)*tsam) = adc*xc(k*tsam) + add*xd(k*tsam) + bd*u(k*tsam)}
@math{yc(t) = ccc*xc(t) + ccd*xd(k*tsam) + dc*u(t)}
@math{yd(k*tsam) = cdc*xc(k*tsam) + cdd*xd(k*tsam) + dd*u(k*tsam)}
Signal partitions
| continuous | discrete |
----------------------------------------------------
states | stname(1:n,:) | stname((n+1):(n+nz),:) |
----------------------------------------------------
outputs | outname(cout,:) | outname(outlist,:) |
----------------------------------------------------
where @math{cout} is the list of in 1:rows(p)
that are not contained in outlist. (Discrete/continuous outputs
may be entered in any order desired by the user.)
Example
octave:1> a = [1 2 3; 4 5 6; 7 8 10];
octave:2> b = [0 0 ; 0 1 ; 1 0];
octave:3> c = eye(3);
octave:4> sys = ss2sys(a,b,c,[],0,3,0,list("volts","amps","joules"));
octave:5> sysout(sys);
Input(s)
1: u_1
2: u_2
Output(s):
1: y_1
2: y_2
3: y_3
state-space form:
3 continuous states, 0 discrete states
State(s):
1: volts
2: amps
3: joules
A matrix: 3 x 3
1 2 3
4 5 6
7 8 10
B matrix: 3 x 2
0 0
0 1
1 0
C matrix: 3 x 3
1 0 0
0 1 0
0 0 1
D matrix: 3 x 3
0 0
0 0
0 0
Notice that the @math{D} matrix is constructed by default to the correct dimensions. Default input and output signals names were assigned since none were given.
@anchor{doc-sys2ss}
Inputs sys system data structure
Outputs
A warning massage is printed if the system is a mixed continuous and discrete system
Example
octave:1> sys=tf2sys([1 2],[3 4 5]); octave:2> [a,b,c,d] = sys2ss(sys) a = 0.00000 1.00000 -1.66667 -1.33333 b = 0 1 c = 0.66667 0.33333 d = 0
@anchor{doc-tf2sys}
Inputs
Outputs sys = system data structure
Example
octave:1> sys=tf2sys([2 1],[1 2 1],0.1);
octave:2> sysout(sys)
Input(s)
1: u_1
Output(s):
1: y_1 (discrete)
Sampling interval: 0.1
transfer function form:
2*z^1 + 1
-----------------
1*z^2 + 2*z^1 + 1
@anchor{doc-sys2tf}
See tf2sys for parameter descriptions.
Example
octave:1> sys=ss2sys([1 -2; -1.1,-2.1],[0;1],[1 1]); octave:2> [num,den] = sys2tf(sys) num = 1.0000 -3.0000 den = 1.0000 1.1000 -4.3000
@anchor{doc-zp2sys}
Inputs
Outputs sys: system data structure
Example
octave:1> sys=zp2sys([1 -1],[-2 -2 0],1);
octave:2> sysout(sys)
Input(s)
1: u_1
Output(s):
1: y_1
zero-pole form:
1 (s - 1) (s + 1)
-----------------
s (s + 2) (s + 2)
@anchor{doc-sys2zp}
See zp2sys for parameter descriptions.
Example
octave:1> sys=ss2sys([1 -2; -1.1,-2.1],[0;1],[1 1]); octave:2> [zer,pol,k] = sys2zp(sys) zer = 3.0000 pol = -2.6953 1.5953 k = 1
@anchor{doc-syschnames}
syssetsignals
@anchor{doc-syschtsam}
@anchor{doc-sysdimensions}
Inputs
"all"
"cst"
"dst"
"in"
"out"
Outputs
@seealso{sysgetsignals and sysgettsam}
@anchor{doc-sysgetsignals}
Inputs
"in"
"out"
"st"
"yd"
sysidx
0
1
Outputs
sigid="in"
sigid="out"
sigid="st"
sigid="yd"
"in",
"out", or "st"), or else the logical flag
indicating whether output(s) signum is(are) discrete (sigval=1)
or continuous (sigval=0).
Examples (From sysrepdemo)
octave> sys=ss2sys(rand(4),rand(4,2),rand(3,4)); octave> [Ast,Ain,Aout,Ayd] = sysgetsignals(sys) i # get all signal names Ast = ( [1] = x_1 [2] = x_2 [3] = x_3 [4] = x_4 ) Ain = ( [1] = u_1 [2] = u_2 ) Aout = ( [1] = y_1 [2] = y_2 [3] = y_3 ) Ayd = 0 0 0 octave> Ain = sysgetsignals(sys,"in") # get only input signal names Ain = ( [1] = u_1 [2] = u_2 ) octave> Aout = sysgetsignals(sys,"out",2) # get name of output 2 (in list) Aout = ( [1] = y_2 ) octave> Aout = sysgetsignals(sys,"out",2,1) # get name of output 2 (as string) Aout = y_2
@anchor{doc-sysgettype}
Inputs sys: system data structure
Outputs
systype: string indicating how the structure was initially
constructed:
values: "ss", "zp", or "tf"
Note FIR initialized systems return systype="tf".
@anchor{doc-syssetsignals}
"out"
"in"
"st"
"yd"
opt = "out", "in", or "st"
opt = "yd"
Outputs retsys=sys with appropriate signal names changed (or yd values, where appropriate)
Example
octave:1> sys=ss2sys([1 2; 3 4],[5;6],[7 8]);
octave:2> sys = syssetsignals(sys,"st",str2mat("Posx","Velx"));
octave:3> sysout(sys)
Input(s)
1: u_1
Output(s):
1: y_1
state-space form:
2 continuous states, 0 discrete states
State(s):
1: Posx
2: Velx
A matrix: 2 x 2
1 2
3 4
B matrix: 2 x 1
5
6
C matrix: 1 x 2
7 8
D matrix: 1 x 1
0
@anchor{doc-sysupdate}
Inputs
"tf"
"zp"
"ss"
"all"
Outputs retsys: contains union of data in sys and requested data. If requested data in sys is already up to date then retsys=sys.
Conversion to tf or zp exits with an error if the system is
mixed continuous/digital.
function [systype, nout, nin, ncstates, ndstates] = minfo(inmat)
MINFO: Determines the type of system matrix. INMAT can be a varying(*), system, constant, and empty matrix.
Returns: systype can be one of: varying, system, constant, and empty nout is the number of outputs of the system nin is the number of inputs of the system ncstates is the number of continuous states of the system ndstates is the number of discrete states of the system
@anchor{doc-sysgettsam}
@anchor{doc-sysout}
[]
"ss"
"tf"
"zp"
"all"
@anchor{doc-tfout}
"s"
@anchor{doc-zpout}
"s"
See section System Analysis-Time Domain.
Unless otherwise noted, all parameters (input,output) are system data structures.
@anchor{doc-bddemo}
@anchor{doc-buildssic}
Form an arbitrary complex (open or closed loop) system in
state-space form from several systems. "buildssic" can
easily (despite it's cryptic syntax) integrate transfer functions
from a complex block diagram into a single system with one call.
This function is especially useful for building open loop
interconnections for H_infinity and H2 designs or for closing
loops with these controllers.
Although this function is general purpose, the use of "sysgroup"
"sysmult", "sysconnect" and the like is recommended for
standard operations since they can handle mixed discrete and continuous
systems and also the names of inputs, outputs, and states.
The parameters consist of 4 lists that describe the connections outputs and inputs and up to 8 systems s1-s8. Format of the lists:
[1 2 -1; 2 1 0] ==> new input 1 is old inpout 1
+ output 2 - output 1, new input 2 is old input 2
+ output 1. The order of rows is arbitrary.
Example: Very simple closed loop system.
w e +-----+ u +-----+
--->o--*-->| K |--*-->| G |--*---> y
^ | +-----+ | +-----+ |
- | | | |
| | +----------------> u
| | |
| +-------------------------|---> e
| |
+----------------------------+
The closed loop system GW can be optained by
GW = buildssic([1 2; 2 -1], 2, [1 2 3], 2, G, K);
Here is a real example:
+----+
-------------------->| W1 |---> v1
z | +----+
----|-------------+ || GW || => min.
| | vz infty
| +---+ v +----+
*--->| G |--->O--*-->| W2 |---> v2
| +---+ | +----+
| |
| v
u y
The closed loop system GW from [z; u]' to [v1; v2; y]' can be obtained by (all SISO systems):
GW = buildssic([1, 4; 2, 4; 3, 1], 3, [2, 3, 5],
[3, 4], G, W1, W2, One);
where "One" is a unity gain (auxillary) function with order 0.
(e.g. One = ugain(1);)
@anchor{doc-jet707}
@anchor{doc-ord2}
Outputs outsys system data structure has representation with @math{w = 2 * pi * nfreq}:
/ \
| / -2w*damp -w \ / w \ |
G = | | |, | |, [ 0 gain ], 0 |
| \ w 0 / \ 0 / |
\ /
See also jet707 (MIMO example, Boeing 707-321
aircraft model)
@anchor{doc-sysadd}
________
----| gsys |---
u | ---------- +|
----- (_)----> y
| ________ +|
----| hsys |---
--------
@anchor{doc-sysappend}
Inputs
Outputs sys
sys.b := [sys.b , b]
sys.c := [sys.c ]
[ c ]
sys.d := [sys.d | D12 ]
[D21 | D22 ]
where @math{D12}, @math{D21}, and @math{D22} are the appropriate dimensioned blocks of the input parameter d.
zeros(1,rows(c))
ones(1,rows(c))
@anchor{doc-sysconnect}
Inputs
sysidx).
The output specified by @math{out_idx(ii)} is connected to the input
specified by @math{in_idx(ii)}.
0
1
Outputs sys: resulting closed loop system.
Method
sysconnect internally permutes selected inputs, outputs as shown
below, closes the loop, and then permutes inputs and outputs back to their
original order
____________________
u_1 ----->| |----> y_1
| sys |
old u_2 | |
u_2* ---->(+)--->| |----->y_2
(in_idx) ^ -------------------| | (out_idx)
| |
-------------------------------
The input that has the summing junction added to it has an * added to the end of the input name.
@anchor{doc-syscont}
Inputs sys is a system data structure
Outputs
@anchor{doc-sysdisc}
Inputs sys = system data structure
Outputs
@anchor{doc-sysdup}
Inputs
sigidx).
duplicates are made of y(out_idx(ii)) and u(in_idx(ii)).
Outputs
retsys: resulting closed loop system:
duplicated i/o names are appended with a "+" suffix.
Method
sysdup creates copies of selected inputs and outputs as
shown below. u1/y1 is the set of original inputs/outputs, and
u2,y2 is the set of duplicated inputs/outputs in the order specified
in in_idx, out_idx, respectively
____________________
u1 ----->| |----> y1
| asys |
u2 ------>| |----->y2
(in_idx) -------------------| (out_idx)
@anchor{doc-sysgroup}
Inputs asys, bsys: system data structures
Outputs @math{sys = block diag(asys,bsys)}
__________________
| ________ |
u1 ----->|--> | asys |--->|----> y1
| -------- |
| ________ |
u2 ----->|--> | bsys |--->|----> y2
| -------- |
------------------
Ksys
The function also rearranges the internal state-space realization of sys so that the continuous states come first and the discrete states come last. If there are duplicate names, the second name has a unique suffix appended on to the end of the name.
@anchor{doc-sysmult}
u ---------- ----------
--->| bsys |---->| asys |--->
---------- ----------
A warning occurs if there is direct feed-through from an input of Bsys or a continuous state of bsys through a discrete output of Bsys to a continuous state or output in asys (system data structure does not recognize discrete inputs).
@anchor{doc-sysprune}
Inputs
retsys = sysprune(Asys,[1:3,4],"u_1");
retsys = sysprune(Asys,list("tx","ty","tz"), 4);
Outputs retsys: resulting system
____________________
u1 ------->| |----> y1
(in_idx) | Asys | (out_idx)
u2 ------->| |----| y2
(deleted)-------------------- (deleted)
@anchor{doc-sysreorder}
Inputs
vlen=vector length, list= a subset of [1:vlen],
Outputs
pv: a permutation vector to order elements of [1:vlen] in
list to the end of a vector.
Used internally by sysconnect to permute vector elements to their
desired locations.
@anchor{doc-sysscale}
Inputs sys: structured system outscale, inscale: constant matrices of appropriate dimension
Outputs sys: resulting open loop system:
----------- ------- -----------
u --->| inscale |--->| sys |--->| outscale |---> y
----------- ------- -----------
If the input names and output names (each a list of strings) are not given and the scaling matrices are not square, then default names will be given to the inputs and/or outputs.
A warning message is printed if outscale attempts to add continuous system outputs to discrete system outputs; otherwise yd is set appropriately in the returned value of sys.
@anchor{doc-syssub}
Method: gsys and hsys are connected in parallel The input vector is connected to both systems; the outputs are subtracted. Returned system names are those of gsys.
+--------+
+--->| gsys |---+
| +--------+ |
| +|
u --+ (_)--> y
| -|
| +--------+ |
+--->| hsys |---+
+--------+
@anchor{doc-ugain}
@anchor{doc-wgt1o}
Weighting function are needed by the H2/H_infinity design procedure. These function are part of thye augmented plant P (see hinfdemo for an applicattion example).
vl = Gain at low frequencies
vh = Gain at high frequencies
fc = Corner frequency (in Hz, *not* in rad/sec)
@anchor{doc-parallel}
____________________ | ________ | u ----->|----> | asys |--->|----> y1 | | -------- | | | ________ | |--->|----> | bsys |--->|----> y2 | -------- | -------------------- ksys
@anchor{doc-sysmin}
@anchor{doc-are}
a' * x + x * a - x * b * x + c = 0
Inputs for identically dimensioned square matrices
"B"):
String option passed to balance prior to ordered Schur decomposition.
Outputs x: solution of the ARE.
Method Laub's Schur method (IEEE Transactions on Automatic Control, 1979) is applied to the appropriate Hamiltonian matrix.
@seealso{balance and dare}
@anchor{doc-dare}
Return the solution, x of the discrete-time algebraic Riccati equation
a' x a - x + a' x b (r + b' x b)^(-1) b' x a + c = 0
Inputs
"B"):
String option passed to balance prior to ordered QZ decomposition.
Outputs x solution of DARE.
Method Generalized eigenvalue approach (Van Dooren; SIAM J. Sci. Stat. Comput., Vol 2) applied to the appropriate symplectic pencil.
See also: Ran and Rodman, "Stable Hermitian Solutions of Discrete Algebraic Riccati Equations," Mathematics of Control, Signals and Systems, Vol 5, no 2 (1992) pp 165-194.
@seealso{balance and are}
@anchor{doc-dre}
-d P/dt = A'P + P A - P B inv(R) B' P + Q P(tf) = Qf
for the LTI system sys. Solution of standard LTI state feedback optimization
min \int_{t_0}^{t_f} x' Q x + u' R u dt + x(t_f)' Qf x(t_f)
optimal input is
u = - inv(R) B' P(t) x
Inputs
Outputs
is selected so that || nth(Plist,ii) - nth(Plist,ii-1) || < Ptol for ii=2:length(tvals)
@anchor{doc-dgram}
x(k+1) = a x(k) + b u(k)
Inputs
Outputs m (n by n) satisfies
a m a' - m + b*b' = 0
@anchor{doc-dlyap}
Inputs
Outputs x: matrix satisfying appropriate discrete time Lyapunov equation. Options:
a x a' - x + b = 0
a x a' - x + b b' = 0or
a' x a - x + b' b = 0,whichever is appropriate.
Method Uses Schur decomposition method as in Kitagawa, An Algorithm for Solving the Matrix Equation @math{X = F X F' + S}, International Journal of Control, Volume 25, Number 5, pages 745--753 (1977).
Column-by-column solution method as suggested in Hammarling, Numerical Solution of the Stable, Non-Negative Definite Lyapunov Equation, IMA Journal of Numerical Analysis, Volume 2, pages 303--323 (1982).
@anchor{doc-gram}
m satisfies @math{a m + m a' + b b' = 0}.
@anchor{doc-lyap}
If a, b, and c are specified, then lyap returns
the solution of the Sylvester equation
a x + x b + c = 0
If only (a, b) are specified, then lyap returns the
solution of the Lyapunov equation
a' x + x a + b = 0
If b is not square, then lyap returns the solution of either
a' x + x a + b' b = 0
or
a x + x a' + b b' = 0
whichever is appropriate.
Solves by using the Bartels-Stewart algorithm (1972).
@anchor{doc-qzval}
(A - lambda B).
a and b must be real matrices.
Note qzval is obsolete; use qz instead.
@anchor{doc-zgfmul}
@anchor{doc-zgfslv}
@anchor{doc-zginit}
@anchor{doc-zgreduce}
@anchor{doc-zgrownorm}
@anchor{doc-zgscal}
zgepbal
@anchor{doc-zgsgiv}
@anchor{doc-zgshsr}
References:
@anchor{doc-analdemo}
@anchor{doc-abcddim}
dx/dt = a x + b u y = c x + d u
or a similar discrete-time system.
If the matrices are compatibly dimensioned, then abcddim returns
Otherwise abcddim returns n = m = p = -1.
Note: n = 0 (pure gain block) is returned without warning.
@seealso{is_abcd}
@anchor{doc-ctrb}
2 n-1
Qs = [ B AB A B ... A B ]
of a system data structure or the pair (a, b).
Note ctrb forms the controllability matrix.
The numerical properties of is_controllable
are much better for controllability tests.
@anchor{doc-h2norm}
Reference: Doyle, Glover, Khargonekar, Francis, "State Space Solutions to Standard H2 and Hinf Control Problems", IEEE TAC August 1989
@anchor{doc-hinfnorm}
Inputs
Outputs
References: Doyle, Glover, Khargonekar, Francis, "State space solutions to standard H2 and Hinf control problems", IEEE TAC August 1989 Iglesias and Glover, "State-Space approach to discrete-time Hinf control," Int. J. Control, vol 54, #5, 1991 Zhou, Doyle, Glover, "Robust and Optimal Control," Prentice-Hall, 1996
@anchor{doc-obsv}
| C |
| CA |
Qb = | CA^2 |
| ... |
| CA^(n-1) |
of a system data structure or the pair (A, C).
Note: obsv() forms the observability matrix.
The numerical properties of is_observable() are much better for observability tests.
@anchor{doc-pzmap}
Outputs if omitted, the poles and zeros are plotted on the screen. otherwise, pol, zer are returned as the system poles and zeros. (see sys2zp for a preferable function call)
@anchor{doc-is_abcd}
@anchor{doc-is_controllable}
Inputs
10*eps
Outputs
Method Controllability is determined by applying Arnoldi iteration with complete re-orthogonalization to obtain an orthogonal basis of the Krylov subspace
span ([b,a*b,...,a^{n-1}*b]).
The Arnoldi iteration is executed with krylov if the system
has a single input; otherwise a block Arnoldi iteration is performed
with krylovb.
@anchor{doc-is_detectable}
Returns 1 if the system a or the pair (a,c)is detectable, 0 if not.
See is_stabilizable for detailed description of
arguments and computational method.
Default: tol = 10*norm(a,'fro')*eps
@seealso{is_stabilizable, size, rows, columns, length, ismatrix, isscalar, and isvector}
@anchor{doc-is_dgkf}
[dx/dt] = [A | Bw Bu ][w] [ z ] [Cz | Dzw Dzu ][u] [ y ] [Cy | Dyw Dyu ]
or similar discrete-time system. If necessary, orthogonal transformations qw, qz and nonsingular transformations ru, ry are applied to respective vectors w, z, u, y in order to satisfy DGKF assumptions. Loop shifting is used if dyu block is nonzero.
Inputs
Outputs
is_dgkf results. Entries:
is_dgkf exits with an error if the system is mixed
discrete/continuous
References
@anchor{doc-is_digital}
@anchor{doc-is_observable}
Default: tol = 10*norm(a,'fro')*eps
Returns 1 if the system sys or the pair (a,c) is observable, 0 if not.
See is_controllable for detailed description of arguments
and default values.
@anchor{doc-is_sample}
@anchor{doc-is_siso}
@anchor{doc-is_stabilizable}
Test for stabilizability is performed via an ordered Schur decomposition that reveals the unstable subspace of the system a matrix.
Returns retval = 1 if the system, a, is stabilizable,
if the pair (a, b) is stabilizable, or 0 if not.
u = orthogonal basis of controllable subspace.
Controllable subspace is determined by applying Arnoldi iteration with complete re-orthogonalization to obtain an orthogonal basis of the Krylov subspace.
span ([b,a*b,...,a^ b]).
tol is a roundoff paramter, set to 200*eps if omitted.
@anchor{doc-is_signal_list}
@anchor{doc-is_stable}
Inputs
dflg != 0
dflg == 0
@seealso{size, rows, columns, length, ismatrix, isscalar, isvector is_observable, is_stabilizable, is_detectable, krylov, and krylovb}
@anchor{doc-c2d}
Inputs
"ex"
"bi"
2(z-1)
s = -----
T(z+1)
FIXME: This option exits with an error if sys is not purely
continuous. (The ex option can handle mixed systems.)
c2d assumes that
the 2nd argument is t and performs appropriate argument checks.
Outputs dsys discrete time equivalent via zero-order hold, sample each t sec.
converts the system data structure describing
. x = Ac x + Bc u
into a discrete time equivalent model
x[n+1] = Ad x[n] + Bd u[n]
via the matrix exponential or bilinear transform
Note This function adds the suffix _d
to the names of the new discrete states.
@anchor{doc-d2c}
sysgettsam(sys)
Inputs
"log" option (see below)
"log"
d2c (sys, tol), with tol
positive scalar, the "log" option is used. The default value
for tol is 1e-8.
"bi"
sysgettsam).
FIXME: bilinear option exits with an error if sys is not purely
discrete
Outputs csys continuous time system (same dimensions and signal names as in sys).
@anchor{doc-dmr2d}
sysgettsam (sys).
Inputs
dmr2d exits with an error if sys is not discrete
sysgettsam(sys) (may be empty); see listidx
sysgettsam(sys) (may be empty)
sysgettsam(sys)
Outputs
WARNING Not thoroughly tested yet; especially when cuflg == 0.
@anchor{doc-damp}
@anchor{doc-dcgain}
@anchor{doc-impulse}
impulse
produces a plot or the impulse response data for system sys.
Inputs
Outputs y, t: impulse response
@anchor{doc-step}
step
produces a plot or the step response data for system sys.
Inputs
Outputs y, t: impulse response
When invoked with the output paramter y the plot is not displayed.
Demonstration/tutorial script @anchor{doc-frdemo}
@anchor{doc-bode}
Inputs
exp(jwT)), where
exp(jwT)}=1) and select the frequency
range based on the breakpoint locations of the frequencies.
sysprune.
Example
bode(sys,[],"y_3",list("u_1","u_4");
Outputs
exp(jwT))} at the selected frequency values.
Notes
bode(sys);bode plots the results to the screen. Descriptive labels are automatically placed. Failure to include a concluding semicolon will yield some garbage being printed to the screen (
ans = []).
exp(jwT))||}
and phase information is not computed.
@anchor{doc-bode_bounds}
Used internally in __freqresp__ (bode, nyquist)
@anchor{doc-freqchkw}
__freqresp__ to check that input frequency vector w
is valid.
Returns boolean value.
@anchor{doc-ltifr}
Outputs out
-1
G(s) = (jw I-A) B
for complex frequencies @math{s = jw}.
@anchor{doc-nyquist}
Compute the frequency response of a system. Inputs (pass as empty to get default values)
outputs, inputs: names or indices of the output(s) and input(s) to be used in the frequency response; see sysprune.
Inputs (pass as empty to get default values)
Outputs
If no output arguments are given, nyquist plots the results to the screen. If atol != 0 and asymptotes are detected then the user is asked interactively if they wish to zoom in (remove asymptotes) Descriptive labels are automatically placed.
Note: if the requested plot is for an MIMO system, a warning message is presented; the returned information is of the magnitude ||G(jw)|| or ||G(exp(jwT))|| only; phase information is not computed.
@anchor{doc-tzero}
. x = Ax + Bu y = Cx + Du
or discrete
x(k+1) = A x(k) + B u(k) y(k) = C x(k) + D u(k)
system. Outputs
References
@anchor{doc-tzero2}
bal = balancing option (see balance); default is "B".
Needs to incorporate mvzero algorithm to isolate finite zeros; use
tzero instead.
@anchor{doc-dgkfdemo}
@anchor{doc-hinfdemo}
H_infinity design demos for continuous SISO and MIMO systems and a discrete system. The SISO system is difficult to control because it is non minimum phase and unstable. The second design example controls the "jet707" plant, the linearized state space model of a Boeing 707-321 aircraft at v=80m/s (M = 0.26, Ga0 = -3 deg, alpha0 = 4 deg, kappa = 50 deg). Inputs: (1) thrust and (2) elevator angle outputs: (1) airspeed and (2) pitch angle. The discrete system is a stable and second order.
s - 2
G(s) = --------------
(s + 2)(s - 1)
+----+
-------------------->| W1 |---> v1
z | +----+
----|-------------+ || T || => min.
| | vz infty
| +---+ v y +----+
u *--->| G |--->O--*-->| W2 |---> v2
| +---+ | +----+
| |
| +---+ |
-----| K |<-------
+---+
W1 und W2 are the robustness and performance weighting
functions
w
1 -----------+
| +----+
+---------------------->| W1 |----> z1
w | | +----+
2 ------------------------+
| | |
| v +----+ v +----+
+--*-->o-->| G |-->o--*-->| W2 |---> z2
| +----+ | +----+
| |
^ v
u (from y (to K)
controller
K)
+ + + +
| z | | w |
| 1 | | 1 |
| z | = [ P ] * | w |
| 2 | | 2 |
| y | | u |
+ + + +
1
G (s) = --------------
k (s + 2)(s + 1)
is discretised with a ZOH (Sampling period = Ts = 1 second):
0.199788z + 0.073498
G(s) = --------------------------
(z - 0.36788)(z - 0.13534)
+----+
-------------------->| W1 |---> v1
z | +----+
----|-------------+ || T || => min.
| | vz infty
| +---+ v +----+
*--->| G |--->O--*-->| W2 |---> v2
| +---+ | +----+
| |
| +---+ |
-----| K |<-------
+---+
W1 and W2 are the robustness and performancs weighting
functions
@anchor{doc-dlqe}
x[k+1] = A x[k] + B u[k] + G w[k] y[k] = C x[k] + D u[k] + v[k]
where w, v are zero-mean gaussian noise processes with
respective intensities sigw = cov (w, w) and
sigv = cov (v, v).
If specified, z is cov (w, v). Otherwise
cov (w, v) = 0.
The observer structure is
z[k|k] = z[k|k-1] + L (y[k] - C z[k|k-1] - D u[k]) z[k+1|k] = A z[k|k] + B u[k]
The following values are returned:
@anchor{doc-dlqr}
x[k+1] = A x[k] + B u[k]
to minimize the cost functional
J = Sum (x' Q x + u' R u)
z omitted or
J = Sum (x' Q x + u' R u + 2 x' Z u)
z included.
The following values are returned:
@anchor{doc-dkalman}
x[k+1] = A x[k] + B u[k] + G w[k] y[k] = C x[k] + D u[k] + v[k]
where w, v are zero-mean gaussian noise processes with
respective intensities Qw = cov (w, w) and
Rv = cov (v, v).
If specified, S is cov (w, v). Otherwise
cov (w, v) = 0.
The observer structure is
x[k+1|k] = A x[k|k-1] + B u[k] + LP (y[k] - C x[k|k-1] - D u[k]) x[k|k] = x[k|k-1] + LF (y[k] - C x[k|k-1] - D u[k])
The following values are returned:
@anchor{doc-h2syn}
Discrete time control per Zhou, Doyle, and Glover, ROBUST AND OPTIMAL CONTROL, Prentice-Hall, 1996
Inputs input system is passed as either
Outputs
@anchor{doc-hinf_ctr}
hinfsyn to compute the H_inf optimal controller.
Inputs
is_dgkf
Outputs controller (system data structure)
Do not attempt to use this at home; no argument checking performed.
@anchor{doc-hinfsyn}
Inputs input system is passed as either
c2d, d2c)
Outputs
@anchor{doc-hinfsyn_chk}
hinfsyn to see if gain g satisfies conditions in
Theorem 3 of
Doyle, Glover, Khargonekar, Francis, "State Space Solutions to Standard
H2 and Hinf Control Problems", IEEE TAC August 1989
Warning Do not attempt to use this at home; no argument checking performed.
Inputs as returned by is_dgkf, except for:
hinfsyn
Outputs
Do not attempt to use this at home; no argument checking performed.
@anchor{doc-hinfsyn_ric}
xx = ([BB; -C1'*d1dot]/R) * [d1dot'*C1 BB']; Ha = [A 0*A; -C1'*C1 -A'] - xx;
and solves associated Riccati equation. The error code x_ha_err indicates one of the following conditions:
@anchor{doc-lqe}
dx -- = a x + b u dt y = c x + d u
where w and v are zero-mean gaussian noise processes with respective intensities
sigw = cov (w, w) sigv = cov (v, v)
The optional argument z is the cross-covariance
cov (w, v). If it is omitted,
cov (w, v) = 0 is assumed.
Observer structure is dz/dt = A z + B u + k (y - C z - D u)
The following values are returned:
@anchor{doc-lqg}
dx/dt = A x + B u + G w [w]=N(0,[Sigw 0 ])
y = C x + v [v] ( 0 Sigv ])
or
x(k+1) = A x(k) + B u(k) + G w(k) [w]=N(0,[Sigw 0 ]) y(k) = C x(k) + v(k) [v] ( 0 Sigv ])
Inputs
sysidx, listidx)
default: last dim(R) inputs are assumed to be controlled inputs, all
others are assumed to be noise inputs.
Outputs
sys2ss, sys2tf, or sys2zp as
appropriate)
@seealso{h2syn, lqe, and lqr}
@anchor{doc-lqr}
dx -- = A x + B u dt
to minimize the cost functional
infinity
/
J = | x' Q x + u' R u
/
t=0
z omitted or
infinity
/
J = | x' Q x + u' R u + 2 x' Z u
/
t=0
z included.
The following values are returned:
Reference Anderson and Moore, OPTIMAL CONTROL: LINEAR QUADRATIC METHODS, Prentice-Hall, 1990, pp. 56-58
@anchor{doc-lsim}
Produces a plot for the output of the system, sys.
U is an array that contains the system's inputs. Each row in u corresponds to a different time step. Each column in u corresponds to a different input. T is an array that contains the time index of the system. T should be regularly spaced. If initial conditions are required on the system, the x0 vector should be added to the argument list.
When the lsim function is invoked with output parameters: [y,x] = lsim(sys,u,t,[x0]) a plot is not displayed, however, the data is returned in y = system output and x = system states.
@anchor{doc-place}
Version: Beta (May-1997): If you have any comments, please let me know. (see the file place.m for my address)
@anchor{doc-axis2dlim}
Inputs axdata nx2 matrix of data [x,y]
Outputs axvec vector of axis limits appropriate for call to axis() function
@anchor{doc-moddemo}
@anchor{doc-prompt}
function prompt([str]) Prompt user to continue str: input string. Default value: "\n ---- Press a key to continue ---"
@anchor{doc-rldemo}
@anchor{doc-rlocus}
[rldata, k] = rlocus(sys[,increment,min_k,max_k])
Displays root locus plot of the specified SISO system.
----- -- --------
--->| + |---|k|---->| SISO |----------->
----- -- -------- |
- ^ |
|_____________________________|
inputs: sys = system data structure
min_k, max_k,increment: minimum, maximum values of k and
the increment used in computing gain values
Outputs: plots the root locus to the screen.
rldata: Data points plotted column 1: real values, column 2: imaginary
values)
k: gains for real axis break points.
@anchor{doc-sortcom}
[yy,idx] = sortcom(xx[,opt]): sort a complex vector xx: complex vector opt: sorting option: "re": real part (default) "mag": by magnitude "im": by imaginary part if opt != "im" then complex conjugate pairs are grouped together, a - jb followed by a + jb. yy: sorted values idx: permutation vector: yy = xx(idx)
@anchor{doc-ss2tf}
[num,den] = ss2tf(a,b,c,d)
Conversion from tranfer function to state-space.
The state space system
.
x = Ax + Bu
y = Cx + Du
is converted to a transfer function
num(s)
G(s)=-------
den(s)
used internally in system data structure format manipulations
@anchor{doc-ss2zp}
Converts a state space representation to a set of poles and zeros. [pol,zer,k] = ss2zp(a,b,c,d) returns the poles and zeros of the state space system (a,b,c,d). K is a gain associated with the zeros. used internally in system data structure format manipulations
@anchor{doc-starp}
Redheffer star product or upper/lower LFT, respectively.
+-------+
--------->| |--------->
| P |
+--->| |---+ ny
| +-------+ |
+-------------------+
| |
+----------------+ |
| |
| +-------+ |
+--->| |------+ nu
| K |
--------->| |--------->
+-------+
If ny and nu "consume" all inputs and outputs of K then the result
is a lower fractional transformation. If ny and nu "consume" all
inputs and outputs of P then the result is an upper fractional
transformation.
ny and/or nu may be negative (= negative feedback)
@anchor{doc-tf2ss}
Conversion from tranfer function to state-space.
The state space system
.
x = Ax + Bu
y = Cx + Du
is obtained from a transfer function
num(s)
G(s)=-------
den(s)
via the function call [a,b,c,d] = tf2ss(num,den).
The vector 'den' must contain only one row, whereas the vector 'num'
may contain as many rows as there are outputs of the system 'y'.
The state space system matrices obtained from this function will be
in controllable canonical form as described in "Modern Control Theory",
[Brogan, 1991].
@anchor{doc-tf2zp}
[zer,pol,k] = tf2zp(num,den) returns the zeros and poles of the SISO system defined by num/den. K is a gain associated with the system zeros.
@anchor{doc-zp2ss}
Outputs a, b, c, d The state space system
. x = Ax + Bu y = Cx + Du
is obtained from a vector of zeros and a vector of poles via the
function call [a,b,c,d] = zp2ss(zer,pol,k).
The vectors `zer' and
`pol' may either be row or column vectors. Each zero and pole that
has an imaginary part must have a conjugate in the list.
The number of zeros must not exceed the number of poles.
`k' is zp-form leading coefficient.
@anchor{doc-zp2tf}
[num,den] = zp2tf(zer,pol,k) forms the transfer function
num/den from the vectors of poles and zeros.
Go to the first, previous, next, last section, table of contents.