esp8266+arduino+网页配网+温湿度上传+温度控制开关+eeprom永久保存+微信小程序控制

最新推荐文章于 2024-06-12 10:27:27 发布

ow114116

最新推荐文章于 2024-06-12 10:27:27 发布

阅读量8.7k

点赞数 7

文章标签：服务器网络运维物联网

本文链接：https://blog.csdn.net/ow114116/article/details/121498131

版权

直接上代码写的不喜勿喷

#include <ESP8266WiFi.h>
#include <EEPROM.h>
#include "DHT.h"
#include <DNSServer.h>
#include <ESP8266WebServer.h>
//#include <NTPClient.h>
//#define UID  "a27bfdae702118e7ac303bc1de2e1434"
//#define TOPIC  "esp"
#define TCP_SERVER_ADDR "bemfa.com" //巴法云服务器地址默认即可
#define TCP_SERVER_PORT "8344" //服务器端口，tcp创客云端口8344
//**************************************************//

#define DHTPIN D4
#define LED_Pin D5
String my_led_status = "off";
String TcpClient_Buff = "";//初始化字符串，用于接收服务器发来的数据
unsigned int TcpClient_BuffIndex = 0;
unsigned long TcpClient_preTick = 0;
unsigned long preHeartTick = 0;//心跳
unsigned long preHeartTick1 = 0;
unsigned long preTCPStartTick = 0;//连接
char get_ssid[40] = {0}; //从EEPROM中读取得到的SSIDchar类型数组
char get_psk[50] = {0}; //从EEPROM中读取得到的WIFI密码
char UID[45] = {0};
char TOPIC[34] = {0};
char wendu[10] = {0};
String kk = "";
String getTopic = "";
String getMsg = "";
String rr;
String tt;
String SSID_S;
String psk_s;
//String Mqtt_Bu;
#define addr 200   //这个地址可以随意设置，如果用本程序则不能设置为小于50以下的值（为读取密码字符串预留空间）
#define addr1 400
#define addr2 600
#define addr3 740
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);
#define MAX_PACKETSIZE 512
//设置心跳值30s
#define KEEPALIVEATIME 30*1000
#define KEEPALIVEATIME1 1*1000
//#define KEEPALIVEATIME2 2*100
//tcp客户端相关初始化，默认即可
WiFiClient TCPclient;
bool preTCPConnected = false;
//void doWiFiTick();
//void startSTA();
void doTCPClientTick();
void startTCPClient();
void sendtoTCPServer(String p);
//led控制函数，具体函数内容见下方
void turnOnLed();
void turnOffLed();
void sendtoTCPServer(String p) {
  if (!TCPclient.connected())
  {
    Serial.println("Client is not readly");
    return;
  }
  TCPclient.print(p);
}

int m ; //读取字符串长度的缓冲变量
union data  //定义一个联合体数据类型
{
  char a;
  byte b[2];
};

data col[40];  //两个缓存联合体用来分别用来读取 WIFI密码和名称
data col_2[50];
data col_3[50];
data col_4[50];
data col_5[50];
//两个用来分别转换字符串的数组
void change(String name1) {

  for (int i = 0; i < name1.length(); i++) {
    col[i].a = name1[i];
  }
}

void change_2(String name1) {

  for (int i = 0; i < name1.length(); i++) {
    col_2[i].a = name1[i];
  }
}
void change_3(String name1) {

  for (int i = 0; i < name1.length(); i++) {
    col_3[i].a = name1[i];
  }
}
void change_4(String name1) {

  for (int i = 0; i < name1.length(); i++) {
    col_4[i].a = name1[i];
  }
}
void change_5(String name1) {

  for (int i = 0; i < name1.length(); i++) {
    col_5[i].a = name1[i];
  }
}
//智能配网

const char* AP_NAME = "配网WIFI";//wifi名字
//暂时存储wifi账号密码
//char get_ssid[32] = {0};
//char get_psk[64] = {0};
//配网页面代码
const char* page_html = "\
<!DOCTYPE html>\r\n\
<html lang='en'>\r\n\
<head>\r\n\
  <meta charset='UTF-8'>\r\n\
  <meta name='viewport' content='width=device-width, initial-scale=1.0'>\r\n\
  <title>Document</title>\r\n\
</head>\r\n\
<body>\r\n\
  <form name='input' action='/' method='POST'>\r\n\
        wifi名称: <br>\r\n\
        <input type='text' name='ssid'><br>\r\n\
        wifi密码:<br>\r\n\
        <input type='text' name='password'><br>\r\n\
        私钥UID:<br>\r\n\
        <input type='text' name='UID'><br>\r\n\
        主题:<br>\r\n\
        <input type='text' name='TOPIC'><br>\r\n\
        <input type='submit' value='保存'>\r\n\
        <a href='./m?x1=1'><input type='button'value='重启'>\r\n\
    </form>\r\n\
</body>\r\n\
</html>\r\n\
";

const byte DNS_PORT = 53;//DNS端口号
IPAddress apIP(192, 168, 4, 1);//esp8266-AP-IP地址
DNSServer dnsServer;//创建dnsServer实例
ESP8266WebServer server(80);//创建WebServer

void handleRoot() {//访问主页回调函数
  server.send(200, "text/html", page_html);
  if (server.arg("x1") == "1") {
    ESP.restart();
    server.send(200, "text/html", "<meta charset='UTF-8'>重启成功");//返回保存成功页面
  }
}


void handleRootPost() {//Post回调函数
  Serial.println("handleRootPost");


  if (server.hasArg("ssid")) {//判断是否有账号参数
    Serial.print("got ssid:");
    strcpy(get_ssid, server.arg("ssid").c_str());//将账号参数拷贝到get_ssid中
    Serial.println(get_ssid);

  } else {//没有参数
    Serial.println("error, not found ssid");
    server.send(200, "text/html", "<meta charset='UTF-8'>error, not found ssid");//返回错误页面
    return;
  }
  //密码与账号同理
  if (server.hasArg("password")) {
    Serial.print("got password:");
    strcpy(get_psk, server.arg("password").c_str());
    Serial.println(get_psk);
  } else {
    Serial.println("error, not found password");
    server.send(200, "text/html", "<meta charset='UTF-8'>error, not found password");
    return;
  }
  if (server.hasArg("UID")) {//判断是否有账号参数
    Serial.print("UID:");
    strcpy(UID, server.arg("UID").c_str());//将账号参数拷贝到get_ssid中
    //    String rr(UID);
    Serial.println(UID);
    //    Serial.println(rr);

  } else {//没有参数
    Serial.println("没有私钥UID");
    server.send(200, "text/html", "<meta charset='UTF-8'>error, 没有私钥UID");//返回错误页面
    return;
  }
  if (server.hasArg("TOPIC")) {//判断是否有账号参数
    Serial.print("got TOPIC:");
    strcpy(TOPIC, server.arg("TOPIC").c_str());//将账号参数拷贝到get_ssid中
    //    String tt(TOPIC);
    Serial.println(TOPIC);
    //    Serial.println(tt);

  } else {//没有参数
    Serial.println("没有主题");
    server.send(200, "text/html", "<meta charset='UTF-8'>error, 没有主题");//返回错误页面
    return;
  }


  server.send(200, "text/html", "<meta charset='UTF-8'>保存成功");//返回保存成功页面

  delay(2000);
  //连接wifi
  connectNewWifi();
}

void initBasic(void) { //初始化基础
  //  Serial.begin(115200);
  WiFi.hostname("Smart-ESP8266");//设置ESP8266设备名
}

void initSoftAP(void) { //初始化AP模式
  WiFi.mode(WIFI_AP);
  WiFi.softAPConfig(apIP, apIP, IPAddress(255, 255, 255, 0));
  if (WiFi.softAP(AP_NAME)) {
    Serial.println("ESP8266 SoftAP is right");
  }
}

void initWebServer(void) { //初始化WebServer
  //server.on("/",handleRoot);
  //上面那行必须以下面这种格式去写否则无法强制门户
  server.on("/", HTTP_GET, handleRoot);//设置主页回调函数
  server.onNotFound(handleRoot);//设置无法响应的http请求的回调函数
  server.on("/", HTTP_POST, handleRootPost);//设置Post请求回调函数
  server.begin();//启动WebServer
  Serial.println("WebServer started!");
}



void connectNewWifi(void) {
  //  Serial.println(get_ssid);
  //    Serial.print(get_psk);
  WiFi.mode(WIFI_STA);//切换为STA模式
  WiFi.setAutoConnect(true);//设置自动连接
  WiFi.begin(get_ssid, get_psk);

  Serial.print("");
  Serial.print("Connect to wifi");
  int count = 0;
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    count++;
    if (count > 50) { //如果5秒内没有连上，就开启Web配网 可适当调整这个时间
      initSoftAP();
      initWebServer();
      initDNS();
      break;//跳出 防止无限初始化
    }
    Serial.print(".");
  }
  Serial.println("");
  if (WiFi.status() == WL_CONNECTED) { //如果连接上 就输出IP信息 防止未连接上break后会误输出
    Serial.println("WIFI Connected!");
    Serial.println("IP address: ");
    Serial.println(WiFi.localIP());//打印esp8266的IP地址
    for (int i = 0; i < 1024; i++)
      EEPROM.write(i, 0);
    EEPROM.commit();
    //    Serial.println(get_ssid);
    //    Serial.print(get_psk);
    String rr(UID);
    String tt(TOPIC);
    change(get_ssid);  //将WIFI的名称和密码转换到缓存数组当中去
    change_2(get_psk);
    change_3(UID);
    change_4(TOPIC);
    Serial.println("已缓存");
    for (int h = 0 ; h < WiFi.SSID().length(); h++) //将名称一个字节一个字节缓存进EEPROM里面
    {
      for (int k = 0 ; k < 2; k++) {
        EEPROM.write(m + addr, col[h].b[k]);
        m++; //m为字符串的个数
      }
    }
    EEPROM.write(addr + 1, m); //将WIFI名称的长度写入到存储到EPRROM里面，将用来前面的判断是否之前存储过WIFI
    m = 0; //将缓存清0
    for (int h = 0 ; h < WiFi.psk().length(); h++) //同理 密码
    {
      for (int k = 0 ; k < 2; k++) {
        EEPROM.write(4 + m, col_2[h].b[k]);
        m++;
      }
    }
    //    Serial.println("写入m得值为：" + m);
    EEPROM.write(0, m); //同理写入密码的长度
    m = 0;
    for (int h = 0 ; h < rr.length(); h++) //将名称一个字节一个字节缓存进EEPROM里面
    {
      for (int k = 0 ; k < 2; k++) {
        EEPROM.write(m + addr1, col_3[h].b[k]);
        m++; //m为字符串的个数
        //       Serial.println("写入m得值为：" + m);
      }
    }
    EEPROM.write(addr1 + 1, m);
    m = 0;
    for (int h = 0 ; h < tt.length(); h++) //将名称一个字节一个字节缓存进EEPROM里面
    {
      for (int k = 0 ; k < 2; k++) {
        EEPROM.write(m + addr2, col_4[h].b[k]);
        m++; //m为字符串的个数
        //       Serial.println("写入m得值为：" + m);
      }
    }
    EEPROM.write(addr2 + 1, m);
    EEPROM.commit();  //不要忘记储存！！！！
    startTCPClient();
    server.stop();
  }
}
void initDNS(void) { //初始化DNS服务器
  if (dnsServer.start(DNS_PORT, "*", apIP)) { //判断将所有地址映射到esp8266的ip上是否成功
    Serial.println("start dnsserver success.");
  }
  else Serial.println("start dnsserver failed.");

}


//初始化相关硬件
void setup() {
  pinMode(LED_Pin, OUTPUT);
  digitalWrite(LED_Pin, HIGH);
  Serial.begin(115200);
  initBasic();
  EEPROM.begin(1024);  //申请512个缓存字节
  dht.begin();
  //  timeClient.begin();
  Serial.println("Beginning...");
  //首先判断是否之前已经缓存了一个WIFI密码和名称，如果没有则进行网页配网，并将WIFI信息进行储存
  if (EEPROM.read(addr + 1) == 0 || EEPROM.read(0) == 0) {
    //smart_config();//网页配网

    initSoftAP();
    initWebServer();
    initDNS();
  }
  else   //如果之前已经储存过密码则对其进行读取
  {
    int n = 0;
    for (int i = 0 ; i < (int)EEPROM.read(addr + 1); i++) {
      if (i % 2 == 0) {
        col[30 + n].b[0] = EEPROM.read(addr + i);
        delay(200);
      }
      else
      {
        col[30 + n].b[1] = EEPROM.read(addr + i);
        //      Serial.print((char)col[30+n].a);
        get_ssid[n] = (char)col[30 + n].a ;
        n++;
        delay(200);
      }
    }
    n = 0;

    for (int i = 0 ; i < (int)EEPROM.read(0); i++) {
      if (i % 2 == 0) {
        col_2[30 + n].b[0] = EEPROM.read(4 + i);
        delay(200); //读取的时候记得延时合理的时间
      }
      else
      {
        col_2[30 + n].b[1] = EEPROM.read(4 + i);
        //      Serial.print((char)col_2[30+n].a);
        get_psk[n] = (char)col_2[30 + n].a ;
        n++;
        delay(200);
      }
    }
    n = 0;
    for (int i = 0 ; i < (int)EEPROM.read(addr1 + 1); i++) {
      if (i % 2 == 0) {
        col_3[30 + n].b[0] = EEPROM.read(addr1 + i);
        delay(200);
      }
      else
      {
        col_3[30 + n].b[1] = EEPROM.read(addr1 + i);
        //        Serial.print((char)col_3[30 + n].a);
        UID[n] = (char)col_3[30 + n].a ;
        n++;
        delay(200);
      }
    }
    n = 0;
    for (int i = 0 ; i < (int)EEPROM.read(addr2 + 1); i++) {
      if (i % 2 == 0) {
        col_4[30 + n].b[0] = EEPROM.read(addr2 + i);
        delay(200);
      }
      else
      {
        col_3[30 + n].b[1] = EEPROM.read(addr2 + i);
        //        Serial.print((char)col_4[30 + n].a);
        TOPIC[n] = (char)col_4[30 + n].a ;
        n++;
        delay(200);
      }
    }
    n = 0;
    for (int i = 0 ; i < (int)EEPROM.read(addr3 + 1); i++) {
      if (i % 2 == 0) {
        col_5[30 + n].b[0] = EEPROM.read(addr3 + i);
        delay(200);
      }
      else
      {
        col_5[30 + n].b[1] = EEPROM.read(addr3 + i);
        //        Serial.print((char)col_5[30 + n].a);
        wendu[n] = (char)col_5[30 + n].a ;
        n++;
        delay(200);
      }
    }
    String SSID_S(get_ssid);
    String psk_s(get_psk);
    rr = UID;
    tt = TOPIC;
    kk = wendu;
    Serial.println("字符串ssid: " + SSID_S);
    Serial.println("字符串secret: " + psk_s);
    Serial.println("字符串UID: " + rr);
    Serial.println("字符串TOPIC: " + tt);
    WiFi.setAutoConnect(true);
    WiFi.begin(SSID_S, psk_s);
    //WiFi.begin(ssid);*/
    int count = 0;
    while (WiFi.status() != WL_CONNECTED) {
      delay(500);
      Serial.print(".");
      count++;
      if (count > 100) { //如果5秒内没有连上，就开启Web配网 可适当调整这个时间
        initSoftAP();
        initWebServer();
        initDNS();
        break;
      }
    }

    if (WiFi.status() == WL_CONNECTED) {
      Serial.println("WiFi connected");
      Serial.println("IP address:");
      Serial.println(WiFi.localIP());
      startTCPClient();
    }
  }
}
void startSTA() {
  WiFi.setAutoConnect(true);
  WiFi.begin(SSID_S, psk_s);
  delay(5000);
}

void startTCPClient() {
  String rr(UID);
  String tt(TOPIC);
  if (WiFi.status() == WL_CONNECTED) {
    if (TCPclient.connect(TCP_SERVER_ADDR, atoi(TCP_SERVER_PORT))) {
      Serial.print("\nConnected to server:");
      Serial.printf("%s:%d\r\n", TCP_SERVER_ADDR, atoi(TCP_SERVER_PORT));

      String tcpTemp = ""; //初始化字符串
      tcpTemp = "cmd=1&uid=" + rr + "&topic=" + tt + "\r\n"; //构建订阅指令
      sendtoTCPServer(tcpTemp); //发送订阅指令
      tcpTemp = ""; //清空


      preTCPConnected = true;
      preHeartTick = millis();
      TCPclient.setNoDelay(true);
    }
    else {
      Serial.print("Failed connected to server:");
      Serial.println(TCP_SERVER_ADDR);
      TCPclient.stop();
      preTCPConnected = false;
      startSTA();
    }
    preTCPStartTick = millis();
  }
}
void doTCPClientTick() {
  //检查是否断开，断开后重连
  getTopic = "";
  getMsg = "";
  //   if(WiFi.status() != WL_CONNECTED) return;
  if (!TCPclient.connected()) {//断开重连

    if (preTCPConnected == true) {
      preTCPConnected = false;
      preTCPStartTick = millis();
      Serial.println();
      Serial.println("TCP Client disconnected.");
      TCPclient.stop();
    } else if (millis() - preTCPStartTick > 1 * 1000) //重新连接
      startTCPClient();
  }
  else
  {
    if (TCPclient.available()) {//收数据
      char c = TCPclient.read();
      TcpClient_Buff += c;
      TcpClient_BuffIndex++;
      TcpClient_preTick = millis();
      if (TcpClient_BuffIndex >= MAX_PACKETSIZE - 1) {
        TcpClient_BuffIndex = MAX_PACKETSIZE - 2;
        TcpClient_preTick = TcpClient_preTick - 10;
      }
      preHeartTick = millis();
    }
    if (millis() - preHeartTick >= KEEPALIVEATIME) { //保持心跳
      preHeartTick = millis();
      Serial.println("--Keep alive:");
      sendtoTCPServer("ping\r\n"); //发送心跳，指令需\r\n结尾，详见接入文档介绍
      Serial.print("4");
    }
  }
  if ((TcpClient_Buff.length() >= 1) && (millis() - TcpClient_preTick >= 10))
  {
    if (TcpClient_Buff.indexOf("#") != -1) {
      TcpClient_Buff = "";
      TcpClient_BuffIndex = 0;
      getMsg = "";
    } else {
      TCPclient.flush();
      Serial.print("Rev string: ");
      TcpClient_Buff.trim(); //去掉首位空格
      Serial.println(TcpClient_Buff); //打印接收到的消息
      if (TcpClient_Buff.length() > 15) { //注意TcpClient_Buff只是个字符串，在上面开头做了初始化 String TcpClient_Buff = "";
        //      Serial.print("11");
        //此时会收到推送的指令，指令大概为 cmd=2&uid=xxx&topic=light002&msg=off
        int topicIndex = TcpClient_Buff.indexOf("&topic=") + 7; //c语言字符串查找，查找&topic=位置，并移动7位，不懂的可百度c语言字符串查找
        int msgIndex = TcpClient_Buff.indexOf("&msg=");//c语言字符串查找，查找&msg=位置
        getTopic = TcpClient_Buff.substring(topicIndex, msgIndex); //c语言字符串截取，截取到topic,不懂的可百度c语言字符串截取
        getMsg = TcpClient_Buff.substring(msgIndex + 5); //c语言字符串截取，截取到消息
        Serial.print("topic:------");
        Serial.println(getTopic); //打印截取到的主题值
        Serial.print("msg:--------");
        Serial.println(getMsg);   //打印截取到的消息值
      }
    }
    if (getMsg  == "on") {     //如果是消息==打开
      //      turnOnLed();
      my_led_status = "on";
      //      delay(100);
    } else if (getMsg == "off") { //如果是消息==关闭
      //      turnOffLed();
      my_led_status = "off";
      //      delay(100);
    }

    if (getMsg.indexOf("°C") != -1) {
      kk = getMsg;
      if (getMsg.indexOf("=") != -1) {
      } else {
        yy();
        getMsg = "";
      }
    }
    TcpClient_Buff = "";
    TcpClient_BuffIndex = 0;
    getMsg = "";
  }
}
void yy() {
  String uu = kk;
  Serial.println("10");
  Serial.println(kk);
  change_5(kk);
  m = 0;
  for (int h = 0 ; h < uu.length(); h++) //将名称一个字节一个字节缓存进EEPROM里面
  {
    for (int k = 0 ; k < 2; k++) {
      EEPROM.write(m + addr3, col_5[h].b[k]);
      m++; //m为字符串的个数
      //       Serial.println("写入m得值为：" + m);
    }
  }
  EEPROM.write(addr3 + 1, m);
  EEPROM.commit();  //不要忘记储存！！！！

}


//打开灯泡
void turnOnLed() {
  //  Serial.println("Turn ON");
  digitalWrite(LED_Pin, LOW);
  delay(10);
}

//关闭灯泡
void turnOffLed() {
  //  Serial.println("Turn OFF");
  digitalWrite(LED_Pin, HIGH);
  delay(10);
}

void fo() {

  int my_int = kk.toInt();
  my_int - 1;
  float h;
  float t;

  if (millis() - preHeartTick1 >= KEEPALIVEATIME1) { //上传数据
    //    oo = "";
    preHeartTick = millis();
    float h = dht.readHumidity();
    // Read temperature as Celsius (the default)
    float t = dht.readTemperature();
    // Read temperature as Fahrenheit (isFahrenheit = true)
    float f = dht.readTemperature(true);
    // Check if any reads failed and exit early (to try again).
    if (isnan(h) || isnan(t) || isnan(f)) {
      Serial.println(F("Failed to read from DHT sensor!"));
      return;
    }
    // Compute heat index in Fahrenheit (the default)
    float hif = dht.computeHeatIndex(f, h);
    // Compute heat index in Celsius (isFahreheit = false)
    float hic = dht.computeHeatIndex(t, h, false);
    String oo(t);
    int my = oo.toInt();
    if (my_led_status == "on") {
      if (my < my_int - 3) {
        turnOnLed();
      } else if (my >= my_int) {
        turnOffLed();
      }
    } else if (my_led_status == "off") {
      turnOffLed();
    } else if (my < 8) {
      turnOnLed();
    } else if (my >= 10) {
      turnOffLed();
    }

    //  Serial.print(F("Humidity: "));
    //  Serial.print(h);
    //  Serial.print(F("%  Temperature: "));
    //  Serial.print(t);
    //  Serial.print(F("°C "));
    //  Serial.print(f);
    //  Serial.print(F("°F  Heat index: "));
    //  Serial.print(hic);
    //  Serial.print(F("°C "));
    //  Serial.print(hif);
    //  Serial.println(F("°F"));
    if (WiFi.status() == WL_CONNECTED) {
      // Reading temperature or humidity takes about 250 milliseconds!
      // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
      String upstr = "";
      upstr = "cmd=2&uid=" + (String)UID + "&topic=" + (String)TOPIC + "&msg=" + (String)t + "#" + (String)h + "#" + (String)my_led_status + "#" + (String)my_int + "\r\n";
      sendtoTCPServer(upstr);
      upstr = "";
      
      //      timeClient.update();
      //      Serial.println(timeClient.getFormattedTime());
    }
  }
}

void loop() {
  //  Serial.println("IP address: ");
  doTCPClientTick();
  fo();

  // put your main code here, to run repeatedly:
  server.handleClient();
  dnsServer.processNextRequest();
}

微信小程序就不上传了上传控制代码

Page({

// index.js
// 获取应用实例

  data: {
    uid:"",//用户密钥，巴法云控制台获取          自己填写
    ledtopic:"",//控制led的主题，创客云控制台创建
    dhttopic:"",//传输温湿度的主题，创客云控制台创建 这里可以使用同一个主题

    device_status:"离线",// 显示led是否在线的字符串，默认离线
    ledOnOff:"关闭",     //显示led开关状态
    checked: false,     //led的状态记录。默认led关闭
    wendu:null,//温度值，默认为空
    shidu:null,//湿度值，默认为空
    dataTime:null, //记录数据上传的时间
    ledicon:"/utils/img/lightoff.png",//显示led图标的状态。默认是关闭状态图标
    client: null,//mqtt客户端，默认为空
    infoMess: '',
    
    userN:'',
  },
//屏幕打开时执行的函数
onLoad() {
  //检查设备是否在线
  this.getOnline()
  //检查设备是打开还是关闭
  this.getOnOff()
  //获取服务器上现在存储的dht11数据
  this.getdht11()
  //设置定时器，每3秒请求一下设备状态
  setInterval(this.getdht11, 3000)
  setInterval(this.getOnline, 10000)
},
  userNameInput:function(e){
    this.setData({
      userN:e.detail.value
    })
  },
  loginBtnClick:function(){
    if(this.data.userN.length == 0 ){
      this.setData({
        infoMess:'温馨提示：设定温度不能为空！',
      })
    }else{
      this.setData({
        infoMess:'设定温度：'+this.data.userN+'℃',
        
      })
      this.LedSendMsg(this.data.userN+"°C")
      delay(1000);
    }
  },

   //控制灯的函数1，小滑块点击后执行的函数
   onChange({ detail }){
    //detail是滑块的值，检查是打开还是关闭，并更换正确图标
    this.setData({ 
      checked: detail,
     });
     if(detail == true){//如果是打开操作
      this.LedSendMsg("on") //发送打开指令
      this.setData({ 
        ledicon: "/utils/img/lighton.png",//设置led图片为on
        
       });
     }else{
      this.LedSendMsg("off") //发送关闭指令
      this.setData({ 
        ledicon: "/utils/img/lightoff.png",//设置led图片为off
       });
       delay(100);
     }
  },
 //点击led图片执行的函数
 onChange2(){
  var that = this
    //如果点击前是打开状态，现在更换为关闭状态，并更换图标，完成状态切换
    if( that.data.checked == true){
      that.LedSendMsg("off")//发送关闭指令
      this.setData({ 
          ledicon: "/utils/img/lightoff.png",//设置led图片为off
          checked:false //设置led状态为false
       });
    }else{
      //如果点击前是关闭状态，现在更换为打开状态，并更换图标，完成状态切换
      that.LedSendMsg("on")//发送打开指令
      that.setData({ 
        ledicon: "/utils/img/lighton.png",//设置led图片为on
        checked:true//设置led状态为true
     });
     delay(100);
    }
},
getOnline(){
  var that = this
   //api 接口详细说明见巴法云接入文档
  wx.request({
    url: 'https://api.bemfa.com/api/device/v1/status/?', //状态api接口，详见巴法云接入文档
    data: {
      uid: that.data.uid,
      topic: that.data.ledtopic,
    },
    header: {
      'content-type': "application/x-www-form-urlencoded"
    },
    success (res) {
      console.log(res.data)
      if(res.data.status === "online"){//如果在线
        that.setData({
          device_status:"在线"  //设置状态为在线
        })
      }else{                          //如果不在线
        that.setData({
          device_status:"离线"   //设置状态为离线
        })
      }
      console.log(that.data.device_status)
    }
  })    

  
  },
  
  
  getOnOff(){
    //api 接口详细说明见巴法云接入文档
    var that = this
    wx.request({
      url: 'https://api.bemfa.com/api/device/v1/data/1/get/', //状态api接口，详见巴法云接入文档
      data: {
        uid: that.data.uid,
        topic: that.data.ledtopic,
        num:1
      },
      header: {
        'content-type': "application/x-www-form-urlencoded"
      },
      success (res) {
        console.log(res.data.msg)
        if(res.data.msg == "on"){  //如果开关on
          that.setData({
            checked:true,
            ledOnOff:"打开",
            ledicon: "/utils/img/lighton.png",
          })
        }else{           //如果开关off
          that.setData({
            checked:false,
            ledOnOff:"关闭",
            ledicon: "/utils/img/lightoff.png",
          })
        }
      }
    })    
  },
  getdht11(){
    //获取温湿度值，屏幕初始化时，未订阅收到温湿度时，先去主动获取值
    //api 接口详细说明见巴法云接入文档
    var that = this
    wx.request({
      url: 'https://api.bemfa.com/api/device/v1/data/1/get/', //状态api接口，详见巴法云接入文档
      data: {
        uid: that.data.uid,
        topic: that.data.dhttopic,
        num:1
      },
      header: {
        'content-type': "application/x-www-form-urlencoded"
      },
      success (res) {
       
        console.log(res)
        if(res.data.msg.indexOf("#") != -1){//如果数据里包含#号，表示获取的是传感器值，因为单片机上传数据的时候用#号进行了包裹
          //如果有#号就进行字符串分割
          var all_data_arr = res.data.msg.split("#"); //分割数据，并把分割后的数据放到数组里。
          console.log(all_data_arr)//打印数组
          that.setData({ //数据赋值给变量
            wendu:all_data_arr[1],//赋值温度
            shidu:all_data_arr[2], //赋值湿度
            wendu1:all_data_arr[4],
            dataTime:res.data.time
          })

          if(all_data_arr[3] != undefined){//判断是否上传了led状态
            if(all_data_arr[3] == "on"){//如果单片机处于打开状态
                that.setData({ //数据赋值给变量
                  ledOnOff:"打开",//赋值led状态
                  ledicon: "/utils/img/lighton.png",
                  checked:true,
                })
            }else{
              that.setData({ //数据赋值给变量
                ledOnOff:"关闭",//赋值led状态
                ledicon: "/utils/img/lightoff.png",
                checked:false,
              })
            }
      }

        }
      }
    })    
  },
//发送开关数据
LedSendMsg(msg){
  wx.request({
    url: 'https://api.bemfa.com/api/device/v1/data/1/push/get/?', //状态api接口，详见巴法云接入文档
    data: {
      uid: this.data.uid,
      topic: this.data.ledtopic,
      msg:msg
    },
    header: {
      'content-type': "application/x-www-form-urlencoded"
    },
    success (res) {
    }
  })   
},
})

欢迎大家讨论