From a36a8614da0f5dcc0c4884b1f220d92e7f3d818d Mon Sep 17 00:00:00 2001 From: kifir Date: Fri, 22 Nov 2024 17:03:47 +0200 Subject: [PATCH] implement `FuelDifferentialPressureTest` (closes #6972) --- .../algo/engine_configuration_defaults.h | 6 + .../test_fuel_differential_pressure.cpp | 188 ++++++++++++++++++ unit_tests/tests/tests.mk | 1 + unit_tests/tests/util/engine_config.cpp | 27 +++ unit_tests/tests/util/engine_config.h | 18 ++ unit_tests/tests/util/test_base.cpp | 10 + unit_tests/tests/util/test_base.h | 6 + .../tests/util/test_engine_configuration.cpp | 63 ++++++ .../tests/util/test_engine_configuration.h | 8 + 9 files changed, 327 insertions(+) create mode 100644 unit_tests/tests/ignition_injection/test_fuel_differential_pressure.cpp diff --git a/firmware/controllers/algo/engine_configuration_defaults.h b/firmware/controllers/algo/engine_configuration_defaults.h index b35a96f2bd..8e096e31c5 100644 --- a/firmware/controllers/algo/engine_configuration_defaults.h +++ b/firmware/controllers/algo/engine_configuration_defaults.h @@ -31,14 +31,20 @@ namespace engine_configuration_defaults { constexpr launchActivationMode_e LAUNCH_ACTIVATION_MODE = SWITCH_INPUT_LAUNCH; constexpr int LAUNCH_SPEED_THRESHOLD = 0; + constexpr fuel_pressure_sensor_mode_e FUEL_PRESSURE_SENSOR_MODE = FPM_Absolute; + /* Injector */ constexpr bool INJECTOR_FLOW_AS_MASS_FLOW = false; constexpr float INJECTOR_FLOW = 200.0f; constexpr BattLagCorrCurve INJECTOR_BATT_LAG_CURR { 3.371f, 1.974f, 1.383f, 1.194f, 1.04f, 0.914f, 0.797f, 0.726 }; + constexpr float FUEL_REFERENCE_PRESSURE = 300.0f; + constexpr injector_compensation_mode_e INJECTOR_COMPENSATION_MODE = ICM_None; /* Secondary injector: */ constexpr float INJECTOR_SECONDARY_FLOW = INJECTOR_FLOW; constexpr BattLagCorrCurve INJECTOR_SECONDARY_BATT_LAG_CURR = INJECTOR_BATT_LAG_CURR; + constexpr float SECONDARY_INJECTOR_FUEL_REFERENCE_PRESSURE = 0.0f; + constexpr injector_compensation_mode_e SECONDARY_INJECTOR_COMPENSATION_MODE = INJECTOR_COMPENSATION_MODE; /* Staged injection: */ constexpr bool ENABLE_STAGED_INJECTION = false; diff --git a/unit_tests/tests/ignition_injection/test_fuel_differential_pressure.cpp b/unit_tests/tests/ignition_injection/test_fuel_differential_pressure.cpp new file mode 100644 index 0000000000..4962126010 --- /dev/null +++ b/unit_tests/tests/ignition_injection/test_fuel_differential_pressure.cpp @@ -0,0 +1,188 @@ +// +// Created by kifir on 11/21/24. +// + +#include "pch.h" + +#include "util/test_base.h" + +namespace { + constexpr float TEST_PRIMARY_INJECTOR_FUEL_REFERENCE_PRESSURE = 5423.1f; + constexpr float TEST_SECONDARY_INJECTOR_FUEL_REFERENCE_PRESSURE = 678.9f; + constexpr float TEST_MAP = 78.9f; + constexpr float TEST_BAROMETRIC_PRESSURE = 67.8f; + constexpr float TEST_FUEL_PRESSURE_INJECTOR = 76.5f; + + constexpr float TEST_PRIMARY_INJECTOR_FIXED_RAIL_FUEL_DIFFERENTIAL_PRESSURE + = TEST_PRIMARY_INJECTOR_FUEL_REFERENCE_PRESSURE + TEST_BAROMETRIC_PRESSURE - TEST_MAP; + constexpr float TEST_SECONDARY_INJECTOR_FIXED_RAIL_FUEL_DIFFERENTIAL_PRESSURE + = TEST_SECONDARY_INJECTOR_FUEL_REFERENCE_PRESSURE + TEST_BAROMETRIC_PRESSURE - TEST_MAP; + constexpr float TEST_SENSED_RAIL_ABSOLUTE_FUEL_DIFFERENTIAL_PRESSURE + = TEST_FUEL_PRESSURE_INJECTOR - TEST_MAP; + constexpr float TEST_SENSED_RAIL_GAUGE_FUEL_DIFFERENTIAL_PRESSURE + = TEST_FUEL_PRESSURE_INJECTOR + TEST_BAROMETRIC_PRESSURE - TEST_MAP; + + const EngineConfig TEST_ENGINE_CONFIG = EngineConfig() + .setFuelReferencePressure(TEST_PRIMARY_INJECTOR_FUEL_REFERENCE_PRESSURE) + .setSecondaryInjectorFuelReferencePressure(TEST_SECONDARY_INJECTOR_FUEL_REFERENCE_PRESSURE); + + class FuelDifferentialPressureTest : public TestBase { + protected: + void SetUp() override; + + void checkFuelDifferrentialPressure( + const EngineConfig& engineConfig, + std::optional primaryInjectorFuelDifferentialPressure, + std::optional secondaryInjectorFuelDifferentialPressure, + const char* context + ); + private: + expected getPrimaryInjectorFuelDifferentialPressure(); + expected getSecondaryInjectorFuelDifferentialPressure(); + }; + + void FuelDifferentialPressureTest::SetUp(){ + TestBase::SetUp(); + + Sensor::setMockValue(SensorType::Map, TEST_MAP); + Sensor::setMockValue(SensorType::BarometricPressure, TEST_BAROMETRIC_PRESSURE); + Sensor::setMockValue(SensorType::FuelPressureInjector, TEST_FUEL_PRESSURE_INJECTOR); + } + + void FuelDifferentialPressureTest::checkFuelDifferrentialPressure( + const EngineConfig& engineConfig, + const std::optional expectedPrimaryInjectorFuelDifferentialPressure, + const std::optional expectedSecondaryInjectorFuelDifferentialPressure, + const char* const context + ) { + setUpEngineConfiguration(engineConfig); + constexpr float INVALID_PRESSURE = -1.0f; + if (expectedPrimaryInjectorFuelDifferentialPressure.has_value()) { + EXPECT_NE(expectedPrimaryInjectorFuelDifferentialPressure, INVALID_PRESSURE) << context; + EXPECT_NEAR( + expectedPrimaryInjectorFuelDifferentialPressure.value(), + getPrimaryInjectorFuelDifferentialPressure().value_or(INVALID_PRESSURE), + EPS5D + ) << context; + } else { + EXPECT_FALSE(getPrimaryInjectorFuelDifferentialPressure().Valid); + } + if (expectedSecondaryInjectorFuelDifferentialPressure.has_value()) { + EXPECT_NE(expectedSecondaryInjectorFuelDifferentialPressure.value(), INVALID_PRESSURE) << context; + EXPECT_NEAR( + expectedSecondaryInjectorFuelDifferentialPressure.value(), + getSecondaryInjectorFuelDifferentialPressure().value_or(INVALID_PRESSURE), + EPS5D + ) << context; + } else { + EXPECT_FALSE(getSecondaryInjectorFuelDifferentialPressure().Valid); + } + } + + expected FuelDifferentialPressureTest::getPrimaryInjectorFuelDifferentialPressure() { + return getModule().getFuelDifferentialPressure(); + } + + expected FuelDifferentialPressureTest::getSecondaryInjectorFuelDifferentialPressure() { + return getModule().getFuelDifferentialPressure(); + } + + TEST_F(FuelDifferentialPressureTest, checkDefault) { + checkFuelDifferrentialPressure( + TEST_ENGINE_CONFIG, + {}, + {}, + "default" + ); + } + + TEST_F(FuelDifferentialPressureTest, checkNone) { + checkFuelDifferrentialPressure( + TEST_ENGINE_CONFIG.clone() + .setInjectorCompensationMode(ICM_None) + .setSecondaryInjectorCompensationMode(ICM_None), + {}, + {}, + "primaryInjectorCompensationMode=ICM_None, " + "secondaryInjectorCompensationMode=ICM_None" + ); + } + + TEST_F(FuelDifferentialPressureTest, checkFixedRailPressure) { + checkFuelDifferrentialPressure( + TEST_ENGINE_CONFIG.clone() + .setInjectorCompensationMode(ICM_FixedRailPressure) + .setSecondaryInjectorCompensationMode(ICM_FixedRailPressure), + { TEST_PRIMARY_INJECTOR_FIXED_RAIL_FUEL_DIFFERENTIAL_PRESSURE }, + { TEST_SECONDARY_INJECTOR_FIXED_RAIL_FUEL_DIFFERENTIAL_PRESSURE }, + "primaryInjectorCompensationMode=ICM_FixedRailPressure, " + "secondaryInjectorCompensationMode=ICM_FixedRailPressure" + ); + } + + TEST_F(FuelDifferentialPressureTest, checkSensedRailPressureDefault) { + checkFuelDifferrentialPressure( + TEST_ENGINE_CONFIG.clone() + .setInjectorCompensationMode(ICM_SensedRailPressure) + .setSecondaryInjectorCompensationMode(ICM_SensedRailPressure), + { TEST_SENSED_RAIL_ABSOLUTE_FUEL_DIFFERENTIAL_PRESSURE }, + { TEST_SENSED_RAIL_ABSOLUTE_FUEL_DIFFERENTIAL_PRESSURE }, + "primaryInjectorCompensationMode=ICM_SensedRailPressure, " + "secondaryInjectorCompensationMode=ICM_SensedRailPressure" + ); + } + + TEST_F(FuelDifferentialPressureTest, checkSensedRailPressureAbsolute) { + checkFuelDifferrentialPressure( + TEST_ENGINE_CONFIG.clone() + .setInjectorCompensationMode(ICM_SensedRailPressure) + .setSecondaryInjectorCompensationMode(ICM_SensedRailPressure) + .setFuelPressureSensorMode(FPM_Absolute), + { TEST_SENSED_RAIL_ABSOLUTE_FUEL_DIFFERENTIAL_PRESSURE }, + { TEST_SENSED_RAIL_ABSOLUTE_FUEL_DIFFERENTIAL_PRESSURE }, + "primaryInjectorCompensationMode=ICM_SensedRailPressure, " + "secondaryInjectorCompensationMode=ICM_SensedRailPressure, " + "fuelPressureSensorMode=FPM_Absolute" + ); + } + + TEST_F(FuelDifferentialPressureTest, checkSensedRailPressureGauge) { + checkFuelDifferrentialPressure( + TEST_ENGINE_CONFIG.clone() + .setInjectorCompensationMode(ICM_SensedRailPressure) + .setSecondaryInjectorCompensationMode(ICM_SensedRailPressure) + .setFuelPressureSensorMode(FPM_Gauge), + { TEST_SENSED_RAIL_GAUGE_FUEL_DIFFERENTIAL_PRESSURE }, + { TEST_SENSED_RAIL_GAUGE_FUEL_DIFFERENTIAL_PRESSURE }, + "primaryInjectorCompensationMode=ICM_SensedRailPressure, " + "secondaryInjectorCompensationMode=ICM_SensedRailPressure, " + "fuelPressureSensorMode=FPM_Gauge" + ); + } + + TEST_F(FuelDifferentialPressureTest, checkSensedRailPressureDifferential) { + checkFuelDifferrentialPressure( + TEST_ENGINE_CONFIG.clone() + .setInjectorCompensationMode(ICM_SensedRailPressure) + .setSecondaryInjectorCompensationMode(ICM_SensedRailPressure) + .setFuelPressureSensorMode(FPM_Differential), + { TEST_FUEL_PRESSURE_INJECTOR }, + { TEST_FUEL_PRESSURE_INJECTOR }, + "primaryInjectorCompensationMode=ICM_SensedRailPressure, " + "secondaryInjectorCompensationMode=ICM_SensedRailPressure, " + "fuelPressureSensorMode=FPM_Differential" + ); + } + + TEST_F(FuelDifferentialPressureTest, checkMix) { + checkFuelDifferrentialPressure( + TEST_ENGINE_CONFIG.clone() + .setInjectorCompensationMode(ICM_FixedRailPressure) + .setSecondaryInjectorCompensationMode(ICM_SensedRailPressure), + { TEST_PRIMARY_INJECTOR_FIXED_RAIL_FUEL_DIFFERENTIAL_PRESSURE }, + { TEST_SENSED_RAIL_ABSOLUTE_FUEL_DIFFERENTIAL_PRESSURE }, + "primaryInjectorCompensationMode=ICM_FixedRailPressure, " + "secondaryInjectorCompensationMode=ICM_SensedRailPressure" + ); + } +} \ No newline at end of file diff --git a/unit_tests/tests/tests.mk b/unit_tests/tests/tests.mk index 046883d48b..1c086e931f 100644 --- a/unit_tests/tests/tests.mk +++ b/unit_tests/tests/tests.mk @@ -49,6 +49,7 @@ TESTS_SRC_CPP = \ tests/ignition_injection/test_odd_firing_engine.cpp \ tests/ignition_injection/test_three_cylinder.cpp \ testa/ignition_injection/test_staged_injection.cpp \ + testa/ignition_injection/test_fuel_differential_pressure.cpp \ tests/util/test_base.cpp \ tests/util/test_engine_configuration.cpp \ tests/util/engine_config.cpp \ diff --git a/unit_tests/tests/util/engine_config.cpp b/unit_tests/tests/util/engine_config.cpp index e27edd7e4d..65b5ec72d1 100644 --- a/unit_tests/tests/util/engine_config.cpp +++ b/unit_tests/tests/util/engine_config.cpp @@ -122,6 +122,11 @@ EngineConfig EngineConfig::setTorqueReductionIgnitionRetard(const std::optional< return *this; } +EngineConfig EngineConfig::setFuelPressureSensorMode(std::optional value) { + m_fuelPressureSensorMode = value; + return *this; +} + EngineConfig EngineConfig::setInjectorFlowAsMassFlow(const std::optional injectorFlowAsMassFlow) { m_injectorFlowAsMassFlow = injectorFlowAsMassFlow; return *this; @@ -137,6 +142,16 @@ EngineConfig EngineConfig::setInjectorBattLagCorr(const std::optional value) { + m_fuelReferencePressure = value; + return *this; +} + +EngineConfig EngineConfig::setInjectorCompensationMode(const std::optional value) { + m_injectorCompensationMode = value; + return *this; +} + EngineConfig EngineConfig::setInjectorSecondaryFlow(const std::optional flow) { m_injectorSecondaryFlow = flow; return *this; @@ -150,4 +165,16 @@ EngineConfig EngineConfig::setInjectorSecondaryBattLagCorr(const std::optional value) { m_isStagedInjectionEnabled = value; return *this; +} + +EngineConfig EngineConfig::setSecondaryInjectorFuelReferencePressure(const std::optional value) { + m_secondaryInjectorFuelReferencePressure = value; + return *this; +} + +EngineConfig EngineConfig::setSecondaryInjectorCompensationMode( + const std::optional value +) { + m_secondaryInjectorCompensationMode = value; + return *this; } \ No newline at end of file diff --git a/unit_tests/tests/util/engine_config.h b/unit_tests/tests/util/engine_config.h index 546ea723b2..e8abf405d3 100644 --- a/unit_tests/tests/util/engine_config.h +++ b/unit_tests/tests/util/engine_config.h @@ -41,14 +41,20 @@ public: std::optional getTorqueReductionIgnitionCut() const { return m_torqueReductionIgnitionCut; } std::optional getTorqueReductionIgnitionRetard() const { return m_torqueReductionIgnitionRetard; } + std::optional getFuelPressureSensorMode() const { return m_fuelPressureSensorMode; }; + // Injector std::optional getInjectorFlow() const { return m_injectorFlow; } std::optional getInjectorBattLagCorr() const { return m_injectorBattLagCorrCurve; } std::optional getInjectorFlowAsMassFlow() const { return m_injectorFlowAsMassFlow; } + std::optional getFuelReferencePressure() const { return m_fuelReferencePressure; } + std::optional getInjectorCompensationMode() const { return m_injectorCompensationMode; } // Secondary injector std::optional getInjectorSecondaryFlow() const { return m_injectorSecondaryFlow; } std::optional getInjectorSecondaryBattLagCorr() const { return m_injectorSecondaryBattLagCorrCurve; } + std::optional getSecondaryInjectorFuelReferencePressure() const { return m_secondaryInjectorFuelReferencePressure; } + std::optional getSecondaryInjectorCompensationMode() const { return m_secondaryInjectorCompensationMode; } // Staged injection std::optional getStagedInjectionEnabled() const { return m_isStagedInjectionEnabled; } @@ -82,14 +88,20 @@ public: EngineConfig setTorqueReductionIgnitionCut(std::optional value); EngineConfig setTorqueReductionIgnitionRetard(std::optional value); + EngineConfig setFuelPressureSensorMode(std::optional value); + // Injector EngineConfig setInjectorFlowAsMassFlow(std::optional injectorFlowAsMassFlow); EngineConfig setInjectorFlow(std::optional flow); EngineConfig setInjectorBattLagCorr(std::optional battLagCorr); + EngineConfig setFuelReferencePressure(std::optional value); + EngineConfig setInjectorCompensationMode(std::optional value); // Secondary injector EngineConfig setInjectorSecondaryFlow(std::optional flow); EngineConfig setInjectorSecondaryBattLagCorr(std::optional battLagCorr); + EngineConfig setSecondaryInjectorFuelReferencePressure(std::optional value); + EngineConfig setSecondaryInjectorCompensationMode(std::optional value); // Staged injection EngineConfig setStagedInjectionEnabled(std::optional value); @@ -120,14 +132,20 @@ private: std::optional m_torqueReductionIgnitionCut; std::optional m_torqueReductionIgnitionRetard; + std::optional m_fuelPressureSensorMode; + // Injector std::optional m_injectorFlow; std::optional m_injectorBattLagCorrCurve; std::optional m_injectorFlowAsMassFlow;; + std::optional m_fuelReferencePressure; + std::optional m_injectorCompensationMode; // Secondary injector std::optional m_injectorSecondaryFlow; std::optional m_injectorSecondaryBattLagCorrCurve; + std::optional m_secondaryInjectorFuelReferencePressure; + std::optional m_secondaryInjectorCompensationMode; // Staged injection std::optional m_isStagedInjectionEnabled; diff --git a/unit_tests/tests/util/test_base.cpp b/unit_tests/tests/util/test_base.cpp index 4812d5a452..208eaa4f1c 100644 --- a/unit_tests/tests/util/test_base.cpp +++ b/unit_tests/tests/util/test_base.cpp @@ -53,14 +53,24 @@ void TestBase::setUpEngineConfiguration(const EngineConfig& config) { getTestEngineConfiguration().configureTorqueReductionIgnitionCut(config.getTorqueReductionIgnitionCut()); getTestEngineConfiguration().configureTorqueReductionIgnitionRetard(config.getTorqueReductionIgnitionRetard()); + getTestEngineConfiguration().configureFuelPressureSensorMode(config.getFuelPressureSensorMode()); + // Injector getTestEngineConfiguration().configureInjectorFlowAsMassFlow(config.getInjectorFlowAsMassFlow()); getTestEngineConfiguration().configureInjectorFlow(config.getInjectorFlow()); getTestEngineConfiguration().configureInjectorBattLagCorr(config.getInjectorBattLagCorr()); + getTestEngineConfiguration().configureFuelReferencePressure(config.getFuelReferencePressure()); + getTestEngineConfiguration().configureInjectorCompensationMode(config.getInjectorCompensationMode()); // Secondary injector getTestEngineConfiguration().configureInjectorSecondaryFlow(config.getInjectorSecondaryFlow()); getTestEngineConfiguration().configureInjectorSecondaryBattLagCorr(config.getInjectorSecondaryBattLagCorr()); + getTestEngineConfiguration().configureSecondaryInjectorFuelReferencePressure( + config.getSecondaryInjectorFuelReferencePressure() + ); + getTestEngineConfiguration().configureSecondaryInjectorCompensationMode( + config.getSecondaryInjectorCompensationMode() + ); // Staged injection getTestEngineConfiguration().configureEnableStagedInjection(config.getStagedInjectionEnabled()); diff --git a/unit_tests/tests/util/test_base.h b/unit_tests/tests/util/test_base.h index 9b488af7c3..1b6754af8b 100644 --- a/unit_tests/tests/util/test_base.h +++ b/unit_tests/tests/util/test_base.h @@ -25,6 +25,12 @@ protected: void updateRpm(float rpm); void updateApp(std::optional app); + + template ModuleType& getModule(); private: std::unique_ptr eth; }; + +template ModuleType& TestBase::getModule() { + return engine->module().unmock(); +} diff --git a/unit_tests/tests/util/test_engine_configuration.cpp b/unit_tests/tests/util/test_engine_configuration.cpp index ab9168bf4e..39a2e6d37b 100644 --- a/unit_tests/tests/util/test_engine_configuration.cpp +++ b/unit_tests/tests/util/test_engine_configuration.cpp @@ -252,6 +252,19 @@ void TestEngineConfiguration::configureTorqueReductionIgnitionRetard(const std:: } } +void TestEngineConfiguration::configureFuelPressureSensorMode( + const std::optional fuelPressureSensorMode +) { + if (fuelPressureSensorMode.has_value()) { + engineConfiguration->fuelPressureSensorMode = fuelPressureSensorMode.value(); + } else { + ASSERT_EQ( + engineConfiguration->fuelPressureSensorMode, + engine_configuration_defaults::FUEL_PRESSURE_SENSOR_MODE + ); // check default value + } +} + void TestEngineConfiguration::configureInjectorFlowAsMassFlow(const std::optional injectorFlowAsMassFlow) { if (injectorFlowAsMassFlow.has_value()) { engineConfiguration->injectorFlowAsMassFlow = injectorFlowAsMassFlow.value(); @@ -286,6 +299,30 @@ void TestEngineConfiguration::configureInjectorBattLagCorr(const std::optional fuelReferencePressure) { + if (fuelReferencePressure.has_value()) { + engineConfiguration->fuelReferencePressure = fuelReferencePressure.value(); + } else { + ASSERT_EQ( + engineConfiguration->fuelReferencePressure, + engine_configuration_defaults::FUEL_REFERENCE_PRESSURE + ); // check default value + } +} + +void TestEngineConfiguration::configureInjectorCompensationMode( + const std::optional injectorCompensationMode +) { + if (injectorCompensationMode.has_value()) { + engineConfiguration->injectorCompensationMode = injectorCompensationMode.value(); + } else { + ASSERT_EQ( + engineConfiguration->injectorCompensationMode, + engine_configuration_defaults::INJECTOR_COMPENSATION_MODE + ); // check default value + } +} + void TestEngineConfiguration::configureInjectorSecondaryFlow(const std::optional flow) { if (flow.has_value()) { engineConfiguration->injectorSecondary.flow = flow.value(); @@ -312,6 +349,32 @@ void TestEngineConfiguration::configureInjectorSecondaryBattLagCorr(const std::o } } +void TestEngineConfiguration::configureSecondaryInjectorFuelReferencePressure( + const std::optional secondaryInjectorFuelReferencePressure +) { + if (secondaryInjectorFuelReferencePressure.has_value()) { + engineConfiguration->secondaryInjectorFuelReferencePressure = secondaryInjectorFuelReferencePressure.value(); + } else { + ASSERT_EQ( + engineConfiguration->secondaryInjectorFuelReferencePressure, + engine_configuration_defaults::SECONDARY_INJECTOR_FUEL_REFERENCE_PRESSURE + ); // check default value + } +} + +void TestEngineConfiguration::configureSecondaryInjectorCompensationMode( + const std::optional secondaryInjectorCompensationMode +) { + if (secondaryInjectorCompensationMode.has_value()) { + engineConfiguration->secondaryInjectorCompensationMode = secondaryInjectorCompensationMode.value(); + } else { + ASSERT_EQ( + engineConfiguration->secondaryInjectorCompensationMode, + engine_configuration_defaults::SECONDARY_INJECTOR_COMPENSATION_MODE + ); // check default value + } +} + void TestEngineConfiguration::configureEnableStagedInjection(const std::optional isStagedInjectionEnabled) { if (isStagedInjectionEnabled.has_value()) { engineConfiguration->enableStagedInjection = isStagedInjectionEnabled.value(); diff --git a/unit_tests/tests/util/test_engine_configuration.h b/unit_tests/tests/util/test_engine_configuration.h index cd046b3640..74746834cc 100644 --- a/unit_tests/tests/util/test_engine_configuration.h +++ b/unit_tests/tests/util/test_engine_configuration.h @@ -42,14 +42,22 @@ public: void configureTorqueReductionIgnitionCut(std::optional ignitionCut); void configureTorqueReductionIgnitionRetard(std::optional ignitionRetard); + void configureFuelPressureSensorMode(std::optional fuelPressureSensorMode); + // Injector void configureInjectorFlow(std::optional flow); void configureInjectorBattLagCorr(std::optional battLagCorr); void configureInjectorFlowAsMassFlow(std::optional injectorFlowAsMassFlow); + void configureFuelReferencePressure(std::optional fuelReferencePressure); + void configureInjectorCompensationMode(std::optional injectorCompensationMode); // Secondary Injector void configureInjectorSecondaryFlow(std::optional flow); void configureInjectorSecondaryBattLagCorr(std::optional battLagCorr); + void configureSecondaryInjectorFuelReferencePressure(std::optional secondaryInjectorFuelReferencePressure); + void configureSecondaryInjectorCompensationMode( + std::optional secondaryInjectorCompensationMode + ); // Staged injection void configureEnableStagedInjection(std::optional isStagedInjectionEnabled);