ESP8266 - SPIFSS/json

Moin,

ich möchte eine eigene Klasse zum Handeln meiner jsonFiles im FFS meines ESP schreiben.
Der File soll beim Start oder auf Anforderung nur einmal gelesen werden.
Um unnötige Zugriffe auf das FFS zu vermeiden, soll der Zugriff dann nur noch über das jsonObject erfolgen.
Die Klasse soll im Grunde nur einzelne Elemente aus dem File lesen und auch wieder zurück schreiben können ohne, dass ich mich um das Handling des FFS weiter kümmern muss.

Die jsonFiles sollen nur eine Ebene enthalten, eine tiefere Struktur muss nicht behandelt werden.

Das lesen der einzelnen Elemente läuft problemlos.
Probleme habe ich beim zurückschreiben des jsonObjektes in das FFS.

cfg.writeItem(“wifiSSID”, “HelloWorld!”);

Nach einem Reset ist der File im FSS leer.
Hat jemand eine Idee wo ich den Fehler mache?

Gruß
Pf@nne

config.json

{
  "webUser":        "ESPuser",
  "webPassword":    "ESPpass",
  "apName":         "ESP8266_1032096",
  "apPassword":     "ESP8266config",
  "wifiSSID":       "Pf@nne-NET",
  "wifiPSK":        "xxxxx",
  "wifiIP":         "",
  "mqttServer":     "192.168.1.203",
  "mqttPort":       "1883",
  "mqttDeviceName": "ESP8266_1032096",
  "updateServer":   "192.168.1.3",
  "filePath":       "/bin/ESP8266_AktSen.ino.bin"
}

FSS.h

#pragma once
//FileSystem
  #include <FS.h>                     //this needs to be first, or it all crashes and burns...
  #include <ArduinoJson.h>
  #include <Arduino.h>
  #include "Setup.h"
  #include "I2C.h"
 
//===============================================================================
//  jsonFile
//===============================================================================
class FFSjsonFile{
public:  
  FFSjsonFile(String filePath, int type);
  String filePath;
  size_t size;                               //filled in readJsonString()
  int type;                                  //0=Object; 1=Array
  String root;
 
  String readItem(String itemName);
  String readItem(int item);
  void writeItem(String itemName, String value);

private: 
  String readJsonString();
  DynamicJsonBuffer JsonBuffer;
  JsonObject& jsonRootObject;
  JsonArray& jsonRootArray;

  void parseJsonObject(JsonObject& jsonObject);
  void parseJsonArray(JsonArray& jsonArray);
};
 

//===============================================================================
//  FFS 
//===============================================================================
class FFS{
public:
  FFS(I2C& i2c);
  I2C& i2c;
  
  FFSjsonFile cfg;
  FFSjsonFile testArray;

  void TEST();  
  
private:
};

FSS.cpp

#include "FFS.h"

//===============================================================================
//  FFS 
//===============================================================================
FFS::FFS(I2C& i2c):
    i2c(i2c),
    cfg(CFG_PATH, TYPE_OBJECT),
    testArray(TESTARRAY_PATH, TYPE_ARRAY){


}

//===> TEST <------------------------------------------------------
void FFS::TEST(){
  //SPIFFS.begin();

//for (int i=0; i<100; i++){ 
  //Serial.println(i); 
  Serial.println(cfg.readItem("apName"));
  Serial.println(cfg.readItem("wifiSSID"));
  Serial.println(cfg.readItem("wifiPSK"));
  Serial.println(cfg.readItem("mqttServer"));
//}  
  i2c.lcd.println(cfg.readItem("apName"), 0);
  i2c.lcd.println(cfg.readItem("wifiSSID"), 1);
  i2c.lcd.println(cfg.readItem("wifiPSK"), 2);
  //i2c.lcd.println(cfg.readItem("mqttServer"), 3);

  
  cfg.writeItem("wifiSSID", "HelloWorld!");
  i2c.lcd.println(cfg.readItem("wifiSSID"), 3);
  //Serial.println(cfg.readItem("wifiSSID"));
}
  

//===============================================================================
//  FFSjsonFile public
//===============================================================================
FFSjsonFile::FFSjsonFile(String filePath, int type) :
    filePath       (filePath),
    type           (type),
    root           (readJsonString()),
    jsonRootObject (JsonBuffer.parseObject(root)),
    jsonRootArray  (JsonBuffer.parseArray(root)){
}

//===> readItem from jsonString <-------------------------------------
String FFSjsonFile::readItem(String itemName){
  return jsonRootObject[itemName].asString();
}

String FFSjsonFile::readItem(int item){
  return jsonRootArray[item].asString(); 
}

//===> writeItem to jsonString <---------------------------------------
void FFSjsonFile::writeItem(String itemName, String value){
  jsonRootObject[itemName] = value;

  //SPIFFS.begin();
  File jsonFile = SPIFFS.open(filePath, "w");
  if (!jsonFile) {
    Serial.println("failed to open File for writing");
    //Serial.print("format file System.. ");
    //SPIFFS.format();
  }

  jsonRootObject.printTo(Serial);
  jsonRootObject.printTo(jsonFile);
  jsonFile.close(); 
}

//  FFSjsonFile private 
//===============================================================================

//===> Read json String from File <------------------------------------
String FFSjsonFile::readJsonString(){    
  File jsonFile;
  String jsonData = "NIL";
 
  if (SPIFFS.begin()) {
    Serial.println("mounted file system...OK");
    if (SPIFFS.exists(filePath)) {
      jsonFile = SPIFFS.open(filePath, "r");
      if (jsonFile) {
        size = jsonFile.size();
        std::unique_ptr<char[]> buf(new char[size]);

        jsonFile.readBytes(buf.get(), size);
        if (type == TYPE_ARRAY){
        //Array 
          DynamicJsonBuffer _jsonBufferArray;
          JsonArray& jsonArray = _jsonBufferArray.parseArray(buf.get());             
          if (jsonArray.success()) {
            char buffer[size];
            jsonArray.printTo(buffer, sizeof(buffer));
            jsonData = String(buffer); 
          }
        }else{
        //Object
          DynamicJsonBuffer _jsonBuffer;
          JsonObject& json = _jsonBuffer.parseObject(buf.get());
          if (json.success()) {         
            char buffer[size];
            json.printTo(buffer, sizeof(buffer));
            jsonData = String(buffer);
          }
        }
      }
    }
  }
  jsonFile.close();
  return jsonData;  
}

//#########################################################################################

void FFSjsonFile::parseJsonObject(JsonObject& jsonObject){
  //Serial.println("parseJsonObject");
  for (auto &element : jsonObject){
    String strKey = element.key;
    String strValue = element.value;
    Serial.print(strKey);Serial.print("      ");Serial.println(strValue);
  }
}

void FFSjsonFile::parseJsonArray(JsonArray& jsonArray){
  for (auto &element : jsonArray){
    if (element.is<JsonArray&>()){
      Serial.println("-->>");//Serial.println(i);
      JsonArray& nestedArray = element;
      parseJsonArray(nestedArray);
    }else{
      Serial.println(element.asString()); //Serial.print(" | ");Serial.println(i);
    }
  }
}