Prvni ulozeni z chegewara githubu

libraries/LittleFS/examples/LITTLEFS_PlatformIO/.gitignore

@@ -0,0 +1,4 @@
+.pio
+.vscode
+mklittlefs.exe
+mklittlefs

libraries/LittleFS/examples/LITTLEFS_PlatformIO/README.md

@@ -0,0 +1,68 @@
+# How to run on PlatformIO IDE
+
+- Download and extract to this project root a **mklittlefs** executable for your OS [from a zipped binary here](https://github.com/earlephilhower/mklittlefs/releases) 
+- Open **LITTLEFS_PlatformIO** folder
+- Run PlatformIO project task: **Upload Filesystem Image** 
+- Run PlatformIO project task: **Upload and Monitor**
+- You will see a Serial output like:
+```
+--- Miniterm on COM5  115200,8,N,1 ---
+--- Quit: Ctrl+C | Menu: Ctrl+T | Help: Ctrl+T followed by Ctrl+H ---
+ets Jun  8 2016 00:22:57
+
+rst:0x1 (POWERON_RESET),boot:0x13 (Snfigsip: 0, SPIWP:0xee
+clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
+mode:DIO, clock div:2
+load:0x3fff0018,len:4
+load:0x3fff001c,len:1044
+load:0x40078000,len:10044
+load:0x40080400,len:5872
+entry 0x400806ac
+Listing directory: /
+  FILE: /file1.txt  SIZE: 3  LAST WRITE: 2020-10-06 15:10:33
+  DIR : /testfolder  LAST WRITE: 2020-10-06 15:10:33
+Creating Dir: /mydir
+Dir created
+Writing file: /mydir/hello2.txt
+- file written
+Listing directory: /
+  FILE: /file1.txt  SIZE: 3  LAST WRITE: 2020-10-06 15:10:33
+  DIR : /mydir  LAST WRITE: 1970-01-01 00:00:00
+Listing directory: /mydir
+  FILE: /mydir/hello2.txt  SIZE: 6  LAST WRITE: 1970-01-01 00:00:00
+  DIR : /testfolder  LAST WRITE: 2020-10-06 15:10:33
+Listing directory: /testfolder
+  FILE: /testfolder/test2.txt  SIZE: 3  LAST WRITE: 2020-10-06 15:10:33
+Deleting file: /mydir/hello2.txt
+- file deleted
+Removing Dir: /mydir
+Dir removed
+Listing directory: /
+  FILE: /file1.txt  SIZE: 3  LAST WRITE: 2020-10-06 15:10:33
+  DIR : /testfolder  LAST WRITE: 2020-10-06 15:10:33
+Listing directory: /testfolder
+  FILE: /testfolder/test2.txt  SIZE: 3  LAST WRITE: 2020-10-06 15:10:33
+Writing file: /hello.txt
+- file written
+Appending to file: /hello.txt
+- message appended
+Reading file: /hello.txt
+- read from file:
+Hello World!
+Renaming file /hello.txt to /foo.txt
+- file renamed
+Reading file: /foo.txt
+- read from file:
+Hello World!
+Deleting file: /foo.txt
+- file deleted
+Testing file I/O with /test.txt
+- writing................................................................
+ - 1048576 bytes written in 12006 ms
+- reading................................................................
+- 1048576 bytes read in 547 ms
+Deleting file: /test.txt
+- file deleted
+Test complete
+```
+- If you have a module with more than 4MB flash, you can uncomment **partitions_custom.csv** in **platformio.ini** and modify the csv file accordingly

libraries/LittleFS/examples/LITTLEFS_PlatformIO/data/file1.txt

@@ -0,0 +1 @@
+aaa

libraries/LittleFS/examples/LITTLEFS_PlatformIO/data/testfolder/test2.txt

@@ -0,0 +1 @@
+bbb

libraries/LittleFS/examples/LITTLEFS_PlatformIO/littlefsbuilder.py

@@ -0,0 +1,2 @@
+Import("env")
+env.Replace( MKSPIFFSTOOL=env.get("PROJECT_DIR") + '/mklittlefs' )  # PlatformIO now believes it has actually created a SPIFFS

libraries/LittleFS/examples/LITTLEFS_PlatformIO/partitions_custom.csv

@@ -0,0 +1,6 @@
+# Name,   Type, SubType,  Offset,   Size,  Flags
+ota_0,     app, ota_0,   0x10000,  0x1A0000,
+ota_1,     app, ota_1,          ,  0x1A0000,
+otadata,  data, ota,    0x350000,  0x2000,
+nvs,      data, nvs,            ,  0x6000,
+data,     data, spiffs,         ,  0xA8000,

libraries/LittleFS/examples/LITTLEFS_PlatformIO/platformio.ini

@@ -0,0 +1,24 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[platformio]
+default_envs = esp32
+
+[env]
+framework = arduino
+
+[env:esp32]
+platform = espressif32
+board = esp32dev
+;board_build.partitions = partitions_custom.csv
+monitor_filters = esp32_exception_decoder
+monitor_speed = 115200
+
+extra_scripts = ./littlefsbuilder.py

libraries/LittleFS/examples/LITTLEFS_PlatformIO/src/main.cpp

@@ -0,0 +1,282 @@
+#include <Arduino.h>
+#include "FS.h"
+#include <LittleFS.h>
+#include <time.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 */
+   
+#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.print(file.name());
+            time_t t= file.getLastWrite();
+            struct tm * tmstruct = localtime(&t);
+            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.name(), 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(&t);
+            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\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
+
+// See: https://github.com/esp8266/Arduino/blob/master/libraries/LittleFS/src/LittleFS.cpp#L60
+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();
+}
+
+// See:  https://github.com/esp8266/Arduino/blob/master/libraries/LittleFS/src/LittleFS.h#L149
+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);
+    if(!LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED)){
+        Serial.println("LittleFS Mount Failed");
+        return;
+    }
+    
+    listDir(LittleFS, "/", 0);
+	createDir(LittleFS, "/mydir");
+	writeFile(LittleFS, "/mydir/hello2.txt", "Hello2");
+  //writeFile(LittleFS, "/mydir/newdir2/newdir3/hello3.txt", "Hello3");
+    writeFile2(LittleFS, "/mydir/newdir2/newdir3/hello3.txt", "Hello3");
+	listDir(LittleFS, "/", 3);
+	deleteFile(LittleFS, "/mydir/hello2.txt");
+  //deleteFile(LittleFS, "/mydir/newdir2/newdir3/hello3.txt");
+    deleteFile2(LittleFS, "/mydir/newdir2/newdir3/hello3.txt");
+	removeDir(LittleFS, "/mydir");
+	listDir(LittleFS, "/", 3);
+    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(){
+
+}

libraries/LittleFS/examples/LITTLEFS_test/LITTLEFS_test.ino

@@ -0,0 +1,288 @@
+#include <Arduino.h>
+#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 */
+
+//#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" ); 
+}
+
+void loop(){
+
+}

libraries/LittleFS/examples/LITTLEFS_test/partitions.csv

@@ -0,0 +1,8 @@
+# Name,   Type, SubType, Offset,  Size, Flags
+nvs,      data, nvs,     0x9000,  0x5000,
+otadata,  data, ota,     0xe000,  0x2000,
+app0,     app,  ota_0,   0x10000, 0x100000,
+app1,     app,  ota_1,           ,0x100000,
+spiffs,   data, spiffs,          ,0x1D0000,
+part2,    data, spiffs,          ,0x20000,
+#1048576

libraries/LittleFS/examples/LITTLEFS_time/LITTLEFS_time.ino

@@ -0,0 +1,214 @@
+#include "FS.h"
+//#include "SPIFFS.h" 
+#include "LittleFS.h"
+#include <time.h> 
+#include <WiFi.h>
+
+#define SPIFFS LittleFS
+
+/* This examples uses "quick re-define" of SPIFFS to run 
+   an existing sketch with LittleFS instead of SPIFFS
+
+   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 */
+   
+#define FORMAT_LITTLEFS_IF_FAILED true
+
+const char* ssid     = "yourssid";
+const char* password = "yourpass";
+
+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(&t);
+            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(&t);
+            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(!SPIFFS.begin(FORMAT_LITTLEFS_IF_FAILED)){
+        Serial.println("LittleFS Mount Failed");
+        return;
+    }
+
+    Serial.println("----list 1----");
+    listDir(SPIFFS, "/", 1);
+	
+    Serial.println("----remove old dir----");
+    removeDir(SPIFFS, "/mydir");
+	
+    Serial.println("----create a new dir----");
+    createDir(SPIFFS, "/mydir");
+	
+    Serial.println("----remove the new dir----");
+    removeDir(SPIFFS, "/mydir");
+	
+    Serial.println("----create the new again----");
+    createDir(SPIFFS, "/mydir");
+	
+    Serial.println("----create and work with file----");
+    writeFile(SPIFFS, "/mydir/hello.txt", "Hello ");
+    appendFile(SPIFFS, "/mydir/hello.txt", "World!\n");
+
+    Serial.println("----list 2----");
+    listDir(SPIFFS, "/", 1);
+	
+    Serial.println("----attempt to remove dir w/ file----");
+    removeDir(SPIFFS, "/mydir");
+	
+    Serial.println("----remove dir after deleting file----");
+    deleteFile(SPIFFS, "/mydir/hello.txt");
+    removeDir(SPIFFS, "/mydir");
+	
+	Serial.println("----list 3----");
+    listDir(SPIFFS, "/", 1);
+	
+	Serial.println( "Test complete" );
+
+}
+
+void loop(){
+
+}