Problem converting a sketch from SPIFFS to LittleFS - no matching function for call error

Question

I'm playing with a tutorial from this DroneBot Workshop YouTube (excellent video presentation by the way on WiFi manager for newbies). I am working with a NodeMCU ESP8266.

The example code was written for SPIFFS. If I use the LittleFS library instead, and whether I define SPIFFS to LittleFS at the start or manually replace all references to SPIFFS with LittleFS, this line will not compile:

if (LittleFS.begin(false) || LittleFS.begin(true))

It gives this error message:

no matching function for call to 'fs::FS::begin(bool)'

Any suggestions as to what I'm missing or need to change?

His original example code which won't compile is below. I'm guessing I'm missing something simple but I'mnot sure what.

I probably should have added that I have commented out the include SPIFFS, added include LittleFS.H

I still have FS.h included in libraries and not sure if that is contributing to the issue. Is there an equivalent replacement for FS.h that comes about with LitteFS that I should be including?

/*
 WiFiManager with saved textboxes Demo
 wfm-text-save-demo.ino
 Saves data in JSON file on ESP32
 Uses SPIFFS
 DroneBot Workshop 2022
 https://dronebotworkshop.com
 Functions based upon sketch by Brian Lough
 https://github.com/witnessmenow/ESP32-WiFi-Manager-Examples
*/
#define ESP_DRD_USE_SPIFFS true
// Include Libraries
// WiFi Library
#include <WiFi.h>
// File System Library
#include <FS.h>
// SPI Flash Syetem Library
#include <SPIFFS.h>
// WiFiManager Library
#include <WiFiManager.h>
// Arduino JSON library
#include <ArduinoJson.h>
// JSON configuration file
#define JSON_CONFIG_FILE "/test_config.json"
// Flag for saving data
bool shouldSaveConfig = false;
// Variables to hold data from custom textboxes
char testString[50] = "test value";
int testNumber = 1234;
// Define WiFiManager Object
WiFiManager wm;
void saveConfigFile()
// Save Config in JSON format
{
 Serial.println(F("Saving configuration..."));
 
 // Create a JSON document
 StaticJsonDocument<512> json;
 json["testString"] = testString;
 json["testNumber"] = testNumber;
 // Open config file
 File configFile = SPIFFS.open(JSON_CONFIG_FILE, "w");
 if (!configFile)
 {
 // Error, file did not open
 Serial.println("failed to open config file for writing");
 }
 // Serialize JSON data to write to file
 serializeJsonPretty(json, Serial);
 if (serializeJson(json, configFile) == 0)
 {
 // Error writing file
 Serial.println(F("Failed to write to file"));
 }
 // Close file
 configFile.close();
}
bool loadConfigFile()
// Load existing configuration file
{
 // Uncomment if we need to format filesystem
 // SPIFFS.format();
 // Read configuration from FS json
 Serial.println("Mounting File System...");
 // May need to make it begin(true) first time you are using SPIFFS
 if (SPIFFS.begin(false) || SPIFFS.begin(true))
 {
 Serial.println("mounted file system");
 if (SPIFFS.exists(JSON_CONFIG_FILE))
 {
 // The file exists, reading and loading
 Serial.println("reading config file");
 File configFile = SPIFFS.open(JSON_CONFIG_FILE, "r");
 if (configFile)
 {
 Serial.println("Opened configuration file");
 StaticJsonDocument<512> json;
 DeserializationError error = deserializeJson(json, configFile);
 serializeJsonPretty(json, Serial);
 if (!error)
 {
 Serial.println("Parsing JSON");
 strcpy(testString, json["testString"]);
 testNumber = json["testNumber"].as<int>();
 return true;
 }
 else
 {
 // Error loading JSON data
 Serial.println("Failed to load json config");
 }
 }
 }
 }
 else
 {
 // Error mounting file system
 Serial.println("Failed to mount FS");
 }
 return false;
}
void saveConfigCallback()
// Callback notifying us of the need to save configuration
{
 Serial.println("Should save config");
 shouldSaveConfig = true;
}
void configModeCallback(WiFiManager *myWiFiManager)
// Called when config mode launched
{
 Serial.println("Entered Configuration Mode");
 Serial.print("Config SSID: ");
 Serial.println(myWiFiManager->getConfigPortalSSID());
 Serial.print("Config IP Address: ");
 Serial.println(WiFi.softAPIP());
}
void setup()
{
 // Change to true when testing to force configuration every time we run
 bool forceConfig = false;
 bool spiffsSetup = loadConfigFile();
 if (!spiffsSetup)
 {
 Serial.println(F("Forcing config mode as there is no saved config"));
 forceConfig = true;
 }
 // Explicitly set WiFi mode
 WiFi.mode(WIFI_STA);
 // Setup Serial monitor
 Serial.begin(115200);
 delay(10);
 // Reset settings (only for development)
 wm.resetSettings();
 // Set config save notify callback
 wm.setSaveConfigCallback(saveConfigCallback);
 // Set callback that gets called when connecting to previous WiFi fails, and enters Access Point mode
 wm.setAPCallback(configModeCallback);
 // Custom elements
 // Text box (String) - 50 characters maximum
 WiFiManagerParameter custom_text_box("key_text", "Enter your string here", testString, 50);
 
 // Need to convert numerical input to string to display the default value.
 char convertedValue[6];
 sprintf(convertedValue, "%d", testNumber); 
 
 // Text box (Number) - 7 characters maximum
 WiFiManagerParameter custom_text_box_num("key_num", "Enter your number here", convertedValue, 7); 
 // Add all defined parameters
 wm.addParameter(&custom_text_box);
 wm.addParameter(&custom_text_box_num);
 if (forceConfig)
 // Run if we need a configuration
 {
 if (!wm.startConfigPortal("NEWTEST_AP", "password"))
 {
 Serial.println("failed to connect and hit timeout");
 delay(3000);
 //reset and try again, or maybe put it to deep sleep
 ESP.restart();
 delay(5000);
 }
 }
 else
 {
 if (!wm.autoConnect("NEWTEST_AP", "password"))
 {
 Serial.println("failed to connect and hit timeout");
 delay(3000);
 // if we still have not connected restart and try all over again
 ESP.restart();
 delay(5000);
 }
 }
 // If we get here, we are connected to the WiFi
 Serial.println("");
 Serial.println("WiFi connected");
 Serial.print("IP address: ");
 Serial.println(WiFi.localIP());
 // Lets deal with the user config values
 // Copy the string value
 strncpy(testString, custom_text_box.getValue(), sizeof(testString));
 Serial.print("testString: ");
 Serial.println(testString);
 //Convert the number value
 testNumber = atoi(custom_text_box_num.getValue());
 Serial.print("testNumber: ");
 Serial.println(testNumber);
 // Save the custom parameters to FS
 if (shouldSaveConfig)
 {
 saveConfigFile();
 }
}
void loop() {
 // put your main code here, to run repeatedly:
}

• jsotola: have you looked at LittleFS example code?
• chrisl: The LittleFS library shows the begin function with some other parameters. That is probably, why the compiler complains about not knowing that function. There is no begin method in LittleFS with just one boolean as parameter. Please try calling the begin function like in the libraries examples

Answer 1

I encountered the same issue. I made the following changes to the code.

1. Commented out this line:

 //x if (SPIFFS.begin(false) || SPIFFS.begin(true))

2. Replaced the commented out line with this line:

 SPIFFS.begin();

3. Then commented out the "else" portion of the code in that block:

 //x else
 //x {
 //x // Error mounting file system
 //x Serial.println("Failed to mount FS");
 //x }

So basically you eliminate the true/false test and always execute the code, not really sure why you would not want execute the code anyway.

Note: I also used LittleFS to make it simple so I used the following include and define:

#include "LittleFS"
#define SPIFFS LittleFS

One final thing, I ran this on an ESP8266 mini D1 clone so I also changed the

#include <WiFi.h>

To

#include <ESP8266WiFi.h>