use core::fmt;
use crate::error::{Error, Result};
use crate::ids::{DeviceId, MANUFACTURER_ID, Model};
use crate::wire::{SYSEX_END, SYSEX_START};
pub const NON_REALTIME: u8 = 0x7E;
pub const GENERAL_INFORMATION: u8 = 0x06;
pub const IDENTITY_REQUEST: u8 = 0x01;
pub const IDENTITY_REPLY: u8 = 0x02;
pub const FAMILY: [u8; 2] = [0x20, 0x00];
pub const MEMBER: [u8; 2] = [0x01, 0x00];
pub const REQUEST_LEN: usize = 6;
pub const REPLY_LEN: usize = 17;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Version {
pub major: u8,
pub minor: u8,
}
impl Version {
#[must_use]
pub const fn from_packed(byte: u8) -> Self {
Self {
major: byte & 0x0F,
minor: byte >> 4,
}
}
#[must_use]
pub const fn at_least(self, major: u8, minor: u8) -> bool {
self.major > major || (self.major == major && self.minor >= minor)
}
#[must_use]
pub const fn is(self, major: u8, minor: u8) -> bool {
self.major == major && self.minor == minor
}
#[must_use]
pub const fn to_packed(self) -> u8 {
((self.minor & 0x07) << 4) | (self.major & 0x0F)
}
}
impl fmt::Display for Version {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}.{}", self.major, self.minor)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[non_exhaustive]
pub struct Identity {
pub device: DeviceId,
pub firmware: Version,
pub voice: Version,
}
pub fn request_into(device: DeviceId, out: &mut [u8]) -> Result<usize> {
let available = out.len();
let out = out.get_mut(..REQUEST_LEN).ok_or(Error::BufferTooSmall {
needed: REQUEST_LEN,
available,
})?;
let bytes = [
SYSEX_START,
NON_REALTIME,
device.to_byte(),
GENERAL_INFORMATION,
IDENTITY_REQUEST,
SYSEX_END,
];
for (slot, byte) in out.iter_mut().zip(bytes) {
*slot = byte;
}
Ok(REQUEST_LEN)
}
pub fn parse_request(bytes: &[u8]) -> Result<DeviceId> {
let (first, rest) = bytes.split_first().ok_or(Error::Unframed)?;
let (last, body) = rest.split_last().ok_or(Error::Unframed)?;
if *first != SYSEX_START || *last != SYSEX_END {
return Err(Error::Unframed);
}
let &[NON_REALTIME, device, GENERAL_INFORMATION, IDENTITY_REQUEST] = body else {
return Err(Error::NotAnInquiryRequest);
};
DeviceId::from_byte(device)
}
pub fn parse_reply(bytes: &[u8]) -> Result<Identity> {
let (first, rest) = bytes.split_first().ok_or(Error::Unframed)?;
let (last, body) = rest.split_last().ok_or(Error::Unframed)?;
if *first != SYSEX_START || *last != SYSEX_END {
return Err(Error::Unframed);
}
let &[
NON_REALTIME,
device,
GENERAL_INFORMATION,
IDENTITY_REPLY,
manufacturer_0,
manufacturer_1,
manufacturer_2,
family_0,
family_1,
member_0,
member_1,
firmware,
_reserved,
voice_major,
voice_minor,
] = body
else {
return Err(Error::NotAnInquiryResponse);
};
if [manufacturer_0, manufacturer_1, manufacturer_2] != MANUFACTURER_ID
|| [family_0, family_1] != FAMILY
|| [member_0, member_1] != MEMBER
{
return Err(Error::NotAnInquiryResponse);
}
Ok(Identity {
device: DeviceId::from_byte(device)?,
firmware: Version::from_packed(firmware),
voice: Version {
major: voice_major,
minor: voice_minor,
},
})
}
pub fn reply_into(identity: &Identity, out: &mut [u8]) -> Result<usize> {
let available = out.len();
let out = out.get_mut(..REPLY_LEN).ok_or(Error::BufferTooSmall {
needed: REPLY_LEN,
available,
})?;
let bytes = [
SYSEX_START,
NON_REALTIME,
identity.device.to_byte(),
GENERAL_INFORMATION,
IDENTITY_REPLY,
MANUFACTURER_ID[0],
MANUFACTURER_ID[1],
MANUFACTURER_ID[2],
FAMILY[0],
FAMILY[1],
MEMBER[0],
MEMBER[1],
identity.firmware.to_packed(),
0x00,
identity.voice.major,
identity.voice.minor,
SYSEX_END,
];
for (slot, byte) in out.iter_mut().zip(bytes) {
*slot = byte;
}
Ok(REPLY_LEN)
}
#[must_use]
pub const fn models() -> &'static [Model] {
Model::ALL
}
#[cfg(test)]
#[expect(
clippy::expect_used,
reason = "a failed expectation is the test failure"
)]
mod tests {
use super::*;
use crate::testing::assert_display;
fn identity() -> Identity {
Identity {
device: DeviceId::Unit(3),
firmware: Version { major: 1, minor: 1 },
voice: Version { major: 1, minor: 0 },
}
}
#[test]
fn a_request_round_trips() {
for device in [DeviceId::Unit(0), DeviceId::Unit(15), DeviceId::Broadcast] {
let mut bytes = [0u8; REQUEST_LEN];
let len = request_into(device, &mut bytes).expect("the buffer fits");
assert_eq!(len, REQUEST_LEN);
assert_eq!(parse_request(&bytes), Ok(device));
}
}
#[test]
fn a_reply_is_not_a_request() {
let mut bytes = [0u8; REPLY_LEN];
reply_into(&identity(), &mut bytes).expect("the buffer fits");
assert_eq!(parse_request(&bytes), Err(Error::NotAnInquiryRequest));
}
#[test]
fn a_deepmind_frame_is_not_a_request() {
let bytes = [0xF0, 0x00, 0x20, 0x32, 0x20, 0x00, 0x03, 0xF7];
assert_eq!(parse_request(&bytes), Err(Error::NotAnInquiryRequest));
}
#[test]
fn a_request_has_to_be_framed() {
assert_eq!(parse_request(&[]), Err(Error::Unframed));
assert_eq!(
parse_request(&[0xF0, 0x7E, 0x7F, 0x06, 0x01]),
Err(Error::Unframed)
);
}
#[test]
fn a_request_addressing_no_unit_is_refused() {
assert_eq!(
parse_request(&[0xF0, 0x7E, 0x10, 0x06, 0x01, 0xF7]),
Err(Error::InvalidDeviceId(0x10))
);
}
#[test]
fn a_reply_round_trips() {
let mut bytes = [0u8; REPLY_LEN];
let len = reply_into(&identity(), &mut bytes).expect("the buffer fits");
assert_eq!(len, REPLY_LEN);
assert_eq!(parse_reply(&bytes), Ok(identity()));
}
#[test]
fn the_manuals_own_byte_layout_parses() {
let bytes = [
0xF0, 0x7E, 0x00, 0x06, 0x02, 0x00, 0x20, 0x32, 0x20, 0x00, 0x01, 0x00, 0x11, 0x00,
0x01, 0x00, 0xF7,
];
let identity = parse_reply(&bytes).expect("the manual's own bytes");
assert_eq!(identity.device, DeviceId::Unit(0));
assert_eq!(identity.firmware.major, 1);
assert_eq!(identity.firmware.minor, 1);
}
#[test]
fn firmware_versions_pack_the_minor_revision_above_the_major() {
assert_display(Version::from_packed(0x01), "1.0");
assert_display(Version::from_packed(0x11), "1.1");
for minor in 0..=7 {
for major in 0..=15 {
let version = Version { major, minor };
assert_eq!(Version::from_packed(version.to_packed()), version);
}
}
}
#[test]
fn another_manufacturers_identity_reply_is_not_ours() {
let mut bytes = [0u8; REPLY_LEN];
reply_into(&identity(), &mut bytes).expect("the buffer fits");
let mut foreign = bytes;
if let Some(slot) = foreign.get_mut(5) {
*slot = 0x41;
}
assert_eq!(parse_reply(&foreign), Err(Error::NotAnInquiryResponse));
assert_eq!(
parse_reply(bytes.get(..REPLY_LEN - 1).expect("a shorter reply")),
Err(Error::Unframed)
);
}
#[test]
fn a_request_addresses_one_unit_or_all_of_them() {
let mut bytes = [0u8; REQUEST_LEN];
request_into(DeviceId::Unit(9), &mut bytes).expect("the buffer fits");
assert_eq!(bytes, [0xF0, 0x7E, 0x09, 0x06, 0x01, 0xF7]);
let mut small = [0u8; 5];
assert_eq!(
request_into(DeviceId::Broadcast, &mut small),
Err(Error::BufferTooSmall {
needed: 6,
available: 5
})
);
}
}