#include <boost_control.h>

Inheritance diagram for BoostController:

[legend]

Collaboration diagram for BoostController:

[legend]

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

scaled_channel< int16_t, 10, 1 >	openLoopYAxis = (int16_t)0

uint8_t	alignmentFill_at_22 [2] = {}

float	luaOpenLoopAdd = (float)0

scaled_channel< int8_t, 2, 1 >	boostControllerClosedLoopPart = (int8_t)0

uint8_t	alignmentFill_at_29 [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 196 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 212 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 225 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 240 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 166 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 123 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);
    openLoopYAxis = 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 79 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 29 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 69 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 59 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 276 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 53 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 390 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 254 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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ getBoostControlDutyCycleWithTemperatureCorrections()

◆ getBoostControlTargetTemperatureAdder()

◆ getBoostTemperatureCorrection()

◆ getClosedLoop()

◆ getClosedLoopImpl()

◆ getOpenLoop()

◆ getSetpoint()

◆ init()

◆ observePlant()

◆ onConfigurationChange()

◆ onFastCallback()

◆ resetLua()

◆ setDefaultConfiguration()

◆ setOutput()

Field Documentation

◆ m_closedLoopTargetMap

◆ m_cltBoostAdderMap

◆ m_cltBoostCorrMap

◆ m_iatBoostAdderMap

◆ m_iatBoostCorrMap

◆ m_openLoopMap

◆ m_pid

◆ m_pwm