rmk 0.1.3

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

#![doc = include_str!("../README.md")]
#![allow(dead_code)]
// Make rust analyzer happy with num-enum crate
#![allow(non_snake_case, non_upper_case_globals)]
// Enable std in test
#![cfg_attr(not(test), no_std)]

use core::{cell::RefCell, convert::Infallible};
use embassy_futures::join::join;
use embassy_time::Timer;
use embassy_usb::driver::Driver;
use embedded_hal::digital::{InputPin, OutputPin};
use embedded_storage::nor_flash::NorFlash;
use keyboard::Keyboard;
use keymap::KeyMap;
use usb::KeyboardUsbDevice;
use via::process::VialService;

pub mod action;
mod debounce;
mod eeprom;
mod flash;
mod keyboard;
pub mod keycode;
pub mod keymap;
mod layout_macro;
mod matrix;
mod usb;
mod via;

/// DEPRECIATED: Use `initialize_keyboard_and_run` instead.
/// Initialize keyboard core and keyboard usb device
pub(crate) fn initialize_keyboard_and_usb_device<
    D: Driver<'static>,
    In: InputPin<Error = Infallible>,
    Out: OutputPin<Error = Infallible>,
    F: NorFlash,
    const EEPROM_SIZE: usize,
    const ROW: usize,
    const COL: usize,
    const NUM_LAYER: usize,
>(
    driver: D,
    input_pins: [In; ROW],
    output_pins: [Out; COL],
    keymap: &'static RefCell<KeyMap<F, EEPROM_SIZE, ROW, COL, NUM_LAYER>>,
    vial_keyboard_Id: &'static [u8],
    vial_keyboard_def: &'static [u8],
) -> (
    Keyboard<'static, In, Out, F, EEPROM_SIZE, ROW, COL, NUM_LAYER>,
    KeyboardUsbDevice<'static, D>,
    VialService<'static, F, EEPROM_SIZE, ROW, COL, NUM_LAYER>,
) {
    (
        Keyboard::new(input_pins, output_pins, keymap),
        KeyboardUsbDevice::new(driver),
        VialService::new(keymap, vial_keyboard_Id, vial_keyboard_def),
    )
}

/// Initialize and run the keyboard service, this function never returns.
pub async fn initialize_keyboard_and_run<
    D: Driver<'static>,
    In: InputPin<Error = Infallible>,
    Out: OutputPin<Error = Infallible>,
    F: NorFlash,
    const EEPROM_SIZE: usize,
    const ROW: usize,
    const COL: usize,
    const NUM_LAYER: usize,
>(
    driver: D,
    input_pins: [In; ROW],
    output_pins: [Out; COL],
    keymap: &'static RefCell<KeyMap<F, EEPROM_SIZE, ROW, COL, NUM_LAYER>>,
    vial_keyboard_Id: &'static [u8],
    vial_keyboard_def: &'static [u8],
) -> ! {
    let (mut keyboard, mut usb_device, vial_service) = (
        Keyboard::new(input_pins, output_pins, keymap),
        KeyboardUsbDevice::new(driver),
        VialService::new(keymap, vial_keyboard_Id, vial_keyboard_def),
    );

    let usb_fut = usb_device.device.run();
    let keyboard_fut = async {
        loop {
            let _ = keyboard.keyboard_task().await;
            keyboard.send_report(&mut usb_device.keyboard_hid).await;
            keyboard.send_media_report(&mut usb_device.other_hid).await;
        }
    };

    let via_fut = async {
        loop {
            vial_service
                .process_via_report(&mut usb_device.via_hid)
                .await;
            Timer::after_millis(1).await;
        }
    };
    join(usb_fut, join(keyboard_fut, via_fut)).await;

    panic!("Keyboard service is died")
}