BoostController Class Reference

#include <boost_control.h>

Inheritance diagram for BoostController:

Collaboration diagram for BoostController:

Public Member Functions
void	init (IPwm *const pmw, const ValueProvider3D *const openLoopMap, const ValueProvider3D *const closedLoopTargetMap, const ValueProvider2D &cltMultiplierProvider, const ValueProvider2D &iatMultiplierProvider, const ValueProvider2D &cltAdderProvider, const ValueProvider2D &iatAdderProvider, pid_s *const pidParams)
void	onFastCallback () override
void	setDefaultConfiguration () override
void	resetLua ()
void	onConfigurationChange (engine_configuration_s const *previousConfig) override
expected< float >	observePlant () override
expected< float >	getSetpoint () override
expected< percent_t >	getOpenLoop (float target) override
expected< percent_t >	getClosedLoop (float target, float manifoldPressure) override
void	setOutput (expected< percent_t > outputValue) override
Public Member Functions inherited from EngineModule
virtual void	initNoConfiguration ()
virtual void	onSlowCallback ()
virtual void	onEngineStop ()
virtual void	onIgnitionStateChanged (bool)
virtual bool	needsDelayedShutoff ()
virtual void	onEnginePhase (float, efitick_t, angle_t, angle_t)
Public Member Functions inherited from ClosedLoopController< float, percent_t >
void	update ()

Private Member Functions
percent_t	getClosedLoopImpl (float target, float manifoldPressure)
float	getBoostControlDutyCycleWithTemperatureCorrections (const float rpm, const float driverIntent) const
std::optional< float >	getBoostControlTargetTemperatureAdder () const
std::optional< float >	getBoostTemperatureCorrection (const SensorType sensorType, const ValueProvider2D &correctionCurve) const

Private Attributes
Pid	m_pid
const ValueProvider3D *	m_openLoopMap = nullptr
const ValueProvider3D *	m_closedLoopTargetMap = nullptr
const ValueProvider2D *	m_cltBoostCorrMap = nullptr
const ValueProvider2D *	m_iatBoostCorrMap = nullptr
const ValueProvider2D *	m_cltBoostAdderMap = nullptr
const ValueProvider2D *	m_iatBoostAdderMap = nullptr
IPwm *	m_pwm = nullptr

Additional Inherited Members
Data Fields inherited from boost_control_s
bool	isTpsInvalid: 1 {}
bool	m_shouldResetPid: 1 {}
bool	isBelowClosedLoopThreshold: 1 {}
bool	isNotClosedLoop: 1 {}
bool	isZeroRpm: 1 {}
bool	hasInitBoost: 1 {}
bool	rpmTooLow: 1 {}
bool	tpsTooLow: 1 {}
bool	mapTooLow: 1 {}
bool	isPlantValid: 1 {}
bool	isBoostControlled: 1 {}
bool	unusedBit_11_11: 1 {}
bool	unusedBit_11_12: 1 {}
bool	unusedBit_11_13: 1 {}
bool	unusedBit_11_14: 1 {}
bool	unusedBit_11_15: 1 {}
bool	unusedBit_11_16: 1 {}
bool	unusedBit_11_17: 1 {}
bool	unusedBit_11_18: 1 {}
bool	unusedBit_11_19: 1 {}
bool	unusedBit_11_20: 1 {}
bool	unusedBit_11_21: 1 {}
bool	unusedBit_11_22: 1 {}
bool	unusedBit_11_23: 1 {}
bool	unusedBit_11_24: 1 {}
bool	unusedBit_11_25: 1 {}
bool	unusedBit_11_26: 1 {}
bool	unusedBit_11_27: 1 {}
bool	unusedBit_11_28: 1 {}
bool	unusedBit_11_29: 1 {}
bool	unusedBit_11_30: 1 {}
bool	unusedBit_11_31: 1 {}
scaled_channel< int16_t, 2, 1 >	luaTargetAdd = (int16_t)0
uint8_t	alignmentFill_at_6 [2] = {}
float	luaTargetMult = (float)0
scaled_channel< int16_t, 30, 1 >	boostControlTarget = (int16_t)0
uint8_t	alignmentFill_at_14 [2] = {}
float	openLoopPart = (float)0
float	luaOpenLoopAdd = (float)0
scaled_channel< int8_t, 2, 1 >	boostControllerClosedLoopPart = (int8_t)0
uint8_t	alignmentFill_at_25 [1] = {}
scaled_channel< int16_t, 100, 1 >	boostOutput = (int16_t)0

Detailed Description

Definition at line 17 of file boost_control.h.

Member Function Documentation

getBoostControlDutyCycleWithTemperatureCorrections()

float BoostController::getBoostControlDutyCycleWithTemperatureCorrections ( const float  rpm, const float  driverIntent  ) const

private

Definition at line 197 of file boost_control.cpp.

        {
    float result = m_openLoopMap->getValue(rpm, driverIntent);
    std::optional<float> cltBoostMultiplier = getBoostTemperatureCorrection(SensorType::Clt, *m_cltBoostCorrMap);
    if (cltBoostMultiplier.has_value()) {
        result *= cltBoostMultiplier.value();
    }
    std::optional<float> iatBoostMultiplier = getBoostTemperatureCorrection(SensorType::Iat, *m_iatBoostCorrMap);
    if (iatBoostMultiplier.has_value()) {
        result *= iatBoostMultiplier.value();
    }
    return result;
}

Referenced by getOpenLoop().

Here is the call graph for this function:

Here is the caller graph for this function:

getBoostControlTargetTemperatureAdder()

std::optional< float > BoostController::getBoostControlTargetTemperatureAdder ( ) const

private

Definition at line 213 of file boost_control.cpp.

                                                                                {
    std::optional<float> result = getBoostTemperatureCorrection(SensorType::Clt, *m_cltBoostAdderMap);
    const std::optional<float> iatBoostAdder = getBoostTemperatureCorrection(SensorType::Iat, *m_iatBoostAdderMap);
    if (iatBoostAdder.has_value()) {
        if (result.has_value()) {
            result.value() += iatBoostAdder.value();
        } else {
            result = iatBoostAdder;
        }
    }
    return result;
}

Referenced by getSetpoint().

Here is the call graph for this function:

Here is the caller graph for this function:

getBoostTemperatureCorrection()

std::optional< float > BoostController::getBoostTemperatureCorrection ( const SensorType  sensorType, const ValueProvider2D &  correctionCurve  ) const

private

Definition at line 226 of file boost_control.cpp.

        {
    const SensorResult temperature = Sensor::get(sensorType);
    if (temperature.Valid) {
        const std::optional<float> boostCorrection = correctionCurve.getValue(temperature.Value);
        if (boostCorrection.has_value()) {
            return std::make_optional<float>(boostCorrection.value());
        }
    }
    return {};
}

Referenced by getBoostControlDutyCycleWithTemperatureCorrections(), and getBoostControlTargetTemperatureAdder().

Here is the call graph for this function:

Here is the caller graph for this function:

getClosedLoop()

expected< percent_t > BoostController::getClosedLoop ( float  target, float  manifoldPressure  )

overridevirtual

Implements ClosedLoopController< float, percent_t >.

Definition at line 241 of file boost_control.cpp.

                                                                                       {
    boostControllerClosedLoopPart = getClosedLoopImpl(target, manifoldPressure);
 
    m_pid.postState(engine->outputChannels.boostStatus);
 
    boostControlTarget = target;
 
    return (float)boostControllerClosedLoopPart;
}

Here is the call graph for this function:

getClosedLoopImpl()

percent_t BoostController::getClosedLoopImpl ( float  target, float  manifoldPressure  )

private

Definition at line 167 of file boost_control.cpp.

                                                                                 {
    // If we're in open loop only mode, make no closed loop correction.
    isNotClosedLoop = engineConfiguration->boostType != CLOSED_LOOP;
    if (isNotClosedLoop) {
        return 0;
    }
 
    // Reset PID if requested
    if (m_shouldResetPid) {
        m_pid.reset();
        m_shouldResetPid = false;
    }
 
    // If the engine isn't running, don't correct.
    isZeroRpm = Sensor::getOrZero(SensorType::Rpm) == 0;
    if (isZeroRpm) {
        m_pid.reset();
        return 0;
    }
 
    isBelowClosedLoopThreshold = manifoldPressure < engineConfiguration->minimumBoostClosedLoopMap;
    if (isBelowClosedLoopThreshold) {
        // We're below the CL threshold, inhibit CL for now
        m_pid.reset();
        return 0;
    }
 
    return m_pid.getOutput(target, manifoldPressure, FAST_CALLBACK_PERIOD_MS / 1000.0f);
}

Referenced by getClosedLoop().

Here is the call graph for this function:

Here is the caller graph for this function:

getOpenLoop()

expected< percent_t > BoostController::getOpenLoop ( float  target )

overridevirtual

Implements ClosedLoopController< float, percent_t >.

Definition at line 125 of file boost_control.cpp.

                                                             {
    // Boost control open loop doesn't care about target - only TPS/RPM
    UNUSED(target);
 
    float rpm = Sensor::getOrZero(SensorType::Rpm);
    auto driverIntent = readGppwmChannel(engineConfiguration->boostOpenLoopYAxis);
 
    isTpsInvalid = !driverIntent.Valid;
 
    if (isTpsInvalid) {
        return unexpected;
    }
 
    efiAssert(ObdCode::OBD_PCM_Processor_Fault, m_openLoopMap != nullptr, "boost open loop", unexpected);
    efiAssert(ObdCode::OBD_PCM_Processor_Fault, m_cltBoostCorrMap != nullptr, "boost CLT multiplier", unexpected);
    efiAssert(ObdCode::OBD_PCM_Processor_Fault, m_iatBoostCorrMap != nullptr, "boost IAT multiplier", unexpected);
 
    percent_t openLoop = luaOpenLoopAdd + getBoostControlDutyCycleWithTemperatureCorrections(rpm, driverIntent.Value);
 
#if EFI_ENGINE_CONTROL
    // Add any blends if configured
    for (size_t i = 0; i < efi::size(config->boostOpenLoopBlends); i++) {
        auto result = calculateBlend(config->boostOpenLoopBlends[i], rpm, driverIntent.Value);
 
        engine->outputChannels.boostOpenLoopBlendParameter[i] = result.BlendParameter;
        engine->outputChannels.boostOpenLoopBlendBias[i] = result.Bias;
        engine->outputChannels.boostOpenLoopBlendOutput[i] = result.Value;
        engine->outputChannels.boostOpenLoopBlendYAxis[i] = result.TableYAxis;
 
        openLoop += result.Value;
    }
#endif // EFI_ENGINE_CONTROL
 
    // Add gear-based adder
    auto gear = Sensor::getOrZero(SensorType::DetectedGear);
    float gearAdder = engineConfiguration->gearBasedOpenLoopBoostAdder[static_cast<int>(gear) + 1];
    openLoop += gearAdder;
 
    openLoopPart = openLoop;
    return openLoop;
}

Here is the call graph for this function:

getSetpoint()

expected< float > BoostController::getSetpoint ( )

overridevirtual

Implements ClosedLoopController< float, percent_t >.

Definition at line 81 of file boost_control.cpp.

                                             {
    // If we're in open loop only mode, disregard any target computation.
    // Open loop needs to work even in case of invalid closed loop config
    isNotClosedLoop = engineConfiguration->boostType != CLOSED_LOOP;
    if (isNotClosedLoop) {
        boostControllerClosedLoopPart = 0;
        return (float)boostControllerClosedLoopPart;
    }
 
    float rpm = Sensor::getOrZero(SensorType::Rpm);
 
    auto driverIntent = Sensor::get(SensorType::DriverThrottleIntent);
    isTpsInvalid = !driverIntent.Valid;
 
    if (isTpsInvalid) {
        return unexpected;
    }
 
    efiAssert(ObdCode::OBD_PCM_Processor_Fault, m_closedLoopTargetMap != nullptr, "boost closed loop target", unexpected);
 
    float target = m_closedLoopTargetMap->getValue(rpm, driverIntent.Value);
#if EFI_ENGINE_CONTROL
    // Add any blends if configured
    for (size_t i = 0; i < efi::size(config->boostClosedLoopBlends); i++) {
        auto result = calculateBlend(config->boostClosedLoopBlends[i], rpm, driverIntent.Value);
 
        engine->outputChannels.boostClosedLoopBlendParameter[i] = result.BlendParameter;
        engine->outputChannels.boostClosedLoopBlendBias[i] = result.Bias;
        engine->outputChannels.boostClosedLoopBlendOutput[i] = result.Value;
        engine->outputChannels.boostClosedLoopBlendYAxis[i] = result.TableYAxis;
 
        target += result.Value;
    }
#endif //EFI_ENGINE_CONTROL
 
    target *= luaTargetMult;
    target += luaTargetAdd;
    const std::optional<float> temperatureAdder = getBoostControlTargetTemperatureAdder();
    if (temperatureAdder.has_value()) {
        target += temperatureAdder.value();
    }
    return target;
}

Here is the call graph for this function:

init()

void BoostController::init	(	IPwm *const	pmw,
		const ValueProvider3D *const	openLoopMap,
		const ValueProvider3D *const	closedLoopTargetMap,
		const ValueProvider2D &	cltMultiplierProvider,
		const ValueProvider2D &	iatMultiplierProvider,
		const ValueProvider2D &	cltAdderProvider,
		const ValueProvider2D &	iatAdderProvider,
		pid_s *const	pidParams
	)

Definition at line 31 of file boost_control.cpp.

  {
    m_pwm = pwm;
    m_openLoopMap = openLoopMap;
    m_closedLoopTargetMap = closedLoopTargetMap;
    m_cltBoostCorrMap = &cltMultiplierProvider;
    m_iatBoostCorrMap = &iatMultiplierProvider;
    m_cltBoostAdderMap = &cltAdderProvider;
    m_iatBoostAdderMap = &iatAdderProvider;
 
    m_pid.initPidClass(pidParams);
    resetLua();
 
    hasInitBoost = true;
}

Referenced by initBoostCtrl().

Here is the call graph for this function:

Here is the caller graph for this function:

observePlant()

expected< float > BoostController::observePlant ( )

overridevirtual

Implements ClosedLoopController< float, percent_t >.

Definition at line 71 of file boost_control.cpp.

                                              {
    expected<float> map = Sensor::get(SensorType::Map);
    if (!map.Valid && engineConfiguration->boostType != CLOSED_LOOP) {
        // if we're in open loop only let's somewhat operate even without valid Map sensor
        map = 0;
    }
    isPlantValid = map.Valid;
    return map;
}

Here is the call graph for this function:

onConfigurationChange()

void BoostController::onConfigurationChange ( engine_configuration_s const *  previousConfig )

overridevirtual

Reimplemented from EngineModule.

Definition at line 61 of file boost_control.cpp.

                                                                                         {
#if EFI_PROD_CODE
  initBoostCtrl();
#endif
 
    if (!previousConfig || !m_pid.isSame(&previousConfig->boostPid)) {
        m_shouldResetPid = true;
    }
}

Here is the call graph for this function:

onFastCallback()

void BoostController::onFastCallback ( )

overridevirtual

Reimplemented from EngineModule.

Definition at line 277 of file boost_control.cpp.

                                     {
    if (!hasInitBoost) {
        return;
    }
 
    m_pid.iTermMin = -20;
    m_pid.iTermMax = 20;
 
    rpmTooLow = Sensor::getOrZero(SensorType::Rpm) < engineConfiguration->boostControlMinRpm;
    tpsTooLow = Sensor::getOrZero(SensorType::Tps1) < engineConfiguration->boostControlMinTps;
    mapTooLow = Sensor::getOrZero(SensorType::Map) < engineConfiguration->boostControlMinMap;
 
  isBoostControlled = !(rpmTooLow || tpsTooLow || mapTooLow);
 
    if (!isBoostControlled) {
        // Passing unexpected will use the safe duty cycle configured by the user
        setOutput(unexpected);
    } else {
        ClosedLoopController::update();
    }
}

Here is the call graph for this function:

resetLua()

void BoostController::resetLua

(

)

Definition at line 55 of file boost_control.cpp.

                               {
    luaTargetAdd = 0;
    luaTargetMult = 1;
    luaOpenLoopAdd = 0;
}

Referenced by init().

Here is the caller graph for this function:

setDefaultConfiguration()

void BoostController::setDefaultConfiguration ( )

overridevirtual

Reimplemented from EngineModule.

Definition at line 391 of file boost_control.cpp.

                                             {
    engineConfiguration->boostCutPressure = 300;
    engineConfiguration->boostCutPressureHyst = 20;
    engineConfiguration->boostControlMinRpm = 2000;
    engineConfiguration->boostControlMinTps = 30;
    engineConfiguration->boostControlMinMap = 110;
}

setOutput()

void BoostController::setOutput ( expected< percent_t >  outputValue )

overridevirtual

Implements ClosedLoopController< float, percent_t >.

Definition at line 255 of file boost_control.cpp.

                                                      {
    // this clamping is just for happier gauge #6339
    boostOutput = clampPercentValue(output.value_or(engineConfiguration->boostControlSafeDutyCycle));
 
    if (!engineConfiguration->isBoostControlEnabled) {
        // If not enabled, force 0% output
        boostOutput = 0;
    }
 
    float duty = PERCENT_TO_DUTY(boostOutput);
 
    if (m_pwm && isBoostControlSolenoidMode()) {
        m_pwm->setSimplePwmDutyCycle(duty);
    } else {
#if EFI_ELECTRONIC_THROTTLE_BODY
    // inject wastegate position into DC controllers, pretty weird workflow to be honest
    // todo: should it be DC controller pulling?
    setEtbWastegatePosition(boostOutput);
#endif // EFI_ELECTRONIC_THROTTLE_BODY
    }
}

Referenced by onFastCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

m_closedLoopTargetMap

const ValueProvider3D* BoostController::m_closedLoopTargetMap = nullptr

private

Definition at line 60 of file boost_control.h.

Referenced by getSetpoint(), and init().

m_cltBoostAdderMap

const ValueProvider2D* BoostController::m_cltBoostAdderMap = nullptr

private

Definition at line 63 of file boost_control.h.

Referenced by getBoostControlTargetTemperatureAdder(), and init().

m_cltBoostCorrMap

const ValueProvider2D* BoostController::m_cltBoostCorrMap = nullptr

private

Definition at line 61 of file boost_control.h.

Referenced by getBoostControlDutyCycleWithTemperatureCorrections(), getOpenLoop(), and init().

m_iatBoostAdderMap

const ValueProvider2D* BoostController::m_iatBoostAdderMap = nullptr

private

Definition at line 64 of file boost_control.h.

Referenced by getBoostControlTargetTemperatureAdder(), and init().

m_iatBoostCorrMap

const ValueProvider2D* BoostController::m_iatBoostCorrMap = nullptr

private

Definition at line 62 of file boost_control.h.

Referenced by getBoostControlDutyCycleWithTemperatureCorrections(), getOpenLoop(), and init().

m_openLoopMap

const ValueProvider3D* BoostController::m_openLoopMap = nullptr

private

Definition at line 59 of file boost_control.h.

Referenced by getBoostControlDutyCycleWithTemperatureCorrections(), getOpenLoop(), and init().

m_pid

Pid BoostController::m_pid

private

Definition at line 57 of file boost_control.h.

Referenced by getClosedLoop(), getClosedLoopImpl(), init(), onConfigurationChange(), and onFastCallback().

m_pwm

IPwm* BoostController::m_pwm = nullptr

private

Definition at line 65 of file boost_control.h.

Referenced by init(), and setOutput().

---

The documentation for this class was generated from the following files:

• controllers/actuators/boost_control.h
• controllers/actuators/boost_control.cpp