Arduino 基于OneNet的环境监测系统数据上传（三）

朱雀 2022-04-04 05:42 570阅读 0赞

## 摘要 ##

随着计算机科学的快速发展, 以及互联网技术的发展, 人机交互技术的研究向着使人和实验室管理系统以更加舒服、更加自然、更加有效率的方式发展。智能实验室是一种自然符合实验室管理人员习惯性的管理方式, 拥有有实验室全景的直观性, 通过各种传感器, 将实验室的数据进行采集打包, 并且经过本地服务器的数据融合算法对数据处理过滤后，利用互联网将数据传输到云端服务器, 再使用客户端向云端服务器请求相应的数据, 并且显示在客户端的界面上。本系统是以Arduino开源控制板，结合传感器技术及HTTP请求对系统硬件构架，功能模块及软件设计进行研究，系统通过温湿度传感器，烟雾传感器，光照传感器等作为采集设备，进行信息采集和处理后，发送给本地服务器，本地服务器对采集的数据进行算法处理后，监测实验室内环境是否异常，如若异常而产生相应的处理措施，并且通过WiFi模块发送到云端服务器。Web客户端和手机客户端通过网络连接着云端服务器，可实时监测实验室内的环境情况。经过测试，系统部署快速简易，搭建成本较低，在扩展性、普及性、定制性和适用性方面具有较好的表现，有效的针对校园实验室环境进行监测，增强设备仪器的使用寿命

## 总体设计 ##

系统由测量模块、数据采集与控制模块、数据处理与通信模块、物联网云平台模块等多个模块组成并实现了温湿度、烟感、光照等实验室环境数据信息的采集和上报．测量模块包含多种传感器对烟感、温度、湿度和光照数据进行感知测量采集，数据采集是通过Arduino控制板读取传感器数据，Arduino控制板对数据经过中位值滤波法后，进行防脉冲干扰平均滤波法处理和过滤，利用通信模块4G或WiFi网络传输数据至云端服务器，通过第三方物联网平台OneNET来实现数据的收集、处理和监控．同时，云平台的传感数据可以随时通过OneNET进行调用，实时查看实验室环境的监控信息，并可设置相应阈值实现自动报警功能，在异常环境下的设备维护需要而进行断电处理。系统以OneNET平台的Web及手机APP作为客户端，使用柱状图和折现图及仪表盘作为显示，直观的明了的展示数据的变化，通过多组传感器采集数据进行数据的对比，提高系统的可靠性，系统在环境采集的同时，也实现了远程控制设备，进而达到加强实验室的安全防范的目的。

系统具有可高度个性化采集数据节点、历史数据，可靠性强、易扩展，便携式以及成本低等特点。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70]

## 所需硬件 ##

*  Arduino UNO x2
 *  ESP8266-01s X2
 *  DHT11温湿度传感器
 *  4路继电器模块
 *  MQ-2烟雾气敏传感器模块
 *  RGB全彩灯
 *  蜂鸣器
 *  红外接收模块
 *  光线传感器
 *  红外遥控

Arduino UNO开发板：![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70 1]  
ESP8266-01S：![在这里插入图片描述][20181215113855681.]  
DHT11温湿度传感器：![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70 2]  
4路继电器模块：![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70 3]  
MQ-2烟雾气敏传感器模块：![在这里插入图片描述][20181215113951112.]  
RGB全彩灯：![在这里插入图片描述][20181215114010907.]  
蜂鸣器：![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70 4]  
红外接收模块：![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70 5]  
光线传感器：![在这里插入图片描述][20181215114100465.]  
红外遥控：![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70 6]

**Arduino UNO扩展板设计：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70 7]

**实物图：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70 8]

## 功能述说 ##

温湿度、光线、烟雾传感器作为采集节点，负责采集温度、湿度、光线、烟雾的数据，红外接收模块负责接收红外遥控的遥控信号，ESP8266 WIFI模块负责连接OneNet模块，将采集节点的数据传给OneNet服务器。当温度>50，湿度>80，烟雾>600 时，蜂鸣器发出报警，温度报警RGB彩灯发出红光，持续时间10s，如果10s内红外遥控按下ok，则关闭报警。同理，湿度报警发出蓝光，烟雾报警发出绿光

## 程序 ##

**Arduino UNO板1（数据上传，环境监测数据）**

#include <dht11.h>      //引用dht11库文件，使得下面可以调用相关参数
    #include <Metro.h> 
    #include <IRremote.h>//红外
    #include <IRremoteInt.h>
    //#include <MsTimer2.h>     //定时器库的头文件
    #include <Adafruit_NeoPixel.h> //RGB
    #include<pt.h>//声明protothread
    #include<PT_timer.h>//声明pt.timer
    #define MAX_LED 9
    #define DHT11PIN 8     //定义温湿度针脚号为8号引脚
    #define DHT11PIN2 9    //定义温湿度针脚号为9号引脚
    #define MQ_2_1PIN A0   //定义烟雾1引脚为A0
    #define MQ_2_2PIN A1   //定义烟雾2引脚为A1
    #define BuzzerPIN A3   //定义蜂鸣器引脚A2
    #define ButtonPIN 4    //定义复位按键引脚4
    #define LightPIN A2    //定义光线传感器引脚A2
    #define RGBPIN 5       //定义RGB灯引脚
    #define SMO1PIN 7      
    #include <SoftwareSerial.h>
    SoftwareSerial mySerial(2,3);//RX=2,TX=3 
    Adafruit_NeoPixel strip = Adafruit_NeoPixel( MAX_LED, RGBPIN, NEO_RGB + NEO_KHZ800 );//长度，引脚，类型
    dht11 DHT11;                                                       //实例化一个对象
    dht11 DHTT11_2;
    Metro T_Hmetro = Metro(2500);   //把 blink1Metro 实例化 Metro 对象 ，并设置间隔时间
    Metro timermetro=Metro(1000);
    PT_timer servotimer1;
    PT_timer servotimer2;//定义两个计时器
    PT_timer servotimer3;//继电器的定时器
    IRrecv irrecv(ButtonPIN);//红外
    decode_results results;//红外
    uint8_t c;
    static struct pt pt1,pt2,pt_r1_on,pt_r2_on,pt_r3_on,pt_r1_off,pt_r2_off,pt_r3_off;//线程
    int data=0;//采样data继电器数据
    int data_Value;//算法消抖后数据 防脉冲干扰平均滤波法
    int H=49;//ASCII
    int L=48;
    int tem_Value,hum_Value,tem2_Value,hum2_Value,smo1_Value,smo2_Value,light;//滤波后
    int tem_warn=0,hum_warn=0,smo_warn=0;
    int Tem_Value,Hum_Value,Tem2_Value,Hum2_Value,Smo1_Value,Smo2_Value;//报警数据
    bool B_Flag=true;
    bool relay_all=false;
    bool flag;//红外状态标识
    bool relay_flag;//WiFi是否被占用
    int label;
    int init_light=250;//初始亮度
    int init_color = 0;//初始颜色
    int key=0;
    //bool close_warn=false;
    
    
    //uint32_t color_green = strip.Color(255,0,0); 
    //uint32_t color_red = strip.Color(0,255,0); 
    //uint32_t color_blue = strip.Color(0,0,255); 
    //uint32_t color[] = {color_no,color_red,color_green,color_blue};
    void setup() {                                                       //设置
    
    Serial.begin(115200);                                            //设置波特率参数
    pinMode(DHT11PIN,INPUT);                       //定义输出口
    pinMode(DHT11PIN2,INPUT);  
    pinMode(MQ_2_1PIN,INPUT); 
    pinMode(MQ_2_2PIN,INPUT); 
    pinMode(BuzzerPIN,OUTPUT);
    pinMode(RGBPIN,OUTPUT);
    pinMode(SMO1PIN,INPUT);
    pinMode(LightPIN,INPUT);
    strip.setBrightness(init_light);
    strip.setPixelColor(0, strip.Color(0,0,0));//G R B 
     irrecv.enableIRIn(); //初始化红外遥控
    mySerial.begin(115200);   //软串口波特率初始化
     PT_INIT(&pt1);
     PT_INIT(&pt2);//两个线程初始化，其实就是pt->lc归零
     PT_INIT(&pt_r1_on);
     PT_INIT(&pt_r2_on);
     PT_INIT(&pt_r3_on);
     PT_INIT(&pt_r1_off);
     PT_INIT(&pt_r2_off);
     PT_INIT(&pt_r3_off);
    
    }
    
    
      
    void loop() {                                                    //循环
      if(timermetro.check()){
      int chk = DHT11.read(DHT11PIN);                 //将读取到的值赋给chk
      int tem=(float)DHT11.temperature;               //将温度值赋值给tem
      int hum=(float)DHT11.humidity;                   //将湿度值赋给hum
      delay(10);
      int T1=Filter(tem);
      int H1=Filter(hum);
      tem_Value=Filter2(T1);//经过Filter(tem)中位值滤波法后的温度
      hum_Value=Filter2(H1);
      int chk2 = DHTT11_2.read(DHT11PIN2);                 //将读取到的值赋给chk
      int tem2=(float)DHTT11_2.temperature;               //将温度值赋值给tem
      int hum2=(float)DHTT11_2.humidity;                   //将湿度值赋给hum
      delay(10);
      int T2=Filter(tem2);//经过Filter(tem)中位值滤波法后的温度
      int H2=Filter(hum2);
      tem2_Value=Filter2(T2);
      hum2_Value=Filter2(H2);
      int smo1=analogRead(MQ_2_1PIN);
      int smo2=analogRead(MQ_2_2PIN);
      int S1=Filter(smo1);
      int S2=Filter(smo2);
      smo1_Value=Filter2(S1);
      smo2_Value=Filter2(S2);
      float light_=analogRead(LightPIN);
      light=light_/10.24;
      }
     
    //  Serial.println(light);
    //if(hongwai(1)||hongwai(2)||hongwai(3)||hongwai(4)||hongwai(5)||hongwai(6)){
    // 
    //}else{
    // 
    //}
    if(T_Hmetro.check()&&relay_flag){  //检查blink1Metro间隔(我的理解是计时器每隔100毫秒就会返回true，就执行以下程序)
      mySerial.println("POST http://api.heclouds.com/devices/500259133/datapoints?type=3 HTTP/1.1");     //打印出http协议post命令
      mySerial.println("api-key: sWydCX=jX3RfgT3bYxaorgEbZ9o="); //apikey OneNet提供的key
      mySerial.println("Host:api.heclouds.com");                //主机
      mySerial.println("Connection:close");                     //断开连接  
      mySerial.println("Content-Length:69");                    //传送的字节
     
      mySerial.print("\r\n{\"TEM\":");                          //换行 传送格式{"TEM":tem,"HUM":hum}
      mySerial.print(tem_Value);                                //打印温度数据
      mySerial.print(",\"HUM\":");                              //传送格式
      mySerial.print(hum_Value);                                //打印湿度数据
      mySerial.print(",\"TEM2\":");                              //传送格式
      mySerial.print(tem2_Value);                                //打印温度数据
      mySerial.print(",\"HUM2\":");                              //传送格式
      mySerial.print(hum2_Value);                                //打印湿度数据
    
      mySerial.print(",\"SMO\":");                              //传送格式
      mySerial.print(smo1_Value);                                //打印温度数据
      mySerial.print(",\"SMO2\":");                              //传送格式
      mySerial.print(smo2_Value);                                //打印湿度数据
      mySerial.print(",\"LIG\":");                              //传送格式
      mySerial.print(light);                                //打印湿度数据
      mySerial.print("}");                                      //打印出}
      Tem_Value=tem_Value;
      Tem2_Value=tem2_Value;
      Hum_Value=hum_Value;
      Hum2_Value=hum2_Value;
      Smo1_Value=smo1_Value;
      Smo2_Value=smo2_Value;
    //  tem_warn=(tem_Value+tem2_Value)/2;//温度1和温度2 求平均用于警报触发
    //  hum_warn=(hum_Value+hum2_Value)/2;
    //  smo_warn=(smo1_Value+smo2_Value)/2;
    }
    if(Tem_Value>=50||Tem2_Value>=50){
      tem_warn=255;
    }else{
      tem_warn=0;
    }
    //Serial.println();
    //Serial.print("  t1 ");
    //Serial.print(tem_Value);
    //Serial.print("  t2 ");
    //Serial.print(tem2_Value);
    //Serial.print("  h1 ");
    //Serial.print(hum_Value);
    //Serial.print("  h2 ");
    //Serial.print(hum2_Value);
    //Serial.print("  s1 ");
    //Serial.print(smo1_Value);
    //Serial.print("  s2 ");
    //Serial.print(smo2_Value);
    
    if(Hum_Value>=80||Hum2_Value>=80){
      hum_warn=255;
    }else{
      hum_warn=0;
    }
    
    if(Smo1_Value>=600||Smo2_Value>=600){
      smo_warn=255;
    }else{
      smo_warn=0;
    }
    
     mission1(&pt1);//线程1 检测是否发生温度，湿度，烟雾过高报警
     mission2(&pt2);//线程2 检测红外遥控是否按下OK 按下关闭警报
     if(relay_all){//是否发生警报
      Relay_all();//关闭所有设备
    }
    mission_r1_on(&pt_r1_on);
    mission_r1_off(&pt_r1_off);
    mission_r2_on(&pt_r2_on);
    mission_r2_off(&pt_r2_off);
    mission_r3_on(&pt_r3_on);
    mission_r3_off(&pt_r3_off);
    remote_control();
    Serial.println(key);
    //if(smo1_Value>=600||smo2_Value&&B_Flag){
    //  Serial.println("Buzzer");
    //  for(int i=200;i<=800;i++){
    //    tone(BuzzerPIN,i);                            //在四号端口输出频率
    //    delay(5);                              //该频率维持5毫秒
    //  }
    //  delay(2000);                            //最高频率下维持4秒钟
    //  for(int i=800;i>=200;i--)
    //  {
    //    tone(BuzzerPIN,i);
    //    delay(10);  
    //  }
    //}else{
    //   B_Flag=false;
    //}
    
    if(digitalRead(ButtonPIN)==LOW){
      B_Flag=false;
    //  Serial.println("LOW");
    }
    
    
    
    
    }
    //
    void remote_control(){
       switch(key){
        case 1:Relay1_on();break;
        case 2:Relay2_on();break;
        case 3:Relay3_on();break;
        case 4:Relay1_off();break;
        case 5:Relay2_off();break;
        case 6:Relay3_off();break;
       }
    }
    
    static int mission1(struct pt *pt)
    {
        PT_BEGIN(pt);//线程开始
        while(1)
        {
            digitalWrite(BuzzerPIN,LOW);//蜂鸣器不响起
            relay_all=false;
            color_rgb(0,0,0);
            PT_WAIT_UNTIL(pt,Smo1_Value>=600||Smo2_Value>=600||Tem_Value>=50||Tem2_Value>=50||Hum_Value>=80||Hum2_Value>=80);//等烟雾浓度过大
            relay_all=true;
            color_rgb(tem_warn,smo_warn,hum_warn);//指示灯 red green blue
            digitalWrite(BuzzerPIN,HIGH);//蜂鸣器响起
            servotimer1.setTimer(10000);//设定跪10秒，这里单位1为一微妙
            PT_WAIT_UNTIL(pt,(servotimer1.Expired()));//当时间溢出，这里是10秒就结束
    }
    PT_END(pt);//线程结束
    }
    
    static int mission2(struct pt *pt)
    {
        PT_BEGIN(pt);
        while(1)
    {
        digitalWrite(BuzzerPIN,LOW);//蜂鸣器不响起
        color_rgb(0,0,0);
        PT_WAIT_UNTIL(pt,hongwai(15));
        digitalWrite(BuzzerPIN,LOW);//蜂鸣器不响起
    //    relay_all=false;
        color_rgb(0,0,0);
        PT_WAIT_UNTIL(pt,(servotimer1.Expired()));
    }
        PT_END(pt);
    }
    
    static int mission_r1_on(struct pt *pt)
    {
        PT_BEGIN(pt);
        while(1)
    {
        key=0;
        relay_flag=true;
        PT_WAIT_UNTIL(pt,hongwai(1));
        relay_flag=false;
        key=1;
        servotimer3.setTimer(5000);//设定跪2秒，这里单位1为一微妙
        PT_WAIT_UNTIL(pt,(servotimer3.Expired()));
    }
        PT_END(pt);
    }
    
    static int mission_r2_on(struct pt *pt)
    {
        PT_BEGIN(pt);
        while(1)
    {
        key=0;
        relay_flag=true;
        PT_WAIT_UNTIL(pt,hongwai(2));
        relay_flag=false;
        key=2;
        servotimer3.setTimer(5000);//设定跪2秒，这里单位1为一微妙
        PT_WAIT_UNTIL(pt,(servotimer3.Expired()));
    }
        PT_END(pt);
    }
    
    static int mission_r3_on(struct pt *pt)
    {
        PT_BEGIN(pt);
        while(1)
    {
        key=0;
        relay_flag=true;
        PT_WAIT_UNTIL(pt,hongwai(3));
        relay_flag=false;
        key=3;
        servotimer3.setTimer(5000);//设定跪2秒，这里单位1为一微妙
        PT_WAIT_UNTIL(pt,(servotimer3.Expired()));
    }
        PT_END(pt);
    }
    
    static int mission_r1_off(struct pt *pt)
    {
        PT_BEGIN(pt);
        while(1)
    {
        key=0;
        relay_flag=true;
        PT_WAIT_UNTIL(pt,hongwai(4));
        relay_flag=false;
        key=4;
        servotimer3.setTimer(5000);//设定跪2秒，这里单位1为一微妙
        PT_WAIT_UNTIL(pt,(servotimer3.Expired()));
    }
        PT_END(pt);
    }
    
    
    static int mission_r2_off(struct pt *pt)
    {
        PT_BEGIN(pt);
        while(1)
    {
        key=0;
        relay_flag=true;
        PT_WAIT_UNTIL(pt,hongwai(5));
        relay_flag=false;
        key=5;
        servotimer3.setTimer(5000);//设定跪2秒，这里单位1为一微妙
        PT_WAIT_UNTIL(pt,(servotimer3.Expired()));
    }
        PT_END(pt);
    }
    
    static int mission_r3_off(struct pt *pt)
    {
        PT_BEGIN(pt);
        while(1)
    {
        key=0;
        relay_flag=true;
        PT_WAIT_UNTIL(pt,hongwai(6));
        relay_flag=false;
        key=6;
        servotimer3.setTimer(5000);//设定跪2秒，这里单位1为一微妙
        PT_WAIT_UNTIL(pt,(servotimer3.Expired()));
    }
        PT_END(pt);
    }
    
    
    
    void color_rgb(int r,int g,int b){
          strip.setPixelColor(0, strip.Color(g,r,b));
          strip.show();
    }
    
    void Relay_all()
    {
      mySerial.println("POST http://api.heclouds.com/devices/500259133/datapoints?type=3 HTTP/1.1");     //打印出http协议post命令
      mySerial.println("api-key: sWydCX=jX3RfgT3bYxaorgEbZ9o="); //apikey OneNet提供的key
      mySerial.println("Host:api.heclouds.com");                //主机
      mySerial.println("Connection:close");                     //断开连接  
      mySerial.println("Content-Length:39");                    //传送的字节
    
      mySerial.print("\r\n{\"Relay\":");                          //换行 传送格式{"Relay":L1,"Relay2":L2}
      mySerial.print(0);                                //打印温度数据
      mySerial.print(",\"Relay2\":");                              //传送格式
      mySerial.print(9);                                //打印湿度数据
      mySerial.print(",\"Relay3\":");                              //传送格式
      mySerial.print(4);                                //打印湿度数据
      mySerial.print("}"); 
    }
    
    void Relay1_on(){
      mySerial.println("POST http://api.heclouds.com/devices/500259133/datapoints?type=3 HTTP/1.1");     //打印出http协议post命令
      mySerial.println("api-key: sWydCX=jX3RfgT3bYxaorgEbZ9o="); //apikey OneNet提供的key
      mySerial.println("Host:api.heclouds.com");                //主机
      mySerial.println("Connection:close");                     //断开连接  
      mySerial.println("Content-Length:24");                    //传送的字节
    
      mySerial.print("\r\n{\"Relay\":");                          //换行 传送格式{"Relay":L1,"Relay2":L2}
      mySerial.print(2);                                //打印温度数据
      mySerial.print("}");
    }
    
    void Relay2_on(){
      mySerial.println("POST http://api.heclouds.com/devices/500259133/datapoints?type=3 HTTP/1.1");     //打印出http协议post命令
      mySerial.println("api-key: sWydCX=jX3RfgT3bYxaorgEbZ9o="); //apikey OneNet提供的key
      mySerial.println("Host:api.heclouds.com");                //主机
      mySerial.println("Connection:close");                     //断开连接  
      mySerial.println("Content-Length:24");                    //传送的字节
    
      mySerial.print("\r\n{\"Relay2\":");                          //换行 传送格式{"Relay":L1,"Relay2":L2}
      mySerial.print(3);                                //打印温度数据
      mySerial.print("}");
    }
    
    void Relay3_on(){
      mySerial.println("POST http://api.heclouds.com/devices/500259133/datapoints?type=3 HTTP/1.1");     //打印出http协议post命令
      mySerial.println("api-key: sWydCX=jX3RfgT3bYxaorgEbZ9o="); //apikey OneNet提供的key
      mySerial.println("Host:api.heclouds.com");                //主机
      mySerial.println("Connection:close");                     //断开连接  
      mySerial.println("Content-Length:24");                    //传送的字节
    
      mySerial.print("\r\n{\"Relay3\":");                          //换行 传送格式{"Relay":L1,"Relay2":L2}
      mySerial.print(6);                                //打印温度数据
      mySerial.print("}");
    }
    
    void Relay1_off(){
      mySerial.println("POST http://api.heclouds.com/devices/500259133/datapoints?type=3 HTTP/1.1");     //打印出http协议post命令
      mySerial.println("api-key: sWydCX=jX3RfgT3bYxaorgEbZ9o="); //apikey OneNet提供的key
      mySerial.println("Host:api.heclouds.com");                //主机
      mySerial.println("Connection:close");                     //断开连接  
      mySerial.println("Content-Length:24");                    //传送的字节
    
      mySerial.print("\r\n{\"Relay\":");                          //换行 传送格式{"Relay":L1,"Relay2":L2}
      mySerial.print(0);                                //打印温度数据
      mySerial.print("}");
    }
    
    void Relay2_off(){
      mySerial.println("POST http://api.heclouds.com/devices/500259133/datapoints?type=3 HTTP/1.1");     //打印出http协议post命令
      mySerial.println("api-key: sWydCX=jX3RfgT3bYxaorgEbZ9o="); //apikey OneNet提供的key
      mySerial.println("Host:api.heclouds.com");                //主机
      mySerial.println("Connection:close");                     //断开连接  
      mySerial.println("Content-Length:24");                    //传送的字节
    
      mySerial.print("\r\n{\"Relay2\":");                          //换行 传送格式{"Relay":L1,"Relay2":L2}
      mySerial.print(9);                                //打印温度数据
      mySerial.print("}");
    }
    
    void Relay3_off(){
      mySerial.println("POST http://api.heclouds.com/devices/500259133/datapoints?type=3 HTTP/1.1");     //打印出http协议post命令
      mySerial.println("api-key: sWydCX=jX3RfgT3bYxaorgEbZ9o="); //apikey OneNet提供的key
      mySerial.println("Host:api.heclouds.com");                //主机
      mySerial.println("Connection:close");                     //断开连接  
      mySerial.println("Content-Length:24");                    //传送的字节
    
      mySerial.print("\r\n{\"Relay3\":");                          //换行 传送格式{"Relay":L1,"Relay2":L2}
      mySerial.print(4);                                //打印温度数据
      mySerial.print("}");
    }
    
    
    // 中位值滤波法
    #define FILTER_N 5
    int Filter(int getData) {
      int filter_buf[FILTER_N];
      int i, j;
      int filter_temp;
      for(i = 0; i < FILTER_N; i++) {
        filter_buf[i] = getData;
        delay(1);
      }
      // 采样值从小到大排列（冒泡法）
      for(j = 0; j < FILTER_N - 1; j++) {
        for(i = 0; i < FILTER_N - 1 - j; i++) {
          if(filter_buf[i] > filter_buf[i + 1]) {
            filter_temp = filter_buf[i];
            filter_buf[i] = filter_buf[i + 1];
            filter_buf[i + 1] = filter_temp;
          }
        }
      }
      return filter_buf[(FILTER_N - 1) / 2];
    }
    
    
    // 中位值平均滤波法（又称防脉冲干扰平均滤波法）（算法1）
    #define FILTER_N 6
    int Filter2(int GetData2) {
      int i, j;
      int filter_temp, filter_sum = 0;
      int filter_buf[FILTER_N];
      for(i = 0; i < FILTER_N; i++) {
        filter_buf[i] = GetData2;
        delay(1);
      }
      // 采样值从小到大排列（冒泡法）
      for(j = 0; j < FILTER_N - 1; j++) {
        for(i = 0; i < FILTER_N - 1 - j; i++) {
          if(filter_buf[i] > filter_buf[i + 1]) {
            filter_temp = filter_buf[i];
            filter_buf[i] = filter_buf[i + 1];
            filter_buf[i + 1] = filter_temp;
          }
        }
      }
      // 去除最大最小极值后求平均
      for(i = 1; i < FILTER_N - 1; i++) filter_sum += filter_buf[i];
      return filter_sum / (FILTER_N - 2);
    }
    
    
    bool hongwai(int r){
      flag=false;
      if (irrecv.decode(&results)) {
    //    Serial.println(results.value,HEX);
         switch(results.value){
            //1
          case 0xFFA25D:
            label=1;
            break;
            //2
          case 0xFF629D:
            label=2;
            break;
            //3
          case 0xFFE21D:
            label=3;
            break;
            //4
          case 0xFF22DD:
            label=4;
            break;
            //5
          case 0xFF02FD:
           Serial.println("5");
            label=5;
            break;
            //6
          case 0xFFC23D:
            label=6;
            break;
            //7
          case 0xFFE01F:
            label=7;
            break;
            //8
          case 0xFFA857:
            label=8;
            break;
            //9
          case 0xFF906F:
            label=9;
            break;
            //0
          case 0xFF9867:
            label=0;
            break;
            //up
          case 0xFF18E7:
            label=11;
            break;
            //down
          case 0xFF4AB5:
            label=12;
            break;
            //left
          case 0xFF10EF:
            label=13;
            break;
            //right
          case 0xFF5AA5:
            label=14;
            break;
            //ok
          case 0xFF38C7:
            label=15;
            break;  
            //*
          case 0xFF6897:
            label=16;
            break;
            //#
          case 0xFFB04F:
            label=17;
            break;
            //else
          default:
            break;
         }
         irrecv.resume(); // 接收下一个值
       }
        if(label==r) {
          flag=true;//确定返回
          label=99;//复位
      }
      return flag;
    }
    
    /*
    A、名称：中位值平均滤波法（又称防脉冲干扰平均滤波法）
    B、方法：
        采一组队列去掉最大值和最小值后取平均值，
        相当于“中位值滤波法”+“算术平均滤波法”。
        连续采样N个数据，去掉一个最大值和一个最小值，
        然后计算N-2个数据的算术平均值。
        N值的选取：3-14。
    C、优点：
        融合了“中位值滤波法”+“算术平均滤波法”两种滤波法的优点。
        对于偶然出现的脉冲性干扰，可消除由其所引起的采样值偏差。
        对周期干扰有良好的抑制作用。
        平滑度高，适于高频振荡的系统。
    D、缺点：
        计算速度较慢，和算术平均滤波法一样。
        比较浪费RAM。
    */
    
    /*
    A、名称：中位值滤波法
    B、方法：
        连续采样N次（N取奇数），把N次采样值按大小排列，
        取中间值为本次有效值。
    C、优点：
        能有效克服因偶然因素引起的波动干扰；
        对温度、液位的变化缓慢的被测参数有良好的滤波效果。
    D、缺点：
        对流量、速度等快速变化的参数不宜。
    */
    
    
    
    /*****   POST命令格式
     POST http://api.heclouds.com/devices/500259133/datapoints?type=3 HTTP/1.1
    api-key: sWydCX=jX3RfgT3bYxaorgEbZ9o=
    Host:api.heclouds.com
    Connection:close
    Content-Length:19
    
    {"TEM":22,"HUM":52}
    
    *****  GET Realy
    GET http://api.heclouds.com/devices/500259133/datastreams/Relay HTTP/1.1
    api-key: sWydCX=jX3RfgT3bYxaorgEbZ9o=
    Host:api.heclouds.com
    Connection:close
    
    
     */

## 效果 ##

客户端视频：[https://v.youku.com/v\_show/id\_XMzk2NTE5MTk5Mg==.html?spm=a2h3j.8428770.3416059.1][https_v.youku.com_v_show_id_XMzk2NTE5MTk5Mg_.html_spm_a2h3j.8428770.3416059.1]

OneNet：[https://open.iot.10086.cn/iotbox/appsquare/appview?openid=5ca523334a5a9b576e316a586de6d738][https_open.iot.10086.cn_iotbox_appsquare_appview_openid_5ca523334a5a9b576e316a586de6d738]

QQ：690333105  
验证信息：Arduino

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70]: /images/20220404/e9c6caf0566b4363a16d2c7dde8c519a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70 1]: /images/20220404/b3b64992b3b14580b8648632260595e0.png
[20181215113855681.]: /images/20220404/50b7a5b1814c43308642cee62fba7cee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70 2]: /images/20220404/eb89adc3b0d643a180df84ea8f52139c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70 3]: /images/20220404/8e480d528e1a46a1ab16d29bc8b5d069.png
[20181215113951112.]: /images/20220404/252c2d96912b4254acd9f7e3a8905566.png
[20181215114010907.]: /images/20220404/56acdc2011d6464c85d462c4942395ab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70 4]: /images/20220404/48b4eace1479413599f24205f7629474.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70 5]: /images/20220404/4f47758b17524b0f90b37448abcd63e9.png
[20181215114100465.]: /images/20220404/9187f0f9c576491bbd93d7d444c2437a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70 6]: /images/20220404/1eba6e1186b34289b11b41dc2e8e7de7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70 7]: /images/20220404/7699efdf97874e508f446a652b8dedc2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NzM4ODM4_size_16_color_FFFFFF_t_70 8]: /images/20220404/db5ca9971cf34b709ea06481bed0486a.png
[https_v.youku.com_v_show_id_XMzk2NTE5MTk5Mg_.html_spm_a2h3j.8428770.3416059.1]: https://v.youku.com/v_show/id_XMzk2NTE5MTk5Mg==.html?spm=a2h3j.8428770.3416059.1
[https_open.iot.10086.cn_iotbox_appsquare_appview_openid_5ca523334a5a9b576e316a586de6d738]: https://open.iot.10086.cn/iotbox/appsquare/appview?openid=5ca523334a5a9b576e316a586de6d738