"Card mount failed" on ESP32 but works on Arduino

I've been trying to make a micro SD card module works on my ESP32 (30 pins) by all possible ways, but I always receive the message "Card mount failed" when running the "SD_test" example, or any other code to teste the module.

I've read lots of sollutions, tutorials, and tips, but nothing really helped me. So what I've done so far:

  • Used the 3.3V and VIN pins from ESP, and also tried with an external regulated power supply (3.3V and 5V) to be sure the module gets whats it needs;
  • Verified the voltages and guanrantee that every pin has electric contact between ESP and the module;
  • Tried to especify the pins i'm using in code by creating a SPI class (MISO: 23, MOSI: 19, SCK: 18, SS: 5), and even used another SPI "channel" (not sure if that's the name), like HSPI;
  • Tested the module with Arduino UNO and Nano boards, and it worked (though the SD card is SDHC, but the arduino boards recognize it's there), so i'm very confident it's not a problem with the module;
  • And finally, I bought a logic level converter to test if it was some kind of incompatibility with the 3.3V level from ESP, but also not worked.

The module is exacly like this one.

So, if i'm doing something wrong, or if there's any sugestions, i'm really open to anything.

code?

Thats the "SD_test" example on the SD(esp32) lib i'm using:

/*
 * 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"

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.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\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);
    if(!SD.begin(5)){
        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);

    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\n", SD.totalBytes() / (1024 * 1024));
    Serial.printf("Used space: %lluMB\n", SD.usedBytes() / (1024 * 1024));
}

void loop(){

}

Have you tried another sd card ? maybe yours is broken?

I've never done this, but found a Youtube video that looks pretty good.

https://www.youtube.com/watch?v=e1xOgZsnAuw

Thats odd.

The SD card holder you showed looks like the correct one for 3.3V logic, use that module on a 5V Arduino or Nano and there is a chance you will damage the micro SD cards, they are 3.3V only.

I'm getting a new one to test, but even if the card is broken, the message shouldn't be "No card attached"?

I don't think the card is broken cause when I test it on Arduino, it shows the wiring is ok and the type of formatting (SDHC). Is this supposed to happen even with a corrupted/burned card?
I'm getting a new one to make sure

Who knows, but the starting point is that the example code does work, so when it does not work, you need to look at whats different.

The SD card reader may not be a 3V3 if its working on a 5V device but not 3V3.

I thought that could be this, but I tried using a logic level converter (like this one) and regulated power supplies.

After all, the card was corrupted.
I was convinced it was working fine but, when I tried to format on my computer it just doesn't make it. So, with a new card, the module finally worked correctly.

Now, I'm not sure if the tests on 5V did this, or, the card was already broken, because I've used it sometimes in other projects and worked well.

But anyway, thanks for everyone.

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.