Remove cast in favor of core::convert

Author: Sh3Rm4n

Cargo.toml

@@ -41,10 +41,6 @@ optional = true
 version = "0.2"
 features = ["const-fn"]
 
-[dependencies.cast]
-version = "0.2"
-default-features = false
-
 [dependencies.stm32-usbd]
 version = "0.5"
 optional = true

src/delay.rs

@@ -1,6 +1,7 @@
 //! Delays
 
-use cast::u32;
+use core::convert::From;
+
 use cortex_m::peripheral::syst::SystClkSource;
 use cortex_m::peripheral::SYST;
 
@@ -35,13 +36,13 @@ impl DelayMs<u32> for Delay {
 
 impl DelayMs<u16> for Delay {
     fn delay_ms(&mut self, ms: u16) {
-        self.delay_ms(u32(ms));
+        self.delay_ms(u32::from(ms));
     }
 }
 
 impl DelayMs<u8> for Delay {
     fn delay_ms(&mut self, ms: u8) {
-        self.delay_ms(u32(ms));
+        self.delay_ms(u32::from(ms));
     }
 }
 
@@ -63,12 +64,12 @@ impl DelayUs<u32> for Delay {
 
 impl DelayUs<u16> for Delay {
     fn delay_us(&mut self, us: u16) {
-        self.delay_us(u32(us))
+        self.delay_us(u32::from(us))
     }
 }
 
 impl DelayUs<u8> for Delay {
     fn delay_us(&mut self, us: u8) {
-        self.delay_us(u32(us))
+        self.delay_us(u32::from(us))
     }
 }

src/dma.rs

@@ -12,8 +12,8 @@ use crate::{
     rcc::AHB,
     serial,
 };
-use cast::u16;
 use core::{
+    convert::TryFrom,
     mem,
     sync::atomic::{self, Ordering},
 };
@@ -57,7 +57,7 @@ impl<B, C: Channel, T: Target> Transfer<B, C, T> {
         // method we can call is `write_buffer`, which is allowed by
         // `WriteBuffer`'s safety requirements.
         let (ptr, len) = unsafe { buffer.write_buffer() };
-        let len = u16(len).expect("buffer is too large");
+        let len = u16::try_from(len).expect("buffer is too large");
 
         // NOTE(unsafe) We are using the address of a 'static WriteBuffer here,
         // which is guaranteed to be safe for DMA.
@@ -84,7 +84,7 @@ impl<B, C: Channel, T: Target> Transfer<B, C, T> {
         // `&mut self` methods we can call, so we are safe according to
         // `ReadBuffer`'s safety requirements.
         let (ptr, len) = unsafe { buffer.read_buffer() };
-        let len = u16(len).expect("buffer is too large");
+        let len = u16::try_from(len).expect("buffer is too large");
 
         // NOTE(unsafe) We are using the address of a 'static ReadBuffer here,
         // which is guaranteed to be safe for DMA.

src/i2c.rs

@@ -1,13 +1,14 @@
 //! Inter-Integrated Circuit (I2C) bus
 
+use core::convert::TryFrom;
+
 use crate::{
     gpio::{gpioa, gpiob, gpiof, AF4},
     hal::blocking::i2c::{Read, Write, WriteRead},
     pac::{I2C1, I2C2},
     rcc::{Clocks, APB1},
     time::Hertz,
 };
-use cast::u8;
 
 /// I2C error
 #[derive(Debug)]
@@ -152,28 +153,25 @@ macro_rules! hal {
                         (presc, scll, sclh, sdadel, scldel)
                     };
 
-                    let presc = u8(presc).unwrap();
                     assert!(presc < 16);
-                    let scldel = u8(scldel).unwrap();
                     assert!(scldel < 16);
-                    let sdadel = u8(sdadel).unwrap();
                     assert!(sdadel < 16);
-                    let sclh = u8(sclh).unwrap();
-                    let scll = u8(scll).unwrap();
+                    let sclh = u8::try_from(sclh).unwrap();
+                    let scll = u8::try_from(scll).unwrap();
 
                     // Configure for "fast mode" (400 KHz)
                     // NOTE(write): writes all non-reserved bits.
                     i2c.timingr.write(|w| {
                         w.presc()
-                            .bits(presc)
+                            .bits(presc as u8)
+                            .sdadel()
+                            .bits(sdadel as u8)
+                            .scldel()
+                            .bits(scldel as u8)
                             .scll()
                             .bits(scll)
                             .sclh()
                             .bits(sclh)
-                            .sdadel()
-                            .bits(sdadel)
-                            .scldel()
-                            .bits(scldel)
                     });
 
                     // Enable the peripheral

src/timer.rs

@@ -1,5 +1,7 @@
 //! Timers
 
+use core::convert::{From, TryFrom};
+
 use crate::hal::timer::{CountDown, Periodic};
 #[cfg(any(
     feature = "stm32f301",
@@ -49,7 +51,6 @@ use crate::pac::{TIM15, TIM16, TIM17, TIM2, TIM6};
 ))]
 use crate::pac::{TIM3, TIM7};
 
-use cast::{u16, u32};
 use void::Void;
 
 use crate::rcc::{Clocks, APB1, APB2};
@@ -99,16 +100,16 @@ macro_rules! hal {
                     let timer_clock = $TIMX::get_clk(&self.clocks);
                     let ticks = timer_clock.0 * if self.clocks.ppre1() == 1 { 1 } else { 2 }
                         / frequency;
-                    let psc = u16((ticks - 1) / (1 << 16)).unwrap();
+                    let psc = u16::try_from((ticks - 1) / (1 << 16)).unwrap();
 
                     // NOTE(write): uses all bits in this register.
                     self.tim.psc.write(|w| w.psc().bits(psc));
 
-                    let arr = u16(ticks / u32(psc + 1)).unwrap();
+                    let arr = u16::try_from(ticks / u32::from(psc + 1)).unwrap();
 
                     // TODO (sh3rm4n)
                     // self.tim.arr.write(|w| { w.arr().bits(arr) });
-                    self.tim.arr.write(|w| unsafe { w.bits(u32(arr)) });
+                    self.tim.arr.write(|w| unsafe { w.bits(u32::from(arr)) });
 
                     // Trigger an update event to load the prescaler value to the clock
                     // NOTE(write): uses all bits in this register.