LAPORAN RESMI

PRAKTIKUM KONTROL CERDAS 1

Oleh:

MUHAMMAD SAHAL
1110171026
3 D4 TEKNIK ELEKTRONIKA A

PROGRAM STUDI D4 TEKNIK ELEKTRONIKA

DEPARTEMEN ELEKTRO
POLITEKNIK ELEKTRONIKA NEGERI SURABAYA
TAHUN AJARAN 2019 – 2020
 BAB IV
Kontrol Logika Fuzzy pada
Pengaturan Kecepatan Motor DC

I. TUJUAN
Mahasiswa diharapkan memahami materi kontrol kecepatan dan aplikasinya
pada pengaturan kecepatan motor DC dengan menggunakan kontrol fuzzy

II. PERALATAN YANG DIBUTUHKAN

Percobaan ini membutuhkan :
1. Komputer 1 unit
2. Kabel Serial 1 unit
3. Modul Motor DC 1 unit

III. DASAR TEORI

Kontroler mengolah sinyal eror untuk menghasilkan suatu sinyal kontrol
yang merepresentasikan tindakan yang harus diambil ketika harga variabel yang
dikontrol mengalami penyimpangan dari set-point. Cara bagaimana kontroler
menghasilkan sinyal kontrol dinamakan aksi kontrol atau mode kontrol. Mode
kontroler biasanya dibagi dua, yaitu kontroler diskontinyu (misalnya kontroler dua
posisi/ON-OFF dan multi posisi) dan kontroler kontinyu (misalnya kontroler PID).
Kontroler cerdas menggunakan model atau proses berdasarkan pengalaman
yang umumnya menghasilkan suatu model yang lebih menekankan bagaimana
proses kelakuan input/output berlangsung daripada pemodelan yang berdasarkan
sebuah respon yang dibangkitkan oleh suatu input perangsang. Sebagai contoh,
sebuah kontroler sistem pakar (expert system), menghasilkan suatu kontroler “rule-
base” yang menghasilkan output berdasarkan pada “bagaimana cara” operasi
manusia. Problem tersebut kemudian bagaimana untuk memperoleh “human
controller” dan menyatakan dengan sebuah cara yang ringkas, representasional dan
dengan perhitungan yang efisien.

32
 Metode yang akan digunakan dalam penelitian ini dalam menentukan output
kontroler pada eror dan derror tertentu yang kemudian diolah dengan menggunakan
metode kontroller Fuzzy untuk masing-masing motor.

Kontroller Fuzzy.
1) Fuzzifikasi
Proses fuzzifikasi merupakan proses untuk mengubah variable non fuzzy
(variabel numerik) menjadi variabel fuzzy (variabel linguistik). Nilai masukan-
masukan yang masih dalam bentuk variabel numeric yang telah dikuantisasi
sebelum diolah oleh pengendali logika fuzzy harus diubah terlebih dahulu ke dalam
variabel fuzzy. Melalui fungsi keanggotaan yang telah disusun maka dari nilai-nilai
masukan tersebut menjadi informasi fuzzy yang berguna nantinya untuk proses
pengolahan secara fuzzy pula. Preses inilah disebut fuzzyfikasi. Keanggotaan yang
digunakan adalah  (triangular).

* Triangular-function 3
Triangular – function didefinisikan sebagai berikut:
0 ua 
 
u  a
b  a a  u  b
T (u; a, b, c ) = 
 (1)
c  u 
buc
c  b 


0 uc 
Bentuk diagramatik Triangular-function ditunjukkan pada gambar 1

0.5

0 a b c

Gambar 4.1. Diagramatik Triangular-function

33
Dengan kata lain fuzzifikasi merupakan pemetaan titik numeric (crisp points) x =
(x1,…,xn)T  U ke himpunan fuzzy A di U. U merupakan semesta pembicaraan dan
pemetaannya yaitu :
Fuzzifikasi Singleton : A adalah fuzzy singleton dengan support x , artinya, A( x ’)

= 1 untuk x ’ = x dan A( x ’) = 0 untuk x ’  U yang lain dengan x ’ x

2) Penyusunan Aturan untuk pengendalian keputusan

Pada umumnya aturan-aturan fuzzy dinyatakan dalam bentuk ‘IF-THEN’ yang
merupakan inti dari relasi fuzzy. Relasi fuzzy dalam pengetahuan dasar dapat
didefinisikan sebagai himpunan pada implikasi fuzzy. Aturan dasar fuzzy adalah
dalam bentuk umum :
R(1) :IF x1 is F11 AND … AND … xn is Fn1, THEN y is G1
Dimana F11 dan G1 adalah himpunan fuzzy masing-masing di U1  R dan V  R,

dan x = (x1, … ,xn)T  U1X … XUn dan y  V adalah variable linguistik.

3) Defuzzyfikasi
Dalam sistem pengendalian secara umum, terdapat suatu hubungan sebab
akibat yang spesifik antara masukan dan keluaran sistem tersebut. Karakteristik
hubungan inilah yang membedakan satu sistem dengan sistem yang lain.
Sistem pengendalian dengan menggunakan logika fuzzy juga
membutuhkan spesifikasi hubungan antara masukan dan keluaran, yang secara
umum dinyatakan :
IF (A1) Then (B1)

IF (An) Then (Bn)

A1,..,An adalah antecedent, yaitu masukan yang telah difuzzifikasi,
sedangkan B1,..,Bn adalah consequent, yaitu aksi keluaran. Hubungan antara
antecedent dan consequent disebut aturan(rule), dan antar satu rule dengan yang
lain tidak ada hubungan sebab akibat.
Proses untuk mendapatkan aksi keluaran dari suatu kondisi masukan dengan
mengikuti rules yang telah ditetapkan disebut inference atau reasoning

34
(pengambilan keputusan). Keputusan yang dihasilkan dari proses reasoning ini
masih dalam bentuk fuzzy, yaitu berupa derajat keanggotaan keluaran. Hasil ini
harus diubah kembali menjadi variabel numerik non-fuzzy melalui proses
defuzzifikasi. Metode defuzzifikasi yang digunakan adalah Centre of Area (COA)
yang didefinisikan sebagai :

Vk v (Vk )
v  k 1m (2)
v (Vk )
0

v0 = nilai keluaran
k 1

m = tingkat kuantisasi
Vk = elemen ke-k
v(Vk) = derajat keanggotaan elemen-elemen pada fuzzy set V
V= semesta pembicaraan

4) Kontrol Fuzzy dan Respon Sistem

Aturan kontrol fuzzy (rule base) suatu kontrol logika fuzzy, merupakan

kumpulan aturan-aturan kontrol sebagai acuan untuk menyatakan aksi kontroler.

Aturan tersebut disusun berdasarkan pengamatan atau perkiraan terhadap respon

secara heuristik, dengan melakukan pengamatan respon terhadap masukan,

kemudian dengan naluri keteknikan (engineering science) ditentukan rule base

kontroler logika fuzzy yang sesuai.

Respon sistem dibagi menjadi 4 area seperti ditunjukan pada Gambar 4.2

(a,b,c) berikut. Indeks digunakan untuk menganalisa respon area dengan tujuan

meningkatkan resolusi dari tingkah laku sistem, identifikasi kecepatan dari respon

sistem disekitar setpoint yang ditunjukkan pada Gambar 4.2 didefinisikan sebagai

berikut:

35
 a1 : e>0 dan e<0 a3 : e<0 dan e>0

a2 : e<0 dan e<0 a4 : e>0 dan e>0

a1 a2 a3 a4

Setpoint

Gambar 4.2. Indentifikasi kecepatan dari respon sistem

Indeks Crossover untuk mengindentifikasi slope dari respon sistem disekitar

setpoint seperti ditunjukkan pada Gambar 4.2 didefinisikan dengan

c1 : (e>0 atau e<0) dan e<<<0

c2 : (e>0 atau e<0) dan e<<0

c3 : (e>0 atau e<0) dan e<0

c4 : (e<0 atau e>0) dan e>0

c5 : (e<0 atau e>0) dan e>>0

c6 : (e<0 atau e>0) dan e>>>0

C1
C2
C3
C4
C5
C6 Setpoint

Gambar 4.3 Indentifikasi slope dari respon sistem

36
 Sedangkan indeks yang menyatakan perluasan overshoot dan undershoot

seperti terlihat pada Gambar 4.3 didefinisikan dengan :

m1 : e  0 dan e <<< 0 m4 : e  0 dan e > 0

m2 : e  0 dan e << 0 m5 : e  0 dan e >> 0

m3 : e  0 dan e < 0 m6 : e  0 dan e >>> 0

m2
m1 m3

m4 Setpoint
m5
m6

Gambar 4.4. Indentifikasi overshoot dan undershoot dari respon sistem

Tabel 1. Rule base berdasarkan area

E/E nb nm nk nol pk pm pb

nb a2 a2 a2 m1 a3 a3 a3

nm a2 a2 a2 m2 a3 a3 a3

nk a2 a2 a2 m3 a3 a3 a3

nol c1 c2 c3 nol c4 c5 c6

pk a1 a1 a1 m4 a4 a4 a4

pm a1 a1 a1 m5 a4 a4 a4

pb a1 a1 a1 m6 a4 a4 a4

37
 Aturan atau rule base kontroler logika fuzzy yang dirancang dengan logika

“jika – maka” dinyatakan sebagai berikut :

R1 : Jika E adalah nb dan E adalah nb maka output adalah nb

R2 : Jika E adalah nb dan E adalah nm maka output adalah nb

R3 : Jika E adalah nb dan E adalah nk maka output adalah nb

..........................................................................................................

R49 : Jika E adalah nb dan E adalah nb maka output adalah nb

Secara lengkap rule base kontroler logika fuzzy pada praktikum ini, yang

diturunkan dengan metode pendekatan heuristik ditunjukkan pada tabel berikut

Tabel 2. Rule base kontroler logika fuzzy

E/E nb nm nk nol pk pm pb

nb nb nb nb nb nm nk nol

nm nb nb nm nm nk nol pk

nk nb nm nk nk nol pk pm

nol nb nk nm nol pk pm pb

pk nm nk nol pk pk pm pb

pm nk nol pk pm pm pb pb

pb nol pk pm pb pb pb pb

38
5) Struktur Dasar Sistem Pengendalian Logika Fuzzy
Kebanyakan proses di dalam sistem pengendalian merupakan proses yang
komplek. Proses-proses tersebut pada kenyataannya bisa dikontrol secara manual
dengan hasil yang cukup baik, oleh operator. Operator tersebut adalah tenaga
terampil yang mengandalkan pengalaman praktis, tanpa dilatarbelakangi teori-teori
sistem pengendalian yang rumit. Pengalaman tersebut diperoleh dalam waktu yang
lama, sehingga pengendalian yang dilakukan sepenuhnya bersifat intuitif. Untuk
mendesain sistem pengendalian otomatis bagi proses-proses tersebut, diperlukan
motode khusus, dalam hal ini digunakan teori logika fuzzy.

Kontroler fuzzy

z-1
Data base

output

Fuzzification Control Rule Defuzzification Process/

Bus System
E

Sensor

Gambar 4.5. Struktur sistem kontrol logika fuzzy dengan error dan delta error

Kontroler fuzzy dalam gambar 2 mempunyai pengolahan dua sinyal masukan

ke kontroler, yaitu sinyal kesalahan (error,E), dan sinyal perubahan kesalahan (delta
error, dE). Sinyal E didapatkan dari pengurangan keluaran proses terhadap set point,
sedangkan sinyal dE didapatkan dari pengurangan sinyal error saat ini E(k), dengan
sinyal error sebelumnya E(k-1). Kedua sinyal tersebut diolah kontroler fuzzy.

Pengaturan Kecepatan Motor DC

Pada saat motor mulai dijalankan (start), tegangan jangkar (Ea) akan
berharga nol dan jika kumparan jangkar dihubungkan langsung ke catu daya maka
arus yang mengalir akan sangat besar karena harga tahanan jangkar sangat kecil.
Untuk itu diperlukan sebuah fasilitas peralatan untuk membatasi arus start yang
besar ini.

39
 Untuk keperluan ini, digunakan beberapa tahanan yang dihubungkan seri
dengan kumparan jangkar untuk starting. Dengan mengunakan tahanan- tahanan ini,
maka motor akan mencapai kecepatan nominal secar perlahan- lahan. Dengan car
ini, maka arus medan akan selalu di set-up pada harga maksimum untuk
memperoleh torsi starting maksimum. Semakin handle digerakkan ke kanan, maka
pengaruh elektromagnetik semakin kecil.
Pada saat motor berjalan, kecepatan dapat diatur. Kecepatan ini pada
dasarnya dikontrol dengan mengatur rasio waktu. Bila rasio waktunya bertambah
secara bekurang bolak balik, kecepatan juga menunjukkan pengulanggan dari
penambahan dan pengurangan. Dimana kecepatan motor DC dapt diatur dengan
mengubah- ubah besaran medan shunt (), Ra, atau Vt.
Secara garis besar, ada dua bagian utama yaitu PC sebagai kontroller
dan modul motor DC yang akan dikontrol. Blok diagramnya sebagai berikut :

Data hsl Sinyal

perhitungan PWM
PC MODUL uC MOTOR

Feedback FeedBack

Gambar 4.6. Blok diagram Modul

PC digunakan untuk menjalankan menjalankan program fuzzy dan menerima data
feedback dari motor DC. Output dari fuzzy dipergunakan untuk menentukan
frekuensi dari PWM yang dihasilkan oleh mikrokontroller. Kecepatan motor
ditentukan oleh berapa besar dutty cycle dari PWM. Set point kecepatan motor
adalah sekitar 91 rps.
Pembebanan perlu dilakukan pada motor, tujuannya adalah untuk
mengetauhi kinerja dari kontroller fuzzy. Apabila setelah dilakukan pembebanan
kemudian kecepatan motor turun sebentar dan kemudian kembali mendekati nilai
set point maka kontroller fuzzy tealah bekerja dengan baik. Pembebanan dilakukan
dengan menggunakan potensiometer yang dipasang seri dengan armatur motor.
Sehingga apabila tahanan potensiometer R1 dan R2 dinaikkan maka kecepatan
motor akan turun. Rangkaiannya sebagai berikut :

40
 R

medan

Gambar 4.7. Rangkaian tahanan untuk menurunkan

kecepatan putaran motor

Dimana kecepatan motor dirumuskan :

N = ( Va – Ia.Ra)/f

Dari persamaan yang ditunjukkan diatas maka kecepatan dapat diubah ubah
dengan mengatur variabel ;
Va = Tegangan input (V),
Ra = Tahanan armatur () dan f = Fluks motor
Sedangkan komponen pennyusun modul motor DC sebagai berikut :

Con DB 9 Feed Back kecepatan motor

Dari & ke PC

Motor
Microcontroller
Sinyal PWM

Driver Motor
Power Supply

Gambar 4.8. komponen pennyusun modul pengontrol kecepatan motor DC

41
IV. PROSEDUR PRAKTIKUM
1. Buatlah rangkaian seperti gambar berikut :

Komputer Modul Motor DC

Sinyal
PWM

PC MODUL MOTOR
Kabel Serial uC

FeedBack

Gambar 4.9 Rangkaian modul praktikum

Berikut adalah tabel dan grafik kecepatan motor dc pada pemberian nilai
PWM yang berbeda dari 0 – 100 % :

Kecepatan Motor DC

120

100
Kecepatan (rps)

80

60

40

20

0
0 20 40 60 80 100 120
% PWM

Gambar 4.10 Grafik Kecepatan motor DC

2. Rangkaikan modul motor DC, catat nilai maksimal kecepatan Motor DC
: ...... rps dengan nilai PWM sebesar 30%.
3. Lengkapi pada program fuzzy, MF error, d_error dan output berikut :
'Fuzzifikasi Error (-0,5 max rps s.d 0.5 max rps)
er_NB = trapmin(error, , )
er_NS = Segitiga(error, , , )
er_ZR = Segitiga(error, , , )
er_PS = Segitiga(error, , , )
er_PB = trapplus(error, , )

42
 'Fuzzifikasi Delta Error (-0,25 max rps s.d 0.25 max rps)
de_NB = trapmin(d_error, , )
de_NS = Segitiga(d_error, , , )
de_ZR = Segitiga(d_error, , , )
de_PS = Segitiga(d_error, , , )
de_PB = trapplus(d_error, , )

'Nilai center PWM -50 s.d 50,

NB =
NS =
ZR =
PS =
PB =

4. Lengkapi tabel rule base berikut

d_error
X NB NS ZR PS PB
NB
NS
error
ZR
PS
PB

5. Amati hasil yang didapat (Setpoint = sesuai dengan 30%)

Beban Error tanpa Error dengan Error dengan
potensiometer kontroller (rps) kontrol fuzzy kontrol
( 0) (rps) proportional
(rps)
0
45
90
135
180

V. ANALISA DAN KESIMPULAN

1. Beri analisa dan kesimpulan hasil percobaan.
2. Bandingkan performasi kontrol proporsional dengan kontrol fuzzy.
3. Modifikasi tabel aturan untuk mendapatkan sistem kontrol yang
mengutamakan performasi waktu naik sistem.

43
 4. Uji coba dan berikan analisa pengaruh perubahan tabel aturan pada
performasi sistem kontrol fuzzy.

Analisa Data Kontrol Kecepatan motor dengan Kontrol Fuzzy

I. Tentukan nilai maksimal kecepatan Motor DC : ...... rps

J. Lengkapi MF error, d_error dan output berikut :

'Fuzzifikasi Error (-0,5 max rps s.d 0.5 max rps)

er_NB = trapmin(error, , )
er_NS = Segitiga(error, , , )
er_ZR = Segitiga(error, , , )
er_PS = Segitiga(error, , , )
er_PB = trapplus(error, , )

'Fuzzifikasi Delta Error (-0,25 max rps s.d 0.25 max rps)
de_NB = trapmin(d_error, , )
de_NS = Segitiga(d_error, , , )
de_ZR = Segitiga(d_error, , , )
de_PS = Segitiga(d_error, , , )
de_PB = trapplus(d_error, , )

'Nilai center PWM -50 s.d 50,

NB =
NS =
ZR =
PS =
PB =

3. Lengkapi tabel rule base berikut

d_error
X NB NS ZR PS PB
NB
NS
error
ZR
PS
PB
Contoh listing Program Kontroler Fuzzy
Function Segitiga(u As Single, a As Single, b As Single, c As Single) As Single

If (u < a) Then
Segitiga = 0
ElseIf ((u >= a) And (u < b)) Then
Segitiga = ((u - a) / (b - a))
ElseIf ((u >= b) And (u < c)) Then
Segitiga = ((c - u) / (c - b))
Else
Segitiga = 0
End If

End Function

Function Fuzzy(err As Single, derr As Single) As Single

'Fuzzifikasi Error edit disini

er_NB = trapmin(error, -50, -30)
er_NS = Segitiga(error, , , )
er_ZR = Segitiga(error, , , )
er_PS = Segitiga(error, , , )
er_PB = trapplus(error, , )

'Fuzzifikasi Delta Error’de_NB = trapmin(derror, , )

de_NS = Segitiga(derror, , , )
de_ZR = Segitiga(derror, , , )
de_PS = Segitiga(derror, , , )
de_PB = trapplus(derror, , )

'Rule Base
'Error = setpoint - rps
'derror = error - errorlalu

r1 = Minimal(er_NB, de_NB)
r2 = Minimal(er_NB, de_NS)
r3 = Minimal(er_NB, de_ZR)
r4 = Minimal(er_NB, de_PS)
r5 = Minimal(er_NB, de_PB)

r6 = Minimal(er_NS, de_NB)
r7 = Minimal(er_NS, de_NS)
r8 = Minimal(er_NS, de_ZR)
r9 = Minimal(er_NS, de_PS)
r10 = Minimal(er_NS, de_PB)

r11 = Minimal(er_ZR, de_NB)

r12 = Minimal(er_ZR, de_NS)
r13 = Minimal(er_ZR, de_ZR)
r14 = Minimal(er_ZR, de_PS)
r15 = Minimal(er_ZR, de_PB)
 r16 = Minimal(er_PS, de_NB)
r17 = Minimal(er_PS, de_NS)
r18 = Minimal(er_PS, de_ZR)
r19 = Minimal(er_PS, de_PS)
r20 = Minimal(er_PS, de_PB)

r21 = Minimal(er_PB, de_NB)

r22 = Minimal(er_PB, de_NS)
r23 = Minimal(er_PB, de_ZR)
r24 = Minimal(er_PB, de_PS)
r25 = Minimal(er_PB, de_PB)

'Nilai center PWM -50 s.d 50, edit disini

NB =
NS =
ZR =
PS =
PB =

temp = (r1 + r2 + r3 + r4 + r5 + r6 + r7 + r8 + r9 + r10 + r11 + r12 + r13 + r14 +

r15 + r16 + r17 + r18 + r19 + r20 + r21 + r22 + r23 + r24 + r25)

'Edit disini
If temp <> 0 Then Fuzzy = ((r1 * NB) + (r2 * NB) + ........... (R25*ZR) / (temp)

End Function

Function Minimal(inp1 As Single, inp2 As Single) As Single

If inp1 > inp2 Then
Minimal = inp2
Else: Minimal = inp1
End If

End Function

Function trapmin(u1 As Single, a1 As Single, b1 As Single) As Single

If u1 < a1 Then
trapmin = 1
ElseIf ((u1 >= a1) And (u1 < b1)) Then
trapmin = ((b1 - u1) / (b1 - a1))
ElseIf u1 > b1 Then
trapmin = 0
End If

End Function

Function trapplus(u2 As Single, a2 As Single, b2 As Single) As Single

If u2 < a2 Then
trapplus = 0
ElseIf ((u2 >= a2) And (u2 <= b2)) Then
trapplus = ((u2 - a2) / (b2 - a2))
ElseIf u2 > b2 Then
trapplus = 1
End If

End Function
Praktikum Kontrol Cerdas 1
Desember 2019
Lab D-106
Anggota:
1. Alfaz Mahardika A (1110171030)
2. Rizky Muhammad P (1110171023)
3. Yogi A (1110171018)

PERCOBAAN 7

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Fuzzy_Classification_CSharp
{
public partial class Form1 : Form
{
float segitiga;
float trapmin;
float trapplus;
float val_minimal;
float temp, sudutREM, tempf;

public Form1()
{
InitializeComponent();
}

private void Form1_Load(object sender, EventArgs e)

 {

private void button1_Click(object sender, EventArgs e)

{
float kecepatan, sangatLambat, Lambat, cukup, cepat, cepatSelali;
float jarak, sangatDekat, agakDekat, sedang, agakJauh, jauhSekali;
float Penuh, agakPenuh, injakSedang, sedikit, sedikitSekali;
float err, derr;
float[] mi = new float[25];
float[] rulef = new float[25];

/* Fuzzifikasi Kecepatan */
kecepatan = float.Parse(textBox11.Text);
sangatLambat = Segitiga(kecepatan, -20, 0, 20);
Lambat = Segitiga(kecepatan, 0, 20, 40);
cukup = Segitiga(kecepatan, 20, 40, 60);
cepat = Segitiga(kecepatan, 40, 60, 80);
cepatSelali = Segitiga(kecepatan, 60, 80, 100);

textBox1.Text = Convert.ToString(sangatLambat);
textBox2.Text = Convert.ToString(Lambat);
textBox3.Text = Convert.ToString(cukup);
textBox4.Text = Convert.ToString(cepat);
textBox5.Text = Convert.ToString(cepatSelali);

//textBox1.Text = Convert.ToString(Segitiga(float.Parse(textBox11.Text), -20, 0,

20)); //Sangat Lambat
//textBox2.Text = Convert.ToString(Segitiga(float.Parse(textBox11.Text), 0, 20, 40));
//Lambat
//textBox3.Text = Convert.ToString(Segitiga(float.Parse(textBox11.Text), 20, 40,
60)); //Cukup
//textBox4.Text = Convert.ToString(Segitiga(float.Parse(textBox11.Text), 40, 60,
80)); //Cepat
 //textBox5.Text = Convert.ToString(Segitiga(float.Parse(textBox11.Text), 60, 80,
100)); //Cepat Sekali

/* Fuzzifikasi Jarak */
jarak = float.Parse(textBox12.Text);
sangatDekat = Segitiga(jarak, -1, 0, 1);
agakDekat = Segitiga(jarak, 0, 1, 2);
sedang = Segitiga(jarak, 1, 2, 3);
agakJauh = Segitiga(jarak, 2, 3, 4);
jauhSekali = Segitiga(jarak, 3, 4, 5);

textBox6.Text = Convert.ToString(sangatDekat);
textBox7.Text = Convert.ToString(agakDekat);
textBox8.Text = Convert.ToString(sedang);
textBox9.Text = Convert.ToString(agakJauh);
textBox10.Text = Convert.ToString(jauhSekali);

/* Nilai center pengereman */

Penuh = 0;
agakPenuh = 10;
injakSedang = 20;
sedikit = 30;
sedikitSekali = 40;

/* Nilai infrensi minimal */

mi[0] = minimal(sangatLambat, sangatDekat);
mi[1] = minimal(sangatLambat, agakDekat);
mi[2] = minimal(sangatLambat, sedang);
mi[3] = minimal(sangatLambat, agakJauh);
mi[4] = minimal(sangatLambat, jauhSekali);

mi[5] = minimal(Lambat, sangatDekat);

mi[6] = minimal(Lambat, agakDekat);
mi[7] = minimal(Lambat, sedang);
mi[8] = minimal(Lambat, agakJauh);
mi[9] = minimal(Lambat, jauhSekali);

mi[10] = minimal(cukup, sangatDekat);

mi[11] = minimal(cukup, agakDekat);
mi[12] = minimal(cukup, sedang);
mi[13] = minimal(cukup, agakJauh);
mi[14] = minimal(cukup, jauhSekali);

mi[15] = minimal(cepat, sangatDekat);

mi[16] = minimal(cepat, agakDekat);
mi[17] = minimal(cepat, sedang);
mi[18] = minimal(cepat, agakJauh);
mi[19] = minimal(cepat, jauhSekali);

mi[20] = minimal(cepatSelali, sangatDekat);

mi[21] = minimal(cepatSelali, agakDekat);
mi[22] = minimal(cepatSelali, sedang);
mi[23] = minimal(cepatSelali, agakJauh);
mi[24] = minimal(cepatSelali, jauhSekali);

rulef[0] = minimal(sangatLambat, sangatDekat) * sedikit;

rulef[1] = minimal(sangatLambat, agakDekat) * sedikit;
rulef[2] = minimal(sangatLambat, sedang) * sedikitSekali;
rulef[3] = minimal(sangatLambat, agakJauh) * sedikitSekali;
rulef[4] = minimal(sangatLambat, jauhSekali) * sedikitSekali;

rulef[5] = minimal(Lambat, sangatDekat) * sedikit;

rulef[6] = minimal(Lambat, agakDekat) * sedikit;
rulef[7] = minimal(Lambat, sedang) * sedikitSekali;
rulef[8] = minimal(Lambat, agakJauh) * sedikitSekali;
rulef[9] = minimal(Lambat, jauhSekali) * sedikitSekali;

rulef[10] = minimal(cukup, sangatDekat) * Penuh;

rulef[11] = minimal(cukup, agakDekat) * agakPenuh;
rulef[12] = minimal(cukup, sedang) * injakSedang;
 rulef[13] = minimal(cukup, agakJauh) * sedikitSekali;
rulef[14] = minimal(cukup, jauhSekali) *sedikit;

rulef[15] = minimal(cepat, sangatDekat) *Penuh;

rulef[16] = minimal(cepat, agakDekat) * Penuh;
rulef[17] = minimal(cepat, sedang) * agakPenuh;
rulef[18] = minimal(cepat, agakJauh) * injakSedang;
rulef[19] = minimal(cepat, jauhSekali) * injakSedang;

rulef[20] = minimal(cepatSelali, sangatDekat) * Penuh;

rulef[21] = minimal(cepatSelali, agakDekat) * Penuh;
rulef[22] = minimal(cepatSelali, sedang) * agakPenuh;
rulef[23] = minimal(cepatSelali, agakJauh) * agakPenuh;
rulef[24] = minimal(cepatSelali, jauhSekali) * sedikitSekali;

for (int i=1; i < 25; i++)

{
temp = temp + mi[i];
tempf = tempf + rulef[i];

if (mi[i] > 0)
{
listBox1.Items.Add("Rule" + Convert.ToString(i) + "=" +
Convert.ToString(rulef[i]));
}
}
if (temp > 0)
{
sudutREM = tempf / temp;
}
else
{
textBox13.Text = "Tidak ada Hasil.";
}
textBox13.Text = Convert.ToString(sudutREM);
 err = float.Parse(textBox15.Text);
derr = float.Parse(textBox14.Text);
fuzzy_func(err, derr);
}

private float Segitiga(float u, float a, float b, float c)

{
if (u < a)
segitiga = 0;
else if ((u >= a) && (u < b))
segitiga = ((u - a) / (b - a));
else if ((u >= b) && (u < c))
segitiga = ((c - u) / (c - b));
else
segitiga = 0;

return segitiga;
}

private float fuzzy_func( float error, float delta_error)

{
//function error
float error_NB, error_NS, error_ZR, error_PS, error_PB;
float fuzzy = 0;
float de_NB, de_NS, de_ZR, de_PS, de_PB;
float NB, NS, ZR, PS, PB;
float r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20,
r21, r22, r23, r24, r25;
float tempura = 0;

error_NB = Trapmin(error, -30, -10);

error_NS = Segitiga(error, -20, -10, 0);
error_ZR = Segitiga(error, -10, 0, 10);
error_PS = Segitiga(error, 0, 10, 20);
error_PB = Trapplus(error, 10, 30);

de_NB = Trapmin(delta_error, -12, -4);

de_NS = Segitiga(delta_error, -8, -4, 0);
de_ZR = Segitiga(delta_error, -4, 0, 4);
de_PS = Segitiga(delta_error, 0, 4, 8);
de_PB = Trapplus(delta_error, 8, 12);

r1 = minimal(error_NB, error_NB);
r2 = minimal(error_NB, error_NS);
r3 = minimal(error_NB, error_ZR);
r4 = minimal(error_NB, error_PS);
r5 = minimal(error_NB, error_PB);

r6 = minimal(error_NS, error_NB);
r7 = minimal(error_NS, error_NS);
r8 = minimal(error_NS, error_ZR);
r9 = minimal(error_NS, error_PS);
r10 = minimal(error_NS, error_PB);

r11 = minimal(error_ZR, error_NB);

r12 = minimal(error_ZR, error_NS);
r13 = minimal(error_ZR, error_ZR);
r14 = minimal(error_ZR, error_PS);
r15 = minimal(error_ZR, error_PB);

r16 = minimal(error_PS, error_NB);

r17 = minimal(error_PS, error_NS);
r18 = minimal(error_PS, error_ZR);
r19 = minimal(error_PS, error_PS);
r20 = minimal(error_PS, error_PB);

r21 = minimal(error_PB, error_NB);

r22 = minimal(error_PB, error_NS);
r23 = minimal(error_PB, error_ZR);
 r24 = minimal(error_PB, error_PS);
r25 = minimal(error_PB, error_PB);

NB = -30;
NS = -10;
ZR = 0;
PS = 10;
PB = 30;

tempura = (r1 + r2 + r3 + r4 + r5 + r6 + r7 + r8 + r9 + r10 + r11 + r12 + r13 + r14 +

r15 + r16 + r17 + r18 + r19 + r20 + r21 + r22 + r23 + r24 + r25);
if (tempura != 0)
{
fuzzy = ((r1 * NB) + (r2 * NB) + (r3 * NS) + (r4 * PS) + (r5 * PB) + (r6 * NS) +
(r7 * NS) + (r8 * ZR) + (r9 * PS) + (r10 * PB) + (r11 * NB) + (r12 * NS) + (r13 * ZR) + (r14
* PS) + (r15 * PB) + (r16 * NS) + (r17 * NS) + (r18 * PS) + (r19 * PB) + (r20 * PB) + (r21 *
NS) + (r22 * PS) + (r23 * PB) + (r24 * PB) + (r25 * PB)/ tempura);
}

textBox16.Text = Convert.ToString(fuzzy);

return fuzzy;
}
private float Trapmin(float u1, float a1, float b1)
{
if (u1 < a1)
{
trapmin = 1;
}
else if ((u1 >= a1) && (u1 < b1))
{
trapmin = ((b1 - u1) / (b1 - a1));
}
else if ((u1 > b1))
{
 trapmin = 0;
}

return trapmin;
}

private float Trapplus(float u2, float a2, float b2)

{
if (u2 < a2)
{
trapplus = 1;
}
else if ((u2 >= a2) && (u2 <= b2))
{
trapplus = ((u2 - a2) / (b2 - a2));
}
else if (u2 > b2)
{
trapplus = 0;
}

return trapplus;

private float minimal(float inp1, float inp2)

{
if (inp1 > inp2)
{
val_minimal = inp2;
}
else
{
val_minimal = inp1;
}
 return val_minimal;
}

private void groupBox1_Enter(object sender, EventArgs e)

{

private void textBox11_TextChanged(object sender, EventArgs e)

{

}
private void button2_Click(object sender, EventArgs e)
{
listBox1.Items.Clear();
textBox13.Text = string.Empty;
}
}
}
ANALISA
Dari percobaan dapat dianalisa bahwasanya untuk menentukan nilai pengereman maka
terdapat 2 input berupa kecepatan dan jarak yang akan mempengaruhinya. Setiap input dan
output memiliki membershipnya sendiri sendiri yaitu :
Input Kecepatan (Sangat lambat , lambat , cukup ,cepat ,cepat sekali)
Input Jarak ( Sangat dekat, Agak dekat , sedang , Agak jauh, Jauh sekali)
Output pengereman ( Penuh , Agak penuh , Injak sedang , sedikit , Sedikit sekali )
Kemudian untuk didapat beberapa rule base dimana didapat sebanyak 25 rule. Untuk rule
base bisa dilihat pada program diatas. Kemudian juga terdapat Membership error berupa
membership (Trapmin , Segitiga , Segitiga, Segitiga , Trapplus )
Dan nilai center dari output :
NB = -30;
NS = -10;
ZR = 0;
PS = 10;
PB = 30;
Sehingga rumus akhir untuk mendapat output fuzzy didapat :
‘output’ tempura = (r1 + r2 + r3 + r4 + r5 + r6 + r7 + r8 + r9 + r10 + r11 + r12 + r13 +
r14 + r15 + r16 + r17 + r18 + r19 + r20 + r21 + r22 + r23 + r24 + r25);
if (tempura != 0)
{
fuzzy = ((r1 * NB) + (r2 * NB) + (r3 * NS) + (r4 * PS) + (r5 * PB) + (r6 * NS) +
(r7 * NS) + (r8 * ZR) + (r9 * PS) + (r10 * PB) + (r11 * NB) + (r12 * NS) + (r13 * ZR) + (r14
* PS) + (r15 * PB) + (r16 * NS) + (r17 * NS) + (r18 * PS) + (r19 * PB) + (r20 * PB) + (r21 *
NS) + (r22 * PS) + (r23 * PB) + (r24 * PB) + (r25 * PB)/ tempura);
}

KESIMPULAN
Dalam merancang sistem kontrol dengan menggunakan logika fuzzy terdapat tiga proses
yaitu fuzzifikasi, evaluasi rule dan defuzzifikasi. Masing-masing proses tersebut akan
mempengaruhi respon sistem yang dikendalikan. Defuzzifikasi merupakan langkah terakhir
dalam suatu sistem logika fuzzy dengan tujuannya mengkonversi setiap hasil dari inference
engine yang diekspresikan dalam bentuk fuzzy set kesuatu bilangan real. Hasil konversi
tersebut merupakan aksi yang diambil oleh sistem kendali logika fuzzy. Karena itu, pemilihan
metode defuzzifikasi yang sesuai juga turut mempengaruhi sistem kendali logika fuzzy dalam
menghasilkan respon yang optimum