Try implementing async I2C (#6)

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

@@ -43,6 +43,7 @@ git = "https://github.com/datdenkikniet/cortex-m-interrupt.git"
 
 [dev-dependencies]
 cortex-m-rtic = "1.1.3"
+fugit = "0.3.6"
 cortex-m = "0.7"
 usbd-serial = "0.1"
 cortex-m-semihosting = "0.3"
@@ -53,6 +54,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
@@ -154,5 +158,9 @@ required-features = ["dma"]
 name = "async_timer"
 required-features = ["atsamd-hal/async", "atsamd-hal/rtic", "cortex-m-interrupt"]
 
+[[example]]
+name = "async_i2c"
+required-features = ["atsamd-hal/async", "atsamd-hal/rtic", "cortex-m-interrupt"]
+
 [patch.crates-io]
 cortex-m-rtic = { git = "https://github.com/rtic-rs/cortex-m-rtic.git", branch = "async-2022" }

boards/feather_m0/examples/async_i2c.rs

@@ -0,0 +1,95 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use panic_probe as _;
+use defmt_rtt as _;
+
+#[rtic::app(device = bsp::pac, dispatchers = [I2S])]
+mod app {
+    use bsp::{hal, pac, pin_alias};
+    use feather_m0 as bsp;
+    use hal::{
+        prelude::*,
+        clock::{enable_internal_32kosc, ClockGenId, ClockSource, GenericClockController},
+        ehal::digital::v2::ToggleableOutputPin,
+        rtc::{Count32Mode, Rtc},
+        sercom::i2c::{self,Config, I2cFuture},
+    };
+    use fugit::MillisDuration;
+
+    #[monotonic(binds = RTC, default = true)]
+    type Monotonic = Rtc<Count32Mode>;
+
+    #[shared]
+    struct Shared {}
+
+    #[local]
+    struct Local {
+        i2c: I2cFuture<Config<bsp::I2cPads>, bsp::pac::Interrupt>,
+        red_led: bsp::RedLed,
+    }
+
+    #[init]
+    fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
+        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();
+
+        // Take SDA and SCL
+        let (sda, scl) = (pins.sda, pins.scl);
+
+        let sercom3_irq = cortex_m_interrupt::take_nvic_interrupt!(pac::Interrupt::SERCOM3, 2);
+        // tc4_irq.set_priority(2);
+
+        enable_internal_32kosc(&mut peripherals.SYSCTRL);
+        let timer_clock = clocks
+            .configure_gclk_divider_and_source(ClockGenId::GCLK2, 1, ClockSource::OSC32K, false)
+            .unwrap();
+        clocks.configure_standby(ClockGenId::GCLK2, true);
+
+        // Setup RTC monotonic
+        let rtc_clock = clocks.rtc(&timer_clock).unwrap();
+        let rtc = Rtc::count32_mode(peripherals.RTC, rtc_clock.freq(), &mut peripherals.PM);
+
+        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_async(sercom3_irq);
+
+
+        async_task::spawn().ok();
+
+        (Shared {}, Local { i2c, red_led }, init::Monotonics(rtc))
+    }
+
+    #[task(local = [i2c, red_led])]
+    async fn async_task(cx: async_task::Context) {
+        let i2c = cx.local.i2c;
+        let red_led = cx.local.red_led;
+
+        loop {
+            defmt::info!("Sending 1 byte to I2C...");
+            // 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 = [0x00; 1];
+            defmt::info!("Reading 1 byte from I2C...");
+            i2c.read(0x76, &mut buffer).await.unwrap();
+            defmt::info!("Chip ID is: {:#x}", buffer[0]);
+            red_led.toggle().unwrap();
+            crate::app::monotonics::delay(MillisDuration::<u32>::from_ticks(500).convert()).await;
+        }
+    }
+}

boards/feather_m0/examples/async_timer.rs

@@ -63,7 +63,7 @@ mod app {
         // configure a clock for the TC4 and TC5 peripherals
         let tc45 = &clocks.tc4_tc5(&timer_clock).unwrap();
 
-        // instantiate a timer objec for the TC3 peripheral
+        // instantiate a timer object for the TC4 peripheral
         let timer = TimerCounter::tc4_(tc45, peripherals.TC4, &mut peripherals.PM);
         let timer = timer.into_async(tc4_irq);
         async_task::spawn().ok();

hal/Cargo.toml

@@ -93,8 +93,7 @@ atsame54n = {version = "0.13.0", path = "../pac/atsame54n", optional = true}
 atsame54p = {version = "0.13.0", path = "../pac/atsame54p", optional = true}
 
 [dependencies.embedded-hal-async]
-version = "0.1.0-alph"
-package = "embedded-hal"
+version = "0.1.0-alpha.2"
 optional = true
 
 [dependencies.critical-section]
@@ -105,12 +104,6 @@ optional = true
 version = "0.1"
 optional = true
 git = "https://github.com/embassy-rs/embassy.git"
-# path = "../../../rust-projects/embassy/embassy-sync"
-
-[dependencies.futures]
-version = "0.3.21"
-optional = true
-default-features = false
 
 [dependencies.cortex-m-interrupt]
 version = "0.1"
@@ -214,7 +207,6 @@ usb = ["usb-device"]
 use_rtt = ["jlink_rtt"]
 async = [
     "cortex-m-interrupt",
-    "futures",
     "critical-section",
     "unproven",
     "embassy-sync",

hal/src/async_hal/mod.rs

@@ -1,24 +1,24 @@
 //! Async APIs
 
-#[cfg(feature = "samd11")]
-#[path = "irqs_samd11.rs"]
-mod irqs;
+// #[cfg(feature = "samd11")]
+// #[path = "irqs_samd11.rs"]
+// mod irqs;
 
-#[cfg(feature = "samd21")]
-#[path = "irqs_samd21.rs"]
-mod irqs;
+// #[cfg(feature = "samd21")]
+// #[path = "irqs_samd21.rs"]
+// mod irqs;
 
-#[cfg(feature = "samd51")]
-#[path = "irqs_thumbv7em.rs"]
-mod irqs;
+// #[cfg(feature = "samd51")]
+// #[path = "irqs_thumbv7em.rs"]
+// mod irqs;
 
-pub mod interrupt {
-    pub use super::irqs::*;
-    pub use cortex_m::interrupt::{CriticalSection, Mutex};
-    pub use embassy::interrupt::{declare, take, Interrupt};
+// pub mod interrupt {
+//     pub use super::irqs::*;
+//     pub use cortex_m::interrupt::{CriticalSection, Mutex};
+//     pub use embassy::interrupt::{declare, take, Interrupt};
 
-    // TODO Priority2 seems to only be true for thumbv6m chips
-    pub use embassy_hal_common::interrupt::Priority2 as Priority;
-}
+//     // TODO Priority2 seems to only be true for thumbv6m chips
+//     pub use embassy_hal_common::interrupt::Priority2 as Priority;
+// }
 
 pub mod timer;

hal/src/async_hal/timer.rs

@@ -100,7 +100,7 @@ where
     #[inline]
     pub fn into_async<I, N>(mut self, irq: I) -> AsyncTimer<T, N>
     where
-        I: NvicInterruptHandle<InterruptNumber = N>,
+        I: NvicInterruptHandle<N>,
         N: InterruptNumber,
     {
         let irq_number = irq.number();

hal/src/sercom/i2c.rs

@@ -276,6 +276,12 @@ pub use config::*;
 
 mod impl_ehal;
 
+#[cfg(feature = "async")]
+mod async_api;
+
+#[cfg(feature = "async")]
+pub use async_api::*;
+
 /// Word size for an I2C message
 pub type Word = u8;