Upload
others
View
5
Download
0
Embed Size (px)
Citation preview
LAPORAN PENELITIAN FAKULTAS
PENGEMBANGAN MEDIA PEMBELAJARAN SISTEM KENDALI
KONTINYU UNTUK MENUNJANG PRAKTIKUM MAHASISWA D3
BIDANG TEKNOLOGI ELEKTRONIKA
Oleh
Dr. Muhammad Rif’an, ST., MT (0022107404)
Dibiayai oleh:
DANA BLU POK FAKULTAS TEKNIK
UNIVERSITAS NEGERI JAKARTA
Berdasarkan Surat Keputusan Pejabat Pembuat Komitmen
Fakultas Teknik Universitas Negeri Jakarta
Nomor : 461.a/SP/2018, Tanggal : 23 MEI 2018
FAKULTAS TEKNIK
UNIVERSITAS NEGERI JAKARTA
NOPEMBER 2018
ii
HALAMAN PENGESAHAN
Judul Penelitian : PENGEMBANGAN MEDIA PEMBELAJARAN
SISTEM KENDALI KONTINYU UNTUK
MENUNJANG PRAKTIKUM MAHASISWA D3
BIDANG TEKNOLOGI ELEKTRONIKA
Pelaksana
a) Nama Lengkap : Dr. Muhammad Rif’an, ST., MT b) NIDN : 0022017404 c) Jabatan Fungsional : Lektor d) Program Studi : D3 Elektronika e) Nomor HP : 08567074880 f) Alamat surel : [email protected] Anggota (1)
a) Nama Lengkap : b) NIDN : c) Perguruan Tinggi : Anggota (2)
a) Nama Lengkap : b) NIDN : c) Perguruan Tinggi Instansi Mitra
Nama Institusi Mitra : -
Alamat : -
Penanggung Jawab :
Biaya Penelitian : Rp 10.000.000,-
Jakarta, 15 Nopember 2018
Mengetahui,
Dekan Fakultas Teknik, Ketua
Dr. Agus Dudung R., M.Pd Dr. Muhammad Rif’an, ST., MT
NIP. 19650817 199102 1 001 NIP. 19741022 200112 1 001
Menyetujui,
Ketua Lembaga Penelitian dan
Pengabdian Kepada Masyarakat UNJ
Dr. Ucu Cahyana, Msi
NIP. 196608201994031002
iii
RINGKASAN
D3 Bidang Teknologi Elektronika pada umumnya memiliki visi menghasilkan lulusan siap
kerja di dunia industri yang trampil dan bersertifikasi serta berkompeten pada bidang
elektronika. Untuk itu salah satu kompetensi yang harus disemai dan dikembangkan kepada
lulusan D3 Bidang Teknologi Elektronika adalah mampu menguasai dan menerapkan sistem
kendali atau sistem elektronika dengan pendekatan analitis dan mempertimbangkan standar
teknis, aspek kinerja, keandalan, kemudahan penerapan, keberlanjutan, serta memperhatikan
faktor-faktor ekonomi, kesehatan dan keselamatan publik, kultural, sosial dan lingkungan.
Kompetensi ini sangat sejalan dengan kerangka kualifikasi nasional indonesia (KKNI) yang
menyatakan bahwa lulusan D3 atau level 5 harus memiliki tingkat kemampuan
menyelesaikan pekerjaan berlingkup luas, memilih berbagai metode.
Sejalan dengan hal tersebut, Kompetensi ini dicapai melalui beberapa mata kuliah seperti
sistem kendali keontinyu. Pengendalian sistem kontinyu telah banyak digunakan pada
industri dalam rangka menjaga kualitas produksi seperti pada pembangkit listrik, pembuatan
mobil, tekstil, dan lain sebagainya. Kesulitan dan keterbatasan dalam menyampaikan dan
menanamkan kompetensi ini adalah kurang mendukungnya fasilitas laboratorium karena
sangat mahal, tidak efisien dan dapat membahayakan mahasiswa jika dalam setiap
laboratorium disediakan sistem kontinyu yang sama dengan industri sesungguhnya.
Untuk itu, dalam penelitian ini akan dikembangkan media pembelajaran untuk sistem kendali
kontinyu menggunakan hardware-in-the-loop sehingga diharapkan dapat dihasilkan sistem
proses di industri yang serupa dan identik yang dapat diujicoba secara langsung oleh
mahasiswa. Hardware-in-the-loop yang dikembangkan merupakan sebuah rangkaian
elektronika dan komputer dengan model sistem berbasis pada neural-network dan model
matematika. Neural network digunakan karena kemampuan-nya dalam identifikasi sistem
proses baik yang bersifat linier maupun non linier. Hal ini sangat sejalan karena sebagian
besar proses di industri adalah sistem non-linier. Selain itu, hardware-in-the-loop yang akan
dikembangkan diharapkan memiliki fitur sistem kendali proses yang dapat diubah-ubah
sesuai dengan kebutuhan, kompatibel dengan komunikasi serial, keluaran dan masukan
berstandar industri (4-20mA), dan fasilitas data logger..
Kata Kunci: Hardware-in-the-loop, Sistem Kendali, Neural Network
iv
PRAKATA
Puji syukur kami panjatkan kehadirat Allah SWT, Tuhan penguasa alam semesta, atas
perkena-Nya lah laporan penelitian fakultas ini dapat dilaksanakan dengan baik. Penelitian
ini merupakan Pengembangan Media Pembelajaran Sistem Kendali Kontinyu Untuk
Menunjang Praktikum Mahasiswa D3 Bidang Teknologi Elektronika.
Pada kesempatan ini peneliti mengucapkan banyak terima kasih kepada Dekan Fakultas
Teknik yang telah memberikan kepercayaan kepada tim peneliti untuk melakukan penelitian
tentang Pengembangan Media Pembelajaran Sistem Kendali Kontinyu Untuk Menunjang
Praktikum Mahasiswa D3 Bidang Teknologi Elektronika tahun 2018 ini.
Sebagai bagian dari proses pembelajaran, laporan penelitian ini tidak luput dari kekeliruan
dan kekurangan, oleh karena itu kami tim peneliti mohon maaf sekaligus terbuka terhadap
masukan dan kritikan bagi perbaikan hasil penelitian kami kelak.
Peneliti
v
DAFTAR ISI
HALAMAN PENGESAHAN ................................................................................................... ii
RINGKASAN .......................................................................................................................... iii
PRAKATA ................................................................................................................................ iv
DAFTAR ISI .............................................................................................................................. v
DAFTAR GAMBAR ................................................................................................................ vi
DAFTAR LAMPIRAN ............................................................................................................ vii
BAB I PENDAHULUAN .......................................................................................................... 1
A. Latar Belakang ............................................................................................................ 1
B. Rumusan Masalah ....................................................................................................... 2
C. Tujuan Penelitian......................................................................................................... 2
D. Kegunaan Penelitian .................................................................................................... 3
E. Urgensi Penelitian ....................................................................................................... 3
BAB II TINJAUAN PUSTAKA ............................................................................................... 4
A. Sistem Pressure Process RIG ...................................................................................... 4
B. Neural Network ........................................................................................................... 5
C. Pengendali PID .......................................................................................................... 11
BAB III TUJUAN DAN MANFAAT PENELITIAN ............................................................. 15
A. Tujuan Penelitian....................................................................................................... 15
B. Manfaat Penelitian..................................................................................................... 15
BAB IV METODE PENELITIAN .......................................................................................... 16
A. Metode Penelitian ...................................................................................................... 16
B. Tempat dan Waktu Penelitian ................................................................................... 17
C. Populasi dan Sample ................................................................................................. 17
D. Teknik Pengumpulan Data Penelitian ....................................................................... 18
E. Teknik Analisis Data ................................................................................................. 18
BAB V HASIL DAN LUARAN YANG DICAPAI................................................................ 19
BAB VI KESIMPULAN DAN SARAN ................................................................................. 26
DAFTAR PUSTAKA .............................................................................................................. 27
LAMPIRAN ............................................................................................................................. 28
vi
DAFTAR GAMBAR
Gambar 1. Sistem Pressure Process RIG ................................................................................... 4
Gambar 2. Saraf Biologis ........................................................................................................... 6
Gambar 3. Neuron sebagai operator matematis ......................................................................... 7
Gambar 4. Blok Diagram Identifikasi dengan Neural Network .............................................. 11
Gambar 5. Konfigurasi PID ..................................................................................................... 12
Gambar 6. Step Respon untuk mendapatkan parameter metode CHR .................................... 14
Gambar 7 Alur Penelitian ........................................................................................................ 17
Gambar 8 Sinyal Input dan Output Sistem PPR ...................................................................... 19
Gambar 9 Sinyal Input dan Output Sistem PPR ...................................................................... 20
Gambar 10 Blok Diagram Identifikasi Sistem PPR dengan Neural Network ......................... 20
Gambar 11 Arsitektur Neural Network .................................................................................... 21
Gambar 12 Error Pembelajaran ............................................................................................... 22
Gambar 13 Hasil Uji coba ........................................................................................................ 23
Gambar 14 Eksperimental Setup ............................................................................................. 24
Gambar 15 Hasil Eksperimental .............................................................................................. 25
vii
DAFTAR LAMPIRAN
Lampiran 1 Biodata SIDOS ..................................................................................................... 28
Lampiran 2 Source Code ......................................................................................................... 46
Lampiran 3 Publikasi ............................................................................................................... 57
1
BAB I PENDAHULUAN
A. Latar Belakang
Dalam matakuliah sistem kendali atau sistem otomasi industri, pemberian pengalaman dan
pengetahuan kepada mahasiswa terkait proses sistem dan pengendalian di industri dipenuhi
melalui praktikum. Dalam kaitan ini, praktikum dilaksanakan dalam rangka mencapai
kompetensi dasar yang diharapkan dari matakuliah sistem kendali atau sistem otomasi
industri serta untuk memenuhi kompetensi lulusan (Program Learning Outcomes) Program
Studi D3 Teknologi elektronikan berdasarkan Kerangka Kualifikasi Nasional Indonesia
(KKNI).
Kompetensi khusus yang dipersyaratkan dalam KKNI untuk bidang studi teknologi
elektronika adalah (1) mampu menerapkan matematika, sains alam, dan prinsip rekayasa ke
dalam prosedur dan praktek teknikal (technical practice) untuk menyelesaikan masalah
rekayasa dalam bidang teknologi elektronika yang terdefinisi dengan jelas (well-defined); (2)
mampu mengidentifikasi dan menyelesaikan masalah rekayasa dalam teknologi elektronika
yang terdefinisi dengan jelas (well-defined) dengan menggunakan analisis data yang relevan
dari codes, database, dan referensi serta memilih metode dengan memperhatikan faktor-faktor
ekonomi, kesehatan, keselamatan publik, dan lingkungan; (3) mampu merancang,
menganalisis rancangan, dan merealisasikan bagian-bagian rancangan teknologi elektronika
well defined yang memenuhi kebutuhan spesifik dengan pertimbangan yang tepat terhadap
masalah keamanan dan kesehatan kerja dan lingkungan; (4) mampu melakukan pemeliharaan
teknologi elektronika secara berkesinambungan; (5) mampu melakukan pengujian dan
pengukuran sistem mekatronika berdasarkan prosedur dan standar, serta mampu menganalisis,
menginterpretasi, dan menerapkan sesuai peruntukan; dan (6) mampu menggunakan dan
memanfaatkan teknologi modern dalam merancang, merealisasikan rancangan, dan merawat
(maintain) teknologi elektronika.
Dengan kompetensi khusus yang dipersyaratkan tersebut, maka D3 teknologi elektronika
menyelenggarakan mata kuliah praktikum sistem kendali atau sistem otomasi industri melalui
kegiatan pembelajaran dan pengajaran di laboratorium untuk mengembangkan kompetensi
kognitif, afektif dan psikomotorik mahasiswa. Namun demikian, untuk memberikan
pengetahuan dan pengalaman tentang sistem kendali dan otomasi industri yang komprehensif
2
kepada mahasiswa D3 diperlukan dukungan sarana dan prasarana yang mencukupi dan
berkualitas. Peralatan-peralatan laboratorium yang digunakan harus mampu mewakili proses-
proses di industri serta mengikuti perkembangan saat ini. Di sisi lain perkembangan sistem
kendali atau sistem otomasi industri berkembang sangat pesat seirama dengan perkembangan
ilmu pengetahuan dan teknologi. Saat ini, perkembangan sistem kendali didukung oleh
perkembangan metoda analisis dan perancangan, metoda sintetis dan realisasi, metoda
komputasi, teknik pengolahan sinyal, komponen mikroelektronika dan komputer.
Berdasarkan perkembangan dan penggunaan teknologi sistem kendali atau sistem otomasi
industri, pengadaan sistem proses industri untuk digunakan sebagai sarana praktikum di
perguruan tinggi khususnya D3 teknologi elektronika dapat menimbulkan ketidak-efektifan
dan ketidak-efisienan. Hal ini dapat terjadi karena pada saat pengadaan sarana sistem proses
yang ada dipasaran oleh institusi pendidikan tinggi, pada saat yang bersamaan pula teknologi
sistem proses telah berubah dan berkembang, sehingga sarana yang dibeli sudah ketinggalan
zaman.
Hardware-in-the-Loop (HIL) adalah proses yang digunakan untuk mensimulasikan peralatan
atau embeded system secara real-time di lingkungan virtual dan langsung berinteraksi dengan
sistem pengendali yang nyata HIL adalah platform yang efektif dan efisien untuk
mengembangkan dan menguji teknik kendali. Pengujian dapat dilakukan dalam berbagai
kondisi operasi termasuk kesalahan dan lingkungan yang benar-benar aman dan berulang.
HIL telah memainkan peran penting dalam perancangan dan pengujian berbagai produk
selama lebih dari dua dekade. Frost dan Sullivan menyadari bahwa HIL sangat ideal untuk
perancangan dan pengujian peralatan kompleks yang digunakan pada mobil, pesawat terbang,
elektronika daya, sistem tenaga, satelit, rudal, roket dan lokomotif. Pengujian dengan
memanfaatkan HIL mendukung prosedur keselamatan di industri serta biaya yang relatif
murah.
B. Rumusan Masalah
Berdasarkan latar belakan tersebut di atas, maka Rumusan Masalah pada penelitian ini adalah
bagaimana mengembangkan Hardware-In-The-Loop sistem kendali proses industri yang
dapat mewakili sistem proses di industri untuk sarana praktikum mahasiswa D3 Elektronika.
C. Tujuan Penelitian
Tujuan Penelitian ini adalah mengembangkan Hardware-In-The-Loop sistem kendali proses
industri yang dapat mewakili sistem proses di industri dengan kemampuan beradaptasi
3
dengan teknologi terkini sehingga tidak ketinggalan zaman. Dengan kehadiran Hardware-In-
The-Loop sistem kendali proses industri pada sebuah laboratoriuam teknik kendali maka
dapat digunakan oleh para mahasiswa untuk praktikum dalam rangka mencapai kompetensi
yang disyaratkan dalam KKNI.
D. Kegunaan Penelitian
Kegunaan penelitian yang dilakukan adalah secara Praktis tentu dengan tersedianya sarana
praktikum sistem kendali berbasis Hardware-In-The-Loop akan membantu pemahaman
mahasiswa terhadap proses industri. Sementara itu, bagi perguruan tinggi, hasil penelitian
diharapkan dapat menjadi dokumen akademik yang berguna untuk dijadikan acuan bagi
sivitas akademika dalam pengembangan ilmu pengetahuan.
E. Urgensi Penelitian
Salah satu langkah yang dapat ditempuh dalam memenuhi kualifikasi untuk lulusan Program
Studi D3 Elektronika Fakultas Teknik Universitas Indonesia adalah dengan memberikan
pemahaman yang utuh terhadap proses industri. Hasil penelitian ini mendukung langkah
tersebut karena menghasilkan prototipe Media Pembelajaran Sistem Kendali Kontinyu Untuk
Menunjang Praktikum Mahasiswa D3 Bidang Teknologi Elektronika.
4
BAB II TINJAUAN PUSTAKA
A. Sistem Pressure Process RIG
Pressure Process Rig (PPR) merupakan instrument yang digunakan untuk proses pengaturan
presusure (tekanan) dan kecepatan aliran (flow) udara. sistem ini terdiri dari:
1. Sebuah Pneumatic Control Valve,
2. Sebuah I/P converter,
3. Sebuah Blok Orifice,
4. Sebuah Flowmeter,
5. Enam buah pengukur tekanan (Gauge),
6. Dua buah regulator tekanan,
7. Sebuah sensor tekanan,
8. Sebuah sensor perbedaan tekanan,
9. Sebuah Air Receiver,
10. Tujuh buah Valve, dan
11. Beberapa buah saluran pipa yang menghubungkan komponen –komponen di atas.
Gambar 1. Sistem Pressure Process RIG
5
Sistem ini merupakan Single Input Single Output (SISO) dengan masukan berupa Air
Compressor. Komponen-komponen sistem yang berpengaruh pada pembuatan skripsi ini
adalah 2 buah regulator (R1 dan R2), 6 buah indikator tekanan (G1, G2, ..., G6), dan 7 buah
valve (V1, V2, ..., V7). Regulator R1 berfungsi untuk mengendalikan tekanan yang diukur
pada G1. Regulator R2 berfungsi untuk mengendalikan tekanan yang diukur pada G3 atau G4
atau G5. Keluaran yang dapat dikendalikan pada sistem ini ada 2 buah, yaitu tekanan pada
G5 dan perbedaan tekanan pada G4 dan G5. Pressure transmitter (Feedback 38-461)
berfungsi untuk mengubah keluaran pressure sensor menjadi besaran arus standar (4-20mA).
Differential Pressure Transmitter (Feedback 38-462) berfungsi untuk mengubah keluaran
differential pressure sensor menjadi besaran arus standar (4-20mA). Keluaran yang
dikendalikan dalam skripsi ini adalah tekanan pada G5, sehingga hanya pressure transmitter
dan pressure sensor yang digunakan.
Terdapat sejumlah variasi konfigurasi sistem yang dapat diterapkan pada Pressure Process
Rig. Variasi ini diperoleh dengan cara membeda-bedakan (membuka atau menutup) katup
(valve). Untuk keperluan skripsi ini, konfigurasi sistem yang digunakan adalah konfigurasi
dengan membuka katup V2, V4, dan V7 (sebagian) dan menutup katup lainnya. Dan keluaran
pada G5 (process variable) memiliki jangkauan 0–10 psi yang dengan Process Transmitter
diubah menjadi sinyal arus standar (4-20mA).
B. Neural Network
Neural Network atau Jaringan Syaraf Tiruan dalam dunia komputer merupakan sebuah model
saraf pusat (khususnya otak) yang mampu belajar dan mengenal pola. Hecht-Nielsend
mendefinisikan Neural Network sebagai suatu struktur pemroses informasi yang terdistribusi
dan bekerja secara paralel, terdiri atas elemen pemroses (yang memiliki memori lokal dan
beroperasi dengan informasi lokal) yang diinterkoneksi bersama dengan alur sinyal searah
yang disebut koneksi. Setiap elemen pemroses memiliki koneksi keluaran tunggal yang
bercabang (fan out) ke sejumlah koneksi kolateral yang diinginkan (setiap koneksi membawa
sinyal yang sama dari keluaran elemen pemroses tersebut). Keluaran dari elemen pemroses
tersebut dapat merupakan sebarang jenis persamaan matematis yang diinginkan. Seluruh
proses yang berlangsung pada setiap elemen pemroses harus benar-benar dilakukan secara
lokal, yaitu keluaran hanya bergantung pada nilai masukan pada saat itu yang diperoleh
melalui koneksi dan nilai yang tersimpan dalam memori lokal. Sementara itu, Haykin, S.
mendefinisikan Neural Network sebagai sebuah jaringan saraf dengan prosesor yang
6
terdistribusi paralel dan mempunyai kecenderungan untuk menyimpan pengetahuan yang
didapatkannya dari pengalaman dan membuatnya tetap tersedia untuk digunakan, serta
menyerupai kerja otak dalam hal mendapatkan pengetahuan melalui suatu proses belajar dan
bobot sinapsis hubungan antar sel saraf yang digunakan untuk menyimpan pengetahuan.
Pada umumnya Neural Network digambarkan sebagai sistem "neuron" yang saling
berhubungan yang dapat menghitung nilai dari input dengan memberi informasi melalui
jaringan sistem “neuron” tersebut. “Neuron” adalah unit pemroses informasi yang menjadi
dasar dalam pengoperasian Jaringan syaraf tiruan. Menurut Siang, Neuron terdiri atas tiga
elemen pembentuk yaitu:
a) Himpunan unit-unit yang dihubungkan dengan jalur koneksi. Jalur-jalur tersebut memiliki
bobot/ kekuatan yang berbeda-beda. Bobot yang bernilai positif akan memperkuat sinyal
dan yang bernilai negatif akan memperlemah sinyal yang dibawanya. Jumlah, Struktur,
dan pola hubungan antar unit-unit tersebut akan menentukan arsitektur jaringan (dan juga
model jaringan yang terbentuk).
b) Suatu unit penjumlah yang akan menjumlahkan input-input sinyal yang sudah dikalikan
dengan bobotnya.
c) Fungsi aktivasi yang akan menentukan apakah sinyal dari input neuron akan diteruskan
ke neuron lain ataukah tidak.
Gambar skematik tipikal neuron dapat dilihat pada gambar 2.
sumber : Situngkir dan surya 2003b.
Gambar 2. Saraf Biologis
Pemrosesan informasi dalam Neural Network dapat diterangkan sebagai berikut: Sinyal (baik
berupa aksi ataupun potensial) muncul sebagai masukan unit (sinapsis) [x1, x2, ..., xN]; efek
dari tiap sinyal ini dinyatakan sebagai bentuk perkalian dengan sebuah nilai bobot [w1, w2, ...,
7
wN] untuk mengindikasikan kekuatan dari sinapsis. Semua sinyal yang diberi pengali bobot
ini kemudian dijumlahkan satu sama lain untuk menghasilkan unit aktivasi. Jika aktivasi ini
melampaui sebuah batas ambang tertentu maka unit tersebut akan memberikan keluaran
dalam bentuk respon terhadap masukan. Unit aktivasi ini kemudian dibandingkan dengan
sebuah nilai ambang, dan hasilnya dimasukkan kedalam fungsi transfer (fungsi non-linier)
yang akan menghasilkan sebuah keluaran. Secara ringkas proses tersebut dapat digambarkan
dalam gambar 3.
Sumber : Situngkir dan Surya, 2003b
Gambar 3. Neuron sebagai operator matematis
Ada beberapa fungsi aktivasi yang sering digunakan dalam Neural Network, antara lain
fungsi step, fungsi Heaviside, fungsi bipolar, fungsi linear, fungsi Sigmoid Biner, dan fungsi
sigmoid bipolar.
Untuk mengenali pola hubungan masukan dan keluaran, Neural Network dilatih melalui
proses pembelajaran untuk mendapatkan bobot yang sesuai dengan pola tersebut. Terdapat
dua tipe pembelajaran dalam Neural network, yaitu Pembelajaran Terawasi dan Pembelajaran
Tidak Terawasi.
Metode pembelajaran terawasi dilakukan apabila output yang diharapkan telah diketahui.
Pada tahap pembelajaran, pola input akan diberikan ke neuron pada lapisan input. Pola ini
akan dirambatkan di sepanjang Neural Network hingga sampai ke neuron pada lapisan output.
Lapisan output ini akan membangkitkan pola output yang nantinya akan dicocokkan dengan
pola output targetnya. Apabila terjadi perbedaan antara pola output hasil pembelajaran
dengan pola target, maka akan terdapat error. Apabila nilai error ini relatif besar maka masih
perlu dilakukan lebih banyak pembelajaran lagi. Terdapat berbagai tipe pembelajaran
terawasi beberapa diantaranya Hebb Rule, Perceptron, Delta Rule, Backpropagation,
8
Heteroassociative Memory, Bidirectional Associative Memory (BAM), Learning Vector
Quantization (LVQ).
Pembelajaran tak terawasi tidak memerlukan target output. Pada metode ini, tidak dapat
ditentukan hasil yang seperti apakah yang diharapkan selama proses pembelajaran. Selama
proses pembelajaran, nilai bobot disusun dalam suatu range tertentu tergantung pada nilai
input yang diberikan. Tujuan pembelajaran ini adalah mengelompokkan unit-unit yang
hampir sama dengan suatu area tertentu. Pembelajaran ini biasanya sangat cocok untuk
pengelompokan (klasifikasi) pola.Contoh metode pembelajaran tak terawasi adalah jaringan
kohonen (kohonen network).
Backpropagation
Propagasi balik merupakan algoritma pembelajaran yang terawasi dan biasanya digunakan
oleh perceptron dengan banyak lapisan untuk mengubah bobot-bobot yang terhubung dengan
neuron-neuron yang ada pada lapisan tersembunyinya. Algoritma propagasi balik
menggunakan error output untuk mengubah nilai bobot-bobotnya dalam arah mundur
(backward). Untuk mendapatkan error ini, tahap perambatan maju (forward propagation)
harus dikerjakan terlebih dahulu. Pada saat perambatan maju, neuron-neuron diaktifkan
dengan menggunakan fungsi aktivasi sigmoid, yaitu :
xexf
−+=
1
1)(
Algoritma backpropagation :
• Inisialisasi bobot (ambil bobot awal dengan nilai random yang cukup kecil).
• Kerjakan langkah-langkah berikut selama kondisi berhenti bernilai FALSE :
1. Untuk tiap-tiap pasangan elemen yang akan dilakukan pembelajaran, kerjakan :
Feedforward :
a. Tiap-tiap unit input (Xi, i=1,2,3,...,n) menerima sinyal xi dan meneruskan
sinyal tersebut ke semua unit pada lapisan yang ada diatasnya (lapisan
tersembunyi).
b. Tiap-tiap unit tersembunyi (Zj, j=1,2,3,...,p) menjumlahkan sinyal-sinyal input
terbobot :
=
+=n
i
ijijj vxvinz1
0_
9
Gunakan fungsi aktivasi untuk menghitung sinyal outputnya :
Zj = f(z_inj)
Dan kirimkan sinyal tersebut ke semua unit di lapisan atasnya (unit-unit
output).
c. Tiap-tiap unit output (Yk, k=1,2,3,...,m) menjumlahkan sinyal-sinyal input
terbobot.
=
+=p
i
jkikj wzwiny1
0_
Gunakan fungsi aktivasi untuk menghitung sinyal outputnya :
yk=f(y_ink)
Dan kirimkan sinyal tersebut ke semua unit dilapisan atasnya (unit-unit
output).
Backpropagation
d. Tiap-tiap unit output (Yk, k=1,2,3,...,m) menerima target pola yang
berhubungan dengan pola input pembelajaran, hitung informasi error nya :
)_()( kkkk inyfyt −=
Kemudian hitung koreksi bobot (yang nantinya akan digunakan untuk
memperbaiki nilai wjk) :
jkjk zW =
Hitung juga koreksi bias (yang nantinya akan digunakan untuk memperbaiki
nilai w0k ) :
kkw = 0
Kirimkan k ini ke unit-unit yang ada dilapisan bawahnya.
e. Tiap-tiap unit tersembunyi (Zj, j=1,2,3,...,p) menjumlahkan delta inputnya
(dari unit-unit yang berada pada lapisan diatasnya) :
10
=
=m
i
jkkj win1
_
Kalikan nilai ini dengan turunan dari fungsi aktivasinya untuk menghitung
informasi error :
)_(_ jjj inzfin =
Kemudian hitung koreksi bobot (yang nantinya akan digunakan untuk
memperbaiki nilai vij):
ijjk xv =
Kemudian hitung koreksi bias (yang nantinya akan digunakan untuk
memperbaiki nilai v0j):
jjv = 0
f. Tiap-tiap unit output (Yk, k=1,2,3,...,m) memperbaiki bias dan bobotnya
(j=0,1,2,...,p):
jkjkjk wlamawbaruw += )()(
Tiap-tiap unit tersembunyi (Zj, j=1,2,3,...,p) memperbaiki bias dan bobotnya
(i=0,1,2,...,n)
ijijij wlamavbaruv += )()(
2. Tes Kondisi berhenti
Identifikasi Sistem Dinamik dengan Neural Network
Secara umum, sistem dinamik dapat direpresentasikan dalam bentuk finite difference
equation sebagai berikut:
�̅�(𝑘 + 1) = 𝑔(�̅�(𝑘), �̅�(𝑘 − 1),⋯ , �̅�(𝑘 − 𝑛), �̅�(𝑘), �̅�(𝑘 − 1),⋯ , �̅�(𝑘 − 𝑚))
Dengan 𝑔(∙) adalah sembarang fungsi (non linier atau linier), �̅�(𝑘) adalah vektor keluaran,
dan �̅�(𝑘) adalah vektor masukan dengan waktu sampling k.
Untuk mengidentifikasi sistem dinamik dalam bentuk persamaan (1) menggunakan Neural
Network, Narenda menyarankan untuk menggunakan data pada waktu lampau sebagai
11
masukan untuk Neural Network. Dengan demikian, Neural Network memiliki potensi untuk
mengidentifikasi sistem dinamis non linier kompleks secara feedforward yang mungkin tidak
ada penyelesaian analitiknya.
Gambar 4 mendeskripsikan blok diagram identifikasi sistem dinamik berbentuk SISO dengan
satu data masukan dan satu data keluaran serta memanfaatkan data pada waktu lampau.
Gambar 4. Blok Diagram Identifikasi dengan Neural Network
C. Pengendali PID
Pengendali PID adalah pengendali yang paling klasik. Keuntungan pengendali ini adalah
tidak membutuhkan model matematis yang akurat dari sistem yang dikendalikan dan telah
digunakan secara luas di pelbagai bidang kendali proses. Untuk sistem time invariant linear,
pengendali PID konvensional selalu dapat memiliki efek antisipasi kendali melalui parameter
tuning, terutama untuk sistem orde rendah. Tetapi jika sistem yang dikendalikan adalah
bervariasi terhadap waktu atau nonlinear, efek kendali dari PID dapat menjadi buruk.
Konfigurasi PID konvensional ditunjukkan seperti Gambar 5.
12
Gambar 5. Konfigurasi PID
Dengan persamaan
𝑢(𝑡) = 𝐾𝑝𝑒(𝑡) + 𝐾𝑖 ∫ 𝑒(𝑡)𝑑𝑡 + 𝐾𝑑𝑑𝑒(𝑡)
𝑑𝑡
𝑡
0
Dalam konfigurasi ini, pengendali ditempatkan secara seri dengan plant. Maka konfigurasi
sistem seperti ini biasa disebut series atau cascade compensation. Konfigurasi ini yang paling
banyak dipakai di dalam desain sistem kontrol. Seperti yang telah diketahui, manfaat
penggunaan feedback yaitu untuk meningkatkan performansi sistem kontrol itu sendiri,
memperbaiki performansi response atau mengatur transien respons (seperti mereduksi time
constant), mengurangi error, dan mengurangi sensitivitas atau mendapatkan robustness. Di
dalam Prakteknya, bisa saja hanya menggunakan term proporsional saja (P), term integral dan
proporsional (PI) atau term proporsional dan derivative (PD). Hal itu disesuaikan dengan
kebutuhan dan sangat tergantung dari karakteristik sistem yang akan dikendalikan.
Pengendali PID pada sistem loop tertutup menggunakan skema yang terlihat pada gambar 5.
Variable (e) menggambarkan tracking error, nilai masukan yang berubah – ubah (R) atau
yang sering disebut set point, keluaran aktual (Y). Signal error ini akan dikirim ke pengendali
PID, dan pengendali akan menghitung keseluruhan turunan dan integral dari signal error ini.
Signal input plant atau signal output dari kontroler (u), sekarang sama dengan proporsional
penguatan (KP) dikalikan ukuran kesalahannya ditambah penguatan integral (Ki) dikalikan
ukuran kesalahan integralnya ditambah penguatan turunan (Kd) dikalikan ukuran kesalahan
derivasinya.
Masing – masing pengendali akan memberikan efek sebagai berikut:
Pengendali Proporsional: sistem menanggapi masukan dengan cepat namun cenderung
memperbesar osilasi yang terjadi. Sehingga bila terlalu besar nilai konstanta penguatannya
(KP) maka overshoot akan semakin besar.
u(t) e(t)
13
Pengendali Integral: mempunyai karakteristik mengurangi error steady state namun akan
memperburuk tanggapan transien sistem. Penambahan konstanta penguatan Ki akan
menambah overshoot pula sehingga penggunaannya akan membuat respons sistem menjadi
lambat.
Pengendali Derivative: mempunyai karakteristik mengurangi fluktuasi pada keluaran sistem
dalam mencapai nilai akhir (DC gain). Penambahan konstanta penguatan Kd akan
mempercepat respons sistem.
Tabel 1. menunjukan ringkasan dari efek peningkatan parameter secara independen dari
pengendali PID
Tabel 1 Efek dari peningkatan parameter PID
Konstanta
Pengendali Rise Time Overshoot Settling Time
Error Steady
State
KP Mengurangi Menambah
Menimbulkan
perubahan
yang kecil
Mengurangi
Ki Mengurangi Menambah Menambah Meniadakan
Kd
Menimbulkan
perubahan
yang kecil
Mengurangi Mengurangi
Menimbulkan
perubahan
yang kecil
Untuk menggunakan pengendali PID, parameter yang terkait dengan operasi harus terlebih
dahulu ditala. Proses penalaan ini digunakan untuk mensinkronkan variabel pengendalo
dengan yang dikendalikan, sehingga memungkinkan proses yang didapat akan optimal sesuai
dengan kondisi operasi yang diinginkan. Metode standar untuk penalaan pengendali PID
telah diteliti selama bertahun-tahun. Beberapa dari mereka adalah kriteria Matematika,
Metode Cohen-coon, Trial and error metode, metode Ziegler-Nichols, metode Mathematical
Criteria, metode Cohen-coon, metode Trial and error, metode Continuous Cycling, metode
Relay Feedback, metode penalaan Kappa-Tau, dan metode Chien-Hrones-Reswick (CHR).
Berdasarkan, metode CHR merupakan metode yang lebih baik jika dibandingkan dengan
metode Cohen-coon atau metode Ziegler-Nichols.
Gambar 6 menunjukkan pendekatan sederhana untuk menghitung waktu TT konstan, waktu
tunda TL, gain kontroler RK dan menentukan nilai konstan = RKTL/TT dari metode CHR
yang didapat dari step respon terhadap waktu dari sistem yang diteliti. Tabel 3.1
14
menunjukkan rumus metode CHR untuk menentukan parameter-parameter konstanta
pengendali P, PI, dan PID, lebih khusus menggunakan fenomena overshoot 0% dan 20%.
Dapat dikatakan bahwa bahwa respon terhadap waktu tercepat dari sistem diberi istilah
“dengan 0% overshoot”, sedangkan proses osilasi tercepat diberi istilah “dengan 20%
overshoot”.
Gambar 6. Step Respon untuk mendapatkan parameter metode CHR
Tabel 2 Rumus perhitungan parameter PID dengan metode CHR
Controller Type With 0% overshoot With 20% overshoot
Kp Ti Td Kp Ti Td
P 0.3/ 0.7/
PI 0.35/ 1.2TT 0.6/ TT
PID 0.6/ TT 0.5TL 0.95/ 1.4TT 0.47TL
15
BAB III TUJUAN DAN MANFAAT PENELITIAN
A. Tujuan Penelitian
Tujuan penelitian ini adalah mengembangkan mengembangkan Hardware-In-The-Loop
sistem kendali proses industri.
B. Manfaat Penelitian
Manfaat dari penelitian ini adalah hasil uji coba peneltian ini dapat dikembangkan dalam
skala perangkat keras yang dapat dimanfaatkan untuk pengembangan modul praktikum
sistem kendali kontinyu.
16
BAB IV METODE PENELITIAN
A. Metode Penelitian
Penelitian dilakukan melalui eksperimen pembuatan protoype dengan tahapan sebagai
berikut:
1). Pra-penelitian
Tahap ini menghimpun data dan informasi terkait Sistem Pressure Process RIG,
Neural Network dan Pengendali PID.
2). Penyusunan Instrumen
Pada tahap ini akan dilakukan penyusunan algoritma Modeling Sistem Pressure
Process RIG menggunakan Neural Network.
3). Validasi Instrumen
Tahap ini melakukan pengujian Model Sistem Pressure Process RIG. Pengujian
dilakukan secara simulasi menggunakan komputer hingga mendapatkan keluaran
yang stabil dan kesalahan yang minimal.
4). Pengumpulan Data
Tahap ini melakukan pembangunan rangkaian berdasarkan desain yang dirancang
dan dilakukan pengujian, serta dikumpulkan datanya.
5). Analisis Data dan Penyusunan Laporan
Tahap ini menganalisi data dan menyimpulkan hasil penelitian berdasarkan hasil uji
coba. Kesimpulan diharapkan dapat menghasilkan suatu prototype hardware-in-the-
loop untuk pengendalian proses industri.
17
Gambar 7 Alur Penelitian
B. Tempat dan Waktu Penelitian
Pelaksanaan penelitian guna mengembangkan Hardware-In-The-Loop sistem kendali proses
industri yang dapat mewakili sistem proses di industri dilakukan di Laboratorium Elektronika,
Jurusan Teknik Elektro, Fakultas Teknik, Universitas Negeri Jakarta, dengan waktu
penelitian dari April hingga Oktober 2018.
C. Populasi dan Sample
Populasi penelitian adalah seluruh proses industri yang kontinyu dan sample yang digunakan
adalah untuk Presure Process RIG Sistem.
Literatur
Penyusunan Model
Sesuai?
Perbaikan Model
Pengujian Model
Stabil?
Perbaikan Model
Pembangunan Rangkaian
Sesuai?
Inspeksi ulang
Kesimpulan
18
D. Teknik Pengumpulan Data Penelitian
Teknik pengumpulan data yang digunakan pada penelitian ini adalah berupa observasi secara
langsung pada prototipe yang dikembangkan. Data yang dikumpulkan berupa kinerja dan
output dari prototipe.
E. Teknik Analisis Data
Teknik analisis yang digunakan adalah membandingkan data yang diperoleh dengan data dari
proses industri sebenarnya.
19
BAB V HASIL DAN LUARAN YANG DICAPAI
Luaran penelitian yang dicapai adalah media pembelajaran untuk sistem kendali kontinyu
menggunakan hardware-in-the-loop.
Perbandingan sistem nyata dengan sistem Hardware-In-The-Loop disajikan pada gambar 8.
Gambar 8 Sinyal Input dan Output Sistem PPR
Sistem asli di industri terdiri dari plant dan pengendali, sedangkan pada Hardware-In-The-
Loop untuk plant digunakan mini komputer (Raspberry Pi) sedangkan pada pengendali
digunakan Arduino Uno.
Langkah awal yang dilakukan adalah identifikasi atau pemodelan dari Pressure process
rig(PPR).
Identifikasi dengan Neural Network untuk Sistem Dinamik Pressure process rig(PPR) yang
merupakan simulator proses pengendalian dan pengukuran tekanan. Data input dan Output
sistem PPR dipresentasikan pada gambar 8.
20
Gambar 9 Sinyal Input dan Output Sistem PPR
Sistem PPR merupakan sistem satu masukan satu keluaran (SISO) dan dapat
direpresentasikan dalam bentuk finite difference equation. Terdapat 5.000 pasang data input
dan output yang dapat digunakan untuk indentifikasi menggunakan Neural Network. Dengan
menggunakan model yang disarankan Narendra, identifikasi sistem PPR menggunakan
Neural Network dapat digambarkan dengan blok diagram pada gambar 10.
Gambar 10 Blok Diagram Identifikasi Sistem PPR dengan Neural Network
Neural Networ memiliki 7 masukan dan 1 keluaran. Masukan terdiri dari u(k), u(k-1), u(k-2),
u(k-3), y(k-1), y(k-2), dan y(k-3), sedangkan keluaran adalah y(k). Nilai keluaran y(k) akan
0
0,5
1
1,5
2
2,5
0 500 1000 1500 2000 2500 3000 3500 4000 4500 5000
Input Output
21
dibandingkan dengan nilai �̅�(k) [output sistem PRR] sehingga didapat nilai error e yang
digunakan untuk pembelajaran neural network selanjutnya.
Dengan 7 input dan 1 output serta menggunakan metode pembelajaran backpropagation
arsitektur Neural Network pada uji coba ini adalah seperti pada gambar 11.
Gambar 11 Arsitektur Neural Network
Uji coba pembelajaran/identifikasi dilakukan untuk 1.000 data dan menggunakan bantuan
Matlab dengan script sebagai berikut:
clear all;
disp('baca data ......');
load('d:\Data_PPR.mat');
disp('baca data ......done');
data_x=Data_PP(1:4010,2);
data_y=Data_PP(1:4010,3);
x_n=data_norm(data_x,'x','normal');
y_n=data_norm(data_y,'y','normal');
layer_hidden=5;
jumlah_data_training=2010;
awal_data=1;
akhir_data=1000;
x_t = [[x_n(1:jumlah_data_training)],...
[0;x_n(1:jumlah_data_training-1)],...
[0;0;x_n(1:jumlah_data_training-2)],...
[0;0;0;x_n(1:jumlah_data_training-3)],...
[0;y_n(1:jumlah_data_training-1)],...
[0;0;y_n(1:jumlah_data_training-2)],...
[0;0;0;y_n(1:jumlah_data_training-3)]];
t_t = y_n(1:jumlah_data_training);
x=x_t(awal_data:akhir_data,:);
t=t_t(awal_data:akhir_data);
max_iterasi=500000;
alpha=0.3;
miu=0.3;
22
[data_output,layer_output]=size(t);
[data_input,layer_input]=size(x);
[data_output,layer_output]=size(t);
[data_input,layer_input]=size(x);
W=awalnw(layer_hidden,layer_output);
V=awalnw(layer_input,layer_hidden);
V_lama=zeros(layer_input+1,layer_hidden);
W_lama=zeros(layer_hidden+1,layer_output);
epsilon=10^(-5);
n_iterasi=0;
t_error=ones(data_output,layer_output);
err=zeros(1,max_iterasi);
while (sum(sum(t_error.^2)) > epsilon) & (n_iterasi < max_iterasi);
n_iterasi=n_iterasi+1;
for k=1:data_input;
f=[x(k,:),1];
z=tansig(f*V);
z=[z,1];
y=tansig(z*W);
ya=data_norm(y,'y','mundur');
t_error(k,:)=data_y(awal_data+k-1,:)-ya;
dok=t_error(k,:).*(1+y).*(1-y).*0.5;
doj=(1+z).*(1-z).*(dok*W').*0.5;
W=W+(alpha*((z'*dok)+(miu*W_lama)));
V=V+(alpha*(f'*doj(1:layer_hidden)+((miu*V_lama))));
W_lama=(z'*dok);
V_lama=(f'*doj(1:layer_hidden));
end;
%clc;
err(n_iterasi)=sum(sum(t_error.^2));
disp(['epoch=',int2str(n_iterasi),...
' SSE=', num2str(err(n_iterasi))]);
end;
plot(err(1:500));
Penurunan Error dari pembelajaran dapat dilihat pada gambar 12.
Gambar 12 Error Pembelajaran
0 50 100 150 200 250 300 350 400 450 5000
2
4
6
8
10
12
epoch
err
or
23
Setelah 500.000 interasi didapat SSE = 0.0331 (MSE= 3.3119e-05) dan nilai bobot untuk
masing-masing layer adalah seperti tabel 1.
Tabel 3 Bobot hasil pembelajaran
Dengan bobot V dan W hasil pembelajaran, Model Neural network diujicoba untuk 3.000
data masukan. Hasil uji coba dengan bobot v dan w tersebut diatas seperti pada gambar 12.
Gambar 13 Hasil Uji coba
Gambar 11 bagian atas menunjukkan bahwa sinyal keluaran Identifikasi sistem dengan
Neural network dengan masukan 3.000 sinyal uji telah mampu mendekati keluaran sistem
PPR dengan SSE sebesar 0.9827 dan MSE sebesar 3.2258e-04. Error untuk masing-masing
pasangan data keluaran sistem dan keluaran Neural Network diperlihatkan pada gambar 12
bagian bawah.
Script Matlab untuk uji coba adalah sebagai berikut:
0 500 1000 1500 2000 2500 30000
0.5
1
1.5
2
2.5
data
outp
ut
0 500 1000 1500 2000 2500 30000
0.05
0.1
0.15
0.2
data
err
or
NN
Sistem
24
%%%UJI COBA%%%%%%%%
jumlah_data_training=4000;%ujicoba
jumlah_data_tampil=3000;
awal_data=1;
akhir_data=3000;
t_t = y_n(1:jumlah_data_training);
t=t_t(awal_data:akhir_data);
yo_n(1)=0;
yo_n(2)=0;
yo_n(3)=0;
for k=4:jumlah_data_tampil;
x(k,:)=[x_n(k),x_n(k-1),x_n(k-2),x_n(k-3),yo_n(k-1),yo_n(k-2),yo_n(k-3)];
f=[x(k,:),1];
z=tansig(f*V);
z=[z,1];
yo_n(k)=tansig(z*W);
yo(k)=data_norm(yo_n(k),'y','mundur');
end;
lx=1:jumlah_data_tampil;
subplot(2,1,2), plot(lx,yo,lx,data_y(awal_data:akhir_data));
subplot(2,1,3), plot(lx,abs(yo'-data_y(awal_data:akhir_data)));
tot_err=sum(sum((yo'-data_y(awal_data:akhir_data)).^2));
disp([' SSE=', num2str(tot_err)]);
Setelah mendapatkan model, langkah berikutnya adalah menanamkan model identifikasi
tersebut ke dalam mini komputer yang pada penelitian ini digunakan Raspberry pi 3 Model B.
Rangkaian uji coba disusun seperti gambar
Gambar 14 Eksperimental Setup
Dalam uji coba didapat hasil sebagai berikut
25
Gambar 15 Hasil Eksperimental
0 50 100 150 200 250 3000.5
1
1.5
2
2.5
data
outp
ut
0 50 100 150 200 250 3000
0.2
0.4
0.6
0.8
1
data
err
or
NN
PPR
26
BAB VI KESIMPULAN DAN SARAN
Dalam penelitian ini prototipe simulasi hardware-in-loop telah dirancang dan dibangun.
Prototipe simulasi hardware-in-loop dengan Neural-Network adalah cara yang efisien untuk
memodelkan sistem kontrol industri.
Hasil eksperimen menghasilkan kesalahan yang relatif kecil dan sistem dapat berfungsi
sesuai rencana.
27
DAFTAR PUSTAKA
[1] Ronsheng L, Satina M (2010) Aerospace real-time control system and software. In: Lewis
(ed) The control handbook: control system applications. CRC Press, Boca Raton, FL
[2] National Aeronautics and Space Administration (2007). NASA systems engineering
handbook. NASA, Washington
[3] European Cooperation for Space Standardization (2010). ECSSE- HB-60A: control
engineering handbook.
[4] European Cooperation for Space Standardization (2001). ECSSE60: control engineering
Standard.
[5] Burbank JL, Kasch W, Ward J (2011) An introduction to network modeling and
simulation for the practicing engineer, 1st edn. John Wiley, Hoboken, NJ
[6] Isermann R (1999) Hardware-in-the-loop simulation for the design and testing of engine-
control systems. Control Eng Pract 7: 643–653
28
LAMPIRAN
Lampiran 1 Biodata SIDOS
46
Lampiran 2 Source Code
Script Raspberry Pi
import
numpy
as np
import random
from math import exp
class NeuralNetwork:
#
# Initialize
#
def __init__(self, n_input=None, n_output=None, n_hidden_nodes=None):
self.n_input = n_input # number of features
self.n_output = n_output # number of classes
self.n_hidden_nodes = n_hidden_nodes # number of hidden nodes/layers
self.network = self._build_network()
#
# Train network
#
def train(self, X_train, y_train, l_rate=0.5, n_epochs=1000):
for epoch in range(n_epochs):
for (x, y) in zip(X_train, y_train):
# Forward-pass training example into network (updates node
output)
self._forward_pass(x)
# Create target output
y_target = np.zeros(self.n_output, dtype=np.int)
y_target[y] = 1
# Backward-pass error into network (updates node delta)
self._backward_pass(y_target)
# Update network weights (using updated node delta and node
output)
self._update_weights(x, l_rate=l_rate)
#
# Predict most probable class labels for a data set X
#
def predict(self, X):
y_predict = np.zeros(len(X), dtype=np.int)
for i, x in enumerate(X):
output = self._forward_pass(x) # output class probabilities
47
y_predict[i] = np.argmax(output) # predict highest prob class
return y_predict
# ==============================
#
# Internal functions
#
# ==============================
#
# Build neural network via settings weights between nodes
# Note: we have no bias terms here
#
def _build_network(self):
# Connect input nodes with outputs nodes using weights
def _build_layer(n_input, n_output):
layer = list()
for idx_out in range(n_output):
weights = list()
for idx_in in range(n_input):
weights.append(random.random())
layer.append({"weights": weights,
"output": None,
"delta": None})
return layer
# Build weights: input layer -> hidden layer(s) -> output layer
n_hidden_layers = len(self.n_hidden_nodes)
network = list()
if n_hidden_layers == 0:
network.append(_build_layer(self.n_input, self.n_output))
else:
network.append(_build_layer(self.n_input, self.n_hidden_nodes[0]))
for i in range(1,n_hidden_layers):
network.append(_build_layer(self.n_hidden_nodes[i-1],
self.n_hidden_nodes[i]))
network.append(_build_layer(self.n_hidden_nodes[n_hidden_layers-1],
self.n_output))
return network
#
# Forward-pass input -> output and save to network node values
# This updates: node['output']
48
#
def _forward_pass(self, x):
# Weighted sum of inputs with no bias term for our activation
def activate(weights, inputs):
activation = 0.0
for i in range(len(weights)):
activation += weights[i] * inputs[i]
return activation
# Perform forward-pass through network and update node outputs
input = x
for layer in self.network:
output = list()
for node in layer:
# Compute activation and apply transfer to it
activation = activate(node['weights'], input)
node['output'] = self._transfer(activation)
output.append(node['output'])
input = output
return input
#
# Backward-pass error into neural network
# The loss function is assumed to be L2-error.
# This updates: node['delta']
#
def _backward_pass(self, target):
# Perform backward-pass through network to update node deltas
n_layers = len(self.network)
for i in reversed(range(n_layers)):
layer = self.network[i]
# Compute errors either:
# - explicit target output difference on last layer
# - weights sum of deltas from frontward layers
errors = list()
if i == n_layers - 1:
# Last layer: errors = target output difference
for j, node in enumerate(layer):
error = target[j] - node['output']
errors.append(error)
else:
# Previous layers: error = weights sum of frontward node deltas
49
for j, node in enumerate(layer):
error = 0.0
for node in self.network[i + 1]:
error += node['weights'][j] * node['delta']
errors.append(error)
# Update delta using our errors
# The weight update will be:
# dW = learning_rate * errors * transfer' * input
# = learning_rate * delta * input
for j, node in enumerate(layer):
node['delta'] = errors[j] *
self._transfer_derivative(node['output'])
#
# Update network weights with error
# This updates: node['weights']
#
def _update_weights(self, x, l_rate=0.3):
# Update weights forward layer by layer
for i_layer, layer in enumerate(self.network):
# Choose previous layer output to update current layer weights
if i_layer == 0:
inputs = x
else:
inputs = np.zeros(len(self.network[i_layer - 1]))
for i_node, node in enumerate(self.network[i_layer - 1]):
inputs[i_node] = node['output']
# Update weights using delta rule for single layer neural network
# The weight update will be:
# dW = learning_rate * errors * transfer' * input
# = learning_rate * delta * input
for node in layer:
for j, input in enumerate(inputs):
dW = l_rate * node['delta'] * input
node['weights'][j] += dW
# Transfer function (sigmoid)
def _transfer(self, x):
return 1.0/(1.0+exp(-x))
# Transfer function derivative (sigmoid)
def _transfer_derivative(self, transfer):
50
return transfer*(1.0-transfer)
def
read_csv(filename):
X_str = list() # data (float)
y_str = list() # class labels (integers)
# Read X and y data from csv file
with open(filename, 'r') as file:
csv_reader = reader(file)
for row in csv_reader:
# Skip row if empty
if not row:
continue
else:
X_str.append(row[:-1])
y_str.append(row[-1])
# Convert our class labels to 0, 1, 2, ..., n_classes-1
def convert_str2idx(y_str):
unique = set(y_str)
lookup = dict()
# Assign each unique class label an index 0, 1, 2, ...,
n_classes-1
for idx_label, label in enumerate(unique):
lookup[label] = idx_label
y_idx = list()
for label in y_str:
y_idx.append(lookup[label])
return y_idx
y_idx = convert_str2idx(y_str)
# Convert to numpy arrays
X = np.array(X_str, dtype=np.float32)
y = np.array(y_idx, dtype=np.int)
return (X, y)
#
# Normalize X data
#
def normalize(X):
# Find the min and max values for each column
x_min = X.min(axis=0)
51
x_max = X.max(axis=0)
# Normalize
for x in X:
for j in range(X.shape[1]):
x[j] = (x[j]-x_min[j])/(x_max[j]-x_min[j])
#
# Randomly permute and extract indices for each fold
#
def crossval_folds(N, n_folds, seed=1):
np.random.seed(seed)
idx_all_permute = np.random.permutation(N)
N_fold = int(N/n_folds)
idx_folds = []
for i in range(n_folds):
start = i*N_fold
end = min([(i+1)*N_fold, N])
idx_folds.append(idx_all_permute[start:end])
return idx_folds
Script Arduino
/**************************************************************************
********************
* Arduino PID Library - Version 1.2.1
* by Brett Beauregard brettbeauregard.com
*
* This Library is licensed under the MIT License
***************************************************************************
*******************/
#if ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
#include
/*Constructor
(...)*********************************************************
* The parameters specified here are those for for which we can't set up
* reliable defaults, so we need to have the user set them.
***************************************************************************
/
PID::PID(double* Input, double* Output, double* Setpoint,
double Kp, double Ki, double Kd, int POn, int ControllerDirection)
{
myOutput = Output;
myInput = Input;
mySetpoint = Setpoint;
52
inAuto = false;
PID::SetOutputLimits(0, 255); //default output
limit corresponds to
//the arduino pwm limits
SampleTime = 100; //default
Controller Sample Time is 0.1 seconds
PID::SetControllerDirection(ControllerDirection);
PID::SetTunings(Kp, Ki, Kd, POn);
lastTime = millis()-SampleTime;
}
/*Constructor
(...)*********************************************************
* To allow backwards compatability for v1.1, or for people that just
want
* to use Proportional on Error without explicitly saying so
***************************************************************************
/
PID::PID(double* Input, double* Output, double* Setpoint,
double Kp, double Ki, double Kd, int ControllerDirection)
:PID::PID(Input, Output, Setpoint, Kp, Ki, Kd, P_ON_E,
ControllerDirection)
{
}
/* Compute()
**********************************************************************
* This, as they say, is where the magic happens. this function should
be called
* every time "void loop()" executes. the function will decide for
itself whether a new
* pid Output needs to be computed. returns true when the output is
computed,
* false when nothing has been done.
***************************************************************************
*******/
bool PID::Compute()
{
if(!inAuto) return false;
unsigned long now = millis();
unsigned long timeChange = (now - lastTime);
if(timeChange>=SampleTime)
{
/*Compute all the working error variables*/
double input = *myInput;
double error = *mySetpoint - input;
double dInput = (input - lastInput);
outputSum+= (ki * error);
/*Add Proportional on Measurement, if P_ON_M is specified*/
if(!pOnE) outputSum-= kp * dInput;
53
if(outputSum > outMax) outputSum= outMax;
else if(outputSum < outMin) outputSum= outMin;
/*Add Proportional on Error, if P_ON_E is specified*/
double output;
if(pOnE) output = kp * error;
else output = 0;
/*Compute Rest of PID Output*/
output += outputSum - kd * dInput;
if(output > outMax) output = outMax;
else if(output < outMin) output = outMin;
*myOutput = output;
/*Remember some variables for next time*/
lastInput = input;
lastTime = now;
return true;
}
else return false;
}
/*
SetTunings(...)************************************************************
*
* This function allows the controller's dynamic performance to be
adjusted.
* it's called automatically from the constructor, but tunings can also
* be adjusted on the fly during normal operation
***************************************************************************
***/
void PID::SetTunings(double Kp, double Ki, double Kd, int POn)
{
if (Kp
54
***************************************************************************
***/
void PID::SetTunings(double Kp, double Ki, double Kd){
SetTunings(Kp, Ki, Kd, pOn);
}
/* SetSampleTime(...)
*********************************************************
* sets the period, in Milliseconds, at which the calculation is performed
***************************************************************************
***/
void PID::SetSampleTime(int NewSampleTime)
{
if (NewSampleTime > 0)
{
double ratio = (double)NewSampleTime
/ (double)SampleTime;
ki *= ratio;
kd /= ratio;
SampleTime = (unsigned long)NewSampleTime;
}
}
/* SetOutputLimits(...)****************************************************
* This function will be used far more often than SetInputLimits.
while
* the input to the controller will generally be in the 0-1023 range
(which is
* the default already,) the output will be a little different. maybe
they'll
* be doing a time window and will need 0-8000 or something. or maybe
they'll
* want to clamp it from 0-125. who knows. at any rate, that can all be
done
* here.
**************************************************************************/
void PID::SetOutputLimits(double Min, double Max)
{
if(Min >= Max) return;
outMin = Min;
outMax = Max;
if(inAuto)
{
if(*myOutput > outMax) *myOutput = outMax;
else if(*myOutput < outMin) *myOutput = outMin;
if(outputSum > outMax) outputSum= outMax;
else if(outputSum < outMin) outputSum= outMin;
}
}
/*
SetMode(...)***************************************************************
*
* Allows the controller Mode to be set to manual (0) or Automatic (non-
zero)
* when the transition from manual to auto occurs, the controller is
* automatically initialized
55
***************************************************************************
***/
void PID::SetMode(int Mode)
{
bool newAuto = (Mode == AUTOMATIC);
if(newAuto && !inAuto)
{ /*we just went from manual to auto*/
PID::Initialize();
}
inAuto = newAuto;
}
/*
Initialize()***************************************************************
*
* does all the things that need to happen to ensure a bumpless transfer
* from manual to automatic mode.
***************************************************************************
***/
void PID::Initialize()
{
outputSum = *myOutput;
lastInput = *myInput;
if(outputSum > outMax) outputSum = outMax;
else if(outputSum < outMin) outputSum = outMin;
}
/*
SetControllerDirection(...)************************************************
*
* The PID will either be connected to a DIRECT acting process (+Output
leads
* to +Input) or a REVERSE acting process(+Output leads to -Input.) we
need to
* know which one, because otherwise we may increase the output when we
should
* be decreasing. This is called from the constructor.
***************************************************************************
***/
void PID::SetControllerDirection(int Direction)
{
if(inAuto && Direction !=controllerDirection)
{
kp = (0 - kp);
ki = (0 - ki);
kd = (0 - kd);
}
controllerDirection = Direction;
}
/* Status
Funcions*************************************************************
* Just because you set the Kp=-1 doesn't mean it actually happened. these
* functions query the internal state of the PID. they're here for display
* purposes. this are the functions the PID Front-end uses for example
***************************************************************************
***/
56
double PID::GetKp(){ return dispKp; }
double PID::GetKi(){ return dispKi;}
double PID::GetKd(){ return dispKd;}
int PID::GetMode(){ return inAuto ? AUTOMATIC : MANUAL;}
int PID::GetDirection(){ return controllerDirection;}
57
Lampiran 3 Publikasi