Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

ESP32-S3 SD NAND openNextFile returning no directories at top level #8870

Open
1 task done
frankcohen opened this issue Nov 11, 2023 · 1 comment
Open
1 task done

ESP32-S3 SD NAND openNextFile returning no directories at top level #8870

frankcohen opened this issue Nov 11, 2023 · 1 comment
Labels
Status: Awaiting triage Issue is waiting for triage

Comments

@frankcohen
Copy link

Board

Reflections board, ESP32-S3 Dev Module compatible

Device Description

Reflections is my open-source ESP32-S3-Mini-1 based board for building mobile entertainment experiences. It has a NAND (SMT form of an SD) onboard.
screenshot_8381
The NAND comes pre-formatted with Fat16.

Hardware Configuration

SPI bus:
#define SPI_MOSI 35
#define SPI_MISO 37
#define SPI_SCK 36

Nand on the SPI bus:
#define NAND_SPI_CS 15

TFT display on an SPI bus:

#define Display_SPI_CS 12
#define Display_SPI_DC 5
#define Display_SPI_RST 0
#define Display_SPI_BK 6

GPS module:
#define RXPin 18
#define TXPin 17
#define GPSPower 21

// Audio
#define I2S_bclkPinP 9
#define I2S_wclkPinP 10
#define I2S_doutPinP 8
#define AudioPower 7

// I2C bus
#define I2CSDA 3
#define I2CSCL 4

Version

v2.0.14

IDE Name

Arduino IDE 2.2.1

Operating System

MacOS 13.3.1 (Ventura)

Flash frequency

80 Mhz

PSRAM enabled

yes

Upload speed

115200

Description

Using File file = root.openNextFile(); to iteratue through files and directories stored on the NAND/SD Fat 16 device. The top level, openNextFile does not return any directorie.

Starting
- - -
SD Card Type: SDSC
SD Card Size: 122MB
Deleting file: /223a0920536e7b99beef941169975c84.tar
File deleted
Creating Dir: /mydir
Dir created
Writing file: /mydir/hello.txt
File written
Creating Dir: /mydir/dir2
Dir created
Writing file: /mydir/dir2/hello2.txt
File written
--- listDir 1---
Listing directory: /mydir
  FILE: hello.txt  SIZE: 6
  DIR : dir2
Listing directory: /mydir/dir2
  FILE: hello2.txt  SIZE: 6
done
---ListDir 2---
Writing file: /hello.txt
File written
Reading file: /hello.txt
Read from file: Hello at the top 
Listing directory: /
done

Sketch

#include "FS.h"
#include "SD.h"
#include "SPI.h"

#define SD_CS_PIN 15

#define SPI_MOSI      35
#define SPI_MISO      37
#define SPI_SCK       36

// Display
#define Display_SPI_DC    5
#define Display_SPI_CS    12
#define Display_SPI_RST   0
#define Display_SPI_BK    6

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.println(file.name());
            if(levels){
                listDir(fs, file.path(), levels -1);
            }
        } else {
            Serial.print("  FILE: ");
            Serial.print(file.name());
            Serial.print("  SIZE: ");
            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\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 testFileIO(fs::FS &fs, const char * path){
    File file = fs.open(path);
    static uint8_t buf[512];
    size_t len = 0;
    uint32_t start = millis();
    uint32_t end = start;
    if(file){
        len = file.size();
        size_t flen = len;
        start = millis();
        while(len){
            size_t toRead = len;
            if(toRead > 512){
                toRead = 512;
            }
            file.read(buf, toRead);
            len -= toRead;
        }
        end = millis() - start;
        Serial.printf("%u bytes read for %u ms\n", flen, end);
        file.close();
    } else {
        Serial.println("Failed to open file for reading");
    }


    file = fs.open(path, FILE_WRITE);
    if(!file){
        Serial.println("Failed to open file for writing");
        return;
    }

    size_t i;
    start = millis();
    for(i=0; i<2048; i++){
        file.write(buf, 512);
    }
    end = millis() - start;
    Serial.printf("%u bytes written for %u ms\n", 2048 * 512, end);
    file.close();
}

void setup(){
    Serial.begin(115200);
    delay(2000);
    Serial.println( "Starting" );

    SPI.begin(SPI_SCK, SPI_MISO, SPI_MOSI, -1);

    pinMode(SD_CS_PIN, OUTPUT );
    digitalWrite(SD_CS_PIN, LOW);

    pinMode(Display_SPI_CS, OUTPUT);
    digitalWrite(Display_SPI_CS, LOW);

    pinMode(Display_SPI_DC, OUTPUT);
    digitalWrite(Display_SPI_DC, HIGH);

    pinMode(Display_SPI_RST, OUTPUT);
    digitalWrite(Display_SPI_RST, HIGH);

    pinMode(Display_SPI_BK, OUTPUT);
    digitalWrite(Display_SPI_BK, LOW);


    Serial.println( "- - -" );

    if( !SD.begin( SD_CS_PIN ) ){
        Serial.println("Card Mount Failed");
        return;
    }
    uint8_t cardType = SD.cardType();

    if(cardType == CARD_NONE){
        Serial.println("No SD card attached");
        return;
    }

    Serial.print("SD Card Type: ");
    if(cardType == CARD_MMC){
        Serial.println("MMC");
    } else if(cardType == CARD_SD){
        Serial.println("SDSC");
    } else if(cardType == CARD_SDHC){
        Serial.println("SDHC");
    } else {
        Serial.println("UNKNOWN");
    }

    uint64_t cardSize = SD.cardSize() / (1024 * 1024);
    Serial.printf("SD Card Size: %lluMB\n", cardSize);

    deleteFile(SD, "/223a0920536e7b99beef941169975c84.tar");


    createDir(SD, "/mydir");
    writeFile(SD, "/mydir/hello.txt", "Hello ");
    createDir(SD, "/mydir/dir2");
    writeFile(SD, "/mydir/dir2/hello2.txt", "Hello ");
    Serial.println("--- listDir 1---");
    listDir(SD, "/mydir", 100);
    Serial.println("done");

    Serial.println("---ListDir 2---");
    writeFile(SD, "/hello.txt", "Hello at the top");
    readFile(SD, "/hello.txt");
    Serial.println( " " );
    listDir(SD, "/", 100);
    Serial.println("done");






/*
    createDir(SD, "/mydir1");
    writeFile(SD, "/mydir1/hello.txt", "Hello ");
    createDir(SD, "/mydir2");
    writeFile(SD, "/mydir1/hello.txt", "Hello ");
    createDir(SD, "/mydir3");
    writeFile(SD, "/mydir1/hello.txt", "Hello ");

    Serial.println("ListDir 3:");
    listDir(SD, "/mydir1", 3);
    Serial.println("ListDir done");
    Serial.println("ListDir: 4");
    listDir(SD, "/", 100);
    Serial.println("ListDir done");

    removeDir(SD, "/mydir");

    Serial.println("ListDir:");
    listDir(SD, "/", 0);
    Serial.println("ListDir done");

    writeFile(SD, "/hello.txt", "Hello ");
    appendFile(SD, "/hello.txt", "World!\n");
    readFile(SD, "/hello.txt");
    deleteFile(SD, "/foo.txt");
    renameFile(SD, "/hello.txt", "/foo.txt");
    readFile(SD, "/foo.txt");
    testFileIO(SD, "/test.txt");
    Serial.printf("Total space: %lluMB\n", SD.totalBytes() / (1024 * 1024));
    Serial.printf("Used space: %lluMB\n", SD.usedBytes() / (1024 * 1024));
    Serial.println("ListDir:");
    listDir(SD, "/", 0);
    Serial.println("ListDir done");
*/

}

void loop(){

}

Debug Message

None, see Serial Monitor output

Other Steps to Reproduce

None. However the work around appears to be putting the needed files and directory structure into a subdirectory of the root. openNextFile returns the file and directories inside the root ddirectory.

I have checked existing issues, online documentation and the Troubleshooting Guide

  • I confirm I have checked existing issues, online documentation and Troubleshooting guide.
@frankcohen frankcohen added the Status: Awaiting triage Issue is waiting for triage label Nov 11, 2023
@frankcohen
Copy link
Author

The entire repository, including Gerber, schematic, example code is at https://github.com/frankcohen/ReflectionsOS

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
Status: Awaiting triage Issue is waiting for triage
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
1 participant
@frankcohen