Hartslagindicator met ECG

Over dit project

Jarenlang wilde ik gewoon iets maken met LED's die naar mijn hartslag knipperen (en niet alleen als ik doodstil zit, en toch hier en daar een slag oversla). Dat bleek verrassend moeilijk, ik heb het jarenlang geprobeerd en faalde. Maar niet meer!

Eigenlijk wordt al het zware werk gedaan door uECG - een klein draagbaar ECG-apparaat dat open source is en een Arduino-vriendelijke output-pin heeft (die pin gaat hoog/laag met elke hartslag). Het verwerken van deze pinstatussen is veel eenvoudiger dan het verwerken van het ECG-signaal, en ik heb geprobeerd er het maximale uit te halen.
UPD:misschien wilt u de tweede versie van dit project controleren, dat gegevens ontvangt via een radioverbinding.

1. Schema's
Omdat we hier alleen met digitale signalen werken, is het heel eenvoudig. Maar als wearable zou het veel betrouwbaarder (en kleiner) zijn als de meeste verbindingen gesoldeerd zijn - voor een snelle test is het niet nodig, maar als je het tijdens een zware activiteit gaat dragen, raad ik dat ten zeerste aan.
Schema's zien er als volgt uit:

• DI-pin van de LED-ring gaat naar pin D11 (configureerbaar in de code)
• DRV-pin van het uECG-apparaat gaat naar pin D3 (ook configureerbaar)
• Batterij + gaat naar Arduino 5V en LED-ring 5V-ingangen
• Batterij - gaat naar Arduino GND, ring GND en uECG's GND

Ik heb de LiPo-batterij rechtstreeks als 5V-ingang gebruikt - er is geen fout, als je hem op Vin aansluit - hij zal niet betrouwbaar werken (spanningsregelaar op Vin introduceert spanningsval en we kunnen er hier absoluut geen betalen). Het punt is dat Arduino stabiel is zolang de ingangsspanning niet onder de 3,4 volt komt. LiPo-batterij begint bij 4,2 volt wanneer deze volledig is opgeladen en bereikt alleen 3,4 volt als er minder dan 15% over is. Dus met elke batterij groter dan ~200 mAh kunt u een behoorlijke bedrijfstijd krijgen. Houd er verder rekening mee dat de batterij moet worden aangesloten via een, nou ja, connector :) Omdat je hem wilt loskoppelen van schema's en af ​​en toe wilt opladen.

2. Code
Het programma werkt op een eenvoudige manier:het leest constant de D3-pin, en wanneer verandering wordt gedetecteerd, duwt het de tijd van die verandering in een array van 20 elementen. Het verschil tussen het eerste en het laatste element, gedeeld door 20, is de gemiddelde tijd per slag (in milliseconden). Dus als we 1 minuut (60000 milliseconden) delen door dat getal, krijgen we de BPM-waarde. U kunt het aantal elementen in de array aanpassen. Een kleiner aantal elementen zou leiden tot een snellere respons, maar minder stabiele resultaten (elk probleem in de beatdetectie zou leiden tot een grote sprong in de berekende BPM). Een hoger aantal elementen zou stabielere gegevens opleveren, maar een langzamere respons wanneer de BPM snel verandert.

Vervolgens wordt BPM in kleur weergegeven (blauw->groen->geel->roze->rood wanneer BPM van laag naar hoog gaat) en in aantal LED's:voor 80 BPM zijn acht segmenten aan, voor 110 - elf enzovoort (schaal ook instelbaar in de code).

#include 
#ifdef __AVR__
#include 
#endif
// DI-pin van LED-ring 
#define PIN 11
// aantal pixels in de ring
#define NUMPIXELS 16
// input pin voor aansluiten uECG
int in_pin =3;
Adafruit_NeoPixel pixels =Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
void setup() {
pixels.begin(); // Dit initialiseert de NeoPixel-bibliotheek.
pinMode(in_pin, INPUT); // zet de pin in de invoermodus
digitalWrite(in_pin, 1); //PULLUP inschakelen:dit is van cruciaal belang, uECG heeft geen interne pull-up
}
//we slaan de laatste 20 hartslagen op om de BPM erover te berekenen
//met een hogere waarde, het wordt betrouwbaarder,
//maar het zal meer tijd kosten om de output te zien veranderen als de BPM verandert
#define BEAT_HIST 20
lange beats[BEAT_HIST];
void push_beat(long ms) // verschuif alle beats in de array en voeg de huidige in
{
for(int x =0; x {
beats[x] =beats[x+1];
}
beats[BEAT_HIST-1] =ms;
}
int get_bpm() //gebruik van tijdsverschil tussen eerste en laatste beats
{
lange dt =beats[BEAT_HIST-1] - beats[0];
lange bpm =BEAT_HIST * 60000 / dt;
return bpm;
}
Lange last_pix_upd =0; //om bij te houden wanneer we de vorige keer pixels hebben bijgewerkt
int prev_in_state =0; //vorige status van invoerpin:we willen alleen statuswijzigingen verwerken
void loop()
{
long ms =millis();
int in_state =digitalRead(in_pin ); //1 als er geen beat wordt gedetecteerd, 0 in beat
if(in_state ==1 &&prev_in_state ==0) //alleen reageren om te veranderen
{
push_beat(ms);
}
prev_in_state =in_state;
if(ms - last_pix_upd> 10) //update pixels niet te vaak
{
int r, g, b;
last_pix_upd =ms;
int bpm =get_bpm();
int max_bright =120; // waarde van maximale helderheid, max 255. Maar je wilt het niet altijd op max :)
float dd =20; //verandering in BPM tussen kleurtonen (blauw->groen->geel->roze->rood)
float t1 =90, t2, t3, t4; //t1 - "basis" BPM, lager dan t1 zou blauw zijn
t2 =t1 + dd;
t3 =t2 + dd;
t4 =t3 + dd;
/ /code voor het veranderen van kleur afhankelijk van in welk t1...t4 bereik we ons nu bevinden
if(bpm else if(bpm else if(bpm else if(bpm anders {r =max_bright; g =0; b =0; }
if(in_state) //wanneer niet in beat, 1/4 intensiteit, dus alleen beats worden gemarkeerd
{
r *=0.25;
g *=0.25;
b *=0.25;
}
int on_pixels =(bpm+5)/10; //aantal gebruikte LED's:voor 60 BPM zullen 6 LED's branden, voor 120 - 12 enz.
for(int i=0;i{
if( i else pixels.setPixelColor(i, pixels.Color(0,0,0)); //zet alle andere LED's uit
}
pixels.show();
}
} 

3. Assembleren als wearable
Het is handig om Arduino in de ring te plaatsen - het komt bijna perfect overeen met de grootte. Batterij past ook in de buurt. Vergeet niet dat uECG op een kist wordt geplaatst - dus je hebt een draad met connectoren nodig, eerst plaats je deze, dan trek je een shirt aan met andere componenten en dan sluit je de connector aan. Anders zou het erg lastig zijn om het aan te doen - geloof me, ik heb het geprobeerd ))

Dat is het eigenlijk - als alles goed is gedaan, begint het binnen 30 seconden nadat je alle connectoren hebt aangesloten te knipperen en geeft het BPM aan.

4. Veldtesten
Ik heb het getest tijdens het lopen en rennen - en ontdekte dat tijdens het hardlopen de batterij recht over de ECG-sensor stuitert, waardoor de meetwaarden worden vervormd. Toen ik het allemaal een beetje bewoog, bleek dat de draad die uECG met Arduino verbindt, te kort is en trekt bij elke stap de ECG-sensor, waardoor de metingen opnieuw worden vervormd. Over het algemeen kreeg ik alleen betrouwbare beats bij het lopen en staan, maar niet bij het rennen - maar ik denk dat ik dat zal verbeteren. Sensor zelf, wanneer ik hem met een ander shirt gebruikte, gaf de BPM ook correct weer tijdens het hardlopen (gecontroleerd via de app).

Het blijkt ook dat LED's op een kist er misschien cool uitzien, maar praktisch nutteloos zijn. Het is echt onhandig om naar beneden te kijken om je hartslag te controleren. Ik denk dat ik in de volgende iteratie een soort polsarmband zal maken die in plaats daarvan beats aangeeft.

PS Als u geïnteresseerd bent in uECG-project, kunt u de hackaday-pagina bekijken, er zijn veel technische details, PCB-ontwerpen, discussies en projectlogboeken

#include #ifdef __AVR__ #include #endif// DI-pin van LED-ring#define PIN 11// aantal pixels in de ring#define NUMPIXELS 16// input pin voor het aansluiten van uECGint in_pin =3; Adafruit_NeoPixel pixels =Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); ongeldige setup() { pixels.begin(); // Hiermee wordt de NeoPixel-bibliotheek geïnitialiseerd. pinMode(in_pin, INPUT); // stel de pin in op de invoermodus digitalWrite (in_pin, 1); //PULLUP inschakelen:dit is van cruciaal belang, uECG heeft geen interne pull-up}//we slaan de laatste 20 hartslagen op om de BPM erover te berekenen//met een hogere waarde wordt het betrouwbaarder,//maar er zal meer nodig zijn tijd om uitvoerverandering te zien wanneer BPM verandert#define BEAT_HIST 20lange beats[BEAT_HIST];void push_beat(long ms) //shift alle beats in array en voeg huidige in{for(int x =0; x  10) // update pixels niet te vaak { int r, g, b; last_pix_upd =ms; int bpm =get_bpm(); int max_bright =120; // waarde van maximale helderheid, max 255. Maar je wilt het niet altijd op max :) float dd =20; // verandering in BPM tussen kleurtonen (blauw->groen->geel->roze->rood) float t1 =90, t2, t3, t4; //t1 - "basis" BPM, lager dan t1 zou blauw zijn t2 =t1 + dd; t3 =t2 + dd; t4 =t3 + dd; // code voor het veranderen van kleur afhankelijk van in welk t1...t4 bereik we ons nu bevinden if(bpm   
 
 Schema's