# Control Systems/Polynomial Design

## Polynomial Design[edit | edit source]

A powerful tool for the design of controller and compensator systems is **polynomial design**. Polynomial design typically consists of two separate stages:

- Determine the desired response of the system
- Adjust your system to match the desired response.

We do this by creating polynomials, such as the transform-domain transfer functions, and equating coefficients to find the necessary values. The goal in all this is to be able to arbitrarily place all the poles in our system at any locations in the transform domain that we desire. In other words, we want to arbitrarily modify the response of our system to match any desired response. The requirements in this chapter are that the system be fully controllable and observable. If either of these conditions are not satisfied, the techniques in this method cannot be directly implemented.

Through this method it is assumed that the plant is given and is not alterable. To adjust the response of the system, a controller unit needs to be designed that helps the system meet the specifications. Because the controller is being custom designed, the response of the controller can be determined arbitrarily (within physical limits, of course).

## Polynomial Representation[edit | edit source]

Let's say that we have a plant, *G(s)*, and a controller, *C(s)*. Both the controller and the plant are proper systems, composed of monic numerator and denominator polynomials. The plant, *G(s)* has an order of *n*, is given, and cannot be altered. The task is to design the controller *C(s)* of order *m*:

Our closed-loop system, *H(s)* will have a transfer function of:

Our characteristic equation then is:

Our plant is given so we know *a(s)* and *b(s)*, but *A(s)* and *B(s)* are configurable as part of our controller. To determine values for these, we must select a desired response, that is the response that our system *should have*. We call our desired response *D(s)*. We can configure our controller to have our system match the desired response by solving the **Diophantine equation**:

### Diophantine Equation[edit | edit source]

The Diophantine equation becomes a system of linear equations in terms of the unknown coefficients of the *A(s)* and *B(s)* polynomials. There are situations where the Diophantine equation will produce a unique result, but there are also situations where the results will be non-unique.

We multiply polynomials, and then combine powers of *s*:

Now we can equate the coefficients of *D(s)* and our resultant system of equations is given as:

This matrix can be a large one, but the pattern is simple: new coefficients are shifted in from the left, and old coefficients are shifted off to the right on each row.

### Conditions for Uniqueness[edit | edit source]

The diophantine matrix, which we will call *S*, has dimensions of *(n + m + 1) × (2m + 2)*. The solution to this equation is unique if the diophantine matrix is square, and therefore is invertable. If the matrix has more columns then rows, the solution will be non-unique. If the matrix has more rows then columns, the poles of the composite system cannot be arbitrarily placed.

The condition for uniqueness can be satisfied if *m = n - 1*. The order of the controller must be one less than the order of the plant. If the order of the controller is higher, the solution will be non-unique. If the order of the controller is lower, not all the poles can be arbitrarily assigned.

### Example: Second Order System[edit | edit source]

We are given a system *G(s)*, and are told that we need to design a tracking system with a desired system response *D(s)*. *G(s)* and *D(s)* are defined as:

Our plant has order *n = 2*, which means the controller must have an order *m = 1* for a unique solution. Also, our desired response is an order *n + m = 3*. Our controller resembles a PID controller form:

Constructing the Diophantine equation gives us:

The bottom two rows give us:

And the top two rows give us:

And our final controller becomes:

### Example: Helicopter Control[edit | edit source]

Pole placement is the most straightforward means of controller design. Here are the steps to designing a system using pole placement techniques:

- The design starts with an assumption of what form the controller must take in order to control the given plant.
- From that assumption a symbolic characteristic equation is formed.
- At this point the desired closed-loop poles must be determined.
- Typically, specifications designate overshoot, rise time, etc. This leads to the formation of a 2nd order equation. Most of the time the final characteristic equation will have more than 2 poles. So additional desired poles must be determined.
- Once the closed loop poles are decided a desired characteristic equation is formed.
- The coefficients for each power of
*s*are equated from the symbolic characteristic equation to the desired. - Algebra is used to determine the controller coefficients necessary to achieve the desired closed-loop poles with the assumed controller form.

Typically, an integrator is used to drive the steady-state error towards 0. This implies that the final characteristic equation will have at least 1 more pole than the uncontrolled system started with.

The following pole placement examples show you how to decide on the desired closed-loop poles, determine the "extra" closed-loop poles, and create a generic and PID controller to achieve those desired closed-loop poles.

Let's assume a 2nd order system of with the following form:

where

- is the system gain
- is the system's natural frequency
- is the system's damping ratio.

Also, we assume a compensator of form

[1]

is adequate to control the plant. The resulting characteristic equation is:

- .

This can be reduced to:

[2a]

In matrix form this is:

[2b]

At this point we must decide what closed loop poles we would like. In order to do this we need to consider system overshoot and settling time (or time to peak). The equations for each are

where

- is overshoot,
- is 1% settling time, and
- is time to peak.

Using the Overshoot equation we find that a common value, , provides an overshoot of only 4.3%. Examination of the Time to Peak equation lets you know that a value of provides a peak time of seconds. However, a little over 3 seconds is probably too slow. Let's shoot for 0.5 seconds instead. This requires

- .

Recap

However, this leaves us with only 2 roots (poles) in our desired characteristic equation. Since we want the above parameters to dominate the closed loop system dynamics we choose a 3rd pole that is well above the desired natural frequency.

[3]

where

- is our 3rd pole.

This 3rd pole is a high frequency pole that allows the desired poles to the dominate the closed-loop system response while allowing the desired characteristic equation to have the correct number of poles.

Our desired characteristic equation, Eqn. 3, can be reduced to

This results in

From here we go back to our characteristic equation (Eqn. **2a** or **2b**) to determine

## Caveats[edit | edit source]

There are a number of problems that can arise from this method.

### Insufficient Order[edit | edit source]

If *K(s)* has a polynomial degree *m*, and *G(s)* has a polynomial degree *n*, then our composite system *H(s)* will have a total degree of *m + n*. If our controller does not have a high enough order, we will not be able to arbitrarily assign every pole in our system. From state space, we know that poles that cannot be arbitrarily assigned are called uncontrollable. The addition of a controller of insufficient order can make one or more poles in our system uncontrollable.

## External links[edit | edit source]

**Control Systems**book is a stub. You can help by expanding this page, but make sure to follow the

**local manual of style**. If you would like to help, but you don't know how, you can ask on the

**main discussion page**.

**(All Stubs)**