drone-stm32 0.8.3

Drone for STM32.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

//! Timers and watchdogs.

mod sys_tick;

pub use self::sys_tick::{SysTick, SysTickRes};

use drone_core::bitfield::Bitfield;
use drone_core::drv::Resource;
use futures::prelude::*;

/// Error returned from [`Timer::interval`](Timer::interval) on overflow.
#[derive(Debug, Fail)]
#[fail(display = "Timer stream overflow.")]
pub struct TimerOverflow;

/// Timer driver.
#[derive(Driver)]
pub struct Timer<T: TimerRes>(T);

/// Timer resource.
#[allow(missing_docs)]
pub trait TimerRes: Resource {
  type Duration;
  type CtrlVal: Bitfield;
  type SleepFuture: Future<Item = (), Error = !> + Send;
  type IntervalStream: Stream<Item = (), Error = TimerOverflow> + Send;
  type IntervalSkipStream: Stream<Item = (), Error = !> + Send;

  fn sleep(
    &mut self,
    dur: Self::Duration,
    ctrl_val: Self::CtrlVal,
  ) -> Self::SleepFuture;

  fn interval(
    &mut self,
    dur: Self::Duration,
    ctrl_val: Self::CtrlVal,
  ) -> Self::IntervalStream;

  fn interval_skip(
    &mut self,
    dur: Self::Duration,
    ctrl_val: Self::CtrlVal,
  ) -> Self::IntervalSkipStream;

  fn stop(&mut self, ctrl_val: Self::CtrlVal);
}

impl<T: TimerRes> Timer<T> {
  /// Returns a future that completes once `dur` ticks have elapsed.
  #[inline(always)]
  pub fn sleep(
    &mut self,
    dur: T::Duration,
    ctrl_val: T::CtrlVal,
  ) -> T::SleepFuture {
    self.0.sleep(dur, ctrl_val)
  }

  /// Returns a stream that resolves every `dur` ticks.
  #[inline(always)]
  pub fn interval(
    &mut self,
    dur: T::Duration,
    ctrl_val: T::CtrlVal,
  ) -> T::IntervalStream {
    self.0.interval(dur, ctrl_val)
  }

  /// Returns a stream that resolves every `dur` ticks. Skips overflow.
  #[inline(always)]
  pub fn interval_skip(
    &mut self,
    dur: T::Duration,
    ctrl_val: T::CtrlVal,
  ) -> T::IntervalSkipStream {
    self.0.interval_skip(dur, ctrl_val)
  }

  /// Stops the timer.
  #[inline(always)]
  pub fn stop(&mut self, ctrl_val: T::CtrlVal) {
    self.0.stop(ctrl_val)
  }
}