Can you help me print the output of the condition i cant seem to do it

[Dozzheesh]

`#include <Fuzzy.h>

// For scope, instantiate all objects you will need to access in loop()
// It may be just one Fuzzy, but for demonstration, this sample will print
// all FuzzySet pertinence

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

// FuzzyInputHB
FuzzySet *veryslow = new FuzzySet(60, 70, 70, 80);
FuzzySet *slow = new FuzzySet(75, 80, 80, 90);
FuzzySet *fast = new FuzzySet(85 ,90, 90, 100);
FuzzySet *veryfast = new FuzzySet(95, 100, 100, 110);

// FuzzyInputTemp
FuzzySet *verycold = new FuzzySet(31, 32, 32, 33);
FuzzySet *cold = new FuzzySet(33,34 , 34, 35);
FuzzySet *hot = new FuzzySet(35, 36, 36, 37);
FuzzySet *veryhot = new FuzzySet(37, 38 , 38, 39);

// FuzzyInputGSR
FuzzySet *verydry= new FuzzySet(0 , 1 , 1 , 2);
FuzzySet *dry = new FuzzySet(1 , 2 , 2, 3);
FuzzySet *moist = new FuzzySet(2 , 3, 3, 4);
FuzzySet *verymoist = new FuzzySet(4 , 5 ,6 , 7);

// Fuzzyoutput
FuzzySet *relax= new FuzzySet(0 , 12.5 , 12.5 , 25);
FuzzySet *tenang = new FuzzySet(25, 37.5, 37.5, 50);
FuzzySet *cemas = new FuzzySet(50, 62.5, 62.5 , 75);
FuzzySet *stress = new FuzzySet(75, 87.5 , 87.5, 100);

void setup()
{
// Set the Serial output
Serial.begin(9600);
// Set a random seed
randomSeed(analogRead(0));

// Every setup must occur in the function setup()

// FuzzyInput
FuzzyInput *Hb = new FuzzyInput(1);

Hb->addFuzzySet(veryslow);
Hb->addFuzzySet(slow);
Hb->addFuzzySet(fast);
Hb->addFuzzySet(veryfast);
fuzzy->addFuzzyInput(Hb);

// FuzzyInput
FuzzyInput *Temp = new FuzzyInput(2);

Temp->addFuzzySet(verycold);
Temp->addFuzzySet(cold);
Temp->addFuzzySet(hot);
Temp->addFuzzySet(veryhot);
fuzzy->addFuzzyInput(Temp);

// FuzzyInput
FuzzyInput *Gsr = new FuzzyInput(3);

Gsr->addFuzzySet(verydry);
Gsr->addFuzzySet(dry);
Gsr->addFuzzySet(moist);
Gsr->addFuzzySet(verymoist);
fuzzy->addFuzzyInput(Gsr);

// FuzzyOutput
FuzzyOutput *Condition = new FuzzyOutput(1);

Condition->addFuzzySet(relax);
Condition->addFuzzySet(tenang);
Condition->addFuzzySet(cemas);
Condition->addFuzzySet(stress);
fuzzy->addFuzzyOutput(Condition);

// Building FuzzyRule

FuzzyRuleAntecedent *HbveryslowAndTempveryhot = new FuzzyRuleAntecedent();
HbveryslowAndTempveryhot->joinWithAND(veryslow, veryhot);
FuzzyRuleAntecedent *IfHbveryslowAndTempveryhotAndGsrverydry = new FuzzyRuleAntecedent();
IfHbveryslowAndTempveryhotAndGsrverydry->joinWithAND(HbveryslowAndTempveryhot, verydry);

FuzzyRuleConsequent *thenConditionrelax = new FuzzyRuleConsequent();
thenConditionrelax->addOutput(relax);

FuzzyRule *fuzzyRule1 = new FuzzyRule(1, IfHbveryslowAndTempveryhotAndGsrverydry, thenConditionrelax);
fuzzy->addFuzzyRule(fuzzyRule1);

// Building FuzzyRule 2

FuzzyRuleAntecedent *HbveryslowAndTemphot = new FuzzyRuleAntecedent();
HbveryslowAndTemphot->joinWithAND(veryslow, hot);
FuzzyRuleAntecedent *IfHbveryslowAndTemphotAndGsrverydry = new FuzzyRuleAntecedent();
IfHbveryslowAndTemphotAndGsrverydry->joinWithAND(HbveryslowAndTemphot, verydry);

FuzzyRule *fuzzyRule2 = new FuzzyRule(2, IfHbveryslowAndTemphotAndGsrverydry, thenConditionrelax);
fuzzy->addFuzzyRule(fuzzyRule2);

// Building FuzzyRule 3

FuzzyRuleAntecedent *HbveryslowAndTempcold = new FuzzyRuleAntecedent();
HbveryslowAndTempcold->joinWithAND(veryslow, cold);
FuzzyRuleAntecedent *IfHbveryslowAndTempcoldAndGsrverydry = new FuzzyRuleAntecedent();
IfHbveryslowAndTempcoldAndGsrverydry->joinWithAND(HbveryslowAndTempcold, verydry);

FuzzyRuleConsequent *thenConditiontenang = new FuzzyRuleConsequent();
thenConditionrelax->addOutput(tenang);

FuzzyRule *fuzzyRule3 = new FuzzyRule(3, IfHbveryslowAndTempcoldAndGsrverydry, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule3);

// Building FuzzyRule 4

FuzzyRuleAntecedent *HbveryslowAndTempverycold = new FuzzyRuleAntecedent();
HbveryslowAndTempverycold->joinWithAND(veryslow, verycold);
FuzzyRuleAntecedent *IfHbveryslowAndTempverycoldAndGsrverydry = new FuzzyRuleAntecedent();
IfHbveryslowAndTempverycoldAndGsrverydry->joinWithAND(HbveryslowAndTempverycold, verydry);

FuzzyRuleConsequent *thenConditioncemas = new FuzzyRuleConsequent();
thenConditioncemas->addOutput(cemas);

FuzzyRule *fuzzyRule4 = new FuzzyRule(4, IfHbveryslowAndTempverycoldAndGsrverydry, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule4);

// Building FuzzyRule 5

FuzzyRuleAntecedent *HbslowAndTempveryhot = new FuzzyRuleAntecedent();
HbslowAndTempveryhot->joinWithAND(slow, veryhot);
FuzzyRuleAntecedent *IfHbslowAndTempveryhotAndGsrverydry = new FuzzyRuleAntecedent();
IfHbslowAndTempveryhotAndGsrverydry->joinWithAND(HbslowAndTempveryhot, verydry);

FuzzyRule *fuzzyRule5 = new FuzzyRule(5, IfHbslowAndTempveryhotAndGsrverydry, thenConditionrelax);
fuzzy->addFuzzyRule(fuzzyRule5);

// Building FuzzyRule 6

FuzzyRuleAntecedent *HbslowAndTemphot = new FuzzyRuleAntecedent();
HbslowAndTemphot->joinWithAND(slow, hot);
FuzzyRuleAntecedent *IfHbslowAndTemphotAndGsrverydry = new FuzzyRuleAntecedent();
IfHbslowAndTemphotAndGsrverydry->joinWithAND(HbslowAndTemphot, verydry);

FuzzyRule *fuzzyRule6 = new FuzzyRule(6, IfHbslowAndTemphotAndGsrverydry, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule6);

// Building FuzzyRule 7

FuzzyRuleAntecedent *HbslowAndTempcold = new FuzzyRuleAntecedent();
HbslowAndTempcold->joinWithAND(slow, cold);
FuzzyRuleAntecedent *IfHbslowAndTempcoldAndGsrverydry = new FuzzyRuleAntecedent();
IfHbslowAndTempcoldAndGsrverydry->joinWithAND(HbslowAndTempcold, verydry);

FuzzyRule *fuzzyRule7 = new FuzzyRule(7, IfHbslowAndTempcoldAndGsrverydry, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule7);

// Building FuzzyRule 8

FuzzyRuleAntecedent *HbslowAndTempverycold = new FuzzyRuleAntecedent();
HbslowAndTempverycold->joinWithAND(slow, verycold);
FuzzyRuleAntecedent *IfHbslowAndTempverycoldAndGsrverydry = new FuzzyRuleAntecedent();
IfHbslowAndTempcoldAndGsrverydry->joinWithAND(HbslowAndTempverycold, verydry);

FuzzyRule *fuzzyRule8 = new FuzzyRule(8, IfHbslowAndTempcoldAndGsrverydry, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule8);

// Building FuzzyRule 9

FuzzyRuleAntecedent *HbfastAndTempveryhot = new FuzzyRuleAntecedent();
HbfastAndTempveryhot->joinWithAND(fast, veryhot);
FuzzyRuleAntecedent *IfHbfastAndTempveryhotAndGsrverydry = new FuzzyRuleAntecedent();
IfHbfastAndTempveryhotAndGsrverydry->joinWithAND(HbfastAndTempveryhot, verydry);

FuzzyRule *fuzzyRule9 = new FuzzyRule(9, IfHbfastAndTempveryhotAndGsrverydry, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule9);

// Building FuzzyRule 10

FuzzyRuleAntecedent *HbfastAndTemphot = new FuzzyRuleAntecedent();
HbfastAndTemphot->joinWithAND(fast, hot);
FuzzyRuleAntecedent *IfHbfastAndTemphotAndGsrverydry = new FuzzyRuleAntecedent();
IfHbfastAndTemphotAndGsrverydry->joinWithAND(HbfastAndTemphot, verydry);

FuzzyRule *fuzzyRule10 = new FuzzyRule(10, IfHbfastAndTemphotAndGsrverydry, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule10);

// Building FuzzyRule 11

FuzzyRuleAntecedent *HbfastAndTempcold = new FuzzyRuleAntecedent();
HbfastAndTempcold->joinWithAND(fast, cold);
FuzzyRuleAntecedent *IfHbfastAndTempcoldAndGsrverydry = new FuzzyRuleAntecedent();
IfHbfastAndTempcoldAndGsrverydry->joinWithAND(HbfastAndTempcold, verydry);

FuzzyRule *fuzzyRule11 = new FuzzyRule(11, IfHbfastAndTempcoldAndGsrverydry, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule11);

// Building FuzzyRule 12

FuzzyRuleAntecedent *HbfastAndTempverycold = new FuzzyRuleAntecedent();
HbfastAndTempverycold->joinWithAND(fast, verycold);
FuzzyRuleAntecedent *IfHbfastAndTempverycoldAndGsrverydry = new FuzzyRuleAntecedent();
IfHbfastAndTempverycoldAndGsrverydry->joinWithAND(HbfastAndTempverycold, verydry);

FuzzyRule *fuzzyRule12 = new FuzzyRule(12, IfHbfastAndTempverycoldAndGsrverydry, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule12);

// Building FuzzyRule 13

FuzzyRuleAntecedent *HbveryfastAndTempveryhot = new FuzzyRuleAntecedent();
HbveryfastAndTempveryhot->joinWithAND(veryfast, veryhot);
FuzzyRuleAntecedent *IfHbveryfastAndTempveryhotAndGsrverydry = new FuzzyRuleAntecedent();
IfHbveryfastAndTempveryhotAndGsrverydry->joinWithAND(HbveryfastAndTempveryhot, verydry);

FuzzyRule *fuzzyRule13 = new FuzzyRule(13, IfHbveryfastAndTempveryhotAndGsrverydry, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule13);

  // Building FuzzyRule 14

FuzzyRuleAntecedent *HbveryfastAndTemphot = new FuzzyRuleAntecedent();
HbveryfastAndTemphot->joinWithAND(veryfast, hot);
FuzzyRuleAntecedent *IfHbveryfastAndTemphotAndGsrverydry = new FuzzyRuleAntecedent();
IfHbveryfastAndTemphotAndGsrverydry->joinWithAND(HbveryfastAndTemphot, verydry);

FuzzyRule *fuzzyRule14 = new FuzzyRule(14, IfHbveryfastAndTemphotAndGsrverydry, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule14);

    // Building FuzzyRule 15

FuzzyRuleAntecedent *HbveryfastAndTempcold = new FuzzyRuleAntecedent();
HbveryfastAndTempcold->joinWithAND(veryfast, cold);
FuzzyRuleAntecedent *IfHbveryfastAndTempcoldAndGsrverydry = new FuzzyRuleAntecedent();
IfHbveryfastAndTempcoldAndGsrverydry->joinWithAND(HbveryfastAndTempcold, verydry);

FuzzyRule *fuzzyRule15 = new FuzzyRule(15, IfHbveryfastAndTempcoldAndGsrverydry, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule15);

      // Building FuzzyRule 16

FuzzyRuleAntecedent *HbveryfastAndTempverycold = new FuzzyRuleAntecedent();
HbveryfastAndTempverycold->joinWithAND(veryfast, verycold);
FuzzyRuleAntecedent *IfHbveryfastAndTempverycoldAndGsrverydry = new FuzzyRuleAntecedent();
IfHbveryfastAndTempverycoldAndGsrverydry->joinWithAND(HbveryfastAndTempverycold, verydry);

FuzzyRule *fuzzyRule16 = new FuzzyRule(16, IfHbveryfastAndTempverycoldAndGsrverydry, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule16);

// Building FuzzyRule 17

HbveryslowAndTempveryhot->joinWithAND(veryslow, veryhot);
FuzzyRuleAntecedent *IfHbveryslowAndTempveryhotAndGsrdry = new FuzzyRuleAntecedent();
IfHbveryslowAndTempveryhotAndGsrdry->joinWithAND(HbveryslowAndTempveryhot, dry);

FuzzyRule *fuzzyRule17 = new FuzzyRule(17, IfHbveryslowAndTempveryhotAndGsrdry, thenConditionrelax);
fuzzy->addFuzzyRule(fuzzyRule17);

// Building FuzzyRule 18

HbveryslowAndTemphot->joinWithAND(veryslow, hot);
FuzzyRuleAntecedent *IfHbveryslowAndTemphotAndGsrdry = new FuzzyRuleAntecedent();
IfHbveryslowAndTemphotAndGsrdry->joinWithAND(HbveryslowAndTemphot, dry);

FuzzyRule *fuzzyRule18 = new FuzzyRule(18, IfHbveryslowAndTemphotAndGsrdry, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule18);

// Building FuzzyRule 19

HbveryslowAndTempcold->joinWithAND(veryslow, cold);
FuzzyRuleAntecedent *IfHbveryslowAndTempcoldAndGsrdry = new FuzzyRuleAntecedent();
IfHbveryslowAndTempcoldAndGsrdry->joinWithAND(HbveryslowAndTempcold, dry);

FuzzyRule *fuzzyRule19 = new FuzzyRule(19, IfHbveryslowAndTempcoldAndGsrdry, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule19);

// Building FuzzyRule 20

HbveryslowAndTempverycold->joinWithAND(veryslow, verycold);
FuzzyRuleAntecedent *IfHbveryslowAndTempverycoldAndGsrdry = new FuzzyRuleAntecedent();
IfHbveryslowAndTempverycoldAndGsrdry->joinWithAND(HbveryslowAndTempverycold, dry);

FuzzyRule *fuzzyRule20 = new FuzzyRule(20, IfHbveryslowAndTempverycoldAndGsrdry, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule20);

// Building FuzzyRule 21

HbslowAndTempveryhot->joinWithAND(slow, veryhot);
FuzzyRuleAntecedent *IfHbslowAndTempveryhotAndGsrdry = new FuzzyRuleAntecedent();
IfHbslowAndTempveryhotAndGsrdry->joinWithAND(HbslowAndTempveryhot, dry);

FuzzyRule *fuzzyRule21 = new FuzzyRule(21, IfHbslowAndTempveryhotAndGsrdry, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule21);

// Building FuzzyRule 22

HbslowAndTemphot->joinWithAND(slow, hot);
FuzzyRuleAntecedent *IfHbslowAndTemphotAndGsrdry = new FuzzyRuleAntecedent();
IfHbslowAndTemphotAndGsrdry->joinWithAND(HbslowAndTemphot, dry);

FuzzyRule *fuzzyRule22 = new FuzzyRule(22, IfHbslowAndTemphotAndGsrdry, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule22);

// Building FuzzyRule 23

HbslowAndTempcold->joinWithAND(slow, cold);
FuzzyRuleAntecedent *IfHbslowAndTempcoldAndGsrdry = new FuzzyRuleAntecedent();
IfHbslowAndTempcoldAndGsrdry->joinWithAND(HbslowAndTempcold, dry);

FuzzyRule *fuzzyRule23 = new FuzzyRule(23, IfHbslowAndTempcoldAndGsrdry, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule23);

// Building FuzzyRule 24

HbslowAndTempverycold->joinWithAND(slow, verycold);
FuzzyRuleAntecedent *IfHbslowAndTempverycoldAndGsrdry = new FuzzyRuleAntecedent();
IfHbslowAndTempverycoldAndGsrdry->joinWithAND(HbslowAndTempverycold, dry);

FuzzyRule *fuzzyRule24 = new FuzzyRule(24, IfHbslowAndTempverycoldAndGsrdry, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule24);

// Building FuzzyRule 25

HbfastAndTempveryhot->joinWithAND(fast, veryhot);
FuzzyRuleAntecedent *IfHbfastAndTempveryhotAndGsrdry = new FuzzyRuleAntecedent();
IfHbfastAndTempveryhotAndGsrdry->joinWithAND(HbfastAndTempveryhot, dry);

FuzzyRule *fuzzyRule25 = new FuzzyRule(25, IfHbfastAndTempveryhotAndGsrdry, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule25);

// Building FuzzyRule 26

HbfastAndTemphot->joinWithAND(fast, hot);
FuzzyRuleAntecedent *IfHbfastAndTemphotAndGsrdry = new FuzzyRuleAntecedent();
IfHbfastAndTemphotAndGsrdry->joinWithAND(HbfastAndTemphot, dry);

FuzzyRule *fuzzyRule26 = new FuzzyRule(26, IfHbfastAndTemphotAndGsrdry, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule26);

// Building FuzzyRule 27

HbfastAndTempcold->joinWithAND(fast, cold);
FuzzyRuleAntecedent *IfHbfastAndTempcoldAndGsrdry = new FuzzyRuleAntecedent();
IfHbfastAndTempcoldAndGsrdry->joinWithAND(HbfastAndTempcold, dry);

FuzzyRule *fuzzyRule27 = new FuzzyRule(27, IfHbfastAndTempcoldAndGsrdry, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule27);

// Building FuzzyRule 28

HbfastAndTempverycold->joinWithAND(fast, verycold);
FuzzyRuleAntecedent *IfHbfastAndTempverycoldAndGsrdry = new FuzzyRuleAntecedent();
IfHbfastAndTempverycoldAndGsrdry->joinWithAND(HbfastAndTempverycold, dry);

FuzzyRule *fuzzyRule28 = new FuzzyRule(28, IfHbfastAndTempverycoldAndGsrdry, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule28);

// Building FuzzyRule 29

HbveryfastAndTempveryhot->joinWithAND(veryfast, veryhot);
FuzzyRuleAntecedent *IfHbveryfastAndTempveryhotAndGsrdry = new FuzzyRuleAntecedent();
IfHbveryfastAndTempveryhotAndGsrdry->joinWithAND(HbveryfastAndTempveryhot, dry);

FuzzyRule *fuzzyRule29 = new FuzzyRule(29, IfHbveryfastAndTempveryhotAndGsrdry, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule29);

  // Building FuzzyRule 30

HbveryfastAndTemphot->joinWithAND(veryfast, hot);
FuzzyRuleAntecedent *IfHbveryfastAndTemphotAndGsrdry = new FuzzyRuleAntecedent();
IfHbveryfastAndTemphotAndGsrdry->joinWithAND(HbveryfastAndTemphot, dry);

FuzzyRule *fuzzyRule30 = new FuzzyRule(30, IfHbveryfastAndTemphotAndGsrdry, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule30);

    // Building FuzzyRule 31

HbveryfastAndTempcold->joinWithAND(veryfast, cold);
FuzzyRuleAntecedent *IfHbveryfastAndTempcoldAndGsrdry = new FuzzyRuleAntecedent();
IfHbveryfastAndTempcoldAndGsrdry->joinWithAND(HbveryfastAndTempcold, dry);

FuzzyRule *fuzzyRule31 = new FuzzyRule(31, IfHbveryfastAndTempcoldAndGsrdry, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule31);

      // Building FuzzyRule 32

HbveryfastAndTempverycold->joinWithAND(veryfast, verycold);
FuzzyRuleAntecedent *IfHbveryfastAndTempverycoldAndGsrdry = new FuzzyRuleAntecedent();
IfHbveryfastAndTempverycoldAndGsrdry->joinWithAND(HbveryfastAndTempverycold, dry);

FuzzyRule *fuzzyRule32 = new FuzzyRule(32, IfHbveryfastAndTempverycoldAndGsrdry, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule32);

// Building FuzzyRule 33

HbveryslowAndTempveryhot->joinWithAND(veryslow, veryhot);
FuzzyRuleAntecedent *IfHbveryslowAndTempveryhotAndGsrmoist = new FuzzyRuleAntecedent();
IfHbveryslowAndTempveryhotAndGsrmoist->joinWithAND(HbveryslowAndTempveryhot, moist);

FuzzyRule *fuzzyRule33 = new FuzzyRule(33, IfHbveryslowAndTempveryhotAndGsrmoist, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule33);

// Building FuzzyRule 34

HbveryslowAndTemphot->joinWithAND(veryslow, hot);
FuzzyRuleAntecedent *IfHbveryslowAndTemphotAndGsrmoist = new FuzzyRuleAntecedent();
IfHbveryslowAndTemphotAndGsrmoist->joinWithAND(HbveryslowAndTemphot, moist);

FuzzyRule *fuzzyRule34 = new FuzzyRule(34, IfHbveryslowAndTemphotAndGsrmoist, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule34);

// Building FuzzyRule 35

HbveryslowAndTempcold->joinWithAND(veryslow, cold);
FuzzyRuleAntecedent *IfHbveryslowAndTempcoldAndGsrmoist = new FuzzyRuleAntecedent();
IfHbveryslowAndTempcoldAndGsrmoist->joinWithAND(HbveryslowAndTempcold, moist);

FuzzyRule *fuzzyRule35 = new FuzzyRule(35, IfHbveryslowAndTempcoldAndGsrmoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule35);

// Building FuzzyRule 36

HbveryslowAndTempverycold->joinWithAND(veryslow, verycold);
FuzzyRuleAntecedent *IfHbveryslowAndTempverycoldAndGsrmoist = new FuzzyRuleAntecedent();
IfHbveryslowAndTempverycoldAndGsrmoist->joinWithAND(HbveryslowAndTempverycold, moist);

FuzzyRule *fuzzyRule36 = new FuzzyRule(36, IfHbveryslowAndTempverycoldAndGsrmoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule36);

// Building FuzzyRule 37

HbslowAndTempveryhot->joinWithAND(slow, veryhot);
FuzzyRuleAntecedent *IfHbslowAndTempveryhotAndGsrmoist = new FuzzyRuleAntecedent();
IfHbslowAndTempveryhotAndGsrmoist->joinWithAND(HbslowAndTempveryhot, moist);

FuzzyRule *fuzzyRule37 = new FuzzyRule(37, IfHbslowAndTempveryhotAndGsrmoist, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule37);

// Building FuzzyRule 38

HbslowAndTemphot->joinWithAND(slow, hot);
FuzzyRuleAntecedent *IfHbslowAndTemphotAndGsrmoist = new FuzzyRuleAntecedent();
IfHbslowAndTemphotAndGsrmoist->joinWithAND(HbslowAndTemphot, moist);

FuzzyRule *fuzzyRule38 = new FuzzyRule(38, IfHbslowAndTemphotAndGsrmoist, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule38);

// Building FuzzyRule 39

HbslowAndTempcold->joinWithAND(slow, cold);
FuzzyRuleAntecedent *IfHbslowAndTempcoldAndGsrmoist = new FuzzyRuleAntecedent();
IfHbslowAndTempcoldAndGsrmoist->joinWithAND(HbslowAndTempcold, moist);

FuzzyRule *fuzzyRule39 = new FuzzyRule(39, IfHbslowAndTempcoldAndGsrmoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule39);

// Building FuzzyRule 40

HbslowAndTempverycold->joinWithAND(slow, verycold);
FuzzyRuleAntecedent *IfHbslowAndTempverycoldAndGsrmoist = new FuzzyRuleAntecedent();
IfHbslowAndTempverycoldAndGsrmoist->joinWithAND(HbslowAndTempverycold, moist);

FuzzyRule *fuzzyRule40 = new FuzzyRule(40, IfHbslowAndTempverycoldAndGsrmoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule40);

// Building FuzzyRule 41

HbfastAndTempveryhot->joinWithAND(fast, veryhot);
FuzzyRuleAntecedent *IfHbfastAndTempveryhotAndGsrmoist = new FuzzyRuleAntecedent();
IfHbfastAndTempveryhotAndGsrmoist->joinWithAND(HbfastAndTempveryhot, moist);

FuzzyRule *fuzzyRule41 = new FuzzyRule(41, IfHbfastAndTempveryhotAndGsrmoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule41);

// Building FuzzyRule 42

HbfastAndTemphot->joinWithAND(fast, hot);
FuzzyRuleAntecedent *IfHbfastAndTemphotAndGsrmoist = new FuzzyRuleAntecedent();
IfHbfastAndTemphotAndGsrmoist->joinWithAND(HbfastAndTemphot, moist);

FuzzyRule *fuzzyRule42 = new FuzzyRule(42, IfHbfastAndTemphotAndGsrmoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule42);

// Building FuzzyRule 43

HbfastAndTempcold->joinWithAND(fast, cold);
FuzzyRuleAntecedent *IfHbfastAndTempcoldAndGsrmoist = new FuzzyRuleAntecedent();
IfHbfastAndTempcoldAndGsrmoist->joinWithAND(HbfastAndTempcold, moist);

FuzzyRule *fuzzyRule43 = new FuzzyRule(43, IfHbfastAndTempcoldAndGsrmoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule43);

// Building FuzzyRule 44

HbfastAndTempverycold->joinWithAND(fast, verycold);
FuzzyRuleAntecedent *IfHbfastAndTempverycoldAndGsrmoist = new FuzzyRuleAntecedent();
IfHbfastAndTempverycoldAndGsrmoist->joinWithAND(HbfastAndTempverycold, moist);

FuzzyRule *fuzzyRule44 = new FuzzyRule(44, IfHbfastAndTempverycoldAndGsrmoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule44);

// Building FuzzyRule 45

HbveryfastAndTempveryhot->joinWithAND(veryfast, veryhot);
FuzzyRuleAntecedent *IfHbveryfastAndTempveryhotAndGsrmoist = new FuzzyRuleAntecedent();
IfHbveryfastAndTempveryhotAndGsrmoist->joinWithAND(HbveryfastAndTempveryhot, moist);

FuzzyRule *fuzzyRule45 = new FuzzyRule(45, IfHbveryfastAndTempveryhotAndGsrmoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule45);

  // Building FuzzyRule 46

HbveryfastAndTemphot->joinWithAND(veryfast, hot);
FuzzyRuleAntecedent *IfHbveryfastAndTemphotAndGsrmoist = new FuzzyRuleAntecedent();
IfHbveryfastAndTemphotAndGsrmoist->joinWithAND(HbveryfastAndTemphot, moist);

FuzzyRule *fuzzyRule46 = new FuzzyRule(46, IfHbveryfastAndTemphotAndGsrmoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule46);

    // Building FuzzyRule 47

HbveryfastAndTempcold->joinWithAND(veryfast, cold);
FuzzyRuleAntecedent *IfHbveryfastAndTempcoldAndGsrmoist = new FuzzyRuleAntecedent();
IfHbveryfastAndTempcoldAndGsrmoist->joinWithAND(HbveryfastAndTempcold, moist);

FuzzyRule *fuzzyRule47 = new FuzzyRule(47, IfHbveryfastAndTempcoldAndGsrmoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule47);

      // Building FuzzyRule 48

HbveryfastAndTempverycold->joinWithAND(veryfast, verycold);
FuzzyRuleAntecedent *IfHbveryfastAndTempverycoldAndGsrmoist = new FuzzyRuleAntecedent();
IfHbveryfastAndTempverycoldAndGsrmoist->joinWithAND(HbveryfastAndTempverycold, moist);

FuzzyRule *fuzzyRule48 = new FuzzyRule(48, IfHbveryfastAndTempverycoldAndGsrmoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule48);

// Building FuzzyRule 49

HbveryslowAndTempveryhot->joinWithAND(veryslow, veryhot);
FuzzyRuleAntecedent *IfHbveryslowAndTempveryhotAndGsrverymoist = new FuzzyRuleAntecedent();
IfHbveryslowAndTempveryhotAndGsrverymoist->joinWithAND(HbveryslowAndTempveryhot, verymoist);

FuzzyRule *fuzzyRule49 = new FuzzyRule(49, IfHbveryslowAndTempveryhotAndGsrverymoist, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule49);

// Building FuzzyRule 50

HbveryslowAndTemphot->joinWithAND(veryslow, hot);
FuzzyRuleAntecedent *IfHbveryslowAndTemphotAndGsrverymoist = new FuzzyRuleAntecedent();
IfHbveryslowAndTemphotAndGsrverymoist->joinWithAND(HbveryslowAndTemphot, verymoist);

FuzzyRule *fuzzyRule50 = new FuzzyRule(50, IfHbveryslowAndTemphotAndGsrverymoist, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule50);

// Building FuzzyRule 51

HbveryslowAndTempcold->joinWithAND(veryslow, cold);
FuzzyRuleAntecedent *IfHbveryslowAndTempcoldAndGsrverymoist = new FuzzyRuleAntecedent();
IfHbveryslowAndTempcoldAndGsrverymoist->joinWithAND(HbveryslowAndTempcold, verymoist);

FuzzyRule *fuzzyRule51 = new FuzzyRule(51, IfHbveryslowAndTempcoldAndGsrverymoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule51);

// Building FuzzyRule 52

HbveryslowAndTempverycold->joinWithAND(veryslow, verycold);
FuzzyRuleAntecedent *IfHbveryslowAndTempverycoldAndGsrverymoist = new FuzzyRuleAntecedent();
IfHbveryslowAndTempverycoldAndGsrverymoist->joinWithAND(HbveryslowAndTempverycold, verymoist);

FuzzyRule *fuzzyRule52 = new FuzzyRule(52, IfHbveryslowAndTempverycoldAndGsrverymoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule52);

// Building FuzzyRule 53

HbslowAndTempveryhot->joinWithAND(slow, veryhot);
FuzzyRuleAntecedent *IfHbslowAndTempveryhotAndGsrverymoist = new FuzzyRuleAntecedent();
IfHbslowAndTempveryhotAndGsrverymoist->joinWithAND(HbslowAndTempveryhot, verymoist);

FuzzyRule *fuzzyRule53 = new FuzzyRule(53, IfHbslowAndTempveryhotAndGsrverymoist, thenConditiontenang);
fuzzy->addFuzzyRule(fuzzyRule53);

// Building FuzzyRule 54

HbslowAndTemphot->joinWithAND(slow, hot);
FuzzyRuleAntecedent *IfHbslowAndTemphotAndGsrverymoist = new FuzzyRuleAntecedent();
IfHbslowAndTemphotAndGsrverymoist->joinWithAND(HbslowAndTemphot, verymoist);

FuzzyRule *fuzzyRule54 = new FuzzyRule(54, IfHbslowAndTemphotAndGsrverymoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule54);

// Building FuzzyRule 55

HbslowAndTempcold->joinWithAND(slow, cold);
FuzzyRuleAntecedent *IfHbslowAndTempcoldAndGsrverymoist = new FuzzyRuleAntecedent();
IfHbslowAndTempcoldAndGsrverymoist->joinWithAND(HbslowAndTempcold, verymoist);

FuzzyRule *fuzzyRule55 = new FuzzyRule(55, IfHbslowAndTempcoldAndGsrverymoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule55);

// Building FuzzyRule 56

HbslowAndTempverycold->joinWithAND(slow, verycold);
FuzzyRuleAntecedent *IfHbslowAndTempverycoldAndGsrverymoist = new FuzzyRuleAntecedent();
IfHbslowAndTempverycoldAndGsrverymoist->joinWithAND(HbslowAndTempverycold, verymoist);

FuzzyRule *fuzzyRule56 = new FuzzyRule(56, IfHbslowAndTempverycoldAndGsrverymoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule56);

// Building FuzzyRule 57

HbfastAndTempveryhot->joinWithAND(fast, veryhot);
FuzzyRuleAntecedent *IfHbfastAndTempveryhotAndGsrverymoist = new FuzzyRuleAntecedent();
IfHbfastAndTempveryhotAndGsrverymoist->joinWithAND(HbfastAndTempveryhot, verymoist);

FuzzyRule *fuzzyRule57 = new FuzzyRule(57, IfHbfastAndTempveryhotAndGsrverymoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule57);

// Building FuzzyRule 58

HbfastAndTemphot->joinWithAND(fast, hot);
FuzzyRuleAntecedent *IfHbfastAndTemphotAndGsrverymoist = new FuzzyRuleAntecedent();
IfHbfastAndTemphotAndGsrverymoist->joinWithAND(HbfastAndTemphot, verymoist);

FuzzyRule *fuzzyRule58 = new FuzzyRule(58, IfHbfastAndTemphotAndGsrverymoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule58);

// Building FuzzyRule 59

HbfastAndTempcold->joinWithAND(fast, cold);
FuzzyRuleAntecedent *IfHbfastAndTempcoldAndGsrverymoist = new FuzzyRuleAntecedent();
IfHbfastAndTempcoldAndGsrverymoist->joinWithAND(HbfastAndTempcold, verymoist);

FuzzyRule *fuzzyRule59 = new FuzzyRule(59, IfHbfastAndTempcoldAndGsrverymoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule59);

// Building FuzzyRule 60

HbfastAndTempverycold->joinWithAND(fast, verycold);
FuzzyRuleAntecedent *IfHbfastAndTempverycoldAndGsrverymoist = new FuzzyRuleAntecedent();
IfHbfastAndTempverycoldAndGsrverymoist->joinWithAND(HbfastAndTempverycold, verymoist);

FuzzyRuleConsequent *thenConditionstress = new FuzzyRuleConsequent();
thenConditionstress->addOutput(stress);

FuzzyRule *fuzzyRule60 = new FuzzyRule(60, IfHbfastAndTempverycoldAndGsrverymoist, thenConditionstress);
fuzzy->addFuzzyRule(fuzzyRule60);

// Building FuzzyRule 61

HbveryfastAndTempveryhot->joinWithAND(veryfast, veryhot);
FuzzyRuleAntecedent *IfHbveryfastAndTempveryhotAndGsrverymoist = new FuzzyRuleAntecedent();
IfHbveryfastAndTempveryhotAndGsrverymoist->joinWithAND(HbveryfastAndTempveryhot, verymoist);

FuzzyRule *fuzzyRule61 = new FuzzyRule(61, IfHbveryfastAndTempveryhotAndGsrverymoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule61);

  // Building FuzzyRule 62

HbveryfastAndTemphot->joinWithAND(veryfast, hot);
FuzzyRuleAntecedent *IfHbveryfastAndTemphotAndGsrverymoist = new FuzzyRuleAntecedent();
IfHbveryfastAndTemphotAndGsrverymoist->joinWithAND(HbveryfastAndTemphot, verymoist);

FuzzyRule *fuzzyRule62 = new FuzzyRule(62, IfHbveryfastAndTemphotAndGsrverymoist, thenConditioncemas);
fuzzy->addFuzzyRule(fuzzyRule62);

    // Building FuzzyRule 63

HbveryfastAndTempcold->joinWithAND(veryfast, cold);
FuzzyRuleAntecedent *IfHbveryfastAndTempcoldAndGsrverymoist = new FuzzyRuleAntecedent();
IfHbveryfastAndTempcoldAndGsrverymoist->joinWithAND(HbveryfastAndTempcold, verymoist);

FuzzyRule *fuzzyRule63 = new FuzzyRule(63, IfHbveryfastAndTempcoldAndGsrverymoist, thenConditionstress);
fuzzy->addFuzzyRule(fuzzyRule63);

      // Building FuzzyRule 64

HbveryfastAndTempverycold->joinWithAND(veryfast, verycold);
FuzzyRuleAntecedent *IfHbveryfastAndTempverycoldAndGsrverymoist = new FuzzyRuleAntecedent();
IfHbveryfastAndTempverycoldAndGsrverymoist->joinWithAND(HbveryfastAndTempverycold, verymoist);

FuzzyRule *fuzzyRule64 = new FuzzyRule(64, IfHbveryfastAndTempverycoldAndGsrverymoist, thenConditionstress);
fuzzy->addFuzzyRule(fuzzyRule64);
}
void loop()
{
// get random entrances
int input1 = random(60, 110);
int input2 = random(32, 37);
int input3 = random(1, 7);

Serial.println("\n\n\nEntrance: ");
Serial.print("\t\t\denyut jantung: ");
Serial.print(input1);
Serial.print(", suhu tubuh: ");
Serial.print(input2);
Serial.print(", and kelembaban: ");
Serial.println(input3);

fuzzy->setInput(1, input1);
fuzzy->setInput(2, input2);
fuzzy->setInput(3, input3);

fuzzy->fuzzify();

Serial.println("Input: ");
Serial.print("\tHb: veryslow-> ");
Serial.print(veryslow->getPertinence());
Serial.print("\tHb: slow-> ");
Serial.print(slow->getPertinence());
Serial.print("\tHb: fast-> ");
Serial.print(fast->getPertinence());
Serial.print("\tHb: veryfast-> ");
Serial.print(veryfast->getPertinence());

Serial.println("Input2: ");
Serial.print("\tTemp: veryhot-> ");
Serial.print(veryhot->getPertinence());
Serial.print("\tTemp: hot-> ");
Serial.print(hot->getPertinence());
Serial.print("\tTemp: cold-> ");
Serial.print(cold->getPertinence());
Serial.print("\tTemp: verycold-> ");
Serial.print(verycold->getPertinence());

Serial.println("Input3: ");
Serial.print("\tGsr: verydry-> ");
Serial.print(verydry->getPertinence());
Serial.print("\tGsr: dry-> ");
Serial.print(dry->getPertinence());
Serial.print("\tGsr: moist-> ");
Serial.print(moist->getPertinence());
Serial.print("\tGsr: verymoist-> ");
Serial.print(verymoist->getPertinence());

float output1 = fuzzy->defuzzify(1);

Serial.println("Output: ");
Serial.print("\tKondisi Relax-> ");
Serial.print(relax->getPertinence());
Serial.print(",Kondisi Tenang-> ");
Serial.print(tenang->getPertinence());
Serial.print(", Kondisi Cemas-> ");
Serial.println(cemas->getPertinence());
Serial.print(", Kondisi Stress-> ");
Serial.println(stress->getPertinence());

Serial.println (output1);

// wait 12 seconds
delay(12000);
}`