use alloc::vec::Vec;
use thiserror::Error;
use crate::wire::{Address, xor_checksum};
pub const MAX_ENCODED_FRAME_SIZE: usize = 522;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum PhysicalLayer {
Fsk,
Psk,
}
impl PhysicalLayer {
pub(crate) const fn delimiter_bit(self) -> u8 {
match self {
Self::Fsk => 0,
Self::Psk => 0x08,
}
}
pub(crate) const fn from_delimiter(delimiter: u8) -> Self {
if delimiter & 0x08 == 0 {
Self::Fsk
} else {
Self::Psk
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum FrameKind {
Request,
Response,
Burst,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum FrameRepair {
DelimiterBit,
ShortAddressRewrite {
checksum_source_node: u8,
},
}
impl FrameKind {
pub(crate) const fn delimiter_base(self) -> u8 {
match self {
Self::Request => 0x02,
Self::Response => 0x06,
Self::Burst => 0x01,
}
}
pub(crate) const fn from_delimiter(delimiter: u8) -> Option<Self> {
match delimiter & 0x1f {
0x02 | 0x0a => Some(Self::Request),
0x06 | 0x0e => Some(Self::Response),
0x01 | 0x09 => Some(Self::Burst),
_ => None,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Error)]
pub enum WireError {
#[error("short address {0} is outside the 0..=63 range")]
PollingAddress(u8),
#[error("expanded device type {0} does not fit in 14 bits")]
ExpandedDeviceType(u16),
#[error("device identifier {0} does not fit in 24 bits")]
DeviceIdentifier(u32),
#[error("frame contains an invalid expansion length: {0}")]
ExpansionLength(usize),
#[error("payload is too large: {0} bytes")]
PayloadLength(usize),
#[error("truncated frame")]
Truncated,
#[error("unknown delimiter 0x{0:02x}")]
Delimiter(u8),
#[error("checksum mismatch: expected 0x{expected:02x}, received 0x{actual:02x}")]
Checksum {
expected: u8,
actual: u8,
},
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Frame {
pub preambles: u8,
pub kind: FrameKind,
pub physical_layer: PhysicalLayer,
pub address: Address,
pub expansion: Vec<u8>,
pub wire_command: u8,
pub payload: Vec<u8>,
pub repair: Option<FrameRepair>,
}
impl Frame {
pub fn encode(&self) -> Result<Vec<u8>, WireError> {
if self.expansion.len() > 3 {
return Err(WireError::ExpansionLength(self.expansion.len()));
}
let count = u8::try_from(self.payload.len())
.map_err(|_| WireError::PayloadLength(self.payload.len()))?;
let long_bit = if self.address.encoded_len() == 5 {
0x80
} else {
0
};
let delimiter = self.kind.delimiter_base()
| self.physical_layer.delimiter_bit()
| long_bit
| (u8::try_from(self.expansion.len()).unwrap_or(0) << 5);
let mut output = Vec::with_capacity(
usize::from(self.preambles)
+ 1
+ self.address.encoded_len()
+ self.expansion.len()
+ 3
+ self.payload.len(),
);
output.resize(usize::from(self.preambles), 0xff);
let checksum_start = output.len();
output.push(delimiter);
self.address
.write_to(self.kind == FrameKind::Burst, &mut output);
output.extend_from_slice(&self.expansion);
output.push(self.wire_command);
output.push(count);
output.extend_from_slice(&self.payload);
output.push(xor_checksum(&output[checksum_start..]));
Ok(output)
}
pub fn delimiter(&self) -> Result<u8, WireError> {
if self.expansion.len() > 3 {
return Err(WireError::ExpansionLength(self.expansion.len()));
}
Ok(self.kind.delimiter_base()
| self.physical_layer.delimiter_bit()
| if self.address.encoded_len() == 5 {
0x80
} else {
0
}
| (u8::try_from(self.expansion.len()).unwrap_or(0) << 5))
}
}