use core::fmt;
use crate::error::Error;
pub const MANUFACTURER_ID: [u8; 3] = [0x00, 0x20, 0x32];
pub const BANK_COUNT: u8 = 8;
pub const PROGRAMS_PER_BANK: u8 = 128;
pub const USER_PATTERN_COUNT: u8 = 32;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum DeviceId {
Unit(u8),
Broadcast,
}
impl DeviceId {
pub const BROADCAST_BYTE: u8 = 0x7F;
pub const fn from_byte(byte: u8) -> Result<Self, Error> {
match byte {
Self::BROADCAST_BYTE => Ok(Self::Broadcast),
0..=15 => Ok(Self::Unit(byte)),
_ => Err(Error::InvalidDeviceId(byte)),
}
}
#[must_use]
pub const fn to_byte(self) -> u8 {
match self {
Self::Unit(id) => id,
Self::Broadcast => Self::BROADCAST_BYTE,
}
}
#[must_use]
pub const fn addresses(self, listener: Self) -> bool {
matches!(self, Self::Broadcast) || self.to_byte() == listener.to_byte()
}
}
impl TryFrom<u8> for DeviceId {
type Error = Error;
fn try_from(byte: u8) -> Result<Self, Error> {
Self::from_byte(byte)
}
}
impl From<DeviceId> for u8 {
fn from(id: DeviceId) -> Self {
id.to_byte()
}
}
impl fmt::Display for DeviceId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Unit(id) => write!(f, "unit {id}"),
Self::Broadcast => f.write_str("broadcast"),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[non_exhaustive]
pub enum Model {
DeepMind6,
DeepMind6X,
#[default]
DeepMind12,
DeepMind12X,
DeepMind12D,
DeepMind12XD,
}
impl Model {
pub const MODEL_ID: u8 = 0x20;
pub const ALL: &'static [Self] = &[
Self::DeepMind6,
Self::DeepMind6X,
Self::DeepMind12,
Self::DeepMind12X,
Self::DeepMind12D,
Self::DeepMind12XD,
];
#[must_use]
pub const fn voice_count(self) -> u8 {
match self {
Self::DeepMind6 | Self::DeepMind6X => 6,
Self::DeepMind12 | Self::DeepMind12X | Self::DeepMind12D | Self::DeepMind12XD => 12,
}
}
#[must_use]
pub const fn has_keyboard(self) -> bool {
!matches!(self, Self::DeepMind12D | Self::DeepMind12XD)
}
#[must_use]
pub const fn name(self) -> &'static str {
match self {
Self::DeepMind6 => "DeepMind 6",
Self::DeepMind6X => "DeepMind 6X",
Self::DeepMind12 => "DeepMind 12",
Self::DeepMind12X => "DeepMind 12X",
Self::DeepMind12D => "DeepMind 12D",
Self::DeepMind12XD => "DeepMind 12XD",
}
}
}
impl fmt::Display for Model {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.name())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ProtocolVersion(u8);
impl ProtocolVersion {
pub const V6: Self = Self(6);
pub const V7: Self = Self(7);
pub const fn new(version: u8) -> Result<Self, Error> {
match version {
6 | 7 => Ok(Self(version)),
_ => Err(Error::UnsupportedProtocolVersion(version)),
}
}
#[must_use]
pub const fn get(self) -> u8 {
self.0
}
#[must_use]
pub const fn program_data_len(self) -> usize {
match self.0 {
6 => 242,
_ => 245,
}
}
}
impl TryFrom<u8> for ProtocolVersion {
type Error = Error;
fn try_from(version: u8) -> Result<Self, Error> {
Self::new(version)
}
}
impl From<ProtocolVersion> for u8 {
fn from(version: ProtocolVersion) -> Self {
version.get()
}
}
impl fmt::Display for ProtocolVersion {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "v{}", self.0)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Bank(u8);
impl Bank {
pub const A: Self = Self(0);
pub const H: Self = Self(7);
pub const fn new(index: u8) -> Result<Self, Error> {
if index < BANK_COUNT {
Ok(Self(index))
} else {
Err(Error::BankOutOfRange(index))
}
}
pub const fn from_letter(letter: char) -> Result<Self, Error> {
match letter {
'A'..='H' => Self::new(letter as u8 - b'A'),
'a'..='h' => Self::new(letter as u8 - b'a'),
_ => Err(Error::BankLetter(letter)),
}
}
#[must_use]
pub const fn index(self) -> u8 {
self.0
}
#[must_use]
pub const fn letter(self) -> char {
(b'A' + self.0) as char
}
}
impl TryFrom<u8> for Bank {
type Error = Error;
fn try_from(index: u8) -> Result<Self, Error> {
Self::new(index)
}
}
impl From<Bank> for u8 {
fn from(bank: Bank) -> Self {
bank.index()
}
}
impl fmt::Display for Bank {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.letter())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ProgramNumber(u8);
impl ProgramNumber {
pub const FIRST: Self = Self(0);
pub const LAST: Self = Self(127);
pub const fn new(number: u8) -> Result<Self, Error> {
if number < PROGRAMS_PER_BANK {
Ok(Self(number))
} else {
Err(Error::ProgramOutOfRange(number))
}
}
#[must_use]
pub const fn get(self) -> u8 {
self.0
}
}
impl TryFrom<u8> for ProgramNumber {
type Error = Error;
fn try_from(number: u8) -> Result<Self, Error> {
Self::new(number)
}
}
impl From<ProgramNumber> for u8 {
fn from(number: ProgramNumber) -> Self {
number.get()
}
}
impl fmt::Display for ProgramNumber {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", u16::from(self.0) + 1)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Slot {
pub bank: Bank,
pub number: ProgramNumber,
}
impl Slot {
pub const FIRST: Self = Self {
bank: Bank::A,
number: ProgramNumber::FIRST,
};
#[must_use]
pub const fn new(bank: Bank, number: ProgramNumber) -> Self {
Self { bank, number }
}
}
impl fmt::Display for Slot {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}{}", self.bank, self.number)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PatternNumber(u8);
impl PatternNumber {
pub const FIRST: Self = Self(0);
pub const LAST: Self = Self(31);
pub const fn new(number: u8) -> Result<Self, Error> {
if number < USER_PATTERN_COUNT {
Ok(Self(number))
} else {
Err(Error::PatternOutOfRange(number))
}
}
#[must_use]
pub const fn get(self) -> u8 {
self.0
}
}
impl TryFrom<u8> for PatternNumber {
type Error = Error;
fn try_from(number: u8) -> Result<Self, Error> {
Self::new(number)
}
}
impl From<PatternNumber> for u8 {
fn from(number: PatternNumber) -> Self {
number.get()
}
}
impl fmt::Display for PatternNumber {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", u16::from(self.0) + 1)
}
}
#[cfg(test)]
#[expect(
clippy::expect_used,
reason = "a failed expectation is the test failure"
)]
mod tests {
use super::*;
use crate::testing::assert_display;
#[test]
fn a_slot_reads_as_the_front_panel_writes_it() {
assert_display(Slot::FIRST, "A1");
assert_display(Slot::new(Bank::H, ProgramNumber::LAST), "H128");
}
#[test]
fn device_id_round_trips_through_its_wire_byte() {
for byte in (0..=15).chain(core::iter::once(0x7F)) {
let id = DeviceId::from_byte(byte).expect("byte is in range");
assert_eq!(id.to_byte(), byte);
}
assert_eq!(DeviceId::from_byte(16), Err(Error::InvalidDeviceId(16)));
assert_eq!(DeviceId::from_byte(0x7E), Err(Error::InvalidDeviceId(0x7E)));
}
#[test]
fn broadcast_addresses_every_unit_but_a_unit_only_addresses_itself() {
let unit_3 = DeviceId::Unit(3);
assert!(DeviceId::Broadcast.addresses(unit_3));
assert!(unit_3.addresses(unit_3));
assert!(!unit_3.addresses(DeviceId::Unit(4)));
}
#[test]
fn every_model_reports_a_plausible_voice_count_and_name() {
for model in Model::ALL.iter().copied() {
assert!(matches!(model.voice_count(), 6 | 12));
assert!(model.name().starts_with("DeepMind "));
}
assert!(!Model::DeepMind12XD.has_keyboard());
assert!(Model::DeepMind6X.has_keyboard());
}
#[test]
fn banks_map_between_index_and_letter() {
for index in 0..BANK_COUNT {
let bank = Bank::new(index).expect("index is in range");
assert_eq!(bank.letter(), (b'A' + index) as char);
assert_eq!(Bank::from_letter(bank.letter()), Ok(bank));
assert_eq!(
Bank::from_letter(bank.letter().to_ascii_lowercase()),
Ok(bank)
);
}
assert!(Bank::new(BANK_COUNT).is_err());
assert_eq!(Bank::from_letter('I'), Err(Error::BankLetter('I')));
assert_display(Bank::H, "H");
}
#[test]
fn program_numbers_reject_out_of_range_slots() {
assert_eq!(ProgramNumber::new(127).map(ProgramNumber::get), Ok(127));
assert_eq!(ProgramNumber::new(128), Err(Error::ProgramOutOfRange(128)));
}
#[test]
fn pattern_numbers_reject_out_of_range_slots() {
assert_eq!(PatternNumber::new(31).map(PatternNumber::get), Ok(31));
assert_eq!(PatternNumber::new(32), Err(Error::PatternOutOfRange(32)));
}
#[test]
fn protocol_versions_carry_their_program_data_length() {
assert_eq!(ProtocolVersion::V6.program_data_len(), 242);
assert_eq!(ProtocolVersion::V7.program_data_len(), 245);
assert_eq!(ProtocolVersion::new(7), Ok(ProtocolVersion::V7));
assert_eq!(
ProtocolVersion::new(99),
Err(Error::UnsupportedProtocolVersion(99))
);
}
#[test]
fn every_id_converts_from_its_byte_and_back() {
assert_eq!(Bank::try_from(7).map(u8::from), Ok(7));
assert_eq!(ProgramNumber::try_from(127).map(u8::from), Ok(127));
assert_eq!(PatternNumber::try_from(31).map(u8::from), Ok(31));
assert_eq!(DeviceId::try_from(0x7F), Ok(DeviceId::Broadcast));
assert_eq!(u8::from(DeviceId::Unit(3)), 3);
assert_eq!(ProtocolVersion::try_from(6).map(u8::from), Ok(6));
assert!(Bank::try_from(8).is_err());
}
}