LAKEHEAD UNIVERSITY

DEPARTMENT OF ELECTRICAL ENGINEERING

0573 FUZZY LOGIC CONTROLLER

FUZZY LOGIC CONTROLLER DESIGN

FIELD-CONTROLLED DC MOTOR SPEED CONTROL

BRUNO SERGIO ADAMCZYK

CLEITON FERREIRA DOS SANTOS

LARISSA RODRIGUES CUSTDIO

APRIL 8th, 2014

CONTENTS

LIST OF FIGURES ...................................................................................................... 4

LIST OF TABLES ....................................................................................................... 4

ABSTRACT ................................................................................................................. 5

1. INTRODUCTION .................................................................................................. 6

2. MODELING .......................................................................................................... 7

2.1. Parameters values........................................................................................ 9

2.2. Frequency domain representation by Laplace transform ........................ 9

2.3. Relation between Laplace transform and Ztransform, and frequency

domain representation by Ztransform ............................................................. 10

2.4. DC motor block diagram with disturbance ........................................... 12

2.5. Comparison between continuous-time and discrete-time ...................... 12

2.6. Disturbances .............................................................................................. 13

2.7. Control objective ........................................................................................ 14

3. FUZZY LOGIC CONTROLLER ......................................................................... 15

3.1. Proportional-Integral (PI) fuzzy controller architecture .......................... 15

3.2. Normalisation ............................................................................................. 16

3.3. Partition ....................................................................................................... 17

3.4. Membership function ................................................................................. 18

3.5. Fuzzy rule base .......................................................................................... 19

3.6. Fuzzification process ................................................................................. 20

3.7. Fuzzy inference engine .............................................................................. 20

3.8. Defuzzification process ............................................................................. 21

3.9. Fuzzy implication ....................................................................................... 23

4. SIMULATION RESULTS ................................................................................... 24

4.1. Discrete PI Controller ................................................................................. 24

4.2. Proportional-Integral Fuzzy Logic Controller (PI-FLC) ........................... 25

4.3. Comparison between discrete PI and PI-FLC .......................................... 27

5. RESULT ANALYSIS .......................................................................................... 29

6. CONCLUSION ................................................................................................... 30

REFERENCES .......................................................................................................... 31

ATTACHMENT I ....................................................................................................... 32

ATTACHMENT II ...................................................................................................... 35

ATTACHMENT III ..................................................................................................... 40

ATTACHMENT IV ..................................................................................................... 42

4

LIST OF FIGURES

Figure 1 Electric equivalent circuit of the motor. ....................................................... 7

Figure 2 System model (open-loop). ...................................................................... 12

Figure 3 Open-loop response: discrete-time vs. continuous-time. .......................... 13

Figure 4 Motor model (closed-loop) for a fuzzy controller. .................................. 14

Figure 5 Block diagram: PI fuzzy controller. ........................................................... 16

Figure 6 Partitioning the error, , and change in error, . ..................................... 17

Figure 7 Partitioning the change in control, . ...................................................... 18

Figure 8 Crisp and centroid found for = 0.5 and = 0.25 by Singleton

fuzzifier, Mamdani Minimun implication, and centroid defuzzification method. .......... 22

Figure 9 Control surface (graphical form), *. ....................................................... 23

Figure 10 System response, with discrete PI controller and disturbance applied at

= 0.3. .................................................................................................................... 24

Figure 11 Error signal, with discrete PI controller. .................................................. 25

Figure 12 PI fuzzy logic controller response. .......................................................... 26

Figure 13 PI fuzzy logic controller response, with disturbance applied at = 0.3.26

Figure 14 Error and change in error signals (fuzzy logic controller inputs). ............ 27

Figure 15 Discrete PI controller vs. PI fuzzy logic controller. .................................. 28

LIST OF TABLES

Table 1 Project variables and conventions. .............................................................. 8

Table 2 Normalised data ranges. ........................................................................... 16

Table 3 Fuzzy rule base. ........................................................................................ 19

Table 4 Control surface (table form), *. ............................................................... 22

5

ABSTRACT

The present work consists in develop a controller for a DC motor in order to control

and regulate its speed. The motor was modeled in frequency domain from differential

equations, which represents the system behavior mathematically. Since the Fuzzy

Logic Controller (FLC) uses discrete values, it was necessary to convert the transfer

function obtained in Laplace domain to Z-domain, which was made by Zero-Order-

Hold (ZOH) method. In order to prove the relation between both domains, a

comparison was made applying a step signal and measuring the open loop response.

However, the goal is to design a closed loop system where a controller will control the

motor speed from an input voltage. Therefore, a FLC was implemented in a

Proportional-Integral (PI) architecture, since the main goal is minimizing the error

signal as much as possible, getting a value that tends to zero, consequently, reaching

the set point. Moreover, a discrete PI controller was designed, with the aid of an

optimized and heuristic algorithm. This implementation was necessary because a

comparison between the controllers response must be done to show that the PI-FLC

is as good as the discrete PI depending on its rules, gains and architecture were

created. Several parameters and configurations were performed in order to tune the

fuzzy controller (normalisation, partition, membership function, fuzzy rule base, fuzzy

inference engine, fuzzifier, defuzzifier, and fuzzy implication), and all of them will shown

in this document. Finally, the simulations are executed and the results are recorded

and analyzed.

Key words: Fuzzy design; Proportional-Integral fuzzy logic controller; Fuzzy controller;

Discrete PI controller; System modeling.

6

1. INTRODUCTION

Nowadays, with the technology advance, it is essential to project controllers that

are able to regulate and control systems. These controllers can be analog or digital,

and can assume several architectures being the most common the Proportional (P),

Proportional-Integral (PI), and Proportional-Integral-Derivative (PID) structures.

However, developing these controllers, sometimes, it is not trivial, since the gains vary

from system to system and the tuning is a hard task, being often necessary to use

Heuristic Methods to find them.

Therefore, to simplify this process and improve functionality, other controllers

were created. For instance, Fuzzy Logic Controllers (FLC), Neural Networks, Genetic

Algorithms, Artificial Intelligence, and so on, are included in this huge group of new

controllers.

Based in this assumption, the main purpose of this project is to design and

implement a fuzzy controller in order to control and regulate the DC motor speed with

a field controlled, which means the current at the armature is constant.

Fuzzy controllers are usually non-linear, in other words, they operate by

bands. In general, this operations adaptability could be useful, but, sometimes, it

could bring some problems to control the system. Everything depends on the goal and

applicability of the project.

Then, this project will try to cover some points regarding the FLC, as the PID

controller. The document is divided in five main sections, and follows this order:

modeling, design, simulations, analysis and conclusion.

7

2. MODELING

The project development began to set up the input and output desired, and then

for modeling the system. The case considered for this project assumes that the current

in the armature is constant equal to , therefore, the field-current is controlled.

In Figure 1, it is shown the general model representation for the considered

system, a DC motor, and its parameters.

Figure 1 Electric equivalent circuit of the motor.

The input of the system is given in voltage denoted by (), and the output

desired is the motor speed, (), in rad/sec. Therefore, the equations, in time domain,

for a DC motor are given by:

()

= () + ()

Equation 1

()

=

()

()() +

1

()

Equation 2

()

=()()

1

()

()

Equation 3

where:

= ()()

() ( )

8

Since the motor field-current is controlled, () is constant, then, from Eq. 2:

()

=

= 0

Therefore, using Kirchoff's voltage law, Equation 1 and Equation 3 could be

rewritten as:

()

+ () = ()

Equation 4

()

+ () = ()() ()

Equation 5

For convenience, let define:

() = ()

() = ()

= () = . = 1

Table 1 Project variables and conventions.

Variable Name Value Unit

Motor torque constant 2.58 N.m/A

Electromotive force constant 0.0182 V.sec/rad

Electric resistance 0.83 Ohm

Electric inductance 0.63 x 10-3 H

Motor viscous friction constant 0.0638 N.m.sec

Moment of inertia of the rotor 5.9 x 10-4 kg.m2

Current in the armature 1 A

() Angular speed (time domain) rad/sec

() Current in the field (time domain) A

() Set point (time domain) V

() Disturbance (time domain) N.m

() Angular speed (frequency domain)

() Current in the field (frequency domain)

() Set point (frequency domain)

() Disturbance (frequency domain)

9

2.1. Parameters values

All parameters and variables used over this project are described in Table 1. In

the table, the variables, their significance, their values and units of measure of are

provided.

2.2. Frequency domain representation by Laplace transform

The transfer function (TF) for this system could be found applying the Laplace

transform to Equation 4 and Equation 5 (Equation 6 and Equation 7, respectively), and

combining both of them (Equation 8). Then, the following results are obtained:

()[ + ] = ()

Equation 6

()[ + ] = () ()

Equation 7

() =(1 )

( + )[()

( + ) ()]

Equation 8

It can be noted, from Equation 8, that this system is MISO (Multiple Input, Single

Output), which means there are two inputs, but only one output. In this case, there is

no way to obtain only one TF, since it is SISO (Single Input, Single Output). Therefore,

two transfer functions will be provided, one relating the output and the input, ()

(), and

the other relating the output and the disturbance, ()

().

The first one, called the system transfer function, is defined as follows:

() =()

()=

(

)

( + ) ( +

)

Equation 9

10

Then the TF relating the output and the disturbance is given by:

() =()

()=( )

( + )

Equation 10

The complete calculations for these transfer functions could be seen in

ATTACHMENT I. Even though the Equation 8 is the Laplace domain representation

for the continuous-time system, the fuzzy logic controller uses discrete variables, which

means that this TF must be in the complex variable z (Z-domain). The next section

shows the relation between s and z arguments, using the Zero-Order-Hold (ZOH)

method.

2.3. Relation between Laplace transform and Ztransform, and frequency

domain representation by Ztransform

An easy method to convert the complex variable s in z is using the following

relation:

() = (1 1) {1 {()

}}

Equation 11

where:

(1 1)

{ }

1{ }

Therefore, using the method shown in Equation 11, the Equation 8 is rewritten

in two terms. One considers the motor TF, [() =()

()], and the other considers the

disturbance TF, [() =()

()].

11

() =(( + ) + ( + ) + ( + )) + ( + + )

( + ) + ()

Equation 12

where , , and are the partial fraction coefficients and, and are the z-poles,

whose values are given by:

=

=

( )

=

( )

= ( )

= ()

where is the sampling period.

Following the same principle, the transfer function relating the output and the

disturbance could be seen in Equation 13.

() =

(

( ))

( )

Equation 13

Equation 12 and Equation 13 are the system representation in Z-domain, which

means that the project works from now on with discrete values, based on the sampling

period. The complete calculations are shown in ATTACHMENT II.

12

2.4. DC motor block diagram with disturbance

Every model could be represented in block diagram, which facilitates

understanding the general system concept. Therefore, Figure 2 shows the system

representation, where () is the input in voltage, () is the output in rad/sec, ()

is the input disturbance in N.m, () is the motor TF and, () is the disturbance

transfer function.

Figure 2 System model (open-loop).

2.5. Comparison between continuous-time and discrete-time

For the values given in Table 1, it is possible to find the open-loop transfer

function in Laplace domain (related with continuous-time) and Z-domain (related with

discrete-time), and them are shown in Equation 14 and Equation 15 (for = 1),

respectively.

() =()

()=

.

+ . + .

Equation 14

() =()

()=

. + .

. + .

Equation 15

Note that the disturbance was not listed on this point, since the goal is doing the

open-loop comparison between continuous-time and discrete-time. In Figure 3, the

comparison is shown in a graphical way.

13

It can be concluded, from the figure, that the relationship between both

transform is valid and proves that the selected sampling time for this system is

consistent. Moreover, the functionality of the zero-order-hold method cited previously

is maintain the present value until the next sampling period running.

Figure 3 Open-loop response: discrete-time vs. continuous-time.

2.6. Disturbances

The only disturbance within the system is a load on the motor during operation.

This load disturbance affects the response of the system's change in error, and it could

be either negative or positive, at any period.

Physically, this disturbance could be understood as a load placed on the motor

shaft, and this load generates a counterforce on the motor trying to stop the movement,

therefore, the disturbance demands a bigger or lower response from the controller.

From the values shown in Table 1, the transfer function relating the output and

the disturbance could be seen in Equation 16.

14

() =()

()=.

.

Equation 16

2.7. Control objective

The main object of this project is controlling the speed of the motor providing an

input voltage the speed will be measure in rad/sec. Furthermore, the operation range

for this motor could vary from 12 to +12, which means that in speed the motor

varies from 660/ to 660/. For control purposes, the maximum torque

varies based on the input voltage, and follows the Equation 17, where is the input.

() = 3.516 + 46.424

Equation 17

The controller will be fed with the error signal, [], and the change in error

signal, [], given by:

[] = [] []

[] = [] [ 1]

where [] is the desired speed, [] is the current response, [] is the current

error, and [ 1] is the previous error.

The closed-loop diagram model, for a fuzzy controller, is shown in Figure 4.

Figure 4 Motor model (closed-loop) for a fuzzy controller.

15

3. FUZZY LOGIC CONTROLLER

According to [PIEGAT, 2001], fuzzy set theory has opened new exploratory

possibilities, among them:

The possibility of creating artificial intelligence similar to human intelligence and

providing automatons and robots with it;

The creation of computers programmed with words;

The application of information of any membership function for modeling, control,

optimization and diagnostics of system and objects;

The possibility of adapting the membership function according to the required

accuracy of modeling, control, optimization, diagnostics, and so forth.

Therefore, a fuzzy control system (or fuzzy logic controller) is a control based

on a mathematical system that analyses input values in terms of logic variables,

converting them in any value between [0,1].

According to [CRESPO and others, 2010], a typical fuzzy logic controller

includes three main parts:

Input signal fuzzicated: converts discrete values into fuzzy sets using

fuzzification;

Fuzzy inference engine with rule base: this step decides what to do based on

the rule base pre-defined by the user;

Output signal defuzzicated: uses the fuzzy set provided by the inference engine

to produce an output real values , also known as defuzzification.

3.1. Proportional-Integral (PI) fuzzy controller architecture

The PI fuzzy controller architecture is shown in Figure 5. The PI architecture

characterizes by having a sum before the motor input. Since this project works as a

proportional-integral controller, the controller output is defined as:

[] = [] + [] + [ 1]

where and are the integral and proportional gain, respectively.

16

Figure 5 Block diagram: PI fuzzy controller.

3.2. Normalisation

The normalisation process consists in amplify/attenuate a value , which varies

in the interval [, ], in order to do it belongs to the interval [-1, 1] using an

appropriate scaling factor.

As previously stated, the operation range varies from 12 to +12,

consequently, for the input the scaling factor chosen was 1 12 , and for the input

was 1 2 , since the maximum values will occur in = 0 and will be equal to the input.

Following the same procedure, the chosen output scaling factor value, for the , was

(1 12 )1= 12. In Table 2, it could be seen the compilation of these values.

Table 2 Normalised data ranges.

Variable Min Value Max Value Scaling factor

(Attenuation/Amplification)

-1 1 1 12

-1 1 1 2

-1 1 12

In short, the universe of discourse for the error, change in error, and change in

control input could be understood as:

[1, 1] [1, 1] [1, 1]

17

3.3. Partition

Partitioning consists in bands apportioning in order to get different actions due

to the error and changing in error variations. Even though more bands can provide

softly responses, they increase the controller complexity as well; however, at least

three bands are necessary to get smoothly transitions. Based on this statement and

previous experiments, the actual project uses three partitions (N, Z and P).

It is possible to see in Figure 6 the selected partition to the error and change in

error, and Figure 7 to the change in control.

Figure 6 Partitioning the error, , and change in error, .

18

Figure 7 Partitioning the change in control, .

3.4. Membership function

The membership function consists of the three linguistic terms defined by:

Negative (N);

Zero (Z);

Positive (P).

Figure 6 and Figure 7 showed, in a graphical way, the membership function

considered for the project. However, the graphs could be represented in sets, as

follows:

() = () = {1

1

1

0.75

1

0.5

0.5

0.25

0

0

0

0.25 0

0.5

0

0.75

0

1}

() = () = {0

1

0

0.75

1/3

0.5

2/3

0.25

1

0

2/3

0.25 1/3

0.5

0

0.75

0

1}

() = () = {0

1

0

0.75

0

0.5

0

0.25

0

0

0.5

0.25 1

0.5

1

0.75

1

1}

19

() = {1

1

1

0.75

1

0.5

0.5

0.25

0

0

0

0.25 0

0.5

0

0.75

0

1}

() = {0

1

0

0.75

0

0.5

0.5

0.25

1

0

0.5

0.25 0

0.5

0

0.75

0

1}

() = {0

1

0

0.75

0

0.5

0

0.25

0

0

0.5

0.25 1

0.5

1

0.75

1

1}

Note that the membership function for the zero shape differs from input and

output. In the considered case, the change in control has a shaper form.

3.5. Fuzzy rule base

According to [PIEGAT, 2001], the rule fuzzy base consists of logical rules

determining causal relationships existing in the system between fuzzy sets of its inputs

and output. For instance, a rule base can be as follow:

Rule 1: IF e is N and ce is N THEN cu is N

Rule 2: IF e is N and ce is Z THEN cu is N

Rule 3: IF e is N and ce is P THEN cu is Z

Rule 4: IF e is Z and ce is N THEN cu is N

Rule 5: IF e is Z and ce is Z THEN cu is Z

Rule 6: IF e is Z and ce is P THEN cu is P

Rule 7: IF e is P and ce is N THEN cu is Z

Rule 8: IF e is P and ce is Z THEN cu is P

Rule 9: IF e is P and ce is P THEN cu is P

Since three rules were selected to the error and change in error, the final

number of rules reach a total value of nine rules. The rules can be represented in a

matrix form, such as in Table 3.

Table 3 Fuzzy rule base.

e\ce N P Z

N N N Z

P N Z P

Z Z P P

20

3.6. Fuzzification process

Into fuzzification process, the membership grades of the numeric values of the

model inputs in fuzzy sets of the inputs are calculated. The most common fuzzifiers

used in this process are:

Singleton fuzzifier;

Gaussian fuzzifier;

Triangular fuzzifier.

Therefore, due to its applicability the Singleton fuzzifier was chosen for this

project. Thus, it is defined as follows:

() = {1, =

0,

() = {1, =

0,

3.7. Fuzzy inference engine

The inference engine is an algorithm, which calculates the controller response

by computing the rule bases into a subset. The Mamdani Minimum Inference (MMI)

was select as the fuzzy inference engine of this project.

The formula used to do the fuzzy inference engine, by Singleton fuzzifier, could

be seen in Equation 19, where is shown the simplified version.

() = { { {(, ), (),

(), ()}}}

Equation 18

This equation could be simplified as shown in Equation 19:

() = {{(), (

), ()}}

Equation 19

21

3.8. Defuzzification process

The defuzzification process calculates from the resulting membership function

a crisp, numeric output value, , being an effect of the numeric inputs values and

.

There are some methods to do this process, among which the most well-known

are:

Middle of maxima method;

Least of maxima method;

Max of maxima method;

Center of maxima method;

Centroid method.

For this project, the centroid method was chosen because it assumes that the

crisp representative is the coordinate of the center of gravity (centroid) of the

surface under the curve determined by this function. This value could be calculated by

Equation 20, as follows:

= =(). . d

(). d

Equation 20

For instance, let define the follow assumption:

= 0.5

= 0.25

Using the fuzzy inference engine defined previously, the follow crisp is found:

() = {()} = {

2

3,2

3,2

3,1

2,1

2,1

2,1

3,1

3,1

3}

Then, by the centroid method, the final result, which means the output signal

from the controller is equal to:

= 0.1667

22

The complete calculations, for this and , could be seen in ATTACHMENT

III.

In Figure 8, the crisp and the centroid could be seen in a graphical way.

Figure 8 Crisp and centroid found for = 0.5 and = 0.25 by Singleton fuzzifier, Mamdani

Minimun implication, and centroid defuzzification method.

Table 4 Control surface (table form), *.

e\ce -1 -0.75 -0.5 -0.25 0 0.25 0.5 0.75 1

-1 -0.6786 -0.6786 -0.6786 -0.65 -0.6786 -0.4286 -0.25 0 0

-0.75 -0.6786 -0.6786 -0.6786 -0.65 -0.6786 -0.4286 -0.25 0 0

-0.5 -0.6786 -0.6786 -0.55 -0.4868 -0.55 -0.1667 0 0.25 0.25

-0.25 -0.65 -0.65 -0.4868 -0.3553 -0.3553 0 0.1667 0.4286 0.4286

0 -0.6786 -0.6786 -0.55 -0.3553 0 0.3553 0.55 0.6786 0.6786

0.25 -0.4286 -0.4286 -0.1667 0 0.3553 0.3553 0.4868 0.65 0.65

0.5 -0.25 -0.25 0 0.1667 0.55 0.4868 0.55 0.6786 0.6786

0.75 0 0 0.25 0.4286 0.6786 0.65 0.6786 0.6786 0.6786

1 0 0 0.25 0.4286 0.6786 0.65 0.6786 0.6786 0.6786

23

Therefore, for the partition defined previously, the control surface is shown in

Table 4, by Singleton fuzzifier, Mamdani Minimun implication, and centroid

defuzzification method. This table could be visualized in a graphical form as well. Then,

in Figure 9 shows the compiled results.

Figure 9 Control surface (graphical form), *.

3.9. Fuzzy implication

The fuzzy implication used forms the basis of the inference engine, which was

explained by the Equation 19. Therefore, the implication takes the form of Equation 21,

which is the Mamdani Minimum implication operator.

(, , ) = (, , ) = {(, ), ()}

Equation 21

24

4. SIMULATION RESULTS

The simulation results are divided into three parts: discrete PI controller, PI fuzzy

logic controller, and the comparison between both controllers.

The algorithm used for the simulation could be seen in ATTACHMENT IV.

4.1. Discrete PI Controller

In order to compare the fuzzy logic controller results, a discrete PI controller was

constructed using an optimized and heuristic method. The response for this controller

could be seen in Figure 10.

Figure 10 System response, with discrete PI controller and disturbance applied at = 0.3.

Note that the response is smoothly and there is no overshoot in the motor.

Moreover, the disturbance was applied in the system in order to analyse whether the

system attenuates or amplifies it. Other important point is that the response is being

25

measured in voltage, to be easier to compare the set point (input) with the output. In

Figure 11, it is shown the error signal for this controller discrete PI controller.

Figure 11 Error signal, with discrete PI controller.

4.2. Proportional-Integral Fuzzy Logic Controller (PI-FLC)

The Proportional-Integral Fuzzy Logic Controller was developed to control the

DC motor speed such as the discrete PI controller. The result will be compiled and

compared with the discrete PI controller in order to contrast the differences between

these controllers. The parameterization for the FLC was based on previous

experiences that showed good results for nine rules. All the parameters/configuration

for the PI-FLC could be seen in the previous section 3.0.

In Figure 12, it is shown the PI-FLC response for different levels of set point,

where a set point of six volts represents a speed, approximately, of 330rad/sec, and a

set point of minus three volts represents a speed, approximately, of -175rad/sec

(opposite direction, or |175|rad/sec in absolute value). It is possible to notice that the

system stabilize in steady state for any input.

26

Figure 12 PI fuzzy logic controller response.

Figure 13 PI fuzzy logic controller response, with disturbance applied at = 0.3.

27

The PI-FLC was tested with disturbance conditions as well, and the results are

shown in Figure 13, which shows the set point and response in voltage. The same set

point was chosen, and the disturbance consisted of a load applied in the motor shaft

after the stabilization at = 0.3. It is possible to see that the PI-FLC rejected the

disturbance restabilising the system.

In Figure 14, it is shown the error and change in error signals for this controller,

PI-FLC, with the disturbance.

Figure 14 Error and change in error signals (fuzzy logic controller inputs).

4.3. Comparison between discrete PI and PI-FLC

The comparison between the two controllers showed that the PI-FLC

proportioned good results, even better than the conventional discrete PI controller, due

to nonappearance of an overshoot and a smaller settling time, being on steady state

in less than 0.04 seconds.

28

It is possible to compare both of the responses in Figure 15, with a disturbance

applied at = 0.3. The following points of the proportional-integral fuzzy logic

controller could be evidenced because they presents better results compared to the

discrete PI controller:

No overshoot (both responses present it);

Less settling time, which means that stabilizes faster;

Better disturbance rejection.

Figure 15 Discrete PI controller vs. PI fuzzy logic controller.

29

5. RESULT ANALYSIS

Analysing the results obtained from the comparison of the two controllers was

possible to verify that the discrete PI controller proportioned good results with a first

order response without overshoot; however, the PI-FLC presented a much better

response, stabilizing in less than 0.04 seconds.

One reason that explain why the discrete PI-FLC showed better results is the

fact that this kind of controller can deal with non-linearity. Fuzzy controllers generate

the response based on the change in error tendency, for this reason it can take control

actions in advance in order to minimize the error, providing good responses such as

the presented on this paper.

The gains for the discrete PI controller were obtained with an optimized and

heuristic algorithm, which tested many values of gains and compared all the responses

to come up with the best response based on settling time and overshoot.

Even though the discrete PI controller showed good results, the proportional-

integral fuzzy logic controller overcome its results by using just nine rules. In fact, better

results for the PI-FLC could be given by increasing the number of the rule bases, but

it also would increase the complexity of the project.

The designer expertise plays an important role when it is necessary tuning a PI-

FLC, which depends on the designer acquaintance about the plant behavior and

previous experiences tuning this kind of controller.

30

6. CONCLUSION

The main purpose of the project was achieved, which was design a fuzzy logic

controller in order to control and regulate a DC motor speed. However, in addition to

design the FLC, several other processes were needed, among them how to obtain a

transfer function from differential equations, the relation between Laplace domain and

Z-domain, how to tune a discrete PI controller, and other related with process control.

Therefore, a discrete PI controller was designed in order to compare its results

with the PI fuzzy logic controller. Thus, an optimized and heuristic algorithm was

developed to find the best gains to the controller.

The FLC was designed in order to obtain the best response as a discrete PI

controller. Using only nine rules, the PI-FLC was able to control the system without

overshoot and in an acceptable time (half of the discrete PI controller). Initially, 49 rules

(7x7) were created for the fuzzy controller, but there was no big difference from the

nine rules shown in this project. Since that, the response is similar and the system is

robust (accepts some variations), opted not to use the biggest rule base due to the

calculation complexity will increase proportionally.

The experiment validates the choices made for the proportional-integral fuzzy

logic controller, including its inference engine, fuzzifier, defuzzifier, and membership

functions. The simulation results showed that any overshoot occurred, and the settling

time for the PI-FLC was less than half of the discrete PI controller. Furthermore, the

error tends to zero, which means that the controller is able to achieve the set point

the main goal for every controller.

It is known that some improvements should be implemented according to the

system. However, the FLC showed that it is possible to change the way of controllers

are designed, bringing human knowledge for the system control.

It could be affirmed that this project was successful in designing a fuzzy logic

controller for a DC motor speed control. These practical applications of Fuzzy Logic

are very useful in the process control fields due to its implementation and simulation

availability.

31

REFERENCES

CHATTERJI, S., MATHEW, L., and NISA S. A., (2013) Comparative analysis of

speed control of DC motor using A.I. technique. International Journal of

Engineering Research and Applications.

CRESPO, B., TROLLEY, Z., ZAPORZAN, B. (2010) Fuzzy logic control of motor

position. Lakehead University.

PACHTER, M. (1981) Speed control of a field controlled D.C. traction motor.

International Federation of Automatic Control.

PIEGAT, A. (2001) Fuzzy modeling and control. Physica-Verlag, Heidelberg, New

York.

PIVONKA, P. (2002) Comparative analysis of fuzzy PI/PD/PID controller based on

classical PID controller approach. IEEE.

PLACENCIA, A. C., RAMIREZ, E. G. (2004) How to tune fuzzy controllers. IEEE.

RAHMANI, R., and others (2012) Fuzzy logic controller optimized by particle

swarm optimization for dc motor speed control. IEEE.

SHAW, I. S. (1998) Fuzzy control of industrial systems: theory and applications.

Kluwer Academic Publishers, Boston, Massachusetts.

32

ATTACHMENT I

The model with input () and output () is:

()

= () + ()

Equation 22

()

=

()

()() +

()

Equation 23

()

=()()

()

()

Equation 24

()

+ () = ()() ()

where:

= ()()

()

For convenience:

() = ()

() = ()

Field-controlled, then:

() .

()

=

= 0

Appling Laplace Transform in Equation 22:

()

+ () = ()

33

() + () = ()

()[ + ] = ()

()

()=

1

( + )

()

()=

(1)

[ + ()]

() = ()()

[ + ()]

Equation 25

Appling Laplace Transform in Equation 24:

()

+

() =

()()

1

()

() = = 1

() +

() =

()

1

()

() [ +

] =

()

()

Equation 26

From Equation 25 and Equation 26:

() [ +

] = ()

(

1)

[ + ()]1

()

34

() = ()()

( + ) ( +

) ()

1

( + )

() = ()()

( + ) ( +

) ()

1

( + )

or

() =( )

( + )[()

( + ) ()]

Let:

() =

( + )

() =

( +)

() = ()[()() ()]

35

ATTACHMENT II

Relation between () and () is:

() = (1 1) {1 {()

}}

Part 1: Motor transfer function:

() = ()()

( + ) ( +

)

() =()

()=

()

( + ) ( +

)

Therefore:

()

=

()

( + ) ( +

)=

+

( + )+

( +)

=

()

( + ) ( +

) |

= 0

=

()

()= (

)(

) =

=

()

( + ) ( +

) ( +

) ||

=

=

()

( ) (

+

) =

() ( +

)

36

=

()

( + ) ( +

) ( +

)||

=

=

()

() (

+ ) =

() (+ )

Continuous time:

() = + ( ) +

()

Discrete time:

[] = + ( ) +

()

where is the sampling time.

() = (1 1) { + ( ) +

()}

() = ( 1

) [

1+

( )

+

()

]

() = + ( 1)

( )

+ ( 1)

()

Let:

= ( )

37

= ()

() = + ( 1)

+

( 1)

() =( )( ) + ( 1)( ) + ( 1)( )

( )( )

() =[2 ( + ) + ()] + [2 (1 + ) + ] + [2 (1 + ) + ]

2 ( + ) + ()

() =(( + ) + ( + ) + ( + )) + ( + + )

( + ) + ()

Part 2: Disturbance transfer function:

() =()

( + )

() =()

()=

(1 )

( + )

()

=

(1)

( + )=

+

( + )

=(1)

( + ) |

= 0

=(1)

( )

= (1

) (

) =

1

38

=(1)

( + ) ( +

) ||

=

=(1)

( )

= (1

) (

) =

1

()

=

1+

1

( + )

Continuous time:

() =1

+1

( )

Discrete time:

[] =1

+1

( )

() = (1 1) {1

+1

( )}

() = ( 1

) [ (1 )

1+

(1)

( )

]

() = ( 1) [(1 )

1+

(1)

( )

]

() = (1

) +

(1)( 1)

( )

() =(1 ) (

( )) + (

1)( 1)

( )

39

() = (1

1) + (

1

( )

1)

( )

() =

(

( ) )

( )

40

ATTACHMENT III

Let define and , then find by Singleton fuzzifier, Mamdani Minimum

implication and centroid method.

= 0.5 () = {1, =

0,

= 0.25 () = {1, =

0,

() = {{(), (

), ()}}

() = 1 (

) = 0

() =

1

3 (

) =2

3

() = 0 (

) = 0.5

1: 1() = {(

), (), ()} = {1,0, {1,1,1,0.5,0,0,0,0,0}}

1: 1() = {0,0,0,0,0,0,0,0,0}

2: 2() = {(

), (), ()} = {1,

2

3, {1,1,1,0.5,0,0,0,0,0}}

2: 2() = {

2

3,2

3,2

3,1

2, 0,0,0,0,0}

3: 3() = {(

), (), ()} = {1,

1

2, {0,0,0,0.5,1,0.5,0,0,0}}

3: 3() = {0,0,0,

1

2,1

2,1

2, 0,0,0}

4: 4() = {(

), (), ()} = {

1

3, 0, {1,1,1,0.5,0,0,0,0,0}}

4: 4() = {0,0,0,0,0,0,0,0,0}

41

5: 5() = {(

), (), ()} = {

1

3,2

3, {0,0,0,0.5,1,0.5,0,0,0}}

5: 5() = {0,0,0,

1

3,1

3,1

3, 0,0,0}

6: 6() = {(

), (), ()} = {

1

3,1

2, {0,0,0,0,0,0.5,1,1,1}}

6: 6() = {0,0,0,0,0,

1

3,1

3,1

3,1

3}

7: 7() = {(

), (), ()} = {0,0, {0,0,0,0.5,1,0.5,0,0,0}}

7: 7() = {0,0,0,0,0,0,0,0,0}

8: 8() = {(

), (), ()} = {0,

2

3, {0,0,0,0,0,0.5,1,1,1}}

8: 8() = {0,0,0,0,0,0,0,0,0}

9: 9() = {(

), (), ()} = {0,

1

2, {0,0,0,0,0,0.5,1,1,1}}

9: 9() = {0,0,0,0,0,0,0,0,0}

() = {()} = {

,

,

,

,

,

,

,

,

}

By centroid defuzzifier:

= .

42

ATTACHMENT IV

Below are the scripts and functions utilized to do this project.

% +-----------------------------------------------------------------------+

% | PI Fuzzy Logic Controller | % | | % | Bruno Sergio Adamczyk (PUCPR) | % | Cleiton Ferreira dos Santos (PUCPR) | % | Larissa Rodrigues Custodio (IFG) | % +-----------------------------------------------------------------------+

% +-----------------------------------------------------------------------+

clear all, close all, clc, warning off; step_length = input('Please insert the step: ');

e = -1:step_length:1; ce = -1:step_length:1;

for r=1:length(e) for c=1:length(ce) cu_star(r,c) = defuzzification(e(r), ce(c), step_length); end end

surf(e,ce, cu_star);

% +-----------------------------------------------------------------------+

function cu_star = defuzzification(e_star, ce_star, step_length) %% if (e_star -0.75) && (e_star -0.5) && (e_star 0) && (e_star 0.5) && (e_star

43

%% if (ce_star -0.75) && (ce_star -0.5) && (ce_star 0) && (ce_star 0.5) && (ce_star

44

% R9 B_cu_prime(i,:) = rule(uP_e_star, uP_ce_star, u_cu_P);

%% [m,n] = size(B_cu_prime); % m = row = #of rules; n = column = step for k=1:n B_cu(k) = max(B_cu_prime(:, k)); end

%% cu_star = defuzz(cu, B_cu, 'centroid'); disp(sprintf('cu* = %0.4f', cu_star)); plot(cu_star, 0, 'r*'); hold on; plot(cu, B_cu, 'LineWidth',2); hold on legend(sprintf('Centroid = %0.4f', cu_star)); line([cu_star cu_star],[0 1],'Color','k'); text(cu_star,0.2,' centroid','FontWeight','bold'); hold off; pause(1); title('\mu(cu*)'); xlabel('cu'); ylabel('\mu(cu)');

%%

function [B_cu_prime] = rule(uN_e_star, uN_ce_star, u_cu_N)

for j=1:length(u_cu_N) B_cu_prime(j) = min(uN_e_star, min(uN_ce_star, u_cu_N(j))); end

% +-----------------------------------------------------------------------+

clear all, close all, clc, warning off;close all, clc, clear all; e = -1:.05:1; cu = -1:.05:1;

%% uN_e = trapmf(e, [-2 -1 -0.5 0]); uZ_e = trimf(e, [-0.75 0 0.75]); uP_e = trapmf(e, [0 0.5 1 2]);

figure; plot(e, uN_e, e, uZ_e, e, uP_e, 'LineWidth',2); title('Membership Function'); xlabel('e, ce'); ylabel('\mu(e), \mu(ce)'); axis([-1 1 -0.05 1.1]); text(-0.74,1.04,'N','FontWeight','bold'); text(-0.01,1.04,'Z','FontWeight','bold'); text(0.74,1.04,'P','FontWeight','bold');

%% uN_cu = trapmf(cu, [-2 -1 -0.5 0]); uZ_cu = trimf(cu, [-0.5 0 0.5]); uP_cu = trapmf(cu, [0 0.5 1 2]);

figure; plot(cu,uN_cu, cu,uZ_cu, cu,uP_cu, 'LineWidth',2); title('Membership Function'); xlabel('cu'); ylabel('\mu(cu)'); axis([-1 1 -0.05 1.1]);

45

text(-0.74,1.04,'N','FontWeight','bold'); text(-0.01,1.04,'Z','FontWeight','bold'); text(0.74,1.04,'P','FontWeight','bold');

% +-----------------------------------------------------------------------+

close all, clear all, clc, warning off;

FuzzyRules_seven_atenuado = readfis('FuzzyRules_three');

V1 = 3; % [V] T1 = 0;

V2 = -6; % [V] T2 = 0.1;

V3 = 9; % [V] T3 = 0.2;

Tau = 3; % [V] Disturbance Time_Tau = 0.3; % [sec] Time_Tau

Tau_end = 0; Time_Tau_end = 0.02;

Ts = 0.001; % Sampling time Simulation_Time = 0.4;

D = 0.0638; % [N.m.s] (motor viscous friction constant) J = 5.9e-4; % [kg.m^2] (moment of inertia of the rotor) Ke = 2.58; % [N.m/A] (motor torque constant) Kv = 0.0182; % [V/rad/sec] (electromotive force constant) Lf = 0.63e-3; % [Henry] (electric inductance) Rf = 0.83; % [Ohm] (electric resistance)

%% % Motor Transfer Function A = Ke/(D*Rf); B = Ke/((-D*Lf)*((-D/J) + (Rf/Lf))); C = Ke/((-J*Rf)*((-Rf/Lf) + (D/J)));

x = exp(-(D/J)*Ts); y = exp(-(Rf/Lf)*Ts);

Coef1 = (A + B + C);

Coef2 = -(A*(x+y) + B*(1+y) + C*(1+x));

Coef3 = (A*(x*y) + B*y + C*x);

%% % Disturbance Transfer Function

% num = [N_Dist] N_Dist = (1/D)*(exp(-(D/J)*Ts) - 1);

% den = [1 D_Dist] D_Dist = -exp(-(D/J)*Ts);

46

%% sim('FuzzyLogic_PI_Discrete_Controller.slx'); fuzzy_Input = Input; fuzzy_resp = PID_resp_V; fuzzy_cont = cont; fuzzy_error = error; fuzzy_change_error = change_error; fuzzy_disturbance = disturbance;

%% Kp = 1; Ki = 100; Kd = 0.0; sim('PID_Controller_Discrete.slx'); discretePI_Input = Input; discretePI_resp = PID_resp_V; discretePI_cont = cont; discretePI_error = error; discretePI_change_error = change_error; % it's not being utilized discretePI_disturbance = disturbance;

%% FIGURES % Fuzzy Controller figure; hold on; plot(fuzzy_Input, 'b'); plot(fuzzy_resp, 'r'); plot(fuzzy_cont, 'g'); plot(fuzzy_error, 'k'); plot(fuzzy_change_error, 'c'); plot(fuzzy_disturbance, 'm'); hold off;

title(sprintf('PI Fuzzy Controller')); axis([0 Simulation_Time -7 12.5]); xlabel('Time [sec]'); ylabel('Voltage [V]'); legend('Set point','Response','Controller signal',... 'Error','Change in error','Disturbance','location', 'southeast');

%%

% Discrete PI Controller figure; hold on; plot(discretePI_Input, 'b'); plot(discretePI_resp, 'r'); plot(discretePI_cont, 'g'); plot(discretePI_error, 'k'); plot(discretePI_change_error, 'c'); plot(discretePI_disturbance, 'm'); hold off;

title(sprintf('Discrete PI Controller')); axis([0 Simulation_Time -7 12.5]); xlabel('Time [sec]'); ylabel('Voltage [V]'); legend('Set point','Response','Controller signal',... 'Error','Change in error','Disturbance','location', 'southeast');

% +-----------------------------------------------------------------------+