3.3.7

libraries/FFat/examples/FFat_Test/FFat_Test.ino

@@ -0,0 +1,188 @@
+#include "FS.h"
+#include "FFat.h"
+
+// This file should be compiled with 'Partition Scheme' (in Tools menu)
+// set to 'Default with ffat' if you have a 4MB ESP32 dev module or
+// set to '16M Fat' if you have a 16MB ESP32 dev module.
+
+// You only need to format FFat the first time you run a test
+#define FORMAT_FFAT 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 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 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 %lu 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("- %zu bytes read in %lu ms\r\n", flen, end);
+    file.close();
+  } else {
+    Serial.println("- failed to open file for reading");
+  }
+}
+
+void setup() {
+  Serial.begin(115200);
+  Serial.setDebugOutput(true);
+  if (FORMAT_FFAT) {
+    FFat.format();
+  }
+  if (!FFat.begin()) {
+    Serial.println("FFat Mount Failed");
+    return;
+  }
+
+  Serial.printf("Total space: %10zu\n", FFat.totalBytes());
+  Serial.printf("Free space: %10zu\n", FFat.freeBytes());
+  listDir(FFat, "/", 0);
+  writeFile(FFat, "/hello.txt", "Hello ");
+  appendFile(FFat, "/hello.txt", "World!\r\n");
+  readFile(FFat, "/hello.txt");
+  renameFile(FFat, "/hello.txt", "/foo.txt");
+  readFile(FFat, "/foo.txt");
+  deleteFile(FFat, "/foo.txt");
+  testFileIO(FFat, "/test.txt");
+  Serial.printf("Free space: %10zu\n", FFat.freeBytes());
+  deleteFile(FFat, "/test.txt");
+  Serial.println("Test complete");
+}
+
+void loop() {}

libraries/FFat/examples/FFat_time/FFat_time.ino

@@ -0,0 +1,184 @@
+#include "FS.h"
+#include "FFat.h"
+#include <time.h>
+#include <WiFi.h>
+
+const char *ssid = "your-ssid";
+const char *password = "your-password";
+
+long timezone = 1;
+byte daysavetime = 1;
+
+void listDir(fs::FS &fs, const char *dirname, uint8_t levels) {
+  Serial.printf("Listing directory: %s\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.print(file.name());
+      time_t t = file.getLastWrite();
+      struct tm tmstruct;
+      localtime_r(&t, &tmstruct);
+      Serial.printf(
+        "  LAST WRITE: %d-%02d-%02d %02d:%02d:%02d\n", (tmstruct.tm_year) + 1900, (tmstruct.tm_mon) + 1, tmstruct.tm_mday, tmstruct.tm_hour, tmstruct.tm_min,
+        tmstruct.tm_sec
+      );
+      if (levels) {
+        listDir(fs, file.path(), levels - 1);
+      }
+    } else {
+      Serial.print("  FILE: ");
+      Serial.print(file.name());
+      Serial.print("  SIZE: ");
+      Serial.print(file.size());
+      time_t t = file.getLastWrite();
+      struct tm tmstruct;
+      localtime_r(&t, &tmstruct);
+      Serial.printf(
+        "  LAST WRITE: %d-%02d-%02d %02d:%02d:%02d\n", (tmstruct.tm_year) + 1900, (tmstruct.tm_mon) + 1, tmstruct.tm_mday, tmstruct.tm_hour, tmstruct.tm_min,
+        tmstruct.tm_sec
+      );
+    }
+    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\n", path);
+
+  File file = fs.open(path);
+  if (!file) {
+    Serial.println("Failed to open file for reading");
+    return;
+  }
+
+  Serial.print("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\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\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\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\n", path);
+  if (fs.remove(path)) {
+    Serial.println("File deleted");
+  } else {
+    Serial.println("Delete failed");
+  }
+}
+
+void setup() {
+  Serial.begin(115200);
+  // We start by connecting to a WiFi network
+  Serial.println();
+  Serial.println();
+  Serial.print("Connecting to ");
+  Serial.println(ssid);
+
+  WiFi.begin(ssid, password);
+
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+  Serial.println("WiFi connected");
+  Serial.println("IP address: ");
+  Serial.println(WiFi.localIP());
+  Serial.println("Contacting Time Server");
+  configTime(3600 * timezone, daysavetime * 3600, "time.nist.gov", "0.pool.ntp.org", "1.pool.ntp.org");
+  struct tm tmstruct;
+  delay(2000);
+  tmstruct.tm_year = 0;
+  getLocalTime(&tmstruct, 5000);
+  Serial.printf(
+    "\nNow is : %d-%02d-%02d %02d:%02d:%02d\n", (tmstruct.tm_year) + 1900, (tmstruct.tm_mon) + 1, tmstruct.tm_mday, tmstruct.tm_hour, tmstruct.tm_min,
+    tmstruct.tm_sec
+  );
+  Serial.println("");
+
+  if (!FFat.begin(true)) {
+    Serial.println("FFat Mount Failed");
+    return;
+  }
+
+  listDir(FFat, "/", 0);
+  removeDir(FFat, "/mydir");
+  createDir(FFat, "/mydir");
+  deleteFile(FFat, "/hello.txt");
+  writeFile(FFat, "/hello.txt", "Hello ");
+  appendFile(FFat, "/hello.txt", "World!\n");
+  listDir(FFat, "/", 0);
+}
+
+void loop() {}

libraries/FFat/examples/FFat_time/ci.yml

@@ -0,0 +1,3 @@
+requires_any:
+  - CONFIG_SOC_WIFI_SUPPORTED=y
+  - CONFIG_ESP_WIFI_REMOTE_ENABLED=y

libraries/FFat/library.properties

@@ -0,0 +1,9 @@
+name=FFat
+version=3.3.7
+author=Hristo Gochkov, Ivan Grokhtkov, Larry Bernstone
+maintainer=Hristo Gochkov <hristo@espressif.com>
+sentence=ESP32 FAT on Flash File System
+paragraph=
+category=Data Storage
+url=
+architectures=esp32

libraries/FFat/src/FFat.cpp

@@ -0,0 +1,159 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "vfs_api.h"
+extern "C" {
+#include "esp_vfs_fat.h"
+#include "diskio.h"
+#include "diskio_wl.h"
+#include "vfs_fat_internal.h"
+}
+#include "FFat.h"
+
+using namespace fs;
+
+F_Fat::F_Fat(FSImplPtr impl) : FS(impl) {}
+
+const esp_partition_t *check_ffat_partition(const char *label) {
+  const esp_partition_t *ck_part = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_DATA_FAT, label);
+  if (!ck_part) {
+    log_e("No FAT partition found with label %s", label);
+    return NULL;
+  }
+  return ck_part;
+}
+
+bool F_Fat::begin(bool formatOnFail, const char *basePath, uint8_t maxOpenFiles, const char *partitionLabel) {
+  if (_wl_handle != WL_INVALID_HANDLE) {
+    log_w("Already Mounted!");
+    return true;
+  }
+
+  if (!check_ffat_partition(partitionLabel)) {
+    log_e("No fat partition found on flash");
+    return false;
+  }
+
+  esp_vfs_fat_mount_config_t conf = {
+    .format_if_mount_failed = formatOnFail,
+    .max_files = maxOpenFiles,
+    .allocation_unit_size = CONFIG_WL_SECTOR_SIZE,
+    .disk_status_check_enable = false,
+    .use_one_fat = false
+  };
+  esp_err_t err = esp_vfs_fat_spiflash_mount_rw_wl(basePath, partitionLabel, &conf, &_wl_handle);
+  if (err) {
+    log_e("Mounting FFat partition failed! Error: %d", err);
+    esp_vfs_fat_spiflash_unmount_rw_wl(basePath, _wl_handle);
+    _wl_handle = WL_INVALID_HANDLE;
+    return false;
+  }
+  _impl->mountpoint(basePath);
+  return true;
+}
+
+void F_Fat::end() {
+  if (_wl_handle != WL_INVALID_HANDLE) {
+    esp_err_t err = esp_vfs_fat_spiflash_unmount_rw_wl(_impl->mountpoint(), _wl_handle);
+    if (err) {
+      log_e("Unmounting FFat partition failed! Error: %d", err);
+      return;
+    }
+    _wl_handle = WL_INVALID_HANDLE;
+    _impl->mountpoint(NULL);
+  }
+}
+
+bool F_Fat::format(bool full_wipe, char *partitionLabel) {
+  esp_err_t result;
+  bool res = true;
+  if (_wl_handle != WL_INVALID_HANDLE) {
+    log_w("Already Mounted!");
+    return false;
+  }
+  wl_handle_t temp_handle;
+  // Attempt to mount to see if there is already data
+  const esp_partition_t *ffat_partition = check_ffat_partition(partitionLabel);
+  if (!ffat_partition) {
+    log_w("No partition!");
+    return false;
+  }
+  result = wl_mount(ffat_partition, &temp_handle);
+
+  if (result == ESP_OK) {
+    // Wipe disk- quick just wipes the FAT. Full zeroes the whole disk
+    uint32_t wipe_size = full_wipe ? wl_size(temp_handle) : 16384;
+    wl_erase_range(temp_handle, 0, wipe_size);
+    wl_unmount(temp_handle);
+  } else {
+    res = false;
+    log_w("wl_mount failed!");
+  }
+  // Now do a mount with format_if_fail (which it will)
+  esp_vfs_fat_mount_config_t conf = {
+    .format_if_mount_failed = true, .max_files = 1, .allocation_unit_size = CONFIG_WL_SECTOR_SIZE, .disk_status_check_enable = false, .use_one_fat = false
+  };
+  result = esp_vfs_fat_spiflash_mount_rw_wl("/format_ffat", partitionLabel, &conf, &temp_handle);
+  esp_vfs_fat_spiflash_unmount_rw_wl("/format_ffat", temp_handle);
+  if (result != ESP_OK) {
+    res = false;
+    log_w("esp_vfs_fat_spiflash_mount_rw_wl failed!");
+  }
+  return res;
+}
+
+size_t F_Fat::totalBytes() {
+  FATFS *fs;
+  DWORD free_clust, tot_sect, sect_size;
+
+  BYTE pdrv = ff_diskio_get_pdrv_wl(_wl_handle);
+  char drv[3] = {(char)(48 + pdrv), ':', 0};
+  if (f_getfree(drv, &free_clust, &fs) != FR_OK) {
+    return 0;
+  }
+  tot_sect = (fs->n_fatent - 2) * fs->csize;
+  sect_size = CONFIG_WL_SECTOR_SIZE;
+  return tot_sect * sect_size;
+}
+
+size_t F_Fat::usedBytes() {
+  FATFS *fs;
+  DWORD free_clust, used_sect, sect_size;
+
+  BYTE pdrv = ff_diskio_get_pdrv_wl(_wl_handle);
+  char drv[3] = {(char)(48 + pdrv), ':', 0};
+  if (f_getfree(drv, &free_clust, &fs) != FR_OK) {
+    return 0;
+  }
+  used_sect = (fs->n_fatent - 2 - free_clust) * fs->csize;
+  sect_size = CONFIG_WL_SECTOR_SIZE;
+  return used_sect * sect_size;
+}
+
+size_t F_Fat::freeBytes() {
+
+  FATFS *fs;
+  DWORD free_clust, free_sect, sect_size;
+
+  BYTE pdrv = ff_diskio_get_pdrv_wl(_wl_handle);
+  char drv[3] = {(char)(48 + pdrv), ':', 0};
+  if (f_getfree(drv, &free_clust, &fs) != FR_OK) {
+    return 0;
+  }
+  free_sect = free_clust * fs->csize;
+  sect_size = CONFIG_WL_SECTOR_SIZE;
+  return free_sect * sect_size;
+}
+
+F_Fat FFat = F_Fat(FSImplPtr(new VFSImpl()));

libraries/FFat/src/FFat.h

@@ -0,0 +1,46 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef _FFAT_H_
+#define _FFAT_H_
+
+#include "FS.h"
+#include "wear_levelling.h"
+
+#define FFAT_WIPE_QUICK      0
+#define FFAT_WIPE_FULL       1
+#define FFAT_PARTITION_LABEL "ffat"
+
+namespace fs {
+
+class F_Fat : public FS {
+public:
+  F_Fat(FSImplPtr impl);
+  bool begin(bool formatOnFail = false, const char *basePath = "/ffat", uint8_t maxOpenFiles = 10, const char *partitionLabel = (char *)FFAT_PARTITION_LABEL);
+  bool format(bool full_wipe = FFAT_WIPE_QUICK, char *partitionLabel = (char *)FFAT_PARTITION_LABEL);
+  size_t totalBytes();
+  size_t usedBytes();
+  size_t freeBytes();
+  void end();
+
+private:
+  wl_handle_t _wl_handle = WL_INVALID_HANDLE;
+};
+
+}  // namespace fs
+
+#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_FFAT)
+extern fs::F_Fat FFat;
+#endif
+
+#endif /* _FFAT_H_ */