ashv2 6.0.2

Implementation of the Asynchronous Serial Host (ASH) protocol.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

use std::fmt::Display;
use std::io;

use tokio::sync::oneshot::Sender;

use crate::Payload;
use crate::frame::{Error, Rst, RstAck};
use crate::utils::{HexSlice, WrappingU3};

/// Messages sent to the `ASHv2` transmitter.
#[derive(Debug)]
#[cfg_attr(target_pointer_width = "64", expect(variant_size_differences))]
pub enum Message {
    /// Payload received from the network.
    Payload {
        /// Data payload to send.
        payload: Box<Payload>,
        /// Response channel to notify when the payload has been sent.
        response_tx: Sender<io::Result<()>>,
    },
    /// Send an ACK frame with the given ack number.
    Ack(WrappingU3),
    /// Send a NAK frame with the given ack number.
    Nak(WrappingU3),
    /// Received RST frame.
    Rst(Rst),
    /// Received RST-ACK frame.
    RstAck(RstAck),
    /// Received ERROR frame.
    Error(Error),
    /// Acknowledgement sent frames up to the given frame number.
    AckSentFrame(WrappingU3),
    /// Negative Acknowledgement sent frames up to the given frame number.
    NakSentFrame(WrappingU3),
    /// Terminate the receiver.
    Terminate,
}

impl Display for Message {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Payload { payload, .. } => write!(f, "Payload({:#04X})", HexSlice::new(payload)),
            Self::Ack(ack_num) => write!(f, "Ack({ack_num})"),
            Self::Nak(ack_num) => write!(f, "Nak({ack_num})"),
            Self::Rst(rst) => write!(f, "Rst({rst})"),
            Self::RstAck(rst_ack) => write!(f, "RstAck({rst_ack})"),
            Self::Error(error) => write!(f, "Error({error})"),
            Self::AckSentFrame(ack_num) => write!(f, "AckSentFrame({ack_num})"),
            Self::NakSentFrame(ack_num) => write!(f, "NakSentFrame({ack_num})"),
            Self::Terminate => write!(f, "Terminate"),
        }
    }
}