emcyphal 0.1.0

Async Cyphal/CAN network stack for no_std environments
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

//! Cyphal node implementation
//!
//! Node holds Cyphal peer data (e.g. NodeId, Health, Mode) and type-agnostic links to
//! registered buffers. It distributes incoming frames among RX buffers and collects outgoing
//! frames from TX ones. It also proxies and synchronizes endpoint access to the associated
//! buffers.
//!
//! ## Examples
//!
//! A minimal node can be created as simply as:
//! ```
//! use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex as Mutex;
//! use emcyphal::core::NodeId;
//! use emcyphal::node::{MinimalNode, Status};
//!
//! // A statically assigned Cyphal node identifier. Must be unique within a network.
//! const NODE_ID: NodeId = NodeId::new(10).unwrap();   
//! // A property of a driver.
//! const SUBJECT_SLOT_COUNT: usize = 7;
//! // Initial node status, can be updated through `control`.
//! let status = Status::default();
//!
//! let mut node = MinimalNode::<Mutex>::new(NODE_ID, status, SUBJECT_SLOT_COUNT);
//! let (hub, link, control, runner) = node.split();
//! ```
//! However, static allocation is typically used to obtain `'static` accessors
//! that can be passed to spawned tasks:
//! ```
//! # use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex as Mutex;
//! # use emcyphal::core::NodeId;
//! # use emcyphal::node::{MinimalNode, Status};
//! # const NODE_ID: NodeId = NodeId::new(10).unwrap();
//! # const SUBJECT_SLOT_COUNT: usize = 7;
//! # let status = emcyphal::node::Status::default();
//! use static_cell::StaticCell;
//!
//! static CELL: StaticCell<MinimalNode<Mutex>> = StaticCell::new();
//! let node = CELL.init(MinimalNode::new(NODE_ID, status, SUBJECT_SLOT_COUNT));
//! let (hub, link, control, runner) = node.split();
//! ```

use crate::marker::{Message, Request, Response};
use crate::registry;

mod core_node;
mod minimal_node;

pub use crate::data_types::node::{Health, Mode};
pub use core_node::CoreNode;
pub use emcyphal_driver::link::Link;
pub use minimal_node::MinimalNode;
pub use minimal_node::Runner as MinimalNodeRunner;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub struct Status {
    pub health: Health,
    pub mode: Mode,
    pub vendor_specific_code: u8,
}

impl Default for Status {
    fn default() -> Self {
        Self {
            health: Health::Nominal,
            mode: Mode::Operational,
            vendor_specific_code: 0,
        }
    }
}

pub(crate) trait DynamicControl {
    fn status(&self) -> Status;
    fn set_status(&self, status: Status);
}

/// Node status control handle
pub struct Control<'a>(&'a (dyn DynamicControl + Sync));

impl<'a> Control<'a> {
    unsafe fn new(node: &'a (dyn DynamicControl + Sync)) -> Self {
        Self(node)
    }

    pub fn status(&self) -> Status {
        self.0.status()
    }

    pub fn set_status(&mut self, status: Status) {
        self.0.set_status(status);
    }
}

#[allow(private_bounds)]
pub(crate) trait DynamicHub {
    fn rx_msg(&self) -> &(dyn registry::RxReg<Message> + Sync);
    fn rx_req(&self) -> &(dyn registry::RxReg<Request> + Sync);
    fn tx_msg(&self) -> &(dyn registry::TxReg<Message> + Sync);
    fn tx_resp(&self) -> &(dyn registry::TxReg<Response> + Sync);
}

/// Shared handle for creating new endpoints.
#[derive(Clone, Copy)]
pub struct Hub<'a>(&'a (dyn DynamicHub + Sync));

impl<'a> Hub<'a> {
    pub(crate) fn new(hub: &'a (dyn DynamicHub + Sync)) -> Self {
        Self(hub)
    }

    pub(crate) fn rx_msg(self) -> &'a (dyn registry::RxReg<Message> + Sync) {
        self.0.rx_msg()
    }

    pub(crate) fn rx_req(self) -> &'a (dyn registry::RxReg<Request> + Sync) {
        self.0.rx_req()
    }

    pub(crate) fn tx_msg(self) -> &'a (dyn registry::TxReg<Message> + Sync) {
        self.0.tx_msg()
    }

    pub(crate) fn tx_resp(self) -> &'a (dyn registry::TxReg<Response> + Sync) {
        self.0.tx_resp()
    }
}