Add interrupt configured check

Author: Sh3Rm4n

CHANGELOG.md

@@ -23,6 +23,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Make timer `InterruptTypes` fields public to be useful. ([#304])
 - Add support for the internal **signature** peripheral ([#281])
 - Add common derives to `Toggle`. ([#281])
+- Add `is_interrupt_configured` and `configured_interrupts` function to
+  `serial::Serial` and `timer::Timer`. ([#281])
 
 ### Fixed
 

src/serial.rs

@@ -674,6 +674,43 @@ where
         }
     }
 
+    /// Check if an interrupt is configured for the [`Event`]
+    #[inline]
+    pub fn is_interrupt_configured(&self, event: Event) -> bool {
+        match event {
+            Event::TransmitDataRegisterEmtpy => self.usart.cr1.read().txeie().is_enabled(),
+            Event::CtsInterrupt => self.usart.cr3.read().ctsie().is_enabled(),
+            Event::TransmissionComplete => self.usart.cr1.read().tcie().is_enabled(),
+            Event::ReceiveDataRegisterNotEmpty => self.usart.cr1.read().rxneie().is_enabled(),
+            Event::ParityError => self.usart.cr1.read().peie().is_enabled(),
+            Event::LinBreak => self.usart.cr2.read().lbdie().is_enabled(),
+            Event::NoiseError | Event::OverrunError | Event::FramingError => {
+                self.usart.cr3.read().eie().is_enabled()
+            }
+            Event::Idle => self.usart.cr1.read().idleie().is_enabled(),
+            Event::CharacterMatch => self.usart.cr1.read().cmie().is_enabled(),
+            Event::ReceiverTimeout => self.usart.cr1.read().rtoie().is_enabled(),
+            // Event::EndOfBlock => self.usart.cr1.read().eobie().is_enabled(),
+            // Event::WakeupFromStopMode => self.usart.cr3.read().wufie().is_enabled(),
+        }
+    }
+
+    /// Check which interrupts are enabled for all [`Event`]s
+    #[cfg(feature = "enumset")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "enumset")))]
+    #[inline]
+    pub fn configured_interrupts(&mut self) -> EnumSet<Event> {
+        let mut events = EnumSet::new();
+
+        for event in EnumSet::<Event>::all().iter() {
+            if self.is_interrupt_configured(event) {
+                events |= event;
+            }
+        }
+
+        events
+    }
+
     /// Check if an interrupt event happend.
     #[inline]
     pub fn is_event_triggered(&self, event: Event) -> bool {

src/timer.rs

@@ -177,6 +177,31 @@ where
         }
     }
 
+    /// Check if an interrupt is configured for the [`Event`]
+    #[inline]
+    pub fn is_interrupt_configured(&self, event: Event) -> bool {
+        match event {
+            Event::Update => self.tim.is_dier_uie_set(),
+        }
+    }
+
+    // TODO: Add to other implementations as well (Serial, ...)
+    /// Check which interrupts are enabled for all [`Event`]s
+    #[cfg(feature = "enumset")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "enumset")))]
+    #[inline]
+    pub fn configured_interrupts(&mut self) -> EnumSet<Event> {
+        let mut events = EnumSet::new();
+
+        for event in EnumSet::<Event>::all().iter() {
+            if self.is_interrupt_configured(event) {
+                events |= event;
+            }
+        }
+
+        events
+    }
+
     /// Check if an interrupt event happend.
     pub fn is_event_triggered(&self, event: Event) -> bool {
         match event {
@@ -260,9 +285,9 @@ where
         self.tim.set_arr(arr);
 
         // Ensure that the below procedure does not create an unexpected interrupt.
-        let is_update_interrupt_active = self.tim.is_dier_uie_set();
+        let is_update_interrupt_active = self.is_interrupt_configured(Event::Update);
         if is_update_interrupt_active {
-            self.tim.set_dier_uie(false);
+            self.configure_interrupt(Event::Update, false);
         }
 
         // Trigger an update event to load the prescaler value to the clock The above line raises
@@ -272,7 +297,7 @@ where
         self.clear_event(Event::Update);
 
         if is_update_interrupt_active {
-            self.tim.set_dier_uie(true);
+            self.configure_interrupt(Event::Update, true)
         }
 
         // start counter