move around character match

Signed-off-by: Leah <[email protected]>

Author: ForsakenHarmony

examples/rtic_frame_serial_dma.rs

@@ -91,7 +91,7 @@ const APP: () = {
         let fr = if let Some(dma_buf) = SerialDMAPool::alloc() {
             // Set up the first reader frame
             let dma_buf = dma_buf.init(DMAFrame::new());
-            serial_rx.with_dma(dma_ch6).frame_read(dma_buf)
+            serial_rx.with_dma(dma_ch6).frame_reader(dma_buf)
         } else {
             unreachable!()
         };
@@ -100,7 +100,6 @@ const APP: () = {
         let fs: FrameSender<Box<SerialDMAPool>, _, 8> = serial_tx.with_dma(dma_ch7).frame_sender();
 
         init::LateResources {
-            rx: serial_rx,
             frame_reader: fr,
             frame_sender: fs,
         }
@@ -112,7 +111,7 @@ const APP: () = {
     #[task(binds = USART2, resources = [rx, frame_reader, frame_sender], priority = 3)]
     fn serial_isr(cx: serial_isr::Context) {
         // Check for character match
-        if cx.resources.rx.is_character_match(true) {
+        if cx.resources.frame_reader.check_character_match(true) {
             if let Some(dma_buf) = SerialDMAPool::alloc() {
                 let dma_buf = dma_buf.init(DMAFrame::new());
                 let buf = cx.resources.frame_reader.character_match_interrupt(dma_buf);

src/dma.rs

@@ -32,6 +32,12 @@ pub enum Half {
     Second,
 }
 
+pub trait CharacterMatch {
+    /// Checks to see if the peripheral has detected a character match and
+    /// clears the flag
+    fn check_character_match(&mut self, clear: bool) -> bool;
+}
+
 /// Frame reader "worker", access and handling of frame reads is made through this structure.
 pub struct FrameReader<BUFFER, PAYLOAD, const N: usize>
 where
@@ -59,6 +65,17 @@ where
     }
 }
 
+impl<BUFFER, PAYLOAD, CHANNEL, const N: usize> FrameReader<BUFFER, RxDma<PAYLOAD, CHANNEL>, N>
+where
+    PAYLOAD: CharacterMatch,
+{
+    /// Checks to see if the peripheral has detected a character match and
+    /// clears the flag
+    pub fn check_character_match(&mut self, clear: bool) -> bool {
+        self.payload.payload.check_character_match(clear)
+    }
+}
+
 /// Frame sender "worker", access and handling of frame transmissions is made through this
 /// structure.
 pub struct FrameSender<BUFFER, PAYLOAD, const N: usize>
@@ -377,7 +394,7 @@ macro_rules! dma {
                 use core::ptr;
                 use stable_deref_trait::StableDeref;
 
-                use crate::dma::{CircBuffer, FrameReader, FrameSender, DMAFrame, DmaExt, Error, Event, Half, Transfer, W, R, RxDma, TxDma, TransferPayload};
+                use crate::dma::{CircBuffer, FrameReader, CharacterMatch, FrameSender, DMAFrame, DmaExt, Error, Event, Half, Transfer, W, R, RxDma, TxDma, TransferPayload};
                 use crate::rcc::AHB1;
 
                 #[allow(clippy::manual_non_exhaustive)]

src/serial.rs

@@ -575,6 +575,63 @@ macro_rules! hal {
 
                     Ok(())
                 }
+
+                /// Checks to see if the USART peripheral has detected an idle line and clears
+                /// the flag
+                pub fn is_idle(&mut self, clear: bool) -> bool {
+                    let isr = unsafe { &(*pac::$USARTX::ptr()).isr.read() };
+                    let icr = unsafe { &(*pac::$USARTX::ptr()).icr };
+
+                    if isr.idle().bit_is_set() {
+                        if clear {
+                            icr.write(|w| w.idlecf().set_bit() );
+                        }
+                        true
+                    } else {
+                        false
+                    }
+                }
+
+
+                /// Checks to see if the USART peripheral has detected an receiver timeout and
+                /// clears the flag
+                pub fn is_receiver_timeout(&mut self, clear: bool) -> bool {
+                    let isr = unsafe { &(*pac::$USARTX::ptr()).isr.read() };
+                    let icr = unsafe { &(*pac::$USARTX::ptr()).icr };
+
+                    if isr.rtof().bit_is_set() {
+                        if clear {
+                            icr.write(|w| w.rtocf().set_bit() );
+                        }
+                        true
+                    } else {
+                        false
+                    }
+                }
+
+                /// Checks to see if the USART peripheral has detected an character match and
+                /// clears the flag
+                pub fn check_character_match(&mut self, clear: bool) -> bool {
+                    let isr = unsafe { &(*pac::$USARTX::ptr()).isr.read() };
+                    let icr = unsafe { &(*pac::$USARTX::ptr()).icr };
+
+                    if isr.cmf().bit_is_set() {
+                        if clear {
+                            icr.write(|w| w.cmcf().set_bit() );
+                        }
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+
+            impl crate::dma::CharacterMatch for Rx<pac::$USARTX> {
+                /// Checks to see if the USART peripheral has detected an character match and
+                /// clears the flag
+                fn check_character_match(&mut self, clear: bool) -> bool {
+                    self.check_character_match(clear)
+                }
             }
 
             impl Tx<pac::$USARTX> {
@@ -665,7 +722,7 @@ macro_rules! hal {
             impl $rxdma {
                 /// Create a frame reader that can either react on the Character match interrupt or
                 /// Transfer Complete from the DMA.
-                pub fn frame_read<BUFFER, const N: usize>(
+                pub fn frame_reader<BUFFER, const N: usize>(
                     mut self,
                     buffer: BUFFER,
                 ) -> FrameReader<BUFFER, Self, N>
@@ -712,54 +769,6 @@ macro_rules! hal {
 
                     FrameReader::new(buffer, self, usart.cr2.read().add().bits())
                 }
-
-                /// Checks to see if the USART peripheral has detected an idle line and clears
-                /// the flag
-                pub fn is_idle(&mut self, clear: bool) -> bool {
-                    let isr = unsafe { &(*pac::$USARTX::ptr()).isr.read() };
-                    let icr = unsafe { &(*pac::$USARTX::ptr()).icr };
-
-                    if isr.idle().bit_is_set() {
-                        if clear {
-                            icr.write(|w| w.idlecf().set_bit() );
-                        }
-                        true
-                    } else {
-                        false
-                    }
-                }
-
-                /// Checks to see if the USART peripheral has detected an character match and
-                /// clears the flag
-                pub fn is_character_match(&mut self, clear: bool) -> bool {
-                    let isr = unsafe { &(*pac::$USARTX::ptr()).isr.read() };
-                    let icr = unsafe { &(*pac::$USARTX::ptr()).icr };
-
-                    if isr.cmf().bit_is_set() {
-                        if clear {
-                            icr.write(|w| w.cmcf().set_bit() );
-                        }
-                        true
-                    } else {
-                        false
-                    }
-                }
-
-                /// Checks to see if the USART peripheral has detected an receiver timeout and
-                /// clears the flag
-                pub fn is_receiver_timeout(&mut self, clear: bool) -> bool {
-                    let isr = unsafe { &(*pac::$USARTX::ptr()).isr.read() };
-                    let icr = unsafe { &(*pac::$USARTX::ptr()).icr };
-
-                    if isr.rtof().bit_is_set() {
-                        if clear {
-                            icr.write(|w| w.rtocf().set_bit() );
-                        }
-                        true
-                    } else {
-                        false
-                    }
-                }
             }
 
             impl $txdma {