KY-039 Capteur de pulsations cardiaques

De SensorKit X40 Wiki

Aller à : navigation, rechercher

Photo

KY-039-02g.png

Données techniques / Description sommaire

Si on met un doigt sur la diode émettrice et le phototransistor, le signal de sortie délivre une image des pulsations du sang dans votre doigt.

Un phototransistor fonctionne comme ceci: il agit comme un transistor normal sauf que le courant de la base est remplacé par de la lumière reçue. Lorsque le phototransistor reçoit de la lumière, il change d'état et peut commuter une intensité relativement importante (en fonction de ses caractéristiques). 


Phototransistor.png

Si vous placez une résistance en série avec le phototransistor, vous pourrez observer le comportement suivant: la tension aux bornes du phototransistor sera proche de 0 V lorsqu'il sera exposé à une lumière extérieure, tandis que cette tension sera proche de la tension d'alimentation dans l'obscurité.

Ce module permet de mesurer vos pulsations en plaçant un doigt entre la diode et le phototransistor. 

Explication: si vous placez votre doigt devant une lampe de poche, il deviendra plus ou moins translucide. Selon l'endroit éclairé, on peut vaguement discerner le pompage du sang.

Ce pompage du sang dans la veine présente une densité différente et donc des différences de luminosité dans le flux sanguin. Ce sont ces différences de luminosité que le module peut détecter et ainsi compter les pulsations. Ce phénomène est illustré par la capture d'écran sur un oscilloscope:

NewFile1.jpg


L'écran montre la variation de la tension au niveau du phototransistor (ainsi que les variations de luminosité dues à la circulation du sang) sur l'axe des ordonnées. Les pics ci-dessus représentent les impulsions du cœur. Si on compte les battements, on obtient environ 71 battements/minute.


Pour obtenir de bons résultats, nous recommandons d'effectuer la mesure sur en plaçant le capteur sur l'extrémité du petit doigt comme sur la photo ci-dessous:

KY-039 600px-IMG 20.jpg


Pour un meilleur résultat, il est préférable de fixer le capteur à l'aire de sparadrap ou ruban adhésif.

KY-039 600px-IMG 20170125 105155.jpg


L'enregistrement du rythme cardiaque est meilleur lorsque le capteur est placé au-dessus d'un vaisseau sanguin majeur.

Il est parfois utile de tester différents emplacements pour le capteur afin d'obtenir un enregistrement de meilleure qualité.

Ce capteur est destiné à une utilisation didactique, le résultat dépend de la personne et de la position du doigt sur le capteur. Il est possible de ne pas obtenir de bons résultats dans certaines conditions.

Brochage

3 G V S.png

Branchement des câbles :

Gris   -->  GND

Blanc -->  +V

Noir   -->  Signal

Exemple de code pour Arduino

L'exemple de code suivant est de Dan Truong qui l'a publié sous ce [|lien] sous licence [|MIT OpenSource]. La version ci-dessous est traduite en français, l'originale est à télécharger ci-dessous. 

Ce code détecte une impulsion. Il n'enregistrera pas le rythme cardiaque, mais il va rechercher les pics qui seront assimilés à des pulsations et feront allumer la led. Le nombre de pulsations peut être plus ou moins calculé.

Si le doigt est replacé entre la LED et le phototransistor, un délai est nécessaire jusqu'à ce que le programme se recalibre pour la nouvelle mesure et délivre la valeur correcte.


////////////////////////////////////////////////////////////////////////
/// 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)
////////////////////////////////////////////////////////////////////////
///
/// Commentaires en français de GO TRONIC
///
////////////////////////////////////////////////////////////////////////
/// @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;  }  
 // Detect new peak 
 if (rawValue > maxValue - (1000/delay)) {
 // Détection de l'impulsion. Si la nouvelle rawValue est plus grande
 // que la dernière valeur maximale, elle sera prise en compte en enregistrée
 if (rawValue > maxValue) {
 maxValue = rawValue;
 }
 // Attribution des pulsations
 if (isPeak == false) {
 result = true;
 }
 isPeak = true;
 } else if (rawValue < maxValue - (3000/delay)) {
 isPeak = false;
 // La valeur maximale est légèrement diminuée à chaque passage.
 // Cela peut prendre plusieurs secondes pour détecter de nouveau
 // le signal lorsque le doigt a bougé ou que le capteur est devant
 // une partie osseuse du doigt. On peut aussi vérifier le délai
 // depuis la dernière pulsation et s'il excède 1 seconde, on
 // rénitialise maxValue
 maxValue-=(1000/delay);
 }
 return result;
}
 
 
////////////////////////////////////////////////////////////////////////
// Arduino main code
////////////////////////////////////////////////////////////////////////
int ledPin=13;
int analogPin=0;
 
void setup()
{
 // La LED Arduino intégrée (Digital 13) est utilisée pour la sortie
 pinMode(ledPin,OUTPUT);
 
 // Initialisation de la sortie série
 Serial.begin(9600);
 Serial.println("Exemple de code de détection de pulsations.");
}
 
const int delayMsec = 60; // 100msec per sample
 
// Le programme principal a deux sorties:
// - Si un battement de coeur est détecté, le voyant clignote
// - L'impulsion est calculée et envoyée vers la sortie série.
 
void loop()
{
 static int beatMsec = 0;
 int heartRateBPM = 0;
 Serial.println(rawValue);
 if (heartbeatDetected(analogPin, delayMsec)) {
 heartRateBPM = 60000 / beatMsec;
 // Sortie LED par impulsion
 digitalWrite(ledPin,1);
 
 // Envoi des données série
 Serial.print(rawValue);
 Serial.print(", ");
 Serial.println(heartRateBPM);
 
 beatMsec = 0;
 } else {
 digitalWrite(ledPin,0);
 }
 delay(delayMsec);
 beatMsec += delayMsec;
 }

Affectation des broches Arduino:


Sensor Signal = [Pin 0]
Sensor +V = [5V]
Sensor - = [Pin GND]

Exemple de programme à télécharger

KY-039-HeartBeatDetector original by DanTruong


KY-039-version par Joy-It et Gotronic

Exemple de code pour Raspberry Pi

!! Attention !! Capteur analogique  !! Attention !!

Contrairement à une carte Arduino, la Raspberry Pi ne dispose pas d'entrées analogiques ni de convertisseur ADC (Analog Digital Converter) intégré. Cela pose problème lorsque vous voulez utiliser des capteurs analogiques avec une carte Raspberry.

Pour contourner ce problème, le Sensorkit X40 inclut le module KY-053 qui possède un module convertisseur ADC de 16 bits et qui peut être raccordé sur la Raspberry pour lui procurer 4 entrées analogiques. Ce module se raccorde à la Raspberry via le bus I2C. Il mesure la tension (analogique) et envoie une valeur numérique à la Raspberry.

Vous trouverez de plus amples informations à ce sujet dans la description du module KY-053.

!!Attention !! Capteur analogique !! Attention !!


Dans ce programme, la fonction de détection du rythme cardiaque "heartBeatDetect" est appelée toutes les 10 ms (délais "delayTime" modifiable).
Si une pulsation est détectée, une impulsion est émise. Il est aussi possible de connecter une led sur la broche LED_PIN (par défaut dans le programme: GPIO 24) pour avoir une visualisation des pulsations (la led s'éclaire à chaque pulsation détectée).

Si le doigt vient d'être placé ou a bougé, le module peut avoir besoin de se recalibrer (3-5 secondes) avant de délivrer une mesure correcte.


Ce programme utilise des librairies Python de la société Adafruit pour piloter les circuits ADS1115 (ADC) et ADS1x15 (I2C). 

Celles-ci se trouvent à la page https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code sous licence BSD


#!/usr/bin/python
# coding=utf-8

#############################################################################################################
### Copyright by Joy-IT
### Published under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
### Commercial use only after permission is requested and granted
###
### Parts of Code based on Dan Truong's KY039 Arduino Heartrate Monitor V1.0
### [https://forum.arduino.cc/index.php?topic=209140.msg2168654] Message #29
###
### Traduction française par Go Tronic
###
#############################################################################################################

# Ce programme utilise les bibliothèques Python ADS115 et I2C pour Raspberry Pi
# Elles sont téléchargeables sous licence BSD via le lien suivant:
# [https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code]
from Adafruit_ADS1x15 import ADS1x15
from time import sleep

# Import et mise en place des autres modules
import time, signal, sys, os
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)

# Initialisation des variables
beatsPerMinute = 0
isPeak = False
result = False
delayTime = 0.01
maxValue = 0
schwelle = 25
beatTime = 0
oldBeatTime = 0

# Affectation des adresses ADS1x15 ADC
ADS1015 = 0x00  # 12-bit ADC
ADS1115 = 0x01	# 16-bit

# Sélection de l'amplification (gain)
gain = 4096  # +/- 4.096V
# gain = 2048  # +/- 2.048V
# gain = 1024  # +/- 1.024V
# gain = 512   # +/- 0.512V
# gain = 256   # +/- 0.256V

# Taux d'échantillonnage du convertisseur analogique
sps = 8    # 8 Samples pro Sekunde
# sps = 16   # 16 Samples pro Sekunde
# sps = 32   # 32 Samples pro Sekunde
# sps = 64   # 64 Samples pro Sekunde
# sps = 128  # 128 Samples pro Sekunde
# sps = 250  # 250 Samples pro Sekunde
# sps = 475  # 475 Samples pro Sekunde
# sps = 860  # 860 Samples pro Sekunde

# Choix de la broche du convertisseur analogique (1-4)
adc_channel = 0    # Channel 0
# adc_channel = 1    # Channel 1
# adc_channel = 2    # Channel 2
# adc_channel = 3    # Channel 3

# Initialisation du convertisseur - ici le module KY-053 utilise le convertisseur ADS1115
adc = ADS1x15(ic=ADS1115)

# Déclaration de la broche sur laquelle est connectée la led
LED_PIN = 24
GPIO.setup(LED_PIN, GPIO.OUT, initial= GPIO.LOW)


#############################################################################################################

# Fonction de calcul du rythme cardiaque
def heartBeatDetect(schwelle):
        global maxValue
        global isPeak
        global result
        global oldBeatTime

        # La valeur de la tension du phototransistor est lue
        # et stockée dans la variable rawValue
        rawValue = adc.readADCSingleEnded(adc_channel, gain, sps)

        # Réinitialisation de la variable de résultat
        if result == True:
            result = False

        # Si la valeur mesurée est trop loin de la valeur maximale
        # (par exemple si le doigt vient d'être mit ou a bougé),
        # alors la valeur maximale est réinitialisée pour avoir une nouvelle valeur de référence
        if rawValue * 4 < maxValue:              maxValue = rawValue * 0.8
        # Détection d'une crête. Si la valeur mesurée rawValue est plus grande que la valeur haute maxValue
        # elle devient la nouvelle valeur haute.
        if rawValue > (maxValue - schwelle):
              if rawValue > maxValue:
                    maxValue = rawValue
              # Et un battement de coeur est compté
              if isPeak == False:
                    result = True

              isPeak = True

        else:
            if rawValue < (maxValue - schwelle):
              isPeak = False
              # Si il n'y a pas de crête détectée, 
              # la valeur maximale est légèrement diminuée à chaque cycle
              # pour s'assurer que les pics suivants dépassent bien cette
              # valeur maximale et soient pris en compte, mais aussi dans 
              # le cas où le doigt se serait légèrement déplacé et que le
              # signal serait plus faible.
            maxValue = maxValue - schwelle/2

        # Dans le cas où un battement a été détecté, la sortie est activée
        if result == True:

            # Calcul du rythme cardiaque
            # L'heure du système est enregistrée à chaque battement 
            # et est comparée à l'heure de du battement précédent.
            # La différence entre les deux est alors utilisée pour 
            # calculer le rythme cardiaque.
            beatTime = time.time()
            timedifference = beatTime - oldBeatTime
            beatsPerMinute = 60/timedifference
            oldBeatTime = beatTime

            # En plus du calcul du rythme cardiaque, une led indique les battements
            GPIO.output(LED_PIN, GPIO.HIGH)
            time.sleep(delayTime*10)
            GPIO.output(LED_PIN, GPIO.LOW)

            # Le rythme cardiaque est retourné comme résultat de la fonction
            return beatsPerMinute


#############################################################################################################

# ########
# Boucle de programme principale
# ########
# Dans ce programme, la fonction de détection du rythme cardiaque "heartBeatDetect"
# est appelée toutes les 10 ms (délais "delayTime" modifiable).
# Si une pulsation est détectée, une impulsion est émise.

try:
        while True:
                time.sleep(delayTime)
                beatsPerMinute = heartBeatDetect(schwelle)
                if result == True:
                    print "---Pulsation détectée !--- Pulsation:", int(beatsPerMinute),"(bpm)"



except KeyboardInterrupt:
        GPIO.cleanup()

Brochage Raspberry Pi:

Module KY-039

Signal = Analog 0 [Pin A0 (ADS1115 - KY-053)]
+V = 3,3V [Pin 1]
GND = Masse [Pin 6]

ADS1115 - KY-053:

VDD = 3,3V [Pin 01]
GND = Masse [Pin 09]
SCL = GPIO03 / SCL [Pin 05]
SDA = GPIO02 / SDA [Pin 03]
A0 = s.o. [Sensor: Signal]

Exemple de programme à télécharger

KY-039_HeartBeatDetector

Commande pour lancer le programme:

sudo python KY-039_HeartBeatDetector.py