ESP32-S3 failed to mount SD on HSPI #7565

schultzgc · 2022-12-09T08:49:30Z

schultzgc
Dec 9, 2022

I am at a bit of a loss. I'm trying to mount a SD card with the ESP32-S3 DEVKIT for days, unfortunately without success.
With past ESP32 I never had this problem. Has anyone already been able to successfully connect an SD card via HSPI?`

Below is my code:

/*
 * Connect the SD card to the following pins:
 *
 * SD Card | ESP32
 *    D2       -
 *    D3       SS
 *    CMD      MOSI
 *    VSS      GND
 *    VDD      3.3V
 *    CLK      SCK
 *    VSS      GND
 *    D0       MISO
 *    D1       -
 */
#include "FS.h"
#include "SD.h"
#include "SPI.h"

#if CONFIG_IDF_TARGET_ESP32

#define SD_SCK  GPIO_NUM_14
#define SD_MISO GPIO_NUM_12
#define SD_MOSI GPIO_NUM_13
#define SD_SS   GPIO_NUM_15

#elif CONFIG_IDF_TARGET_ESP32S3

#define SD_SCK  GPIO_NUM_14
#define SD_MISO GPIO_NUM_12
#define SD_MOSI GPIO_NUM_13 
#define SD_SS   GPIO_NUM_5

#else
#error Board not found!
#endif

SPIClass * hspi = NULL;

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);
//                listDir(fs, file.name(), 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\r\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\r\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){
        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\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){
    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\r\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\r\n", 2048 * 512, end);
    file.close();
}

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

    hspi = new SPIClass(HSPI);
    hspi->begin(SD_SCK, SD_MISO, SD_MOSI, SD_SS);
}

#define SD_SPI_FREQ 1000000
//#define SD_SPI_FREQ 4000000
//#define SD_SPI_FREQ 25000000

bool testSD()
{
    Serial.printf("Trying mount of SD card at freq %u...\r\n", SD_SPI_FREQ);
    if(!SD.begin(SD_SS, *hspi, SD_SPI_FREQ)) {
        Serial.println("Card Mount Failed");
        return false;
    }
    uint8_t cardType = SD.cardType();

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

    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\r\n", cardSize);

    listDir(SD, "/", 0);
    createDir(SD, "/mydir");
    listDir(SD, "/", 0);
    removeDir(SD, "/mydir");
    listDir(SD, "/", 2);
    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\r\n", SD.totalBytes() / (1024 * 1024));
    Serial.printf("Used space: %lluMB\r\n", SD.usedBytes() / (1024 * 1024));

    return true;
}

void loop(){
  bool ok;

  ok = testSD();
  if (ok) {
    Serial.println("OK");
  } else {
    Serial.println("FAIL");
  }
  delay(5000);
}

Answered by P-R-O-C-H-Y

Jan 5, 2023

Hi @schultzgc, I have no issues running SD card on ESP32S3 with your pins setup, but I have slightly edited your code and I left the original lines commented. Can you give it a try?

/*
 * Connect the SD card to the following pins:
 *
 * SD Card | ESP32
 *    D2       -
 *    D3       SS
 *    CMD      MOSI
 *    VSS      GND
 *    VDD      3.3V
 *    CLK      SCK
 *    VSS      GND
 *    D0       MISO
 *    D1       -
 */
#include "FS.h"
#include "SD.h"
#include "SPI.h"

#if CONFIG_IDF_TARGET_ESP32

#define SD_SCK  GPIO_NUM_14
#define SD_MISO GPIO_NUM_12
#define SD_MOSI GPIO_NUM_13
#define SD_SS   GPIO_NUM_15

#elif CONFIG_IDF_TARGET_ESP32S3

#define SD_SCK  GPIO_NUM_14
#define SD_MISO GP…

View full answer

me-no-dev · 2022-12-09T12:51:16Z

me-no-dev
Dec 9, 2022
Maintainer

You should call SD.begin() once in setup(), not every loop. You did not post any serial output?

3 replies

schultzgc Dec 9, 2022
Author

Unfortunately, this is not the solution to the problem.

me-no-dev Dec 9, 2022
Maintainer

you did not give any logs, so everything we can do is just guess. In any case, calling SD.begin() in a loop is never a good idea.

schultzgc Dec 9, 2022
Author

Serial output is:

Card Mount Failed
FAIL

me-no-dev · 2022-12-12T11:05:55Z

me-no-dev
Dec 12, 2022
Maintainer

@P-R-O-C-H-Y would you please have a look?

0 replies

P-R-O-C-H-Y · 2023-01-05T14:06:49Z

P-R-O-C-H-Y
Jan 5, 2023
Maintainer

Hi @schultzgc, I have no issues running SD card on ESP32S3 with your pins setup, but I have slightly edited your code and I left the original lines commented. Can you give it a try?

/*
 * Connect the SD card to the following pins:
 *
 * SD Card | ESP32
 *    D2       -
 *    D3       SS
 *    CMD      MOSI
 *    VSS      GND
 *    VDD      3.3V
 *    CLK      SCK
 *    VSS      GND
 *    D0       MISO
 *    D1       -
 */
#include "FS.h"
#include "SD.h"
#include "SPI.h"

#if CONFIG_IDF_TARGET_ESP32

#define SD_SCK  GPIO_NUM_14
#define SD_MISO GPIO_NUM_12
#define SD_MOSI GPIO_NUM_13
#define SD_SS   GPIO_NUM_15

#elif CONFIG_IDF_TARGET_ESP32S3

#define SD_SCK  GPIO_NUM_14
#define SD_MISO GPIO_NUM_12
#define SD_MOSI GPIO_NUM_13 
#define SD_SS   GPIO_NUM_5

#else
#error Board not found!
#endif

//SPIClass * hspi = NULL;
SPIClass hspi = SPIClass(HSPI);

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);
//                listDir(fs, file.name(), 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\r\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\r\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){
        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\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){
    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\r\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\r\n", 2048 * 512, end);
    file.close();
}

#define SD_SPI_FREQ 1000000
//#define SD_SPI_FREQ 4000000
//#define SD_SPI_FREQ 25000000


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

    //hspi = new SPIClass(HSPI);
    //hspi->begin(SD_SCK, SD_MISO, SD_MOSI, SD_SS);
    hspi.begin(SD_SCK, SD_MISO, SD_MOSI, SD_SS);

    if(!SD.begin(SD_SS, hspi, SD_SPI_FREQ)){
        Serial.println("Card Mount Failed");
        return;
    }

    testSD();

    SD.end();
}


bool testSD()
{
    /*
    Serial.printf("Trying mount of SD card at freq %u...\r\n", SD_SPI_FREQ);
    if(!SD.begin(SD_SS, *hspi, SD_SPI_FREQ)) {
        Serial.println("Card Mount Failed");
        return false;
    }
    */
    uint8_t cardType = SD.cardType();

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

    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\r\n", cardSize);

    listDir(SD, "/", 0);
    createDir(SD, "/mydir");
    listDir(SD, "/", 0);
    removeDir(SD, "/mydir");
    listDir(SD, "/", 2);
    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\r\n", SD.totalBytes() / (1024 * 1024));
    Serial.printf("Used space: %lluMB\r\n", SD.usedBytes() / (1024 * 1024));

    return true;
}

void loop(){
  /*
  bool ok;

  ok = testSD();
  if (ok) {
    Serial.println("OK");
  } else {
    Serial.println("FAIL");
  }
  */
  delay(5000);
}

1 reply

vanshksingh May 8, 2024

Totally works with Cardputer from M5 Stamp too , ESP32S3

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

ESP32-S3 failed to mount SD on HSPI #7565

{{title}}

{{editor}}'s edit

{{editor}}'s edit

Replies: 3 comments 4 replies

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

Select a reply

ESP32-S3 failed to mount SD on HSPI #7565

schultzgc Dec 9, 2022

Replies: 3 comments · 4 replies

me-no-dev Dec 9, 2022 Maintainer

schultzgc Dec 9, 2022 Author

me-no-dev Dec 9, 2022 Maintainer

schultzgc Dec 9, 2022 Author

me-no-dev Dec 12, 2022 Maintainer

P-R-O-C-H-Y Jan 5, 2023 Maintainer

vanshksingh May 8, 2024

schultzgc
Dec 9, 2022

Replies: 3 comments 4 replies

me-no-dev
Dec 9, 2022
Maintainer

schultzgc Dec 9, 2022
Author

me-no-dev Dec 9, 2022
Maintainer

schultzgc Dec 9, 2022
Author

me-no-dev
Dec 12, 2022
Maintainer

P-R-O-C-H-Y
Jan 5, 2023
Maintainer