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 : m.rifan@unj.ac.id 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