use std::thread;
use std::time::{Duration, Instant};
use embedded_hal::blocking::delay::{DelayMs, DelayUs};
use embedded_hal::timer::CountDown;
use void::Void;
#[derive(Debug, Default)]
pub struct Delay {}
impl Delay {
pub fn new() -> Delay {
Delay {}
}
}
impl DelayMs<u8> for Delay {
fn delay_ms(&mut self, ms: u8) {
thread::sleep(Duration::from_millis(u64::from(ms)));
}
}
impl DelayMs<u16> for Delay {
fn delay_ms(&mut self, ms: u16) {
thread::sleep(Duration::from_millis(u64::from(ms)));
}
}
impl DelayMs<u32> for Delay {
fn delay_ms(&mut self, ms: u32) {
thread::sleep(Duration::from_millis(u64::from(ms)));
}
}
impl DelayMs<u64> for Delay {
fn delay_ms(&mut self, ms: u64) {
thread::sleep(Duration::from_millis(ms));
}
}
impl DelayUs<u8> for Delay {
fn delay_us(&mut self, us: u8) {
thread::sleep(Duration::from_micros(u64::from(us)));
}
}
impl DelayUs<u16> for Delay {
fn delay_us(&mut self, us: u16) {
thread::sleep(Duration::from_micros(u64::from(us)));
}
}
impl DelayUs<u32> for Delay {
fn delay_us(&mut self, us: u32) {
thread::sleep(Duration::from_micros(u64::from(us)));
}
}
impl DelayUs<u64> for Delay {
fn delay_us(&mut self, us: u64) {
thread::sleep(Duration::from_micros(us));
}
}
pub struct Hertz(pub f64);
const MICROS_PER_SEC: f64 = 1_000_000.0;
impl From<Hertz> for Duration {
fn from(item: Hertz) -> Self {
if item.0 > 0.0 && item.0.is_finite() {
Duration::from_micros(((1.0 / item.0) * MICROS_PER_SEC) as u64)
} else {
Duration::default()
}
}
}
#[derive(Debug, Copy, Clone)]
pub struct Timer {
now: Instant,
duration: Duration,
}
impl Timer {
pub fn new() -> Self {
Self {
now: Instant::now(),
duration: Duration::from_micros(0),
}
}
}
impl Default for Timer {
fn default() -> Self {
Timer::new()
}
}
impl CountDown for Timer {
type Time = Duration;
fn start<T>(&mut self, timeout: T)
where
T: Into<Self::Time>,
{
self.duration = timeout.into();
self.now = Instant::now();
}
fn wait(&mut self) -> nb::Result<(), Void> {
if self.now.elapsed() >= self.duration {
Ok(())
} else {
Err(nb::Error::WouldBlock)
}
}
}