ESP32 SPI SD-Card-Modul

[Chandler B. (chandler)]

Hallo,
ich möchte gerne mit einem ESP32-Wroom-32 und ESP-IDF Daten von einer 
SD-Karte lesen.
Dazu habe ich einen mikroSD-Karten-Modul wo man über SPI kommunizieren 
kann.
Verbunden habe ich das Modul an HSPI und mit dem 3,3 V vom ESP-Board.

Jetzt habe ich das Beispiel sdspi (esp-idf-v5.4) genommen und die Pins 
aus der Konfig angepasst. Dennoch bekomme ich einen Fehler

I (317) main_task: Started on CPU0
I (327) main_task: Calling app_main()
I (327) example: CONFIG_EXAMPLE_FORMAT_IF_MOUNT_FAILED: 1
I (327) example: CONFIG_EXAMPLE_DEBUG_PIN_CONNECTIONS: FALSE
I (327) example: Initializing SD card
I (327) example: Using SPI peripheral
I (337) example: CONFIG_EXAMPLE_PIN_CLK: 14
I (337) example: CONFIG_EXAMPLE_PIN_MOSI: 13
I (347) example: CONFIG_EXAMPLE_PIN_MISO: 12
I (347) example: CONFIG_EXAMPLE_PIN_CS: 15
I (347) example: Mounting filesystem
I (357) gpio: GPIO[15]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0
E (567) sdmmc_sd: sdmmc_init_sd_if_cond: send_if_cond (1) returned 0x108
E (567) vfs_fat_sdmmc: sdmmc_card_init failed (0x108).
HINT: Please verify if there is an SD card inserted into the SD slot. Then, try rebooting the board.
I (567) gpio: GPIO[15]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0
E (567) example: Failed to initialize the card (ESP_ERR_INVALID_RESPONSE). Make sure SD card lines have pull-up resistors in place.
HINT: Please refer ./README.md for details
I (587) main_task: Returned from app_main()

void app_main(void)
{
    esp_err_t ret;

    // Options for mounting the filesystem.
    // If format_if_mount_failed is set to true, SD card will be partitioned and
    // formatted in case when mounting fails.
    esp_vfs_fat_sdmmc_mount_config_t mount_config = {
#ifdef CONFIG_EXAMPLE_FORMAT_IF_MOUNT_FAILED
        .format_if_mount_failed = true,
#else
        .format_if_mount_failed = false,
#endif // EXAMPLE_FORMAT_IF_MOUNT_FAILED
        .max_files = 5,
        .allocation_unit_size = 16 * 1024
    };
    sdmmc_card_t *card;
    const char mount_point[] = MOUNT_POINT;
    ESP_LOGI(TAG, "CONFIG_EXAMPLE_FORMAT_IF_MOUNT_FAILED: %d", mount_config.format_if_mount_failed);
#ifdef CONFIG_EXAMPLE_DEBUG_PIN_CONNECTIONS
    ESP_LOGI(TAG, "CONFIG_EXAMPLE_DEBUG_PIN_CONNECTIONS: TRUE");
#else
    ESP_LOGI(TAG, "CONFIG_EXAMPLE_DEBUG_PIN_CONNECTIONS: FALSE");
#endif

    ESP_LOGI(TAG, "Initializing SD card");

    // Use settings defined above to initialize SD card and mount FAT filesystem.
    // Note: esp_vfs_fat_sdmmc/sdspi_mount is all-in-one convenience functions.
    // Please check its source code and implement error recovery when developing
    // production applications.
    ESP_LOGI(TAG, "Using SPI peripheral");

    // By default, SD card frequency is initialized to SDMMC_FREQ_DEFAULT (20MHz)
    // For setting a specific frequency, use host.max_freq_khz (range 400kHz - 20MHz for SDSPI)
    // Example: for fixed frequency of 10MHz, use host.max_freq_khz = 10000;
    sdmmc_host_t host = SDSPI_HOST_DEFAULT();

    // For SoCs where the SD power can be supplied both via an internal or external (e.g. on-board LDO) power supply.
    // When using specific IO pins (which can be used for ultra high-speed SDMMC) to connect to the SD card
    // and the internal LDO power supply, we need to initialize the power supply first.
#if CONFIG_EXAMPLE_SD_PWR_CTRL_LDO_INTERNAL_IO
    sd_pwr_ctrl_ldo_config_t ldo_config = {
        .ldo_chan_id = CONFIG_EXAMPLE_SD_PWR_CTRL_LDO_IO_ID,
    };
    sd_pwr_ctrl_handle_t pwr_ctrl_handle = NULL;

    ret = sd_pwr_ctrl_new_on_chip_ldo(&ldo_config, &pwr_ctrl_handle);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Failed to create a new on-chip LDO power control driver");
        return;
    }
    host.pwr_ctrl_handle = pwr_ctrl_handle;
#endif

    spi_bus_config_t bus_cfg = {
        .mosi_io_num = PIN_NUM_MOSI,
        .miso_io_num = PIN_NUM_MISO,
        .sclk_io_num = PIN_NUM_CLK,
        .quadwp_io_num = -1,
        .quadhd_io_num = -1,
        .max_transfer_sz = 400,
    };
    ESP_LOGI(TAG, "CONFIG_EXAMPLE_PIN_CLK: %d", bus_cfg.sclk_io_num);
    ESP_LOGI(TAG, "CONFIG_EXAMPLE_PIN_MOSI: %d", bus_cfg.mosi_io_num);
    ESP_LOGI(TAG, "CONFIG_EXAMPLE_PIN_MISO: %d", bus_cfg.miso_io_num);

    ret = spi_bus_initialize(host.slot, &bus_cfg, SDSPI_DEFAULT_DMA);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Failed to initialize bus.");
        return;
    }

    // This initializes the slot without card detect (CD) and write protect (WP) signals.
    // Modify slot_config.gpio_cd and slot_config.gpio_wp if your board has these signals.
    sdspi_device_config_t slot_config = SDSPI_DEVICE_CONFIG_DEFAULT();
    slot_config.gpio_cs = PIN_NUM_CS;
    slot_config.host_id = host.slot;
    ESP_LOGI(TAG, "CONFIG_EXAMPLE_PIN_CS: %d", slot_config.gpio_cs);

    ESP_LOGI(TAG, "Mounting filesystem");
    ret = esp_vfs_fat_sdspi_mount(mount_point, &host, &slot_config, &mount_config, &card);

    if (ret != ESP_OK) {
        if (ret == ESP_FAIL) {
            ESP_LOGE(TAG, "Failed to mount filesystem. "
                     "If you want the card to be formatted, set the CONFIG_EXAMPLE_FORMAT_IF_MOUNT_FAILED menuconfig option.");
        } else {
            ESP_LOGE(TAG, "Failed to initialize the card (%s). "
                     "Make sure SD card lines have pull-up resistors in place.", esp_err_to_name(ret));
#ifdef CONFIG_EXAMPLE_DEBUG_PIN_CONNECTIONS
            check_sd_card_pins(&config, pin_count);
#endif
        }
        return;
    }

[Harald K. (kirnbichler)]

Ja, und?

Die Fehlermeldung ist sehr ausführlich und gibt Hinweise, was Du Dir 
ansehen solltest.

Hast Du irgendwas davon berücksichtigt?

[Obelix X. (obelix)]

Was ist bei dir anders als in folgendem Guide?

https://randomnerdtutorials.com/esp32-microsd-card-arduino/

[Chandler B. (chandler)]

Obelix X. schrieb:
> Was ist bei dir anders als in folgendem Guide?
>
> https://randomnerdtutorials.com/esp32-microsd-card-arduino/

Anders ist:
1) ich benutze ESP-IDF und nicht Arduino
2) ich benutze die Pins für HSPI und nicht VSPI (die Pins sind aber für 
HSPI konfiguriert, siehe Log)
3) meine SD-Karte ist nur 512 MB groß

Angeschlossen habe ich es
SD-Card-Reader -> ESP32-Wroom-32
GND -> GND
VCC -> 3V3
CS -> GPIO15
MOSI -> GPIO13
CLK -> GPIO14
MISO -> GPIO12

[Chandler B. (chandler)]

Harald K. schrieb:
> Ja, und?
>
> Die Fehlermeldung ist sehr ausführlich und gibt Hinweise, was Du Dir
> ansehen solltest.
>
> Hast Du irgendwas davon berücksichtigt?

die erste Fehlermeldung sagt mir, dass keine SD-Karte drinn ist.
Die ist aber eingelegt.

Die zweite sagt, dass ein pull-up resistor vorhanden sein soll.
Da lese ich aber immer unterschiedliches. In den ganzen Tutorials ist 
nirgends ein Widerstand eingesetzt.
Von wo nach wo (und wie groß) müsste dieser denn sein?

[Harald K. (kirnbichler)]

Chandler B. schrieb:
> Von wo nach wo (und wie groß) müsste dieser denn sein?

Eine der Fehlermeldungen verweist auf "readme.md". Hast Du da 
reingesehen?

(Ich kann das nicht für Dich, weil ich da erst mal rauskramen müsste, 
was auch immer Du Dir da für Libraries zusammengeklickt hast)

[Chandler B. (chandler)]

Harald K. schrieb:
> Chandler B. schrieb:
>> Von wo nach wo (und wie groß) müsste dieser denn sein?
>
> Eine der Fehlermeldungen verweist auf "readme.md". Hast Du da
> reingesehen?
>
> (Ich kann das nicht für Dich, weil ich da erst mal rauskramen müsste,
> was auch immer Du Dir da für Libraries zusammengeklickt hast)

Zusammengeklickt habe ich nichts. Ich habe eins zu eins das Beispiel 
genommen und die Pins angepasst.

Although it is possible to connect an SD card breakout adapter, keep in mind that connections using breakout cables are often unreliable and have poor signal integrity. You may need to use lower clock frequency when working with SD card breakout adapters.

die habe ich auf 400 khz gesetzt

Pins (siehe Anhang)
Wobei bei mir
MISO auf GPIO12
CS auf GPIO15
SCK auf GPIO14
MOSI auf GPIO13

https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/peripherals/sd_pullup_requirements.html#overview-of-compatibility
hiernach hat der ESP32-WROOM-32 keinen Pullup

No Pull-ups
When using a development board without pull-ups:

If your host and slave device are on separate boards, replace one of them with a board that has pull-ups. For the list of Espressif's development boards with pull-ups, go to Development Boards.

Attach external pull-ups by connecting each pin which requires a pull-up to VDD via a 10 kΩ resistor.

aber auch mit 10kOhm bekomme ich die selben Fehler

[Obelix X. (obelix)]

Mit einem Oszi überprüfen ob alle Signale richtig an der SD-Karte 
ankommen. Bilder vom Aufbau und Schaltplan.

[Rüdiger B. (rbruns)]

Damit hatte ich auch gekämpft:
SD_MMC.h benutzt den ESP32 MMC Code, ist etwas schneller.
SD.h ist allgemeiner und benutzt standarmässig HSPI, kann aber eine 
grössere Anzahl dateien gleichzitig öffnen(wenn konfiguriert).
Wichtig ist das immer die richtige von 4 internen SPI Engines verwendet 
wird, Nummer 1 und 2 werden Intern benutzt.
Hier meine Test mit auskommmentieten Fehlern.

//#define VSPI 3  //SPI 3 bus normally attached to pins 5, 18, 19 and 23, but can be matrixed to any pins
SPIClass SD_SPI = SPIClass(VSPI); // Neither HSPI nor VSPI=CYD seem to work
//SPIClass SD_SPI = SPIClass(BOARD_SDCARD_MISO,BOARD_SDCARD_SCK,BOARD_SDCARD_MOSI,BOARD_SDCARD_CS); // Neither HSPI nor VSPI seem to work
//SPIClass SD_SPI = SPIClass(14,2,15,13); // ESP32-CAM   SD_SPI.begin(14, 2, 15, 13); //sck,miso,mosi,ss


//SPI    MOSI    MISO    SCLK    CS
//VSPI  GPIO 23  GPIO 19  GPIO 18  GPIO 5
//HSPI  GPIO 13  GPIO 12  GPIO 14  GPIO 15
  SD_SPI.begin(18, 19, 23); // 
  //SDSPI.begin(SCLK, MISO, MOSI);
  pinMode (BOARD_SDCARD_CS, OUTPUT);

  digitalWrite(BOARD_SDCARD_CS, HIGH);
//   SD_SPI.begin(14, 2, 15, BOARD_SDCARD_CS); //sck,miso,mosi,ss ESP32-CAM
  Serial.println("SPI Started");
  //SD_SPI.setFrequency(1000000);
 if(!SD.begin(BOARD_SDCARD_CS, SD_SPI, 40000000, "/sd",(uint8_t) 15)){
// if(!SD.begin(BOARD_SDCARD_CS, SD_SPI)){
    Serial.println("Card Mount Failed");
    LITTLEFS_test();
    //return;
  }

[Harald K. (kirnbichler)]

Chandler B. schrieb:
> aber auch mit 10kOhm bekomme ich die selben Fehler

Zeig ein Bild Deines Aufbaus. Tüddeldraht auf dem Frickelboard?

[Jan H. (jan_h74)]

SD_MMC 1-bit mode bei ESP32 funtioniert nur bei feste pinbelegung ! Da 
kan mann nicht ueber die pin matrix andere pins auswahlen ! Nur folgende 
pins functionieren :
#define SDCARD_SS 13
#define SDCARD_CLK 14
#define SDCARD_MOSI 15
#define SDCARD_MISO 2
SD_CARD_MISO wird nicht genutzt, soll aber mit ein pullup initialisiert 
werden.
Oder du verwendet SPI mode, dort sind die pins frei wahlbar.
Siehe auch 
https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/peripherals/sdmmc_host.html

[Chandler B. (chandler)]

Harald K. schrieb:
> Chandler B. schrieb:
>> aber auch mit 10kOhm bekomme ich die selben Fehler
>
> Zeig ein Bild Deines Aufbaus. Tüddeldraht auf dem Frickelboard?

Ich habe den Reader mit jumperkabel direkt mit dem ESP verbunden.

[Rüdiger B. (rbruns)]

Dir ist klar das der Reader auf 5 Volt läuft und der ESP32 mit 3,3 Volt 
?

[Chandler B. (chandler)]

Rüdiger B. schrieb:
> Dir ist klar das der Reader auf 5 Volt läuft und der ESP32 mit 3,3 Volt
> ?

mhh, war davon ausgegangen, dass die Signale trotzdem mit 3V laufen 
würden.

habe jetzt einen SD-karten adapter direkt angeschlossen. Damit scheint 
es dann zu funktionieren.
Für die Spannung nehme ich dann jetzt natürlich nur die 3,3V

I (348) example: Mounting filesystem
I (358) gpio: GPIO[5]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0
I (488) sdspi_transaction: cmd=5, R1 response: command not supported
I (648) example: Filesystem mounted
Name: SC32G
Type: SDHC
Speed: 20.00 MHz (limit: 20.00 MHz)
Size: 30436MB
CSD: ver=2, sector_size=512, capacity=62333952 read_bl_len=9
SSR: bus_width=1
I (658) example: Opening file /sdcard/hello.txt
I (708) example: File written
I (708) example: Renaming file /sdcard/hello.txt to /sdcard/foo.txt
I (708) example: Reading file /sdcard/foo.txt
I (708) example: Read from file: 'Hello SC32G!'
I (708) example: Opening file /sdcard/nihao.txt
I (728) example: File written
I (728) example: Reading file /sdcard/nihao.txt
I (728) example: Read from file: 'Nihao SC32G!'
I (728) gpio: GPIO[5]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0
I (738) example: Card unmounted
I (738) gpio: GPIO[23]| InputEn: 0| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
I (748) gpio: GPIO[19]| InputEn: 0| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
I (758) gpio: GPIO[18]| InputEn: 0| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
I (768) main_task: Returned from app_main()