Design by transformation is the second of the two design methods discussed in section 12.4 of Nise’s “Control Systems Engineering.” I’ve distilled the author’s discussion of this topic into the procedure below and I made up an example to demonstrate how to use it. I don’t know why.

## Procedure

- Starting with a plant that has some state-space representation (cascade, parallel, etc.), first find the state equations (z state variables) for the plant
- Find the controllability matrix CMz and evaluate det(CMz) to determine whether the system is controllable
- Find the characteristic equation det(sI-Az)
- Use the coefficients from step 3 to write the phase-variable representation (x state variables)
- Find the controllability matrix CMx and evaluate det(CMx) to determine whether the system is controllable
- Use the results from steps 2 and 5 to calculate the transformation matrix (P=CMz*inv(CMx))
- Find the desired closed-loop system (usually based on some performance specifications, like zeta, T
_{p}, etc.) - Write the state equations for the phase-variable form and find the characteristic equation
- Compare the equations from 7 and 8 to find the controller in terms of the x variables. Use the transformation matrix from 6 to write the controller in terms of z variables.
- Write the transfer function for the closed-loop system (z variables) and test it to verify the performance requirements are met.

## Example Problem

Assume the following plant is represented in cascade form:

Design a controller to meet the following performance requirements:

%OS = 13%

T_{p} = 1.1 sec

Use design by transformation from section 12.

## Solution

### Step 1 – find state equations (z state variables)

The system is in cascade form, so the following signal-flow graph can be drawn:

From the signal-flow graph, the state equations are

Sometimes I try to write the output equation by visually inspecting the transfer function and/or the signal-flow graph (because I’m lazy) – and then I end up with the wrong output equation. In an attempt to not do that, I’ll use the signal-flow graph to derive the output equation the long drawn out way. Notice that y can be written as

But sz_{1} can be written as

Substituting

If the state equations are wrong, then your controller design will probably be wrong. If the output equation is wrong, then your controller design can still be correct, but you’ll probably drive yourself crazy trying to test it.

### Step 2 – find CMx and determine whether the system is controllable

```
>> Az=[-4 1 0;0 -3 1;0 0 -2];Bz=[0; 0; 16];
>> CMz=[Bz Az*Bz (Az^2)*Bz]
CMz =
0 0 16
0 16 -80
16 -32 64
>> det(CMz)
ans =
-4096
```

Since det(CM_{z}) ≠ 0, the system is controllable.

### Step 3 – find the characteristic equation det(sI-Az)

To convert to phase-variable form, first find the characteristic equation det(sI-A_{z}).

Since sI-A_{z} is upper triangular, det(sI-A_{z}) is just the product of the diagonal entries.

### Step 4 – write the phase-variable representation (x state variables)

From the characteristic equation, the signal flow graph is

From the signal flow graph, the phase-variable representation is

### Step 5 – find C_{Mx} and determine controllability

```
Ax=[0 1 0;0 0 1;-24 -26 -9];Bx=[0; 0; 16];
CMx = [Bx Ax*Bx (Ax^2)*Bx]
CMx =
0 0 16
0 16 -144
16 -144 880
det(CMx)
ans =
-4096
```

Not surprisingly, det(C_{Mx})=-4096, which agrees with the result from step 2 and confirms the system is controllable.

### Step 6 – find the transformation matrix P

```
P=CMz*inv(CMx)
P =
1.0000 0 0
4.0000 1.0000 0
12.0000 7.0000 1.0000
```

### Step 7 – find the desired closed-loop system

Since %OS = 13%,

And because T_{p} = 1.1 sec,

Therefore,

The third pole will be designed to cancel the zero in G(s), and so the desired closed-loop system has the characteristic equation

### Step 8 – write the state equations for the phase-variable form

The state equations for the state-variable feedback system are

And the characteristic equation is

### Step 9 – find Kx and transform to Kz

Comparing coefficients from steps 7 and 8:

Transforming the controller back to cascade form:

```
Kx=[2.8488 0.4909 0.0443];
Kz=Kx*inv(P)
Kz =
1.5940 0.1808 0.0443
```

### Step 10 – Write the closed-loop transfer function and test it against the performance requirements

The signal flow graph with state variable feedback is

From the signal flow graph:

Now use the signal flow graph to write u in terms of r and some combination of the state variables:

Substituting into the third state equation:

And so

Checking,

```
Az=[-4 1 0;0 -3 1;0 0 2];
Bz=[0;0;16];
Kz=[1.5940 0.1808 0.0443];
Az-(Bz*Kz)
ans =
-4.0000 1.0000 0
0 -3.0000 1.0000
-25.5040 -2.8928 1.2912
```

So the state equations for the feedback system with input r are

The closed-loop transfer function is

```
Az=[-4 1 0;0 -3 1;-25.5040 -2.8928 -2.7088];
Bz=[0;0;16];
Cz=[2 1 0];
syms s;
I=eye(3);
T=Cz*inv(s*I-Az)*Bz;
pretty(T)
(s + 4) 10000 20000
---------------------------------- + ----------------------------------
3 2 3 2
625 s + 6068 s + 21159 s + 43488 625 s + 6068 s + 21159 s + 43488
```

Or

Which matches the result from step 7. Since the third root cancels the zero,

If u is the unit step,

```
num=16;
den=[1 3.7095 11.5968];
T=tf(num,den)
T =
16
--------------------
s^2 + 3.709 s + 11.6
Continuous-time transfer function.
stepinfo(T)
ans =
struct with fields:
RiseTime: 0.5079
SettlingTime: 1.7082
SettlingMin: 1.2705
SettlingMax: 1.5590
Overshoot: 12.9956
Undershoot: 0
Peak: 1.5590
PeakTime: 1.0925
step(T)
grid on
```