launchy 0.4.1

Low-level bindings and high-level abstractions for the Novation Launchpad MIDI devices
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

/// Used for the Device Inquiry message
pub enum DeviceIdQuery {
    /// Send the Device Inquiry request to a specific device id
    Specific(u8),
    /// Send the Device Inquiry request to all devices
    Any,
}

#[derive(Debug, Eq, PartialEq, Hash, Clone)]
pub struct DeviceInquiry {
    pub device_id: u8,
    pub family_code: u16,
    pub family_member_code: u16,
    pub firmware_revision: u32,
}

#[derive(Debug, Eq, PartialEq, Hash, Clone)]
pub struct VersionInquiry {
    pub bootloader_version: u32,
    pub firmware_version: u32,
    pub bootloader_size: u16,
}

pub(crate) fn request_device_inquiry<T>(
    output: &mut T,
    query: DeviceIdQuery,
) -> Result<(), crate::MidiError>
where
    T: crate::OutputDevice,
{
    const QUERY_DEVICE_ID_FOR_ANY: u8 = 127;

    let query_device_id = match query {
        DeviceIdQuery::Specific(device_id) => {
            assert_ne!(device_id, QUERY_DEVICE_ID_FOR_ANY);
            device_id
        }
        DeviceIdQuery::Any => QUERY_DEVICE_ID_FOR_ANY,
    };

    output.send(&[240, 126, query_device_id, 6, 1, 247])
}

pub(crate) fn request_version_inquiry<T>(output: &mut T) -> Result<(), crate::MidiError>
where
    T: crate::OutputDevice,
{
    output.send(&[240, 0, 32, 41, 0, 112, 247])
}

pub(crate) fn parse_device_query(data: &[u8]) -> Option<DeviceInquiry> {
    if let [240, 126, device_id, 6, 2, 0, 32, 41, fc1, fc2, fmc1, fmc2, fr1, fr2, fr3, fr4, 247] =
        *data
    {
        let family_code = u16::from_be_bytes([fc1, fc2]);
        let family_member_code = u16::from_be_bytes([fmc1, fmc2]);

        let firmware_revision = fr1 as u32 * 1000 + fr2 as u32 * 100 + fr3 as u32 * 10 + fr4 as u32;

        Some(DeviceInquiry {
            device_id,
            family_code,
            family_member_code,
            firmware_revision,
        })
    } else {
        None
    }
}

pub(crate) fn parse_version_query(data: &[u8]) -> Option<VersionInquiry> {
    if let [240, 0, 32, 41, 0, 112, bl1, bl2, bl3, bl4, bl5, fw1, fw2, fw3, fw4, fw5, bs1, bs2, 247] =
        *data
    {
        let bootloader_version = bl1 as u32 * 10000
            + bl2 as u32 * 1000
            + bl3 as u32 * 100
            + bl4 as u32 * 10
            + bl5 as u32;

        let firmware_version = fw1 as u32 * 10000
            + fw2 as u32 * 1000
            + fw3 as u32 * 100
            + fw4 as u32 * 10
            + fw5 as u32;

        let bootloader_size = u16::from_be_bytes([bs1, bs2]);

        Some(VersionInquiry {
            bootloader_version,
            firmware_version,
            bootloader_size,
        })
    } else {
        None
    }
}