Any SD or SDFS example using SPI1?

[fapplin]

I am using an Adafruit Micro SD SPI or SDIO Card Breakout Board - 3V ONLY with my RPi Pico W!

From the Adafruit site:

Power Pins

    3V - This is the power pin. MicroSD cards must use 3.3V, so take care to only hook 3.3V to this pin. Hooking 5V or VBAT to this pin will damage your microSD card.
    GND - common ground for power and logic.

Common Logic Pins

    DET - Detect whether a microSD card is inserted.  This pin is connected to GND internally when there's no card, but when one is inserted it is pulled up to 3V with a 4.7kΩ resistor.  That means that when the pin's logic level is False there's no card and when it's True there is.

SPI Logic Pins

If you're using SPI to connect to your SD cards, the pins have the following functions:

    CLK - This is the SPI Clock pin / SCK Serial Clock, its an input to the chip.
    SO - this is the Serial Out / Microcontroller In Serial Out pin, for data sent from the SD card to your processor.
    SI - this is the Serial In / Microcontroller Out Serial In pin, for data sent from your processor to the SD card. Its an input to the chip and can use 3V logic only.
    CS - this is the Chip Select pin, drop it low to start an SPI transaction. Its an input to the chip and can use 3V logic only.

I have it connected to RPi Pico W:

3V    -> VSYS
GND -> GND
CLK  -> GP10
SI     -> GP11
SO   -> GP12
CS   -> GP13

This is the simple code that I am trying, but I see nothing in the Serial Monitor (unplugging and plugging the board back in).

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <SPI.h>
#include <SD.h>
#include "Arduino.h"

void setup() {
  Serial.begin(9600);
  Serial.println("Initializing SD card...\n");
  SD.begin(13, SPI1); 

  File f = SD.open("user_scales.ini", "r");
  if (!f) 
  {
      Serial.printf("file open failed.\n");
      //return ini;
  } //end if

  f.close();
}

void loop() {

}

And, when I say I see nothing - I mean not even the initial Serial.println("Initializing SD card...\n");

Does SPI1 interfere with the Serial? I'm currently using: GP4, GP5, GP6, GP7, GP8 for other purposes.

Are there any examples using either SD or SDFS while using SPI1? I basically need open and read (and that's it).

Frank

[Andy2No]

And, when I say I see nothing - I mean not even the initial Serial.println("Initializing SD card...\n");

You'll need to add a pause of a few seconds, at the beginning of setup(), to give time for the serial output to start working and for the Arduino serial monitor to start responding to it.

A popular choice seems to be

delay(5000);   // wait 5 seconds

Or add a mini blink, running for a set time, to remind you it hasn't got to the good part, yet.

const byte LedPin = LED_BUILTIN; // Onboard LED
int StartupBlinks= 5; // Repeat the blink sequence this many times (currently takes one second per repeat)
// ...

setup()
{
  pinMode(LedPin, OUTPUT);
  if(StartupBlinks) {
    for (byte blinks = 1; blinks <= StartupBlinks; blinks++) {   // Flash the onboard LED to confirm it's booted up
      delay(300); digitalWrite( LedPin, HIGH ); delay(100); digitalWrite( LedPin, LOW );
      delay(100); digitalWrite( LedPin, HIGH ); delay(200); digitalWrite( LedPin, LOW );
      delay(100); digitalWrite( LedPin, HIGH ); delay(200); digitalWrite( LedPin, LOW );
    }
  }

[fapplin]

So, I modified my code with a delay (which helped - thanks), but I still don't get the SD initialized.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <SPI.h>
#include <SD.h>
#include "Arduino.h"

void setup() {
  Serial.begin(9600);
  while (!Serial) {

    ; // wait for serial port to connect. Needed for native USB port only

  }


  Serial.println("Initializing SD card...\n");


  if (!SD.begin(13, SPI1)) {
    Serial.println("SD Card initialization failed.");
    return;
    //while(1);
  } else {
    Serial.println("initialization done.");
  } //end if
  
  File f = SD.open("user_scales.ini", "r");
  if (!f) 
  {
      Serial.printf("file open failed.\n");
      //return ini;
  } //end if

  f.close();
}

void loop() {

}

Output:

Initializing SD card...

SD Card initialization failed.

[fapplin]

Stupidity on my part - I changed the wiring from 3V -> VSYS to 3V -> 3V and everything works as expected.

[fapplin]

It's not! When I have the SD board plugged into my Maker Pi Pico exactly as described above, change my Arduino setting to use the Cytron Maker Pi Bico Board, and upload my sketch - it works perfectly. I've tried a couple test sketches - both work.

I wire my Pico W in the same configuration, change the Arduino setting to Raspberry Pi Pico W, and upload - neither sketches works.

I've tried 2 different Pico W - same results.

[earlephilhower]

Assuming the HW hookup is good, then I suggest you triple-check the SPI pinout and maybe hardcode it in your sketch. Not all boards have the same SPI configuration and there is 0 code difference between builds besides the pinout and flash sizes/mode.

See https://arduino-pico.readthedocs.io/en/latest/spi.html for how to set the pins (doi it before you start the SD object).

[fapplin]

Are the pins used by the setXXX functions physical pins or GP_xx?

[earlephilhower]

You pass in the RP2040 GPIO numbers, like other calls. They don't correspond, necessarily, to the board pins. On an PicoW from RPI, the setXXX(x) maps to the pin labeled GPx on the board. Other board makers may not follow that simple 1:1 mapping.

[fapplin]

SPI1.setRX(12);
SPI1.setCS(13);
SPI1.setSCK(10);
SPI1.setTX(11);

That was the kicker! Thanks - long frustrating day!

Frank

[johnofleek]

Just incase anyone else makes a mistake with this (like I just did) - the following is a working example based on the ARDUINO SD card example but using PICO SPI 1

#include <Arduino.h>

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

#include "hardware/uart.h"

/*
  Using UART 1 as a debug port - serial data is transmitted by the PICO on GPIO 16
*/
#define UART_ID uart0
#define BAUD_RATE 115200
#define UART_TX_PIN 16
#define UART_RX_PIN 17
#define dbg Serial1

void uart0_initAsSerial1(void){
  Serial1.setRX(UART_RX_PIN);
  Serial1.setTX(UART_TX_PIN);
  Serial1.begin(BAUD_RATE);
  gpio_set_function(UART_TX_PIN, GPIO_FUNC_UART);
  gpio_set_function(UART_RX_PIN, GPIO_FUNC_UART);
  Serial1.printf("Debug on UART0 TX GPIO %d and RX GPIO %d\n\r", UART_TX_PIN, UART_RX_PIN);
}

/*
  SD Card setup
*/
#define SD_SPI1_MISO    (8)   // GPIO 8
#define SD_SPI1_CSn     (9)   // GPIO 9
#define SD_SPI1_SCK     (10)  // GPIO 10
#define SD_SPI1_MOSI    (11)  // GPIO 11

void sd_cardInit(void){
    SPI1.setRX(SD_SPI1_MISO);
    SPI1.setCS(SD_SPI1_CSn);
    SPI1.setSCK(SD_SPI1_SCK);
    SPI1.setTX(SD_SPI1_MOSI );

    dbg.print("Initializing SD card...");

    if (!(SD.begin(SD_SPI1_CSn, SPI1))) {
        dbg.println("initialization failed!");
        while (1);
    }
    Serial.println("initialization done.");
}

/*
  SD card test
*/
File myFile;
void sd_cardTest(void) {
  // open the file. note that only one file can be open at a time,
  // so you have to close this one before opening another.
  myFile = SD.open("test.txt", FILE_WRITE);

  // if the file opened okay, write to it:
  if (myFile) {
    dbg.print("Writing to test.txt...");
    myFile.println("testing 1, 2, 3.");
    // close the file:
    myFile.close();
    dbg.println("done.");
  } else {
    // if the file didn't open, print an error:
    dbg.println("error opening test.txt");
  }

  // re-open the file for reading:
  myFile = SD.open("test.txt");
  if (myFile) {
    dbg.println("test.txt:");
    // read from the file until there's nothing else in it:
    while (myFile.available()) {
      dbg.write(myFile.read());
    }
    // close the file:
    myFile.close();
  } else {
    // if the file didn't open, print an error:
    dbg.println("error opening test.txt");
  }
}

void setup () {
    uart0_initAsSerial1();
    dbg.print("SD_test S1\n\r");
    sd_cardInit();
    sd_cardTest();
}

void loop() {
    dbg.print("SD_test S2\n\r");
    delay(1000); 
}