m5unified 0.3.1

Safe Rust wrapper for M5Unified.
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

use core::ffi::c_int;

#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum ButtonId {
    A,
    B,
    C,
    Pwr,
    Ext,
}

#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum ButtonState {
    NoChange,
    Clicked,
    Hold,
    DecideClickCount,
    Raw(u8),
}

impl ButtonState {
    pub fn from_raw(raw: u8) -> Self {
        match raw {
            0 => Self::NoChange,
            1 => Self::Clicked,
            2 => Self::Hold,
            3 => Self::DecideClickCount,
            raw => Self::Raw(raw),
        }
    }

    pub fn raw(self) -> u8 {
        match self {
            Self::NoChange => 0,
            Self::Clicked => 1,
            Self::Hold => 2,
            Self::DecideClickCount => 3,
            Self::Raw(raw) => raw,
        }
    }
}

#[derive(Debug)]
pub struct Buttons;

impl Buttons {
    pub fn button(&self, id: ButtonId) -> Button {
        Button { id }
    }

    pub fn a(&self) -> Button {
        self.button(ButtonId::A)
    }

    pub fn b(&self) -> Button {
        self.button(ButtonId::B)
    }

    pub fn c(&self) -> Button {
        self.button(ButtonId::C)
    }

    pub fn pwr(&self) -> Button {
        self.button(ButtonId::Pwr)
    }

    pub fn ext(&self) -> Button {
        self.button(ButtonId::Ext)
    }

    pub fn a_is_pressed(&self) -> bool {
        self.a().is_pressed()
    }

    pub fn b_was_pressed(&self) -> bool {
        self.b().was_pressed()
    }
}

#[derive(Debug, Copy, Clone)]
pub struct Button {
    id: ButtonId,
}

impl Button {
    fn raw_id(&self) -> c_int {
        match self.id {
            ButtonId::A => 0,
            ButtonId::B => 1,
            ButtonId::C => 2,
            ButtonId::Pwr => 3,
            ButtonId::Ext => 4,
        }
    }

    pub fn is_pressed(&self) -> bool {
        unsafe { m5unified_sys::m5u_button_is_pressed(self.raw_id()) }
    }

    pub fn is_released(&self) -> bool {
        unsafe { m5unified_sys::m5u_button_is_released(self.raw_id()) }
    }

    pub fn was_pressed(&self) -> bool {
        unsafe { m5unified_sys::m5u_button_was_pressed(self.raw_id()) }
    }

    pub fn was_released(&self) -> bool {
        unsafe { m5unified_sys::m5u_button_was_released(self.raw_id()) }
    }

    pub fn was_released_after_hold(&self) -> bool {
        unsafe { m5unified_sys::m5u_button_was_released_after_hold(self.raw_id()) }
    }

    pub fn was_clicked(&self) -> bool {
        unsafe { m5unified_sys::m5u_button_was_clicked(self.raw_id()) }
    }

    pub fn was_single_clicked(&self) -> bool {
        unsafe { m5unified_sys::m5u_button_was_single_clicked(self.raw_id()) }
    }

    pub fn was_double_clicked(&self) -> bool {
        unsafe { m5unified_sys::m5u_button_was_double_clicked(self.raw_id()) }
    }

    pub fn was_hold(&self) -> bool {
        unsafe { m5unified_sys::m5u_button_was_hold(self.raw_id()) }
    }

    pub fn is_holding(&self) -> bool {
        unsafe { m5unified_sys::m5u_button_is_holding(self.raw_id()) }
    }

    pub fn was_change_pressed(&self) -> bool {
        unsafe { m5unified_sys::m5u_button_was_change_pressed(self.raw_id()) }
    }

    pub fn was_decide_click_count(&self) -> bool {
        unsafe { m5unified_sys::m5u_button_was_decide_click_count(self.raw_id()) }
    }

    pub fn click_count(&self) -> i32 {
        unsafe { m5unified_sys::m5u_button_get_click_count(self.raw_id()) as i32 }
    }

    pub fn was_release_for_ms(&self, ms: u32) -> bool {
        unsafe { m5unified_sys::m5u_button_was_release_for(self.raw_id(), ms) }
    }

    pub fn pressed_for_ms(&self, ms: u32) -> bool {
        unsafe { m5unified_sys::m5u_button_pressed_for(self.raw_id(), ms) }
    }

    pub fn released_for_ms(&self, ms: u32) -> bool {
        unsafe { m5unified_sys::m5u_button_released_for(self.raw_id(), ms) }
    }

    pub fn set_debounce_thresh_ms(&self, ms: u32) {
        unsafe { m5unified_sys::m5u_button_set_debounce_thresh(self.raw_id(), ms) }
    }

    pub fn set_hold_thresh_ms(&self, ms: u32) {
        unsafe { m5unified_sys::m5u_button_set_hold_thresh(self.raw_id(), ms) }
    }

    pub fn state(&self) -> ButtonState {
        unsafe { ButtonState::from_raw(m5unified_sys::m5u_button_get_state(self.raw_id())) }
    }

    pub fn last_change_ms(&self) -> u32 {
        unsafe { m5unified_sys::m5u_button_last_change(self.raw_id()) }
    }

    pub fn debounce_thresh_ms(&self) -> u32 {
        unsafe { m5unified_sys::m5u_button_get_debounce_thresh(self.raw_id()) }
    }

    pub fn hold_thresh_ms(&self) -> u32 {
        unsafe { m5unified_sys::m5u_button_get_hold_thresh(self.raw_id()) }
    }

    pub fn update_msec(&self) -> u32 {
        unsafe { m5unified_sys::m5u_button_get_update_msec(self.raw_id()) }
    }
}