Go Down

Topic: Problem Fuzzy (Read 855 times) previous topic - next topic

muhaimin89

i had problem about my defuzzification process.. when input1 & 2 =0, output should be 0. when i change input1 & 2 it give correct output value..but when i change back to input1&2 to 0, the output hold the previous value..it did not give 0 anymore.. :smiley-roll-sweat:

AWOL

Code: [Select]
byte getvalue ()
{
 const byte returnVal [32] = {3, 6, 9, 13, 16, 19, 22, 25, 28, 31, 34,  38, 41, 44, 47,
                              50, 53, 56, ...etc };
 int index = (digitalRead (DS_L)<<4) | (digitalRead (DS_ML)<<3) | (digitalRead (DS_M)<< 2) | (digitalRead (DS_MR)<< 1) | digitalRead (DS_R);
 return returnVal [index];
}

Why write seven lines, when you can write the same thing in 140?
"Pete, it's a fool looks for logic in the chambers of the human heart." Ulysses Everett McGill.
Do not send technical questions via personal messaging - they will be ignored.

PaulS

Quote
Why write seven lines, when you can write the same thing in 140?

LOL!

PeterH


Code: [Select]
byte getvalue ()
{
 const byte returnVal [32] = {3, 6, 9, 13, 16, 19, 22, 25, 28, 31, 34,  38, 41, 44, 47,
                              50, 53, 56, ...etc };
 int index = (digitalRead (DS_L)<<4) | (digitalRead (DS_ML)<<3) | (digitalRead (DS_M)<< 2) | (digitalRead (DS_MR)<< 1) | digitalRead (DS_R);
 return returnVal [index];
}

Why write seven lines, when you can write the same thing in 140?


Or return map(index, 0, 31, 3, 100);
I only provide help via the forum - please do not contact me for private consultancy.

muhaimin89

i had made changes using your solution but the output still had a same problem like previous programming.. i did not no where the wrong this program..  :smiley-roll-sweat:

Quote
#include <Fuzzy.h>
#include <FuzzyComposition.h>
#include <FuzzyInput.h>
#include <FuzzyIO.h>
#include <FuzzyOutput.h>
#include <FuzzyRule.h>
#include <FuzzyRuleAntecedent.h>
#include <FuzzyRuleConsequent.h>
#include <FuzzySet.h>

# define DS_L   13  //1
# define DS_ML   12  //2
# define DS_M   11  //3
# define DS_MR   10  //4
# define DS_R   9   //5

float val = 0;
float lastError = 0;

// Instantiating an object of library
Fuzzy* fuzzy = new Fuzzy();

FuzzySet* negative = new FuzzySet(-0.44, -0.44, -0.44, 0);
FuzzySet* zero = new FuzzySet(-0.44, 0, 0, 0.53);
FuzzySet* positive = new FuzzySet(0, 0.53, 0.53, 0.53);

FuzzySet* negatif = new FuzzySet(-0.97, -0.97, -0.97, 0);
FuzzySet* kosong = new FuzzySet(-0.97, 0, 0, 0.97);
FuzzySet* positif = new FuzzySet(0, 0.97, 0.97, 0.97);

void setup(){
  pinMode(DS_L,INPUT);
  pinMode(DS_ML,INPUT);
  pinMode(DS_M,INPUT);
  pinMode(DS_MR,INPUT);
  pinMode(DS_R,INPUT);
 
  Serial.begin(9600);
   
  // FuzzyInput
  FuzzyInput* error = new FuzzyInput(1);
  error->addFuzzySet(negative);
  error->addFuzzySet(zero);
  error->addFuzzySet(positive);

  fuzzy->addFuzzyInput(error);

  // FuzzyInput
  FuzzyInput* derror = new FuzzyInput(2);
  derror->addFuzzySet(negatif);
  derror->addFuzzySet(kosong);
  derror->addFuzzySet(positif);

  fuzzy->addFuzzyInput(derror);

  // FuzzyOutput
  FuzzyOutput* motors = new FuzzyOutput(1);

  FuzzySet* HLeft = new FuzzySet(-1.50, -1.00, -1.00, -0.50);
  motors->addFuzzySet(HLeft);
  FuzzySet* SLeft = new FuzzySet(-1.00, -0.50, -0.50, 0);
  motors->addFuzzySet(SLeft);
  FuzzySet* Straight = new FuzzySet(-0.50, 0, 0, 0.50);
  motors->addFuzzySet(Straight);
  FuzzySet* SRight = new FuzzySet(0, 0.50, 0.50, 1.00);
  motors->addFuzzySet(SRight);
  FuzzySet* HRight = new FuzzySet(0.50, 1.00, 1.00, 1.50);
  motors->addFuzzySet(HRight);

  fuzzy->addFuzzyOutput(motors);

  // Building FuzzyRule
  FuzzyRuleAntecedent* iferrornegativeAndderrornegatif = new FuzzyRuleAntecedent();
  iferrornegativeAndderrornegatif->joinWithAND(negative, negatif);

  FuzzyRuleConsequent* thenmotorsHRight = new FuzzyRuleConsequent();
  thenmotorsHRight->addOutput(HRight);

  FuzzyRule* fuzzyRule1 = new FuzzyRule(1, iferrornegativeAndderrornegatif, thenmotorsHRight);
  fuzzy->addFuzzyRule(fuzzyRule1);

  // Building FuzzyRule
  FuzzyRuleAntecedent* iferrornegativeAndderrorkosong = new FuzzyRuleAntecedent();
  iferrornegativeAndderrorkosong->joinWithAND(negative, kosong);
  FuzzyRuleAntecedent* iferrornegativeAndderrorpositif = new FuzzyRuleAntecedent();
  iferrornegativeAndderrorpositif->joinWithAND(negative, positif);
  FuzzyRuleAntecedent* iferrorzeroAndderrornegatif = new FuzzyRuleAntecedent();
  iferrorzeroAndderrornegatif->joinWithAND(zero, negatif);
 
  FuzzyRuleConsequent* thenmotorsSRight = new FuzzyRuleConsequent();
  thenmotorsSRight->addOutput(SRight);
 
  FuzzyRule* fuzzyRule2 = new FuzzyRule(2, iferrornegativeAndderrorkosong, thenmotorsSRight);
  fuzzy->addFuzzyRule(fuzzyRule2);
  FuzzyRule* fuzzyRule3 = new FuzzyRule(3, iferrornegativeAndderrorpositif, thenmotorsSRight);
  fuzzy->addFuzzyRule(fuzzyRule3);
  FuzzyRule* fuzzyRule4 = new FuzzyRule(4, iferrorzeroAndderrornegatif, thenmotorsSRight);
  fuzzy->addFuzzyRule(fuzzyRule4);
 
  // Building FuzzyRule
  FuzzyRuleAntecedent* iferrorzeroAndderrorkosong = new FuzzyRuleAntecedent();
  iferrorzeroAndderrorkosong->joinWithAND(zero, kosong);

  FuzzyRuleConsequent* thenmotorsStraight = new FuzzyRuleConsequent();
  thenmotorsStraight->addOutput(Straight);

  FuzzyRule* fuzzyRule5 = new FuzzyRule(5, iferrorzeroAndderrorkosong, thenmotorsStraight);
  fuzzy->addFuzzyRule(fuzzyRule5);
 
  // Building FuzzyRule
  FuzzyRuleAntecedent* iferrorzeroAndderrorpositif = new FuzzyRuleAntecedent();
  iferrorzeroAndderrorpositif->joinWithAND(zero, positif);
  FuzzyRuleAntecedent* iferrorpositiveAndderrornegatif = new FuzzyRuleAntecedent();
  iferrorpositiveAndderrornegatif->joinWithAND(positive, negatif);
  FuzzyRuleAntecedent* iferrorpositiveAndderrorkosong = new FuzzyRuleAntecedent();
  iferrorpositiveAndderrorkosong->joinWithAND(positive, kosong);
 
  FuzzyRuleConsequent* thenmotorsSLeft = new FuzzyRuleConsequent();
  thenmotorsSLeft->addOutput(SLeft);
 
  FuzzyRule* fuzzyRule6 = new FuzzyRule(6, iferrorzeroAndderrorpositif, thenmotorsSLeft);
  fuzzy->addFuzzyRule(fuzzyRule6);
  FuzzyRule* fuzzyRule7 = new FuzzyRule(7, iferrorpositiveAndderrornegatif, thenmotorsSLeft);
  fuzzy->addFuzzyRule(fuzzyRule7);
  FuzzyRule* fuzzyRule8 = new FuzzyRule(8, iferrorpositiveAndderrorkosong, thenmotorsSLeft);
  fuzzy->addFuzzyRule(fuzzyRule8);
 
  // Building FuzzyRule
  FuzzyRuleAntecedent* iferrorpositiveAndderrorpositif = new FuzzyRuleAntecedent();
  iferrorpositiveAndderrorpositif->joinWithAND(positive, positif);

  FuzzyRuleConsequent* thenmotorsHLeft = new FuzzyRuleConsequent();
  thenmotorsHLeft->addOutput(HLeft);

  FuzzyRule* fuzzyRule9 = new FuzzyRule(9, iferrorpositiveAndderrorpositif, thenmotorsHLeft);
  fuzzy->addFuzzyRule(fuzzyRule9);
}

void loop()
{
  getvalue();
  float error = val - 0.4688;
  float derror = error - lastError;
  lastError = error;
 
  Serial.print("Value:");
  Serial.println(val);
  Serial.print("Error:");
  Serial.println(error);
  Serial.print("Derror:");
  Serial.println(derror);
 
  fuzzy->setInput(1,error);
  fuzzy->setInput(2,derror);

  fuzzy->fuzzify();
   
  Serial.print("Error: ");
  Serial.print(negative->getPertinence());
  Serial.print(", ");
  Serial.print(zero->getPertinence());
  Serial.print(", ");
  Serial.println(positive->getPertinence());
   
  Serial.print("Derror: ");
  Serial.print(negatif->getPertinence());
  Serial.print(", ");
  Serial.print(kosong->getPertinence());
  Serial.print(", ");
  Serial.println(positif->getPertinence());

  float motors = fuzzy->defuzzify(1);

  Serial.print("Motors: ");
  Serial.println(motors);

  delay(1000);
}

void getvalue()
{
  float returnVal [32] = {0.0313, 0.0625, 0.0938, 0.1250, 0.1563, 0.1875, 0.2188, 0.2500, 0.2813, 0.3125, 0.3438, 0.3750, 0.4063, 0.4375, 0.4688,
                          0.5000, 0.5313, 0.5625, 0.5938, 0.6250, 0.6563, 0.6875, 0.7188, 0.7500, 0.7813, 0.8125, 0.8438, 0.8750, 0.9063, 0.9375, 0.9688, 1.0000};
  int index = (digitalRead (DS_L)<<4) | (digitalRead (DS_ML)<<3) | (digitalRead (DS_M)<< 2) | (digitalRead (DS_MR)<< 1) | digitalRead (DS_R);
  val = returnVal [index];
}

muhaimin89

anybody know how to use this http://www.makeproto.com/projects/fuzzy/matlab_arduino_FIST/index.php i did not know how to put it into programming.. maybe some tutorial could be good for me..

AWOL

Shorter still.
uncompiled, untested
Code: [Select]
float getvalue()
{
  int index = (digitalRead (DS_L)<<4) | (digitalRead (DS_ML)<<3) | (digitalRead (DS_M)<< 2) | (digitalRead (DS_MR)<< 1) | digitalRead (DS_R);
  return (float)(index + 1) / 32.0;
}
"Pete, it's a fool looks for logic in the chambers of the human heart." Ulysses Everett McGill.
Do not send technical questions via personal messaging - they will be ignored.

Go Up