SD Card undetected

Hello,
I work with an Arduino Leonardo - I connect a generic Micro SD Card Reader.

=> I check the card to be sure it s ok with the reader (32 GO Micro SDHC)
=> I check the Alimentation with a tenem tool, 5 volts OK
=> I format the SD Card FAT32
=> With the help of GPT I check connections are OK

But still

=== Test des branchements ===

Test CS (Pin 10)... OK

Test SPI... OK

Test Carte SD... Erreur : Carte SD non détectée (= SD CARD not detected.....)

Vérifiez les connexions, la tension et si la carte est formatée en FAT32.

What could I do ? Thanks for help

Please find below the sketch

Texte préformaté#include <SPI.h>
#include <SD.h>

const int chipSelect = 10; // Broche CS pour le module microSD

void setup() {
Serial.begin(9600);
while (!Serial) {
; // Attendre la connexion série (nécessaire pour Leonardo)
}

Serial.println("=== Test des branchements ===");

// Test 1 : Vérification de la broche CS
Serial.print("Test CS (Pin 10)... ");
pinMode(chipSelect, OUTPUT);
digitalWrite(chipSelect, HIGH);
if (digitalRead(chipSelect) == HIGH) {
Serial.println("OK");
} else {
Serial.println("Erreur : Broche CS");
}

// Test 2 : Vérification des connexions SPI
Serial.print("Test SPI... ");
if (testSPI()) {
Serial.println("OK");
} else {
Serial.println("Erreur : SPI non fonctionnel");
}

// Test 3 : Vérification de la carte SD
Serial.print("Test Carte SD... ");
delay(2000); // Délai pour laisser le temps au module de s'initialiser
if (SD.begin(chipSelect)) {
Serial.println("OK");
} else {
Serial.println("Erreur : Carte SD non détectée");
Serial.println("Vérifiez les connexions, la tension et si la carte est formatée en FAT32.");
}

Serial.println("=== Tests terminés ===");
}

void loop() {
// Boucle vide
}

// Fonction pour tester les connexions SPI
bool testSPI() {
SPI.begin();
byte testByte = 0xAA; // Valeur de test
SPI.transfer(testByte); // Envoie un signal SPI
SPI.end();
return true; // Impossible de lire le retour sur SPI, mais cela teste les connexions de base
}Texte préformaté

=== Tests terminés ===

which pins have you connected the SD card too?
I use SPI connections on the ICSP connector, e.g.

// Leonardo connections
// Leonardo ICSP SCK  pin 15  to RFM95 SCK
// Leonardo ICSP MISO pin 14  to RFM95 MISO
// Leonardo ICSP MOSI pin 16   to RFM95 MOSI
// Leonardo pin 2 to RFM95 SS
// Leonardo pin 3 to RFM95 Reset

update the code in post 1 to use code tags </> it make it much more readable

It may be the card size. uSD cards are limited to 16Gb with the SD library.
You might want to check out the SdFat library. Allows 32Gb cards and long filenames.
.Last I checked anyway.

Hello , [update]

Thanks for your answer. I m too novice I guess... I did not really understand. Yes I did ^^

I did Micro sd reader to Leonardo
// Gnd to Gnd
// Vcc to 5V
//Miso to Pin 12
// Mosi to Pin 11
// Sck to Pin 13
// Cs to Pin 10

I did what you say ... and update the code / all ok except again the last check of the sd card

Thanks again

Ps : I try to understand the </> lol

Hello,

Thanks to your answer / I do have a 16 GB as well. I tried and does not work unfortunately.

pins 11, 12 and 13 are for the UNO SPI - does not work on Leonardo

the Leonardo uses pin 14 MISO pin 16 MOSI pin 15 SCK on the ICSP header for SPI
see photo in post 2 or leonardo-pinout

you need to rewire the SD connections

Hello,

Yes Thanks I did it - Unfortunately KO -
The checks are all good but the last one detecting the SD is KO

=== Test des branchements ===

Test CS (Pin 2)... OK

Test SPI... OK

Test Carte SD... Erreur : Carte SD non détectée

connected a SD card reader to a The Things UNO (which is a Leonardo with an onboard LoRa module)
code

// Leonardo SD card read test

/*
  SD card test

  This example shows how use the utility libraries on which the'
  SD library is based in order to get info about your SD card.
  Very useful for testing a card when you're not sure whether its working or not.

  The circuit: Leonardo ICSP header
    SD card attached to SPI bus as follows:
 ** MOSI - pin 16 on Leonardo
 ** MISO - pin 14 on Leonardo
 ** CLK  - pin 15 on Leonardo
 ** CS - pin 10 on Leonardo

  created  28 Mar 2011
  by Limor Fried
  modified 9 Apr 2012
  by Tom Igoe
*/
// include the SD library:
#include <SPI.h>
#include <SD.h>

// set up variables using the SD utility library functions:
Sd2Card card;
SdVolume volume;
SdFile root;

// change this to match your SD shield or module;
// Arduino Ethernet shield: pin 4
// Adafruit SD shields and modules: pin 10
// Sparkfun SD shield: pin 8
// MKRZero SD: SDCARD_SS_PIN
const int chipSelect = 10;

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(115200);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }


  Serial.print("\nInitializing SD card...");

  // we'll use the initialization code from the utility libraries
  // since we're just testing if the card is working!
  if (!card.init(SPI_HALF_SPEED, chipSelect)) {
    Serial.println("initialization failed. Things to check:");
    Serial.println("* is a card inserted?");
    Serial.println("* is your wiring correct?");
    Serial.println("* did you change the chipSelect pin to match your shield or module?");
    while (1);
  } else {
    Serial.println("Wiring is correct and a card is present.");
  }

  // print the type of card
  Serial.println();
  Serial.print("Card type:         ");
  switch (card.type()) {
    case SD_CARD_TYPE_SD1:
      Serial.println("SD1");
      break;
    case SD_CARD_TYPE_SD2:
      Serial.println("SD2");
      break;
    case SD_CARD_TYPE_SDHC:
      Serial.println("SDHC");
      break;
    default:
      Serial.println("Unknown");
  }

  // Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32
  if (!volume.init(card)) {
    Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");
    while (1);
  }

  Serial.print("Clusters:          ");
  Serial.println(volume.clusterCount());
  Serial.print("Blocks x Cluster:  ");
  Serial.println(volume.blocksPerCluster());

  Serial.print("Total Blocks:      ");
  Serial.println(volume.blocksPerCluster() * volume.clusterCount());
  Serial.println();

  // print the type and size of the first FAT-type volume
  uint32_t volumesize;
  Serial.print("Volume type is:    FAT");
  Serial.println(volume.fatType(), DEC);

  volumesize = volume.blocksPerCluster();    // clusters are collections of blocks
  volumesize *= volume.clusterCount();       // we'll have a lot of clusters
  volumesize /= 2;                           // SD card blocks are always 512 bytes (2 blocks are 1KB)
  Serial.print("Volume size (Kb):  ");
  Serial.println(volumesize);
  Serial.print("Volume size (Mb):  ");
  volumesize /= 1024;
  Serial.println(volumesize);
  Serial.print("Volume size (Gb):  ");
  Serial.println((float)volumesize / 1024.0);

  Serial.println("\nFiles found on the card (name, date and size in bytes): ");
  root.openRoot(volume);

  // list all files in the card with date and size
  root.ls(LS_R | LS_DATE | LS_SIZE);
}

void loop(void) {
}


serial output

Initializing SD card...Wiring is correct and a card is present.

Card type:         SDHC
Clusters:          1897344
Blocks x Cluster:  32
Total Blocks:      60715008

Volume type is:    FAT32
Volume size (Kb):  30357504
Volume size (Mb):  29646
Volume size (Gb):  28.95

Files found on the card (name, date and size in bytes): 
SYSTEM~1/     2022-06-25 14:18:42
  WPSETT~1.DAT  2022-06-25 14:18:42 12
  INDEXE~1      2022-07-02 17:15:42 76
USEFUL~1.DOC  2022-07-02 09:47:44 110592
DELETE.BAT    2022-07-02 10:33:34 179
DEL.BAT       2022-07-02 10:34:00 72
TEST/         2022-07-02 10:35:16
  DELETE.BAT    2022-07-02 10:36:14 179
  USEFUL~1.DOC  2022-07-02 10:52:52 110592
  DEL.BAT       2022-07-02 10:53:06 72
  LINUXH~1.ODT  2022-07-02 10:59:14 8149
  SHHXWI~1.ODT  2022-07-02 10:59:50 7721
TEST.TXT      1980-01-01 00:00:04 1048576
FOO.TXT       1980-01-01 00:00:02 13

photo