regenerate messages.rs

Author: andresv

testing/can-messages/src/messages.rs

@@ -23,7 +23,7 @@ impl Messages {
     #[inline(never)]
     pub fn from_can_message(id: u32, payload: &[u8]) -> Result<Self, CanError> {
         use core::convert::TryFrom;
-
+        
         let res = match id {
             256 => Messages::Foo(Foo::try_from(payload)?),
             512 => Messages::Bar(Bar::try_from(payload)?),
@@ -46,20 +46,20 @@ pub struct Foo {
 
 impl Foo {
     pub const MESSAGE_ID: u32 = 256;
-
+    
     /// Construct new Foo from values
     pub fn new(voltage: f32, current: f32) -> Result<Self, CanError> {
         let mut res = Self { raw: [0u8; 4] };
         res.set_voltage(voltage)?;
         res.set_current(current)?;
         Ok(res)
     }
-
+    
     /// Access message payload raw value
     pub fn raw(&self) -> &[u8] {
         &self.raw
     }
-
+    
     /// Voltage
     ///
     /// - Min: 0
@@ -70,7 +70,7 @@ impl Foo {
     pub fn voltage(&self) -> f32 {
         self.voltage_raw()
     }
-
+    
     /// Get raw value of Voltage
     ///
     /// - Start bit: 16
@@ -82,29 +82,27 @@ impl Foo {
     #[inline(always)]
     pub fn voltage_raw(&self) -> f32 {
         let signal = u16::unpack_le_bits(&self.raw, 16, 16);
-
+        
         let factor = 0.000976562_f32;
         let offset = 0_f32;
         (signal as f32) * factor + offset
     }
-
+    
     /// Set value of Voltage
     #[inline(always)]
     pub fn set_voltage(&mut self, value: f32) -> Result<(), CanError> {
         #[cfg(feature = "range_checked")]
-        if value < 0_f32 || 63.9990234375_f32 < value {
-            return Err(CanError::ParameterOutOfRange { message_id: 256 });
-        }
+        if value < 0_f32 || 63.9990234375_f32 < value { return Err(CanError::ParameterOutOfRange{ message_id: 256 }); }
         let factor = 0.000976562_f32;
         let offset = 0_f32;
         let value = ((value - offset) / factor) as u16;
-
+        
         let start_bit = 16;
         let bits = 16;
         value.pack_le_bits(&mut self.raw, start_bit, bits);
         Ok(())
     }
-
+    
     /// Current
     ///
     /// - Min: -2048
@@ -115,7 +113,7 @@ impl Foo {
     pub fn current(&self) -> f32 {
         self.current_raw()
     }
-
+    
     /// Get raw value of Current
     ///
     /// - Start bit: 0
@@ -127,44 +125,42 @@ impl Foo {
     #[inline(always)]
     pub fn current_raw(&self) -> f32 {
         let signal = i16::unpack_le_bits(&self.raw, 0, 16);
-
+        
         let factor = 0.0625_f32;
         let offset = 0_f32;
         (signal as f32) * factor + offset
     }
-
+    
     /// Set value of Current
     #[inline(always)]
     pub fn set_current(&mut self, value: f32) -> Result<(), CanError> {
         #[cfg(feature = "range_checked")]
-        if value < -2048_f32 || 2047.9375_f32 < value {
-            return Err(CanError::ParameterOutOfRange { message_id: 256 });
-        }
+        if value < -2048_f32 || 2047.9375_f32 < value { return Err(CanError::ParameterOutOfRange{ message_id: 256 }); }
         let factor = 0.0625_f32;
         let offset = 0_f32;
         let value = ((value - offset) / factor) as i16;
-
+        
         let start_bit = 0;
         let bits = 16;
         value.pack_le_bits(&mut self.raw, start_bit, bits);
         Ok(())
     }
+    
 }
 
 impl core::convert::TryFrom<&[u8]> for Foo {
     type Error = CanError;
-
+    
     #[inline(always)]
     fn try_from(payload: &[u8]) -> Result<Self, Self::Error> {
-        if payload.len() != 4 {
-            return Err(CanError::InvalidPayloadSize);
-        }
+        if payload.len() != 4 { return Err(CanError::InvalidPayloadSize); }
         let mut raw = [0u8; 4];
         raw.copy_from_slice(&payload[..4]);
         Ok(Self { raw })
     }
 }
 
+
 /// Bar
 ///
 /// - ID: 512 (0x200)
@@ -178,7 +174,7 @@ pub struct Bar {
 
 impl Bar {
     pub const MESSAGE_ID: u32 = 512;
-
+    
     /// Construct new Bar from values
     pub fn new(one: u8, two: f32, three: u8, four: u8, five: bool) -> Result<Self, CanError> {
         let mut res = Self { raw: [0u8; 8] };
@@ -189,12 +185,12 @@ impl Bar {
         res.set_five(five)?;
         Ok(res)
     }
-
+    
     /// Access message payload raw value
     pub fn raw(&self) -> &[u8] {
         &self.raw
     }
-
+    
     /// One
     ///
     /// - Min: 0
@@ -205,7 +201,7 @@ impl Bar {
     pub fn one(&self) -> u8 {
         self.one_raw()
     }
-
+    
     /// Get raw value of One
     ///
     /// - Start bit: 15
@@ -217,23 +213,21 @@ impl Bar {
     #[inline(always)]
     pub fn one_raw(&self) -> u8 {
         let signal = u8::unpack_be_bits(&self.raw, (15 - (2 - 1)), 2);
-
+        
         signal
     }
-
+    
     /// Set value of One
     #[inline(always)]
     pub fn set_one(&mut self, value: u8) -> Result<(), CanError> {
         #[cfg(feature = "range_checked")]
-        if value < 0_u8 || 3_u8 < value {
-            return Err(CanError::ParameterOutOfRange { message_id: 512 });
-        }
+        if value < 0_u8 || 3_u8 < value { return Err(CanError::ParameterOutOfRange{ message_id: 512 }); }
         let start_bit = 15;
         let bits = 2;
         value.pack_be_bits(&mut self.raw, start_bit, bits);
         Ok(())
     }
-
+    
     /// Two
     ///
     /// - Min: 0
@@ -244,7 +238,7 @@ impl Bar {
     pub fn two(&self) -> f32 {
         self.two_raw()
     }
-
+    
     /// Get raw value of Two
     ///
     /// - Start bit: 7
@@ -256,29 +250,27 @@ impl Bar {
     #[inline(always)]
     pub fn two_raw(&self) -> f32 {
         let signal = u8::unpack_be_bits(&self.raw, (7 - (8 - 1)), 8);
-
+        
         let factor = 0.39_f32;
         let offset = 0_f32;
         (signal as f32) * factor + offset
     }
-
+    
     /// Set value of Two
     #[inline(always)]
     pub fn set_two(&mut self, value: f32) -> Result<(), CanError> {
         #[cfg(feature = "range_checked")]
-        if value < 0_f32 || 100_f32 < value {
-            return Err(CanError::ParameterOutOfRange { message_id: 512 });
-        }
+        if value < 0_f32 || 100_f32 < value { return Err(CanError::ParameterOutOfRange{ message_id: 512 }); }
         let factor = 0.39_f32;
         let offset = 0_f32;
         let value = ((value - offset) / factor) as u8;
-
+        
         let start_bit = 7;
         let bits = 8;
         value.pack_be_bits(&mut self.raw, start_bit, bits);
         Ok(())
     }
-
+    
     /// Three
     ///
     /// - Min: 0
@@ -295,7 +287,7 @@ impl Bar {
             x => BarThree::Other(x),
         }
     }
-
+    
     /// Get raw value of Three
     ///
     /// - Start bit: 13
@@ -307,23 +299,21 @@ impl Bar {
     #[inline(always)]
     pub fn three_raw(&self) -> u8 {
         let signal = u8::unpack_be_bits(&self.raw, (13 - (3 - 1)), 3);
-
+        
         signal
     }
-
+    
     /// Set value of Three
     #[inline(always)]
     pub fn set_three(&mut self, value: u8) -> Result<(), CanError> {
         #[cfg(feature = "range_checked")]
-        if value < 0_u8 || 7_u8 < value {
-            return Err(CanError::ParameterOutOfRange { message_id: 512 });
-        }
+        if value < 0_u8 || 7_u8 < value { return Err(CanError::ParameterOutOfRange{ message_id: 512 }); }
         let start_bit = 13;
         let bits = 3;
         value.pack_be_bits(&mut self.raw, start_bit, bits);
         Ok(())
     }
-
+    
     /// Four
     ///
     /// - Min: 0
@@ -340,7 +330,7 @@ impl Bar {
             x => BarFour::Other(x),
         }
     }
-
+    
     /// Get raw value of Four
     ///
     /// - Start bit: 10
@@ -352,34 +342,38 @@ impl Bar {
     #[inline(always)]
     pub fn four_raw(&self) -> u8 {
         let signal = u8::unpack_be_bits(&self.raw, (10 - (2 - 1)), 2);
-
+        
         signal
     }
-
+    
     /// Set value of Four
     #[inline(always)]
     pub fn set_four(&mut self, value: u8) -> Result<(), CanError> {
         #[cfg(feature = "range_checked")]
-        if value < 0_u8 || 3_u8 < value {
-            return Err(CanError::ParameterOutOfRange { message_id: 512 });
-        }
+        if value < 0_u8 || 3_u8 < value { return Err(CanError::ParameterOutOfRange{ message_id: 512 }); }
         let start_bit = 10;
         let bits = 2;
         value.pack_be_bits(&mut self.raw, start_bit, bits);
         Ok(())
     }
-
+    
     /// Five
     ///
     /// - Min: 0
     /// - Max: 1
     /// - Unit: "boolean"
     /// - Receivers: Dolor
     #[inline(always)]
-    pub fn five(&self) -> bool {
-        self.five_raw()
+    pub fn five(&self) -> BarFive {
+        match self.five_raw() {
+            false => BarFive::X0off,
+            true => BarFive::X1on,
+            false => BarFive::X2oner,
+            false => BarFive::X3onest,
+            x => BarFive::Other(x),
+        }
     }
-
+    
     /// Get raw value of Five
     ///
     /// - Start bit: 30
@@ -391,10 +385,10 @@ impl Bar {
     #[inline(always)]
     pub fn five_raw(&self) -> bool {
         let signal = u8::unpack_be_bits(&self.raw, (30 - (1 - 1)), 1);
-
+        
         signal == 1
     }
-
+    
     /// Set value of Five
     #[inline(always)]
     pub fn set_five(&mut self, value: bool) -> Result<(), CanError> {
@@ -404,16 +398,15 @@ impl Bar {
         value.pack_be_bits(&mut self.raw, start_bit, bits);
         Ok(())
     }
+    
 }
 
 impl core::convert::TryFrom<&[u8]> for Bar {
     type Error = CanError;
-
+    
     #[inline(always)]
     fn try_from(payload: &[u8]) -> Result<Self, Self::Error> {
-        if payload.len() != 8 {
-            return Err(CanError::InvalidPayloadSize);
-        }
+        if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); }
         let mut raw = [0u8; 8];
         raw.copy_from_slice(&payload[..8]);
         Ok(Self { raw })
@@ -440,6 +433,17 @@ pub enum BarFour {
     Onest,
     Other(u8),
 }
+/// Defined values for Five
+#[derive(Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+pub enum BarFive {
+    X0off,
+    X1on,
+    X2oner,
+    X3onest,
+    Other(bool),
+}
+
 
 /// This is just to make testing easier
 fn main() {}
@@ -456,3 +460,4 @@ pub enum CanError {
     },
     InvalidPayloadSize,
 }
+