The Ultimate Fuzzy
Inference Development Environment
How to use FIDE in my
Application
------ Step-by-step Graphical Illustrations of Fide
To take advantage of the benefits of
incorporating an integrated tool suite into Fuzzy Logic, Fide
is designed to fully implement the methodology described previously. Different tools in
Fide support alternative designs, invoked from menus organized similar to the step-by-step
design flow in a left-to-right fashion, to develop a fuzzy controller (Figure
10). Thus, Fide serves as your guide for the design flow allowing you to develop your
system in three simple steps (see figure below):
- Model
a System using Membership Editor & Rule Matrix Edior
- Debugging
Tools -- Tracer, Analyzer, Simulator
- Generate Object
Code for Target Platforms with a Button Push
- System-level Design Capability
- Interface with Costumer Programs
via the CAD Cmposer
All the different tools incorporated in Fide are
very easy to learn and use, because they can be invoked through the consistent look and
feel of the MS-Windows environment.
The FIL text Editor allows you to
describe the controller's behavior in a language called Fuzzy Inference Language. FIL is simple because it is a
non-sequential language with English-like statements. The Compiler translates the FIL source into the internal
Aptronix data structure which supports Fide's high level debugging capabilities. The
MF-Editor is an easy-to-use graphical tool which allows you to create and modify different
shapes for the membership functions.
Conventional debugging environments are limited
because they target the software algorithm rather than the application. Fide exploits the
non-linear nature of fuzzy logic by including three unique debugging and analysis
capabilities which target the application. These easy-to-use tools called the tracer, the analyzer, and the simulator enable you to perform both low and high level debugging by
providing a seamless path to the source for instantaneous bug isolation and code
modification.
The code
generation is a fully automatic step where Fide outputs assembly code for variety of
microcontrollers. Fide also supports ANSI C code and MatLab M file code.
With Fide you can develop your design in three
simple steps:
Step #1: Describe the Problem with Rules and Membership Functions
You can describe your controller using Aptronix's
FIL, by entering text in the editor tool. With FIL you can specify the input/output
variables, the membership functions associated with them, and the rules describing the
controller's operation. Furthermore, FIL allows you to use different operators, inference
and defuzzification methods, as well as selection of number of bits for the target
microcontroller.
In addition to FIL, you can create or modify your
membership functions describing the input and output ranges using Fide's MF-Editor
graphical tool. This tool supports simple triangular shapes, or more complex ones if
desired. It includes capabilities to add delete, modify individual points, or .
automatically write the membership functions back into FIL, if desired. Rule Matrax Editor
provides a convenient, spreadsheet-like evironment for the constrction of fuzzy rules.
Once you finish, you can compile the FIL to translate the source into the Aptronix
internal data structures.
Step #2: Debug
and tune the controller
Conventional tools incorporate debugging aids such
as breakpoints, single stepping, etc. because these exploit the sequential nature of the
code executed. Fide's debugging tools are designed to take advantage of the facts that
fuzzy rules are execute in parallel. Fide provides an elegant way to tune your controller
by examining and analyzing its behavior from multiple perspectives via three powerful
debug tools, the tracer, the analyzer, and
the simulator:
Tracer
One of the inherent characteristics of Fuzzy
Inference is that the process is transparent, that is, we can easily trace an output back
to the specific input that caused it. Fide's tracer takes advantage
of this by providing an on-line capability to trace step by step through the Fuzzy
Inference Process, all the way to the source. For example, you can plug a number in an
input and observe the resulting output value. If an undesired result occurs, you can
easily identify the source of the problem by stepping backwards from the output all the
way to a specific rule which had the largest contribution for the result. Then you can
modify some of the membership functions, and re-trace without having to re-compile the FIL code.
System Performance by the
Analyzer (Display 3-D Transfer Function)
The analyzer displays a
global view of the transfer function response. Here, the input/output relationships are
displayed in a three dimensional surface. Advanced, interactive graphics let you check the
function in detail, examine the surface from a variety of perspectives, and isolate any
undesired response by means of movable arrows. Aptronix has made an important advancement
in debugging technology by providing a hot link between the analyzer and the tracer. This
allows you to trace back any problems shown in the 3-D surface directly into the rule that
may have contributed to them.
Run Simulations with
Controlled Inputs via the Simulator
The simulator allows you to
observe the dynamic behavior of your controller. The input to the simulator is a file
which contains a set of values to be applied at the controller's inputs. Then you can run
the simulator to display the output curve generated from each input value applied. A
movable vertical axis allows you to examine the input and output values at any data step.
The simulator also uses the hot link to the tracer which provides
a superior debugging capability by allowing you to isolate undesirable controller behavior
all the way to the source.
Step #3 -- Generate
Real-time Code -- C, Assembly, MatLab,
or Java
Once a target microcontroller has been selected for
implementation, the Real Time Code Generator
(RTC) can output an assembly language program by clicking on a menu item.
Aptronix has demonstrated that the Fide RTC
generates very compact code which saves memory and helps the application to run faster. If
the application is designed in software, the RTC
can generates ANSI C code and Matlab M file code.
Take Advantage of System Design
Capability Built in Fide
Fide incorporates a unique capability unmatched by
any competing tools, which lets you graphically develop, simulate and debug your entire
system including the plant. This tool called the CAD Composergraphically
represent an open or closed loop system consisting of fuzzy allows you to and non-fuzzy
modules interconnected with data transfer channels. You can think of the Composer as a common schematic capture tool, where
each symbol may contain a fuzzy controller or a conventional algorithm. When an entire
system is entered in the Composer you can click
into a menu entry to automatically generate a project which combines all the modules into
a single executable file.
Block-Oriented System Design
Tool -- the CAD Composer
You can describe your system in the CAD Composer using two methods, graphical, or
textual. In its graphical representation, a system is described by placing symbols on a
schematic diagram and connecting their inputs and outputs with data flow paths In its
textual representation, a system is described in a language called the Fide Composer
Language (FCL), similar to a common netlist. This includes a listing of all symbols along
with labels for the intermediate interconnection points. The Composer is an ideal tool to
maintain generic system diagrams and reuse them with minor symbol replacements to design
system upgrades for product variation.
The Composer includes two capabilities, the Data
Flow Viewer and the Simulator, which allow you to test, simulate and debug the entire
system, .
The data flow viewer allows you to initialize your
system with some input values and test its behavior by observing a continuous data flow
between the different modules. You may also interrupt this continuous flow and proceed at
your own pace using the single step mode. If you find a fuzzy module has an undesired
response, a hot-link automatically takes you back to the Tracer.
The simulator helps you analyze the dynamic behavior
of the system. You can set the initial conditions, terminating conditions, and then let
the tool run automatically. When the terminating conditions are met, the values of all
selected input and output variables are displayed as time-value graphs. Again, a hot link
to the tracer allows you to debug individual modules by tracing back an undesirable
behavior all the way to the source code.
Back
to Home
© 1996 Aptronix Inc.
