informis/textfiles
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
root@procul
2021-04-15 13:31:59 -05:00
commit 278a90f7ce
57951 changed files with 34606208 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
programming/FUZZYLOGIC/air_cond.txt
+183
View File
@@ -0,0 +1,183 @@
INTRODUCTION
Temperature control is widely used in various processes. These
processes, no matter if it is in a large industrial plant, or in
a home appliance, share several unfavorable features. These
include non-linearity, interference, dead time, and external
disturbances, among others. Conventional approaches usually do
not result in satisfactory temperature control.
In this Application Note we provide examples of fuzzy logic used
to control temperature in several different situations. These
examples are developed using FIDE, an integrated fuzzy inference
development environment.
FUZZY CONTROLLER FOR AIR CONDITIONING SYSTEM
In the following discussion, we give examples of air conditioning
systems, ranging from a basic model to an advanced model. We do
not provide FIU(Fuzzy Inference Unit) source code as we have in
previous application notes. Instead, this time we concentrate on
the input/output variables of the fuzzy controller for an air
conditioning system.
A Basic Model
Let us start with the simplest air conditioning system, which is
shown in Figure 1. The only control target in this system is
temperature. There are two adjustment valves to change
temperature. An example provided in directory /fide/examples/fans
in the FIDE software package is similar to this basic model.
There is a sensor in the room to monitor temperature for feedback
control, and there are two control elements, cooling valve and
heating valve, to adjust the air supply temperature to the room.
Figure 2 diagrams a fuzzy controller for an air conditioning
system basic model. Rules for this controller may be formulated
using statements similar to:
If temperature is low then open heating valve greatly
Values such as low are defined by fuzzy sets (membership
functions). We can use the MF-edit function in FIDE to define the
fuzzy sets. Generally, membership functions of fuzzy sets take on
a triangular shape because they are effective and easy to
manipulate.
A Modified Model
In the real world, however, it is usually not enough to manage an
air conditioning system with temperature control only. We need to
control humidity as well. A modified air conditioning system is
shown in Figure 3. There are two sensors in this system: one to
monitor temperature and one to monitor humidity. There are three
control elements: cooling valve, heating valve, and humidifying
valve, to adjust temperature and humidity of the air supply.
A fuzzy controller for this modified air conditioning system is
shown in Figure 4. The two inputs to the controller are measured
temperature and humidity. The three outputs are control signals
to the three valves.
Rules for this controller can be formulated by adding rules for
humidity control to those already formulated for temperature
control in the basic model. Additional rules must take the
interference between temperature and humidity into account. For
example, in the winter, when we use heat to raise temperature,
humidity is usually reduced. The air thus becomes too dry. To
address this condition, a rule statement similar to the following
is appropriate:
If temperature is low then open humidifying valve slightly
This rule acts as a predictor of humidity (it leads the humidity
value) and is also designed to prevent overshoot in the output
humidity curve. We could have used the following rule:
If humidity is low then open humidifying valve slightly
But it's action, if acting as the only rule for low humidity,
will be late when low humidity is already the case.
An Advanced Model for Automobile Passenger Environment
Temperature control in an automobile passenger environment is
more complex than that of a static room in a building. To address
driver and passenger comfort and safety, many factors must be
taken into account. Temperature and humidity should be controlled
to provide an enjoyable ride. However, it is also critical to
keep windows from being fogged, which is caused by a temperature
differential between inside and outside air in combination with
the interior humidity. To obtain satisfactory control results,
the strength of sunshine radiation and the automobile speed must
also be factored in.
Figure 5 shows a fuzzy controller which employs five sensors to
obtain data for temperature control and humidity control in an
automobile. A recent industry report on the application of such a
controller on a new model automobile indicates this controller
outperforms conventional control systems substantially. It
prevents rapid change of temperature in the car when doors or
windows are opened and then closed. It even reacts to weather
changes because interior humidity changes caused by the weather
can be detected by sensors.
COMMENTS
Air conditioning systems are essential in most of our daily
lives. Our expectations of such systems have been raised to
demand more than just temperature control, and it is increasingly
desirable to apply these systems in varying situations and
environments. A comfortable and safe environment is often
difficult to define and affected by sometimes contradictory
factors. Fuzzy logic control provides an effective and economic
approach to this problem. Fuzzy controllers incorporated in the
latest model automobiles designed by Japanese auto makers
provide proof that temperature control in diverse environments
can be solved. The key to a good solution lies in thorough
analysis of factors affecting the control target and the kinds
of sensors and sensing techniques used to detect these factors.
We did not provide FIU source code in this note. However we give
examples of the types of rules required. For further
investigation, FIU source code for a temperature control system
can be found in the directory /fide/examples/fans in the FIDE
system provided with the FIDE or FIDE DEMO package.
For an engineer, an ideal machine would be one in which human
requests are automatically interpreted and responded to by
adjusting itself appropriately to variations in the environment.
Fuzzy logic can help make this ideal a reality. At the least, it
makes the effort easier.
(Weijing Zhang, Applications Engineer, Aptronix Inc.)
For Further Information Please Contact:
Aptronix Incorporated
2150 North First Street #300
San Jose, CA 95131
Tel (408) 428-1888
Fax (408) 428-1884
FuzzyNet (408) 428-1883 data 8/N/1
Aptronix Company Overview
Headquartered in San Jose, California, Aptronix develops and
markets fuzzy logic-based software, systems and development tools
for a complete range of commercial applications. The company was
founded in 1989 and has been responsible for a number of
important innovations in fuzzy technology.
Aptronix's product Fide (Fuzzy Inference Development Environment)
-- is a complete environment for the development of fuzzy
logic-based systems. Fide provides system engineers with the
most effective fuzzy tools in the industry and runs in
MS-WindowsTM on 386/486 hardware. The price for Fide is $1495
and can be ordered from any authorized Motorola distributor. For
a list of authorized distributors or more information, please
call Aptronix. The software package comes with complete
documentation on how to develop fuzzy logic based applications,
free telephone support for 90 days and access to the Aptronix
FuzzyNet information exchange.
Temperature Control (2)
FIDE Application Note 005-920903
Aptronix Inc., 1992
programming/FUZZYLOGIC/auto_trn.txt
+216
View File
@@ -0,0 +1,216 @@
INTRODUCTION
Recently fuzzy logic has found increasing applicability in the
field of vehicle control. Applications include automatic
transmission, engine control, cruise control, antiskid braking,
and air conditioning, among others. This application note focuses
on automatic transmission control.
AUTOMATIC TRANSMISSION : BASIC MODEL
A basic automatic transmission system is shown in Figure 1. Fuzzy
logic is employed to infer the best gear selection. The four
fuzzy inference unit inputs are sensor based signals from the car
itself. Using throttle, vehicle speed, engine speed, engine load,
the fuzzy inference unit determines a shift, i.e., gear number,
for the car.
Figure 1 Automatic Transmission System
Definitions of Input/Output Variables
To create a fuzzy inference unit, we first need to define labels
(membership functions) for input and output variables. Examples
of such labels are shown in Figures 2, 3, 4, 5, and 6. The output
variable Shift uses singleton membership functions because the
TVFI (Truth Value Flow Inference) method is the preferred method
of defuzzification.
Figure 2 Labels and Membership Functions of Throttle
Figure 3 Labels and Membership Functions of Vehicle_Speed
Figure 4 Labels and Membership Functions of Engine_Speed
Figure 5 Labels and Membership Functions of Engine_Load
Figure 6 Labels and Membership Functions of Shift
Rules
Using labels as defined above, we can write rules for the fuzzy
inference unit shown in Figure 1. Rules embody the knowledge base
required for decision making. They are represented as English
like if-then statements.
For example, the following is a rule:
IF Throttle is Low and
Vehicle_Speed is Low and
Engine_Speed is Low and
Engine_Load is High
THEN Shift is No_1
We can write many such rules to cover the different situations
encountered in transmission of power to wheel. The totality of
such rules constitutes a fuzzy inference unit for gear selection
in an automobile.
AUTOMATIC TRANSMISSION : MODIFIED MODEL
The performance of the above automatic transmission model is not
very good. The gear shifting procedure is implemented without
taking into account the driving environment. We, as humans, drive
in different "modes" depending on road conditions. For example,
we sometimes drive at a constant low gear when negotiating a
windy mountainous road. This avoids unnecessary gear shifting,
which can add to engine wear and make for a less than smooth ride
for passengers.
With this in mind, a modified transmission system is shown in
Figure 7. We have added an extra input, mode, to the fuzzy
inference unit to influence gear shift behavior. This new driving
mode can be inferred by fuzzy logic(FIU B) as well.
Figure 7 Modified Automatic Transmission System
Figure 8 Fuzzy Inference Unit for Driving Mode
Figure 8 shows a fuzzy inference unit for inferring driving mode.
To create an FIU, we develop rules such as the following:
If Vehicle_Speed is Low and
Variation_of_Vehicle_Speed is Small and
Slope_Resistance is Positive_Large and
Accelerator is Medium then
Mode is Steep_Uphill_Mode
If Vehicle_Speed is Medium and
Variation_of_Vehicle_Speed is Small and
Slope_Resistance is Negative_Large and
Accelerator is Small then
Mode is Gentle_Downhill_Mode
The driving mode output of FIU B can then be further used to
affect the gear shifting procedure. For example, if mode is
Steep_Uphill_Mode, a downshift is necessary in order to obtain
greater engine power. If mode is Gentle_Downhill_Mode, we also
need a lower gear than would be the case for a flat smooth road.
The lower gear provides engine braking power. Typical gear
selection rules could look as follows:
If Mode is Steep_Uphill_Mode then
Shift is No_2
If Mode is Gentle_Downhill_Mode then
Shift is No_3
COMMENTS
In actuality, the inputs to fuzzy inference unit B in Figure 8
could include other factors, such as steering angle, to determine
a more accurate driving mode. With steering angle data, we can
determine whether or not the vehicle is on a winding road. Gear
shifting practices can be quite different on a winding road than
on a straight road.
Again, fuzzy logic provides us with a powerful tool to deal with
complex situations that are intractable using conventional
approaches. We simply include additional variables and rules to
take into account factors that could improve the behavior of our
control system.
(Weijing Zhang, Applications Engineer, Aptronix Inc.)
For Further Information Please Contact:
Aptronix Incorporated
2150 North First Street #300
San Jose, CA 95131
Tel (408) 428-1888
Fax (408) 428-1884
FuzzyNet (408) 428-1883 data 8/N/1
Aptronix Company Overview
Headquartered in San Jose, California, Aptronix develops and
markets fuzzy logic-based software, systems and development tools
for a complete range of commercial applications. The company was
founded in 1989 and has been responsible for a number of
important innovations in fuzzy technology.
Aptronix's product Fide (Fuzzy Inference Development Environment)
-- is a complete environment for the development of fuzzy
logic-based systems. Fide provides system engineers with the
most effective fuzzy tools in the industry and runs in
MS-WindowsTM on 386/486 hardware. The price for Fide is $1495
and can be ordered from any authorized Motorola distributor. For
a list of authorized distributors or more information, please
call Aptronix. The software package comes with complete
documentation on how
FIDE Application Notes Available:
#001
Washing Machine
Decision Making, Determining Wash Time
#002
Automatic Focusing System
Decision Making, Determining Focus
#003
Servo Motor Force Control
Servo Control, Grasping Object
#004
Temperature Control(1)
Process Control, Glass Melting Furnace
#005
Temperature Control(2)
Process Control, Air Conditioner
#006
Temperature Control(3)
Process Control, Reactor
#007
Automatic Transmission
Decision Making, Determining Gear Shift
FIDE Application Note 007-920929 Aptronix Inc., 1992
Automatic Transmission
programming/FUZZYLOGIC/brub1.txt
+140
View File
@@ -0,0 +1,140 @@
Number 21 January 20,1992
The Huntington Technical Brief
By David Brubaker Ph.D.
A Fuzzy Web Tension Controller
---------------------------------------
NOTE: This application is easier to follow
if you have the drawings. If the information
here is important please contact Dr. Brubaker
about a paper version of this issue.
INTRODUCTION
We shall start the year with a description of an application,
for which I thank OMRON Electronics. The application to be
discussed is an industrial control system, specifically a web
tension controller.
DESCRIPTION
A metal film is fed from a supply reel, over a number of pivot
and tension rollers, and onto a take-up reel. As the metal film
is wound from the supply reel to the take-up reel, the tension
rollers are used to keep the film appropriately taut. The
position of the pivot rollers is held constant - that is they
are allowed to rotate but not to move vertically or laterally.
Drive is applied by the controller to both the supply and the
take-up reels.
The system was initially modeled as being linear, and control
was applied using a PID (proportional-integral-derivative)
controller. Unfortunately, action of the film as it moved across
the pivot and tension rollers had significant nonlinearities,
especially during speed changes. The PID controller was forced
to operate at reduced system velocities - higher velocities
resulted in material damage.
With goals of increasing system velocities (and thereby
increasing overall system throughput) and significantly reducing
material damage, a fuzzy approach was implemented. FUZZY
IMPLEMENTATION - Actually a rather simple fuzzy system was
implemented, with eight defined inputs and two outputs. Four
input-output mappings were defined.
The first four inputs are the velocity and acceleration of the
film as it: a) leaves the supply reel (v1 and v1', respectively)
and, b) approaches the take-up reel (v2 and v2', respectively).
The second four inputs are the vertical position variations of
the two tension rollers (dS1 and dS2, respectively) and the
velocities of these two rollers (the derivatives of the position
terms: dS1' and dS2').
The controller generates two outputs, the drives, Dr1 and Dr2, to
the supply and take-up reels. The variables Dr1 and Dr2 are
defined as variations from commanded speed values. Each output is
derived using fuzzy rules from two sets of input values, as shown
below:
(v1, v1') maps to Dr1
(dS1, dS1') maps to Dr1
(v2, v2') maps to Dr2
(dS2, dS2') maps to Dr2
Membership functions for input and output values provide seven
ranges: negative large (NL), negative medium (NM), negative small
(NS), zero (ZE), positive small (PS), positive medium (PM),
positive large (PL). These labels are the same for all eight
inputs and both outputs. Of course each input/output range will
be scaled and defined in units appropriate to the particular
physical parameter.
Each input-to-output mapping (e.g., (v1, v1') maps to ½1) is
calculated independently, but all four mappings use the same
seven entry rule-base. Using the "as... do..." rule format and
the generic variables IN, IN', and OUT, the seven rules are:
1. as (IN is NL) do (OUT is PL)
2. as (IN is NM and IN' is ZE) do (OUT is PM)
3. as (IN is NS and IN' is NS) do (OUT is PS)
4. as ((IN is NS and IN' is PS)
or (IN is ZE and IN' is ZE)
or (IN is PS and IN' is NS) do (OUT is ZE)
5. as (IN is PS and IN' is PS) do (OUT is NS)
6. as (IN is PM and IN' is ZE) do (OUT is NM)
7. as (IN is PL) do (OUT is NL)
At each system time increment, each output will have several
designated actions, both as a result of overlapping input values
on a single rule mapping, and also because two sets of inputs
drive a single output. Multiple actions are combined using a
standard center-of-gravity, or centroid approach.
RESULTS
Although a straightforward design, in actual operation
the fuzzy system handles admirably. System throughput (resulting
in no material damage) was double that of the PID controller.
Important side benefits were:
*Set-up time was greatly reduced.
*Maintenance time was greatly reduced.
*Adjustments to the system could be made by in-house personnel,
rather than a PID expert, as had been the case with the previous
system.
My thanks to OMRON Electronics, and to Brent Schnell, OMRON
senior sales engineer, in particular.
----------------------------------------------------------------
The Huntington Technical Brief is published, monthly and free
of charge, as part of the marketing effort of Dr. David Brubaker
of The Huntington Group. A full collection of past issues
(starting with number 5 -- issues 1 through 4 are unrelated to
fuzzy logic and are unavailable) may be obtained for $10.00. The
42-page report "Introduction to Fuzzy Logic Systems" is
available for $35.00.
For the past fifteen years Dr. Brubaker has provided
technical consulting services in the design of complex systems,
real-time, embedded processor systems, and for the past four
years, fuzzy logic systems. If you need out-of-house expertise
in any of these, please call 415-325-7554.
----------------------------------------------------------------
Copyright 1992 by The Huntington Group
883 Santa Cruz Avenue,Suite 27 Menlo Park, CA 94025-4608
This information is provided by
Aptronix FuzzyNet
408-428-1883 Data USR V.32bis
programming/FUZZYLOGIC/brub2.txt
+174
View File
@@ -0,0 +1,174 @@
Number 22 February 17,1992
The Huntington Technical Brief
By David Brubaker Ph.D.
Dynamic Extent of Fuzzy Variables
---------------------------------
INTRODUCTION
Largely because fuzzy rule-based systems are in their infancy,
those active in the field are still discovering new and powerful
variations on the basic structure. On two projects in the past
few months I have had need of a capability not yet found in the
available fuzzy tools, being able to dynamically modify the
extent associated with a given fuzzy variable.
A fuzzy variable's extent is the range over which it can vary.
Extent modification falls into two categories: a one-time only
modification during system initialization, called DEFINED EXTENT;
and ongoing repetitive modification during system operation -
CONTROLLED EXTENT.
EXTENT
The extent of a fuzzy variable is described by three parameters:
a minimum value, a maximum value, and a density function. These
are the crisp boundary values of the variable. The density
function is a little more complex and will be discussed later in
this brief.
A fuzzy variable's extent can be operated upon. Three operations
provide a basic set: SHIFT, EXPANSION, and COMPRESSION.
An extent is SHIFTED when the positions of its minimum and
maximum values change, but the distance between them does not. An
extent is EXPANDED when the distance between minimum and maximum
values is greater than that of the original function. The
expansion can be about any point within the extent, although will
typically be defined either about the center point or one of the
end points.
An extent is COMPRESSED when the distance between minimum and
maximum is less than that of the original function.
Either expansion or compression can be combined with shifting.
An extent's density function has to do with expansion and
compression. If density is uniform, when either expansion or
compression occurs, the lateral dimensions of all features within
the extent (that is, the membership functions) will change in
proportion to the change in the extent. If the density function
is non-uniform, the lateral dimensions of some regions of the
extent will change differently than those of others. Using a
non-uniform density function allows emphasizing portions of the
fuzzy variable, for example around a crisp value of importance.
The extent of a fuzzy variable is implicitly defined as part of
the system design process, during membership function definition,
and is therefore static. Static extent definition can be thought
of as occurring at compile time. The need can arise, however, for
dynamic extent definition, and this can occur either once, during
initialization (DEFINED EXTENT) or on an ongoing basis, during
runtime (CONTROLLED EXTENT).
DEFINED EXTENT - Defined extent occurs when minimum and maximum
values are defined during the initialization sequence. The
resulting fuzzy variable and its membership functions can
potentially be both shifted and expanded or compressed. In its
simplest form, and with definition of minimum and maximum values
only, a uniform extent density is assumed.
Defined extent will typically have as a basis a statistically
defined extent in the form of a fuzzy variable and associated
membership functions defined as part of the design. This
default definition is used to provide the number and relative
widths of the membership functions. The initialization process
will then modify this default extent, based on calculated or
measured minimum and maximum values.
As an example of defined extent, consider a fuzzy database and
analysis program used in anthropology, with an input variable
HEIGHT. If the default extent of HEIGHT is based on American men
it would range (arbitrarily) from a minimum of 60" to a maximum
of 84".
Now consider using the program to gather and process data on
non-American cultures. Looking at extremes, we might be
interested in members of a pygmy tribe, where both minimum and
maximum would drop by a foot or more, or a Watusi tribe, where
both minimum and maximum would increase on the order of six
inches or more. In both cases, the initialization sequence would
take statistics on the population and derive appropriate minimum
and maximum values. The extent of the variable HEIGHT would be
shifted (and possibly expanded or compressed) appropriately.
Once in place, the newly defined extent, with its corresponding
membership functions, would be used to more accurately perform
the analysis functions of the program.
CONTROLLED EXTENT
Controlled extent is quite similar to defined extent, except
that it occurs on an ongoing basis during system operation. Its
justification is that the meaning of values (membership
functions) assigned to a given fuzzy variable may change with
context - here changing context is loosely defined as changing
input values.
As an example, consider a train deceleration controller that has
DISTANCE_TO_DESTINATION as a fuzzy variable, and NEAR as one of
its values. What constitutes being NEAR the destination tends to
be a function of the actual distance left to travel, the distance
thus far traveled, and the velocity of the train. For example, on
a 2000 km trip, with 10 km left to go and traveling at 100 km/hr,
the train could be considered NEAR its destination. (If it were
traveling at 2 km/hr this would not be the case.) Similarly,
with 50 meters to go, and traveling at 5km/hr, the train is
still NEAR, and with 5 meters left and traveling at 1 km/hr, it
is still NEAR, although both times with different connotations.
In each case, the actual distance to destination is quite
different, but in the context of the other inputs, NEAR ( to some
degree of membership) is a valid value of DISTANCE_TO_DESTINATION.
Controlled extent, like defined extent, is most easily based on a
default. The new extent is then defined as a function of one or
more inputs/outputs. At each system time increment, this function
is calculated, and the new extent determined. Membership
functions associated with this extent are then used as part of
the normal, ongoing fuzzy inference process.
This control function might take a number of forms. It may be a
simple proportional relationship between one or more of the
system inputs/outputs and the extent. It also might be more
complex, involving derivatives and integrals of input/output
values - in effect a linear system. Or it might take the form of
a fuzzy system in of itself, with the inputs being a
(potentially) reduced set of the system's inputs/outputs, and the
outputs being the extent parameters for the given variable.
SUMMARY
This issue has been a brief investigation of dynamic fuzzy
variable extents, resulting in modifiable membership functions.
Although many possible techniques may be used, we have discussed
DEFINED (at initialization) and CONTROLLED (run-time) EXTENTS,
allowing shift and expansion/compression operations.
----------------------------------------------------------------
The Huntington Technical Brief is published, monthly and free
of charge, as part of the marketing effort of Dr. David Brubaker
of The Huntington Group. A full collection of past issues
(starting with number 5 -- issues 1 through 4 are unrelated to
fuzzy logic and are unavailable) may be obtained for $10.00. The
42-page report "Introduction to Fuzzy Logic Systems" is available
for $35.00.
For the past fifteen years Dr. Brubaker has provided
technical consulting services in the design of complex systems,
real-time, embedded processor systems, and for the past four
years, fuzzy logic systems. If you need out-of-house expertise
in any of these, please call 415-325-7554.
----------------------------------------------------------------
Copyright 1992 by The Huntington Group
883 Santa Cruz Avenue, Suite 27 Menlo Park, CA 94025-4608
This information is provided by
Aptronix FuzzyNet
408-428-1883 Data USR V.32bis
programming/FUZZYLOGIC/focus.pro
+212
View File
@@ -0,0 +1,212 @@
INTRODUCTION
Cameras with automatic focusing systems usually measure the
distance to the center of a finder's view. This method, however,
is inaccurate when the object of interest is not at the center of
the view (Figure 1). Measuring more than one distance is an
approach that may solve this problem. The following example shows
the application of fuzzy inference as a means of automatically
determining correct focus distance.
FUZZY INFERENCE
Objective
Determine the object distance using three distance measures for
an automatic camera focusing system.
Definition of Input/Out Variables
Inputs to the FIU (Fuzzy Inference Unit) are three distance
measures at left, center and right points in the finder view.
Outputs are the plausibility values associated with these three
points (Figure 2). The point with the highest plausibility is
deemed to be the object of interest. Its distance is then
forwarded to the automatic focusing system.
Each input variable, representing distance, has three labels:
Near, Medium, and Far. Each output variable, representing
plausibility, has four labels: Low, Medium, High, and VeryHigh.
Membership functions corresponding to these labels are shown in
Figures 3a and 3b.
Fuzzy Rules
The guiding principle for establishing rules of this automatic
focusing system is that the likelihood of an object being at
medium distance (typically 10 meters) is high, and becomes very
low as distance increases (say, more than 40 meters).
Source Code of Fuzzy Inference Unit
$ FILENAME: camera/af1.fil
$ DATE: 07/29/92
$ UPDATE: 08/06/92
$ Three inputs, three outputs, decision making for
$ Automatic Focusing System
$ INPUT(S): Left(Distance), Center(Distance),
$ Right(Distance)
$ OUTPUT(S): Plau(sibility)_of_Left,
$ Plau(sibility)_of_Center, Plau(sibility)_of_Right
$ FIU HEADER
fiu tvfi (min max) *8;
$ DEFINITION OF INPUT VARIABLE(S)
invar Left "meter" : 1 () 100 [
Far (@10, 0, @40, 1, @100, 1),
Medium (@1, 0, @10, 1, @40, 0),
Near (@1, 1, @10, 0)
];
invar Center "meter" : 1 () 100 [
Far (@10, 0, @40, 1, @100, 1),
Medium (@1, 0, @10, 1, @40, 0),
Near (@1, 1, @10, 0)
];
invar Right "meter" : 1 () 100 [
Far (@10, 0, @40, 1, @100, 1),
Medium (@1, 0, @10, 1, @40, 0),
Near (@1, 1, @10, 0)
];
$ DEFINITION OF OUTPUT VARIABLE(S)
outvar Plau_of_Left "degree" : 0 () 1 * (
VeryHigh = 1.0,
High = 0.8,
Medium = 0.5,
Low = 0.3
);
outvar Plau_of_Center "degree" : 0 () 1 * (
VeryHigh = 1.0,
High = 0.8,
Medium = 0.5,
Low = 0.3
);
outvar Plau_of_Right "degree" : 0 () 1 * (
VeryHigh = 1.0,
High = 0.8,
Medium = 0.5,
Low = 0.3
);
$ RULES
if Left is Near then Plau_of_Left is Medium;
if Center is Near then Plau_of_Center is Medium;
if Right is Near then Plau_of_Right is Medium;
if Left is Near and Center is Near and Right is Near then
Plau_of_Center is High;
if Left is Near and Center is Near then Plau_of_Left is Low;
if Right is Near and Center is Near then Plau_of_Right is Low;
if Left is Medium then Plau_of_Left is High;
if Center is Medium then Plau_of_Center is High;
if Right is Medium then Plau_of_Right is High;
if Left is Medium and Center is Medium and Right is Medium then
Plau_of_Center is VeryHigh;
if Left is Medium and Center is Medium then Plau_of_Left is Low;
if Right is Medium and Center is Medium then Plau_of_Right is Low;
if Left is Far then Plau_of_Left is Low;
if Center is Far then Plau_of_Center is Low;
if Right is Far then Plau_of_Right is Low;
if Left is Far and Center is Far and Right is Far then
Plau_of_Center is High;
if Left is Medium and Center is Far then Plau_of_Center is Low;
if Right is Medium and Center is Far then Plau_of_Center is Low
end
Input/Output Response
Now let us compile the FIU source code given above and use the
FIDE analyzer to see how this unit works. Figures 4a and 4b
provide two input/output response surfaces of the FIU. From
Figure 4a, we see that Plausibility_of_Center becomes high when
the distance at the center is around 10 meters, a distance we
defined to be Medium in the definition of input variables. It
becomes lower when the distance increases, especially when the
distance on the left is Medium. Figure 4b shows the
Plausibility_of_Left is high when the distance on the left is
around 10 meters. In this case, when the distance at the center
is about the same as that on the left, we choose center as the
desired object. The Plausibility_of_Right is similar to the
Plausibility_of_Left. The three outputs of the FIU are compared
to identify the point with highest plausibility. The distance
at this point is the focus distance. By adjusting the membership
functions of the distance labels, we can achieve different response
surfaces for different purposes.
COMMENTS
Remember that this example is provided only for easy-to-use
compact cameras targeted for the mass market. For professional
photographers it may be inappropriate to provide strictly
automatic camera focusing using the three distance measures
method. However, if suitable manual overrides were available, it
would still be useful as an option in some situations (e.g. when
speed is important). Besides automatic focusing(AF), fuzzy logic
can be used in automatic exposure(AE) and automatic zooming(AZ).
For AE and and AZ, the input/output variables and rules of the FIU
will be different from those shown above for AF, but the design
process is very similar.
(Weijing Zhang, Applications Engineer, Aptronix Inc.)
For Further Information Please Contact:
Aptronix Incorporated
2150 North First Street #300
San Jose, CA 95131
Tel (408) 428-1888
Fax (408) 428-1884
FuzzyNet (408) 428-1883 data 8/N/1
Aptronix Company Overview
Headquartered in San Jose, California, Aptronix develops and
markets fuzzy logic-based software, systems and development
tools for a complete range of commercial applications. The
company was founded in 1989 and has been responsible for a
number of important innovations in fuzzy technology.
Aptronix's product Fide (Fuzzy Inference Development
Environment) -- is a complete environment for the development of
fuzzy logic-based systems. Fide provides system engineers with
the most effective fuzzy tools in the industry and runs in
MS-Windows(TM) on 386/486 hardware. The price for Fide is $1495 and
can be ordered from any authorized Motorola distributor. For a
list of authorized distributors or more information, please
call Aptronix. The software package comes with complete
documentation on how to develop fuzzy logic based applications,
free telephone support for 90 days and access to the Aptronix
FuzzyNet information exchange.
Automatic Focusing System
FIDE Application Note 002-150892
Aptronix Inc., 1992
programming/FUZZYLOGIC/fuzzwash.txt
+220
View File
@@ -0,0 +1,220 @@
INTRODUCTION
When you use a washing machine, you generally select the length
of wash time based on the amount of clothes you wish to wash and
the type and degree of dirt you have. To automate this process,
we use sensors to detect these parameters (i.e. volume of
clothes, degree and type of dirt). The wash time is then
determined from this data. Unfortunately, there is no easy way
to formulate a precise mathematical relationship between volume
of clothes and dirt and the length of wash time required.
Consequently, this problem has remained unsolved until very
recently. People simply set wash times by hand and from
personal trial and error experience. Washing machines were not
as automatic as they could be.
To build a more fully automatic washing machine with self
determining wash times, we are going to focus on two subsystems
of the machine: (1) the sensor mechanism and (2) the controller
unit. The sensor system provides external input signals into the
machine from which decisions can be made. It is the controller's
responsibility to make the decisions and to signal the outside
world by some form of output. Because the input/output
relationship is not clear, the design of a washing machine
controller has not in the past lent itself to traditional
methods of control design. We address this design problem using
fuzzy logic and Fide.
FUZZY CONTROLLER
Objective: Design a washing machine controller which gives the
correct wash time even though a precise model of the input/output
relationship is not available.
Input/Output of Controller: Figure 1 shows a diagram of
the fuzzy logic controller. There are two inputs: (1) one for the
degree of dirt on the clothes and (2) one for the type of dirt on
the clothes. These two inputs can be obtained from a single
optical sensor. The degree of dirt is determined by the
transparency of the wash water. The dirtier the clothes, the
lower the transparency for a fixed amount of water. On the
other hand, the type of dirt is determined from the saturation
time, the time it takes to reach saturation. Saturation is the
point at which the change in water transparency is close to zero
(below a given number). Greasy clothes, for example, take longer
for water transparency to reach saturation because grease is less
water soluble than other forms of dirt. Thus a fairly
straightforward sensor system can provide the necessary inputs
for our fuzzy controller.
Definition of Input/Output Variables: Before designing the
controller, we must determine the range of possible values for
the input and output variables. These are the membership
functions used to translate real world values to fuzzy values and
back. Figure 2 shows the labels of input and output
variables and their associated membership functions. Values
for the input variables dirtiness and type_of_dirt are
normalized (range of 0 to 100) over the domain of optical
sensor values.
Note that wash_time membership functions are singletons (crisp
numbers) in this example. We can use fuzzy sets or singletons
for output variables. Singletons are simpler than fuzzy sets.
They need less memory space and work faster. If we could not be
satisfied by the result when output values are given by singletons
we could change them into fuzzy sets. Remember that when we use
TVFI method for inference we can only use singltons as values of
outputs. We should use Mandani's method for inference if we want
to define output values as fuzzy sets. Details about TVFI and
Mandani's method can be found in the FIDE User's Manual.
Rules: The decision making capabilities of a fuzzy controller
are codified in a set of rules. In general, the rules are
intuitive and easy to understand, since they are qualitative
statements written in English like if-then sentences. Rules for
our washing machine controller are derived from common sense,
data taken from typical home use, and experimentation in a
controlled environment. A typical intuitive rule is as follows:
If saturation time is long and transparency is bad, then
wash time should be long.
From different combinations of these and other conditions, we
write the rules necessary to build our washing machine
controller.
FIU source code: FIU stands for Fuzzy Inference Unit. This is
the fundamental unit in which FIDE encodes controller
information. The FIU includes input and output variable
definitions and the rules of the application. The following is a
listing of the FIU source for a possible washing machine fuzzy
logic controller. Figure 3 shows the response surface of the
input-output relation as determined by this FIU. FIU language
syntax and the response function are fully explained in FIDE's
User and Reference Manuals.
------ FIU source code begins here ------
$ FILENAME: washmach\wash1.fil $ DATE: July 23, 1992
$ UPDATE: July 29, 1992
$ CONTROLLER for Washing Machine: Two
$ inputs, one output, open-loop control
$ INPUT(S): dirtiness_of_clothes, type_of_dirt
$ OUTPUT(S): wash_time
$ FIU HEADER
fiu tvfi (min max) *8;
$ DEFINITION OF INPUT VARIABLE(S)
invar dirtiness_of_clothes "degree" : 0 () 100 [
Large (@50, 0, @100, 1),
Medium (@0, 0, @50, 1, @100, 0),
Small (@0, 1, @50, 0)
];
invar type_of_dirt "degree" : 0 () 100 [
Greasy (@50, 0, @100, 1),
Medium (@0, 0, @50, 1, @100, 0),
NotGreasy (@0, 1, @50, 0)
];
$ DEFINITION OF OUTPUT VARIABLE(S)
outvar wash_time "minute" : 0 () 60 * (
VeryLong = 60,
Long = 40,
Medium = 20,
Short = 12,
VeryShort = 8
);
$ RULES
if dirtiness_of_clothes is Large and type_of_dirt is Greasy
then wash_time is VeryLong;
if dirtiness_of_clothes is Medium and type_of_dirt is Greasy
then wash_time is Long;
if dirtiness_of_clothes is Small and type_of_dirt is Greasy
then wash_time is Long;
if dirtiness_of_clothes is Large and type_of_dirt is Medium
then wash_time is Long;
if dirtiness_of_clothes is Medium and type_of_dirt is Medium
then wash_time is Medium;
if dirtiness_of_clothes is Small and type_of_dirt is Medium
then wash_time is Medium;
if dirtiness_of_clothes is Large and type_of_dirt is NotGreasy
then wash_time is Medium;
if dirtiness_of_clothes is Medium and type_of_dirt is NotGreasy
then wash_time is Short;
if dirtiness_of_clothes is Small and type_of_dirt is NotGreasy
then wash_time is VeryShort
end
------ FIU source code ends here ------
CONCLUSION
A more fully automatic washing machine is straightforward to
design using fuzzy logic technology. Moreover, the design
process mimics human intuition, which adds to the ease of
development and future maintenance. Although this particular
example controls only the wash time of a washing machine, the
design process can be extended without undue complications to
other control variables such as water level and spin speed. The
formulation and implementation of membership functions and rules
is similar to that shown for wash time.
(Weijing Zhang, Applications Engineer, Aptronix Inc.)
NEXT ISSUE: Automatic Focusing System Uses fuzzy inference to
determine object distance from three measures for automatic
focusing system in a camera.
For Further Information Please Contact:
Aptronix Incorporated
2150 North First Street #300
San Jose, CA 95131
Tel (408) 428-1888
Fax (408) 428-1884
FuzzyNet (408) 428-1883 data 8/N/1
Aptronix Company Overview
Headquartered in San Jose, California, Aptronix develops and
markets fuzzy logic-based software, systems and development
tools for a complete range of commercial applications. The
company was founded in 1989 and has been responsible for a
number of important innovations in fuzzy technology.
Aptronix's product Fide (Fuzzy Inference Development
Environment) -- is a complete environment for the development of
fuzzy logic-based systems. Fide provides system engineers with
the most effective fuzzy tools in the industry and runs in
MS-Windows(TM) on 386/486 hardware. The price for Fide is $1495 and
can be ordered from any authorized Motorola distributor. For a
list of authorized distributors or more information, please
call Aptronix. The software package comes with complete
documentation on how to develop fuzzy logic based applications,
free telephone support for 90 days and access to the Aptronix
FuzzyNet information exchange.
Washing Machine
FIDE Application Note 001-270792
Aptronix Inc., 1992
programming/FUZZYLOGIC/fuzzy.txt
+521
View File
@@ -0,0 +1,521 @@
FUZZY SYSTEMS - A TUTORIAL
by
James F. Brule'
(c) Copyright James F. Brule' 1985. Permission to copy without fee all or
part of this material is granted provided that the copies are not made or
distributed for direct commerical advantage, the copyright notice and the
title and date appear, and notice is given that copying is by permission of
the author. To copy otherwise, or to republish, requires a fee and/or specific
permission.
INTRODUCTION
Fuzzy sytems is an alternative to traditional notions of set membership and
logic that has its origins in ancient Greek philosophy, and applications at
the leading edge of Artificial Intelligence. Yet, despite its long-standing
origins, it is a relatively new field, and as such leaves much room for
development. This paper will present the foundations of fuzzy systems, along
with some of the more noteworthy objections to its use, with examples drawn
from current research in the field of Artificial Intelligence. Ultimately, it
will be demonstrated that the use of fuzzy systems makes a viable addition to
the field of Artificial Intelligence, and perhaps more generally to formal
mathematics as a whole.
THE PROBLEM: REAL-WORLD VAGUENESS␍
␍
Natural language abounds with vague and imprecise concepts, such as "Sally
is tall," or "It is very hot today." Such statements are difficult to
translate into more precise language without losing some of their semantic
value: for example, the statement "Sally's height is 152 cm." does not
explicitly state that she is tall, and the statement "Sally's height is 1.2
standard deviations about the mean height for women of her age in her culture"
is fraught with difficulties: would a woman 1.1999999 standard deviations
above the mean be tall? Which culture does Sally belong to, and how is
membership in it defined?
While it might be argued that such vagueness is an obstacle to clarity of
meaning, only the most staunch tradtionalists would hold that there is no loss
of richness of meaning when statements such as "Sally is tall" are discarded
from a language. Yet this is just what happens when one tries to translate
human language into classic logic. Such a loss is not noticed in the
development of a payroll program, perhaps, but when one wants to allow for
Šnatural language queries, or "knowledge representation" in expert systems, the
meanings lost are often those being searched for.
For example, when one is designing an expert sstem to mimic the diagnostic
powers of a physician, one of the major tasks i to codify the physician's
decision-making process. The designer soon learns that the physician's view of
the world, despite her dependence upon precise, scientific tests and
measurements, incorporates evaluations of symptoms, and relationships between
them, in a "fuzzy," intutive manner: deciding how much of a particular
medication to administer will have as much to do with the physician's sense of
the relative "strength" of the patient's symptoms as it will their
height/weight ratio. While some of the decisions and calculations could be
done using traditional logic, we will see how fuzzy systems affords a broader,
richer field of data and the manipulation of that data than do more
traditional methods.
HISTORIC FUZZINESS
The precision of mathematics owes its success in large part to the efforts
of Aristotle and the philosophers who preceded him. In their efforts to devise ␍
a concise theory of logic, and later mathematics, the so-called "Laws of
Thought" were posited [7]. One of these, the "Law of the Excluded Middle,"
states that every proposition must either be True or False. Even when
Parminedes proposed the first version of this law (around 400 B.C.) there were
strong and immediate objections: for example, Heraclitus proposed that things
could be simultaneously True and not True.
It was Plato who laid the foundation for what would become fuzzy logic,
indicating that there was a third region (beyond True and False) where these
opposites "tumbled about." Other, more modern philosophers echoed his
sentiments, notably Hegel, Marx, and Engels. But it was Lukasiewicz who first
proposed a systematic alternative to the bi-valued logic of Aristotle [8].
In the early 1900's, Lukasiewicz described a three-valued logic, along with
the mathematics to accompany it. The third value he proposed can best be
translated as the term "possible," and he assigned it a numeric value between
True and False. Eventually, he proposed an entire notation and axiomatic
system from which he hoped to derive modern mathematics.
Later, he explored four-valued logics, five-valued logics, and then
declared that in principle there was nothing to prevent the derivation of an
infinite-valued logic. Lukasiewicz felt that three- and infinite-valued logics
were the most intriguing, but he ultimately settled on a four-valued logic
because it seemed to be the most easily adaptable to Aristotlean logic.
Knuth proposed a three-valued logic similar to Lukasiewicz's, from which he
speculated that mathematics would become even more elegant than in traditional
Šbi-valued logic. His insight, apparently missed by Lukasiewicz, was to use the
integral range [-1, 0 +1] rather than [0, 1, 2]. Nonetheless, this alternative
failed to gain acceptance, and has passed into relative obscurity.
It was not until relatively recently that the notion of an infinite-valued
logic took hold. In 1965 Lotfi A. Zadeh published his seminal work "Fuzzy
Sets" ([12], [13]) which described the mathematics of fuzzy set theory, and by
extension fuzzy logic. This theory proposed making the membership function (or ␍
the values False and True) operate over the range of real numbers [0.0, 1.0].
New operations for the calculus of logic were proposed, and showed to be in
principle at least a generalization of classic logic. It is this theory which
we will now discuss.
BASIC CONCEPTS
The notion central to fuzzy systems is that truth values (in fuzzy logic)
or membership values (in fuzzy sets) are indicated by a value on the range
[0.0, 1.0], with 0.0 representing absolute Falseness and 1.0 representing
absolute Truth. For example, let us take the statement:
"Jane is old."
If Jane's age was 75, we might assign the statement the truth value of
0.80. The statement could be translated into set terminology as follows:
"Jane is a member of the set of old people."
This statement would be rendered symbolically with fuzzy sets as:
mOLD(Jane) = 0.80
where m is the membership function, operating in this case on the fuzzy set of
old people, which returns a value between 0.0 and 1.0.
At this juncture it is important to point out the distinction between fuzzy
systems and probability. Both operate over the same numberic range, and at
first glance both have similar values: 0.0 representing False (or non-
membership), and 1.0 representing True (or membership). However, there is a
distinction to be made between the two statements: The probabilistic approach
yields the natural-language statement, "There is an 80% chance that Jane is
old," while the fuzzy terminology corresponds to "Jane's degree of membership
within the set of old people is 0.80." The semantic difference is significant:
the first view supposes that Jane is or is not old (still caught in the Law of
the Excluded Middle); it is just that we only have an 80% chance of knowing
Šwhich set she is in. By contrast, fuzzy terminology supposes that jane is
"more or less" oild, or some other term correspondig to the value of 0.80.
Further distinctions arising out of the operations will be noted below.
The next step in establishing a complete system of fuzzy logic is to define
the operations of EMPTY, EQUAL, COMPLEMENT (NOT), CONTAINMENT, UNION (OR), and
INTERSECTION (AND). Before we can do this rigorously, we must state some
formal definitions:
Definition 1: Let X be some set of objects, with elements noted as x. Thus,
X = {x}.
Definition 2: A fuzzy set A in X is characterized by a membership function
mA(x) which maps each point in X onto the real interval [0.0, 1.0]. As
mA(x) approaches 1.0, the "grade of membership" of x in A increases.
Definition 3: A is EMPTY iff for all x, mA(x) = 0.0.
Definition 4: A = B iff for all x: mA(x) = mB(x) [or, mA = mB].
Definition 5: mA' = 1 - mA.
Definition 6: A is CONTAINED in B iff mA <= mB.
Definition 7: C = A UNION B, where: mC(x) = MAX(mA(x), mB(x)).
Definition 8: C = A INTERSECTION B where: mC(x) = MIN(mA(x), mB(x)).
It is important to note the last two operations, UNION (OR) and
INTERSECTION (AND), which represent the clearest point of departure from a
probabilistic theory for sets to fuzzy sets. Operationally, the differences
are as follows:
For independent events, the probabilistic operation for AND is
multiplication, which (it can be argued) is counterintuitive for fuzzy
systems. For example, let us presume that x = Bob, S is the fuzzy set of smart
people, and T is the fuzzy set of tall people. Then, if mS(x) = 0.90 and
uT(x) = 0.90, the probabilistic result would be:
mS(x) * mT(x) = 0.81
whereas the fuzzy result would be:
Š
MIN(uS(x), uT(x)) = 0.90
The probabilistic calculation yields a result that is lower than either of the
two initial values, which when viewed as "the chance of knowing" makes good
sense.
However, in fuzzy terms the two membership functions would read something
like "Bob is very smart" and "Bob is very tall." If we presume for the sake of
argument that "very" is a stronger term than "quite," and that we would
correlate "quite" with the value 0.81, then the semantic difference becomes
obvious. The probabilistic calculation would yield the statement
If Bob is very smart, and Bob is very tall, then Bob is a quite tall,
smart person.
The fuzzy calculation, however, would yield
If Bob is very smart, and Bob is very tall, then Bob is a very tall,
smart person.
Another problem arises as we incorporate more factors into our equations
(such as the fuzzy set of heavy people, etc.). We find that the ultimate
result of a series of AND's approaches 0.0, even if all factors are initially
high. Fuzzy theorists argue that this is wrong: that five factors of the value
0.90 (let us say, "very") AND'ed together, should yield a value of 0.90
(again, "very"), not 0.59 (perhaps equivalent to "somewhat").
Similarly, the probabilistic version of A OR B is (A+B - A*B), which
approaches 1.0 as additional factors are considered. Fuzzy theorists argue
that a sting of low membership grades should not produce a high membership
gradel instead, the limit of the resulting membership grade should be the
strongest membership value in the collection.
Other values have been established by other authors, as have other
operations. Baldwin [1] proposes a set of truth value restrictions, such as
"unrestricted" (mX = 1.0), "impossible" (mX = 0.0), etc.
The skeptical observer will note that the assignement of values to
linguistic meanings (such as 0.90 to "very") and vice versa, is a most
imprecise operation. Fuzzy systems, it should be noted, kay no claim to
establishing a formal procedure for assignments at this level; in fact, the
only argument for a particular assignment is its intuitive strength. What
fuzzy logic does propose is to establish a formal method of operating on these
values, once the primitives have been established.
Š
HEDGES
Another important feature of fuzzy systems is the ability to define ␍
"hedges," or modifier of fuzzy values. These operations are provided in an
effort to maintain close ties to natural language, and to allow for the
generation of fuzzy statements through mathematical calculations. As such, the
initial definition of hedges and operations upon them will be quite a
subjective process and may vary from one project to another. Nonetheless, the
system ultimately derived operates with the same formality as classic logic.
The simplest example is in which one transforms the statement "Jane is old"
to "Jane is very old." The hedge "very" is usually defined as follows:
m"very"A(x) = mA(x)^2
Thus, if mOLD(Jane) = 0.8, then mVERYOLD(Jane) = 0.64.
Other common hedges are "more or less" [typically SQRT(mA(x))], "somewhat,"
"rather," "sort of," and so on. Again, their definition is entirely
subjective, but their operation is consistent: they serve to transform
membership/truth values in a systematic manner according to standard
mathematical functions.
A more involved approach to hedges is best shown through the work of
Wenstop [11] in his attempt to model organizational behavior. For his study,
he constructed arrays of values for various terms, either as vectors or
matrices. Each term and hedge was represented as a 7-element vector or 7x7
matrix. He ten intuitively assigned each element of every vector and matrix a
value between 0.0 and 1.0, inclusive, in what he hoped was intuitively a
consistent manner. For example, the term "high" was assigned the vector
0.0 0.0 0.1 0.3 0.7 1.0 1.0
and "low" was set equal to the reverse of "high," or
1.0 1.0 0.7 0.3 0.1 0.0 0.0
Wenstop was then able to combne groupings of fuzzy statements to create new ␍
fuzzy statements, using the APL function of Max-Min matrix multiplication.
These values were then translated back into natural language statements, so
Šas to allow fuzzy statements as both input to and output from his simulator.
For example, when the program was asked to generate a label "lower than sortof
low," it returned "very low;" "(slightly higher) than low" yielded "rather
low," etc.
The point of this example is to note that algorithmic procedures can be
devised which translate "fuzzy" terminology into numeric values, perform
reliable operations upon those values, and then return natural language
statements in a reliable manner.
Similar techniques have been adopted by others, primarily in the study of ␍
fuzzy systems as applicable to linguistic approximation (e.g. [2], [3], [4]).
APL appears to be the language of choice, owing to its flexibility and power
in matrix operations.
OBJECTIONS
It would be remarkable if a theory as far-reaching as fuzzy systems did not
arouse some objections in the professional community. While there have been
generic complaints about the "fuzziness" of the process of assigning values to
linguistic terms, perhaps the most cogent criticisms come from Haack [6]. A
formal logician, Haack argues that there are only two ares in which fuzzy
logic could possibly be semonstrated to be "needed," and then maintains that
in each case it can be shown that fuzzy logic is not necessary.
The first area Haack defines is that of the nature of Truth and Falsity: if
it could be shown, she maintains, that these are fuzzy values and not discrete
ones, then a need for fuzzy logic would have been demonstrated. The other area
she identifies is that of fuzzy systems' utility: if it could be demonstrated
that generalizing classic logic to encompass fuzzy logic would aid in
calculations of a given sort, then again a need for fuzzy logic would exist.
In regards to the first statement, Haack argues that True and False are
discrete terms. For example, "The sky is blue" is either true or false; any
fuzziness to the statement arises from an imprecise definition of terms, not
out of the nature of Truth. As far as fuzzy systems' utility is concerned, she
maintains that no area of data manipulation is made easier through the
introduction of fuzzy calculus; if anything, she says, the calculations become
more complex. Therefore, she asserts, fuzzy logic is unnecessary.
Fox [5] has responded to her objetions, indicating that there are three
areas in which fuzzy logic can be of benefit: as a "requisite" apparatus (to
describe real-world relationships which are inherently fuzzy); as a
"prescriptive" apparatus (because some data is fuzzy, and therefore requires a
fuzzy calculus); and as a "descriptive" apparatus (because some inferencing
systems are inherently fuzzy).
Š
His most powerful arguments come, however, from the notion that fuzzy and
classic logics need not be seen as competitive, but complementary. He argues
that many of Haack's objections stem from a lack of semantic clarity, and that
ultimately fuzzy statements may be translatable into phrases which classical
logicians would find palatable.
Lastly, Fox argues that despite the objections of classical logicians,
fuzzy logic has found its way into the world of practical applications, and
has proved very successful there. He maintains, pragmatically, that this is
sufficient reason for continuing to develop the field.
APPLICATIONS
Areas in which fuzzy logic has been successfully applied are often quite
concrete. The first major commercial application was in the area of cement
kiln control, an operation which requires that an operator monitor four
internal states of the kiln, control four sets of operations, and dynamically
manage 40 or 50 "rules of thumb" about their interrelationships, all with the
goal of controlling a highly complex set of chemical interactions. One such
rule is "If the oxygen percentage is rather high and the free-lime and kiln-
drive torque rate is normal, decrease the flow of gas and slightly reduce the
fuel rate" (see Zadeh [14]). A complete accounting of this very successful
system can be found in Umbers and King [10].
The objection has been raised that utilizing fuzzy systems in a dynamic
control environment raises the likelihood of encountering difficult stability
problems: since in control conditions the use of fuzzy systems can roughly
correspond to using threshholds, there must be significant care taken to
insure that oscillations do not develop in the "dead spaces" between
threshhold triggers. This seems to be an important area for future research.
Other applications which have benefited through the use of fuzzy systems
theory have been information retrieval systems, a navigation system for
automatic cars, a predictive fuzzy-logic controller for automatic operation of
trains, laboratory water level controllers, controllers for robot arc-welders,
feature-definition controllers for robot vision, graphics controllers for
automated police sketchers, and more.
Expert systems have been the most obvious recipients of the benefits of
fuzzy logic, since their domain is often inherently fuzzy. Examples of expert
systems with fuzzy logic central to their control are decision-support
systems, financial planners, diagnostic systems for determining soybean
pathology, and a meterological expert system in China for determining areas in
which to establish rubber tree orchards [14]. Another area of application,
akin to expert systems, is that of information retrieval [9].
Š
CONCLUSIONS
Fuzzy systems, including fuzzy logic and fuzzy set theory, provide a rich
and meaningful addition to standard logic. The mathematics generated by these
theories is consistent, and fuzzy logic may be a generalization of classic
logic. The applications which may be generated from or adapted to fuzzy logic
are wide-ranging, and provide the opportunity for modeling of conditions which
are inherently imprecisely defined, despite the concerns of classical
logicians. Many systems may be modeled, simulated, and even replicated with
the help of fuzzy systems, not the least of which is human reasoning itself.
REFERENCES
[1] J.F. Baldwin, "Fuzzy logic and fuzzy reasoning," in Fuzzy Reasoning
and Its Applications, E.H. Mamdani and B.R. Gaines (eds.), London: Academic
Press, 1981.␍
␍
␍
[2] W. Bandler and L.J. Kohout, "Semantics of implication operators and
fuzzy relational products," in Fuzzy Reasoning and Its Applications, E.H.
Mamdani and B.R. Gaines (eds.), London: Academic Press, 1981.
[3] M. Eschbach and J. Cunnyngham, "The logic of fuzzy Bayesian
influence," paper presented at the International Fuzzy Systems Association
Symposium of Fuzzy information Processing in Artificial Intelligence and
Operational Research, Cambridge, England: 1984.
[4] F. Esragh and E.H. Mamdani, "A general approach to linguistic
approximation," in Fuzzy Reasoning and Its Applications, E.H. Mamdani and B.R.
Gaines (eds.), London: Academic Press, 1981.
[5] J. Fox, "Towards a reconciliation of fuzzy logic and standard logic,"
Int. Jrnl. of Man-Mach. Stud., Vol. 15, 1981, pp. 213-220.
[6] S. Haack, "Do we need fuzzy logic?" Int. Jrnl. of Man-Mach. Stud.,
Vol. 11, 1979, pp.437-445.
[7] S. Korner, "Laws of thought," Encyclopedia of Philosophy, Vol. 4,
MacMillan, NY: 1967, pp. 414-417.
[8] C. Lejewski, "Jan Lukasiewicz," Encyclopedia of Philosophy, Vol. 5,
MacMillan, NY: 1967, pp. 104-107.
Š [9] T. Radecki, "An evaluation of the fuzzy set theory approach to
information retrieval," in R. Trappl, N.V. Findler, and W. Horn, Progress in
Cybernetics and System Research, Vol. 11: Proceedings of a Symposium Organized
by the Austrian Society for Cybernetic Studies, Hemisphere Publ. Co., NY:
1982.
[10] I.G. Umbers and P.J. King, "An analysis of human decision-making in
cement kiln control and the implications for automation," Int. Jrnl. of Man-
Mach. Stud., Vol. 12, 1980, pp. 11-23.
[11] F. Wenstop, "Deductive verbal models of organizations," Int. Jrnl. of ␍
Man-Mach. Stud., Vol. 8, 1976, pp. 293-311.
[12] L.A. Zadeh, "Fuzzy sets," Info. & Ctl., Vol. 8, 1965, pp. 338-353.
[13] L.A. Zadeh, "Fuzzy algorithms," Info. & Ctl., Vol. 12, 1968, pp. 94-
102.
[14] L.A. Zadeh, "Making computers think like people," I.E.E.E. Spectrum,
8/1984, pp. 26-32.

programming/FUZZYLOGIC/fuzzy3.txt
+544
View File
@@ -0,0 +1,544 @@
comp.ai.fuzzy #129 (36 more) [1]
From: farzin@apollo3.ntt.jp (Farzin Mokhtarian)
[1] Complete contents of the booklet "Clearly Fuzzy"
Originator: sehari@vincent1.iastate.edu
Organization: Iowa State University of Science and Technology, Ames, Iowa.
Date: Thu Jan 21 15:01:34 MET 1993
Lines: 959
--MORE--(1%)
Complete contents of the booklet "Clearly Fuzzy" by:
OMRON Corporation
International Public Relations Section
3-4-10, Toranomon, Minato-ku
Tokyo, 105 Japan
Tel: 81-3-3436-7139
Fax: 81-3-3436-7029
Contact: Tadashi Katsuno
---------------------------------------------------------------------
1. Introduction
Fuzzy Logic is attracting a great deal of attention in the industrial
world and among the general public today. Quick to recognize this
revolutionary control concept, OMRON seriously began to study Fuzzy
theory and technology in 1984, back when the term "Fuzzy" was still
relatively unknown.
Just three years later, OMRON stunned the academic world and triggered
today's boom when it exhibited its first super-high-speed Fuzzy
controller. It was developed jointly with Assistant Professor Takeshi
Yamakawa of Kumamoto University and shown at the Second International
Conference of the International Fuzzy Systems Association (IFSA).
OMRON has since dedicated itself to exploring the potential of this
innovative technology. The company invited Professor Lotfi A. Zadeh,
the founder of Fuzzy theory, to be a senior advisor, and welcomed
researchers from China, a country known as one of the leaders in
Fuzzy Logic study. As a result of technological exchanges with
research institutes of various countries, OMRON's Fuzzy Logic-related
activities are reaching a global scale. Since 1984, OMRON has applied
for a total of 700 patents, making the company an international leader
in Fuzzy Logic technology.
OMRON's enthusiasm for Fuzzy Logic stems from the company's goal of
creating harmony between people and machinery. As a key technology
in OMRON's future, we will be working hard to strengthen and refine
this exciting technology and give it truly useful applications at
production sites, in offices, in public facilities, as well as in
everyday life.
We hope this booklet will be useful in increasing your knowledge,
or at least in sparking your interest in this exciting technology.
OMRON Corporation
------------------------------------------------------------------
2. Truly Friendly Machines
2.1. Arrival of the Fuzzy Boom
The current Fuzzy boom was triggered by the presentation of trial
Fuzzy applications at the Academic Conference of the International
Fuzzy Systems Association (IFSA). The obvious feasibility of these
forerunners of today's Fuzzy Logic deeply impressed conference
attendees. Nowadays in Japan, Fuzzy Logic is successfully being
applied to industrial systems such as elevators and subways and
to an array of consumer electronic products. Convenient Fuzzy Logic
home electrical appliances include washing machines that sense the
dirtiness and type of fabric to automatically determine water flow
and detergent requirements; and vacuum cleaners capable of detecting
not only the presence but the degree of dust on a floor!
2.2. Shades of Gray
The theory of Fuzzy Logic was introduced to the world by Professor
Lotfi A. Zadeh of the University of California at Berkeley.
Professor Zadeh observed that conventional computer logic is
incapable of manipulating data representing subjective or vague
human ideas, such as "an attractive person" or "pretty hot".
Computer logic previously envisioned reality only in such simple
terms, as on or off, yes or no, and black or white. Fuzzy Logic
was designed to allow computers to determine valid distinctions
among data with shades of gray, working similarly in essence to
the processes which occur in human reasoning. Accordingly, Fuzzy
technologies are designed to incorporate Fuzzy theories into
modern control and data processing, to create more user-friendly
systems and products.
2.3. A Warm Welcome in the Orient
Since Fuzzy Logic's world debut 26 years ago, theoretical and
practical studies have been carried out in countries around
the globe; Fuzzy Logic research is currently underway in over
30 nations including the USA, Europe, Japan and China. It may
be surprising to some to note that the world's largest number
of Fuzzy Logic researchers are in China, with over 10,000
scientists and technicians presently hard at work. Japan ranks
second in Fuzzy Logic manpower, followed by Europe and the USA.
Among all nations however, Japan is currently positioned at the
leading edge of Fuzzy Logic application studies. So it may be
that the popularity of Fuzzy Logic in the Orient reflects the
fact that Oriental thinking more easily accepts the concept of
"Fuzziness".
2.4. Fuzzy - Part of Every Day at OMRON
OMRON is also hard at work in the Fuzzy Logic field. Projects
currently on the go at OMRON include working to establish a
Fuzzy technological base, developing new products incorporating
Fuzzy theory, adapting Fuzzy Logic technology to existing
products and conducting seminars for interested audiences
from outside OMRON. Fuzzy Logic has in fact grown to such
proportions that it has become an integral part of the new
corporate culture at OMRON.
-----------------------------------------------------------------------
3. "Fuzzy" Made Clear
3.1. What is "Fuzzy"?
Originally stemming from the fuzz which covers baby chicks, the term
"fuzzy" in English means "indistinct, blurred, not sharply delineated
or focused." This term is "flou" in French and pronounced "aimai" in
Japanese. In the academic and technological worlds, "Fuzzy" is a
technical term. Fuzziness in this sense represents ambiguity or
vagueness based on human intuitions rather than being based on
probability. Twenty six years ago, Professor Lotfi A. Zadeh
introduced "Fuzzy sets" to adapt the concepts of fuzzy boundaries to
science. Fuzzy theory was devised around the Fuzzy sets and a new
field of engineering known as "Fuzzy Engineering" was born. Although
"Fuzzy sets" may sound very mathematical, the baept with fuzzy boundaries which can not be handled by
conventional computers using the binary system. This is where
Fuzzy theory comes in. Let's suppose that we have concluded that
middle age is 45. However, people 35 or 55 years of age can not
be said to be "definitely not middle-aged". There is a feeling,
however, that the implication of "middle age" is somewhat
different inside those boundaries. On the contrary, those younger
than 30 or older than 60 can be considered "definitely not
middle-aged". Such a concept can be represented by a characteristic
function called the "membership function" having a grade between 0
and 1. A Fuzzy set is represented by this membership function.
However, note that the grade within the membership function can be
e age as soon as their
next birthday arrives! This sort of unnaturalness is due to
inflexible value assignments. Such concepts with distinct values
of 0 or 1 are called "crisp sets" as opposed to the "Fuzzy sets".
-------------------------------------------------------------------
4. Fuzzy Theory in Action
4.1. Fuzzy Algorithm
One example of Fuzzy theory applications is the handling of
approximate numbers. If approximately 2 is added to approximately 6,
the result will be something around 8. People often make this sort
of calculation. For instance, we frequently estimate the result when
performing a calc
computers, which must have crisp data with which to work.
4.2. The Logic in Fuzzy Logic
Another field that applies Fuzzy theory concerns artificial
intelligence, termed "Fuzzy Logic". One of the differences between
Fuzzy Logic and conventional binary logic is that the truth value
in Fuzzy Logic can be any value between 0 and 1, while that in
binary logic is either 0 or 1. Another difference is that the
Fuzzy proposition includes "fuzzi is a reasoning method using Fuzzy theory, whereby
human knowledge is expressed using linguistic rules ("If A is B,
then C is D") with variables B and D. Fuzzy inference is also called
"daily inference" or "common sense inference" since it is performed
by ordinary people. However, conventional computers that employ
binary logic can not handle this reasoning. The use of Fuzzy theory
enables the development of an expert system that can handFuzzy inference
is possible even when the meaning of the fact differs slightly
from the given knowledge. Drawing a conclusion like "Add a little
cold water", Fuzzy inference matches the conclusion based on human
experience, intuition, or possibly even reality.
The "knowledge" part of Fuzzy inference has the structure "if A is
B, then C is D" (example: "If the water is very hot, add plenty of
cold water"). Concepts such as "very hot" and "plenty of cold
water" are subjective and thus represented by Fuzzy sets.
As you may know, Fuzzy theory was devised for the purpose of
enabling machines to handle subjective human ideas and operate
based on advanced knowledge as well as applications of human
beings' intricate experiences.tomobile and its distance to the automobile in front. Amount of
control is expressed in terms of Braking strength.
(1) Express experience and expertise in the form of rules.
With Fuzzy inference control, these rules are called "production
rules". They are represented in the form of "If X is A, then Y is B".
To put it more simply, let's consider two rules as follows:
tance between the two cars and the car speed (antecedent parts)
and the level of speed reduction, or braking strength (consequent
part), are not numeric values but are represented by "Fuzzy Sets"
expressed through linguistic rules. The distance between the two
cars and the speed have a multiple number of Fuzzy values and are
therefore called "Fuzzy variables". Hence, values (lmately 0) labels. Many Fuzzy controllers
use seven labels, as in the OMRON FZ-3000 Fuzzy Controller, for
example.
(3) Replace linguistic production rules with codes for simpler
expression.
Although production rules can be expressed with everyday language,
codes are used to simplify the input to the actual Fuzzy Controllers.: If X1 = M and X2 = L, then Y = M.
(4) Execute Fuzzy inference control.
When the rules are programmed into the Fuzzy Controller and it is put
into operation, the Controller will output the most valid control
value based on the variable input conditions.
1) Establish grades (validity) of input in relation to the Fuzzyhe
smaller value of the grades of inputs. This process is called
"determining MIN (minimum)".
Rule 1: As g11 = 0.4 and g12 = 0.2, the grade (MIN value) of
antecedent part (g1) = 0.2.
Rule 2: As g21 = 0.7 and g22 = 0.6, the grade (MIN value) of
antecedent part (g2) = 0.6.
3) Adjust the membership function of the consequent part.
e based on each of
these rules (adjusted Fuzzy Sets of the consequent parts), the final
conclusion is then determined by summing the Fuzzy Sets of the
conclusions for each rule. This process is called "determining MAX
(maximum)".
This process considers several variable factors, and is thus very
similar to the human thinking process.
With Fuzzy Controess.
Expressing human experience in the form of a mathematical formula
is very difficult, perhaps impossible. In contrast, Fuzzy inference
control has the following advantages over conventional control:
1) Expression of control is easy as it need only derive localized
control rules for each location (or event) in the control range.
2) It therefore handles complex input/output by using many contotal number
of rules.
o Logical Control
Fuzzy inference control rules are expressed logically using simple
linguistic rules ("If A is B, then C is D"). Because everyday
language can be used, Fuzzy inference control proves ideal for
expressing the sophisticated knowledge of experts and incorporating
valuable intuitiony the machine operator or
others.
2) The operator can easily interpret the effect or outcome of each
rule.
-----------------------------------------------------------------------
6. Growing Up: Fuzzy Technology Catches On
6.1. The Birth and Evolution of Fuzzy
6.2. Is "Fuzziness" Really Better?
Dr. Zadeh was one of the original founders of the modern control theory
and remains an authority in this field. Modern control theory is exact,
precise, and logical, harboring no hint of "fuziness".
Today, however, the subjects of control have become increasingly larger
in scale, in turn requiring more advanced and complex control systems,
like those used to control robots also takes an extremely long time to
execute the programs. Dr. Zadeh devised Fuzzy theory to overcome
these debilitating limitations of modern theory.
There was also another, probably more important factor that encouraged
him to come up with a new idea. Conventional computers work by
identifying the factor which seems to have the strongest influence on
the systems to be controlled, since it is impossible to simultaneously
command all the factors that affect the system. In other woe, capable of accurate and fast
computation. However, as the conditional parameters include many
hypotheses, the computer may sometimes yield a ridiculous conclusion
contrary to what common sense would lead us to expect. This is caused
by its attempts to replace "fuzziness" with fixed numeric values.
Thus, it became necessary to develop a theory capable of dealing
with the vagueness prevalent in everyday decisions.
6.3. Strmany criticized him for not
fulfilling his duty as a scientist.
6.4. A Profile of Professor Zadeh
You may want to know a little about the Professor. Here is a
very brief profile:
Lotfi A. Zadeh was born in Iran on February 4, 1921. In 1956,
he was a visiting member of the Institute for Advanced Study in
Princeton, New Jersey and held numhe IEEE and AAAS. He is also
a member of the National Academy of Engineering. Now, Dr.
Zadeh is a senior advisor to OMRON Corporation.
6.5. A Motivating Debate
Here is a little story about how Fuzzy Logic was invented. One
day, Dr. Zadeh got into a long argument with a friend about who
was more beautiful, his wife or his friend's. Each
The first applications of Fuzzy theory were primarily industrial,
such as process control for cement kilns. Then, in 1987, the
first Fuzzy Logic-controlled subway was opened in Sendai in
northern Japan. There, Fuzzy Logic controllers make subway
journeys more comfortable with smooth braking and acceleration.
In fact, all the driver has to do is push the start button!
Fuzzy Major Applications
Automation Steel/iron manufacturing, water purification,
manufacturing lines and robots, train/elevator
operation control, consumer products, etc.
Instrumentation Sensors, measuring instruments, voice/character
and analysis recognition, et7. Historically Speaking ...
The year 1990 witnessed the 25th anniversary of the invention of
Fuzzy theory. It has undergone numerous transformations since its
inception with a variety of Fuzzy Logic applications emerging in
many industrial areas. Dividing these past years into different
stages, the early 1970s are the "theoretical study" stage, the
period ater
becoming the Japan Office of the International Fuzzy
Systems Association (IFSA)).
1973: Zadeh introduces a methodology for describing systems
using language that incorporates fuzziness.
1974: Dr. Mamdani of the University of London, UK succeeds
with an experimental Fuzzy control for a steam engine.
1980: F. L. Smidth & Co. A/S, Denmark, implements Fuzzy
theory in cement kiln control (the world's first
practical implementation of Fuzzy theory).
1983A Fuzzy Future
7.1. Fuzzy Fever Hits Japan
1987 marked the start of Japan's so-called "Fuzzy boom", reaching
a peak in 1990. A wide variety of new consumer products since then
have included the word "Fuzzy" on their labels and have been
advertised as offering the ultimate in convenience.
For instance, Fuzzy Logic found its way into the electronic fuel
injection controls and automatic cruise control ston and the
rest is taken care of by the machine. It automatically judges
the material, the volume and the dirtiness of the laundry and
chooses the optimum cycle and water flow. In air conditioners,
Fuzzy Logic saves energy because it starts cooling more
strongly only when a sensor detects people in the room.
We could go on and on with examples of camcorders, television
sets, and even fund management systems. The sweeping
popularity of Fuzzy Logic in Japan might even surprise
Dr. Zadeh, its founder.
7.2. No Limits: Promise for the Future
Just from these few examples, it is clear that Fuzzy Logic
encompasses an amazing array of applica is described in child care
books. They may drink a little or a lot depending on their
physical condition, mood, and other factors. She conceived
a Fuzzy Logic program that would recommend how much to feed
the baby. The program determines the appropriate amount of
milk according to a knowledge base that includes the child's
personality, physical condition, and some environmenerived from everyday activities in the
home, like the Fuzzy ventilation system. It uses Fuzzy Logic
to switch a fan on and off as dictated by its knowledge base
of the amount of smoke, odors, and room temperature and
humidity. The Fuzzy bath, for example, has a controller that
keeps the temperature of the water juvative application of Fuzzy Logic.
-------------ally advanced company achieved and how? What does
the future hold for this exciting Fuzzy Logic? Through an
interview conducted in February 1991 with General Manager
Masayuki Oyagi of OMRON's Fuzzy Technology Business Promotion
Center, we hope to answer these questions.
Q. How did OMRON become involved with Fuzzy Logic technology?
A. In the early 1980s, we were mportance.
His encouragement led to the formation of the Fuzzy Project
team, now the Fuzzy Technology Business Promotion Center,
which conducts basic studies and explores new business
opportunities.
Q. OMRON's R&D efforts have given rise to numerous original
applications for Fuzzy Logic. Could you give some examples?
A. The most obvious examd a robot
which can grasp something "pretty" soft and fragile - tofu
(bean curd); and a can sorting machine capable of
identifying cans by color. Overall, OMRON has more than
100 successful applications, 20 of which are now available
to the public.
As 1991 progresses, you can expect more OMRON Fuzzy Logic-based
products to be introduced. Toorm of Fuzzy Logic.
Considering the diversity of OMRON's products, this is a
challenging and significant goal.
OMRON's R&D investments account for approximately 7% of its
total sales and I think Fuzzy Logic research represents
nearly 1%.
Q. OMRON is not alone in the Fuzzy Logic business. How does it
distinguish itself from digital and analog units, at
virtually every speed, inference scale and computation capacity.
OMRON also offers Fuzzy Logic products in complete sets,
including chips, software, and development tools, which can be
used both in-house and by customers. Almost eight years of
experience with Fuzzy Logic have gone into all of these products.
There are an afits that
Fuzzy Logic can offer. Any business operates towards goals,
such as major performance improvements, cost reductions,
miniturizing, or others. To attain these goals, businesses
will usually refine their operations, generally without
concern for the kind of technology used. But they do care
about whether the technology can really work for them. Whereessing, computation, memory or output. In other words, it
can manage "fuzziness". The logic itself is purely mathematical,
so the results are not "fuzzy" but rather very clear and precise.
Consider the can sorting machine which I mentioned earlier. With
Fuzzy Logic, a computer can be instructed to sort cans according
to their colors such as "addition to developing applications involves many
people. As an indication, at least 1,000 people have taken a
Fuzzy Logic seminar.
Some are members of the Laboratory for International Fuzzy
Engineering Research (LIFE). One person from our Fuzzy Technology
Business Promotion Center is now working at OMRON Advanced
Systems, Inc. i employees and our customers. Although most of these activities
are within Japan, we plan to expand them to other countries this
year.
The first product scheduledely aiming for simultaneous worldwide release. This coming
spring, a Fuzzy Logic product showroom will open at OMRON
Electronics, Inc. in Schaumburg, Illinois.
A. I think there are positive and negative feelings about this term.
In its early days, "Fuzzy" was not considered an academic term.
Because of this, however, people got the impression that this
technology was something quite singular which, I think, gave it
more impact. On the down side, people thought that its results
or ability would be "fuzzy", and questioned the product
reliability.
nd French and German groups have been
visiting OMRON regularly since 1989. This makes me confident that
Fuzzy Logic technology will grow rapidly in both US and Europe in
the near future.
If consumer electronics giants such as GE introduce products with
Fuzzy Logic, you may see a boom even larger than the one
experienced in Japan lasIntelligence" (AI).
The left hemisphere of a human brain is used for logical
processes, like reading and talking, while the right hemisphere
is for intuitive and emotional mechanisms as well as unconscious
information processing. Conventional computers imitate the left
side, while Fuzzy Logic plays the role of the right side.
In chess, for ntegrating conventional computers with Fuzzy Logic,
expert systems, neural networks, and other technologies.
OMRON's goal is to create machines that approximate human
intelligence and capabilities, and yet still be compact and
inexpensive.
The 1990 Fuzzy Logic boom, I think, was the first wave which
accurately reflected the direction of the tech.
1987 Assistant Professor Takeshi Yamakawa of Kumamoto University
(now Professor of Kyushu Institute of Technology) introduces
super high-speed Fuzzy controller, test-manufactured by
OMRON, at the 2nd Conference of the International Fuzzy
Systems Association.
1988 World's first super high-speed Fuzzy controller, FZ-1000,
marketed.
OMg Fuzzy Logic technology introduced,
including chips, controllers, and software.
Fuzzy Technology Business Promotion Center established.
Bank note feeding mechanism using Fuzzy Logic developed
for ATMs.
Fuzzy hybrid control method developed.
1990 "LUNA-FuzzyRON" Fuzzy Logic software development support
system developed.
Fuzzy Logic human body sensor developed.
Fuzzy controller related ga
---------------------------------------------------------------
10. Fuzzy Logic Products
OMRON has released numerous innovative products that use Fuzzy
Logic. A few of those products scheduled for release overseas
are listed below:
o FP speed)).
* Bus interface similar to that of an SRAM allows connection to
various CPUs.
* Fuzzy Logic operation can be accomplished on a single chip
(Single mode).
* High 12-bit resolution.
* Up to 128 rules applicable for each inference (Expanded mode).
o FS-10AT Fuzzy Software Tool
BM PC-AT expansion slot.
* Uses the rules and membership functions created by the FS-10AT.
* Provided with driver software, allows Fuzzy inference to run
with the user's software.
* Applications include evaluation and field tests of the FP-3000,
and addition of Fuzzy Logic functions to personal computers.
o E5AF Fuzzy Temperature Controller
The industry's first temperature controller to employ Fuzzy Logic.
* Highly precise (+/- 0.3% error) and fast response to external
disparameter setting. Fuzzy Logic parameters
can be programmed to fit the application.
* Ideal for use in physical/chemical equipment, industrial
furnaces, and semiconductor manufacturing equipment.
------------------------------------------------------------------
11. Fuzzy Logic Technologies
OMRsh dispensers (CDs) are easily affected by
ambient humidity, conveyance conditions, etc., which in turn makes
stable bank note feeding difficult. With the aid of Fuzzy Logic,
this new mechanism keeps the gap between the rollers at the
optimum level, notably increasing the reliability of ATMs and CDs
as well as reducing the need for maintenance.
--
programming/FUZZYLOGIC/index.gemini
+45
View File
@@ -0,0 +1,45 @@
# FUZZYLOGIC
Files about Fuzzy Logic
## FILES
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/air_cond.txt [ 8756] Using Fuzzy Logic for Air Conditioning Systems
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/auto_trn.txt [ 7913] Using Fuzzy Logic in an Automatic Transmission
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/brub1.txt [ 6287] The Huntington Technical Brief By David Brubaker Ph.D. (A Fuzzy Web Tension Controller)
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/brub2.txt [ 8945] The Huntington Technical Brief By David Brubaker Ph.D. (Dynamic Extent of Fuzzy Variables)
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/focus.pro [ 8235] Using Fuzzy Inference to determine the proper focus distance in an automatic camera
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/fuzzwash.txt [ 9717] Using Fuzzy Logic with a Washing Machine
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/fuzzy.txt [ 22656] Fuzzy Systems: A Tutorial, by James F. Brule'
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/fuzzy3.txt [ 27378] Complete contents of the booklet "Clearly Fuzzy" by OMRON Corporation, 1993
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/motor.txt [ 15194] Programming a Machine in Fuzzy Intelligence to Grasp Several Different Kinds of Balls
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/news1.txt [ 5712] Fuzzy Logic is Anything But Fuzzy: Interview with Professor Lotfi Zadeh, Computer Design, 1992
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/news10.txt [ 1179] A Brief Answer to "What is Fuzzy Logic?"
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/news11.txt [ 17933] What is the Fuzzy Inference Development Environment, by Aptronix
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/news12.txt [ 2318] We Ask Again: What is Fuzzy Logic?
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/news2.txt [ 3297] NASA Eyes Range of Fuzzy Control Ideas in Space, Computer Design, 1992
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/news3.txt [ 2077] Fuzzy Logic Will Make Cars Smarter, from Computer Design, 1992
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/news4.txt [ 3475] Fuzzy Mug Search Helps Cops Catch Crooks, from Computer Design
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/news5.txt [ 8907] The Seven Noble Truths of Fuzzy Logic, by Ear Cox, April 1992 Computer Design
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/news6.txt [ 5368] Comments on Designing with Traditional PID Control vs. Fuzzy Logic Control
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/reactor.txt [ 39397] An Introduction to using Fuzzy Logic in Nuclear Reactors
=> gemini://informis.land/textfiles/programming/FUZZYLOGIC/temp_cnt.pro [ 13412] Using Fuzzy Logic in Automatic Temperature Control
programming/FUZZYLOGIC/motor.txt
+340
View File
@@ -0,0 +1,340 @@
INTRODUCTION
Servo motors are widely used in the field of motion control in
factory automation. The control target can be position, speed, or
force, among others. For this example application we take force
as the control variable.
In order to implement force control, we need to know the
compliance (response) of the controlled object to force. The
feedback gain in the control loop changes as a function of
compliance.
Grasping a range of objects from, for example, a soft tennis
ball to a hard steel ball using conventional servo control is
extremely difficult. The traditional control model does not
handle a variety of objects with differing material
characteristics very well. The system can become unstable. Fuzzy
logic, with its inherent flexibility, can be employed
effectively as an alternative in this situation.
FUZZY FORCE CONTROLLER
Control Objective
Grasp objects of various compliance, ranging, for example, from a
soft tennis ball to a hard steel ball with a constant force.
Control System
The control block diagram is shown in Figure 1. Output force
applied to the object is measured by a sensor and compared
against a reference force to obtain the difference. A control
gain Kg is applied to diminish this force difference. This gain
also varies as a function of the compliance of the grasped
object. Thus, control gain Kg is affected by two
factors: (1) the compliance of the object and (2) the difference
between a reference force and the measured force. Branches
coming off the error (e) node and speed (v) node of the above
diagram are expansions of those nodes, and represent variables
to be used to determine the control gain. They do not represent
additional control paths. We can write the control gain and
diagram its components as shown in Figure 2 below.
Ks (compliance component) is a function of Ke. Kf (force
component) is a function of error e and its time
derivative ‚. Both can be inferred by fuzzy logic.
The compliance Ke is determined by injecting a
speed command v into the servo motor and
measuring the output force f. Compliance is
expressed as follows:
Ke = df/dx = (df/dt)/(dx/dt) = âf/v
We obtain
Ke = (fk-f(k-1))/v(k-1)
Compliance can be thought of as the change in force (df) required
for a given deformation (dx) of an object. For example, a tennis
ball has a large compliance because the force needed to initiate
deformation is small, but increases significantly as the
deformation process proceeds. The change in force from initiation
to termination is large. At the other extreme is the steel ball,
which has small compliance. Although the force required to
initiate deformation is large, the force to continue deformation
does not change significantly. Consequently, the change from
initiating to terminating force is small.
It is known that the control gain Kg is the
reciprocal of the compliance Ke, so Ks can be inferred from Ke
by the following fuzzy rules:
If Ke is small then Ks is large
If Ke is large then Ks is small
These two rules make up the fuzzy inference unit A which connects
Ke with Ks.
Definition of Input/Out Variables for Unit B
Now let us consider fuzzy inference unit B, inferring Kf from e
and ‚. The two inputs into Unit B are error e and its time derivative
‚. e is the difference between a reference force and the
applied output force. Labels and membership functions for e and
‚ are defined as shown in Figure 3a, 3b respectively. Figure 3c shows
the labels and membership functions for Kf.
FIU Source Code of Unit B
The following is the source code of Unit B written in FIDE's
Fuzzy Inference Language (FIL). Note that in the definition of
input variable Error, the value of P_VerySmall is given as (@-3,
0, @0, 1, @50, 0), and that of N_VerySmall is (@-50, 0,
@0, 1, @3, 0). We use -3 and 3 instead of -1 and 1
respectively because the data range of Error must be accommodated
in a resolution of 8 bits. This means the smallest interval of
Error is 600/256 = 3. The membership functions of these
fuzzy sets are shown in Figure 3a, 3b, and 3c as we have seen.
$ FILENAME: motor/motor1.fil
$ DATE: 08/12/1992
$ UPDATE: 08/14/1992
$ Two inputs, one output, to determine control gain
$ INPUT(S): Error, Derivative(_of_Error)
$ OUTPUT(S): Gain
$ FIU HEADER
fiu tvfi (min max) *8;
$ DEFINITION OF INPUT VARIABLE(S)
invar Error " " : -300 () 300 [
P_Large (@100, 0, @200, 1, @300, 1),
P_Medium (@50, 0, @100, 1, @200, 0),
P_Small (@0, 0, @50, 1, @100, 0),
P_VerySmall (@-3, 0, @0, 1, @50, 0),
N_VerySmall (@-50, 0, @0, 1, @3, 0),
N_Small (@-100,0, @-50, 1, @0, 0),
N_Medium (@-200,0, @-100, 1, @-50, 0),
N_Large (@-300,1, @-200, 1, @-100,0)
];
invar Derivative " " : -30 () 30 [
P_Large (@10, 0, @20, 1, @30, 1),
P_Medium (@5, 0, @10, 1, @20, 0),
P_Small (@0, 0, @5, 1, @10, 0),
P_VerySmall (@-1, 0, @0, 1, @5, 0),
N_VerySmall (@1, 0, @0, 1, @-5, 0),
N_Small (@0, 0, @-5, 1, @-10,0),
N_Medium (@-5, 0, @-10, 1, @-20,0),
N_Large (@-10, 0, @-20, 1, @-30,1)
];
$ DEFINITION OF OUTPUT VARIABLE(S)
outvar Gain " " : -2 () 2 * (
P_Large = 2.00,
P_Medium = 1.00,
P_Small = 0.50,
P_VerySmall = 0.25,
Zero = 0.00,
N_VerySmall = -0.25,
N_Medium = -1.00
);
$ RULES
if Error is N_Large and Derivative is P_Large then Gain is P_Medium;
if Error is N_Large and Derivative is P_Medium then Gain is P_Medium;
if Error is N_Large and Derivative is P_Small then Gain is P_Medium;
if Error is N_Large and Derivative is P_VerySmall then Gain is P_Medium;
if Error is N_Large and Derivative is N_VerySmall then Gain is P_Medium;
if Error is N_Large and Derivative is N_Small then Gain is P_Medium;
if Error is N_Large and Derivative is N_Medium then Gain is P_Small;
if Error is N_Large and Derivative is N_Large then Gain is P_Small;
if Error is N_Medium and Derivative is P_Large then Gain is P_Medium;
if Error is N_Medium and Derivative is P_Medium then Gain is P_Medium;
if Error is N_Medium and Derivative is P_Small then Gain is P_Medium;
if Error is N_Medium and Derivative is P_VerySmall then Gain is P_Medium;
if Error is N_Medium and Derivative is N_VerySmall then Gain is P_Medium;
if Error is N_Medium and Derivative is N_Small then Gain is P_Medium;
if Error is N_Medium and Derivative is N_Medium then Gain is P_Small;
if Error is N_Medium and Derivative is N_Large then Gain is Zero;
if Error is N_Small and Derivative is P_Large then Gain is P_Medium;
if Error is N_Small and Derivative is P_Medium then Gain is P_Medium;
if Error is N_Small and Derivative is P_Small then Gain is P_Medium;
if Error is N_Small and Derivative is P_VerySmall then Gain is P_Medium;
if Error is N_Small and Derivative is N_VerySmall then Gain is P_Medium;
if Error is N_Small and Derivative is N_Small then Gain is P_Small;
if Error is N_Small and Derivative is N_Medium then Gain is P_VerySmall;
if Error is N_Small and Derivative is N_Large then Gain is N_VerySmall;
if Error is N_VerySmall and Derivative is P_Large then Gain is P_Medium;
if Error is N_VerySmall and Derivative is P_Medium then Gain is
P_Medium;
if Error is N_VerySmall and Derivative is P_Small then Gain is P_Medium;
if Error is N_VerySmall and Derivative is P_VerySmall then Gain is
P_Medium;
if Error is N_VerySmall and Derivative is N_VerySmall then Gain is
P_Large;
if Error is N_VerySmall and Derivative is N_Small then Gain is
P_VerySmall;
if Error is N_VerySmall and Derivative is N_Medium then Gain is
N_VerySmall;
if Error is N_VerySmall and Derivative is N_Large then Gain is
N_Medium;
if Error is P_VerySmall and Derivative is P_Large then Gain is
N_Medium;
if Error is P_VerySmall and Derivative is P_Medium then Gain is
N_VerySmall;
if Error is P_VerySmall and Derivative is P_Small then Gain is
P_VerySmall;
if Error is P_VerySmall and Derivative is P_VerySmall then Gain is
P_Large;
if Error is P_VerySmall and Derivative is N_VerySmall then Gain is
P_Medium;
if Error is P_VerySmall and Derivative is N_Small then Gain is
P_Medium;
if Error is P_VerySmall and Derivative is N_Medium then Gain is
P_Medium;
if Error is P_VerySmall and Derivative is N_Large then Gain is
P_Medium;
if Error is P_Small and Derivative is P_Large then Gain is N_VerySmall;
if Error is P_Small and Derivative is P_Medium then Gain is
P_VerySmall;
if Error is P_Small and Derivative is P_Small then Gain is P_Small;
if Error is P_Small and Derivative is P_VerySmall then Gain is
P_Medium;
if Error is P_Small and Derivative is N_VerySmall then Gain is
P_Medium;
if Error is P_Small and Derivative is N_Small then Gain is P_Medium;
if Error is P_Small and Derivative is N_Medium then Gain is P_Medium;
if Error is P_Small and Derivative is N_Large then Gain is P_Medium;
if Error is P_Medium and Derivative is P_Large then Gain is Zero;
if Error is P_Medium and Derivative is P_Medium then Gain is P_Small;
if Error is P_Medium and Derivative is P_Small then Gain is P_Medium;
if Error is P_Medium and Derivative is P_VerySmall then Gain is
P_Medium;
if Error is P_Medium and Derivative is N_VerySmall then Gain is
P_Medium;
if Error is P_Medium and Derivative is N_Small then Gain is P_Medium;
if Error is P_Medium and Derivative is N_Medium then Gain is P_Medium;
if Error is P_Medium and Derivative is N_Large then Gain is P_Medium;
if Error is P_Medium and Derivative is P_Large then Gain is P_Small;
if Error is P_Medium and Derivative is P_Medium then Gain is P_Small;
if Error is P_Medium and Derivative is P_Small then Gain is P_Medium;
if Error is P_Medium and Derivative is P_VerySmall then Gain is
P_Medium;
if Error is P_Medium and Derivative is N_VerySmall then Gain is
P_Medium;
if Error is P_Medium and Derivative is N_Small then Gain is P_Medium;
if Error is P_Medium and Derivative is N_Medium then Gain is P_Medium;
if Error is P_Medium and Derivative is N_Large then Gain is P_Medium
end
Input/Output Response
Figure 4 shows the response surface of the FIU defined above.
This surface is obtained by using the Analyzer tool provided in
FIDE.
COMMENTS
Through experimentation, we can obtain a set of rules to infer
compliance Ke from speed v, and the measured force f. The rules
are in essence as follows:
If v is large and â is small, then Ke is very small
If v is large and â is medium,then Ke is small
If v is large and â is large, then Ke is medium
If v is small and â is small, then Ke is medium
If v is small and â is medium,then Ke is large
If v is small and â is large, then Ke is very large
The label names used here give an intuitive sense of how the
rules apply. However, even though label names are the same for
different variables, the fuzzy sets associated with these labels
may be different. For speed v, the label large
may be a fuzzy set as shown in Figure 5a, and for compliance
Ke, label large could be another fuzzy set as shown in Figure 5b.
The ranges of these variables can be determined by experiment on
the devices and objects of interest. For example, compliance data
gathered from a soft tennis ball and a hard steel ball can be
used to define large and small labels respectively for variable
Ke.
If we use an FIU to infer compliance Ke, the control gain
function now becomes three FIUs and an operations block (FOU) as
shown in Figure 6. The FOU implements Kg = Ks . Kf . Using
Fide's Composer capability, these four blocks can be combined
into a single system for analysis and simulation purposes.
(Weijing Zhang, Applications Engineer, Aptronix Inc.)
For Further Information Please Contact:
Aptronix Incorporated
2150 North First Street #300
San Jose, CA 95131
Tel (408) 428-1888
Fax (408) 428-1884
FuzzyNet (408) 428-1883 data 8/N/1
Aptronix Company Overview
Headquartered in San Jose, California, Aptronix develops and
markets fuzzy logic-based software, systems and development
tools for a complete range of commercial applications. The
company was founded in 1989 and has been responsible for a
number of important innovations in fuzzy technology.
Aptronix's product Fide (Fuzzy Inference Development
Environment) -- is a complete environment for the development of
fuzzy logic-based systems. Fide provides system engineers with
the most effective fuzzy tools in the industry and runs in
MS-Windows(TM) on 386/486 hardware. The price for Fide is $1495 and
can be ordered from any authorized Motorola distributor. For a
list of authorized distributors or more information, please
call Aptronix. The software package comes with complete
documentation on how to develop fuzzy logic based applications,
free telephone support for 90 days and access to the Aptronix
FuzzyNet information exchange.
Servo Motor Force Control
FIDE Application Note 003-140892
Aptronix Inc., 1992
programming/FUZZYLOGIC/news1.txt
+100
View File
@@ -0,0 +1,100 @@
Computer Design
April 1992
FUZZY LOGIC IS ANYTHING BUT FUZZY
---------------------------------
- INTERVIEW WITH PROFESSOR LOTFI ZADEH -
CD: Today fuzzy logic appears to be most widely used in control
applications, but still seems to be having trouble gaining
acceptance. How do you view the situation?
Zadeh: We have to realize that it's very natural for people,
including myself, to be skeptical when they're presented with
something that claims to provide a different way of looking at
things. In 1965 my expectation was that most applications would
be in the realm of ``humanistic systems,'' such as linguistics,
social sciences and biological sciences where hard mathematics
doesn't seem very effective. But then we began to see that
fuzzy logic could be used in control. In control it is said
that people want rigor and respectability. But then there are
many realistic problems that cannot be rigorously defined. Fuzzy
algorithms for control policy will gain increasing though
perhaps grudging acceptance because conventional nonfuzzy
algorithms cannot in general cope with the complexity and ill-
defined nature of large scale systems. Control theory must
become less preoccupied with mathematical rigor and precision
and more concerned with the development of qualitative or
approximate solutions to pressing real world problems.
CD: What do you tell people who express doubts about the
reliability and stability of fuzzy systems?
Zadeh: In the case of control systems, we do have a theory of
stability. And presumably that theory can tell you that a
certain kind of system will be stable. But actually that is
much less significant from a practical point of view than one
might think. Once you read the fine print, you find that what
the theory can tell you is much more limited. It can tell you
that if you linearize and if you do all sorts of things under
certain assumptions. The trouble is it's very difficult to say
whether those assumptions hold or not. So you're left with
something that is not really comforting. You can't really sleep
safely if someone using classical theory tells you that some
control system is stable. Fuzzy systems are course systems.
Fuzzy control is course control that exploits the tolerance for
imprecision. So if there is some imprecision and if the
imprecision can be tolerated, you try to take advantage of it by
making the system more robust and less susceptible to
deviation. But still it is correct to say that at this point we
don't have a theory for stability of fuzzy logic control that is
nearly as well developed as for classical systems. Stability
theory is really effective when it comes to linear systems and
fuzzy systems deal with nonlinearity.
In the case of fuzzy control, the systems are very complex. In
many cases you cannot describe really what they do so it is
difficult to prove or disprove stability. It's not that people
are stupid, it's that the problems are more complex and it's
more difficult to come out with some kind of unqualified
statement. So people compensate for that with simulation. They
perform many, many trial runs. In the case of the subway in the
city of Sendai, Japan, I think there were some 300,000
simulations and 2,000 actual runs to prove the system because
you do not play with a subway system. So I think the fact that
the Sendai subway system has functioned perfectly since July 15,
1987 is a stronger testimony than theory. So here is a system
where the issues of stability and reliability are of paramount
importance and it has proved to be successful.
CD: Is the choice then between devoting a lot of time to
establishing a mathematical model for classical control in
advance, or, in fuzzy logic, designing the system and then
proving and refining it in simulation?
Zadeh: I think you put it well. The test of any theory is the
ability to predict. So if you cannot predict what will happen,
you don't have much of a theory. Many so-called theories flunk
this test, particularly in economics. In fuzzy systems, instead
of performing some sort of analysis on paper or on computer that
will predict how the system will behave, you simulate. So
simulation is an alternative to prediction. It is not as
desirable, but in the final analysis it may be more reliable.
There's always a possibility that your theoretical analysis
didn't take into consideration certain things. Software is a
good example. In the final analysis you have to run the
program. Only actual use will tell you if there are bugs in the
program or not.
------------------------------------------------------------
This is article is provided with permission from Computer
Design. For subscription information to Computer Design, call
Paul Westervelt at (913) 835-3161. Do not redistribute in
any form (written or electronic) without permission from
Computer Design.
This information is provided by
Aptronix FuzzyNet
408-428-1883 Data USR V.32bis
programming/FUZZYLOGIC/news10.txt
+23
View File
@@ -0,0 +1,23 @@
A BRIEF ANSWER TO "WHAT IS FUZZY LOGIC?"
Most decisions we make in daily living are thought out with words, not
numbers. For example, suppose Al Bundy (a shoestore owner) tells his new
assistant that he should first show a size 12 shoe if the customer is a very
tall man and a size 6 if very short. Now a customer walks in and appears to
be "somewhat tall". Since the customer is definitely not very short but also
not exactly very tall, the assistant decides to first show a size 10.
This reasonable decision was achieved by interpolating (finding a middle
ground) between size 6 and size 12. Since the customer was closer to being
very tall than being very short, a number was chosen closer to size 12 than
size 6. This mental process can be modelled in a mathematical way called
fuzzy logic.
Note that a precise numeric value (size 10) was produced, even though the
rules which the assistant was given contained vague non-numeric references,
such as "very tall". That is the power of fuzzy logic.
Mark Jurick
Consultant
programming/FUZZYLOGIC/news11.txt
+399
View File
@@ -0,0 +1,399 @@
APTRONIX
2150 North First Street
San Jose, CA 95131
(408) 428-1888
Fax (408) 428-1884
FuzzyNet (408)428-1883 data 8/N/1
What is Fide?
-------------
Fide (Fuzzy Inference Development Environment) is a complete environment
for the development of fuzzy logic-based systems. Fide provides system
engineers with the most effective fuzzy tools in the industry and runs in
MS-Windows(TM) on 386/486 hardware. The price is $1495 and is available
now from Aptronix and authorized Motorola distributors. The software
package comes with complete documentation on how to develop fuzzy logic
based applications, free telephone support for 90 days and access to
the Aptronix FuzzyNet information exchange.
Fide employs a friendly and useful tool for each level of debugging,
including data tracing, analysis and simulation. These tools present the
inference unit's behavior from the perspective of the user and enable
interactive debugging of the fuzzy model and the inference process. If
the inference unit does not perform as expected, these tools lead the user
to the bug location in the source code. Engineers will feel comfortable
developing applications with Fide because the interaction of the tools
follow a traditional programming approach of design, simulation and
analysis.
Specify the fuzzy inference system effectively
----------------------------------------------
Fide is based on a language called FIL (Fuzzy Inference Language). Because
FIL is a non-sequential language with English-like statements, using FIL
is very easy. Although simple to learn, FIL incorporates the most
efficient inference methods and a rich variety of logic operators for
different applications. FIL also provides optimized flexibility for
membership function representation and the data types required by separate
target processors.
Take advantage of an open architecture that offers easy compatibility
----------------------------------------------------------------------
For the first time, a complete standard for fuzzy systems is combined into
one unit called FSSE, Aptronix's fuzzy system standard environment. In
order to provide the user with an open architecture environment, Aptronix
has made FSSE available to the public. FSSE consists of data formats for
membership functions, inference rules, inference units and other fuzzy
inference parameters.
Simulation instead of fabrication
---------------------------------
Testing a system is usually expensive, time consuming and sometimes
impossible. With Fide engineers can design, simulate and perfect an
entire dynamic system, including hardware, before building anything.
Engineers can perfect designs and examine trade-offs while avoiding costly
errors in the fabrication or assembly stages of construction.
Get the product to market faster
--------------------------------
Fide's integrated tools provide the most efficient environment to debug,
analyze and simulate the behavior of a system. The time from conceptual
design to testing and implementation is reduced dramatically.
HOW TO USE FIDE IN THREE EASY STEPS
-----------------------------------
A fuzzy logic system is based on fuzzy inference units integrated with
non-fuzzy units. Fide is designed to cover the entire spectrum of the
system design process, both at the unit and system level. To design a
fuzzy inference unit, follow these three steps:
STEP #1 - Write the source code.
All source code is written in FIL (the language for fuzzy inference).
Specify the input/output variables, the membership functions associated
with them, and the inference rules with FIL. If the system requires
special logic operators and inference methods, FIL provides the capability
to tailor the source code for specific requirements.
Use the Fide graphic editor to draw a graph of the membership function (as
opposed to using a text editor and FIL to describe a membership
function.) The editor automatically converts the graph into a segment of
code. The Fide compiler translates the source code into the Aptronix
standard data structure.
Step #2 - Debug the code
Fide provides an elegant way to view a unit from multiple perspectives via
three powerful debug tools.
TRACER
A. By using the Fide tracer, designers can set the input
variable to any test value and observe the output
value. If undesired results occur, it is easy to
trace into the details of the inference process, step
by step, and locate the specific location where the
source code can be edited and the bug fixed.
ANALYZER
B. The next debug tool is the Fide analyzer which
displays a global view of the transfer function
response. Here, input/output relationships are
displayed as a three dimensional structure. Advanced,
interactive 3-D graphics let users check the function
in detail, examining the surface from a variety of
perspectives. Aptronix has made an important
advancement in debugging technology by combining the
analyzer and simulator with the tracer. Using a
hot-link to the tracer, engineers can trace the
inference process at any selected point on the surface
-- even to the source level.
SIMULATOR
C. The final debug tool is the Fide simulator. It
runs the unit with input values prepared in an input
value file. The simulator displays curves of the
output values and simulates the unit's dynamic
behavior. Again, a hot-link to the tracer is provided
for immediate access to the source code level
providing unprecedented debugging capability.
Step #3 -- Generate the real-time code.
Once a processor has been selected for implementation,
the corresponding Fide RTC (real-time code) generator
can be used for that chip. If the unit is implemented
in software, the Aptronix run-time library, when
linked into a C program, performs the fuzzy inference
computation.
System integration with Fide using Composer
-------------------------------------------
There is a unique way of graphically simulating and testing a system
of fuzzy inference units and application specific code with Aptronix
Composer. When using the Composer, a system is regarded as an open or
closed loop consisting of units connected with data transfer
channels. In addition to fuzzy inference units, users can integrate
other software modules, such as operation units (performing
mathematical operations) and/or execution units (describing prepared
software modules).
COMPOSER
Source code can be written or drawn using the graphical
editor. The system integration language, called FCL
(Fide Composer Language) has textual and graphical
representations. In its graphical representation, a
system is described by drawing a chart of data flow
paths between units. In its textual representation, a
system is described by listing the units and the data
transferred between them.
The Composer textual editor and Composer graphical
editor are used to design and modify the system and a
built-in converter can change one representation to
the other. To test the system, the data flow viewer
or the dynamic simulator is used.
The data flow viewer allows testing of the unit by
setting input values and observing the details of data
flow in the system. If a fuzzy inference
unit is found to have an undesired response, a
hot-link automatically takes the user to the tracer.
The dynamic simulator analyzes the dynamic behavior of
the system. The user initializes the system with any
values, sets terminating conditions and then lets the
system run automatically. When the terminating
conditions are met, the values of all selected
input/output variables are displayed as time-value
graphs.
Applications
------------
Fuzzy logic can improve system performance and reduce design time and cost
in a wide range of applications. Such as:
Automotive
In order to improve quality, performance, and shorten development cycles,
major automotive manufacturers are now using fuzzy technology. Typical
applications include fuzzy engine control, fuzzy cruise control, fuzzy
anti-lock braking systems and fuzzy transmission systems.
Aerospace
The aerospace industry requires real-time high-performance systems that
present difficult problems for engineers. Fuzzy technology proves new and
useful methods of approaching design of these challenging systems.
Appliances
Fuzzy technology simplifies the product design and development cycle,
lowers production costs, and improves product performance. Many consumer
manufacturers have been quick to implement fuzzy technology into new
products such as washing machines, air conditioners, cameras, VCRs and
televisions.
Chemical
The complexity of system modeling is a very difficult problem in the
chemical industry. The descriptive modeling feature of fuzzy logic makes
it an idea tool for complex systems design.
General Manufacturers
Fuzzy logic-based real-time diagnosis and control systems are invaluable
for increasing equipment efficiency and diagnosing malfunctions.
Civil Engineering
Traditional system analysis and assessment are based on inexact conceptual
models which may lead to errors in system analysis. Since fuzzy
technology describes the system more accurately, the assurance of systems
analysis is increased.
Finance
Fuzzy systems provide a methodology for modeling the uncertainly in market
trends and risk analysis. Using fuzzy logic, the financial world can
develop models that are more realistic.
Education
Academic institutions can use Fide to reach and perform research in fuzzy
inference-based systems design and related work. Aptronix has close ties
with the research community through it's University Program. Through this
program, Aptronix shares important developments in fuzzy technology with a
future generation of engineers.
APTRONIX COMPANY OVERVIEW
-------------------------
Headquartered in San Jose, California, Aptronix develops and markets fuzzy
logic-based software, systems and development tools for a complete range
of commercial applications. The company was founded in 1989 and has been
responsible for a number of important innovations in fuzzy technology.
Aptronix's product Fide (Fuzzy Inference Development Environment) -- is a
complete environment for the development of fuzzy logic-based systems.
Fide provides system engineers with the most effective fuzzy tools in the
industry and runs in MS-Windows(TM) on 386/486 hardware. The price is
$1495 and is available now from Aptronix and from authorized Motorola
distributors. The software package comes with complete documentation on
how to develop fuzzy logic based applications, free telephone support for
90 days and access to the Aptronix FuzzyNet information exchange.
Aptronix Customer Support Services
----------------------------------
When you contact Aptronix Technical Support, you have direct access to
experience. Each member of the Aptronix Customer Support Group works with
Fide every day. We consult with Aptronix programmers on design and
useability issues, and we work regularly with application engineers who
utilize Fide to build advanced fuzzy logic applications.
Whether you are working on a deadline and need a quick answer, or cannot
find the answer in your manual, call Aptronix Technical Support Services.
We have the experience -- and we have the answers.
Get the Answers - Free For 90 Days
----------------------------------
When you are getting started with Fide, call the experts at Aptronix any
business day. We provide 90 days of free telephone service from the time
you send in your registration card. Our telephone support hours are from
9am - 5pm Pacific Standard Time.
After 90 days, you can continue to access Aptronix Technical Support by
using the Aptronix FuzzyNet BBS, fax or mail. All you need to do is
register your copy of Fide.
Aptronix one year extended support
----------------------------------
For on going support and advice on more advanced uses of Fide, Aptronix
provides its AES - Aptronix Extended Support services. This program
includes the following assistance:
1. Tips and tricks for advanced uses of Fide
2. An analysis of the fuzzy inference units you have designed and
recommendations on how to optimize the performance of your inference
unit(s). Customers will need to send example Fide source code and a
summary of the applications.
3. Advice on how to integrate fuzzy inference units into applications to
improve speed and performance of the overall system.
The price for this service is $550 per year and it includes a 9600 baud
external modem for high speed access to our FuzzyNet electronic BBS
system. Telephone support is also included with this service contract.
As an option, users can purchase this service for $350 without the modem --
although we highly suggest using a modem for access to our FuzzyNet
system.
Customer engineering solution services
--------------------------------------
Aptronix also provides Customer Engineering Services for a complete
solution to your application. Aptronix engineers can design your
turn-key system and share our experience and expertise in fuzzy logic.
Through Aptronix, you get the best solution for your application so you
will create better products faster. This service is individually
negotiated based on the scope of the project and requires a detailed
description of your application. Please call (408) 428-1888 for more
information.
BACKGROUND INFORMATION
----------------------
What is fuzzy logic?
Fuzzy logic is a powerful problem-solving methodology with a myriad of
applications in embedded control and information processing. Fuzzy logic
provides a remarkably simple way to draw definite conclusions from vague,
ambiguous or imprecise information. In a sense, fuzzy logic resembles
human decision making with its ability to work from approximate data and
find precise solutions.
Fuzzy logic is based on fuzzy set theory. Unlike traditional " either/or"
set theory, fuzzy logic does not impose rigid classifications such as true
or false, black and white, 0 or 1, etc. Membership in fuzzy sets is a
continuous phenomenon, with values ranging from 0 to 1. This allows
programmers to model vague and subjective concepts such as "very hot,"
"bright red," and "a long time".
Why Use Fuzzy logic?
Using fuzzy logic, system designers can realize lower development costs,
superior features, and better end product performance. Most importantly,
products can be brought to market faster and more cost-effectively.
Several factors make fuzzy logic desirable to the system designer.
1. Describe and model solutions to a problem without having to use complex
mathematical models for systems and development.
2. Optimize a known solution in order to obtain a simpler and more
effective implementation.
3. Simplify the system design process, thereby decreasing development
costs.
4. Make the system more descriptive. A system is more convenient to
manage, maintain, upgrade and is easier to differentiate with less
risk.
5. Have a higher fault-tolerance and a better trade-off between system
robustness and system sensitivity.
6. Provide products with powerful features and performance within a price
range unmatched by other solutions.
For Further Information Contact:
APTRONIX
2150 North First Street
San Jose, CA 95131
(408) 428-1888
Fax (408)-428-1884
FuzzyNet (408)428-1883 data 8/N/1
July 92
programming/FUZZYLOGIC/news12.txt
+52
View File
@@ -0,0 +1,52 @@
WHAT IS FUZZY LOGIC?
Fuzzy logic is a powerful problem-solving methodology with a myriad of
applications in embedded control and information processing. Fuzzy logic
provides a remarkably simple way to draw definite conclusions from vague,
ambiguous or imprecise information. In a sense, fuzzy logic resembles
human decision making with its ability to work from approximate data and
find precise solutions.
Fuzzy logic is based on fuzzy set theory. Unlike traditional " either/or"
set theory, fuzzy logic does not impose rigid classifications such as true
or false, black and white, 0 or 1, etc. Membership in fuzzy sets is a
continuous phenomenon, with values ranging from 0 to 1. This allows
programmers to model vague and subjective concepts such as "very hot,"
"bright red," and "a long time".
WHY USE FUZZY LOGIC?
Using fuzzy logic, system designers can realize lower development costs,
superior features, and better end product performance. Most importantly,
products can be brought to market faster and more cost-effectively.
Several factors that make fuzzy logic so desirable to the system designer.
1. Describe and model solutions to a problem without having to use complex
mathematical models for systems and development.
2. Optimize a known solution in order to obtain a simpler and more
effective implementation.
3. Simplify the system design process, thereby decreasing development
costs.
4. Make the system more descriptive. A system is more convenient to
manage, maintain, and upgrade, and is easier to differentiate with less
risk.
5. Have a higher fault-tolerance and a better trade-off between system
robustness and system sensitivity.
6. Provide products with powerful features and performance within a price
range unmatched by other solutions.
For Further Information Contact:
APTRONIX
2150 North First Street
San Jose, CA 95131
(408) 428-1888
Fax (408)-428-1884
FuzzyNet (408)428-1883 data 8/N/1
programming/FUZZYLOGIC/news2.txt
+60
View File
@@ -0,0 +1,60 @@
Excerpt from Computer Design
April 1992
NASA EYES RANGE OF FUZZY CONTROL IDEAS IN SPACE
------------------------------------------------
NASA has recently reported encouraging research results in a
number of areas using fuzzy logic. One of the most advanced
projects is a controller for space shuttle proximity operations,
i.e. maneuvering around or keeping position with respect to
another object in space. Work has been progressing on a fuzzy-
based translational controller which deals with the parameters
of azimuth and angle and their respective rates of change, and
the range and rate of change of range with respect to another
object.
NASA engineers developed natural language rules to run the
controller and are testing it in a multi-vehicle simulation by
substituting the fuzzy controller for the simulator's normal
human inputs. The rule base was learned from the experience of
human operators and the efficiency of the controller was tuned
based on flight profiles recorded from actual missions and
simulations. One of the main advantages in developing the fuzzy
translational controller were that the engineers did not need to
construct a detailed mathematical model of the system in
advance. Performance was honed through simulation and
experience.
The results of simulations have been encouraging, especially in
terms of fuel efficiency. In holding position with respect to
a target, the fuzzy controller required significantly less
acceleration (i.e. smaller increments of position change) than
did the human controlled simulation. In overall maneuvers, the
fuzzy controller has shown a 20% to 70% better fuel efficiency
than the currently used digital auto pilot and the best
simulation runs of human pilots.
NASA is also exploring other applications of fuzzy control in
space. Among the projects being considered are the use of
inexpensive cameras for constant tracking of objects around the
space station, fuzzy control can contribute to collision
avoidance systems, robot arm control and traffic management.
At the great distance of interplanetary space where it can take
20 minutes to send a signal and receive an answer, robotic
systems will have to operate quasi-independently. A fuzzy
controller on an unmanned Mars rover vehicle is expected to help
the rover avoid obstacles and identify and collect soil samples
based on imprecise sensor input and only partially known
conditions.
------------------------------------------------------------
This is article is provided with permission from Computer
Design. For subscription information to Computer Design, call
Paul Westervelt at (913) 835-3161. Do not redistribute in
an form (written or electronic) without permission from
Computer Design.
This is information is provided by
Aptronix FuzzyNet
408-428-1883 Data USR V.32bis
programming/FUZZYLOGIC/news3.txt
+40
View File
@@ -0,0 +1,40 @@
Excerpt from Computer Design
April 1992
FUZZY LOGIC WILL MAKE CARS SMARTER
----------------------------------
It's estimated that by the end of the century, the amount of
electronics in automobiles will double. Among the areas of
interest are an emission control system that would continuously
monitor the exhaust gases and make adjustments to the carburetor
and ignition systems to keep the levels of hydrocarbons and
other toxic elements within specified limits. Interior climate
control would be able to adjust to the number of passengers like
some fuzzy controlled air conditioning systems do today. Fuzzy
controlled digital signal processors are being investigated for
interior noise cancellation systems.
Today's digital anitlock braking systems work by cycling the
brakes rapidly on and off. A fuzzy controller could presumably
provide smooth antilock braking by adjusting hydraulic pressure
in accordance with slight amounts of wheel rotation.
One item under active development is a multiple mode automatic
transmission. By sensing rotation, torque, engine speed and
throttle position, a fuzzy controller could determine the proper
shift points. By selecting a different set of rules and
membership functions the driver could set the transmission for
smooth shifting, optimal economy shifting or sport shifting.
------------------------------------------------------------
This is article is provided with permission from Computer
Design. For subscription information to Computer Design, call
Paul Westervelt at (913) 835-3161. Do not redistribute in
an form (written or electronic) without permission from
Computer Design.
This is information is provided by
Aptronix FuzzyNet
408-428-1883 Data USR V.32bis
programming/FUZZYLOGIC/news4.txt
+61
View File
@@ -0,0 +1,61 @@
Excerpt from Computer Design
April 1992
FUZZY MUG SEARCH HELPS COPS CATCH CROOKS
----------------------------------------
Well known to all devotees of detective shows is the scene where
a crime victim sits for long hours paging through mug books to
try to identify some evildoer. Even when police departments
have managed to computerize their databases of known
perpetrators, the process of narrowing the identification search
to a manageable number of mug shots based on a witness's
description is a tedious one.
Knowledge Based Systems of White Plains, NY added a fuzzy front
end to the image database of a major European police department
that significantly reduced the number of look throughs witnesses
had to do before finding a set of pictures they could seriously
work with to try to identify a subject. In the past, if someone
came in and said, ``He was kind of tall and heavy-set and looked
rather young,'' the police would have only a vague idea of what
group of pictures to start showing the witness. Even if the
system were computerized, someone would have to decide where the
cutoff point was for ``rather young,'' or ``tall.'' If a person
were described at 6'1'' but was really 5'11'', the system might
not catch the out of range number even if other factors in the
description pointed to an overall match.
In addition to implementing a front end to the database that
uses fuzzy sets to describe characteristics like ``old,''
``thin,'' ``tall'' and so on, KBS built in what it calls
``perspective shifting'' and ``semantic plies.'' Perspective
shifting changes the shape of the fuzzy set representing, say,
``tall'' if the witness is for instance a 16-year-old girl or
Japanese. It allows the system to search for ``old'' from a
``young'' perspective. Semantic plies adjust the description as
in ``tall for women'' or ``heavy for Samoans.''
The success of searching for a useful set of mug shots to
examine is because perspective shifting and semantic plies
affect the degree of belief in a fuzzy concept based on the
witness's characteristics; they do not make crisp distinctions.
Thus 5 feet will have a greater degree of membership in ``tall'
for a 10-year-old than for an adult, etc. The pictures of
subjects to look at are selected on an overall degree of truth
from the combined described characteristics, which in this
instance was set at 0.38. According to KBS, the old system
required an average of 16 look-throughs to find a set that
someone could actually work with, while the fuzzy system reduced
the number of look-throughs to two.
------------------------------------------------------------
This is article is provided with permission from Computer
Design. For subscription information to Computer Design, call
Paul Westervelt at (913) 835-3161. Do not redistribute in
an form (written or electronic) without permission from
Computer Design.
This information is provided by
Aptronix FuzzyNet
408-428-1883 Data USR V.32bis
programming/FUZZYLOGIC/news5.txt
+163
View File
@@ -0,0 +1,163 @@
Excerpt from Computer Design
April 1992
The Seven Noble Truths Of Fuzzy Logic
by Earl Cox
TRUTH ONE
There Is Nothing Fuzzy About Fuzzy Logic
The idea that fuzzy logic is fuzzy or intrinsically imprecise is
one of the most commonly expressed fables in the fuzzy logic
mythos. This wide-spread belief comes in two flavors, the first
holds that fuzzy logic violates common sense and the well proven
laws of logic, and the second, perhaps inspired by its name,
holds that fuzzy systems produce answers that are somehow
ad-hoc, fuzzy, or vague. The feeling persists that fuzzy logic
systems somehow, through their handling of imprecise and
approximate concepts, produce results that are approximations of
the answer we would get if we had access to a model that worked
on hard facts and crisp information. Nothing could be further
from fact.
There is nothing fuzzy about fuzzy logic, Fuzzy Sets differ from
classical or crisp sets in that they allow partial or gradual
degrees of membership. We can see the difference easily by
looking at the difference between a conventional (or "crisp")
set and a fuzzy set. Thus someone 34 years, eleven months, and
twenty eight days old is not middle aged. In the Fuzzy
representation, however, we see that as a person grows older he
or she acquires a partial membership in the set of Middle Aged
people, with total membership at forty years old.
But there is nothing ambiguous about the fuzzy set itself. If
we know a value from the domain, say an age of 35 years old,
then we can find its exact and unambiguous membership In the
set, say 82%. This precision at the set level allows us to write
fuzzy rules at a rather high level of abstraction. Thus we can
say, if age is middle-aged, then weight is usually quite heavy;
and means that, to the degree that the individual's age is
considered middle aged, their weight should be considered
somewhat heavy. A weight estimating function, following this
(very simple) rule might infer a weight from age through the
following fuzzy implication process.
Much of the discomfort with fuzzy logic stems from the implicit
assumption that a single ``right'' logical system exists and to
the degree that another system deviates from this right and
correct logic it is in error. This ``correct'' logic, of
course, is Aristotelian or Boolean logic. But as a logic of
continuous and partial memberships, Fuzzy Logic has a deep and
impressive pedigree. Using the metaphor of the river, Heraclitus
aptly points out that a continuous reasoning system more
correctly maps nature's logical ambiguities. From his dictum
that all is flux, nothing is stationary, he devcloped a
rudimentary multi-valued logic two hundred years before
Aristotle. Recently, Bart Kosko, one of the most profound
thinkers in fuzzy logic, has shown that Boolean logic is, in
fact, a special case of fuzzy logic.
TRUTH TWO
Fuzzy Logic Is Different from Probability
The difference between probability and fuzzy logic is clear when
we consider the underlying concept that each attempts to model.
Probability is concerned with the undecidability in the outcome
of clearly defined and randomly occurring events, while fuzzy
logic is concerned with the ambiguity or undecidability inherent
in the description of the event itself. Fuzziness is often
expressed as ambiguity rather than imprecision or uncertainty
and remains a characteristic of perception as well as concept.
TRUTH THREE
Designing the Fuzzy Sets is very asy
Not only are fuzzy sets easy to conceptualize and represent, but
they reflect, in a general "one-to-one" mapping, the way experts
actually think about a problem. Experts can quickly sketch out
the approximate shape of a fuzzy set. Later, after we have run
the model or examined the process, the precise characteristics
of the fuzzy vocabulary can be adjusted if necessary.
TRUTH FOUR
Fuzzy Systems are Stable, Easily Tuned,
and can be conventionally Validated
Creating fuzzy sets and building a fuzzy system is faster and
quicker than conventional knowledge-based systems using "crisp"
constructs. These fuzzy systems routinely show a one or two
order of magnitude reduction in rules since fuzzy logic
simultaneously handles all the interlocking degrees of freedom.
Fuzzy systems are very robust since the over-lapping of the
fuzzy regions, representing the continuous domain of each
control and solution variable, contributes to a well-behaved and
predictable system operation. These systems are validated in
the same manner as conventional system. The tuning of fuzzy
systems, however, is usually much simpler since there are fewer
rules; representation if visually centered around fuzzy sets,
and operations act simultaneously on the output areas.
TRUTH FIVE
Fuzzy Systems are Different From
and Complementary to Neural Networks
There is a close relationship between fuzzy logic and neural
systems. A fuzzy system attempts to find a region that
represents the space defined by the intersection, union, or
complement of the fuzzy control variables. This has analogies
to both neural network classifiers and linear programming
models. Yet fuzzy systems approach the problem differently with
a deeper and more robust epistemology. In a fuzzy system, the
classification and bounding process is much more open to the
developer and user with capabilities for explanations, rule and
fuzzy set calibration, performance measurements, and controls
over the way the solution is ultimately derived.
TRUTH SIX
Fuzzy logic "ain't just process control anymore"
Historically we have come to view fuzzy logic as a process
control and signal analysis technique, but fuzzy logic is really
a way of logically representing and analyzing information,
independent of particular applications. The information
management field in particular has, until recently, ignored
fuzzy logic, delaying its introduction into expert system and
decision support technology. Recently, however, new types of
knowledge base construction tools have emerged. Such tools will
make it easier for experts who are not computer experts to
intuitively represent and manipulate information.
TRUTH SEVEN
Fuzzy Logic is a Representation and Reasoning Process
Not the "Magic Bullet" for all AI's current problems - Fuzzy
Logic is a tool for representing imprecise, ambiguous, and vague
information. Its power lies in its ability to perform meaningful
and reasonable operations on concepts that are outside the
definitions available in conventional Boolean logic. We have
used fuzzy logic in such applications as project management,
product pricing models, health care provider fraud detection,
sales forecasting, market share demographic analysis, criminal
identification, capital budgeting, and company acquisition
analysis. Although fuzzy logic is a powerful and versatile tool,
it is not a solution to all problems. Nevertheless, it opens the
door for the modeling of problems that have generally been
extremely difficult or intractable.
Earl Cox, CEO
Metus Systems
White Plains, NY
(914) 238-0647
------------------------------------------------------------
This is article is provided with permission from Computer
Design. For subscription information to Computer Design, call
Paul Westervelt at (913) 835-3161. Do not redistribute in
an form (written or electronic) without permission from
Computer Design.
This information is provided by
Aptronix FuzzyNet
408-428-1883 Data USR V.32bis
programming/FUZZYLOGIC/news6.txt
+123
View File
@@ -0,0 +1,123 @@
The following are comments by Aptronix engineers on the
differences between designing with traditional PID
control versus fuzzy logic control. There is an
assumption that you understand the classic control
problem of balancing an inverted pendulum. For more
details please see the Aptronix Quick Start Quide, User
Manual and Reference Manual.
------------------------------------------------------
Fuzzy Control Systems
Aptronix, Inc.
1. For Non-linear, Dynamic System.
As is well known, the conventional linear model-based
controllers can be designed according to some optimal
criteria, and the optimality and stability can be proved.
However, it is difficult to design a optimal or stable
controller for a nonlinear, dynamic, and ill-understood
process, which is common in the real world. One practical
method is to simplify and linearize the non-linear model.
After the simplification, the optimality and stability are
only for the simplified model. For an ill-understood
process, its model is unknown and it is impossible to use
conventional methods to design a controller. In these cases,
human experience should be utilized.
For example, in the designing of a controller for an
inverted pendulum, one must first simplify the real process
model by linear equations and then design an optimal
controller for the simplified model.
Fuzzy logic controllers utilize human knowledge by
describing the control strategies by linguistic rules. For
the inverted pendulum example, a basic control strategy will
be `if the pendulum declines to the right Fast, then move
the cart to the right Fast'. The fuzzy term `Fast' can be
represented by a fuzzy set. By considering the cases more
carefully, we can fine tune these rules.
Such kind of knowledge exists in many industrial control
processes. Clearly, the control rules are model-free: no
matter how (mathematically) difficult the process is, an
experienced operator can still give some control rules.
Fuzzy logic controllers are suitable for non-linear,
dynamic, and ill-understood processes.
2. Robustness
PID (Proportional-Integral-Derivative) control is the
major practical technology that is widely used in
industries. However, the performance of PID controllers
depends heavily on the operating parameters of the system.
If there is any change in the system, a significant amount
of time is required to tune the controllers. As a result,
the average industrial plant operator ends up running over
50% of his PID loops in manual mode.
For example, if the length of the pendulum changes, the
parameters of the linear controller should be changed
accordingly.
Fuzzy controllers are more robust. If the length of the
pendulum changes in a certain range, the control rules and
fuzzy sets need not change. Physical demonstrations have
proven this robustness in several international conferences
of fuzzy systems.
3. Short Development Period
In the design of a linear controller, one should do
the following steps after selecting the sensors:
1. Modelling: Build a mathematical model describing
the process.
2. Linearization: Linearize the model.
3. Solving equations: Make a trial design based on
optimal control or other criteria.
4. Simulation: Simulate the design. If not satisfied,
go to step 1.
For a fuzzy controller, the steps are:
1. Analysis: Analyze the process.
2. Acquisition of rules: Acquire control rules from
experience operators.
3. Simulation: Simulate the fuzzy controller. If not
satisfied, got to step 1.
For the processes that are difficult to model but have
straightforward control rules, the fuzzy controllers are
easy to design and implement. Since the fuzzy controllers
are designed directly from the properties of the process,
the development time will be shorter than for conventional
controllers.
4. Transparency
Since fuzzy controllers are designed according to
experience, they are more transparent than conventional
controllers.
The parameters of conventional controllers are computed from
equations under certain conditions. The parameters and
fuzzy sets in fuzzy controllers are defined according to
experience. Because of transparency, maintenance
and upgrading are easy.
This information is provided by
Aptronix FuzzyNet
408-428-1883 Data USR V.32bis
Voice 408-428-1888
FAX 408-428-1884
programming/FUZZYLOGIC/reactor.txt
+814
View File
@@ -0,0 +1,814 @@
INTRODUCTION
Temperature control is widely used in various processes. These
processes, no matter it is a process of large industrial plant,
or a process in home appliance, share several unfavorable
features such as non-linearness, interference, dead time, and
external disturbance, etc. Conventional control approaches
usually cannot achieve satisfactory results for this kind of
processes.
The following example is third in series using fuzzy logic to
control temperature. By using pressure as an input variable, we
develop a sophisticated temperature controller. This example is
developed with FIDE, an integrated fuzzy system development
environment from Aptronix.
FUZZY TEMPERATURE CONTROLLER FOR REACTOR
A film manufacture equipment is shown in Figure 1. Gas in a
reactor is drained out and a little argon gas is input. Imposing
high frequency voltage, electricity would be discharged between
the electrode and the base. Dissociated argon ions crash onto the
target and make atoms split out so that a film will be generated
on the base. Because base temperature is critical in the process
of film generation, temperature control becomes very important.
Figure 1 shows the system diagram of a fuzzy temperature
controller used in this kind of reactor. Inputs to the controller
are desired base temperature, measured base temperature, measured
pressure in the reactor. Pressure is used because it has a large
influence on base temperature to be controlled. High pressure
results in high temperature. Output signals of the controller
adjust the heater and the electromagnetic valve for the cooling
water in the reactor.
Figure 2 shows the fuzzy controller that has three input
variables and two output variables. Inputs can be prepared from
feedback signals from sensors. The first input variable is the
difference between desired temperature and measured temperature,
the second input variable is the variation between current temperature
difference and previous temperature difference, the third
input variable is current pressure p. Two output variables
are control signals to hte heater and the cooling valve.
Advantages of Fuzzy Controller
A conventional single loop control system adjusts controlled
output temperature only by the feedback signal from a temperature
sensor. Pressure changes in the reactor are regarded as noises to
this system. To design a conventional controller for this kind of
system is difficult and time consuming. However, using a fuzzy
controller, we can deal with this problem simply by taking
factors(such as pressure), which have influence on the output,
into account when designing the controller. To create a fuzzy
controller for the above system, what we need to do is to
write rules that contain not only temperature but also
pressure in their antecedents. This design process is much
easier compared with that of conventional controllers
because we can write rules using commonsense knowledge and
know-how from experts. Rules are English like sentences and
intuitive. No mathematical model of the process is needed
as in the case of conventional control.
Using FIDE to Design a Fuzzy Controller
FIDE is a product of Aptronix(see attached company information at
the end of this note) which provides powerful integrated
development environment for fuzzy logic based systems.
The process of designing a fuzzy controller can be summarized as:
Define input/output variables. This process includes definition
of labels and membership functions for each variable.
Create rules that are represented as if-then English like sentences.
Simulate and tune.
The input/output variables are given in Figure 2. In the
following, we give definitions of labels and membership
functions for each variable and then provide the rules for the
controller in a FIU (Fuzzy Inference Unit) source code.
Definitions of Input/Output Variables
Labels and membership functions of input variables are defined in
Figure 3 and Figure 4. Those of output variables are in Figure 5.
For membership functions whose shapes are simple, such as
triangles, they are easy to be defined in a FIU source code. For
example, for label P_Large in Figure 3, the definition can be
written as (@0.6, 0, @1.0, 1), and for label Zero, the definition
can be written as (@-0.3, 0, @0.0, 1, @0.3, 0), and so on. For
more details on the definition of membership functions, please
see Fide User's Manual and Reference Manual.
Note that all values of variables here are normalized into the
range of [-1,1] or [0,1].
Figure 3 Labels and Membership Functions of Input Variables
Error and Var_Error
Figure 4 Labels and Membership Functions of Input Variable
Pressure
Figure 5 Labels and Membership Functions of Output Variables
Var_Heater and Var_Cooling
FIU Source Code
$ FILENAME: temp/temp3.fil
$ DATE: 09/18/1992
$ UPDATE: 09/23/1992
$ Temperature Controller : Three inputs, two outputs
$ INPUT(S): Error, Var(iationOf)_Error, Pressure
$ OUTPUT(S): Var(iationOf)_Heater, Var(iationOf)_Cooling(Valve)
$ FIU HEADER
fiu tvfi (min max) *8;
$ DEFINITION OF INPUT VARIABLE(S)
invar Error " " : -1.0 () 1.0 [
P_Large (@0.6, 0, @1.0, 1),
P_Medium (@0.3, 0, @0.6, 1, @1.0, 0),
P_Small (@0.0, 0, @0.3, 1, @0.6, 0),
Zero (@-0.3, 0, @0.0, 1, @0.3, 0),
N_Small (@-0.6, 0, @-0.3, 1, @0.0, 0),
N_Medium (@-1.0, 0, @-0.6, 1, @-0.3, 0),
N_Large (@-1.0, 1, @-0.6, 0)
];
invar Var_Error " " : -1.0 () 1.0 [
P_Large (@0.6, 0, @1.0, 1),
P_Medium (@0.3, 0, @0.6, 1, @1.0, 0),
P_Small (@0.0, 0, @0.3, 1, @0.6, 0),
Zero (@-0.3, 0, @0.0, 1, @0.3, 0),
N_Small (@-0.6, 0, @-0.3, 1, @0.0, 0),
N_Medium (@-1.0, 0, @-0.6, 1, @-0.3, 0),
N_Large (@-1.0, 1, @-0.6, 0)
];
invar Pressure " " : 0.0 () 1.0 [
Large (@0.5, 0, @1.0, 1),
Medium (@0.0, 0, @0.5, 1, @1.0, 0),
Small (@0.0, 1, @0.5, 0)
];
$ DEFINITION OF OUTPUT VARIABLE(S)
outvar Var_Heater " " : -1.0 () 1.0 * (
P_Large = 0.8,
P_Medium = 0.4,
P_Small = 0.2,
Zero = 0.0,
N_Small = -0.2,
N_Medium = -0.4,
N_Large = -0.8
);
outvar Var_Cooling " " : -1.0 () 1.0 * (
P_Large = 0.8,
P_Medium = 0.4,
P_Small = 0.2,
Zero = 0.0,
N_Small = -0.2,
N_Medium = -0.4,
N_Large = -0.8
);
$ RULES
if Error is P_Large and Var_Error is N_Large and Pressure is Large
then Var_Heater is Zero;
if Error is P_Large and Var_Error is N_Large and Pressure is Large
then Var_Cooling is N_Small;
if Error is P_Large and Var_Error is N_Medium and Pressure is Large
then Var_Heater is P_Small;
if Error is P_Large and Var_Error is N_Medium and Pressure is Large
then Var_Cooling is N_Medium;
if Error is P_Large and Var_Error is N_Small and Pressure is Large
then Var_Heater is P_Medium;
if Error is P_Large and Var_Error is N_Small and Pressure is Large
then Var_Cooling is N_Large;
if Error is P_Large and Var_Error is N_Large and Pressure is Medium
then Var_Heater is P_Small;
if Error is P_Large and Var_Error is N_Large and Pressure is Medium
then Var_Cooling is N_Small;
if Error is P_Large and Var_Error is N_Medium and Pressure is Medium
then Var_Heater is P_Medium;
if Error is P_Large and Var_Error is N_Medium and Pressure is Medium
then Var_Cooling is N_Medium;
if Error is P_Large and Var_Error is N_Small and Pressure is Medium
then Var_Heater is P_Large;
if Error is P_Large and Var_Error is N_Small and Pressure is Medium
then Var_Cooling is N_Large;
if Error is P_Large and Var_Error is N_Large and Pressure is Small
then Var_Heater is P_Medium;
if Error is P_Large and Var_Error is N_Large and Pressure is Small
then Var_Cooling is N_Small;
if Error is P_Large and Var_Error is N_Medium and Pressure is Small
then Var_Heater is P_Large;
if Error is P_Large and Var_Error is N_Medium and Pressure is Small
then Var_Cooling is N_Medium;
if Error is P_Large and Var_Error is N_Small and Pressure is Small
then Var_Heater is P_Large;
if Error is P_Large and Var_Error is N_Small and Pressure is Small
then Var_Cooling is N_Large;
if Error is P_Medium and Var_Error is N_Large and Pressure is Large
then Var_Heater is N_Small;
if Error is P_Medium and Var_Error is N_Large and Pressure is Large
then Var_Cooling is Zero;
if Error is P_Medium and Var_Error is N_Medium and Pressure is Large
then Var_Heater is Zero;
if Error is P_Medium and Var_Error is N_Medium and Pressure is Large
then Var_Cooling is Zero;
if Error is P_Medium and Var_Error is N_Small and Pressure is Large
then Var_Heater is P_Small;
if Error is P_Medium and Var_Error is N_Small and Pressure is Large
then Var_Cooling is N_Medium;
if Error is P_Medium and Var_Error is N_Large and Pressure is Medium
then Var_Heater is Zero;
if Error is P_Medium and Var_Error is N_Large and Pressure is Medium
then Var_Cooling is Zero;
if Error is P_Medium and Var_Error is N_Medium and Pressure is Medium
then Var_Heater is P_Small;
if Error is P_Medium and Var_Error is N_Medium and Pressure is Medium
then Var_Cooling is Zero;
if Error is P_Medium and Var_Error is N_Small and Pressure is Medium
then Var_Heater is P_Medium;
if Error is P_Medium and Var_Error is N_Small and Pressure is Medium
then Var_Cooling is N_Medium;
if Error is P_Medium and Var_Error is N_Large and Pressure is Small
then Var_Heater is P_Small;
if Error is P_Medium and Var_Error is N_Large and Pressure is Small
then Var_Cooling is Zero;
if Error is P_Medium and Var_Error is N_Medium and Pressure is Small
then Var_Heater is P_Medium;
if Error is P_Medium and Var_Error is N_Medium and Pressure is Small
then Var_Cooling is Zero;
if Error is P_Medium and Var_Error is N_Small and Pressure is Small
then Var_Heater is P_Large;
if Error is P_Medium and Var_Error is N_Small and Pressure is Small
then Var_Cooling is N_Medium;
if Error is P_Small and Var_Error is N_Large and Pressure is Large
then Var_Heater is N_Medium;
if Error is P_Small and Var_Error is N_Large and Pressure is Large
then Var_Cooling is Zero;
if Error is P_Small and Var_Error is N_Medium and Pressure is Large
then Var_Heater is N_Medium;
if Error is P_Small and Var_Error is N_Medium and Pressure is Large
then Var_Cooling is Zero;
if Error is P_Small and Var_Error is N_Small and Pressure is Large
then Var_Heater is N_Small;
if Error is P_Small and Var_Error is N_Small and Pressure is Large
then Var_Cooling is Zero;
if Error is P_Small and Var_Error is N_Large and Pressure is Medium
then Var_Heater is N_Small;
if Error is P_Small and Var_Error is N_Large and Pressure is Medium
then Var_Cooling is Zero;
if Error is P_Small and Var_Error is N_Medium and Pressure is Medium
then Var_Heater is N_Small;
if Error is P_Small and Var_Error is N_Medium and Pressure is Medium
then Var_Cooling is Zero;
if Error is P_Small and Var_Error is N_Small and Pressure is Medium
then Var_Heater is Zero;
if Error is P_Small and Var_Error is N_Small and Pressure is Medium
then Var_Cooling is Zero;
if Error is P_Small and Var_Error is N_Large and Pressure is Small
then Var_Heater is Zero;
if Error is P_Small and Var_Error is N_Large and Pressure is Small
then Var_Cooling is Zero;
if Error is P_Small and Var_Error is N_Medium and Pressure is Small
then Var_Heater is Zero;
if Error is P_Small and Var_Error is N_Medium and Pressure is Small
then Var_Cooling is Zero;
if Error is P_Small and Var_Error is N_Small and Pressure is Small
then Var_Heater is P_Small;
if Error is P_Small and Var_Error is N_Small and Pressure is Small
then Var_Cooling is Zero;
if Error is Zero and Var_Error is N_Large and Pressure is Large
then Var_Heater is N_Large;
if Error is Zero and Var_Error is N_Large and Pressure is Large
then Var_Cooling is P_Medium;
if Error is Zero and Var_Error is N_Medium and Pressure is Large
then Var_Heater is N_Medium;
if Error is Zero and Var_Error is N_Medium and Pressure is Large
then Var_Cooling is P_Small;
if Error is Zero and Var_Error is N_Small and Pressure is Large
then Var_Heater is N_Medium;
if Error is Zero and Var_Error is N_Small and Pressure is Large
then Var_Cooling is Zero;
if Error is Zero and Var_Error is N_Large and Pressure is Medium
then Var_Heater is N_Medium;
if Error is Zero and Var_Error is N_Large and Pressure is Medium
then Var_Cooling is P_Medium;
if Error is Zero and Var_Error is N_Medium and Pressure is Medium
then Var_Heater is N_Small;
if Error is Zero and Var_Error is N_Medium and Pressure is Medium
then Var_Cooling is P_Small;
if Error is Zero and Var_Error is N_Small and Pressure is Medium
then Var_Heater is N_Small;
if Error is Zero and Var_Error is N_Small and Pressure is Medium
then Var_Cooling is Zero;
if Error is Zero and Var_Error is N_Large and Pressure is Small
then Var_Heater is N_Small;
if Error is Zero and Var_Error is N_Large and Pressure is Small
then Var_Cooling is P_Medium;
if Error is Zero and Var_Error is N_Medium and Pressure is Small
then Var_Heater is Zero;
if Error is Zero and Var_Error is N_Medium and Pressure is Small
then Var_Cooling is P_Small;
if Error is Zero and Var_Error is N_Small and Pressure is Small
then Var_Heater is Zero;
if Error is Zero and Var_Error is N_Small and Pressure is Small
then Var_Cooling is Zero;
if Error is N_Small and Var_Error is N_Large and Pressure is Large
then Var_Heater is N_Large;
if Error is N_Small and Var_Error is N_Large and Pressure is Large
then Var_Cooling is P_Large;
if Error is N_Small and Var_Error is N_Medium and Pressure is Large
then Var_Heater is N_Medium;
if Error is N_Small and Var_Error is N_Medium and Pressure is Large
then Var_Cooling is P_Medium;
if Error is N_Small and Var_Error is N_Small and Pressure is Large
then Var_Heater is N_Small;
if Error is N_Small and Var_Error is N_Small and Pressure is Large
then Var_Cooling is P_Medium;
if Error is N_Small and Var_Error is N_Large and Pressure is Medium
then Var_Heater is N_Large;
if Error is N_Small and Var_Error is N_Large and Pressure is Medium
then Var_Cooling is P_Medium;
if Error is N_Small and Var_Error is N_Medium and Pressure is Medium
then Var_Heater is N_Medium;
if Error is N_Small and Var_Error is N_Medium and Pressure is Medium
then Var_Cooling is P_Small;
if Error is N_Small and Var_Error is N_Small and Pressure is Medium
then Var_Heater is N_Small;
if Error is N_Small and Var_Error is N_Small and Pressure is Medium
then Var_Cooling is P_Small;
if Error is N_Small and Var_Error is N_Large and Pressure is Small
then Var_Heater is N_Medium;
if Error is N_Small and Var_Error is N_Large and Pressure is Small
then Var_Cooling is P_Medium;
if Error is N_Small and Var_Error is N_Medium and Pressure is Small
then Var_Heater is N_Small;
if Error is N_Small and Var_Error is N_Medium and Pressure is Small
then Var_Cooling is P_Small;
if Error is N_Small and Var_Error is N_Small and Pressure is Small
then Var_Heater is Zero;
if Error is N_Small and Var_Error is N_Small and Pressure is Small
then Var_Cooling is P_Small;
if Error is N_Medium and Var_Error is N_Large and Pressure is Large
then Var_Heater is N_Large;
if Error is N_Medium and Var_Error is N_Large and Pressure is Large
then Var_Cooling is P_Large;
if Error is N_Medium and Var_Error is N_Medium and Pressure is Large
then Var_Heater is N_Large;
if Error is N_Medium and Var_Error is N_Medium and Pressure is Large
then Var_Cooling is P_Large;
if Error is N_Medium and Var_Error is N_Small and Pressure is Large
then Var_Heater is N_Large;
if Error is N_Medium and Var_Error is N_Small and Pressure is Large
then Var_Cooling is P_Medium;
if Error is N_Medium and Var_Error is N_Large and Pressure is Medium
then Var_Heater is N_Large;
if Error is N_Medium and Var_Error is N_Large and Pressure is Medium
then Var_Cooling is P_Large;
if Error is N_Medium and Var_Error is N_Medium and Pressure is Medium
then Var_Heater is N_Large;
if Error is N_Medium and Var_Error is N_Medium and Pressure is Medium
then Var_Cooling is P_Medium;
if Error is N_Medium and Var_Error is N_Small and Pressure is Medium
then Var_Heater is N_Medium;
if Error is N_Medium and Var_Error is N_Small and Pressure is Medium
then Var_Cooling is P_Medium;
if Error is N_Medium and Var_Error is N_Large and Pressure is Small
then Var_Heater is N_Medium;
if Error is N_Medium and Var_Error is N_Large and Pressure is Small
then Var_Cooling is P_Large;
if Error is N_Medium and Var_Error is N_Medium and Pressure is Small
then Var_Heater is N_Medium;
if Error is N_Medium and Var_Error is N_Medium and Pressure is Small
then Var_Cooling is P_Medium;
if Error is N_Medium and Var_Error is N_Small and Pressure is Small
then Var_Heater is N_Small;
if Error is N_Medium and Var_Error is N_Small and Pressure is Small
then Var_Cooling is P_Medium;
if Error is N_Large and Var_Error is N_Large and Pressure is Large
then Var_Heater is N_Large;
if Error is N_Large and Var_Error is N_Large and Pressure is Large
then Var_Cooling is P_Large;
if Error is N_Large and Var_Error is N_Medium and Pressure is Large
then Var_Heater is N_Large;
if Error is N_Large and Var_Error is N_Medium and Pressure is Large
then Var_Cooling is P_Large;
if Error is N_Large and Var_Error is N_Small and Pressure is Large
then Var_Heater is N_Large;
if Error is N_Large and Var_Error is N_Small and Pressure is Large
then Var_Cooling is P_Large;
if Error is N_Large and Var_Error is N_Large and Pressure is Medium
then Var_Heater is N_Large;
if Error is N_Large and Var_Error is N_Large and Pressure is Medium
then Var_Cooling is P_Large;
if Error is N_Large and Var_Error is N_Medium and Pressure is Medium
then Var_Heater is N_Large;
if Error is N_Large and Var_Error is N_Medium and Pressure is Medium
then Var_Cooling is P_Large;
if Error is N_Large and Var_Error is N_Small and Pressure is Medium
then Var_Heater is N_Large;
if Error is N_Large and Var_Error is N_Small and Pressure is Medium
then Var_Cooling is P_Large;
if Error is N_Large and Var_Error is N_Large and Pressure is Small
then Var_Heater is N_Medium;
if Error is N_Large and Var_Error is N_Large and Pressure is Small
then Var_Cooling is P_Large;
if Error is N_Large and Var_Error is N_Medium and Pressure is Small
then Var_Heater is N_Medium;
if Error is N_Large and Var_Error is N_Medium and Pressure is Small
then Var_Cooling is P_Large;
if Error is N_Large and Var_Error is N_Small and Pressure is Small
then Var_Heater is N_Medium;
if Error is N_Large and Var_Error is N_Small and Pressure is Small
then Var_Cooling is P_Large;
if Error is N_Large and Var_Error is P_Large and Pressure is Large
then Var_Heater is N_Medium;
if Error is N_Large and Var_Error is P_Large and Pressure is Large
then Var_Cooling is P_Small;
if Error is N_Large and Var_Error is P_Medium and Pressure is Large
then Var_Heater is N_Large;
if Error is N_Large and Var_Error is P_Medium and Pressure is Large
then Var_Cooling is P_Medium;
if Error is N_Large and Var_Error is P_Small and Pressure is Large
then Var_Heater is N_Large;
if Error is N_Large and Var_Error is P_Small and Pressure is Large
then Var_Cooling is P_Large;
if Error is N_Large and Var_Error is P_Large and Pressure is Medium
then Var_Heater is N_Small;
if Error is N_Large and Var_Error is P_Large and Pressure is Medium
then Var_Cooling is P_Small;
if Error is N_Large and Var_Error is P_Medium and Pressure is Medium
then Var_Heater is N_Medium;
if Error is N_Large and Var_Error is P_Medium and Pressure is Medium
then Var_Cooling is P_Medium;
if Error is N_Large and Var_Error is P_Small and Pressure is Medium
then Var_Heater is N_Large;
if Error is N_Large and Var_Error is P_Small and Pressure is Medium
then Var_Cooling is P_Large;
if Error is N_Large and Var_Error is P_Large and Pressure is Small
then Var_Heater is Zero;
if Error is N_Large and Var_Error is P_Large and Pressure is Small
then Var_Cooling is P_Small;
if Error is N_Large and Var_Error is P_Medium and Pressure is Small
then Var_Heater is N_Small;
if Error is N_Large and Var_Error is P_Medium and Pressure is Small
then Var_Cooling is P_Medium;
if Error is N_Large and Var_Error is P_Small and Pressure is Small
then Var_Heater is N_Medium;
if Error is N_Large and Var_Error is P__Small and Pressure is Small
then Var_Cooling is P_Large;
if Error is N_Medium and Var_Error is P_Large and Pressure is Large
then Var_Heater is N_Medium;
if Error is N_Medium and Var_Error is P_Large and Pressure is Large
then Var_Cooling is Zero;
if Error is N_Medium and Var_Error is P_Medium and Pressure is Large
then Var_Heater is N_Large;
if Error is N_Medium and Var_Error is P_Medium and Pressure is Large
then Var_Cooling is Zero;
if Error is N_Medium and Var_Error is P_Small and Pressure is Large
then Var_Heater is N_Large;
if Error is N_Medium and Var_Error is P_Small and Pressure is Large
then Var_Cooling is P_Small;
if Error is N_Medium and Var_Error is P_Large and Pressure is Medium
then Var_Heater is N_Small;
if Error is N_Medium and Var_Error is P_Large and Pressure is Medium
then Var_Cooling is Zero;
if Error is N_Medium and Var_Error is P_Medium and Pressure is Medium
then Var_Heater is N_Medium;
if Error is N_Medium and Var_Error is P_Medium and Pressure is Medium
then Var_Cooling is Zero;
if Error is N_Medium and Var_Error is P_Small and Pressure is Medium
then Var_Heater is N_Medium;
if Error is N_Medium and Var_Error is P_Small and Pressure is Medium
then Var_Cooling is P_Small;
if Error is N_Medium and Var_Error is P_Large and Pressure is Small
then Var_Heater is Zero;
if Error is N_Medium and Var_Error is P_Large and Pressure is Small
then Var_Cooling is Zero;
if Error is N_Medium and Var_Error is P_Medium and Pressure is Small
then Var_Heater is N_Small;
if Error is N_Medium and Var_Error is P_Medium and Pressure is Small
then Var_Cooling is Zero;
if Error is N_Medium and Var_Error is P_Small and Pressure is Small
then Var_Heater is N_Small;
if Error is N_Medium and Var_Error is P_Small and Pressure is Small
then Var_Cooling is P_Small;
if Error is N_Small and Var_Error is P_Large and Pressure is Large
then Var_Heater is Zero;
if Error is N_Small and Var_Error is P_Large and Pressure is Large
then Var_Cooling is Zero;
if Error is N_Small and Var_Error is P_Medium and Pressure is Large
then Var_Heater is N_Small;
if Error is N_Small and Var_Error is P_Medium and Pressure is Large
then Var_Cooling is Zero;
if Error is N_Small and Var_Error is P_Small and Pressure is Large
then Var_Heater is N_Medium;
if Error is N_Small and Var_Error is P_Small and Pressure is Large
then Var_Cooling is Zero;
if Error is N_Small and Var_Error is P_Large and Pressure is Medium
then Var_Heater is P_Small;
if Error is N_Small and Var_Error is P_Large and Pressure is Medium
then Var_Cooling is Zero;
if Error is N_Small and Var_Error is P_Medium and Pressure is Medium
then Var_Heater is Zero;
if Error is N_Small and Var_Error is P_Medium and Pressure is Medium
then Var_Cooling is Zero;
if Error is N_Small and Var_Error is P_Small and Pressure is Medium
then Var_Heater is N_Small;
if Error is N_Small and Var_Error is P_Small and Pressure is Medium
then Var_Cooling is Zero;
if Error is N_Small and Var_Error is P_Large and Pressure is Small
then Var_Heater is P_Medium;
if Error is N_Small and Var_Error is P_Large and Pressure is Small
then Var_Cooling is Zero;
if Error is N_Small and Var_Error is P_Medium and Pressure is Small
then Var_Heater is P_Small;
if Error is N_Small and Var_Error is P_Medium and Pressure is Small
then Var_Cooling is Zero;
if Error is N_Small and Var_Error is P_Small and Pressure is Small
then Var_Heater is Zero;
if Error is N_Small and Var_Error is P_Small and Pressure is Small
then Var_Cooling is Zero;
if Error is Zero and Var_Error is P_Large and Pressure is Large
then Var_Heater is P_Medium;
if Error is Zero and Var_Error is P_Large and Pressure is Large
then Var_Cooling is N_Small;
if Error is Zero and Var_Error is P_Medium and Pressure is Large
then Var_Heater is P_Small;
if Error is Zero and Var_Error is P_Medium and Pressure is Large
then Var_Cooling is N_Small;
if Error is Zero and Var_Error is P_Small and Pressure is Large
then Var_Heater is Zero;
if Error is Zero and Var_Error is P_Small and Pressure is Large
then Var_Cooling is N_Small;
if Error is Zero and Var_Error is P_Large and Pressure is Medium
then Var_Heater is P_Large;
if Error is Zero and Var_Error is P_Large and Pressure is Medium
then Var_Cooling is N_Small;
if Error is Zero and Var_Error is P_Medium and Pressure is Medium
then Var_Heater is P_Medium;
if Error is Zero and Var_Error is P_Medium and Pressure is Medium
then Var_Cooling is N_Small;
if Error is Zero and Var_Error is P_Small and Pressure is Medium
then Var_Heater is P_Small;
if Error is Zero and Var_Error is P_Small and Pressure is Medium
then Var_Cooling is N_Small;
if Error is Zero and Var_Error is P_Large and Pressure is Small
then Var_Heater is P_Large;
if Error is Zero and Var_Error is P_Large and Pressure is Small
then Var_Cooling is N_Medium;
if Error is Zero and Var_Error is P_Medium and Pressure is Small
then Var_Heater is P_Large;
if Error is Zero and Var_Error is P_Medium and Pressure is Small
then Var_Cooling is N_Small;
if Error is Zero and Var_Error is P_Small and Pressure is Small
then Var_Heater is P_Medium;
if Error is Zero and Var_Error is P_Small and Pressure is Small
then Var_Cooling is N_Small;
if Error is P_Small and Var_Error is P_Large and Pressure is Large
then Var_Heater is P_Medium;
if Error is P_Small and Var_Error is P_Large and Pressure is Large
then Var_Cooling is N_Medium;
if Error is P_Small and Var_Error is P_Medium and Pressure is Large
then Var_Heater is P_Small;
if Error is P_Small and Var_Error is P_Medium and Pressure is Large
then Var_Cooling is N_Medium;
if Error is P_Small and Var_Error is P_Small and Pressure is Large
then Var_Heater is P_Small;
if Error is P_Small and Var_Error is P_Small and Pressure is Large
then Var_Cooling is N_Small;
if Error is P_Small and Var_Error is P_Large and Pressure is Medium
then Var_Heater is P_Large;
if Error is P_Small and Var_Error is P_Large and Pressure is Medium
then Var_Cooling is N_Medium;
if Error is P_Small and Var_Error is P_Medium and Pressure is Medium
then Var_Heater is P_Medium;
if Error is P_Small and Var_Error is P_Medium and Pressure is Medium
then Var_Cooling is N_Medium;
if Error is P_Small and Var_Error is P_Small and Pressure is Medium
then Var_Heater is P_Medium;
if Error is P_Small and Var_Error is P_Small and Pressure is Medium
then Var_Cooling is N_Small;
if Error is P_Small and Var_Error is P_Large and Pressure is Small
then Var_Heater is P_Large;
if Error is P_Small and Var_Error is P_Large and Pressure is Small
then Var_Cooling is N_Large;
if Error is P_Small and Var_Error is P_Medium and Pressure is Small
then Var_Heater is P_Large;
if Error is P_Small and Var_Error is P_Medium and Pressure is Small
then Var_Cooling is N_Medium;
if Error is P_Small and Var_Error is P_Small and Pressure is Small
then Var_Heater is P_Large;
if Error is P_Small and Var_Error is P_Small and Pressure is Small
then Var_Cooling is N_Small;
if Error is P_Medium and Var_Error is P_Large and Pressure is Large
then Var_Heater is P_Medium;
if Error is P_Medium and Var_Error is P_Large and Pressure is Large
then Var_Cooling is N_Large;
if Error is P_Medium and Var_Error is P_Medium and Pressure is Large
then Var_Heater is P_Medium;
if Error is P_Medium and Var_Error is P_Medium and Pressure is Large
then Var_Cooling is N_Medium;
if Error is P_Medium and Var_Error is P_Small and Pressure is Large
then Var_Heater is P_Small;
if Error is P_Medium and Var_Error is P_Small and Pressure is Large
then Var_Cooling is N_Medium;
if Error is P_Medium and Var_Error is P_Large and Pressure is Medium
then Var_Heater is P_Large;
if Error is P_Medium and Var_Error is P_Large and Pressure is Medium
then Var_Cooling is N_Large;
if Error is P_Medium and Var_Error is P_Medium and Pressure is Medium
then Var_Heater is P_Large;
if Error is P_Medium and Var_Error is P_Medium and Pressure is Medium
then Var_Cooling is N_Medium;
if Error is P_Medium and Var_Error is P_Small and Pressure is Medium
then Var_Heater is P_Medium;
if Error is P_Medium and Var_Error is P_Small and Pressure is Medium
then Var_Cooling is N_Medium;
if Error is P_Medium and Var_Error is P_Large and Pressure is Small
then Var_Heater is P_Large;
if Error is P_Medium and Var_Error is P_Large and Pressure is Small
then Var_Cooling is N_Large;
if Error is P_Medium and Var_Error is P_Medium and Pressure is Small
then Var_Heater is P_Large;
if Error is P_Medium and Var_Error is P_Medium and Pressure is Small
then Var_Cooling is N_Large;
if Error is P_Medium and Var_Error is P_Small and Pressure is Small
then Var_Heater is P_Large;
if Error is P_Medium and Var_Error is P_Small and Pressure is Small
then Var_Cooling is N_Medium;
if Error is P_Large and Var_Error is P_Large and Pressure is Large
then Var_Heater is P_Medium;
if Error is P_Large and Var_Error is P_Large and Pressure is Large
then Var_Cooling is N_Large;
if Error is P_Large and Var_Error is P_Medium and Pressure is Large
then Var_Heater is P_Medium;
if Error is P_Large and Var_Error is P_Medium and Pressure is Large
then Var_Cooling is N_Large;
if Error is P_Large and Var_Error is P_Small and Pressure is Large
then Var_Heater is P_Medium;
if Error is P_Large and Var_Error is P_Small and Pressure is Large
then Var_Cooling is N_Large;
if Error is P_Large and Var_Error is P_Large and Pressure is Medium
then Var_Heater is P_Large;
if Error is P_Large and Var_Error is P_Large and Pressure is Medium
then Var_Cooling is N_Large;
if Error is P_Large and Var_Error is P_Medium and Pressure is Medium
then Var_Heater is P_Large;
if Error is P_Large and Var_Error is P_Medium and Pressure is Medium
then Var_Cooling is N_Large;
if Error is P_Large and Var_Error is P_Small and Pressure is Medium
then Var_Heater is P_Large;
if Error is P_Large and Var_Error is P_Small and Pressure is Medium
then Var_Cooling is N_Large;
if Error is P_Large and Var_Error is P_Large and Pressure is Small
then Var_Heater is P_Large;
if Error is P_Large and Var_Error is P_Large and Pressure is Small
then Var_Cooling is N_Large;
if Error is P_Large and Var_Error is P_Medium and Pressure is Small
then Var_Heater is P_Large;
if Error is P_Large and Var_Error is P_Medium and Pressure is Small
then Var_Cooling is N_Large;
if Error is P_Large and Var_Error is P_Small and Pressure is Small
then Var_Heater is P_Large;
if Error is P_Large and Var_Error is P_Small and Pressure is Small
then Var_Cooling is N_Large
end
Input/Output Response
FIDE provides several powerful debugging and analyzing tools for
system development. Figure 6, 7, 8 show input/output response
surfaces of the controller defined above, which are obtained by
Analyzer in FIDE.
The output in these three figures is Var_Heater. Figure 6 gives
the result when pressure is 0.00; Figure 7 when 0.50 and Figure 8
when 1.00. We can see that the output Var_Heater becomes larger
when pressure gets smaller. This is what we want because lower
pressure results in lower temperature so larger heater output is
needed.
Figure 9 shows input/output response surface of Var_Cooling. Note
that surface in Figure 9 is opposite to that in Figure 7.
Figure 6 Input/Output Surface of Var_Heater when
Pressure=0.00(Small)
Figure 7 Input/Output Surface of Var_Heater when
Pressure=0.50(Medium)
Figure 8 Input/Output Surface of Var_Heater when
Pressure=1.00(Large)
Figure 9 Input/Output Surface of Var_Cooling when
Pressure=0.50(Medium)
COMMENTS
In a fuzzy logic based control system, we can take many factors
into account when creating the controller, some of these factors
are considered to be noises in a conventional control system and
make controller design a very hard work. Using fuzzy logic, it is
much easier to design a controller with better performance in
this kind of situation.
(Weijing Zhang, Applications Engineer, Aptronix Inc.)
For Further Information Please Contact:
Aptronix Incorporated
2150 North First Street #300
San Jose, CA 95131
Tel (408) 428-1888
Fax (408) 428-1884
FuzzyNet (408) 428-1883 data 8/N/1
Aptronix Company Overview
Headquartered in San Jose, California, Aptronix develops and
markets fuzzy logic-based software, systems and development tools
for a complete range of commercial applications. The company was
founded in 1989 and has been responsible for a number of
important innovations in fuzzy technology.
Aptronix's product Fide (Fuzzy Inference Development Environment)
-- is a complete environment for the development of fuzzy
logic-based systems. Fide provides system engineers with the
most effective fuzzy tools in the industry and runs in
MS-WindowsTM on 386/486 hardware. The price for Fide is $1495
and can be ordered from any authorized Motorola distributor. For
a list of authorized distributors or more information, please
call Aptronix. The software package comes with complete
documentation on how to develop fuzzy logic based
applications, free telephone support for 90 days and access
to the Aptronix FuzzyNet information exchange.
FIDE Application Notes Available:
#001
Washing Machine
Decision Making, Determining Wash Time
#002
Automatic Focusing System
Decision Making, Determining Focus
#003
Servo Motor Force Control
Servo Control, Grasping Object
#004
Temperature Control(1)
Process Control, Glass Melting Furnace
#005
Temperature Control(2)
Process Control, Air Conditioner
#006
Temperature Control(3)
Process Control, Reactor
FIDE Application Note 006-920914 Aptronix Inc., 1992
Temperature Control (3)
programming/FUZZYLOGIC/temp_cnt.pro
+348
View File
@@ -0,0 +1,348 @@
INTRODUCTION
Temperature control is widely used in various processes. These
processes, no matter if it is in a large industrial plant, or in
a home appliance, share several unfavorable features. These
include non-linearity, interference, dead time, and external
disturbances, among others. Conventional approaches usually do
not result in satisfactory temperature control.
In this Application Note we provide examples of fuzzy logic used
to control temperature in several different situations. These
examples are developed using FIDE, an integrated fuzzy inference
development environment.
FUZZY CONTROL IN A GLASS MELTING FURNACE
A glass melting furnace has two rooms, a melter and a refiner.
Raw materials are melted into glass at high temperature in the
melter. The temperature of the melted glass is adjusted to a
suitable temperature for the glass forming process to follow. It
takes a long time to change the temperature in the furnace, which
is an example of dead-time in this process. The flow of melted
glass is not uniform, especially at the bottom of the furnace. In
addition to temperature, other factors also contribute to the
thermal characteristics of melted glass. Raw material mixing
procedure, glass color, and the amount of the glass are some of
the factors. Because there are many variables and the procedure
complex, it is very difficult to design an effective temperature
controller for this application using conventional control
approaches.
Control Objective
Control temperature in a dead time process such as in a glass
melting furnace.
Fuzzy Control System
The control block diagram for a glass melting furnace is shown in
Figure 1. Control value u is applied to the
process to adjust the temperature. This value is changed by two
compensators. The variation of u can be written
as u = ud + ue where ud is the output of
the dead time compensator, and ue is the output
of the error compensator. The dead time compensator is used to
reduce the effect dead time has on the process. Its output
(ud), an incremental change in control value, is
derived from the change in the current and previous control value
(u) and the time differential of output
temperature (y). The error compensator is used
to reduce the difference between the desired temperature and the
actual temperture of hte furnace. Its outpu (ue), also an
incremental change in control value, is inferred from the
difference(error) e and its time differential ‚. ud and ue are
combined to change the control value u.
Input/Output Variables of the Dead Time Compensator
Labels and membership functions of input/output variables of the
dead time compensator are shown in Figure 2a, 2b, 2c. The
membership functions can be created by using the MF editor in
FIDE.
FIU Source Code for the Dead Time Compensator
The following is the source code for the dead time compensator
written in FIL, the fuzzy inference language provided in FIDE.
$ FILENAME: temp/temp1_dt.fil
$ DATE: 08/31/1992
$ UPDATE: 09/02/1992
$ Temperature Controller : Part 1 : dead time compensator
$ Two inputs, one output
$ INPUT(S): Prev(ious)_Var(iationOf)_Ctrl, TimeDiff(erentialOf)_Output
$ OUTPUT(S): Var(iationOf)_Ctrl
$ FIU HEADER
fiu tvfi (min max) *8;
$ DEFINITION OF INPUT VARIABLE(S)
invar Prev_Var_Ctrl " " : -1 () 1 [
P_Large (@0.45, 0, @0.75, 1, @1.00, 1),
P_Medium (@0.15, 0, @0.45, 1, @0.75, 0),
P_Small (@-0.15, 0, @0.15, 1, @0.45, 0),
N_Small (@-0.45, 0, @-0.15, 1, @0.15, 0),
N_Medium (@-0.75, 0, @-0.45, 1, @-0.15, 0),
N_Large (@-1.00, 1, @-0.75, 1, @-0.45, 0)
];
invar TimeDiff_Output " " : -90 () 90 [
P_Large (@20, 0, @60, 1, @90, 1),
P_Small (@-20, 0, @20, 1, @60, 0),
N_Small (@-60, 0, @-20, 1, @20, 0),
N_Large (@-90, 1, @-60, 1, @-20, 0)
];
$ DEFINITION OF OUTPUT VARIABLE(S)
outvar Var_Ctrl " " : -1 () 1 * (
P_Large = 0.80,
P_Medium = 0.40,
P_Small = 0.20,
Zero = 0.00,
N_Small = -0.20,
N_Medium = -0.40,
N_Large = -0.80
);
$ RULES
if Prev_Var_Ctrl is P_Large and TimeDiff_Output is P_Large then
Var_Ctrl is N_Large;
if Prev_Var_Ctrl is P_Large and TimeDiff_Output is P_Small then
Var_Ctrl is N_Medium;
if Prev_Var_Ctrl is P_Large and TimeDiff_Output is N_Small then
Var_Ctrl is N_Small;
if Prev_Var_Ctrl is P_Large and TimeDiff_Output is N_Large then
Var_Ctrl is Zero;
if Prev_Var_Ctrl is P_Medium and TimeDiff_Output is P_Large then
Var_Ctrl is N_Medium;
if Prev_Var_Ctrl is P_Medium and TimeDiff_Output is P_Small then
Var_Ctrl is N_Small;
if Prev_Var_Ctrl is P_Medium and TimeDiff_Output is N_Small then
Var_Ctrl is Zero;
if Prev_Var_Ctrl is P_Medium and TimeDiff_Output is N_Large then
Var_Ctrl is Zero;
if Prev_Var_Ctrl is P_Small and TimeDiff_Output is P_Large then
Var_Ctrl is N_Small;
if Prev_Var_Ctrl is P_Small and TimeDiff_Output is P_Small then
Var_Ctrl is Zero;
if Prev_Var_Ctrl is P_Small and TimeDiff_Output is N_Small then
Var_Ctrl is Zero;
if Prev_Var_Ctrl is P_Small and TimeDiff_Output is N_Large then
Var_Ctrl is Zero;
if Prev_Var_Ctrl is N_Small and TimeDiff_Output is P_Large then
Var_Ctrl is Zero;
if Prev_Var_Ctrl is N_Small and TimeDiff_Output is P_Small then
Var_Ctrl is Zero;
if Prev_Var_Ctrl is N_Small and TimeDiff_Output is N_Small then
Var_Ctrl is Zero;
if Prev_Var_Ctrl is N_Small and TimeDiff_Output is N_Large then
Var_Ctrl is P_Small;
if Prev_Var_Ctrl is N_Medium and TimeDiff_Output is P_Large then
Var_Ctrl is Zero;
if Prev_Var_Ctrl is N_Medium and TimeDiff_Output is P_Small then
Var_Ctrl is Zero;
if Prev_Var_Ctrl is N_Medium and TimeDiff_Output is N_Small then
Var_Ctrl is P_Small;
if Prev_Var_Ctrl is N_Medium and TimeDiff_Output is N_Large then
Var_Ctrl is P_Medium;
if Prev_Var_Ctrl is N_Large and TimeDiff_Output is P_Large then
Var_Ctrl is Zero;
if Prev_Var_Ctrl is N_Large and TimeDiff_Output is P_Small then
Var_Ctrl is P_Small;
if Prev_Var_Ctrl is N_Large and TimeDiff_Output is N_Small then
Var_Ctrl is P_Medium;
if Prev_Var_Ctrl is N_Large and TimeDiff_Output is N_Large then
Var_Ctrl is P_Large
end
Input/Output Response of the Dead Time Compensator
Figure 3 shows the response surface of the dead time compensator.
This surface can be obtained by using the Analyzer tool provided
in FIDE.
Input/Output Variables of the Error Compensator
Labels and membership functions of input/output variables of the
Error Compensator are shown in Figure 4a, 4b, 4c.
FIU Source Code of Error Compensator
$ FILENAME: temp/temp1_er.fil
$ DATE: 09/02/1992
$ UPDATE: 09/03/1992
$ Temperature Controller : Part 2 : error compensator
$ Two inputs, one output
$ INPUT(S): Error, TimeDiff(erentialOf)_Error
$ OUTPUT(S): Var(iationOf)_Ctrl
$ FIU HEADER
fiu tvfi (min max) *8;
$ DEFINITION OF INPUT VARIABLE(S)
invar Error " " : -100 () 100 [
P_Large (@50, 0, @80, 1, @100, 1),
P_Medium (@20, 0, @50, 1, @80, 0),
P_Small (@0, 0, @20, 1, @50, 0),
Zero (@-20, 0, @0, 1, @20, 0),
N_Small (@-50, 0, @-20, 1, @0, 0),
N_Medium (@-80, 0, @-50, 1, @-20, 0),
N_Large (@-100,1, @-80, 1, @-50, 0)
];
invar TimeDiff_Error " " : -90 () 90 [
P_Large (@50, 0, @70, 1, @90, 1),
P_Medium (@30, 0, @50, 1, @70, 0),
P_Small (@0, 0, @30, 1, @50, 0),
Zero (@-30, 0, @0, 1, @30, 0),
N_Small (@-50, 0, @-30, 1, @0, 0),
N_Medium (@-70, 0, @-50, 1, @-30, 0),
N_Large (@-90, 1, @-70, 1, @-50, 0)
];
$ DEFINITION OF OUTPUT VARIABLE(S)
outvar Var_Ctrl " " : -1 () 1 * (
P_Large = 0.80,
P_Medium = 0.40,
P_Small = 0.20,
Zero = 0.00,
N_Small = -0.20,
N_Medium = -0.40,
N_Large = -0.80
);
$ RULES
if Error is Zero and TimeDiff_Error is P_Large then Var_Ctrl is
P_Large;
if Error is Zero and TimeDiff_Error is P_Medium then Var_Ctrl is
P_Medium;
if Error is Zero and TimeDiff_Error is P_Small then Var_Ctrl is
Zero;
if Error is Zero and TimeDiff_Error is Zero then Var_Ctrl is
Zero;
if Error is Zero and TimeDiff_Error is N_Small then Var_Ctrl is
Zero;
if Error is Zero and TimeDiff_Error is N_Medium then Var_Ctrl is
N_Medium;
if Error is Zero and TimeDiff_Error is N_Large then Var_Ctrl is
N_Large;
if Error is P_Large and TimeDiff_Error is Zero then Var_Ctrl is
P_Large;
if Error is P_Medium and TimeDiff_Error is Zero then Var_Ctrl is
P_Medium;
if Error is P_Small and TimeDiff_Error is Zero then Var_Ctrl is
Zero;
if Error is N_Small and TimeDiff_Error is Zero then Var_Ctrl is
Zero;
if Error is N_Medium and TimeDiff_Error is Zero then Var_Ctrl is
N_Medium;
if Error is N_Large and TimeDiff_Error is Zero then Var_Ctrl is
N_Large;
if Error is P_Medium and TimeDiff_Error is P_Medium then Var_Ctrl is
P_Large;
if Error is P_Small and TimeDiff_Error is P_Small then Var_Ctrl is
Zero;
if Error is P_Medium and TimeDiff_Error is N_Medium then Var_Ctrl is
Zero;
if Error is P_Small and TimeDiff_Error is N_Large then Var_Ctrl is
N_Medium;
if Error is N_Small and TimeDiff_Error is P_Large then Var_Ctrl is
P_Medium;
if Error is N_Medium and TimeDiff_Error is P_Medium then Var_Ctrl is
Zero;
if Error is N_Small and TimeDiff_Error is N_Small then Var_Ctrl is
Zero;
if Error is N_Medium and TimeDiff_Error is N_Medium then Var_Ctrl is
N_Large
end
Input/Output Response of Error Compensator
Figure 5 shows the response surface of the error compensator.
COMMENTS
Temperature control systems, using fuzzy controllers as shown
above, have been put into operation and provide performance
better than conventional control systems. Fuzzy controllers also
show robust response in the handling of dead time behavior in the
process.
(Weijing Zhang, Applications Engineer, Aptronix Inc.)
For Further Information Please Contact:
Aptronix Incorporated
2150 North First Street #300
San Jose, CA 95131
Tel (408) 428-1888
Fax (408) 428-1884
FuzzyNet (408) 428-1883 data 8/N/1
Aptronix Company Overview
Headquartered in San Jose, California, Aptronix develops and
markets fuzzy logic-based software, systems and development
tools for a complete range of commercial applications. The
company was founded in 1989 and has been responsible for a
number of important innovations in fuzzy technology.
Aptronix's product Fide (Fuzzy Inference Development
Environment) -- is a complete environment for the development of
fuzzy logic-based systems. Fide provides system engineers with
the most effective fuzzy tools in the industry and runs in
MS-Windows(TM) on 386/486 hardware. The price for Fide is $1495 and
can be ordered from any authorized Motorola distributor. For a
list of authorized distributors or more information, please
call Aptronix. The software package comes with complete
documentation on how to develop fuzzy logic based applications,
free telephone support for 90 days and access to the Aptronix
FuzzyNet information exchange.
Temperature Control
FIDE Application Note 004-080992
Aptronix Inc., 1992