andreika-git
/
rusefi
mirror of https://github.com/andreika-git/rusefi.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix test & update tests utils

This commit is contained in:
FDSoftware 2025-02-26 15:43:14 -03:00 committed by rusefillc
parent a5f099770c
commit 13c528de8c
11 changed files with 57 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
firmware/controllers/algo/engine_configuration_defaults.h
View File

@ -42,13 +42,13 @@ namespace engine_configuration_defaults {
/* 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 BattLagCorrTable INJECTOR_BATT_LAG_CURR { { 1.383 * 0.9651, 0.726 * 0.9651 } };
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 BattLagCorrTable INJECTOR_SECONDARY_BATT_LAG_CURR { { 1.383 * 0.9651, 0.726 * 0.9651 } };
constexpr float SECONDARY_INJECTOR_FUEL_REFERENCE_PRESSURE = 0.0f;
constexpr injector_compensation_mode_e SECONDARY_INJECTOR_COMPENSATION_MODE = INJECTOR_COMPENSATION_MODE;

2
firmware/controllers/algo/fuel/batt_lag_corr_curve.h
View File

@ -6,4 +6,4 @@
#include <array>
using BattLagCorrCurve = std::array<float, VBAT_INJECTOR_CURVE_SIZE>;
using BattLagCorrTable = std::array<std::array<float, VBAT_INJECTOR_CURVE_PRESSURE_SIZE>, VBAT_INJECTOR_CURVE_PRESSURE_SIZE>;

2
unit_tests/test-framework/engine_test_helper.cpp
View File

@ -444,7 +444,7 @@ void setupSimpleTestEngineWithMaf(EngineTestHelper *eth, injection_mode_e inject
engineConfiguration->crankingInjectionMode = IM_SIMULTANEOUS;
setArrayValues(config->cltFuelCorrBins, 1.0f);
setArrayValues(engineConfiguration->injector.battLagCorr, 0.0f);
setFlatInjectorLag(0.0);
// this is needed to update injectorLag
engine->updateSlowSensors();

5
unit_tests/tests/ignition_injection/test_fuel_map.cpp
View File

@ -17,10 +17,7 @@ TEST(misc, testFuelMap) {
printf("Setting up FORD_ASPIRE_1996\r\n");
EngineTestHelper eth(engine_type_e::FORD_ASPIRE_1996);
for (int i = 0; i < VBAT_INJECTOR_CURVE_SIZE; i++) {
engineConfiguration->injector.battLagCorrBins[i] = i;
engineConfiguration->injector.battLagCorr[i] = 0.5 + 2 * i;
}
setFlatInjectorLag(0.2);
eth.engine.updateSlowSensors();

2
unit_tests/tests/ignition_injection/test_fuel_math.cpp
View File

@ -238,7 +238,7 @@ TEST(FuelMath, deadtime) {
EXPECT_FLOAT_EQ( 20, engine->engineState.injectionDuration);
// Now add some deadtime
setArrayValues(engineConfiguration->injector.battLagCorr, 2.0f);
setFlatInjectorLag(2.0f);
// Should have deadtime now!
engine->periodicFastCallback();

19
unit_tests/tests/ignition_injection/test_injector_model.cpp
View File

@ -133,17 +133,24 @@ TEST(InjectorModel, Deadtime) {
EngineTestHelper eth(engine_type_e::TEST_ENGINE);
// Some test data in the injector correction table
for (size_t i = 0; i < efi::size(engineConfiguration->injector.battLagCorr); i++) {
engineConfiguration->injector.battLagCorr[i] = 2 * i;
engineConfiguration->injector.battLagCorrBins[i] = i;
}
static const float injectorLagPressureBins[VBAT_INJECTOR_CURVE_PRESSURE_SIZE] = { 300, 600 };
static const float injectorLagVbattBins[VBAT_INJECTOR_CURVE_PRESSURE_SIZE] = { 11.0, 15.0 };
static const float injectorLagCorrection[VBAT_INJECTOR_CURVE_PRESSURE_SIZE][VBAT_INJECTOR_CURVE_PRESSURE_SIZE] = {
{ 6, 1.20 },
{ 14, 1.20 },
};
copyArray(engineConfiguration->injector.battLagCorrBattBins, injectorLagVbattBins);
copyArray(engineConfiguration->injector.battLagCorrPressBins, injectorLagPressureBins);
copyTable(engineConfiguration->injector.battLagCorrTable, injectorLagCorrection);
InjectorModelPrimary dut;
dut.pressureCorrectionReference = 300;
Sensor::setMockValue(SensorType::BatteryVoltage, 3);
Sensor::setMockValue(SensorType::BatteryVoltage, 11);
EXPECT_EQ(dut.getDeadtime(), 6);
Sensor::setMockValue(SensorType::BatteryVoltage, 7);
Sensor::setMockValue(SensorType::BatteryVoltage, 15);
EXPECT_EQ(dut.getDeadtime(), 14);
}

13
unit_tests/tests/ignition_injection/test_staged_injection.cpp
View File

@ -18,16 +18,17 @@ namespace {
constexpr float TEST_SECONDARY_INJECTOR_FLOW = 174.17f;
constexpr float TEST_SECONDARY_INJECTOR_BASE_DURATION = TEST_INJECTION_MASS / TEST_SECONDARY_INJECTOR_FLOW * 1000;
BattLagCorrCurve generateConstantBattLagCorrCurve(const float value) {
BattLagCorrCurve testBattLagCorrCurve;
testBattLagCorrCurve.fill(value);
return testBattLagCorrCurve;
BattLagCorrTable generateConstantBattLagCorrCurve(const float value) {
BattLagCorrTable testBattLagCorrTable;
testBattLagCorrTable[0].fill(value);
testBattLagCorrTable[1].fill(value);
return testBattLagCorrTable;
}
const BattLagCorrCurve TEST_PRIMARY_INJECTOR_BATT_LAG_CORR_CURVE = generateConstantBattLagCorrCurve(
const BattLagCorrTable TEST_PRIMARY_INJECTOR_BATT_LAG_CORR_CURVE = generateConstantBattLagCorrCurve(
TEST_PRIMARY_INJECTOR_DEAD_TIME
);
const BattLagCorrCurve TEST_SECONDARY_INJECTOR_BATT_LAG_CORR_CURVE = generateConstantBattLagCorrCurve(
const BattLagCorrTable TEST_SECONDARY_INJECTOR_BATT_LAG_CORR_CURVE = generateConstantBattLagCorrCurve(
TEST_SECONDARY_INJECTOR_DEAD_TIME
);

4
unit_tests/tests/util/engine_config.cpp
View File

@ -157,7 +157,7 @@ EngineConfig EngineConfig::setInjectorFlow(const std::optional<float> flow) {
return *this;
}
EngineConfig EngineConfig::setInjectorBattLagCorr(const std::optional<BattLagCorrCurve> battLagCorr) {
EngineConfig EngineConfig::setInjectorBattLagCorr(const std::optional<BattLagCorrTable> battLagCorr) {
m_injectorBattLagCorrCurve = battLagCorr;
return *this;
}
@ -177,7 +177,7 @@ EngineConfig EngineConfig::setInjectorSecondaryFlow(const std::optional<float> f
return *this;
}
EngineConfig EngineConfig::setInjectorSecondaryBattLagCorr(const std::optional<BattLagCorrCurve> battLagCorr) {
EngineConfig EngineConfig::setInjectorSecondaryBattLagCorr(const std::optional<BattLagCorrTable> battLagCorr) {
m_injectorSecondaryBattLagCorrCurve = battLagCorr;
return *this;
}

12
unit_tests/tests/util/engine_config.h
View File

@ -51,14 +51,14 @@ public:
// Injector
std::optional<float> getInjectorFlow() const { return m_injectorFlow; }
std::optional<BattLagCorrCurve> getInjectorBattLagCorr() const { return m_injectorBattLagCorrCurve; }
std::optional<BattLagCorrTable> getInjectorBattLagCorr() const { return m_injectorBattLagCorrCurve; }
std::optional<bool> getInjectorFlowAsMassFlow() const { return m_injectorFlowAsMassFlow; }
std::optional<float> getFuelReferencePressure() const { return m_fuelReferencePressure; }
std::optional<injector_compensation_mode_e> getInjectorCompensationMode() const { return m_injectorCompensationMode; }
// Secondary injector
std::optional<float> getInjectorSecondaryFlow() const { return m_injectorSecondaryFlow; }
std::optional<BattLagCorrCurve> getInjectorSecondaryBattLagCorr() const { return m_injectorSecondaryBattLagCorrCurve; }
std::optional<BattLagCorrTable> getInjectorSecondaryBattLagCorr() const { return m_injectorSecondaryBattLagCorrCurve; }
std::optional<float> getSecondaryInjectorFuelReferencePressure() const { return m_secondaryInjectorFuelReferencePressure; }
std::optional<injector_compensation_mode_e> getSecondaryInjectorCompensationMode() const { return m_secondaryInjectorCompensationMode; }
@ -130,13 +130,13 @@ public:
// Injector
EngineConfig setInjectorFlowAsMassFlow(std::optional<bool> injectorFlowAsMassFlow);
EngineConfig setInjectorFlow(std::optional<float> flow);
EngineConfig setInjectorBattLagCorr(std::optional<BattLagCorrCurve> battLagCorr);
EngineConfig setInjectorBattLagCorr(std::optional<BattLagCorrTable> battLagCorr);
EngineConfig setFuelReferencePressure(std::optional<float> value);
EngineConfig setInjectorCompensationMode(std::optional<injector_compensation_mode_e> value);
// Secondary injector
EngineConfig setInjectorSecondaryFlow(std::optional<float> flow);
EngineConfig setInjectorSecondaryBattLagCorr(std::optional<BattLagCorrCurve> battLagCorr);
EngineConfig setInjectorSecondaryBattLagCorr(std::optional<BattLagCorrTable> battLagCorr);
EngineConfig setSecondaryInjectorFuelReferencePressure(std::optional<float> value);
EngineConfig setSecondaryInjectorCompensationMode(std::optional<injector_compensation_mode_e> value);
@ -204,14 +204,14 @@ private:
// Injector
std::optional<float> m_injectorFlow;
std::optional<BattLagCorrCurve> m_injectorBattLagCorrCurve;
std::optional<BattLagCorrTable> m_injectorBattLagCorrCurve;
std::optional<bool> m_injectorFlowAsMassFlow;;
std::optional<float> m_fuelReferencePressure;
std::optional<injector_compensation_mode_e> m_injectorCompensationMode;
// Secondary injector
std::optional<float> m_injectorSecondaryFlow;
std::optional<BattLagCorrCurve> m_injectorSecondaryBattLagCorrCurve;
std::optional<BattLagCorrTable> m_injectorSecondaryBattLagCorrCurve;
std::optional<float> m_secondaryInjectorFuelReferencePressure;
std::optional<injector_compensation_mode_e> m_secondaryInjectorCompensationMode;

39
unit_tests/tests/util/test_engine_configuration.cpp
View File

@ -328,21 +328,22 @@ void TestEngineConfiguration::configureInjectorFlow(const std::optional<float> f
}
}
void TestEngineConfiguration::configureInjectorBattLagCorr(const std::optional<BattLagCorrCurve> battLagCorr) {
void TestEngineConfiguration::configureInjectorBattLagCorr(const std::optional<BattLagCorrTable> battLagCorr) {
if (battLagCorr.has_value()) {
std::copy(
std::begin(battLagCorr.value()),
std::end(battLagCorr.value()),
std::begin(engineConfiguration->injector.battLagCorr)
);
for (size_t i = 0; i < VBAT_INJECTOR_CURVE_PRESSURE_SIZE; i++) {
std::copy(
std::begin(battLagCorr.value()[i]),
std::end(battLagCorr.value()[i]),
std::begin(engineConfiguration->injector.battLagCorrTable[i])
);
}
} else {
EXPECT_THAT(
engineConfiguration->injector.battLagCorr,
testing::ElementsAreArray(engine_configuration_defaults::INJECTOR_BATT_LAG_CURR)
engineConfiguration->injector.battLagCorrTable[0],
testing::ElementsAreArray(engine_configuration_defaults::INJECTOR_BATT_LAG_CURR[0])
);
}
}
void TestEngineConfiguration::configureFuelReferencePressure(const std::optional<float> fuelReferencePressure) {
if (fuelReferencePressure.has_value()) {
engineConfiguration->fuelReferencePressure = fuelReferencePressure.value();
@ -378,17 +379,19 @@ void TestEngineConfiguration::configureInjectorSecondaryFlow(const std::optional
}
}
void TestEngineConfiguration::configureInjectorSecondaryBattLagCorr(const std::optional<BattLagCorrCurve> battLagCorr) {
void TestEngineConfiguration::configureInjectorSecondaryBattLagCorr(const std::optional<BattLagCorrTable> battLagCorr) {
if (battLagCorr.has_value()) {
std::copy(
std::begin(battLagCorr.value()),
std::end(battLagCorr.value()),
std::begin(engineConfiguration->injectorSecondary.battLagCorr)
);
for (size_t i = 0; i < VBAT_INJECTOR_CURVE_PRESSURE_SIZE; i++) {
std::copy(
std::begin(battLagCorr.value()[i]),
std::end(battLagCorr.value()[i]),
std::begin(engineConfiguration->injectorSecondary.battLagCorrTable[i])
);
}
} else {
EXPECT_THAT(
engineConfiguration->injectorSecondary.battLagCorr,
testing::ElementsAreArray(engine_configuration_defaults::INJECTOR_SECONDARY_BATT_LAG_CURR)
EXPECT_THAT(
engineConfiguration->injectorSecondary.battLagCorrTable[0],
testing::ElementsAreArray(engine_configuration_defaults::INJECTOR_SECONDARY_BATT_LAG_CURR[0])
);
}
}

4
unit_tests/tests/util/test_engine_configuration.h
View File

@ -52,14 +52,14 @@ public:
// Injector
void configureInjectorFlow(std::optional<float> flow);
void configureInjectorBattLagCorr(std::optional<BattLagCorrCurve> battLagCorr);
void configureInjectorBattLagCorr(std::optional<BattLagCorrTable> battLagCorr);
void configureInjectorFlowAsMassFlow(std::optional<bool> injectorFlowAsMassFlow);
void configureFuelReferencePressure(std::optional<float> fuelReferencePressure);
void configureInjectorCompensationMode(std::optional<injector_compensation_mode_e> injectorCompensationMode);
// Secondary Injector
void configureInjectorSecondaryFlow(std::optional<float> flow);
void configureInjectorSecondaryBattLagCorr(std::optional<BattLagCorrCurve> battLagCorr);
void configureInjectorSecondaryBattLagCorr(std::optional<BattLagCorrTable> battLagCorr);
void configureSecondaryInjectorFuelReferencePressure(std::optional<float> secondaryInjectorFuelReferencePressure);
void configureSecondaryInjectorCompensationMode(
std::optional<injector_compensation_mode_e> secondaryInjectorCompensationMode