eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
eFLL - A Fuzzy Library for Arduino and Embedded
Systems
Fuzzy Logic is an extension of traditional Boolean logic, using linguistic variables allows to express
logical values intermediate between FALSE and TRUE, describing with greater efficiency the
uncertainty principle in the real world.
Fuzzy Systems are practical applications that employ Fuzzy Logic in its decisions making on the basis
of linguistic variables and terms, the robotics and the electronic engineering has a large utility room.
Developed by Robotic Research Group (RRG) at the State University of Piauí (UESPI-Teresina)
the eFLL (Embedded Fuzzy Logic Library)
library is a versatile, lightweight and efficient option to work with Fuzzy Logic in embedded systems.
Please, report bugs and suggestions with comments or in the official code page on GitHub
Step 4: eFLL will appear in the list, to finish, just click in INSTALL, now you can include eFLL to
your sketchs
Old Way
Step 1: Go to the official project page on GitHub: eFLL
1 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
Step 2: Make a clone of the project using Git or download it
Download on the button "Download as zip."
Step 3: Clone or unzip the files into Arduino libraries' folder:
Obs: Rename the folder from "eFLL-master" to "eFLL"
Ubuntu (/usr/share/arduino/libraries/) if installed via apt-get, if not, on Windows, Mac or Linux (where
you downloaded the Arduino IDE, the Library folder is inside)
Ok! The library is ready to be used.
How to import
If the installation of the library has been successfully held, to import the library is easy:
Step 1: Open your Arduino IDE, check out the tab on the top menu SKETCH →
LIBRARY → Import eFLL
Características
Written in C++/C, uses only standard C language library "stdlib.h", so eFLL is a library designed not
only to Arduino, but any Embedded System or not how have your commands written in C.
2 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
It has no explicit limitations on quantity of Fuzzy, Fuzzy Rules, Inputs or Outputs, these limited
processing power and storage of each microcontroller
The library uses the process:
(MAX-MIN) and (Minimum Mamdani) for inference and composition and (CENTER OF AREA)
to defuzzification in a continuous universe.
Tested with GTest for C, Google Inc.
Simple example:
Speed control of a robotic, entry: Frontal distance obstacle.
#include <Fuzzy.h>
// Instantiating a Fuzzy object
Fuzzy *fuzzy = new Fuzzy();
void setup()
// Set the Serial output
3 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
Serial.begin(9600);
// Set a random seed
randomSeed(analogRead(0));
// Instantiating a FuzzyInput object
FuzzyInput *distance = new FuzzyInput(1);
// Instantiating a FuzzySet object
FuzzySet *small = new FuzzySet(0, 20, 20, 40);
// Including the FuzzySet into FuzzyInput
distance->addFuzzySet(small);
// Instantiating a FuzzySet object
FuzzySet *safe = new FuzzySet(30, 50, 50, 70);
// Including the FuzzySet into FuzzyInput
distance->addFuzzySet(safe);
// Instantiating a FuzzySet object
FuzzySet *big = new FuzzySet(60, 80, 80, 80);
4 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
// Including the FuzzySet into FuzzyInput
distance->addFuzzySet(big);
// Including the FuzzyInput into Fuzzy
fuzzy->addFuzzyInput(distance);
// Instantiating a FuzzyOutput objects
FuzzyOutput *speed = new FuzzyOutput(1);
// Instantiating a FuzzySet object
FuzzySet *slow = new FuzzySet(0, 10, 10, 20);
// Including the FuzzySet into FuzzyOutput
speed->addFuzzySet(slow);
// Instantiating a FuzzySet object
FuzzySet *average = new FuzzySet(10, 20, 30, 40);
// Including the FuzzySet into FuzzyOutput
speed->addFuzzySet(average);
// Instantiating a FuzzySet object
5 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
FuzzySet *fast = new FuzzySet(30, 40, 40, 50);
// Including the FuzzySet into FuzzyOutput
speed->addFuzzySet(fast);
// Including the FuzzyOutput into Fuzzy
fuzzy->addFuzzyOutput(speed);
// Building FuzzyRule "IF distance = small THEN speed = slow"
// Instantiating a FuzzyRuleAntecedent objects
FuzzyRuleAntecedent *ifDistanceSmall = new FuzzyRuleAntecedent();
// Creating a FuzzyRuleAntecedent with just a single FuzzySet
ifDistanceSmall->joinSingle(small);
// Instantiating a FuzzyRuleConsequent objects
FuzzyRuleConsequent *thenSpeedSlow = new FuzzyRuleConsequent();
// Including a FuzzySet to this FuzzyRuleConsequent
thenSpeedSlow->addOutput(slow);
// Instantiating a FuzzyRule objects
6 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
FuzzyRule *fuzzyRule01 = new FuzzyRule(1, ifDistanceSmall, thenSpeedSlow);
// Including the FuzzyRule into Fuzzy
fuzzy->addFuzzyRule(fuzzyRule01);
// Building FuzzyRule "IF distance = safe THEN speed = average"
// Instantiating a FuzzyRuleAntecedent objects
FuzzyRuleAntecedent *ifDistanceSafe = new FuzzyRuleAntecedent();
// Creating a FuzzyRuleAntecedent with just a single FuzzySet
ifDistanceSafe->joinSingle(safe);
// Instantiating a FuzzyRuleConsequent objects
FuzzyRuleConsequent *thenSpeedAverage = new FuzzyRuleConsequent();
// Including a FuzzySet to this FuzzyRuleConsequent
thenSpeedAverage->addOutput(average);
// Instantiating a FuzzyRule objects
FuzzyRule *fuzzyRule02 = new FuzzyRule(2, ifDistanceSafe, thenSpeedAverage);
// Including the FuzzyRule into Fuzzy
7 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
fuzzy->addFuzzyRule(fuzzyRule02);
// Building FuzzyRule "IF distance = big THEN speed = high"
// Instantiating a FuzzyRuleAntecedent objects
FuzzyRuleAntecedent *ifDistanceBig = new FuzzyRuleAntecedent();
// Creating a FuzzyRuleAntecedent with just a single FuzzySet
ifDistanceBig->joinSingle(big);
// Instantiating a FuzzyRuleConsequent objects
FuzzyRuleConsequent *thenSpeedFast = new FuzzyRuleConsequent();
// Including a FuzzySet to this FuzzyRuleConsequent
thenSpeedFast->addOutput(fast);
// Instantiating a FuzzyRule objects
FuzzyRule *fuzzyRule03 = new FuzzyRule(3, ifDistanceBig, thenSpeedFast);
// Including the FuzzyRule into Fuzzy
fuzzy->addFuzzyRule(fuzzyRule03);
8 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
void loop()
// Getting a random value
int input = random(0, 80);
// Printing something
Serial.println("\n\n\nEntrance: ");
Serial.print("\t\t\tDistance: ");
Serial.println(input);
// Set the random value as an input
fuzzy->setInput(1, input);
// Running the Fuzzification
fuzzy->fuzzify();
// Running the Defuzzification
float output = fuzzy->defuzzify(1);
// Printing something
9 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
Serial.println("Result: ");
Serial.print("\t\t\tSpeed: ");
Serial.println(output);
// wait 12 seconds
delay(12000);
Brief documentation
Fuzzy object - This object includes all the Fuzzy System, through it, you can manipulate the Fuzzy
Sets, Linguistic Rules, inputs and outputs.
FuzzyInput object - This object groups all entries Fuzzy Sets that belongs to the same domain.
FuzzyOutput object - This object is similar to FuzzyInput, is used to group all output Fuzzy Sets
that belongs to the same domain.
FuzzySet object - This is one of the main objects of Fuzzy Library, with each set is possible to model
the system in question. Currently the library supports triangular membership functions, trapezoidal and
singleton, which are assembled based on points A, B, C and D, they are passed by parameter in its
constructor FuzzySet(float a, float b, float c, float d) examples:
Triangular pertinence function:
10 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
FuzzySet* fs = FuzzySet(10, 20, 20, 30);
FuzzySet* fs = FuzzySet(10, 33, 33, 33);
FuzzySet* fs = FuzzySet(5, 5, 5, 30);
11 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
Trapezoidal pertinence function:
FuzzySet* fs = FuzzySet(10, 20, 30, 40);
FuzzySet* fs = FuzzySet(0, 0, 10, 20);
Any value below 10 will have pertinence = 1
12 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
FuzzySet* fs = FuzzySet(20, 30, 40, 40);
Any value above 30 will have pertinence = 1
Singleton pertinence function:
FuzzySet* fs = FuzzySet(20, 20, 20, 20);
FuzzyRule object - This object is used to mount the base rule of Fuzzy object, which contains one or
more of this object. Instantiated with FuzzyRule fr = new FuzzyRule (ID, antecedent, consequent)
FuzzyRuleAntecedent object - This object is used to compound the object FuzzyRule, responsible for
assembling the antecedent of the conditional expression of a FuzzyRule, examples:
13 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
"IF distance = small THEN velocity = slow"
FuzzyRuleAntecedent* ifDistanceSmall = new FuzzyRuleAntecedent(); ifDistanceSmall->joinSingle(small);
The method joinSingle(FuzzySet* fuzzySet) is used to build simple expressions IF/THEN. To compose
more complex expressions there are other special methods.
"IF temperature = hot AND pressure = hight THEN rick = big"
FuzzyRuleAntecedent* ifTemperatureHotAndPressureHight = new FuzzyRuleAntecedent();
ifTemperatureHotAndPressureHight->joinWithAND(hot, hight);
"IF temperature = hot OR pressure = hight THEN rick = big"
FuzzyRuleAntecedent* ifTemperatureHotAndPressureHight = new FuzzyRuleAntecedent();
ifTemperatureHotAndPressureHight->joinWithOR(hot, hight);
The methods joinWithAND(FuzzySet* fuzzySet1, FuzzySet* fuzzySet2) and joinWithOR(FuzzySet*
fuzzySet1, FuzzySet* fuzzySet2) can make logical compositions between Fuzzy Sets. These methods
also have more advanced variations that allow further enhance the expression, they are:
bool joinWithAND(FuzzySet* fuzzySet, FuzzyRuleAntecedent* fuzzyRuleAntecedent);
bool joinWithAND(FuzzyRuleAntecedent* fuzzyRuleAntecedent, FuzzySet* fuzzySet);
14 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
bool joinWithOR(FuzzySet* fuzzySet, FuzzyRuleAntecedent* fuzzyRuleAntecedent);
bool joinWithOR(FuzzyRuleAntecedent* fuzzyRuleAntecedent, FuzzySet* fuzzySet);
bool joinWithAND(FuzzyRuleAntecedent* fuzzyRuleAntecedent1, FuzzyRuleAntecedent* fuzzyRuleAntecedent2
bool joinWithOR(FuzzyRuleAntecedent* fuzzyRuleAntecedent1, FuzzyRuleAntecedent* fuzzyRuleAntecedent2
examples:
"IF (velocity = hight AND distance = small) OR fuel = low THEN velocity = small AND consumption
= short"
FuzzyRuleAntecedent* speedHightAndDistanceSmall = new FuzzyRuleAntecedent();
speedHightAndDistanceSmall->joinWithAND(hight, small);
FuzzyRuleAntecedent* fuelLow = new FuzzyRuleAntecedent();
fuelLow->joinSingle(low);
// Este objeto FuzzyRuleAntecedente é que será usada para compor o objeto FuzzyRule
FuzzyRuleAntecedent* ifSpeedHightAndDistanceSmallOrFuelLow = new FuzzyRuleAntecedent();
ifSpeedHightAndDistanceSmallOrFuelLow->joinWithOR(speedHightAndDistanceSmall, fuelLow);
Using these methods, any expression can be mounted, FuzzyRuleAntecedent can be used to compose
another object FuzzyRuleAntecedent, in many different ways.
OBS:. in the previous example, the final antecedent was composed of speedHightAndDistanceSmall
and fuelLow objects, but the latter could be replaced without loss by the FuzzySet object low, since it is
a simple expression, without any conditional operator:
FuzzyRuleAntecedent* speedHightAndDistanceSmall = new FuzzyRuleAntecedent();
15 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
speedHightAndDistanceSmall->joinWithAND(hight, small);
// Este objeto FuzzyRuleAntecedente é que será usada para compor o objeto FuzzyRule
FuzzyRuleAntecedent* ifSpeedHightAndDistanceSmallOrFuelLow = new FuzzyRuleAntecedent();
ifSpeedHightAndDistanceSmallOrFuelLow->joinWithOR(speedHightAndDistanceSmall, low);
FuzzyRuleConsequente object - This object is used to render the object FuzzyRule, responsible for
assembling the output expression of a FuzzyRule, examples:
"IF disctance = small THEN velocity = slow"
FuzzyRuleConsequent* thenSpeedSlow = new FuzzyRuleConsequent();
thenSpeedSlow->addOutput(slow);
What would result in an FuzzyRule object like:
FuzzyRule* fuzzyRule = new FuzzyRule(2, ifDistanceSmall, thenSpeedSlow);
"IF (velocity = hight AND distance = small) OR fuel = low THEN velocity = small AND consumption
= short"
FuzzyRuleConsequent* thenSpeedSmallAndFeedTine = new FuzzyRuleConsequent(); thenSpeedSmallAndFeedSmall
thenSpeedSmallAndFeedSmall->addOutput(tine);
16 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
For the object FuzzyRuleConsequent entire expression is mounted using the method
addOutput(FuzzySet* fuzzySet);
What would result in an FuzzyRule object like:
FuzzyRule* fuzzyRule = new FuzzyRule(2, ifSpeedHightAndDistanceSmallOrFuelLow, thenSpeedSmallAndFeedTine
After assembling an FuzzyRule object, use the method addFuzzyRule(FuzzyRule* fuzzyRule); to add
it to Fuzzy object base rule, repeat the same process for all the rules.
Tip
These are all eFLL library objects that are used in the process. The next step, generally interactive is
handled by three methods of the Fuzzy Class first:
bool setInput(int id, float value);
It is used to pass the
Crispe input value to the system note that the first parameter is the FuzzyInput object' ID which
parameter value is intended.
bool fuzzify();
It is used to start the fuzzification process, composition and inference.
And finally:
17 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
float defuzzify(int id);
It is used to finalize the fuzzification
process, notice that the param ID belongs to FuzzyOutput object which you want to get the
defuzzification value.
Hint: Sometimes is necessary to know the pertinence with which some or each fuzzy set was activated.
To do this, use the method float getPertinence(); of FuzzySet Class, eg:
FuzzySet* hot = new FuzzySet(30, 50, 50, 70);
...
... // After fuzzification with ->fuzzyfy();
...
float pertinenceOfHot = hot->getPertinence();
Or whether a particular rule was fired, use the method bool isFiredRule(int ruleId); of Fuzzy object.
FuzzyRule* fuzzyRule = new FuzzyRule(2, ifDistanceSmall, thenSpeedSlow);
...
... // After fuzzification with ->fuzzyfy();
...
bool wasTheRulleFired = fuzzy->isFiredRule(2);
Advanced example:
#include <Fuzzy.h>
18 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
// For scope, instantiate all objects you will need to access in loop()
// It may be just one Fuzzy, but for demonstration, this sample will print
// all FuzzySet pertinence
// Fuzzy
Fuzzy *fuzzy = new Fuzzy();
// FuzzyInput
FuzzySet *near = new FuzzySet(0, 20, 20, 40);
FuzzySet *safe = new FuzzySet(30, 50, 50, 70);
FuzzySet *distant = new FuzzySet(60, 80, 100, 100);
// FuzzyInput
FuzzySet *stopedInput = new FuzzySet(0, 0, 0, 0);
FuzzySet *slowInput = new FuzzySet(1, 10, 10, 20);
FuzzySet *normalInput = new FuzzySet(15, 30, 30, 50);
FuzzySet *quickInput = new FuzzySet(45, 60, 70, 70);
19 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
// FuzzyInput
FuzzySet *cold = new FuzzySet(-30, -30, -20, -10);
FuzzySet *good = new FuzzySet(-15, 0, 0, 15);
FuzzySet *hot = new FuzzySet(10, 20, 30, 30);
// FuzzyOutput
FuzzySet *minimum = new FuzzySet(0, 20, 20, 40);
FuzzySet *average = new FuzzySet(30, 50, 50, 70);
FuzzySet *maximum = new FuzzySet(60, 80, 80, 100);
// FuzzyOutput
FuzzySet *stopedOutput = new FuzzySet(0, 0, 0, 0);
FuzzySet *slowOutput = new FuzzySet(1, 10, 10, 20);
FuzzySet *normalOutput = new FuzzySet(15, 30, 30, 50);
FuzzySet *quickOutput = new FuzzySet(45, 60, 70, 70);
20 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
void setup()
// Set the Serial output
Serial.begin(9600);
// Set a random seed
randomSeed(analogRead(0));
// Every setup must occur in the function setup()
// FuzzyInput
FuzzyInput *distance = new FuzzyInput(1);
distance->addFuzzySet(near);
distance->addFuzzySet(safe);
distance->addFuzzySet(distant);
fuzzy->addFuzzyInput(distance);
21 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
// FuzzyInput
FuzzyInput *speedInput = new FuzzyInput(2);
speedInput->addFuzzySet(stopedInput);
speedInput->addFuzzySet(slowInput);
speedInput->addFuzzySet(normalInput);
speedInput->addFuzzySet(quickInput);
fuzzy->addFuzzyInput(speedInput);
// FuzzyInput
FuzzyInput *temperature = new FuzzyInput(3);
temperature->addFuzzySet(cold);
temperature->addFuzzySet(good);
temperature->addFuzzySet(hot);
fuzzy->addFuzzyInput(temperature);
22 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
// FuzzyOutput
FuzzyOutput *risk = new FuzzyOutput(1);
risk->addFuzzySet(minimum);
risk->addFuzzySet(average);
risk->addFuzzySet(maximum);
fuzzy->addFuzzyOutput(risk);
// FuzzyOutput
FuzzyOutput *speedOutput = new FuzzyOutput(2);
speedOutput->addFuzzySet(stopedOutput);
speedOutput->addFuzzySet(slowOutput);
speedOutput->addFuzzySet(normalOutput);
speedOutput->addFuzzySet(quickOutput);
fuzzy->addFuzzyOutput(speedOutput);
23 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
// Building FuzzyRule
FuzzyRuleAntecedent *distanceNearAndSpeedQuick = new FuzzyRuleAntecedent();
distanceNearAndSpeedQuick->joinWithAND(near, quickInput);
FuzzyRuleAntecedent *temperatureCold = new FuzzyRuleAntecedent();
temperatureCold->joinSingle(cold);
FuzzyRuleAntecedent *ifDistanceNearAndSpeedQuickOrTemperatureCold = new
FuzzyRuleAntecedent();
ifDistanceNearAndSpeedQuickOrTemperatureCold->joinWithOR(distanceNearAndSpeedQuick,
temperatureCold);
FuzzyRuleConsequent *thenRisMaximumAndSpeedSlow = new FuzzyRuleConsequent();
thenRisMaximumAndSpeedSlow->addOutput(maximum);
thenRisMaximumAndSpeedSlow->addOutput(slowOutput);
FuzzyRule *fuzzyRule1 = new FuzzyRule(1, ifDistanceNearAndSpeedQuickOrTemperatureCold,
thenRisMaximumAndSpeedSlow);
fuzzy->addFuzzyRule(fuzzyRule1);
24 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
// Building FuzzyRule
FuzzyRuleAntecedent *distanceSafeAndSpeedNormal = new FuzzyRuleAntecedent();
distanceSafeAndSpeedNormal->joinWithAND(safe, normalInput);
FuzzyRuleAntecedent *ifDistanceSafeAndSpeedNormalOrTemperatureGood = new
FuzzyRuleAntecedent();
ifDistanceSafeAndSpeedNormalOrTemperatureGood->joinWithOR(distanceSafeAndSpeedNormal,
good);
FuzzyRuleConsequent *thenRiskAverageAndSpeedNormal = new FuzzyRuleConsequent();
thenRiskAverageAndSpeedNormal->addOutput(average);
thenRiskAverageAndSpeedNormal->addOutput(normalOutput);
FuzzyRule *fuzzyRule2 = new FuzzyRule(2, ifDistanceSafeAndSpeedNormalOrTemperatureGood,
thenRiskAverageAndSpeedNormal);
fuzzy->addFuzzyRule(fuzzyRule2);
// Building FuzzyRule
FuzzyRuleAntecedent *distanceDistantAndSpeedSlow = new FuzzyRuleAntecedent();
25 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
distanceDistantAndSpeedSlow->joinWithAND(distant, slowInput);
FuzzyRuleAntecedent *ifDistanceDistantAndSpeedSlowOrTemperatureHot = new
FuzzyRuleAntecedent();
ifDistanceDistantAndSpeedSlowOrTemperatureHot->joinWithOR(distanceDistantAndSpeedSlow,
hot);
FuzzyRuleConsequent *thenRiskMinimumSpeedQuick = new FuzzyRuleConsequent();
thenRiskMinimumSpeedQuick->addOutput(minimum);
thenRiskMinimumSpeedQuick->addOutput(quickOutput);
FuzzyRule *fuzzyRule3 = new FuzzyRule(3, ifDistanceDistantAndSpeedSlowOrTemperatureHot,
thenRiskMinimumSpeedQuick);
fuzzy->addFuzzyRule(fuzzyRule3);
void loop()
// get random entrances
26 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
int input1 = random(0, 100);
int input2 = random(0, 70);
int input3 = random(-30, 30);
Serial.println("\n\n\nEntrance: ");
Serial.print("\t\t\tDistance: ");
Serial.print(input1);
Serial.print(", Speed: ");
Serial.print(input2);
Serial.print(", and Temperature: ");
Serial.println(input3);
fuzzy->setInput(1, input1);
fuzzy->setInput(2, input2);
fuzzy->setInput(3, input3);
fuzzy->fuzzify();
27 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
Serial.println("Input: ");
Serial.print("\tDistance: Near-> ");
Serial.print(near->getPertinence());
Serial.print(", Safe-> ");
Serial.print(safe->getPertinence());
Serial.print(", Distant-> ");
Serial.println(distant->getPertinence());
Serial.print("\tSpeed: Stoped-> ");
Serial.print(stopedInput->getPertinence());
Serial.print(", Slow-> ");
Serial.print(slowInput->getPertinence());
Serial.print(", Normal-> ");
Serial.print(normalInput->getPertinence());
Serial.print(", Quick-> ");
28 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
Serial.println(quickInput->getPertinence());
Serial.print("\tTemperature: Cold-> ");
Serial.print(cold->getPertinence());
Serial.print(", Good-> ");
Serial.print(good->getPertinence());
Serial.print(", Hot-> ");
Serial.println(hot->getPertinence());
float output1 = fuzzy->defuzzify(1);
float output2 = fuzzy->defuzzify(2);
Serial.println("Output: ");
Serial.print("\tRisk: Minimum-> ");
Serial.print(minimum->getPertinence());
Serial.print(", Average-> ");
Serial.print(average->getPertinence());
29 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
Serial.print(", Maximum-> ");
Serial.println(maximum->getPertinence());
Serial.print("\tSpeed: Stoped-> ");
Serial.print(stopedOutput->getPertinence());
Serial.print(", Slow-> ");
Serial.print(slowOutput->getPertinence());
Serial.print(", Normal-> ");
Serial.print(normalOutput->getPertinence());
Serial.print(", Quick-> ");
Serial.println(quickOutput->getPertinence());
Serial.println("Result: ");
Serial.print("\t\t\tRisk: ");
Serial.print(output1);
Serial.print(", and Speed: ");
30 of 31 5/19/21, 1:39 AM
eFLL - A Fuzzy Library for Arduino and Embedded Systems https://blog.zerokol.com/2012/09/arduinofuzzy-fuzzy-library-for-arduino...
Serial.println(output2);
// wait 12 seconds
delay(12000);
31 of 31 5/19/21, 1:39 AM
