血氧饱和度计算（SpO2 Calculation）¶
学习目标¶
完成本模块后，你将能够： - 深入理解血氧饱和度测量的物理和生理学原理 - 掌握光电容积描记（PPG）信号的采集和处理 - 实现完整的SpO2计算算法 - 处理运动伪影和环境光干扰 - 实现脉率检测和灌注指数计算 - 理解并实现校准曲线和补偿算法 - 符合ISO 80601-2-61医疗器械标准 - 优化算法以适应不同肤色和生理状态
前置知识¶
- 光学基础（朗伯-比尔定律）
- 血液生理学和血红蛋白特性
- 数字信号处理理论
- 数字滤波器设计
- FFT频域分析
- ADC采样和光电传感器原理
- C语言编程和嵌入式系统
内容¶
概念介绍¶
血氧饱和度（SpO2）是指血液中氧合血红蛋白占全部血红蛋白的百分比，是评估呼吸功能和氧合状态的关键指标。 脉搏血氧仪通过无创光学方法测量SpO2，是现代医疗监护中最常用的设备之一。
SpO2的临床意义： - 正常范围：95%-100% - 轻度缺氧：90%-94% - 中度缺氧：85%-89% - 重度缺氧：<85% - 危急值：<80%（需要立即干预）
应用场景： - 手术监护：实时监测患者氧合状态 - 重症监护：ICU患者持续监测 - 睡眠监测：检测睡眠呼吸暂停 - 运动医学：评估运动时氧合能力 - 慢性病管理：COPD、心衰患者家庭监测 - 高原医学：高海拔环境适应性评估
测量原理¶
朗伯-比尔定律¶
血氧饱和度测量基于朗伯-比尔定律（Lambert-Beer Law）：
或者：
其中： - I：透射光强度 - I₀：入射光强度 - A：吸光度（Absorbance） - ε：摩尔消光系数（L/(mol·cm)） - c：溶液浓度（mol/L） - d：光程长度（cm）
在血氧测量中的应用： - 不同波长的光对氧合血红蛋白（HbO₂）和还原血红蛋白（Hb）的吸收率不同 - 通过测量两个波长的吸光度比值，可以计算血氧饱和度
血红蛋白的光吸收特性¶
// 血红蛋白吸收系数（单位：cm⁻¹/(g/L)）
typedef struct {
float wavelength; // 波长（nm）
float hb_absorption; // 还原血红蛋白吸收系数
float hbo2_absorption; // 氧合血红蛋白吸收系数
} Hemoglobin_Absorption_t;
// 关键波长的吸收系数
static const Hemoglobin_Absorption_t absorption_data[] = {
// 红光（660nm）
{660.0f, 0.0270f, 0.0050f}, // Hb吸收 > HbO₂吸收
// 红外光（940nm）
{940.0f, 0.0050f, 0.0110f}, // HbO₂吸收 > Hb吸收
// 等吸收点（805nm）
{805.0f, 0.0110f, 0.0110f} // Hb吸收 = HbO₂吸收
};
关键观察： 1. 红光（660nm）：还原血红蛋白吸收更多（暗红色血液） 2. 红外光（940nm）：氧合血红蛋白吸收更多（鲜红色血液） 3. 等吸收点（805nm）：两种血红蛋白吸收相同
双波长测量原理¶
LED红光(660nm)
↓
┌──────────────┐
│ 手指组织 │
│ ┌────────┐ │
│ │ 动脉血 │ │ ← 脉动成分（AC）
│ └────────┘ │
│ 静脉血 │ ← 恒定成分（DC）
│ 组织 │
└──────────────┘
↓
光电检测器
LED红外光(940nm)
↓
┌──────────────┐
│ 手指组织 │
│ ┌────────┐ │
│ │ 动脉血 │ │ ← 脉动成分（AC）
│ └────────┘ │
│ 静脉血 │ ← 恒定成分（DC）
│ 组织 │
└──────────────┘
↓
光电检测器
信号成分： - DC成分：静脉血、组织、骨骼等恒定吸收 - AC成分：动脉血脉动引起的周期性变化（约1-2%）
比值计算：
其中： - AC_red：红光的交流成分（脉动幅度） - DC_red：红光的直流成分（平均值） - AC_ir：红外光的交流成分 - DC_ir：红外光的直流成分
SpO2计算：
通常使用经验校准曲线：
或更精确的多项式：
说明: 这是SpO2计算的经验公式。R是红光和红外光的AC/DC比值的比率，通过多项式拟合得到SpO2值。系数a₀、a₁、a₂、a₃需要通过校准实验确定，不同的传感器可能有不同的系数。
硬件架构¶
光学传感器配置¶
// SpO2传感器配置
typedef struct {
// LED配置
float red_led_wavelength; // 红光波长（nm）
float ir_led_wavelength; // 红外光波长（nm）
float red_led_current; // 红光LED电流（mA）
float ir_led_current; // 红外光LED电流（mA）
uint16_t led_pulse_width; // LED脉冲宽度（μs）
// 光电检测器配置
float photodiode_gain; // 光电二极管增益
float transimpedance_gain; // 跨阻放大器增益
// ADC配置
uint8_t adc_resolution; // ADC分辨率（bits）
float adc_vref; // ADC参考电压（V）
float sample_rate; // 采样率（Hz）
// 时序配置
uint16_t red_sample_time; // 红光采样时间（μs）
uint16_t ir_sample_time; // 红外光采样时间（μs）
uint16_t ambient_sample_time; // 环境光采样时间（μs）
} SpO2_Sensor_Config_t;
// 推荐配置
#define SPO2_RED_WAVELENGTH 660.0f // 660nm红光
#define SPO2_IR_WAVELENGTH 940.0f // 940nm红外光
#define SPO2_LED_CURRENT_MIN 5.0f // 最小LED电流
#define SPO2_LED_CURRENT_MAX 50.0f // 最大LED电流
#define SPO2_LED_PULSE_WIDTH 100 // 100μs脉冲宽度
#define SPO2_SAMPLE_RATE 100.0f // 100Hz采样率
#define SPO2_ADC_RESOLUTION 16 // 16位ADC
时分复用采样¶
为了避免两个LED之间的光学串扰，使用时分复用：
// 采样序列
typedef enum {
SAMPLE_RED = 0, // 采样红光
SAMPLE_IR, // 采样红外光
SAMPLE_AMBIENT, // 采样环境光
SAMPLE_DARK, // 暗电流采样
SAMPLE_STATE_COUNT
} Sample_State_t;
// 采样时序控制
typedef struct {
Sample_State_t current_state;
uint32_t state_counter;
uint16_t samples_per_state;
// 原始ADC值
uint16_t red_adc;
uint16_t ir_adc;
uint16_t ambient_adc;
uint16_t dark_adc;
// 校正后的值
float red_corrected;
float ir_corrected;
} SpO2_Sampling_t;
// 采样状态机
void spo2_sampling_state_machine(SpO2_Sampling_t* sampling,
SpO2_Sensor_Config_t* config) {
switch (sampling->current_state) {
case SAMPLE_RED:
// 1. 打开红光LED
led_red_on(config->red_led_current);
// 2. 等待稳定（LED上升时间）
delay_us(10);
// 3. 采样
sampling->red_adc = adc_read_photodiode();
// 4. 关闭LED
led_red_off();
// 5. 切换到下一状态
sampling->current_state = SAMPLE_IR;
break;
case SAMPLE_IR:
// 1. 打开红外LED
led_ir_on(config->ir_led_current);
// 2. 等待稳定
delay_us(10);
// 3. 采样
sampling->ir_adc = adc_read_photodiode();
// 4. 关闭LED
led_ir_off();
// 5. 切换到下一状态
sampling->current_state = SAMPLE_AMBIENT;
break;
case SAMPLE_AMBIENT:
// 所有LED关闭，采样环境光
sampling->ambient_adc = adc_read_photodiode();
sampling->current_state = SAMPLE_DARK;
break;
case SAMPLE_DARK:
// 采样暗电流（用于校准）
sampling->dark_adc = adc_read_photodiode();
// 校正信号（减去环境光和暗电流）
sampling->red_corrected =
(float)(sampling->red_adc - sampling->ambient_adc - sampling->dark_adc);
sampling->ir_corrected =
(float)(sampling->ir_adc - sampling->ambient_adc - sampling->dark_adc);
sampling->current_state = SAMPLE_RED;
break;
}
}
PPG信号处理¶
PPG信号特征¶
光电容积描记（Photoplethysmography, PPG）信号反映血管容积的周期性变化：
// PPG信号特征
typedef struct {
float dc_component; // DC成分（平均值）
float ac_amplitude; // AC成分（脉动幅度）
float ac_dc_ratio; // AC/DC比值（调制深度）
float pulse_rate; // 脉率（bpm）
float perfusion_index; // 灌注指数（%）
float signal_quality; // 信号质量指标
} PPG_Features_t;
// PPG波形参数
typedef struct {
float systolic_peak; // 收缩峰值
float diastolic_valley; // 舒张谷值
float dicrotic_notch; // 重搏切迹
float pulse_width; // 脉搏宽度（ms）
float rise_time; // 上升时间（ms）
float fall_time; // 下降时间（ms）
} PPG_Waveform_t;
完整的PPG滤波链¶
// PPG滤波器组
typedef struct {
// 直流阻断（高通滤波器）
Biquad_Filter_t hpf_dc; // 0.5Hz高通
// 低通滤波器（抗混叠）
Biquad_Filter_t lpf_alias; // 5Hz低通
// 陷波滤波器（可选，去除特定干扰）
Biquad_Filter_t notch_motion; // 运动频率陷波
// 移动平均滤波器（平滑）
MovingAverage_t ma_smooth;
// 自适应滤波器（运动伪影抑制）
Adaptive_Filter_t adaptive;
float sample_rate;
} PPG_Filter_Bank_t;
// 初始化PPG滤波器组
void ppg_filter_bank_init(PPG_Filter_Bank_t* fb, float sample_rate) {
fb->sample_rate = sample_rate;
// 1. 高通滤波器（0.5Hz）- 去除DC漂移
biquad_highpass_init(&fb->hpf_dc, 0.5f, 0.707f, sample_rate);
// 2. 低通滤波器（5Hz）- 去除高频噪声
// PPG主要频率成分在0.5-5Hz（30-300 bpm）
biquad_lowpass_init(&fb->lpf_alias, 5.0f, 0.707f, sample_rate);
// 3. 移动平均滤波器（5点）
moving_average_init(&fb->ma_smooth, 5);
// 4. 自适应滤波器（用于运动伪影抑制）
adaptive_filter_init(&fb->adaptive, 32, 0.01f);
}
// PPG信号滤波处理
float ppg_filter_process(PPG_Filter_Bank_t* fb, float raw_ppg) {
float signal = raw_ppg;
// 级联滤波
signal = biquad_process(&fb->hpf_dc, signal); // 去DC
signal = biquad_process(&fb->lpf_alias, signal); // 去高频
signal = moving_average_process(&fb->ma_smooth, signal); // 平滑
return signal;
}
DC和AC成分提取¶
// DC/AC分离器
typedef struct {
// DC提取（低通滤波器）
Biquad_Filter_t lpf_dc; // 0.1Hz低通
// AC提取（带通滤波器）
Biquad_Filter_t bpf_ac_low; // 0.5Hz高通
Biquad_Filter_t bpf_ac_high; // 5Hz低通
// 当前值
float dc_value;
float ac_value;
// 统计
float ac_min;
float ac_max;
float ac_amplitude;
} DC_AC_Separator_t;
// 初始化DC/AC分离器
void dc_ac_separator_init(DC_AC_Separator_t* sep, float sample_rate) {
// DC提取：非常低的截止频率
biquad_lowpass_init(&sep->lpf_dc, 0.1f, 0.707f, sample_rate);
// AC提取：带通滤波器（0.5-5Hz）
biquad_highpass_init(&sep->bpf_ac_low, 0.5f, 0.707f, sample_rate);
biquad_lowpass_init(&sep->bpf_ac_high, 5.0f, 0.707f, sample_rate);
sep->dc_value = 0.0f;
sep->ac_value = 0.0f;
sep->ac_min = 0.0f;
sep->ac_max = 0.0f;
sep->ac_amplitude = 0.0f;
}
// 处理单个样本
void dc_ac_separator_process(DC_AC_Separator_t* sep, float ppg_sample) {
// 提取DC成分
sep->dc_value = biquad_process(&sep->lpf_dc, ppg_sample);
// 提取AC成分
float ac_temp = biquad_process(&sep->bpf_ac_low, ppg_sample);
sep->ac_value = biquad_process(&sep->bpf_ac_high, ac_temp);
// 更新AC幅度统计
if (sep->ac_value < sep->ac_min) {
sep->ac_min = sep->ac_value;
}
if (sep->ac_value > sep->ac_max) {
sep->ac_max = sep->ac_value;
}
// 计算峰峰值幅度
sep->ac_amplitude = sep->ac_max - sep->ac_min;
}
// 获取AC/DC比值
float dc_ac_get_ratio(DC_AC_Separator_t* sep) {
if (sep->dc_value > 0.0f) {
return sep->ac_amplitude / sep->dc_value;
}
return 0.0f;
}
脉搏检测¶
峰值检测算法¶
// 脉搏峰值检测器
typedef struct {
// 阈值参数
float threshold;
float threshold_ratio; // 阈值比例（相对于信号幅度）
// 峰值检测状态
float last_peak_value;
uint32_t last_peak_time;
float current_max;
uint32_t current_max_time;
// 不应期（防止重复检测）
uint16_t refractory_samples;
uint32_t samples_since_peak;
// 脉率计算
float* pulse_intervals; // 脉搏间期缓冲区（ms）
uint8_t interval_count;
uint8_t interval_index;
float pulse_rate; // 当前脉率（bpm）
float sample_rate;
} Pulse_Detector_t;
// 初始化脉搏检测器
void pulse_detector_init(Pulse_Detector_t* det, float sample_rate) {
det->sample_rate = sample_rate;
det->threshold = 0.0f;
det->threshold_ratio = 0.5f; // 50%的信号幅度
det->last_peak_value = 0.0f;
det->last_peak_time = 0;
det->current_max = 0.0f;
det->current_max_time = 0;
// 不应期：300ms（防止检测到重搏波）
det->refractory_samples = (uint16_t)(0.3f * sample_rate);
det->samples_since_peak = det->refractory_samples;
// 脉搏间期缓冲区（保存最近8个）
det->pulse_intervals = (float*)calloc(8, sizeof(float));
det->interval_count = 0;
det->interval_index = 0;
det->pulse_rate = 0.0f;
}
// 检测脉搏峰值
bool pulse_detector_process(Pulse_Detector_t* det, float ppg_ac,
uint32_t sample_time) {
det->samples_since_peak++;
// 更新当前最大值
if (ppg_ac > det->current_max) {
det->current_max = ppg_ac;
det->current_max_time = sample_time;
}
// 在不应期内不检测
if (det->samples_since_peak < det->refractory_samples) {
return false;
}
// 自适应阈值（基于最近的峰值）
det->threshold = det->last_peak_value * det->threshold_ratio;
// 检测峰值：信号开始下降且超过阈值
if (det->current_max > det->threshold && ppg_ac < det->current_max * 0.95f) {
// 找到峰值
det->last_peak_value = det->current_max;
det->last_peak_time = det->current_max_time;
// 计算脉搏间期
if (det->interval_count > 0) {
uint32_t interval_samples = sample_time - det->last_peak_time;
float interval_ms = (interval_samples * 1000.0f) / det->sample_rate;
// 验证间期合理性（300-2000ms，对应30-200 bpm）
if (interval_ms >= 300.0f && interval_ms <= 2000.0f) {
// 添加到缓冲区
det->pulse_intervals[det->interval_index] = interval_ms;
det->interval_index = (det->interval_index + 1) % 8;
if (det->interval_count < 8) {
det->interval_count++;
}
// 计算平均脉率
float sum = 0.0f;
for (uint8_t i = 0; i < det->interval_count; i++) {
sum += det->pulse_intervals[i];
}
float avg_interval = sum / det->interval_count;
det->pulse_rate = 60000.0f / avg_interval; // bpm
}
} else {
det->interval_count = 1;
}
// 重置状态
det->samples_since_peak = 0;
det->current_max = 0.0f;
return true; // 检测到脉搏
}
return false;
}
基于FFT的脉率检测¶
对于运动干扰严重的情况，可以使用FFT方法：
// 基于FFT的脉率检测
float pulse_rate_fft(float* ppg_data, uint16_t size, float sample_rate) {
// 1. 初始化FFT
FFT_Config_t* fft_config = fft_init(size, sample_rate);
// 2. 应用汉宁窗
float* windowed_data = (float*)malloc(size * sizeof(float));
memcpy(windowed_data, ppg_data, size * sizeof(float));
apply_hanning_window(windowed_data, size);
// 3. 执行FFT
Complex_t* fft_output = (Complex_t*)malloc(size * sizeof(Complex_t));
fft_execute(windowed_data, fft_output, fft_config);
// 4. 计算功率谱
float* power_spectrum = (float*)malloc(size * sizeof(float));
fft_power_spectrum(fft_output, power_spectrum, size);
// 5. 在脉率范围内查找峰值（30-200 bpm = 0.5-3.33 Hz）
float freq_resolution = sample_rate / size;
uint16_t start_idx = (uint16_t)(0.5f / freq_resolution);
uint16_t end_idx = (uint16_t)(3.33f / freq_resolution);
uint16_t max_idx = start_idx;
float max_power = power_spectrum[start_idx];
for (uint16_t i = start_idx + 1; i < end_idx; i++) {
if (power_spectrum[i] > max_power) {
max_power = power_spectrum[i];
max_idx = i;
}
}
// 6. 计算脉率
float pulse_freq = max_idx * freq_resolution;
float pulse_rate = pulse_freq * 60.0f; // 转换为bpm
// 清理
free(windowed_data);
free(fft_output);
free(power_spectrum);
fft_free(fft_config);
return pulse_rate;
}
SpO2计算¶
比值法（R值计算）¶
// SpO2计算器
typedef struct {
// DC/AC分离器
DC_AC_Separator_t red_separator;
DC_AC_Separator_t ir_separator;
// R值计算
float r_value;
float* r_buffer; // R值缓冲区（平滑）
uint8_t r_buffer_size;
uint8_t r_buffer_index;
// SpO2结果
float spo2_value;
float spo2_smoothed;
// 校准曲线系数
float calib_a0;
float calib_a1;
float calib_a2;
float calib_a3;
// 质量指标
float perfusion_index; // 灌注指数
float signal_quality; // 信号质量
} SpO2_Calculator_t;
// 初始化SpO2计算器
void spo2_calculator_init(SpO2_Calculator_t* calc, float sample_rate) {
// 初始化DC/AC分离器
dc_ac_separator_init(&calc->red_separator, sample_rate);
dc_ac_separator_init(&calc->ir_separator, sample_rate);
// R值缓冲区（平滑，保存最近16个）
calc->r_buffer_size = 16;
calc->r_buffer = (float*)calloc(calc->r_buffer_size, sizeof(float));
calc->r_buffer_index = 0;
calc->r_value = 0.0f;
calc->spo2_value = 0.0f;
calc->spo2_smoothed = 0.0f;
// 默认校准曲线（线性近似）
calc->calib_a0 = 110.0f;
calc->calib_a1 = -25.0f;
calc->calib_a2 = 0.0f;
calc->calib_a3 = 0.0f;
calc->perfusion_index = 0.0f;
calc->signal_quality = 0.0f;
}
// 处理红光和红外光样本
void spo2_calculator_process(SpO2_Calculator_t* calc,
float red_sample, float ir_sample) {
// 1. 提取DC和AC成分
dc_ac_separator_process(&calc->red_separator, red_sample);
dc_ac_separator_process(&calc->ir_separator, ir_sample);
// 2. 计算AC/DC比值
float red_ratio = dc_ac_get_ratio(&calc->red_separator);
float ir_ratio = dc_ac_get_ratio(&calc->ir_separator);
// 3. 计算R值
if (ir_ratio > 0.0f) {
calc->r_value = red_ratio / ir_ratio;
// 添加到缓冲区进行平滑
calc->r_buffer[calc->r_buffer_index] = calc->r_value;
calc->r_buffer_index = (calc->r_buffer_index + 1) % calc->r_buffer_size;
// 计算平滑的R值（中值滤波 + 平均）
float r_smoothed = median_filter(calc->r_buffer, calc->r_buffer_size);
// 4. 使用校准曲线计算SpO2
calc->spo2_value = spo2_from_r_value(calc, r_smoothed);
// 5. 平滑SpO2值（指数移动平均）
float alpha = 0.2f; // 平滑系数
calc->spo2_smoothed = alpha * calc->spo2_value +
(1.0f - alpha) * calc->spo2_smoothed;
// 6. 计算灌注指数（PI）
// PI = (AC / DC) × 100%，通常使用红外光
calc->perfusion_index = ir_ratio * 100.0f;
}
}
// 从R值计算SpO2（使用校准曲线）
float spo2_from_r_value(SpO2_Calculator_t* calc, float r) {
// 多项式校准曲线
float spo2 = calc->calib_a0 +
calc->calib_a1 * r +
calc->calib_a2 * r * r +
calc->calib_a3 * r * r * r;
// 限制范围（0-100%）
if (spo2 > 100.0f) spo2 = 100.0f;
if (spo2 < 0.0f) spo2 = 0.0f;
return spo2;
}
// 中值滤波器（用于R值平滑）
float median_filter(float* data, uint8_t size) {
// 复制数据
float* temp = (float*)malloc(size * sizeof(float));
memcpy(temp, data, size * sizeof(float));
// 冒泡排序
for (uint8_t i = 0; i < size - 1; i++) {
for (uint8_t j = 0; j < size - i - 1; j++) {
if (temp[j] > temp[j + 1]) {
float swap = temp[j];
temp[j] = temp[j + 1];
temp[j + 1] = swap;
}
}
}
// 取中值
float median = temp[size / 2];
free(temp);
return median;
}
校准曲线¶
校准曲线是将R值转换为SpO2的关键。通常通过临床试验获得：
// 校准曲线类型
typedef enum {
CALIB_LINEAR, // 线性：SpO2 = a0 + a1*R
CALIB_QUADRATIC, // 二次：SpO2 = a0 + a1*R + a2*R²
CALIB_CUBIC, // 三次：SpO2 = a0 + a1*R + a2*R² + a3*R³
CALIB_LOOKUP_TABLE // 查找表
} Calibration_Type_t;
// 校准数据点（来自临床试验）
typedef struct {
float r_value;
float spo2_reference; // 参考血氧值（动脉血气分析）
} Calibration_Point_t;
// 典型校准数据（示例）
static const Calibration_Point_t calibration_data[] = {
{0.4f, 100.0f}, // R=0.4 → SpO2=100%
{0.5f, 99.0f},
{0.6f, 97.0f},
{0.7f, 95.0f},
{0.8f, 93.0f},
{0.9f, 90.0f},
{1.0f, 87.0f},
{1.1f, 85.0f},
{1.2f, 82.0f},
{1.3f, 80.0f},
{1.5f, 75.0f},
{1.7f, 70.0f},
{2.0f, 65.0f} // R=2.0 → SpO2=65%
};
// 多项式拟合（最小二乘法）
void calibration_polynomial_fit(Calibration_Point_t* points, uint8_t count,
float* coeffs, uint8_t order) {
// 构建矩阵方程：A*x = b
// 其中 A 是范德蒙矩阵，x 是系数向量，b 是SpO2值
uint8_t n = order + 1;
float** A = (float**)malloc(count * sizeof(float*));
float* b = (float*)malloc(count * sizeof(float));
for (uint8_t i = 0; i < count; i++) {
A[i] = (float*)malloc(n * sizeof(float));
// 填充范德蒙矩阵行
float r = points[i].r_value;
for (uint8_t j = 0; j < n; j++) {
A[i][j] = powf(r, j);
}
b[i] = points[i].spo2_reference;
}
// 求解最小二乘问题（使用正规方程）
// A^T * A * x = A^T * b
least_squares_solve(A, b, coeffs, count, n);
// 清理
for (uint8_t i = 0; i < count; i++) {
free(A[i]);
}
free(A);
free(b);
}
// 查找表方法（线性插值）
float calibration_lookup_table(float r_value,
Calibration_Point_t* table, uint8_t size) {
// 边界检查
if (r_value <= table[0].r_value) {
return table[0].spo2_reference;
}
if (r_value >= table[size - 1].r_value) {
return table[size - 1].spo2_reference;
}
// 查找插值区间
for (uint8_t i = 0; i < size - 1; i++) {
if (r_value >= table[i].r_value && r_value <= table[i + 1].r_value) {
// 线性插值
float r0 = table[i].r_value;
float r1 = table[i + 1].r_value;
float spo2_0 = table[i].spo2_reference;
float spo2_1 = table[i + 1].spo2_reference;
float t = (r_value - r0) / (r1 - r0);
return spo2_0 + t * (spo2_1 - spo2_0);
}
}
return 0.0f; // 不应该到达这里
}
// 设置校准曲线
void spo2_set_calibration(SpO2_Calculator_t* calc,
Calibration_Type_t type,
float* coeffs) {
switch (type) {
case CALIB_LINEAR:
calc->calib_a0 = coeffs[0];
calc->calib_a1 = coeffs[1];
calc->calib_a2 = 0.0f;
calc->calib_a3 = 0.0f;
break;
case CALIB_QUADRATIC:
calc->calib_a0 = coeffs[0];
calc->calib_a1 = coeffs[1];
calc->calib_a2 = coeffs[2];
calc->calib_a3 = 0.0f;
break;
case CALIB_CUBIC:
calc->calib_a0 = coeffs[0];
calc->calib_a1 = coeffs[1];
calc->calib_a2 = coeffs[2];
calc->calib_a3 = coeffs[3];
break;
default:
break;
}
}
运动伪影抑制¶
运动伪影是SpO2测量中最大的挑战之一。
自适应滤波器¶
// 自适应滤波器（LMS算法）
typedef struct {
float* weights; // 滤波器权重
uint16_t filter_length; // 滤波器长度
float* input_buffer; // 输入缓冲区
uint16_t buffer_index;
float mu; // 步长参数
float error; // 误差信号
} Adaptive_LMS_Filter_t;
// 初始化自适应滤波器
void adaptive_lms_init(Adaptive_LMS_Filter_t* filter,
uint16_t length, float mu) {
filter->filter_length = length;
filter->mu = mu;
filter->buffer_index = 0;
filter->error = 0.0f;
filter->weights = (float*)calloc(length, sizeof(float));
filter->input_buffer = (float*)calloc(length, sizeof(float));
}
// LMS自适应滤波处理
float adaptive_lms_process(Adaptive_LMS_Filter_t* filter,
float input, float reference) {
// 1. 更新输入缓冲区
filter->input_buffer[filter->buffer_index] = input;
filter->buffer_index = (filter->buffer_index + 1) % filter->filter_length;
// 2. 计算滤波器输出（卷积）
float output = 0.0f;
for (uint16_t i = 0; i < filter->filter_length; i++) {
uint16_t idx = (filter->buffer_index + i) % filter->filter_length;
output += filter->weights[i] * filter->input_buffer[idx];
}
// 3. 计算误差
filter->error = reference - output;
// 4. 更新权重（LMS算法）
for (uint16_t i = 0; i < filter->filter_length; i++) {
uint16_t idx = (filter->buffer_index + i) % filter->filter_length;
filter->weights[i] += 2.0f * filter->mu * filter->error *
filter->input_buffer[idx];
}
return output;
}
// 运动伪影检测
typedef struct {
float threshold; // 运动检测阈值
float* accel_buffer; // 加速度计缓冲区
uint16_t buffer_size;
float motion_level; // 运动强度
bool motion_detected; // 运动检测标志
} Motion_Detector_t;
// 初始化运动检测器
void motion_detector_init(Motion_Detector_t* det, uint16_t buffer_size) {
det->buffer_size = buffer_size;
det->accel_buffer = (float*)calloc(buffer_size, sizeof(float));
det->threshold = 0.5f; // 0.5g阈值
det->motion_level = 0.0f;
det->motion_detected = false;
}
// 处理加速度计数据
void motion_detector_process(Motion_Detector_t* det,
float accel_x, float accel_y, float accel_z) {
// 计算加速度幅值
float accel_magnitude = sqrtf(accel_x * accel_x +
accel_y * accel_y +
accel_z * accel_z);
// 减去重力（1g）
accel_magnitude = fabsf(accel_magnitude - 1.0f);
// 更新缓冲区
static uint16_t index = 0;
det->accel_buffer[index] = accel_magnitude;
index = (index + 1) % det->buffer_size;
// 计算运动强度（RMS）
float sum_squares = 0.0f;
for (uint16_t i = 0; i < det->buffer_size; i++) {
sum_squares += det->accel_buffer[i] * det->accel_buffer[i];
}
det->motion_level = sqrtf(sum_squares / det->buffer_size);
// 检测运动
det->motion_detected = (det->motion_level > det->threshold);
}
加速度计辅助的运动补偿¶
// 运动补偿系统
typedef struct {
Motion_Detector_t motion_detector;
Adaptive_LMS_Filter_t adaptive_filter;
// 信号质量评估
float signal_quality;
bool valid_measurement;
} Motion_Compensation_t;
// 初始化运动补偿
void motion_compensation_init(Motion_Compensation_t* mc) {
motion_detector_init(&mc->motion_detector, 32);
adaptive_lms_init(&mc->adaptive_filter, 32, 0.01f);
mc->signal_quality = 1.0f;
mc->valid_measurement = true;
}
// 运动补偿处理
float motion_compensation_process(Motion_Compensation_t* mc,
float ppg_signal,
float accel_x, float accel_y, float accel_z) {
// 1. 检测运动
motion_detector_process(&mc->motion_detector, accel_x, accel_y, accel_z);
// 2. 如果检测到运动，使用自适应滤波
if (mc->motion_detector.motion_detected) {
// 使用加速度计信号作为参考
float accel_ref = sqrtf(accel_x * accel_x +
accel_y * accel_y +
accel_z * accel_z) - 1.0f;
// 自适应滤波去除运动伪影
float filtered = adaptive_lms_process(&mc->adaptive_filter,
ppg_signal, accel_ref);
// 降低信号质量指标
mc->signal_quality = 0.5f;
mc->valid_measurement = (mc->motion_detector.motion_level < 1.0f);
return filtered;
} else {
// 无运动，直接返回原始信号
mc->signal_quality = 1.0f;
mc->valid_measurement = true;
return ppg_signal;
}
}
环境光补偿¶
环境光会影响光电检测器的读数，必须进行补偿。
// 环境光补偿
typedef struct {
float ambient_red; // 红光环境光
float ambient_ir; // 红外环境光
float dark_current; // 暗电流
// 自动增益控制
float target_signal_level; // 目标信号电平
float current_gain; // 当前增益
float led_current_red; // 红光LED电流
float led_current_ir; // 红外LED电流
} Ambient_Compensation_t;
// 初始化环境光补偿
void ambient_compensation_init(Ambient_Compensation_t* comp) {
comp->ambient_red = 0.0f;
comp->ambient_ir = 0.0f;
comp->dark_current = 0.0f;
comp->target_signal_level = 32768.0f; // 16位ADC的50%
comp->current_gain = 1.0f;
comp->led_current_red = 10.0f; // 初始10mA
comp->led_current_ir = 10.0f;
}
// 测量环境光（所有LED关闭）
void ambient_compensation_measure(Ambient_Compensation_t* comp,
uint16_t red_adc, uint16_t ir_adc) {
comp->ambient_red = (float)red_adc;
comp->ambient_ir = (float)ir_adc;
}
// 补偿信号
void ambient_compensation_correct(Ambient_Compensation_t* comp,
float* red_signal, float* ir_signal) {
// 减去环境光和暗电流
*red_signal -= (comp->ambient_red + comp->dark_current);
*ir_signal -= (comp->ambient_ir + comp->dark_current);
// 确保非负
if (*red_signal < 0.0f) *red_signal = 0.0f;
if (*ir_signal < 0.0f) *ir_signal = 0.0f;
}
// 自动增益控制（AGC）
void ambient_compensation_agc(Ambient_Compensation_t* comp,
float red_dc, float ir_dc) {
// 计算当前信号电平
float current_level = (red_dc + ir_dc) / 2.0f;
// 计算增益调整
float gain_adjust = comp->target_signal_level / current_level;
// 限制增益调整速率（避免振荡）
if (gain_adjust > 1.1f) gain_adjust = 1.1f;
if (gain_adjust < 0.9f) gain_adjust = 0.9f;
// 更新LED电流
comp->led_current_red *= gain_adjust;
comp->led_current_ir *= gain_adjust;
// 限制LED电流范围
if (comp->led_current_red > 50.0f) comp->led_current_red = 50.0f;
if (comp->led_current_red < 5.0f) comp->led_current_red = 5.0f;
if (comp->led_current_ir > 50.0f) comp->led_current_ir = 50.0f;
if (comp->led_current_ir < 5.0f) comp->led_current_ir = 5.0f;
// 应用新的LED电流
led_set_current_red(comp->led_current_red);
led_set_current_ir(comp->led_current_ir);
}
肤色补偿¶
不同肤色对光的吸收和散射特性不同，需要进行补偿。
// 肤色类型
typedef enum {
SKIN_TONE_VERY_LIGHT = 0, // 非常浅（I型）
SKIN_TONE_LIGHT, // 浅色（II型）
SKIN_TONE_MEDIUM, // 中等（III-IV型）
SKIN_TONE_DARK, // 深色（V型）
SKIN_TONE_VERY_DARK, // 非常深（VI型）
SKIN_TONE_UNKNOWN
} Skin_Tone_t;
// 肤色补偿参数
typedef struct {
Skin_Tone_t skin_tone;
float melanin_correction; // 黑色素校正系数
float calib_offset; // 校准偏移
float calib_scale; // 校准缩放
} Skin_Compensation_t;
// 肤色补偿表
static const struct {
Skin_Tone_t tone;
float melanin_correction;
float calib_offset;
float calib_scale;
} skin_compensation_table[] = {
{SKIN_TONE_VERY_LIGHT, 1.00f, 0.0f, 1.00f},
{SKIN_TONE_LIGHT, 1.05f, 0.5f, 1.02f},
{SKIN_TONE_MEDIUM, 1.10f, 1.0f, 1.05f},
{SKIN_TONE_DARK, 1.20f, 1.5f, 1.10f},
{SKIN_TONE_VERY_DARK, 1.35f, 2.0f, 1.15f},
};
// 初始化肤色补偿
void skin_compensation_init(Skin_Compensation_t* comp, Skin_Tone_t tone) {
comp->skin_tone = tone;
// 查找补偿参数
for (uint8_t i = 0; i < 5; i++) {
if (skin_compensation_table[i].tone == tone) {
comp->melanin_correction = skin_compensation_table[i].melanin_correction;
comp->calib_offset = skin_compensation_table[i].calib_offset;
comp->calib_scale = skin_compensation_table[i].calib_scale;
return;
}
}
// 默认值（中等肤色）
comp->melanin_correction = 1.10f;
comp->calib_offset = 1.0f;
comp->calib_scale = 1.05f;
}
// 应用肤色补偿
float skin_compensation_apply(Skin_Compensation_t* comp, float spo2_raw) {
// 应用校准偏移和缩放
float spo2_compensated = (spo2_raw + comp->calib_offset) * comp->calib_scale;
// 限制范围
if (spo2_compensated > 100.0f) spo2_compensated = 100.0f;
if (spo2_compensated < 0.0f) spo2_compensated = 0.0f;
return spo2_compensated;
}
// 自动肤色检测（基于灌注指数和信号特征）
Skin_Tone_t skin_tone_auto_detect(float perfusion_index,
float red_dc, float ir_dc) {
// 计算红外/红光DC比值
float dc_ratio = ir_dc / red_dc;
// 基于经验规则分类
if (perfusion_index > 5.0f && dc_ratio > 1.5f) {
return SKIN_TONE_VERY_LIGHT;
} else if (perfusion_index > 3.0f && dc_ratio > 1.3f) {
return SKIN_TONE_LIGHT;
} else if (perfusion_index > 1.5f && dc_ratio > 1.1f) {
return SKIN_TONE_MEDIUM;
} else if (perfusion_index > 0.8f && dc_ratio > 0.9f) {
return SKIN_TONE_DARK;
} else {
return SKIN_TONE_VERY_DARK;
}
}
信号质量评估¶
// 信号质量指标
typedef struct {
float perfusion_index; // 灌注指数（%）
float snr; // 信噪比（dB）
float pulse_strength; // 脉搏强度
float motion_level; // 运动水平
float overall_quality; // 总体质量（0-1）
bool measurement_valid; // 测量有效性
} Signal_Quality_t;
// 计算信噪比
float calculate_snr(float* signal, uint16_t size) {
// 1. 计算信号功率（AC成分）
float mean = 0.0f;
for (uint16_t i = 0; i < size; i++) {
mean += signal[i];
}
mean /= size;
float signal_power = 0.0f;
for (uint16_t i = 0; i < size; i++) {
float diff = signal[i] - mean;
signal_power += diff * diff;
}
signal_power /= size;
// 2. 估计噪声功率（高频成分）
float noise_power = 0.0f;
for (uint16_t i = 1; i < size; i++) {
float diff = signal[i] - signal[i - 1];
noise_power += diff * diff;
}
noise_power /= (size - 1);
// 3. 计算SNR（dB）
if (noise_power > 0.0f) {
return 10.0f * log10f(signal_power / noise_power);
}
return 0.0f;
}
// 评估信号质量
void signal_quality_assess(Signal_Quality_t* quality,
float perfusion_index,
float* ppg_signal, uint16_t size,
float motion_level) {
quality->perfusion_index = perfusion_index;
quality->motion_level = motion_level;
// 计算SNR
quality->snr = calculate_snr(ppg_signal, size);
// 计算脉搏强度（峰峰值）
float min_val = ppg_signal[0];
float max_val = ppg_signal[0];
for (uint16_t i = 1; i < size; i++) {
if (ppg_signal[i] < min_val) min_val = ppg_signal[i];
if (ppg_signal[i] > max_val) max_val = ppg_signal[i];
}
quality->pulse_strength = max_val - min_val;
// 综合评估质量（0-1）
float quality_score = 0.0f;
// 1. 灌注指数贡献（权重0.3）
if (perfusion_index > 1.0f) {
quality_score += 0.3f;
} else if (perfusion_index > 0.5f) {
quality_score += 0.15f;
}
// 2. SNR贡献（权重0.3）
if (quality->snr > 20.0f) {
quality_score += 0.3f;
} else if (quality->snr > 10.0f) {
quality_score += 0.15f;
}
// 3. 脉搏强度贡献（权重0.2）
if (quality->pulse_strength > 100.0f) {
quality_score += 0.2f;
} else if (quality->pulse_strength > 50.0f) {
quality_score += 0.1f;
}
// 4. 运动水平贡献（权重0.2，运动越小越好）
if (motion_level < 0.2f) {
quality_score += 0.2f;
} else if (motion_level < 0.5f) {
quality_score += 0.1f;
}
quality->overall_quality = quality_score;
// 判断测量有效性
quality->measurement_valid = (quality_score > 0.6f) &&
(perfusion_index > 0.3f) &&
(quality->snr > 5.0f);
}
完整的SpO2系统集成¶
// 完整的SpO2测量系统
typedef struct {
// 硬件配置
SpO2_Sensor_Config_t sensor_config;
SpO2_Sampling_t sampling;
// 信号处理
PPG_Filter_Bank_t red_filter;
PPG_Filter_Bank_t ir_filter;
// SpO2计算
SpO2_Calculator_t calculator;
// 脉搏检测
Pulse_Detector_t pulse_detector;
// 补偿和校正
Motion_Compensation_t motion_comp;
Ambient_Compensation_t ambient_comp;
Skin_Compensation_t skin_comp;
// 信号质量
Signal_Quality_t signal_quality;
// 测量结果
float spo2_value;
float pulse_rate;
float perfusion_index;
bool valid_measurement;
// 状态
uint32_t sample_count;
bool initialized;
} SpO2_System_t;
// 初始化SpO2系统
void spo2_system_init(SpO2_System_t* sys, float sample_rate) {
// 1. 配置传感器
sys->sensor_config.red_led_wavelength = SPO2_RED_WAVELENGTH;
sys->sensor_config.ir_led_wavelength = SPO2_IR_WAVELENGTH;
sys->sensor_config.red_led_current = 10.0f;
sys->sensor_config.ir_led_current = 10.0f;
sys->sensor_config.sample_rate = sample_rate;
// 2. 初始化采样
sys->sampling.current_state = SAMPLE_RED;
sys->sampling.state_counter = 0;
// 3. 初始化滤波器
ppg_filter_bank_init(&sys->red_filter, sample_rate);
ppg_filter_bank_init(&sys->ir_filter, sample_rate);
// 4. 初始化SpO2计算器
spo2_calculator_init(&sys->calculator, sample_rate);
// 5. 初始化脉搏检测器
pulse_detector_init(&sys->pulse_detector, sample_rate);
// 6. 初始化补偿模块
motion_compensation_init(&sys->motion_comp);
ambient_compensation_init(&sys->ambient_comp);
skin_compensation_init(&sys->skin_comp, SKIN_TONE_MEDIUM);
// 7. 初始化状态
sys->sample_count = 0;
sys->initialized = true;
sys->valid_measurement = false;
}
// SpO2系统主处理函数
void spo2_system_process(SpO2_System_t* sys,
uint16_t red_adc, uint16_t ir_adc,
float accel_x, float accel_y, float accel_z) {
// 1. 采样状态机
spo2_sampling_state_machine(&sys->sampling, &sys->sensor_config);
// 2. 环境光补偿
float red_corrected = sys->sampling.red_corrected;
float ir_corrected = sys->sampling.ir_corrected;
ambient_compensation_correct(&sys->ambient_comp, &red_corrected, &ir_corrected);
// 3. 运动补偿
red_corrected = motion_compensation_process(&sys->motion_comp,
red_corrected,
accel_x, accel_y, accel_z);
ir_corrected = motion_compensation_process(&sys->motion_comp,
ir_corrected,
accel_x, accel_y, accel_z);
// 4. PPG滤波
float red_filtered = ppg_filter_process(&sys->red_filter, red_corrected);
float ir_filtered = ppg_filter_process(&sys->ir_filter, ir_corrected);
// 5. SpO2计算
spo2_calculator_process(&sys->calculator, red_filtered, ir_filtered);
// 6. 脉搏检测
bool pulse_detected = pulse_detector_process(&sys->pulse_detector,
sys->calculator.red_separator.ac_value,
sys->sample_count);
// 7. 肤色补偿
float spo2_raw = sys->calculator.spo2_smoothed;
sys->spo2_value = skin_compensation_apply(&sys->skin_comp, spo2_raw);
// 8. 更新测量结果
sys->pulse_rate = sys->pulse_detector.pulse_rate;
sys->perfusion_index = sys->calculator.perfusion_index;
// 9. 信号质量评估
float ppg_buffer[100]; // 最近100个样本
// ... 填充缓冲区 ...
signal_quality_assess(&sys->signal_quality,
sys->perfusion_index,
ppg_buffer, 100,
sys->motion_comp.motion_detector.motion_level);
sys->valid_measurement = sys->signal_quality.measurement_valid;
// 10. 自动增益控制（每秒更新一次）
if (sys->sample_count % (uint32_t)sys->sensor_config.sample_rate == 0) {
ambient_compensation_agc(&sys->ambient_comp,
sys->calculator.red_separator.dc_value,
sys->calculator.ir_separator.dc_value);
}
sys->sample_count++;
}
// 获取SpO2测量结果
void spo2_system_get_results(SpO2_System_t* sys,
float* spo2, float* pulse_rate,
float* perfusion_index, bool* valid) {
*spo2 = sys->spo2_value;
*pulse_rate = sys->pulse_rate;
*perfusion_index = sys->perfusion_index;
*valid = sys->valid_measurement;
}
// RTOS任务示例
void spo2_measurement_task(void* params) {
SpO2_System_t* sys = (SpO2_System_t*)params;
// 初始化系统
spo2_system_init(sys, 100.0f); // 100Hz采样率
while (1) {
// 1. 读取ADC数据
uint16_t red_adc = adc_read_channel(ADC_CHANNEL_RED);
uint16_t ir_adc = adc_read_channel(ADC_CHANNEL_IR);
// 2. 读取加速度计数据
float accel_x, accel_y, accel_z;
accelerometer_read(&accel_x, &accel_y, &accel_z);
// 3. 处理数据
spo2_system_process(sys, red_adc, ir_adc, accel_x, accel_y, accel_z);
// 4. 获取结果
float spo2, pulse_rate, perfusion_index;
bool valid;
spo2_system_get_results(sys, &spo2, &pulse_rate, &perfusion_index, &valid);
// 5. 更新显示或发送数据
if (valid) {
display_update(spo2, pulse_rate, perfusion_index);
// 检查报警条件
if (spo2 < 90.0f) {
trigger_low_spo2_alarm();
}
} else {
display_show_error("信号质量差");
}
// 6. 等待下一个采样周期（10ms @ 100Hz）
vTaskDelay(pdMS_TO_TICKS(10));
}
}
最佳实践¶
1. 传感器放置¶
- 手指夹式：最常用，放置在食指或中指
- 耳夹式：适用于手指不可用的情况
- 前额式：适用于低灌注状态
- 避免压迫：不要过紧，影响血液循环
- 保持温暖：寒冷会降低灌注指数
2. 信号质量优化¶
- 采样率选择：100-200Hz足够，过高浪费资源
- 滤波器设计：带通0.5-5Hz，保留脉搏频率成分
- 自适应阈值：根据信号幅度动态调整检测阈值
- 多通道平均：使用多个LED/检测器对提高可靠性
3. 运动伪影处理¶
- 加速度计融合：使用3轴加速度计检测和补偿运动
- 自适应滤波：LMS或RLS算法实时去除运动伪影
- 信号质量指标：实时评估，低质量时暂停测量
- 多模态融合：结合ECG、PPG、加速度计多种信号
4. 校准和验证¶
- 临床校准：使用动脉血气分析作为金标准
- 多肤色测试：覆盖不同肤色人群（I-VI型）
- 低灌注测试：测试低血压、休克等极端情况
- 运动测试：步行、跑步等运动状态下的准确性
- 定期校准：每6-12个月重新校准
5. 功耗优化¶
- 动态LED电流：根据信号强度自动调整
- 间歇测量：非关键应用可以间歇采样
- 低功耗模式：待机时关闭LED和ADC
- DMA传输：减少CPU参与，降低功耗
6. 符合医疗标准¶
- ISO 80601-2-61：脉搏血氧仪特定要求
- IEC 60601-1：医疗电气设备通用安全要求
- FDA 510(k)：美国市场准入要求
- CE认证：欧洲市场准入要求
- 准确性要求：SpO2 70-100%范围内，Arms ≤ 3%
7. 报警管理¶
- 低SpO2报警：<90%触发，可配置阈值
- 脉率异常：<40 bpm或>120 bpm
- 信号丢失：探头脱落或信号质量差
- 报警延迟：避免瞬时干扰引起误报
- 报警优先级：根据临床严重性分级
常见陷阱¶
1. 忽略环境光干扰¶
问题：强光（如手术灯、阳光）会导致读数不准确。
解决方案： - 实现环境光采样和补偿 - 使用遮光罩或不透明探头 - 时分复用采样，减去环境光成分
2. 运动伪影未处理¶
问题：手指移动导致SpO2值剧烈波动。
解决方案： - 集成加速度计进行运动检测 - 使用自适应滤波器去除运动伪影 - 运动期间暂停测量或降低更新率
3. 校准曲线不准确¶
问题：使用通用校准曲线，不同人群误差大。
解决方案： - 进行临床试验获取准确校准数据 - 针对不同肤色建立补偿模型 - 定期验证和更新校准曲线
4. 低灌注状态测量失败¶
问题：低血压、休克、寒冷时无法测量。
解决方案： - 增加LED电流提高信号强度 - 使用前额或耳垂等灌注更好的部位 - 实现自动增益控制（AGC） - 加温探头改善局部血液循环
5. 信号质量评估不足¶
问题：输出低质量的测量结果，误导临床决策。
解决方案： - 实现多维度信号质量评估 - 计算灌注指数、SNR、脉搏强度 - 低质量时不显示结果或显示警告 - 记录信号质量指标用于事后分析
6. 采样率不当¶
问题：采样率过低导致混叠，过高浪费资源。
解决方案： - 脉搏频率0.5-5Hz，采样率至少20Hz（奈奎斯特） - 推荐100-200Hz，留有余量 - 实现抗混叠低通滤波器 - 根据应用场景选择合适采样率
7. 电磁干扰（EMI）¶
问题：电源噪声、射频干扰影响测量。
解决方案： - 良好的PCB布局和接地设计 - 使用屏蔽电缆和滤波电容 - 数字和模拟电路分离 - 实现50/60Hz陷波滤波器
实践练习¶
练习1：实现基本的SpO2计算器¶
编写一个简单的SpO2计算器，输入红光和红外光的AC/DC值，输出SpO2值。
要求： - 实现R值计算 - 使用线性校准曲线 - 处理边界情况
练习2：设计PPG滤波器链¶
设计一个完整的PPG信号处理链，包括： - 高通滤波器（去DC） - 低通滤波器（去高频噪声） - 移动平均平滑
要求： - 使用二阶Biquad滤波器 - 截止频率：高通0.5Hz，低通5Hz - 测试频率响应
练习3：实现脉搏检测算法¶
实现一个峰值检测算法，从PPG信号中检测脉搏。
要求： - 自适应阈值 - 不应期防止重复检测 - 计算脉率（bpm）
练习4：运动伪影模拟和补偿¶
生成带有运动伪影的PPG信号，实现补偿算法。
要求： - 模拟正弦运动伪影 - 实现LMS自适应滤波器 - 比较补偿前后的信号质量
自测问题¶
问题1：朗伯-比尔定律的应用¶
问题：为什么SpO2测量需要使用两个不同波长的光？如果只使用一个波长（如660nm红光），能否准确测量血氧饱和度？请解释原因。
点击查看答案
**答案**： 不能只使用一个波长准确测量SpO2，原因如下： 1. **单波长的局限性**： - 在660nm红光下，氧合血红蛋白（HbO₂）和还原血红蛋白（Hb）都会吸收光，但吸收率不同 - 单一波长无法区分吸光度变化是由于血红蛋白浓度变化还是氧合状态变化 - 组织厚度、静脉血、皮肤色素等因素都会影响吸光度 2. **双波长的优势**： - 红光（660nm）：Hb吸收 > HbO₂吸收（吸收系数比约5.4:1） - 红外光（940nm）：HbO₂吸收 > Hb吸收（吸收系数比约2.2:1） - 通过计算两个波长的AC/DC比值的比值（R值），可以消除组织厚度、静脉血等共同因素的影响 - R值与SpO2有单调关系，可以通过校准曲线准确计算 3. **数学原理**： **说明**: R值是SpO2计算的关键参数，表示红光和红外光的调制比的比率。这个比值与血氧饱和度有特定的对应关系，通过经验公式或查找表可以得到SpO2值。 **说明**: 这是R值的计算公式。AC_red和AC_ir是红光和红外光的交流分量(脉动部分)，DC_red和DC_ir是直流分量(非脉动部分)。R值反映了血液中含氧血红蛋白和脱氧血红蛋白的比例。 - 这个比值消除了路径长度、组织吸收等因素 - 只与动脉血中HbO₂和Hb的相对浓度有关 - 通过临床校准建立R与SpO2的对应关系 4. **等吸收点**： - 在805nm处，HbO₂和Hb的吸收系数相同 - 这个波长可以用于测量总血红蛋白浓度，但无法区分氧合状态 - 进一步证明需要两个不同波长 **结论**：双波长测量是SpO2准确测量的基础，单波长无法提供足够的信息来区分血氧饱和度的变化。问题2：AC和DC成分的意义¶
问题：在PPG信号中，AC成分和DC成分分别代表什么？为什么SpO2计算使用AC/DC比值而不是直接使用AC或DC值？
点击查看答案
**答案**： **AC和DC成分的意义**： 1. **DC成分（直流成分）**： - 代表恒定的光吸收 - 主要来源： * 静脉血（约75%的血液） * 组织（皮肤、肌肉、骨骼） * 毛细血管血 * 非脉动的动脉血 - 占总信号的约98-99% - 随时间缓慢变化（呼吸、体位等） 2. **AC成分（交流成分）**： - 代表周期性变化的光吸收 - 主要来源： * 动脉血的脉动（心脏收缩和舒张） * 动脉血管容积的周期性变化 - 占总信号的约1-2% - 频率对应心率（0.5-5Hz，30-300 bpm） **为什么使用AC/DC比值**： 1. **归一化**： - AC/DC比值消除了绝对光强度的影响 - 不同的LED电流、探头位置、组织厚度都会影响绝对值 - 比值使测量结果与这些因素无关 2. **消除共同因素**： - 组织吸收、静脉血吸收等因素同时影响AC和DC - 比值可以消除这些共同因素的影响 - 只保留动脉血氧合状态的信息 3. **物理意义**： - AC/DC比值代表"调制深度" - 反映动脉血容积变化相对于总吸收的比例 - 这个比例与血红蛋白的氧合状态直接相关 4. **R值的计算**： - 进一步消除了脉搏强度的影响 - 只与两种血红蛋白的相对浓度有关 - 与SpO2有稳定的对应关系 5. **实际优势**： - 对探头松动、移动不敏感 - 对LED老化、温度变化不敏感 - 提高测量的鲁棒性和准确性 **结论**：AC/DC比值是一种归一化方法，消除了许多干扰因素，使SpO2测量更加准确和可靠。问题3：运动伪影的挑战¶
问题：运动伪影是SpO2测量中最大的挑战之一。请描述至少三种运动伪影抑制方法，并比较它们的优缺点。
// FFT频域滤波
fft_execute(ppg_data, fft_output, fft_config);
// 识别和保留脉搏频率峰值
// 滤除运动频率成分
ifft_execute(filtered_fft, ppg_filtered, fft_config);
问题4：灌注指数的临床意义¶
问题：灌注指数（Perfusion Index, PI）是如何计算的？它的临床意义是什么？PI值过低时应该如何处理？
点击查看答案
**答案**： **灌注指数的计算**： 灌注指数定义为脉动血流（AC）与非脉动血流（DC）的比值，以百分比表示： 通常使用红外光（940nm）的信号计算： **典型PI值范围**： - **正常范围**：1% - 20% - **良好灌注**：> 4% - **中等灌注**：1% - 4% - **低灌注**：< 1% - **极低灌注**：< 0.3%（测量困难） **临床意义**： 1. **外周灌注评估**： - 反映测量部位的血液循环状况 - 评估外周血管阻力和血流量 - 监测休克、低血压等循环障碍 2. **测量质量指标**： - PI > 1%：通常可以获得可靠的SpO2测量 - PI < 0.5%：SpO2测量可能不准确 - PI < 0.3%：测量失败风险高 3. **临床应用**： - **新生儿监护**：评估外周循环，预测低血压 - **麻醉监测**：评估交感神经阻滞效果 - **休克诊断**：低PI提示外周灌注不足 - **血管疾病**：评估外周动脉疾病严重程度 - **区域麻醉**：评估神经阻滞效果 4. **预测价值**： - 低PI可能预示： * 低血容量 * 血管收缩 * 心输出量降低 * 外周血管疾病 * 低体温 **PI值过低时的处理**： **1. 技术层面**：// 自动增益控制
if (perfusion_index < 1.0f) {
// 增加LED电流
led_current *= 1.2f;
if (led_current > MAX_LED_CURRENT) {
led_current = MAX_LED_CURRENT;
}
led_set_current(led_current);
// 增加放大器增益
amplifier_gain *= 1.5f;
if (amplifier_gain > MAX_GAIN) {
amplifier_gain = MAX_GAIN;
}
set_amplifier_gain(amplifier_gain);
}
// 更换测量部位
if (perfusion_index < 0.5f) {
display_message("灌注不足，请尝试其他手指或耳垂");
}
// 延长平均时间
if (perfusion_index < 1.0f) {
averaging_window = 16; // 增加到16秒
} else {
averaging_window = 8; // 正常8秒
}
// PI阈值报警
typedef struct {
float pi_low_threshold; // 低PI阈值
float pi_critical_threshold; // 危急PI阈值
bool pi_alarm_enabled;
} PI_Alarm_Config_t;
void check_pi_alarm(float perfusion_index, PI_Alarm_Config_t* config) {
if (perfusion_index < config->pi_critical_threshold) {
trigger_alarm(ALARM_PI_CRITICAL, "灌注极低，测量可能不可靠");
} else if (perfusion_index < config->pi_low_threshold) {
trigger_alarm(ALARM_PI_LOW, "灌注不足，请检查探头位置");
}
}
问题5：校准曲线的建立¶
问题：SpO2设备的校准曲线是如何建立的？为什么不能使用理论计算直接从R值得到SpO2，而必须通过临床试验校准？
点击查看答案
**答案**： **校准曲线建立过程**： **1. 临床试验设计**：受试者招募：
- 健康志愿者（通常20-30人）
- 年龄范围：18-65岁
- 不同性别、肤色（Fitzpatrick I-VI型）
- 排除标准：心肺疾病、贫血、吸烟等
试验方案：
- 控制性低氧试验（Controlled Hypoxia Study）
- 受试者吸入不同氧浓度的气体
- SpO2范围：70%-100%（通常不低于70%，安全考虑）
- 每个SpO2水平稳定3-5分钟
// 同步采集数据
typedef struct {
float spo2_reference; // 参考SpO2（动脉血气分析）
float r_value; // 脉搏血氧仪测量的R值
float perfusion_index; // 灌注指数
uint8_t skin_tone; // 肤色类型
float hemoglobin; // 血红蛋白浓度
uint32_t timestamp; // 时间戳
} Calibration_Data_Point_t;
// 参考标准：动脉血气分析（CO-oximetry）
// 这是测量SpO2的金标准
float spo2_reference = co_oximetry_measure();
// 同时记录脉搏血氧仪的R值
float r_value = spo2_device_get_r_value();
// 保存数据点
calibration_data[i].spo2_reference = spo2_reference;
calibration_data[i].r_value = r_value;
// 多项式拟合（通常使用2-3阶）
// SpO2 = a0 + a1*R + a2*R² + a3*R³
// 最小二乘法求解系数
void calibration_curve_fit(Calibration_Data_Point_t* data,
uint16_t count,
float* coefficients) {
// 构建矩阵方程
// [1 R1 R1² R1³] [a0] [SpO2_1]
// [1 R2 R2² R2³] × [a1] = [SpO2_2]
// [1 R3 R3² R3³] [a2] [SpO2_3]
// [...] [a3] [...]
// 使用正规方程求解：(A^T × A) × x = A^T × b
least_squares_solve(data, count, coefficients, 4);
}
// 评估拟合质量
float evaluate_calibration(Calibration_Data_Point_t* data,
uint16_t count,
float* coefficients) {
float sum_squared_error = 0.0f;
for (uint16_t i = 0; i < count; i++) {
// 使用校准曲线计算SpO2
float spo2_calculated = coefficients[0] +
coefficients[1] * data[i].r_value +
coefficients[2] * data[i].r_value * data[i].r_value +
coefficients[3] * data[i].r_value * data[i].r_value * data[i].r_value;
// 计算误差
float error = spo2_calculated - data[i].spo2_reference;
sum_squared_error += error * error;
}
// 计算Arms（准确性指标）
float arms = sqrtf(sum_squared_error / count);
return arms;
}
// 影响因素众多
typedef struct {
float hemoglobin_concentration; // 血红蛋白浓度变化
float hematocrit; // 红细胞压积
float carboxyhemoglobin; // 碳氧血红蛋白（吸烟）
float methemoglobin; // 高铁血红蛋白
float bilirubin; // 胆红素（黄疸）
float melanin; // 黑色素（肤色）
float tissue_thickness; // 组织厚度
float venous_pulsation; // 静脉脉动
} Physiological_Factors_t;
参考文献¶
-
ISO 80601-2-61:2017 - Medical electrical equipment - Part 2-61: Particular requirements for basic safety and essential performance of pulse oximeter equipment
-
Webster, J. G. (Ed.). (1997). Design of Pulse Oximeters. CRC Press.
-
Tremper, K. K., & Barker, S. J. (1989). Pulse oximetry. Anesthesiology, 70(1), 98-108.
-
Nitzan, M., Romem, A., & Koppel, R. (2014). Pulse oximetry: fundamentals and technology update. Medical Devices: Evidence and Research, 7, 231-239.
-
Chan, E. D., Chan, M. M., & Chan, M. M. (2013). Pulse oximetry: understanding its basic principles facilitates appreciation of its limitations. Respiratory Medicine, 107(6), 789-799.
-
Jubran, A. (2015). Pulse oximetry. Critical Care, 19(1), 272.
相关资源¶
- 数字滤波器设计 - PPG信号滤波基础
- FFT快速傅里叶变换 - 频域分析方法
- ECG信号处理 - 类似的生理信号处理
- ADC和DAC - 信号采集硬件
- IEC 60601-1标准 - 医疗电气设备安全标准
- FDA医疗器械认证 - 美国市场准入
最后更新：2026-02-09
版本：1.0
作者：医疗器械嵌入式软件知识体系项目组
💬 讨论区
欢迎在这里分享您的想法、提出问题或参与讨论。需要 GitHub 账号登录。