works, in theory

src/main.rs

@@ -2,30 +2,41 @@
 #![no_std]
 
 extern crate cortex_m;
-#[macro_use(entry, exception)]
 extern crate cortex_m_rt as rt;
 extern crate panic_semihosting;
 
 extern crate stm32f4xx_hal as hal;
-// #[macro_use(block)]
-// extern crate nb;
 
 #[rtic::app(device = stm32f4xx_hal::pac, peripherals = true)]
 mod app {
-    use core::cell::RefCell;
-
-    use cortex_m::interrupt::{free, Mutex};
     use cortex_m::peripheral::NVIC;
     use hal::block;
-    use hal::pac::{self, USART1};
+    use hal::gpio;
+    use hal::pac::{SPI1, TIM5, USART1};
     use hal::serial::{Config, Event, Serial};
     use hal::spi::{Mode, Phase, Polarity, Spi};
+    use hal::timer::Delay;
     use rf4463::config::RADIO_CONFIG_500_2;
     use rf4463::Rf4463;
-    use ringbuf::{Consumer, Producer, Rb, StaticRb};
+    use ringbuf::{Rb, StaticRb};
 
     use crate::hal::{interrupt, prelude::*};
 
+    const PACKET_LEN: usize = 256 + 2 + 65;
+    const BUFFER_LEN: usize = 16_384;
+
+    const MODE: Mode = Mode {
+        polarity: Polarity::IdleLow,
+        phase: Phase::CaptureOnFirstTransition,
+    };
+
+    type Radio = Rf4463<
+        Spi<SPI1>,
+        gpio::Pin<'B', 1, gpio::Output>,
+        gpio::Pin<'B', 0, gpio::Output>,
+        Delay<TIM5, 1000000>,
+    >;
+
     enum SlaveCmd {
         BufferStatus,
         SendPacket,
@@ -41,37 +52,25 @@ mod app {
         }
     }
 
-    enum SlaveState {
+    pub enum SlaveState {
         Idle,
         RecvPacket(usize),
     }
 
     #[shared]
-    struct Shared {}
+    struct Shared {
+        tx_buf: StaticRb<u8, BUFFER_LEN>,
+    }
 
     #[local]
     struct Local {
+        radio: Radio,
         usart: Serial<USART1>,
         state: SlaveState,
-        producer: Producer<u8, StaticRb<u8, 16384>>,
-        consumer: Consumer<u8, StaticRb<u8, 16384>>,
     }
 
-    static USART: Mutex<RefCell<Option<Serial<USART1, u8>>>> = Mutex::new(RefCell::new(None));
-
-    static SLAVE_STATE: Mutex<RefCell<SlaveState>> = Mutex::new(RefCell::new(SlaveState::Idle));
-
-    static BUF: Mutex<RefCell<Option<StaticRb<u8, 16384>>>> = Mutex::new(RefCell::new(None));
-
-    const MODE: Mode = Mode {
-        polarity: Polarity::IdleLow,
-        phase: Phase::CaptureOnFirstTransition,
-    };
-
-    const PACKET_LEN: usize = 256 + 2 + 65;
-
     #[init]
-    fn init(mut ctx: init::Context) -> (Shared, Local, init::Monotonics) {
+    fn init(ctx: init::Context) -> (Shared, Local, init::Monotonics) {
         let rcc = ctx.device.RCC.constrain();
 
         let gpioa = ctx.device.GPIOA.split();
@@ -92,13 +91,13 @@ mod app {
         let spi = Spi::new(ctx.device.SPI1, (sclk, miso, mosi), MODE, 10.MHz(), &clocks);
 
         let delay = ctx.device.TIM5.delay_us(&clocks);
-        let mut radio = Rf4463::new(spi, sdn, cs, delay, &mut RADIO_CONFIG_500_2.clone()).unwrap();
+        let radio = Rf4463::new(spi, sdn, cs, delay, &mut RADIO_CONFIG_500_2.clone()).unwrap();
 
         // setup Pi UART
         let tx = gpioa.pa9;
         let rx = gpioa.pa10;
 
-        let mut serial = Serial::new(
+        let mut usart = Serial::new(
             ctx.device.USART1,
             (tx, rx),
             Config::default().baudrate(921_600.bps()),
@@ -106,27 +105,39 @@ mod app {
         )
         .unwrap();
 
-        serial.listen(Event::Rxne);
+        usart.listen(Event::Rxne);
 
         // enable usart interrupt
         unsafe {
             NVIC::unmask(interrupt::USART1);
         }
 
+        (
+            Shared {
+                tx_buf: StaticRb::default(),
+            },
+            Local {
+                radio,
+                usart,
+                state: SlaveState::Idle,
+            },
+            init::Monotonics(),
+        )
+    }
+
+    #[idle(local = [radio], shared=[tx_buf])]
+    fn idle(mut ctx: idle::Context) -> ! {
         let mut data = [0; PACKET_LEN];
         let mut i = 0;
 
         loop {
             if i == PACKET_LEN {
-                radio.tx(&mut data).unwrap();
+                ctx.local.radio.tx(&mut data).unwrap();
                 i = 0;
                 continue;
             }
 
-            free(|cs| {
-                let mut buf = BUF.borrow(cs).borrow_mut();
-                let buf = buf.as_mut().unwrap();
-
+            ctx.shared.tx_buf.lock(|buf| {
                 if let Some(b) = buf.pop() {
                     data[i] = b;
 
@@ -140,53 +151,44 @@ mod app {
         }
     }
 
-    /*#[exception]
-    unsafe fn HardFault(ef: &ExceptionFrame) -> ! {
-        panic!("{:#?}", ef);
-    }*/
-
-    #[interrupt]
-    fn USART1() {
-        free(|cs| {
-            let mut state = SLAVE_STATE.borrow(cs).borrow_mut();
-
-            let mut usart = USART.borrow(cs).borrow_mut();
-            let usart = usart.as_mut().unwrap();
-
-            let mut buf = BUF.borrow(cs).borrow_mut();
-            let buf = buf.as_mut().unwrap();
-
-            let x = block!(usart.read()).unwrap();
-
-            match *state {
-                SlaveState::Idle => {
-                    if let Some(cmd) = SlaveCmd::from_u8(x) {
-                        match cmd {
-                            SlaveCmd::BufferStatus => {
-                                if buf.free_len() < PACKET_LEN {
-                                    block!(usart.write(0x01)).unwrap(); // not enough space for a new packet
-                                } else {
-                                    block!(usart.write(0x02)).unwrap(); // safe to send a packet
-                                }
-                            }
+    #[task(binds = USART1, local = [state, usart], shared = [tx_buf])]
+    fn usart1(ctx: usart1::Context) {
+        let state = ctx.local.state;
 
-                            SlaveCmd::SendPacket => {
-                                *state = SlaveState::RecvPacket(PACKET_LEN - 1);
+        let usart = ctx.local.usart;
+
+        let mut buf = ctx.shared.tx_buf;
+
+        let x = block!(usart.read()).unwrap();
+
+        match *state {
+            SlaveState::Idle => {
+                if let Some(cmd) = SlaveCmd::from_u8(x) {
+                    match cmd {
+                        SlaveCmd::BufferStatus => {
+                            if buf.lock(|b| b.free_len()) < PACKET_LEN {
+                                block!(usart.write(0x01)).unwrap(); // not enough space for a new packet
+                            } else {
+                                block!(usart.write(0x02)).unwrap(); // safe to send a packet
                             }
                         }
+
+                        SlaveCmd::SendPacket => {
+                            *state = SlaveState::RecvPacket(PACKET_LEN - 1);
+                        }
                     }
                 }
+            }
 
-                SlaveState::RecvPacket(i) => {
-                    *state = if i == 0 {
-                        SlaveState::Idle
-                    } else {
-                        SlaveState::RecvPacket(i - 1)
-                    };
+            SlaveState::RecvPacket(i) => {
+                *state = if i == 0 {
+                    SlaveState::Idle
+                } else {
+                    SlaveState::RecvPacket(i - 1)
+                };
 
-                    buf.push(x).unwrap();
-                }
-            };
-        });
+                buf.lock(|b| b.push(x).unwrap());
+            }
+        };
     }
 }