rmk 0.8.2

Keyboard firmware written in Rust
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

//! Controller module for RMK
//!
//! This module defines the `Controller` trait and its variations for different modes of execution.

pub mod battery_led;
pub mod led_indicator;
pub(crate) mod wpm;

use embassy_futures::select::{Either, select};

/// This trait provides the interface for individual output device controllers.
pub trait Controller {
    /// Type of the received events
    type Event;

    /// Process the received event
    async fn process_event(&mut self, event: Self::Event);

    /// Block waiting for next message
    async fn next_message(&mut self) -> Self::Event;
}

/// The trait for event-driven controllers.
///
/// This trait defines the interface for event-driven controllers in RMK.
///
/// # Example
/// ```rust
/// // Define a controller
/// struct MyController;
///
/// impl Controller for MyController {
///     async fn process_event(&mut self, event: Self::Event) {
///         // handle event
///     }
/// }
///
/// // Use the controller
/// let c = MyController;
///
/// // Run device simultaneously with RMK
/// embassy_futures::join::join(
///     c.event_loop(),
///     run_rmk(
///         // ...
///     ),
/// )
/// .await;
/// ```
pub trait EventController: Controller {
    /// Event loop
    async fn event_loop(&mut self) {
        loop {
            let event = self.next_message().await;
            self.process_event(event).await;
        }
    }
}

// Auto impl `EventController` trait for all `Controller`
impl<T: Controller> EventController for T {}

/// The trait for polling controllers.
///
/// This trait defines the interface for polling controllers in RMK.
///
/// # Example
/// ```rust
/// // Define a controller
/// struct MyController;
///
/// impl Controller for MyController {
///     async fn process_event(&mut self, event: Self::Event) {
///         // handle event
///     }
/// }
///
/// impl PollingController for MyController {
///     type INTERVAL: embassy_time::Duration = embassy_time::Duration::from_hz(30);
///
///     async fn update(&mut self) {
///         // update periodic
///     }
/// }
///
/// // Use the controller
/// let c = MyController;
///
/// // Run device simultaneously with RMK
/// embassy_futures::join::join(
///     c.polling_loop(),
///     run_rmk(
///         // ...
///     ),
/// )
/// .await;
/// ```
pub trait PollingController: Controller {
    /// Interval between `update` calls
    const INTERVAL: embassy_time::Duration;

    /// Update periodically, will be called according to [`Self::INTERVAL`]
    async fn update(&mut self);

    /// Polling loop
    async fn polling_loop(&mut self) {
        let mut last = embassy_time::Instant::now();

        loop {
            let elapsed = last.elapsed();

            match select(
                embassy_time::Timer::after(
                    Self::INTERVAL
                        .checked_sub(elapsed)
                        .unwrap_or(embassy_time::Duration::MIN),
                ),
                self.next_message(),
            )
            .await
            {
                Either::First(_) => {
                    self.update().await;
                    last = embassy_time::Instant::now();
                }
                Either::Second(event) => self.process_event(event).await,
            }
        }
    }
}