Merge #262 #267

262: Add glue to make embedded-sdmmc work nicely r=richardeoin a=olback

It would have been nice to implement `embedded:BlockDevice` directly on `Sdmmc<$SDMMCX>` but that is not possible since `BlockDevice` takes `&self` and the methods that already exist take `&mut self`.

267: USART additions r=richardeoin a=richardeoin

Follow on from #261 

* Add synchronous flag to serial_unchecked method
* Set synchronous bits on USART peripherals only, for others they are reserved
* Add builder methods for USART configuration fields
* Add an example of synchronous USART operation

Co-authored-by: Edwin Svensson <git@olback.net>
Co-authored-by: Richard Meadows <962920+richardeoin@users.noreply.github.com>

Author: 3 people

Cargo.toml

@@ -30,11 +30,12 @@ embedded-dma = "0.1.2"
 cortex-m = "^0.7.1"
 stm32h7 = "^0.14.0"
 void = { version = "1.0.2", default-features = false }
-cast = { version = "0.2.3", default-features = false }
+cast = { version = "0.3.0", default-features = false }
 nb = "1.0.0"
 paste = "1.0.1"
 bare-metal = "1.0.0"
-sdio-host = { version = "0.4", optional = true }
+sdio-host = { version = "0.5", optional = true }
+embedded-sdmmc = { version = "0.3", optional = true }
 stm32-fmc = { version = "0.2", optional = true }
 synopsys-usb-otg = { version = "^0.2.4", features = ["cortex-m"], optional = true }
 embedded-display-controller = { version = "^0.1.0", optional = true }
@@ -88,6 +89,7 @@ ltdc = ["embedded-display-controller"]
 quadspi = []
 fmc = ["stm32-fmc"]
 sdmmc = ["sdio-host"]
+sdmmc-fatfs = ["embedded-sdmmc", "sdmmc"]
 ethernet = ["smoltcp"]
 rtc = ["chrono"]
 crc = []
@@ -153,6 +155,10 @@ required-features = ["quadspi", "rm0433"]
 name = "sdmmc"
 required-features = ["sdmmc", "rm0433"]
 
+[[example]]
+name = "sdmmc_fat"
+required-features = ["sdmmc", "sdmmc-fatfs", "stm32h747cm7"]
+
 [[example]]
 name = "ethernet-stm32h747i-disco"
 required-features = ["rt", "stm32h747cm7", "ethernet"]

examples/sdmmc_fat.rs

@@ -0,0 +1,105 @@
+#![no_main]
+#![no_std]
+
+use {
+    embedded_sdmmc::{Controller, VolumeIdx},
+    log,
+    stm32h7xx_hal::{pac, prelude::*, rcc},
+};
+
+#[macro_use]
+mod utilities;
+
+// This is just a placeholder TimeSource. In a real world application
+// one would probably use the RTC to provide time.
+pub struct TimeSource;
+
+impl embedded_sdmmc::TimeSource for TimeSource {
+    fn get_timestamp(&self) -> embedded_sdmmc::Timestamp {
+        embedded_sdmmc::Timestamp {
+            year_since_1970: 0,
+            zero_indexed_month: 0,
+            zero_indexed_day: 0,
+            hours: 0,
+            minutes: 0,
+            seconds: 0,
+        }
+    }
+}
+
+#[cortex_m_rt::entry]
+unsafe fn main() -> ! {
+    utilities::logger::init();
+
+    // Get peripherals
+    let cp = cortex_m::Peripherals::take().unwrap();
+    let dp = pac::Peripherals::take().unwrap();
+
+    // Constrain and Freeze power
+    let pwr = dp.PWR.constrain();
+    let pwrcfg = example_power!(pwr).freeze();
+
+    // Constrain and Freeze clock
+    let ccdr = dp
+        .RCC
+        .constrain()
+        .sys_ck(480.mhz())
+        .pll1_strategy(rcc::PllConfigStrategy::Iterative)
+        .pll1_q_ck(100.mhz())
+        .pll2_strategy(rcc::PllConfigStrategy::Iterative)
+        .pll3_strategy(rcc::PllConfigStrategy::Iterative)
+        .freeze(pwrcfg, &dp.SYSCFG);
+
+    // Get the delay provider.
+    let mut delay = cp.SYST.delay(ccdr.clocks);
+
+    let gpiob = dp.GPIOB.split(ccdr.peripheral.GPIOB);
+    let gpiod = dp.GPIOD.split(ccdr.peripheral.GPIOD);
+
+    let mut sd = dp.SDMMC2.sdmmc(
+        (
+            gpiod.pd6.into_alternate_af11(),
+            gpiod.pd7.into_alternate_af11(),
+            gpiob.pb14.into_alternate_af9(),
+            gpiob.pb15.into_alternate_af9(),
+            gpiob.pb3.into_alternate_af9(),
+            gpiob.pb4.into_alternate_af9(),
+        ),
+        ccdr.peripheral.SDMMC2,
+        &ccdr.clocks,
+    );
+
+    // Loop until we have a card
+    loop {
+        // On most development boards this can be increased up to 50MHz. We choose a
+        // lower frequency here so that it should work even with flying leads
+        // connected to a SD card breakout.
+        match sd.init_card(2.mhz()) {
+            Ok(_) => break,
+            Err(err) => {
+                log::info!("Init err: {:?}", err);
+            }
+        }
+
+        log::info!("Waiting for card...");
+
+        delay.delay_ms(1000u32);
+    }
+
+    // See https://github.com/rust-embedded-community/embedded-sdmmc-rs for docs
+    // and more examples
+
+    let mut sd_fatfs = Controller::new(sd.sdmmc_block_device(), TimeSource);
+    let sd_fatfs_volume = sd_fatfs.get_volume(VolumeIdx(0)).unwrap();
+    let sd_fatfs_root_dir = sd_fatfs.open_root_dir(&sd_fatfs_volume).unwrap();
+    sd_fatfs
+        .iterate_dir(&sd_fatfs_volume, &sd_fatfs_root_dir, |entry| {
+            log::info!("{:?}", entry);
+        })
+        .unwrap();
+    sd_fatfs.close_dir(&sd_fatfs_volume, sd_fatfs_root_dir);
+
+    loop {
+        cortex_m::asm::nop()
+    }
+}

examples/serial-advanced.rs

@@ -0,0 +1,53 @@
+#![no_main]
+#![no_std]
+
+use cortex_m_rt::entry;
+#[macro_use]
+mod utilities;
+use log::info;
+
+use stm32h7xx_hal::{pac, prelude::*, serial::config::Config};
+
+use core::fmt::Write;
+
+#[entry]
+fn main() -> ! {
+    utilities::logger::init();
+    let dp = pac::Peripherals::take().unwrap();
+
+    // Constrain and Freeze power
+    info!("Setup PWR...                  ");
+    let pwr = dp.PWR.constrain();
+    let pwrcfg = example_power!(pwr).freeze();
+
+    // Constrain and Freeze clock
+    info!("Setup RCC...                  ");
+    let rcc = dp.RCC.constrain();
+    let ccdr = rcc.sys_ck(160.mhz()).freeze(pwrcfg, &dp.SYSCFG);
+
+    // Acquire the GPIOC peripheral. This also enables the clock for
+    // GPIOC in the RCC register.
+    let gpioc = dp.GPIOC.split(ccdr.peripheral.GPIOC);
+
+    let tx = gpioc.pc10.into_alternate_af7();
+    let rx = gpioc.pc11.into_alternate_af7();
+    let clk = gpioc.pc12.into_alternate_af7();
+
+    info!("");
+    info!("stm32h7xx-hal example - USART Advanced");
+    info!("");
+
+    // Configure the serial peripheral in synchronous mode
+    let config = Config::new(115_200.bps()).lastbitclockpulse(true);
+    let serial = dp
+        .USART3
+        .serial((tx, rx, clk), config, ccdr.peripheral.USART3, &ccdr.clocks)
+        .unwrap();
+
+    let (mut tx, _rx) = serial.split();
+
+    loop {
+        // core::fmt::Write is implemented for tx.
+        writeln!(tx, "Hello, world!").unwrap();
+    }
+}

src/sdmmc.rs

@@ -1142,6 +1142,54 @@ macro_rules! sdmmc {
                     Ok(())
                 }
 
+                #[cfg(feature = "sdmmc-fatfs")]
+                pub fn sdmmc_block_device(self) -> SdmmcBlockDevice<Sdmmc<$SDMMCX>> {
+                    SdmmcBlockDevice {
+                        sdmmc: core::cell::RefCell::new(self)
+                    }
+                }
+
+            }
+
+            #[cfg(feature = "sdmmc-fatfs")]
+            impl embedded_sdmmc::BlockDevice for SdmmcBlockDevice<Sdmmc<$SDMMCX>> {
+                type Error = Error;
+
+                fn read(
+                    &self,
+                    blocks: &mut [embedded_sdmmc::Block],
+                    start_block_idx: embedded_sdmmc::BlockIdx,
+                    _reason: &str,
+                ) -> Result<(), Self::Error> {
+                    let start = start_block_idx.0;
+                    let mut sdmmc = self.sdmmc.borrow_mut();
+                    for block_idx in start..(start + blocks.len() as u32) {
+                        sdmmc.read_block(
+                            block_idx,
+                            &mut blocks[(block_idx - start) as usize].contents,
+                        )?;
+                    }
+                    Ok(())
+                }
+
+                fn write(
+                    &self,
+                    blocks: &[embedded_sdmmc::Block],
+                    start_block_idx: embedded_sdmmc::BlockIdx,
+                ) -> Result<(), Self::Error> {
+                    let start = start_block_idx.0;
+                    let mut sdmmc = self.sdmmc.borrow_mut();
+                    for block_idx in start..(start + blocks.len() as u32) {
+                        sdmmc.write_block(block_idx, &blocks[(block_idx - start) as usize].contents)?;
+                    }
+                    Ok(())
+                }
+
+                fn num_blocks(&self) -> Result<embedded_sdmmc::BlockCount, Self::Error> {
+                    let sdmmc = self.sdmmc.borrow_mut();
+                    Ok(embedded_sdmmc::BlockCount(sdmmc.card()?.size() as u32 / 512u32))
+                }
+
             }
         )+
     };
@@ -1238,3 +1286,15 @@ impl Cmd {
         Cmd::new(55, rca, Response::Short)
     }
 }
+
+#[cfg(feature = "sdmmc-fatfs")]
+pub struct SdmmcBlockDevice<SDMMC> {
+    sdmmc: core::cell::RefCell<SDMMC>,
+}
+
+#[cfg(feature = "sdmmc-fatfs")]
+impl<SDMMC> SdmmcBlockDevice<SDMMC> {
+    pub fn free(self) -> SDMMC {
+        self.sdmmc.into_inner()
+    }
+}