zencan_common/
objects.rs

1//! Object Definitions
2//!
3
4/// A container for the address of a subobject
5#[derive(Clone, Copy, Debug, PartialEq)]
6pub struct ObjectId {
7    /// Object index
8    pub index: u16,
9    /// Sub index
10    pub sub: u8,
11}
12
13/// Object Code value
14///
15/// Defines the type of an object or sub object
16#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
17#[repr(u8)]
18pub enum ObjectCode {
19    /// An empty object
20    ///
21    /// Zencan does not support Null objects
22    Null = 0,
23    /// A large chunk of data
24    ///
25    /// Zencan does not support Domain Object; it only supports domain sub-objects.
26    Domain = 2,
27    /// Unused
28    DefType = 5,
29    /// Unused
30    DefStruct = 6,
31    /// An object which has a single sub object
32    #[default]
33    Var = 7,
34    /// An array of sub-objects all with the same data type
35    Array = 8,
36    /// A collection of sub-objects with varying types
37    Record = 9,
38}
39
40impl TryFrom<u8> for ObjectCode {
41    type Error = ();
42
43    fn try_from(value: u8) -> Result<Self, Self::Error> {
44        match value {
45            0 => Ok(ObjectCode::Null),
46            2 => Ok(ObjectCode::Domain),
47            5 => Ok(ObjectCode::DefType),
48            6 => Ok(ObjectCode::DefStruct),
49            7 => Ok(ObjectCode::Var),
50            8 => Ok(ObjectCode::Array),
51            9 => Ok(ObjectCode::Record),
52            _ => Err(()),
53        }
54    }
55}
56
57/// Access type enum
58#[derive(Copy, Clone, Debug, Default, PartialEq)]
59pub enum AccessType {
60    /// Read-only
61    #[default]
62    Ro,
63    /// Write-only
64    Wo,
65    /// Read-write
66    Rw,
67    /// Read-only, and also will never be changed, even internally by the device
68    Const,
69}
70
71impl AccessType {
72    /// Returns true if an object with this access type can be read
73    pub fn is_readable(&self) -> bool {
74        matches!(self, AccessType::Ro | AccessType::Rw | AccessType::Const)
75    }
76
77    /// Returns true if an object with this access type can be written
78    pub fn is_writable(&self) -> bool {
79        matches!(self, AccessType::Rw | AccessType::Wo)
80    }
81}
82
83/// Possible PDO mapping values for an object
84#[derive(Copy, Clone, Debug, Default, PartialEq)]
85#[cfg_attr(
86    feature = "std",
87    derive(serde::Deserialize),
88    serde(rename_all = "lowercase")
89)]
90pub enum PdoMappable {
91    /// Object cannot be mapped to PDOs
92    #[default]
93    None,
94    /// Object can be mapped to RPDOs only
95    Rpdo,
96    /// Object can be mapped to TPDOs only
97    Tpdo,
98    /// Object can be mapped to both RPDOs and TPDOs
99    Both,
100}
101
102impl PdoMappable {
103    /// Can be mapped to a TPDO
104    pub fn supports_tpdo(&self) -> bool {
105        matches!(self, PdoMappable::Tpdo | PdoMappable::Both)
106    }
107
108    /// Can be mapped to an RPDO
109    pub fn supports_rpdo(&self) -> bool {
110        matches!(self, PdoMappable::Rpdo | PdoMappable::Both)
111    }
112}
113
114/// Indicate the type of data stored in an object
115#[derive(Copy, Clone, Debug, Default, PartialEq)]
116#[repr(u16)]
117pub enum DataType {
118    /// A true false value, encoded as a single byte, with 0 for false and 1 for true
119    Boolean = 1,
120    #[default]
121    /// A signed 8-bit integer
122    Int8 = 2,
123    /// A signed 16-bit integer
124    Int16 = 3,
125    /// A signed 32-bit integer
126    Int32 = 4,
127    /// An unsigned 8-bit integer
128    UInt8 = 5,
129    /// An unsigned 16-bit integer
130    UInt16 = 6,
131    /// An unsigned 32-bit integer
132    UInt32 = 7,
133    /// A 32-bit floating point value
134    Real32 = 8,
135    /// An ASCII/utf-8 string
136    VisibleString = 9,
137    /// A byte string
138    OctetString = 0xa,
139    /// A unicode string
140    UnicodeString = 0xb,
141    /// Currently Unimplemented
142    TimeOfDay = 0xc,
143    /// Currently Unimplemented
144    TimeDifference = 0xd,
145    /// An arbitrary byte access type for e.g. data streams, or large chunks of
146    /// data. Size is typically not known at build time.
147    Domain = 0xf,
148    /// A contained for an unrecognized data type value
149    Other(u16),
150}
151
152impl From<u16> for DataType {
153    fn from(value: u16) -> Self {
154        use DataType::*;
155        match value {
156            1 => Boolean,
157            2 => Int8,
158            3 => Int16,
159            4 => Int32,
160            5 => UInt8,
161            6 => UInt16,
162            7 => UInt32,
163            8 => Real32,
164            9 => VisibleString,
165            0xa => OctetString,
166            0xb => UnicodeString,
167            0xf => Domain,
168            _ => Other(value),
169        }
170    }
171}
172
173impl DataType {
174    /// Returns true if data type is one of the string types
175    pub fn is_str(&self) -> bool {
176        matches!(
177            self,
178            Self::VisibleString | Self::OctetString | Self::UnicodeString
179        )
180    }
181}
182
183/// Information about a sub object
184#[derive(Clone, Copy, Debug, Default, PartialEq)]
185pub struct SubInfo {
186    /// The size (or max size) of this sub object, in bytes
187    pub size: usize,
188    /// The data type of this sub object
189    pub data_type: DataType,
190    /// Indicates what accesses (i.e. read/write) are allowed on this sub object
191    pub access_type: AccessType,
192    /// Indicates whether this sub may be mapped to PDOs
193    pub pdo_mapping: PdoMappable,
194    /// Indicates whether this sub should be persisted when data is saved
195    pub persist: bool,
196}
197
198impl SubInfo {
199    /// A shorthand value for sub0 on record and array objects
200    pub const MAX_SUB_NUMBER: SubInfo = SubInfo {
201        size: 1,
202        data_type: DataType::UInt8,
203        access_type: AccessType::Const,
204        pdo_mapping: PdoMappable::None,
205        persist: false,
206    };
207
208    /// Convenience function for creating a new sub-info by type
209    pub const fn new_u32() -> Self {
210        Self {
211            size: 4,
212            data_type: DataType::UInt32,
213            access_type: AccessType::Ro,
214            pdo_mapping: PdoMappable::None,
215            persist: false,
216        }
217    }
218
219    /// Convenience function for creating a new sub-info by type
220    pub const fn new_u16() -> Self {
221        Self {
222            size: 2,
223            data_type: DataType::UInt16,
224            access_type: AccessType::Ro,
225            pdo_mapping: PdoMappable::None,
226            persist: false,
227        }
228    }
229
230    /// Convenience function for creating a new sub-info by type
231    pub const fn new_u8() -> Self {
232        Self {
233            size: 1,
234            data_type: DataType::UInt8,
235            access_type: AccessType::Ro,
236            pdo_mapping: PdoMappable::None,
237            persist: false,
238        }
239    }
240
241    /// Convenience function for creating a new sub-info by type
242    pub const fn new_i32() -> Self {
243        Self {
244            size: 4,
245            data_type: DataType::Int32,
246            access_type: AccessType::Ro,
247            pdo_mapping: PdoMappable::None,
248            persist: false,
249        }
250    }
251
252    /// Convenience function for creating a new sub-info by type
253    pub const fn new_i16() -> Self {
254        Self {
255            size: 2,
256            data_type: DataType::Int16,
257            access_type: AccessType::Ro,
258            pdo_mapping: PdoMappable::None,
259            persist: false,
260        }
261    }
262
263    /// Convenience function for creating a new sub-info by type
264    pub const fn new_i8() -> Self {
265        Self {
266            size: 1,
267            data_type: DataType::Int8,
268            access_type: AccessType::Ro,
269            pdo_mapping: PdoMappable::None,
270            persist: false,
271        }
272    }
273
274    /// Convenience function for creating a new sub-info by type
275    pub const fn new_f32() -> Self {
276        Self {
277            size: 4,
278            data_type: DataType::Real32,
279            access_type: AccessType::Ro,
280            pdo_mapping: PdoMappable::None,
281            persist: false,
282        }
283    }
284
285    /// Convenience function for creating a new sub-info by type
286    pub const fn new_visibile_str(size: usize) -> Self {
287        Self {
288            size,
289            data_type: DataType::VisibleString,
290            access_type: AccessType::Ro,
291            pdo_mapping: PdoMappable::None,
292            persist: false,
293        }
294    }
295
296    /// Convenience function to set the access_type to read-only
297    pub const fn ro_access(mut self) -> Self {
298        self.access_type = AccessType::Ro;
299        self
300    }
301
302    /// Convenience function to set the access_type to read-write
303    pub const fn rw_access(mut self) -> Self {
304        self.access_type = AccessType::Rw;
305        self
306    }
307
308    /// Convenience function to set the access_type to const
309    pub const fn const_access(mut self) -> Self {
310        self.access_type = AccessType::Const;
311        self
312    }
313
314    /// Convenience function to set the access_type to write-only
315    pub const fn wo_access(mut self) -> Self {
316        self.access_type = AccessType::Wo;
317        self
318    }
319
320    /// Convenience function to set the persist value
321    pub const fn persist(mut self, value: bool) -> Self {
322        self.persist = value;
323        self
324    }
325}
zencan_common/objects.rs

zencan_common/
objects.rs
