Add many more test cases

src/diagnostic.rs

@@ -203,6 +203,28 @@ mod tests {
 
     #[test]
     fn diagnostic_1_message_4() {
+        let diagnostic_message =
+            Diagnostic1Message::from_pdu(&[0x00, 0xFF, 0x00, 0x00, 0x00, 0x00]);
+
+        assert_eq!(diagnostic_message.protect_lamp, Some(LampStatus::Off));
+        assert_eq!(diagnostic_message.amber_warning_lamp, Some(LampStatus::Off));
+        assert_eq!(diagnostic_message.red_stop_lamp, Some(LampStatus::Off));
+        assert_eq!(
+            diagnostic_message.malfunction_indicator_lamp,
+            Some(LampStatus::Off)
+        );
+        assert_eq!(diagnostic_message.protect_lamp_flash, None);
+        assert_eq!(diagnostic_message.amber_warning_lamp_flash, None);
+        assert_eq!(diagnostic_message.red_stop_lamp_flash, None);
+        assert_eq!(diagnostic_message.malfunction_indicator_lamp_flash, None);
+        assert_eq!(diagnostic_message.suspect_parameter_number, 0);
+        assert_eq!(diagnostic_message.failure_mode_identifier, 0);
+        assert_eq!(diagnostic_message.spn_conversion_method, 0);
+        assert_eq!(diagnostic_message.occurrence_count, 0);
+    }
+
+    #[test]
+    fn diagnostic_1_message_5() {
         let diagnostic_message_encoded = Diagnostic1Message {
             protect_lamp: Some(LampStatus::Off),
             amber_warning_lamp: Some(LampStatus::Off),
@@ -226,7 +248,7 @@ mod tests {
     }
 
     #[test]
-    fn diagnostic_1_message_5() {
+    fn diagnostic_1_message_6() {
         let diagnostic_message_encoded = Diagnostic1Message {
             protect_lamp: Some(LampStatus::On),
             amber_warning_lamp: Some(LampStatus::Off),

src/pgn.rs

@@ -69,6 +69,8 @@ pub enum PGN {
     DiagnosticMessage12,
     /// SOFT - Software Identification.
     SoftwareIdentification,
+    /// EFL/P2 - Engine Fluid Level/Pressure 2.
+    EngineFluidLevelPressure2,
     /// IO - Idle Operation.
     IdleOperation,
     /// RQST - Request.
@@ -224,6 +226,7 @@ impl From<u32> for PGN {
             65_240 => PGN::CommandedAddress,
             65_241 => PGN::AuxiliaryInputOutputStatus,
             65_242 => PGN::SoftwareIdentification,
+            65_243 => PGN::EngineFluidLevelPressure2,
             65_244 => PGN::IdleOperation,
             65_247 => PGN::ElectronicEngineController3,
             65_248 => PGN::VehicleDistance,
@@ -307,6 +310,7 @@ impl From<PGN> for u32 {
             PGN::CommandedAddress => 65_240,
             PGN::AuxiliaryInputOutputStatus => 65_241,
             PGN::SoftwareIdentification => 65_242,
+            PGN::EngineFluidLevelPressure2 => 65_243,
             PGN::IdleOperation => 65_244,
             PGN::ElectronicEngineController3 => 65_247,
             PGN::VehicleDistance => 65_248,

src/slots.rs

@@ -359,6 +359,29 @@ pub mod pressure4 {
     }
 }
 
+pub mod pressure5 {
+    const RESOLUTION: super::Param = super::Param {
+        scale: 1.0 / 256.0,
+        offset: 0.0,
+        limit_lower: 0.0,
+        limit_upper: 251.0,
+    };
+
+    pub fn dec(value: [u8; 2]) -> Option<u16> {
+        if value == [crate::PDU_NOT_AVAILABLE; 2] {
+            return None;
+        }
+
+        Some(RESOLUTION.dec(u16::from_le_bytes(value) as f32) as u16)
+    }
+
+    pub fn enc(value: Option<u16>) -> [u8; 2] {
+        value.map_or([crate::PDU_NOT_AVAILABLE; 2], |v| {
+            (RESOLUTION.enc(v as f32) as u16).to_le_bytes()
+        })
+    }
+}
+
 pub mod liquid_fuel_usage {
     const RESOLUTION: super::Param = super::Param {
         scale: 0.5,

src/spn.rs

@@ -488,7 +488,6 @@ impl core::fmt::Display for TorqueSpeedControl1Message {
 // Ambient Conditions
 //
 
-// TODO: Not tested
 pub struct AmbientConditionsMessage {
     /// Barometric pressure.
     pub barometric_pressure: Option<u8>,
@@ -732,7 +731,6 @@ impl core::fmt::Display for FuelEconomyMessage {
 // Engine Fluid Level/Pressure 1
 //
 
-// TODO: Not tested
 pub struct EngineFluidLevelPressure1Message {
     /// Gage pressure of fuel in system as delivered from supply pump to the injection pump.
     pub fuel_delivery_pressure: Option<u8>,
@@ -1645,6 +1643,63 @@ impl core::fmt::Display for VehicleElectricalPowerMessage {
     }
 }
 
+//
+// Engine Fluid Level/Pressure 2
+//
+
+// TODO: Not tested
+pub struct EngineFluidLevelPressure2Message {
+    /// The gage pressure of the engine oil in the hydraulic accumulator that powers an
+    /// intensifier used for fuel injection.
+    pub injection_control_pressure: Option<u16>,
+    /// The gage pressure of fuel in the primary, or first, metering rail as
+    /// delivered from the supply pump to the injector metering inlet.
+    pub injector_metering_rail1_pressure: Option<u16>,
+    /// The gage pressure of fuel in the timing rail delivered from the supply pump
+    /// to the injector timing inlet.
+    pub injector_timing_rail1_pressure: Option<u16>,
+    /// The gage pressure of fuel in the metering rail #2 as delivered from the
+    /// supply pump to the injector metering inlet.
+    pub injector_metering_rail2_pressure: Option<u16>,
+}
+
+impl EngineFluidLevelPressure2Message {
+    pub fn from_pdu(pdu: &[u8]) -> Self {
+        Self {
+            injection_control_pressure: slots::pressure5::dec([pdu[0], pdu[1]]),
+            injector_metering_rail1_pressure: slots::pressure5::dec([pdu[2], pdu[3]]),
+            injector_timing_rail1_pressure: slots::pressure5::dec([pdu[4], pdu[5]]),
+            injector_metering_rail2_pressure: slots::pressure5::dec([pdu[6], pdu[7]]),
+        }
+    }
+
+    pub fn to_pdu(&self) -> [u8; 8] {
+        [
+            slots::pressure5::enc(self.injection_control_pressure)[0],
+            slots::pressure5::enc(self.injection_control_pressure)[1],
+            slots::pressure5::enc(self.injector_metering_rail1_pressure)[0],
+            slots::pressure5::enc(self.injector_metering_rail1_pressure)[1],
+            slots::pressure5::enc(self.injector_timing_rail1_pressure)[0],
+            slots::pressure5::enc(self.injector_timing_rail1_pressure)[1],
+            slots::pressure5::enc(self.injector_metering_rail2_pressure)[0],
+            slots::pressure5::enc(self.injector_metering_rail2_pressure)[1],
+        ]
+    }
+}
+
+impl core::fmt::Display for EngineFluidLevelPressure2Message {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(
+            f,
+            "Injection control pressure: {} MPa; Injector metering rail 1 pressure: {} MPa; Injector timing rail 1 pressure: {} MPa; Injector metering rail 2 pressure: {} MPa",
+            self.injection_control_pressure.unwrap_or(0),
+            self.injector_metering_rail1_pressure.unwrap_or(0),
+            self.injector_timing_rail1_pressure.unwrap_or(0),
+            self.injector_metering_rail2_pressure.unwrap_or(0)
+        )
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1757,6 +1812,45 @@ mod tests {
         );
     }
 
+    #[test]
+    fn electronic_engine_controller_3_message_1() {
+        let engine_message = ElectronicEngineController3Message::from_pdu(&[
+            0xFF, 0x00, 0x00, 0xC0, 0x5D, 0x40, 0x00, 0x00,
+        ]);
+
+        assert_eq!(engine_message.nominal_friction_percent_torque, None);
+        assert_eq!(engine_message.engines_desired_operating_speed, Some(0));
+        assert_eq!(
+            engine_message.engines_desired_operating_speed_asymmetry_adjustment,
+            Some(192)
+        );
+    }
+
+    #[test]
+    fn electronic_engine_controller_3_message_2() {
+        let engine_message_encoded = ElectronicEngineController3Message {
+            nominal_friction_percent_torque: Some(50),
+            engines_desired_operating_speed: Some(3632),
+            engines_desired_operating_speed_asymmetry_adjustment: Some(23),
+        }
+        .to_pdu();
+        let engine_message_decoded =
+            ElectronicEngineController3Message::from_pdu(&engine_message_encoded);
+
+        assert_eq!(
+            engine_message_decoded.nominal_friction_percent_torque,
+            Some(50)
+        );
+        assert_eq!(
+            engine_message_decoded.engines_desired_operating_speed,
+            Some(3632)
+        );
+        assert_eq!(
+            engine_message_decoded.engines_desired_operating_speed_asymmetry_adjustment,
+            Some(23)
+        );
+    }
+
     #[test]
     fn torque_speed_control_1_message_1() {
         let torque_speed_encoded = TorqueSpeedControl1Message {
@@ -1815,6 +1909,61 @@ mod tests {
         assert_eq!(torque_speed_decoded.torque, None);
     }
 
+    #[test]
+    fn ambient_conditions_message_1() {
+        let engine_temperature =
+            AmbientConditionsMessage::from_pdu(&[0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0x35, 0xFF, 0xFF]);
+
+        assert_eq!(engine_temperature.barometric_pressure, Some(96));
+        assert_eq!(engine_temperature.cab_interior_temperature, None);
+        assert_eq!(engine_temperature.ambient_air_temperature, None);
+        assert_eq!(engine_temperature.air_inlet_temperature, Some(13));
+        assert_eq!(engine_temperature.road_surface_temperature, None);
+    }
+
+    #[test]
+    fn engine_fluid_level_pressure_1_message_1() {
+        let engine_fluid_level_pressure = EngineFluidLevelPressure1Message::from_pdu(&[
+            0x1A, 0xFF, 0xFF, 0x01, 0xFF, 0xFF, 0x00, 0x00,
+        ]);
+
+        assert_eq!(
+            engine_fluid_level_pressure.fuel_delivery_pressure,
+            Some(104)
+        );
+        assert_eq!(
+            engine_fluid_level_pressure.extended_crankcase_blow_by_pressure,
+            None
+        );
+        assert_eq!(engine_fluid_level_pressure.engine_oil_level, None);
+        assert_eq!(engine_fluid_level_pressure.engine_oil_pressure, Some(4));
+        assert_eq!(engine_fluid_level_pressure.crankcase_pressure, None);
+        assert_eq!(engine_fluid_level_pressure.coolant_pressure, Some(0));
+        assert_eq!(engine_fluid_level_pressure.coolant_level, Some(0));
+    }
+
+    #[test]
+    fn fuel_consumption_message_1() {
+        let fuel_consumption =
+            FuelConsumptionMessage::from_pdu(&[0xFA, 0xD8, 0x02, 0x00, 0xFA, 0xD8, 0x02, 0x00]);
+
+        assert_eq!(fuel_consumption.trip_fuel, Some(93309));
+        assert_eq!(fuel_consumption.total_fuel_used, Some(93309));
+    }
+
+    #[test]
+    fn fuel_consumption_message_2() {
+        let fuel_consumption_encoded = FuelConsumptionMessage {
+            trip_fuel: Some(1234),
+            total_fuel_used: Some(56),
+        }
+        .to_pdu();
+        let fuel_consumption_decoded = FuelConsumptionMessage::from_pdu(&fuel_consumption_encoded);
+
+        assert_eq!(fuel_consumption_decoded.trip_fuel, Some(1234));
+        assert_eq!(fuel_consumption_decoded.total_fuel_used, Some(56));
+    }
+
     #[test]
     fn fan_drive_message_1() {
         let fan_drive_encoded = FanDriveMessage {
@@ -1850,6 +1999,49 @@ mod tests {
         assert_eq!(fan_drive_decoded.fan_speed, None);
     }
 
+    #[test]
+    fn engine_temperature_1_message_1() {
+        let engine_temperature =
+            EngineTemperature1Message::from_pdu(&[0x42, 0x3B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]);
+
+        assert_eq!(engine_temperature.engine_coolant_temperature, Some(26));
+        assert_eq!(engine_temperature.fuel_temperature, Some(19));
+        assert_eq!(engine_temperature.engine_oil_temperature, None);
+        assert_eq!(engine_temperature.turbo_oil_temperature, None);
+        assert_eq!(engine_temperature.engine_intercooler_temperature, None);
+        assert_eq!(
+            engine_temperature.engine_intercooler_thermostat_opening,
+            None
+        );
+    }
+
+    #[test]
+    fn inlet_exhaust_conditions_1_message_1() {
+        let inlet_exhaust_conditions = InletExhaustConditions1Message::from_pdu(&[
+            0xD4, 0x30, 0x3E, 0x32, 0x41, 0x0B, 0x0A, 0x00,
+        ]);
+
+        assert_eq!(
+            inlet_exhaust_conditions.particulate_trap_inlet_pressure,
+            None
+        );
+        assert_eq!(inlet_exhaust_conditions.boost_pressure, Some(96));
+        assert_eq!(
+            inlet_exhaust_conditions.intake_manifold_temperature,
+            Some(22)
+        );
+        assert_eq!(inlet_exhaust_conditions.air_inlet_pressure, Some(100));
+        assert_eq!(
+            inlet_exhaust_conditions.air_filter_differential_pressure,
+            Some(3)
+        );
+        assert_eq!(inlet_exhaust_conditions.exhaust_gas_temperature, Some(-192));
+        assert_eq!(
+            inlet_exhaust_conditions.coolant_filter_differential_pressure,
+            None
+        );
+    }
+
     #[test]
     fn electronic_brake_controller_1_message_1() {
         let brake_message_encoded = ElectronicBrakeController1Message {
@@ -2014,4 +2206,34 @@ mod tests {
             Some(947)
         );
     }
+
+    #[test]
+    fn engine_fluid_level_pressure_2_message_1() {
+        let engine_fluid_message_encoded = EngineFluidLevelPressure2Message {
+            injection_control_pressure: Some(6),
+            injector_metering_rail1_pressure: Some(81),
+            injector_timing_rail1_pressure: None,
+            injector_metering_rail2_pressure: Some(241),
+        }
+        .to_pdu();
+        let engine_fluid_message_decoded =
+            EngineFluidLevelPressure2Message::from_pdu(&engine_fluid_message_encoded);
+
+        assert_eq!(
+            engine_fluid_message_decoded.injection_control_pressure,
+            Some(6)
+        );
+        assert_eq!(
+            engine_fluid_message_decoded.injector_metering_rail1_pressure,
+            Some(81)
+        );
+        assert_eq!(
+            engine_fluid_message_decoded.injector_timing_rail1_pressure,
+            None
+        );
+        assert_eq!(
+            engine_fluid_message_decoded.injector_metering_rail2_pressure,
+            Some(241)
+        );
+    }
 }