bloc2ss

block-diagram to state-space conversion

Calling Sequence

[sl]=bloc2ss(blocd)

Arguments

:blocd list : :sl list :

Description

Given a block-diagram representation of a linear system bloc2ss converts this representation to a state-space linear system. The first element of the list blocd must be the string ‘blocd’. Each other element of this list is itself a list of one the following types :

`list`_('transfer','name_of_linear_system')

`list`_('link','name_of_link',
             [number_of_upstream_box,upstream_box_port],
             [downstream_box_1,downstream_box_1_portnumber],
             [downstream_box_2,downstream_box_2_portnumber],
             ...)

The strings ‘transfer’ and ‘links’ are keywords which indicate the type of element in the block diagram.

Case 1 : the second parameter of the list is a character string which may refer (for a possible further evaluation) to the Scilab name of a linear system given in state-space representation ( syslin list) or in transfer form (matrix of rationals).

To each transfer block is associated an integer. To each input and output of a transfer block is also associated its number, an integer (see examples)

Case 2 : the second kind of element in a block-diagram representation is a link. A link links one output of a block represented by the pair [number_of_upstream_box,upstream_box_port], to different inputs of other blocks. Each such input is represented by the pair [downstream_box_i,downstream_box_i_portnumber].

The different elements of a block-diagram can be defined in an arbitrary order.

For example

[1] S1*S2 with unit feedback.

There are 3 transfers S1 (number n_s1=2) , S2 (number n_s2=3) and an adder (number n_add=4) with symbolic transfer function [‘1’,‘1’].

There are 4 links. The first one (named ‘U’) links the input (port 0 of fictitious block -1, omitted) to port 1 of the adder. The second and third one link respectively (output)port 1 of the adder to (input)port 1 of system S1, and (output)port 1 of S1 to (input)port 1 of S2. The fourth link (named ‘Y’) links (output)port 1 of S2 to the output (port 0 of fictitious block -1, omitted) and to (input)port 2 of the adder.

//Initialization
syst=`list`_('blocd'); l=1;

//Systems
l=l+1;
n_s1=l;
syst(l)=`list`_('transfer','S1');  //System 1
l=l+1;
n_s2=l;
syst(l)=`list`_('transfer','S2');  //System 2
l=l+1;
n_adder=l;
syst(l)=`list`_('transfer',['1','1']);  //adder

//Links
// Inputs  -1 --> input 1
l=l+1;
syst(l)=`list`_('link','U1',[-1],[n_adder,1]);

// Internal
l=l+1;
syst(l)=`list`_('link',' ',[n_adder,1],[n_s1,1]);
l=l+1;
syst(l)=`list`_('link',' ',[n_s1,1],[n_s2,1]);

// Outputs // -1 -> output 1
l=l+1;
syst(l)=`list`_('link','Y',[n_s2,1],[-1],[n_adder,2]);

With s=poly(0,’s’); S1=1/(s+1);S2=1/s; the result of the evaluation call sl=bloc2ss(syst); is a state-space representation for 1/(s^2+s-1).

[2] LFT example

//Initialization
syst=`list`_('blocd');
l=1;

//System (2x2 blocks plant)
l=l+1;
n_s=l;
syst(l)=`list`_('transfer',['P11','P12';'P21','P22']);

//Controller
l=l+1;
n_k=l;
syst(l)=`list`_('transfer','k');

//Links
l=l+1;
syst(l)=`list`_('link','w',[-1],[n_s,1]);
l=l+1;
syst(l)=`list`_('link','z',[n_s,1],[-1]);
l=l+1;
syst(l)=`list`_('link','u',[n_k,1],[n_s,2]);
l=l+1;
syst(l)=`list`_('link','y',[n_s,2],[n_k,1]);

With

A=[0,1;0,0];
B=[1;1];
C=[1,1];
D=`poly`_(0,'s');
P=`syslin`_('c',A,B,C,D);

bloc2exp(syst) returns the evaluation the lft of P and K.

See Also

• bloc2exp Conversion of a block-diagram to its symbolic expression