// ATM Farda , Pajar , Pehan

#include <Fuzzy.h>                //memanggil library untuk logika fungsi fuzzy
#include <FuzzyComposition.h>     // memanggil library yang berfungsi untuk operasi fuzzy variabel fuzzy untuk menghasilkan output yang kita inginkan melalui aturan yang kita terapkan
#include <FuzzyInput.h>           // memanggil library yang berfungsi untuk menyatakan kelas input variabel fuzzy
#include <FuzzyIO.h>              //memanggil library yang bertugas untuk menerima input dari sensor dan menentukan outputnya
#include <FuzzyOutput.h>          // memanggil library yang berfungsi mengolah output dari logika fuzzy
#include <FuzzyRule.h>            // library tempat pemberian aturan untuk mengolah input fuzzy menjadi output fuzzy
#include <FuzzyRuleAntecedent.h>  // library yang mengecek input dan membandingkan ke aturan
#include <FuzzyRuleConsequent.h>  // library yang mengecek perbandingkan input dan aturan dan menentukan output yang didapat
#include <FuzzySet.h>             //menentukan tingkatan anggota dari input yang ada dan memnentukan penempatannya


#define TRIGGER1 4  // pin 4 pada arduino didefinisikan kembali menjadi trigger1
#define ECHO1 5     // pin 5 pada arduino didefinisikan kembali menjadi echo1
#define TRIGGER2 7  // pin 7 pada arduino didefinisikan kembali menjadi trigger2
#define ECHO2 8     // pin 8 pada arduino didefinisikan kembali menjadi echo2
#define LED 6       // pin 6 pada aduino didefinisikan kembali menjadi LED
#define BUZZER 9    // pin 9 pada aduino didefinisikan kembali menjadi LED
Fuzzy *fuzzy = new Fuzzy();


void setup() {
  pinMode(TRIGGER1, OUTPUT);  // penetapan pin 4 (TRIGGER) menjadi output
  pinMode(ECHO1, INPUT);      //penetapan pin 5 (ECHO) menjadi input
  pinMode(TRIGGER2, OUTPUT);  // penetapan pin 7 (TRIGGER) menjadi output
  pinMode(ECHO2, INPUT);      //penetapan pin 8 (ECHO) menjadi input
  pinMode(LED, OUTPUT);       // penetapan pin 6 (LED) menjadi output
  pinMode(BUZZER, OUTPUT);    // penetapan pin 9 (LED) menjadi output
  Serial.begin(9600);

  FuzzySet *Dekat_1 = new FuzzySet(0, 0, 0, 35);
  FuzzySet *Agak_Dekat_1 = new FuzzySet(35, 40, 40, 65);
  FuzzySet *Jauh_1 = new FuzzySet(50, 70, 70, 80);


  FuzzySet *Dekat_2 = new FuzzySet(0, 0, 0, 35);
  FuzzySet *Agak_Dekat_2 = new FuzzySet(35, 40, 40, 65);
  FuzzySet *Jauh_2 = new FuzzySet(50, 70, 70, 80);


  FuzzySet *gelap = new FuzzySet(0, 0, 0, 0);           //pemberian keanggotaan Fuzzyset pertama yaitu gelap untuk output led nanti
  FuzzySet *Sedang = new FuzzySet(0, 100,100 , 155);    //pemberian keanggotaan Fuzzyset kedua yaitu Sedikit_Gelap untuk output led nanti
  FuzzySet *Terang = new FuzzySet(100, 230, 230, 255);  //pemberian keanggotaan Fuzzyset keempat yaitu Terang untuk output led nanti


  FuzzyInput *Jarak_1 = new FuzzyInput(1);  // pendeklarasian universal fuzzygrafik untuk input sensor ultrasonik yang diberinama Jarak dalam bool FuzzyInput(1)
  Jarak_1->addFuzzySet(Dekat_1);
  Jarak_1->addFuzzySet(Agak_Dekat_1);
  Jarak_1->addFuzzySet(Jauh_1);
  fuzzy->addFuzzyInput(Jarak_1);


  FuzzyInput *Jarak_2 = new FuzzyInput(2);  // pendeklarasian universal fuzzygrafik untuk input sensor ultrasonik yang diberinama Jarak dalam bool FuzzyInput(1)
  Jarak_2->addFuzzySet(Dekat_2);
  Jarak_2->addFuzzySet(Agak_Dekat_2);
  Jarak_2->addFuzzySet(Jauh_2);
  fuzzy->addFuzzyInput(Jarak_2);



  FuzzyOutput *LED1 = new FuzzyOutput(1);  // pendeklarasian universal fuzzygrafik untuk output LED yang diberinama Suara dalam bool FuzzyOutput(1)
  LED1->addFuzzySet(gelap);
  LED1->addFuzzySet(Sedang);
  LED1->addFuzzySet(Terang);
  fuzzy->addFuzzyOutput(LED1);


  //aturan 1
  FuzzyRuleAntecedent *S1DS2S = new FuzzyRuleAntecedent();
  S1DS2S->joinWithAND(Dekat_1, Agak_Dekat_2);
  FuzzyRuleConsequent *LT1 = new FuzzyRuleConsequent();
  LT1->addOutput(Terang);
  FuzzyRule *fuzzyRule1 = new FuzzyRule(1, S1DS2S, LT1);
  fuzzy->addFuzzyRule(fuzzyRule1);


  //aturan 2
  FuzzyRuleAntecedent *S1DS2J = new FuzzyRuleAntecedent();
  S1DS2J->joinWithAND(Dekat_1, Jauh_2);
  FuzzyRuleConsequent *LT2 = new FuzzyRuleConsequent();
  LT2->addOutput(Terang);
  FuzzyRule *fuzzyRule2 = new FuzzyRule(2, S1DS2J, LT2);
  fuzzy->addFuzzyRule(fuzzyRule2);


  //aturan 3
  FuzzyRuleAntecedent *S1DS2D = new FuzzyRuleAntecedent();
  S1DS2D->joinWithAND(Dekat_1, Dekat_2);
  FuzzyRuleConsequent *LT3 = new FuzzyRuleConsequent();
  LT3->addOutput(Terang);
  FuzzyRule *fuzzyRule3 = new FuzzyRule(3, S1DS2D, LT3);
  fuzzy->addFuzzyRule(fuzzyRule3);

  //aturan 4
  FuzzyRuleAntecedent *S1SS2D = new FuzzyRuleAntecedent();
  S1SS2D->joinWithAND(Dekat_2,Agak_Dekat_1);
  FuzzyRuleConsequent *LT4 = new FuzzyRuleConsequent();
  LT4->addOutput(Terang);
  FuzzyRule *fuzzyRule4 = new FuzzyRule(4, S1SS2D, LT4);
  fuzzy->addFuzzyRule(fuzzyRule4);


  //aturan 5
  FuzzyRuleAntecedent *S1SS2S = new FuzzyRuleAntecedent();
  S1SS2S->joinWithAND(Agak_Dekat_2, Agak_Dekat_1);
  FuzzyRuleConsequent *LR1 = new FuzzyRuleConsequent();
  LR1->addOutput(Sedang);
  FuzzyRule *fuzzyRule5 = new FuzzyRule(5, S1SS2S, LR1);
  fuzzy->addFuzzyRule(fuzzyRule5);

  //aturan 6
  FuzzyRuleAntecedent *S1SS2J = new FuzzyRuleAntecedent();
  S1SS2J->joinWithAND(Agak_Dekat_1, Jauh_2);
  FuzzyRuleConsequent *LR2 = new FuzzyRuleConsequent();
  LR2->addOutput(Sedang);
  FuzzyRule *fuzzyRule6 = new FuzzyRule(6, S1SS2J, LR2);
  fuzzy->addFuzzyRule(fuzzyRule6);

  FuzzyRuleAntecedent *S1JS2D = new FuzzyRuleAntecedent();
  S1JS2D->joinWithAND(Dekat_2, Jauh_1);
  FuzzyRuleConsequent *LT5 = new FuzzyRuleConsequent();
  LT5->addOutput(Terang);
  FuzzyRule *fuzzyRule7 = new FuzzyRule(7, S1JS2D, LT5);
  fuzzy->addFuzzyRule(fuzzyRule7);


  FuzzyRuleAntecedent *S1JS2S = new FuzzyRuleAntecedent();
  S1JS2S->joinWithAND(Jauh_1, Agak_Dekat_2);
  FuzzyRuleConsequent *LR3 = new FuzzyRuleConsequent();
  LR3->addOutput(Sedang);
  FuzzyRule *fuzzyRule8 = new FuzzyRule(8, S1JS2S, LR3);
  fuzzy->addFuzzyRule(fuzzyRule8);


  FuzzyRuleAntecedent *S1JS2J = new FuzzyRuleAntecedent();
  S1JS2J->joinWithAND(Jauh_1, Jauh_2);
  FuzzyRuleConsequent *LM = new FuzzyRuleConsequent();
  LM->addOutput(gelap);
  FuzzyRule *fuzzyRule9 = new FuzzyRule(9, S1JS2J, LM);
  fuzzy->addFuzzyRule(fuzzyRule9);


  FuzzyRuleAntecedent *JS1 = new FuzzyRuleAntecedent();
  JS1->joinSingle(Dekat_1);
  FuzzyRuleConsequent *LT7 = new FuzzyRuleConsequent();
  LT7->addOutput(Terang);
  FuzzyRule *fuzzyRule10 = new FuzzyRule(10, JS1, LT7);
  fuzzy->addFuzzyRule(fuzzyRule10);


  FuzzyRuleAntecedent *JS2 = new FuzzyRuleAntecedent();
  JS2->joinSingle(Dekat_2);
  FuzzyRuleConsequent *LT6 = new FuzzyRuleConsequent();
  LT6->addOutput(Terang);
  FuzzyRule *fuzzyRule11 = new FuzzyRule(11, JS2, LT6);
  fuzzy->addFuzzyRule(fuzzyRule11);
}

int Jarak_1() {
  digitalWrite(TRIGGER1, LOW);
  delayMicroseconds(5);
  digitalWrite(TRIGGER1, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGER1, LOW);
  long pulse = pulseIn(ECHO1, HIGH) / 2;
  return pulse * 10 / 292;
}


int Jarak_2() {
  digitalWrite(TRIGGER2, LOW);
  delayMicroseconds(5);
  digitalWrite(TRIGGER2, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGER2, LOW);
  long pulse = pulseIn(ECHO2, HIGH) / 2;
  return pulse * 10 / 292;
}



void loop() {

  int distance_1 = Jarak_1();
  int distance_2 = Jarak_2();
  //int SENS = (distance_1 !=  distance_2);


  if (distance_1 < 0 || distance_2 < 0) return;

  fuzzy->setInput(1, distance_1);  // menetapkan nilai distance sebagai set input fuzzy 1
  fuzzy->setInput(2, distance_2);  // menetapkan nilai TheLight sebagai set input fuzzy 2
  //fuzzy->setInput(3, SENS);
  fuzzy->fuzzify();

  int output1 = fuzzy->defuzzify(1);

  analogWrite(LED, output1);


  if (output1 >= 180 && output1 <= 255) {
    digitalWrite(BUZZER, HIGH);  // output tinggi (kterang)
    digitalWrite(LED, HIGH);
    delay(200);
    digitalWrite(BUZZER, LOW);
    digitalWrite(LED, LOW);
  } else if (output1 >= 155 && output1 < 180) {
    digitalWrite(BUZZER, HIGH);  // output sedang (ksedang)
    digitalWrite(LED, HIGH);
    delay(700);
    digitalWrite(BUZZER, LOW);
    digitalWrite(LED, LOW);
  } else if (output1 > 50 && output1 < 155) {
    digitalWrite(BUZZER, HIGH);  // output rendah (kredup)
    delay(1500);
    digitalWrite(BUZZER, LOW);
  } else {
    digitalWrite(BUZZER, LOW);  // output mati (mati)
  }

  Serial.print("  distance_1  > ");
  Serial.print(distance_1);
  Serial.print("  distance_2  > ");
  Serial.print(distance_2);
  Serial.print(" output  ");
  Serial.print(output1);
  Serial.println();
  delay(200);
}