Upload
others
View
4
Download
0
Embed Size (px)
Citation preview
1
,
TUGAS AKHIR (609502A)
PERANCANGAN SISTEM KENDALI DAN MONITORING TRUK
TANPA AWAK UNTUK PENGANTAR PETI KEMAS OTOMATIS
DENGAN METODE FUZZY LOGIC
Muhamad Surya Handika
NRP. 0915040036
DOSEN PEMBIMBING :
Dr. MAT SYAI’IN, S.T., M.T., Ph.D.
Ir. JOKO ENDRASMONO, M.T.
PROGRAM STUDI D4 TEKNIK OTOMASI
JURUSAN TEKNIK KELISTRIKAN KAPAL
POLITEKNIK PERKAPALAN NEGERI SURABAYA
SURABAYA
2019
i
TUGAS AKHIR (609502A)
PERANCANGAN SISTEM KENDALI DAN MONITORING
TRUK TANPA AWAK UNTUK PENGANTAR PETI KEMAS
OTOMATIS DENGAN METODE FUZZY LOGIC
Muhamad Surya Handika
NRP. 0915040036
DOSEN PEMBIMBING :
Dr. MAT SYAI’IN, S.T., M.T., Ph.D.
Ir. JOKO ENDRASMONO, M.T.
PROGRAM STUDI D4 TEKNIK OTOMASI
JURUSAN TEKNIK KELISTRIKAN KAPAL
POLITEKNIK PERKAPALAN NEGERI SURABAYA
SURABAYA
2019
ii
Halaman Sengaja Dikosongkan
iii
iv
Halaman ini sengaja dikosongkan
v
vi
Halaman Sengaja Dikosongkan
vii
KATA PENGANTAR
Puji syukur kehadirat Allah SWT yang melimpahkan segala rahmat dan
karunia-Nya sehingga penulis dapat menyelesaikan Tugas Akhir yang berjudul
“Perancangan Sistem Kendali dan Monitoring Truk Tanpa Awak Untuk Pengantar
Peti Kemas Otomatis dengan Metode Fuzzy Logic” yang menjadi salah satu syarat
mutlak untuk menyelesaikan program studi Teknik Otomasi jenjang Diploma-4
Politeknik Perkapalan Negeri Surabaya. Dengan segala kerendahan hati penulis
menyadari bahwa dalam penyelesaian Tugas Akhir ini tidak lepas dari peran berbagai
pihak yang telah memberi banyak bantuan, bimbingan dan dorongan. Dalam
kesempatan ini penulis ingin mengucapkan terimakasih yang tak terhingga khususnya
kepada :
1. Kedua orang tua penulis, Ibu Suyanti dan Bapak Suparno Adi Cahyono
tercinta yang tidak pernah lelah untuk memberikan semangat, doa dan
restunya kepada penulis. Serta Kakak dan Adik tersayang Sunarti dan
Dimas Very Rahmadhani yang selalu memberikan doa, dukungan dan
menghibur penulis.
2. Bapak Ir. Eko Julianto, M.Sc., FRINA. Selaku Direktur Politeknik
Perkapalan Negeri Surabaya.
3. Bapak Mohammad Basuki Rahmat, S.T., M.T. Selaku Ketua Jurusan
Teknik Kelistrikan Kapal Politeknik Perkapalan Negeri Surabaya.
4. Bapak Dr. Mat Syai’in, S.T., M.T., Ph.D. selaku dosen pembimbing 1 dan
Bapak Ir. Joko Endrasmono, M.T. selaku dosen pembimbing 2 yang selalu
dengan sabar memberikan bimbingannya kepada penulis.
5. Bapak Isa Rachman, S.T., M.T., Bapak Agus Khumaidi, S.ST., M.T., dan
Ibu Purwidi Asri, S.ST., M.T. Selaku dosen penguji yang telah
memberikan kritik dan saran demi menyempurnakan penulisan Tugas
Akhir ini.
6. Ibu Ika Triyana, S.T. dan Bapak David Effendi S.T. Selaku pembimbing
On The Job Training (OJT) yang membantu penulis untuk menemukan
suatu ide permasalahan untuk Tugas Akhir.
7. Arifan, Rifky, Fikri, Daus, Bhakti dan Debri yang selalu dengan ikhlas
membantu penulis hingga Tugas Akhir terselesaikan dengan baik.
8. Teman-teman seperjuangan TO angkatan 2015 yang telah membantu
penulis untuk menyelesaikan kendala-kendala yang dihadapi dalam
pengerjaan Tugas Akhir.
9. Seluruh Bapak/Ibu Dosen Politeknik Perkapalan Negeri Surabaya.
10. Semua pihak terkait, baik secara langsung dan tidak langsung.
viii
Penulis menyadari Tugas Akhir ini masih banyak kekurangan, oleh karena itu
kritik dan saran sangat diharapkan demi menyempurnakan Tugas Akhir ini. Penulis
berharap semoga Tugas Akhir ini bermanfaat bagi semua pihak yang membacanya.
Akhir kata, penulis mengucapkan terimakasih banyak kepada semua pihak yang telah
membantu, semoga Allah SWT selalu melimpahkan rahmat dan hidayah-Nya kepada
kita semua. Aamiin…Aamiin…Aamiin Ya Robbal Alamin.
Penulis,
Muhamad Surya Handika
ix
PERANCANGAN SISTEM KENDALI DAN
MONITORING TRUK TANPA AWAK UNTUK
PENGANTAR PETI KEMAS OTOMATIS DENGAN
METODE FUZZY LOGIC
Muhamad Surya Handika
ABSTRAK
Sebagai salah satu pelabuhan terminal peti kemas di Surabaya, PT. Terminal
Teluk Lamong juga harus menghadapi masalah kecelakaan kerja yang tinggi.
Lebih jauh lagi, catatan perusahaan menunjukkan bahwa sebagian besar dari
kecelakaan yang terjadi diakibatkan oleh kesalahan manusia. Sejumlah data
statistik juga menunjukkan bahwa mayoritas kecelakaan kerja pada sektor industri
maritim berkaitan dengan kesalahan manusia (Puspa, 2018). Dalam hal ini
pekerjaan sebagai sopir truk pengantar peti kemas di Terminal Teluk Lamong
merupakan sebuah pekerjaan yang memiliki resiko yang cukup besar, karena
dalam bidang ini dibutuhkan tingkat kewaspadaan yang cukup tinggi, karena jika
kurang waspada dapat menimbulkan kejadian yang tidak diinginkan seperti
menabrak pembatas jalan, menabrak peti kemas yang berada di penumpukan dan
lain sebagainya. Dengan adanya masalah tersebut tujuan dari penelitian ini adalah
melakukan perancangan sistem kendali otomatis berbasis kompas dan Encoder
pada truk tanpa awak. Memanfaatkan truk tanpa awak dengan sistem navigasi
kompas dan Encoder akan lebih efektif dalam segi waktu, biaya dan keselamatan
pekerja. Sistem kendali berbasis kompas selain sebagai kendali motor servo juga
mampu sebagai monitoring truk secara otomatis dengan menggunakan
Mikrokontroler sebagai penghubung sistem monitoring untuk menampilkan nilai
pada kompas yaitu (utara, selatan, barat, dan timur) pada aplikasi Android dan
Encoder untuk menentukan jarak tempuh atau waypoint. Truk digerakkan oleh 2
motor, motor DC sebagai penggerak utama dan motor servo untuk mengarahkan
kendali (roda depan) truk sesuai tujuan yang telah ditentukan berdasarkan
waypoint. Hasil yang didapatkan dari penelitian ini yaitu dapat merancang sistem
kontrol (kendali) dan pemantauan otomatis. Dan adapun hasil persentase
keberhasilan pada pengujian sistem secara keseluruhan yaitu 83,3%. Untuk
monitoring pembacaan nilai sensor pada aplikasi HP Android tergantung dengan
sinyal wifi yang digunakan.
Kata Kunci : Kompas, Encoder, Waypoint, Mikrokontroler, Android.
x
Halaman Sengaja Dikosongkan
xi
DESIGN OF TRUCK CONTROL SYSTEM AND MONITORING
FOR AUTOMATIC CONTAINER DELIVERY WITH FUZZY LOGIC
METHOD
Muhamad Surya Handika
ABSTRACT
As one of the container terminal ports in Surabaya, PT. Teluk Lamong
Terminal must also face high work accident problems. Furthermore, company
records show that the majority of accidents that occur are caused by human error. A
number of statistical data also show that the majority of workplace accidents in the
maritime industry sector are related to human error (Puspa, 2018). In this case the
work as a container truck delivery driver at Teluk Lamong Terminal is a job that has
considerable risk, because in this field a high level of vigilance is needed, because if
you are not vigilant it can cause undesirable events such as crashing roadblocks, hit
a container that is in stacking and so on. With this problem, this research aims to
design a compass and encoder-based automatic control system on unmanned trucks.
Using unmanned trucks with a compass navigation system and encoders will be more
effective in terms of time, cost, and worker safety. Compass-based control systems
other than as a servo motor control are also capable of monitoring trucks
automatically by using a microcontroller as a connencting monitoring system to
display values on the compass (north, south, west, and east) on the android and
encoder cellphone applications to determine mileage or waypoint. The truck is
driven by 2 motors, the dc motor as the prime mover and the servo motor to drive the
truck according to the destination determined based on the waypoint. The results
obtained from this study can design a control system (control) and automatic
monitoring. And as for the results of the percentage of success in the overall system
testing is 83.3%. To monitor the reading of the sensor value on the android mobile
application depends on the wifi signal used.
Keywords: Compass, Encoder, Waypoint, Microcontroller, Android.
PERNYATAAN BEBAS PLAGIAT
xii
Halaman Sengaja Dikosongkan
xiii
DAFTAR ISI
HALAMAN JUDUL …………………………………………………………………………. i
LEMBAR PENGESAHAN ………………………………………………………………… iii
PERNYATAAN KEASLIAN ………………………………………………………………...v
KATA PENGANTAR ………………………………………………………………………vii
ABSTRAK ………………………………………………………………………………….. ix
ABSTRACT ………………………………………………………………………………….. xi
DAFTAR ISI........................................................................................................................ xiii
DAFTAR TABEL ………………………………………………………………………….xvii
DAFTAR GAMBAR ……………………………………………………………………….xix
BAB 1 PENDAHULUAN .......................................................................................................1
1.1 Latar Belakang .........................................................................................................1
1.2 Rumusan Masalah ....................................................................................................3
1.3 Tujuan ......................................................................................................................3
1.4 Manfaat ....................................................................................................................3
1.5 Batasan Masalah .......................................................................................................4
BAB 2 TINJAUAN PUSTAKA...............................................................................................5
2.1 Penelitian Sebelumnya .............................................................................................5
2.2 Dasar Teori ...............................................................................................................6
2.2.1 Logika Fuzzy ....................................................................................................6
2.2.2 Metode Fuzzy Sugeno.......................................................................................7
2.2.3 Odometry ..........................................................................................................8
2.2.4 Internet of Things (IoT) ..................................................................................10
2.2.5 Model Setara Penguat .....................................................................................11
2.2.6 Penguat Tegangan ..........................................................................................13
2.3 Perangkat IoT .........................................................................................................16
2.3.1 Arduino Mega 2560 ........................................................................................16
2.3.2 Wemos D1 Mini .............................................................................................17
2.4 Hardware yang Digunakan ....................................................................................18
xiv
2.4.1 Sensor Kompas HMC5833L .......................................................................... 18
2.4.2 Sensor Loadcell ............................................................................................. 19
2.4.3 Modul FC03 .................................................................................................. 21
2.4.4 Sensor Ultrasonik HCSR04 ........................................................................... 22
2.4.5 Motor Servo S90............................................................................................ 23
2.4.6 Motor DC 6V................................................................................................. 24
2.4.7 Driver Motor L298N ..................................................................................... 24
2.4.8 Driver Loadcell HX711 ................................................................................. 25
2.4.9 Fire Base ....................................................................................................... 26
2.5 Software yang Digunakan ...................................................................................... 26
2.5.1 Android Studio .............................................................................................. 26
2.5.2 Arduino IDE (Integrated Development Environment) ................................... 26
2.5.3 Matlab ........................................................................................................... 27
BAB 3 METODOLOGI PENELITAN ................................................................................. 29
3.1 Analisa Kebutuhan Sistem..................................................................................... 30
3.2 Perancangan Sistem ............................................................................................... 31
3.2.1 Diagram Blok Sistem..................................................................................... 31
3.2.2 Perancangan Hardware ................................................................................. 32
3.2.3 Perancangan Sensor Ultrasonik HCSR04 ...................................................... 33
3.2.4 Perancangan Sensor Kompas HMC5833L ..................................................... 34
3.2.5 Perancangan Sensor Loadcell ........................................................................ 35
3.2.6 Perancangan Motor Servo .............................................................................. 36
3.2.7 Perancangan Motor DC ................................................................................. 37
3.2.8 Perancangan Mekanik .................................................................................... 38
3.3 Perancangan Software ........................................................................................... 39
3.3.1 Aplikasi Android Studio ................................................................................ 39
3.3.2 Software Arduino IDE ................................................................................... 39
3.4 Layout Jalur Tracking Truk di Perusahaan ............................................................ 39
3.5 Rule Base fuzzy ...................................................................................................... 41
3.6 Flowchart Sistem Kendali Utama.......................................................................... 44
3.7 Flowchart Sistem Kendali fuzzy ........................................................................... 45
xv
BAB 4 HASIL DAN PEMBAHASAN .................................................................................. 47
4.1 Pengujian Hardware (Input) ...................................................................................47
4.1.1 Pengujian Sensor dan Arduino .......................................................................48
4.2 Pengujian Aktuator dan Arduino ............................................................................55
4.2.1 Pengujian Aktuator Motor DC dan Arduino ...................................................55
4.2.2 Pengujian Aktuator Motor Servo dan Arduino ...............................................58
4.2.3 Pengujian Catu Daya ......................................................................................59
4.3 Pengujian Metode Fuzzy Logic...............................................................................62
4.3.1 Pengujian Menggunakan Toolbox Matlab ......................................................63
4.3.2 Pengujian Menggunakan Perhitungan ............................................................63
4.4 Pengujian Sistem ....................................................................................................65
BAB 5 KESIMPULAN DAN SARAN ……………………………………………………...69
5.1 Kesimpulan ............................................................................................................69
5.2 Saran ......................................................................................................................69
DAFTAR PUSTAKA ............................................................................................................ 71
LAMPIRAN -LAMPIRAN......................................................................................................72
xvi
Halaman Sengaja Dikosongkan
xvii
DAFTAR TABEL
Tabel 3.1 Pin Wiring Sensor Ultrasonik dengan Arduino ......................................................33
Tabel 3.2 Pin Wiring Sensor Kompas dengan Arduino ..........................................................35
Tabel 3.3 Pin Wiring Sensor Loadcell dengan Arduino .........................................................36
Tabel 3.4 Pin Wiring Motor Servo dengan Arduino ...............................................................37
Tabel 3.5 Pin Wiring Driver Motor ........................................................................................37
Tabel 3.6 Lanjutan Pin Wiring Driver Motor .........................................................................38
Tabel 3.7 Rule Base ...............................................................................................................42
Tabel 3.8 Lanjutan Rule Base ................................................................................................43
Tabel 4.1 Hasil dan Pembahasan …………………………………………………………………………………………47
Tabel 4.2 Pengambilan Data Sensor Kompas dengan Arduino ..............................................49
Tabel 4.3 Lanjutan Pengambilan Data Sensor Kompas dengan Arduino ...............................50
Tabel 4.4 Tabel Pengambilan Data Sensor Loadcell dengan Arduino ....................................51
Tabel 4.5 Hasil Pengujian Sensor Ultrasonik .........................................................................52
Tabel 4.6 Lanjutan Hasil Pengujian Sensor Ultrasonik ..........................................................53
Tabel 4.7 Hasil Pengujian Modul FC03 .................................................................................54
Tabel 4.8 Hasil Pengujian Motor DC .....................................................................................55
Tabel 4.9 Hasil Pengukuran Oscilloscope ..............................................................................58
Tabel 4.10 Data Pengujian Motor Servo ................................................................................59
Tabel 4.11 Hasil Pengujian Baterai Lipo...............................................................................60
Tabel 4.12 Hasil Pengujian Buck Converter...........................................................................61
Tabel 4.13 Lanjutan Hasil Pengujian Buck Converter............................................................62
Tabel 4.14 Pengujian Sistem Kendali berjalannya Truk tanpa Awak .....................................65
xviii
Halaman Sengaja Dikosongkan
xix
DAFTAR GAMBAR
Gambar 2.1 Diagram Blok Logika Fuzzy ...............................................................................6
Gambar 2.2 Ilustrasi pada Sumbu Cartesian...........................................................................9
Gambar 2.3 Sudut α, β, dan £ .................................................................................................9
Gambar 2.4 Konsep IoT .......................................................................................................11
Gambar 2.5 Rangkaian setara Thevenin Jaringan Bergerbang Dua ......................................12
Gambar 2.6 Pemasangan Tegangan Panjar pada Penguat Emitor Ditanahkan .....................13
Gambar 2.7 Bentuk Isyarat Keluaran Suatu Penguat untuk Isyarat Masukan (a) 1 dan 1.8
mV, (b) 4 dan 8 mV dan (c) 15 dan 20 Mv…………………………………...15
Gambar 2.8 Arduino Mega...................................................................................................17
Gambar 2.9 Wemos d1 Mini ................................................................................................17
Gambar 2.10 Kompas HMC5883L .......................................................................................18
Gambar 2.11 Rangkaian Jembatan Wheatstone tanpa Beban ................................................19
Gambar 2.12 Rangkaian Jembatan Wheatstone dengan Beban .............................................19
Gambar 2.13 Rangkaian Load Cell tanpa Beban ...................................................................20
Gambar 2.14 Rangkaian Load Cell diberi Beban ..................................................................21
Gambar 2.15 Loadcell ...........................................................................................................21
Gambar 2.16 Modul FC03 ....................................................................................................22
Gambar 2.17 Ultrasonik HCSR04 .........................................................................................23
Gambar 2.18 Motor Servo .....................................................................................................23
Gambar 2.19 Motor DC 6V...................................................................................................24
Gambar 2.20 Driver Motor L298N .......................................................................................24
Gambar 2.21 Driver Loadcell HX711 ...................................................................................25
Gambar 3.1 Flowchart alur penelitian…....……………………………………………………………………….29
Gambar 3.2 Diagram Blok Sistem.......................................................................................31
Gambar 3.3 Rancangan Hardware ......................................................................................32
Gambar 3.4 Rangkaian Wiring Ultrasonik ..........................................................................33
Gambar 3.5 Diagram Blok Sensor Ultrasonik .....................................................................34
Gambar 3.6 Rancangan Wiring Kompas .............................................................................34
xx
Gambar 3.7 Rancangan Wiring Loadcell ............................................................................. 35
Gambar 3.8 Diagram Blok Sensor Load Cell ...................................................................... 36
Gambar 3.9 Rancangan Wiring Motor Servo ...................................................................... 36
Gambar 3.10 Rancangan Wiring Motor DC .......................................................................... 37
Gambar 3.11 Desain Mekanik “Bawah” ............................................................................... 38
Gambar 3.12 Desain Mekanik “Tengah” ............................................................................... 38
Gambar 3.13 Desain Mekanik “Atas” .................................................................................. 39
Gambar 3.14 Layout google map di PT. Terminal Teluk Lamong ........................................ 40
Gambar 3.15 Layout AutoCad di PT. Terminal Teluk Lamong ............................................ 40
Gambar 3.16 Gambar Jalur Tracking Prototype .................................................................... 41
Gambar 3.17 Membership Function “Kompas” .................................................................... 43
Gambar 3.18 Flowchart Sistem Kendali Utama .................................................................... 44
Gambar 3.19 Flowchart Sistem Kendali Fuzzy ..................................................................... 45
Gambar 4.1 Pengujian Sensor Kompas…………………………………………………………………………….48
Gambar 4.2 Pengujian Sensor Loadcell ............................................................................... 50
Gambar 4.3 Pengujian Sensor Ultrasonik ............................................................................ 52
Gambar 4.4 Pengukuran Jarak Tempuh Prototipe ............................................................... 54
Gambar 4.5 Pengujian Motor DC ........................................................................................ 55
Gambar 4.6 Pengujian Nilai PWM 145 pada Oscilloscope ................................................. 56
Gambar 4.7 Pengujian Servo dengan Busur ........................................................................ 58
Gambar 4.8 Pengujian Baterai Lipo dan Avometer ............................................................. 60
Gambar 4.9 Pengujian Buck Converter 5V DC ................................................................... 61
Gambar 4.10 Input dan Output Fuzzy Logic .......................................................................... 62
Gambar 4.11 Pengujian Toolbox Matlab ............................................................................... 63
Gambar 4.12 Pergerakan Prototipe dari Waypoint 1 ke Waypoint 2 ...................................... 66
Gambar 4.13 Pergerakan Prototipe dari Waypoint 2 ke Waypoint 3 ...................................... 66
Gambar 4.14 Pergerakan Prototipe dari Waypoint 3 ke Waypoint 4 ...................................... 66
Gambar 4.15 Jalur Tracking Prototipe Truk tanpa Awak ...................................................... 67
1
BAB 1
PENDAHULUAN
1.1 Latar Belakang
Berdasarkan data statistik dari Kementrian Perhubungan, Indonesia
memiliki 111 pelabuhan yang dikelola oleh PT. (Persero) Pelabuhan Indonesia I-IV,
serta memiliki 534 pelabuhan yang dikelola oleh Pemerintah yang tersebar dari
Sabang sampai Merauke. Pelabuhan – pelabuhan tersebut terdiri dari pelabuhan kelas
utama hingga kelas wilker. Dengan jumlah yang signifikan, diperlukan pengelolaan
yang efektif dan efisien agar kegiatan kepelabuhan dapat berjalan dengan lancar.
Sehingga dapat secara langsung meningkatkan sektor – sektor terkait. Beberapa
sektor yang terkait secara langsung adalah sektor Industri, sektor perdagangan dan
sektor transportasi.
Sebagai salah satu pelabuhan terminal peti kemas di Surabaya, PT. Terminal
Teluk Lamong juga harus menghadapi masalah kecelakaan kerja yang tinggi. Lebih
jauh lagi, catatan perusahaan menunjukkan bahwa sebagian besar dari kecelakaan
yang terjadi diakibatkan oleh kesalahan manusia. Sejumlah data statistik juga
menunjukkan bahwa mayoritas kecelakaan kerja pada sektor industri maritim
berkaitan dengan kesalahan manusia (Puspa, 2018). Dalam hal ini pekerjaan sebagai
sopir truk pengantar peti kemas di Terminal Teluk Lamong merupakan sebuah
pekerjaan yang memiliki resiko yang cukup besar, karena dalam bidang ini
dibutuhkan tingkat kewaspadaan yang cukup tinggi, karena jika kurang waspada
dapat menimbulkan kejadian yang tidak diinginkan seperti menabrak pembatas jalan,
menabrak peti kemas yang berada di penumpukan dan lain sebagainya.
Data sekunder mengenai kecelakaan kerja pada shift malam di terminal
bongkar-muat peti kemas menunjukkan bahwa selama tahun 2015, telah terjadi
kecelakaan kerja pada shift malam sebanyak 47 kejadian (24,6%) dari 191 kejadian.
Adapaun pada tahun 2016 juga terjadi 47 kecelakaan pada shift malam (27,8%) dari
2
169 kejadian. Jumlah kecelakaan kerja secara keseluruhan mengalami penurunan dari
tahun 2015 hingga 2016, namun tidak dengan kecelakaan kerja pada shift malam.
(Ayu Wanda Saraswati dan Indriati Paskarini, 2018)
Health and Safety Authority (2015) menjelaskan macam – macam bahaya
utama yang ada pada dermaga dan pelabuhan, termasuk juga terminal petikemas.
Macam – macam bahaya itu yakni jatuh dari ketinggian, kejatuhan benda, kelelahan,
lifting equipment, api/listrik substansi berbahaya, peralatan dan kendaraan bergerak,
jangkar, musculeskeletal disordes (MSDs), kebisingan, terpeleset dan tersandung,
bahaya dari lingkungan, dan yang terakhir adalah shift kerja/bekerja pada malam hari
(night work).
Berdasarkan data dan riset mengenai kesehatan dan kecelakaan kerja yang
dilakukan oleh International Labor Organization (ILO) tahun 2013, setiap tahunnya
lebih dari 250 juta kecelakaan kerja yang terjadi. Dengan adanya masalah tersebut
tujuan dari penelitian ini adalah melakukan perancangan sistem kendali berbasis
kompas dan encoder pada truk tanpa awak. Memanfaatkan truk tanpa awak dengan
sistem navigasi kompas dan encoder akan lebih efektif dalam segi waktu, biaya dan
keselamatan pekerja. Sistem kendali berbasis kompas mampu menggerakkan truk
secara otomatis dengan menggunakan mikrokontroler sebagai pusat sistem yang
mengetahui arah pergerakan truk (utara, selatan, barat, dan timur) dan encoder untuk
menghitung jarak tempuh putaran roda pada motor untuk sampai ke Waypoint yang
telah ditentukan. Truk digerakkan oleh 2 motor, motor DC sebagai penggerak utama
dan motor servo untuk mengarahkan kendali truk sesuai tujuan yang ditentukan pada
tiap – tiap waypoint.
3
1.2 Rumusan Masalah
Berdasarkan latar belakang maka rumusan masalah pada Tugas Akhir ini
adalah:
1. Bagaimana merancang dan membuat prototipe sistem kendali truk tanpa
awak berbasis kompas dan encoder ?
2. Bagaimana kinerja prototipe sistem kendali truk tanpa awak berbasis
kompas dan encoder ?
3. Bagaimana hasil monitoring prototipe sistem kendali truk tanpa awak ?
1.3 Tujuan
Adapun tujuan yang ingin dicapai dalam pengerjaan Tugas Akhir ini adalah :
1. Dapat merancang dan membuat prototipe sistem kendali truk tanpa awak
berbasis kompas dan encoder.
2. Merancang kinerja prototipe sistem kendali truk tanpa awak berbasis
kompas dan encoder.
3. Dapat mengetahui hasil monitoring sistem kendali truk tanpa awak.
1.4 Manfaat
Manfaat yang diperoleh dari pengerjaan Tugas Akhir ini adalah :
1. Bagi perusahaan
Mengurangi terjadinya kecelakaan di PT. Terminal Teluk Lamong,
Efisiensi waktu dan Efisiensi Biaya.
2. Bagi Politeknik
Dapat menjadi referensi ilmu pengetahuan dan teknologi bagi Politeknik
Perkapalan Negeri Surabaya berupa prototipe dalam bidang teknologi
yaitu, Perancangan Sistem kendali dan monitoring truk tanpa awak untuk
pengantar peti kemas otomatis dengan metode fuzzy logic.
3. Bagi Penulis
Sebagai tambahan ilmu pengetahuan untuk membuat sistem kendali
otomatis berbasis kompas dan encoder.
4
1.5 Batasan Masalah
Adapun batasan masalah pada pengerjaan Tugas Akhir ini sebagai berikut :
1. Pada pembuatan Tugas Akhir ini berupa prototipe bukan plant nyata yang
terdapat di Perusahaan. Dengan bentuk plant yang menyerupai jalur yang
terdapat di Perusahaan dengan ukuran P = 320 cm dan L = 230 cm
2. Pengambilan maupun peletakan peti kemas dilakukan manual.
3. Fokus pada kendali jalan lurus atau tidak mendeteksi obstacle didepan.
5
BAB 2
TINJAUAN PUSTAKA
2.1 Penelitian Sebelumnya
Penelitian ini dilakukan tidak lepas dari hasil penelitian – penelitian yang telah
dilakukan oleh para peneliti terdahulu sebagai bahan perbandingan dan kajian.
Berdasarkan penelitian yang dilakukan oleh M. Taufikurrahman dan Hugo
Aprilianto (2017) dengan judul “Penerapan Sistem Navigasi Sensor Kompas pada
Robot Beroda”. Pada penelitian ini sistem navigasi sensor kompas sebagai sensor
yang menunjukkan arah jalan pada robot beroda sehingga robot ini dapat mengatur
posisi maupun juga arah selanjutnya agar dapat berjalan sesuai dengan yang
diharapkan.
Penelitian yang dilakukan oleh Fareza Rizky Ramadhan, Ramdhan Nugraha,
Estananto (2017) dengan judul “Perancangan dan Implementasi Kontrol Posisi Robot
Bawah Air menggunakan Metode Fuzzy Logic Control”. Pada penelitian ini peneliti
menjelaskan bahwa salah satu metode kontrol yang dapat digunakan dalam
pembuatan robot otomatis adalah metode Fuzzy Logic. Fuzzy Logic umumnya
diterapkan pada masalah-masalah yang mengandung unsur ketidakpastian,
ketidaktepatan, dan gangguan. Fuzzy Logic dikembangkan berdasarkan cara berpikir
manusia yang memiliki banyak kemungkinan. Ada tiga proses utama dalam
implementasi Fuzzy Logic yaitu fuzzification, inference system, dan defuzzification.
Tugas Akhir dengan judul “Perancangan Sistem Kendali dan Monitoring Truk
Tanpa Awak untuk Pengantar Peti Kemas Otomatis dengan Metode Fuzzy Logic”
merupakan suatu bentuk pengembangan inovasi dalam mengurangi angka kecelakaan
di Pelabuhan peti kemas khususnya pada pengantaran peti kemas pada tempatnya.
Pada sistem ini mengembangkan teknologi berbasis IoT (Internet of Things) untuk
melakukan pengawasan dan pengendalian sehingga sistem pengantaran peti kemas
6
dapat berjalan otomatis secara realtime. Selain itu, Tugas Akhir ini juga bertujuan
untuk merancang sebuah sistem monitoring nirkabel melalui Smartphone Android
yang dapat memberikan informasi mengenai berat beban yang dibawa dan arah yang
akan dilalui prototipe.
2.2 Dasar Teori
2.2.1 Logika Fuzzy
Struktur Dasar Logika Fuzzy
Gambar 2.1 Diagram Blok Logika Fuzzy
Berdasarkan Gambar 2.1, dalam sistem logika fuzzy terdapat beberapa tahapan
operasional yang meliputi :
1. Fuzzifikasi
Fuzzifikasi adalah suatu proses pengubahan nilai tegas yang ada ke dalam
fungsi keanggotaan.
2. Penalaran (Inference Machine)
Mesin penalaran adalah proses implikasi dalam menalar nilai masukan
guna penentuan nilai keluaran sebagai bentuk pengambilan keputusan.
Salah satu model penalaran yang banyak dipakai adalah penalaran max-
min. Dalam penalaran ini, proses pertama yang dilakukan adalah
melakukan operasi min sinyal keluaran lapisan fuzzifikasi, yang diteruskan
dengan operasi max untuk mencari nilai keluaran yang selanjutnya akan di
defuzzifikasikan sebagai bentuk keluaran.
3. Aturan Dasar (Rule Base)
7
Aturan dasar (Rule Base) pada kontrol logika Fuzzy merupakan suatu
bentuk aturan relasi “Jika-Maka” atau “if-then” seperti berikut ini : if x is
A then y is B dimana A dan B adalah linguistic values yang didefinisikan
dalam rentang variabel X dan Y. Pernyataan “x is A” disebut anticedent
atau premis. Pernyataan “y is B” disebut consequent atau kesimpulan.
4. Defuzzifikasi
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.
Sehingga jika diberikan suatu himpunan fuzzy dalam range tertentu, maka
harus dapat diambil suatu nilai crisp tertentu.
2.2.2 Metode Fuzzy Sugeno
Fuzzy metode sugeno merupakan metode inferensi fuzzy untuk aturan
yang direpresentasikan dalam bentuk IF – THEN, dimana output (konsekuen)
sistem tidak berupa himpunan fuzzy, melainkan berupa konstanta atau
persamaan linear. Metode ini diperkenalkan oleh Takagi-Sugeno Kang pada
tahun 1985. Model Sugeno menggunakan fungsi keanggotaan Singleton yaitu
fungsi keanggotaan yang memiliki derajat keanggotaan 1 pada suatu nilai
crisp tunggal dan 0 pada nilai crisp yang lain. Untuk Orde 0 dengan rumus :
IF (x1 is a1) o (x2 is A2) o...o (xn is An) THEN z=k,
Dengan Ai adalah himpunan fuzzy ke i sebagai antaseden (alasan), adalah
operator fuzzy (AND atau OR) dan k merupakan konstanta tegas sebagai
konsekuen (kesimpulan). Sedangkan rumus Orde I adalah :
IF (x1 is a1) o (x2 is A2) o…o(xn is An) THEN z = p1*x1+…+pn*xn+q
dengan Ai adalah himpunan fuzzy ke i sebagai antaseden, o adalah operator
fuzzy (AND atau OR), pi adalah konstanta ke i dan q juga merupakan
konstanta dalam konsekuen.
8
2.2.3 Odometry
Odometry adalah penggunaan data dari pergerakan aktuator untuk
memprkirakan perubahan posisi dari waktu ke waktu. Odometry digunakan
untuk memperkirakan posisi relatif terhadap posisi awal.
Untuk memperkirakan posisi relatif robot, digunakan perhitungan
jumlah pulsa yang dihasilkan oleh sensor rotary encoder setiap satuan ukuran
yang kemudian dikonversi menjadi satuan milimeter.
Untuk mendapatkan jumlah pulsa setiap satu kali putaran roda digunakan
rumus sebagai berikut.
K roda = 2 x π x r
Pulsa_per_mm = resolusi enc / K roda
Pada sistem penggerak differensial terdapat dua roda, yaitu roda kanan
dan roda kiri dan dimisalkan jumlah pulsa_per_mm untuk roda kanan adalah
right_encoder dan roda kiri adalah left_encoder dan jarak antara dua roda
adalah wheel_base maka didapatkan jarak tempuh (distance) dan sudut
orientasi (θ). Rumusnya adalah sebagai berikut.
Distance = (left_enc + right_enc) / 2
θ = (left enc – right enc) / wheel base
Karena θ adalah sudut dalam radian maka untuk mengetahui sudut dalam
derajat (heading) digunakan rumus sebagai berikut :
Heading = θ x 180
𝜋
Dari ketentuan diatas didapatkan bahwa nilai heading akan bernilai
negatif (-) ketika robot berputar melawan arah jarum jam dan akan bernilai
positif (+) ketika robot berputar searah dengan jarum jam. Dengan
mengetahui jarak dan sudut (distance dan θ) maka peneliti dapat mengetahui
9
koordinat X dan koordinat Y dengan persamaan trigonometri. Pada Gambar
2.2. di bawah ini.
Gambar 2.2 Ilustrasi pada Sumbu Cartesian
Dari ilustrasi diatas maka koordinat dari robot dapat diketahui dengan rumus :
Xpos = distance x sin (θ)
Ypos = distance x cos (θ)
Untuk menentukan error arah hadap dari robot terhadap titik tujuan
maka digunakan teorema phytagoras yang akan menghasilkan posisi (path)
saat ini dan jarak terhadap titik tujuan, berikut perhitungannya :
x = X tujuan – Xpos
y = tujuan – Ypos
target distance = √x2 + y2
Heading dari robot yang telah diketahui sehingga peneliti dapat
menghitung error arah hadap (heading error) robot terhadap titik tujuan.
Gambar 2.3 Sudut α, β, dan £
Pada Gambar 2.3. menunjukkan ilustrasi untuk mencari heading error
(α) dimana β adalah target bearing yaitu sudut antara posisi robot saat ini
10
terhadap titik tujuan. Sedangkan garis berwarna biru adalah garis bantu yang
masing – masing sejajar dengan sumbu X dan sumbu Y.
Untuk mendapat nilai dari β, maka digunakan rumus sebagai berikut :
β = arctan 𝑌𝑡𝑢𝑗𝑢𝑎𝑛−𝑌𝑝𝑜𝑠
𝑋𝑡𝑢𝑗𝑢𝑎𝑛−𝑋 𝑝𝑜𝑠
sehingga,
α = β - £
2.2.4 Internet of Things (IoT)
Pada Tugas Akhir ini, sistem yang dibuat berbasis IoT (Internet of Things).
Internet of Things merupakan perkembangan keilmuan yang sangat
menjanjikan untuk mongoptimalkan kehidupan berdasarkan sensor cerdas dan
peralatan pintar yang berkerjasama melalui jaringan internet (Keoh, S.
L.,2014). Pada dasarnya IoT (Internet of Things) mengacu pada benda yang
dapat diidentifikasikan secara unik sebagai representative virtual dalam
struktur berbasis internet. Cara kerja IoT (Internet of Things) adalah interaksi
antara sesama mesin yang terhubung secara otomatis tanpa campur tangan
user dan dalam jarak berapa pun. Agar tercapainya cara kerja IoT (Internet of
Things) tersebut, maka internet menjadi penghubung diantara kedua interaksi
mesin tersebut, sementara user hanya bertugas sebagai pengatur dan
pengawas bekerjanya alat secara langsung. Manfaat yang didapatkan dari
konsep IoT (Internet of Things) itu sendiri ialah pekerjaan yang dilakukan
bisa menjadi lebih cepat, mudah dan efisien. Gambar 2.4 menunjukkan
sebuah konsep IoT (Internet of Things).
11
Gambar 2.4 Konsep IoT
2.2.5 Model Setara Penguat
Secara umum penguat (amplifier) dapat dikelompokkan menjadi 3
(tiga), yaitu penguat tegangan, penguat arus dan penguat transresistansi. Pada
dasarnya kerja sebuah penguat adalah mengambil masukan (input),
mengolahnya dan menghasilkan keluaran (output) yang besarnya sebanding
dengan masukan. Besarnya tegangan keluaran (vo) dibandingkan dengan
tegangan masukan (vi) dinyatakan sebagai berikut :
vo = Av . vi (2.1)
Dimana Av adalah penguatan tegangan (voltage gain). Hal yang sama untuk
penguat arus berlaku
io = A1 . i1 (2.2)
dimana io adalah arus keluaran, i1 adalah arus masukan dan A1 adalah
penguatan arus (current gain). Sementara ini pembahasan hanya dibatasi pada
penguatan tegangan.
Persamaan 2.1 menunjukkan rangkaian setara Thevenin dari jaringan
bergerbang dua dari suatu penguat. Secara ideal, penguat tidak mengambil
arus dari masukan vi dan tegangan keluaran tidak mengalami perubahan jika
arus diambil dari ujung keluaran (lihat Gambar 2.5-a). Pada kenyataannya
rangkaian yang ideal ini tidak dapat dibuat. Rangkaian seperti terlihat pada
12
Gambar 2.5-b adalah lebih realistik dimana penulis menambah hambatan
masukan Ri dan hambatan keluaran Ro.
(a)
(b)
Gambar 2.5 Rangkaian setara Thevenin Jaringan Bergerbang Dua
Pada Gambar 2.5-b terlihat bahwa pada bagian masukan mengalir arus
masukan sebesar
ii = 𝑣𝑖
𝑅𝑖 (2.3)
semakin besar harga Ri penguat tersebut semakin mendekati kondisi ideal.
Hambatan sumber Rs dan hambatan masukan Ri membentuk pembagi
tegangan sehingga
vi = 𝑅𝑖
𝑅𝑖+𝑅𝑠 vs (2.4)
pada bagian keluaran, dengan adanya Ro, tegangan keluaran vo menjadi
v’o = vo - ioRo
atau
v’o = 𝑅𝐿
𝑅𝑜+𝑅𝐿 vo (2.5)
13
Persamaan 3.5 jelas memperlihatkan bahwa semakin kecil harga Ro suatu
penguat akan mendekati kondisi ideal.
2.2.6 Penguat Tegangan
Pada bagian sebelumnya telah dipelajari bagaimana transistor diberi
tegangan panjar (bias) agar transistor tersebut dapat bekerja sebagai penguat.
Pada Gambar 2.6 diperlihatkan penguat BJT emitor-ditanahkan dengan
tegangan panjar dari Vcc dan VBE.
Gambar 2.6 Pemasangan Tegangan Panjar pada Penguat Emitor Ditanahkan
Antara parameter masukan dan keluaran terdapat hubungan dalam
bentuk eksponensial sebagai berikut
-iE = Io {exp(𝑉𝐵𝐸
𝑉𝑇)-1} (2.6)
= Io exp(𝑉𝐵𝐸
𝑉𝑇)
Arus kolektor (ic) besarnya hampir mendekati arus emitor (iE), dengan
demikian dapat ditulis dengan rumus
ic = Io exp(𝑉𝐵𝐸
𝑉𝑇) (2.7)
14
(a)
(b)
(c)
15
Gambar 2.7 Bentuk Isyarat Keluaran Suatu Penguat untuk Isyarat Masukan (a) 1 dan 1.8 mV, (b) 4
dan 8 mV dan (c) 15 dan 20 mV
dan tegangan kolektor diberikan oleh
vc = Vcc - icRL (2.8)
vc = Vcc – Io RL exp(𝑉𝐵𝐸
𝑉𝑇)
Persamaan 2.8 menunjukkan hubungan antara tegangan input VBE dan
tegangan output vc dimana keduanya terdapat komponen DC (untuk panjar)
dan komponen AC (isyarat).
Sayangnya keluaran dan masukan merupakan hubungan yang tidak
selalu linier. Dengan kata lain tidak selalu keluaran merupakan copy dari
masukan sehingga terjadi keluaran yang terdestori (cacat). Ini terjadi akibat
isyarat masukan yang terlalu besar. Pada Gambar 2.7-a isyarat keluaran dari
suatu input 1 dan 1.8 mV memperlihatkan bentuk sinusoida yang sempurna
(tidak terjadi distorsi). Namun jika isyarat masukan diperbesar menjadi 4 dan
8 mV (Gambar 2.7-b) nampak bahwa untuk garis referensi di 7V, isyarat
keluaran tidak simetri lagi (bagian bawah lebih tajam). Pada isyarat masukan
sebesar 15 mV (Gambar 2.7-c), isyarat keluaran mengalami distorsi yang
sangat nyata. Saat masukan diperbesar ke harga 20 mV, masukan kolektor
menyamai tegangan emitter, akibatnya transistor berada pada daerah jenuh
sehingga isyarat keluaran terpotong kurang lebih 2V.
Dengan demikian hanya dapat menentukan besarnya tegangan
keluaran karena adanya perubahan yang sangat kecil pada masukan, yang
lebih dikenal sebagai penguatan isyarat kecil (small-signal gain). Didapatkan
vc = Vcc – Io RL exp(𝑉𝐵𝐸
𝑉𝑇)
dan besarnya penguatan diberikan oleh
16
𝑑𝑣𝑐
𝑑𝑣𝐵𝐸 = -{(
𝑅𝐿
𝑉𝑇)Io exp(
𝑉𝐵𝐸
𝑉𝑇)} atau
𝑑𝑣𝑐
𝑑𝑣𝐵𝐸 = -
𝑖𝑐𝑅𝐿
𝑉𝑇 (2.9)
Pada Persamaan 2.9 terlihat bahwa penguatan berharga negatif, artinya jika
VBE naik maka ic juga naik, tetapi sebaliknya vc akan menurun.
Untuk pengoperasian pada isyarat kecil, ic tetap mendekati harga
panjar DC yaitu Ic, sehingga penguatan isyarat kecil diberikan oleh :
Av = - 𝐼𝑐𝑅𝐿
𝑉𝑇 (2.10)
Penguatan ini bernilai cukup besar, misalnya untuk IcRL = 5V diperoleh
penguatan sebesar = -200.
2.3 Perangkat IoT
Perangkat IoT yang digunakan pada penelitian Tugas Akhir ini yaitu
menggunakan Arduino Mega yang dimanfaatkan sebagai controller dan Wemos
sebagai modul wifi sehingga suatu sistem dapat terkoneksi dengan internet. Hasil
pembacaan sensor yang diterima oleh Arduino Mega akan dikirimkan ke server
dengan bantuan Wemos. Berikut penjelasan mengenai perangkat-perangkat IoT
tersebut:
2.3.1 Arduino Mega 2560
Pada penelitian ini menggunakan Arduino Mega sebagai controller.
Arduino Mega 2560 adalah papan Mikrokontroler yang berbasis pada Atmega
2560. Ini memiliki 54 pin input / output digital (dimana 15 dapat digunakan
sebagai output Pulse Wide Modulation), 16 input analog, 4 UART (port serial
perangkat keras), osilator Kristal 16 MHz, USB koneksi, colokan listrik,
header ICSP, dan tombol reset, Arduino ini diperlukan untuk mendukung
Mikrokontroler, cukup hubungkan ke komputer dengan kabel USB atau diatur
dengan adaptor AC ke DC atau baterai untuk memulai.
17
Gambar 2.8 Arduino Mega
Fungsi dari Arduino Mega dalam Tugas Akhir ini sebagai pengontrol utama
untuk mengontrol antara Hardware dan Software.
2.3.2 Wemos D1 Mini
Pada Tugas Akhir ini, wemos berfungsi untuk menghubungkan
Arduino ke jaringan internet via wifi. Wemos merupakan salah satu modul
board yang dapat dikombinasikan dengan Arduino khususnya untuk project
yang mengusung konsep IoT. Wemos dapat running stand-alone tanpa perlu
dihubungkan dengan Mikrokontroler. Berbeda dengan modul wifi lain yang
masih membutuhkan Mikrokontroler sebagai pengontrol atau otak dari
rangkaian tersebut. Wemos dapat running stand-alone karena didalamnya
sudah terdapat CPU yang dapat memprogram melalui serial port atau via
OTA serta transfer program secara wireless. Gambar 2.9 merupakan salah
satu jenis wemos.
Gambar 2.9 Wemos d1 Mini
18
Fungsi dari wemos d1 mini dalam Tugas Akhir ini yaitu untuk
mengoneksikan antara program Arduino dengan aplikasi Android.
2.4 Hardware yang Digunakan
Sensor adalah perangkat atau komponen yang bertugas mendeteksi (hasil)
gerakan atau fenomena lingkungan yang diperlukan oleh sistem kontroler. Pada
Tugas Akhir ini, penulis menggunakan 4 macam sensor yaitu sensor kompas, sensor
ultrasonik, sensor loadcell, sensor kecepatan (FC-03). Tedapat 3 sensor ultrasonik
yang masing-masing dipasang disamping kanan, depan dan kiri prototipe. Terdapat
sensor kompas yang dipasang di gearbox roda depan. Terdapat sensor loadcell yang
dipasang ditengah (lapis kedua) prototipe. Serta terdapat sensor kecepatan (FC-03)
dipasang di gearbox belakang.
2.4.1 Sensor Kompas HMC5833L
Sensor kompas yang digunakan pada perancangan ini menggunakan
sensor kompas HMC5883L. Sensor kompas HMC5883L sebuah kompas yang
bekerja dengan menyelaraskan medan magnet bumi. Karena jarum kompas
terbuat dari bahan besi, yang sejalan dengan ayunan pada bantalan di pusat
seperti medan magnet bumi menariknya kedalam keselarasan. Medan magnet
ini berkembang di seluruh permukaan bumi sehingga dapat digunakan untuk
membantu dalam menunjuk arah mata angin.
Gambar 2.10 Kompas HMC5883L
Fungsi dari kompas dalam Tugas Akhir ini yaitu sebagai kendali (setir)
pengatur servo.
19
2.4.2 Sensor Loadcell
Load cell adalah sensor gaya dan tekanan, apabila dikenal gaya atau
tekanan maka bentuknya akan berubah. Pada strain gauge (loadcell) atau
dapat disebut dengan deformasi (strain gauge). Strain gauge mengukur
perubahan yang berpengaruh pada strain sebagai sinyal listrik, karena
perubahan efektif terjadi pada beban hambatan kawat listrik.
Prinsip kerja sensor berat (loadcell) selama proses penimbangan akan
mengakibatkan reaksi terhadap elemen logam pada loadcell yang
mengakibatkan gaya secara elastis. Gaya yang ditimbulkan oleh regangan ini
dikonversikan kedalam sinyal elektrik oleh strain gauge (pengukur regangan)
yang terpasang pada loadcell. Prinsip kerja loadcell berdasarkan rangkaian
jembatan wheatstone dapat dilihat pada Gambar 2.11 di bawah ini.
Gambar 2.11 Rangkaian Jembatan Wheatstone tanpa Beban
Pada Gambar 2. 12 nilai R = 350 Ω, arus yang mengalir pada R1 dan
R3 sama degan arus yang mengalir di R2 dan R4, hal ini dikarenakan nilai
semua resistor sama dan tidak ada perbedaan tegangan antara titik 1 dan 2,
oleh karena itu rangkaian ini dikatakan seimbang.
Gambar 2.12 Rangkaian Jembatan Wheatstone dengan Beban
20
Jika rangkaian jembatan Wheatstone diberi beban, maka nilai R pada
rangkaian akan berubah, nilai R1 = R4 dan R2 = R3. Sehingga membuat sensor load
cell tidak dalam kondisi yang seimbang dan membuat beda potensial. Beda potensial
inilah yang menjadi outputnya. Untuk menghitung Vout atau A seperti pada gambar,
maka rumus yang digunakan adalah sebagai berikut :
Vo = (Vs x (𝑅1
𝑅1+𝑅4)) – (Vs x (
𝑅2
𝑅2+𝑅3))
Vo = (10 x (349,3
349,3+350,7)) – (10 x (
350,7
350,7+349,3))
Vo = (10 x (0,499)) – (10 x (0,501))
Vo = 4,99 – 5,01
Vo = -0,02 x 10 = 2 Mv
Secara teori, prinsip kerja load cell berdasarkan pada jembatan Wheatstone
dimana saat load cell diberi beban terjadi perubahan pada nilai resistansi, nilai
resistansi R1 dan R3 akan turun sedangkan nilai resistansi R2 dan R4 akan naik.
Ketika posisi setimbang, Vout load cell = 0 volt, namun ketika nilai resistansi R1 dan
R3 naik maka akan terjadi perubahan Vout pada load cell. Pada load cell output data
(+) dipengaruhi oleh perubahan resistansi pada R1, sedangkan output (-) dipengaruhi
oleh perubahan resistansi pada R3.
Gambar 2.13 Rangkaian Loadcell tanpa Beban
21
Gambar 2.14 Rangkaian Loadcell diberi Beban
Pada Gambar 2.15 merupakan contoh sensor loadcell yang dipakai pada
Tugas Akhir ini.
Gambar 2.15 Loadcell
Fungsi dari loadcell dalam Tugas Akhir ini yaitu sebagai pendeteksi adanya
berat pada prototipe truk tanpa awak.
2.4.3 Modul FC03
Modul FC-03 adalah sensor optocoupler yang terintegrasi dengan
komparator LM393 dalam satu modul. Modul ini dapat digunakan untuk
menghitung pulsa dan mengukur kecepatan motor. Penggunaannya dilakukan
dengan menempatkan poros encoder diantara optocoupler untuk dihitung
lubang-lubang pada poros encoder.
22
Gambar 2.16 Modul FC03
Fungsi dari modul FC-03 dalam Tugas Akhir ini yaitu sebagai penghitung
jarak tempuh motor pada tiap-tiap waypoint yang telah ditentukan.
2.4.4 Sensor Ultrasonik HCSR04
Pada Tugas Akhir ini penulis menggunakan sensor ultrasonik HC-
SR04 HC-SR04 merupakan sensor ultrasonik yang dapat digunakan untuk
mengukur jarak antara penghalang dan sensor. Didalam kendali
mikrokontroler (untuk mengeluarkan pulsa pemicu), sensor mengirimkan
gelombang ultrasonik pendek dengan frekuensi 40 kHz. Gelombang ini akan
merambat melalui udara dengan kecepatan 344 m/s, membentur suatu objek
dan kemudian kembali ke sensor. Sensor ini menyediakan pulsa keluaran pada
mikrokontroler yang akan diteruskan ketika gelombang pantulan terdeteksi
oleh sensor. Alat ini memiliki 4 pin, pin Vcc, Gnd, Trigger, dan Echo. Prinsip
pengukuran jarak menggunakan sensor ultrasonik HC-SR04 adalah ketika
pulsa trigger diberikan pada sensor, transmitter akan mulai memancarkan
gelombang ultrasonik, pada saat yang sama sensor akan menghasilkan output
TLL transisi naik menandakan sensor mulai menghitung waktu pengukuran,
setelah receiver menerima pantulan yang dihasilkan oleh suatu objek maka
pengukuran waktu akan dihentikan dengan menghasilkan output TTL transisi
turun. Jika waktu pengukuran adalah t dan kecepatan suara adalah 340 m/s,
maka jarak antara sensor dengan objek dihitung dengan menggunakan
Persamaan 2.1 berikut.
23
s = 𝑡 x 340𝑚
𝑠⁄
2 (2.1)
Dimana :
s = Jarak antar sensor dengan objek (m)
t = Waktu tempuh gelombang ultrasonik dari transmitter ke receiver (s)
Gambar 2.17 Ultrasonik HCSR04
Fungsi dari ultrasonik dalam Tugas Akhir ini yaitu sebagai pendeteksi
halangan didepan, samping kanan dan juga kiri apabila ada suatu halangan.
2.4.5 Motor Servo S90
Motor Servo yang digunakan adalah SG90 yang memiliki masukan
tegangan 5V dan memiliki putaran maksimal 1800. Motor servo ini memiliki 3
masukan, yaitu power, ground dan control seperti yang ditunjukkan pada
Gambar 2. 18 di bawah ini.
Gambar 2.18 Motor Servo
Fungsi dari motor servo dalam Tugas Akhir ini yaitu sebagai penggerak
(aktuator) pengatur arah kendali dari prototipe truk tanpa awak.
24
2.4.6 Motor DC 6V
Motor listrik DC atau DC Motor adalah suatu perangkat yang
mengubah energi listrik menjadi energi kinetik atau gerakan (motion). Motor
DC ini juga dapat disebut sebagai Motor arus searah. Seperti namanya, DC
Motor memiliki dua terminal dan memerlukan tegangan arus searah atau DC
(Direct Current) untuk dapat menggerakkannya. Motor listrik DC ini biasanya
digunakan pada perangkat – perangkat elektronik dan listrik yang
menggunakan sumber listrik DC seperti Vibrator Ponsel, Kipas DC dan Bor
Listrik DC.
Gambar 2.19 Motor DC 6V
Fungsi dari motor DC untuk Tugas Akhir ini yaitu sebagai penggerak
(aktuator) utama berjalannya prototipe tanpa awak (roda belakang).
2.4.7 Driver Motor L298N
Driver motor L298N merupakan modul driver motor DC yang
digunakan untuk mengontrol kecepatan serta arah perputaran motor DC. IC
L298N merupakan sebuah IC tipe H-bridge yang mampu mengendalikan
beban – beban induktif seperti relay, solenoid, motor DC dan motor stepper.
Gambar 2.20 Driver Motor L298N
25
Fungsi dari driver motor L298N dalam Tugas Akhir ini untuk mengoneksikan
antara motor DC dengan mikrokontroler Arduino Mega.
2.4.8 Driver Loadcell HX711
HX711 adalah modul timbangan, yang memiliki prinsip kerja
mengkonversi perubahan yang terukur dalam perubahan resistansi dan
mengkonversinya ke dalam besaran tegangan melalui rangkaian yang ada.
Modul melakukan komunikasi dengan komputer/mikrokontroler melalui
TTL232. Digunakan pada bidang aerospace, mekanik, elektrik, kimia,
konstruksi, farmasi dan lainnya, digunakan untuk mengukur gaya, gaya
tekanan, perpindahan, gaya tarikan, torsi dan percepatan. Untuk perhitungan
konversi input analog ke digital yang berbentuk heksadesimal dapat
digunakan rumus sebagai berikut :
Out = 𝑖𝑛𝑝𝑢𝑡−(−40)
80 x 224
Contoh :
Out = 0,3−(−40)
80 x 16777216
Out = 8451522 heksadesimal
Bilangan heksadesimal diataslah yang kemudian yang dapat diolah
mikrokontroler yang kemudian dikonversikan kembali menjadi satuan berat.
Gambar 2. 21 Driver Loadcell HX711
Fungsi dari driver Loadcell HX711 dalam Tugas Akhir ini yaitu untuk
mengoneksikan antara sensor Loadcell dengan mikrokontroler Arduino Mega.
26
2.4.9 Fire Base
Firebase adalah BaaS (Backend as a Service) yang saat ini dimiliki
oleh Google. Firebase ini merupakan solusi yang ditawarkan oleh Google
untuk mempermudah pekerjaan Mobile Apps Developer. Dengan adanya
firebase pengembang software dapat lebih fokus mengembangkan aplikasi
tanpa harus memikirkan software yang besar untuk bagian backend. Fungsi
dari firebase dalam penelitian ini yaitu digunakan untuk pengiriman data
serial sensor yang ada pada prototipe ke smarthphone.
2.5 Software yang Digunakan
2.5.1 Android Studio
Android adalah sebuah sistem operasi untuk perangkat mobile berbasis
linux yang mencakup sistem operasi, middleware dan aplikasi. Android
menyediakan platform terbuka bagi para pengembang untuk membuat aplikasi
sendiri. Pada awalnya dikembangkan oleh Android Inc, sebuah perusahaan
pendatang baru yang membuat perangkat lunak untuk ponsel yang kemudian
dibeli oleh Google Inc. Untuk pengembangannya, dibentuklah Open Handset
Alliance (OHA), konsorsium dari 34 perusahaan perangkat keras, perangkat
lunak dan telekomunikasi termasuk Google. HTC, Intel, Motorola,
Qualcomm, T-Mobile dan Nvidia (Safaat, 2014). Fungsi dari software
Android Studio untuk Tugas Akhir ini yaitu untuk memonitoring agar dapat
mengetahui arah jalur yang dilalui truk tanpa awak, berat peti kemas yang
dibawa oleh prototipe truk tanpa awak dan pendeteksi apabila ada benda
disekitar prototipe.
2.5.2 Arduino IDE (Integrated Development Environment)
IDE itu merupakan kependekan dari Integrated Development
Environment, atau secara bahasa mudahnya merupakan lingkungan
terintegrasi yang digunakan untuk melakukan pengembangan. Disebut sebagai
lingkungan karena melalui software inilah Arduino dilakukan pemrograman
27
untuk melakukan fungsi – fungsi yang dibenamkan melalui sintaks
pemrograman. Arduino menggunakan bahasa pemrograman sendiri yang
menyerupai Bahasa C. Bahasa pemrograman Arduino (sketch) sudah
dilakukan perubahan untuk memudahkan pemula dalam melakukan
pemrograman dari Bahasa aslinya. Sebelum dijual ke pasaran, IC
mikrokontroler Arduino telah ditanamkan suatu program bernama Bootlader
yang berfungsi sebagai penengah antara compiler Arduino dengan
mikrokontroler. Arduino IDE dibuat dari Bahasa pemrograman JAVA.
Arduino IDE juga dilengkapi dengan library C/C++. Yang biasa disebut
Wiring yang membuat operasi input dan Output menjadi lebih mudah.
Arduino IDE ini dikembangkan dari software processing yang dirombak
menjadi Arduino IDE khusus untuk pemrograman dengan Arduino.
Fungsi dari Software Arduino IDE dalam Tugas Akhir ini yaitu sebagai
program utama untuk mengontrol dan mengoneksikan dari tiap – tiap
hardware beserta software Android Studio dan juga MATLAB.
2.5.3 Matlab
MATLAB (Matrix Laboratory) adalah sebuah lingkungan komputasi
numerikal dan Bahasa pemrograman komputer generasi keempat.
Dikembangkan oleh The MathWorks, MATLAB memungkinkan manipulasi
matriks, pem-plot-an fungsi dan data, implementasi algoritma, pembuatan
antar muka pengguna, dan pengantar mukaan dengan program dalam Bahasa
lainnya. Meskipun hanya bernuansa numerik, sebuah kotak kakas atau toolbox
yang menggunakan mesin simbolik MuPAD, memungkinkan akses terhadap
kemampuan aljabar komputer. Sebuah paket tambahan, Simulink,
menambahkan simulasi grafis multirana dan desain berdasar model untuk
sistem terlekat dan dinamik. fungsi dari Sofware Matlab dalam Tugas Akhir
ini yaitu digunakan sebagai pengolahan input Kompas, Ultrasonik dan juga
output (Motor Servo) dengan metode Fuzzy Logic.
28
Halaman Sengaja Dikosongkan
29
BAB 3
METODOLOGI PENELITAN
Pada penelitian ini akan dijelaskan langkah – langkah perencanaan dalam
pembuatan alat pada Tugas Akhir. Alat yang berupa prototipe yang dapat mewakili
sistem yang direncanakan seperti ditunjukkan pada diagram alur berikut :
Gambar 3.1 Flowchart alur penelitian
Mulai
Analisa
Kebutuhan Sistem
Perancangan
Sistem
Perancangan Hardware,
Software dan Mekanik
Apakah Sesuai
Tujuan ?
Analisis Data dan
Kesimpulan
Ya
Tidak
Identifiaksi masalah
dan Studi Literatur
Selesai
30
Gambar 3.1 merupakan flowchart alur penelitian yang dimulai dari identifikasi
masalah saat pelaksanaan On The Job Training (OJT) yang dilakukan di PT.
Terminal Teluk Lamong. Adapun permasalahan tersebut berhubungan dengan sistem
transportasi truk pengantar peti kemas, setelah mengidentifikasi masalah yang ada
penulis melakukan studi literatur guna mencari referensi yang dibutuhkan dalam
pengerjaan Tugas Akhir ini. Kemudian dilakukan tahap Analisa kebutuhan sistem
untuk mengetahui komponen-komponen serta penerapan teknologi yang digunakan.
Tahap selanjutnya yaitu desain dan perencanaan sistem untuk dijadikan sebagai
pedoman atau panduan dalam perancangan hardware, mekanik ataupun software
dalam Tugas Akhir ini. Setelah sistem memiliki desain dan perencanaan yang baik
maka dilanjutkan dengan perancangan sistem yang dimulai dari perancangan
hardware dan mekanik, kemudian dilanjutkan dengan perancangan software.
Selanjutnya tahap integrasi software, hardware dan mekanik diperlukan untuk
memastikan keseluruhan sistem agar sesuai dengan tujuan yang diinginkan penulis.
Apabila sistem dinyatakan berhasil maka dapat dilakukan analisis data dan
kesimpulan. Tetapi, jika pengujian tidak sesuai maka diperlukan perancangan sistem
kembali baik hardware, mekanik atau software.
3.1 Analisa Kebutuhan Sistem
Analisa kebutuhan sistem merupakan proses dalam merancang sistem dengan
memperhitungkan kebutuhan yang diperlukan. Pada tahapan ini dilakukan analisis
terhadap data yang dibutuhkan. Selain itu juga dilakukan analisis tentang teknologi
yang dibutuhkan untuk membangun sistem ini. Berikut adalah teknologi yang
dibutuhkan untuk membangun sistem :
1. Arduino Mega 2560
2. Kompas HMC5883L
3. Modul Encoder FC-03
4. Sensor Loadcell
5. Sensor Ultrasonik HCSR04
6. Wemos D1 mini
31
7. Motor DC
8. Motor Servo SG90
9. Driver Motor L298N
10. Driver Loadcell HX711
3.2 Perancangan Sistem
Setelah mengetahui kebutuhan sistem, dasar – dasar ilmu serta teknologi yang
akan digunakan, maka langkah selanjutnya adalah melakukan perancangan dan
desain dari sistem yang akan dikembangkan. Pada Tugas Akhir ini desain dan
perencanaan sistem meliputi tahap pengumpulan data, diagram blok sistem,
perancangan hardware, perancangan mekanik.
3.2.1 Diagram Blok Sistem
Gambar 3.2 menunjukkan dengan diagram blok sistem yang dirancang
menggunakan empat sensor yaitu Loadcell, Kompas, Encoder FC-03, dan
Ultrasonik. Sensor mengirim data ke Arduino Mega 2560 untuk dilakukan
proses pengolahan data dengan metode fuzzy logic setelah Arduino Mega
2560 mengolah data dari sensor, selanjutnya Arduino Mega 2560 akan
mengontrol Motor DC dan Motor Servo. Selain mengontrol Motor DC dan
Motor Servo, Wemos D1 mini akan mengoneksikan antara Arduino dengan
smartphone.
Gambar 3.2 Diagram Blok Sistem
32
Gambar 3.2 menunjukkan diagram blok yang mewakili sistem yang akan
dijalankan. Pada diagram blok tersebut dapat diketahui bahwa sistem memilki
tiga bagian penting yaitu masukan, proses dan keluaran. Sensor loadcell yang
dipasang di tengah bertugas untuk mendeteksi massa atau berat peti kemas
(balok). Sensor ultrasonik yang dipasang di sisi kiri, depan dan kanan
bertugas untuk mendeteksi benda halangan disekitar. Sensor kompas yang
dipasang di depan bertugas untuk penunjuk arah. Sedangkan sensor encoder
fc-03 bertugas untuk menghitung putaran roda (jarak tempuh) menuju
waypoint yang telah ditentukan. Hasil pembacaan sensor tersebut akan
diterima oleh Arduino Mega untuk kemudian diproses sehingga dapat
menjalankan aktuator berupa motor servo dan motor DC. Selain itu, hasil
pemrosesan Arduino akan dapat dipantau secara realtime menggunakan
smarthphone Android.
3.2.2 Perancangan Hardware
Berikut adalah gambar rancangan hardware sistem kendali/kontrol
truk tanpa awak yang akan dibuat pada tugas akhir ini.
Gambar 3.3 Rancangan Hardware
SENSOR INTERFACE
Kompas CONTROLLER
Wemos D1 Mini Smartphone
Ultrasonik
Motor DC
Arduino Mega
Encoder FC-03
AKTUATOR
Motor Servo
Driver Motor
Driver Load Cell Load Cell
33
3.2.3 Perancangan Sensor Ultrasonik HCSR04
Perancangan sensor ultrasonik bertujuan untuk membaca jarak sekitar
prototipe truk tanpa awak. Pengujian ini dilakukan dilakukan dengan cara
mengukur jarak antara ultrasonik dengan kardus dalam satuan cm dengan
menggunakan mikrokontroler Arduino Mega. Kemudian pembanding sensor
ultrasonik menggunakan penggaris. Berikut merupakan rangkaian sensor
ultrasonik pada Gambar 3.4 di bawah ini.
Gambar 3.4 Rangkaian Wiring Ultrasonik
Dari datasheet pada sensor ultrasonik HCSR04 ini mampu mengukur
jarak maksimal hingga 4 meter, tetapi semakin jauh jarak yang dideteksi,
maka semakin besar pula nilai error dari sensor ini. Sensor ini membutuhkan
daya 3,3 VDC – 5,0 VDC untuk dapat beroperasi. Dari rancangan sensor
ultrasonik yang ditunjukkan pada Gambar 3.4 dapat diperjelas konektivitas
pemasangan pin sensor Arduino dengan sensor ultrasonik pada Tabel 3.1.
Tabel 3.1 Pin Wiring Sensor Ultrasonik dengan Arduino
VCC 5V
TRIG 52
ECHO 50
GND GND
34
Untuk pengukuran jarak, sensor ultrasonik ini memancarkan gelombang
(transmitter) kemudian diterima balik oleh receiver. Berikut pada Gambar 3.5
merupakan diagram blok dari sensor ultrasonik.
Kontroler
(Arduino Mega)
Aktuator
(Motor Servo)
Plant
(Gerak Sudut)
Sensor
(Ultrasonik)
+
-
jarak
Output
Feedback
jarak
Input
Gambar 3.5 Diagram Blok Sensor Ultrasonik
input dari sensor ultrasonik berupa jarak yang akan diproses melalui kontroler
Arduino Mega, setelah itu menggerakkan nilai sudut pada motor servo
sebagai aktuatornya dan output yang akan diperoleh berupa jarak.
3.2.4 Perancangan Sensor Kompas HMC5833L
Perancangan sensor kompas bertujuan untuk mengetahui arah jalur
prototipe truk tanpa awak. Pengujian ini dilakukan pada serial monitor dengan
menggunakan mikrokontroler Arduino Mega. Kemudian pembanding sensor
kompas menggunakan kompas manual. Berikut merupakan rangkaian sensor
kompas pada Gambar 3.6 dibawah ini.
Gambar 3.6 Rancangan Wiring Kompas
35
Dari rancangan sensor kompas yang ditunjukkan pada Gambar 3.6 dapat
diperjelas konektivitas pemasangan pin sensor Arduino dengan sensor kompas
pada Tabel 3.2.
Tabel 3.2 Pin Wiring Sensor Kompas dengan Arduino
VCC 5V
SCL 21
SDA 20
GND GND
3.2.5 Perancangan Sensor Loadcell
Perancangan sensor loadcell untuk mengetahui massa (berat) balok
yang akan dibawa oleh prototipe truk tanpa awak. Pengujian ini dilakukan
pada serial monitor dengan menggunakan mikrokontroler Arduino Mega.
Kemudian pembanding sensor loadcell menggunakan loadcell digital. Berikut
merupakan rangkaian sensor loadcell pada Gambar 3.7 di bawah ini..
Gambar 3.7 Rancangan Wiring Loadcell
Dari rancangan sensor loadcell yang ditunjukkan pada Gambar 3.7 dapat
diperjelas konektivitas pemasangan pin sensor Arduino dengan sensor
loadcell pada Tabel 3.3. Dan juga pada Gambar 3.8 terdapat diagram blok
sensor loadcell.
36
Tabel 3.3 Pin Wiring Sensor Loadcell dengan Arduino
VCC 5V
SCK 8
DT 9
GND GND
Berikut pada Gambar 3.8 merupakan diagram blok sensor loadcell.
Kontroler
(Arduino Mega)
Aktuator
(Motor DC)
Plant
(Gerak Putar)
Sensor
(Loadcell)
+
-
berat
Feedback
Input
berat
Output
Gambar 3.8 Diagram Blok Sensor Loadcell
input dari sensor loadcell berupa berat yang akan diproses melalui kontroler
Arduino Mega, setelah itu menggerakkan roda pada Motor DC sebagai
aktuatornya dan output yang akan diperoleh berupa berat.
3.2.6 Perancangan Motor Servo
Perancangan motor servo untuk menggerakkan kendali roda depan
pada prototipe truk tanpa awak. Pengujian ini dilakukan dengan menggunakan
mikrokontroler Arduino Mega. Kemudian pembanding motor servo
menggunakan busur. Berikut merupakan rangkaian motor servo pada Gambar
3.9 di bawah ini.
Gambar 3.9 Rancangan Wiring Motor Servo
37
Dari rancangan motor servo yang ditunjukkan pada Gambar 3.9 dapat
diperjelas konektivitas pemasangan pin Arduino dengan sensor motor servo
pada Tabel 3.4.
Tabel 3.4 Pin Wiring Motor Servo dengan Arduino
VCC 5V
PWM 13
GND GND
3.2.7 Perancangan Motor DC
Perancangan Motor DC untuk menggerakkan roda belakang pada
prototipe truk tanpa awak. Pengujian ini dilakukan dengan menggunakan
mikrokontroler Arduino Mega. Berikut merupakan rangkaian Motor DC pada
Gambar 3.10 di bawah ini.
Dari rancangan Motor DC yang ditunjukkan pada Gambar 3.10 dapat
diperjelas konektivitas pemasangan pin Arduino dengan Motor DC pada
Tabel 3.5 dan Tabel 3.6 di bawah ini.
Tabel 3.5 Pin Wiring Driver Motor
VCC 5V
IN 1 14
IN 2 15
IN 3 16
Gambar 3.10 Rancangan Wiring Motor DC
38
Tabel 3.6 Lanjutan Pin Wiring Driver Motor
3.2.8 Perancangan Mekanik
Desain mekanik merupakan desain bentuk dari rancang bangun dan
tempat peletakan komponen yang akan digunakan. Dan dapat dilihat desain
mekanik bawah, tengah dan atas pada Gambar 3.11., 3.12., dan 3.13 di bawah
ini.
Gambar 3.11 Desain Mekanik “Bawah”
Gambar 3.12 Desain Mekanik “Tengah”
IN 4 17
ENA 10
ENB 2
GND GND
39
Gambar 3.13 Desain Mekanik “Atas”
3.3 Perancangan Software
Setelah merancang dan membuat hardware, maka tahap selanjutnya yaitu
perancangan dan pembuatan software. Pada tahap ini peneliti menetapkan untuk
menggunakan software Android Studio sebagai program monitoring dan software
Arduino IDE sebagai program kontrol, serta Matlab sebagai pengujian metode fuzzy.
3.3.1 Aplikasi Android Studio
Dalam perancangan ini dilakukan pembuatan program dan desain
tampilan semenarik mungkin agar lebih mempermudah pemahaman dalam
melakukan monitoring arah (kompas), dan massa (berat) pada sensor yang
terdapat di prototipe truk tanpa awak. Pada tampilan interface yang telah
dibuat terdapat 3 halaman yaitu splashcreen, login, dan proses.
3.3.2 Software Arduino IDE
Perancangan dan pembuatan program ini bertujuan untuk proses
pengendalian dari sistem dalam Tugas Akhir ini. Sehingga dapat dilakukan
komunikasi antara HP Android dan Prototipe.
3.4 Layout Jalur Tracking Truk di Perusahaan
Gambar 3.14 merupakan gambaran wilayah untuk perusahaan PT. Terminal
Teluk Lamong dilihat melalui google map.
40
Gambar 3.14 Layout google map di PT. Terminal Teluk Lamong
Gambar 3.15 merupakan gambaran wilayah untuk perusahaan PT. Terminal
Teluk Lamong dilihat melalui desain AutoCAD.
Gambar 3.15 Layout AutoCad di PT. Terminal Teluk Lamong
Dari hasil kedua layout gambar di atas peneliti mencoba untuk membuat jalur
tracking di Gambar 3.16 terdapat 4 Waypoint yang nantinya akan dilalui oleh
prototipe truk tanpa awak. Berikut merupakan gambaran dan penjelasan sistem
operasi prototipe tanpa awak :
Waypoint 1 dari dermaga merupakan awalan start prototipe truk tanpa awak
ketika menerima massa (berat) peti kemas, setelah sampai Waypoint 2 Tikungan 1
maka akan belok ke kiri sesuai perhitungan jarak tempuh atau perputaran piringan
encoder, selanjutnya setelah sampai pada waypoint 3 Tikungan 2 maka akan belok
kearah kiri sesuai pehitungan jarak tempuh atau perputaran encoder selanjutnya, dan
41
terakhir setelah sampai Waypoint 4 (tempat penumpukan peti kemas) yang
merupakan akhiran (finish) dan prototipe truk tanpa awak akan berhenti.
Gambar 3.16 Gambar jalur tracking prototype
3.5 Rule Base fuzzy
Rule Base fuzzy berisi pernyataan – pernyataan logika fuzzy (fuzzy statement),
yang berbentuk pernyataan if-then. Setelah dilakukan fuzzification untuk setiap
masukan dan keluaran, maka langkah berikutnya yaitu membuat aturan (rule base).
Rule Base ini terdiri dari kumpulan aturan yang berbasis logika fuzzy untuk
menyatakan suatu kondisi. Penyusunan rule base sangat berpengaruh pada presisi
model, pada tahap pengambilan keputusan ditentukan berdasarkan rancangan rule
base. Aturan if-then yang dihubungkan dengan logika operasi and dan or. Rule base
yang digunakan pada penelitian ini masing – masing input mempunyai 5 membership
function (mf) yang pertama pada input kompas yaitu kiri, agak kiri, sedang, agak
kanan dan kanan. Kedua pada input ultrasonikkiri yaitu dekat, agak dekat, sedang,
agak jauh dan jauh. Ketiga pada input ultrasonikdepan yaitu dekat, agak dekat,
sedang, agak jauh dan jauh. Keempat pada input ultrasonikkanan yaitu dekat, agak
dekat, sedang, agak jauh dan jauh. Dapat dilihat pada Tabel 3.7 berupa penjelasan
tentang rule base yang akan digunakan dalam Tugas Akhir ini, sebagai berikut :
Untuk output berupa Motor servo yaitu lurus. Hal tersebut dikarenakan program fuzzy
42
ini hanya dikhususkan untuk meluruskan kendali yaitu berupa servo apabila bergeser
sudut di lintasan lurus. Agar prototipe truk tanpa awak berjalan di jalur lurus dapat
stabil. Pada Tabel 3.6 merupakan rule base fuzzy yang digunakan pada Tugas Akhir
ini.
Tabel 3.7 Rule Base
kondisi arah Jarak kanan Jarak depan Jarak kiri sudut
1 Utara jauh jauh jauh lurus
2 Barat laut jauh jauh jauh lurus
3 Timur laut jauh jauh jauh lurus
4 Utara dekat jauh jauh lurus
5 Barat laut dekat jauh jauh lurus
6 Timur laut dekat jauh jauh lurus
7 Utara jauh dekat jauh lurus
8 Barat laut jauh dekat jauh lurus
9 Timur laut jauh dekat jauh lurus
10 Utara jauh jauh dekat lurus
11 Barat laut jauh jauh dekat lurus
12 Timur laut jauh jauh dekat lurus
13 Utara dekat dekat jauh lurus
14 Barat laut dekat dekat jauh lurus
15 Timur laut dekat dekat jauh lurus
16 Utara jauh dekat dekat lurus
17 Barat laut jauh dekat dekat lurus
18 Timur laut jauh dekat dekat lurus
19 Utara dekat jauh dekat lurus
20 Barat laut dekat jauh dekat lurus
21 Timur laut dekat jauh dekat lurus
43
Tabel 3.8 Lanjutan Rule Base
Kondisi arah Jarak kanan Jarak depan Jarak kiri Sudut
22 Utara dekat dekat dekat Lurus
23 Barat laut dekat dekat dekat Lurus
24 Timur laut dekat dekat dekat Lurus
Pada Gambar 3.17 merupakan contoh membership function yang digunakan
pada Tugas Akhir ini.
Gambar 3.17 Membership Function “Kompas”
Dan pada Gambar 3.17 telah dibuat 5 membership function kompas untuk
digunakan sebagai aturan rule base fuzzy yang nantinya akan menentukan keluaran
nilai output.
44
3.6 Flowchart Sistem Kendali Utama
Gambar 3.18 Flowchart Sistem Kendali Utama
Peletakan prototipe pada jalur lintasan, ketika prototipe truk tanpa awak
mendeteksi adanya beban berat peti kemas (benda statis) dengan berat (>200g) maka
motor DC akan aktif menjalankan prototipe dan parameter untuk peti kemas adalah
massa atau berat yang telah ditentukan. Selanjutnya sensor kompas menunjukkan
arah yang telah ditentukan pada layout jalur tracking yang harus dilalui oleh prototipe
Mulai
Baca Sensor Load Cell
Berat Balok
(Peti Kemas)
Berat Balok (Peti
Kemas) >200g ?
Baca Sensor Kompas
Nilai Sudut
Arah Mata
Angin (0-3600)
Baca Sensor Encoder
Roda
Belakang
Motor Aktif
Waypoint = Setpoint ?
Motor DC Akan Berhenti
Selesai
A
A
Arah Roda
Depan
Logika Fuzzy
Tidak
Ya
Ya
Tidak
45
untuk menggerakkan roda depan menuju tiap – tiap waypoint sesuai dengan rule
logika fuzzy. Dan sensor encoder digunakan untuk menghitung jarak tempuh tiap –
tiap waypoint yang harus dilalui oleh prototipe. Setelah sampai pada waypoint =
setpoint maka prototipe akan berhenti.
3.7 Flowchart Sistem Kendali fuzzy
Gambar 3. 19 Flowchart Sistem Kendali Fuzzy
Ketika sensor kompas aktif maka tahap selanjutnya masuk kedalam proses
fungsi keanggotaan (fuzzifikasi), selanjutnya proses rule fuzzy, kemudian hitung
centroid (defuzzifikasi), dan setelah selesai akan mengatur arah roda depan.
Mulai
Nilai Sudut
Arah Mata
Angin (0-3600)
Selesai
Arah Roda
Depan
Fungsi Keanggotaan
(Fuzzifikasi)
Rule Fuzzy
Hitung Centroid
(Deffuzifikasi)
46
Halaman Sengaja Dikosongkan
47
BAB 4
HASIL DAN PEMBAHASAN
Pada bab hasil dan pembahasan berisi tentang hasil pengujian setiap
komponen – komponen penunjang Tugas Akhir dan analisanya. Pada bab ini
dilakukan beberapa pengujian guna memastikan bahwa komponen maupun sistem
dapat berjalan sesuai perencanaan yang telah dibuat. Pengujian meliputi beberapa
bagian antara lain seperti yang terdapat pada Tabel 4.1 di bawah ini :
Tabel 4.1 Hasil dan Pembahasan
PENGUJIAN
TIAP – TIAP
KOMPONEN
INPUT OUTPUT
Sensor Kompas Motor DC
Sensor Loadcell
Sensor Ultrasonik Motor Servo
Modul Encoder FC03
PENGUJIAN
SISTEM
TRACKING PERCOBAAN
Beban (300g)
10x
Berikut merupakan penjelasan masing – masing pengujian yang dilakukan pada
Tugas Akhir ini.
4.1 Pengujian Hardware (Input)
Perancangan hardware elektronika (baik sensor, controller, aktuator dan catu
daya) dirancang sedemikian rupa sehingga komponen – komponen tersebut mampu
memberikan output yang diinginkan. Sensor dapat membaca data input, controller
dapat memproses data dan memberikan sinyal output ke aktuator serta catu daya
dapat memberikan energi listrik yang sesuai. Pada proses pengujian hardware ini
bertujuan untuk mengetahui tingkat keakuratan setiap komponen – komponen
48
tersebut serta mengetahui besarnya persentase error yang dihasilkan. Berikut
pengujian tingkat keakuratan komponen – komponen yang digunakan pada Tugas
Akhir ini :
4.1.1 Pengujian Sensor dan Arduino
Pada Tugas Akhir ini menggunakan empat jenis sensor sebagai
input/masukan pada sistem yaitu sensor kompas, loadcell, ultrasonik, dan
modul encoder fc03. Berikut pengujian tingkat keakuratan pada masing –
masing sensor tersebut:
4.1.1.1 Sensor Kompas dan Arduino
Pada Tugas Akhir ini pengujian sensor kompas bertujuan untuk
menguji apakah data sensor kompas yang muncul pada serial monitor Arduino
sesuai dengan kompas manual (sebenarnya). Pengujian dimulai dari 0 derajat
sampai dengan 360 derajat, seperti ditunjukkan pada dan hasil pengujian
ditunjukkan pada Gambar 4.1 di bawah ini.
Gambar 4.1 Pengujian Sensor Kompas
Pada Gambar 4.1 menunjukkan pengujian data sensor kompas dengan
pembanding kompas manual untuk mengetahui seberapa akurat pendeteksian
sensor kompas terhadap arah mata angin yang sebenarnya. Seperti yang
ditunjukkan pada serial monitor Arduino bahwa pembacaan sensor kompas
apabila dibandingkan dengan kompas manual mendapatkan error seperti yang
terdapat pada Tabel 4.2 di bawah ini.
49
Tabel 4.2 Pengambilan Data Sensor Kompas dengan Arduino
No Kompas manual
(derajat)
Kompas Arduino
(derajat)
Presentase error (%)
1 0 0 0,00
2 10 11 10,00
3 20 20 0,00
4 30 30 0,00
5 40 41 2,50
6 50 53 6,00
7 60 60 0,00
8 70 71 1,43
9 80 81 1,25
10 90 90 0,00
11 109 111 1,83
12 120 121 0,83
13 130 129 0,77
14 140 141 0,71
15 152 149 1,97
16 159 159 0,00
17 169 170 0,59
18 180 178 1,11
19 190 192 1,05
20 200 201 0,50
21 209 211 0,96
22 219 220 0,46
23 230 229 0,43
24 240 240 0,00
25 250 248 0,80
50
Gambar 4.2 Pengujian Sensor Loadcell
Tabel 4.3 Lanjutan Pengambilan Data Sensor Kompas dengan Arduino
Dari hasil pengujian Sensor Kompas yang ditunjukkan oleh dapat diketahui
bahwa pada data kompas terjadi error dengan rata – rata sebesar 1,06%
4.1.1.2 Sensor Loadcell dan Arduino
Pada Tugas Akhir ini, digunakan sensor loadcell untuk mendeteksi
massa (berat) balok untuk permisalan peti kemas yang akan dibawa oleh
prototipe truk tanpa awak nantinya. Dalam pengujian ini menggunakan
pembanding timbangan digital dan hasilnya seperti Gambar 4.2 di bawah ini.
No Kompas manual
(derajat)
Kompas Arduino
(derajat)
Presentase error (%)
26 270 270 0,00
27 280 278 0,71
28 290 289 0,34
39 300 300 0,00
30 310 309 0,32
31 320 321 0,31
32 330 329 0,30
33 340 341 0,29
34 350 351 0,29
35 Rata-rata error 1,06
51
Pada menunjukkan pengujian tingkat keakuratan data massa (berat)
pada balok (peti kemas) yang dibawa oleh prototipe truk tanpa awak dengan
loadcell untuk mengetahui besar error-nya. Agar dapat mengetahui rata – rata
error dari sensor loadcell, maka dilakukan beberapa pengujian sensor yang
kemudian hasilnya dibandingkan dengan menggunakan timbangan digital.
Tabel 4.4 Tabel Pengambilan Data Sensor Loadcell dengan Arduino
No. Sensor Loadcell Timbangan Digital Error(%)
1. 3008 gram 3008 gram 0 %
2. 143 gram 146 gram 2,05%
3. 397 gram 396 gram 0,25%
4. 435 gram 436 gram 0,23%
5. 622 gram 623 gram 0,16%
Rata-rata persentase error 0,54%
Dari Tabel 4.4 menunjukkan bahwa setelah melakukan beberapa
pengujian, data disimpulkan bahwa sensor loadcell cukup akurat karena
menghasilkan rata-rata error yang cukup kecil yaitu 0.54%
4.1.1.3 Sensor Ultrasonik dan Arduino
Pada Tugas Akhir ini menggunakan sensor ultrasonik HC-SR04 untuk
mendeteksi halangan disamping kanan, depan dan kiri prototipe. Selain itu,
hasil pembacaan sensor ultrasonik tersebut juga ditampilkan pada aplikasi
Android.
Untuk mengetahui tingkat keakuratan dan persentase error sensor
ultrasonik yang digunakan maka dilakukan pengujian dengan
membandingkan hasil pembacaan jarak dari sensor ultrasonik dan Arduino
dengan hasil pengukuran jarak menggunakan penggaris yang diberi
penghalang di depannya seperti yang terlihat pada Gambar 4.3 di bawah ini.
52
Gambar 4.3 Pengujian Sensor Ultrasonik
Setelah pengujian sensor ultrasonik HC-SR04 dilakukan, maka
selanjutnya dapat dicari nilai presentase error (% e) adalah hasil nilai mutlak
dari pengurangan nilai aktual (Na) dan nilai eksperimental (Ne) dibagi dengan
nilai aktual (Na) kemudian dikalikan dengan 100% seperti Persamaan 4.1:
% e = |
Na−Ne
| 100%
(4.1)
Na
Tabel 4.5 Hasil Pengujian Sensor Ultrasonik
No.
Jarak Pengujian Hasil Pengukuran
Rata-rata Error (%)
(Penggaris)
(Ultrasonik)
9 cm
9 cm
1. 10 cm 9 cm 9 cm 10
9 cm
9 cm
53
Tabel 4.6 Lanjutan Hasil Pengujian Sensor Ultrasonik
Berdasarkan Hasil Pengujian Sensor Ultrasonik menunjukkan bahwa
hasil pembacaan sensor ultrasonik HC-SR04 dan Arduino dibandingkan
dengan penggaris sebagai alat ukur memiliki error sebanyak 3,95%.
4.1.1.4 Modul Encoder FC03 dan Arduino
Pada Tugas Akhir ini menggunakan sensor encoder FC03 yang
digunakan untuk menghitung jarak tempuh jalur prototipe yang telah dihitung
berdasarkan alat ukur manual berupa penggaris dan akan dibandingkan
dengan control Arduino. Hasil dan pengujian dapat dilihat pada Gambar 4.4
di bawah ini.
No.
Jarak Pengujian Hasil Pengukuran Rata-rata Error (%)
(Penggaris) (Ultrasonik)
2. 20 20 cm
20 cm 20 0
20 cm
29 cm
29 cm
3. 30 cm 29 cm 29 cm 3,3
29 cm
29 cm
39 cm
39 cm
4. 40 cm 39 cm 39 cm 2,5
39 cm
39 cm
Rata-rata error (%) 3,95
54
Gambar 4. 4 Pengukuran Jarak Tempuh Prototipe
Tabel 4.7 Hasil Pengujian Sensor Encoder FC03
No. Set-point posisi
(cm)
Pergeseran sebenarnya
(cm)
Persentase error
(%)
1. 0 0 0
2. 10 10,5 5
3. 20 20,7 3,5
4. 30 30,4 1,3
5. 40 40,2 0,5
6. 50 50,5 1
7. 60 61 1,6
8. 70 70,5 0,7
9. 80 80,8 1
10. 90 90,6 0,6
11. 100 101 1
Rata – rata persentase error 1,62
Berdasarkan Hasil Pengujian Sensor encoder FC03 menunjukkan bahwa
hasil pembacaan sensor encoder FC03 dan Arduino dibandingkan dengan
penggaris sebagai alat ukur memiliki error sebanyak 1,62%.
55
Gambar 4.5 Pengujian Motor DC
4.2 Pengujian Aktuator dan Arduino
Pada Tugas Akhir ini menggunakan dua jenis aktuator sebagai
output/keluaran pada sistem yaitu Motor DC dan Motor Servo. Berikut merupakan
pengujian tingkat keakuratan pada masing – masing aktuator tersebut :
4.2.1 Pengujian Aktuator Motor DC dan Arduino
Pada Tugas Akhir ini menggunakan aktuator Motor DC yang
digunakan untuk menggerakkan roda belakang. Dan dilakukan pengujian
berdasarkan tegangan ideal output Motor DC dengan nilai pengukuran yang
sebenarnya menggunakan Avometer. Berikut merupakan hasil dan pengujian
dapat dilihat pada Gambar 4.5 di bawah ini.
No. Input(Volt) Tegangan
Ideal Output
Motor DC
Nilai
Pengukuran
Sebenarnya
Error (%)
1. 1 1 1 1
2. 2 2 1,98 1,01
3. 3 3 2,96 1,35
4. 4 4 3,99 0,25
5. 5 5 4,95 1,01
Persentase Error 0,924
Tabel 4.8 Hasil Pengujian Motor DC
56
Gambar 4.6 Pengujian Nilai PWM 145 pada Oscilloscope
Berdasarkan data pengujian motor DC seperti yang ditunjukkan Tabel
4.6 diatas dapat dianalisa bahwa terdapat selisih tegangan ideal dengan nilai
pengukuran sebenarnya, dikarenakan beban motor DC tinggi sehingga
mengakibatkan tegangan sebenarnya lebih rendah daripada tegangan ideal.
Dari hasil uji coba motor DC didapatkan rata-rata error sebesar 0,924%.
Pengujian motor dilakukan untuk mengetahui keterkaitan antara PWM
(Pulse Width Modulation) terhadap besarnya tegangan keluaran motor.
Metode pengujian (Pulse Width Modulation) dilakukan menggunakan
Oscilloscope untuk mengetahui lebar pulsa dari nilai Duty Cycle untuk
mengetahui luaran tegangan motor dari hasil masukan PWM. Hasil dari
pengujian menggunakan Oscilloscope yang dibandingkan dengan multimeter
dapat dilihat pada Gambar 4.6 di bawah ini.
Setelah pengujian motor DC, selanjutnya akan dilakukan pengujian
keterkaitan PWM (Pulse With Modulation) terhadap besarnya tegangan
keluaran motor. Metode pengujian PWM menggunakan oscilloscope untuk
mengetahui lebar pulsa dari nilai masukan PWM Arduino. Pada tampilan
oscilloscope akan diketahui Duty Cycle untuk mengetahui keluaran tegangan
motor berdasarkan nilai besaran dari PWM. Dibawah ini merupakan contoh
proses perhitungan dari nilai keluaran sebagai berikut :
57
Diketahui :
Nilai PWM = 145 T/div = 1 ms/div
ton = 1,2 V/div = 1v/div
toff = 1
ttot = ton + toff F = 1
𝑡
= 1,2 + 1 = 1
0,0022
= 2,2ms = 454,54 hz
= 0,0022s
D = 𝑇𝑜𝑛
𝑇𝑡𝑜𝑡 x A A = 1div x
5𝑉
𝑑𝑖𝑣
= 𝑇𝑜𝑛
𝑇𝑡𝑜𝑡 x 100% = 1 x 5V
= 1,2
2,2 x 100% = 5V
= 54,54 %
Vaverage = D x A
= 54,54
100 x 5
= 2,73 V
Keterangan : ton = lebar pulsa ketika high
toff = lebar pulsa ketika low
D = Duty Cycle
A = Amplitudo
Vaverage = Tegangan Keluaran
58
Gambar 4.7 Pengujian Servo dengan Busur
Tabel 4. 9 Hasil Pengukuran Oscilloscope
Pengukuran Oscilloscope Tegangan
Multimeter
(Volt)
Error
(%) No. Nilai PWM
(milisecond)
Ton
(Time
high)
Toff
(Time
low)
A
(Amplitudo)
V
average
(Volt)
1. 0 0 0 5 0,00 0,00 0,00
2. 96 0,8 1,4 5 1,82 1,80 1,11
3. 145 1,2 1 5 2,73 2,75 0,73
4. 227 2 0,3 5 4,35 4,33 0,46
5. 255 2 0 5 5 4,89 2,25
Error rata-rata 0,51
Dari Analisa hasil pengujian nilai PWM sebanyak 5 kali dapat disimpulkan
bahwa presentase error yang diperoleh dari pengujian antara perhitungan
oscilloscope dengan tegangan multimeter yaitu sebesar 0,51%.
4.2.2 Pengujian Aktuator Motor Servo dan Arduino
Pengujian motor servo ini dilakukan dengan cara memasukkan data
pada Arduino. Motor servo diletakkan pada busur 900 (derajat) untuk
mengukur sudut dari perputaran motor servo. Hasil perputaran dari motor
servo akan menunjukkan sudut, kemudian akan dibandingkan dengan sudut
yang ditunjukkan pada busur. Motor servo pada prototipe truk tanpa awak
akan digunakan untuk menggerakkan as pada roda depan. Dapat dilihat pada
Gambar 4.7 di bawah ini.
59
Berikut pada Tabel 4.10 merupakan data hasil pengujian motor servo:
Tabel 4.10 Data Pengujian Motor Servo
No
Sudut pada busur
(derajat)
Sudut hasil perutaran servo
(derajat)
Error (%)
1 0o 0o 0%
2 10o 10o
0%
3 20o 21o
5%
4 25o 24o
4%
5 30o 31o
3,33%
6 40o 41o
2,50%
7 50o 50o
0%
8 60o 62o
3,33%
9 70o 70o
0%
10 90o 89o
1,11%
Rata-rata
error (%)
0.43%
Berdasarkan pengujian yang telah dilakukan terdapat error sudut antara 00
sampai 20 pada putaran servo seperti yang ditunjukkan pada pada proses pengujian
motor servo diperoleh error rata – rata 0,43%. Error yang terjadi pada hasil
percobaan di atas dapat disebabkan oleh arus yang masuk pada servo tersebut kurang
sehingga mempengaruhi gerak dari motor servo serta kualitas mekanik dari servo
yang digunakan.
4.2.3 Pengujian Catu Daya
Pengujian catu daya digunakan untuk mengetahui jumlah tegangan
output yang dihasilkan oleh Baterai Lipo 11.1V, Buck Converter 5Vdc.
Pengujian ini dilakukan dengan membandingkan nilai tegangan keluaran
Baterai Lipo dan Buck Converter tersebut nilai pembacaan Avometer. Berikut
tingkat keakuratan dan presentase error yang didapatkan :
60
Gambar 4.8 Pengujian Baterai Lippo dan Avometer
4.2.3.1 Pengujian Baterai Lipo
Pada Tugas Akhir ini menggunakan baterai lipo dengan tegangan
output sebesar 11.1V DC yang nantinya akan digunakan sebagai sumber
tegangan untuk mengaktifkan aktuator yaitu Motor DC 6V DC. Untuk
mengetahui tingkat keakuratan dan persentase error dari baterai lipo tersebut
maka dilakukan pengujian menggunakan alat ukur Avometer seperti terlihat
pada Gambar 4.8 di bawah ini.
Tabel 4.11 Hasil Pengujian Baterai Lipo
No. Nilai Seharusnya Nilai yang Diperoleh
(Avometer) Error (%)
1. 11.1 V 11,75 V 5.85
2. 11.1 V 11,73 V 5.67
3. 11.1 V 11,72 V 5.58
4. 11.1 V 11,74 V 5.76
5. 11.1 V 11,75 V 5.85
Rata-rata error (%) 5.74
Berdasarkan Hasil Pengujian baterai lipo menunjukkan bahwa presentase error
yang didapatkan dengan membandingkan nilai seharusnya dan nilai yang diperoleh dari
pengukuran menggunakan Avometer yaitu sebesar 5.74%.
61
Gambar 4.9 Pengujian Buck Converter 5V DC
4.2.3.2 Pengujian Buck Converter
Buck Converter merupakan converter penurun tegangan khusus yang
menerapkan sistem SMPS (Switching Mode Power Supply). Buck Converter
pada sistem ini berfungsi untuk menurunkan tegangan Baterai Lipo dari
11.1V DC menjadi 5V DC sebagai sumber tegangan Motor DC dan Motor
Servo serta menurunkan tegangan Baterai Lipo dari 11.1V DC menjadi 5V
DC sebagai sumber tegangan untuk Arduino, Sensor Kompas, Sensor
Loadcell, Sensor Ultrasonik, dan Sensor encoder FC03. Pengujian dilakukan
dengan cara menghubungkan input (+/-) Baterai Lippo ke input (+/-) Buck
Converter, kemudian output Buck Converter tersebut diukur menggunakan
Avometer seperti terlihat pada Gambar 4.9 di bawah ini.
Tabel 4.12 Hasil Pengujian Buck Converter
No. Nilai Seharusnya Nilai yang Diperoleh (Avometer) Rata-rata Error (%)
11,99 V
12,1 V
1. 12 V 12,0 V 12,04 V 0,3
12,0 V
12,1 V
62
Tabel 4. 13 Lanjutan Hasil Pengujian Buck Converter
No. Nilai Seharusnya Nilai yang Diperoleh (Avometer) Rata-rata Error (%)
5 V
5,01 V
2. 5 V 5,0 V 5 V 0
5,1 V
4,9 V
Rata-rata error (%) 0,15
Berdasarkan Hasil Pengujian Buck Converter menunjukkan bahwa
persentase error yang didapatkan dengan membandingkan nilai seharusnya dan
nilai yang diperoleh dari pengukuran menggunakan Avometer yaitu sebesar
0,15%.
4.3 Pengujian Metode Fuzzy Logic
Pada tugas akhir ini menggunakan metode fuzzy sebagai pengendalinya. Sistem
ini menggunakan 4 input (arah dan kompas) dan 1 output (sevo). Hasil pengujian fuzzy
pada Tugas Akhir ini dilakukan dengan toolbox.
Gambar 4. 10 Input dan Output fuzzy logic
63
4.3.1 Pengujian Menggunakan Toolbox Matlab
Dari hasil pengujian fuzzy pada toolbox menunjukkan bahwa input kompas
= -10, ultrakiri = 10
Gambar 4. 11 Pengujian Toolbox Matlab
4.3.2 Pengujian Menggunakan Perhitungan
a. Fuzzifikasi
Fuzzifikasi yang merupakan proses memetakan nilai input kedalam nilai
keanggotaan yang memiliki interval antara 0 hinga 1. Salah satu cara yang
dapat digunakan adalah dengan melalui pendekatan fungsi. Contoh kasus :
Kompas = -5 ;
(-10;0), (0;1) => (0;0), (-10;1)
m = 𝑦2−𝑦1
𝑥2−𝑥1 =
1−0
0−10 =
1
−10 => m =
𝑦2−𝑦1
𝑥2−𝑥1 =
1−0
0−10 =
1
−10
c = y – mx => c = y - mx
= 0 - 1
−10 x -10 = 1 => = 0 -
1
−10 x -10 = 1
64
y = mx + c => y = mx + c
= 1
−10 x -5 + 1 =
1
−10 x -5 + 1
= - 1
2 + 1 = -
1
2 + 1
= 0,5 = 0,5
Ultrakiri1 = 21 ;
(18;0), (24;1) => (24;0), (18;1)
m = 𝑦2−𝑦1
𝑥2−𝑥1 =
1−0
24−18 =
1
6 => m =
𝑦2−𝑦1
𝑥2−𝑥1
c = y – mx => c = y - mx
= 0 - 1
6 x 18 = -3 => = 0 -
1
−6 x 24 = 4
y = mx + c => y = mx + c
= 1
6 x 21 + (-3) =
1
−6 x 21 + 4
= 3,5+(-3) = -3,5 + 4
= 0,5 = 0,5
b. Defuzzifikasi
Proses ini digunakan untuk menentukan nilai keanggotaan dari output.
Nilai servo = (90)
Jumlah pembilang = (90 x 0,5) + (90 x 0,5) + (90 x 0,5) + (90 x 0,5)
Jumlah penyebut = 45 + 45 + 45 + 45
Output = 𝐽𝑢𝑚𝑙𝑎ℎ 𝑃𝑒𝑚𝑏𝑖𝑙𝑎𝑛𝑔
𝐽𝑢𝑚𝑙𝑎ℎ 𝑃𝑒𝑛𝑦𝑒𝑏𝑢𝑡
= 45+45+45+45
0,5+0,5+0,5+0,5
= 180
2 = 90 (servo)
65
4.4 Pengujian Sistem
Tabel 4.14 Pengujian Sistem Kendali berjalannya Truk tanpa Awak
Percobaan Rute Berhasil Tidak
1
Waypoint 1 ke 2 √
Waypoint 2 ke 3 √
Waypoint 3 ke 4 √
2
Waypoint 1 ke 2 √
Waypoint 2 ke 3 √
Waypoint 3 ke 4 √
3
Waypoint 1 ke 2 √
Waypoint 2 ke 3 √
Waypoint 3 ke 4 √
4
Waypoint 1 ke 2 √
Waypoint 2 ke 3 √
Waypoint 3 ke 4 √
5
Waypoint 1 ke 2 √
Waypoint 2 ke 3 √
Waypoint 3 ke 4 √
6
Waypoint 1 ke 2 √
Waypoint 2 ke 3 √
Waypoint 3 ke 4 √
7
Waypoint 1 ke 2 √
Waypoint 2 ke 3 √
Waypoint 3 ke 4 √
8
Waypoint 1 ke 2 √
Waypoint 2 ke 3 √
Waypoint 3 ke 4 √
9
Waypoint 1 ke 2 √
Waypoint 2 ke 3 √
Waypoint 3 ke 4 √
10
Waypoint 1 ke 2 √
Waypoint 2 ke 3 √
Waypoint 3 ke 4 √
Kesimpulan berdasarkan hasil data percobaan pada Tabel 4.14 pengujian
dikatakan berhasil apabila prototipe telah mampu mencapai waypoint – waypoint
yang telah ditentukan jarak tempuhnya, waypoint 1 ke waypoint 2, waypoint 2 ke
waypoint 3, dan waypoint 3 ke waypoint 4. Dan dikatakan tidak berhasil apabila tidak
sampai pada waypoint – waypoint yang telah ditentukan. Dapat dilihat pada Gambar
4.12, 4.13 dan 4.14 di bawah ini.
66
Pada Gambar 4.12 merupakan pergerakan prototipe dari waypoint 1 ke waypoint 2.
Gambar 4.12 Pergerakan Prototipe dari Waypoint 1 ke Waypoint 2
Pada Gambar 4.13 merupakan pergerakan prototipe dari waypoint 2 ke waypoint 3.
Gambar 4.13 Pergerakan Prototipe dari Waypoint 2 ke Waypoint 3
Pada Gambar 4.14 merupakan pergerakan prototipe dari waypoint 3 ke waypoint 4.
Gambar 4.14 Pergerakan Prototipe dari Waypoint 3 ke Waypoint 4
67
➢ Waypoint 1 ke 2 : 10
10 x 100 = 100%
➢ Waypoint 2 ke 3 : 8
10 x 100 = 80%
➢ Waypoint 3 ke 4 :7
10 x 100 = 70%
Jadi, Total Keberhasilan keseluruhan Sistem Kendali mencapai tiap - tiap
waypoint = 83,3 %.
Gambar 4.15 Jalur Tracking Prototipe Truk Tanpa Awak
68
Halaman Sengaja Dikosongkan
69
BAB 5
KESIMPULAN DAN SARAN
5.1 Kesimpulan
Kesimpulan dari penelitian ini adalah sebagai berikut.
1) Tingkat akurasi sensor dan kinerja aktuator yang digunakan pada prototipe
truk tanpa awak rata- rata memiliki tingkat keakuratan yang cukup akurat
dan masih memiliki error yang kecil.
2) Keakuratan untuk berjalannya sistem prototipe truk tanpa awak cukup baik
dengan menghitung jarak tempuh menggunakan Encoder FC03, dengan
tingkat keberhasilan 83,3% yang dapat dilihat pada Tabel 4.14.
3) Monitoring sensor menggunakan Android dapat dibuat, namun untuk
pembacaan nilai sensor pada HP Android tergantung dengan sinyal wifi
yang digunakan.
5.2 Saran
Berdasarkan kesimpulan yang telah diuraikan sebelumnya, adapun saran untuk
menyempurnakan Tugas Akhir ini dengan tujuan menambah performa dan
kualitas alat yaitu :
1) Mengatur kendali servo dan kompas menggunakan metode kontrol yang
lebih cocok sehingga dapat menghasilkan hasil output yang lebih sesuai.
2) Dapat membuat aplikasi monitoring yang lebih baik lagi dan tidak
terkendala dengan sinyal wifi.
70
Halaman Sengaja Dikosongkan
71
DAFTAR PUSTAKA
Aprilianto, Hugo. Dan Taufikurrahman, M. 2017. “Penerapan Sistem
Navigasi Sensor Kompas pada Robot Beroda”. ISSN, STMIK Banjarbaru 2017
Health and Safety Authority, 2015. Guidance for Employers and Employees
on Night and Shift Work. www.hsa.ie/eng/occupational_Health
Nirwani, Affinannisa T. 2018. “Simulator Kursi Roda Otomatis dengan
sensor flex Berbasis Mikrokontroller”, Tugas Akhir, Universitas Negeri Yogyakarta
2018.
Prabarini, Puspa. 2018. “Pengaruh Iklim Keselamatan Kerja dan Big Five
Personality Terhadap Perilaku Keselamatan Karyawan di PT. Terminal Teluk
Lamong”, Tesis, Universitas Airlangga 2018.
Ramadhan, Fareza Rizky. Nugraha, Ramdhan. Dan Estananto.2017.
“Perancangan dan Implementasi Kontrol Posisi Robot Bawah Air menggunakan
Metode Fuzzy Logic Control”, ISSN, Universitas Telkom 2017.
Safaat H, Nazrudin. 2014. “Pemrograman Aplikasi Mobile Smartphone dan
Tablet PC Berbasis Android ”, Informatika Bandung 2014.
Saraswati, Ayu W. Dan Paskarini, Indriati. 2018. “Hubungan Gangguan
Tidur pada Pekerja Shift dengan kejadian Kecelakaan Kerja di Terminal Petikemas”,
Jurnal, Universitas Airlangga 2018.
72
Halaman Sengaja Dikosongkan
73
LAMPIRAN – LAMPIRAN
#include <Servo.h>
Servo motorServo;
#include "fis_header.h"
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_HMC5883_U.h>
Adafruit_HMC5883_Unified mag = Adafruit_HMC5883_Unified(12345);
#include "HX711.h"
#define DOUT 9
#define CLK 8
HX711 scale(DOUT, CLK);
float calibration_factor = 344.10;
int GRAM;
int UltrasonikTrig1 = 52;
int UltrasonikEcho1 = 50;
int UltrasonikTrig2 = 5;
int UltrasonikEcho2 = 4;
int UltrasonikTrig3 = 6;
int UltrasonikEcho3 = 7;
float headingDegrees;
unsigned long endTime;
/* www.nyebarilmu.com */
74
long duration1, duration2, duration3 ;
//long inchi1, inchi2, inchi3;
long cm1, cm2, cm3 ;
//mendefinisikan pin yang digunakan untuk control pin
int IN_1 = 14;
int IN_2 = 15;
int IN_3 = 16;
int IN_4 = 17;
int ENA = 10;
int ENB = 2;
int encoder_pin = 3;
int state;
volatile int c = 0;
int GRAM2;
static volatile unsigned long debounce = 0; // Tiempo del rebote.
/////////////////////////////////fuzzy
// Number of inputs to the fuzzy inference system
const int fis_gcI = 4;
// 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 = 135;
75
FIS_TYPE g_fisInput[fis_gcI];
FIS_TYPE g_fisOutput[fis_gcO];
/////////////////////////////////fuzzy
float data;
int flag1;
void setup()
{
Serial.begin(9600);
pinMode(UltrasonikTrig1, OUTPUT);
pinMode(UltrasonikTrig2, OUTPUT);
pinMode(UltrasonikTrig3, OUTPUT);
pinMode(UltrasonikEcho1, INPUT);
pinMode(UltrasonikEcho2, INPUT);
pinMode(UltrasonikEcho3, INPUT);
Serial.println("HMC5883 Magnetometer Test"); Serial.println("");
motorServo.attach(13); // servo Pada Pin digital 10
motorServo.write(90);
if (!mag.begin())
{
/* There was a problem detecting the HMC5883 ... check your connections */
Serial.println("Ooops, no HMC5883 detected ... Check your wiring!");
while (1);
}
scale.set_scale();
76
scale.tare();
//mendefinisikan control pin sebagai output
pinMode(IN_1, OUTPUT);
pinMode(IN_2, OUTPUT);
pinMode(IN_3, OUTPUT);
pinMode(IN_4, OUTPUT);
state = 3;
pinMode(3, INPUT);
attachInterrupt(digitalPinToInterrupt(3), counter, RISING);
}
void loop() {
analogWrite(ENA, 150);
analogWrite(ENB, 150);
jarak();
magnet();
berat();
if (GRAM >= 150 ) {
state = 1;
}
if (GRAM <= 150 ) {
state = 3;
}
if ( c >= 95 && c <=105) {
motorServo.write(110);
77
state = 1;
c=105;
delay(1000);
//waypoint1
} else if (c >=115 && c<=210) {
motorServo.write(90);
flag1 = 1;
if(flag1 == 1){
int defkom = 262;
data = headingDegrees - defkom;
// Read Input: kompas
g_fisInput[0] = data;
// Read Input: ultrakiri
g_fisInput[1] = cm1;
// Read Input: ultrakanan
g_fisInput[2] = cm2;
// Read Input: ultradepan
g_fisInput[3] = cm3;
motorServo.write(g_fisOutput[0]);
fis_evaluate();
flag1 = 0;
}
} else if (c >=210 && c <=220) {
motorServo.write(110);
c=220;
delay(1000);
78
//2
} else if (c >= 220 && c <=315) {
motorServo.write(90);
flag1 = 1;
if(flag1 == 1){
int defkom = 166;
data = headingDegrees - defkom;
// Read Input: kompas
g_fisInput[0] = data;
// Read Input: ultrakiri
g_fisInput[1] = cm1;
// Read Input: ultrakanan
g_fisInput[2] = cm2;
// Read Input: ultradepan
g_fisInput[3] = cm3;
motorServo.write(g_fisOutput[0]);
fis_evaluate();
flag1 = 0;
}
} else if (c>=315) {
motorServo.write(90);
state = 3;
if (state == 3){
int defkom = 45;
data = headingDegrees - defkom;
// Read Input: kompas
g_fisInput[0] = data;
79
// Read Input: ultrakiri
g_fisInput[1] = cm1;
// Read Input: ultrakanan
g_fisInput[2] = cm2;
// Read Input: ultradepan
g_fisInput[3] = cm3;
// g_fisOutput[0] = 0;
motorServo.write(g_fisOutput[0]);
fis_evaluate();
}
}
if (state == 1) {
maju();
} else if (state == 2) {
mundur();
} else if (state == 3) {
mati();
}
Serial.print(GRAM);
Serial.print("\t c= ");
Serial.print(c,DEC);
Serial.print("\t");
Serial.print("Heading (degrees): ");
Serial.print(headingDegrees);
Serial.print(cm1);
Serial.print(" ");
80
Serial.print(cm2);
Serial.print(" ");
Serial.println(cm3);
delay(500);
}
long microsecondsKeCenti(long microseconds)
{
return microseconds / 29 / 2;
}
void counter(){
if( digitalRead (encoder_pin) && (micros()-debounce > 500) && digitalRead
(encoder_pin) ) {
// Vuelve a comprobar que el encoder envia una señal buena y luego comprueba que el
tiempo es superior a 1000 microsegundos y vuelve a comprobar que la señal es correcta.
debounce = micros(); // Almacena el tiempo para comprobar que no contamos el rebote
que hay en la señal.
c++;} // Suma el pulso bueno que entra.
else ;
if (c >= 190) {
state = 1;
}
}
//***********************************************************************
// Support functions for Fuzzy Inference System
//***********************************************************************
// Triangular Member Function
81
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);
}
// 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);
}
FIS_TYPE fis_min(FIS_TYPE a, FIS_TYPE b)
{
return min(a, b);
}
FIS_TYPE fis_max(FIS_TYPE a, FIS_TYPE b)
{
return max(a, b);
}
FIS_TYPE fis_prod(FIS_TYPE a, FIS_TYPE b)
82
{
return (a * b);
}
FIS_TYPE fis_sum(FIS_TYPE a, FIS_TYPE b)
{
return (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[] =
83
{
fis_trimf, fis_trapmf
};
// Count of member function for each Input
int fis_gIMFCount[] = { 5, 3, 3, 3 };
// Count of member function for each Output
int fis_gOMFCount[] = { 1 };
// Coefficients for the Input Member Functions
FIS_TYPE fis_gMFI0Coeff1[] = { -20, -10, 0 };
FIS_TYPE fis_gMFI0Coeff2[] = { -10, 0, 10 };
FIS_TYPE fis_gMFI0Coeff3[] = { 10, 20, 30 };
FIS_TYPE fis_gMFI0Coeff4[] = { -30, -20, -10 };
FIS_TYPE fis_gMFI0Coeff5[] = { 0, 10, 20 };
FIS_TYPE* fis_gMFI0Coeff[] = { fis_gMFI0Coeff1, fis_gMFI0Coeff2, fis_gMFI0Coeff3,
fis_gMFI0Coeff4, fis_gMFI0Coeff5 };
FIS_TYPE fis_gMFI1Coeff1[] = { 9, 18, 27 };
FIS_TYPE fis_gMFI1Coeff2[] = { 18, 27, 35, 35 };
FIS_TYPE fis_gMFI1Coeff3[] = { 0, 0, 9, 18 };
FIS_TYPE* fis_gMFI1Coeff[] = { fis_gMFI1Coeff1, fis_gMFI1Coeff2, fis_gMFI1Coeff3 };
FIS_TYPE fis_gMFI2Coeff1[] = { 0, 0, 9, 18 };
FIS_TYPE fis_gMFI2Coeff2[] = { 9, 18, 27 };
FIS_TYPE fis_gMFI2Coeff3[] = { 18, 27, 35, 35 };
FIS_TYPE* fis_gMFI2Coeff[] = { fis_gMFI2Coeff1, fis_gMFI2Coeff2, fis_gMFI2Coeff3 };
FIS_TYPE fis_gMFI3Coeff1[] = { 30, 60, 90 };
FIS_TYPE fis_gMFI3Coeff2[] = { 60, 90, 120, 120 };
FIS_TYPE fis_gMFI3Coeff3[] = { 0, 0, 30, 60 };
FIS_TYPE* fis_gMFI3Coeff[] = { fis_gMFI3Coeff1, fis_gMFI3Coeff2, fis_gMFI3Coeff3 };
FIS_TYPE** fis_gMFICoeff[] = { fis_gMFI0Coeff, fis_gMFI1Coeff, fis_gMFI2Coeff,
fis_gMFI3Coeff };
84
// Coefficients for the Output Member Functions
FIS_TYPE fis_gMFO0Coeff1[] = { 0, 0, 0, 0, 90 };
FIS_TYPE* fis_gMFO0Coeff[] = { fis_gMFO0Coeff1 };
FIS_TYPE** fis_gMFOCoeff[] = { fis_gMFO0Coeff };
// Input membership function set
int fis_gMFI0[] = { 0, 0, 0, 0, 0 };
int fis_gMFI1[] = { 0, 1, 1 };
int fis_gMFI2[] = { 1, 0, 1 };
int fis_gMFI3[] = { 0, 1, 1 };
int* fis_gMFI[] = { fis_gMFI0, fis_gMFI1, fis_gMFI2, fis_gMFI3};
// Output membership function set
int* fis_gMFO[] = {};
// Rule Weights
FIS_TYPE fis_gRWeight[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
// Rule Type
int fis_gRType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
// Rule Inputs
int fis_gRI0[] = { 1, 1, 1, 1 };
int fis_gRI1[] = { 1, 1, 1, 2 };
85
int fis_gRI2[] = { 1, 1, 1, 3 };
int fis_gRI3[] = { 1, 1, 2, 1 };
int fis_gRI4[] = { 1, 1, 2, 2 };
int fis_gRI5[] = { 1, 1, 2, 3 };
int fis_gRI6[] = { 1, 1, 3, 1 };
int fis_gRI7[] = { 1, 1, 3, 2 };
int fis_gRI8[] = { 1, 1, 3, 3 };
int fis_gRI9[] = { 1, 2, 1, 1 };
int fis_gRI10[] = { 1, 2, 1, 2 };
int fis_gRI11[] = { 1, 2, 1, 3 };
int fis_gRI12[] = { 1, 2, 2, 1 };
int fis_gRI13[] = { 1, 2, 2, 2 };
int fis_gRI14[] = { 1, 2, 2, 3 };
int fis_gRI15[] = { 1, 2, 3, 1 };
int fis_gRI16[] = { 1, 2, 3, 2 };
int fis_gRI17[] = { 1, 2, 3, 3 };
int fis_gRI18[] = { 1, 3, 1, 1 };
int fis_gRI19[] = { 1, 3, 1, 2 };
int fis_gRI20[] = { 1, 3, 1, 3 };
int fis_gRI21[] = { 1, 3, 2, 1 };
int fis_gRI22[] = { 1, 3, 2, 2 };
int fis_gRI23[] = { 1, 3, 2, 3 };
int fis_gRI24[] = { 1, 3, 3, 1 };
int fis_gRI25[] = { 1, 3, 3, 2 };
int fis_gRI26[] = { 1, 3, 3, 3 };
int fis_gRI27[] = { 2, 1, 1, 1 };
int fis_gRI28[] = { 2, 1, 1, 2 };
int fis_gRI29[] = { 2, 1, 1, 3 };
int fis_gRI30[] = { 2, 1, 2, 1 };
int fis_gRI31[] = { 2, 1, 2, 2 };
int fis_gRI32[] = { 2, 1, 2, 3 };
int fis_gRI33[] = { 2, 1, 3, 1 };
86
int fis_gRI34[] = { 2, 1, 3, 2 };
int fis_gRI35[] = { 2, 1, 3, 3 };
int fis_gRI36[] = { 2, 2, 1, 1 };
int fis_gRI37[] = { 2, 2, 1, 2 };
int fis_gRI38[] = { 2, 2, 1, 3 };
int fis_gRI39[] = { 2, 2, 2, 1 };
int fis_gRI40[] = { 2, 2, 2, 2 };
int fis_gRI41[] = { 2, 2, 2, 3 };
int fis_gRI42[] = { 2, 2, 3, 1 };
int fis_gRI43[] = { 2, 2, 3, 2 };
int fis_gRI44[] = { 2, 2, 3, 3 };
int fis_gRI45[] = { 2, 3, 1, 1 };
int fis_gRI46[] = { 2, 3, 1, 2 };
int fis_gRI47[] = { 2, 3, 1, 3 };
int fis_gRI48[] = { 2, 3, 2, 1 };
int fis_gRI49[] = { 2, 3, 2, 2 };
int fis_gRI50[] = { 2, 3, 2, 3 };
int fis_gRI51[] = { 2, 3, 3, 1 };
int fis_gRI52[] = { 2, 3, 3, 2 };
int fis_gRI53[] = { 2, 3, 3, 3 };
int fis_gRI54[] = { 3, 1, 1, 1 };
int fis_gRI55[] = { 3, 1, 1, 2 };
int fis_gRI56[] = { 3, 1, 1, 3 };
int fis_gRI57[] = { 3, 1, 2, 1 };
int fis_gRI58[] = { 3, 1, 2, 2 };
int fis_gRI59[] = { 3, 1, 2, 3 };
int fis_gRI60[] = { 3, 1, 3, 1 };
int fis_gRI61[] = { 3, 1, 3, 2 };
int fis_gRI62[] = { 3, 1, 3, 3 };
int fis_gRI63[] = { 3, 2, 1, 1 };
int fis_gRI64[] = { 3, 2, 1, 2 };
int fis_gRI65[] = { 3, 2, 1, 3 };
87
int fis_gRI66[] = { 3, 2, 2, 1 };
int fis_gRI67[] = { 3, 2, 2, 2 };
int fis_gRI68[] = { 3, 2, 2, 3 };
int fis_gRI69[] = { 3, 2, 3, 1 };
int fis_gRI70[] = { 3, 2, 3, 2 };
int fis_gRI71[] = { 3, 2, 3, 3 };
int fis_gRI72[] = { 3, 3, 1, 1 };
int fis_gRI73[] = { 3, 3, 1, 2 };
int fis_gRI74[] = { 3, 3, 1, 3 };
int fis_gRI75[] = { 3, 3, 2, 1 };
int fis_gRI76[] = { 3, 3, 2, 2 };
int fis_gRI77[] = { 3, 3, 2, 3 };
int fis_gRI78[] = { 3, 3, 3, 1 };
int fis_gRI79[] = { 3, 3, 3, 2 };
int fis_gRI80[] = { 3, 3, 3, 3 };
int fis_gRI81[] = { 4, 1, 1, 1 };
int fis_gRI82[] = { 4, 1, 1, 2 };
int fis_gRI83[] = { 4, 1, 1, 3 };
int fis_gRI84[] = { 4, 1, 2, 1 };
int fis_gRI85[] = { 4, 1, 2, 2 };
int fis_gRI86[] = { 4, 1, 2, 3 };
int fis_gRI87[] = { 4, 1, 3, 1 };
int fis_gRI88[] = { 4, 1, 3, 2 };
int fis_gRI89[] = { 4, 1, 3, 3 };
int fis_gRI90[] = { 4, 2, 1, 1 };
int fis_gRI91[] = { 4, 2, 1, 2 };
int fis_gRI92[] = { 4, 2, 1, 3 };
int fis_gRI93[] = { 4, 2, 2, 1 };
int fis_gRI94[] = { 4, 2, 2, 2 };
int fis_gRI95[] = { 4, 2, 2, 3 };
int fis_gRI96[] = { 4, 2, 3, 1 };
int fis_gRI97[] = { 4, 2, 3, 2 };
88
int fis_gRI98[] = { 4, 2, 3, 3 };
int fis_gRI99[] = { 4, 3, 1, 1 };
int fis_gRI100[] = { 4, 3, 1, 2 };
int fis_gRI101[] = { 4, 3, 1, 3 };
int fis_gRI102[] = { 4, 3, 2, 1 };
int fis_gRI103[] = { 4, 3, 2, 2 };
int fis_gRI104[] = { 4, 3, 2, 3 };
int fis_gRI105[] = { 4, 3, 3, 1 };
int fis_gRI106[] = { 4, 3, 3, 2 };
int fis_gRI107[] = { 4, 3, 3, 3 };
int fis_gRI108[] = { 5, 1, 1, 1 };
int fis_gRI109[] = { 5, 1, 1, 2 };
int fis_gRI110[] = { 5, 1, 1, 3 };
int fis_gRI111[] = { 5, 1, 2, 1 };
int fis_gRI112[] = { 5, 1, 2, 2 };
int fis_gRI113[] = { 5, 1, 2, 3 };
int fis_gRI114[] = { 5, 1, 3, 1 };
int fis_gRI115[] = { 5, 1, 3, 2 };
int fis_gRI116[] = { 5, 1, 3, 3 };
int fis_gRI117[] = { 5, 2, 1, 1 };
int fis_gRI118[] = { 5, 2, 1, 2 };
int fis_gRI119[] = { 5, 2, 1, 3 };
int fis_gRI120[] = { 5, 2, 2, 1 };
int fis_gRI121[] = { 5, 2, 2, 2 };
int fis_gRI122[] = { 5, 2, 2, 3 };
int fis_gRI123[] = { 5, 2, 3, 1 };
int fis_gRI124[] = { 5, 2, 3, 2 };
int fis_gRI125[] = { 5, 2, 3, 3 };
int fis_gRI126[] = { 5, 3, 1, 1 };
int fis_gRI127[] = { 5, 3, 1, 2 };
int fis_gRI128[] = { 5, 3, 1, 3 };
int fis_gRI129[] = { 5, 3, 2, 1 };
89
int fis_gRI130[] = { 5, 3, 2, 2 };
int fis_gRI131[] = { 5, 3, 2, 3 };
int fis_gRI132[] = { 5, 3, 3, 1 };
int fis_gRI133[] = { 5, 3, 3, 2 };
int fis_gRI134[] = { 5, 3, 3, 3 };
int* fis_gRI[] = { fis_gRI0, fis_gRI1, fis_gRI2, fis_gRI3, fis_gRI4, fis_gRI5, fis_gRI6,
fis_gRI7, fis_gRI8, fis_gRI9, fis_gRI10, fis_gRI11, fis_gRI12, fis_gRI13, fis_gRI14,
fis_gRI15, fis_gRI16, fis_gRI17, fis_gRI18, fis_gRI19, fis_gRI20, fis_gRI21, fis_gRI22,
fis_gRI23, fis_gRI24, fis_gRI25, fis_gRI26, fis_gRI27, fis_gRI28, fis_gRI29, fis_gRI30,
fis_gRI31, fis_gRI32, fis_gRI33, fis_gRI34, fis_gRI35, fis_gRI36, fis_gRI37, fis_gRI38,
fis_gRI39, fis_gRI40, fis_gRI41, fis_gRI42, fis_gRI43, fis_gRI44, fis_gRI45, fis_gRI46,
fis_gRI47, fis_gRI48, fis_gRI49, fis_gRI50, fis_gRI51, fis_gRI52, fis_gRI53, fis_gRI54,
fis_gRI55, fis_gRI56, fis_gRI57, fis_gRI58, fis_gRI59, fis_gRI60, fis_gRI61, fis_gRI62,
fis_gRI63, fis_gRI64, fis_gRI65, fis_gRI66, fis_gRI67, fis_gRI68, fis_gRI69, fis_gRI70,
fis_gRI71, fis_gRI72, fis_gRI73, fis_gRI74, fis_gRI75, fis_gRI76, fis_gRI77, fis_gRI78,
fis_gRI79, fis_gRI80, fis_gRI81, fis_gRI82, fis_gRI83, fis_gRI84, fis_gRI85, fis_gRI86,
fis_gRI87, fis_gRI88, fis_gRI89, fis_gRI90, fis_gRI91, fis_gRI92, fis_gRI93, fis_gRI94,
fis_gRI95, fis_gRI96, fis_gRI97, fis_gRI98, fis_gRI99, fis_gRI100, fis_gRI101, fis_gRI102,
fis_gRI103, fis_gRI104, fis_gRI105, fis_gRI106, fis_gRI107, fis_gRI108, fis_gRI109,
fis_gRI110, fis_gRI111, fis_gRI112, fis_gRI113, fis_gRI114, fis_gRI115, fis_gRI116,
fis_gRI117, fis_gRI118, fis_gRI119, fis_gRI120, fis_gRI121, fis_gRI122, fis_gRI123,
fis_gRI124, fis_gRI125, fis_gRI126, fis_gRI127, fis_gRI128, fis_gRI129, fis_gRI130,
fis_gRI131, fis_gRI132, fis_gRI133, fis_gRI134 };
// Rule Outputs
int fis_gRO0[] = { 1 };
int fis_gRO1[] = { 1 };
int fis_gRO2[] = { 1 };
int fis_gRO3[] = { 1 };
int fis_gRO4[] = { 1 };
int fis_gRO5[] = { 1 };
int fis_gRO6[] = { 1 };
90
int fis_gRO7[] = { 1 };
int fis_gRO8[] = { 1 };
int fis_gRO9[] = { 1 };
int fis_gRO10[] = { 1 };
int fis_gRO11[] = { 1 };
int fis_gRO12[] = { 1 };
int fis_gRO13[] = { 1 };
int fis_gRO14[] = { 1 };
int fis_gRO15[] = { 1 };
int fis_gRO16[] = { 1 };
int fis_gRO17[] = { 1 };
int fis_gRO18[] = { 1 };
int fis_gRO19[] = { 1 };
int fis_gRO20[] = { 1 };
int fis_gRO21[] = { 1 };
int fis_gRO22[] = { 1 };
int fis_gRO23[] = { 1 };
int fis_gRO24[] = { 1 };
int fis_gRO25[] = { 1 };
int fis_gRO26[] = { 1 };
int fis_gRO27[] = { 1 };
int fis_gRO28[] = { 1 };
int fis_gRO29[] = { 1 };
int fis_gRO30[] = { 1 };
int fis_gRO31[] = { 1 };
int fis_gRO32[] = { 1 };
int fis_gRO33[] = { 1 };
int fis_gRO34[] = { 1 };
int fis_gRO35[] = { 1 };
int fis_gRO36[] = { 1 };
int fis_gRO37[] = { 1 };
int fis_gRO38[] = { 1 };
91
int fis_gRO39[] = { 1 };
int fis_gRO40[] = { 1 };
int fis_gRO41[] = { 1 };
int fis_gRO42[] = { 1 };
int fis_gRO43[] = { 1 };
int fis_gRO44[] = { 1 };
int fis_gRO45[] = { 1 };
int fis_gRO46[] = { 1 };
int fis_gRO47[] = { 1 };
int fis_gRO48[] = { 1 };
int fis_gRO49[] = { 1 };
int fis_gRO50[] = { 1 };
int fis_gRO51[] = { 1 };
int fis_gRO52[] = { 1 };
int fis_gRO53[] = { 1 };
int fis_gRO54[] = { 1 };
int fis_gRO55[] = { 1 };
int fis_gRO56[] = { 1 };
int fis_gRO57[] = { 1 };
int fis_gRO58[] = { 1 };
int fis_gRO59[] = { 1 };
int fis_gRO60[] = { 1 };
int fis_gRO61[] = { 1 };
int fis_gRO62[] = { 1 };
int fis_gRO63[] = { 1 };
int fis_gRO64[] = { 1 };
int fis_gRO65[] = { 1 };
int fis_gRO66[] = { 1 };
int fis_gRO67[] = { 1 };
int fis_gRO68[] = { 1 };
int fis_gRO69[] = { 1 };
int fis_gRO70[] = { 1 };
92
int fis_gRO71[] = { 1 };
int fis_gRO72[] = { 1 };
int fis_gRO73[] = { 1 };
int fis_gRO74[] = { 1 };
int fis_gRO75[] = { 1 };
int fis_gRO76[] = { 1 };
int fis_gRO77[] = { 1 };
int fis_gRO78[] = { 1 };
int fis_gRO79[] = { 1 };
int fis_gRO80[] = { 1 };
int fis_gRO81[] = { 1 };
int fis_gRO82[] = { 1 };
int fis_gRO83[] = { 1 };
int fis_gRO84[] = { 1 };
int fis_gRO85[] = { 1 };
int fis_gRO86[] = { 1 };
int fis_gRO87[] = { 1 };
int fis_gRO88[] = { 1 };
int fis_gRO89[] = { 1 };
int fis_gRO90[] = { 1 };
int fis_gRO91[] = { 1 };
int fis_gRO92[] = { 1 };
int fis_gRO93[] = { 1 };
int fis_gRO94[] = { 1 };
int fis_gRO95[] = { 1 };
int fis_gRO96[] = { 1 };
int fis_gRO97[] = { 1 };
int fis_gRO98[] = { 1 };
int fis_gRO99[] = { 1 };
int fis_gRO100[] = { 1 };
int fis_gRO101[] = { 1 };
int fis_gRO102[] = { 1 };
93
int fis_gRO103[] = { 1 };
int fis_gRO104[] = { 1 };
int fis_gRO105[] = { 1 };
int fis_gRO106[] = { 1 };
int fis_gRO107[] = { 1 };
int fis_gRO108[] = { 1 };
int fis_gRO109[] = { 1 };
int fis_gRO110[] = { 1 };
int fis_gRO111[] = { 1 };
int fis_gRO112[] = { 1 };
int fis_gRO113[] = { 1 };
int fis_gRO114[] = { 1 };
int fis_gRO115[] = { 1 };
int fis_gRO116[] = { 1 };
int fis_gRO117[] = { 1 };
int fis_gRO118[] = { 1 };
int fis_gRO119[] = { 1 };
int fis_gRO120[] = { 1 };
int fis_gRO121[] = { 1 };
int fis_gRO122[] = { 1 };
int fis_gRO123[] = { 1 };
int fis_gRO124[] = { 1 };
int fis_gRO125[] = { 1 };
int fis_gRO126[] = { 1 };
int fis_gRO127[] = { 1 };
int fis_gRO128[] = { 1 };
int fis_gRO129[] = { 1 };
int fis_gRO130[] = { 1 };
int fis_gRO131[] = { 1 };
int fis_gRO132[] = { 1 };
int fis_gRO133[] = { 1 };
int fis_gRO134[] = { 1 };
94
int* fis_gRO[] = { fis_gRO0, fis_gRO1, fis_gRO2, fis_gRO3, fis_gRO4, fis_gRO5,
fis_gRO6, fis_gRO7, fis_gRO8, fis_gRO9, fis_gRO10, fis_gRO11, fis_gRO12, fis_gRO13,
fis_gRO14, fis_gRO15, fis_gRO16, fis_gRO17, fis_gRO18, fis_gRO19, fis_gRO20,
fis_gRO21, fis_gRO22, fis_gRO23, fis_gRO24, fis_gRO25, fis_gRO26, fis_gRO27,
fis_gRO28, fis_gRO29, fis_gRO30, fis_gRO31, fis_gRO32, fis_gRO33, fis_gRO34,
fis_gRO35, fis_gRO36, fis_gRO37, fis_gRO38, fis_gRO39, fis_gRO40, fis_gRO41,
fis_gRO42, fis_gRO43, fis_gRO44, fis_gRO45, fis_gRO46, fis_gRO47, fis_gRO48,
fis_gRO49, fis_gRO50, fis_gRO51, fis_gRO52, fis_gRO53, fis_gRO54, fis_gRO55,
fis_gRO56, fis_gRO57, fis_gRO58, fis_gRO59, fis_gRO60, fis_gRO61, fis_gRO62,
fis_gRO63, fis_gRO64, fis_gRO65, fis_gRO66, fis_gRO67, fis_gRO68, fis_gRO69,
fis_gRO70, fis_gRO71, fis_gRO72, fis_gRO73, fis_gRO74, fis_gRO75, fis_gRO76,
fis_gRO77, fis_gRO78, fis_gRO79, fis_gRO80, fis_gRO81, fis_gRO82, fis_gRO83,
fis_gRO84, fis_gRO85, fis_gRO86, fis_gRO87, fis_gRO88, fis_gRO89, fis_gRO90,
fis_gRO91, fis_gRO92, fis_gRO93, fis_gRO94, fis_gRO95, fis_gRO96, fis_gRO97,
fis_gRO98, fis_gRO99, fis_gRO100, fis_gRO101, fis_gRO102, fis_gRO103, fis_gRO104,
fis_gRO105, fis_gRO106, fis_gRO107, fis_gRO108, fis_gRO109, fis_gRO110, fis_gRO111,
fis_gRO112, fis_gRO113, fis_gRO114, fis_gRO115, fis_gRO116, fis_gRO117, fis_gRO118,
fis_gRO119, fis_gRO120, fis_gRO121, fis_gRO122, fis_gRO123, fis_gRO124, fis_gRO125,
fis_gRO126, fis_gRO127, fis_gRO128, fis_gRO129, fis_gRO130, fis_gRO131, fis_gRO132,
fis_gRO133, fis_gRO134 };
// Input range Min
FIS_TYPE fis_gIMin[] = { -30, 0, 0, 0 };
// Input range Max
FIS_TYPE fis_gIMax[] = { 30, 35, 35, 120 };
// Output range Min
FIS_TYPE fis_gOMin[] = { 0 };
// Output range Max
FIS_TYPE fis_gOMax[] = { 1 };
95
//***********************************************************************
// Data dependent support functions for Fuzzy Inference System
//***********************************************************************
// None for Sugeno
//***********************************************************************
// Fuzzy Inference System
//***********************************************************************
void fis_evaluate()
{
FIS_TYPE fuzzyInput0[] = { 0, 0, 0, 0, 0 };
FIS_TYPE fuzzyInput1[] = { 0, 0, 0 };
FIS_TYPE fuzzyInput2[] = { 0, 0, 0 };
FIS_TYPE fuzzyInput3[] = { 0, 0, 0 };
FIS_TYPE* fuzzyInput[fis_gcI] = { fuzzyInput0, fuzzyInput1, fuzzyInput2, fuzzyInput3,
};
FIS_TYPE fuzzyOutput0[] = { 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;
// 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]);
96
}
}
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);
97
}
}
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)
{
FIS_TYPE sWI = 0.0;
for (j = 0; j < fis_gOMFCount[o]; ++j)
{
fuzzyOutput[o][j] = fis_gMFOCoeff[o][j][fis_gcI];
for (i = 0; i < fis_gcI; ++i)
{
fuzzyOutput[o][j] += g_fisInput[i] * fis_gMFOCoeff[o][j][i];
}
}
for (r = 0; r < fis_gcR; ++r)
{
index = fis_gRO[r][o] - 1;
sWI += fuzzyFires[r] * fuzzyOutput[o][index];
98
}
g_fisOutput[o] = sWI / sW;
}
}
}