/**
 * Program ini adalah implementasi dari kontroler logika fuzzy 
 * menggunakan Arduino dan beberapa sensor.
 * Tujuannya adalah mengontrol kecerahan lampu LED berdasarkan dua input, yaitu jarak sensor ultrasonik
 * dan nilai sensor LDR (Light Dependent Resistor). 
 * Kontroler logika fuzzy digunakan untuk membuat keputusan berdasarkan
 * aturan-aturan fuzzy yang telah ditentukan. 
 */

// eFLL includes 
#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>

// pins 
#define LDR A0 
#define TRIGGER 4 
#define ECHO 5 
#define LED 6

// object library 
Fuzzy *fuzzy = new Fuzzy();

void setup() {
  // set console and pins 
  Serial.begin(9600);
  pinMode(LDR, INPUT);
  pinMode(TRIGGER, OUTPUT);
  pinMode(ECHO, INPUT);
  pinMode(LED, OUTPUT);

  // fuzzy sets 
  // distance (0-400cm in Wokwi)
  FuzzySet *small = new FuzzySet(0, 0, 0, 120);
  FuzzySet *mid = new FuzzySet(60, 120, 120, 180);
  FuzzySet *big = new FuzzySet(120, 180, 180, 240);
  FuzzySet *verybig = new FuzzySet(180, 240, 400, 400);

  // ldr (0-1023 in Wokwi)
  FuzzySet *lowldr = new FuzzySet(0, 0, 0, 100);
  FuzzySet *midldr = new FuzzySet(60, 200, 500, 700);
  FuzzySet *highldr = new FuzzySet(400, 700, 1015, 1015);

  // brightness
  FuzzySet *off = new FuzzySet(0, 0, 0, 0);
  FuzzySet *lowb = new FuzzySet(0, 0, 25, 100);
  FuzzySet *midb = new FuzzySet(55, 100, 155, 200);
  FuzzySet *highb = new FuzzySet(155, 230, 255, 255);

  // variable distance with universe 0-400 as input
  FuzzyInput *distance = new FuzzyInput(1);
  distance->addFuzzySet(small);
  distance->addFuzzySet(mid);
  distance->addFuzzySet(big);
  distance->addFuzzySet(verybig);
  fuzzy->addFuzzyInput(distance);

  // variable ldr with universe 0-1015 as input
  FuzzyInput *ldr = new FuzzyInput(2);
  ldr->addFuzzySet(lowldr);
  ldr->addFuzzySet(midldr);
  ldr->addFuzzySet(highldr);
  fuzzy->addFuzzyInput(ldr);

  // variable brightness with universe 0-255 as output
  FuzzyOutput *brightness = new FuzzyOutput(1);
  brightness->addFuzzySet(off);
  brightness->addFuzzySet(lowb);
  brightness->addFuzzySet(midb);
  brightness->addFuzzySet(highb);
  fuzzy->addFuzzyOutput(brightness);
  

  FuzzyRuleAntecedent *ifDistanceSmallAndLdrIsLow = new FuzzyRuleAntecedent();
  ifDistanceSmallAndLdrIsLow->joinWithAND(small, lowldr);
  FuzzyRuleConsequent *thenBrightnessHigh = new FuzzyRuleConsequent();
  thenBrightnessHigh->addOutput(highb);
  FuzzyRule *fuzzyRule1 = new FuzzyRule(1, ifDistanceSmallAndLdrIsLow, thenBrightnessHigh);
  fuzzy->addFuzzyRule(fuzzyRule1);

  FuzzyRuleAntecedent *ifDistanceSmallAndLdrIsHigh = new FuzzyRuleAntecedent();
  ifDistanceSmallAndLdrIsHigh->joinWithAND(small, highldr);
  FuzzyRuleConsequent *thenBrightnessOff = new FuzzyRuleConsequent();
  thenBrightnessOff->addOutput(off);
  FuzzyRule *fuzzyRule2 = new FuzzyRule(2, ifDistanceSmallAndLdrIsHigh, thenBrightnessOff);
  fuzzy->addFuzzyRule(fuzzyRule2);

  FuzzyRuleAntecedent *ifDistanceMid = new FuzzyRuleAntecedent();
  ifDistanceMid->joinSingle(mid);
  FuzzyRuleConsequent *thenBrightnessMidb = new FuzzyRuleConsequent();
  thenBrightnessMidb->addOutput(midb);
  FuzzyRule *fuzzyRule3 = new FuzzyRule(3, ifDistanceMid, thenBrightnessMidb);
  fuzzy->addFuzzyRule(fuzzyRule3);

  FuzzyRuleAntecedent *ifDistanceBig = new FuzzyRuleAntecedent();
  ifDistanceBig->joinSingle(big);
  FuzzyRuleConsequent *thenBrightnessLow = new FuzzyRuleConsequent();
  thenBrightnessLow->addOutput(lowb);
  FuzzyRule* fuzzyRule4 = new FuzzyRule(4, ifDistanceBig, thenBrightnessLow);
  fuzzy->addFuzzyRule(fuzzyRule4);

  FuzzyRuleAntecedent *ifDistanceVeryBig = new FuzzyRuleAntecedent();
  ifDistanceVeryBig->joinSingle(verybig);
  FuzzyRule *fuzzyRule5 = new FuzzyRule(5, ifDistanceVeryBig, thenBrightnessOff);
  fuzzy->addFuzzyRule(fuzzyRule5);

}

// returns the distance 
int distance() {
    digitalWrite(TRIGGER, LOW);
    delayMicroseconds(5);
    digitalWrite(TRIGGER, HIGH);
    delayMicroseconds(10);
    digitalWrite(TRIGGER, LOW);
    long pulse = pulseIn(ECHO, HIGH) / 2;
    return pulse * 10 / 292;
}

// returns the brightness 
int brightness() {
    return analogRead(LDR);
}

// main method 
void loop() {
    // get distance and light 
    int dist = distance();
    int light = brightness();

    // if the inputs are weird, ignore them
    if (dist < 0 || dist > 400 || light < 0 || light > 1023) return;

    // fuzzyfication 
    fuzzy->setInput(1, dist);
    fuzzy->setInput(2, light);
    fuzzy->fuzzify();

    // defuzzyfication 
    int output = fuzzy->defuzzify(1);

    analogWrite(LED, output);

    // print values
    Serial.print("distance: ");
    Serial.print(dist);
    Serial.print(" light: ");
    Serial.print(light);
    Serial.print(" => output: ");
    Serial.println(output);

    delay(100);
}