Limitations of Proportional Control – Why We Need an Integrator in the Control Loop – Control Engineering Lecture – Fusion of Engineering, Control, Coding, Machine Learning, and Science

In this control engineering and control theory tutorial, by using an example, we explain the following important facts about proportional control

Without an integrator in the loop (an integrator can come from the plant or the controller), a proportional controller algorithm usually cannot achieve perfect set-point tracking. That is, a simple proportional controller without an integrator in the loop cannot eliminate a steady-state tracking error.
We can improve the performance of the proportional control algorithm by increasing the proportional control gain. This leads to the high-gain feedback control principle. However, high proportional control gain might have several negative effects.
The limitations of the simple proportional control imply that we need an integrator or an integral control action in the loop.

The example presented in this tutorial is very important for learning control engineering and for preparing control engineering interviews.

Example 1: Proportional Control of First Order System

Problem 1: Consider the control structure given in the figure below.

In the figure above, $y$ is the output of the system, $r$ is the control reference (set point), $u$ is the control input, $K>0$ is a proportional control gain, and $T>0$ and $a>0$ are arbitrary constants defining the transfer function of the plant:

(1) $\begin{align*}W=\frac{1}{Ts+a}\end{align*}$

Assume that the set point is a unit step signal. Is it possible to design the proportional control gain $K$ such that the steady state tracking error is equal to $0$ ?
If NOT, how can we design the proportional control gain $K$ such that the steady-state tracking error is minimized?
How do the model parameters $T$ and $a$ influence the steady-state error and our ability to control the system by using the proportional controller?

Solution:

The solution to this problem is to first derive the transfer function of the closed-loop system. From the figure above, we have

(2) $\begin{align*}Y(s) & =\frac{1}{Ts+a}U(s) \\U(s) & =K E(s) \\E(s) & = R(s)- Y(s)\end{align*}$

where $Y(s)$ , $R(s)$ , $E(s)$ , $U(s)$ , are the Laplace transform of the time domain signals $y(t)$ , $r(t)$ , $e(t)$ , and $u(t)$ . The closed-loop transfer function is

(3) $\begin{align*}W_{\text{cl}}=\frac{Y(s)}{R(s)}\end{align*}$

From the third and second equations in (2), we have

(4) $\begin{align*}U(s)=K\big( R(s)- Y(s) \big)\end{align*}$

By substituting this equation in the first equation of (2), we obtain

(5) $\begin{align*}Y(s) & =\frac{1}{Ts+a}\Big( K\big( R(s)- Y(s) \big) \Big)\end{align*}$

From the last equation, we have

(6) $\begin{align*}& Y(s) =\frac{K}{Ts+a}R(s)- \frac{K}{Ts+a}Y(s) \\& \big(1+\frac{K}{Ts+a} \big) Y(s)= \frac{K}{Ts+a}R(s)\\& \frac{Ts+K+a}{Ts+a} Y(s)=\frac{K}{Ts+a}R(s) \end{align*}$

From the last equation in (6), we obtain the closed loop transfer function

(7) $\begin{align*}W_{\text{cl}}=\frac{Y(s)}{R(s)}=\frac{K}{Ts+K+a}\end{align*}$

From the last equation, we obtain

(8) $\begin{align*}Y(s)=W_{\text{cl}}R(s)=\frac{K}{Ts+K+a}R(s)\end{align*}$

The unit step signal is $r(t)=1$ . The Laplace transform of the unit step signal is

(9) $\begin{align*}R(s)=\frac{1}{s}\end{align*}$

By substituting (9) in (8), we obtain

(10) $\begin{align*}Y(s)=W_{\text{cl}}R(s)=\frac{K}{Ts+K+a}\cdot \frac{1}{s}\end{align*}$

Let us compute the steady-state value of the output $y(t)$ in the time domain. By using the final value theorem, we have

(11) $\begin{align*}y_{\text{ss}}=\lim_{t \rightarrow \infty} y(t) =\lim_{s \rightarrow 0 } s \cdot Y(s)\end{align*}$

By substituting (10) in (11), we obtain

(12) $\begin{align*}y_{\text{ss}} & =\lim_{s \rightarrow 0 } s \cdot Y(s) = \lim_{s \rightarrow 0 } s \cdot \frac{K}{Ts+K+a}\cdot \frac{1}{s} \\y_{\text{ss}} & =\lim_{s \rightarrow 0 } \frac{K}{Ts+K+a} = \frac{K}{K+a}\end{align*}$

The steady-state error is given by

(13) $\begin{align*}e_{\text{ss}} & =\lim_{t\rightarrow \infty} r(t)-y(t) \\e_{\text{ss}} & =1 - y_{\text{ss}} \\e_{\text{ss}} & =1 - \frac{K}{K+a} \\e_{\text{ss}} & = \frac{K+a-K}{K+a} =\frac{a}{K+a}\end{align*}$

The steady-state error is given by

(14) $\begin{align*}e_{\text{ss}}=\frac{a}{K+a}\end{align*}$

We can observe the following

The proportional controller cannot achieve zero steady-state error.
We can minimize the steady-state tracking error by selecting a large value of the gain $K$ . This leads to the high-gain feedback controller.
We can observe that the parameter $T$ does not influence the value of the steady-state error.

Let us now investigate the influence of the parameter $a$ on the value of the steady-state tracking error. Let us assume that $K$ is constant, and let us compute the first derivative of $e_{\text{ss}}$ with respect to $a$ . As a result, we have

(15) $\begin{align*}\frac{\text{d}e_{\text{ss}}}{\text{d}a}=\frac{K+a-(a)}{(K+a)^{2}}=\frac{K}{(K+a)^{2}}\end{align*}$

We can observe that the first derivative is positive. This means that the steady-state error increases with the increase of $a$ . All this implies that if $a$ has a small positive value ( $a$ is positive), then the steady-state error is close to zero if the proportional control gain $K$ is much larger than $a$ . When $a$ is close to zero, then the dynamics of the plant is slow. This means that we can effectively control very slow first-order systems with proportional control.

To achieve a zero value of the steady-state tracking error, either a controller or the plan need to contain an integrator. This will be explained in our next tutorial given here.

Example 1: Proportional Control of First Order System

admin

You might also like

Model Predictive Control (MPC) Tutorial 1: Unconstrained Formulation, Derivation, and Implementation in Python from Scratch

How to Calculate Eigenvalues and Eigenvectors of Matrices by Hand – Mathematics, Dynamics, and Control Engineering Tutorial

Clear and Concise Particle Filter Tutorial with Python Implementation- Part 3: Python Implementation of Particle Filter Algorithm