acex-sim 0.6.0

Deterministic simulation infrastructure. Everything needed to test protocol state machines reproducibly.
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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

// region: Imports

use crate::clock::Instant;
use acex_core::Vec;

// endregion: Imports

// region: Address

/// A logical node address in the simulation network.
///
/// Maps to a CAN ID, DoIP logical address, or any other addressing scheme depending on the
/// protocol layer in use.

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub struct NodeAddress(pub u32);

// endregion: Address

// region: RawMessage

/// A raw byte message between two nodes.
///
/// Used by low-level runtime implementers working directly with frames.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(all(feature = "defmt", not(feature = "alloc")), derive(defmt::Format))]
pub struct RawMessage<const MAX_DATA: usize> {
    pub src: NodeAddress,
    pub dst: NodeAddress,
    pub data: Vec<u8, MAX_DATA>,
    pub timestamp: Instant,
}

// endregion: RawMessage

// region: FrameTransport Trait

/// Low-level transport trait for frame-oriented communication.
///
/// Implementers of CAN/DoIP runtimes use this trait. The simulation replaces this with an
/// in-memory channel that can inject faults.
pub trait FrameTransport<const N: usize> {
    type Error: core::fmt::Debug;

    /// Sends a raw frame to the given destination.
    fn send(&mut self, dst: &NodeAddress, data: &[u8]) -> Result<(), Self::Error>;

    /// Receives the next available raw frame, if any. Returns `None` if no frame is available
    fn recv(&mut self) -> Option<RawMessage<N>>;
}

// endregion: FrameTransport Trait

// region: MessageTransport Trait

/// High-level transport trait for named message communication.
///
/// Application developers building on top of UDS/DoIP use this trait. Messages are typed - the
/// transport handles serialisation internally.
pub trait MessageTransport {
    type Message: core::fmt::Debug;
    type Error: core::fmt::Debug;

    /// Sends a typed message to the given destination
    fn send(&mut self, dst: &NodeAddress, message: Self::Message) -> Result<(), Self::Error>;

    /// Receives the next available typed message, if any.
    fn recv(&mut self) -> Option<(NodeAddress, Self::Message)>;
}

// endregion: MessageTransport Trait