Another probable watchdog API design (issue #98)

Author: luojia65

src/prelude.rs

@@ -28,5 +28,5 @@ pub use crate::serial::Write as _embedded_hal_serial_Write;
 pub use crate::spi::FullDuplex as _embedded_hal_spi_FullDuplex;
 pub use crate::timer::CountDown as _embedded_hal_timer_CountDown;
 pub use crate::watchdog::Watchdog as _embedded_hal_watchdog_Watchdog;
-pub use crate::watchdog::WatchdogDisable as _embedded_hal_watchdog_WatchdogDisable;
-pub use crate::watchdog::WatchdogEnable as _embedded_hal_watchdog_WatchdogEnable;
+pub use crate::watchdog::Disable as _embedded_hal_watchdog_Disable;
+pub use crate::watchdog::Enable as _embedded_hal_watchdog_Enable;

src/watchdog.rs

@@ -15,29 +15,41 @@ pub trait Watchdog {
 
 /// Enables A watchdog timer to reset the processor if software is frozen or
 /// stalled.
-pub trait WatchdogEnable {
-    /// An enumeration of `WatchdogEnable` errors.
+pub trait Enable {
+    /// An enumeration of `Enable` errors.
     ///
     /// For infallible implementations, will be `Infallible`
     type Error;
 
     /// Unit of time used by the watchdog
     type Time;
 
-    /// Starts the watchdog with a given period, typically once this is done
-    /// the watchdog needs to be kicked periodically or the processor is reset.
-    fn try_start<T>(&mut self, period: T) -> Result<(), Self::Error>
+    /// The started watchdog that should be `feed()`
+    type Target: Watchdog;
+
+    /// Starts the watchdog with a given period, typically once this is done 
+    /// the watchdog needs to be kicked periodically or the processor is reset. 
+    ///
+    /// This consumes the value and returns the `Watchdog` trait that you must
+    /// `feed()`.
+    fn try_start<T>(&mut self, period: T) -> Result<Self::Target, Self::Error>
     where
         T: Into<Self::Time>;
 }
 
 /// Disables a running watchdog timer so the processor won't be reset.
-pub trait WatchdogDisable {
-    /// An enumeration of `WatchdogDisable` errors.
+pub trait Disable {
+    /// An enumeration of `Disable` errors.
     ///
     /// For infallible implementations, will be `Infallible`
     type Error;
 
+    /// Disabled watchdog instance that can be enabled.
+    type Target: Enable;
+
     /// Disables the watchdog
-    fn try_disable(&mut self) -> Result<(), Self::Error>;
+    ///
+    /// This stops the watchdog and returns the `Enable` trait so that
+    /// it can be started again.
+    fn try_disable(&mut self) -> Result<Self::Target, Self::Error>;
 }