Merge upstream

Author: kalkyl

examples/rtc-demo/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "rtc-demo"
+version = "0.1.0"
+authors = ["Timo Kröger"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+cortex-m = "0.6.2"
+cortex-m-rt = "0.6.12"
+rtt-target = {version = "0.2.0", features = ["cortex-m"] }
+nrf52840-hal = { features = ["rt"], path = "../../nrf52840-hal" }
+
+[dependencies.embedded-hal]
+version = "0.2.3"
+features = ["unproven"]

examples/rtc-demo/Embed.toml

@@ -0,0 +1,2 @@
+[default.rtt]
+enabled = true

examples/rtc-demo/README.md

@@ -0,0 +1,18 @@
+# RTC demo
+
+This example shows how to use the compare functionality of the real-time counter peripheral.
+Runs on the nRF52840_DK but can easily be adapted for other hardware.
+
+## Set up with `cargo-embed`
+
+Install `cargo-embed` if you don't have it already:
+
+```console
+$ cargo install cargo-embed
+```
+
+Then just `cd` to the example folder and run
+
+```console
+$ cargo embed --target thumbv7em-none-eabihf
+```

examples/rtc-demo/src/main.rs

@@ -0,0 +1,50 @@
+#![no_main]
+#![no_std]
+
+use nrf52840_hal as hal;
+
+use hal::rtc::{Rtc, RtcCompareReg, RtcInterrupt};
+use rtt_target::{rprintln, rtt_init_print};
+
+#[panic_handler] // panicking behavior
+fn panic(_: &core::panic::PanicInfo) -> ! {
+    loop {
+        cortex_m::asm::bkpt();
+    }
+}
+
+#[cortex_m_rt::entry]
+fn main() -> ! {
+    rtt_init_print!();
+
+    let p = hal::pac::Peripherals::take().unwrap();
+
+    // Enable LfClk which is required by the RTC.
+    let clocks = hal::clocks::Clocks::new(p.CLOCK);
+    let clocks = clocks.start_lfclk();
+
+    // Run RTC for 1 second
+    let mut rtc = Rtc::new(p.RTC0);
+    rtc.set_compare(RtcCompareReg::Compare0, 32_768).unwrap();
+    rtc.enable_event(RtcInterrupt::Compare0);
+
+    rprintln!("Starting RTC");
+    let rtc = rtc.enable_counter();
+
+    rprintln!("Waiting for compare match");
+    while !rtc.is_event_triggered(RtcInterrupt::Compare0) {}
+    rtc.reset_event(RtcInterrupt::Compare0);
+
+    rprintln!("Compare match, stopping RTC");
+    let rtc = rtc.disable_counter();
+
+    rprintln!("Counter stopped at {} ticks", rtc.get_counter());
+
+    // Stop LfClk when RTC is not used anymore.
+    rtc.release();
+    clocks.stop_lfclk();
+
+    loop {
+        cortex_m::asm::nop();
+    }
+}

nrf-hal-common/src/gpio.rs

@@ -133,9 +133,13 @@ impl<MODE> Pin<MODE> {
         unsafe { &*ptr }
     }
 
+    pub(crate) fn conf(&self) -> &gpio::PIN_CNF {
+        &self.block().pin_cnf[self.pin() as usize]
+    }
+
     /// Convert the pin to be a floating input
     pub fn into_floating_input(self) -> Pin<Input<Floating>> {
-        self.block().pin_cnf[self.pin() as usize].write(|w| {
+        self.conf().write(|w| {
             w.dir().input();
             w.input().connect();
             w.pull().disabled();
@@ -150,7 +154,7 @@ impl<MODE> Pin<MODE> {
         }
     }
     pub fn into_pullup_input(self) -> Pin<Input<PullUp>> {
-        self.block().pin_cnf[self.pin() as usize].write(|w| {
+        self.conf().write(|w| {
             w.dir().input();
             w.input().connect();
             w.pull().pullup();
@@ -165,7 +169,7 @@ impl<MODE> Pin<MODE> {
         }
     }
     pub fn into_pulldown_input(self) -> Pin<Input<PullDown>> {
-        self.block().pin_cnf[self.pin() as usize].write(|w| {
+        self.conf().write(|w| {
             w.dir().input();
             w.input().connect();
             w.pull().pulldown();
@@ -192,7 +196,7 @@ impl<MODE> Pin<MODE> {
             Level::High => pin.set_high().unwrap(),
         }
 
-        self.block().pin_cnf[self.pin() as usize].write(|w| {
+        self.conf().write(|w| {
             w.dir().output();
             w.input().connect(); // AJM - hack for SPI
             w.pull().disabled();
@@ -224,8 +228,7 @@ impl<MODE> Pin<MODE> {
         }
 
         // This is safe, as we restrict our access to the dedicated register for this pin.
-        let pin_cnf = &self.block().pin_cnf[self.pin() as usize];
-        pin_cnf.write(|w| {
+        self.conf().write(|w| {
             w.dir().output();
             w.input().disconnect();
             w.pull().disabled();
@@ -236,6 +239,20 @@ impl<MODE> Pin<MODE> {
 
         pin
     }
+
+    /// Disconnects the pin.
+    ///
+    /// In disconnected mode the pin cannot be used as input or output.
+    /// It is primarily useful to reduce power usage.
+    pub fn into_disconnected(self) -> Pin<Disconnected> {
+        // Reset value is disconnected.
+        self.conf().reset();
+
+        Pin {
+            _mode: PhantomData,
+            pin_port: self.pin_port,
+        }
+    }
 }
 
 impl<MODE> InputPin for Pin<Input<MODE>> {
@@ -489,6 +506,19 @@ macro_rules! gpio {
                         pin
                     }
 
+                    /// Disconnects the pin.
+                    ///
+                    /// In disconnected mode the pin cannot be used as input or output.
+                    /// It is primarily useful to reduce power usage.
+                    pub fn into_disconnected(self) -> $PXi<Disconnected> {
+                        // Reset value is disconnected.
+                        unsafe { &(*$PX::ptr()).pin_cnf[$i] }.reset();
+
+                        $PXi {
+                            _mode: PhantomData,
+                        }
+                    }
+
                     /// Degrade to a generic pin struct, which can be used with peripherals
                     pub fn degrade(self) -> Pin<MODE> {
                         Pin::new($port_value, $i)
@@ -552,58 +582,58 @@ macro_rules! gpio {
 // 32-bit GPIO port (P0)
 // ===========================================================================
 gpio!(P0, p0, p0, Port::Port0, [
-    P0_00: (p0_00,  0, Input<Disconnected>),
-    P0_01: (p0_01,  1, Input<Disconnected>),
-    P0_02: (p0_02,  2, Input<Disconnected>),
-    P0_03: (p0_03,  3, Input<Disconnected>),
-    P0_04: (p0_04,  4, Input<Disconnected>),
-    P0_05: (p0_05,  5, Input<Disconnected>),
-    P0_06: (p0_06,  6, Input<Disconnected>),
-    P0_07: (p0_07,  7, Input<Disconnected>),
-    P0_08: (p0_08,  8, Input<Disconnected>),
-    P0_09: (p0_09,  9, Input<Disconnected>),
-    P0_10: (p0_10, 10, Input<Disconnected>),
-    P0_11: (p0_11, 11, Input<Disconnected>),
-    P0_12: (p0_12, 12, Input<Disconnected>),
-    P0_13: (p0_13, 13, Input<Disconnected>),
-    P0_14: (p0_14, 14, Input<Disconnected>),
-    P0_15: (p0_15, 15, Input<Disconnected>),
-    P0_16: (p0_16, 16, Input<Disconnected>),
-    P0_17: (p0_17, 17, Input<Disconnected>),
-    P0_18: (p0_18, 18, Input<Disconnected>),
-    P0_19: (p0_19, 19, Input<Disconnected>),
-    P0_20: (p0_20, 20, Input<Disconnected>),
-    P0_21: (p0_21, 21, Input<Disconnected>),
-    P0_22: (p0_22, 22, Input<Disconnected>),
-    P0_23: (p0_23, 23, Input<Disconnected>),
-    P0_24: (p0_24, 24, Input<Disconnected>),
-    P0_25: (p0_25, 25, Input<Disconnected>),
-    P0_26: (p0_26, 26, Input<Disconnected>),
-    P0_27: (p0_27, 27, Input<Disconnected>),
-    P0_28: (p0_28, 28, Input<Disconnected>),
-    P0_29: (p0_29, 29, Input<Disconnected>),
-    P0_30: (p0_30, 30, Input<Disconnected>),
-    P0_31: (p0_31, 31, Input<Disconnected>),
+    P0_00: (p0_00,  0, Disconnected),
+    P0_01: (p0_01,  1, Disconnected),
+    P0_02: (p0_02,  2, Disconnected),
+    P0_03: (p0_03,  3, Disconnected),
+    P0_04: (p0_04,  4, Disconnected),
+    P0_05: (p0_05,  5, Disconnected),
+    P0_06: (p0_06,  6, Disconnected),
+    P0_07: (p0_07,  7, Disconnected),
+    P0_08: (p0_08,  8, Disconnected),
+    P0_09: (p0_09,  9, Disconnected),
+    P0_10: (p0_10, 10, Disconnected),
+    P0_11: (p0_11, 11, Disconnected),
+    P0_12: (p0_12, 12, Disconnected),
+    P0_13: (p0_13, 13, Disconnected),
+    P0_14: (p0_14, 14, Disconnected),
+    P0_15: (p0_15, 15, Disconnected),
+    P0_16: (p0_16, 16, Disconnected),
+    P0_17: (p0_17, 17, Disconnected),
+    P0_18: (p0_18, 18, Disconnected),
+    P0_19: (p0_19, 19, Disconnected),
+    P0_20: (p0_20, 20, Disconnected),
+    P0_21: (p0_21, 21, Disconnected),
+    P0_22: (p0_22, 22, Disconnected),
+    P0_23: (p0_23, 23, Disconnected),
+    P0_24: (p0_24, 24, Disconnected),
+    P0_25: (p0_25, 25, Disconnected),
+    P0_26: (p0_26, 26, Disconnected),
+    P0_27: (p0_27, 27, Disconnected),
+    P0_28: (p0_28, 28, Disconnected),
+    P0_29: (p0_29, 29, Disconnected),
+    P0_30: (p0_30, 30, Disconnected),
+    P0_31: (p0_31, 31, Disconnected),
 ]);
 
 // The p1 types are present in the p0 module generated from the
 // svd, but we want to export them in a p1 module from this crate.
 #[cfg(any(feature = "52833", feature = "52840"))]
 gpio!(P1, p0, p1, Port::Port1, [
-    P1_00: (p1_00,  0, Input<Disconnected>),
-    P1_01: (p1_01,  1, Input<Disconnected>),
-    P1_02: (p1_02,  2, Input<Disconnected>),
-    P1_03: (p1_03,  3, Input<Disconnected>),
-    P1_04: (p1_04,  4, Input<Disconnected>),
-    P1_05: (p1_05,  5, Input<Disconnected>),
-    P1_06: (p1_06,  6, Input<Disconnected>),
-    P1_07: (p1_07,  7, Input<Disconnected>),
-    P1_08: (p1_08,  8, Input<Disconnected>),
-    P1_09: (p1_09,  9, Input<Disconnected>),
-    P1_10: (p1_10, 10, Input<Disconnected>),
-    P1_11: (p1_11, 11, Input<Disconnected>),
-    P1_12: (p1_12, 12, Input<Disconnected>),
-    P1_13: (p1_13, 13, Input<Disconnected>),
-    P1_14: (p1_14, 14, Input<Disconnected>),
-    P1_15: (p1_15, 15, Input<Disconnected>),
+    P1_00: (p1_00,  0, Disconnected),
+    P1_01: (p1_01,  1, Disconnected),
+    P1_02: (p1_02,  2, Disconnected),
+    P1_03: (p1_03,  3, Disconnected),
+    P1_04: (p1_04,  4, Disconnected),
+    P1_05: (p1_05,  5, Disconnected),
+    P1_06: (p1_06,  6, Disconnected),
+    P1_07: (p1_07,  7, Disconnected),
+    P1_08: (p1_08,  8, Disconnected),
+    P1_09: (p1_09,  9, Disconnected),
+    P1_10: (p1_10, 10, Disconnected),
+    P1_11: (p1_11, 11, Disconnected),
+    P1_12: (p1_12, 12, Disconnected),
+    P1_13: (p1_13, 13, Disconnected),
+    P1_14: (p1_14, 14, Disconnected),
+    P1_15: (p1_15, 15, Disconnected),
 ]);

nrf-hal-common/src/gpiote.rs

@@ -361,6 +361,15 @@ fn config_channel_task_pin<P: GpioteOutputPin>(
             TaskOutPolarity::Clear => w.polarity().hi_to_lo(),
             TaskOutPolarity::Toggle => w.polarity().toggle(),
         };
+
+        #[cfg(any(feature = "52833", feature = "52840"))]
+        {
+            match pin.port() {
+                Port::Port0 => w.port().clear_bit(),
+                Port::Port1 => w.port().set_bit(),
+            };
+        }
+
         unsafe { w.psel().bits(pin.pin()) }
     });
 }
@@ -421,16 +430,23 @@ impl GpioteInputPin for Pin<Input<Floating>> {
 /// Trait to represent task output pin.
 pub trait GpioteOutputPin {
     fn pin(&self) -> u8;
+    fn port(&self) -> Port;
 }
 
 impl GpioteOutputPin for Pin<Output<OpenDrain>> {
     fn pin(&self) -> u8 {
         self.pin()
     }
+    fn port(&self) -> Port {
+        self.port()
+    }
 }
 
 impl GpioteOutputPin for Pin<Output<PushPull>> {
     fn pin(&self) -> u8 {
         self.pin()
     }
+    fn port(&self) -> Port {
+        self.port()
+    }
 }

nrf-hal-common/src/i2s.rs

@@ -267,7 +267,7 @@ impl I2S {
     pub fn rx<W, B>(mut self, mut buffer: B) -> Result<Transfer<B>, Error>
     where
         W: SupportedWordSize,
-        B: WriteBuffer<Word = W>,
+        B: WriteBuffer<Word = W> + 'static,
     {
         let (ptr, len) = unsafe { buffer.write_buffer() };
         if ptr as u32 % 4 != 0 {
@@ -300,8 +300,8 @@ impl I2S {
     ) -> Result<TransferFullDuplex<TxB, RxB>, Error>
     where
         W: SupportedWordSize,
-        TxB: ReadBuffer<Word = W>,
-        RxB: WriteBuffer<Word = W>,
+        TxB: ReadBuffer<Word = W> + 'static,
+        RxB: WriteBuffer<Word = W> + 'static,
     {
         let (rx_ptr, rx_len) = unsafe { rx_buffer.write_buffer() };
         let (tx_ptr, tx_len) = unsafe { tx_buffer.read_buffer() };
@@ -345,7 +345,7 @@ impl I2S {
     pub fn tx<W, B>(mut self, buffer: B) -> Result<Transfer<B>, Error>
     where
         W: SupportedWordSize,
-        B: ReadBuffer<Word = W>,
+        B: ReadBuffer<Word = W> + 'static,
     {
         let (ptr, len) = unsafe { buffer.read_buffer() };
         if ptr as u32 % 4 != 0 {
@@ -602,6 +602,7 @@ pub enum I2SEvent {
 
 /// A DMA transfer
 pub struct Transfer<B> {
+    // FIXME: Always `Some`, only using `Option` here to allow moving fields out of `inner`.
     inner: Option<Inner<B>>,
 }
 
@@ -635,6 +636,7 @@ impl<B> Drop for Transfer<B> {
 }
 /// A full duplex DMA transfer
 pub struct TransferFullDuplex<TxB, RxB> {
+    // FIXME: Always `Some`, only using `Option` here to allow moving fields out of `inner`.
     inner: Option<InnerFullDuplex<TxB, RxB>>,
 }
 

nrf-hal-common/src/ppi/mod.rs

@@ -82,7 +82,7 @@ pub trait Ppi {
 }
 
 /// Traits that extends the [Ppi](trait.Ppi.html) trait, marking a channel as fully configurable.
-pub trait ConfigurablePpi {
+pub trait ConfigurablePpi: Ppi {
     /// Sets the task that must be triggered when the configured event occurs. The user must provide
     /// a reference to the task.
     fn set_task_endpoint<T: Task>(&mut self, task: &T);