alarmo 0.0.5

Provides a convenient API to bootstrap firmware and access peripherals on the Nintendo Alarmo
Documentation 
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use core::cell::RefCell;
use cortex_m::interrupt::{CriticalSection, Mutex};
use cortex_m::peripheral::NVIC;
use stm32h7xx_hal::gpio::{Edge, ExtiPin, Input, Pin};
use stm32h7xx_hal::interrupt;
use stm32h7xx_hal::pac::{EXTI, SYSCFG};

pub struct Buttons {
    pin_mail: Pin<'G', 5, Input>,
    pin_back: Pin<'G', 6, Input>,
    pin_dial: Pin<'C', 5, Input>,
}

#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum Button {
    Mail,
    Back,
    DialClick,
}

/// Defines which button to enable when using interrupt-based input.
///
/// With interrupt-based input, it is not possible to enable both the mail and dial click buttons.
/// Interrupts are registered via EXTI, which only allows one GPIO port per line. Because the
/// mail and dial click buttons share the same line (no. 5), they are mutually exclusive.
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum InterruptMode {
    Mail,
    Dial,
}

pub struct ExtInterrupts {
    pub(crate) syscfg: SYSCFG,
    pub(crate) exti: EXTI,
    pub(crate) nvic: NVIC,
}

static BUTTONS: Mutex<RefCell<Option<(Buttons, fn(Button, &CriticalSection))>>> =
    Mutex::new(RefCell::new(None));

impl Buttons {
    pub(crate) fn split(pg5: Pin<'G', 5>, pg6: Pin<'G', 6>, pc5: Pin<'C', 5>) -> Self {
        Self {
            pin_mail: pg5.into_pull_up_input(),
            pin_back: pg6.into_pull_up_input(),
            pin_dial: pc5.into_pull_up_input(),
        }
    }

    pub fn mail(&self) -> bool {
        self.pin_mail.is_low()
    }

    pub fn back(&self) -> bool {
        self.pin_back.is_low()
    }

    pub fn dial_click(&self) -> bool {
        self.pin_dial.is_low()
    }

    pub fn button(&self, button: Button) -> bool {
        match button {
            Button::Mail => self.mail(),
            Button::Back => self.back(),
            Button::DialClick => self.dial_click(),
        }
    }

    /// Consumes the buttons and registers interrupts to listen for button presses.
    ///
    /// **Note**: not all buttons can be enabled in interrupt mode. See the docs for
    /// [`InterruptMode`] for details.
    ///
    /// The `press_handler` function will be invoked when a button is pressed. The invocation
    /// takes place in a critical section, which can be used to lock [`Mutex`]es from the
    /// [`cortex_m`] crate.
    ///
    /// [`Mutex`]: cortex_m::interrupt::Mutex
    pub fn into_interrupts(
        mut self,
        cfg: &mut ExtInterrupts,
        mode: InterruptMode,
        press_handler: fn(Button, &CriticalSection),
    ) {
        // See note for InterruptMode
        if mode == InterruptMode::Mail {
            self.pin_mail.make_interrupt_source(&mut cfg.syscfg);
            self.pin_mail.trigger_on_edge(&mut cfg.exti, Edge::Falling);
            self.pin_mail.enable_interrupt(&mut cfg.exti);
        }

        if mode == InterruptMode::Dial {
            self.pin_dial.make_interrupt_source(&mut cfg.syscfg);
            self.pin_dial.trigger_on_edge(&mut cfg.exti, Edge::Falling);
            self.pin_dial.enable_interrupt(&mut cfg.exti);
        }

        self.pin_back.make_interrupt_source(&mut cfg.syscfg);
        self.pin_back.trigger_on_edge(&mut cfg.exti, Edge::Falling);
        self.pin_back.enable_interrupt(&mut cfg.exti);

        cortex_m::interrupt::free(|cs| {
            BUTTONS.borrow(cs).replace(Some((self, press_handler)));
        });

        unsafe {
            cfg.nvic.set_priority(interrupt::EXTI9_5, 1);
            NVIC::unmask(interrupt::EXTI9_5);
        }
    }
}

#[interrupt]
fn EXTI9_5() {
    cortex_m::interrupt::free(|cs| {
        let mut st_ref = BUTTONS.borrow(cs).borrow_mut();
        let Some((buttons, handler)) = st_ref.as_mut() else {
            return;
        };
        if buttons.mail() {
            buttons.pin_mail.clear_interrupt_pending_bit();
            handler(Button::Mail, cs);
        }
        if buttons.back() {
            buttons.pin_back.clear_interrupt_pending_bit();
            handler(Button::Back, cs);
        }
        if buttons.dial_click() {
            buttons.pin_dial.clear_interrupt_pending_bit();
            handler(Button::DialClick, cs);
        }
    })
}