Abstract the DMA initialization a bit away.

Author: hargoniX

examples/serial-hal-blocking-echo/Cargo.toml

@@ -8,6 +8,7 @@ cortex-m-rt = "0.6.12"
 panic-halt = "0.2.0"
 defmt-rtt = "0.2.0"
 nb = "0.1.2"
+embedded-hal = "0.2.6"
 
 [dependencies.microbit]
 path = "../../microbit"

examples/serial-hal-blocking-echo/src/main.rs

@@ -4,21 +4,29 @@
 use panic_halt as _;
 
 use core::fmt::Write;
-use microbit::hal::prelude::*;
 
 #[cfg(feature = "v1")]
 use microbit::{
     hal::uart,
     hal::uart::{Baudrate, Parity},
+    hal::prelude::*,
 };
+
 #[cfg(feature = "v2")]
 use microbit::{
     hal::uarte,
     hal::uarte::{Baudrate, Parity},
+    hal::prelude::*,
 };
 
 use cortex_m_rt::entry;
 
+#[cfg(feature = "v2")]
+mod serial_setup;
+#[cfg(feature = "v2")]
+use serial_setup::UartePort;
+
+
 #[entry]
 fn main() -> ! {
     let board = microbit::Board::take().unwrap();
@@ -35,22 +43,18 @@ fn main() -> ! {
 
     #[cfg(feature = "v2")]
     let mut serial = {
-        uarte::Uarte::new(
+        let serial = uarte::Uarte::new(
             board.UARTE0,
             board.uart.into(),
             Parity::EXCLUDED,
             Baudrate::BAUD115200,
-        )
+        );
+        UartePort::new(serial)
     };
 
-    /* Print a nice hello message */
-    write!(serial, "Please type characters to echo:\r\n").unwrap();
-
-    /* Endless loop */
     loop {
-        /* Read and echo back */
-        if let Ok(c) = nb::block!(serial.read()) {
-            let _ = nb::block!(serial.write(c));
-        }
+        write!(serial, "Hello World:\r\n").unwrap();
+        let input = nb::block!(serial.read()).unwrap();
+        write!(serial, "You said: {}\r\n", input as char).unwrap();
     }
 }

examples/serial-hal-blocking-echo/src/serial_setup.rs

@@ -0,0 +1,47 @@
+use microbit::hal::uarte::{Uarte, UarteTx, UarteRx, Instance, Error};
+use embedded_hal::serial;
+use embedded_hal::blocking::serial as bserial;
+use core::fmt;
+
+static mut TX_BUF: [u8; 1] = [0; 1];
+static mut RX_BUF: [u8; 1] = [0; 1];
+
+pub struct UartePort<T: Instance>(UarteTx<T>, UarteRx<T>);
+
+impl<T: Instance> UartePort<T> {
+    pub fn new(serial: Uarte<T>) -> UartePort<T> {
+        let (tx, rx) = serial.split(
+            unsafe { &mut TX_BUF },
+            unsafe { &mut RX_BUF }
+        ).unwrap();
+        UartePort(tx, rx)
+    }
+}
+
+impl<T: Instance> fmt::Write for UartePort<T> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+	self.0.write_str(s)
+    }
+}
+
+impl<T: Instance> serial::Write<u8> for UartePort<T> {
+    type Error = Error;
+
+    fn write(&mut self, b: u8) -> nb::Result<(), Self::Error> {
+        self.0.write(b)
+    }
+
+    fn flush(&mut self) -> nb::Result<(), Self::Error> {
+        self.0.flush()
+    }
+}
+
+impl<T: Instance> bserial::write::Default<u8> for UartePort<T> {}
+
+impl<T: Instance> serial::Read<u8> for UartePort<T> {
+    type Error = Error;
+
+    fn read(&mut self) -> nb::Result<u8, Self::Error> {
+	self.1.read()
+    }
+}