Make Pwm trait fallible

Author: eldruin

src/lib.rs

@@ -815,39 +815,44 @@ pub trait Capture {
 /// #       Pwm1
 ///     };
 ///
-///     pwm.set_period(1.khz());
+///     pwm.try_set_period(1.khz()).unwrap();
 ///
-///     let max_duty = pwm.get_max_duty();
+///     let max_duty = pwm.try_get_max_duty().unwrap();
 ///
 ///     // brightest LED
-///     pwm.set_duty(Channel::_1, max_duty);
+///     pwm.try_set_duty(Channel::_1, max_duty).unwrap();
 ///
 ///     // dimmer LED
-///     pwm.set_duty(Channel::_2, max_duty / 4);
+///     pwm.try_set_duty(Channel::_2, max_duty / 4).unwrap();
 /// }
 ///
+/// # use core::convert::Infallible;
 /// # struct KiloHertz(u32);
 /// # trait U32Ext { fn khz(self) -> KiloHertz; }
 /// # impl U32Ext for u32 { fn khz(self) -> KiloHertz { KiloHertz(self) } }
 /// # enum Channel { _1, _2 }
 /// # struct Pwm1;
 /// # impl hal::Pwm for Pwm1 {
+/// #     type Error = Infallible;
 /// #     type Channel = Channel;
 /// #     type Time = KiloHertz;
 /// #     type Duty = u16;
-/// #     fn disable(&mut self, _: Channel) { unimplemented!() }
-/// #     fn enable(&mut self, _: Channel) { unimplemented!() }
-/// #     fn get_duty(&self, _: Channel) -> u16 { unimplemented!() }
-/// #     fn get_max_duty(&self) -> u16 { 0 }
-/// #     fn set_duty(&mut self, _: Channel, _: u16) {}
-/// #     fn get_period(&self) -> KiloHertz { unimplemented!() }
-/// #     fn set_period<T>(&mut self, _: T) where T: Into<KiloHertz> {}
+/// #     fn try_disable(&mut self, _: Channel) -> Result<(), Self::Error> { unimplemented!() }
+/// #     fn try_enable(&mut self, _: Channel) -> Result<(), Self::Error> { unimplemented!() }
+/// #     fn try_get_duty(&self, _: Channel) -> Result<u16, Self::Error> { unimplemented!() }
+/// #     fn try_get_max_duty(&self) -> Result<u16, Self::Error> { 0 }
+/// #     fn try_set_duty(&mut self, _: Channel, _: u16) -> Result<(), Self::Error> {}
+/// #     fn try_get_period(&self) -> Result<KiloHertz, Self::Error> { unimplemented!() }
+/// #     fn try_set_period<T>(&mut self, _: T) -> Result<(), Self::Error> where T: Into<KiloHertz> {}
 /// # }
 /// ```
 #[cfg(feature = "unproven")]
 // reason: pre-singletons API. The `PwmPin` trait seems more useful because it models independent
 // PWM channels. Here a certain number of channels are multiplexed in a single implementer.
 pub trait Pwm {
+    /// Enumeration of `Pwm` errors
+    type Error;
+
     /// Enumeration of channels that can be used with this `Pwm` interface
     ///
     /// If your `Pwm` interface has no channels you can use the type `()`
@@ -864,25 +869,26 @@ pub trait Pwm {
     type Duty;
 
     /// Disables a PWM `channel`
-    fn disable(&mut self, channel: Self::Channel);
+    fn try_disable(&mut self, channel: Self::Channel) -> Result<(), Self::Error>;
 
     /// Enables a PWM `channel`
-    fn enable(&mut self, channel: Self::Channel);
+    fn try_enable(&mut self, channel: Self::Channel) -> Result<(), Self::Error>;
 
     /// Returns the current PWM period
-    fn get_period(&self) -> Self::Time;
+    fn try_get_period(&self) -> Result<Self::Time, Self::Error>;
 
     /// Returns the current duty cycle
-    fn get_duty(&self, channel: Self::Channel) -> Self::Duty;
+    fn try_get_duty(&self, channel: Self::Channel) -> Result<Self::Duty, Self::Error>;
 
     /// Returns the maximum duty cycle value
-    fn get_max_duty(&self) -> Self::Duty;
+    fn try_get_max_duty(&self) -> Result<Self::Duty, Self::Error>;
 
     /// Sets a new duty cycle
-    fn set_duty(&mut self, channel: Self::Channel, duty: Self::Duty);
+    fn try_set_duty(&mut self, channel: Self::Channel, duty: Self::Duty)
+        -> Result<(), Self::Error>;
 
     /// Sets a new PWM period
-    fn set_period<P>(&mut self, period: P)
+    fn try_set_period<P>(&mut self, period: P) -> Result<(), Self::Error>
     where
         P: Into<Self::Time>;
 }