new interrupt driven serial echo example

Author: AdinAck

examples/serial_echo_irq.rs

@@ -0,0 +1,121 @@
+//! Interrupt Driven Serial Echo Example
+
+#![no_main]
+#![no_std]
+#![deny(unsafe_code)]
+#![allow(non_camel_case_types)]
+
+use panic_halt as _;
+use nb::block;
+use core::cell::RefCell;
+
+use cortex_m::interrupt::Mutex;
+use cortex_m_rt::entry;
+
+use stm32f0xx_hal as hal;
+use hal::{
+    pac::{ self, interrupt, Interrupt, USART1 },
+    prelude::*,
+    serial::Serial, gpio::{gpioa::{PA2, PA15}, Alternate, AF1, Output, PushPull, gpiob::PB3},
+    delay::Delay
+};
+
+// setup some types for our globally shared resources
+type LED_PIN = PB3<Output<PushPull>>;
+type SERIAL = Serial<USART1, PA2<Alternate<AF1>>, PA15<Alternate<AF1>>>;
+
+/*
+Create our global variables:
+
+We use a Mutex because Mutexes require a CriticalSection
+context in order to be borrowed. Since CriticalSection
+contexts cannot overlap (by definition) we can rest assured
+that the resource inside the Mutex will not violate
+the RefMut's runtime borrowing rules (Given that we do not
+try to borrow the RefMute more than once per CriticalSection).
+ */
+static LED: Mutex<RefCell<Option<LED_PIN>>> = Mutex::new(RefCell::new(None));
+static SER_PORT: Mutex<RefCell<Option<SERIAL>>> = Mutex::new(RefCell::new(None));
+
+// some helper macros to ensure safe usage of our globals
+macro_rules! init_global {
+    ($CS:ident, $GLOBAL:ident, $VAL:expr) => {
+        *$GLOBAL.borrow($CS).borrow_mut() = Some($VAL);
+    };
+}
+
+macro_rules! with_global_mut {
+    ($CS:ident, $GLOBAL:ident, $LOCAL:ident, $CODE:block) => {
+        if let Some($LOCAL) = $GLOBAL.borrow($CS).borrow_mut().as_mut() {
+            $CODE
+        } else {
+            panic!();
+        }
+    };
+}
+
+// a helper macro to generalize the initialization of a UART
+macro_rules! setup_uart {
+    ( $CS:ident, $DP:ident, $RCC:ident, $GPIOx:ident ) => {
+        let (tx, rx) =
+            (
+                $GPIOx.pa2.into_alternate_af1($CS),
+                $GPIOx.pa15.into_alternate_af1($CS),
+            );
+
+        init_global!($CS, SER_PORT, Serial::usart1($DP.USART1, (tx, rx), 9_600.bps(), &mut $RCC));
+        with_global_mut!($CS, SER_PORT, ser, {
+            ser.listen(hal::serial::Event::Rxne);
+        });
+    };
+}
+
+#[entry]
+fn main() -> ! {
+    let dp = pac::Peripherals::take().unwrap(); // might as well panic if this doesn't work
+    let cp = cortex_m::peripheral::Peripherals::take().unwrap();
+    let mut flash = dp.FLASH;
+    let mut rcc = dp.RCC.configure().sysclk(48.mhz()).freeze(&mut flash);
+
+    let gpioa = dp.GPIOA.split(&mut rcc);
+    let gpiob = dp.GPIOB.split(&mut rcc);
+
+    let mut delay = Delay::new(cp.SYST, &rcc);
+
+    cortex_m::interrupt::free(|cs| {
+        setup_uart!(cs, dp, rcc, gpioa);
+
+        init_global!(cs, LED, gpiob.pb3.into_push_pull_output(cs));
+    });
+
+    #[allow(unsafe_code)] // just this once ;)
+    unsafe { cortex_m::peripheral::NVIC::unmask(Interrupt::USART1); }
+
+    loop {
+        cortex_m::interrupt::free(|cs| {
+            with_global_mut!(cs, LED, led, {
+                led.toggle().ok();
+            });
+        });
+
+        delay.delay_ms(1_000u16);
+    }
+}
+
+#[interrupt]
+fn USART1() {
+    cortex_m::interrupt::free(|cs| {
+        with_global_mut!(cs, SER_PORT, ser, {
+            if let Ok(data) = block!(ser.read()) {
+                block!(ser.write(data)).ok();
+            } else {
+                /*
+                Failed to read a byte:
+
+                There could be some kind of alignment error or the UART
+                was disconnected or something.
+                 */
+            }
+        });
+    });
+}