pole placement evam

Intro to Control Theory Part 6: Pole Placement

In Part 4 , I covered how to make a state-space model of a system to make running simulations easy. In this post, I'll talk about how to use that model to make a controller for our system.

For this post, I'm going to use an example system that I haven't talked about before - A mass on a spring:

If we call \(p\) the position of the cart (we use \(p\) instead of \(x\), since \(x\) is the entire state once we're using a state space representation), then we find that the following equation describes how the cart will move:

\[ \dot{p} = -\frac{k}{m}p \]

Where \(p\) is position, \(k\) is the spring constant of the spring (how strong it is), and \(m\) is the mass of the cart.

You can derive this from Hooke's Law if you're interested, but the intuitive explanation is that the spring pulls back against the cart proportionally to how far it is away from the equilibrium state of the spring, but gets slowed down the heavier the cart is.

This describes a ideal spring, but one thing that you'll notice if you run a simulation of this is that it will keep on oscillating forever! We haven't taken into account friction. Taking into account friction gets us the following equation:

\[ \dot{p} = -\frac{k}{m}p - \frac{c}{m}\dot{p} \]

Where \(c\) is the "damping coefficient" - essentially the amount of friction acting on the cart.

Now that we have this equation, let's convert it into state space form!

This system has two states - position, and velocity:

\[ x = \begin{bmatrix} p \\ \dot{p} \end{bmatrix} \]

Since \(x\) is a vector of length 2, \(A\) will be a 2x2 matrix. Remember, a state space representation always takes this form:

\[ \dot{x} = Ax + Bu \]

We'll find \(A\) first:

\[ \begin{bmatrix} \dot{p} \\ \ddot{p} \end{bmatrix} = \begin{bmatrix} ? & ? \\ ? & ? \end{bmatrix} \begin{bmatrix} p \\ \dot{p} \end{bmatrix} \]

The way that I like to think about this is that each number in the matrix is asking a question - how does X affect Y? So, for example, the upper left number in the A matrix is asking "How does position affect velocity?". Position has no effect on velocity, so the upper left number is zero. Next, we can look at the upper right number. This is asking "How does velocity affect velocity?" Well, velocity is velocity, so we put a 1 there (since you need to multiply velocity by 1 to get velocity). If we keep doing this process, we get the following equation:

\[ \begin{bmatrix} \dot{p} \\ \ddot{p} \end{bmatrix} = \begin{bmatrix} 0 & 1 \\ -\frac{k}{m} & -\frac{c}{m} \end{bmatrix} \begin{bmatrix} p \\ \dot{p} \end{bmatrix} \]

For the sake of this post, I'll pick some arbitrary values for \(m\), \(k\), and \(c\): \(m = 1 \text{kg}\), \(k = 0.4 \text{N/m}\), \(c = 0.3 \text{N/m/s}\). Running a simulation of this system, starting at a position of 1 meter, we get the following response:

Notice that this plot shows two things happening - the position is oscillating, but also decreasing. There's actually a way to quantify how much the system will oscillate and how quickly it will converge to zero (if it does at all!). In order to see how a system will act, we look at the "poles" of the system. In order to understand what the poles of a system mean, we need to take a quick detour into linear algebra.

Our matrix \(A\) is actually a linear transformation . That means that if we multiply a vector by \(A\), we will get out a new, transformed vector. Multiplication and addition are preserved, such that \( A(x \times 5) = (Ax) \times 5 \) and \( A(x_1 + x_2) = Ax_1 + Ax_2 \). When you look at \(A\) as a linear transformation, you'll see that some vectors don't change direction when you apply the transform to them:

The vectors that don't change direction when transformed are called "eigenvectors". For this transform, the eigenvectors are the blue and pink arrows. Each eigenvector has an "eigenvalue", which is how much it stretches the vector by. In this example, the eigenvalue of the blue vectors is 3 and the eigenvalue of the pink vectors is 1.

So how does this all relate to state space systems? Well, the eigenvalues of the system (also called the poles of a system) have a direct effect on the response of the system. Let's look at our eigenvalues for our system above. Plugging the matrix into octave/matlab gives us:

So we can see that we have two eigenvalues, both of which are complex numbers. What does this mean? Well, the real component of the number tells you how fast the system will converge to zero. The more negative it is, the faster it will converge to zero. If it is above zero, the system is unstable, and will trend towards infinity (or negative infinity). If it is exactly zero, the system is "marginally stable" - it won't get larger or smaller. The imaginary part of the number tells you how much the system will oscillate. For every positive imaginary part, there is a negative one of the same magnitude with the same real part, so it's just the magnitude of the imaginary part that determines how much the system will oscillate - the higher the magnitude of the imaginary part, the more the system will oscillate.

Why is this the case? Well, as it turns out, the derivative of a specific state is the current value of that state times the eigenvalue associated with that state. So, a negative eigenvalue will result in a derivative that drives the state to zero, whereas a positive eigenvalue will cause the state to increase in magnitude forever. A eigenvalue of zero will cause the derivative to be zero, which obviously results in no change to the state.

That explains real eigenvalues, but what about imaginary eigenvalues? Let's imagine a system that has two poles, at \(0+0.1i\) and \(0-0.1i\). Since this system has a real component of zero, it will be marginally stable, but since it has an imaginary component, it will oscillate. Here's a way of visualizing this system:

The blue vector is the position of the system. The red vectors are the different components of that position (the sum of the red vectors will equal the blue vector). The green vectors are the time derivatives of the red vectors. As you can see, the eigenvalue being imaginary causes each component of the position to be imaginary, but since there is always a pair of imaginary poles of the same magnitude but different signs, the actual position will always be real.

So, how is this useful? Well, it lets us look at a system and see what it's response will look like. But we don't just want to be able to see how the system will respond, we want to be able to change how the system will respond. Let's return to our mass on a spring:

Now let's say that we can apply an arbitrary force \(u\) to the system. For this, we use our \(B\) matrix:

\[ \begin{bmatrix} \dot{p} \\ \ddot{p} \end{bmatrix} = \begin{bmatrix} 0 & 1 \\ -\frac{k}{m} & -\frac{c}{m} \end{bmatrix} \begin{bmatrix} p \\ \dot{p} \end{bmatrix} + \begin{bmatrix} 0 \\ \frac{1}{m} \end{bmatrix} u \]

Now, let's design a controller that will stop there from being any oscillation, and drive the system to zero much more quickly. Remember, all "designing a controller" means in this case is finding a matrix \(K\), where setting \( u = Kx \) will cause the system to respond in the way that you want it to. How do we do this? Well, it turns out that it's actually fairly easy to place the poles of a system wherever you want. Since we want to have no oscillation, we'll make the imaginary part of the poles zero, and since we want a fast response time, we'll make the real part of the poles -2.5 (this is pretty arbitrary). We can use matlab/octave to find what our K matrix must be to have the poles of the closed loop system be at -2.5:

Which gives us the output:

So our K matrix is:

\[ K = \begin{bmatrix} 5.85 \\ 4.7 \end{bmatrix} \]

And running a simulation of the system with that K matrix gives us:

Much better! It converges in under five seconds with no oscillation, compared with >30 seconds with lots of oscillations for the open-loop response. But wait, if we can place the poles anywhere we want, and the more negative they are the faster the response, why not just place them as far negative as possible? Why not place them at -100 or -1000 or -100000? For that matter, why do we ever want our system to oscillate, if we can just make the imaginary part of the poles zero? Well, the answer is that you can make the system converge as fast as you want, so long as you have enough energy that you can actually apply to the system. In real life, the motors and actuators that are limited in the amount of force that they can apply. We ignore this in the state-space model, since it makes the system non-linear, but it's something that you need to keep in mind when designing a controller. This is also the reason that you might want some oscillation - oscillation will make you reach your target faster than you would otherwise. Sometimes, getting to the target fast is more important than not oscillating much.

So, that's how you design a state space controller with pole placement! There are also a ton of other ways to design controllers (most notably LQR) which I'll go into later, but understanding how poles determine the response of a system is important for any kind of controller.

If you're in NYC and want to meet up over lunch/coffee to chat about the future of technology, get in touch with me .

• LRC circuit
• BoostConverter
• NEXT ►

Introduction: State-Space Methods for Controller Design

In this section, we will show how to design controllers and observers using state-space (or time-domain) methods.

Key MATLAB commands used in this tutorial are: eig , ss , lsim , place , acker

Related Tutorial Links

• LQR Animation 1
• LQR Animation 2

Related External Links

• MATLAB State FB Video
• State Space Intro Video

Controllability and Observability

Control design using pole placement, introducing the reference input, observer design.

There are several different ways to describe a system of linear differential equations. The state-space representation was introduced in the Introduction: System Modeling section. For a SISO LTI system, the state-space form is given below:

To introduce the state-space control design method, we will use the magnetically suspended ball as an example. The current through the coils induces a magnetic force which can balance the force of gravity and cause the ball (which is made of a magnetic material) to be suspended in mid-air. The modeling of this system has been established in many control text books (including Automatic Control Systems by B. C. Kuo, the seventh edition).

The equations for the system are given by:

From inspection, it can be seen that one of the poles is in the right-half plane (i.e. has positive real part), which means that the open-loop system is unstable.

To observe what happens to this unstable system when there is a non-zero initial condition, add the following lines to your m-file and run it again:

It looks like the distance between the ball and the electromagnet will go to infinity, but probably the ball hits the table or the floor first (and also probably goes out of the range where our linearization is valid).

Let's build a controller for this system using a pole placement approach. The schematic of a full-state feedback system is shown below. By full-state, we mean that all state variables are known to the controller at all times. For this system, we would need a sensor measuring the ball's position, another measuring the ball's velocity, and a third measuring the current in the electromagnet.

The state-space equations for the closed-loop feedback system are, therefore,

From inspection, we can see the overshoot is too large (there are also zeros in the transfer function which can increase the overshoot; you do not explicitly see the zeros in the state-space formulation). Try placing the poles further to the left to see if the transient response improves (this should also make the response faster).

This time the overshoot is smaller. Consult your textbook for further suggestions on choosing the desired closed-loop poles.

Note: If you want to place two or more poles at the same position, place will not work. You can use a function called acker which achieves the same goal (but can be less numerically well-conditioned):

K = acker(A,B,[p1 p2 p3])

Now, we will take the control system as defined above and apply a step input (we choose a small value for the step, so we remain in the region where our linearization is valid). Replace t , u , and lsim in your m-file with the following:

The system does not track the step well at all; not only is the magnitude not one, but it is negative instead of positive!

and now a step can be tracked reasonably well. Note, our calculation of the scaling factor requires good knowledge of the system. If our model is in error, then we will scale the input an incorrect amount. An alternative, similar to what was introduced with PID control, is to add a state variable for the integral of the output error. This has the effect of adding an integral term to our controller which is known to reduce steady-state error.

From the above, we can see that the observer estimates converge to the actual state variables quickly and track the state variables well in steady-state.

Published with MATLAB® 9.2

Controller design by pole placement

Cite this chapter.

• L. C. Westphal 2  

358 Accesses

In classical methods of control law design, a structure for the controller is introduced by the designer and then several parameters within that structure are chosen to yield a response which meets specifications. Design work is usually done with the transfer function, either in a complex plane (as in root locus) or in the frequency domain (Nyquist-Bode-Nichols). The mathematics of pole placement design are as useful and interesting as many of the results, and therefore this chapter considers many variations on the basic problem: the essential result is that under certain conditions the poles of the closed-loop system may be placed at arbitrary locations of the designer’s choice.

This is a preview of subscription content, log in via an institution to check access.

Access this chapter

• Available as PDF
• Read on any device
• Instant download
• Own it forever
• Compact, lightweight edition
• Dispatched in 3 to 5 business days
• Free shipping worldwide - see info
• Durable hardcover edition

Tax calculation will be finalised at checkout

Purchases are for personal use only

Institutional subscriptions

Unable to display preview.  Download preview PDF.

Author information

Authors and affiliations.

Department of Electrical and Computer Engineering, University of Queensland, Australia

L. C. Westphal

You can also search for this author in PubMed   Google Scholar

Rights and permissions

Reprints and permissions

Copyright information

© 1995 Springer Science+Business Media Dordrecht

About this chapter

Westphal, L.C. (1995). Controller design by pole placement. In: Sourcebook of Control Systems Engineering. Springer, Boston, MA. https://doi.org/10.1007/978-1-4615-1805-1_23

Download citation

DOI : https://doi.org/10.1007/978-1-4615-1805-1_23

Publisher Name : Springer, Boston, MA

Print ISBN : 978-1-4613-5729-2

Online ISBN : 978-1-4615-1805-1

eBook Packages : Springer Book Archive

Share this chapter

Anyone you share the following link with will be able to read this content:

Sorry, a shareable link is not currently available for this article.

Provided by the Springer Nature SharedIt content-sharing initiative

• Publish with us

Policies and ethics

• Find a journal
• Track your research

Help Center Help Center

• Help Center
• Trial Software
• Product Updates
• Documentation

Pole Placement

Closed-loop pole locations have a direct impact on time response characteristics such as rise time, settling time, and transient oscillations. Root locus uses compensator gains to move closed-loop poles to achieve design specifications for SISO systems. You can, however, use state-space techniques to assign closed-loop poles. This design technique is known as pole placement , which differs from root locus in the following ways:

Using pole placement techniques, you can design dynamic compensators.

Pole placement techniques are applicable to MIMO systems.

Pole placement requires a state-space model of the system (use ss to convert other model formats to state space). In continuous time, such models are of the form

x ˙ = A x + B u y = C x + D u

where u is the vector of control inputs, x is the state vector, and y is the vector of measurements.

State-Feedback Gain Selection

Under state feedback u = − K x , the closed-loop dynamics are given by

x ˙ = ( A − B K ) x

and the closed-loop poles are the eigenvalues of A - BK . Using the place function, you can compute a gain matrix K that assigns these poles to any desired locations in the complex plane (provided that ( A , B ) is controllable).

For example, for state matrices A and B , and vector p that contains the desired locations of the closed loop poles,

computes an appropriate gain matrix K .

State Estimator Design

You cannot implement the state-feedback law u = − K x unless the full state x is measured. However, you can construct a state estimate ξ such that the law u = − K ξ retains similar pole assignment and closed-loop properties. You can achieve this by designing a state estimator (or observer) of the form

ξ ˙ = A ξ + B u + L ( y − C ξ − D u )

The estimator poles are the eigenvalues of A - LC , which can be arbitrarily assigned by proper selection of the estimator gain matrix L , provided that ( C, A ) is observable. Generally, the estimator dynamics should be faster than the controller dynamics (eigenvalues of A - BK ).

Use the place function to calculate the L matrix

where A and C are the state and output matrices, and q is the vector containing the desired closed-loop poles for the observer.

Replacing x by its estimate ξ in u = − K x yields the dynamic output-feedback compensator

ξ ˙ = [ A − L C − ( B − L D ) K ] ξ + L y u = − K ξ

Note that the resulting closed-loop dynamics are

[ x ˙ e ˙ ] = [ A − B K B K 0 A − L C ] [ x e ] ,   e = x − ξ

Hence, you actually assign all closed-loop poles by independently placing the eigenvalues of A - BK and A - LC .

Given a continuous-time state-space model

with seven outputs and four inputs, suppose you have designed

A state-feedback controller gain K using inputs 1, 2, and 4 of the plant as control inputs

A state estimator with gain L using outputs 4, 7, and 1 of the plant as sensors

Input 3 of the plant as an additional known input

You can then connect the controller and estimator and form the dynamic compensator using this code:

Pole Placement Tools

You can use functions to

Compute gain matrices K and L that achieve the desired closed-loop pole locations.

Form the state estimator and dynamic compensator using these gains.

The following table summarizes the functions for pole placement.

Pole placement can be badly conditioned if you choose unrealistic pole locations. In particular, you should avoid:

Placing multiple poles at the same location.

Moving poles that are weakly controllable or observable. This typically requires high gain, which in turn makes the entire closed-loop eigenstructure very sensitive to perturbation.

estim | place | reg

MATLAB Command

You clicked a link that corresponds to this MATLAB command:

Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.

Select a Web Site

Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .

• Switzerland (English)
• Switzerland (Deutsch)
• Switzerland (Français)
• 中国 (English)

You can also select a web site from the following list:

How to Get Best Site Performance

Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.

• América Latina (Español)
• Canada (English)
• United States (English)
• Belgium (English)
• Denmark (English)
• Deutschland (Deutsch)
• España (Español)
• Finland (English)
• France (Français)
• Ireland (English)
• Italia (Italiano)
• Luxembourg (English)
• Netherlands (English)
• Norway (English)
• Österreich (Deutsch)
• Portugal (English)
• Sweden (English)
• United Kingdom (English)

Asia Pacific

• Australia (English)
• India (English)
• New Zealand (English)

Contact your local office

This page is a copy of research/systems_and_control/signalprocessing/automatic/pole_place (Wed, 31 Aug 2022 15:09:11)

This page is a copy of research/syscon/automatic/pole_place (wed, 27 may 2015 14:16:37), pole placement design.

The pole placement problem has been a subject for research for a long time. It is well known that state feedback control is an efficient technique for the pole placement problem. For single-input systems this problem is well understood but for multi-input systems the pole placement problem is more complex. In [1] a parameterization of state feedback gains for pole placement was presented. In [2] this parameterization was developed further and characterized with respect to completeness and existence. In [3] some of the results from [2] are summarized.

This parameterization depends on two matrices that can be regarded as design parameters. In [2] it is shown how the degree of freedom in the pole placement problem for multi-input systems is characterized by these two matrices. It turns out that the properties of the parameterization depend on whether the characteristic polynomials of the open and the closed loop systems are coprime or not. In the case when the open loop and the closed loop characteristic polynomials are coprime the parameterization is complete in the sense that every possible feedback gain can be parameterized in this way. However, this is not the case when the open loop and the closed loop characteristic polynomials are not coprime.

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications

Pole placement for state equation, users can choose feedback gain when K is not unique.

squarezhong/SDM364-Project2-Pole-Placement

Folders and files, repository files navigation, multi-variable control project2, requirement.

Requirement: Modify MATLAB command "place" so to make user have more flexibility in choosing pole-placement controller K when it is not unique.

Introduction

This project is used to calculate controller gain K for a given system (A,B) and desired poles. If K is not unique, users can adjust seed value to choose different K. The function "sdimPlace.m" is the main entry of this project.

File Structure

• "sdimPlace.m": main entry of the project.
• "isCyclic.m": judge if the matrix is cyclic.
• "mustBeControllable.m": check if the pair (A,B) is controllable.
• "cyclicPlace.m": place poles for cyclic matrix.
• "jordanPlace.m": place poles for non-cyclic matrix.
• "examples.mlx": example file concerning the three usages of "sdimPlace.m".

Environment

• MATLAB R2023a
• This project uses "arguments" instead of "varargin" for default parameters, MATLAB version before R2019b is not supported.

Applications

Function sdimPalce() has three usages:

• Single input case, directly use MATLAB "place" function.
• Multiple inputs and cyclic case.
• Multiple inputs and non-cyclic case.

Examples can be found in "examples.mlx".

pair(A,B) must be controllable. If not, do controllability decomposition first. Then use the function sdimPlace(A,B,poles,seed) to get the controller K for controllable subsystems.

Use sdimPlace(A,B,poles,seed) to get the controller K. Change the `seed`` to get different results if K is not unique.

flowchart of the sdimPlace() function

For single input case, the function place() in MATLAB is used directly. Of course, Ackermann's formula and Bass-Gura formula can also be used to get the controller K. They are simple in the single input case.

MI & Cyclic

Theorem (Controllability with p inputs and controllability with 1 input). If the n-dimensional p-input pair (A, B) is controllable and if A is cyclic, then for almost any p × 1 vector V, the single-input pair (A, BV) is controllable.

First judge if the matrix is cyclic (characteristic polynomial = minimal polynomial). If it is cyclic, then use the above theorem to get the controller K.

Random number generator is used to generate the vector V. We need to ensure that the pair (A, BV) is controllable. Therefore if the pair (A, B) is not controllable, V will be generated again until the pair (A, BV) is controllable. Then use MATLAB function place() or Bass-Gura formula to get the controller K_init for the pair(A, BV). Finally, $K = V K_{init}$

MI & Non-cyclic

MATLAB function place() has an limitation that it cannot place poles with multiplicity greater than rank(B). It will display the error message: The "place" command cannot place poles with multiplicity greater than rank(B) .

So I use the Jordan form of A to solve this problem. Repeated eigenvalues of A are treated as jordan blocks rather than single eigenvalues. To be specific, I split the repeated eigenvalues into two groups (of cource they can be splitted into more groups) and calculate the controller K for each group. It is worth noting that the number of jordan blocks of repeated eigenvalues still cannot be greater than rank(B).

If we do eigen decomposition of A - BK, we can get the following equation:

$A - B,K = V,\Lambda,V^{-1}$

with $A, \Lambda, V \in R^{n \times n}, B \in R^{n \times p}, K \in R^{p \times n}$ , where $\Lambda$ is a diagonal matrix with eigenvalues of A - BK on the diagonal.

Then the largest number of columns of V (eigenvectors) that can be chosen freely should equal:

$number \le \displaystyle\frac{n(p-1)}{n-1}$

Let $\Omega = KV$ which is chosen randomly.

For each jordan block of repeated eigenvalues, the corresponding columns of $V$ can be calculated by the following equation:

$V_{\bullet,i} = (A - \Lambda_{i,i},I)^{-1} B,\Omega_{\bullet,i}$

$V_{\bullet,i+k} = (A - \Lambda_{i,i},I)^{-1} (B,\Omega_{\bullet,i+k} + V_{\bullet,i+k-1})$

After calculating each columns of $V$ , we can get the controller K by the following equation:

$K = \Omega V^{-1}$

Since the combination of repeated eigenvalues is not unique, we need to calculate the controller K for each combination.

Future Plan

Some optimization method can be used to make the controller gain matrix K better.

[1] K. van der Veen, “Reference Request: Algorithm for Eigenvalues Placement for MIMO LTI Dynamical Systems,” Mathematics Stack Exchange , Aug. 06, 2017. https://math.stackexchange.com/questions/2388491/reference-request-algorithm-for-eigenvalues-placement-for-mimo-lti-dynamical-sy (accessed Jan. 18, 2024).

[2] J. Braslavsky, “Control Systems Design Lecture 20: Scaling and MIMO State Feedback Design.” Accessed: Jan. 18, 2024. [Online]. Available: https://www.eng.newcastle.edu.au/~jhb519/teaching/elec4410/lectures/Lec20.pdf

• MATLAB 100.0%