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 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

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

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.

45 40 35 30
63.2%

T e m p e ra tu re (C )

25 20 15 10 5 0 0 200 400 600 800 1000 1200 T im e in s e c 1400 1600 1800 2000

28.3%

t1

t2

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 -

The PI controller settings are Kc = 0.9 * kptd

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.

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)) The internal mechanism of the FLC translates it into a mapping: u(k) = f(e(k), e(k)) This relation is similar to conventional PI controller as u(k) = Kp e(k) + Ki e(k) (3) (2) (1)

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

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 Process output Error e(k) : : : r(k) y(k) r(k) y(k)

Change in error Input variables Output variables

e(k)

: : : : : :

e(k) e(k-1) Error e and change of error e Change of u Triangular with 50% overlapping Center Of Gravity (OCG) method [-1 1] [-1 1] [-0.01 0.01]

Membership function type Defuzzification method The range of error The range of change in error:

The range of change in output:

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 e e 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

Membership value ()

Figure: 3 Membership diagram for error

Membership value ()

Figure: 4 Membership diagram for change in error

Membership value ()

Figure: 5 Membership diagram for change in output

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 parents 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 DECODE

Converts base 10 to base 2 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 MATE MUTATE REPRODUC TESTGEN XOVER

Graphing routine for genetic algorithm Randomly reorders (mates) OLD_GEN Change a gene of the OLD_GEN with probability Pm Selects individuals proportional to their fitness Tests genetic algorithm code with f(x) = x10 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., Newtons 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 K c 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 = 0.9 * kptd

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 0.9 * kptd 0.9 * 567 7.91* 63

Kc =

Kc =

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 precomposed 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

70 60 50 T e m p e ra tu re (C ) 40 30 20 10 0 in p u t o u tp u t

500

1000

1500 T im e in s e c

2000

2500

3000

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

70 60 50 T e m p e ra tu re (C ) 40 30 20 10 0 in p u t o u tp u t

500

1000

1500 T im e in s e c

2000

2500

3000

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

70 60 50 T e m p e ra tu re (C ) 40 30 20 10 0 in p u t o u tp u t

500

1000

1500 T im e in s e c

2000

2500

3000

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 Conventional PI controller Fuzzy logic PI controller Genetic algorithm optimal PI controller ISE 204767.95 206025.29 184767.95 ts (secs) 1350 1470 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), 152155. [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.m
function 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 EDIT gui_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}); end if 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'; end try 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') end handles.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; end end load_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'); return end ff=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); end x0s=get(handles.hEdtConPars,'String'); y0=1e10; yy=1e5; if length(x0s)==0, x0=rand(n,1); else, x0=eval(x0s); end xa=get(handles.hEdtConLow,'String'); kLBounds=0; if length(xa)==0, if kTool==3, xm=0.01*X1; else, xm=-inf*X1; end else, xm=eval(xa); kLBounds=1; if prod(size(xm))==1, xm=xm*X1; end end xa=get(handles.hEdtConUp,'String'); if length(xa)==0, if kTool==3, xM=10*X1; else, xM=inf*X1; end else, xM=eval(xa); kLBounds=1; if prod(size(xM))==1, xM=xM*X1; end end x0=[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)']) end set(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'); end end 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...') end if length(t_seq)~=length(y_seq) errordlg('Lengths mismatch in the multi-stairs vectors','Error...') end assignin('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','Discretetime'); 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; end try 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',s trP(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; end end if 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

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

46

set(hObject,'BackgroundColor','white'); end function hEdtConLow_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function hEdtConUp_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function hEdtConPars_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function chkLoop_Callback(hObject, eventdata, handles) function edtTol_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function 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); end catch errordlg('Error in the Edit Box, try again','Error...') end function 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 Parameters refe = 40; % Reference to follow Tf = 2000; % Simulation time yold = 0;yold1=0; yp = []; ys_prime = []; er = refe; % Error (Initial error = Reference) er1 = 0; % First derivative of error er2 = 0; % Second derivative of error eold = 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 parametrs Kp = 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