py32f030_hal 0.1.0

Peripheral Hal Crate for Puya's PY32F030 microcontroller
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use super::*;
use crate::mcu::peripherals::RTC;
use crate::pac::interrupt;
use core::{future::Future, marker::PhantomData, task::Poll};
use embassy_sync::waitqueue::AtomicWaker;

static WAKER: [AtomicWaker; 1] = [AtomicWaker::new()];

pub struct WakeFuture<T: Instance> {
    _t: PhantomData<T>,
    event: EnumSet<EventKind>,
}

impl<T: Instance> WakeFuture<T> {
    pub fn new(event: EnumSet<EventKind>) -> Self {
        Self {
            _t: PhantomData,
            event,
        }
    }

    #[inline]
    fn on_interrupt() {
        EnumSet::all().iter().for_each(|event| {
            if T::event_flag(event) && T::is_enable_interrupt(event) {
                T::event_config(event, false);
            }
        });
        WAKER[T::id() as usize].wake()
    }
}

impl<T: Instance> Future for WakeFuture<T> {
    type Output = ();
    fn poll(
        self: core::pin::Pin<&mut Self>,
        cx: &mut core::task::Context<'_>,
    ) -> core::task::Poll<Self::Output> {
        WAKER[T::id() as usize].register(cx.waker());

        let mut interrupt = false;

        self.event.iter().for_each(|event| {
            if T::event_flag(event) {
                interrupt = true;
                T::clear_interrupt(event);
            }
        });

        if interrupt {
            T::disable_config();
            Poll::Ready(())
        } else {
            Poll::Pending
        }
    }
}

impl<T: Instance> Drop for WakeFuture<T> {
    fn drop(&mut self) {}
}

#[interrupt]
fn RTC() {
    critical_section::with(|_cs| WakeFuture::<RTC>::on_interrupt())
}