/*
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.
*/

// Termasuk dalam eFLL
#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>
#include <LiquidCrystal_I2C.h>
/*
Pada program ini menggunakan pustaka eFLL (Embedded Fuzzy Logic Library) untuk 
mengimplementasikan logika fuzzy. Library ini memungkinkan untuk mendefinisikan
variabel fuzzy, aturan fuzzy, dan melakukan inferensi fuzzy.
*/

// Pin
#define LDR A0
#define TRIGGER 4
#define ECHO 5
#define LED 6
/*
Kode di atas merupakan bagian dari program dari Arduino yang digunakan untuk 
mendefinisikan pin dalam proyek berbasis Arduino.
*/

LiquidCrystal_I2C lcd(0x27, 20, 4);

// Objek pilihan pustaka Fuzzy
Fuzzy *fuzzy = new Fuzzy();

void setup() {
    // Mengatur komunikasi serial dan mode pin
    Serial.begin(9600);
  lcd.begin(16, 2);  // Initialize the LCD 
  lcd.backlight();  // To power ON the backlight
    pinMode(LDR, INPUT);
    pinMode(TRIGGER, OUTPUT);
    pinMode(ECHO, INPUT);
    pinMode(LED, OUTPUT);
   /*
Kode void setup() di atas digunakan untuk menginisialisasi perangkat keras (hardware) 
pada Arduino sebelum program utama (loop()) berjalan.
   */

    // Himpuan Fuzzy
    // Jarak (0–400 cm di Wokwi)
    FuzzySet *kecil = new FuzzySet(0, 0, 0, 120);
    FuzzySet *sedang = new FuzzySet(60, 120, 120, 180);
    FuzzySet *besar = new FuzzySet(120, 180, 180, 240);
    FuzzySet *sangatBesar = new FuzzySet(180, 240, 400, 400);
   /*
Kode di atas merupakan bagian dari program yang menggunakan logika Fuzzy 
untuk menentukan kategori jarak berdasarkan nilai dalam rentang 0–400 cm.
   */

    // LDR (0-1023 di Wokwi)
    FuzzySet *rendahLdr = new FuzzySet(0, 0, 0, 100);
    FuzzySet *sedangLdr = new FuzzySet(60, 200, 500, 700);
    FuzzySet *tinggiLdr = new FuzzySet(400, 700, 1015, 1015);
   /*
Kode di atas merupakan bagian dari sistem logika fuzzy yang digunakan untuk 
mengkategorikan nilai dari LDR (Light Dependent Resistor), yang merupakan sensor cahaya.
   */

    // Kecerahan
    FuzzySet *mati = new FuzzySet(0, 0, 0, 0);
    FuzzySet *rendahK = new FuzzySet(0, 0, 25, 100);
    FuzzySet *sedangK = new FuzzySet(55, 100, 155, 200);
    FuzzySet *tinggiK = new FuzzySet(155, 230, 255, 255);
   /*
Kode di atas mendefinisikan himpunan fuzzy untuk kecerahan (brightness), yang 
digunakan untuk mengontrol intensitas cahaya pada lampu LED atau perangkat lainnya. 
Kecerahan biasanya memiliki nilai antara 0 hingga 255, yang umum dalam sistem 
PWM (Pulse Width Modulation) pada Arduino.
   */

    // Variabel Fuzzy
    // Variabel jarak dengan semesta 0-400 sebagai input
    FuzzyInput *jarak = new FuzzyInput(1);
    jarak->addFuzzySet(kecil);
    jarak->addFuzzySet(sedang);
    jarak->addFuzzySet(besar);
    jarak->addFuzzySet(sangatBesar);
    fuzzy->addFuzzyInput(jarak);
   /*
Kode di atas mendefinisikan variabel fuzzy bernama jarak, yang digunakan sebagai 
input dalam sistem logika fuzzy dengan rentang nilai 0-400 cm. Program ini digunakan 
dalam sistem berbasis sensor jarak, seperti sensor ultrasonik HC-SR04.
   */

    // Variabel LDR dengan semesta 0-1015 sebagai input
    FuzzyInput *ldr = new FuzzyInput(2);
    ldr->addFuzzySet(rendahLdr);
    ldr->addFuzzySet(sedangLdr);
    ldr->addFuzzySet(tinggiLdr);
    fuzzy->addFuzzyInput(ldr);
    /*
Kode di atas merupakan bagian dari program yang menggunakan logika fuzzy untuk 
menangani variabel input berbasis sensor cahaya (LDR).
    */

    // Variabel kecerahan dengan semesta 0-255 sebagai output
    FuzzyOutput *kecerahan = new FuzzyOutput(1);
    kecerahan->addFuzzySet(mati);
    kecerahan->addFuzzySet(rendahK);
    kecerahan->addFuzzySet(sedangK);
    kecerahan->addFuzzySet(tinggiK);
    fuzzy->addFuzzyOutput(kecerahan);
    /*
Kode di atas digunakan untuk mengontrol kecerahan berdasarkan input tertentu 
(misalnya dari sensor LDR).
    */

    // Aturan Fuzzy
    // Aturan 1
    // Jika jarak kecil dan LDR rendah maka kecerahan tinggi
    FuzzyRuleAntecedent *jikaJarakKecilDanLdrRendah = new FuzzyRuleAntecedent();
    jikaJarakKecilDanLdrRendah->joinWithAND(kecil, rendahLdr);
    FuzzyRuleConsequent *makaKecerahanTinggi = new FuzzyRuleConsequent();
    makaKecerahanTinggi->addOutput(tinggiK);
    FuzzyRule *aturan1 = new FuzzyRule(1, jikaJarakKecilDanLdrRendah, makaKecerahanTinggi);
    fuzzy->addFuzzyRule(aturan1);
    /*
Program di atas digunakan untuk mengatur kecerahan berdasarkan dua input yaitu jarak 
dan LDR (Light Dependent Resistor).Program ini terdapat aturan fuzzy (fuzzy rule) 
yang menghubungkan kondisi dua input tersebut untuk menghasilkan suatu output.
    */

    // Aturan 2
    // Jika jarak kecil dan LDR tinggi maka kecerahan mati
    FuzzyRuleAntecedent *jikaJarakKecilDanLdrTinggi = new FuzzyRuleAntecedent();
    jikaJarakKecilDanLdrTinggi->joinWithAND(kecil, tinggiLdr);
    FuzzyRuleConsequent *makaKecerahanMati = new FuzzyRuleConsequent();
    makaKecerahanMati->addOutput(mati);
    FuzzyRule *aturan2 = new FuzzyRule(2, jikaJarakKecilDanLdrTinggi, makaKecerahanMati);
    fuzzy->addFuzzyRule(aturan2);
    /*
Program di atas adalah aturan kedua dalam sistem logika fuzzy untuk mengatur 
kecerahan berdasarkan dua input yaitu jarak dan LDR (Light Dependent Resistor). Pada aturan ini, jika kondisi 
tertentu terpenuhi, maka output kecerahan akan dimatikan.
    */

    // Aturan 3
    // Jika jarak sedang maka kecerahan sedang
    FuzzyRuleAntecedent *jikaJarakSedang = new FuzzyRuleAntecedent();
    jikaJarakSedang->joinSingle(sedang);
    FuzzyRuleConsequent *makaKecerahanSedang = new FuzzyRuleConsequent();
    makaKecerahanSedang->addOutput(sedangK);
    FuzzyRule *aturan3 = new FuzzyRule(3, jikaJarakSedang, makaKecerahanSedang);
    fuzzy->addFuzzyRule(aturan3);
    /*
Program di atas adalah aturan ketiga dalam sistem logika fuzzy yang digunakan untuk mengatur kecerahan 
berdasarkan input jarak. Pada aturan ini, ketika jarak berada pada level sedang, maka kecerahan juga akan diset
pada level sedang.
    */

    // Aturan 4
    // Jika jarak besar maka kecerahan rendah
    FuzzyRuleAntecedent *jikaJarakBesar = new FuzzyRuleAntecedent();
    jikaJarakBesar->joinSingle(besar);
    FuzzyRuleConsequent *makaKecerahanRendah = new FuzzyRuleConsequent();
    makaKecerahanRendah->addOutput(rendahK);
    FuzzyRule *aturan4 = new FuzzyRule(4, jikaJarakBesar, makaKecerahanRendah);
    fuzzy->addFuzzyRule(aturan4);

    // Aturan 5
    // Jika jarak sangat besar maka kecerahan mati
    FuzzyRuleAntecedent *jikaJarakSangatBesar = new FuzzyRuleAntecedent();
    jikaJarakSangatBesar->joinSingle(sangatBesar);
    FuzzyRuleConsequent *makaKecerahanMati2 = new FuzzyRuleConsequent();
    makaKecerahanMati2->addOutput(mati);
    FuzzyRule *aturan5 = new FuzzyRule(5, jikaJarakSangatBesar, makaKecerahanMati2);
    fuzzy->addFuzzyRule(aturan5);
}

// Fungsi untuk mendapatkan jarak
int jarak() {
    digitalWrite(TRIGGER, LOW);
    delayMicroseconds(5);
    digitalWrite(TRIGGER, HIGH);
    delayMicroseconds(10);
    digitalWrite(TRIGGER, LOW);
    long pulsa = pulseIn(ECHO, HIGH) / 2;
    return pulsa * 10 / 292;
}

// Fungsi untuk mendapatkan nilai LDR
int kecerahan() {
    return analogRead(LDR);
}

// Fungsi utama
void loop() {
    // Mengambil data jarak dan cahaya
    int dist = jarak();
    int cahaya = kecerahan();

    // Jika data tidak valid, abaikan
    if (dist < 0 || dist > 400 || cahaya > 1023) return;

    // Fuzzifikasi
    fuzzy->setInput(1, dist);
    fuzzy->setInput(2, cahaya);
    fuzzy->fuzzify();

    // Defuzzifikasi
    int keluaran = fuzzy->defuzzify(1);

    // Menyalakan LED sesuai keluaran fuzzy
    analogWrite(LED, keluaran);

    // Menampilkan data di Serial Monitor
    Serial.print("Jarak: ");
    Serial.print(dist);
    Serial.print(" cm, Cahaya: ");
    Serial.print(cahaya);
    Serial.print(" => Kecerahan LED: ");
    Serial.println(keluaran);

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("      Hasilnya   ");
  lcd.setCursor(2, 1);
  lcd.print("Jarak : ");
  lcd.print(dist);
  lcd.setCursor(2, 2);
  lcd.print("Kecerahan : ");
  lcd.print(cahaya);
  delay(1000);
    
    delay(100);
}