Indicador de latidos cardíacos con ECG

Acerca de este proyecto

Durante muchos años solo quise hacer algo con LED que parpadearan al ritmo de los latidos de mi corazón (y no solo cuando me quedo perfectamente quieto y, sin embargo, me salta un latido aquí y allá). Eso resultó ser sorprendentemente difícil, lo intenté y fracasé durante años. ¡Pero ya no!

En realidad, todo el trabajo pesado lo realiza uECG, un pequeño dispositivo de ECG portátil que es de código abierto y tiene un pin de salida compatible con Arduino (ese pin va alto / bajo con cada latido del corazón). Procesar estos estados de clavija es mucho más fácil que procesar la señal de ECG, y he intentado aprovecharlo al máximo.
UPD:es posible que desee verificar la segunda iteración de este proyecto, que recibe datos a través de un enlace de radio.

1. Esquemas
Dado que aquí trabajamos solo con señales digitales, es muy simple. Pero como un dispositivo portátil sería mucho más confiable (y más pequeño) si la mayoría de las conexiones estuvieran soldadas; para una prueba rápida no es necesario, pero si lo vas a usar durante una actividad intensa, te lo recomiendo encarecidamente.
Los esquemas se ven así:

• El pin DI del anillo LED va al pin D11 (configurable en el código)
• El pin DRV del dispositivo uECG va al pin D3 (también configurable)
• El + de la batería va a las entradas Arduino 5V y LED ring 5V
• Batería:va a Arduino GND, ring GND y uECG's GND

He usado la batería LiPo directamente como entrada de 5V; no hay error, si la conecta a Vin, no funcionará de manera confiable (el regulador de voltaje en Vin introduce una caída de voltaje y no podemos permitirnos uno aquí). La cuestión es que Arduino es estable siempre que el voltaje de entrada no sea inferior a 3,4 voltios. La batería LiPo comienza a 4,2 voltios cuando está completamente cargada y llega a 3,4 voltios solo cuando queda menos del 15% de carga. Entonces, con cualquier batería de más de ~ 200 mAh, puede obtener un tiempo de funcionamiento decente. Aparte de eso, tenga en cuenta que la batería debe conectarse a través de algún, bueno, conector :) Porque desea desconectarla de los esquemas y cargarla de vez en cuando.

2. Código
El programa funciona de una manera simple:lee constantemente el pin D3, y cuando se detecta un cambio, empuja el tiempo de ese cambio a una matriz de 20 elementos. La diferencia entre el primer y el último elemento, dividido por 20, es el tiempo promedio por latido (en milisegundos). Entonces, dividir 1 minuto (60000 milisegundos) por ese número nos da un valor de BPM. Puede ajustar el número de elementos de la matriz. Un número menor de elementos conduciría a una respuesta más rápida, pero a resultados menos estables (cualquier problema en la detección de latidos conduciría a un gran salto en el BPM calculado). Una mayor cantidad de elementos proporcionaría datos más estables, pero una respuesta más lenta cuando BPM cambia rápidamente.

Luego, BPM se asigna a color (azul-> verde-> amarillo-> rosa-> rojo cuando BPM pasa de bajo a alto) y en el número de LED:para 80 BPM, ocho segmentos están encendidos, para 110 - once y así sucesivamente. (escala también ajustable en el código).

  #include  
 #ifdef __AVR__ 
 #include  
 #endif 
 // Pin DI del anillo LED 
 #define PIN 11 
 // número de píxeles en el anillo 
 #define NUMPIXELS 16 
 // pin de entrada para conectar uECG 
 int in_pin =3; 
 Adafruit_NeoPixel píxeles =Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); 
 configuración vacía () {
 píxeles.begin (); // Esto inicializa la biblioteca NeoPixel. 
 pinMode (in_pin, INPUT); // establece el pin en el modo de entrada 
 digitalWrite (in_pin, 1); // habilitar PULLUP:esto es crítico, uECG no tiene pull-up interno 
} 
 // almacenamos los últimos 20 latidos para promediar BPM sobre ellos 
 // con un valor más alto, se volverá más confiable, 
 // pero tomará más tiempo ver el cambio de salida cuando cambie el BPM 
 #define BEAT_HIST 20 
 long beats [BEAT_HIST]; 
 void push_beat (long ms) // cambia todos los latidos en la matriz e inserta uno actual 
 {
 para (int x =0; x  {
 latidos [x] =beats [x + 1]; 
} 
 beats [BEAT_HIST-1] =ms; 
} 
 int get_bpm () // usando la diferencia de tiempo entre el primer y el último tiempo 
 {
 long dt =beats [BEAT_HIST-1] - beats [0]; 
 long bpm =BEAT_HIST * 60000 / dt; 
 return bpm; 
} 
 largo last_pix_upd =0; // para realizar un seguimiento de cuándo actualizamos los píxeles la vez anterior 
 int prev_in_state =0; // estado anterior del pin de entrada:queremos procesar solo cambios de estado 
 void loop () 
 {
 long ms =millis (); 
 int in_state =digitalRead (in_pin ); // 1 cuando no se detecta latido, 0 en latido 
 if (in_state ==1 &&prev_in_state ==0) // reacciona solo para cambiar 
 {
 push_beat (ms); 
} 
 prev_in_state =in_state; 
 if (ms - last_pix_upd> 10) // no actualice los píxeles con demasiada frecuencia 
 {
 int r, g, b; 
 last_pix_upd =ms; 
 int bpm =get_bpm (); 
 int max_bright =120; // valor de brillo máximo, máximo 255. Pero no siempre lo quieres al máximo :) 
 float dd =20; // cambio en BPM entre tonos de color (azul-> verde-> amarillo-> rosa-> rojo) 
 float t1 =90, t2, t3, t4; // t1 - BPM "base", menor que t1 sería azul 
 t2 =t1 + dd; 
 t3 =t2 + dd; 
 t4 =t3 + dd; 
 / / código para cambiar de color dependiendo en qué rango t1 ... t4 estemos ahora 
 if (bpm  más si (bpm  más si (bpm  else if (bpm  else {r =max_bright; g =0; b =0; } 
 if (in_state) // cuando no está en tiempo, 1/4 de intensidad, por lo que solo se resaltan los tiempos 
 {
 r * =0.25; 
 g * =0.25; 
 b * =0.25; 
} 
 int on_pixels =(bpm + 5) / 10; // número de LED usados:para 60 BPM, 6 LED estarán encendidos, para 120 - 12, etc. 
 para (int i =0; i  {
 if ( i  else pixels.setPixelColor (i, pixels.Color (0,0,0)); // apaga todos los demás LED 
} 
 pixels.show (); 
} 
}  

3. Montaje como wearable
Es conveniente colocar Arduino dentro del anillo; coincide con el tamaño casi a la perfección. La batería también cabe cerca. No olvide que uECG se coloca en un cofre, por lo que necesita un cable con conectores, primero lo coloca, luego se pone una camisa con otros componentes y luego enchufa el conector. De lo contrario, sería muy inconveniente ponérselo; créanme, lo intenté))

Eso es básicamente todo:si todo se hizo bien, dentro de los 30 segundos después de enchufar todos los conectores, comenzará a parpadear e indicará BPM.

4. Prueba de campo
Lo probé mientras caminaba y corría, y descubrí que durante la carrera, la batería rebota directamente sobre el sensor de ECG, distorsionando sus lecturas. Cuando lo moví todo un poco, resultó que el cable que conecta uECG con Arduino es demasiado corto y tira del sensor de ECG con cada paso, distorsionando las lecturas nuevamente. En general, obtuve ritmos confiables solo al caminar y estar de pie, pero no al correr; sin embargo, creo que lo mejoraré. El sensor en sí, cuando lo usé con una camisa diferente, también mostró BPM correctamente durante la carrera (verificado a través de su aplicación).

Además, resulta que los LED en un cofre pueden verse geniales, pero son prácticamente inútiles. Es realmente un inconveniente mirar hacia abajo para tomarse el pulso. Creo que en la próxima iteración haré una especie de brazalete de muñeca que indicará latidos en su lugar.

PD Si está interesado en el proyecto uECG, puede consultar su página de hackaday, hay muchos detalles técnicos, diseños de PCB, discusiones y registros del proyecto

 #include  #ifdef __AVR__ #include  # endif // Pin DI del anillo LED # define PIN 11 // número de píxeles en el anillo # define NUMPIXELS 16 // entrada pin para conectar uECGint in_pin =3; Adafruit_NeoPixel píxeles =Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); configuración vacía () {píxeles.begin (); // Esto inicializa la biblioteca NeoPixel. pinMode (in_pin, ENTRADA); // establece el pin en el modo de entrada digitalWrite (in_pin, 1); // habilitar PULLUP:esto es crítico, uECG no tiene pull-up interno} // almacenamos los últimos 20 latidos para promediar BPM sobre ellos // con un valor más alto, será más confiable, // pero tomará más tiempo para ver el cambio de salida cuando cambia BPM # definir BEAT_HIST 20 latidos largos [BEAT_HIST]; void push_beat (ms largo) // cambiar todos los latidos en la matriz e insertar uno actual {for (int x =0; x  10) // no actualice los píxeles con demasiada frecuencia {int r, g, b; last_pix_upd =ms; int bpm =get_bpm (); int max_bright =120; // valor de brillo máximo, máximo 255. Pero no siempre lo quieres al máximo :) float dd =20; // cambio de BPM entre tonos de color (azul-> verde-> amarillo-> rosa-> rojo) float t1 =90, t2, t3, t4; // t1 - BPM "base", menor que t1 sería azul t2 =t1 + dd; t3 =t2 + dd; t4 =t3 + dd; // código para cambiar de color dependiendo en qué rango t1 ... t4 estemos ahora if (bpm   
 
   Esquemas     
  
 

            


            

               Regulador de ducha        
                Pixel Chaser Game