File Systems on ESP32 (SPIFFS & LittleFS)

#include <LittleFS.h>

void setup() {
  Serial.begin(115200);
  delay(1000);

  // Mount LittleFS (true = format if mount fails, e.g. first use)
  if (!LittleFS.begin(true)) {
    Serial.println("Failed to mount LittleFS");
    return;
  }
  Serial.println("LittleFS mounted successfully");

  // --- Write a file ---
  Serial.println("\n--- Writing file ---");
  File fileW = LittleFS.open("/config.txt", "w");  // "w" = write (overwrites)
  if (!fileW) {
    Serial.println("Failed to open file for writing");
    return;
  }
  fileW.println("ssid=MyNetwork");
  fileW.println("password=Secret123");
  fileW.close();
  Serial.println("File written");

  // --- Read a file ---
  Serial.println("\n--- Reading file ---");
  File fileR = LittleFS.open("/config.txt", "r");  // "r" = read
  if (!fileR) {
    Serial.println("Failed to open file for reading");
    return;
  }
  while (fileR.available()) {
    String line = fileR.readStringUntil('\n');
    Serial.println(line);
  }
  fileR.close();

  // --- Append to a file ---
  Serial.println("\n--- Appending to file ---");
  File fileA = LittleFS.open("/config.txt", "a");  // "a" = append
  if (!fileA) {
    Serial.println("Failed to open file for appending");
    return;
  }
  fileA.println("mqtt_broker=192.168.1.100");
  fileA.close();
  Serial.println("Line appended");

  // --- Check if a file exists ---
  if (LittleFS.exists("/config.txt")) {
    Serial.println("\n/config.txt exists");
  }

  // --- List directory contents ---
  Serial.println("\n--- Listing root directory ---");
  File root = LittleFS.open("/");
  File entry = root.openNextFile();
  while (entry) {
    Serial.printf("  %s  (%d bytes)\n", entry.name(), entry.size());
    entry = root.openNextFile();
  }
  root.close();

  // --- Delete a file ---
  Serial.println("\n--- Deleting file ---");
  if (LittleFS.remove("/config.txt")) {
    Serial.println("/config.txt deleted");
  } else {
    Serial.println("Delete failed");
  }

  // Verify it is gone
  if (!LittleFS.exists("/config.txt")) {
    Serial.println("/config.txt no longer exists");
  }
}

void loop() {
  // Nothing here
}

#include <LittleFS.h>
#include <ArduinoJson.h>

const char* CONFIG_FILE = "/config.json";

// Load configuration from file. Returns true if successful.
bool loadConfig(char* ssid, char* password, char* mqttBroker) {
  File file = LittleFS.open(CONFIG_FILE, "r");
  if (!file) {
    Serial.println("Config file not found");
    return false;
  }

  JsonDocument doc;
  DeserializationError error = deserializeJson(doc, file);
  file.close();

  if (error) {
    Serial.printf("Failed to parse config: %s\n", error.c_str());
    return false;
  }

  strlcpy(ssid, doc["ssid"] | "default_ssid", 32);
  strlcpy(password, doc["password"] | "", 64);
  strlcpy(mqttBroker, doc["mqtt_broker"] | "192.168.1.1", 64);

  return true;
}

// Save configuration to file. Returns true if successful.
bool saveConfig(const char* ssid, const char* password,
                const char* mqttBroker) {
  JsonDocument doc;
  doc["ssid"] = ssid;
  doc["password"] = password;
  doc["mqtt_broker"] = mqttBroker;

  File file = LittleFS.open(CONFIG_FILE, "w");
  if (!file) {
    Serial.println("Failed to open config file for writing");
    return false;
  }

  serializeJsonPretty(doc, file);
  file.close();
  return true;
}

void setup() {
  Serial.begin(115200);
  delay(1000);

  if (!LittleFS.begin(true)) {
    Serial.println("Failed to mount LittleFS");
    return;
  }

  char ssid[32];
  char password[64];
  char mqttBroker[64];

  // Try to load existing config
  if (loadConfig(ssid, password, mqttBroker)) {
    Serial.println("Configuration loaded:");
    Serial.printf("  SSID: %s\n", ssid);
    Serial.printf("  Password: %s\n", password);
    Serial.printf("  MQTT Broker: %s\n", mqttBroker);
  } else {
    // No config found -- save defaults
    Serial.println("No config found, saving defaults...");
    saveConfig("MyNetwork", "MyPassword", "192.168.1.100");
    Serial.println("Default config saved. Restart to load it.");
  }
}

void loop() {
  // Your main application code here
}

#include <LittleFS.h>

const char* LOG_FILE = "/sensor_log.csv";
const int BUFFER_SIZE = 10;           // Flush after this many readings
const unsigned long READ_INTERVAL = 5000;  // Read every 5 seconds

float readingBuffer[BUFFER_SIZE];
unsigned long timestampBuffer[BUFFER_SIZE];
int bufferIndex = 0;
unsigned long lastReadTime = 0;

// Simulate a sensor reading (replace with real sensor code)
float readSensor() {
  return 20.0 + random(-50, 50) / 10.0;  // 15.0 to 25.0
}

// Flush buffered readings to flash
void flushBuffer() {
  File file = LittleFS.open(LOG_FILE, "a");
  if (!file) {
    Serial.println("Failed to open log file");
    return;
  }

  for (int i = 0; i < bufferIndex; i++) {
    file.printf("%lu,%.1f\n", timestampBuffer[i], readingBuffer[i]);
  }

  file.close();
  Serial.printf("Flushed %d readings to flash\n", bufferIndex);
  bufferIndex = 0;
}

// Print the entire log file to Serial
void printLog() {
  File file = LittleFS.open(LOG_FILE, "r");
  if (!file) {
    Serial.println("No log file found");
    return;
  }

  Serial.println("\n--- Sensor Log (timestamp_s, temperature_C) ---");
  while (file.available()) {
    Serial.println(file.readStringUntil('\n'));
  }
  Serial.printf("--- End of log (%d bytes) ---\n", file.size());
  file.close();
}

void setup() {
  Serial.begin(115200);
  delay(1000);

  if (!LittleFS.begin(true)) {
    Serial.println("Failed to mount LittleFS");
    return;
  }
  Serial.println("LittleFS mounted");

  // Write CSV header if file does not exist
  if (!LittleFS.exists(LOG_FILE)) {
    File file = LittleFS.open(LOG_FILE, "w");
    file.println("timestamp_s,temperature_C");
    file.close();
    Serial.println("Created new log file with header");
  }

  // Print any existing log data
  printLog();

  Serial.println("\nLogging started. Send 'p' via Serial to print log.");
  bootTime = millis();
}

void loop() {
  unsigned long now = millis();

  // Take a reading at the configured interval
  if (now - lastReadTime >= READ_INTERVAL) {
    lastReadTime = now;
    readingBuffer[bufferIndex] = readSensor();
    timestampBuffer[bufferIndex] = millis() / 1000;  // Seconds since boot
    Serial.printf("Reading %d: %.1f C\n", bufferIndex, readingBuffer[bufferIndex]);
    bufferIndex++;

    // Flush buffer when full
    if (bufferIndex >= BUFFER_SIZE) {
      flushBuffer();
    }
  }

  // Print log on serial command
  if (Serial.available()) {
    char c = Serial.read();
    if (c == 'p' || c == 'P') {
      if (bufferIndex > 0) {
        flushBuffer();  // Write any buffered data first
      }
      printLog();
    }
  }
}