Hello UKHeliBob!
The basic code is just the "LittleFS_test" example from the LittleFS library.
Saving this sketch under a new name will already lead to the "LittleFS-mount failure" when the code is running on the esp32s2. It compiles fine.
An example of my code is as follows:
#include <Arduino.h>
#include "FS.h"
#include <LittleFS.h>
#include <driver/dac.h>
#include "esp_adc_cal.h"
#include "driver/adc.h"
#include "esp_err.h"
#include "sdkconfig.h"
#include "driver/gpio.h"
#include "hal/adc_types.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 */
static const adc_bits_width_t width = ADC_WIDTH_BIT_13; // speziell f'fcr ESP32S2 !!!! Alle anderen Werte nur f'fcr ESP32 und ESP32C3 !!!
// calibration values for the adc
#define DEFAULT_VREF 1100
esp_adc_cal_characteristics_t *adc_chars;
//#define TWOPART
#define FORMAT_LITTLEFS_IF_FAILED true
bool vollIndex = false;
bool sampleBuf1 = true;
int cIndex = 0;
void listDir(fs::FS &fs, const char * dirname, uint8_t levels){
Serial.printf("Listing directory: %srn", 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: %sn", 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: %sn", 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: %srn", 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: %srn", 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: %srn", 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 %srn", 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: %srn", 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: %srn", 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: %srn", 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: %srn", 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: %srn", 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 %srn", path);
static uint8_t buf1[512];
static uint8_t buf2[512];
sampleBuf1 = true;
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<12; i++){
for (int b_index = 2; b_index < 512; b_index=b_index+3)
{
//uint16_t sample = b_index +6000;
// uint16_t sample = adc1_get_raw(ADC1_CHANNEL_7);
uint16_t sample = analogRead(A3);
/*
Serial.print(sample);
Serial.print(" : ADC Sample Index: ");
Serial.println(b_index);*/
uint8_t sample_u8[3];
sample_u8[0]=sample & 0xff;
sample_u8[1]=(sample >> 8);
sample_u8[2] = 44;
if (sampleBuf1 == true)
{
//buf[b_index] = sample + 44;
buf1[b_index-2] = sample_u8[1];
buf1[b_index-1] = sample_u8[0];
buf1[b_index] = sample_u8[2]; // oder 44 als dez.
}
else
{
buf2[b_index-2] = sample_u8[1];
buf2[b_index-1] = sample_u8[0];
buf2[b_index] = sample_u8[2]; // oder 44 als dez.
}
//delayMicroseconds(10);
if(b_index >= 509)
vollIndex = true;
}
if(vollIndex)
{
Serial.println(sampleBuf1);
sampleBuf1 = !sampleBuf1;
}
/*if ((i & 0x001F) == 0x001F){
Serial.print(".");
}*/
if(!sampleBuf1)
file.write(buf1, 512);
else
file.write(buf2, 512);
}
Serial.println("");
uint32_t end = millis() - start;
Serial.printf(" - %u bytes written in %u msrn", 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;
Serial.print("File length: ");
Serial.println(len);
if(toRead > 512){
toRead = 512;
}
file.read(buf1, toRead);
Serial.print("To Read: ");
Serial.println(toRead);
// if ((i++ & 0x001F) == 0x001F){
for (int b_index = 2; b_index < 512; b_index=b_index+3)
{
Serial.print("Hallo");
uint8_t ausgabe_u8[2];
ausgabe_u8[0] = buf1[b_index-2]; // LSB
ausgabe_u8[1] = buf1[b_index-1]; // MSB
//uint16_t ui16 = ausgabe_u8[1] + (ausgabe_u8[0] * 100);
uint16_t ui16 = ausgabe_u8[1] | (ausgabe_u8[0] <<8 );
Serial.printf("buf = %d", ui16);
if (buf1[b_index] == 44)
{
Serial.println();
}
else
Serial.printf("Lesefehler");
}
// } --- if i...
len -= toRead;
}
Serial.println("");
end = millis() - start;
Serial.printf("- %u bytes read in %u msrn", flen, end);
file.close();
} else {
Serial.println("- failed to open file for reading");
}
}
void setup(){
Serial.begin(115200);
delay(3000);
/*
//Range 0-4096
adc1_config_width(width);
// full voltage range
adc1_config_channel_atten(ADC1_CHANNEL_7, ADC_ATTEN_DB_11); // py-qt-32S2 Pin A3, Full Range!
// check to see what calibration is available
if (esp_adc_cal_check_efuse(ESP_ADC_CAL_VAL_EFUSE_VREF) == ESP_OK)
{
Serial.println("Using voltage ref stored in eFuse"); // funktioniert nicht mit ESP32S2 !!
}
if (esp_adc_cal_check_efuse(ESP_ADC_CAL_VAL_EFUSE_TP) == ESP_OK)
{
Serial.println("Using two point values from eFuse");
}
if (esp_adc_cal_check_efuse(ESP_ADC_CAL_VAL_DEFAULT_VREF) == ESP_OK)
{
Serial.println("Using default VREF"); // funktioniert nicht mit ESP32S2 !!
}
//Characterize ADC
adc_chars = (esp_adc_cal_characteristics_t *)calloc(1, sizeof(esp_adc_cal_characteristics_t));
esp_adc_cal_characterize(ADC_UNIT_1, ADC_ATTEN_DB_11, width, DEFAULT_VREF, adc_chars);
*/
#ifdef TWOPART
if(!LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED, "/lfs2", 5, "part2")){
Serial.println("part2 Mount Failed");
return;
}
appendFile(LittleFS, "/hello0.txt", "World0!rn");
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!rn");
readFile(LittleFS, "/hello.txt");
renameFile(LittleFS, "/hello.txt", "/foo.txt");
readFile(LittleFS, "/foo.txt");
deleteFile(LittleFS, "/foo.txt");
deleteFile(LittleFS, "/test.txt");
uint16_t sample = adc1_get_raw(ADC1_CHANNEL_7);
Serial.print("ADC Sample: ");
Serial.println(sample);
testFileIO(LittleFS, "/test.txt");
deleteFile(LittleFS, "/test.txt");
Serial.println( "Test complete" );
}
void loop(){
}
By the way, I first encountered the problem using MacOS with Arduino IDE 1.8.19. I did not use the board manager to add the files for the qt-py-esp32s2 but used the github repository as recomended by Adafruit.
Today I did a clean installation of the IDE and all dependencies on a Win10 System. The error remains the same and is 100% replicable.
I assume that there is some collision between the "LittleFS" library and the esp32s2 board files.
If the code would always fail, that would be comprehensible. But not failing before saving and failing after saving the sketch doesn´t make sense to me.
Thanks and best regards