STM32传感器外设集--心率模块（MAX30102）(2)

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新

需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）

如果你需要这些资料，可以戳这里获取

/* 第1步：发起I2C总线启动信号 */
IIC_Start();

/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
IIC_Send_Byte(max30102_WR_address | I2C_WR);	/* 此处是写指令 */

/* 第3步：发送ACK */
if (IIC_Wait_Ack() != 0)
{
	goto cmd_fail;	/* EEPROM器件无应答 */
}

/* 第4步：发送字节地址， */
IIC_Send_Byte((uint8_t)Register_Address);
if (IIC_Wait_Ack() != 0)
{
	goto cmd_fail;	/* EEPROM器件无应答 */
}


/* 第6步：重新启动I2C总线。下面开始读取数据 */
IIC_Start();

/* 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
IIC_Send_Byte(max30102_WR_address | I2C_RD);	/* 此处是读指令 */

/* 第8步：发送ACK */
if (IIC_Wait_Ack() != 0)
{
	goto cmd_fail;	/* EEPROM器件无应答 */
}

/* 第9步：读取数据 */
{
	data = IIC_Read_Byte(0);	/* 读1个字节 */

	IIC_NAck();	/* 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1) */
}
/* 发送I2C总线停止信号 */
IIC_Stop();
return data;	/* 执行成功 返回data值 */

cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 /
/ 发送I2C总线停止信号 */
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总线启动信号 */
IIC_Start();

/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
IIC_Send_Byte(max30102_WR_address | I2C_WR);	/* 此处是写指令 */

/* 第3步：发送ACK */
if (IIC_Wait_Ack() != 0)
{
	goto cmd_fail;	/* EEPROM器件无应答 */
}

/* 第4步：发送字节地址， */
IIC_Send_Byte((uint8_t)Register_Address);
if (IIC_Wait_Ack() != 0)
{
	goto cmd_fail;	/* EEPROM器件无应答 */
}


/* 第6步：重新启动I2C总线。下面开始读取数据 */
IIC_Start();

/* 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
IIC_Send_Byte(max30102_WR_address | I2C_RD);	/* 此处是读指令 */

/* 第8步：发送ACK */
if (IIC_Wait_Ack() != 0)
{
	goto cmd_fail;	/* EEPROM器件无应答 */
}

/* 第9步：读取数据 */
while (no)
{
	data1 = IIC_Read_Byte(0);	
	IIC_Ack();
	data2 = IIC_Read_Byte(0);
	IIC_Ack();
	Word_Data[i][0] = (((u16)data1 << 8) | data2);  //

	
	data1 = IIC_Read_Byte(0);	
	IIC_Ack();
	data2 = IIC_Read_Byte(0);
	if(1==no)
		IIC_NAck();	/* 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1) */
	else
		IIC_Ack();
	Word_Data[i][1] = (((u16)data1 << 8) | data2); 

	no--;	
	i++;
}
/* 发送I2C总线停止信号 */
IIC_Stop();

cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 /
/ 发送I2C总线停止信号 */
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总线启动信号 */
IIC_Start();

/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
IIC_Send_Byte(max30102_WR_address | I2C_WR);	/* 此处是写指令 */

/* 第3步：发送ACK */
if (IIC_Wait_Ack() != 0)
{
	goto cmd_fail;	/* EEPROM器件无应答 */
}

/* 第4步：发送字节地址， */
IIC_Send_Byte((uint8_t)Register_Address);
if (IIC_Wait_Ack() != 0)
{
	goto cmd_fail;	/* EEPROM器件无应答 */
}


/* 第6步：重新启动I2C总线。下面开始读取数据 */
IIC_Start();

/* 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
IIC_Send_Byte(max30102_WR_address | I2C_RD);	/* 此处是读指令 */

/* 第8步：发送ACK */
if (IIC_Wait_Ack() != 0)
{
	goto cmd_fail;	/* EEPROM器件无应答 */
}

/* 第9步：读取数据 */
Data[0] = IIC_Read_Byte(1);	
Data[1] = IIC_Read_Byte(1);	
Data[2] = IIC_Read_Byte(1);	
Data[3] = IIC_Read_Byte(1);
Data[4] = IIC_Read_Byte(1);	
Data[5] = IIC_Read_Byte(0);
/* 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1) */
/* 发送I2C总线停止信号 */
IIC_Stop();

cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 /
/ 发送I2C总线停止信号 */
IIC_Stop();

// u8 i;
// u8 fifo_wr_ptr;
// u8 firo_rd_ptr;
// u8 number_tp_read;
// //Get the FIFO_WR_PTR
// fifo_wr_ptr = max30102_Bus_Read(REG_FIFO_WR_PTR);
// //Get the FIFO_RD_PTR
// firo_rd_ptr = max30102_Bus_Read(REG_FIFO_RD_PTR);
//
// number_tp_read = fifo_wr_ptr - firo_rd_ptr;
//
// //for(i=0;i<number_tp_read;i++){
// if(number_tp_read>0){
// IIC_ReadBytes(max30102_WR_address,REG_FIFO_DATA,Data,6);
// }

//max30102_Bus_Write(REG_FIFO_RD_PTR,fifo_wr_ptr);

}

void max30102_init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);	
GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_14;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(GPIOB, &GPIO_InitStructure);

IIC_Init();

max30102_reset();

// max30102_Bus_Write(REG_MODE_CONFIG, 0x0b); //mode configuration : temp_en[3] MODE[2:0]=010 HR only enabled 011 SP02 enabled
// max30102_Bus_Write(REG_INTR_STATUS_2, 0xF0); //open all of interrupt
// max30102_Bus_Write(REG_INTR_STATUS_1, 0x00); //all interrupt clear
// max30102_Bus_Write(REG_INTR_ENABLE_2, 0x02); //DIE_TEMP_RDY_EN
// max30102_Bus_Write(REG_TEMP_CONFIG, 0x01); //SET TEMP_EN

// max30102_Bus_Write(REG_SPO2_CONFIG, 0x47); //SPO2_SR[4:2]=001 100 per second LED_PW[1:0]=11 16BITS

// max30102_Bus_Write(REG_LED1_PA, 0x47);
// max30102_Bus_Write(REG_LED2_PA, 0x47);

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

// // Interrupt Enable 1 Register. Set PPG_RDY_EN (data available in FIFO)
// max30102_Bus_Write(0x2, 1<<6);

// // FIFO configuration register
// // SMP_AVE: 16 samples averaged per FIFO sample
// // FIFO_ROLLOVER_EN=1
// //max30102_Bus_Write(0x8, 1<<4);
// max30102_Bus_Write(0x8, (0<<5) | 1<<4);

// // Mode Configuration Register
// // SPO2 mode
// max30102_Bus_Write(0x9, 3);

// // SPO2 Configuration Register
// max30102_Bus_Write(0xa,
// (3<<5) // SPO2_ADC_RGE 2 = full scale 8192 nA (LSB size 31.25pA); 3 = 16384nA
// | (1<<2) // sample rate: 0 = 50sps; 1 = 100sps; 2 = 200sps
// | (3<<0) // LED_PW 3 = 411μs, ADC resolution 18 bits
// );

// // LED1 (red) power (0 = 0mA; 255 = 50mA)
// max30102_Bus_Write(0xc, 0xb0);

// // LED (IR) power
// max30102_Bus_Write(0xd, 0xa0);

}

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;
//
// IIC_WriteBytes(I2C_WRITE_ADDR, ach_i2c_data, 2);
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;
// 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;
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 register
maxim_max30102_read_reg(REG_INTR_STATUS_1, &uch_temp);
maxim_max30102_read_reg(REG_INTR_STATUS_2, &uch_temp);

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.h

#ifndef __MYIIC_H
#define __MYIIC_H
#include “sys.h”
//

#define MAX30102_INT PBin(9)

#define I2C_WR 0 /* 写控制bit /
#define I2C_RD 1 / 读控制bit */

#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

void max30102_init(void);
void max30102_reset(void);
u8 max30102_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);
#endif

### myiic.c

#include “myiic.h”
#include “delay.h”

//初始化IIC
void IIC_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
//RCC->APB2ENR|=1<<4;//先使能外设IO PORTC时钟
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE );

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7|GPIO_Pin_8;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //推挽输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);

IIC_SCL=1;
IIC_SDA=1;

}
//产生IIC起始信号
void IIC_Start(void)
{
SDA_OUT(); //sda线输出
IIC_SDA=1;
IIC_SCL=1;
delay_us(4);
IIC_SDA=0;//START:when CLK is high,DATA change form high to low
delay_us(4);
IIC_SCL=0;//钳住I2C总线，准备发送或接收数据
}
//产生IIC停止信号
void IIC_Stop(void)
{
SDA_OUT();//sda线输出
IIC_SCL=0;
IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
delay_us(4);
IIC_SCL=1;
IIC_SDA=1;//发送I2C总线结束信号
delay_us(4);
}
//等待应答信号到来
//返回值：1，接收应答失败
// 0，接收应答成功
u8 IIC_Wait_Ack(void)
{
u8 ucErrTime=0;
SDA_IN(); //SDA设置为输入
IIC_SDA=1;delay_us(1);
IIC_SCL=1;delay_us(1);
while(READ_SDA)
{
ucErrTime++;
if(ucErrTime>250)
{
IIC_Stop();
return 1;
}
}
IIC_SCL=0;//时钟输出0
return 0;
}
//产生ACK应答
void IIC_Ack(void)
{
IIC_SCL=0;
SDA_OUT();
IIC_SDA=0;
delay_us(2);
IIC_SCL=1;
delay_us(2);
IIC_SCL=0;
}
//不产生ACK应答
void IIC_NAck(void)
{
IIC_SCL=0;
SDA_OUT();
IIC_SDA=1;
delay_us(2);
IIC_SCL=1;
delay_us(2);
IIC_SCL=0;
}
//IIC发送一个字节
//返回从机有无应答
//1，有应答
//0，无应答
void IIC_Send_Byte(u8 txd)
{
u8 t;
SDA_OUT();
IIC_SCL=0;//拉低时钟开始数据传输
for(t=0;t<8;t++)
{
IIC_SDA=(txd&0x80)>>7;
txd<<=1;
delay_us(2); //对TEA5767这三个延时都是必须的
IIC_SCL=1;
delay_us(2);
IIC_SCL=0;
delay_us(2);
}
}
//读1个字节，ack=1时，发送ACK，ack=0，发送nACK
u8 IIC_Read_Byte(unsigned char ack)
{
unsigned char i,receive=0;
SDA_IN();//SDA设置为输入
for(i=0;i<8;i++ )
{
IIC_SCL=0;
delay_us(2);
IIC_SCL=1;
receive<<=1;
if(READ_SDA)receive++;
delay_us(1);
}
if (!ack)
IIC_NAck();//发送nACK
else
IIC_Ack(); //发送ACK
return receive;
}

void IIC_WriteBytes(u8 WriteAddr,u8* data,u8 dataLength)
{
u8 i;
IIC_Start();

IIC_Send_Byte(WriteAddr);	    //发送写命令
IIC_Wait_Ack();

for(i=0;i<dataLength;i++)
{
	IIC_Send_Byte(data[i]);
	IIC_Wait_Ack();
}				    	   
IIC_Stop();//产生一个停止条件 
delay_ms(10);	 

}

void IIC_ReadBytes(u8 deviceAddr, u8 writeAddr,u8* data,u8 dataLength)
{
u8 i;
IIC_Start();

IIC_Send_Byte(deviceAddr);	    //发送写命令
IIC_Wait_Ack();
IIC_Send_Byte(writeAddr);
IIC_Wait_Ack();
IIC_Send_Byte(deviceAddr|0X01);//进入接收模式			   
IIC_Wait_Ack();

for(i=0;i<dataLength-1;i++)
{
	data[i] = IIC_Read_Byte(1);
}		
data[dataLength-1] = IIC_Read_Byte(0);	
IIC_Stop();//产生一个停止条件 
delay_ms(10);	 

}

void IIC_Read_One_Byte(u8 daddr,u8 addr,u8* data)
{
IIC_Start();

IIC_Send_Byte(daddr);	   //发送写命令
IIC_Wait_Ack();
IIC_Send_Byte(addr);//发送地址
IIC_Wait_Ack();		 
IIC_Start();  	 	   
IIC_Send_Byte(daddr|0X01);//进入接收模式			   
IIC_Wait_Ack();	 
*data = IIC_Read_Byte(0);		   
IIC_Stop();//产生一个停止条件	    

}

void IIC_Write_One_Byte(u8 daddr,u8 addr,u8 data)
{
IIC_Start();

IIC_Send_Byte(daddr);	    //发送写命令
IIC_Wait_Ack();
IIC_Send_Byte(addr);//发送地址
IIC_Wait_Ack();	   	 										  		   
IIC_Send_Byte(data);     //发送字节							   
IIC_Wait_Ack();  		    	   
IIC_Stop();//产生一个停止条件 
delay_ms(10);	 

}

### myiic.h

#ifndef __MAX30102_H
#define __MAX30102_H
#include “sys.h”
//

//IO方向设置
#define SDA_IN() {GPIOB->CRH&=0XFFFFFFF0;GPIOB->CRH|=4;}
#define SDA_OUT() {GPIOB->CRH&=0XFFFFFFF0;GPIOB->CRH|=7;}

//IO操作函数
#define IIC_SCL PBout(7) //SCL
#define IIC_SDA PBout(8) //SDA
#define READ_SDA PBin(8) //输入SDA

//IIC所有操作函数
void IIC_Init(void); //初始化IIC的IO口
void IIC_Start(void); //发送IIC开始信号
void IIC_Stop(void); //发送IIC停止信号
void IIC_Send_Byte(u8 txd); //IIC发送一个字节
u8 IIC_Read_Byte(unsigned char ack);//IIC读取一个字节
u8 IIC_Wait_Ack(void); //IIC等待ACK信号
void IIC_Ack(void); //IIC发送ACK信号
void IIC_NAck(void); //IIC不发送ACK信号

void IIC_Write_One_Byte(u8 daddr,u8 addr,u8 data);
void IIC_Read_One_Byte(u8 daddr,u8 addr,u8* data);

void IIC_WriteBytes(u8 WriteAddr,u8* data,u8 dataLength);
void IIC_ReadBytes(u8 deviceAddr, u8 writeAddr,u8* data,u8 dataLength);
#endif

### algorithm.c

/** \file algorithm.c ******************************************************
*

• 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 © 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”

const uint16_t auw_hamm[31]={ 41, 276, 512, 276, 41 }; //Hamm= long16(512* hamming(5)');
//uch_spo2_table is computed as -45.060ratioAverage 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]; //red

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){

收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。

如果你需要这些资料，可以戳这里获取

需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

{
*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){

收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。
[外链图片转存中…(img-dOywE0NO-1715910120390)]
[外链图片转存中…(img-mt8HFnpl-1715910120390)]

如果你需要这些资料，可以戳这里获取

需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！