FUZZY LOGIC - AN INTRODUCTION

PART 1

WHERE DID FUZZY LOGIC COME FROM?

The concept of Fuzzy Logic (FL) was conceived at the beginning of the 70s by Lotfi Zadeh, a professor at the University of California at Berkley, and presented not as a control methodology, but as a way of processing data by allowing partial set membership rather than crisp set membership or non-membership. This approach to set theory was not applied to control systems until the 70's due to insufficient small-computer capability prior to that time. Professor Zadeh reasoned that people do not require precise, numerical information input, and yet they are capable of highly adaptive control. If feedback controllers could be programmed to accept noisy, imprecise input, they would be much more effective and perhaps easier to implement.

WHAT IS FUZZY LOGIC?

In this context, FL is a problem-solving control system methodology that lends itself to implementation in systems ranging from simple, small, embedded micro-controllers to large, networked, multi-channel PC or workstation-based data acquisition and control systems. It can be implemented in hardware, software, or a combination of both. FL provides a simple way to arrive at a definite conclusion based upon vague, ambiguous, imprecise, noisy, or missing input information. FL's approach to control problems mimics how a person would make decisions, only much faster.

HOW IS FL DIFFERENT FROM CONVENTIONAL CONTROL METHODS?

FL incorporates a simple, rule-based IF X AND Y THEN Z approach to a solving control problem rather than attempting to model a system mathematically. The FL model is empirically-based, relying on an operator's experience rather than their technical understanding of the system. For example, rather than dealing with temperature control in terms such as "SP =500F", "T <1000F", or "210C <TEMP <220C", terms like "IF (process is too cool) AND (process is getting colder) THEN (add heat to the process)" or "IF (process is too hot) AND (process is heating rapidly) THEN (cool the process quickly)" are used. These terms are imprecise and yet very descriptive of what must actually happen. Consider what you do in the shower if the temperature is too cold: you will make the water comfortable very quickly with little trouble. FL is capable of mimicking this type of behavior but at very high rate.

HOW DOES FL WORK?

FL requires some numerical parameters in order to operate such as what is considered significant error and significant rate-of-change-of-error, but exact values of these numbers are usually not critical unless very responsive performance is required in which case empirical tuning would determine them. For example, a simple temperature control

system could use a single temperature feedback sensor whose data is subtracted from the command signal to compute "error" and then time-differentiated to yield the error slope or rate-of-change-of-error, hereafter called "error-dot". Error might have units of degs F and a small error considered to be 2F while a large error is 5F. The "error-dot" might then have units of degs/min with a small error-dot being 5F/min and a large one being 15F/min. These values don't have to be symmetrical and can be "tweaked" once the system is operating in order to optimize performance. Generally, FL is so forgiving that the system will probably work the first time without any tweaking.

FUZZY LOGIC - AN INTRODUCTION

PART 2

WHY USE FL?FL offers several unique features that make it a particularly good choice for many control problems. 1) It is inherently robust since it does not require precise, noise-free inputs and can be programmed to fail safely if a feedback sensor quits or is destroyed. The output control is a smooth control function despite a wide range of input variations.

2) Since the FL controller processes user-defined rules governing the target control system, it can be modified and tweaked easily to improve or drastically alter system performance. New sensors can easily be incorporated into the system simply by generating appropriate governing rules.

3) FL is not limited to a few feedback inputs and one or two control outputs, nor is it necessary to measure or compute rate-of-change parameters in order for it to be implemented. Any sensor data that provides some indication of a system's actions and reactions is sufficient. This allows the sensors to be inexpensive and imprecise thus keeping the overall system cost and complexity low.

4) Because of the rule-based operation, any reasonable number of inputs can be processed (1-8 or more) and numerous outputs (1-4 or more) generated.

5) FL can control nonlinear systems that would be difficult or impossible to model mathematically.

HOW IS FL USED?1) Define the control objectives and criteria: What am I trying to control? What do I have to do to control the system? What kind of response do I need? What are the possible (probable) system failure modes?2) Determine the input and output relationships and choose a minimum number of variables for input to the FL engine (typically error and rate-of-change-of-error).3) Using the rule-based structure of FL, break the control problem down into a series of IF X AND Y THEN Z rules that define the desired system output response for given

system input conditions. The number and complexity of rules depends on the number of input parameters that are to be processed and the number fuzzy variables associated with each parameter. If possible, use at least one variable and its time derivative. Although it is possible to use a single, instantaneous error parameter without knowing its rate of change, this cripples the system's ability to minimize overshoot for a step inputs.4) Create FL membership functions that define the meaning (values) of Input/Output terms used in the rules.5) Create the necessary pre- and post-processing FL routines if implementing in S/W, otherwise program the rules into the FL H/W engine.6) Test the system, evaluate the results, tune the rules and membership functions, and retest until satisfactory results are obtained.

LINGUISTIC VARIABLES

In 1973, Professor Lotfi Zadeh proposed the concept of linguistic or "fuzzy" variables. Think of them as linguistic objects or words, rather than numbers. The sensor input is a noun, e.g. "temperature", "displacement", "velocity", "flow", "pressure", etc. Since error is just the difference, it can be thought of the same way. The fuzzy variables themselves are adjectives that modify the variable (e.g. "large positive" error, "small positive" error,"zero" error, "small negative" error, and "large negative" error). As a minimum, one could simply have "positive", "zero", and "negative" variables for each of the parameters. Additional ranges such as "very large" and "very small" could also be added to extend the responsiveness to exceptional or very nonlinear conditions, but aren't necessary in a basic system.

FUZZY LOGIC - AN INTRODUCTION

PART 3

THE RULE MATRIX

In the last article the concept of linguistic variables was presented. The fuzzy parameters of error (command-feedback) and error-dot (rate-of-change-of-error) were modified by the adjectives "negative", "zero", and "positive". To picture this, imagine the simplest practical implementation, a 3-by-3 matrix. The columns represent "negative error", "zero error", and "positive error" inputs from left to right. The rows represent "negative", "zero", and "positive" "error-dot" input from top to bottom. This planar construct is called a rule matrix. It has two input conditions, "error" and "error-dot", and one output

response conclusion (at the intersection of each row and column). In this case there are nine possible logical product (AND) output response conclusions.

Although not absolutely necessary, rule matrices usually have an odd number of rows and columns to accommodate a "zero" center row and column region. This may not be needed as long as the functions on either side of the center overlap somewhat and continuous dithering of the output is acceptable since the "zero" regions correspond to "no change"

_________

000

000

output responses the lack of this region will cause the system to continually hunt for "zero". It is also possible to have a different number of rows than columns. This occurs when numerous degrees of inputs are needed. The maximum number of possible rules is simply the product of the number of rows and columns, but definition of all of these rules may not be necessary since some input conditions may never occur in practical operation. The primary objective of this construct is to map out the universe of possible inputs while keeping the system sufficiently under control.

STARTING THE PROCESS

The first step in implementing FL is to decide exactly what is to be controlled and how. For example, suppose we want to design a simple proportional temperature controller with an electric heating element and a variable-speed cooling fan. A positive signal output calls for 0-100 percent heat while a negative signal output calls for 0-100 percent cooling. Control is achieved through proper balance and control of these two active devices.

Figure 1 - A simple block diagram of the control system.It is necessary to establish a meaningful system for representing the linguistic variables in the matrix.

Define the minimum number of possible input product combinations and corresponding output response conclusions using these terms. For a three-by-three matrix with heating and cooling output responses, all nine rules will need to be defined. The conclusions to the rules with the linguistic variables associated with the output response for each rule are transferred to the matrix.

WHAT IS BEING CONTROLLED AND HOW:

Figure 2 - Typical control system responseFigure 2 shows what command and error look like in a typical control system relative to

the command setpoint as the system hunts for stability.

Linguistic rules describing the control system consist of two parts; an antecedent block (between the IF and THEN) and a consequent block (following THEN). Depending on the system, it may not be necessary to evaluate every possible input combination (for 5-by-5 & up matrices) since some may rarely or never occur. By making this type of evaluation, usually done by an experienced operator, fewer rules can be evaluated, thus simplifying the processing logic and perhaps even improving the FL system performance.

Figures 3 & 4 - The rule structure.

After transferring the conclusions from rules to the matrix there is a noticeable symmetry to the matrix. This suggests (but doesn't guarantee) a reasonably well-behaved (linear) system. This implementation may prove to be too simplistic for some control problems, however it does illustrate the process. Additional degrees of error and error-dot may be included if the desired system response calls for this. This will increase the rulebase size and complexity but may also increase the quality of the control. Figure 4 shows the rule matrix derived from the previous rules.

SUMMARY

Linguistic variables are used to represent an FL system's operating parameters. The rule matrix is a simple graphical tool for mapping the FL control system rules. It accommodates two input variables and expresses their logical product (AND) as one output response variable. To use, define the system using plain-English rules based upon the inputs, decide appropriate output response conclusions, and load these into the rule matrix.

FUZZY LOGIC - AN INTRODUCTION

PART 4

MEMBERSHIP FUNCTIONS

In the last article, the rule matrix was introduced and used. The next logical question is how to apply the rules. This leads into the next concept, the membership function.

The membership function is a graphical representation of the magnitude of participation of each input. It associates a weighting with each of the inputs that are processed, define functional overlap between inputs, and ultimately determines an output response. The rules use the input membership values as weighting factors to determine their influence on the fuzzy output sets of the final output conclusion. Once the functions are inferred, scaled, and combined, they are defuzzified into a crisp output which drives the system. There are different membership functions associated with each input and output response. Some features to note are:

SHAPE - triangular is common, but bell, trapezoidal, haversine and, exponential have been used. More complex functions are possible but require greater computing overhead to implement. HEIGHT or magnitude (usually normalized to 1) WIDTH (of the base of function), SHOULDERING (locks height at maximum if an outer function. Shouldered functions evaluate as 1.0 past their center) CENTER points (center of the member function shape) OVERLAP (N&Z, Z&P, typically about 50% of width but can be less).

Figure 5 - The features of a membership function Figure 5 illustrates the features of the triangular membership function which is used in this example because of its mathematical simplicity. Other shapes can be used but the triangular shape lends itself to this illustration.

The degree of membership (DOM) is determined by plugging the selected input parameter (error or error-dot) into the horizontal axis and projecting vertically to the upper boundary of the membership function(s).

ERROR & ERROR-DOT FUNCTION MEMBERSHIP

The degree of membership for an "error" of -1.0 projects up to the middle of the overlapping part of the "negative" and "zero" function so the result is "negative" membership = 0.5 and "zero" membership = 0.5. Only rules associated with "negative" & "zero" error will actually apply to the output response. This selects only the left and middle columns of the rule matrix.

For an "error-dot" of +2.5, a "zero" and "positive" membership of 0.5 is indicated. This selects the middle and bottom rows of the rule matrix. By overlaying the two regions of the rule matrix, it can be seen that only the rules in the 2-by-2 square in the lower left corner (rules 4,5,7,8) of the rules matrix will generate non-zero output conclusions. The others have a zero weighting due to the logical AND in the rules.

FUZZY LOGIC - AN INTRODUCTION

PART 5

PUTTING IT ALL TOGETHER

As inputs are received by the system, the rulebase is evaluated. The antecedent (IF X AND Y) blocks test the inputs and produce conclusions. The consequent (THEN Z) blocks of some rules are satisfied while others are not. The conclusions are combined to form logical sums. These conclusions feed into the inference process where each response output member function's firing strength (0 to 1) is determined.

Figure 7 - Degree of membership for the error and error-dot functions in the current example

Data summary from previous illustrations:

INPUT DEGREE OF MEMBERSHIP

"error" = -1.0: "negative" = 0.5 and "zero" = 0.5 "error-dot" = +2.5: "zero" = 0.5 and "positive" = 0.5

ANTECEDENT & CONSEQUENT BLOCKS (e = error, er = error-dot or error-rate)

Now referring back to the rules, plug in the membership function weights from above. "Error" selects rules 1,2,4,5,7,8 while "error-dot" selects rules 4 through 9. "Error" and "error-dot" for all rules are combined to a logical product (LP or AND, that is the minimum of either term). Of the nine rules selected, only four (rules 4,5,7,8) fire or have non-zero results. This leaves fuzzy output response magnitudes for only "Cooling" and "No_Change" which must be inferred, combined, and defuzzified to return the actual crisp output. In the rule list below, the following ddefinitions apply: (e)=error, (er)=error-dot.

1. If (e < 0) AND (er < 0) then Cool 0.5 & 0.0 = 0.0 2. If (e = 0) AND (er < 0) then Heat 0.5 & 0.0 = 0.0 3. If (e > 0) AND (er < 0) then Heat 0.0 & 0.0 = 0.0 4. If (e < 0) AND (er = 0) then Cool 0.5 & 0.5 = 0.5 5. If (e = 0) AND (er = 0) then No_Chng 0.5 & 0.5 = 0.5 6. If (e > 0) AND (er = 0) then Heat 0.0 & 0.5 = 0.0 7. If (e < 0) AND (er > 0) then Cool 0.5 & 0.5 = 0.5 8. If (e = 0) AND (er > 0) then Cool 0.5 & 0.5 = 0.5 9. If (e > 0) AND (er > 0) then Heat 0.0 & 0.5 = 0.0

FUZZY LOGIC - AN INTRODUCTION

PART 6

INFERENCING

The last step completed in the example in the last article was to determine the firing strength of each rule. It turned out that rules 4, 5, 7, and 8 each fired at 50% or 0.5 while rules 1, 2, 3, 6, and 9 did not fire at all (0% or 0.0). The logical products for each rule must be combined or inferred (max-min'd, max-dot'd, averaged, root-sum-squared, etc.) before being passed on to the defuzzification process for crisp output generation. Several inference methods exist.

The MAX-MIN method tests the magnitudes of each rule and selects the highest one. The horizontal coordinate of the "fuzzy centroid" of the area under that function is taken as the output. This method does not combine the effects of all applicable rules but does produce a continuous output function and is easy to implement.

The MAX-DOT or MAX-PRODUCT method scales each member function to fit under its respective peak value and takes the horizontal coordinate of the "fuzzy" centroid of the composite area under the function(s) as the output. Essentially, the member function(s) are shrunk so that their peak equals the magnitude of their respective function

("negative", "zero", and "positive"). This method combines the influence of all active rules and produces a smooth, continuous output.

The AVERAGING method is another approach that works but fails to give increased weighting to more rule votes per output member function. For example, if three "negative" rules fire, but only one "zero" rule does, averaging will not reflect this difference since both averages will equal 0.5. Each function is clipped at the average and the "fuzzy" centroid of the composite area is computed.

The ROOT-SUM-SQUARE (RSS) method combines the effects of all applicable rules, scales the functions at their respective magnitudes, and computes the "fuzzy" centroid of the composite area. This method is more complicated mathematically than other methods, but was selected for this example since it seemed to give the best weighted influence to all firing rules.

DEFUZZIFICATION - GETTING BACK TO CRISP NUMBERS

The RSS method was chosen to include all contributing rules since there are so few member functions associated with the inputs and outputs. For the ongoing example, an error of -1.0 and an error-dot of +2.5 selects regions of the "negative" and "zero" output membership functions. The respective output membership function strengths (range: 0-1) from the possible rules (R1-R9) are:

A "FUZZY CENTROID" ALGORITHM

The defuzzification of the data into a crisp output is accomplished by combining the results of the inference process and then computing the "fuzzy centroid" of the area. The weighted strengths of each output member function are multiplied by their respective output membership function center points and summed. Finally, this area is divided by the sum of the weighted member function strengths and the result is taken as the crisp output. One feature to note is that since the zero center is at zero, any zero strength will automatically compute to zero. If the center of the zero function happened to be offset from zero (which is likely in a real system where heating and cooling effects are not perfectly equal), then this factor would have an influence.

Figure 8 - The horizontal coordinate of the centeriod is taken as the crisp output

The horizontal coordinate of the centroid of the area marked in Figure 8 is taken as the normalized, crisp output. This value of -63.4% (63.4% Cooling) seems logical since the particular input conditions (Error=-1, Error-dot=+2.5) indicate that the feedback has exceeded the command and is still increasing therefore cooling is the expected and required system response.

TUNING AND SYSTEM ENHANCEMENT

Tuning the system can be done by changing the rule antecedents or conclusions, changing the centers of the input and/or output membership functions, or adding additional degrees to the input and/or output functions such as "low", "medium", and "high" levels of "error", "error-dot", and output response. These new levels would generate additional rules and membership functions which would overlap with adjacent functions forming longer "mountain ranges" of functions and responses. The techniques for doing this systematically are a subject unto itself.

CONCLUSION

Fuzzy Logic provides a completely different, unorthodox way to approach a control problem. This method focuses on what the system should do rather than trying to understand how it works. One can concentrate on solving the problem rather than trying to model the system mathematically, if that is even possible. This almost invariably leads to quicker, cheaper solutions. Once understood, this technology is not difficult to apply and the results are usually quite surprising and pleasing.

FUZZY TOOLBOX

Matlab is used for implementing fuzzy relations and sets. The Matlab toolbox and

simulink helps the user to view the real time simulations and how the fuzzy logic

works and can be applied for different fields.

The inbuilt fuzzy logic toolbox will pop up when you type fuzzy at the command

prompt. This toolbox has been developed in the Matlab using some predefined

basic functions using the Matlab’s GUI (Graphical User Interface). We can shape

the toolbox as required with user defined functions. This project deals a particular

application. When the user possesses the rough idea of what should be the value

of input1 and Input2, the toolbox will calculate the value of output based on those

values.

Overview:

The toolbox designed may not be as good as the inbuilt fuzzy tipper, but

this is an attempt to get the best results using some programming fundamentals

and user defined functions. The toolbox is names as ‘fuzzytool1’. The toolbox

provides user to define the range of the input membership functions and the

output membership functions. This toolbox has two inputs and a single output.

The rules used are defined in ‘ft3’. In the rules window the input and output

membership functions are displayed. The membership function used here is

triangle. In most of the applications the triangle membership function is well

suited for the purpose and provides satisfactory results.

The user can define the input1 and input2 values and check the output

value and membership function from the rule window. This method is universally

accepted as the best one and proved to be giving consistent results. The user can

check the value and membership function for both AND & OR methods. The

AND method works as min function and OR works as max function. The clipping

method is used in the design process for obtaining output.

The Fuzzy tool window:

Fig. 1

The Fig. 1 shows the, main window when fuzzy tool box is started by typing ‘Fuzzytool1’ at the Matlab prompt (>>). It displays the type of membership functions used for the two inputs viz. Input1 & Input2 which is triangular in both the cases. Moreover the Type of membership function used for representing the output is also triangular.

If we click on the axes background of Input1, Input2, or Output we can open the window showing their characteristics membership functions and a window showing IF -Then Rules for FIS Mamdani.

The AND Method uses Min. Function, OR method uses Max. Function, implication uses Min. Function and the type of Defuzzification used is cantroid.

By clicking on the back ground of axes labeled input1 or input2 we can open a window ‘ft2’ that looks like this:

Fig. 2

‘ft2’ basically shows Membership functions of inputs and output. In both the cases, the type of membership function used is Triangular that can be seen in the MF Plots axis by clicking on input or output push buttons at the top left of the ‘ft2’ window (Fig.2).

The two panels in the same window display the properties of the variables selected.

Fig. 3

We can change the value of the parameters used to draw any of the three triangles in the corresponding edit boxes. When we press input or output buttons the changes can viewed in the display window (Fig. 4).

After changing value in any of the edit boxes press input buttons or output button, the plot will change itself accordingly as shown in Fig. 4

Fig. 4

We can see in Fig. 4 that after changing the value of the parameters in the second edit box from 7.5 to 8 directly into the edit box the green colored triangle changes accordingly. We need to press any of the push buttons labeled ‘input1’, ‘input2’, and ‘output’ on the top left of the window before toolbox can implement any change in the plot.

The Show Rules button when pressed opens a window shown in Fig. 5 that contains the IF-THEN rules and the close button closes the window.

Rules Window:

Fig. 5

The Fig. 5 shows the rules window that display all the rules used by the Fuzzy Inferences Set to come to the desired output. It provides options for Input1 and Input2 and we can set the output based on the two inputs using pop-up menus. It also provides options to choose from AND/OR methods using Radio buttons. We can select only one option from the two conjunctions.

The bottom of the window in Fig. 5 shows FIS Name and a close button that closes the window and we return back to the FIS Mamdani window.

The menu items can be used to switch to other windows in the whole application.The File menu provides options like New FIS, Exit and the Edit provides options like Rules, Membership functions, etc. Last menu item View provides options like View Rules and surface. For example, if we select Rules in the view menu, the toolbox opens ‘f4’ window that looks like what is shown in Fig. 6

The f4 window:

Fig. 6

Fig. 6 shows the main output window where we can view analyze and verify the input and output plots. There are three inputs under the label ‘input1’ & ‘input2’ and three outputs under the label ’output’. The fourth plot under the ‘output’ label provides the defuzzified output plot. This plot is used to calculate the final value of output variable.

We have the same items in the menu as in previous windows and one ‘inputs’ edit box where we can select and change input variables. The default value of input1 is ‘4’ and for input2 it is ‘7’. We can anytime change these values as per our rules.

When we press the ‘Plot’ pushbutton at the bottom of the window, we can see the plots of the membership functions of the two inputs and the output. The last plot displays the defuzzified output from where we can obtain the value of output.

The close button closes all the windows.

The Fig. 7 makes everything clear.

Fig. 7

If we want to switch back to the main window i.e. Fuzzytool1 window (Fig. 1) then we can select New FIS option from the file menu of this window or we can select ‘Exit’ to close all the windows and return to Matlab.

Important Conclusions:

This Fuzzy tool is developed using the IDE feature of the MATLAB version 7.0. It demonstrates some basic features of a Fuzzy tool box and triangular Membership function is being used to imitate the Fuzzy tipper included in the Matlab Software. It can be used for two different inputs to obtain one output. It provides options for two Fuzzy Inference Systems viz. Mamdani and Sugeno that can be selected from File menu of any windows of the application. Shortcomings: This Tool requires that the user must have the knowledge of how to plot the membership functions, like Triangular MF for Input1 or output, when to select Rules option from the edit menu and when press ‘close’ buttons without which he may get the erroneous results or he may close the application before he can see the output plots. Finally, the Fuzzy tool provides the user to work with the basic ideas of the fuzzy inference systems.

FIS-INTROUCTION

Create a Fuzzy Inference System Using Commands in M-file Step 1: In Matlab main console window, select “FileNewM File”. The M

File Editor window is pop-up. Step 2: Type the following code into your M File Editor and save it as M1.mat.

Notice that the same code can be obtained by Select “FileOpen…MFile1.mat” in M File Editor Window.

a = newfis('fis1.fis'); %create a new FIS file in "work" folder

%add and input variable 'x' into the FISa = addvar(a, 'input', 'x', [2 9]);

%remove the 3 MFs created by default when we add an input variablea = rmmf(a, 'input', 1, 'mf1', 1);a = rmmf(a, 'input', 1, 'mf2', 1);

a = rmmf(a, 'input', 1, 'mf3', 1);

%add 2 MFs into the variable xa = addmf(a, 'input', 1, 'A1', 'trimf', [2 5 8]);a = addmf(a, 'input', 1, 'A2', 'trimf', [3 6 9]);

%add and input variable 'x' into the FISa = addvar(a, 'input', 'y', [4 11]);

%remove the 3 MFs created by default when we add an input variablea = rmmf(a, 'input', 2, 'mf1', 1);a = rmmf(a, 'input', 2, 'mf2', 1);a = rmmf(a, 'input', 2, 'mf3', 1);

%add 2 MFs into the variable ya = addmf(a, 'input', 2, 'B1', 'trimf', [5 8 11]);a = addmf(a, 'input', 2, 'B2', 'trimf', [4 7 10]);

%add and output variable 'y' into the FISa = addvar(a, 'output', 'z', [1 9]);

%remove the 3 MFs created by default when we add an output variablea = rmmf(a, 'output', 1, 'mf1', 1);a = rmmf(a, 'output', 1, 'mf2', 1);a = rmmf(a, 'output', 1, 'mf3', 1);

%add 2 MFs into the variable xa = addmf(a, 'output', 1, 'C1', 'trimf', [1 4 7]);a = addmf(a, 'output', 1, 'C2', 'trimf', [3 6 9]);

%1 rule is defined and added into FISrule = [1 1 1 1 1];a = addrule(a, rule);

%The 1st '1' is mean that the 1st MF of 1st input variable will be use in this rule, in this case, A1 will be use%You can put '2' if you want to use 2nd MF of 1st input variable, use '0' if you do not wise the rule involve with 1st input variable

%The 2nd '1' is mean that the 1st MF of 2nd input variable will be use in this rule, in this case, B1 will be use%You can put '2' if you want to use 2nd MF of 1st input variable, use '0' if you do not wise the rule involve with 2nd input variable

%The 3rd '1' is mean that the 1st MF of output variable will be use in this rule, in this case, C1 will be use

%You can put '2' if you want to use 2nd MF of output variable

%The 4th '1' is mean that this rule is create and Enable, use '0' to to create the rule but Disable it.

%The 5th '1' is mean that the relationship between MF of 1st input variable and MF 2nd input variable is "AND"%Use '2' is you want it to be "OR"

%Conclusion, this will add a fule, if x is A1 and y is B1 Then z is C1

writefis(a, 'fis1.fis');

disp('A new FIS is created and save as \work\fis1.fis');disp('Type "Fuzzy fis1.fis" in console window to see the new FIS created');disp('End of the program mfile1.m');

To View the FIS created This can be done by Type “Fuzzy fis1” (the .fis in behind can be ignore). The FIS Editor will be shown as in Figure 1 below.

Figure 1

You can change the setting of the FIS here, such as change the Defuzzification to MOM rather using COA (See Figure 1).

Double Click on the part show the MFs of x in order to see (and change) the detail information of MFs of input ‘x’ created in the code as shown in Figure 2.

Same steps can be done to for variables y and z.

Select “EditRule…” to view and edit the rule added in the code above. The Rule Editor is shown in Figure 3 below.

Figure 2

Select “ViewSurface” to see the decision surface base on the rule(s) created. The Surface Viewer is shown in Figure 4 below.

Figure 3

Figure 4

Select “ViewRules” to see how to inference system work in order to product and output based on the inputs given. We can use to mouse to drag and place the red lines in order to change the inputs and to see the new output as well. See Figure 5 for detail

As a conclusion, to create a new FIS via command is slow. The FIS Edit actually can be use to create or modify FIS in very short time compare to command coding method.

Exercise: Modify the code in MFile1.m above so that it can take three rules as below.

R1: If x is A1 and y is B1 then z is C1R2: If x is A2 and y is B2 then z is C2R3: If x is A1 or y is B2 then z is C2

Solution:Modify only one line in to coderule = [1 1 1 1 1; 2 2 2 1 1; 1 2 2 1 2];

You can use FIS editor to check your answer, notice that the surface viewer will not be the same as before since rules are added.

Another way to see the result is typing command in console windows.

F = readfis(‘fis1.fis’) %Press enter key%information of the FIS will be show.Showrule(F);%the rule of this FIS will be show.

Create common FIS use for Control Systems Using FIS Editor. Step 1: Type “Fuzzy” in the Matlab console window. The FIS edit will be show. Step 2: Select ‘EditAdd VariableInput” to add the second input variable.

Figure 5

Step 3: Highlight on input1, change the name of input1 to ‘E’ (error), as shown in picture below. The rest of information is no change. See Figure 6 for detail

Step 4: Repeat step 3 for input2 become DE (change of error) and the output become U (control signal).

Step 5: Double click on the picture of MFs for variable E, as shown in area P in Figure 6, in order to shown the MFs of variable E. By default when a variable is added, 3 MFs will be automatically. See Figure 7.

Step 6: It will be easy for us to delete all the default MFs, this can be done by select “EditRemove All MFs” as shown in Figure 7. After this, no more MFs for input variable E.

Name of variable is E

Figure 6

P

QR

Step 7: Now we plan to add 7 MFs to input variable E, this can be done by select “EditAdd MFs…”. After select this, another dialog box is pop up as shown in Figure 8. Select Type MFs as gaussmf and number of MFs is 7. See Figure 8 for detail.

Figure 7

Step 8: Select OK by click on the “OK” button. Now 7 MFs have been add into input variable E as shown in Figure 9

Figure 8

Figure 9

Y

X

Step 9: Highlight the mf1 as shown in Figure 9. Change the name of mf1 to NB as shown in area X

Step 10: Repeat Step 9 for mf2 to mf7, to change their names become NM, NS, ZR, PS, PM and PB.

Step 11: Change the range of the variable to [-1 1] as shown in area Y. Step 12: Repeat Step 5 to Step 11 but for input variable DE. Step 13: Repeat Step 5 to Step 12 but for output variable U. Step 14: Select “EditRule”, the rule editor windows is shown as Figure 10.

Step 15: Add the 1st rule into rule editor base on what we have learn in Module 3. E.g the 1st rule is: If E is NB and DE is NB then U is NB

Step 16: Repeat Step 16 to create 2nd until 49th rules. Step 17: Now we can select “ViewSurfaces” to see the decision surface of this

general fuzzy logic control, or select “ViewRules” to see the inference process and the output when inputs are given.

Step 18: Select “FileExportDisk…” to save the FIS created into disk. Do type a file name when you are being as to do so. See Figure 11 for detail.

Figure 10Figure 10

Step 19: If you want the FIS to load into memory, select “FileExportWorkspace…” Do type a workspace name when you are being as to do so. See Figure 11 for detail.Step 20: Test your FIS created in console windows of Matlab, type the commands below.

>> f = readfis('fis2.fis') %Command that you type, read the fis into pointer f

f = %information show by matlab

name: 'fis2' type: 'mamdani' andMethod: 'min' orMethod: 'max' defuzzMethod: 'centroid' impMethod: 'min' aggMethod: 'max' input: [1x2 struct] output: [1x1 struct] rule: [1x49 struct]

Figure 11

>> evalfis([0.2 0.9], f) %command that you type, meaning if E = 0.2 and DE = 0.9, what is U?

ans = %answer calculated by Matlab, U = 0.7530

0.7530

A Fuzzy Logic Controller for Water bath Temperature ControlProblem statement: In this demonstration, we shall design a fuzzy logic controller for the temperature control of a water bath. The plant to be controlled is described by:

Where and . The parameters of the plant are

set as , , and . The plant input u(k) is limited to between 0 and 5 volts. The sampling period, T, is set as 25 seconds. The goal is to design a fuzzy controller what will control the water temperature to follow a reference profile as closely as possible. This reference profile is for minutes, for

minutes, for minutes and for minutes.

The input variables for this controller are chosen as e(k), de(k) where e(k) is the performance error indicating the error between the desire output and the actually output. The de(k) is the change of the error. The output of the controller is the voltage that limited to between 0 to 5 volts.

The source code is shown as below, where we use the FIS (fis2.fis) designed in previous section in this application. Notice that the same source code can be found in \work\mfile2.m

% =======================% Filename : mfile2% =======================clear; %clear the memory of matlabecho on; %to show result of every commandclc;%to clear the matlab console screen

% ===========================================================% A Fuzzy Controller for the Water Bath Temperature Control % ===========================================================

% ====================================================================% Problem Statement: To design a fuzzy controller for% the temperature control of a water bath.% The equations and the parameters of the plant% to be controlled are described in Module 3.% The goal is to design a fuzzy controller that will% control the water temperature to follow a

% reference profile as close as possible.%

% =========================================================% Notice that the FIS used is desgined using FIS editor.% =========================================================

% ===============% Test program% ===============

pause % Hit any key to begin this program.

% Read the FIS file .f = readfis('fis2.fis');

pause % Hit any key to define the plant parameters.T = 25;p = 1*10^(-4);q = 8.7*10^(-3);r = 40.0;yo = 25;y(1) = yo;a = exp(-p*T);b=(q/p)*(1-exp(-p*T));

pause % Hit any key to define the reference output.for k = 1:180 if (k <= 40) ref(k) = 35; elseif (k > 40 & k <= 80) ref(k) = 50; elseif (k > 80 & k <= 120) ref(k) = 65; elseif (k > 120) ref(k) = 80; end;end;

pause % Hit any key to define the gain constanT.GE = 1/15;GDE = 1/15;GU = 80;

pause % Hit any key to test this fuzzy controller.for k = 1:179 e(k)=(ref(k)-y(k)); %error ef(k)=e(k)*GE; %scaled of error

if k == 1 de(k) = 0; %change of error else de(k) = e(k)-e(k-1); end; def(k) = de(k)*GDE; %scaled of change of error

uf(k) = evalfis([ef(k) def(k)],f); %obtain the control signal using FIS base on the error and change of error u(k) = uf(k)*GU; %scale it back

%because in real world the control signal shall be in between 0 to 5 volt if (u(k)>=5) u(k)=5; elseif (u(k)<=0) u(k)=0; end;

%put all the information including the new control signal into the plant y(k+1)=a*y(k)+b/(1+exp(0.5*y(k)-r))*u(k)+(1-a)*yo; end;

% ...end of testing.

pause % Hit any key to plot the plant input and output, and the reference output.

hold on;grid;plot(y(1:180),'.b');plot(ref(1:180),'-r');plot(u(1:179),'g');xlabel('Sampling Time Step KT T=25 seconds');ylabel('Temperature(degree)');title('Reference Signal-- Actual Output . Control Signal __');

AES=sum(abs(ref-y))echo offdisp('End of mfile2.m')

The absolute error obtained for this system is 446.9001. The graphs in Figure 12 shown the result of FLC is satisfactory.

Water Level Control in a Surge Tank Using Fuzzy Logic ControllerIn this section we use a water level problem for a surge tank to show how to the fuzzy logic controller work even though the reference point is keep changing fast all the time. The discrete time equation of a surge tank we use is:

where T is the sampling rate that we set as

0.5 second.

However, we have other restrictions on the plant dynamic. In particular, we assume the plant input, u(k) saturates as +50 and -50. This mean u(k) will be limited in between -50 to +50. Also to ensure that the liquid level never goes negative (which is physically impossible), we simulate our plant using:

.For this application we try to test the ability of fuzzy logic controller on a fast response plant, therefore the desire output is also change with time such as:

Figure 12

The input and output variables are e(k), de(k) and du(k).Here the u(k) can be obtain base on the equation: u(k) = u(k-1) + du(k).

The code is given as below. Notice that the same code can be found in mFile3.m.

%read FIS from filef = readfis('fis2.fis');%f = readfis('mfis1.fis');

%define the plant parametersT = 0.5;h0 = 3.5;p = 1;q = 2;

%define the gain or scaling factor for all variablesGE = 0.3;GDE = 1;GDU = 10;

%number of intervalindex = 600;

%initial the level of water to h0h(1) = h0;

for k = 1 : (index-1) ref(k) = (cos(0.07*k)) + (sin(0.05*k)) + 2.7; e(k) = ref(k)-h(k); %the error use for FIS must be scaled/fuzzify ef(k) = e(k)*GE; if k == 1 de(k) = 0; else de(k) = e(k) - e(k-1); end; %the change of error use for FIS must be scaled/fuzzify def(k) = de(k)*GDE; %to void warning message because of bigger than 1 or smaller than -1 if ef(k) < -1 ef(k)= -1; elseif ef(k) >= 1 ef(k) = 1; else ef(k) = ef(k); end; if def(k) < -1 def(k)= -1;

elseif def(k) >= 1 def(k) = 1; else def(k) = def(k); end; %evaluate the FIS based on the error and change of error calculated duf(k) = evalfis([ef(k) def(k)], f); %the output of FIS shall be scaled/defuzzify du(k) = duf(k)*GDU; if(k > 1) u(k) = u(k-1) + du(k); else u(k) = du(k); end; %input to the plant shall be saturated if (u(k) <= -50) u(k) = -50; elseif (u(k) >= 50) u(k) = 50; else u(k) = u(k); end; %put the output of FIS into the plant for control purpose a = -sqrt(19.6*h(k)); b = p*h(k)*h(k) + q; h(k+1) = h(k) + T*((a/b) + (u(k)/b)); if (h(k+1)) < 0 h(k+1) = 0; end;end;

ref(index) = h(index);

%plot the plant output, target output and error of the planthold on; grid;plot(ref(1:index-1), '-r');plot(h(1:index-1), 'b');plot(e(1:index-1),'g');

xlabel('Sampling time step kT where T = 0.5 second');ylabel('Temperature(degree)');title('Target Output (red) Actual Output (blue) Error (green)');

AES=sum(abs(ref-h))

The absolute error obtained for this system is 22.9821. The result of this application is given in Figure 13.

ExerciseFor both water level and water temperature control applications, try to fine tune the scaling/gain parameters of the input/output variables so that the absolute errors are smaller.

Using Fuzzy Logic Controller in Simulink for Single Link Robot Arm ControlIn this demo, the objective is to control the movement of a simple, single-link robot arm, as shown in the following figure.

Figure 13

The equation of motion for the arm is . Where

x(t) is the angle and u(t) is the control signal (torque). Here we model the single link arm as a library before use it as a plant to test the fuzzy controller in Simulink. This library is then saved as “myrobotarm.mdl”. Type “myrobotarm” in Matlab console window will actually call it out. Figure 15 below shown this robot arm has been model as a library.

In Simulink, fuzzy logic controller has been model as a library. If we need to use FIS in Simulink, 1st, type “fuzblock” in Matlab console window. The fuzzy models are loaded as shown in Figure 15.

x

Figure 14

Figure 15

Once we have both libraries (robot arm and fuzzy controller), start a new Simulink model, right click robot arm library and select ‘copy”, paste it into the new Simulink model. Repeat the copy and paste but for the fuzzy logic controller. See Figure 16 for detail. After that, add other model in Simulink such as Sum, Gain and Delay. Notice that the Simulink model shown in Figure 16 is can be found in sim1.mdl.

However, the Simulink model shown in Figure 16 has not yet ready to run. This is because the fuzzy logic control must be specific the FIS matrix, where the FIS used to be design using FIS Editor.

Figure 15

Figure 16

To do this, design a new FIS or open a existing FIS with FIS Editor, select “FileExportWorkSpace…”. You shall type in a name as you are being as to do so. E.g., you had just designed an FIS, and you export it to workspace with name fis3.fis. The next thing to do is come back to your Simulink model, double click the FLC library, a dialog box is show. See Figure 17 for detail.

As show in Figure 17, you must type in a valid FIS such as fis3.fis which is you just export to workspace via FIS Editor.

Finally we can start run the Simulink model by select “SimulinkStart”, a XY plots shown the output of the fuzzy controlled robot arm compare to random reference points. The result is shown in Figure 18 below.

Advantage Technique: Adaptive Neuro-Fuzzy-Inference-Systems (ANFIS)This module is end with a short discussion on ANFIS. ANFIS was 1st proposed by Roger Jang as a hybrid system between Fuzzy Inference Systems but with neural network

Figure 17

Figure 18

architecture. The learning is required in order to fine-tune the parameters of the membership functions as well as the parameters of defuzzification. For detail of the ANFIS, please see [1].

One of the used of ANFIS in control system is to learn the inverse of the plant, so that I can be used as a controller after training phase. Figure 19 has shown the learning phase of ANFIS. As an example, we take the water bath temperature system as the target plant to be controlled. Notice that the learning of ANFIS is based on error back propagation as well.

After the learning phase is finished, the trained ANFIS is then to be used as a controller for the plant. The configuration of block to do this is shown in Figure 20.

The Matlab source code for training of ANFIS is list out as below. Notice that same source code can be found mFile4.m.

% =======================

Plant, f ))(),(()1( kykufky

1z)(ky

)(ku

ANFIS

1z)(ky

)1( ky)(ku

Figure 19

+

-

ANFIS Plant, f)(ku

)1( ky)1( kyd

1z

)(ky

Figure 20

% Filename : mFile4.m% =======================clear;echo on;clc;

% ==================================================================% ANFIS Controller for the Water Bath Temperature Control % ==================================================================

% ===================================================================% Problem Statement: To design an ANFIS controller for the % temperature control of a bath described in Module 3. % We shall implement the ANFIS controller using% the direct inverse control strategy shown in Fig 19 and 20.% We first obtain the training data by imposing random input voltages to% the water bath system and recording the corresponding temperatures.% The ANFIS is then trained to identify the inverse model% of the water bath system using the gathered training data.% To start the ANFIS training, we need an FIS matrix that specifies% the structure and initial parameters of the FIS for learning.% The user can use the command ``genfis1" to generate an FIS matrix% from the training data using the grid-type partition% according to the given number and types of membership functions.% In this demonstration, we use five% ``gaussmf''-type membership functions.% ===================================================================

% =====================================% This is the Training program of ANFIS% =====================================

pause % Hit any key to begin this program.

pause % Hit any key to define the plant parameters.

Ts = 25;p = 1*10^(-4);q = 8.7*10^(-3);r = 40.0;yo = 25;y(1) = yo;a = exp(-p*Ts);b = (q/p)*(1-exp(-p*Ts));

% Hit any key to define the training data.pause % Here, we use 100 training data. You can try different number of patterns.

for k = 1:120 u(k) = rand(1,1)*5; y(k+1) = a*y(k)+b/(1+exp(0.5*y(k)-r))*u(k)+(1-a)*yo; end;

trndata = [y(2:101);y(1:100);u(1:100)]'; %The ' in behind of this code is very important!

pause % Hit any key to train the ANFIS structure.

% please wait ...nummfs = 5; mftype = 'gaussmf';infismat = genfis1(trndata,nummfs,mftype);[outfismat, error,stepsize] = anfis(trndata, infismat,5);

pause % Hit any key to save the parameters to the disk.save myanfis.mat outfismat

%To run the "mFile5.m" to test the trained ANFIS.

echo offdisp('End of Mfile4.m')

Another source code listed below is for recall phase for ANFIS when it is used as controller to control the temperature of water bath. Same code can be found in mFile5.m

% =======================% Filename : mFile5.m% =======================clear;echo on;clc;

% ==================================================================% ANFIS Controller for the Water Bath Temperature Control % ==================================================================

% ===================================================================% Problem Statement: To design an ANFIS controller for the % temperature control of a bath described in Module 3. % We shall implement the ANFIS controller using% the direct inverse control strategy shown in Fig 19 and 20.% We first obtain the training data by imposing random input voltages to% the water bath system and recording the corresponding temperatures.% The ANFIS is then trained to identify the inverse model% of the water bath system using the gathered training data.% To start the ANFIS training, we need an FIS matrix that specifies% the structure and initial parameters of the FIS for learning.% The user can use the command ``genfis1" to generate an FIS matrix% from the training data using the grid-type partition% according to the given number and types of membership functions.% In this demonstration, we use five% ``gbellmf''-type membership functions.% ===================================================================

% =====================================% This is the Testing program of ANFIS% =====================================

pause % Hit any key to begin this program.

pause % Hit any key to load the myanfis.mat

load myanfis.mat

pause % Hit any key to define the plant parameters.Ts = 25;p = 1*10^(-4);q = 8.7*10^(-3);r = 40.0;yo = 25;y(1) = yo;a = exp(-p*Ts);b = (q/p)*(1-exp(-p*Ts));

pause % Hit any key to define the reference output.for k = 1:180 if (k <= 40) ref(k) = 35; elseif (k > 40 & k <= 80) ref(k) = 50; elseif (k > 80 & k <= 120) ref(k) = 65; elseif (k > 120) ref(k)=80; end;end;

pause % Hit any key to test 180 time-steps.

for k=1:179 u(k) = evalfis([ref(k+1) y(k)],outfismat); if (u(k) >= 5) u(k)=5; elseif (u(k) <= 0) u(k)=0; else u(k)=u(k); end; y(k+1)=a*y(k)+b/(1+exp(0.5*y(k)-r))*u(k)+(1-a)*yo; end;

% ...end of testing.

pause % Hit any key to plot the plant input and output, and the reference output.hold on;grid;plot(y(1:180),'.b');plot(ref(1:180),'-r');plot(u(1:179),'g');xlabel('Sampling Time Step KT T = 25 seconds');ylabel('Temperature(degree)');title('Reference Signal-- Actual Output . Control Signal __');

AE=sum(abs(ref-y))echo offdisp('End of mfile5.m')

The total absolute error of this ANFIS controller for this plant is 369.8952, which is smaller than fuzzy logic controller that we discussed above. Also it produces a stable control signal u(k). See Figure 21 for detail.

Figure 21