keebrs 0.3.0

Keyboard firmware building blocks
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

use core::{
    pin::Pin,
    task::{
        Context,
        Poll,
    },
};

use super::*;

use embrio_core::io::{
    Cursor,
    Read,
    Write,
};

use futures::{
    prelude::*,
    task::noop_waker,
};

use crate::key::*;

fn block_on<F>(mut f: F) -> F::Output
where
    F: Future,
{
    unsafe {
        let mut pinned = Pin::new_unchecked(&mut f);
        loop {
            match pinned
                .as_mut()
                .poll(&mut Context::from_waker(&noop_waker()))
            {
                Poll::Ready(v) => return v,
                _ => continue,
            }
        }
    }
}

fn _is_write<W: Write>(_w: &W) {}
fn _is_read<R: Read>(_r: &R) {}
fn _is_mut_u8<W: AsMut<[u8]>>(_w: &W) {}

#[test]
fn key_chan() {
    use super::super::codec::PostCardCodec;
    let mut buf = vec![0u8; 64];

    _is_mut_u8(&buf);

    let writer = Cursor::new(&mut buf);

    _is_write(&writer);

    let mut sink = PostCardCodec::<Msg>::sink::<_, [u8; 32]>(writer);

    let keys = vec![
        Msg::KeyEvent(PhysKey {
            pos: KeyPos { x: 1, y: 2 },
            state: true.into(),
        }),
        Msg::KeyEvent(PhysKey {
            pos: KeyPos { x: 1, y: 2 },
            state: false.into(),
        }),
        Msg::KeyEvent(PhysKey {
            pos: KeyPos { x: 4, y: 0 },
            state: true.into(),
        }),
        Msg::KeyEvent(PhysKey {
            pos: KeyPos { x: 4, y: 0 },
            state: false.into(),
        }),
    ];

    for key in &keys {
        block_on(sink.send(key.clone())).unwrap();
    }

    drop(sink);

    let reader = &*buf;

    _is_read(&reader);

    let mut stream = PostCardCodec::<Msg>::stream::<_, [u8; 32]>(reader);

    let mut output = vec![];
    for _ in 0..keys.len() {
        output.push(block_on(stream.try_next()).unwrap().unwrap());
    }
    dbg!(&keys);
    dbg!(&output);
    assert_eq!(keys, output);
}

#[test]
fn test_postcard() {
    use crate::key::*;
    let mut buf = [0u8; 32];
    let key = PhysKey {
        pos: KeyPos { x: 2, y: 4 },
        state: true.into(),
    };

    let data = postcard::to_slice_cobs(&Msg::KeyEvent(key), &mut buf[..]).unwrap();

    dbg!(data);
}