Migrate from SPIFFS to LittleFS

Author: jpcornil-git

CMakeLists.txt

@@ -8,12 +8,12 @@ include($ENV{IDF_PATH}/tools/cmake/project.cmake)
 # set(PROJECT_VER "0.0.0")
 project(ayab-esp32)
 
-# Create spiffs partition image
-set(SPIFFS_PARTITION_NAME "spiffs")
-set(SPIFFS_DATA_DIR "${PROJECT_DIR}/data")
-spiffs_create_partition_image(
-    "${SPIFFS_PARTITION_NAME}"
-    "${SPIFFS_DATA_DIR}"
+# Create littlefs partition image
+set(LITTLEFS_PARTITION_NAME "littlefs")
+set(LITTLEFS_DATA_DIR "${PROJECT_DIR}/data")
+littlefs_create_partition_image(
+    "${LITTLEFS_PARTITION_NAME}"
+    "${LITTLEFS_DATA_DIR}"
     FLASH_IN_PROJECT
 )
 
@@ -32,4 +32,4 @@ add_dependencies(create_flash_image app)
 add_dependencies(create_flash_image bootloader)
 add_dependencies(create_flash_image partition-table)
 add_dependencies(create_flash_image blank_ota_data)
-add_dependencies(create_flash_image spiffs_${SPIFFS_PARTITION_NAME}_bin)
+add_dependencies(create_flash_image littlefs_${LITTLEFS_PARTITION_NAME}_bin)

README.md

@@ -11,8 +11,8 @@
 - mDNS server to access device by name rather than IP address (default=ayab.local) 
 - websocket to serial proxy enabling ayab api over a network (with webapp or ayab-desktop)
 - http server to access the ayab webapp
-- SPIFFS file system to store http server files (html, css, js, ...)
-- Over-The-Air (OTA) updates for esp32 firmware, ayab (RA4M1) firmware or SPIFFS (partition or individual files)
+- LITTLEFS file system to store http server files (html, css, js, ...)
+- Over-The-Air (OTA) updates for esp32 firmware, ayab (RA4M1) firmware or LITTLEFS (partition or individual files)
 
 ## How to build
 - Clone this repository

components/ota/CMakeLists.txt

@@ -1,7 +1,7 @@
 set(COMPONENT_SRCS
     ota_handler.c    
     ota_app.c
-    ota_spiffs.c
+    ota_littlefs.c
 )
 
 set(COMPONENT_PUBLIC_INCLUDE_DIRS

components/ota/include/ota_littlefs.h

@@ -0,0 +1,46 @@
+#ifndef _OTA_LITTLEFS_H_
+#define _OTA_LITTLEFS_H_
+#include "esp_err.h"
+#include "esp_partition.h"
+
+const esp_partition_t *ota_littlefs_get_partition();
+
+/**
+ * @brief Initialize the LITTLEFS file system for OTA updates.
+ *
+ * This function sets up the LITTLEFS file system for OTA updates.
+ *
+ * @return ESP_OK on success, or an error code on failure.
+ */
+esp_err_t ota_littlefs_begin();
+
+/**
+ * @brief Write chunk of data to LITTLEFS during OTA update.
+ *
+ * This function writes a chunk of data to LITTLEFS during an OTA update.
+ *
+ * @param data Pointer to the data to write.
+ * @param len Length of the data in bytes.
+ * @return ESP_OK on success, or an error code on failure.
+ */
+esp_err_t ota_littlefs_write(char *data, size_t len);
+
+/**
+ * @brief End the LITTLEFS file system update.
+ *
+ * This function finalizes the LITTLEFS file system update, marking it as complete.
+ *
+ * @return ESP_OK on success, or an error code on failure.
+ */
+esp_err_t ota_littlefs_end();
+
+/**
+ * @brief Check if the LITTLEFS update is in progress.
+ *
+ * This function checks if a LITTLEFS update is currently in progress.
+ *
+ * @return true if a LITTLEFS update is in progress, false otherwise.
+ */
+void ota_littlefs_abort();
+
+#endif

components/ota/include/ota_spiffs.h

@@ -5,11 +5,11 @@
 
 #include "ota_handler.h"
 #include "ota_app.h"
-#include "ota_spiffs.h"
+#include "ota_littlefs.h"
 #include "ra4m1_flash.h"
 
 #define OTA_ESP32_APP      0
-#define OTA_ESP32_SPIFFS   1
+#define OTA_ESP32_LITTLEFS 1
 #define OTA_RA4M1_FIRMWARE 2
 #define OTA_BUFFER_SIZE 8192
 
@@ -24,8 +24,8 @@ typedef struct {
 static const char *TAG = "ota_handler";
 
 static ota_func_t ota_types[] = {
-    { .begin = ota_app_begin,     .write = ota_app_write,     .end = ota_app_end,     .abort = ota_app_abort    ,  .get_partition = ota_app_get_partition},
-    { .begin = ota_spiffs_begin,  .write = ota_spiffs_write,  .end = ota_spiffs_end,  .abort = ota_spiffs_abort ,  .get_partition = ota_spiffs_get_partition},
+    { .begin = ota_app_begin,     .write = ota_app_write,     .end = ota_app_end,     .abort = ota_app_abort,      .get_partition = ota_app_get_partition},
+    { .begin = ota_littlefs_begin,.write = ota_littlefs_write,.end = ota_littlefs_end,.abort = ota_littlefs_abort, .get_partition = ota_littlefs_get_partition},
     { .begin = ra4m1_flash_begin, .write = ra4m1_flash_write, .end = ra4m1_flash_end, .abort = ra4m1_flash_abort , .get_partition = ra4m1_flash_get_partition},
 };
 
@@ -44,8 +44,8 @@ esp_err_t ota_post_handler(httpd_req_t *req) {
             if (httpd_query_key_value(query_buf, "binaryType", value, sizeof(value)) == ESP_OK) {
                 if (!strcmp("esp32_app", value)) {
                     ota_type = OTA_ESP32_APP;
-                } else if (!strcmp("esp32_spiffs", value)) {
-                    ota_type = OTA_ESP32_SPIFFS;
+                } else if (!strcmp("esp32_littlefs", value)) {
+                    ota_type = OTA_ESP32_LITTLEFS;
                 } else if (!strcmp("ra4m1_app", value)) {
                     ota_type = OTA_RA4M1_FIRMWARE;
                 }

components/ota/ota_handler.c

@@ -2,30 +2,30 @@
 
 #include "esp_log.h"
 
-#include "srv_spiffs.h"
-#include "ota_spiffs.h"
+#include "srv_littlefs.h"
+#include "ota_littlefs.h"
 
 typedef struct {
-    const esp_partition_t* partition;  /*!< Pointer to the SPIFFS partition */
+    const esp_partition_t* partition;  /*!< Pointer to the LITTLEFS partition */
     size_t partition_offset;           /*!< Current offset in the partition */
     char* buffer;                      /*!< Buffer for writing data */
     size_t buffer_offset;              /*!< Current offset in the buffer */
-} ota_spiffs_data_t;
+} ota_littlefs_data_t;
 
-static const char *TAG = "ota_spiffs";
+static const char *TAG = "ota_littlefs";
 
-static ota_spiffs_data_t _self;
+static ota_littlefs_data_t _self;
 
-const esp_partition_t *ota_spiffs_get_partition() {
+const esp_partition_t *ota_littlefs_get_partition() {
   return _self.partition;
 }
 
-esp_err_t ota_spiffs_begin() {
+esp_err_t ota_littlefs_begin() {
     _self.buffer_offset = 0;
     _self.partition_offset = 0;
-    _self.partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_DATA_SPIFFS, NULL);
+    _self.partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_DATA_LITTLEFS, NULL);
     if( ! _self.partition) {
-        ESP_LOGE(TAG, "No SPIFFS partion found !");
+        ESP_LOGE(TAG, "No LITTLEFS partion found !");
         return ESP_FAIL;
     }
 
@@ -35,35 +35,35 @@ esp_err_t ota_spiffs_begin() {
         return ESP_FAIL;
     }
 
-    srv_spiffs_stop();
+    srv_littlefs_stop();
 
     ESP_LOGI(TAG, "Writing to partition subtype %d at offset 0x%"PRIx32"(size = 0x%"PRIx32")",
             _self.partition->subtype, _self.partition->address, _self.partition->size);
 
     return ESP_OK;
 }
 
-esp_err_t _ota_spiffs_writeBuffer(size_t len) {
+esp_err_t _ota_littlefs_writeBuffer(size_t len) {
     esp_err_t err = ESP_OK;
 
     err = esp_partition_erase_range(_self.partition, _self.partition_offset, _self.partition->erase_size);
     if (err != ESP_OK) {
-            ESP_LOGE(TAG, "Unable to erase spiffs sector @ 0x%08x (%s)", _self.partition_offset, esp_err_to_name(err));
+            ESP_LOGE(TAG, "Unable to erase littlefs sector @ 0x%08x (%s)", _self.partition_offset, esp_err_to_name(err));
             return ESP_FAIL;            
     }
 
     err = esp_partition_write(_self.partition, _self.partition_offset, _self.buffer, len);
     if (err != ESP_OK) {
-            ESP_LOGE(TAG, "Unable to write spiffs sector @ 0x%08x (%s)", _self.partition_offset, esp_err_to_name(err));
+            ESP_LOGE(TAG, "Unable to write littlefs sector @ 0x%08x (%s)", _self.partition_offset, esp_err_to_name(err));
             return ESP_FAIL;            
     }
     //ESP_LOGI(TAG, "Wrote %d bytes at 0x%08x", len , _self.partition_offset);
     return err;
 }
 
 // TODO: Add support for compressed FS ?
-esp_err_t ota_spiffs_write(char *data, size_t len) {
-    // FIXME: Need to check content to make sure it is a spiffs binary
+esp_err_t ota_littlefs_write(char *data, size_t len) {
+    // FIXME: Need to check content to make sure it is a littlefs binary
     if ((_self.partition_offset + len) > _self.partition->size) {
         ESP_LOGE(TAG, "Not enough space left on flash!");
         return ESP_FAIL;
@@ -74,7 +74,7 @@ esp_err_t ota_spiffs_write(char *data, size_t len) {
         size_t data_to_cpy = _self.partition->erase_size - _self.buffer_offset;
         memcpy(_self.buffer + _self.buffer_offset, data + (len - data_left), data_to_cpy);
 
-        if (_ota_spiffs_writeBuffer(_self.partition->erase_size) != ESP_OK) {
+        if (_ota_littlefs_writeBuffer(_self.partition->erase_size) != ESP_OK) {
             return ESP_FAIL;   
         }
 
@@ -89,22 +89,22 @@ esp_err_t ota_spiffs_write(char *data, size_t len) {
     return ESP_OK;
 }
 
-esp_err_t ota_spiffs_end() {
+esp_err_t ota_littlefs_end() {
     esp_err_t err = ESP_OK;
 
     if (_self.buffer_offset != 0) {
-        err = _ota_spiffs_writeBuffer(_self.buffer_offset);
+        err = _ota_littlefs_writeBuffer(_self.buffer_offset);
     }
 
     free(_self.buffer);
-    ESP_LOGI(TAG, "OTA spiffs update succeeded");
+    ESP_LOGI(TAG, "OTA littlefs update succeeded");
 
-    srv_spiffs_restart();
+    srv_littlefs_restart();
 
     return err;
 }
 
-void ota_spiffs_abort() {
+void ota_littlefs_abort() {
     free(_self.buffer);
-    ESP_LOGI(TAG, "OTA spiffs update aborted");
+    ESP_LOGI(TAG, "OTA littlefs update aborted");
 }

components/ota/ota_spiffs.c renamed to components/ota/ota_littlefs.c

@@ -2,7 +2,7 @@ set(COMPONENT_SRCS
     srv_file.c
     srv_http.c
     srv_mdns.c
-    srv_spiffs.c
+    srv_littlefs.c
     srv_websocket.c
     srv_wifi.c
 )
@@ -21,7 +21,7 @@ set(COMPONENT_REQUIRES
 set(COMPONENT_PRIV_REQUIRES
     esp_app_format
     esp_partition
-    spiffs
+    littlefs
     app_config
     ota
     ra4m1

components/services/CMakeLists.txt

@@ -0,0 +1,35 @@
+#ifndef _SRV_SPIFFS_H_
+#define _SRV_SPIFFS_H_
+
+#include "esp_err.h"
+
+/**
+ * @brief Initialize and mount the LITTLEFS filesystem.
+ *
+ * This function mounts the LITTLEFS filesystem at the given base path.
+ * It must be called before any file operations.
+ *
+ * @param base_path The mount point path for LITTLEFS (e.g., "/littlefs").
+ * @return ESP_OK on success, or an error code from esp_err_t on failure.
+ */
+esp_err_t srv_littlefs_start(char *base_path);
+
+/**
+ * @brief Restart (unmount and remount) the LITTLEFS filesystem.
+ *
+ * This function unmounts and remounts the LITTLEFS filesystem using the last base path.
+ *
+ * @return ESP_OK on success, or an error code from esp_err_t on failure.
+ */
+esp_err_t srv_littlefs_restart(void);
+
+/**
+ * @brief Unmount the LITTLEFS filesystem and release resources.
+ *
+ * This function unmounts the LITTLEFS filesystem and frees associated resources.
+ *
+ * @return ESP_OK on success, or an error code from esp_err_t on failure.
+ */
+esp_err_t srv_littlefs_stop(void);
+
+#endif