Arduino, Tutorial Fuzzy Logic Control System Air Heater

pada kesempatan kali ini saya akan menuliskan Artikel tentang Arduino, Tutorial Fuzzy Logic Controll System Air Heater

Sebelumnya saya sudah menjelaskan Tutorial Dasar Dalam Mendesign Fuzzy, baik menggunakan CVAVR maupun Arduino
silahkan terlebih dahulu untuk membaca artikel berikut, untuk lebih memahami Konses Fuzzy Logic.
karena tidak semua program di buat dengan Copy paste, saat ada error langsung panik seketika seolah dunia mau kiamat.

Keyword :

Tutorial Fuzzy Arduino
Mengerti Fuzzy dengan Mudah
Belajar Fuzzy dengan Arduino
Contoh Program Fuzzy
Contoh Fuzzy Controll System
Belajar Fuzzy Logic
Fuzzy Program
pelajari semuanya perlahan, jangan langsung Copy Paste kemudian Error, beranggapan Codenya tidak Works.

tipe orang seperti ini mungkin kalo di dunia hacker sebutanya Script Kiddie. menggunakan code tanpa dia mengerti code tersebut. ya kira kira begitu.

untuk itu mari kita coba simak dengan seksama, dan jika belum menegerti, pelajari berulang – ulang, karena kemampuan otak kita tidak sehebat Imam Syafi’i, baca sekali langsung hafal.

sadar diri terhadap kemampuan, dengan cara berusaha lebih keras. karena yang saya lakukan juga banyak mengalami kegagalan, bahkan mungkin kegagalan saya lebih banyak.

baiklah lanjut mengenai Tutorial Fuzzy menggunakan Arduino Uno. 

Arduino, Tutorial Fuzzy Logic (Fuzzifikasi)
Arduino, Tutorial Fuzzy Logic (Rule)
Arduino, Tutorial Fuzzy Logic (Defuzzifikasi)

setidaknya artikel diatas menjelaskan konsep dalam mendesain fuzzy. karena pada artikel ini, penjelasanya tidak selengkap yang di atas.

dalam mendesign Fuzzy, terlebih dahulu kita membuat Membership Function, biasa di kategorikan tahap Fuzzifikasi.
berikut adalah gambar fungsi keanggotaan dari Sistem Air Heater yang saya design

Download CODE

Membership Error

Membership dError

untuk membership Error dan dError sama, karena dError adalah hasil dari Error – Error Sebelumnya.
alasan kenapa dibuat seperti itu. begini penjelasanya.

kita tau Error = Sp – Suhu yang di Sensor
misalkan Sp = 30^C dan suhu yang disensor = 27^C maka Error = 3^C, dan Error = 3 membership nya termasuk pada bagian Error Positif dengan nilai keanggotaan = 1,
dan jika Sp = 30^C dan suhu yang di sensor = 32^C maka Error = -2^C dan Error = 3 membershipnya termasuk bagian Error Negatif dengan nilai Keanggotan = 1,

nah artinya, jika error < -1 maka didinginkan full, jika error > 1 dipanaskan Full, sedangkan selain itu, keputusanya di fuzzikan, entah didinginkan atau di panaskan.

Output PWM

Membership Function untuk Output sangat penting di buat untuk menentukan Rule dan juga defuzzifikasinya.
berikut adalah rumus dari membership function Output PWM

Rumus dari Membership Function Output

selanjutnya kita akan buat rule berdasarkan logika kita terhadap membership function yang sudah di buat.

Rule Fuzzy Air Heater

If Error = N And dError = N Then Out Dingin
If Error = N And dError = Z Then Out Dingin
If Error = Z And dError = N Then Out Dingin
If Error = Z And dError = Z Then Out Hangat
If Error = Z And dError = P Then Out Panas
If Error = P And dError = Z Then Out Panas
If Error = P And dError = P Then Out Panas

setelah itu kita bisa mengujikanya dengan program.
yang saya lakukan menguji dengan bahas C terlebih dahulu, menggunakan Code Block, untuk memvalidasi hasil Defuzzifikasinya. namun dengan Arduino IDE juga bisa dilakukan. terserah penggunanya.

nah berikut adalah program Lengkap Tutorial Fuzzy Logic Untuk Pengendali Air Heater

float error_1, error, dError, pwm, Sp = 60;
float anggotaErrorN, anggotadErrorN, anggotapwmN;
float anggotaErrorZ, anggotadErrorZ, anggotapwmZ;
float anggotaErrorP, anggotadErrorP, anggotapwmP;
float rule1, rule2, rule3, rule4a, rule4b, rule5, rule6, rule7;
int def;
float suhu;
int val; 
void error_suhu_N(){
if (error <=-1){ anggotaErrorN = 1;} else if (error > -1 && error < 0){ anggotaErrorN = (0 – error)/1;} else if (error >= 0) {anggotaErrorN = 0;}
}
void error_suhu_Z(){
if (error <=-1){ anggotaErrorZ = 0;} else if (error <= 0 && error >= -1){ anggotaErrorZ = (error + 1)/1;}
else if (error >= 0 && error < 1){ anggotaErrorZ = (1 – error)/1;} else if (error >= 1) {anggotaErrorZ = 0;}
}
void error_suhu_P(){
if (error >= 1){ anggotaErrorP = 1;}
else if (error < 1 && error > 0){ anggotaErrorP = (error – 0)/1;}
else if (error < 0 ) {anggotaErrorP = 0;}
}
void dError_suhu_N(){
if (dError <=-1){ anggotadErrorN = 1;} if (dError > -1 && dError <=0){ anggotadErrorN = (0 – dError)/1;} if (dError >= 0) {anggotadErrorN = 0;}
}
void dError_suhu_Z(){
if (error <=-1){ anggotadErrorZ = 0;} else if (dError <= 0 && dError > -1){ anggotadErrorZ = (dError + 1)/1;}
else if (dError >= 0 && dError < 1){ anggotadErrorZ = (1 – dError)/1;} else if (dError >= 1) {anggotadErrorZ = 0;}
}
void dError_suhu_P(){
if (dError >= 1){ anggotadErrorP = 1;}
else if (dError < 1 && dError > 0){ anggotadErrorP = (dError – 0)/1;}
else if (dError <= 0 ) {anggotadErrorP = 0;}
}
/*
void outPWM_N(){
if (pwm == 0){ anggotapwmN = 1;}
if (pwm > 0 && pwm < 127.5 ){ anggotapwmN = (0 – pwm)/80;}
if (pwm == 127.5) {anggotapwmN = 0;}
}
*/
void fuzifikasi() {
error_suhu_N();
error_suhu_Z();
error_suhu_P();
dError_suhu_N();
dError_suhu_Z();
dError_suhu_P();
}
float Min (float a, float b) {
if (a < b) {
return a;
}
else if (b < a) {
return b;
}
else return a;
}
void rule() {
fuzifikasi();
// rule1 If Error = N And dError = N Then Out N
float x1 = Min (anggotaErrorN, anggotadErrorN);
rule1 = 127.5 – (127.5 * x1);
// rule2 If Error = N And dError = Z Then Out N
float x2 = Min (anggotaErrorN, anggotadErrorZ);
rule2 = 127.5 – (127.5 * x2) ;
//If Error = Z And dError = N Then Out P
float x3 = Min (anggotaErrorZ, anggotadErrorN);
rule3 = 127.5 – (127.5 * x3) ;
//If Error = Z And dError = Z Then Out Z
float x4 = Min (anggotaErrorZ, anggotadErrorZ);
rule4a = 85 + (42.5 * x4);
rule4b = 170 – (42.5 * x4);
//If Error = Z And dError = P Then Out P
float x5 = Min (anggotaErrorZ, anggotadErrorP);
rule5 = 127.5 + (127.5 * x5);
//If Error = P And dError = Z Then Out P
float x6 = Min(anggotaErrorP, anggotadErrorZ);
rule6 = 127.5 + (127.5 * x6);
//If Error = P And dError = P Then Out P
float x7 = Min(anggotaErrorP, anggotadErrorP);
rule7 = 127.5 + (127.5 * x7);
def = ((x1 * rule1) + (x2 * rule2) + (x3 * rule3) + (x4 * rule4a) + (x4 * rule4b) + (x5 * rule5) + (x6 * rule6) + (x7 * rule7)) / (x1 + x2 + x3 + x4 + x4 + x5 + x6 + x7);
}
void runFuzzy() {
bacaSuhu();
error_1 = error;
error = Sp – suhu;
dError = error – error_1;
rule();
analogWrite(5, def);
}
void setup()
{
Serial.begin(9600);
// Serial.println(rule1);
// Serial.println(rule2);
// Serial.println(rule3);
// Serial.println(rule4a);
// Serial.println(rule4b);
// Serial.println(rule5);
// Serial.println(rule6);
// Serial.println(rule7);
// Serial.print(“\n”);
//
// Serial.println(anggotaErrorN);
// Serial.println(anggotaErrorZ);
// Serial.println(anggotaErrorP);
// Serial.println(anggotadErrorN);
// Serial.println(anggotadErrorZ);
// Serial.println(anggotadErrorP);
// Serial.println(anggotadErrorP);
// Serial.println(anggotadErrorP);
// Serial.println(anggotadErrorP);
// Serial.print(“\n”);
//
// 
}
void loop()
{
// if (Serial.available()){
// Sp = Serial.parseInt();
// }
runFuzzy();
// Serial.print(” “); Serial.print(error); Serial.print(” “);
// Serial.print(error_1); Serial.print(” “);
Serial.print(def);
Serial.print(” “); Serial.print(Sp); Serial.print(” “); Serial.println(suhu);
}
void bacaSuhu() {
val = analogRead(A0);
suhu = val / 2.0479;
delay(100);
}