设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › STM32F103单片机使用MAX30102测量心率血氧源程序
返回列表 发新帖
查看: 907|回复: 0
收起左侧

STM32F103单片机使用MAX30102测量心率血氧源程序

[复制链接]
ID:910507 发表于 2024-4-28 10:15 | 显示全部楼层 |阅读模式
单片机源程序如下:
  1. #include "stm32f10x.h"                  // Device header
  2. #include "software_IIC.h"
  3. #include "MAX30102.h"
  4. #include "MAX30102_algorithm.h"
  5. #include "OLED.h"
  6. #include "Key.h"
  7. #include "Delay.h"
  8. #define MAX_BRIGHTNESS 255

  10. uint16_t fifo_red;
  11. uint16_t fifo_ir;



  15. void MAX30102_Init(void)
  16. {
  17.         IIC_GPIO_Init();                                                                        //先初始化底层的I2C
  18.        
  19.         /*MAX30102寄存器初始化，需要对照MAX30102手册的寄存器描述配置，此处仅配置了部分重要的寄存器*/
  20.         IIC_WriteReg(MAX30102_ADDRESS,REG_MODE_CONFIG, 0x40);   //将RESET位设置为1，所有配置、阈值和数据寄存器通过上电复位复位复位到其上电状态。
  21.         IIC_WriteReg(MAX30102_ADDRESS,REG_INTR_ENABLE_1, 0x00);        //不使用中断       
  22.         IIC_WriteReg(MAX30102_ADDRESS,REG_INTR_ENABLE_2, 0x00);               
  23.         IIC_WriteReg(MAX30102_ADDRESS,REG_FIFO_WR_PTR,0x00);        //FIFO写入指针为0               
  24.         IIC_WriteReg(MAX30102_ADDRESS,REG_OVF_COUNTER,0x00);    //溢出数据计数器为0
  25.         IIC_WriteReg(MAX30102_ADDRESS,REG_FIFO_RD_PTR,0x00);    //FIFO读取指针为0
  26.         IIC_WriteReg(MAX30102_ADDRESS,REG_FIFO_CONFIG,0x0f);    //0x0f设置平均取样为4,当FIFO完全充满数据时,FIFO地址滚动到零并且FIFO继续填充新数据。
  27.         IIC_WriteReg(MAX30102_ADDRESS,REG_MODE_CONFIG,0x03);    //SpO2模式
  28.         IIC_WriteReg(MAX30102_ADDRESS,REG_SPO2_CONFIG,0x27);    //0x45ADC量程为8192,采样率为100/s,LED占空比118us,对应采样精度16bit
  29.         IIC_WriteReg(MAX30102_ADDRESS,REG_LED1_PA,0x20);
  30.         IIC_WriteReg(MAX30102_ADDRESS,REG_LED2_PA,0x20);
  31.         IIC_WriteReg(MAX30102_ADDRESS,REG_PILOT_PA,0x7F);
  32.                
  33. }

  35. void MAX30102_IIC_ReadReg(uint8_t slave_ID,uint8_t RegAddress)  //读取6个字节
  36. {
  37.     fifo_red=0;
  38.     fifo_ir=0;
  39.         uint16_t Data1,Data2,Data3,Data4,Data5,Data6;
  40.        
  41.         IIC_Start();                                                //I2C起始
  42.         IIC_SendByte(slave_ID);        //发送从机地址，读写位为0，表示即将写入
  43.         IIC_ReceiveAck();                                        //接收应答
  44.         IIC_SendByte(RegAddress);                        //发送寄存器地址
  45.         IIC_ReceiveAck();                                        //接收应答
  46.        
  47.         IIC_Start();                                                //I2C重复起始
  48.         IIC_SendByte(slave_ID | 0x01);        //发送从机地址，读写位为1，表示即将读取
  49.         IIC_ReceiveAck();                                        //接收应答
  50.         Data1 = IIC_ReceiveByte();                        //接收指定寄存器的数据
  51.         IIC_SendAck(0);                                        //发送应答，给从机非应答，终止从机的数据输出
  52.         Data2 = IIC_ReceiveByte();
  53.         IIC_SendAck(0);       
  54.         Data3 = IIC_ReceiveByte();
  55.         IIC_SendAck(0);
  56.         Data4 = IIC_ReceiveByte();                        //接收指定寄存器的数据
  57.         IIC_SendAck(0);                                        //发送应答，给从机非应答，终止从机的数据输出
  58.         Data5 = IIC_ReceiveByte();
  59.         IIC_SendAck(0);       
  60.         Data6 = IIC_ReceiveByte();
  61.         IIC_SendAck(1);
  62.         IIC_Stop();       
  63.         //I2C终止
  64.         Data1 <<= 14;
  65.     fifo_red+=Data1;
  66.         Data2 <<= 6;
  67.     fifo_red+=Data2;
  68.         Data3 >>= 2;
  69.     fifo_red+=Data3;
  70.        
  71.         Data4 <<= 14;
  72.     fifo_ir+=Data4;
  73.         Data5 <<= 6;
  74.     fifo_ir+=Data5;
  75.         Data6 >>= 2;
  76.     fifo_ir+=Data6;
  77.        
  78.         if(fifo_ir<=10000)
  79.         {
  80.                 fifo_ir=0;
  81.         }
  82.         if(fifo_red<=10000)
  83.         {
  84.                 fifo_red=0;
  85.         }
  86. }

  88. int8_t menu_Back_event(void)//菜单返回
  89. {
  90.         return Key_Back_Get();;                                //返回键接到PA2;
  91. }

  93. void SPO2_function(void)
  94. {
  95.        
  96.         OLED_Clear();
  97.         OLED_ShowChinese(46,0,"血");
  98.         OLED_ShowChinese(62,0,"氧");
  99.         OLED_ShowChinese(78,0,"检");
  100.         OLED_ShowChinese(94,0,"测");
  101.         MAX30102_Init();                     //初始化MAX30102
  102.         OLED_ShowImage(0,0,22,8,qipaoup);    //显示左上方固定的石头块
  103.         OLED_ShowImage(0,56,22,8,qipaodown); //显示左下方固定的石头块
  104.         OLED_Update();
  105.         uint8_t j=128;                       //定义鱼的起始X坐标
  106.         uint8_t ave_Count = 1;               //为了获取10个最终得到的血氧值,设置计数器,(可以更改,值越大测量时间越长，获取数据越多)
  107.         uint16_t cal_ave[10];                //定义长度为10的数组存储10个检测数据
  108.         uint16_t ave_Sum = 0;                //存储10个数据的和
  109.         uint8_t cal_Sum_lock = 0;            //总和计算器锁
  110.     while(1)
  111.    {
  112.                         /*-------------------------移动气泡的程序逻辑------------------------------*/
  113.                 uint8_t i;
  114.                 for(i = 0;i <= 16;i++)
  115.                 {
  116.                         OLED_ClearArea(0,8,22,48);
  117.                         OLED_ShowImage(1,49-i,7,7,qipao);   
  118.                         OLED_ShowImage(1,33-i,7,7,qipao);
  119.         if(i<17)
  120.                 {
  121.                         OLED_ShowImage(1,17-i,7,7,qipao);
  122.                         OLED_ShowImage(0,0,22,8,qipaoup);
  123.                 }       
  124.                         OLED_ShowImage(13,56-i,7,7,qipao);
  125.                         OLED_ShowImage(13,40-i,7,7,qipao);
  126.                         OLED_ShowImage(13,24-i,7,7,qipao);
  127.                 /*-------------------------移动鱼的程序逻辑------------------------------*/
  128.                 if(j<=0)
  129.                 {
  130.                         j = 128;
  131.                         OLED_ClearArea(22,49,106,15);    //清除小鱼游过后的全屏尾迹
  132.                 }
  133.                         OLED_ShowImage(j,49,15,15,Fish);
  134.                         OLED_ClearArea(j+15,49,106,15);    //解除注释可以实时清除小鱼尾迹
  135.                         OLED_ShowImage(0,56,22,8,qipaodown); //刷新左下角石头块,让小鱼从石头快后边游过,注释后会从石头块前方游过
  136.                         j--;
  137.                         Delay_ms(5);        //控制动画移动速度
  138.                         OLED_Update();
  139.                 }
  140.                 if(ave_Count<=10)
  141.                 {
  142.                     blood_Loop();
  143.                         if(SPO2dataResult != 0)
  144.             {
  145.                         OLED_ClearArea(22,16,106,32);
  146.                         OLED_ShowChinese(54,17,"检");
  147.                 OLED_ShowChinese(70,17,"测");
  148.                     OLED_ShowChinese(86,17,"中");                               
  149.                         cal_ave[ave_Count-1] = SPO2dataResult;
  150.                         ave_Count++;
  151.                         }else{
  152.                                     OLED_ClearArea(22,16,106,32);
  153.                                     OLED_ShowChinese(54,16,"请");
  154.                             OLED_ShowChinese(70,16,"正");
  155.                             OLED_ShowChinese(86,16,"确");
  156.                             OLED_ShowChinese(54,32,"佩");
  157.                             OLED_ShowChinese(70,32,"戴");
  158.                             OLED_ShowChar(90,32,'!',OLED_8X16);
  159.                              }
  160.                 }else
  161.                 {
  162.                     ave_Count = 11;   //得到10个数据后将计数器值固定到11防止溢出
  163.                         uint8_t i;
  164.                         uint16_t min;
  165.                         for(i = 0;i<9;i++)                   //取出最小值
  166.                         {
  167.                                 if(i == 0){min = cal_ave[0];}    //
  168.                           if(cal_ave[i+1]<min)
  169.                           {
  170.                           min = cal_ave[i+1];
  171.                           }
  172.                         }
  173.                         if(cal_Sum_lock == 0)
  174.                         {
  175.                                  for(i = 0;i<10;i++)
  176.                                  {
  177.                                       ave_Sum += cal_ave[i];    //计算0个数据的和
  178.                                  }  
  179.                                          cal_Sum_lock = 1;          //和计算一次后打开锁,防止多次累加
  180.                     }
  181.                         OLED_ClearArea(22,17,106,32);
  182.                         OLED_ShowNum(49,17,(ave_Sum-min)/9 + 3,3,OLED_15X24);  //显示最终结果
  183.                         OLED_ShowChar(96,17,0x3A,OLED_15X24);
  184.                 }
  185.             
  186.                 if(menu_Back_event())   //检测按键按下
  187.         {
  188.                         break;
  189.                 }       
  190.    }
  191. }

  193. void Heart_function(void)
  194. {
  195.        
  196.         OLED_Clear();
  197.         OLED_ShowChinese(32,0,"心");
  198.         OLED_ShowChinese(48,0,"率");
  199.         OLED_ShowChinese(64,0,"检");
  200.         OLED_ShowChinese(80,0,"测");
  201.         OLED_Update();
  202.         MAX30102_Init();
  203.        
  204.         uint8_t ave_Count = 1;               //为了获取10个最终得到的心率，设置计数器
  205.         uint16_t cal_ave[10];                //定义长度为10的数组存储测量的10个心率数据
  206.         uint16_t ave_Sum = 0;                //存储10个数据的和
  207.         uint8_t cal_Sum_lock = 0;            //总和计算器锁
  208.         while(1)
  209.         {
  210.                 OLED_ClearArea(0,20,64,44);
  211.                 OLED_ShowImage(0,20,54,49,Heart1);
  212.                 OLED_Update();
  213.                 Delay_ms(10);
  214.                 OLED_ClearArea(0,20,64,44);
  215.                 OLED_ShowImage(0,20,54,49,Heart2);
  216.                 OLED_Update();
  217.                 Delay_ms(10);
  218.                 OLED_ClearArea(0,20,64,44);
  219.                 OLED_ShowImage(0,20,54,49,Heart3);
  220.                 OLED_Update();
  221.                 Delay_ms(10);
  222.                 OLED_ClearArea(0,20,64,44);
  223.                 OLED_ShowImage(0,20,54,49,Heart4);
  224.                 OLED_Update();
  225.                 Delay_ms(10);
  226.                 OLED_ClearArea(0,20,64,44);
  227.                 OLED_ShowImage(0,20,54,49,Heart5);
  228.                 OLED_Update();
  229.                 Delay_ms(10);
  230.                 OLED_ClearArea(0,20,64,44);
  231.                 OLED_ShowImage(0,20,54,49,Heart6);
  232.                 OLED_Update();
  233.                 Delay_ms(10);
  234.                 OLED_ClearArea(0,20,64,44);
  235.                 OLED_ShowImage(0,20,54,49,Heart7);
  236.                 OLED_Update();
  237.                 Delay_ms(10);
  238.                 OLED_ClearArea(0,20,64,44);
  239.                 OLED_ShowImage(0,20,54,49,Heart8);
  240.                 OLED_Update();
  241.                 Delay_ms(10);
  242.                 OLED_ClearArea(0,20,64,44);
  243.                 OLED_ShowImage(0,20,54,49,Heart7);
  244.                 OLED_Update();
  245.                 Delay_ms(10);
  246.                 OLED_ClearArea(0,20,64,44);
  247.                 OLED_ShowImage(0,20,54,49,Heart6);
  248.                 OLED_Update();
  249.                 Delay_ms(10);
  250.                 OLED_ClearArea(0,20,64,44);
  251.                 OLED_ShowImage(0,20,54,49,Heart5);
  252.                 OLED_Update();
  253.                 Delay_ms(10);
  254.                 OLED_ClearArea(0,20,64,44);
  255.                 OLED_ShowImage(0,20,54,49,Heart4);
  256.                 OLED_Update();
  257.                 Delay_ms(10);
  258.                 OLED_ClearArea(0,20,64,44);
  259.                 OLED_ShowImage(0,20,54,49,Heart3);
  260.                 OLED_Update();
  261.                 Delay_ms(10);
  262.                 OLED_ClearArea(0,20,64,44);
  263.                 OLED_ShowImage(0,20,54,49,Heart2);
  264.                 OLED_Update();
  265.                 Delay_ms(10);
  266.                 OLED_ClearArea(0,20,64,44);
  267.                 OLED_ShowImage(0,20,54,49,Heart1);
  268.                 OLED_Update();
  269.                 //blood_Loop();
  270.                 OLED_ClearArea(64,20,64,44);
  271.         if(ave_Count<=10)
  272.                 {
  273.                     blood_Loop();
  274.                         if(SPO2dataResult != 0)
  275.             {
  276.                         OLED_ClearArea(64,16,64,44);
  277.                         OLED_ShowChinese(64,17,"测");
  278.                 OLED_ShowChinese(80,17,"量");
  279.                     OLED_ShowChinese(96,17,"中");
  280.             //OLED_ShowNum(64,17,HeartdataResult,3,OLED_13X24);                               
  281.                         cal_ave[ave_Count-1] = HeartdataResult;
  282.                         ave_Count++;
  283.                         }
  284.                         else
  285.                         {
  286.                                     OLED_ClearArea(64,16,64,44);
  287.                                     OLED_ShowChinese(64,16,"请");
  288.                             OLED_ShowChinese(80,16,"正");
  289.                             OLED_ShowChinese(96,16,"确");
  290.                             OLED_ShowChinese(64,32,"佩");
  291.                             OLED_ShowChinese(80,32,"戴");
  292.                             OLED_ShowChar(100,32,'!',OLED_8X16);
  293.                          }
  294.                 }
  295.                 else
  296.                 {
  297.                     ave_Count = 11;   //得到10个数据后将计数器固定到11防止溢出
  298.                         uint8_t i;
  299.                         uint16_t max;
  300.                         for(i = 0;i<9;i++)                   //取出最大值
  301.                         {
  302.                                 if(i == 0){max = cal_ave[0];}    //
  303.                           if(cal_ave[i+1]>max)
  304.                           {
  305.                           max = cal_ave[i+1];
  306.                           }
  307.                         }
  308.                         if(cal_Sum_lock == 0)
  309.                         {
  310.                                  for(i = 0;i<10;i++)
  311.                                  {
  312.                                       ave_Sum += cal_ave[i];    //计算10个数据的和
  313.                                  }  
  314.                                          cal_Sum_lock = 1;          //和计算一次后打开锁，防止多次计算
  315.                     }
  316.                         OLED_ClearArea(22,17,106,32);
  317.                         OLED_ShowNum(64,17,(ave_Sum-max)/9,3,OLED_15X24);  //显示最终结果
  318.                         Delay_ms(200);
  319.       }
  320.                 if(menu_Back_event())   //检测按键按下
  321.         {
  322.                  break;
  323.                 }
  324.     }
  325. }
复制代码

原理图: 无
仿真: 无
代码: 心率血氧检测.7z (198.14 KB, 下载次数: 30)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 赞一个！

查看全部评分

回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表