delay at least, update e-hal 1.0-rc2

CHANGELOG.md

@@ -9,12 +9,19 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 - Added an example to show how to do DMA with UART (Rx only) [#698]
 - Updated `synopsys-usb-otg` to `0.4.0`
+### Added
+
+ - Added an example to show how to do DMA with UART (Rx only) [#698]
+
+### Changed
+
+ - bump embedded-hal to `1.0-rc2`
 
 ### Fixed
 
-## [v0.18.0] - 2023-11-19
+ - Wait at least given time in `embedded-hal` `delay`
 
-### Changed
+## [v0.18.0] - 2023-11-19
 
  - bump embedded-hal to `1.0-rc1` (remove `serial` part)
  - complete and rework Dma Stream API [#666]

Cargo.toml

@@ -42,7 +42,7 @@ void = { default-features = false, version = "1.0.2" }
 embedded-hal = { features = ["unproven"], version = "0.2.7" }
 embedded-hal-nb = "1.0.0-rc.1"
 display-interface = { version = "0.4.1", optional = true }
-fugit = "0.3.6"
+fugit = "0.3.7"
 fugit-timer = "0.1.3"
 rtic-monotonic = { version = "1.0", optional = true }
 systick-monotonic = { version = "1.0", optional = true }
@@ -55,7 +55,7 @@ version = "0.3.14"
 default-features = false
 
 [dependencies.embedded-hal-one]
-version = "=1.0.0-rc.1"
+version = "=1.0.0-rc.2"
 package = "embedded-hal"
 
 [dependencies.stm32_i2s_v12x]

src/dwt.rs

@@ -114,7 +114,14 @@ impl<T: Into<u64>> embedded_hal::blocking::delay::DelayMs<T> for Delay {
  }
 }
 
-impl embedded_hal_one::delay::DelayUs for Delay {
+impl embedded_hal_one::delay::DelayNs for Delay {
+ fn delay_ns(&mut self, ns: u32) {
+ // Convert us to ticks
+ let start = DWT::cycle_count();
+ let ticks = (ns as u64 * self.clock.raw() as u64) / 1_000_000_000;
+ Delay::delay_ticks(start, ticks);
+ }
+
  fn delay_us(&mut self, us: u32) {
  // Convert us to ticks
  let start = DWT::cycle_count();

src/timer/delay.rs

@@ -110,7 +110,10 @@ pub type DelayMs<TIM> = Delay<TIM, 1_000>;
 impl<TIM: Instance, const FREQ: u32> Delay<TIM, FREQ> {
  /// Sleep for given time
  pub fn delay(&mut self, time: TimerDurationU32<FREQ>) {
- let mut ticks = time.ticks().max(1) - 1;
+ let mut ticks = time.ticks();
+ if ticks > 1 {
+ ticks -= 1;
+ }
  while ticks != 0 {
  let reload = ticks.min(TIM::max_auto_reload());
 

src/timer/hal_02.rs

@@ -7,7 +7,7 @@ use embedded_hal::{
  blocking::delay::{DelayMs, DelayUs},
  timer::{Cancel, CountDown, Periodic},
 };
-use fugit::{ExtU32, HertzU32 as Hertz, TimerDurationU32};
+use fugit::{ExtU32Ceil, HertzU32 as Hertz, TimerDurationU32};
 use void::Void;
 
 use super::{
@@ -16,36 +16,42 @@ use super::{
 };
 
 impl DelayUs<u32> for SysDelay {
+ #[inline]
  fn delay_us(&mut self, us: u32) {
- self.delay(us.micros())
+ self.delay(us.micros_at_least())
  }
 }
 
 impl DelayMs<u32> for SysDelay {
+ #[inline]
  fn delay_ms(&mut self, ms: u32) {
- self.delay_us(ms * 1_000);
+ self.delay(ms.millis_at_least());
  }
 }
 
 impl DelayUs<u16> for SysDelay {
+ #[inline]
  fn delay_us(&mut self, us: u16) {
  self.delay_us(us as u32)
  }
 }
 
 impl DelayMs<u16> for SysDelay {
+ #[inline]
  fn delay_ms(&mut self, ms: u16) {
  self.delay_ms(ms as u32);
  }
 }
 
 impl DelayUs<u8> for SysDelay {
+ #[inline]
  fn delay_us(&mut self, us: u8) {
  self.delay_us(us as u32)
  }
 }
 
 impl DelayMs<u8> for SysDelay {
+ #[inline]
  fn delay_ms(&mut self, ms: u8) {
  self.delay_ms(ms as u32);
  }
@@ -198,40 +204,40 @@ where
 impl<TIM: Instance, const FREQ: u32> DelayUs<u32> for Delay<TIM, FREQ> {
  /// Sleep for `us` microseconds
  fn delay_us(&mut self, us: u32) {
- self.delay(us.micros())
+ self.delay(us.micros_at_least())
  }
 }
 
 impl<TIM: Instance, const FREQ: u32> DelayMs<u32> for Delay<TIM, FREQ> {
  /// Sleep for `ms` milliseconds
  fn delay_ms(&mut self, ms: u32) {
- self.delay(ms.millis())
+ self.delay(ms.millis_at_least())
  }
 }
 
 impl<TIM: Instance, const FREQ: u32> DelayUs<u16> for Delay<TIM, FREQ> {
  /// Sleep for `us` microseconds
  fn delay_us(&mut self, us: u16) {
- self.delay((us as u32).micros())
+ self.delay((us as u32).micros_at_least())
  }
 }
 impl<TIM: Instance, const FREQ: u32> DelayMs<u16> for Delay<TIM, FREQ> {
  /// Sleep for `ms` milliseconds
  fn delay_ms(&mut self, ms: u16) {
- self.delay((ms as u32).millis())
+ self.delay((ms as u32).millis_at_least())
  }
 }
 
 impl<TIM: Instance, const FREQ: u32> DelayUs<u8> for Delay<TIM, FREQ> {
  /// Sleep for `us` microseconds
  fn delay_us(&mut self, us: u8) {
- self.delay((us as u32).micros())
+ self.delay((us as u32).micros_at_least())
  }
 }
 impl<TIM: Instance, const FREQ: u32> DelayMs<u8> for Delay<TIM, FREQ> {
  /// Sleep for `ms` milliseconds
  fn delay_ms(&mut self, ms: u8) {
- self.delay((ms as u32).millis())
+ self.delay((ms as u32).millis_at_least())
  }
 }
 

src/timer/hal_1.rs

@@ -4,28 +4,32 @@
 //! a 16-bit prescaler.
 
 use core::convert::Infallible;
-use embedded_hal_one::delay::DelayUs;
+use embedded_hal_one::delay::DelayNs;
 
 use super::{Delay, Instance, PwmChannel, SysDelay, WithPwm};
-use fugit::ExtU32;
+use fugit::ExtU32Ceil;
 
-impl DelayUs for SysDelay {
- fn delay_us(&mut self, us: u32) {
- self.delay(us.micros());
+impl DelayNs for SysDelay {
+ fn delay_ns(&mut self, ns: u32) {
+ self.delay(ns.nanos_at_least());
  }
 
  fn delay_ms(&mut self, ms: u32) {
- self.delay_us(ms * 1_000);
+ self.delay(ms.millis_at_least());
  }
 }
 
-impl<TIM: Instance, const FREQ: u32> DelayUs for Delay<TIM, FREQ> {
+impl<TIM: Instance, const FREQ: u32> DelayNs for Delay<TIM, FREQ> {
+ fn delay_ns(&mut self, ns: u32) {
+ self.delay(ns.micros_at_least());
+ }
+
  fn delay_us(&mut self, us: u32) {
- self.delay(us.micros());
+ self.delay(us.micros_at_least());
  }
 
  fn delay_ms(&mut self, ms: u32) {
- self.delay(ms.millis());
+ self.delay(ms.millis_at_least());
  }
 }
 
@@ -36,7 +40,7 @@ impl<TIM: Instance + WithPwm, const C: u8> embedded_hal_one::pwm::ErrorType for
 impl<TIM: Instance + WithPwm, const C: u8> embedded_hal_one::pwm::SetDutyCycle
  for PwmChannel<TIM, C>
 {
- fn get_max_duty_cycle(&self) -> u16 {
+ fn max_duty_cycle(&self) -> u16 {
  self.get_max_duty()
  }
  fn set_duty_cycle(&mut self, duty: u16) -> Result<(), Self::Error> {