CHAPTER-1

INTRODUCTION

The very essential task of closed loop controlled system is tuning the

controller. In order to find the optimal controller parameters, the model of the

process is very important.

PI controller is the most popular feedback controller commonly used

with in process industries. The controller is generally preferred in the modern

process industries due to its robustness, excellent control and performance

despites the varied dynamic characteristics of process plant .For the effective

performance of the PI control loop, it is necessary to get the control loop

properly tuned. Standard methods of tuning gives satisfactory for linear process.

Generally for nonlinear system adaptive control methods are suggested,

but one should be careful with the possible abuses of the adaptive schemes

which may produce results worse than that achievable by conventional PI

controller. In order to increase the performance of control loops employed with

the nonlinear system and modern complex control loops we need modern

methods of tuning.

In this project, the parameter settings of PI controller are obtained by

means of closed loop ZN tuning method, Fuzzy Logic based PI controller and

Genetic Algorithm based PI controller.

The effectiveness of the optimum settings is verified with the settings of

the conventional method using the model of air temperature process.

1

1.1 OBJECTIVES

• To identification of model parameter of air temperature process.

• To obtain the mathematical model of the air temperature process.

• To design of conventional PI controller for air temperature process using

ZN tuning rule

• To design of fuzzy logic PI controller for air temperature.

• To design of Genetic Algorithm based optimal PI controller for air

temperature process

1.2 ORGANIZATION OF THE THESIS

Chapter: 2 deals with the Design of controllers

Chapter: 3 deals with process description

Chapter: 4 deals with result and discussion

2

CHAPTER-2

DESIGN OF CONTROLLER

2.1 INTRODUCTION

Tuning a controller implies setting its adjustable parameters to

appropriate values that provide good control performance. Generally the

methods are classified for linear and non linear system.

2.2 CONVENTIONAL PI CONTROLLER

For linear system synthesis method, Z-N, Coohen-coon methods are

suggested for non linear system. The Ziegler – Nichols’ open loop method is

based on the process step response. The PI parameters are calculated from the

response in the process measurement ym after a step with height U in the control

variable u, see figure 1. The term “process” here means all blocks in the control

except controller. The step response experiment is executed on the uncontrolled

process, so the control loop is open (no feedback).

Figure 1: Ziegler – Nichols’ open loop method is based on the step

response of the uncontrolled process

3

2.2.1 MODELING FOR AIR TEMPERATURE PROCESS

In order to find the process modeling, the system was put in to open loop

condition. After steady state was reached, the step change of specify magnitude

was given to the process by changing the inflow of air. First fix the operating

region after analyzing the different operating points in the air temperature

process. Then the gain & time constant of the process are determined by giving

the step change to the air temperature process. Now the process is approximated

to first order with dead time delay (FOPDT) as shown in figure 2.

0 2 0 0 4 0 0 6 0 0 8 0 0 1 0 0 0 1 2 0 0 1 4 0 0 1 6 0 0 1 8 0 0 2 0 0 00

5

1 0

1 5

2 0

2 5

3 0

3 5

4 0

4 5

T i m e i n s e c

Tem

pera

ture

(C)

Figure: 2 Open loop curve

Model parameters are identified using two point technique

From the data

KP = ∆output / ∆Input

τ = 1.5 (t2- t1)

Where Kp =gain of the process

τ = Time constant

td = t2 - τ

4

28.3%

63.2%

t1 t2

The PI controller settings are

Kc = dp tkτ*0.9

Ti = 3.33*td

2.3 FUZZY PI CONTROLLER

The main paradigm of fuzzy control is that the control algorithm is a

knowledge based algorithm, described by methods of fuzzy logic. The fuzzy

logic control system is a kind of expert knowledge – based system that contains

the control algorithm in a simple rule base. The knowledge encoded in the rule

– base is derived from human experience and controlled system. This makes the

fuzzy control special and conceptually different from conventional control. The

operation of approximate reasoning converts the knowledge embedded in the

rule – base (IF – THEN rules) into a crisp (nonfuzzy) control algorithm.

Keeping this in mind, a PI like FLC is designed using fuzzy logic toolbox for

Air Temperature Process and its performances are compared with genetic

algorithm based optimal PI controller. The operation of FLC can be explained

as follows:

If the measured process output is a crisp quantity, it can be fuzzified into

a fuzzy set. This fuzzy output in then considered as the fuzzy input to a fuzzy

controller, which consists of linguistic rule. The output of the fuzzy controller is

then another series of fuzzy sets. Since most physical systems cannot interpret

fuzzy commands (fuzzy sets), the fuzzy controller output must be converted

into crisp quantities using defuzzification methods. These crisp (defuzzified)

control – output values then become the input values to the physical system and

the entire closed – loop cycle is repeated.

5

2.3.1 PI like FLC

The FLC describes with the aid of fuzzy IF-THEN rules the relationship

between the change in the control output Δu(k) = u(k) – u(k-1) on one hand, and

the error e(k) and its change Δe(k) = e(k) – e(k-1) on the other hand as given by

Δu(k) = F(e(k), Δe(k)) (1)

The internal mechanism of the FLC translates it into a mapping:

Δu(k) = f(e(k), Δe(k)) (2)

This relation is similar to conventional PI controller as

Δu(k) = Kp Δe(k) + Ki e(k) (3)

Where Kp and Ki are the parameters of the PI controller. This FLC is

called as a PI – like FLC. In case of PI controller, the equation (3) is linear,

while in FLC, equation (2) is nonlinear.

2.3.1 Design procedure of FLC

Important steps in the design of FLC are listed as

Step1: Determine the input and output variables of FLC: by appropriate

selection of the input and output variables the controller can be identified as PI

– like, PD – like, or PID- like FLC.

Step2: Define the parameters of FLC: Determine the scaling factors and the

normalized universes of discourse and membership functions of the reference

fuzzy sets associated with the linguistic labels of the main variables like error

(e), change in error (Δe(k)) and output Δu(k).

Step3: Determine the rule – base of the FLC: The rule table is formed using the

three meta rules given by

6

Step4: Computational realization of the FLC : The fuzzy output of the FLC is

converted into a crisp output using defuzzification method.

1. If the error e(k) and its change Δe(k) are zero, then maintain present

control setting.

2. If the error e(k) is tending to zero at a satisfactory rate, then maintain

present control setting.

3. If the error e(k) is not self – correcting, then control action setting Δu(k)

is not zero and depends on the sign and magnitude of e(k).

2.3.2 Fuzzy toolbox commands

1. FIS editor – using this command Mandani or sugeno type FIS can be

selected.

2. Input / output – using this command number of inputs / outputs can be

selected.

3. MF editor – Using this command number of membership functions

(MFs) can added, modified or deleted. Also type of MFs can be selected.

4. Rule editor – using this command rules can be edited, modified or

deleted.

5. Rule viewer – firing strength of the rules can be viewed.

6. Surf viewer – output surface can be viewed.

2.3.3 FLC design for air temperature process

Reference input : r(k)

Process output : y(k)

Error e(k) : r(k) – y(k)

7

Change in error Δe(k) : e(k) – e(k-1)

Input variables : Error e and change of error Δe

Output variables : Change of Δu

Membership function type : Triangular with 50% overlapping

Defuzzification method : Center Of Gravity (OCG) method

The range of error : [-1 1]

The range of change in error: [-1 1]

The range of change in output: [-0.01 0.01]

The membership diagrams of e, Δe and Δu are shown in figures 3, 4, 5

the fuzzy control rule table for the given process is given in table1.

Table: 1 FAM (control rules) table

Δee

NB NM NS ZE PS PM PB

NB NB NB NM NM NS NS ZE

NM NB NM NM NS NS ZE PS

NS NM NM NS NS ZE PS PS

ZE NM NS NS ZE PS PS PM

PS NS NS ZE PS PS PM PM

PM NS ZE PS PS PM PM PB

PB ZE PS PS PM PM PB PB

8

Figure: 3 Membership diagram for error

Figure: 4 Membership diagram for change in error

Figure: 5 Membership diagram for change in output

9

Mem

bers

hip

valu

e (µ

)M

embe

rshi

p va

lue

(µ)

Mem

bers

hip

valu

e (µ

)

2.4 GENETIC ALGORITHM

Genetic Algorithms (GA) are stochastic global search methods based on

the mechanics of natural selection and natural genetics. They are iterative

methods, widely used in optimization problems in several branches of the

Science and Technologies. Contrary to what happens in other methods, in this

methodology. In each iteration (generation), not only one point in the search

space is taken into account, but a set of solutions defining a population or

populations of individuals is considered. Genetic Algorithm loop as shown in

figure 6.

Figure: 6 Genetic Algorithm loop

10

1. Initial population

2. Selection individuals for mating

3. Mate individuals to generate offspring

4. Mutate offspring

5. Insert new individuals into population

6. Are criteria satisfied?

7. End of searching

As we can notice above a loop of evolution is closed. Replication starts

from base point again and the best individuals are chosen. The selection of

chromosomes is a random process, but it is very strongly directed for choosing

the best individuals for reproduction. A common practice is to terminate the GA

after number of generation and then test the quality of the best number of the

population against the problem definition. If no acceptable solutions are found,

the may be restarted or a fresh initiated.

2.4.1 Chromosomal representation

Individuals are encoded as strings, chromosomes composed over some

alphabet, so that the genotypes are uniquely mapped onto the decision variable

domain. The most often used for representation in Gas is the binary alphabet.

Here each decision variable in the parameter set is encoded as a binary string

and these are concatenated to form a chromosome.

The chromosomes are seen as binary strings of given length, and

decoded into real numbers over a specified interval using either standard binary

or gray coding. The use of gray coding for binary chromosome representation is

recommended as the regular Hamming distance between intervals reportedly

makes the genetic search less deceptive.

11

2.4.2. Population

The population size is the number of chromosomes in the population.

Having decided the representation, the first step is to create an initial

population. This is usually achieved by generating the required number of

individuals using a random number generator that uniformly distributes number

in the desired range. For example, with the binary population of Nind individuals

whose chromosomes are Lind bits long, Nind x Lind random numbers uniformly

distributed from the set {0, 1} would be produced.

There exist three main variations of genetic algorithms: simple, steady –

state and struggle population.

2.4.3 Simple GA

The simple genetic algorithm is one of the common genetic algorithm

implementations. The simple genetic algorithm uses non – overlapping

population. In each generation, the entire population is replaced with new

individuals. Typically the best individual is carried over from one generation to

the next so that the genetic algorithm does not inadvertently forget the best that

it found. Since the entire population is replaced each generation, the only

“memory” the algorithm has from performance of the crossover operator.

2.4.4 Steady state GA

The study state genetic algorithm uses overlapping population. In each

generation, the newly generated individuals replace a portion of the population.

At one extreme, only one or two algorithm can became a simple genetic

algorithm when the whole entire population is replaced. Since the algorithm

only replaced a portion of the population of each generation, the best

individuals are more likely to be selected and the population quickly converges

to a single individual.

2.4.5 Struggle GA

12

The struggle genetic algorithm is similar to steady – state GA. However,

rather that replacing the worst individual, a new individual replaced the

individual most similar to it, but only if the new individual has a score better

than that which is the most similar.

2.4.6 Fitness function

A fitness function must be devised for each problem, given a particular

chromosome, the fitness function returns a single numerical fitness value, which

is proportional to the ability, or utility, of individual represented by that

chromosome.

For many problems deciding upon the fitness function is very straight

forward, for example for a function optimization search, the fitness is simply

the value of the function. However there are cases where may be performance

measured to optimize.

Ideally, the fitness function should be smooth and regular so those

chromosomes with reasonable fitness are closer in the search space, to

chromosomes with slightly better fitness. However, it is not always possible to

construct such an ideal fitness function. For any type of search to be successful,

the fitness function must not have many local maximums, or a vary isolated

global maximum.

2.4.7 Genetic Algorithms Operations

2.4.7.1 Selection

The purpose of parent selection in a GA is to given more reproductive

changes to those individuals that are the fit. There are many ways to do it, but

one commonly used technique is roulette wheel parent selection (RWS), which

contains three basic steps:

1. Sum the fitness of all population members and name the result total

fitness,

2. Generate n, a random number between 0 and total fitness,

13

3. Return the first population members whose fitness, added to the fitness

of preceding population members, is greater or equal to n.

The effect of roulette wheel parent selection is to return a randomly

selected parent. Using this selection algorithm, each parent’s chance of being

selected is directly proportional to its fitness, but its possible also exists to

choose the worst population member.

A second very popular way of selection is stochastic universal sampling

(SUS). This way is a single – phase algorithm with minimum spread and zero

bias.

2.4.7.2 Crossover (Recombination)

The basic operator for producing new chromosomes in the GA is that of

crossover. Like in nature, crossover produces new individuals, which have some

parts of both parents genetic material. The simplest form of crossover is that of

single – point crossover.

Figure: 7 Single point crossover

Of course there exist other crossover variations such as dual point,

multipoint, uniform, shuffle, asexual crossover, and single child crossover.

2.4.7.3 Mutation

Mutation causes the individual genetic representation to be changed

according to some probabilistic rule. In binary string representation, mutation

case a random bit to change its stat (0 1 or 1 0) and it illustrated in figure

below. In natural evaluation, mutation is randomly applied with low probability,

typically in the range 0.001 and 0.01 and modifies element in the chromosomes.

Given that mutation is generally applied uniformly to an entire population of

14

string, it is possible that a given binary string may be mutated at more than one

point.

Figure: 8 Binary Mutations

2.4.7.4 Reinsertion

Once selection and recombination of individuals from the old population

have produced a new population, the fitness of the individuals in the new

population may be determinate. If fewer individuals are produced by

recombination than the size of the original population, than the fractional

difference between the new and old population sizes in termed a generation gap.

To maintain the size of the original population, the new individuals have

to be reinserted into the old population. Similarly, if not all the new individuals

are to be used at each generation or if more offspring are generated than size of

old population then a reinsertion scheme must be used to determine which

individuals are to exist in the new population. When selecting which members

of the old population should be relocated the most apparent stratyegy is to

replace the least fit members deterministically. The replacement should select

and replace the oldest members of the population.

2.4.8 Genetic Algorithm code in MATLAB

The genetic algorithm toolbox tries to maximize a function using a

simple (haploid) genetic algorithm to find a maximum of the fitness function.

This toolbox consist of net ten files

B10TO2 Converts base 10 to base 2

DECODE Converts from binary to variable representation

15

ENCODE Converts from variable to binary representation, this script

demonstrates the use of the simple genetic algorithm

GENETIC Tries to maximize a function using a simple genetic

algorithm

GENPLOT Graphing routine for genetic algorithm

MATE Randomly reorders (mates) OLD_GEN

MUTATE Change a gene of the OLD_GEN with probability Pm

REPRODUC Selects individuals proportional to their fitness

TESTGEN Tests genetic algorithm code with f(x) = x10

XOVER Creates a NEW_GEN from OLD_GEN using crossover

2.5 Conclusion

In this chapter the design of various tuning techniques for non linear

process were discussed.

16

CHAPTER- 3

PROCESS DESCRIPTION

3.1 INTRODUCTION

The developed of controller tuning scheme for non linear air

temperature process is tested by using developing a mathematical model of the

system.

3.2 PROCESS IDENTIFICATION

The processes used in our control systems have been described by

transfer functions that were derived by applying fundamental principles of

physics and chemical engineering (e.g., Newton’s law, material balance, heat

transfer, fluid mechanics, reaction kinetics, etc.) to well defined processes. In

practice, many of the industrial processes to be controlled are too complex to be

described by the application of fundamental principles. Either the task requires

too much time and effort or the fundamentals of the process are not understood.

By means of experimental tests, one can identify the dynamical nature of such

process and from the results obtain a process model which is at least satisfactory

for use in designing control systems. The experimental determination of the

dynamic behavior of a process is called process identification.

The need for process models arises in many control applications, as we

have seen in the use of tuning methods. Process models are also needed in

17

developing feed forward control algorithms, self-tuning algorithms, and internal

model control algorithms.

Process identification provides several forms that are useful in process

control; some of these forms are

Process reaction curve (obtained by step input)

Frequency response diagram (obtained by sinusoidal input)

Pulse response (obtain by pulse input)

3.3 CLOSED LOOP CONTROL OF AIR TEMPERATURE PROCESS

The process medium used there is air. The temperature of the air is to be

controlled and is allowed to flow through a polypropylene tube. The air is

heated by the heating chamber.

The temperature of the air is sensed by a suitable sensor (RTD- 2) whose

output (4 – 20 mA) is given to the PI controller. The controller compares this

measured variable with its set point value and the error produced is manipulated

through PI circuitry as controllers output (4 – 20 mA). This signal is given as

input to the triac driver circuit.

Triac driver in turn supplies variable AC voltage in the range of 0 – 230

V to the heater which is proportional to controller output. The final control

element is the Triac driver. The input to the heater controls the chamber

temperature which in turn maintains the desired temperature of the air media to

be controlled.

In this project, PI controller modes are implemented and Kc and Ti can

be returned to the desired values so as to achieve the desired closed loop

performance.

18

3.4 WORKING PRINCIPLE

The schematic diagram of the laboratory air temperature process taken

for project is shown in figure 9. The process supplies air at constant temperature

and at constant rate. The constant flow rate of air is maintained by an air

blower. The dry air follow thought the polypropylene type and is heated by the

heating chamber consisting of two heater elements. The temperature of the

following air is to be controlled.

The temperature of the air is sensed by three RTDs. Output of the RTDs

is given to the PC through (i) a suitable signal conditioner and (ii) an analog to

digital converter (ADC). The signal conditioning circuit converts the entire

range of temperature into the range 0 – 5V dc. The ADC converts the process

variable into its equivalent digital value and feeds to the PC. Here the PC is

used as an IMC controller. The controller compares it with the set point 4 – 20

mA which is given to thyristor power controller (TPC) via digital to analog

converter (DCA). The TPC manipulates the power supplies to the heater

element. In this way the closed loop control is achieved.

19

Figure: 9 Schematic (P&I) diagram of laboratory Air Temperature Process

20

Figure: 10 Laboratory Air Temperature Process

21

3.4.1 Precautions

The following precautions should be taken care before turning ON

process

1. Manual value (MV!) should be half open. MV1 and MV3 should be

fully open.

2. PID controller should be in manual mode

3. During start up sequence, first the blower should be turned ON and then

the heater should be ON.

4. To turn OFF the system, first the heater should be turned OFF and then

the blower should be turned OFF.

3.5 CALCULATION OF PI CONTROLLER SETTING

The general from of a first order process with dead time is given by

Where Kp – process gain

τ – Time constant

td – time delay of the process

The identified model for air temperature process is given by

22

The PI controller setting for air temperature process using the Zeigler

Nicholas tuning rules

Kc = dp tkτ*0.9

Ti = 3.33*td

3.6 CONCLUSION

The nonlinear air temperature system identified model in obtained

23

CHAPTER- 4

RESULTS AND DISCUSSIONS

4.1 INTRODUCTION

The tuning results for the parameter settings from the various techniques

are obtained and the behavior of the non-linear air temperature is observed by

implementing the controller parameter settings in the non linear air temperature

process control scheme.

4.2 IDENTIFICATION OF TUNING PARAMETERS (ZN – METHOD)

Consider the air temperature process,

The controller parameters Kc and Ti are obtained from transfer function

using ZN- tuning method

Kc = dp tkτ*0.9

Kc = 63*7.91

567*0.9

Kc = 1.024

Ti = 3.33*td

Ti = 3.33*63 = 209.79

24

4.3 GENETIC ALGORITHM OPTIMAL PI CONTROLLER

4.3.1 PID Controller Optimizer

PID Controller Optimizer is a MATLAB based interface written by the

author and it can be used to optimize PID parameters for the plant model

defined by the user. In the package, Simulink is used in modelling the plant,

which can be SISO continuous/discrete/hybrid, and linear/nonlinear systems of

any complexity. The optimization criteria are ITAE, ISE, IAE and others, which

will be defined later in the tutorial.

One may install the package to a MATLAB directory and include the

path with "File/Set Path" menu item. Then type pid_optimizer under

MATLAB prompt, the design interface will be displayed below.

This is Version 2 of PID Controller Optimizer Interface, released in Sept

2011. The first version was developed in 2008, mainly by the student Dong

Wenbin, and the new one is completely rewritten, with much simpler coding,

due to the release of the PID controller block in Simulink since 2009b. This

version works ONLY for MATLAB R2009b onward and was fully tested in

MATLAB R2011a.

4.3.2 Meaningful Optimization Criteria

The block diagram of the controlled system is shown below, where the

sophistigated PID controller block in the new version of MATLAB/Simulink is

used as the kernel, such that the controller can be tuned with the easy-to-use

manner. The interface is fully tested under MATLAB R2011a, and may work

well with the versions where PID controller block is provided.

25

Figure: 11 Plant Model

The user may construct the plant model with Simulink. The optimized

controller parameters can be obtained by minimizing one of the following

criteria

The ITAE criterion is recommended for a good controller.

4.3.3 To run PID Controller Optimizer

To run the interface, one can issue the command "optimpid" to start the

PID Controller Optimizer program. The interface shown below will be

displayed. An internal Simulink main model is opened and hidden. The plant

model should be created before the interface can be used. If the model created

is "air_temp_tran.mdl", the file name should be entered into the "Plant model

name" edit box. To display the plant model, the button "Show Model" can be

clicked.

26

Figure: 12 PID Controller optimizer

One may use the following essential procedures to design the controller

Step: 1 Enter the Simulink file name in the edit box "Plant model

name", and if a linear plant is involved, one can fill in in the edit box the pre-

composed Simulink model name "air_temp_tran.mdl". The plant model can

also be specified with the dialog box braught in by the file opening icon.

Figure: 13 “air_temp_tran.mdl”

27

Step: 2 Specify the terminate time in the "Terminate Time" edit box.

Step: 3 Click "Create Files" can be used to generate the objective

function in MATLAB.

Step: 4 Click "Optimize" button to design the controller and meanwhile

visualing the optimization process by displaying the relevant curves with the

Scope.

The type of PID type controller can be specified in the group

"Controller Type", where different forms of PID controllers are supported.

The available controller structure can be selected from the

"P/PI/PD/PID/I" controllers list, also "anti-windup PI and PID" controllers

are also supported. The actuator saturation of the controller can be assigned, if

applicable, but the "Actuator Saturation" group. The currently allowed

criterion can be selected from the "ISE/ITAE/IAE/ITSE/IT^2SE/IT^2AE"

list box.

The button "Show Model" can be used to show the plant model in

Simulink.

The "Show File" button can be used to display the objective function

generated.

The "Refresh" button can be used to delete all the existing plant model files, if

any. And also the initial values.

The "Simulation" button can evaluate multi-stairs simulation, and the

driven signal and terminating time can be specified with the "Multi-stairs

Signal" group. The "Hold" checkbox can be used to design optimal controller

under multi-stairs signal instead.

28

The optimized controller parameters can be returned in "Tuned

Controller" edit box, while the allowed lower and upper bounds in the

optimization process. These parameters can be set in the "Controller

Parameters" group.

Controller parameters are obtained by PID controller optimizer:

Kc = 0.9157

Ti = 0.0037

29

Simulation runs of air temperature process are carried out with GA

based PI values. Initially the air temperature is maintained at 40 % operating

temperature, after that, a step size of ±5% of temperature is applied to control

loop. Similar test runs of fuzzy based PI and conventional PI are carried out and

the responses are recorded in figure 15, figure 17 and figure19. From the

results, the performance indices are analyzed in terms of ISE are tabulated in

table 2. The results proven that GA based PI controller gives better performance

than the others.

Figure: 14 Simulink diagram of conventional PI controller

30

0 5 0 0 1 0 0 0 1 5 0 0 2 0 0 0 2 5 0 0 3 0 0 00

1 0

2 0

3 0

4 0

5 0

6 0

7 0

T i m e i n s e c

Tem

pera

ture

(C

)

i n p u t

o u t p u t

Figure: 15 Typical response of conventional PI controller

Figure: 15 Shows the closed loop responses for nonlinear air

temperature process using conventional PI controller. The simulation sequences

are: at time=0, a set point step change of 40oC is initiated and at time = 1500sec,

disturbance 5oC applied on the process.

31

Figure: 16 Simulink diagram of fuzzy logic PI controller

32

0 5 0 0 1 0 0 0 1 5 0 0 2 0 0 0 2 5 0 0 3 0 0 00

1 0

2 0

3 0

4 0

5 0

6 0

7 0

T i m e i n s e c

Tem

pera

ture

(C

)

i n p u t

o u t p u t

Figure: 17 Typical response of Fuzzy Logic PI controller

Figure 17 Shows the closed loop responses for nonlinear air temperature

process using fuzzy logic PI controller. The simulation sequence are: at time=0,

a set point step change of 40oC is initiated and at time = 1500sec, disturbance

5oC applied on the process.

33

Figure: 18 Simulink diagram of Genetic Algorithm optimal PI controller

0 5 0 0 1 0 0 0 1 5 0 0 2 0 0 0 2 5 0 0 3 0 0 00

1 0

2 0

3 0

4 0

5 0

6 0

7 0

T i m e i n s e c

Tem

pera

ture

(C

)

i n p u t

o u t p u t

Figure: 19 Typical response of Genetic Algorithm optimal PI controller

Figure: 19 Shows the closed loop responses for nonlinear air

temperature process using genetic algorithm optimal PI controller. The

simulation sequence are: at time=0, a set point step change of 40oC is initiated

and at time = 1500sec, disturbance 5oC applied on the process.

34

Table.2. Performance analysis based on ISE operating range of 40% of temperature

METHOD ISE ts (secs)

Conventional PI controller 204767.95 1350

Fuzzy logic PI controller 206025.29 1470

Genetic algorithm optimal PI

controller

184767.95 1185

4.5 Conclusion

In this chapter the controller parameters were obtained and implemented

for the non linear air temperature process.

35

CHAPTER- 5

CONCLUSION

In this project, a new method is developed and implemented for the

design of the PI controller based on a GA approach. This approach is related to

process control applications with a large dead time. A GA scheme repetitively

changes the control signal to achieve error convergence. The GA based PI is

implemented in a Temperature control of Air temperature process. A

comparison of the GA based PI mode controller with Fuzzy based PI mode and

ZN based PI mode control is made. Simulations results are furnished to

illustrate the efficiency of the proposed method.

36

REFERENCES

[1].K. K. Tan, R. Ferdous, S. Huang.(2002). Closed-loop automatic tuning

of PID controller for nonlinear systems. Chemical Engineering Science

57 ,3005 – 3011

[2].Astrom, K. J., & Hagglund, T. (1988). Automatic tuning of PID

controllers. Research Triangle Park, NC: Instrument Society of America.

[3].Astrom, K. J., & Hagglund, T. (1995). PID controllers: Theory, design

and tuning. Research Triangle Park, NC: Instrument Society of America.

[4].Gawthrop, P. J. (1986). Self-tuning PID controllers: Algorithms and

implementations IEEE Transaction on Automatic Control, 31(3), 201.

[5].Ho, W. K., Hang, C. C., & Cao, L. S. (1995). Tuning of PID controllers

based on gain and phase margin speci2cation. Automatica, 31, 497–

502.

[6].Ordonez, R., & Passino, K. M. (2001). Adaptive control for a class of

nonlinear systems with a Time varying structure. IEEE Transactions on

Automatic Control, 46(1), 152–155.

[7].Zeigler, J.G., and Nichols, N.B.(1942).Optimum setting for automatic

controllers.Transactions of the ASME,64,759-768.

[8].George stephanopoulos, “chemical process control-An introduction to

Theory and practice,” Prentice Hall India, New Delhi. 1999.

[9].Donald R. Coughanowr, Process Systems Analysis and Control, Mc

GRAW – HILL international editions, second edition 1991.

[10]. www.mathwork.com

37

APPENDIXES

Appendix A m-file

Genetic_algorithm.mfunction varargout = optimpid(varargin)% OPTIMPID Optimal PID controller design interface.% MATLAB code for optimpid.figf% Last Modified by GUIDE v2.5 05-Nov-2011 01:00:59% Begin initialization code - DO NOT EDITgui_Singleton = 1;gui_State = struct('gui_Name', mfilename, ... 'gui_Singleton', gui_Singleton, ... 'gui_OpeningFcn', @optimpid_OpeningFcn, ... 'gui_OutputFcn', @optimpid_OutputFcn, ... 'gui_LayoutFcn', [] , ... 'gui_Callback', []);if nargin && ischar(varargin{1}) gui_State.gui_Callback = str2func(varargin{1});endif nargout [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});else gui_mainfcn(gui_State, varargin{:});end function optimpid_OpeningFcn(hObject, eventdata, handles, varargin)v=version; i=findstr(v,'R'); s1=v(i:i+5); pause(0.0001)if eval(v(i+1:i+4))>2011, s1='R2011a'; endtry str=which(['pidctrl_model' s1 '.mdl']); i=findstr(str,'pidctrl_model'); fpath=[str(1:i-1),'models\']; if length(str)==0 errordlg({'Sorry, the current version is NOT supported,'; 'please try a later one'},'Error in MATLAB version') else copyfile(str,'pidctrl_model.mdl','f'); copyfile([fpath,'mod_1' s1 '.mdl'],'mod_1.mdl','f') copyfile([fpath,'mod_2' s1 '.mdl'],'mod_2.mdl','f') copyfile([fpath,'mod_3' s1 '.mdl'],'mod_3.mdl','f') copyfile([fpath,'mod_lti' s1 '.mdl'],'mod_lti.mdl','f') end

38

catch errordlg({'Sorry, the current folder is a read-only one,'; 'please try another one'},'Error in working folder')endhandles.output = hObject;guidata(hObject, handles);assignin('base','t_seq',0); assignin('base','y_seq',1); assignin('base','keyCriterion',1); assignin('base','Kp',1); assignin('base','Ki',1); assignin('base','Kd',1);set(handles.hEdtConPars,'String','');str='pidctrl_model.mdl.autosave'; h=dir; for i=3:length(h) if strcmp(str,h(i).name), delete(str); break; endendload_system('pidctrl_model')mod_name=get_param('pidctrl_model/Plant Model','ModelNameDialog');set(handles.hEdtPlant,'String',mod_name); % --- Outputs from this function are returned to the command line.function varargout = optimpid_OutputFcn(hObject, eventdata, handles) varargout{1} = handles.output; function hEdtPlant_Callback(hObject, eventdata, handles)mod_name=get(handles.hEdtPlant,'String');set_param('pidctrl_model/Plant Model','ModelNameDialog',mod_name);load_system(mod_name);set_param(mod_name,'InlineParams','on'); % --- Executes on selection change in hListCriterion.function hListCriterion_Callback(hObject, eventdata, handles)assignin('base','keyCriterion',get(handles.hListCriterion,'Value')); function hBtnShowModel_Callback(hObject, eventdata, handles)open_system(get(handles.hEdtPlant,'String')); function hBtnFile_Callback(hObject, eventdata, handles)[FileN,PathN]=uigetfile('*.mdl','Select a plant model');set(handles.hEdtPlant,'String',FileN);hEdtPlant_Callback(hObject, eventdata, handles); function hBtnShow_Callback(hObject, eventdata, handles)str=get(handles.hBtnCreate,'UserData'); edit(str)

39

function hBtnOptim_Callback(hObject, eventdata, handles)set_param('pidctrl_model/Scope','Open','on');str=get(handles.hBtnCreate,'UserData');if length(str)==0 | exist(str)~=2 errordlg({'Error: No objective function file existing. Click ''Create '; 'File'' button to create it first.'},'Error in objective function file'); returnendff=msgbox({'Optimization process is going on. Go back to the Command Window'; 'for optimalization results. Please wait ...'},'Optimizing ...');options=optimset(...%'Display','iter', 'Jacobian','off','LargeScale','off','MaxIter',20);str=get(handles.hBtnCreate,'UserData'); kTool=get(handles.hLstAlgorithm,'Value'); n=get(handles.hLstPIDType,'UserData'); X1=ones(n,1);if get(handles.hChkHold,'Value')==1 set(handles.hEdtTerm,'String',get(handles.hEdtEnd,'String')) hBtnCreate_Callback(hObject, eventdata, handles) assignin('base','t_seq',eval(get(handles.hEdtTSeq,'String'))); assignin('base','y_seq',eval(get(handles.hEdtYSeq,'String')));else assignin('base','t_seq',0); assignin('base','y_seq',1);endx0s=get(handles.hEdtConPars,'String'); y0=1e10; yy=1e5;if length(x0s)==0, x0=rand(n,1); else, x0=eval(x0s); endxa=get(handles.hEdtConLow,'String'); kLBounds=0;if length(xa)==0, if kTool==3, xm=0.01*X1; else, xm=-inf*X1; endelse, xm=eval(xa); kLBounds=1; if prod(size(xm))==1, xm=xm*X1; end endxa=get(handles.hEdtConUp,'String');if length(xa)==0, if kTool==3, xM=10*X1; else, xM=inf*X1; endelse, xM=eval(xa); kLBounds=1; if prod(size(xM))==1, xM=xM*X1; end endx0=[x0(:); rand(2,1)]; x0=x0(1:n);switch kTool case 1 tol=eval(get(handles.edtTol,'String')); while abs(y0-yy)>tol, y0=yy; if kLBounds==0

40

eval(['[x0,yy]=fminsearch(@',str,',x0,options)']) else eval(['[x0,yy]=fmincon(@',str,',x0,[],[],[],[],xm,xM,[],options)']) end set(handles.hTxtCrit,'String',num2str(yy)); if get(handles.chkLoop,'Value')==0, break; end end case 2 if kLBounds==0 eval(['[x0,yy]=ga(@' str ',n)']); else eval(['[x0,yy]=ga(@' str ',n,[],[],[],[],xm,xM)']); end eval([str '(x0)']) case 3 if kLBounds==0, xm=-xM; end x0=gaopt([xm xM],str), eval([str '(x0(1:end-1))']), yy=-x0(end); case 4 if kLBounds==0 eval(['x0=pso_Trelea_vectorized(''' str ''',n)']); else eval(['x0=pso_Trelea_vectorized(''' str ''',n,4,[xm xM])']); end eval(['yy=' str '(x0)']) case 5 if kLBounds==0 eval(['[x0,yy]=simulannealbnd(@',str,',x0)']) else eval(['[x0,yy]=simulannealbnd(@',str,',x0,[xm xM])']) end eval([str '(x0)']) case 6 if kLBounds==0 eval(['[x0,yy]=patternsearch(@',str,',x0)']) else eval(['[x0,yy]=patternsearch(@',str,',x0,[],[],[],[],[xm xM])']) end eval([str '(x0)'])endset(handles.hEdtConPars,'String',['[' num2str(x0(:).') ']']);set(handles.hTxtCrit,'String',num2str(yy));pause(0.0001); delete(ff); function hBtnRefresh_Callback(hObject, eventdata, handles)set(handles.hEdtConPars,'String','');

41

for i=0:1000 try str=['optpidfun_' int2str(i)]; if exist(str)==2, delete([str '.m']); end catch errordlg({'Error deleting files ';lasterr},'Error'); endend function hBtnSimulation_Callback(hObject, eventdata, handles)try t_seq=eval(get(handles.hEdtTSeq,'String')); y_seq=eval(get(handles.hEdtYSeq,'String')); t_end=eval(get(handles.hEdtEnd,'String'))catch errordlg('Syntax errors in the multi-stairs vectors','Error...')endif length(t_seq)~=length(y_seq) errordlg('Lengths mismatch in the multi-stairs vectors','Error...')endassignin('base','t_seq',t_seq);assignin('base','y_seq',y_seq);set_param('pidctrl_model/Scope','Open','on');[tt,xx,yy]=sim('pidctrl_model',[0,t_end]);set(handles.hTxtCrit,'String',num2str(yy(end,1))) function hEdtLower_Callback(hObject, eventdata, handles)set_saturation(handles) function hEdtUpper_Callback(hObject, eventdata, handles)set_saturation(handles) function hRadioCon_Callback(hObject, eventdata, handles)set(handles.hRadioDis,'Value',0)set(handles.hRadioCon,'Value',1)set([handles.hTxtSamp,handles.hEdtSamp],'Visible','off');set_param('pidctrl_model/PID Controller','TimeDomain','Continuous-time'); function hRadioDis_Callback(hObject, eventdata, handles)set(handles.hRadioCon,'Value',0)set(handles.hRadioDis,'Value',1)set([handles.hTxtSamp,handles.hEdtSamp],'Visible','on');T=get(handles.hEdtSamp,'String');set_param('pidctrl_model/PID Controller','TimeDomain','Discrete-time');set_param('pidctrl_model/PID Controller','SampleTime',T);

42

function hEdtSamp_Callback(hObject, eventdata, handles)set_param('pidctrl_model/PID Controller','SampleTime',get(handles.hEdtSamp,'String')); function hBtnInfty_Callback(hObject, eventdata, handles)set(handles.hEdtUpper,'String','inf');set_saturation(handles) function hBtnNInfty_Callback(hObject, eventdata, handles)set(handles.hEdtLower,'String','-inf');set_saturation(handles) function hBtnCreate_Callback(hObject, eventdata, handles)k=0;while 1 str=['optpidfun_' int2str(k)]; if ~any([2 3 5 6]==exist(str)), break; end k=k+1;endtry fid=fopen([str,'.m'],'w'); kTool=get(handles.hLstAlgorithm,'Value'); if kTool==3 % if GAOT is used, rewrite the objective function fprintf(fid,'function [x,y]=%s(x,opts)\r\n',str); else fprintf(fid,'function y=%s(x)\r\n',str); end t_end=eval(get(handles.hEdtTerm,'String')); fprintf(fid,'%% %s An objective function for optimal PID controller tuning\r\n',upper(str)); fprintf(fid,'%% It describes the relationship between the PID controller parameters\r\n'); fprintf(fid,'%% and the chosen performance index.\r\n\r\n'); fprintf(fid,'%% The function is automatically created by PID Controller Optimizer.\r\n'); fprintf(fid,'%% Date of creation %s\r\n',date); strP=['Kp';'Ki';'Kd']; fprintf(fid,'opt=simset(''OutputVariables'',''y'');\r\n'); switch get(handles.hLstPIDType,'Value') case 1, vv=1; n=1; case {2,6}, vv=[1,2]; n=2; case 3, vv=[1,3]; n=2; case {4,7}, vv=[1,2,3]; n=3; case 5, vv=[2]; n=1; end set(handles.hLstPIDType,'UserData',n); ss='';

43

if kTool==4 fprintf(fid,'for i=1:size(x,1)\r\n'); ss=' '; end for i=1: length(vv) if kTool==4 fprintf(fid,' assignin(''base'',''%s'',x(i,%d));\r\n',strP(vv(i),:), i); else fprintf(fid,'assignin(''base'',''%s'',x(%d));\r\n',strP(vv(i),:), i); end end fprintf(fid,[ss,'try\r\n']); fprintf(fid,[ss,' [~,~,y_out]=sim(''pidctrl_model'',[0,%f],opt);\r\n'],t_end); fprintf(fid,[ss,'catch, y_out=1e10; end\r\n']); switch kTool case {1,2,5,6}, fprintf(fid,'y=y_out(end,1);\r\n'); if get(handles.chkOvershoot,'Value')==1 ss=eval(get(handles.edtOvershoot,'String'))*0.01+1; fprintf(fid,'if any(y_out(:,2)>%5.2f*y_out(:,4)), ',ss) fprintf(fid,'y=1.5*y; end\r\n') end case 3, fprintf(fid,'y=-y_out(end,1);\r\n'); case 4, fprintf(fid,' y(i,1)=y_out(end,1);\r\n'); fprintf(fid,'end\r\n'); end fclose(fid); set(handles.hBtnCreate,'UserData',str); edit(str); figure(handles.hMainPID)catch errordlg('The current working folder is read-only, try another one','Error...')end function hBtnHelp_Callback(hObject, eventdata, handles)web(['file:' which('pid_optimizer.htm')]) function hBtnExit_Callback(hObject, eventdata, handles)close_system('pidctrl_model',0); delete(gcf) function hMainPID_CloseRequestFcn(hObject, eventdata, handles)close_system('pidctrl_model',0); delete(gcf) function hLstPIDType_Callback(hObject, eventdata, handles)

44

key=get(handles.hLstPIDType,'Value'); contype={'P','PI','PD','PID','I','PI','PID'};set_param('pidctrl_model/PID Controller','Controller',contype{key});if key<=5 set_param('pidctrl_model/PID Controller','AntiWindupMode','none');else set_param('pidctrl_model/PID Controller','AntiWindupMode','clamping');end function set_saturation(handles)v1s=get(handles.hEdtLower,'String'); v1=isfinite(eval(v1s));v2s=get(handles.hEdtUpper,'String'); v2=isfinite(eval(v2s)); v1v2=v1|v2;set_param('pidctrl_model/PID Controller','LimitOutput',onoff(v1v2));set_param('pidctrl_model/PID Controller','UpperSaturationLimit',v2s)set_param('pidctrl_model/PID Controller','LowerSaturationLimit',v1s) function hLstAlgorithm_Callback(hObject, eventdata, handles)kAlgorithm=get(hObject,'Value'); key=0; str={'Global Optimization'; 'GAOT'; 'PSOt'};switch kAlgorithm case {2,5,6} if exist('ga')~=2, key=1; end case 3 if exist('gaopt')~=2, key=1; end case 4 if exist('pso_Trelea_vectorized')~=2, key=1; endendif key==1 set(hObject,'Value',1); errordlg({['Warning: The ' str{kAlgorithm-1} ' Toolbox is not available on your path.']; 'The default toolbox is selected instead.'},'Warning')end function hChkHold_Callback(hObject, eventdata, handles)set(handles.hEdtTerm,'String',get(handles.hEdtEnd,'String')) function hEdtYSeq_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white');

45

endfunction hLstPIDType_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white');endfunction hEdtTerm_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white');endfunction hEdtTSeq_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white');endfunction hEdtSamp_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white');endfunction hListCriterion_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white');endfunction hLstAlgorithm_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white');endfunction hEdtUpper_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white');endfunction hEdtLower_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white');endfunction hEdtPlant_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white');endfunction hEdtEnd_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))

46

set(hObject,'BackgroundColor','white');endfunction hEdtConLow_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white');endfunction hEdtConUp_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white');endfunction hEdtConPars_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white');endfunction chkLoop_Callback(hObject, eventdata, handles)function edtTol_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white');endfunction chkOvershoot_Callback(hObject, eventdata, handles)function edtOvershoot_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white');end function hEdtYSeq_Callback(hObject, eventdata, handles)evaluation_check(hObject, eventdata, handles) function hEdtTSeq_Callback(hObject, eventdata, handles)evaluation_check(hObject, eventdata, handles) function hEdtEnd_Callback(hObject, eventdata, handles)evaluation_check(hObject, eventdata, handles) function hEdtTerm_Callback(hObject, eventdata, handles)evaluation_check(hObject, eventdata, handles) function hEdtConLow_Callback(hObject, eventdata, handles)evaluation_check(hObject, eventdata, handles) function hEdtConUp_Callback(hObject, eventdata, handles)evaluation_check(hObject, eventdata, handles) function hEdtConPars_Callback(hObject, eventdata, handles)

47

evaluation_check(hObject, eventdata, handles) function edtOvershoot_Callback(hObject, eventdata, handles)evaluation_check(hObject, eventdata, handles) function edtTol_Callback(hObject, eventdata, handles)evaluation_check(hObject, eventdata, handles) function evaluation_check(hObject, eventdata, handles)try vs=get(hObject,'String'); if length(vs)>0, v=eval(vs); endcatch errordlg('Error in the Edit Box, try again','Error...')endfunction str=onoff(val)if val==0, str='off'; else, str='on'; end

48

Appendix B

Conventional_PID.m

% This Matlab code simulates a PID controller for a fisrt order time delay system % G(s) = (K*e(-theta*s))/(T*s+1) % Derick Suranga Widanalage% Graduate Student% Faculty of Engineering and Applied Sciences% Memorial University of Newfoundland% St John's, NL, A1B3X5% Canada clear all; clc; T=567; K=7.91; theta= 63; % System Parametersrefe = 40; % Reference to followTf = 2000; % Simulation timeyold = 0;yold1=0;yp = []; ys_prime = [];er = refe; % Error (Initial error = Reference) er1 = 0; % First derivative of errorer2 = 0; % Second derivative of erroreold = refe; eold2 = 0;dt = 1;for i=1:dt:Tf dtspan = [i i+dt]; eold2 = eold ; eold = er; er = refe - yold; er2 = er + eold2 - 2*eold; er1 = er - eold; init_con = [yold ; (yold-yold1)]; % Initial conditions for the diffirential equations options = []; [t,y] = ode45(@pid_ctrl,dtspan,init_con,options,er,er1,er2); yold1 = yold; ys = y(length(y),1); if i <= theta ys_prime = [0 ys_prime]; else ys_prime = [ys ys_prime]; end

49

yold = ys_prime(1); yp = [yp yold];end plot(yp);xlabel('Time');ylabel('Output');title('Output of the system with PID Controller');grid on;

50

Appendix C

Conventional_PID_call .m

function yprime = pid_ctrl(t,y,er,er1,er2) T=567; K=7.91; % System parametrsKp = 1.095; Ki = 0.005; Kd = 0; % PID Controller parametrs yprime = [y(2); ((1/T)*(-y(2)+ K*Kd*er2 + K*Kp*er1 + K*Ki*er))];

51