LVGL+FreeRTOS实战项目：智能健康助手（Max30102篇）
MAX30102 心率血氧模块简介
-
功能：用于检测心率和血氧饱和度，集成了红外和红光 LED 以及光电二极管。
-
接口：支持 I2C 通信，默认 I2C 地址为
0x57。 -
应用：广泛用于健康监测设备中，如智能手环、手表等。
硬件连接
| MAX30102 引脚 | 功能 | STM32 连接 |
|---|---|---|
| VCC | 电源输入 (+3.3V) | 3.3V |
| GND | 地 | GND |
| INT | 中断输出 | PB8 |
| SDA | 数据线 | PB9 |
| SCL | 时钟线 | PB7 |
软件部分
我们代码中使用的是软件I2C来和MAX30102通信。
Max30102.c
void MAX30102_Init(void)
{
MAX30102_INT_Init();
MAX30102_IIC_Init();
MAX30102_Reset();
max30102_Bus_Write(REG_INTR_ENABLE_1,0xc0); // INTR setting
max30102_Bus_Write(REG_INTR_ENABLE_2,0x00);
max30102_Bus_Write(REG_FIFO_WR_PTR,0x00); //FIFO_WR_PTR[4:0]
max30102_Bus_Write(REG_OVF_COUNTER,0x00); //OVF_COUNTER[4:0]
max30102_Bus_Write(REG_FIFO_RD_PTR,0x00); //FIFO_RD_PTR[4:0]
max30102_Bus_Write(REG_FIFO_CONFIG,0x0f); //sample avg = 1, fifo rollover=false, fifo almost full = 17
max30102_Bus_Write(REG_MODE_CONFIG,0x03); //0x02 for Red only, 0x03 for SpO2 mode 0x07 multimode LED
max30102_Bus_Write(REG_SPO2_CONFIG,0x27); // SPO2_ADC range = 4096nA, SPO2 sample rate (100 Hz), LED pulseWidth (400uS)
max30102_Bus_Write(REG_LED1_PA,0x24); //Choose value for ~ 7mA for LED1
max30102_Bus_Write(REG_LED2_PA,0x24); // Choose value for ~ 7mA for LED2
max30102_Bus_Write(REG_PILOT_PA,0x7f); // Choose value for ~ 25mA for Pilot LED
}
这里我们比较直观了，首先我们肯定是初始化I2C协议，我们用IO口模拟出I2C协议，然后封装好对应的写字节以及读字节函数，然后查看我们的Max30102说明文档，写入对应的参数值，从而实现初始化Max30102模块，我们直接查看源码，配合注释，其实以及非常清晰了。
源文件
#include "max30102.h"
#include "delay.h"u8 max30102_Bus_Write(u8 Register_Address, u8 Word_Data)
{/* 采用串行EEPROM随即读取指令序列，连续读取若干字节 *//* 第1步：发起I2C总线启动信号 */MAX30102_IIC_Start();/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */MAX30102_IIC_Send_Byte(max30102_WR_address | I2C_WR); /* 此处是写指令 *//* 第3步：发送ACK */if (MAX30102_IIC_Wait_Ack() != 0){goto cmd_fail; /* EEPROM器件无应答 */}/* 第4步：发送字节地址 */MAX30102_IIC_Send_Byte(Register_Address);if (MAX30102_IIC_Wait_Ack() != 0){goto cmd_fail; /* EEPROM器件无应答 */}/* 第5步：开始写入数据 */MAX30102_IIC_Send_Byte(Word_Data);/* 第6步：发送ACK */if (MAX30102_IIC_Wait_Ack() != 0){goto cmd_fail; /* EEPROM器件无应答 */}/* 发送I2C总线停止信号 */MAX30102_IIC_Stop();return 1; /* 执行成功 */cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 *//* 发送I2C总线停止信号 */MAX30102_IIC_Stop();return 0;
}u8 max30102_Bus_Read(u8 Register_Address)
{u8 data;/* 第1步：发起I2C总线启动信号 */MAX30102_IIC_Start();/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */MAX30102_IIC_Send_Byte(max30102_WR_address | I2C_WR); /* 此处是写指令 *//* 第3步：发送ACK */if (MAX30102_IIC_Wait_Ack() != 0){goto cmd_fail; /* EEPROM器件无应答 */}/* 第4步：发送字节地址， */MAX30102_IIC_Send_Byte((uint8_t)Register_Address);if (MAX30102_IIC_Wait_Ack() != 0){goto cmd_fail; /* EEPROM器件无应答 */}/* 第6步：重新启动I2C总线。下面开始读取数据 */MAX30102_IIC_Start();/* 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */MAX30102_IIC_Send_Byte(max30102_WR_address | I2C_RD); /* 此处是读指令 *//* 第8步：发送ACK */if (MAX30102_IIC_Wait_Ack() != 0){goto cmd_fail; /* EEPROM器件无应答 */}/* 第9步：读取数据 */{data = MAX30102_IIC_Read_Byte(0); /* 读1个字节 */MAX30102_IIC_NAck(); /* 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1) */}/* 发送I2C总线停止信号 */MAX30102_IIC_Stop();return data; /* 执行成功 返回data值 */cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 *//* 发送I2C总线停止信号 */MAX30102_IIC_Stop();return 0;
}void max30102_FIFO_ReadWords(u8 Register_Address,u16 Word_Data[][2],u8 count)
{u8 i=0;u8 no = count;u8 data1, data2;/* 第1步：发起I2C总线启动信号 */MAX30102_IIC_Start();/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */MAX30102_IIC_Send_Byte(max30102_WR_address | I2C_WR); /* 此处是写指令 *//* 第3步：发送ACK */if (MAX30102_IIC_Wait_Ack() != 0){goto cmd_fail; /* EEPROM器件无应答 */}/* 第4步：发送字节地址， */MAX30102_IIC_Send_Byte((uint8_t)Register_Address);if (MAX30102_IIC_Wait_Ack() != 0){goto cmd_fail; /* EEPROM器件无应答 */}/* 第6步：重新启动I2C总线。下面开始读取数据 */MAX30102_IIC_Start();/* 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */MAX30102_IIC_Send_Byte(max30102_WR_address | I2C_RD); /* 此处是读指令 *//* 第8步：发送ACK */if (MAX30102_IIC_Wait_Ack() != 0){goto cmd_fail; /* EEPROM器件无应答 */}/* 第9步：读取数据 */while (no){data1 = MAX30102_IIC_Read_Byte(0); MAX30102_IIC_Ack();data2 = MAX30102_IIC_Read_Byte(0);MAX30102_IIC_Ack();Word_Data[i][0] = (((u16)data1 << 8) | data2); //data1 = MAX30102_IIC_Read_Byte(0); MAX30102_IIC_Ack();data2 = MAX30102_IIC_Read_Byte(0);if(1==no)MAX30102_IIC_NAck(); /* 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1) */elseMAX30102_IIC_Ack();Word_Data[i][1] = (((u16)data1 << 8) | data2); no--; i++;}/* 发送I2C总线停止信号 */MAX30102_IIC_Stop();cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 *//* 发送I2C总线停止信号 */MAX30102_IIC_Stop();
}void max30102_FIFO_ReadBytes(u8 Register_Address,u8* Data)
{ max30102_Bus_Read(REG_INTR_STATUS_1);max30102_Bus_Read(REG_INTR_STATUS_2);/* 第1步：发起I2C总线启动信号 */MAX30102_IIC_Start();/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */MAX30102_IIC_Send_Byte(max30102_WR_address | I2C_WR); /* 此处是写指令 *//* 第3步：发送ACK */if (MAX30102_IIC_Wait_Ack() != 0){goto cmd_fail; /* EEPROM器件无应答 */}/* 第4步：发送字节地址， */MAX30102_IIC_Send_Byte((uint8_t)Register_Address);if (MAX30102_IIC_Wait_Ack() != 0){goto cmd_fail; /* EEPROM器件无应答 */}/* 第6步：重新启动I2C总线。下面开始读取数据 */MAX30102_IIC_Start();/* 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */MAX30102_IIC_Send_Byte(max30102_WR_address | I2C_RD); /* 此处是读指令 *//* 第8步：发送ACK */if (MAX30102_IIC_Wait_Ack() != 0){goto cmd_fail; /* EEPROM器件无应答 */}/* 第9步：读取数据 */Data[0] = MAX30102_IIC_Read_Byte(1); Data[1] = MAX30102_IIC_Read_Byte(1); Data[2] = MAX30102_IIC_Read_Byte(1); Data[3] = MAX30102_IIC_Read_Byte(1);Data[4] = MAX30102_IIC_Read_Byte(1); Data[5] = MAX30102_IIC_Read_Byte(0);/* 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1) *//* 发送I2C总线停止信号 */MAX30102_IIC_Stop();cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 *//* 发送I2C总线停止信号 */MAX30102_IIC_Stop();
}void MAX30102_INT_Init(void)
{GPIO_InitTypeDef GPIO_InitStructure;RCC_AHB1PeriphClockCmd(MAX30102_INT_CLK,ENABLE); GPIO_InitStructure.GPIO_Pin = MAX30102_INT_PIN;GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;GPIO_Init(MAX30102_INT_PORT, &GPIO_InitStructure);
}//初始化IIC
void MAX30102_IIC_Init(void)
{ GPIO_InitTypeDef GPIO_InitStructure;RCC_AHB1PeriphClockCmd(MAX30102_IIC_CLK, ENABLE); /* 打开GPIO时钟 */GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_InitStructure.GPIO_Pin = MAX30102_IIC_SCL_PIN;GPIO_Init(MAX30102_IIC_PORT, &GPIO_InitStructure);GPIO_InitStructure.GPIO_Pin = MAX30102_IIC_SDA_PIN;GPIO_Init(MAX30102_IIC_PORT, &GPIO_InitStructure);/* 给一个停止信号, 复位I2C总线上的所有设备到待机模式 */MAX30102_IIC_SDA=1; MAX30102_IIC_SCL=1;MAX30102_IIC_Stop();
}void MAX30102_Init(void)
{MAX30102_INT_Init();MAX30102_IIC_Init();MAX30102_Reset();max30102_Bus_Write(REG_INTR_ENABLE_1,0xc0); // INTR settingmax30102_Bus_Write(REG_INTR_ENABLE_2,0x00);max30102_Bus_Write(REG_FIFO_WR_PTR,0x00); //FIFO_WR_PTR[4:0]max30102_Bus_Write(REG_OVF_COUNTER,0x00); //OVF_COUNTER[4:0]max30102_Bus_Write(REG_FIFO_RD_PTR,0x00); //FIFO_RD_PTR[4:0]max30102_Bus_Write(REG_FIFO_CONFIG,0x0f); //sample avg = 1, fifo rollover=false, fifo almost full = 17max30102_Bus_Write(REG_MODE_CONFIG,0x03); //0x02 for Red only, 0x03 for SpO2 mode 0x07 multimode LEDmax30102_Bus_Write(REG_SPO2_CONFIG,0x27); // SPO2_ADC range = 4096nA, SPO2 sample rate (100 Hz), LED pulseWidth (400uS) max30102_Bus_Write(REG_LED1_PA,0x24); //Choose value for ~ 7mA for LED1max30102_Bus_Write(REG_LED2_PA,0x24); // Choose value for ~ 7mA for LED2max30102_Bus_Write(REG_PILOT_PA,0x7f); // Choose value for ~ 25mA for Pilot LED
}void MAX30102_Reset(void)
{max30102_Bus_Write(REG_MODE_CONFIG,0x40);max30102_Bus_Write(REG_MODE_CONFIG,0x40);
}void maxim_max30102_write_reg(uint8_t uch_addr, uint8_t uch_data)
{
// char ach_i2c_data[2];
// ach_i2c_data[0]=uch_addr;
// ach_i2c_data[1]=uch_data;
//
// MAX30102_IIC_WriteBytes(I2C_WRITE_ADDR, ach_i2c_data, 2);MAX30102_IIC_Write_One_Byte(I2C_WRITE_ADDR,uch_addr,uch_data);
}void maxim_max30102_read_reg(uint8_t uch_addr, uint8_t *puch_data)
{
// char ch_i2c_data;
// ch_i2c_data=uch_addr;
// MAX30102_IIC_WriteBytes(I2C_WRITE_ADDR, &ch_i2c_data, 1);
//
// i2c.read(I2C_READ_ADDR, &ch_i2c_data, 1);
//
// *puch_data=(uint8_t) ch_i2c_data;MAX30102_IIC_Read_One_Byte(I2C_WRITE_ADDR,uch_addr,puch_data);
}void maxim_max30102_read_fifo(uint32_t *pun_red_led, uint32_t *pun_ir_led)
{uint32_t un_temp;unsigned char uch_temp;char ach_i2c_data[6];*pun_red_led=0;*pun_ir_led=0;//read and clear status registermaxim_max30102_read_reg(REG_INTR_STATUS_1, &uch_temp);maxim_max30102_read_reg(REG_INTR_STATUS_2, &uch_temp);MAX30102_IIC_ReadBytes(I2C_WRITE_ADDR,REG_FIFO_DATA,(u8 *)ach_i2c_data,6);un_temp=(unsigned char) ach_i2c_data[0];un_temp<<=16;*pun_red_led+=un_temp;un_temp=(unsigned char) ach_i2c_data[1];un_temp<<=8;*pun_red_led+=un_temp;un_temp=(unsigned char) ach_i2c_data[2];*pun_red_led+=un_temp;un_temp=(unsigned char) ach_i2c_data[3];un_temp<<=16;*pun_ir_led+=un_temp;un_temp=(unsigned char) ach_i2c_data[4];un_temp<<=8;*pun_ir_led+=un_temp;un_temp=(unsigned char) ach_i2c_data[5];*pun_ir_led+=un_temp;*pun_red_led&=0x03FFFF; //Mask MSB [23:18]*pun_ir_led&=0x03FFFF; //Mask MSB [23:18]
}//MAX30102引脚输出模式控制
void MAX30102_IIC_SDA_OUT(void)//SDA输出方向配置
{GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_Pin=MAX30102_IIC_SDA_PIN;GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;GPIO_InitStructure.GPIO_Mode=GPIO_Mode_OUT;//SDA推挽输出GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_Init(MAX30102_IIC_PORT,&GPIO_InitStructure); }void MAX30102_IIC_SDA_IN(void)//SDA输入方向配置
{GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_Pin=MAX30102_IIC_SDA_PIN;GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_Init(MAX30102_IIC_PORT,&GPIO_InitStructure);
}//产生IIC起始信号
void MAX30102_IIC_Start(void)
{MAX30102_IIC_SDA_OUT(); //sda线输出MAX30102_IIC_SDA=1; MAX30102_IIC_SCL=1;delay_us(4);MAX30102_IIC_SDA=0;//START:when CLK is high,DATA change form high to low delay_us(4);MAX30102_IIC_SCL=0;//钳住I2C总线，准备发送或接收数据
}
//产生IIC停止信号
void MAX30102_IIC_Stop(void)
{MAX30102_IIC_SDA_OUT();//sda线输出MAX30102_IIC_SCL=0;MAX30102_IIC_SDA=0;//STOP:when CLK is high DATA change form low to highdelay_us(4);MAX30102_IIC_SCL=1; MAX30102_IIC_SDA=1;//发送I2C总线结束信号delay_us(4);
}
//等待应答信号到来
//返回值：1，接收应答失败
// 0，接收应答成功
u8 MAX30102_IIC_Wait_Ack(void)
{u8 ucErrTime=0;MAX30102_IIC_SDA_IN(); //SDA设置为输入 MAX30102_IIC_SDA=1;delay_us(1); MAX30102_IIC_SCL=1;delay_us(1); while(MAX30102_READ_SDA){ucErrTime++;if(ucErrTime>250){MAX30102_IIC_Stop();return 1;}}MAX30102_IIC_SCL=0;//时钟输出0 return 0;
}
//产生ACK应答
void MAX30102_IIC_Ack(void)
{MAX30102_IIC_SCL=0;MAX30102_IIC_SDA_OUT();MAX30102_IIC_SDA=0;delay_us(2);MAX30102_IIC_SCL=1;delay_us(2);MAX30102_IIC_SCL=0;
}
//不产生ACK应答
void MAX30102_IIC_NAck(void)
{MAX30102_IIC_SCL=0;MAX30102_IIC_SDA_OUT();MAX30102_IIC_SDA=1;delay_us(2);MAX30102_IIC_SCL=1;delay_us(2);MAX30102_IIC_SCL=0;
}
//IIC发送一个字节
//返回从机有无应答
//1，有应答
//0，无应答
void MAX30102_IIC_Send_Byte(u8 txd)
{ u8 t; MAX30102_IIC_SDA_OUT(); MAX30102_IIC_SCL=0;//拉低时钟开始数据传输for(t=0;t<8;t++){ MAX30102_IIC_SDA=(txd&0x80)>>7;txd<<=1; delay_us(2); //对TEA5767这三个延时都是必须的MAX30102_IIC_SCL=1;delay_us(2); MAX30102_IIC_SCL=0; delay_us(2);}
}
//读1个字节，ack=1时，发送ACK，ack=0，发送nACK
u8 MAX30102_IIC_Read_Byte(unsigned char ack)
{unsigned char i,receive=0;MAX30102_IIC_SDA_IN();//SDA设置为输入for(i=0;i<8;i++ ){MAX30102_IIC_SCL=0; delay_us(2);MAX30102_IIC_SCL=1;receive<<=1;if(MAX30102_READ_SDA)receive++; delay_us(1); } if (!ack)MAX30102_IIC_NAck();//发送nACKelseMAX30102_IIC_Ack(); //发送ACK return receive;
}void MAX30102_IIC_WriteBytes(u8 WriteAddr,u8* data,u8 dataLength)
{ u8 i; MAX30102_IIC_Start(); MAX30102_IIC_Send_Byte(WriteAddr); //发送写命令MAX30102_IIC_Wait_Ack();for(i=0;i<dataLength;i++){MAX30102_IIC_Send_Byte(data[i]);MAX30102_IIC_Wait_Ack();} MAX30102_IIC_Stop();//产生一个停止条件 delay_ms(10);
}void MAX30102_IIC_ReadBytes(u8 deviceAddr, u8 writeAddr,u8* data,u8 dataLength)
{ u8 i; MAX30102_IIC_Start(); MAX30102_IIC_Send_Byte(deviceAddr); //发送写命令MAX30102_IIC_Wait_Ack();MAX30102_IIC_Send_Byte(writeAddr);MAX30102_IIC_Wait_Ack();MAX30102_IIC_Send_Byte(deviceAddr|0X01);//进入接收模式 MAX30102_IIC_Wait_Ack();for(i=0;i<dataLength-1;i++){data[i] = MAX30102_IIC_Read_Byte(1);} data[dataLength-1] = MAX30102_IIC_Read_Byte(0); MAX30102_IIC_Stop();//产生一个停止条件 delay_ms(10);
}void MAX30102_IIC_Read_One_Byte(u8 daddr,u8 addr,u8* data)
{ MAX30102_IIC_Start(); MAX30102_IIC_Send_Byte(daddr); //发送写命令MAX30102_IIC_Wait_Ack();MAX30102_IIC_Send_Byte(addr);//发送地址MAX30102_IIC_Wait_Ack(); MAX30102_IIC_Start(); MAX30102_IIC_Send_Byte(daddr|0X01);//进入接收模式 MAX30102_IIC_Wait_Ack(); *data = MAX30102_IIC_Read_Byte(0); MAX30102_IIC_Stop();//产生一个停止条件
}void MAX30102_IIC_Write_One_Byte(u8 daddr,u8 addr,u8 data)
{ MAX30102_IIC_Start(); MAX30102_IIC_Send_Byte(daddr); //发送写命令MAX30102_IIC_Wait_Ack();MAX30102_IIC_Send_Byte(addr);//发送地址MAX30102_IIC_Wait_Ack(); MAX30102_IIC_Send_Byte(data); //发送字节 MAX30102_IIC_Wait_Ack(); MAX30102_IIC_Stop();//产生一个停止条件 delay_ms(10);
}const uint16_t auw_hamm[31]={ 41, 276, 512, 276, 41 }; //Hamm= long16(512* hamming(5)');
//uch_spo2_table is computed as -45.060*ratioAverage* ratioAverage + 30.354 *ratioAverage + 94.845 ;
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 } ;
static int32_t an_dx[ BUFFER_SIZE-MA4_SIZE]; // delta
static int32_t an_x[ BUFFER_SIZE]; //ir
static int32_t an_y[ BUFFER_SIZE]; //redvoid 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 Averagefor(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 signalfor( 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_dxfor(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 detectorfor ( 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 calculationfor ( 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_locsn_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 MAfor(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 locationsn_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]); //redn_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]); // irn_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 valuen_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*20)/n_denom ; //formular is ( n_y_ac *n_x_dc_max) / ( n_x_ac *n_y_dc_max) ; ///*************************n_nume原来是*100************************//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 medianelsen_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 peaksn_width = 1;while (i+n_width < n_size && pn_x[i] == pn_x[i+n_width]) // find flat peaksn_width++;if (pn_x[i] > pn_x[i+n_width] && (*pn_npks) < 15 ){ // find right edge of peakspn_locs[(*pn_npks)++] = i; // for flat peaks, peak location is left edgei += n_width+1;}elsei += n_width;}elsei++;}
}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 -1if ( n_dist > n_min_distance || n_dist < -n_min_distance )pn_locs[(*pn_npks)++] = pn_locs[j];}}// Resort indices longo ascending ordermaxim_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;}
}
头文件
#ifndef __MAX30102_H
#define __MAX30102_H#include "main.h"
#include "stdbool.h"// 位带操作宏定义
#define BITBAND(addr, bitnum) ((0x42000000 + ((addr - 0x40000000) * 32) + (bitnum * 4)))
#define MEM_ADDR(addr) *((volatile unsigned long *)(addr))
#define BIT_ADDR(addr, bitnum) MEM_ADDR(BITBAND(addr, bitnum)) // IO口地址映射
#define GPIOA_ODR_Addr (GPIOA_BASE+0x14) // 0x40020014
#define GPIOB_ODR_Addr (GPIOB_BASE+0x14) // 0x40020414
#define GPIOC_ODR_Addr (GPIOC_BASE+0x14) // 0x40020814
#define GPIOD_ODR_Addr (GPIOD_BASE+0x14) // 0x40020C14
#define GPIOE_ODR_Addr (GPIOE_BASE+0x14) // 0x40021014
#define GPIOF_ODR_Addr (GPIOF_BASE+0x14) // 0x40021414
#define GPIOG_ODR_Addr (GPIOG_BASE+0x14) // 0x40021814
#define GPIOH_ODR_Addr (GPIOH_BASE+0x14) // 0x40021C14
#define GPIOI_ODR_Addr (GPIOI_BASE+0x14) // 0x40022014#define GPIOA_IDR_Addr (GPIOA_BASE+0x10) // 0x40020010
#define GPIOB_IDR_Addr (GPIOB_BASE+0x10) // 0x40020410
#define GPIOC_IDR_Addr (GPIOC_BASE+0x10) // 0x40020810
#define GPIOD_IDR_Addr (GPIOD_BASE+0x10) // 0x40020C10
#define GPIOE_IDR_Addr (GPIOE_BASE+0x10) // 0x40021010
#define GPIOF_IDR_Addr (GPIOF_BASE+0x10) // 0x40021410
#define GPIOG_IDR_Addr (GPIOG_BASE+0x10) // 0x40021810
#define GPIOH_IDR_Addr (GPIOH_BASE+0x10) // 0x40021C10
#define GPIOI_IDR_Addr (GPIOI_BASE+0x10) // 0x40022010//IO口操作,只对单一的IO口!
//确保n的值小于16!
#define PAout(n) BIT_ADDR(GPIOA_ODR_Addr,n) //输出
#define PAin(n) BIT_ADDR(GPIOA_IDR_Addr,n) //输入 #define PBout(n) BIT_ADDR(GPIOB_ODR_Addr,n) //输出
#define PBin(n) BIT_ADDR(GPIOB_IDR_Addr,n) //输入 #define PCout(n) BIT_ADDR(GPIOC_ODR_Addr,n) //输出
#define PCin(n) BIT_ADDR(GPIOC_IDR_Addr,n) //输入 #define PDout(n) BIT_ADDR(GPIOD_ODR_Addr,n) //输出
#define PDin(n) BIT_ADDR(GPIOD_IDR_Addr,n) //输入 #define PEout(n) BIT_ADDR(GPIOE_ODR_Addr,n) //输出
#define PEin(n) BIT_ADDR(GPIOE_IDR_Addr,n) //输入#define PFout(n) BIT_ADDR(GPIOF_ODR_Addr,n) //输出
#define PFin(n) BIT_ADDR(GPIOF_IDR_Addr,n) //输入#define PGout(n) BIT_ADDR(GPIOG_ODR_Addr,n) //输出
#define PGin(n) BIT_ADDR(GPIOG_IDR_Addr,n) //输入//==============================================MAX30102硬件接口==================================================
#define MAX30102_IIC_CLK RCC_AHB1Periph_GPIOB
#define MAX30102_IIC_PORT GPIOB
#define MAX30102_IIC_SCL_PIN GPIO_Pin_6
#define MAX30102_IIC_SDA_PIN GPIO_Pin_7#define MAX30102_IIC_SCL PBout(6)
#define MAX30102_IIC_SDA PBout(7)
#define MAX30102_READ_SDA PBin(7) //输入SDA #define MAX30102_INT_CLK RCC_AHB1Periph_GPIOB
#define MAX30102_INT_PORT GPIOB
#define MAX30102_INT_PIN GPIO_Pin_8
#define MAX30102_INT PBin(8)
//#define MAX30102_INT GPIO_ReadInputDataBit(MAX30102_INT_PORT, MAX30102_INT_PIN)
//=============================================================================================================#define I2C_WR 0 /* 写控制bit */
#define I2C_RD 1 /* 读控制bit */#define I2C_WRITE_ADDR 0xAE
#define I2C_READ_ADDR 0xAF#define true 1
#define false 0
#define FS 100
#define BUFFER_SIZE (FS* 5)
#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))#define max30102_WR_address 0xAE#define I2C_WRITE_ADDR 0xAE
#define I2C_READ_ADDR 0xAF//register addresses
#define REG_INTR_STATUS_1 0x00
#define REG_INTR_STATUS_2 0x01
#define REG_INTR_ENABLE_1 0x02
#define REG_INTR_ENABLE_2 0x03
#define REG_FIFO_WR_PTR 0x04
#define REG_OVF_COUNTER 0x05
#define REG_FIFO_RD_PTR 0x06
#define REG_FIFO_DATA 0x07
#define REG_FIFO_CONFIG 0x08
#define REG_MODE_CONFIG 0x09
#define REG_SPO2_CONFIG 0x0A
#define REG_LED1_PA 0x0C
#define REG_LED2_PA 0x0D
#define REG_PILOT_PA 0x10
#define REG_MULTI_LED_CTRL1 0x11
#define REG_MULTI_LED_CTRL2 0x12
#define REG_TEMP_INTR 0x1F
#define REG_TEMP_FRAC 0x20
#define REG_TEMP_CONFIG 0x21
#define REG_PROX_INT_THRESH 0x30
#define REG_REV_ID 0xFE
#define REG_PART_ID 0xFF//IIC所有操作函数
void MAX30102_IIC_Init(void); //初始化IIC的IO口
void MAX30102_IIC_Start(void); //发送IIC开始信号
void MAX30102_IIC_Stop(void); //发送IIC停止信号
void MAX30102_IIC_Send_Byte(u8 txd); //IIC发送一个字节
u8 MAX30102_IIC_Read_Byte(unsigned char ack);//IIC读取一个字节
u8 MAX30102_IIC_Wait_Ack(void); //IIC等待ACK信号
void MAX30102_IIC_Ack(void); //IIC发送ACK信号
void MAX30102_IIC_NAck(void); //IIC不发送ACK信号void MAX30102_IIC_Write_One_Byte(u8 daddr,u8 addr,u8 data);
void MAX30102_IIC_Read_One_Byte(u8 daddr,u8 addr,u8* data);void MAX30102_IIC_WriteBytes(u8 WriteAddr,u8* data,u8 dataLength);
void MAX30102_IIC_ReadBytes(u8 deviceAddr, u8 writeAddr,u8* data,u8 dataLength);//MAX30102所有操作函数
void MAX30102_Init(void);
void MAX30102_Reset(void);
u8 M30102_Bus_Write(u8 Register_Address, u8 Word_Data);
u8 max30102_Bus_Read(u8 Register_Address);
void max30102_FIFO_ReadWords(u8 Register_Address,u16 Word_Data[][2],u8 count);
void max30102_FIFO_ReadBytes(u8 Register_Address,u8* Data);void maxim_max30102_write_reg(uint8_t uch_addr, uint8_t uch_data);
void maxim_max30102_read_reg(uint8_t uch_addr, uint8_t *puch_data);
void maxim_max30102_read_fifo(uint32_t *pun_red_led, uint32_t *pun_ir_led);//心率血氧算法所有函数
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这两个是Max30102的c文件以及头文件，非常之多，封装的非常好，我也是从别人现成的项目下移植过来的，我们只需要在头文件中根据我们的接线，修改对应的宏，就可以直接使用了，宏在头文件如下所示：
修改完这个宏之后，我们就成功移植好了心率血氧模块进入我们的项目了，这里的移植工作还未完成，我们max30102有两个源文件，我们可以在工程上面看到：
user_heart.c
我们还有一个user_heart.c ,其实是以max30102.c上面为基础，进行一些软件算法的优化， 以得到更加准确的心率血氧值。我们可以看一下函数调用关系：
然后我们可以大概看一下算法思路：
#include "user_heart.h"#define MAX_BRIGHTNESS 255
#define INTERRUPT_REG 0X00uint32_t aun_ir_buffer[500]; //IR LED 红外光数据，用于计算血氧
int32_t n_ir_buffer_length; //数据长度
uint32_t aun_red_buffer[500]; //Red LED 红光数据，用于计算心率曲线以及计算心率
int32_t n_sp02; //SPO2值
int8_t ch_spo2_valid; //用于显示SP02计算是否有效的指示符
int32_t n_heart_rate; //心率值
int8_t ch_hr_valid; //用于显示心率计算是否有效的指示符
uint8_t Temp;
uint32_t un_min, un_max, un_prev_data;
int i;
int32_t n_brightness;
float f_temp;
//u8 temp_num=0;
u8 temp[6];
u8 str[100];
u8 dis_hr=0,dis_spo2=0;
extern uint8_t max_int_flag;void MAX30102_Data_Init(void)
{un_min=0x3FFFF;un_max=0;//显示“心率：”//Gui_DrawFont_GBK16(0,0,BLUE,GRAY0, "Heart:");//Gui_DrawFont_GBK16(0,40,BLUE,GRAY0, "Blood:");n_ir_buffer_length=500; //缓冲区长度为100，可存储以100sps运行的5秒样本//读取前500个样本，并确定信号范围for(i=0;i<n_ir_buffer_length;i++){//while(MAX30102_INT==1); //等待，直到中断引脚断言max30102_FIFO_ReadBytes(REG_FIFO_DATA,temp);aun_red_buffer[i] = (long)((long)((long)temp[0]&0x03)<<16) | (long)temp[1]<<8 | (long)temp[2]; // 将值合并得到实际数字aun_ir_buffer[i] = (long)((long)((long)temp[3] & 0x03)<<16) |(long)temp[4]<<8 | (long)temp[5]; // 将值合并得到实际数字if(un_min>aun_red_buffer[i])un_min=aun_red_buffer[i]; //更新计算最小值if(un_max<aun_red_buffer[i])un_max=aun_red_buffer[i]; //更新计算最大值}un_prev_data=aun_red_buffer[i];//计算前500个样本（前5秒的样本）后的心率和血氧饱和度maxim_heart_rate_and_oxygen_saturation(aun_ir_buffer, n_ir_buffer_length, aun_red_buffer, &n_sp02, &ch_spo2_valid, &n_heart_rate, &ch_hr_valid);
}void Get_MAX30102_Data(u8 *hr, u8 *spo2)
{//舍去前100组样本，并将后400组样本移到顶部，将100~500缓存数据移位到0~400for(i=100;i<500;i++){aun_red_buffer[i-100]=aun_red_buffer[i]; //将100-500缓存数据移位到0-400aun_ir_buffer[i-100]=aun_ir_buffer[i]; //将100-500缓存数据移位到0-400//update the signal min and maxif(un_min>aun_red_buffer[i]) //寻找移位后0-400中的最小值un_min=aun_red_buffer[i];if(un_max<aun_red_buffer[i]) //寻找移位后0-400中的最大值un_max=aun_red_buffer[i];}//在计算心率前取100组样本，取的数据放在400-500缓存数组中for(i=400;i<500;i++){un_prev_data=aun_red_buffer[i-1]; //在计算心率前取100组样本，取的数据放在400-500缓存数组中//while(MAX30102_INT==1);max30102_FIFO_ReadBytes(REG_FIFO_DATA,temp); //读取传感器数据，赋值到temp中aun_red_buffer[i] = (long)((long)((long)temp[0]&0x03)<<16) | (long)temp[1]<<8 | (long)temp[2]; //将值合并得到实际数字，数组400-500为新读取数据aun_ir_buffer[i] = (long)((long)((long)temp[3] & 0x03)<<16) |(long)temp[4]<<8 | (long)temp[5]; //将值合并得到实际数字，数组400-500为新读取数据if(aun_red_buffer[i]>un_prev_data) //用新获取的一个数值与上一个数值对比{f_temp=aun_red_buffer[i]-un_prev_data;f_temp/=(un_max-un_min);f_temp*=MAX_BRIGHTNESS; //公式（心率曲线）=（新数值-旧数值）/（最大值-最小值）*255n_brightness-=(int)f_temp;if(n_brightness<0)n_brightness=0;}else{f_temp=un_prev_data-aun_red_buffer[i];f_temp/=(un_max-un_min);f_temp*=MAX_BRIGHTNESS; //公式（心率曲线）=（旧数值-新数值）/（最大值-最小值）*255n_brightness+=(int)f_temp;if(n_brightness>MAX_BRIGHTNESS)n_brightness=MAX_BRIGHTNESS;}//通过UART将样本和计算结果发送到终端程序if(ch_hr_valid == 1 && n_heart_rate<120)//**/ ch_hr_valid == 1 && ch_spo2_valid ==1 && n_heart_rate<120 && n_sp02<101{dis_hr = n_heart_rate;dis_spo2 = n_sp02;}else{dis_hr = 0;dis_spo2 = 0;}}maxim_heart_rate_and_oxygen_saturation(aun_ir_buffer, n_ir_buffer_length, aun_red_buffer, &n_sp02, &ch_spo2_valid, &n_heart_rate, &ch_hr_valid);*hr = dis_hr;*spo2 = dis_spo2;// char buf[64];
// sprintf(buf, "Heart: %d", dis_hr);
// Gui_DrawFont_GBK16(0, 20, BLUE,GRAY0, buf);
// sprintf(buf, "Blood: %d", dis_spo2);
// Gui_DrawFont_GBK16(0, 50, BLUE,GRAY0, buf);
// memset(buf, 0, sizeof(buf));//LCD_Show_Info(0,40, &lv_font_montserrat_14, lv_color_hex(0xffffff), "Heart: %d BMP", dis_hr);//LCD_Show_Info(0,80, &lv_font_montserrat_14, lv_color_hex(0xffffff), "Blood: %d %", dis_spo2);//LCD_Show_Info(0,40, &lv_font_montserrat_14, lv_color_hex(0xffffff), "Heart: %d BMP", *hr);//LCD_Show_Info(0,80, &lv_font_montserrat_14, lv_color_hex(0xffffff), "Blood: %d %", *spo2);//delay_ms(1000);
}void Get_MAX30102(void)
{char buf[40];un_min=0x3FFFF;un_max=0;//显示“心率：”//Gui_DrawFont_GBK16(0,0,BLUE,GRAY0, "Heart:");//Gui_DrawFont_GBK16(0,40,BLUE,GRAY0, "Blood:");n_ir_buffer_length=500; //缓冲区长度为100，可存储以100sps运行的5秒样本//读取前500个样本，并确定信号范围for(i=0;i<n_ir_buffer_length;i++){//while(MAX30102_INT==1); //等待，直到中断引脚断言max30102_FIFO_ReadBytes(REG_FIFO_DATA,temp);aun_red_buffer[i] = (long)((long)((long)temp[0]&0x03)<<16) | (long)temp[1]<<8 | (long)temp[2]; // 将值合并得到实际数字aun_ir_buffer[i] = (long)((long)((long)temp[3] & 0x03)<<16) |(long)temp[4]<<8 | (long)temp[5]; // 将值合并得到实际数字if(un_min>aun_red_buffer[i])un_min=aun_red_buffer[i]; //更新计算最小值if(un_max<aun_red_buffer[i])un_max=aun_red_buffer[i]; //更新计算最大值}un_prev_data=aun_red_buffer[i];//计算前500个样本（前5秒的样本）后的心率和血氧饱和度maxim_heart_rate_and_oxygen_saturation(aun_ir_buffer, n_ir_buffer_length, aun_red_buffer, &n_sp02, &ch_spo2_valid, &n_heart_rate, &ch_hr_valid); while(1){//舍去前100组样本，并将后400组样本移到顶部，将100~500缓存数据移位到0~400for(i=100;i<500;i++){aun_red_buffer[i-100]=aun_red_buffer[i]; //将100-500缓存数据移位到0-400aun_ir_buffer[i-100]=aun_ir_buffer[i]; //将100-500缓存数据移位到0-400//update the signal min and maxif(un_min>aun_red_buffer[i]) //寻找移位后0-400中的最小值un_min=aun_red_buffer[i];if(un_max<aun_red_buffer[i]) //寻找移位后0-400中的最大值un_max=aun_red_buffer[i];}//在计算心率前取100组样本，取的数据放在400-500缓存数组中for(i=400;i<500;i++){un_prev_data=aun_red_buffer[i-1]; //在计算心率前取100组样本，取的数据放在400-500缓存数组中//while(MAX30102_INT==1);max30102_FIFO_ReadBytes(REG_FIFO_DATA,temp); //读取传感器数据，赋值到temp中aun_red_buffer[i] = (long)((long)((long)temp[0]&0x03)<<16) | (long)temp[1]<<8 | (long)temp[2]; //将值合并得到实际数字，数组400-500为新读取数据aun_ir_buffer[i] = (long)((long)((long)temp[3] & 0x03)<<16) |(long)temp[4]<<8 | (long)temp[5]; //将值合并得到实际数字，数组400-500为新读取数据if(aun_red_buffer[i]>un_prev_data) //用新获取的一个数值与上一个数值对比{f_temp=aun_red_buffer[i]-un_prev_data;f_temp/=(un_max-un_min);f_temp*=MAX_BRIGHTNESS; //公式（心率曲线）=（新数值-旧数值）/（最大值-最小值）*255n_brightness-=(int)f_temp;if(n_brightness<0)n_brightness=0;}else{f_temp=un_prev_data-aun_red_buffer[i];f_temp/=(un_max-un_min);f_temp*=MAX_BRIGHTNESS; //公式（心率曲线）=（旧数值-新数值）/（最大值-最小值）*255n_brightness+=(int)f_temp;if(n_brightness>MAX_BRIGHTNESS)n_brightness=MAX_BRIGHTNESS;}//通过UART将样本和计算结果发送到终端程序if(ch_hr_valid == 1 && n_heart_rate<120)//**/ ch_hr_valid == 1 && ch_spo2_valid ==1 && n_heart_rate<120 && n_sp02<101{dis_hr = n_heart_rate;dis_spo2 = n_sp02;}else{dis_hr = 0;dis_spo2 = 0;}}maxim_heart_rate_and_oxygen_saturation(aun_ir_buffer, n_ir_buffer_length, aun_red_buffer, &n_sp02, &ch_spo2_valid, &n_heart_rate, &ch_hr_valid);// LCD_Show_Info(0,40, &lv_font_montserrat_14, lv_color_hex(0xffffff), "Heart: %d BMP", dis_hr);
// LCD_Show_Info(0,80, &lv_font_montserrat_14, lv_color_hex(0xffffff), "Blood: %d %", dis_spo2);sprintf(buf, "Heart: %d", dis_hr);Gui_DrawFont_GBK16(0, 20, BLUE,GRAY0, buf);sprintf(buf, "Blood: %d", dis_spo2);Gui_DrawFont_GBK16(0, 50, BLUE,GRAY0, buf);memset(buf, 0, sizeof(buf));delay_ms(1000);}
}我们拿 void Get_MAX30102_Data(u8 *hr, u8 *spo2)；来举例。
void Get_MAX30102_Data(u8 *hr, u8 *spo2)
{
//舍去前100组样本，并将后400组样本移到顶部，将100~500缓存数据移位到0~400
for(i=100;i<500;i++)
{
aun_red_buffer[i-100]=aun_red_buffer[i]; //将100-500缓存数据移位到0-400
aun_ir_buffer[i-100]=aun_ir_buffer[i]; //将100-500缓存数据移位到0-400
//update the signal min and max
if(un_min>aun_red_buffer[i]) //寻找移位后0-400中的最小值
un_min=aun_red_buffer[i];
if(un_max<aun_red_buffer[i]) //寻找移位后0-400中的最大值
un_max=aun_red_buffer[i];
}
//在计算心率前取100组样本，取的数据放在400-500缓存数组中
for(i=400;i<500;i++)
{
un_prev_data=aun_red_buffer[i-1]; //在计算心率前取100组样本，取的数据放在400-500缓存数组中
//while(MAX30102_INT==1);
max30102_FIFO_ReadBytes(REG_FIFO_DATA,temp); //读取传感器数据，赋值到temp中
aun_red_buffer[i] = (long)((long)((long)temp[0]&0x03)<<16) | (long)temp[1]<<8 | (long)temp[2]; //将值合并得到实际数字，数组400-500为新读取数据
aun_ir_buffer[i] = (long)((long)((long)temp[3] & 0x03)<<16) |(long)temp[4]<<8 | (long)temp[5]; //将值合并得到实际数字，数组400-500为新读取数据
if(aun_red_buffer[i]>un_prev_data) //用新获取的一个数值与上一个数值对比
{
f_temp=aun_red_buffer[i]-un_prev_data;
f_temp/=(un_max-un_min);
f_temp*=MAX_BRIGHTNESS; //公式（心率曲线）=（新数值-旧数值）/（最大值-最小值）*255
n_brightness-=(int)f_temp;
if(n_brightness<0)
n_brightness=0;
}
else
{
f_temp=un_prev_data-aun_red_buffer[i];
f_temp/=(un_max-un_min);
f_temp*=MAX_BRIGHTNESS; //公式（心率曲线）=（旧数值-新数值）/（最大值-最小值）*255
n_brightness+=(int)f_temp;
if(n_brightness>MAX_BRIGHTNESS)
n_brightness=MAX_BRIGHTNESS;
}
//通过UART将样本和计算结果发送到终端程序
if(ch_hr_valid == 1 && n_heart_rate<120)//**/ ch_hr_valid == 1 && ch_spo2_valid ==1 && n_heart_rate<120 && n_sp02<101
{
dis_hr = n_heart_rate;
dis_spo2 = n_sp02;
}
else
{
dis_hr = 0;
dis_spo2 = 0;
}
}
maxim_heart_rate_and_oxygen_saturation(aun_ir_buffer, n_ir_buffer_length, aun_red_buffer, &n_sp02, &ch_spo2_valid, &n_heart_rate, &ch_hr_valid);*hr = dis_hr;
*spo2 = dis_spo2;
// char buf[64];
// sprintf(buf, "Heart: %d", dis_hr);
// Gui_DrawFont_GBK16(0, 20, BLUE,GRAY0, buf);
// sprintf(buf, "Blood: %d", dis_spo2);
// Gui_DrawFont_GBK16(0, 50, BLUE,GRAY0, buf);
// memset(buf, 0, sizeof(buf));//LCD_Show_Info(0,40, &lv_font_montserrat_14, lv_color_hex(0xffffff), "Heart: %d BMP", dis_hr);
//LCD_Show_Info(0,80, &lv_font_montserrat_14, lv_color_hex(0xffffff), "Blood: %d %", dis_spo2);
//LCD_Show_Info(0,40, &lv_font_montserrat_14, lv_color_hex(0xffffff), "Heart: %d BMP", *hr);
//LCD_Show_Info(0,80, &lv_font_montserrat_14, lv_color_hex(0xffffff), "Blood: %d %", *spo2);
//delay_ms(1000);
}
这段代码中，涉及到的主要算法包括心率和血氧饱和度（SpO2）的计算，具体包括以下几个部分：
1. 心率（HR）和血氧饱和度（SpO2）计算
通过MAX30102模块收集的红光和红外光数据，通过以下步骤来计算心率和血氧饱和度：
数据采集与处理：
aun_red_buffer存储红光LED的信号数据，aun_ir_buffer存储红外光LED的信号数据。
在Get_MAX30102_Data函数中，前100个样本被丢弃，剩下的400个样本移位到缓冲区的前面进行处理。这是一个滑动窗口机制，用于获取最近的传感器数据。
每次读取传感器数据时，都会更新信号的最小值（un_min）和最大值（un_max），这些值用于后续的数据标准化处理。
心率曲线计算：
对采集到的红光数据进行处理，通过计算新数据和上一个数据的差异（f_temp），来得到一个亮度变化值（n_brightness）。
根据这个亮度变化值来推算心率曲线。公式为：
f_temp = (new_data - old_data) / (un_max - un_min) * MAX_BRIGHTNESS;
这个公式通过标准化数据（将信号的变化值映射到0到255的亮度范围）来计算心率曲线的振幅变化。
血氧饱和度计算（SpO2）：
代码在maxim_heart_rate_and_oxygen_saturation函数中使用了基于红光和红外信号的算法来计算血氧饱和度（SpO2）。该算法依赖于红光和红外光的不同吸收特性，通过计算它们之间的比率来推算SpO2值。
2. 公式分析
在每次新的数据采集之后，通过比较当前数据与前一个数据的变化，计算出f_temp（心率曲线的变化量），然后根据公式对信号进行标准化处理，并转换成亮度值（n_brightness）。该亮度值用于反映心率曲线的变化。
这些数据处理的核心是：
最小值和最大值的动态更新，用于标准化处理（通过un_min和un_max）。
心率曲线计算，通过计算每个数据点与前一个数据点的差值，标准化后得到亮度变化值。
有效性判断，ch_hr_valid和ch_spo2_valid标志位用于确认计算结果是否有效。
3. 算法作用
心率计算： 通过处理红光信号的波动来计算心率。心率的计算依赖于血液的脉动变化，而这些变化反映在红光信号的吸收上。
血氧饱和度计算： 通过比较红光和红外光信号的相对变化，计算血氧的饱和度。红光和红外光的吸收程度会随着血氧浓度的变化而变化，算法利用这些变化来计算血氧浓度。
心率计算算法： 基于红光信号的变化量来计算心率。该算法通过亮度变化推算出心率值。
血氧计算算法： 基于红光和红外光的吸收差异计算血氧饱和度（SpO2）。
通过Max30102获取心率血氧值
我们在获取传感器任务里面进行获取，我们先不用关注FreeRTOS，我们先去关注一下如何获取传感器数值。
MAX30102_Data_Init();
Get_MAX30102_Data(&sens_data.Hr_Data, &sens_data.Spo2_Data);
两个都是我们之前就封装好的函数，我们只需要在需要获取心率值的时候调用即可。
相关文章：
LVGL+FreeRTOS实战项目：智能健康助手（Max30102篇）
MAX30102 心率血氧模块简介 功能：用于检测心率和血氧饱和度，集成了红外和红光 LED 以及光电二极管。 接口：支持 I2C 通信，默认 I2C 地址为 0x57。 应用：广泛用于健康监测设备中，如智能手环、手表等。 硬…...
人脸识别【python-基于OpenCV】
1. 导入并显示图片 #导入模块 import cv2 as cv#读取图片 imgcv.imread(img/wx(1).jpg) #路径名为全英文，出现中文 图片加载失败,"D:\picture\wx.jpg" #显示图片 （显示标题，显示图片对象） cv.imshow(read_picture,im…...
redis常用命令和内部编码
文章目录 redis 为什么快redis中的Stringsetsetnxsetex getmsetmget计数操作incr、incrby、decr、decrby、incrbyfloatincrincrbyincrbyfloat 拼接（append）、获取(getrange)、修改字符串(setrange)、获取字符串长度(strlen)操作appendgetrangesetrangest…...
UI操作总结
该类 SolarWebx 继承自 Webx 和 IUixLikeMixin，主要用于扩展 giraffe.EasyUILibrary 的功能，提供了一系列与网页操作、元素定位、截图、图片处理等相关的方法。以下是对该类中每个方法的简要总结： __init__ 方法 作用：初始化 Sola…...
数据结构——实验八·学生管理系统
嗨~~欢迎来到Tubishu的博客🌸如果你也是一名在校大学生，正在寻找各种编程资源，那么你就来对地方啦🌟 Tubishu是一名计算机本科生，会不定期整理和分享学习中的优质资源，希望能为你的编程之路添砖加瓦⭐&…...
力扣hot100--＞滑动窗口、贪心
你好呀，欢迎来到 Dong雨 的技术小栈 🌱 在这里，我们一同探索代码的奥秘，感受技术的魅力 ✨。 👉 我的小世界：Dong雨 📌 分享我的学习旅程 🛠️ 提供贴心的实用工具 💡 记…...
Linux 内核中的高效并发处理：深入理解 hlist_add_head_rcu 与 NAPI 接口
在 Linux 内核的开发中，高效处理并发任务和数据结构的管理是提升系统性能的关键。特别是在网络子系统中，处理大量数据包的任务对性能和并发性提出了极高的要求。本文将深入探讨 Linux 内核中的 hlist_add_head_rcu 函数及其在 NAPI（网络接收处理接口）中的应用，揭示这些机制…...
centos哪个版本建站好?centos最稳定好用的版本
在信息化飞速发展的今天，服务器操作系统作为构建网络架构的基石，其稳定性和易用性成为企业和个人用户关注的重点。CentOS作为一款广受欢迎的开源服务器操作系统，凭借其强大的性能、出色的稳定性和丰富的软件包资源，成为众多用户建…...
软件越跑越慢的原因分析
如果是qt软件，可以用Qt Creator Profiler 作性能监控如果是通过web请求，可以用JMeter监控。 软件运行过程中逐渐变慢的现象，通常是因为系统资源（如 CPU、内存、磁盘 I/O 等）逐渐被消耗或软件中存在性能瓶颈。这个问题…...
LeetCode 力扣热题100 二叉树的直径
class Solution { public:// 定义一个变量 maxd，用于存储当前二叉树的最大直径。int maxd 0; // 主函数，计算二叉树的直径。int diameterOfBinaryTree(TreeNode* root) {// 调用 maxDepth 函数进行递归计算，并更新 maxd。maxDepth(root);// …...
【图文详解】lnmp架构搭建Discuz论坛
安装部署LNMP 系统及软件版本信息 软件名称版本nginx1.24.0mysql5.7.41php5.6.27安装nginx 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 关闭防火墙 systemctl stop firewalld &&a…...
小哆啦解题记：整数转罗马数字
小哆啦解题记：整数转罗马数字 小哆啦开始力扣每日一题的第十四天 https://leetcode.cn/problems/integer-to-roman/submissions/595220508/ 第一章：神秘的任务 一天，哆啦A梦接到了一项任务——将一个整数转换为罗马数字。他心想：…...
【Java数据结构】排序
【Java数据结构】排序 一、排序1.1 排序的概念1.2 排序的稳定性1.3 内部排序和外部排序1.3.1 内部排序1.3.2 外部排序 二、插入排序2.1 直接插入排序2.2 希尔排序 三、选择排序3.1 选择排序3.2 堆排序 四、交换排序4.1 冒泡排序4.2 快速排序Hoare法：挖坑法ÿ…...
我的求职之路合集
我把我秋招和春招的一些笔面试经验在这里发一下，网友们也可以参考一下。 我的求职之路：（1）如何谈自己的缺点 我的求职之路：（2）找工作时看重的点 我的求职之路：（3&…...
数据结构(四) B树/跳表
目录 1. LRU 2. B树 3. 跳表 1. LRU: 1.1 概念: 最近最少使用算法, 就是cache缓存的算法. 因为cache(位于内存和cpu之间的存储设备)是一种容量有限的缓存, 有新的数据进入就需要将原本的数据进行排出. 1.2 LRU cache实现: #include <iostream> #include <list>…...
Arcgis国产化替代：Bigemap Pro正式发布
在数字化时代，数据如同新时代的石油，蕴含着巨大的价值。从商业决策到科研探索，从城市规划到环境监测，海量数据的高效处理、精准分析与直观可视化，已成为各行业突破发展瓶颈、实现转型升级的关键所在。历经十年精心打磨…...
LBS 开发微课堂｜AI向导接口服务：重塑用户的出行体验
为了让广大开发者 更深入地了解 百度地图开放平台的 技术能力 轻松掌握满满的 技术干货 更加简单地接入 位置服务 我们特别推出了 “位置服务（LBS）开发微课堂” 系列技术案例 第六期的主题是 《AI向导接口服务的能力与接入方案》 随着地图应…...
AI导航工具我开源了利用node爬取了几百条数据
序言 别因今天的懒惰，让明天的您后悔。输出文章的本意并不是为了得到赞美，而是为了让自己能够学会总结思考；当然，如果有幸能够给到你一点点灵感或者思考，那么我这篇文章的意义将无限放大。 背景 随着AI的发展市面上…...
openstack单机安装
openstack单机安装 网卡配置安装依赖开启虚拟环境修改配置文件 部署openstack部署openstack客户端访问可视化界面Horizon补充 本篇主要讲述Ubuntu2204单机安装openstackstable/2024.2。其他版本的Linux系统或者openstack版本，请参考openstack官网。 网卡配置 需要配…...
Vue3实现小红书瀑布流布局任意组件动态更新页面方法实践
思路 1.首先定义一个瀑布流容器，它的高度暂定（后面会更新）。把需要布局的组件（这里叫做waterfall-item）放在瀑布流容器里面渲染出来。使用绝对定位（position: absolute），把它移到屏幕…...
深度学习项目--基于LSTM的糖尿病预测探究(pytorch实现)
🍨 本文为🔗365天深度学习训练营 中的学习记录博客🍖 原作者：K同学啊 前言 LSTM模型一直是一个很经典的模型，一般用于序列数据预测，这个可以很好的挖掘数据上下文信息，本文将使用LSTM进行糖尿病…...
Next.js 实战 (十)：中间件的魅力，打造更快更安全的应用
什么是中间件？ 在 Next.js 中，中间件（Middleware）是一种用于处理每个传入请求的功能。它允许你在请求到达页面之前对其进行修改或响应。 通过中间件，你可以实现诸如日志记录、身份验证、重定向、CORS配置、压缩等任务…...
python+playwright自动化测试(四)：元素操作(键盘鼠标事件)、文件上传
目录 鼠标事件 悬停 移动 按键 点击 滚轮操作 拖拽 键盘事件 输入文本内容 type输入内容 fill输入内容 按键操作press 文件上传 下拉选/单选框/复选框 滚动条操作 鼠标事件 悬停 page.get_by_text(设置,exactTrue).nth(1).hover() 移动 page.mouse.move(x33…...
【论文+源码】Diffusion-LM 改进了可控文本生成
这篇论文探讨了如何在不重新训练的情况下控制语言模型（LM）的行为，这是自然语言生成中的一个重大开放问题。尽管近期一些研究在控制简单句子属性（如情感）方面取得了成功，但在复杂的细粒度控制（如…...
双目立体校正和Q矩阵
立体校正 对两个摄像机的图像平面重投影，使二者位于同一平面，而且左右图像的行对准。 Bouguet 该算法需要用到双目标定后外参(R，T) 从上图中可以看出，该算法主要分为两步： 使成像平面共面 这个办法很直观ÿ…...
vscode 自用插件
vscode按住ctrl鼠标左键无法跟踪跳转方法名，装这些插件就可以 vscode-elm-jump:常规的代码跳转定义 Vue CSS Peek:跳转css定义 vue-helper:变量函数只跳转定义 Vetur 代码提示 Baidu Comate 自动帮你写console.log Turbo Console Log: ctrl alt l 选中变量之后&am…...
OpenCV：在图像中添加高斯噪声、胡椒噪声
目录 在图像中添加高斯噪声 高斯噪声的特性 添加高斯噪声的实现 给图像添加胡椒噪声 实现胡椒噪声的步骤 相关阅读 OpenCV：图像处理中的低通滤波-CSDN博客 OpenCV：高通滤波之索贝尔、沙尔和拉普拉斯-CSDN博客 OpenCV：图像滤波、卷积与…...
DuckDB：Golang操作DuckDB实战案例
DuckDB是一个嵌入式SQL数据库引擎。它与众所周知的SQLite非常相似，但它是为olap风格的工作负载设计的。DuckDB支持各种数据类型和SQL特性。凭借其在以内存为中心的环境中处理高速分析的能力，它迅速受到数据科学家和分析师的欢迎。在这篇博文中࿰…...
MySQL入门（数据库、数据表、数据、字段的操作以及查询相关sql语法）
天行健，君子以自强不息；地势坤，君子以厚德载物。 每个人都有惰性，但不断学习是好好生活的根本，共勉！ 文章均为学习整理笔记，分享记录为主，如有错误请指正，共同学习进步。…...
kotlin的协程的基础概念
Kotlin的协程是一种用于简化异步编程的强大工具。 理解协程的基础概念可以帮助开发者有效地利用其能力。 以下是Kotlin协程的一些关键基础概念： 协程（Coroutines） ： 协程是一种用于处理并发任务的编程模型，它可以在单…...