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

基于STM32以及HAL库的MAX30102模块使用+OLED显示（资源下载免费，在博主我的资源下载处）_max30102+oled

作者：Gausst松鼠会 | 2024-04-16 23:08:05

赞

踩

max30102+oled

一、关于Max30102模块的一些基本问题

（1）为何连接上电之后，模块的红灯仍然不会发光？

  很明确的说，在没有代码驱动的前提下，只是单纯给MAX30102模块上电的话，MAX30102模块上的红灯是不会亮的，必须要有I2C驱动，为其模块的寄存器写入相应的配置，才能够驱动红灯亮起（里面包括红光以及红外光）。

  那我们买回模块之后，如何确定模块的好坏，其实可以直接在购买物品的平台上向商家索要相应的资料，一般就包括有相应的代码可以直接使用，在接对线的情况下，一般就应该会亮灯了。

  

（2）INT引脚能否不配置，没有配置能不能读取数值？

  先给出我的回答，其实不配置INT引脚或者是直接不使用，也是可以读取数值的，但是配置INT引脚也不难，为其配置为相应的外部中断引脚即可，而中断的产生，也并不是说当手指放上去才会产生中断的，产生中断也可以是每次采样周期结束时才会产生中断的。

（3）为何自己读取的数值波动大，不够稳定？

  在使用商家提供的代码或者自己移植的代码时，可能会有小伙伴发现，怎么数据波动仍然那么大，心率一直处于200多到500跳动，就是数值下不来，那么大概率是因为自己的手指接触到了排针，产生了阻抗，带来了干扰，所以尽量减少手指接触到排针，可以将排针用其他东西挡着，例如胶带之类的。

  当然MAX30102模块寄存器配置，I2C的写法等都有可能造成波动大的问题。

二、OLED+MAX30102接线

MAX30102OLED使用USART3
SCLPB8SCLPB6PB10
SDAPB9SDAPB7PB11
INTPB4

三、关于MAX30102的关键代码

max30102.c

  1. #include "max30102.h"
  2. #include "myiic.h"
  3. #include "gpio.h"
  4.  
  5. /*MAX30102:
  6. 	VCC<->3.3V
  7. 	GND<->GND
  8. 	SCL<->PB8
  9. 	SDA<->PB9
  10. 	IM<->PB4
  11. 	*/
  12. uint32_t aun_ir_buffer[500]; //IR LED sensor data
  13. int32_t n_ir_buffer_length;    //data length
  14. uint32_t aun_red_buffer[500];    //Red LED sensor data
  15. int32_t n_sp02; //SPO2 value
  16. int8_t ch_spo2_valid;   //indicator to show if the SP02 calculation is valid
  17. int32_t n_heart_rate;   //heart rate value
  18. int8_t  ch_hr_valid;    //indicator to show if the heart rate calculation is valid
  19. uint8_t uch_dummy;
  20.  
  21. //variables to calculate the on-board LED brightness that reflects the heartbeats
  22. uint32_t un_min, un_max, un_prev_data;  
  23. int i;
  24. int32_t n_brightness;
  25. float f_temp;
  26. uint8_t temp_num=0;
  27. uint8_t temp[6];
  28. uint8_t str[100];
  29. uint8_t dis_hr=0,dis_spo2=0;
  30. int flag1=0;
  31. uint16_t sum[12];
  32. uint16_t sum1[12];
  33. int j,k,temp1,temp2;
  34. int progess,flag3=0;	
  35. #define MAX_BRIGHTNESS 255
  36.  
  37.  
  38.  
  39. uint8_t max30102_Bus_Write(uint8_t Register_Address, uint8_t Word_Data)
  40. {
  41.  
  42. 	/* 采用串行EEPROM随即读取指令序列，连续读取若干字节 */
  43.  
  44. 	/* 第1步：发起I2C总线启动信号 */
  45. 	IIC_Start();
  46.  
  47. 	/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  48. 	IIC_Send_Byte(max30102_WR_address | I2C_WR);	/* 此处是写指令 */
  49.  
  50. 	/* 第3步：发送ACK */
  51. 	if (IIC_Wait_Ack() != 0)
  52. 	{
  53. 		goto cmd_fail;	/* EEPROM器件无应答 */
  54. 	}
  55.  
  56. 	/* 第4步：发送字节地址 */
  57. 	IIC_Send_Byte(Register_Address);
  58. 	if (IIC_Wait_Ack() != 0)
  59. 	{
  60. 		goto cmd_fail;	/* EEPROM器件无应答 */
  61. 	}
  62. 	
  63. 	/* 第5步：开始写入数据 */
  64. 	IIC_Send_Byte(Word_Data);
  65.  
  66. 	/* 第6步：发送ACK */
  67. 	if (IIC_Wait_Ack() != 0)
  68. 	{
  69. 		goto cmd_fail;	/* EEPROM器件无应答 */
  70. 	}
  71.  
  72. 	/* 发送I2C总线停止信号 */
  73. 	IIC_Stop();
  74. 	return 1;	/* 执行成功 */
  75.  
  76. cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
  77. 	/* 发送I2C总线停止信号 */
  78. 	IIC_Stop();
  79. 	return 0;
  80. }
  81.  
  82.  
  83.  
  84. uint8_t max30102_Bus_Read(uint8_t Register_Address)
  85. {
  86. 	uint8_t  data;
  87.  
  88.  
  89. 	/* 第1步：发起I2C总线启动信号 */
  90. 	IIC_Start();
  91.  
  92. 	/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  93. 	IIC_Send_Byte(max30102_WR_address | I2C_WR);	/* 此处是写指令 */
  94.  
  95. 	/* 第3步：发送ACK */
  96. 	if (IIC_Wait_Ack() != 0)
  97. 	{
  98. 		goto cmd_fail;	/* EEPROM器件无应答 */
  99. 	}
  100.  
  101. 	/* 第4步：发送字节地址， */
  102. 	IIC_Send_Byte((uint8_t)Register_Address);
  103. 	if (IIC_Wait_Ack() != 0)
  104. 	{
  105. 		goto cmd_fail;	/* EEPROM器件无应答 */
  106. 	}
  107. 	
  108.  
  109. 	/* 第6步：重新启动I2C总线。下面开始读取数据 */
  110. 	IIC_Start();
  111.  
  112. 	/* 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  113. 	IIC_Send_Byte(max30102_WR_address | I2C_RD);	/* 此处是读指令 */
  114.  
  115. 	/* 第8步：发送ACK */
  116. 	if (IIC_Wait_Ack() != 0)
  117. 	{
  118. 		goto cmd_fail;	/* EEPROM器件无应答 */
  119. 	}
  120.  
  121. 	/* 第9步：读取数据 */
  122. 	{
  123. 		data = IIC_Read_Byte(0);	/* 读1个字节 */
  124.  
  125. 		IIC_NAck();	/* 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1) */
  126. 	}
  127. 	/* 发送I2C总线停止信号 */
  128. 	IIC_Stop();
  129. 	return data;	/* 执行成功 返回data值 */
  130.  
  131. cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
  132. 	/* 发送I2C总线停止信号 */
  133. 	IIC_Stop();
  134. 	return 0;
  135. }
  136.  
  137.  
  138. void max30102_FIFO_ReadWords(uint8_t Register_Address,uint16_t Word_Data[][2],uint8_t count)
  139. {
  140. 	uint8_t i=0;
  141. 	uint8_t no = count;
  142. 	uint8_t data1, data2;
  143. 	/* 第1步：发起I2C总线启动信号 */
  144. 	IIC_Start();
  145.  
  146. 	/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  147. 	IIC_Send_Byte(max30102_WR_address | I2C_WR);	/* 此处是写指令 */
  148.  
  149. 	/* 第3步：发送ACK */
  150. 	if (IIC_Wait_Ack() != 0)
  151. 	{
  152. 		goto cmd_fail;	/* EEPROM器件无应答 */
  153. 	}
  154.  
  155. 	/* 第4步：发送字节地址， */
  156. 	IIC_Send_Byte((uint8_t)Register_Address);
  157. 	if (IIC_Wait_Ack() != 0)
  158. 	{
  159. 		goto cmd_fail;	/* EEPROM器件无应答 */
  160. 	}
  161. 	
  162.  
  163. 	/* 第6步：重新启动I2C总线。下面开始读取数据 */
  164. 	IIC_Start();
  165.  
  166. 	/* 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  167. 	IIC_Send_Byte(max30102_WR_address | I2C_RD);	/* 此处是读指令 */
  168.  
  169. 	/* 第8步：发送ACK */
  170. 	if (IIC_Wait_Ack() != 0)
  171. 	{
  172. 		goto cmd_fail;	/* EEPROM器件无应答 */
  173. 	}
  174.  
  175. 	/* 第9步：读取数据 */
  176. 	while (no)
  177. 	{
  178. 		data1 = IIC_Read_Byte(0);	
  179. 		IIC_Ack();
  180. 		data2 = IIC_Read_Byte(0);
  181. 		IIC_Ack();
  182. 		Word_Data[i][0] = (((uint16_t)data1 << 8) | data2);  //
  183.  
  184. 		
  185. 		data1 = IIC_Read_Byte(0);	
  186. 		IIC_Ack();
  187. 		data2 = IIC_Read_Byte(0);
  188. 		if(1==no)
  189. 			IIC_NAck();	/* 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1) */
  190. 		else
  191. 			IIC_Ack();
  192. 		Word_Data[i][1] = (((uint16_t)data1 << 8) | data2); 
  193.  
  194. 		no--;	
  195. 		i++;
  196. 	}
  197. 	/* 发送I2C总线停止信号 */
  198. 	IIC_Stop();
  199.  
  200. cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
  201. 	/* 发送I2C总线停止信号 */
  202. 	IIC_Stop();
  203. }
  204.  
  205. void max30102_FIFO_ReadBytes(uint8_t Register_Address,uint8_t* Data)
  206. {	
  207. 	max30102_Bus_Read(REG_INTR_STATUS_1);
  208. 	max30102_Bus_Read(REG_INTR_STATUS_2);
  209. 	
  210. 	/* 第1步：发起I2C总线启动信号 */
  211. 	IIC_Start();
  212.  
  213. 	/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  214. 	IIC_Send_Byte(max30102_WR_address | I2C_WR);	/* 此处是写指令 */
  215.  
  216. 	/* 第3步：发送ACK */
  217. 	if (IIC_Wait_Ack() != 0)
  218. 	{
  219. 		goto cmd_fail;	/* EEPROM器件无应答 */
  220. 	}
  221.  
  222. 	/* 第4步：发送字节地址， */
  223. 	IIC_Send_Byte((uint8_t)Register_Address);
  224. 	if (IIC_Wait_Ack() != 0)
  225. 	{
  226. 		goto cmd_fail;	/* EEPROM器件无应答 */
  227. 	}
  228. 	
  229.  
  230. 	/* 第6步：重新启动I2C总线。下面开始读取数据 */
  231. 	IIC_Start();
  232.  
  233. 	/* 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  234. 	IIC_Send_Byte(max30102_WR_address | I2C_RD);	/* 此处是读指令 */
  235.  
  236. 	/* 第8步：发送ACK */
  237. 	if (IIC_Wait_Ack() != 0)
  238. 	{
  239. 		goto cmd_fail;	/* EEPROM器件无应答 */
  240. 	}
  241.  
  242. 	/* 第9步：读取数据 */
  243. 	Data[0] = IIC_Read_Byte(1);	
  244. 	Data[1] = IIC_Read_Byte(1);	
  245. 	Data[2] = IIC_Read_Byte(1);	
  246. 	Data[3] = IIC_Read_Byte(1);
  247. 	Data[4] = IIC_Read_Byte(1);	
  248. 	Data[5] = IIC_Read_Byte(0);
  249. 	/* 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1) */
  250. 	/* 发送I2C总线停止信号 */
  251. 	IIC_Stop();
  252.  
  253. cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
  254. 	/* 发送I2C总线停止信号 */
  255. 	IIC_Stop();
  256.  
  257. //	uint8_t i;
  258. //	uint8_t fifo_wr_ptr;
  259. //	uint8_t firo_rd_ptr;
  260. //	uint8_t number_tp_read;
  261. //	//Get the FIFO_WR_PTR
  262. //	fifo_wr_ptr = max30102_Bus_Read(REG_FIFO_WR_PTR);
  263. //	//Get the FIFO_RD_PTR
  264. //	firo_rd_ptr = max30102_Bus_Read(REG_FIFO_RD_PTR);
  265. //	
  266. //	number_tp_read = fifo_wr_ptr - firo_rd_ptr;
  267. //	
  268. //	//for(i=0;i<number_tp_read;i++){
  269. //	if(number_tp_read>0){
  270. //		IIC_ReadBytes(max30102_WR_address,REG_FIFO_DATA,Data,6);
  271. //	}
  272. 	
  273. 	//max30102_Bus_Write(REG_FIFO_RD_PTR,fifo_wr_ptr);
  274. }
  275.  
  276. void max30102_init(void)
  277. {
  278. //	GPIO_InitTypeDef GPIO_InitStructure;
  279.  
  280. // 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);	
  281. //	GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_14;
  282. //	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  283. // 	GPIO_Init(GPIOB, &GPIO_InitStructure);
  284. 	
  285. //	IIC_Init();
  286. 	
  287. 	max30102_reset();
  288. 	
  289. //	max30102_Bus_Write(REG_MODE_CONFIG, 0x0b);  //mode configuration : temp_en[3]      MODE[2:0]=010 HR only enabled    011 SP02 enabled
  290. //	max30102_Bus_Write(REG_INTR_STATUS_2, 0xF0); //open all of interrupt
  291. //	max30102_Bus_Write(REG_INTR_STATUS_1, 0x00); //all interrupt clear
  292. //	max30102_Bus_Write(REG_INTR_ENABLE_2, 0x02); //DIE_TEMP_RDY_EN
  293. //	max30102_Bus_Write(REG_TEMP_CONFIG, 0x01); //SET   TEMP_EN
  294.  
  295. //	max30102_Bus_Write(REG_SPO2_CONFIG, 0x47); //SPO2_SR[4:2]=001  100 per second    LED_PW[1:0]=11  16BITS
  296.  
  297. //	max30102_Bus_Write(REG_LED1_PA, 0x47); 
  298. //	max30102_Bus_Write(REG_LED2_PA, 0x47); 
  299. 	
  300. 	
  301. 	
  302. 	max30102_Bus_Write(REG_INTR_ENABLE_1,0xc0);	// INTR setting
  303. 	max30102_Bus_Write(REG_INTR_ENABLE_2,0x00);
  304. 	max30102_Bus_Write(REG_FIFO_WR_PTR,0x00);  	//FIFO_WR_PTR[4:0]
  305. 	max30102_Bus_Write(REG_OVF_COUNTER,0x00);  	//OVF_COUNTER[4:0]
  306. 	max30102_Bus_Write(REG_FIFO_RD_PTR,0x00);  	//FIFO_RD_PTR[4:0]
  307. 	max30102_Bus_Write(REG_FIFO_CONFIG,0x0f);  	//sample avg = 1, fifo rollover=false, fifo almost full = 17
  308. 	max30102_Bus_Write(REG_MODE_CONFIG,0x03);  	//0x02 for Red only, 0x03 for SpO2 mode 0x07 multimode LED
  309. 	max30102_Bus_Write(REG_SPO2_CONFIG,0x27);  	// SPO2_ADC range = 4096nA, SPO2 sample rate (100 Hz), LED pulseWidth (400uS)  
  310. 	max30102_Bus_Write(REG_LED1_PA,0x24);   	//Choose value for ~ 7mA for LED1
  311. 	max30102_Bus_Write(REG_LED2_PA,0x24);   	// Choose value for ~ 7mA for LED2
  312. 	max30102_Bus_Write(REG_PILOT_PA,0x7f);   	// Choose value for ~ 25mA for Pilot LED
  313.  
  314. 											
  315. }
  316.  
  317. void max30102_reset(void)
  318. {
  319. 	max30102_Bus_Write(REG_MODE_CONFIG,0x40);
  320. 	max30102_Bus_Write(REG_MODE_CONFIG,0x40);
  321. }
  322.  
  323.  
  324.  
  325.  
  326.  
  327.  
  328. void maxim_max30102_write_reg(uint8_t uch_addr, uint8_t uch_data)
  329. {
  330.  
  331. 	IIC_Write_One_Byte(I2C_WRITE_ADDR,uch_addr,uch_data);
  332. }
  333.  
  334. void maxim_max30102_read_reg(uint8_t uch_addr, uint8_t *puch_data)
  335. {
  336.  
  337. 	
  338. 	IIC_Read_One_Byte(I2C_WRITE_ADDR,uch_addr,puch_data);
  339. }
  340.  
  341. void maxim_max30102_read_fifo(uint32_t *pun_red_led, uint32_t *pun_ir_led)
  342. {
  343. 	uint32_t un_temp;
  344. 	unsigned char uch_temp;
  345. 	char ach_i2c_data[6];
  346. 	*pun_red_led=0;
  347. 	*pun_ir_led=0;
  348.  
  349.   
  350.   //read and clear status register
  351.   maxim_max30102_read_reg(REG_INTR_STATUS_1, &uch_temp);
  352.   maxim_max30102_read_reg(REG_INTR_STATUS_2, &uch_temp);
  353.   
  354.   IIC_ReadBytes(I2C_WRITE_ADDR,REG_FIFO_DATA,(uint8_t *)ach_i2c_data,6);
  355.   
  356.   un_temp=(unsigned char) ach_i2c_data[0];
  357.   un_temp<<=16;
  358.   *pun_red_led+=un_temp;
  359.   un_temp=(unsigned char) ach_i2c_data[1];
  360.   un_temp<<=8;
  361.   *pun_red_led+=un_temp;
  362.   un_temp=(unsigned char) ach_i2c_data[2];
  363.   *pun_red_led+=un_temp;
  364.   
  365.   un_temp=(unsigned char) ach_i2c_data[3];
  366.   un_temp<<=16;
  367.   *pun_ir_led+=un_temp;
  368.   un_temp=(unsigned char) ach_i2c_data[4];
  369.   un_temp<<=8;
  370.   *pun_ir_led+=un_temp;
  371.   un_temp=(unsigned char) ach_i2c_data[5];
  372.   *pun_ir_led+=un_temp;
  373.   *pun_red_led&=0x03FFFF;  //Mask MSB [23:18]
  374.   *pun_ir_led&=0x03FFFF;  //Mask MSB [23:18]
  375. }
  376.  
  377.  
  378. void dis_DrawCurve(uint32_t* data,uint8_t x)
  379. {
  380. 	uint16_t i;
  381. 	uint32_t max=0,min=262144;
  382. 	uint32_t temp;
  383. 	uint32_t compress;
  384. 	
  385. 	for(i=0;i<128*2;i++)
  386. 	{
  387. 		if(data[i]>max)
  388. 		{
  389. 			max = data[i];
  390. 		}
  391. 		if(data[i]<min)
  392. 		{
  393. 			min = data[i];
  394. 		}
  395. 	}
  396. 	
  397. 	compress = (max-min)/20;
  398. 	
  399. 	for(i=0;i<128;i++)
  400. 	{
  401. 		temp = data[i*2] + data[i*2+1];
  402. 		temp/=2;
  403. 		temp -= min;
  404. 		temp/=compress;
  405. 		if(temp>20)temp=20;
  406. 	}
  407. }
  408.  
  409.  
  410. void MAX30102_data_set()
  411. {
  412. //	printf("\r\n MAX30102  init  \r\n");
  413. 	
  414. 	un_min=0x3FFFF;
  415. 	un_max=0;
  416. 	
  417. 	n_ir_buffer_length=500; //buffer length of 100 stores 5 seconds of samples running at 100sps
  418. 	//read the first 500 samples, and determine the signal range
  419.     for(i=0;i<n_ir_buffer_length;i++)
  420.     {
  421.        while(MAX30102_INT==1);   //wait until the interrupt pin asserts
  422.      
  423. 		max30102_FIFO_ReadBytes(REG_FIFO_DATA,temp);
  424. 		aun_red_buffer[i] =  (long)((long)((long)temp[0]&0x03)<<16) | (long)temp[1]<<8 | (long)temp[2];    // Combine values to get the actual number
  425. 		aun_ir_buffer[i] = (long)((long)((long)temp[3] & 0x03)<<16) |(long)temp[4]<<8 | (long)temp[5];   // Combine values to get the actual number
  426.             
  427.         if(un_min>aun_red_buffer[i])
  428.             un_min=aun_red_buffer[i];    //update signal min
  429.         if(un_max<aun_red_buffer[i])
  430.             un_max=aun_red_buffer[i];    //update signal max
  431.     }
  432. 	un_prev_data=aun_red_buffer[i];
  433. 	//calculate heart rate and SpO2 after first 500 samples (first 5 seconds of samples)
  434.     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); 
  435. }
  436.  
  437.  
  438. void MAX30102_get(uint8_t *hr,uint8_t *spo2)
  439. {
  440. 	    i=0;
  441.         un_min=0x3FFFF;
  442.         un_max=0;
  443. 		
  444. 		//dumping the first 100 sets of samples in the memory and shift the last 400 sets of samples to the top
  445.         for(i=100;i<500;i++)
  446.         {
  447.             aun_red_buffer[i-100]=aun_red_buffer[i];
  448.             aun_ir_buffer[i-100]=aun_ir_buffer[i];
  449.             
  450.             //update the signal min and max
  451.             if(un_min>aun_red_buffer[i])
  452.             un_min=aun_red_buffer[i];
  453.             if(un_max<aun_red_buffer[i])
  454.             un_max=aun_red_buffer[i];
  455.         }
  456. 		//take 100 sets of samples before calculating the heart rate.
  457.         for(i=400;i<500;i++)
  458.         {
  459.             un_prev_data=aun_red_buffer[i-1];
  460.             while(MAX30102_INT==1); 
  461. 			
  462.             max30102_FIFO_ReadBytes(REG_FIFO_DATA,temp);
  463. 			aun_red_buffer[i] =  (long)((long)((long)temp[0]&0x03)<<16) | (long)temp[1]<<8 | (long)temp[2];    // Combine values to get the actual number
  464. 			aun_ir_buffer[i] = (long)((long)((long)temp[3] & 0x03)<<16) |(long)temp[4]<<8 | (long)temp[5];   // Combine values to get the actual number
  465.         
  466.             if(aun_red_buffer[i]>un_prev_data)
  467.             {
  468.                 f_temp=aun_red_buffer[i]-un_prev_data;
  469.                 f_temp/=(un_max-un_min);
  470.                 f_temp*=MAX_BRIGHTNESS;
  471.                 n_brightness-=(int)f_temp;
  472.                 if(n_brightness<0)
  473.                     n_brightness=0;
  474.             }
  475.             else
  476.             {
  477.                 f_temp=un_prev_data-aun_red_buffer[i];
  478.                 f_temp/=(un_max-un_min);
  479.                 f_temp*=MAX_BRIGHTNESS; 
  480.                 n_brightness+=(int)f_temp;
  481.                 if(n_brightness>MAX_BRIGHTNESS)
  482.                     n_brightness=MAX_BRIGHTNESS;
  483.             }
  484. 			
  485. 			printf("red=");
  486.             printf("%i", aun_red_buffer[i]);
  487.             printf(", ir=");
  488.             printf("%i", aun_ir_buffer[i]);
  489.             printf(", HR=%i, ", n_heart_rate); 
  490.             printf("HRvalid=%i, ", ch_hr_valid);
  491.             printf("SpO2=%i, ", n_sp02);
  492.             printf("SPO2Valid=%i\n\r", ch_spo2_valid);
  493.  
  494. 		//当心率满足一下条件后，就读取一次	
  495. 			if(ch_hr_valid == 1 && n_heart_rate<150&&n_heart_rate>60&&aun_red_buffer[i]>80000&&ch_spo2_valid==1&&aun_ir_buffer[i]>120000)
  496. 			{
  497. 				 sum[j] = n_heart_rate;	
  498.                  sum1[j]=n_sp02;
  499. 		    }
  500.  
  501. 		//读取11个数值，第一个舍弃，比较后面10个数据，选取最小值作为最后的心率
  502. 			if(j==11)
  503. 			{
  504. 				for(j = 1;j <10;j++)     
  505. 				{
  506. 					for(k = j+1;k <10;k++)
  507. 					{
  508. 						if(sum[k] < sum[j])
  509. 						{
  510. 							temp1 = sum[j];
  511. 							sum[j] = sum[k];
  512. 							sum[k] = temp1;
  513. 						}
  514. 							if(sum1[k] < sum1[j])
  515. 						{
  516. 							temp2 = sum1[j];
  517. 							sum1[j] = sum1[k];
  518. 							sum1[k] = temp2;
  519. 						}
  520. 					}
  521. 				}
  522. 				dis_hr=sum[1];
  523. 				dis_spo2=sum1[8];
  524. 				j = 0;           
  525. 			 }	
  526.  
  527.      	    *hr = dis_hr;
  528. 			*spo2 = dis_spo2;
  529.  
  530. 			if(progess==100)
  531. 			flag3=1;			 
  532. 			
  533. 		}
  534. 		
  535.         if(sum[j]!=0) 
  536. 		{
  537. 			if(progess!=100&&j!=0)
  538. 	        progess+=10;
  539. 			
  540. 			j++;
  541. 		}
  542.  
  543.         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);
  544. 		//send samples and calculation result to terminal program through UART
  545. 		
  546.         //显示进度，到100则是读取成功	
  547. 		OLED_ShowNum(90,0,progess,3,16);	
  548. 		
  549. 		
  550. 		//红光在上，红外在下
  551. 		dis_DrawCurve(aun_red_buffer,20);
  552. 		dis_DrawCurve(aun_ir_buffer,0);
  553. 	
  554.  
  555. }

max30102.h

  1. #ifndef __MAX30102_H
  2. #define __MAX30102_H
  3. #include "main.h"
  4. // 	  
  5.  
  6. #define MAX30102_INT HAL_GPIO_ReadPin(GPIOB,MAX30102_INT_Pin)
  7.  
  8. #define I2C_WR	0		/* 写控制bit */
  9. #define I2C_RD	1		/* 读控制bit */
  10.  
  11. #define max30102_WR_address 0xAE
  12.  
  13. #define I2C_WRITE_ADDR 0xAE
  14. #define I2C_READ_ADDR 0xAF
  15.  
  16. //register addresses
  17. #define REG_INTR_STATUS_1 0x00
  18. #define REG_INTR_STATUS_2 0x01
  19. #define REG_INTR_ENABLE_1 0x02
  20. #define REG_INTR_ENABLE_2 0x03
  21. #define REG_FIFO_WR_PTR 0x04
  22. #define REG_OVF_COUNTER 0x05
  23. #define REG_FIFO_RD_PTR 0x06
  24. #define REG_FIFO_DATA 0x07
  25. #define REG_FIFO_CONFIG 0x08
  26. #define REG_MODE_CONFIG 0x09
  27. #define REG_SPO2_CONFIG 0x0A
  28. #define REG_LED1_PA 0x0C
  29. #define REG_LED2_PA 0x0D
  30. #define REG_PILOT_PA 0x10
  31. #define REG_MULTI_LED_CTRL1 0x11
  32. #define REG_MULTI_LED_CTRL2 0x12
  33. #define REG_TEMP_INTR 0x1F
  34. #define REG_TEMP_FRAC 0x20
  35. #define REG_TEMP_CONFIG 0x21
  36. #define REG_PROX_INT_THRESH 0x30
  37. #define REG_REV_ID 0xFE
  38. #define REG_PART_ID 0xFF
  39.  
  40. void max30102_init(void);  
  41. void max30102_reset(void);
  42. uint8_t max30102_Bus_Write(uint8_t Register_Address, uint8_t Word_Data);
  43. uint8_t max30102_Bus_Read(uint8_t Register_Address);
  44. void max30102_FIFO_ReadWords(uint8_t Register_Address,uint16_t  Word_Data[][2],uint8_t count);
  45. void max30102_FIFO_ReadBytes(uint8_t Register_Address,uint8_t* Data);
  46.  
  47. void maxim_max30102_write_reg(uint8_t uch_addr, uint8_t uch_data);
  48. void maxim_max30102_read_reg(uint8_t uch_addr, uint8_t *puch_data);
  49. void maxim_max30102_read_fifo(uint32_t *pun_red_led, uint32_t *pun_ir_led);
  50.  
  51. void dis_DrawCurve(uint32_t* data,uint8_t x);
  52. void MAX30102_get(uint8_t *hr,uint8_t *spo2);
  53. void MAX30102_data_set();
  54.  
  55.  
  56. #endif

algorithm.c

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

algorithm.h

  1. #ifndef ALGORITHM_H_
  2. #define ALGORITHM_H_
  3.  
  4. #include "main.h"
  5.  
  6. #define true 1
  7. #define false 0
  8. #define FS 100
  9. #define BUFFER_SIZE  (FS* 5) 
  10. #define HR_FIFO_SIZE 7
  11. #define MA4_SIZE  4 // DO NOT CHANGE
  12. #define HAMMING_SIZE  5// DO NOT CHANGE
  13. #define min(x,y) ((x) < (y) ? (x) : (y))
  14.  
  15. const uint16_t auw_hamm[31]={ 41,    276,    512,    276,     41 }; //Hamm=  long16(512* hamming(5)');
  16. //uch_spo2_table is computed as  -45.060*ratioAverage* ratioAverage + 30.354 *ratioAverage + 94.845 ;
  17. 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, 
  18.                             99, 99, 99, 99, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 
  19.                             100, 100, 100, 100, 99, 99, 99, 99, 99, 99, 99, 99, 98, 98, 98, 98, 98, 98, 97, 97, 
  20.                             97, 97, 96, 96, 96, 96, 95, 95, 95, 94, 94, 94, 93, 93, 93, 92, 92, 92, 91, 91, 
  21.                             90, 90, 89, 89, 89, 88, 88, 87, 87, 86, 86, 85, 85, 84, 84, 83, 82, 82, 81, 81, 
  22.                             80, 80, 79, 78, 78, 77, 76, 76, 75, 74, 74, 73, 72, 72, 71, 70, 69, 69, 68, 67, 
  23.                             66, 66, 65, 64, 63, 62, 62, 61, 60, 59, 58, 57, 56, 56, 55, 54, 53, 52, 51, 50, 
  24.                             49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 31, 30, 29, 
  25.                             28, 27, 26, 25, 23, 22, 21, 20, 19, 17, 16, 15, 14, 12, 11, 10, 9, 7, 6, 5, 
  26.                             3, 2, 1 } ;
  27. static  int32_t an_dx[ BUFFER_SIZE-MA4_SIZE]; // delta
  28. static  int32_t an_x[ BUFFER_SIZE]; //ir
  29. static  int32_t an_y[ BUFFER_SIZE]; //red
  30.  
  31.  
  32. 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);
  33. 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 );
  34. 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 );
  35. void maxim_remove_close_peaks( int32_t *pn_locs, int32_t *pn_npks,   int32_t  *pn_x, int32_t n_min_distance );
  36. void maxim_sort_ascend( int32_t *pn_x, int32_t n_size );
  37. void maxim_sort_indices_descend(  int32_t  *pn_x, int32_t *pn_indx, int32_t n_size);
  38.  
  39. #endif /* ALGORITHM_H_ */

I2C.c

  1. #include "myiic.h"
  2. #include "stm32f1xx_hal.h"
  3.  
  4.  
  5. //产生IIC起始信号
  6. void I2C_delay(void) 
  7. { 
  8.    uint16_t i=60; //Set delay time value
  9.    while(i)  
  10.    {  
  11.      i--;  
  12.    }  
  13. }
  14.  
  15. void IIC_Start(void)
  16. {
  17. 	SDA_H;
  18. 	I2C_delay();
  19. 	SCL_H;
  20. 	I2C_delay();
  21. 	SDA_L;
  22. 	I2C_delay();
  23. 	SCL_L;
  24. 	I2C_delay();
  25. }	  
  26. //产生IIC停止信号
  27. void IIC_Stop(void)
  28. {
  29.     SCL_L;
  30.     I2C_delay();	
  31. 	SDA_L; 
  32. 	I2C_delay();
  33. 	SCL_H; 
  34. 	I2C_delay(); 
  35. 	SDA_H; 
  36. 	I2C_delay();							   	
  37. }
  38. //等待应答信号到来
  39. //返回值：1，接收应答失败
  40. //        0，接收应答成功
  41. uint8_t IIC_Wait_Ack(void)
  42. {
  43. 	uint8_t re;
  44. 	SCL_L; 
  45. 	I2C_delay();
  46. 	SDA_H; 
  47. 	I2C_delay(); 
  48. 	SCL_H; 
  49. 	I2C_delay(); 
  50. 	if(SDA_read) 
  51. 	{ 
  52.     re=1;   
  53. 	} 
  54. 	else re=0;
  55. 	SCL_L; 
  56. 	return re; 
  57. 	
  58. //	uint8_t re;
  59.  
  60. //	SDA_L;	/* CPU释放SDA总线 */  //让它必须应答  自己修改的
  61. //	I2C_delay();
  62. //	SCL_H;	/* CPU驱动SCL = 1, 此时器件会返回ACK应答 */
  63. //	I2C_delay();
  64. //	
  65. //	re = SDA_read;/* CPU读取SDA口线状态 */
  66.  
  67. //	SCL_L;
  68. //	I2C_delay();
  69. //	return re;
  70. } 
  71. //产生ACK应答
  72. void IIC_Ack(void)
  73. {
  74.     SCL_L; 
  75. 	I2C_delay(); 
  76. 	SDA_L; 
  77. 	I2C_delay(); 
  78. 	SCL_H; 
  79. 	I2C_delay(); 
  80. 	SCL_L; 
  81. 	I2C_delay(); 
  82. }
  83. //不产生ACK应答		    
  84. void IIC_NAck(void)
  85. {
  86.     SCL_L; 
  87. 	I2C_delay(); 
  88. 	SDA_H; 
  89. 	I2C_delay(); 
  90. 	SCL_H; 
  91. 	I2C_delay(); 
  92. 	SCL_L; 
  93. 	I2C_delay(); 
  94. }					 				     
  95. //IIC发送一个字节
  96. //返回从机有无应答
  97. //1，有应答
  98. //0，无应答			  
  99. void IIC_Send_Byte(uint8_t SendByte)
  100. {                        
  101. 	uint8_t i=8;
  102. 	
  103.   while(i--) 
  104.   { 	
  105. 		SCL_L;
  106. 		I2C_delay(); 
  107.     if((SendByte&0x80))
  108. 		{
  109.      SDA_H; 
  110. 		}			
  111.     else
  112. 		{			
  113.      SDA_L; 
  114. 		}			
  115.     SendByte<<=1; 
  116.     I2C_delay(); 
  117. 	SCL_H; 
  118.     I2C_delay(); 
  119. 		
  120.   } 
  121. 	SCL_L; 	 
  122. } 	    
  123. //读1个字节，ack=1时，发送ACK，ack=0，发送nACK   
  124. uint8_t IIC_Read_Byte(unsigned char ack)
  125. {
  126. 	unsigned char i=8,receive=0; 	 
  127. 			SDA_H;	
  128.     while(i--)
  129.     {
  130.         receive<<=1;      
  131.         SCL_L;
  132.         I2C_delay();
  133. 	      SCL_H;
  134.         I2C_delay();
  135.         if(SDA_read)
  136.         {
  137.           receive|=0x01;
  138.         }
  139.     }
  140.      SCL_L;	
  141.     if (!ack)
  142.         IIC_NAck();//发送nACK
  143.     else
  144.         IIC_Ack(); //发送ACK   
  145.     return receive;
  146. }
  147.  
  148.  
  149. void IIC_WriteBytes(uint8_t WriteAddr,uint8_t* data,uint8_t dataLength)
  150. {		
  151. 	uint8_t i;	
  152.     IIC_Start();  
  153.  
  154. 	IIC_Send_Byte(WriteAddr);	    //发送写命令
  155. 	IIC_Wait_Ack();
  156. 	
  157. 	for(i=0;i<dataLength;i++)
  158. 	{
  159. 		IIC_Send_Byte(data[i]);
  160. 		IIC_Wait_Ack();
  161. 	}				    	   
  162.     IIC_Stop();//产生一个停止条件 
  163. 	I2C_delay(); 	 
  164. }
  165.  
  166. void IIC_ReadBytes(uint8_t deviceAddr, uint8_t writeAddr,uint8_t* data,uint8_t dataLength)
  167. {		
  168. 	uint8_t i;	
  169.     IIC_Start();  
  170.  
  171. 	IIC_Send_Byte(deviceAddr);	    //发送写命令
  172. 	IIC_Wait_Ack();
  173. 	IIC_Send_Byte(writeAddr);
  174. 	IIC_Wait_Ack();
  175. 	IIC_Send_Byte(deviceAddr|0X01);//进入接收模式			   
  176. 	IIC_Wait_Ack();
  177. 	
  178. 	for(i=0;i<dataLength-1;i++)
  179. 	{
  180. 		data[i] = IIC_Read_Byte(1);
  181. 	}		
  182. 	data[dataLength-1] = IIC_Read_Byte(0);	
  183.     IIC_Stop();//产生一个停止条件 
  184. 	I2C_delay(); 	 
  185. }
  186.  
  187. void IIC_Read_One_Byte(uint8_t daddr,uint8_t addr,uint8_t* data)
  188. {				  	  	    																 
  189.     IIC_Start();  
  190. 	
  191. 	IIC_Send_Byte(daddr);	   //发送写命令
  192. 	IIC_Wait_Ack();
  193. 	IIC_Send_Byte(addr);//发送地址
  194. 	IIC_Wait_Ack();		 
  195. 	IIC_Start();  	 	   
  196. 	IIC_Send_Byte(daddr|0X01);//进入接收模式			   
  197. 	IIC_Wait_Ack();	 
  198.     *data = IIC_Read_Byte(0);		   
  199.     IIC_Stop();//产生一个停止条件	    
  200. }
  201.  
  202. void IIC_Write_One_Byte(uint8_t daddr,uint8_t addr,uint8_t data)
  203. {				   	  	    																 
  204.     IIC_Start();  
  205. 	
  206. 	IIC_Send_Byte(daddr);	    //发送写命令
  207. 	IIC_Wait_Ack();
  208. 	IIC_Send_Byte(addr);//发送地址
  209. 	IIC_Wait_Ack();	   	 										  		   
  210. 	IIC_Send_Byte(data);     //发送字节							   
  211. 	IIC_Wait_Ack();  		    	   
  212.     IIC_Stop();//产生一个停止条件 
  213. 	I2C_delay(); 	 
  214. }

main.c

  1. int main(void)
  2. {
  3.   /* USER CODE BEGIN 1 */
  4.  
  5.  
  6.   /* USER CODE END 1 */
  7.  
  8.   /* MCU Configuration--------------------------------------------------------*/
  9.  
  10.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  11.   HAL_Init();
  12.  
  13.   /* USER CODE BEGIN Init */
  14.  
  15.   /* USER CODE END Init */
  16.  
  17.   /* Configure the system clock */
  18.   SystemClock_Config();
  19.  
  20.   /* USER CODE BEGIN SysInit */
  21.  
  22.   /* USER CODE END SysInit */
  23.  
  24.   /* Initialize all configured peripherals */
  25.   MX_GPIO_Init();
  26.  
  27.   MX_USART3_UART_Init();
  28.   /* USER CODE BEGIN 2 */
  29.   OLED_Init();			//初始化OLED  
  30.   OLED_Clear() ; 
  31.   
  32.   max30102_init();
  33.   MAX30102_data_set();	
  34. 	
  35.   
  36.     //wait until the user presses a key
  37. //    while(pc.readable()==0)
  38. //    {
  39. //        pc.printf("\x1B[2J");  //clear terminal program screen
  40. //        pc.printf("Press any key to start conversion\n\r");
  41. //        wait(1);
  42. //    }
  43. //    uch_dummy=getchar();
  44.     
  45.  
  46.   /* USER CODE END 2 */
  47.  
  48.   /* Infinite loop */
  49.   /* USER CODE BEGIN WHILE */
  50.  
  51. //        HAL_GPIO_WritePin(GPIOB,MAX30102_INT_Pin,SET);
  52.         
  53.   while (1)
  54.   {
  55.     /* USER CODE END WHILE */
  56.  
  57.     /* USER CODE BEGIN 3 */
  58.  
  59. 	        MAX30102_get(&HR,&SPO2);     
  60. 		    OLED_ShowNum(30,0,HR,3,16);	   
  61. 		    OLED_ShowNum(60,0,SPO2,3,16);	
  62.  
  63.  
  64.  
  65.        
  66.   }
  67.   /* USER CODE END 3 */
  68. }

OLED

  这个大家可以直接去上网购物平台搜索OLED，一般商家都会有现成的代码可以使用，比如我这里用的则是中景园的OLED代码，大家也可以直接上购物平台查。

四、效果展示

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

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

  

闽ICP备14008679号