Pages: [1]   Go Down
Author Topic: Problem Fuzzy  (Read 767 times)
0 Members and 1 Guest are viewing this topic.
Offline Offline
Newbie
*
Karma: 0
Posts: 5
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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

* viva.txt (11.22 KB - downloaded 33 times.)
Logged

Global Moderator
UK
Offline Offline
Brattain Member
*****
Karma: 310
Posts: 26632
I don't think you connected the grounds, Dave.
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Code:
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?
Logged

"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.

Seattle, WA USA
Online Online
Brattain Member
*****
Karma: 653
Posts: 50922
Seattle, WA USA
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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

UK
Offline Offline
Shannon Member
****
Karma: 223
Posts: 12630
-
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Code:
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);
Logged

I only provide help via the forum - please do not contact me for private consultancy.

Offline Offline
Newbie
*
Karma: 0
Posts: 5
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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];
}
Logged

Offline Offline
Newbie
*
Karma: 0
Posts: 5
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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..
Logged

Global Moderator
UK
Offline Offline
Brattain Member
*****
Karma: 310
Posts: 26632
I don't think you connected the grounds, Dave.
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Shorter still.
uncompiled, untested
Code:
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;
}
Logged

"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.

Pages: [1]   Go Up
Jump to: