简介
上一个章节中我们已经点亮了SSD1306的屏幕并且进行了输出测试。 那么在本章节我们将驱动max30102. 并且将数据显示在SSD1306的屏幕上。 这个传感器的驱动倒是也好写。但是麻烦的是计算数据。计算数据的话自己写算法是一件十分复杂的事情。我的这个计算方式是从GITHUB中找到的算法计算代码。原本是C++的版本，我把它简单的修改了一下就变成C语言的版本了。
对于MAX30102的读取比较简单。首先定义各种需要用到的寄存器
// ---------- MAX30102 寄存器 ---------- #define MAX30102_ADDR 0x57 // 7-bit I2C 地址 #define REG_INT_STATUS_1 0x00 #define REG_INT_ENABLE_1 0x02 #define REG_FIFO_WR_PTR 0x04 #define REG_OVF_COUNTER 0x05 #define REG_FIFO_RD_PTR 0x06 #define REG_FIFO_DATA 0x07 #define REG_MODE_CONFIG 0x09 #define REG_SPO2_CONFIG 0x0A #define REG_LED1_PA 0x0C // RED LED #define REG_LED2_PA 0x0D // IR LED #define REG_TEMP_INTEGER 0x1F #define REG_TEMP_FRACTION 0x20 #define REG_PART_ID 0xFF #define MA4_SIZE 4 #define HAMMING_SIZE 5 uint32_t red_buffer[BUFFER_SIZE]; uint32_t ir_buffer[BUFFER_SIZE]; int buffer_index = 0;
以及封装一下原本的I2C函数
// ---------------- I2C 基础读写函数 ----------------
int max30102_write_reg(uint8_t reg, uint8_t value)
{
uint8_t data[2] = {reg, value};
mxc_i2c_req_t req;
req.i2c = I2C_INST;
req.addr = MAX30102_ADDR;
req.tx_buf = data;
req.tx_len = 2;
req.rx_buf = NULL;
req.rx_len = 0;
req.restart = 0;
req.callback = NULL;
return MXC_I2C_MasterTransaction(&req);
}
int max30102_read_reg(uint8_t reg, uint8_t *value)
{
mxc_i2c_req_t req;
int err;
req.i2c = I2C_INST;
req.addr = MAX30102_ADDR;
req.tx_buf = ®
req.tx_len = 1;
req.rx_buf = NULL;
req.rx_len = 0;
req.restart = 1; // Repeated START
req.callback = NULL;
err = MXC_I2C_MasterTransaction(&req);
if (err != E_NO_ERROR)
return err;
req.tx_buf = NULL;
req.tx_len = 0;
req.rx_buf = value;
req.rx_len = 1;
req.restart = 0;
req.callback = NULL;
return MXC_I2C_MasterTransaction(&req);
}
int max30102_read_multi(uint8_t reg, uint8_t *buf, int len)
{
mxc_i2c_req_t req;
int err;
req.i2c = I2C_INST;
req.addr = MAX30102_ADDR;
req.tx_buf = ®
req.tx_len = 1;
req.rx_buf = NULL;
req.rx_len = 0;
req.restart = 1;
req.callback = NULL;
err = MXC_I2C_MasterTransaction(&req);
if (err != E_NO_ERROR)
return err;
req.tx_buf = NULL;
req.tx_len = 0;
req.rx_buf = buf;
req.rx_len = len;
req.restart = 0;
req.callback = NULL;
return MXC_I2C_MasterTransaction(&req);
}MAX30102的初始化，其主要作用为初始化寄存器等。
int max30102_init(void)
{
int ret;
uint8_t part_id;
MXC_I2C_Shutdown(I2C_INST);
MXC_I2C_Init(I2C_INST, 1, 0); // master mode
MXC_I2C_SetFrequency(I2C_INST, 400000); // 400kHz
ret = max30102_read_reg(REG_PART_ID, &part_id);
if (ret != E_NO_ERROR)
{
printf("I2C read failed\n");
return ret;
}
if (part_id != 0x15)
{
printf("MAX30102 not found! Part ID: 0x%02X\n", part_id);
return -1;
}
printf("MAX30102 detected, Part ID: 0x%02X\n", part_id);
max30102_write_reg(REG_MODE_CONFIG, 0x40);
MXC_Delay(MXC_DELAY_MSEC(10));
max30102_write_reg(REG_MODE_CONFIG, 0x03); // SpO2 模式
max30102_write_reg(REG_SPO2_CONFIG, 0x27); // 18-bit, 100Hz
max30102_write_reg(REG_LED1_PA, 0x24); // 红光 ~7mA
max30102_write_reg(REG_LED2_PA, 0x24); // IR ~7mA
return 0;
}然后从FIFO读取数据即可。
// ---------------- 读取 FIFO 数据 ----------------
int max30102_read_fifo(uint32_t *red, uint32_t *ir)
{
uint8_t buf[6];
int ret = max30102_read_multi(REG_FIFO_DATA, buf, 6);
if (ret != E_NO_ERROR)
return ret;
*red = ((uint32_t)buf[0] << 16) | ((uint32_t)buf[1] << 8) | buf[2];
*ir = ((uint32_t)buf[3] << 16) | ((uint32_t)buf[4] << 8) | buf[5];
*red &= 0x3FFFF; // 18-bit
*ir &= 0x3FFFF;
return 0;
}上述的代码就已经可以完整的驱动起来这个传感器了。但是此时读取到的数据并不是血氧和心跳，而是原始的数据。所以如果需要读取心跳血氧数据的话需要进行转换。而这个算法好像还是保密的，我在GIThub上找到了一个C++的版本。所幸不需要很多修改即可。
我修改后的头文件如下所示
#ifndef ALGORITHM_H_ #define ALGORITHM_H_ #include <stdint.h> #define true 1 #define false 0 #define FS 100 #define BUFFER_SIZE (FS * 8) #define HR_FIFO_SIZE 7 #define MA4_SIZE 4 // DO NOT CHANGE #define HAMMING_SIZE 5 // DO NOT CHANGE #define min(x, y) ((x) < (y) ? (x) : (y)) // ====== 只声明，不定义 ====== extern const uint16_t auw_hamm[HAMMING_SIZE]; extern const uint8_t uch_spo2_table[184]; extern int32_t an_dx[BUFFER_SIZE - MA4_SIZE]; extern int32_t an_x[BUFFER_SIZE]; extern int32_t an_y[BUFFER_SIZE]; // ====== 函数声明 ====== void maxim_heart_rate_and_oxygen_saturation( uint32_t *pun_ir_buffer, int32_t n_ir_buffer_length, uint32_t *pun_red_buffer, int32_t *pn_spo2, int8_t *pch_spo2_valid, int32_t *pn_heart_rate, int8_t *pch_hr_valid); void maxim_find_peaks(int32_t *pn_locs, int32_t *pn_npks, int32_t *pn_x, int32_t n_size, int32_t n_min_height, int32_t n_min_distance, int32_t n_max_num); void maxim_peaks_above_min_height(int32_t *pn_locs, int32_t *pn_npks, int32_t *pn_x, int32_t n_size, int32_t n_min_height); void maxim_remove_close_peaks(int32_t *pn_locs, int32_t *pn_npks, int32_t *pn_x, int32_t n_min_distance); void maxim_sort_ascend(int32_t *pn_x, int32_t n_size); void maxim_sort_indices_descend(int32_t *pn_x, int32_t *pn_indx, int32_t n_size); #endif /* ALGORITHM_H_ */
源文件
/** \file algorithm.cpp ******************************************************
*
* Project: MAXREFDES117#
* Filename: algorithm.cpp
* Description: This module calculates the heart rate/SpO2 level
*
*
* --------------------------------------------------------------------
*
* This code follows the following naming conventions:
*
* char ch_pmod_value
* char (array) s_pmod_s_string[16]
* float f_pmod_value
* int32_t n_pmod_value
* int32_t (array) an_pmod_value[16]
* int16_t w_pmod_value
* int16_t (array) aw_pmod_value[16]
* uint16_t uw_pmod_value
* uint16_t (array) auw_pmod_value[16]
* uint8_t uch_pmod_value
* uint8_t (array) auch_pmod_buffer[16]
* uint32_t un_pmod_value
* int32_t * pn_pmod_value
*
* ------------------------------------------------------------------------- */
/*******************************************************************************
* Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
* OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Except as contained in this notice, the name of Maxim Integrated
* Products, Inc. shall not be used except as stated in the Maxim Integrated
* Products, Inc. Branding Policy.
*
* The mere transfer of this software does not imply any licenses
* of trade secrets, proprietary technology, copyrights, patents,
* trademarks, maskwork rights, or any other form of intellectual
* property whatsoever. Maxim Integrated Products, Inc. retains all
* ownership rights.
*******************************************************************************
*/
#include "algorithm.h"
// Hamming 窗口
const uint16_t auw_hamm[HAMMING_SIZE] = {41, 276, 512, 276, 41};
// SpO2 查表
const uint8_t uch_spo2_table[184] = {
95, 95, 95, 96, 96, 96, 97, 97, 97, 97, 97, 98, 98, 98, 98, 98, 99, 99, 99, 99,
99, 99, 99, 99, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
100, 100, 100, 100, 100, 100, 100, 100, 99, 99, 99, 99, 99, 99, 99, 99,
98, 98, 98, 98, 98, 98, 97, 97, 97, 97, 96, 96, 96, 96, 95, 95, 95, 94,
94, 94, 93, 93, 93, 92, 92, 92, 91, 91, 90, 90, 89, 89, 89, 88, 88, 87,
87, 86, 86, 85, 85, 84, 84, 83, 82, 82, 81, 81, 80, 80, 79, 78, 78, 77,
76, 76, 75, 74, 74, 73, 72, 72, 71, 70, 69, 69, 68, 67, 66, 66, 65, 64,
63, 62, 62, 61, 60, 59, 58, 57, 56, 56, 55, 54, 53, 52, 51, 50, 49, 48,
47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 31, 30, 29,
28, 27, 26, 25, 23, 22, 21, 20, 19, 17, 16, 15, 14, 12, 11, 10, 9, 7, 6, 5,
3, 2, 1};
// 这里才是真正定义（全局唯一）
int32_t an_dx[BUFFER_SIZE - MA4_SIZE];
int32_t an_x[BUFFER_SIZE];
int32_t an_y[BUFFER_SIZE];
void maxim_heart_rate_and_oxygen_saturation(uint32_t *pun_ir_buffer, int32_t n_ir_buffer_length, uint32_t *pun_red_buffer, int32_t *pn_spo2, int8_t *pch_spo2_valid,
int32_t *pn_heart_rate, int8_t *pch_hr_valid)
/**
* \brief Calculate the heart rate and SpO2 level
* \par Details
* By detecting peaks of PPG cycle and corresponding AC/DC of red/infra-red signal, the ratio for the SPO2 is computed.
* Since this algorithm is aiming for Arm M0/M3. formaula for SPO2 did not achieve the accuracy due to register overflow.
* Thus, accurate SPO2 is precalculated and save longo uch_spo2_table[] per each ratio.
*
* \param[in] *pun_ir_buffer - IR sensor data buffer
* \param[in] n_ir_buffer_length - IR sensor data buffer length
* \param[in] *pun_red_buffer - Red sensor data buffer
* \param[out] *pn_spo2 - Calculated SpO2 value
* \param[out] *pch_spo2_valid - 1 if the calculated SpO2 value is valid
* \param[out] *pn_heart_rate - Calculated heart rate value
* \param[out] *pch_hr_valid - 1 if the calculated heart rate value is valid
*
* \retval None
*/
{
uint32_t un_ir_mean, un_only_once;
int32_t k, n_i_ratio_count;
int32_t i, s, m, n_exact_ir_valley_locs_count, n_middle_idx;
int32_t n_th1, n_npks, n_c_min;
int32_t an_ir_valley_locs[15];
int32_t an_exact_ir_valley_locs[15];
int32_t an_dx_peak_locs[15];
int32_t n_peak_interval_sum;
int32_t n_y_ac, n_x_ac;
int32_t n_spo2_calc;
int32_t n_y_dc_max, n_x_dc_max;
int32_t n_y_dc_max_idx, n_x_dc_max_idx;
int32_t an_ratio[5], n_ratio_average;
int32_t n_nume, n_denom;
// remove DC of ir signal
un_ir_mean = 0;
for (k = 0; k < n_ir_buffer_length; k++)
un_ir_mean += pun_ir_buffer[k];
un_ir_mean = un_ir_mean / n_ir_buffer_length;
for (k = 0; k < n_ir_buffer_length; k++)
an_x[k] = pun_ir_buffer[k] - un_ir_mean;
// 4 pt Moving Average
for (k = 0; k < BUFFER_SIZE - MA4_SIZE; k++)
{
n_denom = (an_x[k] + an_x[k + 1] + an_x[k + 2] + an_x[k + 3]);
an_x[k] = n_denom / (int32_t)4;
}
// get difference of smoothed IR signal
for (k = 0; k < BUFFER_SIZE - MA4_SIZE - 1; k++)
an_dx[k] = (an_x[k + 1] - an_x[k]);
// 2-pt Moving Average to an_dx
for (k = 0; k < BUFFER_SIZE - MA4_SIZE - 2; k++)
{
an_dx[k] = (an_dx[k] + an_dx[k + 1]) / 2;
}
// hamming window
// flip wave form so that we can detect valley with peak detector
for (i = 0; i < BUFFER_SIZE - HAMMING_SIZE - MA4_SIZE - 2; i++)
{
s = 0;
for (k = i; k < i + HAMMING_SIZE; k++)
{
s -= an_dx[k] * auw_hamm[k - i];
}
an_dx[i] = s / (int32_t)1146; // divide by sum of auw_hamm
}
n_th1 = 0; // threshold calculation
for (k = 0; k < BUFFER_SIZE - HAMMING_SIZE; k++)
{
n_th1 += ((an_dx[k] > 0) ? an_dx[k] : ((int32_t)0 - an_dx[k]));
}
n_th1 = n_th1 / (BUFFER_SIZE - HAMMING_SIZE);
// peak location is acutally index for sharpest location of raw signal since we flipped the signal
maxim_find_peaks(an_dx_peak_locs, &n_npks, an_dx, BUFFER_SIZE - HAMMING_SIZE, n_th1, 8, 5); // peak_height, peak_distance, max_num_peaks
n_peak_interval_sum = 0;
if (n_npks >= 2)
{
for (k = 1; k < n_npks; k++)
n_peak_interval_sum += (an_dx_peak_locs[k] - an_dx_peak_locs[k - 1]);
n_peak_interval_sum = n_peak_interval_sum / (n_npks - 1);
*pn_heart_rate = (int32_t)(6000 / n_peak_interval_sum); // beats per minutes
*pch_hr_valid = 1;
}
else
{
*pn_heart_rate = -999;
*pch_hr_valid = 0;
}
for (k = 0; k < n_npks; k++)
an_ir_valley_locs[k] = an_dx_peak_locs[k] + HAMMING_SIZE / 2;
// raw value : RED(=y) and IR(=X)
// we need to assess DC and AC value of ir and red PPG.
for (k = 0; k < n_ir_buffer_length; k++)
{
an_x[k] = pun_ir_buffer[k];
an_y[k] = pun_red_buffer[k];
}
// find precise min near an_ir_valley_locs
n_exact_ir_valley_locs_count = 0;
for (k = 0; k < n_npks; k++)
{
un_only_once = 1;
m = an_ir_valley_locs[k];
n_c_min = 16777216; // 2^24;
if (m + 5 < BUFFER_SIZE - HAMMING_SIZE && m - 5 > 0)
{
for (i = m - 5; i < m + 5; i++)
if (an_x[i] < n_c_min)
{
if (un_only_once > 0)
{
un_only_once = 0;
}
n_c_min = an_x[i];
an_exact_ir_valley_locs[k] = i;
}
if (un_only_once == 0)
n_exact_ir_valley_locs_count++;
}
}
if (n_exact_ir_valley_locs_count < 2)
{
*pn_spo2 = -999; // do not use SPO2 since signal ratio is out of range
*pch_spo2_valid = 0;
return;
}
// 4 pt MA
for (k = 0; k < BUFFER_SIZE - MA4_SIZE; k++)
{
an_x[k] = (an_x[k] + an_x[k + 1] + an_x[k + 2] + an_x[k + 3]) / (int32_t)4;
an_y[k] = (an_y[k] + an_y[k + 1] + an_y[k + 2] + an_y[k + 3]) / (int32_t)4;
}
// using an_exact_ir_valley_locs , find ir-red DC andir-red AC for SPO2 calibration ratio
// finding AC/DC maximum of raw ir * red between two valley locations
n_ratio_average = 0;
n_i_ratio_count = 0;
for (k = 0; k < 5; k++)
an_ratio[k] = 0;
for (k = 0; k < n_exact_ir_valley_locs_count; k++)
{
if (an_exact_ir_valley_locs[k] > BUFFER_SIZE)
{
*pn_spo2 = -999; // do not use SPO2 since valley loc is out of range
*pch_spo2_valid = 0;
return;
}
}
// find max between two valley locations
// and use ratio betwen AC compoent of Ir & Red and DC compoent of Ir & Red for SPO2
for (k = 0; k < n_exact_ir_valley_locs_count - 1; k++)
{
n_y_dc_max = -16777216;
n_x_dc_max = -16777216;
if (an_exact_ir_valley_locs[k + 1] - an_exact_ir_valley_locs[k] > 10)
{
for (i = an_exact_ir_valley_locs[k]; i < an_exact_ir_valley_locs[k + 1]; i++)
{
if (an_x[i] > n_x_dc_max)
{
n_x_dc_max = an_x[i];
n_x_dc_max_idx = i;
}
if (an_y[i] > n_y_dc_max)
{
n_y_dc_max = an_y[i];
n_y_dc_max_idx = i;
}
}
n_y_ac = (an_y[an_exact_ir_valley_locs[k + 1]] - an_y[an_exact_ir_valley_locs[k]]) * (n_y_dc_max_idx - an_exact_ir_valley_locs[k]); // red
n_y_ac = an_y[an_exact_ir_valley_locs[k]] + n_y_ac / (an_exact_ir_valley_locs[k + 1] - an_exact_ir_valley_locs[k]);
n_y_ac = an_y[n_y_dc_max_idx] - n_y_ac; // subracting linear DC compoenents from raw
n_x_ac = (an_x[an_exact_ir_valley_locs[k + 1]] - an_x[an_exact_ir_valley_locs[k]]) * (n_x_dc_max_idx - an_exact_ir_valley_locs[k]); // ir
n_x_ac = an_x[an_exact_ir_valley_locs[k]] + n_x_ac / (an_exact_ir_valley_locs[k + 1] - an_exact_ir_valley_locs[k]);
n_x_ac = an_x[n_y_dc_max_idx] - n_x_ac; // subracting linear DC compoenents from raw
n_nume = (n_y_ac * n_x_dc_max) >> 7; // prepare X100 to preserve floating value
n_denom = (n_x_ac * n_y_dc_max) >> 7;
if (n_denom > 0 && n_i_ratio_count < 5 && n_nume != 0)
{
an_ratio[n_i_ratio_count] = (n_nume * 100) / n_denom; // formular is ( n_y_ac *n_x_dc_max) / ( n_x_ac *n_y_dc_max) ;
n_i_ratio_count++;
}
}
}
maxim_sort_ascend(an_ratio, n_i_ratio_count);
n_middle_idx = n_i_ratio_count / 2;
if (n_middle_idx > 1)
n_ratio_average = (an_ratio[n_middle_idx - 1] + an_ratio[n_middle_idx]) / 2; // use median
else
n_ratio_average = an_ratio[n_middle_idx];
if (n_ratio_average > 2 && n_ratio_average < 184)
{
n_spo2_calc = uch_spo2_table[n_ratio_average];
*pn_spo2 = n_spo2_calc;
*pch_spo2_valid = 1; // float_SPO2 = -45.060*n_ratio_average* n_ratio_average/10000 + 30.354 *n_ratio_average/100 + 94.845 ; // for comparison with table
}
else
{
*pn_spo2 = -999; // do not use SPO2 since signal ratio is out of range
*pch_spo2_valid = 0;
}
}
void maxim_find_peaks(int32_t *pn_locs, int32_t *pn_npks, int32_t *pn_x, int32_t n_size, int32_t n_min_height, int32_t n_min_distance, int32_t n_max_num)
/**
* \brief Find peaks
* \par Details
* Find at most MAX_NUM peaks above MIN_HEIGHT separated by at least MIN_DISTANCE
*
* \retval None
*/
{
maxim_peaks_above_min_height(pn_locs, pn_npks, pn_x, n_size, n_min_height);
maxim_remove_close_peaks(pn_locs, pn_npks, pn_x, n_min_distance);
*pn_npks = min(*pn_npks, n_max_num);
}
void maxim_peaks_above_min_height(int32_t *pn_locs, int32_t *pn_npks, int32_t *pn_x, int32_t n_size, int32_t n_min_height)
/**
* \brief Find peaks above n_min_height
* \par Details
* Find all peaks above MIN_HEIGHT
*
* \retval None
*/
{
int32_t i = 1, n_width;
*pn_npks = 0;
while (i < n_size - 1)
{
if (pn_x[i] > n_min_height && pn_x[i] > pn_x[i - 1])
{ // find left edge of potential peaks
n_width = 1;
while (i + n_width < n_size && pn_x[i] == pn_x[i + n_width]) // find flat peaks
n_width++;
if (pn_x[i] > pn_x[i + n_width] && (*pn_npks) < 15)
{ // find right edge of peaks
pn_locs[(*pn_npks)++] = i;
// for flat peaks, peak location is left edge
i += n_width + 1;
}
else
i += n_width;
}
else
i++;
}
}
void maxim_remove_close_peaks(int32_t *pn_locs, int32_t *pn_npks, int32_t *pn_x, int32_t n_min_distance)
/**
* \brief Remove peaks
* \par Details
* Remove peaks separated by less than MIN_DISTANCE
*
* \retval None
*/
{
int32_t i, j, n_old_npks, n_dist;
/* Order peaks from large to small */
maxim_sort_indices_descend(pn_x, pn_locs, *pn_npks);
for (i = -1; i < *pn_npks; i++)
{
n_old_npks = *pn_npks;
*pn_npks = i + 1;
for (j = i + 1; j < n_old_npks; j++)
{
n_dist = pn_locs[j] - (i == -1 ? -1 : pn_locs[i]); // lag-zero peak of autocorr is at index -1
if (n_dist > n_min_distance || n_dist < -n_min_distance)
pn_locs[(*pn_npks)++] = pn_locs[j];
}
}
// Resort indices longo ascending order
maxim_sort_ascend(pn_locs, *pn_npks);
}
void maxim_sort_ascend(int32_t *pn_x, int32_t n_size)
/**
* \brief Sort array
* \par Details
* Sort array in ascending order (insertion sort algorithm)
*
* \retval None
*/
{
int32_t i, j, n_temp;
for (i = 1; i < n_size; i++)
{
n_temp = pn_x[i];
for (j = i; j > 0 && n_temp < pn_x[j - 1]; j--)
pn_x[j] = pn_x[j - 1];
pn_x[j] = n_temp;
}
}
void maxim_sort_indices_descend(int32_t *pn_x, int32_t *pn_indx, int32_t n_size)
/**
* \brief Sort indices
* \par Details
* Sort indices according to descending order (insertion sort algorithm)
*
* \retval None
*/
{
int32_t i, j, n_temp;
for (i = 1; i < n_size; i++)
{
n_temp = pn_indx[i];
for (j = i; j > 0 && pn_x[n_temp] > pn_x[pn_indx[j - 1]]; j--)
pn_indx[j] = pn_indx[j - 1];
pn_indx[j] = n_temp;
}
}这样的话通过上述的算法就可以将原始数据转换成血氧和心率了。
然后只需要在主函数中进行调用和显示OLED即可。
int main(void)
{
uint32_t red, ir;
if (max30102_init() != 0)
{
printf("MAX30102 init failed!\n");
return 0;
}
SSD1306_Init();
SSD1306_Clear();
SSD1306_Print(0, 0, "MAX30102 Demo");
SSD1306_DisplayFrame(SSD1306_Buffer);
while (1)
{
if (max30102_read_fifo(&red, &ir) == 0)
{
red_buffer[buffer_index] = red;
ir_buffer[buffer_index] = ir;
buffer_index++;
if (buffer_index >= BUFFER_SIZE)
{
int32_t spo2, heart_rate;
int8_t spo2_valid, hr_valid;
// 调用算法
maxim_heart_rate_and_oxygen_saturation(
ir_buffer, BUFFER_SIZE,
red_buffer,
&spo2, &spo2_valid,
&heart_rate, &hr_valid);
// 清屏
SSD1306_Clear();
// 打印心率
if (hr_valid && heart_rate > 40 && heart_rate < 180)
{
printf("Heart Rate = %d BPM, ", heart_rate);
SSD1306_Print(0, 2, "HR:");
SSD1306_PrintInt(30, 2, heart_rate);
SSD1306_Print(80, 2, "BPM");
}
else
{
printf("Heart Rate = --- , ");
SSD1306_Print(0, 2, "HR: ---");
}
// 打印血氧
if (spo2_valid && spo2 > 70 && spo2 <= 100)
{
printf("SpO2 = %d%%\n", spo2);
SSD1306_Print(0, 4, "SpO2:");
SSD1306_PrintInt(40, 4, spo2);
SSD1306_Print(80, 4, "%");
}
else
{
printf("SpO2 = ---\n");
SSD1306_Print(0, 4, "SpO2: ---");
}
// 刷新屏幕
SSD1306_DisplayFrame(SSD1306_Buffer);
// 重置 buffer
buffer_index = 0;
}
}
// 100Hz 采样
MXC_Delay(MXC_DELAY_MSEC(10));
}
}效果如下所示
实际上尽管如此，我感觉数据还是不是很准确。但是这已经是目前能做到的极限了。
我要赚赏金
STM32
MCU
通讯及无线技术
物联网技术
电子DIY
板卡试用
基础知识
软件与操作系统
我爱生活
小e食堂
