Monitor de frecuencia cardíaca (portátil e inalámbrico con ECG)

Acerca de este proyecto

Esta es una segunda iteración de mi proyecto de monitoreo cardíaco, el anterior mostraba latidos cardíacos en un pecho y estaba conectado a uECG a través de un cable. Eso se ve genial, pero no es práctico en absoluto:no puede ver bien cuántos LED están exactamente encendidos actualmente, está fuera de su campo de visión normal y el cable que lo conecta al dispositivo uECG crea muchos problemas para el sensor en sí , por lo que básicamente no funciona cuando corres.

Esta versión resuelve todos estos problemas:se usa en la muñeca, por lo que puede verlo mientras mantiene los ojos en la carretera, y es inalámbrico, por lo que no distorsiona las lecturas, realmente funciona para correr y le permite realizar un seguimiento de la carga cardíaca.

1. Componentes

Al igual que en el proyecto anterior, todo el trabajo duro lo realiza uECG:mide datos y calcula BPM a bordo. Pero también, cuando se cambia al modo de enlace directo, envía toda esta información (junto con los datos de ECG de alta resolución, que no estamos usando aquí) a través de un protocolo de radio que es compatible con el chip nRF24 genérico. Entonces, el segundo componente crítico es el módulo nRF24. Y Arduino Nano tiene el tamaño justo para caber debajo de un pequeño anillo LED, así que lo estoy usando como controlador (pero realmente cualquier cosa funcionaría igual de bien aquí).

2. Esquemas

Conectar el módulo nRF24 no es simple, debe conectar todos los cables SPI (MISO, MOSI, SCK, CS), también el cable de habilitación del chip y la fuente de alimentación. Y si lo desea en un tamaño razonablemente pequeño, se deben quitar todos los cabezales de los pines y soldar los cables directamente a las almohadillas. Entonces, conectar nRF solo requiere 7 cables, 14 puntos de soldadura. La buena noticia es que todo lo demás es simple:el anillo LED requiere 1 cable de datos y 2 cables de alimentación, y otros 2 cables de alimentación van al conector de la batería.

La lista de conexiones es la siguiente:
nRF24 pin 1 (GND) - Arduino's GND
nRF24 pin 2 (Vcc) - Arduino's 3.3v
nRF24 pin 3 (Chip Enable) - Arduino's D9
nRF24 pin 4 (SPI:CS) - Arduino's D8
nRF24 pin 5 (SPI:SCK) - Arduino's D13
nRF24 pin 6 (SPI:MOSI) - Arduino's D11
nRF24 pin 7 ( SPI:MISO) - Arduino's D12
LED ring Power - Arduino's 5V
LED ring GND - Arduino's GND
LED ring DI - Arduino's D5
Positivo de la batería (rojo) - Arduino's 5V
Negativo de la batería (negro) - GND de Arduino
(tenga en cuenta que la batería requiere un conector, por lo que podría desconectarse y cargarse)

Nota importante:no puede conectar cables MOSI, MISO, SCK a otros pines Arduino. El hardware SPI se encuentra en D11, D12, D13 y no funcionará si no está conectado allí. Todos los demás pines se pueden cambiar (si realiza los cambios correspondientes en el programa).

3. Programa

Lo único complicado del software aquí es la configuración del canal de RF. Pasé bastante tiempo tratando de hacerlo funcionar antes de darme cuenta de que uECG y nRF24 usan un orden de bits diferente para la dirección de la tubería. Cuando arreglé eso, todo comenzó a funcionar de inmediato :) Básicamente, solo leemos los paquetes entrantes, usamos su quinto byte como BPM y lo filtramos (el canal de RF es ruidoso, por lo que de vez en cuando obtienes un valor aleatorio en lugar de una lectura correcta, y hardware CRC está deshabilitado por razones de compatibilidad). Después de eso, BPM se convierte en color y número de píxeles activos, y eso es todo.

  #include  
 #ifdef __AVR__ 
 #include  
 #endif 
 #include  
 #include  
 #include  
 #include  
 int rf_cen =9; // pin de habilitación del chip nRF24 
 int rf_cs =8; // clavija nRF24 CS 
 RF24 rf (rf_cen, rf_cs); 
 // dirección de tubería - codificada en el lado de uECG 
 uint8_t pipe_rx [8] ={0x0E, 0xE6, 0x0D, 0xA7, 0 , 0, 0, 0}; 
 // ¿Qué pin del Arduino está conectado a los NeoPixels? 
 #define PIN 5 
 // ¿Cuántos NeoPixels están conectados al Arduino? 
 # define NUMPIXELS 16 
 Adafruit_NeoPixel píxeles =Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); 
 uint8_t swapbits (uint8_t a) {// la dirección de tubería uECG usa orden de bits intercambiados 
 // invertir el orden de los bits en un solo byte 
 uint8_t v =0; 
 if (a &0x80) v | =0x01; 
 if (a &0x40) v | =0x02; 
 if (a &0x20) v | =0x04; 
 if (a &0x10) v | =0x08; 
 if (a &0x08) v | =0x10; 
 if (a &0x04) v | =0x20; 
 if (a &0x02) v | =0x40; 
 if (a &0x01) v | =0x80; 
 return v; 
} 
 configuración void () {
 píxeles.begin (); // Esto inicializa la biblioteca NeoPixel. 
 for (int i =0; i pixels.setPixelColor(i, pixels.Color (1,1,1)); 
} 
 pixels.show (); 
 // nRF24 requiere SPI relativamente lento, probablemente también funcionaría a 2MHz 
 SPI.begin (); 
 SPI.setBitOrder (MSBFIRST ); 
 SPI.beginTransaction (SPISettings (1000000, MSBFIRST, SPI_MODE0)); 
 for (int x =0; x <8; x ++) // nRF24 y uECG tienen un orden de bits diferente para la dirección de tubería 
 pipe_rx [x] =swapbits (pipe_rx [x]); 
 // configurar parámetros de radio 
 rf.begin (); 
 rf.setDataRate (RF24_1MBPS); 
 rf.setAddressWidth (4); 
 rf.setChannel (22); 
 rf.setRetries (0, 0); 
 rf.setAutoAck (0); 
 rf.disableDynamicPayloads ( ); 
 rf.setPayloadSize (32); 
 rf.openReadingPipe (0, pipe_rx); 
 rf.setCRCLength (RF24_CRC_DISABLED); 
 rf.disableCRC (); 
 rf.startListening (); // escucha los datos de uECG 
 // Tenga en cuenta que uECG debe cambiarse al modo de datos sin procesar (presionando un botón largo) 
 // para enviar paquetes compatibles, por defecto envía datos en modo BLE 
 // que no puede ser recibido por nRF24 
} 
 long last_pix_upd =0; 
 byte in_pack [32]; 
 int rf_bpm =0; 
 int bpm_hist [5]; // dado que deshabilitamos CRC, necesitamos filtrar los datos entrantes 
 void loop () 
 {
 if (rf.available ()) 
 {
 rf.read ( en_paquete, 32); 
 int bb =en_paquete [5]; // BPM está ubicado en el quinto byte del paquete 
 // la estructura detallada del paquete está en los documentos de uECG 
 // ya que no tenemos CRC por razones de compatibilidad, necesitamos filtrar 
 // datos entrantes, el canal de radio puede ser ruidoso. Comparamos los últimos 5 
 // valores de BPM recibidos y usamos uno solo si los 5 son iguales. 
 // Dado que uECG envía alrededor de 100 paquetes por segundo, no causará 
 // cualquier retraso notable en la visualización de datos 
 for (int n =0; n <5-1; n ++) // cambia la matriz del historial de bpm en 1 
 bpm_hist [n] =bpm_hist [n + 1]; 
 bpm_hist [4] =bb; // agrega un nuevo valor de bpm 
 para (int n =0; n <5; n ++) // verifica si todos son iguales 
 if (bpm_hist [n]! =bb) bb =-1; 
 if (bb> 0) // si es así - guárdelo como nuevo BPM recibido 
 rf_bpm =bb; 
} 
 long ms =millis (); 
 if ( ms - last_pix_upd> 10) // no actualice los píxeles con demasiada frecuencia 
 {
 int r, g, b; 
 last_pix_upd =ms; 
 int bpm =rf_bpm; 
 int max_bright =160; // valor de brillo máximo, máximo 255. Pero no siempre lo quieres al máximo :) 
 float dd =25; // 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; } 
 int on_pixels =(bpm-80) / 8; // dado que está diseñado para ejecutarse, no estoy 
 // mostrando nada menos de 80 BPM, de esta manera es más sensible en 
 // área de carga alta 
 para (int i =0; i  {
 // los píxeles se configuran del último al primero sin ninguna razón en particular, 
 // funcionarían igual de bien si se configuraran del primero al último 
 if (i  else pixels.setPixelColor (NUMPIXELS-i-1, pixels.Color (0, 0,0)); // apaga todos los demás LED 
} 
 pixels.show (); 
} 
}  

4. Ensamblaje de muñequera

Cuando todos los cables están soldados, el programa parpadea y usted confirma que se reciben los datos de uECG, es hora de juntarlo todo.

Elegí una forma muy sencilla de mantenerlo todo junto:pegamento térmico. Dado que las piezas en sí mismas ya casi encajan (Nano se ajusta al tamaño del anillo exterior, el módulo nRF24 se ajusta al tamaño del anillo interno y la batería, aunque no encaja en ninguna pieza, de alguna manera no interfiere mucho, no estoy seguro de cómo funciona, pero simplemente pegué estaba allí y de alguna manera estaba realmente bien :) Luego lo cosí a una pulsera aleatoria que tenía a mano (sobrante del paquete de la estación de soldadura, una banda que se usa para conectar a tierra mientras se suelda), ¡y eso es todo!

5. Prueba

Para las pruebas, salí a correr y funcionó bien, excepto por una sorpresa. He usado configuraciones tales que a 192 BPM todos los LED estaban encendidos, ya que según todas las recomendaciones, dicha frecuencia cardíaca es demasiado alta para mis parámetros. La sorpresa fue que lo he superado en tan solo unos minutos de carrera, sin siquiera darme cuenta. Incluso pensé que podría ser un error del sensor, pero no, cuando me detuve, no bajó de inmediato, sino que hubo una relajación lenta (el sensor es 100% confiable cuando no hay mucho movimiento). Entonces resulta que durante un tiempo entreno muy por encima de mi umbral saludable (al menos lo que se supone que es saludable para un adulto estándar de mi edad / peso). Es interesante:me gustan mucho los deportes (amateur) desde la niñez, pero tuve problemas cardíacos en mi adolescencia y parecían desaparecer con el tiempo. Pero sé por experiencia que cualquier carga superior a una caminata rápida era muy difícil para mí, pero seguí entrenando, y eso aumentó mi límite con el tiempo, hasta el punto de que ahora me considero bastante en forma. Y ahora tengo una pregunta:¿mi BPM es más alto de lo normal debido a esos problemas cardíacos en la adolescencia, o realmente estoy presionando demasiado sin darme cuenta? De todos modos, tendré que hacer algo con él:aumentar el BPM máximo en el monitor o entrenar con menos intensidad. :)

PD sorprendentemente, uECG funcionó muy bien como sensor EMG; puede leerlo en mi proyecto de control robótico de manos

 #include  #ifdef __AVR__ #include  # endif # include  #include  #include  #include  int rf_cen =9; // chip nRF24 habilita pinint rf_cs =8; // nRF24 CS pinRF24 rf (rf_cen, rf_cs); // dirección de tubería - codificada en uECG sideuint8_t pipe_rx [8] ={0x0E, 0xE6, 0x0D, 0xA7, 0, 0, 0, 0}; // ¿Qué pin en el ¿Arduino está conectado a los NeoPixels? #Define PIN 5 // ¿Cuántos NeoPixels están conectados al Arduino? #Define NUMPIXELS 16Adafruit_NeoPixel pixels =Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); uint8_t8 swap_bits a la dirección usa el orden de los bits intercambiados // invierte el orden de los bits en un solo byte uint8_t v =0; si (a &0x80) v | =0x01; si (a &0x40) v | =0x02; si (a &0x20) v | =0x04; si (a &0x10) v | =0x08; si (a &0x08) v | =0x10; si (a &0x04) v | =0x20; si (a &0x02) v | =0x40; si (a &0x01) v | =0x80; return v;} void setup () {pixels.begin (); // Esto inicializa la biblioteca NeoPixel. para (int i =0; i  0) // si es así - almacenarlo como nuevo BPM recibido rf_bpm =bb; } ms largo =milis (); if (ms - last_pix_upd> 10) // no actualice los píxeles con demasiada frecuencia {int r, g, b; last_pix_upd =ms; int bpm =rf_bpm; int max_bright =160; // valor de brillo máximo, máximo 255. Pero no siempre lo quieres al máximo :) float dd =25; // 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     
 

 Sin documento. 
   nrf24_led_ring_o2Gij5oigT.fzz 
 

            


            

               Gráficos TFT:Gráficos del historial en vivo        
                Sistema de alumbrado público inteligente basado en IoT