Is the Filesystem on ESP8266 Read-Only After Writing with LittleFS or SPIFFS?

Описание: Discover if writing a LittleFS filesystem to flash on your ESP8266 is truly read-only and learn how to create and modify files dynamically.
---
This video is based on the question https://stackoverflow.com/q/73198339/ asked by the user 'Dan Forever' ( https://stackoverflow.com/u/1683284/ ) and on the answer https://stackoverflow.com/a/73198700/ provided by the user 'romkey' ( https://stackoverflow.com/u/2670348/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: With SPIFFS or LittleFS, on an ESP8266, is it possible to write a filesystem to flash, and then later create/modify files from the firmware?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding Filesystem Functionality on the ESP8266

If you've been working with the ESP8266, particularly the ESP-12S module using NodeMCU 1.0, you may encounter some confusion regarding the capability of the filesystem when using LittleFS or SPIFFS. One common question arises when you have bundled HTML files and images into a filesystem binary and flash it to the ESP8266. Can you later create and modify files from the firmware, or is this filesystem essentially "read-only"? Let's dive into the details to clarify this situation.

The Problem Context

In many projects, developers often write a filesystem, embed HTML and image files, and utilize libraries such as LittleFS for handling data persistence. The process typically involves:

Bundling files into a binary using tools like esptool or the Arduino IDE

Flashing that binary to the ESP8266's flash storage

Attempting to further manipulate the filesystem by creating new files or updating existing ones

However, issues can arise, evident in a situation where invoking LittleFS.open(path, "w"); could lead to crashes or resets, prompting questions about the read/write capabilities of the filesystem.

Key Concerns

Is the written filesystem read-only?

What happens when trying to create or modify files afterwards?

Are there potential bugs in the code or configuration?

Solution: Filesystem on ESP8266 is Not Read-Only

The straightforward answer is that a filesystem image written to flash using LittleFS or SPIFFS is not read-only. This means the firmware has complete access to create, modify, and delete files despite the initial flashing of the filesystem. Here's a breakdown of how this works:

1. Functionality of LittleFS/SPIFFS:

Editing Data: Just like filesystems on typical operating systems, these libraries allow you to manage files dynamically.

No Limitations: There is no discernible difference from the software's perspective whether a filesystem is created at runtime or flashed from an image.

2. Potential Issues:

If you encounter resets or crashes, it points toward a bug in your code rather than limitations of the filesystem itself. Possible areas to investigate include:

File Paths: Ensure the specified path in LittleFS.open(path, "w") is valid.

Memory Issues: The ESP8266 has limited RAM and flash memory. Make sure you're not running out of space when creating or modifying files.

Library Compatibility: Ensure you're using the latest versions of the libraries to avoid any unresolved issues.

3. Best Practices:

Testing Incrementally: Begin with basic file operations to confirm that your environment is set up correctly before trying more complex operations.

Error Handling: Implement error handling to address issues dynamically and avoid crashes on file operations.

Update Firmware: Keeping your firmware up to date can resolve many unexpected bugs.

Conclusion

In conclusion, writing a filesystem to the flash of an ESP8266 using LittleFS or SPIFFS does not render it read-only. The firmware can access, create, and modify files freely. If you notice issues during these operations, the problem may reside not in filesystem limitations but rather in your code or the system setup. So, dig into your code and test your approach. Happy coding!