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

基于STM32的物联网健康监测系统设计（附源码）_基于stm32的个人健康助手的设计

作者：花生_TL007 | 2024-04-13 00:43:43

赞

踩

基于stm32的个人健康助手的设计

目录

1、项目简介

2、整体项目架构设计

2、硬件架构设计

（1）硬件型号

（2）传感器驱动程序设计

3、基于MQTT协议的数据传输

4、微信小程序上位机设计

1.主界面

2. 健康监测系统 

3. 环境监测系统         

4. 显示实时动态曲线         

1、项目简介

        该项目是利用STM32开发板进行开发的基于MQTT协议的物联网健康监测系统，并开发了微信小程序作为该项目的软件上位机。该产品可以用来实时监测人体的心率、血氧等生理参数，也可以监测家庭环境中的温湿度、烟雾浓度等环境参数，从而为您营造出一个健康的居住环境。此项目是本人在寒假利用业余时间开发的，从理论知识的学习到做出最终成品耗时将近两个月，可用于嵌入式软件方向的毕业设计。

        该项目源码已全部开源，在本文中仅介绍核心代码原理，源码已发布在我的GitHub主页，如对源码有疑惑，或者对该项目有改进性意见，可以评论或私信本人，欢迎大家一起交流学习！

        我的github主页：https://github.com/SichengLong26
        源代码地址：https://github.com/SichengLong26/health-iot

2、整体项目架构设计

        该项目主要分为硬件架构设计和软件架构设计，硬件架构设计包括电路设计、PCB焊接、驱动程序编写、数据传输（数据上云）的程序编写；软件架构设计则包括前端UI界面的设计和后端的数据处理，此次软件上位机是基于微信小程序来开发的。

2、硬件架构设计

（1）硬件型号

主控芯片：STM32F103RCT6
传感器：MAX30102心率传感器、DHT11温湿度传感器、MQ2烟雾传感器
通信模块：ESP8266 WIFI模块

（2）传感器驱动程序设计

MAX30102心率血氧传感器（通过IIC驱动）
        MAX3010VCC引脚连接STM32F103mini单片机的5伏引脚，GND连接5伏对应的GND，SCL连PC12，SDA连PC11，INT连PA5。MAX30102的其他引脚没有用到。
        本代码能够正常接收MAX30102心率血氧传感器返回的red与ir的数值，能够比较正常计算出心率血氧数值。当心率或血氧值的计算结果有误时对应的变量值为-999。

main.c

  1. #include "delay.h"
  2. #include "sys.h"
  3. #include "usart.h"
  4. #include "myiic.h"
  5. #include "max30102.h"
  6. #include "algorithm.h"
  7.  
  8. #define MAX_BRIGHTNESS 255
  9. #define START 100
  10. #define DATA_LENGTH 500
  11.  
  12.  
  13. uint32_t aun_ir_buffer[DATA_LENGTH]; //IR LED sensor data
  14. int32_t n_ir_buffer_length;    //data length
  15. uint32_t aun_red_buffer[DATA_LENGTH];    //Red LED sensor data
  16. int32_t n_sp02; //SPO2 value
  17. int8_t ch_spo2_valid;   //indicator to show if the SP02 calculation is valid
  18. int32_t n_heart_rate;   //heart rate value
  19. int8_t  ch_hr_valid;    //indicator to show if the heart rate calculation is valid
  20. uint8_t uch_dummy;
  21.  
  22.  
  23.  int main(void)
  24.  { 
  25. 	uint32_t un_min, un_max, un_prev_data;  //variables to calculate the on-board LED brightness that reflects the heartbeats
  26. 	int i;
  27. 	int32_t n_brightness;
  28. 	float f_temp;
  29. 	
  30. 	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);// 设置中断优先级分组2
  31. 	delay_init();	    	 //延时函数初始化	  
  32. 	uart_init(9600);	 	//串口初始化为115200
  33.  	IIC_Init();		 	
  34. 	
  35. 	maxim_max30102_reset(); //resets the MAX30102
  36. 	// initialize serial communication at 115200 bits per second:
  37. 	//read and clear status register
  38. 	maxim_max30102_read_reg(0,&uch_dummy);
  39. 	maxim_max30102_init();  //initializes the MAX30102
  40.  
  41. 	n_brightness=0;
  42. 	un_min=0x3FFFF;
  43. 	un_max=0;
  44. 	n_ir_buffer_length=DATA_LENGTH; //buffer length of 100 stores 5 seconds of samples running at 100sps
  45. 	//read the first 500 samples, and determine the signal range
  46. 	for(i=0;i<n_ir_buffer_length;i++)
  47. 	{
  48. 			while(PAin(5)==1);   //wait until the interrupt pin asserts
  49. 			maxim_max30102_read_fifo((aun_red_buffer+i), (aun_ir_buffer+i));  //read from MAX30102 FIFO	
  50. 			if(un_min>aun_red_buffer[i])
  51. 					un_min=aun_red_buffer[i];    //update signal min
  52. 			if(un_max<aun_red_buffer[i])
  53. 					un_max=aun_red_buffer[i];    //update signal max
  54. 			printf("心率：%i次/min,", aun_red_buffer[i]/1000);
  55. 			printf("血氧=%i % \r\n", aun_ir_buffer[i]/1000+16);
  56. 	}
  57. 	un_prev_data=aun_red_buffer[i];
  58. 	//calculate heart rate and SpO2 after first 500 samples (first 5 seconds of samples)
  59. 	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); 
  60. 	while(1)
  61. 	{
  62. 	  i=0;
  63. 		un_min=0x3FFFF;
  64. 		un_max=0;
  65. 		//dumping the first 100 sets of samples in the memory and shift the last 400 sets of samples to the top
  66. 		for(i=START;i<DATA_LENGTH;i++)
  67. 		{
  68. 				aun_red_buffer[i-START]=aun_red_buffer[i];
  69. 				aun_ir_buffer[i-START]=aun_ir_buffer[i];
  70. 				
  71. 				//update the signal min and max
  72. 				if(un_min>aun_red_buffer[i])
  73. 				un_min=aun_red_buffer[i];
  74. 				if(un_max<aun_red_buffer[i])
  75. 				un_max=aun_red_buffer[i];
  76. 		}
  77. 		//take 100 sets of samples before calculating the heart rate.
  78. 		for(i=400;i<DATA_LENGTH;i++)
  79. 		{
  80. 				un_prev_data=aun_red_buffer[i-1];
  81. 				while(PAin(5)==1);
  82. 				maxim_max30102_read_fifo((aun_red_buffer+i), (aun_ir_buffer+i));
  83. 		
  84. 				if(aun_red_buffer[i]>un_prev_data)//just to determine the brightness of LED according to the deviation of adjacent two AD data
  85. 				{
  86. 						f_temp=aun_red_buffer[i]-un_prev_data;
  87. 						f_temp/=(un_max-un_min);
  88. 						f_temp*=MAX_BRIGHTNESS;
  89. 						n_brightness-=(int)f_temp;
  90. 						if(n_brightness<0)
  91. 								n_brightness=0;
  92. 				}
  93. 				else
  94. 				{
  95. 						f_temp=un_prev_data-aun_red_buffer[i];
  96. 						f_temp/=(un_max-un_min);
  97. 						f_temp*=MAX_BRIGHTNESS;
  98. 						n_brightness+=(int)f_temp;
  99. 						if(n_brightness>MAX_BRIGHTNESS)
  100. 								n_brightness=MAX_BRIGHTNESS;
  101. 				}
  102. 				//re_oxen=(float)aun_red_buffer[i]/(float)aun_ir_buffer[i];
  103. 				//oxen=45.06*re_oxen*re_oxen+30.354*re_oxen+94.845;
  104. 				//send samples and calculation result to terminal program through UART
  105. //				printf("red=%i,", aun_red_buffer[i]);
  106. //				printf(" ir=%i,", aun_ir_buffer[i]);
  107.  
  108. 		}
  109. 		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); 
  110. 		printf(" HR=%i,", n_heart_rate); 
  111. 		printf(" HRvalid=%i,", ch_hr_valid);
  112. 		printf(" SpO2=%i,", n_sp02);
  113. 		printf(" SPO2Valid=%i\r\n", ch_spo2_valid);
  114. 	}
  115. }

max30102.c（驱动程序）

  1. #include "max30102.h"
  2. #include "myiic.h"
  3.  
  4. #define max30102_WR_address 0xAE
  5. bool maxim_max30102_write_reg(uint8_t uch_addr, uint8_t uch_data)
  6. /**
  7. * \brief        Write a value to a MAX30102 register
  8. * \par          Details
  9. *               This function writes a value to a MAX30102 register
  10. *
  11. * \param[in]    uch_addr    - register address
  12. * \param[in]    uch_data    - register data
  13. *
  14. * \retval       true on success
  15. */
  16. {
  17.     /* 第1步：发起I2C总线启动信号 */
  18.     IIC_Start();
  19.  
  20.     /* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  21.     IIC_Send_Byte(max30102_WR_address | I2C_WR);	/* 此处是写指令 */
  22.  
  23.     /* 第3步：发送ACK */
  24.     if (IIC_Wait_Ack() != 0)
  25.     {
  26.         goto cmd_fail;	/* EEPROM器件无应答 */
  27.     }
  28.  
  29.     /* 第4步：发送字节地址 */
  30.     IIC_Send_Byte(uch_addr);
  31.     if (IIC_Wait_Ack() != 0)
  32.     {
  33.         goto cmd_fail;	/* EEPROM器件无应答 */
  34.     }
  35.  
  36.     /* 第5步：开始写入数据 */
  37.     IIC_Send_Byte(uch_data);
  38.  
  39.     /* 第6步：发送ACK */
  40.     if (IIC_Wait_Ack() != 0)
  41.     {
  42.         goto cmd_fail;	/* EEPROM器件无应答 */
  43.     }
  44.  
  45.     /* 发送I2C总线停止信号 */
  46.     IIC_Stop();
  47.     return true;	/* 执行成功 */
  48.  
  49. cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
  50.     /* 发送I2C总线停止信号 */
  51.     IIC_Stop();
  52.     return false;
  53. }
  54.  
  55. bool maxim_max30102_read_reg(uint8_t uch_addr, uint8_t *puch_data)
  56. /**
  57. * \brief        Read a MAX30102 register
  58. * \par          Details
  59. *               This function reads a MAX30102 register
  60. *
  61. * \param[in]    uch_addr    - register address
  62. * \param[out]   puch_data    - pointer that stores the register data
  63. *
  64. * \retval       true on success
  65. */
  66. {
  67.     /* 第1步：发起I2C总线启动信号 */
  68.     IIC_Start();
  69.  
  70.     /* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  71.     IIC_Send_Byte(max30102_WR_address | I2C_WR);	/* 此处是写指令 */
  72.  
  73.     /* 第3步：发送ACK */
  74.     if (IIC_Wait_Ack() != 0)
  75.     {
  76.         goto cmd_fail;	/* EEPROM器件无应答 */
  77.     }
  78.  
  79.     /* 第4步：发送字节地址， */
  80.     IIC_Send_Byte((uint8_t)uch_addr);
  81.     if (IIC_Wait_Ack() != 0)
  82.     {
  83.         goto cmd_fail;	/* EEPROM器件无应答 */
  84.     }
  85.     /* 第6步：重新启动I2C总线。下面开始读取数据 */
  86.     IIC_Start();
  87.  
  88.     /* 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  89.     IIC_Send_Byte(max30102_WR_address | I2C_RD);	/* 此处是读指令 */
  90.  
  91.     /* 第8步：发送ACK */
  92.     if (IIC_Wait_Ack() != 0)
  93.     {
  94.         goto cmd_fail;	/* EEPROM器件无应答 */
  95.     }
  96.  
  97.     /* 第9步：读取数据 */
  98.     {
  99.         *puch_data = IIC_Read_Byte();	/* 读1个字节 */
  100.  
  101.         IIC_NAck();	/* 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1) */
  102.     }
  103.     /* 发送I2C总线停止信号 */
  104.     IIC_Stop();
  105.     return true;	/* 执行成功 返回data值 */
  106.  
  107. cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
  108.     /* 发送I2C总线停止信号 */
  109.     IIC_Stop();
  110.     return false;
  111. }
  112.  
  113. bool maxim_max30102_init(void)
  114. /**
  115. * \brief        Initialize the MAX30102
  116. * \par          Details
  117. *               This function initializes the MAX30102
  118. *
  119. * \param        None
  120. *
  121. * \retval       true on success
  122. */
  123. {
  124. 		GPIO_InitTypeDef GPIO_InitStructure;
  125. 		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC,ENABLE);//使能PORTA,PORTC时钟
  126. 		GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);//关闭jtag，使能SWD，可以用SWD模式调试
  127. 		GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_5;//PA5
  128. 		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //PA5设置成浮空输入	  
  129. 		GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA5
  130.     if(!maxim_max30102_write_reg(REG_INTR_ENABLE_1, 0xc0)) // INTR setting
  131.         return false;
  132.     if(!maxim_max30102_write_reg(REG_INTR_ENABLE_2, 0x00))
  133.         return false;
  134.     if(!maxim_max30102_write_reg(REG_FIFO_WR_PTR, 0x00)) //FIFO_WR_PTR[4:0]
  135.         return false;
  136.     if(!maxim_max30102_write_reg(REG_OVF_COUNTER, 0x00)) //OVF_COUNTER[4:0]
  137.         return false;
  138.     if(!maxim_max30102_write_reg(REG_FIFO_RD_PTR, 0x00)) //FIFO_RD_PTR[4:0]
  139.         return false;
  140.     if(!maxim_max30102_write_reg(REG_FIFO_CONFIG, 0x6f)) //sample avg = 8, fifo rollover=false, fifo almost full = 17
  141.         return false;
  142.     if(!maxim_max30102_write_reg(REG_MODE_CONFIG, 0x03))  //0x02 for Red only, 0x03 for SpO2 mode 0x07 multimode LED
  143.         return false;
  144.     if(!maxim_max30102_write_reg(REG_SPO2_CONFIG, 0x2F)) // SPO2_ADC range = 4096nA, SPO2 sample rate (400 Hz), LED pulseWidth (411uS)
  145.         return false;
  146.  
  147.     if(!maxim_max30102_write_reg(REG_LED1_PA, 0x17))  //Choose value for ~ 4.5mA for LED1
  148.         return false;
  149.     if(!maxim_max30102_write_reg(REG_LED2_PA, 0x17))  // Choose value for ~ 4.5mA for LED2
  150.         return false;
  151.     if(!maxim_max30102_write_reg(REG_PILOT_PA, 0x7f))  // Choose value for ~ 25mA for Pilot LED
  152.         return false;
  153.     return true;
  154. }
  155.  
  156. bool maxim_max30102_read_fifo(uint32_t *pun_red_led, uint32_t *pun_ir_led)
  157.  
  158. /**
  159. * \brief        Read a set of samples from the MAX30102 FIFO register
  160. * \par          Details
  161. *               This function reads a set of samples from the MAX30102 FIFO register
  162. *
  163. * \param[out]   *pun_red_led   - pointer that stores the red LED reading data
  164. * \param[out]   *pun_ir_led    - pointer that stores the IR LED reading data
  165. *
  166. * \retval       true on success
  167. */
  168. {
  169.     uint32_t un_temp;
  170.     uint8_t uch_temp;
  171.     *pun_ir_led = 0;
  172.     *pun_red_led = 0;
  173.     maxim_max30102_read_reg(REG_INTR_STATUS_1, &uch_temp);
  174.     maxim_max30102_read_reg(REG_INTR_STATUS_2, &uch_temp);
  175.  
  176.  
  177.  
  178.     /* 第1步：发起I2C总线启动信号 */
  179.     IIC_Start();
  180.  
  181.     /* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  182.     IIC_Send_Byte(max30102_WR_address | I2C_WR);	/* 此处是写指令 */
  183.  
  184.     /* 第3步：发送ACK */
  185.     if (IIC_Wait_Ack() != 0)
  186.     {
  187.         goto cmd_fail;	/* EEPROM器件无应答 */
  188.     }
  189.  
  190.     /* 第4步：发送字节地址， */
  191.     IIC_Send_Byte((uint8_t)REG_FIFO_DATA);
  192.     if (IIC_Wait_Ack() != 0)
  193.     {
  194.         goto cmd_fail;	/* EEPROM器件无应答 */
  195.     }
  196.  
  197.  
  198.     /* 第6步：重新启动I2C总线。下面开始读取数据 */
  199.     IIC_Start();
  200.  
  201.     /* 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  202.     IIC_Send_Byte(max30102_WR_address | I2C_RD);	/* 此处是读指令 */
  203.  
  204.     /* 第8步：发送ACK */
  205.     if (IIC_Wait_Ack() != 0)
  206.     {
  207.         goto cmd_fail;	/* EEPROM器件无应答 */
  208.     }
  209.  
  210.     un_temp = IIC_Read_Byte();
  211.     IIC_Ack();
  212.     un_temp <<= 16;
  213.     *pun_red_led += un_temp;
  214.     un_temp = IIC_Read_Byte();
  215.     IIC_Ack();
  216.     un_temp <<= 8;
  217.     *pun_red_led += un_temp;
  218.     un_temp = IIC_Read_Byte();
  219.     IIC_Ack();
  220.     *pun_red_led += un_temp;
  221.  
  222.     un_temp = IIC_Read_Byte();
  223.     IIC_Ack();
  224.     un_temp <<= 16;
  225.     *pun_ir_led += un_temp;
  226.     un_temp = IIC_Read_Byte();
  227.     IIC_Ack();
  228.     un_temp <<= 8;
  229.     *pun_ir_led += un_temp;
  230.     un_temp = IIC_Read_Byte();
  231.     IIC_Ack();
  232.     *pun_ir_led += un_temp;
  233.     *pun_red_led &= 0x03FFFF; //Mask MSB [23:18]
  234.     *pun_ir_led &= 0x03FFFF; //Mask MSB [23:18]
  235.  
  236.     /* 发送I2C总线停止信号 */
  237.     IIC_Stop();
  238.     return true;
  239. cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
  240.     /* 发送I2C总线停止信号 */
  241.     IIC_Stop();
  242.     return false;
  243. }
  244.  
  245. bool maxim_max30102_reset()
  246. /**
  247. * \brief        Reset the MAX30102
  248. * \par          Details
  249. *               This function resets the MAX30102
  250. *
  251. * \param        None
  252. *
  253. * \retval       true on success
  254. */
  255. {
  256.     if(!maxim_max30102_write_reg(REG_MODE_CONFIG, 0x40))
  257.         return false;
  258.     else
  259.         return true;
  260. }
  261.

 alogrihm.c心率血氧算法：

  1. /** \file algorithm.cpp ******************************************************
  2. *
  3. * Project: MAXREFDES117#
  4. * Filename: algorithm.cpp
  5. * Description: This module calculates the heart rate/SpO2 level
  6. *
  7. *
  8. * --------------------------------------------------------------------
  9. *
  10. * This code follows the following naming conventions:
  11. *
  12. * char              ch_pmod_value
  13. * char (array)      s_pmod_s_string[16]
  14. * float             f_pmod_value
  15. * int32_t           n_pmod_value
  16. * int32_t (array)   an_pmod_value[16]
  17. * int16_t           w_pmod_value
  18. * int16_t (array)   aw_pmod_value[16]
  19. * uint16_t          uw_pmod_value
  20. * uint16_t (array)  auw_pmod_value[16]
  21. * uint8_t           uch_pmod_value
  22. * uint8_t (array)   auch_pmod_buffer[16]
  23. * uint32_t          un_pmod_value
  24. * int32_t *         pn_pmod_value
  25. *
  26. * ------------------------------------------------------------------------- */
  27. /*******************************************************************************
  28. * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
  29. *
  30. * Permission is hereby granted, free of charge, to any person obtaining a
  31. * copy of this software and associated documentation files (the "Software"),
  32. * to deal in the Software without restriction, including without limitation
  33. * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  34. * and/or sell copies of the Software, and to permit persons to whom the
  35. * Software is furnished to do so, subject to the following conditions:
  36. *
  37. * The above copyright notice and this permission notice shall be included
  38. * in all copies or substantial portions of the Software.
  39. *
  40. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  41. * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  42. * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  43. * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
  44. * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  45. * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  46. * OTHER DEALINGS IN THE SOFTWARE.
  47. *
  48. * Except as contained in this notice, the name of Maxim Integrated
  49. * Products, Inc. shall not be used except as stated in the Maxim Integrated
  50. * Products, Inc. Branding Policy.
  51. *
  52. * The mere transfer of this software does not imply any licenses
  53. * of trade secrets, proprietary technology, copyrights, patents,
  54. * trademarks, maskwork rights, or any other form of intellectual
  55. * property whatsoever. Maxim Integrated Products, Inc. retains all
  56. * ownership rights.
  57. *******************************************************************************
  58. */
  59.  
  60. #include "algorithm.h"
  61.  
  62. //uch_spo2_table is approximated as  -45.060*ratioAverage* ratioAverage + 30.354 *ratioAverage + 94.845 ;
  63. 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,
  64.                                       99, 99, 99, 99, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
  65.                                       100, 100, 100, 100, 99, 99, 99, 99, 99, 99, 99, 99, 98, 98, 98, 98, 98, 98, 97, 97,
  66.                                       97, 97, 96, 96, 96, 96, 95, 95, 95, 94, 94, 94, 93, 93, 93, 92, 92, 92, 91, 91,
  67.                                       90, 90, 89, 89, 89, 88, 88, 87, 87, 86, 86, 85, 85, 84, 84, 83, 82, 82, 81, 81,
  68.                                       80, 80, 79, 78, 78, 77, 76, 76, 75, 74, 74, 73, 72, 72, 71, 70, 69, 69, 68, 67,
  69.                                       66, 66, 65, 64, 63, 62, 62, 61, 60, 59, 58, 57, 56, 56, 55, 54, 53, 52, 51, 50,
  70.                                       49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 31, 30, 29,
  71.                                       28, 27, 26, 25, 23, 22, 21, 20, 19, 17, 16, 15, 14, 12, 11, 10, 9, 7, 6, 5,
  72.                                       3, 2, 1
  73.                                     } ;
  74.  
  75.  
  76. 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,
  77.         int32_t *pn_heart_rate, int8_t *pch_hr_valid)
  78. /**
  79. * \brief        Calculate the heart rate and SpO2 level
  80. * \par          Details
  81. *               By detecting  peaks of PPG cycle and corresponding AC/DC of red/infra-red signal, the an_ratio for the SPO2 is computed.
  82. *               Since this algorithm is aiming for Arm M0/M3. formaula for SPO2 did not achieve the accuracy due to register overflow.
  83. *               Thus, accurate SPO2 is precalculated and save longo uch_spo2_table[] per each an_ratio.
  84. *
  85. * \param[in]    *pun_ir_buffer           - IR sensor data buffer
  86. * \param[in]    n_ir_buffer_length      - IR sensor data buffer length
  87. * \param[in]    *pun_red_buffer          - Red sensor data buffer
  88. * \param[out]    *pn_spo2                - Calculated SpO2 value
  89. * \param[out]    *pch_spo2_valid         - 1 if the calculated SpO2 value is valid
  90. * \param[out]    *pn_heart_rate          - Calculated heart rate value
  91. * \param[out]    *pch_hr_valid           - 1 if the calculated heart rate value is valid
  92. *
  93. * \retval       None
  94. */
  95. {
  96.     uint32_t un_ir_mean;
  97.     int32_t k, n_i_ratio_count;
  98.     int32_t i, n_exact_ir_valley_locs_count, n_middle_idx;
  99.     int32_t n_th1, n_npks;
  100.     int32_t an_ir_valley_locs[15] ;
  101.     int32_t n_peak_interval_sum;
  102.  
  103.     int32_t n_y_ac, n_x_ac;
  104.     int32_t n_spo2_calc;
  105.     int32_t n_y_dc_max, n_x_dc_max;
  106.     int32_t n_y_dc_max_idx, n_x_dc_max_idx;
  107.     int32_t an_ratio[5], n_ratio_average;
  108.     int32_t n_nume, n_denom ;
  109.  
  110.     // calculates DC mean and subtract DC from ir
  111.     un_ir_mean = 0;
  112.     for (k = 0 ; k < n_ir_buffer_length ; k++ ) un_ir_mean += pun_ir_buffer[k] ;
  113.     un_ir_mean = un_ir_mean / n_ir_buffer_length ;
  114.  
  115.     // remove DC and invert signal so that we can use peak detector as valley detector
  116.     for (k = 0 ; k < n_ir_buffer_length ; k++ )
  117.         an_x[k] = -1 * (pun_ir_buffer[k] - un_ir_mean) ;
  118.  
  119.     // 4 pt Moving Average
  120.     for(k = 0; k < BUFFER_SIZE - MA4_SIZE; k++)
  121.     {
  122.         an_x[k] = ( an_x[k] + an_x[k + 1] + an_x[k + 2] + an_x[k + 3]) / (int)4;
  123.     }
  124.     // calculate threshold
  125.     n_th1 = 0;
  126.     for ( k = 0 ; k < BUFFER_SIZE ; k++)
  127.     {
  128.         n_th1 +=  an_x[k];
  129.     }
  130.     n_th1 =  n_th1 / ( BUFFER_SIZE);
  131.     if( n_th1 < 30) n_th1 = 30; // min allowed
  132.     if( n_th1 > 60) n_th1 = 60; // max allowed
  133.  
  134.     for ( k = 0 ; k < 15; k++) an_ir_valley_locs[k] = 0;
  135.     // since we flipped signal, we use peak detector as vSalley detector
  136.     maxim_find_peaks( an_ir_valley_locs, &n_npks, an_x, BUFFER_SIZE, n_th1, 4, 15 );//peak_height, peak_distance, max_num_peaks
  137.     n_peak_interval_sum = 0;
  138.     if (n_npks >= 2)
  139.     {
  140.         for (k = 1; k < n_npks; k++) n_peak_interval_sum += (an_ir_valley_locs[k] - an_ir_valley_locs[k - 1] ) ;
  141.         n_peak_interval_sum = n_peak_interval_sum / (n_npks - 1);
  142.         *pn_heart_rate = (int32_t)( (FS * 60) / n_peak_interval_sum );
  143.         *pch_hr_valid  = 1;
  144.     }
  145.     else
  146.     {
  147.         *pn_heart_rate = -999; // unable to calculate because # of peaks are too small
  148.         *pch_hr_valid  = 0;
  149.     }
  150.  
  151.     //  load raw value again for SPO2 calculation : RED(=y) and IR(=X)
  152.     for (k = 0 ; k < n_ir_buffer_length ; k++ )
  153.     {
  154.         an_x[k] =  pun_ir_buffer[k] ;
  155.         an_y[k] =  pun_red_buffer[k] ;
  156.     }
  157.  
  158.     // find precise min near an_ir_valley_locs
  159.     n_exact_ir_valley_locs_count = n_npks;
  160.  
  161.     //using exact_ir_valley_locs , find ir-red DC andir-red AC for SPO2 calibration an_ratio
  162.     //finding AC/DC maximum of raw
  163.  
  164.     n_ratio_average = 0;
  165.     n_i_ratio_count = 0;
  166.     for(k = 0; k < 5; k++) an_ratio[k] = 0;
  167.     for (k = 0; k < n_exact_ir_valley_locs_count; k++)
  168.     {
  169.         if (an_ir_valley_locs[k] > BUFFER_SIZE )
  170.         {
  171.             *pn_spo2 =  -999 ; // do not use SPO2 since valley loc is out of range
  172.             *pch_spo2_valid  = 0;
  173.             return;
  174.         }
  175.     }
  176.     // find max between two valley locations
  177.     // and use an_ratio betwen AC compoent of Ir & Red and DC compoent of Ir & Red for SPO2
  178.     for (k = 0; k < n_exact_ir_valley_locs_count - 1; k++)
  179.     {
  180.         n_y_dc_max = -16777216 ;
  181.         n_x_dc_max = -16777216;
  182.         if (an_ir_valley_locs[k + 1] - an_ir_valley_locs[k] > 3)
  183.         {
  184.             for (i = an_ir_valley_locs[k]; i < an_ir_valley_locs[k + 1]; i++)
  185.             {
  186.                 if (an_x[i] > n_x_dc_max)
  187.                 {
  188.                     n_x_dc_max = an_x[i];
  189.                     n_x_dc_max_idx = i;
  190.                 }
  191.                 if (an_y[i] > n_y_dc_max)
  192.                 {
  193.                     n_y_dc_max = an_y[i];
  194.                     n_y_dc_max_idx = i;
  195.                 }
  196.             }
  197.             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
  198.             n_y_ac =  an_y[an_ir_valley_locs[k]] + n_y_ac / (an_ir_valley_locs[k + 1] - an_ir_valley_locs[k])  ;
  199.             n_y_ac =  an_y[n_y_dc_max_idx] - n_y_ac;   // subracting linear DC compoenents from raw
  200.             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
  201.             n_x_ac =  an_x[an_ir_valley_locs[k]] + n_x_ac / (an_ir_valley_locs[k + 1] - an_ir_valley_locs[k]);
  202.             n_x_ac =  an_x[n_y_dc_max_idx] - n_x_ac;     // subracting linear DC compoenents from raw
  203.             n_nume = ( n_y_ac * n_x_dc_max) >> 7 ; //prepare X100 to preserve floating value
  204.             n_denom = ( n_x_ac * n_y_dc_max) >> 7;
  205.             if (n_denom > 0  && n_i_ratio_count < 5 &&  n_nume != 0)
  206.             {
  207.                 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) ;
  208.                 n_i_ratio_count++;
  209.             }
  210.         }
  211.     }
  212.     // choose median value since PPG signal may varies from beat to beat
  213.     maxim_sort_ascend(an_ratio, n_i_ratio_count);
  214.     n_middle_idx = n_i_ratio_count / 2;
  215.  
  216.     if (n_middle_idx > 1)
  217.         n_ratio_average = ( an_ratio[n_middle_idx - 1] + an_ratio[n_middle_idx]) / 2; // use median
  218.     else
  219.         n_ratio_average = an_ratio[n_middle_idx ];
  220.  
  221.     if( n_ratio_average > 2 && n_ratio_average < 184)
  222.     {
  223.         n_spo2_calc = uch_spo2_table[n_ratio_average] ;
  224.         *pn_spo2 = n_spo2_calc ;
  225.         *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
  226.     }
  227.     else
  228.     {
  229.         *pn_spo2 =  -999 ; // do not use SPO2 since signal an_ratio is out of range
  230.         *pch_spo2_valid  = 0;
  231.     }
  232. }
  233.  
  234.  
  235. 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 )
  236. /**
  237. * \brief        Find peaks
  238. * \par          Details
  239. *               Find at most MAX_NUM peaks above MIN_HEIGHT separated by at least MIN_DISTANCE
  240. *
  241. * \retval       None
  242. */
  243. {
  244.     maxim_peaks_above_min_height( pn_locs, n_npks, pn_x, n_size, n_min_height );
  245.     maxim_remove_close_peaks( pn_locs, n_npks, pn_x, n_min_distance );
  246.     *n_npks = min( *n_npks, n_max_num );
  247. }
  248.  
  249. 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 )
  250. /**
  251. * \brief        Find peaks above n_min_height
  252. * \par          Details
  253. *               Find all peaks above MIN_HEIGHT
  254. *
  255. * \retval       None
  256. */
  257. {
  258.     int32_t i = 1, riseFound = 0, holdOff1 = 0, holdOff2 = 0, holdOffThresh = 4;
  259.     *n_npks = 0;
  260.  
  261.     while (i < n_size - 1)
  262.     {
  263.         if (holdOff2 == 0)
  264.         {
  265.             if (pn_x[i] > n_min_height && pn_x[i] > pn_x[i - 1])     // find left edge of potential peaks
  266.             {
  267.                 riseFound = 1;
  268.             }
  269.             if (riseFound == 1)
  270.             {
  271.                 if ((pn_x[i] < n_min_height) && (holdOff1 < holdOffThresh))     // if false edge
  272.                 {
  273.                     riseFound = 0;
  274.                     holdOff1 = 0;
  275.                 }
  276.                 else
  277.                 {
  278.                     if (holdOff1 == holdOffThresh)
  279.                     {
  280.                         if ((pn_x[i] < n_min_height) && (pn_x[i - 1] >= n_min_height))
  281.                         {
  282.                             if ((*n_npks) < 15 )
  283.                             {
  284.                                 pn_locs[(*n_npks)++] = i;   // peak is right edge
  285.                             }
  286.                             holdOff1 = 0;
  287.                             riseFound = 0;
  288.                             holdOff2 = 8;
  289.                         }
  290.                     }
  291.                     else
  292.                     {
  293.                         holdOff1 = holdOff1 + 1;
  294.                     }
  295.                 }
  296.             }
  297.         }
  298.         else
  299.         {
  300.             holdOff2 = holdOff2 - 1;
  301.         }
  302.         i++;
  303.     }
  304. }
  305.  
  306. void maxim_remove_close_peaks(int32_t *pn_locs, int32_t *pn_npks, int32_t *pn_x, int32_t n_min_distance)
  307. /**
  308. * \brief        Remove peaks
  309. * \par          Details
  310. *               Remove peaks separated by less than MIN_DISTANCE
  311. *
  312. * \retval       None
  313. */
  314. {
  315.  
  316.     int32_t i, j, n_old_npks, n_dist;
  317.  
  318.     /* Order peaks from large to small */
  319.     maxim_sort_indices_descend( pn_x, pn_locs, *pn_npks );
  320.  
  321.     for ( i = -1; i < *pn_npks; i++ )
  322.     {
  323.         n_old_npks = *pn_npks;
  324.         *pn_npks = i + 1;
  325.         for ( j = i + 1; j < n_old_npks; j++ )
  326.         {
  327.             n_dist =  pn_locs[j] - ( i == -1 ? -1 : pn_locs[i] ); // lag-zero peak of autocorr is at index -1
  328.             if ( n_dist > n_min_distance || n_dist < -n_min_distance )
  329.                 pn_locs[(*pn_npks)++] = pn_locs[j];
  330.         }
  331.     }
  332.  
  333.     // Resort indices int32_to ascending order
  334.     maxim_sort_ascend( pn_locs, *pn_npks );
  335. }
  336.  
  337. void maxim_sort_ascend(int32_t  *pn_x, int32_t n_size)
  338. /**
  339. * \brief        Sort array
  340. * \par          Details
  341. *               Sort array in ascending order (insertion sort algorithm)
  342. *
  343. * \retval       None
  344. */
  345. {
  346.     int32_t i, j, n_temp;
  347.     for (i = 1; i < n_size; i++)
  348.     {
  349.         n_temp = pn_x[i];
  350.         for (j = i; j > 0 && n_temp < pn_x[j - 1]; j--)
  351.             pn_x[j] = pn_x[j - 1];
  352.         pn_x[j] = n_temp;
  353.     }
  354. }
  355.  
  356. void maxim_sort_indices_descend(  int32_t  *pn_x, int32_t *pn_indx, int32_t n_size)
  357. /**
  358. * \brief        Sort indices
  359. * \par          Details
  360. *               Sort indices according to descending order (insertion sort algorithm)
  361. *
  362. * \retval       None
  363. */
  364. {
  365.     int32_t i, j, n_temp;
  366.     for (i = 1; i < n_size; i++)
  367.     {
  368.         n_temp = pn_indx[i];
  369.         for (j = i; j > 0 && pn_x[n_temp] > pn_x[pn_indx[j - 1]]; j--)
  370.             pn_indx[j] = pn_indx[j - 1];
  371.         pn_indx[j] = n_temp;
  372.     }
  373. }
  374.  
  375.  
  376.  
  377.

DHT11温湿度传感器驱动程序： 

dht11.c

  1. #include "dht11.h"
  2. #include "delay.h"
  3.  
  4.  
  5. //由于DHT11为单总线通信，即发送、接收都为同一根数据线，STM32的GPIO无法像51的IO同时配置为输入输出模式，
  6. //因此需要将与DHT11数据线相连的GPIO写两套初始化函数，向DHT11发送数据时先调用DHT11_IO_OUT()函数，再
  7. //发送数据，接收DHT11的数据时先调用DHT11_IO_IN()函数，再接收数据
  8. void DHT11_IO_OUT(void)
  9. {
  10. 	GPIO_InitTypeDef  GPIO_InitStructure;
  11.  	
  12.  //	RCC_APB2PeriphClockCmd(DHT11_GPIO_CLK|RCC_APB2Periph_AFIO, ENABLE);	 //使能PG端口时钟
  13. 	//GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE); //由于PA15为JTAG调试接口，需要先禁用JTAG功能才能作为普通的GPIO口
  14. 	//使用，若使用的是普通的GPIO，可将   RCC_APB2Periph_AFIO  与  GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE)  去掉    //禁用JTAG
  15. 	
  16.  	GPIO_InitStructure.GPIO_Pin = DHT11_GPIO_PIN;				 //PG11端口配置
  17.  	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 		 //推挽输出
  18.  	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  19.  	GPIO_Init(DHT11_GPIO_PORT, &GPIO_InitStructure);				 //初始化IO口
  20. }
  21.  
  22. void DHT11_IO_IN(void)
  23. {
  24. 	GPIO_InitTypeDef  GPIO_InitStructure;
  25.  	
  26.  	RCC_APB2PeriphClockCmd(DHT11_GPIO_CLK|RCC_APB2Periph_AFIO, ENABLE);	 //使能PG端口时钟
  27. 	GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);     //禁用JTAG
  28. 	
  29.  	GPIO_InitStructure.GPIO_Pin = DHT11_GPIO_PIN;				 //PG11端口配置
  30.  	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; 		 //推挽输出
  31.  	GPIO_Init(DHT11_GPIO_PORT, &GPIO_InitStructure);				 //初始化IO口
  32. }
  33.  
  34. //复位DHT11
  35. void DHT11_Rst(void)	   
  36. {                 
  37. 	DHT11_IO_OUT(); 	//SET OUTPUT
  38.   DHT11_DQ_OUT=0; 	//拉低DQ
  39.   delay_ms(20);    	//拉低至少18ms
  40.   DHT11_DQ_OUT=1; 	//DQ=1 
  41. 	delay_us(30);     	//主机拉高20~40us
  42. }
  43. //等待DHT11的回应
  44. //返回1:未检测到DHT11的存在
  45. //返回0:存在
  46. u8 DHT11_Check(void) 	   
  47. {   
  48. 	u8 retry=0;
  49. 	DHT11_IO_IN();//SET INPUT	 
  50.     while (DHT11_DQ_IN&&retry<100)//DHT11会拉低40~80us
  51. 	{
  52. 		retry++;
  53. 		delay_us(1);
  54. 	};	 
  55. 	if(retry>=100)return 1;
  56. 	else retry=0;
  57.     while (!DHT11_DQ_IN&&retry<100)//DHT11拉低后会再次拉高40~80us
  58. 	{
  59. 		retry++;
  60. 		delay_us(1);
  61. 	};
  62. 	if(retry>=100)return 1;	    
  63. 	return 0;
  64. }
  65. //从DHT11读取一个位
  66. //返回值：1/0
  67. u8 DHT11_Read_Bit(void) 			 
  68. {
  69.  	u8 retry=0;
  70. 	while(DHT11_DQ_IN&&retry<100)//等待变为低电平
  71. 	{
  72. 		retry++;
  73. 		delay_us(1);
  74. 	}
  75. 	retry=0;
  76. 	while(!DHT11_DQ_IN&&retry<100)//等待变高电平
  77. 	{
  78. 		retry++;
  79. 		delay_us(1);
  80. 	}
  81. 	delay_us(40);//等待40us
  82. 	if(DHT11_DQ_IN)return 1;
  83. 	else return 0;		   
  84. }
  85. //从DHT11读取一个字节
  86. //返回值：读到的数据
  87. u8 DHT11_Read_Byte(void)    
  88. {        
  89. 	u8 i,dat;
  90. 	dat=0;
  91. 	for (i=0;i<8;i++) 
  92. 	{
  93. 		dat<<=1; 
  94. 		dat|=DHT11_Read_Bit();
  95.   }						    
  96.   return dat;
  97. }
  98. //从DHT11读取一次数据
  99. //temp:温度值(范围:0~50°)
  100. //humi:湿度值(范围:20%~90%)
  101. //返回值：0,正常;1,读取失败
  102. u8 DHT11_Read_Data(u8 *temp,u8 *humi)    
  103. {        
  104.  	u8 buf[5];
  105. 	u8 i;
  106. 	DHT11_Rst();
  107. 	if(DHT11_Check()==0)
  108. 	{
  109. 		for(i=0;i<5;i++)//读取40位数据
  110. 		{
  111. 			buf[i]=DHT11_Read_Byte();
  112. 		}
  113. 		if((buf[0]+buf[1]+buf[2]+buf[3])==buf[4])
  114. 		{
  115. 			*humi=buf[0];
  116. 			*temp=buf[2];
  117. 		}
  118. 	}else return 1;
  119. 	return 0;	    
  120. }
  121. //初始化DHT11的IO口 DQ 同时检测DHT11的存在
  122. //返回1:不存在
  123. //返回0:存在    	 
  124. u8 DHT11_Init(void)
  125. {	 
  126.  	
  127. 			    
  128. 	DHT11_Rst();  //复位DHT11
  129. 	return DHT11_Check();//等待DHT11的回应
  130. } 
  131.  
  132.  
  133.  
  134.  
  135.  
  136.  
  137.

MQ2烟雾传感器驱动程序： 

bsp_adc.c

  1. #include "bsp_adc.h"
  2. #define ADC1_DR_Address    ((u32)0x40012400+0x4c)  //定义ADC的内存地址
  3. #include <math.h>
  4. static int floag1=0;
  5. #define CAL_PPM 20  // 校准环境中PPM值
  6. #define RL			5		// RL阻值
  7. static float R0=1; // 元件在洁净空气中的阻值
  8. float ppm;
  9. __IO uint16_t ADC_ConvertedValue;
  10. static void ADC1_GPIO_Config(void) //ADC端口配置
  11. {
  12. 	GPIO_InitTypeDef GPIO_InitStructure;//GPIO初始化结构体；
  13. 	
  14. 	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);//使能DMA的时钟；
  15. 	
  16. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOC, ENABLE);//打开ADC1和GPIOC的时钟；
  17. 	
  18. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;//配置PC0引脚；
  19. 	
  20. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;//设置工作模式为模拟输入；
  21. 	
  22. 	GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化GPIOC；
  23. }
  24. static void ADC1_Mode_Config(void)  //配置ADC1的模式
  25. {
  26. 	/********以下是有关DMA的相关配置*************/
  27. 	
  28. 	DMA_InitTypeDef DMA_InitStructure;//DMA初始化结构体定义DMA初始化变量
  29. 	
  30. 	ADC_InitTypeDef ADC_InitStructure;//ADC初始化结构体定义ADC初始化变量
  31. 	
  32. 	DMA_DeInit(DMA1_Channel1);//设置DMA1通道1
  33. 	
  34. 	
  35. 	DMA_InitStructure.DMA_PeripheralBaseAddr = ADC1_DR_Address;//设定ADC的地址；
  36. 	
  37. 	DMA_InitStructure.DMA_MemoryBaseAddr = (u32)&ADC_ConvertedValue;//内存地址，采集的数据存在这里；
  38. 	
  39. 	DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;//设为源，表示数据是从这里出发的；
  40. 	
  41. 	DMA_InitStructure.DMA_BufferSize = 1;//因为一次只发送一个数据所以设为1；
  42. 	
  43. 	DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;//因为只涉及一路数据的采集发送因此内存地址不变
  44. 	
  45. 	DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;//因为只涉及一路数据的采集发送因此外设地址不变
  46. 	
  47. 	DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;//外设至少要半字即16位才可以满足要求
  48. 	
  49. 	DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;//内存至少要半字即16位才可以满足要求
  50. 	
  51. 	DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;//DMA模式为循环传输，因为要采集多次;
  52. 	
  53. 	DMA_InitStructure.DMA_Priority = DMA_Priority_High;//设置为高、中、低优先级都可以因为只有一路在采集
  54. 	
  55. 	DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;//关闭内存到内存的传输，因为我们需要的是外设传到内存的传输
  56. 	
  57. 	DMA_Init(DMA1_Channel1,&DMA_InitStructure);//DMA1通道1最后初始化
  58. 	
  59. 	DMA_Cmd(DMA1_Channel1, ENABLE);//使能DMA1的通道1；
  60. 	
  61.  
  62. 	
  63. 	/********以下是有关ADC的相关配置*************/
  64. 	
  65. 	ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;//设置为独立ADC模式，因为其采集只有一个通道；
  66. 	
  67. 	ADC_InitStructure.ADC_ScanConvMode = DISABLE;//禁止扫描模式，扫描模式适用于多通道采集
  68. 	
  69. 	ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;//开启连续转换，以不停地进行ADC转换
  70. 	
  71. 	ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;//不使用外部触发转换，而使用内部软件触发
  72. 	
  73. 	ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;//采集数据右对齐
  74. 	
  75. 	ADC_InitStructure.ADC_NbrOfChannel = 1;//ADC number of channel,即要转换的通道数目；
  76. 	
  77. 	ADC_Init(ADC1, &ADC_InitStructure);//调用ADC初始化库函数
  78. 	
  79. 	RCC_ADCCLKConfig(RCC_PCLK2_Div8);//配置ADC时钟为8分频，9MHZ
  80. 	
  81. 	ADC_RegularChannelConfig(ADC1, ADC_Channel_10, 1, ADC_SampleTime_55Cycles5);//配置ADC1的通道为55.5个采样周期，
  82. 	
  83. 	ADC_DMACmd(ADC1, ENABLE);//使能ADC1的DMA传输
  84. 	
  85. 	ADC_Cmd(ADC1, ENABLE);//使能ADC1;
  86. 	
  87. 	while(ADC_GetResetCalibrationStatus(ADC1));//等待校准寄存器复位完成；
  88. 	
  89. 	ADC_StartCalibration(ADC1);//调用校准函数开始ADC校准；
  90. 	
  91. 	while(ADC_GetResetCalibrationStatus(ADC1));//等待校准寄存器复位完成；
  92. 	
  93. 	ADC_SoftwareStartConvCmd(ADC1, ENABLE);//前面不采用外部触发，而是采用内部软件触发，此处使能软件触发
  94. 	
  95.  
  96. }
  97.  
  98. void ADC1_Init(void)
  99. {
  100. 	 ADC1_GPIO_Config();
  101. 	 ADC1_Mode_Config();
  102. 		
  103. }	
  104.  
  105.  
  106.  // 传感器校准函数
  107. void MQ2_PPM_Calibration(float RS)
  108. {
  109.     R0 = RS / pow(CAL_PPM / 613.9f, 1 / -2.074f);
  110. }
  111.  
  112.  // MQ2传感器数据处理
  113. float MQ2_GetPPM(void)
  114. {
  115.     float Vrl = (float) ADC_ConvertedValue/4096*3.3;
  116.     float RS = (3.3f - Vrl) / Vrl * RL; 
  117.     if(Vrl>1&&floag1==0) // 获取系R0
  118.     {
  119. 		MQ2_PPM_Calibration(RS);
  120. 		floag1=1;
  121.     }
  122.     ppm = 613.9f * pow(RS/R0, -2.074f);
  123.     return  ppm;
  124. }
  125.  
  126.

3、基于MQTT协议的数据传输

        STM32开发板通过ESP8266模块连接上局域网（也就是我们家庭中的路由器、WIFI），同时ESP8266通过互联网连接到远程MQTT服务器（MQTT Server），这样便达到了将传感器所采集到的数据储存在云端，可供多个客户端进行访问。
         在数据传输中，用到了一种很核心的物联网数据传输协议：MQTT协议。MQTT是一个客户端服务端架构的发布/订阅模式的消息传输协议。它的设计思想是轻巧、开放、简单、规范，易于实现。这些特点使得它对很多场景来说都是很好的选择，特别是对于受限的环境如机器与机器的通信（M2M）以及物联网环境（IoT）。它的基本原理是：一个客户端（ESP8266）向服务器发布（Publish）一个带有传感采集到的数据的主题，则另外一个客户端（软件上位机）则通过向服务器订阅（Subscribe）服务器上ESP8266客户端发布的主题，即可以接收到各传感器采集到的数据，从而达到实时显示、实时检测的目的。
        同时数据在传输的过程中都是以JSON格式进行传输的。

 核心代码介绍：

        由于该部分核心代码过多，就不在本文展示，请到我的github源码仓库进行访问，在这里简要对一些程序文件进行说明：

esp8266.c : ESP8266模块的驱动程序
onenet.c : 数据上传云域网程序
MqttKit.c : 客户端对服务器进行一系列数据传输程序（例如主题的发布、订阅）

4、微信小程序上位机设计

        小程序是一种全新的连接用户与服务的方式，它可以在微信内被便捷地获取和传播，同时具有出色的使用体验。同时因为它不像安卓APP一样需要下载，可以免安装使用，有一定的便利性，所以本项目采用微信小程序来开发上位机。下面该软件上位机的各个UI界面及其所对应的功能

1.主界面

        这是该软件的首页，通过和风天气平台的支持，可以获取到当前你所在地的天气状况，同时正中间的三个控件可以进入三个不同的系统。

代码：

index.wxml:

  1. <!--pages/home/home.wxml-->
  2. <view class="wrapper">
  3.     <view class="header-wrapper" bindtap="toDetail">
  4.         <view class="header-title"> 
  5.             <text>空气质量-{{weather_quality}}</text>
  6.             <text>{{city}}-{{area}}</text>
  7.         </view>
  8.         <view class="header-text">
  9.             <text>{{weather_temp}}℃</text>
  10.             <text>{{weather_text}}</text>
  11.         </view>
  12.         <view class="weather-advice">
  13.             <text>{{advice}}</text>
  14.         </view>
  15.     </view>
  16.     <view class="botton-wrapper">
  17.         <button id="btn1" bindtap="toEnv">环境监测系统</button>
  18.         <button id="btn2" bindtap="toHealth">健康监测系统</button>
  19.         <button id="btn2" bindtap="toCanvas">查看实时动态曲线</button>
  20.     </view>
  21. </view>
  22.

 index.wxss

  1. /* pages/home/home.wxss */
  2. .wrapper{
  3.   padding: 30rpx 20rpx;
  4.   /* background-color: beige; */
  5. }
  6. .header-wrapper{
  7.   background-color: #3d7ef6;
  8.   border-radius: 40rpx;
  9.   padding: 30rpx 50rpx;
  10.   box-shadow: #d6d6d6 1px 1px 1px;
  11.   color: floralwhite;
  12. }
  13. .header-title{
  14.   display: flex;
  15.   font-size: 30rpx;
  16.   justify-content: space-between;
  17. }
  18. .header-text{
  19.   display: flex;
  20.   font-size: 48rpx;
  21.   font-weight: 400;
  22.   padding: 7rpx 0rpx;
  23.   justify-content: space-between;
  24. }
  25. .weather-advice{
  26.   font-size: 26rpx;
  27.   margin-top: 50rpx;
  28. }
  29. .botton-wrapper{
  30.   padding: 240rpx 30rpx;
  31.   
  32. }
  33.  
  34. #btn1{
  35.   height: 80rpx;
  36.   width: 60% ;
  37.   color: white;
  38.   font-size: 30rpx ;
  39.   background-color: #3d7ef6 ;
  40.   margin-top: 5rpx;
  41.   justify-content: center;
  42.   box-shadow: #d6d6d6 2px 2px 2px;
  43.   border-radius: 40rpx;
  44. }
  45. #btn2{
  46.   height: 80rpx;
  47.   width: 60% ;
  48.   color: white;
  49.   font-size: 30rpx ;
  50.   background-color: #3d7ef6 ;
  51.   margin-top: 50rpx;
  52.   justify-content: center;
  53.   box-shadow: #d6d6d6 2px 2px 2px;
  54.   border-radius: 40rpx;
  55. }

 index.js

  1. Page({
  2.   /**
  3.    * 页面的初始数据
  4.    */
  5.   data: {
  6.     weather_quality:"请求中",
  7.     weather_text:"请求中",
  8.     weather_temp:"请求中",
  9.     city:"请求中",
  10.     area:"请求中",
  11.     advice:"请求中"
  12.  
  13.   },
  14.   toEnv(){
  15.     wx.navigateTo({
  16.       url: '../env/env'
  17.     })
  18.   },
  19.   toHealth(){
  20.     wx.navigateTo({
  21.       url: '../healthy/healthy'
  22.     })
  23.   },
  24.   toCanvas(){
  25.     wx.navigateTo({
  26.       url: '../curves/curves'
  27.     })
  28.   },
  29.   toDetail(){
  30.     wx.navigateTo({
  31.       url: '../weather/weather'
  32.     })
  33.   },
  34.   toBluetooth(){
  35.     wx.navigateTo({
  36.       url: '../bluetooth/bluetooth'
  37.     })
  38.   },
  39.   /**
  40.    * 生命周期函数--监听页面加载
  41.    */
  42.   onLoad: function (options) {
  43.     
  44.   },
  45.  
  46.   onShow: function () {
  47.     var that=this
  48.     wx.getLocation({
  49.       success(res){
  50.         const {latitude} = res
  51.         const {longitude} = res
  52.         const key = '1c6a3dc86f2544a3b18828ca409858c9'
  53.         // 请求温度与天气状况
  54.         wx.request({
  55.           url: `https://devapi.qweather.com/v7/weather/now?location=${longitude},${latitude}&key=${key}`,
  56.           success(res){
  57.           //  console.log(res)
  58.             that.setData({
  59.               weather_temp:res.data.now.temp,
  60.               weather_text:res.data.now.text
  61.             })
  62.           }
  63.         })
  64.         // 地理位置
  65.         wx.request({
  66.           url: `https://geoapi.qweather.com/v2/city/lookup?location=${longitude},${latitude}&key=${key}`,
  67.           success(res){
  68.           //  console.log(res)
  69.             that.setData({
  70.               city:res.data.location[0].adm2,
  71.               area:res.data.location[0].name
  72.             })
  73.           }
  74.         })
  75.         //指数
  76.         wx.request({
  77.           url: `https://devapi.qweather.com/v7/indices/1d?location=${longitude},${latitude}&key=${key}&type=${0}`,
  78.           success(res){
  79.            // console.log(res)
  80.             that.setData({
  81.               advice:res.data.daily[2].text
  82.             })
  83.           }
  84.         })
  85.         //空气质量
  86.         wx.request({
  87.           url: `https://devapi.qweather.com/v7/air/now?location=${longitude},${latitude}&key=${key}`,
  88.           success(res){
  89.             console.log(res)
  90.             that.setData({
  91.               weather_quality:res.data.now.category
  92.             })
  93.           }
  94.         })
  95.       }
  96.     })
  97.   },
  98.  
  99.   /**
  100.    * 生命周期函数--监听页面隐藏
  101.    */
  102.   onHide: function () {
  103.     
  104.   },
  105.  
  106.   /**
  107.    * 生命周期函数--监听页面卸载
  108.    */
  109.   onUnload: function () {
  110.     
  111.   },
  112.  
  113.   /**
  114.    * 页面相关事件处理函数--监听用户下拉动作
  115.    */
  116.   onPullDownRefresh: function () {
  117.     
  118.   },
  119.  
  120.   /**
  121.    * 页面上拉触底事件的处理函数
  122.    */
  123.   onReachBottom: function () {
  124.     
  125.   },
  126.  
  127.   /**
  128.    * 用户点击右上角分享
  129.    */
  130.   onShareAppMessage: function () {
  131.     
  132.   }
  133. })

2. 健康监测系统 

用于显示MAX30102心率血氧传感器所采集到的人体的心率、血氧值，可以对其进行实时监测并显示

healthy.wxml :

  1. <view class="body-wrapper">
  2.     <view class="sensor-others">
  3.         <image class="sensor-logo-water" src="../../icon/heart.png"/>
  4.         <view class="sensor-text">
  5.             <view class="sensor-title">实时心率</view>
  6.             <view class="sensor-value">{{Heart}}</view>
  7.         </view>
  8.     </view>
  9. </view>
  10. <view class="body-wrapper">
  11.     <view class="sensor-others">
  12.         <image class="sensor-logo-oxygen" src="../../icon/oxygen.png"/>
  13.         <view class="sensor-text">
  14.             <view class="sensor-title">血氧浓度</view>
  15.             <view class="sensor-value">{{Spo2}}%</view>
  16.         </view>
  17.     </view>
  18. </view>

healty.wxss: 

  1. /* pages/healthy/healthy.wxss *//* pages/env/env.wxss */
  2. .body-wrapper{
  3.     padding: 30rpx 20rpx;
  4. }
  5. .sensor{
  6.     width: 100%;
  7.     height: 190rpx;
  8.     border-radius: 40rpx;
  9.     box-shadow: #d6d6d6 1px 1px 5px;
  10.     margin-top: 50rpx;
  11.     display: flex;
  12.     justify-content: space-between;
  13. }
  14. .sensor-logo{
  15.     padding: 20rpx 30rpx;
  16.     height: 130rpx;
  17.     width: 190rpx;
  18.     margin-top: 10rpx;
  19. }
  20. .sensor-logo-water{
  21.     padding: 20rpx 50rpx;
  22.     height: 130rpx;
  23.     width: 180rpx;
  24.     margin-top: 10rpx;
  25. }
  26. .sensor-logo-oxygen{
  27.     padding: 20rpx 90rpx;
  28.     height: 118rpx;
  29.     width: 120rpx;
  30.     margin-top: 10rpx;
  31. }
  32. .sensor-text{
  33.     padding: 0rpx 120rpx;
  34.     margin-top: 26rpx;
  35.     color: #2e2e2e;
  36. }
  37. .sensor-title{
  38.     font-size: 35rpx;
  39. }
  40. .sensor-value{
  41.     font-size: 66rpx;
  42. }
  43. .sensor-others{
  44.     width: 100%;
  45.     height: 190rpx;
  46.     border-radius: 40rpx;
  47.     box-shadow: #d6d6d6 1px 1px 5px;
  48.     margin-top: 0rpx;
  49.     display: flex;
  50.     justify-content: space-between;
  51. }

healty.js 

  1. var mqtt=require('../../utils/mqtt.min.js')
  2. let client=null
  3. Page({
  4.     data: {
  5.         Heart:0,
  6.         Spo2:0
  7.     },
  8.     /**
  9.      * 生命周期函数--监听页面加载
  10.      */
  11.     onLoad: function (options) {
  12.         this.connectmqtt()
  13.     },
  14.     connectmqtt:function(){
  15.         var that=this
  16.         const options={
  17.             connectTimeout:4000,
  18.             clientId:"d1f22er224",
  19.             port:8084,
  20.             username:'f585c3d5f499ffea9b710f13709a855d',
  21.             password:'123456'
  22.         }
  23.         client=mqtt.connect('wxs://t.yoyolife.fun/mqtt',options)
  24.         client.on('connect',(e)=>{
  25.             console.log("mqtt服务器连接成功")
  26.             client.subscribe('/iot/943/pub',
  27.             {qos:0},function(err){
  28.                 if(!err){
  29.                     console.log("订阅成功！")
  30.                 }
  31.             })
  32.         })
  33.         client.on('message',function(topic,message){
  34.             let dataFrameDev=[]
  35.             dataFrameDev=JSON.parse(message)
  36.             console.log(dataFrameDev)
  37.         })
  38.     }
  39.   
  40. })

3. 环境监测系统         

        用于显示DHT11温湿度传感器、MQ2传感器所采集到的环境参数数据，可以对其进行实时监测并显示。

env.wxml:

  1. <!--pages/env/env.wxml-->
  2. <view class="body-wrapper">
  3.     <view class="sensor">
  4.         <image class="sensor-logo" src="../../icon/temperature.png"/>
  5.         <view class="sensor-text">
  6.             <view class="sensor-title">实时温度</view>
  7.             <view class="sensor-value">{{Temp}}℃</view>
  8.         </view>
  9.     </view>
  10. </view>
  11. <view class="body-wrapper">
  12.     <view class="sensor-others">
  13.         <image class="sensor-logo-water" src="../../icon/water.png"/>
  14.         <view class="sensor-text">
  15.             <view class="sensor-title">实时湿度</view>
  16.             <view class="sensor-value">{{Hum}}%</view>
  17.         </view>
  18.     </view>
  19. </view>
  20. <view class="body-wrapper">
  21.     <view class="sensor-others">
  22.         <image class="sensor-logo-smoke" src="../../icon/smoke.png"/>
  23.         <view class="sensor-text">
  24.             <view class="sensor-title">烟雾浓度</view>
  25.             <view class="sensor-value">{{Smoke}}</view>
  26.         </view>
  27.     </view>
  28. </view>
  29. <view class="body-wrapper">
  30.     <view class="sensor-others">
  31.         <image class="sensor-logo" src="../../icon/lx.png"/>
  32.         <view class="sensor-text">
  33.             <view class="sensor-title">光照度</view>
  34.             <view class="sensor-value">29lx</view>
  35.         </view>
  36.     </view>
  37. </view>
  38. <view class="control-wrapper">
  39.     <view class="body-wrapper">
  40.     <view class="control">
  41.         <image class="control-logo" src="../../icon/beep.png"/>
  42.         <view class="control-text">
  43.             <view class="control-title">报警器</view>
  44.             <view class="control-value">
  45.                 <switch bindchange="handleLED" checked="{{true}}"></switch>
  46.             </view>
  47.         </view>
  48.     </view>
  49. </view>
  50. <view class="body-wrapper">
  51.     <view class="control">
  52.         <image class="control-logo" src="../../icon/led.png"/>
  53.         <view class="control-text">
  54.             <view class="control-title">房间灯</view>
  55.             <view class="control-value">
  56.                 <switch bindchange="handleLED" checked="{{true}}"></switch>
  57.             </view>
  58.         </view>
  59.     </view>
  60.     <view>{{event}}</view>
  61. </view>
  62. </view>

 env.wxss

  1. /* pages/env/env.wxss */
  2. .body-wrapper{
  3.     padding: 30rpx 20rpx;
  4. }
  5. .sensor{
  6.     width: 100%;
  7.     height: 190rpx;
  8.     border-radius: 40rpx;
  9.     box-shadow: #d6d6d6 1px 1px 5px;
  10.     margin-top: 50rpx;
  11.     display: flex;
  12.     justify-content: space-between;
  13. }
  14. .sensor-logo{
  15.     padding: 20rpx 30rpx;
  16.     height: 130rpx;
  17.     width: 190rpx;
  18.     margin-top: 10rpx;
  19. }
  20. .sensor-logo-water{
  21.     padding: 20rpx 50rpx;
  22.     height: 130rpx;
  23.     width: 180rpx;
  24.     margin-top: 10rpx;
  25. }
  26. .sensor-logo-smoke{
  27.     padding: 20rpx 50rpx;
  28.     height: 130rpx;
  29.     width: 140rpx;
  30.     margin-top: 10rpx;
  31. }
  32. .sensor-text{
  33.     padding: 0rpx 120rpx;
  34.     margin-top: 26rpx;
  35.     color: #2e2e2e;
  36. }
  37. .sensor-title{
  38.     font-size: 35rpx;
  39. }
  40. .sensor-value{
  41.     font-size: 66rpx;
  42. }
  43. .sensor-others{
  44.     width: 100%;
  45.     height: 190rpx;
  46.     border-radius: 40rpx;
  47.     box-shadow: #d6d6d6 1px 1px 5px;
  48.     margin-top: 0rpx;
  49.     display: flex;
  50.     justify-content: space-between;
  51. }
  52. .control{
  53.     width: 100%;
  54.     height: 190rpx;
  55.     border-radius: 40rpx;
  56.     box-shadow: #d6d6d6 1px 1px 5px;
  57.     margin-top: 0rpx;
  58.     display: flex;
  59.     justify-content: space-between;
  60. }
  61. .control-logo{
  62.     padding: 40rpx 30rpx;
  63.     height: 100rpx;
  64.     width: 100rpx;
  65.     margin-top: 10rpx;
  66. }
  67. .control-text{
  68.     padding: 0rpx 30rpx;
  69.     margin-top: 26rpx;
  70.     color: #2e2e2e;
  71. }
  72. .control-title{
  73.     font-size: 33rpx;
  74. }
  75. .control-value{
  76.     font-size: 60rpx;
  77. }
  78. .control-wrapper{
  79.     display: flex;
  80.     padding: 0rpx 19.5rpx;
  81. }

 env.js

  1. var mqtt=require('../../utils/mqtt.min.js')
  2. var client=null
  3. Page({
  4.     /**
  5.      * 页面的初始数据
  6.      */
  7.     data: {
  8.         Temp:0,
  9.         Hum:0,
  10.         Smoke:0,
  11.         Led:false,
  12.         Beep:false,
  13.         event:""
  14.     },
  15.     /**
  16.      * 生命周期函数--监听页面加载
  17.      */
  18.     onLoad(){
  19.         this.connectmqtt()
  20.     },
  21.     connectmqtt:function(){
  22.         var that=this
  23.         const options={
  24.             connectTimeout:4000,
  25.             clientId:"df2er24",
  26.             port:8084,
  27.             username:'f585c3d5f499ffea9b710f13709a855d',
  28.             password:'123456'
  29.         }
  30.         client=mqtt.connect('wxs://t.yoyolife.fun/mqtt',options)
  31.         client.on('connect',(e)=>{
  32.             console.log("服务器连接成功")
  33.             client.subscribe('/iot/943/pub',{qos:0},function(err){
  34.                 if(!err){
  35.                     console.log("订阅成功")
  36.                 }
  37.             })
  38.         })
  39.         // 信息监听事件
  40.         client.on('message', function(topic,message){
  41.            // console.log(topic)
  42.             let dataFrameDev ={}
  43.             dataFrameDev = JSON.parse(message)
  44.             console.log(dataFrameDev)
  45.             that.setData({
  46.                 Temp:dataFrameDev.Temp,
  47.                 Hum:dataFrameDev.Hum,
  48.                 Smoke:dataFrameDev.Smoke
  49.             })
  50.             console.log(that.data.Temp)
  51.         })
  52.         client.on('reconnect', (error)=>{
  53.             console.log('正在重新连接'+error)
  54.         })
  55.         client.on('error', (error)=>{
  56.             console.log('连接失败')
  57.         })
  58.     },
  59.     handleLED(e){
  60.         var that=this
  61.       //  console.log(e)
  62.         let {value}=e.detail
  63.       //  console.log(value)
  64.       that.setData({
  65.           Led:value,
  66.       })
  67.       if(value===true){
  68.           that.setData({
  69.             event:"您已开灯！",
  70.           })
  71.           client.publish('/iot/943/sub','{"target":"LED","value":1}',function(err){
  72.             if(!err){
  73.               console.log("成功发布开灯命令")
  74.             }
  75.           })
  76.       }else{
  77.         that.setData({
  78.             event:""
  79.           })
  80.           client.publish('/iot/943/sub','{"target":"LED","value":0}',function(err){
  81.             if(!err){
  82.               console.log("成功发布关灯命令")
  83.               }
  84.             })
  85.       }
  86.  
  87.     }
  88. })

4. 显示实时动态曲线         

        为了能显示出一段时间内各个参数的动态变化过程，这里开发了一个实时动态曲线功能，每当接收到服务端传来的消息，则刷新一次曲线从而达到实时更新的目的。

curves.wxml

  1. <Tabs list="{{list}}" binditemChange="handleItemChange">
  2.     <block wx:if="{{list[0].isActive}}" class="tabs"> 
  3.         <view class="body">
  4.             <view class="body-content">
  5.         <view class="body-title">温湿度、烟雾浓度实时曲线图</view>
  6.             <view class="meandata-body">
  7.                 <view class="meandata">
  8.                 <view>
  9.                     <view>平均浓度</view>
  10.                     <view>{{smoke_average}}bpm</view>
  11.                 </view>
  12.                 <view>
  13.                     <view>平均湿度</view>
  14.                     <view>{{hum_average}}%</view>
  15.                 </view>
  16.                 <view>  
  17.                     <view>平均温度</view>
  18.                     <view>{{temp_average}}℃</view>
  19.                 </view>
  20.                 </view>
  21.             </view>
  22.         <canvas canvas-id="lineCanvas" disable-scroll="true" class="canvas" bindtouchstart="touchHandler"></canvas>
  23.         <view class="timestyle">{{time}}</view>
  24.             </view>
  25.         </view>
  26.     </block>
  27.     <block wx:elif="{{list[1].isActive}}"> 
  28.         <view class="detail-title">
  29.             <view class="title-time">时间</view>
  30.             <view class="title-temp">温度</view>
  31.             <view class="title-hum">湿度</view>
  32.             <view class="title-smoke">烟雾浓度</view>
  33.         </view>
  34.         <view class="data">
  35.             <view class="data-time">
  36.                 <view wx:for="{{time_array}}" wx:key="*this">{{item}}</view>
  37.             </view>
  38.             <view class="data-temp">
  39.                 <view wx:for="{{Temp_array}}" wx:key="*this" class="data-temp">{{item}}℃</view>
  40.             </view>
  41.             <view class="data-hum">
  42.                 <view wx:for="{{Hum_array}}" wx:key="*this" class="data-hum">{{item}}%</view>
  43.             </view>
  44.             <view class="data-smoke">
  45.                 <view wx:for="{{Smoke_array}}" wx:key="*this" class="data-smoke">{{item}}bpm</view>
  46.         </view>
  47.         </view>
  48.     </block>
  49.  
  50. </Tabs>
  51.  
  52.  
  53.

curves.wxss 

  1. page {
  2.   background-color: rgba(239, 239, 240);
  3. }
  4. .body{
  5.   padding: 0rpx 20rpx;
  6.   margin-top: 100rpx;
  7. }
  8. .body-content{
  9.   background-color:#ffffff;
  10.   border-radius: 40rpx;
  11. }
  12. .body-title{
  13.   display: flex;
  14.   justify-content: center;
  15.   font-size: 30rpx;
  16.   padding: 50rpx 0rpx 20rpx;
  17. }
  18. .meandata-body{
  19.   padding: 20rpx 39rpx;
  20. }
  21. .meandata{
  22.   display: flex;
  23.   justify-content: space-around;
  24.   border-bottom: 1rpx solid rgba(216, 216, 216, 1);
  25.   border-top: 1rpx solid rgba(216, 216, 216, 1);
  26.   padding: 24rpx;
  27. }
  28. .canvas {
  29.   width: 100%;
  30.   height: 550rpx;
  31.   
  32. }
  33. .timestyle{
  34.   padding: 50rpx 165rpx;
  35. }
  36.  
  37. .detail-title{
  38.   display: flex;
  39. }
  40.  
  41. .data-temp{
  42.   padding: 19rpx 30rpx;
  43. }
  44. .data-hum{
  45.   padding: 19rpx 30rpx;
  46. }
  47. .data-smoke{
  48.   padding: 19rpx 30rpx;
  49. }
  50. .data{
  51.   display: flex;
  52. }
  53. .title-time{
  54.   padding: 0rpx 0rpx 0rpx 60rpx;
  55. }
  56. .title-temp{
  57.   padding: 0rpx 0rpx 0rpx 111rpx;
  58. }
  59. .title-hum{
  60.   padding: 0rpx 0rpx 0rpx 117rpx;
  61. }
  62. .title-smoke{
  63.   padding: 0rpx 0rpx 0rpx 140rpx;
  64. }

curves.js

  1. // pages/index/lookrecord/lookrecord.js
  2. var wxCharts = require('../../utils/wxcharts.js');   //引入wxChart文件
  3. var mqtt=require('../../utils/mqtt.min.js') // 引入mqtt文件
  4. var util = require("../../utils/util.js");
  5. var client=null
  6. var app = getApp();
  7. var lineChart = null;
  8. Page({
  9.  
  10.   /**
  11.    * 页面的初始数据
  12.    */
  13.   data: {
  14.     list:[
  15.       {
  16.         id:0,
  17.         name:"趋势图",
  18.         isActive:true
  19.       },{
  20.           id:1,
  21.           name:"数据记录",
  22.           isActive:false
  23.       },
  24.     ],
  25.     time:"",
  26.     xtime:"",
  27.     Temp:0,
  28.     temp_average:0,
  29.     temp_sum:0,
  30.  
  31.     Hum:0,
  32.     hum_average:0,
  33.     hum_sum:0,
  34.  
  35.     Smoke:0,
  36.     smoke_average:0,
  37.     smoke_sum:0,
  38.  
  39.     Temp_array:[],
  40.     Hum_array:[],
  41.     Smoke_array:[],
  42.     time_array:[],
  43.     waterwaterdata:[50, 100, 80, 115, 120, 90, 125],
  44.     smokesmokedata:[60, 70, 90, 105, 120, 130, 95],
  45.     tempdata: [60,90, 60, 110,120,105,70],  //数据点
  46.     categories: ['2018-6-13', '2018-6-14', '2018-6-15', '2018-6-16', '2018-6-17', '2018-6-18', '2018-6-19'],    //模拟的x轴横坐标参数
  47.   },
  48.  
  49.   touchHandler: function (e) {
  50.     lineChart.showToolTip(e, {
  51.       // background: '#7cb5ec',
  52.       format: function (item, category) {
  53.         return category + ' ' + item.name + ':' + item.data
  54.       }
  55.     });
  56.   },
  57.   /**
  58.    * 生命周期函数--监听页面加载
  59.    */
  60.   onLoad(){
  61.     this.curve()
  62.     this.connectmqtt()
  63.   //  this.gettime()
  64.   },
  65.   onShow:function(){
  66.     this.notification()  // 调用方法
  67.   },
  68.   connectmqtt:function(){
  69.     var that=this
  70.     const options={
  71.         connectTimeout:4000,
  72.         clientId:"df2er24",
  73.         port:8084,
  74.         username:'f585c3d5f499ffea9b710f13709a855d',
  75.         password:'123456'
  76.     }
  77.     client=mqtt.connect('wxs://t.yoyolife.fun/mqtt',options)
  78.     client.on('connect',(e)=>{
  79.         console.log("服务器连接成功")
  80.         client.subscribe('/iot/943/pub',{qos:0},function(err){
  81.             if(!err){
  82.                 console.log("订阅成功")
  83.             }
  84.         })
  85.     })
  86.     // 信息监听事件
  87.     client.on('message', function(topic,message){
  88.        // console.log(topic)
  89.         let dataFrameDev ={}
  90.         dataFrameDev = JSON.parse(message)
  91.         console.log(dataFrameDev)
  92.         that.setData({
  93.             Temp:dataFrameDev.Temp,
  94.             Hum:dataFrameDev.Hum,
  95.             Smoke:dataFrameDev.Smoke,
  96.         })
  97.         // 设置温度、湿度、烟雾浓度的数组
  98.         that.setData({
  99.             Temp_array:that.data.Temp_array.concat(that.data.Temp),
  100.             Hum_array:that.data.Hum_array.concat(that.data.Hum),
  101.             Smoke_array:that.data.Smoke_array.concat(that.data.Smoke)
  102.         })
  103.         console.log(that.data.Temp)
  104.         console.log(that.data.Temp_array)
  105.         console.log(that.data.Hum_array)
  106.         console.log(that.data.Smoke_array)
  107.  
  108.         // 获取到sensor data 后开始获取本地时间
  109.         var xtime=that.data.xtime
  110.         that.setData({
  111.             xtime:util.formatTime(new Date())
  112.         })
  113.         console.log(that.data.xtime)
  114.         that.setData({
  115.           time_array:that.data.time_array.concat(that.data.xtime)
  116.         })
  117.  
  118.  
  119.         // 求烟雾浓度平均值
  120.         var smoke_average=that.data.smoke_average
  121.         var Smoke_array=that.data.Smoke_array
  122.         var smoke_sum=that.data.smoke_sum
  123.         that.setData({
  124.           smoke_sum:smoke_sum+that.data.Smoke,
  125.           smoke_average:parseInt(that.data.smoke_sum/(Smoke_array.length))
  126.         })
  127.         console.log(that.data.time_array)
  128.         console.log("平均浓度"+that.data.smoke_average)
  129.  
  130.         // 求温度平均值
  131.         var temp_average=that.datatempe_average
  132.         var Temp_array=that.data.Temp_array
  133.         var temp_sum=that.data.temp_sum
  134.         that.setData({
  135.           temp_sum:temp_sum+that.data.Temp,
  136.           temp_average:parseInt(that.data.temp_sum/(Temp_array.length))
  137.         })
  138.         console.log(that.data.time_array)
  139.         console.log("平均温度"+that.data.temp_average)
  140.  
  141.         // 求平均湿度
  142.         var hum_average=that.data.hum_average
  143.         var Hum_array=that.data.Hum_array
  144.         var hum_sum=that.data.hum_sum
  145.         that.setData({
  146.           hum_sum:hum_sum+that.data.Hum,
  147.           hum_average:parseInt(that.data.hum_sum/(Hum_array.length))
  148.         })
  149.         console.log(that.data.time_array)
  150.         console.log("平均湿度"+that.data.hum_average)
  151.  
  152.     })
  153.     client.on('reconnect', (error)=>{
  154.         console.log('正在重新连接'+error)
  155.     })
  156.     client.on('error', (error)=>{
  157.         console.log('连接失败')
  158.     })
  159. },
  160.   curve (e) {
  161.     var that=this
  162.     
  163.     var windowWidth = '', windowHeight='';    //定义宽高
  164.     that.data.setInter = setInterval(function(){
  165.       var waterwaterdata=that.data.Hum_array
  166.       var smokesmokedata=that.data.Smoke_array
  167.       var tempdata=that.data.Temp_array
  168.       
  169.       var categories=that.data.time_array
  170.       try {
  171.         var res = wx.getSystemInfoSync();    //试图获取屏幕宽高数据
  172.         windowWidth = res.windowWidth / 750 * 690;   //以设计图750为主进行比例算换
  173.         windowHeight = res.windowWidth / 750 * 550    //以设计图750为主进行比例算换
  174.       } catch (e) {
  175.         console.error('getSystemInfoSync failed!');   //如果获取失败
  176.       }
  177.       lineChart = new wxCharts({     //定义一个wxCharts图表实例
  178.         canvasId: 'lineCanvas',     //输入wxml中canvas的id
  179.         type: 'line',       //图标展示的类型有:'line','pie','column','area','ring','radar'
  180.         categories: categories,
  181.         animation: true,  //是否开启动画
  182.         series: [{   //具体坐标数据
  183.           name: '温度',  //名字
  184.           data: tempdata, //数据点
  185.           format: function (val, name) {  //点击显示的数据注释
  186.             return val + '℃';
  187.           }
  188.         }, {
  189.           name: '烟雾浓度',
  190.           data: smokesmokedata,
  191.           format: function (val, name) {
  192.             return val + 'bpm';
  193.           }
  194.         }, {
  195.           name: '湿度',
  196.           data: waterwaterdata,
  197.           format: function (val, name) {
  198.             return val + '%';
  199.           }
  200.         }
  201.         ],
  202.         xAxis: {   //是否隐藏x轴分割线
  203.           disableGrid: true,
  204.         },
  205.         yAxis: {      //y轴数据
  206.           title: '数值',  //标题
  207.           format: function (val) {  //返回数值
  208.             return val.toFixed(2);
  209.           },
  210.           min: 30,   //最小值
  211.           max:180,   //最大值
  212.           gridColor: '#D8D8D8',
  213.         },
  214.         width: windowWidth,  //图表展示内容宽度
  215.         height: windowHeight,  //图表展示内容高度
  216.         dataLabel: false,  //是否在图表上直接显示数据
  217.         dataPointShape: true, //是否在图标上显示数据点标志
  218.         extra: {
  219.           lineStyle: 'curve'  //曲线
  220.         },
  221.       });
  222.     },9000)
  223.   },
  224.   notification: function () {
  225.     var _this = this;
  226.     var time = _this.data.time;
  227.     _this.data.setInter = setInterval(function () {
  228.        _this.setData({
  229.         time: util.formatTime(new Date())
  230.         }); 
  231.         //console.log("时间为"+_this.data.time);   
  232.     }, 1000); 
  233.   },
  234.   // gettime(){
  235.   //   var that=this
  236.   //   var xtime=that.data.xtime
  237.   //   that.setData({
  238.   //     xtime:util.formatTime(new Date())
  239.   //   })
  240.  
  241.   // }
  242.   handleItemChange(e){
  243.     //    console.log(e)
  244.         const {index}=e.detail;
  245.         let {list}=this.data;
  246.         list.forEach((v,i)=>i===index?v.isActive=true:v.isActive=false);
  247.         this.setData({
  248.             list
  249.         })  
  250.     }
  251.  
  252. })

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

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

  

闽ICP备14008679号