use super::crc::crc8;
pub const PAYLOAD_LEN: usize = 1;
pub const FRAME_LEN: usize = 4;
const _: () = assert!(PAYLOAD_LEN == 1);
const _: () = assert!(FRAME_LEN == 4);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
pub enum FrameType {
Data = 0x01,
Ack = 0x02,
Nack = 0x03,
Start = 0x04,
Finish = 0x05,
}
impl FrameType {
const fn from_u8(byte: u8) -> Option<Self> {
match byte {
0x01 => Some(FrameType::Data),
0x02 => Some(FrameType::Ack),
0x03 => Some(FrameType::Nack),
0x04 => Some(FrameType::Start),
0x05 => Some(FrameType::Finish),
_ => None,
}
}
const fn is_control(self) -> bool {
!matches!(self, FrameType::Data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FrameError {
InvalidType(u8),
CrcMismatch {
expected: u8,
got: u8,
},
InvalidSemantics,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Frame {
frame_type: FrameType,
seq: u8,
data: u8,
}
impl Frame {
const fn raw(frame_type: FrameType, seq: u8, data: u8) -> Self {
Frame {
frame_type,
seq,
data,
}
}
pub const fn data(seq: u8, byte: u8) -> Self {
Frame::raw(FrameType::Data, seq, byte)
}
pub const fn data_frame(seq: u8, data: u8) -> Self {
Frame::data(seq, data)
}
pub const fn ack(seq: u8) -> Self {
Frame::raw(FrameType::Ack, seq, 0)
}
pub const fn nack(seq: u8) -> Self {
Frame::raw(FrameType::Nack, seq, 0)
}
pub const fn start() -> Self {
Frame::raw(FrameType::Start, 0, 0)
}
pub const fn finish(seq: u8) -> Self {
Frame::raw(FrameType::Finish, seq, 0)
}
pub const fn frame_type(&self) -> FrameType {
self.frame_type
}
pub const fn seq(&self) -> u8 {
self.seq
}
pub const fn payload(&self) -> u8 {
self.data
}
pub const fn to_bytes(&self) -> [u8; FRAME_LEN] {
let header = [self.frame_type as u8, self.seq, self.data];
let crc = crc8(&header);
[header[0], header[1], header[2], crc]
}
const fn semantics_ok(frame_type: FrameType, seq: u8, data: u8) -> bool {
if frame_type.is_control() && data != 0 {
return false;
}
if matches!(frame_type, FrameType::Start) && seq != 0 {
return false;
}
true
}
pub fn from_bytes(bytes: [u8; FRAME_LEN]) -> Result<Self, FrameError> {
let frame_type =
FrameType::from_u8(bytes[0]).ok_or(FrameError::InvalidType(bytes[0]))?;
let expected = crc8(&bytes[..3]);
let got = bytes[3];
if expected != got {
return Err(FrameError::CrcMismatch { expected, got });
}
let seq = bytes[1];
let data = bytes[2];
if !Self::semantics_ok(frame_type, seq, data) {
return Err(FrameError::InvalidSemantics);
}
Ok(Frame::raw(frame_type, seq, data))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn roundtrip_data_frame() {
let frame = Frame::data(42, 0xAA);
assert_eq!(Frame::from_bytes(frame.to_bytes()), Ok(frame));
assert_eq!(frame.payload(), 0xAA);
}
#[test]
fn control_constructors_force_data_zero() {
assert_eq!(Frame::ack(7).payload(), 0);
assert_eq!(Frame::nack(7).payload(), 0);
assert_eq!(Frame::start().payload(), 0);
assert_eq!(Frame::start().seq(), 0);
assert_eq!(Frame::finish(255).payload(), 0);
}
#[test]
fn roundtrip_all_control_frames() {
for frame in [
Frame::ack(7),
Frame::nack(7),
Frame::start(),
Frame::finish(255),
] {
assert_eq!(Frame::from_bytes(frame.to_bytes()), Ok(frame));
}
}
#[test]
fn rejects_unknown_type_byte() {
let mut bytes = Frame::data(1, 2).to_bytes();
bytes[0] = 0x00;
assert_eq!(Frame::from_bytes(bytes), Err(FrameError::InvalidType(0x00)));
}
#[test]
fn rejects_corrupted_payload() {
let mut bytes = Frame::data(1, 2).to_bytes();
bytes[2] ^= 0xFF;
assert!(matches!(
Frame::from_bytes(bytes),
Err(FrameError::CrcMismatch { .. })
));
}
#[test]
fn rejects_ack_with_nonzero_data_even_if_crc_matches() {
let header = [FrameType::Ack as u8, 42, 0xFF];
let crc = crc8(&header);
let bytes = [header[0], header[1], header[2], crc];
assert_eq!(
Frame::from_bytes(bytes), Err(FrameError::InvalidSemantics
));
}
#[test]
fn rejects_start_with_nonzero_seq() {
let header = [FrameType::Start as u8, 1, 0];
let crc = crc8(&header);
let bytes = [header[0], header[1], header[2], crc];
assert_eq!(
Frame::from_bytes(bytes), Err(FrameError::InvalidSemantics
));
}
#[test]
fn seq_and_data_span_full_u8_range() {
for &seq in &[0u8, 1, 127, 128, 254, 255] {
for &data in &[0u8, 1, 127, 128, 254, 255] {
assert_eq!(
Frame::from_bytes(Frame::data(seq, data).to_bytes()),
Ok(Frame::data(seq, data))
);
}
}
}
}