Scilab Home page | Wiki | Bug tracker | Forge | Mailing list archives | ATOMS | File exchange
Change language to: Français - Português - 日本語 - Русский

Please note that the recommended version of Scilab is 6.1.1. This page might be outdated.
However, this page did not exist in the previous stable version.

Scilab help >> Elementary Functions > Signal processing > bloc2exp

# bloc2exp

Conversion of a block-diagram to its symbolic expression

### Calling Sequence

```[str]=bloc2exp(blocd)
[str,names]=bloc2exp(blocd)```

blocd

list

str

string

names

string

### Description

given a block-diagram representation of a linear system `bloc2exp` returns its symbolic evaluation. The first element of the list `blocd` must be the string `'blocd'`. Each other element of this list `(blocd(2),blocd(3),...)` 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 `'link'` 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

 `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.

### Examples

```//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

// Inputs  -1 --> input 1
// Internal

// Outputs // -1 -> output 1

//Evaluation call
w=bloc2exp(syst);```

The result is the character string: `w=-(s2*s1-eye())\s2*s1`.

Note that invoked with two output arguments, ```[str,names]= blocd(syst)``` returns in `names` the list of symbolic names of named links. This is useful to set names to inputs and outputs.

```//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');

//Evaluation call
w=bloc2exp(syst);```

In this case the result is a formula equivalent to the usual one:

`P11+P12*invr(eye()-K*P22)*K*P21;`