1 files changed, 20 insertions, 41 deletions

diff --git a/examples/src/bin/rtc_async.rs b/examples/src/bin/rtc_async.rs
index 977621d4c..3bffabf0f 100644
--- a/examples/src/bin/rtc_async.rs
+++ b/examples/src/bin/rtc_async.rs
@@ -8,39 +8,30 @@ use example_common::*;
 
 use core::mem::MaybeUninit;
 use cortex_m_rt::entry;
-use embassy::clock::Monotonic;
+use embassy::executor::{task, Executor, WfeModel};
+use embassy::time::{Duration, Instant, Timer};
+use embassy_nrf::pac;
 use embassy_nrf::rtc;
-use futures_intrusive::timer::{Clock, LocalTimer, LocalTimerService};
 use nrf52840_hal::clocks;
-use static_executor::{task, Executor};
-
-struct RtcClock<T>(rtc::RTC<T>);
-
-impl<T: rtc::Instance> Clock for RtcClock<T> {
-    fn now(&self) -> u64 {
-        self.0.now()
-    }
-}
 
 #[task]
-async fn run1(rtc: &'static rtc::RTC<embassy_nrf::pac::RTC1>, timer: &'static LocalTimerService) {
+async fn run1() {
     loop {
-        info!("tick 1");
-        timer.deadline(rtc.now() + 64000).await;
+        info!("BIG INFREQUENT TICK");
+        Timer::after(Duration::from_ticks(64000)).await;
     }
 }
 
 #[task]
-async fn run2(rtc: &'static rtc::RTC<embassy_nrf::pac::RTC1>, timer: &'static LocalTimerService) {
+async fn run2() {
     loop {
-        info!("tick 2");
-        timer.deadline(rtc.now() + 23000).await;
+        info!("tick");
+        Timer::after(Duration::from_ticks(13000)).await;
     }
 }
 
-static EXECUTOR: Executor = Executor::new(cortex_m::asm::sev);
-static mut RTC: MaybeUninit<RtcClock<embassy_nrf::pac::RTC1>> = MaybeUninit::uninit();
-static mut TIMER: MaybeUninit<LocalTimerService> = MaybeUninit::uninit();
+static mut RTC: MaybeUninit<rtc::RTC<pac::RTC1>> = MaybeUninit::uninit();
+static mut EXECUTOR: MaybeUninit<Executor<WfeModel, rtc::Alarm<pac::RTC1>>> = MaybeUninit::uninit();
 
 #[entry]
 fn main() -> ! {
@@ -55,35 +46,23 @@ fn main() -> ! {
 
     let rtc: &'static _ = unsafe {
         let ptr = RTC.as_mut_ptr();
-        ptr.write(RtcClock(rtc::RTC::new(p.RTC1)));
+        ptr.write(rtc::RTC::new(p.RTC1));
         &*ptr
     };
 
-    rtc.0.start();
+    rtc.start();
+    unsafe { embassy::time::set_clock(|| RTC.as_ptr().as_ref().unwrap().now()) };
 
-    let timer: &'static _ = unsafe {
-        let ptr = TIMER.as_mut_ptr();
-        ptr.write(LocalTimerService::new(rtc));
+    let executor: &'static _ = unsafe {
+        let ptr = EXECUTOR.as_mut_ptr();
+        ptr.write(Executor::new(rtc.alarm0()));
         &*ptr
     };
 
     unsafe {
-        EXECUTOR.spawn(run1(&rtc.0, timer)).dewrap();
-        EXECUTOR.spawn(run2(&rtc.0, timer)).dewrap();
-
-        loop {
-            timer.check_expirations();
-
-            EXECUTOR.run();
-
-            match timer.next_expiration() {
-                // If this is in the past, set_alarm will immediately trigger the alarm,
-                // which will make the wfe immediately return so we do another loop iteration.
-                Some(at) => rtc.0.set_alarm(at, cortex_m::asm::sev),
-                None => rtc.0.clear_alarm(),
-            }
+        executor.spawn(run1()).dewrap();
+        executor.spawn(run2()).dewrap();
 
-            cortex_m::asm::wfe();
-        }
+        executor.run()
     }
 }