# First Order Systems 2.2

Published

In the previous tutorial, we familiarized ourselves with the time response of control systems and took a look at the standard test signals that are used to study the time response of a control system. In this tutorial, we shall learn about the first order systems.

In simple words, first order systems are those systems where the denominator of the transfer function is of the first order (the means that the highest power of “s” is 1). If you recall the tutorial about transfer functions, we can state that first order systems are those systems with only one pole.

The generalized block diagram of a first order system looks like the following,

where

- R(s) is the input,
- C(s) is the output,
- G(s) is the forward path gain, and
- H(s) is the feedback gain.

For a general first order system,

and

What is “T” here? - It’s called the time constant of the system. For now, just remember that the time constant is a measure of how fast the system responds.

Alright, now we are ready to march ahead. Remember we had discussed the standard test inputs in the last tutorial. Now we shall apply those standard test inputs to this first order system and check how it responds at the same time making some important observations. Drum roll for the first test signal!! “The Unit Impulse”.

## Response of the First Order System to Unit Impulse Input

As we know, the unit impulse signal is represented by 𝛿(t).

Hence, the input *r*(*t*) = 𝛿(*t*). Now, taking the Laplace transform,

As discussed earlier, for a first order system -

Which can also be written as

You’ll want to do this last step to simplify the process of converting it back into the time domain from the Laplace domain. To find the time response, we need to take the inverse Laplace of C(s)

So how does this look graphically?

Let’s use Scilab for this purpose. If you aren’t familiar with Scilab, you can check out our basic tutorials on Scilab and XCOS. It’s basically a free MATLAB.

Carefully observe the syntax that is being used here.

For simplicity, let’s take *T* = 1

s = %s; // defines 's' as polynomial variable

T = 1; // the time constant

tf = syslin('c', 1, s*T + 1); // defining the transfer function. This syntax is - syslin('c', numerator, denominator) where 'c' denotes the continuous time.

t = 0:0.001:25; // setting the simulation time to 25s with step time of 0.001s

c = csim('imp', t, tf); // the output c(t) as the impulse('imp') response of the system

plot2d(t, c)

xgrid (5 ,1 ,7) //for those red grid in the plot

xtitle ( 'Impulse Response', 'Time(sec)', 'C(t)')

The response of the first order system after you give an unit impulse at time t = 0 is as follows.

Now, try changing the value of T and see how the system behaves. Remember, ‘T’ is the time constant of the system.

As we can see, the system takes more time to reach a steady state as we increase the time constant which justifies what we discussed earlier as time constant being the measure of how fast the system responds. The larger the time constant, the more the time it takes to settle.

Next we’ll move on to the unit step signal.

## Response of the First Order System to Unit Step Input

As we know, the unit step signal is represented by *u*(*t*).

Hence, the input *r*(*t*) = *u*(*t*). Now, taking Laplace transform,

For a first order system -

With the help of the method of partial fractions, we can rewrite the above equation as -

To find the time response, we need to take the inverse Laplace of C(s)

Now let’s see how the response looks with Scilab’s help. And, again, observe the syntax carefully.

Let’s take *T *= 1

s = %s; // defines 's' as polynomial variable

T = 1; // the time constant

tf = syslin('c', 1, s*T + 1); // defining the transfer function. This syntax is - syslin('c', numerator, denominator) where 'c' denotes the continuous time

t = 0:0.001:25; // setting the simulation time to 25s with step time of 0.001s

c = csim('step', t, tf); // the output c(t) as the step('step') response of the system

plot2d(t, c)

xgrid (5 ,1 ,7) //for those red grid in the plot

xtitle ( 'Step Response', 'Time(sec)', 'C(t)')

Upon running,

Something that we can observe here is that the system can’t change its state suddenly and takes a while depending on certain system parameters. Now, let’s change the time constant and see how it responds.

Again here, we can observe the same thing. As we increased the time constant, the system took more time to settle.

Let’s make one more observation here. We obtained the output equation for the step response of a first order system as *c*(*t*) = 1 - *e*^{-t/T}.

What would be the output at time *t* = *T*? Let’s see,

This brings us to another definition of the time constant which says “** time constant is the time required for the output to attain 63.2% of its steady state value.**” This is extremely important and will be referenced frequently.

Before we march ahead, we shall learn about steady state error now. It is the difference between the desired response(which is the input) and the output as time approaches to a large value.

Hence, the steady state error of the step response for a general first order system is zero. We shall verify this by plotting *e*(*t*).

s = %s; // defines 's' as polynomial variable

T = 1; // the time constant

tf = syslin('c', 1, s*T + 1); // defining the transfer function. This syntax is - syslin('c', numerator, denominator) where 'c' denotes the continuous time

t = 0:0.001:25; // setting the simulation time to 25s with step time of 0.001s

c = csim('step', t, tf); // the output c(t) as the step('step') response of the system

plot2d(t, c)

e = 1 - c; // the error for step response

plot2d(t, e, style=[color("red")])

xgrid (5 ,1 ,7) // for those red grid in the plot

legend("c(t)", "e(t)")

xtitle ( 'Step Response', 'Time(sec)', )

As we can see, the steady state error is zero as the error ceases to exist after a while.

Shall we move to the unit ramp input?

Oh wait, we had forgotten about XCOS! We can simulate all this without having to write the code and with just blocks. Makes life much simpler.

And after running, we get -

which is just the same thing. Don’t be shy to try these out. In order to change the time constant while trying out in xcos, just edit the transfer function block. (For example, for T = 2, making the transfer function - 1/1+2s)

## Response of the First Order System to Unit Ramp Input

As we know, the unit ramp signal is represented by *r*(*t*).

Now, taking the Laplace transform,

For a first order system -

With the help of the method of partial fractions, we can rewrite the above equation as -

To find the time response, we need to take the inverse Laplace of C(s)

Now let’s see how the response looks with Scilab’s help. Observe the syntax carefully.

Let’s take T=1and simulate using XCOS now.

After running,

Next, we shall see the steady state error of the ramp response for a general first order system.

The steady state error in this case is T which is the time constant. Which means for a system with a larger time constant, the steady state error will be more. We shall be dealing with the errors in detail in the later tutorials of this chapter.

Let’s observe this -

In a similar way, we can analyze for a parabolic input. But we shall skip it here as it’s rarely used and the calculations get a little complicated. Feel free to comment if you face any difficulties while trying this.

One of the most common examples of a first order system in electrical engineering is the RC low pass filter circuit.

By voltage division,

where T(time constant) = R*C

You can apply the test inputs to this filter and check if the responses discussed match.

In this tutorial, we learnt about first order systems and how they respond to the standard test inputs with the help of Scilab and XCOS. In the next tutorial we shall discuss in detail about second order systems. If you have any questions, feel free to drop it in the comments.

Get the latest tools and tutorials, fresh from the toaster.