autosar_data_abstraction/communication/network_management/
can_nm.rs

1use crate::communication::{
2    AbstractNmCluster, AbstractNmClusterCoupling, AbstractNmNode, CanCluster, CanCommunicationController, NmEcu,
3};
4use crate::{AbstractionElement, AutosarAbstractionError, IdentifiableAbstractionElement, abstraction_element};
5use autosar_data::{Element, ElementName};
6
7//##################################################################
8
9/// Can specific `NmCluster` attributes
10#[derive(Debug, Clone, PartialEq, Eq, Hash)]
11pub struct CanNmCluster(Element);
12abstraction_element!(CanNmCluster, CanNmCluster);
13impl IdentifiableAbstractionElement for CanNmCluster {}
14
15impl CanNmCluster {
16    pub(crate) fn new(
17        name: &str,
18        parent: &Element,
19        settings: &CanNmClusterSettings,
20        can_cluster: &CanCluster,
21    ) -> Result<Self, AutosarAbstractionError> {
22        let can_nm_cluster_elem = parent.create_named_sub_element(ElementName::CanNmCluster, name)?;
23        let can_nm_cluster = Self(can_nm_cluster_elem);
24
25        can_nm_cluster.set_communication_cluster(can_cluster)?;
26        can_nm_cluster.set_nm_busload_reduction_active(settings.nm_busload_reduction_active)?;
27        can_nm_cluster.set_nm_immediate_nm_transmissions(settings.nm_immediate_nm_transmissions)?;
28        can_nm_cluster.set_nm_message_timeout_time(settings.nm_message_timeout_time)?;
29        can_nm_cluster.set_nm_msg_cycle_time(settings.nm_msg_cycle_time)?;
30        can_nm_cluster.set_nm_network_timeout(settings.nm_network_timeout)?;
31        can_nm_cluster.set_nm_remote_sleep_indication_time(settings.nm_remote_sleep_indication_time)?;
32        can_nm_cluster.set_nm_repeat_message_time(settings.nm_repeat_message_time)?;
33        can_nm_cluster.set_nm_wait_bus_sleep_time(settings.nm_wait_bus_sleep_time)?;
34
35        Ok(can_nm_cluster)
36    }
37
38    /// set the nmBusloadReductionActive flag
39    pub fn set_nm_busload_reduction_active(
40        &self,
41        nm_busload_reduction_active: bool,
42    ) -> Result<(), AutosarAbstractionError> {
43        self.element()
44            .get_or_create_sub_element(ElementName::NmBusloadReductionActive)?
45            .set_character_data(nm_busload_reduction_active)?;
46        Ok(())
47    }
48
49    /// get the nmBusloadReductionActive flag
50    #[must_use]
51    pub fn nm_busload_reduction_active(&self) -> Option<bool> {
52        self.element()
53            .get_sub_element(ElementName::NmBusloadReductionActive)
54            .and_then(|elem| elem.character_data())
55            .and_then(|cdata| cdata.parse_bool())
56    }
57
58    /// set the nmImmediateNmTransmissions value
59    pub fn set_nm_immediate_nm_transmissions(
60        &self,
61        nm_immediate_nm_transmissions: u32,
62    ) -> Result<(), AutosarAbstractionError> {
63        self.element()
64            .get_or_create_sub_element(ElementName::NmImmediateNmTransmissions)?
65            .set_character_data(u64::from(nm_immediate_nm_transmissions))?;
66        Ok(())
67    }
68
69    /// get the nmImmediateNmTransmissions value
70    #[must_use]
71    pub fn nm_immediate_nm_transmissions(&self) -> Option<u32> {
72        self.element()
73            .get_sub_element(ElementName::NmImmediateNmTransmissions)
74            .and_then(|elem| elem.character_data())
75            .and_then(|cdata| cdata.parse_integer())
76    }
77
78    /// set the nmMessageTimeoutTime
79    pub fn set_nm_message_timeout_time(&self, nm_message_timeout_time: f64) -> Result<(), AutosarAbstractionError> {
80        self.element()
81            .get_or_create_sub_element(ElementName::NmMessageTimeoutTime)?
82            .set_character_data(nm_message_timeout_time)?;
83        Ok(())
84    }
85
86    /// get the nmMessageTimeoutTime
87    #[must_use]
88    pub fn nm_message_timeout_time(&self) -> Option<f64> {
89        self.element()
90            .get_sub_element(ElementName::NmMessageTimeoutTime)
91            .and_then(|elem| elem.character_data())
92            .and_then(|cdata| cdata.parse_float())
93    }
94
95    /// set the nmMsgCycleTime
96    pub fn set_nm_msg_cycle_time(&self, nm_msg_cycle_time: f64) -> Result<(), AutosarAbstractionError> {
97        self.element()
98            .get_or_create_sub_element(ElementName::NmMsgCycleTime)?
99            .set_character_data(nm_msg_cycle_time)?;
100        Ok(())
101    }
102
103    /// get the nmMsgCycleTime
104    #[must_use]
105    pub fn nm_msg_cycle_time(&self) -> Option<f64> {
106        self.element()
107            .get_sub_element(ElementName::NmMsgCycleTime)
108            .and_then(|elem| elem.character_data())
109            .and_then(|cdata| cdata.parse_float())
110    }
111
112    /// set the nmNetworkTimeout
113    pub fn set_nm_network_timeout(&self, nm_network_timeout: f64) -> Result<(), AutosarAbstractionError> {
114        self.element()
115            .get_or_create_sub_element(ElementName::NmNetworkTimeout)?
116            .set_character_data(nm_network_timeout)?;
117        Ok(())
118    }
119
120    /// get the nmNetworkTimeout
121    #[must_use]
122    pub fn nm_network_timeout(&self) -> Option<f64> {
123        self.element()
124            .get_sub_element(ElementName::NmNetworkTimeout)
125            .and_then(|elem| elem.character_data())
126            .and_then(|cdata| cdata.parse_float())
127    }
128
129    /// set the nmRemoteSleepIndicationTime
130    pub fn set_nm_remote_sleep_indication_time(
131        &self,
132        nm_remote_sleep_indication_time: f64,
133    ) -> Result<(), AutosarAbstractionError> {
134        self.element()
135            .get_or_create_sub_element(ElementName::NmRemoteSleepIndicationTime)?
136            .set_character_data(nm_remote_sleep_indication_time)?;
137        Ok(())
138    }
139
140    /// get the nmRemoteSleepIndicationTime
141    #[must_use]
142    pub fn nm_remote_sleep_indication_time(&self) -> Option<f64> {
143        self.element()
144            .get_sub_element(ElementName::NmRemoteSleepIndicationTime)
145            .and_then(|elem| elem.character_data())
146            .and_then(|cdata| cdata.parse_float())
147    }
148
149    /// set the nmRepeatMessageTime
150    pub fn set_nm_repeat_message_time(&self, nm_repeat_message_time: f64) -> Result<(), AutosarAbstractionError> {
151        self.element()
152            .get_or_create_sub_element(ElementName::NmRepeatMessageTime)?
153            .set_character_data(nm_repeat_message_time)?;
154        Ok(())
155    }
156
157    /// get the nmRepeatMessageTime
158    #[must_use]
159    pub fn nm_repeat_message_time(&self) -> Option<f64> {
160        self.element()
161            .get_sub_element(ElementName::NmRepeatMessageTime)
162            .and_then(|elem| elem.character_data())
163            .and_then(|cdata| cdata.parse_float())
164    }
165
166    /// set the nmWaitBusSleepTime
167    pub fn set_nm_wait_bus_sleep_time(&self, nm_wait_bus_sleep_time: f64) -> Result<(), AutosarAbstractionError> {
168        self.element()
169            .get_or_create_sub_element(ElementName::NmWaitBusSleepTime)?
170            .set_character_data(nm_wait_bus_sleep_time)?;
171        Ok(())
172    }
173
174    /// get the nmWaitBusSleepTime
175    #[must_use]
176    pub fn nm_wait_bus_sleep_time(&self) -> Option<f64> {
177        self.element()
178            .get_sub_element(ElementName::NmWaitBusSleepTime)
179            .and_then(|elem| elem.character_data())
180            .and_then(|cdata| cdata.parse_float())
181    }
182
183    /// add a `CanNmNode` to the cluster
184    pub fn create_can_nm_node(
185        &self,
186        name: &str,
187        controller: &CanCommunicationController,
188        nm_ecu: &NmEcu,
189    ) -> Result<CanNmNode, AutosarAbstractionError> {
190        let nm_nodes = self.element().get_or_create_sub_element(ElementName::NmNodes)?;
191        CanNmNode::new(name, &nm_nodes, controller, nm_ecu)
192    }
193}
194
195impl AbstractNmCluster for CanNmCluster {
196    type CommunicationClusterType = CanCluster;
197    type NmNodeType = CanNmNode;
198}
199
200//##################################################################
201
202/// Mandatory settings for a `CanNmCluster`
203///
204/// These settings are mandatory for a `CanNmCluster` and must be set during creation.
205/// Additional optional settings can be set using the `CanNmCluster` methods.
206#[derive(Debug, Clone, PartialEq)]
207pub struct CanNmClusterSettings {
208    /// nmBusloadReductionActive: Determines if bus load reduction for the respective `CanNm` channel is active.
209    pub nm_busload_reduction_active: bool,
210    /// nmImmediateNmTransmissions: Defines the number of immediate `NmPdus` which shall be transmitted.
211    /// If the value is zero no immediate `NmPdus` are transmitted.
212    pub nm_immediate_nm_transmissions: u32,
213    /// nmMessageTimeoutTime: Timeout of an `NmPdu` in seconds.
214    pub nm_message_timeout_time: f64,
215    /// nmMsgCycleTime: Period of a `NmPdu` in seconds
216    pub nm_msg_cycle_time: f64,
217    /// nmNetworkTimeout: Network Timeout for `NmPdus` in seconds.
218    pub nm_network_timeout: f64,
219    /// nmRemoteSleepIndicationTime: Timeout for Remote Sleep Indication in seconds.
220    pub nm_remote_sleep_indication_time: f64,
221    /// nmRepeatMessageTime: Timeout for Repeat Message State in seconds.
222    pub nm_repeat_message_time: f64,
223    /// nmWaitBusSleepTime: Timeout for bus calm down phase in seconds.
224    pub nm_wait_bus_sleep_time: f64,
225}
226
227//##################################################################
228
229/// A `CanNmClusterCoupling` couples multiple `CanNmCluster`s, and contains CAN specific settings.
230#[derive(Debug, Clone, PartialEq, Eq, Hash)]
231pub struct CanNmClusterCoupling(Element);
232abstraction_element!(CanNmClusterCoupling, CanNmClusterCoupling);
233
234impl CanNmClusterCoupling {
235    pub(crate) fn new(
236        parent: &Element,
237        nm_busload_reduction_enabled: bool,
238        nm_immediate_restart_enabled: bool,
239    ) -> Result<Self, AutosarAbstractionError> {
240        let nm_cluster_coupling_elem = parent.create_sub_element(ElementName::CanNmClusterCoupling)?;
241        let nm_cluster_coupling = Self(nm_cluster_coupling_elem);
242        nm_cluster_coupling.set_nm_busload_reduction_enabled(nm_busload_reduction_enabled)?;
243        nm_cluster_coupling.set_nm_immediate_restart_enabled(nm_immediate_restart_enabled)?;
244
245        Ok(nm_cluster_coupling)
246    }
247
248    /// set the nmBusloadReductionEnabled flag
249    pub fn set_nm_busload_reduction_enabled(
250        &self,
251        nm_busload_reduction_enabled: bool,
252    ) -> Result<(), AutosarAbstractionError> {
253        self.element()
254            .get_or_create_sub_element(ElementName::NmBusloadReductionEnabled)?
255            .set_character_data(nm_busload_reduction_enabled)?;
256        Ok(())
257    }
258
259    /// get the nmBusloadReductionEnabled flag
260    #[must_use]
261    pub fn nm_busload_reduction_enabled(&self) -> Option<bool> {
262        self.element()
263            .get_sub_element(ElementName::NmBusloadReductionEnabled)
264            .and_then(|elem| elem.character_data())
265            .and_then(|cdata| cdata.parse_bool())
266    }
267
268    /// set the nmImmediateRestartEnabled flag
269    pub fn set_nm_immediate_restart_enabled(
270        &self,
271        nm_immediate_restart_enabled: bool,
272    ) -> Result<(), AutosarAbstractionError> {
273        self.element()
274            .get_or_create_sub_element(ElementName::NmImmediateRestartEnabled)?
275            .set_character_data(nm_immediate_restart_enabled)?;
276        Ok(())
277    }
278
279    /// get the nmImmediateRestartEnabled flag
280    #[must_use]
281    pub fn nm_immediate_restart_enabled(&self) -> Option<bool> {
282        self.element()
283            .get_sub_element(ElementName::NmImmediateRestartEnabled)
284            .and_then(|elem| elem.character_data())
285            .and_then(|cdata| cdata.parse_bool())
286    }
287}
288
289impl AbstractNmClusterCoupling for CanNmClusterCoupling {
290    type NmClusterType = CanNmCluster;
291}
292
293//##################################################################
294
295/// A `CanNmNode` represents a node in a `CanNmCluster`.
296///
297/// The node connects to a `CanCommunicationController` and an `NmEcu`.
298#[derive(Debug, Clone, PartialEq, Eq, Hash)]
299pub struct CanNmNode(Element);
300abstraction_element!(CanNmNode, CanNmNode);
301impl IdentifiableAbstractionElement for CanNmNode {}
302
303impl CanNmNode {
304    pub(crate) fn new(
305        name: &str,
306        parent: &Element,
307        controller: &CanCommunicationController,
308        nm_ecu: &NmEcu,
309    ) -> Result<Self, AutosarAbstractionError> {
310        let can_nm_node_elem = parent.create_named_sub_element(ElementName::CanNmNode, name)?;
311        let can_nm_ecu = Self(can_nm_node_elem);
312        can_nm_ecu.set_communication_controller(controller)?;
313        can_nm_ecu.set_nm_ecu(nm_ecu)?;
314
315        Ok(can_nm_ecu)
316    }
317}
318
319impl AbstractNmNode for CanNmNode {
320    type CommunicationControllerType = CanCommunicationController;
321}
autosar_data_abstraction/communication/network_management/can_nm.rs

autosar_data_abstraction/communication/network_management/
can_nm.rs
