Source Code Fuzzy Logic Arduino

Posted on 15-09-2021 by admin

A Fuzzy Logic Control Library in C++

By: Juan Rada-Vilela, Ph.D.

Fuzzy control is based on fuzzy logic. A logical system that is much closer in spirit to human thinking and natural language than traditional. Genetic Algorithm: An Authentic tool for Agriculture Business System implemented by MATLAB. The study of agricultural system is most extreme vital for India being the place that is known for farming. Jun 25, 2013 could u help me out with the arduino code for a fuzzy logic controller. I am planning to implement a collision avoidance mobile robot using the fuzzy logic controller system June 25, 2013, 10:06am.

Fuzzy logic C library. This class allows you to create an object of fuzzy logic type, supports the creation of multiple inputs, outputs, and sets for each of them, as well as the creation of multiple rules. Allows defuzzification, and find the current value of the outputs, based on the current value of the inputs, and the defined rules. For More Matlab Projects on Fuzzy Logic. IEEE Matlab Projects: Listing out some of the latest IEEE based Final Year Matlab Project Ideas for Engineering Students. This article provides you the latest IEEE Matlab Projects with Full Source Code. M2M: A Simple Matlab-to-MapReduce Translator for Cloud Computing. Explaination: The Leonard is Arduino’s first development board to use one microcontroller with built-in USB. This means that it can be cheaper and simple, And also, code libraries are available which allow the board to emulate a computer keyboard etc.

Released: 20/March/2017

License
Introduction
Features
Example
Compile, Link, and Execute
Bulding from Source
Binaries
What's new
What's next

License

fuzzylite 6.0 is licensed under the GNU General Public License (GPL) 3.0. You are strongly encouraged to support the development of the FuzzyLite Libraries by purchasing a license of QtFuzzyLite 6.

QtFuzzyLite 6 is the new and (very likely) the best graphical user interface available to easily design and directly operate fuzzy logic controllers in real time. Available for Windows, Mac, and Linux, its goal is to significantly speed up the design of your fuzzy logic controllers, while providing a very useful, functional and beautiful user interface. Please, download it and check it out for free at www.fuzzylite.com/downloads/.

Introduction

fuzzylite is a free and open-source fuzzy logic control library programmed in C++ for multiple platforms (e.g., Windows, Linux, Mac, iOS). jfuzzylite is the equivalent library for Java and Android platforms. Together, they are the FuzzyLite Libraries for Fuzzy Logic Control.

The goal of the FuzzyLite Libraries is to easily design and efficiently operate fuzzy logic controllers following an object-oriented programming model without relying on external libraries.

Reference

If you are using the FuzzyLite Libraries, please cite the following reference in your article:

Juan Rada-Vilela. fuzzylite: a fuzzy logic control library, 2017. URL http://www.fuzzylite.com/.

author={Juan Rada-Vilela},

url={http://www.fuzzylite.com/},

Documentation

The documentation for the fuzzylite library is available at: www.fuzzylite.com/documentation/.

Features

**(6) Controllers**: Mamdani, Takagi-Sugeno, Larsen, Tsukamoto, Inverse Tsukamoto, Hybrids

**(21) Linguistic terms**: (4) Basic: triangle, trapezoid, rectangle, discrete. (9) Extended: bell, cosine, gaussian, gaussian product, pi-shape, sigmoid difference, sigmoid product, spike. (5) Edges: binary, concave, ramp, sigmoid, s-shape, z-shape. (3) Functions: constant, linear, function.

**(7) Activation methods**: general, proportional, threshold, first, last, lowest, highest.

**(8) Conjunction and Implication (T-Norms)**: minimum, algebraic product, bounded difference, drastic product, einstein product, hamacher product, nilpotent minimum, function.

**(10) Disjunction and Aggregation (S-Norms)**: maximum, algebraic sum, bounded sum, drastic sum, einstein sum, hamacher sum, nilpotent maximum, normalized sum, unbounded sum, function.

**(7) Defuzzifiers**: (5) Integral: centroid, bisector, smallest of maximum, largest of maximum, mean of maximum. (2) Weighted: weighted average, weighted sum.

**(7) Hedges**: any, not, extremely, seldom, somewhat, very, function.

**(3) Importers**: FuzzyLite Language fll, Fuzzy Inference System fis, Fuzzy Control Language fcl.

**(7) Exporters**: C++, Java, FuzzyLite Language fll, FuzzyLite Dataset fld, R script, Fuzzy Inference System fis, Fuzzy Control Language fcl.

Source Code Fuzzy Logic Arduino Code

**(30+) Examples** of Mamdani, Takagi-Sugeno, Tsukamoto, and Hybrid controllers from fuzzylite, Octave, and Matlab, each included in the following formats: C++, Java, fll, fld, R, fis, and fcl.

Example

#### FuzzyLite Language

Engine: ObstacleAvoidance

enabled: true

lock-range: false

term: right Ramp 0.000 1.000

enabled: true

lock-range: false

defuzzifier: Centroid 100

lock-previous: false

term: right Ramp 0.000 1.000

enabled: true

disjunction: none

activation: General

rule: if obstacle is right then mSteer is left

#include 'fl/Headers.h'

int main(int argc, char* argv[]){

Engine* engine = FllImporter().fromFile('ObstacleAvoidance.fll');

std::string status;

throwException('[engine error] engine is not ready:n' + status, FL_AT);

InputVariable* obstacle = engine->getInputVariable('obstacle');

OutputVariable* steer = engine->getOutputVariable('mSteer');

for (int i = 0; i <= 50; ++i){

scalar location = obstacle->getMinimum() + i * (obstacle->range() / 50);

engine->process();

FL_LOG('obstacle.input = ' << Op::str(location) <<

' => ' << 'steer.output = ' << Op::str(steer->getValue()));

}

#### C++

#include 'fl/Headers.h'

int main(int argc, char* argv[]){

//Code automatically generated with fuzzylite 6.0.

using namespace fl;

Engine* engine = newEngine;

engine->setDescription(');

InputVariable* obstacle = newInputVariable;

obstacle->setDescription(');

obstacle->setRange(0.000, 1.000);

obstacle->addTerm(newRamp('left', 1.000, 0.000));

Source code fuzzy logic arduino programming

obstacle->addTerm(newRamp('right', 0.000, 1.000));

mSteer->setName('mSteer');

mSteer->setEnabled(true);

mSteer->setLockValueInRange(false);

mSteer->setDefuzzifier(newCentroid(100));

mSteer->setLockPreviousValue(false);

mSteer->addTerm(newRamp('right', 0.000, 1.000));

mamdani->setName('mamdani');

mamdani->setEnabled(true);

mamdani->setDisjunction(fl::null);

mamdani->setActivation(newGeneral);

mamdani->addRule(Rule::parse('if obstacle is left then mSteer is right', engine));

mamdani->addRule(Rule::parse('if obstacle is right then mSteer is left', engine));

if (not engine->isReady(&status))

throwException('[engine error] engine is not ready:n' + status, FL_AT);

for (int i = 0; i <= 50; ++i){

scalar location = obstacle->getMinimum() + i * (obstacle->range() / 50);

engine->process();

FL_LOG('obstacle.input = ' << Op::str(location) <<

' => ' << 'steer.output = ' << Op::str(steer->getValue()));

}

Compile, Link, and Execute

Once you have an engine written in C++, you can compile it to create an executable file which links to the fuzzylite library. The linking can be either static or dynamic. Basically, the differences between static and dynamic linking are the following. Static linking includes the fuzzylite library into your executable file, hence increasing its size, but the executable no longer needs to have access to the fuzzylite library files. Dynamic linking does not include the fuzzylite library into your executable file, hence reducing its size, but the executable needs to have access to the fuzzylite shared library file. When using dynamic linking, make sure that the shared library files are either in the same directory as the executable, or are reachable via environmental variables:

set PATH='pathtofuzzylitereleasebin;%PATH%'

export LD_LIBRARY_PATH='/path/to/fuzzylite/release/bin/:$LD_LIBRARY_PATH'

Windows

The commands to compile your engine in Windows are the following:

C++11 (default)

cl.exe ObstacleAvoidance.cpp fuzzylite-static.lib /Ipath/to/fuzzylite /EHsc /MD

cl.exe ObstacleAvoidance.cpp fuzzylite.lib /Ipath/to/fuzzylite /DFL_IMPORT_LIBRARY /EHsc /MD

C++98

cl.exe ObstacleAvoidance.cpp fuzzylite-static.lib /Ipath/to/fuzzylite /DFL_CPP98=ON /EHsc /MD

cl.exe ObstacleAvoidance.cpp fuzzylite.lib /Ipath/to/fuzzylite /DFL_IMPORT_LIBRARY /DFL_CPP98=ON /EHsc /MD

Unix

The commands to compile your engine in Unix are the following:

C++11 (default)

g++ ObstacleAvoidance.cpp -o ObstacleAvoidance -I/path/to/fuzzylite -L/path/to/fuzzylite/release/bin -lfuzzylite-static --std=c++11

g++ ObstacleAvoidance.cpp -o ObstacleAvoidance -I/path/to/fuzzylite -L/path/to/fuzzylite/release/bin -lfuzzylite -Wno-non-literal-null-conversion

C++98

g++ ObstacleAvoidance.cpp -o ObstacleAvoidance -I/path/to/fuzzylite -L/path/to/fuzzylite/release/bin -lfuzzylite-static -DFL_CPP98=ON

g++ ObstacleAvoidance.cpp -o ObstacleAvoidance -I/path/to/fuzzylite -L/path/to/fuzzylite/release/bin -lfuzzylite -DFL_CPP98=ON -Wno-non-literal-null-conversion

CMake

Alternatively, you can use CMake to build your project linking to fuzzylite. Please, refer to the example application available at examples/application.

Building from Source

You can build the fuzzylite library from source using CMake(cmake.org).

The files fuzzylite/build.bat and fuzzylite/build.sh are build scripts for the Windows and Unix platforms, respectively. After building from source, the resulting binaries will be located in the sub-folders fuzzylite/release/bin and fuzzylite/debug/bin. The usage of these scripts is presented as follows.

#### Windows

Usage: build.bat [options]

all builds fuzzylite in debug and release mode (default)

release builds fuzzylite in release mode

help shows this information

#### Unix

Usage: [bash] ./build.sh [options]

all builds fuzzylite in debug and release mode (default)

release builds fuzzylite in release mode

help shows this information

Building Options

For advanced building options, please check the contents of fuzzylite/build.bat or fuzzylite/build.sh, and the contents of fuzzylite/CMakeLists.txt.

The following building options available:

-DFL_USE_FLOAT=ON builds the binaries utilizing the fl::scalar data type as a float represented in 4 bytes. By default, the binaries are built utilizing -DFL_USE_FLOAT=OFF to utilize fl::scalar as a double represented in 8 bytes and hence providing better accuracy. If fuzzylite is built with -DFL_USE_FLOAT=ON, then the applications linking to fuzzylite also need to specify this compilation flag.
-DFL_CPP98=ON builds binaries utilizing C++98 features. By default, fuzzylite is built with -DFL_CPP98=OFF to utilize C++11 features. If compiling for C++98, be aware that you will not be able to benchmark the performance of your engine using the Benchmark class.
-DFL_BACKTRACE=OFF disables the backtrace information in case of errors (default is ON). In Windows, the backtrace information requires the external library dbghelp, which is generally available in your system.
-DCMAKE_BUILD_TYPE=[Debug|Release] sets the mode of your build. You can only build one mode at a time with a single CMake script.