精华内容
下载资源
问答
  • max3102心率血氧传感器 max3102心率血氧传感器 max3102心率血氧传感器 max3102心率血氧传感器 max3102心率血氧传感器 max3102心率血氧传感器 max3102心率血氧传感器
  • 针对传统的心率血氧饱和度检测方法在现代医院的应用中存在的缺陷和不足问题,开发了一种基于LoRa的心率血氧实时监测系统。该系统包括一组患者佩戴的心率血氧实时监测手环和与心率血氧实时监测手环通过LoRa基站连接...
  • MAX30102心率血氧算法

    2018-07-27 14:55:37
    基于MAX30102/30101采集PPG,包括信号处理及心率血氧算法
  • 心率 血氧 STM32

    2018-05-06 12:55:50
    基于STM32的max30102心率血氧 测试,MAX30102模块接口:PB9-SDA,PB8-SCL,PB7-INT PA2/PA3为串口传输口TX和RX,波特率设置为115200 PC13为显示LED
  • MAX30102心率血氧传感器模块STM32F103MAX30102心率血氧传感器模块STM32F103MAX30102心率血氧传感器模块STM32F103
  • 网上很多程序都是标题党,说是心率血氧数据都有,然而只有测温度和ID,所以我就特意参照手册和网上资料对程序进行添加修改,得到血氧心率的raw值,大家如果想要得出心率还需要进一步的算法,我这里就提供获取原始...
  • 心率血氧采集 该手表由两大块组成,分别是蓝牙DA14580的数据传输及显示以及内置我们疯壳优质算法的主核心为STM32的“血压/血氧/心率/心电”四合一模组。在该实验中为了更直观的呈现出来效果,采用独立模组的方式...
    心率血氧采集


     

    该手表由两大块组成,分别是蓝牙DA14580的数据传输及显示以及内置我们疯壳优质算法的主核心为STM32的“血压/血氧/心率/心电”四合一模组。在该实验中为了更直观的呈现出来效果,采用独立模组的方式进行演示教学。如图1.0所示为“血压/血氧/心率/心电”四合一模组。

     

        
    图1.0 “血压/血氧/心率/心电”四合一模组


    1.1采集指令及配置
    模组在出厂时已经烧录好固件,我们只需要简单的通过串口诶模组发送指令即可。指令表如表1.0所示。
     
    表1.0 指令表
      
      
      
    返回数据中携带的信息
    备注
    返回内容示例
    fk\r\n
    ok\r\n
    返回ok代表通信正常
    ok
    fk+version\r\n
    版本信息
    版本信息
    LIB:1.0.10
    fk+mode1\r\n
    uint16_t 类型的心率
      
    spo2:float spo2\r\n
    uint16_t 类型的心率值heart_rate
      
    float 类型的血氧浓度spo2
    hr:86
      
    spo2:98.5
    fk+mode2\r\n
    hr:uint16_t  heart_rate\r\n
      
    sbp/dbp: float sbp  /float dbp\r\n
    uint16_t 类型的心率值heart_rate
      
    float类型的收缩压sbp
      
    float类型的舒张压dbp
    hr:86
      
    sbp/dbp:119.2/78.5
    fk+mode3\r\n
    ecg:int32_t amb1_led4_ecg
    int32_t类型的心电图的原始数据值 amb1_led4_ecg
    1285439
    fk+close
    close ok\r\n
    关闭测量
     
    串口的通信配置信息为:
    通信方式:UART;
    波特率115200;
    8位数据;
    1位停止位;
    无奇偶校验。

    1.2实验现象
    向模组发送fk+mode1\r\n,一会后便可以收到模组的回复。如图1.1所示。
    [size=0.83em]

     
    图1.1 心率血氧获取

     
     
    2.png (49.86 KB, 下载次数: 0)






    [url=][/url]【3】4900 7072心率血压血氧心电四合一智能手表&模组心率血氧
    展开全文
  • MAX30100心率血氧传感器中文翻译。Max30100是一款集成的脉搏血氧心率检测传感器。它使用了两个LED灯,一个用来优化光学的光电探测器,和低噪声模拟信号处理器,用来检测脉搏的血氧心率信号。 Max30100的运行电压...
  • 可直接拿过去用到心率血氧MAX30100初始化程序,可以直接复制工程里去用
  • MAX30102的VCC引脚连接单片机5伏引脚,GND连接5伏GND,SCL连PC12,SDA连PC11,INT连PA5。 本代码能够比较正常计算出心率血氧数值。 当心率血氧计算结果错误时对应的变量值为-999。
  • STM32通过IIC驱动MAX30102心率血氧传感器

    千次阅读 多人点赞 2020-11-28 15:06:47
    STM32F103单片机通过IIC控制MAX30102心率血氧传感器 MAX30102的VCC引脚连接STM32F103mini单片机的5伏引脚,GND连接5伏对应的GND,SCL连PC12,SDA连PC11,INT连PA5。MAX30102的其他引脚没有用到。 本代码能够正常接收...

    STM32F103单片机通过IIC控制MAX30102心率血氧传感器

    MAX30102的VCC引脚连接STM32F103mini单片机的5伏引脚,GND连接5伏对应的GND,SCL连PC12,SDA连PC11,INT连PA5。MAX30102的其他引脚没有用到。

    本代码能够正常接收MAX30102心率血氧传感器返回的red与ir的数值,能够比较正常计算出心率血氧数值。当心率或血氧值的计算结果有误时对应的变量值为-999。

    本文最后有源工程文件的下载链接。

    工程文件中使用的delay.h,sys.h,usart.h,myiic.h均为正点原子官方提供的STM32F103mini单片机对应的源码,未做改动。

    因此本文只粘贴新加的max30102.h(max30102驱动代码头文件),max30102.c(max30102驱动代码),algorithm.h(max30102心率血氧算法函数头文件),algorithm.c(max30102心率血氧算法函数文件),以及main.c的测试样例

    main.c文件

    #include "delay.h"
    #include "sys.h"
    #include "usart.h"
    #include "myiic.h"
    #include "max30102.h"
    #include "algorithm.h"
    
    #define MAX_BRIGHTNESS 255
    #define START 100
    #define DATA_LENGTH 500
    
    
    uint32_t aun_ir_buffer[DATA_LENGTH]; //IR LED sensor data
    int32_t n_ir_buffer_length;    //data length
    uint32_t aun_red_buffer[DATA_LENGTH];    //Red LED sensor data
    int32_t n_sp02; //SPO2 value
    int8_t ch_spo2_valid;   //indicator to show if the SP02 calculation is valid
    int32_t n_heart_rate;   //heart rate value
    int8_t  ch_hr_valid;    //indicator to show if the heart rate calculation is valid
    uint8_t uch_dummy;
    
    
     int main(void)
     { 
    	uint32_t un_min, un_max, un_prev_data;  //variables to calculate the on-board LED brightness that reflects the heartbeats
    	int i;
    	int32_t n_brightness;
    	float f_temp;
    	
    	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);// 设置中断优先级分组2
    	delay_init();	    	 //延时函数初始化	  
    	uart_init(115200);	 	//串口初始化为115200
     	IIC_Init();		 	
    	
    	maxim_max30102_reset(); //resets the MAX30102
    	// initialize serial communication at 115200 bits per second:
    	//read and clear status register
    	maxim_max30102_read_reg(0,&uch_dummy);
    	maxim_max30102_init();  //initializes the MAX30102
    
    	n_brightness=0;
    	un_min=0x3FFFF;
    	un_max=0;
    	n_ir_buffer_length=DATA_LENGTH; //buffer length of 100 stores 5 seconds of samples running at 100sps
    	//read the first 500 samples, and determine the signal range
    	for(i=0;i<n_ir_buffer_length;i++)
    	{
    			while(PAin(5)==1);   //wait until the interrupt pin asserts
    			maxim_max30102_read_fifo((aun_red_buffer+i), (aun_ir_buffer+i));  //read from MAX30102 FIFO	
    			if(un_min>aun_red_buffer[i])
    					un_min=aun_red_buffer[i];    //update signal min
    			if(un_max<aun_red_buffer[i])
    					un_max=aun_red_buffer[i];    //update signal max
    			printf("red=%i,", aun_red_buffer[i]);
    			printf("ir=%i\r\n", aun_ir_buffer[i]);
    	}
    	un_prev_data=aun_red_buffer[i];
    	//calculate heart rate and SpO2 after first 500 samples (first 5 seconds of samples)
    	maxim_heart_rate_and_oxygen_saturation(aun_ir_buffer, n_ir_buffer_length, aun_red_buffer, &n_sp02, &ch_spo2_valid, &n_heart_rate, &ch_hr_valid); 
    	while(1)
    	{
    	  i=0;
    		un_min=0x3FFFF;
    		un_max=0;
    		//dumping the first 100 sets of samples in the memory and shift the last 400 sets of samples to the top
    		for(i=START;i<DATA_LENGTH;i++)
    		{
    				aun_red_buffer[i-START]=aun_red_buffer[i];
    				aun_ir_buffer[i-START]=aun_ir_buffer[i];
    				
    				//update the signal min and max
    				if(un_min>aun_red_buffer[i])
    				un_min=aun_red_buffer[i];
    				if(un_max<aun_red_buffer[i])
    				un_max=aun_red_buffer[i];
    		}
    		//take 100 sets of samples before calculating the heart rate.
    		for(i=400;i<DATA_LENGTH;i++)
    		{
    				un_prev_data=aun_red_buffer[i-1];
    				while(PAin(5)==1);
    				maxim_max30102_read_fifo((aun_red_buffer+i), (aun_ir_buffer+i));
    		
    				if(aun_red_buffer[i]>un_prev_data)//just to determine the brightness of LED according to the deviation of adjacent two AD data
    				{
    						f_temp=aun_red_buffer[i]-un_prev_data;
    						f_temp/=(un_max-un_min);
    						f_temp*=MAX_BRIGHTNESS;
    						n_brightness-=(int)f_temp;
    						if(n_brightness<0)
    								n_brightness=0;
    				}
    				else
    				{
    						f_temp=un_prev_data-aun_red_buffer[i];
    						f_temp/=(un_max-un_min);
    						f_temp*=MAX_BRIGHTNESS;
    						n_brightness+=(int)f_temp;
    						if(n_brightness>MAX_BRIGHTNESS)
    								n_brightness=MAX_BRIGHTNESS;
    				}
    				//send samples and calculation result to terminal program through UART
    //				printf("red=%i,", aun_red_buffer[i]);
    //				printf(" ir=%i,", aun_ir_buffer[i]);
    
    		}
    		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); 
    		printf(" HR=%i,", n_heart_rate); 
    		printf(" HRvalid=%i,", ch_hr_valid);
    		printf(" SpO2=%i,", n_sp02);
    		printf(" SPO2Valid=%i\r\n", ch_spo2_valid);
    	}
    }
    
    

    max30102.h文件

    /** \file max30102.h ******************************************************
    *
    * Project: MAXREFDES117#
    * Filename: max30102.h
    * Description: This module is an embedded controller driver header file for MAX30102
    *
    * Revision History:
    *\n 1-18-2016 Rev 01.00 GL Initial release.
    *\n
    *
    * --------------------------------------------------------------------
    *
    * This code follows the following naming conventions:
    *
    * char              ch_pmod_value
    * char (array)      s_pmod_s_string[16]
    * float             f_pmod_value
    * int32_t           n_pmod_value
    * int32_t (array)   an_pmod_value[16]
    * int16_t           w_pmod_value
    * int16_t (array)   aw_pmod_value[16]
    * uint16_t          uw_pmod_value
    * uint16_t (array)  auw_pmod_value[16]
    * uint8_t           uch_pmod_value
    * uint8_t (array)   auch_pmod_buffer[16]
    * uint32_t          un_pmod_value
    * int32_t *         pn_pmod_value
    *
    * ------------------------------------------------------------------------- */
    /*******************************************************************************
    * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
    *
    * Permission is hereby granted, free of charge, to any person obtaining a
    * copy of this software and associated documentation files (the "Software"),
    * to deal in the Software without restriction, including without limitation
    * the rights to use, copy, modify, merge, publish, distribute, sublicense,
    * and/or sell copies of the Software, and to permit persons to whom the
    * Software is furnished to do so, subject to the following conditions:
    *
    * The above copyright notice and this permission notice shall be included
    * in all copies or substantial portions of the Software.
    *
    * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
    * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
    * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
    * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
    * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
    * OTHER DEALINGS IN THE SOFTWARE.
    *
    * Except as contained in this notice, the name of Maxim Integrated
    * Products, Inc. shall not be used except as stated in the Maxim Integrated
    * Products, Inc. Branding Policy.
    *
    * The mere transfer of this software does not imply any licenses
    * of trade secrets, proprietary technology, copyrights, patents,
    * trademarks, maskwork rights, or any other form of intellectual
    * property whatsoever. Maxim Integrated Products, Inc. retains all
    * ownership rights.
    *******************************************************************************
    */
    #ifndef MAX30102_H_
    #define MAX30102_H_
    
    #include "stm32f10x.h"
    #include "stdbool.h"
    
    #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
    
    bool maxim_max30102_init(void);
    bool maxim_max30102_read_fifo(uint32_t *pun_red_led, uint32_t *pun_ir_led);
    bool maxim_max30102_write_reg(uint8_t uch_addr, uint8_t uch_data);
    bool maxim_max30102_read_reg(uint8_t uch_addr, uint8_t *puch_data);
    bool maxim_max30102_reset(void);
    #endif /*  MAX30102_H_ */
    
    

    max30102.c文件

    /** \file max30102.cpp ******************************************************
    *
    * Project: MAXREFDES117#
    * Filename: max30102.cpp
    * Description: This module is an embedded controller driver for the MAX30102
    *
    * Revision History:
    *\n 1-18-2016 Rev 01.00 GL Initial release.
    *\n
    */
    
    #include "max30102.h"
    #include "myiic.h"
    
    #define max30102_WR_address 0xAE
    bool maxim_max30102_write_reg(uint8_t uch_addr, uint8_t uch_data)
    /**
    * \brief        Write a value to a MAX30102 register
    * \par          Details
    *               This function writes a value to a MAX30102 register
    *
    * \param[in]    uch_addr    - register address
    * \param[in]    uch_data    - register data
    *
    * \retval       true on success
    */
    {
        /* 第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(uch_addr);
        if (IIC_Wait_Ack() != 0)
        {
            goto cmd_fail;	/* EEPROM器件无应答 */
        }
    
        /* 第5步:开始写入数据 */
        IIC_Send_Byte(uch_data);
    
        /* 第6步:发送ACK */
        if (IIC_Wait_Ack() != 0)
        {
            goto cmd_fail;	/* EEPROM器件无应答 */
        }
    
        /* 发送I2C总线停止信号 */
        IIC_Stop();
        return true;	/* 执行成功 */
    
    cmd_fail: /* 命令执行失败后,切记发送停止信号,避免影响I2C总线上其他设备 */
        /* 发送I2C总线停止信号 */
        IIC_Stop();
        return false;
    }
    
    bool maxim_max30102_read_reg(uint8_t uch_addr, uint8_t *puch_data)
    /**
    * \brief        Read a MAX30102 register
    * \par          Details
    *               This function reads a MAX30102 register
    *
    * \param[in]    uch_addr    - register address
    * \param[out]   puch_data    - pointer that stores the register data
    *
    * \retval       true on success
    */
    {
        /* 第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)uch_addr);
        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步:读取数据 */
        {
            *puch_data = IIC_Read_Byte();	/* 读1个字节 */
    
            IIC_NAck();	/* 最后1个字节读完后,CPU产生NACK信号(驱动SDA = 1) */
        }
        /* 发送I2C总线停止信号 */
        IIC_Stop();
        return true;	/* 执行成功 返回data值 */
    
    cmd_fail: /* 命令执行失败后,切记发送停止信号,避免影响I2C总线上其他设备 */
        /* 发送I2C总线停止信号 */
        IIC_Stop();
        return false;
    }
    
    bool maxim_max30102_init(void)
    /**
    * \brief        Initialize the MAX30102
    * \par          Details
    *               This function initializes the MAX30102
    *
    * \param        None
    *
    * \retval       true on success
    */
    {
    		GPIO_InitTypeDef GPIO_InitStructure;
    		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC,ENABLE);//使能PORTA,PORTC时钟
    		GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);//关闭jtag,使能SWD,可以用SWD模式调试
    		GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_5;//PA5
    		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //PA5设置成浮空输入,接MAX30102的INT数据转换是否完成的信号引脚  
    		GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA5
        if(!maxim_max30102_write_reg(REG_INTR_ENABLE_1, 0xc0)) // INTR setting
            return false;
        if(!maxim_max30102_write_reg(REG_INTR_ENABLE_2, 0x00))
            return false;
        if(!maxim_max30102_write_reg(REG_FIFO_WR_PTR, 0x00)) //FIFO_WR_PTR[4:0]
            return false;
        if(!maxim_max30102_write_reg(REG_OVF_COUNTER, 0x00)) //OVF_COUNTER[4:0]
            return false;
        if(!maxim_max30102_write_reg(REG_FIFO_RD_PTR, 0x00)) //FIFO_RD_PTR[4:0]
            return false;
        if(!maxim_max30102_write_reg(REG_FIFO_CONFIG, 0x6f)) //sample avg = 8, fifo rollover=false, fifo almost full = 17
            return false;
        if(!maxim_max30102_write_reg(REG_MODE_CONFIG, 0x03))  //0x02 for Red only, 0x03 for SpO2 mode 0x07 multimode LED
            return false;
        if(!maxim_max30102_write_reg(REG_SPO2_CONFIG, 0x2F)) // SPO2_ADC range = 4096nA, SPO2 sample rate (400 Hz), LED pulseWidth (411uS)
            return false;
    
        if(!maxim_max30102_write_reg(REG_LED1_PA, 0x17))  //Choose value for ~ 4.5mA for LED1
            return false;
        if(!maxim_max30102_write_reg(REG_LED2_PA, 0x17))  // Choose value for ~ 4.5mA for LED2
            return false;
        if(!maxim_max30102_write_reg(REG_PILOT_PA, 0x7f))  // Choose value for ~ 25mA for Pilot LED
            return false;
        return true;
    }
    
    bool maxim_max30102_read_fifo(uint32_t *pun_red_led, uint32_t *pun_ir_led)
    
    /**
    * \brief        Read a set of samples from the MAX30102 FIFO register
    * \par          Details
    *               This function reads a set of samples from the MAX30102 FIFO register
    *
    * \param[out]   *pun_red_led   - pointer that stores the red LED reading data
    * \param[out]   *pun_ir_led    - pointer that stores the IR LED reading data
    *
    * \retval       true on success
    */
    {
        uint32_t un_temp;
        uint8_t uch_temp;
        *pun_ir_led = 0;
        *pun_red_led = 0;
        maxim_max30102_read_reg(REG_INTR_STATUS_1, &uch_temp);
        maxim_max30102_read_reg(REG_INTR_STATUS_2, &uch_temp);
    
    
    
        /* 第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)REG_FIFO_DATA);
        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器件无应答 */
        }
    
        un_temp = IIC_Read_Byte();
        IIC_Ack();
        un_temp <<= 16;
        *pun_red_led += un_temp;
        un_temp = IIC_Read_Byte();
        IIC_Ack();
        un_temp <<= 8;
        *pun_red_led += un_temp;
        un_temp = IIC_Read_Byte();
        IIC_Ack();
        *pun_red_led += un_temp;
    
        un_temp = IIC_Read_Byte();
        IIC_Ack();
        un_temp <<= 16;
        *pun_ir_led += un_temp;
        un_temp = IIC_Read_Byte();
        IIC_Ack();
        un_temp <<= 8;
        *pun_ir_led += un_temp;
        un_temp = IIC_Read_Byte();
        IIC_Ack();
        *pun_ir_led += un_temp;
        *pun_red_led &= 0x03FFFF; //Mask MSB [23:18]
        *pun_ir_led &= 0x03FFFF; //Mask MSB [23:18]
    
        /* 发送I2C总线停止信号 */
        IIC_Stop();
        return true;
    cmd_fail: /* 命令执行失败后,切记发送停止信号,避免影响I2C总线上其他设备 */
        /* 发送I2C总线停止信号 */
        IIC_Stop();
        return false;
    }
    
    bool maxim_max30102_reset()
    /**
    * \brief        Reset the MAX30102
    * \par          Details
    *               This function resets the MAX30102
    *
    * \param        None
    *
    * \retval       true on success
    */
    {
        if(!maxim_max30102_write_reg(REG_MODE_CONFIG, 0x40))
            return false;
        else
            return true;
    }
    
    
    

    algorithm.h

    /** \file algorithm.h ******************************************************
    *
    * Project: MAXREFDES117#
    * Filename: algorithm.h
    * Description: This module is the heart rate/SpO2 calculation algorithm header file
    *
    * Revision History:
    *\n 1-18-2016 Rev 01.00 SK Initial release.
    *\n
    *
    * --------------------------------------------------------------------
    *
    * This code follows the following naming conventions:
    *
    *\n char              ch_pmod_value
    *\n char (array)      s_pmod_s_string[16]
    *\n float             f_pmod_value
    *\n int32_t           n_pmod_value
    *\n int32_t (array)   an_pmod_value[16]
    *\n int16_t           w_pmod_value
    *\n int16_t (array)   aw_pmod_value[16]
    *\n uint16_t          uw_pmod_value
    *\n uint16_t (array)  auw_pmod_value[16]
    *\n uint8_t           uch_pmod_value
    *\n uint8_t (array)   auch_pmod_buffer[16]
    *\n uint32_t          un_pmod_value
    *\n int32_t *         pn_pmod_value
    *
    * ------------------------------------------------------------------------- */
    /*******************************************************************************
    * Copyright (C) 2015 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.
    *******************************************************************************
    */
    #ifndef ALGORITHM_H_
    #define ALGORITHM_H_
    #include "stm32f10x.h"
    #include "stdbool.h"
    
    #define true 1
    #define false 0
    #define FS 50    //sampling frequency
    #define BUFFER_SIZE  (FS* 3) 
    #define MA4_SIZE  4 // DONOT CHANGE
    #define min(x,y) ((x) < (y) ? (x) : (y))
    
    
    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);
    void maxim_find_peaks(int32_t *pn_locs, int32_t *n_npks,  int32_t  *pn_x, int32_t n_size, int32_t n_min_height, int32_t n_min_distance, int32_t n_max_num);
    void maxim_peaks_above_min_height(int32_t *pn_locs, int32_t *n_npks,  int32_t  *pn_x, int32_t n_size, int32_t n_min_height);
    void maxim_remove_close_peaks(int32_t *pn_locs, int32_t *pn_npks, int32_t *pn_x, int32_t n_min_distance);
    void maxim_sort_ascend(int32_t  *pn_x, int32_t n_size);
    void maxim_sort_indices_descend(int32_t  *pn_x, int32_t *pn_indx, int32_t n_size);
    
    #endif /* ALGORITHM_H_ */
    
    
    

    algorithm.c

    /** \file algorithm.cpp ******************************************************
    *
    * Project: MAXREFDES117#
    * Filename: algorithm.cpp
    * Description: This module calculates the heart rate/SpO2 level
    *
    *
    * --------------------------------------------------------------------
    *
    * This code follows the following naming conventions:
    *
    * char              ch_pmod_value
    * char (array)      s_pmod_s_string[16]
    * float             f_pmod_value
    * int32_t           n_pmod_value
    * int32_t (array)   an_pmod_value[16]
    * int16_t           w_pmod_value
    * int16_t (array)   aw_pmod_value[16]
    * uint16_t          uw_pmod_value
    * uint16_t (array)  auw_pmod_value[16]
    * uint8_t           uch_pmod_value
    * uint8_t (array)   auch_pmod_buffer[16]
    * uint32_t          un_pmod_value
    * int32_t *         pn_pmod_value
    *
    * ------------------------------------------------------------------------- */
    /*******************************************************************************
    * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
    *
    * Permission is hereby granted, free of charge, to any person obtaining a
    * copy of this software and associated documentation files (the "Software"),
    * to deal in the Software without restriction, including without limitation
    * the rights to use, copy, modify, merge, publish, distribute, sublicense,
    * and/or sell copies of the Software, and to permit persons to whom the
    * Software is furnished to do so, subject to the following conditions:
    *
    * The above copyright notice and this permission notice shall be included
    * in all copies or substantial portions of the Software.
    *
    * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
    * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
    * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
    * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
    * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
    * OTHER DEALINGS IN THE SOFTWARE.
    *
    * Except as contained in this notice, the name of Maxim Integrated
    * Products, Inc. shall not be used except as stated in the Maxim Integrated
    * Products, Inc. Branding Policy.
    *
    * The mere transfer of this software does not imply any licenses
    * of trade secrets, proprietary technology, copyrights, patents,
    * trademarks, maskwork rights, or any other form of intellectual
    * property whatsoever. Maxim Integrated Products, Inc. retains all
    * ownership rights.
    *******************************************************************************
    */
    
    #include "algorithm.h"
    
    //uch_spo2_table is approximated as  -45.060*ratioAverage* ratioAverage + 30.354 *ratioAverage + 94.845 ;
    const uint8_t uch_spo2_table[184] = { 95, 95, 95, 96, 96, 96, 97, 97, 97, 97, 97, 98, 98, 98, 98, 98, 99, 99, 99, 99,
                                          99, 99, 99, 99, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
                                          100, 100, 100, 100, 99, 99, 99, 99, 99, 99, 99, 99, 98, 98, 98, 98, 98, 98, 97, 97,
                                          97, 97, 96, 96, 96, 96, 95, 95, 95, 94, 94, 94, 93, 93, 93, 92, 92, 92, 91, 91,
                                          90, 90, 89, 89, 89, 88, 88, 87, 87, 86, 86, 85, 85, 84, 84, 83, 82, 82, 81, 81,
                                          80, 80, 79, 78, 78, 77, 76, 76, 75, 74, 74, 73, 72, 72, 71, 70, 69, 69, 68, 67,
                                          66, 66, 65, 64, 63, 62, 62, 61, 60, 59, 58, 57, 56, 56, 55, 54, 53, 52, 51, 50,
                                          49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 31, 30, 29,
                                          28, 27, 26, 25, 23, 22, 21, 20, 19, 17, 16, 15, 14, 12, 11, 10, 9, 7, 6, 5,
                                          3, 2, 1
                                        } ;
    
    
    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 an_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 an_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;
        int32_t k, n_i_ratio_count;
        int32_t i, n_exact_ir_valley_locs_count, n_middle_idx;
        int32_t n_th1, n_npks;
        int32_t an_ir_valley_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 ;
    
        // calculates DC mean and subtract DC from ir
        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 ;
    
        // remove DC and invert signal so that we can use peak detector as valley detector
        for (k = 0 ; k < n_ir_buffer_length ; k++ )
            an_x[k] = -1 * (pun_ir_buffer[k] - un_ir_mean) ;
    
        // 4 pt Moving Average
        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]) / (int)4;
        }
        // calculate threshold
        n_th1 = 0;
        for ( k = 0 ; k < BUFFER_SIZE ; k++)
        {
            n_th1 +=  an_x[k];
        }
        n_th1 =  n_th1 / ( BUFFER_SIZE);
        if( n_th1 < 30) n_th1 = 30; // min allowed
        if( n_th1 > 60) n_th1 = 60; // max allowed
    
        for ( k = 0 ; k < 15; k++) an_ir_valley_locs[k] = 0;
        // since we flipped signal, we use peak detector as vSalley detector
        maxim_find_peaks( an_ir_valley_locs, &n_npks, an_x, BUFFER_SIZE, n_th1, 4, 15 );//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_ir_valley_locs[k] - an_ir_valley_locs[k - 1] ) ;
            n_peak_interval_sum = n_peak_interval_sum / (n_npks - 1);
            *pn_heart_rate = (int32_t)( (FS * 60) / n_peak_interval_sum );
            *pch_hr_valid  = 1;
        }
        else
        {
            *pn_heart_rate = -999; // unable to calculate because # of peaks are too small
            *pch_hr_valid  = 0;
        }
    
        //  load raw value again for SPO2 calculation : RED(=y) and IR(=X)
        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 = n_npks;
    
        //using exact_ir_valley_locs , find ir-red DC andir-red AC for SPO2 calibration an_ratio
        //finding AC/DC maximum of raw
    
        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_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 an_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_ir_valley_locs[k + 1] - an_ir_valley_locs[k] > 3)
            {
                for (i = an_ir_valley_locs[k]; i < an_ir_valley_locs[k + 1]; i++)
                {
                    if (an_x[i] > n_x_dc_max)
                    {
                        n_x_dc_max = an_x[i];
                        n_x_dc_max_idx = i;
                    }
                    if (an_y[i] > n_y_dc_max)
                    {
                        n_y_dc_max = an_y[i];
                        n_y_dc_max_idx = i;
                    }
                }
                n_y_ac = (an_y[an_ir_valley_locs[k + 1]] - an_y[an_ir_valley_locs[k] ] ) * (n_y_dc_max_idx - an_ir_valley_locs[k]); //red
                n_y_ac =  an_y[an_ir_valley_locs[k]] + n_y_ac / (an_ir_valley_locs[k + 1] - an_ir_valley_locs[k])  ;
                n_y_ac =  an_y[n_y_dc_max_idx] - n_y_ac;   // subracting linear DC compoenents from raw
                n_x_ac = (an_x[an_ir_valley_locs[k + 1]] - an_x[an_ir_valley_locs[k] ] ) * (n_x_dc_max_idx - an_ir_valley_locs[k]); // ir
                n_x_ac =  an_x[an_ir_valley_locs[k]] + n_x_ac / (an_ir_valley_locs[k + 1] - an_ir_valley_locs[k]);
                n_x_ac =  an_x[n_y_dc_max_idx] - n_x_ac;     // subracting linear DC compoenents from raw
                n_nume = ( n_y_ac * n_x_dc_max) >> 7 ; //prepare X100 to preserve floating value
                n_denom = ( n_x_ac * n_y_dc_max) >> 7;
                if (n_denom > 0  && n_i_ratio_count < 5 &&  n_nume != 0)
                {
                    an_ratio[n_i_ratio_count] = (n_nume * 100) / n_denom ; //formular is ( n_y_ac *n_x_dc_max) / ( n_x_ac *n_y_dc_max) ;
                    n_i_ratio_count++;
                }
            }
        }
        // choose median value since PPG signal may varies from beat to beat
        maxim_sort_ascend(an_ratio, n_i_ratio_count);
        n_middle_idx = n_i_ratio_count / 2;
    
        if (n_middle_idx > 1)
            n_ratio_average = ( an_ratio[n_middle_idx - 1] + an_ratio[n_middle_idx]) / 2; // use median
        else
            n_ratio_average = an_ratio[n_middle_idx ];
    
        if( n_ratio_average > 2 && n_ratio_average < 184)
        {
            n_spo2_calc = uch_spo2_table[n_ratio_average] ;
            *pn_spo2 = n_spo2_calc ;
            *pch_spo2_valid  = 1;//  float_SPO2 =  -45.060*n_ratio_average* n_ratio_average/10000 + 30.354 *n_ratio_average/100 + 94.845 ;  // for comparison with table
        }
        else
        {
            *pn_spo2 =  -999 ; // do not use SPO2 since signal an_ratio is out of range
            *pch_spo2_valid  = 0;
        }
    }
    
    
    void maxim_find_peaks( int32_t *pn_locs, int32_t *n_npks,  int32_t  *pn_x, int32_t n_size, int32_t n_min_height, int32_t n_min_distance, int32_t n_max_num )
    /**
    * \brief        Find peaks
    * \par          Details
    *               Find at most MAX_NUM peaks above MIN_HEIGHT separated by at least MIN_DISTANCE
    *
    * \retval       None
    */
    {
        maxim_peaks_above_min_height( pn_locs, n_npks, pn_x, n_size, n_min_height );
        maxim_remove_close_peaks( pn_locs, n_npks, pn_x, n_min_distance );
        *n_npks = min( *n_npks, n_max_num );
    }
    
    void maxim_peaks_above_min_height( int32_t *pn_locs, int32_t *n_npks,  int32_t  *pn_x, int32_t n_size, int32_t n_min_height )
    /**
    * \brief        Find peaks above n_min_height
    * \par          Details
    *               Find all peaks above MIN_HEIGHT
    *
    * \retval       None
    */
    {
        int32_t i = 1, riseFound = 0, holdOff1 = 0, holdOff2 = 0, holdOffThresh = 4;
        *n_npks = 0;
    
        while (i < n_size - 1)
        {
            if (holdOff2 == 0)
            {
                if (pn_x[i] > n_min_height && pn_x[i] > pn_x[i - 1])     // find left edge of potential peaks
                {
                    riseFound = 1;
                }
                if (riseFound == 1)
                {
                    if ((pn_x[i] < n_min_height) && (holdOff1 < holdOffThresh))     // if false edge
                    {
                        riseFound = 0;
                        holdOff1 = 0;
                    }
                    else
                    {
                        if (holdOff1 == holdOffThresh)
                        {
                            if ((pn_x[i] < n_min_height) && (pn_x[i - 1] >= n_min_height))
                            {
                                if ((*n_npks) < 15 )
                                {
                                    pn_locs[(*n_npks)++] = i;   // peak is right edge
                                }
                                holdOff1 = 0;
                                riseFound = 0;
                                holdOff2 = 8;
                            }
                        }
                        else
                        {
                            holdOff1 = holdOff1 + 1;
                        }
                    }
                }
            }
            else
            {
                holdOff2 = holdOff2 - 1;
            }
            i++;
        }
    }
    
    void maxim_remove_close_peaks(int32_t *pn_locs, int32_t *pn_npks, int32_t *pn_x, int32_t n_min_distance)
    /**
    * \brief        Remove peaks
    * \par          Details
    *               Remove peaks separated by less than MIN_DISTANCE
    *
    * \retval       None
    */
    {
    
        int32_t i, j, n_old_npks, n_dist;
    
        /* Order peaks from large to small */
        maxim_sort_indices_descend( pn_x, pn_locs, *pn_npks );
    
        for ( i = -1; i < *pn_npks; i++ )
        {
            n_old_npks = *pn_npks;
            *pn_npks = i + 1;
            for ( j = i + 1; j < n_old_npks; j++ )
            {
                n_dist =  pn_locs[j] - ( i == -1 ? -1 : pn_locs[i] ); // lag-zero peak of autocorr is at index -1
                if ( n_dist > n_min_distance || n_dist < -n_min_distance )
                    pn_locs[(*pn_npks)++] = pn_locs[j];
            }
        }
    
        // Resort indices int32_to ascending order
        maxim_sort_ascend( pn_locs, *pn_npks );
    }
    
    void maxim_sort_ascend(int32_t  *pn_x, int32_t n_size)
    /**
    * \brief        Sort array
    * \par          Details
    *               Sort array in ascending order (insertion sort algorithm)
    *
    * \retval       None
    */
    {
        int32_t i, j, n_temp;
        for (i = 1; i < n_size; i++)
        {
            n_temp = pn_x[i];
            for (j = i; j > 0 && n_temp < pn_x[j - 1]; j--)
                pn_x[j] = pn_x[j - 1];
            pn_x[j] = n_temp;
        }
    }
    
    void maxim_sort_indices_descend(  int32_t  *pn_x, int32_t *pn_indx, int32_t n_size)
    /**
    * \brief        Sort indices
    * \par          Details
    *               Sort indices according to descending order (insertion sort algorithm)
    *
    * \retval       None
    */
    {
        int32_t i, j, n_temp;
        for (i = 1; i < n_size; i++)
        {
            n_temp = pn_indx[i];
            for (j = i; j > 0 && pn_x[n_temp] > pn_x[pn_indx[j - 1]]; j--)
                pn_indx[j] = pn_indx[j - 1];
            pn_indx[j] = n_temp;
        }
    }
    
    
    
    
    
    

    点这里:源工程文件下载地址

    展开全文
  • 使用da14580 ARM 芯片和心率血氧芯片MAX30102,采集人体心率血氧(Use da14580 chip and MAX30102,Collect the HEARD_RATE AND OXYGEN)
  • 原来的描述:MAX30102心率血氧显示例程,keil-MDK,C语言,裸机代码,包含计算心率血氧的算法。移植自美信官方例程。 最近需要用stm32做心率血氧测试,找了下要么是只有芯片驱动没有算法,要么是美信的官方例程,而...
  • MAX30102芯片心率血氧传感器模块传感器模块软硬件设计资料包括STM32测试源码AD设计原理图及心率血氧参考设计资料: 参考代码及实验数据 工程文件及库 心率血氧参考设计资料 芯片数据手册 1771.pdf 2ES Teck PEMS ...
  • 利用stm32单片机和max30102传感器实现测量心率血氧
  • 心率血氧MAX30102模块资料

    千次阅读 热门讨论 2020-02-21 14:44:52
    心率血氧MAX30102模块资料 话不多说,上链接: 链接:https://pan.baidu.com/s/1L0ggBInD8XZUIjypgbl6JA 提取码:q8am

    心率血氧MAX30102模块资料

    在这里插入图片描述
    话不多说,上链接:
    链接:https://pan.baidu.com/s/1L0ggBInD8XZUIjypgbl6JA
    提取码:q8am

    展开全文
  • MAX30102芯片+心率血氧传感器模块+传感器模块
  • adpd44RI心率血氧采集

    2020-05-06 16:34:41
    求助adpd44RI心率血氧采集嵌入式代码,初学者,现在拥有这个芯片,但是不知道怎么驱动,芯片手册上也写的很模糊,关于 怎么获取数据没有提到,只有配置寄存器的操作,有没有人搞过这个? ...

    求助adpd44RI心率血氧采集嵌入式代码,初学者,现在拥有这个芯片,但是不知道怎么驱动,芯片手册上也写的很模糊,关于

    怎么获取数据没有提到,只有配置寄存器的操作,有没有人搞过这个?

    展开全文
  • 心率血氧算法代码 algorithm.h /** \file algorithm.h ****************************************************** * * Project: MAXREFDES117# * Filename: algorithm.h * Description: This module is the heart ...
  • 使用一块0.96单色OLED显示心率波形。基于RT-Thread操作系统实现,RT-Thread部分源码未包含,需自行添加或使用SCONS构建。演示视频见:https://www.bilibili.com/video/BV1kb4y1R72T/
  • 2.心率血氧模块:天易合芯hx3690 iic通信时,发现总是失败,但是用逻辑分析仪捕捉iic信号是正常,通信也成功。用万能表探头接触时也正常,最后发现探头接触模块的电源和地时,通信成功。最后硬件工程师确认模块供电...
  • 之前对MAX30100的心率血氧浓度传感器进行了驱动,后来由于项目需要,所以开发了MAX30102心率模块的驱动,话不多说,直接贴代码 [ *-* ] MAX30102.c文件: /* MAX30102.c */ /*==================================...
  • max30102开发组件以及例程,非中文资料,谨慎下载,本人想知道有咩有max30102与51的例程
  • MAX301002心率血氧代码

    2017-12-05 17:04:45
    基于stm32f103zet6平台写的max301002模块的驱动,使用模拟iic
  • 在自己学习中发现这个文档很有作用,现在推广,希望帮到跟多的人
  • 主要通过iic配置max30102寄存器 通过iic读取红外值,和中断值,通过解算得出心率血氧,这个传感器有个很大的坑就是算法定义的数组太大 太吃内存了,有个投机解决方法具体在我的主页 看我博客
  • max30102中文翻译文档,亲自使用准确率高,适合开发参考。值得下载看看。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 969
精华内容 387
关键字:

心率血氧