Go Down

Topic: Problem Fuzzy (Read 2705 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.
I speak for myself, not Arduino.

PaulS

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

LOL!
The art of getting good answers lies in asking good questions.

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);

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.
I speak for myself, not Arduino.

Go Up