多功能医疗健康手表设计制作,可测量心率,体温 实现计步器 比赛作品

  这是我们暑假参加比赛的作品，含源码，实物图，原理图。请大家多多指教，一起学习。本作品设计了一种可以同时检测心率和体温，并可以实现计步功能的手表，该装置包括单片机控制器、MLX90614红外测温模块、MMA7455计步模块、系统实时时钟、Pulse Sensor心率模块、OLED12864显示模块、nRF24L01无线通信模块和计算机控制软件、电源九部分。
利用MLX90614红外测温模块及Pulse Sensor心率模块采集到人的实时体温和心率数据，通过nRF24L01无线通信模块将采集到的数据发送到单片机控制器，经过STC89LE5A60S2微控制器进行数据处理，再将数据传到OLED12864显示，并通过数据线串口发送数据到电脑，然后通过LabVIEW软件对采集到的数据进一步的处理和分析。

  同时本作品还可以将计步模块的数据通过STC89LE5A60S2单片机送到OLED12864显示，实现计步功能。该作品可当作一个便携式家用医疗小系统，实时监测体温和心率，并可实现户外运动的计步功能，达到方便、快捷、可自由移动的目的。

实物图计步器功能：

手表端

下面是电路原理图：

手表端原理图

下面是整机图：

耳闻模块

心率仪

耳闻原理图

多功能医疗健康手表设计的所有资料下载
（里面包含2个单片机源程序，分别实现了2个功能MLX90614程序-发送-耳温和手表显示）：
程序.rar (253.42 KB, 下载次数: 235)

2017-2-28 19:12 上传

点击文件名下载附件



计步程序jibu.h文件：

1. #include<reg51.h>
   
2. #include <intrins.h>
   
3. //#define uchar unsigned char
   
4. //#define uint unsigned int
   
5. 
   
6. void KeyScan1(void);
   
7. 
   
8. sbit Key_jibu=P2^0;
   
9. 
   
10. #define SET_TR2 AUXR |=  0x10
    
11. #define CLR_TR2 AUXR &= ~0x10
    
12. 
    
13. #define SET_ET2 IE2 |=  0x04
    
14. #define CLR_ET2 IE2 &= ~0x04
    
15. 
    
16. 
    
17. //nop指令个数定义
    
18. #define nops() {_nop_();_nop_();_nop_();_nop_();_nop_();}
    
19. bit start_flag=0;
    
20. //端口定义，可修改
    
21. sbit SDA1=P1^1; //IIC数据线定义 （可自行定义引脚）
    
22. sbit SCL=P1^0; //IIC时钟线定义 （可自行定义引脚）
    
23. 
    
24. //内部数据定义
    
25. unsigned char IIC_ad_main; //器件从地址   
    
26. unsigned char IIC_ad_sub;  //器件子地址            
    
27. unsigned char *IIC_buf;    //发送接收数据缓冲区   
    
28. unsigned char IIC_num;     //发送接收数据缓个数
    
29. unsigned int step_num=0;
    
30. unsigned char x1,y1,z1;
    
31. int x,y,z;
    
32. bit x_flag=0;  
    
33. //bit z_flag=0;
    
34. #define ack 1      //主应答
    
35. #define no_ack 0   //从应答
    
36. 
    
37. /*延时子程序，实现按键消抖功能*/
    
38. void delayms( )
    
39. { int i=10,j=110;
    
40.   for(i=10;i>0;i--)
    
41.     for(j=110;j>0;j--);
    
42.   }
    
43. 
    
44. 
    
45. void send232byte(unsigned char bytebuf)
    
46. {
    
47.         SBUF=bytebuf;
    
48.         while(!TI);       
    
49.     TI=0;          
    
50. }
    
51. 
    
52. void IIC_start(void){
    
53.         SCL=0;
    
54.         SDA1=1;
    
55.         _nop_();
    
56.         SCL=1;
    
57.         nops();
    
58.         SDA1=0;
    
59.         nops();
    
60.         SCL=0;
    
61. }
    
62. //************************************************
    
63. //送停止位SDA=0->1
    
64. void IIC_stop(void){
    
65.         SCL=0;
    
66.         _nop_();
    
67.         SDA1=0;
    
68.         _nop_();
    
69.         SCL=1;
    
70.         nops();
    
71.         SDA1=1;
    
72.         nops();
    
73.         SCL=0;
    
74. }
    
75. //************************************************
    
76. //主应答（包括ack:SDA=0和no_ack:SDA=0)
    
77. void IIC_ack_main(bit ack_main){
    
78.         SCL=0;
    
79.         if(ack_main)SDA1=0; //ack主应答
    
80.         else SDA1=1; //no_ack无需应答
    
81.         nops();
    
82.         SCL=1;
    
83.         nops();
    
84.         SCL=0;
    
85. }
    
86. //*************************************************
    
87. //字节发送程序
    
88. //发送c（可以是数据也可以是地址），送完后接收从应答
    
89. //不考虑从应答
    
90. void send_byte(unsigned char c)
    
91. {
    
92.         unsigned char i;
    
93.         for(i=0;i<8;i++)
    
94.         {
    
95.                 SCL=0;
    
96.                 if((c<<i) & 0x80)SDA1=1; //判断发送位
    
97.                 else SDA1=0;
    
98.                 _nop_();
    
99.                 SCL=1;
    
100.                 nops();
     
101.                 SCL=0;
     
102.        
     
103.         nops();
     
104.         SCL=0;
     
105.         }
     
106.         nops();
     
107.         SDA1=1; //发送完8bit，释放总线准备接受应答位
     
108.         _nop_();
     
109.         SCL=1;
     
110.         nops(); //sda上数据即是从应答位
     
111.         SCL=0; //不考虑从应答但要控制好时序
     
112. }
     
113. //**************************************************
     
114. //字节接收程序
     
115. //接受器件传来的数据，此程序应配合主应答函数IIC-ack main（）使用
     
116. //return: uchar型1字节
     
117. unsigned char read_byte(void){
     
118. unsigned char i;
     
119. unsigned char c;
     
120.         c=0;
     
121.         SCL=0;
     
122.         _nop_();
     
123.         SDA1=1; //置数据线为输入方式
     
124.         for(i=0;i<8;i++){
     
125.                 _nop_();
     
126.                 SCL=0; //置时钟线为低，准备接收数据位
     
127.                 nops();
     
128.                 SCL=1; //置时钟线为高，使数据线上数据有效
     
129.                 _nop_();
     
130.                 c<<=1;
     
131.                 if(SDA1)c+=1; //读数据位，将接收的数据存c
     
132.         }
     
133.         SCL=0;
     
134.         return c;
     
135. }
     
136. //***************************************************
     
137. //向无子地址器件发送单字节数据
     
138. void send_to_byte(unsigned char ad_main,unsigned char c){
     
139.         IIC_start();
     
140.         send_byte(ad_main); //发送器件地址
     
141.         send_byte(c); //发送数据c
     
142.         IIC_stop();
     
143. }
     
144. //***************************************************
     
145. //向有子地址器件发送多字节数据
     
146. void send_to_nbyte(unsigned char ad_main,unsigned char ad_sub,unsigned char *buf,unsigned char num)
     
147. {   unsigned char i;
     
148.     IIC_start();
     
149.         send_byte(ad_main); //发送器件地址
     
150.         send_byte(ad_sub); //发送器件子地址
     
151.         for(i=0;i<num;i++){
     
152.                 send_byte(*buf); //发送数据buf
     
153.                 buf++;
     
154.         }
     
155.         IIC_stop();
     
156. }
     
157. //***************************************************
     
158. //从无子地址器件读单字节数据
     
159. //function:器件地址，所读数据存在接收缓冲区当前字节
     
160. void read_from_byte(unsigned char ad_main,unsigned char *buf){
     
161.         IIC_start();
     
162.         send_byte(ad_main); //发送器件
     
163.         *buf=read_byte();
     
164.         IIC_ack_main(no_ack); //无需应答<no_ack=0>
     
165.         IIC_stop();
     
166.         }
     
167. //***************************************************
     
168. //从有子地址器件读多个字节数据
     
169. //function:
     
170. void read_from_nbyte(unsigned char ad_main,unsigned char ad_sub,unsigned char *buf,unsigned char num){
     
171.         unsigned char i;
     
172.         IIC_start();
     
173.         send_byte(ad_main);
     
174.         send_byte(ad_sub);
     
175.         for(i=0;i<num-1;i++){
     
176.                 *buf=read_byte();
     
177.                 IIC_ack_main(ack); //，主应答<ack=1>
     
178.                 buf++;
     
179.         }
     
180.         *buf=read_byte;
     
181.         buf++; //本次指针调整无意义，目的是操作后buf指向下一地址
     
182.         IIC_ack_main(no_ack); //无需应答<no_ack=0>
     
183.         IIC_stop();
     
184. }
     
185. 
     
186. 
     
187. unsigned char MMA7455_readbyte(unsigned char address)
     
188. {
     
189. unsigned char ret = 100;
     
190.         IIC_start();                //启动
     
191.         send_byte(0x3A);        //写入设备ID及写信号
     
192.         send_byte(address);        //X地址
     
193.         IIC_start();                //重新发送开始
     
194.         send_byte(0x3B);        //写入设备ID及读信号
     
195.         ret = read_byte();        //读取一字节
     
196.         IIC_stop();
     
197. 
     
198.         return ret;
     
199. }
     
200. 
     
201. //写入
     
202. void MMA7455_writebyte(unsigned char address, unsigned char thedata)
     
203. {
     
204.         IIC_start();                //启动
     
205.         send_byte(0x3A);        //写入设备ID及写信号
     
206.         send_byte(address);        //X地址
     
207.         send_byte(thedata);        //写入设备ID及读信号
     
208.         IIC_stop();
     
209. }
     
210. 
     
211. //初始化
     
212. //初始化为指定模式
     
213. void MMA7455_init()
     
214. {  //2g输出 测量模式
     
215.         MMA7455_writebyte(0x16, 0x05);
     
216.         //根据实际环境修改校验值
     
217.         /*MMA7455_writebyte(0x10,0x10);//校正X值
     
218.         MMA7455_writebyte(0x12,0x30);//校正Y值
     
219.         MMA7455_writebyte(0x14,0x00);//校正Z值 */
     
220. }
     
221. /************************显示程序**********************************/
     
222. void display()
     
223. {
     
224.   if (step_num/10000>0)         //万
     
225.    OLED_ShowNum(0+8*5,4,step_num/10000,1,8*16);
     
226.   else
     
227.    OLED_ShowNum(0+8*5,4,0,1,8*16);
     
228.       if (step_num/1000>0)        //千
     
229.         OLED_ShowNum(0+8*6,4,step_num%10000/1000,1,8*16);
     
230.      else
     
231.         OLED_ShowNum(0+8*6,4,0,1,8*16);          
     
232.                      if (step_num/100>0)        //百
     
233.              OLED_ShowNum(0+8*7,4,step_num%1000/100,1,8*16);
     
234.           else
     
235.              OLED_ShowNum(0+8*7,4,0,1,8*16);
     
236.                          if (step_num/10>0)        //十
     
237.              OLED_ShowNum(0+8*8,4,step_num%100/10,1,8*16);
     
238.           else
     
239.              OLED_ShowNum(0+8*8,4,0,1,8*16);
     
240.                          //个
     
241.                         OLED_ShowNum(0+8*9,4,step_num%10,1,8*16);                    
     
242. }
     
243. 
     
244. /************读取重力信息**************/
     
245. void Dat_dispose()
     
246. {
     
247.            if(start_flag)
     
248.      {  x1=MMA7455_readbyte(0x06);
     
249.             y1=MMA7455_readbyte(0x07);
     
250.         z1=MMA7455_readbyte(0x08);
     
251.           }
     
252.            x=x1;
     
253.          y=y1;
     
254.          z=z1;
     
255.          if((x&0x80)==0x00)
     
256.          { x=(int)((x*196)/127); //转变成加速度值
     
257.          }
     
258.          else {  x=255-x;
     
259.                  x=(int)((x*196)/127);//转变成加速度值
     
260.                          x=(-1)*x;
     
261.                    }
     
262.          if((y&0x80)==0x00)
     
263.          { y=(int)((y*196)/127); //转变成加速度值
     
264.          }
     
265.          else {  y=255-y;
     
266.                  y=(int)((y*196)/127);//转变成加速度值
     
267.                          y=(-1)*y;
     
268.                    }
     
269.          if((z&0x80)==0x00)
     
270.          { z=(int)(((z-10)*196)/127); //转变成加速度值
     
271.          }
     
272.          else {  z=255-z;
     
273.                  z=(int)(((z+12)*196)/127);//转变成加速度值
     
274.                          z=(-1)*z;
     
275.                    }
     
276. 
     
277.          if(start_flag)
     
278.           {
     
279.            if(y>30&&x_flag==0&&z>70&&z<100)
     
280.              {x_flag=1;
     
281.                   step_num++;}
     
282.                 else if(y<0)
     
283.                 {  x_flag=0;}
     
284.            }
     
285.           else x_flag=0;
     
286. }
     
287. 
     

复制代码

主程序：

1. #include "REG51.h"
   
2. #include "OLED.h"
   
3. //#include "bmp.h"
   
4. #include "DS1302.h"
   
5. #include "NRF24L01.h"
   
6. #include "key_deal.h"
   
7. #include "MMA7455.h"
   
8. 
   
9. 
   
10. #define false 0
    
11. #define true 1
    
12. #define FOSC 11059200L                //系统时钟
    
13. #define BAUD 115200                                //波特率
    
14. #define T0MS (65536-FOSC/12/500)                //500HZ in 12T MODE
    
15. 
    
16. #define ADC_POWER 0x80                        //ADC POWER CONTROL BIT
    
17. #define ADC_FLAG 0x10                        //ADC COMPLETE FLAG
    
18. #define ADC_START 0x08;                        //ADC START CONTROL BIT
    
19. #define ADC_SPEEDLL 0x00                //540 CLOCKS
    
20. #define ADC_SPEEDL 0x20                        //360 CLOCKS
    
21. #define ADC_SPEEDH 0x40                        //180 CLOCKS
    
22. #define ADC_SPEEDHH 0x60                //90 CLOCKS
    
23. #define ADC_MASK 0x01
    
24. 
    
25. 
    
26. void ADC_init(unsigned char channel);
    
27. void InitTimer0(void);
    
28. unsigned char ReturnPulse(void);
    
29. unsigned int analogRead(unsigned char channel);
    
30. unsigned char PulsePin = 5;       // Pulse Sensor purple wire connected to analog pin 0(P1.0为传感器输入口)
    
31. int fadeRate = 0;                 // used to fade LED on with PWM on fadePin
    
32. unsigned char pp1;
    
33. unsigned char pp0;
    
34. unsigned char pp2;
    
35. unsigned char pp3;
    
36. unsigned int PL1=0;
    
37. 
    
38. void UART_init(void);
    
39. void Send(void);
    
40. 
    
41. // these variables are volatile because they are used during the interrupt service routine!
    
42. volatile unsigned int BPM;                   // used to hold the pulse rate
    
43. volatile unsigned int Signal;                // holds the incoming raw data
    
44. volatile unsigned int IBI = 600;             // holds the time between beats, must be seeded!
    
45. volatile bit Pulse = false;     // true when pulse wave is high, false when it's low
    
46. volatile bit QS = false;        // becomes true when Arduoino finds a beat.
    
47. volatile int rate[10];                    // array to hold last ten IBI values
    
48. volatile unsigned long sampleCounter = 0;          // used to determine pulse timing
    
49. volatile unsigned long lastBeatTime = 0;           // used to find IBI
    
50. volatile int Peak =512;                      // used to find peak in pulse wave, seeded
    
51. volatile int Trough = 512;                     // used to find trough in pulse wave, seeded
    
52. volatile int thresh = 512;                // used to find instant moment of heart beat, seeded
    
53. volatile int amp = 100;                   // used to hold amplitude of pulse waveform, seeded
    
54. volatile bit firstBeat = true;        // used to seed rate array so we startup with reasonable BPM
    
55. volatile bit secondBeat = false;      // used to seed rate array so we startup with reasonable BPM
    
56. static unsigned char order=0;
    
57. unsigned char DisBuff[4]={0};
    
58. 
    
59. void Int0_Init(void);
    
60. //void Int1_Init(void);
    
61. void Display_Init(void);
    
62. 
    
63. 
    
64. static unsigned char data temp[10];
    
65. bit data T0_FLAG=0;
    
66. bit data key_flag;
    
67. bit data key_flag1;
    
68. unsigned int mode1 = 0;
    
69. 
    
70. void delay(unsigned int n)
    
71. {
    
72.         unsigned int i,j;
    
73.         for(i=0;i<n;i++)
    
74.                 for(j=0;j<100;j++);
    
75. }
    
76. 
    
77. 
    
78. 
    
79. int main(void)
    
80. {             //u8 t;
    
81.                 //delay_init();                     //延时函数初始化          
    
82.         //        NVIC_Configuration();          //设置NVIC中断分组2:2位抢占优先级，2位响应优先级         LED_Init();                             //LED端口初始化
    
83.                 OLED_Init();                        //初始化OLED
    
84.                 Ds1302_Init();
    
85.                 InitTimer0();
    
86.                 Display_Init();
    
87.                 ADC_init(PulsePin);
    
88.                 //InitTimer1();
    
89.                 Int0_Init();
    
90.                 init_NRF24L01();
    
91.                 SetRX_Mode();
    
92.                 UART_init();
    
93.                 //Int1_Init();       
    
94. 
    
95.     while(1)
    
96.         {
    
97.              delay_ms(10);
    
98. 
    
99.             Ds1302_Read_Time();
    
100.            /*判断按键2是否启动测试*/
     
101.                 if(0 == Key_Down)               
     
102.             {
     
103.                  delay_ms(100);
     
104.                  if(0 == Key_Down)
     
105.             {
     
106.              mode1=mode1+1;
     
107.                  }
     
108.                  }
     
109.                  
     
110.                                 /*        测心率        */
     
111.                 if(mode1==1)
     
112.                 {
     
113.                          OLED_ShowCHinese(0,0,0);  //心
     
114.                 OLED_ShowCHinese(16,0,1); //率
     
115.                 OLED_ShowString(32,0,":");
     
116.                         OLED_ShowCHinese(0,2,2);  //体
     
117.                 OLED_ShowCHinese(16,2,3);  //温
     
118.                 OLED_ShowString(32,2,":");
     
119.                                        
     
120.                 if (QS == true&&PL1>1000)
     
121.                 {                       // Quantified Self flag is true when arduino finds a heartbeat
     
122.                                
     
123.                 QS = false;
     
124.                     delay(100);
     
125.                         OLED_ShowNum(0+8*5,0,DisBuff[2],1,8*16);         //百位显示
     
126.                         OLED_ShowNum(0+8*6,0,DisBuff[1],1,8*16);                                         //个十位显示
     
127.                         OLED_ShowNum(0+8*7,0,DisBuff[0],1,8*16);
     
128.                     OLED_ShowString(64,0,"bpm");
     
129.                                  
     
130.                                   ///判断是否异常
     
131.                         if((DisBuff[1]*10+DisBuff[0])<100&&(DisBuff[1]*10+DisBuff[0])>=60&&DisBuff[2]!=1)          
     
132.                         {
     
133.                          OLED_ShowCHinese(0+8*12,0,24);         //正常
     
134.                          OLED_ShowCHinese(0+8*14,0,26);
     
135.                         }
     
136.                         else if(DisBuff[1]==0&&DisBuff[2]==0&&DisBuff[0]==0)
     
137.                         {        
     
138.                            OLED_ShowCHinese(0+8*12,0,29);           //空
     
139.                            OLED_ShowCHinese(0+8*14,0,29);
     
140.                          }
     
141.                         else
     
142.                         {
     
143.                          OLED_ShowCHinese(0+8*12,0,25);                //异常
     
144.                          OLED_ShowCHinese(0+8*14,0,26);
     
145.                         }               
     
146.                          
     
147.                          }
     
148.           delay(138);                         //  take a break 19.6ms
     
149. 
     
150.                   /*温度测量 */
     
151.                    if(nRF24L01_RxPacket(temp)&&PL1>1000)  //接收温度
     
152.                 {
     
153.                         SetTX_Mode();
     
154.                         delay(100);                                          
     
155.                         OLED_ShowString(56,2,".");
     
156.                         OLED_ShowCHinese(72,2,19);
     
157.                     OLED_ShowNum(0+8*5,2,temp[3]%100/10,1,8*16);   //temp[3]存放十位
     
158.                         OLED_ShowNum(0+8*6,2,temp[3]%10,1,8*16);             //个位
     
159.                         OLED_ShowNum(0+8*8,2,temp[2]%100/10,1,8*16);                //temp[2]存放小数位
     
160.                             if(temp[3]>=36&&temp[3]<38)
     
161.                             {
     
162.                               OLED_ShowCHinese(0+8*12,2,24);
     
163.                               OLED_ShowCHinese(0+8*14,2,26);
     
164.                              }
     
165.                                 else
     
166.                                    {
     
167.                                       OLED_ShowCHinese(0+8*12,2,25);
     
168.                                       OLED_ShowCHinese(0+8*14,2,26);
     
169.                                            }  
     
170.                         temp[4] = ReturnPulse();
     
171.                         nRF24L01_TxPacket(temp);
     
172.                         SetRX_Mode();
     
173.                                
     
174.            }   
     
175.                 if(PL1>1000)
     
176.                  {
     
177.                 PL1=0;
     
178.                 Send();
     
179.                 }
     
180.            }
     
181.            if(mode1>=3)
     
182.            {                                                                      
     
183.                     mode1=0;
     
184.                         OLED_ShowCHinese(0,0,29); //心
     
185.                         OLED_ShowCHinese(16,0,29);        //率
     
186.                         OLED_ShowCHinese(32,0,29);
     
187.                         OLED_ShowCHinese(64,0,29);
     
188.                         OLED_ShowCHinese(72,0,29);
     
189.                         OLED_ShowCHinese(48,0,29);
     
190.                         OLED_ShowCHinese(56,0,29);
     
191.                         OLED_ShowCHinese(40,0,29);
     
192.                         OLED_ShowCHinese(0+8*12,0,29);
     
193.                         OLED_ShowCHinese(0+8*14,0,29);
     
194.                        
     
195.                                          
     
196.                         OLED_ShowCHinese(0,2,29); //
     
197.                         OLED_ShowCHinese(16,2,29);        //
     
198.                         OLED_ShowCHinese(32,2,29);
     
199.                         OLED_ShowCHinese(72,2,29);
     
200.                         OLED_ShowCHinese(64,2,29);
     
201.                         OLED_ShowCHinese(48,2,29);
     
202.                         OLED_ShowCHinese(56,2,29);
     
203.                         OLED_ShowCHinese(40,2,29);
     
204.                         OLED_ShowCHinese(0+8*12,2,29);       
     
205.                         OLED_ShowCHinese(0+8*14,2,29);
     
206.           
     
207.                 }
     
208.                                      
     
209.                                 OLED_ShowNum(0+8*10,4,time_buf1[6]/10,1,8*16);                  
     
210.                                 OLED_ShowNum(0+8*11,4,time_buf1[6]%10,1,8*16);
     
211.                                 if(0 == time_buf1[6])
     
212.                                 {
     
213.                             OLED_ShowNum(0+8*7,4,time_buf1[5]/10,1,8*16);
     
214.                                 OLED_ShowNum(0+8*8,4,time_buf1[5]%10,1,8*16);
     
215.                                         if(0 == time_buf1[5])
     
216.                                         {
     
217.                                             EA = 0;                                                //////
     
218.                                                 OLED_ShowNum(0+8*4,4,time_buf1[4]/10,1,8*16);
     
219.                                                 OLED_ShowNum(0+8*5,4,time_buf1[4]%10,1,8*16);
     
220.                                                 if(0 == time_buf1[4])                                                 
     
221.                                                 {                                       
     
222.                                                         OLED_ShowNum(0+8*9,6,time_buf1[3]/10,1,8*16);
     
223.                                                         OLED_ShowNum(0+8*10,6,time_buf1[3]%10,1,8*16);
     
224.                                                         OLED_ShowCHinese(8*12,6,WEEK[time_buf1[7]]);
     
225.                                                         if(0 == time_buf1[3])
     
226.                                                         {
     
227.                                                                         OLED_ShowNum(0+8*6,6,time_buf1[2]/10,1,8*16);
     
228.                                                                         OLED_ShowNum(0+8*7,6,time_buf1[2]%10,1,8*16);
     
229.                                                                 if(0 == time_buf1[2])
     
230.                                                                 {
     
231.                                                                         OLED_ShowNum(0+8*3,6,time_buf1[1]/10,1,8*16);
     
232.                                                                         OLED_ShowNum(0+8*4,6,time_buf1[1]%10,1,8*16);
     
233.                                                                 }               
     
234.                                                         }
     
235.                                                 }
     
236.                                        
     
237.                                                 InitTimer0();  //每隔一小时，重新初始化一次                               
     
238.                                         }
     
239.                   
     
240.                                                 }
     
241.                         /*        时间调整/计步按键判断        */
     
242.                                                                 //按键判断
     
243.                         if(key_flag == 1) //进入按键扫描
     
244.                         {
     
245.                                 KeyScan();
     
246.                                 key_flag = 0;
     
247.                                 mode1=0;
     
248.                         }
     
249.                                  
     
250.                        
     
251.                         }                 
     
252.                         }
     
253.                        
     
254. …………余下代码请下载附件……

复制代码

不错哟。。。

还不错，功能也多

多向你们学习

如果你还喜欢健身,那么你就会很想做一个这东西了

你好  请问你的心律仪在哪里买的 型号是？

你好  请问你的心律仪是在哪里买的

如果能加上心电监测就好了

楼主，能发一下电路原理图吗？1327342081@qq.com,不胜感激

如果能加上心电监测就好了

厉害   很给力啊

若能连接手机app显示心电图就太棒了

厉害啊

要想链接手机app要怎么做啊

DDbong 发表于 2018-3-23 15:06
要想链接手机app要怎么做啊

你好！如果手机APP显示，要用 WIFI 或 蓝牙模块来实现；
可以加我QQ，完成方案设计

厉害厉害

请问你的心律仪是在哪里买的

很有实用价值，感谢分享

谢谢分享，感觉你这个肯定获奖了把。很不错

谢谢分享，使用价值很高，很不错的设计

cjjcjj1 发表于 2018-3-23 18:41
你好！如果手机APP显示，要用 WIFI 或 蓝牙模块来实现；
可以加我QQ，完成方案设计

有偿急需设计一款只有计步功能的，速联系我，电话：13930396692

下載，學習了。

谢谢分享,很不错的

不错的想法，不错的设计，但体积和电池续航问题怎样呢？

labview文件可以发吗

感谢博主的干货