Merge #366

366: update dependencies r=therealprof a=burrbull



Co-authored-by: Andrey Zgarbul <zgarbul.andrey@gmail.com>

Author: bors[bot]

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Breaking changes
 
+- Bump `stm32f1` to `0.14.0`, `cortex-m-rtic` to `0.6.0-rc2` and others
 - Bump `stm32-usbd` dependency (`0.6.0`)
 - Use bit-banding for Peripheral enable/reset.
   Don't require APBs in initializers.

Cargo.toml

@@ -16,24 +16,15 @@ features = ["stm32f103", "rt"]
 default-target = "x86_64-unknown-linux-gnu"
 
 [dependencies]
-cortex-m = "0.6.0"
-nb = "0.1.2"
-cortex-m-rt = "0.6.8"
-stm32f1 = "0.11.0"
+cortex-m = "0.7"
+cortex-m-rt = "0.7"
+nb = "1"
+stm32f1 = "0.14.0"
 embedded-dma = "0.1.2"
 bxcan = ">=0.4, <0.6"
-
-[dependencies.void]
-default-features = false
-version = "1.0.2"
-
-[dependencies.cast]
-default-features = false
-version = "0.2.2"
-
-[dependencies.embedded-hal]
-version = "0.2.3"
-features = ["unproven"]
+cast = { default-features = false, version = "0.3.0" }
+void = { default-features = false, version = "1.0.2" }
+embedded-hal = { features = ["unproven"], version = "0.2.6" }
 
 [dependencies.stm32-usbd]
 version = "0.6.0"
@@ -43,34 +34,19 @@ optional = true
 panic-halt = "0.2.0"
 panic-semihosting = "0.5.2"
 panic-itm = "0.4.1"
-cortex-m-rtic = "0.5"
+cortex-m-rtic = "0.6.0-rc.2"
 cortex-m-semihosting = "0.3.3"
-heapless = "0.5.6"
+heapless = "0.7.7"
 m = "0.1.1"
 mfrc522 = "0.2.0"
-serde_derive = "1.0.90"
-usb-device = "0.2.3"
-usbd-serial = "0.1.0"
-
-[dev-dependencies.byteorder]
-default-features = false
-version = "1.3.1"
-
-[dev-dependencies.cobs]
-default-features = false
-version = "0.1.4"
-
-[dev-dependencies.crc16]
-default-features = false
-version = "0.4.0"
-
-[dev-dependencies.either]
-default-features = false
-version = "1.5.2"
-
-[dev-dependencies.serde]
-default-features = false
-version = "1.0.90"
+usb-device = "0.2.8"
+usbd-serial = "0.1.1"
+byteorder = { default-features = false, version = "1.4.3" }
+cobs = { default-features = false, version = "0.1.4" }
+crc16 = { default-features = false, version = "0.4.0" }
+either = { default-features = false, version = "1.6.1" }
+serde = { default-features = false, version = "1.0.130"}
+serde_derive = "1.0.130"
 
 [features]
 device-selected = []

examples/can-rtic.rs

@@ -11,21 +11,14 @@
 #![no_main]
 #![no_std]
 
+use panic_halt as _;
+
+use bxcan::Frame;
 use core::cmp::Ordering;
 
-use bxcan::{filter::Mask32, ExtendedId, Frame, Interrupts, Rx, StandardId, Tx};
-use heapless::{
-    binary_heap::{BinaryHeap, Max},
-    consts::*,
-};
-use nb::block;
-use panic_halt as _;
-use rtic::app;
-use stm32f1xx_hal::{
-    can::Can,
-    pac::{Interrupt, CAN1},
-    prelude::*,
-};
+use heapless::binary_heap::{BinaryHeap, Max};
+
+use stm32f1xx_hal::pac::Interrupt;
 
 #[derive(Debug)]
 pub struct PriorityFrame(Frame);
@@ -52,22 +45,31 @@ impl PartialEq for PriorityFrame {
 
 impl Eq for PriorityFrame {}
 
-fn enqueue_frame(queue: &mut BinaryHeap<PriorityFrame, U16, Max>, frame: Frame) {
+fn enqueue_frame(queue: &mut BinaryHeap<PriorityFrame, Max, 16>, frame: Frame) {
     queue.push(PriorityFrame(frame)).unwrap();
     rtic::pend(Interrupt::USB_HP_CAN_TX);
 }
 
-#[app(device = stm32f1xx_hal::pac, peripherals = true)]
-const APP: () = {
-    struct Resources {
+#[rtic::app(device = stm32f1xx_hal::pac)]
+mod app {
+    use super::{enqueue_frame, PriorityFrame};
+    use bxcan::{filter::Mask32, ExtendedId, Frame, Interrupts, Rx, StandardId, Tx};
+    use heapless::binary_heap::{BinaryHeap, Max};
+    use stm32f1xx_hal::{can::Can, pac::CAN1, prelude::*};
+
+    #[local]
+    struct Local {
         can_tx: Tx<Can<CAN1>>,
-        can_tx_queue: BinaryHeap<PriorityFrame, U16, Max>,
-        tx_count: usize,
         can_rx: Rx<Can<CAN1>>,
     }
+    #[shared]
+    struct Shared {
+        can_tx_queue: BinaryHeap<PriorityFrame, Max, 16>,
+        tx_count: usize,
+    }
 
     #[init]
-    fn init(cx: init::Context) -> init::LateResources {
+    fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
         let mut flash = cx.device.FLASH.constrain();
         let rcc = cx.device.RCC.constrain();
 
@@ -105,23 +107,25 @@ const APP: () = {
         can.enable_interrupts(
             Interrupts::TRANSMIT_MAILBOX_EMPTY | Interrupts::FIFO0_MESSAGE_PENDING,
         );
-        block!(can.enable()).unwrap();
+        nb::block!(can.enable()).unwrap();
 
         let (can_tx, can_rx) = can.split();
 
         let can_tx_queue = BinaryHeap::new();
 
-        init::LateResources {
-            can_tx,
-            can_tx_queue,
-            tx_count: 0,
-            can_rx,
-        }
+        (
+            Shared {
+                can_tx_queue,
+                tx_count: 0,
+            },
+            Local { can_tx, can_rx },
+            init::Monotonics(),
+        )
     }
 
-    #[idle(resources = [can_tx_queue, tx_count])]
+    #[idle(shared = [can_tx_queue, tx_count])]
     fn idle(mut cx: idle::Context) -> ! {
-        let mut tx_queue = cx.resources.can_tx_queue;
+        let mut tx_queue = cx.shared.can_tx_queue;
 
         // Enqueue some messages. Higher ID means lower priority.
         tx_queue.lock(|mut tx_queue| {
@@ -155,7 +159,7 @@ const APP: () = {
 
         // Add some higher priority messages when 3 messages have been sent.
         loop {
-            let tx_count = cx.resources.tx_count.lock(|tx_count| *tx_count);
+            let tx_count = cx.shared.tx_count.lock(|tx_count| *tx_count);
 
             if tx_count >= 3 {
                 tx_queue.lock(|mut tx_queue| {
@@ -196,45 +200,50 @@ const APP: () = {
     }
 
     // This ISR is triggered by each finished frame transmission.
-    #[task(binds = USB_HP_CAN_TX, resources = [can_tx, can_tx_queue, tx_count])]
+    #[task(binds = USB_HP_CAN_TX, local = [can_tx], shared = [can_tx_queue, tx_count])]
     fn can_tx(cx: can_tx::Context) {
-        let tx = cx.resources.can_tx;
-        let tx_queue = cx.resources.can_tx_queue;
+        let tx = cx.local.can_tx;
+        let mut tx_queue = cx.shared.can_tx_queue;
+        let mut tx_count = cx.shared.tx_count;
 
         tx.clear_interrupt_flags();
 
         // There is now a free mailbox. Try to transmit pending frames until either
         // the queue is empty or transmission would block the execution of this ISR.
-        while let Some(frame) = tx_queue.peek() {
-            match tx.transmit(&frame.0) {
-                Ok(None) => {
-                    // Frame was successfully placed into a transmit buffer.
-                    tx_queue.pop();
-                    *cx.resources.tx_count += 1;
+        (&mut tx_queue, &mut tx_count).lock(|tx_queue, tx_count| {
+            while let Some(frame) = tx_queue.peek() {
+                match tx.transmit(&frame.0) {
+                    Ok(None) => {
+                        // Frame was successfully placed into a transmit buffer.
+                        tx_queue.pop();
+                        *tx_count += 1;
+                    }
+                    Ok(Some(pending_frame)) => {
+                        // A lower priority frame was replaced with our high priority frame.
+                        // Put the low priority frame back in the transmit queue.
+                        tx_queue.pop();
+                        enqueue_frame(tx_queue, pending_frame);
+                    }
+                    Err(nb::Error::WouldBlock) => break,
+                    Err(_) => unreachable!(),
                 }
-                Ok(Some(pending_frame)) => {
-                    // A lower priority frame was replaced with our high priority frame.
-                    // Put the low priority frame back in the transmit queue.
-                    tx_queue.pop();
-                    enqueue_frame(tx_queue, pending_frame);
-                }
-                Err(nb::Error::WouldBlock) => break,
-                Err(_) => unreachable!(),
             }
-        }
+        });
     }
 
-    #[task(binds = USB_LP_CAN_RX0, resources = [can_rx, can_tx_queue])]
-    fn can_rx0(cx: can_rx0::Context) {
+    #[task(binds = USB_LP_CAN_RX0, local = [can_rx], shared = [can_tx_queue])]
+    fn can_rx0(mut cx: can_rx0::Context) {
         // Echo back received packages with correct priority ordering.
         loop {
-            match cx.resources.can_rx.receive() {
+            match cx.local.can_rx.receive() {
                 Ok(frame) => {
-                    enqueue_frame(cx.resources.can_tx_queue, frame);
+                    cx.shared.can_tx_queue.lock(|can_tx_queue| {
+                        enqueue_frame(can_tx_queue, frame);
+                    });
                 }
                 Err(nb::Error::WouldBlock) => break,
                 Err(nb::Error::Other(_)) => {} // Ignore overrun errors.
             }
         }
     }
-};
+}

examples/exti_rtic.rs

@@ -3,24 +3,26 @@
 #![no_std]
 #![no_main]
 
-extern crate rtic;
-
 use panic_halt as _;
-use rtic::app;
-use stm32f1xx_hal::{
-    gpio::{gpioa::PA0, gpioc::PC13, Edge, ExtiPin, Input, Output, PullDown, PushPull},
-    prelude::*,
-};
-
-#[app(device = stm32f1xx_hal::pac, peripherals = true)]
-const APP: () = {
-    struct Resources {
+
+#[rtic::app(device = stm32f1xx_hal::pac)]
+mod app {
+    use stm32f1xx_hal::{
+        gpio::{gpioa::PA0, gpioc::PC13, Edge, ExtiPin, Input, Output, PullDown, PushPull},
+        prelude::*,
+    };
+
+    #[shared]
+    struct Shared {}
+
+    #[local]
+    struct Local {
         button: PA0<Input<PullDown>>,
         led: PC13<Output<PushPull>>,
     }
 
     #[init]
-    fn init(mut ctx: init::Context) -> init::LateResources {
+    fn init(mut ctx: init::Context) -> (Shared, Local, init::Monotonics) {
         let mut afio = ctx.device.AFIO.constrain();
 
         let mut gpioc = ctx.device.GPIOC.split();
@@ -32,12 +34,12 @@ const APP: () = {
         button.enable_interrupt(&mut ctx.device.EXTI);
         button.trigger_on_edge(&mut ctx.device.EXTI, Edge::Rising);
 
-        init::LateResources { button, led }
+        (Shared {}, Local { button, led }, init::Monotonics())
     }
 
-    #[task(binds = EXTI0, resources = [button, led])]
+    #[task(binds = EXTI0, local = [button, led])]
     fn button_click(ctx: button_click::Context) {
-        ctx.resources.button.clear_interrupt_pending_bit();
-        ctx.resources.led.toggle();
+        ctx.local.button.clear_interrupt_pending_bit();
+        ctx.local.led.toggle();
     }
-};
+}

examples/panics.rs

@@ -1,6 +1,5 @@
 //! Prints "Hello, world" on the OpenOCD console
 
-#![deny(unsafe_code)]
 #![no_main]
 #![no_std]
 
@@ -18,11 +17,11 @@ fn main() -> ! {
 }
 
 #[exception]
-fn HardFault(ef: &ExceptionFrame) -> ! {
+unsafe fn HardFault(ef: &ExceptionFrame) -> ! {
     panic!("{:#?}", ef);
 }
 
 #[exception]
-fn DefaultHandler(irqn: i16) {
+unsafe fn DefaultHandler(irqn: i16) {
     panic!("Unhandled exception (IRQn = {})", irqn);
 }