Notch Filter

There are many times when the transfer function of a controlled process contains one or more pairs of complex-conjugate poles that lie close to the imaginary axis in the s-plane. This will result in an undesirable closed-loop system that is unstable or only lightly damped. For example, consider the following transfer function,

If you were to take the root locus of this system,

```num = 1;
den = conv([1 3],[1 1 10]);
plant = tf(num,den);

rlocus(plant)
```
you would end up with the following plot

As you can see, the plot shows that this system is only stable for a small region of the root locus. The portion that is stable will only be lightly damped (small zeta). By closing the loop and plotting the step response to this system in the portion of the root locus that is in the right half plane (assuming a gain of one), you can see that the response is poor.

```     sys_cl = feedback(plant,1);
step(sys_cl)
```

There is a large overshoot, long settling time, and a large steady-state error. If you try to increase the gain, you will see that the response improves slightly, but becomes unstable before a desirable response can achieved. Pure proportional control is obviously not a good way to control this system.

One way to control this system is to design a controller with zeros near the undesirable, lightly-damped poles of the plant. These zeros can attenuate the effect of these poles. The poles of the controller can then be placed in a more desirable position. Such a controller is called a notch filter. Before getting into the specifics of a notch filter, it should be noted that due to the nature of most systems, exact pole/zero cancellation cannot be obtained; nor should it be attempted. Approximate cancellation will give us many of the desirable characteristics without the pitfalls.

For the example above, let's try placing the zeros slightly to the left of the lightly-damped poles (it is a good idea to pull the poles to the left instead of the right). Try the following compensator

As you can see, the roots of the numerator of the controller are almost the same as the complex poles of the denominator of the plant; the denominator of the controller introduces two poles at -10. If we implement this controller into our m-file and plot the root locus

```numnotch = [1 1.5 10];
dennotch = [1 20 100];
notch = tf(numnotch,dennotch);

rlocus(notch*plant);
```

The complex poles near the imaginary axis have been nearly canceled and more of the root locus is now in the left half plane. This means that higher gains, k, can be used, while maintaining stability. Furthermore, higher damping can be achieved using lower gains (zeta term will be larger). If we close this loop (using the rlocfind command to find the gain), and look at the step response, the system response should look much better.

```[k,poles] = rlocfind(notch*plant)
sys_cl = feedback(k*notch*plant,1);
step(sys_cl)
```
When prompted to select a point, pick a point near one of the crosses in the root locus above. The gain (k) should be about 200.

This is a much better step response. The overshoot and settling time are both smaller. There is still a steady-state error, but that can be reduced with a lag controller later. The placement of the poles in the controller is a matter of trial and error. They should be sufficiently to the left to pull the root locus into the left half plane, but their exact location can be determined based on the desired root locus plot and by trial and error.

Use your browser's "Back" button to return to the previous page.