Extras: Steady-State Error

Contents

  • Calculating steady-state errors
  • System type and steady-state error
  • Example: Meeting steady-state error requirements

Steady-state error is defined as the difference between the input (command) and the output of a system in the limit as time
goes to infinity (i.e. when the response has reached steady state). The steady-state error will depend on the type of input
(step, ramp, etc.) as well as the system type (0, I, or II).

Note: Steady-state error analysis is only useful for stable systems. You should always check the system for stability before
performing a steady-state error analysis. Many of the techniques that we present will give an answer even if the error does
not reach a finite steady-state value.

Calculating steady-state errors

Before talking about the relationships between steady-state error and system type, we will show how to calculate error regardless
of system type or input. Then, we will start deriving formulas we can apply when the system has a specific structure and the
input is one of our standard functions. Steady-state error can be calculated from the open- or closed-loop transfer function
for unity feedback systems. For example, let’s say that we have the system given below.

This is equivalent to the following system, where T(s) is the closed-loop transfer function.

We can calculate the steady-state error for this system from either the open- or closed-loop transfer function using the Final
Value Theorem. Recall that this theorem can only be applied if the subject of the limit (sE(s) in this case) has poles with negative real part.

(1)$$ e(\infty) = \lim_{s\rightarrow0}sE(s) = \lim_{s\rightarrow0}\frac{sR(s)}{1+G(s)} $$

(2)$$ e(\infty) = \lim_{s\rightarrow0}sE(s) = \lim_{s\rightarrow0}sR(s)[1-T(s)] $$

Now, let’s plug in the Laplace transforms for some standard inputs and determine equations to calculate steady-state error
from the open-loop transfer function in each case.

  • Step Input (R(s) = 1 / s):

(3)$$ e(\infty)=\frac{1}{1+\lim_{s\rightarrow0}G(s)}=\frac{1}{1+K_{p}}\Rightarrow K_{p}=\lim_{s\rightarrow0}G(s) $$

  • Ramp Input (R(s) = 1 / s^2):

(4)$$ e(\infty)=\frac{1}{\lim_{s\rightarrow0}sG(s)}=\frac{1}{K_{v}}\Rightarrow K_{v}=\lim_{s\rightarrow0}sG(s) $$

  • Parabolic Input (R(s) = 1 / s^3):

(5)$$ e(\infty)=\frac{1}{\lim_{s\rightarrow0}s^2G(s)}=\frac{1}{K_{a}}\Rightarrow K_{a}=\lim_{s\rightarrow0}s^2G(s) $$

When we design a controller, we usually also want to compensate for disturbances to a system. Let’s say that we have a system
with a disturbance that enters in the manner shown below.

We can find the steady-state error due to a step disturbance input again employing the Final Value Theorem (treat R(s) = 0).

(6)$$ e(\infty)= \lim_{s\rightarrow0}sE(s) = \frac{1}{\lim_{s\rightarrow0}\frac{1}{P(s)}+\lim_{s\rightarrow0}
C(s)} $$

When we have a non-unity feedback system we need to be careful since the signal entering G(s) is no longer the actual error E(s). Error is the difference between the commanded reference and the actual output, E(s) = R(s) – Y(s). When there is a transfer function H(s) in the feedback path, the signal being substracted from R(s) is no longer the true output Y(s), it has been distorted by H(s). This situation is depicted below.

Manipulating the blocks, we can transform the system into an equivalent unity-feedback structure as shown below.

Then we can apply the equations we derived above.

System type and steady-state error

If you refer back to the equations for calculating steady-state errors for unity feedback systems, you will find that we have
defined certain constants (known as the static error constants). These constants are the position constant (Kp), the velocity constant (Kv), and the acceleration constant (Ka). Knowing the value of these constants, as well as the system type, we can predict if our system is going to have a finite
steady-state error.

First, let’s talk about system type. The system type is defined as the number of pure integrators in the forward path of a
unity-feedback system. That is, the system type is equal to the value of n when the system is represented as in the following figure. It does not matter if the integrators are part of the controller
or the plant.

Therefore, a system can be type 0, type 1, etc. The following tables summarize how steady-state error varies with system type.

Type 0 system Step Input Ramp Input Parabolic Input
Steady-State Error Formula 1/(1+Kp) 1/Kv 1/Ka
Static Error Constant Kp = constant Kv = 0 Ka = 0
Error 1/(1+Kp) infinity infinity
Type 1 system Step Input Ramp Input Parabolic Input
Steady-State Error Formula 1/(1+Kp) 1/Kv 1/Ka
Static Error Constant Kp = infinity Kv = constant Ka = 0
Error 0 1/Kv infinity
Type 2 system Step Input Ramp Input Parabolic Input
Steady-State Error Formula 1/(1+Kp) 1/Kv 1/Ka
Static Error Constant Kp = infinity Kv = infinity Ka = constant
Error 0 0 1/Ka

Example: Meeting steady-state error requirements

Consider a system of the form shown below.

For this example, let G(s) equal the following.

(7)$$G(s) = \frac{K(s+3)(s+5)}{s(s+7)(s+8)}$$

Since this system is type 1, there will be no steady-state error for a step input and there will be infinite error for a parabolic
input. The only input that will yield a finite steady-state error in this system is a ramp input. We wish to choose K such that the closed-loop system has a steady-state error of 0.1 in response to a ramp reference. Let’s first examine the
ramp input response for a gain of K = 1.

s = tf('s');
G = ((s+3)*(s+5))/(s*(s+7)*(s+8));
T = feedback(G,1);
t = 0:0.1:25;
u = t;
[y,t,x] = lsim(T,u,t);
plot(t,y,'y',t,u,'m')
xlabel('Time (sec)')
ylabel('Amplitude')
title('Input-purple, Output-yellow')

The steady-state error for this system is quite large, since we can see that at time 20 seconds the output is approximately
16 as compared to an input of 20 (steady-state error is approximately equal to 4). Let’s examine this in further detail.

We know from our problem statement that the steady-state error must be 0.1. Therefore, we can solve the problem following
these steps:

(8)$$e(\infty)=\frac{1}{K_{v}}=0.1$$

(9)$$K_{v}=10=\lim_{s\rightarrow0}sG(s)=\frac{15K}{56}$$

(10)$$\Rightarrow K=37.33$$

Let’s see the ramp input response for K = 37.33 by entering the following code in the MATLAB command window.

K = 37.33 ;
s = tf('s');
G = (K*(s+3)*(s+5))/(s*(s+7)*(s+8));
sysCL = feedback(G,1);
t = 0:0.1:50;
u = t;
[y,t,x] = lsim(sysCL,u,t);
plot(t,y,'y',t,u,'m')
xlabel('Time (sec)')
ylabel('Amplitude')
title('Input-purple, Output-yellow')

In order to get a better view, we must zoom in on the response. We choose to zoom in between time equals 39.9 and 40.1 seconds
because that will ensure that the system has reached steady state.

axis([39.9,40.1,39.9,40.1])

Examination of the above shows that the steady-state error is indeed 0.1 as desired.

Now let’s modify the problem a little bit and say that our system has the form shown below.

In essence we are not distinguishing between the controller and the plant in our feedback system. Now we want to achieve zero
steady-state error for a ramp input.

From our tables, we know that a system of type 2 gives us zero steady-state error for a ramp input. Therefore, we can get
zero steady-state error by simply adding an integrator (a pole at the origin). Let’s view the ramp input response for a step
input if we add an integrator and employ a gain K = 1.

s = tf('s');
P = ((s+3)*(s+5))/(s*(s+7)*(s+8));
C = 1/s;
sysCL = feedback(C*P,1);
t = 0:0.1:250;
u = t;
[y,t,x] = lsim(sysCL,u,t);
plot(t,y,'y',t,u,'m')
xlabel('Time (sec)')
ylabel('Amplitude')
title('Input-purple, Output-yellow')

As you can see, there is initially some oscillation (you may need to zoom in). However, at steady state we do have zero steady-state
error as desired. Let’s zoom in around 240 seconds (trust me, it doesn’t reach steady state until then).

axis([239.9,240.1,239.9,240.1])

As you can see, the steady-state error is zero. Feel free to zoom in on different areas of the graph to observe how the response
approaches steady state.

In this post I want to talk about the Final Value Theorem and steady state error because these concepts will be useful as we go on to discuss controller design in more detail. Steady state error describes how far the system deviates from the desired reference signal as time goes to infinity [1]. It is a commonly used performance metric for controller design, which is why I want to establish the concept now before we apply it in future posts on controller design [2]. I will start the discussion, though, with the Final Value Theorem because that concept is critical to understanding steady state error.

The Final Value Theorem is used to find the “final value” of a system as time goes to infinity. It is derived from the Laplace transform of the derivative, taken as time goes to infinity (or s goes to zero), as shown in the equation below [2]. Note that we can only use the Final Value Theorem if a system is stable, or at least has all its poles at the origin (and the left half plane). If the system is unstable or a non-decaying sinusoid, then the Final Value Theorem will produce results, but they will be meaningless because the system does not actually converge to zero [1],[2]. Don’t be fooled – always test for stability before using the Final Value Theorem!

Fig 1

Now that we have the Final Value Theorem equation, we can use it to find the steady state error. The formal definition of steady state error, according to Nise, is the difference between a reference signal and the corresponding output signal for a prescribed test input as time goes to infinity [2]. I italicized “for a prescribed test input” because this helps to understand the process we are going to use. We are going to take the transfer function of the error of a system and apply a test input to that transfer function. The test input can be a step input (corresponds to a position command), a ramp input (corresponds to a velocity command) or a parabolic input (corresponds to an acceleration command) [1], [2]. The error transfer function will describe how the system error responds to that input, and we can use the Final Value Theorem to see how the error will respond in the long-term. This is shown in Equation 2 below.

Fig 2

Note that for unity feedback, you can also write the error as the ratio between the reference signal and the forward transfer function, G(s) [2]. This is shown in Equation 3 below. This form will be helpful in the next step of our discussion.

Fig 3

If we substitute the test input for R(s) and solve the Final Value Theorem for our system, we can get 3 possible types of steady state errors:

(1) Zero error: this means that the system is capable of eliminating all steady state error. In order to do this the system must have at least one pole at the origin (an integrator).
(2) Finite error: this means that the system is capable of reaching steady state given this input, but it does not have enough integrators to eliminate all of the error produced by following the test signal.
(3) Infinite error: this means that the system cannot track this reference signal at all.

The results of the steady state error equation can also be used to help us determine the system “Type”. The system type is a number corresponding to the number of integrators it possesses [1]. For example, if a system is Type 0, it does not have any integrators. It can only track a step input, but even with that input it will have some finite steady state error because it has no integrators with which to eliminate that error. Conversely, a Type 1 system has 1 integrator and it can track a step input with zero error and a ramp input with finite error [1], [2].

What if you want to find the steady state error contribution from a disturbance input? I have shown the block diagram for a disturbance input and the derivation of the equation for steady state error in the figure below. Notice that I went back to the fundamentals shown in Equation 1 to get the equation for steady state error as a function of contributions from both the reference signal and the disturbance signal.

Fig 4
Figure 1

We also made an important assumption in our discussion up to this point: we assumed that we had unity feedback because it simplified the math. However, we often have non-unity feedback because sensor noise and system dynamics can contribute to the feedback path of our system. In these cases, it is helpful to apply the trick demonstrated below to re-draw the block diagram as a unity feedback system. I have worked out some of the math alongside the diagrams.

Fig 5
Figure 2

Now that we have this concept in hand, next time we will work through an example of the design process to meet steady state and transient performance requirements using root locus plots.

References

[1] Douglas, Brian. “Final Value Theorem and Steady State Error.” https://www.youtube.com/watch?v=PXxveGoNRUw&list=PLUMWjy5jgHK1NC52DXXrriwihVrYZKqjk&index=15 Viewed on 07/23/2019.

[2] Nise, Norman S. Control Systems Engineering, 4th Ed. John Wiley & Sons, Inc. 2004.

Steady state error (SSE) is a measure of how well a system tracks a reference input over time. It is equal to the difference between the desired output and the actual output, averaged over time. To calculate SSE, you need to know the system’s transfer function and the reference input.

The transfer function is a mathematical description of the system’s behavior. It can be obtained from a system’s specifications or from experimental data. The reference input is the desired value of the output.

SSE can be used to identify problems with a system and to optimize its performance. It is especially useful for control systems, which are designed to track reference inputs.

There are several ways to calculate SSE. The most common method is the least squares method. Other methods include the Kalman filter and the Wiener filter.

The least squares method is a mathematical technique used to minimize the error between two sets of data. It is often used to calculate SSE.

The Kalman filter is a mathematical algorithm used to estimate the state of a system from noisy measurements. It can be used to calculate SSE.

The Wiener filter is a mathematical algorithm used to remove noise from data. It can be used to calculate SSE.

The most common way to reduce SSE is to improve the system’s transfer function. This can be done by redesigning the system or by adding feedback control.

SSE is a measure of how well a system tracks a reference input over time. It is equal to the difference between the desired output and the actual output, averaged over time.

The transfer function is a mathematical description of the system’s behavior. It can be obtained from a system’s specifications or from experimental data.

The reference input is the desired value of the output.

SSE can be used to identify problems with a system and to optimize its performance. It is especially useful for control systems, which are designed to track reference inputs.

SSE can be minimized by improving the system’s transfer function. This can be done by redesigning the system or by adding feedback control.

Contents

  • 1 How do you find the steady-state error?
  • 2 What is the steady-state error?
  • 3 What is the value of steady-state error?
  • 4 Is steady-state error a percentage?
  • 5 What is steady-state error in PID controller?
  • 6 How do you find the steady-state error in Matlab?
  • 7 What is steady-state response of a circuit?

How do you find the steady-state error?

In control systems theory, the steady-state error (SSE) is the error between the desired output of a system and the actual output, as a function of time, after the system has reached a steady state. In other words, it is the error in the output of a system that is caused by the system’s initial conditions and not by its dynamics. The steady-state error is usually a very important parameter in the design of a control system.

There are several ways to calculate the steady-state error of a system. One way is to use the Laplace transform of the system’s input and output signals. This transform allows you to find the poles and zeroes of a system’s transfer function, which can then be used to calculate the system’s steady-state error. Another way to calculate the steady-state error is to use the Nyquist criterion. This criterion allows you to find the system’s stability margins, which can then be used to calculate the system’s steady-state error.

What is the steady-state error?

The steady-state error is a measure of how close a system’s output is to its desired output. The steady-state error is determined by taking the difference between the system’s desired output and its actual output, and dividing that difference by the system’s gain. The steady-state error is always less than or equal to the system’s transient error.

What is the value of steady-state error?

The steady-state error (SSE) is the amount of error in a system’s output over time when the system is operating in a steady state. The SSE is usually expressed in terms of the system’s output error per unit of time. The SSE can be used to help determine how well a system is able to maintain a steady state.

There are several factors that can affect the SSE of a system. The most important factor is the type of system feedback loop used in the system. A system with a negative feedback loop will have a smaller SSE than a system with a positive feedback loop. Other factors that can affect the SSE include the type of system input, the type of system dynamics, and the system’s initial condition.

The SSE can be used to help design and tune a system. By understanding the factors that affect the SSE, engineers can design systems with smaller SSE values. The SSE can also be used to determine the stability of a system. A system with a small SSE is more likely to be stable than a system with a large SSE.

Is steady-state error a percentage?

Steady-state error is a measure of how accurately a system can reproduce a desired output over time. It is expressed as a percentage of the desired output.

To calculate the steady-state error, you need to know the desired output and the actual output of the system. You then subtract the desired output from the actual output and divide by the desired output. This gives you the error as a percentage.

For example, if you have a system that produces an output of 100 units, and you want it to produce a output of 105 units, the steady-state error would be 5%.

What is steady-state error in PID controller?

The steady-state error in a PID controller is the difference between the desired value and the actual value of the controlled variable at the point where the controller is in equilibrium. In other words, it’s the error that remains after the system has had time to settle down and reach a steady state.

The steady-state error is an important parameter that needs to be considered when tuning a PID controller. It can be used to determine how close the controller is to achieving the desired outcome, and it can also be used to troubleshoot problems with the system.

There are several factors that can affect the steady-state error in a PID controller. One of the most important is the type of system that is being controlled. Another important factor is the gain of the controller. The gain affects the speed at which the controller responds to changes in the input signal, and it can also affect the stability of the system.

The steady-state error can also be affected by the dynamics of the system. For example, if the system has a lot of inertia, it will take longer for the system to reach a steady state. This can cause the steady-state error to be larger than it would be if the system had less inertia.

The steady-state error can also be affected by the initial conditions of the system. If the system is not at equilibrium when the controller is activated, the steady-state error will be larger than it would be if the system was already at equilibrium.

The steady-state error is usually a small error that is caused by the system not reaching a stable equilibrium right away. However, it can sometimes be larger than the error that is caused by the actual fluctuations in the output signal. This can be a problem if the controller is trying to correct for the fluctuations in the output signal, and it can cause the controller to oscillate around the desired value.

The steady-state error can be reduced by increasing the gain of the controller, or by adding a filter to the system. The filter will help to remove the noise from the input signal, and it will also help to stabilize the system.

How do you find the steady-state error in Matlab?

The steady-state error is the error in a system’s output that remains constant over time. It is important to understand and calculate the steady-state error in order to properly design and test a system. In this article, we will show how to find the steady-state error in Matlab.

First, we need to define the system’s transfer function. This can be done using the tf command. For example, the transfer function for a simple spring-mass system can be written as:

[s,y] = tf(1,1)

This function defines a linear time-invariant system with a unit gain. The input (s) is the angular frequency and the output (y) is the displacement of the mass.

Next, we need to calculate the system’s characteristic equation. This can be done using the roots command. For example, the roots of the transfer function above can be calculated as:

roots([1 1])

This returns the two roots of the equation: 1 and -1.

Now, we can use the steady-state error equation to calculate the steady-state error. The equation is:

es = eo / (1 + k * es)

where:

es = the steady-state error

eo = the desired output

k = the gain of the system

We can calculate the steady-state error for our example system using the equation above. For a frequency of 1 rad/s, the steady-state error would be:

es = eo / (1 + k * es)

es = 0.5 / (1 + 1 * es)

es = 0.5 / 2

This means that the steady-state error for this system is 0.5.

We can also graph the system’s response using the plot command. For example, the plot below shows the displacement of the mass as a function of time. The solid line shows the actual output and the dashed line shows the desired output.

We can see that the system is responding as expected and that the steady-state error is 0.5.

What is steady-state response of a circuit?

What is Steady-State Response of a Circuit?

The steady-state response of a circuit is the response of the circuit when it has reached a steady state. This is the point at which the input and output voltages are no longer changing. The steady-state response of a circuit is determined by the characteristics of the circuit elements and the input signal.

The steady-state response of a circuit can be analyzed using the response of the individual circuit elements. The resistor, capacitor, and inductor all have different responses to a changing signal. The resistor has a linear response, meaning that the voltage across the resistor is directly proportional to the current through the resistor. The capacitor has a linear response up to a certain point, and then the response becomes exponential. The inductor has an exponential response.

The steady-state response of a circuit can also be analyzed using the Fourier series. This analysis takes into account the frequency of the input signal.

The deviation of the output of control system from desired response during steady state is known as steady state error. It is represented as ess. … Example.

Input signal Error constant Steady state error
r2(t)=2tu(t) Kv=lims→0sG(s)=∞ ess2=2Kv=0
r3(t)=t22u(t) Ka=lims→0s2G(s)=1 ess3=1ka=1

The steady-state gain of a loop can be computed by substituting s=0 into a closed-loop transfer function. 3. Steady-state output is gain x steady state input.

How do you calculate steady-state error for unit step input?

How do you calculate steady-state error on a graph?

Direct link to this answer

  1. SP=5; %input value, if you put 1 then is the same as step(sys)
  2. [y,t]=step(SP*sys); %get the response of the system to a step with amplitude SP.
  3. sserror=abs(SP-y(end)) %get the steady state error.

How do you calculate steady state error in Bode plot?

What is KV in control system?

These constants are the position constant (Kp), the velocity constant (Kv), and the acceleration constant (Ka). Knowing the value of these constants, as well as the system type, we can predict if our system is going to have a finite steady-state error.

What is steady state error?

Steady-state error is defined as the difference between the input (command) and the output of a system in the limit as time goes to infinity (i.e. when the response has reached steady state). The steady-state error will depend on the type of input (step, ramp, etc.) as well as the system type (0, I, or II).

How does Matlab calculate steady state error?

Direct link to this answer

  1. SP=5; %input value, if you put 1 then is the same as step(sys)
  2. [y,t]=step(SP*sys); %get the response of the system to a step with amplitude SP.
  3. sserror=abs(SP-y(end)) %get the steady state error.

How do you calculate steady state time?

The time to reach steady state is defined by the elimination half-life of the drug. After 1 half-life, you will have reached 50% of steady state. After 2 half-lives, you will have reached 75% of steady state, and after 3 half-lives you will have reached 87.5% of steady state.

What is steady state error in PID controller?

Steady-State error is the final difference between the process variable and set point. A phenomenon called integral windup results when integral action saturates a controller without the controller driving the error signal toward zero. Derivative Response.

Is steady state error a percentage?

The steady state error for a step response is often reported as a percentage of the input magnitude, similar to the overshoot . Steady state error can also be defined for other types of signals, such as ramps, as long as the error converges to a constant.

How do you calculate steady-state offset?

How does Matlab calculate steady-state?

Finding Steady-State Points

  1. You can use the trim function to find the values of the input and the states that set both outputs to 1. …
  2. x = [0; 0; 0]; u = 0; y = [1; 1]; …
  3. ix = []; % Don’t fix any of the states iu = []; % Don’t fix the input iy = [1;2]; % Fix both output 1 and output 2.

What is the value of steady state error in closed loop system?

It can be seen that in steady-state, the output is exactly equal to the input. Hence the steady-state error is zero. The response of this function to a unit ramp input is shown in Figure-2. It can be seen that in steady-state there is a difference between input and output.

How do you find the stability of a Bode plot?

Bode Plot Stability

  1. Gain Margin: Greater will the gain margin greater will be the stability of the system. …
  2. Phase Margin: Greater will the phase margin greater will be the stability of the system. …
  3. Gain Crossover Frequency: It refers to the frequency at which the magnitude curve cuts the zero dB axis in the bode plot.

How do you calculate static gain?

The number G(0) is called the static gain of the system because it tells the ratio of the output and the input under steady state condition. If the input is constant u = u0 and the system is stable then the output will reach the steady state value y0 = G(0)u0.

How do you calculate crossover frequency?

The gain margin is defined as the reciprocal of the magnitude |G(jω)| at the frequency at which the phase angle is −180°. Defining the phase crossover frequency ω1 to be the frequency at which the phase angle of the open-loop transfer function equals −180° gives the gain margin Kg:K g = 1 | G ( j ω 1 ) | .

How do I get rid of steady state error?

This shows that the steady state error can be reduced by increasing the gain. However, to achieve zero steady-state error, the gain would have to approach infinity. Therefore, for a first order system, a proportional controller cannot be used to eliminate the step response steady state error.

How do you find the steady state error for a ramp input?

Steady-State Error to Ramp Input Assuming that the feedback loop contains an integrator, so that the steady-state error to a step input is zero, the steady-state error to a ramp input is expressed as: e(s)=[1−T(s)]r(s);r(s)=1s2.

How can the steady state error can be reduced Mcq?

Explanation: The integrator is similar to the phase lag systems and it is used to reduce or eliminate the steady state error and when it is cascaded with the ramp input.

What is the steady-state value?

If your input is the unit step function, then the gain is the system’s value at steady state, t=∞. The steady state value is also called the final value. So if your transfer function is H(z)=Y(z)X(z)=.

How do you calculate DC gain in Matlab?

Compute the DC Gain of a MIMO Transfer Function H = [1 tf([1 -1],[1 1 3]) ; tf(1,[1 1]) tf([1 2],[1 -3])]; Compute the DC gain of the transfer function. For continuous-time models, the DC gain is the transfer function value at the frequency s = 0 . The DC gain for each input-output pair is returned.

What is steady state equation?

A steady state for a differential equation is a solution where the value of y does not change over time. For example, consider an economy with capital and depriciation.

How do you calculate steady state concentration from Half Life?

Consequently, the half-life represents the time required to reduce the plasma concentration of the drug reached in steady-state by 50%. The half-life can be calculated with the following formula: t 1/2 = 0,693•Vd/CL.

How does PK calculate MRT?

The MRT is calculated by summing the total time in the body and dividing by the number of molecules, which is turns out to be 85.6 minutes.

Graduated from ENSAT (national agronomic school of Toulouse) in plant sciences in 2018, I pursued a CIFRE doctorate under contract with Sun’Agri and INRAE ​​in Avignon between 2019 and 2022. My thesis aimed to study dynamic agrivoltaic systems, in my case in arboriculture. I love to write and share science related Stuff Here on my Website. I am currently continuing at Sun’Agri as an R&D engineer.

A steady-state error is defined as the difference between the desired value and the actual value of a system when the response has reached the steady state.

From: Electric Motor Control, 2017

System Response

William Bolton, in Instrumentation and Control Systems (Third Edition), 2021

10.7 Steady-State Error

The term steady-state error is used for the error that occurs between the set input to a control system and its output after it has settled down to its steady value (see Section 5.3.2 for a preliminary discussion of the issue). The steady-state error is a measure of the accuracy a control system has in tracking a command input. While steady-state errors can arise from non-linear behaviour of control system elements, the steady-state errors to be discussed in this section arise from the configuration of the control system. The steady-state error can be obtained using the Laplace final value theorem (see Appendix C2.2). Ideally, there should be no error and the output response should be the value the control system input was set to.

A closed-loop control system with unity feedback (Figure 10.16) has an overall transfer function (see Section 9.3.2) and error e is given by:

Figure 10.16. Unity feedback control system.

Overall transfer function=Y(s)X(s)=G(s)1+KG(s)

E(s)=X(s)−Y(s)

Hence,

E(s)=X(s)−G(s)X(s)1+KG(s)=11+KG(s)X(s)

The steady-state error is the error as e(t) tends to infinity and is given by the final value theorem as:

Steady−state error=lims→0sE(s)

Steady−state error=lims→0s11+KG(s)X(s)

When considering control systems and their steady-state errors there are three main forms of input – step, ramp and parabola. For a unit step we have x(t)=1(t) and hence X(s)=1/s, this representing a constant position for a positioning system. For a unit ramp we have x(t)=t(t) and hence X(s)=1/s2, this representing a constant velocity for a positioning system. For a unit parabola we have x(t)=1/2t2(t) and hence X(s)=1/s3, this representing a constant acceleration for a positioning system.

If we have a unit step input to the unity-feedback system, then X(s)=1/s and so:

Steady−state error=lims→0s11+KG(s)1s=lims→011+KG(s)

Thus, there will be a steady-state error. With proportional control we always have a steady-state error, regardless of the type of input involved. As an illustration, consider a unity feedback system with a plant of G(s)=1/(s+1) and a proportional controller of K=10. If we have a step input of size 2 units, then we have:

Steady−state error=2lims→011+KG(s)=2lims→011+10×(1/(s+1))=211=0.18

If, however, we replace the proportional controller in the unity feedback system by an integral controller K/s then:

Overall transfer function=Y(s)X(s)=(K/s)G(s)1+(K/s)G(s)=KG(s)s+KG(s)

E(s)=X(s)−KG(s)X(s)s+KG(s)=ss+KG(s)X(s)

and so:

Steady−state error=lims→0sE(s)

Steady−state error=lims→0s21s+KG(s)X(s)

Thus, with a step input:

Steady−state error=lims→0s21s+KG(s)1s=0

and thus, no steady-state error when the controller is an integral one and the input is a step (Figure 10.17A). If, however, the input had been a ramp x(t)=1t then X(s)=1/s2 and the steady-state error becomes:

Figure 10.17. Steady-state error with an integral controller and input (A) a step, (B) a ramp.

Steady−state error=lims→0s11+KG(s)X(s)=lims→0s11+KG(s)1s2

The steady-state error thus becomes infinity.

There is thus a steady-state error with a ramp input to an integral controller system (Figure 10.17B). In general, the steady-state error will be zero if there is at least one pure integrator in the forward path of a unity feedback control system with a step input, but a different form of input will give an error.

If, however, the input to an integral controller system had been a parabola x(t)=1/2t2(t), then X(s)=1/s3 and the steady-state error becomes:

Steady−state error=lims→0s11+KG(s)X(s)=lims→0s11+KG(s)1s3

The steady-state error thus becomes infinity.

For a unity negative feedback system, the steady-state error depends upon the number of integrations in the forward path, i.e. the number of 1/s terms. The number of such terms is termed the system type. Thus, type 0 has zero integrators in the forward path, type 1 has one integrator, type 2 has two integrators. Thus, for example, a system with a forward path transfer function of 10/(s+2)(s2+3s+6) is type 0 since there is no 1/s term. A forward path transfer function of 1/s(s+5) is type 1 since there is one 1/s term. A forward path transfer function of 1/s2(s2+3s+1) is type 2 since there are two 1/s terms.

The steady-state error not only depends upon the number of integrations in the forward path but also the type of input used. Type 0 system gives an error with a step input and an infinite error with a ramp or a parabolic input. Type 1 system gives no error with a step input, a constant error with a ramp and an infinite error with a parabolic input; type 2 system a zero error with a step or ramp input but an error with a parabolic input

Example

A unity feedback system has a forward path transfer function of:

G(s)=50(s+2)(s+3)(s+8)

Will there be a steady-state error for (1) a step input, (2) a ramp input?

As there is no 1/s term the system is type 0 and so there will be a steady-state error for a step input but an infinite error for a ramp or parabolic input.

Example

A unity feedback system has an integral controller with transfer function K/s and a plant with transfer function (s+2)/(s+1)(s+3). If it is subject to a unit ramp input, what will be the steady-state error?

Using the equation derived above:

Steady−state error=lims→01KG(s)=lims→01K((s+2)/((s+1)(s+3)))=32K

Thus, if we wanted the controller to have K=30 then the error would be 0.05.

Read full chapter

URL: 

https://www.sciencedirect.com/science/article/pii/B9780128234716000101

Control of direct current motors

Sang-Hoon Kim, in Electric Motor Control, 2017

2.5.3.3 Steady-state error

A steady-state error is defined as the difference between the desired value and the actual value of a system when the response has reached the steady state. We can calculate the steady-state error of the system using the final value theorem. This theorem is given for the unit feedback system in Fig. 2.28 as

Figure 2.28. Unit feedback system.

(2.21)Finalvaluetheorem:e∞=limt→∞e(t)=lims→0sE(s)=lims→0s1+G(s)R(s)

(Error:E(s)=R(s)−Y(s)=R(s)1+G(s))

As an example, let us evaluate the steady-state error for a step input command in the control system for a DC motor, where the speed or current command is generally given as a step signal. Assume that the control system for the DC motor is a unit feedback system as in Fig. 2.28, and the transfer function of the current control system is G(s). For the unit step input (r(t)=1→R(s)=1/s) to this system, the steady-state error is given from the final value theorem by

(2.22)e∞=lims→0s1+G(s)R(s)=lims→0s1+G(s)1s=lims→011+G(s)

The steady-state error depends on the system type (0, I, or II).

First, suppose a control system of type 0 expressed as G(s)=K/(Ts+1). In this system the steady-state error is given as

(2.23)e∞=11+G(0)=11+K

The magnitude of the error depends on the system gain K and will be never zero.

Next, suppose a type I system of G(s)=K/s(Ts+1). This control system has no steady-state error as

(2.24)e∞=11+G(0)=11+∞=0

From this, it can be seen that if a control system includes an integrator 1/s, then the steady-state error to a step reference will be zero.

Read full chapter

URL: 

https://www.sciencedirect.com/science/article/pii/B9780128121382000027

ASCE Test Cases

Enrique Bonet Gil, in Experimental Design and Verification of a Centralized Controller for Irrigation Canals, 2018

10.6.3 Steady-state error (StE)

The steady-state error is defined as the maximum of the average error over the last two hours of the test. The conclusion is that the conditions should be stable during this period of time:

[10.5]StE=maxy22,24−ytargetytarget

where y22,24 is the average water level between 10 and 12 hours. Some control algorithms have not performed well due to constant oscillation around the sluice gate trajectory solution. This indicator is proposed in order to detect excessive oscillations in water levels at the end of the test.

Read full chapter

URL: 

https://www.sciencedirect.com/science/article/pii/B9781785483073500100

Time- and Frequency-Domain Controls of Feedback Systems

Nicolae Lobontiu, in System Dynamics for Engineering Students (Second Edition), 2018

Nonunity-Feedback Systems

The steady-state error of a SISO nonunity-feedback system is expressed in Eq. (13.23). Consider the more complex system of Figure 11.13, which uses a prefilter G1(s), a feed-forward transfer function G2(s), and a feedback transfer function G3(s). Such a system can equivalently be transformed into a standard unity-feedback system, whose feed-forward transfer function is obtained from the prefilter transfer function G1(s), and the functions G(s) = G2(s) and H(s) = G3(s) as in Eq. (11.21) of Example 11.2, which is rewritten here:

(13.32)G∗s=G1s·Gs1+Gs·Hs−G1s·Gs→G1(s)=1G∗s=Gs1+Gs·Hs−Gs

The last form of Eq. (13.32) gives the feed-forward transfer function of a unity-feedback system that is equivalent to the nonunity-feedback control system without prefilter. The steady-state error can now be calculated with Eq. (13.32), or by using Tables 13.1 and/or 13.2.

Example 13.3

Find the open-loop transfer function of a unity-feedback system without prefilter that is equivalent to the feedback system whose block diagram is illustrated in Figure 13.8. Calculate the steady-state error corresponding to r(t) = 1.

Figure 13.8. Block Diagram of a Nonunity-Feedback Control System With Prefilter.

Solution

Taking into consideration that G1(s) = 10, G(s) = 1/(s2 + 2s + 100), and H(s) = 1/(s + 200), the feed-forward transfer function of the unity-feedback system without prefilter that is equivalent to the system of Figure 13.8 is calculated by means of Eq. (13.32):

(13.33)G∗(s)=10s+2000s3+202s2+490s+18001

The closed-loop transfer function is therefore:

(13.34)GCL(s)=G∗(s)1+G∗(s)=10s+2000s3+202s2+500s+20001

whose poles are: −200 and −1 ± 9.95·j. They are all located in the LHP, and therefore the feedback system is stable. The denominator of G(s) from Eq. (13.33) does not have any integrator, and the unity-feedback system is consequently a zero-type system. The corresponding static error constant and steady-state error are:

(13.35)Kp=lims→0G∗(s)=0.111;e(∞)=11+Kp=0.9

Read full chapter

URL: 

https://www.sciencedirect.com/science/article/pii/B9780128045596000130

Reactor control

Thomas W. Kerlin, Belle R. Upadhyaya, in Dynamics and Control of Nuclear Reactors, 2019

8.3.7.1 Proportional controller

In this type of controller, the control action is proportional to the error. Thus,

Gcs=Kp,Kp>0andFs=KpEs

As shown in Appendix D, Section D.5, the closed-loop transfer function is.

(8.7)YsXs=GcsGps1+GcsGps

For our example, Eq. (8.7) becomes

(8.8)YsXs=Kps+a+Kp,Kp>0

The Laplace transform of the error, e(t), is given by (See Section 3.7).

(8.9)Es=Xs1+GcsGps

For our example, E(s) becomes.

(8.10)Es=s+aXss+a+Kp

For a unit step input, X(s) = 1/s, and

Es=s+ass+a+Kp

The final, steady-state value of the error, e(t), when x(t) is a unit step, is given by.

(8.11)et=lims→0sEs=aa+Kp

Note that the steady-state error is not equal to zero, and may be decreased by increasing Kp, the proportional gain. For a = 0.02 and Kp = 1, the steady-state error is e(∞) = 1/51 = 0.0196. If Kp is increased to 10, then the steady-state error is e(∞) = 0.002.

Remarks

1.

As the proportional gain constant Kp increases, the steady-state error decreases. However, the steady-state error is never zero.

2.

As the gain Kp increases, the time constant of the system decreases, and the rate of system response increases. For the open-loop system in the above example (a = 0.02), the time constant, τ = 50 s. For the closed-loop system with a proportional gain Kp, the time constant is given by

(8.12)τ=1a+Kp

Thus, for Kp = 0.1, the time constant decreases to τ = 8.33 s.

3.

An increased Kp results in a faster response of the control system. Since there are limitations on the achievable responses of control devices, Kp should not be increased arbitrarily. Furthermore, an increase in Kp above a certain value can make the system unstable. The stability margin will decrease with increasing values of Kp.

All these points must be considered in choosing the proportional gain. The proportional controller increases the speed of response of a system. The steady-state error is nonzero.

Read full chapter

URL: 

https://www.sciencedirect.com/science/article/pii/B9780128152614000081

State Feedback Control

M. Sami Fadali, Antonio Visioli, in Digital Control Engineering (Second Edition), 2013

9.3 Servo problem

The schemes shown in Figures 9.1 and 9.2 are regulators that drive the system state to zero starting from any initial condition capable of rejecting impulse disturbances. In practice, it is often necessary to track a constant reference input r with zero steady-state error. For this purpose, a possible approach is to use the two degree-of-freedom control scheme in Figure 9.7, so called because we now have two matrices to select: the feedback gain matrix K and the reference gain matrix F.

Figure 9.7. Block diagram of the two degree-of-freedom controller.

The reference input of (9.2) becomes v(k)=Fr(k), and the control law is chosen as

(9.25)u(k)=−Kx(k)+Fr(k)

with r(k) the reference input to be tracked. The corresponding closed-loop system equations are

(9.26)x(k+1)=Aclx(k)+BFr(k)y(k)=Cx(k)

where the closed-loop state matrix is

Acl=A−BK

The z-transform of the corresponding output is given by (see Section 7.8)

Y(z)=C[zIn−Acl]−1BFR(z)

The steady-state tracking error for a unit step input is given by

Limz→1(z−1){Y(z)−R(z)}=Limz→1{C[zIn−Acl]−1BF−I}=C[In−Acl]−1BF−I

For zero steady-state error, we require the condition

(9.27)C[In−Acl]−1BF=In

If the system is square (m=l) and Acl is stable (no unity eigenvalues), we solve for the reference gain

(9.28)F=[C(In−Acl)−1B]−1

Example 9.6

Design a state–space controller for the discretized state–space model of the DC motor speed control system described in Example 6.9 (with T=0.02) to obtain zero steady-state error due to a unit step, a damping ratio of 0.7, and a settling time of about 1 s.

Solution

The discretized transfer function of the system with digital-to-analog converter (DAC) and analog-to-digital converter (ADC) is

GZAS(z)=(1−z−1)Z{G(s)s}=1.8604×10−4z+0.9293(z−0.8187)(z−0.9802)

The corresponding state–space model, computed with MATLAB, is

[x1(k+1)x2(k+1)]=[1.799−0.802510][x1(k)x2(k)]+[0.015630]u(k)

y(k)=[0.011910.01107][x1(k)x2(k)]

The desired eigenvalues of the closed-loop system are selected as {0.9±j0.09}, as in Example 6.9. This yields the feedback gain vector

K=[−0.0685170.997197]

and the closed-loop state matrix

Acl=[1.8−0.818110]

The feedforward gain is

F=[C(In−Acl)−1B]−1=[[0.011910.01107]([1001]−[1.8−0.818110])−1[0.015630]]−1=50.42666

The response of the system to a step reference input r is shown in Figure 9.8. The system has a settling time of about 0.84

 

s and percentage overshoot of about 4%, with a peak time of about 1

 

s. All design specifications are met.

Figure 9.8. Step response of the closed-loop system of Example 9.6.

The control law (9.25) is equivalent to a feedforward action determined by F to yield zero steady-state error for a constant reference input r. Because the forward action does not include any form of feedback, this approach is not robust to modeling uncertainties. Thus, modeling errors (which always occur in practice) will result in nonzero steady-state error. To eliminate such errors, we introduce the integral control shown in Figure 9.9, with a new state added for each control error integrated.

Figure 9.9. Control scheme with integral control.

The resulting state–space equations are

(9.29)x(k+1)=Ax(k)+Bu(k)x¯(k+1)=x¯(k)+r(k)−y(k)y(k)=Cx(k)u(k)=−Kx(k)−K¯x¯(k)

where is l×1. The state–space equations can be combined and rewritten in terms of an augmented state vector xa(k)=[x(k)x¯(k)]T as

[x(k+1)x¯(k+1)]=[A0−CIl][x(k)x¯(k)]−[B0][KK¯][x(k)x¯(k)]+[0Il]r(k)

y(k)=[C0][x(k+1)x¯(k+1)]

That is,

(9.30)xa(k+1)=(A˜−B˜K˜)xa(k)+[0Il]r(k)y(k)=[C0]xa(k)

where

(9.31)A˜=[A0−CIl]B˜=[B0]K˜=[KK¯]

It can be shown that the system of (9.31) is controllable if and only if the original system is controllable. The eigenvalues of the closed-loop system state matrix Acl=(A˜−B˜K˜) can be arbitrarily assigned by computing the gain matrix using any of the procedures for the regulator problem as described in Section 9.2.

Example 9.7

Solve the design problem presented in Example 9.6 using integral control.

Solution

The state–space matrices of the system are

A=[1.799−0.802510]B=[0.015630]

C=[0.011910.01107]

Adding integral control, we obtain

A˜=[A0−C1]=[1.799−0.80250100−0.01191−0.011071]B˜=[B0]=[0.0156300]

In Example 9.6, the eigenvalues were selected as {0.9±j0.09}. Using integral control increases the order of the system by one, and an additional eigenvalue must be selected. The desired eigenvalues are selected as {0.9±j0.09, 0.2}, and the additional eigenvalue at 0.2 is chosen for its negligible effect on the overall dynamics. This yields the feedback gain vector

K˜=[51.1315−40.4431−40.3413]

The closed-loop system state matrix is

Acl=[1−0.17060.6303100−0.0119−0.01111]

The response of the system to a unit step reference signal r is shown in Figure 9.10. The figure shows that the control specifications are satisfied. The settling time of 0.87 is well below the specified value of 1 s, and the percentage overshoot is about 4.2%, which is less than the value corresponding to ζ=0.7 for the dominant pair.

Figure 9.10. Step response of the closed-loop system of Example 9.7.

Read full chapter

URL: 

https://www.sciencedirect.com/science/article/pii/B9780123943910000095

State feedback control

M. Sami Fadali, Antonio Visioli, in Digital Control Engineering (Third Edition), 2020

9.7 Pole assignment using transfer functions

The pole assignment problem can be solved in the framework of transfer functions. Consider the state–space equations of the two-degree-of-freedom controller shown in Fig. 9.7 with the state vector estimated using a full-order observer. For a SISO plant with observer state feedback, we have

xˆ(k+1)=Axˆ(k)+Bu(k)+L(y(k)−Cxˆ(k))u(k)=−Kxˆ(k)+Fr(k)

or equivalently,

xˆ(k+1)=(A−BK−LC)xˆ(k)+[BFL][r(k)y(k)]u(k)=−Kxˆ(k)+Fr(k)

The corresponding z-transfer function from [r, y] to is

Xˆ(z)=(zI−A+BK+LC)−1[BFL][R(z)Y(z)]

The transfer function from [r,y] to u is

U(z)=[−K(zI−A+BK+LC)−1BF+F]R(z)−[K(zI−A+BK+LC)−1L]Y(z)

Thus, the full-order observer state feedback is equivalent to the transfer function model depicted in Fig. 9.18 with

Figure 9.18. Block diagram for pole assignment with transfer functions.

U(z)=Gf(z)R(z)−H(z)Y(z)

where

H(z)=S(z)D(z)

is the feedback gain with

H(z)=K(zI−A+BK+LC)−1L

and

Gf(z)=N(z)D(z)=−K(zI−A+BK+LC)−1BF+F

is the prefilter gain.

The plant transfer function G(z) = P(z)/Q(z) is assumed strictly realizable; that is, the degree of P(z) is less than the degree of Q(z). We also assume that P(z) and Q(z) are coprime (i.e., they have no common factors). Further, it is assumed that Q(z) is monic, that is, the coefficient of the term with the highest power in z is one.

From the block diagram of Fig. 9.18, simple block diagram manipulations give the closed-loop transfer function

Y(z)R(z)=G(z)1+G(z)H(z)Gf(z)=P(z)N(z)Q(z)D(z)+P(z)S(z)

and the polynomial equation

(9.68)(Q(z)D(z)+P(z)S(z))Y(z)=P(z)N(z)R(z)

Therefore, the closed-loop characteristic polynomial is

(9.69)Δcl(z)=Q(z)D(z)+P(z)S(z)

The pole placement problem thus reduces to finding polynomials D(z) and S(z) that satisfy Eq. (9.69) for given P(z), Q(z), and for a given desired characteristic polynomial Δcl(z). Eq. (9.69) is called a Diophantine equation, and its solution can be found by first expanding its RHS terms as

P(z)=pn−1zn−1+pn−2zn−2+…+p1z+p0

Q(z)=zn+qn−1zn−1+…+q1z+q0

D(z)=dmzm+dm−1zm−1+…+d1z+d0

S(z)=smzm+sm−1zm−1+…+s1z+s0

The closed-loop characteristic polynomial Δcl(z), which can be obtained from the desired pole locations, is of degree n + m and has the form

Δcl(z)=zn+m+δn+m−1zn+m−1+…+δ1z+δ0

Thus, Eq. (9.69) can be rewritten as

(9.70)zn+m+δn+m−1zn+m−1+···+δ1z+δ0=(zn−qn−1zn−1+···+q1z+q0)(dmzm+dm−1zm−1+···+d1z+d0)+(pn−1zn−1+pn−2zn−2+···+p1z+p0)(smzm+sm−1zm−1+···+s1z+s0)

Eq. (9.70) is linear in the 2m unknowns di and si, i = 0, 1, 2, …, m−1, and its LHS is a known polynomial with n + m−1 coefficients. The solution of the Diophantine equation is unique if n + m−1 = 2m—that is, if m = n−1. Eq. (9.70) can be written in the matrix form

(9.71)[100…000…0qn−110…0pn−10…0qn−2qn−11…0pn−2pn−1…0⋮⋮⋮⋮⋮⋮⋮q0q1q2…qn−1p0p1…pn−10q0q1…qn−20p0…pn−200q0…qn−300…pn−3⋮⋮⋮⋮⋮⋮⋮000…q000…p0][dmdm−1dm−2⋮d0smsm−1⋮s0]=[1δsn−2δ2n−3⋮δn−1δn−2δn−3⋮δ0]

It can be shown that the matrix on the LHS is nonsingular if and only if the polynomials P(z) and Q(z) are coprime, which we assume. As discussed in Section 9.2.3, the matrix must have a small condition number for the system to be robust with respect to errors in the known parameters. The condition number becomes larger as the matrix becomes almost singular.

The structure of the matrix shows that it will be almost singular if the coefficients of the numerator polynomial P(z) and denominator polynomial Q(z) are almost identical. We therefore require that the roots of the polynomials P(z) and Q(z) be sufficiently different to avoid an ill-conditioned matrix. From the discussion of pole-zero matching of Section 6.3.2, it can be deduced that the poles of the discretized plant approach the zeros as the sampling interval is reduced (see also Section 12.2.2). Thus, when the controller is designed by pole assignment, the sampling interval must not be excessively short to avoid an ill-conditioned matrix in Eq. (9.71).

We now discuss the choice of the desired characteristic polynomial. From the equivalence of the transfer function design to the state–space design described in Section 9.6, the separation principle implies that Δcld(z) can be written as the product

Δcld(z)=Δcd(z)Δod(z)

where Δcd(z) is the controller characteristic polynomial and Δod(z) is the observer characteristic polynomial. We select the polynomial N(z) as

(9.72)N(z)=kffΔod(z)

so that the observer polynomial Δod(z) cancels in the transfer function from the reference input to the system output. The scalar constant kff is selected so that the steady-state output is equal to the constant reference input

Y(1)R(1)=P(1)N(1)Δcd(1)Δod(1)=P(1)kffΔod(1)Δcd(1)Δod(1)=1

The condition for zero steady-state error is

(9.73)kff=Δcd(1)P(1)

Example 9.15

Solve Example 9.14 using the transfer function approach.

Solution

The plant transfer function is

G(z)=P(z)Q(z)=10−61.622z2+45.14z+48.23z3−2.895z2+2.791z−0.8959

Thus, we have the polynomials

P(z)=1.622×10−6z2+45.14×10−6z+48.23×10−6

with coefficients

p2=1.622×10−6,p1=45.14×10−6,p0=48.23×10−6

Q(z)=z3−2.895z2+2.791z−0.8959

with coefficients

q2=−2.895,q1=2.791,q0=−0.8959

The plant is third order—that is, n = 3—and the solvability condition of the Diophantine equation is m = n−1 = 2. The order of the desired closed-loop characteristic polynomial is m + n = 5. We can therefore select the controller poles as {0.6, 0.4 ± j0.33} and the observer poles as {0.1, 0.2} with the corresponding polynomials

Δcd(z)=z3−1.6z2+0.9489z−0.18756

Δod(z)=z2−0.3z+0.02

Δcld(z)=Δcd(z)Δod(z)=z5−1.9z4+1.4489z3−0.50423z2+0.075246z−0.0037512

In other words, δ4 = −1.9, δ3 = 1.4489, δ2 = −0.50423, δ1 = 0.075246, and δ0 = −0.0037512.

Using the matrix Eq. (9.71) gives

[100000−2.8949101.622×10−6002.790752−2.8949145.14×10−61.622×10−60−0.8958522.790752−2.894948.23×10−645.14×10−61.622×10−60−0.8958522.790752048.23×10−645.14×10−600−0.8958520048.23×10−6][d2d1d0s2s1s0]=[1−1.91.4489−0.504230.075246−0.00375]

The MATLAB command linsolve gives the solution

d2=1,d1=0.9645,d0=0.6526,s2=1.8735⋅104,s1=−2.9556⋅104,s0=1.2044⋅104

and the polynomials

D(z)=z2+0.9645z+0.6526

S(z)=1.8735⋅104z2−2.9556⋅104z+1.2044⋅104

Then, from Eq. (9.72), we have kff = 1698.489 and the numerator polynomial

N(z)=1698.489(z2−0.3z+0.02)

The step response of the control system of Fig. 9.19 has a settling time of 0.1 s and a percentage overshoot of less than 7%. The response meets all the design specifications.

Figure 9.19. Step response for Example 9.15.

Read full chapter

URL: 

https://www.sciencedirect.com/science/article/pii/B9780128144336000090

Process controllers

W. Bolton, in Instrumentation and Control Systems, 2004

5.3.2 Limitations of proportional control

Proportional controllers have limitations. Consider the above example in Figure 5.8 of the amplifier as the proportional controller. Initially, take the temperature of the liquid in the bath to be at the set value. There is then no error signal and consequently no current to the heating element. Now suppose the temperature of the inflowing liquid changes to a constant lower value (Figure 5.12). The temperature sensor will, after a time lag, indicate a temperature value which differs from the set value. The greater the mass of the liquid in the tank, i.e. the capacitance, the longer will be the time taken for the sensor to react to the change. This is because it will take longer for the colder liquid to have mixed with the liquid in the tank and reached the sensor. The differential amplifier will then give an error signal and the power amplifier a signal to the heater which is proportional to the error. The current to the heater will be proportional to the error, the constant of proportionality being the gain of the amplifier. The higher the gain the larger will be the current to the heater for a particular error and thus the faster the system will respond to the temperature change. As indicated in Figure 5.12, the inflow is constantly at this lower temperature. Thus, when steady state conditions prevail, we always need current passing through the heater. Thus there must be a continuing error signal and so the temperature can never quite be the set value. This error signal which persists under steady state conditions is termed the steady state error or the proportional offset. The higher the gain of the amplifier the lower will be the steady state error because the system reacts more quickly.

Figure 5.12. Inflow change

In the above example, we could have obtained the same type of response if, instead of changing the temperature of the input liquid, we had made a sudden change of the set value to a new constant value. There would need to be a steady state error or proportional offset from the original value. We can also obtain steady state errors in the case of a control system which has to, say, give an output of an output shaft rotating at a constant rate, the error results in a velocity-lag.

All proportional control systems have a steady state error. The proportional mode of control tends to be used in processes where the gain KP can be made large enough to reduce the steady state error to an acceptable level. However, the larger the gain the greater the chance of the system oscillating. The oscillations occur because of time lags in the system, the higher the gain the bigger will be the controlling action for a particular error and so the greater the chance that the system will overshoot the set value and oscillations occur.

Read full chapter

URL: 

https://www.sciencedirect.com/science/article/pii/B978075066432550005X

Process Controllers

William Bolton, in Instrumentation and Control Systems (Third Edition), 2021

5.3.2 Limitations of Proportional Control

Proportional controllers have limitations. Consider a simple unity feedback control system (Figure 5.12). When there is no error, we must have the output value equal to the set value. For many closed-loop control systems, this is what is wanted. But will this be achieved with a proportional control system? The error signal fed to the proportional controller Kp is the difference between the set value and the output value from the system.

Figure 5.12. A closed-loop control system.

Error=set value−output value

Thus when there is an error and the plant is not delivering the required output, the correcting input applied to the plant is Kp×error. This correcting signal will steadily reduce the error. However, as the error becomes smaller, the signal applied to the plant to correct the output becomes smaller and will eventually become too small for the output to be maintained at the required set value. We can only have a correcting input to the plant if the error is not zero. Thus this use of a proportional controller leaves the output with a steady-state error.

All proportional control systems have a steady-state error. The proportional mode of control tends to be used in processes where the gain KP can be made large enough to reduce the steady-state error to an acceptable level. However, the larger the gain, the greater the chance of the system oscillating. The oscillations occur because of time lags in the system—the higher the gain, the bigger will be the controlling action for a particular error and so the greater the chance that the system will overshoot the set value and oscillations occur. Zero steady-state error can be obtained when there is an integrator with the proportional control, see Section 5.5.1 for a discussion of PI control. Steady-state errors are also discussed in Section 10.7.

Example

A proportional controller has a gain of 4. What will be the percentage steady state error signal required to maintain an output from the controller of 20% when the normal set value is 0%?

With a proportional controller we have

%controller output=gain×%error=20=4×%error

Hence the percentage error is 5%.

Example

For the water level control system described in Figure 5.9, the water level is at the required height when the linear control valve has a flow rate of 5 m3/h and the outflow is 5 m3/h. The controller output is then 50% and operates as a proportional controller with a gain of 10. What will be the controller output and the offset when the outflow changes to 6 m3/h?

Since a controller output of 50% corresponds to 5 m3/h from the linear control valve, then 6 m3/h means that the controller output will need to be 60%. To give a change in output of 60−50=10% with a controller having a gain of 10 means that the error signal into the controller must be 1%. There is thus an offset of 1%.

Read full chapter

URL: 

https://www.sciencedirect.com/science/article/pii/B9780128234716000058

Process Controllers

William Bolton, in Instrumentation and Control Systems (Second Edition), 2015

5.3.2 Limitations of Proportional Control

Proportional controllers have limitations. Consider the example in Figure 5.8 of the amplifier as the proportional controller. Initially, take the temperature of the liquid in the bath to be at the set value. There is then no error signal and consequently no current to the heating element. Now suppose the temperature of the inflowing liquid changes to a constant lower value (Figure 5.12). The temperature sensor will, after a time lag, indicate a temperature value which differs from the set value. The greater the mass of the liquid in the tank, i.e. the capacitance, the longer will be the time taken for the sensor to react to the change. This is because it will take longer for the colder liquid to have mixed with the liquid in the tank and reached the sensor. The differential amplifier will then give an error signal and the power amplifier a signal to the heater which is proportional to the error. The current to the heater will be proportional to the error, the constant of proportionality being the gain of the amplifier. The higher the gain the larger will be the current to the heater for a particular error and thus the faster the system will respond to the temperature change. As indicated in Figure 5.12, the inflow is constantly at this lower temperature. Thus, when steady state conditions prevail, we always need current passing through the heater. Thus there must be a continuing error signal and so the temperature can never quite be the set value. This error signal which persists under steady state conditions is termed the steady state error or the proportional offset. The higher the gain of the amplifier the lower will be the steady state error because the system reacts more quickly.

Figure 5.12. Inflow change.

In the above example, we could have obtained the same type of response if, instead of changing the temperature of the input liquid, we had made a sudden change of the set value to a new constant value. There would need to be a steady state error or proportional offset from the original value. We can also obtain steady state errors in the case of a control system which has to, say, give an output of an output shaft rotating at a constant rate, the error results in a velocity lag.

All proportional control systems have a steady state error. The proportional mode of control tends to be used in processes where the gain KP can be made large enough to reduce the steady state error to an acceptable level. However, the larger the gain the greater the chance of the system oscillating. The oscillations occur because of time lags in the system, the higher the gain the bigger will be the controlling action for a particular error and so the greater the chance that the system will overshoot the set value and oscillations occur.

Example

A proportional controller has a gain of 4. What will be the percentage steady state error signal required to maintain an output from the controller of 20% when the normal set value is 0%?

With a proportional controller we have

%controller output=gain×%error=20=4×%error

Hence the percentage error is 5%.

Example

For the water level control system described in Figure 5.9, the water level is at the required height when the linear control valve has a flow rate of 5 m3/h and the outflow is 5 m3/h. The controller output is then 50% and operates as a proportional controller with a gain of 10. What will be the controller output and the offset when the outflow changes to 6 m3/h?

Since a controller output of 50% corresponds to 5 m3/h from the linear control valve, then 6 m3/h means that the controller output will need to be 60%. To give a change in output of 60−50=10% with a controller having a gain of 10 means that the error signal into the controller must be 1%. There is thus an offset of 1%.

Read full chapter

URL: 

https://www.sciencedirect.com/science/article/pii/B9780081006139000055

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *