Renamed some types and cleaned up some clippy lints.

Changed BlockSpi to AcquiredSdCard.
Changed SdMmcSpi to SdCard.

Author: jonathanpallant

CHANGELOG.md

@@ -10,6 +10,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 [Unreleased]: https://github.com/rust-embedded-community/embedded-sdmmc-rs/compare/v0.4.0...develop
 
 - Renamed `Controller` to `VolumeManager`, to better describe what it does.
+- Renamed `SdMmcSpi` to `SdCard`
+- Renamed `BlockSpi` to `AcquiredSdCard`
 
 ## [Version 0.4.0](https://github.com/rust-embedded-community/embedded-sdmmc-rs/releases/tag/v0.4.0)
 

README.md

@@ -12,10 +12,10 @@ You will need something that implements the `BlockDevice` trait, which can read
 
 ```rust
 // Build an SD Card interface out of an SPI device
-let mut spi_dev = embedded_sdmmc::SdMmcSpi::new(sdmmc_spi, sdmmc_cs);
+let mut spi_dev = embedded_sdmmc::SdCard::new(sdmmc_spi, sdmmc_cs);
 // Try and initialise the SD card
 let block_dev = spi_dev.acquire()?;
-// The SD Card was initialised, and we have a `BlockSpi` object
+// The SD Card was initialised, and we have a `AcquiredSdCard` object
 // representing the initialised card.
 write!(uart, "Card size is {} bytes", block_dev.card_size_bytes()?)?;
 // Now let's look for volumes (also known as partitions) on our block device.

src/fat/volume.rs

@@ -149,7 +149,7 @@ impl FatVolume {
             }
             FatSpecificInfo::Fat32(_fat32_info) => {
                 // FAT32 => 4 bytes per entry
-                let fat_offset = cluster.0 as u32 * 4;
+                let fat_offset = cluster.0 * 4;
                 this_fat_block_num = self.lba_start + self.fat_start.offset_bytes(fat_offset);
                 let this_fat_ent_offset = (fat_offset % Block::LEN_U32) as usize;
                 volume_mgr

src/filesystem/filename.rs

@@ -81,12 +81,7 @@ impl ShortFileName {
                     }
                 }
                 _ => {
-                    let ch = if (b'a'..=b'z').contains(&ch) {
-                        // Uppercase characters only
-                        ch - 32
-                    } else {
-                        ch
-                    };
+                    let ch = ch.to_ascii_uppercase();
                     if seen_dot {
                         if (Self::FILENAME_BASE_MAX_LEN..Self::FILENAME_MAX_LEN).contains(&idx) {
                             sfn.contents[idx] = ch;

src/filesystem/timestamp.rs

@@ -27,7 +27,7 @@ pub struct Timestamp {
 impl Timestamp {
     /// Create a `Timestamp` from the 16-bit FAT date and time fields.
     pub fn from_fat(date: u16, time: u16) -> Timestamp {
-        let year = (1980 + (date >> 9)) as u16;
+        let year = 1980 + (date >> 9);
         let month = ((date >> 5) & 0x000F) as u8;
         let day = (date & 0x001F) as u8;
         let hours = ((time >> 11) & 0x001F) as u8;

src/lib.rs

@@ -40,7 +40,7 @@
 //! # let mut sdmmc_spi = DummySpi;
 //! # let mut sdmmc_cs = DummyCsPin;
 //! # let time_source = DummyTimeSource;
-//! let mut spi_dev = embedded_sdmmc::SdMmcSpi::new(sdmmc_spi, sdmmc_cs);
+//! let mut spi_dev = embedded_sdmmc::SdCard::new(sdmmc_spi, sdmmc_cs);
 //! let block = spi_dev.acquire()?;
 //! println!("Card size {} bytes", block.card_size_bytes()?);
 //! let mut volume_mgr = VolumeManager::new(block, time_source);
@@ -101,7 +101,7 @@ pub use crate::filesystem::{
     Timestamp, MAX_FILE_SIZE,
 };
 pub use crate::sdmmc::Error as SdMmcError;
-pub use crate::sdmmc::{BlockSpi, SdMmcSpi};
+pub use crate::sdmmc::{AcquiredSdCard, SdCard};
 
 mod volume_mgr;
 pub use volume_mgr::VolumeManager;

src/sdmmc.rs

@@ -22,7 +22,7 @@ const DEFAULT_DELAY_COUNT: u32 = 32_000;
 /// Built from an SPI peripheral and a Chip
 /// Select pin. We need Chip Select to be separate so we can clock out some
 /// bytes without Chip Select asserted (which puts the card into SPI mode).
-pub struct SdMmcSpi<SPI, CS>
+pub struct SdCard<SPI, CS>
 where
     SPI: embedded_hal::blocking::spi::Transfer<u8>,
     CS: embedded_hal::digital::v2::OutputPin,
@@ -35,15 +35,16 @@ where
 }
 
 /// An initialized block device used to access the SD card.
-/// **Caution**: any data must be flushed manually before dropping `BlockSpi`, see `deinit`.
+///
+/// **Caution**: any data must be flushed manually before dropping `AcquiredSdCard`, see `deinit`.
 /// Uses SPI mode.
-pub struct BlockSpi<'a, SPI, CS>(&'a mut SdMmcSpi<SPI, CS>)
+pub struct AcquiredSdCard<'a, SPI, CS>(&'a mut SdCard<SPI, CS>)
 where
     SPI: embedded_hal::blocking::spi::Transfer<u8>,
     CS: embedded_hal::digital::v2::OutputPin,
     <SPI as embedded_hal::blocking::spi::Transfer<u8>>::Error: core::fmt::Debug;
 
-/// The possible errors `SdMmcSpi` can generate.
+/// The possible errors this crate can generate.
 #[cfg_attr(feature = "defmt-log", derive(defmt::Format))]
 #[derive(Debug, Copy, Clone)]
 pub enum Error {
@@ -77,7 +78,7 @@ pub enum Error {
     GpioError,
 }
 
-/// The possible states `SdMmcSpi` can be in.
+/// The possible states `SdCard` can be in.
 #[cfg_attr(feature = "defmt-log", derive(defmt::Format))]
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum State {
@@ -92,6 +93,7 @@ pub enum State {
 /// The different types of card we support.
 #[cfg_attr(feature = "defmt-log", derive(defmt::Format))]
 #[derive(Debug, Copy, Clone, PartialEq)]
+#[allow(clippy::upper_case_acronyms)]
 enum CardType {
     SD1,
     SD2,
@@ -137,15 +139,15 @@ impl Default for AcquireOpts {
     }
 }
 
-impl<SPI, CS> SdMmcSpi<SPI, CS>
+impl<SPI, CS> SdCard<SPI, CS>
 where
     SPI: embedded_hal::blocking::spi::Transfer<u8>,
     CS: embedded_hal::digital::v2::OutputPin,
     <SPI as embedded_hal::blocking::spi::Transfer<u8>>::Error: core::fmt::Debug,
 {
     /// Create a new SD/MMC interface using a raw SPI interface.
-    pub fn new(spi: SPI, cs: CS) -> SdMmcSpi<SPI, CS> {
-        SdMmcSpi {
+    pub fn new(spi: SPI, cs: CS) -> SdCard<SPI, CS> {
+        SdCard {
             spi: RefCell::new(spi),
             cs: RefCell::new(cs),
             card_type: CardType::SD1,
@@ -165,12 +167,15 @@ where
     }
 
     /// Initializes the card into a known state
-    pub fn acquire(&mut self) -> Result<BlockSpi<SPI, CS>, Error> {
+    pub fn acquire(&mut self) -> Result<AcquiredSdCard<SPI, CS>, Error> {
         self.acquire_with_opts(Default::default())
     }
 
     /// Initializes the card into a known state
-    pub fn acquire_with_opts(&mut self, options: AcquireOpts) -> Result<BlockSpi<SPI, CS>, Error> {
+    pub fn acquire_with_opts(
+        &mut self,
+        options: AcquireOpts,
+    ) -> Result<AcquiredSdCard<SPI, CS>, Error> {
         debug!("acquiring card with opts: {:?}", options);
         let f = |s: &mut Self| {
             // Assume it hasn't worked
@@ -269,7 +274,7 @@ where
         let result = f(self);
         self.cs_high()?;
         let _ = self.receive();
-        result.map(move |()| BlockSpi(self))
+        result.map(move |()| AcquiredSdCard(self))
     }
 
     /// Perform a function that might error with the chipselect low.
@@ -377,7 +382,7 @@ where
     }
 }
 
-impl<SPI, CS> BlockSpi<'_, SPI, CS>
+impl<SPI, CS> AcquiredSdCard<'_, SPI, CS>
 where
     SPI: embedded_hal::blocking::spi::Transfer<u8>,
     CS: embedded_hal::digital::v2::OutputPin,
@@ -517,7 +522,7 @@ impl<U: BlockDevice, T: Deref<Target = U>> BlockDevice for T {
     }
 }
 
-impl<SPI, CS> BlockDevice for BlockSpi<'_, SPI, CS>
+impl<SPI, CS> BlockDevice for AcquiredSdCard<'_, SPI, CS>
 where
     SPI: embedded_hal::blocking::spi::Transfer<u8>,
     <SPI as embedded_hal::blocking::spi::Transfer<u8>>::Error: core::fmt::Debug,
@@ -595,7 +600,7 @@ where
     }
 }
 
-impl<SPI, CS> Drop for BlockSpi<'_, SPI, CS>
+impl<SPI, CS> Drop for AcquiredSdCard<'_, SPI, CS>
 where
     SPI: embedded_hal::blocking::spi::Transfer<u8>,
     <SPI as embedded_hal::blocking::spi::Transfer<u8>>::Error: core::fmt::Debug,

src/volume_mgr.rs

@@ -237,7 +237,6 @@ where
                 break;
             }
         }
-        drop(dir);
     }
 
     /// Look in a directory for a named file.
@@ -603,7 +602,6 @@ where
                 break;
             }
         }
-        drop(file);
         Ok(())
     }