Early Warning System PDF

PROYEK AKHIR
MATA KULIAH LOGIKA FUZZY

SEMESTER GENAP 2013-2014
SISTEM PAKAR PEMANTAU KONDISI PASIEN RAWAT

INAP MENGGUNAKAN FUZZY INFERENSI TSUKAMOTO
Disusun oleh:
Kelompok D Kelas A
Eko Subha (105060801111067)
Dosen Pengajar: Wayan Firdaus Mahmudy, Ph.D.
PROGRAM STUDI INFORMATIKA

PROGRAM TEKNOLOGI INFORMASI DAN ILMU KOMPUTER
UNIVERSITAS BRAWIJAYA
MALANG
KATA PENGANTAR
Puji syukur penulis panjatkan kehadirat Allah SWT yang telah

melimpahkan segala kasih sayang dan rahmat-Nya sehingga penulis dapat
menyelesaikan proyek akhir dengan judul Sistem Pakar Pemantau Kondisi
Pasien Rawat Inap Menggunakan Fuzzy Inferensi Tsukamoto. Dokumentasi ini
menjadi bagian dari proyek akhir mata kuliah Logika Fuzzy di Program Teknologi
Informasi dan Ilmu Komputer Universitas Brawijaya.
Penulis menyadari bahwa proyek akhir ini tidak dapat terealisasikan
tanpa bantuan dari berbagai pihak, untuk itu penulis menyampaikan penghargaan
dan ucapan terima kasih yang sedalam-dalamnya kepada:
1. Wayan Firdaus Mahmudy, Ph.D., selaku dosen mata kuliah Logika Fuzzy
kelas A 2014;
2. Arief Andy Soebroto, ST.,M.Kom., selaku dosen mata kuliah Sistem
Pakar kelas A 2014;
3. Orang tua penulis yang sudah memberikan sumbangan materiil maupun
non materiil;
4. Teman-teman kelompok 9 mata kuliah Sistem Pakar untuk bantuan, kerja
sama dan semangatnya; dan
5. Semua pihak yang tidak dapat disebutkan satu-persatu.
Penulis menyadari bahwa proyek akhir ini masih jauh dari
kesempurnaan, untuk itu dengan segala kerendahan hati penulis mengharapkan
saran dan kritik yang membangun demi kesempurnaan penulisan selanjutnya.
Semoga laporan proyek akhir ini dapat bermanfaat untuk semua pihak.
Malang, 26 Mei 2014
Penulis
ii
DAFTAR ISI
KATA PENGANTAR............................................................................................................... ii
DAFTAR ISI .......................................................................................................................... iii
DAFTAR GAMBAR................................................................................................................vi
DAFTAR TABEL ...................................................................................................................vii
DAFTAR PERSAMAAN........................................................................................................ viii
BAB I PENDAHULUAN ......................................................................................................... 1
1.1 Latar Belakang............................................................................................................... 1
1.2 Rumusan Masalah ......................................................................................................... 2
1.3 Batasan Masalah ........................................................................................................... 3
1.4 Tujuan ........................................................................................................................... 3
1.5 Manfaat ......................................................................................................................... 4
1.6 Sistematika Penulisan ................................................................................................... 4
BAB II DASAR TEORI ............................................................................................................ 6
2.1 Pelayanan Rawat Inap ................................................................................................... 6
2.2 Sistem Pakar .................................................................................................................. 6
2.2.1 Ciri dan Karakteristik Sistem Pakar .................................................................... 7
2.2.2 Rule .................................................................................................................. 10
2.3 Logika Fuzzy ................................................................................................................ 11
2.3.1 Himpunan Fuzzy ............................................................................................... 12
2.3.2 Fungsi Keanggotaan Fuzzy ............................................................................... 14
2.4 Fuzzy Inference System (FIS) Tsukamoto .................................................................... 15
2.4.1 Forward Chaining ............................................................................................. 15
2.4.2 Backward Chaining .......................................................................................... 16
2.5 Bahasa Pemrograman Java ......................................................................................... 19
2.6 Metode SBAR .............................................................................................................. 21
BAB III METODOLOGI PENELITIAN .................................................................................... 24
3.1 Studi Literatur ............................................................................................................. 25
3.2 Pengumpulan Data...................................................................................................... 25
3.3 Analisa Kebutuhan ...................................................................................................... 25
iii
3.4 Analisa Perancangan ................................................................................................... 27
3.4.1 Deskripsi Sistem ............................................................................................... 27
3.5 Implementasi Sistem................................................................................................... 34
3.6 Uji Coba Sistem ........................................................................................................... 34
3.7 Penarikan Kesimpulan................................................................................................. 36
BAB IV PERANCANGAN ..................................................................................................... 37
4.1 Analisa Kebutuhan Perangkat Lunak .......................................................................... 38
4.1.1 Identifikasi Aktor .............................................................................................. 38
4.1.2 Daftar Kebutuhan Sistem ................................................................................. 38
4.1.3 Diagram Use Case ............................................................................................ 39
4.1.4 Skenario Use Case ............................................................................................ 40
4.2 Perancangan Sistem Pakar .......................................................................................... 41
4.2.1 Akuisisi Pengetahuan ....................................................................................... 41
4.2.2 Basis Pengetahuan ........................................................................................... 41
4.2.2.1 Himpunan Bahasa Variable ....................................................................... 42
4.2.2.2 Semesta Pembicaraan............................................................................... 42
4.2.2.3 Fungsi Derajat Keanggotaan Variabel Tekanan Darah (SBP) .................... 42
4.2.2.4 Fungsi Derajat Keanggotaan Variabel Heart Rate..................................... 45
4.2.2.5 Fungsi Derajat Keanggotaan Variabel Tingkat kejenuhan Oksigen pada
Darah (SPO2) ......................................................................................................... 47
4.2.2.6 Fungsi Derajat Keanggotaan Variabel Suhu .............................................. 49
4.2.2.7 Fungsi Derajat Keanggotaan Variabel Gula Darah .................................... 51
4.2.2.8 Fungsi Derajat Keanggotaan Output ......................................................... 53
4.2.2.9 Rule ........................................................................................................... 57
4.2.3 Mesin Inferensi ................................................................................................ 86
4.2.4 Subsistem Antarmuka Pengguna ..................................................................... 87
BAB V IMPLEMENTASI....................................................................................................... 88
5.1 Lingkungan Implementasi ........................................................................................... 88
5.1.1 Kebutuhan Perangkat Keras............................................................................. 88
5.1.2 Kebutuhan Perangkat Lunak ............................................................................ 88
5.2 Implementasi Aplikasi ................................................................................................. 89
5.2.1 Kode Sumber Aplikasi ...................................................................................... 89
5.2.1.1 BloodSugar.java ........................................................................................ 89
iv
5.2.1.2 HeartRate.java .......................................................................................... 93
5.2.1.3 SystolicBloodPressure.java ....................................................................... 97
5.2.1.4 OxygenSaturation.java ............................................................................ 101
5.2.1.5 Temperature.java.................................................................................... 104
5.2.1.6 Risk.java .................................................................................................. 107
5.2.1.7 RiskPrediction.java .................................................................................. 108
5.2.1.8 PCMFuzzy.java ........................................................................................ 113
5.2.1.9 DBConnection.java .................................................................................. 114
5.2.1.10 LoginWindow.java................................................................................. 115
5.2.1.11 MainWindow.java ................................................................................. 121
5.2.1.12 TestUnit.java ......................................................................................... 138
5.2.2 Antarmuka Aplikasi ........................................................................................ 139
BAB VI PENUTUP ............................................................................................................. 141
7.1 Kesimpulan................................................................................................................ 141
7.2 Saran ......................................................................................................................... 141
DAFTAR PUSTAKA ........................................................................................................... 142
v
DAFTAR GAMBAR
Gambar 2.1 Blok Diagram Sistem Pakar ................................................................ 9

Gambar 2.2 Konsep Dasar Fuzzy .......................................................................... 12
Gambar 2.3 Perbandingan Fungsi Keanggotaan Himpunan Fuzzy Terhadap Crisp
............................................................................................................................... 13
Gambar 2.4 Fungsi Keanggotaan Segitiga ............................................................ 14
Gambar 2.5 Fungsi Keanggotaan Trapesium ........................................................ 15
Gambar 2.6 Diagram Blok Sistem Inferensi Fuzzy ............................................... 17
Gambar 2.7 Inferensi dengan menggunakan MetodeTsukamoto ......................... 18
Gambar 3.1 Alur Penelitian................................................................................... 24
Gambar 3.2 Diagram Alir Pengambilan Data Sampel .......................................... 26
Gambar 3.3 Arsitektur Sistem Pakar Pemantau kondisi Rawat Inap .................... 28
Gambar 3.4 Diagram alir aplikasi dari segi user................................................... 32
Gambar 3.5 Diagram alir aplikasi dari segi pakar................................................. 33
Gambar 3.6 Diagram alir proses pengujian dengan akurasi ................................. 34
Gambar 3.7 Diagram alir proses pengujian fungsional sistem ............................. 35
Gambar 4.1 Pohon Perancangan Sistem Pakar Pemantau Kondisi Pasien Rawat
Inap Menggunakan Fuzzy Inferensi Tsukamoto ................................................... 37
Gambar 4.2 Diagram Use Case............................................................................. 39
Gambar 4.3 Grafik fuzzy set tekanan darah ........................................................... 44
Gambar 4.4 Grafik fuzzy set heart rate ................................................................. 46
Gambar 4.5 Grafik fuzzy set SPO2........................................................................ 48
Gambar 4.6 Grafik fuzzy set suhu ......................................................................... 50
Gambar 4.7 Grafik fuzzy set gula darah ................................................................ 51
Gambar 4.8 Grafik fuzzy set risk group ................................................................ 54
Gambar 4.9 Flowchart Metode Fuzzy Tsukamoto ................................................ 86
Gambar 4.10 Antarmuka Sistem ........................................................................... 87
Gambar 5.1 Antarmuka Window Log in ............................................................. 139
Gambar 5.2 Antarmuka Window Utama ............................................................. 140
vi
DAFTAR TABEL
Tabel 3.1 Konsep pengetahuan sistem pakar pemantau kondisi pasien rawat inap
............................................................................................................................... 30
Tabel 4.1 Identifikasi Aktor .................................................................................. 38
Tabel 4.2 Daftar kebutuhan Sistem ....................................................................... 38
Tabel 4.3 Skenario Use Case ................................................................................ 40
Tabel 4.4 Semesta Pembicaraan ............................................................................ 42
Tabel 4.5 Range Fuzzy Set SBP ........................................................................... 43
Tabel 4.6 Range Fuzzy Set Heart Rate.................................................................. 45
Tabel 4.7 Range Fuzzy Set SPO2 .......................................................................... 48
Tabel 4.8 Range Fuzzy Set Suhu ........................................................................... 49
Tabel 4.9 Range Fuzzy Set Gula Darah ................................................................. 51
Tabel 4.10 Range fuzzy set risk group .................................................................. 53
vii
DAFTAR PERSAMAAN
Persamaan 2-1 Fungsi Keanggotaan Himpunan Fuzzy ...13

Persamaan 2-2 Fungsi Keanggotaan Segitiga ..14
Persamaan 2-3 Fungsi Keanggotaan Trapesium .15
viii
BAB I
PENDAHULUAN
1.1 Latar Belakang
Rumah sakit sebagai salah satu institusi pelayanan umum, membutuhkan

keberadaan suatu sistem informasi yang akurat dan handal, serta cukup memadai
untuk meningkatkan pelayanan kepada para pasien serta lingkungan yang terkait
lainnya. Informasi yang intensif memainkan peranan vital dalam pengambilan
keputusan.
Menurut surat Keputusan Menteri Kesehatan RI no.
159b/MENKES/PER/II/1988 tentang rumah sakit, pelayanan kesehatan di rumah
sakit berupa pelayanan rawat jalan, pelayanan rawat inap, dan pelayanan gawat
darurat yang mencangkup pelayanan medik dan pelayanan penunjang medik [8:3].
Masing-masing pelayanan mempunyai sistem informasi yang terintegrasi dalam
suatu sistem informasi rumah sakit. Kondisi penyakit level kronis membutuhkan
pemantauan yang ekstra waspada dari pihak rumah sakit. Pemantauan tersebut
bisa mengenai infus, tekanan darah, detak jantung dan lain-lain. Dengan demikian
dibutuhkan sistem pemantau kondisi pasien untuk memudahkan kerja tenaga
medis dalam melayani pasien.
Sistem Early Warning Scoring System (EWSS) dapat mengidentifikasi
keadaan pasien yang beresiko lebih awal dan menggunakan multi parameter [9:4].
Para ahli mengatakan bahwa, sistem ini dapat menghasilkan manfaat lebih bagi
pasien dan rumah sakit dengan mengidentifikasi penurunan kondisi pasien. EWS
yang digunakan di rumah sakit Indonesia saat ini masih berbasis kertas dan
perhitungannya masih dilakukan manual dengan menggunakan tabel. Perlu
dilakukan trasformasi media dari semula kertas ke media yang dapat dengan
mudah diakses oleh tenaga medis. Salah satu media yang dapat digunakan adalah
komputer.
Pada sistem pakar terdapat salah suatu metode yaitu fuzzy Tsukamoto.
Metode Tsukamoto mengaplikasikan penalaran monoton pada setiap aturannya.
Kalau pada penalaran monoton, sistem hanya memiliki satu aturan. Pada metode
Tsukamoto, sistem terdiri atas beberapa aturan [10:22]. Fuzzy Tsukamoto
merupakan metode yang cocok digunakan dalam pemantauan kondisi pasien
rawat inap. Fuzzy Tsukamoto merupakan metode yang sangat fleksibel dan
memiliki toleransi pada data yang ada. Metode ini memiliki kelebihan yaitu lebih
intuitif, diterima oleh banyak pihak, lebih cocok untuk masukan yang diterima
dari manusia bukan mesin.
Pada penelitian sebelumnya yang berjudul Fuzzy Logic Based Patients
Monitoring System(Jumanah Abdullah Al-Dmour. 2013), membahas tentang
pemantauan kondisi pasien rumah sakit menggunakan teknologi RFID untuk
mengintegrasikan tanda-tanda vital seperti suhu tubuh, tekanan darah, gula darah,
dan kadar oksigen dalam darah. Sistem yang telah dibuat sebelumnya terlalu rumit
untuk diaplikasikan pada setiap rumah sakit. Karena tidak semua rumah sakit
mempunyai teknologi serupa.
Berdasarkan permasalahan tersebut maka perlu dikembangkan perangkat
lunak dengan kemampuan sama atau mendekati seorang pakar sistem pemantauan
kondisi pasien rawat inap dengan ketelitian tinggi, lebih sederhana dan lebih
lengkap dibandingkan sistem yang serupa. Untuk itu kami mengangkat judul
Sistem Pakar Pemantau Kondisi Pasien Rawat Inap Menggunakan Fuzzy
Inferensi Tsukamoto.
1.2 Rumusan Masalah
Berdasarkan paparan latar belakang tersebut, maka rumusan masalah

adalah sebagai berikut
1. Bagaimana merancang dan mengimplementasikan sistem pakar
pemantau kondisi pasien rawat inap menggunakan fuzzy inferensi
metode Tsukamotto.
2. Bagaimana menguji sistem pakar pemantau kondisi pasien rawat inap
menggunakan fuzzy inferensi metode Tsukamotto.
2
1.3 Batasan Masalah
Penelitian ini dibatasi oleh hal-hal sebagai berikut:

1. Kriteria yang digunakan terdiri dari:
a. SBAR
Situation
Background
Assessment
Recommendation [7:17]
b. EWS (Early Warning Score). Pengamatan fisiologi yang dilakukan
meliputi:
Oxygen saturation
Blood sugar
Heart rate
Systolic blood pressure
Temperature [5:5] [9:7].
2. Pemprosesan data (EWS) menggunakan fuzzy logic dengan metode
inferensi tsukamoto [5:58-62].
3. Bahasa pemrograman yang digunakan adalah bahasa pemrograman Java.
4. DBMS yang digunakan adalah MySQL.
5. Perangkat lunak IDE yang digunakan untuk implementasi sistem ini
adalah Netbeans.
6. Pengujian disesuaikan dengan kebutuhan mata kuliah Logika Fuzzy.
1.4 Tujuan
Tujuan penelitian ini adalah merancang, mengimplementasikan dan

menguji sistem pakar pemantau kondisi pasien rawat inap menggunakan fuzzy
inferensi Tsukamoto.
3
1.5 Manfaat
Manfaat penelitian ini adalah
1.5.1 Bagi Pasien

1. Dapat memberikan kenyaman pada pasien sehingga mengurangi
keluhan dari pasien mengenai lambatnya penanganan dokter.
2. Dapat mempercepat waktu distribusi informasi kondisi pasien.
1.5.2 Bagi Tenaga Medis (Suster dan Dokter)

1. Dapat memberikan kenyaman pada tenaga medis dalam melakukan
monitoring keadaan pasien rawat inap.
2. Dapat meningkatkan efektifitas dan efisiensi waktu antara tenaga
medis
1.5.3 Bagi Rumah Sakit
1. Dapat meningkatkan pelayanan terhadap pasien.
2. Dapat meningkatkan kepercayaan publik terhadap Rumah Sakit.
1.5.4 Bagi Penulis
1. Proyek akhir ini diharapkan dapat menjadi pembelajaran dan dapat
menambah pengalaman di bidang studi keilmuan yang terkait.
1.6 Sistematika Penulisan
Untuk mencapai tujuan yang diharapkan, maka sistematika penulisan yang

disusun dalam proyek akhir ini adalah sebagai berikut:
BAB I Pendahuluan
Bab ini berisi tentang latar belakang, rumusan masalah, batasan masalah,
tujuan penelitian, manfaat penelitian, sistematika penulisan, dan waktu
pengerjaan dari penelitian sistem pakar pemantau kondisi pasien rawat
inap menggunakan fuzzy inferensi Tsukamoto.
4
BAB II Dasar Teori
Bab ini terdiri membahas teori-teori yang mendukung dalam perancangan
dan pengembangan sistem pakar pemantau kondisi pasien rawat inap
menggunakan fuzzy inferensi Tsukamoto.
BAB III Metodologi
Membahas tentang metode yang digunakan dalam penelitian sistem pakar
pemantau kondisi pasien rawat inap menggunakan fuzzy inferensi
Tsukamoto yang berupa studi literatur.
BAB IVAnalisis Kebutuhan dan Perancangan
Membahas tentang analisa kebutuhan dari sistem pakar pemantau kondisi
pasien rawat inap menggunakan fuzzy inferensi Tsukamoto dan kemudian
merancang hal-hal yang berhubungan dengan analisa tersebut.
BAB V Implementasi
Membahas tentang hasil perancangan dari analisis kebutuhan dan
implementasi sistem pakar pemantau kondisi pasien rawat inap
menggunakan fuzzy inferensi Tsukamoto.
BAB VI Penutup
Memuat kesimpulan yang diperoleh dari pembuatan dan pengujian
perangkat lunak sistem pakar pemantau kondisi pasien rawat inap
menggunakan fuzzy inferensi Tsukamoto yang dikembangkan dalam
proyek akhir ini serta saran-saran untuk pengembangan lebih lanjut.
5
BAB II
DASAR TEORI
2.1 Pelayanan Rawat Inap
Pelayanan rawat inap merupakan salah satu bentuk pelayanan rumah sakit
yang memberikan pelayanan kepada pasien yang perlu menginap untuk keperluan
observasi, diagnosis, pengobatan, bagi individu dengan keadaan medis tertentu,
pada kasus bedah, kebidanan, penyakit kronis atau rehabilitasi yang memerlukan
perawatan dokter setiap hari. Sedangkan DepKes 1991 membatasi pelayanan
rawat inap adalah layanan terhadap pasien masuk rumah sakit yang menempati
tempat tidur untuk keperluan observasi, diagnosis, terapi, rehabilitasi medis dan
atau pelayanan medis lainnya (Antin Yohana. 2006)
2.2 Sistem Pakar
Sistem pakar adalah perangkat lunak komputer yang menggunakan

pengetahuan (aturan-aturan tentang sifat dari suatu unsur masalah), fakta dan
teknik inferensi untuk masalah yang biasanya membutuhkan kemampuan seorang
ahli (Marimin, 2005). Pengetahuan yang digunakan dalam sistem pakar terdiri
dari akidah-kaidah (rules) atau informasi dari pengalaman tentang tingkah laku
suatu unsur dari suatu gugus persoalan. Kaidah-kaidah biasanya memberikan
deskripsi tentang kondisi yang diikuti oleh akibat dari prasyarat tersebut.
Tujuan perancangan sistem pakar adalah untuk mempermudah kerja atau
bahkan menggantikan tenaga ahli, penggabungan ilmu dan pengalaman dari
beberapa tenaga ahli, training tenaga ahli baru, penyediaan keahlian yang
diperlukan oleh suatu proyek yang tidak ada atau tidak mampu membayar tenaga
ahli. Hal tersebut dapat dipahami secara rasional, karena kaderisasi tenaga ahli
dalam suatu organisasi sangat diperlukan, terutama untuk badan usaha yang
mempunyai keterbatasan dana untuk menyediakan tenaga ahli.
Penggabungan ilmu dan pengalaman para tenaga ahli bukan merupakan
pekerjaan yang mudah, khususnya untuk tenaga ahli yang berbeda dalam bidang
6
keahlian. Dalam hal ini sistem pakar dirancang untuk menyimpan dan
menggunakan ilmu serta pengalaman dari satu atau beberapa tenaga ahli. Untuk
itu sustu sistem pakar yang mempunyai kapasitas besar diperkirakan mampu
memecahkan suatu persoalan yang tidak dapat dipecahkan oleh satu atau
sekelompok kecil tenaga ahli [10:12-13].
2.2.1 Ciri dan Karakteristik Sistem Pakar
Ada berbagai ciri dan karakteristik yang membedakan sistem pakar dengan
sistem yang lain. Ciri dan karakteristik ini menjadi pedoman utama dalam
pengembangan sistem pakar. Ciri dan karakteristik yang dimaksud antara lain
[2:1-3]:
1. Pengetahuan sistem pakar merupakan suatu konsep, bukan berbentuk
numeris. Hal ini dikarenakan komputer melakukan proses pengolahan data
secara numerik sedangkan keahlian dari seorang pakar adalah fakta dan
aturan-aturan, bukan numerik.
2. Informasi dalam sistem pakar tidak selalu lengkap, subyektif, tidak
konsisten, subyek terus berubah dan tergantung pada kondisi lingkungan
sehingga keputusan yang diambil bersifat tidak pasti dan tidak mutlak ya
atau tidak akan tetapi menurut ukuran kebenaran tertentu. Oleh karena
itu dibutuhkan kemampuan sistem untuk belajar secara mandiri dalam
menyelesaikan masalah-masalah dengan pertimbangan-pertimbangan
khusus.
3. Kemungkinan solusi sistem pakar terhadap suatu permasalahan adalah
bervariasi dan mempunyai banyak pilihan jawaban yang dapat diterima,
semua faktor yang ditelusuri memiliki ruang masalah yang luas dan tidak
pasti. Oleh karena itu diperlukan sistem yang fleksibel dalam menangani
kemungkinan solusi dari berbagai permasalahan.
4. Perubahan atau pengembangan pengetahuan dalam sistem pakar dapat
terjadi setiap saat bahkan sepanjang waktu sehingga diperlukan
kemudahan dalam modifikasi sistem untuk menampung jumlah
pengetahuan yang semakin besar dan semakin bervariasi.
7
5. Pandangan dan pendapat setiap pakar tidak selalu sama, oleh karena itu
tidak ada jaminan bahwa solusi sistem pakar merupakan jawaban yang
pasti benar. Setiap pakar akan memberikan pertimbangan-pertimbangan
berdasarkan faktor subyektif.
6. Keputusan merupakan bagian terpenting dari sistem pakar. Sistem pakar
harus memberikan solusi yang akurat berdasarkan masukan pengetahuan
meskipun solusinya sulit sehingga fasilitas informasi sistem harus selalu
diperlukan.
Blok diagram sistem pakar bisa dilihat pada Gambar 2.2. Pada gambar
tersebut menjelaskan bahwa sistem pakar juga dapat dilihat dari sudut pandang
lingkungan (environment) dalam sistem. Terdapat dua lingkungan yaitu
lingkungan konsultasi dan lingkungan pengembangan. Lingkungan konsultasi
diperuntukkan bagi pengguna non pakar untuk melakukan konsultasi dengan
sistem yang tujuannya adalah mendapatkan nasehat pakar. Sedangkan lingkungan
pengembangan ditujukan bagi pembangun sistem pakar untuk membangun
komponen dan memasukkan pengetahuan hasil akuisisi pengetahuan ke dalam
basis pengetahuan.
8
LINGKUNGAN KONSULTASI LINGKUNGAN PENGEMBANGAN
Basis
Fakta tentang
Pemakai Pengetahuan :
kejadian tertentu
fakta dan aturan
Antarmuka Knowledge
Fasilitas Engineer
Penjelas
Mesin Inferensi
Pakar
Aksi yang
direkomendasikan
Perbaikan
Workplace Pengetahuan
Gambar 2.1 Blok Diagram Sistem Pakar

Sumber: [12:24]
Secara umum sistem pakar biasanya terdiri atas beberapa komponen yang
masing-masing berhubungan. Basis pengetahuan sistem pakar yang dibutuhkan
untuk memahami, memformulasi, dan memecahkan masalah. Basis pengetahuan
tersusun atas dua elemen dasar yaitu [11]:
1. Fakta
Fakta disini misalnya situasi, konsisi dan kenyataan dari permasalahan
yang ada, serta teori dalam bidang; sistem pakar diterapkan.
2. Aturan
Aturan, yang mengarahkan penggunaan pengetahuan untuk memecahkan
masalah yang spesifik dalam bidang yang khusus.
Mesin inferensi (inference engine) merupakan otak dari sistem pakar.

Mesin inferensi juga dikenal sebagai penerjemah aturan (rule interpreter).
Komponen ini berupa program komputer yang menyediakan suatu metodologi
9
untuk memikirkan (reasoning) dan memformulasi kesimpulan. Kerja mesin
inferensi meliputi [11]:
1. Menentukan aturan mana akan dipakai
2. Menyajikan pertanyaan kepada pemakai, ketika diperlukan.
3. Menambahkan jawaban ke dalam memori sistem pakar.
4. Menyimpulkan fakta baru dari sebuah aturan
5. Menambahkan fakta tadi ke dalam memori
2.2.2 Rule
Rule adalah sebuah struktur knowledge yang menghubungkan beberapa

informasi yang sudah diketahui ke informasi lain sehingga dapat disimpulkan.
Sebuah rule adalah sebuah bentuk knowledge yang prosedural. Dengan demikian
yang dimaksud dengan sistem pakar berbasis rule adalah sebuah program
computer untuk memproses masalah dari informasi spesifik yang terdapat dalam
memori aktif dengan sebuah set dari rule dalam knowledge base, dengan
menggunakan inference engine untuk menghasilkan informasi baru.
Struktur rule secara logika menghubungkan satu atau lebih anteseden (juga
disebut premis) yang terletak dalam bagian IF dengan satu atau lebih konsekuen
(juga disebut konklusi) yang terletak dalam bagian THEN. Secara umum, sebuah
rule dapat mempunyai premis jamak dihubungkan dengan pernyataan AND
(konjungsi) pernyataan OR (disjungsi) atau kombinasi dari keduanya.
Dalam sistem pakar berbasis aturan domain knowledge ditampung dalam
sebuah set dari rules dan dimasukkan dalam basis sistem pengetahuan. Sistem
menggunakan aturan ini dengan informasi selama berada dalam memori aktif
untuk memecahkan masalah. Sistem pakar berbasis aturan mempunyai arsitektur
yang dapat dijelaskan sebagai berikut [10:14-15]:
1. User interface
Digunakan sebagai media oleh user untuk melihat dan berinteraksi dengan
sistem.
2. Developer interface
Media yang digunakan untuk mengembangkan sistem oleh engineer.
10
3. Fasilitas penjelasan
Sub sistem yang berfungsi untuk menyediakan penjelesan dalam sistem
reasoning.
4. Program eksternal
5. Program seperti basis data, spreadsheet, yang bekerja dalam mendukung
keseluruhan sistem.
2.3 Logika Fuzzy
Logika fuzzy didasarkan pada logika Boolean yang umum digunakan

dalam komputasi. Secara ringkas, teorema fuzzy memungkinkan komputer
berpikir tidak hanya dalam skala hitam-putih (0 dan 1, mati atau hidup) tetapi
juga dalam skala abu-abu. Dalam Logika Fuzzy suatu preposisi dapat
direpresentasikan dalam derajat kebenaran (truthfulness) atau kesalahan
(falsehood) tertentu.
Pada sistem diagnosis fuzzy peranan manusia/operator lebih dominan.
Pengiriman data dilaksanakan oleh operator ke dalam sistem. Ketika sistem
memerlukan data tambahan. Selain itu operator dapat meminta atau menanyakan
informasi dari sistem diagnosis berupa hasil konklusi atau prosedur detail hasil
diagnosis oleh sistem. Dari sifat sistem ini, sistem diagnosis fuzzy dapat
digolongkan pada sistem pakar fuzzy. Sistem pakar fuzzy adalah sistem pakar yang
menggunakan notasi fuzzy pada aturan-aturan dan proses inference (logika
keputusan).
Banyak sistem yang terlalu kompleks untuk dimodelkan secara akurat,
meskipun dengan persamaan matematis yang kompleks. Dalam kasus seperti itu,
ungkapan bahasa yang digunakan dalam logika kabur dapat membantu
mendefinisikan karakteristik operasional sistem dengan lebih baik. Ungkapan
bahasa untuk karakteristik sistem biasanya dinyatakan dalam bentuk implikasi
logika. Misalnya aturan IF-THEN.
Penerapan logika fuzzy dapat meningkatkan kinerja sistem kendali dengan
menekan munculnya fungsi-fungsi liar pada keluaran yang disebabkan oleh
11
fluktuasi pada variabel masukan. Pendekatan logika fuzzy secara garis besar
diimplementasikan dalam tiga tahapan yaitu [10:15-16]:
1. Tahap pengaburan (fuzzification) yakni pemetaan dari masukan tegas ke
himpunan kabur.
2. Tahap inferensi, yakni pembangkitan aturan kabur.
3. Tahap penegasan (defuzzification), yakni tranformasi keluaran dari nilai
kabur ke nilai tegas.
Fuzzy Controller
Inference
Mechanism
Reference
Defuzification
Fuzification
Input Input Output

Process
Rule-base
Gambar 2.2 Konsep Dasar Fuzzy

Sumber:[13]
2.3.1 Himpunan Fuzzy
Himpunan fuzzy adalah konsep yang mendasari lahirnya logika fuzzy.

Himpunan fuzzy adalah sebuah himpunan yang anggotanya memiliki derajat
keanggotaan tertentu. Setiap anggota memiliki derajat keanggotaan tertentu yang
ditentukan oleh fungsi keangotaan (membership function) tertentu atau disebut
juga fungsi karakteristik (characteristic function).
Himpunan crisp adalah himpunan klasik yang telah dikenal secara umum.
Himpunan crisp membedakan anggotanya dengan nilai nol atau satu, anggota
himpunan atau bukan. Sebagai contoh himpunan crisp yaitu, pada himpunan
manusia. Himpunan wanita atau laki-laki dapat dipresentasikan dengan mudah
12
dengan cara himpunan klasik. Akan tetapi, bagaimana mempresentasikan
himpunan pada manusia muda atau tua. Muda atau tua itu cukup relatif tidak
langsung terpisah hanya karena berbeda satu hal. Dalam hal ini himpunan fuzzy
dapat memberikan pengelompokan dengan memberi nilai dalam derajat tertentu.
Berbeda dengan himpunan klasik, keanggotaan himpunan fuzzy dapat bernilai
parsial [6:1].
(x)
Classical (crips) set A
Fuzzy set
1.0
Membership
function (x)
0.0
X
Gambar 2.3 Perbandingan Fungsi Keanggotaan Himpunan Fuzzy Terhadap

Crisp
Sumber : [6:1]
semesta, maka fungsi keanggotaan (fungsi keanggotaan/fungsi karakteristik A

Fungsi keanggotaan didefinisikan sebagai berikut: Jika X adalah himpunan
[0,1](2-1)
pada X) yang didefinisikan oleh himpunan fuzzy A memiliki ketentuan berikut:
himpunan A dan B dinyatakan sama jika dan hanya jika (x) = (x). Jika (x)
nilai [0,1] adalah interval bilangan real dari nol sampai dengan satu. Dua
bernilai nol, berarti x bukan anggota dari himpunan fuzzy A. Jika (x) bernilai
satu, menunjukkan x adalah himpunan fuzzy A. Sementara nilai antara nol hingga
13
satu menunjukkan bahwa x merupakan anggota dari himpunan fuzzy A secara
parsial [6:1-2].
2.3.2 Fungsi Keanggotaan Fuzzy
Fungsi keanggotaan (membership function) adalah suatu kurva yang

menunjukkan pemetaan titik-titik input data ke dalam nilai keanggotaannya
(sering juga disebut dengan derajat keanggotaan) yang memiliki interval 0 sampai
1. Salah satu cara yang dapat digunakan untuk mendapatkan nilai keanggotaan
adalah menggunakan pendekatan fungsi. Macam-macam fungsi keanggotaan
[10:16-17]:
1. Fungsi keanggotaan yang mempunyai parameter a, b, dan c dengan
formulasi segitiga (x: a, b, c) = max{min{(x a)/(b-a), (c-x)/(c-b)}, 0}.
Gambar 2.4 Fungsi Keanggotaan Segitiga

Sumber: [10:17]
dengan a, b, dan c merupakan parameter segitiga (x: a, b, c). Fungsi

Keanggotaan Kurva Segitiga:
0 ;

; <
[ ]

; < <
.(2-2)
14
2. Fungsi keanggotaan yang mempunyai parameter a,b,c, dan d dengan
formulasi Trapesium (x; a, b, c, d) = max{min{(x-a)/(b-a), 1, (d-x)/(d-c)},
0}.
Gambar 2.5 Fungsi Keanggotaan Trapesium

Sumber : [10:17]
dengan a,b,c, dan d merupakan parameter trapesium (x: a, b, c, d). Fungsi

Keanggotaan Kurva Trapesium:
0 ; "

! ; <
[ ]
1 ; <
!# ; < < "
...(2-3)
#
2.4 Fuzzy Inference System (FIS) Tsukamoto
Inferensi adalah proses penggabungan banyak aturan berdasarkan data

yang tersedia. Komponen yang melakukan inferensi dalam sistem pakar disebut
mesin inferensi. Dua pendekatan untuk menarik kesimpulan pada IF-THEN rule
(aturan jika-maka) adalah forward chaining dan backward chaining [3:36].
2.4.1 Forward Chaining
Forward chaining mencari bagian JIKA terlebih dahulu. Setelah semua

kondisi dipenuhi, aturan dipilih untuk mendapatkan kesimpulan. Jika kesimpulan
15
yang diambil dari keadaan pertama bukan dari keadaan yang terakhir, maka ia
akan digunakan sebagai fakta untuk disesuaikan dengan kondisi aturan JIKA yang
lain untuk mendapatkan kesimpulan yang lebih baik. Proses ini berlanjut hingga
dicapai kesimpulan akhir.
2.4.2 Backward Chaining
Backward chaining adalah kebalikan dari forward chaining. Pendekatan ini

dimulai dari kesimpulan dan hipotesis bahwa kesimpulan adalah benar. Mesin
inferensi kemudian mengidentifikasi kondisi JIKA yang diperlukan untuk
membuat kesimpulan benar dan mencari fakta untuk menguji apakah kondisi
JIKA adalah benar. Jika semua kondisi JIKA adalah benar, maka aturan dipilih
dan kesimpulan dicapai. Jika beberapa kondisi salah, maka aturan dibuang dan
aturan berikutnya digunakan sebagai hipotesis kedua. Jika tidak ada fakta yang
membuktikan bahwa semua kondisi JIKA adalah benar atau salah, maka mesin
inferensi terus mencari aturan yang kesimpulannya sesuai dengan kondisi JIKA
yang tidak diputuskan untuk bergerak satu langkah ke depan memeriksa kondisi
tersebut. Proses ini berlanjut hingga suatu set aturan didapat untuk mencapai
kesimpulan atau untuk membuktikan tidak dapat mencapai kesimpulan.
Sistem inferensi fuzzy merupakan suatu kerangka komputasi yang
didasarkan pada teori himpunan fuzzy, aturan fuzzy yang berbentuk IF-THEN, dan
penalaran fuzzy. Secara garis besar, diagram blok proses inferensi fuzzy terlihat
pada Gambar 2.6.
16
Aturan-1
IF-THEN Fuzzy
Crips
Input Agregasi
Aturan-n
IF-THEN Fuzzy
Fuzzy
Defuzzy
Crips
Output
Gambar 2.6 Diagram Blok Sistem Inferensi Fuzzy

Sumber: [3:37]
Sistem inferensi fuzzy menerima input crisp. Data input kemudian dikirim
ke basis pengetahuan yang berisi n aturan fuzzy dalam bentuk IF-THEN. Fire
strength (nilai keanggotaan anteseden atau ) akan dicari pada setiap aturan. Apabila
aturan lebih dari satu, maka akan dilakukan agregasi semua aturan. Selanjutnya
pada hasil agregasi akan dilakukan defuzzy untuk mendapatkan nilai crisp sebagai
output sistem. Salah satu metode FIS yang dapat digunakan untuk pengambilan
keputusan adalah metodeTsukamoto.
Pada metode Tsukamoto, implikasi setiap aturan berbentuk implikasi
"Sebab-Akibat"/Implikasi "Input-Output" yang antara anteseden dan konsekuen harus ada
berhubungan. Setiap aturan direpresentasikan menggunakan himpunan-himpunan
fuzzy, dengan fungsi keanggotaan yang monoton. Kemudian untuk menentukan
hasil tegas (crisp solution) digunakan rumus penegasan (defuzzifikasi) yang
disebut "Metode rata-rata terpusat" atau "Metode defuzzifikasi rata-rata terpusat
(center average deffuzzyfier). Untuk lebih memahami metodeTsukamoto,
perhatikan Contoh 2.1.
Contoh 2.1: Misalkan ada 2 variabel input, Var-1 (x) dan Var-2(x), serta variabel
output, Var-3(z), dimana Var-1 terbagi atas 2 himpunan yaitu A1 dan A2. Var-2
17
terbagi atas 2 himpunan B1 dan B2, Var-3 juga terbagi atas 2 himpunan yaitu C1
dan C2 (C1 dan C2 harus monoton). Ada 2 aturan yang digunakan, yaitu:
[R1] IF (x is A1) and (y is B2) THEN (z is C1)
[R2] IF (x is A2) and (y is B1) THEN (z is C2)
Pertama-tama dicari fungsi keanggotaan dari masing-masing himpunan
fuzzy dari setiap aturan, yaitu himpunan A1, B2 dan C1 dari aturan fuzzy [R1], dan
himpunan A2, B1 dan C2 dari aturan fuzzy [R2]. Aturan fuzzy R1 dan R2 dapat
direpresentasikan dalam Gambar 2.7 untuk mendapatkan suatu nilai crisp Z.
Gambar 2.7 Inferensi dengan menggunakan MetodeTsukamoto

Sumber: [3:39]
Karena pada metode Tsukamoto operasi himpunan yang digunakan adalah

konjungsi (AND), maka nilai keanggotaan anteseden dari aturan fuzzy [R1] adalah
irisan dari nilai keanggotaan A1 dari Var-1 dengan nilai keanggotaan B1 dari Var-2.
Menurut teori operasi himpunan, maka nilai keanggotaan anteseden dari operasi
konjungsi (And) dari aturan fuzzy [R1] adalah nilai minimum antara nilai
18
keanggotaan A1 dari Var-1 dan nilai keanggotaan B2 dari Var-2. Demikian pula
nilai keanggotaan anteseden dari aturan fuzzy [R2] adalah nilai minimum antara
nilai keanggotaan A2 dari Var-1 dengan nilai keanggotaan B1 dari Var-2.
Selanjutnya, nilai keanggotaan anteseden dari aturan fuzzy [R1] dan [R2]
masing-masing disebut dengan 1 dan 2. Nilai 1 dan 2 kemudian disubstitusikan
pada fungsi keanggotaan himpunan C1 dan C2 sesuai aturan fuzzy [R1] dan [R2]
untuk memperoleh nilai z1 dan z2, yaitu nilai z (nilai perkiraan produksi) untuk
aturan fuzzy [R1] dan [R2]. Nilai output crisp/nilai tegas Z dapat diperoleh
dengan cara mengubah input (berupa himpunan fuzzy yang diperoleh dari
komposisi aturan-aturan fuzzy) menjadi suatu bilangan pada domain himpunan
fuzzy tersebut. Cara ini disebut dengan metode defuzzifikasi(penegasan). Metode
defuzzifikasi yang digunakan dalam metode Tsukamoto adalah metode
defuzzifikasi rata-rata terpusat (center average defuzzyfier).
2.5 Bahasa Pemrograman Java
Bahasa pemrograman Java dikembangkan di Sun Microsystems dibawah

pengawasan dari tokoh-tokoh dari Net yaitu James Gosling dan Bill Joy. Java
didesain agar menjadi bahasa pemrograman yang independen terhadap jenis
mesin (machine-independent) yang cukup aman untuk melintasi jaringan dan
kuat untuk menggantikan kode executable asal.
Sebagian besar antusiasme untuk Java pada awalnya tersentralisasi sekitar
kapabilitasnya untuk membangun aplikasi tertanam (embedded applications)
untuk World Wide Web; aplikasi ini disebut applets. Applets dapat menjadi
program mandiri pada dirinya sendiri, atau front-end mutakhir pada program
yang dijalankan pada server. Ketertarikan telah bergeser ke area lain akhir-akhir
ini. Dengan Java 2, Java memiliki alat paling mutakhir untuk membangun
antarmuka pengguna berbasis grafis (graphical user interface); perkembangan ini
membuat Java menjadi platform populer untuk mengembangkan perangkat lunak
aplikasi tradisional. Java juga sudah menjadi platform penting untuk aplikasi sisi
server, menggunakan antarmuka servlet, dan untuk aplikasi enterprise
19
menggunakan teknologi seperti Enterprise JavaBeans. Dan Java adalah pilihan
platform untuk aplikasi terdistribusi modern.
Bibit Java ditanam pada tahun 1990 oleh kepala peneliti Sun
Microsystems yaitu Bill Joy. Sun telah mendorong suatu ide sejak permulaan Sun
di awal tahun 1980: Jaringan adalah computer. Sun berkompetisi dalam
workstation market yang relatif kecil pada waktu itu, sedangkan Microsoft
memulai dominasi dari dunia PC berbasis Intel. Saat Sun ketinggalan dalam
revolusi PC, Joy ditarik ke Aspen, Colorado, untuk bekerja pada penelitian yang
lebih lanjut. Ia berkomitmen untuk menyelesaikan tugas kompleks dengan
perangkat lunak sederhana, dan menemukan yang tepatnya disebut Sun Aspen
Smallworks.
Dari anggota asli tim programmer kecil yang dibentuk di Aspen, James
Gosling yang akan diingat sebagai bapak Java. Gosling pertama kali melejitkan
namanya di awal tahun 1980 sebagai penulis Gosling Emacs, versi pertama dari
editor Emacs populer yang ditulis bengan bahasa C dan dijalankan dibawah
Unix. Gosling Emacs menjadi populer, namun kemudian tertutup oleh versi
gratis, GNU Emacs, yang ditulis oleh desainer asli Emacs. Gosling telah pindah
untuk mendesain sistem window NeWS dari Sun pada waktu itu.
Mendesain NeWS mengajarkan Gosling kekuatan dari integrasi bahasa
ekspresif dengan network-aware windowing GUI. Hal tersebut juga mengajarkan
Sun bahwa komunitas pemrograman internet akan menolak untuk menerima
standar hak milik, tidak peduli seberapa bagus hal tersebut nantinya. Bibit dari
skema lisensi permissive disebarkan oleh kegagalan NeWS. Gosling membawa
apa yang telah ia pelajari ke proyek Aspen baru milik Bill Joy, dan pada 1992,
bekerja pada proyek memimpin ke penemuan cabang Sun, FirstPerson, Inc.
Misinya adalah untuk memimpin Sun menuju dunia elektronik consumer.
Tim FirstPerson bekerja pada mengembangkan perangkat lunak untuk alat
informasi, seperti telepon seluler dan personal digital assistants (PDAs).
Tujuannya adalah untuk meng-enable transfer informasi dan aplikasi real-time
melalui infrared murah dan jaringan berbasis paket. Limitasi memori dan
bandwidth mendiktekan kode kecil dan efisien. Basis dari aplikasi juga menuntut
mereka untuk menjadi aman dan kuat. Gosling dan anggota timnya memulai
20
memrogram di C++, namun mereka kemudian terkepung dalam bahasa yang
terlalu kompleks, berat, dan tidak aman untuk tugasnya. Mereka memutuskan
untuk memulai dari awal, dan Gosling memulai bekerja pada sesuatu yang ia
juluki C++ minus minus.
Telah menjadi kenyataan bahwa bahtera PDA belum sampai dengan
tenggelamnya Apple Newton, jadi Sun mengalihkan usaha FirstPerson ke TV
interaktif (ITV). Bahasa pemrograman terpilih untuk ITV merupakan nenek
moyang dekat dari Java, yaitu Oak. Oak tidak mampu menyelamatkan penyebab
hilangnya ITV bahkan dengan keeleganannya dan kemampuannya untuk
menyediakan interaktifitas aman. Pelanggan tidak menginginkannya, dan Sun
kemudian mengabaikan konsep tersebut.
Joy dan Gosling berkolaborasi untuk memutuskan strategi baru untuk
bahasa mereka pada waktu itu. Pada waktu itu di tahun 1993, terjadi ledakan
interest di internet, khususnya World Wide Web, yang mempersembahkan
kesempatan baru. Oak adalah bahasa pemrograman yang kecil, kuat,
architecture-independent, dan berorientasi obyek. Selama hal tersebut terjadi,
terdapat pula kebutuhan untuk bahasa pemrograman yang universal dan pandai-
jaringan (network-savvy). Sun dengan cepat mengubah fokus, dengan sedikit
melengkapi kembali, Oak menjadi Java [4 : 10]
2.6 Metode SBAR
Kerangka komunikasi efektif yang digunakan di rumah sakit adalah

komunikasi SBAR (Situation, Background, Assessment, Recommendation).
Metode komunikasi ini digunakan pada saat perawat melakukan handover ke
pasien. Komunikasi SBAR adalah kerangka teknik komunikasi yang disediakan
untuk petugas kesehatan dalam menyampaikan kondisi pasien[14:6].
SBAR adalah metode terstruktur untuk mengkomunikasikan informasi
penting yang membutuhkan perhatian segera dan tindakan berkontribusi terhadap
eskalasi yang efektif dan meningkatkan keselamatan pasien. SBAR juga dapat
digunakan secara efektif untuk meningkatkan serah terima antar shift atau antara
staf di daerah klinis yang sama atau berbeda. Melibatkan semua anggota tim
21
kesehatan untuk memberikan masukan ke dalam situasi pasien termasuk
memberikan rekomendasi. SBAR memberikan kesempatan untuk diskusi antara
anggota tim kesehatan atau tim kesehatan lainnya.
Keuntungan dari penggunaan metode SBAR adalah[14:6-7]:
1. Kekuatan perawat berkomunikasi secara efektif.
2. Dokter percaya pada analisa perawat karena menunjukkan perawat paham
akan kondisi pasien.
3. Memperbaiki komunikasi sama dengan memperbaiki keamanan pasien.
Komunikasi efektif SBAR dapat diterapkan oleh semua tenaga kesehatan,
diharapkan semua tenaga kesehatan maka dokumentasi tidak terpecah sendiri-
sendiri. Diharapkan dokumentasi catatan perkembangan pasien terintegrasi
dengan baik. sehingga tenaga kesehatan lain dapat mengetahui perkembangan
pasien.
1. Situation: Bagaimana situasi yang akan dibicarakan/dilaporkan?
- Mengidentifikasi nama diri petugas dan pasien.
- Diagnosa medis
- Apa yang terjadi dengan pasien yang memprihatinkan
2. Background: Apa latar belakang informasi klinis yang berhubungan dengan
situasi?
- Obat saat ini dan alergi
- Tanda-tanda vital terbaru
- Hasil laboratorium: tanggal dan waktu tes dilakukan dan hasil tes
sebelumnya untuk perbandingan
- Riwayat medis
- Temuan klinis terbaru
3. Assessment: berbagai hasil penilaian klinis perawat
- Apa temuan klinis?
- Apa analisis dan pertimbangan perawat
- Apakah masalah ini parah atau mengancam kehidupan?
4. Recommendation: apa yang perawat inginkan terjadi dan kapan?
- Apa tindakan/rekomendasi yang diperlukan untuk memperbaiki masalah?
- Apa solusi yang bisa perawat tawarkan dokter?
22
- Apa yang perawat butuhkan dari dokter untuk memperbaiki kondisi
pasien?
- Kapan waktu yang perawat harapkan tindakan ini terjadi?
Sebelum serah terima pasien, perawat harus melakukan [14:8]:
1. Perawat mendapatkan pengkajian kondisi pasien terkini.
2. Perawat mengkumpulkan data-data yang diperlukan yang berhubungan
dengan kondisi pasien yang akan dilaporkan.
3. Perawat memastikan diagnosa medis pasien dan prioritas masalah
keperawatan yang harus dilanjutkan.
4. Perawat membaca dan pahami catatan perkembangan terkini & hasil
pengkajian perawat shift sebelumnya.
5. Perawat menyiapkan medical record pasien termasuk rencana perawat harian.
23
BAB III
METODOLOGI PENELITIAN
Pada bab ini akan dibahas tentang langkah-langkah yang akan dilakukan
dalam penyusunan proyek akhir mata kuliah Logika Fuzzy, yang meliputi: studi
literatur, pengumpulan data, analisa dan perancangan, implementasi, pengujian
sistem, pembuatan laporan. Berikut adalah diagram alir dari metode penelitian
yang dilakukan.
Gambar 3.1 Alur Penelitian

Sumber: Perancangan
24
3.1 Studi Literatur
Dasar teori yang digunakan untuk menunjang penulisan serta pengerjaan

proyek akhi, dipelajari dalam studi literatur. Teori-teori pendukung penulisan serta
pemahaman tentang tugas akhir diperoleh dari buku, jurnal, e-book, penelitian
sebelumnya yang berkaitan tentang topic proyek akhir ini, bantuan dan mesin
pencari (search engine) internet. Referensi utama yang diperlukan untuk
menunjang penulisan ini adalah:
1. Pelayanan rawat inap
2. Sistem Pakar
3. Metode Fuzzy Tsukamotto
4. Metode SBAR
5. EWS (early warning score)
6. Pengujian Akurasi
3.2 Pengumpulan Data
Lokasi penelitian proyek akhir ini adalah Rumah Sakit Umum Lavalette
Malang. Hipotesis penelitian ini merancang, membangun, dan
mengimplementasikan sistem pakar pemantau kondisi pasien rawat inap
menggunakan fuzzy inferensi Tsukamotto. Pengumpulan data pada penelitian ini
menggunakan data primer. Data primer adalah data yang didapatkan langsung dari
sumber penelitian. Pengumpulan data primer dapat dilakukan menggunakan
wawancara, kuisioner maupun observasi.
3.3 Analisa Kebutuhan
Analisis kebutuhan bertujuan untuk mendapatkan semua kebutuhan dalam

membangun sistem pakar pemantau kondisi pasien rawat inap. Metode analisis
yang digunakan adalah Object Oriented Analysis dengan menggunakan bahasa
pemodelan UML (Unified Modeling Language). Diagram Use Case digunakan
untuk mendeskripsikan kebutuhan-kebutuhan dan fungsionalitas sistem dari
25
perspektif end-user. Analisis kebutuhan dilakukan dengan mengidentifikasi semua
kebutuhan (requirements) sistem.
Sumber data yang digunakan berasal rumah sakit Lavalette. Data yang
dimaksud adalah sistem pemantauan kondisi pasien rawat inap yang sudah ada di
rumah sakit Lavalette sebagai acuan dalam pengembangan aplikasi dan
perancangan sistem. Selain itu, diperlukan juga kuisioner, untuk menentukan
kebutuhan pasien dan tenaga medis dalam sistem yang diinginkan. Data-data
tersebut digunakan untuk menghitung tingkat keberhasilan dari sistem. Diagram
alir untuk pengambilan data sampel ditunjukkan pada Gambar 3.2.
Gambar 3.2 Diagram Alir Pengambilan Data Sampel

Sumber: Perancangan
Spesifikasi Kebutuhan perangkat yang digunakan dalam pembuatan sistem

pakar diantaranya:
1. Spesifikasi Kebutuhan Hardware
a. Komputer (PC)/Laptop
26
2. Spesifikasi Kebutuhan Software
a. Linux distribusi Ubuntu 12.04 sebagai sistem operasi yang
digunakan.
b. MySql sebagai sistem manajemen database.
c. Bahasa Java dipilih untuk membangun aplikasi.
3.4 Analisa Perancangan
Analisa dan perancangan sistem dilakukan sebelum penelitian

dilaksanakan, Analisa dan perancangan sistem berisi uraian umum tentang
jalannya sistem.
3.4.1 Deskripsi Sistem
Sistem pakar pemantau kondisi pasien rawat inap dibangun dengan

menerapkan metode fuzzy inferensi Tsukamotto. Arsitektur sistem pakar pemantau
kondisi pasien rawat inap dibentuk seperti pada Gambar 3.3.
27
Gambar 3.3 Arsitektur Sistem Pakar Pemantau kondisi Rawat Inap
Sumber: Perancangan
Proses yang dapat dijelaskan dari arsitektur sistem pakar pemantau kondisi
pasien rawat inap yakni, pertama perawat akan memasukkan data PHR (Personal
Healt Record) yang meliputi tekanan darah, heart rate, suhu, gula darah dan
tingkat kejenuhan oksigen (SPO2) ke dalam sistem. Selanjutnya, masuan tersebut
akan menentukan rekomendasi tindakan dari tenaga medis yang sesuai.
Proses interaksi user dengan sistem dilakukan melalui antarmuka
pengguna. Pada antarmuka juga dilengkapi dengan fasilitas penjelas yang
memberikan penjelasan bagaimana hasil kesimpulan diperoleh sehingga dapat
meyakinkan pengguna. Kesimpulan yang diperoleh dari input yang diberikan
berupa rekomendasi tindakan yang harus dilakukan oleh tenaga medis yang sesuai
dengan kondisi pasien saat itu.
28
Pakar mengambil peranan sangat aktif dalam pembuatan basis
pengetahuan. Tempat kerja disediakan bagi pakar untuk membantu memberikan
solusi bagi permasalahan saat sistem dijalankan dan menyedikan fasilitas untuk
menulis agenda dan deskripsi terhadap permasalahan khusus yang belum
diprediksi. Knowledge engineer bertanggung jawab membuat kesan yang tepat,
secara positif mengomunikasikan informasi tentang proyek, memahami tipe
pakar, mempersiapkan sesi, dan seterusnya.
Metode akuisisi pengetahuan yang digunakan adalah metode manual, yang
terdiri dari:
1. Metode wawancara terstuktur
Teknik wawancara melibatkan dialog langsung antara pakar dan
knowledge engineer. Informasi dikumpulkan dengan bantuan instrumen
konvensional (misalnya tape recorder atau kuisioner) dan selanjutnya
ditranskip, dianalisis dan dikodekan. Metode wawancara terstruktur
adalah proses berorientasi tujuan yang sistematik. Proses berorientasi
tujuan menekankan komunikasi terorganisasi antara knowledge engineer
dan pakar. Struktur sistematik mengurangi persoalan interpretasi yang
inheren dan memungkinkan knowledge engineer mencegah distorsi yang
disebabkan oleh subjektivitas pakar domain.
2. Metode analisis kasus
Pada metode analisis kasus, pakar ditanya bagaimana mereka menangani
kasus khusus di masa sebelumnya. Biasanya metode ini melibatkan
analisis dokumentasi .
Basis pengetahuan sistem pakar ini berisi pengetahuan setara pakar yang
telah diisi oleh knowledge engineer. Basis pengetahuan berisi fakta tindakan-
tindakan yang harus dilakukan seorang tenaga medis yang sesuai dengan kondisi
pasien serta aturan yang berhubungan dengan metode fuzzy. Representasi yang
digunakan yaitu aturan produksi, karena pada basis pengetahuan digunakan aturan
pengetahuan sedangkan pada mesin inferensi dapat digunakan aturan inferensi
dengan menerapkan metode fuzzy.
29
Konsep pengetahuan yang dibangun terdiri dari atribut dan alternatif yang
dibutuhkan. Atribut yang diperlukan disesuaikan dengan data input PHR.
Alternatif yang dihasilkan sesuai dengan yang ditentukan pada batasan masalah.
Konsep pengetahuan yang dibangun, digambarkan pada Tabel 3.1.
Tabel 3.1 Konsep pengetahuan sistem pakar pemantau kondisi pasien rawat inap
Minimum
Total Score Observation Alert Response
Frequency
Nurse in charge Nurse in charge to

1 12 Hourly
review if new score 1
Nurse in charge Nurse in charge t

2 6 Hourly
review
Nurse in charge & 1. SHO to review

3 4 Hourly
Team/On-call SHO within 1 hour

Team/On-call SHO within hour
2. If no response to
treatment within 1
4-6 1 Hourly hour, contact
Registrar
3. Consider continuous
patient monitoring
4. Consider transfer to
higher level of care
Nurse in charge & 1. Registrar to review
Team/On-call immediately
Registrar inform 2. Continuous patient
Team/On-call monitoring
Consultant recommended
>= 7 Hourly 3. Plan to transfer to
higher level of care
4. Activate Emergency
Response System
(ERS) (as
appropriate to
hospital model)
30
Note: Single score triggers
Score of 2 Nurse in charge & 1. SHO to review

HR <= 40 Hourly Team/On-call SHO immediately
(Bradicardia)

Team/On-call SHO immediately
Hourly pr 2. If no response to
*score of 3
as indicated treatment or still
in any single
by patients concerned contact
parameter
condition Registrar
3. Consider activating
ERS
* in certain circumstances a score of 3 in a single parameter may not require
hourly observations. i.e. some patients on O2
When communicatingpatiens score inform relevant personnel if patient is

charted for supplemental oxygen e.g. post-op.
Document all communication and management plans at each escalation
point in medical and nursing notes.
Escalation protocol may be stepped down as appropriate and documented in
management plan.
IMPORTANT:
1. If response is not carried out as above CNM/Nurse in charge must contact

the Registrar or Consultant.
2. If you are concerned about a patient ascalate care regardless of score.
Sumber: [12:24]
Basis pengetahuan berinteraksi dua arah dengan mesin inferensi; pada

mesin inferensi ini sendiri dilakukan proses pengambilan kesimpulan. Metode
penalaran yang dilakukan adalah forward chaining, yaitu berjalan dari fakta
menuju kesimpulan. Pada sistem ini dilakukan update pengetahuan dan perbaikan
secara teratur sehingga informasi yang diberikan tetap valid.
Berikut ini adalah penjelasan antarmuka pengguna saat user mengakses
aplikasi sistem pakar yang digambarkan dalam diagram alir:
1. Perawat
31
Proses penggunaan aplikasi saat log in sebagai perawat harus melakukan
log in untuk bisa masuk ke sistem. Setelah masuk ke sistem perawat harus
memasukan data PHR. Pada tahap selanjutnya proses akan berlangsung
secara otomatis. Masukan akan diproses dengan metode fuzzy sehingga
akan ditampilkan penjelasan pengambilan kesimpulan dan analisis dari
pakar.
Gambar 3.4 Diagram alir aplikasi dari segi user

Sumber: Perancangan
Proses representasi pengetahuan yang menggunakan metode aturan
produksi ditunjukkan saat proses user memasukkan data. Teknik penalaran
forward chaining ditunjukkan saat user melakukan entry data berupa fakta
hingga akhirnya mendapat keluaran berupa tindakan yang perlu dilakukan.
32
Proses inferensi dilakukan dengan menerapkan metode TOPSIS, sehingga
diperoleh kesimpulan dari fakta yang diketahui.
2. Pakar
Proses penggunaan aplikasi dari segi pakar dimulai dari pakar melakukan
log in. Setelah masuk sebagai pakar, akan muncul halaman utama. Pada
halaman utama, pakar dapat melihat data-data masukan PHR dan data
rekomendasi hasil analisis dari sistem. Selanjutnya terhadapa menu untuk
pakar mengedit data. Edit data dimaksudkan untuk mengubah data dan
atau menambahkan data hasil analisis dari sistem. Data yang telah
diakusisi oleh pakar akan ditampilkan sebagai hasil akhir.
Gambar 3.5 Diagram alir aplikasi dari segi pakar

Sumber: Perancangan
33
3.5 Implementasi Sistem
Implementasi aplikasi dilakukan dengan mengacu kepada perancangan

aplikasi. Implementasi perangkat lunak dilakukan menggunakan bahasa
pemrograman Java dengan Netbeans IDE. Pada pembuatan database sistem pakar,
digunakan Database Management System (DBMS) MySQL.
3.6 Uji Coba Sistem
Pengujian sistem dilakukan untuk mengetahui kesesuai dengan harapan

awal. Pengujian terdiri dari:
1. Pengujian akurasi
Melakukan pengujian berdasarkan implementasi yang telah dibuat
melalui perhitungan akurasi. Perhitungan akurasi digambarkan pada
diagram alir berikut.
Gambar 3.6 Diagram alir proses pengujian dengan akurasi

Sumber: Perancangan
34
Pada Gambar 3.6, pertama dilakukan perhitungan antara data hasil
keluaran dari sistem dengan hasil keluaran yang diberikan oleh pakar
yang menggunakan proses manual. Proses manual pakar adalah proses
yang biasa dilakukan pakar untuk memberi keluaran dengan
subjektifitas pakar kesahatan. Hasil akurasi yang didapat akan
digunakan sebagai acuan sebagai hasil akhir akurasi.
2. Pengujian fungsional sistem
Pengujian fungsional sistem berfungsi untuk mengetahui kinerja sistem
sesuai dengan rancangan dan tujuan yang dibuat. Berikut ini adalah
diagram alir pengujian fungsional dari sistem pakar pemilihan bidang
studi.
Gambar 3.7 Diagram alir proses pengujian fungsional sistem

Sumber: Perancangan
35
Pengujian fungsional ini dilakukan dengan memeriksa keterpenuhan
fungsional sistem pada aplikasi sistem pakar yang dibuat.
3.7 Penarikan Kesimpulan
Kesimpulan dilakukan setelah semua tahapan perancangan, implementasi

dan pengujian sistem terhadap metode yang digunakan. Penulisan saran berguna
untuk memberikan pertimbangan atas hasil yang telah dilakukan.
36
BAB IV
PERANCANGAN
Pada bab ini akan dibahas tentang perancangan sistem pakar untuk
pemantau kondisi pasien rawat inap. Tahap perancangan sistem terdiri dari
analisis kebutuhan perangkat lunak dan perancangan sistem pakar. Tahap analisis
kebutuhan perangkat lunak meliputi identifikasi aktor, daftar kebutuhan sistem,
dan use case diagram serta skenario use case. Sedangkan tahap perancangan
sistem pakar meliputi akuisisi pengetahuan, basis pengetahuan, mesin inferensi,
dan sub sistem antarmuka. Berikut ilustrasi pohon perancangan Sistem Pakar
Pemantau Kondisi Pasien Rawat Inap Menggunakan Fuzzy Inferensi Tsukamoto.
4.1.1 Identifikasi Aktor
4.1.2 Daftar Kebutuhan

Sistem
4.1 Analisis
Kebutuhan
Perangkat Lunak 4.1.3 Use Case Diagram
4.1.4 Skenario Use Case

4. Perancangan
4.2.1 Akuisisi
Pengetahuan
4.2.2 Basis Pengetahuan

4.2 Perancangan
Sistem Pakar
4.2.3 Mesin Inferensi
4.2.4 Subsistem
Antarmuka
Gambar 4.1 Pohon Perancangan Sistem Pakar Pemantau Kondisi Pasien

Rawat Inap Menggunakan Fuzzy Inferensi Tsukamoto
Sumber: Perancangan
37
4.1 Analisa Kebutuhan Perangkat Lunak
Tahapan analisa kebutuhan sistem memiliki tujuan untuk memodelkan

informasi yang akan digunakan dalam tahapan perancangan. Analisa kebutuhan
sistem yang diperlukan meliputi identifikasi aktor, daftar kebutuhan sistem, dan
use case diagram. Berikut ini merupakan penjelasan dari masing-masing
tahapannya.
4.1.1 Identifikasi Aktor
Tahapan ini bertujuan untuk mengidentifikasi aktor-aktor yang nantinya

akan berinteraksi dengan sistem. Pada kolom aktor disebutkan aktor yang
berperan dalam sistem dan pada kolom lainnya akan menunjukkan deskripsi dari
aktor. Tabel 4.1 memperlihatkan aktor yang berperan dalam sistem yang
dilengkapi dengan penjelasannya yang merupakan hasil dari proses identifikasi
aktor.
Tabel 4.1 Identifikasi Aktor

Aktor Deskripsi Aktor
User User merupakan aktor pengguna yang ingin mendapatkan analisis
sistem pakar yang berupa pemantau kondisi pasien.
Sumber: Perancangan
4.1.2 Daftar Kebutuhan Sistem
Tahapan ini bertujuan untuk menjelaskan kebutuhan sistem yang harus

dipenuhi saat aktor melakukan sebuah aksi. Daftar kebutuhan ini terdiri dari
sebuah kolom yang merupakan hal-hal yang harus disediakan oleh sistem,
sedangkan pada kolom yang lain menunjukkan nama use case yang menampilkan
fungsionalitas masing-masing kebutuhan tersebut.
Tabel 4.2 Daftar kebutuhan Sistem

Kebutuhan Aktor Nama Use Case
38
Sistem harus User
User
User
User
Sumber: Perancangan
4.1.3 Diagram Use Case
Use case diagram merupakan salah satu diagram yang digunakan untuk
menggambarkan kebutuhan-kebutuhan dan fungsionalitas dari sistem serta
digunakan untuk menunjukan aksi-aksi yang dilakukan oleh aktor dari sistem.
Gambar 4.2 merupakan diagram use case sistem pakar yang menunjukkan
spesifikasi fungsionalitas yang disediakan oleh sistem dari segi aktor Admin dan
User.
Calculate
Reset
Lihat Hasil
Lihat Rule
User
Remove Rule
Gambar 4.2 Diagram Use Case
39
Sumber: Perancangan
Dalam sistem ini aktor dapat memasukkan kondisi pasien. Selain itu aktor
juga dapat mengkalkulasi hasil dari inputan kondisi pasien. Secara otomatis
sistem akan menyimpan hasil-hasil analisa sistem pakar serta dapat melihat rule.
Disamping itu user dapat mengatur ulang input kondisi pasien serta menghapus
rule.
4.1.4 Skenario Use Case
Use case yang telah digambarkan dalam diagram use case akan lebih
dijelaskan secara terperinci dalam skenario use case. Penggunaan skenario use
case ini bertujuan untuk mendapatkan deskripsi secara global mengenai use case,
kondisi awal dan akhir yang harus dipenuhi oleh use case setelah fungsionalitas
telah dijalankan. Dalam Tabel 4.3 akan menjelaskan bagaimana tanggapan sistem
terhadap aksi yang dilakukan oleh aktor.
Tabel 4.3 Skenario Use Case

Identifikasi
Nama Mengolah data
Deskripsi Use case ini menjelaskan tentang proses input data dalam
sistem
Aktor User
Pra-kondisi Sistem telah menampilkan halaman user
Skenario Input Data
Aksi Aktor Reaksi Sistem
Aktor masuk ke halaman utama Sistem menampilkan halaman

utama
Aktor masuk ke menu input data Sistem menampilkan halaman
menu input data
Aktor masukkan data-data Sistem memasukkan data yang
berupa kondisi pasien. telah dimasukkan oleh aktor ke
dalam database.
Sistem menampilkan hasil analisis
sistem pakar.
40
Aktor melihat hasil data Sistem menampilkan hasil proses
sebelumnya. data yang dimasukkan sebelumnya.
Aktor mereset hasil data. Sistem mereset hasil data.
Sumber: Perancangan
4.2 Perancangan Sistem Pakar
Berikut ini dijelaskan tentang perancangan sistem pakar yang terdiri dari
akuisisi pengetahuan, basis pengetahuan, mesin inferensi, dan subsistem
antarmuka.
4.2.1 Akuisisi Pengetahuan
Akuisisi pengetahuan dilakukan dengan mencari berbagai informasi

tentang kondisi pasien berdasarkan tekanan darah (SBP), Heart Rate (HR),
kejenuhan kandungan oksigen dalam darah pasien (SPO2), Suhu (Temp), gula
darah (BS), dan mesin inferensi. Informasi diperoleh dari buku, jurnal, laporan
penelitian, skripsi yang telah ada sebelumnya, dan internet. Informasi-informasi
yang diperoleh membantu dalam proses pembuatan sistem pakar untuk
pemantauan kondisi pasien rawat inap.
4.2.2 Basis Pengetahuan
Basis pengetahuan berisi pengetahuan-pengetahuan pakar berupa fakta-

fakta, konsep, aturan, prosedur, dan hubungan di antaranya, yang telah
direpresentasikan dalam bentuk yang dimengerti oleh sistem. Basis pengetahuan
dibutuhkan untuk memahami, memformulasikan, dan memecahkan masalah yang
dihadapi oleh sistem, di sini basis pengetahuan berfungsi sebagai sumber referensi
untuk mengambil suatu tindakan. Basis pengetahuan dalam sistem pakar ini
meliputi himpunan bahasa variabel, semesta pembicaraan, fungsi derajat
keanggotaan, dan rule.
41
4.2.2.1 Himpunan Bahasa Variable
Himpunan bahasa variabel pada sistem pakar pemantau kondisi pasien
rawat inap adalah sebagai berikut
1.Tekanan Darah (SBP) : Low-3, Low-2, Low-1, Normal-0, High-2.

2.Heart Rate (HR) : Low-2, Low-1, Normal-0, High-1, High-2, High-3
3.Saturasi O2 (SPO2) : Low-3, Low-2, Low-1, Normal-0.
4.Suhu (TEMP) : Low-2, Normal-0, High-2
5.Gula Darah (BS) : Low-3, Low-2, Normal-0, High-2, High-3.
4.2.2.2 Semesta Pembicaraan

Berikut ini adalah semesta pembicaraan yang menjelaskan tentang kondisi
pasien rawat inap yang berdasarkan rentang kriteria-kriteria beserta rentang nilai
yang ditentukan oleh pakar.
Tabel 4.4 Semesta Pembicaraan

Input Low-3 Low-2 Low-1 Normal-0 High-1 High-2 High-3
SBP <75 70-80 80-100 95-199 - - >185

HR - <50 45-60 53-100 95-110 105- >125
130
SPO2 <85 83-90 87-95 >93 - - -
TEMP - <36.5 - 36-38.5 - >38 -
BS <66 63-72 - 70-110 - 106- >140
150
Sumber: Perancangan
4.2.2.3 Fungsi Derajat Keanggotaan Variabel Tekanan Darah (SBP)

Nilai-nilai yang berbeda tekanan darah mengubah hasilnya dengan mudah.
Dalam hal ini, kami menggunakan tekanan darah sistolik. Variabel input ini dibagi
menjadi 5 fuzzy set yaitu Low-3, Low-2, Low-1, Normal-0, dan High-2; fungsi
keanggotaan dari 5 fuzzy set adalah trapesium. Langkah pertama dalam
menerapkan algoritma kontrol logika fuzzy adalah untuk fuzzify variabel yang
42
diukur. Untuk fuzzify variabel SBP, harus ditentukan range nilai untuk SBP.
Ditentukan nilai SBP menjadi 100 sampai 185mm Hg (mungkin, tidak semua
orang setuju dengan hal ini, pilihan ini berdasarkan pengalaman ahli). Dengan
demikian kita membuat himpunan fuzzy berlabel Normal-0 dan menetapkan nilai-
nilai SBP antara 101 dan 199 mm Hg ke tingkat keanggotaan dari 1,0 di set ini.
Selanjutnya kita mengatasi masalah lebih jelas dari apa yang kisaran nilai untuk
SBP mungkin bisa normal, tetapi juga menjadi abnormal. Setiap saran ahli,
kisaran 185-199 diputuskan untuk berada di ujung atas dan 95 sampai 100 di
ujung bawah pertama. Dengan kata lain, jika SBP di atas 199 mm Hg, itu terlalu
tinggi (yang diberi label High-2 pada fuzzy set), pilihan terbaik adalah rentang
nilai antara 185 dan 199 mm Hg. Tabel fungsi keanggotaan dan grafik fuzzy set
dan variabel SBP secara berturut-turut ditunjukkan pada Tabel 4.5 dan Gambar
4.3.
Tabel 4.5 Range Fuzzy Set SBP

Input Field Range Fuzzy Set
<75 Low-3
Tekanan Darah 70 85 Low-2

Sistolik 80 100 Low-1
(TDS) 95 199 Normal-0
>185 High-2
Sumber: Perancangan
43
SBP
1.2
1
Low-3
0.8
Low-2
0.6
Low-1
0.4
Normal-0
0.2
High-2
0
0 50 100 150 200 250
Gambar 4.3 Grafik fuzzy set tekanan darah

Sumber: Perancangan
Fungsi Derajat Keanggotaan SBP
$%&' [ ] =
1, < 70
)+,+- , 70 < 75 ...........................................................(4-1)
+,
0, 75
$%&/ [ ] =
+,+- , 70 < 75
+-
! 1, 75 < 80
, 80 < 85
1,
! 1,1-
........................................................(4-2)
0, 70 85
44
$%&2 [ ] =
1,1- , 80 < 85
1-
! 1, 85 < 95
, 95 < 100
2--
!2--4,
.....................................................(4-3)
0, 80 100
5%678- [ ] =
2--4, , 95 < 100

4,
! 1, 100 < 185

, 185 < 199
244
!24421,
.............................................(4-4)
0, 95 199
9:;</ [ ] =
, 185 < 199

21,
)
24421,
1, 199
0, < 185
.....................................................(4-5)
4.2.2.4 Fungsi Derajat Keanggotaan Variabel Heart Rate

Berdasarkan sistem MEWS scoring dan setiap saran ahli, enam fuzzy set
(Low-2, Low-1, Normal-0, High-1, High-2, dan High-3) digunakan dalam variabel
heart rate. Fungsi keanggotaan dari fuzzy set ini adalah trapesium. Penentuan nilai
HR mirip dengan penentuan nilai SBP. Tabel fungsi keanggotaan dan grafik fuzzy
set variabel heart rate secara berturut-turut ditunjukkan pada Tabel 4.6 dan
Gambar 4.4.
Tabel 4.6 Range Fuzzy Set Heart Rate

Heart Rate <50 Low-2

(HR) 45 - 60 Low-1
45
53 - 100 Normal-0
95 - 110 High-1
105 - 130 High-2
>125 High-3
Sumber: Perancangan
HR
1.2
Low-2
1
0.8 Low-1
0.6 Normal-0
0.4 High-1
0.2 High-3
0
High-2
0 50 100 150 200
Gambar 4.4 Grafik fuzzy set heart rate

Sumber: Perancangan
Fungsi Derajat Keanggotaan HR
$%&/ [ ] =
1, < 45
),->, , 45 < 50 .............................................................(4-6)
,-
0, 50
$%&2 [ ] =
,'>, , 45 < 50
>,
! 1, 50 < 53
, 53 < 60
@-
! @-,'
.........................................................(4-7)
0, 45 60
46
5%678- [ ] =
@-,' , 53 < 60
,'
! 1, 60 < 95
, 95 < 100
2--
!2--4,
.................................................(4-8)
0, 53 100
9:;<2 [ ] =
2--4, , 95 < 100

4,
! 1, 100 < 105

, 105 < 110
22-
!22-2-,
.................................................(4-9)
0, 95 110
9:;</ [ ] =
22-2-, , 105 < 110

2-,
! 1, 110 < 125

, 125 < 130
2'-
! 2'-2/,
..............................................(4-10)
0, 105 130
9:;<' [ ] =
, 125 < 130

2/,
)
2'-2/,
1, 130
0, < 125
..................................................(4-11)
4.2.2.5 Fungsi Derajat Keanggotaan Variabel Tingkat kejenuhan Oksigen pada

Darah (SPO2)
Nilai variabel ini adalah tingkat kejenuhan oksigen pada darah pasien.
Dalam hal ini, digunakan empat variabel linguistik (fuzzy set) (Low-3, Low-2,
Low-1, dan Normal-0). Setiap nilai yang lebih tinggi dari 95(>95) dianggap
47
sebagai Normal-0. Pada table ini fuzzy set didefinisikan. Fungsi keanggotaan dari
fuzzy set adalah trapesium dan ditunjukkan pada Gambar 4.5.
Tabel 4.7 Range Fuzzy Set SPO2

<85 Low-3
83 - 90 Low-2
SPO2
87 - 95 Low-1
>93 Normal-0
Sumber: Perancangan
SPO2
1.2
1
0.8 Low-3
0.6 Low-2
0.4 Low-1
0.2 Normal-0
0
0 50 100 150
Gambar 4.5 Grafik fuzzy set SPO2

Sumber: Perancangan
Fungsi Derajat Keanggotaan SPO2
$%&' [ ] =
1, < 83
)1,1' , 83 < 85 ...........................................................(4-12)
1,
0, 85
48
$%&/ [ ] =
1,1' , 83 < 85
1'
! 1, 85 < 87
, 87 < 90
4-
! 4-1+
.......................................................(4-13)
0, 83 90
$%&2 [ ] =
4-1+ , 87 < 90
1+
! 1, 90 < 93
, 93 < 95
4,
! 4,4'
.......................................................(4-14)
0, 87 95
5%678- [ ] =
, 93 < 95
4'
)
4,4'
1, 95
0, < 93
......................................................(4-15)
4.2.2.6 Fungsi Derajat Keanggotaan Variabel Suhu

Tiga fuzzy set (Low-2, Normal-0, dan High-2) digunakan untuk variabel
suhu. Dalam tabel ini fuzzy set didefinisikan. Fungsi keanggotaan dari fuzzy set
ini adalah trapesium. Fungsi keanggotaan ini dijelaskan dalam Gambar 4.6.
Tabel 4.8 Range Fuzzy Set Suhu

<36.5 Low-2
Temperatur
36 - 38.5 Normal-0
(TEMP)
>38 High-2
Sumber: Perancangan
49
TEMP
1.2
0.8
Low-2
0.6
Normal-0
0.4 High-2
0.2
0
0 10 20 30 40 50
Gambar 4.6 Grafik fuzzy set suhu

Sumber: Perancangan
Fungsi Derajat Keanggotaan suhu
$%&/ [ ] =
1, < 36
)'@.,'@ , 36 < 36.5 .....................................................(4-16)
'@.,
0, 36.5
5%678- [ ] =
'@.,'@ , 36 < 36.5

'@
! 1, 36.5 < 38
, 38 < 38.5
'1.,
! '1.,'1
............................................(4-17)
0, 36 38.5
9:;</ [ ] =
, 38 < 38.5
'1
)
'1.,'1
1, 38.5
0, < 38
.....................................................(4-18)
50
4.2.2.7 Fungsi Derajat Keanggotaan Variabel Gula Darah
Gula darah merupakan faktor yang sangat penting. Input field ini memiliki
lima fuzzy set (Low-3, Low-2, Normal-0, High-2, dan High-3). Dalam sistem ini,
Telah ditetapkan bahwa jika nilai jumlah gula darah lebih rendah dari 66 (<66)
maka pasien memiliki gula darag rendah (Low-3), jika lebih tinggi dari 140
(>140) maka pasien memiliki gula darah yang sangat tinggi (High-3), dan set
lainnya ditunjukkan pada tabel dibawah ini. Gambar 4.7 menunjukkan fungsi
keanggotaan gula darah. Fungsi keanggotaan dari fuzzy set ini adalah trapesium.
Tabel 4.9 Range Fuzzy Set Gula Darah

<66 Low-3
63 - 72 Low-2
Gula Darah 70 - 110 Normal-0
106 - 150 High-2
>140 High-3
Sumber: Perancangan
BS
1.2
1 Low-3
0.8 Low-2
0.6
Normal-0
0.4
0.2 High-2
0 High-3
0 100 200 300 400 500
Gambar 4.7 Grafik fuzzy set gula darah

Sumber: Perancangan
51
Fungsi Derajat Keanggotaan Gula Darah
$%&' [ ] =
1, < 63
)@@@' , 63 < 66 ...........................................................(4-19)
@@
0, 66
$%&/ [ ] =
@@@' , 63 < 66
@'
! 1, 66 < 70
, 70 < 72
+/
! +/+-
.......................................................(4-20)
0, 63 72
5%678- [ ] =
, 70 < 72
+-

!
+/+-
1, 72 < 106
, 106 < 110
22-
!22-2-@
...........................................(4-21)
0, 70 110
9:;</ [ ] =
22-2-@ , 106 < 110

2-@
! 1, 110 < 140

, 140 < 150
2,-
! 2,-2>-
..............................................(4-22)
0, 106 150
9:;<' [ ] =
, 140 < 150

2>-
)
2,-2>-
1, 150
0, < 140
..................................................(4-23)
52
4.2.2.8 Fungsi Derajat Keanggotaan Output
Pada subseksi ini menjelaskan output dari sistem logika fuzzy. Terdapat
satu output variabel Risk Group, yang mengarahkan ketingkat kemungkinan
kondisi pasien. Range-nya dari 0 sampai 14. Nilai tertinggi adalah nilai resiko
kesehatan tertinggi pasien. Sistem ini mempunyai 15 fuzzy set untuk output
variabel risk group yaitu NRM, LRG1, LRG2, LRG3, LRG4, HRG5, HRG6,
HRG7, HRG8, HRG9, HRG10, HRG11, HRG12, HRG13, dan HRG14.
Membership functions pada variabel ini adalah trapesium. Detail membership
Functions dapat dilihat pada Tabel 4.10 dan Gambar 4.8
Tabel 4.10 Range fuzzy set risk group

Output Field Range Fuzzy Set
0<RG<0.5 NRM
0.5<RG<1.5 LRG 1
1.5<RG<2.5 LRG 2
2.5<RG<3.5 LRG 3
3.5<RG<4.5 LRG 4
4.5<RG<5.5 HRG 5
5.5<RG<6.5 HRG 6
Risk Group 6.5<RG<7.5 HRG 7
7.5<RG<8.5 HRG 8
8.5<RG<9.5 HRG 9
9.5<RG<10.5 HRG 10
10.5<RG<11.5 HRG 11
11.5<RG<12.5 HRG 12
12.5<RG<13.5 HRG 13
13.5<RG<14 HRG 14
Sumber: Perancangan
53
Risk Group
1.2
NRM
1 LRG1
LRG2
0.8
LRG3
0.6 LRG4
HRG5
0.4
HRG6
0.2 HRG7
HRG8
0
HRG9
-1 4 9 14
Gambar 4.8 Grafik fuzzy set risk group

Sumber: Perancangan
Fungsi Derajat Keanggotaan Output
, 0 < 0.5
-.,
5DE [ ] = F -.,-
0, 0 0.5
...............................................(4-24)
$DG2 [ ] =
, 0.5 < 1
-.,
2-.,
H 2., , 1 < 1.5 .....................................................(4-25)
2.,2
0, 0.5 1.5
$DG/ [ ] =
, 1.5 < 2
2.,
/2.,
H /., , 2 < 2.5 .....................................................(4-26)
/.,/
0, 1.5 2.5
54
$DG' [ ] =
, 2.5 < 3
/.,
'/.,
H '., , 3 < 3.5 .....................................................(4-27)
'.,'
0, 2.5 3.5
$DG> [ ] =
, 3.5 < 4
'.,
>'.,
H >., , 4 < 4.5 .....................................................(4-28)
>.,>
0, 3.5 4.5
9DG, [ ] =
, 4.5 < 5
>.,
,>.,
H ,., , 5 < 5.5 .....................................................(4-29)
,.,,
0, 4.5 5.5
9DG@ [ ] =
, 5.5 < 6
,.,
@,.,
H @., , 6 < 6.5 .....................................................(4-30)
@.,@
0, 5.5 6.5
9DG+ [ ] =
, 6.5 < 7
@.,
+@.,
H +., , 7 < 7.5 .....................................................(4-31)
+.,+
0, 6.5 7.5
55
9DG1 [ ] =
, 7.5 < 8
+.,
1+.,
H 1., , 8 < 8.5 .....................................................(4-32)
1.,1
0, 7.5 8.5
9DG4 [ ] =
, 8.5 < 9
1.,
41.,
H 4., , 9 < 9.5 .....................................................(4-33)
4.,4
0, 8.5 9.5
9DG2- [ ] =
, 9.5 < 10
4.,
2-4.,
H 2-., , 10 < 10.5 ................................................(4-34)
2-.,2-
0, 9.5 10.5
9DG22 [ ] =
, 10.5 < 11
2-.,
222-.,
H 22., , 11 < 11.5 .............................................(4-35)
22.,22
0, 10.5 11.5
9DG2/ [ ] =
, 11.5 < 12
22.,
2/22.,
H 2/., , 12 < 12.5 ............................................(4-36)
2/.,2/
0, 11.5 12.5
56
9DG2' [ ] =
, 12.5 < 13
2/.,
2'2/.,
H 2'., , 13 < 13.5 .............................................(4-37)
2'.,2'
0, 12.5 13.5
9DG2> [ ] =
, 13.5 < 14
2'.,
F2>2'.,
0, 13.5
................................................(4-38)
4.2.2.9 Rule
Rule merupakan serangkaian aturan yang digunakan sebagai dasar
perhitungan yang akan dilakukan dalam metode fuzzy Tsukamoto. Dibawah ini
adalah rule yang dibuat oleh pakar untuk Sistem Pakar Pemantau Kondisi Pasien
Rawat Inap Menggunakan Fuzzy Inferensi Tsukamoto.
1. If SBP=low3 and HR=low2 and SPO2=low3 and TEMP=low2 and

BS=low3 THEN EWS SCORE=13
BS=normal THEN EWS SCORE=10
BS=high2 THEN EWS SCORE=12
6. If SBP=low3 and HR=low2 and SPO2=low3 and TEMP=normal and
57
11. If SBP=low3 and HR=low2 and SPO2=low3 and TEMP=high2 and
58
46. If SBP=low3 and HR=low2 and SPO2=normal and TEMP=low2 and
59
51. If SBP=low3 and HR=low2 and SPO2=normal and TEMP=normal and
56. If SBP=low3 and HR=low2 and SPO2=normal and TEMP=high2 and
60
61
100. If SBP=low3 and HR=low1 and SPO2=low1 and TEMP=normal
and BS=high3 THEN EWS SCORE=8
101. If SBP=low3 and HR=low1 and SPO2=low1 and TEMP=high2
and BS=low3 THEN EWS SCORE=10
and BS=normal THEN EWS SCORE=7
106. If SBP=low3 and HR=low1 and SPO2=normal and TEMP=low2
62
111. If SBP=low3 and HR=low1 and SPO2=normal and TEMP=normal
116. If SBP=low3 and HR=low1 and SPO2=normal and TEMP=high2
121. If SBP=low3 and HR=normal and SPO2=low3 and TEMP=low2
126. If SBP=low3 and HR=normal and SPO2=low3 and TEMP=normal
63
131. If SBP=low3 and HR=normal and SPO2=low3 and TEMP=high2
64
166. If SBP=low3 and HR=normal and SPO2=normal and TEMP=low2
65
171. If SBP=low3 and HR=normal and SPO2=normal and
TEMP=normal and BS=low3 THEN EWS SCORE=6
TEMP=normal and BS=normal THEN EWS SCORE=3
TEMP=normal and BS=high2 THEN EWS SCORE=5
TEMP=high2 and BS=low3 THEN EWS SCORE=8
TEMP=high2 and BS=normal THEN EWS SCORE=5
TEMP=high2 and BS=high2 THEN EWS SCORE=7
181. If SBP=low3 and HR=high1 and SPO2=low3 and TEMP=low2
186. If SBP=low3 and HR=high1 and SPO2=low3 and TEMP=normal
66
191. If SBP=low3 and HR=high1 and SPO2=low3 and TEMP=high2
67
226. If SBP=low3 and HR=high1 and SPO2=normal and TEMP=low2
68
231. If SBP=low3 and HR=high1 and SPO2=normal and
236. If SBP=low3 and HR=high1 and SPO2=normal and TEMP=high2
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
TEMP=high2 and BS=normal THEN EWS SCORE=4
84
85
4.2.3 Mesin Inferensi
Dalam mesin inferensi ini akan dimodelkan cara sistem memproses data
dengan menggunakan metode ini. Proses tersebut dimulai dengan memasukkan
data dari user, kemudian data masuan user dihitung sesuai dengan perumusan
Tsukamoto.
Gambar 4.9 Flowchart Metode Fuzzy Tsukamoto

Sumber: Perancangan
86
4.2.4 Subsistem Antarmuka Pengguna
Untuk mempermudah dalam proses implementasi program, diperlukan

adanya rancangan yang menggambarkan program aplikasi yang akan dibuat ini.
Rancangan ini berupa sketsa fitur-fitur yang akan diimplementasikan dalam
aplikasi. Secara garis besar, aplikasi Sistem Pakar Pemantau Kondisi Pasien
Rawat Inap Menggunakan Fuzzy Inferensi Tsukamoto. Untuk lebih jelasnya,
dapat dilihat pada serangkaian Gambar 4.4. Pada saat aplikasi pertama kali
dijalankan, user akan masuk ke halaman utama.
Gambar 4.10 Antarmuka Sistem

Sumber: Perancangan
87
BAB V
IMPLEMENTASI
Pada bab ini akan dijelaskan tentang implementasi rancangan Sistem Pakar
Pemantau Kondisi Pasien Rawat Inap Menggunakan Fuzzy Inferensi Tsukamoto.
Ruang lingkup implementasi dalam sistem pakar ini meliputi Lingkungan
Implementasi, dan Implementasi Aplikasi (Kode Sumber Aplikasi).
5.1 Lingkungan Implementasi
Lingkungan implementasi Sistem Pakar Pemantau Kondisi Pasien Rawat

Inap Menggunakan Fuzzy Inferensi Tsukamoto meliputi lingkup perangkat keras
dan perangkat lunak komputer yang bisa digunakan untuk menjalankan sistem ini.
5.1.1 Kebutuhan Perangkat Keras
Spesifikasi perangkat keras yang digunakan dalam pengembangan Sistem

Pakar Pemantau Kondisi Pasien Rawat Inap Menggunakan Fuzzy Inferensi
Tsukamoto adalah
1. Prosesor : Intel Pentium Core i3
2. Memori (RAM) : 8 GB
3. Harddisk : 500 GB
5.1.2 Kebutuhan Perangkat Lunak
Spesifikasi perangkat lunak yang digunakan dalam pengembangan Sistem

Pakar Pemantau Kondisi Pasien Rawat Inap Menggunakan Fuzzy Inferensi
Tsukamoto adalah adalah
1. Sistem operasi : Linux Distribusi Ubuntu 12.04
2. IDE : Netbeans IDE 8.0
3. Bahasa Pemrograman : Java
4. JRE - JDK : OpenJDK Java 7
5. DBMS : MySQL
88
5.2 Implementasi Aplikasi
Tahap implementasi aplikasi menjadi salah satu bagian utama dalam

pengembangan Sistem Pakar Pemantau Kondisi Pasien Rawat Inap Menggunakan
Fuzzy Inferensi Tsukamoto. Implementasi aplikasi meliputi implementasi pada
bagian kode sumber aplikasi (back end) dan implementasi antarmuka aplikasi
(front end). Berikut ini uraian masing-masing bagian pada tahap implementasi
aplikasi.
5.2.1 Kode Sumber Aplikasi
Sistem Pakar Pemantau Kondisi Pasien Rawat Inap ini dibangun

menggunakan bahasa Java dan dalam implemetasinya, sistem ini dibangun dengan
menerapkan konsep pemrograman berorientasi objek. Dibawah ini kode sumber
aplikasi.
5.2.1.1 BloodSugar.java
package engine;
import ui.MainWindow;
import java.util.ArrayList;
public class BloodSugar {

private double bloodSugar;
private final int[] bloodSugarLinguistic = {-3,-
2,0,2,3};
private ArrayList<Integer> linguistic = new
ArrayList<Integer>();
private MainWindow mainWindow;
public BloodSugar (double bloodSugar, MainWindow

mainWindow){
this.bloodSugar = bloodSugar;
this.mainWindow = mainWindow;
}
public BloodSugar() {
}
89
public double GetBS (){
return bloodSugar;
}
public int[] getBloodSugarLinguistic() {

return bloodSugarLinguistic;
}
public void SetBS(double BS) {

this.bloodSugar = BS;
}
public void clearLinguistik(){

this.linguistic.clear();
}
public int[] convertLinguistik(){

int[] adjacent = new int[this.linguistic.size()];
int count = 0;
for (Integer n : this.linguistic){
adjacent[count++] = n.intValue();
}
return adjacent;
}
public void setLinguistik(double BS) {

mainWindow.setHasilText("BS :
"+this.bloodSugar+"\n");
if(BS < 66){
this.linguistic.add(-3);
"+this.convertToString(-3)+"\n");
}
if(BS >= 63 && BS <= 72){
}
if(BS >= 70 && BS <= 110){
this.linguistic.add(0);
"+this.convertToString(0)+"\n");
}
if(BS >= 106 && BS <= 150){
90
}
if(BS > 140){
}
}
public double selectionRule(int value){

if(value==-3){
return(low3());
}else if(value==-2){
return(low2());
}else if(value==0){
return(normal0());
}else if(value==2){
return(high2());
}else if(value==3){
return(high3());
}
else return 0;
}
public double low3(){

if (bloodSugar <= 63){
return 1;
} else if(bloodSugar > 63 && bloodSugar < 66){
return (66-bloodSugar)/3;
}else {
return 0;
}
}

if (bloodSugar >= 63 && bloodSugar <66){
return (bloodSugar-63)/3;
}else if(bloodSugar >= 66 && bloodSugar < 70){
return 1;
}else if (bloodSugar >= 70 && bloodSugar <= 72){
}else {
return 0;
}
91
}
public double normal0(){

return 1;
}else {
return 0;
}
}
public double high2(){

return 1;
}else {
return 0;
}
}

if (bloodSugar >= 150){
return 1;
} else if (bloodSugar > 140 && bloodSugar < 150){
} else{
return 0;
}
}
private String convertToString(int value){

if(value==-3){
return "low3";
return "low2";
return "low1";
}else if(value==0){
return "normal";
92
}else if(value==1){
return "high1";
}else if(value==2){
return "high2";
}else if(value==3){
return "high3";
}else return "";
}
5.2.1.2 HeartRate.java
package engine;
public class HeartRate {

private double heartRate;
private final int[] heartRateLinguistic = {-2,-
1,0,1,2,3};
public HeartRate(double heartRate, MainWindow

mainWindow){
this.heartRate = heartRate;
}
public HeartRate() {
}
public double GetHR (){

return heartRate;
}
public int[] getHeartRateLinguistic() {

return heartRateLinguistic;
}
public void SetHR(double HR) {

this.heartRate = HR;
93
}

}

int count = 0;
}
return adjacent;
}
public void setLinguistik(double HR) {

mainWindow.setHasilText("HR :
"+this.heartRate+"\n");
if(HR < 50){
}
if(HR >= 45 && HR <= 60){
}
if(HR >= 53 && HR <= 100){
}
if(HR >= 95 && HR <= 110){
}
if(HR >= 105 && HR <= 130){
}
if(HR > 125){
94
}
}

if(value==-2){
return(low2());
return(low1());
}else if(value==0){
return(normal0());
}else if(value==1){
return(high1());
}else if(value==2){
return(high2());
}else if(value==3){
return(high3());
}
else return 0;
}

if (heartRate <= 45){
return 1;
} else if(heartRate > 45 && heartRate < 50){
return (50-heartRate)/5;
}else {
return 0;
}
}

if (heartRate >= 45 && heartRate <50){
return (heartRate-45)/5;
}else if(heartRate >= 50 && heartRate < 53){
return 1;
}else if (heartRate >= 53 && heartRate <= 60){
}else {
return 0;
}
}
95
return 1;
}else if (heartRate >=95 && heartRate <= 100){
}else {
return 0;
}
}

return 1;
}else {
return 0;
}
}

return 1;
}else {
return 0;
}
}

if (heartRate >= 130){
return 1;
} else if (heartRate > 125 && heartRate < 130){
} else{
return 0;
}
}
96
if(value==-3){
return "low3";
return "low2";
return "low1";
}else if(value==0){
return "normal";
}else if(value==1){
return "high1";
}else if(value==2){
return "high2";
}else if(value==3){
return "high3";
}else return "";
}
}
5.2.1.3 SystolicBloodPressure.java
package engine;
public class SystolicBloodPressure {

private double systolicBloodPressure;
private final int[] sbpLinguistic = {-3,-2,-1,0,2};
public SystolicBloodPressure (double

systolicBloodPressure, MainWindow mainWindow){
this.systolicBloodPressure = systolicBloodPressure;
}
public SystolicBloodPressure() {
}
public double GetSBP (){

return systolicBloodPressure;
}
97
public int[] getSbpLinguistic() {
return sbpLinguistic;
}
public void SetSBP(double SBP) {

this.systolicBloodPressure = SBP;
}

}

int count = 0;
}
return adjacent;
}
public void setLinguistik(double SBP) {

mainWindow.setHasilText("SBP :
"+this.systolicBloodPressure+"\n");
if(SBP < 75){
}
if(SBP >= 70 && SBP <= 85){
}
if(SBP >= 80 && SBP <= 100){
}
if(SBP >= 95 && SBP <= 199){
}
98
if(SBP > 185){
}
}

if(value==-3){
return(low3());
return(low2());
return(low1());
}else if(value==0){
return(normal0());
}else if(value==2){
return(high2());
}
else return 0;
}

if (systolicBloodPressure < 70){
return 1;
} else if(systolicBloodPressure >= 70 &&
systolicBloodPressure < 75){
return (75-systolicBloodPressure)/5;
}else {
return 0;
}
}

if (systolicBloodPressure >= 70 &&
systolicBloodPressure <75){
return (systolicBloodPressure-70)/5;
}else if(systolicBloodPressure >= 75 &&
return 1;
}else if (systolicBloodPressure >= 80 &&
systolicBloodPressure <= 85){
}else {
return 0;
99
}
}

return 1;
}else {
return 0;
}
}

return 1;
}else {
return 0;
}
}

if (systolicBloodPressure >= 199){
return 1;
} else if (systolicBloodPressure > 185 &&
} else{
return 0;
}
}
100
if(value==-3){
return "low3";
return "low2";
return "low1";
}else if(value==0){
return "normal";
}else if(value==1){
return "high1";
}else if(value==2){
return "high2";
}else if(value==3){
return "high3";
}else return "";
}
}
5.2.1.4 OxygenSaturation.java
package engine;
public class OxygenSaturation {

private double oxygenSaturation;
private final int[] oxygenSaturationLinguistic = {-3,-
2,-1,0};
public OxygenSaturation (double oxygenSaturation,

MainWindow mainWindow){
this.oxygenSaturation= oxygenSaturation;
}
public OxygenSaturation() {
}
public double GetSPO2 (){

return oxygenSaturation;
}
101
public int[] getOxygenSaturationLinguistic() {
return oxygenSaturationLinguistic;
}
public void SetSPO2(double SPO2) {

this.oxygenSaturation = SPO2;
}

}

int count = 0;
}
return adjacent;
}
public void setLinguistik(double SPO2) {

mainWindow.setHasilText("SPO2 :
"+this.oxygenSaturation+"\n");
if(SPO2 < 85){
}
if(SPO2 >= 83 && SPO2 <= 90){
}
if(SPO2 >= 87 && SPO2 <= 95){
}
if(SPO2 > 93){
}
102
}

if(value==-3){
return(low3());
return(low2());
return(low1());
}else if(value==0){
return(normal0());
}
else return 0;
}

if (oxygenSaturation <= 83){
return 1;
} else if(oxygenSaturation > 83 && oxygenSaturation
< 85){
return (85-oxygenSaturation)/2;
}else {
return 0;
}
}

if (oxygenSaturation >=83 && oxygenSaturation <85){
return (oxygenSaturation-83)/2;
}else if(oxygenSaturation >= 85 && oxygenSaturation
< 87){
return 1;
}else if (oxygenSaturation >= 87 && oxygenSaturation
<= 90){
}else {
return 0;
}
}

if (oxygenSaturation >= 87 && oxygenSaturation <90){
}else if(oxygenSaturation >= 90 && oxygenSaturation
< 93){
103
return 1;
}else if (oxygenSaturation >= 93 && oxygenSaturation
<= 95){
}else {
return 0;
}
}

if (oxygenSaturation >= 95){
return 1;
} else if (oxygenSaturation > 93 && oxygenSaturation
< 95){
} else{
return 0;
}
}

if(value==-3){
return "low3";
return "low2";
return "low1";
}else if(value==0){
return "normal";
}else if(value==1){
return "high1";
}else if(value==2){
return "high2";
}else if(value==3){
return "high3";
}else return "";
}
5.2.1.5 Temperature.java
package engine;
104
public class Temperature {

private double temperature;
private final int[] temperatureLinguistic = {-2,0,2};
public Temperature (double temperature, MainWindow

mainWindow){
this.temperature = temperature;
}
public Temperature() {
}
public double GetTEMP (){

return temperature;
}
public int[] getTemperatureLinguistic() {

return temperatureLinguistic;
}
public void SetTEMP(double TEMP) {

this.temperature = TEMP;
}

}

int count = 0;
}
return adjacent;
}
public void setLinguistik(double TEMP) {

mainWindow.setHasilText("TEMP :
105
"+this.temperature+"\n");
if(TEMP < 36.5){
}
if(TEMP >= 36 && TEMP <= 38.5){
}
if(TEMP > 38){
}
}

if(value==-2){
return(low2());
}else if(value==0){
return(normal0());
}else if(value==2){
return(high2());
}
else return 0;
}

if (temperature <= 36){
return 1;
} else if(temperature > 36 && temperature < 36.5){
return (36.5-temperature)/0.5;
}else {
return 0;
}
}

if (temperature >= 36 && temperature <36.5 ){
return (temperature-36)/0.5;
} else if (temperature >=36.5 && temperature < 38 ){
return 1;
} else if (temperature >=38 && temperature <= 38.5
106
){
return (38.5-temperature)/0.5;
}else{
return 0;
}
}

if (temperature >= 38.5){
return 1;
} else if (temperature > 38 && temperature < 38.5){
return (temperature-38)/0.5;
} else{
return 0;
}
}

if(value==-3){
return "low3";
return "low2";
return "low1";
}else if(value==0){
return "normal";
}else if(value==1){
return "high1";
}else if(value==2){
return "high2";
}else if(value==3){
return "high3";
}else return "";
}
}
5.2.1.6 Risk.java
package engine;
public class Risk {

private int Risk;
public Risk(int Risk) {

this.Risk = Risk;
107
}
public Risk() {
}
public int getRisk() {

return Risk;
}
public void setRisk(int Risk) {

this.Risk = Risk;
}
}
5.2.1.7 RiskPrediction.java
package engine;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.DecimalFormat;
import java.util.logging.Level;
import java.util.logging.Logger;
public class RiskPrediction {
private double sbpValue, heartRateValue, spo2Value,

tempValue, bloodSugarValue;
private double alpha[] = new double[50];
private double Z[] = new double[50];
private int[] Lsbp,Lhr,Lspo2,Ltemp,Lbs;
private int[] str=new int[7];
private ResultSet rs=null;
private DBConnection strconn = null;
private MainWindow pcm;
public RiskPrediction(double systolicBloodPressure,

double heartRate, double oxygenSaturation, double
temperature, double bloodSugar, DBConnection startConn,
MainWindow mainWindow) {
this.sbpValue = systolicBloodPressure;
this.heartRateValue = heartRate;
this.spo2Value = oxygenSaturation;
this.tempValue = temperature;
108
this.bloodSugarValue = bloodSugar;
this.strconn = startConn;
this.pcm = mainWindow;
}
private double findMin(double a, double b, double c,

double d, double e) {
if (a < b && a < c && a < d && a < e) {
return a;
} else if (b < a && b < c && b < d && b < e) {
return b;
} else if (c < a && c < b && c < d && c < e) {
return c;
} else if (d < a && d < b && d < c && d < e){
return d;
}else if (e < a && e < b && e < c && e < d){
return e;
}else if (a==b && b==c && c==d && d==e){
return a;
}else {
return 0;
}
}
private int applyRule() {

SystolicBloodPressure SBP = new
SystolicBloodPressure(sbpValue, this.pcm);
HeartRate HR = new HeartRate(heartRateValue,
this.pcm);
OxygenSaturation SPO2 = new
OxygenSaturation(spo2Value, this.pcm);
Temperature TEMP = new Temperature(tempValue,
this.pcm);
BloodSugar BS = new BloodSugar(bloodSugarValue,
this.pcm);
Risk risk = new Risk();
int count=0;
pcm.ClearHasilText();
pcm.setHasilText("***** Proses *****\n\n\n");
pcm.setHasilText("=== Fuzzifikasi ===\n");
SBP.setLinguistik(this.sbpValue);
Lsbp=SBP.convertLinguistik();
109
SBP.clearLinguistik();
pcm.setHasilText("\n");
HR.setLinguistik(this.heartRateValue);
Lhr=HR.convertLinguistik();
HR.clearLinguistik();
SPO2.setLinguistik(this.spo2Value);
Lspo2=SPO2.convertLinguistik();
SPO2.clearLinguistik();
TEMP.setLinguistik(this.tempValue);
Ltemp=TEMP.convertLinguistik();
TEMP.clearLinguistik();
BS.setLinguistik(this.bloodSugarValue);
Lbs=BS.convertLinguistik();
BS.clearLinguistik();
pcm.setHasilText("\n\n");
pcm.setHasilText("=== Selection Rule ===\n");

for(int a=0;a<Lsbp.length;a++){
for(int b=0;b<Lhr.length;b++){
for(int c=0;c<Lspo2.length;c++){
for(int d=0;d<Ltemp.length;d++){
for(int e=0;e<Lbs.length;e++){
rs = strconn.query("SELECT *
from rule where SBP="+Lsbp[a]+" AND HR="+Lhr[b]+" AND
SPO2="+Lspo2[c]+" AND TEMP="+Ltemp[d]+" AND BS="+Lbs[e]+"");
try {
while (rs.next()) {
str[0]=rs.getInt(1);
110
}
} catch (SQLException ex) {
Logger.getLogger(RiskPrediction.class.getName()).log(Level.S
EVERE, null, ex);
}
pcm.setProsessText("Rule
No."+str[0]+" => If SBP="+this.convertToString(str[1])+" and
HR="+this.convertToString(str[2])+" and
SPO2="+this.convertToString(str[3])+" and
TEMP="+this.convertToString(str[4])+" and
BS="+this.convertToString(str[5])+" THEN EWS
SCORE="+str[6]+"\n");
pcm.setHasilText("Rule
No."+str[0]+" => If SBP="+this.convertToString(str[1])+" and
pcm.setHasilText("miu SBP
"+this.convertToString(str[1])+" =
"+SBP.selectionRule(str[1])+"\n");
pcm.setHasilText("miu HR
"+HR.selectionRule(str[2])+"\n");
pcm.setHasilText("miu SPO2
"+SPO2.selectionRule(str[3])+"\n");
pcm.setHasilText("miu TEMP
"+TEMP.selectionRule(str[4])+"\n");
pcm.setHasilText("miu BS
"+BS.selectionRule(str[5])+"\n\n");
alpha[count]=findMin(SBP.selectionRule(str[1]),
HR.selectionRule(str[2]), SPO2.selectionRule(str[3]),
TEMP.selectionRule(str[4]), BS.selectionRule(str[5]));
Z[count]=str[6];
count++;
}
}
111
}
}
}
return count;
}

if(value==-3){
return "low3";
return "low2";
return "low1";
}else if(value==0){
return "normal";
}else if(value==1){
return "high1";
}else if(value==2){
return "high2";
}else if(value==3){
return "high3";
}else return "";
}
public double getRiskPrediction() {

int count = 0;
count = applyRule();
return defuzzy(count);
}
private double defuzzy(int count) {

pcm.setHasilText("=== Defuzzifikasi ===\n");

DecimalFormat bulat = new DecimalFormat(".##");
double a = 0, temp1 = 0, temp2 = 0;
double hasil1,hasil2;
pcm.setHasilText("EWS Score = ((");

for (int i = 0; i < count; i++) {
temp1 = temp1+ alpha[i] * Z[i];
temp2 = temp2 + alpha[i];
if(i != count-
1)pcm.setHasilText("("+alpha[i]+"*"+Z[i]+")+");
else
112
pcm.setHasilText("("+alpha[i]+"*"+Z[i]+")");
}
pcm.setHasilText(")/(");
for (int i = 0; i < count; i++) {
if(i != count-1)pcm.setHasilText(alpha[i]+"+");
else pcm.setHasilText(""+alpha[i]);
}
pcm.setHasilText("))\n");
hasil1 = temp1 / temp2;
hasil2 = Double.valueOf(bulat.format(hasil1));
pcm.setHasilText("EWS Score = "+hasil1);
return hasil1;
}
}
5.2.1.8 PCMFuzzy.java
package engine;
public class PCMFuzzy {

private double systolicBloodPressure, heartRate,
oxygenSaturation, temperature, bloodSugar;
private String assesment, keterangan;
private DBConnection startConn = null;
public PCMFuzzy(double systolicBloodPressure, double

heartRate, double oxygenSaturation, double temperature,
double bloodSugar, DBConnection startConn, MainWindow
mainWindow) {
this.systolicBloodPressure =
systolicBloodPressure;
this.oxygenSaturation = oxygenSaturation;
this.temperature = temperature;
this.bloodSugar = bloodSugar;
this.mainWindow= mainWindow;
this.startConn = startConn;
public double getSystolicBloodPressure() {

return systolicBloodPressure;
113
}
public void setPemrintaan(double SBP) {

this.systolicBloodPressure = SBP;
}
public double getHeartRate() {

return heartRate;
}
public void setHeartRate(double heartRate) {

}
public double getOxygenSaturation() {

return oxygenSaturation;
}
public void setOxygenSaturation(double oxygenSaturation)

{
this.oxygenSaturation = oxygenSaturation;
}
public double getRiskPrediction(){

return (new
RiskPrediction(systolicBloodPressure,heartRate,oxygenSaturat
ion,temperature,bloodSugar,startConn,
mainWindow).getRiskPrediction());
}
}
5.2.1.9 DBConnection.java
package engine;
import com.mysql.jdbc.Connection;
import com.mysql.jdbc.Statement;
import java.sql.DriverManager;
public class DBConnection {
private Connection conn = null;
114
public DBConnection(String host, String username, String
password){
try {
this.conn = (Connection)
DriverManager.getConnection(host,username,password);
System.out.println("Connected");
}
catch (SQLException ex) {
System.out.println("Not Connected");
}
}
public ResultSet query(String sql){

ResultSet rs = null;
try {
Statement statement = (Statement)
conn.createStatement();
rs = statement.executeQuery(sql);
}
catch (SQLException ex) {}
return rs;
}
public void dmlQuery(String sql){

try {
Statement statement = (Statement)
conn.createStatement();
statement.executeUpdate(sql);
}
catch (SQLException ex) {}
}
}
5.2.1.10 LoginWindow.java
package ui;
import engine.DBConnection;
import java.awt.Dimension;
import java.awt.Toolkit;
import java.sql.Connection;
import java.sql.Statement;
115
import javax.swing.JOptionPane;
public class LoginWindow extends javax.swing.JFrame {

Connection Con;
ResultSet resultSet;
Statement statement;
DBConnection startConn = null;
public LoginWindow() {
initComponents();
initDB();
}
public void initDB(){

String hosttext="localhost";
String databasetext="pcm";
String usernametext="root";
String passwordtext="My Lab1";
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (Exception ex) {
System.err.println("Error (1): " + ex);
System.exit(1);
}
startConn = new
DBConnection("jdbc:mysql://"+hosttext+":3306/"+databasetext,
usernametext,passwordtext);
@SuppressWarnings("unchecked")
private void initComponents() {
usernameLabel = new javax.swing.JLabel();

usernameField = new javax.swing.JTextField();
passwordLabel = new javax.swing.JLabel();
loginButton = new javax.swing.JButton();
passwordField = new javax.swing.JPasswordField();
jLabel1 = new javax.swing.JLabel();
jLabel2 = new javax.swing.JLabel();
jSeparator1 = new javax.swing.JSeparator();
116
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON
_CLOSE);
usernameLabel.setText("Username");
passwordLabel.setText("Password");
loginButton.setText("Log In");
loginButton.addActionListener(new
java.awt.event.ActionListener() {
public void
actionPerformed(java.awt.event.ActionEvent evt) {
loginButtonActionPerformed(evt);
}
});
jLabel1.setText("Silahkan log in untuk masuk ke

Sistem Pakar");
jLabel2.setText("Pemantau Kondisi Pasien Rawat

Inap");
javax.swing.GroupLayout layout = new

javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment
.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout
.Alignment.TRAILING)
.addGroup(layout.createSequentialGroup()
.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE)
.addComponent(loginButton))
.addGroup(javax.swing.GroupLayout.Alignment.LEADING,
layout.createSequentialGroup()
.addGap(60, 60, 60)
117
.Alignment.LEADING)
.addComponent(usernameLabel)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.
RELATED, javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE)
.addComponent(usernameField,
javax.swing.GroupLayout.PREFERRED_SIZE, 130,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addComponent(passwordLabel)
Short.MAX_VALUE)
.addComponent(passwordField,
.Alignment.LEADING)
.addComponent(jLabel1)
.addGap(25, 25, 25)
.addComponent(jLabel2)))
.addGap(0, 0,
Short.MAX_VALUE)))))
.addGap(69, 69, 69))
.addGap(28, 28, 28)
.addComponent(jSeparator1,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE))
);
118
layout.setVerticalGroup(
.LEADING)
.addGap(24, 24, 24)
RELATED)
UNRELATED)
.addComponent(jSeparator1,
RELATED, 31, Short.MAX_VALUE)
.Alignment.LEADING)
.addComponent(usernameLabel,
javax.swing.GroupLayout.Alignment.TRAILING)
.addComponent(usernameField,
javax.swing.GroupLayout.Alignment.TRAILING,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
.addGap(18, 18, 18)
.Alignment.BASELINE)
.addComponent(passwordField,
.addComponent(passwordLabel))
.addGap(33, 33, 33)
.addComponent(loginButton)
.addGap(44, 44, 44))
);
pack();
119
}
private void
loginButtonActionPerformed(java.awt.event.ActionEvent evt) {
String password = null;
String username = null;
password = new String(passwordField.getPassword());
username = usernameField.getText();
int countRow = 0;
resultSet = startConn.query("select * from admins

where username = '"+username+"' and password =
'"+password+"'");
try {
while (resultSet.next()){
countRow = resultSet.getInt(1);
}
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, e);
}
if (countRow == 1) {
MainWindow mainWindow = new MainWindow();
mainWindow.setVisible(true);
Dimension dimension =
Toolkit.getDefaultToolkit().getScreenSize();
int x = (int) ((dimension.getWidth() -
mainWindow.getWidth()) / 2);
int y = (int) ((dimension.getHeight() -
mainWindow.getHeight()) / 2);
mainWindow.setLocation(x, y);
} else {
JOptionPane.showMessageDialog(null, "username
dan password tidak cocok");
}
private javax.swing.JLabel jLabel1;

private javax.swing.JLabel jLabel2;
private javax.swing.JSeparator jSeparator1;
private javax.swing.JButton loginButton;
120
private javax.swing.JPasswordField passwordField;
private javax.swing.JLabel passwordLabel;
private javax.swing.JTextField usernameField;
private javax.swing.JLabel usernameLabel;
}
5.2.1.11 MainWindow.java
package ui;
import engine.DBConnection;
import engine.BloodSugar;
import engine.HeartRate;
import engine.PCMFuzzy;
import engine.OxygenSaturation;
import engine.SystolicBloodPressure;
import engine.Temperature;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;
public class MainWindow extends javax.swing.JFrame {

public MainWindow() {
initComponents();
initDB();
initRule();
}
private void initDB(){

String hosttext="localhost";
String databasetext="pcm";
String usernametext="root";
String passwordtext="My Lab1";
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (Exception ex) {
System.err.println("Error (1): " + ex);
System.exit(1);
}
startConn = new
DBConnection("jdbc:mysql://"+hosttext+":3306/"+databasetext,
usernametext,passwordtext);
121
}
private void initRule(){

int countRow = 0;
int[] str = new int[7];
resultSet = startConn.query("select count(*) from
rule");
try {
countRow=resultSet.getInt(1);
}
Logger.getLogger(MainWindow.class.getName()).log(Level.SEVER
E, null, ex);
}
if (countRow>0){
resultSet=startConn.query("select * from rule");
this.ProsessText.setText("");
try {
countRow=resultSet.getInt(1);
str[0]=resultSet.getInt(1);
this.ProsessText.append(str[0]+". If
SBP="+this.convertToString(str[1])+" and
}
Logger.getLogger(MainWindow.class.getName()).log(Level.SEVER
E, null, ex);
}
this.BtnImportRule.setEnabled(false);
122
this.BtnRemoveRule.setEnabled(true);
}
else {
this.BtnImportRule.setEnabled(true);
this.BtnRemoveRule.setEnabled(false);
}
}
@SuppressWarnings("unchecked")
private void initComponents() {
jTabbedPane1 = new javax.swing.JTabbedPane();

jPanel1 = new javax.swing.JPanel();
Textsbp = new javax.swing.JTextField();
jScrollPane1 = new javax.swing.JScrollPane();
HasilText = new javax.swing.JTextArea();
jScrollPane2 = new javax.swing.JScrollPane();
ProsessText = new javax.swing.JTextArea();
Texthr = new javax.swing.JTextField();
Textspo2 = new javax.swing.JTextField();
Texttemp = new javax.swing.JTextField();
Textbs = new javax.swing.JTextField();
BtnPrediksi = new javax.swing.JButton();
BtnReset = new javax.swing.JButton();
Labelsbp = new javax.swing.JLabel();
Labelhr = new javax.swing.JLabel();
Labelspo2 = new javax.swing.JLabel();
Labeltemp = new javax.swing.JLabel();
Labelbs = new javax.swing.JLabel();
BtnImportRule = new javax.swing.JButton();
BtnRemoveRule = new javax.swing.JToggleButton();
jMenuBar1 = new javax.swing.JMenuBar();
jMenu1 = new javax.swing.JMenu();
jMenu2 = new javax.swing.JMenu();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON
_CLOSE);
jTabbedPane1.setName("jTabbedPane1"); // NOI18N
jPanel1.setName("jPanel1"); // NOI18N
Textsbp.setToolTipText("Systolic Blood Pleasure");

Textsbp.setName("Textsbp"); // NOI18N
123
Textsbp.addActionListener(new
public void
TextsbpActionPerformed(evt);
}
});
Textsbp.addKeyListener(new
java.awt.event.KeyAdapter() {
public void keyPressed(java.awt.event.KeyEvent
evt) {
TextsbpKeyPressed(evt);
}
public void keyReleased(java.awt.event.KeyEvent
evt) {
TextsbpKeyReleased(evt);
}
});
jScrollPane1.setName("jScrollPane1"); // NOI18N
HasilText.setColumns(20);
HasilText.setEditable(false);
HasilText.setRows(5);
HasilText.setName("HasilText"); // NOI18N
jScrollPane1.setViewportView(HasilText);
jScrollPane2.setName("jScrollPane2"); // NOI18N
ProsessText.setColumns(20);
ProsessText.setEditable(false);
ProsessText.setRows(5);
ProsessText.setName("ProsessText"); // NOI18N
jScrollPane2.setViewportView(ProsessText);
Texthr.setToolTipText("Heart Rate");
Texthr.setName("Texthr"); // NOI18N
Texthr.addActionListener(new
public void
TexthrActionPerformed(evt);
}
});
Texthr.addKeyListener(new
124
evt) {
TexthrKeyPressed(evt);
}
evt) {
TexthrKeyReleased(evt);
}
});
Textspo2.setToolTipText("Oxygen Saturation");
Textspo2.setName("Textspo2"); // NOI18N
Textspo2.addActionListener(new
public void
Textspo2ActionPerformed(evt);
}
});
Textspo2.addKeyListener(new
evt) {
Textspo2KeyPressed(evt);
}
evt) {
Textspo2KeyReleased(evt);
}
});
Texttemp.setToolTipText("Temperature");
Texttemp.setName("Texttemp"); // NOI18N
Texttemp.addActionListener(new
public void
TexttempActionPerformed(evt);
}
});
Texttemp.addKeyListener(new
evt) {
125
TexttempKeyPressed(evt);
}
evt) {
TexttempKeyReleased(evt);
}
});
Textbs.setToolTipText("Blood Sugar");
Textbs.setName("Textbs"); // NOI18N
Textbs.addActionListener(new
public void
TextbsActionPerformed(evt);
}
});
Textbs.addKeyListener(new
evt) {
TextbsKeyPressed(evt);
}
evt) {
TextbsKeyReleased(evt);
}
});
BtnPrediksi.setText("CALCULATE");
BtnPrediksi.setName("BtnPrediksi"); // NOI18N
BtnPrediksi.addActionListener(new
public void
BtnPrediksiActionPerformed(evt);
}
});
BtnReset.setText("RESET");
BtnReset.setName("BtnReset"); // NOI18N
BtnReset.addActionListener(new
public void
126
BtnResetActionPerformed(evt);
}
});
Labelsbp.setText("SBP");
Labelsbp.setName("Labelsbp"); // NOI18N
Labelhr.setText("HR");
Labelhr.setName("Labelhr"); // NOI18N
Labelspo2.setText("SPO2");
Labelspo2.setName("Labelspo2"); // NOI18N
Labeltemp.setText("TEMP");
Labeltemp.setName("Labeltemp"); // NOI18N
Labelbs.setText("BS");
Labelbs.setName("Labelbs"); // NOI18N
BtnImportRule.setText("Import Rule");
BtnImportRule.setName("BtnImportRule"); // NOI18N
BtnImportRule.addActionListener(new
public void
BtnImportRuleActionPerformed(evt);
}
});
BtnRemoveRule.setText("Remove Rule");
BtnRemoveRule.setName("BtnRemoveRule"); // NOI18N
BtnRemoveRule.addActionListener(new
public void
BtnRemoveRuleActionPerformed(evt);
}
});
javax.swing.GroupLayout jPanel1Layout = new

javax.swing.GroupLayout(jPanel1);
jPanel1.setLayout(jPanel1Layout);
jPanel1Layout.setHorizontalGroup(
jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Al
127
ignment.LEADING)
.addGroup(jPanel1Layout.createSequentialGroup()
.addContainerGap()
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.Grou
pLayout.Alignment.LEADING)
.addComponent(jScrollPane2,
javax.swing.GroupLayout.Alignment.TRAILING,
javax.swing.GroupLayout.DEFAULT_SIZE, 649, Short.MAX_VALUE)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
jPanel1Layout.createSequentialGroup()
pLayout.Alignment.LEADING, false)
.addComponent(Labelsbp,
.addComponent(Labelhr,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(Labelspo2,
.addComponent(BtnPrediksi,
.addComponent(Labeltemp,
.addComponent(Labelbs,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
.addGap(36, 36, 36)
pLayout.Alignment.LEADING, false)
.addComponent(BtnReset,
.addComponent(Textsbp,
.addComponent(Texthr)
.addComponent(Textspo2)
.addComponent(Texttemp)
.addComponent(Textbs))
128
.addGap(66, 66, 66)
.addComponent(BtnImportRule,
UNRELATED)
.addComponent(BtnRemoveRule)))
.addContainerGap())
);
jPanel1Layout.setVerticalGroup(
jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Al
ignment.LEADING)
.addContainerGap()
pLayout.Alignment.LEADING)
.addComponent(jScrollPane1)
pLayout.Alignment.BASELINE)
.addComponent(Textsbp,
.addComponent(Labelsbp))
.addGap(18, 18, 18)
.addComponent(Texthr,
.addComponent(Labelhr))
.addGap(18, 18, 18)
129
.addComponent(Textspo2,
.addComponent(Labelspo2))
.addGap(18, 18, 18)
.addComponent(Texttemp,
.addComponent(Labeltemp))
.addGap(18, 18, 18)
.addComponent(Textbs,
.addComponent(Labelbs))
Short.MAX_VALUE)
.addComponent(BtnPrediksi)
.addComponent(BtnReset))
.addGap(9, 9, 9)))
.addGap(36, 36, 36)
.addGap(7, 7, 7)
.addComponent(BtnImportRule)
130
.addComponent(BtnRemoveRule))
.addContainerGap())
);
jTabbedPane1.addTab("main", jPanel1);
jMenuBar1.setName("jMenuBar1"); // NOI18N
jMenu1.setText("File");
jMenu1.setName("jMenu1"); // NOI18N
jMenuBar1.add(jMenu1);
jMenu2.setText("Edit");
jMenu2.setName("jMenu2"); // NOI18N
jMenuBar1.add(jMenu2);
setJMenuBar(jMenuBar1);
javax.swing.GroupLayout layout = new

javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
.LEADING)
.addComponent(jTabbedPane1,
javax.swing.GroupLayout.Alignment.TRAILING)
);
layout.setVerticalGroup(
.LEADING)
.addComponent(jTabbedPane1,
Short.MAX_VALUE)
);
pack();
}
private void
TextsbpActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
}
131
private void
TexthrActionPerformed(java.awt.event.ActionEvent evt) {
}
private void
Textspo2ActionPerformed(java.awt.event.ActionEvent evt) {
}
private void
TexttempActionPerformed(java.awt.event.ActionEvent evt) {
}
private void
TextbsActionPerformed(java.awt.event.ActionEvent evt) {
}
private void TextsbpKeyPressed(java.awt.event.KeyEvent

evt) {
if (evt.getKeyCode() == 10 || evt.getKeyCode() ==
11) {
Textsbp.requestFocus();
}
}
private void TexthrKeyPressed(java.awt.event.KeyEvent

evt) {
11) {
Texthr.requestFocus();
}
}
private void Textspo2KeyPressed(java.awt.event.KeyEvent

evt) {
11) {
Textspo2.requestFocus();
}
}
private void TexttempKeyPressed(java.awt.event.KeyEvent
132
evt) {
11) {
Texttemp.requestFocus();
}
}
private void TextbsKeyPressed(java.awt.event.KeyEvent

evt) {
11) {
Textbs.requestFocus();
}
}
private void TextsbpKeyReleased(java.awt.event.KeyEvent

evt) {
if (!isInt(evt.getKeyCode())) {
JOptionPane.showMessageDialog(null, "Inputan
berupa angka!!");
Textsbp.setText("");
}
}
private void TexthrKeyReleased(java.awt.event.KeyEvent

evt) {
berupa angka!!");
Texthr.setText("");
}
}
private void Textspo2KeyReleased(java.awt.event.KeyEvent

evt) {
berupa angka!!");
Textspo2.setText("");
}
}
private void TexttempKeyReleased(java.awt.event.KeyEvent

evt) {
133
berupa angka!!");
Texttemp.setText("");
}
}
private void TextbsKeyReleased(java.awt.event.KeyEvent

evt) {
berupa angka!!");
Textbs.setText("");
}
}
private void
BtnPrediksiActionPerformed(java.awt.event.ActionEvent evt) {
if (Textsbp.getText().equals("")) {
belum lengkap");
} else if (Texthr.getText().equals("")) {
belum lengkap");
Texthr.requestFocus();
} else if (Textspo2.getText().equals("")) {
belum lengkap");
Textspo2.requestFocus();
} else if (Texttemp.getText().equals("")) {
belum lengkap");
Texttemp.requestFocus();
} else if (Textbs.getText().equals("")) {
belum lengkap");
Textbs.requestFocus();
} else {
HasilText.setText("");
ProsessText.setText("");
double Risk = new
PCMFuzzy(Double.valueOf(Textsbp.getText()),
Double.valueOf(Texthr.getText()),
Double.valueOf(Textspo2.getText()),
134
Double.valueOf(Texttemp.getText()),
Double.valueOf(Textbs.getText()),startConn,
this).getRiskPrediction();
HasilText.append("\n\n\n***** FINISHED *****");
}
}
private void
BtnResetActionPerformed(java.awt.event.ActionEvent evt) {
Textsbp.setText("");
Texthr.setText("");
Textspo2.setText("");
Texttemp.setText("");
Textbs.setText("");
HasilText.setText("");
initRule();
}
private void
BtnImportRuleActionPerformed(java.awt.event.ActionEvent evt)
{
int sbp[]=systolicBloodPressure.getSbpLinguistic();
int hr[]=heartRate.getHeartRateLinguistic();
int
spo2[]=oxygenSaturation.getOxygenSaturationLinguistic();
int temp[]=temperature.getTemperatureLinguistic();
int bs[]=bloodSugar.getBloodSugarLinguistic();
int total=0, jumlah=0, jumlahRule=0;
String sql=null;
//jumlahRule=sbp.length*hr.length*spo2.length*temp.length*bs
.length;
for(int a=0;a<sbp.length;a++){
for(int b=0;b<hr.length;b++){
for(int c=0;c<spo2.length;c++){
for(int d=0;d<temp.length;d++){
for(int e=0;e<bs.length;e++){
jumlah=Math.abs(sbp[a])+Math.abs(hr[b])+Math.abs(spo2[
c])+Math.abs(temp[d])+Math.abs(bs[e]);
startConn.dmlQuery("insert
into rule (SBP,HR,SPO2,TEMP,BS,risk) values
135
("+sbp[a]+","+hr[b]+","+spo2[c]+","+temp[d]+","+bs[e]+","+ju
mlah+")");
//this.ProsessText.append((total+1)+". If
SystolicBloodPressure="+this.convertToString(sbp[a])+" and
HeartRate="+this.convertToString(hr[b])+" and
OxygenSaturation="+this.convertToString(spo2[c])+" and
Temperature="+this.convertToString(temp[d])+" and
BloodSugar="+this.convertToString(bs[e])+" THEN EWS
SCORE="+jumlah+"\n");
this.ProsessText.setText("added " +total);

total++;
}
}
}
}
}
initRule();
JOptionPane.showMessageDialog(null, "Succes added
"+total+" rule");
}
private void
BtnRemoveRuleActionPerformed(java.awt.event.ActionEvent evt)
{
int dialogButton = JOptionPane.NO_OPTION;
JOptionPane.showConfirmDialog (null, "Would You Like
to Delete All Rule ?","Warning",dialogButton);
if(dialogButton == 1){ //The ISSUE is here

startConn.dmlQuery("truncate rule");
initRule();
}
}
private boolean isInt(int key) {

if (key >= 48 && key <= 57 || key >= 8 && key <=
11|| key == 46) {
return true;
} else {
return false;
}
136
}

if(value==-3){
return "low3";
return "low2";
return "low1";
}else if(value==0){
return "normal";
}else if(value==1){
return "high1";
}else if(value==2){
return "high2";
}else if(value==3){
return "high3";
}else return "";
}
public void ClearHasilText(){

this.HasilText.setText("");
}
public void ClearProsessText(){

}
public void setHasilText(String str){

this.HasilText.append(str);
}
public void setProsessText(String str){

this.ProsessText.append(str);
}
private javax.swing.JButton BtnImportRule;

private javax.swing.JButton BtnPrediksi;
private javax.swing.JToggleButton BtnRemoveRule;
private javax.swing.JButton BtnReset;
private javax.swing.JTextArea HasilText;
private javax.swing.JLabel Labelbs;
private javax.swing.JLabel Labelhr;
private javax.swing.JLabel Labelsbp;
private javax.swing.JLabel Labelspo2;
137
private javax.swing.JLabel Labeltemp;
private javax.swing.JTextArea ProsessText;
private javax.swing.JTextField Textbs;
private javax.swing.JTextField Texthr;
private javax.swing.JTextField Textsbp;
private javax.swing.JTextField Textspo2;
private javax.swing.JTextField Texttemp;
private javax.swing.JMenu jMenu1;
private javax.swing.JMenu jMenu2;
private javax.swing.JMenuBar jMenuBar1;
private javax.swing.JPanel jPanel1;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JScrollPane jScrollPane2;
private javax.swing.JTabbedPane jTabbedPane1;
private SystolicBloodPressure systolicBloodPressure =

new SystolicBloodPressure();
private HeartRate heartRate = new HeartRate();
private OxygenSaturation oxygenSaturation = new
OxygenSaturation();
private Temperature temperature = new Temperature();
private BloodSugar bloodSugar = new BloodSugar();
private DBConnection startConn = null;
private ResultSet resultSet = null;
}
5.2.1.12 TestUnit.java
package ui;
import java.awt.Dimension;
import java.awt.Toolkit;
public class TestUnit {

public static void main(String[] args) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
LoginWindow loginForm = new LoginWindow();
loginForm.setVisible(true);
Dimension dimension =
Toolkit.getDefaultToolkit().getScreenSize();
int x = (int) ((dimension.getWidth() -
loginForm.getWidth()) / 2);
int y = (int) ((dimension.getHeight() -
138
loginForm.getHeight()) / 2);
loginForm.setLocation(x, y);
}
});
}
}
5.2.2 Antarmuka Aplikasi
Antarmuka aplikasi terdiri dari dua bagian yaitu antarmuka log in dan
antarmuka utama. Antarmuka log in digunakan untuk autentikasi pengguna
aplikasi. Hanya pengguna dengan level admininistrator yang dapat menggunakan
aplikasi ini, misal perawat dan dokter. Antarmuka utama terditi dari beberapa field
input dan output yaitu field input kondisi pasien berdasarkan tekanan darah
sistolik (SBP), jetak jantung (HR), tingkat kejenuhan oksigen darah (SPO2), suhu
tubuh (TEMP), dan gula darah (BS). Field output terdari dari dua bagian yaitu
field output hasil perhitungan fuzzy dengan metode FIS Tsukamoto dan field
output rule. Gambar
Gambar 5.1 Antarmuka Window Log in

Sumber: Perancangan
139
Gambar 5.2 Antarmuka Window Utama
Sumber: Perancangan
140
BAB VI
PENUTUP
7.1 Kesimpulan
Sistem pakar adalah sistem yang berusaha mengadopsi pengetahuan

manusia ke komputer yang dirancang untuk memodelkan kemampuan
menyelesaikan masalah layaknya seorang pakar. Basis pengetahuan mengandung
pemahaman, formulasi, dan penyelesaian masalah. Komponen sistem pakar
didasarkan pada dua elemen antara lain fakta dan aturan.
Penelitian yang telah dilakukan untuk memantau kondisi pasien rawat inap
menggunakan fuzzy Tsukamoto. Pemantauan kondisi pasien rawat inap tersebut
memantau tekanan darah (SBP), detak jantung (HR), kejenuhan oksigen darah
(SPO2), suhu (TEMP), dan gula darah (BS). Sehingga pemikiran pakar
disampaikan melalu mesin inferensi untuk memudahkan pemantauan kondisi
pasien.
7.2 Saran
- Aplikasi ini memberikan deteksi dini untuk pemantauan pasien rawat inap.
- Untuk dapat mengembangkan Fuzzy Tsukamoto untuk mengetahui faktor-
faktor pada kondisi pasien.
- Untuk menyertakan faktor jenis kelamin dan usia dalam proses
pengambilan keputusan.
Hasil dari sistem yang diusulkan mengkonfirmasi efektivitas logika fuzzy
dalam pemantauan pasien, tetapi masih perlu diuji dalam lingkungan real-time
untuk menunjukkan nilai klinis penuh.
141
DAFTAR PUSTAKA
[1] Yohana, Antin. 2009. Analisis Harapan Dan Kepuasan Pasien Rawat Inap
Penyakit Dalam Terhadap Mutu Pelayanan Dokter Spesialis Di Rsi Sunan
Kudus. Semarang: Universitas Diponegoro.
[2] Teori Penunjang Sistem Pakar. URL: http://www.informatika.web.id,
diakses pada tanggal 7 April 2014.
[3] Abdurrahman, Ginanjar. 2011. Penerapan Metode Tsukamoto (Logika
Fuzzy) dalam Sistem Pendukung Keputusan untuk Menentukan Jumlah
Produksi Barang Berdasarkan Data Persediaan dan Jumlah Permintaan.
Yogyakarta: Universitas Negeri Yogyakarta.
[4] Niemeyer, Pat dan Jonathan Knudsen. 2010. Learning Java. O'Reilly.
[5] Al-Dmour, J.A. 2013. Fuzzy Logic Based Patients Monitoring System.
Thesis tidak diterbitkan, United Arab Emirates, Faculty of American
University of Sharjah College of Engineering.
[6] Purwanto, Ikhlas. 2009. Studi Pengukuran Kemiripan Rantai DNA Virus
H5N1 Berbasis Himpunan Fuzzy. Depok: Universitas Indonesia.
[7] Dalgleish, Jordanne and Beatrice Mpamugo Colleen Kearney. 2010.
Adapting and Implementing SBAR in a Home Care Setting.
[8] KepMenKes RI no. 159b/MENKES/PER/II/1988 .Rumah Sakit. Jakarta:
DepKes RI.
[9] The National Early Warning Score Project Governance and Advisory
Groups as a work stream of the Acute Medicine Progamme. 2012. Guiding
Framework and Policy for the National Early Warning Score System to
Recognise and Respond to Clinical Deterioration. Ireland:
Feidhmearnnacht ma Smirbhise Stainte Health Service Execullve.
[10] Thamrin, Fanoeel. Studi Inferensi Fuzzy Tsukamoto untuk Penentuan
Faktor Pembebasan Trafo PLN. Semarang.
[11] Sistem Pakar. URL: http://birtandp.wordpress.com/tag/manfaat-sistem-
pakar/, diakses pada tanggal 29 Mei 2014.
142
[12] Broto, A.S. 2010. Perancangan Dan Implementasi Sistem Pakar Untuk
Analisa Penyakit Dalam. Semarang: Universitas Diponegoro.
[13] Tahap Pemodelan Dalam Fuzzy Logic. URL:
http://fahmizaleeits.wordpress.com/category/kuliah-kontrol/fuzzy-
logic/page/2/, diakses pada tanggal 29 Mei 2014.
[14] Rochmat, Noer. 2014. Implementasi Sasaran Keselamatan Pasien:
Komunikasi Efektif Di Instalasi Rawat Inap. Pemerintah Propinsi Jawa
Tengah RSUD Tugurejo Semarang.
143

Early Warning System PDF

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Early Warning System PDF

Judul Asli:

Diunggah oleh

Hak Cipta:

Format Tersedia

PROYEK AKHIR

MATA KULIAH LOGIKA FUZZY

SISTEM PAKAR PEMANTAU KONDISI PASIEN RAWAT

Dosen Pengajar: Wayan Firdaus Mahmudy, Ph.D.

PROGRAM STUDI INFORMATIKA

Puji syukur penulis panjatkan kehadirat Allah SWT yang telah

Malang, 26 Mei 2014

Gambar 2.1 Blok Diagram Sistem Pakar ................................................................ 9

Persamaan 2-1 Fungsi Keanggotaan Himpunan Fuzzy ...13

1.1 Latar Belakang

Rumah sakit sebagai salah satu institusi pelayanan umum, membutuhkan

1.2 Rumusan Masalah

Berdasarkan paparan latar belakang tersebut, maka rumusan masalah

Penelitian ini dibatasi oleh hal-hal sebagai berikut:

Tujuan penelitian ini adalah merancang, mengimplementasikan dan

Manfaat penelitian ini adalah

1.5.1 Bagi Pasien

1.5.2 Bagi Tenaga Medis (Suster dan Dokter)

1.6 Sistematika Penulisan

Untuk mencapai tujuan yang diharapkan, maka sistematika penulisan yang

2.1 Pelayanan Rawat Inap

2.2 Sistem Pakar

Sistem pakar adalah perangkat lunak komputer yang menggunakan

2.2.1 Ciri dan Karakteristik Sistem Pakar

Gambar 2.1 Blok Diagram Sistem Pakar

Mesin inferensi (inference engine) merupakan otak dari sistem pakar.

Rule adalah sebuah struktur knowledge yang menghubungkan beberapa

2.3 Logika Fuzzy

Logika fuzzy didasarkan pada logika Boolean yang umum digunakan

Input Input Output

Gambar 2.2 Konsep Dasar Fuzzy

2.3.1 Himpunan Fuzzy

Himpunan fuzzy adalah konsep yang mendasari lahirnya logika fuzzy.

Gambar 2.3 Perbandingan Fungsi Keanggotaan Himpunan Fuzzy Terhadap

semesta, maka fungsi keanggotaan (fungsi keanggotaan/fungsi karakteristik A

2.3.2 Fungsi Keanggotaan Fuzzy

Fungsi keanggotaan (membership function) adalah suatu kurva yang

Gambar 2.4 Fungsi Keanggotaan Segitiga

dengan a, b, dan c merupakan parameter segitiga (x: a, b, c). Fungsi

Gambar 2.5 Fungsi Keanggotaan Trapesium

dengan a,b,c, dan d merupakan parameter trapesium (x: a, b, c, d). Fungsi

2.4 Fuzzy Inference System (FIS) Tsukamoto

Inferensi adalah proses penggabungan banyak aturan berdasarkan data

2.4.1 Forward Chaining

Forward chaining mencari bagian JIKA terlebih dahulu. Setelah semua

2.4.2 Backward Chaining

Backward chaining adalah kebalikan dari forward chaining. Pendekatan ini

Gambar 2.6 Diagram Blok Sistem Inferensi Fuzzy

Gambar 2.7 Inferensi dengan menggunakan MetodeTsukamoto

Karena pada metode Tsukamoto operasi himpunan yang digunakan adalah

2.5 Bahasa Pemrograman Java

Bahasa pemrograman Java dikembangkan di Sun Microsystems dibawah

2.6 Metode SBAR

Kerangka komunikasi efektif yang digunakan di rumah sakit adalah

Gambar 3.1 Alur Penelitian

Dasar teori yang digunakan untuk menunjang penulisan serta pengerjaan

3.2 Pengumpulan Data

3.3 Analisa Kebutuhan

Analisis kebutuhan bertujuan untuk mendapatkan semua kebutuhan dalam

Gambar 3.2 Diagram Alir Pengambilan Data Sampel

Spesifikasi Kebutuhan perangkat yang digunakan dalam pembuatan sistem

3.4 Analisa Perancangan

2--4, , 95 < 100

2--4, , 95 < 100

22-2-, , 105 < 110

0, 105 130