The NXTFuzzyLogic Library

NXTFuzzyLogic is an open fuzzy logic library created by students from Faculty of Mathematics and Computer Science, Adam Mickiewicz University. It provides an easy way for operating fuzzy logic controllers on Lego Mindstorms NXT. It requires LeJOS 0.85 firmware on the brick. Some of its features are:

- Defuzification methods:

Aggregation functions:
- - Product
  - Maximum
  - Bounded difference

- - Center of gravity (COG)
  - Center of area (COA)
  - Rightmost maximum, leftmost maximum

Membership functions:
- - Triangular
  - Trapezoidal
  - Singleton

How to use NXTFuzzyLogic Library?

Using NXTFuzzyLogic library is quite simple - NXTFuzzyLogic.jar file have to be downloaded (from Downloads section), placed in the project workspace directory and added to Java Build Path.

How to use NXTFuzzyLogic under Eclipse?

First, you will have to install LeJOS in you PC. After adding LeJOS classes.jar to Java Build Path NXTFuzzyLogic.jar have to be added by choosing Project's Properties -> Java Build Path -> Add External JARs and pointing to the NXTFuzzyLogic.jar file.

Defining first Fuzzy Logic Controler

First thing is to add nxtfuzzylogic

import:import nxtfuzzylogic.*;

The definition of the controller starts with construction of nxtfuzzylogic object and definition of input and output linguistic variables:nfl = new NXTFuzzyLogic();

nfl.defineInputLinguisticVariable("in_variable_name", min_range, max_range, default_value);

nfl.defineOutputLinguisticVariable("out_variable_name", min_range, max_range, default_value);

Next thing is to define Terms. You can define following kinds of terms: ZType, Traingluar, SType

nfl.defineTermZType("term_name", "linguistic_variable_name", max, min);

nfl.defineTermTriangular("term_name", "linguistic_variable_name", left_min, center_max, right_min);

nfl.defineTermSType("term_name", "linguistic_variable_name", min, max);

Rule definitions:

nfl.defineRule(new String[] {"condition_1", "condition_2"}, "conclusion_name", aggregation_method);

Controler initialization:

nfl.init()

Setting up intput value and getting output from controller

public void setInput(int angularVelocity, int angle) {

nfl.setInputValue("in_variable_name", value);

}

public int getOutput() {

nfl.evaluate();

return (int) nfl.getOutputValue("out_variable_name");

}

Sample Fuzzy Logic controller for a Segway robot

import nxtfuzzylogic.*;

public class Controller {

private NXTFuzzyLogic nfl = new NXTFuzzyLogic();

public Controller() {

nfl = new NXTFuzzyLogic();

nfl.defineInputLinguisticVariable("vel", -900, 900, 0);

nfl.defineInputLinguisticVariable("angle", -90, 90, 0);

nfl.defineTermZType("backLarge", "vel", -75, -50);

nfl.defineTermTriangular("backMedium", "vel", -75, -50, -25);

nfl.defineTermTriangular("backSmall", "vel", -50, -25, 0);

nfl.defineTermTriangular("zero", "vel", -25, 0, 25);

nfl.defineTermTriangular("fowSmall", "vel", 0, 25, 50);

nfl.defineTermTriangular("fowMedium", "vel", 25, 50, 75);

nfl.defineTermSType("fowLarge", "vel", 50, 75);

nfl.defineTermZType("negLarge", "angle", -16, -9);

nfl.defineTermTriangular("negMedium", "angle", -13, -9, -4);

nfl.defineTermTriangular("negSmall", "angle", -6, -3, 0);

nfl.defineTermTriangular("zeroAng", "angle", -2, 0, 2);

nfl.defineTermTriangular("posSmall", "angle", 0, 3, 6);

nfl.defineTermTriangular("posMedium","angle", 4, 9, 13);

nfl.defineTermSType("posLarge", "angle", 9, 16);

nfl.defineOutputLinguisticVariable("speed", -900, 900, 0, NXTFuzzyLogic.COG);

nfl.defineTermZType("backVeryFast", "speed", -900, -420);

nfl.defineTermTriangular("backFast", "speed", -530, -310, -190);

nfl.defineTermTriangular("backMedium", "speed", -220, -160, -115);

nfl.defineTermTriangular("backSlow", "speed", -155, -105, -55);

nfl.defineTermTriangular("backVerySlow", "speed", -80, -40, 0);

nfl.defineTermTriangular("stop", "speed", -15, 0, 15);

nfl.defineTermTriangular("fowVerySlow", "speed", 0, 40, 80);

nfl.defineTermTriangular("fowSlow", "speed", 55, 105, 155);

nfl.defineTermTriangular("fowMedium", "speed", 115, 160, 220);

nfl.defineTermTriangular("fowFast", "speed", 190, 310, 530);

nfl.defineTermSType("fowVeryFast", "speed", 420, 900);

//negLarge========================================================

String[] r0 = {"negLarge", "backLarge"};

nfl.defineRule(r0, "backVeryFast", NXTFuzzyLogic.MIN);

String[] r1 = {"negLarge", "backMedium"};

nfl.defineRule(r1, "backVeryFast", NXTFuzzyLogic.MIN);

String[] r2 = {"negLarge", "backSmall"};

nfl.defineRule(r2, "backVeryFast", NXTFuzzyLogic.MIN);

String[] r3 = {"negLarge", "zero"};

nfl.defineRule(r3, "backFast", NXTFuzzyLogic.MIN);

String[] r4 = {"negLarge", "fowSmall"};

nfl.defineRule(r4, "backFast", NXTFuzzyLogic.MIN);

String[] r5 = {"negLarge", "fowMedium"};

nfl.defineRule(r5, "backMedium", NXTFuzzyLogic.MIN);

String[] r6 = {"negLarge", "fowLarge"};

nfl.defineRule(r6, "backMedium", NXTFuzzyLogic.MIN);

//negMedium ======================================================

String[] r7 = {"negMedium", "backLarge"};

nfl.defineRule(r7, "backVeryFast", NXTFuzzyLogic.MIN);

String[] r8 = {"negMedium", "backMedium"};

nfl.defineRule(r8, "backFast", NXTFuzzyLogic.MIN);

String[] r9 = {"negMedium", "backSmall"};

nfl.defineRule(r9, "backFast", NXTFuzzyLogic.MIN);

String[] r10 = {"negMedium", "zero"};

nfl.defineRule(r10, "backMedium", NXTFuzzyLogic.MIN);

String[] r11 = {"negMedium", "fowSmall"};

nfl.defineRule(r11, "backMedium", NXTFuzzyLogic.MIN);

String[] r12 = {"negMedium", "fowMedium"};

nfl.defineRule(r12, "backSlow", NXTFuzzyLogic.MIN);

String[] r13 = {"negMedium", "fowLarge"};

nfl.defineRule(r13, "backSlow", NXTFuzzyLogic.MIN);

//negSmall========================================================

String[] r14 = {"negSmall", "backLarge"};

nfl.defineRule(r14, "backFast", NXTFuzzyLogic.MIN);

String[] r15 = {"negSmall", "backMedium"};

nfl.defineRule(r15, "backMedium", NXTFuzzyLogic.MIN);

String[] r16 = {"negSmall", "backSmall"};

nfl.defineRule(r16, "backMedium", NXTFuzzyLogic.MIN);

String[] r17 = {"negSmall", "zero"};

nfl.defineRule(r17, "backSlow", NXTFuzzyLogic.MIN);

String[] r18 = {"negSmall", "fowSmall"};

nfl.defineRule(r18, "backSlow", NXTFuzzyLogic.MIN);

String[] r19 = {"negSmall", "fowMedium"};

nfl.defineRule(r19, "backVerySlow", NXTFuzzyLogic.MIN);

String[] r20 = {"negSmall", "fowLarge"};

nfl.defineRule(r20, "backVerySlow", NXTFuzzyLogic.MIN);

//zeroAng=========================================================

String[] r21 = {"zeroAng", "backLarge"};

nfl.defineRule(r21, "backSlow", NXTFuzzyLogic.MIN);

String[] r22 = {"zeroAng", "backMedium"};

nfl.defineRule(r22, "backVerySlow", NXTFuzzyLogic.MIN);

String[] r23 = {"zeroAng", "backSmall"};

nfl.defineRule(r23, "backVerySlow", NXTFuzzyLogic.MIN);

String[] r24 = {"zeroAng", "zero"};

nfl.defineRule(r24, "stop", NXTFuzzyLogic.MIN);

String[] r25 = {"zeroAng", "fowSmall"};

nfl.defineRule(r25, "fowVerySlow", NXTFuzzyLogic.MIN);

String[] r26 = {"zeroAng", "fowMedium"};

nfl.defineRule(r26, "fowVerySlow", NXTFuzzyLogic.MIN);

String[] r27 = {"zeroAng", "fowLarge"};

nfl.defineRule(r27, "fowSlow", NXTFuzzyLogic.MIN);

//posSmall========================================================

String[] r28 = {"posSmall", "backLarge"};

nfl.defineRule(r28, "fowVerySlow", NXTFuzzyLogic.MIN);

String[] r29 = {"posSmall", "backMedium"};

nfl.defineRule(r29, "fowVerySlow", NXTFuzzyLogic.MIN);

String[] r30 = {"posSmall", "backSmall"};

nfl.defineRule(r30, "fowSlow", NXTFuzzyLogic.MIN);

String[] r31 = {"posSmall", "zero"};

nfl.defineRule(r31, "fowSlow", NXTFuzzyLogic.MIN);

String[] r32 = {"posSmall", "fowSmall"};

nfl.defineRule(r32, "fowMedium", NXTFuzzyLogic.MIN);

String[] r33 = {"posSmall", "fowMedium"};

nfl.defineRule(r33, "fowMedium", NXTFuzzyLogic.MIN);

String[] r34 = {"posSmall", "fowLarge"};

nfl.defineRule(r34, "fowFast", NXTFuzzyLogic.MIN);

//posMedium=======================================================

String[] r35 = {"posMedium", "backLarge"};

nfl.defineRule(r35, "fowSlow", NXTFuzzyLogic.MIN);

String[] r36 = {"posMedium", "backMedium"};

nfl.defineRule(r36, "fowSlow", NXTFuzzyLogic.MIN);

String[] r37 = {"posMedium", "backSmall"};

nfl.defineRule(r37, "fowMedium", NXTFuzzyLogic.MIN);

String[] r38 = {"posMedium", "zero"};

nfl.defineRule(r38, "fowMedium", NXTFuzzyLogic.MIN);

String[] r39 = {"posMedium", "fowSmall"};

nfl.defineRule(r39, "fowFast", NXTFuzzyLogic.MIN);

String[] r40 = {"posMedium", "fowMedium"};

nfl.defineRule(r40, "fowFast", NXTFuzzyLogic.MIN);

String[] r41 = {"posMedium", "fowLarge"};

nfl.defineRule(r41, "fowVeryFast", NXTFuzzyLogic.MIN);

//kat - posLarge========================================================

String[] r42 = {"posLarge", "backLarge"};

nfl.defineRule(r42, "fowMedium", NXTFuzzyLogic.MIN);

String[] r43 = {"posLarge", "backMedium"};

nfl.defineRule(r43, "fowMedium", NXTFuzzyLogic.MIN);

String[] r44 = {"posLarge", "backSmall"};

nfl.defineRule(r44, "fowFast", NXTFuzzyLogic.MIN);

String[] r45 = {"posLarge", "zero"};

nfl.defineRule(r45, "fowFast", NXTFuzzyLogic.MIN);

String[] r46 = {"posLarge", "fowSmall"};

nfl.defineRule(r46, "fowVeryFast", NXTFuzzyLogic.MIN);

String[] r47 = {"posLarge", "fowMedium"};

nfl.defineRule(r47, "fowVeryFast", NXTFuzzyLogic.MIN);

String[] r48 = {"posLarge", "fowLarge"};

nfl.defineRule(r48, "fowVeryFast", NXTFuzzyLogic.MIN);

nfl.init();

}

public void setInput(int angularVelocity, int angle){

nfl.setInputValue("vel", angularVelocity);

nfl.setInputValue("angle", angle);

}

public int getOutput(){

nfl.evaluate();

return (int) nfl.getOutputValue("speed");

}

References

http://code.google.com/p/nxtfuzzylogic/

Author

- David Trejo