Problems Initializing SD Card on ESP32 (AZDelivery) using VSPI Interface

Projects Networking, Protocols, and Devices
1

I'm currently working on a project involving an ESP32 (AZDelivery but I also tried several other ESP Boards like Heltec Wifi Kit V3 and a nonage ESP Wroom 32) and I am facing issues with initializing the SD card using the VSPI interface (It was working with the Arduino Nano just finde, unfortuanlly with the nano my GPS was not working :D). Here is a brief overview of my setup and the code I am using for the SD card initialization.

Hardware Connections:

  • SD Card Interface (VSPI)
    • MISO: GPIO 19
    • MOSI: GPIO 23
    • SCK: GPIO 18
    • CS: GPIO 5

Problem Description:

The initialization of the SD card fails. The serial monitor outputs "SD card initialization failed!" during the setup process. Below is the relevant section of my code where the SD card is initialized.

Code Snippet:

// Pin Definitions for VSPI
#define PIN_MISO 19  // VSPI MISO
#define PIN_MOSI 23  // VSPI MOSI
#define PIN_SCK  18  // VSPI SCK
#define PIN_CS   5   // CS for SD card, set to GPIO 5

void setup() {
    Serial.begin(9600);
    while (!Serial);  // Wait until serial is ready
    Serial.println("Serial initialized");

    // SPI for SD card initialization
    Serial.println("Initializing SD card...");
    if (!SD.begin(PIN_CS)) {
        Serial.println("SD card initialization failed!");
    } else {
        Serial.println("SD card initialized successfully.");
        sdCardInitialized = true;
    }
}

It will always show "SD card initialization failed!"...

Troubleshooting Steps Taken:

  1. Checked the wiring connections multiple times to ensure proper connections.
  2. Tried different SD cards to rule out the possibility of a faulty card (even though it works on my Nano with SDFat-library just fine)
  3. Verified the correct pin assignments for the VSPI interface.
2

your connections VSPI to SD card look OK - I have used these without problems
how do you power the SD card reader?
also have a look at esp32-microsd-card-arduino

3

Hi Horace,

I'm powering the AZ Delivery SD card reader through the ESP32 at 3.3V. I'll check out the esp32-microsd-card-arduino link you mentioned but I think I already browsed through it. Any specific advice or common issues I should watch for? Could it be the size of 32 Gb? According to different posts, this should be fine?

4

Did you try asking chatai for code ??. Try once with specify models. Try making server on esp32. To check if sd card works.

SD Card Module to ESP32:
VCC → 3.3V
GND → GND
MISO → GPIO 19
MOSI → GPIO 23
SCK → GPIO 18
CS → GPIO 5 (or any other GPIO you choose)
Make sure to set the correct CS pin in your code!

#include #include

const int chipSelect = 5; // Pin connected to SD card module's CS pin

void setup() {
Serial.begin(115200);
while (!Serial) {
; // Wait for serial port to connect
}

if (!SD.begin(chipSelect)) {
Serial.println("Initialization failed!");
return;
}

Serial.println("Initialization done.");

int fileCount = 0;
int itemCount = 0;

countFiles(SD.open("/"), fileCount, itemCount);

Serial.print("Number of files: ");
Serial.println(fileCount);
Serial.print("Total items (files and directories): ");
Serial.println(itemCount);
}

void loop() {
// Nothing to do here
}

void countFiles(File dir, int &fileCount, int &itemCount) {
while (true) {
File entry = dir.openNextFile();
if (!entry) {
break; // No more files
}

itemCount++; // Count the item (file or directory)

if (entry.isDirectory()) {
  countFiles(entry, fileCount, itemCount); // Recursively count files in directories
} else {
  fileCount++; // Count the file
}

entry.close();

}
}

5

this is the test code I used on an ESP32
note the 5V supply to SD card (it does not work with 3.3V)

/*
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/esp32-microsd-card-arduino/
  
  This sketch can be found at: Examples > SD(esp32) > SD_Test
*/

// ESP32 connections
// ESP32 SCK pin GPIO18  to SD card  SCK
// ESP32 MISO pin GPIO19  to SD card  MISO
// ESP32 MOSI pin GPIO23  to SD card  MOSI
// ESP32 SS  pin GPIO 5   to SD card SS
// ESP32 5V to SD VCC and GND to GND

#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(){

}

test with a 32G SD card

  FILE: start4db.elf  SIZE: 3746856
  FILE: start4x.elf  SIZE: 2998120
  FILE: fixup4.dat  SIZE: 5400
  FILE: fixup4cd.dat  SIZE: 3170
  FILE: fixup4db.dat  SIZE: 8382
  DIR : System Volume Information
Listing directory: System Volume Information
Failed to open directory
  FILE: fixup4x.dat  SIZE: 8386
  FILE: LICENCE.broadcom  SIZE: 1594
Writing file: /hello.txt
File written
Appending to file: /hello.txt
Message appended
Reading file: /hello.txt
Read from file: Hello World!
Deleting file: /foo.txt
Delete failed
Renaming file /hello.txt to /foo.txt
File renamed
Reading file: /foo.txt
Read from file: Hello World!
Failed to open file for reading
1048576 bytes written for 3052 ms
Total space: 254MB
Used space: 31MB
6

Thank you guys for your help. It is working now. :slight_smile:

7

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