An Introduction to Control Systems: Designing a PID Controller Using MATLAB’s SISO Tool
Introduction
Control systems engineering requires knowledge of at least two basic components of a system: the plant, which describes the mathematically modeled behavior of your system, and the output which is the goal you are trying to reach. A control system which has become commonplace in the automotive industry is the cruise control system: an output is programmed by the driver, and the control system has to manage all of the vehicle readings in order to maintain velocity.Because the road we drive on has imperfections, sometimes the system will have to accelerate or decelerate automatically. If you’ve ever used this feature on a car, you may have noticed that the car tends to keep a very smooth pace on the velocity you’ve chosen  it doesn’t abruptly accelerate or decelerate. This means that the vehicle’s control system is first given a desired output, then manages errors of the actual output by compensating for the input (for example, by how much fuel is provided to the engine).
Before solving for a system, we will briefly analyze the components and behavior of a system (uncompensated) and then the individual components of a PID (proportionalintegralderivative) controller. The final step would be to bring these two together and design a PID controller that will compensate the originally observed system. It is important to know that PID controllers are not the only type of compensation a designer can apply to system, but it's a great place to start and learn some of the universal characteristics that will stay true in other methods.
Note: In this tutorial we will be analyzing analog systems under ideal conditions (no noise or disturbance) and all or most the mathematical analysis will done via MATLAB.
Observing a System
A system can be made up of various components arranged in equally various ways; but we will begin by analyzing the components and functionality of a classical closedloop sytem (Figure 1).
Figure 1  An example block diagram of a singleinput singleoutput system closed loop system.
 Input: r  An input is some sort of reference
value that should have a direct correlation with the system’s output.
This doesn’t necessary translate directly to a voltage/power source,
but rather a setting or switch that will connect a voltage/power source
to the system. In the system example that we will analyze later, our
input signal will be a unitary step.
 Controller: C  In our case, this is the PID
controller that we will design. It is positioned before the plant that
we are compensated for and just after the junction of the input signal
and feedback.
 Plant: G  This is all of your subsystems
mathematically expressed as a transfer function. If what you are
attempting to control is a DC motor, then the plant is in fact, your DC
motor. You input will cause the plant to react in a way that will
supply an output value that is ideally close to your input.
 Output: y  This reading is the actual system’s
response to our desired response (the input) which has passed through
our assembled system (plant). The performance of the system is judged
by the comparison of the output to the input, given that certain errors
will occur and have been taken into account as acceptable.
 Feedback: H  In a system’s equivalent block
diagram (see Figure 1), the feedback line introduces the output of the
system into the input. What this means is that any discrepancies
between the output (actual response) and input (desired response) can be
measured  in other words, the error between the input and output is
what is introduced to the controller. Our system's error is then equal
to: input  output x H; if the system has a unitary feedback (meaning
that H = 1), then our error is simply input minus the output. This will
be an important idea to remember when we move onto describing how each
facet of the PID controller works.
 It is important to note that the transfer function for the complete loop in Figure 1 could be further simplified into just one block with a single input and single output by the use of the closed loop transfer function:
PID Control Definition
A PID controller is actually a three part system: Proportional compensation: the main function of the
proportional compensator is to introduce a gain that is proportional to
the error reading which is produced by comparing the system's output and
input.
 Derivative compensation: in a unitary feedback system, the
derivative compensator will introduce the derivative of the error signal
multiplied by a gain
 . This means that the area under the error signal's curve will be affecting the output signal. We will prove this later, but it is important to note that this facet of the controller will improve the steadystate error of overall closedloop system.
Compensation  Time Domain  SDomain 

Proportional 
Derivative 
Integral 
Therefore, a PID controller can be mathematically described as:
Compensation  Time Domain  SDomain 

PID Controller 
For no reason other than simplicity, one can see why the sdomain is exclusively used when analyzing or designing analogous systems  working with fractions is always easier than doing integration and/or derivatives. If we now take what we have described as a PID controller and apply it to Figure 1, our block diagram will now resemble something like what you see in Figure 1.1 below.
Figure 1.1  Our "C" block is essentially everything contained within
the red box: the summation of proportional, derivative and integral
compensations to the system.
Output Characteristics
Now that we know what a system is made of and how we will applying our PID controller, we can start to talk about the characteristics of our output signal (afterall, this is what we're monitoring and attempting to change)Important Equations
Output analysis:
Characteristic  Equation  Description 
General Equation (2ndorder) 
This general equation will help describe the behavior of a typical secondorder function with no zeros. However, not all transfer functions are or will be secondorder and many will contain zeros. In these cases it is required to do a partial fractions analysis to determine the error between using the secondorder equations on a higherorder system. (Note: we will assume the error is acceptable for the example used later in this article).  
Overshoot (percent)  
This value will describe the percent at which the output's waveform overshoots (or surpasses) it's final/steadystate value. It is expressed as a percent of the the final value.  
Damping Ratio 
It is important to take note that the equation for the damping ratio is solely dependant on the overshoot. The ratio will describe if a system is is undamped (equal to 0), underdamped (between 0 and 1), critically damped (equal to 1), or overdamped (greater than 1).  
PeakTime 
This is the time (in seconds) for the waveform to reach its maximum, or peak, value.  
SettlingTime 
The time it takes for the waveform to settle within +/ 2% of the final/steadystate value. Because oscillations may continue indefinitely (albeit minor), this does not require the waveform to settle absolutely. 
Steadystate error Analysis:
where
Graphical Representations:
Figure 1.2  The plot provides a visualization of how different damping
ratios affect a system's output (in response to a step). This also
shows a the direct correlation between a system's damping ratio and
percent overshoot (the smaller the damping ratio, the larger the
overshoot).
Figure 1.3  An example of a systems response to a step input. Using
MATLAB SISO Tool's analysis allows for the user to display
characteristics of the response  in this case: peaktime, overshoot,
and settlingtime.
Controller Design in Matlab
There are several improvements we need to do once we have our transfer function of the component (or plant) whose response needs to be improved. MATLAB includes many “engineering toolboxes” that enable engineers to create, analyze and simulate a variety of different projects. In our case, MATLAB has included the Control Systems Toolbox which includes several functions tailored for control systems engineering. They’ve also included the SISO (singleinput singleoutput) tool, a GUI that allows for interactive system analysis and control design. Two of the best aspects of the SISO tool approach are:
How changes in the transfer function’s poles and zeros alter the root
locus and bode plots in live response. The changes in gain can also be
instantly reflected in the system’s step response.

Specifying the design requirements will create visual limitations on
the graphs to help the user set and find appropriate gains. This is
done by rightclicking on the SISO tool root locus plot and selecting
‘Design Requirements’. You then chose the type of characteristic you
want to set and define its limits. This will provide you with a defined
border limit and a shaded ‘invalid’ area (orange shade). It is
important that as a designer, you keep a list of your priorities and
note the specifications that are of most importance.
Design Requirements:
 An overshoot of no more than 20%
 Peaktime (Tp) that is no more than twothirds that of uncompensated system. (refer to equations)
 Zero steadystate error for a stepinput (refer to equations)
Sectioned MATLAB Script
%% Define our Plant
n=poly([8]); %defining our numerator
d=poly([3 6 10]); %defining our denominator
Ps=tf(n,d) %tf is a function that calls for a predefined numerator and
%denominator value to create a transfer function
Ts=feedback(Ps,1) %the feedback function will automatically provide you
%with the closed loop transfer function while defining
%your plant as the first variable, and your feedback as
%your second variable
% Once you click on "Run Section" you will note that values have appeared
% in your Workspace and a transfer function as been printed in your
% Command Window.
%% Run SISO tool to analyze Plant transfer function
sisotool(Ps) %Note that we are running sisotool on the openloop TF
%% Apply gain & analyze system response
% At this point you can either export your gain (K) value or you can
% manually enter and save the value in your workspace.
K=116.5; %K as given through siso analysis
Ps1=K*Ps %Muliplying K with plant
Ts1=feedback(Ps1,1) %This will provide the closed loop transfer function
%where the feedback line has a value of just 1
%(nothing contained in feedback  unitary feedback)
stepinfo(Ts1) %stepinfo will print detailed step response data
step(Ts,Ts1); %will provide a graph of the step response for visual analysis
%% Calculate Goal PeakTime
Tp=0.2978; %value of Tp that I found in previous section from stepinfo
Tp_goal=Tp*(2/3) %printing my goal peak time in command window
pOS = 20;
dr=log(pOS/100)/sqrt(pi^2+(log(pOS/100))^2); % OS to Damping Ratio eq.
w=pi/(Tp_goal*sqrt(1(dr^2))) % Peak Time and DR to find freq.
%% Apply PD compensation
% Here we run sisotool again, this time on Ps1 instead of Ps.
% We will now add an additional design characteristic  our goal peaktime
% Refer to peaktime equation to find settlingtime equivalent
sisotool(Ps1)
%% Export the PD compensator for analysis
PD=C %Only run this section once to ensure that PD is not overwritten with
%another C value from SISO tool
Ps2=Ps1*PD
Ts2=feedback(Ps2,1)
stepinfo(Ts2)
step(Ts,Ts1,Ts2)
%% Apply PID compensation
% As before, we will run sisotool, this time on Ps2 and finalize our PID
sisotool(Ps2)
%% Export the PID compensator value for analysis
PID=C % This will carry the value of our new C and attach it to PID
Ps3=Ps2*PID % muliply the integrator to the PD
Ts3=feedback(Ps3,1)
stepinfo(Ts3)
step(Ts,Ts1,Ts2,Ts3)
%% Finally we will calculate our steadystate error (refer to equations)
kp=dcgain(Ps3); % dcgain is a function that will carry out our limit s>0
ess=1/(1+kp) % this is the equation for the steady state error for a step
Command Window Prompts
Ps =
s + 8

s^3 + 19 s^2 + 108 s + 180
Continuoustime transfer function.
Ts =
s + 8

s^3 + 19 s^2 + 109 s + 188
Continuoustime transfer function.
Ps1 =
116.5 s + 932

s^3 + 19 s^2 + 108 s + 180
Continuoustime transfer function.
Ts1 =
116.5 s + 932

s^3 + 19 s^2 + 224.5 s + 1112
Continuoustime transfer function.
ans =
RiseTime: 0.1330
SettlingTime: 0.7119
SettlingMin: 0.7736
SettlingMax: 1.0057
Overshoot: 19.9931
Undershoot: 0
Peak: 1.0057
PeakTime: 0.2978
Tp_goal =
0.1985
w =
17.7797
PD =
0.045476 (s+56)
Continuoustime zero/pole/gain model.
Ps2 =
5.298 (s+8) (s+56)

(s+10) (s+6) (s+3)
Continuoustime zero/pole/gain model.
Ts2 =
5.298 (s+56) (s+8)

(s+8.08) (s^2 + 16.22s + 316)
Continuoustime zero/pole/gain model.
ans =
RiseTime: 0.0807
SettlingTime: 0.4507
SettlingMin: 0.8508
SettlingMax: 1.1313
Overshoot: 21.7083
Undershoot: 0
Peak: 1.1313
PeakTime: 0.1761
PID =
1.0013 (s+0.1)

s
Continuoustime zero/pole/gain model.
Ps3 =
5.3048 (s+8) (s+56) (s+0.1)

s (s+10) (s+6) (s+3)
Continuoustime zero/pole/gain model.
Ts3 =
5.3048 (s+56) (s+8) (s+0.1)

(s+8.081) (s+0.09324) (s^2 + 16.13s + 315.4)
Continuoustime zero/pole/gain model.
ans =
RiseTime: 0.0881
SettlingTime: 13.0990
SettlingMin: 0.8943
SettlingMax: 1.1375
Overshoot: 13.7503
Undershoot: 0
Peak: 1.1375
PeakTime: 0.1770
ess =
0
Step Responses and Root Locus via MATLAB SISO Tool
Figure 2  The uncompensated system will have to reach a gain of about 116.5 in order to achieve the 20% overshoot (the only design characteristic at this point)
Figure
3  Note that the borders of the two design requirements meet at
certain point. Altering the gain will cause that point will position the
poles.. Placing the zero at 56 will provide the plot to cross over the
junction point, then adjust its gain.
Figure
4  The goal is to design an ideal integrator that will bring the
steadystate error to zero. This is achieved by placing a pole at the
origin and a zero close to the origin (rule of thumb is anything less
than or equal to 0.8); in this case, choose to place the zero at 0.1.
Feel free to adjust these numbers and see how the system’s reaction
changes.
Figure
5  This shows the step response of the given system with zero gain
(for reference), uncompensated (with gain), with PD controller, and
finally with PID controller
Figure 6  A better view of our peak responses
Conclusion
As previously mentioned, this article attempted to substitute the mathematical modeling and analysis by using visual manipulations of the system’s behavior and requirements. As our end result shows, we were able to meet our design requirements and implement the mathematical model of our compensator. It’s important to note that it would require an active circuit to implement the design our PID controller, and that there are several viable solutions to our problem. Should you decide to design your own controller for the same system, it is recommended that you choose different values for the poles and zeroes.It is likely that you could design a controller that still meets the requirements and does not have the exact values as shown above. Upon analysis of figure 5, it becomes clear how each step impacted our end result. By simply defining the region of overshoot and adjusting our gain, we were able to achieve an output that resembled our input (albeit with an obvious error). By looking at figure 6, we can immediately tell that our next attempt (PD controller) was able to dramatically improve our peak time and steadystate error. Finally, our PID was able to take what we already had defined in our PD and improve our steadystate error to our goal of zero. Becoming proficient with the SISO tool not only helps improve the time it takes to design a functional controller, but helps to ingrain the relationships of each aspect/component to our end result.