找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 4652|回复: 2
收起左侧

基于stc89c52的心率测试程序

[复制链接]
ID:205792 发表于 2017-5-29 11:02 | 显示全部楼层 |阅读模式
基于stc89c52的心率测试程序
0.png
0.png 0.png

单片机源程序如下:
  1. #include <reg52.h>
  2. #include <intrins.h>         //                         包含头文件

  3. #define uint            unsigned int
  4. #define uchar           unsigned char
  5. #define ulong           unsigned long         //宏定义
  6. #define LCD_DATA        P0                                 //定义P0口为LCD_DATA

  7. sbit LCD_RS =P2^5;
  8. sbit LCD_RW =P2^6;
  9. sbit LCD_E  =P2^7;                                                 //定义LCD控制引脚

  10. sbit Xintiao =P3^2 ;                                         //脉搏检测输入端定义
  11. sbit speaker =P2^4;                                                 //蜂鸣器引脚定义

  12. void delay5ms(void);   //误差 0us
  13. void LCD_WriteData(uchar LCD_1602_DATA);         /********LCD1602数据写入***********/
  14. void LCD_WriteCom(uchar LCD_1602_COM);                 /********LCD1602命令写入***********/
  15. void lcd_1602_word(uchar Adress_Com,uchar Num_Adat,uchar *Adress_Data); /*1602字符显示函数,变量依次为字符显示首地址,显示字符长度,所显示的字符*/
  16. void InitLcd();//液晶初始化函数

  17. void Tim_Init();

  18. uchar Xintiao_Change=0;           //
  19. uint  Xintiao_Jishu;
  20. uchar stop;
  21. uchar View_Data[3];
  22. uchar View_L[3];
  23. uchar View_H[3];
  24. uchar Xintiao_H=100;        //脉搏上限
  25. uchar Xintiao_L=40;                //脉搏下限


  26. uchar Key_Change;
  27. uchar Key_Value;                //按键键值
  28. uchar View_Con;                        //设置的位(0正常工作,1设置上限,2设置下限)
  29. uchar View_Change;

  30. void main()          //主函数
  31. {
  32.         InitLcd();
  33.         Tim_Init();
  34.         lcd_1602_word(0x80,16,"Heart Rate:     ");          //初始化显示
  35.         TR0=1;
  36.         TR1=1;                                  //打开定时器
  37.         while(1)                          //进入循环
  38.         {
  39.                 if(Key_Change)          //有按键按下并已经得出键值
  40.                 {
  41.                         Key_Change=0;          //将按键使能变量清零,等待下次按键按下
  42.                         View_Change=1;
  43.                         switch(Key_Value)                                //判断键值
  44.                         {
  45.                                 case 1:                                                //设置键按下
  46.                                 {
  47.                                         View_Con++;                        //设置的位加
  48.                                         if(View_Con>=3)                //都设置好后将此变量清零
  49.                                         View_Con=0;
  50.                                         break;                                //跳出,下同
  51.                                 }
  52.                                 case 2:                                                //加键按下
  53.                                 {
  54.                                         if(View_Con==2)                //判断是设置上限
  55.                                         {
  56.                                                 if(Xintiao_H<150)        //上限数值小于150
  57.                                                 Xintiao_H++;                //上限+
  58.                                         }
  59.                                         if(View_Con==1)                //如果是设置下限
  60.                                         {
  61.                                                 if(Xintiao_L<Xintiao_H)//下限值小于上限(下限值不能超过上限)
  62.                                                 Xintiao_L++;                //下限值加
  63.                                         }
  64.                                         break;
  65.                                 }
  66.                                 case 3:                                                //减键按下
  67.                                 {
  68.                                         if(View_Con==2)                //设置上限
  69.                                         {
  70.                                                 if(Xintiao_H>Xintiao_L)//上限数据大于下限(同样上限值不能小于下限)
  71.                                                 Xintiao_H--;                //上限数据减
  72.                                         }
  73.                                         if(View_Con==1)                //设置下限
  74.                                         {
  75.                                                 if(Xintiao_L>30)        //下限数据大于30时
  76.                                                 Xintiao_L--;                //下限数据减
  77.                                         }
  78.                                         break;
  79.                                 }
  80.                         }
  81.                 }
  82.                 if(View_Change)//显示变量
  83.                 {
  84.                         View_Change=0;//变量清零
  85.                         if(stop==0)                          //心率正常时
  86.                         {
  87.                                 if(View_Data[0]==0x30) //最高位为0时不显示
  88.                                 View_Data[0]=' ';
  89.                         }
  90.                         else                                          //心率不正常(计数超过5000,也就是两次信号时间超过5s)不显示数据
  91.                         {
  92.                                 View_Data[0]=' ';
  93.                                 View_Data[1]=' ';
  94.                                 View_Data[2]=' ';
  95.                         }
  96.                         switch(View_Con)
  97.                         {
  98.                                 case 0: //正常显示
  99.                                 {
  100.                                         lcd_1602_word(0x80,16,"Heart Rate:     ");//显示一行数据
  101.                                         lcd_1602_word(0xc0,16,"                ");//显示第二行数据
  102.                                         lcd_1602_word(0xcd,3,View_Data);                         //第二行显示心率
  103.                                         break;
  104.                                 }
  105.                                 case 1: //设置下限时显示
  106.                                 {
  107.                                         lcd_1602_word(0x80,16,"Heart Rate:     ");//第一行显示心率
  108.                                         lcd_1602_word(0x8d,3,View_Data);
  109.                                        
  110.                                         View_L[0]=Xintiao_L/100+0x30;                //将下限数据拆字
  111.                                         View_L[1]=Xintiao_L%100/10+0x30;
  112.                                         View_L[2]=Xintiao_L%10+0x30;
  113.                                        
  114.                                         if(View_L[0]==0x30)                                        //最高位为0时,不显示
  115.                                         View_L[0]=' ';
  116.         
  117.                                         lcd_1602_word(0xC0,16,"Warning L :     ");//第二行显示下限数据
  118.                                         lcd_1602_word(0xCd,3,View_L);
  119.                                         break;
  120.                                 }
  121.                                 case 2: //设置上限时显示(同上)
  122.                                 {
  123.                                         lcd_1602_word(0x80,16,"Heart Rate:     ");
  124.                                         lcd_1602_word(0x8d,3,View_Data);
  125.                                        
  126.                                         View_H[0]=Xintiao_H/100+0x30;
  127.                                         View_H[1]=Xintiao_H%100/10+0x30;
  128.                                         View_H[2]=Xintiao_H%10+0x30;
  129.                                        
  130.                                         if(View_H[0]==0x30)
  131.                                         View_H[0]=' ';
  132.                                        
  133.                                         lcd_1602_word(0xC0,16,"Warning H :     ");
  134.                                         lcd_1602_word(0xCd,3,View_H);
  135.                                         break;
  136.                                 }
  137.                         }
  138.                 }
  139.         }
  140. }

  141. void Time1() interrupt 3                //定时器1服务函数
  142. {
  143.         static uchar Key_Con,Xintiao_Con;
  144.         TL1=0xd8;                   //10ms
  145.         TH1=0xf0;                   //重新赋初值
  146.         switch(Key_Con)   //无按键按下时此值为0
  147.         {
  148.                 case 0:                   //每10ms扫描此处
  149.                 {
  150.                         if((P1&0xf7)!=0xf7)//扫描按键是否有按下
  151.                         {
  152.                                 Key_Con++;                  //有按下此值加1,值为1
  153.                         }
  154.                         break;
  155.                 }
  156.                 case 1:                                          //10ms后二次进入中断后扫描此处(Key_Con为1)
  157.                 {
  158.                         if((P1&0xf7)!=0xf7)//第二次进入中断时,按键仍然是按下(起到按键延时去抖的作用)
  159.                         {
  160.                                 Key_Con++;                  //变量加1,值为2
  161.                                 switch(P1&0xf7)  //判断是哪个按键按下
  162.                                 {
  163.                                         case 0x06:Key_Value=1;break;         //判断好按键后将键值赋值给变量Key_Value
  164.                                         case 0x05:Key_Value=2;break;
  165.                                         case 0x03:Key_Value=3;break;
  166.                                 }
  167.                         }
  168.                         else                                                                 //如果10ms时没有检测到按键按下(按下时间过短)
  169.                         {
  170.                                 Key_Con=0;                                                 //变量清零,重新检测按键
  171.                         }
  172.                         break;
  173.                 }
  174.                 case 2:                                                                         //20ms后检测按键
  175.                 {
  176.                         if((P1&0xf7)==0xf7)                                 //检测按键是否还是按下状态
  177.                         {
  178.                                 Key_Change=1;                                         //有按键按下使能变量,(此变量为1时才会处理键值数据)
  179.                                 Key_Con=0;                                                //变量清零,等待下次有按键按下
  180.                         }
  181.                         break;
  182.                 }
  183.         }
  184.         switch (Xintiao_Con)//此处与上面按键的检测类似
  185.         {
  186.                 case 0:                         //默认Xintiao_Con是为0的
  187.                 {
  188.                         if(!Xintiao)//每10ms(上面的定时器)检测一次脉搏是否有信号
  189.                         {
  190.                                 Xintiao_Con++;//如果有信号,变量加一,程序就会往下走了
  191.                         }
  192.                         break;
  193.                 }
  194.                 case 1:
  195.                 {
  196.                         if(!Xintiao)           //每过10ms检测一下信号是否还存在
  197.                         {
  198.                                 Xintiao_Con++;//存在就加一
  199.                         }
  200.                         else
  201.                         {
  202.                                 Xintiao_Con=0;//如果不存在了,检测时间很短,说明检测到的不是脉搏信号,可能是其他干扰,将变量清零,跳出此次检测
  203.                         }
  204.                         break;
  205.                 }
  206.                 case 2:
  207.                 {
  208.                         if(!Xintiao)
  209.                         {
  210.                                 Xintiao_Con++;//存在就加一
  211.                         }
  212.                         else
  213.                         {
  214.                                 Xintiao_Con=0;//如果不存在了,检测时间很短,说明检测到的不是脉搏信号,可能是其他干扰,将变量清零,跳出此次检测
  215.                         }
  216.                         break;
  217.                 }
  218.                 case 3:
  219.                 {
  220.                         if(!Xintiao)
  221.                         {
  222.                                 Xintiao_Con++;//存在就加一
  223.                         }
  224.                         else
  225.                         {
  226.                                 Xintiao_Con=0;//如果不存在了,检测时间很短,说明检测到的不是脉搏信号,可能是其他干扰,将变量清零,跳出此次检测
  227.                         }
  228.                         break;
  229.                 }
  230.                 case 4:
  231.                 {
  232.                         if(Xintiao)//超过30ms一直有信号,判定此次是脉搏信号,执行以下程序
  233.                         {
  234.                                 if(Xintiao_Change==1)//心率计原理为检测两次脉冲间隔时间计算心率,变量Xintiao_Change第一次脉冲时为0的,所有走下面的else,第二次走这里
  235.                                 {
  236.                                         if(60000/Xintiao_Jishu>200)
  237.                                         {
  238.                                                 View_Data[0]='-';        
  239.                                                 View_Data[1]='-';         
  240.                                                 View_Data[2]='-';
  241.                                                 speaker=1;                        //不响        
  242.                                         }
  243.                                         else
  244.                                         {
  245.                                                 View_Data[0]=(60000/Xintiao_Jishu)/100+30;                  //计算心跳并拆字显示:心跳计时是以1ms为单位,两次心跳中间计数如果是1000次,也就是1000*1ms=1000ms=1s
  246.                                                 View_Data[1]=(60000/Xintiao_Jishu)%100/10+30;          //那么计算出的一分钟(60s)心跳数就是:60*1000/(1000*1ms)=60次          其中60是一分钟60s,1000是一秒有1000ms,1000是计数值,1是一次计数对应 的时间是1ms
  247.                                                 View_Data[2]=(60000/Xintiao_Jishu)%10+30;                  //计算出的心跳数/100得到心跳的百位,%100是取余的,就是除以100的余数,再除以10就得到十位了,以此类推
  248.                                                                   //鹱趾蟮牡ジ鍪?0x30的目的是得到对应数字的液晶显示码,数字0对应的液晶显示码是0x30,1是0x30+1,以此类推
  249.                                                 if(((60000/Xintiao_Jishu)>=Xintiao_H)||((60000/Xintiao_Jishu)<=Xintiao_L))//心率不在范围内报警
  250.                                                 speaker=0;                        //蜂鸣器响
  251.                                                 else
  252.                                                 speaker=1;                        //不响
  253.                                         }
  254.                                        
  255.                                         View_Change=1;           //计算出心率后启动显示
  256.                                         Xintiao_Jishu=0;           //心跳计数清零
  257.                                         Xintiao_Change=0;   //计算出心率后该变量清零,准备下次检测心率
  258.                                         stop=0;                           //计算出心率后stop邈
  259.                                 }
  260.                                 else//第一次脉冲时Xintiao_Change为0
  261.                                 {
  262.                                         Xintiao_Jishu=0;        //脉冲计时变量清零,开始计时
  263.                                         Xintiao_Change=1;//Xintiao_Change置1,准备第二次检测到脉冲时计算心率
  264.                                 }
  265.                                 Xintiao_Con=0;        //清零,准备检测下一次脉冲
  266.                                 break;
  267.                         }
  268.                 }
  269.         }
  270. }
  271. /**定时器T0工作函数**/
  272. void Time0() interrupt 1
  273. {
  274.         TL0=0xfc;                   //1ms
  275.         TH0=0x18;                   //重新赋初值
  276.         Xintiao_Jishu++;  //心跳计数加
  277.         if(Xintiao_Jishu==5000)//心跳计数大于5000
  278.         {
  279.                 Xintiao_Jishu=0;                //数据清零
  280.                 View_Change=1;                //显示位置1
  281.                 Xintiao_Change=0;        //置零,准备再次检测
  282.                 stop=1;           //心跳计数超过5000后说明心率不正常或者没有测出,stop置1
  283.                 speaker=1;  //关闭蜂鸣器
  284.         }
  285. }
  286. /**定时器初始化函数**/
  287. void Tim_Init()
  288. {
  289.         EA=1;                          //打开中断总开关
  290.         ET0=1;                          //打开T0中断允许开关
  291.         ET1=1;                          //打开T1中断允许开关
  292.         TMOD=0x11;                  //设定定时器状态
  293.         TL0=0xfc;                   //1ms
  294.         TH0=0x18;                   //赋初值
  295.         
  296.         TL1=0xd8;                   //10ms
  297.         TH1=0xf0;                   //赋初值
  298. }
  299. /**在指定地址显示指定数量的指定字符**/
  300. /**Adress_Com显示地址,Num_Adat显示字符数量,Adress_Data显示字符串内容**/
  301. void lcd_1602_word(uchar Adress_Com,uchar Num_Adat,uchar *Adress_Data)
  302. {
  303.         uchar a=0;
  304.         uchar Data_Word;
  305.         LCD_WriteCom(Adress_Com); //选中地址
  306.         for(a=0;a<Num_Adat;a++)   //for循环决定显示字符个数
  307.         {
  308.                 Data_Word=*Adress_Data;          //读取字符串数据
  309.                 LCD_WriteData(Data_Word);  //显示字符串
  310.                 Adress_Data++;                          //显示地址加一
  311.         }
  312. }

  313. /***************1602函数*******************/
  314. void LCD_WriteData(uchar LCD_1602_DATA)         /********LCD1602数据写入***********/
  315. {
  316.         delay5ms();  //操作前短暂延时,保证信号稳定
  317.         LCD_E=0;
  318.         LCD_RS=1;
  319.         LCD_RW=0;
  320.         _nop_();
  321.         LCD_E=1;
  322.         LCD_DATA=LCD_1602_DATA;
  323. ……………………

  324. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
1-程序注释.zip (57.2 KB, 下载次数: 57)
回复

使用道具 举报

ID:778798 发表于 2020-6-14 11:01 | 显示全部楼层
感谢楼主分享
回复

使用道具 举报

ID:695384 发表于 2020-6-15 10:00 | 显示全部楼层
MAX30102测心率血氧饱和度的代码

#include <Wire.h>
#include "MAX30105.h"
#include "spo2_algorithm.h"

MAX30105 particleSensor;

#define MAX_BRIGHTNESS 255

#if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega168__)
//Arduino Uno doesn't have enough SRAM to store 100 samples of IR led data and red led data in 32-bit format
//To solve this problem, 16-bit MSB of the sampled data will be truncated. Samples become 16-bit data.
uint16_t irBuffer[100]; //infrared LED sensor data
uint16_t redBuffer[100]; //red LED sensor data
#else
uint32_t irBuffer[100]; //infrared LED sensor data
uint32_t redBuffer[100]; //red LED sensor data
#endif

int32_t bufferLength; //data length
int32_t spo2; //SPO2 value
int8_t validSPO2; //indicator to show if the SPO2 calculation is valid
int32_t heartRate; //heart rate value
int8_t validHeartRate; //indicator to show if the heart rate calculation is valid

byte pulseLED = 11; //Must be on PWM pin
byte readLED = 13; //Blinks with each data read

void setup()
{
Serial.begin(115200); // initialize serial communication at 115200 bits per second:

pinMode(pulseLED, OUTPUT);
pinMode(readLED, OUTPUT);

// Initialize sensor
if (!particleSensor.begin(Wire, I2C_SPEED_FAST)) //Use default I2C port, 400kHz speed
{
Serial.println(F("MAX30105 was not found. Please check wiring/power."));
while (1);
}

Serial.println(F("Attach sensor to finger with rubber band. Press any key to start conversion"));
while (Serial.available() == 0) ; //wait until user presses a key
Serial.read();

byte ledBrightness = 60; //Options: 0=Off to 255=50mA
byte sampleAverage = 4; //Options: 1, 2, 4, 8, 16, 32
byte ledMode = 2; //Options: 1 = Red only, 2 = Red + IR, 3 = Red + IR + Green
byte sampleRate = 100; //Options: 50, 100, 200, 400, 800, 1000, 1600, 3200
int pulseWidth = 411; //Options: 69, 118, 215, 411
int adcRange = 4096; //Options: 2048, 4096, 8192, 16384

particleSensor.setup(ledBrightness, sampleAverage, ledMode, sampleRate, pulseWidth, adcRange); //Configure sensor with these settings
}

void loop()
{
bufferLength = 100; //buffer length of 100 stores 4 seconds of samples running at 25sps

//read the first 100 samples, and determine the signal range
for (byte i = 0 ; i < bufferLength ; i++)
{
while (particleSensor.available() == false) //do we have new data?
particleSensor.check(); //Check the sensor for new data
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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