#include "HX711.

h"
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <FuzzyRule.h>
#include <FuzzyComposition.h>
#include <Fuzzy.h>
#include <FuzzyRuleConsequent.h>
#include <FuzzyOutput.h>
#include <FuzzyInput.h>
#include <FuzzyIO.h>
#include <FuzzySet.h>
#include <FuzzyRuleAntecedent.h>

LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Set the LCD I2C

address
float suhu;
int suhuPin = A0;

int kelembaban;
int lembabPin = A2;

int relay = 8;

float keluar1;
int keluar;
int keluar2;

HX711 scale(5, 6);

float calibration_factor = 2300; // this calibration factor is adjusted according
to my load cell
float beban;
float units;
float ounces;
float dryer;
const int durasi = 1;

//-----------------------------------------Set
Fuzzy---------------------------------------
Fuzzy* fuzzy = new Fuzzy();
// Fuzzy input suhu
FuzzySet* dingin = new FuzzySet(20, 20, 28, 30); // suhu dingin
FuzzySet* normal = new FuzzySet(28, 30, 40, 42); // suhu normal
FuzzySet* panas = new FuzzySet(40, 42, 50, 50); // suhu panas

// Fuzzy input kelembaban

FuzzySet* kering = new FuzzySet(10, 10, 16, 20); // kering
FuzzySet* normal1 = new FuzzySet(16, 20, 70, 74); // normal
FuzzySet* basah = new FuzzySet(70, 74, 80, 80); // basah

// Fuzzy input beban

FuzzySet* ringan = new FuzzySet(100, 100, 101, 102); // ringan
FuzzySet* sedang = new FuzzySet(101, 102, 108, 109); // sedang
FuzzySet* berat = new FuzzySet(108, 109, 110, 110); // berat

// Fuzzy output Durasi

FuzzySet* pendek = new FuzzySet(0, 0, 2, 2.5); // durasi pendek
FuzzySet* sedang1= new FuzzySet(2, 2.5, 4.5, 5); // durasi sedang
FuzzySet* panjang = new FuzzySet(4.5, 5, 7, 7); // durasi panjang
//---------------------------------------------------------------------------------
--------

void setup()
{

pinMode(relay, OUTPUT);

pinMode(durasi, OUTPUT);
Serial.begin(9600);
lcd.begin(16,2); // initialize the lcd for 16 chars 2 lines, turn on backlight

scale.set_scale();
scale.tare(); //Reset the scale to 0
long zero_factor = scale.read_average(); //Get a baseline reading
Serial.print("Zero factor: "); //This can be used to remove the need to tare the
scale. Useful in permanent scale projects.
Serial.println(zero_factor);

//---------------------------------------------------------------------------------
--------
//----------------------------------Penambahan Set
Fuzzy-----------------------------------
//---------------------------------------------------------------------------------
--------
FuzzyInput* suhu = new FuzzyInput(1);// Creating a FuzzyInput suhu
suhu->addFuzzySet(dingin); // Add FuzzySet dingin to FuzzyInput suhu
suhu->addFuzzySet(normal); // Add FuzzySet normal to FuzzyInput suhu
suhu->addFuzzySet(panas); // Add FuzzySet panas to FuzzyInput suhu
fuzzy->addFuzzyInput(suhu); // Add FuzzyInput to Fuzzy suhu

FuzzyInput* kelembaban = new FuzzyInput(2);// Creating a FuzzyInput kelembaban

kelembaban->addFuzzySet(kering); // Add FuzzySet kering to FuzzyInput kelembaban
kelembaban->addFuzzySet(normal1); // Add FuzzySet normal to FuzzyInput kelembaban
kelembaban->addFuzzySet(basah); // Add FuzzySet basah to FuzzyInput kelembaban
fuzzy->addFuzzyInput(kelembaban); // Add FuzzyInput to Fuzzy
kelembaban

FuzzyInput* beban = new FuzzyInput(3);// Creating a FuzzyInput beban

beban->addFuzzySet(ringan); // Add FuzzySet ringan to FuzzyInput beban
beban->addFuzzySet(sedang); // Add FuzzySet sedang to FuzzyInput beban
beban->addFuzzySet(berat); // Add FuzzySet berat to FuzzyInput beban
fuzzy->addFuzzyInput(beban); // Add FuzzyInput to Fuzzy beban

FuzzyOutput* dryer = new FuzzyOutput(1);// Creating FuzzyOutput dryer

dryer->addFuzzySet(pendek); // Add FuzzySet durasi pendek
dryer->addFuzzySet(sedang1); // Add FuzzySet durasi sedang
dryer->addFuzzySet(panjang); // Add FuzzySet durasi panjang
fuzzy->addFuzzyOutput(dryer); // Add FuzzyOutput to Fuzzy durasi
//---------------------------------------------------------------------------------
--------
//====================================== FUZZY RULE
======================================
//---------------------------------------------------------------------------------
--------
//======================================== RULE 1
========================================
FuzzyRuleAntecedent* suhudinginAndkelembabankering = new FuzzyRuleAntecedent();
suhudinginAndkelembabankering->joinWithAND(dingin, kering);
FuzzyRuleAntecedent* bebanringan = new FuzzyRuleAntecedent();
 bebanringan->joinSingle(ringan);
FuzzyRuleAntecedent* ifsuhudinginAndkelembabankeringOrbebanringan = new
FuzzyRuleAntecedent();
ifsuhudinginAndkelembabankeringOrbebanringan-
>joinWithAND(suhudinginAndkelembabankering,bebanringan);
FuzzyRuleConsequent* thendryerpendek = new FuzzyRuleConsequent();
thendryerpendek->addOutput(pendek);
FuzzyRule* fuzzyRule1 = new FuzzyRule(1,
ifsuhudinginAndkelembabankeringOrbebanringan, thendryerpendek);
fuzzy->addFuzzyRule(fuzzyRule1);
//======================================== RULE 2
========================================
suhudinginAndkelembabankering->joinWithAND(dingin, kering);
FuzzyRuleAntecedent* bebansedang = new FuzzyRuleAntecedent();
bebansedang->joinSingle(sedang);
FuzzyRuleAntecedent* ifsuhudinginAndkelembabankeringOrbebansedang = new
FuzzyRuleAntecedent();
ifsuhudinginAndkelembabankeringOrbebansedang-
>joinWithAND(suhudinginAndkelembabankering,bebansedang);
FuzzyRuleConsequent* thendryersedang1 = new FuzzyRuleConsequent();
thendryersedang1->addOutput(sedang1);
FuzzyRule* fuzzyRule2 = new FuzzyRule(2,
ifsuhudinginAndkelembabankeringOrbebansedang, thendryersedang1);
fuzzy->addFuzzyRule(fuzzyRule2);
//======================================== RULE 3
========================================
suhudinginAndkelembabankering->joinWithAND(dingin, kering);
FuzzyRuleAntecedent* bebanberat = new FuzzyRuleAntecedent();
bebanberat->joinSingle(berat);
FuzzyRuleAntecedent* ifsuhudinginAndkelembabankeringOrbebanberat = new
FuzzyRuleAntecedent();
ifsuhudinginAndkelembabankeringOrbebanberat-
>joinWithAND(suhudinginAndkelembabankering,bebanberat);
thendryersedang1->addOutput(sedang1);
FuzzyRule* fuzzyRule3 = new FuzzyRule(3,
ifsuhudinginAndkelembabankeringOrbebanberat, thendryersedang1);
fuzzy->addFuzzyRule(fuzzyRule3);
//======================================== RULE 4
========================================
FuzzyRuleAntecedent* suhudinginAndkelembabannormal1 = new FuzzyRuleAntecedent();
suhudinginAndkelembabannormal1->joinWithAND(dingin, normal1);
bebanringan->joinSingle(ringan);
FuzzyRuleAntecedent* ifsuhudinginAndkelembabannormal1Orbebanringan = new
FuzzyRuleAntecedent();
ifsuhudinginAndkelembabannormal1Orbebanringan-
>joinWithAND(suhudinginAndkelembabannormal1,bebanringan);
thendryersedang1->addOutput(sedang1);
FuzzyRule* fuzzyRule4 = new FuzzyRule(4,
ifsuhudinginAndkelembabannormal1Orbebanringan, thendryersedang1);
fuzzy->addFuzzyRule(fuzzyRule4);
//======================================== RULE 5
========================================
suhudinginAndkelembabannormal1->joinWithAND(dingin, normal1);
FuzzyRuleAntecedent* ifsuhudinginAndkelembabannormal1Orbebansedang = new
FuzzyRuleAntecedent();
ifsuhudinginAndkelembabannormal1Orbebansedang-
>joinWithAND(suhudinginAndkelembabannormal1,bebansedang);
thendryersedang1->addOutput(sedang1);
FuzzyRule* fuzzyRule5 = new FuzzyRule(5,
ifsuhudinginAndkelembabannormal1Orbebansedang, thendryersedang1);
fuzzy->addFuzzyRule(fuzzyRule5);
//======================================== RULE 6
========================================
suhudinginAndkelembabannormal1->joinWithAND(dingin, normal1);
bebanberat->joinSingle(berat);
FuzzyRuleAntecedent* ifsuhudinginAndkelembabannormal1Orbebanberat = new
FuzzyRuleAntecedent();
ifsuhudinginAndkelembabannormal1Orbebanberat-
>joinWithAND(suhudinginAndkelembabannormal1,bebanberat);
FuzzyRuleConsequent* thendryerpanjang = new FuzzyRuleConsequent();
thendryerpanjang->addOutput(panjang);
FuzzyRule* fuzzyRule6 = new FuzzyRule(6,
ifsuhudinginAndkelembabannormal1Orbebanberat, thendryerpanjang);
fuzzy->addFuzzyRule(fuzzyRule6);
//======================================== RULE 7
========================================
FuzzyRuleAntecedent* suhudinginAndkelembabanbasah = new FuzzyRuleAntecedent();
suhudinginAndkelembabanbasah->joinWithAND(dingin, basah);
bebanringan->joinSingle(ringan);
FuzzyRuleAntecedent* ifsuhudinginAndkelembabanbasahOrbebanringan = new
FuzzyRuleAntecedent();
ifsuhudinginAndkelembabanbasahOrbebanringan-
>joinWithAND(suhudinginAndkelembabanbasah,bebanringan);
thendryerpanjang->addOutput(panjang);
FuzzyRule* fuzzyRule7 = new FuzzyRule(7,
ifsuhudinginAndkelembabanbasahOrbebanringan, thendryerpanjang);
fuzzy->addFuzzyRule(fuzzyRule7);
//======================================== RULE 8
========================================
suhudinginAndkelembabanbasah->joinWithAND(dingin, basah);
bebansedang->joinSingle(sedang);
FuzzyRuleAntecedent* ifsuhudinginAndkelembabanbasahOrbebansedang = new
FuzzyRuleAntecedent();
ifsuhudinginAndkelembabanbasahOrbebansedang-
>joinWithAND(suhudinginAndkelembabanbasah,bebansedang);
thendryerpanjang->addOutput(panjang);
FuzzyRule* fuzzyRule8 = new FuzzyRule(8,
ifsuhudinginAndkelembabanbasahOrbebansedang, thendryerpanjang);
fuzzy->addFuzzyRule(fuzzyRule8);
//======================================== RULE 9
========================================
suhudinginAndkelembabanbasah->joinWithAND(dingin, basah);
bebanberat->joinSingle(berat);
FuzzyRuleAntecedent* ifsuhudinginAndkelembabanbasahOrbebanberat = new
FuzzyRuleAntecedent();
ifsuhudinginAndkelembabanbasahOrbebanberat-
>joinWithAND(suhudinginAndkelembabanbasah,bebanberat);
thendryerpanjang->addOutput(panjang);
FuzzyRule* fuzzyRule9 = new FuzzyRule(9,
ifsuhudinginAndkelembabanbasahOrbebanberat, thendryerpanjang);
fuzzy->addFuzzyRule(fuzzyRule9);
//======================================== RULE 10
========================================
FuzzyRuleAntecedent* suhunormalAndkelembabankering = new FuzzyRuleAntecedent();
suhunormalAndkelembabankering->joinWithAND(normal, kering);
bebanringan->joinSingle(ringan);
FuzzyRuleAntecedent* ifsuhunormalAndkelembabankeringOrbebanringan = new
FuzzyRuleAntecedent();
 ifsuhunormalAndkelembabankeringOrbebanringan-
>joinWithAND(suhunormalAndkelembabankering,bebanringan);
thendryerpendek->addOutput(pendek);
FuzzyRule* fuzzyRule10 = new FuzzyRule(10,
ifsuhunormalAndkelembabankeringOrbebanringan, thendryerpendek);
fuzzy->addFuzzyRule(fuzzyRule10);
//======================================== RULE 11
========================================
suhunormalAndkelembabankering->joinWithAND(normal, kering);
bebansedang->joinSingle(sedang);
FuzzyRuleAntecedent* ifsuhunormalAndkelembabankeringOrbebansedang = new
FuzzyRuleAntecedent();
ifsuhunormalAndkelembabankeringOrbebansedang-
>joinWithAND(suhunormalAndkelembabankering,bebansedang);
thendryersedang1->addOutput(sedang1);
FuzzyRule* fuzzyRule11 = new FuzzyRule(11,
ifsuhunormalAndkelembabankeringOrbebansedang, thendryersedang1);
fuzzy->addFuzzyRule(fuzzyRule11);
//======================================== RULE 12
========================================
suhunormalAndkelembabankering->joinWithAND(normal, kering);
bebanberat->joinSingle(berat);
FuzzyRuleAntecedent* ifsuhunormalAndkelembabankeringOrbebanberat = new
FuzzyRuleAntecedent();
ifsuhunormalAndkelembabankeringOrbebanberat-
>joinWithAND(suhunormalAndkelembabankering,bebanberat);
FuzzyRuleConsequent* thendryerberat1 = new FuzzyRuleConsequent();
thendryersedang1->addOutput(sedang1);
FuzzyRule* fuzzyRule12 = new FuzzyRule(12,
ifsuhunormalAndkelembabankeringOrbebanberat, thendryersedang1);
fuzzy->addFuzzyRule(fuzzyRule12);
//======================================== RULE 13
========================================
FuzzyRuleAntecedent* suhunormalAndkelembabannormal1 = new FuzzyRuleAntecedent();
suhunormalAndkelembabannormal1->joinWithAND(normal, normal1);
bebanringan->joinSingle(ringan);
FuzzyRuleAntecedent* ifsuhunormalAndkelembabannormal1Orbebanringan = new
FuzzyRuleAntecedent();
ifsuhunormalAndkelembabannormal1Orbebanringan-
>joinWithAND(suhunormalAndkelembabannormal1,bebanringan);
thendryersedang1->addOutput(sedang1);
FuzzyRule* fuzzyRule13 = new FuzzyRule(13,
ifsuhunormalAndkelembabannormal1Orbebanringan, thendryersedang1);
fuzzy->addFuzzyRule(fuzzyRule13);
//======================================== RULE 14
========================================
suhunormalAndkelembabannormal1->joinWithAND(normal, normal1);
bebansedang->joinSingle(sedang);
FuzzyRuleAntecedent* ifsuhunormalAndkelembabannormal1Orbebansedang = new
FuzzyRuleAntecedent();
ifsuhunormalAndkelembabannormal1Orbebansedang-
>joinWithAND(suhunormalAndkelembabannormal1,bebansedang);
thendryersedang1->addOutput(sedang1);
FuzzyRule* fuzzyRule14 = new FuzzyRule(14,
ifsuhunormalAndkelembabannormal1Orbebansedang, thendryersedang1);
fuzzy->addFuzzyRule(fuzzyRule14);
//======================================== RULE 15
========================================
suhunormalAndkelembabannormal1->joinWithAND(normal, normal1);
 bebanberat->joinSingle(berat);
FuzzyRuleAntecedent* ifsuhunormalAndkelembabannormal1Orbebanberat = new
FuzzyRuleAntecedent();
ifsuhunormalAndkelembabannormal1Orbebanberat-
>joinWithAND(suhunormalAndkelembabannormal1,bebanberat);
thendryersedang1->addOutput(sedang1);
FuzzyRule* fuzzyRule15 = new FuzzyRule(15,
ifsuhunormalAndkelembabannormal1Orbebanberat, thendryersedang1);
fuzzy->addFuzzyRule(fuzzyRule15);
//======================================== RULE 16
========================================
FuzzyRuleAntecedent* suhunormalAndkelembabanbasah = new FuzzyRuleAntecedent();
suhunormalAndkelembabanbasah->joinWithAND(normal, basah);
bebanringan->joinSingle(ringan);
FuzzyRuleAntecedent* ifsuhunormalAndkelembabanbasahOrbebanringan = new
FuzzyRuleAntecedent();
ifsuhunormalAndkelembabanbasahOrbebanringan-
>joinWithAND(suhunormalAndkelembabanbasah,bebanringan);
thendryersedang1->addOutput(sedang1);
FuzzyRule* fuzzyRule16 = new FuzzyRule(16,
ifsuhunormalAndkelembabanbasahOrbebanringan, thendryersedang1);
fuzzy->addFuzzyRule(fuzzyRule16);
//======================================== RULE 17
========================================
suhunormalAndkelembabanbasah->joinWithAND(normal, basah);
bebansedang->joinSingle(sedang);
FuzzyRuleAntecedent* ifsuhunormalAndkelembabanbasahOrbebansedang = new
FuzzyRuleAntecedent();
ifsuhunormalAndkelembabanbasahOrbebansedang-
>joinWithAND(suhunormalAndkelembabanbasah,bebansedang);
thendryersedang1->addOutput(sedang1);
FuzzyRule* fuzzyRule17 = new FuzzyRule(17,
ifsuhunormalAndkelembabanbasahOrbebansedang, thendryersedang1);
fuzzy->addFuzzyRule(fuzzyRule17);
/*/======================================== RULE 18
========================================
suhunormalAndkelembabanbasah->joinWithAND(normal, basah);
bebanberat->joinSingle(berat);
FuzzyRuleAntecedent* ifsuhunormalAndkelembabanbasahOrbebanberat = new
FuzzyRuleAntecedent();
ifsuhunormalAndkelembabanbasahOrbebanberat-
>joinWithAND(suhunormalAndkelembabanbasah,bebanberat);
thendryerpanjang->addOutput(panjang);
FuzzyRule* fuzzyRule18 = new FuzzyRule(18,
ifsuhunormalAndkelembabanbasahOrbebanberat, thendryerpanjang);
fuzzy->addFuzzyRule(fuzzyRule18);
//======================================== RULE 19
========================================
FuzzyRuleAntecedent* suhupanasAndkelembabankering = new FuzzyRuleAntecedent();
suhupanasAndkelembabankering->joinWithAND(panas, kering);
bebanringan->joinSingle(ringan);
FuzzyRuleAntecedent* ifsuhupanasAndkelembabankeringOrbebanringan = new
FuzzyRuleAntecedent();
ifsuhupanasAndkelembabankeringOrbebanringan-
>joinWithAND(suhupanasAndkelembabankering,bebanringan);
thendryerpendek->addOutput(pendek);
FuzzyRule* fuzzyRule19 = new FuzzyRule(19,
ifsuhupanasAndkelembabankeringOrbebanringan, thendryerpendek);
fuzzy->addFuzzyRule(fuzzyRule19);
//======================================== RULE 20
========================================
suhupanasAndkelembabankering->joinWithAND(panas, kering);
bebansedang->joinSingle(sedang);
FuzzyRuleAntecedent* ifsuhupanasAndkelembabankeringOrbebansedang = new
FuzzyRuleAntecedent();
ifsuhupanasAndkelembabankeringOrbebansedang-
>joinWithAND(suhupanasAndkelembabankering,bebansedang);
thendryerpendek->addOutput(pendek);
FuzzyRule* fuzzyRule20 = new FuzzyRule(20,
ifsuhupanasAndkelembabankeringOrbebansedang, thendryerpendek);
fuzzy->addFuzzyRule(fuzzyRule20);
//======================================== RULE 21
========================================
suhupanasAndkelembabankering->joinWithAND(panas, kering);
bebanberat->joinSingle(berat);
FuzzyRuleAntecedent* ifsuhupanasAndkelembabankeringOrbebanberat = new
FuzzyRuleAntecedent();
ifsuhupanasAndkelembabankeringOrbebanberat-
>joinWithAND(suhupanasAndkelembabankering,bebanberat);
thendryerpendek->addOutput(pendek);
FuzzyRule* fuzzyRule21 = new FuzzyRule(21,
ifsuhupanasAndkelembabankeringOrbebanberat, thendryerpendek);
fuzzy->addFuzzyRule(fuzzyRule21);
//======================================== RULE 22
========================================
FuzzyRuleAntecedent* suhupanasAndkelembabannormal1 = new FuzzyRuleAntecedent();
suhupanasAndkelembabannormal1->joinWithAND(panas, normal1);
bebanringan->joinSingle(ringan);
FuzzyRuleAntecedent* ifsuhupanasAndkelembabannormal1Orbebanringan = new
FuzzyRuleAntecedent();
ifsuhupanasAndkelembabannormal1Orbebanringan-
>joinWithAND(suhupanasAndkelembabannormal1,bebanringan);
thendryerpendek->addOutput(pendek);
FuzzyRule* fuzzyRule22 = new FuzzyRule(22,
ifsuhupanasAndkelembabannormal1Orbebanringan, thendryerpendek);
fuzzy->addFuzzyRule(fuzzyRule22);
//======================================== RULE 23
========================================
suhupanasAndkelembabannormal1->joinWithAND(panas, normal1);
bebansedang->joinSingle(sedang);
FuzzyRuleAntecedent* ifsuhupanasAndkelembabannormal1Orbebansedang = new
FuzzyRuleAntecedent();
ifsuhupanasAndkelembabannormal1Orbebansedang-
>joinWithAND(suhupanasAndkelembabannormal1,bebansedang);
thendryersedang1->addOutput(sedang1);
FuzzyRule* fuzzyRule23 = new FuzzyRule(23,
ifsuhupanasAndkelembabannormal1Orbebansedang, thendryersedang1);
fuzzy->addFuzzyRule(fuzzyRule23);
//======================================== RULE 24
========================================
suhupanasAndkelembabannormal1->joinWithAND(panas, normal1);
bebanberat->joinSingle(berat);
FuzzyRuleAntecedent* ifsuhupanasAndkelembabannormal1Orbebanberat = new
FuzzyRuleAntecedent();
ifsuhupanasAndkelembabannormal1Orbebanberat-
>joinWithAND(suhupanasAndkelembabannormal1,bebanberat);
thendryersedang1->addOutput(sedang1);
FuzzyRule* fuzzyRule24 = new FuzzyRule(24,
ifsuhupanasAndkelembabannormal1Orbebanberat, thendryersedang1);
fuzzy->addFuzzyRule(fuzzyRule24);
//======================================== RULE 25
========================================
FuzzyRuleAntecedent* suhupanasAndkelembabanbasah = new FuzzyRuleAntecedent();
suhupanasAndkelembabanbasah->joinWithAND(panas, basah);
bebanringan->joinSingle(ringan);
FuzzyRuleAntecedent* ifsuhupanasAndkelembabanbasahOrbebanringan = new
FuzzyRuleAntecedent();
ifsuhupanasAndkelembabanbasahOrbebanringan-
>joinWithAND(suhupanasAndkelembabanbasah,bebanringan);
thendryersedang1->addOutput(sedang1);
FuzzyRule* fuzzyRule25 = new FuzzyRule(25,
ifsuhupanasAndkelembabanbasahOrbebanringan, thendryersedang1);
fuzzy->addFuzzyRule(fuzzyRule25);
//======================================== RULE 26
========================================
suhupanasAndkelembabanbasah->joinWithAND(panas, basah);
bebansedang->joinSingle(sedang);
FuzzyRuleAntecedent* ifsuhupanasAndkelembabanbasahOrbebansedang = new
FuzzyRuleAntecedent();
ifsuhupanasAndkelembabanbasahOrbebansedang-
>joinWithAND(suhupanasAndkelembabanbasah,bebansedang);
thendryersedang1->addOutput(sedang1);
FuzzyRule* fuzzyRule26 = new FuzzyRule(26,
ifsuhupanasAndkelembabanbasahOrbebansedang, thendryersedang1);
fuzzy->addFuzzyRule(fuzzyRule26);
//======================================== RULE 27
========================================
suhupanasAndkelembabanbasah->joinWithAND(panas, basah);
bebanberat->joinSingle(berat);
FuzzyRuleAntecedent* ifsuhupanasAndkelembabanbasahOrbebanberat = new
FuzzyRuleAntecedent();
ifsuhupanasAndkelembabanbasahOrbebanberat-
>joinWithAND(suhupanasAndkelembabanbasah,bebanberat);
thendryerpanjang->addOutput(panjang);
FuzzyRule* fuzzyRule27 = new FuzzyRule(27,
ifsuhupanasAndkelembabanbasahOrbebanberat, thendryerpanjang);
fuzzy->addFuzzyRule(fuzzyRule27);

*/

}
void loop()
{

digitalWrite(relay, LOW);
//--------------------------------------INPUTAN
SENSOR--------------------------------------
//====================================== sensor berat
======================================
scale.set_scale(calibration_factor); //Adjust to this calibration factor
beban = scale.get_units(), 10;
if (beban < 0)
{
beban = 0.00;
}
ounces = beban * 0.035274-18.9;
//===================================== sensor suhu
=====================================
suhu = analogRead(suhuPin);//membaca nilai adc sensor
suhu = (suhu/1024.0)*3500;//konversi data analog menjadi milivolt
suhu = suhu/10;//konversi kedalam derajat celsius dengan persamaan 1derajat/10mv

//================================== sensor kelembaban

==================================
kelembaban = analogRead(lembabPin);
kelembaban = map(kelembaban,800,1030,100,0);
/*
beban=110;
kelembaban=75;
suhu=30;*/
//-------------------------------------
FUZZIFIKASI--------------------------------------
fuzzy->setInput(1, suhu);
fuzzy->setInput(2, kelembaban);
fuzzy->setInput(3, beban);

//Executing the fuzzification

fuzzy->fuzzify();

//defuzzification
float output = fuzzy->defuzzify(1);
int output1=output*60000;

//----------------------------------TAMPILAN
OUTPUT-----------------------------------
/* digitalWrite(durasi,HIGH);
delay(output1);*/
Serial.print("DURASI "); Serial.print(output); Serial.print(" MENIT");
keluar = output ;

for (keluar2 = keluar; keluar2 >=0 ; keluar2--) {

//----------------------------------TAMPILAN
Detik------------------------------------
lcd.setCursor(0, 0);
lcd.print("W "); lcd.print(keluar2,1);
Serial.print(keluar2);
delay(50);
//----------------------------------TAMPILAN
SUHU-------------------------------------
lcd.setCursor(7, 0);
lcd.print("S "); lcd.print(suhu,1); lcd.print("\xdf"); lcd.print("C");
delay(50);
//-------------------------------TAMPILAN
KELEMBABAN----------------------------------
lcd.setCursor(0, 1);
lcd.print("L "); lcd.print(kelembaban,1); lcd.print("%");
delay(50);
//----------------------------------TAMPILAN
BEBAN------------------------------------
lcd.setCursor(7, 1);
lcd.print("B "); lcd.print(beban,1); lcd.print(" g");
delay(50);
delay(60000);
}
 digitalWrite(relay, HIGH);
delay(5000);
}