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

use embedded_hal::digital::StatefulOutputPin;

use crate::channel::{CONTROLLER_CHANNEL, ControllerSub};
use crate::controller::{Controller, PollingController};
use crate::driver::gpio::OutputController;
use crate::event::ControllerEvent;

/// Battery state
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum BatteryState {
    Low,
    Normal,
    Charging,
}

pub struct BatteryLedController<P: StatefulOutputPin> {
    pin: OutputController<P>,
    sub: ControllerSub,
    state: BatteryState,
}

impl<P: StatefulOutputPin> BatteryLedController<P> {
    pub fn new(pin: P, low_active: bool) -> Self {
        Self {
            pin: OutputController::new(pin, low_active),
            sub: unwrap!(CONTROLLER_CHANNEL.subscriber()),
            state: BatteryState::Normal,
        }
    }
}

impl<P: StatefulOutputPin> Controller for BatteryLedController<P> {
    type Event = ControllerEvent;

    async fn process_event(&mut self, event: Self::Event) {
        match event {
            ControllerEvent::Battery(level) => {
                if self.state != BatteryState::Charging {
                    if level < 10 {
                        self.state = BatteryState::Low;
                    } else {
                        self.state = BatteryState::Normal;
                    }
                }
            }
            ControllerEvent::ChargingState(charging) => {
                if charging {
                    self.state = BatteryState::Charging;
                } else {
                    self.state = BatteryState::Normal;
                }
            }
            _ => (),
        }
    }

    async fn next_message(&mut self) -> Self::Event {
        self.sub.next_message_pure().await
    }
}

impl<P: StatefulOutputPin> PollingController for BatteryLedController<P> {
    const INTERVAL: embassy_time::Duration = embassy_time::Duration::from_secs(1);

    async fn update(&mut self) {
        match self.state {
            BatteryState::Low => self.pin.toggle(),
            BatteryState::Normal => self.pin.deactivate(),
            BatteryState::Charging => self.pin.activate(),
        }
    }
}