HALAMAN SAMPUL

JOBSHEET
KENDALI FUZZY LOGIC BERBASIS ARDUINO NANO

Disusun oleh:
Hernawan Prabowo
14502241029
Pendidikan Teknik Elektronika

Pembimbing:
Dr. Fatchul Arifin, M.T.
 KATA PENGANTAR

Puji syukur kepada Allah SWT, atas berkat serta hidayah yang telah diberikan-Nya
dalam penyusunan “Job Sheet Kendali Fuzzy Logic” ini. Terimakasih kepada seluruh pihak
yang telah berpartisipasi dalam penyelesaian job sheet ini baik secara langsung maupun
tidak. Job Sheet ini merupakan bahan ajar pada kegiatan praktikum mata kuliah Praktik
Sistem Kendali Cerdas di jurusan Pendidikan Teknik Elektronika Fakultas Teknik UNY.
Job Sheet ini digunakan berdampingan bersama Media Pembelajaran kendali fuzzy
logic dengan bantuan Personal Computer (PC) sebagai penghubung bahasa pemrograman,
perintah, dan pengguna. Job Sheet ini dilengkapi dengan beberapa pokok pembahasan
mengenai sistem kendali berbasis sistem cerdas fuzzy logic dengan aplikasi pemrograman
Arduino. Masing–masing pokok pembahasan dijelaskan secara singkat melalui pengetahuan,
pengenalan dan kajian teori yang dikemas dalam model praktikum.
Besar harapan penyusun agar pengguna, praktikan, dan pembimbing dapat
memberikan kritik maupun saran mengenai isi job sheet ini, akhir kata, penyusun
mengucapkan terimakasih kepada semua pihak. Semoga Bermanfaat.

Yogyakarta, 5 Februari 2018

Penulis

JOB SHEET KENDALI FUZZY LOGIC ii

 DAFTAR ISI
HALAMAN SAMPUL...................................................................................... 0
KATA PENGANTAR ...................................................................................... ii
DAFTAR ISI .............................................................................................. iii
DAFTAR GAMBAR ...................................................................................... vi
DAFTAR TABEL ........................................................................................viii
PENDAHULUAN .......................................................................................... 1
A. Deskripsi .......................................................................................... 1
B. Petunjuk Job Sheet ............................................................................. 2
C. Tujuan Akhir ..................................................................................... 2
PEGENALAN MEDIA PEMBELAJARAN KENDALI FUZZY LOGIC .................................... 3
A. Bentuk Fisik Media Pembelajaran............................................................. 3
B. Bagian-Bagian Media Pembelajaran .......................................................... 4
C. Software Pemrograman .......................................................................12
00. Fuzifikasi, Evaluasi Rule & Defuzzifikasi pada Mikrokontroller Arduino Nano
Menggunakan ISIS Proteus ....................................................................... 16
A. Tujuan ...........................................................................................16
B. Teori Dasar ......................................................................................16
C. Alat dan Bahan .................................................................................17
D. Keselamatan Kerja .............................................................................17
E. Skema ............................................................................................18
F. Langkah Kerja ..................................................................................19
01. Fuzzifikasi pada Mikrokontroller Arduino Nano ........................................... 29
A. Tujuan ...........................................................................................29
B. Teori Dasar ......................................................................................29
C. Alat dan Bahan .................................................................................33
D. Keselamatan Kerja .............................................................................33
E. Flowchart .......................................................................................33
F. Skema ............................................................................................35
G. Langkah Kerja ..................................................................................35
H. Tugas .............................................................................................42
02. Evaluasi Rule pada Mikrokontroler Arduino ................................................ 43
A. Tujuan ...........................................................................................43
B. Teori Dasar ......................................................................................43
C. Alat dan Bahan .................................................................................46
D. Keselamatan Kerja .............................................................................46
E. Flowchart .......................................................................................46

JOB SHEET KENDALI FUZZY LOGIC iii

 F. Skema ............................................................................................48
G. Langkah Kerja ..................................................................................48
H. Tugas .............................................................................................54
03. Defuzzifikasi pada Mikrokontroler Arduino ................................................ 55
A. Tujuan ...........................................................................................55
B. Teori Dasar ......................................................................................55
C. Alat dan Bahan .................................................................................58
D. Keselamatan Kerja .............................................................................58
E. Flowchart .......................................................................................58
F. Skema ............................................................................................59
G. Langkah Kerja ..................................................................................60
H. Tugas .............................................................................................67
04. Penerapan Logika Fuzzy pada Pengereman Kendaraan Otomatis ..................... 68
A. Tujuan ...........................................................................................68
B. Teori Dasar ......................................................................................68
C. Alat dan Bahan .................................................................................71
D. Keselamatan Kerja .............................................................................71
E. Skema ............................................................................................71
F. Langkah Kerja ..................................................................................73
G. Tugas .............................................................................................80
05. Penerapan Logika Fuzzy pada Tirai Otomatis ............................................. 81
A. Tujuan ...........................................................................................81
B. Teori Dasar ......................................................................................81
C. Alat dan Bahan .................................................................................83
D. Keselamatan Kerja .............................................................................83
E. Skema ............................................................................................83
F. Langkah Kerja ..................................................................................84
G. Tugas .............................................................................................87
06. Penerapan Logika Fuzzy pada kipas angin cerdas ........................................ 88
A. Tujuan ...........................................................................................88
B. Teori Dasar ......................................................................................88
C. Alat dan Bahan .................................................................................89
D. Keselamatan Kerja .............................................................................89
E. Skema ............................................................................................90
F. Langkah Kerja ..................................................................................90

JOB SHEET KENDALI FUZZY LOGIC iv

 G. Tugas ........................................................................................... 103
DAFTAR PUSTAKA ................................................................................... 104

JOB SHEET KENDALI FUZZY LOGIC v

 DAFTAR GAMBAR

Gambar 1. Bagian Fisik Media Pembelajaran dan Dimensinya ........................................ 3

Gambar 2. Bagian-Bagian Media Pembelajaran Kendali Fuzzy Logic ............................. 4
Gambar 3. LCD 20x4 (Kiri) dan I2C Modul (Kanan) ............................................................ 5
Gambar 4. Motor DC ................................................................................................................ 5
Gambar 5. Modul Driver Motor L293D .................................................................................. 6
Gambar 6. Push Button ........................................................................................................... 6
Gambar 7. Motor Servo SG90 ................................................................................................. 7
Gambar 8. Sensor Ultrasonik HC-SR05 ................................................................................. 7
Gambar 9. Sensor Cahaya (Light Depend Resistor) ........................................................... 8
Gambar 10. Sensor DHT 11 .................................................................................................... 8
Gambar 11. Bentuk dan pinout Board Arduino Nano......................................................... 9
Gambar 12. Switch pada media pembelajaran ................................................................ 10
Gambar 13. Potensiometer .................................................................................................. 10
Gambar 14. Bread Board ...................................................................................................... 11
Gambar 15. Pin pada Media Pembelajaran Kendali Fuzy Logic..................................... 12
Gambar 16. Tampilan proses membuka Arduino IDE ...................................................... 13
Gambar 17. Tampilan aplikasi Arduino IDE ....................................................................... 13
Gambar 18. FIS (Fuzzy Inference System) Editor ............................................................. 15
Gambar 19. Tampilan Website Make Proto ....................................................................... 15
Gambar 20. Skematik Rangkaian Pada Simulasi Proteus ................................................ 18
Gambar 21. Direktori File Hex Disimpan ........................................................................... 26
Gambar 22. Tampilan LCD fuzzifikasi ................................................................................ 26
Gambar 23. Representasi Kurva Segitiga........................................................................... 29
Gambar 24. Representasi Kurva Trapesium ...................................................................... 30
Gambar 25. Fungsi keanggotaan Input Error .................................................................... 31
Gambar 26. Contoh fuzzyfikasi Error ................................................................................. 31
Gambar 27. Fungsi keanggotaan Input Perubahan Error ................................................ 32
Gambar 28. Contoh fuzzyfikasi Perubahan Error ............................................................. 32
Gambar 29. Flowchart Fuzzyfikasi Variabel Error ........................................................... 34
Gambar 30. Flowchart Fuzzyfikasi Variabel Perubahan Error ....................................... 34

JOB SHEET KENDALI FUZZY LOGIC vi

Gambar 31. Skematik Fuzzyfikasi Pada Arduino .............................................................. 35
Gambar 32. Cara Memasukan Library ke Arduino ............................................................ 36
Gambar 33. Setting Konfigurasi Arduino ........................................................................... 40
Gambar 34. Tombol Upload ................................................................................................. 40
Gambar 35. Tampilan LCD fuzzifikasi ................................................................................ 40
Gambar 36. Aplikasi fungsi implikasi untuk nilai error 4 dan Derror 2 ........................ 45
Gambar 37. Tampilan Evaluasi Rule Pada LCD 20x4 ....................................................... 45
Gambar 38. Flowchart Aturan Fuzzy .................................................................................. 47
Gambar 39. Skematik Evaluasi Rule Pada Arduino .......................................................... 48
Gambar 40. Fungsi keanggotaan Output Perubahan Kecepatan ................................... 56
Gambar 41. Luas Daerah Anggota Negative Small........................................................... 56
Gambar 42. Titik Tengah Setiap Anggota .......................................................................... 57
Gambar 43. Flowchart proses defuzzyfikasi ..................................................................... 59
Gambar 44. Skematik Defuzzyfikasi Pada Arduino .......................................................... 59
Gambar 45. Fungsi Keanggotaan Input kecepatan motor............................................... 69
Gambar 46. Fungsi keanggotaan Input Jarak .................................................................... 69
Gambar 47. Fungsi keanggotaan Output Perubahan Kecepatan Motor DC.................. 71
Gambar 48. Diagram Blok Pengereman Kendaraan Otomatis dengan Logika Fuzzy .. 71
Gambar 49. Skematik Pengereman Kendaraan Otomatis dengan Logika Fuzzy ......... 72
Gambar 50. Rancangan FIS Fuzzy pada Tirai Otomatis................................................... 82
Gambar 51. Membership Function Input Sensor Cahaya ................................................ 82
Gambar 52. Membership Function Output Motor Servo ................................................. 82
Gambar 53. Skematik Tirai Otomatis dengan Library Fuzzy .......................................... 83
Gambar 54. Diagram Perangkat Keras Kipas Angin Cerdas ............................................ 89
Gambar 55. Skematik Kipas Angin Cerdas ......................................................................... 90
Gambar 56. FIS (Fuzzy Inference System) untuk Kipas Angin Cerdas .......................... 91
Gambar 57. Membership Function Input Jarak ................................................................ 91
Gambar 58. Membership Function Input Suhu ................................................................. 91
Gambar 59. Membership Function Output Kipas .............................................................. 92
Gambar 60. Langkah Upload dan Convert File FIS Ke File Arduino .............................. 93
Gambar 61. File Konversi Siap Download .......................................................................... 93

JOB SHEET KENDALI FUZZY LOGIC vii

 DAFTAR TABEL

Tabel 1. Karakteristik Arduino Nano .................................................................................... 9

Tabel 2. Tabel List Komponen ............................................................................................. 18
Tabel 3. Konfigurasi Pin Skematik ...................................................................................... 19
Tabel 4. Tabel Fuzzyfikasi Error ......................................................................................... 26
Tabel 5. Tabel Fuzzyfikasi Perubahan Error atau D_error ............................................. 27
Tabel 6. Data Hasil Penggalamatan Fuzifikasi, Evaluasi Rule & Defuzzifikasi ........... 28
Tabel 7. Data Uji.................................................................................................................... 28
Tabel 8. Konfigurasi Pin Skematik ...................................................................................... 35
Tabel 9. Tabel Fuzzyfikasi Error ......................................................................................... 41
Tabel 10. Tabel Fuzzyfikasi Perubahan Error atau D_error ........................................... 41
Tabel 11. Basis Aturan .......................................................................................................... 43
Tabel 12. Konfigurasi Pin Skematik .................................................................................... 48
Tabel 13. Hasil Pengamatan ................................................................................................ 54
Tabel 14. Data Uji ................................................................................................................. 54
Tabel 15. Luas dan Titik Tengah ......................................................................................... 57
Tabel 16. Konfigurasi Pin Skematik .................................................................................... 60
Tabel 17. Hasil Pengamatan ................................................................................................ 67
Tabel 18. Data Uji ................................................................................................................. 67
Tabel 19. Tabel Basis Aturan ............................................................................................... 70
Tabel 20. Konfigurasi Pin Skematik .................................................................................... 72
Tabel 21. Hasil Pengamatan ................................................................................................ 80
Tabel 22. Data Uji ................................................................................................................. 80
Tabel 23. Tabel Evaluasi Rule Tirai Otomatis .................................................................. 82
Tabel 20. Konfigurasi Pin Skematik .................................................................................... 84
Tabel 25. Hasil Pengamatan ................................................................................................ 87
Tabel 20. Konfigurasi Pin Skematik .................................................................................... 90
Tabel 27. Basis Aturan Kipas Angin Cerdas ....................................................................... 92
Tabel 28. Hasil Pengamatan .............................................................................................. 103

JOB SHEET KENDALI FUZZY LOGIC viii

 PENDAHULUAN

A. Deskripsi

Media Pembelajaran kendali fuzzy logic berbasis Arduino nano merupakan media
pembelajaran yang berfungsi untuk mempermudah dalam menerapkan teori kendali logika
fuzzy ke penerapan perangkat keras yang terintegrasi dengan perangkat lunak. Media
pembelajaran ini berisikan berbagai macam sensor seperti sensor suhu, jarak dan cahaya.
Bagian kontroler menggunakan Arduino nano sebagai pengontrol. Kemudian untuk bagian
output terdiri dari LCD 20x4, Motor DC + Driver L298N dan Motor Servo. Keseluruhan sistem
input, kontroler dan output yang di gunakan disesuaikan dengan berbagai kasus dan
permasalahan di dalam kehidupan sehari-hari.
Job Sheet ini menggunakan bantuan Personal Computer (PC) atau laptop dan
aplikasi Arduino IDE untuk mendukung interaksi antara pengguna dan Media Pembelajaran.
Job Sheet ini memiliki ruang lingkup pembahasan penerapan kendali fuzzy logic pada
perangkat keras dan menggunkakan 4 bantuan perangkat lunak yaitu Arduino IDE, Library
Fuzzy, Matlab dan Make Proto berbasis website. Job Sheet ini mencakup 6 kegiatan belajar
diantaranya:

1. Fuzzifikasi pada mikrokontroler arduino

2. Evaluasi rule pada mikrokontroler arduino
3. Defuzzifikasi pada mikrokontroler arduino
4. Penerapan Logika Fuzzy pada pengereman kendaraan otomatis
5. Penerapan Logika Fuzzy pada tirai Otomatis (Library Fuzzy)
6. Penerapan Logika Fuzzy pada kipas angin cerdas (Make Proto)

Job sheet dan media pembelajaran kendali fuzzy logic ini diharapkan mampu
menambah penggalaman mahasiswa dalam menerapkan sistem kendali fuzzy logic secara
nyata yang terintegrasi antara perangkat keras dan perangkat lunak. Media pembelajaran
kendali fuzzy logic sebelumnya hanya menggunakan simulasi dapat menjadi interaktif dan
menarik dimana tujuan akhirnya adalah dapat meningatkan kualitas pembelajaran pada
mata kuliah praktik sistem kendali cerdas khususnya pada materi fuzzy logic.

JOB SHEET KENDALI FUZZY LOGIC 1

B. Petunjuk Job Sheet

a. Bagi Mahasiswa
Beberapa hal yang harus dilakukan dalam pelaksanaan praktik ini antara lain:
1) Mempersiapkan dengan baik fisik dan psikis.
2) Mempersiapkan pemahaman mengenai teori kendali fuzzy logic.
3) Mempersiapkan kemampuan algoritma pemrograman dengan baik.
4) Mempersiapkan kemampuan pemrograman dan kendali berbasis mikrokontroler.
5) Memahami dan mencermati setiap uraian materi pada kegiatan belajar.
6) Memahami dan mencermati langkah kerja pada setiap kegiatan belajar.
7) Tanyakan kepada dosen pengampu jika belum menguasai materi kegiatan.
b. Bagi Dosen
Dalam setiap kegiatan belajar mengajar dosen memiliki peran sebagai berikut:
1) Membimbing mahasiswa selama kegiatan belajar berlangsung.
2) Memotivasi mahasiswa selama kegiatan belajar mengakar berlangsung.
3) Memeriksa hasil belajar mahasiswa.

C. Tujuan Akhir

Tujuan akhir dari kegiatan belajar yaitu mahasiswa mampu:

1) Memahami fungsi pada bagian media pembelajaran.
2) Memahami dan mampu menerapkan sistem kendali fuzzy logic pada aplikasi
kehidupan sehari-hari secara nyata.
3) Memahami proses fuzzifikasi, evaluasi rule dan defuzzifikasi.
4) Menerapkan fuzzifikasi, evaluasi rule dan defuzzifikasi.

File Pendukung & Video Tutorial :

Dapat di unduh di →
[Link]

JOB SHEET KENDALI FUZZY LOGIC 2

 PEGENALAN MEDIA PEMBELAJARAN KENDALI FUZZY LOGIC

A. Bentuk Fisik Media Pembelajaran

Media Pembelajaran kendali fuzzy logic berbasis Arduino nano merupakan media
pembelajaran yang berfungsi untuk mempermudah dalam menerapkan teori kendali logika
fuzzy ke dalam penerapan perangkat keras yang terintegrasi dengan perangkat lunak.
Media pembelajaran ini berisikan berbagai macam sensor seperti sensor suhu, jarak dan
cahaya. Bagian kontroler menggunakan Arduino nano sebagai pengontrol. Kemudian untuk
bagian output terdiri dari LCD 20x4, Motor DC + Driver L298N dan Motor Servo. Keseluruhan
sistem input, kontroler dan output yang digunakan disesuaikan dengan berbagai kasus dan
permasalahan di dalam kehidupan sehari-hari.
Media pembelajaran ini digunakan pada mata kuliah Praktik Sistem Kendali Cerdas
di Jurusan Pendidikan Teknik Elektronika FT UNY. Media ini terpadu dalam satu kesatuan
yang terdiri dari beberapa komponen, lebih jelasnya lihat gambar 1 dan 2 seperti berikut:

Gambar 1. Bagian Fisik Media Pembelajaran dan Dimensinya

JOB SHEET KENDALI FUZZY LOGIC 3

 Gambar 2. Bagian-Bagian Media Pembelajaran Kendali Fuzzy Logic

B. Bagian-Bagian Media Pembelajaran

a. LCD 20x4 dan I2C Modul

LCD (Liquid Crystal Display) 20x4 adalah salah satu komponen elektronika yang
berfungsi sebagai tampilan suatu data, baik karakter, huruf ataupun grafik. Dipasaran
tampilan LCD sudah tersedia dalam bentuk modul yaitu tampilan LCD beserta rangkaian
pendukungnya. LCD mempunyai pin data, kontrol catu daya, dan pengatur kontras
tampilan. Pada pengembangan sistem embedded, LCD mutlak diperlukan sebagai sumber
pemberi informasi utama. Pada pengembangan media pembelajaran kendali fuzzy logic
yang akan di kembangkan fungsi dari LCD 20x4 adalah sebagai sarana penampil informasi
hasil pengolahan logika fuzzy yang bisa dilihat pada gambar 3.
I2C LCD modul adalah modul LCD yang dikendalikan secara serial sinkron dengan
protocol I2C/IIC (Inter Integrated Circuit) atau TWI (Two Wire Interface). Pada media
pembelajaran ini menggunakan 4 pin agar lebih sederhana karena data telah di kirim
secara serial yaitu (+), (-), SCL (serial clock), SDA (serial data).

JOB SHEET KENDALI FUZZY LOGIC 4

 Gambar 3. LCD 20x4 (Kiri) dan I2C Modul (Kanan)

b. Motor DC
Motor DC adalah motor listrik yang memerlukan suplai tegangan arus searah pada
kumparan medan untuk diubah menjadi energi gerak mekanik. Kumparan medan pada
motor DC disebut stator (bagian yang tidak berputar) dan kumparan jangkar disebut rotor
(bagian yang berputar). Motor arus searah, sebagaimana namanya, menggunakan arus
langsung yang tidak langsung atau direct-unidirectional. Pada pengembangan media
pembelajaran Kendali fuzzy logic yang akan di kembangkan fungsi dari motor DC adalah
keluaran dari fuzzy yang berfungsi sebagai penggerak yang bisa dilihat pada gambar 4.

Gambar 4. Motor DC

c. Modul Driver Motor L298N

Modul driver L298N, menggunakan chip ST L298N yang dapat secara langsung
mengontrol dua motor DC 3-30V, dan menyediakan antarmuka keluaran 5 V, kita dapat
mengontrol dengan mudah kecepatan dan Arah pergerakan Motor DC, kita juga dapat
mengontrol 2-phasa motor stepper. Driver motor L298N dapat dilihat pada gambar 5.
Produk parameter:
• Drive Chip: L298N dual H-bridge driver chip
• Terminal bagian pengontrol dengan sumber pasokan VMS: +5V~+35V
• Bagian Driver dengan Arus maksimal Io: 2A/Bridge
• Bagian Logika dengan terminal Power Suplay berkisar Vss: 4,5-5,5 V

JOB SHEET KENDALI FUZZY LOGIC 5

 • Bagian Logika dengan arus boperasional berkisar: 0~26mA
• Kontrol Tegangan sinyal input berkisar: 4,5-5,5 V low 0V high
• Konsumsi power Maksimum: 20W
• Temperatur penyimpanan: -25 ~ +130
• Ukuran Papan Drive: 55mm*60mm*30mm
• Berat papan drive: 33g
• Fitur lain: kontrol arah indikator, indikator daya, deteksi arus, dst.

Gambar 5. Modul Driver Motor L293D

d. Push Button
Tombol digunakan sebagai input pada media pembelajaran fuzzy logic. Tombol ini
di set pada kondisi aktif low sehingga saat tombol ditekan maka nilai logika low (0) akan
masuk ke dalam port mikrokontroler. Saat tombol tidak ditekan kondisi logika akan high
(1). Kondisi input low dinilai lebih aman bagi mikrokontroler, untuk peletakanya bisa
dilihat pada gambar 6.

Gambar 6. Push Button

e. Motor Servo
Motor servo adalah sebuah perangkat atau aktuator putar (motor) yang dirancang
dengan sistem kontrol umpan balik loop tertutup (servo), sehingga dapat di set-up atau di
atur untuk menentukan dan memastikan posisi sudut dari poros output motor. motor servo
merupakan perangkat yang terdiri dari motor DC, serangkaian gear, rangkaian kontrol dan
potensiometer. Serangkaian gear yang melekat pada poros motor DC akan memperlambat
putaran poros dan meningkatkan torsi motor servo, sedangkan potensiometer dengan
perubahan resistansinya saat motor berputar berfungsi sebagai penentu batas posisi
putaran poros motor servo. Motor servo yang digunakan adalah SG 90 seperti gambar 7
dengan spesifikasi.

JOB SHEET KENDALI FUZZY LOGIC 6

 • Torsi 1,8 kg
• Berat 15 g
• Kecepatan 0,12/60deg
• Tegangan 4,8 volt
• Catatan : Tegangan kerja tidak lebih dari 5V!

Gambar 7. Motor Servo SG90

f. Sensor Ultrasonik (HC-SR05)

Sensor Jarak HC-SR05 merupakan sensor pengukur jarak yang menggunakan
ultrasonik. Di mana prinsip kerja sensor Ultrasonik ini adalah Pemancar (transmitter)
mengirimkan seberkas gelombang ultrasonik, lalu diukur waktu yang dibutuhkan hingga
datangnya pantulan dari obyek. Lamanya waktu ini sebanding dengan dua kali jarak sensor
dengan obyek, sehingga didapat jarak sensor dengan obyek yang bisa ditentukan. Berikut
ini adalah spesifikasi sensor ultrasonic HC-SR05:
• Operating Voltage: 5V DC
• Operating Current: 15mA
• Measure Angle: 15°
• Ranging Distance: 2cm - 4m

Gambar 8. Sensor Ultrasonik HC-SR05

JOB SHEET KENDALI FUZZY LOGIC 7

g. Sensor Cahaya (LDR-Light Depend Resistor)
Light Dependent Resistor atau disingkat dengan LDR adalah jenis Resistor yang nilai
hambatan atau nilai resistansinya tergantung pada intensitas cahaya yang diterimanya.
Nilai Hambatan LDR akan menurun pada saat cahaya terang dan nilai Hambatannya akan
menjadi tinggi jika dalam kondisi gelap. Dengan kata lain, fungsi LDR (Light Dependent
Resistor) adalah untuk menghantarkan arus listrik jika menerima sejumlah intensitas
cahaya (Kondisi Terang) dan menghambat arus listrik dalam kondisi gelap.

Gambar 9. Sensor Cahaya (Light Depend Resistor)

h. Sensor Suhu (DHT11)

Sensor DHT11 adalah salah satu sensor yang dapat mengukur dua parameter
lingkungan sekaligus, yakni suhu dan kelembaban udara (humidity). Dalam sensor ini
terdapat sebuah thermistor tipe NTC (Negative Temperature Coefficient) untuk mengukur
suhu, sebuah sensor kelembaban tipe resitif dan sebuah mikrokontroler 8-bit yang
mengolah kedua sensor tersebut dan mengirim hasilnya ke pin output dengan format
single-wire bi-directional (kabel tunggal dua arah). Berikut ini adalah spesifikasi dari
sensor DHT11:
• Power supply : DC 3.5 - 5.5 V
• Konsumsi arus : measurement 0.3 mA, standby 60u A
• Periode sampling : lebih dari 2 detik
• Resolusi pengukuran : 16 Bit
• Repeability : ± 0.2 OC
• Range : At 25 OC ± 2 OC
• Waktu Respon : 1/e (63%) 10 Detik

Gambar 10. Sensor DHT 11

JOB SHEET KENDALI FUZZY LOGIC 8

i. Arduino Nano
Arduino Nano merupakan board yang menggunakan IC Atmega328P. Arduino ini
memiliki 14 pin digital input/output (6 pin dapat digunakan sebagai output PWM), 6 analog
input, frekuensi clock 16 MHz, koneksi USB, jack power, ICSP header, dan tombol reset.
Cara menggunakannya tinggal melakukan koneksi USB dengan komputer atau menggunakan
adaptor AC ke DC. Tabel 1 merupakan karakteristik dari Arduino Nano.
Tabel 1. Karakteristik Arduino Nano

Gambar 11 merupakan bentuk board Arduino Nano. Pemilihan board mikrokontroler

dalam penelitian ini memiliki beberapa alasan yaitu (1) kemudahan dalam
mengaksesnya karena sudah dilengkapi IDE dari Arduino, (2) murah dan fleksibel,
dan (3) bersifat open source sehingga banyak developer yang membuat library
pemprogramannya.

Gambar 11. Bentuk dan pinout Board Arduino Nano

JOB SHEET KENDALI FUZZY LOGIC 9

j. Switch
Switch (saklar tombol tekan) adalah perangkat atau saklar sederhana yang berfungsi
untuk menghubungkan atau memutuskan aliran arus listrik dengan sistem kerja normalnya
adalah off jika ditekan maka saklar akan berada pada posisi on terus, hingga saklar ditekan
kembali sehingga saklar akan berubah status menjadi off. Sistem kerja unlock disini berarti
saklar akan bekerja sebagai device penghubung atau pemutus aliran arus listrik saat
tombol ditekan, dan saat tombol tidak ditekan (dilepas), maka saklar masih dalam kondisi
on dan akan off ketika di tekan kembali.

Gambar 12. Switch pada media pembelajaran

k. Potensiometer
Potensiometer adalah resistor tiga terminal dengan sambungan geser yang
membentuk pembagi tegangan dapat disetel. Jika hanya dua terminal yang digunakan
(salah satu terminal tetap dan terminal geser), potensiometer berperan sebagai resistor
variabel atau Rheostat. Potensiometer biasanya digunakan untuk mengendalikan peranti
elektronik seperti pengendali suara pada penguat. Potensiometer yang dioperasikan oleh
suatu mekanisme dapat digunakan sebagai transduser untuk merubah nilai fuzzy logic pada
media pembelajaran ini.

Gambar 13. Potensiometer

JOB SHEET KENDALI FUZZY LOGIC 10

l. Project Board
Project board digunakan untuk menghubungkan komponen lain seperti sensor,
aktuator dan menambahkan tegangan jika dibutuhkan. Project board yang digunakan
berdimensi 8,5 x 5,5 cm dengan 30 baris dan 15 kolom pin. Lebih jelasnya lihat gambar 14.

Gambar 14. Bread Board

m. PIN pada Media Pembelajaran

Media pembelajaran fuzzy logic memliki pin pada masing-masing bagian
komponennya. Pin tersebut merupakan pin yang nantinya akan dihubungkan dengan
Arduino Nano sebagai pusat kontroler menggunakan kabel jumper. Lebih jelasnya lihat
gambar 15. Bagian masing-masing komponen terdapat pin yaitu.
• Bagian LCD (GND, VCC, SDA, SCL) yang digunakan untuk mengakses LCD 20X4,
• Bagian potensiometer (GND, VCC, P1, P2, P3) yang digunakan untuk mengakses
Potensiometer,
• Bagian switch (GND, S1, S2, S3, S4) yang digunakan untuk mengakses Switch,
• Bagian Push Button (GND, B1, B2, B3) yang digunakan untuk mengakses Button,
• Bagian Sensor Cahaya LDR (GND, VCC, Data) yang digunakan untuk mengakses Sensor
Cahaya LDR,
• Bagian Driver Motor L298N blok daya (5 V, GND, 12 V) dan blok control (ENA, IN1, IN2,
IN3, IN4, ENB) yang digunakan untuk mengakses Driver Motor L298N. Pada bagian ini
terdapat dua buah motor DC yang telah terhubung dengan driver.
• Bagian Motor Servo (VCC, GND, Data) yang digunakan untuk mengakses Motor Servo,
• Bagian Sensor DHT11 (GND, VCC, Data) yang digunakan untuk mengakses Sensor DHT11,
• Bagian Sensor Ultrasonik HC-SRF05 (GND, VCC, Trig, Echo) yang digunakan untuk
mengakses Sensor Ultrasonik HC-SRF05,

JOB SHEET KENDALI FUZZY LOGIC 11

 Gambar 15. Pin pada Media Pembelajaran Kendali Fuzy Logic

C. Software Pemrograman

a. Arduino IDE
Software pemrograman digunakan untuk membuat program yang akan dimasukkan
pada media pembelajaran kendali fuzzy logic. Software yang dapat digunakan adalah
Arduino IDE. Memprogram dengan software Arduino, dibutuhkan sebuah aplikasi IDE
(Integrated Development Environment) yang telah disediakan secara resmi oleh pihak
Arduino. Aplikasi tersebut bisa didapatkan secara bebas di official website
[Link] aplikasi ini berguna untuk membuat,
membuka, dan mengedit program Arduino.
Untuk menggunakan aplikasi Arduino IDE, komputer harus sudah ter-install aplikasi
Arduino terlebih dahulu. Jika komputer belum memiliki aplikasi Arduino dapat dilakukan
proses peng-install-an hingga selesai. Berikut langkah meng-install Arduino IDE.
a. Buka folder master softwre Arduino IDE.
b. Doubleclick “arduino-1.6.7-windows” untuk membuka master software.
c. Setelah muncul jendela baru, click “RUN” kemudian tunggu beberapa saat hingga
proses selesai.

JOB SHEET KENDALI FUZZY LOGIC 12

 Gambar 16. Tampilan proses membuka Arduino IDE

Gambar 17. Tampilan aplikasi Arduino IDE

Berdasarkan gambar di atas berikut ini adalah Bagian-bagian dari Arduino IDE:
a) Verify Pada versi sebelumnya dikenal dengan istilah compile. Sebelum sketch
program di upload ke mikrokontroler, biasakan untuk memverifikasi terlebih dahulu
sketch yang dibuat. Jika ada kesalahan pada sketch, maka akan muncul error.
Proses verify / compile mengubah sketch ke bahasa mesin untuk di-upload ke
mikrokontroler.
b) Upload Tombol ini berfungsi untuk meng-upload sketch ke mikrokontroler.
Walaupun kita tidak mengklik tombol verify, maka sketch akan di-compile,
kemudian langsung di-upload ke mikrokontroler. Berbeda dengan tombol verify
yang hanya berfungsi untuk memverifikasi source code saja.
c) New Sketch Membuka window dan membuat sketch baru.
d) Open Sketch Membuka sketch yang sudah pernah dibuat. Sketch yang dibuat
dengan IDE Arduino akan disimpan dengan ekstensi [Link]

JOB SHEET KENDALI FUZZY LOGIC 13

 e) Save Sketch Menyimpan sketch, tetapi tidak disertai dengan meng-compile.
f) Serial Monitor Membuka interface untuk komunikasi serial.
g) Keterangan Aplikasi Pesan-pesan yang dilakukan aplikasi akan muncul di sini, misal
“compiling” dan “Done Uploading” ketika aplikasi sedang meng-compile dan meng-
upload sketch ke board mikrokontroler.
h) Konsol Pesan-pesan yang dikerjakan aplikasi dan pesan-pesan tentang sketch akan
muncul pada bagian ini. Ketika aplikasi meng-compile atau ketika ada kesalahan
pada sketch ang dibuat, maka informasi error dan baris akan diinformasikan di
bagian konsol.
i) Line Number Bagian ini akan menunjukkan posisi baris kursor yang sedang aktif
pada sketch.
j) Informasi Port Bagian ini menginformasikan port yang dipakai oleh board
mikrokontroler.

b. eFLL (Embedded Fuzzy Logic Library)

eFLL (Embedded Fuzzy Logic Library) adalah library atau pustaka standar yang di
buat untuk Embedded Systems tipe arduino board dan software Arduino IDE agar para
praktikan di permudah dalam mengimplementasikan Sistem Fuzzy sehingga mampu
membuat sebuah program atau alat yang efisien. Libaray fuzzy ini di kembangkan oleh
Robotic Research Group (RRG) di perpustakaan Universitas Negeri Piauí (UESPI-Teresina).
Library eFLL (Embedded Fuzzy Logic Library) adalah pilihan serbaguna, ringan dan efisien
untuk bekerja dengan Fuzzy Logic dalam sistem embedded.

c. Matlab
MATLAB adalah bahasa pemrograman teknis yang sangat andal untuk proses simulasi
dan visualisasi data. MATLAB menjadi tools bagi para ilmuan dan pelajar untuk
memodelkan sistem, menganalisis serta menampilkan data. Saat ini, MATLAB terus
berkembang untuk menyokong berbagai disiplin keilmuan, termasuk Logika Fuzzy. MATLAB
telah menyediakan sebuah tools untuk merancang logika fuzzy, yang dikenal sebagai Fuzzy
Logic Toolbox yang ditunjukkan pada gambar 18. Fuzzy Logic Toolbox digunakan untuk
mempermudah dalam memahami, merancang dan menerapkan sistem fuzzy logic.

JOB SHEET KENDALI FUZZY LOGIC 14

 Gambar 18. FIS (Fuzzy Inference System) Editor

d. Make Proto
MakeProto adalah sebuah website yang beralamat
[Link] yang
mampu mengubah file dengan ekstensi (.FIS) dari matlab menjadi file program arduino
dengan ekstensi (.INO). Dengan adanya website ini pembuatan program untuk
implementasi fuzzy menjadi lebih mudah dan cepat karena kita cukup hanya membuat file
FIS dengan menggunkan matlab setelah itu file FIS tersebut di upload ke dalam sistem
MakeProto. Setelah di upload di sistem MakeProto maka dengan mengkilik tombol convert
maka program Arduino (.INO) sudah dibuatkan. Namun file program Arduino tersebut perlu
kita sesuaikan dengan alamat input dan output yang akan kita gunakan di dalam sistem
sebelum di upload ke Arduino board dan program siap di implementasikan pada alat.

Gambar 19. Tampilan Website Make Proto

JOB SHEET KENDALI FUZZY LOGIC 15

 FAKULTAS TEKNIK
UNIVERSITAS NEGERI YOGYAKARTA
JOB SHEET PRAKTIK SISTEM KENDALI CEDAS

0. Fuzifikasi, Evaluasi Rule & Defuzzifikasi

Sem Ganjil
pada Mikrokontroller Arduino Nano
/ Genap 200 menit
Menggunakan ISIS Proteus
SKL/EKA/EKA416/00 Revisi: 03 Tgl: 5/29/2018

00. Fuzifikasi, Evaluasi Rule & Defuzzifikasi pada

Mikrokontroller Arduino Nano Menggunakan ISIS Proteus
A. Tujuan
Setelah melakukan praktikum mahasiswa diharapkan :
1. Memahami dan mengenal proses fuzzyfikasi, Evaluasi Rule dan Defuzzyfikasi serta
aplikasinya pada mikrokontroller Arduino Nano dalam bentuk simulasi ISIS Proteus.

B. Teori Dasar
Logika Fuzzy pertama kali dikembangkan oleh Lotfi A. Zadeh pada tahun 1965.
Teori ini banyak diterapkan di berbagai bidang, antara lain representasi pikiran manusia
kedalam suatu sistem. Banyak alasan mengapa penggunaan logika fuzzy ini sering
dipergunakan antara lain, konsep logika fuzzy yang mirip dengan konsep berpikir manusia.
Sistem fuzzy dapat merepresentasikan pengetahuan manusia ke dalam bentuk matematis
dengan lebih menyerupai cara berpikir manusia. Pengontrol dengan logika fuzzy
mempunyai kelebihan yaitudapat mengontrol sistem yang kompleks, non-linier, atau sistem
yang sulit direpresentasikan kedalam bentuk matematis. Selain itu, informasi Berupa
pengetahuan dan pengalaman mempunyai peranan penting dalam Mengenali perilaku
sistem di dunia nyata.
Logika Fuzzy adalah suatu cara yang tepat untuk memetakan suatu ruang input ke
dalam ruang output. Untuk sistem yang sangat rumit, penggunaan logika fuzzy (fuzzy logic)
adalah salah satu pemecahannya. Sistem tradisional dirancang untuk mengontrol keluaran
tunggal yang berasal dari beberapa masukan yang tidak saling berhubungan. Karena
ketidaktergantungan ini, penambahan masukan yang baru akan memperumit proses kontrol
dan membutuhkan proses perhitungan kembali dari semua fungsi. Kebalikannya,
penambahan masukan baru pada sistem fuzzy, yaitu sistem yang bekerja berdasarkan
prinsip-prinsip logika fuzzy, hanya membutuhkan penambahan fungsi keanggotaan yang
baru dan aturan-aturan yang berhubungan dengannya.

JOB SHEET KENDALI FUZZY LOGIC 16

 Logika fuzzy juga memiliki himpunan fuzzy yang mana pada dasarnya, teori
himpunan fuzzy merupakan perluasan dari teori himpunan klasik. Dimana dengan logika
fuzzy, hasil yang keluar tidak akan selalu konstan dengan input yang ada. Cara kerja logika
fuzzy secara garis besar terdiri dari input, proses dan [Link] fuzzy merupakan suatu
teori himpunan logika yang dikembangkan untuk mengatasi konsep nilai yang terdapat
diantara kebenaran (truth) dan kesalahan (false). Dengan menggunakan fuzzy logic nilai
yang dihasilkan bukan hanya ya (1) atau tidak (0) tetapi seluruh kemungkinan diantara 0
dan 1.
Proteus adalah sebuah software untuk mendesain PCB yang juga dilengkapi dengan
simulasi PSpice pada level skematik sebelum rangkaian skematik di-upgrade ke PCB
sehingga sebelum PCBnya di cetak kita akan tahu apakah PCB yang akan kita cetak
apakah sudah benar atau tidak. Proteus mampu mengkombinasikan program ISIS untuk
membuat skematik desain rangkaian dengan program ARES untuk membuat layout PCB dari
skematik yang kita buat. Software Proteus ini bagus digunakan untuk desain rangkaian
mikrokontroller.
Proteus juga bagus untuk belajar elektronika seperti dasar-dasar elektronika sampai
pada aplikasi pada mikrokontroller. Software Proteus ini menyediakan banyak contoh
aplikasi desain yang disertakan pada instalasinya. Sehingga memungkinkan kita bisa belajar
dari contoh-contoh yang sudah ada. Proteus lebih memiliki kelebihan pada desainnya yang
sederhana, sangat mudah dan bagus digunakan untuk perancangan rangkaian
mikrokontroller yang akan sangat membantu digunakan oleh mahasiswa yang mengambil
mata kuliah berhubungan dengan mikrokontroller. Kelebihannya yang lain adalah sebelum
PCB dicetak skematiknya bisa disimulasikan dulu. Desain-desainnya bisa digabungkan dan
masih banyak lagi kelebihan yang dimiliki Proteus.

C. Alat dan Bahan

1. PC (Personal Computer) / Laptop
2. Software Arduino IDE + Software ISIS Proteus
3. Library Pendukung

D. Keselamatan Kerja
1. Awali praktikum dengan berdoa.
2. Gunakanlah pakaian praktik pada saat praktikum.
3. Jauhkan peralatan yang tidak diperlukan dari meja kerja.

JOB SHEET KENDALI FUZZY LOGIC 17

 4. Bekerjalah dengan keadaan tanpa tegangan pada saat membuat dan mengubah
rangkaian.
5. Tanyakan kepada dosen pengampu atau staff pengajar ketika ada hal-hal yang
masih kurang paham.

E. Skema

Gambar 20. Skematik Rangkaian Pada Simulasi Proteus

Tabel 2. Tabel List Komponen

Nama Komponen Nama Komponen di Proteus

Arduino Nano Arduino Nano
LCD 20 x 4 LM044L
Potensiometer POT-HG
Push Button Button
Motor DC Motor
Driver Motor L293D

JOB SHEET KENDALI FUZZY LOGIC 18

 Tabel 3. Konfigurasi Pin Skematik

Pin Arduino Pin Trainer Pin Arduino Pin Trainer

LCD Driver Motor L293D
8 D7 2 IN1
9 D6 3 IN2
10 D5 6 EN1 (KANAN)
11 D4 4 IN3
12 E 7 IN4
13 RS 5 EN2 (KIRI)
Push Button Potensiometer
A2 S1 A0 ERROR
A3 S2 A1 D_ERROR
A4 S3

F. Langkah Kerja
1. Instal dahulu komponen Arduino Nano pada software ISIS Proteus anda. Library bisa
di download di [Link] cari file “Library Arduino in [Link]”
kemudian klik download.
2. Ekstrak dan buka folder “Library Arduino in Proteus”, Copy ke-enam file library
tersebut dan masukkan ke dalam folder LIBRARY pada instalasi folder Proteus yaitu
“C:\Program Files\Labcenter Electronics\Proteus 7 Professional\LIBRARY\”
3. Untuk melihat hasilnya, re-open atau tutup dan buka kembali aplikasi ISIS Proteus.
4. Lihat dikomponen Library atau tekan P, lalu cari dengan keyword Arduino, Setelah
library Arduino Nano terinstal kemudian siapkan alat dan bahan yang dibutuhkan.
5. Buatlah rangkaian pada software ISIS Proteus sesuai pada gambar 20 di atas.
6. Setelah selesai membuat rangkaian kemudian buka software Arduino IDE dan
ketikkan program berikut ini pada software Arduino IDE.

//motor kanan
#define IN1 2
#define IN2 3
#define pwm_kanan 6
//motor kanan

//motor kiri
#define IN3 4
#define IN4 7
#define pwm_kiri 5
//motor kiri

//lcd
#include <LiquidCrystal.h>
LiquidCrystal lcd(13, 12, 11, 10, 9, 8);

/*

JOB SHEET KENDALI FUZZY LOGIC 19

 * The circuit:
* LCD RS pin to digital pin 12
* LCD Enable pin to digital pin 11
* LCD D4 pin to digital pin 5
* LCD D5 pin to digital pin 4
* LCD D6 pin to digital pin 3
* LCD D7 pin to digital pin 2
*/
//lcd

//variabel global
int a,b,i,j,speed_left,speed_right,sensorA,sensorB;
float x, y, error, d_error, z1=60,z2=80,a1=-145.5556,a2=-
80,a3=0,a4=80,a5=145.5556;//z = luas dan a = COA out;
float u_error[3],u_d_error[3],u[3][3], errorneg, errorzero, errorpos,
d_errorneg, d_errorzero,d_errorpos;
float nilai_awal,beda_pwm, validasi, pembilang, penyebut;
//variabel global

void setup() {
[Link](20, 4);

[Link](9600);

pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
pinMode(pwm_kanan, OUTPUT);
pinMode(pwm_kiri, OUTPUT);

pinMode(16, INPUT_PULLUP);
pinMode(17, INPUT_PULLUP);
pinMode(18, INPUT_PULLUP);
}

void loop() {
nilai_awal = 100;

baca_sensor(); //membaca nilai error dan d_error

fuzzyfikasi();
rule();
defuzzyfikasi();

kendali_motor(speed_left,speed_right);

int tombol_fuzzyfikasi = digitalRead(16);

int tombol_rule = digitalRead(17);
int tombol_defuzzyfikasi = digitalRead(18);

if(tombol_fuzzyfikasi==0 && tombol_rule==1 && tombol_defuzzyfikasi==1)

{display_fuzzyfikasi();} //menampilkan data proses fuzzyfikasi
if(tombol_fuzzyfikasi==1 && tombol_rule==0 && tombol_defuzzyfikasi==1)
{display_rule();} //nenampilkan implikasi setiap rule
if(tombol_fuzzyfikasi==1 && tombol_rule==1 && tombol_defuzzyfikasi==0)
{display_defuzzyfikasi();}//menampilkan output tegas dan nilai kecepatan
motor kiri dan kanan
if(tombol_fuzzyfikasi==1 && tombol_rule==1 && tombol_defuzzyfikasi==1)
{[Link]();}
}

JOB SHEET KENDALI FUZZY LOGIC 20

void baca_sensor()
{
sensorA = analogRead(A0);
sensorB = analogRead(A1);

a = map(sensorA, 0, 1023, 0, 255);

b = map(sensorB, 0, 1023, 0, 255);

if(a>=241) {error=8;}
else if(a>=227) {error=7;}
else if(a>=213) {error=6;}
else if(a>=199) {error=5;}
else if(a>=185) {error=4;}
else if(a>=171) {error=3;}
else if(a>=157) {error=2;}
else if(a>=143) {error=1;}
else if(a>=129) {error=0;}
else if(a>=115) {error=-1;}
else if(a>=101) {error=-2;}
else if(a>=87) {error=-3;}
else if(a>=73) {error=-4;}
else if(a>=59) {error=-5;}
else if(a>=45) {error=-6;}
else if(a>=31) {error=-7;}
else if((a<31)&&(a>=0)) {error=-8;}

if(b>=248) {d_error=16;}
else if(b>=241) {d_error=15;}
else if(b>=234) {d_error=14;}
else if(b>=227) {d_error=13;}
else if(b>=220) {d_error=12;}
else if(b>=213) {d_error=11;}
else if(b>=206) {d_error=10;}
else if(b>=199) {d_error=9;}
else if(b>=192) {d_error=8;}
else if(b>=185) {d_error=7;}
else if(b>=178) {d_error=6;}
else if(b>=171) {d_error=5;}
else if(b>=164) {d_error=4;}
else if(b>=157) {d_error=3;}
else if(b>=150) {d_error=2;}
else if(b>=143) {d_error=1;}
else if(b>=136) {d_error=0;}
else if(b>=129) {d_error=-1;}
else if(b>=122) {d_error=-2;}
else if(b>=115) {d_error=-3;}
else if(b>=108) {d_error=-4;}
else if(b>=101) {d_error=-5;}
else if(b>= 94) {d_error=-6;}
else if(b>= 87) {d_error=-7;}
else if(b>= 80) {d_error=-8;}
else if(b>= 73) {d_error=-9;}
else if(b>= 66) {d_error=-10;}
else if(b>= 59) {d_error=-11;}
else if(b>= 52) {d_error=-12;}
else if(b>= 45) {d_error=-13;}
else if(b>= 38) {d_error=-14;}
else if(b>= 31) {d_error=-15;}
else if((b<31)&&(b>= 0)) {d_error=-16;}
}

JOB SHEET KENDALI FUZZY LOGIC 21

void fuzzyfikasi_error()
{
x = error;
//u_error[0] = Negatif 1
//u_error[1] = Zero 1
//u_error[2] = Positif 1

if(x >= 5)
{
u_error[0]=0;
u_error[1]=0;
u_error[2]=1;
}

else if(x >= 0)

{
u_error[0]=0;
u_error[1]=(5-x)/5;
u_error[2]=(x-0)/5;
}

else if(x >= -5)

{
u_error[0]=(0-x)/5;
u_error[1]=(x+5)/5;
u_error[2]=0;
}

else if(x < -5)

{
u_error[0]=1;
u_error[1]=0;
u_error[2]=0;
}

errorneg = u_error[0];
errorzero = u_error[1];
errorpos = u_error[2];
}

void fuzzyfikasi_perubahan_error()
{
y = d_error;
// u_d_error[0]=Negatif 2
// u_d_error[1]=Zero 2,
//u_d_error[2]=Positif 2

if(y >= 8)
{
u_d_error[0]=0;
u_d_error[1]=0;
u_d_error[2]=1;
}

else if(y >= 0)

{
u_d_error[0]=0;
u_d_error[1]=(8-y)/8;
u_d_error[2]=(y-0)/8;
}

JOB SHEET KENDALI FUZZY LOGIC 22

 else if(y >= -8)
{
u_d_error[0]=(0-y)/8;
u_d_error[1]=(y+8)/8;
u_d_error[2]=0;
}

else if(y < -8)

{
u_d_error[0]=1;
u_d_error[1]=0;
u_d_error[2]=0;
}

d_errorneg = u_d_error[0];
d_errorzero = u_d_error[1];
d_errorpos = u_d_error[2];
}

void fuzzyfikasi()
{
fuzzyfikasi_error();
fuzzyfikasi_perubahan_error();
}

void rule() // basis aturan

{
for(i=0;i<=2;i++)
{
for(j=0;j<=2;j++)
{
if(u_error[i]<u_d_error[j])
{
u[i][j]=u_error[i]; // menggunakan operator AND
}
else
{
u[i][j]=u_d_error[j];
}
}
}
}

void defuzzyfikasi()
{
//menggunakan metode mamdani dan defuzzyfikasi meggunakan metode centroid
of area
pembilang
=(u[0][0]*a5*z1)+(u[0][1]*a4*z2)+(u[0][2]*a3*z2)+(u[1][0]*a4*z2)+(u[1][1]*a
3*z2)+(u[1][2]*a2*z2)+(u[2][0]*a3*z2)+(u[2][1]*a2*z2)+(u[2][2]*a1*z1);

penyebut
=(u[0][0]*z1)+(u[0][1]*z2)+(u[0][2]*z2)+(u[1][0]*z2)+(u[1][1]*z2)+(u[1][2]*
z2)+(u[2][0]*z2)+(u[2][1]*z2)+(u[2][2]*z1);

validasi=pembilang/penyebut; // perhitungan defuzzyfikasi dengan

menggabungkan seluruh nilai min yang sudah didapatkan
[Link]("validasi= ");
[Link](validasi);
beda_pwm = validasi;

JOB SHEET KENDALI FUZZY LOGIC 23

 speed_left = nilai_awal-beda_pwm;
speed_right = nilai_awal+beda_pwm;
}

void kendali_motor(float pwm_ki,float pwm_ka)

{

if(pwm_ki>=0) //motor kiri maju

{
analogWrite(pwm_kiri, pwm_ki);
digitalWrite(IN3, LOW);
digitalWrite(IN4, HIGH);
//IN3 = 0;
//IN4 = 1;
}

else if(pwm_ki<0)
{
analogWrite(pwm_kiri, -pwm_ki);
digitalWrite(IN3, HIGH);
digitalWrite(IN4, LOW);
//IN3 = 1;
//IN4 = 0;
}

if(pwm_ka>=0) //motor kanan maju

{
analogWrite(pwm_kanan, pwm_ka);
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
//IN1 = 0;
//IN2 = 1;
}

else if(pwm_ka<0) //motor kanan mundur

{
analogWrite(pwm_kanan, -pwm_ka);
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
//IN1 = 1;
//IN2 = 0;
}
}

void display_fuzzyfikasi()
{
[Link](0, 0);[Link]("er=");
[Link](3, 0);[Link](error);
[Link](9, 0);[Link]("d_er=");
[Link](14, 0);[Link](d_error);

[Link](0, 1);[Link]("neg=");
[Link](4, 1);[Link](errorneg);
[Link](9, 1);[Link]("neg=");
[Link](14, 1);[Link](d_errorneg);

[Link](0, 2);[Link]("zer=");
[Link](4, 2);[Link](errorzero);
[Link](9, 2);[Link]("zer=");

JOB SHEET KENDALI FUZZY LOGIC 24

 [Link](14, 2);[Link](d_errorzero);

[Link](0, 3);[Link]("pos=");
[Link](4, 3);[Link](errorpos);
[Link](9, 3);[Link]("pos=");
[Link](14, 3);[Link](d_errorpos);
}

void display_rule()
{
[Link](0, 0);[Link]("er=");
[Link](3, 0);[Link](error);
[Link](9, 0);[Link]("d_er=");
[Link](14, 0);[Link](d_error);

[Link](0, 1);[Link]("1=");
[Link](2, 1);[Link](u[0][0]);
[Link](7, 1);[Link]("2=");
[Link](9, 1);[Link](u[0][1]);
[Link](14, 1);[Link]("3=");
[Link](16, 1);[Link](u[0][2]);

[Link](0, 2);[Link]("4=");
[Link](2, 2);[Link](u[1][0]);
[Link](7, 2);[Link]("5=");
[Link](9, 2);[Link](u[1][1]);
[Link](14, 2);[Link]("6=");
[Link](16, 2);[Link](u[1][2]);

[Link](0, 3);[Link]("7=");
[Link](2, 3);[Link](u[2][0]);
[Link](7, 3);[Link]("8=");
[Link](9, 3);[Link](u[2][1]);
[Link](14, 3);[Link]("9=");
[Link](16, 3);[Link](u[2][2]);
}

void display_defuzzyfikasi()
{
[Link](0, 0);[Link]("er=");
[Link](3, 0);[Link](error);
[Link](9, 0);[Link]("d_er=");
[Link](14, 0);[Link](d_error);

[Link](0, 1);[Link]("Output =");

[Link](15, 1);[Link](beda_pwm);

[Link](0, 2);[Link]("Speed_Right =");

[Link](15, 2);[Link](speed_right);

[Link](0, 3);[Link]("Speed_Left =");

[Link](15, 3);[Link](speed_left);
}

7. Setelah program ditulis dan pastikan tidak ada program yang salah kemudian
lakukan proses compile program.

JOB SHEET KENDALI FUZZY LOGIC 25

 8. Setelah program selesai di compile, periksa dimana direktori file hex di bagian
bawah Arduino, lihat gambar di bawah ini.

Gambar 21. Direktori File Hex Disimpan

9. Buka ISIS Protus Klik dua kali komponen Arduino Nano, pada bagian program file
klik icon folder kemudian bukalah direktori berikut sebagai contoh
"C:\Users\USER~[Link]\AppData\Local\Temp\buildef30c71794278a04d1962dea16
[Link]/Job_8.[Link]"
Catatan: letak direktori file tersebut bisa berbeda-beda pastikan dahulu anda cek
di bagian bawah software Arduino IDE.
10. Setelah itu klik OK kemudian jalankan simulasi proteus.
11. Setelah program telah di kirim ke Arduino nano dengan baik maka LCD 20x4 akan
menampilkan tulisan seperti gambar di bawah ini:

Gambar 22. Tampilan LCD fuzzifikasi

12. Ubahlah nilai error menjadi 0 dengan memutar potensiometer error dan amati nilai
error_negatif, error_zero dan error_positif pada display LCD.
13. Ulangi langkah kerja 12 untuk data error sesuai tabel 4 dan catat hasilnya.

Tabel 4. Tabel Fuzzyfikasi Error

Error Error_negatif Error_zero Error_positif

-8
-7
-6
-5
-4
-3

JOB SHEET KENDALI FUZZY LOGIC 26

 -2
-1
0
1
2
3
4
5
6
7
8

14. Ulangi langkah kerja 12 dan 13 untuk variabel D_error atau perubahan error dan
catat hasilnya pada Tabel 5.

Tabel 5. Tabel Fuzzyfikasi Perubahan Error atau D_error

D_error Error_negatif Error_zero Error_positif

-16
-15
-14
-13
-12
-11
-10
-9
-8
-7
-6
-5
-4
-3
-2
-1
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
16

JOB SHEET KENDALI FUZZY LOGIC 27

 15. Ubahlah nilai error menjadi 5 dan nilai perubahan error menjadi 7 dengan
memutar potensiometer.
16. Tekan saklar ’fuzzyfikasi’ untuk menampilkan data derajat keanggotaan masing-
masing anggota variabel error dan perubahan error. Catat nilai error_negatif,
error_zero dan error_positif serta nilai D_error_negatif, D_error_zero dan
D_error_positif pada tabel 6.
17. Tekan saklar ’rule’ untuk menampilkan semua keluaran rule yaitu rule ke-1 hingga
rule ke-9. Catat nilai masing-masing keluaran rule pada tabel 6.
18. Tekan saklar ’defuzifikasi’ untuk menampilkan semua keluaran defuzifikasi yaitu
Output keluaran fuzzy, Speed Motor Right dan Speed Motor Left. Catat nilai masing-
masing keluaran defuzifikasi pada tabel 6.

Tabel 6. Data Hasil Penggalamatan Fuzifikasi, Evaluasi Rule & Defuzzifikasi

Error : ... D_error_negatif D_error_zero D_error_positif
D error : ... ... ... ...
Error_Negatif Rule 1 Rule 2 Rule 3
... ... ... ...
Error_Zero Rule 4 Rule 5 Rule 6
... ... ...
Error_Positif Rule 7 Rule 8 Rule 9
... ... ... ...
Output Fuzzy ........
Speed Motor Right ........
Speed Motor Left ........

19. Ulangi langkah kerja 15 s.d. 18 untuk nilai error dan D_error sesuai tabel 7
kemudian catat hasilnya seperti pada tabel 6.
Tabel 7. Data Uji

No. Error D_error

1 6 15
2 3 7
3 2 6
4 1 5
5 0 4
5 0 4
6 -2 3
7 -2 -1
8 -2 -4
9 -3 -5
10 -5 -9

20. Buatlah kesimpulan berdasarkan hasil praktik yang telah diperoleh.

JOB SHEET KENDALI FUZZY LOGIC 28

 FAKULTAS TEKNIK
UNIVERSITAS NEGERI YOGYAKARTA
JOB SHEET PRAKTIK SISTEM KENDALI CEDAS
Sem Ganjil 01. Fuzzifikasi pada Mikrokontroller
/ Genap Arduino Nano 200 menit
SKL/EKA/EKA416/01 Revisi: 03 Tgl: 5/29/2018

01. Fuzzifikasi pada Mikrokontroller Arduino Nano

A. Tujuan
Setelah melakukan praktikum mahasiswa diharapkan :
2. Memahami proses fuzzyfikasi serta aplikasinya pada mikrokontroller Arduino Nano.
3. Memahami perhitungan derajat keanggotaan.

B. Teori Dasar
Fuzzyfikasi
Fuzzyfikasi yaitu suatu proses untuk mengubah suatu masukan dari bentuk tegas
(crisp) menjadi fuzzy (variabel linguistik) yang biasanya disajikan dalam bentuk himpunan-
himpunan fuzzy dengan suatu fungsi keanggotaannya masing-masing. Fungsi keanggotaan
merupakan suatu kurva yang menunjukkan pemetaan titik-titik input data kedalam nilai
keanggotaanya (disebut juga dengan derajat keanggotaan) yang memiliki interval antara 0
sampai 1. Untuk mendapatkan nilai keanggotaan dapat menggunakan cara pendekatan
fungsi. Fungsi keanggotaan yang digunakan dalam praktikum kali ini adalah Representasi
Kurva Segitiga dan Representasi Kurva Trapesium.
1) Representasi Kurva Segitiga
Representasi kurva segitiga pada dasarnya merupakan gabungan antara 2 garis
(linear) yang membentuk segitiga seperti terlihat pada Gambar 23.

Gambar 23. Representasi Kurva Segitiga

JOB SHEET KENDALI FUZZY LOGIC 29

 Persamaan fungsi keanggotaan kurva segitiga dapat di rumuskan sebagai berikut :

2) Representasi Kurva Trapesium

Kurva trapesium pada dasarnya seperti bentuk segitiga, hanya saja ada beberapa
titik yang memiliki nilai keanggotaan 1 seperti pada Gambar 24.

Gambar 24. Representasi Kurva Trapesium

Persamaan fungsi keanggotaan Kurva Trapesium dapat di rumuskan sebagai berikut:

Pada percobaan kali ini akan dibahas tahapan proses fuzzyfikasi dengan dua
variabel Input yang diperoleh dari 2 buah potensiometer. Pada bagian Input terdapat 2
variabel yaitu variabel Error dan variabel Perubahan Error. Linguistik Variabel Error
mempunyai 3 buah linguistik value yaitu ErrorNeg, ErrorZero dan ErrorPos sedangkan
untuk Linguistik Variabel Perubahan Error mempunyai 3 buah linguistik value yaitu
DerrorNeg, DerrorZero dan DerrorPos. Data ADC dari potensiometer bernilai 0-255,
karena data tersebut terlalu lebar sehingga perlu dilakukan pembatasan atau range agar
nilai variabel error dapat bernilai -8 sampai 8 dan nilai variabel perubahan error bernilai -
16 sampai 16.

JOB SHEET KENDALI FUZZY LOGIC 30

1. Variabel Error
Variabel Error dibuat range pengukuran yaitu mulai -8 sampai dengan 8. Nilai ini
diperoleh dari pembacaan perubahan tegangan dari potensiometer yang menghasilkan nilai
error. Selanjutnya menentukan nilai untuk masing-masing domain seperti pada gambar 25.

Gambar 25. Fungsi keanggotaan Input Error

Setelah diketahui nilai errornya, bisa dilihat nilai error tersebut masuk anggota
mana saja beserta mencari nilai derajat keanggotaanya dengan memperhatikan gambar 26
dan penjelasan di bawah ini.

Gambar 26. Contoh fuzzyfikasi Error

Berdasarkan gambar 23 dapat dilihat bahwa nilai error 4 masuk anggota ErrorZero
dengan derajat keanggotaan sebesar X1. Selain itu, nilai error 4 juga masuk anggota
ErrorPos dengan derajat keanggotaan sebesar X2. Berikut ini perhitungan untuk mencari
nilai derajat keanggotaan dari nilai error 4 sebagai anggota ErrorZero dan ErrorPos:

Nilai x1 = (c-x)/(c-b) = (5-4)/(5-0) = 1/5 = 0,2

Nilai x2 = (x-b)/(c-b) = (4-0)/(5-0) = 4/5 = 0,8

Sehingga berdasarkan perhitungan di atas dapat dilihat bahwa nilai error 4

merupakan anggota himpunan ErrorZero dengan nilai keanggotaan 0,2 dan juga nilai
error 4 merupakan anggota himpunan ErrorPos dengan nilai keanggotaan 0,8.

JOB SHEET KENDALI FUZZY LOGIC 31

2. Variabel Perubahan Error
Variabel Perubahan Error dibuat range pengukuran yaitu mulai -16 sampai dengan
16. Variabel Perubahan Error mempunyai 3 buah anggota yaitu DerrorNeg, DerrorZero dan
DerrorPos. Selanjutnya menentukan nilai untuk masing-masing domain seperti terlihat
pada gambar 27.

Gambar 27. Fungsi keanggotaan Input Perubahan Error

Setelah diketahui nilai perubahan errornya, bisa dilihat nilai perubahan error
tersebut masuk anggota mana saja beserta mencari nilai derajat keanggotaanya dengan
memperhatikan gambar 28 dan penjelasan di bawah ini.

Gambar 28. Contoh fuzzyfikasi Perubahan Error

Berdasarkan gambar 25 bisa dilihat bahwa nilai perubahan error 2 masuk anggota
DerrorZero dengan derajat keanggotaan sebesar X1. Selain itu, nilai perubahan error 2
juga masuk anggota DerrorPos dengan derajat keanggotaan sebesar X2. Berikut ini
perhitungan untuk mencari nilai derajat keanggotaan dari nilai perubahan error 2 sebagai
anggota DerrorZero dan DerrorPos:

Nilai x1 = (c-x)/(c-b) = (8-2)/(8-0) = 6/8 = 0,75

Nilai x2 = (x-b)/(c-b) = (2-0)/(8-0) = 2/8 = 0,25

JOB SHEET KENDALI FUZZY LOGIC 32

 Sehingga berdasarkan perhitungan di atas dapat dilihat bahwa nilai perubahan error
2 merupakan anggota himpunan DerrorZero dengan nilai keanggotaan 0,75 dan juga nilai
perubahan error 2 merupakan anggota himpunan DerrorPos dengan nilai keanggotaan
0,25.

C. Alat dan Bahan

1. PC (Personal Computer) / Laptop
2. Media Pembelajaran Fuzzy Logic + Kabel Data + Kabel Penghubung
3. Software Arduino IDE

D. Keselamatan Kerja
1. Awali praktikum dengan berdoa.
2. Gunakanlah pakaian praktik pada saat praktikum.
3. Jauhkan peralatan yang tidak diperlukan dari meja kerja.
4. Bekerjalah dengan keadaan tanpa tegangan pada saat membuat dan mengubah
rangkaian.
5. Tanyakan kepada dosen pengampu atau staff pengajar ketika ada hal-hal yang
masih kurang paham.

E. Flowchart
Flowchart atau diagram alir adalah suatu bagan dengan simbol-simbol tertentu yang
menggambarkan urutan proses secara mendetail dan hubungan antara suatu proses
(instruksi) dengan proses lainnya dalam suatu program. Tujuannya agar praktikan dapat
dengan mudah memahami alur atau algoritma program dan juga dapat menyelaraskan
pikiran dengan rangkaian hardware yang hendak dirancang. Maka dari itu, flowchart
fuzzyfikasi variabel error pada gambar 29 dan flowchart fuzzyfikasi variabel perubahan
error pada gambar 30 adalah sebagai berikut.

JOB SHEET KENDALI FUZZY LOGIC 33

 Gambar 29. Flowchart Fuzzyfikasi Variabel Error

Gambar 30. Flowchart Fuzzyfikasi Variabel Perubahan Error

JOB SHEET KENDALI FUZZY LOGIC 34

F. Skema

Gambar 31. Skematik Fuzzyfikasi Pada Arduino

Tabel 8. Konfigurasi Pin Skematik

Pin Arduino Pin Trainer Pin Arduino Pin Trainer

LCD Potensiometer
A4 SDA A0 ERROR
A5 SCL A1 D_ERROR

G. Langkah Kerja
1. Siapkan alat dan bahan yang dibutuhkan.
2. Buatlah rangkaian sesuai pada gambar 31 dan Tabel 8 di atas dengan mengbungkan
pin Arduino nano dengan pin potensiometer dan pin LCD menggunakan kabel
jumper.
3. Hidupkan PC/Laptop dan kemudian buka software Arduino IDE.
4. Siapkan library I2C LCD dapat di download di link [Link]
cari file “LiquidCrystal_I2C.rar” kemudian klik download.

JOB SHEET KENDALI FUZZY LOGIC 35

 5. Masukan library I2C LCD ke Arduino IDE dengan cara klik menu bar Sketch →
include library → add .ZIP Library → pilih file library → open. Lebih jelas lihat
gambar 32.

Gambar 32. Cara Memasukan Library ke Arduino

6. Setelah Library I2C LCD terinstal langkah selanjutnya adalah ketikkan program
seperti yang tertulis berikut ini pada software Arduino IDE.
//----------I2C LCD------------
//A4:SDA -- A5:SCL (pin configurasi)
#include <Wire.h> // Menyertakan Library Komunikasi
#include <LiquidCrystal_I2C.h> // Menyertakan Library I2C
LiquidCrystal_I2C lcd(0x27,20,4); // set I2C address ke 0x27

//variabel global
int a,b,sensorA,sensorB; //variabel baca sensor ADC
float x, error; //variabel error
float y, d_error; //variabel perubahan error
float u_error[3],u_d_error[3], errorneg, errorzero, errorpos,
d_errorneg, d_errorzero,d_errorpos;

void setup() {
[Link](); // inisialisasi LCD
[Link]();// nyalakan backlight
}

void loop() {
baca_sensor(); //membaca nilai error dan d_error
fuzzyfikasi(); //memanggil & menjalankan fungsi fuzzifikasi
display_fuzzyfikasi(); //memanggil & menjalankan fungsi
penampilan hasil fuzzifikasi di LCD
}

void baca_sensor()
{
sensorA = analogRead(A0); //baca data analog di pin A0 dari
potensiometer untuk dikirim ke variabel sensorA
sensorB = analogRead(A1); //baca data analog di pin A1 dari
potensiometer untuk dikirim ke variabel sensorA

a = map(sensorA, 0, 1023, 0, 255); //merubah resolusi data SensorA

dari 10 bit(1023) menjadi 8 bit (255) kemudian disimpan di variabel a
b = map(sensorB, 0, 1023, 0, 255); //merubah resolusi data SensorB
dari 10 bit(1023) menjadi 8 bit (255) kemudian disimpan di variabel b

//range variabel a=(-8)~(8) untuk nilai error

if(a>=241) {error=8;}
else if(a>=227) {error=7;}

JOB SHEET KENDALI FUZZY LOGIC 36

 else if(a>=213) {error=6;}
else if(a>=199) {error=5;}
else if(a>=185) {error=4;}
else if(a>=171) {error=3;}
else if(a>=157) {error=2;}
else if(a>=143) {error=1;}
else if(a>=129) {error=0;}
else if(a>=115) {error=-1;}
else if(a>=101) {error=-2;}
else if(a>=87) {error=-3;}
else if(a>=73) {error=-4;}
else if(a>=59) {error=-5;}
else if(a>=45) {error=-6;}
else if(a>=31) {error=-7;}
else if((a<31)&&(a>=0)) {error=-8;}

//range variabel b=(-16)~(16) untuk nilai d_error

if(b>=248) {d_error=16;}
else if(b>=241) {d_error=15;}
else if(b>=234) {d_error=14;}
else if(b>=227) {d_error=13;}
else if(b>=220) {d_error=12;}
else if(b>=213) {d_error=11;}
else if(b>=206) {d_error=10;}
else if(b>=199) {d_error=9;}
else if(b>=192) {d_error=8;}
else if(b>=185) {d_error=7;}
else if(b>=178) {d_error=6;}
else if(b>=171) {d_error=5;}
else if(b>=164) {d_error=4;}
else if(b>=157) {d_error=3;}
else if(b>=150) {d_error=2;}
else if(b>=143) {d_error=1;}
else if(b>=136) {d_error=0;}
else if(b>=129) {d_error=-1;}
else if(b>=122) {d_error=-2;}
else if(b>=115) {d_error=-3;}
else if(b>=108) {d_error=-4;}
else if(b>=101) {d_error=-5;}
else if(b>= 94) {d_error=-6;}
else if(b>= 87) {d_error=-7;}
else if(b>= 80) {d_error=-8;}
else if(b>= 73) {d_error=-9;}
else if(b>= 66) {d_error=-10;}
else if(b>= 59) {d_error=-11;}
else if(b>= 52) {d_error=-12;}
else if(b>= 45) {d_error=-13;}
else if(b>= 38) {d_error=-14;}
else if(b>= 31) {d_error=-15;}
else if((b<31)&&(b>= 0)) {d_error=-16;}
}

void fuzzyfikasi_error()
{
x = error; //nilai error dikirim ke "x"

//range untuk menentukan derajat keanggotaan error

if(x >= 5)
{
u_error[0]=0;

JOB SHEET KENDALI FUZZY LOGIC 37

 u_error[1]=0;
u_error[2]=1;
}

else if(x >= 0)

{
u_error[0]=0;
u_error[1]=(5-x)/5;
u_error[2]=(x-0)/5;
}

else if(x >= -5)

{
u_error[0]=(0-x)/5;
u_error[1]=(x+5)/5;
u_error[2]=0;
}

else if(x < -5)

{
u_error[0]=1;
u_error[1]=0;
u_error[2]=0;
}

errorneg = u_error[0]; //simpan nilai "u_error[0]" ke fungsi

keanggotaan errorneg
errorzero = u_error[1]; //simpan nilai "u_error[1]" ke fungsi
keanggotaan errorzero
errorpos = u_error[2]; //simpan nilai "u_error[2]" ke fungsi
keanggotaan errorpos
}

void fuzzyfikasi_perubahan_error()
{
y = d_error; //nilai d_error dikirim ke "y"

//range untuk menentukan derajat keanggotaan u_d_error

if(y >= 8)
{
u_d_error[0]=0;
u_d_error[1]=0;
u_d_error[2]=1;
}

else if(y >= 0)

{
u_d_error[0]=0;
u_d_error[1]=(8-y)/8;
u_d_error[2]=(y-0)/8;
}

else if(y >= -8)

{
u_d_error[0]=(0-y)/8;
u_d_error[1]=(y+8)/8;
u_d_error[2]=0;
}

JOB SHEET KENDALI FUZZY LOGIC 38

 else if(y < -8)
{
u_d_error[0]=1;
u_d_error[1]=0;
u_d_error[2]=0;
}

d_errorneg = u_d_error[0]; //simpan nilai "u_d_error[0]" ke fungsi

keanggotaan d_errorneg
d_errorzero = u_d_error[1]; //simpan nilai "u_d_error[1]" ke fungsi
keanggotaan d_errorzero
d_errorpos = u_d_error[2]; //simpan nilai "u_d_error[2]" ke fungsi
keanggotaan d_errorpos
}

//fungsi fuzzifikasi error dan perubahan error

void fuzzyfikasi()
{
fuzzyfikasi_error(); //fungsi fuzzyfikasi_error
fuzzyfikasi_perubahan_error(); //fungsi fuzzyfikasi_perubahan_error
}

//Fungsi menampilkan nilai fuzzyfikasi ke LCD

void display_fuzzyfikasi()
{
[Link](0, 0);[Link]("er=");
[Link](3, 0);[Link](error);
[Link](9, 0);[Link]("d_er=");
[Link](14, 0);[Link](d_error);

[Link](0, 1);[Link]("neg=");
[Link](4, 1);[Link](errorneg);
[Link](9, 1);[Link]("neg=");
[Link](14, 1);[Link](d_errorneg);

[Link](0, 2);[Link]("zer=");
[Link](4, 2);[Link](errorzero);
[Link](9, 2);[Link]("zer=");
[Link](14, 2);[Link](d_errorzero);

[Link](0, 3);[Link]("pos=");
[Link](4, 3);[Link](errorpos);
[Link](9, 3);[Link]("pos=");
[Link](14, 3);[Link](d_errorpos);
}

7. Setelah program ditulis dan pastikan tidak ada program yang salah lakukan upload
program ke arduino dengan menghubungkan kabel data dari laptop ke arduino nano
kemudian mengatur menu bar Tools → Board : ”Arduino Nano” → Processor :
”Atmega328” → Port : ”Com (Menyesuaikan silahkan di cek di device manager)”
atau dapat dilihat melalui gambar 33 di bawah ini.

JOB SHEET KENDALI FUZZY LOGIC 39

 Gambar 33. Setting Konfigurasi Arduino

8. Setelah pengaturan board seperti di atas selesai dilakukan lakukan dengan klik
tombol upload.

Gambar 34. Tombol Upload

9. Tunggu beberapa detik hingga program selesai dikirim, setelah program selesai di
kirim.
10. Setelah program telah di kirim ke Arduino nano dengan baik maka LCD 20x4 akan
menampilkan tulisan seperti gambar di bawah ini:

Gambar 35. Tampilan LCD fuzzifikasi

11. Ubahlah nilai error menjadi 0 dengan memutar potensiometer error dan amati nilai
error_negatif, error_zero dan error_positif pada display LCD.
12. Ulangi langkah kerja 10 untuk data error sesuai tabel 9 dan catat hasilnya.

JOB SHEET KENDALI FUZZY LOGIC 40

 Tabel 9. Tabel Fuzzyfikasi Error

Error Error_negatif Error_zero Error_positif

-8
-7
-6
-5
-4
-3
-2
-1
0
1
2
3
4
5
6
7
8

13. Ulangi langkah kerja 10 dan 11 untuk variabel D_error atau perubahan error dan
catat hasilnya pada Tabel 10.

Tabel 10. Tabel Fuzzyfikasi Perubahan Error atau D_error

D_error Error_negatif Error_zero Error_positif

-16
-15
-14
-13
-12
-11
-10
-9
-8
-7
-6
-5
-4
-3
-2
-1
0
1
2
3
4
5
6

JOB SHEET KENDALI FUZZY LOGIC 41

 7
8
9
10
11
12
13
14
16
17

14. Buatlah kesimpulan berdasarkan hasil praktik yang telah diperoleh.

H. Tugas
1. Bandingkan data hasil percobaan dengan perhitungan secara langsung masing-
masing nilai derajat keanggotaan dari anggota variabel error dan D_error
menggunakan formula yang terdapat pada dasar teori.
2. Buatlah sistem fuzzyfikasi logika fuzzy dengan tiga buah input dan lima buah
membership function dengan kriteria dan range bebas.

JOB SHEET KENDALI FUZZY LOGIC 42

 FAKULTAS TEKNIK
UNIVERSITAS NEGERI YOGYAKARTA
JOB SHEET PRAKTIK SISTEM KENDALI CEDAS
Sem Ganjil / 02. Evaluasi Rule pada Mikrokontroler
Genap Arduino 200 menit
SKL/EKA/EKA416/02 Revisi: 03 Tgl: 5/29/2018

02. Evaluasi Rule pada Mikrokontroler Arduino

A. Tujuan
Setelah melakukan praktikum mahasiswa diharapkan :
1. Memahami proses evaluasi rule pada mikrokontroler aduino nano.
2. Menerapkan evaluasi rule pada mikrokontroler aduino nano.

B. Teori Dasar
Evaluasi Rule
Basis aturan (rule base) adalah sebuah aturan yang dibuat untuk menentukan
Output atau keluran dari sistem fuzzy yang terjadi. Basis aturan yang digunakan dalam
praktikum kali ini ditunjukkan oleh tabel 11.

Tabel 11. Basis Aturan

Perubahan Error→
DerrorNeg DerrorZero DerrorPos
Error↓
Positive Big Positive Small Zero
ErrorNeg
(R1) (R2) (R3)
Positive Small Zero Negative Small
ErrorZero
(R4) (R5) (R6)
Zero Negative Small Negative Big
ErrorPos
(R7) (R8) (R9)

Berdasarkan tabel 11 dapat dirumuskan 9 aturan. Berikut ini aturan yang digunakan
pada perancangan sistem fuzzy pada praktikum kali ini.
1. Jika error (ErrorNeg) dan perubahan error (DerrorNeg) maka perubahan kecepatan
akan (Positive Big).
2. Jika error (ErrorNeg) dan perubahan error (DerrorZero) maka perubahan
kecepatan akan (Positive Small).
3. Jika error (ErrorNeg) dan perubahan error (DerrorPos) maka perubahan
kecepatan akan (Zero).

JOB SHEET KENDALI FUZZY LOGIC 43

 4. Jika error (ErrorZero) dan perubahan error (DerrorNeg) maka perubahan
kecepatan akan (Positive Small).
5. Jika error (ErrorZero) dan perubahan error (DerrorZero) maka perubahan
kecepatan akan (Zero).
6. Jika error (ErrorZero) dan perubahan error (DerrorPos) maka perubahan
kecepatan akan (Negative Small).
7. Jika error (ErrorPos) dan perubahan error (DerrorNeg) maka perubahan kecepatan
akan (Zero).
8. Jika error (ErrorPos) dan perubahan error (DerrorZero) maka perubahan
kecepatan akan (Negative Small).
9. Jika error (ErrorPos) dan perubahan error (DerrorPos) maka perubahan kecepatan
akan (Negative Big).

Selanjutnya untuk menentukan aplikasi fungsi implikasi pada setiap aturan.

menggunakan metode Mamdani, pada metode mamdani aplikasi fungsi implikasi
menggunakan MIN, sedang komposisi aturan menggunakan metode MAX. Metode Mamdani
dikenal juga dengan metode MAX-MIN.
Inferensi output yang dihasilkan berupa bilangan fuzzy maka harus ditentukan suatu
nilai crisp tertentu sebagai output. Karena menggunakan Metode Mamdani, maka fungsi
implikasi yang digunakan adalah fungsi MIN. Dalam rule di atas menggunakan operator AND
maka nilai keanggotaan terkecil yang diambil dari himpunan yang bersangkutan yang
digambarkan oleh rumus berikut ini.

µA ∩ µB = min (µA[x], µB[y])

Contoh kasus:
Diketahui nilai Error = 4 dan Perubahan error = 2
Berikut diperlihatkan aplikasi fungsi implikasi untuk nilai Error = 4 dan Perubahan error = 2:

JOB SHEET KENDALI FUZZY LOGIC 44

 Gambar 36. Aplikasi fungsi implikasi untuk nilai error 4 dan Derror 2

Gambar 37. Tampilan Evaluasi Rule Pada LCD 20x4

Berdasarkan gambar 36 bisa dianalisa untuk hasil aplikasi fungsi implikasi untuk
masing-masing aturan (rule). Untuk rule R1, R2, R3, R4 dan R7 menghasilkan nilai implikasi
0 karena salah satu input mempunyai nilai derajat keanggotaan 0. Sehingga untuk kelima
rule tadi bisa diabaikan.
1. [R5] Jika error ErrorZero dan perubahan error DerrorZero maka perubahan
kecepatan akan Zero
α-predikat 5 = µ error ErrorZero ∩ µ perubahan error DerrorZero
= min(µ ErrorZero[4],µ DerrorZero [2])
= min(0,2 ; 0,75)
= 0,2
2. [R6] Jika error ErrorZero dan perubahan error DerrorPos maka perubahan kecepatan
akan Negative Small
α-predikat 6 = µ error ErrorZero 1 ∩ µ per error DerrorPos
= min(µ ErrorZero 1[4],µ DerrorPos[2])
= min(0,2 ; 0,25)
= 0,2

JOB SHEET KENDALI FUZZY LOGIC 45

 3. [R8] Jika error ErrorPos dan perubahan error DerrorZero maka perubahan kecepatan
akan Negative Small
α-predikat 8 = µ error ErrorPos ∩ µ per error ErrorZero
= min(µ error ErrorPos[4],µ per error ErrorZero[2])
= min(0,8 ; 0,75)
= 0,75
4. [R9] Jika error ErrorPos dan perubahan error DerrorPos maka perubahan kecepatan
akan Negative Big
α-predikat 9 = µ error ErrorPos ∩ µ perubahan error DerrorPos
= min(µ error ErrorPos[4],µ per error DerrorPos[2])
= min(0,8 ; 0,25)
= 0,25

C. Alat dan Bahan

1. PC (Personal Computer) / Laptop
2. Media Pembelajaran Fuzzy Logic + Kabel Data + Kabel Penghubung
3. Software Arduino IDE

D. Keselamatan Kerja
1. Awali praktikum dengan berdoa.
2. Gunakanlah pakaian praktik pada saat praktikum.
3. Jauhkan peralatan yang tidak diperlukan dari meja kerja.
4. Bekerjalah dengan keadaan tanpa tegangan pada saat membuat dan mengubah
rangkaian.
5. Tanyakan kepada dosen pengampu atau staff pengajar ketika ada hal-hal yang
masih kurang paham.

E. Flowchart
Berikut flowchart dari aturan fuzzy yang berlaku seperti terlihat pada gambar 38.

JOB SHEET KENDALI FUZZY LOGIC 46

 Gambar 38. Flowchart Aturan Fuzzy

Berdasarkan gambar 38, terlihat proses fuzzyfikasi sebelumnya diperoleh nilai

keanggotaan µE[ i ] dan µD[ j ]. Dikarenakan penggunaan operator AND maka nilai yang
diambil adalah MIN (µE[ I ] < µD[ j ] = rule[ i ][ j ] = µE[ i ] ). Selanjutnya dilakukan proses
looping agar semua keadaan dari rule yang ada dapat dijalankan seluruhnya.
Subrutin program evaluasi rule akan membandingkan nilai derajat keanggotaan dari
anggota error dengan anggota perubahan error. u_error[i] menunjukkan anggota variabel
error sedangkan u_d_error[j] menunjukkan anggota variabel perubahan error. Nilai terkecil
akan diambil karena penggunaan operator AND. Perulangan for digunakan agar semua
kondisi pada evaluasi rule terpenuhi yaitu sebanyak sembilan aturan.

JOB SHEET KENDALI FUZZY LOGIC 47

F. Skema

Gambar 39. Skematik Evaluasi Rule Pada Arduino

Tabel 12. Konfigurasi Pin Skematik

Pin Arduino Pin Trainer Pin Arduino Pin Trainer

LCD Potensiometer
A4 SDA A0 ERROR
A5 SCL A1 D_ERROR
Push Button
8 FUZZYFIKASI
9 RULE

G. Langkah Kerja
1. Siapkan alat dan bahan yang dibutuhkan.
2. Buatlah rangkaian sesuai pada gambar 39 dan Tabel 12 di atas dengan mengbungkan
pin Arduino nano dengan pin potensiometer, pin switch dan pin LCD menggunakan
kabel jumper.
3. Hidupkan PC/Laptop dan kemudian buka software Arduino IDE.
4. Ketikkan program seperti yang tertulis berikut ini pada software Arduino IDE.

JOB SHEET KENDALI FUZZY LOGIC 48

//----------I2C LCD------------
//A4:SDA -- A5:SCL (pin configurasi)
#include <Wire.h> // Menyertakan Library Komunikasi
#include <LiquidCrystal_I2C.h> // Menyertakan Library I2C
LiquidCrystal_I2C lcd(0x27,20,4); // set I2C address ke 0x27

//variabel global
int a,b,i,j,sensorA,sensorB;
float x, y, error, d_error;
float u_error[3],u_d_error[3],u[3][3], errorneg, errorzero, errorpos,
d_errorneg, d_errorzero,d_errorpos;

void setup() {
[Link](); // inisialisasi LCD
[Link](); // nyalakan backlight

pinMode(8, INPUT_PULLUP); //Set pin 8 sebagai input set high

pinMode(9, INPUT_PULLUP); //Set pin 9 sebagai input set high
}

void loop() {

baca_sensor(); //membaca nilai error dan d_error

fuzzyfikasi(); //memanggil & menjalankan fungsi fuzzifikasi
rule(); //memanggil & menjalankan fungsi rule

int tombol_fuzzyfikasi = digitalRead(8); //baca pin 8

int tombol_rule = digitalRead(9); //baca pin 9

if(tombol_fuzzyfikasi==0 && tombol_rule==1) {display_fuzzyfikasi();}

//menampilkan data proses fuzzyfikasi
if(tombol_fuzzyfikasi==1 && tombol_rule==0) {display_rule();}
//menampilkan implikasi setiap rule
if(tombol_fuzzyfikasi==1 && tombol_rule==1) {[Link]();}
//menghapus tampilan lcd
}

void baca_sensor()
{
sensorA = analogRead(A0); //baca data analog di pin A0 dari
potensiometer untuk dikirim ke variabel sensorA
sensorB = analogRead(A1); //baca data analog di pin A1 dari
potensiometer untuk dikirim ke variabel sensorA

a = map(sensorA, 0, 1023, 0, 255); //merubah resolusi data SensorA dari

10 bit(1023) menjadi 8 bit (255) kemudian disimpan di variabel a
b = map(sensorB, 0, 1023, 0, 255); //merubah resolusi data SensorB dari
10 bit(1023) menjadi 8 bit (255) kemudian disimpan di variabel b

//range variabel a=(-8)~(8) untuk nilai error

if(a>=241) {error=8;}
else if(a>=227) {error=7;}
else if(a>=213) {error=6;}
else if(a>=199) {error=5;}
else if(a>=185) {error=4;}
else if(a>=171) {error=3;}
else if(a>=157) {error=2;}
else if(a>=143) {error=1;}
else if(a>=129) {error=0;}

JOB SHEET KENDALI FUZZY LOGIC 49

 else if(a>=115) {error=-1;}
else if(a>=101) {error=-2;}
else if(a>=87) {error=-3;}
else if(a>=73) {error=-4;}
else if(a>=59) {error=-5;}
else if(a>=45) {error=-6;}
else if(a>=31) {error=-7;}
else if((a<31)&&(a>=0)) {error=-8;}

//range variabel b=(-16)~(16) untuk nilai d_error

if(b>=248) {d_error=16;}
else if(b>=241) {d_error=15;}
else if(b>=234) {d_error=14;}
else if(b>=227) {d_error=13;}
else if(b>=220) {d_error=12;}
else if(b>=213) {d_error=11;}
else if(b>=206) {d_error=10;}
else if(b>=199) {d_error=9;}
else if(b>=192) {d_error=8;}
else if(b>=185) {d_error=7;}
else if(b>=178) {d_error=6;}
else if(b>=171) {d_error=5;}
else if(b>=164) {d_error=4;}
else if(b>=157) {d_error=3;}
else if(b>=150) {d_error=2;}
else if(b>=143) {d_error=1;}
else if(b>=136) {d_error=0;}
else if(b>=129) {d_error=-1;}
else if(b>=122) {d_error=-2;}
else if(b>=115) {d_error=-3;}
else if(b>=108) {d_error=-4;}
else if(b>=101) {d_error=-5;}
else if(b>= 94) {d_error=-6;}
else if(b>= 87) {d_error=-7;}
else if(b>= 80) {d_error=-8;}
else if(b>= 73) {d_error=-9;}
else if(b>= 66) {d_error=-10;}
else if(b>= 59) {d_error=-11;}
else if(b>= 52) {d_error=-12;}
else if(b>= 45) {d_error=-13;}
else if(b>= 38) {d_error=-14;}
else if(b>= 31) {d_error=-15;}
else if((b<31)&&(b>= 0)) {d_error=-16;}
}

void fuzzyfikasi_error()
{
x = error; //nilai error dikirim ke "x"

//range untuk menentukan derajat keanggotaan error

if(x >= 5)
{
u_error[0]=0;
u_error[1]=0;
u_error[2]=1;
}

else if(x >= 0)

{
u_error[0]=0;

JOB SHEET KENDALI FUZZY LOGIC 50

 u_error[1]=(5-x)/5;
u_error[2]=(x-0)/5;
}

else if(x >= -5)

{
u_error[0]=(0-x)/5;
u_error[1]=(x+5)/5;
u_error[2]=0;
}

else if(x < -5)

{
u_error[0]=1;
u_error[1]=0;
u_error[2]=0;
}

errorneg = u_error[0]; //simpan nilai "u_error[0]" ke fungsi keanggotaan

errorneg
errorzero = u_error[1]; //simpan nilai "u_error[1]" ke fungsi keanggotaan
errorzero
errorpos = u_error[2]; //simpan nilai "u_error[2]" ke fungsi keanggotaan
errorpos
}

void fuzzyfikasi_perubahan_error()
{
y = d_error; //nilai d_error dikirim ke "y"

//range untuk menentukan derajat keanggotaan u_d_error

if(y >= 8)
{
u_d_error[0]=0;
u_d_error[1]=0;
u_d_error[2]=1;
}

else if(y >= 0)

{
u_d_error[0]=0;
u_d_error[1]=(8-y)/8;
u_d_error[2]=(y-0)/8;
}

else if(y >= -8)

{
u_d_error[0]=(0-y)/8;
u_d_error[1]=(y+8)/8;
u_d_error[2]=0;
}

else if(y < -8)

{
u_d_error[0]=1;
u_d_error[1]=0;
u_d_error[2]=0;
}

JOB SHEET KENDALI FUZZY LOGIC 51

 d_errorneg = u_d_error[0]; //simpan nilai "u_d_error[0]" ke fungsi
keanggotaan d_errorneg
d_errorzero = u_d_error[1]; //simpan nilai "u_d_error[1]" ke fungsi
keanggotaan d_errorzero
d_errorpos = u_d_error[2]; //simpan nilai "u_d_error[2]" ke fungsi
keanggotaan d_errorpos
}

//fungsi fuzzifikasi error dan perubahan error

void fuzzyfikasi()
{
fuzzyfikasi_error(); //fungsi fuzzyfikasi_error
fuzzyfikasi_perubahan_error(); //fungsi fuzzyfikasi_perubahan_error
}

void rule() // basis aturan

{
for(i=0;i<=2;i++) //looping jumlah keanggotaan variabel error
{
for(j=0;j<=2;j++) //looping jumlah keanggotaan variabel perubahan error
{
if(u_error[i]<u_d_error[j]) //apakah nilai anggota variabel error lebih
kecil dari anggota variabel perubahan error.
{
u[i][j]=u_error[i]; // menggunakan operator AND yang di ambil
nilai terkecil
}
else
{
u[i][j]=u_d_error[j];
}
}
}
}

//Fungsi menampilkan nilai fuzzyfikasi ke LCD

void display_fuzzyfikasi()
{
[Link](0, 0);[Link]("er=");
[Link](3, 0);[Link](error);
[Link](9, 0);[Link]("d_er=");
[Link](14, 0);[Link](d_error);

[Link](0, 1);[Link]("neg=");
[Link](4, 1);[Link](errorneg);
[Link](9, 1);[Link]("neg=");
[Link](14, 1);[Link](d_errorneg);

[Link](0, 2);[Link]("zer=");
[Link](4, 2);[Link](errorzero);
[Link](9, 2);[Link]("zer=");
[Link](14, 2);[Link](d_errorzero);

[Link](0, 3);[Link]("pos=");
[Link](4, 3);[Link](errorpos);
[Link](9, 3);[Link]("pos=");
[Link](14, 3);[Link](d_errorpos);
}

JOB SHEET KENDALI FUZZY LOGIC 52

//Fungsi menampilkan nilai rule ke LCD
void display_rule()
{
[Link](0, 0);[Link]("er=");
[Link](3, 0);[Link](error);
[Link](9, 0);[Link]("d_er=");
[Link](14, 0);[Link](d_error);

[Link](0, 1);[Link]("1=");
[Link](2, 1);[Link](u[0][0]);
[Link](7, 1);[Link]("2=");
[Link](9, 1);[Link](u[0][1]);
[Link](14, 1);[Link]("3=");
[Link](16, 1);[Link](u[0][2]);

[Link](0, 2);[Link]("4=");
[Link](2, 2);[Link](u[1][0]);
[Link](7, 2);[Link]("5=");
[Link](9, 2);[Link](u[1][1]);
[Link](14, 2);[Link]("6=");
[Link](16, 2);[Link](u[1][2]);

[Link](0, 3);[Link]("7=");
[Link](2, 3);[Link](u[2][0]);
[Link](7, 3);[Link]("8=");
[Link](9, 3);[Link](u[2][1]);
[Link](14, 3);[Link]("9=");
[Link](16, 3);[Link](u[2][2]);
}

5. Setelah program ditulis dan pastikan tidak ada program yang salah lakukan upload
program ke arduino dengan menghubungkan kabel data dari laptop ke arduino nano
kemudian mengatur menu bar Tools → Board : ”Arduino Nano” → Processor :
”Atmega328” → Port : ”Com (Menyesuaikan silahkan di cek di device manager)”
6. Setelah pengaturan board seperti di atas selesai dilakukan lakukan dengan klik
tombol upload.
7. Tunggu beberapa detik hingga program selesai dikirim, setelah program selesai di
kirim.
8. Ubahlah nilai error menjadi 5 dan nilai perubahan error menjadi 7 dengan
memutar potensiometer.
9. Tekan saklar ’fuzzyfikasi’ untuk menampilkan data derajat keanggotaan masing-
masing anggota variabel error dan perubahan error. Catat nilai error_negatif,
error_zero dan error_positif serta nilai D_error_negatif, D_error_zero dan
D_error_positif pada tabel 13.
10. Tekan saklar ’rule’ untuk menampilkan semua keluaran rule yaitu rule ke-1 hingga
rule ke-9. Catat nilai masing-masing keluaran rule pada tabel 13.

JOB SHEET KENDALI FUZZY LOGIC 53

 Tabel 13. Hasil Pengamatan
Error : ... D_error_negatif D_error_zero D_error_positif
D error : ... ... ... ...
Error_Negatif Rule 1 Rule 2 Rule 3
... ... ... ...
Error_Zero Rule 4 Rule 5 Rule 6
... ... ... ...
Error_Positif Rule 7 Rule 8 Rule 9
... ... ... ...

11. Ulangi langkah kerja 9 s.d. 11 untuk nilai error dan D_error sesuai tabel 6 kemudian
catat hasilnya seperti pada tabel 14.

Tabel 14. Data Uji

No. Error D_error

1 6 15
2 3 7
3 2 6
4 1 5
5 0 4
6 -2 3
7 -2 -1
8 -2 -4
9 -3 -5
10 -5 -9

12. Buatlah kesimpulan berdasarkan hasil praktik yang telah diperoleh.

H. Tugas
1. Bandingkan data hasil percobaan dengan perhitungan secara langsung masing-
masing keluaran rule untuk nilai error dan D_error sesuai data pengujian. Ambil dua
sample nilai error dan perubahan error untuk dihitung.
2. Buatlah sistem fuzzy dengan jumlah 15 aturan.

JOB SHEET KENDALI FUZZY LOGIC 54

 FAKULTAS TEKNIK
UNIVERSITAS NEGERI YOGYAKARTA
JOB SHEET PRAKTIK SISTEM KENDALI CEDAS
Sem Ganjil / 03. Defuzzifikasi pada mikrokontroler
Genap arduino 200 menit
SKL/EKA/EKA416/03 Revisi: 03 Tgl: 5/29/2018

03. Defuzzifikasi pada Mikrokontroler Arduino

A. Tujuan
Setelah melakukan praktikum mahasiswa diharapkan :
1. Mampu memahami dan menerapkan proses defuzzyfikasi pada mikrokontroler
Arduino nano.
2. Memahami perhitungan-perhitungan pada tahap defuzzyfikasi.

B. Teori Dasar
Defuzzyfikasi
Defuzzifikasi merupakan suatu proses pengubahan besaran fuzzy ke bentuk bentuk
tegasnya (crisp) kembali. Hal ini diperlukan sebab dalam aplikasi nyata yang dibutuhkan
adalah nilai tegas (crisp). Prosesnya adalah sebagai berikut: suatu nilai fuzzy output yang
berasal dari rule evaluation diambil kemudian dimasukkan ke dalam suatu membership
function output.
Input dari proses defuzzifikasi adalah suatu himpunan fuzzy yang diperoleh dari
komposisi aturan-aturan fuzzy, sedangkan output yang dihasilkan merupakan suatu
bilangan pada domain himpunan fuzzy tersebut. Jika diberikan suatu himpunan fuzzy
dalam range tertentu, maka harus dapat di ambil suatu nilai crisp tertentu sebagai output.
Metode defuzzyfikasi yang digunakan adalah metode centroid atau juga dikenal
dengan Center of Area (COA). Pada metode ini, solusi crisp diperoleh dengan cara
mengambil titik pusat daerah fuzzy.
Output fuzzy yang diharapkan disini adalah nilai perubahan kecepatan motor DC
dimana inputnya didapat dari dua buah potensiometer. Nilai perubahan kecepatan akan
digunakan dalam mempengaruhi kecepatan putar antara motor sebelah kanan dan motor
sebelah kiri. Masing-masing kecepatan motor sudah ditentukan nilai awalnya yaitu 60.
Sedangkan rentang kecepatan motor berkisar antara 0-255 yang mana merupan nilai PWM
yang dihasilkan dari mikrokontroler. Awal proses defuzzyfikasi adalah mengolah data pada
variabel output. Variabel output disini adalah variabel Perubahan Kecepatan. Variable ini
mempunyai nilai antara -160 sampai dengan 160.

JOB SHEET KENDALI FUZZY LOGIC 55

 Variabel Perubahan Kecepatan mempunyai 5 buah linguistik value yaitu Negative
Big, Negative Small, Zero, Positive Small dan Positive Big. Gambar 40 merupakan
gambar fungsi keanggotaan output perubahan kecepatan.

Gambar 40. Fungsi keanggotaan Output Perubahan Kecepatan

Selanjutnya dari setiap fungsi keanggotaan dicari luas daerah dan titik tengah
masing-masing anggota. Untuk menghitung Luas daerah anggota Negative Small, Zero dan
Positive Small digunakan rumus luas segitiga karena ketiganya berbentuk segitiga.
• Contoh perhitungan luas daerah anggota Negative Small.

Gambar 41. Luas Daerah Anggota Negative Small

Berdasarkan gambar 41 di atas, bisa dihitung luas daerah anggota Negative Small.

Panjang alas (a) = 0 – (-160) = 160

Tinggi =1

Luas daerah = = = 80

Perhitungan diatas juga berlaku untuk mencari luas daerah anggota Zero dan
Positive Small. Sedangkan untuk mencari luas daerah anggota Negative Big dan Positive Big
digunakan rumus luas trapesium.

JOB SHEET KENDALI FUZZY LOGIC 56

 Selanjutnya mencari titik tengah untuk masing-masing anggota. Titik tengah yang
dimaksud di sini adalah titik yang membagi daerah tersebut menjadi dua bagian yang
mempunyai luas yang sama antara sebelah kiri dan kanan. Untuk nilai titik tengah anggota
Negative Small, Zero dan Positive Small bisa diketahui secara langsung karena ketiga
anggota tersebut berbentuk segitiga sama kaki atau sebelah kanan dan kiri simetris.
Sedangkan untuk mencari titik tengah anggota Negative Big dan Positive Big menggunakan
rumus (nilai titik terjauh dari Negative Big atau Positive Big - COA Negative Small atau
Positive Small / 2) setelah itu hasilnya ditambahkan ke nilai COA Negative Small atau
Positive Small.
Berikut gambaran lengkap dalam mencari nilai titik tengah masing-masing anggota
seperti terlihat pada gambar 42.

Gambar 42. Titik Tengah Setiap Anggota

Data lengkap luas daerah dan titik tengah masing-masing anggota dapat dilihat
pada tabel 15 berikut ini.

Tabel 15. Luas dan Titik Tengah

Anggota Luas Titik Tengah (CoA)

Negative Big z1 60 a1 -145,5
Negative Small z2 80 a2 -80
Zero z3 80 a3 0
Positive Small z4 80 a4 80
Positive Big z5 60 a5 145,5

Langkah selanjutnya dilakukan perhitungan untuk mencari nilai output yang

diharapkan.

JOB SHEET KENDALI FUZZY LOGIC 57

 Keterangan
Rule : hasil fungsi implikasi dari kedua input
Coa : titik tengah anggota
Luas : luas daerah anggota
n : jumlah rule yang dipakai
i : data ke-n

Setelah nilai output ditemukan maka nilai tersebut adalah output fuzzy yang
diharapkan. Tahap akhirnya adalah memasukkan nilai output ke dalam persamaan untuk
menentukan kecepatan motor kanan dan kiri. Keluaran dari proses fuzzyfikasi adalah nilai
validasi. Selanjutnya nilai validasi dimasukkan ke dalam variabel beda_pwm. Nilai
beda_pwm akan mempengaruhi kecepatan motor kanan dan motor kiri. Nilai validasi
diperoleh dari hasil bagi antara pembilang dan penyebut.
• Nilai perubahan kecepatan = output
• Nilai kecepatan motor kanan = nilai awal - nilai perubahan kecepatan
• Nilai kecepatan motor kiri = nilai awal + nilai perubahan kecepatan

C. Alat dan Bahan

1. PC (Personal Computer) / Laptop
2. Media Pembelajaran Fuzzy Logic + Kabel Data + Kabel Penghubung
3. Software Arduino IDE

D. Keselamatan Kerja
1. Awali praktikum dengan berdoa.
2. Gunakanlah pakaian praktik pada saat praktikum.
3. Jauhkan peralatan yang tidak diperlukan dari meja kerja.
4. Bekerjalah dengan keadaan tanpa tegangan pada saat membuat dan mengubah
rangkaian.
5. Tanyakan kepada dosen pengampu atau staff pengajar ketika ada hal-hal yang
masih kurang paham.

E. Flowchart
Flowchart proses defuzzyfikasi seperti terlihat ada gambar 43.

JOB SHEET KENDALI FUZZY LOGIC 58

 Gambar 43. Flowchart proses defuzzyfikasi

F. Skema

Gambar 44. Skematik Defuzzyfikasi Pada Arduino

JOB SHEET KENDALI FUZZY LOGIC 59

 Tabel 16. Konfigurasi Pin Skematik

Pin Arduino Pin Trainer Pin Arduino Pin Trainer

LCD Driver Motor L293D
A4 SDA 2 IN1
A5 SCL 3 IN2
Push Button 6 EN1 (KANAN)
8 S1 4 IN3
9 S2 7 IN4
10 S3 5 EN2 (KIRI)
Potensiometer
A0 ERROR
A1 D_ERROR

G. Langkah Kerja
1. Siapkan alat dan bahan yang dibutuhkan.
2. Buatlah rangkaian sesuai pada gambar 44 dan tabel 16 di atas dengan mengbungkan
pin Arduino nano dengan pin potensiometer, pin switch, pin driver motor L298N +
motor DC dan pin LCD menggunakan kabel jumper.
3. Hidupkan PC/Laptop dan kemudian buka software Arduino IDE.
4. Ketikkan program seperti yang tertulis berikut ini pada software Arduino IDE.

//inisialisasi motor kanan

#define IN1 2 //definisikan pin 2 dengan variabel IN2
#define IN2 3 //definisikan pin 3 dengan variabel IN3
#define pwm_kanan 6 //definisikan pin 6 dengan variabel pwm_kanan

//inisialisasi motor kiri

#define IN3 4 //definisikan pin 4 dengan variabel IN3
#define IN4 7 //definisikan pin 7 dengan variabel IN4
#define pwm_kiri 5 //definisikan pin 5 dengan variabel pwm_kiri

//----------I2C LCD------------
//A4:SDA -- A5:SCL (pin configurasi)
#include <Wire.h> // Menyertakan Library Komunikasi
#include <LiquidCrystal_I2C.h> // Menyertakan Library I2C
LiquidCrystal_I2C lcd(0x27,20,4); // set I2C address ke 0x27

//variabel global
int a,b,i,j,sensorA,sensorB;
float x, y, error, d_error, z1=60,z2=80,a1=-145.5556,a2=-
80,a3=0,a4=80,a5=145.5556;//z = luas dan a = COA out;
float u_error[3],u_d_error[3],u[3][3], errorneg, errorzero, errorpos,
d_errorneg, d_errorzero,d_errorpos;
float nilai_awal,beda_pwm, validasi, pembilang,
penyebut,speed_left,speed_right;

void setup() {
[Link](); // inisialisasi LCD
[Link](); // nyalakan backlight

JOB SHEET KENDALI FUZZY LOGIC 60

 //inisialisasi pin untuk motor DC
pinMode(IN1, OUTPUT); //set variabel IN1 sebagai output
pinMode(IN2, OUTPUT); //set variabel IN2 sebagai output
pinMode(IN3, OUTPUT); //set variabel IN3 sebagai output
pinMode(IN4, OUTPUT); //set variabel IN4 sebagai output
pinMode(pwm_kanan, OUTPUT); //set variabel pwm_kanan sebagai output
pinMode(pwm_kiri, OUTPUT); //set variabel pwm_kiri sebagai output

//inisialisasi pin switch

pinMode(8, INPUT_PULLUP); //Set pin 8 sebagai input set high
pinMode(9, INPUT_PULLUP); //Set pin 9 sebagai input set high
pinMode(10, INPUT_PULLUP);//Set pin 10 sebagai input set high
}

void loop() {
nilai_awal = 100; //set nilai awal pwm sebesar 100

baca_sensor(); //membaca nilai error dan d_error

fuzzyfikasi(); //memanggil & menjalankan fungsi fuzzifikasi
rule(); //memanggil & menjalankan fungsi evaluasi rule
defuzzyfikasi();//memanggil & menjalankan fungsi defuzzifikasi

kendali_motor(speed_left,speed_right); //memangil fungsi kendali motor

int tombol_fuzzyfikasi = digitalRead(8); //baca nilai pin 8

int tombol_rule = digitalRead(9); //baca nilai pin 9
int tombol_defuzzyfikasi = digitalRead(10);//baca nilai pin 10

if(tombol_fuzzyfikasi==0 && tombol_rule==1 && tombol_defuzzyfikasi==1)

{display_fuzzyfikasi();} //menampilkan data proses fuzzyfikasi
if(tombol_fuzzyfikasi==1 && tombol_rule==0 && tombol_defuzzyfikasi==1)
{display_rule();} //menampilkan implikasi setiap rule
if(tombol_fuzzyfikasi==1 && tombol_rule==1 && tombol_defuzzyfikasi==0)
{display_defuzzyfikasi();}//menampilkan output tegas dan nilai kecepatan
motor kiri dan kanan
if(tombol_fuzzyfikasi==1 && tombol_rule==1 && tombol_defuzzyfikasi==1)
{[Link]();} //menghapus tampilan lcd
}

void baca_sensor()
{
sensorA = analogRead(A0); //baca data analog di pin A0 dari
potensiometer untuk dikirim ke variabel sensorA
sensorB = analogRead(A1); //baca data analog di pin A1 dari
potensiometer untuk dikirim ke variabel sensorA

a = map(sensorA, 0, 1023, 0, 255); //merubah resolusi data SensorA dari

10 bit(1023) menjadi 8 bit (255) kemudian disimpan di variabel a
b = map(sensorB, 0, 1023, 0, 255); //merubah resolusi data SensorB dari
10 bit(1023) menjadi 8 bit (255) kemudian disimpan di variabel b

//range variabel a=(-8)~(8) untuk nilai error

if(a>=241) {error=8;}
else if(a>=227) {error=7;}
else if(a>=213) {error=6;}
else if(a>=199) {error=5;}
else if(a>=185) {error=4;}
else if(a>=171) {error=3;}
else if(a>=157) {error=2;}
else if(a>=143) {error=1;}

JOB SHEET KENDALI FUZZY LOGIC 61

 else if(a>=129) {error=0;}
else if(a>=115) {error=-1;}
else if(a>=101) {error=-2;}
else if(a>=87) {error=-3;}
else if(a>=73) {error=-4;}
else if(a>=59) {error=-5;}
else if(a>=45) {error=-6;}
else if(a>=31) {error=-7;}
else if((a<31)&&(a>=0)) {error=-8;}

//range variabel b=(-16)~(16) untuk nilai d_error

if(b>=248) {d_error=16;}
else if(b>=241) {d_error=15;}
else if(b>=234) {d_error=14;}
else if(b>=227) {d_error=13;}
else if(b>=220) {d_error=12;}
else if(b>=213) {d_error=11;}
else if(b>=206) {d_error=10;}
else if(b>=199) {d_error=9;}
else if(b>=192) {d_error=8;}
else if(b>=185) {d_error=7;}
else if(b>=178) {d_error=6;}
else if(b>=171) {d_error=5;}
else if(b>=164) {d_error=4;}
else if(b>=157) {d_error=3;}
else if(b>=150) {d_error=2;}
else if(b>=143) {d_error=1;}
else if(b>=136) {d_error=0;}
else if(b>=129) {d_error=-1;}
else if(b>=122) {d_error=-2;}
else if(b>=115) {d_error=-3;}
else if(b>=108) {d_error=-4;}
else if(b>=101) {d_error=-5;}
else if(b>= 94) {d_error=-6;}
else if(b>= 87) {d_error=-7;}
else if(b>= 80) {d_error=-8;}
else if(b>= 73) {d_error=-9;}
else if(b>= 66) {d_error=-10;}
else if(b>= 59) {d_error=-11;}
else if(b>= 52) {d_error=-12;}
else if(b>= 45) {d_error=-13;}
else if(b>= 38) {d_error=-14;}
else if(b>= 31) {d_error=-15;}
else if((b<31)&&(b>= 0)) {d_error=-16;}
}

void fuzzyfikasi_error()
{
x = error; //nilai error dikirim ke "x"

//range untuk menentukan derajat keanggotaan error

if(x >= 5)
{
u_error[0]=0;
u_error[1]=0;
u_error[2]=1;
}

else if(x >= 0)

{

JOB SHEET KENDALI FUZZY LOGIC 62

 u_error[0]=0;
u_error[1]=(5-x)/5;
u_error[2]=(x-0)/5;
}

else if(x >= -5)

{
u_error[0]=(0-x)/5;
u_error[1]=(x+5)/5;
u_error[2]=0;
}

else if(x < -5)

{
u_error[0]=1;
u_error[1]=0;
u_error[2]=0;
}

errorneg = u_error[0]; //simpan nilai "u_error[0]" ke fungsi keanggotaan

errorneg
errorzero = u_error[1]; //simpan nilai "u_error[1]" ke fungsi keanggotaan
errorzero
errorpos = u_error[2]; //simpan nilai "u_error[2]" ke fungsi keanggotaan
errorpos
}

void fuzzyfikasi_perubahan_error()
{
y = d_error; //nilai d_error dikirim ke "y"

//range untuk menentukan derajat keanggotaan u_d_error

if(y >= 8)
{
u_d_error[0]=0;
u_d_error[1]=0;
u_d_error[2]=1;
}

else if(y >= 0)

{
u_d_error[0]=0;
u_d_error[1]=(8-y)/8;
u_d_error[2]=(y-0)/8;
}

else if(y >= -8)

{
u_d_error[0]=(0-y)/8;
u_d_error[1]=(y+8)/8;
u_d_error[2]=0;
}

else if(y < -8)

{
u_d_error[0]=1;
u_d_error[1]=0;
u_d_error[2]=0;
}

JOB SHEET KENDALI FUZZY LOGIC 63

 d_errorneg = u_d_error[0]; //simpan nilai "u_d_error[0]" ke fungsi
keanggotaan d_errorneg
d_errorzero = u_d_error[1]; //simpan nilai "u_d_error[1]" ke fungsi
keanggotaan d_errorzero
d_errorpos = u_d_error[2]; //simpan nilai "u_d_error[2]" ke fungsi
keanggotaan d_errorpos
}

//fungsi fuzzifikasi error dan perubahan error

void fuzzyfikasi()
{
fuzzyfikasi_error(); //fungsi fuzzyfikasi_error
fuzzyfikasi_perubahan_error(); //fungsi fuzzyfikasi_perubahan_error
}

void rule() // basis aturan

{
for(i=0;i<=2;i++) //looping jumlah keanggotaan variabel error
{
for(j=0;j<=2;j++) //looping jumlah keanggotaan variabel perubahan error
{
if(u_error[i]<u_d_error[j]) //apakah nilai anggota variabel error lebih
kecil dari anggota variabel perubahan error.
{
u[i][j]=u_error[i]; // menggunakan operator AND yang di ambil
nilai terkecil
}
else
{
u[i][j]=u_d_error[j];
}
}
}
}

void defuzzyfikasi()
{
//menggunakan metode mamdani dan defuzzyfikasi menggunakan metode
centroid of area
pembilang
=(u[0][0]*a5*z1)+(u[0][1]*a4*z2)+(u[0][2]*a3*z2)+(u[1][0]*a4*z2)+(u[1][1]*a
3*z2)+(u[1][2]*a2*z2)+(u[2][0]*a3*z2)+(u[2][1]*a2*z2)+(u[2][2]*a1*z1);

penyebut
=(u[0][0]*z1)+(u[0][1]*z2)+(u[0][2]*z2)+(u[1][0]*z2)+(u[1][1]*z2)+(u[1][2]*
z2)+(u[2][0]*z2)+(u[2][1]*z2)+(u[2][2]*z1);

validasi=pembilang/penyebut; // perhitungan defuzzyfikasi dengan

menggabungkan seluruh nilai min yang sudah didapatkan
beda_pwm = validasi;
speed_left = nilai_awal-beda_pwm;
speed_right = nilai_awal+beda_pwm;
}

void kendali_motor(float pwm_ki,float pwm_ka)

{

if(pwm_ki>=0) //motor kiri maju

{
analogWrite(pwm_kiri, pwm_ki); //kirim pulsa pwm ke motor kiri

JOB SHEET KENDALI FUZZY LOGIC 64

 digitalWrite(IN3, LOW); //set putaran motor kiri maju
digitalWrite(IN4, HIGH); //set putaran motor kiri maju
}

else if(pwm_ki<0)
{
analogWrite(pwm_kiri, -pwm_ki); //kirim pulsa pwm ke motor kiri
digitalWrite(IN3, HIGH); //set putaran motor kiri mundur
digitalWrite(IN4, LOW); //set putaran motor kiri mundur
}

if(pwm_ka>=0) //motor kanan maju

{
analogWrite(pwm_kanan, pwm_ka); //kirim pulsa pwm ke motor kanan
digitalWrite(IN1, LOW); //set putaran motor kanan maju
digitalWrite(IN2, HIGH); //set putaran motor kanan maju
}

else if(pwm_ka<0) //motor kanan mundur

{
analogWrite(pwm_kanan, -pwm_ka); //kirim pulsa pwm ke motor kanan
digitalWrite(IN1, HIGH); //set putaran motor kanan mundur
digitalWrite(IN2, LOW); //set putaran motor kanan mundur
}
}

//Fungsi menampilkan nilai fuzzyfikasi ke LCD

void display_fuzzyfikasi()
{
[Link](0, 0);[Link]("er=");
[Link](3, 0);[Link](error);
[Link](9, 0);[Link]("d_er=");
[Link](14, 0);[Link](d_error);

[Link](0, 1);[Link]("neg=");
[Link](4, 1);[Link](errorneg);
[Link](9, 1);[Link]("neg=");
[Link](14, 1);[Link](d_errorneg);

[Link](0, 2);[Link]("zer=");
[Link](4, 2);[Link](errorzero);
[Link](9, 2);[Link]("zer=");
[Link](14, 2);[Link](d_errorzero);

[Link](0, 3);[Link]("pos=");
[Link](4, 3);[Link](errorpos);
[Link](9, 3);[Link]("pos=");
[Link](14, 3);[Link](d_errorpos);
}

//Fungsi menampilkan nilai rule ke LCD

void display_rule()
{
[Link](0, 0);[Link]("er=");
[Link](3, 0);[Link](error);
[Link](9, 0);[Link]("d_er=");
[Link](14, 0);[Link](d_error);

[Link](0, 1);[Link]("1=");
[Link](2, 1);[Link](u[0][0]);

JOB SHEET KENDALI FUZZY LOGIC 65

 [Link](7, 1);[Link]("2=");
[Link](9, 1);[Link](u[0][1]);
[Link](14, 1);[Link]("3=");
[Link](16, 1);[Link](u[0][2]);

[Link](0, 2);[Link]("4=");
[Link](2, 2);[Link](u[1][0]);
[Link](7, 2);[Link]("5=");
[Link](9, 2);[Link](u[1][1]);
[Link](14, 2);[Link]("6=");
[Link](16, 2);[Link](u[1][2]);

[Link](0, 3);[Link]("7=");
[Link](2, 3);[Link](u[2][0]);
[Link](7, 3);[Link]("8=");
[Link](9, 3);[Link](u[2][1]);
[Link](14, 3);[Link]("9=");
[Link](16, 3);[Link](u[2][2]);
}

//Fungsi menampilkan nilai hasil defuzzyfikasi ke LCD

void display_defuzzyfikasi()
{
[Link](0, 0);[Link]("er=");
[Link](3, 0);[Link](error);
[Link](9, 0);[Link]("d_er=");
[Link](14, 0);[Link](d_error);

[Link](0, 1);[Link]("Output =");

[Link](13, 1);[Link](beda_pwm);

[Link](0, 2);[Link]("Speed_Right=");
[Link](13, 2);[Link](speed_right);

[Link](0, 3);[Link]("Speed_Left =");

[Link](13, 3);[Link](speed_left);
}

5. Setelah program ditulis dan pastikan tidak ada program yang salah lakukan upload
program ke arduino dengan menghubungkan kabel data dari laptop ke arduino nano
kemudian mengatur menu bar Tools → Board : ”Arduino Nano” → Processor :
”Atmega328” → Port : ”Com (Menyesuaikan silahkan di cek di device manager)”
6. Setelah pengaturan board seperti di atas selesai dilakukan lakukan dengan klik
tombol upload.
7. Tunggu beberapa detik hingga program selesai dikirim, setelah program selesai di
kirim.
8. Ubahlah nilai error menjadi 5 dan nilai perubahan error menjadi 7 dengan
memutar potensiometer.

JOB SHEET KENDALI FUZZY LOGIC 66

 9. Tekan saklar ’fuzzyfikasi’ untuk menampilkan data derajat keanggotaan masing-
masing anggota variabel error dan perubahan error. Catat nilai error_negatif,
error_zero dan error_positif serta nilai D_error_negatif, D_error_zero dan
D_error_positif pada tabel 17.
10. Tekan saklar ’rule’ untuk menampilkan semua keluaran rule yaitu rule ke-1 hingga
rule ke-9. Catat nilai masing-masing keluaran rule pada tabel 17.
11. Tekan saklar ’defuzifikasi’ untuk menampilkan semua keluaran defuzifikasi yaitu
Output keluaran fuzzy, Speed Motor Right dan Speed Motor Left. Catat nilai
masing-masing keluaran defuzifikasi pada tabel 17.

Tabel 17. Hasil Pengamatan

Error : ... D_error_negatif D_error_zero D_error_positif
D error : ... ... ... ...
Error_Negatif Rule 1 Rule 2 Rule 3
... ... ... ...
Error_Zero Rule 4 Rule 5 Rule 6
... ... ... ...
Error_Positif Rule 7 Rule 8 Rule 9
... ... ... ...
Output Fuzzy ........
Speed Motor Right ........
Speed Motor Left ........

12. Ulangi langkah kerja 8 s.d. 11 untuk nilai error dan D_error sesuai tabel 18
kemudian catat hasilnya seperti pada tabel 17.

Tabel 18. Data Uji

No. Error D_error

1 6 15
2 3 7
3 2 6
4 1 5
5 0 4

13. Buatlah kesimpulan berdasarkan hasil praktik yang telah diperoleh.

H. Tugas
1. Bandingkan data hasil percobaan dengan perhitungan mencari output fuzzy secara
manual. Ambil dua sample nilai error dan perubahan error untuk dihitung.

JOB SHEET KENDALI FUZZY LOGIC 67

 FAKULTAS TEKNIK
UNIVERSITAS NEGERI YOGYAKARTA
JOB SHEET PRAKTIK SISTEM KENDALI CEDAS
Sem Ganjil / 04. Penerapan Logika Fuzzy pada
Genap Pengereman Kendaraan Otomatis 200 menit
SKL/EKA/EKA416/04 Revisi: 03 Tgl: 5/29/2018

04. Penerapan Logika Fuzzy pada Pengereman Kendaraan Otomatis

A. Tujuan
Setelah melakukan praktikum mahasiswa diharapkan :
1. Memahami proses fuzzyfikasi, proses evaluasi rule dan proses defuzzyfikasi pada
aplikasi pengeraman kendaraan otomatis
2. Mampu menerapkan sistem kendali cerdas fuzzy pada sebuah sistem pengeraman
kendaraan otomatis.

B. Teori Dasar
Logika Fuzzy pada pengereman kendaraan bermotor
Logika Fuzzy merupakan logika samar yang bernilai diantara 1 dan 0. Logika Fuzzy
sangat bermanfaat dalam sistem kontrol yang lebih fleksibel. Tidak hanya mengenal logika
biner 1 dan 0 akan tetapi diantaranya. Ada kalanya sebuah sistem kontrol tidak hanya
mengenal logika 1 dan 0 seperti halnya sistem pengereman kendaraan bermotor, 1 = rem
dan 0 tidak mengerem. Namun ada fase pengereman secara soft, medium dan hard.
Sehingga diperlukan metode pendekatan metode logika Fuzzy.
Pada aplikasi pengereman kendaraan bermotor input fuzzy adalah kecepatan dan
jarak kendaraan di depan. Dimana untuk kecepatan memiliki 3 membership function yaitu
pelan, sedang dan cepat. Sedangkan jarak antar dua kendaraaan memiliki 3 membership
function yaitu dekat, sedang, dan jauh. Sedangkan output memiliki membership function:
soft, medium, Hard. Grafik membership function nya dapat dilihat pada bagian fuzzyfikasi
dibawah ini.
Fuzzyfikasi
Pada percobaan kali ini akan dibahas tahapan proses fuzzyfikasi dua variable Input
yang diperoleh dari pengolahan sensor kecepatan motor dan sensor jarak. Pada bagian
Input terdapat 2 variabel yaitu variabel kecepatan motor dan variabel jarak. Linguistik
Variabel Kecepatan Motor mempunyai 3 buah linguistik value yaitu Pelan, Sedang dan
Cepat sedangkan untuk Linguistik Variabel Jarak mempunyai 3 buah linguistik value yaitu
Dekat, Sedang dan Jauh.

JOB SHEET KENDALI FUZZY LOGIC 68

1. Variabel Kecepatan Motor
Variabel kecepatan motor dibuat range skala kecepatan yaitu mulai 0 sampai dengan
50. Nilai ini diperoleh dari pembacaan sensor kecepatan, Potensiometer sebagai pengganti
pembacaan kecepatan motor yang menghasilkan nilai kecepatan motor. Gambar 45 ini
adalah nilai untuk masing-masing domain.

Gambar 45. Fungsi Keanggotaan Input kecepatan motor

2. Variabel Jarak
Variabel Jarak dibuat range pengukuran yaitu mulai 0cm sampai dengan 50cm. Nilai
Jarak ini diperoleh dari perhitungan sensor Jarak HC-SR04. Gambar 46 ini adalah grafik
untuk menentukan nilai masing-masing domain.

Gambar 46. Fungsi keanggotaan Input Jarak

Evaluasi Rule
Basis aturan (rule base) adalah sebuah aturan yang dibuat untuk menentukan Output
yang terjadi. Basis aturan yang digunakan dalam job ini ditunjukkan oleh tabel 19.

JOB SHEET KENDALI FUZZY LOGIC 69

 Tabel 19. Tabel Basis Aturan

Jarak→
Dekat Sedang Jauh
Speed ↓
Soft Soft Soft
Lambat
(R1) (R2) (R3)
Soft Med Med
Sedang
(R4) (R5) (R6)
Soft Med Fast
Cepat
(R7) (R8) (R9)

Berdasarkan tabel 19 dapat dirumuskan 9 aturan. Berikut ini aturan yang digunakan
pada perancangan alat ini.

1. If (Jarak : Dekat) and (Speed : Lambat) then (Motor : Soft)

2. If (Jarak : Sedang) and (Speed : Lambat) then (Motor : Soft)
3. If (Jarak : Jauh) and (Speed : Lambat) then (Motor : Soft)
4. If (Jarak : Dekat) and (Speed : Sedang) then (Motor : Soft)
5. If (Jarak : Sedang) and (Speed : Sedang) then (Motor : Med)
6. If (Jarak : Jauh) and (Speed : Sedang) then (Motor : Med)
7. If (Jarak : Dekat) and (Speed : Cepat) then (Motor : Soft)
8. If (Jarak : Sedang) and (Speed : Cepat) then (Motor : Med)
9. If (Jarak : Jauh) and (Speed : Cepat) then (Motor : Fast)

Selanjutnya menentukan aplikasi fungsi implikasi untuk setiap aturan. Karena

menggunakan Metode Mamdani, maka fungsi implikasi yang digunakan adalah fungsi MIN.
Dalam rule di atas menggunakan operator AND maka nilai keanggotaan terkecil yang
diambil dari himpunan yang bersangkutan.

µA ∩ µB = min(µA[x], µB[y])

Defuzzyfikasi
Pada metode ini, solusi crisp diperoleh dengan cara mengambil titik pusat daerah
fuzzy. Output fuzzy yang diharapkan disini adalah nilai perubahan kecepatan motor DC.
Nilai perubahan kecepatan motor DC akan digunakan dalam mempengaruhi derajat putaran
motor DC. Kecepatan motor berkisar antara 0-180 yang mana merupan nilai PWM yang
dihasilkan dari mikrokontroler. Awal proses defuzzyfikasi adalah mengolah data pada
variabel output. Variabel output disini adalah variabel Perubahan Kecepatan motor DC.
Variable ini mempunyai nilai antara 0 sampai dengan 180. Variabel Perubahan Kecepatan

JOB SHEET KENDALI FUZZY LOGIC 70

motor DC mempunyai 3 buah linguistik value yaitu Soft, Mid dan Hard. Gambar 47
merupakan gambar fungsi keanggotaan output perubahan kecepatan Motor DC.

Gambar 47. Fungsi keanggotaan Output Perubahan Kecepatan Motor DC

C. Alat dan Bahan

1. PC (Personal Computer) / Laptop
2. Media Pembelajaran Fuzzy Logic + Kabel Data + Kabel Penghubung
3. Software Arduino IDE

D. Keselamatan Kerja
1. Awali praktikum dengan berdoa.
2. Gunakanlah pakaian praktik pada saat praktikum.
3. Jauhkan peralatan yang tidak diperlukan dari meja kerja.
4. Bekerjalah dengan keadaan tanpa tegangan pada saat membuat dan mengubah
rangkaian.
5. Tanyakan kepada dosen pengampu atau staff pengajar ketika ada hal-hal yang
masih kurang paham.

E. Skema

Gambar 48. Diagram Blok Pengereman Kendaraan Otomatis dengan Logika Fuzzy

JOB SHEET KENDALI FUZZY LOGIC 71

 Gambar 49. Skematik Pengereman Kendaraan Otomatis dengan Logika Fuzzy

Tabel 20. Konfigurasi Pin Skematik

Pin Arduino Pin Trainer Pin Arduino Pin Trainer

LCD Driver Motor L293D
A4 SDA 2 IN1
A5 SCL 3 IN2
Push Button 6 EN1 (KANAN)
10 S1 4 IN3
11 S2 7 IN4
12 S3 5 EN2 (KIRI)
Ultrasonik Potensiometer
9 TRIG A0 TRIG
8 ECHO

JOB SHEET KENDALI FUZZY LOGIC 72

F. Langkah Kerja
1. Siapkan alat dan bahan yang dibutuhkan.
2. Buatlah rangkaian sesuai pada gambar 49 dan tabel 20 di atas dengan mengbungkan
pin Arduino nano dengan pin potensiometer, pin switch, pin sensor ultrasonic, pin
driver motor L298N dan pin LCD menggunakan kabel jumper.
3. Hidupkan PC/Laptop dan kemudian buka software Arduino IDE.
4. Ketikkan program seperti yang tertulis berikut ini pada software Arduino IDE.
//----------I2C LCD------------
//A4:SDA -- A5:SCL (pin configurasi)
#include <Wire.h> // Menyertakan Library Komunikasi
#include <LiquidCrystal_I2C.h> // Menyertakan Library I2C
LiquidCrystal_I2C lcd(0x27,20,4); // set I2C address ke 0x27

//inisialisasi motor kanan

#define IN1 2 //definisikan pin 2 dengan variabel IN2
#define IN2 3 //definisikan pin 3 dengan variabel IN3
#define pwm_kanan 6 //definisikan pin 6 dengan variabel pwm_kanan
//inisialisasi motor kiri
#define IN3 4 //definisikan pin 4 dengan variabel IN3
#define IN4 7 //definisikan pin 7 dengan variabel IN4
#define pwm_kiri 5 //definisikan pin 5 dengan variabel pwm_kiri

//variabel global
int i,j;
float SpeedADC,Speed;
float u_Speed[3],u_jarak[3],u[3][3],Speed_lambat, Speed_sedang, Speed_cepat,
jarak_dekat, jarak_sedang,jarak_jauh;
float kiri,validasi, pembilang, penyebut,
z1=67.5,z2=45,a1=45.5,a2=90,a3=135.5;//z = luas dan a = COA out;;

//SENSOR ULTRASONIK HC-SR04

#define echoPin 8 //definisikan pin 8 dengan variabel echoPin
#define trigPin 9 //definisikan pin 9 dengan variabel trigPin
long duration, distance;
float jarak;

void setup() {
[Link](); // inisialisasi LCD
[Link]();// nyalakan backlight

pinMode(trigPin, OUTPUT);//set variabel trigPin sebagai output

pinMode(echoPin, INPUT); //set variabel echoPin sebagai output

JOB SHEET KENDALI FUZZY LOGIC 73

 //inisialisasi pin untuk motor DC
pinMode(IN1, OUTPUT); //set variabel IN1 sebagai output
pinMode(IN2, OUTPUT); //set variabel IN2 sebagai output
pinMode(IN3, OUTPUT); //set variabel IN3 sebagai output
pinMode(IN4, OUTPUT); //set variabel IN4 sebagai output
pinMode(pwm_kanan, OUTPUT); //set variabel pwm_kanan sebagai output
pinMode(pwm_kiri, OUTPUT); //set variabel pwm_kiri sebagai output

//inisialisasi pin switch

pinMode(10, INPUT_PULLUP); //Set pin 8 sebagai input set high
pinMode(11, INPUT_PULLUP); //Set pin 9 sebagai input set high
pinMode(12, INPUT_PULLUP);//Set pin 10 sebagai input set high
}

void loop() {
fuzzyfikasi(); //memanggil & menjalankan fungsi fuzzifikasi
rule(); //memanggil & menjalankan fungsi evaluasi rule
defuzzyfikasi();//memanggil & menjalankan fungsi defuzzifikasi
int tombol_fuzzyfikasi = digitalRead(10); //baca nilai pin 8
int tombol_rule = digitalRead(11); //baca nilai pin 9
int tombol_defuzzyfikasi = digitalRead(12);//baca nilai pin 10

if(tombol_fuzzyfikasi==0 && tombol_rule==1 && tombol_defuzzyfikasi==1)

{display_fuzzyfikasi();} //menampilkan data proses fuzzyfikasi
if(tombol_fuzzyfikasi==1 && tombol_rule==0 && tombol_defuzzyfikasi==1)
{display_rule();} //menampilkan implikasi setiap rule
if(tombol_fuzzyfikasi==1 && tombol_rule==1 && tombol_defuzzyfikasi==0)
{display_defuzzyfikasi();}//menampilkan output tegas dan nilai kecepatan
motor kiri dan kanan
if(tombol_fuzzyfikasi==1 && tombol_rule==1 && tombol_defuzzyfikasi==1)
{[Link]();} //menghapus tampilan lcd
}

//Fungsi sensor ultrasonik

void sensorUltrasonic(int pinTrigger, int pinEcho)
{
digitalWrite(pinTrigger, LOW);
delayMicroseconds(2);
digitalWrite(pinTrigger, HIGH);
delayMicroseconds(10);
digitalWrite(pinTrigger, LOW);
duration = pulseIn(pinEcho, HIGH);
distance = (duration / 2) / 29.1;
delay(100);
}

JOB SHEET KENDALI FUZZY LOGIC 74

 void fuzzyfikasi_Speed()
{
SpeedADC = analogRead(A0); //baca data analog pada alamat A0 dan simpan di
variabel SpeedADC
Speed=SpeedADC/20;

//range untuk menentukan derajat keanggotaan speed

if(Speed >= 35)
{
u_Speed[0]=0;
u_Speed[1]=0;
u_Speed[2]=1;
}

else if(Speed >= 25)

{
u_Speed[0]=0;
u_Speed[1]=(35-Speed)/10;
u_Speed[2]=(Speed-25)/10;
}

else if(Speed >= 15)

{
u_Speed[0]=(25-Speed)/10;
u_Speed[1]=(Speed-15)/10;
u_Speed[2]=0;
}

else if(Speed < 15)

{
u_Speed[0]=1;
u_Speed[1]=0;
u_Speed[2]=0;
}

Speed_lambat = u_Speed[0]; //simpan nilai "u_speed[0]" ke fungsi

keanggotaan Speed_lambat
Speed_sedang = u_Speed[1]; //simpan nilai "u_speed[1]" ke fungsi
keanggotaan Speed_sedang
Speed_cepat = u_Speed[2]; //simpan nilai "u_speed[2]" ke fungsi
keanggotaan Speed_cepat
}

JOB SHEET KENDALI FUZZY LOGIC 75

 void fuzzyfikasi_jarak()
{
sensorUltrasonic(trigPin, echoPin); //pangil fungsi sensor ultrasonik
jarak = distance; //nilai distance kirik ke jarak

//range untuk menentukan derajat keanggotaan error jarak

if(jarak >= 35)
{
u_jarak[0]=0;
u_jarak[1]=0;
u_jarak[2]=1;
}

else if(jarak >=25 )

{
u_jarak[0]=0;
u_jarak[1]=(35-jarak)/10;
u_jarak[2]=(jarak-25)/10;
}

else if(jarak >= 15)

{
u_jarak[0]=(25-jarak)/10;
u_jarak[1]=(jarak-15)/10;
u_jarak[2]=0;
}

else if(jarak < 15)

{
u_jarak[0]=1;
u_jarak[1]=0;
u_jarak[2]=0;
}

jarak_dekat = u_jarak[0]; //simpan nilai "u_jarak[0]" ke fungsi

keanggotaan jarak_dekat
jarak_sedang = u_jarak[1]; //simpan nilai "u_jarak[1]" ke fungsi
keanggotaan jarak_sedang
jarak_jauh = u_jarak[2]; //simpan nilai "u_jarak[2]" ke fungsi
keanggotaan jarak_jauh
}

JOB SHEET KENDALI FUZZY LOGIC 76

 void fuzzyfikasi() //penggabungan fuzzyfikasi
{
fuzzyfikasi_jarak();
fuzzyfikasi_Speed();
}

void rule() // basis aturan

{
for(i=0;i<=2;i++) //looping jumlah keanggotaan
{
for(j=0;j<=2;j++) //looping jumlah keanggotaan
{
if(u_Speed[i]<u_jarak[j]) //mengecek nilai fungsi keanggotaan
{
u[i][j]=u_Speed[i]; // menggunakan operator AND
}
else
{
u[i][j]=u_jarak[j];
}
}
}
}

void defuzzyfikasi()
{
//menggunakan metode mamdani dan defuzzyfikasi meggunakan metode centroid
of area
pembilang
=(u[0][0]*a1*z1)+(u[0][1]*a1*z1)+(u[0][2]*a1*z1)+(u[1][0]*a1*z1)+(u[1][1]*a2*
z2)+(u[1][2]*a2*z2)+(u[2][0]*a1*z1)+(u[2][1]*a2*z2)+(u[2][2]*a3*z1);

penyebut
=(u[0][0]*z1)+(u[0][1]*z1)+(u[0][2]*z1)+(u[1][0]*z1)+(u[1][1]*z2)+(u[1][2]*z2
)+(u[2][0]*z1)+(u[2][1]*z2)+(u[2][2]*z1);

validasi=pembilang/penyebut; // perhitungan defuzzyfikasi dengan

menggabungkan seluruh nilai min yang sudah didapatkan
kiri=validasi+30;
//kirim data PWM ke motor kanan & kiri
analogWrite(pwm_kiri, kiri);
analogWrite(pwm_kanan, validasi);
//kiri maju
digitalWrite(IN3, LOW);
digitalWrite(IN4, HIGH);

JOB SHEET KENDALI FUZZY LOGIC 77

 //kanan maju
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
}

//Fungsi menampilkan nilai fuzzyfikasi ke LCD

void display_fuzzyfikasi()
{
[Link](0, 0);[Link]("Sped=");
[Link](5, 0);[Link](Speed);
[Link](9, 0);[Link]("|Jarak=");
[Link](16, 0);[Link](jarak);

[Link](0, 1);[Link]("lmb=");
[Link](4, 1);[Link](Speed_lambat);
[Link](9, 1);[Link]("dkt=");
[Link](14, 1);[Link](jarak_dekat);

[Link](0, 2);[Link]("sdg=");
[Link](4, 2);[Link](Speed_sedang);
[Link](9, 2);[Link]("sdg=");
[Link](14, 2);[Link](jarak_sedang);

[Link](0, 3);[Link]("cpt=");
[Link](4, 3);[Link](Speed_cepat);
[Link](9, 3);[Link]("jauh=");
[Link](14, 3);[Link](jarak_jauh);
}
//Fungsi menampilkan nilai rule ke LCD
void display_rule()
{
[Link](0, 0);[Link]("Sped=");
[Link](5, 0);[Link](Speed);
[Link](9, 0);[Link]("|Jarak=");
[Link](16, 0);[Link](jarak);

[Link](0, 1);[Link]("1=");
[Link](2, 1);[Link](u[0][0]);
[Link](7, 1);[Link]("2=");
[Link](9, 1);[Link](u[0][1]);
[Link](14, 1);[Link]("3=");
[Link](16, 1);[Link](u[0][2]);

[Link](0, 2);[Link]("4=");
[Link](2, 2);[Link](u[1][0]);

JOB SHEET KENDALI FUZZY LOGIC 78

 [Link](7, 2);[Link]("5=");
[Link](9, 2);[Link](u[1][1]);
[Link](14, 2);[Link]("6=");
[Link](16, 2);[Link](u[1][2]);

[Link](0, 3);[Link]("7=");
[Link](2, 3);[Link](u[2][0]);
[Link](7, 3);[Link]("8=");
[Link](9, 3);[Link](u[2][1]);
[Link](14, 3);[Link]("9=");
[Link](16, 3);[Link](u[2][2]);
}
//Fungsi menampilkan nilai hasil defuzzyfikasi ke LCD
void display_defuzzyfikasi()
{
[Link](0, 0);[Link]("Speed=");
[Link](5, 0);[Link](Speed);
[Link](9, 0);[Link]("|Jarak=");
[Link](16, 0);[Link](jarak);
[Link](0, 1);[Link]("Output =");
[Link](13, 1);[Link](validasi);
[Link](0, 2);[Link](" ");
}

5. Setelah program ditulis dan pastikan tidak ada program yang salah lakukan upload
program ke arduino dengan menghubungkan kabel data dari laptop ke arduino nano
kemudian mengatur menu bar Tools → Board : ”Arduino Nano” → Processor :
”Atmega328” → Port : ”Com (Menyesuaikan silahkan di cek di device manager)”
6. Setelah pengaturan board seperti di atas selesai dilakukan lakukan dengan klik
tombol upload.
7. Tunggu beberapa detik hingga program selesai dikirim, setelah program selesai di
kirim.
8. Ubahlah nilai sensor Jarak menjadi 20cm dan nilai sensor Speed menjadi 35.
9. Tekan saklar ’fuzzyfikasi’ untuk menampilkan data derajat keanggotaan masing-
masing anggota sensor kecepatan dan sensor jarak. Catat nilai variabel sensor
kecepatan yaitu lambat, normal dan cepat serta nilai variabel sensor jarak yaitu
dekat,sedang dan jauh pada tabel 21.
10. Tekan saklar ’rule’ untuk menampilkan semua keluaran rule yaitu rule ke-1 hingga
rule ke-9. Catat nilai masing-masing keluaran rule pada tabel 21.

JOB SHEET KENDALI FUZZY LOGIC 79

 11. Tekan saklar ’defuzifikasi’ untuk menampilkan semua keluaran defuzifikasi yaitu
Output keluaran fuzzy, Speed Motor Right dan Speed Motor Left. Catat nilai
masing-masing keluaran defuzifikasi pada tabel 21.

Tabel 21. Hasil Pengamatan

Jarak : ... Dekat Sedang Jauh
Speed : ... ... ... ...
Lambat Rule 1 Rule 2 Rule 3
... ... ... ...
Sedang Rule 4 Rule 5 Rule 6
... ... ... ...
Cepat Rule 7 Rule 8 Rule 9
... ... ... ...
Output Fuzzy Motor ........

12. Ulangi langkah kerja 8 s.d. 11 untuk nilai error dan D_error sesuai tabel 22
kemudian catat hasilnya seperti pada tabel 21.

Tabel 22. Data Uji

No. Speed Jarak

1 5 13
2 10 19
3 15 15
4 25 63
5 30 20

13. Buatlah kesimpulan berdasarkan hasil praktik yang telah diperoleh.

G. Tugas
1. Bandingkan data hasil percobaan dengan perhitungan secara langsung masing-
masing nilai derajat keanggotaan dari anggota variabel jarak dan kecepatan.
2. Buatlah Flowchart Fuzzyfikasi Variabel jarak dan kecepatan.
3. Bandingkan data hasil percobaan dengan perhitungan secara langsung masing-
masing keluaran rule untuk nilai jarak dan kecepatan sesuai data pengujian. Ambil
dua sampel nilai jarak dan kecepatan untuk dihitung.
4. Buatlah Flowchart Aturan Fuzzy.
5. Bandingkan data hasil percobaan dengan perhitungan mencari output fuzzy secara
manual. Ambil dua sample nilai jarak dan kecepatan untuk dihitung.

JOB SHEET KENDALI FUZZY LOGIC 80

 FAKULTAS TEKNIK
UNIVERSITAS NEGERI YOGYAKARTA
JOB SHEET PRAKTIK SISTEM KENDALI CEDAS
Sem Ganjil / 05. Penerapan Logika Fuzzy pada Tirai Otomatis
200
Genap (Menggunakan Library Fuzzy)
Menit
SKL/EKA/EKA416/05 Revisi: 03 Tgl: 5/29/2018

05. Penerapan Logika Fuzzy pada Tirai Otomatis

(Menggunakan Library Fuzzy)
A. Tujuan
Setelah melakukan praktikum mahasiswa diharapkan :
1. Memahami dan mampu menggunakan library fuzzy untuk memprogram tirai
otomatis.

B. Teori Dasar
Pada praktikum sebelumnya yaitu pada job 1, 2, 3 dan 4 telah dipraktikan penerapan
logika fuzzy menggunakan program Arduino IDE secara manual dan bantuan matlab.
Pembuatan program tersebut masih dibuat secara manual dengan membuat perhitungan,
rumus dan programnya. Pada praktikum kali ini akan dipraktikan membuat program logika
fuzzy dengan bantuan library fuzzy yang bernama eFLL (Embedded Fuzzy Logic Library).
Pengunaan library ini diharapkan dapat mempermudah dan mempercepat dalam
perancangan program fuzzy sehingga dapat terciptanya keeffektifan.
Tirai otomatis ini bekerja berdasarkan intensitas cahaya yang masuk. Jika cahaya
yang di terima terang maka tirai akan tertutup, jika cahaya sedang maka tirai akan terbuka
setengah dan jika cahaya yang di terima gelap maka tirai akan terbuka.
eFLL (Embedded Fuzzy Logic Library)
eFLL (Embedded Fuzzy Logic Library) adalah library atau pustaka standar yang di
buat untuk Embedded Systems tipe arduino board dan software Arduino IDE agar para
praktikan di permudah dalam mengimplementasikan Sistem Fuzzy sehingga mampu
membuat sebuah program atau alat yang efisien. Libaray fuzzy ini di kembangkan oleh
Robotic Research Group (RRG) di perpustakaan Universitas Negeri Piauí (UESPI-Teresina).
Library eFLL (Embedded Fuzzy Logic Library) adalah pilihan serbaguna, ringan dan efisien
untuk bekerja dengan Fuzzy Logic dalam sistem embedded.
Rancangan fuzzy inference sistem yang digunakan pada praktikum kali ini terdiri dari
input yang berasal dari sensor cahaya sedangkan untuk outputnya menggunakan motor
servo. Input dari sensor cahaya memiliki tiga buah fungsi keanggotaan yaitu gelap, sedang
dan terang. Sedangkan untuk rule terdapat tiga buah rule yang dapat disaksikan di bawah
ini. Output nya yang menggunakan motor servo juga memiliki tiga buah fungsi keangotaan.

JOB SHEET KENDALI FUZZY LOGIC 81

 Gambar 50. Rancangan FIS Fuzzy pada Tirai Otomatis

Gambar 51. Membership Function Input Sensor Cahaya

Tabel 23. Tabel Evaluasi Rule Tirai Otomatis

Rule Kondisi Cahaya Out Motor Servo
R1 Gelap Besar
R2 Sedanng Sedang
R3 Terang Kecil

Gambar 52. Membership Function Output Motor Servo

JOB SHEET KENDALI FUZZY LOGIC 82

C. Alat dan Bahan
1. PC (Personal Computer) / Laptop
2. Media Pembelajaran Fuzzy Logic + Kabel Data + Kabel Penghubung
3. Software Arduino IDE

D. Keselamatan Kerja
1. Awali praktikum dengan berdoa.
2. Gunakanlah pakaian praktik pada saat praktikum.
3. Jauhkan peralatan yang tidak diperlukan dari meja kerja.
4. Bekerjalah dengan keadaan tanpa tegangan pada saat membuat dan mengubah
rangkaian.
5. Tanyakan kepada dosen pengampu atau staff pengajar ketika ada hal-hal yang
masih kurang paham.

E. Skema

Gambar 53. Skematik Tirai Otomatis dengan Library Fuzzy

JOB SHEET KENDALI FUZZY LOGIC 83

 Tabel 24. Konfigurasi Pin Skematik

Pin Arduino Pin Trainer Pin Arduino Pin Trainer

LCD Motor Servo
A4 SDA 2 SERVO
A5 SCL LDR
A0 LLDR

F. Langkah Kerja
1. Siapkan alat dan bahan yang dibutuhkan.
2. Buatlah rangkaian sesuai pada gambar 53 dan tabel 24 di atas dengan mengbungkan
pin Arduino nano dengan pin sensor cahaya, pin motor servo dan pin LCD
menggunakan kabel jumper.
3. Hidupkan PC/Laptop dan kemudian buka software Arduino IDE.
4. Instal library fuzzy yang dapat di download di link [Link]
cari file “[Link]” kemudian klik download.
5. Setelah libary berhasil di install, ketikkan program seperti yang tertulis berikut ini
pada software Arduino IDE.

//----------I2C LCD------------
#include <Wire.h> // Menyertakan Library Komunikasi
#include <LiquidCrystal_I2C.h> // Menyertakan Library I2C
LiquidCrystal_I2C lcd(0x27,20,4); // set I2C address ke 0x27

//menyertakan pustaka fungsi libaray Fuzzy

#include <FuzzyRule.h>
#include <FuzzyComposition.h>
#include <Fuzzy.h>
#include <FuzzyRuleConsequent.h>
#include <FuzzyOutput.h>
#include <FuzzyInput.h>
#include <FuzzyIO.h>
#include <FuzzySet.h>
#include <FuzzyRuleAntecedent.h>

// Step 1 - Instantiating an object library

Fuzzy*fuzzy=new Fuzzy(); //perkalian variabel Fuzzy dgn fuzzy akan
menghasilkan variabel baru fuzzy

float cahayaadc,cahaya; //deklarasi variabel sensor cahaya

//deklarasi library fuzzy dan variabel

#include <Servo.h>
Servo myservo;

void setup() {
[Link](); // inisialisasi LCD
[Link]();// nyalakan backlight

JOB SHEET KENDALI FUZZY LOGIC 84

 [Link](2); //set pin servo pada pin 2

// Step 2 - Creating a FuzzyInput cahaya

//variabel input dimana masukannya berupa cahaya dari sensor terang
(LDR)
FuzzyInput*cahaya=new FuzzyInput(1); //deklaarasi variabel INPUT

// Creating the FuzzySet to compond FuzzyInput cahaya

FuzzySet*gelap=new FuzzySet(0,0,15,25); //pengaturan nilai pada aturan
gelap
cahaya->addFuzzySet(gelap); //nilai gelap dibaca jika
berada pd nilai 0-15
FuzzySet*normal=new FuzzySet(15,25,25,35);//pengaturan nilai pada aturan
normal
cahaya->addFuzzySet(normal); //nilai normal dibaca jika
berada pd nilai 15-25
FuzzySet*terang=new FuzzySet(25,35,50,50);//pengaturan nilai pada aturan
terang
cahaya->addFuzzySet(terang); //nilai terang dibaca jika
berada pd nilai 25-50

fuzzy->addFuzzyInput(cahaya); // Add FuzzyInput to Fuzzy object

FuzzyOutput*motor=new FuzzyOutput(1); //deklarasi variabel OUTPUT

FuzzySet*kecil=new FuzzySet(0,0,45,90); //pengaturan nilai pada

aturan kecil (output)
motor->addFuzzySet(kecil); //nilai kecil dibaca jika
berada pd nilai 0-45
FuzzySet*sedang=new FuzzySet(45,90,90,135);//pengaturan nilai pada
aturan sedanng (output)
motor->addFuzzySet(sedang); //nilai sedang dibaca jika
berada pd nilai 45-90
FuzzySet*besar=new FuzzySet(90,135,180,180);//pengaturan nilai pada
aturan besar (output)
motor->addFuzzySet(besar); //nilai besar dibaca jika
berada pd nilai 90-180

fuzzy->addFuzzyOutput(motor);
//------------jika cahaya adalah gelap maka motor besar
FuzzyRuleAntecedent*ifcahayagelap=new FuzzyRuleAntecedent();
ifcahayagelap->joinSingle(gelap);
FuzzyRuleConsequent*thenMotorbesar=new FuzzyRuleConsequent();
thenMotorbesar->addOutput(besar);
FuzzyRule*fuzzyRule01=new FuzzyRule(1, ifcahayagelap,thenMotorbesar);
fuzzy->addFuzzyRule(fuzzyRule01);

//------------jika cahaya adalah sedang maka motor sedang

FuzzyRuleAntecedent*ifcahayanormal=new FuzzyRuleAntecedent();
ifcahayanormal->joinSingle(normal);
FuzzyRuleConsequent*thenMotorsedang=new FuzzyRuleConsequent();
thenMotorsedang->addOutput(sedang);
FuzzyRule*fuzzyRule02=new FuzzyRule(2, ifcahayanormal,thenMotorsedang);
fuzzy->addFuzzyRule(fuzzyRule02);

//------------jika cahaya adalah terang maka motor kecil

FuzzyRuleAntecedent*ifcahayaterang=new FuzzyRuleAntecedent();
ifcahayaterang->joinSingle(terang);
FuzzyRuleConsequent*thenMotorkecil=new FuzzyRuleConsequent();

JOB SHEET KENDALI FUZZY LOGIC 85

 thenMotorkecil->addOutput(kecil);
FuzzyRule*fuzzyRule03=new FuzzyRule(3,ifcahayaterang,thenMotorkecil);
fuzzy->addFuzzyRule(fuzzyRule03);
}

void loop() {

fuzzy->setInput(1,cahaya); //set input

fuzzy->fuzzify(); //defuzzifikasi
float output=fuzzy->defuzzify(1);
float servo;
cahayaadc = analogRead(A0); //baca data ADC pada pin A0
cahaya=cahayaadc/20;

//cetak di LCD nilai2 fuzzy

[Link](2, 0);[Link]("-Tirai Otomatis-");
[Link](0, 1);[Link]("Cahaya= (0-50)");
[Link](7, 1);[Link](cahaya);
[Link](0, 2);[Link]("Out Servo=");
[Link](10, 2);[Link](output);

//keluaran nilai fuzzy ke servo

servo=output+30;
[Link](servo);
delay(500);
}

6. Setelah program ditulis dan pastikan tidak ada program yang salah lakukan upload
program ke arduino dengan menghubungkan kabel data dari laptop ke arduino nano
kemudian mengatur menu bar Tools → Board : ”Arduino Nano” → Processor :
”Atmega328” → Port : ”Com (Menyesuaikan silahkan di cek di device manager)”
7. Setelah pengaturan board seperti di atas selesai dilakukan lakukan dengan klik
tombol upload.
8. Tunggu beberapa detik hingga program selesai dikirim, setelah program selesai di
kirim.
9. Ubahlah data nilai sensor cahaya menjadi 10. Kemudian catat hasil keluaran fuzzy
pada tabel 25 di bawah ini.
10. Kemudian bandingkan hasil fuzzy ini dengan mengunakan Matlab. Gunakan data
berdasarakan tabel 25 di bawah ini.

JOB SHEET KENDALI FUZZY LOGIC 86

 Tabel 25. Hasil Pengamatan
No. Cahaya Output dengan Output dengan
Library Fuzzy Matlab
1 10
2 13
3 19
4 15
5 63
6 20
7 7
8 51
9 45
10 30
11 23

11. Buatlah kesimpulan berdasarkan hasil praktik yang telah diperoleh.

G. Tugas
1. Berikan pendapat anda setelah menggunakan library fuzzy di bandingkan dengan
Program Arduino sebelumnya tanpa menggunakan library fuzzy.
2. Buatlah sistem fuzzy dengan menggunakan library fuzzy dengan menggunakan 2
input (variasi pengunaan sensor bebas) dengan 1 buah output bebas.

JOB SHEET KENDALI FUZZY LOGIC 87

 FAKULTAS TEKNIK
UNIVERSITAS NEGERI YOGYAKARTA
JOB SHEET PRAKTIK SISTEM KENDALI CEDAS
06. Penerapan Logika Fuzzy Pada Kipas
Sem Ganjil /
Genap
Angin Cerdas 200
(Menggunakan Make Proto) Menit
SKL/EKA/EKA416/06 Revisi: 03 Tgl: 5/29/2018

06. Penerapan Logika Fuzzy pada kipas angin cerdas

(Menggunakan Make Proto)
A. Tujuan
Setelah melakukan praktikum mahasiswa diharapkan :
1. Mampu menggunakan MakeProto untuk mempermudah dalam pembuatan program
logika fuzzy untuk kipas angin cerdas.

B. Teori Dasar
Make Proto
MakeProto adalah sebuah website yang beralamat
[Link] yang
mampu mengubah file dengan ekstensi (.FIS) dari matlab menjadi file program arduino
dengan ekstensi (.INO). Dengan adanya website ini pembuatan program untuk
implementasi fuzzy menjadi lebih mudah dan cepat karena kita cukup hanya membuat file
FIS dengan menggunkan matlab setelah itu file FIS tersebut di upload ke dalam sistem
MakeProto. Setelah di upload di sistem MakeProto maka dengan mengkilik tombol convert
maka program Arduino (.INO) sudah dibuatkan. Namun file program Arduino tersebut perlu
kita sesuaikan dengan alamat input dan output yang akan kita gunakan di dalam sistem
sebelum di upload ke Arduino board dan program siap di implementasikan pada alat.

Kipas Angin Cerdas

Praktikum kali ini akan membahas perancangan sebuah aplikasi dengan menggunakan
logika fuzzy dan mikrokontroler Arduino nano yang dapat berguna sebagai alat untuk
mengaktifkan atau menonaktifkan kipas angin pada suatu ruangan juga mengatur
kecepatan motor kipas berdasarkan suhu ruangan dan jarak dengan pengguna kipas.
Perancangan sistem ini dilengkapi dengan beberapa perangkat keras yaitu sebuah
motor DC, sensor jarak (ultrasonic HC-SR04), sensor suhu (DHT11), Arduino Uno dan
rangkaian driver motor. Rancangan dari sistem ini digunakan untuk mengatur putaran kipas
angin yang disesuaikan dengan temperatur dan jarak dari suatu objek. Adapun diagram
hardware nya sebagai berikut :

JOB SHEET KENDALI FUZZY LOGIC 88

 Gambar 54. Diagram Perangkat Keras Kipas Angin Cerdas

C. Alat dan Bahan

1. PC (Personal Computer) / Laptop
2. Media Pembelajaran Fuzzy Logic + Kabel Data + Kabel Penghubung
3. Software Arduino IDE
4. Web Browser + Make Proto

D. Keselamatan Kerja
1. Awali praktikum dengan berdoa.
2. Gunakanlah pakaian praktik pada saat praktikum.
3. Jauhkan peralatan yang tidak diperlukan dari meja kerja.
4. Bekerjalah dengan keadaan tanpa tegangan pada saat membuat dan mengubah
rangkaian.
5. Tanyakan kepada dosen pengampu atau staff pengajar ketika ada hal-hal yang
masih kurang paham.

JOB SHEET KENDALI FUZZY LOGIC 89

E. Skema

Gambar 55. Skematik Kipas Angin Cerdas

Tabel 26. Konfigurasi Pin Skematik

Pin Arduino Pin Trainer Pin Arduino Pin Trainer

LCD Driver Motor L293D
A4 SDA 2 IN1
A5 SCL 3 IN2
Sensor Suhu DHT11 6 EN1 (KANAN)
A2 SUHU Sensor Ultrasonik
9 TRIG
8 ECHO

F. Langkah Kerja
1. Siapkan alat dan bahan yang dibutuhkan.
2. Buatlah rangkaian sesuai pada gambar 55 Ddan tabel 26 di atas dengan
mengbungkan pin Arduino nano dengan pin sensor ultrasonik, pin sensor suhu
DHT11, pin driver motor L298D dan pin LCD menggunakan kabel jumper.

JOB SHEET KENDALI FUZZY LOGIC 90

 3. Hidupkan PC/Laptop dan kemudian buka software Matlab kemudian buatlah FIS
dengan ketentuan sebagai berikut :

Gambar 56. FIS (Fuzzy Inference System) untuk Kipas Angin Cerdas

Gambar 57. Membership Function Input Jarak

Gambar 58. Membership Function Input Suhu

JOB SHEET KENDALI FUZZY LOGIC 91

 Tabel 27. Basis Aturan Kipas Angin Cerdas
Jarak →
Suhu ↓ Dekat Sedang Jauh

Lambat Lambat Sedang

Dingin
(R1) (R2) (R3)
Lambat Sedang Cepat
Hangat
(R4) (R5) (R6)
Sedang Cepat Cepat
Panas
(R7) (R8) (R9)

Gambar 59. Membership Function Output Kipas

4. Setelah file FIS sudah di buat berdasarkan langkah di atas simpan lah file FIS anda.
5. Bukalah link website MakeProto dibawah ini:
[Link]
6. Setelah website terbuka, perhatikan dan ikutilah langkah-langkah yang ada pada
gambar di bawah ini:
1) Upload file FIS anda dengan klik tombol telusuri, cari file FIS yang telah anda
buat kemudian klik Open.
2) Setelah file berhasil terupload kemudian klik Convert.

JOB SHEET KENDALI FUZZY LOGIC 92

 Gambar 60. Langkah Upload dan Convert File FIS Ke File Arduino

7. Setelah klik tombol convert jika berhasil maka akan muncul gambar sebagai berkut:

Gambar 61. File Konversi Siap Download

8. Klik tombol Download fisRiset_Suh.zip

9. Setelah di download kemudian ekstrak dan buka file ”Download fisRiset_Suh.zip”.
Buka file ”fisRiset_Suh.INO” kemudian tambahkan program yang di bold di bawah
ini :

//***********************************************************************
// Matlab .fis to arduino C converter v2.0.1.25122016
// - Karthik Nadig, USA
// Please report bugs to:
// [Link]
// If you don't have a GitHub account mail to karthiknadig@[Link]
//***********************************************************************
#include "fis_header.h" //masukan libarry fuzzy

JOB SHEET KENDALI FUZZY LOGIC 93

 // Number of inputs to the fuzzy inference system
const int fis_gcI = 2;
// Number of outputs to the fuzzy inference system
const int fis_gcO = 1;
// Number of rules to the fuzzy inference system
const int fis_gcR = 9;

FIS_TYPE g_fisInput[fis_gcI]; //deklarasi FIS Input

FIS_TYPE g_fisOutput[fis_gcO];//deklarasi FIS Output

//SENSOR ULTRASONIK HC-SR04

#define echoPin 5 //definisikan pin 8 dengan variabel echoPin
#define trigPin 4 //definisikan pin 9 dengan variabel trigPin
long duration, distance;
float jarak;

//DHT 11 SENSOR SUHU

#include "DHT.h" //Sertakan library DHT
#define DHTPIN A2 //Pin apa yang digunakan
#define DHTTYPE DHT11 // DHT 11
DHT dht(DHTPIN, DHTTYPE);
float h,suhu;

//inisialisasi motor kanan

#define IN1 2 //definisikan pin 2 dengan variabel IN2
#define IN2 3 //definisikan pin 3 dengan variabel IN3
#define pwm_kanan 6 //definisikan pin 6 dengan variabel pwm_kanan

//----------I2C LCD------------
//A4:SDA -- A5:SCL (pin configurasi)
#include <Wire.h> // Menyertakan Library Komunikasi
#include <LiquidCrystal_I2C.h> // Menyertakan Library I2C
LiquidCrystal_I2C lcd(0x27,20,4); // set I2C address ke 0x27

// Setup routine runs once when you press reset:

void setup()
{
[Link](); // inisialisasi LCD
[Link](); // nyalakan backlight

[Link](); //mulai DHT

//inisialiasi sensor ultrasonik

pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);

JOB SHEET KENDALI FUZZY LOGIC 94

 // initialize the Analog for output motor.
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(pwm_kanan, OUTPUT);
}

// Loop routine runs over and over again forever:

void loop()
{
//transfer variabel jarak
sensorUltrasonic(trigPin, echoPin);
jarak = distance;

//transfer variabel suhu

h = [Link]();
suhu = [Link]();

// Read Input: Jarak

g_fisInput[0] = jarak;
// Read Input: Suhu
g_fisInput[1] = suhu;

//fungsi output
g_fisOutput[0] = 0;
fis_evaluate();

// Set output vlaue: Kipas

digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
analogWrite(pwm_kanan, g_fisOutput[0]);

//Cetak hasil fuzzy ke LCD

[Link](0, 0);[Link]("Fuzzy with MakeProto");
[Link](0, 1);[Link]("Suhu =");
[Link](7, 1);[Link](g_fisInput[1]);
[Link](0, 2);[Link]("Jarak =");
[Link](7, 2);[Link](jarak);
[Link](0, 3);[Link]("Output=");
[Link](7, 3);[Link](g_fisOutput[0]);
}

JOB SHEET KENDALI FUZZY LOGIC 95

 //Fungsi sensor ultrasonik
void sensorUltrasonic(int pinTrigger, int pinEcho)
{
digitalWrite(pinTrigger, LOW);
delayMicroseconds(2);
digitalWrite(pinTrigger, HIGH);
delayMicroseconds(10);
digitalWrite(pinTrigger, LOW);
duration = pulseIn(pinEcho, HIGH);
distance = (duration / 2) / 29.1;
delay(100);
}

//***********************************************************************
// Support functions for Fuzzy Inference System
//***********************************************************************
// Trapezoidal Member Function
FIS_TYPE fis_trapmf(FIS_TYPE x, FIS_TYPE* p)
{
FIS_TYPE a = p[0], b = p[1], c = p[2], d = p[3];
FIS_TYPE t1 = ((x <= c) ? 1 : ((d < x) ? 0 : ((c != d) ? ((d - x) / (d -
c)) : 0)));
FIS_TYPE t2 = ((b <= x) ? 1 : ((x < a) ? 0 : ((a != b) ? ((x - a) / (b -
a)) : 0)));
return (FIS_TYPE) min(t1, t2);
}

// Triangular Member Function

FIS_TYPE fis_trimf(FIS_TYPE x, FIS_TYPE* p)
{
FIS_TYPE a = p[0], b = p[1], c = p[2];
FIS_TYPE t1 = (x - a) / (b - a);
FIS_TYPE t2 = (c - x) / (c - b);
if ((a == b) && (b == c)) return (FIS_TYPE) (x == a);
if (a == b) return (FIS_TYPE) (t2*(b <= x)*(x <= c));
if (b == c) return (FIS_TYPE) (t1*(a <= x)*(x <= b));
t1 = min(t1, t2);
return (FIS_TYPE) max(t1, 0);
}

FIS_TYPE fis_min(FIS_TYPE a, FIS_TYPE b)

{
return min(a, b);
}
FIS_TYPE fis_max(FIS_TYPE a, FIS_TYPE b)

JOB SHEET KENDALI FUZZY LOGIC 96

 {
return max(a, b);
}

FIS_TYPE fis_array_operation(FIS_TYPE *array, int size, _FIS_ARR_OP pfnOp)

{
int i;
FIS_TYPE ret = 0;

if (size == 0) return ret;

if (size == 1) return array[0];

ret = array[0];
for (i = 1; i < size; i++)
{
ret = (*pfnOp)(ret, array[i]);
}

return ret;
}

//***********************************************************************
// Data for Fuzzy Inference System
//***********************************************************************
// Pointers to the implementations of member functions
_FIS_MF fis_gMF[] =
{
fis_trapmf, fis_trimf
};

// Count of member function for each Input

int fis_gIMFCount[] = { 3, 3 };

// Count of member function for each Output

int fis_gOMFCount[] = { 3 };

// Coefficients for the Input Member Functions

FIS_TYPE fis_gMFI0Coeff1[] = { 0, 0, 15, 25 };
FIS_TYPE fis_gMFI0Coeff2[] = { 15, 25, 35 };
FIS_TYPE fis_gMFI0Coeff3[] = { 25, 35, 50, 50 };
FIS_TYPE* fis_gMFI0Coeff[] = { fis_gMFI0Coeff1, fis_gMFI0Coeff2,
fis_gMFI0Coeff3 };
FIS_TYPE fis_gMFI1Coeff1[] = { 20, 25, 30, 35 };
FIS_TYPE fis_gMFI1Coeff2[] = { 30, 35, 40 };
FIS_TYPE fis_gMFI1Coeff3[] = { 35, 40, 50, 60 };

JOB SHEET KENDALI FUZZY LOGIC 97

 FIS_TYPE* fis_gMFI1Coeff[] = { fis_gMFI1Coeff1, fis_gMFI1Coeff2,
fis_gMFI1Coeff3 };
FIS_TYPE** fis_gMFICoeff[] = { fis_gMFI0Coeff, fis_gMFI1Coeff };

// Coefficients for the Output Member Functions

FIS_TYPE fis_gMFO0Coeff1[] = { 0, 0, 45, 90 };
FIS_TYPE fis_gMFO0Coeff2[] = { 45, 90, 135 };
FIS_TYPE fis_gMFO0Coeff3[] = { 90, 135, 180, 180 };
FIS_TYPE* fis_gMFO0Coeff[] = { fis_gMFO0Coeff1, fis_gMFO0Coeff2,
fis_gMFO0Coeff3 };
FIS_TYPE** fis_gMFOCoeff[] = { fis_gMFO0Coeff };

// Input membership function set

int fis_gMFI0[] = { 0, 1, 0 };
int fis_gMFI1[] = { 0, 1, 0 };
int* fis_gMFI[] = { fis_gMFI0, fis_gMFI1};

// Output membership function set

int fis_gMFO0[] = { 0, 1, 0 };
int* fis_gMFO[] = { fis_gMFO0};

// Rule Weights
FIS_TYPE fis_gRWeight[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };

// Rule Type
int fis_gRType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };

// Rule Inputs
int fis_gRI0[] = { 1, 1 };
int fis_gRI1[] = { 2, 1 };
int fis_gRI2[] = { 3, 1 };
int fis_gRI3[] = { 1, 2 };
int fis_gRI4[] = { 2, 2 };
int fis_gRI5[] = { 3, 2 };
int fis_gRI6[] = { 1, 3 };
int fis_gRI7[] = { 2, 3 };
int fis_gRI8[] = { 3, 3 };
int* fis_gRI[] = { fis_gRI0, fis_gRI1, fis_gRI2, fis_gRI3, fis_gRI4,
fis_gRI5, fis_gRI6, fis_gRI7, fis_gRI8 };

// Rule Outputs
int fis_gRO0[] = { 1 };
int fis_gRO1[] = { 1 };
int fis_gRO2[] = { 2 };

JOB SHEET KENDALI FUZZY LOGIC 98

 int fis_gRO3[] = { 1 };
int fis_gRO4[] = { 2 };
int fis_gRO5[] = { 3 };
int fis_gRO6[] = { 2 };
int fis_gRO7[] = { 3 };
int fis_gRO8[] = { 3 };
int* fis_gRO[] = { fis_gRO0, fis_gRO1, fis_gRO2, fis_gRO3, fis_gRO4,
fis_gRO5, fis_gRO6, fis_gRO7, fis_gRO8 };

// Input range Min

FIS_TYPE fis_gIMin[] = { 0, 25 };

// Input range Max

FIS_TYPE fis_gIMax[] = { 50, 50 };

// Output range Min

FIS_TYPE fis_gOMin[] = { 0 };

// Output range Max

FIS_TYPE fis_gOMax[] = { 180 };

//***********************************************************************
// Data dependent support functions for Fuzzy Inference System
//***********************************************************************
FIS_TYPE fis_MF_out(FIS_TYPE** fuzzyRuleSet, FIS_TYPE x, int o)
{
FIS_TYPE mfOut;
int r;

for (r = 0; r < fis_gcR; ++r)

{
int index = fis_gRO[r][o];
if (index > 0)
{
index = index - 1;
mfOut = (fis_gMF[fis_gMFO[o][index]])(x,
fis_gMFOCoeff[o][index]);
}
else if (index < 0)
{
index = -index - 1;
mfOut = 1 - (fis_gMF[fis_gMFO[o][index]])(x,
fis_gMFOCoeff[o][index]);
}
else

JOB SHEET KENDALI FUZZY LOGIC 99

 {
mfOut = 0;
}

fuzzyRuleSet[0][r] = fis_min(mfOut, fuzzyRuleSet[1][r]);

}
return fis_array_operation(fuzzyRuleSet[0], fis_gcR, fis_max);
}

FIS_TYPE fis_defuzz_centroid(FIS_TYPE** fuzzyRuleSet, int o)

{
FIS_TYPE step = (fis_gOMax[o] - fis_gOMin[o]) / (FIS_RESOLUSION - 1);
FIS_TYPE area = 0;
FIS_TYPE momentum = 0;
FIS_TYPE dist, slice;
int i;

// calculate the area under the curve formed by the MF outputs

for (i = 0; i < FIS_RESOLUSION; ++i){
dist = fis_gOMin[o] + (step * i);
slice = step * fis_MF_out(fuzzyRuleSet, dist, o);
area += slice;
momentum += slice*dist;
}

return ((area == 0) ? ((fis_gOMax[o] + fis_gOMin[o]) / 2) : (momentum /

area));
}

//***********************************************************************
// Fuzzy Inference System
//***********************************************************************
void fis_evaluate()
{
FIS_TYPE fuzzyInput0[] = { 0, 0, 0 };
FIS_TYPE fuzzyInput1[] = { 0, 0, 0 };
FIS_TYPE* fuzzyInput[fis_gcI] = { fuzzyInput0, fuzzyInput1, };
FIS_TYPE fuzzyOutput0[] = { 0, 0, 0 };
FIS_TYPE* fuzzyOutput[fis_gcO] = { fuzzyOutput0, };
FIS_TYPE fuzzyRules[fis_gcR] = { 0 };
FIS_TYPE fuzzyFires[fis_gcR] = { 0 };
FIS_TYPE* fuzzyRuleSet[] = { fuzzyRules, fuzzyFires };
FIS_TYPE sW = 0;

JOB SHEET KENDALI FUZZY LOGIC 100

 // Transforming input to fuzzy Input
int i, j, r, o;
for (i = 0; i < fis_gcI; ++i)
{
for (j = 0; j < fis_gIMFCount[i]; ++j)
{
fuzzyInput[i][j] =
(fis_gMF[fis_gMFI[i][j]])(g_fisInput[i],
fis_gMFICoeff[i][j]);
}
}

int index = 0;
for (r = 0; r < fis_gcR; ++r)
{
if (fis_gRType[r] == 1)
{
fuzzyFires[r] = FIS_MAX;
for (i = 0; i < fis_gcI; ++i)
{
index = fis_gRI[r][i];
if (index > 0)
fuzzyFires[r] = fis_min(fuzzyFires[r],
fuzzyInput[i][index - 1]);
else if (index < 0)
fuzzyFires[r] = fis_min(fuzzyFires[r], 1 -
fuzzyInput[i][-index - 1]);
else
fuzzyFires[r] = fis_min(fuzzyFires[r], 1);
}
}
else
{
fuzzyFires[r] = FIS_MIN;
for (i = 0; i < fis_gcI; ++i)
{
index = fis_gRI[r][i];
if (index > 0)
fuzzyFires[r] = fis_max(fuzzyFires[r],
fuzzyInput[i][index - 1]);
else if (index < 0)
fuzzyFires[r] = fis_max(fuzzyFires[r], 1 -
fuzzyInput[i][-index - 1]);
else
fuzzyFires[r] = fis_max(fuzzyFires[r], 0);

JOB SHEET KENDALI FUZZY LOGIC 101

 }
}

fuzzyFires[r] = fis_gRWeight[r] * fuzzyFires[r];

sW += fuzzyFires[r];
}

if (sW == 0)
{
for (o = 0; o < fis_gcO; ++o)
{
g_fisOutput[o] = ((fis_gOMax[o] + fis_gOMin[o]) / 2);
}
}
else
{
for (o = 0; o < fis_gcO; ++o)
{
g_fisOutput[o] = fis_defuzz_centroid(fuzzyRuleSet, o);
}
}
}

10. Setelah listing program selesai ditulis, install terlebih dahulu library DHT11 dengan
mengikuti langkah sebagai berikut:
11. Siapkan library Sensor DHT11 dapat di download di link [Link]
cari file “[Link]” kemudian klik download.
12. Masukan library I2C LCD ke Arduino IDE dengan cara klik menu bar Sketch →
include library → add .ZIP Library → pilih file library → open.
13. Lakukan upload program ke arduino dengan menghubungkan kabel data dari laptop
ke arduino nano kemudian mengatur menu bar Tools → Board:”Arduino Nano” →
”Processor:Atmega328” → ”Port:”Com (Menyesuaikan silahkan di cek di device
manager)”
14. Setelah pengaturan board seperti di atas selesai dilakukan lakukan dengan klik
tombol upload.
15. Ubahlah nilai sensor suhu menjadi 30OC dan nilai sensor jarak menjadi 10 cm
catat hasil keluaran fuzzy pada tabel 28.
16. Kemudian bandingkan hasil fuzzy ini dengan mengunakan Matlab. Gunakan data
berdasarakan tabel 28 di bawah ini.

JOB SHEET KENDALI FUZZY LOGIC 102

 Tabel 28. Hasil Pengamatan
Output dengan Output dengan
No. Suhu Jarak
Make Proto Matlab
1 30 10
2 25 13
3 28 19
4 30 15
5 32 63
6 35 20
7 38 7
8 40 51
9 42 45
10 45 30
11 48 23

17. Buatlah kesimpulan berdasarkan hasil praktik yang telah diperoleh.

G. Tugas
1. Berikan pendapat anda setelah menggunakan bantuan software Make Proto di
bandingkan dengan Program Arduino sebelumnya yang menggunakan library fuzzy.
2. Buatlah sistem fuzzy dengan menggunakan Make Proto dengan menggunakan 3 input
(variasi pengunaan sensor bebas) dengan 2 buah output bebas.

JOB SHEET KENDALI FUZZY LOGIC 103

 DAFTAR PUSTAKA

Anonim. (-----). Komponen Elektronika. Diakses dari [Link]

Arduino. (2018, Januari 4). [Link]. Diambil kembali dari [Link]:
[Link]
Arduino. (2010). Diambil kembali dari [Link]
[Link] Pada tanggal 1
Januari 2018.
Baiquni, Ahmad Ganjar. (2014). Pengembangan trainer teknik kendali fuzzy logic pada
mobil RC untuk pembelajaran mata kuliah sistem cerdas di Jurusan Teknik Elektro
Fakultas Teknik Universitas Negeri Malang. Malang: Universitas Negeri Malang.
Fatchurrohman, Amir Fatah. (2014). Robot Line Follower Pid Sebagai Media Pembelajaran
Aplikasi Mikrokontroler Di Jurusan Pendidikan Teknik Elektronika Fakultas Teknik
Universitas Negeri Yogyakarta. Yogyakarta: Universitas Negeri Yogyakarta.
Widiyatmoko, A. (2016). Robot Beroda Pemadam Api Dengan Pengolahan Sensor Api
Berbasis Fuzzy Logic. Yogyakarta: Universitas Negeri Yogyakarta.

JOB SHEET KENDALI FUZZY LOGIC 104