From 3342a183847922b7bf0b01b31ee41bdf7d1ac97a Mon Sep 17 00:00:00 2001
From: Hanno Braun <hanno@braun-embedded.com>
Date: Fri, 16 Oct 2020 15:39:19 +0200
Subject: [PATCH 1/7] Add inherent methods to MRT channels

This is a step in preparation for implementing the `CountDown` trait
from the alpha version of embedded-hal. These have different names
(`try_` prefix) and are fallible. Since we will most likely drop support
for the old version of embedded-hal at some point, I thought it best to
add the infallible versions as inherent methods now, instead of having
to make another change later.
---
 src/mrt.rs | 52 ++++++++++++++++++++++++++++++----------------------
 1 file changed, 30 insertions(+), 22 deletions(-)

diff --git a/src/mrt.rs b/src/mrt.rs
index d9d5c5b6a..ea04b952c 100644
--- a/src/mrt.rs
+++ b/src/mrt.rs
@@ -74,32 +74,13 @@ where
         Self(RegProxy::new())
     }
 
-    /// Returns the current timer value
-    pub fn value(&self) -> u32 {
-        self.0.timer.read().value().bits()
-    }
-}
-
-impl<T> CountDown for Channel<T>
-where
-    T: Trait,
-{
-    /// The timer operates in clock ticks from the system clock, that means it
-    /// runs at 12_000_000 ticks per second if you haven't changed it.
-    ///
-    /// It can also only use values smaller than 0x7FFFFFFF.
-    type Time = u32;
-
-    /// Start counting down from the given count
+    /// Start the timer
     ///
     /// The `reload` argument must be smaller than or equal to [`MAX_VALUE`].
     ///
     /// [`MAX_VALUE`]: constant.MAX_VALUE.html
-    fn start<Time>(&mut self, count: Time)
-    where
-        Time: Into<Self::Time>,
-    {
-        let reload: Self::Time = count.into();
+    pub fn start(&mut self, reload: impl Into<u32>) {
+        let reload = reload.into();
         debug_assert!(reload <= MAX_VALUE);
 
         // This stops the timer, to prevent race conditions when resetting the
@@ -114,6 +95,11 @@ where
             .write(|w| unsafe { w.ivalue().bits(reload + 1) });
     }
 
+    /// Returns the current timer value
+    pub fn value(&self) -> u32 {
+        self.0.timer.read().value().bits()
+    }
+
     /// Non-blockingly "waits" until the count down finishes
     fn wait(&mut self) -> Result<(), Void> {
         if self.0.stat.read().intflag().is_pending_interrupt() {
@@ -126,6 +112,28 @@ where
     }
 }
 
+impl<T> CountDown for Channel<T>
+where
+    T: Trait,
+{
+    /// The timer operates in clock ticks from the system clock, that means it
+    /// runs at 12_000_000 ticks per second if you haven't changed it.
+    ///
+    /// It can also only use values smaller than 0x7FFFFFFF.
+    type Time = u32;
+
+    fn start<Time>(&mut self, count: Time)
+    where
+        Time: Into<Self::Time>,
+    {
+        self.start(count);
+    }
+
+    fn wait(&mut self) -> Result<(), Void> {
+        self.wait()
+    }
+}
+
 impl<T> Periodic for Channel<T> where T: Trait {}
 
 /// Implemented for types that identify MRT channels

From 45e9979f2923859e89654152d44b4267e805830a Mon Sep 17 00:00:00 2001
From: Hanno Braun <hanno@braun-embedded.com>
Date: Fri, 16 Oct 2020 15:54:21 +0200
Subject: [PATCH 2/7] Make use of `nb` types explicit

---
 src/mrt.rs | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/mrt.rs b/src/mrt.rs
index ea04b952c..024154a68 100644
--- a/src/mrt.rs
+++ b/src/mrt.rs
@@ -13,7 +13,6 @@ use crate::{
 };
 
 use embedded_hal::timer::{CountDown, Periodic};
-use nb::{Error, Result};
 use void::Void;
 
 /// Represents the MRT instance
@@ -101,13 +100,13 @@ where
     }
 
     /// Non-blockingly "waits" until the count down finishes
-    fn wait(&mut self) -> Result<(), Void> {
+    fn wait(&mut self) -> nb::Result<(), Void> {
         if self.0.stat.read().intflag().is_pending_interrupt() {
             // Reset the interrupt flag
             self.0.stat.write(|w| w.intflag().set_bit());
             Ok(())
         } else {
-            Err(Error::WouldBlock)
+            Err(nb::Error::WouldBlock)
         }
     }
 }
@@ -129,7 +128,7 @@ where
         self.start(count);
     }
 
-    fn wait(&mut self) -> Result<(), Void> {
+    fn wait(&mut self) -> nb::Result<(), Void> {
         self.wait()
     }
 }

From abccc4e466535967c411ab18d12f91743bbdac3f Mon Sep 17 00:00:00 2001
From: Hanno Braun <hanno@braun-embedded.com>
Date: Fri, 16 Oct 2020 15:58:58 +0200
Subject: [PATCH 3/7] Add alpha version of embedded-hal traits for MRT

---
 src/mrt.rs | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/src/mrt.rs b/src/mrt.rs
index 024154a68..1cf98e6c4 100644
--- a/src/mrt.rs
+++ b/src/mrt.rs
@@ -13,6 +13,9 @@ use crate::{
 };
 
 use embedded_hal::timer::{CountDown, Periodic};
+use embedded_hal_alpha::timer::{
+    CountDown as CountDownAlpha, Periodic as PeriodicAlpha,
+};
 use void::Void;
 
 /// Represents the MRT instance
@@ -133,8 +136,34 @@ where
     }
 }
 
+impl<T> CountDownAlpha for Channel<T>
+where
+    T: Trait,
+{
+    type Error = Void;
+
+    /// The timer operates in clock ticks from the system clock, that means it
+    /// runs at 12_000_000 ticks per second if you haven't changed it.
+    ///
+    /// It can also only use values smaller than 0x7FFFFFFF.
+    type Time = u32;
+
+    fn try_start<Time>(&mut self, count: Time) -> Result<(), Self::Error>
+    where
+        Time: Into<Self::Time>,
+    {
+        Ok(self.start(count))
+    }
+
+    fn try_wait(&mut self) -> nb::Result<(), Self::Error> {
+        self.wait()
+    }
+}
+
 impl<T> Periodic for Channel<T> where T: Trait {}
 
+impl<T> PeriodicAlpha for Channel<T> where T: Trait {}
+
 /// Implemented for types that identify MRT channels
 pub trait Trait: Reg<Target = CHANNEL> + sealed::Sealed {}
 

From fa5459210ab68297b7dbb3ef8aba64383c768abe Mon Sep 17 00:00:00 2001
From: Hanno Braun <hanno@braun-embedded.com>
Date: Fri, 16 Oct 2020 16:09:05 +0200
Subject: [PATCH 4/7] Add dependency on embedded-time

I think that the library looks really nice and has the potential to
become a de-facto standard across the ecosystem.
---
 Cargo.toml | 5 +++--
 src/lib.rs | 1 +
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index a8c7e82ac..8d05d049e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -23,8 +23,9 @@ travis-ci = { repository = "lpc-rs/lpc8xx-hal" }
 
 
 [dependencies]
-cortex-m = "0.6.3"
-nb       = "1.0.0"
+cortex-m      = "0.6.3"
+embedded-time = "0.10.0"
+nb            = "1.0.0"
 
 # This should be in [dev-dependencies], but those can't be optional.
 # Issue: https://github.com/rust-lang/cargo/issues/1596
diff --git a/src/lib.rs b/src/lib.rs
index 12e6e29a0..f52e7fe34 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -103,6 +103,7 @@ pub extern crate cortex_m;
 pub extern crate cortex_m_rt;
 pub extern crate embedded_hal;
 pub extern crate embedded_hal_alpha;
+pub extern crate embedded_time;
 pub extern crate nb;
 pub extern crate void;
 

From 7ad402f50def266457e6fe1f16c34a06a51412da Mon Sep 17 00:00:00 2001
From: Hanno Braun <hanno@braun-embedded.com>
Date: Fri, 16 Oct 2020 16:46:24 +0200
Subject: [PATCH 5/7] Add additional methods to `mrt::Channel` API

---
 src/mrt.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/mrt.rs b/src/mrt.rs
index 1cf98e6c4..c0c147855 100644
--- a/src/mrt.rs
+++ b/src/mrt.rs
@@ -97,11 +97,21 @@ where
             .write(|w| unsafe { w.ivalue().bits(reload + 1) });
     }
 
+    /// Indicates whether the timer is running
+    pub fn is_running(&self) -> bool {
+        self.0.stat.read().run().is_running()
+    }
+
     /// Returns the current timer value
     pub fn value(&self) -> u32 {
         self.0.timer.read().value().bits()
     }
 
+    /// Returns the reload value of the timer
+    pub fn reload_value(&self) -> u32 {
+        self.0.intval.read().ivalue().bits()
+    }
+
     /// Non-blockingly "waits" until the count down finishes
     fn wait(&mut self) -> nb::Result<(), Void> {
         if self.0.stat.read().intflag().is_pending_interrupt() {

From a2bc21713d88b10d5f368000845d4afe911a3bb1 Mon Sep 17 00:00:00 2001
From: Hanno Braun <hanno@braun-embedded.com>
Date: Fri, 16 Oct 2020 16:47:12 +0200
Subject: [PATCH 6/7] Impl `embedded_time::Clock` for `mrt::Channel`

---
 src/mrt.rs | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/src/mrt.rs b/src/mrt.rs
index c0c147855..0051c2435 100644
--- a/src/mrt.rs
+++ b/src/mrt.rs
@@ -16,6 +16,7 @@ use embedded_hal::timer::{CountDown, Periodic};
 use embedded_hal_alpha::timer::{
     CountDown as CountDownAlpha, Periodic as PeriodicAlpha,
 };
+use embedded_time::{clock, fraction::Fraction, Instant};
 use void::Void;
 
 /// Represents the MRT instance
@@ -174,6 +175,25 @@ impl<T> Periodic for Channel<T> where T: Trait {}
 
 impl<T> PeriodicAlpha for Channel<T> where T: Trait {}
 
+impl<T> embedded_time::Clock for Channel<T>
+where
+    T: Trait,
+{
+    type T = u32;
+
+    const SCALING_FACTOR: Fraction = Fraction::new(1, 12_000_000);
+
+    fn try_now(&self) -> Result<Instant<Self>, clock::Error> {
+        if self.is_running() {
+            // embedded-time assumes that clocks are counting up, but we are
+            // counting down here. Thus, the need for some translation.
+            Ok(Instant::new(self.reload_value() - self.value()))
+        } else {
+            Err(clock::Error::NotRunning)
+        }
+    }
+}
+
 /// Implemented for types that identify MRT channels
 pub trait Trait: Reg<Target = CHANNEL> + sealed::Sealed {}
 

From e84836e16eba7e6376bccef4e8a53ed143f70547 Mon Sep 17 00:00:00 2001
From: Hanno Braun <hanno@braun-embedded.com>
Date: Fri, 16 Oct 2020 17:04:16 +0200
Subject: [PATCH 7/7] Add example that uses MRT as embedded-time clock

---
 Cargo.toml            |  4 ++++
 examples/mrt_clock.rs | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 36 insertions(+)
 create mode 100644 examples/mrt_clock.rs

diff --git a/Cargo.toml b/Cargo.toml
index 8d05d049e..d2961061c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -159,6 +159,10 @@ required-features = ["rt-selected", "82x"]
 name              = "i2c_eeprom"
 required-features = ["rt-selected"]
 
+[[example]]
+name              = "mrt_clock"
+required-features = ["rt-selected", "845"]
+
 [[example]]
 name              = "pinint"
 required-features = ["rt-selected", "845"]
diff --git a/examples/mrt_clock.rs b/examples/mrt_clock.rs
new file mode 100644
index 000000000..75f7a8ad0
--- /dev/null
+++ b/examples/mrt_clock.rs
@@ -0,0 +1,32 @@
+#![no_main]
+#![no_std]
+
+extern crate panic_rtt_target;
+
+use embedded_time::{duration::Extensions as _, Clock as _};
+use lpc8xx_hal::{cortex_m_rt::entry, gpio::Level, mrt, Peripherals};
+
+#[entry]
+fn main() -> ! {
+    rtt_target::rtt_init_print!();
+
+    let p = Peripherals::take().unwrap();
+
+    let mut syscon = p.SYSCON.split();
+    let gpio = p.GPIO.enable(&mut syscon.handle);
+    let mut mrt = p.MRT0.split(&mut syscon.handle).mrt0;
+
+    let mut led = p
+        .pins
+        .pio1_1
+        .into_output_pin(gpio.tokens.pio1_1, Level::Low);
+
+    loop {
+        mrt.start(mrt::MAX_VALUE);
+
+        let timer = mrt.new_timer(1u32.seconds());
+        timer.start().unwrap().wait().unwrap();
+
+        led.toggle();
+    }
+}