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

auto-sync

This commit is contained in:
rusEfi 2014-10-02 13:03:28 -05:00
parent b3c0d3efa3
commit c01b2127c4
14 changed files with 107 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
firmware/console/status_loop.cpp
View File

@ -148,7 +148,7 @@ void printSensors(void) {
reportSensorF(getCaption(LP_ECT), getCoolantTemperature(engineConfiguration2), 2); reportSensorF(getCaption(LP_ECT), getCoolantTemperature(engineConfiguration2), 2);
} }
reportSensorF(getCaption(LP_IAT), getIntakeAirTemperature(), 2); reportSensorF(getCaption(LP_IAT), getIntakeAirTemperature(engineConfiguration2), 2);
// debugFloat(&logger, "tch", getTCharge1(tps), 2); // debugFloat(&logger, "tch", getTCharge1(tps), 2);
@ -174,7 +174,7 @@ void printState(int currentCkpEventCounter) {
debugFloat(&logger, "fuel_base", baseFuel, 2); debugFloat(&logger, "fuel_base", baseFuel, 2);
// debugFloat(&logger, "fuel_iat", getIatCorrection(getIntakeAirTemperature()), 2); // debugFloat(&logger, "fuel_iat", getIatCorrection(getIntakeAirTemperature()), 2);
// debugFloat(&logger, "fuel_clt", getCltCorrection(getCoolantTemperature()), 2); // debugFloat(&logger, "fuel_clt", getCltCorrection(getCoolantTemperature()), 2);
debugFloat(&logger, "fuel_lag", getInjectorLag(getVBatt()), 2); debugFloat(&logger, "fuel_lag", getInjectorLag(engineConfiguration, getVBatt()), 2);
debugFloat(&logger, "fuel", getRunningFuel(baseFuel, &engine, rpm), 2); debugFloat(&logger, "fuel", getRunningFuel(baseFuel, &engine, rpm), 2);
debugFloat(&logger, "timing", getAdvance(rpm, engineLoad), 2); debugFloat(&logger, "timing", getAdvance(rpm, engineLoad), 2);
@ -306,16 +306,16 @@ void updateDevConsoleState(void) {
*/ */
static void showFuelInfo2(float rpm, float engineLoad) { static void showFuelInfo2(float rpm, float engineLoad) {
float baseFuel = getBaseTableFuel((int) rpm, engineLoad); float baseFuel = getBaseTableFuel(engineConfiguration, (int) rpm, engineLoad);
scheduleMsg(&logger2, "algo=%s/pump=%s", algorithmToString(engineConfiguration->algorithm), boolToString(getOutputPinValue(FUEL_PUMP_RELAY))); scheduleMsg(&logger2, "algo=%s/pump=%s", algorithmToString(engineConfiguration->algorithm), boolToString(getOutputPinValue(FUEL_PUMP_RELAY)));
scheduleMsg(&logger2, "cranking fuel: %f", getCrankingFuel(&engine)); scheduleMsg(&logger2, "cranking fuel: %f", getCrankingFuel(&engine));
if (engine.rpmCalculator->isRunning()) { if (engine.rpmCalculator->isRunning()) {
float iatCorrection = getIatCorrection(getIntakeAirTemperature()); float iatCorrection = getIatCorrection(getIntakeAirTemperature(engineConfiguration2));
float cltCorrection = getCltCorrection(getCoolantTemperature(engineConfiguration2)); float cltCorrection = getCltCorrection(getCoolantTemperature(engineConfiguration2));
float injectorLag = getInjectorLag(getVBatt()); float injectorLag = getInjectorLag(engineConfiguration, getVBatt());
scheduleMsg(&logger2, "rpm=%f engineLoad=%f", rpm, engineLoad); scheduleMsg(&logger2, "rpm=%f engineLoad=%f", rpm, engineLoad);
scheduleMsg(&logger2, "baseFuel=%f", baseFuel); scheduleMsg(&logger2, "baseFuel=%f", baseFuel);
@ -358,10 +358,10 @@ void updateTunerStudioState(TunerStudioOutputChannels *tsOutputChannels) {
float tps = getTPS(); float tps = getTPS();
float coolant = getCoolantTemperature(engineConfiguration2); float coolant = getCoolantTemperature(engineConfiguration2);
float intake = getIntakeAirTemperature(); float intake = getIntakeAirTemperature(engineConfiguration2);
float engineLoad = getEngineLoad(); float engineLoad = getEngineLoad();
float baseFuel = getBaseTableFuel((int) rpm, engineLoad); float baseFuel = getBaseTableFuel(engineConfiguration, (int) rpm, engineLoad);
tsOutputChannels->rpm = rpm; tsOutputChannels->rpm = rpm;
tsOutputChannels->coolant_temperature = coolant; tsOutputChannels->coolant_temperature = coolant;
@ -389,7 +389,7 @@ void updateTunerStudioState(TunerStudioOutputChannels *tsOutputChannels) {
tsOutputChannels->secondTriggerChannelEnabled = engineConfiguration->secondTriggerChannelEnabled; tsOutputChannels->secondTriggerChannelEnabled = engineConfiguration->secondTriggerChannelEnabled;
tsOutputChannels->isCltError = !isValidCoolantTemperature(getCoolantTemperature(engineConfiguration2)); tsOutputChannels->isCltError = !isValidCoolantTemperature(getCoolantTemperature(engineConfiguration2));
tsOutputChannels->isIatError = !isValidIntakeAirTemperature(getIntakeAirTemperature()); tsOutputChannels->isIatError = !isValidIntakeAirTemperature(getIntakeAirTemperature(engineConfiguration2));
#endif #endif
tsOutputChannels->tCharge = getTCharge(rpm, tps, coolant, intake); tsOutputChannels->tCharge = getTCharge(rpm, tps, coolant, intake);
tsOutputChannels->sparkDwell = getSparkDwellMs(rpm); tsOutputChannels->sparkDwell = getSparkDwellMs(rpm);

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

@ -28,7 +28,7 @@
#include "speed_density.h" #include "speed_density.h"
void initDataStructures(engine_configuration_s *engineConfiguration) { void initDataStructures(engine_configuration_s *engineConfiguration) {
prepareFuelMap(); prepareFuelMap(engineConfiguration);
prepareTimingMap(); prepareTimingMap();
initSpeedDensity(engineConfiguration); initSpeedDensity(engineConfiguration);
} }

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

@ -22,7 +22,7 @@ static Logging logger;
* We are executing these heavy (logarithm) methods from outside the trigger callbacks for performance reasons. * We are executing these heavy (logarithm) methods from outside the trigger callbacks for performance reasons.
*/ */
void Engine::updateSlowSensors() { void Engine::updateSlowSensors() {
engineState.iat = getIntakeAirTemperature(); engineState.iat = getIntakeAirTemperature(engineConfiguration2);
engineState.clt = getCoolantTemperature(engineConfiguration2); engineState.clt = getCoolantTemperature(engineConfiguration2);
} }

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

@ -46,7 +46,7 @@ float getBaseFuel(Engine *engine, int rpm) {
return getSpeedDensityFuel(engine, rpm); return getSpeedDensityFuel(engine, rpm);
} else { } else {
float engineLoad = getEngineLoadT(engine); float engineLoad = getEngineLoadT(engine);
return getBaseTableFuel(rpm, engineLoad); return getBaseTableFuel(engine->engineConfiguration, rpm, engineLoad);
} }
} }
@ -83,9 +83,10 @@ float getFuelMs(int rpm, Engine *engine) {
// todo: start using 'engine' parameter and not 'extern' // todo: start using 'engine' parameter and not 'extern'
float getRunningFuel(float baseFuel, Engine *engine, int rpm) { float getRunningFuel(float baseFuel, Engine *engine, int rpm) {
float iatCorrection = getIatCorrection(getIntakeAirTemperature()); engine_configuration_s *engineConfiguration = engine->engineConfiguration;
float cltCorrection = getCltCorrection(getCoolantTemperature(engine->engineConfiguration2)); float iatCorrection = getIatCorrection(engineConfiguration, getIntakeAirTemperature(engine->engineConfiguration2));
float injectorLag = getInjectorLag(getVBatt()); float cltCorrection = getCltCorrection(engineConfiguration, getCoolantTemperature(engine->engineConfiguration2));
float injectorLag = getInjectorLag(engineConfiguration, getVBatt());
#if EFI_ACCEL_ENRICHMENT #if EFI_ACCEL_ENRICHMENT
float accelEnrichment = getAccelEnrichment(); float accelEnrichment = getAccelEnrichment();
@ -105,7 +106,7 @@ static Map3D1616 fuelMap;
* @param vBatt Battery voltage. * @param vBatt Battery voltage.
* @return Time in ms for injection opening time based on current battery voltage * @return Time in ms for injection opening time based on current battery voltage
*/ */
float getInjectorLag(float vBatt) { float getInjectorLag(engine_configuration_s *engineConfiguration, float vBatt) {
if (cisnan(vBatt)) { if (cisnan(vBatt)) {
warning(OBD_System_Voltage_Malfunction, "vBatt=%f", vBatt); warning(OBD_System_Voltage_Malfunction, "vBatt=%f", vBatt);
return 0; return 0;
@ -120,20 +121,20 @@ float getInjectorLag(float vBatt) {
* @note this method has nothing to do with fuel map VALUES - it's job * @note this method has nothing to do with fuel map VALUES - it's job
* is to prepare the fuel map data structure for 3d interpolation * is to prepare the fuel map data structure for 3d interpolation
*/ */
void prepareFuelMap(void) { void prepareFuelMap(engine_configuration_s *engineConfiguration) {
fuelMap.init(engineConfiguration->fuelTable); fuelMap.init(engineConfiguration->fuelTable);
} }
/** /**
* @brief Engine warm-up fuel correction. * @brief Engine warm-up fuel correction.
*/ */
float getCltCorrection(float clt) { float getCltCorrection(engine_configuration_s *engineConfiguration, float clt) {
if (cisnan(clt)) if (cisnan(clt))
return 1; // this error should be already reported somewhere else, let's just handle it return 1; // this error should be already reported somewhere else, let's just handle it
return interpolate2d(clt, engineConfiguration->cltFuelCorrBins, engineConfiguration->cltFuelCorr, CLT_CURVE_SIZE); return interpolate2d(clt, engineConfiguration->cltFuelCorrBins, engineConfiguration->cltFuelCorr, CLT_CURVE_SIZE);
} }
float getIatCorrection(float iat) { float getIatCorrection(engine_configuration_s *engineConfiguration, float iat) {
if (cisnan(iat)) if (cisnan(iat))
return 1; // this error should be already reported somewhere else, let's just handle it return 1; // this error should be already reported somewhere else, let's just handle it
return interpolate2d(iat, engineConfiguration->iatFuelCorrBins, engineConfiguration->iatFuelCorr, IAT_CURVE_SIZE); return interpolate2d(iat, engineConfiguration->iatFuelCorrBins, engineConfiguration->iatFuelCorr, IAT_CURVE_SIZE);
@ -142,7 +143,7 @@ float getIatCorrection(float iat) {
/** /**
* @return Fuel injection duration injection as specified in the fuel map, in milliseconds * @return Fuel injection duration injection as specified in the fuel map, in milliseconds
*/ */
float getBaseTableFuel(int rpm, float engineLoad) { float getBaseTableFuel(engine_configuration_s *engineConfiguration, int rpm, float engineLoad) {
if (cisnan(engineLoad)) { if (cisnan(engineLoad)) {
warning(OBD_PCM_Processor_Fault, "NaN engine load"); warning(OBD_PCM_Processor_Fault, "NaN engine load");
return NAN; return NAN;
@ -155,10 +156,11 @@ float getBaseTableFuel(int rpm, float engineLoad) {
* @return Duration of fuel injection while craning, in milliseconds * @return Duration of fuel injection while craning, in milliseconds
*/ */
float getCrankingFuel(Engine *engine) { float getCrankingFuel(Engine *engine) {
return getStartingFuel(getCoolantTemperature(engine->engineConfiguration2)); return getStartingFuel(engine->engineConfiguration,
getCoolantTemperature(engine->engineConfiguration2));
} }
float getStartingFuel(float coolantTemperature) { float getStartingFuel(engine_configuration_s *engineConfiguration, float coolantTemperature) {
// these magic constants are in Celsius // these magic constants are in Celsius
if (cisnan(coolantTemperature) || coolantTemperature < engineConfiguration->crankingSettings.coolantTempMinC) if (cisnan(coolantTemperature) || coolantTemperature < engineConfiguration->crankingSettings.coolantTempMinC)
return engineConfiguration->crankingSettings.fuelAtMinTempMs; return engineConfiguration->crankingSettings.fuelAtMinTempMs;

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

@ -10,16 +10,16 @@
#include "engine.h" #include "engine.h"
void prepareFuelMap(void); void prepareFuelMap(engine_configuration_s *engineConfiguration);
float getBaseFuel(Engine *engine, int rpm); float getBaseFuel(Engine *engine, int rpm);
float getBaseTableFuel(int rpm, float engineLoad); float getBaseTableFuel(engine_configuration_s *engineConfiguration, int rpm, float engineLoad);
float getIatCorrection(float iat); float getIatCorrection(engine_configuration_s *engineConfiguration, float iat);
float getInjectorLag(float vBatt); float getInjectorLag(engine_configuration_s *engineConfiguration, float vBatt);
float getCltCorrection(float clt); float getCltCorrection(engine_configuration_s *engineConfiguration, float clt);
float getRunningFuel(float baseFuel, Engine *engine, int rpm); float getRunningFuel(float baseFuel, Engine *engine, int rpm);
float getCrankingFuel(Engine *engine); float getCrankingFuel(Engine *engine);
float getStartingFuel(float coolantTemperature); float getStartingFuel(engine_configuration_s *engineConfiguration, float coolantTemperature);
float getFuelMs(int rpm, Engine *engine); float getFuelMs(int rpm, Engine *engine);
#endif /* FUEL_MAP_H_ */ #endif /* FUEL_MAP_H_ */

2
firmware/controllers/math/speed_density.cpp
View File

@ -68,7 +68,7 @@ float getSpeedDensityFuel(Engine *engine, int rpm) {
float tps = getTPS(); float tps = getTPS();
float coolantC = getCoolantTemperature(engine->engineConfiguration2); float coolantC = getCoolantTemperature(engine->engineConfiguration2);
float intakeC = getIntakeAirTemperature(); float intakeC = getIntakeAirTemperature(engine->engineConfiguration2);
float tChargeK = convertCelsiusToKelvin(getTCharge(rpm, tps, coolantC, intakeC)); float tChargeK = convertCelsiusToKelvin(getTCharge(rpm, tps, coolantC, intakeC));
float map = getMap(); float map = getMap();
float VE = veMap.getValue(map, engineConfiguration->veLoadBins, rpm, float VE = veMap.getValue(map, engineConfiguration->veLoadBins, rpm,

4
firmware/controllers/sensors/allsensors.cpp
View File

@ -9,6 +9,8 @@
#include "allsensors.h" #include "allsensors.h"
extern Engine engine;
void initSensors(void) { void initSensors(void) {
initThermistors(); initThermistors(&engine);
} }

14
firmware/controllers/sensors/thermistors.cpp
View File

@ -78,7 +78,7 @@ float getKelvinTemperature(float resistance, ThermistorConf *thermistor) {
float getResistance(Thermistor *thermistor) { float getResistance(Thermistor *thermistor) {
float voltage = getVoltageDivided(thermistor->channel); float voltage = getVoltageDivided(thermistor->channel);
efiAssert(thermistor->config != NULL, "config is null", NAN); efiAssert(thermistor->config != NULL, "thermistor config is null", NAN);
float resistance = getR2InVoltageDividor(voltage, _5_VOLTS, thermistor->config->bias_resistor); float resistance = getR2InVoltageDividor(voltage, _5_VOLTS, thermistor->config->bias_resistor);
return resistance; return resistance;
} }
@ -152,7 +152,7 @@ void prepareThermistorCurve(ThermistorConf * config) {
/** /**
* @return Celsius value * @return Celsius value
*/ */
float getIntakeAirTemperature(void) { float getIntakeAirTemperature(engine_configuration2_s * engineConfiguration2) {
float temperature = getTemperatureC(&engineConfiguration2->iat); float temperature = getTemperatureC(&engineConfiguration2->iat);
if (!isValidIntakeAirTemperature(temperature)) { if (!isValidIntakeAirTemperature(temperature)) {
warning(OBD_PCM_Processor_Fault, "unrealistic IAT %f", temperature); warning(OBD_PCM_Processor_Fault, "unrealistic IAT %f", temperature);
@ -178,10 +178,10 @@ void setCommonNTCSensor(ThermistorConf *thermistorConf) {
setThermistorConfiguration(thermistorConf, -20, 18000, 23.8889, 2100, 120.0, 100.0); setThermistorConfiguration(thermistorConf, -20, 18000, 23.8889, 2100, 120.0, 100.0);
} }
void initThermistors(void) { void initThermistors(Engine *engine) {
initThermistorCurve(&engineConfiguration2->clt, &engineConfiguration->cltThermistorConf, initThermistorCurve(&engine->engineConfiguration2->clt, &engine->engineConfiguration->cltThermistorConf,
engineConfiguration->cltAdcChannel); engine->engineConfiguration->cltAdcChannel);
initThermistorCurve(&engineConfiguration2->iat, &engineConfiguration->iatThermistorConf, initThermistorCurve(&engine->engineConfiguration2->iat, &engine->engineConfiguration->iatThermistorConf,
engineConfiguration->iatAdcChannel); engine->engineConfiguration->iatAdcChannel);
initialized = TRUE; initialized = TRUE;
} }

7
firmware/controllers/sensors/thermistors.h
View File

@ -40,7 +40,7 @@ float getResistance(Thermistor *thermistor);
float getTemperatureC(Thermistor *thermistor); float getTemperatureC(Thermistor *thermistor);
float getCoolantTemperature(engine_configuration2_s * engineConfiguration2); float getCoolantTemperature(engine_configuration2_s * engineConfiguration2);
bool isValidCoolantTemperature(float temperature); bool isValidCoolantTemperature(float temperature);
float getIntakeAirTemperature(void); float getIntakeAirTemperature(engine_configuration2_s * engineConfiguration2);
bool isValidIntakeAirTemperature(float temperature); bool isValidIntakeAirTemperature(float temperature);
float convertResistanceToKelvinTemperature(float resistance, float convertResistanceToKelvinTemperature(float resistance,
@ -48,7 +48,10 @@ float convertResistanceToKelvinTemperature(float resistance,
void setThermistorConfiguration(ThermistorConf * tc, float temp1, float r1, float temp2, float r2, float temp3, void setThermistorConfiguration(ThermistorConf * tc, float temp1, float r1, float temp2, float r2, float temp3,
float r3); float r3);
void prepareThermistorCurve(ThermistorConf * config); void prepareThermistorCurve(ThermistorConf * config);
void initThermistors(void);
class Engine;
void initThermistors(Engine *engine);
void setCommonNTCSensor(ThermistorConf *thermistorConf); void setCommonNTCSensor(ThermistorConf *thermistorConf);

2
firmware/emulation/rfi_perftest.cpp
View File

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

4
unit_tests/engine_test_helper.cpp
View File

@ -9,6 +9,7 @@
#include "stddef.h" #include "stddef.h"
#include "trigger_decoder.h" #include "trigger_decoder.h"
#include "speed_density.h" #include "speed_density.h"
#include "fuel_math.h"
extern int timeNow; extern int timeNow;
@ -19,6 +20,9 @@ EngineTestHelper::EngineTestHelper(engine_type_e engineType) {
configuration.engineConfiguration = ec; configuration.engineConfiguration = ec;
configuration.engineConfiguration2 = &ec2; configuration.engineConfiguration2 = &ec2;
engine.engineConfiguration2 = &ec2;
prepareFuelMap(engine.engineConfiguration);
initSpeedDensity(ec); initSpeedDensity(ec);

3
unit_tests/main.cpp
View File

@ -101,7 +101,6 @@ int main(void) {
testInterpolate2d(); testInterpolate2d();
testGpsParser(); testGpsParser();
testMisc(); testMisc();
prepareFuelMap();
testFuelMap(); testFuelMap();
testEngineMath(); testEngineMath();
testEventRegistry(); testEventRegistry();
@ -131,7 +130,7 @@ int main(void) {
testFLStack(); testFLStack();
// resizeMap(); // resizeMap();
printf("Success 20131001\r\n"); printf("Success 20131002\r\n");
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }

100
unit_tests/test_fuel_map.cpp
View File

@ -20,75 +20,72 @@
extern float testMafValue; extern float testMafValue;
extern engine_configuration_s *engineConfiguration;
extern engine_configuration2_s *engineConfiguration2;
void testFuelMap(void) { void testFuelMap(void) {
chDbgCheck(engineConfiguration!=NULL, "engineConfiguration");
printf("*************************************************** testFuelMap\r\n"); printf("*************************************************** testFuelMap\r\n");
for (int k = 0; k < FUEL_LOAD_COUNT; k++) {
for (int r = 0; r < FUEL_RPM_COUNT; r++) {
engineConfiguration->fuelTable[k][r] = k * 200 + r;
}
}
printf("*************************************************** initThermistors\r\n");
initThermistors();
printf("*** getInjectorLag\r\n");
assertEquals(0, getInjectorLag(12));
for (int i = 0; i < FUEL_LOAD_COUNT; i++)
engineConfiguration->fuelLoadBins[i] = i;
for (int i = 0; i < FUEL_RPM_COUNT; i++)
engineConfiguration->fuelRpmBins[i] = i;
printf("*************************************************** prepareFuelMap\r\n");
assertEquals(1005, getBaseTableFuel(5, 5));
engineConfiguration->injectorLag = 0.5;
for (int i = 0; i < VBAT_INJECTOR_CURVE_SIZE; i++) {
engineConfiguration->battInjectorLagCorrBins[i] = i;
engineConfiguration->battInjectorLagCorr[i] = 2 * i;
}
EngineTestHelper eth(FORD_ASPIRE_1996); EngineTestHelper eth(FORD_ASPIRE_1996);
for (int k = 0; k < FUEL_LOAD_COUNT; k++) {
for (int r = 0; r < FUEL_RPM_COUNT; r++) {
eth.engine.engineConfiguration->fuelTable[k][r] = k * 200 + r;
}
}
for (int i = 0; i < FUEL_LOAD_COUNT; i++)
eth.engine.engineConfiguration->fuelLoadBins[i] = i;
for (int i = 0; i < FUEL_RPM_COUNT; i++)
eth.engine.engineConfiguration->fuelRpmBins[i] = i;
assertEqualsM("base fuel table", 1005, getBaseTableFuel(eth.engine.engineConfiguration, 5, 5));
printf("*************************************************** initThermistors\r\n");
initThermistors(&eth.engine);
printf("*** getInjectorLag\r\n");
assertEquals(0, getInjectorLag(eth.engine.engineConfiguration, 12));
eth.engine.engineConfiguration->injectorLag = 0.5;
for (int i = 0; i < VBAT_INJECTOR_CURVE_SIZE; i++) {
eth.engine.engineConfiguration->battInjectorLagCorrBins[i] = i;
eth.engine.engineConfiguration->battInjectorLagCorr[i] = 2 * i;
}
// because all the correction tables are zero // because all the correction tables are zero
printf("*************************************************** getRunningFuel\r\n"); printf("*************************************************** getRunningFuel 1\r\n");
float baseFuel = getBaseTableFuel(5, getEngineLoadT(&eth.engine)); float baseFuel = getBaseTableFuel(eth.engine.engineConfiguration, 5, getEngineLoadT(&eth.engine));
assertEqualsM("value", 0.5, getRunningFuel(baseFuel, &eth.engine, 5)); assertEqualsM("base fuel", 5.5, getRunningFuel(baseFuel, &eth.engine, 5));
printf("*************************************************** setting IAT table\r\n"); printf("*************************************************** setting IAT table\r\n");
for (int i = 0; i < IAT_CURVE_SIZE; i++) { for (int i = 0; i < IAT_CURVE_SIZE; i++) {
engineConfiguration->iatFuelCorrBins[i] = i; eth.engine.engineConfiguration->iatFuelCorrBins[i] = i;
engineConfiguration->iatFuelCorr[i] = 2 * i; eth.engine.engineConfiguration->iatFuelCorr[i] = 2 * i;
} }
engineConfiguration->iatFuelCorr[0] = 2; eth.engine.engineConfiguration->iatFuelCorr[0] = 2;
printf("*************************************************** setting CLT table\r\n"); printf("*************************************************** setting CLT table\r\n");
for (int i = 0; i < CLT_CURVE_SIZE; i++) { for (int i = 0; i < CLT_CURVE_SIZE; i++) {
engineConfiguration->cltFuelCorrBins[i] = i; eth.engine.engineConfiguration->cltFuelCorrBins[i] = i;
engineConfiguration->cltFuelCorr[i] = 1; eth.engine.engineConfiguration->cltFuelCorr[i] = 1;
} }
engineConfiguration->injectorLag = 0; eth.engine.engineConfiguration->injectorLag = 0;
assertEquals(NAN, getIntakeAirTemperature()); engine_configuration_s *engineConfiguration = eth.engine.engineConfiguration;
float iatCorrection = getIatCorrection(-KELV);
assertEquals(NAN, getIntakeAirTemperature(eth.engine.engineConfiguration2));
float iatCorrection = getIatCorrection(engineConfiguration, -KELV);
assertEqualsM("IAT", 2, iatCorrection); assertEqualsM("IAT", 2, iatCorrection);
float cltCorrection = getCltCorrection(getCoolantTemperature(engineConfiguration2)); float cltCorrection = getCltCorrection(engineConfiguration, getCoolantTemperature(eth.engine.engineConfiguration2));
assertEqualsM("CLT", 1, cltCorrection); assertEqualsM("CLT", 1, cltCorrection);
float injectorLag = getInjectorLag(getVBatt()); float injectorLag = getInjectorLag(engineConfiguration, getVBatt());
assertEquals(0, injectorLag); assertEquals(0, injectorLag);
testMafValue = 5; testMafValue = 5;
// 1005 * 2 for IAT correction // 1005 * 2 for IAT correction
printf("*************************************************** getRunningFuel\r\n"); printf("*************************************************** getRunningFuel 2\r\n");
baseFuel = getBaseTableFuel(5, getEngineLoadT(&eth.engine)); baseFuel = getBaseTableFuel(eth.engine.engineConfiguration, 5, getEngineLoadT(&eth.engine));
assertEqualsM("v1", 30150, getRunningFuel(baseFuel, &eth.engine, 5)); assertEqualsM("v1", 30150, getRunningFuel(baseFuel, &eth.engine, 5));
testMafValue = 0; testMafValue = 0;
@ -102,11 +99,14 @@ void testFuelMap(void) {
printf("*************************************************** getStartingFuel\r\n"); printf("*************************************************** getStartingFuel\r\n");
// NAN in case we have issues with the CLT sensor // NAN in case we have issues with the CLT sensor
// assertEquals(16, getStartingFuel(NAN)); // assertEquals(16, getStartingFuel(NAN));
assertEquals(20, getStartingFuel(0)); assertEquals(20, getStartingFuel(engineConfiguration, 0));
assertEquals(18.5231, getStartingFuel(8)); assertEquals(18.5231, getStartingFuel(engineConfiguration, 8));
assertEquals(8, getStartingFuel(70)); assertEquals(8, getStartingFuel(engineConfiguration, 70));
} }
extern engine_configuration_s *engineConfiguration;
extern engine_configuration2_s *engineConfiguration2;
static void confgiureFordAspireTriggerShape(trigger_shape_s * s) { static void confgiureFordAspireTriggerShape(trigger_shape_s * s) {
s->reset(FOUR_STROKE_CAM_SENSOR); s->reset(FOUR_STROKE_CAM_SENSOR);

12
unit_tests/test_trigger_decoder.cpp
View File

@ -342,10 +342,10 @@ extern EventQueue schedulingQueue;
static void testRpmCalculator(void) { static void testRpmCalculator(void) {
printf("*************************************************** testRpmCalculator\r\n"); printf("*************************************************** testRpmCalculator\r\n");
initThermistors();
EngineTestHelper eth(FORD_INLINE_6_1995); EngineTestHelper eth(FORD_INLINE_6_1995);
initThermistors(&eth.engine);
engine_configuration_s *ec = &eth.persistentConfig.engineConfiguration; engine_configuration_s *ec = &eth.persistentConfig.engineConfiguration;
engine_configuration2_s *ec2 = &eth.ec2; engine_configuration2_s *ec2 = &eth.ec2;
@ -375,7 +375,7 @@ static void testRpmCalculator(void) {
eth.triggerCentral.handleShaftSignal(&configuration, SHAFT_PRIMARY_UP, timeNow); eth.triggerCentral.handleShaftSignal(&configuration, SHAFT_PRIMARY_UP, timeNow);
assertEqualsM("index #2", 0, eth.triggerCentral.triggerState.getCurrentIndex()); assertEqualsM("index #2", 0, eth.triggerCentral.triggerState.getCurrentIndex());
assertEqualsM("queue size", 4, schedulingQueue.size()); assertEqualsM("queue size", 4, schedulingQueue.size());
assertEqualsM("ev 1", 695000, schedulingQueue.getForUnitText(0)->momentUs); assertEqualsM("ev 1", 248000, schedulingQueue.getForUnitText(0)->momentUs);
assertEqualsM("ev 2", 245000, schedulingQueue.getForUnitText(1)->momentUs); assertEqualsM("ev 2", 245000, schedulingQueue.getForUnitText(1)->momentUs);
schedulingQueue.clear(); schedulingQueue.clear();
@ -389,7 +389,7 @@ static void testRpmCalculator(void) {
assertEqualsM("queue size 3", 6, schedulingQueue.size()); assertEqualsM("queue size 3", 6, schedulingQueue.size());
assertEquals(258333, schedulingQueue.getForUnitText(0)->momentUs); assertEquals(258333, schedulingQueue.getForUnitText(0)->momentUs);
assertEquals(257833, schedulingQueue.getForUnitText(1)->momentUs); assertEquals(257833, schedulingQueue.getForUnitText(1)->momentUs);
assertEqualsM("ev 5", 708333, schedulingQueue.getForUnitText(2)->momentUs); assertEqualsM("ev 5", 261333, schedulingQueue.getForUnitText(2)->momentUs);
assertEqualsM("3/3", 258333, schedulingQueue.getForUnitText(3)->momentUs); assertEqualsM("3/3", 258333, schedulingQueue.getForUnitText(3)->momentUs);
schedulingQueue.clear(); schedulingQueue.clear();
@ -414,7 +414,7 @@ static void testRpmCalculator(void) {
eth.triggerCentral.handleShaftSignal(&configuration, SHAFT_PRIMARY_UP, timeNow); eth.triggerCentral.handleShaftSignal(&configuration, SHAFT_PRIMARY_UP, timeNow);
assertEqualsM("queue size 6", 5, schedulingQueue.size()); assertEqualsM("queue size 6", 5, schedulingQueue.size());
assertEqualsM("6/0", 285000, schedulingQueue.getForUnitText(0)->momentUs); assertEqualsM("6/0", 285000, schedulingQueue.getForUnitText(0)->momentUs);
assertEqualsM("6/1", 735000, schedulingQueue.getForUnitText(1)->momentUs); assertEqualsM("6/1", 288000, schedulingQueue.getForUnitText(1)->momentUs);
assertEqualsM("6/0", 285000, schedulingQueue.getForUnitText(2)->momentUs); assertEqualsM("6/0", 285000, schedulingQueue.getForUnitText(2)->momentUs);
schedulingQueue.clear(); schedulingQueue.clear();
@ -428,7 +428,7 @@ static void testRpmCalculator(void) {
assertEqualsM("queue size 8", 6, schedulingQueue.size()); assertEqualsM("queue size 8", 6, schedulingQueue.size());
assertEqualsM("8/0", 298333, schedulingQueue.getForUnitText(0)->momentUs); assertEqualsM("8/0", 298333, schedulingQueue.getForUnitText(0)->momentUs);
assertEqualsM("8/1", 297833, schedulingQueue.getForUnitText(1)->momentUs); assertEqualsM("8/1", 297833, schedulingQueue.getForUnitText(1)->momentUs);
assertEqualsM("8/2", 748333, schedulingQueue.getForUnitText(2)->momentUs); assertEqualsM("8/2", 301333, schedulingQueue.getForUnitText(2)->momentUs);
assertEqualsM("8/3", 298333, schedulingQueue.getForUnitText(3)->momentUs); assertEqualsM("8/3", 298333, schedulingQueue.getForUnitText(3)->momentUs);
schedulingQueue.clear(); schedulingQueue.clear();