use embedded_can::{Frame, StandardId};
use socketcan::{CanAnyFrame, CanFrame};
use crate::{EncodedFrame, FramePayload, FrameRef};
impl From<&EncodedFrame> for CanFrame {
fn from(frame: &EncodedFrame) -> Self {
let id = StandardId::new(frame.id()).expect("encoded standard CAN ID");
if frame.is_remote() {
Self::new_remote(id, usize::from(frame.dlc()))
} else {
Self::new(id, frame.data())
}
.expect("valid encoded Classic CAN frame")
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum FromSocketcanError {
ErrorFrame,
}
impl core::fmt::Display for FromSocketcanError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str("SocketCAN bus error notification is not a protocol frame")
}
}
impl core::error::Error for FromSocketcanError {}
impl<'a> TryFrom<&'a CanFrame> for FrameRef<'a> {
type Error = FromSocketcanError;
fn try_from(frame: &'a CanFrame) -> Result<Self, Self::Error> {
let payload = match frame {
CanFrame::Data(frame) => FramePayload::Data(frame.data()),
CanFrame::Remote(frame) => FramePayload::Remote {
dlc: frame.dlc() as u8,
},
CanFrame::Error(_) => return Err(FromSocketcanError::ErrorFrame),
};
Ok(Self {
id: frame.id().into(),
payload,
})
}
}
impl<'a> TryFrom<&'a CanAnyFrame> for FrameRef<'a> {
type Error = FromSocketcanError;
fn try_from(frame: &'a CanAnyFrame) -> Result<Self, Self::Error> {
let payload = match frame {
CanAnyFrame::Normal(frame) => FramePayload::Data(frame.data()),
CanAnyFrame::Remote(frame) => FramePayload::Remote {
dlc: frame.dlc() as u8,
},
CanAnyFrame::Fd(frame) => FramePayload::Fd(frame.data()),
CanAnyFrame::Error(_) => return Err(FromSocketcanError::ErrorFrame),
};
Ok(Self {
id: frame.id().into(),
payload,
})
}
}