devbox
黑客灵魂
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

STM32单片机+MAX30102心率血氧传感器+OLED屏幕+心率血氧数据发送到串口调试助手+源代码_stm32 心率血氧 oled 云平台

作者：黑客灵魂 | 2024-07-20 08:50:38

赞

踩

stm32 心率血氧 oled 云平台

目录

一、MAX30102心率血氧传感器介绍

二、MAX30102心率血氧传感器接线说明

三、测试说明、MAX30102心率血氧传感器驱动代码

四、串口调试助手把采集的心率血氧数据发送出来

五、串口调试助手软件下载

六、源代码

七、MAX30102心率血氧传感器原理图资料

一、MAX30102心率血氧传感器介绍

        MAX30102是一款集成了心率和血氧测量功能的传感器模块。它采用了专利的心率血氧测量技术，能够通过反射光谱测量来实时监测心率和血氧饱和度。

        MAX30102传感器模块内置了红外光和红光LED，通过这两种光源照射皮肤，然后利用光电二极管接收反射光信号。这个过程中，红外光主要用于血氧测量，而红光则用于心率检测。

        MAX30102传感器模块具有高灵敏度、低功耗和噪声抑制等特点，适用于可穿戴设备、医疗设备、运动健康监测等领域。它可以通过I2C接口与微控制器进行通信，并且提供了丰富的寄存器接口和算法库，方便开发者进行定制化的应用开发。

二、MAX30102心率血氧传感器接线说明

VIN（+）：电源正极接口，外接电源 5V电源正极，接单片机的5v引脚

GND（-）：电源负极接口，外接电源负极或地线GND，接单片机的GND

   SCL       ：时钟线，接单片机的PB7引脚

   SDA      ：数据线，接单片机的PB8引脚

   INT       ：接单片机的PB9引脚

三、测试说明、MAX30102心率血氧传感器驱动代码

编译环境：keil5

测试单片机: STM32F103C8T6

功能：功能1：采集心率、血氧数据在OLED屏幕上显示出来

           功能2：把采集心率、血氧数据发送到串口调试助手上

MAX30102.c文件编写心率血氧传感器驱动代码如下：

  1. #include "MAX30102.h"
  2. #include "MAX30102_IIC.h"
  3. #include "delay.h"
  4.  
  5. u8 max30102_Bus_Write(u8 Register_Address, u8 Word_Data)
  6. {
  7.  
  8. 	/* 采用串行EEPROM随即读取指令序列，连续读取若干字节 */
  9.  
  10. 	/* 第1步：发起I2C总线启动信号 */
  11. 	IIC_Start();
  12.  
  13. 	/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  14. 	IIC_Send_Byte(max30102_WR_address | I2C_WR);	/* 此处是写指令 */
  15.  
  16. 	/* 第3步：发送ACK */
  17. 	if (IIC_Wait_Ack() != 0)
  18. 	{
  19. 		goto cmd_fail;	/* EEPROM器件无应答 */
  20. 	}
  21.  
  22. 	/* 第4步：发送字节地址 */
  23. 	IIC_Send_Byte(Register_Address);
  24. 	if (IIC_Wait_Ack() != 0)
  25. 	{
  26. 		goto cmd_fail;	/* EEPROM器件无应答 */
  27. 	}
  28. 	
  29. 	/* 第5步：开始写入数据 */
  30. 	IIC_Send_Byte(Word_Data);
  31.  
  32. 	/* 第6步：发送ACK */
  33. 	if (IIC_Wait_Ack() != 0)
  34. 	{
  35. 		goto cmd_fail;	/* EEPROM器件无应答 */
  36. 	}
  37.  
  38. 	/* 发送I2C总线停止信号 */
  39. 	IIC_Stop();
  40. 	return 1;	/* 执行成功 */
  41.  
  42. cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
  43. 	/* 发送I2C总线停止信号 */
  44. 	IIC_Stop();
  45. 	return 0;
  46. }
  47.  
  48.  
  49.  
  50. u8 max30102_Bus_Read(u8 Register_Address)
  51. {
  52. 	u8  data;
  53.  
  54.  
  55. 	/* 第1步：发起I2C总线启动信号 */
  56. 	IIC_Start();
  57.  
  58. 	/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  59. 	IIC_Send_Byte(max30102_WR_address | I2C_WR);	/* 此处是写指令 */
  60.  
  61. 	/* 第3步：发送ACK */
  62. 	if (IIC_Wait_Ack() != 0)
  63. 	{
  64. 		goto cmd_fail;	/* EEPROM器件无应答 */
  65. 	}
  66.  
  67. 	/* 第4步：发送字节地址， */
  68. 	IIC_Send_Byte((uint8_t)Register_Address);
  69. 	if (IIC_Wait_Ack() != 0)
  70. 	{
  71. 		goto cmd_fail;	/* EEPROM器件无应答 */
  72. 	}
  73. 	
  74.  
  75. 	/* 第6步：重新启动I2C总线。下面开始读取数据 */
  76. 	IIC_Start();
  77.  
  78. 	/* 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  79. 	IIC_Send_Byte(max30102_WR_address | I2C_RD);	/* 此处是读指令 */
  80.  
  81. 	/* 第8步：发送ACK */
  82. 	if (IIC_Wait_Ack() != 0)
  83. 	{
  84. 		goto cmd_fail;	/* EEPROM器件无应答 */
  85. 	}
  86.  
  87. 	/* 第9步：读取数据 */
  88. 	{
  89. 		data = IIC_Read_Byte(0);	/* 读1个字节 */
  90.  
  91. 		IIC_NAck();	/* 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1) */
  92. 	}
  93. 	/* 发送I2C总线停止信号 */
  94. 	IIC_Stop();
  95. 	return data;	/* 执行成功 返回data值 */
  96.  
  97. cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
  98. 	/* 发送I2C总线停止信号 */
  99. 	IIC_Stop();
  100. 	return 0;
  101. }
  102.  
  103.  
  104. void max30102_FIFO_ReadWords(u8 Register_Address,u16 Word_Data[][2],u8 count)
  105. {
  106. 	u8 i=0;
  107. 	u8 no = count;
  108. 	u8 data1, data2;
  109. 	/* 第1步：发起I2C总线启动信号 */
  110. 	IIC_Start();
  111.  
  112. 	/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  113. 	IIC_Send_Byte(max30102_WR_address | I2C_WR);	/* 此处是写指令 */
  114.  
  115. 	/* 第3步：发送ACK */
  116. 	if (IIC_Wait_Ack() != 0)
  117. 	{
  118. 		goto cmd_fail;	/* EEPROM器件无应答 */
  119. 	}
  120.  
  121. 	/* 第4步：发送字节地址， */
  122. 	IIC_Send_Byte((uint8_t)Register_Address);
  123. 	if (IIC_Wait_Ack() != 0)
  124. 	{
  125. 		goto cmd_fail;	/* EEPROM器件无应答 */
  126. 	}
  127. 	
  128.  
  129. 	/* 第6步：重新启动I2C总线。下面开始读取数据 */
  130. 	IIC_Start();
  131.  
  132. 	/* 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  133. 	IIC_Send_Byte(max30102_WR_address | I2C_RD);	/* 此处是读指令 */
  134.  
  135. 	/* 第8步：发送ACK */
  136. 	if (IIC_Wait_Ack() != 0)
  137. 	{
  138. 		goto cmd_fail;	/* EEPROM器件无应答 */
  139. 	}
  140.  
  141. 	/* 第9步：读取数据 */
  142. 	while (no)
  143. 	{
  144. 		data1 = IIC_Read_Byte(0);	
  145. 		IIC_Ack();
  146. 		data2 = IIC_Read_Byte(0);
  147. 		IIC_Ack();
  148. 		Word_Data[i][0] = (((u16)data1 << 8) | data2);  //
  149.  
  150. 		
  151. 		data1 = IIC_Read_Byte(0);	
  152. 		IIC_Ack();
  153. 		data2 = IIC_Read_Byte(0);
  154. 		if(1==no)
  155. 			IIC_NAck();	/* 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1) */
  156. 		else
  157. 			IIC_Ack();
  158. 		Word_Data[i][1] = (((u16)data1 << 8) | data2); 
  159.  
  160. 		no--;	
  161. 		i++;
  162. 	}
  163. 	/* 发送I2C总线停止信号 */
  164. 	IIC_Stop();
  165.  
  166. cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
  167. 	/* 发送I2C总线停止信号 */
  168. 	IIC_Stop();
  169. }
  170.  
  171. void max30102_FIFO_ReadBytes(u8 Register_Address,u8* Data)
  172. {	
  173. 	max30102_Bus_Read(REG_INTR_STATUS_1);
  174. 	max30102_Bus_Read(REG_INTR_STATUS_2);
  175. 	
  176. 	/* 第1步：发起I2C总线启动信号 */
  177. 	IIC_Start();
  178.  
  179. 	/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  180. 	IIC_Send_Byte(max30102_WR_address | I2C_WR);	/* 此处是写指令 */
  181.  
  182. 	/* 第3步：发送ACK */
  183. 	if (IIC_Wait_Ack() != 0)
  184. 	{
  185. 		goto cmd_fail;	/* EEPROM器件无应答 */
  186. 	}
  187.  
  188. 	/* 第4步：发送字节地址， */
  189. 	IIC_Send_Byte((uint8_t)Register_Address);
  190. 	if (IIC_Wait_Ack() != 0)
  191. 	{
  192. 		goto cmd_fail;	/* EEPROM器件无应答 */
  193. 	}
  194. 	
  195.  
  196. 	/* 第6步：重新启动I2C总线。下面开始读取数据 */
  197. 	IIC_Start();
  198.  
  199. 	/* 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  200. 	IIC_Send_Byte(max30102_WR_address | I2C_RD);	/* 此处是读指令 */
  201.  
  202. 	/* 第8步：发送ACK */
  203. 	if (IIC_Wait_Ack() != 0)
  204. 	{
  205. 		goto cmd_fail;	/* EEPROM器件无应答 */
  206. 	}
  207.  
  208. 	/* 第9步：读取数据 */
  209. 	Data[0] = IIC_Read_Byte(1);	
  210. 	Data[1] = IIC_Read_Byte(1);	
  211. 	Data[2] = IIC_Read_Byte(1);	
  212. 	Data[3] = IIC_Read_Byte(1);
  213. 	Data[4] = IIC_Read_Byte(1);	
  214. 	Data[5] = IIC_Read_Byte(0);
  215. 	/* 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1) */
  216. 	/* 发送I2C总线停止信号 */
  217. 	IIC_Stop();
  218.  
  219. cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
  220. 	/* 发送I2C总线停止信号 */
  221. 	IIC_Stop();
  222.  
  223. //	u8 i;
  224. //	u8 fifo_wr_ptr;
  225. //	u8 firo_rd_ptr;
  226. //	u8 number_tp_read;
  227. //	//Get the FIFO_WR_PTR
  228. //	fifo_wr_ptr = max30102_Bus_Read(REG_FIFO_WR_PTR);
  229. //	//Get the FIFO_RD_PTR
  230. //	firo_rd_ptr = max30102_Bus_Read(REG_FIFO_RD_PTR);
  231. //	
  232. //	number_tp_read = fifo_wr_ptr - firo_rd_ptr;
  233. //	
  234. //	//for(i=0;i<number_tp_read;i++){
  235. //	if(number_tp_read>0){
  236. //		IIC_ReadBytes(max30102_WR_address,REG_FIFO_DATA,Data,6);
  237. //	}
  238. 	
  239. 	//max30102_Bus_Write(REG_FIFO_RD_PTR,fifo_wr_ptr);
  240. }
  241.  
  242. void max30102_init(void)
  243. {
  244. 	GPIO_InitTypeDef GPIO_InitStructure;
  245.  
  246.  	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);	
  247. 	GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_14;
  248. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  249.  	GPIO_Init(GPIOB, &GPIO_InitStructure);
  250. 	
  251. 	IIC_Init();
  252. 	
  253. 	max30102_reset();
  254. 	
  255. //	max30102_Bus_Write(REG_MODE_CONFIG, 0x0b);  //mode configuration : temp_en[3]      MODE[2:0]=010 HR only enabled    011 SP02 enabled
  256. //	max30102_Bus_Write(REG_INTR_STATUS_2, 0xF0); //open all of interrupt
  257. //	max30102_Bus_Write(REG_INTR_STATUS_1, 0x00); //all interrupt clear
  258. //	max30102_Bus_Write(REG_INTR_ENABLE_2, 0x02); //DIE_TEMP_RDY_EN
  259. //	max30102_Bus_Write(REG_TEMP_CONFIG, 0x01); //SET   TEMP_EN
  260.  
  261. //	max30102_Bus_Write(REG_SPO2_CONFIG, 0x47); //SPO2_SR[4:2]=001  100 per second    LED_PW[1:0]=11  16BITS
  262.  
  263. //	max30102_Bus_Write(REG_LED1_PA, 0x47); 
  264. //	max30102_Bus_Write(REG_LED2_PA, 0x47); 
  265. 	
  266. 	
  267. 	
  268. 	max30102_Bus_Write(REG_INTR_ENABLE_1,0xc0);	// INTR setting
  269. 	max30102_Bus_Write(REG_INTR_ENABLE_2,0x00);
  270. 	max30102_Bus_Write(REG_FIFO_WR_PTR,0x00);  	//FIFO_WR_PTR[4:0]
  271. 	max30102_Bus_Write(REG_OVF_COUNTER,0x00);  	//OVF_COUNTER[4:0]
  272. 	max30102_Bus_Write(REG_FIFO_RD_PTR,0x00);  	//FIFO_RD_PTR[4:0]
  273. 	max30102_Bus_Write(REG_FIFO_CONFIG,0x0f);  	//sample avg = 1, fifo rollover=false, fifo almost full = 17
  274. 	max30102_Bus_Write(REG_MODE_CONFIG,0x03);  	//0x02 for Red only, 0x03 for SpO2 mode 0x07 multimode LED
  275. 	max30102_Bus_Write(REG_SPO2_CONFIG,0x27);  	// SPO2_ADC range = 4096nA, SPO2 sample rate (100 Hz), LED pulseWidth (400uS)  
  276. 	max30102_Bus_Write(REG_LED1_PA,0x24);   	//Choose value for ~ 7mA for LED1
  277. 	max30102_Bus_Write(REG_LED2_PA,0x24);   	// Choose value for ~ 7mA for LED2
  278. 	max30102_Bus_Write(REG_PILOT_PA,0x7f);   	// Choose value for ~ 25mA for Pilot LED
  279.  
  280.  
  281. 	
  282. //	// Interrupt Enable 1 Register. Set PPG_RDY_EN (data available in FIFO)
  283. //	max30102_Bus_Write(0x2, 1<<6);
  284.  
  285. //	// FIFO configuration register
  286. //	// SMP_AVE: 16 samples averaged per FIFO sample
  287. //	// FIFO_ROLLOVER_EN=1
  288. //	//max30102_Bus_Write(0x8,  1<<4);
  289. //	max30102_Bus_Write(0x8, (0<<5) | 1<<4);
  290.  
  291. //	// Mode Configuration Register
  292. //	// SPO2 mode
  293. //	max30102_Bus_Write(0x9, 3);
  294.  
  295. //	// SPO2 Configuration Register
  296. //	max30102_Bus_Write(0xa,
  297. //			(3<<5)  // SPO2_ADC_RGE 2 = full scale 8192 nA (LSB size 31.25pA); 3 = 16384nA
  298. //			| (1<<2) // sample rate: 0 = 50sps; 1 = 100sps; 2 = 200sps
  299. //			| (3<<0) // LED_PW 3 = 411μs, ADC resolution 18 bits
  300. //	);
  301.  
  302. //	// LED1 (red) power (0 = 0mA; 255 = 50mA)
  303. //	max30102_Bus_Write(0xc, 0xb0);
  304.  
  305. //	// LED (IR) power
  306. //	max30102_Bus_Write(0xd, 0xa0);
  307. 											
  308. }
  309.  
  310. void max30102_reset(void)
  311. {
  312. 	max30102_Bus_Write(REG_MODE_CONFIG,0x40);
  313. 	max30102_Bus_Write(REG_MODE_CONFIG,0x40);
  314. }
  315.  
  316.  
  317.  
  318.  
  319.  
  320.  
  321. void maxim_max30102_write_reg(uint8_t uch_addr, uint8_t uch_data)
  322. {
  323. //  char ach_i2c_data[2];
  324. //  ach_i2c_data[0]=uch_addr;
  325. //  ach_i2c_data[1]=uch_data;
  326. //	
  327. //  IIC_WriteBytes(I2C_WRITE_ADDR, ach_i2c_data, 2);
  328. 	IIC_Write_One_Byte(I2C_WRITE_ADDR,uch_addr,uch_data);
  329. }
  330.  
  331. void maxim_max30102_read_reg(uint8_t uch_addr, uint8_t *puch_data)
  332. {
  333. //  char ch_i2c_data;
  334. //  ch_i2c_data=uch_addr;
  335. //  IIC_WriteBytes(I2C_WRITE_ADDR, &ch_i2c_data, 1);
  336. //	
  337. //  i2c.read(I2C_READ_ADDR, &ch_i2c_data, 1);
  338. //  
  339. //   *puch_data=(uint8_t) ch_i2c_data;
  340. 	IIC_Read_One_Byte(I2C_WRITE_ADDR,uch_addr,puch_data);
  341. }
  342.  
  343. void maxim_max30102_read_fifo(uint32_t *pun_red_led, uint32_t *pun_ir_led)
  344. {
  345. 	uint32_t un_temp;
  346. 	unsigned char uch_temp;
  347. 	char ach_i2c_data[6];
  348. 	*pun_red_led=0;
  349. 	*pun_ir_led=0;
  350.  
  351.   
  352.   //read and clear status register
  353.   maxim_max30102_read_reg(REG_INTR_STATUS_1, &uch_temp);
  354.   maxim_max30102_read_reg(REG_INTR_STATUS_2, &uch_temp);
  355.   
  356.   IIC_ReadBytes(I2C_WRITE_ADDR,REG_FIFO_DATA,(u8 *)ach_i2c_data,6);
  357.   
  358.   un_temp=(unsigned char) ach_i2c_data[0];
  359.   un_temp<<=16;
  360.   *pun_red_led+=un_temp;
  361.   un_temp=(unsigned char) ach_i2c_data[1];
  362.   un_temp<<=8;
  363.   *pun_red_led+=un_temp;
  364.   un_temp=(unsigned char) ach_i2c_data[2];
  365.   *pun_red_led+=un_temp;
  366.   
  367.   un_temp=(unsigned char) ach_i2c_data[3];
  368.   un_temp<<=16;
  369.   *pun_ir_led+=un_temp;
  370.   un_temp=(unsigned char) ach_i2c_data[4];
  371.   un_temp<<=8;
  372.   *pun_ir_led+=un_temp;
  373.   un_temp=(unsigned char) ach_i2c_data[5];
  374.   *pun_ir_led+=un_temp;
  375.   *pun_red_led&=0x03FFFF;  //Mask MSB [23:18]
  376.   *pun_ir_led&=0x03FFFF;  //Mask MSB [23:18]
  377. }

 MAX30102_IIC.c文件编写心率血氧传感器IIC代码如下：

  1. #include "MAX30102_IIC.h"
  2. #include "delay.h"
  3.  
  4. //初始化IIC
  5. void IIC_Init(void)
  6. {					     
  7. 	GPIO_InitTypeDef GPIO_InitStructure;
  8. 	//RCC->APB2ENR|=1<<4;//先使能外设IO PORTC时钟 
  9. 	RCC_APB2PeriphClockCmd(	RCC_APB2Periph_GPIOB, ENABLE );	
  10. 	   
  11. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7|GPIO_Pin_8;
  12. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //推挽输出
  13. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  14. 	GPIO_Init(GPIOB, &GPIO_InitStructure);
  15.  
  16. 	IIC_SCL=1;
  17. 	IIC_SDA=1;
  18.  
  19. }
  20. //产生IIC起始信号
  21. void IIC_Start(void)
  22. {
  23. 	SDA_OUT();     //sda线输出
  24. 	IIC_SDA=1;	  	  
  25. 	IIC_SCL=1;
  26. 	Delay_us(4);
  27.  	IIC_SDA=0;//START:when CLK is high,DATA change form high to low 
  28. 	Delay_us(4);
  29. 	IIC_SCL=0;//钳住I2C总线，准备发送或接收数据 
  30. }	  
  31. //产生IIC停止信号
  32. void IIC_Stop(void)
  33. {
  34. 	SDA_OUT();//sda线输出
  35. 	IIC_SCL=0;
  36. 	IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
  37.  	Delay_us(4);
  38. 	IIC_SCL=1; 
  39. 	IIC_SDA=1;//发送I2C总线结束信号
  40. 	Delay_us(4);							   	
  41. }
  42. //等待应答信号到来
  43. //返回值：1，接收应答失败
  44. //        0，接收应答成功
  45. u8 IIC_Wait_Ack(void)
  46. {
  47. 	u8 ucErrTime=0;
  48. 	SDA_IN();      //SDA设置为输入  
  49. 	IIC_SDA=1;Delay_us(1);	   
  50. 	IIC_SCL=1;Delay_us(1);	 
  51. 	while(READ_SDA)
  52. 	{
  53. 		ucErrTime++;
  54. 		if(ucErrTime>250)
  55. 		{
  56. 			IIC_Stop();
  57. 			return 1;
  58. 		}
  59. 	}
  60. 	IIC_SCL=0;//时钟输出0 	   
  61. 	return 0;  
  62. } 
  63. //产生ACK应答
  64. void IIC_Ack(void)
  65. {
  66. 	IIC_SCL=0;
  67. 	SDA_OUT();
  68. 	IIC_SDA=0;
  69. 	Delay_us(2);
  70. 	IIC_SCL=1;
  71. 	Delay_us(2);
  72. 	IIC_SCL=0;
  73. }
  74. //不产生ACK应答		    
  75. void IIC_NAck(void)
  76. {
  77. 	IIC_SCL=0;
  78. 	SDA_OUT();
  79. 	IIC_SDA=1;
  80. 	Delay_us(2);
  81. 	IIC_SCL=1;
  82. 	Delay_us(2);
  83. 	IIC_SCL=0;
  84. }					 				     
  85. //IIC发送一个字节
  86. //返回从机有无应答
  87. //1，有应答
  88. //0，无应答			  
  89. void IIC_Send_Byte(u8 txd)
  90. {                        
  91.     u8 t;   
  92. 	SDA_OUT(); 	    
  93.     IIC_SCL=0;//拉低时钟开始数据传输
  94.     for(t=0;t<8;t++)
  95.     {              
  96.         IIC_SDA=(txd&0x80)>>7;
  97.         txd<<=1; 	  
  98. 		Delay_us(2);   //对TEA5767这三个延时都是必须的
  99. 		IIC_SCL=1;
  100. 		Delay_us(2); 
  101. 		IIC_SCL=0;	
  102. 		Delay_us(2);
  103.     }	 
  104. } 	    
  105. //读1个字节，ack=1时，发送ACK，ack=0，发送nACK   
  106. u8 IIC_Read_Byte(unsigned char ack)
  107. {
  108. 	unsigned char i,receive=0;
  109. 	SDA_IN();//SDA设置为输入
  110.     for(i=0;i<8;i++ )
  111. 	{
  112.         IIC_SCL=0; 
  113.         Delay_us(2);
  114. 		IIC_SCL=1;
  115.         receive<<=1;
  116.         if(READ_SDA)receive++;   
  117. 		Delay_us(1); 
  118.     }					 
  119.     if (!ack)
  120.         IIC_NAck();//发送nACK
  121.     else
  122.         IIC_Ack(); //发送ACK   
  123.     return receive;
  124. }
  125.  
  126.  
  127. void IIC_WriteBytes(u8 WriteAddr,u8* data,u8 dataLength)
  128. {		
  129. 	u8 i;	
  130.     IIC_Start();  
  131.  
  132. 	IIC_Send_Byte(WriteAddr);	    //发送写命令
  133. 	IIC_Wait_Ack();
  134. 	
  135. 	for(i=0;i<dataLength;i++)
  136. 	{
  137. 		IIC_Send_Byte(data[i]);
  138. 		IIC_Wait_Ack();
  139. 	}				    	   
  140.     IIC_Stop();//产生一个停止条件 
  141. 	Delay_ms(10);	 
  142. }
  143.  
  144. void IIC_ReadBytes(u8 deviceAddr, u8 writeAddr,u8* data,u8 dataLength)
  145. {		
  146. 	u8 i;	
  147.     IIC_Start();  
  148.  
  149. 	IIC_Send_Byte(deviceAddr);	    //发送写命令
  150. 	IIC_Wait_Ack();
  151. 	IIC_Send_Byte(writeAddr);
  152. 	IIC_Wait_Ack();
  153. 	IIC_Send_Byte(deviceAddr|0X01);//进入接收模式			   
  154. 	IIC_Wait_Ack();
  155. 	
  156. 	for(i=0;i<dataLength-1;i++)
  157. 	{
  158. 		data[i] = IIC_Read_Byte(1);
  159. 	}		
  160. 	data[dataLength-1] = IIC_Read_Byte(0);	
  161.     IIC_Stop();//产生一个停止条件 
  162. 	Delay_ms(10);	 
  163. }
  164.  
  165. void IIC_Read_One_Byte(u8 daddr,u8 addr,u8* data)
  166. {				  	  	    																 
  167.     IIC_Start();  
  168. 	
  169. 	IIC_Send_Byte(daddr);	   //发送写命令
  170. 	IIC_Wait_Ack();
  171. 	IIC_Send_Byte(addr);//发送地址
  172. 	IIC_Wait_Ack();		 
  173. 	IIC_Start();  	 	   
  174. 	IIC_Send_Byte(daddr|0X01);//进入接收模式			   
  175. 	IIC_Wait_Ack();	 
  176.     *data = IIC_Read_Byte(0);		   
  177.     IIC_Stop();//产生一个停止条件	    
  178. }
  179.  
  180. void IIC_Write_One_Byte(u8 daddr,u8 addr,u8 data)
  181. {				   	  	    																 
  182.     IIC_Start();  
  183. 	
  184. 	IIC_Send_Byte(daddr);	    //发送写命令
  185. 	IIC_Wait_Ack();
  186. 	IIC_Send_Byte(addr);//发送地址
  187. 	IIC_Wait_Ack();	   	 										  		   
  188. 	IIC_Send_Byte(data);     //发送字节							   
  189. 	IIC_Wait_Ack();  		    	   
  190.     IIC_Stop();//产生一个停止条件 
  191. 	Delay_ms(10);	 
  192. }
  193.  
  194.  
  195.  
  196.  
  197.  
  198.  
  199.  
  200.  
  201.  
  202.  
  203.  
  204.  
  205.  
  206.  
  207.  
  208.  
  209.  
  210.  
  211.  
  212.  
  213.  
  214.  
  215.  
  216.  
  217.  
  218.  
  219.

  Algorithm.c文件编写心率血氧传感器算法代码如下：

  1. #include "algorithm.h"
  2.  
  3. const uint16_t auw_hamm[31]={ 41,    276,    512,    276,     41 }; //Hamm=  long16(512* hamming(5)');
  4. //uch_spo2_table is computed as  -45.060*ratioAverage* ratioAverage + 30.354 *ratioAverage + 94.845 ;
  5. 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, 
  6.                             99, 99, 99, 99, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 
  7.                             100, 100, 100, 100, 99, 99, 99, 99, 99, 99, 99, 99, 98, 98, 98, 98, 98, 98, 97, 97, 
  8.                             97, 97, 96, 96, 96, 96, 95, 95, 95, 94, 94, 94, 93, 93, 93, 92, 92, 92, 91, 91, 
  9.                             90, 90, 89, 89, 89, 88, 88, 87, 87, 86, 86, 85, 85, 84, 84, 83, 82, 82, 81, 81, 
  10.                             80, 80, 79, 78, 78, 77, 76, 76, 75, 74, 74, 73, 72, 72, 71, 70, 69, 69, 68, 67, 
  11.                             66, 66, 65, 64, 63, 62, 62, 61, 60, 59, 58, 57, 56, 56, 55, 54, 53, 52, 51, 50, 
  12.                             49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 31, 30, 29, 
  13.                             28, 27, 26, 25, 23, 22, 21, 20, 19, 17, 16, 15, 14, 12, 11, 10, 9, 7, 6, 5, 
  14.                             3, 2, 1 } ;
  15. static  int32_t an_dx[ BUFFER_SIZE-MA4_SIZE]; // delta
  16. static  int32_t an_x[ BUFFER_SIZE]; //ir
  17. static  int32_t an_y[ BUFFER_SIZE]; //red
  18.  
  19. 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, 
  20.                               int32_t *pn_heart_rate, int8_t  *pch_hr_valid)
  21. /**
  22. * \brief        Calculate the heart rate and SpO2 level
  23. * \par          Details
  24. *               By detecting  peaks of PPG cycle and corresponding AC/DC of red/infra-red signal, the ratio for the SPO2 is computed.
  25. *               Since this algorithm is aiming for Arm M0/M3. formaula for SPO2 did not achieve the accuracy due to register overflow.
  26. *               Thus, accurate SPO2 is precalculated and save longo uch_spo2_table[] per each ratio.
  27. *
  28. * \param[in]    *pun_ir_buffer           - IR sensor data buffer
  29. * \param[in]    n_ir_buffer_length      - IR sensor data buffer length
  30. * \param[in]    *pun_red_buffer          - Red sensor data buffer
  31. * \param[out]    *pn_spo2                - Calculated SpO2 value
  32. * \param[out]    *pch_spo2_valid         - 1 if the calculated SpO2 value is valid
  33. * \param[out]    *pn_heart_rate          - Calculated heart rate value
  34. * \param[out]    *pch_hr_valid           - 1 if the calculated heart rate value is valid
  35. *
  36. * \retval       None
  37. */
  38. {
  39.     uint32_t un_ir_mean ,un_only_once ;
  40.     int32_t k ,n_i_ratio_count;
  41.     int32_t i, s, m, n_exact_ir_valley_locs_count ,n_middle_idx;
  42.     int32_t n_th1, n_npks,n_c_min;      
  43.     int32_t an_ir_valley_locs[15] ;
  44.     int32_t an_exact_ir_valley_locs[15] ;
  45.     int32_t an_dx_peak_locs[15] ;
  46.     int32_t n_peak_interval_sum;
  47.     
  48.     int32_t n_y_ac, n_x_ac;
  49.     int32_t n_spo2_calc; 
  50.     int32_t n_y_dc_max, n_x_dc_max; 
  51.     int32_t n_y_dc_max_idx, n_x_dc_max_idx; 
  52.     int32_t an_ratio[5],n_ratio_average; 
  53.     int32_t n_nume,  n_denom ;
  54.     // remove DC of ir signal    
  55.     un_ir_mean =0; 
  56.     for (k=0 ; k<n_ir_buffer_length ; k++ ) un_ir_mean += pun_ir_buffer[k] ;
  57.     un_ir_mean =un_ir_mean/n_ir_buffer_length ;
  58.     for (k=0 ; k<n_ir_buffer_length ; k++ )  an_x[k] =  pun_ir_buffer[k] - un_ir_mean ; 
  59.     
  60.     // 4 pt Moving Average
  61.     for(k=0; k< BUFFER_SIZE-MA4_SIZE; k++){
  62.         n_denom= ( an_x[k]+an_x[k+1]+ an_x[k+2]+ an_x[k+3]);
  63.         an_x[k]=  n_denom/(int32_t)4; 
  64.     }
  65.  
  66.     // get difference of smoothed IR signal
  67.     
  68.     for( k=0; k<BUFFER_SIZE-MA4_SIZE-1;  k++)
  69.         an_dx[k]= (an_x[k+1]- an_x[k]);
  70.  
  71.     // 2-pt Moving Average to an_dx
  72.     for(k=0; k< BUFFER_SIZE-MA4_SIZE-2; k++){
  73.         an_dx[k] =  ( an_dx[k]+an_dx[k+1])/2 ;
  74.     }
  75.     
  76.     // hamming window
  77.     // flip wave form so that we can detect valley with peak detector
  78.     for ( i=0 ; i<BUFFER_SIZE-HAMMING_SIZE-MA4_SIZE-2 ;i++){
  79.         s= 0;
  80.         for( k=i; k<i+ HAMMING_SIZE ;k++){
  81.             s -= an_dx[k] *auw_hamm[k-i] ; 
  82.                      }
  83.         an_dx[i]= s/ (int32_t)1146; // divide by sum of auw_hamm 
  84.     }
  85.  
  86.  
  87.     n_th1=0; // threshold calculation
  88.     for ( k=0 ; k<BUFFER_SIZE-HAMMING_SIZE ;k++){
  89.         n_th1 += ((an_dx[k]>0)? an_dx[k] : ((int32_t)0-an_dx[k])) ;
  90.     }
  91.     n_th1= n_th1/ ( BUFFER_SIZE-HAMMING_SIZE);
  92.     // peak location is acutally index for sharpest location of raw signal since we flipped the signal         
  93.     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 
  94.  
  95.     n_peak_interval_sum =0;
  96.     if (n_npks>=2){
  97.         for (k=1; k<n_npks; k++)
  98.             n_peak_interval_sum += (an_dx_peak_locs[k]-an_dx_peak_locs[k -1]);
  99.         n_peak_interval_sum=n_peak_interval_sum/(n_npks-1);
  100.         *pn_heart_rate=(int32_t)(6000/n_peak_interval_sum);// beats per minutes
  101.         *pch_hr_valid  = 1;
  102.     }
  103.     else  {
  104.         *pn_heart_rate = -999;
  105.         *pch_hr_valid  = 0;
  106.     }
  107.             
  108.     for ( k=0 ; k<n_npks ;k++)
  109.         an_ir_valley_locs[k]=an_dx_peak_locs[k]+HAMMING_SIZE/2; 
  110.  
  111.  
  112.     // raw value : RED(=y) and IR(=X)
  113.     // we need to assess DC and AC value of ir and red PPG. 
  114.     for (k=0 ; k<n_ir_buffer_length ; k++ )  {
  115.         an_x[k] =  pun_ir_buffer[k] ; 
  116.         an_y[k] =  pun_red_buffer[k] ; 
  117.     }
  118.  
  119.     // find precise min near an_ir_valley_locs
  120.     n_exact_ir_valley_locs_count =0; 
  121.     for(k=0 ; k<n_npks ;k++){
  122.         un_only_once =1;
  123.         m=an_ir_valley_locs[k];
  124.         n_c_min= 16777216;//2^24;
  125.         if (m+5 <  BUFFER_SIZE-HAMMING_SIZE  && m-5 >0){
  126.             for(i= m-5;i<m+5; i++)
  127.                 if (an_x[i]<n_c_min){
  128.                     if (un_only_once >0){
  129.                        un_only_once =0;
  130.                    } 
  131.                    n_c_min= an_x[i] ;
  132.                    an_exact_ir_valley_locs[k]=i;
  133.                 }
  134.             if (un_only_once ==0)
  135.                 n_exact_ir_valley_locs_count ++ ;
  136.         }
  137.     }
  138.     if (n_exact_ir_valley_locs_count <2 ){
  139.        *pn_spo2 =  -999 ; // do not use SPO2 since signal ratio is out of range
  140.        *pch_spo2_valid  = 0; 
  141.        return;
  142.     }
  143.     // 4 pt MA
  144.     for(k=0; k< BUFFER_SIZE-MA4_SIZE; k++){
  145.         an_x[k]=( an_x[k]+an_x[k+1]+ an_x[k+2]+ an_x[k+3])/(int32_t)4;
  146.         an_y[k]=( an_y[k]+an_y[k+1]+ an_y[k+2]+ an_y[k+3])/(int32_t)4;
  147.     }
  148.  
  149.     //using an_exact_ir_valley_locs , find ir-red DC andir-red AC for SPO2 calibration ratio
  150.     //finding AC/DC maximum of raw ir * red between two valley locations
  151.     n_ratio_average =0; 
  152.     n_i_ratio_count =0; 
  153.     
  154.     for(k=0; k< 5; k++) an_ratio[k]=0;
  155.     for (k=0; k< n_exact_ir_valley_locs_count; k++){
  156.         if (an_exact_ir_valley_locs[k] > BUFFER_SIZE ){             
  157.             *pn_spo2 =  -999 ; // do not use SPO2 since valley loc is out of range
  158.             *pch_spo2_valid  = 0; 
  159.             return;
  160.         }
  161.     }
  162.     // find max between two valley locations 
  163.     // and use ratio betwen AC compoent of Ir & Red and DC compoent of Ir & Red for SPO2 
  164.  
  165.     for (k=0; k< n_exact_ir_valley_locs_count-1; k++){
  166.         n_y_dc_max= -16777216 ; 
  167.         n_x_dc_max= - 16777216; 
  168.         if (an_exact_ir_valley_locs[k+1]-an_exact_ir_valley_locs[k] >10){
  169.             for (i=an_exact_ir_valley_locs[k]; i< an_exact_ir_valley_locs[k+1]; i++){
  170.                 if (an_x[i]> n_x_dc_max) {n_x_dc_max =an_x[i];n_x_dc_max_idx =i; }
  171.                 if (an_y[i]> n_y_dc_max) {n_y_dc_max =an_y[i];n_y_dc_max_idx=i;}
  172.             }
  173.             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
  174.             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])  ; 
  175.         
  176.         
  177.             n_y_ac=  an_y[n_y_dc_max_idx] - n_y_ac;    // subracting linear DC compoenents from raw 
  178.             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
  179.             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]); 
  180.             n_x_ac=  an_x[n_y_dc_max_idx] - n_x_ac;      // subracting linear DC compoenents from raw 
  181.             n_nume=( n_y_ac *n_x_dc_max)>>7 ; //prepare X100 to preserve floating value
  182.             n_denom= ( n_x_ac *n_y_dc_max)>>7;
  183.             if (n_denom>0  && n_i_ratio_count <5 &&  n_nume != 0)
  184.             {   
  185.                 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************************//
  186.                 n_i_ratio_count++;
  187.             }
  188.         }
  189.     }
  190.  
  191.     maxim_sort_ascend(an_ratio, n_i_ratio_count);
  192.     n_middle_idx= n_i_ratio_count/2;
  193.  
  194.     if (n_middle_idx >1)
  195.         n_ratio_average =( an_ratio[n_middle_idx-1] +an_ratio[n_middle_idx])/2; // use median
  196.     else
  197.         n_ratio_average = an_ratio[n_middle_idx ];
  198.  
  199.     if( n_ratio_average>2 && n_ratio_average <184){
  200.         n_spo2_calc= uch_spo2_table[n_ratio_average] ;
  201.         *pn_spo2 = n_spo2_calc ;
  202.         *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
  203.     }
  204.     else{
  205.         *pn_spo2 =  -999 ; // do not use SPO2 since signal ratio is out of range
  206.         *pch_spo2_valid  = 0; 
  207.     }
  208. }
  209.  
  210.  
  211. 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)
  212. /**
  213. * \brief        Find peaks
  214. * \par          Details
  215. *               Find at most MAX_NUM peaks above MIN_HEIGHT separated by at least MIN_DISTANCE
  216. *
  217. * \retval       None
  218. */
  219. {
  220.     maxim_peaks_above_min_height( pn_locs, pn_npks, pn_x, n_size, n_min_height );
  221.     maxim_remove_close_peaks( pn_locs, pn_npks, pn_x, n_min_distance );
  222.     *pn_npks = min( *pn_npks, n_max_num );
  223. }
  224.  
  225. 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)
  226. /**
  227. * \brief        Find peaks above n_min_height
  228. * \par          Details
  229. *               Find all peaks above MIN_HEIGHT
  230. *
  231. * \retval       None
  232. */
  233. {
  234.     int32_t i = 1, n_width;
  235.     *pn_npks = 0;
  236.     
  237.     while (i < n_size-1){
  238.         if (pn_x[i] > n_min_height && pn_x[i] > pn_x[i-1]){            // find left edge of potential peaks
  239.             n_width = 1;
  240.             while (i+n_width < n_size && pn_x[i] == pn_x[i+n_width])    // find flat peaks
  241.                 n_width++;
  242.             if (pn_x[i] > pn_x[i+n_width] && (*pn_npks) < 15 ){                            // find right edge of peaks
  243.                 pn_locs[(*pn_npks)++] = i;        
  244.                 // for flat peaks, peak location is left edge
  245.                 i += n_width+1;
  246.             }
  247.             else
  248.                 i += n_width;
  249.         }
  250.         else
  251.             i++;
  252.     }
  253. }
  254.  
  255.  
  256. void maxim_remove_close_peaks(int32_t *pn_locs, int32_t *pn_npks, int32_t *pn_x, int32_t n_min_distance)
  257. /**
  258. * \brief        Remove peaks
  259. * \par          Details
  260. *               Remove peaks separated by less than MIN_DISTANCE
  261. *
  262. * \retval       None
  263. */
  264. {
  265.     
  266.     int32_t i, j, n_old_npks, n_dist;
  267.     
  268.     /* Order peaks from large to small */
  269.     maxim_sort_indices_descend( pn_x, pn_locs, *pn_npks );
  270.  
  271.     for ( i = -1; i < *pn_npks; i++ ){
  272.         n_old_npks = *pn_npks;
  273.         *pn_npks = i+1;
  274.         for ( j = i+1; j < n_old_npks; j++ ){
  275.             n_dist =  pn_locs[j] - ( i == -1 ? -1 : pn_locs[i] ); // lag-zero peak of autocorr is at index -1
  276.             if ( n_dist > n_min_distance || n_dist < -n_min_distance )
  277.                 pn_locs[(*pn_npks)++] = pn_locs[j];
  278.         }
  279.     }
  280.  
  281.     // Resort indices longo ascending order
  282.     maxim_sort_ascend( pn_locs, *pn_npks );
  283. }
  284.  
  285. void maxim_sort_ascend(int32_t *pn_x,int32_t n_size) 
  286. /**
  287. * \brief        Sort array
  288. * \par          Details
  289. *               Sort array in ascending order (insertion sort algorithm)
  290. *
  291. * \retval       None
  292. */
  293. {
  294.     int32_t i, j, n_temp;
  295.     for (i = 1; i < n_size; i++) {
  296.         n_temp = pn_x[i];
  297.         for (j = i; j > 0 && n_temp < pn_x[j-1]; j--)
  298.             pn_x[j] = pn_x[j-1];
  299.         pn_x[j] = n_temp;
  300.     }
  301. }
  302.  
  303. void maxim_sort_indices_descend(int32_t *pn_x, int32_t *pn_indx, int32_t n_size)
  304. /**
  305. * \brief        Sort indices
  306. * \par          Details
  307. *               Sort indices according to descending order (insertion sort algorithm)
  308. *
  309. * \retval       None
  310. */ 
  311. {
  312.     int32_t i, j, n_temp;
  313.     for (i = 1; i < n_size; i++) {
  314.         n_temp = pn_indx[i];
  315.         for (j = i; j > 0 && pn_x[n_temp] > pn_x[pn_indx[j-1]]; j--)
  316.             pn_indx[j] = pn_indx[j-1];
  317.         pn_indx[j] = n_temp;
  318.     }
  319. }
  320.

四、串口调试助手把采集的心率血氧数据发送出来

  1. printf("心率= %d BPM 血氧= %d ",dis_hr,dis_spo2);
  2. Serial_SendString("%\r\n");

五、串口调试助手软件下载

串口调试助手-keil5调试工具_dht11温度传感器串口资源-CSDN文库

六、源代码

《STM32单片机+MAX30102心率血氧传感器+OLED屏幕+心率血氧数据发送到串口调试助手》源代码资源-CSDN文库

七、MAX30102心率血氧传感器原理图资料

MAX30102心率血氧传感器原理图、模块参考资料、50hz采样率的数据绘制的心率波形、芯片数据手册资源-CSDN文库

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/黑客灵魂/article/detail/856015
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号