I’ve been reading through all the threads on how to get LittleFS up and running for the ESP32 and it seems to be a bit of a pain. Are we any closer to having official support for it on the ESP32?
I notice that the latest of the arduino-esp32 - GitHub - espressif/arduino-esp32: Arduino core for the ESP32 - now has LittleFS built into it.
This is already tracked in Add LittleFS and FFat filesystem support · Issue #570 · platformio/platform-espressif32 · GitHub, unless developers implement it in the official platforms, one can only wait or use custom modifications.
for some reason i’m getting all sorts of issues getting LittleFS to run on VSC with PlatformIO on LOLIN S3 board.
It all works fine when I compile code on Arduino IDE but not with VSC + PlatformIO.
Its driving me nuts 
Any help would be appreciated.
This is the error I get with VSC + PlatformIO (I’m using latest libraries)
My platformio.ini file =
[env:lolin_s3]
platform = espressif32
board = lolin_s3
framework = arduino
board_build.partitions = default_8MB.csv
lib_deps =
and my main.cpp is =
#include <Arduino.h>
#include "FS.h"
#include <LittleFS.h>
#define FORMAT_LITTLEFS_IF_FAILED true
void listDir(fs::FS &fs, const char *dirname, uint8_t levels)
{
Serial.printf("Listing directory: %s\r\n", dirname);
File root = fs.open(dirname);
if (!root)
{
Serial.println("- failed to open directory");
return;
}
if (!root.isDirectory())
{
Serial.println(" - not a directory");
return;
}
File file = root.openNextFile();
while (file)
{
if (file.isDirectory())
{
Serial.print(" DIR : ");
Serial.println(file.name());
if (levels)
{
listDir(fs, file.path(), levels - 1);
}
}
else
{
Serial.print(" FILE: ");
Serial.print(file.name());
Serial.print("\tSIZE: ");
Serial.println(file.size());
}
file = root.openNextFile();
}
}
void createDir(fs::FS &fs, const char *path)
{
Serial.printf("Creating Dir: %s\n", path);
if (fs.mkdir(path))
{
Serial.println("Dir created");
}
else
{
Serial.println("mkdir failed");
}
}
void removeDir(fs::FS &fs, const char *path)
{
Serial.printf("Removing Dir: %s\n", path);
if (fs.rmdir(path))
{
Serial.println("Dir removed");
}
else
{
Serial.println("rmdir failed");
}
}
void readFile(fs::FS &fs, const char *path)
{
Serial.printf("Reading file: %s\r\n", path);
File file = fs.open(path);
if (!file || file.isDirectory())
{
Serial.println("- failed to open file for reading");
return;
}
Serial.println("- read from file:");
while (file.available())
{
Serial.write(file.read());
}
file.close();
}
void writeFile(fs::FS &fs, const char *path, const char *message)
{
Serial.printf("Writing file: %s\r\n", path);
File file = fs.open(path, FILE_WRITE);
if (!file)
{
Serial.println("- failed to open file for writing");
return;
}
if (file.print(message))
{
Serial.println("- file written");
}
else
{
Serial.println("- write failed");
}
file.close();
}
void appendFile(fs::FS &fs, const char *path, const char *message)
{
Serial.printf("Appending to file: %s\r\n", path);
File file = fs.open(path, FILE_APPEND);
if (!file)
{
Serial.println("- failed to open file for appending");
return;
}
if (file.print(message))
{
Serial.println("- message appended");
}
else
{
Serial.println("- append failed");
}
file.close();
}
void renameFile(fs::FS &fs, const char *path1, const char *path2)
{
Serial.printf("Renaming file %s to %s\r\n", path1, path2);
if (fs.rename(path1, path2))
{
Serial.println("- file renamed");
}
else
{
Serial.println("- rename failed");
}
}
void deleteFile(fs::FS &fs, const char *path)
{
Serial.printf("Deleting file: %s\r\n", path);
if (fs.remove(path))
{
Serial.println("- file deleted");
}
else
{
Serial.println("- delete failed");
}
}
void writeFile2(fs::FS &fs, const char *path, const char *message)
{
if (!fs.exists(path))
{
if (strchr(path, '/'))
{
Serial.printf("Create missing folders of: %s\r\n", path);
char *pathStr = strdup(path);
if (pathStr)
{
char *ptr = strchr(pathStr, '/');
while (ptr)
{
*ptr = 0;
fs.mkdir(pathStr);
*ptr = '/';
ptr = strchr(ptr + 1, '/');
}
}
free(pathStr);
}
}
Serial.printf("Writing file to: %s\r\n", path);
File file = fs.open(path, FILE_WRITE);
if (!file)
{
Serial.println("- failed to open file for writing");
return;
}
if (file.print(message))
{
Serial.println("- file written");
}
else
{
Serial.println("- write failed");
}
file.close();
}
void deleteFile2(fs::FS &fs, const char *path)
{
Serial.printf("Deleting file and empty folders on path: %s\r\n", path);
if (fs.remove(path))
{
Serial.println("- file deleted");
}
else
{
Serial.println("- delete failed");
}
char *pathStr = strdup(path);
if (pathStr)
{
char *ptr = strrchr(pathStr, '/');
if (ptr)
{
Serial.printf("Removing all empty folders on path: %s\r\n", path);
}
while (ptr)
{
*ptr = 0;
fs.rmdir(pathStr);
ptr = strrchr(pathStr, '/');
}
free(pathStr);
}
}
void testFileIO(fs::FS &fs, const char *path)
{
Serial.printf("Testing file I/O with %s\r\n", path);
static uint8_t buf[512];
size_t len = 0;
File file = fs.open(path, FILE_WRITE);
if (!file)
{
Serial.println("- failed to open file for writing");
return;
}
size_t i;
Serial.print("- writing");
uint32_t start = millis();
for (i = 0; i < 2048; i++)
{
if ((i & 0x001F) == 0x001F)
{
Serial.print(".");
}
file.write(buf, 512);
}
Serial.println("");
uint32_t end = millis() - start;
Serial.printf(" - %u bytes written in %u ms\r\n", 2048 * 512, end);
file.close();
file = fs.open(path);
start = millis();
end = start;
i = 0;
if (file && !file.isDirectory())
{
len = file.size();
size_t flen = len;
start = millis();
Serial.print("- reading");
while (len)
{
size_t toRead = len;
if (toRead > 512)
{
toRead = 512;
}
file.read(buf, toRead);
if ((i++ & 0x001F) == 0x001F)
{
Serial.print(".");
}
len -= toRead;
}
Serial.println("");
end = millis() - start;
Serial.printf("- %u bytes read in %u ms\r\n", flen, end);
file.close();
}
else
{
Serial.println("- failed to open file for reading");
}
}
void setup()
{
// Initialize the serial port
Serial.begin(115200);
Serial.println("in setup()");
if (!LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED))
{
Serial.println("LittleFS Mount Failed");
return;
}
Serial.println("SPIFFS-like write file to new path and delete it w/folders");
writeFile2(LittleFS, "/new1/new2/new3/hello3.txt", "Hello3");
listDir(LittleFS, "/", 3);
deleteFile2(LittleFS, "/new1/new2/new3/hello3.txt");
listDir(LittleFS, "/", 3);
createDir(LittleFS, "/mydir");
writeFile(LittleFS, "/mydir/hello2.txt", "Hello2");
listDir(LittleFS, "/", 1);
deleteFile(LittleFS, "/mydir/hello2.txt");
removeDir(LittleFS, "/mydir");
listDir(LittleFS, "/", 1);
writeFile(LittleFS, "/hello.txt", "Hello ");
appendFile(LittleFS, "/hello.txt", "World!\r\n");
readFile(LittleFS, "/hello.txt");
renameFile(LittleFS, "/hello.txt", "/foo.txt");
readFile(LittleFS, "/foo.txt");
deleteFile(LittleFS, "/foo.txt");
testFileIO(LittleFS, "/test.txt");
deleteFile(LittleFS, "/test.txt");
Serial.println("Test complete");
}
void loop() {}
Please show a screenshot of your Arduino IDE “Tools” menu along with Tools->Board->Board Manager → esp32 so we can see the core version.
just for reference and a test I just also downgraded from V2.0.9 to V2.0.8 in ESP32 in Arduini IDE and it still works in Aurduino IDE when I compile and executed code.
That one’s still missing
Oof, I forgot Arduino IDE 2.0 doesn’t show the actual value of the selected setting. What’s the value of th partition scheme and flash mode?
@maxgerhardt sorry to bother you, wondering if you had a chance to have another look at this issue I am experiening (I’ve added addtional info above as requested).
If you selected this option, the Arduino IDE does
i.e. it uses ffat.csv. Weird that it doesn’t mention LittleFS, but can you set the same partition table in the platformio.ini?
That’s… what in the. The Arduino IDE LittleFS example worked with the Partition scheme set to “FATFS”?
We’ve reached the point where nothing makes even the slightest amount of sense anymore. I’ll see if I have a S3 board here and can flash it with the littlefs example…
No, I don’t have a S3 board. I only have regular ESP32 and ESP32-C3.
Can you please show a screenshot of the LittleFS sketch happily running in the Arduino serial monitor with the partition table being selected as FFat?
got me confused too… here are details:
here is Serial output:
here is code:
// #include <Arduino.h>
// #include <WiFiManager.h> // https://github.com/tzapu/WiFiManager
#include "FS.h"
#include <LittleFS.h>
/* You only need to format LittleFS the first time you run a
test or else use the LITTLEFS plugin to create a partition
https://github.com/lorol/arduino-esp32littlefs-plugin
If you test two partitions, you need to use a custom
partition.csv file, see in the sketch folder */
//WiFiManager, Local intialization. Once its business is done, there is no need to keep it around
// WiFiManager wm;
//#define TWOPART
#define FORMAT_LITTLEFS_IF_FAILED true
void listDir(fs::FS &fs, const char * dirname, uint8_t levels){
Serial.printf("Listing directory: %s\r\n", dirname);
File root = fs.open(dirname);
if(!root){
Serial.println("- failed to open directory");
return;
}
if(!root.isDirectory()){
Serial.println(" - not a directory");
return;
}
File file = root.openNextFile();
while(file){
if(file.isDirectory()){
Serial.print(" DIR : ");
Serial.println(file.name());
if(levels){
listDir(fs, file.path(), levels -1);
}
} else {
Serial.print(" FILE: ");
Serial.print(file.name());
Serial.print("\tSIZE: ");
Serial.println(file.size());
}
file = root.openNextFile();
}
}
void createDir(fs::FS &fs, const char * path){
Serial.printf("Creating Dir: %s\n", path);
if(fs.mkdir(path)){
Serial.println("Dir created");
} else {
Serial.println("mkdir failed");
}
}
void removeDir(fs::FS &fs, const char * path){
Serial.printf("Removing Dir: %s\n", path);
if(fs.rmdir(path)){
Serial.println("Dir removed");
} else {
Serial.println("rmdir failed");
}
}
void readFile(fs::FS &fs, const char * path){
Serial.printf("Reading file: %s\r\n", path);
File file = fs.open(path);
if(!file || file.isDirectory()){
Serial.println("- failed to open file for reading");
return;
}
Serial.println("- read from file:");
while(file.available()){
Serial.write(file.read());
}
file.close();
}
void writeFile(fs::FS &fs, const char * path, const char * message){
Serial.printf("Writing file: %s\r\n", path);
File file = fs.open(path, FILE_WRITE);
if(!file){
Serial.println("- failed to open file for writing");
return;
}
if(file.print(message)){
Serial.println("- file written");
} else {
Serial.println("- write failed");
}
file.close();
}
void appendFile(fs::FS &fs, const char * path, const char * message){
Serial.printf("Appending to file: %s\r\n", path);
File file = fs.open(path, FILE_APPEND);
if(!file){
Serial.println("- failed to open file for appending");
return;
}
if(file.print(message)){
Serial.println("- message appended");
} else {
Serial.println("- append failed");
}
file.close();
}
void renameFile(fs::FS &fs, const char * path1, const char * path2){
Serial.printf("Renaming file %s to %s\r\n", path1, path2);
if (fs.rename(path1, path2)) {
Serial.println("- file renamed");
} else {
Serial.println("- rename failed");
}
}
void deleteFile(fs::FS &fs, const char * path){
Serial.printf("Deleting file: %s\r\n", path);
if(fs.remove(path)){
Serial.println("- file deleted");
} else {
Serial.println("- delete failed");
}
}
// SPIFFS-like write and delete file, better use #define CONFIG_LITTLEFS_SPIFFS_COMPAT 1
void writeFile2(fs::FS &fs, const char * path, const char * message){
if(!fs.exists(path)){
if (strchr(path, '/')) {
Serial.printf("Create missing folders of: %s\r\n", path);
char *pathStr = strdup(path);
if (pathStr) {
char *ptr = strchr(pathStr, '/');
while (ptr) {
*ptr = 0;
fs.mkdir(pathStr);
*ptr = '/';
ptr = strchr(ptr+1, '/');
}
}
free(pathStr);
}
}
Serial.printf("Writing file to: %s\r\n", path);
File file = fs.open(path, FILE_WRITE);
if(!file){
Serial.println("- failed to open file for writing");
return;
}
if(file.print(message)){
Serial.println("- file written");
} else {
Serial.println("- write failed");
}
file.close();
}
void deleteFile2(fs::FS &fs, const char * path){
Serial.printf("Deleting file and empty folders on path: %s\r\n", path);
if(fs.remove(path)){
Serial.println("- file deleted");
} else {
Serial.println("- delete failed");
}
char *pathStr = strdup(path);
if (pathStr) {
char *ptr = strrchr(pathStr, '/');
if (ptr) {
Serial.printf("Removing all empty folders on path: %s\r\n", path);
}
while (ptr) {
*ptr = 0;
fs.rmdir(pathStr);
ptr = strrchr(pathStr, '/');
}
free(pathStr);
}
}
void testFileIO(fs::FS &fs, const char * path){
Serial.printf("Testing file I/O with %s\r\n", path);
static uint8_t buf[512];
size_t len = 0;
File file = fs.open(path, FILE_WRITE);
if(!file){
Serial.println("- failed to open file for writing");
return;
}
size_t i;
Serial.print("- writing" );
uint32_t start = millis();
for(i=0; i<2048; i++){
if ((i & 0x001F) == 0x001F){
Serial.print(".");
}
file.write(buf, 512);
}
Serial.println("");
uint32_t end = millis() - start;
Serial.printf(" - %u bytes written in %u ms\r\n", 2048 * 512, end);
file.close();
file = fs.open(path);
start = millis();
end = start;
i = 0;
if(file && !file.isDirectory()){
len = file.size();
size_t flen = len;
start = millis();
Serial.print("- reading" );
while(len){
size_t toRead = len;
if(toRead > 512){
toRead = 512;
}
file.read(buf, toRead);
if ((i++ & 0x001F) == 0x001F){
Serial.print(".");
}
len -= toRead;
}
Serial.println("");
end = millis() - start;
Serial.printf("- %u bytes read in %u ms\r\n", flen, end);
file.close();
} else {
Serial.println("- failed to open file for reading");
}
}
void setup(){
Serial.begin(115200);
#ifdef TWOPART
if(!LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED, "/lfs2", 5, "part2")){
Serial.println("part2 Mount Failed");
return;
}
appendFile(LittleFS, "/hello0.txt", "World0!\r\n");
readFile(LittleFS, "/hello0.txt");
LittleFS.end();
Serial.println( "Done with part2, work with the first lfs partition..." );
#endif
if(!LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED)){
Serial.println("LittleFS Mount Failed");
return;
}
Serial.println( "SPIFFS-like write file to new path and delete it w/folders" );
writeFile2(LittleFS, "/new1/new2/new3/hello3.txt", "Hello3");
listDir(LittleFS, "/", 3);
deleteFile2(LittleFS, "/new1/new2/new3/hello3.txt");
listDir(LittleFS, "/", 3);
createDir(LittleFS, "/mydir");
writeFile(LittleFS, "/mydir/hello2.txt", "Hello2");
listDir(LittleFS, "/", 1);
deleteFile(LittleFS, "/mydir/hello2.txt");
removeDir(LittleFS, "/mydir");
listDir(LittleFS, "/", 1);
writeFile(LittleFS, "/hello.txt", "Hello ");
appendFile(LittleFS, "/hello.txt", "World!\r\n");
readFile(LittleFS, "/hello.txt");
renameFile(LittleFS, "/hello.txt", "/foo.txt");
readFile(LittleFS, "/foo.txt");
deleteFile(LittleFS, "/foo.txt");
testFileIO(LittleFS, "/test.txt");
deleteFile(LittleFS, "/test.txt");
Serial.println( "Test complete" );
bool res;
// res = wm.autoConnect(); // auto generated AP name from chipid
// res = wm.autoConnect("AutoConnectAP"); // anonymous ap
// res = wm.autoConnect("AutoConnectAP","password"); // password protected ap
if(!res) {
Serial.println("Failed to connect");
// ESP.restart();
}
else {
//if you get here you have connected to the WiFi
Serial.println("connected...yeey :)");
}
}
void loop(){
}
partition table selected:
thanks for trying to help.
I hope you or someone in the community figures out an answer … i really exhausted all my knowldge on this 
@maxgerhardt what’s the current status of the LittleFS support? I’m a bit confused, since the PR is closed, but I seemingly something is not working as for ESP8266:
#if defined(ESP8266) || defined(ESP32)
File file = LittleFS.open(tmp_buffer, "r+");
if(!file) {
FSInfo fs_info;
LittleFS.info(fs_info);
// check if we are getting close to run out of space, and delete some oldest files
if(fs_info.totalBytes < fs_info.usedBytes + fs_info.blockSize * 4) {
// delete the oldest 7 files (1 week of log)
for(byte i=0;i<7;i++) delete_log_oldest();
}
file = LittleFS.open(tmp_buffer, "w");
if(!file) return;
}
file.seek(0, SeekEnd);
This give me compilation error:
error: 'FSInfo' was not declared in this scope
and
'class fs::LittleFSFS' has no member named 'info'
(LittleFS.h and FS.h in included)
There are no issues.
Make sure your Espressif8266 platform is up-to-date. E.g., CLI → pio pkg update -g -p espressif8266.
Okay this does fail for ESP32. But where does it say that that API is available for ESP32?
