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

Merge pull request #1632 from mck1117/remove-plain-maf 

goodbye, plain maf
This commit is contained in:
rusefillc 2020-08-01 09:16:38 -04:00 committed by GitHub
parent f3fba6f45e 795da6ea43
commit e009d60b29
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 38 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
firmware/config/boards/kinetis/config/controllers/algo/auto_generated_enums.cpp
View File

@ -591,8 +591,6 @@ case LM_ALPHA_N_2:
return "LM_ALPHA_N_2";
case LM_MOCK:
return "LM_MOCK";
case LM_PLAIN_MAF:
return "LM_PLAIN_MAF";
case LM_REAL_MAF:
return "LM_REAL_MAF";
case LM_SPEED_DENSITY:

2
firmware/config/engines/ford_festiva.cpp
View File

@ -80,9 +80,7 @@ void setFordEscortGt(DECLARE_CONFIG_PARAMETER_SIGNATURE) {
engineConfiguration->globalFuelCorrection = 0.75;
engineConfiguration->specs.displacement = 1.839;
// engineConfiguration->fuelAlgorithm = LM_PLAIN_MAF;
setAlgorithm(LM_SPEED_DENSITY PASS_CONFIG_PARAMETER_SUFFIX);
// engineConfiguration->fuelAlgorithm = LM_REAL_MAF;
setFuelLoadBin(1.2, 4.4 PASS_CONFIG_PARAMETER_SUFFIX);
setFuelRpmBin(800, 7000 PASS_CONFIG_PARAMETER_SUFFIX);

4
firmware/config/engines/mazda_miata_1_6.cpp
View File

@ -357,7 +357,6 @@ void setMiataNA6_MAP_Frankenso(DECLARE_CONFIG_PARAMETER_SIGNATURE) {
void setMiataNA6_VAF_Frankenso(DECLARE_CONFIG_PARAMETER_SIGNATURE) {
setMiataNA6_MAP_Frankenso(PASS_CONFIG_PARAMETER_SIGNATURE);
engineConfiguration->fuelAlgorithm = LM_PLAIN_MAF;
/**
* Stage 0 we only have OEM TPS switch
@ -415,8 +414,6 @@ void setMiataNA6_VAF_MRE(DECLARE_CONFIG_PARAMETER_SIGNATURE) {
engineConfiguration->isHip9011Enabled = false;
engineConfiguration->isSdCardEnabled = true;
engineConfiguration->fuelAlgorithm = LM_PLAIN_MAF;
#endif /* BOARD_TLE8888_COUNT */
}
@ -503,6 +500,5 @@ void setMiataNA6_MAP_MRE(DECLARE_CONFIG_PARAMETER_SIGNATURE) {
// TLE8888_PIN_24: "43 - GP Out 4"
engineConfiguration->fsioOutputPins[1] = TLE8888_PIN_24;
#endif /* BOARD_TLE8888_COUNT */
}

2
firmware/console/status_loop.cpp
View File

@ -286,7 +286,7 @@ void updateDevConsoleState(void) {
static void showFuelInfo2(float rpm, float engineLoad) {
float baseFuelMs = getBaseTableFuel((int) rpm, engineLoad);
float baseFuelMs = 0; // TODO
float magicAir = SpeedDensityBase::getAirmassImpl(1, 100, convertCelsiusToKelvin(20) PASS_ENGINE_PARAMETER_SUFFIX);

2
firmware/controllers/algo/auto_generated_enums.cpp
View File

@ -729,8 +729,6 @@ case LM_ALPHA_N_2:
return "LM_ALPHA_N_2";
case LM_MOCK:
return "LM_MOCK";
case LM_PLAIN_MAF:
return "LM_PLAIN_MAF";
case LM_REAL_MAF:
return "LM_REAL_MAF";
case LM_SPEED_DENSITY:

2
firmware/controllers/algo/engine_configuration.cpp
View File

@ -979,7 +979,7 @@ static void setDefaultEngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->ignitionOffset = 0;
engineConfiguration->sensorChartFrequency = 20;
engineConfiguration->fuelAlgorithm = LM_PLAIN_MAF;
engineConfiguration->fuelAlgorithm = LM_SPEED_DENSITY;
engineConfiguration->vbattDividerCoeff = ((float) (15 + 65)) / 15;

64
firmware/controllers/algo/fuel_math.cpp
View File

@ -197,39 +197,24 @@ floatms_t getBaseFuel(int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) {
efiAssert(CUSTOM_ERR_ASSERT, !cisnan(tpsAccelEnrich), "NaN tpsAccelEnrich", 0);
ENGINE(engineState.tpsAccelEnrich) = tpsAccelEnrich;
floatms_t baseFuel;
// airmass modes - get airmass first, then convert to fuel
auto model = getAirmassModel(PASS_ENGINE_PARAMETER_SIGNATURE);
efiAssert(CUSTOM_ERR_ASSERT, model != nullptr, "Invalid airmass mode", 0.0f);
if ((CONFIG(fuelAlgorithm) == LM_SPEED_DENSITY) ||
(engineConfiguration->fuelAlgorithm == LM_REAL_MAF) ||
(engineConfiguration->fuelAlgorithm == LM_ALPHA_N_2) ||
(engineConfiguration->fuelAlgorithm == LM_MOCK)) {
// airmass modes - get airmass first, then convert to fuel
auto model = getAirmassModel(PASS_ENGINE_PARAMETER_SIGNATURE);
efiAssert(CUSTOM_ERR_ASSERT, model != nullptr, "Invalid airmass mode", 0.0f);
auto airmass = model->getAirmass(rpm);
auto airmass = model->getAirmass(rpm);
// The airmass mode will tell us how to look up AFR - use the provided Y axis value
float targetAfr = afrMap.getValue(rpm, airmass.EngineLoadPercent);
// The airmass mode will tell us how to look up AFR - use the provided Y axis value
float targetAfr = afrMap.getValue(rpm, airmass.EngineLoadPercent);
// Plop some state for others to read
ENGINE(engineState.targetAFR) = targetAfr;
ENGINE(engineState.sd.airMassInOneCylinder) = airmass.CylinderAirmass;
ENGINE(engineState.fuelingLoad) = airmass.EngineLoadPercent;
// TODO: independently selectable ignition load mode
ENGINE(engineState.ignitionLoad) = airmass.EngineLoadPercent;
// Plop some state for others to read
ENGINE(engineState.targetAFR) = targetAfr;
ENGINE(engineState.sd.airMassInOneCylinder) = airmass.CylinderAirmass;
ENGINE(engineState.fuelingLoad) = airmass.EngineLoadPercent;
// TODO: independently selectable ignition load mode
ENGINE(engineState.ignitionLoad) = airmass.EngineLoadPercent;
baseFuel = getInjectionDurationForAirmass(airmass.CylinderAirmass, targetAfr PASS_ENGINE_PARAMETER_SUFFIX) * 1000;
efiAssert(CUSTOM_ERR_ASSERT, !cisnan(baseFuel), "NaN baseFuel", 0);
} else {
float tps = Sensor::get(SensorType::Tps1).value_or(0);
ENGINE(engineState.fuelingLoad) = tps;
// TODO: independently selectable ignition load mode
ENGINE(engineState.ignitionLoad) = tps;
baseFuel = getBaseTableFuel(rpm, getEngineLoadT(PASS_ENGINE_PARAMETER_SIGNATURE));
efiAssert(CUSTOM_ERR_ASSERT, !cisnan(baseFuel), "NaN bt baseFuel", 0);
}
float baseFuel = getInjectionDurationForAirmass(airmass.CylinderAirmass, targetAfr PASS_ENGINE_PARAMETER_SUFFIX) * 1000;
efiAssert(CUSTOM_ERR_ASSERT, !cisnan(baseFuel), "NaN baseFuel", 0);
engine->engineState.baseFuel = baseFuel;
@ -446,27 +431,6 @@ float getFuelCutOffCorrection(efitick_t nowNt, int rpm DECLARE_ENGINE_PARAMETER_
return fuelCorr;
}
/**
* @return Fuel injection duration injection as specified in the fuel map, in milliseconds
*/
floatms_t getBaseTableFuel(int rpm, float engineLoad) {
#if EFI_ENGINE_CONTROL && EFI_SHAFT_POSITION_INPUT
if (cisnan(engineLoad)) {
warning(CUSTOM_NAN_ENGINE_LOAD_2, "NaN engine load");
return 0;
}
floatms_t result = fuelMap.getValue(rpm, engineLoad);
if (cisnan(result)) {
// result could be NaN in case of invalid table, like during initialization
result = 0;
warning(CUSTOM_ERR_FUEL_TABLE_NOT_READY, "baseFuel table not ready");
}
return result;
#else
return 0;
#endif
}
float getBaroCorrection(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
if (hasBaroSensor(PASS_ENGINE_PARAMETER_SIGNATURE)) {
float correction = baroCorrMap.getValue(GET_RPM(), getBaroPressure(PASS_ENGINE_PARAMETER_SIGNATURE));

1
firmware/controllers/algo/fuel_math.h
View File

@ -22,7 +22,6 @@ floatms_t getBaseFuel(int rpm DECLARE_ENGINE_PARAMETER_SUFFIX);
*/
floatms_t getRunningFuel(floatms_t baseFuel DECLARE_ENGINE_PARAMETER_SUFFIX);
floatms_t getBaseTableFuel(int rpm, float engineLoad);
float getBaroCorrection(DECLARE_ENGINE_PARAMETER_SIGNATURE);
int getNumberOfInjections(injection_mode_e mode DECLARE_ENGINE_PARAMETER_SUFFIX);
angle_t getInjectionOffset(float rpm, float load DECLARE_ENGINE_PARAMETER_SUFFIX);

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

@ -427,10 +427,6 @@ typedef enum {
* This enum is used to select your desired Engine Load calculation algorithm
*/
typedef enum {
/**
* raw Mass Air Flow sensor value algorithm. http://en.wikipedia.org/wiki/Mass_flow_sensor
*/
LM_PLAIN_MAF = 0,
/**
* Speed Density algorithm - Engine Load is a function of MAP, VE and target AFR
* http://articles.sae.org/8539/

9
firmware/controllers/math/engine_math.cpp
View File

@ -65,13 +65,6 @@ float getEngineLoadT(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
efiAssert(CUSTOM_ERR_ASSERT, engine!=NULL, "engine 2NULL", NAN);
efiAssert(CUSTOM_ERR_ASSERT, engineConfiguration!=NULL, "engineConfiguration 2NULL", NAN);
switch (engineConfiguration->fuelAlgorithm) {
case LM_PLAIN_MAF:
if (!hasMafSensor(PASS_ENGINE_PARAMETER_SIGNATURE)) {
// todo: make this not happen during hardware CI
warning(CUSTOM_MAF_NEEDED, "MAF sensor needed for current fuel algorithm");
return NAN;
}
return getMafVoltage(PASS_ENGINE_PARAMETER_SIGNATURE);
case LM_SPEED_DENSITY:
return getMap(PASS_ENGINE_PARAMETER_SIGNATURE);
case LM_ALPHA_N_2:
@ -80,7 +73,7 @@ float getEngineLoadT(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
return getRealMaf(PASS_ENGINE_PARAMETER_SIGNATURE);
default:
firmwareError(CUSTOM_UNKNOWN_ALGORITHM, "Unexpected engine load parameter: %d", engineConfiguration->fuelAlgorithm);
return -1;
return 0;
}
}

2
firmware/development/rfi_perftest.cpp
View File

@ -75,8 +75,6 @@ static void testRusefiMethods(const int count) {
start = currentTimeMillis();
for (int i = 0; i < count; i++)
tempi += getBaseTableFuel(testEngine.engineConfiguration, 4020, 2.21111);
time = currentTimeMillis() - start;
if (tempi != 0)
scheduleMsg(logger, "Finished %d iterations of getBaseFuel in %dms", count, time);

3
firmware/integration/rusefi_config.txt
View File

@ -459,8 +459,7 @@ end_struct
int sensorSnifferRpmThreshold;+Disable sensor sniffer above this rpm;"RPM", 1, 0, 0,30000, 0
int rpmHardLimit;set rpm_hard_limit X;"rpm", 1, 0, 0, 20000.0, 2
#define engine_load_mode_e_enum "MAF", "Alpha-N/TPS", "INVALID", "Speed Density", "MAF Air Charge", "Alpha-N", "INVALID"
#define engine_load_mode_e_enum "INVALID", "Alpha-N/TPS", "INVALID", "Speed Density", "MAF Air Charge", "Alpha-N", "INVALID"
custom engine_load_mode_e 4 bits, U32, @OFFSET@, [0:2], @@engine_load_mode_e_enum@@

12
firmware/tunerstudio/rusefi.input
View File

@ -355,7 +355,6 @@ enable2ndByteCanID = false
;
; todo: generate this section programatically
LM_PLAIN_MAF = {0},
LM_SPEED_DENSITY = {3},
LM_REAL_MAF = {4}
@ -706,16 +705,6 @@ enable2ndByteCanID = false
[TableEditor]
; table_id, map3d_id, "title", page
table = fuelTableMAFTbl, fuelTableMAFMap, "Fuel Table", 1
topicHelp = "fuelHelp"
; constant, variable
xBins = fuelRpmBins, RPMValue
yBins = fuelLoadBins, MAFValue
zBins = fuelTable
; gridHeight = 2.0
gridOrient = 250, 0, 340 ; Space 123 rotation of grid in degrees.
upDownLabel = "(RICHER)", "(LEANER)"
table = fuelTableTPSTbl, fuelTableTPSMap, "Fuel Table", 1
topicHelp = "fuelHelp"
; constant, variable
@ -1528,7 +1517,6 @@ cmd_set_engine_type_default = "w\x00\x31\x00\x00"
[UserDefined]
dialog = fuelTableBottomDialog, "", card
panel = fuelTableMAFTbl, Center, {fuelAlgorithm==LM_PLAIN_MAF}
panel = fuelTableELTbl, Center
dialog = fuelTableRight, "", yAxis

20
unit_tests/tests/test_fuel_map.cpp
View File

@ -21,23 +21,8 @@ using ::testing::FloatNear;
TEST(misc, testFuelMap) {
printf("Setting up FORD_ASPIRE_1996\r\n");
WITH_ENGINE_TEST_HELPER(FORD_ASPIRE_1996);
engineConfiguration->fuelAlgorithm = LM_PLAIN_MAF;
printf("Filling fuel map\r\n");
for (int k = 0; k < FUEL_LOAD_COUNT; k++) {
for (int r = 0; r < FUEL_RPM_COUNT; r++) {
eth.engine.config->fuelTable[k][r] = k * 200 + r;
}
}
for (int i = 0; i < FUEL_LOAD_COUNT; i++)
eth.engine.config->fuelLoadBins[i] = i;
for (int i = 0; i < FUEL_RPM_COUNT; i++)
eth.engine.config->fuelRpmBins[i] = i;
ASSERT_EQ( 1005, getBaseTableFuel(5, 5)) << "base fuel table";
printf("*** getInjectorLag\r\n");
// engine->engineState.vb
assertEqualsM("lag", 1.04, getInjectorLag(12 PASS_ENGINE_PARAMETER_SUFFIX));
for (int i = 0; i < VBAT_INJECTOR_CURVE_SIZE; i++) {
@ -53,8 +38,7 @@ TEST(misc, testFuelMap) {
// because all the correction tables are zero
printf("*************************************************** getRunningFuel 1\r\n");
eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
float baseFuel = getBaseTableFuel(5, getEngineLoadT(PASS_ENGINE_PARAMETER_SIGNATURE));
ASSERT_NEAR(5.3679, getRunningFuel(baseFuel PASS_ENGINE_PARAMETER_SUFFIX), EPS4D) << "base fuel";
ASSERT_NEAR(5.3679, getRunningFuel(5 PASS_ENGINE_PARAMETER_SUFFIX), EPS4D) << "base fuel";
printf("*************************************************** setting IAT table\r\n");
for (int i = 0; i < IAT_CURVE_SIZE; i++) {
@ -88,8 +72,6 @@ TEST(misc, testFuelMap) {
// 1005 * 2 for IAT correction
printf("*************************************************** getRunningFuel 2\r\n");
eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
baseFuel = getBaseTableFuel(5, getEngineLoadT(PASS_ENGINE_PARAMETER_SIGNATURE));
EXPECT_EQ(baseFuel, 1005);
// Check that runningFuel corrects appropriately
EXPECT_EQ( 42, getRunningFuel(1 PASS_ENGINE_PARAMETER_SUFFIX)) << "v1";

59
unit_tests/tests/trigger/test_trigger_decoder.cpp
View File

@ -591,15 +591,16 @@ static void assertInjectionEventBatch(const char *msg, InjectionEvent *ev, int i
}
static void setTestBug299(EngineTestHelper *eth) {
// TODO: switch to mock airmass
eth->persistentConfig.engineConfiguration.fuelAlgorithm = LM_PLAIN_MAF;
setupSimpleTestEngineWithMafAndTT_ONE_trigger(eth);
EXPECT_CALL(eth->mockAirmass, getAirmass(_))
.WillRepeatedly(Return(AirmassResult{0.1008001f, 50.0f}));
Engine *engine = &eth->engine;
EXPAND_Engine
eth->assertRpm(0, "RPM=0");
ASSERT_EQ( 0, getEngineLoadT(PASS_ENGINE_PARAMETER_SIGNATURE)) << "setTestBug299 EL";
eth->fireTriggerEventsWithDuration(20);
// still no RPM since need to cycles measure cycle duration
eth->assertRpm(0, "setTestBug299: RPM#1");
@ -739,7 +740,7 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
ASSERT_FLOAT_EQ(12.5, engine->injectionDuration) << "fuel#2_0";
engine->injectionDuration = 12.5f;
assertEqualsM("duty for maf=3", 62.5, getInjectorDutyCycle(GET_RPM() PASS_ENGINE_PARAMETER_SUFFIX));
ASSERT_EQ( 4, engine->executor.size()) << "qs#1";
@ -798,8 +799,6 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
/**
* one more revolution
*/
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
t = &ENGINE(injectionEvents);
@ -874,7 +873,7 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
eth.firePrimaryTriggerRise();
ASSERT_EQ( 5, engine->executor.size()) << "Queue.size#03";
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
eth.assertInjectorUpEvent("07@0", 0, MS2US(7.5), 1);
eth.assertInjectorDownEvent("07@1", 1, MS2US(10), 0);
eth.assertInjectorUpEvent("07@2", 2, MS2US(17.5), 0);
@ -896,18 +895,13 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
assertInjectionEvent("#2#", &t->elements[2], 0, 1, 315);
assertInjectionEvent("#3#", &t->elements[3], 1, 0, 45 + 90);
setArray(fuelMap.pointers[engineLoadIndex], FUEL_RPM_COUNT, 35);
setArray(fuelMap.pointers[engineLoadIndex + 1], FUEL_RPM_COUNT, 35);
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("fuel#3", 17.5, engine->injectionDuration);
engine->injectionDuration = 17.5;
// duty cycle above 75% is a special use-case because 'special' fuel event overlappes the next normal event in batch mode
assertEqualsM("duty for maf=3", 87.5, getInjectorDutyCycle(GET_RPM() PASS_ENGINE_PARAMETER_SUFFIX));
assertInjectionEvent("#03", &t->elements[0], 0, 0, 315);
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
ASSERT_EQ( 1, enginePins.injectors[0].currentLogicValue) << "inj#0";
@ -922,9 +916,6 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
eth.executeActions();
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
eth.fireRise(20);
ASSERT_EQ( 7, engine->executor.size()) << "Queue.size#05";
eth.executeActions();
@ -937,8 +928,6 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
eth.executeActions();
eth.firePrimaryTriggerRise();
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
t = &ENGINE(injectionEvents);
assertInjectionEvent("#00", &t->elements[0], 0, 0, 225); // 87.5 duty cycle
@ -959,12 +948,6 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
//// assertInjectorDownEvent("8@8", 8, MS2US(45), 1);
//// assertInjectorDownEvent("8@9", 9, MS2US(55), 0);
eth.executeActions();
engine->mockMapValue = 0;
engineConfiguration->mafAdcChannel = EFI_ADC_10;
engine->engineState.mockAdcState.setMockVoltage(EFI_ADC_10, 0 PASS_ENGINE_PARAMETER_SUFFIX);
ASSERT_EQ( 1, unitTestWarningCodeState.recentWarnings.getCount()) << "warningCounter#testFuelSchedulerBug299smallAndMedium";
ASSERT_EQ(CUSTOM_OBD_SKIPPED_FUEL, unitTestWarningCodeState.recentWarnings.get(0));
}
@ -1036,36 +1019,30 @@ TEST(big, testSequential) {
TEST(big, testDifferentInjectionModes) {
WITH_ENGINE_TEST_HELPER(TEST_ENGINE);
setTestBug299(&eth);
ASSERT_EQ( 4, engine->executor.size()) << "Lqs#0";
setupSimpleTestEngineWithMafAndTT_ONE_trigger(&eth);
// set fuel map values - extract method?
int engineLoadIndex = findIndex(config->fuelLoadBins, FUEL_LOAD_COUNT, getMafVoltage(PASS_ENGINE_PARAMETER_SIGNATURE));
ASSERT_EQ(8, engineLoadIndex);
setArray(fuelMap.pointers[engineLoadIndex], FUEL_RPM_COUNT, 40);
setArray(fuelMap.pointers[engineLoadIndex + 1], FUEL_RPM_COUNT, 40);
EXPECT_CALL(eth.mockAirmass, getAirmass(_))
.WillRepeatedly(Return(AirmassResult{1.3440001f, 50.0f}));
setInjectionMode((int)IM_BATCH PASS_ENGINE_PARAMETER_SUFFIX);
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("injectionMode IM_BATCH", (int)IM_BATCH, (int)engineConfiguration->injectionMode);
ASSERT_EQ( 20, engine->injectionDuration) << "injection while batch";
EXPECT_FLOAT_EQ( 20, engine->injectionDuration) << "injection while batch";
setInjectionMode((int)IM_SIMULTANEOUS PASS_ENGINE_PARAMETER_SUFFIX);
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
ASSERT_EQ( 10, engine->injectionDuration) << "injection while simultaneous";
EXPECT_FLOAT_EQ( 10, engine->injectionDuration) << "injection while simultaneous";
setInjectionMode((int)IM_SEQUENTIAL PASS_ENGINE_PARAMETER_SUFFIX);
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
ASSERT_EQ( 40, engine->injectionDuration) << "injection while IM_SEQUENTIAL";
EXPECT_FLOAT_EQ( 40, engine->injectionDuration) << "injection while IM_SEQUENTIAL";
setInjectionMode((int)IM_SINGLE_POINT PASS_ENGINE_PARAMETER_SUFFIX);
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
ASSERT_EQ( 40, engine->injectionDuration) << "injection while IM_SINGLE_POINT";
ASSERT_EQ( 0, unitTestWarningCodeState.recentWarnings.getCount()) << "warningCounter#testDifferentInjectionModes";
EXPECT_FLOAT_EQ( 40, engine->injectionDuration) << "injection while IM_SINGLE_POINT";
EXPECT_EQ( 0, unitTestWarningCodeState.recentWarnings.getCount()) << "warningCounter#testDifferentInjectionModes";
}
TEST(big, testFuelSchedulerBug299smallAndLarge) {
printf("*************************************************** testFuelSchedulerBug299 small to large\r\n");
WITH_ENGINE_TEST_HELPER(TEST_ENGINE);
setTestBug299(&eth);
ASSERT_EQ( 4, engine->executor.size()) << "Lqs#0";
@ -1077,7 +1054,7 @@ TEST(big, testFuelSchedulerBug299smallAndLarge) {
setArray(fuelMap.pointers[engineLoadIndex + 1], FUEL_RPM_COUNT, 35);
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
ASSERT_FLOAT_EQ(17.5, engine->injectionDuration) << "Lfuel#2_1";
engine->injectionDuration = 17.5f;
assertEqualsM("Lduty for maf=3", 87.5, getInjectorDutyCycle(GET_RPM() PASS_ENGINE_PARAMETER_SUFFIX));
@ -1141,7 +1118,7 @@ TEST(big, testFuelSchedulerBug299smallAndLarge) {
setArray(fuelMap.pointers[engineLoadIndex + 1], FUEL_RPM_COUNT, 4);
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
ASSERT_EQ( 2, engine->injectionDuration) << "Lfuel#4";
engine->injectionDuration = 2.0f;
ASSERT_EQ( 10, getInjectorDutyCycle(GET_RPM() PASS_ENGINE_PARAMETER_SUFFIX)) << "Lduty for maf=3";

2
unit_tests/unit_test_framework.cpp
View File

@ -18,7 +18,7 @@ void assertEqualsM2(const char *msg, float expected, float actual, float eps) {
}
void assertEqualsM4(const char *prefix, const char *msg, float expected, float actual) {
ASSERT_NEAR(expected, actual, 0.00001) << prefix << msg;
ASSERT_NEAR(expected, actual, 0.0001f) << prefix << msg;
}
void assertEqualsLM(const char *msg, long expected, long actual) {