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

/*
Kode di atas adalah program yang menggunakan pustaka Fuzzy.h 
untuk mengimplementasikan logika fuzzy pada Arduino.
*/

// pin
#define LDR A0 //Pin A0 untuk membaca nilai dari sensor LDR
#define TRIGGER 4 //Pin 4 sebagai Trigger sensor ultrasonik HC-SR04
#define ECHO 5 //Pin 5 sebagai Echo untuk menerima pantulan suara dari sensor ultrasonik
#define LED 6 //Pin 6 untuk mengontrol LED

/*
define digunakan pada program Arduino untuk mendefinisikan 
pin untuk beberapa sensor dan aktuator.
*/

// inisialisasi LCD I2C ukuran 20x4
LiquidCrystal_I2C lcd(0x27, 20, 4);

// Obyek pustaka Fuzzy
Fuzzy *fuzzy = new Fuzzy();

void setup() {
    // set console and pins
    Serial.begin(9600);
    lcd.init();
    lcd.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.
    */

    // himpunan fuzzy
    // jarak (0–400cm di Wokwi)
    FuzzySet *kecil = new FuzzySet(0, 0, 0, 120); // trapezoid MF (a, b, c, d)
    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)
// ldr (0-100000 lux => 1015≈8 nilai resistansi 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 *off = new FuzzySet(0, 0, 0, 0);
FuzzySet *rendahB = new FuzzySet(0, 0, 25, 100);
FuzzySet *sedangB = new FuzzySet(55, 100, 155, 200);
FuzzySet *tinggiB = new FuzzySet(155, 230, 255, 255);

/*
Kode tersebut mendefinisikan himpunan fuzzy untuk kecerahan (brightness), 
yang berfungsi dalam mengatur tingkat intensitas cahaya pada LED atau 
perangkat sejenis. Nilai kecerahan biasanya berkisar antara 0 hingga 255,
yang sering digunakan dalam sistem PWM (Pulse Width Modulation) 
pada Arduino untuk mengontrol kecerahan.
*/

// variabel fuzzy
// variabel jarak sebagai 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 berfungsi 
sebagai input dalam sistem logika fuzzy dengan rentang nilai 0 hingga 400 cm. 
Program ini dirancang untuk digunakan dalam sistem yang mengandalkan 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 
variabel input berbasis sensor cahaya (LDR).
*/

// variabel kecerahan dengan semesta 0-255 sebagai output
FuzzyOutput *kecerahan = new FuzzyOutput(1);
kecerahan->addFuzzySet(off);
kecerahan->addFuzzySet(rendahB);
kecerahan->addFuzzySet(sedangB);
kecerahan->addFuzzySet(tinggiB);
fuzzy->addFuzzyOutput(kecerahan);

/*
Kode di atas digunakan untuk mengontrol kecerahan berdasarkan input tertentu 
(misalnya dari sensor LDR).
*/

// Peraturan 1
// Jika jarak kecil dan LDR rendah maka kecerahan tinggi
FuzzyRuleAntecedent *jikaJarakKecilDanLdrLambat = new FuzzyRuleAntecedent();
jikaJarakKecilDanLdrLambat->joinWithAND(kecil, rendahLdr); // for Potentiometer highLdr, for actual LDR => lowLdr
FuzzyRuleConsequent *setelahituKecerahanTinggi = new FuzzyRuleConsequent();
setelahituKecerahanTinggi->addOutput(tinggiB); // for Potentiometer lowB, for actual LDR => highB
FuzzyRule *fuzzyRule1 = new FuzzyRule(1, jikaJarakKecilDanLdrLambat, setelahituKecerahanTinggi);
fuzzy->addFuzzyRule(fuzzyRule1);

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

// Peraturan 2
// Jika jarak kecil dan LDR tinggi (cahaya terang) maka kecerahan mati
FuzzyRuleAntecedent *jikaJarakKecilDanLdrtinggi = new FuzzyRuleAntecedent();
jikaJarakKecilDanLdrtinggi->joinWithAND(kecil, tinggiLdr);
FuzzyRuleConsequent *setelahituKecerahanOFF = new FuzzyRuleConsequent();
setelahituKecerahanOFF->addOutput(off);
FuzzyRule *fuzzyRule2 = new FuzzyRule(2, jikaJarakKecilDanLdrtinggi, setelahituKecerahanOFF);
fuzzy->addFuzzyRule(fuzzyRule2);

/*
Program tersebut adalah peraturan 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.
*/

// Peraturan 3
// Jika jarak sedang maka kecerahan sedang (sedangB)
FuzzyRuleAntecedent *jikaJarakSedang = new FuzzyRuleAntecedent();
jikaJarakSedang->joinSingle(sedang);
FuzzyRuleConsequent *setelahituKecerahanSedangB = new FuzzyRuleConsequent();
setelahituKecerahanSedangB->addOutput(sedangB);
FuzzyRule *fuzzyRule3 = new FuzzyRule(3, jikaJarakSedang, setelahituKecerahanSedangB);
fuzzy->addFuzzyRule(fuzzyRule3);

/*
Program di atas adalah peraturan 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.
*/

// Peraturan 4
// Jika jarak besar maka kecerahan rendah
FuzzyRuleAntecedent *jikaJarakBesar = new FuzzyRuleAntecedent();
jikaJarakBesar->joinSingle(besar);
FuzzyRuleConsequent *setelahituKecerahanRendah = new FuzzyRuleConsequent();
setelahituKecerahanRendah->addOutput(rendahB);
FuzzyRule *fuzzyRule4 = new FuzzyRule(4, jikaJarakBesar, setelahituKecerahanRendah);
fuzzy->addFuzzyRule(fuzzyRule4);

/*
Program tersebut berisi tentang peraturan keempat dalam sistem logika fuzzy yang mengatur kecerahan 
berdasarkan jarak. Pada aturan ini, jika jarak besar, maka kecerahan rendah.
*/

// Peraturan 5
// Jika jarak sangatbesar, maka kecerahan mati
FuzzyRuleAntecedent *jikaJarakSangatBesar = new FuzzyRuleAntecedent();
jikaJarakSangatBesar->joinSingle(sangatbesar);
FuzzyRuleConsequent *setelahituKecerahanOff2 = new FuzzyRuleConsequent();
setelahituKecerahanOff2->addOutput(off);
FuzzyRule *fuzzyRule5 = new FuzzyRule(5, jikaJarakSangatBesar, setelahituKecerahanOff2);
fuzzy->addFuzzyRule(fuzzyRule5);

/*
Program diatas berisikan tentang peraturan kelima dalam sistem logika fuzzy, yang digunakan untuk 
mengatur kecerahan berdasarkan jarak. Pada aturan ini, ketika jarak sangat besar, maka kecerahan mati.
*/

}


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

    /*
    Program tersebut berisi fungsi untuk mengukur jarak menggunakan sensor ultrasonik HC-SR04 pada 
    mikrokontroler. Sensor ini beroperasi dengan mengirimkan gelombang ultrasonik dan kemudian 
    menghitung waktu yang diperlukan bagi gelombang tersebut untuk memantul kembali setelah mengenai suatu objek.
    */

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

    /*
    Program diatas berisi tentang fungsi untuk membaca nilai dari Light Dependent Resistor (LDR), 
    yang digunakan untuk mengukur tingkat kecerahan cahaya yang diterima oleh sensor. LDR adalah komponen 
    yang nilai resistansinya berubah tergantung pada intensitas cahaya yang diterimanya. Semakin banyak 
    cahaya yang diterima, semakin rendah resistansi LDR, dan sebaliknya.
    */

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

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

    // fuzzifikasi 
    fuzzy->setInput(1, dist);  // jarak sebagai fuzzy input 1 (jarak)
    fuzzy->setInput(2, light); // cahaya sebagai fuzzy input 2 (ldr)
    fuzzy->fuzzify();

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

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

    /*
    Kode diatas merupakan bagian dari pengendalian perangkat keras (LED) berdasarkan hasil dari defuzzifikasi 
    dalam sistem logika fuzzy. Fungsi ini menggunakan output yang dihasilkan dari proses defuzzifikasi 
    untuk mengatur tingkat kecerahan LED.
    */

    // menampilkan data di serial monitor
    Serial.print("jarak: ");
    Serial.print(dist);
    Serial.print(" cahaya: ");
    Serial.print(light);
    Serial.print(" => kecerahan LED: ");
    Serial.println(output);

    /*
    Program diatas merupakan bagian yang bertanggung jawab untuk menampilkan data sensor (jarak dan cahaya) serta 
    nilai keluaran yang dihasilkan dari proses logika fuzzy ke Serial Monitor di Arduino IDE.
    */

    // menampilkan data di LCD I2C
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Jarak     : ");
    lcd.print(dist);
    lcd.setCursor(0, 1);
    lcd.print("Cahaya : ");
    lcd.print(light);
    lcd.setCursor(0, 2);
    lcd.print("Kecerahan LED : ");
    lcd.print(output);
    lcd.setCursor(0,3);
    lcd.print ("....................");
    
    delay(100);

    /*
    Program diatas merupakan bagian untuk menampilkan nilai dari sensor jarak dan cahaya pada LCD (Liquid Crystal Display). 
    LCD ini  berfungsi ntuk melihat informasi secara langsung pada layar dan memberikan beberapa informasi lainnya.
    */

    delay(100);
}