Merge pull request #22 from gschwaer/dev/sdcard

Add support for sdcard

Author: Disasm

Cargo.toml

@@ -15,6 +15,7 @@ embedded-hal = "0.2.3"
 nb = "0.1.2"
 riscv = "0.6.0"
 st7735-lcd = { version = "0.7", optional = true }
+embedded-sdmmc = { version = "0.3.0", optional = true }
 
 [dev-dependencies]
 riscv-rt = "0.8.0"
@@ -24,6 +25,7 @@ ushell = "0.3.3"
 
 [features]
 lcd = ["st7735-lcd"]
+sdcard = ["embedded-sdmmc"]
 
 [[example]]
 name = "display"
@@ -33,6 +35,10 @@ required-features = ["lcd"]
 name = "ferris"
 required-features = ["lcd"]
 
+[[example]]
+name = "sdcard_test"
+required-features = ["sdcard"]
+
 [package.metadata.docs.rs]
 features = ['lcd']
 rustdoc-args = ["--cfg", "docsrs"]

examples/sdcard_test.rs

@@ -0,0 +1,85 @@
+#![no_std]
+#![no_main]
+
+use embedded_sdmmc::{Directory, Volume, VolumeIdx};
+
+use longan_nano::sdcard::SdCard;
+use panic_halt as _;
+
+use riscv_rt::entry;
+use longan_nano::hal::{pac, prelude::*};
+use longan_nano::{sdcard, sdcard_pins, sprint, sprintln};
+
+#[entry]
+fn main() -> ! {
+    let dp = pac::Peripherals::take().unwrap();
+
+    // Configure clocks
+    let mut rcu = dp.RCU.configure()
+        .ext_hf_clock(8.mhz())
+        .sysclk(108.mhz())
+        .freeze();
+
+    let mut afio = dp.AFIO.constrain(&mut rcu);
+
+    let gpioa = dp.GPIOA.split(&mut rcu);
+    longan_nano::stdout::configure(dp.USART0, gpioa.pa9, gpioa.pa10, 115_200.bps(), &mut afio, &mut rcu);
+
+    let gpiob = dp.GPIOB.split(&mut rcu);
+    let sdcard_pins = sdcard_pins!(gpiob);
+    let mut sdcard = sdcard::configure(dp.SPI1, sdcard_pins, sdcard::SdCardFreq::Safe, &mut rcu);
+
+    sprint!("Initializing SD card ... ");
+    if let Err(_) = sdcard.device().init() {
+        sprintln!("Failed to initialize sdcard.");
+    } else {
+        sprintln!("OK");
+
+        let size = sdcard.device().card_size_bytes().unwrap();
+        sprintln!("SD Card Capacity: {} MB", size / 1000 / 1000);
+
+        // open the first partition
+        sprintln!("Partition 0:");
+        let mut volume = sdcard.get_volume(VolumeIdx(0)).unwrap();
+
+        // list files in root dir
+        let root_dir = sdcard.open_root_dir(&volume).unwrap();
+        sdcard.iterate_dir(&volume, &root_dir, | entry | {
+            sprintln!("{: >5}B  {}", entry.size, entry.name);
+        }).unwrap();
+
+        // if a file with the name SDTST.TXT is present, do a read/write test
+        if let Ok(_) = sdcard.find_directory_entry(&volume, &root_dir, "SDTST.TXT") {
+            read_write_test(&mut sdcard, &mut volume, &root_dir);
+        }
+    }
+    sprintln!("Done");
+
+    loop { }
+}
+
+fn read_write_test(sdcard: &mut SdCard, volume: &mut Volume, dir: &Directory) {
+    sprint!("Write test: ");
+    let mut file = sdcard.open_file_in_dir(volume, dir, "SDTST.CSV", embedded_sdmmc::Mode::ReadWriteCreateOrTruncate).unwrap();
+    let data = "1,2,3,4,20";
+    if let Ok(size_written) = sdcard.write(volume, &mut file, data.as_bytes()) {
+        sprintln!("Success (Wrote {} bytes)", size_written);
+    } else {
+        sprintln!("Failed");
+    }
+    sdcard.close_file(volume, file).unwrap();
+
+    sprint!("Read test: ");
+    let mut file = sdcard.open_file_in_dir(volume, dir, "SDTST.CSV", embedded_sdmmc::Mode::ReadOnly).unwrap();
+    let mut buffer: [u8; 32] = [0; 32];
+    if let Ok(size_read) = sdcard.read(volume, &mut file, &mut buffer) {
+        if size_read == data.len() && buffer[0..size_read].eq(data.as_bytes()) {
+            sprintln!("Success (Read same {} bytes)", size_read);
+        } else {
+            sprintln!("Content differs.");
+        }
+    } else {
+        sprintln!("Failed");
+    }
+    sdcard.close_file(volume, file).unwrap();
+}

src/lib.rs

@@ -10,3 +10,6 @@ pub use gd32vf103xx_hal as hal;
 pub mod lcd;
 pub mod led;
 pub mod stdout;
+#[cfg(feature = "sdcard")]
+#[cfg_attr(docsrs, doc(cfg(feature = "sdcard")))]
+pub mod sdcard;

src/sdcard.rs

@@ -0,0 +1,99 @@
+//! On-board SD Card Slot
+
+use embedded_hal::digital::v2::OutputPin;
+use gd32vf103xx_hal::gpio::gpiob::{PB12, PB13, PB14, PB15};
+use gd32vf103xx_hal::gpio::{Alternate, Floating, Input, Output, PushPull};
+use gd32vf103xx_hal::pac::{SPI1};
+use gd32vf103xx_hal::rcu::Rcu;
+use gd32vf103xx_hal::spi::{Spi, MODE_0};
+use gd32vf103xx_hal::time::{Hertz, U32Ext};
+use embedded_sdmmc::{Controller, SdMmcSpi, TimeSource, Timestamp};
+
+/// Sets up all the needed GPIO pins for the sdcard
+///
+/// ```
+/// let gpiob = dp.GPIOB.split(&mut rcu);
+/// let sdcard_pins = sdcard_pins!(gpiob);
+/// ```
+#[macro_export]
+macro_rules! sdcard_pins {
+    ($gpiob:ident) => {{
+        $crate::sdcard::SdCardPins {
+            miso: $gpiob.pb14.into_floating_input(),
+            mosi: $gpiob.pb15.into_alternate_push_pull(),
+            sck: $gpiob.pb13.into_alternate_push_pull(),
+            cs: $gpiob.pb12.into_push_pull_output(),
+        }
+    }};
+}
+
+type SckPin = PB13<Alternate<PushPull>>;
+type MisoPin = PB14<Input<Floating>>;
+type MosiPin = PB15<Alternate<PushPull>>;
+type CsPin = PB12<Output<PushPull>>;
+type SPI1Pins = (SckPin, MisoPin, MosiPin);
+
+type Spi1 = Spi<SPI1, SPI1Pins>;
+
+/// A type based on embedded_sdmmc::SdMmcSpi that is used by SdCard.
+pub type SdCardSpi = SdMmcSpi<Spi1, CsPin>;
+
+/// A type based on embedded_sdmmc::Controller.
+pub type SdCard = Controller<SdCardSpi, FakeTimeSource>;
+
+pub struct SdCardPins {
+    pub miso: MisoPin,
+    pub mosi: MosiPin,
+    pub sck: SckPin,
+    pub cs: CsPin,
+}
+
+pub enum SdCardFreq {
+    /// Should work for all cards
+    Safe,
+    /// May not work for some cards
+    Fast,
+    /// Specify SPI frequency
+    Custom(Hertz)
+}
+
+/// Constructs SD Card driver from the required components.
+pub fn configure(spi: SPI1, pins: SdCardPins, freq: SdCardFreq, rcu: &mut Rcu) -> SdCard {
+    let freq = match freq {
+        SdCardFreq::Safe => 200.khz().into(), // using 300 kHz here because the sdcard init needs 100 to 400 kHz (see SdMmcSpi.init)
+        SdCardFreq::Fast => 27.mhz().into(),  // this is the max SPI frequency according to datasheet
+        SdCardFreq::Custom(val) => val,
+    };
+
+    let spi1 = Spi::spi1(
+        spi,
+        (pins.sck, pins.miso, pins.mosi),
+        MODE_0,
+        freq,
+        rcu,
+    );
+
+    let mut cs = pins.cs;
+    cs.set_high().unwrap();
+
+    let sdmmcspi = SdMmcSpi::new(spi1, cs);
+    let ctime_source = FakeTimeSource {};
+
+    Controller::new(sdmmcspi, ctime_source)
+}
+
+/// A fake time source that always returns a date of zero.
+pub struct FakeTimeSource {}
+
+impl TimeSource for FakeTimeSource {
+    fn get_timestamp(&self) -> embedded_sdmmc::Timestamp {
+        Timestamp {
+            year_since_1970: 0,
+            zero_indexed_month: 0,
+            zero_indexed_day: 0,
+            hours: 0,
+            minutes: 0,
+            seconds: 0,
+        }
+    }
+}