基于Arduino、ESP8266的物联网项目开发方案整理、毕业设计(第三波)

博主联系方式汇总(非诚勿扰)
博主联系方式汇总(非诚勿扰)
博主联系方式汇总(非诚勿扰)

1、背景

了解博哥的同学都知道,作为一名电子爱好者,博哥除了平时乐于分享基础知识之外,还需要肩负起减轻家庭负担的责任(毕竟从农村走出来的孩子)。

目前,一般加博哥好友的人大概可以分为两类:

  • 学习知识(这一部分目前基本上都很正常运转起来,更多人还是喜欢我的ESP8266开发系列,主要着重点在于基础)
  • 项目开发、毕业设计等(这一部分内容缺失,没有一系列的帖子去记录过博哥有经历过哪些项目开发,不一定是我开发的。。。。)

所以,经过仔细考虑还是需要去介绍一下一些项目开发整理。

2、项目整理

主要分为几个项目:

  • 挪威牛栏气体检测
  • 触摸屏显示称重
  • G7物流沙盘
  • 阿里云家庭生产线

2.1 挪威牛栏气体检测

2.1.1 功能介绍

这是挪威的一个小项目,主要用来检测牛栏气体浓度。

  • 0、电源输入为110v~220v交流电。
  • 1、电路需要设计备用电源电路(也就是锂电池部分)。当电源停电时,自动启动备用电源。
  • 2、MQ传感器探头不直接焊接在PCB板,而是通过座子接入。
  • 3、 每x秒(x=1或者其他)读取一次MQ的值,并计算出CH4, CO2, NH3, H2S ppm值。
  • 4、显示屏显示ppm值和pm2.5值以及温湿度值。
  • 5、当这些值任意一个超过限定值时,就发送一条短信
  • 6、当备用电源启动时,也发送一条短信。

2.1.2 实物图片

1、1* ATmega2560-16AU及其配套的阻容器件
2、1* 3.5寸触摸屏
3、1*MQ4 传感器(测 CH4)
4、1*MQ135 传感器(测NH3)
5、1*MQ136 传感器(测 H2S)
6、1*SGP30芯片(测 CO2)
7、1*DHT11(测温湿度)
8、1压电式有源蜂鸣器
9、1
5v继电器
10、1*GSM868模块
11、1*灰尘传感器(测PM2.5)
12、可充电电池组
13、其他器件,如电阻、电容、指示灯、电源开关等

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

2.1.3 视频

演示视频暂时无法上传(需要的可以另外帖子留言

2.1.4 源代码

暂未公开

2.2 触摸屏显示称重

2.2.1 功能介绍

在这里插入图片描述

  • 1、一共12个相同的物块,放在称重平台。
  • 2、当在对应位置放置1个物块后,就亮一颗灯(白色暖光色)。HMI屏幕显示对应的数量,屏幕右下角显示剩余个数。中间一个大数字显示剩余个数(假如剩4个),右下角显示已完成个数8/12。
  • 3、当12个位置都放满后,12颗灯就闪烁闪一圈就行,且HMI屏幕显示successful。
  • 4、RGB值需要支持调整,例如灯光亮度。

2.2.2 实物图片

1、1Arduino uno
2、1
HX711模块称重套件
3、1*12颗WS2812 RGB灯条
3、其他可能需要的元器件(按钮、电阻、电容、导线等)

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

2.2.3 视频

演示视频暂时无法上传(需要的可以另外帖子留言

2.2.4 源代码

#include "HX711.h" 
#include <Adafruit_NeoPixel.h>

#define PIN       5                    //LED引脚
#define NUMPIXELS 12                   //LED数量
#define loding_delay 10                //进度条响应速度,数值越大响应越慢
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
const int LOADCELL_DOUT_PIN = 2;       //HX711驱动DOUT引脚
const int LOADCELL_SCK_PIN = 3;        //HX711驱动CLK引脚
bool change_flag = 0;
bool LED_flag = 1;
int LED_num = 0;
int Old_num = 0;
int J_val = 0;
int Old_J_val = 0;
int Old_val = 0;
char payload[30];
char End[] = {0xff,0xff,0xff};
int Bright = 200;                      //LED亮度设置 0-255
#define PIN       5                    //LED引脚
#define NUMPIXELS 12                   //LED数量

float calibration_factor = 415;        //重力校准系数
float units;                           //储存质量变量,单位g
float units_flag = 7.5;                 //单个物品重量设置,单位g
float units_Debug = 1;                //质量误差设置
HX711 scale;

void setup() {
  Serial.begin(9600);
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  scale.set_scale(calibration_factor); //重力常量初始化
  scale.tare();                        //质量置0(去皮)
  pixels.begin();                      //LED初始化
  pixels.setBrightness(Bright);        //LED亮度设置
}

void loop() {
  get_Weight();     //获取质量
  getLED_Num();     //获取LED模式
  tft_Run();        //刷新屏幕显示
  LED_Run();        //刷新LED状态
  J_val = map(LED_num,0,12,0,100);
  j_val();          //屏幕进度条单独刷新
}

/********获取质量函数*********/
void get_Weight(){
  if (scale.is_ready()) {              //检测传感器是否就绪
    units = scale.get_units();         //更新重量
    //Serial.print("HX711 reading: "); //串口打印重量调试时可打开
    //Serial.println(units);
  }
}

/********质量状态转化函数*********/
void getLED_Num(){
  if(units < (units_flag - units_Debug)){LED_num = 0;}
  else if(units > (units_flag - units_Debug) && units < (units_flag*2 - units_Debug)){LED_num = 1;}
  else if(units > (units_flag*2 - units_Debug) && units < (units_flag*3 - units_Debug)){LED_num = 2;}
  else if(units > (units_flag*3 - units_Debug) && units < (units_flag*4 - units_Debug)){LED_num = 3;}
  else if(units > (units_flag*4 - units_Debug) && units < (units_flag*5 - units_Debug)){LED_num = 4;}
  else if(units > (units_flag*5 - units_Debug) && units < (units_flag*6 - units_Debug)){LED_num = 5;}
  else if(units > (units_flag*6 - units_Debug) && units < (units_flag*7 - units_Debug)){LED_num = 6;}
  else if(units > (units_flag*7 - units_Debug) && units < (units_flag*8 - units_Debug)){LED_num = 7;}
  else if(units > (units_flag*8 - units_Debug) && units < (units_flag*9 - units_Debug)){LED_num = 8;}
  else if(units > (units_flag*9 - units_Debug) && units < (units_flag*10 - units_Debug)){LED_num = 9;}
  else if(units > (units_flag*10 - units_Debug) && units < (units_flag*11 - units_Debug)){LED_num = 10;}
  else if(units > (units_flag*11 - units_Debug) && units < (units_flag*12 - units_Debug)){LED_num = 11;}
  else if(units > (units_flag*12 - units_Debug)){LED_num = 12;}
}

/********显示屏状态刷新函数*********/
void tft_Run(){
  if(LED_num != Old_num){              //减少不必要的串口输出
    Old_num = LED_num;                 //更新状态
    if(LED_num <= 11){
      if(change_flag == 1){            //页面切换标志位,防止不必要的刷新
        sprintf(payload,"page 0");
        Serial.print(payload);         //切换到页面0
        Serial.print(End);
        change_flag = 0;
    }
    sprintf(payload,"t0.txt=\"%d\"",LED_num);
    Serial.print(payload);       //更新t0状态
    Serial.print(End);
    sprintf(payload,"t1.txt=\"%d\"",(12-LED_num)); 
    Serial.print(payload);             //更新t1状态
    Serial.print(End);
  }
  else{
    sprintf(payload,"page 1");
    Serial.print(payload);             //切换到页面1
    Serial.print(End);  
    change_flag = 1;                   //重置切换标志位
  }
  }
}

/********进度条状态刷新函数*********/
void j_val(){
  if(Old_J_val != J_val){
    Old_J_val = J_val;
    for(Old_val;Old_val < J_val;Old_val++){
      sprintf(payload,"j0.val=%d",Old_val);
      Serial.print(payload);
      Serial.print(End);
      delay(loding_delay);
    }
    for(Old_val;Old_val > J_val;Old_val--){
      sprintf(payload,"j0.val=%d",Old_val);
      Serial.print(payload);
      Serial.print(End);
      delay(loding_delay);
    }
  }
}

/********LED状态刷新函数*********/
void LED_Run(){
  if(LED_num == 0){                    //没有时将灯熄灭
    pixels.clear();
    pixels.show();
    LED_flag = 1;
  }
  else if(LED_num == 12){              //12个全满时闪烁一圈
    if(LED_flag == 1){
      pixels.clear();
      LED_flag = 0;
      for(int i = 0;i < 12;i++){
        pixels.setPixelColor(i, pixels.Color(255, 255, 255));
        pixels.show();
        delay(100);
      }
    }
      
  }
  else{                                //其他情况点亮对应数量的灯
    pixels.clear();
    LED_flag = 1;
    for(int m = 0; m < (LED_num); m++){
      pixels.setPixelColor(m, pixels.Color(255, 255, 255));
    }
    pixels.show();
  }
}

2.3 G7物流沙盘

2.3.1 功能介绍

  • 1、车子是独立运行,当车子进入红外传感器是,会停留约1min。
  • 2、当第1个红外传感器检测到车子时,Arduino串口发送十六进制数据 0xEE 0X01。以此类推第2个红外传感器发送0xEE 0x02,第15个就发送0xEE 0x0F。
  • 3、从车子进入某个红外传感器到车子离开,有且只有发送一次十六进制数据。

在这里插入图片描述

2.3.2 实物图片

1、1Arduino uno/nano
2、15
红外传感器,传感器到Arduino的线长是3m。
3、其他可能需要的元器件(面包板、按钮、电阻、电容、导线等)

2.3.3 视频

演示视频暂时无法上传(需要的可以另外帖子留言

2.3.4 源代码

#define versions "FirmwareVersions:V3.0"

/**************************引脚定义***************************/
//注A6、A7脚只能作为模拟信号
#define Switch_1  A0
#define Switch_2  A1
#define Switch_3  A2
#define Switch_4  A3
#define Switch_5  A4
#define Switch_6  3
#define Switch_7  4
#define Switch_8  5
#define Switch_9  6
#define Switch_10 7
#define Switch_11 8
#define Switch_12 9
#define Switch_13 10
#define Switch_14 11
#define Switch_15 12
#define MAX485_RDE 13

bool Scan_flag = 1;          //扫描标志位
bool Set_State = 0;          //触发电平设置
char Sent_Data[] = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
char Sent_void[1];
char Sent_head[] = {0xEE};
char Last_Sent_void[1];
void setup(){
  Serial.begin(9600,SERIAL_8N1);   //Arduino Serial UART Config
  pinMode(Switch_1,INPUT);
  pinMode(Switch_2,INPUT);
  pinMode(Switch_3,INPUT);
  pinMode(Switch_4,INPUT);
  pinMode(Switch_5,INPUT);
  pinMode(Switch_6,INPUT);
  pinMode(Switch_7,INPUT);
  pinMode(Switch_8,INPUT);
  pinMode(Switch_9,INPUT);
  pinMode(Switch_10,INPUT);
  pinMode(Switch_11,INPUT);
  pinMode(Switch_12,INPUT);
  pinMode(Switch_13,INPUT);
  pinMode(Switch_14,INPUT);
  pinMode(Switch_15,INPUT);
  pinMode(MAX485_RDE,OUTPUT);
  digitalWrite(MAX485_RDE,HIGH);
}


/**************************按键扫描函数***************************/
void Switch_Scan(){
  if (Scan_flag == 1){
    if(digitalRead(Switch_1) == Set_State){Sent_void[0] = Sent_Data[0];}
    if(digitalRead(Switch_2) == Set_State){Sent_void[0] = Sent_Data[1];}
    if(digitalRead(Switch_3) == Set_State){Sent_void[0] = Sent_Data[2];}
    if(digitalRead(Switch_4) == Set_State){Sent_void[0] = Sent_Data[3];}
    if(digitalRead(Switch_5) == Set_State){Sent_void[0] = Sent_Data[4];}
    if(digitalRead(Switch_6) == Set_State){Sent_void[0] = Sent_Data[5];}
    if(digitalRead(Switch_7) == Set_State){Sent_void[0] = Sent_Data[6];}
    if(digitalRead(Switch_8) == Set_State){Sent_void[0] = Sent_Data[7];}
    if(digitalRead(Switch_9) == Set_State){Sent_void[0] = Sent_Data[8];}
    if(digitalRead(Switch_10) == Set_State){Sent_void[0] = Sent_Data[9];}
    if(digitalRead(Switch_11) == Set_State){Sent_void[0] = Sent_Data[10];}
    if(digitalRead(Switch_12) == Set_State){Sent_void[0] = Sent_Data[11];}
    if(digitalRead(Switch_13) == Set_State){Sent_void[0] = Sent_Data[12];}
    if(digitalRead(Switch_14) == Set_State){Sent_void[0] = Sent_Data[13];}
    if(digitalRead(Switch_15) == Set_State){Sent_void[0] = Sent_Data[14];}
  }
}

/**************************数据发送函数***************************/
void Send(){
  if(Sent_void[0] != Last_Sent_void[0]){
    Last_Sent_void[0] = Sent_void[0];
    //Serial.print("chang");
    Serial.write(Sent_head);
    Serial.write(Sent_void[0]);
  }
}

void loop(){
  Switch_Scan();
  Send();
}

2.4 阿里云家庭生产线

2.4.1 功能介绍

  • 1、阿里云物联网平台设置3个温度值起始加热温度T1(Start_heating)、停止加热温度T2(Stop_heating)、过热通风温度T3(Ventilate_temp)。
  • 2、nodemcu读取阿里云设置的3个温度值。
  • 3、nodemcu把3个温度值通过串口的形式发给Arduino。
  • 4、Arduino实时监测8个DS18B20传感器的数据。
  • 5、当8个温度值,任意一个低于T1,则给高电平闭合8合1对应的继电器。如果对应的通风口打开(即Switch_L6或Switch_R6是低电平),则给高低电平反转左边或者右边2合1对应的继电器。直到Switch_L6或Switch_R6是高电平。
  • 6、当8个温度值,任意一个高于T2,则给低电平断开8合1对应的继电器。
  • 7、当左边或者右边的4个温度值的平均值,高于T3。如果Switch_L5/Switch_R5为低电平,则高电平闭合Relay_L5/R5,低电平断开Relay_L6/R6,实现正转。反之,如果Switch_L5/R5为高电平,则低电平断开Relay_L5/R5、L6/R6实现停止。
  • 8、12个微动限位开关,按下是高电平、不按下是低电平。其中8个和DS18B20传感器对应,按下表示盖子盖上,不按下表示盖子打开。另外4个(Switch_L5、Switch_L6、Switch_R5、Switch_R6)作为限位开关。
    当按下Switch_L5或Switch_L6时,低电平断开2个对应的继电器(Relay_L5、L6)
    同理当按下Switch_R5或Switch_R6时,低电平断开2个对应的继电器(Relay_R5、R6)
  • 9、设置的3个温度值,需要断电保存。也就是断电重新开机,需要恢复上一次设置的值。当然如果阿里云重新设置了其中的一个或多个温度值,则也要同步更新。
  • 10、要把8个DS18B20传感器的数据和12个微动开关的状态,以及12个继电器的状态显示在云端。
  • 11、特别重要:如果是首次降温到T1,在降温过程中不管温度如何,都不操作12个继电器。当不是首次低于T1,也可以通过阿里云的开关恢复到首次降温。

2.4.2 实物图片

1、Arduino mega 2560代码
2、nodemcu 8266 代码

在这里插入图片描述

2.4.3 视频

演示视频暂时无法上传(需要的可以另外帖子留言

2.4.4 源代码

Mega2560:



#include <DallasTemperature.h>
#include <EEPROM.h>
int addr = 0;

bool first_flag = 1;   //首次加热标志位
unsigned long lastSend = 0;     //上传时间现态
unsigned long last_SendF = 0;     //刷新时间现态
unsigned long eeprom_Send = 0;
union data{
  float a;
  byte b[4];//一个float4字节
};
data EP_T1,EP_T2,EP_T3,EP_T4;


bool L_Wind_flag ;//左通风状态
bool R_Wind_flag ;//右通风状态
float Temperature_L1;
float Temperature_L2;
float Temperature_L3;
float Temperature_L4;
float Temperature_R1;
float Temperature_R2;
float Temperature_R3;
float Temperature_R4;
float Average_L ;
float Average_R ;
float T1 ;       //起始加热温度
float T2 ;       //停止加热温度
float T3 ;       //停止通风温度
float T4 ;       //过热通风温度

float Old_T1 = T1;       //起始加热温度
float Old_T2 = T2;       //停止加热温度
float Old_T3 = T3;       //停止通风温度
float Old_T4 = T4;       //过热通风温度
String Clouddata[5] = {""};

bool Switch_L1;    //盒子状态
bool Switch_L2;
bool Switch_L3;
bool Switch_L4;
bool Switch_L5;
bool Switch_L6;
bool Switch_R1;
bool Switch_R2;
bool Switch_R3;
bool Switch_R4;
bool Switch_R5;
bool Switch_R6;
bool Relay_L1;   //继电器状态
bool Relay_L2;
bool Relay_L3;
bool Relay_L4;
bool Relay_L5;
bool Relay_L6;
bool Relay_R1;
bool Relay_R2;
bool Relay_R3;
bool Relay_R4;
bool Relay_R5;
bool Relay_R6;

#define Switch_Pin_L1 20
#define Switch_Pin_L2 21
#define Switch_Pin_L3 22
#define Switch_Pin_L4 23

#define Switch_Pin_L5 28
#define Switch_Pin_L6 29

#define Switch_Pin_R1 24
#define Switch_Pin_R2 25
#define Switch_Pin_R3 26
#define Switch_Pin_R4 27

#define Switch_Pin_R5 30
#define Switch_Pin_R6 31

#define Relay_Pin_L1 2
#define Relay_Pin_L2 3
#define Relay_Pin_L3 4
#define Relay_Pin_L4 5

#define Relay_Pin_L5 10
#define Relay_Pin_L6 11

#define Relay_Pin_R1 6
#define Relay_Pin_R2 7
#define Relay_Pin_R3 8
#define Relay_Pin_R4 9

#define Relay_Pin_R5 12
#define Relay_Pin_R6 13

#define button_state  HIGH //按钮按下时电平
#define Hot_state HIGH     //继电器加热电平


#define ONE_WIRE_BUS 14               //温度传感器数据总线连接在IO14

OneWire oneWire(ONE_WIRE_BUS);       //声明
DallasTemperature sensors(&oneWire); //声明

DeviceAddress myDS18B20[8]; //声明一个地址对象

//获取数据
void get_data(){
  if(Serial1.available() > 0){
    String Rawdata = "";
    while (Serial1.available() > 0){
      Rawdata += char(Serial1.read());
      delay(2);
    }
//    Serial.println(Rawdata);
    int index = 0;
    for(int i = 0; i < Rawdata.length(); i++){
      if(Rawdata[i]==','){
        Clouddata[index] = "";
        for(i++; Rawdata[i]!=','; i++){
          Clouddata[index] += Rawdata[i];
        }
//        Serial.println(String("i=")+ i);
//        Serial.println(Clouddata[index]);
        
        if(i < Rawdata.length() - 2)i--;
        index++;
      }
    }
    T1 = Clouddata[0].toFloat();
    T2 = Clouddata[1].toFloat();
    T3 = Clouddata[2].toFloat();
    T4 = Clouddata[3].toFloat();
  }
}
//校验数据
void data_Check(){
  if(T1 > Old_T2 || T1 == 0){T1 = Old_T1;}
  else{Old_T1 = T1;}
  if(T2 > Old_T3 || T2 == 0){T2 = Old_T2;}
  else{Old_T2 = T2;}
  if(T3 > Old_T4 || T3 == 0){T3 = Old_T3;}
  else{Old_T3 = T3;}
  if(T4 < Old_T3 || T4 == 0){T4 = Old_T4;}
  else{Old_T4 = T4;}
  
}
//发送数据
void sent_data(){
  String all_data = ","+ String(Temperature_L1)+","+String(Temperature_L2)+","+String(Temperature_L3)+","+String(Temperature_L4)+","+String(Temperature_R1)+","+String(Temperature_R2)+","+String(Temperature_R3)+","+String(Temperature_R4);
  all_data += ","+ String(T1)+","+String(T2)+","+String(T3)+","+String(T4);
  all_data += ","+String(Switch_L1)+","+String(Switch_L2)+","+String(Switch_L3)+","+String(Switch_L4)+","+String(Switch_L5)+","+String(Switch_L6)+","+String(Switch_R1)+","+String(Switch_R2)+","+String(Switch_R3)+","+String(Switch_R4)+","+String(Switch_R5)+","+String(Switch_R6);
  all_data += ","+String(Relay_L1)+","+String(Relay_L2)+","+String(Relay_L3)+","+String(Relay_L4)+","+String(Relay_L5)+","+String(Relay_L6)+","+String(Relay_R1)+","+String(Relay_R2)+","+String(Relay_R3)+","+String(Relay_R4)+","+String(Relay_R5)+","+String(Relay_R6)+",";
  Serial1.print(all_data);
}


void setup() {
  Serial.begin(115200);
  Serial1.begin(115200);
  eeprom_read();          //读取缓存数据
  T1 = Old_T1;
  T2 = Old_T2;
  T3 = Old_T3;
  T4 = Old_T4;
  
  Serial.println("");
  sensors.begin();         //初始化总线
  Serial.print("总线上DS18系列设备数量为:");
  Serial.println(sensors.getDS18Count());
  Serial.print("总线是否需要寄生供电(1-true; 0-false):");
  Serial.println(sensors.isParasitePowerMode());
  Serial.print("总线上设备数据最大分辨率为:");
  Serial.println(sensors.getResolution());
  for(int i = 0;i <= 7;i++){
    sensors.getAddress(myDS18B20[i], i); //获取索引号0的设备地址(设备序列号)
  }
  
  pinMode(Switch_Pin_L1,INPUT_PULLUP);      //GetButton(Switch_Pin_L1,0)
  pinMode(Switch_Pin_L2,INPUT_PULLUP);
  pinMode(Switch_Pin_L3,INPUT_PULLUP);
  pinMode(Switch_Pin_L4,INPUT_PULLUP);
  pinMode(Switch_Pin_L5,INPUT);
  pinMode(Switch_Pin_L6,INPUT);
  pinMode(Switch_Pin_R1,INPUT_PULLUP);
  pinMode(Switch_Pin_R2,INPUT_PULLUP);
  pinMode(Switch_Pin_R3,INPUT_PULLUP);
  pinMode(Switch_Pin_R4,INPUT_PULLUP);
  pinMode(Switch_Pin_R5,INPUT);
  pinMode(Switch_Pin_R6,INPUT);

  pinMode(Relay_Pin_L1,OUTPUT);
  pinMode(Relay_Pin_L2,OUTPUT);
  pinMode(Relay_Pin_L3,OUTPUT);
  pinMode(Relay_Pin_L4,OUTPUT);
  pinMode(Relay_Pin_L5,OUTPUT);
  pinMode(Relay_Pin_L6,OUTPUT);
  pinMode(Relay_Pin_R1,OUTPUT);
  pinMode(Relay_Pin_R2,OUTPUT);
  pinMode(Relay_Pin_R3,OUTPUT);
  pinMode(Relay_Pin_R4,OUTPUT);
  pinMode(Relay_Pin_R5,OUTPUT);
  pinMode(Relay_Pin_R6,OUTPUT);
  
  while(Serial1.read()>= 0){}//clear serialbuffer
}

/********写入数据函数***********/
void eeprom_write(){
  EP_T1.a = Old_T1;
  EP_T2.a = Old_T2;
  EP_T3.a = Old_T3;
  EP_T4.a = Old_T4;
  for(int i = 0;i <= 3;i++){
    EEPROM.write(i,EP_T1.b[i]);
    EEPROM.write(i+4,EP_T2.b[i]);
    EEPROM.write(i+8,EP_T3.b[i]);
    EEPROM.write(i+12,EP_T4.b[i]);
  }
}

/********读取数据函数***********/
void eeprom_read(){
  for(int i = 0;i <= 3;i++){
    EP_T1.b[i] = EEPROM.read(i);
    EP_T2.b[i] = EEPROM.read(i+4);
    EP_T3.b[i] = EEPROM.read(i+8);
    EP_T4.b[i] = EEPROM.read(i+12);
    Old_T1 = EP_T1.a ;
    Old_T2 = EP_T2.a ;
    Old_T3 = EP_T3.a ;
    Old_T4 = EP_T4.a ;
  }
}

void eeprom_chack(){
  if(millis() - eeprom_Send >5){
    if(EP_T1.a != Old_T1 || EP_T2.a != Old_T2 || EP_T3.a != Old_T3|| EP_T4.a != Old_T4){
      eeprom_write();
    }
  }
}
/********按钮结构体*********/
struct Button{
  int buttonState;                     //按钮状态变量
  int lastButtonState = LOW;           //按钮状态初始化
  long lastDebounceTime = 0;           //记录抖动变量
  long debounceDelay = 50;             //抖动时间变量50ms
};
Button button[12];                         //新建1个按钮

/********按钮消抖函数********/
void GetButton(int button_pin,int button_NUM){                    
  int reading = digitalRead(button_pin);  //读取I/O口状态
  if(reading!=button[button_NUM].lastButtonState){ //如果状态发生改变
    button[button_NUM].lastDebounceTime = millis();//更新时间
  }                                    //如果等待时间大于debounceDelay
  if((millis()-button[button_NUM].lastDebounceTime)>button[button_NUM].debounceDelay){
    if(reading!=button[button_NUM].buttonState){   //读取状态不等于按钮状态
      button[button_NUM].buttonState = reading;    //更新buttonState
    }
  }
  button[button_NUM].lastButtonState = reading;    //更新lastButtonState
}

/********获取按钮状态函数********/
void GetAllButton(){
  GetButton(Switch_Pin_L1,0);
  GetButton(Switch_Pin_L2,1);
  GetButton(Switch_Pin_L3,2);
  GetButton(Switch_Pin_L4,3);
  GetButton(Switch_Pin_L5,4);
  GetButton(Switch_Pin_L6,5);
  GetButton(Switch_Pin_R1,6);
  GetButton(Switch_Pin_R2,7);
  GetButton(Switch_Pin_R3,8);
  GetButton(Switch_Pin_R4,9);
  GetButton(Switch_Pin_R5,10);
  GetButton(Switch_Pin_R6,11);
  Switch_L1 = button[0].lastButtonState;
  Switch_L2 = button[1].lastButtonState;
  Switch_L3 = button[2].lastButtonState;
  Switch_L4 = button[3].lastButtonState;
  Switch_L5 = button[4].lastButtonState;
  Switch_L6 = button[5].lastButtonState;
  Switch_R1 = button[6].lastButtonState;
  Switch_R2 = button[7].lastButtonState;
  Switch_R3 = button[8].lastButtonState;
  Switch_R4 = button[9].lastButtonState;
  Switch_R5 = button[10].lastButtonState;
  Switch_R6 = button[11].lastButtonState;
}


/*************获取温度函数*************/
void get_Temp(){
  for(int i = 0;i <= 7;i++){
    sensors.requestTemperaturesByAddress(myDS18B20[i]); //向总线上指定地址传感器发送温度转换请求
    //Serial.print(i);
    //Serial.print(">当前摄氏是: ");
    //Serial.println(sensors.getTempCByIndex(i));
    if(i == 0){Temperature_L1 = sensors.getTempCByIndex(i);}
    if(i == 1){Temperature_L2 = sensors.getTempCByIndex(i);}
    if(i == 2){Temperature_L3 = sensors.getTempCByIndex(i);}
    if(i == 3){Temperature_L4 = sensors.getTempCByIndex(i);}
    if(i == 4){Temperature_R1 = sensors.getTempCByIndex(i);}
    if(i == 5){Temperature_R2 = sensors.getTempCByIndex(i);}
    if(i == 6){Temperature_R3 = sensors.getTempCByIndex(i);}
    if(i == 7){Temperature_R4 = sensors.getTempCByIndex(i);}
  }
  Average_L = (Temperature_L1+Temperature_L2+Temperature_L3+Temperature_L4)/4;
  Average_R = (Temperature_R1+Temperature_R2+Temperature_R3+Temperature_R4)/4;
}

/*************加热触发函数*************/
void Heating(){
  if(first_flag == 1){
    if(Temperature_L1 < T1 || Temperature_L2 < T1 || Temperature_L3 < T1 || Temperature_L4 < T1 || Temperature_R1 < T1 || Temperature_R2 < T1 || Temperature_R3 < T1 || Temperature_R4 < T1){
      first_flag = 0;         //如果温度降到T1,更新标志位
    }                         //各盒子温度低于T1开始加热,否则停止加热
  }
  if(Temperature_L1 < T1 ){digitalWrite(Relay_Pin_L1,Hot_state);Relay_L1=Hot_state;}
  if(Temperature_L1 > T2 ){digitalWrite(Relay_Pin_L1,!Hot_state);Relay_L1=!Hot_state;}
    
  if(Temperature_L2 < T1 ){digitalWrite(Relay_Pin_L2,Hot_state);Relay_L2=Hot_state;}
  if(Temperature_L2 > T2 ){digitalWrite(Relay_Pin_L2,!Hot_state);Relay_L2=!Hot_state;}

  if(Temperature_L3 < T1 ){digitalWrite(Relay_Pin_L3,Hot_state);Relay_L3=Hot_state;}
  if(Temperature_L3 > T2 ){digitalWrite(Relay_Pin_L3,!Hot_state);Relay_L3=!Hot_state;}

  if(Temperature_L4 < T1 ){digitalWrite(Relay_Pin_L4,Hot_state);Relay_L4=Hot_state;}
  if(Temperature_L4 > T2 ){digitalWrite(Relay_Pin_L4,!Hot_state);Relay_L4=!Hot_state;}

  if(Temperature_R1 < T1 ){digitalWrite(Relay_Pin_R1,Hot_state);Relay_R1=Hot_state;}
  if(Temperature_R1 > T2 ){digitalWrite(Relay_Pin_R1,!Hot_state);Relay_R1=!Hot_state;}

  if(Temperature_R2 < T1 ){digitalWrite(Relay_Pin_R2,Hot_state);Relay_R2=Hot_state;}
  if(Temperature_R2 > T2 ){digitalWrite(Relay_Pin_R2,!Hot_state);Relay_R2=!Hot_state;}

  if(Temperature_R3 < T1 ){digitalWrite(Relay_Pin_R3,Hot_state);Relay_R3=Hot_state;}
  if(Temperature_R3 > T2 ){digitalWrite(Relay_Pin_R3,!Hot_state);Relay_R3=!Hot_state;}

  if(Temperature_R4 < T1 ){digitalWrite(Relay_Pin_R4,Hot_state);Relay_R4=Hot_state;}
  if(Temperature_R4 > T2 ){digitalWrite(Relay_Pin_R4,!Hot_state);Relay_R4=!Hot_state;}
}

/*************过热通风函数*************/
void Cooling(){
  if(first_flag == 0){
    if(Average_L > T4){Left_Vent_On();L_Wind_flag = 1;}
    if(Average_L < T3){Left_Vent_Off();L_Wind_flag = 0;}
    if(Average_R > T4){Right_Vent_On();R_Wind_flag = 1;}
    if(Average_L < T3){Right_Vent_Off();R_Wind_flag = 0;}
  }
}

void Left_Vent_On(){
  if(button[4].lastButtonState != button_state){
    digitalWrite(Relay_Pin_L5,HIGH);
    digitalWrite(Relay_Pin_L6,LOW);
  }
   else{
    digitalWrite(Relay_Pin_L5,LOW);
    digitalWrite(Relay_Pin_L6,LOW);
  }
}
void Left_Vent_Off(){
  if(button[5].lastButtonState != button_state){
    digitalWrite(Relay_Pin_L5,LOW);
    digitalWrite(Relay_Pin_L6,HIGH);
  }
  else{
    digitalWrite(Relay_Pin_L5,LOW);
    digitalWrite(Relay_Pin_L6,LOW);
  }
}
void Right_Vent_On(){
  if(button[10].lastButtonState != button_state){
    digitalWrite(Relay_Pin_R5,HIGH);
    digitalWrite(Relay_Pin_R6,LOW);
  }
   else{
    digitalWrite(Relay_Pin_R5,LOW);
    digitalWrite(Relay_Pin_R6,LOW);
  }
}
void Right_Vent_Off(){
  if(button[11].lastButtonState != button_state){
    digitalWrite(Relay_Pin_R5,LOW);
    digitalWrite(Relay_Pin_R6,HIGH);
  }
  else{
    digitalWrite(Relay_Pin_R5,LOW);
    digitalWrite(Relay_Pin_R6,LOW);
  }
}

/*************串口显示函数*************/
void Serial_Send(){
  String data1 = "----------------------------------------------------------------\r\n";
  data1 +="    T1:" + String(T1) + "   \tT2:" + String(T2) + "   \tT3:" + String(T3) + "   \tT4:" + String(T4) +"\r\n";
  data1 += "\tSwitch\tRelay\tSensor\tSensor\tRelay\tSwitch\r\n";
  data1 += "L1\t  " + String(Switch_L1)+ "\t  " + String(Relay_L1)+ "\t" + String(Temperature_L1)+ "\t" + String(Temperature_R1)+ "\t  " + String(Relay_R1) + "\t  " +String(Switch_R1)+ "\t" +"R1\r\n";
  data1 += "L2\t  " + String(Switch_L2)+ "\t  " + String(Relay_L2)+ "\t" + String(Temperature_L2)+ "\t" + String(Temperature_R2)+ "\t  " + String(Relay_R2) + "\t  " +String(Switch_R2)+ "\t" +"R2\r\n";
  data1 += "L3\t  " + String(Switch_L3)+ "\t  " + String(Relay_L3)+ "\t" + String(Temperature_L3)+ "\t" + String(Temperature_R3)+ "\t  " + String(Relay_R3) + "\t  " +String(Switch_R3)+ "\t" +"R3\r\n";
  data1 += "L4\t  " + String(Switch_L4)+ "\t  " + String(Relay_L4)+ "\t" + String(Temperature_L4)+ "\t" + String(Temperature_R4)+ "\t  " + String(Relay_R4) + "\t  " +String(Switch_R4)+ "\t" +"R4\r\n";
  data1 += "L5\t  " + String(Switch_L5)+ "\t  " + String(Relay_L5)+ "\t" + String("   Average  ")+ "\t  " + String(Relay_R5) + "\t  " +String(Switch_R5)+ "\t" +"R5\r\n";
  data1 += "L6\t  " + String(Switch_L6)+ "\t  " + String(Relay_L6)+ "\t" + String(Average_L)+ "\t" + String(Average_R)+ "\t  " + String(Relay_R6) + "\t  " +String(Switch_R6)+ "\t" +"R6\r\n";

  //data += "L_wind\t  " + String(L_Wind_flag)+ "\t  " + String(L_Wind_flag)+ "\t" + String(Average_L)+ "\t" + String(Average_R)+ "\t  " + String(R_Wind_flag) + "\t  " +String(R_Wind_flag)+ "\t" +"R_Wind\r\n";
  data1 += "Is it the first cooling :" + String(first_flag);
  Serial.println(data1);
  
}

/*************随机温度函数*************/
void random_temp(){
  T1 = 35;
  T2 = 39;
  T3 = 40;
  T4 = 50;
  Temperature_L1 = random(25,60);
  Temperature_L2 = random(25,60);
  Temperature_L3 = random(25,60);
  Temperature_L4 = random(25,60);
  Temperature_R1 = random(25,60);
  Temperature_R2 = random(25,60);
  Temperature_R3 = random(25,60);
  Temperature_R4 = random(25,60);
}
  
void loop() {
  if(millis() - lastSend >= 1000){
    sent_data();
  }
  if(millis() - last_SendF >= 3000){
    get_Temp();          //获取温度
    //random_temp();     //随机获取温度
    GetAllButton();    //获取按钮状态函数
    Heating();            //加热判断
    Cooling();           //过热通风
    Serial_Send();       //串口打印状态
  }
  eeprom_chack();
  get_data();
  data_Check();
}

nodemcu:


#include <ESP8266WiFi.h>  
#include <DNSServer.h>
#include <ESP8266WebServer.h>
#include <WiFiManager.h>
#include <ArduinoJson.h>
#include <aliyun_mqtt.h>
#include <Ticker.h>
void initSystem();
void initWifiManager();
void configModeCallback(WiFiManager *myWiFiManager);
void saveConfigCallback();
void tick();
bool shouldSaveConfig = false;
Ticker ticker;
char mqtt_server[40];
char mqtt_port[6] = "8080";
char api_key[34] = "Your ApiKey";

int Switch_L1;    //盒子状态
int Switch_L2;
int Switch_L3;
int Switch_L4;
int Switch_L5;
int Switch_L6;
int Switch_R1;
int Switch_R2;
int Switch_R3;
int Switch_R4;
int Switch_R5;
int Switch_R6;
int Relay_L1;   //继电器状态
int Relay_L2;
int Relay_L3;
int Relay_L4;
int Relay_L5;
int Relay_L6;
int Relay_R1;
int Relay_R2;
int Relay_R3;
int Relay_R4;
int Relay_R5;
int Relay_R6;
float T1 ;       //起始加热温度
float T2 ;       //停止加热温度
float T3 ;       //停止通风温度
float T4 ;       //过热通风温度

unsigned long lastSend = 0;     //上云时间现态
float Old_T1 = T1;       //起始加热温度
float Old_T2 = T2;       //停止加热温度
float Old_T3 = T3;       //停止通风温度
float Old_T4 = T4;       //过热通风温度

String Clouddata[40] = {""};
float Temperature_L1;
float Old_Temperature_L1;
float Temperature_L2;
float Temperature_L3;
float Temperature_L4;
float Temperature_R1;
float Temperature_R2;
float Temperature_R3;
float Temperature_R4;

/* 产品的三元组信息,根据9个测试设备的三元组,每个设备都烧录不同的*/
#define PRODUCT_KEY       "a1q7OV3Qy0Y"
#define DEVICE_NAME       "code_V1"
#define DEVICE_SECRET     "u9rwv4Z6OSz0kt6rUfol9SaZ2UOydI3K"

#define ALINK_BODY_FORMAT         "{\"id\":\"123\",\"version\":\"1.0\",\"method\":\"%s\",\"params\":%s}"
#define ALINK_TOPIC_PROP_POST     "/sys/" PRODUCT_KEY "/" DEVICE_NAME "/thing/event/property/post"
#define ALINK_TOPIC_PROP_POSTRSP  "/sys/" PRODUCT_KEY "/" DEVICE_NAME "/thing/event/property/post_reply"
#define ALINK_TOPIC_PROP_SET      "/sys/" PRODUCT_KEY "/" DEVICE_NAME "/thing/service/property/set"
#define ALINK_METHOD_PROP_POST    "thing.event.property.post"

//创建WiFiClient实例
WiFiClient espClient;
//创建MqttClient实例
PubSubClient mqttClient(espClient);

//监听云端下发指令并处理 
void callback(char *topic, byte *payload, unsigned int length){
  payload[length] = '\0';
//    Serial.println((char *)payload);
  if (strstr(topic, ALINK_TOPIC_PROP_SET)){
    StaticJsonBuffer<400> jsonBuffer;
    JsonObject &root = jsonBuffer.parseObject(payload);
    if (!root.success()){   
//    Serial.println("parseObject() failed");
    } 
    else{
//      Serial.println("parseObject() success");
//      Serial.println((char )payload[52]);
//      Serial.println((char )payload[53]);
//      Serial.println((char )payload[54]);
//      Serial.println((char )payload[55]);
//      Serial.println((char )payload[56]);
      if((char )payload[55] == '1' || (char )payload[5] == '1'){
        T1 = root["params"]["T1"];
//        Serial.println("T1 change");
//        Serial.println(T1);
      }
      if((char )payload[55] == '2'){
        T2 = root["params"]["T2"]; 
//        Serial.println("T2 change");
//        Serial.println(T2);
      }
      if((char )payload[55] == '3'){
        T3 = root["params"]["T3"];
//        Serial.println("T3 change");
//        Serial.println(T3);
      }
      if((char )payload[55] == '4'){
        T4 = root["params"]["T4"]; 
//        Serial.println("T4 change");
//        Serial.println(T4);
      }
      mqttIntervalPost_back();
    }
  }
}

/********连接Mqtt订阅属性设置Topic*********/
void mqttCheckConnect(){
  bool connected = connectAliyunMQTT(mqttClient, PRODUCT_KEY, DEVICE_NAME, DEVICE_SECRET);
  if (connected){
    //Serial.println("MQTT connect succeed!");
    //订阅属性设置Topic
    mqttClient.subscribe(ALINK_TOPIC_PROP_SET); 
    //Serial.println("subscribe done");
  }
}
// 云端下发指令数据回调T1-T4
void mqttIntervalPost_back(){
  char param1[300];
  char jsonBuf1[512];
  sprintf(param1, "{\"T1\":%f,\"T2\":%f,\"T3\":%f,\"T4\":%f}",T1,T2,T3,T4);
  sprintf(jsonBuf1, ALINK_BODY_FORMAT, ALINK_METHOD_PROP_POST, param1);
  mqttClient.publish(ALINK_TOPIC_PROP_POST, jsonBuf1); 
  delay(100);
}

// 上报属性Topic数据
void mqttIntervalPost(){
  char param1[300];
  char jsonBuf1[512];
  sprintf(param1, "{\"TL1\":%f,\"TL2\":%f,\"TL3\":%f,\"TL4\":%f,\"TR1\":%f,\"TR2\":%f,\"TR3\":%f,\"TR4\":%f}", Temperature_L1,Temperature_L2,Temperature_L3,Temperature_L4,Temperature_R1,Temperature_R2,Temperature_R3,Temperature_R4);
  sprintf(jsonBuf1, ALINK_BODY_FORMAT, ALINK_METHOD_PROP_POST, param1);
  mqttClient.publish(ALINK_TOPIC_PROP_POST, jsonBuf1); 
//  Serial.println(jsonBuf1);
  delay(100);
  sprintf(param1, "{\"SL1\":%d,\"SL2\":%d,\"SL3\":%d,\"SL4\":%d,\"SL5\":%d,\"SL6\":%d,\"SR1\":%d,\"SR2\":%d,\"SR3\":%d,\"SR4\":%d,\"SR5\":%d,\"SR6\":%d}",Switch_L1,Switch_L2,Switch_L3,Switch_L4,Switch_L5,Switch_L6,Switch_R1,Switch_R2,Switch_R3,Switch_R4,Switch_R5,Switch_R6);
  sprintf(jsonBuf1, ALINK_BODY_FORMAT, ALINK_METHOD_PROP_POST, param1);
  mqttClient.publish(ALINK_TOPIC_PROP_POST, jsonBuf1); 
  delay(100);
//  Serial.println(jsonBuf1);
  sprintf(param1, "{\"RL1\":%d,\"RL2\":%d,\"RL3\":%d,\"RL4\":%d,\"RL5\":%d,\"RL6\":%d,\"RR1\":%d,\"RR2\":%d,\"RR3\":%d,\"RR4\":%d,\"RR5\":%d,\"RR6\":%d}",Relay_L1,Relay_L2,Relay_L3,Relay_L4,Relay_L5,Relay_L6,Relay_R1,Relay_R2,Relay_R3,Relay_R4,Relay_R5,Relay_R6);
  sprintf(jsonBuf1, ALINK_BODY_FORMAT, ALINK_METHOD_PROP_POST, param1);
  mqttClient.publish(ALINK_TOPIC_PROP_POST, jsonBuf1); 
//  Serial.println(jsonBuf1);
}

/********数据下发*********/
void data_down(){
  if(T1 != Old_T1 || T2 != Old_T2 || T3 != Old_T3 || T4 != Old_T4){
    String all_data = ","+ String(T1)+","+String(T2)+","+String(T3)+","+String(T4)+",";
    Serial.print(all_data);
    Old_T1 = T1;
    Old_T2 = T2;
    Old_T3 = T3;
    Old_T4 = T4;
  }
}

/********获取数据*********/
void get_data(){
  if(Serial.available() > 0){
    String Rawdata = "";
    while (Serial.available() > 0){
      Rawdata += char(Serial.read());
      delay(2);
    }
//    Serial.println(Rawdata);
    int index = 0;
    for(int i = 0; i < Rawdata.length(); i++){
      if(Rawdata[i]==','){
        Clouddata[index] = "";
        for(i++; Rawdata[i]!=','; i++){
          Clouddata[index] += Rawdata[i];
        }
//        Serial.println(String("i=")+ i);
//        Serial.println(Clouddata[index]);
 
        if(i < Rawdata.length() - 2)i--;
        index++;
      }
    }
    sent_data_up();
  } 
}
//数据上云前处理
void sent_data_up(){
  Temperature_L1 = Clouddata[0].toFloat();
  Temperature_L2 = Clouddata[1].toFloat();
  Temperature_L3 = Clouddata[2].toFloat();
  Temperature_L4 = Clouddata[3].toFloat();
  Temperature_R1 = Clouddata[4].toFloat();
  Temperature_R2 = Clouddata[4].toFloat();
  Temperature_R3 = Clouddata[5].toFloat();
  Temperature_R4 = Clouddata[7].toFloat();
  T1 = Clouddata[8].toFloat();
  T2 = Clouddata[9].toFloat();
  T3 = Clouddata[10].toFloat();
  T4 = Clouddata[11].toFloat();
  Switch_L1 = Clouddata[12].toInt();
  Switch_L2 = Clouddata[13].toInt();
  Switch_L3 = Clouddata[14].toInt();
  Switch_L4 = Clouddata[15].toInt();
  Switch_L5 = Clouddata[16].toInt();
  Switch_L6 = Clouddata[17].toInt();
  Switch_R1 = Clouddata[18].toInt();
  Switch_R2 = Clouddata[19].toInt();
  Switch_R3 = Clouddata[20].toInt();
  Switch_R4 = Clouddata[21].toInt();
  Switch_R5 = Clouddata[22].toInt();
  Switch_R6 = Clouddata[23].toInt();
  Relay_L1 = Clouddata[24].toInt();
  Relay_L2 = Clouddata[25].toInt();
  Relay_L3 = Clouddata[26].toInt();
  Relay_L4 = Clouddata[27].toInt();
  Relay_L5 = Clouddata[28].toInt();
  Relay_L6 = Clouddata[29].toInt();
  Relay_R1 = Clouddata[30].toInt();
  Relay_R2 = Clouddata[31].toInt();
  Relay_R3 = Clouddata[32].toInt();
  Relay_R4 = Clouddata[33].toInt();
  Relay_R5 = Clouddata[34].toInt();
  Relay_R6 = Clouddata[35].toInt();
//  Serial.println(Temperature_L1);
//  Serial.println(Temperature_R1);
//  Serial.println(T1);
//  Serial.println(Switch_R5);
//  Serial.println(Relay_L5);
//  Serial.println(Relay_R2);
//  Serial.println(Relay_R6);
}

void setup() {
  Serial.begin(115200);
  initSystem();
  initWifiManager();
//  Serial.println("connected...so easy :)");
  ticker.detach();
  digitalWrite(BUILTIN_LED, LOW);

  mqttCheckConnect(); //初始化首次链接
  mqttIntervalPost(); //上报初始化数据
  mqttClient.setCallback(callback); // 回调,监听云端下发指令,当ESP8266收到订阅Topic后调用callback函数

}

void loop() {
  //sent_data_down();
  get_data();
  data_down();
  if (millis() - lastSend >= 1000){  //每隔1s尝试连接一次云
    lastSend = millis();
    mqttIntervalPost();               //上报一次数据
  }
  mqttClient.loop();
}

void initSystem(){
//  Serial.begin(115200);
//  Serial.println();
  pinMode(BUILTIN_LED, OUTPUT);
  ticker.attach(0.6, tick);
}

void initWifiManager(){
  WiFiManager wifiManager;
  wifiManager.setConnectTimeout(60);
  wifiManager.setDebugOutput(true);
  wifiManager.setMinimumSignalQuality(30);
  IPAddress _ip = IPAddress(192, 168, 4, 25);
  IPAddress _gw = IPAddress(192, 168, 4, 1);
  IPAddress _sn = IPAddress(255, 255, 255, 0);
  wifiManager.setAPStaticIPConfig(_ip, _gw, _sn);
  wifiManager.setAPCallback(configModeCallback);
  wifiManager.setSaveConfigCallback(saveConfigCallback);
  wifiManager.setBreakAfterConfig(true);
  wifiManager.setRemoveDuplicateAPs(true);
  WiFiManagerParameter custom_mqtt_server("server", "mqtt server", mqtt_server, 40);
  WiFiManagerParameter custom_mqtt_port("port", "mqtt port", mqtt_port, 6);
  WiFiManagerParameter custom_apikey("apikey", "onenet apikey", api_key, 32);
  wifiManager.addParameter(&custom_mqtt_server);
  wifiManager.addParameter(&custom_mqtt_port);
  wifiManager.addParameter(&custom_apikey);
  if (!wifiManager.autoConnect("ESP","12345678")) {
//      Serial.println("failed to connect and hit timeout");
      ESP.reset();
      delay(1000);
  }
  strcpy(mqtt_server, custom_mqtt_server.getValue());
  strcpy(mqtt_port, custom_mqtt_port.getValue());
  strcpy(api_key, custom_apikey.getValue());
  if (shouldSaveConfig) {
//      Serial.println("saving config");
      DynamicJsonBuffer jsonBuffer;
      JsonObject& json = jsonBuffer.createObject();
      json["mqtt_server"] = mqtt_server;
      json["mqtt_port"] = mqtt_port;
      json["api_key"] = api_key;
      json.printTo(Serial);
  }
//  Serial.println("local ip");
//  Serial.println(WiFi.localIP());
}

void configModeCallback (WiFiManager *myWiFiManager) {
//  Serial.println("Entered config mode");
//  Serial.println(WiFi.softAPIP());
//  Serial.println(myWiFiManager->getConfigPortalSSID());
  ticker.attach(0.2, tick);
}

void saveConfigCallback () {
//  Serial.println("Should save config");
  shouldSaveConfig = true;
}

void tick(){
  int state = digitalRead(BUILTIN_LED); 
  digitalWrite(BUILTIN_LED, !state);  
}

3、如何联系我们

博主联系方式汇总(非诚勿扰)

  • 12
    点赞
  • 51
    收藏
  • 打赏
    打赏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:点我我会动 设计师:我叫白小胖 返回首页
评论 1

打赏作者

单片机菜鸟哥

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值