defaults.h File Reference

Functions
void	setLeftRightBanksNeedBetterName ()
void	setDefaultBaseEngine ()
void	setDefaultFuel ()
void	setDefaultIgnition ()
void	setDefaultCranking ()
void	setGDIFueling ()
void	setHpfpLobeProfileAngle (int lobes)
void	setGdiWallWetting ()
void	setInline4 ()
void	setDynoDefaults ()
void	setupTLE9201 (Gpio controlPin, Gpio direction, Gpio disable, int dcIndex=0)
void	setupTLE9201IncludingStepper (Gpio controlPin, Gpio direction, Gpio disable, int dcIndex=0)
void	setPPSInputs (adc_channel_e pps1, adc_channel_e pps2)
void	setPPSCalibration (float primaryUp, float primaryDown, float secondaryUp, float secondaryDown)
void	setTPS1Inputs (adc_channel_e tps1, adc_channel_e tps2)
void	setTPS1Calibration (uint16_t tpsMin, uint16_t tpsMax)
void	setTPS1Calibration (uint16_t tpsMin, uint16_t tpsMax, uint16_t tps1SecondaryMin, uint16_t tps1SecondaryMax)
void	setCustomMap (float lowValue, float mapLowValueVoltage, float highValue, float mapHighValueVoltage)
void	setEtbPID (float p, float i, float d)
void	defaultsOrFixOnBurn ()

Function Documentation

defaultsOrFixOnBurn()

void defaultsOrFixOnBurn

(

)

Definition at line 129 of file default_base_engine.cpp.

                           {
  if (config->dynoCarCarMassKg == 0) {
    setDynoDefaults();
  }
 
    if (engineConfiguration->mapExpAverageAlpha <= 0 || engineConfiguration->mapExpAverageAlpha > 1) {
      engineConfiguration->mapExpAverageAlpha = 1;
    }
 
    if (engineConfiguration->ppsExpAverageAlpha <= 0 || engineConfiguration->ppsExpAverageAlpha > 1) {
      engineConfiguration->ppsExpAverageAlpha = 1;
    }
    if (engineConfiguration->afrExpAverageAlpha <= 0 || engineConfiguration->afrExpAverageAlpha > 1) {
      engineConfiguration->afrExpAverageAlpha = 1;
    }
 
    if (engineConfiguration->alternator_iTermMin == 0) {
    engineConfiguration->alternator_iTermMin = -1000;
    }
    if (engineConfiguration->alternator_iTermMax == 0) {
    engineConfiguration->alternator_iTermMax = 1000;
    }
    if (engineConfiguration->idleReturnTargetRampDuration <= 0.1){
        engineConfiguration->idleReturnTargetRampDuration = 3;
    }
 
    if (engineConfiguration->vvtControlMinRpm < engineConfiguration->cranking.rpm) {
        engineConfiguration->vvtControlMinRpm = engineConfiguration->cranking.rpm;
    }
}

Referenced by setDefaultBaseEngine(), and validateConfigOnStartUpOrBurn().

Here is the call graph for this function:

Here is the caller graph for this function:

setCustomMap()

void setCustomMap	(	float	lowValue,
		float	mapLowValueVoltage,
		float	highValue,
		float	mapHighValueVoltage
	)

Definition at line 456 of file default_base_engine.cpp.

                                                                                                        {
    engineConfiguration->map.sensor.type = MT_CUSTOM;
    engineConfiguration->map.sensor.lowValue = lowValue;
    engineConfiguration->mapLowValueVoltage = mapLowValueVoltage;
    engineConfiguration->map.sensor.highValue = highValue;
    engineConfiguration->mapHighValueVoltage = mapHighValueVoltage;
}

Referenced by hellen112_17_boardDefaultConfiguration(), setHarley(), setHyundaiPb(), setMercedesM111EngineConfiguration(), and setSlingshot().

Here is the caller graph for this function:

setDefaultBaseEngine()

void setDefaultBaseEngine

(

)

Definition at line 160 of file default_base_engine.cpp.

                            {
    // Base Engine Settings
    engineConfiguration->displacement = 2;
    engineConfiguration->knockDetectionUseDoubleFrequency = true;
#if MAX_CYLINDER_COUNT >= 4
    setInline4();
#else
  // todo: invoke more complete one cylinder default?
  engineConfiguration->cylindersCount = 1;
#endif
 
  engineConfiguration->isTuningDetectorEnabled = true;
 
  for (size_t i = 0; i < engineConfiguration->cylindersCount; i++) {
    // one knock sensor by default. See also 'setLeftRightBanksNeedBetterName()'
    // zero-based index
    engineConfiguration->cylinderBankSelect[i] = 0;
  }
 
  engineConfiguration->ltft.enabled = true;
  engineConfiguration->ltft.correctionEnabled = true;
 
    engineConfiguration->compressionRatio = 9;
    engineConfiguration->vssFilterReciprocal = VSS_FILTER_MIN;
    engineConfiguration->boardUseCanTerminator = true;
    engineConfiguration->acLowRpmLimit = 500;
 
    engineConfiguration->mafFilterParameter = 1;
 
#ifdef EFI_KLINE
  engineConfiguration->kLinePeriodUs = 300 /* us*/;
  engineConfiguration->kLineDoHondaSend = true;
#endif
 
  setGdiDefaults();
 
  // it's useful to know what starting point is given tune based on
  engineConfiguration->calibrationBirthday = compilationYear() * 10000 + compilationMonth() * 100 + compilationDay();
 
  engineConfiguration->enableExtendedCanBroadcast = true;
 
  engineConfiguration->fan1ExtraIdle = 2;
  engineConfiguration->fan2ExtraIdle = 2;
 
  engineConfiguration->auxSpeed1Multiplier = 1;
  engineConfiguration->magicNumberAvailableForDevTricks = 1;
 
  engineConfiguration->acrRevolutions = 5;
    engineConfiguration->acPressure.v2 = 5;
    engineConfiguration->acPressure.value2 = 100;
 
    engineConfiguration->lowPressureFuel.v2 = 5;
    engineConfiguration->lowPressureFuel.value2 = 100;
 
    engineConfiguration->wastegatePositionOpenedVoltage = 4.0;
 
  engineConfiguration->fuelLevelAveragingAlpha = engine_configuration_defaults::FUEL_LEVEL_AVERAGING_ALPHA;
  engineConfiguration->fuelLevelUpdatePeriodSec = engine_configuration_defaults::FUEL_LEVEL_UPDATE_PERIOD_SEC;
  engineConfiguration->fuelLevelLowThresholdVoltage = engine_configuration_defaults::FUEL_LEVEL_LOW_THRESHOLD_VOLTAGE;
  engineConfiguration->fuelLevelHighThresholdVoltage = engine_configuration_defaults::FUEL_LEVEL_HIGH_THRESHOLD_VOLTAGE;
 
  engineConfiguration->watchOutForLinearTime = true;
 
  setLinearCurve(engineConfiguration->tractionControlSlipBins, /*from*/0.9, /*to*/1.2, 0.05);
    setLinearCurve(engineConfiguration->tractionControlSpeedBins, /*from*/10, /*to*/120, 5);
 
    engineConfiguration->turbochargerFilter = 0.01f;
 
    mc33810defaults();
 
    setRpmTableBin(config->torqueRpmBins);
    setLinearCurve(config->torqueLoadBins, 0, 100, 1);
 
    engineConfiguration->fuelAlgorithm = engine_load_mode_e::LM_SPEED_DENSITY;
    // let's have valid default while we still have the field
    engineConfiguration->debugMode = DBG_EXECUTOR;
 
  engineConfiguration->speedometerPulsePerKm = 2485; // GM GMT800 platform
 
    engineConfiguration->primingDelay = 0.5;
    // this should not be below default rpm! maybe even make them equal?
    engineConfiguration->vvtControlMinRpm = 600;
 
  // todo: this "2JZ" trigger is very powerful for many low tooth quantity applications
  // todo: we might be getting closer to a re-name
  // by the way 2GRFE intake likes position 160 / precision 20
  // see also https://github.com/rusefi/rusefi/issues/7345
  //
  // 2JZ values
    engineConfiguration->camDecoder2jzPosition = 95;
    engineConfiguration->camDecoder2jzPrecision = 40;
 
    // Limits and Fallbacks
    engineConfiguration->rpmHardLimit = 7000;
    engineConfiguration->rpmHardLimitHyst = 50;
    engineConfiguration->cutFuelOnHardLimit = true;
    engineConfiguration->cutSparkOnHardLimit = true;
    engineConfiguration->etbRevLimitRange = 250;
 
  engineConfiguration->tpsAccelFractionDivisor = 1;
 
  engineConfiguration->rpmSoftLimitTimingRetard = 4;
 
    // CLT RPM limit table - just the X axis
    copyArray(config->cltRevLimitRpmBins, { -20, 0, 40, 80 });
 
    engineConfiguration->ALSMinRPM = 400;
    engineConfiguration->ALSMaxRPM = 3200;
    engineConfiguration->ALSMaxDuration = 3;
    engineConfiguration->ALSMaxCLT = 105;
//  engineConfiguration->alsMinPps = 10;
    engineConfiguration->alsMinTimeBetween = 5;
    engineConfiguration->alsEtbPosition = 30;
    engineConfiguration->ALSMaxTPS = 5;
 
    engineConfiguration->torqueReductionActivationTemperature = 60;
 
    engineConfiguration->knockRetardAggression = 20;
    engineConfiguration->knockRetardReapplyRate = 3;
    engineConfiguration->knockFuelTrim = 0;
    engineConfiguration->knockSuppressMinTps = 10;
 
  setRpmTableBin(config->maxKnockRetardRpmBins);
  setLinearCurve(config->maxKnockRetardLoadBins, 0, 100, 1);
  setTable(config->maxKnockRetardTable, 20);
 
    // Trigger
    engineConfiguration->trigger.type = trigger_type_e::TT_TOOTHED_WHEEL_60_2;
 
#if EFI_SIMULATOR
    engineConfiguration->vvtMode[0] = VVT_SINGLE_TOOTH;
    engineConfiguration->vvtOffsets[0] = 450;
    engineConfiguration->vvtPins[0] = Gpio::A0; // a random unused pin needed to unblock startSimplePwmExt()
#endif // EFI_SIMULATOR
 
#if EFI_SIMULATOR
    // R
    config->tcuSolenoidTable[0][0] = 99;
    config->tcuSolenoidTable[0][1] = 1;
    config->tcuSolenoidTable[0][2] = 2;
    config->tcuSolenoidTable[0][3] = 3;
    config->tcuSolenoidTable[0][4] = 4;
    config->tcuSolenoidTable[0][5] = 5;
    // P/N
    config->tcuSolenoidTable[1][0] = 10;
    config->tcuSolenoidTable[1][1] = 11;
    config->tcuSolenoidTable[1][2] = 12;
    config->tcuSolenoidTable[1][3] = 13;
    config->tcuSolenoidTable[1][4] = 14;
    config->tcuSolenoidTable[1][5] = 15;
    config->tcuSolenoidTable[1][6] = 16;
    config->tcuSolenoidTable[1][7] = 17;
    config->tcuSolenoidTable[1][8] = 18;
    config->tcuSolenoidTable[1][9] = 19;
    // 1
    config->tcuSolenoidTable[2][0] = 20;
    config->tcuSolenoidTable[2][1] = 21;
    config->tcuSolenoidTable[2][2] = 22;
    // 2
    config->tcuSolenoidTable[3][0] = 30;
    config->tcuSolenoidTable[3][1] = 31;
    config->tcuSolenoidTable[3][3] = 33;
    // 3
    config->tcuSolenoidTable[4][0] = 40;
    config->tcuSolenoidTable[4][1] = 41;
    config->tcuSolenoidTable[4][4] = 44;
    // 4
    config->tcuSolenoidTable[5][0] = 50;
    config->tcuSolenoidTable[5][1] = 51;
    config->tcuSolenoidTable[5][5] = 55;
 
  // [tag:runNotSquareTest] huh why is this not a unit test?!
    config->scriptTable4[0][0] = 140;
    config->scriptTable4[0][1] = 141;
    config->scriptTable4[0][2] = 142;
    config->scriptTable4[0][3] = 143;
    config->scriptTable4[0][4] = 144;
    config->scriptTable4[0][5] = 145;
 
    config->scriptTable4[1][0] = 240;
    config->scriptTable4[1][1] = 241;
    config->scriptTable4[1][2] = 242;
    config->scriptTable4[1][3] = 243;
    config->scriptTable4[1][4] = 244;
    config->scriptTable4[1][5] = 245;
 
    config->scriptTable4[4][0] = 40;
    config->scriptTable4[4][2] = 41;
    config->scriptTable4[4][3] = 42;
    config->scriptTable4[4][4] = 43;
    config->scriptTable4[4][5] = 44;
    config->scriptTable4[4][5] = 45;
 
    config->scriptTable4[5][0] = 50;
    config->scriptTable4[5][1] = 51;
    config->scriptTable4[5][2] = 52;
    config->scriptTable4[5][3] = 53;
    config->scriptTable4[5][4] = 54;
    config->scriptTable4[5][5] = 55;
 
#endif // EFI_SIMULATOR
 
    engineConfiguration->globalTriggerAngleOffset = 0;
 
    // Default this to on - if you want to diagnose, turn it off.
    engineConfiguration->silentTriggerError = true;
 
    engineConfiguration->idleStepperReactionTime = 3;
    engineConfiguration->idleStepperTotalSteps = 200;
    engineConfiguration->stepperForceParkingEveryRestart = true;
    engineConfiguration->iacByTpsTaper = 2;
 
    engineConfiguration->etbSplit = MAX_TPS_PPS_DISCREPANCY;
 
    // Advanced Trigger
 
    // Battery and alternator
    engineConfiguration->vbattDividerCoeff = ((float) (15 + 65)) / 15;
 
#if EFI_ALTERNATOR_CONTROL
    setDefaultAlternatorParameters();
#endif /* EFI_ALTERNATOR_CONTROL */
 
    // Fuel pump
    // todo: maybe change to 2s as default?
    engineConfiguration->startUpFuelPumpDuration = 4;
 
    engineConfiguration->kLineBaudRate = KLINE_BAUD_RATE;
 
    engineConfiguration->benchTestOnTime = 4;
    engineConfiguration->benchTestOffTime = 500;
    engineConfiguration->benchTestCount = 3;
 
 
    // Tachometer
    // 50% duty cycle is the default for tach signal
    engineConfiguration->tachPulseDurationAsDutyCycle = true;
    engineConfiguration->tachPulseDuractionMs = 0.5;
    engineConfiguration->tachPulsePerRev = 1;
 
    engineConfiguration->etbMinimumPosition = 1;
    engineConfiguration->etbMaximumPosition = 100;
 
    engineConfiguration->tcuInputSpeedSensorTeeth = 1;
    engineConfiguration->issFilterReciprocal = 2;
 
    //knock
#ifdef KNOCK_SPECTROGRAM
    engineConfiguration->enableKnockSpectrogram = false;
    engineConfiguration->enableKnockSpectrogramFilter = false;
    engineConfiguration->knockSpectrumSensitivity = 1.0;
    engineConfiguration->knockFrequency = 0.0;
#endif
 
    // Check engine light
#if EFI_PROD_CODE
    engineConfiguration->warningPeriod = 10;
#else
    engineConfiguration->warningPeriod = 0;
#endif /* EFI_PROD_CODE */
 
    setDefaultVrThresholds();
 
    // Oil pressure protection
    engineConfiguration->minimumOilPressureTimeout = 0.5f;
    setRpmTableBin(config->minimumOilPressureBins);
    setRpmTableBin(config->maximumOilPressureBins);
 
    engine->engineModules.apply_all([](auto & m) { m.setDefaultConfiguration(); });
  // we invoke this last so that we can validate even defaults
  defaultsOrFixOnBurn();
}

Referenced by setDefaultEngineConfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

setDefaultCranking()

void setDefaultCranking

(

)

Definition at line 6 of file default_cranking.cpp.

                          {
    engineConfiguration->cranking.rpm = 550;
 
    // Fuel
    engineConfiguration->crankingInjectionMode = IM_SIMULTANEOUS;
 
    // Ignition
    engineConfiguration->ignitionDwellForCrankingMs = DEFAULT_CRANKING_DWELL_MS;
    engineConfiguration->crankingTimingAngle = DEFAULT_CRANKING_ANGLE;
 
    // IAC
    setArrayValues(config->cltCrankingCorr, 50);
    // should be 100 once tune is better
    setArrayValues(config->afterCrankingIACtaperDuration, 200);
    setLinearCurve(config->afterCrankingIACtaperDurationBins, CLT_CURVE_RANGE_FROM, 100, 1);
 
    engineConfiguration->isFasterEngineSpinUpEnabled = true;
 
    // After start enrichment
#if !EFI_UNIT_TEST
    // don't set this for unit tests, as it makes things more complicated to test
    setLinearCurve(config->postCrankingCLTBins, /*from*/-20, /*to*/80, 20);
    setLinearCurve(config->postCrankingDurationBins, /*from*/0, /*to*/150, 40);
    setTable(config->postCrankingFactor, 1.2f);
#endif
 
    setLinearCurve(config->crankingTpsCoef, /*from*/1, /*to*/1, 1);
    setLinearCurve(config->crankingTpsBins, 0, 100, 1);
 
    setLinearCurve(config->cltCrankingCorrBins, CLT_CURVE_RANGE_FROM, 100, 1);
    setLinearCurve(config->cltCrankingCorr, 50, 50, 1); // now as % of idle valve/etb
 
#if CRANKING_CURVE_SIZE == 8
    // Cranking temperature compensation
    static const float crankingCoef[] = {
        2.8,
        2.2,
        1.8,
        1.55,
        1.3,
        1.1,
        1.0,
        1.0
    };
    copyArray(config->crankingFuelCoef,     crankingCoef);
    copyArray(config->crankingFuelCoefE100, crankingCoef);
 
    // Deg C
    static const float crankingBins[] = {
        -20,
        -10,
        5,
        20,
        35,
        50,
        65,
        90
    };
    copyArray(config->crankingFuelBins, crankingBins);
#endif
    // Cranking cycle compensation
 
    setTable(config->crankingCycleBaseFuel, 27.0f);
    setLinearCurve(config->crankingCycleFuelCltBins, 0, 60, 1);
 
    // X values are simply counting up cycle number starting at 1
    for (size_t i = 0; i < efi::size(config->crankingCycleBins); i++) {
        config->crankingCycleBins[i] = i + 1;
    }
 
    // Cranking ignition timing
    setArrayValues(config->crankingAdvance, 0);
 
    static const float advanceBins[] = { 0, 200, 400, 1000 };
    copyArray(config->crankingAdvanceBins, advanceBins);
 
    engineConfiguration->useTLE8888_cranking_hack = true;
}

Referenced by setDefaultEngineConfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

setDefaultFuel()

void setDefaultFuel

(

)

By the way http://users.erols.com/srweiss/tableifc.htm has a LOT of data

Definition at line 314 of file default_fuel.cpp.

                      {
    // Base injection configuration
    engineConfiguration->isInjectionEnabled = true;
    engineConfiguration->injectionMode = IM_SEQUENTIAL;
 
    /**
     * By the way http://users.erols.com/srweiss/tableifc.htm has a LOT of data
     */
    engineConfiguration->injector.flow = 200;
    engineConfiguration->injectorSecondary.flow = 200;
    engineConfiguration->stoichRatioPrimary = STOICH_RATIO;
 
    // 9.0 = E100 pure ethanol
    engineConfiguration->stoichRatioSecondary = 9.0f;
 
    // Injector deadtime
    setBosch02880155868(engineConfiguration->injector);
    setBosch02880155868(engineConfiguration->injectorSecondary);
 
    // Tables
    setFuelTablesLoadBin(10, 160);
    setRpmTableBin(config->injPhaseRpmBins);
 
    setRpmTableBin(config->tpsTspCorrValuesBins);
    setLinearCurve(config->tpsTspCorrValues, 1, 1);
 
    setRpmTableBin(config->predictiveMapBlendDurationBins);
    setLinearCurve(config->predictiveMapBlendDurationValues, 1, 1);
 
    setDefaultVETable();
    setDefaultLambdaTable();
 
    setLinearCurve(config->injectorStagingLoadBins, 0, 100, 10);
    setRpmTableBin(config->injectorStagingRpmBins);
 
    setRpmTableBin(config->mapEstimateRpmBins);
    setLinearCurve(config->mapEstimateTpsBins, 0, 100);
    setTable(config->mapEstimateTable, 60);
 
    setTable(config->injectionPhase, PORT_INJECTION_OFFSET);
 
    // Charge temperature estimation
    engineConfiguration->tChargeMinRpmMinTps = 0.25;
    engineConfiguration->tChargeMinRpmMaxTps = 0.25;
    engineConfiguration->tChargeMaxRpmMinTps = 0.25;
    engineConfiguration->tChargeMaxRpmMaxTps = 0.9;
    engineConfiguration->tChargeMode = TCHARGE_MODE_RPM_TPS;
    engineConfiguration->tChargeAirCoefMin = 0.098f;
    engineConfiguration->tChargeAirCoefMax = 0.902f;
    engineConfiguration->tChargeAirFlowMax = 153.6f;
    engineConfiguration->tChargeAirIncrLimit = 1.0f;
    engineConfiguration->tChargeAirDecrLimit = 12.5f;
 
    // CLT correction table
    setDefaultWarmupFuelEnrichment();
 
    // IAT correction table
    // TODO
 
    // Closed loop fuel correction
    setDefaultStftSettings();
    setDefaultLtftSettings();
 
    // Decel fuel cut
    setDefaultFuelCutParameters();
 
    engineConfiguration->tpsAccelEnrichmentThreshold = 40; // TPS % change, per engine cycle
 
    setDefaultWallWetting();
 
    // TPS/TPS AE curve
    setMazdaMiataNbTpsTps();
 
    // Some reasonable reference pressure that many vehicles use
    engineConfiguration->fuelReferencePressure = 300;
 
    setDefaultWboSettings();
 
    // Lambda protection defaults
    setDefaultLambdaProtection();
 
    setDefaultPriming();
 
    // Cut at 110% instantly
    engineConfiguration->maxInjectorDutyInstant = 110;
    // Cut at 96% after 0.5 second
    engineConfiguration->maxInjectorDutySustained = 96;
    engineConfiguration->maxInjectorDutySustainedTimeout = 0.5f;
}

Referenced by setDefaultEngineConfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

setDefaultIgnition()

void setDefaultIgnition

(

)

Definition at line 101 of file default_ignition.cpp.

                          {
    // Ignition base settings
    engineConfiguration->isIgnitionEnabled = true;
 
    engineConfiguration->timingMode = TM_DYNAMIC;
    engineConfiguration->fixedModeTiming = 50;
 
    engineConfiguration->minimumIgnitionTiming = -10;
    engineConfiguration->maximumIgnitionTiming = 60;
 
    // Dwell table - a bit conservative but reasonable
    setConstantDwell(4);
 
    setLinearCurve(config->dwellVoltageCorrVoltBins, 8, 15, 0.1);
    setLinearCurve(config->dwellVoltageCorrValues, 1, 1, 1);
 
    // Multispark
    setDefaultMultisparkParameters();
 
    // Ignition advance table
    setLinearCurve(config->ignitionLoadBins, 20, 120, 3);
    setTimingRpmBin(800, 7000);
    buildTimingMap(35);
 
    setDefaultTrailingSparkTable();
 
    // CLT correction
    setDefaultCltTimingCorrection();
 
    // IAT correction
    setDefaultIatTimingCorrection();
 
    // Give default axes for cylinder trim tables
#if IGN_TRIM_SIZE == 4
    copyArray(config->ignTrimRpmBins, { 1000, 3000, 5000, 7000 });
    copyArray(config->ignTrimLoadBins, { 20, 50, 80, 100 });
#else
  setRpmTableBin(config->ignTrimRpmBins);
  setLinearCurve(config->ignTrimLoadBins, 20, 100);
#endif
 
    // Default axes for VE blends
    for (size_t i = 0; i < efi::size(config->ignBlends); i++) {
        auto& blend = config->ignBlends[i];
        setLinearCurve(blend.loadBins, 0, 100, 10);
        setLinearCurve(blend.rpmBins, 0, 7000);
 
        setLinearCurve(blend.blendBins, 0, 100);
        setLinearCurve(blend.blendValues, 0, 100);
    }
}

Referenced by setDefaultEngineConfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

setDynoDefaults()

void setDynoDefaults

(

)

Definition at line 108 of file default_base_engine.cpp.

                       {
    config->dynoRpmStep = 100;
 
    config->dynoSaeTemperatureC = 20;
    config->dynoSaeBaro = STD_ATMOSPHERE;
    config->dynoSaeRelativeHumidity = 80;
 
    config->dynoCarWheelDiaInch = 18;
    config->dynoCarWheelTireWidthMm = 235;
    config->dynoCarWheelAspectRatio = 40;
 
    config->dynoCarGearPrimaryReduction = 1;
    config->dynoCarGearRatio = 1.0;
    config->dynoCarGearFinalDrive = 4.2;
 
    config->dynoCarCarMassKg = 1000;
    config->dynoCarCargoMassKg = 95;
    config->dynoCarCoeffOfDrag = 0.29;
    config->dynoCarFrontalAreaM2 = 1.85;
 }

Referenced by defaultsOrFixOnBurn().

Here is the caller graph for this function:

setEtbPID()

void setEtbPID	(	float	p,
		float	i,
		float	d
	)

Definition at line 471 of file default_base_engine.cpp.

                                          {
    engineConfiguration->etb.pFactor = p;
    engineConfiguration->etb.iFactor = i;
    engineConfiguration->etb.dFactor = d;
}

Referenced by hellen121_nissan_boardDefaultConfiguration(), hellen_gm_e67_boardDefaultConfiguration(), and set201xHyundai().

Here is the caller graph for this function:

setGDIFueling()

void setGDIFueling

(

)

Definition at line 70 of file default_base_engine.cpp.

                     {
#ifdef HW_HELLEN_8CHAN
  engineConfiguration->externalRusEfiGdiModule = true;
#endif
 
    engineConfiguration->injectionMode = IM_SEQUENTIAL;
    engineConfiguration->crankingInjectionMode = IM_SEQUENTIAL;
    engineConfiguration->ignitionMode = IM_INDIVIDUAL_COILS;
 
  setGdiWallWetting();
    // Use high pressure sensor
    engineConfiguration->injectorPressureType = IPT_High;
    // Automatic compensation of injector flow based on rail pressure
    engineConfiguration->injectorCompensationMode = ICM_SensedRailPressure;
    // Reference rail pressure is 10 000 kPa = 100 bar
    engineConfiguration->fuelReferencePressure = 10000;
    //setting "flat" 0.2 ms injector's lag time
    setTable(engineConfiguration->injector.battLagCorrTable, 0.2);
 
    setTable(config->injectionPhase, -200.0f);
    engineConfiguration->injectionTimingMode = InjectionTimingMode::Center;
    engineConfiguration->isPhaseSyncRequiredForIgnition = true;
}

Referenced by alphax_4kgdi_defaultConfiguration(), commonPassatB6(), setGmGdi(), and setHyundaiPb().

Here is the call graph for this function:

Here is the caller graph for this function:

setGdiWallWetting()

void setGdiWallWetting

(

)

Definition at line 245 of file default_fuel.cpp.

                         {
    engineConfiguration->wwaeTau = 0;
    engineConfiguration->wwaeBeta = 0;
}

Referenced by setGDIFueling().

Here is the caller graph for this function:

setHpfpLobeProfileAngle()

void setHpfpLobeProfileAngle

(

int

lobes

)

Definition at line 22 of file default_base_engine.cpp.

                                        {
#if HPFP_LOBE_PROFILE_SIZE == 16
static const float hardCodedHpfpLobeProfileAnglesForThreeLobes[16] = {0.0, 7.5, 16.5, 24.0,
32.0 , 40.0, 48.0, 56.0,
64.0 , 72.0, 80.0, 88.0,
96.0 , 103.5, 112.5, 120.0
};
 
  float multiplier = 3.0 / lobes;
    for (size_t i = 0; i < HPFP_LOBE_PROFILE_SIZE; i++) {
    config->hpfpLobeProfileAngle[i] = multiplier * hardCodedHpfpLobeProfileAnglesForThreeLobes[i];
    }
#endif // HPFP_LOBE_PROFILE_SIZE
}

Referenced by set4CylGmEcotec3(), setBoschHDEV_5_injectors(), setFordEcoboost(), and setHyundaiPb().

Here is the caller graph for this function:

setInline4()

void setInline4

(

)

Definition at line 477 of file default_base_engine.cpp.

                  {
    engineConfiguration->cylindersCount = 4;
    engineConfiguration->firingOrder = FO_1_3_4_2;
}

Referenced by alphax_2chan_defaultConfiguration(), alphax_silver_boardDefaultConfiguration(), alphax_silver_revA_boardDefaultConfiguration(), commonPassatB6(), set4CylGmEcotec3(), setDefaultBaseEngine(), setFordEcoboost(), setHellen121nissanQR(), setHyundaiPb(), and setVwAba().

Here is the caller graph for this function:

setLeftRightBanksNeedBetterName()

void setLeftRightBanksNeedBetterName

(

)

file defaults.h

Definition at line 95 of file default_base_engine.cpp.

                                       {
    for (size_t i = 0; i < engineConfiguration->cylindersCount; i++) {
      // zero-based index
        engineConfiguration->cylinderBankSelect[i] = i % 2;
    }
}

Referenced by setGmLs4(), and setSubaruEG33Defaults().

Here is the caller graph for this function:

setPPSCalibration()

void setPPSCalibration	(	float	primaryUp,
		float	primaryDown,
		float	secondaryUp,
		float	secondaryDown
	)

Definition at line 464 of file default_base_engine.cpp.

                                                                                                   {
    engineConfiguration->throttlePedalUpVoltage = primaryUp;
    engineConfiguration->throttlePedalWOTVoltage = primaryDown;
    engineConfiguration->throttlePedalSecondaryUpVoltage = secondaryUp;
    engineConfiguration->throttlePedalSecondaryWOTVoltage = secondaryDown;
}

Referenced by commonPassatB6(), hellen121_nissan_boardDefaultConfiguration(), hellen128_boardDefaultConfiguration(), hellen88_boardDefaultConfiguration(), set201xHyundai(), setDefaultEtbParameters(), setEngineBMW_M73_Proteus(), setGmGdi(), setGmLs4(), setMaverickX3(), setMercedesM111EngineConfiguration(), setSubaru2011(), setToyota89281_33010_pedal_position_sensor(), and setupDefaultSensorInputs().

Here is the caller graph for this function:

setPPSInputs()

void setPPSInputs	(	adc_channel_e	pps1,
		adc_channel_e	pps2
	)

Definition at line 433 of file default_base_engine.cpp.

                                                          {
    engineConfiguration->throttlePedalPositionAdcChannel = pps1;
    engineConfiguration->throttlePedalPositionSecondAdcChannel = pps2;
}

Referenced by alphax_4kgdi_defaultConfiguration(), hellen128_boardDefaultConfiguration(), m74_9_boardDefaultConfiguration(), setDefaultSensorInputs(), setGmLs4(), setHarley(), setHondaObd1(), setMercedesM111EngineConfiguration(), setMreVwPassatB6(), setProteusEtbIO(), setProteusHitachiEtbDefaults(), setStepperHw(), setupDefaultSensorInputs(), and setupDefaultSensorInputs().

Here is the caller graph for this function:

setTPS1Calibration() [1/2]

void setTPS1Calibration	(	uint16_t	tpsMin,
		uint16_t	tpsMax
	)

Definition at line 443 of file default_base_engine.cpp.

                                                          {
    engineConfiguration->tpsMin = tpsMin;
    engineConfiguration->tpsMax = tpsMax;
}

Referenced by hellen112_17_boardDefaultConfiguration(), hellen_honda_k_boardDefaultConfiguration(), proteusDcWastegateTest(), set201xHyundai(), setDefaultEngineConfiguration(), setGmLnf(), setGmLs4(), setMaverickX3(), setMercedesM111EngineConfiguration(), setTPS1Calibration(), super_uaefi_boardDefaultConfiguration(), and uaefi_boardDefaultConfiguration().

Here is the caller graph for this function:

setTPS1Calibration() [2/2]

void setTPS1Calibration	(	uint16_t	tpsMin,
		uint16_t	tpsMax,
		uint16_t	tps1SecondaryMin,
		uint16_t	tps1SecondaryMax
	)

Definition at line 448 of file default_base_engine.cpp.

                                                                                                                {
    setTPS1Calibration(tpsMin, tpsMax);
 
 
    engineConfiguration->tps1SecondaryMin = tps1SecondaryMin;
    engineConfiguration->tps1SecondaryMax = tps1SecondaryMax;
}

Here is the call graph for this function:

setTPS1Inputs()

void setTPS1Inputs	(	adc_channel_e	tps1,
		adc_channel_e	tps2
	)

Definition at line 438 of file default_base_engine.cpp.

                                                           {
    engineConfiguration->tps1_1AdcChannel = tps1;
    engineConfiguration->tps1_2AdcChannel = tps2;
}

Referenced by alphax_4kgdi_defaultConfiguration(), m74_9_boardDefaultConfiguration(), setDefaultSensorInputs(), setGmEcotec3(), setGmLs4(), setHarley(), setMercedesM111EngineConfiguration(), and setupDefaultSensorInputs().

Here is the call graph for this function:

Here is the caller graph for this function:

setupTLE9201()

void setupTLE9201	(	Gpio	controlPin,
		Gpio	direction,
		Gpio	disable,
		int	dcIndex = 0
	)

Definition at line 489 of file default_base_engine.cpp.

                                                                              {
    // TLE9201 driver
    // This chip has three control pins:
    // DIR - sets direction of the motor
    // PWM - pwm control (enable high, coast low)
    // DIS - disables motor (enable low)
 
    // PWM pin
    engineConfiguration->etbIo[dcIndex].controlPin = controlPin;
    // DIR pin
    engineConfiguration->etbIo[dcIndex].directionPin1 = direction;
    // Disable pin
    engineConfiguration->etbIo[dcIndex].disablePin = disable;
 
    // we only have pwm/dir, no dira/dirb
    engineConfiguration->etb_use_two_wires = false;
}

Referenced by alphax_4chan_defaultConfiguration(), alphax_4kgdi_boardConfigOverrides(), hellen154hyundai_f7_boardConfigOverrides(), hellen_gm_e67_boardConfigOverrides(), setupEtb(), and setupTLE9201IncludingStepper().

Here is the call graph for this function:

Here is the caller graph for this function:

setupTLE9201IncludingStepper()

void setupTLE9201IncludingStepper	(	Gpio	controlPin,
		Gpio	direction,
		Gpio	disable,
		int	dcIndex = 0
	)

Definition at line 507 of file default_base_engine.cpp.

                                                                                              {
  setupTLE9201(controlPin, direction, disable, dcIndex);
 
  // on SBC style stepper IAC fully-extended valve shaft would give least idle air
  // fully-retracted valve shaft would give most idle air
  int stepperIndexWeirdness = 1 - dcIndex;
    engineConfiguration->stepperDcIo[stepperIndexWeirdness].controlPin = controlPin;
    engineConfiguration->stepperDcIo[stepperIndexWeirdness].directionPin1 = direction;
    engineConfiguration->stepperDcIo[stepperIndexWeirdness].directionPin2 = Gpio::Unassigned;
    engineConfiguration->stepperDcIo[stepperIndexWeirdness].disablePin = disable;
}

Referenced by set8chanDefaultETBPins(), setDefaultETBPins(), setMegaUaefiBoardDefaultConfiguration(), and setUaefiDefaultETBPins().

Here is the call graph for this function:

Here is the caller graph for this function:

Go to the source code of this file.