Merge pull request #323 from braun-embedded/dependencies

Upgrade to latest RTIC alpha

Author: david-sawatzke

Cargo.toml

@@ -63,7 +63,7 @@ default-features = false
 
 
 [dev-dependencies]
-cortex-m-rtic = "=0.6.0-alpha.4"
+cortex-m-rtic = "=0.6.0-alpha.5"
 
 [dev-dependencies.panic-rtt-target]
 version  = "0.1.1"

examples/i2c_master_slave.rs

@@ -15,17 +15,18 @@ mod app {
 
     const ADDRESS: u8 = 0x24;
 
-    #[resources]
-    struct Resources {
-        #[lock_free]
-        i2c_master: i2c::Master<I2C0, Enabled<PhantomData<IOSC>>, Enabled>,
+    #[shared]
+    struct Shared {}
 
-        #[lock_free]
+    #[local]
+    struct Local {
+        i2c_master: i2c::Master<I2C0, Enabled<PhantomData<IOSC>>, Enabled>,
         i2c_slave: i2c::Slave<I2C0, Enabled<PhantomData<IOSC>>, Enabled>,
+        i2c_data: Option<u8>,
     }
 
     #[init]
-    fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
+    fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
         rtt_target::rtt_init_print!();
 
         let p = Peripherals::take().unwrap();
@@ -57,19 +58,21 @@ mod app {
         });
 
         (
-            init::LateResources {
+            Shared {},
+            Local {
                 i2c_master: i2c.master,
                 i2c_slave: i2c.slave,
+                i2c_data: None,
             },
             init::Monotonics(),
         )
     }
 
-    #[idle(resources = [i2c_master])]
+    #[idle(local = [i2c_master])]
     fn idle(context: idle::Context) -> ! {
         let data = 0x14;
 
-        let i2c = context.resources.i2c_master;
+        let i2c = context.local.i2c_master;
 
         loop {
             rprintln!("MASTER: Starting I2C transaction...");
@@ -92,11 +95,10 @@ mod app {
         }
     }
 
-    #[task(binds = I2C0, resources = [i2c_slave])]
+    #[task(binds = I2C0, local = [i2c_slave, i2c_data])]
     fn i2c0(context: i2c0::Context) {
-        static mut DATA: Option<u8> = None;
-
-        let i2c = context.resources.i2c_slave;
+        let i2c = context.local.i2c_slave;
+        let data = context.local.i2c_data;
 
         rprintln!("SLAVE: Handling interrupt...");
 
@@ -111,15 +113,15 @@ mod app {
             Ok(i2c::slave::State::RxReady(i2c)) => {
                 rprintln!("SLAVE: Ready to receive.");
 
-                *DATA = Some(i2c.read().unwrap());
+                *data = Some(i2c.read().unwrap());
                 i2c.ack().unwrap();
 
                 rprintln!("SLAVE: Received and ack'ed.");
             }
             Ok(i2c::slave::State::TxReady(i2c)) => {
                 rprintln!("SLAVE: Ready to transmit.");
 
-                if let Some(data) = *DATA {
+                if let Some(data) = *data {
                     i2c.transmit(data << 1).unwrap();
                     rprintln!("SLAVE: Transmitted.");
                 }

examples/i2c_master_slave_dma.rs

@@ -14,22 +14,23 @@ mod app {
 
     const ADDRESS: u8 = 0x24;
 
-    #[resources]
-    struct Resources {
-        #[lock_free]
+    #[shared]
+    struct Shared {}
+
+    #[local]
+    struct Local {
         i2c_master:
             Option<i2c::Master<I2C0, Enabled<PhantomData<IOSC>>, Enabled>>,
-
-        #[lock_free]
         i2c_slave: i2c::Slave<I2C0, Enabled<PhantomData<IOSC>>, Enabled>,
+        i2c_data: Option<u8>,
 
-        #[lock_free]
         dma_channel:
             Option<dma::Channel<<I2C0 as i2c::Instance>::MstChannel, Enabled>>,
+        dma_rx_buf: [u8; 1],
     }
 
     #[init]
-    fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
+    fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
         rtt_target::rtt_init_print!();
 
         let p = Peripherals::take().unwrap();
@@ -62,27 +63,27 @@ mod app {
         });
 
         (
-            init::LateResources {
+            Shared {},
+            Local {
                 i2c_master: Some(i2c.master),
                 i2c_slave: i2c.slave,
+                i2c_data: None,
                 dma_channel: Some(dma.channels.channel15),
+                dma_rx_buf: [0; 1],
             },
             init::Monotonics(),
         )
     }
 
-    #[idle(resources = [i2c_master, dma_channel])]
+    #[idle(local = [i2c_master, dma_channel, dma_rx_buf])]
     fn idle(context: idle::Context) -> ! {
-        static mut RX_BUF: [u8; 1] = [0; 1];
-
-        let mut rx_buf = &mut RX_BUF[..];
-
         static TX_BUF: [u8; 1] = [0x14];
 
         // The `.take().unwrap()` workaround is required, because RTIC won't
         // allow us to move resources in here directly.
-        let mut i2c = context.resources.i2c_master.take().unwrap();
-        let mut channel = context.resources.dma_channel.take().unwrap();
+        let mut i2c = context.local.i2c_master.take().unwrap();
+        let mut channel = context.local.dma_channel.take().unwrap();
+        let mut rx_buf = &mut context.local.dma_rx_buf[..];
 
         loop {
             rprintln!("MASTER: Starting I2C transaction...");
@@ -122,11 +123,10 @@ mod app {
         }
     }
 
-    #[task(binds = I2C0, resources = [i2c_slave])]
+    #[task(binds = I2C0, local = [i2c_slave, i2c_data])]
     fn i2c0(context: i2c0::Context) {
-        static mut DATA: Option<u8> = None;
-
-        let i2c = context.resources.i2c_slave;
+        let i2c = context.local.i2c_slave;
+        let data = context.local.i2c_data;
 
         rprintln!("SLAVE: Handling interrupt...");
 
@@ -141,15 +141,15 @@ mod app {
             Ok(i2c::slave::State::RxReady(i2c)) => {
                 rprintln!("SLAVE: Ready to receive.");
 
-                *DATA = Some(i2c.read().unwrap());
+                *data = Some(i2c.read().unwrap());
                 i2c.ack().unwrap();
 
                 rprintln!("SLAVE: Received and ack'ed.");
             }
             Ok(i2c::slave::State::TxReady(i2c)) => {
                 rprintln!("SLAVE: Ready to transmit.");
 
-                if let Some(data) = *DATA {
+                if let Some(data) = *data {
                     i2c.transmit(data << 1).unwrap();
                     rprintln!("SLAVE: Transmitted.");
                 }

examples/pinint.rs

@@ -13,17 +13,17 @@ mod app {
         Peripherals,
     };
 
-    #[resources]
-    struct Resources {
-        #[lock_free]
-        int: pinint::Interrupt<PININT0, PIO0_4, Enabled>,
+    #[shared]
+    struct Shared {}
 
-        #[lock_free]
+    #[local]
+    struct Local {
+        int: pinint::Interrupt<PININT0, PIO0_4, Enabled>,
         led: GpioPin<PIO1_1, Output>,
     }
 
     #[init]
-    fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
+    fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
         rtt_target::rtt_init_print!();
 
         let p = Peripherals::take().unwrap();
@@ -45,7 +45,7 @@ mod app {
             .pio1_1
             .into_output_pin(gpio.tokens.pio1_1, Level::High);
 
-        (init::LateResources { int, led }, init::Monotonics())
+        (Shared {}, Local { int, led }, init::Monotonics())
     }
 
     #[idle]
@@ -57,10 +57,10 @@ mod app {
         }
     }
 
-    #[task(binds = PIN_INT0, resources = [int, led])]
+    #[task(binds = PIN_INT0, local = [int, led])]
     fn pinint0(context: pinint0::Context) {
-        let int = context.resources.int;
-        let led = context.resources.led;
+        let int = context.local.int;
+        let led = context.local.led;
 
         led.toggle();
 

examples/rtic.rs

@@ -13,17 +13,17 @@ mod app {
         Peripherals,
     };
 
-    #[resources]
-    struct Resources {
-        #[lock_free]
-        delay: Delay,
+    #[shared]
+    struct Shared {}
 
-        #[lock_free]
+    #[local]
+    struct Local {
+        delay: Delay,
         led: GpioPin<PIO1_1, Output>,
     }
 
     #[init]
-    fn init(cx: init::Context) -> (init::LateResources, init::Monotonics) {
+    fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
         rtt_target::rtt_init_print!();
 
         let p = Peripherals::take().unwrap();
@@ -38,13 +38,13 @@ mod app {
             .pio1_1
             .into_output_pin(gpio.tokens.pio1_1, Level::Low);
 
-        (init::LateResources { delay, led }, init::Monotonics())
+        (Shared {}, Local { delay, led }, init::Monotonics())
     }
 
-    #[idle(resources = [delay, led])]
+    #[idle(local = [delay, led])]
     fn idle(cx: idle::Context) -> ! {
-        let delay = cx.resources.delay;
-        let led = cx.resources.led;
+        let delay = cx.local.delay;
+        let led = cx.local.led;
 
         loop {
             led.set_high();