use crate::protocol::compat::embedded_can::InvalidFrameLength;
use crate::{
AttemptError, BeginSendError, Driver, IngestResult, Instant, SendPermit, TxAttempt,
TxCompletion, TxOutcome,
};
use embedded_can::{Frame, nb};
pub trait CanTx {
type Frame: Frame;
type Error;
fn try_transmit(
&mut self,
frame: &Self::Frame,
) -> Result<Option<Self::Frame>, ::nb::Error<Self::Error>>;
}
pub trait CanRx {
type Frame: Frame;
type Error;
fn try_receive(&mut self) -> Result<Self::Frame, ::nb::Error<Self::Error>>;
}
impl<C> CanTx for C
where
C: nb::Can,
{
type Frame = C::Frame;
type Error = C::Error;
fn try_transmit(
&mut self,
frame: &Self::Frame,
) -> Result<Option<Self::Frame>, ::nb::Error<Self::Error>> {
self.transmit(frame)
}
}
impl<C> CanRx for C
where
C: nb::Can,
{
type Frame = C::Frame;
type Error = C::Error;
fn try_receive(&mut self) -> Result<Self::Frame, ::nb::Error<Self::Error>> {
self.receive()
}
}
#[must_use]
pub struct NbTx<'s> {
attempt: TxAttempt<'s>,
}
impl core::fmt::Debug for NbTx<'_> {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.debug_struct("NbTx").finish_non_exhaustive()
}
}
impl<'s> NbTx<'s> {
pub fn begin(
driver: &mut Driver<'s>,
permit: SendPermit<'s>,
at: Instant,
) -> Result<Self, BeginSendError> {
driver
.begin_send(permit, at)
.map(|attempt| Self { attempt })
}
pub fn cancel_unsubmitted(
self,
driver: &mut Driver<'s>,
occurred_at: Instant,
processed_at: Instant,
) -> Result<(), AttemptError> {
driver.cancel_unsubmitted(self.attempt, occurred_at, processed_at)
}
pub fn poll<T>(
self,
driver: &mut Driver<'s>,
tx: &mut T,
mut now: impl FnMut() -> Instant,
) -> Result<NbTransmit<'s, T::Frame>, NbTransmitError<'s, T::Error>>
where
T: CanTx,
{
let frame = match driver.authorize_tx(&self.attempt, now()) {
Ok(frame) => frame,
Err(error) => {
return Err(NbTransmitError::Authorize {
attempt: self,
error,
});
}
};
let Some(native) = frame.to_embedded_can::<T::Frame>() else {
let occurred_at = now();
let processed_at = now();
return match finish_not_submitted(driver, self.attempt, occurred_at, processed_at) {
Ok(_) => Err(NbTransmitError::FrameRejected),
Err(error) => Err(NbTransmitError::Finish(error)),
};
};
match tx.try_transmit(&native) {
Ok(displaced) => {
let occurred_at = now();
let processed_at = now();
match driver.finish_tx(
self.attempt,
TxOutcome::Submitted { occurred_at },
processed_at,
) {
Ok(TxCompletion::Submitted) => Ok(NbTransmit::Submitted { displaced }),
Ok(completion) => Ok(NbTransmit::Finished {
displaced,
completion,
}),
Err(error) => Ok(NbTransmit::Uncertain { displaced, error }),
}
}
Err(::nb::Error::WouldBlock) => {
let occurred_at = now();
let processed_at = now();
match driver.finish_tx(
self.attempt,
TxOutcome::WouldBlock { occurred_at },
processed_at,
) {
Ok(TxCompletion::Retry(retry)) => Ok(NbTransmit::WouldBlock { retry }),
Ok(completion) => Ok(NbTransmit::Finished {
displaced: None,
completion,
}),
Err(error) => Ok(NbTransmit::Uncertain {
displaced: None,
error,
}),
}
}
Err(::nb::Error::Other(error)) => {
let _ = driver.abandon_attempt(self.attempt, now());
Err(NbTransmitError::Driver(error))
}
}
}
}
fn finish_not_submitted<'s>(
driver: &mut Driver<'s>,
attempt: TxAttempt<'s>,
occurred_at: Instant,
processed_at: Instant,
) -> Result<TxCompletion<'s>, AttemptError> {
driver.finish_tx(
attempt,
TxOutcome::NotSubmitted { occurred_at },
processed_at,
)
}
#[derive(Debug)]
pub enum NbTransmit<'s, F> {
Submitted {
displaced: Option<F>,
},
WouldBlock {
retry: SendPermit<'s>,
},
Uncertain {
displaced: Option<F>,
error: AttemptError,
},
Finished {
displaced: Option<F>,
completion: TxCompletion<'s>,
},
}
#[derive(Debug)]
pub enum NbTransmitError<'s, E> {
Authorize {
attempt: NbTx<'s>,
error: AttemptError,
},
FrameRejected,
Finish(AttemptError),
Driver(E),
}
#[derive(Debug)]
pub enum NbReceive<F> {
Empty,
Frame {
frame: F,
received_at: Instant,
classification: IngestResult,
},
}
#[derive(Debug)]
pub enum NbReceiveError<F, E> {
Driver(E),
InvalidFrame {
frame: F,
received_at: Instant,
error: InvalidFrameLength,
},
}
pub type NbReceiveResult<R> = Result<
NbReceive<<R as CanRx>::Frame>,
NbReceiveError<<R as CanRx>::Frame, <R as CanRx>::Error>,
>;
pub fn receive_nb<R>(
driver: &mut Driver<'_>,
rx: &mut R,
observed_at: impl FnOnce() -> Instant,
) -> NbReceiveResult<R>
where
R: CanRx,
{
match rx.try_receive() {
Ok(frame) => {
let received_at = observed_at();
ingest_classic_frame(driver, frame, received_at).map_err(|(frame, error)| {
NbReceiveError::InvalidFrame {
frame,
received_at,
error,
}
})
}
Err(::nb::Error::WouldBlock) => Ok(NbReceive::Empty),
Err(::nb::Error::Other(error)) => Err(NbReceiveError::Driver(error)),
}
}
pub fn ingest_classic_frame<F>(
driver: &mut Driver<'_>,
frame: F,
received_at: Instant,
) -> Result<NbReceive<F>, (F, InvalidFrameLength)>
where
F: Frame,
{
let view = match crate::protocol::FrameRef::from_classic_embedded_can(&frame) {
Ok(view) => view,
Err(error) => return Err((frame, error)),
};
let classification = driver.ingest(view, received_at);
Ok(NbReceive::Frame {
frame,
received_at,
classification,
})
}