Create a simpler example and fix review comments

Author: jkristell

Cargo.toml

@@ -59,10 +59,6 @@ ssd1306 = "0.2.6"
 embedded-graphics = "0.4.9"
 usb-device = "0.2.5"
 usbd-serial = "0.1.0"
-usbd_scsi = "0.1.0"
-usbd_mass_storage = "0.1.0"
-rtt-target = {version = "0.1.1", features = ["cortex-m"]}
-panic-rtt-target = { version = "0.1", features = ["cortex-m"] }
 
 [features]
 device-selected = []
@@ -102,8 +98,8 @@ name = "usb_serial"
 required-features = ["rt", "stm32f401", "usb_fs"]
 
 [[example]]
-name = "sdio-usb-block"
-required-features = ["rt", "stm32f405", "usb_fs"]
+name = "sd"
+required-features = ["rt", "stm32f405"]
 
 [[example]]
 name = "delay-blinky"

examples/sd.rs

@@ -0,0 +1,73 @@
+#![no_std]
+#![no_main]
+
+use cortex_m_rt::entry;
+use cortex_m_semihosting::{hprint, hprintln};
+use panic_semihosting as _;
+
+use stm32f4xx_hal::{delay, prelude::*, sdio::Sdio, stm32};
+
+#[entry]
+fn main() -> ! {
+    let device = stm32::Peripherals::take().unwrap();
+    let core = cortex_m::Peripherals::take().unwrap();
+
+    let rcc = device.RCC.constrain();
+    let clocks = rcc
+        .cfgr
+        .use_hse(12.mhz())
+        .require_pll48clk()
+        .sysclk(168.mhz())
+        .hclk(168.mhz())
+        .pclk1(42.mhz())
+        .pclk2(84.mhz())
+        .freeze();
+
+    assert!(clocks.is_pll48clk_valid());
+
+    let mut delay = delay::Delay::new(core.SYST, clocks);
+
+    let gpioc = device.GPIOC.split();
+    let gpiod = device.GPIOD.split();
+
+    let d0 = gpioc.pc8.into_alternate_af12().internal_pull_up(true);
+    let d1 = gpioc.pc9.into_alternate_af12().internal_pull_up(true);
+    let d2 = gpioc.pc10.into_alternate_af12().internal_pull_up(true);
+    let d3 = gpioc.pc11.into_alternate_af12().internal_pull_up(true);
+    let clk = gpioc.pc12.into_alternate_af12().internal_pull_up(false);
+    let cmd = gpiod.pd2.into_alternate_af12().internal_pull_up(true);
+    let mut sdio = Sdio::new(device.SDIO, (clk, cmd, d0, d1, d2, d3));
+
+    hprintln!("Waiting for card...").ok();
+
+    // Wait for card to be ready
+    loop {
+        match sdio.init_card() {
+            Ok(_) => break,
+            Err(_err) => (),
+        }
+
+        delay.delay_ms(1000u32);
+    }
+
+    let nblocks = sdio.card().map(|c| c.block_count()).unwrap_or(0);
+    hprintln!("Card detected: nbr of blocks: {:?}", nblocks).ok();
+
+    // Read a block from the card and print the data
+    let mut block = [0u8; 512];
+
+    match sdio.read_block(0, &mut block) {
+        Ok(()) => (),
+        Err(err) => {
+            hprintln!("Failed to read block: {:?}", err).ok();
+        }
+    }
+
+    for b in block.iter() {
+        hprint!("{:X} ", b).ok();
+    }
+
+    loop {
+        continue;
+    }
+}

examples/sdio-usb-block.rs

@@ -148,7 +148,7 @@ pub enum CardVersion {
 
 #[derive(Debug, Copy, Clone)]
 pub enum CardType {
-    /// Standard Capacity (< 2Gn)
+    /// Standard Capacity (< 2Gb)
     SDSC,
     /// High capacity (< 32Gb)
     SDHC,
@@ -186,9 +186,9 @@ pub struct Sdio {
 }
 
 struct Cmd {
-    pub cmd: u8,
-    pub arg: u32,
-    pub resp: Response,
+    cmd: u8,
+    arg: u32,
+    resp: Response,
 }
 
 #[derive(Debug, Copy, Clone, Default)]
@@ -214,16 +214,16 @@ pub struct Csd {
 
 #[derive(Debug, Default, Copy, Clone)]
 pub struct Status {
-    bus_width: u8,
-    secure_mode: u8,
-    card_type: u16,
-    protected_area_size: u32,
-    speed_class: u8,
-    performance_move: u8,
-    allocation_units: u8,
-    erase_size: u16,
-    erase_timeout: u8,
-    erase_offset: u8,
+    pub bus_width: u8,
+    pub secure_mode: u8,
+    pub card_type: u16,
+    pub protected_area_size: u32,
+    pub speed_class: u8,
+    pub performance_move: u8,
+    pub allocation_units: u8,
+    pub erase_size: u16,
+    pub erase_timeout: u8,
+    pub erase_offset: u8,
 }
 
 #[derive(Debug, Default)]