Pole placement design
Pole placement is a method of calculating the optimum gain matrix used to assign closed-loop poles to specified locations, thereby ensuring system stability. Closed-loop pole locations have a direct impact on time response characteristics such as rise time, settling time, and transient oscillations. For more information, see Pole Placement.
From the figure, consider a linear dynamic system in state-space form
For a given vector
p of desired self-conjugate
closed-loop pole locations,
place computes a gain matrix
K such that the state feedback u =
–Kx places the poles at the locations
p. In other
words, the eigenvalues of A – BK will match the entries
p (up to the ordering).
places the desired closed-loop poles
K = place(
p by computing a state-feedback gain
K. All the inputs of the plant are assumed to be control inputs.
place also works for multi-input systems and is based on the algorithm
from . This algorithm uses
the extra degrees of freedom to find a solution that minimizes the sensitivity of the
closed-loop poles to perturbations in A or B.
prec] = place(
prec, an accuracy estimate of how closely the eigenvalues of
A – BK match the specified locations
prec measures the number of accurate decimal
digits in the actual closed-loop poles). A warning is issued if some nonzero closed-loop
pole is more than 10% off from the desired location.
Pole Placement Design for Second-Order System
For this example, consider a simple second-order system with the following state-space matrices:
Input the matrices and create the state-space system.
A = [-1,-2;1,0]; B = [2;0]; C = [0,1]; D = 0; sys = ss(A,B,C,D);
Compute the open-loop poles and check the step response of the open-loop system.
Pol = pole(sys)
Pol = 2×1 complex -0.5000 + 1.3229i -0.5000 - 1.3229i
figure(1) step(sys) hold on;
Notice that there is an unstable pole, and the resultant system is underdamped. Hence, choose real poles in the left half of the complex-plane to remove oscillations.
p = [-1,-2];
Find the gain matrix
K using pole placement and check the closed-loop poles of
K = place(A,B,p); Acl = A-B*K; syscl = ss(Acl,B,C,D); Pcl = pole(syscl)
Pcl = 2×1 -2.0000 -1.0000
Now, compare the step response of the closed-loop system.
Hence, the closed-loop system obtained using pole placement is stable with good steady-state response.
Note that choosing poles that are further away from the imaginary axis achieves faster response time but lowers the steady-state gain of the system. For instance, consider using the poles
[-2,-3] for the above system.
p = [-2, -3]; K2 = place(A,B,p); syscl2 = ss(A-B*K2,B,C,D); figure(1); step(syscl2);
ans = struct with fields: RiseTime: 2.5901 TransientTime: 4.6002 SettlingTime: 4.6002 SettlingMin: 0.9023 SettlingMax: 0.9992 Overshoot: 0 Undershoot: 0 Peak: 0.9992 PeakTime: 7.7827
ans = struct with fields: RiseTime: 1.4130 TransientTime: 2.4766 SettlingTime: 2.4766 SettlingMin: 0.3003 SettlingMax: 0.3331 Overshoot: 0 Undershoot: 0 Peak: 0.3331 PeakTime: 4.1216
Pole Placement Precision
For this example, consider the pole locations
[-2e-13,-3e-4,-3e-3]. Compute the precision of the actual poles.
A = [4,2,1;0,-1,2;0,1e-8,1]; B = [1,2;3,1;1e-6,0]; p = [-2e-13,-3e-4,3e-3]; [~,prec] = place(A,B,p)
prec = 2
A precision value of 2 is obtained indicating that the actual pole locations are precise up to 2 decimal places.
Pole Placement using Complex Poles
For this example, consider the following transfer function with complex-conjugate poles at :
Input the transfer function model. Then, convert it to state-space form since
place uses the
B matrices as input arguments.
s = tf('s'); systf = 8/(s^2+4*s+2); sys = ss(systf);
Next, compute the gain matrix
K using the complex-conjugate poles.
p = [-2+2i,-2-2i]; K = place(sys.A,sys.B,p)
K = 1×2 0 1.5000
The values of the gain matrix are real since the poles are self-conjugate. The values of
K would be complex if
p did not contain self-conjugate poles.
Now, verify the step response of the closed-loop system.
syscl = ss(sys.A-sys.B*K,sys.B,sys.C,sys.D); step(syscl)
Pole Placement Observer Design
For this example, consider the following SISO state-space model:
Create the SISO state-space model defined by the following state-space matrices:
A = [-1,-0.75;1,0]; B = [1;0]; C = [1,1]; D = 0; Plant = ss(A,B,C,D);
Now, provide a pulse to the plant and simulate it using
lsim. Plot the output.
N = 250; t = linspace(0,25,N); u = [ones(N/2,1); zeros(N/2,1)]; x0 = [1;2]; [y,t,x] = lsim(Plant,u,t,x0); figure plot(t,y); title('Output');
For this example, assume that all the state variables cannot be measured and only the output is measured. Hence, design an observer with this measurement. Use
place to compute the estimator gain by transposing the
A matrix and substituting
C' for matrix
B. For this instance, select the desired pole locations at
L = place(A',C',[-2,-3])';
Use the estimator gain to substitute the state matrices using the principle of duality/separation and create the estimated state-space model.
At = A-L*C; Bt = [B,L]; Ct = [C;eye(2)]; sysObserver = ss(At,Bt,Ct,0);
Simulate the time response of the system using the same pulse input.
[observerOutput,t] = lsim(sysObserver,[u,y],t); yHat = observerOutput(:,1); xHat = observerOutput(:,[2 3]);
Compare the response of the actual system and the estimated system.
figure; plot(t,x); hold on; plot(t,xHat,'--'); legend('x_1','x_2','xHat_1','xHat_2') title('Comparison - Actual vs. Estimated');
A — State matrix
State matrix, specified as an
Nx is the number of states.
B — Input-to-state matrix
Input-to-state matrix, specified as an
Nu matrix where,
the number of states and
Nu is the number of inputs.
p — Closed-loop pole locations
Closed-loop pole locations, specified as a vector of length
Nx is the number of states. In other words, the length of
p must match the row size of
A. Closed-loop pole
locations have a direct impact on time response characteristics such as rise time,
settling time, and transient oscillations. For an example on selecting poles, see Pole Placement Design for Second-Order System.
place returns an error if some poles in
multiplicity greater than
In high-order problems, some choices of pole locations result in very large gains. The sensitivity problems attached with large gains suggest caution in the use of pole placement techniques. See  for results from numerical testing.
K — Optimum gain
Optimum gain or full-state feedback gain, returned as an
Nx matrix where,
the number of states and
Ny is the number of outputs.
place computes a gain matrix
K such that the
state feedback u = –Kx places the closed-loop
poles at the locations
complex when the pole locations are not complex-conjugates.
prec — Accuracy estimate of the assigned poles
Accuracy estimate of the assigned poles, returned as a scalar.
prec measures the number of accurate decimal digits in the actual
closed-loop poles in contrast to the pole locations specified in
 Kautsky, J., N.K. Nichols, and P. Van Dooren, "Robust Pole Assignment in Linear State Feedback," International Journal of Control, 41 (1985), pp. 1129-1155.
 Laub, A.J. and M. Wette, Algorithms and Software for Pole Assignment and Observers, UCRL-15646 Rev. 1, EE Dept., Univ. of Calif., Santa Barbara, CA, Sept. 1984.
Introduced before R2006a