None DMA version of usart printer

src/debug.rs

@@ -1,73 +0,0 @@
-
-use hcl::platform::usart;
-use hcl::platform::dma;
-use hcl::platform::PeripheralRef;
-use hcl::platform::Location;
-use hcl::dma::*;
-
-use alloc::vec::Vec;
-
-
-type UsartDRRef<Addr> = PeripheralRef<usart::USARTdr, usart::USART_part_offsets::dr<Addr>>;
-type UsartDMAResult<'a, Addr, Chan> = Result<'a, Vec<u8>, UsartDRRef<Addr>, Chan, SetupError>;
-
-
-pub struct UsartPrinter<'a, Addr, Chan : 'a, ChanAddr> where
-    Addr : hcl::platform::Location,
-    Chan: hcl::dma::PeripheralChannel,
-    ChanAddr: hcl::platform::Location {
-    usart_dr: Option<UsartDRRef<Addr>>,
-    dma_result : Option<UsartDMAResult<'a, Addr, Chan>>,
-
-    dma_channel_idx: u32,
-    dma_channel: PeripheralRef<Chan,ChanAddr>,
-}
-
-impl<'a, Addr, Chan, ChanAddr> UsartPrinter<'a, Addr, Chan, ChanAddr> where
-    Addr : hcl::platform::Location,
-    Chan: hcl::dma::PeripheralChannel,
-    ChanAddr: hcl::platform::Location {
-
-    pub fn init(usart: usart::USARTParts<Addr>,
-            dma_channel_idx: u32,
-            dma_channel: PeripheralRef<Chan,ChanAddr>) -> UsartPrinter<'a, Addr, Chan, ChanAddr> {
-        UsartPrinter {
-            usart_dr: Some(usart.dr),
-            dma_result: None,
-            dma_channel_idx: dma_channel_idx,
-            dma_channel: dma_channel,
-        }
-    }
-
-    pub fn wait_for_completion(&mut self, dma_control: &mut dma::DMA1control) -> () {
-        match self.dma_result.take() {
-            Some(res) => {
-                let dr = match res {
-                    Ok(tx) => {
-                        while !dma_control.transfer_complete(self.dma_channel_idx) {
-                        }
-                        tx.retrieve().1
-                    },
-                    Err((_, sink, _)) => sink
-                };
-                self.usart_dr = Some(dr)
-            }
-            None => {}
-        }
-    }
-
-    pub fn print(&'a mut self, data: Vec<u8>, dma_control: & mut dma::DMA1control) -> () {
-        let dr = match self.usart_dr.take() {
-            Some(dr) => dr,
-            None => {
-                self.wait_for_completion(dma_control);
-                self.usart_dr.take().unwrap()
-            }
-        };
-
-        let foo = &self.dma_channel;
-
-        dma_control.clear_transfer_complete(self.dma_channel_idx);
-        self.dma_result = Some(self.dma_channel.begin_source(data, dr));
-    }
-}

src/main.rs

@@ -19,9 +19,9 @@ use hcl::platform::usart;
 use hcl::platform::dma;
 use hcl::dma::*;
 
-mod debug;
+mod printer;
 
-use debug::UsartPrinter;
+use printer::UsartPrinter;
 
 fn configure_clocks(rcc: &mut rcc::RCC) {
     rcc.clock_control.set_hse_on(true);
@@ -45,7 +45,6 @@ fn configure_peripherals(rcc: &mut hcl::platform::rcc::RCC,
     rcc.apb2_enable.set_gpio_a(true);
     rcc.apb1_enable.configure(|a| a
         .set_usart2(true));
-    rcc.ahb_enable.set_dma1(true);
 
     gpio.configure(|g| g
         .set_mode(2, gpio::PinMode::Output2MHz)
@@ -58,7 +57,6 @@ fn configure_peripherals(rcc: &mut hcl::platform::rcc::RCC,
     usart.configure(|u| u
         .set_enabled(true)
         .set_tx_enabled(true)
-        .set_dma_transmit_enabled(true)
         .set_baudgen((21, 11))); // 115.2 kbaud
 }
 
@@ -70,18 +68,12 @@ fn run(mut scs: scs::Instance, mut p: hcl::platform::Instance) {
     configure_clocks(&mut p.rcc);
     configure_peripherals(&mut p.rcc, &mut p.gpio_a, &mut p.usart2);
 
-    let dma = p.dma1.split();
-
-
-    let mut dma_control = dma.control;
-
-
-    let printer = UsartPrinter::init(p.usart2.split(), 7, dma.channel7);
+    let mut printer = UsartPrinter::init(p.usart2);
 
     for i in 0u32..0xffffffff {
         let x = format!("> {}\r\n", i).into_bytes();
 
-        priner.print(x);
+        printer.print(x);
     }
 
 }

src/printer.rs

@@ -0,0 +1,34 @@
+
+use hcl::platform::usart;
+use hcl::platform::dma;
+use hcl::platform::PeripheralRef;
+use hcl::platform::Location;
+use hcl::dma::*;
+
+use alloc::vec::Vec;
+
+
+
+
+pub struct UsartPrinter<Addr> where
+    Addr : hcl::platform::Location, {
+    usart: PeripheralRef<usart::USART, Addr>
+}
+
+impl<Addr> UsartPrinter<Addr> where Addr : hcl::platform::Location {
+
+    pub fn init(usart: PeripheralRef<usart::USART, Addr>) -> UsartPrinter<Addr> {
+        UsartPrinter {
+            usart: usart,
+        }
+    }
+
+    pub fn print(&mut self, data: Vec<u8>) -> () {
+        for byte in data {
+            self.usart.clear_tx_complete();
+            self.usart.set_data(byte.into());
+            while !self.usart.tx_complete() {
+            };
+        }
+    }
+}