Van KY-039 tot hartslag

Met dit fragment neem ik de sensormetingen op in brokken van 20 ms, waardoor de 50 Hz-flikkering die wordt veroorzaakt door kunstlicht, wordt geëgaliseerd. Als je in een land met 60 Hz woont, gebruik dan 16,67 ms chunks. Of 16667 µs.

Omdat ik de curve al in secties van 20 ms gladstrijk, heb ik de array die ik eerder heb gebruikt niet echt nodig, maar omdat hij er is en gemakkelijk kan worden aangepast, laat ik hem daar. En het gebruik van een arraygrootte van 5 lijkt de laatste vervelende ruis te compenseren. Dit is wat ik nu heb:

Het laatste wat ik moet doen, is een deel van het herhalende patroon herkennen. Omdat de stijgende helling regelmatiger is, ga ik ervoor. Merk op hoe de waarden van de y-as in alle grafieken heel verschillend zijn. Ik kan echt niet alleen vertrouwen op absolute waarden. Ik kan alleen vertrouwen op het stijgen en dalen van de curve. Wiskundigen zouden het hebben over de afgeleide. Ik ben tevreden als ik n . vind opeenvolgende stijgende waarden, waarbij n zou een handige instelbare waarde kunnen zijn. Ik begin met 5. Hiervoor heb ik de rise_threshold constante gedefinieerd in de code. Als ik 5 opeenvolgende stijgende waarden vind, weet ik dat ik aan de onderkant van de curve naar boven sta. Ik neem de tijd. Ik wacht op een dalende curve, dan wacht ik op de volgende 5 stijgende waarden en noteer de tijd. Vervolgens print ik de bijbehorende BPM.

Ik heb een test gedaan en geteld hoe veel opeenvolgend stijgend waarden daar zijn in de kromme en gevonden uit daar waren tussen 10 en 15. Dus als Ik tel naar 5, Ik zal de meeste zeker weet Ik heb gevonden de begin van de hartslag.

Omdat ik pas na elke hartslag print, zal er niet veel worden afgedrukt. Er is meer tijd voor het uitlezen van de sensor. Ik kan meer hoogfrequent geluid opvangen, wat ik niet zal zien, omdat de plotter niet aan staat. Laten we eens kijken hoe het werkt.

De laatste code

#define samp_siz 4#define rise_threshold 5// Pulse Monitor Test Scriptint sensorPin =0;void setup() { Serial.begin(9600);}void loop (){ float reads[samp_siz], sum; lange int nu, ptr; float laatste, lezer, start; float eerste, tweede, derde, voor, print_value; bool stijgt; int stijging_telling; int n; lange int last_beat; voor (int i =0; i  before) { rise_count++; if (!rising &&rise_count> rise_threshold) { // Ok, we hebben een stijgende curve gedetecteerd, wat impliceert een hartslag. // Noteer de tijd sinds de laatste slag, houd de twee vorige // tijden bij (eerste, tweede, derde) om een ​​gewogen gemiddelde te krijgen. // De stijgende vlag voorkomt dat we dezelfde stijging detecteren // meer dan eenmaal stijgen =waar; eerste =millis () - laatste_slag; last_beat =millis(); // Bereken het gewogen gemiddelde van de hartslag // volgens de drie laatste slagen print_value =60000. / (0,4 * eerste + 0,3 * tweede + 0,3 * derde); Serial.print(print_value); Serieel.print('\n'); derde =tweede; tweede =eerste; } } else { // Ok, de curve daalt stijgend =false; stijging_count =0; } voor =laatste; ptr++; ptr %=samp_grootte; }}  

Het werkt best goed. Hier is een video.

Merk op dat de kleine RX-led op de Arduino synchroon met mijn hart knippert. Simpelweg omdat wanneer er een hartslag is, de snelheid wordt berekend en afgedrukt naar de serie, die de led knippert. Wanneer de vinger een beetje beweegt, zullen er foutlezingen zijn.

Verdere ontwikkeling

Op dit moment wordt de afgedrukte snelheid berekend op basis van de laatste drie beats. Maar het zou passender kunnen zijn om het te berekenen op basis van bijvoorbeeld een periode van 15 s. Ik zou 15 opeenvolgende snelheidswaarden kunnen opslaan, het gemiddelde kunnen berekenen, dan de vijf waarden die het verst van het gemiddelde liggen weglaten en een nieuw gemiddelde berekenen. Dit zou vrijwel een betrouwbare en stabiele meting van de hartslag opleveren.

Ik heb de sensor alleen op mijn vrouw en op mij getest. Elke stap in het verbeteren van het signaal heb ik gemaakt op basis van de vorige metingen. Iemand anders kan een ander soort hartslag hebben die een ander gevormde curve veroorzaakt, die een andere benadering nodig heeft om de beat te vinden. Misschien is het de dalende curve die gemakkelijker te herkennen is. Of helemaal bovenaan. En wat gebeurt er als de puls 180 - 200 BPM is? Het vinden van de stijgende curve is misschien lastiger.

Code

• Definitieve versie

Definitieve versieC/C++

Het programma leest de hartslag en drukt de snelheid af in het seriële venster.

#define samp_siz 4#define rise_threshold 4// Pulse Monitor Test Scriptint sensorPin =0;void setup() { Serial.begin(9600);}void loop (){ float leest [samp_siz], som; lange int nu, ptr; float laatste, lezer, start; float eerste, tweede, derde, voor, print_value; bool stijgt; int stijging_telling; int n; lange int last_beat; voor (int i =0; i  before) { rise_count++; if (!rising &&rise_count> rise_threshold) { // Ok, we hebben een stijgende curve gedetecteerd, wat impliceert een hartslag. // Noteer de tijd sinds de laatste slag, houd de twee vorige // tijden bij (eerste, tweede, derde) om een ​​gewogen gemiddelde te krijgen. // De stijgende vlag voorkomt dat we dezelfde stijging meer dan eens detecteren. stijgend =waar; eerste =millis() - laatste_slag; last_beat =millis(); // Bereken het gewogen gemiddelde van de hartslag // volgens de drie laatste slagen print_value =60000. / (0,4 * eerste + 0,3 * tweede + 0,3 * derde); Serial.print(print_value); Serieel.print('\n'); derde =tweede; tweede =eerste; } } else { // Ok, de curve daalt stijgend =false; stijging_count =0; } voor =laatste; ptr++; ptr %=samp_grootte; }} 

Schema's