f64->f32

Our ARM target doesn't have double precision floats in hardware.

Author: Pascal Hertleif

src/main.rs

@@ -292,7 +292,7 @@ fn render_signal(mut w: impl Write, signal: &Signal, dbc: &DBC, msg: &Message) -
         let type_name = enum_name(msg, signal);
         let match_on_raw_type = match signal_to_rust_type(signal).as_str() {
             "bool" => |x: f64| format!("{}", (x as i64) == 1),
-            "f64" => |x: f64| format!("{}", x),
+            "f32" => |x: f64| format!("{}", x),
             _ => |x: f64| format!("{}", x as i64),
         };
 
@@ -395,9 +395,9 @@ fn signal_from_payload(mut w: impl Write, signal: &Signal) -> Result<()> {
         writeln!(&mut w, "signal == 1")?;
     } else if signal_is_float_in_rust(signal) {
         // Scaling is always done on floats
-        writeln!(&mut w, "let factor = {}_f64;", signal.factor)?;
-        writeln!(&mut w, "let offset = {}_f64;", signal.offset)?;
-        writeln!(&mut w, "(signal as f64) * factor + offset")?;
+        writeln!(&mut w, "let factor = {}_f32;", signal.factor)?;
+        writeln!(&mut w, "let offset = {}_f32;", signal.offset)?;
+        writeln!(&mut w, "(signal as f32) * factor + offset")?;
     } else {
         writeln!(&mut w, "signal")?;
     }
@@ -410,8 +410,8 @@ fn signal_to_payload(mut w: impl Write, signal: &Signal) -> Result<()> {
         writeln!(&mut w, "let value = value as u8;")?;
     } else if signal_is_float_in_rust(signal) {
         // Massage value into an int
-        writeln!(&mut w, "let factor = {}_f64;", signal.factor)?;
-        writeln!(&mut w, "let offset = {}_f64;", signal.offset)?;
+        writeln!(&mut w, "let factor = {}_f32;", signal.factor)?;
+        writeln!(&mut w, "let offset = {}_f32;", signal.offset)?;
         writeln!(
             &mut w,
             "let value = ((value - offset) / factor) as {};",
@@ -483,8 +483,8 @@ fn signal_to_rust_type(signal: &Signal) -> String {
     if signal.signal_size == 1 {
         String::from("bool")
     } else if signal_is_float_in_rust(signal) {
-        // If there is any scaling needed, go for double precision
-        String::from("f64")
+        // If there is any scaling needed, go for float
+        String::from("f32")
     } else {
         signal_to_rust_int(signal)
     }

testing/can-messages/src/messages.rs

@@ -48,7 +48,7 @@ impl Foo {
     pub const MESSAGE_ID: u32 = 256;
 
     /// Construct new Foo from values
-    pub fn new(voltage: f64, current: f64) -> Result<Self, CanError> {
+    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)?;
@@ -62,7 +62,7 @@ impl Foo {
     /// - Unit: "V"
     /// - Receivers: Vector__XXX
     #[inline(always)]
-    pub fn voltage(&self) -> f64 {
+    pub fn voltage(&self) -> f32 {
         self.voltage_raw()
     }
 
@@ -75,19 +75,19 @@ impl Foo {
     /// - Byte order: LittleEndian
     /// - Value type: Unsigned
     #[inline(always)]
-    pub fn voltage_raw(&self) -> f64 {
+    pub fn voltage_raw(&self) -> f32 {
         let signal = u16::unpack_le_bits(&self.raw, 16, 16);
 
-        let factor = 0.000976562_f64;
-        let offset = 0_f64;
-        (signal as f64) * factor + offset
+        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: f64) -> Result<(), CanError> {
-        let factor = 0.000976562_f64;
-        let offset = 0_f64;
+    pub fn set_voltage(&mut self, value: f32) -> Result<(), CanError> {
+        let factor = 0.000976562_f32;
+        let offset = 0_f32;
         let value = ((value - offset) / factor) as u16;
 
         let start_bit = 16;
@@ -103,7 +103,7 @@ impl Foo {
     /// - Unit: "A"
     /// - Receivers: Vector__XXX
     #[inline(always)]
-    pub fn current(&self) -> f64 {
+    pub fn current(&self) -> f32 {
         self.current_raw()
     }
 
@@ -116,19 +116,19 @@ impl Foo {
     /// - Byte order: LittleEndian
     /// - Value type: Signed
     #[inline(always)]
-    pub fn current_raw(&self) -> f64 {
+    pub fn current_raw(&self) -> f32 {
         let signal = i16::unpack_le_bits(&self.raw, 0, 16);
 
-        let factor = 0.0625_f64;
-        let offset = 0_f64;
-        (signal as f64) * factor + offset
+        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: f64) -> Result<(), CanError> {
-        let factor = 0.0625_f64;
-        let offset = 0_f64;
+    pub fn set_current(&mut self, value: f32) -> Result<(), CanError> {
+        let factor = 0.0625_f32;
+        let offset = 0_f32;
         let value = ((value - offset) / factor) as i16;
 
         let start_bit = 0;
@@ -167,7 +167,7 @@ impl Bar {
     pub const MESSAGE_ID: u32 = 512;
 
     /// Construct new Bar from values
-    pub fn new(one: u8, two: f64, three: u8, four: u8) -> Result<Self, CanError> {
+    pub fn new(one: u8, two: f32, three: u8, four: u8) -> Result<Self, CanError> {
         let mut res = Self { raw: [0u8; 8] };
         res.set_one(one)?;
         res.set_two(two)?;
@@ -218,7 +218,7 @@ impl Bar {
     /// - Unit: "%"
     /// - Receivers: Dolor
     #[inline(always)]
-    pub fn two(&self) -> f64 {
+    pub fn two(&self) -> f32 {
         self.two_raw()
     }
 
@@ -231,19 +231,19 @@ impl Bar {
     /// - Byte order: BigEndian
     /// - Value type: Unsigned
     #[inline(always)]
-    pub fn two_raw(&self) -> f64 {
+    pub fn two_raw(&self) -> f32 {
         let signal = u8::unpack_be_bits(&self.raw, (7 - (8 - 1)), 8);
 
-        let factor = 0.39_f64;
-        let offset = 0_f64;
-        (signal as f64) * factor + offset
+        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: f64) -> Result<(), CanError> {
-        let factor = 0.39_f64;
-        let offset = 0_f64;
+    pub fn set_two(&mut self, value: f32) -> Result<(), CanError> {
+        let factor = 0.39_f32;
+        let offset = 0_f32;
         let value = ((value - offset) / factor) as u8;
 
         let start_bit = 7;

testing/rust-integration/tests/compare_to_socketcan.rs

@@ -6,17 +6,17 @@ fn simple_byte_aligned_message() {
     let (_, payload) = parse_canframe("100#20000008");
     let msg = messages::Foo::try_from(payload.as_slice()).unwrap();
 
-    assert_f64_eq(msg.voltage(), 2_f64);
-    assert_f64_eq(msg.current(), 2_f64);
+    assert_f32_eq(msg.voltage(), 2_f32);
+    assert_f32_eq(msg.current(), 2_f32);
 }
 
 #[test]
 fn another_simple_byte_aligned_message() {
     let (_, payload) = parse_canframe("100#D500AEA9");
     let msg = messages::Foo::try_from(payload.as_slice()).unwrap();
 
-    assert_f64_eq(msg.voltage(), 42.42_f64);
-    assert_f64_eq(msg.current(), 13.37_f64);
+    assert_f32_eq(msg.voltage(), 42.42_f32);
+    assert_f32_eq(msg.current(), 13.37_f32);
 }
 
 #[test]
@@ -25,7 +25,7 @@ fn weirdly_aligned_bigendian_message_1() {
     let msg = messages::Bar::try_from(payload.as_slice()).unwrap();
 
     assert_eq!(msg.one(), 2);
-    assert_f64_eq(msg.two(), 2_f64);
+    assert_f32_eq(msg.two(), 2_f32);
     assert_eq!(msg.three(), 2);
     assert!(matches!(msg.four(), messages::BarFour::Oner));
 }
@@ -36,7 +36,7 @@ fn weirdly_aligned_bigendian_message_2() {
     let msg = messages::Bar::try_from(payload.as_slice()).unwrap();
 
     assert_eq!(msg.one(), 1);
-    assert_f64_eq(msg.two(), 2_f64);
+    assert_f32_eq(msg.two(), 2_f32);
     assert_eq!(msg.three(), 3);
     assert!(matches!(msg.four(), messages::BarFour::On));
 }
@@ -55,6 +55,6 @@ fn parse_canframe(candump_line: &str) -> (u32, Vec<u8>) {
     (id, payload)
 }
 
-fn assert_f64_eq(a: f64, b: f64) {
+fn assert_f32_eq(a: f32, b: f32) {
     let _ = approx::abs_diff_eq!(a, b);
 }