Nodemcu（ESP8266）未从文件系统读取正确的数据

Question

我的问题是，在wificonnectionHandler构造函数的输入中，readfile（）在其他地方工作正常，并未读取文件。 我没有任何错误消息，只是与“”（空白字符串网络）的连接失败，

这是我的代码，对不起格式和注释不良

/*
Editor: Kertesz Domokos ([email protected])
Version: v1.5-beta
*/
//Header fileok
#include <Arduino.h>
#include "a_home.h"
#include "wifi-icos.h"
// #include "thingProperties.h"
#include "website.h"
#include <GxEPD2_BW.h> // including both doesn't use more code or ram
#include <GxEPD2_3C.h> // including both doesn't use more code or ram
#include <pgmspace.h>
#include <Adafruit_GFX.h>
#include <Fonts/FreeSansBold12pt7b.h>
#include <Fonts/Roboto_12.h>
#include <Fonts/Roboto_Bold_14.h>
#include <Fonts/Roboto_Bold_39.h>
#include <Fonts/FreeSans9pt7b.h>
#include <Fonts/FreeSans12pt7b.h>
#include <Fonts/FreeSans18pt7b.h>
#include <Fonts/FreeSans24pt7b.h>
#include <Fonts/FreeSansBold9pt7b.h>
#include <DHT.h>
#include <TimeLib.h>
#include <LittleFS.h>
#include <ESP8266WiFi.h>
#include <Hash.h>
#include <ESPAsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include <EEPROM.h>
#include <ESP8266WiFi.h>
#include <ESPAsyncTCP.h>
#include <ESP8266WiFi.h>
#include <ESPAsyncTCP.h>
#include <Hash.h>
#include <FS.h>
#include <ArduinoIoTCloud.h>
#include <Arduino_ConnectionHandler.h>


#define AnalogInput   A0
#define DHTPIN 3     //  RX PIN
//Kijelző beállításai
#define GxEPD2_DISPLAY_CLASS GxEPD2_BW
#define GxEPD2_DRIVER_CLASS GxEPD2_290_T94_V2  // ez a kijelző
#define MAX_DISPLAY_BUFFER_SIZE (81920ul-34000ul-5000ul) // ~34000 base use, change 5000 to your application use
#define MAX_HEIGHT(EPD) (EPD::HEIGHT <= MAX_DISPLAY_BUFFER_SIZE / (EPD::WIDTH / 8) ? EPD::HEIGHT : MAX_DISPLAY_BUFFER_SIZE / (EPD::WIDTH / 8))

#define DHTTYPE DHT22 

//Beállíthato változók
int InterruptPin    = 4;
int ReadValue       = 0;
int VolumeOld = -1;
int Volume          = 0;
char Result         = (' ');
int lightPin = 1; //TX PIN //fenyero a fény ereje
int humPin = 12; //D6/
int fanPin = 2; //D4


/**
  A napi okosságokat tartalmazó lista
*/
String didu[11][2] =
{ {"Mushrooms are genetically",  "closer to humans than plants."},
  {"Fungi are the largest",       "life forms on earth"},
  {"Fungi allow trees to",        "talk to each other"},
  {"Mushrooms are the fruit",     "of a fungus"},
  {"Mushrooms can create",        "airflow to disperse spores"},
  {"There’s a mushroom that",     "devours itself when picked"},
  {"Mushrooms produce vitamin D", " "},
  {"Mushrooms create fairy rings", " "},
  {"You can use mushrooms",       "as a natural pesticide"},
  {"Lightning boosts",           "mushroom growth"},
  {"Lightning boosts",           "mushroom growth"}
};

/**
  A napi érdekességek két sorának kezdő koordinátái
*/
int16_t cors[11][2] = {
  {30, 20},
  {60, 74},
  {65, 79},
  {45, 100},
  {55, 39},
  {50, 40},
  {15, 0},
  {20, 0},
  {35, 50},
  {68, 65},
  {68, 65}
};





// DHT dht(DHTPIN, DHTTYPE);

GxEPD2_DISPLAY_CLASS <GxEPD2_DRIVER_CLASS, MAX_HEIGHT(GxEPD2_DRIVER_CLASS)>
display(GxEPD2_DRIVER_CLASS(/**CS=D8*/ 0, /**DC=D3*/ 15, /**RST=D4*/ 5, /**BUSY=D2*/ 16));

//DHT beállítása



//Variables
int daynum = 1; //a termesztés jelenlegi napja
unsigned long unixtime;// a jelenlegi unix formátumú idő tárolására szolgáló változó
long millisToTime = 0;
long onlinecheckTime = 0;
long legcsereTime = 0;
long legcsereTimeOn = 0;
bool legcsereOn = 0;
int loadlineState = 0; //A folyamat töltővonalának állpota, nem csak naponta növekszik
long ledStateTime;
long paraTime;
int lastVolume;
long voltime;
int growpoint = 0;
long reftime;
bool online;
bool lastOnline;
bool ledState = false;
float para;
float homerseklet; 
long paraAutoTime;
long paraAutoTimeOn;
long paraOffTime;
bool normal=0;
bool firstStep=1;
bool secondStep=0;
bool apon=0;
bool beginned=0;
String lastSSID;
String eeprssid;
String eeprpass;


//thingProperties
const char DEVICE_LOGIN_NAME[]  = "2a93a86c-b9eb-4ae0-aed2-cddf35c12f59";
const char DEVICE_KEY[]  = "KEPPUTOYOFUK9Q6WD1NX";    // Secret device password

String SSIDiot;
String PASS;


String growStartTime;
String messages;
CloudTemperatureSensor tempwifi;
int celPara=80;
int fanSpeed=255;
int fenyero;
int lightOffTime=22;
int lightOnTime=10;
int paraCiklus=10000;
int paraPeriod=100;
int timezone;
CloudRelativeHumidity humwifi;
bool fanStatus;
bool humSatus;
bool paraSzenzorOff=0;
bool switchh=0;

void ICACHE_RAM_ATTR read_encoder(); //Hogy ne fagyjon be az encoder

AsyncWebServer server(80);

String readFile(const char * path) {
  if(beginned==0){
    LittleFS.begin();
    beginned=1;
  }

  Serial.printf("Reading file: %s\n", path);

  File file = LittleFS.open(path, "r");
  if (!file) {
    Serial.println("Failed to open file for reading");
    return "error";
  }
  String cont;
  Serial.print("Read from file: ");
  cont=file.readStringUntil('\n');
  // while (file.available()) {
  //   cont+=String((char)file.read());
  //   Serial.write(file.read());
  // }
  delay(10);
  file.close();
  return cont;
}

void writeFile(const char * path, String message) {
  Serial.printf("Writing file: %s\n", path);

  File file = LittleFS.open(path, "w");
  if (!file) {
    Serial.println("Failed to open file for writing");
    return;
  }
  if (file.print(message+"\n")) {
    Serial.println("File written "+message);
  } else {
    Serial.println("Write failed "+message);
  }
  file.flush();
  delay(10);
  file.close();
}

WiFiConnectionHandler ArduinoIoTPreferredConnection(readFile("/ssid.txt").c_str(), readFile("/pass.txt").c_str()); //Here is the problem

void setup() {

  pinMode(lightPin, OUTPUT);
  pinMode(fanPin, OUTPUT);
  pinMode(humPin, OUTPUT);
  pinMode(InterruptPin, INPUT);

  Serial.begin(115200);
  Serial.println("Setup begin...");
  EEPROM.begin(512);
  // WiFi.softAP(ssid);
  // IPAddress IP = WiFi.softAPIP();


   Serial.println("filesystem begin...");
if(!beginned){
  bool suc = LittleFS.begin();
  beginned=1;
  Serial.println("filesystem inicialize: "+String(suc));
}

   Serial.println("ssid and pass config...");
   SSIDiot=readFile("/ssid.txt");
   PASS=readFile("/pass.txt");
   Serial.println("wifidatas updatet from files...");


  //Példány beállítások
  display.setRotation(1);  //képernyő tájolása
  display.init();
  // dht.begin();

  Serial.println("display and dhtz config success...");



  Serial.println("SSID,PASS: "+SSIDiot+PASS);

  WiFi.mode(WIFI_STA);

  iotconfig();


  //Induláskor meghívandó függvények
  // reftime = ArduinoCloud.getInternalTime();//iotconfig után
  // eeprRead();//EEPROM adatok betöltése
  // onlineCheck();// eszköz csatlakozik-e az internethez
  // updateScreen();//Képernyő frissítése
  attachInterrupt (digitalPinToInterrupt(InterruptPin), read_encoder, RISING);
  Serial.println("setup ended.");
}


void loop() {
  if(normal==0){

    if(millis()<30000 &&SSIDiot!=""){
      firstStep=0;
    }else{
      secondStep=1;
      firstStep=1;
    }

    if(firstStep==0){
      Serial.print("Check... ");
      switch(ArduinoCloud.getConnection()->getStatus()){
        case NetworkConnectionState::INIT: Serial.println("INIT");break;
        case NetworkConnectionState::CONNECTING: Serial.println("CONNECTING");break;
        case NetworkConnectionState::CONNECTED: Serial.println("CONNECTED");break;
        case NetworkConnectionState::DISCONNECTING: Serial.println("DISCONNECTING");break;
        case NetworkConnectionState::DISCONNECTED: Serial.println("DISCONNECTED"); break;
        case NetworkConnectionState::ERROR:   Serial.println("ERROR"); break;
        default:  Serial.println("dontknow"); break;
      }
      if(ArduinoCloud.getConnection()->getStatus()==NetworkConnectionState::CONNECTED ){
        normal=1;
      }
      
      ArduinoCloud.update();
    }

    if(secondStep==1){
    if(ArduinoCloud.getConnection()->getStatus()!=NetworkConnectionState::CONNECTED){
        lastSSID = SSIDiot;
        SSIDiot = readFile("/ssid.txt");
        if(apon==0){
          ArduinoCloud.getConnection()->disconnect();
          firstStep=1;
          Serial.println("Make AP");
          configAP();
          apon=1;
        }
      }
    }
    if(apon==1){
      if(eeprssid!=lastSSID){
        WiFi.disconnect();
        ESP.restart();
      }
    }
  }
//
//normal futás, amennyiben nem szükséges a konfiguráció
  if(normal==1){
    if (millis() - millisToTime >= 1728000 && online == 0) { //EEPROM írása kb. fél óránként (hiba nélküli termesztés során 100 írás történik)
      eeprWrite();
    }

    if (millis() - onlinecheckTime >= 1000) {// Másodpercenkénti képernyő, és pontos idő frissítés
      onlineCheck();
      updateScreen();
      calcLine();
      dayCalc();
      onlinecheckTime = millis();
      messages=String(humSatus);
    }

    if (millis() - ledStateTime >= 10000) {//5 másodpercenkénti LED check, amennyiben szükséges beállít
      ledAuto();
      ledStateTime = millis();
      sensorRead();
    }

    if (lastVolume != Volume) {//Encoder változásának érzékelése
      encoder();
    }
    lastVolume = Volume;

    if (millis() - legcsereTime >= 1800000) { //Fél óránkénti légcsere
      legcsereOn = 1;
    }

    //online értékek frissítése
    legcsere();
    if(paraSzenzorOff==0){paraCheck();}else{paraAuto();}
    ArduinoCloud.update();

    if(humSatus==1){
      analogWrite(12,255);
    }else{
      analogWrite(12,0);
    }
  }
}





void paraAuto(){
 if (millis()-paraAutoTime > paraPeriod) {
    paraAutoTime = millis();
    paraAutoTimeOn = millis();
    analogWrite(humPin, 255);
  }

if (millis() - paraAutoTime > paraCiklus) {
    analogWrite(humPin, 0);
  }
}

/**
  Aszükséges változókat a Flash memóriába írja
*/
void eeprWrite() {
  EEPROM_writelong(0, now());
  EEPROM_writelong(1, loadlineState);
  EEPROM_writelong(2, daynum);
  millisToTime = millis();
}

void eeprRead() {
  setTime(EEPROM_readlong(0));
  loadlineState = EEPROM_readlong(1);
  daynum = EEPROM_readlong(2);
  growStartTime = String(EEPROM_readlong(3));
}

/**
  Amennyiben a rotary encodert forgatjuk, a LED fényerő változik, ennek állításáért felelős függvény
*/
void encoder() {
  voltime = millis();
  while (millis() - voltime < 5000) {
    show_encoder();
    if (Volume > 99) {
      Volume = 100;
    } if (Volume < 1) {
      Volume = 0;
    }
    analogWrite(lightPin, int(Volume * 2.55));
    changeLightScreen();
    if (lastVolume != Volume) {
      voltime = millis();
    }
    lastVolume = Volume;
  }
  Volume = 0;
  onlineCheck();
  updateScreen();
}

/**
  A világítás állítására szolgáló függvény, meghíváskor ellenőrzi, hogy a lokális idő szerint
  szükséges-e a lámpa állapotának változtatása
*/
void ledAuto() {
  if(online=1){
    int loctime = hour() + timezone;
    if (loctime >= lightOnTime && loctime <= lightOffTime) {
      digitalWrite(lightPin, 1);
      switchh=1;
      fenyero=255;

    }
    else {
      digitalWrite(lightPin, 0);
      switchh=0;
      fenyero=0;
    }
  }else{
    digitalWrite(lightPin, 1);
    switchh=1;
    fenyero=255;

  }
}

/**
  A termesztés állpotát mutató változó
*/
void calcLine() { //10nap=864000sec egy pixel szélesedés:4547, max 190
  long secs = unixtime - growStartTime.toInt();
  loadlineState = int(secs / 5000);
}

/**
  Meghíváskor ellenőrzi a páratartalmat, és ha alacsony fél percig párásít
*/
void paraCheck() {
  if (humwifi <= celPara) {
    analogWrite(humPin, 255);
  }else{
    analogWrite(humPin, 0);
  }
}

/**
  Meghíváskor a levegő cseréjét végzi el, ezt fél óránként egy percnyi működéssel végzi
*/
void legcsere() {
  if (legcsereOn == 1) {
    legcsereTimeOn = millis();
    analogWrite(fanPin, fanSpeed);
    legcsereOn = 0;
    legcsereTime = millis();
  }
  else if (millis() - legcsereTimeOn > 60000) {
    analogWrite(fanPin, 0);
    fanStatus=0;
  }
}

/**
  A függvény ellenőrzi, hogy a vezérlő online van-e, és frissíti az időt.
  Amennyiben a termesztés még nem kezdődött el, beállítja a termelés kezdőidőpontját
*/
void onlineCheck() {
  lastOnline = online;
  if (ArduinoCloud.getInternalTime() > reftime) {
    online = 1;
    if (growStartTime == "0") {
      growStartTime = String(unixtime);
      EEPROM_writelong(3, unixtime);
      eeprWrite();
      unixtime = ArduinoCloud.getInternalTime();
      setTime(unixtime);
    }

  } else {
    online = 0;
  }
  if (lastOnline != online) {
    eeprWrite();
  }
}

/**
  Az arduino IoT Cloud működéséhez szükséges beállításokat végzi el
*/
void iotconfig() {
  initProperties();
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);
  setDebugMessageLevel(2);
  ArduinoCloud.printDebugInfo();
  // return ArduinoIoTPreferredConnection;
}

/**
  A fényerő módosításokor megjelenő képernyő
*/
void changeLightScreen() {
  display.setPartialWindow(0, 0 , 296, 128);
  display.fillScreen(GxEPD_WHITE);

  display.setCursor(118, 50);
  display.drawInvertedBitmap(118, 10, light, 60, 60, GxEPD_BLACK);

  display.setFont(&FreeSansBold9pt7b);
  if (Volume < 10) {
    display.setCursor(138, 100);
    display.print(String(Volume) + "%");
  }
  if (Volume > 10 && Volume < 100) {
    display.setCursor(136, 100);
    display.print(String(Volume) + "%");
  }
  if (Volume == 100) {
    display.setCursor(130, 100);
    display.print(String(Volume) + "%");
  }

  while (display.nextPage());
}

/**
  A képernyő másodpercenkénti frissítését végzi, itt az összes állapotjelző (hőmérséklet, stb) frissül
*/
void updateScreen() {
  growpoint++;
  if (growpoint > 3) {
    growpoint = 0;
  }
  if (daynum > 10) {
    growpoint = 4;
    daynum = 11;
  }
  if (daynum == 0) {
    daynum = 1;
  }
  display.setPartialWindow(0, 0 , 296, 128);
  display.fillScreen(GxEPD_WHITE);
  display.setTextColor(GxEPD_BLACK);

  display.setFont(&FreeSans9pt7b);
  display.setCursor(85, 17);
  display.print("Did you know?");

  display.setFont(&FreeSansBold9pt7b);
  display.setCursor(cors[daynum - 1][0], 50);
  display.print(didu[daynum - 1][0]);

  display.setCursor(cors[daynum - 1][1], 70);
  display.print(didu[daynum - 1][1]);

  display.setCursor(0, 0);
  display.drawInvertedBitmap(0, 0, loadingline, 296, 128, GxEPD_BLACK);
  if (online == 1) {
    display.drawInvertedBitmap(0, 0, onwifi, 30, 26, GxEPD_BLACK);
  } if (online == 0) {
    display.drawInvertedBitmap(0, 0, offwifi, 30, 24, GxEPD_BLACK);
  }

  if (growpoint == 0) {
    display.setFont(&FreeSans9pt7b);
    display.setCursor(10, 100);
    display.print("Growing in progress");
  }
  if (growpoint == 1) {
    display.setFont(&FreeSans9pt7b);
    display.setCursor(10, 100);
    display.print("Growing in progress.");
  }
  if (growpoint == 2) {
    display.setFont(&FreeSans9pt7b);
    display.setCursor(10, 100);
    display.print("Growing in progress..");
  }
  if (growpoint == 3) {
    display.setFont(&FreeSans9pt7b);
    display.setCursor(10, 100);
    display.print("Growing in progress...");
  }
  if (growpoint == 4) {
    display.setFont(&FreeSans9pt7b);
    display.setCursor(10, 100);
    display.print("Enjoy your harvest!");
  }
  display.setCursor(235, 100);
  display.print("Temp");

  display.setFont(&FreeSansBold9pt7b);
  display.setCursor(237, 120);
  display.print(homerseklet);
  if (millis() > 30000 && loadlineState < 190) {
    display.fillRect(10, 110, loadlineState, 10, GxEPD_BLACK);
  }
  while (display.nextPage());
}

void dayCalc() {
  if (growStartTime != "") {
    daynum = int((now() - growStartTime.toInt()) / 86400);
    if (daynum > 11) {
      daynum = 11;
    }
  }
}

/**
  Szenzorértékek olvasása, előző  óta nem változott
*/
void sensorRead()
{
  // para = dht.readHumidity();
  // humwifi = para;
  // homerseklet =(dht.readTemperature()*1.8)+32;
  // tempwifi = homerseklet;
}

void read_encoder(){                                                                                  // Interrupt Service Routine (ISR) to read the encoder functions
  Result = (' ');                                                                                    // Clear the old result, let's see if we can get a new one
  ReadValue = (analogRead(AnalogInput) + analogRead(AnalogInput) + analogRead(AnalogInput)) / 3;     // Read the average value from the Analog Input A0
  if ( ReadValue >  590 && ReadValue <  660 )   Result = ('M');
  if ( ReadValue >  695 && ReadValue <  760 )   Result = ('U');                                      // So, P=581-620, and then U=651-740, and then D=771-860
  if ( ReadValue >  870 && ReadValue <  940 )   Result = ('D');                                      // The 'window' values depend on the resistors used, and
  if ( Result == (' ') ) ReadValue = 0;
  show_encoder();
}

void show_encoder()
{
  if ( ReadValue != 0 ) 
  {
    if (Result == 'U') Volume = Volume + 1;
    if (Result == 'D') Volume = Volume - 1;
    ReadValue = 0;
  }
}

/**
  A cloudban módosított értékek felhasználása. Ezek a függvények kerülnek automatikus meghívásra az állapotváltozás esetén.
*/
void onSwitchhChange()  {
  // Add your code here to act upon Switchh change
  if (switchh == true)
  {
    digitalWrite(lightPin, HIGH);
    fenyero=255;
    ledStateTime = millis();
  }
  else
  {
    digitalWrite(lightPin, LOW);
    ledStateTime = millis();
    fenyero=0;
  }
}

void onFenyeroChange()  {
  analogWrite(lightPin, fenyero);
  ledStateTime = millis();
  if(fenyero!=0){
    switchh=1;
  }else{switchh=0;}
}

/**
  Since HumSatus is READ_WRITE variable, onHumSatusChange() is
  executed every time a new value is received from IoT Cloud.
*/
void onHumSatusChange(){

}


/**
Ha a switchet a dashboardon bekapcsoljuk működik, amíg ki nem kapcsoljuk vagy fél perc el nem telik.
Ha a fél perc nem telik el, a rendszeres légfrissítésbe nem számít bele.
*/
void onFanStatusChange()  {
  // Add your code here to act upon FanStatus change
  if (fanStatus == true)
  {
    legcsereTimeOn = millis();
    analogWrite(fanPin, fanSpeed);
    legcsereOn = 0;
  }else{
    analogWrite(fanPin, 0);
  }

}



/**
onChange függvények, többsége használatlan, de szükséges definiálni
*/
void onTimestepChange()  {
}
void onLastUpdateUnixChange() {
}
void onNowChange()  {
}
void onGrowStartTimeChange() {
}
void onMessagesChange() {
}
void onTimezoneChange() {
}

unsigned long EEPROM_readlong(int address)
{
  //use word read function for reading upper part
  unsigned long dword = EEPROM_readint(address);
  //shift read word up
  dword = dword << 16;
  // read lower word from EEPROM and OR it into double word
  dword = dword | EEPROM_readint(address + 2);
  return dword;
}

/*
  Long és int értékek EEPROMban való tárolásához
*/
void EEPROM_writelong(int address, unsigned long value)
{
  EEPROM_writeint(address + 2, word(value));
  value = value >> 16;
  EEPROM_writeint(address, word(value));
}
unsigned int EEPROM_readint(int address)
{
  unsigned int word = word(EEPROM.read(address), EEPROM.read(address + 1));
  return word;
}
void EEPROM_writeint(int address, int value)
{
  EEPROM.write(address, highByte(value));
  EEPROM.write(address + 1 , lowByte(value));
}


//Hálózat létrehozása és wifi jelszó bekérése
void configAP(){

  Serial.println("AP creating...");
  WiFi.mode(WIFI_AP);
  WiFi.softAP("ESPap");

  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
      request->send_P(200, "text/html", index_html, processor);
    });
  server.on("/get", HTTP_GET, [] (AsyncWebServerRequest *request) {
    String pp;
    String ss;
    if (request->hasParam(ssidHTML)&&request->hasParam(passHTML)) {
      pp = request->getParam(passHTML)->value();
      ss = request->getParam(ssidHTML)->value();

      writeFile("/ssid.txt",ss);
      writeFile("/pass.txt",pp);
    }
    else {
      pp = ss = "No message sent";
    }
    request->send(200, "text/text", pp+", "+ss);
  });
    server.begin();

    Serial.println("AP and server created.");

}

  
String processor(const String& var){
  if(var == "inputSSID"){
    return readFile("/ssid.txt");
  }
  else if(var == "inputPASS"){
    if(readFile("/pass.txt")!=""){
      return "*********";
    }
    else{
      return "";
    }
  }
    return String();
}

void onCelParaChange(){}
void onFanSpeedChange(){}
void onLightOffTimeChange(){}
void onLightOnTimeChange(){}
void onParaCiklusChange(){}
void onParaPeriodChange(){}
void onParaSzenzorOffChange(){}

void initProperties(){

  ArduinoCloud.setBoardId(DEVICE_LOGIN_NAME);
  ArduinoCloud.setSecretDeviceKey(DEVICE_KEY);
  ArduinoCloud.addProperty(growStartTime, READWRITE, ON_CHANGE, onGrowStartTimeChange);
  ArduinoCloud.addProperty(messages, READWRITE, ON_CHANGE, onMessagesChange);
  ArduinoCloud.addProperty(tempwifi, READ, ON_CHANGE, NULL);
  ArduinoCloud.addProperty(celPara, READWRITE, ON_CHANGE, onCelParaChange);
  ArduinoCloud.addProperty(fanSpeed, READWRITE, ON_CHANGE, onFanSpeedChange);
  ArduinoCloud.addProperty(fenyero, READWRITE, ON_CHANGE, onFenyeroChange);
  ArduinoCloud.addProperty(lightOffTime, READWRITE, ON_CHANGE, onLightOffTimeChange);
  ArduinoCloud.addProperty(lightOnTime, READWRITE, ON_CHANGE, onLightOnTimeChange);
  ArduinoCloud.addProperty(paraCiklus, READWRITE, ON_CHANGE, onParaCiklusChange);
  ArduinoCloud.addProperty(paraPeriod, READWRITE, ON_CHANGE, onParaPeriodChange);
  ArduinoCloud.addProperty(timezone, READWRITE, ON_CHANGE, onTimezoneChange);
  ArduinoCloud.addProperty(humwifi, READ, ON_CHANGE, NULL);
  ArduinoCloud.addProperty(fanStatus, READWRITE, ON_CHANGE, onFanStatusChange);
  ArduinoCloud.addProperty(humSatus, READWRITE, ON_CHANGE, onHumSatusChange);
  ArduinoCloud.addProperty(paraSzenzorOff, READWRITE, ON_CHANGE, onParaSzenzorOffChange);
  ArduinoCloud.addProperty(switchh, READWRITE, ON_CHANGE, onSwitchhChange);
}

Answer 1

您的代码定义了此全局变量：

WiFiConnectionHandler ArduinoIoTPreferredConnection(readFile("/ssid.txt").c_str(), readFile("/pass.txt").c_str()); //Here is the problem

构造函数将在调用setup（）之前调用，这意味着尚未初始化文件系统。因此，调用readfile（）无法成功。

您有几个选择：

• 的配置移至begin（）
• 将wificonnectionhandler 不是全局或静态的变量 - 在这种情况下，您必须谨慎管理对象的生命周期（如果将其放入setup（）中，则将在setup时被销毁（）返回）
• 重写readfile（）注意到文件系统尚未初始化，并在这种情况下初始化它