Fingertip Pulse Oximeter

#include <Arduino.h>
#include <Wire.h>
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
#include "MAX30105.h"
#include "spo2_algorithm.h"

constexpr int I2C_SDA_PIN = 6;
constexpr int I2C_SCL_PIN = 7;
constexpr uint8_t SAMPLE_AVERAGE = 4;
constexpr uint8_t LED_MODE_RED_IR = 2;
constexpr int SAMPLE_RATE_HZ = 100;
constexpr int LED_PULSE_WIDTH_US = 411;
constexpr int ADC_RANGE_NA = 4096;
constexpr int BUFFER_LENGTH = 100;
constexpr int NEW_SAMPLES_PER_RESULT = 25;
constexpr uint32_t FINGER_PRESENT_IR = 50000;
constexpr uint32_t NOTIFY_INTERVAL_MS = 2000;

MAX30105 pulseSensor;
BLECharacteristic *heartRateCharacteristic;
BLECharacteristic *oxygenCharacteristic;
uint32_t irBuffer[BUFFER_LENGTH];
uint32_t redBuffer[BUFFER_LENGTH];
int32_t bloodOxygenPercent = 0;
int8_t bloodOxygenValid = 0;
int32_t heartRateBpm = 0;
int8_t heartRateValid = 0;
uint32_t lastNotifyMs = 0;

bool waitForSample(uint32_t timeoutMs) {
  const uint32_t started = millis();
  while (!pulseSensor.available()) {
    pulseSensor.check();
    if (millis() - started >= timeoutMs) return false;
    delay(1);
  }
  return true;
}

bool collectSample(uint32_t &red, uint32_t &ir) {
  if (!waitForSample(1000)) return false;
  red = pulseSensor.getRed();
  ir = pulseSensor.getIR();
  pulseSensor.nextSample();
  return true;
}

void publishReading() {
  if (millis() - lastNotifyMs < NOTIFY_INTERVAL_MS) return;
  lastNotifyMs = millis();
  const bool fingerPresent = irBuffer[BUFFER_LENGTH - 1] >= FINGER_PRESENT_IR;
  const bool valid = fingerPresent && heartRateValid && bloodOxygenValid &&
                     heartRateBpm > 30 && heartRateBpm < 220 &&
                     bloodOxygenPercent >= 70 && bloodOxygenPercent <= 100;
  uint8_t heartRatePacket[2] = {0x00, 0x00};
  uint8_t oxygenPacket[1] = {0};
  if (valid) {
    heartRatePacket[1] = static_cast<uint8_t>(heartRateBpm);
    oxygenPacket[0] = static_cast<uint8_t>(bloodOxygenPercent);
  }
  heartRateCharacteristic->setValue(heartRatePacket, sizeof(heartRatePacket));
  oxygenCharacteristic->setValue(oxygenPacket, sizeof(oxygenPacket));
  heartRateCharacteristic->notify();
  oxygenCharacteristic->notify();
}

void calculateAndPublish() {
  maxim_heart_rate_and_oxygen_saturation(irBuffer, BUFFER_LENGTH, redBuffer,
    &bloodOxygenPercent, &bloodOxygenValid, &heartRateBpm, &heartRateValid);
  publishReading();
}

void setupBluetooth() {
  BLEDevice::init("RingPulse");
  BLEServer *server = BLEDevice::createServer();
  BLEService *heartRateService = server->createService("180D");
  heartRateCharacteristic = heartRateService->createCharacteristic(
    "2A37", BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
  heartRateCharacteristic->addDescriptor(new BLE2902());
  BLEService *oxygenService = server->createService("9b6d0001-5c7e-4f6e-9b18-7cb00b1b0001");
  oxygenCharacteristic = oxygenService->createCharacteristic(
    "9b6d0002-5c7e-4f6e-9b18-7cb00b1b0001",
    BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
  oxygenCharacteristic->addDescriptor(new BLE2902());
  heartRateService->start();
  oxygenService->start();
  BLEAdvertising *advertising = BLEDevice::getAdvertising();
  advertising->addServiceUUID(heartRateService->getUUID());
  advertising->addServiceUUID(oxygenService->getUUID());
  advertising->setScanResponse(true);
  BLEDevice::startAdvertising();
}

void setup() {
  Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN);
  // The sensor is mounted under the finger, with the XIAO stacked above it.
  // Use standard-mode I2C for margin with the short flexible interconnect.
  Wire.setClock(100000);
  setupBluetooth();
  if (!pulseSensor.begin(Wire, I2C_SPEED_FAST)) while (true) delay(1000);
  pulseSensor.setup(0x1F, SAMPLE_AVERAGE, LED_MODE_RED_IR, SAMPLE_RATE_HZ,
                    LED_PULSE_WIDTH_US, ADC_RANGE_NA);
  pulseSensor.setPulseAmplitudeGreen(0);
  pulseSensor.clearFIFO();
  for (int i = 0; i < BUFFER_LENGTH; ++i) {
    if (!collectSample(redBuffer[i], irBuffer[i])) while (true) delay(1000);
  }
  calculateAndPublish();
}

void loop() {
  for (int i = NEW_SAMPLES_PER_RESULT; i < BUFFER_LENGTH; ++i) {
    redBuffer[i - NEW_SAMPLES_PER_RESULT] = redBuffer[i];
    irBuffer[i - NEW_SAMPLES_PER_RESULT] = irBuffer[i];
  }
  for (int i = BUFFER_LENGTH - NEW_SAMPLES_PER_RESULT; i < BUFFER_LENGTH; ++i) {
    if (!collectSample(redBuffer[i], irBuffer[i])) {
      delay(50);
      return;
    }
  }
  calculateAndPublish();
}