init.h File Reference

Functions
void	initOverrideSensors ()
void	initNewSensors ()
void	stopSensors ()
void	reconfigureSensors ()
void	initVbatt ()
void	initMaf ()
void	initMap ()
void	initTps ()
void	initFluidPressure ()
void	initThermistors ()
void	initCanSensors ()
void	initLambda ()
void	initEgt ()
void	initFlexSensor (bool isFirstTime)
void	initFuelLevel ()
void	initBaro ()
void	initAuxSensors ()
void	initVehicleSpeedSensor ()
void	initTurbochargerSpeedSensor ()
void	initAuxSpeedSensors ()
void	initInputShaftSpeedSensor ()
void	initRangeSensors ()
void	deinitVbatt ()
void	deinitTps ()
void	deinitThermistors ()
void	deinitFluidPressure ()
void	deInitFlexSensor ()
void	deinitAuxSensors ()
void	deInitVehicleSpeedSensor ()
void	deinitTurbochargerSpeedSensor ()
void	deinitMap ()
void	deinitAuxSpeedSensors ()
void	deinitInputShaftSpeedSensor ()
void	stopEgt ()
void	startEgt ()
void	sentPressureDecode (SentInput sentCh)
void	pokeAuxDigital ()

Function Documentation

deinitAuxSensors()

void deinitAuxSensors

(

)

Definition at line 58 of file init_aux.cpp.

                        {
    for (size_t i = 0; i < efi::size(engineConfiguration->auxAnalogInputs); i++) {
        AdcSubscription::UnsubscribeSensor(auxSensors[i]);
        auxSensors[i].unregister();
    }
}

Referenced by stopSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

deinitAuxSpeedSensors()

void deinitAuxSpeedSensors

(

)

Definition at line 51 of file init_aux_speed_sensor.cpp.

                             {
    auxSpeed1.deInit();
    auxSpeed2.deInit();
    wheelSlipSensor.unregister();
}

Referenced by stopSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

deInitFlexSensor()

void deInitFlexSensor

(

)

Definition at line 98 of file init_flex.cpp.

                        {
    flexSensor.unregister();
    flexFuelTemp.unregister();
 
#if EFI_PROD_CODE
    if (!isBrainPinValid(flexPin)) {
        return;
    }
 
    efiExtiDisablePin(flexPin);
 
    flexPin = Gpio::Unassigned;
#endif
}

Referenced by stopSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

deinitFluidPressure()

void deinitFluidPressure

(

)

Definition at line 115 of file init_fluid_pressure.cpp.

                           {
    AdcSubscription::UnsubscribeSensor(oilpSensor, engineConfiguration->oilPressure.hwChannel);
    AdcSubscription::UnsubscribeSensor(fuelPressureSensorLow, engineConfiguration->lowPressureFuel.hwChannel);
    AdcSubscription::UnsubscribeSensor(fuelPressureSensorHigh, engineConfiguration->highPressureFuel.hwChannel);
    AdcSubscription::UnsubscribeSensor(auxLinear1Sensor, engineConfiguration->auxLinear1.hwChannel);
    AdcSubscription::UnsubscribeSensor(auxLinear2Sensor, engineConfiguration->auxLinear2.hwChannel);
    AdcSubscription::UnsubscribeSensor(auxLinear3Sensor, engineConfiguration->auxLinear3.hwChannel);
    AdcSubscription::UnsubscribeSensor(auxLinear4Sensor, engineConfiguration->auxLinear4.hwChannel);
}

Referenced by stopSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

deinitInputShaftSpeedSensor()

void deinitInputShaftSpeedSensor

(

)

Definition at line 26 of file init_input_shaft_speed_sensor.cpp.

                                   {
    inputShaftSpeedSensor.deInit();
}

Referenced by stopSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

deinitMap()

void deinitMap

(

)

Definition at line 144 of file init_map.cpp.

                 {
    AdcSubscription::UnsubscribeSensor(slowMapSensor, engineConfiguration->map.sensor.hwChannel);
    AdcSubscription::UnsubscribeSensor(baroSensor, engineConfiguration->baroSensor.hwChannel);
    AdcSubscription::UnsubscribeSensor(throttleInletPress, engineConfiguration->throttleInletPressureChannel);
    AdcSubscription::UnsubscribeSensor(compressorDischargePress, engineConfiguration->compressorDischargePressureChannel);
}

Referenced by stopSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

deinitThermistors()

void deinitThermistors

(

)

Definition at line 142 of file init_thermistors.cpp.

                         {
    AdcSubscription::UnsubscribeSensor(clt, engineConfiguration->clt.adcChannel);
    AdcSubscription::UnsubscribeSensor(iat, engineConfiguration->iat.adcChannel);
    AdcSubscription::UnsubscribeSensor(oilTempSensor, engineConfiguration->oilTempSensor.adcChannel);
    AdcSubscription::UnsubscribeSensor(fuelTempSensor, engineConfiguration->fuelTempSensor.adcChannel);
    AdcSubscription::UnsubscribeSensor(ambientTempSensor, engineConfiguration->ambientTempSensor.adcChannel);
    AdcSubscription::UnsubscribeSensor(compressorDischargeTemp, engineConfiguration->compressorDischargeTemperature.adcChannel);
    AdcSubscription::UnsubscribeSensor(aux1, engineConfiguration->auxTempSensor1.adcChannel);
    AdcSubscription::UnsubscribeSensor(aux2, engineConfiguration->auxTempSensor2.adcChannel);
}

Referenced by stopSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

deinitTps()

void deinitTps

(

)

Definition at line 278 of file init_tps.cpp.

                 {
    bool isFordTps = activeConfiguration.useFordRedundantTps;
    bool isFordPps = activeConfiguration.useFordRedundantPps;
 
    analogTps1.deinit(isFordTps, &fordTps1);
    tps2.deinit(isFordTps, &fordTps2);
    pedal.deinit(isFordPps, &fordPps);
 
#if EFI_SENT_SUPPORT
    sentTps.unregister();
#endif
 
    wastegate.deinit();
    idlePos.deinit();
}

Referenced by stopSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

deinitTurbochargerSpeedSensor()

void deinitTurbochargerSpeedSensor

(

)

Definition at line 20 of file init_turbocharger_speed_sensor.cpp.

                                     {
    turbochargerSpeedSensor.deInit();
}

Referenced by stopSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

deinitVbatt()

void deinitVbatt

(

)

Definition at line 36 of file init_vbatt.cpp.

                   {
    AdcSubscription::UnsubscribeSensor(vbattSensor, engineConfiguration->vbattAdcChannel);
    AdcSubscription::UnsubscribeSensor(ignBattSensor, engineConfiguration->ignKeyAdcChannel);
}

Referenced by stopSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

deInitVehicleSpeedSensor()

void deInitVehicleSpeedSensor

(

)

Definition at line 23 of file init_vehicle_speed_sensor.cpp.

                                {
    vehicleSpeedSensor.deInit();
}

Referenced by stopSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

initAuxSensors()

void initAuxSensors

(

)

Definition at line 36 of file init_aux.cpp.

                      {
    for (size_t i = 0; i < efi::size(engineConfiguration->auxAnalogInputs); i++) {
        auto channel = engineConfiguration->auxAnalogInputs[i];
 
        // Skip unconfigured channels
        if (!isAdcChannelValid(channel)) {
            continue;
        }
 
        auto& sensor = auxSensors[i];
        sensor.setFunction(identityFunction);
        sensor.Register();
 
        AdcSubscription::SubscribeSensor(sensor, channel, 10);
    }
 
    for (size_t i = 0; i < efi::size(luaGauges); i++) {
        auto& sensor = luaGauges[i];
        sensor.Register();
    }
}

Referenced by sensorStartUpOrReconfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

initAuxSpeedSensors()

void initAuxSpeedSensors

(

)

Definition at line 41 of file init_aux_speed_sensor.cpp.

                           {
    auxSpeed1.useBiQuad = engineConfiguration->useBiQuadOnAuxSpeedSensors;
    auxSpeed1.initIfValid(engineConfiguration->auxSpeedSensorInputPin[0], converter, engineConfiguration->auxFrequencyFilter);
    auxSpeed2.initIfValid(engineConfiguration->auxSpeedSensorInputPin[1], converter, 0.05f);
 
  if (engineConfiguration->useAuxSpeedForSlipRatio) {
      wheelSlipSensor.Register();
    }
}

Referenced by sensorStartUpOrReconfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

initBaro()

void initBaro

(

)

Definition at line 7 of file init_baro.cpp.

                {
    // If there's already an external (analog) baro sensor configured,
    // don't configure the internal one.
    if (Sensor::hasSensor(SensorType::BarometricPressure)) {
        return;
    }
 
    if (device.init(engineConfiguration->lps25BaroSensorScl, engineConfiguration->lps25BaroSensorSda)) {
        sensor.Register();
    }
}

Referenced by initNewSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

initCanSensors()

void initCanSensors

(

)

Definition at line 41 of file init_can_sensors.cpp.

                      {
    if (engineConfiguration->consumeObdSensors) {
        registerCanSensor(obdRpmSensor);
        registerCanSensor(obdCltSensor);
        registerCanSensor(obdIatSensor);
        registerCanSensor(obdTpsSensor);
    }
}

Referenced by initNewSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

initEgt()

void initEgt

(

)

Definition at line 16 of file init_egt.cpp.

               {
#if EFI_CAN_SUPPORT
    if (engineConfiguration->enableAemXSeriesEgt) {
        if (!engineConfiguration->canReadEnabled) {
            criticalError("CAN read is required to use CAN EGT.");
            return;
        }
 
        registerCanSensor(aemEgt1);
        registerCanSensor(aemEgt2);
        registerCanSensor(aemEgt3);
        registerCanSensor(aemEgt4);
        registerCanSensor(aemEgt5);
        registerCanSensor(aemEgt6);
 
        return;
    }
#endif
 
#if EFI_MAX_31855
    initMax3185x(engineConfiguration->max31855spiDevice, engineConfiguration->max31855_cs);
#endif /* EFI_MAX_31855 */
}

Referenced by initNewSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

initFlexSensor()

void initFlexSensor

(

bool

isFirstTime

)

Definition at line 64 of file init_flex.cpp.

                                      {
#if EFI_PROD_CODE
    if (efiExtiEnablePin("flex", engineConfiguration->flexSensorPin,
        PAL_EVENT_MODE_BOTH_EDGES, flexExtiCallback, nullptr) < 0) {
        return;
    }
    flexPin = engineConfiguration->flexSensorPin;
#endif
 
    // 0.01 means filter bandwidth of ~1hz with ~100hz sensor
    flexTempFilter.configureLowpass(1, 0.01f);
    flexSensor.setFunction(converter);
 
#if EFI_PROD_CODE
    if (isFirstTime) {
        addConsoleAction("flexinfo", []() {
            efiPrintf("flex counter %d", flexCallbackCounter);
            efiPrintf("lowFlexCallbackCounter counter %d", lowFlexCallbackCounter);
            efiPrintf("flex freq %f", frequency);
            efiPrintf("pulseWidthUs %f", pulseWidthUs);
            efiPrintf("latestCallbackTime %lld", latestCallbackTime);
        });
    }
 
#endif // EFI_PROD_CODE
 
    flexSensor.Register();
 
    // If an analog fuel temp sensor is configured, don't use the flex sensor for fuel temp
    if (!isAdcChannelValid(engineConfiguration->fuelTempSensor.adcChannel)) {
        flexFuelTemp.Register();
    }
}

Referenced by sensorStartUpOrReconfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

initFluidPressure()

void initFluidPressure

(

)

Definition at line 75 of file init_fluid_pressure.cpp.

                         {
    initFluidPressure(oilpSensorFunc, oilpSensor, engineConfiguration->oilPressure, 10);
    initFluidPressure(fuelPressureFuncLow, fuelPressureSensorLow, engineConfiguration->lowPressureFuel, 10);
 
#if EFI_SENT_SUPPORT
    if ((engineConfiguration->FuelHighPressureSentType != SentFuelHighPressureType::NONE) &&
        (engineConfiguration->FuelHighPressureSentInput != SentInput::NONE)) {
        if (engineConfiguration->FuelHighPressureSentType == SentFuelHighPressureType::GM_TYPE) {
            /* This sensor sends two pressure signals:
             * Sig0 occupies 3 first nibbles
             * Sig1 occupies next 3 nibbles
             * Signals are close, but not identical.
             * Sig0 shows about 197..198 at 1 Atm (open air) and 282 at 1000 KPa (10 Bar)
             * Sig1 shows abour 202..203 at 1 Atm (open air) and 283 at 1000 KPa (10 Bar)
             */
            initSentLinearSensor(fuelPressureFuncHigh, fuelPressureSensorHigh,
                200, BAR2KPA(1),
                283, BAR2KPA(10),
                BAR2KPA(0), BAR2KPA(1000) /* What is limit of this sensor? */);
        }
    } else
#endif
    {
        initFluidPressure(fuelPressureFuncHigh, fuelPressureSensorHigh, engineConfiguration->highPressureFuel, 100);
    }
    initFluidPressure(acPressureFunc, acPressureSensor, engineConfiguration->acPressure, 10);
    initFluidPressure(auxLinear1Func, auxLinear1Sensor, engineConfiguration->auxLinear1, 10);
    initFluidPressure(auxLinear2Func, auxLinear2Sensor, engineConfiguration->auxLinear2, 10);
    initFluidPressure(auxLinear3Func, auxLinear3Sensor, engineConfiguration->auxLinear3, 10);
    initFluidPressure(auxLinear4Func, auxLinear4Sensor, engineConfiguration->auxLinear4, 10);
 
    injectorPressure.setProxiedSensor(
        engineConfiguration->injectorPressureType == IPT_High
        ? SensorType::FuelPressureHigh
        : SensorType::FuelPressureLow
    );
 
    injectorPressure.Register();
}

Referenced by initFluidPressure(), and sensorStartUpOrReconfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

initFuelLevel()

void initFuelLevel

(

)

Definition at line 8 of file init_fuel_level.cpp.

                     {
    adc_channel_e channel = engineConfiguration->fuelLevelSensor;
 
    if (!isAdcChannelValid(channel)) {
        return;
    }
 
    // noisy data from fuel tank slosh is handled on an higher level
    AdcSubscription::SubscribeSensor(fuelSensor, channel, /*lowpassCutoff =*/ 100);
    fuelSensor.Register();
}

Referenced by initNewSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

initInputShaftSpeedSensor()

void initInputShaftSpeedSensor

(

)

Definition at line 15 of file init_input_shaft_speed_sensor.cpp.

                                 {
    int parameter = engineConfiguration->issFilterReciprocal;
 
    if (parameter < 3 || parameter > 200) {
        parameter = 3;
    }
 
    float filterParameter = 1.0f / parameter;
    inputShaftSpeedSensor.initIfValid(engineConfiguration->tcuInputSpeedSensorPin, inputSpeedConverter, filterParameter);
}

Referenced by sensorStartUpOrReconfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

initLambda()

void initLambda

(

)

Definition at line 52 of file init_lambda.cpp.

                  {
    // first we register the smoothed sensors for the early return on the can wbo case
    smoothedLambda1Sensor.Register();
    smoothedLambda2Sensor.Register();
 
#if EFI_CAN_SUPPORT
    if (engineConfiguration->enableAemXSeries) {
        if (!engineConfiguration->canWriteEnabled || !engineConfiguration->canReadEnabled) {
            criticalError("CAN read and write are required to use CAN wideband.");
            return;
        }
 
        registerCanSensor(aem1);
        registerCanSensor(aem2);
 
        return;
    }
#endif
 
#if EFI_UNIT_TEST
  constexpr bool isUnitTest = true;
#else
  constexpr bool isUnitTest = false;
#endif
 
  // CANbus option is handled above, let's handle analog inputs conditionally to give Lua sensors a chance
  if (isAdcChannelValid(engineConfiguration->afr.hwChannel) || isUnitTest) {
      lambdaSensor.Register();
    }
    if (isAdcChannelValid(engineConfiguration->afr.hwChannel2) || isUnitTest) {
      lambdaSensor2.Register();
  }
}

Referenced by initNewSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

initMaf()

void initMaf

(

)

Definition at line 92 of file init_maf.cpp.

               {
    initMaf(engineConfiguration->mafAdcChannel, maf);
    initMaf(engineConfiguration->maf2AdcChannel, maf2);
}

Referenced by initMaf(), and initNewSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

initMap()

void initMap

(

)

Definition at line 105 of file init_map.cpp.

               {
    // Set up the conversion function
    configureMapFunction(mapConverter, engineConfiguration->map.sensor.type);
 
    slowMapSensor.setFunction(mapConverter);
// unfinished/dead? slowMapSensor2.setFunction(mapConverter);
    fastMapSensor.setFunction(mapConverter);
    fastMapSensor2.setFunction(mapConverter);
    compressorDischargePress.setFunction(mapConverter);
    throttleInletPress.setFunction(mapConverter);
 
    auto mapChannel = engineConfiguration->map.sensor.hwChannel;
    if (isAdcChannelValid(mapChannel)) {
        slowMapSensor.Register();
// unfinished/dead?     slowMapSensor2.Register();
        fastMapSensor.Register();
        fastMapSensor2.Register();
        mapCombiner.Register();
        mapCombiner2.Register();
 
        // Configure slow MAP as a normal analog sensor
        // it's possible/probably that slow and fast both read from same physical pin, apparently that's fine?!
        AdcSubscription::SubscribeSensor(slowMapSensor, mapChannel, 100);
    }
 
    AdcSubscription::SubscribeSensor(throttleInletPress, engineConfiguration->throttleInletPressureChannel, 100);
    AdcSubscription::SubscribeSensor(compressorDischargePress, engineConfiguration->compressorDischargePressureChannel, 100);
 
    auto baroChannel = engineConfiguration->baroSensor.hwChannel;
    if (isAdcChannelValid(baroChannel)) {
        configureMapFunction(baroConverter, engineConfiguration->baroSensor.type);
 
        baroSensor.setFunction(baroConverter);
        baroSensor.Register();
 
        AdcSubscription::SubscribeSensor(baroSensor, baroChannel, 10);
    }
}

Referenced by sensorStartUpOrReconfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

initNewSensors()

void initNewSensors

(

)

Definition at line 112 of file init_sensors.cpp.

                      {
#if EFI_PROD_CODE && EFI_CAN_SUPPORT
    initCanSensors();
#endif
 
    initOverrideSensors();
 
  sensorStartUpOrReconfiguration(true);
  // todo:
    initLambda();
    // todo: 'isFirstTime' approach for initEgt vs startEgt
    initEgt();
    initBaro();
 
    initFuelLevel();
    initMaf();
 
    initOldAnalogInputs();
    initAuxDigital();
 
    // Init CLI functionality for sensors (mocking)
    initSensorCli();
 
#if defined(HARDWARE_CI) && !defined(HW_PROTEUS)
    chThdSleepMilliseconds(100);
 
    if (Sensor::getOrZero(SensorType::BatteryVoltage) < 8) {
        // Fake that we have battery voltage, some tests rely on it
        Sensor::setMockValue(SensorType::BatteryVoltage, 10);
    }
#endif
 
#if EFI_SIMULATOR
    // Simulator gets battery voltage so it detects ignition-on
    Sensor::setMockValue(SensorType::BatteryVoltage, 14);
#endif // EFI_SIMULATOR
}

Referenced by commonInitEngineController().

Here is the call graph for this function:

Here is the caller graph for this function:

initOverrideSensors()

void initOverrideSensors

(

)

Definition at line 84 of file init_sensors.cpp.

                           {
      overrideRpm.Register();
      overrideVehicleSpeed.Register();
      overrideClt.Register();
      overrideBatteryVoltage.Register();
}

Referenced by initNewSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

initRangeSensors()

void initRangeSensors

(

)

Definition at line 25 of file init_range.cpp.

                        {
    for (size_t i = 0; i < efi::size(engineConfiguration->tcu_rangeAnalogInput); i++) {
        auto channel = engineConfiguration->tcu_rangeAnalogInput[i];
 
        // Skip unconfigured channels
        if (!isAdcChannelValid(channel)) {
            continue;
        }
 
        rangeFuncs[i].configure(5.0f, engineConfiguration->tcu_rangeSensorBiasResistor, engineConfiguration->tcu_rangeSensorPulldown);
        
        auto& sensor = rangeSensors[i];
        sensor.setFunction(rangeFuncs[i]);
        sensor.Register();
 
        AdcSubscription::SubscribeSensor(sensor, channel, 10);
    }
}

Referenced by sensorStartUpOrReconfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

initThermistors()

void initThermistors

(

)

Definition at line 88 of file init_thermistors.cpp.

                       {
    if (!engineConfiguration->consumeObdSensors) {
        configureTempSensor("clt",
                        clt,
                        fclt,
                        engineConfiguration->clt,
                        engineConfiguration->useLinearCltSensor,
                        engineConfiguration->cltSensorPulldown);
 
        configureTempSensor("iat",
                        iat,
                        fiat,
                        engineConfiguration->iat,
                        engineConfiguration->useLinearIatSensor,
                        engineConfiguration->iatSensorPulldown);
    }
 
    configureTempSensor("oil temp",
                        oilTempSensor,
                        faux2,
                        engineConfiguration->oilTempSensor,
                        false);
 
    configureTempSensor("fuel temp",
                        fuelTempSensor,
                        ffuel,
                        engineConfiguration->fuelTempSensor,
                        false);
 
    configureTempSensor("ambient temp",
                        ambientTempSensor,
                        fambient,
                        engineConfiguration->ambientTempSensor,
                        false);
 
    configureTempSensor("compressor discharge temp",
                        compressorDischargeTemp,
                        fcdt,
                        engineConfiguration->compressorDischargeTemperature,
                        false);
 
    configureTempSensor("aux1",
                        aux1,
                        faux1,
                        engineConfiguration->auxTempSensor1,
                        false);
 
    configureTempSensor("aux2",
                        aux2,
                        faux2,
                        engineConfiguration->auxTempSensor2,
                        false);
}

Referenced by sensorStartUpOrReconfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

initTps()

void initTps

(

)

Definition at line 206 of file init_tps.cpp.

               {
    criticalAssertVoid(engineConfiguration != nullptr, "null engineConfiguration");
    percent_t minTpsPps = engineConfiguration->tpsErrorDetectionTooLow;
    percent_t maxTpsPps = engineConfiguration->tpsErrorDetectionTooHigh;
 
    if (!engineConfiguration->consumeObdSensors) {
        bool isFordTps = engineConfiguration->useFordRedundantTps;
        bool isFordPps = engineConfiguration->useFordRedundantPps;
 
        float tpsSecondaryMaximum = engineConfiguration->tpsSecondaryMaximum;
        if (tpsSecondaryMaximum < 20) {
            // don't allow <20% split point
            tpsSecondaryMaximum = 20;
        }
 
 
#if EFI_SENT_SUPPORT
        if (isDigitalTps1()) {
            sentTps.Register();
        } else
#endif
        {
            analogTps1.init(isFordTps, &fordTps1, tpsSecondaryMaximum,
                { engineConfiguration->tps1_1AdcChannel, (float)engineConfiguration->tpsMin, (float)engineConfiguration->tpsMax, minTpsPps, maxTpsPps },
                { engineConfiguration->tps1_2AdcChannel, (float)engineConfiguration->tps1SecondaryMin, (float)engineConfiguration->tps1SecondaryMax, minTpsPps, maxTpsPps }
            );
        }
 
        tps2.init(isFordTps, &fordTps2, tpsSecondaryMaximum,
            { engineConfiguration->tps2_1AdcChannel, (float)engineConfiguration->tps2Min, (float)engineConfiguration->tps2Max, minTpsPps, maxTpsPps },
            { engineConfiguration->tps2_2AdcChannel, (float)engineConfiguration->tps2SecondaryMin, (float)engineConfiguration->tps2SecondaryMax, minTpsPps, maxTpsPps }
        );
 
        float ppsSecondaryMaximum = engineConfiguration->ppsSecondaryMaximum;
        if (ppsSecondaryMaximum < 20) {
            // don't allow <20% split point
            ppsSecondaryMaximum = 20;
        }
 
    // Pedal sensors
    pedal.init(isFordPps, &fordPps, ppsSecondaryMaximum,
        { engineConfiguration->throttlePedalPositionAdcChannel, engineConfiguration->throttlePedalUpVoltage, engineConfiguration->throttlePedalWOTVoltage, minTpsPps, maxTpsPps },
        { engineConfiguration->throttlePedalPositionSecondAdcChannel, engineConfiguration->throttlePedalSecondaryUpVoltage, engineConfiguration->throttlePedalSecondaryWOTVoltage, minTpsPps, maxTpsPps },
        engineConfiguration->allowIdenticalPps
    );
    ppsFilterSensor.setProxiedSensor(SensorType::AcceleratorPedalUnfiltered);
    ppsFilterSensor.setConverter([](SensorResult arg) {
      if (!arg) {
        return arg;
      }
      static ExpAverage ppsExpAverage;
      ppsExpAverage.setSmoothingFactor(engineConfiguration->ppsExpAverageAlpha);
      SensorResult result = ppsExpAverage.initOrAverage(arg.Value);
    return result;
  });
    ppsFilterSensor.Register();
 
        // TPS-like stuff that isn't actually a TPS
        wastegate.init({ engineConfiguration->wastegatePositionSensor, engineConfiguration->wastegatePositionClosedVoltage, engineConfiguration->wastegatePositionOpenedVoltage, minTpsPps, maxTpsPps });
        idlePos.init({ engineConfiguration->idlePositionChannel, (float)engineConfiguration->idlePositionMin, (float)engineConfiguration->idlePositionMax, minTpsPps, maxTpsPps });
    }
 
    // Route the pedal or TPS to driverIntent as appropriate
    if (isAdcChannelValid(engineConfiguration->throttlePedalPositionAdcChannel)) {
        driverIntent.setProxiedSensor(SensorType::AcceleratorPedal);
    } else {
        driverIntent.setProxiedSensor(SensorType::Tps1);
    }
 
    driverIntent.Register();
}

Referenced by sensorStartUpOrReconfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

initTurbochargerSpeedSensor()

void initTurbochargerSpeedSensor

(

)

Definition at line 15 of file init_turbocharger_speed_sensor.cpp.

                                   {
    // Filter parameter of 0.01 filters over roughly 100 teeth
    turbochargerSpeedSensor.initIfValid(engineConfiguration->turboSpeedSensorInputPin, turbochargerSpeedConverter, engineConfiguration->turbochargerFilter);
}

Referenced by sensorStartUpOrReconfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

initVbatt()

void initVbatt

(

)

Definition at line 11 of file init_vbatt.cpp.

                 {
  {
    static LinearFunc vbattFunc; // static with scoped visibility just to reduce change of code defect
      vbattFunc.configure(0, 0, 1, engineConfiguration->vbattDividerCoeff, 0, 50);
      vbattSensor.setFunction(vbattFunc);
    }
 
  if (engineConfiguration->ignKeyAdcDivider > 0) {
    static LinearFunc ignBattFunc; // static with scoped visibility just to reduce change of code defect
      ignBattFunc.configure(0, 0, 1, engineConfiguration->ignKeyAdcDivider, 0, 50);
      ignBattSensor.setFunction(ignBattFunc);
    }
 
    if (isAdcChannelValid(engineConfiguration->vbattAdcChannel)) {
      // adcVoltsPerVolt is set to 1.0 because vbatt doesn't go thru the analog input divider
      AdcSubscription::SubscribeSensor(vbattSensor, engineConfiguration->vbattAdcChannel, /* filter HZ = */ 20, /* adcVoltsPerVolt = */ 1.0f);
      vbattSensor.Register();
    }
 
    if (isAdcChannelValid(engineConfiguration->ignKeyAdcChannel)) {
      AdcSubscription::SubscribeSensor(ignBattSensor, engineConfiguration->ignKeyAdcChannel, /* filter HZ = */ 20, /* adcVoltsPerVolt = */ 1.0f);
      ignBattSensor.Register();
    }
}

Referenced by sensorStartUpOrReconfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

initVehicleSpeedSensor()

void initVehicleSpeedSensor

(

)

Definition at line 11 of file init_vehicle_speed_sensor.cpp.

                              {
    int parameter = engineConfiguration->vssFilterReciprocal;
 
    if (parameter < VSS_FILTER_MIN || parameter > VSS_FILTER_MAX) {
        parameter = VSS_FILTER_MIN;
    }
 
    float filterParameter = 1.0f / parameter;
 
    vehicleSpeedSensor.initIfValid(engineConfiguration->vehicleSpeedSensorInputPin, vehicleSpeedConverter, filterParameter);
}

Referenced by sensorStartUpOrReconfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

pokeAuxDigital()

void pokeAuxDigital

(

)

Definition at line 65 of file init_sensors.cpp.

                      {
#if EFI_PROD_CODE
    for (size_t i = 0;i<efi::size(engineConfiguration->luaDigitalInputPins);i++) {
      engine->luaDigitalInputState[i].state.update(getAuxDigital(i));
    }
#endif // EFI_PROD_CODE
}

Referenced by Engine::updateSwitchInputs().

Here is the call graph for this function:

Here is the caller graph for this function:

reconfigureSensors()

void reconfigureSensors

(

)

Definition at line 168 of file init_sensors.cpp.

                          {
    sensorStartUpOrReconfiguration(false);
    startEgt();
 
    initOldAnalogInputs();
}

Referenced by applyNewHardwareSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

sentPressureDecode()

void sentPressureDecode

(

SentInput

sentCh

)

Definition at line 130 of file init_fluid_pressure.cpp.

                                          {
    if (engineConfiguration->FuelHighPressureSentInput != sentCh) {
        return;
    }
 
    if (engineConfiguration->FuelHighPressureSentType == SentFuelHighPressureType::GM_TYPE) {
        uint16_t sig0, sig1;
        int ret = getSentValues(sentCh, &sig0, &sig1);
 
        if (ret) {
            return;
        }
 
        /* This sensor sends two pressure signals - average */
        fuelPressureSensorHigh.postRawValue(((float)sig0 + (float)sig1) / 2, getTimeNowNt());
    }
}

Referenced by SentDecoderThread().

Here is the call graph for this function:

Here is the caller graph for this function:

startEgt()

void startEgt

(

)

Definition at line 47 of file init_egt.cpp.

                {
    /* TODO: also start CAN sensors */
#if EFI_MAX_31855
    startMax3185x(engineConfiguration->max31855spiDevice, engineConfiguration->max31855_cs);
#else
  criticalAssertVoid(SPI_NONE == engineConfiguration->max31855spiDevice, "not EFI_MAX_31855");
#endif /* EFI_MAX_31855 */
}

Referenced by reconfigureSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

stopEgt()

void stopEgt

(

)

Definition at line 40 of file init_egt.cpp.

               {
    /* TODO: also stop CAN sensors */
#if EFI_MAX_31855
    stopMax3185x();
#endif /* EFI_MAX_31855 */
}

Referenced by stopSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

stopSensors()

void stopSensors

(

)

Definition at line 150 of file init_sensors.cpp.

                   {
    deInitAuxDigital();
    deInitOldAnalogInputs();
 
    deinitVbatt();
    deinitTps();
    deinitFluidPressure();
    deinitThermistors();
    deInitFlexSensor();
    deinitAuxSensors();
    deInitVehicleSpeedSensor();
    deinitTurbochargerSpeedSensor();
    deinitAuxSpeedSensors();
    deinitMap();
    deinitInputShaftSpeedSensor();
    stopEgt();
}

Referenced by applyNewHardwareSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

Go to the source code of this file.