Beetle 树莓派 RP2350：健康监测系统 简单

#include <Wire.h>
#include "MAX30105.h"
#include "spo2_algorithm.h"
#include "heartRate.h"
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128             // OLED分辨率
#define SCREEN_HEIGHT 64             // OLED分辨率
#define OLED_RESET     -1            // 复位引脚，不接
#define BATT_PIN       29            // 电池检测引脚(IO29)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

MAX30105 particleSensor;

// 数据缓冲区和计算结果
#define SAMPLE_SIZE 100
uint32_t irBuffer[SAMPLE_SIZE];      // 红外光数据缓冲区
uint32_t redBuffer[SAMPLE_SIZE];     // 红光数据缓冲区
int32_t heartRateValue = 0;          // 心率值
int8_t validHeartRate = 0;           // 心率计算有效性标志
int32_t spo2Value = 0;               // 血氧饱和度值
int8_t validSPO2 = 0;                // 血氧计算有效性标志
float temperatureValue = 0.0;        // 温度值
const float TEMP_CALIBRATION = 0.5;  // 温度校准偏移量
int32_t signalStrength = 0;          // 信号强度指标

// 心率计算相关变量
const byte RATE_SIZE = 4;            // 心率平均值计算窗口大小
byte rates[RATE_SIZE];               // 心率值数组
byte rateSpot = 0;
long lastBeat = 0;                   // 上次心跳时间戳
uint32_t beatCount = 0;              // 心跳计数

// 显示区域定义
#define STATUS_AREA_Y      0
#define BATTERY_AREA_X    100
#define SPO2_AREA_Y       15
#define HR_AREA_Y         35
#define SIGNAL_AREA_Y     55

// 手指检测稳定性参数
const byte FINGER_STABILIZE_COUNT = 3;
byte fingerStableCount = 0;

// 状态评估常量
enum Status {
  STATUS_NORMAL,           // 正常
  STATUS_MILD_HYPOXIA,     // 轻度缺氧
  STATUS_SEVERE_HYPOXIA,   // 重度缺氧
  STATUS_TACHYCARDIA,      // 心动过速
  STATUS_BRADYCARDIA,      // 心动过缓
  STATUS_INVALID,          // 测量中
  STATUS_FINGER_MISSING    // 手指未放置
};

// 初始化传感器
bool initializeSensor() {
  Serial.println("MAX30102健康监测系统初始化中...");
  
  // 初始化传感器
  if (!particleSensor.begin(Wire, I2C_SPEED_FAST)) {
    Serial.println("错误：未找到MAX30102传感器，请检查接线和电源！");
    return false;
  }

  // 配置传感器参数（优化信号质量）
  byte ledBrightness = 40;   // 降低LED亮度，避免信号饱和
  byte sampleAverage = 8;    // 增加采样平均，提高稳定性
  byte ledMode = 2;          // 双模模式(红光+红外)
  byte sampleRate = 100;     // 采样率(100Hz)
  int pulseWidth = 411;      // 脉冲宽度
  int adcRange = 4096;       // ADC范围
  
  particleSensor.setup(ledBrightness, sampleAverage, ledMode, sampleRate, pulseWidth, adcRange);
  particleSensor.enableDIETEMPRDY();  // 启用温度测量
  
  Serial.println("传感器就绪");
  return true;
}

// 初始化显示屏
void initializeDisplay() {
  // 初始化OLED显示屏
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { 
    Serial.println(F("SSD1306显示屏初始化失败"));
    for(;;);
  }

  // 显示初始化画面（英文）
  clearDisplayArea(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println("MAX30105 Health Monitor");
  display.setTextSize(2);
  display.setCursor(30, 20);
  display.println("Initializing...");
  display.setTextSize(1);
  display.setCursor(0, 50);
  display.println("Place finger on sensor");
  display.display();
  delay(2000);
}

// 清除指定区域
void clearDisplayArea(int16_t x, int16_t y, int16_t w, int16_t h) {
  display.fillRect(x, y, w, h, SSD1306_BLACK);
}

// 检测手指是否正确放置（增强稳定性）
bool isFingerPresent() {
  while (!particleSensor.available()) 
    particleSensor.check();
  
  uint32_t irValue = particleSensor.getIR();
  signalStrength = irValue / 1000; // 计算信号强度指标
  
  // 连续稳定检测到手指才返回true
  if (irValue > 50000) {
    fingerStableCount = min(fingerStableCount + 1, FINGER_STABILIZE_COUNT);
  } else {
    fingerStableCount = 0;
  }
  
  return fingerStableCount >= FINGER_STABILIZE_COUNT;
}

// 获取电池电量百分比（适配分压电路）
int getBatteryLevel() {
  int adcValue = analogRead(BATT_PIN);
  float voltage = adcValue * (3.3 / 1023.0) * 2.0;
  int batteryPercent = constrain(map(voltage * 100, 300, 370, 0, 100), 0, 100);
  
  return batteryPercent;
}

// 获取血氧饱和度
int getSPO2() {
  return validSPO2 ? spo2Value : 0;
}

// 获取心率（添加数据过滤）
int getHeartbeat() {
  int hr = validHeartRate ? heartRateValue : 0;
  // 过滤异常心率值（正常范围：20-200 BPM）
  return (hr >= 20 && hr <= 200) ? hr : 0;
}

// 获取温度(摄氏度)
float getTemperature_C() {
  return temperatureValue;
}

// 计算平均心率
int calculateAverageRate() {
  byte sum = 0;
  byte count = 0;
  for (byte i = 0; i < RATE_SIZE; i++) {
    if (rates[i] > 20 && rates[i] <= 200) { // 只统计有效心率
      sum += rates[i];
      count++;
    }
  }
  return count > 0 ? sum / count : 0;
}

// 评估综合状态
Status evaluateStatus() {
  if (!isFingerPresent()) return STATUS_FINGER_MISSING;
  if (!validHeartRate || !validSPO2) return STATUS_INVALID;
  
  int hr = getHeartbeat();
  int spo2 = getSPO2();
  
  if (spo2 >= 95 && hr >= 60 && hr <= 100) {
    return STATUS_NORMAL;
  } else if (spo2 >= 90 && spo2 < 95) {
    return STATUS_MILD_HYPOXIA;
  } else if (spo2 < 90) {
    return STATUS_SEVERE_HYPOXIA;
  } else if (hr > 100 && hr <= 200) {
    return STATUS_TACHYCARDIA;
  } else if (hr < 60 && hr >= 20) {
    return STATUS_BRADYCARDIA;
  } else {
    return STATUS_INVALID;
  }
}

// 获取状态文本描述（中文，用于串口输出）
const char* getStatusTextCN(Status status) {
  switch(status) {
    case STATUS_NORMAL: return "正常";
    case STATUS_MILD_HYPOXIA: return "轻度缺氧";
    case STATUS_SEVERE_HYPOXIA: return "重度缺氧";
    case STATUS_TACHYCARDIA: return "心动过速";
    case STATUS_BRADYCARDIA: return "心动过缓";
    case STATUS_INVALID: return "测量中...";
    case STATUS_FINGER_MISSING: return "请放手指";
    default: return "未知";
  }
}

// 获取状态文本描述（英文，用于OLED显示）
const char* getStatusTextEN(Status status) {
  switch(status) {
    case STATUS_NORMAL: return "Normal";
    case STATUS_MILD_HYPOXIA: return "Mild Hypoxia";
    case STATUS_SEVERE_HYPOXIA: return "Severe Hypoxia";
    case STATUS_TACHYCARDIA: return "Tachycardia";
    case STATUS_BRADYCARDIA: return "Bradycardia";
    case STATUS_INVALID: return "Measuring";
    case STATUS_FINGER_MISSING: return "Place Finger";
    default: return "Unknown";
  }
}

// 更新OLED显示内容（英文）
void updateOLEDDisplay() {
  Status currentStatus = evaluateStatus();
  
  // 清屏准备显示新数据
  display.clearDisplay();
  
  // 显示状态文本（英文）
  clearDisplayArea(0, STATUS_AREA_Y, SCREEN_WIDTH, 10);
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, STATUS_AREA_Y);
  display.print("Stat:");
  display.println(getStatusTextEN(currentStatus));
  
  // 显示电池电量
  clearDisplayArea(BATTERY_AREA_X, STATUS_AREA_Y, SCREEN_WIDTH - BATTERY_AREA_X, 10);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(BATTERY_AREA_X + 3, STATUS_AREA_Y);
  display.print(getBatteryLevel());
  display.println("%");
  
  // 显示血氧数据
  clearDisplayArea(0, SPO2_AREA_Y, SCREEN_WIDTH, 15);
  display.setTextSize(2);
  display.setCursor(0, SPO2_AREA_Y);
  display.print("SPO2: ");
  if (validSPO2 && spo2Value >= 70 && spo2Value <= 100) {
    display.setTextColor(SSD1306_WHITE);
    display.print(spo2Value);
    display.println("%");
  } else {
    display.setTextColor(SSD1306_BLACK, SSD1306_WHITE);
    display.println("-- %");
  }
  
  // 显示心率数据
  clearDisplayArea(0, HR_AREA_Y, SCREEN_WIDTH, 15);
  display.setTextSize(2);
  display.setCursor(0, HR_AREA_Y);
  display.print("HR: ");
  if (validHeartRate && heartRateValue >= 20 && heartRateValue <= 200) {
    display.setTextColor(SSD1306_WHITE);
    display.print(heartRateValue);
    display.print(" BPM");
  } else {
    display.setTextColor(SSD1306_BLACK, SSD1306_WHITE);
    display.println("-- BPM");
  }
  
  // 显示信号强度
  clearDisplayArea(0, SIGNAL_AREA_Y, SCREEN_WIDTH, 10);
  display.setTextSize(1);
  display.setCursor(0, SIGNAL_AREA_Y);
  display.print("Signal: ");
  display.print(min(signalStrength, 100)); // 限制最大值为100
  display.print("/100");
  
  // 显示心跳动画
  if (validHeartRate && beatCount % 2 == 0) {
    clearDisplayArea(115, SIGNAL_AREA_Y, 10, 10);
    display.setTextSize(1);
    display.setCursor(115, SIGNAL_AREA_Y);
    display.print("♥");
  } else {
    clearDisplayArea(115, SIGNAL_AREA_Y, 10, 10);
  }
  
  // 将缓冲区内容刷新到屏幕
  display.display();
}

// 串口输出监测数据（中文）
void printSensorDataToSerial() {
  Status currentStatus = evaluateStatus();
  
  // 输出时间戳
  Serial.print("时间: ");
  Serial.print(millis() / 1000);
  Serial.println("秒");
  
  // 输出状态
  Serial.print("状态: ");
  Serial.println(getStatusTextCN(currentStatus));
  
  // 输出血氧
  Serial.print("血氧饱和度: ");
  if (validSPO2 && spo2Value >= 70 && spo2Value <= 100) {
    Serial.print(spo2Value);
    Serial.println(" %");
  } else {
    Serial.println("未检测到");
  }
  
  // 输出心率
  Serial.print("心率: ");
  if (validHeartRate && heartRateValue >= 20 && heartRateValue <= 200) {
    Serial.print(heartRateValue);
    Serial.print(" BPM (平均: ");
    Serial.print(calculateAverageRate());
    Serial.println(" BPM)");
  } else {
    Serial.println("未检测到");
  }
  
  // 输出信号强度
  Serial.print("信号强度: ");
  Serial.print(min(signalStrength, 100)); // 限制最大值为100
  Serial.println("/100");
  
  // 输出电池电量
  Serial.print("电池电量: ");
  Serial.print(getBatteryLevel());
  Serial.println("%");
  
  // 输出温度
  Serial.print("传感器温度: ");
  Serial.print(getTemperature_C(), 1);
  Serial.println(" °C");
  
  // 分隔线
  Serial.println("===================================");
  Serial.println();
}

// 采集一次完整数据
void collectSensorData() {
  // 检测手指是否放置
  if (!isFingerPresent()) {
    validHeartRate = 0;
    validSPO2 = 0;
    return;
  }
  
  // 数据缓冲区滑动
  for (byte i = 25; i < SAMPLE_SIZE; i++) {
    redBuffer[i - 25] = redBuffer[i];
    irBuffer[i - 25] = irBuffer[i];
  }

  // 采集新数据
  for (byte i = SAMPLE_SIZE - 25; i < SAMPLE_SIZE; i++) {
    while (!particleSensor.available()) 
      particleSensor.check();
    
    redBuffer[i] = particleSensor.getRed();
    irBuffer[i] = particleSensor.getIR();
    particleSensor.nextSample();
  }

  // 计算心率和血氧
  maxim_heart_rate_and_oxygen_saturation(irBuffer, SAMPLE_SIZE, redBuffer, &spo2Value, &validSPO2, &heartRateValue, &validHeartRate);
  
  // 过滤异常心率值
  if (validHeartRate && (heartRateValue < 20 || heartRateValue > 200)) {
    validHeartRate = 0;
  }
  
  // 过滤异常血氧值
  if (validSPO2 && (spo2Value < 70 || spo2Value > 100)) {
    validSPO2 = 0;
  }
  
  // 更新心率平均值计算
  if (validHeartRate) {
    long irValue = particleSensor.getIR();
    if (checkForBeat(irValue) == true) {
      beatCount++;
      long delta = millis() - lastBeat;
      lastBeat = millis();

      float bpm = 60 / (delta / 1000.0);
      if (bpm > 20 && bpm <= 200) {
        rates[rateSpot++] = (byte)bpm;
        rateSpot %= RATE_SIZE;
      }
    }
  }
  
  // 读取温度数据
  temperatureValue = particleSensor.readTemperature() + TEMP_CALIBRATION;
}

// 显示错误信息（英文）
void displayError(const char* message) {
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println("ERROR");
  display.setTextSize(2);
  display.setCursor(0, 20);
  display.println(message);
  display.setTextSize(1);
  display.setCursor(0, 50);
  display.println("Please restart device");
  display.display();
}

void setup() {
  Serial.begin(115200);
  pinMode(BATT_PIN, INPUT);
  
  initializeDisplay();
  
  if (!initializeSensor()) {
    displayError("Sensor Connection Failed");
    while (1) delay(1000);  // 保持错误状态
  }
  
  lastBeat = millis();
  memset(rates, 0, sizeof(rates)); // 初始化心率数组
  
  // 串口输出初始化完成信息
  Serial.println("初始化完成，请将手指放在传感器上");
  Serial.println("开始测量...");
  Serial.println("===================================");
}

void loop() {
  static unsigned long lastUpdateTime = 0;
  static unsigned long lastSensorCheckTime = 0;
  static unsigned long lastSerialOutputTime = 0;
  
  // 每100ms检查传感器状态
  if (millis() - lastSensorCheckTime >= 100) {
    collectSensorData();
    lastSensorCheckTime = millis();
  }
  
  // 每秒更新一次OLED显示
  if (millis() - lastUpdateTime >= 1000) {
    updateOLEDDisplay();
    lastUpdateTime = millis();
  }
  
  // 每2秒串口输出一次数据
  if (millis() - lastSerialOutputTime >= 2000) {
    printSensorDataToSerial();
    lastSerialOutputTime = millis();
  }
  
  // 低功耗延时
  delay(10);
}