Reading LittleFS file into buffer for sending

 Reading LittleFS file into buffer for sending to another ESP32 via ESP Now.

Created dummy file 1321 bytes long with "sensor" information in the form like this:


    uint8_t sensorData1[] = "[ 00 12:05:12:06:01 22 33 44 \n";

Red stuff above is timestamp to later get in real time from DS3231. 
Blue stuff is dummy sensor information, two ascii chars representing 00 to 99.
Black stuff is just formatting chars and spaces. The following program reads in about 43 lines of sensor information as above and puts it into LittleFS file called sensorReadings.txt. This file then gets cut up into 200 byte chunks (via sendBuf[200] ) and gets sent to dummy sender file called sendNowBuf().

No actual sending takes place, so next sub-project is to send the 200 byte chunks one by one via ESPNow to second ESP32.

//41 From Arduino Examples/mnt/c/Users/Dell/Documents/Arduino/Working202411/LITTLEFS_test2/LITTLEFS_test2.ino
#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-plugi


   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(" gg- 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 < 2; i++) {
  //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("- %u 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);


  if (!LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED)) {
    Serial.println("LittleFS Mount Failed");
    return;
  }
  Serial.println("___________3,1p,______"); 
  for (int i=0;i<3;i++) {
     delay(2000);
     Serial.printf("Wait %d \n",i);
  }   
  listDir(LittleFS, "/", 3);  
  createSensorAr(); 
  listDir(LittleFS, "/", 1);  
  showSensorData1Ar(); //output all the sensor log rows
  readFileIntoNowBufs();

}


void loop() {}

//File below from perpLittleFS1.ino
void doPerpLittle1(void) {

    // Create an array of bytes (simulating sensor data)
    uint8_t sensorData[] = "[ 12:05:12:06:01 22 33 44 \n";
    //uint8_t sensorData[] = "Now is the time.";
    //uint8_t sensorData[] = {0x41, 0x42, 0x43, 0x44, 0x45}; // Example data: ABCDE in ASCII
    size_t dataSize = sizeof(sensorData);
    sensorData[3]=0x41;
    //sensorData[3]=sensorData[3] +1 ; //x41; 
    for(int i=0x30;i<0x3B;i++) {
       sensorData[3] = i;
       appendFile(LittleFS,"/hello.txt",(const char *)sensorData); //Pb converted uint * to const char*.. Surprised it worked.
    }   



    // Write the array to myFile.txt
    File file = LittleFS.open("/myFile.txt", "w");
    if (!file) {
        Serial.println("Failed to open file for writing");
        return;
    }
    if (file.write(sensorData, dataSize) == dataSize) {
        Serial.println("File was written");
    } else {
        Serial.println("File write failed");
    }
    file.close();

    // Read from myFile.txt
    file = LittleFS.open("/myFile.txt", "r");
    if (!file) {
        Serial.println("Failed to open file for reading");
        return;
    }
    Serial.println("Reading file:");
    while (file.available()) {
        Serial.printf("%02X ", file.read());
    }
    Serial.println();
    file.close();

    // Read from myFile.txt and output in chars
    file = LittleFS.open("/myFile.txt", "r");
    if (!file) {
        Serial.println("Failed to open file for reading");
        return;
    }
    Serial.println("Reading file, outpuy in chars...:");
    while (file.available()) {
        Serial.printf("%c", file.read());
    }
    Serial.println();
    file.close();


    // Read from  and hello.txt output in chars
    file = LittleFS.open("/hello.txt", "r");
    if (!file) {
        Serial.println("Failed to open file for reading");
        return;
    }
    Serial.println("Reading file (hello.txt), output in chars------------...:");
    while (file.available()) {
        Serial.printf("%c", file.read());
    }
    Serial.println();
    file.close();
}
void createSensorAr(void) { //dummy sensor readings about 50 of them
   
    uint8_t sensorData1[] = "[ 00 12:05:12:06:01 22 33 44 \n";
    size_t dataSize1 = sizeof(sensorData1);
    Serial.printf("Size of sensorData1[] is... %d \n",dataSize1);
    // Write the array to sensorReadings.txt
    File file1= LittleFS.open("/sensorReadings.txt", "w"); //delete old one
    if (!file1) {
        Serial.println("Failed to open file for writing");
        return;
    }
    if (file1.write(sensorData1, dataSize1) == dataSize1) {
        Serial.println("File was written");
    } else {
        Serial.println("File write failed");
    }
    file1.close();
    //for(int i=0x30;i<0x32;i++) { //all chars from '0' =0x30 to 'Z'=0x5B
    for(int i=0x30;i<0x5B;i++) { //all chars from '0' =0x30 to 'Z'=0x5B
       sensorData1[3] = i;
       appendFile(LittleFS,"/sensorReadings.txt",(const char *)sensorData1); //Pb converted uint * to const char*.. Surprised it worked.
     }
  auto file = LittleFS.open("/sensorReadings.txt" , "r");
    size_t filesize = file.size();
   Serial.printf(" Size is ..%d",filesize);
    // Don't forget to clean up!
     file.close();
}    

void showSensorData1Ar(void) { //output all the sensor log rows
    // Read from sensorReadings.txt output in chars
    File file = LittleFS.open("/sensorReadings.txt", "r");
    if (!file) {
        Serial.println("Failed to open file for reading");
        return;
    }
    Serial.println("Reading file (sensorReadings.txt), output in chars------------...:");
    while (file.available()) {
        Serial.printf("%c", file.read());
    }
    Serial.println("sensorReadings.txt all output");
    Serial.printf("Size is ...%d \n",file.size()); 
    file.close();
}

void readFileIntoNowBufs(void) { //put all bytes from sensorReadings.txt in nowBufs and send via ESP-Now
   int bufs = 0; int k=0; uint8_t nowBuf[200]; uint8_t b;
    File file = LittleFS.open("/sensorReadings.txt", "r");
    if (!file) {
        Serial.println("Failed to open file for reading");
        return;
    }
    Serial.println("Reading file (sensorReadings.txt), output in chars------------...:");
    while (file.available()) {
        b = file.read(); 
        Serial.printf("%c",b); // file.read());
        nowBuf[k++] = b;
        if (k==200) {
          sendNowBuf();// bufs++;
          Serial.printf("Buf counter = %d , k = %d \n",bufs++,k);
          k=0;
          
       }
    }
    sendNowBuf(); //final half filled buffer gets sent at the end.
     Serial.printf("Last buf counter = %d , k = %d \n",bufs,k);
}
void sendNowBuf(void) { //dummy stub
   Serial.println("now buf sent");
}   

void removeThings(void) { //have some rubbish to clear up
   
  deleteFile(LittleFS, "/new4/sensorReadings.txt");
  listDir(LittleFS, "/", 2);  
  removeDir(LittleFS, "/new4");
}

Comments

Post a Comment

Popular posts from this blog

ESP32 buttons and bouncing

 ESP32 buttons and bouncing Rigged up button to GPIO 21 to explore, button presses, debouncing and interrupts. Following worked. /*  * This ESP32 code is created by esp32io.com Worked 7/11/24  *  * This ESP32 code is released in the public domain  *  * For more detail (instruction and wiring diagram), visit https://esp32io.com/tutorials/esp32-button-debounce  */ #include <ezButton.h> #define DEBOUNCE_TIME 50 // the debounce time in millisecond, increase this time if it still chatters ezButton button ( 21 ) ; // create ezButton object that attach to pin GPIO21 void setup () {   Serial . begin ( 9600 ) ;   button . setDebounceTime ( DEBOUNCE_TIME ) ; // set debounce time to 50 milliseconds } void loop () {   button . loop () ; // MUST call the loop() function first   if ( button . isPressed ())     Serial . println ( "The button is pressed" ) ;   if ( button . isReleased ())     Serial . pri...
Read more