Add support for the USARTS/UARTS/LPUART.

Most of this code has been taken from the stm32g0xx HAL. Changes include:

- The types contain the pins. It is possible to destroy Serial objects to
  reinitialize them with different a different configuration or with
  different pins at runtime.
- The DMA code has been adapted to the different API provided by this HAL.

Author: mgottschlag

examples/uart-dma.rs

@@ -0,0 +1,73 @@
+#![deny(warnings)]
+#![deny(unsafe_code)]
+#![no_main]
+#![no_std]
+
+extern crate cortex_m_rt as rt;
+
+use core::fmt::Write;
+
+use hal::dma::{config::DmaConfig, stream::DMAExt, TransferExt};
+use hal::prelude::*;
+use hal::serial::*;
+use hal::{rcc, stm32};
+use stm32g4xx_hal as hal;
+
+use cortex_m_rt::entry;
+use log::info;
+
+#[macro_use]
+mod utils;
+
+#[entry]
+fn main() -> ! {
+    utils::logger::init();
+
+    let dp = stm32::Peripherals::take().expect("cannot take peripherals");
+
+    let rcc = dp.RCC.constrain();
+    let mut rcc = rcc.freeze(rcc::Config::hsi());
+
+    let streams = dp.DMA1.split(&rcc);
+    let config = DmaConfig::default()
+        .transfer_complete_interrupt(false)
+        .circular_buffer(false)
+        .memory_increment(true);
+
+    info!("Init UART");
+    let gpioa = dp.GPIOA.split(&mut rcc);
+    let tx = gpioa.pa2.into_alternate();
+    let rx = gpioa.pa3.into_alternate();
+    let mut usart = dp
+        .USART2
+        .usart(
+            tx,
+            rx,
+            FullConfig::default().baudrate(115200.bps()),
+            &mut rcc,
+        )
+        .unwrap();
+
+    let mut led = gpioa.pa5.into_push_pull_output();
+
+    info!("Start writing");
+
+    writeln!(usart, "Hello without DMA\r\n").unwrap();
+
+    let tx_buffer = cortex_m::singleton!(: [u8; 16] = *b"Hello with DMA!\n").unwrap();
+
+    let (tx, _rx) = usart.split();
+
+    // Setup DMA for USART1 TX with dma channel 1.
+    let mut transfer =
+        streams
+            .0
+            .into_memory_to_peripheral_transfer(tx.enable_dma(), &mut tx_buffer[..], config);
+
+    loop {
+        transfer.start(|_tx| {});
+        while !transfer.get_transfer_complete_flag() {}
+
+        led.toggle().unwrap();
+    }
+}

examples/uart-fifo.rs

@@ -0,0 +1,71 @@
+#![deny(warnings)]
+#![deny(unsafe_code)]
+#![no_main]
+#![no_std]
+
+extern crate cortex_m_rt as rt;
+
+use core::fmt::Write;
+
+use hal::prelude::*;
+use hal::serial::*;
+use hal::{rcc, stm32};
+use stm32g4xx_hal as hal;
+
+use cortex_m_rt::entry;
+use log::info;
+
+#[macro_use]
+mod utils;
+
+#[entry]
+fn main() -> ! {
+    utils::logger::init();
+
+    info!("start");
+    let dp = stm32::Peripherals::take().expect("cannot take peripherals");
+    let mut rcc = dp.RCC.freeze(rcc::Config::hsi());
+
+    info!("Init UART");
+    let gpioa = dp.GPIOA.split(&mut rcc);
+    let tx = gpioa.pa2.into_alternate();
+    let rx = gpioa.pa3.into_alternate();
+    let mut usart = dp
+        .USART2
+        .usart(
+            tx,
+            rx,
+            FullConfig::default()
+                .baudrate(115200.bps())
+                .fifo_enable()
+                .rx_fifo_enable_interrupt()
+                .rx_fifo_threshold(FifoThreshold::FIFO_4_BYTES),
+            &mut rcc,
+        )
+        .unwrap();
+
+    writeln!(usart, "Hello USART2\r\n").unwrap();
+
+    let (mut tx1, mut rx1) = usart.split();
+
+    let mut cnt = 0;
+    loop {
+        if rx1.fifo_threshold_reached() {
+            loop {
+                match rx1.read() {
+                    Err(nb::Error::WouldBlock) => {
+                        // no more data available in fifo
+                        break;
+                    }
+                    Err(nb::Error::Other(_err)) => {
+                        // Handle other error Overrun, Framing, Noise or Parity
+                    }
+                    Ok(byte) => {
+                        writeln!(tx1, "{}: {}\n", cnt, byte).unwrap();
+                        cnt += 1;
+                    }
+                }
+            }
+        }
+    }
+}

examples/uart.rs

@@ -0,0 +1,52 @@
+#![deny(warnings)]
+#![deny(unsafe_code)]
+#![no_main]
+#![no_std]
+
+use core::fmt::Write;
+
+use hal::prelude::*;
+use hal::serial::FullConfig;
+use hal::{rcc, stm32};
+use stm32g4xx_hal as hal;
+
+use cortex_m_rt::entry;
+use log::info;
+use nb::block;
+
+#[macro_use]
+mod utils;
+
+#[entry]
+fn main() -> ! {
+    utils::logger::init();
+
+    info!("start");
+    let dp = stm32::Peripherals::take().expect("cannot take peripherals");
+    let mut rcc = dp.RCC.freeze(rcc::Config::hsi());
+
+    info!("Init UART");
+    let gpioa = dp.GPIOA.split(&mut rcc);
+    let tx = gpioa.pa2.into_alternate();
+    let rx = gpioa.pa3.into_alternate();
+    let mut usart = dp
+        .USART2
+        .usart(tx, rx, FullConfig::default(), &mut rcc)
+        .unwrap();
+    /*let gpioc = dp.GPIOC.split(&mut rcc);
+    let tx = gpioc.pc4.into_alternate();
+    let rx = gpioc.pc5.into_alternate();
+    let mut usart = dp
+        .USART1
+        .usart(tx, rx, FullConfig::default(), &mut rcc)
+        .unwrap();*/
+
+    writeln!(usart, "Hello USART2\r\n").unwrap();
+
+    let mut cnt = 0;
+    loop {
+        let byte = block!(usart.read()).unwrap();
+        writeln!(usart, "{}: {}\r", cnt, byte).unwrap();
+        cnt += 1;
+    }
+}

src/lib.rs

@@ -75,7 +75,7 @@ pub mod prelude;
 // pub mod qei;
 pub mod rcc;
 // pub mod rng;
-// pub mod serial;
+pub mod serial;
 pub mod signature;
 // pub mod spi;
 // pub mod stopwatch;

src/prelude.rs

@@ -31,7 +31,7 @@ pub use crate::rcc::MCOExt as _;
 pub use crate::rcc::RccExt as _;
 // pub use crate::rng::RngCore as _;
 // pub use crate::rng::RngExt as _;
-// pub use crate::serial::SerialExt as _;
+pub use crate::serial::SerialExt as _;
 // pub use crate::spi::SpiExt as _;
 pub use crate::time::U32Ext as _;
 // pub use crate::timer::opm::OpmExt as _;