Generate raw signal getters and setters

Author: felixvanoost

README.md

@@ -189,7 +189,7 @@ SG_ Type : 30|1@0+ (1,0) [0|1] "boolean" Dolor
 
 ```rust,ignore
 pub fn xtype(&self) -> BarType {
-    match self.xtype_raw() {
+    match self.xtype_phys() {
         false => BarType::X0off,
         true => BarType::X1on,
         x => BarType::_Other(x),

src/lib.rs

@@ -739,7 +739,7 @@ impl Config<'_> {
                             }
                         }
                     }
-                    writeln!(w, "_ => {type_name}::_Other(self.{fn_name}_raw()),")?;
+                    writeln!(w, "_ => {type_name}::_Other(self.{fn_name}_phys()),")?;
                 }
                 writeln!(w, "}}")?;
             }
@@ -750,30 +750,29 @@ impl Config<'_> {
             writeln!(w, "pub fn {fn_name}(&self) -> {typ} {{")?;
             {
                 let mut w = PadAdapter::wrap(w);
-                writeln!(w, "self.{fn_name}_raw()")?;
+                writeln!(w, "self.{fn_name}_phys()")?;
             }
             writeln!(w, "}}")?;
             writeln!(w)?;
         }
 
-        writeln!(w, "/// Get raw value of '{}'", signal.name)?;
+        writeln!(w, "/// Get physical value of '{}'", signal.name)?;
         writeln!(w, "///")?;
-        writeln!(w, "/// - Start bit: {}", signal.start_bit)?;
-        writeln!(w, "/// - Signal size: {} bits", signal.size)?;
         writeln!(w, "/// - Factor: {}", signal.factor)?;
         writeln!(w, "/// - Offset: {}", signal.offset)?;
-        writeln!(w, "/// - Byte order: {:?}", signal.byte_order)?;
-        writeln!(w, "/// - Value type: {:?}", signal.value_type)?;
+        writeln!(w, "/// - Unit: {:?}", signal.unit)?;
         writeln!(w, "#[inline(always)]")?;
         let typ = ValType::from_signal(signal);
-        writeln!(w, "pub fn {fn_name}_raw(&self) -> {typ} {{")?;
+        writeln!(w, "pub fn {fn_name}_phys(&self) -> {typ} {{")?;
         {
             let mut w = PadAdapter::wrap(w);
             signal_from_payload(&mut w, signal, msg).context("signal from payload")?;
         }
         writeln!(w, "}}")?;
         writeln!(w)?;
 
+        render_raw_accessors(w, signal, msg)?;
+
         self.render_set_signal(w, signal, dbc, msg)?;
 
         Ok(())
@@ -861,25 +860,24 @@ impl Config<'_> {
         dbc: &Dbc,
         msg: &Message,
     ) -> Result<()> {
-        writeln!(w, "/// Get raw value of '{}'", signal.name)?;
+        writeln!(w, "/// Get physical value of '{}'", signal.name)?;
         writeln!(w, "///")?;
-        writeln!(w, "/// - Start bit: {}", signal.start_bit)?;
-        writeln!(w, "/// - Signal size: {} bits", signal.size)?;
         writeln!(w, "/// - Factor: {}", signal.factor)?;
         writeln!(w, "/// - Offset: {}", signal.offset)?;
-        writeln!(w, "/// - Byte order: {:?}", signal.byte_order)?;
-        writeln!(w, "/// - Value type: {:?}", signal.value_type)?;
+        writeln!(w, "/// - Unit: {:?}", signal.unit)?;
         writeln!(w, "#[inline(always)]")?;
         let field = signal.field_name();
         let signal_typ = ValType::from_signal(signal);
-        writeln!(w, "pub fn {field}_raw(&self) -> {signal_typ} {{")?;
+        writeln!(w, "pub fn {field}_phys(&self) -> {signal_typ} {{")?;
         {
             let mut w = PadAdapter::wrap(w);
             signal_from_payload(&mut w, signal, msg).context("signal from payload")?;
         }
         writeln!(w, "}}")?;
         writeln!(w)?;
 
+        render_raw_accessors(w, signal, msg)?;
+
         let field = signal.field_name();
         let typ = multiplex_enum_name(msg, signal)?;
         writeln!(w, "pub fn {field}(&mut self) -> Result<{typ}, CanError> {{")?;
@@ -899,7 +897,7 @@ impl Config<'_> {
 
         {
             let mut w = PadAdapter::wrap(w);
-            writeln!(w, "match self.{}_raw() {{", signal.field_name())?;
+            writeln!(w, "match self.{}_phys() {{", signal.field_name())?;
 
             {
                 let mut w = PadAdapter::wrap(&mut w);
@@ -1198,6 +1196,14 @@ fn signal_to_payload(w: &mut impl Write, signal: &Signal, msg: &Message) -> Resu
         }
     }
 
+    pack_bits(w, signal, msg)?;
+
+    writeln!(w, "Ok(())")?;
+    Ok(())
+}
+
+/// Pack `value` into the message payload.
+fn pack_bits(w: &mut impl Write, signal: &Signal, msg: &Message) -> Result<()> {
     if signal.value_type == Signed {
         let typ = ValType::from_signal_uint(signal);
         writeln!(w, "let value = {typ}::from_ne_bytes(value.to_ne_bytes());")?;
@@ -1220,7 +1226,54 @@ fn signal_to_payload(w: &mut impl Write, signal: &Signal, msg: &Message) -> Resu
         }
     }
 
-    writeln!(w, "Ok(())")?;
+    Ok(())
+}
+
+/// Generate the raw getter and setter for a signal.
+fn render_raw_accessors(w: &mut impl Write, signal: &Signal, msg: &Message) -> Result<()> {
+    let field = signal.field_name();
+    let typ = ValType::from_signal_int(signal);
+
+    writeln!(w, "/// Get raw value of '{}'", signal.name)?;
+    writeln!(w, "///")?;
+    writeln!(w, "/// - Start bit: {}", signal.start_bit)?;
+    writeln!(w, "/// - Signal size: {} bits", signal.size)?;
+    writeln!(w, "/// - Byte order: {:?}", signal.byte_order)?;
+    writeln!(w, "/// - Value type: {:?}", signal.value_type)?;
+    writeln!(w, "#[inline(always)]")?;
+    writeln!(w, "pub fn {field}_raw(&self) -> {typ} {{")?;
+    {
+        let mut w = PadAdapter::wrap(&mut *w);
+        writeln!(w, "{}", read_fn(signal, msg)?)?;
+    }
+    writeln!(w, "}}")?;
+    writeln!(w)?;
+
+    // To avoid accidentally changing the multiplexor value without changing
+    // the signals accordingly this fn is kept private for multiplexors.
+    let visibility = if signal.multiplexer_indicator == Multiplexor {
+        ""
+    } else {
+        "pub "
+    };
+
+    writeln!(w, "/// Set raw value of '{}'", signal.name)?;
+    if visibility.is_empty() {
+        // Private multiplexor raw setters have no internal caller.
+        writeln!(w, "#[allow(dead_code)]")?;
+    }
+    writeln!(w, "#[inline(always)]")?;
+    writeln!(
+        w,
+        "{visibility}fn set_{field}_raw(&mut self, value: {typ}) {{",
+    )?;
+    {
+        let mut w = PadAdapter::wrap(&mut *w);
+        pack_bits(&mut w, signal, msg)?;
+    }
+    writeln!(w, "}}")?;
+    writeln!(w)?;
+
     Ok(())
 }
 

tests-snapshots/canpy/DBC_template.snap.rs

@@ -93,22 +93,35 @@ impl CanMultiplexed {
     pub fn raw(&self) -> &[u8; 2] {
         &self.raw
     }
+    /// Get physical value of 'Multiplexer'
+    ///
+    /// - Factor: 1
+    /// - Offset: 0
+    /// - Unit: ""
+    #[inline(always)]
+    pub fn multiplexer_phys(&self) -> u8 {
+        let signal = self.raw.view_bits::<Lsb0>()[0..8].load_le::<u8>();
+        let factor = 1;
+        u8::from(signal).saturating_mul(factor).saturating_add(0)
+    }
     /// Get raw value of 'Multiplexer'
     ///
     /// - Start bit: 0
     /// - Signal size: 8 bits
-    /// - Factor: 1
-    /// - Offset: 0
     /// - Byte order: LittleEndian
     /// - Value type: Unsigned
     #[inline(always)]
     pub fn multiplexer_raw(&self) -> u8 {
-        let signal = self.raw.view_bits::<Lsb0>()[0..8].load_le::<u8>();
-        let factor = 1;
-        u8::from(signal).saturating_mul(factor).saturating_add(0)
+        self.raw.view_bits::<Lsb0>()[0..8].load_le::<u8>()
+    }
+    /// Set raw value of 'Multiplexer'
+    #[allow(dead_code)]
+    #[inline(always)]
+    fn set_multiplexer_raw(&mut self, value: u8) {
+        self.raw.view_bits_mut::<Lsb0>()[0..8].store_le(value);
     }
     pub fn multiplexer(&mut self) -> Result<CanMultiplexedMultiplexerIndex, CanError> {
-        match self.multiplexer_raw() {
+        match self.multiplexer_phys() {
             0 => {
                 Ok(
                     CanMultiplexedMultiplexerIndex::M0(CanMultiplexedMultiplexerM0 {
@@ -321,22 +334,34 @@ impl CanMultiplexedMultiplexerM0 {
             2 => CanMultiplexedValue0::Value2,
             1 => CanMultiplexedValue0::Value1,
             0 => CanMultiplexedValue0::Value0,
-            _ => CanMultiplexedValue0::_Other(self.value0_raw()),
+            _ => CanMultiplexedValue0::_Other(self.value0_phys()),
         }
     }
+    /// Get physical value of 'Value0'
+    ///
+    /// - Factor: 1
+    /// - Offset: 0
+    /// - Unit: ""
+    #[inline(always)]
+    pub fn value0_phys(&self) -> u8 {
+        let signal = self.raw.view_bits::<Lsb0>()[8..16].load_le::<u8>();
+        let factor = 1;
+        u8::from(signal).saturating_mul(factor).saturating_add(0)
+    }
     /// Get raw value of 'Value0'
     ///
     /// - Start bit: 8
     /// - Signal size: 8 bits
-    /// - Factor: 1
-    /// - Offset: 0
     /// - Byte order: LittleEndian
     /// - Value type: Unsigned
     #[inline(always)]
     pub fn value0_raw(&self) -> u8 {
-        let signal = self.raw.view_bits::<Lsb0>()[8..16].load_le::<u8>();
-        let factor = 1;
-        u8::from(signal).saturating_mul(factor).saturating_add(0)
+        self.raw.view_bits::<Lsb0>()[8..16].load_le::<u8>()
+    }
+    /// Set raw value of 'Value0'
+    #[inline(always)]
+    pub fn set_value0_raw(&mut self, value: u8) {
+        self.raw.view_bits_mut::<Lsb0>()[8..16].store_le(value);
     }
     /// Set value of 'Value0'
     #[inline(always)]
@@ -398,22 +423,34 @@ impl CanMultiplexedMultiplexerM1 {
             2 => CanMultiplexedValue1::Two,
             1 => CanMultiplexedValue1::One,
             0 => CanMultiplexedValue1::Zero,
-            _ => CanMultiplexedValue1::_Other(self.value1_raw()),
+            _ => CanMultiplexedValue1::_Other(self.value1_phys()),
         }
     }
+    /// Get physical value of 'Value1'
+    ///
+    /// - Factor: 1
+    /// - Offset: 0
+    /// - Unit: ""
+    #[inline(always)]
+    pub fn value1_phys(&self) -> u8 {
+        let signal = self.raw.view_bits::<Lsb0>()[8..16].load_le::<u8>();
+        let factor = 1;
+        u8::from(signal).saturating_mul(factor).saturating_add(0)
+    }
     /// Get raw value of 'Value1'
     ///
     /// - Start bit: 8
     /// - Signal size: 8 bits
-    /// - Factor: 1
-    /// - Offset: 0
     /// - Byte order: LittleEndian
     /// - Value type: Unsigned
     #[inline(always)]
     pub fn value1_raw(&self) -> u8 {
-        let signal = self.raw.view_bits::<Lsb0>()[8..16].load_le::<u8>();
-        let factor = 1;
-        u8::from(signal).saturating_mul(factor).saturating_add(0)
+        self.raw.view_bits::<Lsb0>()[8..16].load_le::<u8>()
+    }
+    /// Set raw value of 'Value1'
+    #[inline(always)]
+    pub fn set_value1_raw(&mut self, value: u8) {
+        self.raw.view_bits_mut::<Lsb0>()[8..16].store_le(value);
     }
     /// Set value of 'Value1'
     #[inline(always)]
@@ -481,22 +518,34 @@ impl CanMessage {
     /// - Receivers: Node1, Node2
     #[inline(always)]
     pub fn signal1(&self) -> u64 {
-        self.signal1_raw()
+        self.signal1_phys()
     }
-    /// Get raw value of 'Signal1'
+    /// Get physical value of 'Signal1'
     ///
-    /// - Start bit: 32
-    /// - Signal size: 32 bits
     /// - Factor: 100
     /// - Offset: 0
-    /// - Byte order: LittleEndian
-    /// - Value type: Unsigned
+    /// - Unit: "%"
     #[inline(always)]
-    pub fn signal1_raw(&self) -> u64 {
+    pub fn signal1_phys(&self) -> u64 {
         let signal = self.raw.view_bits::<Lsb0>()[32..64].load_le::<u32>();
         let factor = 100;
         u64::from(signal).saturating_mul(factor).saturating_add(0)
     }
+    /// Get raw value of 'Signal1'
+    ///
+    /// - Start bit: 32
+    /// - Signal size: 32 bits
+    /// - Byte order: LittleEndian
+    /// - Value type: Unsigned
+    #[inline(always)]
+    pub fn signal1_raw(&self) -> u32 {
+        self.raw.view_bits::<Lsb0>()[32..64].load_le::<u32>()
+    }
+    /// Set raw value of 'Signal1'
+    #[inline(always)]
+    pub fn set_signal1_raw(&mut self, value: u32) {
+        self.raw.view_bits_mut::<Lsb0>()[32..64].store_le(value);
+    }
     /// Set value of 'Signal1'
     #[inline(always)]
     pub fn set_signal1(&mut self, value: u64) -> Result<(), CanError> {
@@ -525,23 +574,36 @@ impl CanMessage {
     /// - Receivers: Node1, Node2
     #[inline(always)]
     pub fn signal0(&self) -> i32 {
-        self.signal0_raw()
+        self.signal0_phys()
     }
-    /// Get raw value of 'Signal0'
+    /// Get physical value of 'Signal0'
     ///
-    /// - Start bit: 0
-    /// - Signal size: 32 bits
     /// - Factor: 1
     /// - Offset: 0
-    /// - Byte order: LittleEndian
-    /// - Value type: Signed
+    /// - Unit: ""
     #[inline(always)]
-    pub fn signal0_raw(&self) -> i32 {
+    pub fn signal0_phys(&self) -> i32 {
         let signal = self.raw.view_bits::<Lsb0>()[0..32].load_le::<i32>();
         let factor = 1;
         let signal = signal as i32;
         i32::from(signal).saturating_mul(factor).saturating_add(0)
     }
+    /// Get raw value of 'Signal0'
+    ///
+    /// - Start bit: 0
+    /// - Signal size: 32 bits
+    /// - Byte order: LittleEndian
+    /// - Value type: Signed
+    #[inline(always)]
+    pub fn signal0_raw(&self) -> i32 {
+        self.raw.view_bits::<Lsb0>()[0..32].load_le::<i32>()
+    }
+    /// Set raw value of 'Signal0'
+    #[inline(always)]
+    pub fn set_signal0_raw(&mut self, value: i32) {
+        let value = u32::from_ne_bytes(value.to_ne_bytes());
+        self.raw.view_bits_mut::<Lsb0>()[0..32].store_le(value);
+    }
     /// Set value of 'Signal0'
     #[inline(always)]
     pub fn set_signal0(&mut self, value: i32) -> Result<(), CanError> {