Perpustakaan Arduino untuk pemantauan detak jantung dengan oksimeter pulsa
Salah satu parameter yang dipantau dalam proyek manajemen tidur saya
Itu denyut nadinya. untuk mengukurnya Saya mengembangkan perangkat berdasarkan perilaku hemoglobin dan oksihemoglobin terhadap panjang gelombang cahaya yang berbeda. Pada dasarnya ini tentang mengukur seberapa banyak cahaya jenis tertentu yang dapat melewati atau dipantulkan di area tubuh yang memiliki pengairan baik. Frekuensi terjadinya siklus lengkap fenomena ini memungkinkan pengukuran denyut nadi.Dalam tahap desain dan pengujian alat pengukur denyut nadi Saya mengembangkan beberapa program kecil untuk membantu saya memverifikasi bahwa perakitan sudah benar. Pertama saya menulis kode di bawah ini, yang mengambil nilai terukur dari waktu ke waktu (setidaknya setiap dan paling banyak masing-masing ) ketika mereka memvariasikan minimum antara satu dan yang sebelumnya (nilai yang sesuai dengan ) dan dipantau dari komputer dengan aplikasi Python untuk dapat menganalisisnya nanti.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
#define PIN_OXIMETRO 0 // Pin analógico 0
#define MEDIDA_MINIMA 10 // Cambio menor monitorizado
#define TIEMPO_MAXIMO_MEDIDA 200 // Cambio menor entre medidas (determina la resolución vertical)
#define TIEMPO_MINIMO_MEDIDA 100 // Milisegundos entre medidas (determina la resolución horizontal)
int lectura_anterior_oximetro=0;
int lectura_oximetro;
unsigned long cronometro_minimo=0;
unsigned long cronometro_maximo=0;
void setup()
{
Serial.begin(9600);
//pinMode(PIN_OXIMETRO,INPUT); // Ya es entrada por defecto
}
void loop()
{
if(millis()>cronometro_minimo)
{
lectura_oximetro=analogRead(PIN_OXIMETRO);
if(abs(lectura_oximetro–lectura_anterior_oximetro)>MEDIDA_MINIMA||millis()>cronometro_maximo)
{
cronometro_minimo=millis()+TIEMPO_MINIMO_MEDIDA;
cronometro_maximo=millis()+TIEMPO_MAXIMO_MEDIDA;
lectura_anterior_oximetro=lectura_oximetro;
Serial.println(String(millis(),DEC)+“,”+String(lectura_oximetro,DEC));
}
}
}
|
Setelah nilainya disesuaikan (dimulai dengan pengukuran yang sangat padat) saya mendapatkan kumpulan nilai dari oksimeter denyut seiring berjalannya waktu saya dapat membuat grafik menggunakan spreadsheet, Kalkulator LibreOffice de LibreOffice, spesifik.
Dengan data yang dikumpulkan, seperti yang ditunjukkan pada gambar di atas, operasi selanjutnya adalah menentukan apakah kepadatan nilai memungkinkan kita menghitung dengan cara yang andal namun "ekonomis" (tidak mengambil sampel lebih dari data yang diperlukan) nilai dari denyut nadi; Seperti terlihat pada grafik di bawah ini, langkah-langkah yang diambil tampaknya memberikan hasil yang sesuai dengan harapan.
.
Selanjutnya, berdasarkan informasi dari pengambilan sampel data, perlu dikembangkan suatu algoritma yang dapat mengukur denyut nadi. Berpegang pada grafik yang, untuk kesederhanaan, diasumsikan mewakili tata letak yang mirip dengan Kompleks QRS, hal paling sederhana adalah mengukur waktu antara bagian yang paling menonjol, dengan nilai yang lebih tinggi (yang sesuai dengan zona depolarisasi qRs ventrikel), membuang zona yang lebih datar dan "lebih berisik", yang karenanya lebih sulit untuk mengukur. Solusi yang diadopsi, yang sesuai dengan kode pengujian di bawah ini, bekerja sesuai dengan prosedur berikut:
-
Deteksi area yang diukur dalam setiap kasus untuk hanya memperhatikan puncak nilai qRs dan membuang lembah itu. Untuk melakukan hal ini, nilai yang lebih tinggi dari konstanta tertentu dapat diukur, namun terdapat risiko bahwa individu dan/atau keadaan dapat, meskipun secara proporsional, menaikkan atau menurunkan nilai tersebut. Untuk menghindari hal ini, suatu nilai dalam luas dianggap lebih besar dari nilai yang melebihi nilai rata-rata dengan koefisien tertentu. Dengan cara ini, pengukuran dikalibrasi sendiri secara sensitif dan dapat disesuaikan lebih jauh lagi dengan menyempurnakan koefisien, yang dalam kasus saya telah saya capai secara eksperimental selama pengujian.
Pilih nilai zona menurun untuk pengukuran (Rs) dari puncak qRs, sedekat mungkin dengan kurva maksimum. Untuk mengetahui bahwa zona menaik ditinggalkan, cukup dengan memverifikasi bahwa nilai baru lebih kecil dari yang sebelumnya dan memverifikasi bahwa nilai yang dicari belum ditemukan karena pada umumnya ada beberapa nilai di zona menurun. zona qRs tergantung pada kepadatan pengambilan sampel. Untuk menentukan waktu denyut nadi, nilai waktu saat titik ditemukan disimpan (milidetik dikembalikan oleh milis ()) dan membandingkannya dengan yang berikutnya.
Untuk memastikan bahwa nilai yang diukur adalah yang terbesar di zona menurun pada kurva tertinggi, digunakan variabel boolean ( dalam contoh ini dan di perpustakaan) yang diaktifkan ketika memasuki zona menaik dari kurva utama dan dinonaktifkan setelah nilai turun pertama ditemukan, yaitu nilai waktunya.
Seperti biasa untuk menyatakan durasi pulsa sebagai detak per menit (ppm), nilai waktu antara pulsa yang diperoleh dikoreksi dengan menghitung dengan membagi total waktu representasi (satu menit, 60000 milidetik) dengan interval yang diperoleh dengan mengurangkan milidetik saat ini (dari nilai saat ini) di antara milidetik yang dihitung sebelumnya.
Untuk menghindari pengukuran yang salah (seperti alat yang mengukur dalam ruang hampa, misalnya), diverifikasi bahwa hasilnya berada di antara nilai maksimum dan minimum sebelum menerima begitu saja. Meskipun rata-rata dianggap bahwa nilai normal untuk orang dewasa sehat saat istirahat adalah antara 60 dan 100 ppm, ada nilai yang dapat diterima di bawah ini, mudah untuk menemukan 40 ppm pada atlet saat istirahat, hingga 200 ppm selama olahraga intens dan lebih dari 100 ppm pada orang dewasa yang tidak banyak bergerak dalam keadaan gembira, merupakan faktor yang menarik untuk proyek manajemen tidur yang mengarahkan saya untuk mengembangkan ini alat pengukur denyut nadi. Oleh karena itu, disarankan untuk banyak mengendurkan nilai-nilai tersebut agar nilai-nilai ekstrem tidak hilang, yang justru dapat menunjukkan aspek-aspek yang relevan.
Nilai rata-rata baru dihitung dengan cara menurunkan relevansi rata-rata saat ini berdasarkan jumlah nilai yang diambil sampelnya dan nilai terakhir yang ditambahkan, juga ditimbang dengan koefisien yang semakin memperkecil semakin banyak nilai yang diukur selama ini. .
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
#define PIN_OXIMETRO 0 // Pin analógico 0
#define TIEMPO_MINIMO_MEDIDA 20 // Milisegundos entre medidas (determina la resolución horizontal)
#define COEFICIENTE_PULSO 1.25 // Coeficiente que determina la zona de valores en la que medir el pulso
#define PULSO_MENOR 30 // Ignorar valores menores (Es infrecuente un pulso más lento aún en reposo)
#define PULSO_MAYOR 180 // Ignorar valores mayores (Es infrecuente un pulso mayor en reposo)
#define MINUTO 60000.0 // Milisegundos en un minuto
float velocidad_pulso;
float lectura_media_oximetro=511.5;
unsigned long valores_contados=0;
int lectura_anterior_oximetro=0;
int lectura_oximetro;
boolean medir_pulso=false;
unsigned long cronometro_pulso=0;
unsigned long cronometro_oximetro=0;
void setup()
{
Serial.begin(9600);
//pinMode(PIN_OXIMETRO,INPUT); // Ya es entrada por defecto
}
void loop()
{
if(millis()>cronometro_oximetro)
{
cronometro_oximetro=millis()+TIEMPO_MINIMO_MEDIDA;
lectura_oximetro=analogRead(PIN_OXIMETRO);
valores_contados++;
lectura_media_oximetro=lectura_media_oximetro*(float(valores_contados–1)/valores_contados);
lectura_media_oximetro+=lectura_oximetro*(1.0/valores_contados);
if(lectura_oximetro>lectura_media_oximetro*COEFICIENTE_PULSO)
{
if(lectura_anterior_oximetro<lectura_oximetro)
{
medir_pulso=true;
}
else
{
if(medir_pulso)
{
velocidad_pulso=MINUTO/float(millis()–cronometro_pulso);
medir_pulso=false;
if(velocidad_pulso>PULSO_MENOR&&velocidad_pulso<PULSO_MAYOR)
{
Serial.println(“Pulso “+String(velocidad_pulso,DEC));
}
cronometro_pulso=millis();
}
}
}
lectura_anterior_oximetro=lectura_oximetro;
}
}
|
Terakhir, dengan menggunakan algoritma yang dijelaskan sebelumnya, saya mengembangkan perpustakaan untuk menghitung denyut nadi dengan mendeteksi keberadaannya hemoglobin o la oksihemoglobin (tergantung panjang gelombang cahaya yang digunakan) dari kode di bawah ini.
Perpustakaan mengharapkan fungsi sampling dipanggil secara berkala untuk menghitung pulsa, yang dapat dikonsultasikan dengan fungsinya atau dengan fungsinya denyut nadi rata-rata. Selain karena sumber daya yang terbatas, saya mengesampingkan penggunaan interupsi karena saya tidak memerlukan nilai langsung melainkan nilai berkelanjutan dari waktu ke waktu untuk memantau denyut nadi dalam proyek manajemen tidur saya
. Bagaimanapun, dari tes yang telah saya lakukan, sepertinya hal itu tidak perlu; baik oleh perangkat atau oleh perilaku denyut nadi, pengambilan sampel pada frekuensi tertentu memberikan informasi yang cukup dan tidak lebih banyak (relevan) yang diperoleh dengan meningkatkannya, juga tidak mungkin untuk menguranginya banyak tanpa kehilangan data yang relevan untuk perhitungan; di versi awal kode untuk memantau pembacaan oksimeter denyut Saya menemukan bahwa tidak perlu terpaku pada waktu pengukuran maksimum karena, jika variasi nilai yang berurutan dipertimbangkan dengan benar, itu akan sangat mendekati waktu minimum.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
//pulso.h
#if defined(ARDUINO) && ARDUINO>=100
#include “Arduino.h”
#else
#include “WProgram.h”
#endif
#define PULSO_MINIMO 5 // Pulso mínimo. Un pulso menor se considera un error.
#define PULSO_MAXIMO 200 // Pulso máximo. Un pulso mayor se considera un error.
#define COEFICIENTE_PULSO 1.25 // Coeficiente que multiplica el pulso medio para determinar si el valor medido está en la zona que se cronometra. Puede usarse para calibra el dispositivo
#define OXIMETRIA_MEDIA 511.5 // Medida media inicial del pulso (1023/2) Puede usarse para calibrar el dispositivo
#define PULSO_MEDIO 80.0 // Pulso medio de un adulto en reposo (sólo para referencia)
class Pulso
{
private:
byte pin_oximetro; // Pin analógico al que se conecta el sensor de pulso
int lectura_oximetro; // Último valor medido en el sensor de pulso
int lectura_anterior_oximetro; // Penúltimo valor medido en el sensor de pulso para compararlo con el último y establecer la zona de valores en la que se encuentra
unsigned long numero_lecturas_oximetro; // Número de medidas del oxímetro tomadas. Usado para calcular la media
unsigned long numero_lecturas_pulso; // Número de medidas de pulso tomadas. Usado para calcular la media
float lectura_media_oximetro; // Medida media del sensor de pulso. Usado para saber si un valor se encuentra en la zona de medida (que se cronometra) del pulso
boolean medicion_de_pulso_activa; // Verdadero si se ha entrado de la zona del pulso (para no confundir si aún se encuentra en una zona ya medida)
float velocidad_pulso; // Último valor de pulso calculado
float ultima_velocidad_pulso; // Último valor de pulso correcto
float velocidad_media_pulso; // Media de los pulsos calculados durante la última sesión (creación del objeto Pulso)
unsigned long cronometro_pulso; // Tiempo entre medidas de pulso consecutivas
protected:
public:
Pulso(byte pin_oximetro_solicitado);
~Pulso();
void monitorizar_pulso(); // Se llama periódicamente (entre 10 y 50 ms) para calcular el pulso
byte ultimo_pulso(); // Devuelve el último valor correcto de pulso muestreado
byte pulso_medio(); // Devuelve el pulso medio de la sesión
};
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
//pulso.cpp
#include “pulso.h”
Pulso::Pulso(byte pin_oximetro_solicitado)
{
pin_oximetro=pin_oximetro_solicitado;
//pinMode(pin_oximetro,INPUT); // Ya es entrada por defecto
numero_lecturas_oximetro=0;
numero_lecturas_pulso=0;
lectura_media_oximetro=OXIMETRIA_MEDIA;
velocidad_media_pulso=PULSO_MEDIO;
medicion_de_pulso_activa=false;
lectura_anterior_oximetro=0;
ultima_velocidad_pulso=0; // Para indicar que es un valor incorrecto por el momento
cronometro_pulso=0;
}
Pulso::~Pulso()
{
}
byte Pulso::ultimo_pulso()
{
return round(ultima_velocidad_pulso);
}
byte Pulso::pulso_medio()
{
return round(velocidad_media_pulso);
}
void Pulso::monitorizar_pulso()
{
lectura_oximetro=analogRead(pin_oximetro);
numero_lecturas_oximetro++;
lectura_media_oximetro=lectura_media_oximetro*(float(numero_lecturas_oximetro–1)/numero_lecturas_oximetro); // Cambiar la representatividad de la parte actual de la media de pulso
lectura_media_oximetro+=lectura_oximetro*(1.0/numero_lecturas_oximetro); // Añadir la nueva lectura a la media
if(lectura_oximetro>lectura_media_oximetro*COEFICIENTE_PULSO)
{
if(lectura_anterior_oximetro<lectura_oximetro) // Medida de valores creciente
{
medicion_de_pulso_activa=true;
}
else
{
if(medicion_de_pulso_activa)
{
velocidad_pulso=60000.0/float(millis()–cronometro_pulso); // Cálculo de las pulsaciones por minuto (representación habitual del pulso)
medicion_de_pulso_activa=false; // Ya se ha medido el pulso, no medir hasta entrar en una nueva zona ascendente
if(velocidad_pulso>PULSO_MINIMO&&velocidad_pulso<PULSO_MAXIMO)
{
numero_lecturas_pulso++;
ultima_velocidad_pulso=velocidad_pulso;
velocidad_media_pulso=velocidad_media_pulso*(float(numero_lecturas_pulso–1)/numero_lecturas_pulso); // Calcular la representatividad de la media actual en la nueva media
velocidad_media_pulso+=velocidad_pulso*(1.0/numero_lecturas_pulso); // Añadir la nueva lectura a la media
}
cronometro_pulso=millis();
}
}
}
lectura_anterior_oximetro=lectura_oximetro;
}
|
Contoh program berikut menunjukkan cara menggunakan perpustakaan sebelumnya untuk mengukur denyut nadi dengan oksimeter denyut. Selain membuat instance kelas pemantauan tingkat oksihemoglobin/hemoglobin dan dengan periodisitas yang lebih kecil nilai denyut nadi dihitung dan rata-rata.
Untuk memastikan bahwa pengukuran relevan, waktu tunggu diprogram sebelum menampilkan nilai apa pun. Karena nilainya mungkin salah (misalnya jika pengguna melepas perangkat), nilai hanya ditampilkan jika berada dalam rentang yang dianggap valid.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
#define PIN_PULSOMETRO 0
#define TIEMPO_MONITORIZACION_PULSO 20
#define TIEMPO_PRESENTACION_PULSO 5000
#include “pulso.h”
Pulso pulso(PIN_PULSOMETRO);
unsigned long cronometro_monitorizacion_pulso;
unsigned long cronometro_presentacion_pulso;
byte velocidad_pulso;
byte velocidad_media_pulso;
void setup()
{
Serial.begin(9600);
cronometro_monitorizacion_pulso=0;
cronometro_presentacion_pulso=TIEMPO_PRESENTACION_PULSO*2;
}
void loop()
{
if(millis()>cronometro_monitorizacion_pulso)
{
cronometro_monitorizacion_pulso=millis()+TIEMPO_MONITORIZACION_PULSO;
pulso.monitorizar_pulso();
}
if(millis()>cronometro_presentacion_pulso)
{
cronometro_presentacion_pulso=millis()+TIEMPO_PRESENTACION_PULSO;
velocidad_pulso=pulso.ultimo_pulso();
velocidad_media_pulso=pulso.pulso_medio();
if(velocidad_pulso)
{
Serial.print(“Pulso “);
Serial.print(velocidad_pulso,DEC);
Serial.print(” | Pulso medio “);
Serial.println(velocidad_media_pulso,DEC);
}
}
}
|
Posting