MAX30102 Tutorial: Herzfrequenz & Blutsauerstoff messen – einfach erklärt

#include <MAX3010x.h>
#include "filters.h"
#include "MATRIX7219.h"

// Sensor (adjust to your sensor type)
MAX30105 sensor;
const auto kSamplingRate = sensor.SAMPLING_RATE_400SPS;
const float kSamplingFrequency = 400.0;

// Finger Detection Threshold and Cooldown
const unsigned long kFingerThreshold = 10000;
const unsigned int kFingerCooldownMs = 500;

// Edge Detection Threshold (decrease for MAX30100)
const float kEdgeThreshold = -2000.0;

// Filters
const float kLowPassCutoff = 5.0;
const float kHighPassCutoff = 0.5;

// Averaging
const bool kEnableAveraging = false;
const int kAveragingSamples = 5;
const int kSampleThreshold = 5;

void setup() {
  Serial.begin(9600);

  if (!sensor.begin() && !sensor.setSamplingRate(kSamplingRate)) {
    Serial.println("Sensor not found");
    while (1)
      ;
  }
}

// Filter Instances
LowPassFilter low_pass_filter_red(kLowPassCutoff, kSamplingFrequency);
LowPassFilter low_pass_filter_ir(kLowPassCutoff, kSamplingFrequency);
HighPassFilter high_pass_filter(kHighPassCutoff, kSamplingFrequency);
Differentiator differentiator(kSamplingFrequency);
MovingAverageFilter<kAveragingSamples> averager_bpm;
MovingAverageFilter<kAveragingSamples> averager_r;
MovingAverageFilter<kAveragingSamples> averager_spo2;

// Statistic for pulse oximetry
MinMaxAvgStatistic stat_red;
MinMaxAvgStatistic stat_ir;

// R value to SpO2 calibration factors
// See https://www.maximintegrated.com/en/design/technical-documents/app-notes/6/6845.html
float kSpO2_A = 1.5958422;
float kSpO2_B = -34.6596622;
float kSpO2_C = 112.6898759;

// Timestamp of the last heartbeat
long last_heartbeat = 0;

// Timestamp for finger detection
long finger_timestamp = 0;
bool finger_detected = false;

// Last diff to detect zero crossing
float last_diff = NAN;
bool crossed = false;
long crossed_time = 0;

void loop() {
  auto sample = sensor.readSample(1000);
  float current_value_red = sample.red;
  float current_value_ir = sample.ir;

  // Detect Finger using raw sensor value
  if (sample.red > kFingerThreshold) {
    if (millis() - finger_timestamp > kFingerCooldownMs) {
      finger_detected = true;
    }
  } else {
    // Reset values if the finger is removed
    differentiator.reset();
    averager_bpm.reset();
    averager_r.reset();
    averager_spo2.reset();
    low_pass_filter_red.reset();
    low_pass_filter_ir.reset();
    high_pass_filter.reset();
    stat_red.reset();
    stat_ir.reset();

    finger_detected = false;
    finger_timestamp = millis();
  }

  if (finger_detected) {
    current_value_red = low_pass_filter_red.process(current_value_red);
    current_value_ir = low_pass_filter_ir.process(current_value_ir);

    // Statistics for pulse oximetry
    stat_red.process(current_value_red);
    stat_ir.process(current_value_ir);

    // Heart beat detection using value for red LED
    float current_value = high_pass_filter.process(current_value_red);
    float current_diff = differentiator.process(current_value);

    // Valid values?
    if (!isnan(current_diff) && !isnan(last_diff)) {

      // Detect Heartbeat - Zero-Crossing
      if (last_diff > 0 && current_diff < 0) {
        crossed = true;
        crossed_time = millis();
      }

      if (current_diff > 0) {
        crossed = false;
      }

      // Detect Heartbeat - Falling Edge Threshold
      if (crossed && current_diff < kEdgeThreshold) {
        if (last_heartbeat != 0 && crossed_time - last_heartbeat > 300) {
          // Show Results
          int bpm = 60000 / (crossed_time - last_heartbeat);
          float rred = (stat_red.maximum() - stat_red.minimum()) / stat_red.average();
          float rir = (stat_ir.maximum() - stat_ir.minimum()) / stat_ir.average();
          float r = rred / rir;
          float spo2 = kSpO2_A * r * r + kSpO2_B * r + kSpO2_C;

          if (bpm > 50 && bpm < 250) {
            // Average?
            if (kEnableAveraging) {
              int average_bpm = averager_bpm.process(bpm);
              int average_r = averager_r.process(r);
              int average_spo2 = averager_spo2.process(spo2);

              // Show if enough samples have been collected
              if (averager_bpm.count() >= kSampleThreshold) {
                Serial.print("HeartRate:");
                Serial.println(average_bpm);
                Serial.print("SpO2:");
                Serial.println(average_spo2);
              }
            } else {
              Serial.print("HeartRate:");
              Serial.println(bpm);
              Serial.print("SpO2:");
              Serial.println(spo2);
            }
          }

          // Reset statistic
          stat_red.reset();
          stat_ir.reset();
        }

        crossed = false;
        last_heartbeat = crossed_time;
      }
    }

    last_diff = current_diff;
  }
}

#define DIN 8
#define CS 9
#define CLK 10
uint8_t count = 1;
MATRIX7219 mx(DIN, CS, CLK, count);

#include <MAX3010x.h>
#include "filters.h"
#include "MATRIX7219.h"

MAX30105 sensor;

// Sensor
const auto kSamplingRate = sensor.SAMPLING_RATE_400SPS;
const float kSamplingFrequency = 400.0;

// Finger detection
const unsigned long kFingerThreshold = 10000;
const unsigned int kFingerCooldownMs = 500;

// Beat detection
const float kLowPassCutoff = 5.0;
const float kHighPassCutoff = 0.5;
const float kEdgeThreshold = -2000.0;

// Dot Matrix
#define DIN 8
#define CS 9
#define CLK 10
uint8_t count = 1;
MATRIX7219 mx(DIN, CS, CLK, count);

// Buzzer
#define BUZZER 4
const int TON_PAUSE = 125;
const int FREQ = 1200;
const int PAUSE = 300;

// Filter
LowPassFilter low_pass_filter(kLowPassCutoff, kSamplingFrequency);
HighPassFilter high_pass_filter(kHighPassCutoff, kSamplingFrequency);
Differentiator differentiator(kSamplingFrequency);

// Status
long finger_timestamp = 0;
bool finger_detected = false;

long last_heartbeat = 0;
float last_diff = NAN;
bool crossed = false;
long crossed_time = 0;

void setup() {
  Serial.begin(9600);

  if (sensor.begin() && sensor.setSamplingRate(kSamplingRate)) {
    Serial.println("Sensor initialized");
  } else {
    Serial.println("Sensor not found");
    while (1)
      ;
  }

  mx.begin();
  mx.clear();
  mx.setBrightness(3);
  drawHeartSmall();

  pinMode(BUZZER, OUTPUT);
}

void loop() {
  auto sample = sensor.readSample(1000);
  float red = sample.red;

  // Finger erkannt?
  if (red > kFingerThreshold) {
    if (millis() - finger_timestamp > kFingerCooldownMs) {
      finger_detected = true;
    }
  } else {
    // Reset wenn Finger weg
    finger_detected = false;
    finger_timestamp = millis();

    low_pass_filter.reset();
    high_pass_filter.reset();
    differentiator.reset();

    last_diff = NAN;
    crossed = false;
    last_heartbeat = 0;

    drawHeartSmall();
    return;
  }

  if (!finger_detected) {
    return;
  }

  // Signal filtern
  float filtered = low_pass_filter.process(red);
  float heartbeat_signal = high_pass_filter.process(filtered);
  float current_diff = differentiator.process(heartbeat_signal);

  if (!isnan(current_diff) && !isnan(last_diff)) {
    // Zero crossing
    if (last_diff > 0 && current_diff < 0) {
      crossed = true;
      crossed_time = millis();
    }

    if (current_diff > 0) {
      crossed = false;
    }

    // Beat erkannt
    if (crossed && current_diff < kEdgeThreshold) {
      if (last_heartbeat != 0 && crossed_time - last_heartbeat > 300) {
        int bpm = 60000 / (crossed_time - last_heartbeat);

        if (bpm > 50 && bpm < 250) {
          Serial.print("Beat! BPM: ");
          Serial.println(bpm);

          pulseHeart();
        }
      }

      crossed = false;
      last_heartbeat = crossed_time;
    }
  }

  last_diff = current_diff;
}

void pulseHeart() {
  drawHeartBig();
  tone(BUZZER, FREQ, TON_PAUSE);
  delay(PAUSE);
  drawHeartSmall();
  delay(PAUSE);
}

void drawHeartSmall() {
  mx.clear();
  mx.setRow(3, 0b00100100, 1);
  mx.setRow(4, 0b01111110, 1);
  mx.setRow(5, 0b01111110, 1);
  mx.setRow(6, 0b00111100, 1);
  mx.setRow(7, 0b00011000, 1);
}

void drawHeartBig() {
  mx.clear();
  mx.setRow(1, 0b00000000, 1);
  mx.setRow(2, 0b01100110, 1);
  mx.setRow(3, 0b10011001, 1);
  mx.setRow(4, 0b10000001, 1);
  mx.setRow(5, 0b01000010, 1);
  mx.setRow(6, 0b00100100, 1);
  mx.setRow(7, 0b00011000, 1);
}

Der MAX30102 liefert für DIY-Projekte und Experimente durchaus brauchbare Werte. Die Herzfrequenz (BPM) ist in der Regel relativ zuverlässig, während die Blutsauerstoffmessung (SpO2) stärker schwanken kann. Faktoren wie Fingerposition, Bewegung oder Umgebungslicht haben großen Einfluss auf die Genauigkeit.

Das ist ein häufiges Problem und liegt meist nicht am Sensor selbst. Typische Ursachen sind:

• Finger liegt nicht ruhig auf dem Sensor
• zu viel Umgebungslicht
• schlechter Kontakt zur Haut
• ungeeignete oder falsch konfigurierte Bibliothek

👉 Tipp: Finger ruhig auflegen und leicht andrücken, ohne den Sensor komplett abzudecken.

Der MAX30102 verwendet standardmäßig die I2C-Adresse: 0x57

Ja, der MAX30102 lässt sich problemlos mit klassischen Arduino-Boards wie dem Arduino Nano oder Arduino UNO betreiben. Wichtig ist lediglich die korrekte Verkabelung über die I2C-Pins (SDA/SCL).

Der MAX30102 ist der Nachfolger des MAX30100 und bietet einige Verbesserungen, unter anderem:

• stabilere Messwerte
• bessere Signalverarbeitung
• zusätzliche Funktionen wie einen Temperatursensor

Zudem ist der MAX30102 aktuell deutlich verbreiteter und wird von modernen Bibliotheken besser unterstützt.

Ein häufiger Grund ist die Verwendung eines „MAX3010x“-Moduls. Diese sind nicht immer sauber aufgebaut und können Probleme bei der Spannungsversorgung verursachen.

👉 Empfehlung: Ein Modul mit klarer Bezeichnung MAX30102 verwenden.

Nein. Der MAX30102 ist kein medizinisch zertifiziertes Gerät. Die gemessenen Werte dienen ausschließlich zu Demonstrations- und Lernzwecken und sollten nicht für medizinische Entscheidungen verwendet werden.

Ja, die Messwerte lassen sich problemlos weiterverarbeiten, zum Beispiel:

• Darstellung auf einem Display (OLED, LED Matrix)
• Übertragung per Bluetooth oder WiFi (z. B. mit ESP32)
• Speicherung in einer Datenbank oder Cloud