diff --git a/firmware/console/status_loop.cpp b/firmware/console/status_loop.cpp index 3432e43cd0..2bbf1fcb6e 100644 --- a/firmware/console/status_loop.cpp +++ b/firmware/console/status_loop.cpp @@ -143,10 +143,10 @@ void printSensors(Engine *engine) { reportSensorF(getCaption(LP_THROTTLE), getTPS(engine->engineConfiguration), 2); if (engineConfiguration->hasCltSensor) { - reportSensorF(getCaption(LP_ECT), getCoolantTemperature(engineConfiguration2), 2); + reportSensorF(getCaption(LP_ECT), getCoolantTemperature(engine), 2); } - reportSensorF(getCaption(LP_IAT), getIntakeAirTemperature(engineConfiguration2), 2); + reportSensorF(getCaption(LP_IAT), getIntakeAirTemperature(engine), 2); // debugFloat(&logger, "tch", getTCharge1(tps), 2); @@ -311,8 +311,8 @@ static void showFuelInfo2(float rpm, float engineLoad, Engine *engine) { scheduleMsg(&logger2, "cranking fuel: %f", getCrankingFuel(engine)); if (engine->rpmCalculator->isRunning()) { - float iatCorrection = getIatCorrection(engineConfiguration, getIntakeAirTemperature(engineConfiguration2)); - float cltCorrection = getCltCorrection(engineConfiguration, getCoolantTemperature(engineConfiguration2)); + float iatCorrection = getIatCorrection(engineConfiguration, getIntakeAirTemperature(engine)); + float cltCorrection = getCltCorrection(engineConfiguration, getCoolantTemperature(engine)); float injectorLag = getInjectorLag(engineConfiguration, getVBatt()); scheduleMsg(&logger2, "rpm=%f engineLoad=%f", rpm, engineLoad); scheduleMsg(&logger2, "baseFuel=%f", baseFuelMs); @@ -409,8 +409,8 @@ void updateTunerStudioState(Engine *engine, TunerStudioOutputChannels *tsOutputC #endif float tps = getTPS(engineConfiguration); - float coolant = getCoolantTemperature(engineConfiguration2); - float intake = getIntakeAirTemperature(engineConfiguration2); + float coolant = getCoolantTemperature(engine); + float intake = getIntakeAirTemperature(engine); float engineLoad = getEngineLoadT(engine); float baseFuelMs = getBaseTableFuel(engineConfiguration, (int) rpm, engineLoad); @@ -438,11 +438,11 @@ void updateTunerStudioState(Engine *engine, TunerStudioOutputChannels *tsOutputC tsOutputChannels->ignition_enabled = engineConfiguration->isIgnitionEnabled; tsOutputChannels->injection_enabled = engineConfiguration->isInjectionEnabled; tsOutputChannels->cylinder_cleanup_enabled = engineConfiguration->isCylinderCleanupEnabled; - tsOutputChannels->cylinder_cleanup_activated = engineConfiguration2->isCylinderCleanupMode; + tsOutputChannels->cylinder_cleanup_activated = engine->isCylinderCleanupMode; tsOutputChannels->secondTriggerChannelEnabled = engineConfiguration->secondTriggerChannelEnabled; - tsOutputChannels->isCltError = !isValidCoolantTemperature(getCoolantTemperature(engineConfiguration2)); - tsOutputChannels->isIatError = !isValidIntakeAirTemperature(getIntakeAirTemperature(engineConfiguration2)); + tsOutputChannels->isCltError = !isValidCoolantTemperature(getCoolantTemperature(engine)); + tsOutputChannels->isIatError = !isValidIntakeAirTemperature(getIntakeAirTemperature(engine)); #endif tsOutputChannels->tCharge = getTCharge(rpm, tps, coolant, intake); tsOutputChannels->sparkDwell = getSparkDwellMs(rpm); diff --git a/firmware/controllers/algo/ec2.h b/firmware/controllers/algo/ec2.h index 648bd9345a..db37d5be8e 100644 --- a/firmware/controllers/algo/ec2.h +++ b/firmware/controllers/algo/ec2.h @@ -44,28 +44,16 @@ class engine_configuration2_s { public: engine_configuration2_s(); + // todo: this should go, too engine_configuration_s *engineConfiguration; - Thermistor iat; - Thermistor clt; trigger_shape_s triggerShape; EventHandlerConfiguration engineEventConfiguration; - - /** - * This coefficient translates ADC value directly into voltage adjusted according to - * voltage divider configuration. This is a future (?) performance optimization. - */ - float adcToVoltageInputDividerCoefficient; - - /** - * This field is true if we are in 'cylinder cleanup' state right now - * see isCylinderCleanupEnabled - */ - bool isCylinderCleanupMode; }; +// todo: eliminate this structure? we have Engine and engineConfiguration2 now references engineConfiguration typedef struct { engine_configuration_s *engineConfiguration; engine_configuration2_s *engineConfiguration2; diff --git a/firmware/controllers/algo/engine.cpp b/firmware/controllers/algo/engine.cpp index 7487a94bfb..37122f63f3 100644 --- a/firmware/controllers/algo/engine.cpp +++ b/firmware/controllers/algo/engine.cpp @@ -22,8 +22,8 @@ static Logging logger; * We are executing these heavy (logarithm) methods from outside the trigger callbacks for performance reasons. */ void Engine::updateSlowSensors() { - engineState.iat = getIntakeAirTemperature(engineConfiguration2); - engineState.clt = getCoolantTemperature(engineConfiguration2); + engineState.iat = getIntakeAirTemperature(this); + engineState.clt = getCoolantTemperature(this); } void Engine::onTriggerEvent(uint64_t nowUs) { diff --git a/firmware/controllers/algo/engine.h b/firmware/controllers/algo/engine.h index 455cef65f5..b5db41a279 100644 --- a/firmware/controllers/algo/engine.h +++ b/firmware/controllers/algo/engine.h @@ -31,10 +31,26 @@ public: engine_configuration_s *engineConfiguration; engine_configuration2_s *engineConfiguration2; + Thermistor iat; + Thermistor clt; + void onTriggerEvent(uint64_t nowUs); EngineState engineState; uint64_t lastTriggerEventTimeUs; + /** + * This coefficient translates ADC value directly into voltage adjusted according to + * voltage divider configuration. This is a future (?) performance optimization. + */ + float adcToVoltageInputDividerCoefficient; + + /** + * This field is true if we are in 'cylinder cleanup' state right now + * see isCylinderCleanupEnabled + */ + bool isCylinderCleanupMode; + + void updateSlowSensors(); void watchdog(); private: diff --git a/firmware/controllers/algo/engine_configuration.cpp b/firmware/controllers/algo/engine_configuration.cpp index ee8e882161..70557922e9 100644 --- a/firmware/controllers/algo/engine_configuration.cpp +++ b/firmware/controllers/algo/engine_configuration.cpp @@ -511,6 +511,7 @@ void resetConfigurationExt(Logging * logger, engine_type_e engineType, engine_co } engine_configuration2_s::engine_configuration2_s() { + engineConfiguration = NULL; } void applyNonPersistentConfiguration(Logging * logger, engine_configuration_s *engineConfiguration, diff --git a/firmware/controllers/algo/fuel_math.cpp b/firmware/controllers/algo/fuel_math.cpp index 10d7456b4e..77b166d41f 100644 --- a/firmware/controllers/algo/fuel_math.cpp +++ b/firmware/controllers/algo/fuel_math.cpp @@ -87,8 +87,8 @@ float getFuelMs(int rpm, Engine *engine) { float getRunningFuel(float baseFuelMs, Engine *engine, int rpm) { engine_configuration_s *engineConfiguration = engine->engineConfiguration; - float iatCorrection = getIatCorrection(engineConfiguration, getIntakeAirTemperature(engine->engineConfiguration2)); - float cltCorrection = getCltCorrection(engineConfiguration, getCoolantTemperature(engine->engineConfiguration2)); + float iatCorrection = getIatCorrection(engineConfiguration, getIntakeAirTemperature(engine)); + float cltCorrection = getCltCorrection(engineConfiguration, getCoolantTemperature(engine)); #if EFI_ACCEL_ENRICHMENT float accelEnrichment = getAccelEnrichment(); @@ -155,8 +155,7 @@ float getBaseTableFuel(engine_configuration_s *engineConfiguration, int rpm, flo * @return Duration of fuel injection while craning, in milliseconds */ float getCrankingFuel(Engine *engine) { - return getStartingFuel(engine->engineConfiguration, - getCoolantTemperature(engine->engineConfiguration2)); + return getStartingFuel(engine->engineConfiguration, getCoolantTemperature(engine)); } float getStartingFuel(engine_configuration_s *engineConfiguration, float coolantTemperature) { diff --git a/firmware/controllers/core/le_functions.cpp b/firmware/controllers/core/le_functions.cpp index c80d5bdcd4..c01ee6f3c8 100644 --- a/firmware/controllers/core/le_functions.cpp +++ b/firmware/controllers/core/le_functions.cpp @@ -32,9 +32,9 @@ float getLEValue(Engine *engine, le_action_e action) { // case LE_METHOD_FAN: // return ; case LE_METHOD_COOLANT: - return getCoolantTemperature(engine->engineConfiguration2); + return getCoolantTemperature(engine); case LE_METHOD_INTAKE_AIR: - return getIntakeAirTemperature(engine->engineConfiguration2); + return getIntakeAirTemperature(engine); case LE_METHOD_RPM: return engine->rpmCalculator->rpm(); case LE_METHOD_TIME_SINCE_BOOT: diff --git a/firmware/controllers/engine_controller.cpp b/firmware/controllers/engine_controller.cpp index 1d000d7a32..e6ecd66ac0 100644 --- a/firmware/controllers/engine_controller.cpp +++ b/firmware/controllers/engine_controller.cpp @@ -127,9 +127,9 @@ static void updateErrorCodes(void) { /** * technically we can set error codes right inside the getMethods, but I a bit on a fence about it */ - setError(isValidIntakeAirTemperature(getIntakeAirTemperature(engineConfiguration2)), + setError(isValidIntakeAirTemperature(getIntakeAirTemperature(&engine)), OBD_Intake_Air_Temperature_Circuit_Malfunction); - setError(isValidCoolantTemperature(getCoolantTemperature(engineConfiguration2)), + setError(isValidCoolantTemperature(getCoolantTemperature(&engine)), OBD_Engine_Coolant_Temperature_Circuit_Malfunction); } @@ -141,9 +141,9 @@ static void fanRelayControl(void) { int newValue; if (isCurrentlyOn) { // if the fan is already on, we keep it on till the 'fanOff' temperature - newValue = getCoolantTemperature(engineConfiguration2) > engineConfiguration->fanOffTemperature; + newValue = getCoolantTemperature(&engine) > engineConfiguration->fanOffTemperature; } else { - newValue = getCoolantTemperature(engineConfiguration2) > engineConfiguration->fanOnTemperature; + newValue = getCoolantTemperature(&engine) > engineConfiguration->fanOnTemperature; } if (isCurrentlyOn != newValue) { @@ -182,8 +182,8 @@ static void cylinderCleanupControl(Engine *engine) { } else { newValue = false; } - if (newValue != engineConfiguration2->isCylinderCleanupMode) { - engineConfiguration2->isCylinderCleanupMode = newValue; + if (newValue != engine->isCylinderCleanupMode) { + engine->isCylinderCleanupMode = newValue; scheduleMsg(&logger, "isCylinderCleanupMode %s", boolToString(newValue)); } } diff --git a/firmware/controllers/lcd_controller.cpp b/firmware/controllers/lcd_controller.cpp index 28516172be..b773d82753 100644 --- a/firmware/controllers/lcd_controller.cpp +++ b/firmware/controllers/lcd_controller.cpp @@ -41,13 +41,12 @@ static char * prepareVBattMapLine(char *buffer) { } static char * prepareCltIatTpsLine(Engine *engine, char *buffer) { - engine_configuration2_s *engineConfiguration2 = engine->engineConfiguration2; char *ptr = buffer; *ptr++ = 'C'; - ptr = ftoa(ptr, getCoolantTemperature(engineConfiguration2), 10.0f); + ptr = ftoa(ptr, getCoolantTemperature(engine), 10.0f); ptr = appendStr(ptr, " C"); - ptr = ftoa(ptr, getIntakeAirTemperature(engineConfiguration2), 10.0f); + ptr = ftoa(ptr, getIntakeAirTemperature(engine), 10.0f); ptr = appendStr(ptr, " TP"); ptr = itoa10(ptr, (int) getTPS(engine->engineConfiguration)); diff --git a/firmware/controllers/math/speed_density.cpp b/firmware/controllers/math/speed_density.cpp index a12da99a9b..8db1661ceb 100644 --- a/firmware/controllers/math/speed_density.cpp +++ b/firmware/controllers/math/speed_density.cpp @@ -67,8 +67,8 @@ float getSpeedDensityFuel(Engine *engine, int rpm) { engine_configuration_s *engineConfiguration = engine->engineConfiguration; float tps = getTPS(engineConfiguration); - float coolantC = getCoolantTemperature(engine->engineConfiguration2); - float intakeC = getIntakeAirTemperature(engine->engineConfiguration2); + float coolantC = getCoolantTemperature(engine); + float intakeC = getIntakeAirTemperature(engine); float tChargeK = convertCelsiusToKelvin(getTCharge(rpm, tps, coolantC, intakeC)); float map = getMap(); float VE = veMap.getValue(map, engineConfiguration->veLoadBins, rpm, diff --git a/firmware/controllers/sensors/thermistors.cpp b/firmware/controllers/sensors/thermistors.cpp index 11ce32fba7..046c40c8d1 100644 --- a/firmware/controllers/sensors/thermistors.cpp +++ b/firmware/controllers/sensors/thermistors.cpp @@ -15,7 +15,6 @@ #include "adc_inputs.h" #include "engine_configuration.h" #include "engine_math.h" -#include "ec2.h" // Celsius #define LIMPING_MODE_IAT_TEMPERATURE 30.0f @@ -107,9 +106,10 @@ bool isValidIntakeAirTemperature(float temperature) { /** * @return coolant temperature, in Celsius */ -float getCoolantTemperature(engine_configuration2_s * engineConfiguration2) { - float temperature = getTemperatureC(&engineConfiguration2->clt); +float getCoolantTemperature(Engine * engine) { + float temperature = getTemperatureC(&engine->clt); if (!isValidCoolantTemperature(temperature)) { + efiAssert(engineConfiguration2->engineConfiguration!=NULL, "NULL engineConfiguration", NAN); if (engineConfiguration2->engineConfiguration->hasCltSensor) { warning(OBD_PCM_Processor_Fault, "unrealistic CLT %f", temperature); } @@ -154,10 +154,11 @@ void prepareThermistorCurve(ThermistorConf * config) { /** * @return Celsius value */ -float getIntakeAirTemperature(engine_configuration2_s * engineConfiguration2) { - float temperature = getTemperatureC(&engineConfiguration2->iat); +float getIntakeAirTemperature(Engine * engine) { + float temperature = getTemperatureC(&engine->iat); if (!isValidIntakeAirTemperature(temperature)) { - if (engineConfiguration2->engineConfiguration->hasIatSensor) { + efiAssert(engine->engineConfiguration!=NULL, "NULL engineConfiguration", NAN); + if (engine->engineConfiguration->hasIatSensor) { warning(OBD_PCM_Processor_Fault, "unrealistic IAT %f", temperature); } return LIMPING_MODE_IAT_TEMPERATURE; @@ -185,9 +186,9 @@ void setCommonNTCSensor(ThermistorConf *thermistorConf) { void initThermistors(Engine *engine) { efiAssertVoid(engine!=NULL, "e NULL initThermistors"); efiAssertVoid(engine->engineConfiguration2!=NULL, "e2 NULL initThermistors"); - initThermistorCurve(&engine->engineConfiguration2->clt, &engine->engineConfiguration->cltThermistorConf, + initThermistorCurve(&engine->clt, &engine->engineConfiguration->cltThermistorConf, engine->engineConfiguration->cltAdcChannel); - initThermistorCurve(&engine->engineConfiguration2->iat, &engine->engineConfiguration->iatThermistorConf, + initThermistorCurve(&engine->iat, &engine->engineConfiguration->iatThermistorConf, engine->engineConfiguration->iatAdcChannel); initialized = TRUE; } diff --git a/firmware/controllers/sensors/thermistors.h b/firmware/controllers/sensors/thermistors.h index 158432d444..877b5639af 100644 --- a/firmware/controllers/sensors/thermistors.h +++ b/firmware/controllers/sensors/thermistors.h @@ -14,7 +14,7 @@ #define KELV 273.15 #include "sensor_types.h" -#include "ec2.h" +#include "engine.h" #ifdef __cplusplus extern "C" @@ -38,9 +38,9 @@ float convertFtoCelcius(float tempF); float getKelvinTemperature(float resistance, ThermistorConf *thermistor); float getResistance(Thermistor *thermistor); float getTemperatureC(Thermistor *thermistor); -float getCoolantTemperature(engine_configuration2_s * engineConfiguration2); +float getCoolantTemperature(Engine * engine); bool isValidCoolantTemperature(float temperature); -float getIntakeAirTemperature(engine_configuration2_s * engineConfiguration2); +float getIntakeAirTemperature(Engine * engine); bool isValidIntakeAirTemperature(float temperature); float convertResistanceToKelvinTemperature(float resistance, diff --git a/firmware/controllers/settings.cpp b/firmware/controllers/settings.cpp index 7d0e2ddd00..252f85a2e4 100644 --- a/firmware/controllers/settings.cpp +++ b/firmware/controllers/settings.cpp @@ -309,12 +309,12 @@ static void printTPSInfo(void) { } static void printTemperatureInfo(void) { - printThermistor("CLT", &engineConfiguration2->clt); - if (!isValidCoolantTemperature(getCoolantTemperature(engineConfiguration2))) { + printThermistor("CLT", &engine.clt); + if (!isValidCoolantTemperature(getCoolantTemperature(&engine))) { scheduleMsg(&logger, "CLT sensing error"); } - printThermistor("IAT", &engineConfiguration2->iat); - if (!isValidIntakeAirTemperature(getIntakeAirTemperature(engineConfiguration2))) { + printThermistor("IAT", &engine.iat); + if (!isValidIntakeAirTemperature(getIntakeAirTemperature(&engine))) { scheduleMsg(&logger, "IAT sensing error"); } diff --git a/firmware/controllers/trigger/main_trigger_callback.cpp b/firmware/controllers/trigger/main_trigger_callback.cpp index cbe3b8ebc4..f18fec11e2 100644 --- a/firmware/controllers/trigger/main_trigger_callback.cpp +++ b/firmware/controllers/trigger/main_trigger_callback.cpp @@ -87,7 +87,7 @@ static void handleFuelInjectionEvent(MainTriggerCallback *mainTriggerCallback, A return; } - if (mainTriggerCallback->engineConfiguration2->isCylinderCleanupMode) + if (mainTriggerCallback->engine->isCylinderCleanupMode) return; float delay = getOneDegreeTimeMs(rpm) * event->position.angleOffset; diff --git a/unit_tests/engine_test_helper.cpp b/unit_tests/engine_test_helper.cpp index fce952c0c9..010b715bb6 100644 --- a/unit_tests/engine_test_helper.cpp +++ b/unit_tests/engine_test_helper.cpp @@ -21,6 +21,7 @@ EngineTestHelper::EngineTestHelper(engine_type_e engineType) { configuration.engineConfiguration = ec; configuration.engineConfiguration2 = &ec2; engine.engineConfiguration2 = &ec2; + ec2.engineConfiguration = ec; prepareFuelMap(engine.engineConfiguration); diff --git a/unit_tests/test_fuel_map.cpp b/unit_tests/test_fuel_map.cpp index 43a4541bee..ae0d5883f7 100644 --- a/unit_tests/test_fuel_map.cpp +++ b/unit_tests/test_fuel_map.cpp @@ -73,10 +73,10 @@ void testFuelMap(void) { engine_configuration_s *engineConfiguration = eth.engine.engineConfiguration; - assertEquals(NAN, getIntakeAirTemperature(eth.engine.engineConfiguration2)); + assertEquals(NAN, getIntakeAirTemperature(ð.engine)); float iatCorrection = getIatCorrection(engineConfiguration, -KELV); assertEqualsM("IAT", 2, iatCorrection); - float cltCorrection = getCltCorrection(engineConfiguration, getCoolantTemperature(eth.engine.engineConfiguration2)); + float cltCorrection = getCltCorrection(engineConfiguration, getCoolantTemperature(ð.engine)); assertEqualsM("CLT", 1, cltCorrection); float injectorLag = getInjectorLag(engineConfiguration, getVBatt()); assertEquals(0, injectorLag);