Tutorial Lengkap Fuzzy Logic Arduino Mamdani

Fuzzy arduino mamdani merupakan program pengambil keputusan berdasarkan logika fuzzy atau fuzzy logic controller, Arduino sebagai mikrokontroler yang memproses program fuzzy logic, Pada artikel ini akan dikupas tuntas mengenai pembuatan desain fuzzy logic mamdani dengan arduino serta implementasinya.

Fuzzy logic merupakan cabang ilmu matematika untuk pengambilan keputusan secara fuzzy atau samar.

Lain dengan logika crisp yang nilainya jelas atau trang, fuzzy menerapkan metode samar samar untuk menentukan suatu keputusan.

Contoh logika fuzzy dalam kehidupan

1. Mengendarai sepda motor
2. Menendang bola
3. Menentukan cantik jelek nya seseorang
4. dan masih banyak lagi perilaku dan penilaian manusia terhadap yang lainya

Contoh fuzzy logic pada sistem atau robot

1. Robot pemadam api dengan fuzzy
2. Robot Balancing dengan Fuzzy
3. Sistem air heater dengan fuzzy
4. Mesin cuci fuzzy
5. dan masih banyak sistem yang lainya dengan menerapkan fuzzy logic sebagai kontroler

Tutorial fuzzy arduino dengan satu input dan dua output

Fuzzy pada artikel kali ini adalah penerapan metode mamdani dengan arduino, motor DC dan sensor jarak.

Kasus nya sederhana saja yaitu membuat kontroler untuk menentukan kecepatan motor DC berdasarkan jarak yang terbaca oleh sensor ultrasonik.

Skema Rangkaian Arduino, Sensor Ultrasonik dan Motor DC

Berikut adalah rangkaian dengan menggunakan proteus 8

Desain Fuzzyfikasi dengan Software Matlab Atau Labview (Opsional bisa pakai corel atau apapun untuk gambar)

Berikut adalah gambar himpunan fuzzy mamdani untuk arduino input jarak dan output pwm yang sudah saya buat dengan menggunakan fungsi fuzzy simulation and control labview.

Selanjutnya kita akan membuat program untuk menghitung fuzzyfikasi atau himpunan fuzzy mamdani dengan arduino untuk input dan output.

Berdasarkan gambar diatas yang sudah saya desain untuk fuzzyfikasi input jarak seperti ini

• fungsi keanggotaan dekat = 1 ketika input jarak kurang dari 10
• fungsi keanggotaan dekat = (100 – x) / (100-10) ketika input jarak lebih dari 10 atau kurang dari 100
• fungsi keanggotaan dekat = 0 ketika input jarak lebih dari 100

• fungsi keanggotaan lumayan = 1 ketika input jarak = 150
• fungsi keanggotaan lumayan = (x – 50) / (150-50) ketika input jarak lebih dari 50 atau kurang dari 150
• fungsi keanggotaan lumayan = (150 – x) / (250-150) ketika input jarak lebih dari 150 atau kurang dari 250
• fungsi keanggotaan lumayan = 0 ketika input jarak kurang dari 50 atau lebih dari 250

• fungsi keanggotaan jauh = 1 ketika input jarak lebih dari 290
• fungsi keanggotaan jauh = (x-200) / (290-200) ketika input jarak lebih dari 10 atau kurang dari 100
• fungsi keanggotaan jauh = 0 ketika input jarak kurang dari 200

Untuk fuzzy output pwm nya silahkan kalian pikirkan sendiri. jika ada yang salah penjelasan diatas silahkan berkomentar.

dengan mengetahui dan memahami tabel diatas kita akan mudah membuat program himpunan fuzzy dengan bahasa C atau Arduino

Kode Fuzzifikasi Mamdani dengan Bahasa C atau Arduino

float fudeket[4] = {0, 0, 10, 100};
float fulumayan[3] = {50, 150, 250};
float fujauh[4] = {200, 290, 300, 300};

float fylambat[3] = {0, 0, 100};
float fysedang[3] = {20, 127.5, 235};
float fycepat[3] = {155, 255, 255};

float inputf, outputf;

float FiN(){
    if (inputf < fudeket[2]){return 1;}
    else if (inputf >= fudeket[2] && inputf <= fudeket[3]){return (fudeket[3] - inputf)/(fudeket[3]-fudeket[2]);}
    else if (inputf > fudeket[3]){return 0;}
}

float FiZ(){

    if (inputf < fulumayan[0]){return 0;}
    else if (inputf >= fulumayan[0] && inputf <= fulumayan[1]){return (inputf - fulumayan[0])/(fulumayan[1]-fulumayan[0]);}
    else if (inputf >= fulumayan[1] && inputf <= fulumayan[2]){return (fulumayan[2] - inputf)/(fulumayan[2]-fulumayan[1]);}
    else if (inputf > fulumayan[2]){return 0;}

}

float FiP(){
    if (inputf < fujauh[0]){return 0;}
    else if (inputf >= fujauh[0] && inputf <= fujauh[1]){return (inputf - fujauh[0])/(fujauh[1]-fujauh[0]);}
    else if (inputf > fujauh[2]){return 1;}
}

float FoN(){
    if (outputf < fylambat[1]){return 1;}
    else if (outputf >= fylambat[1] && outputf <= fylambat[2]){return (fylambat[2] - outputf)/(fylambat[2]-fylambat[1]);}
    else if (outputf > fylambat[2]){return 0;}
}

float FoZ(){

    if (outputf < fysedang[0]){return 0;}
    else if (outputf >= fysedang[0] && outputf <= fysedang[1]){return (outputf - fysedang[0])/(fysedang[1]-fysedang[0]);}
    else if (outputf >= fysedang[1] && outputf <= fysedang[2]){return (fysedang[2] - outputf)/(fysedang[2]-fysedang[1]);}
    else if (outputf > fysedang[2]){return 0;}

}

float FoP(){
    if (outputf < fycepat[0]){return 0;}
    else if (outputf >= fycepat[0] && outputf <= fycepat[1]){return (outputf - fycepat[0])/(fycepat[1]-fycepat[0]);}
    else if (outputf > fycepat[1]){return 1;}
}

int main(){
    printf ("Masukan Input Jarak 0 - 300 :");
    scanf ("%f", &inputf);
    
    printf ("Masukan Input PWM 0 - 255 :");
    scanf ("%f", &outputf);
    
    printf ("Keanggotaan Jarak Deket : %f\n", FiN());
    printf ("Keanggotaan Jarak Lumayan : %f\n", FiZ());
    printf ("Keanggotaan Jarak Jauh : %f\n", FiP());
    
    printf ("Keanggotaan PWM Lambat : %f\n", FoN());
    printf ("Keanggotaan PWM Sedang : %f\n", FoZ());
    printf ("Keanggotaan PWM Cepat : %f\n", FoP());
    
}

Silahkan jalankan program diatas kemudian cek hasilnya apakah sudah sesuai atau belum, jika belum sesuai silahkan berkoemntar maka akan saya perbaiki.

Kemudian kita akan menerapkan fungsi implikasi berdasarkan rule rule yang akan kita buat.

Pertama mari kita buat rule fuzzy mamdani untuk arduino nya terlebih dahulu, sensor jarak sebagai input dan PWM sebagai outputnya.

Rule Fuzzy Mamdani dengan Arduino atau bahasa C

1. If jarak dekat Then PWM lambat
2. If jarak lumayan Then PWM sedang
3. If jarak Jauh Then PWM cepat

Maka fungsi implikasi untuk tiap rule nya seperti ini dalam program fuzzy arduino mamdani atau bahasa C

Perhatikan kembali gambar himpunan fuzzy output mamdani arduino diatas.

• Rumus keanggotaan fuzzy lambat = (100 – x) / (100 – 0)
• Rumus keanggotaan fuzzy sedang a = (x – 20) / (127.5 – 20)
• Rumus keanggotaan fuzzy sedang b = (235 – x) / (235 – 127.5)
• Rumus keanggotaan fuzzy cepat (x – 155) / (255-255)

dengan membolak balikan rumus maka didapatkan hasi program seperti dibawah ini. (Untuk belajar menghitungnya bisa menghubungi saya untuk les privat telegram : @anakkendali)

void implikasi (){
//sesuai dengan rule
// if deket then lambat
a1 = 100 - (FiN() * (fylambat[2] - fylambat[1]));
// if lumayan then sedang
b1a = 20 + (FiZ() * (fysedang[1] - fysedang[0]));
b1b =  235 - (FiZ() * (fysedang[2] - fysedang[1]));
// if jauh then cepat
c1 = 155 + (FiP() * (fycepat[1] - fycepat[0]));
}

Untuk program lengkapnya menghitung implikasi fuzzy mamdani berdasarkan rule diatas bisa lihat di bawah.

#include<stdio.h>
#include<math.h>
float A, B;
int sel_;

float a1, b1a, b1b, c1;

float fudeket[4] = {0, 0, 10, 100};
float fulumayan[3] = {50, 150, 250};
float fujauh[4] = {200, 290, 300, 300};

float fylambat[3] = {0, 0, 100};
float fysedang[3] = {20, 127.5, 235};
float fycepat[3] = {155, 255, 255};

float inputf, outputf;

float FiN(){
    if (inputf < fudeket[2]){return 1;}
    else if (inputf >= fudeket[2] && inputf <= fudeket[3]){return (fudeket[3] - inputf)/(fudeket[3]-fudeket[2]);}
    else if (inputf > fudeket[3]){return 0;}
}

float FiZ(){

    if (inputf < fulumayan[0]){return 0;}
    else if (inputf >= fulumayan[0] && inputf <= fulumayan[1]){return (inputf - fulumayan[0])/(fulumayan[1]-fulumayan[0]);}
    else if (inputf >= fulumayan[1] && inputf <= fulumayan[2]){return (fulumayan[2] - inputf)/(fulumayan[2]-fulumayan[1]);}
    else if (inputf > fulumayan[2]){return 0;}

}

float FiP(){
    if (inputf < fujauh[0]){return 0;}
    else if (inputf >= fujauh[0] && inputf <= fujauh[1]){return (inputf - fujauh[0])/(fujauh[1]-fujauh[0]);}
    else if (inputf > fujauh[1]){return 1;}
}

float FoN(){
    if (outputf < fylambat[1]){return 1;}
    else if (outputf >= fylambat[1] && outputf <= fylambat[2]){return (fylambat[2] - outputf)/(fylambat[2]-fylambat[1]);}
    else if (outputf > fylambat[2]){return 0;}
}

float FoZ(){

    if (outputf < fysedang[0]){return 0;}
    else if (outputf >= fysedang[0] && outputf <= fysedang[1]){return (outputf - fysedang[0])/(fysedang[1]-fysedang[0]);}
    else if (outputf >= fysedang[1] && outputf <= fysedang[2]){return (fysedang[2] - outputf)/(fysedang[2]-fysedang[1]);}
    else if (outputf > fysedang[2]){return 0;}

}

float FoP(){
    if (outputf < fycepat[0]){return 0;}
    else if (outputf >= fycepat[0] && outputf <= fycepat[1]){return (outputf - fycepat[0])/(fycepat[1]-fycepat[0]);}
    else if (outputf > fycepat[1]){return 1;}
}

void implikasi (){
//sesuai dengan rule
// if deket then lambat
a1 = 100 - (FiN() * (fylambat[2] - fylambat[1]));
// if lumayan then sedang
b1a = 20 + (FiZ() * (fysedang[1] - fysedang[0]));
b1b =  235 - (FiZ() * (fysedang[2] - fysedang[1]));
// if jauh then cepat
c1 = 155 + (FiP() * (fycepat[1] - fycepat[0]));
}

float f(float x){

    if (B > 0 && sel_ == 0){
    return ((x-A)/B)*x;
    }
    else if (B > 0 && sel_ == 1){
    return ((A-x)/B)*x;
    }
    else {
    return A*x;
    }
}

/*Function definition to perform integration by Simpson's 1/3rd Rule */
float simpsons(float f(float x), float a,float b,float n){
  float h,integral,x,sum=0;
  int i;
  h=fabs(b-a)/n;
  for(i=1;i<n;i++){
    x=a+i*h;
    if(i%2==0){
      sum=sum+2*f(x);
    }
    else{
      sum=sum+4*f(x);
    }
  }
  integral=(h/3)*(f(a)+f(b)+sum);
  return integral;
}

float fx(float limd, float limu, float a, float b, int sel){
    int n,i=2;
    float h,x,integral,eps=0.1,integral_new;
    A = a;
    B = b;
    sel_ = sel;

    integral_new=simpsons(f,limd,limu,i);

    do{
        integral=integral_new;
        i=i+2;
        integral_new=simpsons(f,limd,limu,i);
    }while(fabs(integral_new-integral)>=eps);

    /*Print the answer */
    return integral_new;
}
main(){
    printf ("Masukan Input Jarak 0 - 300 :");
    scanf ("%f", &inputf);

    printf ("Keanggotaan Jarak Deket : %f\n", FiN());
    printf ("Keanggotaan Jarak Lumayan : %f\n", FiZ());
    printf ("Keanggotaan Jarak Jauh : %f\n", FiP());

    implikasi();

    printf("a1 : %f\n", a1);
    printf("b1a : %f\n", b1a);
    printf("b1b : %f\n", b1b);
    printf("c1 : %f\n", c1);
}

Silahkan dicoba pada compiler bahasa C kalian dan perhatikan hasil implikasinya sudah sesuai dengan perhitungan manual atau belum.

Selanjutnya kita akan mengkomposisikan seluruh output fuzzy mamdani arduino.

Komposisi output fuzzy logic arduino metode mamdani

Kita asumsikan dulu biar mudah, misalkan input yang kita masukan untuk jarak adalah 50. maka dihasilkan data sebagai berikut :

• Keanggotaan Jarak Deket : 0.555556
• Keanggotaan Jarak Lumayan : 0.000000
• Keanggotaan Jarak Jauh : 0.000000
• a1 : 44.444443
• b1a : 20.000000
• b1b : 235.000000
• c1 : 155.000000

(100-pwm)/100-0 untuk a1 <= pwm <= 100

jika disederhanakan maka hasilnya seperti ini

100 – pwm / 100

Kita coba validasi dengan menghitung balik pwm = 44.444443 maka 100 – 44.444443 / 100 = 0.55556
Untuk keseluruhan komposisi nya sebagai berikut

• (100-pwm)/100-0 untuk a1 <= pwm <= 100
• 0.555556 untuk pwm < a1
• (pwm-20)/127.5-20 untuk 20 <= pwm <= b1a
• (235-pwm)/235-1275 untuk b1b <= pwm <= 235
• 0 untuk b1a < pwm > b1b
• (pwm-155)/255-155 untuk 155 <= pwm <= c1
• 0 untuk pwm > c1

Susah dimengerti ya ? hehe mamang susah sih, saya pun berkali-kali ngitungnya kadang salah, jadi memang harus teliti, dan jika anda paham dan mendapati saya keliru dalam menulis rumus atau penjelasan bisa langsung komentar ya.

Selanjutnya kita akan menghitung luas dan hal ini sudah masuk ke tahap defuzzyfikasi.

Defuzzyfikasi Metode Mamdani dengan Arduino atau Bahasa C

Menghitung luas sangat mudah, karena hanya terdapat bentuk segitiga dan kotak atau persegi, maka rumus nya untuk segitiga yaitu AxT/2 atau 1/2 AT. Sedangkan rumus luas persegi adalah panjang x lebar.

Sesuai sampel nya dimana input fuzzy jarak adalah 50 dan didapati data seperti diatas maka kita hitung seperti berikut.

• A1 = ((100 – a1) *0.55556) / 2 = 15.432222
• A2 = (a1 – 0) * 0.55556 = 24.69155
• A3 = ((b1a – 20)*0) / 2 = 0
• A4 = ((235 – b1b)*0) / 2 = 0
• A5 = (b1b – b1a)*0 = 0
• A6 = (c1 – 155)*0 / 2 = 0
• A7 = (255 – c1)* 0 = 0

Kita akan coba langsung dengan program, apakah hasilnya sama atau ada kesalahan ngitung.

#include<stdio.h>
#include<math.h>
float A, B;
int sel_;

float a1, b1a, b1b, c1;

float A1, A2, A3, A4, A5, A6, A7;

float fudeket[4] = {0, 0, 10, 100};
float fulumayan[3] = {50, 150, 250};
float fujauh[4] = {200, 290, 300, 300};

float fylambat[3] = {0, 0, 100};
float fysedang[3] = {20, 127.5, 235};
float fycepat[3] = {155, 255, 255};

float inputf, outputf;

float FiN(){
    if (inputf < fudeket[2]){return 1;}
    else if (inputf >= fudeket[2] && inputf <= fudeket[3]){return (fudeket[3] - inputf)/(fudeket[3]-fudeket[2]);}
    else if (inputf > fudeket[3]){return 0;}
}

float FiZ(){

    if (inputf < fulumayan[0]){return 0;}
    else if (inputf >= fulumayan[0] && inputf <= fulumayan[1]){return (inputf - fulumayan[0])/(fulumayan[1]-fulumayan[0]);}
    else if (inputf >= fulumayan[1] && inputf <= fulumayan[2]){return (fulumayan[2] - inputf)/(fulumayan[2]-fulumayan[1]);}
    else if (inputf > fulumayan[2]){return 0;}

}

float FiP(){
    if (inputf < fujauh[0]){return 0;}
    else if (inputf >= fujauh[0] && inputf <= fujauh[1]){return (inputf - fujauh[0])/(fujauh[1]-fujauh[0]);}
    else if (inputf > fujauh[1]){return 1;}
}

float FoN(){
    if (outputf < fylambat[1]){return 1;}
    else if (outputf >= fylambat[1] && outputf <= fylambat[2]){return (fylambat[2] - outputf)/(fylambat[2]-fylambat[1]);}
    else if (outputf > fylambat[2]){return 0;}
}

float FoZ(){

    if (outputf < fysedang[0]){return 0;}
    else if (outputf >= fysedang[0] && outputf <= fysedang[1]){return (outputf - fysedang[0])/(fysedang[1]-fysedang[0]);}
    else if (outputf >= fysedang[1] && outputf <= fysedang[2]){return (fysedang[2] - outputf)/(fysedang[2]-fysedang[1]);}
    else if (outputf > fysedang[2]){return 0;}

}

float FoP(){
    if (outputf < fycepat[0]){return 0;}
    else if (outputf >= fycepat[0] && outputf <= fycepat[1]){return (outputf - fycepat[0])/(fycepat[1]-fycepat[0]);}
    else if (outputf > fycepat[1]){return 1;}
}

void implikasi (){
//sesuai dengan rule
// if deket then lambat
a1 = 100 - (FiN() * (fylambat[2] - fylambat[1]));
// if lumayan then sedang
b1a = 20 + (FiZ() * (fysedang[1] - fysedang[0]));
b1b =  235 - (FiZ() * (fysedang[2] - fysedang[1]));
// if jauh then cepat
c1 = 155 + (FiP() * (fycepat[1] - fycepat[0]));
}

void luas_deffuzzy(){
implikasi ();
A1 = ((fylambat[2] - a1) * FiN()) / 2; //= 15.432222
A2 = (a1 - fylambat[0]) * FiN(); // = 24.69155
A3 = ((b1a - fysedang[0])* FiZ()) / 2; // = 0
A4 = ((fysedang[2] - b1b)* FiZ()) / 2; // = 0
A5 = (b1b - b1a)*FiZ(); // = 0
A6 = ((c1 - fycepat[0]) * FiP()) / 2; // = 0
A7 = (fycepat[2] - c1)* FiP(); // = 0
}

float f(float x){

    if (B > 0 && sel_ == 0){
    return ((x-A)/B)*x;
    }
    else if (B > 0 && sel_ == 1){
    return ((A-x)/B)*x;
    }
    else {
    return A*x;
    }
}

/*Function definition to perform integration by Simpson's 1/3rd Rule */
float simpsons(float f(float x), float a,float b,float n){
  float h,integral,x,sum=0;
  int i;
  h=fabs(b-a)/n;
  for(i=1;i<n;i++){
    x=a+i*h;
    if(i%2==0){
      sum=sum+2*f(x);
    }
    else{
      sum=sum+4*f(x);
    }
  }
  integral=(h/3)*(f(a)+f(b)+sum);
  return integral;
}

float fx(float limd, float limu, float a, float b, int sel){
    int n,i=2;
    float h,x,integral,eps=0.1,integral_new;
    A = a;
    B = b;
    sel_ = sel;

    integral_new=simpsons(f,limd,limu,i);

    do{
        integral=integral_new;
        i=i+2;
        integral_new=simpsons(f,limd,limu,i);
    }while(fabs(integral_new-integral)>=eps);

    /*Print the answer */
    return integral_new;
}
main(){
    printf ("Masukan Input Jarak 0 - 300 :");
    scanf ("%f", &inputf);

    printf ("Keanggotaan Jarak Deket : %f\n", FiN());
    printf ("Keanggotaan Jarak Lumayan : %f\n", FiZ());
    printf ("Keanggotaan Jarak Jauh : %f\n", FiP());

    luas_deffuzzy();

    printf("a1 : %f\n", a1);
    printf("b1a : %f\n", b1a);
    printf("b1b : %f\n", b1b);
    printf("c1 : %f\n", c1);

    printf("A1 :%f\n", A1);
    printf("A2 :%f\n", A2);
    printf("A3 :%f\n", A3);
    printf("A4 :%f\n", A4);
    printf("A5 :%f\n", A5);
    printf("A6 :%f\n", A6);
    printf("A7 :%f\n", A7);
}

Selanjutnya kita akan menghitung moment defuzzyfikasi Mamdani Arduino atau bahasa C.

Pada perhitungan kali ini kita akan memerlukan sedikit pengetahuan integral dasar, jik kalian lupa materi integral matematika silahkan berlajar lagi ke materi matematika SMA.

dari data komposisi yang sudah kita hitung diatas, selanjutnya kita kalikan dengan x, karena integral nya terhadap sumbu x.

• (100-pwm)/100-0 untuk a1 <= pwm <= 100
• 0.555556 untuk pwm < a1
• (pwm-20)/127.5-20 untuk 20 <= pwm <= b1a
• (235-pwm)/235-1275 untuk b1b <= pwm <= 235
• 0 untuk b1a < pwm > b1b
• (pwm-155)/255-155 untuk 155 <= pwm <= c1
• 0 untuk pwm > c1

1. M1 = ∫ ((100-x)/100)x dx ==================> limd a1 dan limup 100
2. M2 = ∫ 0.555556x dx ==================> limd 0 dan limup a1
3. M3 = ∫ ((x-20)/107.5)x dx ==================> limd 20 dan limup b1a
4. M4 = ∫ ((235-x)/107.5)x dx ==================> limd b1b dan limup 235
5. M5 = ∫ 0 dx ==================> limd b1a dan limup b1b
6. M6 = ∫ ((x-155)/100)x dx ==================> limd 155 dan limup c1
7. M7 = ∫ 0 dx ==================> limd c1 dan limup 255

Dari data diatas kita percaya aja ya untuk M3 – M7 hasilnya pasti 0 hehe.
untuk M1 nya silahkan dihitung manual, dan hasil perhitungan saya adalah

• M1 = 971.64929
• M2 = 548.69865

Untuk menghitung fuzzy nya sangat mudah, tinggal hitung center of area deffuzzyfikasi.

SUM M1 / SUM A1

(M1+M2+M3+M4+M5+M6+M7) / (A1+A2+A3+A4+A5+A6+A7)

Hasil input jarak = 50 maka deffuzy output nya adalah = 37.891

Berikut adalah program akhir fuzzy mamdani dengan arduino atau bahasa C

Kode Bahasa C Fuzzy Logic Mamdani

#include<stdio.h>
#include<math.h>
float A, B;
int sel_;

float a1, b1a, b1b, c1;

float A1, A2, A3, A4, A5, A6, A7;
float M1, M2, M3, M4, M5, M6, M7;

float fudeket[4] = {0, 0, 10, 100};
float fulumayan[3] = {50, 150, 250};
float fujauh[4] = {200, 290, 300, 300};

float fylambat[3] = {0, 0, 100};
float fysedang[3] = {20, 127.5, 235};
float fycepat[3] = {155, 255, 255};

float inputf, outputf;

float FiN(){
    if (inputf < fudeket[2]){return 1;}
    else if (inputf >= fudeket[2] && inputf <= fudeket[3]){return (fudeket[3] - inputf)/(fudeket[3]-fudeket[2]);}
    else if (inputf > fudeket[3]){return 0;}
}

float FiZ(){

    if (inputf < fulumayan[0]){return 0;}
    else if (inputf >= fulumayan[0] && inputf <= fulumayan[1]){return (inputf - fulumayan[0])/(fulumayan[1]-fulumayan[0]);}
    else if (inputf >= fulumayan[1] && inputf <= fulumayan[2]){return (fulumayan[2] - inputf)/(fulumayan[2]-fulumayan[1]);}
    else if (inputf > fulumayan[2]){return 0;}

}

float FiP(){
    if (inputf < fujauh[0]){return 0;}
    else if (inputf >= fujauh[0] && inputf <= fujauh[1]){return (inputf - fujauh[0])/(fujauh[1]-fujauh[0]);}
    else if (inputf > fujauh[1]){return 1;}
}

float FoN(){
    if (outputf < fylambat[1]){return 1;}
    else if (outputf >= fylambat[1] && outputf <= fylambat[2]){return (fylambat[2] - outputf)/(fylambat[2]-fylambat[1]);}
    else if (outputf > fylambat[2]){return 0;}
}

float FoZ(){

    if (outputf < fysedang[0]){return 0;}
    else if (outputf >= fysedang[0] && outputf <= fysedang[1]){return (outputf - fysedang[0])/(fysedang[1]-fysedang[0]);}
    else if (outputf >= fysedang[1] && outputf <= fysedang[2]){return (fysedang[2] - outputf)/(fysedang[2]-fysedang[1]);}
    else if (outputf > fysedang[2]){return 0;}

}

float FoP(){
    if (outputf < fycepat[0]){return 0;}
    else if (outputf >= fycepat[0] && outputf <= fycepat[1]){return (outputf - fycepat[0])/(fycepat[1]-fycepat[0]);}
    else if (outputf > fycepat[1]){return 1;}
}

void implikasi (){
//sesuai dengan rule
// if deket then lambat
a1 = 100 - (FiN() * (fylambat[2] - fylambat[1]));
// if lumayan then sedang
b1a = 20 + (FiZ() * (fysedang[1] - fysedang[0]));
b1b =  235 - (FiZ() * (fysedang[2] - fysedang[1]));
// if jauh then cepat
c1 = 155 + (FiP() * (fycepat[1] - fycepat[0]));
}

void luas_deffuzzy(){
implikasi ();
A1 = ((fylambat[2] - a1) * FiN()) / 2; //= 15.432222
A2 = (a1 - fylambat[0]) * FiN(); // = 24.69155
A3 = ((b1a - fysedang[0])* FiZ()) / 2; // = 0
A4 = ((fysedang[2] - b1b)* FiZ()) / 2; // = 0
A5 = (b1b - b1a)*FiZ(); // = 0
A6 = ((c1 - fycepat[0]) * FiP()) / 2; // = 0
A7 = (fycepat[2] - c1)* FiP(); // = 0
}

float f(float x){

    if (B > 0 && sel_ == 0){
    return ((x-A)/B)*x;
    }
    else if (B > 0 && sel_ == 1){
    return ((A-x)/B)*x;
    }
    else {
    return A*x;
    }
}

/*Function definition to perform integration by Simpson's 1/3rd Rule */
float simpsons(float f(float x), float a,float b,float n){
  float h,integral,x,sum=0;
  int i;
  h=fabs(b-a)/n;
  for(i=1;i<n;i++){
    x=a+i*h;
    if(i%2==0){
      sum=sum+2*f(x);
    }
    else{
      sum=sum+4*f(x);
    }
  }
  integral=(h/3)*(f(a)+f(b)+sum);
  return integral;
}

float fx(float limd, float limu, float a, float b, int sel){
    int n,i=2;
    float h,x,integral,eps=0.1,integral_new;
    A = a;
    B = b;
    sel_ = sel;

    integral_new=simpsons(f,limd,limu,i);

    do{
        integral=integral_new;
        i=i+2;
        integral_new=simpsons(f,limd,limu,i);
    }while(fabs(integral_new-integral)>=eps);

    /*Print the answer */
    return integral_new;
}

/*
(fylambat[2]-pwm)/fylambat[2]-fylambat[0] untuk a1 <= pwm <= 100
FiN() untuk pwm < a1
(pwm-20)/127.5-20 untuk 20 <= pwm <= b1a
(235-pwm)/235-1275 untuk b1b <= pwm <= 235
0 untuk b1a < pwm > b1b
(pwm-155)/255-155 untuk 155 <= pwm <= c1
0 untuk pwm > c1
*/

void moment(){
luas_deffuzzy();

//M1 = ∫ ((100-x)/100)x dx ==================> limd a1 dan limup 100
M1 = fx(a1, fylambat[2], fylambat[2], (fylambat[2]-fylambat[0]), 1);
//M2 = ∫ 0.555556x dx ==================> limd 0 dan limup a1
M2 = fx(fylambat[0], a1, FiN(), 0, 0);
//M3 = ∫ ((x-20)/107.5)x dx ==================> limd 20 dan limup b1a
M3 = fx(fysedang[0], b1a, fysedang[0], (fysedang[1] - fysedang[0]), 0);
//M4 = ∫ ((235-x)/107.5)x dx ==================> limd b1b dan limup 235
M4 = fx (b1b, fysedang[2], fysedang[2], (fysedang[2]-fysedang[1]), 1);
//M5 = ∫ 0 dx ==================> limd b1a dan limup b1b
M5 = fx (b1a, b1b, FiZ(), 0, 0);
//M6 = ∫ ((x-155)/100)x dx ==================> limd 155 dan limup c1
M6 = fx(fycepat[0], c1, fycepat[0], (fycepat[2]-fycepat[0]), 0);
//M7 = ∫ 0 dx ==================> limd c1 dan limup 255
M7 = fx(c1, fycepat[2], FiP(), 0, 0);
}

float deffuzzyfikasi(){
return (M1+M2+M3+M4+M5+M6+M7)/(A1+A2+A3+A4+A5+A6+A7);
}
main(){
    printf ("Masukan Input Jarak 0 - 300 :");
    scanf ("%f", &inputf);

    printf ("Keanggotaan Jarak Deket : %f\n", FiN());
    printf ("Keanggotaan Jarak Lumayan : %f\n", FiZ());
    printf ("Keanggotaan Jarak Jauh : %f\n", FiP());

    moment();

    printf("a1 : %f\n", a1);
    printf("b1a : %f\n", b1a);
    printf("b1b : %f\n", b1b);
    printf("c1 : %f\n", c1);

    printf("A1 :%f\n", A1);
    printf("A2 :%f\n", A2);
    printf("A3 :%f\n", A3);
    printf("A4 :%f\n", A4);
    printf("A5 :%f\n", A5);
    printf("A6 :%f\n", A6);
    printf("A7 :%f\n", A7);

    printf("M1 : %f\n", M1);
    printf("M2 : %f\n", M2);
    printf("M3 : %f\n", M3);
    printf("M4 : %f\n", M4);
    printf("M5 : %f\n", M5);
    printf("M6 : %f\n", M6);
    printf("M7 : %f\n", M7);

    printf("OutDefuzzyfikasi : %f", deffuzzyfikasi());
}

Akhirnya selesai juga temen-temen tutorial arduino fuzzy metode mamdani, bagaimana perasaanya ?

Sama saya juga capek dan pusing setengah hari ngitung fuzzy yang untuk satu input dan satu output saja.

Bagaimana kalo misalkan dua input satu output atau sebagainya ? serahkan pada admin anakkendali.com hehe. nanti admin akan bantu.

Berikut hasil testing dengan labview dan bahasa C fuzzy mamdani diatas.

Kode Arduino Fuzzy Logic Mamdani

#include<math.h>
float A, B;
int sel_;

float a1, b1a, b1b, c1;

float L1, L2, L3, L4, L5, L6, L7;
float M1, M2, M3, M4, M5, M6, M7;

float fudeket[4] = {0, 0, 10, 100};
float fulumayan[3] = {50, 150, 250};
float fujauh[4] = {200, 290, 300, 300};

float fylambat[3] = {0, 0, 100};
float fysedang[3] = {20, 127.5, 235};
float fycepat[3] = {155, 255, 255};

float inputf, outputf;

float FiN() {
  if (inputf < fudeket[2]) {
    return 1;
  }
  else if (inputf >= fudeket[2] && inputf <= fudeket[3]) {
    return (fudeket[3] - inputf) / (fudeket[3] - fudeket[2]);
  }
  else if (inputf > fudeket[3]) {
    return 0;
  }
}

float FiZ() {

  if (inputf < fulumayan[0]) {
    return 0;
  }
  else if (inputf >= fulumayan[0] && inputf <= fulumayan[1]) {
    return (inputf - fulumayan[0]) / (fulumayan[1] - fulumayan[0]);
  }
  else if (inputf >= fulumayan[1] && inputf <= fulumayan[2]) {
    return (fulumayan[2] - inputf) / (fulumayan[2] - fulumayan[1]);
  }
  else if (inputf > fulumayan[2]) {
    return 0;
  }

}

float FiP() {
  if (inputf < fujauh[0]) {
    return 0;
  }
  else if (inputf >= fujauh[0] && inputf <= fujauh[1]) {
    return (inputf - fujauh[0]) / (fujauh[1] - fujauh[0]);
  }
  else if (inputf > fujauh[1]) {
    return 1;
  }
}

float FoN() {
  if (outputf < fylambat[1]) {
    return 1;
  }
  else if (outputf >= fylambat[1] && outputf <= fylambat[2]) {
    return (fylambat[2] - outputf) / (fylambat[2] - fylambat[1]);
  }
  else if (outputf > fylambat[2]) {
    return 0;
  }
}

float FoZ() {

  if (outputf < fysedang[0]) {
    return 0;
  }
  else if (outputf >= fysedang[0] && outputf <= fysedang[1]) {
    return (outputf - fysedang[0]) / (fysedang[1] - fysedang[0]);
  }
  else if (outputf >= fysedang[1] && outputf <= fysedang[2]) {
    return (fysedang[2] - outputf) / (fysedang[2] - fysedang[1]);
  }
  else if (outputf > fysedang[2]) {
    return 0;
  }

}

float FoP() {
  if (outputf < fycepat[0]) {
    return 0;
  }
  else if (outputf >= fycepat[0] && outputf <= fycepat[1]) {
    return (outputf - fycepat[0]) / (fycepat[1] - fycepat[0]);
  }
  else if (outputf > fycepat[1]) {
    return 1;
  }
}

void implikasi () {
  //sesuai dengan rule
  // if deket then lambat
  a1 = 100 - (FiN() * (fylambat[2] - fylambat[1]));
  // if lumayan then sedang
  b1a = 20 + (FiZ() * (fysedang[1] - fysedang[0]));
  b1b =  235 - (FiZ() * (fysedang[2] - fysedang[1]));
  // if jauh then cepat
  c1 = 155 + (FiP() * (fycepat[1] - fycepat[0]));
}

void luas_deffuzzy() {
  implikasi ();
  L1 = ((fylambat[2] - a1) * FiN()) / 2; //= 15.432222
  L2 = (a1 - fylambat[0]) * FiN(); // = 24.69155
  L3 = ((b1a - fysedang[0]) * FiZ()) / 2; // = 0
  L4 = ((fysedang[2] - b1b) * FiZ()) / 2; // = 0
  L5 = (b1b - b1a) * FiZ(); // = 0
  L6 = ((c1 - fycepat[0]) * FiP()) / 2; // = 0
  L7 = (fycepat[2] - c1) * FiP(); // = 0
}

float f(float x) {

  if (B > 0 && sel_ == 0) {
    return ((x - A) / B) * x;
  }
  else if (B > 0 && sel_ == 1) {
    return ((A - x) / B) * x;
  }
  else {
    return A * x;
  }
}

/*Function definition to perform integration by Simpson's 1/3rd Rule */
float simpsons(float f(float x), float a, float b, float n) {
  float h, integral, x, sum = 0;
  int i;
  h = fabs(b - a) / n;
  for (i = 1; i < n; i++) {
    x = a + i * h;
    if (i % 2 == 0) {
      sum = sum + 2 * f(x);
    }
    else {
      sum = sum + 4 * f(x);
    }
  }
  integral = (h / 3) * (f(a) + f(b) + sum);
  return integral;
}

float fx(float limd, float limu, float a, float b, int sel) {
  int n, i = 2;
  float h, x, integral, eps = 0.1, integral_new;
  A = a;
  B = b;
  sel_ = sel;

  integral_new = simpsons(f, limd, limu, i);

  do {
    integral = integral_new;
    i = i + 2;
    integral_new = simpsons(f, limd, limu, i);
  } while (fabs(integral_new - integral) >= eps);

  /*Print the answer */
  return integral_new;
}

/*
  (fylambat[2]-pwm)/fylambat[2]-fylambat[0] untuk a1 <= pwm <= 100
  FiN() untuk pwm < a1
  (pwm-20)/127.5-20 untuk 20 <= pwm <= b1a
  (235-pwm)/235-1275 untuk b1b <= pwm <= 235
  0 untuk b1a < pwm > b1b
  (pwm-155)/255-155 untuk 155 <= pwm <= c1
  0 untuk pwm > c1
*/

void moment() {
  luas_deffuzzy();

  //M1 = ∫ ((100-x)/100)x dx ==================> limd a1 dan limup 100
  M1 = fx(a1, fylambat[2], fylambat[2], (fylambat[2] - fylambat[0]), 1);
  //M2 = ∫ 0.555556x dx ==================> limd 0 dan limup a1
  M2 = fx(fylambat[0], a1, FiN(), 0, 0);
  //M3 = ∫ ((x-20)/107.5)x dx ==================> limd 20 dan limup b1a
  M3 = fx(fysedang[0], b1a, fysedang[0], (fysedang[1] - fysedang[0]), 0);
  //M4 = ∫ ((235-x)/107.5)x dx ==================> limd b1b dan limup 235
  M4 = fx (b1b, fysedang[2], fysedang[2], (fysedang[2] - fysedang[1]), 1);
  //M5 = ∫ 0 dx ==================> limd b1a dan limup b1b
  M5 = fx (b1a, b1b, FiZ(), 0, 0);
  //M6 = ∫ ((x-155)/100)x dx ==================> limd 155 dan limup c1
  M6 = fx(fycepat[0], c1, fycepat[0], (fycepat[2] - fycepat[0]), 0);
  //M7 = ∫ 0 dx ==================> limd c1 dan limup 255
  M7 = fx(c1, fycepat[2], FiP(), 0, 0);
}

float deffuzzyfikasi() {
  moment();
  return (M1 + M2 + M3 + M4 + M5 + M6 + M7) / (L1 + L2 + L3 + L4 + L5 + L6 + L7);
}
void setup() {
  Serial.begin(9600);
  Serial.println("---Program Fuzzy anakkendali.co---");
  Serial.println ("Masukan Input Jarak 0 - 300 :");
}

void loop() {
  if (Serial.available()) {
    int a = Serial.parseInt();
    if (a >= 0) {
      inputf = a;
      Serial.print("Input jarak :");
      Serial.print(inputf);
      Serial.println(" CM");
      Serial.print("Output Deffuzyfikasi Mamdani :");
      Serial.println(deffuzzyfikasi());
    }
  }
}

Berikut hasil yang tampil pada arduino serial monitor

Keyword

1. fuzzy arduino,
2. arduino fuzzy,
3. fuzzy logic arduino,
4. penejalasan fuzzy logic arduino,
5. tutorial fuzzy logic arduino,
6. fuzzy logic bahasa c,
7. fuzzy logic c language,
8. fuzzy logic mamdani arduino,
9. fuzzy mamdani arduino,
10. arduino fuzzy mamdani,

Beli Komponen di Tokopedia.com