ESP32 MAX30102 : Oxymètre de pouls et fréquence cardiaque (Arduino)

Ce tutoriel est un guide de démarrage pour interfacer l’oxymètre de pouls et le capteur de fréquence cardiaque MAX30102 avec l’ESP32 programmé avec l’IDE Arduino. Ce capteur peut mesurer la fréquence cardiaque, la saturation en oxygène du sang (SpO2) et la température corporelle. Il communique en utilisant le protocole de communication I2C.

Nous expliquerons comment câbler le capteur et fournirons des exemples de code pour obtenir la fréquence cardiaque, la saturation en oxygène et la température corporelle.

Table des matières

Dans ce guide, nous aborderons les sujets suivants :

Présentation de l’oxymètre de pouls et du capteur de fréquence cardiaque MAX30102

Ce module comprend le MAX30102 IC, qui est un capteur optique capable de mesurer la saturation en oxygène du sang (SpO2) et la fréquence cardiaque de manière non invasive. Il comprend également un capteur de température utilisé pour la compensation et l’étalonnage de la température.

Le MAX30102 possède une LED rouge, une LED infrarouge et un photodétecteur. Les LED émettent de la lumière dans la peau et le photodétecteur mesure la lumière réfléchie. La quantité de lumière réfléchie change avec le flux sanguin et les battements du cœur. En traitant ces changements, nous pouvons calculer la fréquence cardiaque et la SpO2.

Comment fonctionne le MAX30102 ?

Voici comment fonctionne le capteur pour obtenir des mesures de SpO2 et de fréquence cardiaque.

1) Émission de lumière : les LED rouges et infrarouges émettent de la lumière dans les tissus corporels. Chaque LED fonctionne à une longueur d’onde différente.

2) Détection de la lumière réfléchie : la lumière émise pénètre dans les tissus corporels et une partie est réfléchie. La quantité de lumière réfléchie dépend du volume sanguin et du niveau d’oxygénation. Le photodétecteur du capteur mesure la lumière réfléchie.

3) Modifications de l’intensité lumineuse : en mesurant les variations de l’intensité lumineuse réfléchie aux deux longueurs d’onde, rouge et infrarouge, le capteur peut différencier l’hémoglobine oxygénée et désoxygénée. Ces mesures peuvent ensuite être utilisées pour calculer la fréquence cardiaque et la SpO2.

• Hémoglobine oxygénée : absorbe davantage de lumière infrarouge
• Hémoglobine désoxygénée : absorbe davantage de lumière rouge

Sur la base du rapport des intensités de lumière réfléchie aux longueurs d’onde rouge et infrarouge, le capteur peut calculer la SpO2. Les modifications du volume sanguin à chaque battement cardiaque nous permettent de mesurer la fréquence cardiaque (BPM).

Où acheter ?

Vous pouvez consulter notre page Maker Advisor Tools pour comparer le prix du module MAX30102 dans différents magasins.

Câblage du capteur MAX30102 à l’ESP32

Le capteur MAX30102 communique à l’aide du protocole de communication I2C. Nous utiliserons les broches I2C par défaut de l’ESP32 pour câbler le capteur.

Le module capteur peut être alimenté via la broche VIN en utilisant 5V ou 3V3.

Câblez le capteur à l’ESP32 comme indiqué dans le schéma suivant (ajustez en fonction de votre modèle de carte ESP32 spécifique).

En savoir plus sur le brochage de l’ESP32 :

Préparation de l’IDE Arduino

Nous allons programmer la carte ESP32 à l’aide de l’IDE Arduino. Assurez-vous donc que le module complémentaire ESP32 est installé. Suivez le tutoriel suivant :

Si vous préférez utiliser VSCode + PlatformIO, suivez plutôt le tutoriel suivant :

Installation de la bibliothèque SparkFun MAX3010x

Il existe plusieurs bibliothèques que vous pouvez utiliser pour interfacer le module de capteur MAX30102 avec l’ESP32. Nous utiliserons la bibliothèque SparkFun MAX3010X qui fonctionne bien pour ce capteur et est facile à utiliser.

Ouvrez le gestionnaire de bibliothèque Arduino IDE, recherchez SparkFun MAX3010x et installez la bibliothèque par SparkFun.

1) ESP32 avec MAX30102 : Obtenez la fréquence cardiaque – Code

Le code suivant montre comment obtenir la fréquence cardiaque du capteur MAX30102 avec l’ESP32. Il obtient la fréquence cardiaque et affiche les résultats sur le moniteur série.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-max30102-oximeter-heart-rate-sensor/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/
#include 
#include "MAX30105.h"
#include "heartRate.h"

MAX30105 sensor;

// Settings
const byte RATE_SIZE = 5;   // How many beats we average
byte rates[RATE_SIZE];      // Store last few valid BPM values
byte rateSpot = 0;
byte validBeats = 0;
long lastBeat = 0;
float currentBPM = 0;
int averageBPM = 0;

unsigned long lastPrint = 0;

// Only accept realistic heart rates (adjust for your case)
const float MIN_BPM = 45;
const float MAX_BPM = 180;

void setup() {
  Serial.begin(115200);
  Serial.println("MAX30102 Heart Rate Sensor");
  Serial.println();
  Serial.println("Place your finger on the sensor...");
  Serial.println();

  // Initialize the sensor
  if (!sensor.begin(Wire, I2C_SPEED_FAST)) {
    Serial.println("Error initializing the sensor...");
    while (1);
  }

  sensor.setup();                    // Use default settings
  sensor.setPulseAmplitudeRed(0);    // Turn off red LED
}

void loop() {
  long irValue = sensor.getIR();      // Read infrared value

  // Check if a heartbeat was detected
  if (checkForBeat(irValue)) {
    long timeBetweenBeats = millis() - lastBeat;
    lastBeat = millis();

    currentBPM = 60.0 / (timeBetweenBeats / 1000.0);

    // Only keep realistic values
    if (currentBPM >= MIN_BPM && currentBPM <= MAX_BPM) {
      rates[rateSpot] = (byte)currentBPM;
      rateSpot++;
      if (rateSpot >= RATE_SIZE){
        rateSpot = 0;
      }
      // Count valid beats (until buffer is full)
      if (validBeats < RATE_SIZE) {
        validBeats++;
      }
      
      // Only calculate average when buffer is full
      if (validBeats >= RATE_SIZE) {
        // Calculate the average
        averageBPM = 0;
        for (byte i = 0; i < RATE_SIZE; i++) {
          averageBPM += rates[i];
        }
        averageBPM /= RATE_SIZE;
      }
    }
  }

  // Print once every second
  if (millis() - lastPrint >= 1000) {
    lastPrint = millis();

    if (irValue < 50000) {
      // No finger on the sensor
      Serial.println("Waiting for finger...");
    }
    else if (averageBPM == 0) {
      // Finger is present but not enough valid beats yet
      Serial.println("Measuring... keep your finger still");
    }
    else {
      // We have a valid average
      Serial.print("Heart Rate: ");
      Serial.print(averageBPM);
      Serial.println(" BPM");
    }
  }
}

Afficher le code brut

Comment le MAX30102 obtient-il la fréquence cardiaque ?

Le capteur est livré avec deux LED : une LED infrarouge et une LED rouge.

Ces LED émettent de la lumière qui traverse le bout de votre doigt. Le sang qui coule absorbe la lumière. Lorsque le cœur bat, davantage de sang est poussé dans les vaisseaux de votre doigt et davantage de lumière est absorbée.

Pour détecter la fréquence cardiaque, nous prenons en compte la quantité de lumière infrarouge réfléchie. Le capteur dispose d’un photodétecteur pour mesurer que :

• Battement cardiaque : plus de sang signifie que plus de lumière infrarouge est absorbée, donc moins de lumière atteint le photodétecteur.
• Entre les battements cardiaques : moins de sang signifie moins de lumière infrarouge absorbée, donc plus de lumière atteint le photodétecteur

Les changements d’intensité lumineuse créent une forme d’onde. En mesurant le temps entre ses pics, vous pouvez calculer la fréquence cardiaque.

En tenant compte de cela, il est désormais facile de comprendre le fonctionnement du code.

Comment fonctionne le code ?

Jetons un coup d’œil rapide au fonctionnement du code.

Bibliothèques

Tout d’abord, incluez les bibliothèques requises :

#include 
#include "MAX30105.h"
#include "heartRate.h"

Objet capteur

Créez un objet MAX30105 appelé capteur.

MAX30105 sensor;

Variables globales

Nous avons besoin de quelques variables globales pour stocker plusieurs lectures de fréquence cardiaque dans un tableau et calculer le BPM moyen.

const byte RATE_SIZE = 5;  
byte rates[RATE_SIZE]; 
byte rateSpot = 0;
byte validBeats = 0;
long lastBeat = 0;
float currentBPM = 0;
int averageBPM = 0;

unsigned long lastPrint = 0;

Le RATE_SIZE définit le nombre de lectures que nous rassemblerons pour calculer le BPM moyen. Vous pouvez augmenter cette valeur pour des résultats plus stables. La variable rate crée un tableau avec 5 valeurs (RATE_SIZE).

Le rateSpot sera utilisé pour indiquer la position actuelle dans le tableau des taux. Le validBeat compte combien de battements valides ont été collectés jusqu’à présent. Il augmente jusqu’à atteindre RATE_SIZE (5).

Le lastBeat stocke l’heure du dernier battement valide ; le currentBPM stocke la valeur actuelle du BPM ; et le BPM moyen stocke la moyenne de toutes les valeurs stockées dans le tableau des taux.

Pour nous assurer que nous ne prenons en compte que les lectures valides, nous excluons les valeurs de rythme cardiaque trop faibles ou trop élevées, qui peuvent être causées par un mauvais placement du doigt sur le capteur. Vous pouvez ajuster ces valeurs pour votre scénario ou ne pas les inclure du tout.

const float MIN_BPM = 45;
const float MAX_BPM = 180;

installation()

Dans setup(), nous initialisons le moniteur série à un débit en bauds de 115 200 et initialisons le capteur.

void setup() {
  Serial.begin(115200);
  Serial.println("MAX30102 Heart Rate Sensor");
  Serial.println();
  Serial.println("Place your finger on the sensor...");
  Serial.println();

  // Initialize the sensor
  if (!sensor.begin(Wire, I2C_SPEED_FAST)) {
    Serial.println("Error initializing the sensor...");
    while (1);
  }

Pour mesurer la fréquence cardiaque, l’algorithme utilise uniquement la lumière LED infrarouge. Nous désactivons donc le rouge et laissons tous les autres paramètres par défaut.

sensor.setup(); 
sensor.setPulseAmplitudeRed(0);

boucle()

Dans la boucle(), on commence par obtenir une valeur infrarouge (la lumière infrarouge qui a été réfléchie et lue par le photodétecteur).

long irValue = sensor.getIR(); 

Ensuite, la fonction checkForBeat() détecte si un battement de coeur vient de se produire, en fonction du signal infrarouge. Si nous avons un battement de cœur, nous calculons le temps écoulé depuis le dernier battement et, en fonction du temps écoulé entre les battements, nous pouvons estimer le battement de cœur (BPM – battements par minute).

// Check if a heartbeat was detected
if (checkForBeat(irValue)) {
  long timeBetweenBeats = millis() - lastBeat;
  lastBeat = millis();

  currentBPM = 60.0 / (timeBetweenBeats / 1000.0);

On va un peu plus loin, et on ne sauvegarde une valeur de BPM que si elle se situe dans la plage que nous avons définie précédemment. Si tel est le cas, nous l’ajoutons à un endroit de notre tableau de tarifs.

// Only keep realistic values
if (currentBPM >= MIN_BPM && currentBPM <= MAX_BPM) {
  rates[rateSpot] = (byte)currentBPM;
  rateSpot++;
  if (rateSpot >= RATE_SIZE){
    rateSpot = 0;
  }

Une fois le tableau des taux plein, nous calculons la fréquence cardiaque moyenne en fonction des 5 dernières lectures (RATE_SIZE)

// Count valid beats (until buffer is full)
if (validBeats < RATE_SIZE) {
  validBeats++;
}
      
// Only calculate average when buffer is full
if (validBeats >= RATE_SIZE) {
  // Calculate the average
  averageBPM = 0;
  for (byte i = 0; i < RATE_SIZE; i++) {
    averageBPM += rates[i];
  }
  averageBPM /= RATE_SIZE;
}

Toujours dans la boucle(), nous pouvons avoir l’un des scénarios suivants.

Si l’irValue est inférieure à 50 000, cela signifie qu’il n’y a pas de doigt sur le capteur. Nous imprimons un message sur le moniteur série.

if (irValue < 50000) {
  // No finger on the sensor
  Serial.println("Waiting for finger...");
}

Si le BPM moyen actuel est de 0, cela signifie que nous n’avons pas suffisamment de lectures dans le tableau. L’utilisateur doit garder le doigt sur le capteur pour obtenir des lectures valides.

else if (averageBPM == 0) {
  // Finger is present but not enough valid beats yet
  Serial.println("Measuring... keep your finger still");
}

Si aucun des scénarios précédents ne se produit, cela signifie que nous disposons d’une valeur de fréquence cardiaque valide et que nous imprimons les résultats dans le moniteur série.

else {
  // We have a valid average
  Serial.print("Heart Rate: ");
  Serial.print(averageBPM);
  Serial.println(" BPM");
}

Démonstration

Téléchargez le code sur votre carte ESP32. Après le téléchargement, ouvrez le moniteur série à un débit en bauds de 115 200.

Placez votre doigt sur le capteur. Pour des résultats meilleurs et plus précis, le doigt doit rester immobile avec une pression constante. Vous pouvez fixer le capteur à votre doigt à l’aide d’un élastique.

Les valeurs BPM seront imprimées dans le moniteur série.

2) ESP32 avec MAX30102 : Obtenez la saturation en oxygène (SpO2) – Code

Le code suivant montre comment obtenir la saturation en oxygène du sang du capteur MAX30102 avec l’ESP32. Les résultats sont imprimés dans le moniteur série.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-max30102-oximeter-heart-rate-sensor/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/
#include 
#include "MAX30105.h"
#include "spo2_algorithm.h"

MAX30105 sensor;

// Buffers needed by the algorithm
#define BUFFER_SIZE 100
uint32_t irBuffer[BUFFER_SIZE];
uint32_t redBuffer[BUFFER_SIZE];

int32_t spo2;          // Oxygen saturation value
int8_t  validSPO2;     // 1 = valid reading, 0 = not valid yet
int32_t heartRate;     // Not used, but required by the function
int8_t  validHeartRate;

void setup() {
  Serial.begin(115200);
  Serial.println("MAX30102 Oxygen Saturation");
  Serial.println();
  Serial.println("Place your finger on the sensor...");
  Serial.println();

  // Initialize the sensor
  if (!sensor.begin(Wire, I2C_SPEED_FAST)) {
    Serial.println("Error initializing the sensor...");
    while (1);
  }

  byte ledBrightness = 60;  // 0=Off to 255=50mA
  byte sampleAverage = 4;   // 1, 2, 4, 8, 16, 32
  byte ledMode = 2;         // 1 = Red only, 2 = Red + IR, 3 = Red + IR + Green
  byte sampleRate = 100;    // 50, 100, 200, 400, 800, 1000, 1600, 3200
  int pulseWidth = 411;     // 69, 118, 215, 411
  int adcRange = 4096;      // 2048, 4096, 8192, 16384

  // Configure sensor with these settings
  sensor.setup(ledBrightness, sampleAverage, ledMode, sampleRate, pulseWidth, adcRange);
}

void loop() {
  // Collect 100 samples (takes a few seconds)
  for (byte i = 0; i < BUFFER_SIZE; i++) {
    while (sensor.available() == false) {
      sensor.check();
    }

    redBuffer[i] = sensor.getRed();
    irBuffer[i]  = sensor.getIR();
    sensor.nextSample();
  }

  // Calculate SpO2
  maxim_heart_rate_and_oxygen_saturation(irBuffer, BUFFER_SIZE, redBuffer, &spo2, &validSPO2, &heartRate, &validHeartRate);

  // Display oxygen saturation
  if (validSPO2) {
    Serial.print("Oxygen Saturation: ");
    Serial.print(spo2);
    Serial.println(" %");
  } else {
    Serial.println("Measuring... keep your finger still");
  }

  Serial.println();
}

Afficher le code brut

Comment le MAX30102 obtient-il la SpO2 ?

Comme nous l’avons vu précédemment, le MAX30102 est livré avec une LED rouge et une LED infrarouge.

Ces LED émettent une lumière qui traverse le bout de vos doigts. Une partie de la lumière est absorbée et une autre est réfléchie. La lumière réfléchie est mesurée par le photodétecteur présent sur le module.

A partir des variations de l’intensité lumineuse réfléchie (rouge et infrarouge), on peut calculer la SpO2.

• Hémoglobine oxygénée : absorbe davantage de lumière infrarouge
• Hémoglobine désoxygénée : absorbe davantage de lumière rouge

Sur la base du rapport des intensités de lumière réfléchie aux longueurs d’onde rouge et infrarouge, le capteur peut calculer la SpO2.

Comment fonctionne le code ?

Jetons un coup d’œil rapide au fonctionnement du code.

Bibliothèques

Tout d’abord, incluez les bibliothèques requises :

#include 
#include "MAX30105.h"
#include "heartRate.h"

Objet capteur

Créez un objet MAX30105 appelé capteur.

MAX30105 sensor;

Variables globales

Nous créons quelques variables globales qui sont utilisées dans tout le code. Nous avons besoin d’un tampon de 100 lectures infrarouges et rouges pour que l’algorithme calcule la SpO2. Les variables liées à la fréquence cardiaque sont également nécessaires à l’algorithme de la bibliothèque pour calculer la SpO2.

// Buffers needed by the algorithm
#define BUFFER_SIZE 100
uint32_t irBuffer[BUFFER_SIZE];
uint32_t redBuffer[BUFFER_SIZE];

int32_t spo2;             // Oxygen saturation value
int8_t  validSPO2;     // 1 = valid reading, 0 = not valid yet
int32_t heartRate;     // Not used, but required by the function
int8_t  validHeartRate;

installation()

Dans le setup(), initialisez le moniteur série et le capteur.

void setup() {
  Serial.begin(115200);
  Serial.println("MAX30102 Oxygen Saturation");
  Serial.println();
  Serial.println("Place your finger on the sensor...");
  Serial.println();

  // Initialize the sensor
  if (!sensor.begin(Wire, I2C_SPEED_FAST)) {
    Serial.println("Error initializing the sensor...");
    while (1);
  }

Nous configurons le capteur avec les paramètres recommandés pour les mesures SpO2.

byte ledBrightness = 60;
byte sampleAverage = 4;
byte ledMode = 2;
byte sampleRate = 100;
int pulseWidth = 411;
int adcRange = 4096;

sensor.setup(ledBrightness, sampleAverage, ledMode, sampleRate, pulseWidth, adcRange);

Le tableau suivant montre ce qu’est chaque paramètre et quelles valeurs ils peuvent avoir.

boucle()

Dans la boucle(), nous obtenons 100 échantillons de lumière infrarouge et rouge réfléchie et les enregistrons dans les variables redBuffer et irBuffer.

// Collect 100 samples (takes a few seconds)
for (byte i = 0; i < BUFFER_SIZE; i++) {
  while (sensor.available() == false) {
    sensor.check();
  }

  redBuffer[i] = sensor.getRed();
  irBuffer[i]  = sensor.getIR();
  sensor.nextSample();
}

Enfin, nous appelons la fonction maxim_heart_rate_and_oxygen_saturation() avec les paramètres suivants pour obtenir la valeur de SpO2.

maxim_heart_rate_and_oxygen_saturation(irBuffer, BUFFER_SIZE, redBuffer, &spo2, &validSPO2, &heartRate, &validHeartRate);

La valeur de saturation en oxygène est enregistrée dans la variable spo2 et validSPO2 nous indique si nous avons une lecture valide. Nous imprimons les résultats sur le Serial Monitor.

// Display oxygen saturation
if (validSPO2) {
  Serial.print("Oxygen Saturation: ");
  Serial.print(spo2);
  Serial.println(" %");
} else {
  Serial.println("Measuring... keep your finger still");
}

Serial.println();

Démonstration

Téléchargez le code sur votre carte ESP32. Après le téléchargement, ouvrez le moniteur série à un débit en bauds de 115 200.

Placez votre doigt sur le capteur. Attendez quelques secondes jusqu’à ce que vous ayez des lectures SpO2 valides.

3) ESP32 avec MAX30102 : Obtenir la température – Code

Le capteur MAX30102 est également livré avec un capteur de température nécessaire à l’étalonnage des valeurs BPM et SpO2. Nous pouvons également utiliser ce capteur pour obtenir la valeur de la température corporelle (dans ce cas, la température du bout des doigts).

Le code suivant montre comment obtenir la température corporelle du capteur MAX30102 avec l’ESP32.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-max30102-oximeter-heart-rate-sensor/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/
#include 
#include "MAX30105.h"

MAX30105 sensor;

void setup() {
  Serial.begin(115200);
  Serial.println("MAX30102 Temperature Sensor");
  Serial.println();

  // Initialize the sensor
  if (!sensor.begin(Wire, I2C_SPEED_FAST)) {
    Serial.println("Error initializing the sensor...");
    while (1);
  }
  
  // Turn off the LEDs so they don't heat the sensor
  sensor.setup(0);            // 0 = LEDs off
  sensor.enableDIETEMPRDY();  // Enable temperature ready signal
}

void loop() {
  // Read temperature in Celsius
  float tempC = sensor.readTemperature();

  // Convert to Fahrenheit
  float tempF = tempC * 1.8 + 32.0;

  // Print the temperature readings
  Serial.print("Temperature: ");
  Serial.print(tempC, 2);
  Serial.print(" °C   |   ");
  Serial.print(tempF, 2);
  Serial.println(" °F");

  delay(1000);
}

Afficher le code brut

Comment fonctionne le code ?

Jetons un coup d’œil rapide au fonctionnement du code.

Bibliothèques

Commencez par inclure les bibliothèques requises.

#include 
#include "MAX30105.h"

Objet capteur

Créez un objet MAX30105 appelé capteur.

MAX30105 sensor;

installation()

Dans setup(), initialisez le moniteur série à un débit en bauds de 115 200.

Serial.begin(115200);
Serial.println("MAX30102 Temperature Sensor");
Serial.println();

Initialisez le capteur.

// Initialize the sensor
if (!sensor.begin(Wire, I2C_SPEED_FAST)) {
  Serial.println("Error initializing the sensor...");
  while (1);
}

Éteignez les LED du capteur afin qu’elles n’interfèrent pas avec les lectures de température et activez le signal pour lire la température.

// Turn off the LEDs so they don't heat the sensor
sensor.setup(0); 
sensor.enableDIETEMPRDY();

boucle()

Enfin, dans la boucle(), nous lisons en continu la température toutes les secondes.

Obtenir la température en Celsius est aussi simple que d’appeler la fonction readTemperature() sur l’objet capteur.

float tempC = sensor.readTemperature();

Nous pouvons ensuite convertir la température en Fahrenheit comme suit.

// Convert to Fahrenheit
float tempF = tempC * 1.8 + 32.0;

Imprimez les résultats dans le moniteur série.

// Print the temperature readings
Serial.print("Temperature: ");
Serial.print(tempC, 2);
Serial.print(" °C   |   ");
Serial.print(tempF, 2);
Serial.println(" °F");

Démonstration

Téléchargez le code sur votre tableau. Ensuite, ouvrez le moniteur série à un débit en bauds de 115 200.

Fixez le capteur à votre doigt à l’aide d’un élastique.

Il commencera à afficher les relevés de température toutes les secondes. Attendez quelques secondes que les résultats se stabilisent.

Conclusion

Dans ce didacticiel, vous avez appris à interfacer le module capteur MAX30102 avec l’ESP32 pour obtenir la fréquence cardiaque, la concentration en oxygène dans le sang et la température corporelle (bout du doigt). Ce capteur peut être utilisé dans une grande variété de projets portables/santé.

Vous pouvez aller plus loin dans ce projet et ajouter un module d’affichage pour afficher les résultats, ou créer un serveur Web pour afficher les données. Vous trouverez peut-être utile de consulter les guides suivants pour choisir un module d’affichage ou créer un serveur Web :

Vous pouvez également créer un périphérique BLE avec ces caractéristiques et une application Web ou mobile pour afficher les résultats.

Nous créerons d’autres projets en utilisant ce capteur, alors restez à l’écoute.

Cette vidéo vous emmène dans l’histoire de Raspberry Pi :