Download CAPTURA Y GRAFICACIÓN DEL ECG POR EL PUERTO SERIAL

CAPTURA Y GRAFICACIÓN DEL
ECG POR EL PUERTO SERIAL
2. CONTENIDO
2.1 CIRCUITO ECG
RESUMEN
En este documento se muestra como se
realiza
la
captura
del
electrocardiograma (ECG), donde por
medio del puerto serial del computador
se realiza la graficación del mismo y
cuenta el numero de pulsaciones del
corazón.
Con el siguiente circuito se realiza la
captura del electrocardiograma.
1. INTRODUCCIÓN
El electrocardiograma (ECG) es el
registro gráfico, en función del tiempo,
de las variaciones de potencial
eléctrico generadas por el conjunto de
células cardiacas y recogidas en la
superficie corporal.
Este circuito debe generar la siguiente
onda.
Las variaciones de potencial eléctrico
durante el ciclo cardiaco producen las
ondas características del ECG.
La formación del impulso y su
conducción
generan
corrientes
eléctricas débiles que se diseminan por
todo el cuerpo. Al colocar electrodos
en diferentes sitios y conectarlos a un
instrumento de registro como el
electrocardiógrafo se obtiene el
trazado
característico
que
analizaremos en la práctica.
Las conexiones de entrada al aparato
deben ser realizadas de tal forma que
una deflexión hacia arriba indique un
potencial positivo y una hacia abajo
uno negativo.
Los electrodos deben estar ubicados de
la siguiente manera:
•
•
•
Electrodo 1: en la parte derecha
del pecho.
Electrodo 2: en la parte
izquierda el pecho.
Electrodo 3: en el tobillo
2.2 DIGITALIZACIÓN ECG
Para el ingreso del electrocardiograma
al computador, es necesario digitalizar
la señal ya que el PC solo es capaza de
interpretar señales digitales.
Para la digitalización fue necesario
utilizar un Pic 16f877A y un MAX32
que es el encargado de convertir la
señal digital entregada por el Pic a
15V y -15V.
El programa del Pic es el siguiente:
TEMP
EQU 20H
;----------------------------ORG
5H
GOTO
START
;----------------------------CONFIG_USART
BANKSEL
TXSTA
BCF
PIE1,TXIE
INTERRUPCIONES DE TX
BCF
TXSTA,BRGH
BSF
TXSTA,TXEN
MOVLW
0x1F
;COMUNICACION A 9600 BAUDIOS
MOVWF
SPBRG
BCF
TXSTA,SYNC
BANKSEL
PORTA
;BANCO 0
BSF
RCSTA,SPEN
BCF
INTCON,GIE
INTERRUPCIONES
BSF
INTCON,PEIE
INTERRUPCIONES POR PERIFERICOS
RETURN
;-------------------------------------CONFIGURAR_ADC
BANKSEL
ADCON1
CLRF
ADCON1
ENTRADAS ANALOGAS
BSF
TRISA,0
BSF
ADCON1,ADFM
LA DERECHA
BANKSEL
ADCON0
BSF
ADCON0,ADON
BSF
ADCON0,ADCS1
BCF
ADCON0,ADCS0
BCF
PIR1, ADIF
RETURN
;----------------------------------CONVERSION_TEMP
BANKSEL
ADCON0
BSF
ADCON0, GO
CONVERSIÓN
BANKSEL
PIR1
WTCON
;ESPERA ADC
BTFSS
PIR1, ADIF
GOTO
WTCON
BCF
PIR1, ADIF
BANKSEL
ADRESL
;LOW REGISTER
MOVF
ADRESL,W
BANKSEL ADCON0 ;CONTROL REGITER0
MOVWF
TEMP
RETURN
;---------------------------------TXSERIAL_TEMP
MOVLW
0X0
MOVWF
TXREG
BANKSEL
TXSTA
ESP1
BTFSS
TXSTA,TRMT
GOTO
ESP1
BANKSEL
PORTA
MOVF
TEMP,W
MOVWF
TXREG
BANKSEL
TXSTA
ESP2
BTFSS
TXSTA,TRMT
GOTO
BANKSEL
RETURN
;---------------------------------AJUSTARVALOR
BCF
RRF
;DIVIDO POR 2
RETURN
;-----------------------------------CANAL_TEMP
BANKSEL
BCF
análoga 0 (puertoA)
RETURN
;-----------------------------------CANAL_LUZ
BANKSEL
BSF
análoga 1 (puertoA)
RETURN
;-----------------------------------START
CALL
CALL
AGAIN
CALL
CALL
CALL
CALL
GOTO
END
ESP2
PORTA
STATUS,C
TEMP,F
ADCON0
ADCON0,CHS0
; Selecciono el banco0
; Selecciono la entrada
ADCON0
ADCON0, CHS0
; Selecciono el banco0
; Selecciono la entrada
CONFIGURAR_ADC
CONFIG_USART
CANAL_TEMP
CONVERSION_TEMP
AJUSTARVALOR
TXSERIAL_TEMP
AGAIN
Con este código no solo digitaliza la
señal si no que también se esta
sincronizando a 9600 baudios, 8 bits y
otras características del estándar
RS232.
;BANCO 1
;DESHABILITO
;Baja velocidad
;Habilitar Tx
;Asincrono
2.3 GRAFICACIÓN ECG (JAVA)
;DESHABILITO
;HABILITO
;TODAS
;JUSTIFICACION
LAS
A
Para la graficación de la señal se
utilizo el lenguaje de programación
Java por su fácil manejo de puertos.
El programa se divide en dos partes.
Uno para la captura de los datos que
ingresan por el puerto serie y otro para
la graficación del electrocardiograma.
;EMPIEZA
Los dos programas serán compilados
pero el de captura serial será el
ejecutado, ya que es este quien llama a
la graficación.
Este es el código de la captura serial:
import java.awt.*;
import java.util.*;
import javax.comm.*;
import java.io.*;
//****************************************************
public class txserial implements Runnable,SerialPortEventListener
case SerialPortEvent.FE:
case SerialPortEvent.PE:
case SerialPortEvent.CD:
case SerialPortEvent.CTS:
case SerialPortEvent.DSR:
case SerialPortEvent.RI:
case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
{
static CommPortIdentifier idPuerto;
static Enumeration listaPuertos;
InputStream entrada;
//canal de entrada
SerialPort puertoSerie;
Thread tLectura;
int x=0;
int dib[] = new int[400];
Graficador graf;
Dibujar grafica;
break;
// Aca se imprimen los datos
case SerialPortEvent.DATA_AVAILABLE:
byte[] bufferLectura = new byte[400];
try
{
while( entrada.available() != 0 )
{
if(x<400)
{
dib[x] = entrada.read( bufferLectura );
System.out.print(dib[x]);
System.out.print(" ");
}
if(x==400)
{
x=0;
grafica.resize(400,300);
grafica.setResizable(false);
grafica.show();
}
x++;
}
}
catch( IOException e ) {}
break;
}
}
//****************************************************
class Dibujar extends Frame
{
Panel c;
public Dibujar()
{
super("Grafica EGC de Marcela y Julian");
graf = new Graficador();
graf.setBackground(Color.black);
add("Center", graf);
}
//****************************************************
public void paint(Graphics g)
{
graf.HaceLinea(dib);
graf.repaint(5);
}
}
//****************************************************
//****************************************************
// En esta parte es donde el programa esta esperando que
// se ingresen datos por el puerto para leerlos
public txserial()
{
// Verifica que el puerto no este en uso
grafica = new Dibujar();
try
{
puertoSerie
=
(SerialPort)idPuerto.open(
"AplLectura",2000 );
}
catch( PortInUseException e ) {}
// Canal de entrada
try
{
entrada = puertoSerie.getInputStream();
}
catch( IOException e ) {}
public static void main( String[] args )
{
// Identificacion de los puertos
listaPuertos = CommPortIdentifier.getPortIdentifiers();
while( listaPuertos.hasMoreElements() )
{
idPuerto
(CommPortIdentifier)listaPuertos.nextElement();
if(
idPuerto.getPortType()
CommPortIdentifier.PORT_SERIAL )
{
if(
idPuerto.getName().equals("COM1") )
{
txserial lector = new txserial();
}
}
}
}
// Esta escuchando el puerto
try
{
puertoSerie.addEventListener( this );
}
catch( TooManyListenersException e ) {}
}
Este es el código que grafica la señal y
cuenta el número de pulsos:
// En esta parte nos damos cuenta si se estan ingresando
// datos o no
puertoSerie.notifyOnDataAvailable( true );
try
{
puertoSerie.setSerialPortParams(
SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE );
}
catch( UnsupportedCommOperationException e ) {}
// Aca se espera los datos por el puerto
System.out.println("Esperando datos ECG");
tLectura = new Thread( this );
tLectura.start();
}
//****************************************************
public void run()
{
try
{
// Esta parte es la encargada de poner un tiempo de
// espera de datos para que no se bloquee el PC
Thread.sleep( 10000 );
}
catch( InterruptedException e ) {}
}
//****************************************************
public void serialEvent( SerialPortEvent _ev )
{
switch( _ev.getEventType() )
{
// Aca son lineas de control para que el puerto
// sea vigilado
case SerialPortEvent.BI:
case SerialPortEvent.OE:
=
==
9600,
import java.awt.*;
public class Graficador extends Panel
{
int vectorp[];
int contador;
public Graficador()
{
super(new FlowLayout());
}
public void HaceLinea(int[] vector)
{
vectorp=new int[400];
vectorp=vector;
}
public void paint(Graphics w)
{
int y2=0; int y1=0; int x2=0; int x1=0; int c=0; int cont=0;
y1=0; x1=0; x2=1;
w.setColor(Color.white);
w.drawString ("Número de pulsos", 90,20);
while(c<400)
{
y2=vectorp[c]*3;
w.setColor(Color.white);
w.drawLine(0,150,400,150);
w.drawLine(0,152,400,152);
w.drawLine(0,0,0,300);
w.drawLine(2,0,2,300);
w.setColor(Color.red);
w.drawLine(x1,150-y1,x2,150-y2);
w.setColor(Color.red);
y1=y2;
x1=x2;
x2=x2+1;
c++;
//aca se cuentan los pulsos
if (y2>20) //&& (y2<60))
{
w.setColor(Color.black);
w.fillRect(200,10,50,12);
w.setColor(Color.blue);
contador++;
w.drawString(String.valueOf(contador), 200, 20);
}
}
}
}
3. CONCLUSIONES
•
El ECG es una herramienta
indispensable para conocer el
estado del corazón, conociendo
la forma normal de las ondas S
Q R T.
•
Para el montaje del circuito es
necesario utilizar lo valores
exactos escritos en el plano
para no tener inconvenientes.
•
Después de tener digitalizada la
señal, en algunos casos es
importante que sea amplificada
antes de ser enviada el puerto
serial del PC.
•
En el graficación se debe tomar
en cuenta el estándar RS232
para que sea posible el
entendimiento mutuo entre
hardware y software.
4. REFERENCIAS
•
http://med.javeriana.edu.co/fisi
ologia/nguias/ekgall.htm#1
•
http://med.javeriana.edu.co/fisi
ologia/lab.htm
5. AUTORES
Marcela Rudas Florez
Julian H. Higuera D.