bool LocalVersionHolder::isOld() {
int global = getGlobalConfigurationVersion();
if (global > localVersion) {
localVersion = global;
return true;
}
return false;
}
static void updateTriggerShapeIfNeeded(PwmConfig *state) {
if (emulatorConfigVersion.isOld()) {
scheduleMsg(logger, "Stimulator: updating trigger shape: %d/%d %d", emulatorConfigVersion.getVersion(),
getGlobalConfigurationVersion(), currentTimeMillis());
applyNonPersistentConfiguration(logger PASS_ENGINE_PARAMETER);
TriggerShape *s = &engine->triggerShape;
pin_state_t *pinStates[PWM_PHASE_MAX_WAVE_PER_PWM] = { s->wave.waves[0].pinStates, s->wave.waves[1].pinStates,
s->wave.waves[2].pinStates };
copyPwmParameters(state, s->getSize(), s->wave.switchTimes, PWM_PHASE_MAX_WAVE_PER_PWM, pinStates);
state->safe.periodNt = -1; // this would cause loop re-initialization
}
}
static void updateTriggerShapeIfNeeded(PwmConfig *state) {
if (atTriggerVersion < engine->triggerCentral.triggerShape.version) {
atTriggerVersion = engine->triggerCentral.triggerShape.version;
scheduleMsg(logger, "Stimulator: updating trigger shape: %d/%d %d", atTriggerVersion,
getGlobalConfigurationVersion(), currentTimeMillis());
TriggerShape *s = &engine->triggerCentral.triggerShape;
pin_state_t *pinStates[PWM_PHASE_MAX_WAVE_PER_PWM] = { s->wave.waves[0].pinStates, s->wave.waves[1].pinStates,
s->wave.waves[2].pinStates };
copyPwmParameters(state, s->getSize(), s->wave.switchTimes, PWM_PHASE_MAX_WAVE_PER_PWM, pinStates);
state->safe.periodNt = -1; // this would cause loop re-initialization
}
}
/**
* @brief Prints current engine configuration to human-readable console.
*/
void printConfiguration(engine_configuration_s *engineConfiguration, engine_configuration2_s *engineConfiguration2) {
scheduleMsg(&logger, getConfigurationName(engineConfiguration));
scheduleMsg(&logger, "configurationVersion=%d", getGlobalConfigurationVersion());
for (int k = 0; k < FUEL_LOAD_COUNT; k++) {
// print("line %d (%f): ", k, engineConfiguration->fuelKeyBins[k]);
// for (int r = 0; r < FUEL_RPM_COUNT; r++) {
// print("%f ", engineConfiguration->fuelTable[k][r]);
// }
// print("\r\n");
}
printFloatArray("RPM bin: ", engineConfiguration->fuelRpmBins, FUEL_RPM_COUNT);
printFloatArray("Y bin: ", engineConfiguration->fuelLoadBins, FUEL_LOAD_COUNT);
printFloatArray("CLT: ", engineConfiguration->cltFuelCorr, CLT_CURVE_SIZE);
printFloatArray("CLT bins: ", engineConfiguration->cltFuelCorrBins, CLT_CURVE_SIZE);
printFloatArray("IAT: ", engineConfiguration->iatFuelCorr, IAT_CURVE_SIZE);
printFloatArray("IAT bins: ", engineConfiguration->iatFuelCorrBins, IAT_CURVE_SIZE);
printFloatArray("vBatt: ", engineConfiguration->battInjectorLagCorr, VBAT_INJECTOR_CURVE_SIZE);
printFloatArray("vBatt bins: ", engineConfiguration->battInjectorLagCorrBins, VBAT_INJECTOR_CURVE_SIZE);
// appendMsgPrefix(&logger);
scheduleMsg(&logger, "rpmHardLimit: %d", engineConfiguration->rpmHardLimit);
scheduleMsg(&logger, "rpmMultiplier=%f", engineConfiguration->rpmMultiplier);
scheduleMsg(&logger, "tpsMin: %d", engineConfiguration->tpsMin);
scheduleMsg(&logger, "tpsMax: %d", engineConfiguration->tpsMax);
scheduleMsg(&logger, "timingMode: %d", engineConfiguration->timingMode);
scheduleMsg(&logger, "fixedModeTiming: %d", (int) engineConfiguration->fixedModeTiming);
scheduleMsg(&logger, "ignitionOffset=%f", engineConfiguration->ignitionOffset);
scheduleMsg(&logger, "injectionOffset=%f", engineConfiguration->injectionOffset);
scheduleMsg(&logger, "crankingChargeAngle=%f", engineConfiguration->crankingChargeAngle);
scheduleMsg(&logger, "crankingTimingAngle=%f", engineConfiguration->crankingTimingAngle);
scheduleMsg(&logger, "globalTriggerAngleOffset=%f", engineConfiguration->globalTriggerAngleOffset);
// scheduleMsg(&logger, "analogChartMode: %d", engineConfiguration->analogChartMode);
// scheduleMsg(&logger, "crankingRpm: %d", engineConfiguration->crankingSettings.crankingRpm);
scheduleMsg(&logger, "idlePinMode: %d", boardConfiguration->idleValvePinMode);
scheduleMsg(&logger, "malfunctionIndicatorPinMode: %d", boardConfiguration->malfunctionIndicatorPinMode);
scheduleMsg(&logger, "analogInputDividerCoefficient: %f", engineConfiguration->analogInputDividerCoefficient);
scheduleMsg(&logger, "needSecondTriggerInput: %d", engineConfiguration->needSecondTriggerInput);
#if EFI_PROD_CODE
scheduleMsg(&logger, "idleValvePin: %s", hwPortname(boardConfiguration->idleValvePin));
scheduleMsg(&logger, "fuelPumpPin: mode %d @ %s", boardConfiguration->fuelPumpPinMode, hwPortname(boardConfiguration->fuelPumpPin));
scheduleMsg(&logger, "injectionPins: mode %d", boardConfiguration->injectionPinMode);
for (int i = 0; i < engineConfiguration->cylindersCount; i++) {
brain_pin_e brainPin = boardConfiguration->injectionPins[i];
scheduleMsg(&logger, "injection %d @ %s", i, hwPortname(brainPin));
}
scheduleMsg(&logger, "ignitionPins: mode %d", boardConfiguration->ignitionPinMode);
// todo: calculate coils count based on ignition mode
for (int i = 0; i < 4; i++) {
brain_pin_e brainPin = boardConfiguration->ignitionPins[i];
scheduleMsg(&logger, "ignition %d @ %s", i, hwPortname(brainPin));
}
scheduleMsg(&logger, "primary trigger simulator: %s %d", hwPortname(boardConfiguration->triggerSimulatorPins[0]), boardConfiguration->triggerSimulatorPinModes[0]);
scheduleMsg(&logger, "secondary trigger simulator: %s %d", hwPortname(boardConfiguration->triggerSimulatorPins[1]), boardConfiguration->triggerSimulatorPinModes[1]);
#endif /* EFI_PROD_CODE */
scheduleMsg(&logger, "isInjectionEnabledFlag %d", engineConfiguration2->isInjectionEnabledFlag);
// appendPrintf(&logger, DELIMETER);
// scheduleLogging(&logger);
}
/**
* @brief Prints current engine configuration to human-readable console.
*/
void printConfiguration(engine_configuration_s *engineConfiguration) {
scheduleMsg(&logger, "Template %s/%d trigger %s/%s/%d", getConfigurationName(engineConfiguration->engineType),
engineConfiguration->engineType, getTrigger_type_e(engineConfiguration->trigger.type),
getEngine_load_mode_e(engineConfiguration->algorithm), engineConfiguration->algorithm);
scheduleMsg(&logger, "configurationVersion=%d", getGlobalConfigurationVersion());
for (int k = 0; k < FUEL_LOAD_COUNT; k++) {
// print("line %d (%f): ", k, engineConfiguration->fuelKeyBins[k]);
// for (int r = 0; r < FUEL_RPM_COUNT; r++) {
// print("%f ", engineConfiguration->fuelTable[k][r]);
// }
// print("\r\n");
}
// printFloatArray("RPM bin: ", config->fuelRpmBins, FUEL_RPM_COUNT);
//
// printFloatArray("Y bin: ", config->fuelLoadBins, FUEL_LOAD_COUNT);
//
// printFloatArray("CLT: ", config->cltFuelCorr, CLT_CURVE_SIZE);
// printFloatArray("CLT bins: ", config->cltFuelCorrBins, CLT_CURVE_SIZE);
//
// printFloatArray("IAT: ", config->iatFuelCorr, IAT_CURVE_SIZE);
// printFloatArray("IAT bins: ", config->iatFuelCorrBins, IAT_CURVE_SIZE);
//
// printFloatArray("vBatt: ", engineConfiguration->injector.battLagCorr, VBAT_INJECTOR_CURVE_SIZE);
// printFloatArray("vBatt bins: ", engineConfiguration->injector.battLagCorrBins, VBAT_INJECTOR_CURVE_SIZE);
scheduleMsg(&logger, "rpmHardLimit: %d/operationMode=%d", engineConfiguration->rpmHardLimit,
engineConfiguration->operationMode);
scheduleMsg(&logger, "globalTriggerAngleOffset=%f", engineConfiguration->globalTriggerAngleOffset);
scheduleMsg(&logger, "=== cranking ===");
scheduleMsg(&logger, "crankingRpm: %d", engineConfiguration->cranking.rpm);
scheduleMsg(&logger, "cranking injection %s", getInjection_mode_e(engineConfiguration->crankingInjectionMode));
if (engineConfiguration->useConstantDwellDuringCranking) {
scheduleMsg(&logger, "ignitionDwellForCrankingMs=%f", engineConfiguration->ignitionDwellForCrankingMs);
} else {
scheduleMsg(&logger, "cranking charge charge angle=%f fire at %f", engineConfiguration->crankingChargeAngle,
engineConfiguration->crankingTimingAngle);
}
scheduleMsg(&logger, "=== ignition ===");
scheduleMsg(&logger, "ignitionMode: %s/enabled=%s", getIgnition_mode_e(engineConfiguration->ignitionMode),
boolToString(engineConfiguration->isIgnitionEnabled));
scheduleMsg(&logger, "timingMode: %s", getTiming_mode_e(engineConfiguration->timingMode));
if (engineConfiguration->timingMode == TM_FIXED) {
scheduleMsg(&logger, "fixedModeTiming: %d", (int) engineConfiguration->fixedModeTiming);
}
scheduleMsg(&logger, "ignitionOffset=%f", engineConfiguration->ignitionOffset);
scheduleMsg(&logger, "=== injection ===");
scheduleMsg(&logger, "injection %s offset=%f/enabled=%s", getInjection_mode_e(engineConfiguration->injectionMode),
(double) engineConfiguration->injectionOffset, boolToString(engineConfiguration->isInjectionEnabled));
printOutputs(engineConfiguration);
scheduleMsg(&logger, "map_avg=%s/mil=%s/fp=%s/ts=%s/wa=%s/it=%s/fastAdc=%s",
boolToString(engineConfiguration->isMapAveragingEnabled), boolToString(engineConfiguration->isMilEnabled),
boolToString(engineConfiguration->isFuelPumpEnabled),
boolToString(engineConfiguration->isTunerStudioEnabled),
boolToString(engineConfiguration->isWaveAnalyzerEnabled),
boolToString(engineConfiguration->isIdleThreadEnabled), boolToString(boardConfiguration->isFastAdcEnabled));
scheduleMsg(&logger, "isManualSpinningMode=%s/isCylinderCleanupEnabled=%s",
boolToString(engineConfiguration->isManualSpinningMode),
boolToString(engineConfiguration->isCylinderCleanupEnabled));
scheduleMsg(&logger, "clutchUp@%s: %s", hwPortname(boardConfiguration->clutchUpPin),
boolToString(engine->clutchUpState));
scheduleMsg(&logger, "clutchDown@%s: %s", hwPortname(boardConfiguration->clutchDownPin),
boolToString(engine->clutchDownState));
scheduleMsg(&logger, "boardTestModeJumperPin: %s/nesting=%d",
hwPortname(boardConfiguration->boardTestModeJumperPin), maxNesting);
scheduleMsg(&logger, "digitalPotentiometerSpiDevice %d", boardConfiguration->digitalPotentiometerSpiDevice);
for (int i = 0; i < DIGIPOT_COUNT; i++) {
scheduleMsg(&logger, "digitalPotentiometer CS%d %s", i,
hwPortname(boardConfiguration->digitalPotentiometerChipSelect[i]));
}
#if EFI_PROD_CODE
printSpiState(&logger, boardConfiguration);
#endif /* EFI_PROD_CODE */
}
