KY-039 Capteur de pulsations cardiaques

////////////////////////////////////////////////////////////////////////
/// 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 broche analogique à laquelle est raccordé le capteur
/// @param[in] delay (msec) Le délai entre les appels de la fonction de balayage.
///                         Les meilleurs résultats sont obtenus si vous appelez la fonction 5 fois/pulsation
///                         Pas plus lent que 150 ms pour environ 70 pulsations/min.
///                         Un délai de 60 ms ou plus rapide pour aller lusqu'à 200 pulsations/min.
/// @Résumé
/// Sortie Vraie si une pulsation est détectée
/// Ce code détecte seulement les impulsions, il ne donne
/// pas la forme d'onde des impulsions cardiaques.
////////////////////////////////////////////////////////////////////////
  
int rawValue;

bool heartbeatDetected(int IRSensorPin, int delay) {
  static int maxValue = 0;
  static bool isPeak = false;
  bool result = false;
  rawValue = analogRead(IRSensorPin);
  // La tension au phototransistor est lue et stockée dans la variable rawValue
  rawValue *= (1000/delay);
  // Si la valeur de la dernière mesure dévie trop 
  // (par exemple parce que le doigt a été enlevé ou a bougé)
  // maxValue se réinitialise
  if (rawValue * 4L < maxValue) maxValue = rawValue * 0.8; // Détection d'un nouveau pic
  if (rawValue > maxValue - (1000/delay)) {
    // Le pic réel est détecté ici. Si une nouvelle valeur brute est plus grande
    // que la dernière valeur maximale, elle sera reconnue comme le sommet des données enregistrées.
    if (rawValue > maxValue) {
      maxValue = rawValue;
    }
    // Un seul battement de cœur doit être assigné au pic reconnu
    if (isPeak == false) {
      result = true;
    }
    isPeak = true;
  } else if (rawValue < maxValue - (3000/delay)) {
    isPeak = false;
    // Il s'agit de la valeur maximale pour chaque passe
    // légèrement réduite à nouveau. La raison en est que
    // non seulement la valeur est par ailleurs toujours stable à chaque passage
    // serait la même ou plus petite, mais aussi,
    // si le doigt ne bougeait que très peu et que, par conséquent
    // le signal deviendrait généralement plus faible.
    maxValue-=(1000/delay);
 }
  return result;
}
////////////////////////////////////////////////////////////////////////
// Code principal Arduino
////////////////////////////////////////////////////////////////////////
int ledPin=13;
int analogPin=0;

void setup() {
  // La LED Arduino intégrée (Digital 13) est utilisée ici pour la sortie.
  pinMode(ledPin,OUTPUT);
  // Initialisation de la sortie série
  Serial.begin(9600);
  Serial.println("KY-039 Mesure de la fréquence cardiaque");
}
const int delayMsec = 60; // 100msec par échantillon
// Le programme principal a deux tâches :
// - Si un battement de cœur est reconnu, la LED clignote brièvement.
// - Le pouls est calculé et transmis à la sortie série.
  
void loop() {
  static int beatMsec = 0;
  int heartRateBPM = 0;
  if (heartbeatDetected(analogPin, delayMsec)) {
    heartRateBPM = 60000 / beatMsec;
    /// Sortie d'une LED lors d'un battement de cœur
    digitalWrite(ledPin,1);
    // Exclure les valeurs trop élevées ou trop basses
    if (heartRateBPM > 30 && heartRateBPM < 200){
      // Sortie de données en série
      Serial.print("Impulsion détectée : ");
      Serial.println(heartRateBPM);
    }
    beatMsec = 0;
  } 
  else {
    digitalWrite(ledPin,0);
  }
  delay(delayMsec);
  beatMsec += delayMsec;
}

Le capteur de battements de cœur détecte le pouls lorsqu'un doigt est placé entre la diode électroluminescente infrarouge et le phototransistor. Le pouls peut alors être lu à la sortie du signal.

Le fonctionnement d'un phototransistor est le suivant : Un phototransistor fonctionne de la même manière qu'un transistor normal, dans lequel un courant plus élevé le traverse, plus la tension de commande qui lui est appliquée est élevée. Dans le cas d'un phototransistor, c'est toutefois la lumière incidente qui représente la tension de commande. Cela signifie que plus la lumière atteint le phototransistor, plus le courant qu'il laisse passer est élevé. Dans ce capteur, la variation de la quantité de lumière provoquée par le flux sanguin dans le doigt est détectée par le phototransistor et convertie en un signal qui peut être utilisé pour la détection d'impulsions.

Ce capteur est idéal pour les projets où la surveillance de la fréquence cardiaque est nécessaire, comme par exemple dans les trackers de fitness, les systèmes de surveillance de la santé ou d'autres applications biométriques.

Si vous connectez une résistance en série devant le transistor, le comportement suivant se produit lorsque vous mesurez la tension aux bornes du transistor : si le transistor est très éclairé ou s'il fait jour, vous pouvez mesurer une faible tension proche de 0V - si le transistor est dans l'obscurité, il laisse passer un courant relativement faible et vous mesurez une tension proche de +V.

Le dispositif de mesure avec diode infrarouge et phototransistor intégré dans ce module de détection nous permet maintenant de mesurer l'impulsion en plaçant un doigt entre la diode et le transistor. Explication : la peau de la main peut être éclairée de la même manière qu'avec une torche. Si vous touchez une veine sanguine en faisant passer la lumière à travers elle, vous pouvez voir le sang pomper très faiblement. Ce pompage est reconnaissable parce que le sang a une densité différente à différents endroits de la veine et que l'on peut donc voir des différences de luminosité dans le flux sanguin. Le module de détection permet d'enregistrer précisément ces différences de luminosité et de reconnaître ainsi l'impulsion. Cela devient clair en regardant l'image d'oscilloscope suivante.

L'axe des ordonnées montre le changement de tension au niveau du phototransistor, et donc les changements de luminosité causés par le sang qui coule. Les pics marqués ci-dessus montrent donc les battements du cœur. Si nous calculons maintenant les battements enregistrés par temps enregistré, nous arrivons à un pouls d'environ 71 battements/minute (bpm).

Comme vous pouvez le voir sur l'image supérieure de l'oscilloscope, le signal enregistré est relativement faible et le transistor est très sensible pour capter le signal faible. Pour obtenir un résultat optimal, nous vous recommandons de préparer le module pour la mesure comme indiqué dans les images suivantes :

Pour augmenter la sensibilité du capteur, nous recommandons de fixer le capteur au bout du petit doigt à l'aide d'un sparadrap / d'un ruban adhésif / d'un ruban isolant.

Le rythme cardiaque est particulièrement bien enregistré lorsque le capteur est placé au-dessus d'un gros vaisseau sanguin. Pour améliorer le signal, nous recommandons également de changer la position du capteur sur le bout du doigt si nécessaire.

Affectation des broches

Couleur du câble	Signification du câble
Noir	Signal
Bleu	+V
Gris	GND

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

Capteur	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

Capteur analogique, il faut donc respecter les points suivants.

Contrairement à l'Arduino, le Raspberry Pi n'a pas d'entrées analogiques ou il n'y a pas d'ADC (convertisseur analogique numérique) intégré dans la puce du Raspberry Pi. Cela limite le Raspberry Pi, si vous voulez utiliser des capteurs, où les valeurs de sortie ne sont pas numériques [valeur de tension dépassée -> valeur numérique ON | valeur de tension sous-cotée -> valeur numérique OFF | exemple : bouton enfoncé [ON] bouton relâché [OFF]], mais il doit s'agir d'une valeur variable continue (exemple : potentiomètre -> autre position = autre valeur de tension).

Pour éviter ce problème, notre kit de capteur X40 a le KY-053, un module avec ADC précis de 16 bits, que vous pouvez utiliser sur le Raspberry pour l'étendre avec 4 entrées analogiques. Il est connecté au Raspberry Pi via I2C, prend en charge la mesure analogique et transmet la valeur numérique au Raspberry Pi.

Ainsi, nous recommandons de connecter le module KY-053 avec ledit ADC entre les capteurs analogiques de cet ensemble. Pour plus d'informations, veuillez consulter la page d'information sur le convertisseur analogique-numérique KY-053.

Exemple de code

Le programme utilise les bibliothèques Python ADS1x15 et I2C correspondantes d'Adafruit pour piloter l'ADC ADS1115. Ceux-ci ont été publiés au lien suivant https://github.com/adafruit/Adafruit_CircuitPython_ADS1x15 sous la licence MIT. Les bibliothèques requises ne sont pas incluses dans le paquet de téléchargement ci-dessous.

Le programme utilise l'ADC ADS1115 pour mesurer la valeur de la tension actuelle au niveau de l'ADC, calcule la résistance actuelle de la CTN à partir de celle-ci, calcule la température en utilisant les valeurs déterminées à l'avance pour ce capteur et les transmet à la console.

Veuillez noter que vous devez activer I2C sur votre Raspberry Pi avant d'utiliser cet exemple.

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

i2c = busio.I2C(board.SCL, board.SDA)

ads = ADS.ADS1115(i2c)

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;
        lastTime = curTime
        N = sampleCounter - lastBeatTime;
       

        ##  find the peak 
        if Signal < thresh and N > (IBI/5.0)*3.0 :
            if Signal < T :
              T = Signal;

        if Signal > thresh and  Signal > P:
            P = Signal;

         
          # signal surges up in value every time there is a pulse
        if N > 250 :
            if  (Signal > thresh) and  (Pulse == False) and  (N > (IBI/5.0)*3.0)  :       
              Pulse = True;
              IBI = sampleCounter - lastBeatTime;
              lastBeatTime = sampleCounter;

              if secondBeat :
                secondBeat = False;
                for i in range(0,10):
                  rate[i] = IBI;                      

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


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

              for i in range(0,9):
                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 :
            Pulse = False;                         
            amp = P - T;                           
            thresh = amp/2 + T;                    
            P = thresh;                            
            T = thresh;

        if N > 2500 :
            thresh = 512;
            P = 512;
            T = 512;
            lastBeatTime = sampleCounter;
            firstBeat = True;
            secondBeat = False;
            print ("no beats found")

        time.sleep(0.005)

Exemple de téléchargement de programme

KY039-RPi.zip

Pour commencer avec la commande :

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("")
		})
	

# Importer les bibliothèques
from machine import ADC
import utime

# Utiliser GPIO26 comme entrée analogique
analog_pin = ADC(0)  

# Variables d'initialisation
raw_value = 0
max_value = 0
is_peak = False

# Fonction de détection d'un battement de cœur
def heartbeat_detected(ir_sensor_pin, delay_msec):
    global raw_value, max_value, is_peak
    
    result = False
    # Lecture de la valeur de tension actuelle (0 à 65535)
    raw_value = ir_sensor_pin.read_u16()
    # Ajuster la valeur au délai
    raw_value = (raw_value * 1000) // delay_msec 
    
    # Réinitialisation de la valeur maximale si la différence est trop importante
    if raw_value * 4 < max_value:
        max_value = int(raw_value * 0.8)
    
    # Détection des pics
    if raw_value > max_value - (1000 // delay_msec):
        if raw_value > max_value:
            max_value = raw_value
        # Un seul battement de cœur doit être attribué au pic détecté
        if not is_peak:
            result = True
        is_peak = True
    elif raw_value < max_value - (3000 // delay_msec):
        is_peak = False
        # La valeur maximale est diminuée à chaque passage.
        # est légèrement diminuée. La raison en est que
        # non seulement la valeur serait sinon toujours stable à chaque coup
        # serait égale ou inférieure, mais aussi,
        # si le doigt bougeait un peu et que, par conséquent
        # le signal s'affaiblirait.
        max_value -= 1000 // delay_msec
    
    return result

# Délai en millisecondes par échantillonnage
delay_msec = 60
beat_msec = 0

print("KY-039 Mesure du rythme cardiaque")

while True:
    heart_rate_bpm = 0
    if heartbeat_detected(analog_pin, delay_msec):
        # Calculer uniquement les battements de cœur si beat_msec n'est pas 0
        if beat_msec > 0:
            heart_rate_bpm = 60000 // beat_msec       
        # Ne donner le pouls que s'il se situe dans une plage réaliste
        if 30 < heart_rate_bpm < 200:
            print("Pouls détecté: {} BPM".format(heart_rate_bpm))
        # Réinitialiser après la détection
        beat_msec = 0  
        
    utime.sleep_ms(delay_msec)
    beat_msec += delay_msec