How to Build a Fitness Wristband Prototype with ESP32

// Fitness Wristband — ESP32 + MAX30102 + MPU6050 + SSD1306 OLED
// Heart rate uses real beat detection via SparkFun MAX3010x heartRate.h.
// The display redraws at ~4 Hz; beat sampling runs every loop() iteration
// so no beats are missed between redraws. This split is important: the
// MAX30102 FIFO fills quickly and stale reads skew timing calculations.

#include <Wire.h>
#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_SSD1306.h>
#include <MAX30105.h>
#include "heartRate.h"

// ── Pin definitions ──────────────────────────────────────────────────────────
#define SDA_PIN     21
#define SCL_PIN     22
#define HR_INT_PIN  19
#define VIBE_PIN    25
#define BTN_PIN     33

// ── Display ──────────────────────────────────────────────────────────────────
#define SCREEN_W 128
#define SCREEN_H  64
Adafruit_SSD1306 display(SCREEN_W, SCREEN_H, &Wire, -1);

// ── Sensors ──────────────────────────────────────────────────────────────────
Adafruit_MPU6050 mpu;
MAX30105 particleSensor;

// ── Step counting ────────────────────────────────────────────────────────────
unsigned long steps       = 0;
unsigned long lastStepMs  = 0;
bool          stepHigh    = false;

// ── Display mode cycling ─────────────────────────────────────────────────────
int  displayMode    = 0;   // 0 = Health, 1 = Motion, 2 = Summary
bool btnWasPressed  = false;

// ── Heart-rate beat detection ────────────────────────────────────────────────
// Rolling average over RATE_SIZE beats for stable display.
// Fewer samples → more responsive but noisier; 4 is a good wristband trade-off.
#define RATE_SIZE 4
float beatsPerMinute          = 0.0f;
float beatAvg                 = 0.0f;
float rates[RATE_SIZE]        = {0};
byte  rateSpot                = 0;
long  lastBeatMs              = 0;

// ── OLED refresh throttle ────────────────────────────────────────────────────
// Beat sampling runs every loop(); OLED only redraws every DISPLAY_INTERVAL ms.
// This keeps the I2C bus free for continuous sensor polling and prevents the
// ~25 ms SSD1306 write from adding jitter to beat-interval measurements.
#define DISPLAY_INTERVAL 250   // ms → ~4 FPS, responsive and battery-friendly
unsigned long lastDisplayMs = 0;

// ── Forward declarations ─────────────────────────────────────────────────────
void vibrate(int durationMs);
void drawHealth(bool fingerPresent, float bpm, unsigned long stepCount);
void drawMotion(float ax, float ay, float az, float mag);
void drawSummary(unsigned long stepCount, long ir);

// ─────────────────────────────────────────────────────────────────────────────
void setup() {
  Serial.begin(115200);
  delay(100);

  Wire.begin(SDA_PIN, SCL_PIN);

  // MPU6050
  if (!mpu.begin()) {
    Serial.println("MPU6050 not found — check wiring on GPIO21/22");
  } else {
    mpu.setAccelerometerRange(MPU6050_RANGE_8_G);
    mpu.setFilterBandwidth(MPU6050_BAND_21_HZ);
    Serial.println("MPU6050 OK");
  }

  // MAX30102
  if (!particleSensor.begin(Wire, I2C_SPEED_FAST)) {
    Serial.println("MAX30102 not found — check wiring on GPIO21/22");
  } else {
    // Default setup: IR LED 6.4 mA, 400 Hz sample rate, 411 µs pulse width
    particleSensor.setup();
    particleSensor.setPulseAmplitudeRed(0x0A);  // dim red LED (SpO2 not used here)
    particleSensor.setPulseAmplitudeGreen(0);    // green off
    Serial.println("MAX30102 OK");
  }

  // SSD1306 OLED
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println("SSD1306 not found — check wiring on GPIO21/22");
  }
  display.setTextColor(SSD1306_WHITE);
  display.clearDisplay();
  display.display();

  // GPIO
  pinMode(VIBE_PIN, OUTPUT);
  digitalWrite(VIBE_PIN, LOW);
  pinMode(BTN_PIN, INPUT_PULLUP);

  Serial.println("Wristband ready");
  vibrate(60);  // startup haptic confirmation
}

// ─────────────────────────────────────────────────────────────────────────────
void loop() {
  // ── Mode button ─────────────────────────────────────────────────────────
  bool btnNow = !digitalRead(BTN_PIN);
  if (btnNow && !btnWasPressed) {
    displayMode = (displayMode + 1) % 3;
    vibrate(40);
  }
  btnWasPressed = btnNow;

  // ── Step counting (MPU6050) ──────────────────────────────────────────────
  sensors_event_t a, g, temp;
  mpu.getEvent(&a, &g, &temp);
  float accelMag = sqrt(
    a.acceleration.x * a.acceleration.x +
    a.acceleration.y * a.acceleration.y +
    a.acceleration.z * a.acceleration.z
  );

  // Simple peak-threshold step detector.
  // 13.0 m/s² ≈ 1.3 g — typical heel-strike peak; 300 ms refractory prevents
  // double-counting the same step from sensor ringing.
  if (accelMag > 13.0f && !stepHigh && (millis() - lastStepMs) > 300) {
    steps++;
    stepHigh   = true;
    lastStepMs = millis();
    if (steps % 500 == 0) vibrate(80);  // milestone buzz every 500 steps
  }
  if (accelMag < 11.0f) stepHigh = false;

  // ── Heart-rate beat detection (MAX30102) ─────────────────────────────────
  // Read the latest sample from the FIFO — runs every loop() so no samples
  // accumulate, which would cause latency in beat-interval measurements.
  long ir = particleSensor.getIR();
  bool fingerPresent = (ir > 50000);  // ~50k counts distinguishes fingertip from ambient

  if (fingerPresent) {
    if (checkForBeat(ir)) {
      long now     = millis();
      long delta   = now - lastBeatMs;
      lastBeatMs   = now;

      // Instantaneous BPM from inter-beat interval
      beatsPerMinute = 60000.0f / (float)delta;

      // Only keep physiologically plausible readings (20–255 bpm)
      if (beatsPerMinute > 20.0f && beatsPerMinute < 255.0f) {
        rates[rateSpot++] = beatsPerMinute;
        rateSpot %= RATE_SIZE;

        // Rolling average over the last RATE_SIZE beats
        float sum = 0.0f;
        for (byte i = 0; i < RATE_SIZE; i++) sum += rates[i];
        beatAvg = sum / RATE_SIZE;
      }
    }
  } else {
    // Finger removed — reset beat state so next placement starts fresh
    beatsPerMinute = 0.0f;
    beatAvg        = 0.0f;
    lastBeatMs     = 0;
    rateSpot       = 0;
    for (byte i = 0; i < RATE_SIZE; i++) rates[i] = 0.0f;
  }

  // ── OLED redraw (throttled) ───────────────────────────────────────────────
  // Draw at most every DISPLAY_INTERVAL ms. Beat sampling above runs
  // unconditionally every loop() — decoupling the two is what keeps BPM
  // accurate regardless of how long clearDisplay()/display() take.
  if (millis() - lastDisplayMs >= DISPLAY_INTERVAL) {
    lastDisplayMs = millis();

    display.clearDisplay();
    display.setCursor(0, 0);

    if (displayMode == 0) {
      drawHealth(fingerPresent, beatAvg, steps);
    } else if (displayMode == 1) {
      drawMotion(a.acceleration.x, a.acceleration.y, a.acceleration.z, accelMag);
    } else {
      drawSummary(steps, ir);
    }

    display.display();
  }
}

// ─────────────────────────────────────────────────────────────────────────────
// Draw helpers
// ─────────────────────────────────────────────────────────────────────────────

void drawHealth(bool fingerPresent, float bpm, unsigned long stepCount) {
  display.setTextSize(1);
  display.println("-- Health --");
  display.println();

  display.print("BPM:  ");
  display.setTextSize(2);
  if (!fingerPresent) {
    display.println("--");
    display.setTextSize(1);
    display.println("Place finger");
  } else if (bpm < 1.0f) {
    display.println("...");   // finger present but still acquiring
    display.setTextSize(1);
    display.println("Measuring...");
  } else {
    display.println((int)bpm);
    display.setTextSize(1);
    display.println();
  }

  display.setTextSize(1);
  display.print("Steps: ");
  display.println(stepCount);
}

void drawMotion(float ax, float ay, float az, float mag) {
  display.setTextSize(1);
  display.println("-- Motion --");
  display.printf("X: %6.2f\n", ax);
  display.printf("Y: %6.2f\n", ay);
  display.printf("Z: %6.2f\n", az);
  display.printf("Mag: %5.1f\n", mag);
}

void drawSummary(unsigned long stepCount, long ir) {
  display.setTextSize(1);
  display.println("-- Summary --");
  display.println();
  display.printf("Steps today: %lu\n", stepCount);
  display.printf("IR signal:   %ld\n", ir);
}

// ─────────────────────────────────────────────────────────────────────────────
void vibrate(int durationMs) {
  digitalWrite(VIBE_PIN, HIGH);
  delay(durationMs);
  digitalWrite(VIBE_PIN, LOW);
}

// Run this and build other cool things at schematik.io