LAPORAN RESMI

PRAKTIKUM KONTROL CERDAS 1

Disusun Oleh:

RIZKY MUHAMMAD PANJI

1110171023

3 D4 ELEKTRONIKA A

PRODI D4 TEKNIK ELEKTRONIKA

DEPARTEMEN ELEKTRO

POLITEKNIK ELEKTRONIKA NEGERI SURABAYA

2019 / 2020
 PERCOBAAN 7
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.

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:

Bentuk diagramatik Triangular-function ditunjukkan pada gambar 1

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 F 1, THEN
n 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 (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 :

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:

Indeks Crossover untuk mengindentifikasi slope dari respon sistem disekitar setpoint

seperti ditunjukkan pada Gambar 4.2 didefinisikan dengan

 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
Setpoin
m6 t

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
 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
1) 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
-1
z
Data base

outpu
t
Fuzzification Control Rule Defuzzification
Bus System

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.
 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 MOTOR

Feedback MODUL uC 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 :
 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

I. PROSEDUR PRAKTIKUM
1. Buatlah rangkaian seperti gambar berikut :

Komputer Modul Motor DC

Sinyal
PWM

MODUL MOTOR
Kabel Serial 4.9 Rangkaian modul praktikum
Gambar
PC uC
Berikut adalah tabel dan grafik kecepatan motorFeedBack
dc pada pemberian nilai PWM
yang berbeda dari 0 – 100 % :

Kecepatan Motor DC

100
Kecepatan (rps)

80

60

40

20

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 rpss.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 =

1. Lengkapi tabel rule base berikut

d_erro
r
X NB NS ZR P PB
S
NB
error NS
ZR
PS
PB

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

Beban Error tanpa Error Error
potensiomet kontroller dengan dengan
er ( 0) (rps) kontrol kontrol
fuzzy (rps) proportiona
l
(rps)
0
45
90
13
5
18
0

IV. 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.

4. Uji coba dan berikan analisa pengaruh perubahan tabel aturan pada
performasi sistem kontrol fuzzy.
Praktikum Kontrol Cerdas 1
Desember 2019
Lab D-106
Anggota:
1. RIZKY MUHAMMAD PANJI (1110171023)

PERCOBAAN 7
Simulasi Logika Fuzzy pada Motor DC

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 err, derr;
float[] mi = new float[25];
float[] rulef = new float[25];

/* Fuzzifikasi ERROR */
de_NB = float.Parse(textBox11.Text);
de_NS = Segitiga(kecepatan, -20, 0, 20);
Zero = Segitiga(kecepatan, 0, 20, 40);
de_PS = Segitiga(kecepatan, 20, 40, 60);
de_PB = Segitiga(kecepatan, 40, 60, 80);

textBox1.Text = Convert.ToString(de_NB);
textBox2.Text = Convert.ToString(de_NS);
textBox3.Text = Convert.ToString(Zero);
textBox4.Text = Convert.ToString(de_PS);
textBox5.Text = Convert.ToString(de_PB);

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

//NegativeBig
//textBox2.Text = Convert.ToString(Segitiga(float.Parse(textBox11.Text), 0, 20, 40));
//NegativeSmall
//textBox3.Text = Convert.ToString(Segitiga(float.Parse(textBox11.Text), 20, 40,60));
//Zero
//textBox4.Text = Convert.ToString(Segitiga(float.Parse(textBox11.Text), 40, 60,80));
//PositiveBig
//textBox5.Text=Convert.ToString(Segitiga(float.Parse(textBox11.Text), 60,80,100));
//PositiveSmall

/* Fuzzifikasi DELTA ERROR */

NegativeBig = float.Parse(textBox12.Text);
NegativeSmall = Segitiga(jarak, -1, 0, 1);
Zero = Segitiga(jarak, 0, 1, 2);
PositiveBig = Segitiga(jarak, 1, 2, 3);
PositiveSmall = Segitiga(jarak, 2, 3, 4);
textBox6.Text = Convert.ToString(NegativeBig);
textBox7.Text = Convert.ToString(NegativeSmall);
textBox8.Text = Convert.ToString(Zero);
textBox9.Text = Convert.ToString(PositiveSmall);
textBox10.Text = Convert.ToString(PositiveBig);

/* Nilai center pengereman */

NegativeBig = 0;
NegativeSmall = 10;
Zero = 20;
PositiveBig = 30;
PositiveSmall = 40;

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);

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 temporer = 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;

temporer = (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 (temporer != 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)/ temporer);
}
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 DATA
Dari percobaan diatas dapat dilakukan analisa bahwa :
Pada percobaan ini membuat program fuzzy dengan 2 input yaitu ERROR dan
DELTA_ERROR.
Sedangkan ada 1 output yaitu nilai variable fuzzy yang nantinya akan dijumlahkan
dengan nilai output ke motor. Pada percobaan ini saat diterapkan pada motor nilai speed
yang ada pada motor masih belum bisa menuju ke setpoint dengan cepat, namun ada
delay yang cukup lama. Namun nilai steady state error masih cukup jauh dari setpoint,
ketika percobaan nilai steady state errornya antara nilai 5-15. Ketika diberi setpoint
speed maksimal, nilai steady state errornya sangat besar hingga mencapai nilai 15.

Dari input membership kecepatan terdapat 5 membership yaitu

- de_NB
- de_NS
- de_Z
- de_PS
- de_PB

Jarak memiliki 5 membership yaitu

- error_NB
- error_NS
- error_Z
- error _PS
- error _PB

Sedangkan membership output pengeraman terdapat 5 membership yaitu

- NegativeBig
- NegativeSmall
- Zero
- PositiveBig
- PositiveSmall
Rule base yang didapat dari percobaan terdapat 25 rule . yaitu
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);

Lalu, untuk mendapatkan output dengan rumus minimal dari 25 rule contoh :
“r8 = minimal(error_NS, error_ZR);”
Dan nilai center dari output :
NB = -30;
NS = -10;
ZR = 0;
PS = 10;
PB = 30;

Sehingga rumus akhir untuk mendapat output fuzzy didapat :

‘output’ temporer = (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 (temporer!= 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));
fuzzy=fuzzy/temporer;
}

KESIMPULAN
Berdasarkan Analisa data dan percobaan yang dilakukan, maka dapat kita
simpulkan bahwa pada percobaan ini, kita dapat melakukan kontrol motor DC
menggunakan metode fuzzy. Maka kita harus memberikan input pada fuzzy
berupa Error dan DeltaError, yang bisa didapatkan dari sensor pada motor.
Kemudian akan difuzzykan sehingga menghasilkan nilai kecepatan yang akan
dikirimkan pada motor. Namun pada percobaan ini, ketika motor diberi
pembebanan, reaksi motor mempertahankan sesuai setpoint yang ditentukannya
lambat. Jadi kami belum bisa mendapat datanya, karena output yang ada pada
motor tidak lebih baik dari kontrol close loop sebelumnya yang merupakan
kontrol Proporsi saja.