Indicateur de battements cardiaques utilisant l'ECG

Outils et machines nécessaires

Fer à souder (générique)

À propos de ce projet

Pendant de nombreuses années, je voulais juste faire quelque chose avec des LED qui clignotent au rythme de mes battements de cœur (et pas seulement lorsque je reste parfaitement immobile, tout en sautant un battement ici et là). Cela s'est avéré étonnamment difficile, j'ai essayé et échoué pendant des années. Mais plus maintenant !

En fait, tout le travail lourd est effectué par uECG - un petit appareil ECG portable qui est open source et dispose d'une broche de sortie compatible Arduino (cette broche devient haute/basse à chaque battement de cœur). Le traitement de ces états de broche est beaucoup plus facile que le traitement du signal ECG, et j'ai essayé d'en tirer le meilleur parti.
UPD :vous voudrez peut-être vérifier la 2e itération de ce projet, qui reçoit des données via une liaison radio.

1. Schémas
Comme nous ne travaillons ici qu'avec des signaux numériques, c'est très simple. Mais en tant que portable, il serait beaucoup plus fiable (et plus petit) si la plupart des connexions étaient soudées - pour un test rapide, ce n'est pas nécessaire, mais si vous comptez le porter pendant une activité intense, je le recommande vivement.
Le schéma ressemble à ceci :

• La broche DI de l'anneau LED va à la broche D11 (configurable dans le code)
• La broche DRV de l'appareil uECG va à la broche D3 (également configurable)
• La batterie + va aux entrées Arduino 5V et anneau LED 5V
• Batterie - va à Arduino GND, ring GND et uECG's GND

J'ai utilisé une batterie LiPo directement comme entrée 5V - il n'y a pas d'erreur, si vous la connectez à Vin - cela ne fonctionnera pas de manière fiable (le régulateur de tension sur Vin introduit une chute de tension et nous ne pouvons absolument pas nous en permettre une ici). Le fait est qu'Arduino est stable tant que la tension d'entrée ne descend pas en dessous de 3,4 volts. La batterie LiPo commence à 4,2 volts lorsqu'elle est complètement chargée et n'atteint à 3,4 volts que lorsqu'il reste moins de 15 % de charge. Ainsi, avec toute batterie supérieure à ~ 200 mAh, vous pouvez obtenir une durée de fonctionnement décente. En dehors de cela, veuillez garder à l'esprit que la batterie doit être connectée via un connecteur :) Parce que vous voulez la déconnecter des schémas et la charger de temps en temps.

2. Code
Le programme fonctionne de manière simple :il lit constamment la broche D3 et, lorsqu'un changement est détecté, il pousse l'heure de ce changement dans un tableau de 20 éléments. La différence entre le premier et le dernier élément, divisée par 20, est le temps moyen par battement (en millisecondes). Donc, diviser 1 minute (60000 millisecondes) par ce nombre nous donne la valeur BPM. Vous pouvez ajuster le nombre d'éléments dans le tableau. Un plus petit nombre d'éléments conduirait à une réponse plus rapide, mais des résultats moins stables (tout problème de détection de battement conduirait à un saut important dans le BPM calculé). Un nombre plus élevé d'éléments donnerait des données plus stables, mais une réponse plus lente lorsque le BPM change rapidement.

Ensuite, le BPM est mappé en couleur (bleu->vert->jaune->rose->rouge lorsque le BPM passe de bas en haut) et en nombre de LED :pour 80 BPM, huit segments sont allumés, pour 110 - onze et ainsi de suite (échelle également réglable dans le code).

#include 
#ifdef __AVR__
#include 
#endif
// Broche DI de l'anneau LED 
#define PIN 11
// nombre de pixels dans l'anneau
#define NUMPIXELS 16
// pin d'entrée pour connecter uECG
int in_pin =3;
Adafruit_NeoPixel pixels =Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
void setup() {
pixels.begin(); // Ceci initialise la bibliothèque NeoPixel.
pinMode(in_pin, INPUT); //définir la broche en mode d'entrée
digitalWrite(in_pin, 1); //activer PULLUP :c'est critique, uECG n'a pas de pull-up interne
}
//nous stockons les 20 derniers battements cardiaques pour faire la moyenne des BPM sur eux
//avec une valeur plus élevée, il deviendra plus fiable,
//mais il faudra plus de temps pour voir le changement de sortie lorsque le BPM change
#define BEAT_HIST 20
long beats[BEAT_HIST] ;
void push_beat(long ms) //décaler tous les battements du tableau et insérer le battement actuel
{
for(int x =0; x {
beats[x] =beats[x+1];
}
beats[BEAT_HIST-1] =ms;
}
int get_bpm() //utilisation de la différence de temps entre le premier et le dernier temps
{
dt long =beats[BEAT_HIST-1] - beats[0] ;
bpm long =BEAT_HIST * 60000 / dt ;
bpm de retour ;
}
long last_pix_upd =0; //pour garder une trace de quand nous avons mis à jour les pixels la fois précédente
int prev_in_state =0; //état précédent de la broche d'entrée :nous voulons traiter uniquement les changements d'état
void loop()
{
long ms =millis();
int in_state =digitalRead(in_pin ); // lorsqu'aucun battement n'est détecté, 0 en battement
if(in_state ==1 &&prev_in_state ==0) //réagir uniquement au changement
{
push_beat(ms);
}
prev_in_state =in_state;
if(ms - last_pix_upd> 10) //ne met pas à jour les pixels trop souvent
{
int r, g, b;
last_pix_upd =ms;
int bpm =get_bpm();
int max_bright =120; //valeur de la luminosité maximale, max 255. Mais vous ne la voulez pas toujours au max :)
float dd =20; //changement de BPM entre les tons de couleur (bleu->vert->jaune->rose->rouge)
float t1 =90, t2, t3, t4 ; //t1 - "base" BPM, inférieur à t1 serait bleu
t2 =t1 + dd;
t3 =t2 + dd;
t4 =t3 + dd;
/ /code pour changer de couleur selon dans quelle plage t1...t4 nous sommes maintenant
if(bpm sinon if(bpm else if(bpm else if(bpm else {r =max_bright; g =0 ; b =0 ; }
if(in_state) //lorsqu'il n'est pas en temps, 1/4 d'intensité, donc seuls les temps sont mis en évidence
{
r *=0.25;
g *=0.25;
b *=0.25;
}
int on_pixels =(bpm+5)/10 ; //nombre de LED utilisées :pour 60 BPM, 6 LED seront allumées, pour 120 - 12 etc
for(int i=0;i{
if( i else pixels.setPixelColor(i, pixels.Color(0,0,0)); //éteindre toutes les autres LED
}
pixels.show();
}
} 

3. Assemblage en tant que wearable
Il est pratique de placer Arduino à l'intérieur de l'anneau - il correspond presque parfaitement à la taille. La batterie s'adapte également à proximité. N'oubliez pas que l'uECG est placé sur un coffre - vous avez donc besoin d'un fil avec des connecteurs, vous le placez d'abord, puis vous mettez une chemise avec d'autres composants, puis vous branchez le connecteur. Sinon, ce serait vraiment gênant de le mettre - croyez-moi, j'ai essayé ))

C'est fondamentalement tout - si tout a été fait correctement, dans les 30 secondes après avoir branché tous les connecteurs, il commencera à clignoter et indiquera BPM.

4. Tests sur le terrain
Je l'ai testé en marchant et en courant - et j'ai constaté que pendant la course, la batterie rebondit juste sur le capteur ECG, déformant ses lectures. Quand j'ai tout déplacé un peu, il s'est avéré que le fil reliant uECG à Arduino est trop court et qu'il tire le capteur ECG à chaque étape, déformant à nouveau les lectures. Dans l'ensemble, j'ai obtenu des battements fiables uniquement en marchant et en restant debout, mais pas en courant - mais je pense que je vais améliorer cela. Le capteur lui-même, lorsque je l'ai utilisé avec une chemise différente, affichait également le BPM correctement pendant la course (vérifié via son application).

De plus, il s'avère que les LED sur un coffre peuvent sembler cool mais sont pratiquement inutiles. C'est vraiment gênant de regarder en bas pour vérifier son pouls. Je pense que dans la prochaine itération, je ferai une sorte de bracelet qui indiquera les battements à la place.

P.S. Si vous êtes intéressé par le projet uECG - vous pouvez consulter sa page hackaday, il y a beaucoup de détails techniques, des conceptions de PCB, des discussions et des journaux de projet

Code

• uECG_pixel_ring.ino

uECG_pixel_ring.inoArduino

#include #ifdef __AVR__ #include #endif// Broche DI de l'anneau LED#define PIN 11// nombre de pixels dans l'anneau#define NUMPIXELS 16// input broche pour connecter uECGint in_pin =3; Adafruit_NeoPixel pixels =Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);void setup() { pixels.begin(); // Ceci initialise la bibliothèque NeoPixel. pinMode(in_pin, INPUT); //définir la broche sur le mode d'entrée digitalWrite(in_pin, 1); //activer PULLUP :c'est critique, uECG n'a pas de pull-up interne}//nous stockons les 20 derniers battements cardiaques pour faire la moyenne des BPM sur eux//avec une valeur plus élevée, cela deviendra plus fiable,//mais cela prendra plus temps pour voir le changement de sortie lorsque le BPM change#define BEAT_HIST 20long beats[BEAT_HIST];void push_beat(long ms) //décaler tous les battements dans le tableau et insérer celui actuel{ for(int x =0; x  10) //ne met pas à jour les pixels trop souvent { int r, g, b; last_pix_upd =ms; int bpm =get_bpm(); int max_brillant =120 ; //valeur de la luminosité maximale, max 255. Mais vous ne voulez pas toujours qu'elle soit au max :) float dd =20; //changement de BPM entre les tons de couleur (bleu->vert->jaune->rose->rouge) float t1 =90, t2, t3, t4; //t1 - "base" BPM, inférieur à t1 serait bleu t2 =t1 + dd; t3 =t2 + jj ; t4 =t3 + jj ; //code pour changer de couleur en fonction de la plage t1...t4 dans laquelle nous sommes maintenant if(bpm  

Schémas