therealprof gets what therealprof wants

Author: AdinAck

examples/serial_echo_irq.rs

@@ -17,17 +17,14 @@ use hal::{
     delay::Delay,
     gpio::{
         gpioa::{PA15, PA2},
-        gpiob::PB3,
-        Alternate, Output, PushPull, AF1,
+        Alternate, AF1,
     },
     pac::{self, interrupt, Interrupt, USART1},
     prelude::*,
     serial::Serial,
 };
 use stm32f0xx_hal as hal;
 
-// setup some types for our globally shared resources
-type LED_PIN = PB3<Output<PushPull>>;
 type SERIAL = Serial<USART1, PA2<Alternate<AF1>>, PA15<Alternate<AF1>>>;
 
 /*
@@ -40,48 +37,11 @@ that the resource inside the Mutex will not violate
 the RefMut's runtime borrowing rules (Given that we do not
 try to borrow the RefMut 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 mut delay = cortex_m::interrupt::free(|cs| {
+    let (mut delay, mut led) = cortex_m::interrupt::free(|cs| {
         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;
@@ -91,11 +51,24 @@ fn main() -> ! {
         let gpiob = dp.GPIOB.split(&mut rcc);
 
         let delay = Delay::new(cp.SYST, &rcc);
-        setup_uart!(cs, dp, rcc, gpioa);
 
-        init_global!(cs, LED, gpiob.pb3.into_push_pull_output(cs));
+        // setup UART
+        let (tx, rx) = (
+            gpioa.pa2.into_alternate_af1(cs),
+            gpioa.pa15.into_alternate_af1(cs),
+        );
+
+        // initialize global serial
+        *SER_PORT.borrow(cs).borrow_mut() =
+            Some(Serial::usart1(dp.USART1, (tx, rx), 9_600.bps(), &mut rcc));
+        
+        if let Some(ser) = SER_PORT.borrow(cs).borrow_mut().as_mut() {
+            ser.listen(hal::serial::Event::Rxne); // trigger the USART1 interrupt when bytes are available (receive buffer not empty)
+        }
+
+        let led = gpiob.pb3.into_push_pull_output(cs);
 
-        delay
+        (delay, led)
     });
 
     #[allow(unsafe_code)] // just this once ;)
@@ -104,11 +77,7 @@ fn main() -> ! {
     }
 
     loop {
-        cortex_m::interrupt::free(|cs| {
-            with_global_mut!(cs, LED, led, {
-                led.toggle().ok();
-            });
-        });
+        led.toggle().ok();
 
         delay.delay_ms(1_000u16);
     }
@@ -117,7 +86,7 @@ fn main() -> ! {
 #[interrupt]
 fn USART1() {
     cortex_m::interrupt::free(|cs| {
-        with_global_mut!(cs, SER_PORT, ser, {
+        if let Some(ser) = SER_PORT.borrow(cs).borrow_mut().as_mut() {
             if let Ok(data) = block!(ser.read()) {
                 block!(ser.write(data)).ok();
             } else {
@@ -128,6 +97,6 @@ fn USART1() {
                 was disconnected or something.
                  */
             }
-        });
+        }
     });
 }