Sistema de adquisición de constantes vitalesdeeea.urv.cat/public/PROPOSTES/pub/pdf/1987pub.pdf · Sistema de adquisición de constantes vitales 2 temperatura, la dieta, estado emocional,

Sistema de adquisición de constantes vitales

Titulación: Ingeniería en Automática y Electrónica Industrial

AUTOR: Jose Antonio García-Uceda Calvo

DIRECTOR: Alfonso Romero

FECHA: Junio del 2012


1

Índice

1 MEMORIA DESCRIPTIVA....................................................................................................... 1 1.1 OBJETO DEL PROYECTO. ........................................................................................................ 1 1.2 ALCANCE............................................................................................................................... 1

2 ESFIGMOMANÓMETRO. ........................................................................................................ 1 2.1 DEFINICIÓN, APLICACIÓN Y SOLUCIÓN................................................................................... 1

2.1.1 Definición. ................................................................................................................... 1 2.1.2 Métodos de obtención de la presión arterial............................................................... 3 2.1.3 Método oscilométrico. ................................................................................................. 5 2.1.4 Obtención de las presiones: media, sistólica y diastólica ........................................... 7 2.1.5 Solución adoptada....................................................................................................... 8

2.2 DISEÑO HARDWARE............................................................................................................... 9 2.2.1 Diagrama Hardware ................................................................................................... 9 2.2.2 Transductor de presión ............................................................................................. 10 2.2.3 Amplificador de instrumentación .............................................................................. 10 2.2.4 Filtro paso banda y amplificación ............................................................................ 11 2.2.5 Etapa de acoplamiento AC........................................................................................ 14 2.2.6 Acelerómetro ......................................................................................................... 15 2.2.7 Microcontrolador ...................................................................................................... 17 2.2.8 Etapa de potencia .................................................................................................. 17 2.2.9 Etapa de alimentación............................................................................................... 18

2.3 CÁLCULO DE LA PRESIÓN..................................................................................................... 18 2.4 ALGORITMOS DE CONTROL ................................................................................................. 21

2.4.1 Firmware................................................................................................................... 21 2.4.1.1 Función main(). ..................................................................................................................... 21 2.4.1.2 Adquisición mediante ADC................................................................................................... 21 2.4.1.3 Empaquetado de los datos adquiridos. ................................................................................... 22 2.4.1.4 Envío de paquetes al host....................................................................................................... 23 2.4.1.5 Recepción de paquetes provenientes del host. ....................................................................... 23 2.4.1.6 Activación y desactivación de la bomba................................................................................ 24 2.4.1.7 Activación y desactivación de la válvula ............................................................................... 25 2.4.1.8 Estados de trabajo.................................................................................................................. 26 2.4.1.9 Obtención del umbral para detectar vibración. ...................................................................... 26

2.4.2 Software..................................................................................................................... 27 2.4.2.1 Función main. ........................................................................................................................ 27 2.4.2.2 Comunicación usb. ................................................................................................................ 27 2.4.2.3 Graficación de señales. .......................................................................................................... 28 2.4.2.4 Control por teclado. ............................................................................................................... 29

2.5 PRESUPUESTO...................................................................................................................... 31 2.5.1 Coste de recursos hardware...................................................................................... 31 2.5.2 Coste de recursos Software. ...................................................................................... 31 2.5.3 Coste de los componentes.......................................................................................... 32 2.5.4 Coste de recursos humanos. ...................................................................................... 34 2.5.5 Coste total del proyecto............................................................................................. 34

2.6 BIBLIOGRAFÍA Y WEBGRAFIA............................................................................................... 35 3 ELECTROCARDIÓGRAFO.................................................................................................... 36

3.1 DEFINICIÓN, APLICACIÓN Y SOLUCIÓN................................................................................. 36 3.1.1 El Electrocardiógrafo................................................................................................ 36 3.1.2 El corazón. ................................................................................................................ 37

II

3.1.3 Sistema de conducción. ............................................................................................. 37 3.1.4 Electrocardiografía. .................................................................................................. 38 3.1.5 Derivaciones.............................................................................................................. 39 3.1.6 Solución adoptada..................................................................................................... 40

3.2 DISEÑO HARDWARE............................................................................................................. 41 3.2.1 Diagrama Hardware ................................................................................................. 41 3.2.2 Amplificador de Instrumentación .............................................................................. 41 3.2.3 Filtro paso banda y amplificación ............................................................................ 42 3.2.4 Filtro NOTCH ........................................................................................................... 45 3.2.5 Desplazador de nivel. ................................................................................................ 46 3.2.6 Driver RL .................................................................................................................. 47 3.2.7 Microcontrolador ...................................................................................................... 49

3.3 ALGORITMOS DE CONTROL. ................................................................................................ 50 3.3.1 Firmware................................................................................................................... 50

3.3.1.1 Función main(). ..................................................................................................................... 50 3.3.1.2 Adquisición mediante ADC................................................................................................... 50 3.3.1.3 Empaquetado de los datos adquiridos. ................................................................................... 51 3.3.1.4 Envío de paquetes al host....................................................................................................... 51 3.3.1.5 Recepción de paquetes provenientes del host. ....................................................................... 52 3.3.1.6 Detección del complejo RR ................................................................................................... 52

3.3.2 Software..................................................................................................................... 54 3.3.2.1 Función main. ........................................................................................................................ 54 3.3.2.2 Comunicación usb. ................................................................................................................ 54 3.3.2.3 Graficación de señales. .......................................................................................................... 55 3.3.2.4 Control por teclado. ............................................................................................................... 56

3.4 PRESUPUESTO...................................................................................................................... 57 3.4.1 Coste de recursos hardware...................................................................................... 57 3.4.2 Coste de recursos Software. ...................................................................................... 57 3.4.3 Coste de los componentes.......................................................................................... 58 3.4.4 Coste de recursos humanos. ...................................................................................... 59 3.4.5 Coste total del proyecto............................................................................................. 60

3.5 BIBLIOGRAFIA Y WEBGRAFIA............................................................................................... 61 4 PRESUPUESTO......................................................................................................................... 62

4.1 PRESUPUESTO TOTAL........................................................................................................... 62 5 ANEXOS. ...................................................................................................................................... 1

5.1 CÓDIGO, FIRMWARE .............................................................................................................. 1 5.2 CÓDIGO, SOFTWARE ............................................................................................................ 13 5.3 CÓDIGO, MATLAB ............................................................................................................... 48 5.4 DISEÑO PCB.......................................................................................................................... 1 5.5 DISEÑO GRÁFICO ................................................................................................................... 4


1

1 Memoria Descriptiva.

1.1 Objeto del proyecto.

El presente proyecto tiene como objeto diseñar y montar un circuito automático que sea capaz de medir los dos principales signos vitales, la tensión arterial y la señal electrocardiográfica. Con este proyecto se busca la interacción de un sistema automático con uno electrónico y en ningún caso se busca mejorar sistemas ya existentes. En definitiva, este trabajo tiene como objetivo una interacción real con sistemas automáticos y electrónicos que tienen una incidencia muy significativa en nuestra sociedad, como es el caso del electrocardiógrafo y el esfigmomanómetro, dándole al proyectista una visión mas cercana del diseño de esta clase de instrumentos.

Tanto los sistemas de medición de la presión arterial como los de medición electrocardiográfica, hoy por hoy son imprescindibles en medicina; tanto para controlar como para detectar estados anormales en la salud, ya que nos proporcionan información directa e indirecta de patología/s asociada/s a esos estados de anormalidad. De ahí, el interés por entender e intentar desarrollar este tipo de sistemas.

1.2 Alcance Se pretende diseñar un electrocardiógrafo para monitoreo, asistido por

microcontrolador y controlado vía software. También se diseñará un esfigmomanómetro, basado en el método oscilométrico, asistido por microcontrolador y controlado por software.

2 Esfigmomanómetro.

2.1 Definición, aplicación y solución.

2.1.1 Definición.

Un esfigmomanómetro es un instrumento de diagnóstico médico usado para la medición de la presión arterial. La palabra proviene del griego sphygmós, pulso; manós, no denso y metron, medida. También es conocido popularmente como tensiómetro o baumanómetro aunque correctamente es "manómetro".

Antes de entrar de lleno en la definición y diseño de un esfigmomanómetro convendría definir que es la presión arterial y que utilidad nos reporta su lectura o mejor dicho su medición.

La presión arterial es una magnitud de la fuerza que se aplica sobre las paredes de las arterias a medida que el corazón bombea sangre a través del cuerpo. Está determinada por la fuerza y el volumen de sangre bombeada, así como por el tamaño y la flexibilidad de las arterias. Su cambio es continuo dependiendo de: La actividad del cuerpo, la


2

temperatura, la dieta, estado emocional, la postura, el estado físico, los medicamentos que se administren, etc.

Figura 2.1 Sistema circulatorio. Figura 2.2 Presión arterial.

¿Como se induce esa presión? Cuando late el corazón, bombea sangre hacia sus arterias (venas y capilares) creando presión en ellas (la sangre circula por todo el cuerpo). En condiciones normales el corazón late de 60 a 80 veces por minuto. Con cada latido manda una ola de sangre a las arterias. Esto hace que la presión se eleve en las mismas. Por otra parte la presión baja cuando el corazón descansa entre latidos. En condiciones normales, los factores que determinan la presión arterial se mantienen en conjunción armónica, controlados por sistemas de autorregulación.

A la presión máxima arterial, antes nombrada, se le denomina sistólica y a la mínima diastólica. La presión sistólica esta directamente relacionada con el volumen por minuto, la fuerza contráctil del ventrículo izquierdo, volumen total de la sangre y elasticidad de la aorta; mientras que la presión diastolica esta directamente relacionada con la resistencia periférica y la elasticidad de la aorta. De ahí que su medición y control nos sean tan importantes a la hora de diagnosticar patologías asociadas a una disfunción de dichas presiones.

Valores normales y anormales de la presión arterial:


3

Presión arterial Sistólica (mmHg)

Diastólica(mmHg)

Óptima <120 <80

Normal <130 <85

Alta normal 130-139 85-89

Alta-Estado 1 140-159 90-99

Alta-Estado 2 160-179 100-109

Alta-Estado 3 >=180 >=110

Tabla 2.1 Valores normales y anormales de la presión arterial.

Figura 2.3 Relación edad-presión.

2.1.2 Métodos de obtención de la presión arterial.

Una vez definida la presión arterial volvamos a la definición de esfigmomanómetro y a los métodos de medición de dicha presión. Existen una amplia cantidad de métodos para la medición de la presión arterial de forma invasiva y no invasiva, siendo los primeros potencialmente mas exactos, pero la complejidad e inconveniencia en su aplicación hacen que los métodos no invasivos sean los mas extendidos.


4

Método Invasivo

Medición continua Tipo obtención de medidas

Intraarterial(catéter) SÍ SÍ Directa

Korotkoff(Riva_Rocci) NO NO Indirecta

Fotopletismografía NO NO Indirecta

Doppler NO NO Indirecta

Oscilométrico NO Puede Indirecta

Tabla 2.2 Obtención de la presión arterial mediante diferente metodología.

En la tabla podemos apreciar la multitud de métodos no invasivos frente a los invasivos. También se indica como obtenemos la medida, de forma directa o indirecta. La forma directa nos indica exactitud en la medida mientras que la indirecta nos indica medidas estimadas, con lo cual nunca son del todo exactas. Pese a la diferencia de exactitudes se utilizan de forma generalizada los métodos indirectos. Nosotros como ya hemos dicho, utilizaremos el método oscilométrico.

El funcionamiento del esfigmomanómetro basado en el método oscilométrico consiste básicamente en colocar un manguito en la parte superior del brazo e insuflar a una presión por encima de un umbral determinado para obstruir el flujo sanguíneo. Una vez cortado el flujo sanguíneo, se hace decrecer la presión del manguito gradualmente mediante una válvula. En el momento que la presión es inferior a la presión sistólica empieza a circula sangre produciendo turbulencia y vibraciones en el vaso ocluido. El estudio y análisis de dichas oscilaciones nos permitirán la obtención de la presión arterial.

Figura 2.4 Oscilaciones y presión en manguito.


5

2.1.3 Método oscilométrico. El sistema más utilizado en las últimas dos décadas para la obtención de la presión

arterial es sin duda la utilización del método oscilométrico. Este método intenta medir las variaciones u oscilaciones de presión que se producen en un manguito inflable y que se fija (normalmente) en la parte superior del brazo. Después del inflado el cual ha de estar por encima de la presión sistólica, y donde el propósito del cual es ocluir a la arteria braquial, el manguito comienza a desinflarse y las oscilaciones comienzan a ser evidentes por la apertura de la arteria anteriormente ocluida. Las oscilaciones dejan de estar presentes en el momento que la arteria recupera su estado normal y el manguito pasa a estar desinflado.

La presión del manguito se mide mediante un transductor de presión y a partir de

aquí se obtienen dos señales: Una, que es la que representa la caída de presión del brazalete y la otra, la señal oscilométrica, que se obtiene de filtrar y amplificar la primera señal. Estas señales pueden ser observadas en la figura 2.5.

Figura 2.5 Señales: Presión y oscilométrica.

Si observamos la figura 2.5 el punto de máxima amplitud de la señal oscilométrica, normalmente, corresponde a la presión arterial media. El punto por debajo de la presión media donde la variación de las oscilaciones disminuye de forma abrupta corresponde a la presión diastólica y el punto por encima de la presión media en el cual las oscilaciones comienzan a crecer en amplitud corresponde a la presión sistólica.

Calculando la curva envolvente de la señal oscilométrica, es posible determinar a

partir de la atura o la pendiente (de las oscilaciones) las presiones media, sistólica y diastolica. A esta curva se la conoce como pulso índice oscilométrico.

Cálculo a partir de la pendiente: se buscan los puntos de máxima y mínima pendiente en la curva envolvente.


6

Cálculo a partir de las alturas: se busca la presión de la banda a la cual la razón del valor del pulso índice medio con relación al valor máximo del pulso índice medio es igual a un valor determinado:

s

sm

HKH

= (1) d

dm

HKH

= (2)

Donde,

Ks es la constante para determinar de la presión sistólica.

Kd es la constante para determinar de la presión diastólica.

Kd y Ks se determinan de forma experimental.

Hm es la altura máxima del pulso índice oscilométrico y corresponde a la PAM

Hs es la altura que corresponde a la presión sistólica (PS)

Hd es la altura que corresponde a la presión diastolica. (PD)

Figura 2.6 Pulso índice oscilatorio.

Aun y así, el método oscilométrico solo es capaz de medir con exactitud la presión arterial media mientras que las demás presiones se estiman a partir de ella. Es por eso que existen multitud de algoritmos y criterios de cálculo.

En este proyecto no se calcularán las presiones a partir de las alturas o las pendientes sino que se utilizará un sistema de cálculo basado en la experiencia, es decir: Existen bases de datos donde se guardan multitud de lecturas de presiones arteriales y donde se buscan coincidencias dentro de la señal oscilométrica.


7

Se sabe que la presión arterial media se puede obtener de forma exacta pero que las presiones sistólica y diastólica se tienen que estimar. Partiendo de esto, se sabe empíricamente que la presión diastólica se hace evidente después hallar la presión media (pico mas alto de la señal oscilométrica). Esa presión, la diastólica, se halla en la diferencia mas abrupta entre picos de la señal oscilométrica después de la presión media.

Una vez hallada la presión media y estimada la presión diastólica, se estima la presión sistólica a través de la siguiente relación empírica:

3S DPAM D −

= +

2.1.4 Obtención de las presiones: media, sistólica y diastólica

Si observamos la figura el punto de máxima amplitud de la señal oscilométrica, normalmente, corresponde a la presión arterial media. El punto por debajo de la presión media donde la variación de las oscilaciones disminuye de forma mas abrupta corresponde a la presión diastólica y el punto por encima de la presión media en el cual las oscilaciones comienzan a crecer en amplitud corresponde a la presión sistólica.

Figura 2.15 Pulso índice o envolvente.

Ahora si nos fijamos mejor aún, podremos observar que a priori parece un tanto

complicado obtener los puntos u oscilaciones donde marca presión diastólica o sistólica. Pero por otra banda, no parece muy complicado hallar el punto mas alto que se corresponde con la presión media.

Sabiendo esto: primero registraremos las oscilaciones que se generan en el

manguito y luego determinaremos el punto más alto al que le corresponderá una presión, que será la media. A partir de ahí estimaremos las demás presiones.


8

Dicho esto, primero determinaremos la presión media y luego estimaremos las

sistólica y diastolica a partir de la siguiente relación empírica:

3

S DPAM D −= +

Para determinar la presión media, buscaremos, en el envolvente (pulso índice), el punto más elevado ya que se corresponde con la presión arterial media (PAM). Una vez obtenido ese punto buscaremos otra vez, en el envolvente, la diferencia entre los picos de las oscilaciones (después del pico de la PAM) mas abrupta, ya que empíricamente se corresponde con la presión diastólica. Y para acabar deduciremos la presión sistólica sustituyendo en la anterior formula.

Con este sistema tendremos unas medidas más que válidas para nuestro prototipo. Cabe decir que el secreto mejor guardado de las empresas que se dedican al diseño de esfigmomanómetros y que utilizan el método oscilométrico, es su algoritmo de cálculo.

2.1.5 Solución adoptada

La frecuencia de oscilación que se presenta en el flujo sanguíneo cuando se tapona un vaso y luego se libera, está en el orden de 1 a 4Hz. Conociendo esto y teniendo presente los puntos anteriores, diseñaremos y utilizaremos lo siguiente:

- Un sistema automático que sea capaz de taponar y liberar la arteria braquial.

- Un transductor de presión, que sea capaz de transformar presión en impulso eléctrico.

- Un sistema de acondicionamiento para la señal oscilométrica proveniente del transductor.

- Un sistema que sea capaz de detectar vibración.

- Un Sistema de control basado en microcontrolador y computadora.

La pieza angular de todo el diseño es el transductor de presión, que es el dispositivo que va a convertir la diferencia de presión a la entrada del transductor a una tensión de salida proporcional a dicha diferencia. El transductor que vamos a utilizar y que posteriormente explicaremos, entregará a su salida tensiones de 0 a 40mV en condiciones normales y nominales (alimentación a 10V).

Para amplificar la componente procedente del transductor utilizaremos un amplificador de instrumentación en cascada con un amplificador de tensión en configuración no inversora para que se cumplan los criterios de adquisición del micro. Esta señal nos servirá para conocer la presión.

Seguidamente y con una configuración también en serie con el amplificador de instrumentación (y en paralelo con el apartado anterior), situaremos un filtro paso banda


9

con un ancho de banda de 4Hz (1 a 4 Hz) que es el rango de frecuencias donde se moverán las oscilaciones que nos interesan captar del manguito o brazalete.

Posteriormente amplificaremos la señal procedente del filtro paso banda y añadiremos una señal continua, DC Bias.

Para completar el diseño utilizaremos un acelerómetro que nos mida la vibración durante la adquisición de la señal y a si poder rechazar una mala medida producida por el movimiento desmesurado durante la obtención de las presiones.

Para que el microcontrolador pueda interpretar la tensiones de salida del transductor es necesario que esas tensiones sean amplificadas a unas que estén en el rango de adquisición del conversor A/D del microcontrolador, para el caso que nos ocupa estará entre 0 y 5V para una resolución de 256 bytes.

2.2 Diseño hardware.

2.2.1 Diagrama Hardware

El diagrama de la figura 2.7 muestra como opera nuestro dispositivo. El usuario mediante comandos procedentes del software de gestión controla todo el sistema. El microcontrolador es el componente de control principal ya que controla todas las operaciones de inflado/desinflado, conversión A/D y comunicación ya que también se encarga de enviar al PC toda la información relevante para el control y análisis del proceso.

Figura 2.7 Diagrama conceptual del circuito.


10

2.2.2 Transductor de presión

El transductor de presión que vamos a utilizar es el MPX2202 de Freescale que es capaz de medir presiones de hasta 200kPa y responder con una tensión a su salida que oscila de forma proporcional de 0 a 40mV para una tensión de alimentación de 10V. Su salida es radiometric, es decir, que responde de forma proporcional dependiendo a que tensión alimentemos al transductor.

Figura 2.8 Relación entrada-salida del transductor. Transductor de presión

2.2.3 Amplificador de instrumentación

El AD620 es el amplificador de instrumentación que vamos a utilizar. Este amplificador fija su amplificación (ganancia) mediante una formula que nos proporciona, donde G es la ganancia y Rg es la resistencia que tendremos que poner para que trabaje como queremos.

49, 4

1gkR

GΩ

=−

49, 414,62 1g

kR Ω=

−36gR k= Ω

Nosotros buscamos una amplificación de 14.62, entonces, Rg tendrá un valor de 36 kΩ. La explicación del porque de esta ganancia viene explicado en el cálculo de las presiones apartado 2.3 Cálculo de la presión.


11

3

21

MPX2202

RG

AI VOUT

Figura 2.9 Amplificador de instrumentación AD620

2.2.4 Filtro paso banda y amplificación

La etapa del filtro paso banda (1 a 4Hz) se ha diseñado poniendo dos células Sallen-Key de segundo orden en cascada.

3

21

RA RB

CB

CA

3

21VIN

RD

RE

CD CE

VOUT

Figura 2.10 Filtro paso banda en configuración Sallen-Key.

Cálculo de filtro paso-alto:

Función de transferencia del filtro paso-alto,

20

2 1 1 1i

d d e e d d e e

V sV

s sC R C R C R C R

=⎛ ⎞

+ + +⎜ ⎟⋅ ⋅ ⋅ ⋅ ⋅⎝ ⎠

Donde,


12

1

2ce e d d

fR C R Cπ

=

( ) ( )

2( )

22( ) 2 2 2

out s

in s c c

V sV s f s fζ π π

=+ +

y 1

2Q

ζ=

Resolvemos y fijamos Ra=Rb y Ca=Cb y una frecuencia de corte de 1Hz. Para resolver este sistema se ha diseñado un proceso en Matlab que se encarga de resolverlo. Ver anexo.

1cF Hz=

eR 16dR k= = Ω

e 10dC C Fμ= =

Cálculo de filtro paso-bajo:

Función de transferencia del filtro paso-bajo,

0

2

1

1 1 1a b b a

i

a b b a a b b a

V C R C RV

s sC R C R C R C R

⋅ ⋅ ⋅=

⎛ ⎞+ + +⎜ ⎟⋅ ⋅ ⋅ ⋅ ⋅⎝ ⎠

Donde,

1

2ca b b a

fr c r cπ

=

( )

( ) ( )

2( )

22( )

22 2 2

out s c

in s c c

V fV s f s f

π

ζ π π=

+ + y

12

Qζ

=


4cF Hz=

R 39a bR k= = Ω


13

1a bC C Fμ= =

La etapa de amplificación consta de dos amplificadores en configuración no inversora puestos en serie:

5

67

R3 R4

VOUT

5

67

R1 R2

Vin

Figura 2.11 Amplificadores no inversores en serie.

Para que la señal sea mostrada correctamente, en la primera etapa fijaremos una ganancia de 100 y la segunda de 55, es decir, 100*55=5500. Luego hay que añadir la ganancia de AI que es de 14,62. La amplificación total será de G=14.62*100.55=80410.

( ) ( ) ( )Ganancia total Ganancia AI Ganancia Amp= ⋅

( ) 14,62 100 55 80410Ganancia total = ⋅ ⋅ =

Entonces para la primera etapa amplificadora tenemos,

2

1

(1 )out inRV VR

= + 2

1

100 (1 )RR

= +

Para un valor de 1 1R k= Ω tenemos 2 99R k= Ω

Y para la segunda etapa,

4

3

(1 )out inRV VR

= + 4

3

55 (1 )RR

= +

Para un valor de 3 2,22R k= Ω tenemos 4 120R k= Ω


14

Etapa amplificadora para la señal DC.

5

67

R1 R2

VinVOUT

Figura 2.12 Amplificador no inversor.

Para cumplir los criterios de amplificación, que se fijan en el apartado 2.3 Cálculo de la presión, es necesaria una amplificación de la señal de 100:


( ) 14,62 100 1462Ganancia total = ⋅ =

Entonces,

2

1

(1 )out inRV VR

= + 2

1

100 (1 )RR

= +

Para un valor de 1 1R k= Ω tenemos 2 9,9R k= Ω

2.2.5 Etapa de acoplamiento AC.

Para que el micro pueda trabajar bien, acoplamos la señal AC e introducimos una continua (DC bias level) de justo la mitad de 5V, es decir, 2.5V.


15

Figura 2.13 DC bias level.

Fijamos un condensador de 47uF y las dos resistencias iguales para tener la mitad del voltaje, 2.5V. R1=R2=50kΩ.

2.2.6 Acelerómetro

El ADXL335, de Analog Divices, es el acelerómetro que vamos a utilizar. Las características principales son las siguientes:

Figura 2.14 Acelerómetro de 3 ejes (X, Y, Z)

Es un sensor de aceleración capacitivo de 3 ejes (X, Y y Z) que se presenta en un único circuito integrado. Las tres salidas de este sensor son tensiones analógicas generadas por la aceleración. Estas tensiones serán igual a la mitad del valor de la alimentación (3,3V) más un elemento que dependerá de las aceleraciones registradas:


16

( , , ) . .2out

VsV x y z f a= ±

Vs Tensión de alimentación

F.a factor de alimentación= sensibilidad*aceleración

Sensibilidad del ADXL335 300mV/g

Ejemplo, para el registro de +1g o -1g tendríamos lo siguiente:

3.3( , , ) 0.3 1.65 0.32outV x y z = ± = ±

Donde,

( , , ) 1.65 0.3 1.95outV x y z V= ± = Para +1g

( , , ) 1.65 0.3 1.35outV x y z V= ± = Para -1g

Las salidas pueden ser leídas directamente por el micro, nosotros le añadiremos a cada salida un seguidor de tensión para mejorar la entrada al micro.


17

2.2.7 Microcontrolador

El microcontrolador que vamos a utilizar es PIC18f4550 de la casa Microchip. Principalmente se va utilizar este microcontrolador debido a que sus características se ajustan a lo que buscamos. Tiene los canales y resolución adecuada en los módulos A/D, la posibilidad de utilizar el PWM, conexión usb, varios timers, etc. Las características principales del micro son las siguientes: Disponibilidad en encapsulados de 40 y 80 pins, memoria de programa tipo flash de 32kB, memoria SRAM de 2048 bytes, memoria EEPROM de 248 bytes, puede operar a 10 MIPs, disponibilidad de hasta 13 entradas A/D, disponibilidad de una pila de 32 niveles para interrupciones internas y externas, comunicación usb, RS232, I2C o SPI, la alimentación puede oscilar entre 2 y 5,5V, etc. El esquema del micro es el siguiente:

Figura 2.15 Microcontrolador 18f4550

2.2.8 Etapa de potencia

Tanto la bomba para insuflar aire al manguito como la válvula de desinflado, necesitan de una etapa de potencia (o driver) que sea capaz de proporcionarles mucha mas potencia para poder trabajar de forma óptima con las dos cargas. Nosotros utilizaremos el integrado L293b de 4 canales capaz de proporcionar en cada una de sus salidas hasta 1A y dispone de una entrada de alimentación separada.


18

2.2.9 Etapa de alimentación

El objeto de este proyecto no tiene como objetivo diseñar una fuente de tensión para alimentar la interfase propuesta. Al tratarse de un prototipo, se prefiere alimentar el circuito con una fuente bien regulada y que sea capaz de proporcionar los siguientes voltajes: +5V, -5V y 3,3V. Para ese propósito utilizaremos una fuente tensión para PCS ya que nos proporciona todas las tensiones muy bien reguladas.

2.3 Cálculo de la presión. Ya que el transductor de presión trabaja con kPa y nosotros vamos a trabajar en

mmHg enunciaremos las siguientes igualdades:

1 0,1333mmHg kPa=

760 101,325mmHg kPa=

Es decir,

1( ) ( )0,1333

mmHgPresion mmHg Presion kPakPa

= ⋅

Conociendo esto, sabemos que: a la entrada del transductor tenemos presión mientras que a su salida tendremos su equivalente en voltios. Entonces, La relación entrada-salida (slope) es la que sigue:

520 0,13333 1,3 10 /200 1

mV kPaSlope Solope x V mmHgkPa mmHg

−= → ⋅ =

200kPa es la presión máxima que es capaz de leer el transductor a su entrada, mientras que los 20mV es el voltaje que es capaz de entregar el dispositivo para esa presión a su entrada. O sea, por cada mmHg a la entrada del transductor tendremos a su salida una variación de 0,000013V que deberemos amplificar. Hemos de recordar que el dispositivo es radiometric, en condiciones nominales con una alimentación de 10V tendríamos 40mV para un presión de 200kPa mientras que para una alimentación de 5V (por ejemplo) tendremos 20mV.

Una vez sabemos la relación entrada-salida vamos a la siguiente etapa, la amplificación de la señal de salida del transductor.

Si juntamos en un mismo bloque el amplificador de instrumentación y el amplificador de tensión en configuración no inversora y a este bloque le asignamos una entrada Vin(Amp) y una salida Vout(Amp) hallamos lo siguiente,


19

( )( ) ( )( )

Vout AmpVin Amp Vout TransductorGanancia Amp

= =

( )( ) Vout TransductorPresión kPaSlope

=

( )( )( )

Vout AmpGanancia AmpPresión kPa

Slope=

( ) 760( )( ) 101,325

Vout AmpPresión mmHgGanancia Amp Slope

= ⋅⋅

4

( ) 760( )( ) 101,325 1 10 /

Vout Amp mmHgPresión mmHgGanancia Amp kPa x V kPa−= ⋅

⋅

( )( ) 75006,16( )

Vout AmpPresión mmHgGanancia Amp

= ⋅

Con lo que sabiendo la ganancia de la etapa amplificadora y la tensión de salida de esa misma etapa podemos conocer la presión en mmHg.

La señal de la etapa amplificadora Vout(Amp) llega al ADC del micro para poder ser interpretada. El micro que vamos a utilizar puede trabajar con 10 y 8 bits de resolución, nosotros trabajaremos con 8 bits. A su vez, el rango de adquisición de microcontrolador esta entre 0 y 5V.

5( ) 0,0195 /256

Vresolución ADC V ByteBytes

= =

Una vez que sabemos cual es la unidad mínima en voltios que es capaz de medir el micro, vamos a estudiar con que ganancia tenemos que trabajar para ser capaces de medir una variación de 1 mmHg a la entrada del ADC.

Teniendo,

( )( ) 75.006,16( )

Vout AmpPresión mmHgGanancia Amp

= ⋅

Para 1mmHg tendremos lo siguiente


20

( )1 75.006,16( )

Vout AmpmmHgGanancia Amp

= ⋅

0.0195( ) 75.006,161

Ganancia AmpmmHg

= ⋅

( ) 1462,62Ganancia Amp =

Es decir, para detectar 1mmHg a la entrada del micro deberemos amplificar la señal que sale del transductor 1462 veces.

Y para saber que medida le corresponde a 5V, hacemos lo siguiente:

5( ) 75.006,161462,62

VPresión mmHg = ⋅

( ) 256,4Presión mmHg mmHg=


21

2.4 Algoritmos de Control.

2.4.1 Firmware

2.4.1.1 Función main().

La función principal main() representa la rutina que se ejecuta en el micro. Podemos ver la simplicidad del mismo. Primero inicializamos variables y configuramos módulos (adc, pwm, timers..) y luego entramos en un bucle infinito en el que se ejecutaran dos funciones principales. La primera función es la de escucha o recepción de ordenes que provienen del host, la segunda función principal sería la ejecución de las ordenes y envío de datos al host. void main(void) ini(); config(); while (TRUE) /*Bucle infinito*/ accions(); recibir();

2.4.1.2 Adquisición mediante ADC.

Para la obtención de los datos vía ADC creamos una función (ten_acel()) que fija los tiempos de adquisición, es decir, la frecuencia de muestreo de las señales. Los canales utilizados son el AN0, AN1 y AN5. La frecuencia de muestreo supera con creces las señales a adquirir, cumplimos con Nyquist. Esta función muestrea tanto las dos señales que provienen del transductor de presión como la señal que proviene del acelerómetro. La función es la siguiente: void ten_acel(void) /*Funcion: ecg_ten_acel. ADC canales: AN0 AN1 AN5 Retardo entre lecturas: 3ms Envio de Datos:tramas de 128 bytes Endpoint de salida: 2*/ if(flag_ecg_ten_acel==1) /*componente DC*/ if((flag_dc)&(flag_paquete_listo==0))


22

Set_ADC_Channel(0); /*señal DC*/ delay_us(5); c=read_ADC(); send_ten[cnt]=c; cnt=cnt+1; if(cnt==128) cnt=0; flag_paquete_listo=1; endpoint=2; /*componente AC*/ if((flag_ac)&(flag_paquete_listo==0)) Set_ADC_Channel(1); /*señal AC*/ delay_us(5); cc=read_ADC(); send_ten[cnt]=cc; cnt=cnt+1; if(cnt==128) cnt=0; flag_paquete_listo=1; endpoint=2; /*componente de aceleración*/ if((flag_acel)&(flag_paquete_listo==0)) Set_ADC_Channel(5); delay_us(5); cc_aux=read_ADC(); flt_umbral_beta(); /*evaluamos el umbral*/ flag_ecg_ten_acel=0; if((flag_paquete_listo)&(flag_acel)&(flag_dc)&(flag_ac)) if(usb_enumerated()) usb_put_packet(endpoint, send_ten, 128, USB_DTS_TOGGLE); flag_paquete_listo=0;

2.4.1.3 Empaquetado de los datos adquiridos.

La función read_ADC() se encarga de captar la muestra. Esa muestra pasa a un array de 128 posiciones que una vez completado dará por finalizado el paquete activando la bandera flag_paquete_listo y nos indicará el endpoint de salida.


23

/*... aquí hay mas código ...*/ delay_us(5); c=read_ADC(); send_ten[cnt]=c; cnt=cnt+1; if(cnt==128) cnt=0; flag_paquete_listo=1; endpoint=2; /*... aquí hay mas código...*/

2.4.1.4 Envío de paquetes al host.

La condición necesaria para poder enviar un paquete al host, es tener el paquete listo que se nos notificará mediante la activación de la bandera flag_paquete_listo. Una vez que tenemos el OK, comprobamos mediante usb_enumerated() que el host nos ha enumerado y si es así, mediante la función usb_put_packet() enviamos la trama con los datos.

if((flag_paquete_listo)&(flag_acel)&(flag_dc)&(flag_ac)) if(usb_enumerated()) usb_put_packet(endpoint, send_ten, 128, USB_DTS_TOGGLE); flag_paquete_listo=0;

2.4.1.5 Recepción de paquetes provenientes del host.

Esta función siempre esta a la escucha mediante polling, es decir, durante la ejecución todo el proceso testea el endpoint (en este caso el 1) para saber si ha dejado algo en el buffer, si se cumple la condición recoge los datos y comprueba las ordenes. Dependiendo de lo que llegue ejecutará una cosa u otra.

void recibir(void) if (usb_kbhit(1)) if(usb_get_packet(1, entrada, 64)) /*... aquí hay mas código, no relevante para el tensiómetro*/


24

if(entrada[25]==3) /*tensiómetro acelerómetro activo*/ channel=8; cnt=0; if(entrada[11]==9) /*bomba on*/ flag_motor_on=1; if(entrada[11]==2) /*bomba off*/ flag_motor_off=1; if(entrada[1]==3) /*válvula on*/ flag_valvula_on=1; if(entrada[1]==4) /*válvula off*/ flag_valvula_off=1; if(entrada[4]==1) /*bomba on, válvula on*/ estado_1(); if(entrada[4]==2) /*bomba off, válvula on*/ estado_2(); if(entrada[4]==3) /*válvula off, abierta*/ estado_3(); /*... aquí hay mas código, no relevante para el tensiómetro*/

2.4.1.6 Activación y desactivación de la bomba

Para la activación y la desactivación de la bomba utilizamos el PWM variando el duty cycle de forma incremental o decremental dependiendo del caso.

void bomba(int activar_M) /*Función: bomba. Config: PWM_1 Duty: Ton=T-> incremental*/ int16 i; if(activar_M==1) /*Activamos el motor*/ output_high(PIN_D2); for(i=0;i<1024;i++)


25

delay_us(300); Set_pwm1_duty(i); flag_motor_set=1; activar_M=101; if(activar_M==0) /*Desactivamos el motor*/ if(flag_motor_set==1) for(i=1023;i>0;i--) delay_us(300); Set_pwm1_duty(i); output_low(PIN_D2); activar_M=101; flag_motor_set=0;

2.4.1.7 Activación y desactivación de la válvula

Para la activación de la válvula utilizamos el PWM variando el duty cycle de forma incremental y para la desactivación anulamos directamente la tensión que alimenta a la válvula. De esa forma la abrimos de forma inmediata.

void valvula(int activar_V) /*Función: válvula. Config: PWM_2. Duty: Ton=T -> incremental*/ int16 i; if(activar_V==1) /*activamos la válvula*/ output_high(PIN_D3); for(i=0;i<1024;i++) Set_pwm2_duty(i); activar_V=101; if(activar_V==0) /*desactivamos la válvula*/ output_low(PIN_D3); activar_V=101;


26

2.4.1.8 Estados de trabajo

Cuando trabajamos con el tensiómetro, básicamente estaremos en 3 estados: cuando la bomba esta insuflando aire al manguito y la válvula este cerrada, estado_1(). Después de haber insuflado aire y hemos llegado a la consigna, apagamos la bomba y mantenemos la válvula estado_2(). Y por último, abrimos la válvula estado_3(). void estado_1(void) valvula(on); bomba(on); void estado_2(void) bomba(off); valvula(on); void estado_3(void) valvula(off);

2.4.1.9 Obtención del umbral para detectar vibración.

Esta función se encarga de obtener mil muestras del acelerómetro en un segundo. Hace la media de esas mil muestras y el resultado lo fija como el umbral. Cuando detecta vibración por encima del umbral mas menos un Offset, esta obvia los dotas captados por el transductor y no los registra. De esa forma evitamos vibración en la medida.

void obt_umbral(void) float acumulado=0; int16 i; for(i=0;i<1000;i++) delay_ms(1); Set_ADC_Channel(5); delay_us(5); cc=read_ADC(); acumulado=acumulado+cc; acumulado=acumulado/1000; umbral_acel=acumulado; umbral_acel_1=umbral_acel+20; /*sumamos una cota al umbral*/ umbral_acel_2=umbral_acel-20; cnt_errores=0; void flt_umbral_beta(void) /*esta función sirve como filtro y va a absorver las oscilaciones que


27

/*no nos interesan*/ if((cc_aux>umbral_acel_1)|(cc_aux<umbral_acel_2)) cnt=cnt-2; cnt_errores=cnt_errores+1; if(cnt_errores==255)cnt_errores=0;

2.4.2 Software.

2.4.2.1 Función main.

Como vemos en el código, este proceso hace lo siguiente: Inicializar, conectar con el dispositivo vía usb y después entrar en un bucle infinito (video.Menu()) del que no sale hasta que el usuario lo decide. Dentro de este bucle infinito se representaran las señales y datos que recibamos del instrumento.

int _tmain(int argc, _TCHAR* argv[]) video.Inicializacion(); video.Mascara(); usb.inicializacion(); video.CargarImagen(40,520, "Panel_texto.jpg", 40); if(usb.DeviceConectado()) video.mensaje(48,550, msn_1,13,2); else video.mensaje(48,550, msn_2,13,3); video.AbrirVentana(); video.Menu(); video.CerrarVentana(); return 0;

2.4.2.2 Comunicación usb.

Para la comunicación usb hemos utilizado la librería mpusbapi.h que nos permite la comunicación con el microcontrolador. Para utilizar las funciones que nos proporciona esta librería, hemos creado una serie de funciones de entre las cuales se encuentran las siguientes:

void inicializacion();

/*llama a la función LoadMUSBDLL() y nos dice si el dispositivo esta conectado*/


28

void LoadMPUSBDLL(); /*Carga la librería MPUSBDLL*/

void OpenPipes(); /*Abre un “tubo,pipe” el que le digamos para comunicarnos*/

void ClosePipes(); /*Cierra el “tubo,pipe” que hemos estado utilizando*/

int DeviceConectado(); /*Función que testea si el dispositivo esta conectado*/

void SendPacket(BYTE *SendData, DWORD SendLength); /*Función que testea si el dispositivo esta conectado*/ void ReceivePacket_ecg(BYTE *ReceiveData, DWORD *ReceiveLength); /*Función que testea si hay datos provenientes del usb, en este caso datos concernientes a la señal ECG*/ void ReceivePacket_acel(BYTE *ReceiveData, DWORD *ReceiveLength); /*Función que testea si hay datos provenientes del usb, en este caso datos concernientes a la señal de aceleración*/ void ReceivePacket_ten(BYTE *ReceiveData, DWORD *ReceiveLength); /*Función que testea si hay datos provenientes del usb, en este caso datos concernientes a la señal de presión*/ int recibir_ecg(); /*Función que llama ReceivePacket y guarda los datos recibidos en un

Array. En este caso guarda datos del ECG*/ int recibir_acel(); /*Función que llama ReceivePacket y guarda los datos recibidos en un

Array. En este caso guarda datos del acelerómetro*/ int recibir_ten(); /*Función que llama ReceivePacket y guarda los datos recibidos en un

Array. En este caso guarda datos del tensiómetro*/ void cmd(BYTE x, int j); /*Función que llama a sendPacket*/

2.4.2.3 Graficación de señales.

Para la representación de los datos, graficas y “form” de nuestro proceso hemos utilizado la librería SDL.h que es OpenSource y de la cual existe multitud de documentación ya que es muy utiliza para el diseño de juegos. Las principales funciones que hemos creado para el graficado son las siguientes: int Inicializacion(); /*En esta función inicializamos y declaramos principalmente la resolución de la pantalla y el timer que vamos a utilizar para escribir en ella, entre otras*/ int IniVariables(); /*Inicializacion de variables o funciones*/ int Pantalla(); /*Llama a la función Recibirdatos(), grafica las señales y actualiza los cambios en la pantalla*/


29

int mensaje(int x,int y, char mensaje[200],int size, int colorMsn); /*Función que presenta por pantalla un string junto con los Parametros, tamaño o size, posición y color*/ int Liberar_Superficies(); /*Función que sirve para liberar superficies cargadas en memoria*/ int PrintlowSeñal(int dato,int top, int down,int right,int left); /*Función que presenta la señal ECG en un rectángulo. Los parametros permiten redimensionar la presentación de la gráfica*/ void Mascara(); /*Función que dibuja la forma o “chasis” del programa*/ void Mascara_Reset(); /*Función que redibuja la forma o “chasis” del programa*/ void CargarImagen(int x, int y, char file[60], int intensidad); /*Función que presenta una imagen en pantalla. Sus parametros son: posición e intensidad*/ void Borrar_Screen(int x, int y, int w, int h); /*Función que borra mediante un rectangulo la porción de pantalla que le pasamos*/ void CerrarVentana(); /*Función que emula el redimensionado de mayor a menor de una ventana*/ void AbrirVentana(); /*Función que emula el redimensionado de menor a mayor de una ventana*/ void PrintSeñal(); /*Función que grafica las señales a presentar*/ void Fondo(); /*Función que nos carga el fondo de nuestro proceso*/ void Help(); /*Función que presenta varias imágenes con contenido informativo*/

2.4.2.4 Control por teclado.

El control del proceso se realiza por teclado. Las librerías SDL.h disponen de funciones tanto para dibujar en la pantalla como la de escucha de eventos provenientes del teclado o ratón (también nos permite utilizar la tarjeta de sonido, aunque no la utilizaremos). Nosotros aprovechamos estas cualidades de escucha de eventos para controlar los estados de nuestro proceso. Las funciones mas características son las siguientes:

void Eventos_Teclado(void); /*Función que agrupa y llama a las funciones Teclado_fn(), Teclado_numeros, Teclado_letras() y Teclado_especiales()*/ void Teclado_fn(void);


30

/*Función que escucha si se oprimen las teclas función y a partir de aquí llama a diferentes funciones*/ void Teclado_numeros(void); /*Función que escucha si se oprimen las teclas números y a partir de aquí llama a diferentes funciones*/ void Teclado_letras(void); /*Función que escucha si se oprimen las teclas letras y a partir de aquí llama a diferentes funciones*/ void Teclado_especiales(void); /*Función que escucha si se oprimen las teclas especiales y a partir de aquí llama a diferentes funciones*/


31

2.5 Presupuesto.

2.5.1 Coste de recursos hardware.

El hardware de desarrollo del sistema consta de un ordenador portátil de las siguientes características:

• Procesador Intel(R) Pentium(R) M a 2GHz. • Memoria RAM de 1GB a 798MHz. • Disco duro de 80GB.

Además del PC, se ha hecho uso de un voltímetro digital, el programador in-Circuit Debugger ICD2, una fuente de tensión, un osciloscopio Tektronic y una estación soldadora.

Para calcular el importe proporcional al uso dado, teniendo en cuenta el periodo de amortización de los recursos hardware utilizado, se establece un periodo medio de amortización de 6 meses para cada uno de los elementos. Por otra banda se fija un periodo de amortización total de 60 meses. Con lo que:

CONCEPTO PRECIO € / MES MESES IMPORTE

PC Pentium(R) M 2GHZ 1500 € 25 € 6 150,00 €

Programador Debugger ICD2 300 € 5 € 6 30,00 €

Estación de soldar 150 € 2.5 € 6 15,00 €

Multímetro digital 30 € 0.05 € 6 0,30 €

Osciloscopio Tektronic 300 € 5 € 6 30,00 €

Fuente de tensión 100 € 1,6 € 6 10,00 €

TOTAL 235,30€

Tabla 2.3 Coste recursos hardware.

2.5.2 Coste de recursos Software.

El software utilizado en el desarrollo del proyecto consta de:

• Sistema operativo: Microsoft Windows XP Pro SP3. • Software desarrollo software: Visual C++ 2008 Express Edition.


32

• Software desarrollo software: Matlab R2009b. • Software desarrollo firmware: Mplab IDE v8.10. • Software desarrollo firmware: PCWH 3.235 de CCS. • Software diseño circuitos: Eagle Professional 4.16. • Software simulación de circuitos: Proteus 7 Professional. • Software simulación/diseño de circuitos: FilterPro.

Para calcular el importe proporcional de los componentes software, también se establece un periodo de amortización de 60 meses.

El software que le acompañe el símbolo (*) no lo contabilizamos ya que son versiones para estudiantes o son trials versions, suficientes para realizar el proyecto.


Microsoft Windows XP Professional SP2 100 € 1,66 € 6 10,00 €

Visual C++ 2008 Express Edition (*) 0 € 0 6 0,00 €

Matlab R2009b (*) 0 € 0 6 0,00 €

Mplab IDE v8.10 (*) 0 € 0 6 0,00 €

PCWH 3.235 de CCS (*) 0 € 0 6 0,00 €

Eagle Professional 4.16 (*) 0 € 0 6 0,00 €

Compilador PCWH 3.235 (*) 0 € 0 6 0,00 €

FilterPro (*) 0 € 0 6 0,00 €

TOTAL 10,00 €

Tabla 2.4 Coste recursos software.

2.5.3 Coste de los componentes.

A continuación se detalla el precio, en euros, y la cantidad de cada componente utilizado:


33

CONCEPTO PRECIO UNIDAD UDS. PRECIO

TOTAL

Resistencia 0,25W 3k6Ω 0,04 1 0,04 €

Resistencia 0,25W 16kΩ 0,04 2 0,08 €

Resistencia 0,25W 39kΩ 0,10 2 0,20 €

Resistencia 0,25W 99kΩ 0,10 1 0,20 €

Resistencia 0,25W 1kΩ 0,04 2 0,08 €

Resistencia 0,25W 120kΩ 0,15 1 0,15 €

Resistencia 0,25W 2k2Ω 0,04 1 0,04 €

Resistencia 0,25W 9k9Ω 0,15 1 0,15 €

Resistencia 0,25W 50kΩ 0,10 2 0,20 €

Condensador electrolítico 10uF 0,18 2 0,36 €


Condensador poliéster 100nF 0,20 4 0,80 €


Condensador cerámico 15pF 0,30 2 0,60 €

Diodo 1N4148 0,05 2 0,10 €

Diodo Led 5mm 0,05 2 0,10 €

Pulsador 6x6mm 0,26 2 0,52 €


TOTAL

Conector USB tipo B hembra 1,25 1 1,25 €

Conector RS232 DB9 2,45 2 4,90 €

CI MAX232 2,50 1 2,50 €

CI AD620A 5,50 1 5,50 €

CI TL084A 1,50 2 3,00 €

CI L293 4 1 4,00 €

CI PIC18F4550 8,30 1 8,30 €

MPX 2202GP 10,50 1 10,50 €

Diodo Led 5mm tricolor 0,37 2 0,74 €

Cristal oscilador de cuarzo 20MHz 0,91 1 0,91 €

Zócalo de 40 pines 0,27 1 0,27 €




34

Terminal roscado 1 6 6,00 €

Placa de prototipos 2,85 1 2,85 €

Cable USB A macho-B macho 2,95 1 2,95 €


TOTAL

BOMBA DC 11 1 11,00 €

VÁLVULA DC 9 1 9,00 €

CUF 11 1 11,00 €

TUBO PLÁSTICO 5 1 5,00 €

TOTAL 94,55 €

Tabla 2.5 Coste componentes electrónicos.

2.5.4 Coste de recursos humanos.

Las tareas realizadas son el análisis de requisitos, diseño, implementación y experimentación.

A continuación se muestra el tiempo dedicado a cada una de las tareas y el importe resultante aplicando un precio de 40€/hora:

CONCEPTO UDS. IMPORTE

Análisis de requisitos 60 2400,00 €

Diseño 130 5200,00 €

Implementación 100 4000,00 €

Experimentación 50 2000,00 €

TOTAL 13.600,00 €

Tabla 2.6 Coste de recursos humanos.

2.5.5 Coste total del proyecto.

Los precios mostrados en todo el presupuesto incluyen el 18% de IVA. A continuación se muestra el coste total del proyecto:


35

CONCEPTO IMPORTE

Recursos Hardware 235,30 €

Recursos Software 10,00 €

Componentes 94,55 €

Recursos Humanos 13.600,00 €

TOTAL 13.939,85 €

Tabla 2.7 Coste total del proyecto.

El coste total del proyecto asciende a TRECE MIL NOVECIENTOS TREINTA Y NUEVE euros con CINQUENTA Y CINCO céntimos.

2.6 Bibliografía y webgrafía.

1. Consulta esfigmomanómetro en la enciclopedia online Wikipedia: http://es.wikipedia.org/wiki/Esfigmoman%C3%B3metro, 2011

2. Consulta presión arterial en la Universidad de Oviedo:

http://www.ate.uniovi.es/14005/documentos/clases%20pdf/presion%20arterial%201.pdf, 2011

3. Diseño y construcción de una interfaz de medición de signos vitales para priorizar

la atención medica en el servicio de urgencias de un hospital general de zona: http://itzamna.bnct.ipn.mx:8080/dspace/bitstream/123456789/8041/1/ice309.pdf, 2011

4. Esfigmomanómetro basado en el método oscilométrico:

http://www.rosario2009.sabi.org.ar/uploadsarchivos/p200.pdf, 2011

5. Portable blood pressure monitor: http://people.ece.cornell.edu/land/courses/ece4760/FinalProjects/s2005/ww56_ws62/Final%20Project%20Web/index.html, 2011


36

3 Electrocardiógrafo.

3.1 Definición, aplicación y solución.

3.1.1 El Electrocardiógrafo.

Desde el siglo XVII se estudian las señales eléctricas en los tejidos humanos y animales. El trascurso del tiempo y los sucesivos descubrimientos en esta materia y paralelamente en otras, han ido desembocando en sistemas de detección y tratamiento de ciertas patologías, entre ellas las cardiacas, como el electrocardiógrafo o el desfibrilador.

Durante todo ese tiempo se han logrado grandes avances, nombraré los mas relevantes:

En 1842 el físico Carlo Matteucci muestra cómo la corriente eléctrica acompaña a cada latido cardíaco. Para este experimento, utiliza el nervio de un anca de rana. 14 años después, en 1856, Rudolph von Koelliker y Heinrich Muller, confirman el experimento de Matterucci, en el que aseguraba, que a cada latido, le acompañaba un impulso eléctrico. Para ello, aplicaron un galvanómetro en la base y ápice de un ventrículo expuesto.

En 1872, Alexander Muirhead, un ingeniero eléctrico. Dice haber registrado un electrocardiograma conectando unos alambres a las muñecas de un paciente. 6 años después, John Burden Sanderson junto con Frederick Page registran la señal eléctrica del corazón mediante un electrómetro capilar diferenciando dos fases: la señal QRS y la T.

A finales del XIX, Auguste Waller pública el primer electrocardiograma humano. Utiliza un galvanómetro capilar. Mas tarde, William Bayliss y Edward Starling mejoran el galvanómetro capilar y hallan una “variación trifásica” que acompaña a cada latido (P-QRS-T), dándose cuenta que hay un retraso de 0,13s entre estimulación atrial y despolarización ventricular (intervalo PR).

En 1895 aparece en escena el Dr. en medicina holandés Willem Einthoven, el cual diferencia cinco ondas a las que denominará P, Q, R, S y T. Seis años después inventa un dispositivo capaz de generar electrocardiogramas, el dispositivo en cuestión era un galvanómetro a cuerda. Gracias a este invento, publica su primer artículo y comunica su experiencia y utilidad para registrar señales eléctricas cardiacas. Mas tarde en un artículo titulado “Le telecardiogramme” describe con detalle las aplicaciones clínicas del electrocardiograma, y centra sus investigaciones en la detección de patrones asociados a patologías cardiacas. Einthoven llego a conectar el hospital, en el que trabajaba, vía cable a su laboratorio que estaba a 1,5km. Poco después la empresa Cambridge Scientific Instruments fabrica la máquina de Einthoven (1911). Al año siguiente describe un triangulo formado por tres derivaciones I, II, III y que mas adelante sería llamado el triangulo de Einthoven. En 1924 recibe el premio Nobel por inventar el electrocardiógrafo.

En 1928 la empresa Frank Sanborn comercializa el primer electrocardiógrafo portátil (con 25kg de peso y una batería de 6V). Unos años después (1949) Norman Holter desarrolla una especie de mochila con la que se pueden registrar electrocardiogramas y


37

transmitir sus señales. Posteriormente a este dispositivo se le llamará monitor Holter. Hoy en día es muy utilizado.

Actualmente el electrocardiógrafo es el instrumento número uno en detección de patología cardiaca.

Se siguen desarrollando nuevos electrocardiógrafos, cada vez más fiables y más inteligentes. Como apunte, decir que el corazón es el órgano más estudiado y del que mejor se conoce su funcionamiento y patología asociada. No hace falta decir que esto se debe en gran parte al electrocardiógrafo.

3.1.2 El corazón.

El corazón, es sin duda el órgano más relevante del cuerpo humano. Su función principal es hacer llegar a todo el cuerpo sangre oxigenada. Este órgano se divide en dos partes (izquierda y derecha) y estas, a su vez, se dividen en dos cavidades (ventrículo y aurícula) que están separadas por unas válvulas que permiten que la sangre solo circule en un sentido.

¿Como interactúan estas partes? Por la aurícula derecha llega la sangre venosa del cuerpo y es reconducida a través de la válvula al ventrículo derecho, el cual la bombea hacia los pulmones. Una vez que la sangre ha sido oxigenada por el paso por los pulmones es devuelta al corazón a través de la aurícula izquierda. De aquí, pasa al ventrículo izquierdo y este la bombea al resto del cuerpo. Esta es la principal función del corazón.

Pero ¿que es lo que hace que trabaje de esta forma? O mejor dicho ¿que provoca el sincronismo anterior? El sistema de conducción.

3.1.3 Sistema de conducción.

Este sistema tiene su origen en el nodo sinusal (mirar figura 3.1) que es capaz de generar un impulso electroquímico que se propaga a través del miocardio estimulándolo, causando su contracción y haciendo que la sangre sea bombeada por todo el cuerpo.

Ese estímulo electro-químico se inicia, debido a las características electrofisiológicas de las células que lo forman, en el nodo sinusal, situado cerca de la desembocadura de la vena cava superior, en la aurícula derecha. Desde aquí y a través de las vías de conducción ínter auriculares e internodales, el impulso, que se transmite a ambas aurículas, alcanza el nodo AV, situado en la porción derecha de la unión de los tabiques interauricular e interventricular. En este nodo AV se produce un ligero enlentecimiento de la velocidad de conducción del impulso (unos 110ms) que coincide con la sístole o contracción auricular. El impulso continúa por el Haz de His y sus ramas (derecha e izquierda), hasta alcanzar a través de la red de Purkinje a las fibras musculares de ambos ventrículos.

Este proceso se repite de forma continua hasta el fallecimiento.


38

Figura 3.1 Sistema de conducción.

3.1.4 Electrocardiografía.

Al estudio de la actividad eléctrica del corazón se la conoce como electrocardiografía y tiene como principal objetivo la diagnosis clínica. El gráfico que se obtiene de medir esa actividad eléctrica se le denomina electrocardiograma o ECG. Y al interfaz capaz de registrar la actividad eléctrica del corazón se le denomina electrocardiógrafo.

El electrocardiograma, como hemos dicho, representa la señal eléctrica que circula por el corazón. Esa señal eléctrica, se repite en cada latido, en principio, con ondas fácilmente identificables. Cada uno de esas ondas definen una parte de la electro-física cardiaca. La suma de esas ondas dan lugar al electrocardiograma.

Figura 3.2 Electrocardiograma, ondas e intervalos.


39

Principales ondas e intervalos:

Onda P: se corresponde con la despolarización auricular o contracción auricular. Su morfología es redondeada y los tiempos de esta onda suelen ser inferiores a 100ms con amplitudes que van desde los 0,1mV a los 0,5mV.

Ondas Q, R, S. Se corresponden con la despolarización ventricular o contracción ventricular. Su morfología es picuda y los tiempos de esta onda suelen estar comprendidos entre 60 y 110ms con amplitudes de hasta 4mV.

Onda T: Se corresponde con la repolarización ventricular o descontracción ventricular con amplitudes no superiores a 0,6mV.

Onda U: Se cree que se corresponde con la despolarización de las fibras de Purkinje y su amplitud es de muy bajo voltaje.

Intervalo PQ: Varía con la edad y con la frecuencia cardiaca. Comienza en el inicio de la onda P y acaba al inicio del complejo QRS. Esta producido en gran medida por el retraso del impulso que viene de las aurículas al pasar por el nodo AV. Este intervalo oscila entre 100ms-200ms.

Intervalo QT: Es la suma de la despolaración y repolarización del miocardio ventricular y se mide desde el inicio del complejo QRS hasta el final de la onda T. Intervalo inferior a 400ms.

Intervalo RR: Se corresponde al intervalo de tiempo entre la onda R de un complejo QRS con la onda R del siguiente complejo QRS. Representa la frecuencia cardiaca.

3.1.5 Derivaciones.

Para poder medir la actividad eléctrica es necesaria la colocación de electrodos en determinadas partes del cuerpo, tales como: Los brazos, las piernas y el pecho, dando lugar a 12 derivaciones las cuales se dividen en 3 grupos: Derivaciones bipolares, monopolares y precordiales.

Las derivaciones bipolares registran la diferencia de potencial entre dos puntos y se clasifican de la siguiente forma:

Derivación I: Entre el brazo izquierdo (+) y brazo derecho (-).

Derivación II: Entre pierna izquierda (+ ) y brazo derecho(-).

Derivación III: Entre pierna izquierda (+) y brazo izquierdo (-).

Las derivaciones monopolares registran las variaciones de potencial de un punto respecto a otro que se considera con actividad eléctrica 0 y se clasifican en: aVR, aVL y aVF donde la “a” significa aumento, V significa vector, R (right), L (left) y F (foot).

Las derivaciones precordiales se disponen de la siguiente manera:

V1: 4º espacio intercostal derecho, línea paraesternal derecha. V2: 4º espacio intercostal izquierdo, línea paraesternal izquierda V3: simétrico entre V2 y V4. V4: 5º espacio intercostal izquierdo, línea medioclavicular. V5: 5º espacio intercostal izquierdo, línea anterior axilar.


40

V6: 5º espacio intercostal izquierdo, línea axilar media

Figura 3.3 Derivaciones.

3.1.6 Solución adoptada

La tensión que vamos a sensar del cuerpo para reproducir la señal generada por el corazón es del orden de 0,1mV y las frecuencias de esta señal, para monitoreo, están por debajo de los 100Hz, así que utilizaremos varias etapas para que el sensado y el acondicionamiento sean correctos. Las etapas que utilizaremos para el diseño son las siguientes: Amplificación de instrumentación, filtro paso alto, filtro paso bajo, filtro paso banda, desplazador de nivel y una etapa para disminuir el ruido en modo común. También utilizaremos un microcontrolador para el registro de la señal y la conversión analógica a digital.

Descripción de las etapas:

Para amplificar la componente procedente del cuerpo utilizaremos un amplificador de instrumentación con un alto CMRR.

Para disminuir el ruido en modo común, que puede afectar a la señal utilizaremos el driver RL o también conocido como right-leg common mode feedback.

Seguidamente y con una configuración en serie con el amplificador de instrumentación, situaremos un filtro paso banda con un ancho de banda de 100 Hz (0,05 a 100Hz) que es el rango de frecuencias donde se moverán las oscilaciones que nos interesan captar.

Una vez filtrada la señal que nos interesa eliminaremos el espectro de 50Hz (procedente de la red) mediante un filtro rechaza banda. Posteriormente elevaremos la señal.

Posteriormente y también en configuración en serie con el filtro rechaza banda y amplificador, situaremos una etapa de polarización positiva (desplazador de nivel) ya que el micro no es capaz de interpretar tensión negativa y de ahí que sea necesaria esa etapa.

Para que el microcontrolador pueda interpretar las tensiones captadas del cuerpo es necesario que esas tensiones sean amplificadas a unas que estén en el rango de adquisición


41

del conversor A/D del micro, para el caso que nos ocupa estará entre 0 y 5V para una resolución de 256 bytes.

3.2 Diseño hardware.

3.2.1 Diagrama Hardware

El diagrama de la figura 3.4 muestra como opera nuestro dispositivo. El sistema se gestiona a través de comandos procedentes del software. El microcontrolador es el componente principal de control, ya que controla todas las operaciones de conversión, recepción y envío de datos. Los otros módulos al no ser “inteligentes” se limitan a una única función: Amplificar, filtrar, polarizar, etc. Respecto al PC, se limita a interpretar todos los datos que envía el micro y a mostrarlos por pantalla de forma adecuada.

Figura 3.4 Diagrama conceptual del circuito.

3.2.2 Amplificador de Instrumentación

El AD620 es el amplificador de instrumentación que vamos a utilizar. Este amplificador fija su amplificación (ganancia) mediante una fórmula que nos proporciona el fabricante, donde G es la ganancia y Rg es la resistencia que tendremos que poner para que trabaje con esa ganancia.

49, 4

1gKR

GΩ

=−


42

Como posteriormente se explicara, necesitamos sensar el CMRR. Para ello, añadimos dos resistencias como se muestra en la figura 3.5. Al añadir dichas resistencias, la ganancia del AI queda definida de la siguiente forma:

49, 4 49, 4 1

1 2gK KR

G RΩ Ω

= + ⋅−

Nosotros buscamos una amplificación de 10, entonces, RG tendrá un valor de 6,6kΩ para un valor de R=22kΩ.

Figura 3.5 Amplificador de instrumentación AD620.

3.2.3 Filtro paso banda y amplificación

La etapa del filtro paso-banda (0,05 a 100Hz) se ha diseñado poniendo dos células Sallen-Key de segundo orden en cascada.

3

21

RA RB

CB

CA

3

21VIN

RD

RE

CD CE

VOUT

Figura 3.6 Filtro paso banda en configuración Sallen-key


43

Cálculo de filtro paso-alto:

Función de transferencia del filtro paso-alto,

20

2 1 1 1i

d d e e d d e e

V sV

s sC R C R C R C R

=⎛ ⎞

+ + +⎜ ⎟⋅ ⋅ ⋅ ⋅ ⋅⎝ ⎠

Donde,

1

2ce e d d

fR C R Cπ

=

( ) ( )

2( )

22( ) 2 2 2

out s

in s c c

V sV s f s fζ π π

=+ +

y 1

2Q

ζ=

Resolvemos y fijamos Ra=Rb y Ca=Cb y una frecuencia de corte de 0,05Hz. Para resolver este sistema se ha diseñado un proceso en Matlab que se encarga de resolverlo. Ver anexo.

0,05cF Hz=

e 330dR R k= = Ω

e 10dC C Fμ= =

Cálculo de filtro paso-bajo:

Función de transferencia del filtro paso-bajo,

0

2

1

1 1 1a b b a

i

a b b a a b b a

V C R C RV

s sC R C R C R C R

⋅ ⋅ ⋅=

⎛ ⎞+ + +⎜ ⎟⋅ ⋅ ⋅ ⋅ ⋅⎝ ⎠

Donde,


44

1

2ca b b a

fR C R Cπ

=

( )

( ) ( )

2( )

22( )

22 2 2

out s c

in s c c

V fV s f s f

π

ζ π π=

+ + y

12

Qζ

=


100cF Hz=

R 1,6a bR k= = Ω

1a bC C Fμ= =

La etapa de amplificación consta de dos amplificadores en configuración no inversora puestos en serie:

5

67

R3 R4

VOUT

5

67

R1 R2

Vin

Figura 3.7 Amplificadores en serie en configuración no inversora.

Para que la señal sea mostrada correctamente, en la primera etapa fijaremos una ganancia de 10 y la segunda de 10, es decir ,10*10=100. Luego hay que añadir la ganancia de AI que es de 10. La amplificación total será de G=10*100=1000.


( ) 10 10 10 1000Ganancia total = ⋅ ⋅ =

Entonces para la primera etapa amplificadora tenemos,


45

2

1

(1 )out inRV VR

= + 2

1

10 (1 )RR

= +


Y para la segunda etapa,

2

1

(1 )out inRV VR

= + 2

1

10 (1 )RR

= +


3.2.4 Filtro NOTCH

Un filtro Notch es un filtro que se diseña para que rechace una banda o frecuencia determinada. En el caso que nos ocupa la frecuencia que nos interesa eliminar es la de la red, 50Hz. El filtro Notch que proponemos es el siguiente:

Figura 3.8 Filtro Notch en doble T.

Si,

1

2oFRCπ

=


46

Si ahora fijamos el valor C=100nF y la frecuencia que queremos eliminar 50Hz, tenemos que,

1 31,8

2 o

R kF Cπ

= = Ω

3.2.5 Desplazador de nivel.

Lo que se busca con esta etapa es pasar la señal AC de su forma bipolar a unipolar, desplazando las tensiones negativas a regiones positivas para que el micro pueda trabajar con ellas, así que, ponemos en serie un sumador inversor seguido de un amplificador inversor y recuperamos la fase original.

Figura 3.9 Desplazador de nivel.

1 2

f fout in

R RV Vcc V

R R= +

Donde,

5ccV V= y ( 5 ,5 )inV V V= −

Queremos que cuando aparezca -5V en Vin el valor de salida sea 0V, y por otra banda cuando aparezca 5V en Vin el valor sea de 5V entonces hacemos lo siguiente:

1 2

0 ( 5)f fR RVcc

R R= + −

1 2

5 5f fR RVcc

R R= +

Para Vcc=5V resolvemos el sistema que nos dice lo siguiente:

2 1R R= y


47

2 1

2 2fR RR= =

Para acabar le damos valores a las resistencia teniendo en cuenta las igualdades anteriores. Entonces,

Si 2 1 10R R k= = Ω en consecuencia 5fR k= Ω

3.2.6 Driver RL

El driver RL o right-leg common mode feedback lo utilizamos para cerrar el lazo de realimentación del circuito y así disminuir el ruido de modo común que pueda afectar a la señal. La configuración básica de este tipo de circuito la podemos ver en la figura 3.10 y es la que utilizaremos. El CMRR es sensado mediante las resistencias Ra. Luego se invierte, se amplifica y se devuelve al cuerpo.

Figura 3.10 Right-Leg interface.

Figura 3.11 Medical instrumentation applications and Design, author John G.Webster


48

Si analizamos el circuito anterior tenemos:

0

00

22 0 fcmcm

fa

RV V V VR R R

+ = ⇒ =

0cm l dV R i V= +

Entonces,

1 2l d

cmf a

R iVR R

=+

Resistencia efectiva

1 2l cm

f a d

R VR R i

=+

Nos podemos encontrar con dos posibles casos:

1-Saturación del operacional, entonces aparecería en la salida Vcc (alimentación del operacional). La pierna estaría conectada a través de las resistencias Rf y Ro. Para limitar la corriente de paso a la pierna se busca un valor elevado del orden de Mega Ohmios. Esto repercute en la corriente id que por ende será muy pequeña a la vez que Vcm

2-No saturación, en este caso queremos que Vcm se minimice lo máximo posible. Esto se hace eligiendo Rf>>Ra . Los valores típicos suelen ser como estos:

0 5fR R M= = Ω 100lR k= Ω 25aR k= Ω

Y para estos valores id (típicamente) sería de 0,2uA

Donde, 2491 2

l

f a

RR R

= Ω+ que sería la resistencia de descarga a tierra, para los

valores anteriores. y

249 0.2 50cmV A Vμ μ= ⋅ = , que realmente sería muy pequeña.

Y si queremos utilizar valores normalizados podemos poner:

0 4.7fR R M= = Ω 100lR k= Ω 22aR k= Ω


49

3.2.7 Microcontrolador

El microcontrolador que vamos a utilizar es PIC18f4550 de la casa Microchip. Principalmente se va utilizar este microcontrolador debido a que sus características se ajustan a lo que buscamos. Tiene los canales y resolución adecuada en los módulos A/D, la posibilidad de utilizar el PWM, conexión usb, varios timers, etc. Las características principales del micro son las siguientes: Disponibilidad en encapsulados de 40 y 80 pins, memoria de programa tipo flash de 32kB, memoria SRAM de 2048 bytes, memoria EEPROM de 248 bytes, puede operar a 10 MIPs, disponibilidad de hasta 13 entradas A/D, disponibilidad de una pila de 32 niveles para interrupciones internas y externas, comunicación USB, RS232, I2C o SPI, la alimentación puede oscilar entre 2 y 5,5V, etc.

El esquema del micro es el siguiente:

Figura 3.12 Microcontrolador 18f4550


50

3.3 Algoritmos de Control.

3.3.1 Firmware.

3.3.1.1 Función main().

La función principal main() representa el proceso que se ejecuta en el micro. Podemos ver la simplicidad del mismo. Primero inicializamos variables y configuramos módulos (adc, timers…) y luego entramos en un bucle infinito en el que se ejecutaran 2 funciones principales. La primera función es la de escucha o recepción de ordenes que provienen del host, la segunda función principal sería la ejecución de las ordenes y el envío de datos al host. void main(void) ini(); config(); while (TRUE) recibir(); accions();

3.3.1.2 Adquisición mediante ADC.

Para la obtención de los datos vía ADC creamos una función (ecg_128). El canal utilizado es el AN4. La frecuencia de muestreo supera con creces las señales a adquirir, cumplimos con Nyquist . La función es la siguiente: void ecg_128(void) if(flag_ecg) send_128[cnt]=read_ADC(); value=send_128[cnt]; rr_detection(); /*búsqueda del complejo R-R*/ cnt=cnt+1; if(cnt==127) send_128[cnt]=ppm; /*pulsaciones por minuto*/ cnt=128;


51

if(cnt==128) /*¿paquete listo?*/ cnt=0; flag_paquete_listo=1; endpoint=1; flag_ecg=0; if(flag_paquete_listo) /*envio del paquete via usb*/ if(usb_enumerated()) usb_put_packet(endpoint,send_128,128,USB_DTS_TOGGLE); flag_paquete_listo=0;

3.3.1.3 Empaquetado de los datos adquiridos.

La función read_ADC() se encarga de captar la muestra. Esa muestra pasa a un array de 128 posiciones que una vez completado dará por finalizado el paquete activando la bandera flag_paquete_listo.

send_128[cnt]=read_ADC(); /*leemos el dato y lo guardamos */ rr_detection(); /*en esta funcion buscamos el complejo R*/ /*para dectectar las pulsaciones*/ cnt=cnt+1; if(cnt==127) send_128[cnt]=ppm; /*ppm = pulsaciones por minuto*/ cnt=128; if(cnt==128) /*si paquete listo*/ cnt=0; flag_paquete_listo=1; endpoint=1;

3.3.1.4 Envío de paquetes al host.

La condición necesaria para poder enviar un paquete al host, es tener el paquete listo que se nos notificara mediante la activación de la bandera flag_paquete_listo. Una vez que tenemos el OK, comprobamos mediante usb_enumerated() que el host nos ha enumerado y si es así, mediante la función usb_put_packet() enviamos la trama con los datos.

if(flag_paquete_listo) /*envio del paquete via usb*/ if(usb_enumerated())


52

usb_put_packet(endpoint,send_128,128,USB_DTS_TOGGLE); flag_paquete_listo=0;

3.3.1.5 Recepción de paquetes provenientes del host.

Esta función siempre esta a la escucha mediante polling, es decir, durante la ejecución todo el proceso testea el endpoint (en este caso el 1) para saber si ha dejado algo en el buffer, si se cumple la condición recoge los datos y comprueba las ordenes. Dependiendo de lo que llegue ejecutará una cosa u otra.

void recibir() if (usb_kbhit(1)) if(usb_get_packet(1, entrada, 64)) /*... aquí hay mas código, no relevante para el ECG*/ if(entrada[3]==8) /*ECG 128 activo*/ channel=1; cnt=0; /*... aquí hay mas código, no relevante para el ECG*/

3.3.1.6 Detección del complejo RR

Un electrocardiograma se compone del complejo P-QRS-T. El punto R, es el punto mas elevado de dicho complejo. Si queremos determinar el número de veces que se repite en un minuto para así poder deducir las ppm (pulsaciones por minuto), debemos hacer un algoritmo que sea capaz de detectar el punto R. Proponemos el siguiente: void rr_detection(void) if(flag_ecg_ventana==1) /*cada 200ms entramos e incrementamos nn hasta llegar a 30*/ nn=nn+1; aux=0; flag_ecg_ventana=0;


53

if(nn==30) for(i=0;i<30;i++)aux_4[i]=aux_2[i]; /*copiamos todo el*/ /*contenido*/ chi=1; K=0; while(chi) /*buscamos y guardamos los 4 valores*/ /*mas altos de las 30 ventanas de 200ms (6 segundos)*/ aux=0; /*los valores que obtenemos los dejamos en el array*/ /*aux_3[]*/ for(i=0;i<30;i++) if(aux_2[i]>aux) aux=aux_2[i]; ic=i; if(i==29)aux_3[k]=aux;k=k+1;aux_2[ic]=0; if(k==4)chi=0; /*cuando ya tenemos los 4 números mas altos nos quedamos con el /*mas pequeño de esos cuatro*/ /*y lo utilizamos para aplicar el umbral en la detección del /*complejo QRS*/ umbral=aux_3[3]; cuenta_r=0; /*volvemos a cojer los 30 valores de las ventanas de 200ms*/ /*y les aplicamos el umbral. Si superan el umbral */ /*los identificaremos como complejo R. Luego contamos cuantos*/ /*hay en 6 segundos y multiplicamos por 10 /*de esa forma tendremos las ppm*/ for(i=0;i<30;i++) if(aux_4[i]>=umbral) cuenta_r=cuenta_r+1; ppm=cuenta_r*10; cuenta_r=0; nn=0; aux=0; if(value>aux) /*valor actual es mas grande que el anterior?¿*/ aux=value; /*actualizamos el punto mas alto*/ aux_2[nn]=aux;


54

3.3.2 Software.

3.3.2.1 Función main.

Como vemos en el código, este proceso hace lo siguiente: Inicializar, conectar con el dispositivo vía usb y después entrar en un bucle infinito (video.Menu()) del que no sale hasta que el usuario lo decide. Dentro de este bucle infinito se representaran las señales y datos que recibamos del instrumento.

int _tmain(int argc, _TCHAR* argv[]) video.Inicializacion(); video.Mascara(); usb.inicializacion(); video.CargarImagen(40,520, "Panel_texto.jpg", 40); if(usb.DeviceConectado()) video.mensaje(48,550, msn_1,13,2); else video.mensaje(48,550, msn_2,13,3); video.AbrirVentana(); video.Menu(); video.CerrarVentana(); return 0;

3.3.2.2 Comunicación usb.

Para la comunicación usb hemos utilizado la librería mpusbapi.h que nos permite la comunicación con el microcontrolador. Para utilizar las funciones que nos proporciona esta librería, hemos creado una serie de funciones de entre las cuales se encuentran las siguientes:

void inicializacion();

/*llama a la función LoadMUSBDLL() y nos dice si el dispositivo esta conectado*/

void LoadMPUSBDLL(); /*Carga la librería MPUSBDLL*/

void OpenPipes(); /*Abre un “tubo,pipe” el que le digamos para comunicarnos*/

void ClosePipes(); /*Cierra el “tubo,pipe” que hemos estado utilizando*/


55

int DeviceConectado(); /*Función que testea si el dispositivo esta conectado*/

void SendPacket(BYTE *SendData, DWORD SendLength); /*Función que testea si el dispositivo esta conectado*/ void ReceivePacket_ecg(BYTE *ReceiveData, DWORD *ReceiveLength); /*Función que testea si hay datos provenientes del usb, en este caso datos concernientes a la señal ECG*/ void ReceivePacket_acel(BYTE *ReceiveData, DWORD *ReceiveLength); /*Función que testea si hay datos provenientes del usb, en este caso datos concernientes a la señal de aceleración*/ void ReceivePacket_ten(BYTE *ReceiveData, DWORD *ReceiveLength); /*Función que testea si hay datos provenientes del usb, en este caso datos concernientes a la señal de presión*/ int recibir_ecg(); /*Función que llama ReceivePacket y guarda los datos recibidos en un

Array. En este caso guarda datos del ECG*/ int recibir_acel(); /*Función que llama ReceivePacket y guarda los datos recibidos en un

Array. En este caso guarda datos del acelerómetro*/ int recibir_ten(); /*Función que llama ReceivePacket y guarda los datos recibidos en un

Array. En este caso guarda datos del tensiómetro*/ void cmd(BYTE x, int j); /*Función que llama a sendPacket*/

3.3.2.3 Graficación de señales.

Para la representación de los datos, graficas y “form” de nuestro proceso hemos utilizado la librería SDL.h que es OpenSource y de la cual existe multitud de documentación ya que es muy utiliza para el diseño de juegos. Las principales funciones que hemos creado para el graficado son las siguientes: int Inicializacion(); /*En esta función inicializamos y declaramos principalmente la resolución de la pantalla y el timer que vamos a utilizar para escribir en ella, entre otras*/ int IniVariables(); /*Inicializacion de variables o funciones*/ int Pantalla(); /*Llama a la función Recibirdatos(), grafica las señales y actualiza los cambios en la pantalla*/ int mensaje(int x,int y, char mensaje[200],int size, int colorMsn); /*Función que presenta por pantalla un string junto con los Parametros, tamaño o size, posición y color*/ int Liberar_Superficies(); /*Función que sirve para liberar superficies cargadas en memoria*/ int PrintlowSeñal(int dato,int top, int down,int right,int left); /*Función que presenta la señal ECG en un rectángulo. Los parametros permiten redimensionar la presentación de la gráfica*/ void Mascara();


56

/*Función que dibuja la forma o “chasis” del programa*/ void Mascara_Reset(); /*Función que redibuja la forma o “chasis” del programa*/ void CargarImagen(int x, int y, char file[60], int intensidad); /*Función que presenta una imagen en pantalla. Sus parametros son: posición e intensidad*/ void Borrar_Screen(int x, int y, int w, int h); /*Función que borra mediante un rectangulo la porción de pantalla que le pasamos*/ void CerrarVentana(); /*Función que emula el redimensionado de mayor a menor de una ventana*/ void AbrirVentana(); /*Función que emula el redimensionado de menor a mayor de una ventana*/ void PrintSeñal(); /*Función que grafica las señales a presentar*/ void Fondo(); /*Función que carga el fondo de nuestro proceso*/ void Help(); /*Función que presenta varias imágenes con contenido informativo*/

3.3.2.4 Control por teclado.

El control del proceso se realiza por teclado. Las librerías SDL.h disponen de funciones tanto para dibujar en la pantalla como la de escucha de eventos provenientes del teclado o ratón (también nos permite utilizar la tarjeta de sonido, aunque no la utilizaremos). Nosotros aprovechamos estas cualidades de escucha de eventos para controlar los estados de nuestro proceso. Las funciones mas características son las siguientes:

void Eventos_Teclado(void); /*Función que agrupa y llama a las funciones Teclado_fn(), Teclado_numeros, Teclado_letras() y Teclado_especiales()*/ void Teclado_fn(void); /*Función que escucha si se oprimen las teclas función y a partir de aquí llama a diferentes funciones*/ void Teclado_numeros(void); /*Función que escucha si se oprimen las teclas números y a partir de aquí llama a diferentes funciones*/ void Teclado_letras(void); /*Función que escucha si se oprimen las teclas letras y a partir de aquí llama a diferentes funciones*/ void Teclado_especiales(void); /*Función que escucha si se oprimen las teclas especiales y a partir de aquí llama a diferentes funciones*/


57

3.4 Presupuesto.

3.4.1 Coste de recursos hardware.

El hardware de desarrollo del sistema consta de un ordenador portátil de las siguientes características:

• Procesador Intel(R) Pentium(R) M a 2GHz. • Memoria RAM de 1GB a 798MHz. • Disco duro de 80GB.

Además del PC, se ha hecho uso de un voltímetro digital, el programador in-Circuit Debugger ICD2, una fuente de tensión, un osciloscopio Tektronic y una estación soldadora.

Para calcular el importe proporcional al uso dado, teniendo en cuenta el periodo de amortización de los recursos hardware utilizado, se establece un periodo medio de amortización de 6 meses para cada uno de los elementos. Por otra banda se fija un periodo de amortización total de 60 meses. Con lo que:


PC Pentium(R) M 2GHZ 1500 € 25 € 6 150,00 €

Programador Debugger ICD2 300 € 5 € 6 30,00 €

Estación de soldar 150 € 2,5 € 6 15,00 €

Multímetro digital 30 € 0,05 € 6 0,30 €

Osciloscopio Tektronic 300 € 5 € 6 30,00 €

Fuente de tensión 100 € 1,6 € 6 10,00 €

TOTAL 235,30 €

Tabla 3.1 Coste recursos hardware.

3.4.2 Coste de recursos Software.

El software utilizado en el desarrollo del proyecto consta de:

• Sistema operativo: Microsoft Windows XP Pro SP3. • Software desarrollo software: Visual C++ 2008 Express Edition. • Software desarrollo software: Matlab R2009b. • Software desarrollo firmware: Mplab IDE v8.10. • Software desarrollo firmware: PCWH 3.235 de CCS. • Software diseño circuitos: Eagle Professional 4.16. • Software simulación de circuitos: Proteus 7 Professional.


58

• Software simulación/diseño de circuitos: FilterPro.

Para calcular el importe proporcional de los componentes software, también se establece un periodo de amortización de 60 meses.

El software que le acompañe el símbolo (*) no lo contabilizamos ya que son versiones para estudiantes o son trials versions, suficientes para realizar el proyecto.


Microsoft Windows XP Professional SP2 100 € 1,66 € 6 10,00 €

Visual C++ 2008 Express Edition (*) 0 € 0 6 0,00 €

Matlab R2009b (*) 0 € 0 6 0,00 €

Mplab IDE v8.10 (*) 0 € 0 6 0,00 €

PCWH 3.235 de CCS (*) 0 € 0 6 0,00 €

Eagle Professional 4.16 (*) 0 € 0 6 0,00 €

Compilador PCWH 3.235 (*) 0 € 0 6 0,00 €

FilterPro (*) 0 € 0 6 0,00 €

TOTAL 10,00 €

Tabla 3.2 Coste recursos software.

3.4.3 Coste de los componentes.

A continuación se detalla el precio, en euros, y la cantidad de cada componente utilizado:


TOTAL

Resistencia 0,25W 6k6Ω 0,04 1 0,04 €

Resistencia 0,25W 22kΩ 0,10 2 0,20 €

Resistencia 0,25W 330kΩ 0,15 2 0,30 €

Resistencia 0,25W 1k6Ω 0,04 2 0,08 €

Resistencia 0,25W 31k8Ω 0,10 2 0,20 €


59

Resistencia 0,25W 16kΩ 0,04 2 0,08 €

Resistencia 0,25W 10kΩ 0,04 4 0,16 €

Resistencia 0,25W 5kΩ 0,04 1 0,04 €

Resistencia 0,25W 4M7Ω 0,25 2 0,50 €

Resistencia 0,25W 100kΩ 0,15 1 0,15 €






TOTAL

CI AD620A 5,50 1 5 ,50 €

CI TL084A 1,50 3 4,50 €

Terminal roscado 1,00 6 6,00 €

Placa de prototipos 2,85 1 2,85 €


TOTAL

ELECTRODOS 0 3 0,00 €

CABLE ELECTRODS 0 3 0,00 €

TOTAL 21,92 €

Tabla 3.3 Coste componentes electrónicos.

3.4.4 Coste de recursos humanos.

Las tareas realizadas son el análisis de requisitos, diseño, implementación y experimentación.

A continuación se muestra el tiempo dedicado a cada una de las tareas y el importe resultante aplicando un precio de 40€/hora:


60

CONCEPTO UDS. IMPORTE

Análisis de requisitos 45 1.800,00 €

Diseño 100 4.000,00 €

Implementación 90 3.600,00 €

Experimentación 50 2.000,00 €

TOTAL 11.400,00 €

Tabla 3.4 Coste de recursos humanos.

3.4.5 Coste total del proyecto.


CONCEPTO IMPORTE



Componentes 21,92 €

Recursos Humanos 11.400,00 €

TOTAL 11.667,22 €


El coste total del proyecto asciende a ONCE MIL SEISCIENTOS SESENTA Y SIETE euros con VEINTIDOS céntimos.


61

3.5 Bibliografia y webgrafia.

1. Consulta de la historia de la historia del electrocardiógrafo: http://www.electrocardiograma.org/historia-del-electrocardiografo.html, 2011

2. ECG guía Práctica de interpretación, Dr. Antonio Fuertes García, 2011

3. 3-Lead Wireless, Anwar Vahed, 2005

4. Desarrollo de un Holter digital con grabación de eventos y software de

visualización, Leonardo E.Villa Rodriguez, 2009 5. Análisis de esquemas de filtrado análogo para señales ECG, Leydy Laura Älvarez

E., 2007

6. Sistema portátil de electrocardiografía de tres derivaciones con comunicación wiress, Mohamed Essaban, 2006

7. Biomedical instrumentation, R. Yagiz Mungan, 2011

8. ECG guía Práctica de interpretación, Dr. Antonio Fuertes García, 2011

9. Experimentos avanzados de física, electrocardiograma, E. Testé, 2011

10. Desarrollo y evaluación de diferentes métodos de detección de apnea a partir de

la señal electrocardiográfica (ECG), Vladimir Manzanera Navarro, 2009

11. Portable ECG logger, Jessica Lambourn, 2003

12. Obtención de micro potenciales cardíacos latido a latido por vía superficial, Mireya Fernández Chimeneo, 1996

13. Monitor de electrocardiografía a través de una computador personal, M.Sc.

Miguel Yapur, 2005


62

4 Presupuesto.

4.1 Presupuesto total.


CONCEPTO IMPORTE



Componentes esfigmomanómetro 94,55 €

Componentes electrocardiógrafo 21,92 €

Recursos Humanos esfigmomanómetro 13.600,00 €

Recursos Humanos electrocardiógrafo 11.400,00 €

TOTAL 25.607,07 €


El coste total del proyecto asciende a VEINTICINCO MIL SEISCIENTOS SIETE euros con SIETE céntimos.


1

5 Anexos.

5.1 Código, firmware

Rutina que ejecuta el microcontrolador 18f4550.

/*******************************************************************************/ /*************Declaracion de definiciones y librerias***************************/ /*******************************************************************************/ #include <18F4550.h> #device adc=8 #fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN #use delay(clock=48000000) #define USB_HID_DEVICE FALSE #define USB_CDC_DEVICE FALSE #define USB_USE_FULL_SPEED TRUE #define USB_EP1_TX_ENABLE USB_ENABLE_BULK #define USB_EP1_RX_ENABLE USB_ENABLE_BULK #define USB_EP2_TX_ENABLE USB_ENABLE_BULK #define USB_EP3_TX_ENABLE USB_ENABLE_BULK #define USB_EP1_TX_SIZE 128 #define USB_EP1_RX_SIZE 64 #define USB_EP2_TX_SIZE 128 #define USB_EP3_TX_SIZE 64 #define LEDR PIN_D1 #define LEDV PIN_D0 #define LEDR2 PIN_D4 #define LED_ON output_high #define LED_OFF output_low #define on 1 #define off 0 #include <pic18_usb.h> #include <PicUSB.h> #include <usb.c> #include <stdlib.h> /*******************************************************************************/ /*************Declaracion de Variables******************************************/ /*******************************************************************************/ int8 send[64]; int8 send_low[64]; int8 send_test[64]; int8 send_ten[128]; int8 send_128[128]; int8 send_256[256]; int8 send_200[200]; int8 flag_umbral; int8 chi; int8 k; int8 v; int8 ic; int8 cuenta_r; int8 ppm; int8 aux_2[64]; int8 aux_3[64]; int8 aux_4[64]; int8 flag_paquete_listo; int8 c,cc,n,nn,i; int8 entrada[64]; int8 channel,cc_aux; int8 endpoint; int16 valor; int16 cnt; int16 cnt_T1; int16 cnt_T2; int16 cnt_T3; int16 cnt_ten; int16 cnt_T4; int16 cnt_T5; int16 cnt_low; int16 duty; int16 xx=10;


2

int8 flag_acel; int8 flag_ecg; int8 flag_ecg_ventana; int8 flag_ventana; int8 flag_ecg_cnt; int8 flag_led_1_on; int8 flag_led_1_off; int8 flag_led_2_on; int8 flag_led_2_off; int8 flag_led_3_on; int8 flag_led_3_off; int8 flag_motor_on; int8 flag_motor_off; int8 flag_valvula_on; int8 flag_valvula_off; int8 flag_motor_set; int8 flag_eje_x; int8 flag_eje_y; int8 flag_eje_z; int8 flag_dc; int8 flag_ac; int8 banderas; int8 flag_inf_auto; int8 flag_des_auto; int8 flag_ecg_ten_acel; int8 flag_paquete_listo_low; int8 flag_ecg_low; int8 flag_test; int8 flag_test_aux; int8 flag_reset_usb=1; int8 cnt_errores=0; long value; long aux; float media; float umbral; float umbral_acel; float umbral_acel_1; float umbral_acel_2; char cmedia[5]; /*******************************************************************************/ /*************Declaracion de Funciones******************************************/ /*******************************************************************************/ void recibir(void); void accions(void); void banderas(int banderas); void ecg(void); void acelerometro(void); void tensiometro(void); void bomba(int activar_M); void valvula(int activar_V); void estado_1(void); void estado_2(void); void estado_3(void); void rr_detection(void); void obt_umbral(void); void flt_umbral_beta(void); void ten_acel(void); void ecg_ten_acel(void); void ecg_low(void); void ini(void); void config(void); void ecg_128(void); /*******************************************************************************/ /*************Rutinas de atencion a la interrupcion*****************************/ /*******************************************************************************/ #int_timer1 void timer1_isr(void) /*el timer_1 se desborda cada 1 ms*/ /*contador para leds*/ cnt_T1++; if(cnt_T1==500)flag_led_1_on=1; if(cnt_T1==1000)flag_led_1_off=1;cnt_T1=0; /*contador frecuencia de muestreo del ecg*/ cnt_T3++; if(cnt_T3==3)cnt_T3=0;flag_ecg=1; /*contador frecuencia de muestreo del ecg_low*/ cnt_T5++; if(cnt_T5==3)cnt_T5=0;flag_ecg_low=1; /*contador frecuencia de muestreo del ten_acel*/ cnt_T4++;


3

if(cnt_T4==5)cnt_T4=0;flag_ecg_ten_acel=1; /*contador para deteccion de picos del ecg*/ if(flag_ecg_cnt==1) cnt_T2++; if(cnt_T2==200) flag_ecg_ventana=1; cnt_T2=0; /*Volvemos a cargar el Timer1 para que desborde*/ set_timer1(64036); /*******************************************************************************/ /*************Funcion Main******************************************************/ /*******************************************************************************/ void main(void) ini(); config(); while (TRUE) recibir(); accions(); /*******************************************************************************/ /*************Funciones de inicialización y configuración***********************/ /*******************************************************************************/ void ini(void) valor=0; cnt=0; n=0; nn=0; v=0; cnt_T1=0; cnt_T2=0; cnt_T3=0; cnt_T4=0; cnt_T5=0; endpoint=1; flag_ecg_cnt=0; flag_umbral=0; flag_paquete_listo=0; flag_paquete_listo_low=0; flag_ecg_low=0; flag_led_1_on=0; flag_led_1_off=0; flag_led_2_on=0; flag_led_2_off=0; flag_led_3_on=0; flag_led_3_off=0; flag_motor_on=0; flag_motor_off=0; flag_valvula_on=0; flag_valvula_off=0; flag_motor_set=0; duty=0; flag_ac=0; flag_dc=0; flag_eje_x=0; flag_eje_y=0; flag_eje_z=0; flag_acel=0; flag_ecg_ten_acel=0; cnt_ten=0; cnt_low=0;


4

flag_test=0; flag_test_aux=0; channel=101; void config(void) LED_ON(LEDR2); // Programa activoVisualización mediante leds delay_ms(500); LED_ON(LEDR); delay_ms(500); LED_ON(LEDV); Setup_ccp1(ccp_pwm); // Configuracion del PWM Setup_ccp2(ccp_pwm); output_low(PIN_D2); setup_timer_2(T2_DIV_BY_16, 255, 1); // Configuracion del Timer2 para el PWM Set_pwm1_duty(valor); Set_pwm2_duty(valor); Setup_ADC_Ports(ALL_ANALOG|VSS_VDD); // Todas las Salidas Analogicas activas, tension de // referencia alimentacion Setup_ADC(ADC_CLOCK_DIV_32); // 48000000/32 -> Freq. adq. setup_timer_1(T1_INTERNAL | T1_DIV_BY_8); // Base de tiempo cada 1 ms set_timer1(64036); // 1ms=(4/48000000)*8*(65536-X) => X=64036 // Resolucion=(4/48000000)*8 enable_interrupts(INT_TIMER1); // Activamos el servicio de la interrupcion del Timer1 enable_interrupts(global); output_high(PIN_D2); usb_init(); // Inicializamos la comunicación usb usb_task(); usb_wait_for_enumeration(); delay_ms(500); LED_OFF(LEDR2); delay_ms(500); LED_OFF(LEDR); delay_ms(500); LED_OFF(LEDV); void recibir(void) if (usb_kbhit(1)) /*el parámetro 1 hace referencia al endpoint 1*/ if(usb_get_packet(1, entrada, 64)) /*1, es el endpoint, entrada el vector y 64 el tamaño*/ if(entrada[25]==3) /*tensiómetor acelerómetro activo*/ channel=8; cnt=0; if(entrada[25]==9) /*calibrar el acel*/ channel=9; if(entrada[0]==8) /*acelerómetro activo*/ channel=7; cnt=0; if(entrada[3]==8) /*ECG 128 activo*/ channel=1; cnt=0; if(entrada[0]==2) /*tensiómetro activo*/ channel=2; cnt=0; if(entrada[0]==3) /*ECG 64 activo*/ channel=3; cnt=0; if(entrada[11]==9) /*bomba on*/ flag_motor_on=1;


5

if(entrada[11]==2) /*bomba off*/ flag_motor_off=1; if(entrada[1]==3) /*válvula on*/ flag_valvula_on=1; if(entrada[1]==4) /*válvula off*/ flag_valvula_off=1; if(entrada[2]==1) /*led1 on*/ flag_led_1_on=1; if(entrada[2]==2) /*led1 off*/ flag_led_1_off=1; if(entrada[2]==3) /*led2 on*/ flag_led_2_on=1; if(entrada[2]==4) /*led2 off*/ flag_led_2_off=1; if(entrada[2]==5) /*led3 on*/ flag_led_3_on=1; if(entrada[2]==6) /*led3 off*/ flag_led_3_off=1; if(entrada[4]==1) /*bomba on, válvula on*/ estado_1(); if(entrada[4]==2) /*bomba off, válvula on*/ estado_2(); if(entrada[4]==3) /*válvula off, abierta*/ estado_3(); void accions(void) if(channel==1) /*ECG 128 bytes por trama*/ Set_ADC_Channel(4); banderas(1); ecg_128(); flag_ecg_cnt=1; if(channel==2) /*tensiómetro 64 bytes por trama sin acelerometro*/ banderas(2); flag_ecg_cnt=0; tensiometro(); if(channel==3) /*ECG 64 bytes por trama*/ Set_ADC_Channel(4); banderas(1); ecg(); flag_ecg_cnt=1; if(channel==7) /*acelerómetro */ banderas(3); flag_ecg_cnt=0; acelerometro(); if(channel==8) /*tensiómetro, acelerómetro y ECG*/ banderas(4);


6

flag_ecg_cnt=0; ten_acel(); ecg_low(); if(channel==9) /*umbral acelerómetro*/ obt_umbral(); if(flag_led_1_on) /*activación y desactivación de los Leds*/ LED_ON(LEDV); flag_led_1_on=0; if(flag_led_1_off) LED_OFF(LEDV); flag_led_1_off=0; if(flag_led_2_on) LED_ON(LEDR); flag_led_2_on=0; if(flag_led_2_off) LED_OFF(LEDR); flag_led_2_off=0; if(flag_led_3_on) LED_ON(LEDR2); flag_led_3_on=0; if(flag_led_3_off) LED_OFF(LEDR2); flag_led_3_off=0; if(flag_motor_on) /*activación y desactivación de la bomba y la válvula*/ bomba(on); flag_motor_on=0; flag_motor_off=0; flag_valvula_on=0; flag_valvula_off=0; if(flag_motor_off) bomba(off); flag_motor_on=0; flag_motor_off=0; flag_valvula_on=0; flag_valvula_off=0; if(flag_valvula_on) valvula(on); flag_motor_on=0; flag_motor_off=0; flag_valvula_on=0; flag_valvula_off=0; if(flag_valvula_off) valvula(off); flag_motor_on=0; flag_motor_off=0; flag_valvula_on=0; flag_valvula_off=0; /*******************************************************************************/ /*************Funciones Varias**************************************************/ /*******************************************************************************/ void banderas(int banderas) if(banderas==1) flag_ac=0; flag_dc=0; flag_eje_x=0;


7

flag_eje_y=0; flag_eje_z=0; flag_acel=0; if(banderas==2) flag_ac=1; flag_dc=1; flag_eje_x=0; flag_eje_y=0; flag_eje_z=0; flag_acel=0; if(banderas==3) flag_ac=0; flag_dc=0; flag_eje_x=1; flag_eje_y=1; flag_eje_z=1; flag_acel=0; if(banderas==4) flag_ac=1; flag_dc=1; flag_eje_x=0; flag_eje_y=0; flag_eje_z=0; flag_acel=1; /*******************************************************************************/ /*************Funcion para el acelerómetro**************************************/ /*******************************************************************************/ void acelerometro(void) /*Funcion: Acelerometro. ADC canales: AN5,AN6,AN7. Retardo entre lecturas: 2700us Envio de Datos: tramas de 64 bytes Endpoint Salida: 2*/ if((flag_eje_x)&(flag_paquete_listo==0)) Set_ADC_Channel(5); delay_us(900); c=read_ADC(); send[cnt]=c; cnt=cnt+1; if(cnt==63) cnt=0; send[63]=101, flag_paquete_listo=1; endpoint=3; if((flag_eje_y)&(flag_paquete_listo==0)) Set_ADC_Channel(6); delay_us(900); c=read_ADC(); send[cnt]=c; cnt=cnt+1; if(cnt==63) cnt=0; send[63]=101, flag_paquete_listo=1; endpoint=3; if((flag_eje_z)&(flag_paquete_listo==0)) Set_ADC_Channel(7); delay_us(900); c=read_ADC(); send[cnt]=c;


8

cnt=cnt+1; if(cnt==63) cnt=0; send[63]=101; flag_paquete_listo=1; endpoint=3; if((flag_paquete_listo)&(flag_eje_x)&(flag_eje_y)&(flag_eje_z)) if(usb_enumerated()) usb_put_packet(endpoint, send, 64, USB_DTS_TOGGLE); flag_paquete_listo=0; /******************************************* ************************************/ /*************Funciones para el tensiómetro*************************************/ /*******************************************************************************/ void tensiometro(void) /*Funcion: adc_tensiometro. ADC canales: AN0,AN1 Retardo entre lecturas: 5ms Envio de Datos:tramas de 128 bytes Endpoint de salida: 1*/ delay_ms(5); if((flag_dc)&(flag_paquete_listo==0)) Set_ADC_Channel(0); delay_us(5); c=read_ADC(); send_ten[cnt]=c; cnt=cnt+1; if(cnt==128) cnt=0; flag_paquete_listo=1; endpoint=2; if((flag_ac)&(flag_paquete_listo==0)) Set_ADC_Channel(1); delay_us(5); cc=read_ADC(); send_ten[cnt]=cc; cnt=cnt+1; if(cnt==128) cnt=0; flag_paquete_listo=1; endpoint=2; if((flag_paquete_listo)&(flag_dc)&(flag_ac)) if(usb_enumerated()) usb_put_packet(endpoint, send_ten, 128, USB_DTS_TOGGLE); flag_paquete_listo=0; void bomba(int activar_M) /*Función: bomba. Config: PWM_1 Duty: Ton=T-> incremental*/ int16 i; if(activar_M==1) /*Activamos el motor*/ output_high(PIN_D2); for(i=0;i<1024;i++) delay_us(300); Set_pwm1_duty(i);


9

flag_motor_set=1; activar_M=101; if(activar_M==0) /*Desactivamos el motor*/ if(flag_motor_set==1) for(i=1023;i>0;i--) delay_us(300); Set_pwm1_duty(i); output_low(PIN_D2); activar_M=101; flag_motor_set=0; void valvula(int activar_V) /*Función: válvula. Config: PWM_2. Duty: Ton=T -> incremental*/ int16 i; if(activar_V==1) /*activamos la válvula*/ output_high(PIN_D3); for(i=0;i<1024;i++) Set_pwm2_duty(i); activar_V=101; if(activar_V==0) /*desactivamos la válvula*/ output_low(PIN_D3); activar_V=101; void estado_1(void) valvula(on); bomba(on); void estado_2(void) bomba(off); valvula(on); void estado_3(void) valvula(off); /*******************************************************************************/ /*************Funciones para el ecg*********************************************/ /*******************************************************************************/ void ecg(void) if(flag_ecg) send_test[cnt]=read_ADC(); value=send_test[cnt]; rr_detection(); /*búsqueda del complejo R-R*/ cnt=cnt+1; if(cnt==63) /*pulsaciones por minuto*/ send_test[cnt]=ppm; cnt=64; if(cnt==64) /*¿paquete listo?*/ cnt=0; flag_paquete_listo=1; endpoint=3; flag_ecg=0;


10

if(flag_paquete_listo) /*envio del paquete via usb*/ if(usb_enumerated()) usb_put_packet(endpoint,send_test,64,USB_DTS_TOGGLE); flag_paquete_listo=0; void ecg_128(void) if(flag_ecg) send_128[cnt]=read_ADC(); value=send_128[cnt]; rr_detection(); /*búsqueda del complejo R-R*/ cnt=cnt+1; if(cnt==127) send_128[cnt]=ppm; /*pulsaciones por minuto*/ cnt=128; if(cnt==128) /*¿paquete listo?*/ cnt=0; flag_paquete_listo=1; endpoint=1; flag_ecg=0; if(flag_paquete_listo) /*envio del paquete via usb*/ if(usb_enumerated()) usb_put_packet(endpoint,send_128,128,USB_DTS_TOGGLE); flag_paquete_listo=0; void ecg_low(void) if(flag_ecg_low) Set_ADC_Channel(4); send_low[cnt_low]=read_ADC(); cnt_low=cnt_low+1; if(cnt_low==64) /*¿paquete listo?*/ cnt_low=0; flag_paquete_listo_low=1; endpoint=3; flag_ecg_low=0; if(flag_paquete_listo_low) /*envio del paquete via usb*/ if(usb_enumerated()) usb_put_packet(endpoint,send_low,64,USB_DTS_TOGGLE); flag_paquete_listo_low=0; void rr_detection(void)


11

if(flag_ecg_ventana==1) /*cada 200ms entramos e incrementamos nn hasta llegar a 30*/ nn=nn+1; aux=0; flag_ecg_ventana=0; if(nn==30) for(i=0;i<30;i++)aux_4[i]=aux_2[i]; /*copiamos todo el contenido*/ chi=1; K=0; while(chi) /*buscamos y guardamos los 4 valores*/ /*mas altos de las 30 ventanas de 200ms (6 segundos)*/ aux=0; /*los valores que obtenemos los dejamos en el array aux_3[]*/ for(i=0;i<30;i++) if(aux_2[i]>aux) aux=aux_2[i]; ic=i; if(i==29)aux_3[k]=aux;k=k+1;aux_2[ic]=0; if(k==4)chi=0; /*cuando ya tenemos los 4 números mas altos nos quedamos con el mas pequeño de esos cuatro*/ /*y lo utilizamos para aplicar el umbral en la detección del complejo QRS*/ umbral=aux_3[3]; cuenta_r=0; for(i=0;i<30;i++) /*volvemos a cojer los 30 valores de las ventanas de 200ms*/ /*y les aplicamos el umbral. Si superan el umbral */ /*los identificaremos como complejo R. Luego contamos cuantos*/ if(aux_4[i]>=umbral) /*hay en 6 segundos y multiplicamos por 10.*/ /*de esa forma tendremos las ppm*/ cuenta_r=cuenta_r+1; ppm=cuenta_r*10; cuenta_r=0; nn=0; aux=0; if(value>aux) /*valor actual es mas grande que el anterior?¿*/ aux=value; /*actualizamos el punto mas alto*/ aux_2[nn]=aux; /*******************************************************************************/ /*************Funciones para el tensiometro con el acelerometro*****************/ /*******************************************************************************/ void ten_acel(void) /*Funcion: ecg_ten_acel. ADC canales: AN0 AN1 AN5 Retardo entre lecturas: 3ms Envio de Datos:tramas de 128 bytes Endpoint de salida: 2*/ if(flag_ecg_ten_acel==1) /*componente DC*/ if((flag_dc)&(flag_paquete_listo==0)) Set_ADC_Channel(0); /*señal DC*/ delay_us(5); c=read_ADC(); send_ten[cnt]=c; cnt=cnt+1; if(cnt==128) cnt=0; flag_paquete_listo=1; endpoint=2;


12

/*componente AC*/ if((flag_ac)&(flag_paquete_listo==0)) Set_ADC_Channel(1); /*señal AC*/ delay_us(5); cc=read_ADC(); send_ten[cnt]=cc; cnt=cnt+1; if(cnt==128) cnt=0; flag_paquete_listo=1; endpoint=2; /*componente de aceleración*/ if((flag_acel)&(flag_paquete_listo==0)) Set_ADC_Channel(5); delay_us(5); cc_aux=read_ADC(); flt_umbral_beta(); /*evaluamos el umbral*/ flag_ecg_ten_acel=0; if((flag_paquete_listo)&(flag_acel)&(flag_dc)&(flag_ac)) if(usb_enumerated()) usb_put_packet(endpoint, send_ten, 128, USB_DTS_TOGGLE); flag_paquete_listo=0; void obt_umbral(void) float acumulado=0; int16 i; for(i=0;i<1000;i++) delay_ms(1); Set_ADC_Channel(5); delay_us(5); cc=read_ADC(); acumulado=acumulado+cc; acumulado=acumulado/1000; umbral_acel=acumulado; umbral_acel_1=umbral_acel+20; /*sumamos una cota al umbral*/ umbral_acel_2=umbral_acel-20; cnt_errores=0; void flt_umbral_beta(void) /*esta función sirve como filtro y va a absorver las oscilaciones que no*/ /*nos interesan*/ if((cc_aux>umbral_acel_1)|(cc_aux<umbral_acel_2)) cnt=cnt-2; cnt_errores=cnt_errores+1; if(cnt_errores==255)cnt_errores=0;


13

5.2 Código, Software

Proceso que se ejecuta en el PC bajo el sistema operativo Windows XP.

Función principal main(). #include "stdafx.h" #include "windows.h" #include "stdlib.h" #include "string.h" #include "stdio.h" #include "stdlib.h" #include "video.h" #include "conexionUsb.h" #include "utils.h" class conexionUsb usb; class video video; int _tmain(int argc, _TCHAR* argv[]) video.Inicializacion(); video.Mascara(); usb.inicializacion(); video.CargarImagen(40,520, "Panel_texto.jpg", 40); if(usb.DeviceConectado()) video.mensaje(48,550, msn_1,13,2); else video.mensaje(48,550, msn_2,13,3); video.AbrirVentana(); video.Menu(); video.CerrarVentana(); return 0;

Clase conexionUsb.

#include "conexionUsb.h" #include "mpusbapi.h" HMODULE hLib; HINSTANCE libHandle; HANDLE myOutPipe; HANDLE myInPipe; HANDLE myOutPipe2; HANDLE myInPipe2; HANDLE myOutPipe3; HANDLE myInPipe3; HANDLE myOutPipe4; HANDLE myInPipe4; HANDLE sendpaquet; HANDLE recvpaquet; DWORD current_instance=0; DWORD DeviceConnection=1; DWORD RecvLength,RecvLength_ft,RecvLength_st; char in_pipe[] = "\\MCHP_EP1"; char out_pipe[] = "\\MCHP_EP1"; char in_pipeEP2[] = "\\MCHP_EP2"; char out_pipeEP2[] = "\\MCHP_EP2"; char in_pipeEP3[] = "\\MCHP_EP3"; char out_pipeEP3[] = "\\MCHP_EP3"; char in_pipeEP4[] = "\\MCHP_EP4"; char out_pipeEP4[] = "\\MCHP_EP4"; char in_pipeEP5[] = "\\MCHP_EP5"; char out_pipeEP5[] = "\\MCHP_EP5"; char vid_pid[] = "vid_04d8&pid_0011";


14

int flagR=0,flagL=0; int f=0,r=0; int flagEP1=0,flagEP2=0; int full_transfer=0; int flag_dibujo=0; int flag_dibujo_64=0; int flag_dibujo_128=0; int stop_ecg=0; int i; int pflag_dibujo_128=0; int yr1[64]; int yr2[64]; int yr4[64]; int yr5[64]; int yr3[128]; int ii=0; int tt=0; int yr1_ft[128]; int yr1_S[256]; int yr1_256[256]; int yr1_200[200]; int yr1_128[128]; int yr1_64[64]; int contador=0; int j=0; int nnn=0; BYTE send_buf[64]; BYTE receive_buf[64]; BYTE receive_buf_ft[128]; BYTE receive_buf_st[256]; BYTE receive_buf2[64]; BYTE receive_buf_Acel[64]; BYTE receive_buf_ecg_low[64]; BYTE receive_buf_128[128]; BYTE receive_buf_64[64]; BYTE receive_buf_256[256]; BYTE receive_buf_200[200]; BYTE receive_buf_S[256]; void conexionUsb::inicializacion() LoadMPUSBDLL(); //Inicializamos para poder testar si nuestro dispositivo esta conectado MPUSBGetDeviceCount=(DWORD(*)(PCHAR))GetProcAddress(libHandle,"_MPUSBGetDeviceCount"); void conexionUsb::LoadMPUSBDLL() printf("-----> Cargando Libreria: mpusbapi.dll\n\r"); libHandle = NULL; libHandle = LoadLibrary(_T("mpusbapi")); if (libHandle == NULL) printf(" LoadMPUSBDLL - Error Cargando Libreria\n\r"); else MPUSBOpen = (HANDLE(*) (DWORD,PCHAR,PCHAR,DWORD,DWORD)) GetProcAddress(libHandle, "_MPUSBOpen"); MPUSBRead = (DWORD(*) (HANDLE,PVOID,DWORD,PDWORD,DWORD)) GetProcAddress(libHandle, "_MPUSBRead"); MPUSBWrite = (DWORD(*) (HANDLE,PVOID,DWORD,PDWORD,DWORD)) GetProcAddress(libHandle, "_MPUSBWrite"); MPUSBClose = (BOOL(*) (HANDLE)) GetProcAddress(libHandle, "_MPUSBClose"); if ((MPUSBOpen == NULL) || (MPUSBRead == NULL) || (MPUSBWrite == NULL) || (MPUSBClose == NULL)) printf(" LoadMPUSBDLL - GetProcAddress failed\r\n"); void conexionUsb::OpenPipes() DWORD selection = 0; myOutPipe = MPUSBOpen(selection, vid_pid, out_pipe, 0, 0); myInPipe = MPUSBOpen(selection, vid_pid, in_pipe, 1, 0); void conexionUsb::ClosePipes() MPUSBClose(myOutPipe); MPUSBClose(myInPipe); void conexionUsb::CheckInvalidHandle() if (GetLastError() == ERROR_INVALID_HANDLE) MPUSBClose(myOutPipe); MPUSBClose(myInPipe); myOutPipe = myInPipe = INVALID_HANDLE_VALUE;


15

else printf(" CheckInvalidHandle - Error Code %d\n\r",GetLastError()); int conexionUsb::DeviceConectado() int x; if(MPUSBGetDeviceCount(vid_pid)>0) x=1; else x=0; return x; void conexionUsb::cmd(BYTE x, int j) for (i=0; i<64; i++) send_buf[i]=0; send_buf[j]=x; SendPacket(send_buf,64); void conexionUsb::SendPacket(BYTE *SendData, DWORD SendLength) UINT SendDelay = 1000; DWORD SentDataLength; OpenPipes(); MPUSBWrite(myOutPipe, (void*)SendData, SendLength, &SentDataLength, SendDelay); ClosePipes(); int conexionUsb::recibir_ecg() RecvLength_ft=128; ReceivePacket_ecg(receive_buf_ft,&RecvLength_ft); for(i=0;i<128;i++) yr1_ft[i]=receive_buf_ft[i]; receive_buf_ft[i]=0; printf("[dato(%d): %d ]\n", i, yr1_ft[i]); pyr2=&yr1_ft[0]; return 1; int conexionUsb::recibir_acel() RecvLength=64; int j; ReceivePacket_acel(receive_buf_Acel,&RecvLength); for(j=0;j<64;j++) yr4[j]=receive_buf_Acel[j]; receive_buf_Acel[j]=0; printf("[dato(%d): %d ]\n", j, yr4[j]); pyr3=&yr4[0]; return 1; int conexionUsb::recibir_ten() RecvLength=128; int j; ReceivePacket_ten(receive_buf_128,&RecvLength); for(j=0;j<128;j++)


16

yr3[j]=receive_buf_128[j]; receive_buf_128[j]=0; printf("[dato(%d): %d ]\n", j, yr3[j]); pyr5=&yr3[0]; return 1; int conexionUsb::recibir_ecg_low() RecvLength=64; int j; ReceivePacket_ecg_low(receive_buf_Acel,&RecvLength); for(j=0;j<64;j++) yr5[j]=receive_buf_Acel[j]; receive_buf_Acel[j]=0; printf("[#ecg_low(%d): %d ]\n", j, yr5[j]); pyr6=&yr5[0]; return 1; void conexionUsb::ReceivePacket_ecg(BYTE *ReceiveData, DWORD *ReceiveLength) UINT ReceiveDelay=1; DWORD ExpectedReceiveLength = *ReceiveLength; OpenPipes(); //ExpectedReceiveLength=128 MPUSBRead(myInPipe, (void*)ReceiveData, ExpectedReceiveLength, ReceiveLength, ReceiveDelay); ClosePipes(); bandera=0; if(*ReceiveLength==ExpectedReceiveLength)bandera=1; elsebandera=2;//mensaje(48,580,msn4,13,2); void conexionUsb::ReceivePacket_ten(BYTE *ReceiveData, DWORD *ReceiveLength) UINT ReceiveDelay=1; DWORD selection = 0; DWORD ExpectedReceiveLength = *ReceiveLength; myOutPipe2 = MPUSBOpen(selection, vid_pid, out_pipeEP2, 0, 0); myInPipe2 = MPUSBOpen(selection, vid_pid, in_pipeEP2, 1, 0); MPUSBRead(myInPipe2, (void*)ReceiveData, ExpectedReceiveLength, ReceiveLength, ReceiveDelay); MPUSBClose(myOutPipe2); MPUSBClose(myInPipe2); void conexionUsb::ReceivePacket_acel(BYTE *ReceiveData, DWORD *ReceiveLength) UINT ReceiveDelay=1; DWORD selection = 0; DWORD ExpectedReceiveLength = *ReceiveLength; myOutPipe3 = MPUSBOpen(selection, vid_pid, out_pipeEP3, 0, 0); myInPipe3 = MPUSBOpen(selection, vid_pid, in_pipeEP3, 1, 0); MPUSBRead(myInPipe3, (void*)ReceiveData, ExpectedReceiveLength, ReceiveLength, ReceiveDelay); MPUSBClose(myOutPipe3); MPUSBClose(myInPipe3); void conexionUsb::ReceivePacket_ecg_low(BYTE *ReceiveData, DWORD *ReceiveLength) UINT ReceiveDelay=1; DWORD selection = 0; DWORD ExpectedReceiveLength = *ReceiveLength; myOutPipe3 = MPUSBOpen(selection, vid_pid, out_pipeEP3, 0, 0); myInPipe3 = MPUSBOpen(selection, vid_pid, in_pipeEP3, 1, 0); MPUSBRead(myInPipe3, (void*)ReceiveData, ExpectedReceiveLength, ReceiveLength, ReceiveDelay); MPUSBClose(myOutPipe3); MPUSBClose(myInPipe3);


17

Clase video.

#include "video.h" FILE* pfichero; FILE* prec_AN0; FILE* prec_AN2; FILE* copia; FILE* copia_2; FILE* maximos; FILE* maximos_2; FILE* m2; FILE* m2_2; FILE* fecg; FILE* picos_AC_valor; FILE* picos_AC_punto; FILE* picos_DC_valor; FILE* copia_picos_DC_valor; FILE* copia_picos_AC_valor; int flag_1280=0; int flag_msn_acel_2=0; int zoom_y_ecg=1; int count_i=1; int count_ii=1; int count_iii=1; int count_iiii=1; int count_m=0; int count_mm=0; int count_mmm=0; int count_mmmm=0; int flag_m=3; int flag_mm=3; int flag_mmm=3; int flag_mmmm=3; int flag_clock_ocultar=0; int exit_t=0; int in_true=1; int flag_stop=0; int var_nn2=0; int cnt_nn2=0; int flag_fecg=0; int flag_contador=0; int cnt_1=0; int cnt_2=0; int flag_start=0; int O2=0; int O1=0; int O=0; int flag_SO=0; int flag_O=0; int flag_calc_sis=0; int sis=0; int flag_sys_activa=0; int n_n=0,n_v=0; int n_nn=0,n_vv=0; int n_nnn=0,n_vvv=0; int n_nnnn=0,n_vvvv=0; int cnt_3=0; int flag_grabar=0; int rec[65000]; int rec_1[40000]; int rec_2[40000]; int rec_3[40000]; int rec_4[40000]; int nw=0; int flag_ten_Y2_1=0; int flag_ten_Y2_2=0; int flag_ten_Y2_3=0; int var_ten_Y2_1=0; int var_ten_Y2_2=0; int flag_ten_barra=0; int cnt_ten_barra=0; int flag_ten_sis=0; int flag_ten_X2=2; int cnt_ten_X2=0; int flag_40=0; int flag_return=0; int flag_return_end=0; int flag_return_V=0; int flag_num=0; int conta=0; int total=0; int total2=0;


18

int tic=0; int tic_s=0; int tic_m=0; int tic_h=0; int flagText=0; int flagboton=0; int bandera=3; int bandera2=0; int cnt=0; int acelerometro=0; int tensiometro=0; int ecg=0; int flag_F1=0; int flag_F1_R=0; int nnnn=0; int flag_Mascara=0; int flag_help=0; int flag_eventos; int t=0; int flag_5s=0; int flag_calculo_media=0; int flag_ten_vec=0; int var_ten_aux_1=0; int var_ten_aux_2=0; int vec_ten_1[50]; int aux1,aux2; double aux3; int freq; int freq_x; int freqV[7]; int xx_1=43; int xx_2=44; int xx_a; int n_x=1; int n_y=1; int n_z=0; int n_r=0; int ten_X_1=350; int ten_X_2=350; int ten_Y_1=450; int ten_Y_2=450; int flag_fin=0; int flag_fin_2=0; int flag_recepcion=0; int flag_pixelar=0; int flag_presion_muestra=0; int flag_presion=0; int flag_presion_move=0; int flag_presion_move_2=0; int flag_presion_tres=0; int flag_presion_dos=0; int flag_presion_uno=0; int flag_presion_borrar=0; int flag_presion_ready=0; int flag_presion_abort=0; int flag_presion_mensajes=0; int flag_primera_vez=1; int tic_grafica_low=0; int flag_ecg_low=0; int flag_ecg_low_primera_vez=0; int flag_archivo_abierto=0; int flag_archivo_abierto_ecg=0; int flag_f1=0; int flag_help_a=0; int tf=0; int flag_120=0; int tn=0; int ij=0; int y_2,y_1,x_2,x_1=90; int aux_w,aux_h; char msn_error[200]="ERROR"; char msn_move[200]="DON'T MOVE"; char msn_ready[200]=" STARTING "; char msn_abort[200]=" ABORTING "; char msn_try_again[200]=" Try again "; char msn_tres[200]="3"; char msn_dos[200]="2"; char msn_uno[200]="1"; char msn_acel[200]=">: Accelerometer Working "; char msn_freq[200]=">: Work Frequency :"; char msn_ecg[200]=">: Electrocardiogram Working "; char msn_ten[200]=">: Sphigomanometer Working "; char freq_Hz[100]="Hz"; char ijj[10];


19

SDL_Color textColor = 255, 255, 255; SDL_Color colorFondoCaracter = 0, 0, 0; SDL_Color Cverde = 99, 255, 66; SDL_Color Crojo = 255, 0, 0; SDL_Color Camarillo = 255, 255, 0; SDL_Color Cazul = 99, 255, 255; SDL_Color Cblanco = 255, 255, 255; SDL_Color CblancoFojo = 100, 100, 100; SDL_Rect destT; class conexionUsb Cusb; /* TIMER */ Uint32 timer(Uint32 interval, void *maze) tic_grafica_low=tic_grafica_low+1; if(tic_grafica_low==10)tic_grafica_low=0; if(flag_presion_move==1) /*contador que controla el mensaje DONT MOVE*/ if(tn<100)flag_presion_move_2=1; /*don't move on*/ if(tn==100)Cusb.cmd(0x03,1);flag_presion_tres=1; /*valvula on*/ if(tn==150)Cusb.cmd(0x09,25); /*adquisicion de datos por parte del acelerometro*/ if(tn==200)flag_presion_dos=1; if(tn==300)Cusb.cmd(0x03,25);flag_presion_uno=1; /*activamos adquisicion del tensiometro*/ if(tn==350)Cusb.cmd(0x09,11); /*bomba on*/ if(tn==400)flag_presion_ready=1; if(tn==600)tn=0;flag_presion_move=0;flag_presion_borrar=1; tn=tn+1; if(flag_presion==1) /*Mostramos la presion*/ tic=tic+1; if(tic==5)flag_presion_muestra=1; if(tic==10)tic=0;flag_presion_muestra=1; if(flag_5s==1) t=t+1; flag_stop=0; if(t==1000) /* cada 10 segundos reinicia el contador */ t=0; flag_5s=0; flag_stop=1; if(flag_fin==1) tf=tf+1; if(tf==5800) /*cada 58 segundos reinicia el contador*/ tf=0; flag_fin=0; flag_fin_2=1; return 1; /* FUNCIONES MISCELANEA */ void video::GestionEventos() /* GESTION DE MENSAJES */ /* gestion del mensaje DONT MOVE*/ if(flag_presion_mensajes==1) if(flag_presion_move_2==1) mensaje(280,220,msn_move,66,3); flag_presion_move_2=0; if(flag_presion_tres==1)mensaje(480,300,msn_tres,96,2);flag_presion_tres=0;


20

if(flag_presion_dos==1)mensaje(480,300,msn_dos,96,2);flag_presion_dos=0; if(flag_presion_uno==1)mensaje(480,300,msn_uno,96,2);flag_presion_uno=0; if(flag_presion_ready==1) Borrar_Screen(280, 220, 420, 180); mensaje(280,220,msn_ready,66,2); flag_presion_ready=0; if(flag_presion_borrar==1) Borrar_Screen(280, 220, 420, 180); flag_presion_borrar=0; //aqui activamos el dibujo de la grafica tensiometro=1; if(flag_presion_abort==1) Borrar_Screen(280, 220, 420, 180); mensaje(280,220,msn_abort,66,3); flag_presion_abort=0; /* fin gestion del mensaje DONT MOVE*/ if(flag_msn_acel==1) mensaje(48,570,msn_acel,13,5); mensaje(48,590,">: Status :",13,2); flag_msn_acel=0; if(flag_msn_ecg==1) mensaje(48,570,msn_ecg,13,1); mensaje(48,590,">: Status :",13,2); flag_msn_ecg=0; if(flag_msn_ten==1) mensaje(48,570,msn_ten,13,4); mensaje(48,590,">: Status :",13,2); flag_msn_ten=0; if(flag_msn_error==1) mensaje(180,640,msn_error,40,3); flag_msn_error=0; if(flag_msn_recibiendo==1) mensaje(180,640,"WORKING",30,5); flag_msn_recibiendo=0; // FIN DE LA GESTION MENSAJES // GESTION DEL LATIDO DEL CORAZON if(flagText) flag_heartrate=1; flag_sys=1; ContadorCorazon=ContadorCorazon+1; //iniciaclizamos en IniVariables if(ContadorCorazon==1) CargarImagen(1195, 93, "corazon.jpg", 255); if(ContadorCorazon==2) CargarImagen(1195, 93, "corazon2.jpg", 240); ContadorCorazon=0; flagText=0; //FIN DE LA GESTION DEL LATIDO DEL CORAZON //GESTION DEL BOTON DE ENCENDIDO Y APAGADO if(flag_Start) CargarImagen(960, 520, "start-button.jpg", 180); //960,510


21

if(flag_help_a==1)mensaje(180,640," ",30,5); flag_help_a=0; elsemensaje(180,640," PAUSE ",30,5); flag_Start=0; if(flag_Stop) CargarImagen(960, 520, "stop-button.jpg", 180); if(flag_help_a==1)mensaje(180,640," ",30,5); flag_help_a=0; elsemensaje(180,640,"WORKING",30,5); flag_Stop=0; //FIN DE LA GESTION DEL BOTON DE ENCENDIDO Y APAGADO int video::Inicializacion() /*Vamos a inicializar el video y timer*/ if ( SDL_Init(SDL_INIT_AUDIO|SDL_INIT_VIDEO|SDL_INIT_TIMER) < 0 ) fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError()); exit(1); atexit(SDL_Quit); /*Configuración de la pantalla*/ screen = SDL_SetVideoMode(1280, 800, 32, SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_FULLSCREEN ); if ( screen == NULL ) fprintf(stderr, "Imposible Inicializar la pantalla de video: %s\n", SDL_GetError()); flag_1280=1; // en el caso que la pantalla no fuese de 1280x800 /*Gestión de pantallas*/ if(flag_1280==1) flag_1280=0; screen = SDL_SetVideoMode(1024, 768, 32, SDL_HWSURFACE | SDL_DOUBLEBUF |SDL_FULLSCREEN ); if ( screen == NULL ) fprintf(stderr, "Imposible Inicializar la pantalla de video: %s\n", SDL_GetError()); exit(1); /*inicialización de la fuente*/ TTF_Init(); atexit(TTF_Quit); /*inicialización del timer*/ SDL_TimerID mytimer; mytimer = SDL_AddTimer(10, timer, NULL); return 1; int video::IniVariables() xx1=43; xx2=44; yy1=270; yy2=270; acel_X1=350; acel_X2=350; acel_Y1=400; acel_Y2=400; acel_Z1=450; acel_Z2=450; ten_X1=350; ten_X2=350; ten_Y1=450; ten_Y2=450; ii=0; iii=0; v=0; p=0;


22

flag_msn_error=0; flag_msn_recibiendo=0; flag_msn_acel=0; flag_msn_ten=0; flag_msn_ecg=0; flag_grafica_inv=0; flag_recibir_64=0; flag_recibir_128=0; flag_recibir_acel=0; flag_recibir_ten=0; flag_dibujo_64=0; flag_dibujo_128=0; flag_dibujo_acel=0; flag_dibujo=0; flag_dibujo_ten=0; flag_ecg_64=0; flag_ecg_128=0; flag_heartrate=1; flag_sys=1; flag_dia=1; flag_Start=0; flag_Stop=0; flag_F1=0; flag_help=0; flag_clock=1; flag_freq_msn=0; flag_barra_incremento=0; flag_barra_decremento=0; flag_barra=1; flag_eventos=1; nn1=0; nn2=0; nn3=0; nn4=0; ContadorCorazon=0; stopstart=0; fc=0; stop=1; sum=0; Cusb.endpoint_1=0; Cusb.endpoint_2=0; Cusb.endpoint_3=0; Cusb.endpoint_4=0; Cusb.endpoint_5=0; SDL_Color textColor = 255, 255, 255; SDL_Color colorFondoCaracter = 0, 0, 0; font = TTF_OpenFont( "arial.ttf", 120); return 1; void video::Zoom(void) if(tensiometro) if(n_x>40) xxa=xx2; xx1=xx2; xx2=1+xxa; n_x=0; n_x++;


23

if(acelerometro|ecg) if(n_r==0) if(n_y>n_z) xxa=xx2; xx1=xx2; xx2=1+xxa;//normalmente 2 n_y=0; n_y++; if(n_r==1) xxa=xx2; xx1=xx2; xx2=1+xxa; /* TENSIOMETRO */ void video::DiaSys(void) if(flag_sys) font = TTF_OpenFont( "arial.ttf", 120); //120 SDL_Color textColor = 100, 100, 100;//0 200 200 SDL_Color colorFondoCaracter = 0, 0, 0; Borrar_Screen(980, 260, 200, 120); itoa(nn4,sys,10); if (nn4>=10)xx=1046; if (nn4>=100)xx=980; if (nn4<10)xx=1112; SDL_FreeSurface(message); message=TTF_RenderText_Shaded( font, sys, textColor, colorFondoCaracter ); destT.x = xx; destT.y = 260; destT.h = message->h; destT.w = message->w; SDL_BlitSurface(message, NULL, screen, &destT); TTF_CloseFont(font); flag_sys=0; if(flag_dia) font = TTF_OpenFont( "arial.ttf", 120); SDL_Color textColor = 100, 100, 100; SDL_Color colorFondoCaracter = 0, 0, 0; Borrar_Screen(980, 380, 200, 120); itoa(nn3,dia,10); if (nn3>=10)xxx=1046; if (nn3>=100)xxx=980; if (nn3<10)xxx=1112; SDL_FreeSurface(message); message=TTF_RenderText_Shaded( font, dia, textColor, colorFondoCaracter ); destT.x = xxx; destT.y = 380; destT.h = message->h; destT.w = message->w; SDL_BlitSurface(message, NULL, screen, &destT); TTF_CloseFont(font); flag_dia=0; void video::Calc_Sys_Prueba(void) nn2=ten_Y2; /*dato entrante del puerto usb*/ Conversion_Presion(); /*aqui tratamos nn2 y sacamos nn2 pero en mmhg*/ /*en esa funcion meteremos nuestro factor de conversion*/ /*En este trozo de codigo activo flag_heartrate para utilizar el espacio de la frecuencia cardiaca*/ /*y mostrar las presiones*/


24

/*cada 50 ms lo muestro mediante un flag del timer*/ if(flag_presion_muestra==1) flag_heartrate=1; nn1=nn2; flag_presion_muestra=0; /*fin muestra presiones*/ if(flag_grabar==1) /*guardamos todos los datos nn2*/ fprintf(prec_AN2,"%d\n",nn2); /*guardamos todos los datos entrantes en el fichero AN2*/ rec[cnt_3++]=nn2; /*guardamos todos los datos entrantes en el array rec[]*/ if(nn2>=120) /* Cuando llegamos a 120mmHg */ flag_5s=1; /* contamos 10 segundos */ aux2=0; aux1=0; flag_grabar=1; /* empiezo a grabar */ cnt_3=0; /* este contador lo utilizo para el array rec[cnt_3] y lo inicializo aqui*/ flag_fin=1; if(flag_fin_2==1) Cusb.cmd(0x03,4); /* abrimos la valvula para que salga el aire */ flag_grabar=0; /* dejamos de grabar */ Copia(); /* copiamos el contenido de AN2(presiones mmHg) a un vector y tambien a un archivo copia.txt*/ Subida(); Copia_2(); Subida_2(); Picos(); Pam(); Cierre_Ficheros_presion(); flag_presion=0; /* desactivamos el timer que hace que muestre las presiones*/ flag_fin_2=0; if(flag_stop==1)Cusb.cmd(0x02,4);flag_stop=0; /* cuando pasan los 5 segundos paramos el motor */ void video::Copia(void) /* Función que pasa los datos del fichero AN2 a un vector y luego lo copia a otro archivo llamado copia*/ /* los datos que lleva el archivo AN2 son la presiones pasadas a mmHg */ int xi; int xab; int ir; int flaggg=0; int t=0; char joder[6]; fclose(prec_AN2); prec_AN2=fopen("AN2.txt","r"); /* En AN2.txt tenemos los puntos de la componente DC en mmHg */ /* Los copiamos a otro archivo */ while(!feof(prec_AN2)) /* recorremos todo el archivo prec_AN2 y lo pasamos a un array*/ for(ir=0;ir<5;ir++) /* vector de 5 posiciones donde guardaremos el dato a leer*/ joder[ir]=' '; for(ir=0;ir<5;ir++) xab=fgetc(prec_AN2); /* leemos caracter por caracter*/ if(xab!='\n') joder[ir]=(char)xab; if(xab=='\n') /* cuando llegamos al salto de linia salimos del for*/ ir=5; xi=atoi(joder); /* hacemos la conversion de caracter a entero*/ rec_1[t]=xi; /* lo copio todo en un vector par poder trabajar con el mas rapido */ t=t+1; fprintf(copia,"%d\n",xi); /* lo guardamos en un archivo llamado copia*/


25

void video::Copia_2(void) int xi; int xab; char joder[6]; int ir; char caracteres[3]; int flaggg=0; int t=0; fclose(prec_AN0); prec_AN0==fopen("AN0.txt","r"); // En AN0.txt tenemos los puntos de la componente AC // Los copiamos a otro archivo while(!feof(prec_AN0)) for(ir=0;ir<5;ir++) joder[ir]=' '; for(ir=0;ir<5;ir++) xab=fgetc(prec_AN0); if(xab!='\n') joder[ir]=(char)xab; if(xab=='\n') ir=5; xi=atoi(joder); rec_2[t]=xi; t=t+1; fprintf(copia_2,"%d\n",xi); void video::Subida(void) int f[40000]; int a[2]; int k[2]; int fla_g=0; int fla_g2=0; int h=0; int g=0; char osc_2[10]; int in=0; for(in=0;in<40000;in++) f[in]=rec_1[in]; a[0]=f[0]; while(h<40000) h=h+1; if((f[h] > f[h-1])&(fla_g==0)) a[0]=f[h-1]; a[1]=a[0]; fla_g=1; if((fla_g==1)&(f[h]>a[0])) if(f[h]>=a[1]) a[1]=f[h]; k[1]=h; fla_g2=1; if(f[h]<=a[0]) a[0]=f[h]; fla_g=0; if(fla_g2==1)


26

fprintf(maximos,"%d\n",a[1]);/*en este archivo voy a guardar Y*/ fprintf(m2,"%d\n",k[1]); /*en este archivo voy a guardar X*/ fla_g2=0; void video::Subida_2(void) int f[40000]; int a[2]; int k[2]; int fla_g=0; int fla_g2=0; int h=0; int g=0; char osc_2[10]; int in=0; for(in=0;in<40000;in++) f[in]=rec_2[in]; a[0]=f[0]; while(h<40000) h=h+1; if((f[h] > f[h-1])&(fla_g==0)) a[0]=f[h-1]; a[1]=a[0]; fla_g=1; if((fla_g==1)&(f[h]>a[0])) if(f[h]>=a[1]) a[1]=f[h]; k[1]=h; fla_g2=1; if(f[h]<=a[0]) a[0]=f[h]; fla_g=0; if(fla_g2==1) fprintf(maximos_2,"%d\n",a[1]);/*en este archivo voy a guardar Y*/ fprintf(m2_2,"%d\n",k[1]); /*en este archivo voy a guardar X*/ fla_g2=0; void video::Picos(void) /* esta funcion se dedica a buscar el valor mas alto de un vector de x posiciones */ /* a ese valor viene asociada su presion*/ int n=0; int r=0; int aux=0; int aux_2=0; int aux_3=0; picos_AC_valor=fopen("picos_AC_valor.txt","w+"); picos_AC_punto=fopen("picos_AC_punto.txt","w+"); picos_DC_valor=fopen("picos_DC_valor.txt","w+"); aux=rec_2[0]; while(n<40000) r=0; while(r<250) //350 if(rec_2[n]>aux) /* en rec_2[] esta la componente AC */ aux=rec_2[n];


27

aux_2=n; aux_3=rec_1[n]; /* Con rec_1 obtengo el valor de la presion */ n++; r++; fprintf(picos_AC_valor,"%d\n",aux); /* aqui guardamos el pico mas alto de cada 250 posiciones*/ fprintf(picos_AC_punto,"%d\n",aux_2); /* aqui guardamos el indice del vector de ese pico*/ fprintf(picos_DC_valor,"%d\n",aux_3); /* aqui guardamos el valor de la presion en esa posicion*/ aux=0; fclose(picos_AC_valor); fclose(picos_AC_punto); fclose(picos_DC_valor); void video::Pam(void) int aux_1; int aux_2; int xi; int xab; char joder[6]; char xa; int ir; int t=0; int n=0; char osc_2[10]; char osc_3[10]; int aux_D=0; int aux_d; int D[6]; int tt=0; int D_0; int D_1; int D_2; int D_3; int D_4; int D_5; int dia_; int sys_; int media; /*Abrimos archivos *.txt */ copia_picos_DC_valor=fopen("copia_picos_DC_valor.txt","w+"); picos_DC_valor=fopen("picos_DC_valor.txt","r"); copia_picos_AC_valor=fopen("copia_picos_AC_valor.txt","w+"); picos_AC_valor=fopen("picos_AC_valor.txt","r"); while(!feof(picos_AC_valor)) for(ir=0;ir<5;ir++) joder[ir]=' '; for(ir=0;ir<5;ir++) xab=fgetc(picos_AC_valor); if(xab!='\n') joder[ir]=(char)xab; if(xab=='\n') ir=5; xi=atoi(joder); rec_3[t]=xi; t=t+1; fprintf(copia_picos_AC_valor,"%d\n",xi); t=0; while(!feof(picos_DC_valor)) for(ir=0;ir<5;ir++) joder[ir]=' ';


28

for(ir=0;ir<5;ir++) xab=fgetc(picos_DC_valor); if(xab!='\n') joder[ir]=(char)xab; if(xab=='\n') ir=5; xi=atoi(joder); rec_4[t]=xi; t=t+1; fprintf(copia_picos_DC_valor,"%d\n",xi); /*Aqui busco la PAM en la componente AC*/ aux_1=rec_3[0]; while(n<100) /*Algoritmo que me permite saber el numero mas grande de una array*/ /*el array tiene una longitud de 100*/ if(rec_3[n]>aux_1) aux_1=rec_3[n]; aux_2=n; n++; /**Fin Aqui busco la PAM en la componente AC**/ Borrar_Screen(920,247,30,16); itoa(rec_4[aux_2],osc_2,10); if((rec_4[aux_2]<10)&(rec_4[aux_2]>=0))mensaje(948,247,osc_2,16,5); if((rec_4[aux_2]<100)&(rec_4[aux_2]>10))mensaje(940,247,osc_2,16,5); if((rec_4[aux_2]>=100))mensaje(932,247,osc_2,16,5); media=rec_4[aux_2]; /* aqui ya tenemos la presion media o pam*/ D_0=rec_3[aux_2]-rec_3[aux_2+1]; /* aqui buscamos la diferencia mas abrupta */ D_1=rec_3[aux_2+1]-rec_3[aux_2+2]; /* entre 6 valores seguidos despues de la presion media */ D_2=rec_3[aux_2+2]-rec_3[aux_2+3]; /* ya que empiricamente sabemos que la diferencia mas */ D_3=rec_3[aux_2+3]-rec_3[aux_2+4]; /* abrupta entre dos picos cuando ya se ha detectado la pam */ D_4=rec_3[aux_2+4]-rec_3[aux_2+5]; /* suele ser la presion diastolica */ D_5=rec_3[aux_2+5]-rec_3[aux_2+6]; D[0]=D_0; /* aqui guardamos las diferencias para encontrar la mas abrupta*/ D[1]=D_1; D[2]=D_2; D[3]=D_3; D[4]=D_4; D[5]=D_5; aux_D=0; tt=0; while(tt<6) /* buscamos el valor mas grande que se corresponde con la diferencia */ /* mas grande*/ if(D[tt]>=aux_D) aux_D=D[tt]; tt++; if(aux_D==D_0)aux_d=rec_4[aux_2+1]; /* y sabiendo cual es la diferencia mas grande podemos obtener*/ if(aux_D==D_1)aux_d=rec_4[aux_2+2]; /* la diastole de forma estimada*/ if(aux_D==D_2)aux_d=rec_4[aux_2+3]; if(aux_D==D_3)aux_d=rec_4[aux_2+4]; if(aux_D==D_4)aux_d=rec_4[aux_2+5]; if(aux_D==D_5)aux_d=rec_4[aux_2+6]; dia_=aux_d; /* diástole estimada*/ sys_=dia_+(media-dia_)*3; /* sístole estimada */ /*presentacion de las presiones*/ nn4=sys_; nn3=dia_; flag_dibujo_ten=2; tensiometro=0; flag_dia=1; flag_sys=1;


29

/* Fin presentacion de las presiones */ /* cerramos los archivos */ fclose(picos_DC_valor); fclose(copia_picos_DC_valor); fclose(picos_AC_valor); fclose(copia_picos_AC_valor); void video::Conversion_Presion() long nn2_i; double nn2_d; double nn2_r; double aux; if((nn2)<0)nn2=0; nn2_d=(double)nn2; nn2_d=nn2_d*0.01953; // esto lo hacemos para tener Vadc, Xbytes*0,01953v(que es lo que vale el byte) nn2_d=nn2_d/(1850); // lo dividimos por la ganancia nn2_d=nn2_d/(0.0000133); // ahora lo dividimos por el Slope osea, 0,0000133 V/mmhg // Y ya tenemos el valor en milimetros de mercurio nn2_r=nn2_d; nn2_i=(int)nn2_d; nn2=nn2_i; aux=nn2_r-nn2_i; if((aux)>=(0.5))nn2=nn2+1; void video::Cierre_Ficheros_presion(void) fclose(pfichero); fclose(prec_AN0); fclose(prec_AN2); fclose(copia); fclose(copia_2); fclose(maximos); fclose(maximos_2); fclose(m2); fclose(m2_2); /* ECG */ void video::HeartRate(void) if(flag_heartrate) font = TTF_OpenFont( "arial.ttf", 120); SDL_Color textColor = 100, 100, 100; //200,5,5 SDL_Color colorFondoCaracter = 0, 0, 0; Borrar_Screen(980, 80, 200, 120); itoa(nn1,heart,10); if (nn1>=10)x=1046; if (nn1>=100)x=980; if (nn1<10)x=1112; SDL_FreeSurface(message); message=TTF_RenderText_Shaded( font, heart, textColor, colorFondoCaracter ); destT.x = x; destT.y = 80; destT.h = message->h; destT.w = message->w; SDL_BlitSurface(message, NULL, screen, &destT); TTF_CloseFont(font); flag_heartrate=0; /* RECEPCION DE DATOS */ void video::RecibirDatos(void) R_ecg(); R_acel(); R_ten(); R_ecg_low();


30

void video::R_ecg(void) if(flag_ecg_64==1) if(flag_dibujo_128==0) if(flag_recibir_128==1) /*cuando no dibuja recibe datos, polling*/ Cusb.recibir_ecg_low(); flag_dibujo_128=1; p=0; if((flag_dibujo_128==1)) yy2=*((Cusb.pyr6)+(p)); fprintf (fecg, "%d\n",yy2); /*guardamos los datos en un .txt para tratarlos despues*/ if(flag_fecg==1) fprintf(fecg,"%d\n",yy2); if(p==63) nn1=yy2; /*nn1 sirve para mostrar la frecuencia, ppm*/ yy2=*((Cusb.pyr6)+(62)); printf("[pulsaciones por minuto: %d ]\n", nn1); flag_heartrate=1; if((flag_grafica_inv==0)) p++; yy2=300-yy2; if((flag_grafica_inv==1)) p++; yy2=yy2; //yy2+170 if(p==64) p=0; flag_dibujo_128=0; if(flag_ecg_128==1) if(flag_dibujo_128==0) if(flag_recibir_128==1) /*cuando no dibuja recibe datos, polling*/ Cusb.recibir_ecg(); flag_dibujo_128=1; iii=0; if((flag_dibujo_128==1)) yy2=*((Cusb.pyr2)+(iii)); fprintf (fecg, "%d\n",yy2); /*guardamos los datos en un .txt para tratarlos despues*/ if(flag_fecg==1) fprintf(fecg,"%d\n",yy2); if(iii==127) nn1=yy2; /*nn1 sirve para mostrar la frecuencia cardiaco ppm*/ yy2=*((Cusb.pyr2)+(126)); printf("[pulsaciones por minuto: %d ]\n", nn1); flag_heartrate=1;


31

if((flag_grafica_inv==0)) iii++; yy2=300-yy2; if((flag_grafica_inv==1)) iii++; yy2=yy2; //yy2+170 if(iii==128) iii=0; flag_dibujo_128=0; void video::R_ten(void) if(flag_dibujo_ten==0) if(flag_recibir_ten==1) /*cuando no dibuja recibe datos*/ Cusb.recibir_ten(); flag_dibujo_ten=1; iv=0; if(flag_dibujo_ten==1) ten_Y2=*((Cusb.pyr5)+(iv)); /*AN0 del pic, componente DC*/ Calc_Sys_Prueba(); iv++; ten_Y2=nn2; ten_Y2=470-ten_Y2; if(iv==128) iv=0; flag_dibujo_ten=0; if(flag_dibujo_ten==1) ten_X2=*((Cusb.pyr5)+(iv)); /*AN1 del pic, componente AC*/ if(flag_grabar==1) fprintf(prec_AN0,"%d\n",ten_X2); iv++; ten_X2=350-ten_X2; if(iv==128) iv=0; flag_dibujo_ten=0; void video::R_acel(void) if(flag_dibujo_acel==0) if(flag_recibir_acel==1) Cusb.recibir_acel(); flag_dibujo_acel=1; ii=0; if(flag_dibujo_acel==1) acel_X2=*((Cusb.pyr3)+(ii)); ii++; acel_X2=350-acel_X2; //yy2+170 if(ii==63) ii=0;


32

flag_dibujo_acel=0; if(flag_dibujo_acel==1) acel_Y2=*((Cusb.pyr3)+(ii)); ii++; acel_Y2=400-acel_Y2; //yy2+170 if(ii==63) ii=0; flag_dibujo_acel=0; if(flag_dibujo_acel==1) acel_Z2=*((Cusb.pyr3)+(ii)); ii++; acel_Z2=450-acel_Z2; //yy2+170 if(ii==63) ii=0; flag_dibujo_acel=0; /* EVENTOS DE TECLADO */ void video::Eventos_Teclado(void) Teclado_especiales(); Teclado_numeros(); Teclado_letras(); Teclado_fn(); void video::Teclado_numeros(void) if (event.key.keysym.sym == SDLK_1) /*Activamos LED_1*/ Cusb.cmd(0x01,2); if (event.key.keysym.sym == SDLK_2) /*Activamos LED_2*/ Cusb.cmd(0x03,2); if (event.key.keysym.sym == SDLK_3) /*Activamos LED_3*/ Cusb.cmd(0x05,2); void video::Teclado_letras(void) if (event.key.keysym.sym == SDLK_v) /*Activamos la válvula*/ Cusb.cmd(0x03,1); if (event.key.keysym.sym == SDLK_b) /*Activamos la bomba*/ Cusb.cmd(0x09,11); if (event.key.keysym.sym == SDLK_c) /*Desactivamos la válvula*/ Cusb.cmd(0x04,1); if (event.key.keysym.sym == SDLK_n) /*Desactivamos la bomba*/ Cusb.cmd(0x02,11); if (event.key.keysym.sym == SDLK_i) /*Inversión de la gráfica*/ flag_grafica_inv=1; if (event.key.keysym.sym == SDLK_o) /*Inversión de la gráfica*/ flag_grafica_inv=0; if (event.key.keysym.sym == SDLK_q) /*Activamos LED_1*/ Cusb.cmd(0x02,2);


33

if (event.key.keysym.sym == SDLK_w) /*Activamos LED_2*/ Cusb.cmd(0x04,2); if (event.key.keysym.sym == SDLK_e) /*Activamos LED_3*/ Cusb.cmd(0x06,2); void video::Teclado_fn(void) if (event.key.keysym.sym == SDLK_F1) flag_F1=1; flag_f1=1; flag_help=1; acelerometro=0; tensiometro=0; ecg=0; stop=0; flag_eventos=0; stopstart=2; if (event.key.keysym.sym == SDLK_F4) if(flag_help==0) if(flag_archivo_abierto==1) Cierre_Ficheros_presion(); flag_archivo_abierto=0; xx2=898; flag_msn_ecg=1; flag_msn_recibiendo=1; Cusb.cmd(0x08,3); nn1=0; nn2=0; nn3=0; nn4=0; flag_ecg_low_primera_vez=0; /*desabilito ecg_low*/ flag_ecg_low=0; flag_sys=1; /*Tanto flag_sys como flag_dia las activo pq necesito que borren*/ flag_dia=1; /*los datos de la sistole o distole en el caso que se hallan buscado*/ flag_heartrate=1; flag_presion=0; /*flag ten-acel en el timer*/ flag_presion_move=0; /*flag ten-acel en el timer*/ flag_recibir_256=0; flag_dibujo_256=0; flag_recibir_128=1; flag_dibujo_128=0; flag_recibir_64=0; flag_dibujo_64=0; flag_recibir_acel=0; flag_dibujo_acel=0; flag_recibir_ten=0; flag_dibujo_ten=0; flag_ecg_128=1; flag_ecg_64=0; acelerometro=0; tensiometro=0; ecg=1; tn=0; /*contador a 0 para el tensiometro-acelerometro*/ flag_presion_mensajes=0; Borrar_Screen(600, 550,300,200); CargarImagen(980,40, "heartrate2.jpg", 255);


34

Borrar_Screen(1190, 165, 100, 30); CargarImagen(1190,165, "bpm.bmp", 255); CargarImagen(40,40, "Panel_860_460.jpg", 40); if(flag_archivo_abierto_ecg==1) fclose(fecg); flag_archivo_abierto_ecg=0; if(flag_archivo_abierto_ecg==0) fecg=fopen("ecg.txt","w+"); flag_archivo_abierto_ecg=1; if (event.key.keysym.sym == SDLK_F5) if(flag_help==0) if(flag_archivo_abierto==1) Cierre_Ficheros_presion(); flag_archivo_abierto=0; xx2=898; flag_msn_ecg=1; flag_msn_recibiendo=1; Cusb.cmd(0x03,0); nn1=0; nn2=0; nn3=0; nn4=0; flag_ecg_low_primera_vez=0; /*desabilito ecg_low*/ flag_ecg_low=0; flag_sys=1; /*Tanto flag_sys como flag_dia las activo pq necesito que borren*/ flag_dia=1; /*los datos de la sistole o distole en el caso que se hallan buscado*/ flag_heartrate=1; flag_presion=0; /*flag ten-acel en el timer*/ flag_presion_move=0; /*flag ten-acel en el timer*/ flag_recibir_256=0; flag_dibujo_256=0; flag_recibir_128=1; flag_dibujo_128=0; flag_recibir_64=0; flag_dibujo_64=0; flag_recibir_acel=0; flag_dibujo_acel=0; flag_recibir_ten=0; flag_dibujo_ten=0; flag_ecg_128=0; flag_ecg_64=1; acelerometro=0; tensiometro=0; ecg=1; tn=0; /*contador a 0 para el tensiometro-acelerometro*/ flag_presion_mensajes=0; Borrar_Screen(600, 550,300,200); CargarImagen(980,40, "heartrate2.jpg", 255); Borrar_Screen(1190, 165, 100, 30); CargarImagen(1190,165, "bpm.bmp", 255); CargarImagen(40,40, "Panel_860_460.jpg", 40); if(flag_archivo_abierto_ecg==1) fclose(fecg); flag_archivo_abierto_ecg=0; if(flag_archivo_abierto_ecg==0)


35

fecg=fopen("ecg.txt","w+"); flag_archivo_abierto_ecg=1; if (event.key.keysym.sym == SDLK_F6) if(flag_help==0) xx2=898; flag_msn_ten=1; flag_msn_recibiendo=1; nn1=0; nn2=0; nn3=0; nn4=0; flag_ecg_low_primera_vez=1; /*entrada al ecg_low*/ flag_ecg_low=1; flag_sys=1; flag_dia=1; flag_heartrate=1; flag_presion=1; /*flags ten-acel en el timer*/ flag_presion_move=1; /*flags ten-acel en el timer*/ flag_presion_mensajes=1; tn=0; /*contador a 0 para el tensiometro-acelerometro*/ flag_recibir_256=0; flag_dibujo_256=0; flag_recibir_128=0; flag_dibujo_128=0; flag_recibir_64=0; flag_dibujo_64=0; flag_recibir_acel=0; flag_dibujo_acel=0; flag_recibir_ten=1; flag_dibujo_ten=0; flag_ecg_128=0; flag_ecg_64=0; acelerometro=0; tensiometro=0; /*este lo vamos a activar el timer, no aqui*/ ecg=0; if(flag_archivo_abierto==0) pfichero=fopen("pam.txt","a+"); prec_AN0=fopen("AN0.txt","w+"); prec_AN2=fopen("AN2.txt","w+"); copia=fopen("copia.txt","w+"); copia_2=fopen("copia_2.txt","w+"); maximos=fopen("maximos.txt","w+"); maximos_2=fopen("maximos_2.txt","w+"); m2=fopen("m2.txt","w+"); m2_2=fopen("m2_2.txt","w+"); flag_archivo_abierto=1; if(flag_archivo_abierto_ecg==1) fclose(fecg); flag_archivo_abierto_ecg=0; if(flag_archivo_abierto_ecg==0) fecg=fopen("ecg.txt","w+"); flag_archivo_abierto_ecg=1; long r1; for(r1=0;r1<40000;r1++)rec_2[r1]=0;rec_3[r1]=0;rec_4[r1]=0; for(r1=0;r1<65000;r1++)rec[r1]=0; CargarImagen(980,40, "pressure-yellow.jpg", 255); CargarImagen(1190,165, "mmHg.bmp", 255); roundedRectangleRGBA(screen, 600, 550, 878, 650, 8, 255,255,255,50);


36

if (event.key.keysym.sym == SDLK_F7) if(flag_help==0) if(flag_archivo_abierto==1) Cierre_Ficheros_presion(); flag_archivo_abierto=0; if(flag_archivo_abierto_ecg==1) fclose(fecg); flag_archivo_abierto_ecg=0; xx2=898; flag_msn_acel=1; flag_msn_recibiendo=1; Cusb.cmd(0x08,0); nn1=0; nn2=0; nn3=0; nn4=0; flag_ecg_low_primera_vez=0; /*desabilito ecg_low*/ flag_ecg_low=0; flag_sys=1; /*Tanto flag_sys como flag_dia las activo pq necesito que borren*/ flag_dia=1; /*los datos de la sistole o distole en el caso que se hallan buscado*/ flag_heartrate=1; flag_presion=0; /*flag ten-acel en el timer*/ flag_presion_move=0; /*flag ten-acel en el timer*/ flag_presion_mensajes=0; tn=0; /*contador a 0 para el tensiometro-acelerometro*/ flag_recibir_256=0; flag_dibujo_256=0; flag_recibir_128=0; flag_dibujo_128=0; flag_recibir_64=0; flag_dibujo_64=0; flag_recibir_acel=1; flag_dibujo_acel=0; flag_recibir_ten=0; flag_dibujo_ten=0; flag_ecg_128=0; flag_ecg_64=0; acelerometro=1; tensiometro=0; ecg=0; Borrar_Screen(600, 550,300,200); CargarImagen(980,40, "heartrate2.jpg", 255); Borrar_Screen(1190, 165, 100, 30); CargarImagen(1190,165, "bpm.bmp", 255); CargarImagen(40,40, "Panel_860_460.jpg", 40); void video::Teclado_especiales(void) if (event.key.keysym.sym == SDLK_RETURN) Cusb.cmd(0x04,1); /*desactivación de la valvula*/ SDL_Delay(200); Cusb.cmd(0x02,11); /*desactivación de la bomba*/ flag_presion_abort=1;


37

flag_presion=0; /*flag ten-acel en el timer*/ flag_presion_move=0; /*flag ten-acel en el timer*/ tensiometro=0; acelerometro=0; ecg=0; tn=0; if(flag_archivo_abierto==1) Cierre_Ficheros_presion(); flag_archivo_abierto=0; if(flag_archivo_abierto==1) Cierre_Ficheros_presion(); flag_archivo_abierto=0; if(flag_archivo_abierto_ecg==1) fclose(fecg); flag_archivo_abierto_ecg=0; if (event.key.keysym.sym == SDLK_ESCAPE) if(flag_help) stop=1; flag_help=0; flag_help_a=1; flag_recibir_256=0; flag_dibujo_256=0; flag_recibir_128=0; flag_dibujo_128=0; flag_recibir_64=0; flag_dibujo_64=0; flag_recibir_acel=0; flag_dibujo_acel=0; flag_recibir_ten=0; flag_dibujo_ten=0; acelerometro=0; tensiometro=0; ecg=0; flag_F1=0; flag_f1=0; Mascara_Reset(); flag_sys=1; flag_dia=1; flag_heartrate=1; CargarImagen(960, 520, "start-button.jpg", 180); flag_eventos=1; if(stopstart==2) flag_Start=1; flag_Stop=0; stopstart=0; else exit_t=1; if (event.key.keysym.sym == SDLK_SPACE) if(ecg|tensiometro|acelerometro) if(stopstart>=3)stopstart=1; stopstart=stopstart+1; if(stopstart==1) flag_Start=0; flag_Stop=1;


38

stop=0; xx1=43; xx2=46; if(stopstart==2) flag_Start=1; flag_Stop=0; stopstart=0; stop=1; if (event.key.keysym.sym == SDLK_LEFT) if((flag_F1_R==0)&(flag_f1==1)) flag_F1=1; flag_help=1; acelerometro=0; tensiometro=0; ecg=0; stop=0; flag_eventos=0; stopstart=2; if(flag_f1==0) n_z=n_z+1; /*esto nos sirve para el zoom*/ if (event.key.keysym.sym == SDLK_RIGHT) if((flag_F1==1)&(flag_f1==1)) /*con este if deslizo la foto de ayuda a la derecha*/ stop=0; flag_F1_R=1; if(flag_f1==0) n_z=n_z-1; /*esto nos sirve para el zoom*/ if(n_z<=0)n_z=0; /* PRESENTACION DE DATOS */ void video::PrintSeñal(void) if(stop==0) int top=42; int down=500; int right=898; int left=43; if(ten_X2>=500)ten_X2=495; /*señal del tensiometro (2) limites eje Y*/ if(ten_X1>=500)ten_X1=495; if(ten_X2<=42)ten_X2=42; if(ten_X1<=42)ten_X1=42; if(ten_Y2>=500)ten_Y2=495; if(ten_Y1>=500)ten_Y1=495; if(ten_Y2<=42)ten_Y2=42; if(ten_Y1<=42)ten_Y1=42; if(acel_X2>=500)acel_X2=495; /*señal del acelerometro (3)limites eje Y*/ if(acel_X1>=500)acel_X1=495; if(acel_X2<=42)acel_X2=42; if(acel_X1<=42)acel_X1=42; if(acel_Y2>=500)acel_Y2=495; if(acel_Y1>=500)acel_Y1=495; if(acel_Y2<=42)acel_Y2=42; if(acel_Y1<=42)acel_Y1=42; if(acel_Z2>=500)acel_Z2=495; if(acel_Z1>=500)acel_Z1=495; if(acel_Z2<=42)acel_Z2=42; if(acel_Z1<=42)acel_Z1=42;


39

if(yy2>=down)yy2=(down-5); /*señal del ecg (1)limites eje Y*/ if(yy1>=down)yy1=(down-5); if(yy2<=top)yy2=top; if(yy1<=top)yy1=top; if(xx2>=right) /*limites eje X*/ xx1=43; xx2=46; Liberar_Superficies(); imagen = IMG_Load("Panel_860_460.jpg"); dest.x =40; dest.y =40; dest.w = imagen->w; dest.h = imagen->h; SDL_FillRect(screen,&dest,SDL_MapRGB(screen->format,0,0,0)); SDL_SetAlpha(imagen, SDL_SRCALPHA, 40);//90 SDL_BlitSurface(imagen, NULL, screen, &dest); //rojo verde azul Help(); if(ecg) aalineRGBA(screen,xx1,yy1,xx2,yy2,0, 255, 0, 255); // Color Verde if(acelerometro) aalineRGBA(screen,xx1,acel_X1,xx2,acel_X2,255, 0, 0, 255); // Color Azul aalineRGBA(screen,xx1,acel_Y1,xx2,acel_Y2,0, 255, 0, 255); // aalineRGBA(screen,xx1,acel_Z1,xx2,acel_Z2,5, 0,255,255); if(tensiometro) ten_X2=ten_X2-8; // Le resto para que entren todas las señales y no se recorten las Presiones medias!!! aalineRGBA(screen,xx1,ten_X1,xx2,ten_X2,0, 255, 255, 255); aalineRGBA(screen,xx1,ten_Y1,xx2,ten_Y2,255, 255, 0, 255); if(flag_ten_barra==1) aalineRGBA(screen,(60+cnt_ten_barra),740,(60+cnt_ten_barra),(900-var_ten_aux_2),255, 255, 255,255); aalineRGBA(screen,(61+cnt_ten_barra),740,(61+cnt_ten_barra),(900-var_ten_aux_2),255, 255, 255,255); aalineRGBA(screen,(62+cnt_ten_barra),740,(62+cnt_ten_barra),(900-var_ten_aux_2),255, 255, 255,255); aalineRGBA(screen,(63+cnt_ten_barra),740,(63+cnt_ten_barra),(900-var_ten_aux_2),255, 255, 255,255); aalineRGBA(screen,(64+cnt_ten_barra),740,(64+cnt_ten_barra),(900-var_ten_aux_2),255, 255, 255,255); aalineRGBA(screen,(65+cnt_ten_barra),740,(65+cnt_ten_barra),(900-var_ten_aux_2),255, 255, 255,255); cnt_ten_barra=cnt_ten_barra+10; flag_ten_barra=0; if(flag_ten_Y2_3==1) itoa(var_ten_Y2_2,ten_1,10); mensaje(500,(516+nw),ten_1,16,2); nw=nw+20; flag_ten_Y2_3=0; Zoom(); ten_X1=ten_X2; ten_Y1=ten_Y2; yy1=yy2; acel_X1=acel_X2; acel_Y1=acel_Y2; acel_Z1=acel_Z2; if(ten_X2>=500)ten_X2=495; /*señal del tensiometro (2) limites eje Y*/ if(ten_X1>=500)ten_X1=495; if(ten_X2<=42)ten_X2=42; if(ten_X1<=42)ten_X1=42; if(ten_Y2>=500)ten_Y2=495; if(ten_Y1>=500)ten_Y1=495; if(ten_Y2<=42)ten_Y2=42; if(ten_Y1<=42)ten_Y1=42; if(acel_X2>=500)acel_X2=495; /*señal del acelerometro (3)limites eje Y*/ if(acel_X1>=500)acel_X1=495; if(acel_X2<=42)acel_X2=42; if(acel_X1<=42)acel_X1=42;


40

if(acel_Y2>=500)acel_Y2=495; if(acel_Y1>=500)acel_Y1=495; if(acel_Y2<=42)acel_Y2=42; if(acel_Y1<=42)acel_Y1=42; if(acel_Z2>=500)acel_Z2=495; if(acel_Z1>=500)acel_Z1=495; if(acel_Z2<=42)acel_Z2=42; if(acel_Z1<=42)acel_Z1=42; if(yy2>=down)yy2=(down-5); /*señal del ecg (1)limites eje Y*/ if(yy1>=down)yy1=(down-5); if(yy2<=top)yy2=top; if(yy1<=top)yy1=top; if(xx2>=right) /*limites eje X*/ xx1=43; xx2=46; // (**) Liberar_Superficies(); imagen = IMG_Load("Panel_860_460.jpg"); dest.x =40; dest.y =40; dest.w = imagen->w; dest.h = imagen->h; SDL_FillRect(screen,&dest,SDL_MapRGB(screen->format,0,0,0)); SDL_SetAlpha(imagen, SDL_SRCALPHA, 40); SDL_BlitSurface(imagen, NULL, screen, &dest); //fins stop void video::Fondo() SDL_Rect destFondo; fondo = IMG_Load("1280x800.jpg"); destFondo.x =0; destFondo.y =0; destFondo.w = fondo->w; destFondo.h = fondo->h; SDL_BlitSurface(fondo, NULL, screen, &destFondo); SDL_Flip(screen); void video::CerrarVentana() int i; int alpha=40; for(i=0;i<14;i++) if(i==0)imagen = IMG_Load("Panel_860_460_1.jpg"); if(i==1)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_2.jpg"); if(i==2)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_3.jpg"); if(i==3)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_4.jpg"); if(i==4)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_5.jpg"); if(i==5)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_6.jpg"); if(i==6)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_7.jpg"); if(i==7)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_8.jpg"); if(i==8)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_9.jpg"); if(i==9)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_10.jpg"); if(i==10)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_11.jpg"); if(i==11)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_12.jpg"); if(i==12)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_13.jpg"); if(i==13)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_13.jpg");alpha=1; dest.x =40; dest.y =40; dest.w = imagen->w; dest.h = imagen->h; SDL_FillRect(screen,&dest,SDL_MapRGB(screen->format,0,0,0)); SDL_SetAlpha(imagen, SDL_SRCALPHA, alpha); SDL_BlitSurface(imagen, NULL, screen, &dest); alpha=40; SDL_Flip(screen);


41

void video::AbrirVentana() int i; for(i=0;i<13;i++) if(i==12)imagen = IMG_Load("Panel_860_460_1.jpg"); if(i==11)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_2.jpg"); if(i==10)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_3.jpg"); if(i==9)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_4.jpg"); if(i==8)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_5.jpg"); if(i==7)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_6.jpg"); if(i==6)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_7.jpg"); if(i==5)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_8.jpg"); if(i==4)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_9.jpg"); if(i==3)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_10.jpg"); if(i==2)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_11.jpg"); if(i==1)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_12.jpg"); if(i==0)Liberar_Superficies();imagen = IMG_Load("Panel_860_460_13.jpg"); dest.x =40; dest.y =40; dest.w = imagen->w; dest.h = imagen->h; SDL_FillRect(screen,&dest,SDL_MapRGB(screen->format,0,0,0)); SDL_SetAlpha(imagen, SDL_SRCALPHA, 40); SDL_BlitSurface(imagen, NULL, screen, &dest); SDL_Flip(screen); int video::mensaje(int x,int y, char mensaje[200],int size, int colorMsn) if(colorMsn==0)textColor=CblancoFojo; if(colorMsn==1)textColor=Cverde; if(colorMsn==2)textColor=Cblanco; if(colorMsn==3)textColor=Crojo; if(colorMsn==4)textColor=Cazul; if(colorMsn==5)textColor=Camarillo; font = TTF_OpenFont( "arial.ttf", size); SDL_FreeSurface(message); message=TTF_RenderText_Shaded( font, mensaje, textColor, colorFondoCaracter ); destT.x = x; destT.y = y; destT.h = message->h; destT.w = message->w; SDL_BlitSurface(message, NULL, screen, &destT); TTF_CloseFont(font); textColor=Cblanco; return 1; int video::Pantalla() RecibirDatos(); if(flag_help==0) HeartRate();/*esta funcion solo muestra el valor de las pulsaciones por minuto por pantalla y tambien las /*presiones*/ DiaSys(); /*esta funcion solo muestra el valor de la diastole y sistole por pantalla*/ PrintSeñal(); SDL_Flip(screen); //Actualiza la pantalla "screen", sube todos los cambios. //La actualizacion siempre al final. Enganchamos todo en //nuestra screen y cuando todo esta enganchado se actualiza //la pantalla. De esa forma evitamos parpadeos. return 1; void video::CargarImagen(int x, int y, char file[60], int intensidad) /* x e y son las coordenadas donde quiero posicionar la imagen


42

file es el nombre de la imagen (con extension) que quiero abrir e intensidad es un entero de 0 a 255 e indica la intesidad de la imagen (0 transparente 255 original) */ SDL_FreeSurface(imagen); imagen = IMG_Load(file); dest.x =x; dest.y =y; dest.w = imagen->w; dest.h = imagen->h; SDL_FillRect(screen,&dest,SDL_MapRGB(screen->format,0,0,0)); SDL_SetAlpha(imagen, SDL_SRCALPHA, intensidad); SDL_BlitSurface(imagen, NULL, screen, &dest); SDL_Flip(screen); int video::Liberar_Superficies() SDL_FreeSurface(imagen); SDL_FreeSurface(screen); return 0; void video::Borrar_Screen(int x, int y, int w, int h) /*indico coordenadas para la creacion de un rectangulo de borrado (x,y)*/ rect.x = x; // coordenada x rect.y = y; // coordenada y rect.w = w; // ancho rect.h = h; // alto SDL_FillRect(screen,&rect,SDL_MapRGB(screen->format,0,0,0));//000 void video::Mascara() int xx,nn,r,m,a=0; xx=980;//980 nn=0; SDL_Rect destFondo; fondo = IMG_Load("1280x800.jpg"); destFondo.x =0; destFondo.y =0; destFondo.w = fondo->w; destFondo.h = fondo->h; imagen = IMG_Load("logo_inicio.bmp"); dest.x =240; dest.y =1; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 220); SDL_BlitSurface(imagen, NULL, fondo, &dest); SDL_BlitSurface(fondo, NULL, screen, &destFondo); SDL_Flip(screen); for(r=0;r<20000;r++) for(m=0;m<20000;m++) a = a + 1; Borrar_Screen(dest.x, dest.y, dest.w, dest.h); fondo = IMG_Load("1280x800.jpg"); destFondo.x =0; destFondo.y =0; destFondo.w = fondo->w; destFondo.h = fondo->h; imagen = IMG_Load("corazon.jpg"); dest.x =1195; dest.y =93; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, fondo, &dest);


43

imagen = IMG_Load("logo_panel.bmp"); dest.x =1030; dest.y =745; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 200); SDL_BlitSurface(imagen, NULL, fondo, &dest); imagen = IMG_Load("heartrate2.jpg"); dest.x =980; dest.y =40; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, fondo, &dest); imagen = IMG_Load("bpm.bmp"); dest.x =1190; dest.y =165; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, fondo, &dest); imagen = IMG_Load("bloodpressure.bmp"); dest.x =980; dest.y =220; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, fondo, &dest); imagen = IMG_Load("sys.bmp"); dest.x =1190; dest.y =270; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, fondo, &dest); imagen = IMG_Load("mmHg.bmp"); dest.x =1190; dest.y =345; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, fondo, &dest); imagen = IMG_Load("dia.bmp"); dest.x =1190; dest.y =390; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, fondo, &dest); imagen = IMG_Load("mmHg.bmp"); dest.x =1190; dest.y =465; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, fondo, &dest); imagen = IMG_Load("start-button.jpg"); dest.x =960; //960 dest.y =520; //510 dest.w = imagen->w; dest.h = imagen->h; stopstart=2; SDL_SetAlpha(imagen, SDL_SRCALPHA, 180); SDL_BlitSurface(imagen, NULL, fondo, &dest); SDL_BlitSurface(fondo, NULL, screen, &destFondo); SDL_Flip(screen); mensaje(910,230,"PAM/P",16,2); itoa(ij,ijj,10); mensaje(948,247,ijj,16,5);


44

void video::Mascara_Reset() int xx,nn,r,m,a=0; xx=980;//980 nn=0; SDL_Rect destFondo; fondo = IMG_Load("1280x800.jpg"); destFondo.x =0; destFondo.y =0; destFondo.w = fondo->w; destFondo.h = fondo->h; imagen = IMG_Load("Panel_860_460.jpg"); dest.x =40; dest.y =40; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 40); SDL_BlitSurface(imagen, NULL, fondo, &dest); imagen = IMG_Load("corazon.jpg"); dest.x =1195; dest.y =93; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, fondo, &dest); imagen = IMG_Load("logo_panel.bmp"); dest.x =1030; dest.y =745; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 200); SDL_BlitSurface(imagen, NULL, fondo, &dest); imagen = IMG_Load("heartrate2.jpg"); dest.x =980; dest.y =40; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, fondo, &dest); imagen = IMG_Load("bpm.bmp"); dest.x =1190; dest.y =165; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, fondo, &dest); imagen = IMG_Load("bloodpressure.bmp"); dest.x =980; dest.y =220; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, fondo, &dest); imagen = IMG_Load("sys.bmp"); dest.x =1190; dest.y =270; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, fondo, &dest); imagen = IMG_Load("mmHg.bmp"); dest.x =1190; dest.y =345; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, fondo, &dest);


45

imagen = IMG_Load("dia.bmp"); dest.x =1190; dest.y =390; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, fondo, &dest); imagen = IMG_Load("mmHg.bmp"); dest.x =1190; dest.y =465; dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, fondo, &dest); if(stopstart==2) imagen = IMG_Load("start-button.jpg"); dest.x =960; //960 dest.y =520; //510 dest.w = imagen->w; dest.h = imagen->h; if(stopstart==1) imagen = IMG_Load("stop-button.jpg"); dest.x =960; //960 dest.y =520; //510 dest.w = imagen->w; dest.h = imagen->h; SDL_SetAlpha(imagen, SDL_SRCALPHA, 180); SDL_BlitSurface(imagen, NULL, fondo, &dest); SDL_BlitSurface(fondo, NULL, screen, &destFondo); CargarImagen(40,520, "Panel_texto.jpg", 40); if(Cusb.DeviceConectado()) char msn[200]=">: Device USB connected .................................................. [OK]"; mensaje(48,550, msn,13,2); else char msn2[200]=">: Device USB connected .................................................. [kO]"; mensaje(48,550, msn2,13,3); void video::Help() if(flag_F1) xx1=43; xx2=46; Liberar_Superficies(); imagen = IMG_Load("iron5.jpg"); dest.x =0; dest.y =0; dest.w = imagen->w; dest.h = imagen->h; SDL_FillRect(screen,&dest,SDL_MapRGB(screen->format,0,0,0)); SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, screen, &dest); //rojo verde azul flag_Mascara=1; flag_F1=1; stop=1; if(flag_F1_R) xx1=43; xx2=46; Liberar_Superficies(); imagen = IMG_Load("iron5b.jpg"); dest.x =0; dest.y =0; dest.w = imagen->w; dest.h = imagen->h;


46

SDL_FillRect(screen,&dest,SDL_MapRGB(screen->format,0,0,0)); SDL_SetAlpha(imagen, SDL_SRCALPHA, 255); SDL_BlitSurface(imagen, NULL, screen, &dest); //rojo verde azul flag_Mascara=1; flag_F1=0; flag_F1_R=0; stop=1; /* MENU */ int video::Menu() IniVariables(); /*inicializamos variables*/ while(TRUE) /*de este while no saldremos hasta que no finalice el programa*/ if(flag_eventos) GestionEventos(); /*Activación de tareas por flags*/ Pantalla(); /*Recepción de datos y presentación de datos por pantalla*/ while (SDL_PollEvent(&event)) /*Gestion de las tareas por teclado*/ switch (event.type) case SDL_KEYDOWN: break; case SDL_KEYUP: Eventos_Teclado(); if(exit_t==1)return 0; exit_t=0; break; case SDL_QUIT: return(0); CerrarVentana(); return 0; /* GRAFICA PEQUEÑA*/ int aux23,aux24,aux25,cnt26; int video::PrintlowSeñal(int dato,int top, int down,int right,int left) if(flag_primera_vez==1) x_2=left+1; x_1=left; y_2=dato; y_1=y_2; flag_primera_vez=0; y_2=dato; if(y_2>=down)y_2=down-2; /*señal del ecg limites eje Y*/ if(y_1>=down)y_1=(down-2); if(y_2<=top)y_2=top+2; if(y_1<=top)y_1=top+2; if(x_2>=right) /*limites eje X*/ x_1=left+2; x_2=left+2; aux_w=right-left; aux_h=down-top; Borrar_Screen(left, top,(aux_w+2),(aux_h+10)); roundedRectangleRGBA(screen, 600, 550, 880, 650, 8, 255,255,255,50);


47

aalineRGBA(screen,x_1,y_1,x_2,y_2,0, 0, 255, 255); if(n_r==0) if(n_y>2) x_2=x_1; x_1=x_1+1; n_y=0; n_y++; y_1=y_2; if(y_2>=down)y_2=(down-2); if(y_1>=down)y_1=(down-2); if(y_2<=top)y_2=top+2; if(y_1<=top)y_1=top+2; if(x_2>=right) x_1=left+2; x_2=left+2; aux_w=right-left; aux_h=down-top; Borrar_Screen(left, top,(aux_w+2),(aux_h+10)); roundedRectangleRGBA(screen, 600, 550, 878, 650, 8, 255,255,255,50); return 1; int video::R_ecg_low() if((flag_ecg_low==1)&(flag_help==0)) int dato1; if(flag_ecg_low_primera_vez==1) Cusb.recibir_ecg_low(); flag_ecg_low_primera_vez=0; aux23=0; aux24=0; aux25=0; cnt26=0; if(v==64) Cusb.recibir_ecg_low(); v=0; if(cnt26==256)aux24=aux23/256;aux23=0;cnt26=0; dato1=*((Cusb.pyr6)+(v)); aux23=aux23+dato1; aux25=600-aux24; dato1=dato1+aux25; v=v+1; cnt26++; PrintlowSeñal(dato1,550,645,878,600); return 1;


48

5.3 Código, Matlab Rutina para hallar los filtros de segundo orden Sallen-Key, paso bajos y paso altos, propuestos en este proyecto.

clc; disp('Butterwoth 12db/octava PASA ALTAS/BAJAS 2ºorden'); disp('-----------------------------------------'); disp(' 1-Pasa Altas'); disp(' 2-Pasa Bajas'); eleccion=input(' >:'); %Pasa Altas if eleccion==1 clc; disp('Butterwoth 12db/octava PASA ALTAS 2ºorden'); disp('-----------------------------------------'); disp(''); disp(' Criterios de diseño:'); disp(''); disp(' R = valores entre 4K7-10K'); disp(' C = 1,000/(2*pi*Fc*R)'); disp(''); f=input(' Elige la Frecuencia de corte en Hz:'); resistencia=input(' Elige el valor de la resistencia en Ohmios:'); disp(' '); disp(' '); fc=f; r=resistencia; disp(' Resultados:'); C=1/(2*pi*fc*r); disp(' C:'); disp(C); disp(' R:'); disp(r); disp(' Fc:'); disp(fc); s=zpk('s'); transfun=(s^2)/( s^2 + s*((1/(r*C))+ (1/(r*C))) + (1/(r*r*C*C))); tf(transfun) %muestro la funcion de transferencia ceros=zero(transfun) %resuelve ceros polos=pole(transfun) %resuelve polos n=1; while(n) disp(' Gráficas:'); disp('-----------------------------'); disp(' 1-Diagrama de polos y ceros'); disp(' 2-Bode'); disp(' 3-Lugar geometrico de las raices'); disp(' 4-Nyquist'); disp(' 5-Margin'); disp(' 6-salir'); opcion=input(' >:'); if opcion == 1 pzmap(transfun) %diagrama de polos y ceros end if opcion == 2 bode(transfun) %bode end if opcion == 3 rlocus(transfun) %lugar geometrico de las raices end if opcion == 4 nyquist(transfun) %lugar geometrico de las raices end if opcion == 5 margin(transfun) %lugar geometrico de las raices end if opcion == 6 n=0; end if opcion > 6 disp('No es una opción valida'); end


49

if opcion < 1 disp('No es una opción valida'); end end end %Pasa bajas if eleccion==2 clc; disp('Butterwoth 12db/octava PASA BAJAS 2ºorden'); disp('-----------------------------------------'); disp(''); disp(' Criterios de diseño:'); disp(''); disp(' R = valores entre 4K7-10K'); disp(' C = 1,000/(2*pi*Fc*R)'); % disp(' Ca = 1,4142/(2*pi*Fc*R)'); % disp(' Cb = 0,7071/(2*pi*Fc*R)'); disp(''); f=input(' Elige la Frecuencia de corte en Hz:'); resistencia=input(' Elige el valor de la resistencia en Ohmios:'); disp(' '); disp(' '); fc=f; r=resistencia; disp(' Resultados:'); C=1/(2*pi*fc*r); %Ca=1.4142/(2*pi*fc*r); %Cb=0.7071/(2*pi*fc*r); disp(' C:'); disp(C); %disp(' Ca:'); %disp(Ca); %disp(' Cb:'); %disp(Cb); disp(' R:'); disp(r); disp(' Fc:'); disp(fc); Ca=C; Cb=C; s=zpk('s'); transfun=(1/(r*r*Ca*Cb))/( s^2 + s*((1/(r*Ca))+ (1/(r*Cb))) + (1/(r*r*Ca*Cb))); tf(transfun) %muestro la funcion de transferencia ceros=zero(transfun) %resuelve ceros polos=pole(transfun) %resuelve polos n=1; while(n) disp(' Gráficas:'); disp('-----------------------------'); disp(' 1-Diagrama de polos y ceros'); disp(' 2-Bode'); disp(' 3-Lugar geometrico de las raices'); disp(' 4-Nyquist'); disp(' 5-Margin'); disp(' 6-salir'); opcion=input(' >:'); if opcion == 1 pzmap(transfun) %diagrama de polos y ceros end if opcion == 2 bode(transfun) %bode end if opcion == 3 rlocus(transfun) %lugar geometrico de las raices end if opcion == 4 nyquist(transfun) %lugar geometrico de las raices end if opcion == 5 margin(transfun) %lugar geometrico de las raices end if opcion == 6 n=0; end


50

if opcion > 6 disp('No es una opción valida'); end if opcion < 1 disp('No es una opción valida'); end end end


1

5.4 Diseño PCB

Layout del diseño del circuito.


2

Cara “top” de la PCB.


3

Cara “bottom” de la PCB.


4

5.5 Diseño gráfico Lista de “PrintScreens” del software.

Figura 5.1 Pantalla de inicio del software.

Figura 5.2 Pantalla, F1 posición de los electrodos.


5

Figura 5.3 Pantalla, F1 posición del manguito y acelerómetro.

Figura 5.4 Pantalla de inicio sin dispositivo usb conectado.


6

Figura 5.5 Secuencia de calibración del acelerómetro.

Figura 5.6 Pantalla de inicio con dispositivo conectado.


7

Figura 5.7 Pruebas con el acelerómetro.

Figura 5.8 Grafica ECG sin sujeto conectado.


8

Figura 5.9 Medida de la presión y grafica de la envolvente..

Figura 5.10 Salida del sistema durante el inflado.

Documents

Sistema de adquisición de constantes vitalesdeeea.urv.cat/public/PROPOSTES/pub/pdf/1987pub.pdf · Sistema de adquisición de constantes vitales 2 temperatura, la dieta, estado emocional,