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 64-bit floating point value
149    Real64 = 0x11,
150    /// A signed 64-bit integer
151    Int64 = 0x15,
152    /// An unsigned 64-bit integer
153    UInt64 = 0x1b,
154    /// A contained for an unrecognized data type value
155    Other(u16),
156}
157
158impl From<u16> for DataType {
159    fn from(value: u16) -> Self {
160        use DataType::*;
161        match value {
162            1 => Boolean,
163            2 => Int8,
164            3 => Int16,
165            4 => Int32,
166            5 => UInt8,
167            6 => UInt16,
168            7 => UInt32,
169            8 => Real32,
170            9 => VisibleString,
171            0xa => OctetString,
172            0xb => UnicodeString,
173            0xf => Domain,
174            _ => Other(value),
175        }
176    }
177}
178
179impl DataType {
180    /// Returns true if data type is one of the string types
181    pub fn is_str(&self) -> bool {
182        matches!(
183            self,
184            Self::VisibleString | Self::OctetString | Self::UnicodeString
185        )
186    }
187}
188
189/// Information about a sub object
190#[derive(Clone, Copy, Debug, Default, PartialEq)]
191pub struct SubInfo {
192    /// The size (or max size) of this sub object, in bytes
193    pub size: usize,
194    /// The data type of this sub object
195    pub data_type: DataType,
196    /// Indicates what accesses (i.e. read/write) are allowed on this sub object
197    pub access_type: AccessType,
198    /// Indicates whether this sub may be mapped to PDOs
199    pub pdo_mapping: PdoMappable,
200    /// Indicates whether this sub should be persisted when data is saved
201    pub persist: bool,
202}
203
204impl SubInfo {
205    /// A shorthand value for sub0 on record and array objects
206    pub const MAX_SUB_NUMBER: SubInfo = SubInfo {
207        size: 1,
208        data_type: DataType::UInt8,
209        access_type: AccessType::Const,
210        pdo_mapping: PdoMappable::None,
211        persist: false,
212    };
213
214    /// Convenience function for creating a new sub-info by type
215    pub const fn new_u32() -> Self {
216        Self {
217            size: 4,
218            data_type: DataType::UInt32,
219            access_type: AccessType::Ro,
220            pdo_mapping: PdoMappable::None,
221            persist: false,
222        }
223    }
224
225    /// Convenience function for creating a new sub-info by type
226    pub const fn new_u16() -> Self {
227        Self {
228            size: 2,
229            data_type: DataType::UInt16,
230            access_type: AccessType::Ro,
231            pdo_mapping: PdoMappable::None,
232            persist: false,
233        }
234    }
235
236    /// Convenience function for creating a new sub-info by type
237    pub const fn new_u8() -> Self {
238        Self {
239            size: 1,
240            data_type: DataType::UInt8,
241            access_type: AccessType::Ro,
242            pdo_mapping: PdoMappable::None,
243            persist: false,
244        }
245    }
246
247    /// Convenience function for creating a new sub-info by type
248    pub const fn new_i32() -> Self {
249        Self {
250            size: 4,
251            data_type: DataType::Int32,
252            access_type: AccessType::Ro,
253            pdo_mapping: PdoMappable::None,
254            persist: false,
255        }
256    }
257
258    /// Convenience function for creating a new sub-info by type
259    pub const fn new_i16() -> Self {
260        Self {
261            size: 2,
262            data_type: DataType::Int16,
263            access_type: AccessType::Ro,
264            pdo_mapping: PdoMappable::None,
265            persist: false,
266        }
267    }
268
269    /// Convenience function for creating a new sub-info by type
270    pub const fn new_i8() -> Self {
271        Self {
272            size: 1,
273            data_type: DataType::Int8,
274            access_type: AccessType::Ro,
275            pdo_mapping: PdoMappable::None,
276            persist: false,
277        }
278    }
279
280    /// Convenience function for creating a new sub-info by type
281    pub const fn new_f32() -> Self {
282        Self {
283            size: 4,
284            data_type: DataType::Real32,
285            access_type: AccessType::Ro,
286            pdo_mapping: PdoMappable::None,
287            persist: false,
288        }
289    }
290
291    /// Convenience function for creating a new sub-info by type
292    pub const fn new_visibile_str(size: usize) -> Self {
293        Self {
294            size,
295            data_type: DataType::VisibleString,
296            access_type: AccessType::Ro,
297            pdo_mapping: PdoMappable::None,
298            persist: false,
299        }
300    }
301
302    /// Convenience function to set the access_type to read-only
303    pub const fn ro_access(mut self) -> Self {
304        self.access_type = AccessType::Ro;
305        self
306    }
307
308    /// Convenience function to set the access_type to read-write
309    pub const fn rw_access(mut self) -> Self {
310        self.access_type = AccessType::Rw;
311        self
312    }
313
314    /// Convenience function to set the access_type to const
315    pub const fn const_access(mut self) -> Self {
316        self.access_type = AccessType::Const;
317        self
318    }
319
320    /// Convenience function to set the access_type to write-only
321    pub const fn wo_access(mut self) -> Self {
322        self.access_type = AccessType::Wo;
323        self
324    }
325
326    /// Convenience function to set the persist value
327    pub const fn persist(mut self, value: bool) -> Self {
328        self.persist = value;
329        self
330    }
331}
zencan_common/objects.rs

zencan_common/
objects.rs
