Add example with interrupt and PPI usage with onboard buttons and led for nRF52840-DK

Author: Henrik Alsér

Cargo.toml

@@ -16,6 +16,7 @@ members = [
   "examples/ecb-demo",
   "examples/ccm-demo",
   "examples/ppi-demo",
+  "examples/gpiote-demo",
 ]
 
 [profile.dev]

examples/gpiote-demo/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "gpiote-demo"
+version = "0.1.0"
+authors = ["Henrik Alsér"]
+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-rtic = "0.5.3"
+rtt-target = {version = "0.2.0", features = ["cortex-m"] }
+nrf52840-hal = { version = "0.10", features = ["rt"], path = "../../nrf52840-hal" }
+
+[dependencies.embedded-hal]
+version = "0.2.3"
+features = ["unproven"]

examples/gpiote-demo/Embed.toml

@@ -0,0 +1,46 @@
+[probe]
+# The index of the probe in the connected probe list.
+# probe_index = 0
+# The protocol to be used for communicating with the target.
+protocol = "Swd"
+# The speed in kHz of the data link to the target.
+# speed = 1337
+
+[flashing]
+# Whether or not the target should be flashed.
+enabled = true
+# Whether or not the target should be halted after flashing.
+halt_afterwards = false
+# Whether or not bytes erased but not rewritten with data from the ELF
+# should be restored with their contents before erasing.
+restore_unwritten_bytes = false
+# The path where an SVG of the assembled flash layout should be written to.
+# flash_layout_output_path = "out.svg"
+
+[general]
+# The chip name of the chip to be debugged.
+chip = "nRF52840"
+# A list of chip descriptions to be loaded during runtime.
+chip_descriptions = []
+# The default log level to be used.
+log_level = "Warn"
+
+[rtt]
+# Whether or not an RTTUI should be opened after flashing.
+# This is exclusive and cannot be used with GDB at the moment.
+enabled = true
+# A list of channel associations to be displayed. If left empty, all channels are displayed.
+channels = [
+    # { up = 0, down = 0, name = "name" }
+]
+# The duration in ms for which the logger should retry to attach to RTT.
+timeout = 3000
+# Whether timestamps in the RTTUI are enabled
+show_timestamps = true
+
+[gdb]
+# Whether or not a GDB server should be opened after flashing.
+# This is exclusive and cannot be used with RTT at the moment.
+enabled = false
+# The connection string in host:port format wher the GDB server will open a socket.
+# gdb_connection_string

examples/gpiote-demo/src/main.rs

@@ -0,0 +1,120 @@
+#![no_std]
+#![no_main]
+
+use embedded_hal::digital::v2::InputPin;
+use {
+    core::{
+        panic::PanicInfo,
+        sync::atomic::{compiler_fence, Ordering},
+    },
+    hal::{
+        gpio::{Input, Level, Pin, PullUp},
+        gpiote::*,
+        ppi::{self, ConfigurablePpi, Ppi},
+    },
+    nrf52840_hal as hal,
+    rtic::cyccnt::U32Ext,
+    rtt_target::{rprintln, rtt_init_print},
+};
+
+#[rtic::app(device = crate::hal::pac, peripherals = true, monotonic = rtic::cyccnt::CYCCNT)]
+const APP: () = {
+    struct Resources {
+        gpiote: Gpiote,
+        btn1: Pin<Input<PullUp>>,
+        btn2: Pin<Input<PullUp>>,
+        btn3: Pin<Input<PullUp>>,
+        btn4: Pin<Input<PullUp>>,
+    }
+
+    #[init]
+    fn init(mut ctx: init::Context) -> init::LateResources {
+        let _clocks = hal::clocks::Clocks::new(ctx.device.CLOCK).enable_ext_hfosc();
+        rtt_init_print!();
+        let p0 = hal::gpio::p0::Parts::new(ctx.device.P0);
+        let btn1 = p0.p0_11.into_pullup_input().degrade();
+        let btn2 = p0.p0_12.into_pullup_input().degrade();
+        let btn3 = p0.p0_24.into_pullup_input().degrade();
+        let btn4 = p0.p0_25.into_pullup_input().degrade();
+        let led1 = p0.p0_13.into_push_pull_output(Level::High).degrade();
+
+        let gpiote = Gpiote::new(ctx.device.GPIOTE);
+
+        // Set btn1 to generate event on channel 0 and enable interrupt
+        gpiote.channel(0).input_pin(&btn1).hi_to_lo(true);
+
+        // Set both btn3 & btn4 to generate port event
+        gpiote.port().input_pin(&btn3).low();
+        gpiote.port().input_pin(&btn4).low();
+        // Enable interrupt for port event
+        gpiote.port().enable_interrupt();
+
+        // PPI usage, channel 2 event triggers "task out" (toggle) on channel 1 (toggles led1)
+        gpiote.channel(1).output_pin(&led1).task_out_polarity(TaskOutPolarity::Toggle).init_high();
+        gpiote.channel(2).input_pin(&btn2).hi_to_lo(false);
+        let ppi_channels = ppi::Parts::new(ctx.device.PPI);
+        let mut channel0 = ppi_channels.ppi0;
+        channel0.set_task_endpoint(gpiote.channel(1).task_out());
+        channel0.set_event_endpoint(gpiote.channel(2).event());
+        channel0.enable();
+
+        // Enable the monotonic timer (CYCCNT)
+        ctx.core.DCB.enable_trace();
+        ctx.core.DWT.enable_cycle_counter();
+
+        rprintln!("Press a button");
+
+        init::LateResources {
+            gpiote,
+            btn1,
+            btn2,
+            btn3,
+            btn4,
+        }
+    }
+
+    #[idle]
+    fn idle(_: idle::Context) -> ! {
+        loop {
+            cortex_m::asm::wfi();
+        }
+    }
+
+    #[task(binds = GPIOTE, resources = [gpiote], schedule = [debounce])]
+    fn on_gpiote(ctx: on_gpiote::Context) {
+        // Reset all events
+        ctx.resources.gpiote.reset_events();
+        // Debounce
+        ctx.schedule.debounce(ctx.start + 3_000_000.cycles()).ok();
+    }
+
+    #[task(resources = [gpiote, btn1, btn2, btn3, btn4])]
+    fn debounce(ctx: debounce::Context) {
+        let btn1_pressed = ctx.resources.btn1.is_low().unwrap();
+        let btn2_pressed = ctx.resources.btn2.is_low().unwrap();
+        let btn3_pressed = ctx.resources.btn3.is_low().unwrap();
+        let btn4_pressed = ctx.resources.btn4.is_low().unwrap();
+
+        if btn1_pressed {
+            rprintln!("Button 1 was pressed!");
+            // Manually run "task out" (toggle) on channel 1 (toggles led1)
+            ctx.resources.gpiote.channel(1).out();
+        }
+        if btn3_pressed { rprintln!("Button 3 was pressed!"); }
+        if btn4_pressed { rprintln!("Button 4 was pressed!"); }
+    }
+
+    extern "C" {
+        fn SWI0_EGU0();
+    }
+};
+
+#[inline(never)]
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    cortex_m::interrupt::disable();
+    rprintln!("{}", info);
+    loop {
+        compiler_fence(Ordering::SeqCst);
+    }
+}

nrf-hal-common/src/gpiote.rs

@@ -157,35 +157,27 @@ impl<'a, P: GpioteInputPin> GpioteChannelEvent<'_, P> {
         config_channel_event_pin(self.gpiote, self.channel, self.pin, EventPolarity::HiToLo);
         if enable_interrupt {
             self.enable_interrupt();
-        } else {
-            self.disable_interrupt();
         }
     }
 
     pub fn lo_to_hi(&self, enable_interrupt: bool) {
         config_channel_event_pin(self.gpiote, self.channel, self.pin, EventPolarity::LoToHi);
         if enable_interrupt {
             self.enable_interrupt();
-        } else {
-            self.disable_interrupt();
         }
     }
 
     pub fn toggle(&self, enable_interrupt: bool) {
         config_channel_event_pin(self.gpiote, self.channel, self.pin, EventPolarity::Toggle);
         if enable_interrupt {
             self.enable_interrupt();
-        } else {
-            self.disable_interrupt();
         }
     }
 
     pub fn none(&self, enable_interrupt: bool) {
         config_channel_event_pin(self.gpiote, self.channel, self.pin, EventPolarity::None);
         if enable_interrupt {
             self.enable_interrupt();
-        } else {
-            self.disable_interrupt();
         }
     }
 
@@ -197,15 +189,6 @@ impl<'a, P: GpioteInputPin> GpioteChannelEvent<'_, P> {
                 .modify(|r, w| w.bits(r.bits() | self.pin.pin() as u32))
         }
     }
-
-    pub fn disable_interrupt(&self) {
-        // Disable interrupt for pin
-        unsafe {
-            self.gpiote
-                .intenclr
-                .modify(|r, w| w.bits(r.bits() | self.pin.pin() as u32))
-        }
-    }
 }
 
 fn config_channel_event_pin<P: GpioteInputPin>(