New interrupt bindings

boards/feather_m0/.cargo/config

@@ -7,6 +7,7 @@ rustflags = [
   # See https://github.com/rust-embedded/cortex-m-quickstart/pull/95
   "-C", "link-arg=--nmagic",
   "-C", "link-arg=-Tlink.x",
+  "-C", "link-arg=-Tdefmt.x"
 ]
 
 [target.thumbv6m-none-eabi]

boards/feather_m0/Cargo.toml

@@ -37,7 +37,9 @@ version = "0.3"
 optional = true
 
 [dev-dependencies]
-cortex-m-rtic = "1.0"
+rtic = { version = "2.0.1", features = ["thumbv6-backend"] }
+rtic-monotonics = { version = "1.3.0", features = ["cortex-m-systick", "systick-10khz"] }
+fugit = "0.3.6"
 cortex-m = "0.7"
 usbd-serial = "0.1"
 cortex-m-semihosting = "0.3"
@@ -48,6 +50,9 @@ nom = { version = "5", default-features = false }
 heapless = "0.7"
 panic-halt = "0.2"
 panic-semihosting = "0.5"
+defmt = "0.3"
+defmt-rtt = "0.3"
+panic-probe = "0.3"
 
 [features]
 # ask the HAL to enable atsamd21g support
@@ -65,8 +70,8 @@ max-channels = ["dma", "atsamd-hal/max-channels"]
 # Enable pins for the adalogger SD card reader
 adalogger = []
 sdmmc = ["embedded-sdmmc", "atsamd-hal/sdmmc"]
-rtic = ["atsamd-hal/rtic"]
 use_semihosting = []
+nightly = []
 
 [profile.dev]
 incremental = false
@@ -135,7 +140,7 @@ required-features = ["adalogger", "usb", "sdmmc", "unproven"]
 
 [[example]]
 name = "blinky_rtic"
-required-features = ["rtic", "unproven"]
+required-features = ["unproven", "nightly"]
 
 [[example]]
 name = "uart"
@@ -144,3 +149,27 @@ required-features = ["dma"]
 [[example]]
 name = "i2c"
 required-features = ["dma"]
+
+[[example]]
+name = "async_dmac"
+required-features = ["dma", "atsamd-hal/async", "nightly"]
+
+[[example]]
+name = "async_timer"
+required-features = ["atsamd-hal/async", "nightly"]
+
+[[example]]
+name = "async_eic"
+required-features = ["atsamd-hal/async", "nightly"]
+
+[[example]]
+name = "async_i2c"
+required-features = ["dma", "atsamd-hal/async", "nightly"]
+
+[[example]]
+name = "async_spi"
+required-features = ["dma", "atsamd-hal/async", "nightly"]
+
+[[example]]
+name = "async_uart"
+required-features = ["dma", "atsamd-hal/async", "nightly"]

boards/feather_m0/examples/async_dmac.rs

@@ -0,0 +1,94 @@
+//! This example shows a safe API to
+//! execute a memory-to-memory DMA transfer
+
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt_rtt as _;
+use panic_probe as _;
+
+atsamd_hal::bind_interrupts!(struct Irqs {
+    DMAC => atsamd_hal::dmac::InterruptHandler;
+});
+
+#[rtic::app(device = bsp::pac, dispatchers = [I2S])]
+mod app {
+    use bsp::hal;
+    use feather_m0 as bsp;
+    use hal::{
+        clock::GenericClockController,
+        dmac::{
+            Ch0, Channel, DmaController, PriorityLevel, ReadyFuture, TriggerAction, TriggerSource,
+        },
+    };
+
+    #[shared]
+    struct Shared {}
+
+    #[local]
+    struct Local {
+        channel: Channel<Ch0, ReadyFuture>,
+    }
+
+    #[init]
+    fn init(cx: init::Context) -> (Shared, Local) {
+        let mut peripherals = cx.device;
+        let _core = cx.core;
+
+        let _clocks = GenericClockController::with_external_32kosc(
+            peripherals.GCLK,
+            &mut peripherals.PM,
+            &mut peripherals.SYSCTRL,
+            &mut peripherals.NVMCTRL,
+        );
+
+        // Initialize DMA Controller
+        let dmac = DmaController::init(peripherals.DMAC, &mut peripherals.PM);
+
+        // Turn dmac into an async controller
+        let mut dmac = dmac.into_future(crate::Irqs);
+        // Get individual handles to DMA channels
+        let channels = dmac.split();
+
+        // Initialize DMA Channel 0
+        let channel = channels.0.init(PriorityLevel::LVL0);
+
+        async_task::spawn().ok();
+        (Shared {}, Local { channel })
+    }
+
+    #[task(local = [channel])]
+    async fn async_task(cx: async_task::Context) {
+        let channel = cx.local.channel;
+
+        let mut source = [0xff; 500];
+        let mut dest = [0x0; 500];
+
+        defmt::info!(
+            "Launching a DMA transfer.\n\tSource: {}\n\tDestination: {}",
+            &source,
+            &dest
+        );
+
+        channel
+            .transfer_future(
+                &mut source,
+                &mut dest,
+                TriggerSource::DISABLE,
+                TriggerAction::BLOCK,
+            )
+            .await
+            .unwrap();
+
+        defmt::info!(
+            "Finished DMA transfer.\n\tSource: {}\n\tDestination: {}",
+            &source,
+            &dest
+        );
+
+        loop {
+            cortex_m::asm::wfi();
+        }
+    }
+}

boards/feather_m0/examples/async_eic.rs

@@ -0,0 +1,85 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt_rtt as _;
+use panic_probe as _;
+
+use bsp::{hal, pin_alias};
+use feather_m0 as bsp;
+use hal::{
+    clock::{enable_internal_32kosc, ClockGenId, ClockSource, GenericClockController},
+    ehal::digital::v2::ToggleableOutputPin,
+    eic::{
+        pin::{ExtInt2, Sense},
+        EIC,
+    },
+    gpio::{pin::PA18, Pin, PullUpInterrupt},
+    rtc::{Count32Mode, Rtc},
+};
+
+atsamd_hal::bind_interrupts!(struct Irqs {
+    EIC => atsamd_hal::eic::InterruptHandler;
+});
+
+#[rtic::app(device = bsp::pac, dispatchers = [I2S])]
+mod app {
+    use super::*;
+
+    #[shared]
+    struct Shared {}
+
+    #[local]
+    struct Local {
+        extint: ExtInt2<Pin<PA18, PullUpInterrupt>>,
+        red_led: bsp::RedLed,
+    }
+
+    #[init]
+    fn init(cx: init::Context) -> (Shared, Local) {
+        let mut peripherals = cx.device;
+        let _core = cx.core;
+
+        let mut clocks = GenericClockController::with_external_32kosc(
+            peripherals.GCLK,
+            &mut peripherals.PM,
+            &mut peripherals.SYSCTRL,
+            &mut peripherals.NVMCTRL,
+        );
+        let pins = bsp::Pins::new(peripherals.PORT);
+        let red_led: bsp::RedLed = pin_alias!(pins.red_led).into();
+
+        let internal_clock = clocks
+            .configure_gclk_divider_and_source(ClockGenId::GCLK2, 1, ClockSource::OSC32K, false)
+            .unwrap();
+        clocks.configure_standby(ClockGenId::GCLK2, true);
+
+        enable_internal_32kosc(&mut peripherals.SYSCTRL);
+
+        // Configure a clock for the EIC peripheral
+        let gclk2 = clocks.gclk2();
+        let eic_clock = clocks.eic(&gclk2).unwrap();
+
+        let mut eic = EIC::init(&mut peripherals.PM, eic_clock, peripherals.EIC).into_future(Irqs);
+        let button: Pin<_, PullUpInterrupt> = pins.d10.into();
+        let mut extint = ExtInt2::new(button, &mut eic);
+        extint.enable_interrupt_wake();
+
+        async_task::spawn().ok();
+
+        (Shared {}, Local { extint, red_led })
+    }
+
+    #[task(local = [extint, red_led])]
+    async fn async_task(cx: async_task::Context) {
+        let extint = cx.local.extint;
+        let red_led = cx.local.red_led;
+
+        loop {
+            // Here we show straight falling edge detection without
+            extint.wait(Sense::FALL).await;
+            defmt::info!("Falling edge detected");
+            red_led.toggle().unwrap();
+        }
+    }
+}

boards/feather_m0/examples/async_i2c.rs

@@ -0,0 +1,102 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt_rtt as _;
+use panic_probe as _;
+
+use bsp::hal;
+use feather_m0 as bsp;
+use fugit::MillisDuration;
+use hal::{
+    clock::GenericClockController,
+    dmac::{Ch0, DmaController, PriorityLevel},
+    prelude::*,
+    sercom::{
+        i2c::{self, Config, I2cFutureDma},
+        Sercom3,
+    },
+};
+use rtic_monotonics::systick::Systick;
+
+atsamd_hal::bind_interrupts!(struct Irqs {
+    SERCOM3 => atsamd_hal::sercom::i2c::InterruptHandler<Sercom3>;
+    DMAC => atsamd_hal::dmac::InterruptHandler;
+});
+
+#[rtic::app(device = bsp::pac, dispatchers = [I2S])]
+mod app {
+    use super::*;
+
+    #[shared]
+    struct Shared {}
+
+    #[local]
+    struct Local {
+        i2c: I2cFutureDma<Config<bsp::I2cPads>, Ch0>,
+    }
+
+    #[init]
+    fn init(cx: init::Context) -> (Shared, Local) {
+        let mut peripherals = cx.device;
+        let _core = cx.core;
+
+        let mut clocks = GenericClockController::with_external_32kosc(
+            peripherals.GCLK,
+            &mut peripherals.PM,
+            &mut peripherals.SYSCTRL,
+            &mut peripherals.NVMCTRL,
+        );
+
+        let pins = bsp::Pins::new(peripherals.PORT);
+
+        // Take SDA and SCL
+        let (sda, scl) = (pins.sda, pins.scl);
+
+        // Initialize DMA Controller
+        let dmac = DmaController::init(peripherals.DMAC, &mut peripherals.PM);
+
+        // Turn dmac into an async controller
+        let mut dmac = dmac.into_future(Irqs);
+        // Get individual handles to DMA channels
+        let channels = dmac.split();
+
+        // Initialize DMA Channel 0
+        let channel0 = channels.0.init(PriorityLevel::LVL0);
+
+        let gclk0 = clocks.gclk0();
+        let sercom3_clock = &clocks.sercom3_core(&gclk0).unwrap();
+        let pads = i2c::Pads::new(sda, scl);
+        let i2c = i2c::Config::new(
+            &peripherals.PM,
+            peripherals.SERCOM3,
+            pads,
+            sercom3_clock.freq(),
+        )
+        .baud(100.kHz())
+        .enable()
+        .into_future(Irqs)
+        .with_dma_channel(channel0);
+
+        async_task::spawn().ok();
+
+        (Shared {}, Local { i2c })
+    }
+
+    #[task(local = [i2c])]
+    async fn async_task(cx: async_task::Context) {
+        let i2c = cx.local.i2c;
+
+        loop {
+            defmt::info!("Sending 0x00 to I2C device...");
+            // This test is based on the BMP388 barometer. Feel free to use any I2C
+            // peripheral you have on hand.
+            i2c.write(0x76, &[0x00]).await.unwrap();
+
+            let mut buffer = [0xff; 4];
+            i2c.read(0x76, &mut buffer).await.unwrap();
+            defmt::info!("Read buffer: {:#x}", buffer);
+            Systick::delay(MillisDuration::<u32>::from_ticks(500).convert()).await;
+        }
+    }
+}