KY-039 Herzschlagsensor

////////////////////////////////////////////////////////////////////////
/// Copyright (c)2015 Dan Truong
/// Permission is granted to use this software under the MIT
/// licence, with my name and copyright kept in source code
/// http://http://opensource.org/licenses/MIT
///
/// KY039 Arduino Heartrate Monitor V1.0 (April 02, 2015)
////////////////////////////////////////////////////////////////////////
  
////////////////////////////////////////////////////////////////////////
/// @param[in] IRSensorPin Analog PI an welchen der Sensor angeschlossen ist
/// @param[in] delay (msec) Die Verzoegerung zwischen den Aufrufen der Abtastfunktion.
//                   Die besten Ergebnisse erhaelt man, wenn man 5 mal Pro Herzschlag abtastet.
///                  Nicht langsamer als 150mSec für z.B. 70 BPM Puls
///                  Besser waere 60 mSec für z.B. bis zu einen Puls von 200 BPM.
///
/// @Kurzbeschreibung
/// Dieser Code stellt eine sog. Peak-Detection dar.
/// Es wird kein Herzschlagverlauf aufgezeichnet, sondern es
/// wird innerhalb der aufgezeichneten Daten nach "Peaks" (Spitzen) gesucht, 
/// und per LED angezeigt. Mittels der bekannten Delay Abstaende, kann somit
/// grob der Puls errechnet werden.
////////////////////////////////////////////////////////////////////////
  
int rawValue;

bool heartbeatDetected(int IRSensorPin, int delay) {
  static int maxValue = 0;
  static bool isPeak = false;
  bool result = false;
  rawValue = analogRead(IRSensorPin);
  // Hier wird der aktuelle Spannungswert am Fototransistor ausgelesen und in der rawValue-Variable zwischengespeichert
  rawValue *= (1000/delay);
  // Sollte der aktuelle Wert vom letzten maximalen Wert zu weit abweichen
  // (z.B. da der Finger neu aufgesetzt oder weggenommen wurde)
  // So wird der MaxValue resetiert, um eine neue Basis zu erhalten.
  if (rawValue * 4L < maxValue) maxValue = rawValue * 0.8; // Neue Spitzenwerte erkennen
  if (rawValue > maxValue - (1000/delay)) {
    // Hier wird der eigentliche Peak detektiert. Sollte ein neuer RawValue groeßer sein
    // als der letzte maximale Wert, so wird das als Spitze der aufgezeichnten Daten erkannt.
    if (rawValue > maxValue) {
      maxValue = rawValue;
    }
    // Zum erkannten Peak soll nur ein Herzschlag zugewiesen werden
    if (isPeak == false) {
      result = true;
    }
    isPeak = true;
  } 
  else if (rawValue < maxValue - (3000/delay)) {
    isPeak = false;
    // Hierbei wird der maximale Wert bei jeden Durchlauf
    // etwas wieder herabgesetzt. Dies hat den Grund, dass
    // nicht nur der Wert sonst immer stabil bei jedem Schlag
    // gleich oder kleiner werden wuerde, sondern auch,
    // falls der Finger sich minimal bewegen sollte und somit
    // das Signal generell schwaecher werden wuerde.
    maxValue-=(1000/delay);
 }
  return result;
}
////////////////////////////////////////////////////////////////////////
// Arduino Hauptprogramm
////////////////////////////////////////////////////////////////////////
int ledPin=13;
int analogPin=0;

void setup() {
  // Die eingebaute Arduino LED (Digital 13), wird hier zur Ausgabe genutzt
  pinMode(ledPin,OUTPUT);
  // Serielle Ausgabe Initialisierung
  Serial.begin(9600);
  Serial.println("KY-039 Herzschlagmessung");
}
const int delayMsec = 60; // 100msec pro Probe
// Das Hauptprogramm hat zwei Aufgaben: 
// - Wird ein Herzschlag erkannt, so blinkt die LED kurz aufgesetzt
// - Der Puls wird errechnet und auf der serriellen Ausgabe ausgegeben.
  
void loop() {
  static int beatMsec = 0;
  int heartRateBPM = 0;
  if (heartbeatDetected(analogPin, delayMsec)) {
    heartRateBPM = 60000 / beatMsec;
    // LED-Ausgabe bei Herzschlag
    digitalWrite(ledPin,1);
    // zu hohe oder zu niedrige Werte ausschließen
    if (heartRateBPM > 30 && heartRateBPM < 200){
      // Serielle Datenausgabe
      Serial.print("Puls erkannt: ");
      Serial.println(heartRateBPM);
    }
    beatMsec = 0;
  } 
  else {
    digitalWrite(ledPin,0);
  }
  delay(delayMsec);
  beatMsec += delayMsec;
}

Der Herzschlagsensor detektiert den Puls, wenn ein Finger zwischen die Infrarot-Leuchtdiode und den Foto-Transistor gehalten wird. Am Signalausgang kann der Puls dann abgelesen werden.

Die Funktionsweise eines Fototransistors ist wie folgt: Ein Fototransistor funktioniert ähnlich wie ein normaler Transistor, bei dem ein höherer Strom durch ihn fließt, je höher die an ihn angelegte Steuerspannung ist. Bei einem Fototransistor stellt jedoch das einfallende Licht die Steuerspannung dar. Das bedeutet, je mehr Licht auf den Fototransistor trifft, desto mehr Strom lässt er durch. In diesem Sensor wird die Veränderung der Lichtmenge, die durch den Blutfluss im Finger verursacht wird, vom Fototransistor erfasst und in ein Signal umgewandelt, das zur Pulsdetektion verwendet werden kann.

Dieser Sensor ist ideal für Projekte, bei denen die Herzfrequenzüberwachung erforderlich ist, wie z.B. in Fitness-Tracker, Gesundheitsüberwachungssystemen oder anderen biometrischen Anwendungen.

Schaltet man vor dem Transistor einen Widerstand in Reihe, so ergibt sich folgendes Verhalten, wenn man die Spannung über den Transistor misst: Scheint auf den Transistor viel Licht bzw. ist es außen hell, so kann man eine niedrige Spannung nahe 0V gemessen - ist der Transistor im Dunklen, so lässt dieser einen relativ kleinen Strom durch und man misst eine Spannung nahe +V.

Der bei diesem Sensormodul aufgebaute Messaufbau mit Infrarotdiode und Fototransistor ermöglicht uns nun den Puls zu messen, indem ein Finger zwischen Diode und Transistor gelegt wird. Erklärung: genauso wie man es von der Taschenlampe kennt, kann die Haut an der Hand durchleuchtet werden. Trifft man beim Durchleuchten auf eine Blutader, so kann man ganz schwach das Pumpen des Blutes erkennen. Dieses Pumpen erkennt man, da das Blut an unterschiedlichen Stellen in der Ader eine andere Dichte besitzt und somit Helligkeitsunterschiede beim Blutfluss erkennbar sind. Genau diese Unterschiede in der Helligkeit kann man mit dem Sensormodul aufnehmen und somit den Puls erkennen. Deutlich wird dieses beim Betrachten des folgenden Oszilloskop-Bildes.

Dieses zeigt auf der Y-Achse die Veränderung der Spannung am Fototransistor - somit die Helligkeitsveränderungen hervorgerufen durch das fließende Blut. Die oben gekennzeichneten Spitzen ergeben somit das Schlagen vom Herz. Rechnet man nun die registrierten Schläge pro aufgenommene Zeit, so kommt man auf einen Puls von ca. 71 Schläge/Minute (bpm)

Wie man auf dem oberen Oszilloskop-Bild zudem sehen kann, ist das aufgenommene Signal relativ klein bzw. der Transistor sehr empfindlich, um das schwache Signal aufnehmen zu können. Um ein optimales Ergebnis zu erhalten, empfehlen wir das Modul zum Messen so vorzubereiten, wie in den folgenden Bildern gezeigt:

Um die Empfindlichkeit des Sensors zu erhöhen, empfehlen wir den Sensor mittels eines Pflasters / Klebebandes / Isolierbandes an der Fingerkuppe des kleinen Fingers zu fixieren.

Der Herzschlag wird besonders gut aufgezeichnet/registriert, wenn sich der Sensor über einem größeren Blutgefäß befindet - um das Signal zu verbessern, empfehlen wir zudem die Position des Sensors gegeben falls auf der Fingerkuppe zu verändern.

Pin-Belegung

Kabelfarbe	Kabelbedeutung
Schwarz	Signal
Blau	+V
Grau	GND

Raspberry Pi	Sensor
3,3 V [Pin 1]	+V
GND [Pin 6]	GND
-	Signal

Sensor	KY-053
Signal	A0
+V	-
GND	-

Raspberry Pi	KY-053
GPIO 3 [Pin 5]	SCL
GPIO 2 [Pin 3]	SDA
3,3 V [Pin 1]	VDD
GND [Pin 6]	GND

Analoger Sensor, daher muss folgendes beachtet werden

Der Raspberry Pi besitzt im Gegensatz zum Arduino keine analogen Eingänge bzw. es ist kein ADC (analog digital Converter) im Chip des Raspberry Pi's integriert. Dies schränkt den Raspberry Pi ein, wenn man Sensoren einsetzen möchte, wo nicht digital Werte ausgegeben werden [Spannungswert überschritten -> digital EIN | Spannungswert unterschritten -> digital AUS | Beispiel: Knopf gedrückt [EIN] Knopf losgelassen [AUS]], sondern es sich hier um einen kontinuierlichen veränderlichen Wert handeln sollte (Beispiel: Potentiometer -> Andere Position = Anderer Spannungswert)

Um diese Problematik zu umgehen, besitzt unser Sensorkit X40 mit dem KY-053 ein Modul mit 16 Bit genauen ADC, welches Sie am Raspberry nutzen können, um diesen um 4 analoge Eingänge erweitern zu können. Dieses wird per I2C an den Raspberry Pi angeschlossen, übernimmt die analoge Messung und gibt den Wert digital an den Raspberry Pi weiter.

Somit empfehlen wir, bei analogen Sensoren dieses Sets das KY-053 Modul mit dem besagten ADC dazwischenzuschalten. Nähere Informationen finden Sie auf der Informationsseite zum KY-053 Analog Digital Converter

Code-Beispiel

Das Programm nutzt zur Ansteuerung des ADS1115 ADC die entsprechenden ADS1x15 und I2C Python-Libraries von Adafruit. Diese wurden unter dem folgenden Link https://github.com/adafruit/Adafruit_CircuitPython_ADS1x15 unter der MIT-Lizenz veröffentlicht. Die benötigten Libraries sind nicht im unteren Download-Paket enthalten.

Bitte beachten Sie das Sie vor der benutzung dieses Beispiels I2C auf ihrem Raspberry Pi aktivieren müssen.

import time
import board
import busio
import adafruit_ads1x15.ads1115 as ADS
from adafruit_ads1x15.analog_in import AnalogIn

# Create the I2C bus
i2c = busio.I2C(board.SCL, board.SDA)

# Create the ADC object using the I2C bus
ads = ADS.ADS1115(i2c)

# Create single-ended input on channels
chan0 = AnalogIn(ads, ADS.P0)
chan1 = AnalogIn(ads, ADS.P1)
chan2 = AnalogIn(ads, ADS.P2)
chan3 = AnalogIn(ads, ADS.P3)

if __name__ == '__main__':

   
    # initialization 
    GAIN = 2/3  
    curState = 0
    thresh = 525  # mid point in the waveform
    P = 512
    T = 512
    stateChanged = 0
    sampleCounter = 0
    lastBeatTime = 0
    firstBeat = True
    secondBeat = False
    Pulse = False
    IBI = 600
    rate = [0]*10
    amp = 100

    lastTime = int(time.time()*1000)

    # Main loop. use Ctrl-c to stop the code
    while True:
        # read from the ADC
        Signal = chan0.value   #TODO: Select the correct ADC channel. I have selected A0 here
        curTime = int(time.time()*1000)

        sampleCounter += curTime - lastTime;      ## keep track of the time in mS with this variable
        lastTime = curTime
        N = sampleCounter - lastBeatTime;     #  # monitor the time since the last beat to avoid noise
       

        ##  find the peak 
        if Signal < thresh and N > (IBI/5.0)*3.0 :  #       # avoid dichrotic noise by waiting 3/5 of last IBI
            if Signal < T :                        # T is the trough
              T = Signal;                         # keep track of lowest point in pulse wave 

        if Signal > thresh and  Signal > P:           # thresh condition helps avoid noise
            P = Signal;                             # P is the peak
                                                # keep track of highest point in pulse wave

         
          # signal surges up in value every time there is a pulse
        if N > 250 :                                   # avoid high frequency noise
            if  (Signal > thresh) and  (Pulse == False) and  (N > (IBI/5.0)*3.0)  :       
              Pulse = True;                               # set the Pulse flag when we think there is a pulse
              IBI = sampleCounter - lastBeatTime;         # measure time between beats in mS
              lastBeatTime = sampleCounter;               # keep track of time for next pulse

              if secondBeat :                        # if this is the second beat, if secondBeat == TRUE
                secondBeat = False;                  # clear secondBeat flag
                for i in range(0,10):             # seed the running total to get a realisitic BPM at startup
                  rate[i] = IBI;                      

              if firstBeat :
                firstBeat = False;                   
                secondBeat = True;
                continue                              


              # keep a running total of the last 10 IBI values
              runningTotal = 0;                  # clear the runningTotal variable    

              for i in range(0,9):                # shift data in the rate array
                rate[i] = rate[i+1];                   
                runningTotal += rate[i];              

              rate[9] = IBI;                          
              runningTotal += rate[9];                
              runningTotal /= 10;                     
              BPM = 60000/runningTotal;               
              print ('BPM: {}'.format(BPM))

        if Signal > thresh and Pulse == True :   # when the values are going down, the beat is over
            Pulse = False;                         
            amp = P - T;                           
            thresh = amp/2 + T;                    
            P = thresh;                            
            T = thresh;

        if N > 2500 :                          # if 2.5 seconds go by without a beat
            thresh = 512;                          # set thresh default
            P = 512;                               # set P default
            T = 512;                               # set T default
            lastBeatTime = sampleCounter;          # bring the lastBeatTime up to date        
            firstBeat = True;                      # set these to avoid noise
            secondBeat = False;                    # when we get the heartbeat back
            print ("no beats found")

        time.sleep(0.005)

Beispielprogramm Download

KY039-RPi.zip

Zu starten mit dem Befehl:

sudo python3 KY039.py

	
		let hrNo = 0
		let d = 0
		let c = 0
		let b = 0
		let a = 0
		let bpm = 0
		basic.showIcon(IconNames.Heart)
		serial.setBaudRate(BaudRate.BaudRate115200)
		pins.analogSetPeriod(AnalogPin.P2, 20000)
		let timer = 0
		let peakCount = 0
		basic.forever(function () {
		    for (let index = 0; index < 5; index++) {
		        timer += 1
		        basic.pause(1000)
		    }
		    bpm = peakCount / 5 * 6
		    timer = 0
		    peakCount = 0
		    serial.writeLine("BPM is " + Math.round(bpm))
		    basic.pause(1000)
		})
		basic.forever(function () {
		    a = pins.analogReadPin(AnalogPin.P2)
		    basic.pause(20)
		    b = pins.analogReadPin(AnalogPin.P2)
		    basic.pause(20)
		    c = pins.analogReadPin(AnalogPin.P2)
		    basic.pause(20)
		    d = pins.analogReadPin(AnalogPin.P2)
		    basic.pause(20)
		    hrNo = (a + b + c + d) / 4
		    serial.writeNumber(hrNo)
		    if (hrNo > 520) {
		        peakCount += 1
		    }
		    serial.writeLine("")
		})
	

# Importieren der Bibliotheken
from machine import ADC
import utime

# GPIO26 als Analogeingang verwenden
analog_pin = ADC(0)  

# Initialisierungsvariablen
raw_value = 0
max_value = 0
is_peak = False

# Funktion zum Erkennen eines Herzschlags
def heartbeat_detected(ir_sensor_pin, delay_msec):
    global raw_value, max_value, is_peak
    
    result = False
    # Lesen des aktuellen Spannungswerts (0 bis 65535)
    raw_value = ir_sensor_pin.read_u16()
    # Anpassen des Werts an die Verzögerung
    raw_value = (raw_value * 1000) // delay_msec 
    
    # Reset des Maximalwerts, wenn der Unterschied zu groß ist
    if raw_value * 4 < max_value:
        max_value = int(raw_value * 0.8)
    
    # Peak-Erkennung
    if raw_value > max_value - (1000 // delay_msec):
        if raw_value > max_value:
            max_value = raw_value
        # Zum erkannten Peak soll nur ein Herzschlag zugewiesen werden
        if not is_peak:
            result = True
        is_peak = True
    elif raw_value < max_value - (3000 // delay_msec):
        is_peak = False
        # Hierbei wird der maximale Wert bei jeden Durchlauf
        # etwas wieder herabgesetzt. Dies hat den Grund, dass
        # nicht nur der Wert sonst immer stabil bei jedem Schlag
        # gleich oder kleiner werden wuerde, sondern auch,
        # falls der Finger sich minimal bewegen sollte und somit
        # das Signal generell schwaecher werden wuerde.
        max_value -= 1000 // delay_msec
    
    return result

# Verzögerung in Millisekunden pro Abtastung
delay_msec = 60
beat_msec = 0

print("KY-039 Herzschlagmessung")

while True:
    heart_rate_bpm = 0
    if heartbeat_detected(analog_pin, delay_msec):
        # Nur Herzschlag berechnen, wenn beat_msec nicht 0 ist
        if beat_msec > 0:
            heart_rate_bpm = 60000 // beat_msec       
        # Puls nur ausgeben, wenn er im realistischen Bereich liegt
        if 30 < heart_rate_bpm < 200:
            print("Puls erkannt: {} BPM".format(heart_rate_bpm))
        # Nach der Erkennung zurücksetzen
        beat_msec = 0  
        
    utime.sleep_ms(delay_msec)
    beat_msec += delay_msec