(1)LAMPIRAN A
#Program Sistem Media Pembelajaran
Biomedical
#include <Adafruit_TFTLCD.h>
#include <TouchScreen.h>
#define LCD_RESET A4
#define TS_MINX 204
#define TS_MINY 195
#define TS_MAXX 948
#define TS_MAXY 910
#define YP A1 // must be an analog pin, use "An" notation!
#define XM A2 // must be an analog pin, use "An" notation!
#define YM 7 // can be a digital pin
#define XP 6 // can be a digital pin
#define MINPRESSURE 10
#define MAXPRESSURE 1000
TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
#define BLACK 0x0000
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
boolean buttonEnabled = true;
int q=0; // isi array jumlah HR tekanan
int e=0; //isi array jumlah rata2 mmhg
int addr=0;
int maks_tekanan=0;
int min_tekanan=1000;
int tinggi_tekanan=0;
int tanda_puncakTekanan=0;
int tanda_puncakTekanan1=0;
int waktu_awal_puncakTekanan=0;
int waktu_akhir_puncakTekanan=0;
int waktu_selisih_puncakTekanan=0;
boolean flag_cetak_bpmBP=false;
int v=0; //proteksi data rusak tekanan darah
int simpan_tinggi[500];
int simpan_tekanan[500];
int y=0; // array simpan tinggi dan tekanan
int habis_tekanan=60;
boolean flag_cetak_SDH=false;
int r=0; // isi array tekanan
int MAP=0;
boolean flag_panjang_arrayTekanan=false;
int z=0; // panjang array tekanan
int u=0; //isi array simpan tekanan dan tinggi
int nilai_sistol=0;
int nilai_diastol=0;
int tekanan_MAP=0;
boolean j=false; // proteksi data rusak HR Tekanan darah
boolean tanda_habis=false;
boolean lanjut_cetak=false;
boolean ulang=false;
boolean dapat_sistol=false;
const int numReadings =3;
int readings[numReadings]; // the readings from the analog
input
int readIndex = 0; // the index of the current
reading
int total = 0; // the running total
int average = 0;
const int numReadings2 =8;
int readings2[numReadings2]; // the readings from the analog
input
int readIndex2 = 0; // the index of the current
reading
int total2 = 0; // the running total
int average2 = 0;
const int numReadings3 =50;
int readings3[numReadings3]; // the readings from the analog input
int readIndex3 = 0; // the index of the current reading
int total3 = 0; // the running total
int average3 = 0;
const int numReadings4 =5;
int readings4[numReadings4]; // the readings from the analog input
int readIndex4 = 0; // the index of the current reading
int total4 = 0; // the running total
int average4 = 0;
const int numReadings5 =50;
TSPoint p = ts.getPoint();
// we have some minimum pressure we consider 'valid'
// pressure of 0 means no pressing!
if (p.z > MINPRESSURE && p.z < MAXPRESSURE) {
Serial.print("X = "); Serial.print(p.x);
Serial.print("\tY = "); Serial.print(p.y);
Serial.print("\tPressure = "); Serial.println(p.z);
}
//TSPoint p = ts.getPoint();
if(p.x>108 && p.x<363 && p.y>133 && p.y <942 &&buttonEnabled &p.z >
MINPRESSURE && p.z < MAXPRESSURE )
{
Serial.println("if1");
pil=1;
else if(p.x>396 && p.x<634 && p.y>122 && p.y <935 &&buttonEnabled &p.z >
MINPRESSURE && p.z < MAXPRESSURE )
{
Serial.println("if2");
pil=2;
flag_cetak_subMenu=true;
masuk_subMenu=true;
buttonEnabled = false;
buttonEnabled1=true;
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
digitalWrite(pin_buzzer,LOW);
}
else if(p.x>662 && p.x<910 && p.y>112 && p.y <935 &&buttonEnabled
&p.z > MINPRESSURE && p.z < MAXPRESSURE )
{
Serial.println("if 3");
pil=3;
masuk_subMenu=true;
flag_cetak_subMenu=true;
flag_cetak_SDH=true;
r=0;
flag_panjang_arrayTekanan=true;
z=0;
flag_cetak_bpmBP=false;
letak_MAP=0;
MAP=0;
ulang=true;
u=0;
v=0;
digitalWrite(pin_buzzer,LOW);
tanda_puncakTekanan=0;
tanda_puncakTekanan1=0;
nilai_sistol=0;
nilai_diastol=0;
dapat_sistol=false;
digitalWrite(pin_valve,LOW);
tekanan_MAP=0;
tekanan_berhenti=false;
tanda_habis=false;
buttonEnabled = false;
buttonEnabled1=true;
lanjut_cetak=false;
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
}
switch(pil)
{
case 1:
Serial.println("case 1 ");
menuEKG();
tft.fillRect(0,0,320, 80, RED);
tft.drawRect(0,0,320,80,WHITE);
tft.fillRect(0,80,320,80, BLUE);
tft.drawRect(0,80,320,80,WHITE);
tft.fillRect(0,160,320, 79, GREEN);
tft.drawRect(0,160,320,79,WHITE);
tft.setCursor(35,185);
tft.setTextColor(WHITE);
tft.setTextSize(3);
void menuEKG()
{
while( masuk_subMenu==true)
{
//This is important, because the libraries are sharing pins
pinMode(XM, OUTPUT);
tft.fillRect(200,0,320,120,YELLOW);
tft.setCursor(220,50);
tft.drawPixel(x,nilai+3,WHITE);
masuk_subMenu=false;
}
void menuPPG()
{
while( masuk_subMenu==true)
{
//This is important, because the libraries are sharing pins
tft.fillRect(200,0,320,120,YELLOW);
tft.setCursor(220,50);
if(m>2&&buttonEnabled3==true)
{
}
masuk_subMenu=false;
}
void menuBLOOD()
{
while( masuk_subMenu==true)
{
//This is important, because the libraries are sharing pins
tft.fillRect(200,0,320,120,YELLOW);
tft.setCursor(220,50);
void baca_LED()
selisih_acLED=max_acLED-min_acLED;
Serial.print("SElisih
LED=========================================");
//Baca Waktu Puncak ke Puncak LED
if (data_acLED > 100 && flag_puncak == false )
if (data_acLED < 80 && flag_puncak==true)
{
flag_lembah = true;
digitalWrite(pin_buzzer,LOW);
}
if(data_acLED>100 && flag_lembah == true )
{
digitalWrite(pin_buzzer,HIGH);
waktu_akhirPuncak=millis();
waktu_selisihPuncak=waktu_akhirPuncak-waktu_awalPuncak;
tft.fillRect(100,25,100,25,RED);
tft.setCursor(100,25);
tft.setTextColor(WHITE);
tft.setTextSize(3);
tft.print((60000/waktu_selisihPuncak));
flag_puncak = false;
{ digitalWrite(pin_buzzer,LOW);
digitalWrite(pin_LED,LOW);
digitalWrite(pin_IR,HIGH);
flag_puncak=false;
for(x=0; x<320; x++)
Serial.print("SElisih IR=========================================");
Serial.println(selisih_acIR);
if(data_acIR > max_acIR)
{
nilai=map(data_acIR,0,1023,239,95);
//Baca Waktu Puncak ke Puncak LED
if (data_acIR > 100 && flag_puncak == false )
if (data_acIR < 80 && flag_puncak==true)
{
flag_lembah = true;
digitalWrite(pin_buzzer,LOW);
}
if(data_acIR>100 && flag_lembah == true )
{
waktu_akhirPuncak=millis();
waktu_selisihPuncak=waktu_akhirPuncak-waktu_awalPuncak;
tft.fillRect(100,25,100,25,RED);
tft.setCursor(100,25);
tft.setTextColor(WHITE);
tft.setTextSize(3);
tft.print((60000/waktu_selisihPuncak));
flag_puncak = false;
Serial.print("dc LED=========================================");
Serial.println(data_dcLED);
ratio_acLED=(float)(0.701*selisih_acLED)/data_dcLED;
ratio_acIR=(float)(0.701*selisih_acIR)/data_dcIR;
spo2=(110 -((ratio_acLED/ratio_acIR)*25))+11;
Serial.print("SPO2=========================================");
Serial.println(spo2);
Serial.print("spo2=================");
tft.fillRect(90,60,100,50,BLUE);
tft.setCursor(100,80);
tekanan_asli= average3;
tekanan_filter=(average2);
data_tekananFilter= map(tekanan_filter,0,1023,237,120);
data_tekananAsli= map(tekanan_asli,0,1023,0,50000);
mmhg=(((data_tekananAsli/9)*7.50062)/100)-14;
ratio_acLED=(float)(0.701*selisih_acLED)/data_dcLED;
ratio_acIR=(float)(0.701*selisih_acIR)/data_dcIR;
spo2=(110 -((ratio_acLED/ratio_acIR)*25))+11;
Serial.print("SPO2=========================================");
Serial.println(spo2);
Serial.print("spo2=================");
tft.fillRect(90,60,100,50,BLUE);
tft.setCursor(100,80);
if(flag_cetak_bpmBP==true && tekanan_berhenti==true && j==true &&
tanda_habis==false)
{
tft.fillRect(100,25,100,25,RED);
tft.setCursor(100,25);
tft.setTextColor(WHITE);
tft.setTextSize(3);
tft.print((60000/waktu_selisih_puncakTekanan));
flag_cetak_bpmBP=false;
}
if(e>=9 && tanda_habis==false)
{
rata_mmhg=total_mmhg/10;
tft.fillRect(130,60,70,50,BLUE);
tft.setCursor(135,80);
if(mmhg<habis_tekanan && tekanan_berhenti==true && tanda_habis==false)
{
if(flag_panjang_arrayTekanan==true)
ratio_acLED=(float)(0.701*selisih_acLED)/data_dcLED;
ratio_acIR=(float)(0.701*selisih_acIR)/data_dcIR;
spo2=(110 -((ratio_acLED/ratio_acIR)*25));
Serial.print("SPO2=========================================");
Serial.println(spo2);
z=y;
flag_panjang_arrayTekanan=false;
}
tft.fillRect(0,120,320,240,BLACK);
x=0;
if(MAP<simpan_tinggi[r+3])
{
MAP=simpan_tinggi[r+3];
tekanan_MAP=simpan_tekanan[r+3];
letak_MAP=r+3;
Serial.println(tekanan_MAP );
Serial.print("letak====");
Serial.println(letak_MAP);
Serial.print("SISTOL====");
Serial.println(nilai_sistol);
Serial.print("DIASTOL====");
&&((float)simpan_tinggi[u+2]/MAP) <= 0.65 &&
simpan_tekanan[u+2]>=tekanan_MAP)
{
nilai_sistol=simpan_tekanan[u+2];
u=letak_MAP;
flag_cetak_bpmBP=false;
if( ((float)simpan_tinggi[u]/MAP)>= 0.75 &&
((float)simpan_tinggi[u]/MAP) <= 0.85 &&simpan_tekanan[u+2]<tekanan_MAP)
{
nilai_diastol=simpan_tekanan[u]-15;
lanjut_cetak=true;
/// Cetak Diastol dan Sistol
tft.fillRect(130,60,70,50,BLUE);
TSPoint p = ts.getPoint();
if(p.x>122 && p.x<506 && p.y>120 && p.y <421 &&buttonEnabled1==true
||buttonEnabled3==false)
digitalWrite(pin_pompa,HIGH);
Serial.println("HIDUP");
}
tft.fillRect(130,60,70,50,BLUE);
EEPROM.write(addr,tekanan_filter/4);
baca_data_tekananFilter=EEPROM.read(addr);
if(mmhg<85)
{
error_puncak=12;
}
batas_puncakTekanan=EEPROM.read(addr-25)-error_puncak;
if(baca_data_tekananFilter<batas_puncakTekanan && tanda_puncakTekanan>2
&& tanda_puncakTekanan1<2 && tekanan_berhenti==true )
{
digitalWrite(pin_buzzer,LOW);
maks_tekanan=batas_puncakTekanan;
waktu_awal_puncakTekanan=millis();
tanda_puncakTekanan=0;
}
if( baca_data_tekananFilter>batas_puncakTekanan &&
tanda_puncakTekanan<2 && tanda_puncakTekanan1<2)
{
digitalWrite(pin_buzzer,HIGH);
min_tekanan=batas_puncakTekanan;
tinggi_tekanan=maks_tekanan - min_tekanan;
simpan_tekanan[y]=mmhg;
simpan_tinggi[y]=tinggi_tekanan;
Serial.print("Tinggi 1=============================");
Serial.println(simpan_tinggi[y]);
Serial.print("Tekanan =============================");
Serial.println(simpan_tekanan[y]);
tanda_puncakTekanan1=5;
maks_tekanan=batas_puncakTekanan;
tinggi_tekanan=maks_tekanan - min_tekanan;
simpan_tinggi[y]=tinggi_tekanan;
simpan_tekanan[y]=mmhg;
waktu_selisih_puncakTekanan=waktu_akhir_puncakTekanan-
waktu_awal_puncakTekanan;
bpm_blood =(60000/waktu_selisih_puncakTekanan);
if(bpm_blood >60 )
{
simpan_bpm_blood[q]=bpm_blood;
jumlah_bpm_blood=simpan_bpm_blood[q]+jumlah_bpm_blood;
q++;
}
Serial.print("Tinggi 2============================");
Serial.println(simpan_tinggi[y]);
Serial.print("Tekanan =============================");
Serial.println(simpan_tekanan[y]);
tanda_puncakTekanan1=0;
tanda_puncakTekanan=5;
flag_cetak_bpmBP=true;
y++;
total = total - readings[readIndex];
// read from the sensor:
readings[readIndex] = analogRead(A11);
// add the reading to the total:
total = total + readings[readIndex];
// advance to the next position in the array:
readIndex = readIndex + 1;
// if we're at the end of the array...
if (readIndex >= numReadings) {
// ...wrap around to the beginning:
readIndex = 0;
}
// calculate the average:
average = total / numReadings;
// send it to the computer as ASCII digits
//Serial.println(average);
void coba2() {
// subtract the last reading:
total2 = total2 - readings2[readIndex2];
// read from the sensor:
readings2[readIndex2] = analogRead(A12);
// add the reading to the total:
total2 = total2 + readings2[readIndex2];
// advance to the next position in the array:
readIndex2 = readIndex2 + 1;
// if we're at the end of the array...
if (readIndex2 >= numReadings2) {
// ...wrap around to the beginning:
readIndex2 = 0;
}
// calculate the average:
average2 = total2 / numReadings2;
// send it to the computer as ASCII digits
total3 = total3 - readings3[readIndex3];
// read from the sensor:
readings3[readIndex3] = analogRead(A13);
// add the reading to the total:
total3 = total3 + readings3[readIndex3];
// advance to the next position in the array:
readIndex3 = readIndex3 + 1;
// if we're at the end of the array...
if (readIndex3 >= numReadings3) {
// ...wrap around to the beginning:
readIndex3 = 0;
}
// calculate the average:
average3 = total3 / numReadings3;
// send it to the computer as ASCII digits
total4 = total4 - readings4[readIndex4];
// read from the sensor:
readings4[readIndex4] = analogRead(A15);
// add the reading to the total:
// if we're at the end of the array...
if (readIndex4 >= numReadings4) {
// ...wrap around to the beginning:
readIndex4 = 0;
}
// calculate the average:
average4 = total4 / numReadings4;
// send it to the computer as ASCII digits
total5 = total5 - readings4[readIndex5];
// read from the sensor:
readings5[readIndex5] = analogRead(A14);
// add the reading to the total:
total5 = total5 + readings5[readIndex5];
// advance to the next position in the array:
readIndex5 = readIndex5 + 1;
// if we're at the end of the array...
if (readIndex5 >= numReadings5) {
// ...wrap around to the beginning:
readIndex5 = 0;
}
// calculate the average:
average5 = total5 / numReadings5;
// send it to the computer as ASCII digits
if (average >=410 && flag_puncak == false && flag_lembah==false)
{
digitalWrite(pin_buzzer,HIGH);
waktu_awalPuncak=millis();
flag_puncak = true;
}
if (average <= 390 && flag_puncak==true && flag_lembah==false)
{
flag_lembah = true;
digitalWrite(pin_buzzer,LOW);
}
if (average >=410 && flag_lembah==true)
{
waktu_selisihPuncak=waktu_akhirPuncak-waktu_awalPuncak;
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
cetak_jantung();
flag_puncak = false;
flag_lembah=false;
}
}
void cetak_jantung()
{
tft.fillRect(0,60,150,50,BLUE);
tft.setCursor(80,80);
tft.setTextColor(WHITE);
tft.setTextSize(3);
LAMPIRAN B
ANGKET
Petunjuk Praktikum Pembelajaran Materi
Biomedical
Berilah tanda check list (
√
) pada kotak penilaian yang sesuai dengan kenyataan
yang ada.
No.
Aspek yang di observasi
Penilaian
Baik
Cukup
Kurang
1.
Apakah
petunjuk
praktikum
materi
biomedical
mudah dimengerti ?
2.
Apakah tujuan dari petunjuk praktikum
tersampaikan ?
3.
Apakah petunjuk praktikum ini dapat
membantu
anda
memahami
materi
biomedical
yang sudah diajarkan ?
4.
Apakah dari tugas yang diberikan dalam
praktikum dapat membantu memahami
materi
biomedical
?
5.
Apakah petunjuk praktikum ini dapat
membuat
anda lebih tertarik
materi
LAMPIRAN C
Petunjuk Penggunaan
“
Media Pembelajaran Sistem Pengukuran Aktivitas Elektrik Jantung, Keadaan
Oksigen Dalam Darah, dan Tekanan Darah Dengan Metode Non-
Invasive
”
1.
Tekan tombol
power
pada bagian belakang
box
ke arah bawah.
Gambar 1.
Box
Tampak Belakang
2.
Saat tombol
power
ON, LCD pada
box
bagian atas akan tertampil seperti
gambar berikut. Terdapat tiga pilihan menu, yaitu EKG, PPG, dan
Blood
Pressure
.
3.
Berikut adalah
box
tampak depan .
Gambar 3.
Box
Tampak Depan
Berikut penjelasan masing-masing bagian pada
box
alat bagian depan:
1.
Handcuff
digunakan untuk pengukuran tekanan darah yang dililitkan pada
lengan.
2.
Mechanical gauge
digunakan sebagai pembanding alat ukur tekanan dari
sensor tekanan MPX5050GP.
3.
DB15 digunakan sebgai penguhubung sensor PPG dengan rangkaian.
4.
Sensor PPG terdiri dari LED merah, LED inframerah, dan
photodiode
untuk
mengukur SpO
2.
5.
Penghubung elektroda digunakan untuk menghubungkan elektroda
pad
ke
module AD8232.
A.
Pengukuran Aktivitas Elektrik Jantung
Gambar 4. Pemasangan Elektroda
2.
Agar hasil lebih bagus usahakan pengukuran dilakukan dengan keadaan tubuh
terlentang dan dalam keadaan rileks. Pastikan tidak ada alat elektronik, cincin,
kalung, dan logam lainya yang dapat menganggu pengukuran menempel pada
tubuh yang diukur.
3.
Tekan menu EKG pada menu utama.
B.
Pengukuran Kadar Oksigen Saturasi
1.
Pasang sensor PPG pada jari seperti gambar berikut.
Gambar 6. Sensor PPG
2.
Tekan menu PPG pada menu utama.
3.
Berikut tampilan menu PPG.
Gambar 7. Sinyal PPG
C.
Pengukuran Tekanan Darah
1.
Pasang
handcuff
seperti gambar berikut. Agar pengukuran lebih baik pasang
2.
Tekan menu
blood pressure
.
3.
Berikut tampilan menu
blood pressure
saat pengambilan data.
Gambar 9. Sinyal
Blood Pressure
4.
Berikut tampilan menu
blood pressure
saat nilai tekanan sistolik dan
diastolik sudah didapatkan.
LAMPIRAN D
HANDOUT PRAKTIKUM TOPIK 1
EE-636 PERANCANGAN SISTEM ELEKTRONIKA
Pengajar: DED, GND, DS
Waktu: 120 menit
Judul :
Pengukuran kadar oksigen saturasi dalam darah menggunakan metode
pulse
oximetry
non-
invasive
.
Tujuan :
Mahasiswa dapat membuat dan memahami bagaimana mengukur kadar oksigen
saturasi dalam darah (SpO
2
) dan
heart rate
dengan metode
pulse oximetry
non-
invasive.
Alat dan Bahan :
1.
Arduino Mega 2560
2.
Oscilloscope
3.
Breadboard
4.
Kabel jumper
5.
Photodioda
6.
LED merah dan LED inframerah
7.
LM324N
8.
Resistor 10kΩ (2), 22kΩ, 100Ω, 150Ω, 68kΩ, 150kΩ
, dan Variabel Resistor
5kΩ
9.
Kapasitor 4,7uf dan 200nf
10.
Transistor 2n222 (2)
Dasar Teori :
Photoplethysmograph
(PPG) adalah suatu perangkat yang digunakan untuk
mengukur kondisi peredaran darah yang dipompa oleh jantung pada bagian ujung jari
atau daun telinga. Hasil pengukuran tersebut dapat berguna untuk mengetahui kondisi
jantung. Selain untuk mengamati kinerja jantung, PPG juga dapat dimanfaatkan untuk
monitoring
pernafasan dan mengukur saturasi oksigen (SpO
2
) dalam darah. Saturasi
oksigen adalah perbandingan hemoglobin yang mengikat oksigen dengan hemoglobin
yang tidak mengikat oksigen.
Pulse oximetry
adalah suatu metode untuk mengukur SpO
2
. Alat
pulse oximetry
menggunakan dua panjang gelombang cahaya yang berbeda, yaitu merah antara 630 -
darah arteri, berkurangnya cahaya oleh unsur jaringan lainnya adalah relatif tetap.
Transmisi cahaya melalui arteri adalah denyutan yang diakibatkan pemompaan darah
oleh jantung.
Pulse oximetry
didasarkan pada prinsip
oxygenated hemoglobin
(HbO
2
) yang
menyerap cahaya yang berbeda dengan
deoxygenated hemoglobin
(Hb) [2], seperti
ditunjukkan oleh Gambar 1.
Gambar 1. Penyerapan Hb dan HbO
2
Alat
pulse oximetry
menggunakan
Light Emitting Diode
(LED) merah dan LED
inframerah bersama-sama dengan
photodetector
untuk mengukur penyerapan cahaya
melalui jari atau daun telinga. Pengurangan cahaya dapat dilihat pada Gambar 2,
terdapat tiga bagian besar, yaitu pengurangan cahaya akibat darah arteri, pengurangan
cahaya akibat darah vena, dan pengurangan darah akibat jaringan. Pengurangan cahaya
akibat aliran darah vena dan jaringan, menghasilkan sinyal yang relatif tetap (
DC
),
sedangkan pengurangan cahaya oleh aliran denyut dari arteri menghasilkan sinyal yang
Penyerapan lebih tinggi cahaya inframerah dibandingkan cahaya merah adalah
indikasi dari oksigen saturasi yang tinggi sedangkan penyerapan lebih tinggi cahaya
merah dibandingkan cahaya inframerah adalah indikasi dari oksigen saturasi yang
rendah. Fungsi dari oksigen saturasi (SpO
2
) digambarkan sebagai perbandingan HbO
2
dengan total jumlah Hb. Berikut adalah Persamaan 1 yaitu perbandingan HbO
2
dengan
Hb yang diukur menggunakan
pulse oximetry
:
(1)
Keterangan :
SpO
2
= Kadar oksigen saturasi dalam darah (%).
HbO
2
= Hemoglobin yang mengikat oksigen.
Hb
= Hemoglobin yang tidak mengikat oksigen.
Warna yang lebih gelap pada darah vena dibandingkan dengan darah arteri
berkaitan dengan fakta bahwa Hb menyerap warna merah lebih banyak daripada cahaya
biru. Perbedaan warna molekul Hb dan HbO
2
adalah kunci dari
pulse oximetry
. Nilai
R
dihitung dari
oximetry
dengan pengambilan perbandingan penyerapan cahaya merah
dan inframerah.
(2)
Keterangan :
R
= Rasio penyerapan cahaya LED merah dengan LED inframerah
ACred
= Penyerapan cahaya LED merah pada arteri (V).
ACired
= Penyerapan cahaya LED inframerah pada arteri (V).
Nilai SpO
2
dapat dihitung dengan memasukkan nilai
R
pada persamaan di bawah
ini.
(3)
Keterangan :
SpO
2
= Kadar oksigen saturasi dalam darah (%).
R
= Rasio penyerapan cahaya LED merah dengan LED inframerah
Langkah Percobaan :
A.
Menghitung
Heart Rate
1.
Buatlah rangkaian transistor sebagai saklar dengan mengikuti gambar di bawah ini!
Buatlah program untuk menghidupkan dan mematikan LED menggunakan
pin
digital
Arduino.
Pin digital
Arduino Mega dihubungkan ke
input
basis pada
transistor! (Pastikan semua
ground
terhubung).
Gambar 3.
Driver
LED Merah Gambar 4.
Driver
LED IR
2.
Rangkailah photodioda seperti gambar di bawah ini! Arahkan photodioda ke LED
merah. Buatlah program untuk mengamati
output
dari photodioda menggunakan
pin
analog
Arduino. Gunakan fitur
serial plotter
pada Arduino Mega (
Tool> Serial
Plotter
) untuk mengamati sinyal keluaran photodioda. (
Output
akan bernilai
HIGH
Gambar 5. Rangkaian Sensor Cahaya
Gambar 6.
Datahseet
2N2222
3.
Rangkailah bandpass aktif
filter
seperti gambar di bawah ini!
Input filter
berasal dari
output
photodioda.
Gambar 8.
Datasheet
LM324N
4.
Masukkan
output
filter
pada Gambar 7 di
pin analog
Arduino Mega. Letakan ujung
jari diantara photodioda dan LED merah (LED merah dalam keadaan hidup).
Kemudian baca dengan menggunakan fitur
serial plotter (Tool> Serial Ploter
).
Lakukan dengan LED merah dan LED inframerah secara bergantian. Hasil akan
seperti pada Gambar 9. Gunakan fungsi
Smoothing
(
File> Example> Analog>
Smoothing
)
yang ada di Arduino untuk memperhalus sinyal dengan cara mengubah
nilai variabel numReadings (Atur nilai sesuai kebutuhan agar seperti pada Gambar
9.)
Gambar 9. Sinyal Keluaran
Filter
di Arduino Mega
5.
Buatlah program untuk menghitung periode sinyal dengan meng gunakan fungsi
Millis pada Arduino. Millis adalah
counter up
pada Arduino dengan ketelitian 1ms.
(
File> Example> Digital> Blink without delay
)
Periode sinyal didapatkan dengan menghitung waktu yang dibutuhkan antar puncak.
6.
Setelah periode sinyal didapat, kita bisa menghitung
heart rate
dengan rumus
1.
SpO
2
dapat dihitung menggunakan rumus SpO
2
= 110-(25*R). Sedangkan
R
didapatkan dari Persamaan 2. Nilai AC adalah amplitudo sinyal keluaran
filter
. Nilai
DC diambil dari keluaran
photodiode
. (Nilai SpO
2
normal 95-100%). Pengambilan
data LED merah dan LED inframerah dilakukan secara bergantian.
Tugas :
LAMPIRAN E
HANDOUT PRAKTIKUM TOPIK 2
EE-636 PERANCANGAN SISTEM ELEKTRONIKA
Pengajar: DED, GND, DS
Waktu: 120 menit
Judul :
Pengukuran aktivitas elektrik jantung menggunakan module EKG AD8232
untuk menghitung
heart rate
.
Tujuan :
1.
Mahasiswa dapat menghitung
heart rate
dari sinyal yang didapat dari module
EKG AD8232.
Alat dan Bahan :
1.
Laptop
2.
Module EKG AD8232
3.
Arduino Mega 2560
4.
Breadboard
5.
Elektroda
Pad
6.
Alkohol 70% dan kapas
7.
Kabel Jumper
Dasar Teori :
EKG adalah sebuah peralatan medis yang digunakan untuk mengukur aktivitas
elektrik otot jantung dengan mengukur perbedaan biopotensial bagian luar tubuh.
Biopotensial adalah aktivitas listrik dari sel-sel yang ada di dalam tubuh yang
menimbulkan sinyal listrik [1]. Sinyal EKG merupakan suatu gambaran dari potensial
listrik yang dihasilkan oleh aktivitas listrik otot jantung. Elektrokardiogram merupakan
rekaman informasi kondisi jantung yang diambil menggunakan elektrokardiograf yang
ditampilkan melalui monitor atau dicetak pada kertas. Sinyal EKG merupakan sinyal
Dapat dilihat pada Gambar 1, sebuah sinyal EKG mempunyai beberapa
komponen, yaitu bagian
P
,
PQ
,
QRS
,
ST
,
T
, dan
U
. Titik
P
adalah denyutan/kontraksi
pada atrium jantung (
dextra
&
sinistra
). Titik
Q
,
R,
dan
S
adalah denyutan/kontraksi
pada ventrikel jantung (
dextra
&
sinistra
) dan titik
T
berarti relaksasi pada ventikel
jantung. Orang yang berumur enam tahun keatas memiliki 60-100
beat per minute
(bpm). Besarnya amplitudo dari sinyal EKG tersebut bervariasi tergantung pada
pemasangan elektroda dan kondisi tubuh seseorang .
Langkah Percobaan :
1.
Rangkailah
module
EKG AD8232 seperti gambar berikut ini !
Gambar 1.
Wiring
module EKG AD8232
Gambar 2. Pemasangan Elektroda
3.
Buka
software
Arduino. buka
File> Example
>
Analog> Smoothing
dan ganti nilai
variabel numReadings =3; kemudian
upload
.
4.
Amati sinyal yang dihasilkan melalui
serial plotter
yang ada di Arduino Mega
(
Tool> Serial
Plotter
). Pastikan laptop tidak dalam keadaan di cas agar sinyal
EKG tidak terganggu.
A.
Menghitung
Heart Rate
1.
Buatlah program untuk menghitung periode sinyal dengan menggunakan fungsi
Millis pada Arduino. Millis adalah
counter up
pada Arduino dengan ketelitian
1ms. (
File> Example> Digital> Blink without delay
)
Periode sinyal didapatkan dengan menghitung waktu yang dibutuhkan antar
puncak.
LAMPIRAN F
HANDOUT PRAKTIKUM TOPIK 3
EE-636 PERANCANGAN SISTEM ELEKTRONIKA
Pengajar: DED, GND, DS
Waktu: 120 menit
Judul :
Pengukuran tekanan darah menggunakan metode
Oscillometry.
Tujuan :
1.
Mahasiswa dapat menentukan nilai tekanan darah menggunakan metode
Oscillometry
.
Alat dan Bahan :
1.
Arduino Mega 2560
2.
Breadboard
3.
Sensor Tekanan MPX5050GP
4.
Solenoid Valve
5.
Handcuff
6.
Air Pump Motor
7.
Selang akuarium
8.
Pengatur keluaran angin pada
handcuff
9.
LM324N
10.
Resistor : 150kΩ, 200Ω(2), 68kΩ, 100kΩ, 1kΩ,
11.
Kapasitor : 200nf, 4,7uf,
12.
Transistor 2N2222 (2)
13.
DC
power supply
Dasar Teori :
Tekanan darah merupakan tekanan hasil dari peredaran darah pada tubuh manusia.
Tekanan darah akan mencapai maksimal saat jantung berkontraksi untuk memompa
darah dan disebut tekanan sistolik.
Sedangkan saat jantung sedang istirahat diantara dua kontraksi tersebut, tekanan darah
akan mencapai nilai minimal dimana disebut tekanan diastolik. Untuk kekuatan jantung
dan frekuensi denyut jantung diatur oleh syaraf-syaraf yang menyelubungi jantung.
Pengukuran tekanan darah menggunakan metode
oscillometry
non-
invasive
tekanan tertentu (Gambar 1) dan sensor tekanan akan menerima sinyal tekanan dari
handcuff
untuk diproses menjadi tekanan sistolik atau diastolik melalui mikrokontroller.
Gambar 1. Contoh Hasil Sinyal Keluaran dari Sensor Tekanan
Keluaran sensor tekanan harus melalui
high pass filter
(HPF) untuk membuang
sinyal frekuensi 0,04Hz karena merupakan frekuensi
handcuff
sedangkan frekuensi
yang dibutuhkan adalah 1Hz yaitu frekuensi tekanan darah. Setelah melewati
rangkaian
filte
r didapatkan data keluaran sensor tekanan dan
Mean Atrial Pulse
(MAP), dengan data tersebut dapat ditentukan posisi tekanan diastolik
dan tekanan
sistolik. Tekanan sistolik dapat dihitung dengan mencari nilai tekanan saat
amplitudo 0,6 dari nilai MAP sebelum nilai MAP, sedangkan tekanan diastolik
dapat dihitung dengan mencari nilai tekanan saat amplitudo 0,8 dari MAP setelah
nilai MAP .
Langkah Percobaan :
1.
Pasang sensor tekanan MPX5050GP seperti gambar berikut !
Gambar 3.
Datasheet
MPX5050GP
2.
Ukur masukan sensor tekanan MPX5050GP menggunakan
pin analog
Arduino
sebagai data DC. Ubah masukan sensor tekanan dalam mmHg menggunakan
datasheet
yang sudah disediakan.
3.
Tampilkan tekanan dalam mmHg ke
serial monitor
tanpa memberi tekanan pada
sensor tekanan MPX5050GP. Kalibrasi sensor dengan mengurangi nilai yang
tertampil menjadi 0mmHg.
4.
Rangkailah seperti gambar berikut ini menggunakan penguhubung selang
akuarium.
Spesifikasi :
-
Supply
: 5 VDC, 7mA typ.
-
Ported elements, gauge.
-
Pressure range
: 0-50kPa atau 0-375mmHg.
-
Sensitivity
: 90mV/kPa atau 12mV/mmHg.
-
Response time
: 1ms.
5.
Buatlah
driver
air pump motor
dan solenoid
valve
seperti gambar berikut ini
!
Gambar 5.
Driver
transistor 12V
Gambar 6.
Datasheet
2N2222
6.
Gunakan
pin digital
Arduino untuk mengatur
driver
motor dan solenoid
valve
.
Motor dan solenoid
valve
akan aktif ketika
pin digital
bernilai
HIGH.
7.
Rangkailah
filter
seperti gambar berikut ini ! Masukan
filter
berasal dari sensor
tekanan MPX5050GP. Keluaran
filter
masuk
pin analog
Arduino berupa data
AC.
Gambar 6.
Datasheet
LM324N
A.
Menghitung
Heart Rate
1.
Buatlah program untuk mengatur pompa seperti diagram alir berikut !
Gambar 6. Diagram Alir
Heart Rate
2.
Pasang
handcuff
seperti Gambar 7. Agar pengukuran lebih baik pasang
handcuff
pada lengan kiri karena lebih dekat dengan jantung. Lakukan pengukuran saat
Gambar 7. Pemasangan
Handcuff
3.
Amati data AC melalui
serial plotter
pada Arduino (
Tool> Serial Plotter
). Atur
keluaran solenoid
valve
agar keluaran tekanan menjadi 2mmHg/s. Berikut hasil
keluaran data AC dilihat melalui
serial plotter.
Gunakan fitur
smoothing
untuk
memperhalus sinyal AC (
File> Example> Analog> Smoothing).
Data AC
biasanya akan terlihat saat tekanan 70mmHg sampai 130mmHg.
Gambar 8. Data AC dilihat dari
serial plotter
Arduino
B.
Menentukan Nilai Tekanan Sistolik Dan Diastolik
1.
Hitung nilai
Mean Atrial Pulse
(MAP) dengan mencari amplutido maksiamal
sinyal .
Gambar 9. Daerah Osilasi Sinyal
Blood Pressure
2.
Tekanan sistolik dapat dihitung dengan mencari nilai tekanan saat amplitudo 0,6
dari nilai MAP sebelum nilai MAP, sedangkan tekanan diastolik
dapat dihitung
dengan mencari nilai tekanan saat amplitudo 0,8 dari MAP setelah nilai MAP.
Tugas :
