SD Card Test ->SD card is not connected or unusable :-(

I have teensy 4.0 with Audio Adaptor Board rev D, and the SanDisk Ultra SDHC UHS-I Card 16G with the 4 Wave exemples files in

I run the sketch: Sd Card Test
the code of this sketch follows
And I only got the message :SD card is not connected or unusable :-(
on the terminal

Other Sktech work well Like :
Part_2_03_Samples
Part_2_08_Oscillators



DSC_0561.jpg

4 files on the micro Sd
files.png

sdcard.jpg

the card is formatted fat32
carte.png


Here is the code I Upload:

// SD Card Test
//
// Check if the SD card on the Audio Shield is working,
// and perform some simple speed measurements to gauge
// its ability to play 1, 2, 3 and 4 WAV files at a time.
//
// Requires the audio shield:
// http://www.pjrc.com/store/teensy3_audio.html
//
// Data files to put on your SD card can be downloaded here:
// http://www.pjrc.com/teensy/td_libs_AudioDataFiles.html
//
// This example code is in the public domain.

#include <SD.h>
#include <SPI.h>

// Use these with the Teensy Audio Shield
#define SDCARD_CS_PIN 10
#define SDCARD_MOSI_PIN 7
#define SDCARD_SCK_PIN 14

// Use these with the Teensy 3.5 & 3.6 SD card
//#define SDCARD_CS_PIN BUILTIN_SDCARD
//#define SDCARD_MOSI_PIN 11 // not actually used
//#define SDCARD_SCK_PIN 13 // not actually used

// Use these for the SD+Wiz820 or other adaptors
//#define SDCARD_CS_PIN 4
//#define SDCARD_MOSI_PIN 11
//#define SDCARD_SCK_PIN 13

void setup() {
Sd2Card card;
SdVolume volume;
File f1, f2, f3, f4;
char buffer[512];
boolean status;
unsigned long usec, usecMax;
elapsedMicros usecTotal, usecSingle;
int i, type;
float size;

// wait for the Arduino Serial Monitor to open
while (!Serial) ;
delay(50);

// Configure SPI
SPI.setMOSI(SDCARD_MOSI_PIN);
SPI.setSCK(SDCARD_SCK_PIN);

Serial.begin(9600);
Serial.println("SD Card Test");
Serial.println("------------");

// First, detect the card
status = card.init(SPI_FULL_SPEED, SDCARD_CS_PIN);
if (status) {
Serial.println("SD card is connected :)");
} else {
Serial.println("SD card is not connected or unusable :-(");
return;
}

type = card.type();
if (type == SD_CARD_TYPE_SD1 || type == SD_CARD_TYPE_SD2) {
Serial.println("Card type is SD");
} else if (type == SD_CARD_TYPE_SDHC) {
Serial.println("Card type is SDHC");
} else {
Serial.println("Card is an unknown type (maybe SDXC?)");
}

// Then look at the file system and print its capacity
status = volume.init(card);
if (!status) {
Serial.println("Unable to access the filesystem on this card. :-(");
return;
}

size = volume.blocksPerCluster() * volume.clusterCount();
size = size * (512.0 / 1e6); // convert blocks to millions of bytes
Serial.print("File system space is ");
Serial.print(size);
Serial.println(" Mbytes.");

// Now open the SD card normally
status = SD.begin(SDCARD_CS_PIN);
if (status) {
Serial.println("SD library is able to access the filesystem");
} else {
Serial.println("SD library can not access the filesystem!");
Serial.println("Please report this problem, with the make & model of your SD card.");
Serial.println(" http://forum.pjrc.com/forums/4-Suggestions-amp-Bug-Reports");
}


// Open the 4 sample files. Hopefully they're on the card
f1 = SD.open("SDTEST1.WAV");
f2 = SD.open("SDTEST2.WAV");
f3 = SD.open("SDTEST3.WAV");
f4 = SD.open("SDTEST4.WAV");

// Speed test reading a single file
if (f1) {
Serial.println();
Serial.println("Reading SDTEST1.WAV:");
if (f1.size() >= 514048) {
usecMax = 0;
usecTotal = 0;
for (i=0; i < 1000; i++) {
usecSingle = 0;
f1.read(buffer, 512);
usec = usecSingle;
if (usec > usecMax) usecMax = usec;
}
reportSpeed(1, 1000, usecTotal, usecMax);
} else {
Serial.println("SDTEST1.WAV is too small for speed testing");
}
} else {
Serial.println("Unable to find SDTEST1.WAV on this card");
return;
}

// Speed test reading two files
if (f2) {
Serial.println();
Serial.println("Reading SDTEST1.WAV & SDTEST2.WAV:");
if (f2.size() >= 514048) {
f1.seek(0);
usecMax = 0;
usecTotal = 0;
for (i=0; i < 1000; i++) {
usecSingle = 0;
f1.read(buffer, 512);
f2.read(buffer, 512);
usec = usecSingle;
if (usec > usecMax) usecMax = usec;
}
reportSpeed(2, 1000, usecTotal, usecMax);

Serial.println();
Serial.println("Reading SDTEST1.WAV & SDTEST2.WAV staggered:");
f1.seek(0);
f2.seek(0);
f1.read(buffer, 512);
usecMax = 0;
usecTotal = 0;
for (i=0; i < 1000; i++) {
usecSingle = 0;
f1.read(buffer, 512);
f2.read(buffer, 512);
usec = usecSingle;
if (usec > usecMax) usecMax = usec;
}
reportSpeed(2, 1000, usecTotal, usecMax);
} else {
Serial.println("SDTEST2.WAV is too small for speed testing");
}
} else {
Serial.println("Unable to find SDTEST2.WAV on this card");
return;
}


// Speed test reading three files
if (f3) {
Serial.println();
Serial.println("Reading SDTEST1.WAV, SDTEST2.WAV, SDTEST3.WAV:");
if (f3.size() >= 514048) {
f1.seek(0);
f2.seek(0);
usecMax = 0;
usecTotal = 0;
for (i=0; i < 1000; i++) {
usecSingle = 0;
f1.read(buffer, 512);
f2.read(buffer, 512);
f3.read(buffer, 512);
usec = usecSingle;
if (usec > usecMax) usecMax = usec;
}
reportSpeed(3, 1000, usecTotal, usecMax);

Serial.println();
Serial.println("Reading SDTEST1.WAV, SDTEST2.WAV, SDTEST3.WAV staggered:");
f1.seek(0);
f2.seek(0);
f3.seek(0);
f1.read(buffer, 512);
f1.read(buffer, 512);
f2.read(buffer, 512);
usecMax = 0;
usecTotal = 0;
for (i=0; i < 1000; i++) {
usecSingle = 0;
f1.read(buffer, 512);
f2.read(buffer, 512);
f3.read(buffer, 512);
usec = usecSingle;
if (usec > usecMax) usecMax = usec;
}
reportSpeed(3, 1000, usecTotal, usecMax);
} else {
Serial.println("SDTEST3.WAV is too small for speed testing");
}
} else {
Serial.println("Unable to find SDTEST3.WAV on this card");
return;
}


// Speed test reading four files
if (f4) {
Serial.println();
Serial.println("Reading SDTEST1.WAV, SDTEST2.WAV, SDTEST3.WAV, SDTEST4.WAV:");
if (f4.size() >= 514048) {
f1.seek(0);
f2.seek(0);
f3.seek(0);
usecMax = 0;
usecTotal = 0;
for (i=0; i < 1000; i++) {
usecSingle = 0;
f1.read(buffer, 512);
f2.read(buffer, 512);
f3.read(buffer, 512);
f4.read(buffer, 512);
usec = usecSingle;
if (usec > usecMax) usecMax = usec;
}
reportSpeed(4, 1000, usecTotal, usecMax);

Serial.println();
Serial.println("Reading SDTEST1.WAV, SDTEST2.WAV, SDTEST3.WAV, SDTEST4.WAV staggered:");
f1.seek(0);
f2.seek(0);
f3.seek(0);
f4.seek(0);
f1.read(buffer, 512);
f1.read(buffer, 512);
f1.read(buffer, 512);
f2.read(buffer, 512);
f2.read(buffer, 512);
f3.read(buffer, 512);
usecMax = 0;
usecTotal = 0;
for (i=0; i < 1000; i++) {
usecSingle = 0;
f1.read(buffer, 512);
f2.read(buffer, 512);
f3.read(buffer, 512);
f4.read(buffer, 512);
usec = usecSingle;
if (usec > usecMax) usecMax = usec;
}
reportSpeed(4, 1000, usecTotal, usecMax);
} else {
Serial.println("SDTEST4.WAV is too small for speed testing");
}
} else {
Serial.println("Unable to find SDTEST4.WAV on this card");
return;
}

}


unsigned long maximum(unsigned long a, unsigned long b,
unsigned long c, unsigned long d)
{
if (b > a) a = b;
if (c > a) a = c;
if (d > a) a = d;
return a;
}


void reportSpeed(unsigned int numFiles, unsigned long blockCount, unsigned long usecTotal, unsigned long usecMax)
{
float bytesPerSecond = (float)(blockCount * 512 * numFiles) / usecTotal;
Serial.print(" Overall speed = ");
Serial.print(bytesPerSecond);
Serial.println(" Mbyte/sec");
Serial.print(" Worst block time = ");
Serial.print((float)usecMax / 1000.0);
Serial.println(" ms");
Serial.print(" ");
Serial.print( (float)usecMax / 29.01333);
Serial.println("% of audio frame time");
}


void loop(void) {
// do nothing after the test
}
 
I just successfully ran the SdCardTest sketch on the sd adapter of a rev.C audioshield connected to a T4.0 with the modified spi pin definitions.

Did you check the connections of pins 10, 11, 12, 13 between the teensy and the auidioshield with a multimeter?

Code:
SD Card Test
------------
SD card is connected :-)
Card type is SDHC
File system space is 15560.87 Mbytes.
SD library is able to access the filesystem

Reading SDTEST1.WAV:
  Overall speed = 0.73 Mbyte/sec
  Worst block time = 1.38 ms
    47.60% of audio frame time

Reading SDTEST1.WAV & SDTEST2.WAV:
  Overall speed = 0.51 Mbyte/sec
  Worst block time = 3.34 ms
    115.19% of audio frame time

Reading SDTEST1.WAV & SDTEST2.WAV staggered:
  Overall speed = 0.51 Mbyte/sec
  Worst block time = 2.77 ms
    95.37% of audio frame time

Reading SDTEST1.WAV, SDTEST2.WAV, SDTEST3.WAV:
  Overall speed = 0.55 Mbyte/sec
  Worst block time = 5.04 ms
    173.54% of audio frame time

Reading SDTEST1.WAV, SDTEST2.WAV, SDTEST3.WAV staggered:
  Overall speed = 0.55 Mbyte/sec
  Worst block time = 3.93 ms
    135.32% of audio frame time

Reading SDTEST1.WAV, SDTEST2.WAV, SDTEST3.WAV, SDTEST4.WAV:
  Overall speed = 0.57 Mbyte/sec
  Worst block time = 6.72 ms
    231.62% of audio frame time

Reading SDTEST1.WAV, SDTEST2.WAV, SDTEST3.WAV, SDTEST4.WAV staggered:
  Overall speed = 0.56 Mbyte/sec
  Worst block time = 4.79 ms
    164.92% of audio frame time
 
I just successfully ran the SdCardTest sketch on the sd adapter of a rev.C audioshield connected to a T4.0 with the modified spi pin definitions.

Did you check the connections of pins 10, 11, 12, 13 between the teensy and the auidioshield with a multimeter?

Yes I just did and the connections are OK.
Maybe it's the SD Card that is not compatible, I did try with 2 others card : a core micro 2gb and a Kinsgten 32 gb without success.
 
Are these the pins on the audio sheild or the teensy itself?

I just successfully ran the SdCardTest sketch on the sd adapter of a rev.C audioshield connected to a T4.0 with the modified spi pin definitions.

Did you check the connections of pins 10, 11, 12, 13 between the teensy and the auidioshield with a multimeter?

Code:
SD Card Test
------------
SD card is connected :-)
Card type is SDHC
File system space is 15560.87 Mbytes.
SD library is able to access the filesystem

Reading SDTEST1.WAV:
  Overall speed = 0.73 Mbyte/sec
  Worst block time = 1.38 ms
    47.60% of audio frame time

Reading SDTEST1.WAV & SDTEST2.WAV:
  Overall speed = 0.51 Mbyte/sec
  Worst block time = 3.34 ms
    115.19% of audio frame time

Reading SDTEST1.WAV & SDTEST2.WAV staggered:
  Overall speed = 0.51 Mbyte/sec
  Worst block time = 2.77 ms
    95.37% of audio frame time

Reading SDTEST1.WAV, SDTEST2.WAV, SDTEST3.WAV:
  Overall speed = 0.55 Mbyte/sec
  Worst block time = 5.04 ms
    173.54% of audio frame time

Reading SDTEST1.WAV, SDTEST2.WAV, SDTEST3.WAV staggered:
  Overall speed = 0.55 Mbyte/sec
  Worst block time = 3.93 ms
    135.32% of audio frame time

Reading SDTEST1.WAV, SDTEST2.WAV, SDTEST3.WAV, SDTEST4.WAV:
  Overall speed = 0.57 Mbyte/sec
  Worst block time = 6.72 ms
    231.62% of audio frame time

Reading SDTEST1.WAV, SDTEST2.WAV, SDTEST3.WAV, SDTEST4.WAV staggered:
  Overall speed = 0.56 Mbyte/sec
  Worst block time = 4.79 ms
    164.92% of audio frame time

I am having a similar issue and have the 2 boards connected as per https://forum.pjrc.com/attachment.php?attachmentid=17212&d=1565797918 this diagram but these are the only conncections i have.

using Teensy 4.1 and Audiosheild Rev C
 
That diagram is missing 3 of the 4 wires you need for the SD card on the audio shield to work, and 1 of the 4 wires appear to be shown connected to the wrong place.

The 4 connections you need are:

pin 10 to SDCS - missing from diagram
pin 11 to MOSI - missing from diagram
pin 12 to MISO - missing from diagram
pin 13 to SCLK - shown incorrectly connected to pin 14

However, if you are able to physically access the SD socket on your Teensy 4.1, you could just put the SD card there instead of using the socket on the audio shield. Then you would just edit the code to use BUILTIN_SDCARD for SDCARD_CS_PIN. To see an example with the proper syntax, click File > Examples > Audio > WavFilePlayer. Look for the comment "Use these with the Teensy 3.5 & 3.6 SD card". Syntax is the same for the SD card on Teensy 4.1.
 
I'm having a similar issue with my Teensy 4 when connected to a Teensy audio shield (rev d2). I've used a test code designed specifically for this setup to test the SD card, but unfortunately, the card is not being initialized. I continuously receive the message "SD card is not connected or unusable ;-(".

Here are some details:

The SD card pin setup is correct, with CS on pin 10. The other pins are ignored by the Teensy 4.
The SD card itself is a SanDisk A1 32GB and is formatted correctly to FAT32.
I soldered female headers to the shield and directly connected the teensy to it.
Wiring connections have been verified with a multimeter.
I've tried using different SD cards, but the issue persists.

I also thought the issue might be the audio board itself so I bought another one but I'm still having the same issue so I'm pretty much out of ideas

Here's the code I used
Code:
// SD Card Test
//
// Check if the SD card on the Audio Shield is working,
// and perform some simple speed measurements to gauge
// its ability to play 1, 2, 3 and 4 WAV files at a time.
//
// Requires the audio shield:
//   [url]http://www.pjrc.com/store/teensy3_audio.html[/url]
//
// Data files to put on your SD card can be downloaded here:
//   [url]http://www.pjrc.com/teensy/td_libs_AudioDataFiles.html[/url]
//
// This example code is in the public domain.

#include <SD.h>
#include <SPI.h>

// Use these with the Teensy Audio Shield
#define SDCARD_CS_PIN    10
#define SDCARD_MOSI_PIN  7   // Teensy 4 ignores this, uses pin 11
#define SDCARD_SCK_PIN   14  // Teensy 4 ignores this, uses pin 13

// Use these with the Teensy 3.5 & 3.6 & 4.1 SD card
//#define SDCARD_CS_PIN    BUILTIN_SDCARD
//#define SDCARD_MOSI_PIN  11  // not actually used
//#define SDCARD_SCK_PIN   13  // not actually used

// Use these for the SD+Wiz820 or other adaptors
//#define SDCARD_CS_PIN    4
//#define SDCARD_MOSI_PIN  11
//#define SDCARD_SCK_PIN   13

void setup() {
  Sd2Card card;
  SdVolume volume;
  File f1, f2, f3, f4;
  char buffer[512];
  boolean status;
  unsigned long usec, usecMax;
  elapsedMicros usecTotal, usecSingle;
  int i, type;
  float size;

  // wait for the Arduino Serial Monitor to open
  while (!Serial) ;
  delay(50);

  // Configure SPI
  SPI.setMOSI(SDCARD_MOSI_PIN);
  SPI.setSCK(SDCARD_SCK_PIN);

  Serial.begin(9600);
  Serial.println("SD Card Test");
  Serial.println("------------");

  // First, detect the card
  status = card.init(SPI_FULL_SPEED, SDCARD_CS_PIN);
  if (status) {
    Serial.println("SD card is connected :-)");
  } else {
    Serial.println("SD card is not connected or unusable :-(");
    return;
  }

  type = card.type();
  if (type == SD_CARD_TYPE_SD1 || type == SD_CARD_TYPE_SD2) {
    Serial.println("Card type is SD");
  } else if (type == SD_CARD_TYPE_SDHC) {
    Serial.println("Card type is SDHC");
  } else {
    Serial.println("Card is an unknown type (maybe SDXC?)");
  }

  // Then look at the file system and print its capacity
  status = volume.init(card);
  if (!status) {
    Serial.println("Unable to access the filesystem on this card. :-(");
    return;
  }

  size = volume.blocksPerCluster() * volume.clusterCount();
  size = size * (512.0 / 1e6); // convert blocks to millions of bytes
  Serial.print("File system space is ");
  Serial.print(size);
  Serial.println(" Mbytes.");

  // Now open the SD card normally
  status = SD.begin(SDCARD_CS_PIN);
  if (status) {
    Serial.println("SD library is able to access the filesystem");
  } else {
    Serial.println("SD library can not access the filesystem!");
    Serial.println("Please report this problem, with the make & model of your SD card.");
    Serial.println("  http://forum.pjrc.com/forums/4-Suggestions-amp-Bug-Reports");
  }


  // Open the 4 sample files.  Hopefully they're on the card
  f1 = SD.open("SDTEST1.WAV");
  f2 = SD.open("SDTEST2.WAV");
  f3 = SD.open("SDTEST3.WAV");
  f4 = SD.open("SDTEST4.WAV");

  // Speed test reading a single file
  if (f1) {
    Serial.println();
    Serial.println("Reading SDTEST1.WAV:");
    if (f1.size() >= 514048) {
      usecMax = 0;
      usecTotal = 0;
      for (i=0; i < 1000; i++) {
        usecSingle = 0;
        f1.read(buffer, 512);
        usec = usecSingle;
        if (usec > usecMax) usecMax = usec;
      }
      reportSpeed(1, 1000, usecTotal, usecMax);
    } else {
      Serial.println("SDTEST1.WAV is too small for speed testing");
    }
  } else {
    Serial.println("Unable to find SDTEST1.WAV on this card");
    return;
  }

  // Speed test reading two files
  if (f2) {
    Serial.println();
    Serial.println("Reading SDTEST1.WAV & SDTEST2.WAV:");
    if (f2.size() >= 514048) {
      f1.seek(0);
      usecMax = 0;
      usecTotal = 0;
      for (i=0; i < 1000; i++) {
        usecSingle = 0;
        f1.read(buffer, 512);
        f2.read(buffer, 512);
        usec = usecSingle;
        if (usec > usecMax) usecMax = usec;
      }
      reportSpeed(2, 1000, usecTotal, usecMax);

      Serial.println();
      Serial.println("Reading SDTEST1.WAV & SDTEST2.WAV staggered:");
      f1.seek(0);
      f2.seek(0);
      f1.read(buffer, 512);
      usecMax = 0;
      usecTotal = 0;
      for (i=0; i < 1000; i++) {
        usecSingle = 0;
        f1.read(buffer, 512);
        f2.read(buffer, 512);
        usec = usecSingle;
        if (usec > usecMax) usecMax = usec;
      }
      reportSpeed(2, 1000, usecTotal, usecMax);
    } else {
      Serial.println("SDTEST2.WAV is too small for speed testing");
    }
  } else {
    Serial.println("Unable to find SDTEST2.WAV on this card");
    return;
  }


  // Speed test reading three files
  if (f3) {
    Serial.println();
    Serial.println("Reading SDTEST1.WAV, SDTEST2.WAV, SDTEST3.WAV:");
    if (f3.size() >= 514048) {
      f1.seek(0);
      f2.seek(0);
      usecMax = 0;
      usecTotal = 0;
      for (i=0; i < 1000; i++) {
        usecSingle = 0;
        f1.read(buffer, 512);
        f2.read(buffer, 512);
        f3.read(buffer, 512);
        usec = usecSingle;
        if (usec > usecMax) usecMax = usec;
      }
      reportSpeed(3, 1000, usecTotal, usecMax);

      Serial.println();
      Serial.println("Reading SDTEST1.WAV, SDTEST2.WAV, SDTEST3.WAV staggered:");
      f1.seek(0);
      f2.seek(0);
      f3.seek(0);
      f1.read(buffer, 512);
      f1.read(buffer, 512);
      f2.read(buffer, 512);
      usecMax = 0;
      usecTotal = 0;
      for (i=0; i < 1000; i++) {
        usecSingle = 0;
        f1.read(buffer, 512);
        f2.read(buffer, 512);
        f3.read(buffer, 512);
        usec = usecSingle;
        if (usec > usecMax) usecMax = usec;
      }
      reportSpeed(3, 1000, usecTotal, usecMax);
    } else {
      Serial.println("SDTEST3.WAV is too small for speed testing");
    }
  } else {
    Serial.println("Unable to find SDTEST3.WAV on this card");
    return;
  }


  // Speed test reading four files
  if (f4) {
    Serial.println();
    Serial.println("Reading SDTEST1.WAV, SDTEST2.WAV, SDTEST3.WAV, SDTEST4.WAV:");
    if (f4.size() >= 514048) {
      f1.seek(0);
      f2.seek(0);
      f3.seek(0);
      usecMax = 0;
      usecTotal = 0;
      for (i=0; i < 1000; i++) {
        usecSingle = 0;
        f1.read(buffer, 512);
        f2.read(buffer, 512);
        f3.read(buffer, 512);
        f4.read(buffer, 512);
        usec = usecSingle;
        if (usec > usecMax) usecMax = usec;
      }
      reportSpeed(4, 1000, usecTotal, usecMax);

      Serial.println();
      Serial.println("Reading SDTEST1.WAV, SDTEST2.WAV, SDTEST3.WAV, SDTEST4.WAV staggered:");
      f1.seek(0);
      f2.seek(0);
      f3.seek(0);
      f4.seek(0);
      f1.read(buffer, 512);
      f1.read(buffer, 512);
      f1.read(buffer, 512);
      f2.read(buffer, 512);
      f2.read(buffer, 512);
      f3.read(buffer, 512);
      usecMax = 0;
      usecTotal = 0;
      for (i=0; i < 1000; i++) {
        usecSingle = 0;
        f1.read(buffer, 512);
        f2.read(buffer, 512);
        f3.read(buffer, 512);
        f4.read(buffer, 512);
        usec = usecSingle;
        if (usec > usecMax) usecMax = usec;
      }
      reportSpeed(4, 1000, usecTotal, usecMax);
    } else {
      Serial.println("SDTEST4.WAV is too small for speed testing");
    }
  } else {
    Serial.println("Unable to find SDTEST4.WAV on this card");
    return;
  }

}


unsigned long maximum(unsigned long a, unsigned long b,
  unsigned long c, unsigned long d)
{
  if (b > a) a = b;
  if (c > a) a = c;
  if (d > a) a = d;
  return a;
}


void reportSpeed(unsigned int numFiles, unsigned long blockCount, unsigned long usecTotal, unsigned long usecMax)
{
  float bytesPerSecond = (float)(blockCount * 512 * numFiles) / usecTotal;
  Serial.print("  Overall speed = ");
  Serial.print(bytesPerSecond);
  Serial.println(" Mbyte/sec");
  Serial.print("  Worst block time = ");
  Serial.print((float)usecMax / 1000.0);
  Serial.println(" ms");
  Serial.print("    ");
  Serial.print( (float)usecMax / 29.01333);
  Serial.println("% of audio frame time");
}


void loop(void) {
  // do nothing after the test
}
 
Last edited by a moderator:
Hi,fellows
i had the same issue,so i took my ohm-meter to find the pinout of the sd card of the audio board for my teeny3.2 and these are the winning numbers:


NC / NC
DAT3 / CS-> 10
CMD / MOSI->11
GND / GND->---
VDD / VDD->3,3V
CLK / SCK->13
GND / GND->GND
DAT0 / MISO->12
DAT1 / IRQ->---


So -> #define SDCARD_CS_PIN 10
#define SDCARD_MOSI_PIN 11
#define SDCARD_SCK_PIN 13

...And that's not enough for all cards,i had also picked up a freeware named formatter 4:

https://www.sdcard.org/downloads/formatter_4/

And he did it automatically to SDHC,then all works !!!:cool:
 
Back
Top